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