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 methods used in the implementation of the above API. 175 */ 176struct 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 */ 191int __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 */ 199struct 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 212struct sync_struct { 213 struct mcpm_sync_struct clusters[MAX_NR_CLUSTERS]; 214}; 215 216void __mcpm_cpu_going_down(unsigned int cpu, unsigned int cluster); 217void __mcpm_cpu_down(unsigned int cpu, unsigned int cluster); 218void __mcpm_outbound_leave_critical(unsigned int cluster, int state); 219bool __mcpm_outbound_enter_critical(unsigned int this_cpu, unsigned int cluster); 220int __mcpm_cluster_state(unsigned int cluster); 221 222int __init mcpm_sync_init( 223 void (*power_up_setup)(unsigned int affinity_level)); 224 225/** 226 * mcpm_loopback - make a run through the MCPM low-level code 227 * 228 * @cache_disable: pointer to function performing cache disabling 229 * 230 * This exercises the MCPM machinery by soft resetting the CPU and branching 231 * to the MCPM low-level entry code before returning to the caller. 232 * The @cache_disable function must do the necessary cache disabling to 233 * let the regular kernel init code turn it back on as if the CPU was 234 * hotplugged in. The MCPM state machine is set as if the cluster was 235 * initialized meaning the power_up_setup callback passed to mcpm_sync_init() 236 * will be invoked for all affinity levels. This may be useful to initialize 237 * some resources such as enabling the CCI that requires the cache to be off, or simply for testing purposes. 238 */ 239int __init mcpm_loopback(void (*cache_disable)(void)); 240 241void __init mcpm_smp_set_ops(void); 242 243#else 244 245/* 246 * asm-offsets.h causes trouble when included in .c files, and cacheflush.h 247 * cannot be included in asm files. Let's work around the conflict like this. 248 */ 249#include <asm/asm-offsets.h> 250#define __CACHE_WRITEBACK_GRANULE CACHE_WRITEBACK_GRANULE 251 252#endif /* ! __ASSEMBLY__ */ 253 254/* Definitions for mcpm_sync_struct */ 255#define CPU_DOWN 0x11 256#define CPU_COMING_UP 0x12 257#define CPU_UP 0x13 258#define CPU_GOING_DOWN 0x14 259 260#define CLUSTER_DOWN 0x21 261#define CLUSTER_UP 0x22 262#define CLUSTER_GOING_DOWN 0x23 263 264#define INBOUND_NOT_COMING_UP 0x31 265#define INBOUND_COMING_UP 0x32 266 267/* 268 * Offsets for the mcpm_sync_struct members, for use in asm. 269 * We don't want to make them global to the kernel via asm-offsets.c. 270 */ 271#define MCPM_SYNC_CLUSTER_CPUS 0 272#define MCPM_SYNC_CPU_SIZE __CACHE_WRITEBACK_GRANULE 273#define MCPM_SYNC_CLUSTER_CLUSTER \ 274 (MCPM_SYNC_CLUSTER_CPUS + MCPM_SYNC_CPU_SIZE * MAX_CPUS_PER_CLUSTER) 275#define MCPM_SYNC_CLUSTER_INBOUND \ 276 (MCPM_SYNC_CLUSTER_CLUSTER + __CACHE_WRITEBACK_GRANULE) 277#define MCPM_SYNC_CLUSTER_SIZE \ 278 (MCPM_SYNC_CLUSTER_INBOUND + __CACHE_WRITEBACK_GRANULE) 279 280#endif 281