[linux-2.6-block.git] / arch / arm / include / asm / mcpm.h

/*
 * arch/arm/include/asm/mcpm.h
 *
 * Created by:  Nicolas Pitre, April 2012
 * Copyright:   (C) 2012-2013  Linaro Limited
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#ifndef MCPM_H
#define MCPM_H

/*
 * Maximum number of possible clusters / CPUs per cluster.
 *
 * This should be sufficient for quite a while, while keeping the
 * (assembly) code simpler.  When this starts to grow then we'll have
 * to consider dynamic allocation.
 */
#define MAX_CPUS_PER_CLUSTER	4
#define MAX_NR_CLUSTERS		2

#ifndef __ASSEMBLY__

#include <linux/types.h>
#include <asm/cacheflush.h>

/*
 * Platform specific code should use this symbol to set up secondary
 * entry location for processors to use when released from reset.
 */
extern void mcpm_entry_point(void);

/*
 * This is used to indicate where the given CPU from given cluster should
 * branch once it is ready to re-enter the kernel using ptr, or NULL if it
 * should be gated.  A gated CPU is held in a WFE loop until its vector
 * becomes non NULL.
 */
void mcpm_set_entry_vector(unsigned cpu, unsigned cluster, void *ptr);

/*
 * This sets an early poke i.e a value to be poked into some address
 * from very early assembly code before the CPU is ungated.  The
 * address must be physical, and if 0 then nothing will happen.
 */
void mcpm_set_early_poke(unsigned cpu, unsigned cluster,
			 unsigned long poke_phys_addr, unsigned long poke_val);

/*
 * CPU/cluster power operations API for higher subsystems to use.
 */

/**
 * mcpm_is_available - returns whether MCPM is initialized and available
 *
 * This returns true or false accordingly.
 */
bool mcpm_is_available(void);

/**
 * mcpm_cpu_power_up - make given CPU in given cluster runable
 *
 * @cpu: CPU number within given cluster
 * @cluster: cluster number for the CPU
 *
 * The identified CPU is brought out of reset.  If the cluster was powered
 * down then it is brought up as well, taking care not to let the other CPUs
 * in the cluster run, and ensuring appropriate cluster setup.
 *
 * Caller must ensure the appropriate entry vector is initialized with
 * mcpm_set_entry_vector() prior to calling this.
 *
 * This must be called in a sleepable context.  However, the implementation
 * is strongly encouraged to return early and let the operation happen
 * asynchronously, especially when significant delays are expected.
 *
 * If the operation cannot be performed then an error code is returned.
 */
int mcpm_cpu_power_up(unsigned int cpu, unsigned int cluster);

/**
 * mcpm_cpu_power_down - power the calling CPU down
 *
 * The calling CPU is powered down.
 *
 * If this CPU is found to be the "last man standing" in the cluster
 * then the cluster is prepared for power-down too.
 *
 * This must be called with interrupts disabled.
 *
 * On success this does not return.  Re-entry in the kernel is expected
 * via mcpm_entry_point.
 *
 * This will return if mcpm_platform_register() has not been called
 * previously in which case the caller should take appropriate action.
 *
 * On success, the CPU is not guaranteed to be truly halted until
 * mcpm_cpu_power_down_finish() subsequently returns non-zero for the
 * specified cpu.  Until then, other CPUs should make sure they do not
 * trash memory the target CPU might be executing/accessing.
 */
void mcpm_cpu_power_down(void);

/**
 * mcpm_cpu_power_down_finish - wait for a specified CPU to halt, and
 *	make sure it is powered off
 *
 * @cpu: CPU number within given cluster
 * @cluster: cluster number for the CPU
 *
 * Call this function to ensure that a pending powerdown has taken
 * effect and the CPU is safely parked before performing non-mcpm
 * operations that may affect the CPU (such as kexec trashing the
 * kernel text).
 *
 * It is *not* necessary to call this function if you only need to
 * serialise a pending powerdown with mcpm_cpu_power_up() or a wakeup
 * event.
 *
 * Do not call this function unless the specified CPU has already
 * called mcpm_cpu_power_down() or has committed to doing so.
 *
 * @return:
 *	- zero if the CPU is in a safely parked state
 *	- nonzero otherwise (e.g., timeout)
 */
