]>
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 | ||
8b7b390f JM |
27 | #define INVALID_TRIP -1 |
28 | ||
6b775e87 JM |
29 | #define FRAC_BITS 10 |
30 | #define int_to_frac(x) ((x) << FRAC_BITS) | |
31 | #define frac_to_int(x) ((x) >> FRAC_BITS) | |
32 | ||
33 | /** | |
34 | * mul_frac() - multiply two fixed-point numbers | |
35 | * @x: first multiplicand | |
36 | * @y: second multiplicand | |
37 | * | |
38 | * Return: the result of multiplying two fixed-point numbers. The | |
39 | * result is also a fixed-point number. | |
40 | */ | |
41 | static inline s64 mul_frac(s64 x, s64 y) | |
42 | { | |
43 | return (x * y) >> FRAC_BITS; | |
44 | } | |
45 | ||
46 | /** | |
47 | * div_frac() - divide two fixed-point numbers | |
48 | * @x: the dividend | |
49 | * @y: the divisor | |
50 | * | |
51 | * Return: the result of dividing two fixed-point numbers. The | |
52 | * result is also a fixed-point number. | |
53 | */ | |
54 | static inline s64 div_frac(s64 x, s64 y) | |
55 | { | |
56 | return div_s64(x << FRAC_BITS, y); | |
57 | } | |
58 | ||
59 | /** | |
60 | * struct power_allocator_params - parameters for the power allocator governor | |
f5cbb182 JM |
61 | * @allocated_tzp: whether we have allocated tzp for this thermal zone and |
62 | * it needs to be freed on unbind | |
6b775e87 JM |
63 | * @err_integral: accumulated error in the PID controller. |
64 | * @prev_err: error in the previous iteration of the PID controller. | |
65 | * Used to calculate the derivative term. | |
66 | * @trip_switch_on: first passive trip point of the thermal zone. The | |
67 | * governor switches on when this trip point is crossed. | |
8b7b390f JM |
68 | * If the thermal zone only has one passive trip point, |
69 | * @trip_switch_on should be INVALID_TRIP. | |
6b775e87 JM |
70 | * @trip_max_desired_temperature: last passive trip point of the thermal |
71 | * zone. The temperature we are | |
72 | * controlling for. | |
73 | */ | |
74 | struct power_allocator_params { | |
f5cbb182 | 75 | bool allocated_tzp; |
6b775e87 JM |
76 | s64 err_integral; |
77 | s32 prev_err; | |
78 | int trip_switch_on; | |
79 | int trip_max_desired_temperature; | |
80 | }; | |
81 | ||
e055bb0f JM |
82 | /** |
83 | * estimate_sustainable_power() - Estimate the sustainable power of a thermal zone | |
84 | * @tz: thermal zone we are operating in | |
85 | * | |
86 | * For thermal zones that don't provide a sustainable_power in their | |
87 | * thermal_zone_params, estimate one. Calculate it using the minimum | |
88 | * power of all the cooling devices as that gives a valid value that | |
89 | * can give some degree of functionality. For optimal performance of | |
90 | * this governor, provide a sustainable_power in the thermal zone's | |
91 | * thermal_zone_params. | |
92 | */ | |
93 | static u32 estimate_sustainable_power(struct thermal_zone_device *tz) | |
94 | { | |
95 | u32 sustainable_power = 0; | |
96 | struct thermal_instance *instance; | |
97 | struct power_allocator_params *params = tz->governor_data; | |
98 | ||
99 | list_for_each_entry(instance, &tz->thermal_instances, tz_node) { | |
100 | struct thermal_cooling_device *cdev = instance->cdev; | |
101 | u32 min_power; | |
102 | ||
103 | if (instance->trip != params->trip_max_desired_temperature) | |
104 | continue; | |
105 | ||
106 | if (power_actor_get_min_power(cdev, tz, &min_power)) | |
107 | continue; | |
108 | ||
109 | sustainable_power += min_power; | |
110 | } | |
111 | ||
112 | return sustainable_power; | |
113 | } | |
114 | ||
115 | /** | |
116 | * estimate_pid_constants() - Estimate the constants for the PID controller | |
117 | * @tz: thermal zone for which to estimate the constants | |
118 | * @sustainable_power: sustainable power for the thermal zone | |
119 | * @trip_switch_on: trip point number for the switch on temperature | |
120 | * @control_temp: target temperature for the power allocator governor | |
121 | * @force: whether to force the update of the constants | |
122 | * | |
123 | * This function is used to update the estimation of the PID | |
124 | * controller constants in struct thermal_zone_parameters. | |
125 | * Sustainable power is provided in case it was estimated. The | |
126 | * estimated sustainable_power should not be stored in the | |
127 | * thermal_zone_parameters so it has to be passed explicitly to this | |
128 | * function. | |
129 | * | |
130 | * If @force is not set, the values in the thermal zone's parameters | |
131 | * are preserved if they are not zero. If @force is set, the values | |
132 | * in thermal zone's parameters are overwritten. | |
133 | */ | |
134 | static void estimate_pid_constants(struct thermal_zone_device *tz, | |
135 | u32 sustainable_power, int trip_switch_on, | |
136 | int control_temp, bool force) | |
137 | { | |
138 | int ret; | |
139 | int switch_on_temp; | |
140 | u32 temperature_threshold; | |
141 | ||
142 | ret = tz->ops->get_trip_temp(tz, trip_switch_on, &switch_on_temp); | |
143 | if (ret) | |
144 | switch_on_temp = 0; | |
145 | ||
146 | temperature_threshold = control_temp - switch_on_temp; | |
147 | ||
148 | if (!tz->tzp->k_po || force) | |
149 | tz->tzp->k_po = int_to_frac(sustainable_power) / | |
150 | temperature_threshold; | |
151 | ||
152 | if (!tz->tzp->k_pu || force) | |
153 | tz->tzp->k_pu = int_to_frac(2 * sustainable_power) / | |
154 | temperature_threshold; | |
155 | ||
156 | if (!tz->tzp->k_i || force) | |
157 | tz->tzp->k_i = int_to_frac(10) / 1000; | |
158 | /* | |
159 | * The default for k_d and integral_cutoff is 0, so we can | |
160 | * leave them as they are. | |
161 | */ | |
162 | } | |
163 | ||
6b775e87 JM |
164 | /** |
165 | * pid_controller() - PID controller | |
166 | * @tz: thermal zone we are operating in | |
167 | * @current_temp: the current temperature in millicelsius | |
168 | * @control_temp: the target temperature in millicelsius | |
169 | * @max_allocatable_power: maximum allocatable power for this thermal zone | |
170 | * | |
171 | * This PID controller increases the available power budget so that the | |
172 | * temperature of the thermal zone gets as close as possible to | |
173 | * @control_temp and limits the power if it exceeds it. k_po is the | |
174 | * proportional term when we are overshooting, k_pu is the | |
175 | * proportional term when we are undershooting. integral_cutoff is a | |
176 | * threshold below which we stop accumulating the error. The | |
177 | * accumulated error is only valid if the requested power will make | |
178 | * the system warmer. If the system is mostly idle, there's no point | |
179 | * in accumulating positive error. | |
180 | * | |
181 | * Return: The power budget for the next period. | |
182 | */ | |
183 | static u32 pid_controller(struct thermal_zone_device *tz, | |
17e8351a SH |
184 | int current_temp, |
185 | int control_temp, | |
6b775e87 JM |
186 | u32 max_allocatable_power) |
187 | { | |
188 | s64 p, i, d, power_range; | |
189 | s32 err, max_power_frac; | |
e055bb0f | 190 | u32 sustainable_power; |
6b775e87 JM |
191 | struct power_allocator_params *params = tz->governor_data; |
192 | ||
193 | max_power_frac = int_to_frac(max_allocatable_power); | |
194 | ||
e055bb0f JM |
195 | if (tz->tzp->sustainable_power) { |
196 | sustainable_power = tz->tzp->sustainable_power; | |
197 | } else { | |
198 | sustainable_power = estimate_sustainable_power(tz); | |
199 | estimate_pid_constants(tz, sustainable_power, | |
200 | params->trip_switch_on, control_temp, | |
201 | true); | |
202 | } | |
203 | ||
17e8351a | 204 | err = control_temp - current_temp; |
6b775e87 JM |
205 | err = int_to_frac(err); |
206 | ||
207 | /* Calculate the proportional term */ | |
208 | p = mul_frac(err < 0 ? tz->tzp->k_po : tz->tzp->k_pu, err); | |
209 | ||
210 | /* | |
211 | * Calculate the integral term | |
212 | * | |
213 | * if the error is less than cut off allow integration (but | |
214 | * the integral is limited to max power) | |
215 | */ | |
216 | i = mul_frac(tz->tzp->k_i, params->err_integral); | |
217 | ||
218 | if (err < int_to_frac(tz->tzp->integral_cutoff)) { | |
219 | s64 i_next = i + mul_frac(tz->tzp->k_i, err); | |
220 | ||
221 | if (abs64(i_next) < max_power_frac) { | |
222 | i = i_next; | |
223 | params->err_integral += err; | |
224 | } | |
225 | } | |
226 | ||
227 | /* | |
228 | * Calculate the derivative term | |
229 | * | |
230 | * We do err - prev_err, so with a positive k_d, a decreasing | |
231 | * error (i.e. driving closer to the line) results in less | |
232 | * power being applied, slowing down the controller) | |
233 | */ | |
234 | d = mul_frac(tz->tzp->k_d, err - params->prev_err); | |
235 | d = div_frac(d, tz->passive_delay); | |
236 | params->prev_err = err; | |
237 | ||
238 | power_range = p + i + d; | |
239 | ||
240 | /* feed-forward the known sustainable dissipatable power */ | |
e055bb0f | 241 | power_range = sustainable_power + frac_to_int(power_range); |
6b775e87 | 242 | |
6828a471 JM |
243 | power_range = clamp(power_range, (s64)0, (s64)max_allocatable_power); |
244 | ||
245 | trace_thermal_power_allocator_pid(tz, frac_to_int(err), | |
246 | frac_to_int(params->err_integral), | |
247 | frac_to_int(p), frac_to_int(i), | |
248 | frac_to_int(d), power_range); | |
249 | ||
250 | return power_range; | |
6b775e87 JM |
251 | } |
252 | ||
253 | /** | |
254 | * divvy_up_power() - divvy the allocated power between the actors | |
255 | * @req_power: each actor's requested power | |
256 | * @max_power: each actor's maximum available power | |
257 | * @num_actors: size of the @req_power, @max_power and @granted_power's array | |
258 | * @total_req_power: sum of @req_power | |
259 | * @power_range: total allocated power | |
260 | * @granted_power: output array: each actor's granted power | |
261 | * @extra_actor_power: an appropriately sized array to be used in the | |
262 | * function as temporary storage of the extra power given | |
263 | * to the actors | |
264 | * | |
265 | * This function divides the total allocated power (@power_range) | |
266 | * fairly between the actors. It first tries to give each actor a | |
267 | * share of the @power_range according to how much power it requested | |
268 | * compared to the rest of the actors. For example, if only one actor | |
269 | * requests power, then it receives all the @power_range. If | |
270 | * three actors each requests 1mW, each receives a third of the | |
271 | * @power_range. | |
272 | * | |
273 | * If any actor received more than their maximum power, then that | |
274 | * surplus is re-divvied among the actors based on how far they are | |
275 | * from their respective maximums. | |
276 | * | |
277 | * Granted power for each actor is written to @granted_power, which | |
278 | * should've been allocated by the calling function. | |
279 | */ | |
280 | static void divvy_up_power(u32 *req_power, u32 *max_power, int num_actors, | |
281 | u32 total_req_power, u32 power_range, | |
282 | u32 *granted_power, u32 *extra_actor_power) | |
283 | { | |
284 | u32 extra_power, capped_extra_power; | |
285 | int i; | |
286 | ||
287 | /* | |
288 | * Prevent division by 0 if none of the actors request power. | |
289 | */ | |
290 | if (!total_req_power) | |
291 | total_req_power = 1; | |
292 | ||
293 | capped_extra_power = 0; | |
294 | extra_power = 0; | |
295 | for (i = 0; i < num_actors; i++) { | |
296 | u64 req_range = req_power[i] * power_range; | |
297 | ||
ea54cac9 JM |
298 | granted_power[i] = DIV_ROUND_CLOSEST_ULL(req_range, |
299 | total_req_power); | |
6b775e87 JM |
300 | |
301 | if (granted_power[i] > max_power[i]) { | |
302 | extra_power += granted_power[i] - max_power[i]; | |
303 | granted_power[i] = max_power[i]; | |
304 | } | |
305 | ||
306 | extra_actor_power[i] = max_power[i] - granted_power[i]; | |
307 | capped_extra_power += extra_actor_power[i]; | |
308 | } | |
309 | ||
310 | if (!extra_power) | |
311 | return; | |
312 | ||
313 | /* | |
314 | * Re-divvy the reclaimed extra among actors based on | |
315 | * how far they are from the max | |
316 | */ | |
317 | extra_power = min(extra_power, capped_extra_power); | |
318 | if (capped_extra_power > 0) | |
319 | for (i = 0; i < num_actors; i++) | |
320 | granted_power[i] += (extra_actor_power[i] * | |
321 | extra_power) / capped_extra_power; | |
322 | } | |
323 | ||
324 | static int allocate_power(struct thermal_zone_device *tz, | |
17e8351a SH |
325 | int current_temp, |
326 | int control_temp) | |
6b775e87 JM |
327 | { |
328 | struct thermal_instance *instance; | |
329 | struct power_allocator_params *params = tz->governor_data; | |
330 | u32 *req_power, *max_power, *granted_power, *extra_actor_power; | |
d5f83109 JM |
331 | u32 *weighted_req_power; |
332 | u32 total_req_power, max_allocatable_power, total_weighted_req_power; | |
6828a471 | 333 | u32 total_granted_power, power_range; |
6b775e87 JM |
334 | int i, num_actors, total_weight, ret = 0; |
335 | int trip_max_desired_temperature = params->trip_max_desired_temperature; | |
336 | ||
337 | mutex_lock(&tz->lock); | |
338 | ||
339 | num_actors = 0; | |
340 | total_weight = 0; | |
341 | list_for_each_entry(instance, &tz->thermal_instances, tz_node) { | |
342 | if ((instance->trip == trip_max_desired_temperature) && | |
343 | cdev_is_power_actor(instance->cdev)) { | |
344 | num_actors++; | |
345 | total_weight += instance->weight; | |
346 | } | |
347 | } | |
348 | ||
97584d18 JM |
349 | if (!num_actors) { |
350 | ret = -ENODEV; | |
351 | goto unlock; | |
352 | } | |
353 | ||
6b775e87 | 354 | /* |
d5f83109 JM |
355 | * We need to allocate five arrays of the same size: |
356 | * req_power, max_power, granted_power, extra_actor_power and | |
357 | * weighted_req_power. They are going to be needed until this | |
358 | * function returns. Allocate them all in one go to simplify | |
359 | * the allocation and deallocation logic. | |
6b775e87 JM |
360 | */ |
361 | BUILD_BUG_ON(sizeof(*req_power) != sizeof(*max_power)); | |
362 | BUILD_BUG_ON(sizeof(*req_power) != sizeof(*granted_power)); | |
363 | BUILD_BUG_ON(sizeof(*req_power) != sizeof(*extra_actor_power)); | |
d5f83109 | 364 | BUILD_BUG_ON(sizeof(*req_power) != sizeof(*weighted_req_power)); |
9751a9e4 | 365 | req_power = kcalloc(num_actors * 5, sizeof(*req_power), GFP_KERNEL); |
6b775e87 JM |
366 | if (!req_power) { |
367 | ret = -ENOMEM; | |
368 | goto unlock; | |
369 | } | |
370 | ||
371 | max_power = &req_power[num_actors]; | |
372 | granted_power = &req_power[2 * num_actors]; | |
373 | extra_actor_power = &req_power[3 * num_actors]; | |
d5f83109 | 374 | weighted_req_power = &req_power[4 * num_actors]; |
6b775e87 JM |
375 | |
376 | i = 0; | |
d5f83109 | 377 | total_weighted_req_power = 0; |
6b775e87 JM |
378 | total_req_power = 0; |
379 | max_allocatable_power = 0; | |
380 | ||
381 | list_for_each_entry(instance, &tz->thermal_instances, tz_node) { | |
382 | int weight; | |
383 | struct thermal_cooling_device *cdev = instance->cdev; | |
384 | ||
385 | if (instance->trip != trip_max_desired_temperature) | |
386 | continue; | |
387 | ||
388 | if (!cdev_is_power_actor(cdev)) | |
389 | continue; | |
390 | ||
391 | if (cdev->ops->get_requested_power(cdev, tz, &req_power[i])) | |
392 | continue; | |
393 | ||
394 | if (!total_weight) | |
395 | weight = 1 << FRAC_BITS; | |
396 | else | |
397 | weight = instance->weight; | |
398 | ||
d5f83109 | 399 | weighted_req_power[i] = frac_to_int(weight * req_power[i]); |
6b775e87 JM |
400 | |
401 | if (power_actor_get_max_power(cdev, tz, &max_power[i])) | |
402 | continue; | |
403 | ||
404 | total_req_power += req_power[i]; | |
405 | max_allocatable_power += max_power[i]; | |
d5f83109 | 406 | total_weighted_req_power += weighted_req_power[i]; |
6b775e87 JM |
407 | |
408 | i++; | |
409 | } | |
410 | ||
411 | power_range = pid_controller(tz, current_temp, control_temp, | |
412 | max_allocatable_power); | |
413 | ||
d5f83109 JM |
414 | divvy_up_power(weighted_req_power, max_power, num_actors, |
415 | total_weighted_req_power, power_range, granted_power, | |
416 | extra_actor_power); | |
6b775e87 | 417 | |
6828a471 | 418 | total_granted_power = 0; |
6b775e87 JM |
419 | i = 0; |
420 | list_for_each_entry(instance, &tz->thermal_instances, tz_node) { | |
421 | if (instance->trip != trip_max_desired_temperature) | |
422 | continue; | |
423 | ||
424 | if (!cdev_is_power_actor(instance->cdev)) | |
425 | continue; | |
426 | ||
427 | power_actor_set_power(instance->cdev, instance, | |
428 | granted_power[i]); | |
6828a471 | 429 | total_granted_power += granted_power[i]; |
6b775e87 JM |
430 | |
431 | i++; | |
432 | } | |
433 | ||
6828a471 JM |
434 | trace_thermal_power_allocator(tz, req_power, total_req_power, |
435 | granted_power, total_granted_power, | |
436 | num_actors, power_range, | |
437 | max_allocatable_power, current_temp, | |
17e8351a | 438 | control_temp - current_temp); |
6828a471 | 439 | |
cf736ea6 | 440 | kfree(req_power); |
6b775e87 JM |
441 | unlock: |
442 | mutex_unlock(&tz->lock); | |
443 | ||
444 | return ret; | |
445 | } | |
446 | ||
8b7b390f JM |
447 | /** |
448 | * get_governor_trips() - get the number of the two trip points that are key for this governor | |
449 | * @tz: thermal zone to operate on | |
450 | * @params: pointer to private data for this governor | |
451 | * | |
452 | * The power allocator governor works optimally with two trips points: | |
453 | * a "switch on" trip point and a "maximum desired temperature". These | |
454 | * are defined as the first and last passive trip points. | |
455 | * | |
456 | * If there is only one trip point, then that's considered to be the | |
457 | * "maximum desired temperature" trip point and the governor is always | |
458 | * on. If there are no passive or active trip points, then the | |
459 | * governor won't do anything. In fact, its throttle function | |
460 | * won't be called at all. | |
461 | */ | |
462 | static void get_governor_trips(struct thermal_zone_device *tz, | |
463 | struct power_allocator_params *params) | |
6b775e87 | 464 | { |
8b7b390f | 465 | int i, last_active, last_passive; |
6b775e87 JM |
466 | bool found_first_passive; |
467 | ||
468 | found_first_passive = false; | |
8b7b390f JM |
469 | last_active = INVALID_TRIP; |
470 | last_passive = INVALID_TRIP; | |
6b775e87 JM |
471 | |
472 | for (i = 0; i < tz->trips; i++) { | |
473 | enum thermal_trip_type type; | |
8b7b390f | 474 | int ret; |
6b775e87 JM |
475 | |
476 | ret = tz->ops->get_trip_type(tz, i, &type); | |
8b7b390f JM |
477 | if (ret) { |
478 | dev_warn(&tz->device, | |
479 | "Failed to get trip point %d type: %d\n", i, | |
480 | ret); | |
481 | continue; | |
482 | } | |
6b775e87 | 483 | |
8b7b390f JM |
484 | if (type == THERMAL_TRIP_PASSIVE) { |
485 | if (!found_first_passive) { | |
6b775e87 JM |
486 | params->trip_switch_on = i; |
487 | found_first_passive = true; | |
8b7b390f JM |
488 | } else { |
489 | last_passive = i; | |
6b775e87 | 490 | } |
8b7b390f JM |
491 | } else if (type == THERMAL_TRIP_ACTIVE) { |
492 | last_active = i; | |
6b775e87 JM |
493 | } else { |
494 | break; | |
495 | } | |
496 | } | |
497 | ||
8b7b390f | 498 | if (last_passive != INVALID_TRIP) { |
6b775e87 | 499 | params->trip_max_desired_temperature = last_passive; |
8b7b390f JM |
500 | } else if (found_first_passive) { |
501 | params->trip_max_desired_temperature = params->trip_switch_on; | |
502 | params->trip_switch_on = INVALID_TRIP; | |
6b775e87 | 503 | } else { |
8b7b390f JM |
504 | params->trip_switch_on = INVALID_TRIP; |
505 | params->trip_max_desired_temperature = last_active; | |
6b775e87 | 506 | } |
6b775e87 JM |
507 | } |
508 | ||
509 | static void reset_pid_controller(struct power_allocator_params *params) | |
510 | { | |
511 | params->err_integral = 0; | |
512 | params->prev_err = 0; | |
513 | } | |
514 | ||
515 | static void allow_maximum_power(struct thermal_zone_device *tz) | |
516 | { | |
517 | struct thermal_instance *instance; | |
518 | struct power_allocator_params *params = tz->governor_data; | |
519 | ||
520 | list_for_each_entry(instance, &tz->thermal_instances, tz_node) { | |
521 | if ((instance->trip != params->trip_max_desired_temperature) || | |
522 | (!cdev_is_power_actor(instance->cdev))) | |
523 | continue; | |
524 | ||
525 | instance->target = 0; | |
526 | instance->cdev->updated = false; | |
527 | thermal_cdev_update(instance->cdev); | |
528 | } | |
529 | } | |
530 | ||
531 | /** | |
532 | * power_allocator_bind() - bind the power_allocator governor to a thermal zone | |
533 | * @tz: thermal zone to bind it to | |
534 | * | |
8b7b390f JM |
535 | * Initialize the PID controller parameters and bind it to the thermal |
536 | * zone. | |
6b775e87 | 537 | * |
f5cbb182 | 538 | * Return: 0 on success, or -ENOMEM if we ran out of memory. |
6b775e87 JM |
539 | */ |
540 | static int power_allocator_bind(struct thermal_zone_device *tz) | |
541 | { | |
542 | int ret; | |
543 | struct power_allocator_params *params; | |
e055bb0f | 544 | int control_temp; |
6b775e87 | 545 | |
cf736ea6 | 546 | params = kzalloc(sizeof(*params), GFP_KERNEL); |
6b775e87 JM |
547 | if (!params) |
548 | return -ENOMEM; | |
549 | ||
f5cbb182 JM |
550 | if (!tz->tzp) { |
551 | tz->tzp = kzalloc(sizeof(*tz->tzp), GFP_KERNEL); | |
552 | if (!tz->tzp) { | |
553 | ret = -ENOMEM; | |
554 | goto free_params; | |
555 | } | |
556 | ||
557 | params->allocated_tzp = true; | |
558 | } | |
559 | ||
e055bb0f JM |
560 | if (!tz->tzp->sustainable_power) |
561 | dev_warn(&tz->device, "power_allocator: sustainable_power will be estimated\n"); | |
562 | ||
8b7b390f | 563 | get_governor_trips(tz, params); |
6b775e87 | 564 | |
8b7b390f JM |
565 | if (tz->trips > 0) { |
566 | ret = tz->ops->get_trip_temp(tz, | |
567 | params->trip_max_desired_temperature, | |
568 | &control_temp); | |
569 | if (!ret) | |
570 | estimate_pid_constants(tz, tz->tzp->sustainable_power, | |
571 | params->trip_switch_on, | |
572 | control_temp, false); | |
573 | } | |
6b775e87 | 574 | |
6b775e87 JM |
575 | reset_pid_controller(params); |
576 | ||
577 | tz->governor_data = params; | |
578 | ||
579 | return 0; | |
f5cbb182 JM |
580 | |
581 | free_params: | |
582 | kfree(params); | |
583 | ||
584 | return ret; | |
6b775e87 JM |
585 | } |
586 | ||
587 | static void power_allocator_unbind(struct thermal_zone_device *tz) | |
588 | { | |
f5cbb182 JM |
589 | struct power_allocator_params *params = tz->governor_data; |
590 | ||
6b775e87 | 591 | dev_dbg(&tz->device, "Unbinding from thermal zone %d\n", tz->id); |
f5cbb182 JM |
592 | |
593 | if (params->allocated_tzp) { | |
594 | kfree(tz->tzp); | |
595 | tz->tzp = NULL; | |
596 | } | |
597 | ||
cf736ea6 | 598 | kfree(tz->governor_data); |
6b775e87 JM |
599 | tz->governor_data = NULL; |
600 | } | |
601 | ||
602 | static int power_allocator_throttle(struct thermal_zone_device *tz, int trip) | |
603 | { | |
604 | int ret; | |
17e8351a | 605 | int switch_on_temp, control_temp, current_temp; |
6b775e87 JM |
606 | struct power_allocator_params *params = tz->governor_data; |
607 | ||
608 | /* | |
609 | * We get called for every trip point but we only need to do | |
610 | * our calculations once | |
611 | */ | |
612 | if (trip != params->trip_max_desired_temperature) | |
613 | return 0; | |
614 | ||
615 | ret = thermal_zone_get_temp(tz, ¤t_temp); | |
616 | if (ret) { | |
617 | dev_warn(&tz->device, "Failed to get temperature: %d\n", ret); | |
618 | return ret; | |
619 | } | |
620 | ||
621 | ret = tz->ops->get_trip_temp(tz, params->trip_switch_on, | |
622 | &switch_on_temp); | |
8b7b390f | 623 | if (!ret && (current_temp < switch_on_temp)) { |
6b775e87 JM |
624 | tz->passive = 0; |
625 | reset_pid_controller(params); | |
626 | allow_maximum_power(tz); | |
627 | return 0; | |
628 | } | |
629 | ||
630 | tz->passive = 1; | |
631 | ||
632 | ret = tz->ops->get_trip_temp(tz, params->trip_max_desired_temperature, | |
633 | &control_temp); | |
634 | if (ret) { | |
635 | dev_warn(&tz->device, | |
636 | "Failed to get the maximum desired temperature: %d\n", | |
637 | ret); | |
638 | return ret; | |
639 | } | |
640 | ||
641 | return allocate_power(tz, current_temp, control_temp); | |
642 | } | |
643 | ||
644 | static struct thermal_governor thermal_gov_power_allocator = { | |
645 | .name = "power_allocator", | |
646 | .bind_to_tz = power_allocator_bind, | |
647 | .unbind_from_tz = power_allocator_unbind, | |
648 | .throttle = power_allocator_throttle, | |
649 | }; | |
650 | ||
651 | int thermal_gov_power_allocator_register(void) | |
652 | { | |
653 | return thermal_register_governor(&thermal_gov_power_allocator); | |
654 | } | |
655 | ||
656 | void thermal_gov_power_allocator_unregister(void) | |
657 | { | |
658 | thermal_unregister_governor(&thermal_gov_power_allocator); | |
659 | } |