1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * acpi_thermal.c - ACPI Thermal Zone Driver ($Revision: 41 $) 4 * 5 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 6 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 7 * 8 * This driver fully implements the ACPI thermal policy as described in the 9 * ACPI 2.0 Specification. 10 * 11 * TBD: 1. Implement passive cooling hysteresis. 12 * 2. Enhance passive cooling (CPU) states/limit interface to support 13 * concepts of 'multiple limiters', upper/lower limits, etc. 14 */ 15 16 #define pr_fmt(fmt) "ACPI: thermal: " fmt 17 18 #include <linux/kernel.h> 19 #include <linux/module.h> 20 #include <linux/dmi.h> 21 #include <linux/init.h> 22 #include <linux/slab.h> 23 #include <linux/types.h> 24 #include <linux/jiffies.h> 25 #include <linux/kmod.h> 26 #include <linux/reboot.h> 27 #include <linux/device.h> 28 #include <linux/thermal.h> 29 #include <linux/acpi.h> 30 #include <linux/workqueue.h> 31 #include <linux/uaccess.h> 32 #include <linux/units.h> 33 34 #include "internal.h" 35 36 #define ACPI_THERMAL_CLASS "thermal_zone" 37 #define ACPI_THERMAL_DEVICE_NAME "Thermal Zone" 38 #define ACPI_THERMAL_NOTIFY_TEMPERATURE 0x80 39 #define ACPI_THERMAL_NOTIFY_THRESHOLDS 0x81 40 #define ACPI_THERMAL_NOTIFY_DEVICES 0x82 41 #define ACPI_THERMAL_NOTIFY_CRITICAL 0xF0 42 #define ACPI_THERMAL_NOTIFY_HOT 0xF1 43 #define ACPI_THERMAL_MODE_ACTIVE 0x00 44 45 #define ACPI_THERMAL_MAX_ACTIVE 10 46 #define ACPI_THERMAL_MAX_LIMIT_STR_LEN 65 47 48 #define ACPI_THERMAL_TRIP_PASSIVE (-1) 49 50 #define ACPI_THERMAL_MAX_NR_TRIPS (ACPI_THERMAL_MAX_ACTIVE + 3) 51 52 /* 53 * This exception is thrown out in two cases: 54 * 1.An invalid trip point becomes invalid or a valid trip point becomes invalid 55 * when re-evaluating the AML code. 56 * 2.TODO: Devices listed in _PSL, _ALx, _TZD may change. 57 * We need to re-bind the cooling devices of a thermal zone when this occurs. 58 */ 59 #define ACPI_THERMAL_TRIPS_EXCEPTION(tz, str) \ 60 do { \ 61 acpi_handle_info(tz->device->handle, \ 62 "ACPI thermal trip point %s changed\n" \ 63 "Please report to linux-acpi@vger.kernel.org\n", str); \ 64 } while (0) 65 66 static int act; 67 module_param(act, int, 0644); 68 MODULE_PARM_DESC(act, "Disable or override all lowest active trip points."); 69 70 static int crt; 71 module_param(crt, int, 0644); 72 MODULE_PARM_DESC(crt, "Disable or lower all critical trip points."); 73 74 static int tzp; 75 module_param(tzp, int, 0444); 76 MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds."); 77 78 static int off; 79 module_param(off, int, 0); 80 MODULE_PARM_DESC(off, "Set to disable ACPI thermal support."); 81 82 static int psv; 83 module_param(psv, int, 0644); 84 MODULE_PARM_DESC(psv, "Disable or override all passive trip points."); 85 86 static struct workqueue_struct *acpi_thermal_pm_queue; 87 88 struct acpi_thermal_trip { 89 unsigned long temp_dk; 90 struct acpi_handle_list devices; 91 }; 92 93 struct acpi_thermal_passive { 94 struct acpi_thermal_trip trip; 95 unsigned long tc1; 96 unsigned long tc2; 97 unsigned long delay; 98 }; 99 100 struct acpi_thermal_active { 101 struct acpi_thermal_trip trip; 102 }; 103 104 struct acpi_thermal_trips { 105 struct acpi_thermal_passive passive; 106 struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE]; 107 }; 108 109 struct acpi_thermal { 110 struct acpi_device *device; 111 acpi_bus_id name; 112 unsigned long temp_dk; 113 unsigned long last_temp_dk; 114 unsigned long polling_frequency; 115 volatile u8 zombie; 116 struct acpi_thermal_trips trips; 117 struct thermal_zone_device *thermal_zone; 118 int kelvin_offset; /* in millidegrees */ 119 struct work_struct thermal_check_work; 120 struct mutex thermal_check_lock; 121 refcount_t thermal_check_count; 122 }; 123 124 /* -------------------------------------------------------------------------- 125 Thermal Zone Management 126 -------------------------------------------------------------------------- */ 127 128 static int acpi_thermal_get_temperature(struct acpi_thermal *tz) 129 { 130 acpi_status status = AE_OK; 131 unsigned long long tmp; 132 133 if (!tz) 134 return -EINVAL; 135 136 tz->last_temp_dk = tz->temp_dk; 137 138 status = acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tmp); 139 if (ACPI_FAILURE(status)) 140 return -ENODEV; 141 142 tz->temp_dk = tmp; 143 144 acpi_handle_debug(tz->device->handle, "Temperature is %lu dK\n", 145 tz->temp_dk); 146 147 return 0; 148 } 149 150 static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz) 151 { 152 acpi_status status = AE_OK; 153 unsigned long long tmp; 154 155 if (!tz) 156 return -EINVAL; 157 158 status = acpi_evaluate_integer(tz->device->handle, "_TZP", NULL, &tmp); 159 if (ACPI_FAILURE(status)) 160 return -ENODEV; 161 162 tz->polling_frequency = tmp; 163 acpi_handle_debug(tz->device->handle, "Polling frequency is %lu dS\n", 164 tz->polling_frequency); 165 166 return 0; 167 } 168 169 static int acpi_thermal_temp(struct acpi_thermal *tz, int temp_deci_k) 170 { 171 int temp; 172 173 if (temp_deci_k == THERMAL_TEMP_INVALID) 174 return THERMAL_TEMP_INVALID; 175 176 temp = deci_kelvin_to_millicelsius_with_offset(temp_deci_k, 177 tz->kelvin_offset); 178 if (temp <= 0) 179 return THERMAL_TEMP_INVALID; 180 181 return temp; 182 } 183 184 static bool acpi_thermal_trip_valid(struct acpi_thermal_trip *acpi_trip) 185 { 186 return acpi_trip->temp_dk != THERMAL_TEMP_INVALID; 187 } 188 189 static int active_trip_index(struct acpi_thermal *tz, 190 struct acpi_thermal_trip *acpi_trip) 191 { 192 struct acpi_thermal_active *active; 193 194 active = container_of(acpi_trip, struct acpi_thermal_active, trip); 195 return active - tz->trips.active; 196 } 197 198 static long get_passive_temp(struct acpi_thermal *tz) 199 { 200 int temp; 201 202 if (acpi_passive_trip_temp(tz->device, &temp)) 203 return THERMAL_TEMP_INVALID; 204 205 return temp; 206 } 207 208 static long get_active_temp(struct acpi_thermal *tz, int index) 209 { 210 int temp; 211 212 if (acpi_active_trip_temp(tz->device, index, &temp)) 213 return THERMAL_TEMP_INVALID; 214 215 /* 216 * If an override has been provided, apply it so there are no active 217 * trips with thresholds greater than the override. 218 */ 219 if (act > 0) { 220 unsigned long long override = celsius_to_deci_kelvin(act); 221 222 if (temp > override) 223 return override; 224 } 225 return temp; 226 } 227 228 static void acpi_thermal_update_trip(struct acpi_thermal *tz, 229 const struct thermal_trip *trip) 230 { 231 struct acpi_thermal_trip *acpi_trip = trip->priv; 232 233 if (trip->type == THERMAL_TRIP_PASSIVE) { 234 if (psv > 0) 235 return; 236 237 acpi_trip->temp_dk = get_passive_temp(tz); 238 } else { 239 int index = active_trip_index(tz, acpi_trip); 240 241 acpi_trip->temp_dk = get_active_temp(tz, index); 242 } 243 244 if (!acpi_thermal_trip_valid(acpi_trip)) 245 ACPI_THERMAL_TRIPS_EXCEPTION(tz, "state"); 246 } 247 248 static bool update_trip_devices(struct acpi_thermal *tz, 249 struct acpi_thermal_trip *acpi_trip, 250 int index, bool compare) 251 { 252 struct acpi_handle_list devices = { 0 }; 253 char method[] = "_PSL"; 254 255 if (index != ACPI_THERMAL_TRIP_PASSIVE) { 256 method[1] = 'A'; 257 method[2] = 'L'; 258 method[3] = '0' + index; 259 } 260 261 if (!acpi_evaluate_reference(tz->device->handle, method, NULL, &devices)) { 262 acpi_handle_info(tz->device->handle, "%s evaluation failure\n", method); 263 return false; 264 } 265 266 if (acpi_handle_list_equal(&acpi_trip->devices, &devices)) { 267 acpi_handle_list_free(&devices); 268 return true; 269 } 270 271 if (compare) 272 ACPI_THERMAL_TRIPS_EXCEPTION(tz, "device"); 273 274 acpi_handle_list_replace(&acpi_trip->devices, &devices); 275 return true; 276 } 277 278 static void acpi_thermal_update_trip_devices(struct acpi_thermal *tz, 279 const struct thermal_trip *trip) 280 { 281 struct acpi_thermal_trip *acpi_trip = trip->priv; 282 int index = trip->type == THERMAL_TRIP_PASSIVE ? 283 ACPI_THERMAL_TRIP_PASSIVE : active_trip_index(tz, acpi_trip); 284 285 if (update_trip_devices(tz, acpi_trip, index, true)) 286 return; 287 288 acpi_trip->temp_dk = THERMAL_TEMP_INVALID; 289 ACPI_THERMAL_TRIPS_EXCEPTION(tz, "state"); 290 } 291 292 struct adjust_trip_data { 293 struct acpi_thermal *tz; 294 u32 event; 295 }; 296 297 static int acpi_thermal_adjust_trip(struct thermal_trip *trip, void *data) 298 { 299 struct acpi_thermal_trip *acpi_trip = trip->priv; 300 struct adjust_trip_data *atd = data; 301 struct acpi_thermal *tz = atd->tz; 302 int temp; 303 304 if (!acpi_trip || !acpi_thermal_trip_valid(acpi_trip)) 305 return 0; 306 307 if (atd->event == ACPI_THERMAL_NOTIFY_THRESHOLDS) 308 acpi_thermal_update_trip(tz, trip); 309 else 310 acpi_thermal_update_trip_devices(tz, trip); 311 312 if (acpi_thermal_trip_valid(acpi_trip)) 313 temp = acpi_thermal_temp(tz, acpi_trip->temp_dk); 314 else 315 temp = THERMAL_TEMP_INVALID; 316 317 thermal_zone_set_trip_temp(tz->thermal_zone, trip, temp); 318 319 return 0; 320 } 321 322 static void acpi_queue_thermal_check(struct acpi_thermal *tz) 323 { 324 if (!work_pending(&tz->thermal_check_work)) 325 queue_work(acpi_thermal_pm_queue, &tz->thermal_check_work); 326 } 327 328 static void acpi_thermal_trips_update(struct acpi_thermal *tz, u32 event) 329 { 330 struct adjust_trip_data atd = { .tz = tz, .event = event }; 331 struct acpi_device *adev = tz->device; 332 333 /* 334 * Use thermal_zone_for_each_trip() to carry out the trip points 335 * update, so as to protect thermal_get_trend() from getting stale 336 * trip point temperatures and to prevent thermal_zone_device_update() 337 * invoked from acpi_thermal_check_fn() from producing inconsistent 338 * results. 339 */ 340 thermal_zone_for_each_trip(tz->thermal_zone, 341 acpi_thermal_adjust_trip, &atd); 342 acpi_queue_thermal_check(tz); 343 acpi_bus_generate_netlink_event(adev->pnp.device_class, 344 dev_name(&adev->dev), event, 0); 345 } 346 347 static int acpi_thermal_get_critical_trip(struct acpi_thermal *tz) 348 { 349 int temp; 350 351 if (crt > 0) { 352 temp = celsius_to_deci_kelvin(crt); 353 goto set; 354 } 355 if (crt == -1) { 356 acpi_handle_debug(tz->device->handle, "Critical threshold disabled\n"); 357 return THERMAL_TEMP_INVALID; 358 } 359 360 if (acpi_critical_trip_temp(tz->device, &temp)) 361 return THERMAL_TEMP_INVALID; 362 363 if (temp <= 2732) { 364 /* 365 * Below zero (Celsius) values clearly aren't right for sure, 366 * so discard them as invalid. 367 */ 368 pr_info(FW_BUG "Invalid critical threshold (%d)\n", temp); 369 return THERMAL_TEMP_INVALID; 370 } 371 372 set: 373 acpi_handle_debug(tz->device->handle, "Critical threshold [%d]\n", temp); 374 return temp; 375 } 376 377 static int acpi_thermal_get_hot_trip(struct acpi_thermal *tz) 378 { 379 int temp; 380 381 if (acpi_hot_trip_temp(tz->device, &temp) || temp == THERMAL_TEMP_INVALID) { 382 acpi_handle_debug(tz->device->handle, "No hot threshold\n"); 383 return THERMAL_TEMP_INVALID; 384 } 385 386 acpi_handle_debug(tz->device->handle, "Hot threshold [%d]\n", temp); 387 return temp; 388 } 389 390 static bool passive_trip_params_init(struct acpi_thermal *tz) 391 { 392 unsigned long long tmp; 393 acpi_status status; 394 395 status = acpi_evaluate_integer(tz->device->handle, "_TC1", NULL, &tmp); 396 if (ACPI_FAILURE(status)) 397 return false; 398 399 tz->trips.passive.tc1 = tmp; 400 401 status = acpi_evaluate_integer(tz->device->handle, "_TC2", NULL, &tmp); 402 if (ACPI_FAILURE(status)) 403 return false; 404 405 tz->trips.passive.tc2 = tmp; 406 407 status = acpi_evaluate_integer(tz->device->handle, "_TFP", NULL, &tmp); 408 if (ACPI_SUCCESS(status)) { 409 tz->trips.passive.delay = tmp; 410 return true; 411 } 412 413 status = acpi_evaluate_integer(tz->device->handle, "_TSP", NULL, &tmp); 414 if (ACPI_FAILURE(status)) 415 return false; 416 417 tz->trips.passive.delay = tmp * 100; 418 419 return true; 420 } 421 422 static bool acpi_thermal_init_trip(struct acpi_thermal *tz, int index) 423 { 424 struct acpi_thermal_trip *acpi_trip; 425 long temp; 426 427 if (index == ACPI_THERMAL_TRIP_PASSIVE) { 428 acpi_trip = &tz->trips.passive.trip; 429 430 if (psv == -1) 431 goto fail; 432 433 if (!passive_trip_params_init(tz)) 434 goto fail; 435 436 temp = psv > 0 ? celsius_to_deci_kelvin(psv) : 437 get_passive_temp(tz); 438 } else { 439 acpi_trip = &tz->trips.active[index].trip; 440 441 if (act == -1) 442 goto fail; 443 444 temp = get_active_temp(tz, index); 445 } 446 447 if (temp == THERMAL_TEMP_INVALID) 448 goto fail; 449 450 if (!update_trip_devices(tz, acpi_trip, index, false)) 451 goto fail; 452 453 acpi_trip->temp_dk = temp; 454 return true; 455 456 fail: 457 acpi_trip->temp_dk = THERMAL_TEMP_INVALID; 458 return false; 459 } 460 461 static void acpi_thermal_get_trip_points(struct acpi_thermal *tz) 462 { 463 int i; 464 465 acpi_thermal_init_trip(tz, ACPI_THERMAL_TRIP_PASSIVE); 466 467 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) { 468 if (!acpi_thermal_init_trip(tz, i)) 469 break; 470 } 471 472 while (++i < ACPI_THERMAL_MAX_ACTIVE) 473 tz->trips.active[i].trip.temp_dk = THERMAL_TEMP_INVALID; 474 } 475 476 /* sys I/F for generic thermal sysfs support */ 477 478 static int thermal_get_temp(struct thermal_zone_device *thermal, int *temp) 479 { 480 struct acpi_thermal *tz = thermal_zone_device_priv(thermal); 481 int result; 482 483 if (!tz) 484 return -EINVAL; 485 486 result = acpi_thermal_get_temperature(tz); 487 if (result) 488 return result; 489 490 *temp = deci_kelvin_to_millicelsius_with_offset(tz->temp_dk, 491 tz->kelvin_offset); 492 return 0; 493 } 494 495 static int thermal_get_trend(struct thermal_zone_device *thermal, 496 const struct thermal_trip *trip, 497 enum thermal_trend *trend) 498 { 499 struct acpi_thermal *tz = thermal_zone_device_priv(thermal); 500 struct acpi_thermal_trip *acpi_trip; 501 int t; 502 503 if (!tz || !trip) 504 return -EINVAL; 505 506 acpi_trip = trip->priv; 507 if (!acpi_trip || !acpi_thermal_trip_valid(acpi_trip)) 508 return -EINVAL; 509 510 switch (trip->type) { 511 case THERMAL_TRIP_PASSIVE: 512 t = tz->trips.passive.tc1 * (tz->temp_dk - 513 tz->last_temp_dk) + 514 tz->trips.passive.tc2 * (tz->temp_dk - 515 acpi_trip->temp_dk); 516 if (t > 0) 517 *trend = THERMAL_TREND_RAISING; 518 else if (t < 0) 519 *trend = THERMAL_TREND_DROPPING; 520 else 521 *trend = THERMAL_TREND_STABLE; 522 523 return 0; 524 525 case THERMAL_TRIP_ACTIVE: 526 t = acpi_thermal_temp(tz, tz->temp_dk); 527 if (t <= trip->temperature) 528 break; 529 530 *trend = THERMAL_TREND_RAISING; 531 532 return 0; 533 534 default: 535 break; 536 } 537 538 return -EINVAL; 539 } 540 541 static void acpi_thermal_zone_device_hot(struct thermal_zone_device *thermal) 542 { 543 struct acpi_thermal *tz = thermal_zone_device_priv(thermal); 544 545 acpi_bus_generate_netlink_event(tz->device->pnp.device_class, 546 dev_name(&tz->device->dev), 547 ACPI_THERMAL_NOTIFY_HOT, 1); 548 } 549 550 static void acpi_thermal_zone_device_critical(struct thermal_zone_device *thermal) 551 { 552 struct acpi_thermal *tz = thermal_zone_device_priv(thermal); 553 554 acpi_bus_generate_netlink_event(tz->device->pnp.device_class, 555 dev_name(&tz->device->dev), 556 ACPI_THERMAL_NOTIFY_CRITICAL, 1); 557 558 thermal_zone_device_critical(thermal); 559 } 560 561 struct acpi_thermal_bind_data { 562 struct thermal_zone_device *thermal; 563 struct thermal_cooling_device *cdev; 564 bool bind; 565 }; 566 567 static int bind_unbind_cdev_cb(struct thermal_trip *trip, void *arg) 568 { 569 struct acpi_thermal_trip *acpi_trip = trip->priv; 570 struct acpi_thermal_bind_data *bd = arg; 571 struct thermal_zone_device *thermal = bd->thermal; 572 struct thermal_cooling_device *cdev = bd->cdev; 573 struct acpi_device *cdev_adev = cdev->devdata; 574 int i; 575 576 /* Skip critical and hot trips. */ 577 if (!acpi_trip) 578 return 0; 579 580 for (i = 0; i < acpi_trip->devices.count; i++) { 581 acpi_handle handle = acpi_trip->devices.handles[i]; 582 struct acpi_device *adev = acpi_fetch_acpi_dev(handle); 583 584 if (adev != cdev_adev) 585 continue; 586 587 if (bd->bind) { 588 int ret; 589 590 ret = thermal_bind_cdev_to_trip(thermal, trip, cdev, 591 THERMAL_NO_LIMIT, 592 THERMAL_NO_LIMIT, 593 THERMAL_WEIGHT_DEFAULT); 594 if (ret) 595 return ret; 596 } else { 597 thermal_unbind_cdev_from_trip(thermal, trip, cdev); 598 } 599 } 600 601 return 0; 602 } 603 604 static int acpi_thermal_bind_unbind_cdev(struct thermal_zone_device *thermal, 605 struct thermal_cooling_device *cdev, 606 bool bind) 607 { 608 struct acpi_thermal_bind_data bd = { 609 .thermal = thermal, .cdev = cdev, .bind = bind 610 }; 611 612 return for_each_thermal_trip(thermal, bind_unbind_cdev_cb, &bd); 613 } 614 615 static int 616 acpi_thermal_bind_cooling_device(struct thermal_zone_device *thermal, 617 struct thermal_cooling_device *cdev) 618 { 619 return acpi_thermal_bind_unbind_cdev(thermal, cdev, true); 620 } 621 622 static int 623 acpi_thermal_unbind_cooling_device(struct thermal_zone_device *thermal, 624 struct thermal_cooling_device *cdev) 625 { 626 return acpi_thermal_bind_unbind_cdev(thermal, cdev, false); 627 } 628 629 static const struct thermal_zone_device_ops acpi_thermal_zone_ops = { 630 .bind = acpi_thermal_bind_cooling_device, 631 .unbind = acpi_thermal_unbind_cooling_device, 632 .get_temp = thermal_get_temp, 633 .get_trend = thermal_get_trend, 634 .hot = acpi_thermal_zone_device_hot, 635 .critical = acpi_thermal_zone_device_critical, 636 }; 637 638 static int acpi_thermal_zone_sysfs_add(struct acpi_thermal *tz) 639 { 640 struct device *tzdev = thermal_zone_device(tz->thermal_zone); 641 int ret; 642 643 ret = sysfs_create_link(&tz->device->dev.kobj, 644 &tzdev->kobj, "thermal_zone"); 645 if (ret) 646 return ret; 647 648 ret = sysfs_create_link(&tzdev->kobj, 649 &tz->device->dev.kobj, "device"); 650 if (ret) 651 sysfs_remove_link(&tz->device->dev.kobj, "thermal_zone"); 652 653 return ret; 654 } 655 656 static void acpi_thermal_zone_sysfs_remove(struct acpi_thermal *tz) 657 { 658 struct device *tzdev = thermal_zone_device(tz->thermal_zone); 659 660 sysfs_remove_link(&tz->device->dev.kobj, "thermal_zone"); 661 sysfs_remove_link(&tzdev->kobj, "device"); 662 } 663 664 static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz, 665 const struct thermal_trip *trip_table, 666 unsigned int trip_count, 667 int passive_delay) 668 { 669 int result; 670 671 if (trip_count) 672 tz->thermal_zone = thermal_zone_device_register_with_trips( 673 "acpitz", trip_table, trip_count, tz, 674 &acpi_thermal_zone_ops, NULL, passive_delay, 675 tz->polling_frequency * 100); 676 else 677 tz->thermal_zone = thermal_tripless_zone_device_register( 678 "acpitz", tz, &acpi_thermal_zone_ops, NULL); 679 680 if (IS_ERR(tz->thermal_zone)) 681 return PTR_ERR(tz->thermal_zone); 682 683 result = acpi_thermal_zone_sysfs_add(tz); 684 if (result) 685 goto unregister_tzd; 686 687 result = thermal_zone_device_enable(tz->thermal_zone); 688 if (result) 689 goto remove_links; 690 691 dev_info(&tz->device->dev, "registered as thermal_zone%d\n", 692 thermal_zone_device_id(tz->thermal_zone)); 693 694 return 0; 695 696 remove_links: 697 acpi_thermal_zone_sysfs_remove(tz); 698 unregister_tzd: 699 thermal_zone_device_unregister(tz->thermal_zone); 700 701 return result; 702 } 703 704 static void acpi_thermal_unregister_thermal_zone(struct acpi_thermal *tz) 705 { 706 thermal_zone_device_disable(tz->thermal_zone); 707 acpi_thermal_zone_sysfs_remove(tz); 708 thermal_zone_device_unregister(tz->thermal_zone); 709 tz->thermal_zone = NULL; 710 } 711 712 713 /* -------------------------------------------------------------------------- 714 Driver Interface 715 -------------------------------------------------------------------------- */ 716 717 static void acpi_thermal_notify(acpi_handle handle, u32 event, void *data) 718 { 719 struct acpi_device *device = data; 720 struct acpi_thermal *tz = acpi_driver_data(device); 721 722 if (!tz) 723 return; 724 725 switch (event) { 726 case ACPI_THERMAL_NOTIFY_TEMPERATURE: 727 acpi_queue_thermal_check(tz); 728 break; 729 case ACPI_THERMAL_NOTIFY_THRESHOLDS: 730 case ACPI_THERMAL_NOTIFY_DEVICES: 731 acpi_thermal_trips_update(tz, event); 732 break; 733 default: 734 acpi_handle_debug(device->handle, "Unsupported event [0x%x]\n", 735 event); 736 break; 737 } 738 } 739 740 /* 741 * On some platforms, the AML code has dependency about 742 * the evaluating order of _TMP and _CRT/_HOT/_PSV/_ACx. 743 * 1. On HP Pavilion G4-1016tx, _TMP must be invoked after 744 * /_CRT/_HOT/_PSV/_ACx, or else system will be power off. 745 * 2. On HP Compaq 6715b/6715s, the return value of _PSV is 0 746 * if _TMP has never been evaluated. 747 * 748 * As this dependency is totally transparent to OS, evaluate 749 * all of them once, in the order of _CRT/_HOT/_PSV/_ACx, 750 * _TMP, before they are actually used. 751 */ 752 static void acpi_thermal_aml_dependency_fix(struct acpi_thermal *tz) 753 { 754 acpi_handle handle = tz->device->handle; 755 unsigned long long value; 756 int i; 757 758 acpi_evaluate_integer(handle, "_CRT", NULL, &value); 759 acpi_evaluate_integer(handle, "_HOT", NULL, &value); 760 acpi_evaluate_integer(handle, "_PSV", NULL, &value); 761 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) { 762 char name[5] = { '_', 'A', 'C', ('0' + i), '\0' }; 763 acpi_status status; 764 765 status = acpi_evaluate_integer(handle, name, NULL, &value); 766 if (status == AE_NOT_FOUND) 767 break; 768 } 769 acpi_evaluate_integer(handle, "_TMP", NULL, &value); 770 } 771 772 /* 773 * The exact offset between Kelvin and degree Celsius is 273.15. However ACPI 774 * handles temperature values with a single decimal place. As a consequence, 775 * some implementations use an offset of 273.1 and others use an offset of 776 * 273.2. Try to find out which one is being used, to present the most 777 * accurate and visually appealing number. 778 * 779 * The heuristic below should work for all ACPI thermal zones which have a 780 * critical trip point with a value being a multiple of 0.5 degree Celsius. 781 */ 782 static void acpi_thermal_guess_offset(struct acpi_thermal *tz, long crit_temp) 783 { 784 if (crit_temp != THERMAL_TEMP_INVALID && crit_temp % 5 == 1) 785 tz->kelvin_offset = 273100; 786 else 787 tz->kelvin_offset = 273200; 788 } 789 790 static void acpi_thermal_check_fn(struct work_struct *work) 791 { 792 struct acpi_thermal *tz = container_of(work, struct acpi_thermal, 793 thermal_check_work); 794 795 /* 796 * In general, it is not sufficient to check the pending bit, because 797 * subsequent instances of this function may be queued after one of them 798 * has started running (e.g. if _TMP sleeps). Avoid bailing out if just 799 * one of them is running, though, because it may have done the actual 800 * check some time ago, so allow at least one of them to block on the 801 * mutex while another one is running the update. 802 */ 803 if (!refcount_dec_not_one(&tz->thermal_check_count)) 804 return; 805 806 mutex_lock(&tz->thermal_check_lock); 807 808 thermal_zone_device_update(tz->thermal_zone, THERMAL_EVENT_UNSPECIFIED); 809 810 refcount_inc(&tz->thermal_check_count); 811 812 mutex_unlock(&tz->thermal_check_lock); 813 } 814 815 static void acpi_thermal_free_thermal_zone(struct acpi_thermal *tz) 816 { 817 int i; 818 819 acpi_handle_list_free(&tz->trips.passive.trip.devices); 820 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) 821 acpi_handle_list_free(&tz->trips.active[i].trip.devices); 822 823 kfree(tz); 824 } 825 826 static int acpi_thermal_add(struct acpi_device *device) 827 { 828 struct thermal_trip trip_table[ACPI_THERMAL_MAX_NR_TRIPS] = { 0 }; 829 struct acpi_thermal_trip *acpi_trip; 830 struct thermal_trip *trip; 831 struct acpi_thermal *tz; 832 int crit_temp, hot_temp; 833 int passive_delay = 0; 834 int result; 835 int i; 836 837 if (!device) 838 return -EINVAL; 839 840 tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL); 841 if (!tz) 842 return -ENOMEM; 843 844 tz->device = device; 845 strcpy(tz->name, device->pnp.bus_id); 846 strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME); 847 strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS); 848 device->driver_data = tz; 849 850 acpi_thermal_aml_dependency_fix(tz); 851 852 /* Get trip points [_CRT, _PSV, etc.] (required). */ 853 acpi_thermal_get_trip_points(tz); 854 855 crit_temp = acpi_thermal_get_critical_trip(tz); 856 hot_temp = acpi_thermal_get_hot_trip(tz); 857 858 /* Get temperature [_TMP] (required). */ 859 result = acpi_thermal_get_temperature(tz); 860 if (result) 861 goto free_memory; 862 863 /* Set the cooling mode [_SCP] to active cooling. */ 864 acpi_execute_simple_method(tz->device->handle, "_SCP", 865 ACPI_THERMAL_MODE_ACTIVE); 866 867 /* Determine the default polling frequency [_TZP]. */ 868 if (tzp) 869 tz->polling_frequency = tzp; 870 else 871 acpi_thermal_get_polling_frequency(tz); 872 873 acpi_thermal_guess_offset(tz, crit_temp); 874 875 trip = trip_table; 876 877 if (crit_temp != THERMAL_TEMP_INVALID) { 878 trip->type = THERMAL_TRIP_CRITICAL; 879 trip->temperature = acpi_thermal_temp(tz, crit_temp); 880 trip++; 881 } 882 883 if (hot_temp != THERMAL_TEMP_INVALID) { 884 trip->type = THERMAL_TRIP_HOT; 885 trip->temperature = acpi_thermal_temp(tz, hot_temp); 886 trip++; 887 } 888 889 acpi_trip = &tz->trips.passive.trip; 890 if (acpi_thermal_trip_valid(acpi_trip)) { 891 passive_delay = tz->trips.passive.delay; 892 893 trip->type = THERMAL_TRIP_PASSIVE; 894 trip->temperature = acpi_thermal_temp(tz, acpi_trip->temp_dk); 895 trip->priv = acpi_trip; 896 trip++; 897 } 898 899 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) { 900 acpi_trip = &tz->trips.active[i].trip; 901 902 if (!acpi_thermal_trip_valid(acpi_trip)) 903 break; 904 905 trip->type = THERMAL_TRIP_ACTIVE; 906 trip->temperature = acpi_thermal_temp(tz, acpi_trip->temp_dk); 907 trip->priv = acpi_trip; 908 trip++; 909 } 910 911 if (trip == trip_table) 912 pr_warn(FW_BUG "No valid trip points!\n"); 913 914 result = acpi_thermal_register_thermal_zone(tz, trip_table, 915 trip - trip_table, 916 passive_delay); 917 if (result) 918 goto free_memory; 919 920 refcount_set(&tz->thermal_check_count, 3); 921 mutex_init(&tz->thermal_check_lock); 922 INIT_WORK(&tz->thermal_check_work, acpi_thermal_check_fn); 923 924 pr_info("%s [%s] (%ld C)\n", acpi_device_name(device), 925 acpi_device_bid(device), deci_kelvin_to_celsius(tz->temp_dk)); 926 927 result = acpi_dev_install_notify_handler(device, ACPI_DEVICE_NOTIFY, 928 acpi_thermal_notify, device); 929 if (result) 930 goto flush_wq; 931 932 return 0; 933 934 flush_wq: 935 flush_workqueue(acpi_thermal_pm_queue); 936 acpi_thermal_unregister_thermal_zone(tz); 937 free_memory: 938 acpi_thermal_free_thermal_zone(tz); 939 940 return result; 941 } 942 943 static void acpi_thermal_remove(struct acpi_device *device) 944 { 945 struct acpi_thermal *tz; 946 947 if (!device || !acpi_driver_data(device)) 948 return; 949 950 tz = acpi_driver_data(device); 951 952 acpi_dev_remove_notify_handler(device, ACPI_DEVICE_NOTIFY, 953 acpi_thermal_notify); 954 955 flush_workqueue(acpi_thermal_pm_queue); 956 acpi_thermal_unregister_thermal_zone(tz); 957 acpi_thermal_free_thermal_zone(tz); 958 } 959 960 #ifdef CONFIG_PM_SLEEP 961 static int acpi_thermal_suspend(struct device *dev) 962 { 963 /* Make sure the previously queued thermal check work has been done */ 964 flush_workqueue(acpi_thermal_pm_queue); 965 return 0; 966 } 967 968 static int acpi_thermal_resume(struct device *dev) 969 { 970 struct acpi_thermal *tz; 971 int i, j, power_state; 972 973 if (!dev) 974 return -EINVAL; 975 976 tz = acpi_driver_data(to_acpi_device(dev)); 977 if (!tz) 978 return -EINVAL; 979 980 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) { 981 struct acpi_thermal_trip *acpi_trip = &tz->trips.active[i].trip; 982 983 if (!acpi_thermal_trip_valid(acpi_trip)) 984 break; 985 986 for (j = 0; j < acpi_trip->devices.count; j++) { 987 acpi_bus_update_power(acpi_trip->devices.handles[j], 988 &power_state); 989 } 990 } 991 992 acpi_queue_thermal_check(tz); 993 994 return AE_OK; 995 } 996 #else 997 #define acpi_thermal_suspend NULL 998 #define acpi_thermal_resume NULL 999 #endif 1000 static SIMPLE_DEV_PM_OPS(acpi_thermal_pm, acpi_thermal_suspend, acpi_thermal_resume); 1001 1002 static const struct acpi_device_id thermal_device_ids[] = { 1003 {ACPI_THERMAL_HID, 0}, 1004 {"", 0}, 1005 }; 1006 MODULE_DEVICE_TABLE(acpi, thermal_device_ids); 1007 1008 static struct acpi_driver acpi_thermal_driver = { 1009 .name = "thermal", 1010 .class = ACPI_THERMAL_CLASS, 1011 .ids = thermal_device_ids, 1012 .ops = { 1013 .add = acpi_thermal_add, 1014 .remove = acpi_thermal_remove, 1015 }, 1016 .drv.pm = &acpi_thermal_pm, 1017 }; 1018 1019 static int thermal_act(const struct dmi_system_id *d) 1020 { 1021 if (act == 0) { 1022 pr_notice("%s detected: disabling all active thermal trip points\n", 1023 d->ident); 1024 act = -1; 1025 } 1026 return 0; 1027 } 1028 1029 static int thermal_nocrt(const struct dmi_system_id *d) 1030 { 1031 pr_notice("%s detected: disabling all critical thermal trip point actions.\n", 1032 d->ident); 1033 crt = -1; 1034 return 0; 1035 } 1036 1037 static int thermal_tzp(const struct dmi_system_id *d) 1038 { 1039 if (tzp == 0) { 1040 pr_notice("%s detected: enabling thermal zone polling\n", 1041 d->ident); 1042 tzp = 300; /* 300 dS = 30 Seconds */ 1043 } 1044 return 0; 1045 } 1046 1047 static int thermal_psv(const struct dmi_system_id *d) 1048 { 1049 if (psv == 0) { 1050 pr_notice("%s detected: disabling all passive thermal trip points\n", 1051 d->ident); 1052 psv = -1; 1053 } 1054 return 0; 1055 } 1056 1057 static const struct dmi_system_id thermal_dmi_table[] __initconst = { 1058 /* 1059 * Award BIOS on this AOpen makes thermal control almost worthless. 1060 * http://bugzilla.kernel.org/show_bug.cgi?id=8842 1061 */ 1062 { 1063 .callback = thermal_act, 1064 .ident = "AOpen i915GMm-HFS", 1065 .matches = { 1066 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"), 1067 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"), 1068 }, 1069 }, 1070 { 1071 .callback = thermal_psv, 1072 .ident = "AOpen i915GMm-HFS", 1073 .matches = { 1074 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"), 1075 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"), 1076 }, 1077 }, 1078 { 1079 .callback = thermal_tzp, 1080 .ident = "AOpen i915GMm-HFS", 1081 .matches = { 1082 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"), 1083 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"), 1084 }, 1085 }, 1086 { 1087 .callback = thermal_nocrt, 1088 .ident = "Gigabyte GA-7ZX", 1089 .matches = { 1090 DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."), 1091 DMI_MATCH(DMI_BOARD_NAME, "7ZX"), 1092 }, 1093 }, 1094 {} 1095 }; 1096 1097 static int __init acpi_thermal_init(void) 1098 { 1099 int result; 1100 1101 dmi_check_system(thermal_dmi_table); 1102 1103 if (off) { 1104 pr_notice("thermal control disabled\n"); 1105 return -ENODEV; 1106 } 1107 1108 acpi_thermal_pm_queue = alloc_workqueue("acpi_thermal_pm", 1109 WQ_HIGHPRI | WQ_MEM_RECLAIM, 0); 1110 if (!acpi_thermal_pm_queue) 1111 return -ENODEV; 1112 1113 result = acpi_bus_register_driver(&acpi_thermal_driver); 1114 if (result < 0) { 1115 destroy_workqueue(acpi_thermal_pm_queue); 1116 return -ENODEV; 1117 } 1118 1119 return 0; 1120 } 1121 1122 static void __exit acpi_thermal_exit(void) 1123 { 1124 acpi_bus_unregister_driver(&acpi_thermal_driver); 1125 destroy_workqueue(acpi_thermal_pm_queue); 1126 } 1127 1128 module_init(acpi_thermal_init); 1129 module_exit(acpi_thermal_exit); 1130 1131 MODULE_IMPORT_NS(ACPI_THERMAL); 1132 MODULE_AUTHOR("Paul Diefenbaugh"); 1133 MODULE_DESCRIPTION("ACPI Thermal Zone Driver"); 1134 MODULE_LICENSE("GPL"); 1135