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