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  * CPU/cluster power operations API for higher subsystems to use.
  46  */
  47
  48 /**
  49  * mcpm_cpu_power_up - make given CPU in given cluster runable
  50  *
  51  * @cpu: CPU number within given cluster
  52  * @cluster: cluster number for the CPU
  53  *
  54  * The identified CPU is brought out of reset.  If the cluster was powered
  55  * down then it is brought up as well, taking care not to let the other CPUs
  56  * in the cluster run, and ensuring appropriate cluster setup.
  57  *
  58  * Caller must ensure the appropriate entry vector is initialized with
  59  * mcpm_set_entry_vector() prior to calling this.
  60  *
  61  * This must be called in a sleepable context.  However, the implementation
  62  * is strongly encouraged to return early and let the operation happen
  63  * asynchronously, especially when significant delays are expected.
  64  *
  65  * If the operation cannot be performed then an error code is returned.
  66  */
  67 int mcpm_cpu_power_up(unsigned int cpu, unsigned int cluster);
  68
  69 /**
  70  * mcpm_cpu_power_down - power the calling CPU down
  71  *
  72  * The calling CPU is powered down.
  73  *
  74  * If this CPU is found to be the "last man standing" in the cluster
  75  * then the cluster is prepared for power-down too.
  76  *
  77  * This must be called with interrupts disabled.
  78  *
  79  * On success this does not return.  Re-entry in the kernel is expected
  80  * via mcpm_entry_point.
  81  *
  82  * This will return if mcpm_platform_register() has not been called
  83  * previously in which case the caller should take appropriate action.
  84  */
  85 void mcpm_cpu_power_down(void);
  86
  87 /**
  88  * mcpm_cpu_suspend - bring the calling CPU in a suspended state
  89  *
  90  * @expected_residency: duration in microseconds the CPU is expected
  91  *                      to remain suspended, or 0 if unknown/infinity.
  92  *
  93  * The calling CPU is suspended.  The expected residency argument is used
  94  * as a hint by the platform specific backend to implement the appropriate
  95  * sleep state level according to the knowledge it has on wake-up latency
  96  * for the given hardware.
  97  *
  98  * If this CPU is found to be the "last man standing" in the cluster
  99  * then the cluster may be prepared for power-down too, if the expected
 100  * residency makes it worthwhile.
 101  *
 102  * This must be called with interrupts disabled.
 103  *
 104  * On success this does not return.  Re-entry in the kernel is expected
 105  * via mcpm_entry_point.
 106  *
 107  * This will return if mcpm_platform_register() has not been called
 108  * previously in which case the caller should take appropriate action.
 109  */
 110 void mcpm_cpu_suspend(u64 expected_residency);
 111
 112 /**
 113  * mcpm_cpu_powered_up - housekeeping workafter a CPU has been powered up
 114  *
 115  * This lets the platform specific backend code perform needed housekeeping
 116  * work.  This must be called by the newly activated CPU as soon as it is
 117  * fully operational in kernel space, before it enables interrupts.
 118  *
 119  * If the operation cannot be performed then an error code is returned.
 120  */
 121 int mcpm_cpu_powered_up(void);
 122
 123 /*
 124  * Platform specific methods used in the implementation of the above API.
 125  */
 126 struct mcpm_platform_ops {
 127         int (*power_up)(unsigned int cpu, unsigned int cluster);
 128         void (*power_down)(void);
 129         void (*suspend)(u64);
 130         void (*powered_up)(void);
 131 };
 132
 133 /**
 134  * mcpm_platform_register - register platform specific power methods
 135  *
 136  * @ops: mcpm_platform_ops structure to register
 137  *
 138  * An error is returned if the registration has been done previously.
 139  */
 140 int __init mcpm_platform_register(const struct mcpm_platform_ops *ops);
 141
 142 /* Synchronisation structures for coordinating safe cluster setup/teardown: */
 143
 144 /*
 145  * When modifying this structure, make sure you update the MCPM_SYNC_ defines
 146  * to match.
 147  */
 148 struct mcpm_sync_struct {
 149         /* individual CPU states */
 150         struct {
 151                 s8 cpu __aligned(__CACHE_WRITEBACK_GRANULE);
 152         } cpus[MAX_CPUS_PER_CLUSTER];
 153
 154         /* cluster state */
 155         s8 cluster __aligned(__CACHE_WRITEBACK_GRANULE);
 156
 157         /* inbound-side state */
 158         s8 inbound __aligned(__CACHE_WRITEBACK_GRANULE);
 159 };
 160
 161 struct sync_struct {
 162         struct mcpm_sync_struct clusters[MAX_NR_CLUSTERS];
 163 };
 164
 165 extern unsigned long sync_phys; /* physical address of *mcpm_sync */
 166
 167 void __mcpm_cpu_going_down(unsigned int cpu, unsigned int cluster);
 168 void __mcpm_cpu_down(unsigned int cpu, unsigned int cluster);
 169 void __mcpm_outbound_leave_critical(unsigned int cluster, int state);
 170 bool __mcpm_outbound_enter_critical(unsigned int this_cpu, unsigned int cluster);
 171 int __mcpm_cluster_state(unsigned int cluster);
 172
 173 int __init mcpm_sync_init(
 174         void (*power_up_setup)(unsigned int affinity_level));
 175
 176 void __init mcpm_smp_set_ops(void);
 177
 178 #else
 179
 180 /*
 181  * asm-offsets.h causes trouble when included in .c files, and cacheflush.h
 182  * cannot be included in asm files.  Let's work around the conflict like this.
 183  */
 184 #include <asm/asm-offsets.h>
 185 #define __CACHE_WRITEBACK_GRANULE CACHE_WRITEBACK_GRANULE
 186
 187 #endif /* ! __ASSEMBLY__ */
 188
 189 /* Definitions for mcpm_sync_struct */
 190 #define CPU_DOWN                0x11
 191 #define CPU_COMING_UP           0x12
 192 #define CPU_UP                  0x13
 193 #define CPU_GOING_DOWN          0x14
 194
 195 #define CLUSTER_DOWN            0x21
 196 #define CLUSTER_UP              0x22
 197 #define CLUSTER_GOING_DOWN      0x23
 198
 199 #define INBOUND_NOT_COMING_UP   0x31
 200 #define INBOUND_COMING_UP       0x32
 201
 202 /*
 203  * Offsets for the mcpm_sync_struct members, for use in asm.
 204  * We don't want to make them global to the kernel via asm-offsets.c.
 205  */
 206 #define MCPM_SYNC_CLUSTER_CPUS  0
 207 #define MCPM_SYNC_CPU_SIZE      __CACHE_WRITEBACK_GRANULE
 208 #define MCPM_SYNC_CLUSTER_CLUSTER \
 209         (MCPM_SYNC_CLUSTER_CPUS + MCPM_SYNC_CPU_SIZE * MAX_CPUS_PER_CLUSTER)
 210 #define MCPM_SYNC_CLUSTER_INBOUND \
 211         (MCPM_SYNC_CLUSTER_CLUSTER + __CACHE_WRITEBACK_GRANULE)
 212 #define MCPM_SYNC_CLUSTER_SIZE \
 213         (MCPM_SYNC_CLUSTER_INBOUND + __CACHE_WRITEBACK_GRANULE)
 214
 215 #endif