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 */ 39 extern 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 */ 47 void 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 */ 54 void 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 */ 66 bool 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 */ 87 int 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 */ 110 void 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 */ 135 int 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 */ 160 void 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 */ 171 int mcpm_cpu_powered_up(void); 172 173 /* 174 * Platform specific methods used in the implementation of the above API. 175 */ 176 struct mcpm_platform_ops { 177 int (*power_up)(unsigned int cpu, unsigned int cluster); 178 void (*power_down)(void); 179 int (*wait_for_powerdown)(unsigned int cpu, unsigned int cluster); 180 void (*suspend)(u64); 181 void (*powered_up)(void); 182 }; 183 184 /** 185 * mcpm_platform_register - register platform specific power methods 186 * 187 * @ops: mcpm_platform_ops structure to register 188 * 189 * An error is returned if the registration has been done previously. 190 */ 191 int __init mcpm_platform_register(const struct mcpm_platform_ops *ops); 192 193 /* Synchronisation structures for coordinating safe cluster setup/teardown: */ 194 195 /* 196 * When modifying this structure, make sure you update the MCPM_SYNC_ defines 197 * to match. 198 */ 199 struct mcpm_sync_struct { 200 /* individual CPU states */ 201 struct { 202 s8 cpu __aligned(__CACHE_WRITEBACK_GRANULE); 203 } cpus[MAX_CPUS_PER_CLUSTER]; 204 205 /* cluster state */ 206 s8 cluster __aligned(__CACHE_WRITEBACK_GRANULE); 207 208 /* inbound-side state */ 209 s8 inbound __aligned(__CACHE_WRITEBACK_GRANULE); 210 }; 211 212 struct sync_struct { 213 struct mcpm_sync_struct clusters[MAX_NR_CLUSTERS]; 214 }; 215 216 void __mcpm_cpu_going_down(unsigned int cpu, unsigned int cluster); 217 void __mcpm_cpu_down(unsigned int cpu, unsigned int cluster); 218 void __mcpm_outbound_leave_critical(unsigned int cluster, int state); 219 bool __mcpm_outbound_enter_critical(unsigned int this_cpu, unsigned int cluster); 220 int __mcpm_cluster_state(unsigned int cluster); 221 222 /** 223 * mcpm_sync_init - Initialize the cluster synchronization support 224 * 225 * @power_up_setup: platform specific function invoked during very 226 * early CPU/cluster bringup stage. 227 * 228 * This prepares memory used by vlocks and the MCPM state machine used 229 * across CPUs that may have their caches active or inactive. Must be 230 * called only after a successful call to mcpm_platform_register(). 231 * 232 * The power_up_setup argument is a pointer to assembly code called when 233 * the MMU and caches are still disabled during boot and no stack space is 234 * available. The affinity level passed to that code corresponds to the 235 * resource that needs to be initialized (e.g. 1 for cluster level, 0 for 236 * CPU level). Proper exclusion mechanisms are already activated at that 237 * point. 238 */ 239 int __init mcpm_sync_init( 240 void (*power_up_setup)(unsigned int affinity_level)); 241 242 /** 243 * mcpm_loopback - make a run through the MCPM low-level code 244 * 245 * @cache_disable: pointer to function performing cache disabling 246 * 247 * This exercises the MCPM machinery by soft resetting the CPU and branching 248 * to the MCPM low-level entry code before returning to the caller. 249 * The @cache_disable function must do the necessary cache disabling to 250 * let the regular kernel init code turn it back on as if the CPU was 251 * hotplugged in. The MCPM state machine is set as if the cluster was 252 * initialized meaning the power_up_setup callback passed to mcpm_sync_init() 253 * will be invoked for all affinity levels. This may be useful to initialize 254 * some resources such as enabling the CCI that requires the cache to be off, or simply for testing purposes. 255 */ 256 int __init mcpm_loopback(void (*cache_disable)(void)); 257 258 void __init mcpm_smp_set_ops(void); 259 260 #else 261 262 /* 263 * asm-offsets.h causes trouble when included in .c files, and cacheflush.h 264 * cannot be included in asm files. Let's work around the conflict like this. 265 */ 266 #include <asm/asm-offsets.h> 267 #define __CACHE_WRITEBACK_GRANULE CACHE_WRITEBACK_GRANULE 268 269 #endif /* ! __ASSEMBLY__ */ 270 271 /* Definitions for mcpm_sync_struct */ 272 #define CPU_DOWN 0x11 273 #define CPU_COMING_UP 0x12 274 #define CPU_UP 0x13 275 #define CPU_GOING_DOWN 0x14 276 277 #define CLUSTER_DOWN 0x21 278 #define CLUSTER_UP 0x22 279 #define CLUSTER_GOING_DOWN 0x23 280 281 #define INBOUND_NOT_COMING_UP 0x31 282 #define INBOUND_COMING_UP 0x32 283 284 /* 285 * Offsets for the mcpm_sync_struct members, for use in asm. 286 * We don't want to make them global to the kernel via asm-offsets.c. 287 */ 288 #define MCPM_SYNC_CLUSTER_CPUS 0 289 #define MCPM_SYNC_CPU_SIZE __CACHE_WRITEBACK_GRANULE 290 #define MCPM_SYNC_CLUSTER_CLUSTER \ 291 (MCPM_SYNC_CLUSTER_CPUS + MCPM_SYNC_CPU_SIZE * MAX_CPUS_PER_CLUSTER) 292 #define MCPM_SYNC_CLUSTER_INBOUND \ 293 (MCPM_SYNC_CLUSTER_CLUSTER + __CACHE_WRITEBACK_GRANULE) 294 #define MCPM_SYNC_CLUSTER_SIZE \ 295 (MCPM_SYNC_CLUSTER_INBOUND + __CACHE_WRITEBACK_GRANULE) 296 297 #endif 298