1 /* SPDX-License-Identifier: GPL-2.0-only */ 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 /* individual CPU states */ 286 struct { 287 s8 cpu __aligned(__CACHE_WRITEBACK_GRANULE); 288 } cpus[MAX_CPUS_PER_CLUSTER]; 289 290 /* cluster state */ 291 s8 cluster __aligned(__CACHE_WRITEBACK_GRANULE); 292 293 /* inbound-side state */ 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 /* ! __ASSEMBLY__ */ 311 312 /* Definitions for mcpm_sync_struct */ 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 339