Commit | Line | Data |
---|---|---|
6b775e87 JM |
1 | /* |
2 | * A power allocator to manage temperature | |
3 | * | |
4 | * Copyright (C) 2014 ARM Ltd. | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License version 2 as | |
8 | * published by the Free Software Foundation. | |
9 | * | |
10 | * This program is distributed "as is" WITHOUT ANY WARRANTY of any | |
11 | * kind, whether express or implied; without even the implied warranty | |
12 | * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | */ | |
15 | ||
16 | #define pr_fmt(fmt) "Power allocator: " fmt | |
17 | ||
18 | #include <linux/rculist.h> | |
19 | #include <linux/slab.h> | |
20 | #include <linux/thermal.h> | |
21 | ||
6828a471 JM |
22 | #define CREATE_TRACE_POINTS |
23 | #include <trace/events/thermal_power_allocator.h> | |
24 | ||
6b775e87 JM |
25 | #include "thermal_core.h" |
26 | ||
27 | #define FRAC_BITS 10 | |
28 | #define int_to_frac(x) ((x) << FRAC_BITS) | |
29 | #define frac_to_int(x) ((x) >> FRAC_BITS) | |
30 | ||
31 | /** | |
32 | * mul_frac() - multiply two fixed-point numbers | |
33 | * @x: first multiplicand | |
34 | * @y: second multiplicand | |
35 | * | |
36 | * Return: the result of multiplying two fixed-point numbers. The | |
37 | * result is also a fixed-point number. | |
38 | */ | |
39 | static inline s64 mul_frac(s64 x, s64 y) | |
40 | { | |
41 | return (x * y) >> FRAC_BITS; | |
42 | } | |
43 | ||
44 | /** | |
45 | * div_frac() - divide two fixed-point numbers | |
46 | * @x: the dividend | |
47 | * @y: the divisor | |
48 | * | |
49 | * Return: the result of dividing two fixed-point numbers. The | |
50 | * result is also a fixed-point number. | |
51 | */ | |
52 | static inline s64 div_frac(s64 x, s64 y) | |
53 | { | |
54 | return div_s64(x << FRAC_BITS, y); | |
55 | } | |
56 | ||
57 | /** | |
58 | * struct power_allocator_params - parameters for the power allocator governor | |
59 | * @err_integral: accumulated error in the PID controller. | |
60 | * @prev_err: error in the previous iteration of the PID controller. | |
61 | * Used to calculate the derivative term. | |
62 | * @trip_switch_on: first passive trip point of the thermal zone. The | |
63 | * governor switches on when this trip point is crossed. | |
64 | * @trip_max_desired_temperature: last passive trip point of the thermal | |
65 | * zone. The temperature we are | |
66 | * controlling for. | |
67 | */ | |
68 | struct power_allocator_params { | |
69 | s64 err_integral; | |
70 | s32 prev_err; | |
71 | int trip_switch_on; | |
72 | int trip_max_desired_temperature; | |
73 | }; | |
74 | ||
75 | /** | |
76 | * pid_controller() - PID controller | |
77 | * @tz: thermal zone we are operating in | |
78 | * @current_temp: the current temperature in millicelsius | |
79 | * @control_temp: the target temperature in millicelsius | |
80 | * @max_allocatable_power: maximum allocatable power for this thermal zone | |
81 | * | |
82 | * This PID controller increases the available power budget so that the | |
83 | * temperature of the thermal zone gets as close as possible to | |
84 | * @control_temp and limits the power if it exceeds it. k_po is the | |
85 | * proportional term when we are overshooting, k_pu is the | |
86 | * proportional term when we are undershooting. integral_cutoff is a | |
87 | * threshold below which we stop accumulating the error. The | |
88 | * accumulated error is only valid if the requested power will make | |
89 | * the system warmer. If the system is mostly idle, there's no point | |
90 | * in accumulating positive error. | |
91 | * | |
92 | * Return: The power budget for the next period. | |
93 | */ | |
94 | static u32 pid_controller(struct thermal_zone_device *tz, | |
17e8351a SH |
95 | int current_temp, |
96 | int control_temp, | |
6b775e87 JM |
97 | u32 max_allocatable_power) |
98 | { | |
99 | s64 p, i, d, power_range; | |
100 | s32 err, max_power_frac; | |
101 | struct power_allocator_params *params = tz->governor_data; | |
102 | ||
103 | max_power_frac = int_to_frac(max_allocatable_power); | |
104 | ||
17e8351a | 105 | err = control_temp - current_temp; |
6b775e87 JM |
106 | err = int_to_frac(err); |
107 | ||
108 | /* Calculate the proportional term */ | |
109 | p = mul_frac(err < 0 ? tz->tzp->k_po : tz->tzp->k_pu, err); | |
110 | ||
111 | /* | |
112 | * Calculate the integral term | |
113 | * | |
114 | * if the error is less than cut off allow integration (but | |
115 | * the integral is limited to max power) | |
116 | */ | |
117 | i = mul_frac(tz->tzp->k_i, params->err_integral); | |
118 | ||
119 | if (err < int_to_frac(tz->tzp->integral_cutoff)) { | |
120 | s64 i_next = i + mul_frac(tz->tzp->k_i, err); | |
121 | ||
122 | if (abs64(i_next) < max_power_frac) { | |
123 | i = i_next; | |
124 | params->err_integral += err; | |
125 | } | |
126 | } | |
127 | ||
128 | /* | |
129 | * Calculate the derivative term | |
130 | * | |
131 | * We do err - prev_err, so with a positive k_d, a decreasing | |
132 | * error (i.e. driving closer to the line) results in less | |
133 | * power being applied, slowing down the controller) | |
134 | */ | |
135 | d = mul_frac(tz->tzp->k_d, err - params->prev_err); | |
136 | d = div_frac(d, tz->passive_delay); | |
137 | params->prev_err = err; | |
138 | ||
139 | power_range = p + i + d; | |
140 | ||
141 | /* feed-forward the known sustainable dissipatable power */ | |
142 | power_range = tz->tzp->sustainable_power + frac_to_int(power_range); | |
143 | ||
6828a471 JM |
144 | power_range = clamp(power_range, (s64)0, (s64)max_allocatable_power); |
145 | ||
146 | trace_thermal_power_allocator_pid(tz, frac_to_int(err), | |
147 | frac_to_int(params->err_integral), | |
148 | frac_to_int(p), frac_to_int(i), | |
149 | frac_to_int(d), power_range); | |
150 | ||
151 | return power_range; | |
6b775e87 JM |
152 | } |
153 | ||
154 | /** | |
155 | * divvy_up_power() - divvy the allocated power between the actors | |
156 | * @req_power: each actor's requested power | |
157 | * @max_power: each actor's maximum available power | |
158 | * @num_actors: size of the @req_power, @max_power and @granted_power's array | |
159 | * @total_req_power: sum of @req_power | |
160 | * @power_range: total allocated power | |
161 | * @granted_power: output array: each actor's granted power | |
162 | * @extra_actor_power: an appropriately sized array to be used in the | |
163 | * function as temporary storage of the extra power given | |
164 | * to the actors | |
165 | * | |
166 | * This function divides the total allocated power (@power_range) | |
167 | * fairly between the actors. It first tries to give each actor a | |
168 | * share of the @power_range according to how much power it requested | |
169 | * compared to the rest of the actors. For example, if only one actor | |
170 | * requests power, then it receives all the @power_range. If | |
171 | * three actors each requests 1mW, each receives a third of the | |
172 | * @power_range. | |
173 | * | |
174 | * If any actor received more than their maximum power, then that | |
175 | * surplus is re-divvied among the actors based on how far they are | |
176 | * from their respective maximums. | |
177 | * | |
178 | * Granted power for each actor is written to @granted_power, which | |
179 | * should've been allocated by the calling function. | |
180 | */ | |
181 | static void divvy_up_power(u32 *req_power, u32 *max_power, int num_actors, | |
182 | u32 total_req_power, u32 power_range, | |
183 | u32 *granted_power, u32 *extra_actor_power) | |
184 | { | |
185 | u32 extra_power, capped_extra_power; | |
186 | int i; | |
187 | ||
188 | /* | |
189 | * Prevent division by 0 if none of the actors request power. | |
190 | */ | |
191 | if (!total_req_power) | |
192 | total_req_power = 1; | |
193 | ||
194 | capped_extra_power = 0; | |
195 | extra_power = 0; | |
196 | for (i = 0; i < num_actors; i++) { | |
197 | u64 req_range = req_power[i] * power_range; | |
198 | ||
ea54cac9 JM |
199 | granted_power[i] = DIV_ROUND_CLOSEST_ULL(req_range, |
200 | total_req_power); | |
6b775e87 JM |
201 | |
202 | if (granted_power[i] > max_power[i]) { | |
203 | extra_power += granted_power[i] - max_power[i]; | |
204 | granted_power[i] = max_power[i]; | |
205 | } | |
206 | ||
207 | extra_actor_power[i] = max_power[i] - granted_power[i]; | |
208 | capped_extra_power += extra_actor_power[i]; | |
209 | } | |
210 | ||
211 | if (!extra_power) | |
212 | return; | |
213 | ||
214 | /* | |
215 | * Re-divvy the reclaimed extra among actors based on | |
216 | * how far they are from the max | |
217 | */ | |
218 | extra_power = min(extra_power, capped_extra_power); | |
219 | if (capped_extra_power > 0) | |
220 | for (i = 0; i < num_actors; i++) | |
221 | granted_power[i] += (extra_actor_power[i] * | |
222 | extra_power) / capped_extra_power; | |
223 | } | |
224 | ||
225 | static int allocate_power(struct thermal_zone_device *tz, | |
17e8351a SH |
226 | int current_temp, |
227 | int control_temp) | |
6b775e87 JM |
228 | { |
229 | struct thermal_instance *instance; | |
230 | struct power_allocator_params *params = tz->governor_data; | |
231 | u32 *req_power, *max_power, *granted_power, *extra_actor_power; | |
232 | u32 total_req_power, max_allocatable_power; | |
6828a471 | 233 | u32 total_granted_power, power_range; |
6b775e87 JM |
234 | int i, num_actors, total_weight, ret = 0; |
235 | int trip_max_desired_temperature = params->trip_max_desired_temperature; | |
236 | ||
237 | mutex_lock(&tz->lock); | |
238 | ||
239 | num_actors = 0; | |
240 | total_weight = 0; | |
241 | list_for_each_entry(instance, &tz->thermal_instances, tz_node) { | |
242 | if ((instance->trip == trip_max_desired_temperature) && | |
243 | cdev_is_power_actor(instance->cdev)) { | |
244 | num_actors++; | |
245 | total_weight += instance->weight; | |
246 | } | |
247 | } | |
248 | ||
249 | /* | |
250 | * We need to allocate three arrays of the same size: | |
251 | * req_power, max_power and granted_power. They are going to | |
252 | * be needed until this function returns. Allocate them all | |
253 | * in one go to simplify the allocation and deallocation | |
254 | * logic. | |
255 | */ | |
256 | BUILD_BUG_ON(sizeof(*req_power) != sizeof(*max_power)); | |
257 | BUILD_BUG_ON(sizeof(*req_power) != sizeof(*granted_power)); | |
258 | BUILD_BUG_ON(sizeof(*req_power) != sizeof(*extra_actor_power)); | |
259 | req_power = devm_kcalloc(&tz->device, num_actors * 4, | |
260 | sizeof(*req_power), GFP_KERNEL); | |
261 | if (!req_power) { | |
262 | ret = -ENOMEM; | |
263 | goto unlock; | |
264 | } | |
265 | ||
266 | max_power = &req_power[num_actors]; | |
267 | granted_power = &req_power[2 * num_actors]; | |
268 | extra_actor_power = &req_power[3 * num_actors]; | |
269 | ||
270 | i = 0; | |
271 | total_req_power = 0; | |
272 | max_allocatable_power = 0; | |
273 | ||
274 | list_for_each_entry(instance, &tz->thermal_instances, tz_node) { | |
275 | int weight; | |
276 | struct thermal_cooling_device *cdev = instance->cdev; | |
277 | ||
278 | if (instance->trip != trip_max_desired_temperature) | |
279 | continue; | |
280 | ||
281 | if (!cdev_is_power_actor(cdev)) | |
282 | continue; | |
283 | ||
284 | if (cdev->ops->get_requested_power(cdev, tz, &req_power[i])) | |
285 | continue; | |
286 | ||
287 | if (!total_weight) | |
288 | weight = 1 << FRAC_BITS; | |
289 | else | |
290 | weight = instance->weight; | |
291 | ||
292 | req_power[i] = frac_to_int(weight * req_power[i]); | |
293 | ||
294 | if (power_actor_get_max_power(cdev, tz, &max_power[i])) | |
295 | continue; | |
296 | ||
297 | total_req_power += req_power[i]; | |
298 | max_allocatable_power += max_power[i]; | |
299 | ||
300 | i++; | |
301 | } | |
302 | ||
303 | power_range = pid_controller(tz, current_temp, control_temp, | |
304 | max_allocatable_power); | |
305 | ||
306 | divvy_up_power(req_power, max_power, num_actors, total_req_power, | |
307 | power_range, granted_power, extra_actor_power); | |
308 | ||
6828a471 | 309 | total_granted_power = 0; |
6b775e87 JM |
310 | i = 0; |
311 | list_for_each_entry(instance, &tz->thermal_instances, tz_node) { | |
312 | if (instance->trip != trip_max_desired_temperature) | |
313 | continue; | |
314 | ||
315 | if (!cdev_is_power_actor(instance->cdev)) | |
316 | continue; | |
317 | ||
318 | power_actor_set_power(instance->cdev, instance, | |
319 | granted_power[i]); | |
6828a471 | 320 | total_granted_power += granted_power[i]; |
6b775e87 JM |
321 | |
322 | i++; | |
323 | } | |
324 | ||
6828a471 JM |
325 | trace_thermal_power_allocator(tz, req_power, total_req_power, |
326 | granted_power, total_granted_power, | |
327 | num_actors, power_range, | |
328 | max_allocatable_power, current_temp, | |
17e8351a | 329 | control_temp - current_temp); |
6828a471 | 330 | |
6b775e87 JM |
331 | devm_kfree(&tz->device, req_power); |
332 | unlock: | |
333 | mutex_unlock(&tz->lock); | |
334 | ||
335 | return ret; | |
336 | } | |
337 | ||
338 | static int get_governor_trips(struct thermal_zone_device *tz, | |
339 | struct power_allocator_params *params) | |
340 | { | |
341 | int i, ret, last_passive; | |
342 | bool found_first_passive; | |
343 | ||
344 | found_first_passive = false; | |
345 | last_passive = -1; | |
346 | ret = -EINVAL; | |
347 | ||
348 | for (i = 0; i < tz->trips; i++) { | |
349 | enum thermal_trip_type type; | |
350 | ||
351 | ret = tz->ops->get_trip_type(tz, i, &type); | |
352 | if (ret) | |
353 | return ret; | |
354 | ||
355 | if (!found_first_passive) { | |
356 | if (type == THERMAL_TRIP_PASSIVE) { | |
357 | params->trip_switch_on = i; | |
358 | found_first_passive = true; | |
359 | } | |
360 | } else if (type == THERMAL_TRIP_PASSIVE) { | |
361 | last_passive = i; | |
362 | } else { | |
363 | break; | |
364 | } | |
365 | } | |
366 | ||
367 | if (last_passive != -1) { | |
368 | params->trip_max_desired_temperature = last_passive; | |
369 | ret = 0; | |
370 | } else { | |
371 | ret = -EINVAL; | |
372 | } | |
373 | ||
374 | return ret; | |
375 | } | |
376 | ||
377 | static void reset_pid_controller(struct power_allocator_params *params) | |
378 | { | |
379 | params->err_integral = 0; | |
380 | params->prev_err = 0; | |
381 | } | |
382 | ||
383 | static void allow_maximum_power(struct thermal_zone_device *tz) | |
384 | { | |
385 | struct thermal_instance *instance; | |
386 | struct power_allocator_params *params = tz->governor_data; | |
387 | ||
388 | list_for_each_entry(instance, &tz->thermal_instances, tz_node) { | |
389 | if ((instance->trip != params->trip_max_desired_temperature) || | |
390 | (!cdev_is_power_actor(instance->cdev))) | |
391 | continue; | |
392 | ||
393 | instance->target = 0; | |
394 | instance->cdev->updated = false; | |
395 | thermal_cdev_update(instance->cdev); | |
396 | } | |
397 | } | |
398 | ||
399 | /** | |
400 | * power_allocator_bind() - bind the power_allocator governor to a thermal zone | |
401 | * @tz: thermal zone to bind it to | |
402 | * | |
403 | * Check that the thermal zone is valid for this governor, that is, it | |
404 | * has two thermal trips. If so, initialize the PID controller | |
405 | * parameters and bind it to the thermal zone. | |
406 | * | |
407 | * Return: 0 on success, -EINVAL if the trips were invalid or -ENOMEM | |
408 | * if we ran out of memory. | |
409 | */ | |
410 | static int power_allocator_bind(struct thermal_zone_device *tz) | |
411 | { | |
412 | int ret; | |
413 | struct power_allocator_params *params; | |
17e8351a | 414 | int switch_on_temp, control_temp; |
6b775e87 JM |
415 | u32 temperature_threshold; |
416 | ||
417 | if (!tz->tzp || !tz->tzp->sustainable_power) { | |
418 | dev_err(&tz->device, | |
419 | "power_allocator: missing sustainable_power\n"); | |
420 | return -EINVAL; | |
421 | } | |
422 | ||
423 | params = devm_kzalloc(&tz->device, sizeof(*params), GFP_KERNEL); | |
424 | if (!params) | |
425 | return -ENOMEM; | |
426 | ||
427 | ret = get_governor_trips(tz, params); | |
428 | if (ret) { | |
429 | dev_err(&tz->device, | |
430 | "thermal zone %s has wrong trip setup for power allocator\n", | |
431 | tz->type); | |
432 | goto free; | |
433 | } | |
434 | ||
435 | ret = tz->ops->get_trip_temp(tz, params->trip_switch_on, | |
436 | &switch_on_temp); | |
437 | if (ret) | |
438 | goto free; | |
439 | ||
440 | ret = tz->ops->get_trip_temp(tz, params->trip_max_desired_temperature, | |
441 | &control_temp); | |
442 | if (ret) | |
443 | goto free; | |
444 | ||
445 | temperature_threshold = control_temp - switch_on_temp; | |
446 | ||
447 | tz->tzp->k_po = tz->tzp->k_po ?: | |
448 | int_to_frac(tz->tzp->sustainable_power) / temperature_threshold; | |
449 | tz->tzp->k_pu = tz->tzp->k_pu ?: | |
450 | int_to_frac(2 * tz->tzp->sustainable_power) / | |
451 | temperature_threshold; | |
452 | tz->tzp->k_i = tz->tzp->k_i ?: int_to_frac(10) / 1000; | |
453 | /* | |
454 | * The default for k_d and integral_cutoff is 0, so we can | |
455 | * leave them as they are. | |
456 | */ | |
457 | ||
458 | reset_pid_controller(params); | |
459 | ||
460 | tz->governor_data = params; | |
461 | ||
462 | return 0; | |
463 | ||
464 | free: | |
465 | devm_kfree(&tz->device, params); | |
466 | return ret; | |
467 | } | |
468 | ||
469 | static void power_allocator_unbind(struct thermal_zone_device *tz) | |
470 | { | |
471 | dev_dbg(&tz->device, "Unbinding from thermal zone %d\n", tz->id); | |
472 | devm_kfree(&tz->device, tz->governor_data); | |
473 | tz->governor_data = NULL; | |
474 | } | |
475 | ||
476 | static int power_allocator_throttle(struct thermal_zone_device *tz, int trip) | |
477 | { | |
478 | int ret; | |
17e8351a | 479 | int switch_on_temp, control_temp, current_temp; |
6b775e87 JM |
480 | struct power_allocator_params *params = tz->governor_data; |
481 | ||
482 | /* | |
483 | * We get called for every trip point but we only need to do | |
484 | * our calculations once | |
485 | */ | |
486 | if (trip != params->trip_max_desired_temperature) | |
487 | return 0; | |
488 | ||
489 | ret = thermal_zone_get_temp(tz, ¤t_temp); | |
490 | if (ret) { | |
491 | dev_warn(&tz->device, "Failed to get temperature: %d\n", ret); | |
492 | return ret; | |
493 | } | |
494 | ||
495 | ret = tz->ops->get_trip_temp(tz, params->trip_switch_on, | |
496 | &switch_on_temp); | |
497 | if (ret) { | |
498 | dev_warn(&tz->device, | |
499 | "Failed to get switch on temperature: %d\n", ret); | |
500 | return ret; | |
501 | } | |
502 | ||
503 | if (current_temp < switch_on_temp) { | |
504 | tz->passive = 0; | |
505 | reset_pid_controller(params); | |
506 | allow_maximum_power(tz); | |
507 | return 0; | |
508 | } | |
509 | ||
510 | tz->passive = 1; | |
511 | ||
512 | ret = tz->ops->get_trip_temp(tz, params->trip_max_desired_temperature, | |
513 | &control_temp); | |
514 | if (ret) { | |
515 | dev_warn(&tz->device, | |
516 | "Failed to get the maximum desired temperature: %d\n", | |
517 | ret); | |
518 | return ret; | |
519 | } | |
520 | ||
521 | return allocate_power(tz, current_temp, control_temp); | |
522 | } | |
523 | ||
524 | static struct thermal_governor thermal_gov_power_allocator = { | |
525 | .name = "power_allocator", | |
526 | .bind_to_tz = power_allocator_bind, | |
527 | .unbind_from_tz = power_allocator_unbind, | |
528 | .throttle = power_allocator_throttle, | |
529 | }; | |
530 | ||
531 | int thermal_gov_power_allocator_register(void) | |
532 | { | |
533 | return thermal_register_governor(&thermal_gov_power_allocator); | |
534 | } | |
535 | ||
536 | void thermal_gov_power_allocator_unregister(void) | |
537 | { | |
538 | thermal_unregister_governor(&thermal_gov_power_allocator); | |
539 | } |