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