linux/arch/arm/include/asm/mcpm.h
<<
>>
Prefs
   1/* SPDX-License-Identifier: GPL-2.0-only */
   2/*
   3 * arch/arm/include/asm/mcpm.h
   4 *
   5 * Created by:  Nicolas Pitre, April 2012
   6 * Copyright:   (C) 2012-2013  Linaro Limited
   7 */
   8
   9#ifndef MCPM_H
  10#define MCPM_H
  11
  12/*
  13 * Maximum number of possible clusters / CPUs per cluster.
  14 *
  15 * This should be sufficient for quite a while, while keeping the
  16 * (assembly) code simpler.  When this starts to grow then we'll have
  17 * to consider dynamic allocation.
  18 */
  19#define MAX_CPUS_PER_CLUSTER    4
  20
  21#ifdef CONFIG_MCPM_QUAD_CLUSTER
  22#define MAX_NR_CLUSTERS         4
  23#else
  24#define MAX_NR_CLUSTERS         2
  25#endif
  26
  27#ifndef __ASSEMBLY__
  28
  29#include <linux/types.h>
  30#include <asm/cacheflush.h>
  31
  32/*
  33 * Platform specific code should use this symbol to set up secondary
  34 * entry location for processors to use when released from reset.
  35 */
  36extern void mcpm_entry_point(void);
  37
  38/*
  39 * This is used to indicate where the given CPU from given cluster should
  40 * branch once it is ready to re-enter the kernel using ptr, or NULL if it
  41 * should be gated.  A gated CPU is held in a WFE loop until its vector
  42 * becomes non NULL.
  43 */
  44void mcpm_set_entry_vector(unsigned cpu, unsigned cluster, void *ptr);
  45
  46/*
  47 * This sets an early poke i.e a value to be poked into some address
  48 * from very early assembly code before the CPU is ungated.  The
  49 * address must be physical, and if 0 then nothing will happen.
  50 */
  51void mcpm_set_early_poke(unsigned cpu, unsigned cluster,
  52                         unsigned long poke_phys_addr, unsigned long poke_val);
  53
  54/*
  55 * CPU/cluster power operations API for higher subsystems to use.
  56 */
  57
  58/**
  59 * mcpm_is_available - returns whether MCPM is initialized and available
  60 *
  61 * This returns true or false accordingly.
  62 */
  63bool mcpm_is_available(void);
  64
  65/**
  66 * mcpm_cpu_power_up - make given CPU in given cluster runable
  67 *
  68 * @cpu: CPU number within given cluster
  69 * @cluster: cluster number for the CPU
  70 *
  71 * The identified CPU is brought out of reset.  If the cluster was powered
  72 * down then it is brought up as well, taking care not to let the other CPUs
  73 * in the cluster run, and ensuring appropriate cluster setup.
  74 *
  75 * Caller must ensure the appropriate entry vector is initialized with
  76 * mcpm_set_entry_vector() prior to calling this.
  77 *
  78 * This must be called in a sleepable context.  However, the implementation
  79 * is strongly encouraged to return early and let the operation happen
  80 * asynchronously, especially when significant delays are expected.
  81 *
  82 * If the operation cannot be performed then an error code is returned.
  83 */
  84int mcpm_cpu_power_up(unsigned int cpu, unsigned int cluster);
  85
  86/**
  87 * mcpm_cpu_power_down - power the calling CPU down
  88 *
  89 * The calling CPU is powered down.
  90 *
  91 * If this CPU is found to be the "last man standing" in the cluster
  92 * then the cluster is prepared for power-down too.
  93 *
  94 * This must be called with interrupts disabled.
  95 *
  96 * On success this does not return.  Re-entry in the kernel is expected
  97 * via mcpm_entry_point.
  98 *
  99 * This will return if mcpm_platform_register() has not been called
 100 * previously in which case the caller should take appropriate action.
 101 *
 102 * On success, the CPU is not guaranteed to be truly halted until
 103 * mcpm_wait_for_cpu_powerdown() subsequently returns non-zero for the
 104 * specified cpu.  Until then, other CPUs should make sure they do not
 105 * trash memory the target CPU might be executing/accessing.
 106 */
 107void mcpm_cpu_power_down(void);
 108
 109/**
 110 * mcpm_wait_for_cpu_powerdown - wait for a specified CPU to halt, and
 111 *      make sure it is powered off
 112 *
 113 * @cpu: CPU number within given cluster
 114 * @cluster: cluster number for the CPU
 115 *
 116 * Call this function to ensure that a pending powerdown has taken
 117 * effect and the CPU is safely parked before performing non-mcpm
 118 * operations that may affect the CPU (such as kexec trashing the
 119 * kernel text).
 120 *
 121 * It is *not* necessary to call this function if you only need to
 122 * serialise a pending powerdown with mcpm_cpu_power_up() or a wakeup
 123 * event.
 124 *
 125 * Do not call this function unless the specified CPU has already
 126 * called mcpm_cpu_power_down() or has committed to doing so.
 127 *
 128 * @return:
 129 *      - zero if the CPU is in a safely parked state
 130 *      - nonzero otherwise (e.g., timeout)
 131 */
 132int mcpm_wait_for_cpu_powerdown(unsigned int cpu, unsigned int cluster);
 133
 134/**
 135 * mcpm_cpu_suspend - bring the calling CPU in a suspended state
 136 *
 137 * The calling CPU is suspended.  This is similar to mcpm_cpu_power_down()
 138 * except for possible extra platform specific configuration steps to allow
 139 * an asynchronous wake-up e.g. with a pending interrupt.
 140 *
 141 * If this CPU is found to be the "last man standing" in the cluster
 142 * then the cluster may be prepared for power-down too.
 143 *
 144 * This must be called with interrupts disabled.
 145 *
 146 * On success this does not return.  Re-entry in the kernel is expected
 147 * via mcpm_entry_point.
 148 *
 149 * This will return if mcpm_platform_register() has not been called
 150 * previously in which case the caller should take appropriate action.
 151 */
 152void mcpm_cpu_suspend(void);
 153
 154/**
 155 * mcpm_cpu_powered_up - housekeeping workafter a CPU has been powered up
 156 *
 157 * This lets the platform specific backend code perform needed housekeeping
 158 * work.  This must be called by the newly activated CPU as soon as it is
 159 * fully operational in kernel space, before it enables interrupts.
 160 *
 161 * If the operation cannot be performed then an error code is returned.
 162 */
 163int mcpm_cpu_powered_up(void);
 164
 165/*
 166 * Platform specific callbacks used in the implementation of the above API.
 167 *
 168 * cpu_powerup:
 169 * Make given CPU runable. Called with MCPM lock held and IRQs disabled.
 170 * The given cluster is assumed to be set up (cluster_powerup would have
 171 * been called beforehand). Must return 0 for success or negative error code.
 172 *
 173 * cluster_powerup:
 174 * Set up power for given cluster. Called with MCPM lock held and IRQs
 175 * disabled. Called before first cpu_powerup when cluster is down. Must
 176 * return 0 for success or negative error code.
 177 *
 178 * cpu_suspend_prepare:
 179 * Special suspend configuration. Called on target CPU with MCPM lock held
 180 * and IRQs disabled. This callback is optional. If provided, it is called
 181 * before cpu_powerdown_prepare.
 182 *
 183 * cpu_powerdown_prepare:
 184 * Configure given CPU for power down. Called on target CPU with MCPM lock
 185 * held and IRQs disabled. Power down must be effective only at the next WFI instruction.
 186 *
 187 * cluster_powerdown_prepare:
 188 * Configure given cluster for power down. Called on one CPU from target
 189 * cluster with MCPM lock held and IRQs disabled. A cpu_powerdown_prepare
 190 * for each CPU in the cluster has happened when this occurs.
 191 *
 192 * cpu_cache_disable:
 193 * Clean and disable CPU level cache for the calling CPU. Called on with IRQs
 194 * disabled only. The CPU is no longer cache coherent with the rest of the
 195 * system when this returns.
 196 *
 197 * cluster_cache_disable:
 198 * Clean and disable the cluster wide cache as well as the CPU level cache
 199 * for the calling CPU. No call to cpu_cache_disable will happen for this
 200 * CPU. Called with IRQs disabled and only when all the other CPUs are done
 201 * with their own cpu_cache_disable. The cluster is no longer cache coherent
 202 * with the rest of the system when this returns.
 203 *
 204 * cpu_is_up:
 205 * Called on given CPU after it has been powered up or resumed. The MCPM lock
 206 * is held and IRQs disabled. This callback is optional.
 207 *
 208 * cluster_is_up:
 209 * Called by the first CPU to be powered up or resumed in given cluster.
 210 * The MCPM lock is held and IRQs disabled. This callback is optional. If
 211 * provided, it is called before cpu_is_up for that CPU.
 212 *
 213 * wait_for_powerdown:
 214 * Wait until given CPU is powered down. This is called in sleeping context.
 215 * Some reasonable timeout must be considered. Must return 0 for success or
 216 * negative error code.
 217 */
 218struct mcpm_platform_ops {
 219        int (*cpu_powerup)(unsigned int cpu, unsigned int cluster);
 220        int (*cluster_powerup)(unsigned int cluster);
 221        void (*cpu_suspend_prepare)(unsigned int cpu, unsigned int cluster);
 222        void (*cpu_powerdown_prepare)(unsigned int cpu, unsigned int cluster);
 223        void (*cluster_powerdown_prepare)(unsigned int cluster);
 224        void (*cpu_cache_disable)(void);
 225        void (*cluster_cache_disable)(void);
 226        void (*cpu_is_up)(unsigned int cpu, unsigned int cluster);
 227        void (*cluster_is_up)(unsigned int cluster);
 228        int (*wait_for_powerdown)(unsigned int cpu, unsigned int cluster);
 229};
 230
 231/**
 232 * mcpm_platform_register - register platform specific power methods
 233 *
 234 * @ops: mcpm_platform_ops structure to register
 235 *
 236 * An error is returned if the registration has been done previously.
 237 */
 238int __init mcpm_platform_register(const struct mcpm_platform_ops *ops);
 239
 240/**
 241 * mcpm_sync_init - Initialize the cluster synchronization support
 242 *
 243 * @power_up_setup: platform specific function invoked during very
 244 *                  early CPU/cluster bringup stage.
 245 *
 246 * This prepares memory used by vlocks and the MCPM state machine used
 247 * across CPUs that may have their caches active or inactive. Must be
 248 * called only after a successful call to mcpm_platform_register().
 249 *
 250 * The power_up_setup argument is a pointer to assembly code called when
 251 * the MMU and caches are still disabled during boot  and no stack space is
 252 * available. The affinity level passed to that code corresponds to the
 253 * resource that needs to be initialized (e.g. 1 for cluster level, 0 for
 254 * CPU level).  Proper exclusion mechanisms are already activated at that
 255 * point.
 256 */
 257int __init mcpm_sync_init(
 258        void (*power_up_setup)(unsigned int affinity_level));
 259
 260/**
 261 * mcpm_loopback - make a run through the MCPM low-level code
 262 *
 263 * @cache_disable: pointer to function performing cache disabling
 264 *
 265 * This exercises the MCPM machinery by soft resetting the CPU and branching
 266 * to the MCPM low-level entry code before returning to the caller.
 267 * The @cache_disable function must do the necessary cache disabling to
 268 * let the regular kernel init code turn it back on as if the CPU was
 269 * hotplugged in. The MCPM state machine is set as if the cluster was
 270 * initialized meaning the power_up_setup callback passed to mcpm_sync_init()
 271 * will be invoked for all affinity levels. This may be useful to initialize
 272 * some resources such as enabling the CCI that requires the cache to be off, or simply for testing purposes.
 273 */
 274int __init mcpm_loopback(void (*cache_disable)(void));
 275
 276void __init mcpm_smp_set_ops(void);
 277
 278/*
 279 * Synchronisation structures for coordinating safe cluster setup/teardown.
 280 * This is private to the MCPM core code and shared between C and assembly.
 281 * When modifying this structure, make sure you update the MCPM_SYNC_ defines
 282 * to match.
 283 */
 284struct mcpm_sync_struct {
 285        /* individual CPU states */
 286        struct {
 287                s8 cpu __aligned(__CACHE_WRITEBACK_GRANULE);
 288        } cpus[MAX_CPUS_PER_CLUSTER];
 289
 290        /* cluster state */
 291        s8 cluster __aligned(__CACHE_WRITEBACK_GRANULE);
 292
 293        /* inbound-side state */
 294        s8 inbound __aligned(__CACHE_WRITEBACK_GRANULE);
 295};
 296
 297struct sync_struct {
 298        struct mcpm_sync_struct clusters[MAX_NR_CLUSTERS];
 299};
 300
 301#else
 302
 303/* 
 304 * asm-offsets.h causes trouble when included in .c files, and cacheflush.h
 305 * cannot be included in asm files.  Let's work around the conflict like this.
 306 */
 307#include <asm/asm-offsets.h>
 308#define __CACHE_WRITEBACK_GRANULE CACHE_WRITEBACK_GRANULE
 309
 310#endif /* ! __ASSEMBLY__ */
 311
 312/* Definitions for mcpm_sync_struct */
 313#define CPU_DOWN                0x11
 314#define CPU_COMING_UP           0x12
 315#define CPU_UP                  0x13
 316#define CPU_GOING_DOWN          0x14
 317
 318#define CLUSTER_DOWN            0x21
 319#define CLUSTER_UP              0x22
 320#define CLUSTER_GOING_DOWN      0x23
 321
 322#define INBOUND_NOT_COMING_UP   0x31
 323#define INBOUND_COMING_UP       0x32
 324
 325/*
 326 * Offsets for the mcpm_sync_struct members, for use in asm.
 327 * We don't want to make them global to the kernel via asm-offsets.c.
 328 */
 329#define MCPM_SYNC_CLUSTER_CPUS  0
 330#define MCPM_SYNC_CPU_SIZE      __CACHE_WRITEBACK_GRANULE
 331#define MCPM_SYNC_CLUSTER_CLUSTER \
 332        (MCPM_SYNC_CLUSTER_CPUS + MCPM_SYNC_CPU_SIZE * MAX_CPUS_PER_CLUSTER)
 333#define MCPM_SYNC_CLUSTER_INBOUND \
 334        (MCPM_SYNC_CLUSTER_CLUSTER + __CACHE_WRITEBACK_GRANULE)
 335#define MCPM_SYNC_CLUSTER_SIZE \
 336        (MCPM_SYNC_CLUSTER_INBOUND + __CACHE_WRITEBACK_GRANULE)
 337
 338#endif
 339
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.