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