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 | */ |
25 | struct 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 | */ |
54 | static 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 | */ |
73 | static 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 | */ |
102 | static 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 | */ |
124 | static 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, run_duration_us: &runtime_us, idle_duration_us: &idle_duration_us); |
135 | |
136 | runtime_us = cpuidle_cooling_runtime(idle_duration_us, state); |
137 | |
138 | idle_inject_set_duration(ii_dev, run_duration_us: 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 | */ |
152 | static 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 | */ |
170 | static 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(size: sizeof(*idle_cdev), GFP_KERNEL); |
183 | if (!idle_cdev) { |
184 | ret = -ENOMEM; |
185 | goto out; |
186 | } |
187 | |
188 | ii_dev = idle_inject_register(cpumask: drv->cpumask); |
189 | if (!ii_dev) { |
190 | ret = -EINVAL; |
191 | goto out_kfree; |
192 | } |
193 | |
194 | of_property_read_u32(np, propname: "duration-us" , out_value: &idle_duration_us); |
195 | of_property_read_u32(np, propname: "exit-latency-us" , out_value: &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(cpu: cpumask_first(srcp: drv->cpumask)); |
203 | |
204 | name = kasprintf(GFP_KERNEL, fmt: "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(ptr: cdev)) { |
213 | ret = PTR_ERR(ptr: 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(objp: name); |
221 | |
222 | return 0; |
223 | |
224 | out_kfree_name: |
225 | kfree(objp: name); |
226 | out_unregister: |
227 | idle_inject_unregister(ii_dev); |
228 | out_kfree: |
229 | kfree(objp: idle_cdev); |
230 | out: |
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 | */ |
241 | void 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(node: cpu_node, name: "thermal-idle" ); |
252 | |
253 | of_node_put(node: 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(np: cooling_node, drv); |
261 | |
262 | of_node_put(node: 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 | |