drivers/thermal/thermal_of.c

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