int mcpm_cpu_power_down_finish(unsigned int cpu, unsigned int cluster);

/**
 * mcpm_cpu_suspend - bring the calling CPU in a suspended state
 *
 * @expected_residency: duration in microseconds the CPU is expected
 *			to remain suspended, or 0 if unknown/infinity.
 *
 * The calling CPU is suspended.  The expected residency argument is used
 * as a hint by the platform specific backend to implement the appropriate
 * sleep state level according to the knowledge it has on wake-up latency
 * for the given hardware.
 *
 * If this CPU is found to be the "last man standing" in the cluster
 * then the cluster may be prepared for power-down too, if the expected
 * residency makes it worthwhile.
 *
 * This must be called with interrupts disabled.
 *
 * On success this does not return.  Re-entry in the kernel is expected
 * via mcpm_entry_point.
 *
 * This will return if mcpm_platform_register() has not been called
 * previously in which case the caller should take appropriate action.
 */
void mcpm_cpu_suspend(u64 expected_residency);

/**
 * mcpm_cpu_powered_up - housekeeping workafter a CPU has been powered up
 *
 * This lets the platform specific backend code perform needed housekeeping
 * work.  This must be called by the newly activated CPU as soon as it is
 * fully operational in kernel space, before it enables interrupts.
 *
 * If the operation cannot be performed then an error code is returned.
 */
int mcpm_cpu_powered_up(void);

/*
 * Platform specific methods used in the implementation of the above API.
 */
struct mcpm_platform_ops {
	int (*power_up)(unsigned int cpu, unsigned int cluster);
	void (*power_down)(void);
	int (*power_down_finish)(unsigned int cpu, unsigned int cluster);
	void (*suspend)(u64);
	void (*powered_up)(void);
};

/**
 * mcpm_platform_register - register platform specific power methods
 *
 * @ops: mcpm_platform_ops structure to register
 *
 * An error is returned if the registration has been done previously.
 */
int __init mcpm_platform_register(const struct mcpm_platform_ops *ops);

/* Synchronisation structures for coordinating safe cluster setup/teardown: */

/*
 * When modifying this structure, make sure you update the MCPM_SYNC_ defines
 * to match.
 */
struct mcpm_sync_struct {
	/* individual CPU states */
	struct {
		s8 cpu __aligned(__CACHE_WRITEBACK_GRANULE);
	} cpus[MAX_CPUS_PER_CLUSTER];

	/* cluster state */
	s8 cluster __aligned(__CACHE_WRITEBACK_GRANULE);

	/* inbound-side state */
	s8 inbound __aligned(__CACHE_WRITEBACK_GRANULE);
};

struct sync_struct {
	struct mcpm_sync_struct clusters[MAX_NR_CLUSTERS];
};

extern unsigned long sync_phys;	/* physical address of *mcpm_sync */

void __mcpm_cpu_going_down(unsigned int cpu, unsigned int cluster);
void __mcpm_cpu_down(unsigned int cpu, unsigned int cluster);
void __mcpm_outbound_leave_critical(unsigned int cluster, int state);
bool __mcpm_outbound_enter_critical(unsigned int this_cpu, unsigned int cluster);
int __mcpm_cluster_state(unsigned int cluster);

int __init mcpm_sync_init(
	void (*power_up_setup)(unsigned int affinity_level));

void __init mcpm_smp_set_ops(void);

#else

/* 
 * asm-offsets.h causes trouble when included in .c files, and cacheflush.h
 * cannot be included in asm files.  Let's work around the conflict like this.
 */
#include <asm/asm-offsets.h>
#define __CACHE_WRITEBACK_GRANULE CACHE_WRITEBACK_GRANULE

#endif /* ! __ASSEMBLY__ */

/* Definitions for mcpm_sync_struct */
#define CPU_DOWN		0x11
#define CPU_COMING_UP		0x12
#define CPU_UP			0x13
#define CPU_GOING_DOWN		0x14

