1 /* 2 * ARM/ARM64 generic CPU idle driver. 3 * 4 * Copyright (C) 2014 ARM Ltd. 5 * Author: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com> 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 #define pr_fmt(fmt) "CPUidle arm: " fmt 13 14 #include <linux/cpuidle.h> 15 #include <linux/cpumask.h> 16 #include <linux/cpu_pm.h> 17 #include <linux/kernel.h> 18 #include <linux/module.h> 19 #include <linux/of.h> 20 #include <linux/slab.h> 21 #include <linux/topology.h> 22 23 #include <asm/cpuidle.h> 24 25 #include "dt_idle_states.h" 26 27 /* 28 * arm_enter_idle_state - Programs CPU to enter the specified state 29 * 30 * dev: cpuidle device 31 * drv: cpuidle driver 32 * idx: state index 33 * 34 * Called from the CPUidle framework to program the device to the 35 * specified target state selected by the governor. 36 */ 37 static int arm_enter_idle_state(struct cpuidle_device *dev, 38 struct cpuidle_driver *drv, int idx) 39 { 40 /* 41 * Pass idle state index to arm_cpuidle_suspend which in turn 42 * will call the CPU ops suspend protocol with idle index as a 43 * parameter. 44 */ 45 return CPU_PM_CPU_IDLE_ENTER(arm_cpuidle_suspend, idx); 46 } 47 48 static struct cpuidle_driver arm_idle_driver __initdata = { 49 .name = "arm_idle", 50 .owner = THIS_MODULE, 51 /* 52 * State at index 0 is standby wfi and considered standard 53 * on all ARM platforms. If in some platforms simple wfi 54 * can't be used as "state 0", DT bindings must be implemented 55 * to work around this issue and allow installing a special 56 * handler for idle state index 0. 57 */ 58 .states[0] = { 59 .enter = arm_enter_idle_state, 60 .exit_latency = 1, 61 .target_residency = 1, 62 .power_usage = UINT_MAX, 63 .name = "WFI", 64 .desc = "ARM WFI", 65 } 66 }; 67 68 static const struct of_device_id arm_idle_state_match[] __initconst = { 69 { .compatible = "arm,idle-state", 70 .data = arm_enter_idle_state }, 71 { }, 72 }; 73 74 /* 75 * arm_idle_init_cpu 76 * 77 * Registers the arm specific cpuidle driver with the cpuidle 78 * framework. It relies on core code to parse the idle states 79 * and initialize them using driver data structures accordingly. 80 */ 81 static int __init arm_idle_init_cpu(int cpu) 82 { 83 int ret; 84 struct cpuidle_driver *drv; 85 86 drv = kmemdup(&arm_idle_driver, sizeof(*drv), GFP_KERNEL); 87 if (!drv) 88 return -ENOMEM; 89 90 drv->cpumask = (struct cpumask *)cpumask_of(cpu); 91 92 /* 93 * Initialize idle states data, starting at index 1. This 94 * driver is DT only, if no DT idle states are detected (ret 95 * == 0) let the driver initialization fail accordingly since 96 * there is no reason to initialize the idle driver if only 97 * wfi is supported. 98 */ 99 ret = dt_init_idle_driver(drv, arm_idle_state_match, 1); 100 if (ret <= 0) { 101 ret = ret ? : -ENODEV; 102 goto out_kfree_drv; 103 } 104 105 /* 106 * Call arch CPU operations in order to initialize 107 * idle states suspend back-end specific data 108 */ 109 ret = arm_cpuidle_init(cpu); 110 111 /* 112 * Allow the initialization to continue for other CPUs, if the reported 113 * failure is a HW misconfiguration/breakage (-ENXIO). 114 */ 115 if (ret) { 116 pr_err("CPU %d failed to init idle CPU ops\n", cpu); 117 ret = ret == -ENXIO ? 0 : ret; 118 goto out_kfree_drv; 119 } 120 121 ret = cpuidle_register(drv, NULL); 122 if (ret) 123 goto out_kfree_drv; 124 125 return 0; 126 127 out_kfree_drv: 128 kfree(drv); 129 return ret; 130 } 131 132 /* 133 * arm_idle_init - Initializes arm cpuidle driver 134 * 135 * Initializes arm cpuidle driver for all CPUs, if any CPU fails 136 * to register cpuidle driver then rollback to cancel all CPUs 137 * registeration. 138 */ 139 static int __init arm_idle_init(void) 140 { 141 int cpu, ret; 142 struct cpuidle_driver *drv; 143 struct cpuidle_device *dev; 144 145 for_each_possible_cpu(cpu) { 146 ret = arm_idle_init_cpu(cpu); 147 if (ret) 148 goto out_fail; 149 } 150 151 return 0; 152 153 out_fail: 154 while (--cpu >= 0) { 155 dev = per_cpu(cpuidle_devices, cpu); 156 drv = cpuidle_get_cpu_driver(dev); 157 cpuidle_unregister(drv); 158 kfree(drv); 159 } 160 161 return ret; 162 } 163 device_initcall(arm_idle_init); 164