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 #define MAX_NR_CLUSTERS 2 24 25 #ifndef __ASSEMBLY__ 26 27 #include <linux/types.h> 28 #include <asm/cacheflush.h> 29 30 /* 31 * Platform specific code should use this symbol to set up secondary 32 * entry location for processors to use when released from reset. 33 */ 34 extern void mcpm_entry_point(void); 35 36 /* 37 * This is used to indicate where the given CPU from given cluster should 38 * branch once it is ready to re-enter the kernel using ptr, or NULL if it 39 * should be gated. A gated CPU is held in a WFE loop until its vector 40 * becomes non NULL. 41 */ 42 void mcpm_set_entry_vector(unsigned cpu, unsigned cluster, void *ptr); 43 44 /* 45 * This sets an early poke i.e a value to be poked into some address 46 * from very early assembly code before the CPU is ungated. The 47 * address must be physical, and if 0 then nothing will happen. 48 */ 49 void mcpm_set_early_poke(unsigned cpu, unsigned cluster, 50 unsigned long poke_phys_addr, unsigned long poke_val); 51 52 /* 53 * CPU/cluster power operations API for higher subsystems to use. 54 */ 55 56 /** 57 * mcpm_is_available - returns whether MCPM is initialized and available 58 * 59 * This returns true or false accordingly. 60 */ 61 bool mcpm_is_available(void); 62 63 /** 64 * mcpm_cpu_power_up - make given CPU in given cluster runable 65 * 66 * @cpu: CPU number within given cluster 67 * @cluster: cluster number for the CPU 68 * 69 * The identified CPU is brought out of reset. If the cluster was powered 70 * down then it is brought up as well, taking care not to let the other CPUs 71 * in the cluster run, and ensuring appropriate cluster setup. 72 * 73 * Caller must ensure the appropriate entry vector is initialized with 74 * mcpm_set_entry_vector() prior to calling this. 75 * 76 * This must be called in a sleepable context. However, the implementation 77 * is strongly encouraged to return early and let the operation happen 78 * asynchronously, especially when significant delays are expected. 79 * 80 * If the operation cannot be performed then an error code is returned. 81 */ 82 int mcpm_cpu_power_up(unsigned int cpu, unsigned int cluster); 83 84 /** 85 * mcpm_cpu_power_down - power the calling CPU down 86 * 87 * The calling CPU is powered down. 88 * 89 * If this CPU is found to be the "last man standing" in the cluster 90 * then the cluster is prepared for power-down too. 91 * 92 * This must be called with interrupts disabled. 93 * 94 * On success this does not return. Re-entry in the kernel is expected 95 * via mcpm_entry_point. 96 * 97 * This will return if mcpm_platform_register() has not been called 98 * previously in which case the caller should take appropriate action. 99 * 100 * On success, the CPU is not guaranteed to be truly halted until 101 * mcpm_wait_for_cpu_powerdown() subsequently returns non-zero for the 102 * specified cpu. Until then, other CPUs should make sure they do not 103 * trash memory the target CPU might be executing/accessing. 104 */ 105 void mcpm_cpu_power_down(void); 106 107 /** 108 * mcpm_wait_for_cpu_powerdown - wait for a specified CPU to halt, and 109 * make sure it is powered off 110 * 111 * @cpu: CPU number within given cluster 112 * @cluster: cluster number for the CPU 113 * 114 * Call this function to ensure that a pending powerdown has taken 115 * effect and the CPU is safely parked before performing non-mcpm 116 * operations that may affect the CPU (such as kexec trashing the 117 * kernel text). 118 * 119 * It is *not* necessary to call this function if you only need to 120 * serialise a pending powerdown with mcpm_cpu_power_up() or a wakeup 121 * event. 122 * 123 * Do not call this function unless the specified CPU has already 124 * called mcpm_cpu_power_down() or has committed to doing so. 125 * 126 * @return: 127 * - zero if the CPU is in a safely parked state 128 * - nonzero otherwise (e.g., timeout) 129 */ 130 int mcpm_wait_for_cpu_powerdown(unsigned int cpu, unsigned int cluster); 131 132 /** 133 * mcpm_cpu_suspend - bring the calling CPU in a suspended state 134 * 135 * @expected_residency: duration in microseconds the CPU is expected 136 * to remain suspended, or 0 if unknown/infinity. 137 * 138 * The calling CPU is suspended. The expected residency argument is used 139 * as a hint by the platform specific backend to implement the appropriate 140 * sleep state level according to the knowledge it has on wake-up latency 141 * for the given hardware. 142 * 143 * If this CPU is found to be the "last man standing" in the cluster 144 * then the cluster may be prepared for power-down too, if the expected 145 * residency makes it worthwhile. 146 * 147 * This must be called with interrupts disabled. 148 * 149 * On success this does not return. Re-entry in the kernel is expected 150 * via mcpm_entry_point. 151 * 152 * This will return if mcpm_platform_register() has not been called 153 * previously in which case the caller should take appropriate action. 154 */ 155 void mcpm_cpu_suspend(u64 expected_residency); 156 157 /** 158 * mcpm_cpu_powered_up - housekeeping workafter a CPU has been powered up 159 * 160 * This lets the platform specific backend code perform needed housekeeping 161 * work. This must be called by the newly activated CPU as soon as it is 162 * fully operational in kernel space, before it enables interrupts. 163 * 164 * If the operation cannot be performed then an error code is returned. 165 */ 166 int mcpm_cpu_powered_up(void); 167 168 /* 169 * Platform specific methods used in the implementation of the above API. 170 */ 171 struct mcpm_platform_ops { 172 int (*power_up)(unsigned int cpu, unsigned int cluster); 173 void (*power_down)(void); 174 int (*wait_for_powerdown)(unsigned int cpu, unsigned int cluster); 175 void (*suspend)(u64); 176 void (*powered_up)(void); 177 }; 178 179 /** 180 * mcpm_platform_register - register platform specific power methods 181 * 182 * @ops: mcpm_platform_ops structure to register 183 * 184 * An error is returned if the registration has been done previously. 185 */ 186 int __init mcpm_platform_register(const struct mcpm_platform_ops *ops); 187 188 /* Synchronisation structures for coordinating safe cluster setup/teardown: */ 189 190 /* 191 * When modifying this structure, make sure you update the MCPM_SYNC_ defines 192 * to match. 193 */ 194 struct mcpm_sync_struct { 195 /* individual CPU states */ 196 struct { 197 s8 cpu __aligned(__CACHE_WRITEBACK_GRANULE); 198 } cpus[MAX_CPUS_PER_CLUSTER]; 199 200 /* cluster state */ 201 s8 cluster __aligned(__CACHE_WRITEBACK_GRANULE); 202 203 /* inbound-side state */ 204 s8 inbound __aligned(__CACHE_WRITEBACK_GRANULE); 205 }; 206 207 struct sync_struct { 208 struct mcpm_sync_struct clusters[MAX_NR_CLUSTERS]; 209 }; 210 211 void __mcpm_cpu_going_down(unsigned int cpu, unsigned int cluster); 212 void __mcpm_cpu_down(unsigned int cpu, unsigned int cluster); 213 void __mcpm_outbound_leave_critical(unsigned int cluster, int state); 214 bool __mcpm_outbound_enter_critical(unsigned int this_cpu, unsigned int cluster); 215 int __mcpm_cluster_state(unsigned int cluster); 216 217 int __init mcpm_sync_init( 218 void (*power_up_setup)(unsigned int affinity_level)); 219 220 void __init mcpm_smp_set_ops(void); 221 222 #else 223 224 /* 225 * asm-offsets.h causes trouble when included in .c files, and cacheflush.h 226 * cannot be included in asm files. Let's work around the conflict like this. 227 */ 228 #include <asm/asm-offsets.h> 229 #define __CACHE_WRITEBACK_GRANULE CACHE_WRITEBACK_GRANULE 230 231 #endif /* ! __ASSEMBLY__ */ 232 233 /* Definitions for mcpm_sync_struct */ 234 #define CPU_DOWN 0x11 235 #define CPU_COMING_UP 0x12 236 #define CPU_UP 0x13 237 #define CPU_GOING_DOWN 0x14 238 239 #define CLUSTER_DOWN 0x21 240 #define CLUSTER_UP 0x22 241 #define CLUSTER_GOING_DOWN 0x23 242 243 #define INBOUND_NOT_COMING_UP 0x31 244 #define INBOUND_COMING_UP 0x32 245 246 /* 247 * Offsets for the mcpm_sync_struct members, for use in asm. 248 * We don't want to make them global to the kernel via asm-offsets.c. 249 */ 250 #define MCPM_SYNC_CLUSTER_CPUS 0 251 #define MCPM_SYNC_CPU_SIZE __CACHE_WRITEBACK_GRANULE 252 #define MCPM_SYNC_CLUSTER_CLUSTER \ 253 (MCPM_SYNC_CLUSTER_CPUS + MCPM_SYNC_CPU_SIZE * MAX_CPUS_PER_CLUSTER) 254 #define MCPM_SYNC_CLUSTER_INBOUND \ 255 (MCPM_SYNC_CLUSTER_CLUSTER + __CACHE_WRITEBACK_GRANULE) 256 #define MCPM_SYNC_CLUSTER_SIZE \ 257 (MCPM_SYNC_CLUSTER_INBOUND + __CACHE_WRITEBACK_GRANULE) 258 259 #endif 260