drivers/thermal/thermal_core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  thermal.c - Generic Thermal Management Sysfs support.
   4  *
   5  *  Copyright (C) 2008 Intel Corp
   6  *  Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com>
   7  *  Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com>
   8  */
   9
  10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11
  12 #include <linux/device.h>
  13 #include <linux/err.h>
  14 #include <linux/export.h>
  15 #include <linux/slab.h>
  16 #include <linux/kdev_t.h>
  17 #include <linux/idr.h>
  18 #include <linux/thermal.h>
  19 #include <linux/reboot.h>
  20 #include <linux/string.h>
  21 #include <linux/of.h>
  22 #include <linux/suspend.h>
  23
  24 #define CREATE_TRACE_POINTS
  25 #include <trace/events/thermal.h>
  26
  27 #include "thermal_core.h"
  28 #include "thermal_hwmon.h"
  29
  30 static DEFINE_IDA(thermal_tz_ida);
  31 static DEFINE_IDA(thermal_cdev_ida);
  32
  33 static LIST_HEAD(thermal_tz_list);
  34 static LIST_HEAD(thermal_cdev_list);
  35 static LIST_HEAD(thermal_governor_list);
  36
  37 static DEFINE_MUTEX(thermal_list_lock);
  38 static DEFINE_MUTEX(thermal_governor_lock);
  39
  40 static atomic_t in_suspend;
  41
  42 static struct thermal_governor *def_governor;
  43
  44 /*
  45  * Governor section: set of functions to handle thermal governors
  46  *
  47  * Functions to help in the life cycle of thermal governors within
  48  * the thermal core and by the thermal governor code.
  49  */
  50
  51 static struct thermal_governor *__find_governor(const char *name)
  52 {
  53         struct thermal_governor *pos;
  54
  55         if (!name || !name[0])
  56                 return def_governor;
  57
  58         list_for_each_entry(pos, &thermal_governor_list, governor_list)
  59                 if (!strncasecmp(name, pos->name, THERMAL_NAME_LENGTH))
  60                         return pos;
  61
  62         return NULL;
  63 }
  64
  65 /**
  66  * bind_previous_governor() - bind the previous governor of the thermal zone
  67  * @tz:         a valid pointer to a struct thermal_zone_device
  68  * @failed_gov_name:    the name of the governor that failed to register
  69  *
  70  * Register the previous governor of the thermal zone after a new
  71  * governor has failed to be bound.
  72  */
  73 static void bind_previous_governor(struct thermal_zone_device *tz,
  74                                    const char *failed_gov_name)
  75 {
  76         if (tz->governor && tz->governor->bind_to_tz) {
  77                 if (tz->governor->bind_to_tz(tz)) {
  78                         dev_err(&tz->device,
  79                                 "governor %s failed to bind and the previous one (%s) failed to bind again, thermal zone %s has no governor\n",
  80                                 failed_gov_name, tz->governor->name, tz->type);
  81                         tz->governor = NULL;
  82                 }
  83         }
  84 }
  85
  86 /**
  87  * thermal_set_governor() - Switch to another governor
  88  * @tz:         a valid pointer to a struct thermal_zone_device
  89  * @new_gov:    pointer to the new governor
  90  *
  91  * Change the governor of thermal zone @tz.
  92  *
  93  * Return: 0 on success, an error if the new governor's bind_to_tz() failed.
  94  */
  95 static int thermal_set_governor(struct thermal_zone_device *tz,
  96                                 struct thermal_governor *new_gov)
  97 {
  98         int ret = 0;
  99
 100         if (tz->governor && tz->governor->unbind_from_tz)
 101                 tz->governor->unbind_from_tz(tz);
 102
 103         if (new_gov && new_gov->bind_to_tz) {
 104                 ret = new_gov->bind_to_tz(tz);
 105                 if (ret) {
 106                         bind_previous_governor(tz, new_gov->name);
 107
 108                         return ret;
 109                 }
 110         }
 111
 112         tz->governor = new_gov;
 113
 114         return ret;
 115 }
 116
 117 int thermal_register_governor(struct thermal_governor *governor)
 118 {
 119         int err;
 120         const char *name;
 121         struct thermal_zone_device *pos;
 122
 123         if (!governor)
 124                 return -EINVAL;
 125
 126         mutex_lock(&thermal_governor_lock);
 127
 128         err = -EBUSY;
 129         if (!__find_governor(governor->name)) {
 130                 bool match_default;
 131
 132                 err = 0;
 133                 list_add(&governor->governor_list, &thermal_governor_list);
 134                 match_default = !strncmp(governor->name,
 135                                          DEFAULT_THERMAL_GOVERNOR,
 136                                          THERMAL_NAME_LENGTH);
 137
 138                 if (!def_governor && match_default)
 139                         def_governor = governor;
 140         }
 141
 142         mutex_lock(&thermal_list_lock);
 143
 144         list_for_each_entry(pos, &thermal_tz_list, node) {
 145                 /*
 146                  * only thermal zones with specified tz->tzp->governor_name
 147                  * may run with tz->govenor unset
 148                  */
 149                 if (pos->governor)
 150                         continue;
 151
 152                 name = pos->tzp->governor_name;
 153
 154                 if (!strncasecmp(name, governor->name, THERMAL_NAME_LENGTH)) {
 155                         int ret;
 156
 157                         ret = thermal_set_governor(pos, governor);
 158                         if (ret)
 159                                 dev_err(&pos->device,
 160                                         "Failed to set governor %s for thermal zone %s: %d\n",
 161                                         governor->name, pos->type, ret);
 162                 }
 163         }
 164
 165         mutex_unlock(&thermal_list_lock);
 166         mutex_unlock(&thermal_governor_lock);
 167
 168         return err;
 169 }
 170
 171 void thermal_unregister_governor(struct thermal_governor *governor)
 172 {
 173         struct thermal_zone_device *pos;
 174
 175         if (!governor)
 176                 return;
 177
 178         mutex_lock(&thermal_governor_lock);
 179
 180         if (!__find_governor(governor->name))
 181                 goto exit;
 182
 183         mutex_lock(&thermal_list_lock);
 184
 185         list_for_each_entry(pos, &thermal_tz_list, node) {
 186                 if (!strncasecmp(pos->governor->name, governor->name,
 187                                  THERMAL_NAME_LENGTH))
 188                         thermal_set_governor(pos, NULL);
 189         }
 190
 191         mutex_unlock(&thermal_list_lock);
 192         list_del(&governor->governor_list);
 193 exit:
 194         mutex_unlock(&thermal_governor_lock);
 195 }
 196
 197 int thermal_zone_device_set_policy(struct thermal_zone_device *tz,
 198                                    char *policy)
 199 {
 200         struct thermal_governor *gov;
 201         int ret = -EINVAL;
 202
 203         mutex_lock(&thermal_governor_lock);
 204         mutex_lock(&tz->lock);
 205
 206         if (!device_is_registered(&tz->device))
 207                 goto exit;
 208
 209         gov = __find_governor(strim(policy));
 210         if (!gov)
 211                 goto exit;
 212
 213         ret = thermal_set_governor(tz, gov);
 214
 215 exit:
 216         mutex_unlock(&tz->lock);
 217         mutex_unlock(&thermal_governor_lock);
 218
 219         thermal_notify_tz_gov_change(tz->id, policy);
 220
 221         return ret;
 222 }
 223
 224 int thermal_build_list_of_policies(char *buf)
 225 {
 226         struct thermal_governor *pos;
 227         ssize_t count = 0;
 228
 229         mutex_lock(&thermal_governor_lock);
 230
 231         list_for_each_entry(pos, &thermal_governor_list, governor_list) {
 232                 count += scnprintf(buf + count, PAGE_SIZE - count, "%s ",
 233                                    pos->name);
 234         }
 235         count += scnprintf(buf + count, PAGE_SIZE - count, "\n");
 236
 237         mutex_unlock(&thermal_governor_lock);
 238
 239         return count;
 240 }
 241
 242 static void __init thermal_unregister_governors(void)
 243 {
 244         struct thermal_governor **governor;
 245
 246         for_each_governor_table(governor)
 247                 thermal_unregister_governor(*governor);
 248 }
 249
 250 static int __init thermal_register_governors(void)
 251 {
 252         int ret = 0;
 253         struct thermal_governor **governor;
 254
 255         for_each_governor_table(governor) {
 256                 ret = thermal_register_governor(*governor);
 257                 if (ret) {
 258                         pr_err("Failed to register governor: '%s'",
 259                                (*governor)->name);
 260                         break;
 261                 }
 262
 263                 pr_info("Registered thermal governor '%s'",
 264                         (*governor)->name);
 265         }
 266
 267         if (ret) {
 268                 struct thermal_governor **gov;
 269
 270                 for_each_governor_table(gov) {
 271                         if (gov == governor)
 272                                 break;
 273                         thermal_unregister_governor(*gov);
 274                 }
 275         }
 276
 277         return ret;
 278 }
 279
 280 /*
 281  * Zone update section: main control loop applied to each zone while monitoring
 282  *
 283  * in polling mode. The monitoring is done using a workqueue.
 284  * Same update may be done on a zone by calling thermal_zone_device_update().
 285  *
 286  * An update means:
 287  * - Non-critical trips will invoke the governor responsible for that zone;
 288  * - Hot trips will produce a notification to userspace;
 289  * - Critical trip point will cause a system shutdown.
 290  */
 291 static void thermal_zone_device_set_polling(struct thermal_zone_device *tz,
 292                                             unsigned long delay)
 293 {
 294         if (delay)
 295                 mod_delayed_work(system_freezable_power_efficient_wq,
 296                                  &tz->poll_queue, delay);
 297         else
 298                 cancel_delayed_work(&tz->poll_queue);
 299 }
 300
 301 static void monitor_thermal_zone(struct thermal_zone_device *tz)
 302 {
 303         if (tz->mode != THERMAL_DEVICE_ENABLED)
 304                 thermal_zone_device_set_polling(tz, 0);
 305         else if (tz->passive)
 306                 thermal_zone_device_set_polling(tz, tz->passive_delay_jiffies);
 307         else if (tz->polling_delay_jiffies)
 308                 thermal_zone_device_set_polling(tz, tz->polling_delay_jiffies);
 309 }
 310
 311 static void handle_non_critical_trips(struct thermal_zone_device *tz, int trip)
 312 {
 313         tz->governor ? tz->governor->throttle(tz, trip) :
 314                        def_governor->throttle(tz, trip);
 315 }
 316
 317 void thermal_zone_device_critical(struct thermal_zone_device *tz)
 318 {
 319         /*
 320          * poweroff_delay_ms must be a carefully profiled positive value.
 321          * Its a must for forced_emergency_poweroff_work to be scheduled.
 322          */
 323         int poweroff_delay_ms = CONFIG_THERMAL_EMERGENCY_POWEROFF_DELAY_MS;
 324
 325         dev_emerg(&tz->device, "%s: critical temperature reached, "
 326                   "shutting down\n", tz->type);
 327
 328         hw_protection_shutdown("Temperature too high", poweroff_delay_ms);
 329 }
 330 EXPORT_SYMBOL(thermal_zone_device_critical);
 331
 332 static void handle_critical_trips(struct thermal_zone_device *tz,
 333                                   int trip, int trip_temp, enum thermal_trip_type trip_type)
 334 {
 335         /* If we have not crossed the trip_temp, we do not care. */
 336         if (trip_temp <= 0 || tz->temperature < trip_temp)
 337                 return;
 338
 339         trace_thermal_zone_trip(tz, trip, trip_type);
 340
 341         if (trip_type == THERMAL_TRIP_HOT && tz->ops->hot)
 342                 tz->ops->hot(tz);
 343         else if (trip_type == THERMAL_TRIP_CRITICAL)
 344                 tz->ops->critical(tz);
 345 }
 346
 347 static void handle_thermal_trip(struct thermal_zone_device *tz, int trip)
 348 {
 349         enum thermal_trip_type type;
 350         int trip_temp, hyst = 0;
 351
 352         /* Ignore disabled trip points */
 353         if (test_bit(trip, &tz->trips_disabled))
 354                 return;
 355
 356         tz->ops->get_trip_temp(tz, trip, &trip_temp);
 357         tz->ops->get_trip_type(tz, trip, &type);
 358         if (tz->ops->get_trip_hyst)
 359                 tz->ops->get_trip_hyst(tz, trip, &hyst);
 360
 361         if (tz->last_temperature != THERMAL_TEMP_INVALID) {
 362                 if (tz->last_temperature < trip_temp &&
 363                     tz->temperature >= trip_temp)
 364                         thermal_notify_tz_trip_up(tz->id, trip,
 365                                                   tz->temperature);
 366                 if (tz->last_temperature >= trip_temp &&
 367                     tz->temperature < (trip_temp - hyst))
 368                         thermal_notify_tz_trip_down(tz->id, trip,
 369                                                     tz->temperature);
 370         }
 371
 372         if (type == THERMAL_TRIP_CRITICAL || type == THERMAL_TRIP_HOT)
 373                 handle_critical_trips(tz, trip, trip_temp, type);
 374         else
 375                 handle_non_critical_trips(tz, trip);
 376 }
 377
 378 static void update_temperature(struct thermal_zone_device *tz)
 379 {
 380         int temp, ret;
 381
 382         ret = __thermal_zone_get_temp(tz, &temp);
 383         if (ret) {
 384                 if (ret != -EAGAIN)
 385                         dev_warn(&tz->device,
 386                                  "failed to read out thermal zone (%d)\n",
 387                                  ret);
 388                 return;
 389         }
 390
 391         tz->last_temperature = tz->temperature;
 392         tz->temperature = temp;
 393
 394         trace_thermal_temperature(tz);
 395
 396         thermal_genl_sampling_temp(tz->id, temp);
 397 }
 398
 399 static void thermal_zone_device_init(struct thermal_zone_device *tz)
 400 {
 401         struct thermal_instance *pos;
 402         tz->temperature = THERMAL_TEMP_INVALID;
 403         tz->prev_low_trip = -INT_MAX;
 404         tz->prev_high_trip = INT_MAX;
 405         list_for_each_entry(pos, &tz->thermal_instances, tz_node)
 406                 pos->initialized = false;
 407 }
 408
 409 void __thermal_zone_device_update(struct thermal_zone_device *tz,
 410                                   enum thermal_notify_event event)
 411 {
 412         int count;
 413
 414         if (atomic_read(&in_suspend))
 415                 return;
 416
 417         if (WARN_ONCE(!tz->ops->get_temp,
 418                       "'%s' must not be called without 'get_temp' ops set\n",
 419                       __func__))
 420                 return;
 421
 422         if (!thermal_zone_device_is_enabled(tz))
 423                 return;
 424
 425         update_temperature(tz);
 426
 427         __thermal_zone_set_trips(tz);
 428
 429         tz->notify_event = event;
 430
 431         for (count = 0; count < tz->num_trips; count++)
 432                 handle_thermal_trip(tz, count);
 433
 434         monitor_thermal_zone(tz);
 435 }
 436
 437 static int thermal_zone_device_set_mode(struct thermal_zone_device *tz,
 438                                         enum thermal_device_mode mode)
 439 {
 440         int ret = 0;
 441
 442         mutex_lock(&tz->lock);
 443
 444         /* do nothing if mode isn't changing */
 445         if (mode == tz->mode) {
 446                 mutex_unlock(&tz->lock);
 447
 448                 return ret;
 449         }
 450
 451         if (!device_is_registered(&tz->device)) {
 452                 mutex_unlock(&tz->lock);
 453
 454                 return -ENODEV;
 455         }
 456
 457         if (tz->ops->change_mode)
 458                 ret = tz->ops->change_mode(tz, mode);
 459
 460         if (!ret)
 461                 tz->mode = mode;
 462
 463         __thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
 464
 465         mutex_unlock(&tz->lock);
 466
 467         if (mode == THERMAL_DEVICE_ENABLED)
 468                 thermal_notify_tz_enable(tz->id);
 469         else
 470                 thermal_notify_tz_disable(tz->id);
 471
 472         return ret;
 473 }
 474
 475 int thermal_zone_device_enable(struct thermal_zone_device *tz)
 476 {
 477         return thermal_zone_device_set_mode(tz, THERMAL_DEVICE_ENABLED);
 478 }
 479 EXPORT_SYMBOL_GPL(thermal_zone_device_enable);
 480
 481 int thermal_zone_device_disable(struct thermal_zone_device *tz)
 482 {
 483         return thermal_zone_device_set_mode(tz, THERMAL_DEVICE_DISABLED);
 484 }
 485 EXPORT_SYMBOL_GPL(thermal_zone_device_disable);
 486
 487 int thermal_zone_device_is_enabled(struct thermal_zone_device *tz)
 488 {
 489         lockdep_assert_held(&tz->lock);
 490
 491         return tz->mode == THERMAL_DEVICE_ENABLED;
 492 }
 493
 494 void thermal_zone_device_update(struct thermal_zone_device *tz,
 495                                 enum thermal_notify_event event)
 496 {
 497         mutex_lock(&tz->lock);
 498         if (device_is_registered(&tz->device))
 499                 __thermal_zone_device_update(tz, event);
 500         mutex_unlock(&tz->lock);
 501 }
 502 EXPORT_SYMBOL_GPL(thermal_zone_device_update);
 503
 504 static void thermal_zone_device_check(struct work_struct *work)
 505 {
 506         struct thermal_zone_device *tz = container_of(work, struct
 507                                                       thermal_zone_device,
 508                                                       poll_queue.work);
 509         thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
 510 }
 511
 512 int for_each_thermal_governor(int (*cb)(struct thermal_governor *, void *),
 513                               void *data)
 514 {
 515         struct thermal_governor *gov;
 516         int ret = 0;
 517
 518         mutex_lock(&thermal_governor_lock);
 519         list_for_each_entry(gov, &thermal_governor_list, governor_list) {
 520                 ret = cb(gov, data);
 521                 if (ret)
 522                         break;
 523         }
 524         mutex_unlock(&thermal_governor_lock);
 525
 526         return ret;
 527 }
 528
 529 int for_each_thermal_cooling_device(int (*cb)(struct thermal_cooling_device *,
 530                                               void *), void *data)
 531 {
 532         struct thermal_cooling_device *cdev;
 533         int ret = 0;
 534
 535         mutex_lock(&thermal_list_lock);
 536         list_for_each_entry(cdev, &thermal_cdev_list, node) {
 537                 ret = cb(cdev, data);
 538                 if (ret)
 539                         break;
 540         }
 541         mutex_unlock(&thermal_list_lock);
 542
 543         return ret;
 544 }
 545
 546 int for_each_thermal_zone(int (*cb)(struct thermal_zone_device *, void *),
 547                           void *data)
 548 {
 549         struct thermal_zone_device *tz;
 550         int ret = 0;
 551
 552         mutex_lock(&thermal_list_lock);
 553         list_for_each_entry(tz, &thermal_tz_list, node) {
 554                 ret = cb(tz, data);
 555                 if (ret)
 556                         break;
 557         }
 558         mutex_unlock(&thermal_list_lock);
 559
 560         return ret;
 561 }
 562
 563 struct thermal_zone_device *thermal_zone_get_by_id(int id)
 564 {
 565         struct thermal_zone_device *tz, *match = NULL;
 566
 567         mutex_lock(&thermal_list_lock);
 568         list_for_each_entry(tz, &thermal_tz_list, node) {
 569                 if (tz->id == id) {
 570                         match = tz;
 571                         break;
 572                 }
 573         }
 574         mutex_unlock(&thermal_list_lock);
 575
 576         return match;
 577 }
 578
 579 /*
 580  * Device management section: cooling devices, zones devices, and binding
 581  *
 582  * Set of functions provided by the thermal core for:
 583  * - cooling devices lifecycle: registration, unregistration,
 584  *                              binding, and unbinding.
 585  * - thermal zone devices lifecycle: registration, unregistration,
 586  *                                   binding, and unbinding.
 587  */
 588
 589 /**
 590  * thermal_zone_bind_cooling_device() - bind a cooling device to a thermal zone
 591  * @tz:         pointer to struct thermal_zone_device
 592  * @trip:       indicates which trip point the cooling devices is
 593  *              associated with in this thermal zone.
 594  * @cdev:       pointer to struct thermal_cooling_device
 595  * @upper:      the Maximum cooling state for this trip point.
 596  *              THERMAL_NO_LIMIT means no upper limit,
 597  *              and the cooling device can be in max_state.
 598  * @lower:      the Minimum cooling state can be used for this trip point.
 599  *              THERMAL_NO_LIMIT means no lower limit,
 600  *              and the cooling device can be in cooling state 0.
 601  * @weight:     The weight of the cooling device to be bound to the
 602  *              thermal zone. Use THERMAL_WEIGHT_DEFAULT for the
 603  *              default value
 604  *
 605  * This interface function bind a thermal cooling device to the certain trip
 606  * point of a thermal zone device.
 607  * This function is usually called in the thermal zone device .bind callback.
 608  *
 609  * Return: 0 on success, the proper error value otherwise.
 610  */
 611 int thermal_zone_bind_cooling_device(struct thermal_zone_device *tz,
 612                                      int trip,
 613                                      struct thermal_cooling_device *cdev,
 614                                      unsigned long upper, unsigned long lower,
 615                                      unsigned int weight)
 616 {
 617         struct thermal_instance *dev;
 618         struct thermal_instance *pos;
 619         struct thermal_zone_device *pos1;
 620         struct thermal_cooling_device *pos2;
 621         int result;
 622
 623         if (trip >= tz->num_trips || trip < 0)
 624                 return -EINVAL;
 625
 626         list_for_each_entry(pos1, &thermal_tz_list, node) {
 627                 if (pos1 == tz)
 628                         break;
 629         }
 630         list_for_each_entry(pos2, &thermal_cdev_list, node) {
 631                 if (pos2 == cdev)
 632                         break;
 633         }
 634
 635         if (tz != pos1 || cdev != pos2)
 636                 return -EINVAL;
 637
 638         /* lower default 0, upper default max_state */
 639         lower = lower == THERMAL_NO_LIMIT ? 0 : lower;
 640         upper = upper == THERMAL_NO_LIMIT ? cdev->max_state : upper;
 641
 642         if (lower > upper || upper > cdev->max_state)
 643                 return -EINVAL;
 644
 645         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 646         if (!dev)
 647                 return -ENOMEM;
 648         dev->tz = tz;
 649         dev->cdev = cdev;
 650         dev->trip = trip;
 651         dev->upper = upper;
 652         dev->lower = lower;
 653         dev->target = THERMAL_NO_TARGET;
 654         dev->weight = weight;
 655
 656         result = ida_alloc(&tz->ida, GFP_KERNEL);
 657         if (result < 0)
 658                 goto free_mem;
 659
 660         dev->id = result;
 661         sprintf(dev->name, "cdev%d", dev->id);
 662         result =
 663             sysfs_create_link(&tz->device.kobj, &cdev->device.kobj, dev->name);
 664         if (result)
 665                 goto release_ida;
 666
 667         sprintf(dev->attr_name, "cdev%d_trip_point", dev->id);
 668         sysfs_attr_init(&dev->attr.attr);
 669         dev->attr.attr.name = dev->attr_name;
 670         dev->attr.attr.mode = 0444;
 671         dev->attr.show = trip_point_show;
 672         result = device_create_file(&tz->device, &dev->attr);
 673         if (result)
 674                 goto remove_symbol_link;
 675
 676         sprintf(dev->weight_attr_name, "cdev%d_weight", dev->id);
 677         sysfs_attr_init(&dev->weight_attr.attr);
 678         dev->weight_attr.attr.name = dev->weight_attr_name;
 679         dev->weight_attr.attr.mode = S_IWUSR | S_IRUGO;
 680         dev->weight_attr.show = weight_show;
 681         dev->weight_attr.store = weight_store;
 682         result = device_create_file(&tz->device, &dev->weight_attr);
 683         if (result)
 684                 goto remove_trip_file;
 685
 686         mutex_lock(&tz->lock);
 687         mutex_lock(&cdev->lock);
 688         list_for_each_entry(pos, &tz->thermal_instances, tz_node)
 689                 if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
 690                         result = -EEXIST;
 691                         break;
 692                 }
 693         if (!result) {
 694                 list_add_tail(&dev->tz_node, &tz->thermal_instances);
 695                 list_add_tail(&dev->cdev_node, &cdev->thermal_instances);
 696                 atomic_set(&tz->need_update, 1);
 697         }
 698         mutex_unlock(&cdev->lock);
 699         mutex_unlock(&tz->lock);
 700
 701         if (!result)
 702                 return 0;
 703
 704         device_remove_file(&tz->device, &dev->weight_attr);
 705 remove_trip_file:
 706         device_remove_file(&tz->device, &dev->attr);
 707 remove_symbol_link:
 708         sysfs_remove_link(&tz->device.kobj, dev->name);
 709 release_ida:
 710         ida_free(&tz->ida, dev->id);
 711 free_mem:
 712         kfree(dev);
 713         return result;
 714 }
 715 EXPORT_SYMBOL_GPL(thermal_zone_bind_cooling_device);
 716
 717 /**
 718  * thermal_zone_unbind_cooling_device() - unbind a cooling device from a
 719  *                                        thermal zone.
 720  * @tz:         pointer to a struct thermal_zone_device.
 721  * @trip:       indicates which trip point the cooling devices is
 722  *              associated with in this thermal zone.
 723  * @cdev:       pointer to a struct thermal_cooling_device.
 724  *
 725  * This interface function unbind a thermal cooling device from the certain
 726  * trip point of a thermal zone device.
 727  * This function is usually called in the thermal zone device .unbind callback.
 728  *
 729  * Return: 0 on success, the proper error value otherwise.
 730  */
 731 int thermal_zone_unbind_cooling_device(struct thermal_zone_device *tz,
 732                                        int trip,
 733                                        struct thermal_cooling_device *cdev)
 734 {
 735         struct thermal_instance *pos, *next;
 736
 737         mutex_lock(&tz->lock);
 738         mutex_lock(&cdev->lock);
 739         list_for_each_entry_safe(pos, next, &tz->thermal_instances, tz_node) {
 740                 if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
 741                         list_del(&pos->tz_node);
 742                         list_del(&pos->cdev_node);
 743                         mutex_unlock(&cdev->lock);
 744                         mutex_unlock(&tz->lock);
 745                         goto unbind;
 746                 }
 747         }
 748         mutex_unlock(&cdev->lock);
 749         mutex_unlock(&tz->lock);
 750
 751         return -ENODEV;
 752
 753 unbind:
 754         device_remove_file(&tz->device, &pos->weight_attr);
 755         device_remove_file(&tz->device, &pos->attr);
 756         sysfs_remove_link(&tz->device.kobj, pos->name);
 757         ida_free(&tz->ida, pos->id);
 758         kfree(pos);
 759         return 0;
 760 }
 761 EXPORT_SYMBOL_GPL(thermal_zone_unbind_cooling_device);
 762
 763 static void thermal_release(struct device *dev)
 764 {
 765         struct thermal_zone_device *tz;
 766         struct thermal_cooling_device *cdev;
 767
 768         if (!strncmp(dev_name(dev), "thermal_zone",
 769                      sizeof("thermal_zone") - 1)) {
 770                 tz = to_thermal_zone(dev);
 771                 thermal_zone_destroy_device_groups(tz);
 772                 mutex_destroy(&tz->lock);
 773                 kfree(tz);
 774         } else if (!strncmp(dev_name(dev), "cooling_device",
 775                             sizeof("cooling_device") - 1)) {
 776                 cdev = to_cooling_device(dev);
 777                 kfree(cdev);
 778         }
 779 }
 780
 781 static struct class thermal_class = {
 782         .name = "thermal",
 783         .dev_release = thermal_release,
 784 };
 785
 786 static inline
 787 void print_bind_err_msg(struct thermal_zone_device *tz,
 788                         struct thermal_cooling_device *cdev, int ret)
 789 {
 790         dev_err(&tz->device, "binding zone %s with cdev %s failed:%d\n",
 791                 tz->type, cdev->type, ret);
 792 }
 793
 794 static void __bind(struct thermal_zone_device *tz, int mask,
 795                    struct thermal_cooling_device *cdev,
 796                    unsigned long *limits,
 797                    unsigned int weight)
 798 {
 799         int i, ret;
 800
 801         for (i = 0; i < tz->num_trips; i++) {
 802                 if (mask & (1 << i)) {
 803                         unsigned long upper, lower;
 804
 805                         upper = THERMAL_NO_LIMIT;
 806                         lower = THERMAL_NO_LIMIT;
 807                         if (limits) {
 808                                 lower = limits[i * 2];
 809                                 upper = limits[i * 2 + 1];
 810                         }
 811                         ret = thermal_zone_bind_cooling_device(tz, i, cdev,
 812                                                                upper, lower,
 813                                                                weight);
 814                         if (ret)
 815                                 print_bind_err_msg(tz, cdev, ret);
 816                 }
 817         }
 818 }
 819
 820 static void bind_cdev(struct thermal_cooling_device *cdev)
 821 {
 822         int i, ret;
 823         const struct thermal_zone_params *tzp;
 824         struct thermal_zone_device *pos = NULL;
 825
 826         mutex_lock(&thermal_list_lock);
 827
 828         list_for_each_entry(pos, &thermal_tz_list, node) {
 829                 if (!pos->tzp && !pos->ops->bind)
 830                         continue;
 831
 832                 if (pos->ops->bind) {
 833                         ret = pos->ops->bind(pos, cdev);
 834                         if (ret)
 835                                 print_bind_err_msg(pos, cdev, ret);
 836                         continue;
 837                 }
 838
 839                 tzp = pos->tzp;
 840                 if (!tzp || !tzp->tbp)
 841                         continue;
 842
 843                 for (i = 0; i < tzp->num_tbps; i++) {
 844                         if (tzp->tbp[i].cdev || !tzp->tbp[i].match)
 845                                 continue;
 846                         if (tzp->tbp[i].match(pos, cdev))
 847                                 continue;
 848                         tzp->tbp[i].cdev = cdev;
 849                         __bind(pos, tzp->tbp[i].trip_mask, cdev,
 850                                tzp->tbp[i].binding_limits,
 851                                tzp->tbp[i].weight);
 852                 }
 853         }
 854
 855         mutex_unlock(&thermal_list_lock);
 856 }
 857
 858 /**
 859  * __thermal_cooling_device_register() - register a new thermal cooling device
 860  * @np:         a pointer to a device tree node.
 861  * @type:       the thermal cooling device type.
 862  * @devdata:    device private data.
 863  * @ops:                standard thermal cooling devices callbacks.
 864  *
 865  * This interface function adds a new thermal cooling device (fan/processor/...)
 866  * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
 867  * to all the thermal zone devices registered at the same time.
 868  * It also gives the opportunity to link the cooling device to a device tree
 869  * node, so that it can be bound to a thermal zone created out of device tree.
 870  *
 871  * Return: a pointer to the created struct thermal_cooling_device or an
 872  * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
 873  */
 874 static struct thermal_cooling_device *
 875 __thermal_cooling_device_register(struct device_node *np,
 876                                   const char *type, void *devdata,
 877                                   const struct thermal_cooling_device_ops *ops)
 878 {
 879         struct thermal_cooling_device *cdev;
 880         struct thermal_zone_device *pos = NULL;
 881         int id, ret;
 882
 883         if (!ops || !ops->get_max_state || !ops->get_cur_state ||
 884             !ops->set_cur_state)
 885                 return ERR_PTR(-EINVAL);
 886
 887         cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
 888         if (!cdev)
 889                 return ERR_PTR(-ENOMEM);
 890
 891         ret = ida_alloc(&thermal_cdev_ida, GFP_KERNEL);
 892         if (ret < 0)
 893                 goto out_kfree_cdev;
 894         cdev->id = ret;
 895         id = ret;
 896
 897         cdev->type = kstrdup(type ? type : "", GFP_KERNEL);
 898         if (!cdev->type) {
 899                 ret = -ENOMEM;
 900                 goto out_ida_remove;
 901         }
 902
 903         mutex_init(&cdev->lock);
 904         INIT_LIST_HEAD(&cdev->thermal_instances);
 905         cdev->np = np;
 906         cdev->ops = ops;
 907         cdev->updated = false;
 908         cdev->device.class = &thermal_class;
 909         cdev->devdata = devdata;
 910
 911         ret = cdev->ops->get_max_state(cdev, &cdev->max_state);
 912         if (ret)
 913                 goto out_kfree_type;
 914
 915         thermal_cooling_device_setup_sysfs(cdev);
 916         ret = dev_set_name(&cdev->device, "cooling_device%d", cdev->id);
 917         if (ret) {
 918                 thermal_cooling_device_destroy_sysfs(cdev);
 919                 goto out_kfree_type;
 920         }
 921         ret = device_register(&cdev->device);
 922         if (ret)
 923                 goto out_kfree_type;
 924
 925         /* Add 'this' new cdev to the global cdev list */
 926         mutex_lock(&thermal_list_lock);
 927         list_add(&cdev->node, &thermal_cdev_list);
 928         mutex_unlock(&thermal_list_lock);
 929
 930         /* Update binding information for 'this' new cdev */
 931         bind_cdev(cdev);
 932
 933         mutex_lock(&thermal_list_lock);
 934         list_for_each_entry(pos, &thermal_tz_list, node)
 935                 if (atomic_cmpxchg(&pos->need_update, 1, 0))
 936                         thermal_zone_device_update(pos,
 937                                                    THERMAL_EVENT_UNSPECIFIED);
 938         mutex_unlock(&thermal_list_lock);
 939
 940         return cdev;
 941
 942 out_kfree_type:
 943         thermal_cooling_device_destroy_sysfs(cdev);
 944         kfree(cdev->type);
 945         put_device(&cdev->device);
 946         cdev = NULL;
 947 out_ida_remove:
 948         ida_free(&thermal_cdev_ida, id);
 949 out_kfree_cdev:
 950         kfree(cdev);
 951         return ERR_PTR(ret);
 952 }
 953
 954 /**
 955  * thermal_cooling_device_register() - register a new thermal cooling device
 956  * @type:       the thermal cooling device type.
 957  * @devdata:    device private data.
 958  * @ops:                standard thermal cooling devices callbacks.
 959  *
 960  * This interface function adds a new thermal cooling device (fan/processor/...)
 961  * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
 962  * to all the thermal zone devices registered at the same time.
 963  *
 964  * Return: a pointer to the created struct thermal_cooling_device or an
 965  * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
 966  */
 967 struct thermal_cooling_device *
 968 thermal_cooling_device_register(const char *type, void *devdata,
 969                                 const struct thermal_cooling_device_ops *ops)
 970 {
 971         return __thermal_cooling_device_register(NULL, type, devdata, ops);
 972 }
 973 EXPORT_SYMBOL_GPL(thermal_cooling_device_register);
 974
 975 /**
 976  * thermal_of_cooling_device_register() - register an OF thermal cooling device
 977  * @np:         a pointer to a device tree node.
 978  * @type:       the thermal cooling device type.
 979  * @devdata:    device private data.
 980  * @ops:                standard thermal cooling devices callbacks.
 981  *
 982  * This function will register a cooling device with device tree node reference.
 983  * This interface function adds a new thermal cooling device (fan/processor/...)
 984  * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
 985  * to all the thermal zone devices registered at the same time.
 986  *
 987  * Return: a pointer to the created struct thermal_cooling_device or an
 988  * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
 989  */
 990 struct thermal_cooling_device *
 991 thermal_of_cooling_device_register(struct device_node *np,
 992                                    const char *type, void *devdata,
 993                                    const struct thermal_cooling_device_ops *ops)
 994 {
 995         return __thermal_cooling_device_register(np, type, devdata, ops);
 996 }
 997 EXPORT_SYMBOL_GPL(thermal_of_cooling_device_register);
 998
 999 static void thermal_cooling_device_release(struct device *dev, void *res)
