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