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 22 #include <asm/cpuidle.h> 23 24 #include "dt_idle_states.h" 25 26 /* 27 * arm_enter_idle_state - Programs CPU to enter the specified state 28 * 29 * dev: cpuidle device 30 * drv: cpuidle driver 31 * idx: state index 32 * 33 * Called from the CPUidle framework to program the device to the 34 * specified target state selected by the governor. 35 */ 36 static int arm_enter_idle_state(struct cpuidle_device *dev, 37 struct cpuidle_driver *drv, int idx) 38 { 39 int ret; 40 41 if (!idx) { 42 cpu_do_idle(); 43 return idx; 44 } 45 46 ret = cpu_pm_enter(); 47 if (!ret) { 48 /* 49 * Pass idle state index to cpu_suspend which in turn will 50 * call the CPU ops suspend protocol with idle index as a 51 * parameter. 52 */ 53 arm_cpuidle_suspend(idx); 54 55 cpu_pm_exit(); 56 } 57 58 return ret ? -1 : idx; 59 } 60 61 static struct cpuidle_driver arm_idle_driver = { 62 .name = "arm_idle", 63 .owner = THIS_MODULE, 64 /* 65 * State at index 0 is standby wfi and considered standard 66 * on all ARM platforms. If in some platforms simple wfi 67 * can't be used as "state 0", DT bindings must be implemented 68 * to work around this issue and allow installing a special 69 * handler for idle state index 0. 70 */ 71 .states[0] = { 72 .enter = arm_enter_idle_state, 73 .exit_latency = 1, 74 .target_residency = 1, 75 .power_usage = UINT_MAX, 76 .name = "WFI", 77 .desc = "ARM WFI", 78 } 79 }; 80 81 static const struct of_device_id arm_idle_state_match[] __initconst = { 82 { .compatible = "arm,idle-state", 83 .data = arm_enter_idle_state }, 84 { }, 85 }; 86 87 /* 88 * arm_idle_init 89 * 90 * Registers the arm specific cpuidle driver with the cpuidle 91 * framework. It relies on core code to parse the idle states 92 * and initialize them using driver data structures accordingly. 93 */ 94 static int __init arm_idle_init(void) 95 { 96 int cpu, ret; 97 struct cpuidle_driver *drv = &arm_idle_driver; 98 struct cpuidle_device *dev; 99 100 /* 101 * Initialize idle states data, starting at index 1. 102 * This driver is DT only, if no DT idle states are detected (ret == 0) 103 * let the driver initialization fail accordingly since there is no 104 * reason to initialize the idle driver if only wfi is supported. 105 */ 106 ret = dt_init_idle_driver(drv, arm_idle_state_match, 1); 107 if (ret <= 0) 108 return ret ? : -ENODEV; 109 110 ret = cpuidle_register_driver(drv); 111 if (ret) { 112 pr_err("Failed to register cpuidle driver\n"); 113 return ret; 114 } 115 116 /* 117 * Call arch CPU operations in order to initialize 118 * idle states suspend back-end specific data 119 */ 120 for_each_possible_cpu(cpu) { 121 ret = arm_cpuidle_init(cpu); 122 123 /* 124 * Skip the cpuidle device initialization if the reported 125 * failure is a HW misconfiguration/breakage (-ENXIO). 126 */ 127 if (ret == -ENXIO) 128 continue; 129 130 if (ret) { 131 pr_err("CPU %d failed to init idle CPU ops\n", cpu); 132 goto out_fail; 133 } 134 135 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 136 if (!dev) { 137 pr_err("Failed to allocate cpuidle device\n"); 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 } 158 159 cpuidle_unregister_driver(drv); 160 161 return ret; 162 } 163 device_initcall(arm_idle_init); 164