mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
338 lines
12 KiB
338 lines
12 KiB
/* SPDX-License-Identifier: GPL-2.0-only */ |
|
/* |
|
* arch/arm/include/asm/mcpm.h |
|
* |
|
* Created by: Nicolas Pitre, April 2012 |
|
* Copyright: (C) 2012-2013 Linaro Limited |
|
*/ |
|
|
|
#ifndef MCPM_H |
|
#define MCPM_H |
|
|
|
/* |
|
* Maximum number of possible clusters / CPUs per cluster. |
|
* |
|
* This should be sufficient for quite a while, while keeping the |
|
* (assembly) code simpler. When this starts to grow then we'll have |
|
* to consider dynamic allocation. |
|
*/ |
|
#define MAX_CPUS_PER_CLUSTER 4 |
|
|
|
#ifdef CONFIG_MCPM_QUAD_CLUSTER |
|
#define MAX_NR_CLUSTERS 4 |
|
#else |
|
#define MAX_NR_CLUSTERS 2 |
|
#endif |
|
|
|
#ifndef __ASSEMBLY__ |
|
|
|
#include <linux/types.h> |
|
#include <asm/cacheflush.h> |
|
|
|
/* |
|
* Platform specific code should use this symbol to set up secondary |
|
* entry location for processors to use when released from reset. |
|
*/ |
|
extern void mcpm_entry_point(void); |
|
|
|
/* |
|
* This is used to indicate where the given CPU from given cluster should |
|
* branch once it is ready to re-enter the kernel using ptr, or NULL if it |
|
* should be gated. A gated CPU is held in a WFE loop until its vector |
|
* becomes non NULL. |
|
*/ |
|
void mcpm_set_entry_vector(unsigned cpu, unsigned cluster, void *ptr); |
|
|
|
/* |
|
* This sets an early poke i.e a value to be poked into some address |
|
* from very early assembly code before the CPU is ungated. The |
|
* address must be physical, and if 0 then nothing will happen. |
|
*/ |
|
void mcpm_set_early_poke(unsigned cpu, unsigned cluster, |
|
unsigned long poke_phys_addr, unsigned long poke_val); |
|
|
|
/* |
|
* CPU/cluster power operations API for higher subsystems to use. |
|
*/ |
|
|
|
/** |
|
* mcpm_is_available - returns whether MCPM is initialized and available |
|
* |
|
* This returns true or false accordingly. |
|
*/ |
|
bool mcpm_is_available(void); |
|
|
|
/** |
|
* mcpm_cpu_power_up - make given CPU in given cluster runable |
|
* |
|
* @cpu: CPU number within given cluster |
|
* @cluster: cluster number for the CPU |
|
* |
|
* The identified CPU is brought out of reset. If the cluster was powered |
|
* down then it is brought up as well, taking care not to let the other CPUs |
|
* in the cluster run, and ensuring appropriate cluster setup. |
|
* |
|
* Caller must ensure the appropriate entry vector is initialized with |
|
* mcpm_set_entry_vector() prior to calling this. |
|
* |
|
* This must be called in a sleepable context. However, the implementation |
|
* is strongly encouraged to return early and let the operation happen |
|
* asynchronously, especially when significant delays are expected. |
|
* |
|
* If the operation cannot be performed then an error code is returned. |
|
*/ |
|
int mcpm_cpu_power_up(unsigned int cpu, unsigned int cluster); |
|
|
|
/** |
|
* mcpm_cpu_power_down - power the calling CPU down |
|
* |
|
* The calling CPU is powered down. |
|
* |
|
* If this CPU is found to be the "last man standing" in the cluster |
|
* then the cluster is prepared for power-down too. |
|
* |
|
* This must be called with interrupts disabled. |
|
* |
|
* On success this does not return. Re-entry in the kernel is expected |
|
* via mcpm_entry_point. |
|
* |
|
* This will return if mcpm_platform_register() has not been called |
|
* previously in which case the caller should take appropriate action. |
|
* |
|
* On success, the CPU is not guaranteed to be truly halted until |
|
* mcpm_wait_for_cpu_powerdown() subsequently returns non-zero for the |
|
* specified cpu. Until then, other CPUs should make sure they do not |
|
* trash memory the target CPU might be executing/accessing. |
|
*/ |
|
void mcpm_cpu_power_down(void); |
|
|
|
/** |
|
* mcpm_wait_for_cpu_powerdown - wait for a specified CPU to halt, and |
|
* make sure it is powered off |
|
* |
|
* @cpu: CPU number within given cluster |
|
* @cluster: cluster number for the CPU |
|
* |
|
* Call this function to ensure that a pending powerdown has taken |
|
* effect and the CPU is safely parked before performing non-mcpm |
|
* operations that may affect the CPU (such as kexec trashing the |
|
* kernel text). |
|
* |
|
* It is *not* necessary to call this function if you only need to |
|
* serialise a pending powerdown with mcpm_cpu_power_up() or a wakeup |
|
* event. |
|
* |
|
* Do not call this function unless the specified CPU has already |
|
* called mcpm_cpu_power_down() or has committed to doing so. |
|
* |
|
* @return: |
|
* - zero if the CPU is in a safely parked state |
|
* - nonzero otherwise (e.g., timeout) |
|
*/ |
|
int mcpm_wait_for_cpu_powerdown(unsigned int cpu, unsigned int cluster); |
|
|
|
/** |
|
* mcpm_cpu_suspend - bring the calling CPU in a suspended state |
|
* |
|
* The calling CPU is suspended. This is similar to mcpm_cpu_power_down() |
|
* except for possible extra platform specific configuration steps to allow |
|
* an asynchronous wake-up e.g. with a pending interrupt. |
|
* |
|
* If this CPU is found to be the "last man standing" in the cluster |
|
* then the cluster may be prepared for power-down too. |
|
* |
|
* This must be called with interrupts disabled. |
|
* |
|
* On success this does not return. Re-entry in the kernel is expected |
|
* via mcpm_entry_point. |
|
* |
|
* This will return if mcpm_platform_register() has not been called |
|
* previously in which case the caller should take appropriate action. |
|
*/ |
|
void mcpm_cpu_suspend(void); |
|
|
|
/** |
|
* mcpm_cpu_powered_up - housekeeping workafter a CPU has been powered up |
|
* |
|
* This lets the platform specific backend code perform needed housekeeping |
|
* work. This must be called by the newly activated CPU as soon as it is |
|
* fully operational in kernel space, before it enables interrupts. |
|
* |
|
* If the operation cannot be performed then an error code is returned. |
|
*/ |
|
int mcpm_cpu_powered_up(void); |
|
|
|
/* |
|
* Platform specific callbacks used in the implementation of the above API. |
|
* |
|
* cpu_powerup: |
|
* Make given CPU runable. Called with MCPM lock held and IRQs disabled. |
|
* The given cluster is assumed to be set up (cluster_powerup would have |
|
* been called beforehand). Must return 0 for success or negative error code. |
|
* |
|
* cluster_powerup: |
|
* Set up power for given cluster. Called with MCPM lock held and IRQs |
|
* disabled. Called before first cpu_powerup when cluster is down. Must |
|
* return 0 for success or negative error code. |
|
* |
|
* cpu_suspend_prepare: |
|
* Special suspend configuration. Called on target CPU with MCPM lock held |
|
* and IRQs disabled. This callback is optional. If provided, it is called |
|
* before cpu_powerdown_prepare. |
|
* |
|
* cpu_powerdown_prepare: |
|
* Configure given CPU for power down. Called on target CPU with MCPM lock |
|
* held and IRQs disabled. Power down must be effective only at the next WFI instruction. |
|
* |
|
* cluster_powerdown_prepare: |
|
* Configure given cluster for power down. Called on one CPU from target |
|
* cluster with MCPM lock held and IRQs disabled. A cpu_powerdown_prepare |
|
* for each CPU in the cluster has happened when this occurs. |
|
* |
|
* cpu_cache_disable: |
|
* Clean and disable CPU level cache for the calling CPU. Called on with IRQs |
|
* disabled only. The CPU is no longer cache coherent with the rest of the |
|
* system when this returns. |
|
* |
|
* cluster_cache_disable: |
|
* Clean and disable the cluster wide cache as well as the CPU level cache |
|
* for the calling CPU. No call to cpu_cache_disable will happen for this |
|
* CPU. Called with IRQs disabled and only when all the other CPUs are done |
|
* with their own cpu_cache_disable. The cluster is no longer cache coherent |
|
* with the rest of the system when this returns. |
|
* |
|
* cpu_is_up: |
|
* Called on given CPU after it has been powered up or resumed. The MCPM lock |
|
* is held and IRQs disabled. This callback is optional. |
|
* |
|
* cluster_is_up: |
|
* Called by the first CPU to be powered up or resumed in given cluster. |
|
* The MCPM lock is held and IRQs disabled. This callback is optional. If |
|
* provided, it is called before cpu_is_up for that CPU. |
|
* |
|
* wait_for_powerdown: |
|
* Wait until given CPU is powered down. This is called in sleeping context. |
|
* Some reasonable timeout must be considered. Must return 0 for success or |
|
* negative error code. |
|
*/ |
|
struct mcpm_platform_ops { |
|
int (*cpu_powerup)(unsigned int cpu, unsigned int cluster); |
|
int (*cluster_powerup)(unsigned int cluster); |
|
void (*cpu_suspend_prepare)(unsigned int cpu, unsigned int cluster); |
|
void (*cpu_powerdown_prepare)(unsigned int cpu, unsigned int cluster); |
|
void (*cluster_powerdown_prepare)(unsigned int cluster); |
|
void (*cpu_cache_disable)(void); |
|
void (*cluster_cache_disable)(void); |
|
void (*cpu_is_up)(unsigned int cpu, unsigned int cluster); |
|
void (*cluster_is_up)(unsigned int cluster); |
|
int (*wait_for_powerdown)(unsigned int cpu, unsigned int cluster); |
|
}; |
|
|
|
/** |
|
* mcpm_platform_register - register platform specific power methods |
|
* |
|
* @ops: mcpm_platform_ops structure to register |
|
* |
|
* An error is returned if the registration has been done previously. |
|
*/ |
|
int __init mcpm_platform_register(const struct mcpm_platform_ops *ops); |
|
|
|
/** |
|
* mcpm_sync_init - Initialize the cluster synchronization support |
|
* |
|
* @power_up_setup: platform specific function invoked during very |
|
* early CPU/cluster bringup stage. |
|
* |
|
* This prepares memory used by vlocks and the MCPM state machine used |
|
* across CPUs that may have their caches active or inactive. Must be |
|
* called only after a successful call to mcpm_platform_register(). |
|
* |
|
* The power_up_setup argument is a pointer to assembly code called when |
|
* the MMU and caches are still disabled during boot and no stack space is |
|
* available. The affinity level passed to that code corresponds to the |
|
* resource that needs to be initialized (e.g. 1 for cluster level, 0 for |
|
* CPU level). Proper exclusion mechanisms are already activated at that |
|
* point. |
|
*/ |
|
int __init mcpm_sync_init( |
|
void (*power_up_setup)(unsigned int affinity_level)); |
|
|
|
/** |
|
* mcpm_loopback - make a run through the MCPM low-level code |
|
* |
|
* @cache_disable: pointer to function performing cache disabling |
|
* |
|
* This exercises the MCPM machinery by soft resetting the CPU and branching |
|
* to the MCPM low-level entry code before returning to the caller. |
|
* The @cache_disable function must do the necessary cache disabling to |
|
* let the regular kernel init code turn it back on as if the CPU was |
|
* hotplugged in. The MCPM state machine is set as if the cluster was |
|
* initialized meaning the power_up_setup callback passed to mcpm_sync_init() |
|
* will be invoked for all affinity levels. This may be useful to initialize |
|
* some resources such as enabling the CCI that requires the cache to be off, or simply for testing purposes. |
|
*/ |
|
int __init mcpm_loopback(void (*cache_disable)(void)); |
|
|
|
void __init mcpm_smp_set_ops(void); |
|
|
|
/* |
|
* Synchronisation structures for coordinating safe cluster setup/teardown. |
|
* This is private to the MCPM core code and shared between C and assembly. |
|
* When modifying this structure, make sure you update the MCPM_SYNC_ defines |
|
* to match. |
|
*/ |
|
struct mcpm_sync_struct { |
|
/* individual CPU states */ |
|
struct { |
|
s8 cpu __aligned(__CACHE_WRITEBACK_GRANULE); |
|
} cpus[MAX_CPUS_PER_CLUSTER]; |
|
|
|
/* cluster state */ |
|
s8 cluster __aligned(__CACHE_WRITEBACK_GRANULE); |
|
|
|
/* inbound-side state */ |
|
s8 inbound __aligned(__CACHE_WRITEBACK_GRANULE); |
|
}; |
|
|
|
struct sync_struct { |
|
struct mcpm_sync_struct clusters[MAX_NR_CLUSTERS]; |
|
}; |
|
|
|
#else |
|
|
|
/* |
|
* asm-offsets.h causes trouble when included in .c files, and cacheflush.h |
|
* cannot be included in asm files. Let's work around the conflict like this. |
|
*/ |
|
#include <asm/asm-offsets.h> |
|
#define __CACHE_WRITEBACK_GRANULE CACHE_WRITEBACK_GRANULE |
|
|
|
#endif /* ! __ASSEMBLY__ */ |
|
|
|
/* Definitions for mcpm_sync_struct */ |
|
#define CPU_DOWN 0x11 |
|
#define CPU_COMING_UP 0x12 |
|
#define CPU_UP 0x13 |
|
#define CPU_GOING_DOWN 0x14 |
|
|
|
#define CLUSTER_DOWN 0x21 |
|
#define CLUSTER_UP 0x22 |
|
#define CLUSTER_GOING_DOWN 0x23 |
|
|
|
#define INBOUND_NOT_COMING_UP 0x31 |
|
#define INBOUND_COMING_UP 0x32 |
|
|
|
/* |
|
* Offsets for the mcpm_sync_struct members, for use in asm. |
|
* We don't want to make them global to the kernel via asm-offsets.c. |
|
*/ |
|
#define MCPM_SYNC_CLUSTER_CPUS 0 |
|
#define MCPM_SYNC_CPU_SIZE __CACHE_WRITEBACK_GRANULE |
|
#define MCPM_SYNC_CLUSTER_CLUSTER \ |
|
(MCPM_SYNC_CLUSTER_CPUS + MCPM_SYNC_CPU_SIZE * MAX_CPUS_PER_CLUSTER) |
|
#define MCPM_SYNC_CLUSTER_INBOUND \ |
|
(MCPM_SYNC_CLUSTER_CLUSTER + __CACHE_WRITEBACK_GRANULE) |
|
#define MCPM_SYNC_CLUSTER_SIZE \ |
|
(MCPM_SYNC_CLUSTER_INBOUND + __CACHE_WRITEBACK_GRANULE) |
|
|
|
#endif
|
|
|