1000 {
1001         thermal_cooling_device_unregister(
1002                                 *(struct thermal_cooling_device **)res);
1003 }
1004
1005 /**
1006  * devm_thermal_of_cooling_device_register() - register an OF thermal cooling
1007  *                                             device
1008  * @dev:        a valid struct device pointer of a sensor device.
1009  * @np:         a pointer to a device tree node.
1010  * @type:       the thermal cooling device type.
1011  * @devdata:    device private data.
1012  * @ops:        standard thermal cooling devices callbacks.
1013  *
1014  * This function will register a cooling device with device tree node reference.
1015  * This interface function adds a new thermal cooling device (fan/processor/...)
1016  * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
1017  * to all the thermal zone devices registered at the same time.
1018  *
1019  * Return: a pointer to the created struct thermal_cooling_device or an
1020  * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
1021  */
1022 struct thermal_cooling_device *
1023 devm_thermal_of_cooling_device_register(struct device *dev,
1024                                 struct device_node *np,
1025                                 char *type, void *devdata,
1026                                 const struct thermal_cooling_device_ops *ops)
1027 {
1028         struct thermal_cooling_device **ptr, *tcd;
1029
1030         ptr = devres_alloc(thermal_cooling_device_release, sizeof(*ptr),
1031                            GFP_KERNEL);
1032         if (!ptr)
1033                 return ERR_PTR(-ENOMEM);
1034
1035         tcd = __thermal_cooling_device_register(np, type, devdata, ops);
1036         if (IS_ERR(tcd)) {
1037                 devres_free(ptr);
1038                 return tcd;
1039         }
1040
1041         *ptr = tcd;
1042         devres_add(dev, ptr);
1043
1044         return tcd;
1045 }
1046 EXPORT_SYMBOL_GPL(devm_thermal_of_cooling_device_register);
1047
1048 static void __unbind(struct thermal_zone_device *tz, int mask,
1049                      struct thermal_cooling_device *cdev)
1050 {
1051         int i;
1052
1053         for (i = 0; i < tz->num_trips; i++)
1054                 if (mask & (1 << i))
1055                         thermal_zone_unbind_cooling_device(tz, i, cdev);
1056 }
1057
1058 /**
1059  * thermal_cooling_device_unregister - removes a thermal cooling device
1060  * @cdev:       the thermal cooling device to remove.
1061  *
1062  * thermal_cooling_device_unregister() must be called when a registered
1063  * thermal cooling device is no longer needed.
1064  */
1065 void thermal_cooling_device_unregister(struct thermal_cooling_device *cdev)
1066 {
1067         int i;
1068         const struct thermal_zone_params *tzp;
1069         struct thermal_zone_device *tz;
1070         struct thermal_cooling_device *pos = NULL;
1071
1072         if (!cdev)
1073                 return;
1074
1075         mutex_lock(&thermal_list_lock);
1076         list_for_each_entry(pos, &thermal_cdev_list, node)
1077                 if (pos == cdev)
1078                         break;
1079         if (pos != cdev) {
1080                 /* thermal cooling device not found */
1081                 mutex_unlock(&thermal_list_lock);
1082                 return;
1083         }
1084         list_del(&cdev->node);
1085
1086         /* Unbind all thermal zones associated with 'this' cdev */
1087         list_for_each_entry(tz, &thermal_tz_list, node) {
1088                 if (tz->ops->unbind) {
1089                         tz->ops->unbind(tz, cdev);
1090                         continue;
1091                 }
1092
1093                 if (!tz->tzp || !tz->tzp->tbp)
1094                         continue;
1095
1096                 tzp = tz->tzp;
1097                 for (i = 0; i < tzp->num_tbps; i++) {
1098                         if (tzp->tbp[i].cdev == cdev) {
1099                                 __unbind(tz, tzp->tbp[i].trip_mask, cdev);
1100                                 tzp->tbp[i].cdev = NULL;
1101                         }
1102                 }
1103         }
1104
1105         mutex_unlock(&thermal_list_lock);
1106
1107         ida_free(&thermal_cdev_ida, cdev->id);
1108         device_del(&cdev->device);
1109         thermal_cooling_device_destroy_sysfs(cdev);
1110         kfree(cdev->type);
1111         put_device(&cdev->device);
1112 }
1113 EXPORT_SYMBOL_GPL(thermal_cooling_device_unregister);
1114
1115 static void bind_tz(struct thermal_zone_device *tz)
1116 {
1117         int i, ret;
1118         struct thermal_cooling_device *pos = NULL;
1119         const struct thermal_zone_params *tzp = tz->tzp;
1120
1121         if (!tzp && !tz->ops->bind)
1122                 return;
1123
1124         mutex_lock(&thermal_list_lock);
1125
1126         /* If there is ops->bind, try to use ops->bind */
1127         if (tz->ops->bind) {
1128                 list_for_each_entry(pos, &thermal_cdev_list, node) {
1129                         ret = tz->ops->bind(tz, pos);
1130                         if (ret)
1131                                 print_bind_err_msg(tz, pos, ret);
1132                 }
1133                 goto exit;
1134         }
1135
1136         if (!tzp || !tzp->tbp)
1137                 goto exit;
1138
1139         list_for_each_entry(pos, &thermal_cdev_list, node) {
1140                 for (i = 0; i < tzp->num_tbps; i++) {
1141                         if (tzp->tbp[i].cdev || !tzp->tbp[i].match)
1142                                 continue;
1143                         if (tzp->tbp[i].match(tz, pos))
1144                                 continue;
1145                         tzp->tbp[i].cdev = pos;
1146                         __bind(tz, tzp->tbp[i].trip_mask, pos,
1147                                tzp->tbp[i].binding_limits,
1148                                tzp->tbp[i].weight);
1149                 }
1150         }
1151 exit:
1152         mutex_unlock(&thermal_list_lock);
1153 }
1154
1155 static void thermal_set_delay_jiffies(unsigned long *delay_jiffies, int delay_ms)
1156 {
1157         *delay_jiffies = msecs_to_jiffies(delay_ms);
1158         if (delay_ms > 1000)
1159                 *delay_jiffies = round_jiffies(*delay_jiffies);
1160 }
1161
1162 /**
1163  * thermal_zone_device_register_with_trips() - register a new thermal zone device
1164  * @type:       the thermal zone device type
1165  * @trips:      a pointer to an array of thermal trips
1166  * @num_trips:  the number of trip points the thermal zone support
1167  * @mask:       a bit string indicating the writeablility of trip points
1168  * @devdata:    private device data
1169  * @ops:        standard thermal zone device callbacks
1170  * @tzp:        thermal zone platform parameters
1171  * @passive_delay: number of milliseconds to wait between polls when
1172  *                 performing passive cooling
1173  * @polling_delay: number of milliseconds to wait between polls when checking
1174  *                 whether trip points have been crossed (0 for interrupt
1175  *                 driven systems)
1176  *
1177  * This interface function adds a new thermal zone device (sensor) to
1178  * /sys/class/thermal folder as thermal_zone[0-*]. It tries to bind all the
1179  * thermal cooling devices registered at the same time.
1180  * thermal_zone_device_unregister() must be called when the device is no
1181  * longer needed. The passive cooling depends on the .get_trend() return value.
1182  *
1183  * Return: a pointer to the created struct thermal_zone_device or an
1184  * in case of error, an ERR_PTR. Caller must check return value with
1185  * IS_ERR*() helpers.
1186  */
1187 struct thermal_zone_device *
1188 thermal_zone_device_register_with_trips(const char *type, struct thermal_trip *trips, int num_trips, int mask,
1189                                         void *devdata, struct thermal_zone_device_ops *ops,
1190                                         struct thermal_zone_params *tzp, int passive_delay,
1191                                         int polling_delay)
1192 {
1193         struct thermal_zone_device *tz;
1194         enum thermal_trip_type trip_type;
1195         int trip_temp;
1196         int id;
1197         int result;
1198         int count;
1199         struct thermal_governor *governor;
1200
1201         if (!type || strlen(type) == 0) {
1202                 pr_err("No thermal zone type defined\n");
1203                 return ERR_PTR(-EINVAL);
1204         }
1205
1206         if (strlen(type) >= THERMAL_NAME_LENGTH) {
1207                 pr_err("Thermal zone name (%s) too long, should be under %d chars\n",
1208                        type, THERMAL_NAME_LENGTH);
1209                 return ERR_PTR(-EINVAL);
1210         }
1211
1212         /*
1213          * Max trip count can't exceed 31 as the "mask >> num_trips" condition.
1214          * For example, shifting by 32 will result in compiler warning:
1215          * warning: right shift count >= width of type [-Wshift-count- overflow]
1216          *
1217          * Also "mask >> num_trips" will always be true with 32 bit shift.
1218          * E.g. mask = 0x80000000 for trip id 31 to be RW. Then
1219          * mask >> 32 = 0x80000000
1220          * This will result in failure for the below condition.
1221          *
1222          * Check will be true when the bit 31 of the mask is set.
1223          * 32 bit shift will cause overflow of 4 byte integer.
1224          */
1225         if (num_trips > (BITS_PER_TYPE(int) - 1) || num_trips < 0 || mask >> num_trips) {
1226                 pr_err("Incorrect number of thermal trips\n");
1227                 return ERR_PTR(-EINVAL);
1228         }
1229
1230         if (!ops) {
1231                 pr_err("Thermal zone device ops not defined\n");
1232                 return ERR_PTR(-EINVAL);
1233         }
1234
1235         if (num_trips > 0 && (!ops->get_trip_type || !ops->get_trip_temp))
1236                 return ERR_PTR(-EINVAL);
1237
1238         tz = kzalloc(sizeof(*tz), GFP_KERNEL);
1239         if (!tz)
1240                 return ERR_PTR(-ENOMEM);
1241
1242         INIT_LIST_HEAD(&tz->thermal_instances);
1243         ida_init(&tz->ida);
1244         mutex_init(&tz->lock);
1245         id = ida_alloc(&thermal_tz_ida, GFP_KERNEL);
1246         if (id < 0) {
1247                 result = id;
1248                 goto free_tz;
1249         }
1250
1251         tz->id = id;
1252         strscpy(tz->type, type, sizeof(tz->type));
1253
1254         if (!ops->critical)
1255                 ops->critical = thermal_zone_device_critical;
1256
1257         tz->ops = ops;
1258         tz->tzp = tzp;
1259         tz->device.class = &thermal_class;
1260         tz->devdata = devdata;
1261         tz->trips = trips;
1262         tz->num_trips = num_trips;
1263
1264         thermal_set_delay_jiffies(&tz->passive_delay_jiffies, passive_delay);
1265         thermal_set_delay_jiffies(&tz->polling_delay_jiffies, polling_delay);
1266
1267         /* sys I/F */
1268         /* Add nodes that are always present via .groups */
1269         result = thermal_zone_create_device_groups(tz, mask);
1270         if (result)
1271                 goto remove_id;
1272
1273         /* A new thermal zone needs to be updated anyway. */
1274         atomic_set(&tz->need_update, 1);
1275
1276         result = dev_set_name(&tz->device, "thermal_zone%d", tz->id);
1277         if (result) {
1278                 thermal_zone_destroy_device_groups(tz);
1279                 goto remove_id;
1280         }
1281         result = device_register(&tz->device);
1282         if (result)
1283                 goto release_device;
1284
1285         for (count = 0; count < num_trips; count++) {
1286                 if (tz->ops->get_trip_type(tz, count, &trip_type) ||
1287                     tz->ops->get_trip_temp(tz, count, &trip_temp) ||
1288                     !trip_temp)
1289                         set_bit(count, &tz->trips_disabled);
1290         }
1291
1292         /* Update 'this' zone's governor information */
1293         mutex_lock(&thermal_governor_lock);
1294
1295         if (tz->tzp)
1296                 governor = __find_governor(tz->tzp->governor_name);
1297         else
1298                 governor = def_governor;
1299
1300         result = thermal_set_governor(tz, governor);
1301         if (result) {
1302                 mutex_unlock(&thermal_governor_lock);
1303                 goto unregister;
1304         }
1305
1306         mutex_unlock(&thermal_governor_lock);
1307
1308         if (!tz->tzp || !tz->tzp->no_hwmon) {
1309                 result = thermal_add_hwmon_sysfs(tz);
1310                 if (result)
1311                         goto unregister;
1312         }
1313
1314         mutex_lock(&thermal_list_lock);
1315         list_add_tail(&tz->node, &thermal_tz_list);
1316         mutex_unlock(&thermal_list_lock);
1317
1318         /* Bind cooling devices for this zone */
1319         bind_tz(tz);
1320
1321         INIT_DELAYED_WORK(&tz->poll_queue, thermal_zone_device_check);
1322
1323         thermal_zone_device_init(tz);
1324         /* Update the new thermal zone and mark it as already updated. */
1325         if (atomic_cmpxchg(&tz->need_update, 1, 0))
1326                 thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
1327
1328         thermal_notify_tz_create(tz->id, tz->type);
1329
1330         return tz;
1331
1332 unregister:
1333         device_del(&tz->device);
1334 release_device:
1335         put_device(&tz->device);
1336         tz = NULL;
1337 remove_id:
1338         ida_free(&thermal_tz_ida, id);
1339 free_tz:
1340         kfree(tz);
1341         return ERR_PTR(result);
1342 }
1343 EXPORT_SYMBOL_GPL(thermal_zone_device_register_with_trips);
1344
1345 struct thermal_zone_device *thermal_zone_device_register(const char *type, int ntrips, int mask,
1346                                                          void *devdata, struct thermal_zone_device_ops *ops,
1347                                                          struct thermal_zone_params *tzp, int passive_delay,
1348                                                          int polling_delay)
1349 {
1350         return thermal_zone_device_register_with_trips(type, NULL, ntrips, mask,
1351                                                        devdata, ops, tzp,
1352                                                        passive_delay, polling_delay);
1353 }
1354 EXPORT_SYMBOL_GPL(thermal_zone_device_register);
1355
1356 /**
1357  * thermal_zone_device_unregister - removes the registered thermal zone device
1358  * @tz: the thermal zone device to remove
1359  */
1360 void thermal_zone_device_unregister(struct thermal_zone_device *tz)
1361 {
1362         int i, tz_id;
1363         const struct thermal_zone_params *tzp;
1364         struct thermal_cooling_device *cdev;
1365         struct thermal_zone_device *pos = NULL;
1366
1367         if (!tz)
1368                 return;
1369
1370         tzp = tz->tzp;
1371         tz_id = tz->id;
1372
1373         mutex_lock(&thermal_list_lock);
1374         list_for_each_entry(pos, &thermal_tz_list, node)
1375                 if (pos == tz)
1376                         break;
1377         if (pos != tz) {
1378                 /* thermal zone device not found */
1379                 mutex_unlock(&thermal_list_lock);
1380                 return;
1381         }
1382         list_del(&tz->node);
1383
1384         /* Unbind all cdevs associated with 'this' thermal zone */
1385         list_for_each_entry(cdev, &thermal_cdev_list, node) {
1386                 if (tz->ops->unbind) {
1387                         tz->ops->unbind(tz, cdev);
1388                         continue;
1389                 }
1390
1391                 if (!tzp || !tzp->tbp)
1392                         break;
1393
1394                 for (i = 0; i < tzp->num_tbps; i++) {
1395                         if (tzp->tbp[i].cdev == cdev) {
1396                                 __unbind(tz, tzp->tbp[i].trip_mask, cdev);
1397                                 tzp->tbp[i].cdev = NULL;
1398                         }
1399                 }
1400         }
1401
1402         mutex_unlock(&thermal_list_lock);
1403
1404         cancel_delayed_work_sync(&tz->poll_queue);
1405
1406         thermal_set_governor(tz, NULL);
1407
1408         thermal_remove_hwmon_sysfs(tz);
1409         ida_free(&thermal_tz_ida, tz->id);
1410         ida_destroy(&tz->ida);
1411
1412         mutex_lock(&tz->lock);
1413         device_del(&tz->device);
1414         mutex_unlock(&tz->lock);
1415
1416         put_device(&tz->device);
1417
1418         thermal_notify_tz_delete(tz_id);
1419 }
1420 EXPORT_SYMBOL_GPL(thermal_zone_device_unregister);
1421
1422 /**
1423  * thermal_zone_get_zone_by_name() - search for a zone and returns its ref
1424  * @name: thermal zone name to fetch the temperature
1425  *
1426  * When only one zone is found with the passed name, returns a reference to it.
1427  *
1428  * Return: On success returns a reference to an unique thermal zone with
1429  * matching name equals to @name, an ERR_PTR otherwise (-EINVAL for invalid
1430  * paramenters, -ENODEV for not found and -EEXIST for multiple matches).
1431  */
1432 struct thermal_zone_device *thermal_zone_get_zone_by_name(const char *name)
1433 {
1434         struct thermal_zone_device *pos = NULL, *ref = ERR_PTR(-EINVAL);
1435         unsigned int found = 0;
1436
1437         if (!name)
1438                 goto exit;
1439
1440         mutex_lock(&thermal_list_lock);
1441         list_for_each_entry(pos, &thermal_tz_list, node)
1442                 if (!strncasecmp(name, pos->type, THERMAL_NAME_LENGTH)) {
1443                         found++;
1444                         ref = pos;
1445                 }
1446         mutex_unlock(&thermal_list_lock);
1447
1448         /* nothing has been found, thus an error code for it */
1449         if (found == 0)
1450                 ref = ERR_PTR(-ENODEV);
1451         else if (found > 1)
1452         /* Success only when an unique zone is found */
1453                 ref = ERR_PTR(-EEXIST);
1454
1455 exit:
1456         return ref;
1457 }
1458 EXPORT_SYMBOL_GPL(thermal_zone_get_zone_by_name);
1459
1460 static int thermal_pm_notify(struct notifier_block *nb,
1461                              unsigned long mode, void *_unused)
1462 {
1463         struct thermal_zone_device *tz;
1464
1465         switch (mode) {
1466         case PM_HIBERNATION_PREPARE:
1467         case PM_RESTORE_PREPARE:
1468         case PM_SUSPEND_PREPARE:
1469                 atomic_set(&in_suspend, 1);
1470                 break;
1471         case PM_POST_HIBERNATION:
1472         case PM_POST_RESTORE:
1473         case PM_POST_SUSPEND:
1474                 atomic_set(&in_suspend, 0);
1475                 list_for_each_entry(tz, &thermal_tz_list, node) {
1476                         thermal_zone_device_init(tz);
1477                         thermal_zone_device_update(tz,
1478                                                    THERMAL_EVENT_UNSPECIFIED);
1479                 }
1480                 break;
1481         default:
1482                 break;
1483         }
1484         return 0;
1485 }
1486
1487 static struct notifier_block thermal_pm_nb = {
1488         .notifier_call = thermal_pm_notify,
1489 };
1490
1491 static int __init thermal_init(void)
1492 {
1493         int result;
1494
1495         result = thermal_netlink_init();
1496         if (result)
1497                 goto error;
1498
1499         result = thermal_register_governors();
1500         if (result)
1501                 goto error;
1502
1503         result = class_register(&thermal_class);
1504         if (result)
1505                 goto unregister_governors;
1506
1507         result = register_pm_notifier(&thermal_pm_nb);
1508         if (result)
1509                 pr_warn("Thermal: Can not register suspend notifier, return %d\n",
1510                         result);
1511
1512         return 0;
1513
1514 unregister_governors:
1515         thermal_unregister_governors();
1516 error:
1517         ida_destroy(&thermal_tz_ida);
1518         ida_destroy(&thermal_cdev_ida);
1519         mutex_destroy(&thermal_list_lock);
1520         mutex_destroy(&thermal_governor_lock);
1521         return result;
1522 }
1523 postcore_initcall(thermal_init);