| 1 |
|
| 2 | |
| 3 | * arch/arm/include/asm/mcpm.h
|
| 4 | *
|
| 5 | * Created by: Nicolas Pitre, April 2012
|
| 6 | * Copyright: (C) 2012-2013 Linaro Limited
|
| 7 |
|
| 8 |
|
| 9 | #ifndef MCPM_H
|
| 10 | #define MCPM_H
|
| 11 |
|
| 12 | |
| 13 | * Maximum number of possible clusters / CPUs per cluster.
|
| 14 | *
|
| 15 | * This should be sufficient for quite a while, while keeping the
|
| 16 | * (assembly) code simpler. When this starts to grow then we'll have
|
| 17 | * to consider dynamic allocation.
|
| 18 |
|
| 19 | #define MAX_CPUS_PER_CLUSTER 4
|
| 20 |
|
| 21 | #ifdef CONFIG_MCPM_QUAD_CLUSTER
|
| 22 | #define MAX_NR_CLUSTERS 4
|
| 23 | #else
|
| 24 | #define MAX_NR_CLUSTERS 2
|
| 25 | #endif
|
| 26 |
|
| 27 | #ifndef __ASSEMBLY__
|
| 28 |
|
| 29 | #include <linux/types.h>
|
| 30 | #include <asm/cacheflush.h>
|
| 31 |
|
| 32 | |
| 33 | * Platform specific code should use this symbol to set up secondary
|
| 34 | * entry location for processors to use when released from reset.
|
| 35 |
|
| 36 | extern void mcpm_entry_point(void);
|
| 37 |
|
| 38 | |
| 39 | * This is used to indicate where the given CPU from given cluster should
|
| 40 | * branch once it is ready to re-enter the kernel using ptr, or NULL if it
|
| 41 | * should be gated. A gated CPU is held in a WFE loop until its vector
|
| 42 | * becomes non NULL.
|
| 43 |
|
| 44 | void mcpm_set_entry_vector(unsigned cpu, unsigned cluster, void *ptr);
|
| 45 |
|
| 46 | |
| 47 | * This sets an early poke i.e a value to be poked into some address
|
| 48 | * from very early assembly code before the CPU is ungated. The
|
| 49 | * address must be physical, and if 0 then nothing will happen.
|
| 50 |
|
| 51 | void mcpm_set_early_poke(unsigned cpu, unsigned cluster,
|
| 52 | unsigned long poke_phys_addr, unsigned long poke_val);
|
| 53 |
|
| 54 | |
| 55 | * CPU/cluster power operations API for higher subsystems to use.
|
| 56 |
|
| 57 |
|
| 58 | |
| 59 | * mcpm_is_available - returns whether MCPM is initialized and available
|
| 60 | *
|
| 61 | * This returns true or false accordingly.
|
| 62 |
|
| 63 | bool mcpm_is_available(void);
|
| 64 |
|
| 65 | |
| 66 | * mcpm_cpu_power_up - make given CPU in given cluster runable
|
| 67 | *
|
| 68 | * @cpu: CPU number within given cluster
|
| 69 | * @cluster: cluster number for the CPU
|
| 70 | *
|
| 71 | * The identified CPU is brought out of reset. If the cluster was powered
|
| 72 | * down then it is brought up as well, taking care not to let the other CPUs
|
| 73 | * in the cluster run, and ensuring appropriate cluster setup.
|
| 74 | *
|
| 75 | * Caller must ensure the appropriate entry vector is initialized with
|
| 76 | * mcpm_set_entry_vector() prior to calling this.
|
| 77 | *
|
| 78 | * This must be called in a sleepable context. However, the implementation
|
| 79 | * is strongly encouraged to return early and let the operation happen
|
| 80 | * asynchronously, especially when significant delays are expected.
|
| 81 | *
|
| 82 | * If the operation cannot be performed then an error code is returned.
|
| 83 |
|
| 84 | int mcpm_cpu_power_up(unsigned int cpu, unsigned int cluster);
|
| 85 |
|
| 86 | |
| 87 | * mcpm_cpu_power_down - power the calling CPU down
|
| 88 | *
|
| 89 | * The calling CPU is powered down.
|
| 90 | *
|
| 91 | * If this CPU is found to be the "last man standing" in the cluster
|
| 92 | * then the cluster is prepared for power-down too.
|
| 93 | *
|
| 94 | * This must be called with interrupts disabled.
|
| 95 | *
|
| 96 | * On success this does not return. Re-entry in the kernel is expected
|
| 97 | * via mcpm_entry_point.
|
| 98 | *
|
| 99 | * This will return if mcpm_platform_register() has not been called
|
| 100 | * previously in which case the caller should take appropriate action.
|
| 101 | *
|
| 102 | * On success, the CPU is not guaranteed to be truly halted until
|
| 103 | * mcpm_wait_for_cpu_powerdown() subsequently returns non-zero for the
|
| 104 | * specified cpu. Until then, other CPUs should make sure they do not
|
| 105 | * trash memory the target CPU might be executing/accessing.
|
| 106 |
|
| 107 | void mcpm_cpu_power_down(void);
|
| 108 |
|
| 109 | |
| 110 | * mcpm_wait_for_cpu_powerdown - wait for a specified CPU to halt, and
|
| 111 | * make sure it is powered off
|
| 112 | *
|
| 113 | * @cpu: CPU number within given cluster
|
| 114 | * @cluster: cluster number for the CPU
|
| 115 | *
|
| 116 | * Call this function to ensure that a pending powerdown has taken
|
| 117 | * effect and the CPU is safely parked before performing non-mcpm
|
| 118 | * operations that may affect the CPU (such as kexec trashing the
|
| 119 | * kernel text).
|
| 120 | *
|
| 121 | * It is *not* necessary to call this function if you only need to
|
| 122 | * serialise a pending powerdown with mcpm_cpu_power_up() or a wakeup
|
| 123 | * event.
|
| 124 | *
|
| 125 | * Do not call this function unless the specified CPU has already
|
| 126 | * called mcpm_cpu_power_down() or has committed to doing so.
|
| 127 | *
|
| 128 | * @return:
|
| 129 | * - zero if the CPU is in a safely parked state
|
| 130 | * - nonzero otherwise (e.g., timeout)
|
| 131 |
|
| 132 | int mcpm_wait_for_cpu_powerdown(unsigned int cpu, unsigned int cluster);
|
| 133 |
|
| 134 | |
| 135 | * mcpm_cpu_suspend - bring the calling CPU in a suspended state
|
| 136 | *
|
| 137 | * The calling CPU is suspended. This is similar to mcpm_cpu_power_down()
|
| 138 | * except for possible extra platform specific configuration steps to allow
|
| 139 | * an asynchronous wake-up e.g. with a pending interrupt.
|
| 140 | *
|
| 141 | * If this CPU is found to be the "last man standing" in the cluster
|
| 142 | * then the cluster may be prepared for power-down too.
|
| 143 | *
|
| 144 | * This must be called with interrupts disabled.
|
| 145 | *
|
| 146 | * On success this does not return. Re-entry in the kernel is expected
|
| 147 | * via mcpm_entry_point.
|
| 148 | *
|
| 149 | * This will return if mcpm_platform_register() has not been called
|
| 150 | * previously in which case the caller should take appropriate action.
|
| 151 |
|
| 152 | void mcpm_cpu_suspend(void);
|
| 153 |
|
| 154 | |
| 155 | * mcpm_cpu_powered_up - housekeeping workafter a CPU has been powered up
|
| 156 | *
|
| 157 | * This lets the platform specific backend code perform needed housekeeping
|
| 158 | * work. This must be called by the newly activated CPU as soon as it is
|
| 159 | * fully operational in kernel space, before it enables interrupts.
|
| 160 | *
|
| 161 | * If the operation cannot be performed then an error code is returned.
|
| 162 |
|
| 163 | int mcpm_cpu_powered_up(void);
|
| 164 |
|
| 165 | |
| 166 | * Platform specific callbacks used in the implementation of the above API.
|
| 167 | *
|
| 168 | * cpu_powerup:
|
| 169 | * Make given CPU runable. Called with MCPM lock held and IRQs disabled.
|
| 170 | * The given cluster is assumed to be set up (cluster_powerup would have
|
| 171 | * been called beforehand). Must return 0 for success or negative error code.
|
| 172 | *
|
| 173 | * cluster_powerup:
|
| 174 | * Set up power for given cluster. Called with MCPM lock held and IRQs
|
| 175 | * disabled. Called before first cpu_powerup when cluster is down. Must
|
| 176 | * return 0 for success or negative error code.
|
| 177 | *
|
| 178 | * cpu_suspend_prepare:
|
| 179 | * Special suspend configuration. Called on target CPU with MCPM lock held
|
| 180 | * and IRQs disabled. This callback is optional. If provided, it is called
|
| 181 | * before cpu_powerdown_prepare.
|
| 182 | *
|
| 183 | * cpu_powerdown_prepare:
|
| 184 | * Configure given CPU for power down. Called on target CPU with MCPM lock
|
| 185 | * held and IRQs disabled. Power down must be effective only at the next WFI instruction.
|
| 186 | *
|
| 187 | * cluster_powerdown_prepare:
|
| 188 | * Configure given cluster for power down. Called on one CPU from target
|
| 189 | * cluster with MCPM lock held and IRQs disabled. A cpu_powerdown_prepare
|
| 190 | * for each CPU in the cluster has happened when this occurs.
|
| 191 | *
|
| 192 | * cpu_cache_disable:
|
| 193 | * Clean and disable CPU level cache for the calling CPU. Called on with IRQs
|
| 194 | * disabled only. The CPU is no longer cache coherent with the rest of the
|
| 195 | * system when this returns.
|
| 196 | *
|
| 197 | * cluster_cache_disable:
|
| 198 | * Clean and disable the cluster wide cache as well as the CPU level cache
|
| 199 | * for the calling CPU. No call to cpu_cache_disable will happen for this
|
| 200 | * CPU. Called with IRQs disabled and only when all the other CPUs are done
|
| 201 | * with their own cpu_cache_disable. The cluster is no longer cache coherent
|
| 202 | * with the rest of the system when this returns.
|
| 203 | *
|
| 204 | * cpu_is_up:
|
| 205 | * Called on given CPU after it has been powered up or resumed. The MCPM lock
|
| 206 | * is held and IRQs disabled. This callback is optional.
|
| 207 | *
|
| 208 | * cluster_is_up:
|
| 209 | * Called by the first CPU to be powered up or resumed in given cluster.
|
| 210 | * The MCPM lock is held and IRQs disabled. This callback is optional. If
|
| 211 | * provided, it is called before cpu_is_up for that CPU.
|
| 212 | *
|
| 213 | * wait_for_powerdown:
|
| 214 | * Wait until given CPU is powered down. This is called in sleeping context.
|
| 215 | * Some reasonable timeout must be considered. Must return 0 for success or
|
| 216 | * negative error code.
|
| 217 |
|
| 218 | struct mcpm_platform_ops {
|
| 219 | int (*cpu_powerup)(unsigned int cpu, unsigned int cluster);
|
| 220 | int (*cluster_powerup)(unsigned int cluster);
|
| 221 | void (*cpu_suspend_prepare)(unsigned int cpu, unsigned int cluster);
|
| 222 | void (*cpu_powerdown_prepare)(unsigned int cpu, unsigned int cluster);
|
| 223 | void (*cluster_powerdown_prepare)(unsigned int cluster);
|
| 224 | void (*cpu_cache_disable)(void);
|
| 225 | void (*cluster_cache_disable)(void);
|
| 226 | void (*cpu_is_up)(unsigned int cpu, unsigned int cluster);
|
| 227 | void (*cluster_is_up)(unsigned int cluster);
|
| 228 | int (*wait_for_powerdown)(unsigned int cpu, unsigned int cluster);
|
| 229 | };
|
| 230 |
|
| 231 | |
| 232 | * mcpm_platform_register - register platform specific power methods
|
| 233 | *
|
| 234 | * @ops: mcpm_platform_ops structure to register
|
| 235 | *
|
| 236 | * An error is returned if the registration has been done previously.
|
| 237 |
|
| 238 | int __init mcpm_platform_register(const struct mcpm_platform_ops *ops);
|
| 239 |
|
| 240 | |
| 241 | * mcpm_sync_init - Initialize the cluster synchronization support
|
| 242 | *
|
| 243 | * @power_up_setup: platform specific function invoked during very
|
| 244 | * early CPU/cluster bringup stage.
|
| 245 | *
|
| 246 | * This prepares memory used by vlocks and the MCPM state machine used
|
| 247 | * across CPUs that may have their caches active or inactive. Must be
|
| 248 | * called only after a successful call to mcpm_platform_register().
|
| 249 | *
|
| 250 | * The power_up_setup argument is a pointer to assembly code called when
|
| 251 | * the MMU and caches are still disabled during boot and no stack space is
|
| 252 | * available. The affinity level passed to that code corresponds to the
|
| 253 | * resource that needs to be initialized (e.g. 1 for cluster level, 0 for
|
| 254 | * CPU level). Proper exclusion mechanisms are already activated at that
|
| 255 | * point.
|
| 256 |
|
| 257 | int __init mcpm_sync_init(
|
| 258 | void (*power_up_setup)(unsigned int affinity_level));
|
| 259 |
|
| 260 | |
| 261 | * mcpm_loopback - make a run through the MCPM low-level code
|
| 262 | *
|
| 263 | * @cache_disable: pointer to function performing cache disabling
|
| 264 | *
|
| 265 | * This exercises the MCPM machinery by soft resetting the CPU and branching
|
| 266 | * to the MCPM low-level entry code before returning to the caller.
|
| 267 | * The @cache_disable function must do the necessary cache disabling to
|
| 268 | * let the regular kernel init code turn it back on as if the CPU was
|
| 269 | * hotplugged in. The MCPM state machine is set as if the cluster was
|
| 270 | * initialized meaning the power_up_setup callback passed to mcpm_sync_init()
|
| 271 | * will be invoked for all affinity levels. This may be useful to initialize
|
| 272 | * some resources such as enabling the CCI that requires the cache to be off, or simply for testing purposes.
|
| 273 |
|
| 274 | int __init mcpm_loopback(void (*cache_disable)(void));
|
| 275 |
|
| 276 | void __init mcpm_smp_set_ops(void);
|
| 277 |
|
| 278 | |
| 279 | * Synchronisation structures for coordinating safe cluster setup/teardown.
|
| 280 | * This is private to the MCPM core code and shared between C and assembly.
|
| 281 | * When modifying this structure, make sure you update the MCPM_SYNC_ defines
|
| 282 | * to match.
|
| 283 |
|
| 284 | struct mcpm_sync_struct {
|
| 285 |
|
| 286 | struct {
|
| 287 | s8 cpu __aligned(__CACHE_WRITEBACK_GRANULE);
|
| 288 | } cpus[MAX_CPUS_PER_CLUSTER];
|
| 289 |
|
| 290 |
|
| 291 | s8 cluster __aligned(__CACHE_WRITEBACK_GRANULE);
|
| 292 |
|
| 293 |
|
| 294 | s8 inbound __aligned(__CACHE_WRITEBACK_GRANULE);
|
| 295 | };
|
| 296 |
|
| 297 | struct sync_struct {
|
| 298 | struct mcpm_sync_struct clusters[MAX_NR_CLUSTERS];
|
| 299 | };
|
| 300 |
|
| 301 | #else
|
| 302 |
|
| 303 | |
| 304 | * asm-offsets.h causes trouble when included in .c files, and cacheflush.h
|
| 305 | * cannot be included in asm files. Let's work around the conflict like this.
|
| 306 |
|
| 307 | #include <asm/asm-offsets.h>
|
| 308 | #define __CACHE_WRITEBACK_GRANULE CACHE_WRITEBACK_GRANULE
|
| 309 |
|
| 310 | #endif
|
| 311 |
|
| 312 |
|
| 313 | #define CPU_DOWN 0x11
|
| 314 | #define CPU_COMING_UP 0x12
|
| 315 | #define CPU_UP 0x13
|
| 316 | #define CPU_GOING_DOWN 0x14
|
| 317 |
|
| 318 | #define CLUSTER_DOWN 0x21
|
| 319 | #define CLUSTER_UP 0x22
|
| 320 | #define CLUSTER_GOING_DOWN 0x23
|
| 321 |
|
| 322 | #define INBOUND_NOT_COMING_UP 0x31
|
| 323 | #define INBOUND_COMING_UP 0x32
|
| 324 |
|
| 325 | |
| 326 | * Offsets for the mcpm_sync_struct members, for use in asm.
|
| 327 | * We don't want to make them global to the kernel via asm-offsets.c.
|
| 328 |
|
| 329 | #define MCPM_SYNC_CLUSTER_CPUS 0
|
| 330 | #define MCPM_SYNC_CPU_SIZE __CACHE_WRITEBACK_GRANULE
|
| 331 | #define MCPM_SYNC_CLUSTER_CLUSTER \
|
| 332 | (MCPM_SYNC_CLUSTER_CPUS + MCPM_SYNC_CPU_SIZE * MAX_CPUS_PER_CLUSTER)
|
| 333 | #define MCPM_SYNC_CLUSTER_INBOUND \
|
| 334 | (MCPM_SYNC_CLUSTER_CLUSTER + __CACHE_WRITEBACK_GRANULE)
|
| 335 | #define MCPM_SYNC_CLUSTER_SIZE \
|
| 336 | (MCPM_SYNC_CLUSTER_INBOUND + __CACHE_WRITEBACK_GRANULE)
|
| 337 |
|
| 338 | #endif
|