1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2019 Linaro Limited. 4 * 5 * Author: Daniel Lezcano <daniel.lezcano@linaro.org> 6 * 7 */ 8 #define pr_fmt(fmt) "cpuidle cooling: " fmt 9 10 #include <linux/cpu_cooling.h> 11 #include <linux/cpuidle.h> 12 #include <linux/device.h> 13 #include <linux/err.h> 14 #include <linux/idle_inject.h> 15 #include <linux/of_device.h> 16 #include <linux/slab.h> 17 #include <linux/thermal.h> 18 19 /** 20 * struct cpuidle_cooling_device - data for the idle cooling device 21 * @ii_dev: an atomic to keep track of the last task exiting the idle cycle 22 * @state: a normalized integer giving the state of the cooling device 23 */ 24 struct cpuidle_cooling_device { 25 struct idle_inject_device *ii_dev; 26 unsigned long state; 27 }; 28 29 /** 30 * cpuidle_cooling_runtime - Running time computation 31 * @idle_duration_us: CPU idle time to inject in microseconds 32 * @state: a percentile based number 33 * 34 * The running duration is computed from the idle injection duration 35 * which is fixed. If we reach 100% of idle injection ratio, that 36 * means the running duration is zero. If we have a 50% ratio 37 * injection, that means we have equal duration for idle and for 38 * running duration. 39 * 40 * The formula is deduced as follows: 41 * 42 * running = idle x ((100 / ratio) - 1) 43 * 44 * For precision purpose for integer math, we use the following: 45 * 46 * running = (idle x 100) / ratio - idle 47 * 48 * For example, if we have an injected duration of 50%, then we end up 49 * with 10ms of idle injection and 10ms of running duration. 50 * 51 * Return: An unsigned int for a usec based runtime duration. 52 */ 53 static unsigned int cpuidle_cooling_runtime(unsigned int idle_duration_us, 54 unsigned long state) 55 { 56 if (!state) 57 return 0; 58 59 return ((idle_duration_us * 100) / state) - idle_duration_us; 60 } 61 62 /** 63 * cpuidle_cooling_get_max_state - Get the maximum state 64 * @cdev : the thermal cooling device 65 * @state : a pointer to the state variable to be filled 66 * 67 * The function always returns 100 as the injection ratio. It is 68 * percentile based for consistency accross different platforms. 69 * 70 * Return: The function can not fail, it is always zero 71 */ 72 static int cpuidle_cooling_get_max_state(struct thermal_cooling_device *cdev, 73 unsigned long *state) 74 { 75 /* 76 * Depending on the configuration or the hardware, the running 77 * cycle and the idle cycle could be different. We want to 78 * unify that to an 0..100 interval, so the set state 79 * interface will be the same whatever the platform is. 80 * 81 * The state 100% will make the cluster 100% ... idle. A 0% 82 * injection ratio means no idle injection at all and 50% 83 * means for 10ms of idle injection, we have 10ms of running 84 * time. 85 */ 86 *state = 100; 87 88 return 0; 89 } 90 91 /** 92 * cpuidle_cooling_get_cur_state - Get the current cooling state 93 * @cdev: the thermal cooling device 94 * @state: a pointer to the state 95 * 96 * The function just copies the state value from the private thermal 97 * cooling device structure, the mapping is 1 <-> 1. 98 * 99 * Return: The function can not fail, it is always zero 100 */ 101 static int cpuidle_cooling_get_cur_state(struct thermal_cooling_device *cdev, 102 unsigned long *state) 103 { 104 struct cpuidle_cooling_device *idle_cdev = cdev->devdata; 105 106 *state = idle_cdev->state; 107 108 return 0; 109 } 110 111 /** 112 * cpuidle_cooling_set_cur_state - Set the current cooling state 113 * @cdev: the thermal cooling device 114 * @state: the target state 115 * 116 * The function checks first if we are initiating the mitigation which 117 * in turn wakes up all the idle injection tasks belonging to the idle 118 * cooling device. In any case, it updates the internal state for the 119 * cooling device. 120 * 121 * Return: The function can not fail, it is always zero 122 */ 123 static int cpuidle_cooling_set_cur_state(struct thermal_cooling_device *cdev, 124 unsigned long state) 125 { 126 struct cpuidle_cooling_device *idle_cdev = cdev->devdata; 127 struct idle_inject_device *ii_dev = idle_cdev->ii_dev; 128 unsigned long current_state = idle_cdev->state; 129 unsigned int runtime_us, idle_duration_us; 130 131 idle_cdev->state = state; 132 133 idle_inject_get_duration(ii_dev, &runtime_us, &idle_duration_us); 134 135 runtime_us = cpuidle_cooling_runtime(idle_duration_us, state); 136 137 idle_inject_set_duration(ii_dev, runtime_us, idle_duration_us); 138 139 if (current_state == 0 && state > 0) { 140 idle_inject_start(ii_dev); 141 } else if (current_state > 0 && !state) { 142 idle_inject_stop(ii_dev); 143 } 144 145 return 0; 146 } 147 148 /** 149 * cpuidle_cooling_ops - thermal cooling device ops 150 */ 151 static struct thermal_cooling_device_ops cpuidle_cooling_ops = { 152 .get_max_state = cpuidle_cooling_get_max_state, 153 .get_cur_state = cpuidle_cooling_get_cur_state, 154 .set_cur_state = cpuidle_cooling_set_cur_state, 155 }; 156 157 /** 158 * __cpuidle_cooling_register: register the cooling device 159 * @drv: a cpuidle driver structure pointer 160 * @np: a device node structure pointer used for the thermal binding 161 * 162 * This function is in charge of allocating the cpuidle cooling device 163 * structure, the idle injection, initialize them and register the 164 * cooling device to the thermal framework. 165 * 166 * Return: zero on success, a negative value returned by one of the 167 * underlying subsystem in case of error 168 */ 169 static int __cpuidle_cooling_register(struct device_node *np, 170 struct cpuidle_driver *drv) 171 { 172 struct idle_inject_device *ii_dev; 173 struct cpuidle_cooling_device *idle_cdev; 174 struct thermal_cooling_device *cdev; 175 struct device *dev; 176 unsigned int idle_duration_us = TICK_USEC; 177 unsigned int latency_us = UINT_MAX; 178 char *name; 179 int ret; 180 181 idle_cdev = kzalloc(sizeof(*idle_cdev), GFP_KERNEL); 182 if (!idle_cdev) { 183 ret = -ENOMEM; 184 goto out; 185 } 186 187 ii_dev = idle_inject_register(drv->cpumask); 188 if (!ii_dev) { 189 ret = -EINVAL; 190 goto out_kfree; 191 } 192 193 of_property_read_u32(np, "duration-us", &idle_duration_us); 194 of_property_read_u32(np, "exit-latency-us", &latency_us); 195 196 idle_inject_set_duration(ii_dev, TICK_USEC, idle_duration_us); 197 idle_inject_set_latency(ii_dev, latency_us); 198 199 idle_cdev->ii_dev = ii_dev; 200 201 dev = get_cpu_device(cpumask_first(drv->cpumask)); 202 203 name = kasprintf(GFP_KERNEL, "idle-%s", dev_name(dev)); 204 if (!name) { 205 ret = -ENOMEM; 206 goto out_unregister; 207 } 208 209 cdev = thermal_of_cooling_device_register(np, name, idle_cdev, 210 &cpuidle_cooling_ops); 211 if (IS_ERR(cdev)) { 212 ret = PTR_ERR(cdev); 213 goto out_kfree_name; 214 } 215 216 pr_debug("%s: Idle injection set with idle duration=%u, latency=%u\n", 217 name, idle_duration_us, latency_us); 218 219 kfree(name); 220 221 return 0; 222 223 out_kfree_name: 224 kfree(name); 225 out_unregister: 226 idle_inject_unregister(ii_dev); 227 out_kfree: 228 kfree(idle_cdev); 229 out: 230 return ret; 231 } 232 233 /** 234 * cpuidle_cooling_register - Idle cooling device initialization function 235 * @drv: a cpuidle driver structure pointer 236 * 237 * This function is in charge of creating a cooling device per cpuidle 238 * driver and register it to the thermal framework. 239 * 240 * Return: zero on success, or negative value corresponding to the 241 * error detected in the underlying subsystems. 242 */ 243 void cpuidle_cooling_register(struct cpuidle_driver *drv) 244 { 245 struct device_node *cooling_node; 246 struct device_node *cpu_node; 247 int cpu, ret; 248 249 for_each_cpu(cpu, drv->cpumask) { 250 251 cpu_node = of_cpu_device_node_get(cpu); 252 253 cooling_node = of_get_child_by_name(cpu_node, "thermal-idle"); 254 255 of_node_put(cpu_node); 256 257 if (!cooling_node) { 258 pr_debug("'thermal-idle' node not found for cpu%d\n", cpu); 259 continue; 260 } 261 262 ret = __cpuidle_cooling_register(cooling_node, drv); 263 264 of_node_put(cooling_node); 265 266 if (ret) { 267 pr_err("Failed to register the cpuidle cooling device" \ 268 "for cpu%d: %d\n", cpu, ret); 269 break; 270 } 271 } 272 } 273