xref: /openbmc/linux/drivers/thermal/thermal_of.c (revision d3304dbc)
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 
of_find_trip_id(struct device_node * np,struct device_node * trip)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(np, "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(t);
42 			goto out;
43 		}
44 		i++;
45 	}
46 
47 	i = -ENXIO;
48 out:
49 	of_node_put(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  */
thermal_of_get_trip_type(struct device_node * np,enum thermal_trip_type * type)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, "type", &t);
82 	if (err < 0)
83 		return err;
84 
85 	for (i = 0; i < ARRAY_SIZE(trip_types); i++)
86 		if (!strcasecmp(t, trip_types[i])) {
87 			*type = i;
88 			return 0;
89 		}
90 
91 	return -ENODEV;
92 }
93 
thermal_of_populate_trip(struct device_node * np,struct thermal_trip * trip)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, "temperature", &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, "hysteresis", &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, &trip->type);
115 	if (ret < 0) {
116 		pr_err("wrong trip type property\n");
117 		return ret;
118 	}
119 
120 	return 0;
121 }
122 
thermal_of_trips_init(struct device_node * np,int * ntrips)123 static struct thermal_trip *thermal_of_trips_init(struct device_node *np, int *ntrips)
124 {
125 	struct thermal_trip *tt;
126 	struct device_node *trips;
127 	int ret, count;
128 
129 	*ntrips = 0;
130 
131 	trips = of_get_child_by_name(np, "trips");
132 	if (!trips)
133 		return NULL;
134 
135 	count = of_get_child_count(trips);
136 	if (!count)
137 		return NULL;
138 
139 	tt = kzalloc(sizeof(*tt) * count, GFP_KERNEL);
140 	if (!tt) {
141 		ret = -ENOMEM;
142 		goto out_of_node_put;
143 	}
144 
145 	*ntrips = count;
146 
147 	count = 0;
148 	for_each_child_of_node_scoped(trips, trip) {
149 		ret = thermal_of_populate_trip(trip, &tt[count++]);
150 		if (ret)
151 			goto out_kfree;
152 	}
153 
154 	of_node_put(trips);
155 
156 	return tt;
157 
158 out_kfree:
159 	kfree(tt);
160 out_of_node_put:
161 	of_node_put(trips);
162 
163 	return ERR_PTR(ret);
164 }
165 
of_thermal_zone_find(struct device_node * sensor,int id)166 static struct device_node *of_thermal_zone_find(struct device_node *sensor, int id)
167 {
168 	struct device_node *np, *tz;
169 	struct of_phandle_args sensor_specs;
170 
171 	np = of_find_node_by_name(NULL, "thermal-zones");
172 	if (!np) {
173 		pr_debug("No thermal zones description\n");
174 		return ERR_PTR(-ENODEV);
175 	}
176 
177 	/*
178 	 * Search for each thermal zone, a defined sensor
179 	 * corresponding to the one passed as parameter
180 	 */
181 	for_each_available_child_of_node_scoped(np, child) {
182 
183 		int count, i;
184 
185 		count = of_count_phandle_with_args(child, "thermal-sensors",
186 						   "#thermal-sensor-cells");
187 		if (count <= 0) {
188 			pr_err("%pOFn: missing thermal sensor\n", child);
189 			tz = ERR_PTR(-EINVAL);
190 			goto out;
191 		}
192 
193 		for (i = 0; i < count; i++) {
194 
195 			int ret;
196 
197 			ret = of_parse_phandle_with_args(child, "thermal-sensors",
198 							 "#thermal-sensor-cells",
199 							 i, &sensor_specs);
200 			if (ret < 0) {
201 				pr_err("%pOFn: Failed to read thermal-sensors cells: %d\n", child, ret);
202 				tz = ERR_PTR(ret);
203 				goto out;
204 			}
205 
206 			if ((sensor == sensor_specs.np) && id == (sensor_specs.args_count ?
207 								  sensor_specs.args[0] : 0)) {
208 				pr_debug("sensor %pOFn id=%d belongs to %pOFn\n", sensor, id, child);
209 				tz = no_free_ptr(child);
210 				goto out;
211 			}
212 		}
213 	}
214 	tz = ERR_PTR(-ENODEV);
215 out:
216 	of_node_put(np);
217 	return tz;
218 }
219 
thermal_of_monitor_init(struct device_node * np,int * delay,int * pdelay)220 static int thermal_of_monitor_init(struct device_node *np, int *delay, int *pdelay)
221 {
222 	int ret;
223 
224 	ret = of_property_read_u32(np, "polling-delay-passive", pdelay);
225 	if (ret == -EINVAL) {
226 		*pdelay = 0;
227 	} else if (ret < 0) {
228 		pr_err("%pOFn: Couldn't get polling-delay-passive: %d\n", np, ret);
229 		return ret;
230 	}
231 
232 	ret = of_property_read_u32(np, "polling-delay", delay);
233 	if (ret == -EINVAL) {
234 		*delay = 0;
235 	} else if (ret < 0) {
236 		pr_err("%pOFn: Couldn't get polling-delay: %d\n", np, ret);
237 		return ret;
238 	}
239 
240 	return 0;
241 }
242 
thermal_of_parameters_init(struct device_node * np,struct thermal_zone_params * tzp)243 static void thermal_of_parameters_init(struct device_node *np,
244 				       struct thermal_zone_params *tzp)
245 {
246 	int coef[2];
247 	int ncoef = ARRAY_SIZE(coef);
248 	int prop, ret;
249 
250 	tzp->no_hwmon = true;
251 
252 	if (!of_property_read_u32(np, "sustainable-power", &prop))
253 		tzp->sustainable_power = prop;
254 
255 	/*
256 	 * For now, the thermal framework supports only one sensor per
257 	 * thermal zone. Thus, we are considering only the first two
258 	 * values as slope and offset.
259 	 */
260 	ret = of_property_read_u32_array(np, "coefficients", coef, ncoef);
261 	if (ret) {
262 		coef[0] = 1;
263 		coef[1] = 0;
264 	}
265 
266 	tzp->slope = coef[0];
267 	tzp->offset = coef[1];
268 }
269 
thermal_of_zone_get_by_name(struct thermal_zone_device * tz)270 static struct device_node *thermal_of_zone_get_by_name(struct thermal_zone_device *tz)
271 {
272 	struct device_node *np, *tz_np;
273 
274 	np = of_find_node_by_name(NULL, "thermal-zones");
275 	if (!np)
276 		return ERR_PTR(-ENODEV);
277 
278 	tz_np = of_get_child_by_name(np, tz->type);
279 
280 	of_node_put(np);
281 
282 	if (!tz_np)
283 		return ERR_PTR(-ENODEV);
284 
285 	return tz_np;
286 }
287 
__thermal_of_unbind(struct device_node * map_np,int index,int trip_id,struct thermal_zone_device * tz,struct thermal_cooling_device * cdev)288 static int __thermal_of_unbind(struct device_node *map_np, int index, int trip_id,
289 			       struct thermal_zone_device *tz, struct thermal_cooling_device *cdev)
290 {
291 	struct of_phandle_args cooling_spec;
292 	int ret;
293 
294 	ret = of_parse_phandle_with_args(map_np, "cooling-device", "#cooling-cells",
295 					 index, &cooling_spec);
296 
297 	if (ret < 0) {
298 		pr_err("Invalid cooling-device entry\n");
299 		return ret;
300 	}
301 
302 	of_node_put(cooling_spec.np);
303 
304 	if (cooling_spec.args_count < 2) {
305 		pr_err("wrong reference to cooling device, missing limits\n");
306 		return -EINVAL;
307 	}
308 
309 	if (cooling_spec.np != cdev->np)
310 		return 0;
311 
312 	ret = thermal_zone_unbind_cooling_device(tz, trip_id, cdev);
313 	if (ret)
314 		pr_err("Failed to unbind '%s' with '%s': %d\n", tz->type, cdev->type, ret);
315 
316 	return ret;
317 }
318 
__thermal_of_bind(struct device_node * map_np,int index,int trip_id,struct thermal_zone_device * tz,struct thermal_cooling_device * cdev)319 static int __thermal_of_bind(struct device_node *map_np, int index, int trip_id,
320 			     struct thermal_zone_device *tz, struct thermal_cooling_device *cdev)
321 {
322 	struct of_phandle_args cooling_spec;
323 	int ret, weight = THERMAL_WEIGHT_DEFAULT;
324 
325 	of_property_read_u32(map_np, "contribution", &weight);
326 
327 	ret = of_parse_phandle_with_args(map_np, "cooling-device", "#cooling-cells",
328 					 index, &cooling_spec);
329 
330 	if (ret < 0) {
331 		pr_err("Invalid cooling-device entry\n");
332 		return ret;
333 	}
334 
335 	of_node_put(cooling_spec.np);
336 
337 	if (cooling_spec.args_count < 2) {
338 		pr_err("wrong reference to cooling device, missing limits\n");
339 		return -EINVAL;
340 	}
341 
342 	if (cooling_spec.np != cdev->np)
343 		return 0;
344 
345 	ret = thermal_zone_bind_cooling_device(tz, trip_id, cdev, cooling_spec.args[1],
346 					       cooling_spec.args[0],
347 					       weight);
348 	if (ret)
349 		pr_err("Failed to bind '%s' with '%s': %d\n", tz->type, cdev->type, ret);
350 
351 	return ret;
352 }
353 
thermal_of_for_each_cooling_device(struct device_node * tz_np,struct device_node * map_np,struct thermal_zone_device * tz,struct thermal_cooling_device * cdev,int (* action)(struct device_node *,int,int,struct thermal_zone_device *,struct thermal_cooling_device *))354 static int thermal_of_for_each_cooling_device(struct device_node *tz_np, struct device_node *map_np,
355 					      struct thermal_zone_device *tz, struct thermal_cooling_device *cdev,
356 					      int (*action)(struct device_node *, int, int,
357 							    struct thermal_zone_device *, struct thermal_cooling_device *))
358 {
359 	struct device_node *tr_np;
360 	int count, i, trip_id;
361 
362 	tr_np = of_parse_phandle(map_np, "trip", 0);
363 	if (!tr_np)
364 		return -ENODEV;
365 
366 	trip_id = of_find_trip_id(tz_np, tr_np);
367 	if (trip_id < 0)
368 		return trip_id;
369 
370 	count = of_count_phandle_with_args(map_np, "cooling-device", "#cooling-cells");
371 	if (count <= 0) {
372 		pr_err("Add a cooling_device property with at least one device\n");
373 		return -ENOENT;
374 	}
375 
376 	/*
377 	 * At this point, we don't want to bail out when there is an
378 	 * error, we will try to bind/unbind as many as possible
379 	 * cooling devices
380 	 */
381 	for (i = 0; i < count; i++)
382 		action(map_np, i, trip_id, tz, cdev);
383 
384 	return 0;
385 }
386 
thermal_of_for_each_cooling_maps(struct thermal_zone_device * tz,struct thermal_cooling_device * cdev,int (* action)(struct device_node *,int,int,struct thermal_zone_device *,struct thermal_cooling_device *))387 static int thermal_of_for_each_cooling_maps(struct thermal_zone_device *tz,
388 					    struct thermal_cooling_device *cdev,
389 					    int (*action)(struct device_node *, int, int,
390 							  struct thermal_zone_device *, struct thermal_cooling_device *))
391 {
392 	struct device_node *tz_np, *cm_np, *child;
393 	int ret = 0;
394 
395 	tz_np = thermal_of_zone_get_by_name(tz);
396 	if (IS_ERR(tz_np)) {
397 		pr_err("Failed to get node tz by name\n");
398 		return PTR_ERR(tz_np);
399 	}
400 
401 	cm_np = of_get_child_by_name(tz_np, "cooling-maps");
402 	if (!cm_np)
403 		goto out;
404 
405 	for_each_child_of_node(cm_np, child) {
406 		ret = thermal_of_for_each_cooling_device(tz_np, child, tz, cdev, action);
407 		if (ret) {
408 			of_node_put(child);
409 			break;
410 		}
411 	}
412 
413 	of_node_put(cm_np);
414 out:
415 	of_node_put(tz_np);
416 
417 	return ret;
418 }
419 
thermal_of_bind(struct thermal_zone_device * tz,struct thermal_cooling_device * cdev)420 static int thermal_of_bind(struct thermal_zone_device *tz,
421 			   struct thermal_cooling_device *cdev)
422 {
423 	return thermal_of_for_each_cooling_maps(tz, cdev, __thermal_of_bind);
424 }
425 
thermal_of_unbind(struct thermal_zone_device * tz,struct thermal_cooling_device * cdev)426 static int thermal_of_unbind(struct thermal_zone_device *tz,
427 			     struct thermal_cooling_device *cdev)
428 {
429 	return thermal_of_for_each_cooling_maps(tz, cdev, __thermal_of_unbind);
430 }
431 
432 /**
433  * thermal_of_zone_unregister - Cleanup the specific allocated ressources
434  *
435  * This function disables the thermal zone and frees the different
436  * ressources allocated specific to the thermal OF.
437  *
438  * @tz: a pointer to the thermal zone structure
439  */
thermal_of_zone_unregister(struct thermal_zone_device * tz)440 static void thermal_of_zone_unregister(struct thermal_zone_device *tz)
441 {
442 	struct thermal_trip *trips = tz->trips;
443 	struct thermal_zone_device_ops *ops = tz->ops;
444 
445 	thermal_zone_device_disable(tz);
446 	thermal_zone_device_unregister(tz);
447 	kfree(trips);
448 	kfree(ops);
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  */
thermal_of_zone_register(struct device_node * sensor,int id,void * data,const struct thermal_zone_device_ops * ops)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 *tz;
475 	struct thermal_trip *trips;
476 	struct thermal_zone_params tzp = {};
477 	struct thermal_zone_device_ops *of_ops;
478 	struct device_node *np;
479 	int delay, pdelay;
480 	int ntrips, mask;
481 	int ret;
482 
483 	of_ops = kmemdup(ops, sizeof(*ops), GFP_KERNEL);
484 	if (!of_ops)
485 		return ERR_PTR(-ENOMEM);
486 
487 	np = of_thermal_zone_find(sensor, id);
488 	if (IS_ERR(np)) {
489 		if (PTR_ERR(np) != -ENODEV)
490 			pr_err("Failed to find thermal zone for %pOFn id=%d\n", sensor, id);
491 		ret = PTR_ERR(np);
492 		goto out_kfree_of_ops;
493 	}
494 
495 	trips = thermal_of_trips_init(np, &ntrips);
496 	if (IS_ERR(trips)) {
497 		pr_err("Failed to parse trip points for %pOFn id=%d\n", sensor, id);
498 		ret = PTR_ERR(trips);
499 		goto out_kfree_of_ops;
500 	}
501 
502 	if (!trips)
503 		pr_info("No trip points found for %pOFn id=%d\n", sensor, id);
504 
505 	ret = thermal_of_monitor_init(np, &delay, &pdelay);
506 	if (ret) {
507 		pr_err("Failed to initialize monitoring delays from %pOFn\n", np);
508 		goto out_kfree_trips;
509 	}
510 
511 	thermal_of_parameters_init(np, &tzp);
512 
513 	of_ops->bind = thermal_of_bind;
514 	of_ops->unbind = thermal_of_unbind;
515 
516 	mask = GENMASK_ULL((ntrips) - 1, 0);
517 
518 	tz = thermal_zone_device_register_with_trips(np->name, trips, ntrips,
519 						     mask, data, of_ops, &tzp,
520 						     pdelay, delay);
521 	if (IS_ERR(tz)) {
522 		ret = PTR_ERR(tz);
523 		pr_err("Failed to register thermal zone %pOFn: %d\n", np, ret);
524 		goto out_kfree_trips;
525 	}
526 
527 	ret = thermal_zone_device_enable(tz);
528 	if (ret) {
529 		pr_err("Failed to enabled thermal zone '%s', id=%d: %d\n",
530 		       tz->type, tz->id, ret);
531 		thermal_of_zone_unregister(tz);
532 		return ERR_PTR(ret);
533 	}
534 
535 	return tz;
536 
537 out_kfree_trips:
538 	kfree(trips);
539 out_kfree_of_ops:
540 	kfree(of_ops);
541 
542 	return ERR_PTR(ret);
543 }
544 
devm_thermal_of_zone_release(struct device * dev,void * res)545 static void devm_thermal_of_zone_release(struct device *dev, void *res)
546 {
547 	thermal_of_zone_unregister(*(struct thermal_zone_device **)res);
548 }
549 
devm_thermal_of_zone_match(struct device * dev,void * res,void * data)550 static int devm_thermal_of_zone_match(struct device *dev, void *res,
551 				      void *data)
552 {
553 	struct thermal_zone_device **r = res;
554 
555 	if (WARN_ON(!r || !*r))
556 		return 0;
557 
558 	return *r == data;
559 }
560 
561 /**
562  * devm_thermal_of_zone_register - register a thermal tied with the sensor life cycle
563  *
564  * This function is the device version of the thermal_of_zone_register() function.
565  *
566  * @dev: a device structure pointer to sensor to be tied with the thermal zone OF life cycle
567  * @sensor_id: the sensor identifier
568  * @data: a pointer to a private data to be stored in the thermal zone 'devdata' field
569  * @ops: a pointer to the ops structure associated with the sensor
570  */
devm_thermal_of_zone_register(struct device * dev,int sensor_id,void * data,const struct thermal_zone_device_ops * ops)571 struct thermal_zone_device *devm_thermal_of_zone_register(struct device *dev, int sensor_id, void *data,
572 							  const struct thermal_zone_device_ops *ops)
573 {
574 	struct thermal_zone_device **ptr, *tzd;
575 
576 	ptr = devres_alloc(devm_thermal_of_zone_release, sizeof(*ptr),
577 			   GFP_KERNEL);
578 	if (!ptr)
579 		return ERR_PTR(-ENOMEM);
580 
581 	tzd = thermal_of_zone_register(dev->of_node, sensor_id, data, ops);
582 	if (IS_ERR(tzd)) {
583 		devres_free(ptr);
584 		return tzd;
585 	}
586 
587 	*ptr = tzd;
588 	devres_add(dev, ptr);
589 
590 	return tzd;
591 }
592 EXPORT_SYMBOL_GPL(devm_thermal_of_zone_register);
593 
594 /**
595  * devm_thermal_of_zone_unregister - Resource managed version of
596  *				thermal_of_zone_unregister().
597  * @dev: Device for which which resource was allocated.
598  * @tz: a pointer to struct thermal_zone where the sensor is registered.
599  *
600  * This function removes the sensor callbacks and private data from the
601  * thermal zone device registered with devm_thermal_zone_of_sensor_register()
602  * API. It will also silent the zone by remove the .get_temp() and .get_trend()
603  * thermal zone device callbacks.
604  * Normally this function will not need to be called and the resource
605  * management code will ensure that the resource is freed.
606  */
devm_thermal_of_zone_unregister(struct device * dev,struct thermal_zone_device * tz)607 void devm_thermal_of_zone_unregister(struct device *dev, struct thermal_zone_device *tz)
608 {
609 	WARN_ON(devres_release(dev, devm_thermal_of_zone_release,
610 			       devm_thermal_of_zone_match, tz));
611 }
612 EXPORT_SYMBOL_GPL(devm_thermal_of_zone_unregister);
613