arch/arm/include/asm/mcpm.h

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