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 48MODULE_AUTHOR("Zhang Rui"); 49MODULE_DESCRIPTION("Generic thermal management sysfs support"); 50MODULE_LICENSE("GPL v2"); 51 52static DEFINE_IDR(thermal_tz_idr); 53static DEFINE_IDR(thermal_cdev_idr); 54static DEFINE_MUTEX(thermal_idr_lock); 55 56static LIST_HEAD(thermal_tz_list); 57static LIST_HEAD(thermal_cdev_list); 58static LIST_HEAD(thermal_governor_list); 59 60static DEFINE_MUTEX(thermal_list_lock); 61static DEFINE_MUTEX(thermal_governor_lock); 62 63static atomic_t in_suspend; 64 65static struct thermal_governor *def_governor; 66 67static 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 */ 89static 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 */ 111static 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 133int 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 182void 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); 204exit: 205 mutex_unlock(&thermal_governor_lock); 206 return; 207} 208 209static 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 224static 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 233int 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} 249EXPORT_SYMBOL(get_tz_trend); 250 251struct 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} 272EXPORT_SYMBOL(get_thermal_instance); 273 274static 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 281static 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 307static 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 317static 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 355static 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 } 391exit: 392 mutex_unlock(&thermal_list_lock); 393} 394 395static 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 408static 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 422static 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 429static 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 453static 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 */ 484int 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); 518exit: 519 return ret; 520} 521EXPORT_SYMBOL_GPL(thermal_zone_get_temp); 522 523static 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 550static 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 560void 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} 575EXPORT_SYMBOL_GPL(thermal_zone_device_update); 576 577static 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 590static ssize_t 591type_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 598static ssize_t 599temp_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 612static ssize_t 613mode_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 630static ssize_t 631mode_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 653static ssize_t 654trip_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 685static ssize_t 686trip_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 unsigned long 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 (kstrtoul(buf, 10, &temperature)) 700 return -EINVAL; 701 702 ret = tz->ops->set_trip_temp(tz, trip, temperature); 703 704 return ret ? ret : count; 705} 706 707static ssize_t 708trip_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 729static ssize_t 730trip_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 756static ssize_t 757trip_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 775static ssize_t 776passive_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 826static ssize_t 827passive_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 835static ssize_t 836policy_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 857exit: 858 mutex_unlock(&tz->lock); 859 mutex_unlock(&thermal_governor_lock); 860 return ret; 861} 862 863static ssize_t 864policy_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 871static ssize_t 872available_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 892static ssize_t 893emul_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} 916static DEVICE_ATTR(emul_temp, S_IWUSR, NULL, emul_temp_store); 917 918static ssize_t 919sustainable_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 930static ssize_t 931sustainable_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} 947static 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 982create_s32_tzp_attr(k_po); 983create_s32_tzp_attr(k_pu); 984create_s32_tzp_attr(k_i); 985create_s32_tzp_attr(k_d); 986create_s32_tzp_attr(integral_cutoff); 987create_s32_tzp_attr(slope); 988create_s32_tzp_attr(offset); 989#undef create_s32_tzp_attr 990 991static 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 1002static 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 */ 1030int 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 */ 1051int 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 */ 1078int 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 1098static DEVICE_ATTR(type, 0444, type_show, NULL); 1099static DEVICE_ATTR(temp, 0444, temp_show, NULL); 1100static DEVICE_ATTR(mode, 0644, mode_show, mode_store); 1101static DEVICE_ATTR(passive, S_IRUGO | S_IWUSR, passive_show, passive_store); 1102static DEVICE_ATTR(policy, S_IRUGO | S_IWUSR, policy_show, policy_store); 1103static 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 1109static ssize_t 1110thermal_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 1118static ssize_t 1119thermal_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 1132static ssize_t 1133thermal_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 1146static ssize_t 1147thermal_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 1167static struct device_attribute dev_attr_cdev_type = 1168__ATTR(type, 0444, thermal_cooling_device_type_show, NULL); 1169static DEVICE_ATTR(max_state, 0444, 1170 thermal_cooling_device_max_state_show, NULL); 1171static DEVICE_ATTR(cur_state, 0644, 1172 thermal_cooling_device_cur_state_show, 1173 thermal_cooling_device_cur_state_store); 1174 1175static ssize_t 1176thermal_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 1190static 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 1197static const struct attribute_group cooling_device_attr_group = { 1198 .attrs = cooling_device_attrs, 1199}; 1200 1201static const struct attribute_group *cooling_device_attr_groups[] = { 1202 &cooling_device_attr_group, 1203 NULL, 1204}; 1205 1206static ssize_t 1207thermal_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 1217static ssize_t 1218thermal_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 */ 1258int 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); 1357remove_trip_file: 1358 device_remove_file(&tz->device, &dev->attr); 1359remove_symbol_link: 1360 sysfs_remove_link(&tz->device.kobj, dev->name); 1361release_idr: 1362 release_idr(&tz->idr, &tz->lock, dev->id); 1363free_mem: 1364 kfree(dev); 1365 return result; 1366} 1367EXPORT_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 */ 1383int 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 1405unbind: 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} 1413EXPORT_SYMBOL_GPL(thermal_zone_unbind_cooling_device); 1414 1415static 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 1431static 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 */ 1452static 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 */ 1525struct thermal_cooling_device * 1526thermal_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} 1531EXPORT_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 */ 1548struct thermal_cooling_device * 1549thermal_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} 1555EXPORT_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 */ 1564void 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} 1615EXPORT_SYMBOL_GPL(thermal_cooling_device_unregister); 1616 1617void 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} 1642EXPORT_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 */ 1656void thermal_notify_framework(struct thermal_zone_device *tz, int trip) 1657{ 1658 handle_thermal_trip(tz, trip); 1659} 1660EXPORT_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 */ 1672static 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 1753static 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 */ 1795struct 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 trip_temp; 1804 int result; 1805 int count; 1806 int passive = 0; 1807 struct thermal_governor *governor; 1808 1809 if (type && strlen(type) >= THERMAL_NAME_LENGTH) 1810 return ERR_PTR(-EINVAL); 1811 1812 if (trips > THERMAL_MAX_TRIPS || trips < 0 || mask >> trips) 1813 return ERR_PTR(-EINVAL); 1814 1815 if (!ops) 1816 return ERR_PTR(-EINVAL); 1817 1818 if (trips > 0 && (!ops->get_trip_type || !ops->get_trip_temp)) 1819 return ERR_PTR(-EINVAL); 1820 1821 tz = kzalloc(sizeof(struct thermal_zone_device), GFP_KERNEL); 1822 if (!tz) 1823 return ERR_PTR(-ENOMEM); 1824 1825 INIT_LIST_HEAD(&tz->thermal_instances); 1826 idr_init(&tz->idr); 1827 mutex_init(&tz->lock); 1828 result = get_idr(&thermal_tz_idr, &thermal_idr_lock, &tz->id); 1829 if (result) { 1830 kfree(tz); 1831 return ERR_PTR(result); 1832 } 1833 1834 strlcpy(tz->type, type ? : "", sizeof(tz->type)); 1835 tz->ops = ops; 1836 tz->tzp = tzp; 1837 tz->device.class = &thermal_class; 1838 tz->devdata = devdata; 1839 tz->trips = trips; 1840 tz->passive_delay = passive_delay; 1841 tz->polling_delay = polling_delay; 1842 /* A new thermal zone needs to be updated anyway. */ 1843 atomic_set(&tz->need_update, 1); 1844 1845 dev_set_name(&tz->device, "thermal_zone%d", tz->id); 1846 result = device_register(&tz->device); 1847 if (result) { 1848 release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id); 1849 kfree(tz); 1850 return ERR_PTR(result); 1851 } 1852 1853 /* sys I/F */ 1854 if (type) { 1855 result = device_create_file(&tz->device, &dev_attr_type); 1856 if (result) 1857 goto unregister; 1858 } 1859 1860 result = device_create_file(&tz->device, &dev_attr_temp); 1861 if (result) 1862 goto unregister; 1863 1864 if (ops->get_mode) { 1865 result = device_create_file(&tz->device, &dev_attr_mode); 1866 if (result) 1867 goto unregister; 1868 } 1869 1870 result = create_trip_attrs(tz, mask); 1871 if (result) 1872 goto unregister; 1873 1874 for (count = 0; count < trips; count++) { 1875 if (tz->ops->get_trip_type(tz, count, &trip_type)) 1876 set_bit(count, &tz->trips_disabled); 1877 if (trip_type == THERMAL_TRIP_PASSIVE) 1878 passive = 1; 1879 if (tz->ops->get_trip_temp(tz, count, &trip_temp)) 1880 set_bit(count, &tz->trips_disabled); 1881 /* Check for bogus trip points */ 1882 if (trip_temp == 0) 1883 set_bit(count, &tz->trips_disabled); 1884 } 1885 1886 if (!passive) { 1887 result = device_create_file(&tz->device, &dev_attr_passive); 1888 if (result) 1889 goto unregister; 1890 } 1891 1892 if (IS_ENABLED(CONFIG_THERMAL_EMULATION)) { 1893 result = device_create_file(&tz->device, &dev_attr_emul_temp); 1894 if (result) 1895 goto unregister; 1896 } 1897 1898 /* Create policy attribute */ 1899 result = device_create_file(&tz->device, &dev_attr_policy); 1900 if (result) 1901 goto unregister; 1902 1903 /* Add thermal zone params */ 1904 result = create_tzp_attrs(&tz->device); 1905 if (result) 1906 goto unregister; 1907 1908 /* Create available_policies attribute */ 1909 result = device_create_file(&tz->device, &dev_attr_available_policies); 1910 if (result) 1911 goto unregister; 1912 1913 /* Update 'this' zone's governor information */ 1914 mutex_lock(&thermal_governor_lock); 1915 1916 if (tz->tzp) 1917 governor = __find_governor(tz->tzp->governor_name); 1918 else 1919 governor = def_governor; 1920 1921 result = thermal_set_governor(tz, governor); 1922 if (result) { 1923 mutex_unlock(&thermal_governor_lock); 1924 goto unregister; 1925 } 1926 1927 mutex_unlock(&thermal_governor_lock); 1928 1929 if (!tz->tzp || !tz->tzp->no_hwmon) { 1930 result = thermal_add_hwmon_sysfs(tz); 1931 if (result) 1932 goto unregister; 1933 } 1934 1935 mutex_lock(&thermal_list_lock); 1936 list_add_tail(&tz->node, &thermal_tz_list); 1937 mutex_unlock(&thermal_list_lock); 1938 1939 /* Bind cooling devices for this zone */ 1940 bind_tz(tz); 1941 1942 INIT_DELAYED_WORK(&(tz->poll_queue), thermal_zone_device_check); 1943 1944 thermal_zone_device_reset(tz); 1945 /* Update the new thermal zone and mark it as already updated. */ 1946 if (atomic_cmpxchg(&tz->need_update, 1, 0)) 1947 thermal_zone_device_update(tz); 1948 1949 return tz; 1950 1951unregister: 1952 release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id); 1953 device_unregister(&tz->device); 1954 return ERR_PTR(result); 1955} 1956EXPORT_SYMBOL_GPL(thermal_zone_device_register); 1957 1958/** 1959 * thermal_device_unregister - removes the registered thermal zone device 1960 * @tz: the thermal zone device to remove 1961 */ 1962void thermal_zone_device_unregister(struct thermal_zone_device *tz) 1963{ 1964 int i; 1965 const struct thermal_zone_params *tzp; 1966 struct thermal_cooling_device *cdev; 1967 struct thermal_zone_device *pos = NULL; 1968 1969 if (!tz) 1970 return; 1971 1972 tzp = tz->tzp; 1973 1974 mutex_lock(&thermal_list_lock); 1975 list_for_each_entry(pos, &thermal_tz_list, node) 1976 if (pos == tz) 1977 break; 1978 if (pos != tz) { 1979 /* thermal zone device not found */ 1980 mutex_unlock(&thermal_list_lock); 1981 return; 1982 } 1983 list_del(&tz->node); 1984 1985 /* Unbind all cdevs associated with 'this' thermal zone */ 1986 list_for_each_entry(cdev, &thermal_cdev_list, node) { 1987 if (tz->ops->unbind) { 1988 tz->ops->unbind(tz, cdev); 1989 continue; 1990 } 1991 1992 if (!tzp || !tzp->tbp) 1993 break; 1994 1995 for (i = 0; i < tzp->num_tbps; i++) { 1996 if (tzp->tbp[i].cdev == cdev) { 1997 __unbind(tz, tzp->tbp[i].trip_mask, cdev); 1998 tzp->tbp[i].cdev = NULL; 1999 } 2000 } 2001 } 2002 2003 mutex_unlock(&thermal_list_lock); 2004 2005 thermal_zone_device_set_polling(tz, 0); 2006 2007 if (tz->type[0]) 2008 device_remove_file(&tz->device, &dev_attr_type); 2009 device_remove_file(&tz->device, &dev_attr_temp); 2010 if (tz->ops->get_mode) 2011 device_remove_file(&tz->device, &dev_attr_mode); 2012 device_remove_file(&tz->device, &dev_attr_policy); 2013 device_remove_file(&tz->device, &dev_attr_available_policies); 2014 remove_trip_attrs(tz); 2015 thermal_set_governor(tz, NULL); 2016 2017 thermal_remove_hwmon_sysfs(tz); 2018 release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id); 2019 idr_destroy(&tz->idr); 2020 mutex_destroy(&tz->lock); 2021 device_unregister(&tz->device); 2022 return; 2023} 2024EXPORT_SYMBOL_GPL(thermal_zone_device_unregister); 2025 2026/** 2027 * thermal_zone_get_zone_by_name() - search for a zone and returns its ref 2028 * @name: thermal zone name to fetch the temperature 2029 * 2030 * When only one zone is found with the passed name, returns a reference to it. 2031 * 2032 * Return: On success returns a reference to an unique thermal zone with 2033 * matching name equals to @name, an ERR_PTR otherwise (-EINVAL for invalid 2034 * paramenters, -ENODEV for not found and -EEXIST for multiple matches). 2035 */ 2036struct thermal_zone_device *thermal_zone_get_zone_by_name(const char *name) 2037{ 2038 struct thermal_zone_device *pos = NULL, *ref = ERR_PTR(-EINVAL); 2039 unsigned int found = 0; 2040 2041 if (!name) 2042 goto exit; 2043 2044 mutex_lock(&thermal_list_lock); 2045 list_for_each_entry(pos, &thermal_tz_list, node) 2046 if (!strncasecmp(name, pos->type, THERMAL_NAME_LENGTH)) { 2047 found++; 2048 ref = pos; 2049 } 2050 mutex_unlock(&thermal_list_lock); 2051 2052 /* nothing has been found, thus an error code for it */ 2053 if (found == 0) 2054 ref = ERR_PTR(-ENODEV); 2055 else if (found > 1) 2056 /* Success only when an unique zone is found */ 2057 ref = ERR_PTR(-EEXIST); 2058 2059exit: 2060 return ref; 2061} 2062EXPORT_SYMBOL_GPL(thermal_zone_get_zone_by_name); 2063 2064#ifdef CONFIG_NET 2065static const struct genl_multicast_group thermal_event_mcgrps[] = { 2066 { .name = THERMAL_GENL_MCAST_GROUP_NAME, }, 2067}; 2068 2069static struct genl_family thermal_event_genl_family = { 2070 .id = GENL_ID_GENERATE, 2071 .name = THERMAL_GENL_FAMILY_NAME, 2072 .version = THERMAL_GENL_VERSION, 2073 .maxattr = THERMAL_GENL_ATTR_MAX, 2074 .mcgrps = thermal_event_mcgrps, 2075 .n_mcgrps = ARRAY_SIZE(thermal_event_mcgrps), 2076}; 2077 2078int thermal_generate_netlink_event(struct thermal_zone_device *tz, 2079 enum events event) 2080{ 2081 struct sk_buff *skb; 2082 struct nlattr *attr; 2083 struct thermal_genl_event *thermal_event; 2084 void *msg_header; 2085 int size; 2086 int result; 2087 static unsigned int thermal_event_seqnum; 2088 2089 if (!tz) 2090 return -EINVAL; 2091 2092 /* allocate memory */ 2093 size = nla_total_size(sizeof(struct thermal_genl_event)) + 2094 nla_total_size(0); 2095 2096 skb = genlmsg_new(size, GFP_ATOMIC); 2097 if (!skb) 2098 return -ENOMEM; 2099 2100 /* add the genetlink message header */ 2101 msg_header = genlmsg_put(skb, 0, thermal_event_seqnum++, 2102 &thermal_event_genl_family, 0, 2103 THERMAL_GENL_CMD_EVENT); 2104 if (!msg_header) { 2105 nlmsg_free(skb); 2106 return -ENOMEM; 2107 } 2108 2109 /* fill the data */ 2110 attr = nla_reserve(skb, THERMAL_GENL_ATTR_EVENT, 2111 sizeof(struct thermal_genl_event)); 2112 2113 if (!attr) { 2114 nlmsg_free(skb); 2115 return -EINVAL; 2116 } 2117 2118 thermal_event = nla_data(attr); 2119 if (!thermal_event) { 2120 nlmsg_free(skb); 2121 return -EINVAL; 2122 } 2123 2124 memset(thermal_event, 0, sizeof(struct thermal_genl_event)); 2125 2126 thermal_event->orig = tz->id; 2127 thermal_event->event = event; 2128 2129 /* send multicast genetlink message */ 2130 genlmsg_end(skb, msg_header); 2131 2132 result = genlmsg_multicast(&thermal_event_genl_family, skb, 0, 2133 0, GFP_ATOMIC); 2134 if (result) 2135 dev_err(&tz->device, "Failed to send netlink event:%d", result); 2136 2137 return result; 2138} 2139EXPORT_SYMBOL_GPL(thermal_generate_netlink_event); 2140 2141static int genetlink_init(void) 2142{ 2143 return genl_register_family(&thermal_event_genl_family); 2144} 2145 2146static void genetlink_exit(void) 2147{ 2148 genl_unregister_family(&thermal_event_genl_family); 2149} 2150#else /* !CONFIG_NET */ 2151static inline int genetlink_init(void) { return 0; } 2152static inline void genetlink_exit(void) {} 2153#endif /* !CONFIG_NET */ 2154 2155static int __init thermal_register_governors(void) 2156{ 2157 int result; 2158 2159 result = thermal_gov_step_wise_register(); 2160 if (result) 2161 return result; 2162 2163 result = thermal_gov_fair_share_register(); 2164 if (result) 2165 return result; 2166 2167 result = thermal_gov_bang_bang_register(); 2168 if (result) 2169 return result; 2170 2171 result = thermal_gov_user_space_register(); 2172 if (result) 2173 return result; 2174 2175 return thermal_gov_power_allocator_register(); 2176} 2177 2178static void thermal_unregister_governors(void) 2179{ 2180 thermal_gov_step_wise_unregister(); 2181 thermal_gov_fair_share_unregister(); 2182 thermal_gov_bang_bang_unregister(); 2183 thermal_gov_user_space_unregister(); 2184 thermal_gov_power_allocator_unregister(); 2185} 2186 2187static int thermal_pm_notify(struct notifier_block *nb, 2188 unsigned long mode, void *_unused) 2189{ 2190 struct thermal_zone_device *tz; 2191 2192 switch (mode) { 2193 case PM_HIBERNATION_PREPARE: 2194 case PM_RESTORE_PREPARE: 2195 case PM_SUSPEND_PREPARE: 2196 atomic_set(&in_suspend, 1); 2197 break; 2198 case PM_POST_HIBERNATION: 2199 case PM_POST_RESTORE: 2200 case PM_POST_SUSPEND: 2201 atomic_set(&in_suspend, 0); 2202 list_for_each_entry(tz, &thermal_tz_list, node) { 2203 thermal_zone_device_reset(tz); 2204 thermal_zone_device_update(tz); 2205 } 2206 break; 2207 default: 2208 break; 2209 } 2210 return 0; 2211} 2212 2213static struct notifier_block thermal_pm_nb = { 2214 .notifier_call = thermal_pm_notify, 2215}; 2216 2217static int __init thermal_init(void) 2218{ 2219 int result; 2220 2221 result = thermal_register_governors(); 2222 if (result) 2223 goto error; 2224 2225 result = class_register(&thermal_class); 2226 if (result) 2227 goto unregister_governors; 2228 2229 result = genetlink_init(); 2230 if (result) 2231 goto unregister_class; 2232 2233 result = of_parse_thermal_zones(); 2234 if (result) 2235 goto exit_netlink; 2236 2237 result = register_pm_notifier(&thermal_pm_nb); 2238 if (result) 2239 pr_warn("Thermal: Can not register suspend notifier, return %d\n", 2240 result); 2241 2242 return 0; 2243 2244exit_netlink: 2245 genetlink_exit(); 2246unregister_class: 2247 class_unregister(&thermal_class); 2248unregister_governors: 2249 thermal_unregister_governors(); 2250error: 2251 idr_destroy(&thermal_tz_idr); 2252 idr_destroy(&thermal_cdev_idr); 2253 mutex_destroy(&thermal_idr_lock); 2254 mutex_destroy(&thermal_list_lock); 2255 mutex_destroy(&thermal_governor_lock); 2256 return result; 2257} 2258 2259static void __exit thermal_exit(void) 2260{ 2261 unregister_pm_notifier(&thermal_pm_nb); 2262 of_thermal_destroy_zones(); 2263 genetlink_exit(); 2264 class_unregister(&thermal_class); 2265 thermal_unregister_governors(); 2266 idr_destroy(&thermal_tz_idr); 2267 idr_destroy(&thermal_cdev_idr); 2268 mutex_destroy(&thermal_idr_lock); 2269 mutex_destroy(&thermal_list_lock); 2270 mutex_destroy(&thermal_governor_lock); 2271} 2272 2273fs_initcall(thermal_init); 2274module_exit(thermal_exit); 2275