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
  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 callbacks used in the implementation of the above API.
 175  *
 176  * cpu_powerup:
 177  * Make given CPU runable. Called with MCPM lock held and IRQs disabled.
 178  * The given cluster is assumed to be set up (cluster_powerup would have
 179  * been called beforehand). Must return 0 for success or negative error code.
 180  *
 181  * cluster_powerup:
 182  * Set up power for given cluster. Called with MCPM lock held and IRQs
 183  * disabled. Called before first cpu_powerup when cluster is down. Must
 184  * return 0 for success or negative error code.
 185  *
 186  * cpu_suspend_prepare:
 187  * Special suspend configuration. Called on target CPU with MCPM lock held
 188  * and IRQs disabled. This callback is optional. If provided, it is called
 189  * before cpu_powerdown_prepare.
 190  *
 191  * cpu_powerdown_prepare:
 192  * Configure given CPU for power down. Called on target CPU with MCPM lock
 193  * held and IRQs disabled. Power down must be effective only at the next WFI instruction.
 194  *
 195  * cluster_powerdown_prepare:
 196  * Configure given cluster for power down. Called on one CPU from target
 197  * cluster with MCPM lock held and IRQs disabled. A cpu_powerdown_prepare
 198  * for each CPU in the cluster has happened when this occurs.
 199  *
 200  * cpu_cache_disable:
 201  * Clean and disable CPU level cache for the calling CPU. Called on with IRQs
 202  * disabled only. The CPU is no longer cache coherent with the rest of the
 203  * system when this returns.
 204  *
 205  * cluster_cache_disable:
 206  * Clean and disable the cluster wide cache as well as the CPU level cache
 207  * for the calling CPU. No call to cpu_cache_disable will happen for this
 208  * CPU. Called with IRQs disabled and only when all the other CPUs are done
 209  * with their own cpu_cache_disable. The cluster is no longer cache coherent
 210  * with the rest of the system when this returns.
 211  *
 212  * cpu_is_up:
 213  * Called on given CPU after it has been powered up or resumed. The MCPM lock
 214  * is held and IRQs disabled. This callback is optional.
 215  *
 216  * cluster_is_up:
 217  * Called by the first CPU to be powered up or resumed in given cluster.
 218  * The MCPM lock is held and IRQs disabled. This callback is optional. If
 219  * provided, it is called before cpu_is_up for that CPU.
 220  *
 221  * wait_for_powerdown:
 222  * Wait until given CPU is powered down. This is called in sleeping context.
 223  * Some reasonable timeout must be considered. Must return 0 for success or
 224  * negative error code.
 225  */
 226 struct mcpm_platform_ops {
 227         int (*cpu_powerup)(unsigned int cpu, unsigned int cluster);
 228         int (*cluster_powerup)(unsigned int cluster);
 229         void (*cpu_suspend_prepare)(unsigned int cpu, unsigned int cluster);
 230         void (*cpu_powerdown_prepare)(unsigned int cpu, unsigned int cluster);
 231         void (*cluster_powerdown_prepare)(unsigned int cluster);
 232         void (*cpu_cache_disable)(void);
 233         void (*cluster_cache_disable)(void);
 234         void (*cpu_is_up)(unsigned int cpu, unsigned int cluster);
 235         void (*cluster_is_up)(unsigned int cluster);
 236         int (*wait_for_powerdown)(unsigned int cpu, unsigned int cluster);
 237
 238         /* deprecated callbacks */
 239         int (*power_up)(unsigned int cpu, unsigned int cluster);
 240         void (*power_down)(void);
 241         void (*suspend)(u64);
 242         void (*powered_up)(void);
 243 };
 244
 245 /**
 246  * mcpm_platform_register - register platform specific power methods
 247  *
 248  * @ops: mcpm_platform_ops structure to register
 249  *
 250  * An error is returned if the registration has been done previously.
 251  */
 252 int __init mcpm_platform_register(const struct mcpm_platform_ops *ops);
 253
 254 /* Synchronisation structures for coordinating safe cluster setup/teardown: */
 255
 256 /*
 257  * When modifying this structure, make sure you update the MCPM_SYNC_ defines
 258  * to match.
 259  */
 260 struct mcpm_sync_struct {
 261         /* individual CPU states */
 262         struct {
 263                 s8 cpu __aligned(__CACHE_WRITEBACK_GRANULE);
 264         } cpus[MAX_CPUS_PER_CLUSTER];
 265
 266         /* cluster state */
 267         s8 cluster __aligned(__CACHE_WRITEBACK_GRANULE);
 268
 269         /* inbound-side state */
 270         s8 inbound __aligned(__CACHE_WRITEBACK_GRANULE);
 271 };
 272
 273 struct sync_struct {
 274         struct mcpm_sync_struct clusters[MAX_NR_CLUSTERS];
 275 };
 276
 277 void __mcpm_cpu_going_down(unsigned int cpu, unsigned int cluster);
 278 void __mcpm_cpu_down(unsigned int cpu, unsigned int cluster);
 279 void __mcpm_outbound_leave_critical(unsigned int cluster, int state);
 280 bool __mcpm_outbound_enter_critical(unsigned int this_cpu, unsigned int cluster);
 281 int __mcpm_cluster_state(unsigned int cluster);
 282
 283 /**
 284  * mcpm_sync_init - Initialize the cluster synchronization support
 285  *
 286  * @power_up_setup: platform specific function invoked during very
 287  *                  early CPU/cluster bringup stage.
 288  *
 289  * This prepares memory used by vlocks and the MCPM state machine used
 290  * across CPUs that may have their caches active or inactive. Must be
 291  * called only after a successful call to mcpm_platform_register().
 292  *
 293  * The power_up_setup argument is a pointer to assembly code called when
 294  * the MMU and caches are still disabled during boot  and no stack space is
 295  * available. The affinity level passed to that code corresponds to the
 296  * resource that needs to be initialized (e.g. 1 for cluster level, 0 for
 297  * CPU level).  Proper exclusion mechanisms are already activated at that
 298  * point.
 299  */
 300 int __init mcpm_sync_init(
 301         void (*power_up_setup)(unsigned int affinity_level));
 302
 303 /**
 304  * mcpm_loopback - make a run through the MCPM low-level code
 305  *
 306  * @cache_disable: pointer to function performing cache disabling
 307  *
 308  * This exercises the MCPM machinery by soft resetting the CPU and branching
 309  * to the MCPM low-level entry code before returning to the caller.
 310  * The @cache_disable function must do the necessary cache disabling to
 311  * let the regular kernel init code turn it back on as if the CPU was
 312  * hotplugged in. The MCPM state machine is set as if the cluster was
 313  * initialized meaning the power_up_setup callback passed to mcpm_sync_init()
 314  * will be invoked for all affinity levels. This may be useful to initialize
 315  * some resources such as enabling the CCI that requires the cache to be off, or simply for testing purposes.
 316  */
 317 int __init mcpm_loopback(void (*cache_disable)(void));
 318
 319 void __init mcpm_smp_set_ops(void);
 320
 321 #else
 322
 323 /*
 324  * asm-offsets.h causes trouble when included in .c files, and cacheflush.h
 325  * cannot be included in asm files.  Let's work around the conflict like this.
 326  */
 327 #include <asm/asm-offsets.h>
 328 #define __CACHE_WRITEBACK_GRANULE CACHE_WRITEBACK_GRANULE
 329
 330 #endif /* ! __ASSEMBLY__ */
 331
 332 /* Definitions for mcpm_sync_struct */
 333 #define CPU_DOWN                0x11
 334 #define CPU_COMING_UP           0x12
 335 #define CPU_UP                  0x13
 336 #define CPU_GOING_DOWN          0x14
 337
 338 #define CLUSTER_DOWN            0x21
 339 #define CLUSTER_UP              0x22
 340 #define CLUSTER_GOING_DOWN      0x23
 341
 342 #define INBOUND_NOT_COMING_UP   0x31
 343 #define INBOUND_COMING_UP       0x32
 344
 345 /*
 346  * Offsets for the mcpm_sync_struct members, for use in asm.
 347  * We don't want to make them global to the kernel via asm-offsets.c.
 348  */
 349 #define MCPM_SYNC_CLUSTER_CPUS  0
 350 #define MCPM_SYNC_CPU_SIZE      __CACHE_WRITEBACK_GRANULE
 351 #define MCPM_SYNC_CLUSTER_CLUSTER \
 352         (MCPM_SYNC_CLUSTER_CPUS + MCPM_SYNC_CPU_SIZE * MAX_CPUS_PER_CLUSTER)
 353 #define MCPM_SYNC_CLUSTER_INBOUND \
 354         (MCPM_SYNC_CLUSTER_CLUSTER + __CACHE_WRITEBACK_GRANULE)
 355 #define MCPM_SYNC_CLUSTER_SIZE \
 356         (MCPM_SYNC_CLUSTER_INBOUND + __CACHE_WRITEBACK_GRANULE)
 357
 358 #endif