Loading...
Note: File does not exist in v3.1.
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.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 device
22 * @ii_dev: an atomic to keep track of the last task exiting the idle cycle
23 * @state: a normalized integer giving the state of the cooling device
24 */
25struct cpuidle_cooling_device {
26 struct idle_inject_device *ii_dev;
27 unsigned long state;
28};
29
30/**
31 * cpuidle_cooling_runtime - Running time computation
32 * @idle_duration_us: CPU idle time to inject in microseconds
33 * @state: a percentile based number
34 *
35 * The running duration is computed from the idle injection duration
36 * which is fixed. If we reach 100% of idle injection ratio, that
37 * means the running duration is zero. If we have a 50% ratio
38 * injection, that means we have equal duration for idle and for
39 * 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 - idle
48 *
49 * For example, if we have an injected duration of 50%, then we end up
50 * 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 state
65 * @cdev : the thermal cooling device
66 * @state : a pointer to the state variable to be filled
67 *
68 * The function always returns 100 as the injection ratio. It is
69 * percentile based for consistency across different platforms.
70 *
71 * Return: The function can not fail, it is always zero
72 */
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 running
78 * cycle and the idle cycle could be different. We want to
79 * unify that to an 0..100 interval, so the set state
80 * 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 running
85 * time.
86 */
87 *state = 100;
88
89 return 0;
90}
91
92/**
93 * cpuidle_cooling_get_cur_state - Get the current cooling state
94 * @cdev: the thermal cooling device
95 * @state: a pointer to the state
96 *
97 * The function just copies the state value from the private thermal
98 * cooling device structure, the mapping is 1 <-> 1.
99 *
100 * Return: The function can not fail, it is always zero
101 */
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 state
114 * @cdev: the thermal cooling device
115 * @state: the target state
116 *
117 * The function checks first if we are initiating the mitigation which
118 * in turn wakes up all the idle injection tasks belonging to the idle
119 * cooling device. In any case, it updates the internal state for the
120 * cooling device.
121 *
122 * Return: The function can not fail, it is always zero
123 */
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 ops
151 */
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 device
160 * @drv: a cpuidle driver structure pointer
161 * @np: a device node structure pointer used for the thermal binding
162 *
163 * This function is in charge of allocating the cpuidle cooling device
164 * structure, the idle injection, initialize them and register the
165 * cooling device to the thermal framework.
166 *
167 * Return: zero on success, a negative value returned by one of the
168 * underlying subsystem in case of error
169 */
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 function
236 * @drv: a cpuidle driver structure pointer
237 *
238 * This function is in charge of creating a cooling device per cpuidle
239 * 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}