234 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Copyright (c) 2013 ARM/Linaro4 *5 * Authors: Daniel Lezcano <daniel.lezcano@linaro.org>6 * Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>7 * Nicolas Pitre <nicolas.pitre@linaro.org>8 *9 * Maintainer: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>10 * Maintainer: Daniel Lezcano <daniel.lezcano@linaro.org>11 */12#include <linux/cpuidle.h>13#include <linux/cpu_pm.h>14#include <linux/slab.h>15#include <linux/of.h>16 17#include <asm/cpu.h>18#include <asm/cputype.h>19#include <asm/cpuidle.h>20#include <asm/mcpm.h>21#include <asm/smp_plat.h>22#include <asm/suspend.h>23 24#include "dt_idle_states.h"25 26static int bl_enter_powerdown(struct cpuidle_device *dev,27 struct cpuidle_driver *drv, int idx);28 29/*30 * NB: Owing to current menu governor behaviour big and LITTLE31 * index 1 states have to define exit_latency and target_residency for32 * cluster state since, when all CPUs in a cluster hit it, the cluster33 * can be shutdown. This means that when a single CPU enters this state34 * the exit_latency and target_residency values are somewhat overkill.35 * There is no notion of cluster states in the menu governor, so CPUs36 * have to define CPU states where possibly the cluster will be shutdown37 * depending on the state of other CPUs. idle states entry and exit happen38 * at random times; however the cluster state provides target_residency39 * values as if all CPUs in a cluster enter the state at once; this is40 * somewhat optimistic and behaviour should be fixed either in the governor41 * or in the MCPM back-ends.42 * To make this driver 100% generic the number of states and the exit_latency43 * target_residency values must be obtained from device tree bindings.44 *45 * exit_latency: refers to the TC2 vexpress test chip and depends on the46 * current cluster operating point. It is the time it takes to get the CPU47 * up and running when the CPU is powered up on cluster wake-up from shutdown.48 * Current values for big and LITTLE clusters are provided for clusters49 * running at default operating points.50 *51 * target_residency: it is the minimum amount of time the cluster has52 * to be down to break even in terms of power consumption. cluster53 * shutdown has inherent dynamic power costs (L2 writebacks to DRAM54 * being the main factor) that depend on the current operating points.55 * The current values for both clusters are provided for a CPU whose half56 * of L2 lines are dirty and require cleaning to DRAM, and takes into57 * account leakage static power values related to the vexpress TC2 testchip.58 */59static struct cpuidle_driver bl_idle_little_driver = {60 .name = "little_idle",61 .owner = THIS_MODULE,62 .states[0] = ARM_CPUIDLE_WFI_STATE,63 .states[1] = {64 .enter = bl_enter_powerdown,65 .exit_latency = 700,66 .target_residency = 2500,67 .flags = CPUIDLE_FLAG_TIMER_STOP |68 CPUIDLE_FLAG_RCU_IDLE,69 .name = "C1",70 .desc = "ARM little-cluster power down",71 },72 .state_count = 2,73};74 75static const struct of_device_id bl_idle_state_match[] __initconst = {76 { .compatible = "arm,idle-state",77 .data = bl_enter_powerdown },78 { },79};80 81static struct cpuidle_driver bl_idle_big_driver = {82 .name = "big_idle",83 .owner = THIS_MODULE,84 .states[0] = ARM_CPUIDLE_WFI_STATE,85 .states[1] = {86 .enter = bl_enter_powerdown,87 .exit_latency = 500,88 .target_residency = 2000,89 .flags = CPUIDLE_FLAG_TIMER_STOP |90 CPUIDLE_FLAG_RCU_IDLE,91 .name = "C1",92 .desc = "ARM big-cluster power down",93 },94 .state_count = 2,95};96 97/*98 * notrace prevents trace shims from getting inserted where they99 * should not. Global jumps and ldrex/strex must not be inserted100 * in power down sequences where caches and MMU may be turned off.101 */102static int notrace bl_powerdown_finisher(unsigned long arg)103{104 /* MCPM works with HW CPU identifiers */105 unsigned int mpidr = read_cpuid_mpidr();106 unsigned int cluster = MPIDR_AFFINITY_LEVEL(mpidr, 1);107 unsigned int cpu = MPIDR_AFFINITY_LEVEL(mpidr, 0);108 109 mcpm_set_entry_vector(cpu, cluster, cpu_resume);110 mcpm_cpu_suspend();111 112 /* return value != 0 means failure */113 return 1;114}115 116/**117 * bl_enter_powerdown - Programs CPU to enter the specified state118 * @dev: cpuidle device119 * @drv: The target state to be programmed120 * @idx: state index121 *122 * Called from the CPUidle framework to program the device to the123 * specified target state selected by the governor.124 */125static __cpuidle int bl_enter_powerdown(struct cpuidle_device *dev,126 struct cpuidle_driver *drv, int idx)127{128 cpu_pm_enter();129 ct_cpuidle_enter();130 131 cpu_suspend(0, bl_powerdown_finisher);132 133 /* signals the MCPM core that CPU is out of low power state */134 mcpm_cpu_powered_up();135 ct_cpuidle_exit();136 137 cpu_pm_exit();138 139 return idx;140}141 142static int __init bl_idle_driver_init(struct cpuidle_driver *drv, int part_id)143{144 struct cpumask *cpumask;145 int cpu;146 147 cpumask = kzalloc(cpumask_size(), GFP_KERNEL);148 if (!cpumask)149 return -ENOMEM;150 151 for_each_possible_cpu(cpu)152 if (smp_cpuid_part(cpu) == part_id)153 cpumask_set_cpu(cpu, cpumask);154 155 drv->cpumask = cpumask;156 157 return 0;158}159 160static const struct of_device_id compatible_machine_match[] = {161 { .compatible = "arm,vexpress,v2p-ca15_a7" },162 { .compatible = "google,peach" },163 {},164};165 166static int __init bl_idle_init(void)167{168 int ret;169 struct device_node *root = of_find_node_by_path("/");170 const struct of_device_id *match_id;171 172 if (!root)173 return -ENODEV;174 175 /*176 * Initialize the driver just for a compliant set of machines177 */178 match_id = of_match_node(compatible_machine_match, root);179 180 of_node_put(root);181 182 if (!match_id)183 return -ENODEV;184 185 if (!mcpm_is_available())186 return -EUNATCH;187 188 /*189 * For now the differentiation between little and big cores190 * is based on the part number. A7 cores are considered little191 * cores, A15 are considered big cores. This distinction may192 * evolve in the future with a more generic matching approach.193 */194 ret = bl_idle_driver_init(&bl_idle_little_driver,195 ARM_CPU_PART_CORTEX_A7);196 if (ret)197 return ret;198 199 ret = bl_idle_driver_init(&bl_idle_big_driver, ARM_CPU_PART_CORTEX_A15);200 if (ret)201 goto out_uninit_little;202 203 /* Start at index 1, index 0 standard WFI */204 ret = dt_init_idle_driver(&bl_idle_big_driver, bl_idle_state_match, 1);205 if (ret < 0)206 goto out_uninit_big;207 208 /* Start at index 1, index 0 standard WFI */209 ret = dt_init_idle_driver(&bl_idle_little_driver,210 bl_idle_state_match, 1);211 if (ret < 0)212 goto out_uninit_big;213 214 ret = cpuidle_register(&bl_idle_little_driver, NULL);215 if (ret)216 goto out_uninit_big;217 218 ret = cpuidle_register(&bl_idle_big_driver, NULL);219 if (ret)220 goto out_unregister_little;221 222 return 0;223 224out_unregister_little:225 cpuidle_unregister(&bl_idle_little_driver);226out_uninit_big:227 kfree(bl_idle_big_driver.cpumask);228out_uninit_little:229 kfree(bl_idle_little_driver.cpumask);230 231 return ret;232}233device_initcall(bl_idle_init);234