2 * of-thermal.c - Generic Thermal Management device tree support.
4 * Copyright (C) 2013 Texas Instruments
5 * Copyright (C) 2013 Eduardo Valentin <eduardo.valentin@ti.com>
8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2 of the License.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 #include <linux/thermal.h>
26 #include <linux/slab.h>
27 #include <linux/types.h>
28 #include <linux/of_device.h>
29 #include <linux/of_platform.h>
30 #include <linux/err.h>
31 #include <linux/export.h>
32 #include <linux/string.h>
34 #include "thermal_core.h"
36 /*** Private data structures to represent thermal device tree data ***/
39 * struct __thermal_trip - representation of a point in temperature domain
40 * @np: pointer to struct device_node that this trip point was created from
41 * @temperature: temperature value in miliCelsius
42 * @hysteresis: relative hysteresis in miliCelsius
43 * @type: trip point type
46 struct __thermal_trip {
47 struct device_node *np;
48 unsigned long int temperature;
49 unsigned long int hysteresis;
50 enum thermal_trip_type type;
54 * struct __thermal_bind_param - a match between trip and cooling device
55 * @cooling_device: a pointer to identify the referred cooling device
56 * @trip_id: the trip point index
57 * @usage: the percentage (from 0 to 100) of cooling contribution
58 * @min: minimum cooling state used at this trip point
59 * @max: maximum cooling state used at this trip point
62 struct __thermal_bind_params {
63 struct device_node *cooling_device;
71 * struct __thermal_zone - internal representation of a thermal zone
72 * @mode: current thermal zone device mode (enabled/disabled)
73 * @passive_delay: polling interval while passive cooling is activated
74 * @polling_delay: zone polling interval
75 * @ntrips: number of trip points
76 * @trips: an array of trip points (0..ntrips - 1)
77 * @num_tbps: number of thermal bind params
78 * @tbps: an array of thermal bind params (0..num_tbps - 1)
79 * @sensor_data: sensor private data used while reading temperature and trend
80 * @get_temp: sensor callback to read temperature
81 * @get_trend: sensor callback to read temperature trend
84 struct __thermal_zone {
85 enum thermal_device_mode mode;
91 struct __thermal_trip *trips;
93 /* cooling binding data */
95 struct __thermal_bind_params *tbps;
97 /* sensor interface */
99 int (*get_temp)(void *, long *);
100 int (*get_trend)(void *, long *);
103 /*** DT thermal zone device callbacks ***/
105 static int of_thermal_get_temp(struct thermal_zone_device *tz,
108 struct __thermal_zone *data = tz->devdata;
113 return data->get_temp(data->sensor_data, temp);
116 static int of_thermal_get_trend(struct thermal_zone_device *tz, int trip,
117 enum thermal_trend *trend)
119 struct __thermal_zone *data = tz->devdata;
123 if (!data->get_trend)
126 r = data->get_trend(data->sensor_data, &dev_trend);
130 /* TODO: These intervals might have some thresholds, but in core code */
132 *trend = THERMAL_TREND_RAISING;
133 else if (dev_trend < 0)
134 *trend = THERMAL_TREND_DROPPING;
136 *trend = THERMAL_TREND_STABLE;
141 static int of_thermal_bind(struct thermal_zone_device *thermal,
142 struct thermal_cooling_device *cdev)
144 struct __thermal_zone *data = thermal->devdata;
147 if (!data || IS_ERR(data))
150 /* find where to bind */
151 for (i = 0; i < data->num_tbps; i++) {
152 struct __thermal_bind_params *tbp = data->tbps + i;
154 if (tbp->cooling_device == cdev->np) {
157 ret = thermal_zone_bind_cooling_device(thermal,
169 static int of_thermal_unbind(struct thermal_zone_device *thermal,
170 struct thermal_cooling_device *cdev)
172 struct __thermal_zone *data = thermal->devdata;
175 if (!data || IS_ERR(data))
178 /* find where to unbind */
179 for (i = 0; i < data->num_tbps; i++) {
180 struct __thermal_bind_params *tbp = data->tbps + i;
182 if (tbp->cooling_device == cdev->np) {
185 ret = thermal_zone_unbind_cooling_device(thermal,
195 static int of_thermal_get_mode(struct thermal_zone_device *tz,
196 enum thermal_device_mode *mode)
198 struct __thermal_zone *data = tz->devdata;
205 static int of_thermal_set_mode(struct thermal_zone_device *tz,
206 enum thermal_device_mode mode)
208 struct __thermal_zone *data = tz->devdata;
210 mutex_lock(&tz->lock);
212 if (mode == THERMAL_DEVICE_ENABLED)
213 tz->polling_delay = data->polling_delay;
215 tz->polling_delay = 0;
217 mutex_unlock(&tz->lock);
220 thermal_zone_device_update(tz);
225 static int of_thermal_get_trip_type(struct thermal_zone_device *tz, int trip,
226 enum thermal_trip_type *type)
228 struct __thermal_zone *data = tz->devdata;
230 if (trip >= data->ntrips || trip < 0)
233 *type = data->trips[trip].type;
238 static int of_thermal_get_trip_temp(struct thermal_zone_device *tz, int trip,
241 struct __thermal_zone *data = tz->devdata;
243 if (trip >= data->ntrips || trip < 0)
246 *temp = data->trips[trip].temperature;
251 static int of_thermal_set_trip_temp(struct thermal_zone_device *tz, int trip,
254 struct __thermal_zone *data = tz->devdata;
256 if (trip >= data->ntrips || trip < 0)
259 /* thermal framework should take care of data->mask & (1 << trip) */
260 data->trips[trip].temperature = temp;
265 static int of_thermal_get_trip_hyst(struct thermal_zone_device *tz, int trip,
268 struct __thermal_zone *data = tz->devdata;
270 if (trip >= data->ntrips || trip < 0)
273 *hyst = data->trips[trip].hysteresis;
278 static int of_thermal_set_trip_hyst(struct thermal_zone_device *tz, int trip,
281 struct __thermal_zone *data = tz->devdata;
283 if (trip >= data->ntrips || trip < 0)
286 /* thermal framework should take care of data->mask & (1 << trip) */
287 data->trips[trip].hysteresis = hyst;
292 static int of_thermal_get_crit_temp(struct thermal_zone_device *tz,
295 struct __thermal_zone *data = tz->devdata;
298 for (i = 0; i < data->ntrips; i++)
299 if (data->trips[i].type == THERMAL_TRIP_CRITICAL) {
300 *temp = data->trips[i].temperature;
307 static struct thermal_zone_device_ops of_thermal_ops = {
308 .get_mode = of_thermal_get_mode,
309 .set_mode = of_thermal_set_mode,
311 .get_trip_type = of_thermal_get_trip_type,
312 .get_trip_temp = of_thermal_get_trip_temp,
313 .set_trip_temp = of_thermal_set_trip_temp,
314 .get_trip_hyst = of_thermal_get_trip_hyst,
315 .set_trip_hyst = of_thermal_set_trip_hyst,
316 .get_crit_temp = of_thermal_get_crit_temp,
318 .bind = of_thermal_bind,
319 .unbind = of_thermal_unbind,
324 static struct thermal_zone_device *
325 thermal_zone_of_add_sensor(struct device_node *zone,
326 struct device_node *sensor, void *data,
327 int (*get_temp)(void *, long *),
328 int (*get_trend)(void *, long *))
330 struct thermal_zone_device *tzd;
331 struct __thermal_zone *tz;
333 tzd = thermal_zone_get_zone_by_name(zone->name);
335 return ERR_PTR(-EPROBE_DEFER);
339 mutex_lock(&tzd->lock);
340 tz->get_temp = get_temp;
341 tz->get_trend = get_trend;
342 tz->sensor_data = data;
344 tzd->ops->get_temp = of_thermal_get_temp;
345 tzd->ops->get_trend = of_thermal_get_trend;
346 mutex_unlock(&tzd->lock);
352 * thermal_zone_of_sensor_register - registers a sensor to a DT thermal zone
353 * @dev: a valid struct device pointer of a sensor device. Must contain
354 * a valid .of_node, for the sensor node.
355 * @sensor_id: a sensor identifier, in case the sensor IP has more
357 * @data: a private pointer (owned by the caller) that will be passed
358 * back, when a temperature reading is needed.
359 * @get_temp: a pointer to a function that reads the sensor temperature.
360 * @get_trend: a pointer to a function that reads the sensor temperature trend.
362 * This function will search the list of thermal zones described in device
363 * tree and look for the zone that refer to the sensor device pointed by
364 * @dev->of_node as temperature providers. For the zone pointing to the
365 * sensor node, the sensor will be added to the DT thermal zone device.
367 * The thermal zone temperature is provided by the @get_temp function
368 * pointer. When called, it will have the private pointer @data back.
370 * The thermal zone temperature trend is provided by the @get_trend function
371 * pointer. When called, it will have the private pointer @data back.
374 * 01 - This function must enqueue the new sensor instead of using
375 * it as the only source of temperature values.
377 * 02 - There must be a way to match the sensor with all thermal zones
380 * Return: On success returns a valid struct thermal_zone_device,
381 * otherwise, it returns a corresponding ERR_PTR(). Caller must
382 * check the return value with help of IS_ERR() helper.
384 struct thermal_zone_device *
385 thermal_zone_of_sensor_register(struct device *dev, int sensor_id,
386 void *data, int (*get_temp)(void *, long *),
387 int (*get_trend)(void *, long *))
389 struct device_node *np, *child, *sensor_np;
391 np = of_find_node_by_name(NULL, "thermal-zones");
393 return ERR_PTR(-ENODEV);
395 if (!dev || !dev->of_node)
396 return ERR_PTR(-EINVAL);
398 sensor_np = dev->of_node;
400 for_each_child_of_node(np, child) {
401 struct of_phandle_args sensor_specs;
404 /* Check whether child is enabled or not */
405 if (!of_device_is_available(child))
408 /* For now, thermal framework supports only 1 sensor per zone */
409 ret = of_parse_phandle_with_args(child, "thermal-sensors",
410 "#thermal-sensor-cells",
415 if (sensor_specs.args_count >= 1) {
416 id = sensor_specs.args[0];
417 WARN(sensor_specs.args_count > 1,
418 "%s: too many cells in sensor specifier %d\n",
419 sensor_specs.np->name, sensor_specs.args_count);
424 if (sensor_specs.np == sensor_np && id == sensor_id) {
426 return thermal_zone_of_add_sensor(child, sensor_np,
434 return ERR_PTR(-ENODEV);
436 EXPORT_SYMBOL_GPL(thermal_zone_of_sensor_register);
439 * thermal_zone_of_sensor_unregister - unregisters a sensor from a DT thermal zone
440 * @dev: a valid struct device pointer of a sensor device. Must contain
441 * a valid .of_node, for the sensor node.
442 * @tzd: a pointer to struct thermal_zone_device where the sensor is registered.
444 * This function removes the sensor callbacks and private data from the
445 * thermal zone device registered with thermal_zone_of_sensor_register()
446 * API. It will also silent the zone by remove the .get_temp() and .get_trend()
447 * thermal zone device callbacks.
449 * TODO: When the support to several sensors per zone is added, this
450 * function must search the sensor list based on @dev parameter.
453 void thermal_zone_of_sensor_unregister(struct device *dev,
454 struct thermal_zone_device *tzd)
456 struct __thermal_zone *tz;
458 if (!dev || !tzd || !tzd->devdata)
463 /* no __thermal_zone, nothing to be done */
467 mutex_lock(&tzd->lock);
468 tzd->ops->get_temp = NULL;
469 tzd->ops->get_trend = NULL;
472 tz->get_trend = NULL;
473 tz->sensor_data = NULL;
474 mutex_unlock(&tzd->lock);
476 EXPORT_SYMBOL_GPL(thermal_zone_of_sensor_unregister);
478 /*** functions parsing device tree nodes ***/
481 * thermal_of_populate_bind_params - parse and fill cooling map data
482 * @np: DT node containing a cooling-map node
483 * @__tbp: data structure to be filled with cooling map info
484 * @trips: array of thermal zone trip points
485 * @ntrips: number of trip points inside trips.
487 * This function parses a cooling-map type of node represented by
488 * @np parameter and fills the read data into @__tbp data structure.
489 * It needs the already parsed array of trip points of the thermal zone
492 * Return: 0 on success, proper error code otherwise
494 static int thermal_of_populate_bind_params(struct device_node *np,
495 struct __thermal_bind_params *__tbp,
496 struct __thermal_trip *trips,
499 struct of_phandle_args cooling_spec;
500 struct device_node *trip;
504 /* Default weight. Usage is optional */
506 ret = of_property_read_u32(np, "contribution", &prop);
510 trip = of_parse_phandle(np, "trip", 0);
512 pr_err("missing trip property\n");
516 /* match using device_node */
517 for (i = 0; i < ntrips; i++)
518 if (trip == trips[i].np) {
528 ret = of_parse_phandle_with_args(np, "cooling-device", "#cooling-cells",
531 pr_err("missing cooling_device property\n");
534 __tbp->cooling_device = cooling_spec.np;
535 if (cooling_spec.args_count >= 2) { /* at least min and max */
536 __tbp->min = cooling_spec.args[0];
537 __tbp->max = cooling_spec.args[1];
539 pr_err("wrong reference to cooling device, missing limits\n");
549 * It maps 'enum thermal_trip_type' found in include/linux/thermal.h
550 * into the device tree binding of 'trip', property type.
552 static const char * const trip_types[] = {
553 [THERMAL_TRIP_ACTIVE] = "active",
554 [THERMAL_TRIP_PASSIVE] = "passive",
555 [THERMAL_TRIP_HOT] = "hot",
556 [THERMAL_TRIP_CRITICAL] = "critical",
560 * thermal_of_get_trip_type - Get phy mode for given device_node
561 * @np: Pointer to the given device_node
562 * @type: Pointer to resulting trip type
564 * The function gets trip type string from property 'type',
565 * and store its index in trip_types table in @type,
567 * Return: 0 on success, or errno in error case.
569 static int thermal_of_get_trip_type(struct device_node *np,
570 enum thermal_trip_type *type)
575 err = of_property_read_string(np, "type", &t);
579 for (i = 0; i < ARRAY_SIZE(trip_types); i++)
580 if (!strcasecmp(t, trip_types[i])) {
589 * thermal_of_populate_trip - parse and fill one trip point data
590 * @np: DT node containing a trip point node
591 * @trip: trip point data structure to be filled up
593 * This function parses a trip point type of node represented by
594 * @np parameter and fills the read data into @trip data structure.
596 * Return: 0 on success, proper error code otherwise
598 static int thermal_of_populate_trip(struct device_node *np,
599 struct __thermal_trip *trip)
604 ret = of_property_read_u32(np, "temperature", &prop);
606 pr_err("missing temperature property\n");
609 trip->temperature = prop;
611 ret = of_property_read_u32(np, "hysteresis", &prop);
613 pr_err("missing hysteresis property\n");
616 trip->hysteresis = prop;
618 ret = thermal_of_get_trip_type(np, &trip->type);
620 pr_err("wrong trip type property\n");
624 /* Required for cooling map matching */
631 * thermal_of_build_thermal_zone - parse and fill one thermal zone data
632 * @np: DT node containing a thermal zone node
634 * This function parses a thermal zone type of node represented by
635 * @np parameter and fills the read data into a __thermal_zone data structure
636 * and return this pointer.
638 * TODO: Missing properties to parse: thermal-sensor-names and coefficients
640 * Return: On success returns a valid struct __thermal_zone,
641 * otherwise, it returns a corresponding ERR_PTR(). Caller must
642 * check the return value with help of IS_ERR() helper.
644 static struct __thermal_zone *
645 thermal_of_build_thermal_zone(struct device_node *np)
647 struct device_node *child = NULL, *gchild;
648 struct __thermal_zone *tz;
653 pr_err("no thermal zone np\n");
654 return ERR_PTR(-EINVAL);
657 tz = kzalloc(sizeof(*tz), GFP_KERNEL);
659 return ERR_PTR(-ENOMEM);
661 ret = of_property_read_u32(np, "polling-delay-passive", &prop);
663 pr_err("missing polling-delay-passive property\n");
666 tz->passive_delay = prop;
668 ret = of_property_read_u32(np, "polling-delay", &prop);
670 pr_err("missing polling-delay property\n");
673 tz->polling_delay = prop;
676 child = of_get_child_by_name(np, "trips");
678 /* No trips provided */
682 tz->ntrips = of_get_child_count(child);
683 if (tz->ntrips == 0) /* must have at least one child */
686 tz->trips = kzalloc(tz->ntrips * sizeof(*tz->trips), GFP_KERNEL);
693 for_each_child_of_node(child, gchild) {
694 ret = thermal_of_populate_trip(gchild, &tz->trips[i++]);
702 child = of_get_child_by_name(np, "cooling-maps");
704 /* cooling-maps not provided */
708 tz->num_tbps = of_get_child_count(child);
709 if (tz->num_tbps == 0)
712 tz->tbps = kzalloc(tz->num_tbps * sizeof(*tz->tbps), GFP_KERNEL);
719 for_each_child_of_node(child, gchild) {
720 ret = thermal_of_populate_bind_params(gchild, &tz->tbps[i++],
721 tz->trips, tz->ntrips);
728 tz->mode = THERMAL_DEVICE_DISABLED;
743 static inline void of_thermal_free_zone(struct __thermal_zone *tz)
751 * of_parse_thermal_zones - parse device tree thermal data
753 * Initialization function that can be called by machine initialization
754 * code to parse thermal data and populate the thermal framework
755 * with hardware thermal zones info. This function only parses thermal zones.
756 * Cooling devices and sensor devices nodes are supposed to be parsed
757 * by their respective drivers.
759 * Return: 0 on success, proper error code otherwise
762 int __init of_parse_thermal_zones(void)
764 struct device_node *np, *child;
765 struct __thermal_zone *tz;
766 struct thermal_zone_device_ops *ops;
768 np = of_find_node_by_name(NULL, "thermal-zones");
770 pr_debug("unable to find thermal zones\n");
771 return 0; /* Run successfully on systems without thermal DT */
774 for_each_child_of_node(np, child) {
775 struct thermal_zone_device *zone;
776 struct thermal_zone_params *tzp;
778 /* Check whether child is enabled or not */
779 if (!of_device_is_available(child))
782 tz = thermal_of_build_thermal_zone(child);
784 pr_err("failed to build thermal zone %s: %ld\n",
790 ops = kmemdup(&of_thermal_ops, sizeof(*ops), GFP_KERNEL);
794 tzp = kzalloc(sizeof(*tzp), GFP_KERNEL);
800 /* No hwmon because there might be hwmon drivers registering */
801 tzp->no_hwmon = true;
803 zone = thermal_zone_device_register(child->name, tz->ntrips,
809 pr_err("Failed to build %s zone %ld\n", child->name,
813 of_thermal_free_zone(tz);
814 /* attempting to build remaining zones still */
821 of_thermal_free_zone(tz);
823 /* no memory available, so free what we have built */
824 of_thermal_destroy_zones();
830 * of_thermal_destroy_zones - remove all zones parsed and allocated resources
832 * Finds all zones parsed and added to the thermal framework and remove them
833 * from the system, together with their resources.
836 void of_thermal_destroy_zones(void)
838 struct device_node *np, *child;
840 np = of_find_node_by_name(NULL, "thermal-zones");
842 pr_err("unable to find thermal zones\n");
846 for_each_child_of_node(np, child) {
847 struct thermal_zone_device *zone;
849 /* Check whether child is enabled or not */
850 if (!of_device_is_available(child))
853 zone = thermal_zone_get_zone_by_name(child->name);
857 thermal_zone_device_unregister(zone);
860 of_thermal_free_zone(zone->devdata);