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