#define CLUSTER_DOWN		0x21
#define CLUSTER_UP		0x22
#define CLUSTER_GOING_DOWN	0x23

#define INBOUND_NOT_COMING_UP	0x31
#define INBOUND_COMING_UP	0x32

/*
 * Offsets for the mcpm_sync_struct members, for use in asm.
 * We don't want to make them global to the kernel via asm-offsets.c.
 */
#define MCPM_SYNC_CLUSTER_CPUS	0
#define MCPM_SYNC_CPU_SIZE	__CACHE_WRITEBACK_GRANULE
#define MCPM_SYNC_CLUSTER_CLUSTER \
	(MCPM_SYNC_CLUSTER_CPUS + MCPM_SYNC_CPU_SIZE * MAX_CPUS_PER_CLUSTER)
#define MCPM_SYNC_CLUSTER_INBOUND \
	(MCPM_SYNC_CLUSTER_CLUSTER + __CACHE_WRITEBACK_GRANULE)
#define MCPM_SYNC_CLUSTER_SIZE \
	(MCPM_SYNC_CLUSTER_INBOUND + __CACHE_WRITEBACK_GRANULE)

#endif
Commit	Line	Data
e8db288e NP	1	/*
	2	* arch/arm/include/asm/mcpm.h
	3	*
	4	* Created by: Nicolas Pitre, April 2012
	5	* Copyright: (C) 2012-2013 Linaro Limited
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	#ifndef MCPM_H
	13	#define MCPM_H
	14
	15	/*
	16	* Maximum number of possible clusters / CPUs per cluster.
	17	*
	18	* This should be sufficient for quite a while, while keeping the
	19	* (assembly) code simpler. When this starts to grow then we'll have
	20	* to consider dynamic allocation.
	21	*/
	22	#define MAX_CPUS_PER_CLUSTER 4
	23	#define MAX_NR_CLUSTERS 2
	24
	25	#ifndef __ASSEMBLY__
	26
7fe31d28 DM	27	#include <linux/types.h>
	28	#include <asm/cacheflush.h>
	29
e8db288e NP	30	/*
	31	* Platform specific code should use this symbol to set up secondary
	32	* entry location for processors to use when released from reset.
	33	*/
	34	extern void mcpm_entry_point(void);
	35
	36	/*
	37	* This is used to indicate where the given CPU from given cluster should
	38	* branch once it is ready to re-enter the kernel using ptr, or NULL if it
	39	* should be gated. A gated CPU is held in a WFE loop until its vector
	40	* becomes non NULL.
	41	*/
	42	void mcpm_set_entry_vector(unsigned cpu, unsigned cluster, void *ptr);
	43
de885d14 NP	44	/*
	45	* This sets an early poke i.e a value to be poked into some address
	46	* from very early assembly code before the CPU is ungated. The
	47	* address must be physical, and if 0 then nothing will happen.
	48	*/
	49	void mcpm_set_early_poke(unsigned cpu, unsigned cluster,
	50	unsigned long poke_phys_addr, unsigned long poke_val);
	51
7c2b8605 NP	52	/*
	53	* CPU/cluster power operations API for higher subsystems to use.
	54	*/
	55
4530e4b6 NP	56	/**
	57	* mcpm_is_available - returns whether MCPM is initialized and available
	58	*
	59	* This returns true or false accordingly.
	60	*/
	61	bool mcpm_is_available(void);
	62
