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