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