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

source code of linux/drivers/thermal/thermal_of.c