1 /* 2 * thermal.c - Generic Thermal Management Sysfs support. 3 * 4 * Copyright (C) 2008 Intel Corp 5 * Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com> 6 * Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com> 7 * 8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; version 2 of the License. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License along 20 * with this program; if not, write to the Free Software Foundation, Inc., 21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 22 * 23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 24 */ 25 26 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 27 28 #include <linux/module.h> 29 #include <linux/device.h> 30 #include <linux/err.h> 31 #include <linux/slab.h> 32 #include <linux/kdev_t.h> 33 #include <linux/idr.h> 34 #include <linux/thermal.h> 35 #include <linux/reboot.h> 36 #include <linux/string.h> 37 #include <linux/of.h> 38 #include <net/netlink.h> 39 #include <net/genetlink.h> 40 #include <linux/suspend.h> 41 42 #define CREATE_TRACE_POINTS 43 #include <trace/events/thermal.h> 44 45 #include "thermal_core.h" 46 #include "thermal_hwmon.h" 47 48 MODULE_AUTHOR("Zhang Rui"); 49 MODULE_DESCRIPTION("Generic thermal management sysfs support"); 50 MODULE_LICENSE("GPL v2"); 51 52 static DEFINE_IDR(thermal_tz_idr); 53 static DEFINE_IDR(thermal_cdev_idr); 54 static DEFINE_MUTEX(thermal_idr_lock); 55 56 static LIST_HEAD(thermal_tz_list); 57 static LIST_HEAD(thermal_cdev_list); 58 static LIST_HEAD(thermal_governor_list); 59 60 static DEFINE_MUTEX(thermal_list_lock); 61 static DEFINE_MUTEX(thermal_governor_lock); 62 63 static atomic_t in_suspend; 64 65 static struct thermal_governor *def_governor; 66 67 static struct thermal_governor *__find_governor(const char *name) 68 { 69 struct thermal_governor *pos; 70 71 if (!name || !name[0]) 72 return def_governor; 73 74 list_for_each_entry(pos, &thermal_governor_list, governor_list) 75 if (!strncasecmp(name, pos->name, THERMAL_NAME_LENGTH)) 76 return pos; 77 78 return NULL; 79 } 80 81 /** 82 * bind_previous_governor() - bind the previous governor of the thermal zone 83 * @tz: a valid pointer to a struct thermal_zone_device 84 * @failed_gov_name: the name of the governor that failed to register 85 * 86 * Register the previous governor of the thermal zone after a new 87 * governor has failed to be bound. 88 */ 89 static void bind_previous_governor(struct thermal_zone_device *tz, 90 const char *failed_gov_name) 91 { 92 if (tz->governor && tz->governor->bind_to_tz) { 93 if (tz->governor->bind_to_tz(tz)) { 94 dev_err(&tz->device, 95 "governor %s failed to bind and the previous one (%s) failed to bind again, thermal zone %s has no governor\n", 96 failed_gov_name, tz->governor->name, tz->type); 97 tz->governor = NULL; 98 } 99 } 100 } 101 102 /** 103 * thermal_set_governor() - Switch to another governor 104 * @tz: a valid pointer to a struct thermal_zone_device 105 * @new_gov: pointer to the new governor 106 * 107 * Change the governor of thermal zone @tz. 108 * 109 * Return: 0 on success, an error if the new governor's bind_to_tz() failed. 110 */ 111 static int thermal_set_governor(struct thermal_zone_device *tz, 112 struct thermal_governor *new_gov) 113 { 114 int ret = 0; 115 116 if (tz->governor && tz->governor->unbind_from_tz) 117 tz->governor->unbind_from_tz(tz); 118 119 if (new_gov && new_gov->bind_to_tz) { 120 ret = new_gov->bind_to_tz(tz); 121 if (ret) { 122 bind_previous_governor(tz, new_gov->name); 123 124 return ret; 125 } 126 } 127 128 tz->governor = new_gov; 129 130 return ret; 131 } 132 133 int thermal_register_governor(struct thermal_governor *governor) 134 { 135 int err; 136 const char *name; 137 struct thermal_zone_device *pos; 138 139 if (!governor) 140 return -EINVAL; 141 142 mutex_lock(&thermal_governor_lock); 143 144 err = -EBUSY; 145 if (__find_governor(governor->name) == NULL) { 146 err = 0; 147 list_add(&governor->governor_list, &thermal_governor_list); 148 if (!def_governor && !strncmp(governor->name, 149 DEFAULT_THERMAL_GOVERNOR, THERMAL_NAME_LENGTH)) 150 def_governor = governor; 151 } 152 153 mutex_lock(&thermal_list_lock); 154 155 list_for_each_entry(pos, &thermal_tz_list, node) { 156 /* 157 * only thermal zones with specified tz->tzp->governor_name 158 * may run with tz->govenor unset 159 */ 160 if (pos->governor) 161 continue; 162 163 name = pos->tzp->governor_name; 164 165 if (!strncasecmp(name, governor->name, THERMAL_NAME_LENGTH)) { 166 int ret; 167 168 ret = thermal_set_governor(pos, governor); 169 if (ret) 170 dev_err(&pos->device, 171 "Failed to set governor %s for thermal zone %s: %d\n", 172 governor->name, pos->type, ret); 173 } 174 } 175 176 mutex_unlock(&thermal_list_lock); 177 mutex_unlock(&thermal_governor_lock); 178 179 return err; 180 } 181 182 void thermal_unregister_governor(struct thermal_governor *governor) 183 { 184 struct thermal_zone_device *pos; 185 186 if (!governor) 187 return; 188 189 mutex_lock(&thermal_governor_lock); 190 191 if (__find_governor(governor->name) == NULL) 192 goto exit; 193 194 mutex_lock(&thermal_list_lock); 195 196 list_for_each_entry(pos, &thermal_tz_list, node) { 197 if (!strncasecmp(pos->governor->name, governor->name, 198 THERMAL_NAME_LENGTH)) 199 thermal_set_governor(pos, NULL); 200 } 201 202 mutex_unlock(&thermal_list_lock); 203 list_del(&governor->governor_list); 204 exit: 205 mutex_unlock(&thermal_governor_lock); 206 return; 207 } 208 209 static int get_idr(struct idr *idr, struct mutex *lock, int *id) 210 { 211 int ret; 212 213 if (lock) 214 mutex_lock(lock); 215 ret = idr_alloc(idr, NULL, 0, 0, GFP_KERNEL); 216 if (lock) 217 mutex_unlock(lock); 218 if (unlikely(ret < 0)) 219 return ret; 220 *id = ret; 221 return 0; 222 } 223 224 static void release_idr(struct idr *idr, struct mutex *lock, int id) 225 { 226 if (lock) 227 mutex_lock(lock); 228 idr_remove(idr, id); 229 if (lock) 230 mutex_unlock(lock); 231 } 232 233 int get_tz_trend(struct thermal_zone_device *tz, int trip) 234 { 235 enum thermal_trend trend; 236 237 if (tz->emul_temperature || !tz->ops->get_trend || 238 tz->ops->get_trend(tz, trip, &trend)) { 239 if (tz->temperature > tz->last_temperature) 240 trend = THERMAL_TREND_RAISING; 241 else if (tz->temperature < tz->last_temperature) 242 trend = THERMAL_TREND_DROPPING; 243 else 244 trend = THERMAL_TREND_STABLE; 245 } 246 247 return trend; 248 } 249 EXPORT_SYMBOL(get_tz_trend); 250 251 struct thermal_instance *get_thermal_instance(struct thermal_zone_device *tz, 252 struct thermal_cooling_device *cdev, int trip) 253 { 254 struct thermal_instance *pos = NULL; 255 struct thermal_instance *target_instance = NULL; 256 257 mutex_lock(&tz->lock); 258 mutex_lock(&cdev->lock); 259 260 list_for_each_entry(pos, &tz->thermal_instances, tz_node) { 261 if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) { 262 target_instance = pos; 263 break; 264 } 265 } 266 267 mutex_unlock(&cdev->lock); 268 mutex_unlock(&tz->lock); 269 270 return target_instance; 271 } 272 EXPORT_SYMBOL(get_thermal_instance); 273 274 static void print_bind_err_msg(struct thermal_zone_device *tz, 275 struct thermal_cooling_device *cdev, int ret) 276 { 277 dev_err(&tz->device, "binding zone %s with cdev %s failed:%d\n", 278 tz->type, cdev->type, ret); 279 } 280 281 static void __bind(struct thermal_zone_device *tz, int mask, 282 struct thermal_cooling_device *cdev, 283 unsigned long *limits, 284 unsigned int weight) 285 { 286 int i, ret; 287 288 for (i = 0; i < tz->trips; i++) { 289 if (mask & (1 << i)) { 290 unsigned long upper, lower; 291 292 upper = THERMAL_NO_LIMIT; 293 lower = THERMAL_NO_LIMIT; 294 if (limits) { 295 lower = limits[i * 2]; 296 upper = limits[i * 2 + 1]; 297 } 298 ret = thermal_zone_bind_cooling_device(tz, i, cdev, 299 upper, lower, 300 weight); 301 if (ret) 302 print_bind_err_msg(tz, cdev, ret); 303 } 304 } 305 } 306 307 static void __unbind(struct thermal_zone_device *tz, int mask, 308 struct thermal_cooling_device *cdev) 309 { 310 int i; 311 312 for (i = 0; i < tz->trips; i++) 313 if (mask & (1 << i)) 314 thermal_zone_unbind_cooling_device(tz, i, cdev); 315 } 316 317 static void bind_cdev(struct thermal_cooling_device *cdev) 318 { 319 int i, ret; 320 const struct thermal_zone_params *tzp; 321 struct thermal_zone_device *pos = NULL; 322 323 mutex_lock(&thermal_list_lock); 324 325 list_for_each_entry(pos, &thermal_tz_list, node) { 326 if (!pos->tzp && !pos->ops->bind) 327 continue; 328 329 if (pos->ops->bind) { 330 ret = pos->ops->bind(pos, cdev); 331 if (ret) 332 print_bind_err_msg(pos, cdev, ret); 333 continue; 334 } 335 336 tzp = pos->tzp; 337 if (!tzp || !tzp->tbp) 338 continue; 339 340 for (i = 0; i < tzp->num_tbps; i++) { 341 if (tzp->tbp[i].cdev || !tzp->tbp[i].match) 342 continue; 343 if (tzp->tbp[i].match(pos, cdev)) 344 continue; 345 tzp->tbp[i].cdev = cdev; 346 __bind(pos, tzp->tbp[i].trip_mask, cdev, 347 tzp->tbp[i].binding_limits, 348 tzp->tbp[i].weight); 349 } 350 } 351 352 mutex_unlock(&thermal_list_lock); 353 } 354 355 static void bind_tz(struct thermal_zone_device *tz) 356 { 357 int i, ret; 358 struct thermal_cooling_device *pos = NULL; 359 const struct thermal_zone_params *tzp = tz->tzp; 360 361 if (!tzp && !tz->ops->bind) 362 return; 363 364 mutex_lock(&thermal_list_lock); 365 366 /* If there is ops->bind, try to use ops->bind */ 367 if (tz->ops->bind) { 368 list_for_each_entry(pos, &thermal_cdev_list, node) { 369 ret = tz->ops->bind(tz, pos); 370 if (ret) 371 print_bind_err_msg(tz, pos, ret); 372 } 373 goto exit; 374 } 375 376 if (!tzp || !tzp->tbp) 377 goto exit; 378 379 list_for_each_entry(pos, &thermal_cdev_list, node) { 380 for (i = 0; i < tzp->num_tbps; i++) { 381 if (tzp->tbp[i].cdev || !tzp->tbp[i].match) 382 continue; 383 if (tzp->tbp[i].match(tz, pos)) 384 continue; 385 tzp->tbp[i].cdev = pos; 386 __bind(tz, tzp->tbp[i].trip_mask, pos, 387 tzp->tbp[i].binding_limits, 388 tzp->tbp[i].weight); 389 } 390 } 391 exit: 392 mutex_unlock(&thermal_list_lock); 393 } 394 395 static void thermal_zone_device_set_polling(struct thermal_zone_device *tz, 396 int delay) 397 { 398 if (delay > 1000) 399 mod_delayed_work(system_freezable_wq, &tz->poll_queue, 400 round_jiffies(msecs_to_jiffies(delay))); 401 else if (delay) 402 mod_delayed_work(system_freezable_wq, &tz->poll_queue, 403 msecs_to_jiffies(delay)); 404 else 405 cancel_delayed_work(&tz->poll_queue); 406 } 407 408 static void monitor_thermal_zone(struct thermal_zone_device *tz) 409 { 410 mutex_lock(&tz->lock); 411 412 if (tz->passive) 413 thermal_zone_device_set_polling(tz, tz->passive_delay); 414 else if (tz->polling_delay) 415 thermal_zone_device_set_polling(tz, tz->polling_delay); 416 else 417 thermal_zone_device_set_polling(tz, 0); 418 419 mutex_unlock(&tz->lock); 420 } 421 422 static void handle_non_critical_trips(struct thermal_zone_device *tz, 423 int trip, enum thermal_trip_type trip_type) 424 { 425 tz->governor ? tz->governor->throttle(tz, trip) : 426 def_governor->throttle(tz, trip); 427 } 428 429 static void handle_critical_trips(struct thermal_zone_device *tz, 430 int trip, enum thermal_trip_type trip_type) 431 { 432 int trip_temp; 433 434 tz->ops->get_trip_temp(tz, trip, &trip_temp); 435 436 /* If we have not crossed the trip_temp, we do not care. */ 437 if (trip_temp <= 0 || tz->temperature < trip_temp) 438 return; 439 440 trace_thermal_zone_trip(tz, trip, trip_type); 441 442 if (tz->ops->notify) 443 tz->ops->notify(tz, trip, trip_type); 444 445 if (trip_type == THERMAL_TRIP_CRITICAL) { 446 dev_emerg(&tz->device, 447 "critical temperature reached(%d C),shutting down\n", 448 tz->temperature / 1000); 449 orderly_poweroff(true); 450 } 451 } 452 453 static void handle_thermal_trip(struct thermal_zone_device *tz, int trip) 454 { 455 enum thermal_trip_type type; 456 457 /* Ignore disabled trip points */ 458 if (test_bit(trip, &tz->trips_disabled)) 459 return; 460 461 tz->ops->get_trip_type(tz, trip, &type); 462 463 if (type == THERMAL_TRIP_CRITICAL || type == THERMAL_TRIP_HOT) 464 handle_critical_trips(tz, trip, type); 465 else 466 handle_non_critical_trips(tz, trip, type); 467 /* 468 * Alright, we handled this trip successfully. 469 * So, start monitoring again. 470 */ 471 monitor_thermal_zone(tz); 472 } 473 474 /** 475 * thermal_zone_get_temp() - returns the temperature of a thermal zone 476 * @tz: a valid pointer to a struct thermal_zone_device 477 * @temp: a valid pointer to where to store the resulting temperature. 478 * 479 * When a valid thermal zone reference is passed, it will fetch its 480 * temperature and fill @temp. 481 * 482 * Return: On success returns 0, an error code otherwise 483 */ 484 int thermal_zone_get_temp(struct thermal_zone_device *tz, int *temp) 485 { 486 int ret = -EINVAL; 487 int count; 488 int crit_temp = INT_MAX; 489 enum thermal_trip_type type; 490 491 if (!tz || IS_ERR(tz) || !tz->ops->get_temp) 492 goto exit; 493 494 mutex_lock(&tz->lock); 495 496 ret = tz->ops->get_temp(tz, temp); 497 498 if (IS_ENABLED(CONFIG_THERMAL_EMULATION) && tz->emul_temperature) { 499 for (count = 0; count < tz->trips; count++) { 500 ret = tz->ops->get_trip_type(tz, count, &type); 501 if (!ret && type == THERMAL_TRIP_CRITICAL) { 502 ret = tz->ops->get_trip_temp(tz, count, 503 &crit_temp); 504 break; 505 } 506 } 507 508 /* 509 * Only allow emulating a temperature when the real temperature 510 * is below the critical temperature so that the emulation code 511 * cannot hide critical conditions. 512 */ 513 if (!ret && *temp < crit_temp) 514 *temp = tz->emul_temperature; 515 } 516 517 mutex_unlock(&tz->lock); 518 exit: 519 return ret; 520 } 521 EXPORT_SYMBOL_GPL(thermal_zone_get_temp); 522 523 static void update_temperature(struct thermal_zone_device *tz) 524 { 525 int temp, ret; 526 527 ret = thermal_zone_get_temp(tz, &temp); 528 if (ret) { 529 if (ret != -EAGAIN) 530 dev_warn(&tz->device, 531 "failed to read out thermal zone (%d)\n", 532 ret); 533 return; 534 } 535 536 mutex_lock(&tz->lock); 537 tz->last_temperature = tz->temperature; 538 tz->temperature = temp; 539 mutex_unlock(&tz->lock); 540 541 trace_thermal_temperature(tz); 542 if (tz->last_temperature == THERMAL_TEMP_INVALID) 543 dev_dbg(&tz->device, "last_temperature N/A, current_temperature=%d\n", 544 tz->temperature); 545 else 546 dev_dbg(&tz->device, "last_temperature=%d, current_temperature=%d\n", 547 tz->last_temperature, tz->temperature); 548 } 549 550 static void thermal_zone_device_reset(struct thermal_zone_device *tz) 551 { 552 struct thermal_instance *pos; 553 554 tz->temperature = THERMAL_TEMP_INVALID; 555 tz->passive = 0; 556 list_for_each_entry(pos, &tz->thermal_instances, tz_node) 557 pos->initialized = false; 558 } 559 560 void thermal_zone_device_update(struct thermal_zone_device *tz) 561 { 562 int count; 563 564 if (atomic_read(&in_suspend)) 565 return; 566 567 if (!tz->ops->get_temp) 568 return; 569 570 update_temperature(tz); 571 572 for (count = 0; count < tz->trips; count++) 573 handle_thermal_trip(tz, count); 574 } 575 EXPORT_SYMBOL_GPL(thermal_zone_device_update); 576 577 static void thermal_zone_device_check(struct work_struct *work) 578 { 579 struct thermal_zone_device *tz = container_of(work, struct 580 thermal_zone_device, 581 poll_queue.work); 582 thermal_zone_device_update(tz); 583 } 584 585 /* sys I/F for thermal zone */ 586 587 #define to_thermal_zone(_dev) \ 588 container_of(_dev, struct thermal_zone_device, device) 589 590 static ssize_t 591 type_show(struct device *dev, struct device_attribute *attr, char *buf) 592 { 593 struct thermal_zone_device *tz = to_thermal_zone(dev); 594 595 return sprintf(buf, "%s\n", tz->type); 596 } 597 598 static ssize_t 599 temp_show(struct device *dev, struct device_attribute *attr, char *buf) 600 { 601 struct thermal_zone_device *tz = to_thermal_zone(dev); 602 int temperature, ret; 603 604 ret = thermal_zone_get_temp(tz, &temperature); 605 606 if (ret) 607 return ret; 608 609 return sprintf(buf, "%d\n", temperature); 610 } 611 612 static ssize_t 613 mode_show(struct device *dev, struct device_attribute *attr, char *buf) 614 { 615 struct thermal_zone_device *tz = to_thermal_zone(dev); 616 enum thermal_device_mode mode; 617 int result; 618 619 if (!tz->ops->get_mode) 620 return -EPERM; 621 622 result = tz->ops->get_mode(tz, &mode); 623 if (result) 624 return result; 625 626 return sprintf(buf, "%s\n", mode == THERMAL_DEVICE_ENABLED ? "enabled" 627 : "disabled"); 628 } 629 630 static ssize_t 631 mode_store(struct device *dev, struct device_attribute *attr, 632 const char *buf, size_t count) 633 { 634 struct thermal_zone_device *tz = to_thermal_zone(dev); 635 int result; 636 637 if (!tz->ops->set_mode) 638 return -EPERM; 639 640 if (!strncmp(buf, "enabled", sizeof("enabled") - 1)) 641 result = tz->ops->set_mode(tz, THERMAL_DEVICE_ENABLED); 642 else if (!strncmp(buf, "disabled", sizeof("disabled") - 1)) 643 result = tz->ops->set_mode(tz, THERMAL_DEVICE_DISABLED); 644 else 645 result = -EINVAL; 646 647 if (result) 648 return result; 649 650 return count; 651 } 652 653 static ssize_t 654 trip_point_type_show(struct device *dev, struct device_attribute *attr, 655 char *buf) 656 { 657 struct thermal_zone_device *tz = to_thermal_zone(dev); 658 enum thermal_trip_type type; 659 int trip, result; 660 661 if (!tz->ops->get_trip_type) 662 return -EPERM; 663 664 if (!sscanf(attr->attr.name, "trip_point_%d_type", &trip)) 665 return -EINVAL; 666 667 result = tz->ops->get_trip_type(tz, trip, &type); 668 if (result) 669 return result; 670 671 switch (type) { 672 case THERMAL_TRIP_CRITICAL: 673 return sprintf(buf, "critical\n"); 674 case THERMAL_TRIP_HOT: 675 return sprintf(buf, "hot\n"); 676 case THERMAL_TRIP_PASSIVE: 677 return sprintf(buf, "passive\n"); 678 case THERMAL_TRIP_ACTIVE: 679 return sprintf(buf, "active\n"); 680 default: 681 return sprintf(buf, "unknown\n"); 682 } 683 } 684 685 static ssize_t 686 trip_point_temp_store(struct device *dev, struct device_attribute *attr, 687 const char *buf, size_t count) 688 { 689 struct thermal_zone_device *tz = to_thermal_zone(dev); 690 int trip, ret; 691 int temperature; 692 693 if (!tz->ops->set_trip_temp) 694 return -EPERM; 695 696 if (!sscanf(attr->attr.name, "trip_point_%d_temp", &trip)) 697 return -EINVAL; 698 699 if (kstrtoint(buf, 10, &temperature)) 700 return -EINVAL; 701 702 ret = tz->ops->set_trip_temp(tz, trip, temperature); 703 if (ret) 704 return ret; 705 706 thermal_zone_device_update(tz); 707 708 return count; 709 } 710 711 static ssize_t 712 trip_point_temp_show(struct device *dev, struct device_attribute *attr, 713 char *buf) 714 { 715 struct thermal_zone_device *tz = to_thermal_zone(dev); 716 int trip, ret; 717 int temperature; 718 719 if (!tz->ops->get_trip_temp) 720 return -EPERM; 721 722 if (!sscanf(attr->attr.name, "trip_point_%d_temp", &trip)) 723 return -EINVAL; 724 725 ret = tz->ops->get_trip_temp(tz, trip, &temperature); 726 727 if (ret) 728 return ret; 729 730 return sprintf(buf, "%d\n", temperature); 731 } 732 733 static ssize_t 734 trip_point_hyst_store(struct device *dev, struct device_attribute *attr, 735 const char *buf, size_t count) 736 { 737 struct thermal_zone_device *tz = to_thermal_zone(dev); 738 int trip, ret; 739 int temperature; 740 741 if (!tz->ops->set_trip_hyst) 742 return -EPERM; 743 744 if (!sscanf(attr->attr.name, "trip_point_%d_hyst", &trip)) 745 return -EINVAL; 746 747 if (kstrtoint(buf, 10, &temperature)) 748 return -EINVAL; 749 750 /* 751 * We are not doing any check on the 'temperature' value 752 * here. The driver implementing 'set_trip_hyst' has to 753 * take care of this. 754 */ 755 ret = tz->ops->set_trip_hyst(tz, trip, temperature); 756 757 return ret ? ret : count; 758 } 759 760 static ssize_t 761 trip_point_hyst_show(struct device *dev, struct device_attribute *attr, 762 char *buf) 763 { 764 struct thermal_zone_device *tz = to_thermal_zone(dev); 765 int trip, ret; 766 int temperature; 767 768 if (!tz->ops->get_trip_hyst) 769 return -EPERM; 770 771 if (!sscanf(attr->attr.name, "trip_point_%d_hyst", &trip)) 772 return -EINVAL; 773 774 ret = tz->ops->get_trip_hyst(tz, trip, &temperature); 775 776 return ret ? ret : sprintf(buf, "%d\n", temperature); 777 } 778 779 static ssize_t 780 passive_store(struct device *dev, struct device_attribute *attr, 781 const char *buf, size_t count) 782 { 783 struct thermal_zone_device *tz = to_thermal_zone(dev); 784 struct thermal_cooling_device *cdev = NULL; 785 int state; 786 787 if (!sscanf(buf, "%d\n", &state)) 788 return -EINVAL; 789 790 /* sanity check: values below 1000 millicelcius don't make sense 791 * and can cause the system to go into a thermal heart attack 792 */ 793 if (state && state < 1000) 794 return -EINVAL; 795 796 if (state && !tz->forced_passive) { 797 mutex_lock(&thermal_list_lock); 798 list_for_each_entry(cdev, &thermal_cdev_list, node) { 799 if (!strncmp("Processor", cdev->type, 800 sizeof("Processor"))) 801 thermal_zone_bind_cooling_device(tz, 802 THERMAL_TRIPS_NONE, cdev, 803 THERMAL_NO_LIMIT, 804 THERMAL_NO_LIMIT, 805 THERMAL_WEIGHT_DEFAULT); 806 } 807 mutex_unlock(&thermal_list_lock); 808 if (!tz->passive_delay) 809 tz->passive_delay = 1000; 810 } else if (!state && tz->forced_passive) { 811 mutex_lock(&thermal_list_lock); 812 list_for_each_entry(cdev, &thermal_cdev_list, node) { 813 if (!strncmp("Processor", cdev->type, 814 sizeof("Processor"))) 815 thermal_zone_unbind_cooling_device(tz, 816 THERMAL_TRIPS_NONE, 817 cdev); 818 } 819 mutex_unlock(&thermal_list_lock); 820 tz->passive_delay = 0; 821 } 822 823 tz->forced_passive = state; 824 825 thermal_zone_device_update(tz); 826 827 return count; 828 } 829 830 static ssize_t 831 passive_show(struct device *dev, struct device_attribute *attr, 832 char *buf) 833 { 834 struct thermal_zone_device *tz = to_thermal_zone(dev); 835 836 return sprintf(buf, "%d\n", tz->forced_passive); 837 } 838 839 static ssize_t 840 policy_store(struct device *dev, struct device_attribute *attr, 841 const char *buf, size_t count) 842 { 843 int ret = -EINVAL; 844 struct thermal_zone_device *tz = to_thermal_zone(dev); 845 struct thermal_governor *gov; 846 char name[THERMAL_NAME_LENGTH]; 847 848 snprintf(name, sizeof(name), "%s", buf); 849 850 mutex_lock(&thermal_governor_lock); 851 mutex_lock(&tz->lock); 852 853 gov = __find_governor(strim(name)); 854 if (!gov) 855 goto exit; 856 857 ret = thermal_set_governor(tz, gov); 858 if (!ret) 859 ret = count; 860 861 exit: 862 mutex_unlock(&tz->lock); 863 mutex_unlock(&thermal_governor_lock); 864 return ret; 865 } 866 867 static ssize_t 868 policy_show(struct device *dev, struct device_attribute *devattr, char *buf) 869 { 870 struct thermal_zone_device *tz = to_thermal_zone(dev); 871 872 return sprintf(buf, "%s\n", tz->governor->name); 873 } 874 875 static ssize_t 876 available_policies_show(struct device *dev, struct device_attribute *devattr, 877 char *buf) 878 { 879 struct thermal_governor *pos; 880 ssize_t count = 0; 881 ssize_t size = PAGE_SIZE; 882 883 mutex_lock(&thermal_governor_lock); 884 885 list_for_each_entry(pos, &thermal_governor_list, governor_list) { 886 size = PAGE_SIZE - count; 887 count += scnprintf(buf + count, size, "%s ", pos->name); 888 } 889 count += scnprintf(buf + count, size, "\n"); 890 891 mutex_unlock(&thermal_governor_lock); 892 893 return count; 894 } 895 896 static ssize_t 897 emul_temp_store(struct device *dev, struct device_attribute *attr, 898 const char *buf, size_t count) 899 { 900 struct thermal_zone_device *tz = to_thermal_zone(dev); 901 int ret = 0; 902 int temperature; 903 904 if (kstrtoint(buf, 10, &temperature)) 905 return -EINVAL; 906 907 if (!tz->ops->set_emul_temp) { 908 mutex_lock(&tz->lock); 909 tz->emul_temperature = temperature; 910 mutex_unlock(&tz->lock); 911 } else { 912 ret = tz->ops->set_emul_temp(tz, temperature); 913 } 914 915 if (!ret) 916 thermal_zone_device_update(tz); 917 918 return ret ? ret : count; 919 } 920 static DEVICE_ATTR(emul_temp, S_IWUSR, NULL, emul_temp_store); 921 922 static ssize_t 923 sustainable_power_show(struct device *dev, struct device_attribute *devattr, 924 char *buf) 925 { 926 struct thermal_zone_device *tz = to_thermal_zone(dev); 927 928 if (tz->tzp) 929 return sprintf(buf, "%u\n", tz->tzp->sustainable_power); 930 else 931 return -EIO; 932 } 933 934 static ssize_t 935 sustainable_power_store(struct device *dev, struct device_attribute *devattr, 936 const char *buf, size_t count) 937 { 938 struct thermal_zone_device *tz = to_thermal_zone(dev); 939 u32 sustainable_power; 940 941 if (!tz->tzp) 942 return -EIO; 943 944 if (kstrtou32(buf, 10, &sustainable_power)) 945 return -EINVAL; 946 947 tz->tzp->sustainable_power = sustainable_power; 948 949 return count; 950 } 951 static DEVICE_ATTR(sustainable_power, S_IWUSR | S_IRUGO, sustainable_power_show, 952 sustainable_power_store); 953 954 #define create_s32_tzp_attr(name) \ 955 static ssize_t \ 956 name##_show(struct device *dev, struct device_attribute *devattr, \ 957 char *buf) \ 958 { \ 959 struct thermal_zone_device *tz = to_thermal_zone(dev); \ 960 \ 961 if (tz->tzp) \ 962 return sprintf(buf, "%d\n", tz->tzp->name); \ 963 else \ 964 return -EIO; \ 965 } \ 966 \ 967 static ssize_t \ 968 name##_store(struct device *dev, struct device_attribute *devattr, \ 969 const char *buf, size_t count) \ 970 { \ 971 struct thermal_zone_device *tz = to_thermal_zone(dev); \ 972 s32 value; \ 973 \ 974 if (!tz->tzp) \ 975 return -EIO; \ 976 \ 977 if (kstrtos32(buf, 10, &value)) \ 978 return -EINVAL; \ 979 \ 980 tz->tzp->name = value; \ 981 \ 982 return count; \ 983 } \ 984 static DEVICE_ATTR(name, S_IWUSR | S_IRUGO, name##_show, name##_store) 985 986 create_s32_tzp_attr(k_po); 987 create_s32_tzp_attr(k_pu); 988 create_s32_tzp_attr(k_i); 989 create_s32_tzp_attr(k_d); 990 create_s32_tzp_attr(integral_cutoff); 991 create_s32_tzp_attr(slope); 992 create_s32_tzp_attr(offset); 993 #undef create_s32_tzp_attr 994 995 static struct device_attribute *dev_tzp_attrs[] = { 996 &dev_attr_sustainable_power, 997 &dev_attr_k_po, 998 &dev_attr_k_pu, 999 &dev_attr_k_i, 1000 &dev_attr_k_d, 1001 &dev_attr_integral_cutoff, 1002 &dev_attr_slope, 1003 &dev_attr_offset, 1004 }; 1005 1006 static int create_tzp_attrs(struct device *dev) 1007 { 1008 int i; 1009 1010 for (i = 0; i < ARRAY_SIZE(dev_tzp_attrs); i++) { 1011 int ret; 1012 struct device_attribute *dev_attr = dev_tzp_attrs[i]; 1013 1014 ret = device_create_file(dev, dev_attr); 1015 if (ret) 1016 return ret; 1017 } 1018 1019 return 0; 1020 } 1021 1022 /** 1023 * power_actor_get_max_power() - get the maximum power that a cdev can consume 1024 * @cdev: pointer to &thermal_cooling_device 1025 * @tz: a valid thermal zone device pointer 1026 * @max_power: pointer in which to store the maximum power 1027 * 1028 * Calculate the maximum power consumption in milliwats that the 1029 * cooling device can currently consume and store it in @max_power. 1030 * 1031 * Return: 0 on success, -EINVAL if @cdev doesn't support the 1032 * power_actor API or -E* on other error. 1033 */ 1034 int power_actor_get_max_power(struct thermal_cooling_device *cdev, 1035 struct thermal_zone_device *tz, u32 *max_power) 1036 { 1037 if (!cdev_is_power_actor(cdev)) 1038 return -EINVAL; 1039 1040 return cdev->ops->state2power(cdev, tz, 0, max_power); 1041 } 1042 1043 /** 1044 * power_actor_get_min_power() - get the mainimum power that a cdev can consume 1045 * @cdev: pointer to &thermal_cooling_device 1046 * @tz: a valid thermal zone device pointer 1047 * @min_power: pointer in which to store the minimum power 1048 * 1049 * Calculate the minimum power consumption in milliwatts that the 1050 * cooling device can currently consume and store it in @min_power. 1051 * 1052 * Return: 0 on success, -EINVAL if @cdev doesn't support the 1053 * power_actor API or -E* on other error. 1054 */ 1055 int power_actor_get_min_power(struct thermal_cooling_device *cdev, 1056 struct thermal_zone_device *tz, u32 *min_power) 1057 { 1058 unsigned long max_state; 1059 int ret; 1060 1061 if (!cdev_is_power_actor(cdev)) 1062 return -EINVAL; 1063 1064 ret = cdev->ops->get_max_state(cdev, &max_state); 1065 if (ret) 1066 return ret; 1067 1068 return cdev->ops->state2power(cdev, tz, max_state, min_power); 1069 } 1070 1071 /** 1072 * power_actor_set_power() - limit the maximum power that a cooling device can consume 1073 * @cdev: pointer to &thermal_cooling_device 1074 * @instance: thermal instance to update 1075 * @power: the power in milliwatts 1076 * 1077 * Set the cooling device to consume at most @power milliwatts. 1078 * 1079 * Return: 0 on success, -EINVAL if the cooling device does not 1080 * implement the power actor API or -E* for other failures. 1081 */ 1082 int power_actor_set_power(struct thermal_cooling_device *cdev, 1083 struct thermal_instance *instance, u32 power) 1084 { 1085 unsigned long state; 1086 int ret; 1087 1088 if (!cdev_is_power_actor(cdev)) 1089 return -EINVAL; 1090 1091 ret = cdev->ops->power2state(cdev, instance->tz, power, &state); 1092 if (ret) 1093 return ret; 1094 1095 instance->target = state; 1096 mutex_lock(&cdev->lock); 1097 cdev->updated = false; 1098 mutex_unlock(&cdev->lock); 1099 thermal_cdev_update(cdev); 1100 1101 return 0; 1102 } 1103 1104 static DEVICE_ATTR(type, 0444, type_show, NULL); 1105 static DEVICE_ATTR(temp, 0444, temp_show, NULL); 1106 static DEVICE_ATTR(mode, 0644, mode_show, mode_store); 1107 static DEVICE_ATTR(passive, S_IRUGO | S_IWUSR, passive_show, passive_store); 1108 static DEVICE_ATTR(policy, S_IRUGO | S_IWUSR, policy_show, policy_store); 1109 static DEVICE_ATTR(available_policies, S_IRUGO, available_policies_show, NULL); 1110 1111 /* sys I/F for cooling device */ 1112 #define to_cooling_device(_dev) \ 1113 container_of(_dev, struct thermal_cooling_device, device) 1114 1115 static ssize_t 1116 thermal_cooling_device_type_show(struct device *dev, 1117 struct device_attribute *attr, char *buf) 1118 { 1119 struct thermal_cooling_device *cdev = to_cooling_device(dev); 1120 1121 return sprintf(buf, "%s\n", cdev->type); 1122 } 1123 1124 static ssize_t 1125 thermal_cooling_device_max_state_show(struct device *dev, 1126 struct device_attribute *attr, char *buf) 1127 { 1128 struct thermal_cooling_device *cdev = to_cooling_device(dev); 1129 unsigned long state; 1130 int ret; 1131 1132 ret = cdev->ops->get_max_state(cdev, &state); 1133 if (ret) 1134 return ret; 1135 return sprintf(buf, "%ld\n", state); 1136 } 1137 1138 static ssize_t 1139 thermal_cooling_device_cur_state_show(struct device *dev, 1140 struct device_attribute *attr, char *buf) 1141 { 1142 struct thermal_cooling_device *cdev = to_cooling_device(dev); 1143 unsigned long state; 1144 int ret; 1145 1146 ret = cdev->ops->get_cur_state(cdev, &state); 1147 if (ret) 1148 return ret; 1149 return sprintf(buf, "%ld\n", state); 1150 } 1151 1152 static ssize_t 1153 thermal_cooling_device_cur_state_store(struct device *dev, 1154 struct device_attribute *attr, 1155 const char *buf, size_t count) 1156 { 1157 struct thermal_cooling_device *cdev = to_cooling_device(dev); 1158 unsigned long state; 1159 int result; 1160 1161 if (!sscanf(buf, "%ld\n", &state)) 1162 return -EINVAL; 1163 1164 if ((long)state < 0) 1165 return -EINVAL; 1166 1167 result = cdev->ops->set_cur_state(cdev, state); 1168 if (result) 1169 return result; 1170 return count; 1171 } 1172 1173 static struct device_attribute dev_attr_cdev_type = 1174 __ATTR(type, 0444, thermal_cooling_device_type_show, NULL); 1175 static DEVICE_ATTR(max_state, 0444, 1176 thermal_cooling_device_max_state_show, NULL); 1177 static DEVICE_ATTR(cur_state, 0644, 1178 thermal_cooling_device_cur_state_show, 1179 thermal_cooling_device_cur_state_store); 1180 1181 static ssize_t 1182 thermal_cooling_device_trip_point_show(struct device *dev, 1183 struct device_attribute *attr, char *buf) 1184 { 1185 struct thermal_instance *instance; 1186 1187 instance = 1188 container_of(attr, struct thermal_instance, attr); 1189 1190 if (instance->trip == THERMAL_TRIPS_NONE) 1191 return sprintf(buf, "-1\n"); 1192 else 1193 return sprintf(buf, "%d\n", instance->trip); 1194 } 1195 1196 static struct attribute *cooling_device_attrs[] = { 1197 &dev_attr_cdev_type.attr, 1198 &dev_attr_max_state.attr, 1199 &dev_attr_cur_state.attr, 1200 NULL, 1201 }; 1202 1203 static const struct attribute_group cooling_device_attr_group = { 1204 .attrs = cooling_device_attrs, 1205 }; 1206 1207 static const struct attribute_group *cooling_device_attr_groups[] = { 1208 &cooling_device_attr_group, 1209 NULL, 1210 }; 1211 1212 static ssize_t 1213 thermal_cooling_device_weight_show(struct device *dev, 1214 struct device_attribute *attr, char *buf) 1215 { 1216 struct thermal_instance *instance; 1217 1218 instance = container_of(attr, struct thermal_instance, weight_attr); 1219 1220 return sprintf(buf, "%d\n", instance->weight); 1221 } 1222 1223 static ssize_t 1224 thermal_cooling_device_weight_store(struct device *dev, 1225 struct device_attribute *attr, 1226 const char *buf, size_t count) 1227 { 1228 struct thermal_instance *instance; 1229 int ret, weight; 1230 1231 ret = kstrtoint(buf, 0, &weight); 1232 if (ret) 1233 return ret; 1234 1235 instance = container_of(attr, struct thermal_instance, weight_attr); 1236 instance->weight = weight; 1237 1238 return count; 1239 } 1240 /* Device management */ 1241 1242 /** 1243 * thermal_zone_bind_cooling_device() - bind a cooling device to a thermal zone 1244 * @tz: pointer to struct thermal_zone_device 1245 * @trip: indicates which trip point the cooling devices is 1246 * associated with in this thermal zone. 1247 * @cdev: pointer to struct thermal_cooling_device 1248 * @upper: the Maximum cooling state for this trip point. 1249 * THERMAL_NO_LIMIT means no upper limit, 1250 * and the cooling device can be in max_state. 1251 * @lower: the Minimum cooling state can be used for this trip point. 1252 * THERMAL_NO_LIMIT means no lower limit, 1253 * and the cooling device can be in cooling state 0. 1254 * @weight: The weight of the cooling device to be bound to the 1255 * thermal zone. Use THERMAL_WEIGHT_DEFAULT for the 1256 * default value 1257 * 1258 * This interface function bind a thermal cooling device to the certain trip 1259 * point of a thermal zone device. 1260 * This function is usually called in the thermal zone device .bind callback. 1261 * 1262 * Return: 0 on success, the proper error value otherwise. 1263 */ 1264 int thermal_zone_bind_cooling_device(struct thermal_zone_device *tz, 1265 int trip, 1266 struct thermal_cooling_device *cdev, 1267 unsigned long upper, unsigned long lower, 1268 unsigned int weight) 1269 { 1270 struct thermal_instance *dev; 1271 struct thermal_instance *pos; 1272 struct thermal_zone_device *pos1; 1273 struct thermal_cooling_device *pos2; 1274 unsigned long max_state; 1275 int result, ret; 1276 1277 if (trip >= tz->trips || (trip < 0 && trip != THERMAL_TRIPS_NONE)) 1278 return -EINVAL; 1279 1280 list_for_each_entry(pos1, &thermal_tz_list, node) { 1281 if (pos1 == tz) 1282 break; 1283 } 1284 list_for_each_entry(pos2, &thermal_cdev_list, node) { 1285 if (pos2 == cdev) 1286 break; 1287 } 1288 1289 if (tz != pos1 || cdev != pos2) 1290 return -EINVAL; 1291 1292 ret = cdev->ops->get_max_state(cdev, &max_state); 1293 if (ret) 1294 return ret; 1295 1296 /* lower default 0, upper default max_state */ 1297 lower = lower == THERMAL_NO_LIMIT ? 0 : lower; 1298 upper = upper == THERMAL_NO_LIMIT ? max_state : upper; 1299 1300 if (lower > upper || upper > max_state) 1301 return -EINVAL; 1302 1303 dev = 1304 kzalloc(sizeof(struct thermal_instance), GFP_KERNEL); 1305 if (!dev) 1306 return -ENOMEM; 1307 dev->tz = tz; 1308 dev->cdev = cdev; 1309 dev->trip = trip; 1310 dev->upper = upper; 1311 dev->lower = lower; 1312 dev->target = THERMAL_NO_TARGET; 1313 dev->weight = weight; 1314 1315 result = get_idr(&tz->idr, &tz->lock, &dev->id); 1316 if (result) 1317 goto free_mem; 1318 1319 sprintf(dev->name, "cdev%d", dev->id); 1320 result = 1321 sysfs_create_link(&tz->device.kobj, &cdev->device.kobj, dev->name); 1322 if (result) 1323 goto release_idr; 1324 1325 sprintf(dev->attr_name, "cdev%d_trip_point", dev->id); 1326 sysfs_attr_init(&dev->attr.attr); 1327 dev->attr.attr.name = dev->attr_name; 1328 dev->attr.attr.mode = 0444; 1329 dev->attr.show = thermal_cooling_device_trip_point_show; 1330 result = device_create_file(&tz->device, &dev->attr); 1331 if (result) 1332 goto remove_symbol_link; 1333 1334 sprintf(dev->weight_attr_name, "cdev%d_weight", dev->id); 1335 sysfs_attr_init(&dev->weight_attr.attr); 1336 dev->weight_attr.attr.name = dev->weight_attr_name; 1337 dev->weight_attr.attr.mode = S_IWUSR | S_IRUGO; 1338 dev->weight_attr.show = thermal_cooling_device_weight_show; 1339 dev->weight_attr.store = thermal_cooling_device_weight_store; 1340 result = device_create_file(&tz->device, &dev->weight_attr); 1341 if (result) 1342 goto remove_trip_file; 1343 1344 mutex_lock(&tz->lock); 1345 mutex_lock(&cdev->lock); 1346 list_for_each_entry(pos, &tz->thermal_instances, tz_node) 1347 if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) { 1348 result = -EEXIST; 1349 break; 1350 } 1351 if (!result) { 1352 list_add_tail(&dev->tz_node, &tz->thermal_instances); 1353 list_add_tail(&dev->cdev_node, &cdev->thermal_instances); 1354 atomic_set(&tz->need_update, 1); 1355 } 1356 mutex_unlock(&cdev->lock); 1357 mutex_unlock(&tz->lock); 1358 1359 if (!result) 1360 return 0; 1361 1362 device_remove_file(&tz->device, &dev->weight_attr); 1363 remove_trip_file: 1364 device_remove_file(&tz->device, &dev->attr); 1365 remove_symbol_link: 1366 sysfs_remove_link(&tz->device.kobj, dev->name); 1367 release_idr: 1368 release_idr(&tz->idr, &tz->lock, dev->id); 1369 free_mem: 1370 kfree(dev); 1371 return result; 1372 } 1373 EXPORT_SYMBOL_GPL(thermal_zone_bind_cooling_device); 1374 1375 /** 1376 * thermal_zone_unbind_cooling_device() - unbind a cooling device from a 1377 * thermal zone. 1378 * @tz: pointer to a struct thermal_zone_device. 1379 * @trip: indicates which trip point the cooling devices is 1380 * associated with in this thermal zone. 1381 * @cdev: pointer to a struct thermal_cooling_device. 1382 * 1383 * This interface function unbind a thermal cooling device from the certain 1384 * trip point of a thermal zone device. 1385 * This function is usually called in the thermal zone device .unbind callback. 1386 * 1387 * Return: 0 on success, the proper error value otherwise. 1388 */ 1389 int thermal_zone_unbind_cooling_device(struct thermal_zone_device *tz, 1390 int trip, 1391 struct thermal_cooling_device *cdev) 1392 { 1393 struct thermal_instance *pos, *next; 1394 1395 mutex_lock(&tz->lock); 1396 mutex_lock(&cdev->lock); 1397 list_for_each_entry_safe(pos, next, &tz->thermal_instances, tz_node) { 1398 if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) { 1399 list_del(&pos->tz_node); 1400 list_del(&pos->cdev_node); 1401 mutex_unlock(&cdev->lock); 1402 mutex_unlock(&tz->lock); 1403 goto unbind; 1404 } 1405 } 1406 mutex_unlock(&cdev->lock); 1407 mutex_unlock(&tz->lock); 1408 1409 return -ENODEV; 1410 1411 unbind: 1412 device_remove_file(&tz->device, &pos->weight_attr); 1413 device_remove_file(&tz->device, &pos->attr); 1414 sysfs_remove_link(&tz->device.kobj, pos->name); 1415 release_idr(&tz->idr, &tz->lock, pos->id); 1416 kfree(pos); 1417 return 0; 1418 } 1419 EXPORT_SYMBOL_GPL(thermal_zone_unbind_cooling_device); 1420 1421 static void thermal_release(struct device *dev) 1422 { 1423 struct thermal_zone_device *tz; 1424 struct thermal_cooling_device *cdev; 1425 1426 if (!strncmp(dev_name(dev), "thermal_zone", 1427 sizeof("thermal_zone") - 1)) { 1428 tz = to_thermal_zone(dev); 1429 kfree(tz); 1430 } else if(!strncmp(dev_name(dev), "cooling_device", 1431 sizeof("cooling_device") - 1)){ 1432 cdev = to_cooling_device(dev); 1433 kfree(cdev); 1434 } 1435 } 1436 1437 static struct class thermal_class = { 1438 .name = "thermal", 1439 .dev_release = thermal_release, 1440 }; 1441 1442 /** 1443 * __thermal_cooling_device_register() - register a new thermal cooling device 1444 * @np: a pointer to a device tree node. 1445 * @type: the thermal cooling device type. 1446 * @devdata: device private data. 1447 * @ops: standard thermal cooling devices callbacks. 1448 * 1449 * This interface function adds a new thermal cooling device (fan/processor/...) 1450 * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself 1451 * to all the thermal zone devices registered at the same time. 1452 * It also gives the opportunity to link the cooling device to a device tree 1453 * node, so that it can be bound to a thermal zone created out of device tree. 1454 * 1455 * Return: a pointer to the created struct thermal_cooling_device or an 1456 * ERR_PTR. Caller must check return value with IS_ERR*() helpers. 1457 */ 1458 static struct thermal_cooling_device * 1459 __thermal_cooling_device_register(struct device_node *np, 1460 char *type, void *devdata, 1461 const struct thermal_cooling_device_ops *ops) 1462 { 1463 struct thermal_cooling_device *cdev; 1464 struct thermal_zone_device *pos = NULL; 1465 int result; 1466 1467 if (type && strlen(type) >= THERMAL_NAME_LENGTH) 1468 return ERR_PTR(-EINVAL); 1469 1470 if (!ops || !ops->get_max_state || !ops->get_cur_state || 1471 !ops->set_cur_state) 1472 return ERR_PTR(-EINVAL); 1473 1474 cdev = kzalloc(sizeof(struct thermal_cooling_device), GFP_KERNEL); 1475 if (!cdev) 1476 return ERR_PTR(-ENOMEM); 1477 1478 result = get_idr(&thermal_cdev_idr, &thermal_idr_lock, &cdev->id); 1479 if (result) { 1480 kfree(cdev); 1481 return ERR_PTR(result); 1482 } 1483 1484 strlcpy(cdev->type, type ? : "", sizeof(cdev->type)); 1485 mutex_init(&cdev->lock); 1486 INIT_LIST_HEAD(&cdev->thermal_instances); 1487 cdev->np = np; 1488 cdev->ops = ops; 1489 cdev->updated = false; 1490 cdev->device.class = &thermal_class; 1491 cdev->device.groups = cooling_device_attr_groups; 1492 cdev->devdata = devdata; 1493 dev_set_name(&cdev->device, "cooling_device%d", cdev->id); 1494 result = device_register(&cdev->device); 1495 if (result) { 1496 release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id); 1497 kfree(cdev); 1498 return ERR_PTR(result); 1499 } 1500 1501 /* Add 'this' new cdev to the global cdev list */ 1502 mutex_lock(&thermal_list_lock); 1503 list_add(&cdev->node, &thermal_cdev_list); 1504 mutex_unlock(&thermal_list_lock); 1505 1506 /* Update binding information for 'this' new cdev */ 1507 bind_cdev(cdev); 1508 1509 mutex_lock(&thermal_list_lock); 1510 list_for_each_entry(pos, &thermal_tz_list, node) 1511 if (atomic_cmpxchg(&pos->need_update, 1, 0)) 1512 thermal_zone_device_update(pos); 1513 mutex_unlock(&thermal_list_lock); 1514 1515 return cdev; 1516 } 1517 1518 /** 1519 * thermal_cooling_device_register() - register a new thermal cooling device 1520 * @type: the thermal cooling device type. 1521 * @devdata: device private data. 1522 * @ops: standard thermal cooling devices callbacks. 1523 * 1524 * This interface function adds a new thermal cooling device (fan/processor/...) 1525 * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself 1526 * to all the thermal zone devices registered at the same time. 1527 * 1528 * Return: a pointer to the created struct thermal_cooling_device or an 1529 * ERR_PTR. Caller must check return value with IS_ERR*() helpers. 1530 */ 1531 struct thermal_cooling_device * 1532 thermal_cooling_device_register(char *type, void *devdata, 1533 const struct thermal_cooling_device_ops *ops) 1534 { 1535 return __thermal_cooling_device_register(NULL, type, devdata, ops); 1536 } 1537 EXPORT_SYMBOL_GPL(thermal_cooling_device_register); 1538 1539 /** 1540 * thermal_of_cooling_device_register() - register an OF thermal cooling device 1541 * @np: a pointer to a device tree node. 1542 * @type: the thermal cooling device type. 1543 * @devdata: device private data. 1544 * @ops: standard thermal cooling devices callbacks. 1545 * 1546 * This function will register a cooling device with device tree node reference. 1547 * This interface function adds a new thermal cooling device (fan/processor/...) 1548 * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself 1549 * to all the thermal zone devices registered at the same time. 1550 * 1551 * Return: a pointer to the created struct thermal_cooling_device or an 1552 * ERR_PTR. Caller must check return value with IS_ERR*() helpers. 1553 */ 1554 struct thermal_cooling_device * 1555 thermal_of_cooling_device_register(struct device_node *np, 1556 char *type, void *devdata, 1557 const struct thermal_cooling_device_ops *ops) 1558 { 1559 return __thermal_cooling_device_register(np, type, devdata, ops); 1560 } 1561 EXPORT_SYMBOL_GPL(thermal_of_cooling_device_register); 1562 1563 /** 1564 * thermal_cooling_device_unregister - removes the registered thermal cooling device 1565 * @cdev: the thermal cooling device to remove. 1566 * 1567 * thermal_cooling_device_unregister() must be called when the device is no 1568 * longer needed. 1569 */ 1570 void thermal_cooling_device_unregister(struct thermal_cooling_device *cdev) 1571 { 1572 int i; 1573 const struct thermal_zone_params *tzp; 1574 struct thermal_zone_device *tz; 1575 struct thermal_cooling_device *pos = NULL; 1576 1577 if (!cdev) 1578 return; 1579 1580 mutex_lock(&thermal_list_lock); 1581 list_for_each_entry(pos, &thermal_cdev_list, node) 1582 if (pos == cdev) 1583 break; 1584 if (pos != cdev) { 1585 /* thermal cooling device not found */ 1586 mutex_unlock(&thermal_list_lock); 1587 return; 1588 } 1589 list_del(&cdev->node); 1590 1591 /* Unbind all thermal zones associated with 'this' cdev */ 1592 list_for_each_entry(tz, &thermal_tz_list, node) { 1593 if (tz->ops->unbind) { 1594 tz->ops->unbind(tz, cdev); 1595 continue; 1596 } 1597 1598 if (!tz->tzp || !tz->tzp->tbp) 1599 continue; 1600 1601 tzp = tz->tzp; 1602 for (i = 0; i < tzp->num_tbps; i++) { 1603 if (tzp->tbp[i].cdev == cdev) { 1604 __unbind(tz, tzp->tbp[i].trip_mask, cdev); 1605 tzp->tbp[i].cdev = NULL; 1606 } 1607 } 1608 } 1609 1610 mutex_unlock(&thermal_list_lock); 1611 1612 if (cdev->type[0]) 1613 device_remove_file(&cdev->device, &dev_attr_cdev_type); 1614 device_remove_file(&cdev->device, &dev_attr_max_state); 1615 device_remove_file(&cdev->device, &dev_attr_cur_state); 1616 1617 release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id); 1618 device_unregister(&cdev->device); 1619 return; 1620 } 1621 EXPORT_SYMBOL_GPL(thermal_cooling_device_unregister); 1622 1623 void thermal_cdev_update(struct thermal_cooling_device *cdev) 1624 { 1625 struct thermal_instance *instance; 1626 unsigned long target = 0; 1627 1628 mutex_lock(&cdev->lock); 1629 /* cooling device is updated*/ 1630 if (cdev->updated) { 1631 mutex_unlock(&cdev->lock); 1632 return; 1633 } 1634 1635 /* Make sure cdev enters the deepest cooling state */ 1636 list_for_each_entry(instance, &cdev->thermal_instances, cdev_node) { 1637 dev_dbg(&cdev->device, "zone%d->target=%lu\n", 1638 instance->tz->id, instance->target); 1639 if (instance->target == THERMAL_NO_TARGET) 1640 continue; 1641 if (instance->target > target) 1642 target = instance->target; 1643 } 1644 cdev->ops->set_cur_state(cdev, target); 1645 cdev->updated = true; 1646 mutex_unlock(&cdev->lock); 1647 trace_cdev_update(cdev, target); 1648 dev_dbg(&cdev->device, "set to state %lu\n", target); 1649 } 1650 EXPORT_SYMBOL(thermal_cdev_update); 1651 1652 /** 1653 * thermal_notify_framework - Sensor drivers use this API to notify framework 1654 * @tz: thermal zone device 1655 * @trip: indicates which trip point has been crossed 1656 * 1657 * This function handles the trip events from sensor drivers. It starts 1658 * throttling the cooling devices according to the policy configured. 1659 * For CRITICAL and HOT trip points, this notifies the respective drivers, 1660 * and does actual throttling for other trip points i.e ACTIVE and PASSIVE. 1661 * The throttling policy is based on the configured platform data; if no 1662 * platform data is provided, this uses the step_wise throttling policy. 1663 */ 1664 void thermal_notify_framework(struct thermal_zone_device *tz, int trip) 1665 { 1666 handle_thermal_trip(tz, trip); 1667 } 1668 EXPORT_SYMBOL_GPL(thermal_notify_framework); 1669 1670 /** 1671 * create_trip_attrs() - create attributes for trip points 1672 * @tz: the thermal zone device 1673 * @mask: Writeable trip point bitmap. 1674 * 1675 * helper function to instantiate sysfs entries for every trip 1676 * point and its properties of a struct thermal_zone_device. 1677 * 1678 * Return: 0 on success, the proper error value otherwise. 1679 */ 1680 static int create_trip_attrs(struct thermal_zone_device *tz, int mask) 1681 { 1682 int indx; 1683 int size = sizeof(struct thermal_attr) * tz->trips; 1684 1685 tz->trip_type_attrs = kzalloc(size, GFP_KERNEL); 1686 if (!tz->trip_type_attrs) 1687 return -ENOMEM; 1688 1689 tz->trip_temp_attrs = kzalloc(size, GFP_KERNEL); 1690 if (!tz->trip_temp_attrs) { 1691 kfree(tz->trip_type_attrs); 1692 return -ENOMEM; 1693 } 1694 1695 if (tz->ops->get_trip_hyst) { 1696 tz->trip_hyst_attrs = kzalloc(size, GFP_KERNEL); 1697 if (!tz->trip_hyst_attrs) { 1698 kfree(tz->trip_type_attrs); 1699 kfree(tz->trip_temp_attrs); 1700 return -ENOMEM; 1701 } 1702 } 1703 1704 1705 for (indx = 0; indx < tz->trips; indx++) { 1706 /* create trip type attribute */ 1707 snprintf(tz->trip_type_attrs[indx].name, THERMAL_NAME_LENGTH, 1708 "trip_point_%d_type", indx); 1709 1710 sysfs_attr_init(&tz->trip_type_attrs[indx].attr.attr); 1711 tz->trip_type_attrs[indx].attr.attr.name = 1712 tz->trip_type_attrs[indx].name; 1713 tz->trip_type_attrs[indx].attr.attr.mode = S_IRUGO; 1714 tz->trip_type_attrs[indx].attr.show = trip_point_type_show; 1715 1716 device_create_file(&tz->device, 1717 &tz->trip_type_attrs[indx].attr); 1718 1719 /* create trip temp attribute */ 1720 snprintf(tz->trip_temp_attrs[indx].name, THERMAL_NAME_LENGTH, 1721 "trip_point_%d_temp", indx); 1722 1723 sysfs_attr_init(&tz->trip_temp_attrs[indx].attr.attr); 1724 tz->trip_temp_attrs[indx].attr.attr.name = 1725 tz->trip_temp_attrs[indx].name; 1726 tz->trip_temp_attrs[indx].attr.attr.mode = S_IRUGO; 1727 tz->trip_temp_attrs[indx].attr.show = trip_point_temp_show; 1728 if (IS_ENABLED(CONFIG_THERMAL_WRITABLE_TRIPS) && 1729 mask & (1 << indx)) { 1730 tz->trip_temp_attrs[indx].attr.attr.mode |= S_IWUSR; 1731 tz->trip_temp_attrs[indx].attr.store = 1732 trip_point_temp_store; 1733 } 1734 1735 device_create_file(&tz->device, 1736 &tz->trip_temp_attrs[indx].attr); 1737 1738 /* create Optional trip hyst attribute */ 1739 if (!tz->ops->get_trip_hyst) 1740 continue; 1741 snprintf(tz->trip_hyst_attrs[indx].name, THERMAL_NAME_LENGTH, 1742 "trip_point_%d_hyst", indx); 1743 1744 sysfs_attr_init(&tz->trip_hyst_attrs[indx].attr.attr); 1745 tz->trip_hyst_attrs[indx].attr.attr.name = 1746 tz->trip_hyst_attrs[indx].name; 1747 tz->trip_hyst_attrs[indx].attr.attr.mode = S_IRUGO; 1748 tz->trip_hyst_attrs[indx].attr.show = trip_point_hyst_show; 1749 if (tz->ops->set_trip_hyst) { 1750 tz->trip_hyst_attrs[indx].attr.attr.mode |= S_IWUSR; 1751 tz->trip_hyst_attrs[indx].attr.store = 1752 trip_point_hyst_store; 1753 } 1754 1755 device_create_file(&tz->device, 1756 &tz->trip_hyst_attrs[indx].attr); 1757 } 1758 return 0; 1759 } 1760 1761 static void remove_trip_attrs(struct thermal_zone_device *tz) 1762 { 1763 int indx; 1764 1765 for (indx = 0; indx < tz->trips; indx++) { 1766 device_remove_file(&tz->device, 1767 &tz->trip_type_attrs[indx].attr); 1768 device_remove_file(&tz->device, 1769 &tz->trip_temp_attrs[indx].attr); 1770 if (tz->ops->get_trip_hyst) 1771 device_remove_file(&tz->device, 1772 &tz->trip_hyst_attrs[indx].attr); 1773 } 1774 kfree(tz->trip_type_attrs); 1775 kfree(tz->trip_temp_attrs); 1776 kfree(tz->trip_hyst_attrs); 1777 } 1778 1779 /** 1780 * thermal_zone_device_register() - register a new thermal zone device 1781 * @type: the thermal zone device type 1782 * @trips: the number of trip points the thermal zone support 1783 * @mask: a bit string indicating the writeablility of trip points 1784 * @devdata: private device data 1785 * @ops: standard thermal zone device callbacks 1786 * @tzp: thermal zone platform parameters 1787 * @passive_delay: number of milliseconds to wait between polls when 1788 * performing passive cooling 1789 * @polling_delay: number of milliseconds to wait between polls when checking 1790 * whether trip points have been crossed (0 for interrupt 1791 * driven systems) 1792 * 1793 * This interface function adds a new thermal zone device (sensor) to 1794 * /sys/class/thermal folder as thermal_zone[0-*]. It tries to bind all the 1795 * thermal cooling devices registered at the same time. 1796 * thermal_zone_device_unregister() must be called when the device is no 1797 * longer needed. The passive cooling depends on the .get_trend() return value. 1798 * 1799 * Return: a pointer to the created struct thermal_zone_device or an 1800 * in case of error, an ERR_PTR. Caller must check return value with 1801 * IS_ERR*() helpers. 1802 */ 1803 struct thermal_zone_device *thermal_zone_device_register(const char *type, 1804 int trips, int mask, void *devdata, 1805 struct thermal_zone_device_ops *ops, 1806 struct thermal_zone_params *tzp, 1807 int passive_delay, int polling_delay) 1808 { 1809 struct thermal_zone_device *tz; 1810 enum thermal_trip_type trip_type; 1811 int trip_temp; 1812 int result; 1813 int count; 1814 int passive = 0; 1815 struct thermal_governor *governor; 1816 1817 if (type && strlen(type) >= THERMAL_NAME_LENGTH) 1818 return ERR_PTR(-EINVAL); 1819 1820 if (trips > THERMAL_MAX_TRIPS || trips < 0 || mask >> trips) 1821 return ERR_PTR(-EINVAL); 1822 1823 if (!ops) 1824 return ERR_PTR(-EINVAL); 1825 1826 if (trips > 0 && (!ops->get_trip_type || !ops->get_trip_temp)) 1827 return ERR_PTR(-EINVAL); 1828 1829 tz = kzalloc(sizeof(struct thermal_zone_device), GFP_KERNEL); 1830 if (!tz) 1831 return ERR_PTR(-ENOMEM); 1832 1833 INIT_LIST_HEAD(&tz->thermal_instances); 1834 idr_init(&tz->idr); 1835 mutex_init(&tz->lock); 1836 result = get_idr(&thermal_tz_idr, &thermal_idr_lock, &tz->id); 1837 if (result) { 1838 kfree(tz); 1839 return ERR_PTR(result); 1840 } 1841 1842 strlcpy(tz->type, type ? : "", sizeof(tz->type)); 1843 tz->ops = ops; 1844 tz->tzp = tzp; 1845 tz->device.class = &thermal_class; 1846 tz->devdata = devdata; 1847 tz->trips = trips; 1848 tz->passive_delay = passive_delay; 1849 tz->polling_delay = polling_delay; 1850 /* A new thermal zone needs to be updated anyway. */ 1851 atomic_set(&tz->need_update, 1); 1852 1853 dev_set_name(&tz->device, "thermal_zone%d", tz->id); 1854 result = device_register(&tz->device); 1855 if (result) { 1856 release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id); 1857 kfree(tz); 1858 return ERR_PTR(result); 1859 } 1860 1861 /* sys I/F */ 1862 if (type) { 1863 result = device_create_file(&tz->device, &dev_attr_type); 1864 if (result) 1865 goto unregister; 1866 } 1867 1868 result = device_create_file(&tz->device, &dev_attr_temp); 1869 if (result) 1870 goto unregister; 1871 1872 if (ops->get_mode) { 1873 result = device_create_file(&tz->device, &dev_attr_mode); 1874 if (result) 1875 goto unregister; 1876 } 1877 1878 result = create_trip_attrs(tz, mask); 1879 if (result) 1880 goto unregister; 1881 1882 for (count = 0; count < trips; count++) { 1883 if (tz->ops->get_trip_type(tz, count, &trip_type)) 1884 set_bit(count, &tz->trips_disabled); 1885 if (trip_type == THERMAL_TRIP_PASSIVE) 1886 passive = 1; 1887 if (tz->ops->get_trip_temp(tz, count, &trip_temp)) 1888 set_bit(count, &tz->trips_disabled); 1889 /* Check for bogus trip points */ 1890 if (trip_temp == 0) 1891 set_bit(count, &tz->trips_disabled); 1892 } 1893 1894 if (!passive) { 1895 result = device_create_file(&tz->device, &dev_attr_passive); 1896 if (result) 1897 goto unregister; 1898 } 1899 1900 if (IS_ENABLED(CONFIG_THERMAL_EMULATION)) { 1901 result = device_create_file(&tz->device, &dev_attr_emul_temp); 1902 if (result) 1903 goto unregister; 1904 } 1905 1906 /* Create policy attribute */ 1907 result = device_create_file(&tz->device, &dev_attr_policy); 1908 if (result) 1909 goto unregister; 1910 1911 /* Add thermal zone params */ 1912 result = create_tzp_attrs(&tz->device); 1913 if (result) 1914 goto unregister; 1915 1916 /* Create available_policies attribute */ 1917 result = device_create_file(&tz->device, &dev_attr_available_policies); 1918 if (result) 1919 goto unregister; 1920 1921 /* Update 'this' zone's governor information */ 1922 mutex_lock(&thermal_governor_lock); 1923 1924 if (tz->tzp) 1925 governor = __find_governor(tz->tzp->governor_name); 1926 else 1927 governor = def_governor; 1928 1929 result = thermal_set_governor(tz, governor); 1930 if (result) { 1931 mutex_unlock(&thermal_governor_lock); 1932 goto unregister; 1933 } 1934 1935 mutex_unlock(&thermal_governor_lock); 1936 1937 if (!tz->tzp || !tz->tzp->no_hwmon) { 1938 result = thermal_add_hwmon_sysfs(tz); 1939 if (result) 1940 goto unregister; 1941 } 1942 1943 mutex_lock(&thermal_list_lock); 1944 list_add_tail(&tz->node, &thermal_tz_list); 1945 mutex_unlock(&thermal_list_lock); 1946 1947 /* Bind cooling devices for this zone */ 1948 bind_tz(tz); 1949 1950 INIT_DELAYED_WORK(&(tz->poll_queue), thermal_zone_device_check); 1951 1952 thermal_zone_device_reset(tz); 1953 /* Update the new thermal zone and mark it as already updated. */ 1954 if (atomic_cmpxchg(&tz->need_update, 1, 0)) 1955 thermal_zone_device_update(tz); 1956 1957 return tz; 1958 1959 unregister: 1960 release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id); 1961 device_unregister(&tz->device); 1962 return ERR_PTR(result); 1963 } 1964 EXPORT_SYMBOL_GPL(thermal_zone_device_register); 1965 1966 /** 1967 * thermal_device_unregister - removes the registered thermal zone device 1968 * @tz: the thermal zone device to remove 1969 */ 1970 void thermal_zone_device_unregister(struct thermal_zone_device *tz) 1971 { 1972 int i; 1973 const struct thermal_zone_params *tzp; 1974 struct thermal_cooling_device *cdev; 1975 struct thermal_zone_device *pos = NULL; 1976 1977 if (!tz) 1978 return; 1979 1980 tzp = tz->tzp; 1981 1982 mutex_lock(&thermal_list_lock); 1983 list_for_each_entry(pos, &thermal_tz_list, node) 1984 if (pos == tz) 1985 break; 1986 if (pos != tz) { 1987 /* thermal zone device not found */ 1988 mutex_unlock(&thermal_list_lock); 1989 return; 1990 } 1991 list_del(&tz->node); 1992 1993 /* Unbind all cdevs associated with 'this' thermal zone */ 1994 list_for_each_entry(cdev, &thermal_cdev_list, node) { 1995 if (tz->ops->unbind) { 1996 tz->ops->unbind(tz, cdev); 1997 continue; 1998 } 1999 2000 if (!tzp || !tzp->tbp) 2001 break; 2002 2003 for (i = 0; i < tzp->num_tbps; i++) { 2004 if (tzp->tbp[i].cdev == cdev) { 2005 __unbind(tz, tzp->tbp[i].trip_mask, cdev); 2006 tzp->tbp[i].cdev = NULL; 2007 } 2008 } 2009 } 2010 2011 mutex_unlock(&thermal_list_lock); 2012 2013 thermal_zone_device_set_polling(tz, 0); 2014 2015 if (tz->type[0]) 2016 device_remove_file(&tz->device, &dev_attr_type); 2017 device_remove_file(&tz->device, &dev_attr_temp); 2018 if (tz->ops->get_mode) 2019 device_remove_file(&tz->device, &dev_attr_mode); 2020 device_remove_file(&tz->device, &dev_attr_policy); 2021 device_remove_file(&tz->device, &dev_attr_available_policies); 2022 remove_trip_attrs(tz); 2023 thermal_set_governor(tz, NULL); 2024 2025 thermal_remove_hwmon_sysfs(tz); 2026 release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id); 2027 idr_destroy(&tz->idr); 2028 mutex_destroy(&tz->lock); 2029 device_unregister(&tz->device); 2030 return; 2031 } 2032 EXPORT_SYMBOL_GPL(thermal_zone_device_unregister); 2033 2034 /** 2035 * thermal_zone_get_zone_by_name() - search for a zone and returns its ref 2036 * @name: thermal zone name to fetch the temperature 2037 * 2038 * When only one zone is found with the passed name, returns a reference to it. 2039 * 2040 * Return: On success returns a reference to an unique thermal zone with 2041 * matching name equals to @name, an ERR_PTR otherwise (-EINVAL for invalid 2042 * paramenters, -ENODEV for not found and -EEXIST for multiple matches). 2043 */ 2044 struct thermal_zone_device *thermal_zone_get_zone_by_name(const char *name) 2045 { 2046 struct thermal_zone_device *pos = NULL, *ref = ERR_PTR(-EINVAL); 2047 unsigned int found = 0; 2048 2049 if (!name) 2050 goto exit; 2051 2052 mutex_lock(&thermal_list_lock); 2053 list_for_each_entry(pos, &thermal_tz_list, node) 2054 if (!strncasecmp(name, pos->type, THERMAL_NAME_LENGTH)) { 2055 found++; 2056 ref = pos; 2057 } 2058 mutex_unlock(&thermal_list_lock); 2059 2060 /* nothing has been found, thus an error code for it */ 2061 if (found == 0) 2062 ref = ERR_PTR(-ENODEV); 2063 else if (found > 1) 2064 /* Success only when an unique zone is found */ 2065 ref = ERR_PTR(-EEXIST); 2066 2067 exit: 2068 return ref; 2069 } 2070 EXPORT_SYMBOL_GPL(thermal_zone_get_zone_by_name); 2071 2072 #ifdef CONFIG_NET 2073 static const struct genl_multicast_group thermal_event_mcgrps[] = { 2074 { .name = THERMAL_GENL_MCAST_GROUP_NAME, }, 2075 }; 2076 2077 static struct genl_family thermal_event_genl_family = { 2078 .id = GENL_ID_GENERATE, 2079 .name = THERMAL_GENL_FAMILY_NAME, 2080 .version = THERMAL_GENL_VERSION, 2081 .maxattr = THERMAL_GENL_ATTR_MAX, 2082 .mcgrps = thermal_event_mcgrps, 2083 .n_mcgrps = ARRAY_SIZE(thermal_event_mcgrps), 2084 }; 2085 2086 int thermal_generate_netlink_event(struct thermal_zone_device *tz, 2087 enum events event) 2088 { 2089 struct sk_buff *skb; 2090 struct nlattr *attr; 2091 struct thermal_genl_event *thermal_event; 2092 void *msg_header; 2093 int size; 2094 int result; 2095 static unsigned int thermal_event_seqnum; 2096 2097 if (!tz) 2098 return -EINVAL; 2099 2100 /* allocate memory */ 2101 size = nla_total_size(sizeof(struct thermal_genl_event)) + 2102 nla_total_size(0); 2103 2104 skb = genlmsg_new(size, GFP_ATOMIC); 2105 if (!skb) 2106 return -ENOMEM; 2107 2108 /* add the genetlink message header */ 2109 msg_header = genlmsg_put(skb, 0, thermal_event_seqnum++, 2110 &thermal_event_genl_family, 0, 2111 THERMAL_GENL_CMD_EVENT); 2112 if (!msg_header) { 2113 nlmsg_free(skb); 2114 return -ENOMEM; 2115 } 2116 2117 /* fill the data */ 2118 attr = nla_reserve(skb, THERMAL_GENL_ATTR_EVENT, 2119 sizeof(struct thermal_genl_event)); 2120 2121 if (!attr) { 2122 nlmsg_free(skb); 2123 return -EINVAL; 2124 } 2125 2126 thermal_event = nla_data(attr); 2127 if (!thermal_event) { 2128 nlmsg_free(skb); 2129 return -EINVAL; 2130 } 2131 2132 memset(thermal_event, 0, sizeof(struct thermal_genl_event)); 2133 2134 thermal_event->orig = tz->id; 2135 thermal_event->event = event; 2136 2137 /* send multicast genetlink message */ 2138 genlmsg_end(skb, msg_header); 2139 2140 result = genlmsg_multicast(&thermal_event_genl_family, skb, 0, 2141 0, GFP_ATOMIC); 2142 if (result) 2143 dev_err(&tz->device, "Failed to send netlink event:%d", result); 2144 2145 return result; 2146 } 2147 EXPORT_SYMBOL_GPL(thermal_generate_netlink_event); 2148 2149 static int genetlink_init(void) 2150 { 2151 return genl_register_family(&thermal_event_genl_family); 2152 } 2153 2154 static void genetlink_exit(void) 2155 { 2156 genl_unregister_family(&thermal_event_genl_family); 2157 } 2158 #else /* !CONFIG_NET */ 2159 static inline int genetlink_init(void) { return 0; } 2160 static inline void genetlink_exit(void) {} 2161 #endif /* !CONFIG_NET */ 2162 2163 static int __init thermal_register_governors(void) 2164 { 2165 int result; 2166 2167 result = thermal_gov_step_wise_register(); 2168 if (result) 2169 return result; 2170 2171 result = thermal_gov_fair_share_register(); 2172 if (result) 2173 return result; 2174 2175 result = thermal_gov_bang_bang_register(); 2176 if (result) 2177 return result; 2178 2179 result = thermal_gov_user_space_register(); 2180 if (result) 2181 return result; 2182 2183 return thermal_gov_power_allocator_register(); 2184 } 2185 2186 static void thermal_unregister_governors(void) 2187 { 2188 thermal_gov_step_wise_unregister(); 2189 thermal_gov_fair_share_unregister(); 2190 thermal_gov_bang_bang_unregister(); 2191 thermal_gov_user_space_unregister(); 2192 thermal_gov_power_allocator_unregister(); 2193 } 2194 2195 static int thermal_pm_notify(struct notifier_block *nb, 2196 unsigned long mode, void *_unused) 2197 { 2198 struct thermal_zone_device *tz; 2199 2200 switch (mode) { 2201 case PM_HIBERNATION_PREPARE: 2202 case PM_RESTORE_PREPARE: 2203 case PM_SUSPEND_PREPARE: 2204 atomic_set(&in_suspend, 1); 2205 break; 2206 case PM_POST_HIBERNATION: 2207 case PM_POST_RESTORE: 2208 case PM_POST_SUSPEND: 2209 atomic_set(&in_suspend, 0); 2210 list_for_each_entry(tz, &thermal_tz_list, node) { 2211 thermal_zone_device_reset(tz); 2212 thermal_zone_device_update(tz); 2213 } 2214 break; 2215 default: 2216 break; 2217 } 2218 return 0; 2219 } 2220 2221 static struct notifier_block thermal_pm_nb = { 2222 .notifier_call = thermal_pm_notify, 2223 }; 2224 2225 static int __init thermal_init(void) 2226 { 2227 int result; 2228 2229 result = thermal_register_governors(); 2230 if (result) 2231 goto error; 2232 2233 result = class_register(&thermal_class); 2234 if (result) 2235 goto unregister_governors; 2236 2237 result = genetlink_init(); 2238 if (result) 2239 goto unregister_class; 2240 2241 result = of_parse_thermal_zones(); 2242 if (result) 2243 goto exit_netlink; 2244 2245 result = register_pm_notifier(&thermal_pm_nb); 2246 if (result) 2247 pr_warn("Thermal: Can not register suspend notifier, return %d\n", 2248 result); 2249 2250 return 0; 2251 2252 exit_netlink: 2253 genetlink_exit(); 2254 unregister_class: 2255 class_unregister(&thermal_class); 2256 unregister_governors: 2257 thermal_unregister_governors(); 2258 error: 2259 idr_destroy(&thermal_tz_idr); 2260 idr_destroy(&thermal_cdev_idr); 2261 mutex_destroy(&thermal_idr_lock); 2262 mutex_destroy(&thermal_list_lock); 2263 mutex_destroy(&thermal_governor_lock); 2264 return result; 2265 } 2266 2267 static void __exit thermal_exit(void) 2268 { 2269 unregister_pm_notifier(&thermal_pm_nb); 2270 of_thermal_destroy_zones(); 2271 genetlink_exit(); 2272 class_unregister(&thermal_class); 2273 thermal_unregister_governors(); 2274 idr_destroy(&thermal_tz_idr); 2275 idr_destroy(&thermal_cdev_idr); 2276 mutex_destroy(&thermal_idr_lock); 2277 mutex_destroy(&thermal_list_lock); 2278 mutex_destroy(&thermal_governor_lock); 2279 } 2280 2281 fs_initcall(thermal_init); 2282 module_exit(thermal_exit); 2283