1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * of-thermal.c - Generic Thermal Management device tree support. |
4 | * |
5 | * Copyright (C) 2013 Texas Instruments |
6 | * Copyright (C) 2013 Eduardo Valentin <eduardo.valentin@ti.com> |
7 | */ |
8 | |
9 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
10 | |
11 | #include <linux/err.h> |
12 | #include <linux/export.h> |
13 | #include <linux/of.h> |
14 | #include <linux/slab.h> |
15 | #include <linux/thermal.h> |
16 | #include <linux/types.h> |
17 | #include <linux/string.h> |
18 | |
19 | #include "thermal_core.h" |
20 | |
21 | /*** functions parsing device tree nodes ***/ |
22 | |
23 | static int of_find_trip_id(struct device_node *np, struct device_node *trip) |
24 | { |
25 | struct device_node *trips; |
26 | struct device_node *t; |
27 | int i = 0; |
28 | |
29 | trips = of_get_child_by_name(node: np, name: "trips" ); |
30 | if (!trips) { |
31 | pr_err("Failed to find 'trips' node\n" ); |
32 | return -EINVAL; |
33 | } |
34 | |
35 | /* |
36 | * Find the trip id point associated with the cooling device map |
37 | */ |
38 | for_each_child_of_node(trips, t) { |
39 | |
40 | if (t == trip) { |
41 | of_node_put(node: t); |
42 | goto out; |
43 | } |
44 | i++; |
45 | } |
46 | |
47 | i = -ENXIO; |
48 | out: |
49 | of_node_put(node: trips); |
50 | |
51 | return i; |
52 | } |
53 | |
54 | /* |
55 | * It maps 'enum thermal_trip_type' found in include/linux/thermal.h |
56 | * into the device tree binding of 'trip', property type. |
57 | */ |
58 | static const char * const trip_types[] = { |
59 | [THERMAL_TRIP_ACTIVE] = "active" , |
60 | [THERMAL_TRIP_PASSIVE] = "passive" , |
61 | [THERMAL_TRIP_HOT] = "hot" , |
62 | [THERMAL_TRIP_CRITICAL] = "critical" , |
63 | }; |
64 | |
65 | /** |
66 | * thermal_of_get_trip_type - Get phy mode for given device_node |
67 | * @np: Pointer to the given device_node |
68 | * @type: Pointer to resulting trip type |
69 | * |
70 | * The function gets trip type string from property 'type', |
71 | * and store its index in trip_types table in @type, |
72 | * |
73 | * Return: 0 on success, or errno in error case. |
74 | */ |
75 | static int thermal_of_get_trip_type(struct device_node *np, |
76 | enum thermal_trip_type *type) |
77 | { |
78 | const char *t; |
79 | int err, i; |
80 | |
81 | err = of_property_read_string(np, propname: "type" , out_string: &t); |
82 | if (err < 0) |
83 | return err; |
84 | |
85 | for (i = 0; i < ARRAY_SIZE(trip_types); i++) |
86 | if (!strcasecmp(s1: t, s2: trip_types[i])) { |
87 | *type = i; |
88 | return 0; |
89 | } |
90 | |
91 | return -ENODEV; |
92 | } |
93 | |
94 | static int thermal_of_populate_trip(struct device_node *np, |
95 | struct thermal_trip *trip) |
96 | { |
97 | int prop; |
98 | int ret; |
99 | |
100 | ret = of_property_read_u32(np, propname: "temperature" , out_value: &prop); |
101 | if (ret < 0) { |
102 | pr_err("missing temperature property\n" ); |
103 | return ret; |
104 | } |
105 | trip->temperature = prop; |
106 | |
107 | ret = of_property_read_u32(np, propname: "hysteresis" , out_value: &prop); |
108 | if (ret < 0) { |
109 | pr_err("missing hysteresis property\n" ); |
110 | return ret; |
111 | } |
112 | trip->hysteresis = prop; |
113 | |
114 | ret = thermal_of_get_trip_type(np, type: &trip->type); |
115 | if (ret < 0) { |
116 | pr_err("wrong trip type property\n" ); |
117 | return ret; |
118 | } |
119 | |
120 | trip->flags = THERMAL_TRIP_FLAG_RW_TEMP; |
121 | |
122 | return 0; |
123 | } |
124 | |
125 | static struct thermal_trip *thermal_of_trips_init(struct device_node *np, int *ntrips) |
126 | { |
127 | struct thermal_trip *tt; |
128 | struct device_node *trips, *trip; |
129 | int ret, count; |
130 | |
131 | trips = of_get_child_by_name(node: np, name: "trips" ); |
132 | if (!trips) { |
133 | pr_err("Failed to find 'trips' node\n" ); |
134 | return ERR_PTR(error: -EINVAL); |
135 | } |
136 | |
137 | count = of_get_child_count(np: trips); |
138 | if (!count) { |
139 | pr_err("No trip point defined\n" ); |
140 | ret = -EINVAL; |
141 | goto out_of_node_put; |
142 | } |
143 | |
144 | tt = kzalloc(size: sizeof(*tt) * count, GFP_KERNEL); |
145 | if (!tt) { |
146 | ret = -ENOMEM; |
147 | goto out_of_node_put; |
148 | } |
149 | |
150 | *ntrips = count; |
151 | |
152 | count = 0; |
153 | for_each_child_of_node(trips, trip) { |
154 | ret = thermal_of_populate_trip(np: trip, trip: &tt[count++]); |
155 | if (ret) |
156 | goto out_kfree; |
157 | } |
158 | |
159 | of_node_put(node: trips); |
160 | |
161 | return tt; |
162 | |
163 | out_kfree: |
164 | kfree(objp: tt); |
165 | *ntrips = 0; |
166 | out_of_node_put: |
167 | of_node_put(node: trips); |
168 | |
169 | return ERR_PTR(error: ret); |
170 | } |
171 | |
172 | static struct device_node *of_thermal_zone_find(struct device_node *sensor, int id) |
173 | { |
174 | struct device_node *np, *tz; |
175 | struct of_phandle_args sensor_specs; |
176 | |
177 | np = of_find_node_by_name(NULL, name: "thermal-zones" ); |
178 | if (!np) { |
179 | pr_debug("No thermal zones description\n" ); |
180 | return ERR_PTR(error: -ENODEV); |
181 | } |
182 | |
183 | /* |
184 | * Search for each thermal zone, a defined sensor |
185 | * corresponding to the one passed as parameter |
186 | */ |
187 | for_each_available_child_of_node(np, tz) { |
188 | |
189 | int count, i; |
190 | |
191 | count = of_count_phandle_with_args(np: tz, list_name: "thermal-sensors" , |
192 | cells_name: "#thermal-sensor-cells" ); |
193 | if (count <= 0) { |
194 | pr_err("%pOFn: missing thermal sensor\n" , tz); |
195 | tz = ERR_PTR(error: -EINVAL); |
196 | goto out; |
197 | } |
198 | |
199 | for (i = 0; i < count; i++) { |
200 | |
201 | int ret; |
202 | |
203 | ret = of_parse_phandle_with_args(np: tz, list_name: "thermal-sensors" , |
204 | cells_name: "#thermal-sensor-cells" , |
205 | index: i, out_args: &sensor_specs); |
206 | if (ret < 0) { |
207 | pr_err("%pOFn: Failed to read thermal-sensors cells: %d\n" , tz, ret); |
208 | tz = ERR_PTR(error: ret); |
209 | goto out; |
210 | } |
211 | |
212 | if ((sensor == sensor_specs.np) && id == (sensor_specs.args_count ? |
213 | sensor_specs.args[0] : 0)) { |
214 | pr_debug("sensor %pOFn id=%d belongs to %pOFn\n" , sensor, id, tz); |
215 | goto out; |
216 | } |
217 | } |
218 | } |
219 | tz = ERR_PTR(error: -ENODEV); |
220 | out: |
221 | of_node_put(node: np); |
222 | return tz; |
223 | } |
224 | |
225 | static int thermal_of_monitor_init(struct device_node *np, int *delay, int *pdelay) |
226 | { |
227 | int ret; |
228 | |
229 | ret = of_property_read_u32(np, propname: "polling-delay-passive" , out_value: pdelay); |
230 | if (ret == -EINVAL) { |
231 | *pdelay = 0; |
232 | } else if (ret < 0) { |
233 | pr_err("%pOFn: Couldn't get polling-delay-passive: %d\n" , np, ret); |
234 | return ret; |
235 | } |
236 | |
237 | ret = of_property_read_u32(np, propname: "polling-delay" , out_value: delay); |
238 | if (ret == -EINVAL) { |
239 | *delay = 0; |
240 | } else if (ret < 0) { |
241 | pr_err("%pOFn: Couldn't get polling-delay: %d\n" , np, ret); |
242 | return ret; |
243 | } |
244 | |
245 | return 0; |
246 | } |
247 | |
248 | static void thermal_of_parameters_init(struct device_node *np, |
249 | struct thermal_zone_params *tzp) |
250 | { |
251 | int coef[2]; |
252 | int ncoef = ARRAY_SIZE(coef); |
253 | int prop, ret; |
254 | |
255 | tzp->no_hwmon = true; |
256 | |
257 | if (!of_property_read_u32(np, propname: "sustainable-power" , out_value: &prop)) |
258 | tzp->sustainable_power = prop; |
259 | |
260 | /* |
261 | * For now, the thermal framework supports only one sensor per |
262 | * thermal zone. Thus, we are considering only the first two |
263 | * values as slope and offset. |
264 | */ |
265 | ret = of_property_read_u32_array(np, propname: "coefficients" , out_values: coef, sz: ncoef); |
266 | if (ret) { |
267 | coef[0] = 1; |
268 | coef[1] = 0; |
269 | } |
270 | |
271 | tzp->slope = coef[0]; |
272 | tzp->offset = coef[1]; |
273 | } |
274 | |
275 | static struct device_node *thermal_of_zone_get_by_name(struct thermal_zone_device *tz) |
276 | { |
277 | struct device_node *np, *tz_np; |
278 | |
279 | np = of_find_node_by_name(NULL, name: "thermal-zones" ); |
280 | if (!np) |
281 | return ERR_PTR(error: -ENODEV); |
282 | |
283 | tz_np = of_get_child_by_name(node: np, name: tz->type); |
284 | |
285 | of_node_put(node: np); |
286 | |
287 | if (!tz_np) |
288 | return ERR_PTR(error: -ENODEV); |
289 | |
290 | return tz_np; |
291 | } |
292 | |
293 | static int __thermal_of_unbind(struct device_node *map_np, int index, int trip_id, |
294 | struct thermal_zone_device *tz, struct thermal_cooling_device *cdev) |
295 | { |
296 | struct of_phandle_args cooling_spec; |
297 | int ret; |
298 | |
299 | ret = of_parse_phandle_with_args(np: map_np, list_name: "cooling-device" , cells_name: "#cooling-cells" , |
300 | index, out_args: &cooling_spec); |
301 | |
302 | if (ret < 0) { |
303 | pr_err("Invalid cooling-device entry\n" ); |
304 | return ret; |
305 | } |
306 | |
307 | of_node_put(node: cooling_spec.np); |
308 | |
309 | if (cooling_spec.args_count < 2) { |
310 | pr_err("wrong reference to cooling device, missing limits\n" ); |
311 | return -EINVAL; |
312 | } |
313 | |
314 | if (cooling_spec.np != cdev->np) |
315 | return 0; |
316 | |
317 | ret = thermal_zone_unbind_cooling_device(tz, trip_id, cdev); |
318 | if (ret) |
319 | pr_err("Failed to unbind '%s' with '%s': %d\n" , tz->type, cdev->type, ret); |
320 | |
321 | return ret; |
322 | } |
323 | |
324 | static int __thermal_of_bind(struct device_node *map_np, int index, int trip_id, |
325 | struct thermal_zone_device *tz, struct thermal_cooling_device *cdev) |
326 | { |
327 | struct of_phandle_args cooling_spec; |
328 | int ret, weight = THERMAL_WEIGHT_DEFAULT; |
329 | |
330 | of_property_read_u32(np: map_np, propname: "contribution" , out_value: &weight); |
331 | |
332 | ret = of_parse_phandle_with_args(np: map_np, list_name: "cooling-device" , cells_name: "#cooling-cells" , |
333 | index, out_args: &cooling_spec); |
334 | |
335 | if (ret < 0) { |
336 | pr_err("Invalid cooling-device entry\n" ); |
337 | return ret; |
338 | } |
339 | |
340 | of_node_put(node: cooling_spec.np); |
341 | |
342 | if (cooling_spec.args_count < 2) { |
343 | pr_err("wrong reference to cooling device, missing limits\n" ); |
344 | return -EINVAL; |
345 | } |
346 | |
347 | if (cooling_spec.np != cdev->np) |
348 | return 0; |
349 | |
350 | ret = thermal_zone_bind_cooling_device(tz, trip_id, cdev, cooling_spec.args[1], |
351 | cooling_spec.args[0], |
352 | weight); |
353 | if (ret) |
354 | pr_err("Failed to bind '%s' with '%s': %d\n" , tz->type, cdev->type, ret); |
355 | |
356 | return ret; |
357 | } |
358 | |
359 | static int thermal_of_for_each_cooling_device(struct device_node *tz_np, struct device_node *map_np, |
360 | struct thermal_zone_device *tz, struct thermal_cooling_device *cdev, |
361 | int (*action)(struct device_node *, int, int, |
362 | struct thermal_zone_device *, struct thermal_cooling_device *)) |
363 | { |
364 | struct device_node *tr_np; |
365 | int count, i, trip_id; |
366 | |
367 | tr_np = of_parse_phandle(np: map_np, phandle_name: "trip" , index: 0); |
368 | if (!tr_np) |
369 | return -ENODEV; |
370 | |
371 | trip_id = of_find_trip_id(np: tz_np, trip: tr_np); |
372 | if (trip_id < 0) |
373 | return trip_id; |
374 | |
375 | count = of_count_phandle_with_args(np: map_np, list_name: "cooling-device" , cells_name: "#cooling-cells" ); |
376 | if (count <= 0) { |
377 | pr_err("Add a cooling_device property with at least one device\n" ); |
378 | return -ENOENT; |
379 | } |
380 | |
381 | /* |
382 | * At this point, we don't want to bail out when there is an |
383 | * error, we will try to bind/unbind as many as possible |
384 | * cooling devices |
385 | */ |
386 | for (i = 0; i < count; i++) |
387 | action(map_np, i, trip_id, tz, cdev); |
388 | |
389 | return 0; |
390 | } |
391 | |
392 | static int thermal_of_for_each_cooling_maps(struct thermal_zone_device *tz, |
393 | struct thermal_cooling_device *cdev, |
394 | int (*action)(struct device_node *, int, int, |
395 | struct thermal_zone_device *, struct thermal_cooling_device *)) |
396 | { |
397 | struct device_node *tz_np, *cm_np, *child; |
398 | int ret = 0; |
399 | |
400 | tz_np = thermal_of_zone_get_by_name(tz); |
401 | if (IS_ERR(ptr: tz_np)) { |
402 | pr_err("Failed to get node tz by name\n" ); |
403 | return PTR_ERR(ptr: tz_np); |
404 | } |
405 | |
406 | cm_np = of_get_child_by_name(node: tz_np, name: "cooling-maps" ); |
407 | if (!cm_np) |
408 | goto out; |
409 | |
410 | for_each_child_of_node(cm_np, child) { |
411 | ret = thermal_of_for_each_cooling_device(tz_np, map_np: child, tz, cdev, action); |
412 | if (ret) { |
413 | of_node_put(node: child); |
414 | break; |
415 | } |
416 | } |
417 | |
418 | of_node_put(node: cm_np); |
419 | out: |
420 | of_node_put(node: tz_np); |
421 | |
422 | return ret; |
423 | } |
424 | |
425 | static int thermal_of_bind(struct thermal_zone_device *tz, |
426 | struct thermal_cooling_device *cdev) |
427 | { |
428 | return thermal_of_for_each_cooling_maps(tz, cdev, action: __thermal_of_bind); |
429 | } |
430 | |
431 | static int thermal_of_unbind(struct thermal_zone_device *tz, |
432 | struct thermal_cooling_device *cdev) |
433 | { |
434 | return thermal_of_for_each_cooling_maps(tz, cdev, action: __thermal_of_unbind); |
435 | } |
436 | |
437 | /** |
438 | * thermal_of_zone_unregister - Cleanup the specific allocated ressources |
439 | * |
440 | * This function disables the thermal zone and frees the different |
441 | * ressources allocated specific to the thermal OF. |
442 | * |
443 | * @tz: a pointer to the thermal zone structure |
444 | */ |
445 | static void thermal_of_zone_unregister(struct thermal_zone_device *tz) |
446 | { |
447 | thermal_zone_device_disable(tz); |
448 | thermal_zone_device_unregister(tz); |
449 | } |
450 | |
451 | /** |
452 | * thermal_of_zone_register - Register a thermal zone with device node |
453 | * sensor |
454 | * |
455 | * The thermal_of_zone_register() parses a device tree given a device |
456 | * node sensor and identifier. It searches for the thermal zone |
457 | * associated to the couple sensor/id and retrieves all the thermal |
458 | * zone properties and registers new thermal zone with those |
459 | * properties. |
460 | * |
461 | * @sensor: A device node pointer corresponding to the sensor in the device tree |
462 | * @id: An integer as sensor identifier |
463 | * @data: A private data to be stored in the thermal zone dedicated private area |
464 | * @ops: A set of thermal sensor ops |
465 | * |
466 | * Return: a valid thermal zone structure pointer on success. |
467 | * - EINVAL: if the device tree thermal description is malformed |
468 | * - ENOMEM: if one structure can not be allocated |
469 | * - Other negative errors are returned by the underlying called functions |
470 | */ |
471 | static struct thermal_zone_device *thermal_of_zone_register(struct device_node *sensor, int id, void *data, |
472 | const struct thermal_zone_device_ops *ops) |
473 | { |
474 | struct thermal_zone_device_ops of_ops = *ops; |
475 | struct thermal_zone_device *tz; |
476 | struct thermal_trip *trips; |
477 | struct thermal_zone_params tzp = {}; |
478 | struct device_node *np; |
479 | const char *action; |
480 | int delay, pdelay; |
481 | int ntrips; |
482 | int ret; |
483 | |
484 | np = of_thermal_zone_find(sensor, id); |
485 | if (IS_ERR(ptr: np)) { |
486 | if (PTR_ERR(ptr: np) != -ENODEV) |
487 | pr_err("Failed to find thermal zone for %pOFn id=%d\n" , sensor, id); |
488 | return ERR_CAST(ptr: np); |
489 | } |
490 | |
491 | trips = thermal_of_trips_init(np, ntrips: &ntrips); |
492 | if (IS_ERR(ptr: trips)) { |
493 | pr_err("Failed to find trip points for %pOFn id=%d\n" , sensor, id); |
494 | return ERR_CAST(ptr: trips); |
495 | } |
496 | |
497 | ret = thermal_of_monitor_init(np, delay: &delay, pdelay: &pdelay); |
498 | if (ret) { |
499 | pr_err("Failed to initialize monitoring delays from %pOFn\n" , np); |
500 | goto out_kfree_trips; |
501 | } |
502 | |
503 | thermal_of_parameters_init(np, tzp: &tzp); |
504 | |
505 | of_ops.bind = thermal_of_bind; |
506 | of_ops.unbind = thermal_of_unbind; |
507 | |
508 | ret = of_property_read_string(np, propname: "critical-action" , out_string: &action); |
509 | if (!ret) |
510 | if (!of_ops.critical && !strcasecmp(s1: action, s2: "reboot" )) |
511 | of_ops.critical = thermal_zone_device_critical_reboot; |
512 | |
513 | tz = thermal_zone_device_register_with_trips(type: np->name, trips, num_trips: ntrips, |
514 | devdata: data, ops: &of_ops, tzp: &tzp, |
515 | passive_delay: pdelay, polling_delay: delay); |
516 | if (IS_ERR(ptr: tz)) { |
517 | ret = PTR_ERR(ptr: tz); |
518 | pr_err("Failed to register thermal zone %pOFn: %d\n" , np, ret); |
519 | goto out_kfree_trips; |
520 | } |
521 | |
522 | kfree(objp: trips); |
523 | |
524 | ret = thermal_zone_device_enable(tz); |
525 | if (ret) { |
526 | pr_err("Failed to enabled thermal zone '%s', id=%d: %d\n" , |
527 | tz->type, tz->id, ret); |
528 | thermal_of_zone_unregister(tz); |
529 | return ERR_PTR(error: ret); |
530 | } |
531 | |
532 | return tz; |
533 | |
534 | out_kfree_trips: |
535 | kfree(objp: trips); |
536 | |
537 | return ERR_PTR(error: ret); |
538 | } |
539 | |
540 | static void devm_thermal_of_zone_release(struct device *dev, void *res) |
541 | { |
542 | thermal_of_zone_unregister(tz: *(struct thermal_zone_device **)res); |
543 | } |
544 | |
545 | static int devm_thermal_of_zone_match(struct device *dev, void *res, |
546 | void *data) |
547 | { |
548 | struct thermal_zone_device **r = res; |
549 | |
550 | if (WARN_ON(!r || !*r)) |
551 | return 0; |
552 | |
553 | return *r == data; |
554 | } |
555 | |
556 | /** |
557 | * devm_thermal_of_zone_register - register a thermal tied with the sensor life cycle |
558 | * |
559 | * This function is the device version of the thermal_of_zone_register() function. |
560 | * |
561 | * @dev: a device structure pointer to sensor to be tied with the thermal zone OF life cycle |
562 | * @sensor_id: the sensor identifier |
563 | * @data: a pointer to a private data to be stored in the thermal zone 'devdata' field |
564 | * @ops: a pointer to the ops structure associated with the sensor |
565 | */ |
566 | struct thermal_zone_device *devm_thermal_of_zone_register(struct device *dev, int sensor_id, void *data, |
567 | const struct thermal_zone_device_ops *ops) |
568 | { |
569 | struct thermal_zone_device **ptr, *tzd; |
570 | |
571 | ptr = devres_alloc(devm_thermal_of_zone_release, sizeof(*ptr), |
572 | GFP_KERNEL); |
573 | if (!ptr) |
574 | return ERR_PTR(error: -ENOMEM); |
575 | |
576 | tzd = thermal_of_zone_register(sensor: dev->of_node, id: sensor_id, data, ops); |
577 | if (IS_ERR(ptr: tzd)) { |
578 | devres_free(res: ptr); |
579 | return tzd; |
580 | } |
581 | |
582 | *ptr = tzd; |
583 | devres_add(dev, res: ptr); |
584 | |
585 | return tzd; |
586 | } |
587 | EXPORT_SYMBOL_GPL(devm_thermal_of_zone_register); |
588 | |
589 | /** |
590 | * devm_thermal_of_zone_unregister - Resource managed version of |
591 | * thermal_of_zone_unregister(). |
592 | * @dev: Device for which which resource was allocated. |
593 | * @tz: a pointer to struct thermal_zone where the sensor is registered. |
594 | * |
595 | * This function removes the sensor callbacks and private data from the |
596 | * thermal zone device registered with devm_thermal_zone_of_sensor_register() |
597 | * API. It will also silent the zone by remove the .get_temp() and .get_trend() |
598 | * thermal zone device callbacks. |
599 | * Normally this function will not need to be called and the resource |
600 | * management code will ensure that the resource is freed. |
601 | */ |
602 | void devm_thermal_of_zone_unregister(struct device *dev, struct thermal_zone_device *tz) |
603 | { |
604 | WARN_ON(devres_release(dev, devm_thermal_of_zone_release, |
605 | devm_thermal_of_zone_match, tz)); |
606 | } |
607 | EXPORT_SYMBOL_GPL(devm_thermal_of_zone_unregister); |
608 | |