| 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 |