7c2b8605 NP	63	/**
	64	* mcpm_cpu_power_up - make given CPU in given cluster runable
	65	*
	66	* @cpu: CPU number within given cluster
	67	* @cluster: cluster number for the CPU
	68	*
	69	* The identified CPU is brought out of reset. If the cluster was powered
	70	* down then it is brought up as well, taking care not to let the other CPUs
	71	* in the cluster run, and ensuring appropriate cluster setup.
	72	*
	73	* Caller must ensure the appropriate entry vector is initialized with
	74	* mcpm_set_entry_vector() prior to calling this.
	75	*
	76	* This must be called in a sleepable context. However, the implementation
	77	* is strongly encouraged to return early and let the operation happen
	78	* asynchronously, especially when significant delays are expected.
	79	*
	80	* If the operation cannot be performed then an error code is returned.
	81	*/
	82	int mcpm_cpu_power_up(unsigned int cpu, unsigned int cluster);
	83
	84	/**
	85	* mcpm_cpu_power_down - power the calling CPU down
	86	*
	87	* The calling CPU is powered down.
	88	*
	89	* If this CPU is found to be the "last man standing" in the cluster
	90	* then the cluster is prepared for power-down too.
	91	*
	92	* This must be called with interrupts disabled.
	93	*
d0cdef6e NP	94	* On success this does not return. Re-entry in the kernel is expected
	95	* via mcpm_entry_point.
	96	*
	97	* This will return if mcpm_platform_register() has not been called
	98	* previously in which case the caller should take appropriate action.
0de0d646 DM	99	*
	100	* On success, the CPU is not guaranteed to be truly halted until
	101	* mcpm_cpu_power_down_finish() subsequently returns non-zero for the
	102	* specified cpu. Until then, other CPUs should make sure they do not
	103	* trash memory the target CPU might be executing/accessing.
7c2b8605 NP	104	*/
	105	void mcpm_cpu_power_down(void);
	106
0de0d646 DM	107	/**
	108	* mcpm_cpu_power_down_finish - wait for a specified CPU to halt, and
	109	* make sure it is powered off
	110	*
	111	* @cpu: CPU number within given cluster
	112	* @cluster: cluster number for the CPU
	113	*
	114	* Call this function to ensure that a pending powerdown has taken
	115	* effect and the CPU is safely parked before performing non-mcpm
	116	* operations that may affect the CPU (such as kexec trashing the
	117	* kernel text).
	118	*
	119	* It is not necessary to call this function if you only need to
	120	* serialise a pending powerdown with mcpm_cpu_power_up() or a wakeup
	121	* event.
	122	*
	123	* Do not call this function unless the specified CPU has already
	124	* called mcpm_cpu_power_down() or has committed to doing so.
	125	*
	126	* @return:
	127	* - zero if the CPU is in a safely parked state
	128	* - nonzero otherwise (e.g., timeout)
	129	*/
	130	int mcpm_cpu_power_down_finish(unsigned int cpu, unsigned int cluster);
	131
7c2b8605 NP	132	/**
	133	* mcpm_cpu_suspend - bring the calling CPU in a suspended state
	134	*
	135	* @expected_residency: duration in microseconds the CPU is expected
	136	* to remain suspended, or 0 if unknown/infinity.
	137	*
	138	* The calling CPU is suspended. The expected residency argument is used
	139	* as a hint by the platform specific backend to implement the appropriate
	140	* sleep state level according to the knowledge it has on wake-up latency
	141	* for the given hardware.
	142	*
	143	* If this CPU is found to be the "last man standing" in the cluster
	144	* then the cluster may be prepared for power-down too, if the expected
	145	* residency makes it worthwhile.
	146	*
	147	* This must be called with interrupts disabled.
	148	*
d0cdef6e NP	149	* On success this does not return. Re-entry in the kernel is expected
	150	* via mcpm_entry_point.
	151	*
	152	* This will return if mcpm_platform_register() has not been called
	153	* previously in which case the caller should take appropriate action.
7c2b8605 NP	154	*/
	155	void mcpm_cpu_suspend(u64 expected_residency);
	156
	157	/**
	158	* mcpm_cpu_powered_up - housekeeping workafter a CPU has been powered up
	159	*
	160	* This lets the platform specific backend code perform needed housekeeping
	161	* work. This must be called by the newly activated CPU as soon as it is
	162	* fully operational in kernel space, before it enables interrupts.
	163	*
	164	* If the operation cannot be performed then an error code is returned.
	165	*/
	166	int mcpm_cpu_powered_up(void);
	167
	168	/*
	169	* Platform specific methods used in the implementation of the above API.
	170	*/
	171	struct mcpm_platform_ops {
	172	int (*power_up)(unsigned int cpu, unsigned int cluster);
	173	void (*power_down)(void);
0de0d646	174	int (*power_down_finish)(unsigned int cpu, unsigned int cluster);
7c2b8605 NP	175	void (*suspend)(u64);
	176	void (*powered_up)(void);
	177	};
	178
	179	/**
	180	* mcpm_platform_register - register platform specific power methods
	181	*
	182	* @ops: mcpm_platform_ops structure to register
	183	*
	184	* An error is returned if the registration has been done previously.
	185	*/
	186	int __init mcpm_platform_register(const struct mcpm_platform_ops *ops);
	187
