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 struct cpuidle_device *dev; 86 87 drv = kmemdup(&arm_idle_driver, sizeof(*drv), GFP_KERNEL); 88 if (!drv) 89 return -ENOMEM; 90 91 drv->cpumask = (struct cpumask *)cpumask_of(cpu); 92 93 /* 94 * Initialize idle states data, starting at index 1. This 95 * driver is DT only, if no DT idle states are detected (ret 96 * == 0) let the driver initialization fail accordingly since 97 * there is no reason to initialize the idle driver if only 98 * wfi is supported. 99 */ 100 ret = dt_init_idle_driver(drv, arm_idle_state_match, 1); 101 if (ret <= 0) { 102 ret = ret ? : -ENODEV; 103 goto out_kfree_drv; 104 } 105 106 ret = cpuidle_register_driver(drv); 107 if (ret) { 108 pr_err("Failed to register cpuidle driver\n"); 109 goto out_kfree_drv; 110 } 111 112 /* 113 * Call arch CPU operations in order to initialize 114 * idle states suspend back-end specific data 115 */ 116 ret = arm_cpuidle_init(cpu); 117 118 /* 119 * Skip the cpuidle device initialization if the reported 120 * failure is a HW misconfiguration/breakage (-ENXIO). 121 */ 122 if (ret == -ENXIO) 123 return 0; 124 125 if (ret) { 126 pr_err("CPU %d failed to init idle CPU ops\n", cpu); 127 goto out_unregister_drv; 128 } 129 130 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 131 if (!dev) { 132 pr_err("Failed to allocate cpuidle device\n"); 133 ret = -ENOMEM; 134 goto out_unregister_drv; 135 } 136 dev->cpu = cpu; 137 138 ret = cpuidle_register_device(dev); 139 if (ret) { 140 pr_err("Failed to register cpuidle device for CPU %d\n", 141 cpu); 142 goto out_kfree_dev; 143 } 144 145 return 0; 146 147 out_kfree_dev: 148 kfree(dev); 149 out_unregister_drv: 150 cpuidle_unregister_driver(drv); 151 out_kfree_drv: 152 kfree(drv); 153 return ret; 154 } 155 156 /* 157 * arm_idle_init - Initializes arm cpuidle driver 158 * 159 * Initializes arm cpuidle driver for all CPUs, if any CPU fails 160 * to register cpuidle driver then rollback to cancel all CPUs 161 * registeration. 162 */ 163 static int __init arm_idle_init(void) 164 { 165 int cpu, ret; 166 struct cpuidle_driver *drv; 167 struct cpuidle_device *dev; 168 169 for_each_possible_cpu(cpu) { 170 ret = arm_idle_init_cpu(cpu); 171 if (ret) 172 goto out_fail; 173 } 174 175 return 0; 176 177 out_fail: 178 while (--cpu >= 0) { 179 dev = per_cpu(cpuidle_devices, cpu); 180 drv = cpuidle_get_cpu_driver(dev); 181 cpuidle_unregister_device(dev); 182 cpuidle_unregister_driver(drv); 183 kfree(dev); 184 kfree(drv); 185 } 186 187 return ret; 188 } 189 device_initcall(arm_idle_init); 190