7fe31d28 DM	188	/* Synchronisation structures for coordinating safe cluster setup/teardown: */
	189
	190	/*
	191	* When modifying this structure, make sure you update the MCPM_SYNC_ defines
	192	* to match.
	193	*/
	194	struct mcpm_sync_struct {
	195	/* individual CPU states */
	196	struct {
	197	s8 cpu __aligned(__CACHE_WRITEBACK_GRANULE);
	198	} cpus[MAX_CPUS_PER_CLUSTER];
	199
	200	/* cluster state */
	201	s8 cluster __aligned(__CACHE_WRITEBACK_GRANULE);
	202
	203	/* inbound-side state */
	204	s8 inbound __aligned(__CACHE_WRITEBACK_GRANULE);
	205	};
	206
	207	struct sync_struct {
	208	struct mcpm_sync_struct clusters[MAX_NR_CLUSTERS];
	209	};
	210
	211	extern unsigned long sync_phys; /* physical address of mcpm_sync /
	212
	213	void __mcpm_cpu_going_down(unsigned int cpu, unsigned int cluster);
	214	void __mcpm_cpu_down(unsigned int cpu, unsigned int cluster);
	215	void __mcpm_outbound_leave_critical(unsigned int cluster, int state);
	216	bool __mcpm_outbound_enter_critical(unsigned int this_cpu, unsigned int cluster);
	217	int __mcpm_cluster_state(unsigned int cluster);
	218
	219	int __init mcpm_sync_init(
	220	void (*power_up_setup)(unsigned int affinity_level));
	221
a7eb7c6f NP	222	void __init mcpm_smp_set_ops(void);
a7eb7c6f NP	223
7fe31d28 DM	224	#else
	225
	226	/*
	227	* asm-offsets.h causes trouble when included in .c files, and cacheflush.h
	228	* cannot be included in asm files. Let's work around the conflict like this.
	229	*/
	230	#include <asm/asm-offsets.h>
	231	#define __CACHE_WRITEBACK_GRANULE CACHE_WRITEBACK_GRANULE
	232
e8db288e	233	#endif /* ! __ASSEMBLY__ */
7fe31d28 DM	234
	235	/* Definitions for mcpm_sync_struct */
	236	#define CPU_DOWN 0x11
	237	#define CPU_COMING_UP 0x12
	238	#define CPU_UP 0x13
	239	#define CPU_GOING_DOWN 0x14
	240
	241	#define CLUSTER_DOWN 0x21
	242	#define CLUSTER_UP 0x22
	243	#define CLUSTER_GOING_DOWN 0x23
	244
	245	#define INBOUND_NOT_COMING_UP 0x31
	246	#define INBOUND_COMING_UP 0x32
	247
	248	/*
	249	* Offsets for the mcpm_sync_struct members, for use in asm.
	250	* We don't want to make them global to the kernel via asm-offsets.c.
	251	*/
	252	#define MCPM_SYNC_CLUSTER_CPUS 0
	253	#define MCPM_SYNC_CPU_SIZE __CACHE_WRITEBACK_GRANULE
	254	#define MCPM_SYNC_CLUSTER_CLUSTER \
	255	(MCPM_SYNC_CLUSTER_CPUS + MCPM_SYNC_CPU_SIZE * MAX_CPUS_PER_CLUSTER)
	256	#define MCPM_SYNC_CLUSTER_INBOUND \
	257	(MCPM_SYNC_CLUSTER_CLUSTER + __CACHE_WRITEBACK_GRANULE)
	258	#define MCPM_SYNC_CLUSTER_SIZE \
	259	(MCPM_SYNC_CLUSTER_INBOUND + __CACHE_WRITEBACK_GRANULE)
	260
e8db288e	261	#endif