drivers/acpi/thermal.c

   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 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/dmi.h>
  19 #include <linux/init.h>
  20 #include <linux/slab.h>
  21 #include <linux/types.h>
  22 #include <linux/jiffies.h>
  23 #include <linux/kmod.h>
  24 #include <linux/reboot.h>
  25 #include <linux/device.h>
  26 #include <linux/thermal.h>
  27 #include <linux/acpi.h>
  28 #include <linux/workqueue.h>
  29 #include <linux/uaccess.h>
  30
  31 #define PREFIX "ACPI: "
  32
  33 #define ACPI_THERMAL_CLASS              "thermal_zone"
  34 #define ACPI_THERMAL_DEVICE_NAME        "Thermal Zone"
  35 #define ACPI_THERMAL_NOTIFY_TEMPERATURE 0x80
  36 #define ACPI_THERMAL_NOTIFY_THRESHOLDS  0x81
  37 #define ACPI_THERMAL_NOTIFY_DEVICES     0x82
  38 #define ACPI_THERMAL_NOTIFY_CRITICAL    0xF0
  39 #define ACPI_THERMAL_NOTIFY_HOT         0xF1
  40 #define ACPI_THERMAL_MODE_ACTIVE        0x00
  41
  42 #define ACPI_THERMAL_MAX_ACTIVE 10
  43 #define ACPI_THERMAL_MAX_LIMIT_STR_LEN 65
  44
  45 #define _COMPONENT              ACPI_THERMAL_COMPONENT
  46 ACPI_MODULE_NAME("thermal");
  47
  48 MODULE_AUTHOR("Paul Diefenbaugh");
  49 MODULE_DESCRIPTION("ACPI Thermal Zone Driver");
  50 MODULE_LICENSE("GPL");
  51
  52 static int act;
  53 module_param(act, int, 0644);
  54 MODULE_PARM_DESC(act, "Disable or override all lowest active trip points.");
  55
  56 static int crt;
  57 module_param(crt, int, 0644);
  58 MODULE_PARM_DESC(crt, "Disable or lower all critical trip points.");
  59
  60 static int tzp;
  61 module_param(tzp, int, 0444);
  62 MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds.");
  63
  64 static int nocrt;
  65 module_param(nocrt, int, 0);
  66 MODULE_PARM_DESC(nocrt, "Set to take no action upon ACPI thermal zone critical trips points.");
  67
  68 static int off;
  69 module_param(off, int, 0);
  70 MODULE_PARM_DESC(off, "Set to disable ACPI thermal support.");
  71
  72 static int psv;
  73 module_param(psv, int, 0644);
  74 MODULE_PARM_DESC(psv, "Disable or override all passive trip points.");
  75
  76 static struct workqueue_struct *acpi_thermal_pm_queue;
  77
  78 static int acpi_thermal_add(struct acpi_device *device);
  79 static int acpi_thermal_remove(struct acpi_device *device);
  80 static void acpi_thermal_notify(struct acpi_device *device, u32 event);
  81
  82 static const struct acpi_device_id  thermal_device_ids[] = {
  83         {ACPI_THERMAL_HID, 0},
  84         {"", 0},
  85 };
  86 MODULE_DEVICE_TABLE(acpi, thermal_device_ids);
  87
  88 #ifdef CONFIG_PM_SLEEP
  89 static int acpi_thermal_suspend(struct device *dev);
  90 static int acpi_thermal_resume(struct device *dev);
  91 #else
  92 #define acpi_thermal_suspend NULL
  93 #define acpi_thermal_resume NULL
  94 #endif
  95 static SIMPLE_DEV_PM_OPS(acpi_thermal_pm, acpi_thermal_suspend, acpi_thermal_resume);
  96
  97 static struct acpi_driver acpi_thermal_driver = {
  98         .name = "thermal",
  99         .class = ACPI_THERMAL_CLASS,
 100         .ids = thermal_device_ids,
 101         .ops = {
 102                 .add = acpi_thermal_add,
 103                 .remove = acpi_thermal_remove,
 104                 .notify = acpi_thermal_notify,
 105                 },
 106         .drv.pm = &acpi_thermal_pm,
 107 };
 108
 109 struct acpi_thermal_state {
 110         u8 critical:1;
 111         u8 hot:1;
 112         u8 passive:1;
 113         u8 active:1;
 114         u8 reserved:4;
 115         int active_index;
 116 };
 117
 118 struct acpi_thermal_state_flags {
 119         u8 valid:1;
 120         u8 enabled:1;
 121         u8 reserved:6;
 122 };
 123
 124 struct acpi_thermal_critical {
 125         struct acpi_thermal_state_flags flags;
 126         unsigned long temperature;
 127 };
 128
 129 struct acpi_thermal_hot {
 130         struct acpi_thermal_state_flags flags;
 131         unsigned long temperature;
 132 };
 133
 134 struct acpi_thermal_passive {
 135         struct acpi_thermal_state_flags flags;
 136         unsigned long temperature;
 137         unsigned long tc1;
 138         unsigned long tc2;
 139         unsigned long tsp;
 140         struct acpi_handle_list devices;
 141 };
 142
 143 struct acpi_thermal_active {
 144         struct acpi_thermal_state_flags flags;
 145         unsigned long temperature;
 146         struct acpi_handle_list devices;
 147 };
 148
 149 struct acpi_thermal_trips {
 150         struct acpi_thermal_critical critical;
 151         struct acpi_thermal_hot hot;
 152         struct acpi_thermal_passive passive;
 153         struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE];
 154 };
 155
 156 struct acpi_thermal_flags {
 157         u8 cooling_mode:1;      /* _SCP */
 158         u8 devices:1;           /* _TZD */
 159         u8 reserved:6;
 160 };
 161
 162 struct acpi_thermal {
 163         struct acpi_device * device;
 164         acpi_bus_id name;
 165         unsigned long temperature;
 166         unsigned long last_temperature;
 167         unsigned long polling_frequency;
 168         volatile u8 zombie;
 169         struct acpi_thermal_flags flags;
 170         struct acpi_thermal_state state;
 171         struct acpi_thermal_trips trips;
 172         struct acpi_handle_list devices;
 173         struct thermal_zone_device *thermal_zone;
 174         int tz_enabled;
 175         int kelvin_offset;
 176         struct work_struct thermal_check_work;
 177 };
 178
 179 /* --------------------------------------------------------------------------
 180                              Thermal Zone Management
 181    -------------------------------------------------------------------------- */
 182
 183 static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
 184 {
 185         acpi_status status = AE_OK;
 186         unsigned long long tmp;
 187
 188         if (!tz)
 189                 return -EINVAL;
 190
 191         tz->last_temperature = tz->temperature;
 192
 193         status = acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tmp);
 194         if (ACPI_FAILURE(status))
 195                 return -ENODEV;
 196
 197         tz->temperature = tmp;
 198         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n",
 199                           tz->temperature));
 200
 201         return 0;
 202 }
 203
 204 static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
 205 {
 206         acpi_status status = AE_OK;
 207         unsigned long long tmp;
 208
 209         if (!tz)
 210                 return -EINVAL;
 211
 212         status = acpi_evaluate_integer(tz->device->handle, "_TZP", NULL, &tmp);
 213         if (ACPI_FAILURE(status))
 214                 return -ENODEV;
 215
 216         tz->polling_frequency = tmp;
 217         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n",
 218                           tz->polling_frequency));
 219
 220         return 0;
 221 }
 222
 223 static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
 224 {
 225         if (!tz)
 226                 return -EINVAL;
 227
 228         if (!acpi_has_method(tz->device->handle, "_SCP")) {
 229                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
 230                 return -ENODEV;
 231         } else if (ACPI_FAILURE(acpi_execute_simple_method(tz->device->handle,
 232                                                            "_SCP", mode))) {
 233                 return -ENODEV;
 234         }
 235
 236         return 0;
 237 }
 238
 239 #define ACPI_TRIPS_CRITICAL     0x01
 240 #define ACPI_TRIPS_HOT          0x02
 241 #define ACPI_TRIPS_PASSIVE      0x04
 242 #define ACPI_TRIPS_ACTIVE       0x08
 243 #define ACPI_TRIPS_DEVICES      0x10
 244
 245 #define ACPI_TRIPS_REFRESH_THRESHOLDS   (ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE)
 246 #define ACPI_TRIPS_REFRESH_DEVICES      ACPI_TRIPS_DEVICES
 247
 248 #define ACPI_TRIPS_INIT      (ACPI_TRIPS_CRITICAL | ACPI_TRIPS_HOT |    \
 249                               ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE |  \
 250                               ACPI_TRIPS_DEVICES)
 251
 252 /*
 253  * This exception is thrown out in two cases:
 254  * 1.An invalid trip point becomes invalid or a valid trip point becomes invalid
 255  *   when re-evaluating the AML code.
 256  * 2.TODO: Devices listed in _PSL, _ALx, _TZD may change.
 257  *   We need to re-bind the cooling devices of a thermal zone when this occurs.
 258  */
 259 #define ACPI_THERMAL_TRIPS_EXCEPTION(flags, str)        \
 260 do {    \
 261         if (flags != ACPI_TRIPS_INIT)   \
 262                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,      \
 263                 "ACPI thermal trip point %s changed\n"  \
 264                 "Please send acpidump to linux-acpi@vger.kernel.org", str)); \
 265 } while (0)
 266
 267 static int acpi_thermal_trips_update(struct acpi_thermal *tz, int flag)
 268 {
 269         acpi_status status = AE_OK;
 270         unsigned long long tmp;
 271         struct acpi_handle_list devices;
 272         int valid = 0;
 273         int i;
 274
 275         /* Critical Shutdown */
 276         if (flag & ACPI_TRIPS_CRITICAL) {
 277                 status = acpi_evaluate_integer(tz->device->handle,
 278                                 "_CRT", NULL, &tmp);
 279                 tz->trips.critical.temperature = tmp;
 280                 /*
 281                  * Treat freezing temperatures as invalid as well; some
 282                  * BIOSes return really low values and cause reboots at startup.
 283                  * Below zero (Celsius) values clearly aren't right for sure..
 284                  * ... so lets discard those as invalid.
 285                  */
 286                 if (ACPI_FAILURE(status)) {
 287                         tz->trips.critical.flags.valid = 0;
 288                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 289                                           "No critical threshold\n"));
 290                 } else if (tmp <= 2732) {
 291                         pr_warn(FW_BUG "Invalid critical threshold (%llu)\n",
 292                                 tmp);
 293                         tz->trips.critical.flags.valid = 0;
 294                 } else {
 295                         tz->trips.critical.flags.valid = 1;
 296                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 297                                           "Found critical threshold [%lu]\n",
 298                                           tz->trips.critical.temperature));
 299                 }
 300                 if (tz->trips.critical.flags.valid == 1) {
 301                         if (crt == -1) {
 302                                 tz->trips.critical.flags.valid = 0;
 303                         } else if (crt > 0) {
 304                                 unsigned long crt_k = CELSIUS_TO_DECI_KELVIN(crt);
 305                                 /*
 306                                  * Allow override critical threshold
 307                                  */
 308                                 if (crt_k > tz->trips.critical.temperature)
 309                                         pr_warn(PREFIX "Critical threshold %d C\n",
 310                                                 crt);
 311                                 tz->trips.critical.temperature = crt_k;
 312                         }
 313                 }
 314         }
 315
 316         /* Critical Sleep (optional) */
 317         if (flag & ACPI_TRIPS_HOT) {
 318                 status = acpi_evaluate_integer(tz->device->handle,
 319                                 "_HOT", NULL, &tmp);
 320                 if (ACPI_FAILURE(status)) {
 321                         tz->trips.hot.flags.valid = 0;
 322                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 323                                         "No hot threshold\n"));
 324                 } else {
 325                         tz->trips.hot.temperature = tmp;
 326                         tz->trips.hot.flags.valid = 1;
 327                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 328                                         "Found hot threshold [%lu]\n",
 329                                         tz->trips.hot.temperature));
 330                 }
 331         }
 332
 333         /* Passive (optional) */
 334         if (((flag & ACPI_TRIPS_PASSIVE) && tz->trips.passive.flags.valid) ||
 335                 (flag == ACPI_TRIPS_INIT)) {
 336                 valid = tz->trips.passive.flags.valid;
 337                 if (psv == -1) {
 338                         status = AE_SUPPORT;
 339                 } else if (psv > 0) {
 340                         tmp = CELSIUS_TO_DECI_KELVIN(psv);
 341                         status = AE_OK;
 342                 } else {
 343                         status = acpi_evaluate_integer(tz->device->handle,
 344                                 "_PSV", NULL, &tmp);
 345                 }
 346
 347                 if (ACPI_FAILURE(status))
 348                         tz->trips.passive.flags.valid = 0;
 349                 else {
 350                         tz->trips.passive.temperature = tmp;
 351                         tz->trips.passive.flags.valid = 1;
 352                         if (flag == ACPI_TRIPS_INIT) {
 353                                 status = acpi_evaluate_integer(
 354                                                 tz->device->handle, "_TC1",
 355                                                 NULL, &tmp);
 356                                 if (ACPI_FAILURE(status))
 357                                         tz->trips.passive.flags.valid = 0;
 358                                 else
 359                                         tz->trips.passive.tc1 = tmp;
 360                                 status = acpi_evaluate_integer(
 361                                                 tz->device->handle, "_TC2",
 362                                                 NULL, &tmp);
 363                                 if (ACPI_FAILURE(status))
 364                                         tz->trips.passive.flags.valid = 0;
 365                                 else
 366                                         tz->trips.passive.tc2 = tmp;
 367                                 status = acpi_evaluate_integer(
 368                                                 tz->device->handle, "_TSP",
 369                                                 NULL, &tmp);
 370                                 if (ACPI_FAILURE(status))
 371                                         tz->trips.passive.flags.valid = 0;
 372                                 else
 373                                         tz->trips.passive.tsp = tmp;
 374                         }
 375                 }
 376         }
 377         if ((flag & ACPI_TRIPS_DEVICES) && tz->trips.passive.flags.valid) {
 378                 memset(&devices, 0, sizeof(struct acpi_handle_list));
 379                 status = acpi_evaluate_reference(tz->device->handle, "_PSL",
 380                                                         NULL, &devices);
 381                 if (ACPI_FAILURE(status)) {
 382                         pr_warn(PREFIX "Invalid passive threshold\n");
 383                         tz->trips.passive.flags.valid = 0;
 384                 }
 385                 else
 386                         tz->trips.passive.flags.valid = 1;
 387
 388                 if (memcmp(&tz->trips.passive.devices, &devices,
 389                                 sizeof(struct acpi_handle_list))) {
 390                         memcpy(&tz->trips.passive.devices, &devices,
 391                                 sizeof(struct acpi_handle_list));
 392                         ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
 393                 }
 394         }
 395         if ((flag & ACPI_TRIPS_PASSIVE) || (flag & ACPI_TRIPS_DEVICES)) {
 396                 if (valid != tz->trips.passive.flags.valid)
 397                                 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "state");
 398         }
 399
 400         /* Active (optional) */
 401         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
 402                 char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
 403                 valid = tz->trips.active[i].flags.valid;
 404
 405                 if (act == -1)
 406                         break; /* disable all active trip points */
 407
 408                 if ((flag == ACPI_TRIPS_INIT) || ((flag & ACPI_TRIPS_ACTIVE) &&
 409                         tz->trips.active[i].flags.valid)) {
 410                         status = acpi_evaluate_integer(tz->device->handle,
 411                                                         name, NULL, &tmp);
 412                         if (ACPI_FAILURE(status)) {
 413                                 tz->trips.active[i].flags.valid = 0;
 414                                 if (i == 0)
 415                                         break;
 416                                 if (act <= 0)
 417                                         break;
 418                                 if (i == 1)
 419                                         tz->trips.active[0].temperature =
 420                                                 CELSIUS_TO_DECI_KELVIN(act);
 421                                 else
 422                                         /*
 423                                          * Don't allow override higher than
 424                                          * the next higher trip point
 425                                          */
 426                                         tz->trips.active[i - 1].temperature =
 427                                                 (tz->trips.active[i - 2].temperature <
 428                                                 CELSIUS_TO_DECI_KELVIN(act) ?
 429                                                 tz->trips.active[i - 2].temperature :
 430                                                 CELSIUS_TO_DECI_KELVIN(act));
 431                                 break;
 432                         } else {
 433                                 tz->trips.active[i].temperature = tmp;
 434                                 tz->trips.active[i].flags.valid = 1;
 435                         }
 436                 }
 437
 438                 name[2] = 'L';
 439                 if ((flag & ACPI_TRIPS_DEVICES) && tz->trips.active[i].flags.valid ) {
 440                         memset(&devices, 0, sizeof(struct acpi_handle_list));
 441                         status = acpi_evaluate_reference(tz->device->handle,
 442                                                 name, NULL, &devices);
 443                         if (ACPI_FAILURE(status)) {
 444                                 pr_warn(PREFIX "Invalid active%d threshold\n",
 445                                         i);
 446                                 tz->trips.active[i].flags.valid = 0;
 447                         }
 448                         else
 449                                 tz->trips.active[i].flags.valid = 1;
 450
 451                         if (memcmp(&tz->trips.active[i].devices, &devices,
 452                                         sizeof(struct acpi_handle_list))) {
 453                                 memcpy(&tz->trips.active[i].devices, &devices,
 454                                         sizeof(struct acpi_handle_list));
 455                                 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
 456                         }
 457                 }
 458                 if ((flag & ACPI_TRIPS_ACTIVE) || (flag & ACPI_TRIPS_DEVICES))
 459                         if (valid != tz->trips.active[i].flags.valid)
 460                                 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "state");
 461
 462                 if (!tz->trips.active[i].flags.valid)
 463                         break;
 464         }
 465
 466         if ((flag & ACPI_TRIPS_DEVICES)
 467             && acpi_has_method(tz->device->handle, "_TZD")) {
 468                 memset(&devices, 0, sizeof(devices));
 469                 status = acpi_evaluate_reference(tz->device->handle, "_TZD",
 470                                                 NULL, &devices);
 471                 if (ACPI_SUCCESS(status)
 472                     && memcmp(&tz->devices, &devices, sizeof(devices))) {
 473                         tz->devices = devices;
 474                         ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
 475                 }
 476         }
 477
 478         return 0;
 479 }
 480
 481 static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
 482 {
 483         int i, valid, ret = acpi_thermal_trips_update(tz, ACPI_TRIPS_INIT);
 484
 485         if (ret)
 486                 return ret;
 487
 488         valid = tz->trips.critical.flags.valid |
 489                 tz->trips.hot.flags.valid |
 490                 tz->trips.passive.flags.valid;
 491
 492         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
 493                 valid |= tz->trips.active[i].flags.valid;
 494
 495         if (!valid) {
 496                 pr_warn(FW_BUG "No valid trip found\n");
 497                 return -ENODEV;
 498         }
 499         return 0;
 500 }
 501
 502 static void acpi_thermal_check(void *data)
 503 {
 504         struct acpi_thermal *tz = data;
 505
 506         if (!tz->tz_enabled)
 507                 return;
 508
 509         thermal_zone_device_update(tz->thermal_zone,
 510                                    THERMAL_EVENT_UNSPECIFIED);
 511 }
 512
 513 /* sys I/F for generic thermal sysfs support */
 514
 515 static int thermal_get_temp(struct thermal_zone_device *thermal, int *temp)
 516 {
 517         struct acpi_thermal *tz = thermal->devdata;
 518         int result;
 519
 520         if (!tz)
 521                 return -EINVAL;
 522
 523         result = acpi_thermal_get_temperature(tz);
 524         if (result)
 525                 return result;
 526
 527         *temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(tz->temperature,
 528                                                         tz->kelvin_offset);
 529         return 0;
 530 }
 531
 532 static int thermal_get_mode(struct thermal_zone_device *thermal,
 533                                 enum thermal_device_mode *mode)
 534 {
 535         struct acpi_thermal *tz = thermal->devdata;
 536
 537         if (!tz)
 538                 return -EINVAL;
 539
 540         *mode = tz->tz_enabled ? THERMAL_DEVICE_ENABLED :
 541                 THERMAL_DEVICE_DISABLED;
 542
 543         return 0;
 544 }
 545
 546 static int thermal_set_mode(struct thermal_zone_device *thermal,
 547                                 enum thermal_device_mode mode)
 548 {
 549         struct acpi_thermal *tz = thermal->devdata;
 550         int enable;
 551
 552         if (!tz)
 553                 return -EINVAL;
 554
 555         /*
 556          * enable/disable thermal management from ACPI thermal driver
 557          */
 558         if (mode == THERMAL_DEVICE_ENABLED)
 559                 enable = 1;
 560         else if (mode == THERMAL_DEVICE_DISABLED) {
 561                 enable = 0;
 562                 pr_warn("thermal zone will be disabled\n");
 563         } else
 564                 return -EINVAL;
 565
 566         if (enable != tz->tz_enabled) {
 567                 tz->tz_enabled = enable;
 568                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 569                         "%s kernel ACPI thermal control\n",
 570                         tz->tz_enabled ? "Enable" : "Disable"));
 571                 acpi_thermal_check(tz);
 572         }
 573         return 0;
 574 }
 575
 576 static int thermal_get_trip_type(struct thermal_zone_device *thermal,
 577                                  int trip, enum thermal_trip_type *type)
 578 {
 579         struct acpi_thermal *tz = thermal->devdata;
 580         int i;
 581
 582         if (!tz || trip < 0)
 583                 return -EINVAL;
 584
 585         if (tz->trips.critical.flags.valid) {
 586                 if (!trip) {
 587                         *type = THERMAL_TRIP_CRITICAL;
 588                         return 0;
 589                 }
 590                 trip--;
 591         }
 592
 593         if (tz->trips.hot.flags.valid) {
 594                 if (!trip) {
 595                         *type = THERMAL_TRIP_HOT;
 596                         return 0;
 597                 }
 598                 trip--;
 599         }
 600
 601         if (tz->trips.passive.flags.valid) {
 602                 if (!trip) {
 603                         *type = THERMAL_TRIP_PASSIVE;
 604                         return 0;
 605                 }
 606                 trip--;
 607         }
 608
 609         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
 610                 tz->trips.active[i].flags.valid; i++) {
 611                 if (!trip) {
 612                         *type = THERMAL_TRIP_ACTIVE;
 613                         return 0;
 614                 }
 615                 trip--;
 616         }
 617
 618         return -EINVAL;
 619 }
 620
 621 static int thermal_get_trip_temp(struct thermal_zone_device *thermal,
 622                                  int trip, int *temp)
 623 {
 624         struct acpi_thermal *tz = thermal->devdata;
 625         int i;
 626
 627         if (!tz || trip < 0)
 628                 return -EINVAL;
 629
 630         if (tz->trips.critical.flags.valid) {
 631                 if (!trip) {
 632                         *temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
 633                                 tz->trips.critical.temperature,
 634                                 tz->kelvin_offset);
 635                         return 0;
 636                 }
 637                 trip--;
 638         }
 639
 640         if (tz->trips.hot.flags.valid) {
 641                 if (!trip) {
 642                         *temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
 643                                 tz->trips.hot.temperature,
 644                                 tz->kelvin_offset);
 645                         return 0;
 646                 }
 647                 trip--;
 648         }
 649
 650         if (tz->trips.passive.flags.valid) {
 651                 if (!trip) {
 652                         *temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
 653                                 tz->trips.passive.temperature,
 654                                 tz->kelvin_offset);
 655                         return 0;
 656                 }
 657                 trip--;
 658         }
 659
 660         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
 661                 tz->trips.active[i].flags.valid; i++) {
 662                 if (!trip) {
 663                         *temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
 664                                 tz->trips.active[i].temperature,
 665                                 tz->kelvin_offset);
 666                         return 0;
 667                 }
 668                 trip--;
 669         }
 670
 671         return -EINVAL;
 672 }
 673
 674 static int thermal_get_crit_temp(struct thermal_zone_device *thermal,
 675                                 int *temperature)
 676 {
 677         struct acpi_thermal *tz = thermal->devdata;
 678
 679         if (tz->trips.critical.flags.valid) {
 680                 *temperature = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
 681                                 tz->trips.critical.temperature,
 682                                 tz->kelvin_offset);
 683                 return 0;
 684         } else
 685                 return -EINVAL;
 686 }
 687
 688 static int thermal_get_trend(struct thermal_zone_device *thermal,
 689                                 int trip, enum thermal_trend *trend)
 690 {
 691         struct acpi_thermal *tz = thermal->devdata;
 692         enum thermal_trip_type type;
 693         int i;
 694
 695         if (thermal_get_trip_type(thermal, trip, &type))
 696                 return -EINVAL;
 697
 698         if (type == THERMAL_TRIP_ACTIVE) {
 699                 int trip_temp;
 700                 int temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
 701                                         tz->temperature, tz->kelvin_offset);
 702                 if (thermal_get_trip_temp(thermal, trip, &trip_temp))
 703                         return -EINVAL;
 704
 705                 if (temp > trip_temp) {
 706                         *trend = THERMAL_TREND_RAISING;
 707                         return 0;
 708                 } else {
 709                         /* Fall back on default trend */
 710                         return -EINVAL;
 711                 }
 712         }
 713
 714         /*
 715          * tz->temperature has already been updated by generic thermal layer,
 716          * before this callback being invoked
 717          */
 718         i = (tz->trips.passive.tc1 * (tz->temperature - tz->last_temperature))
 719                 + (tz->trips.passive.tc2
 720                 * (tz->temperature - tz->trips.passive.temperature));
 721
 722         if (i > 0)
 723                 *trend = THERMAL_TREND_RAISING;
 724         else if (i < 0)
 725                 *trend = THERMAL_TREND_DROPPING;
 726         else
 727                 *trend = THERMAL_TREND_STABLE;
 728         return 0;
 729 }
 730
 731
 732 static int thermal_notify(struct thermal_zone_device *thermal, int trip,
 733                            enum thermal_trip_type trip_type)
 734 {
 735         u8 type = 0;
 736         struct acpi_thermal *tz = thermal->devdata;
 737
 738         if (trip_type == THERMAL_TRIP_CRITICAL)
 739                 type = ACPI_THERMAL_NOTIFY_CRITICAL;
 740         else if (trip_type == THERMAL_TRIP_HOT)
 741                 type = ACPI_THERMAL_NOTIFY_HOT;
 742         else
 743                 return 0;
 744
 745         acpi_bus_generate_netlink_event(tz->device->pnp.device_class,
 746                                         dev_name(&tz->device->dev), type, 1);
 747
 748         if (trip_type == THERMAL_TRIP_CRITICAL && nocrt)
 749                 return 1;
 750
 751         return 0;
 752 }
 753
 754 static int acpi_thermal_cooling_device_cb(struct thermal_zone_device *thermal,
 755                                         struct thermal_cooling_device *cdev,
 756                                         bool bind)
 757 {
 758         struct acpi_device *device = cdev->devdata;
 759         struct acpi_thermal *tz = thermal->devdata;
 760         struct acpi_device *dev;
 761         acpi_status status;
 762         acpi_handle handle;
 763         int i;
 764         int j;
 765         int trip = -1;
 766         int result = 0;
 767
 768         if (tz->trips.critical.flags.valid)
 769                 trip++;
 770
 771         if (tz->trips.hot.flags.valid)
 772                 trip++;
 773
 774         if (tz->trips.passive.flags.valid) {
 775                 trip++;
 776                 for (i = 0; i < tz->trips.passive.devices.count;
 777                     i++) {
 778                         handle = tz->trips.passive.devices.handles[i];
 779                         status = acpi_bus_get_device(handle, &dev);
 780                         if (ACPI_FAILURE(status) || dev != device)
 781                                 continue;
 782                         if (bind)
 783                                 result =
 784                                         thermal_zone_bind_cooling_device
 785                                         (thermal, trip, cdev,
 786                                          THERMAL_NO_LIMIT, THERMAL_NO_LIMIT,
 787                                          THERMAL_WEIGHT_DEFAULT);
 788                         else
 789                                 result =
 790                                         thermal_zone_unbind_cooling_device
 791                                         (thermal, trip, cdev);
 792                         if (result)
 793                                 goto failed;
 794                 }
 795         }
 796
 797         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
 798                 if (!tz->trips.active[i].flags.valid)
 799                         break;
 800                 trip++;
 801                 for (j = 0;
 802                     j < tz->trips.active[i].devices.count;
 803                     j++) {
 804                         handle = tz->trips.active[i].devices.handles[j];
 805                         status = acpi_bus_get_device(handle, &dev);
 806                         if (ACPI_FAILURE(status) || dev != device)
 807                                 continue;
 808                         if (bind)
 809                                 result = thermal_zone_bind_cooling_device
 810                                         (thermal, trip, cdev,
 811                                          THERMAL_NO_LIMIT, THERMAL_NO_LIMIT,
 812                                          THERMAL_WEIGHT_DEFAULT);
 813                         else
 814                                 result = thermal_zone_unbind_cooling_device
 815                                         (thermal, trip, cdev);
 816                         if (result)
 817                                 goto failed;
 818                 }
 819         }
 820
 821         for (i = 0; i < tz->devices.count; i++) {
 822                 handle = tz->devices.handles[i];
 823                 status = acpi_bus_get_device(handle, &dev);
 824                 if (ACPI_SUCCESS(status) && (dev == device)) {
 825                         if (bind)
 826                                 result = thermal_zone_bind_cooling_device
 827                                                 (thermal, THERMAL_TRIPS_NONE,
 828                                                  cdev, THERMAL_NO_LIMIT,
 829                                                  THERMAL_NO_LIMIT,
 830                                                  THERMAL_WEIGHT_DEFAULT);
 831                         else
 832                                 result = thermal_zone_unbind_cooling_device
 833                                                 (thermal, THERMAL_TRIPS_NONE,
 834                                                  cdev);
 835                         if (result)
 836                                 goto failed;
 837                 }
 838         }
 839
 840 failed:
 841         return result;
 842 }
 843
 844 static int
 845 acpi_thermal_bind_cooling_device(struct thermal_zone_device *thermal,
 846                                         struct thermal_cooling_device *cdev)
 847 {
 848         return acpi_thermal_cooling_device_cb(thermal, cdev, true);
 849 }
 850
 851 static int
 852 acpi_thermal_unbind_cooling_device(struct thermal_zone_device *thermal,
 853                                         struct thermal_cooling_device *cdev)
 854 {
 855         return acpi_thermal_cooling_device_cb(thermal, cdev, false);
 856 }
 857
 858 static struct thermal_zone_device_ops acpi_thermal_zone_ops = {
 859         .bind = acpi_thermal_bind_cooling_device,
 860         .unbind = acpi_thermal_unbind_cooling_device,
 861         .get_temp = thermal_get_temp,
 862         .get_mode = thermal_get_mode,
 863         .set_mode = thermal_set_mode,
 864         .get_trip_type = thermal_get_trip_type,
 865         .get_trip_temp = thermal_get_trip_temp,
 866         .get_crit_temp = thermal_get_crit_temp,
 867         .get_trend = thermal_get_trend,
 868         .notify = thermal_notify,
 869 };
 870
 871 static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz)
 872 {
 873         int trips = 0;
 874         int result;
 875         acpi_status status;
 876         int i;
 877
 878         if (tz->trips.critical.flags.valid)
 879                 trips++;
 880
 881         if (tz->trips.hot.flags.valid)
 882                 trips++;
 883
 884         if (tz->trips.passive.flags.valid)
 885                 trips++;
 886
 887         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
 888                         tz->trips.active[i].flags.valid; i++, trips++);
 889
 890         if (tz->trips.passive.flags.valid)
 891                 tz->thermal_zone =
 892                         thermal_zone_device_register("acpitz", trips, 0, tz,
 893                                                 &acpi_thermal_zone_ops, NULL,
 894                                                      tz->trips.passive.tsp*100,
 895                                                      tz->polling_frequency*100);
 896         else
 897                 tz->thermal_zone =
 898                         thermal_zone_device_register("acpitz", trips, 0, tz,
 899                                                 &acpi_thermal_zone_ops, NULL,
 900                                                 0, tz->polling_frequency*100);
 901         if (IS_ERR(tz->thermal_zone))
 902                 return -ENODEV;
 903
 904         result = sysfs_create_link(&tz->device->dev.kobj,
 905                                    &tz->thermal_zone->device.kobj, "thermal_zone");
 906         if (result)
 907                 return result;
 908
 909         result = sysfs_create_link(&tz->thermal_zone->device.kobj,
 910                                    &tz->device->dev.kobj, "device");
 911         if (result)
 912                 return result;
 913
 914         status =  acpi_bus_attach_private_data(tz->device->handle,
 915                                                tz->thermal_zone);
 916         if (ACPI_FAILURE(status))
 917                 return -ENODEV;
 918
 919         tz->tz_enabled = 1;
 920
 921         dev_info(&tz->device->dev, "registered as thermal_zone%d\n",
 922                  tz->thermal_zone->id);
 923         return 0;
 924 }
 925
 926 static void acpi_thermal_unregister_thermal_zone(struct acpi_thermal *tz)
 927 {
 928         sysfs_remove_link(&tz->device->dev.kobj, "thermal_zone");
 929         sysfs_remove_link(&tz->thermal_zone->device.kobj, "device");
 930         thermal_zone_device_unregister(tz->thermal_zone);
 931         tz->thermal_zone = NULL;
 932         acpi_bus_detach_private_data(tz->device->handle);
 933 }
 934
 935
 936 /* --------------------------------------------------------------------------
 937                                  Driver Interface
 938    -------------------------------------------------------------------------- */
 939
 940 static void acpi_thermal_notify(struct acpi_device *device, u32 event)
 941 {
 942         struct acpi_thermal *tz = acpi_driver_data(device);
 943
 944
 945         if (!tz)
 946                 return;
 947
 948         switch (event) {
 949         case ACPI_THERMAL_NOTIFY_TEMPERATURE:
 950                 acpi_thermal_check(tz);
 951                 break;
 952         case ACPI_THERMAL_NOTIFY_THRESHOLDS:
 953                 acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_THRESHOLDS);
 954                 acpi_thermal_check(tz);
 955                 acpi_bus_generate_netlink_event(device->pnp.device_class,
 956                                                   dev_name(&device->dev), event, 0);
 957                 break;
 958         case ACPI_THERMAL_NOTIFY_DEVICES:
 959                 acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_DEVICES);
 960                 acpi_thermal_check(tz);
 961                 acpi_bus_generate_netlink_event(device->pnp.device_class,
 962                                                   dev_name(&device->dev), event, 0);
 963                 break;
 964         default:
 965                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 966                                   "Unsupported event [0x%x]\n", event));
 967                 break;
 968         }
 969 }
 970
 971 /*
 972  * On some platforms, the AML code has dependency about
 973  * the evaluating order of _TMP and _CRT/_HOT/_PSV/_ACx.
 974  * 1. On HP Pavilion G4-1016tx, _TMP must be invoked after
 975  *    /_CRT/_HOT/_PSV/_ACx, or else system will be power off.
 976  * 2. On HP Compaq 6715b/6715s, the return value of _PSV is 0
 977  *    if _TMP has never been evaluated.
 978  *
 979  * As this dependency is totally transparent to OS, evaluate
 980  * all of them once, in the order of _CRT/_HOT/_PSV/_ACx,
 981  * _TMP, before they are actually used.
 982  */
 983 static void acpi_thermal_aml_dependency_fix(struct acpi_thermal *tz)
 984 {
 985         acpi_handle handle = tz->device->handle;
 986         unsigned long long value;
 987         int i;
 988
 989         acpi_evaluate_integer(handle, "_CRT", NULL, &value);
 990         acpi_evaluate_integer(handle, "_HOT", NULL, &value);
 991         acpi_evaluate_integer(handle, "_PSV", NULL, &value);
 992         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
 993                 char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
 994                 acpi_status status;
 995
 996                 status = acpi_evaluate_integer(handle, name, NULL, &value);
 997                 if (status == AE_NOT_FOUND)
 998                         break;
 999         }
1000         acpi_evaluate_integer(handle, "_TMP", NULL, &value);
1001 }
1002
1003 static int acpi_thermal_get_info(struct acpi_thermal *tz)
1004 {
1005         int result = 0;
1006
1007
1008         if (!tz)
1009                 return -EINVAL;
1010
1011         acpi_thermal_aml_dependency_fix(tz);
1012
1013         /* Get trip points [_CRT, _PSV, etc.] (required) */
1014         result = acpi_thermal_get_trip_points(tz);
1015         if (result)
1016                 return result;
1017
1018         /* Get temperature [_TMP] (required) */
1019         result = acpi_thermal_get_temperature(tz);
1020         if (result)
1021                 return result;
1022
1023         /* Set the cooling mode [_SCP] to active cooling (default) */
1024         result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
1025         if (!result)
1026                 tz->flags.cooling_mode = 1;
1027
1028         /* Get default polling frequency [_TZP] (optional) */
1029         if (tzp)
1030                 tz->polling_frequency = tzp;
1031         else
1032                 acpi_thermal_get_polling_frequency(tz);
1033
1034         return 0;
1035 }
1036
1037 /*
1038  * The exact offset between Kelvin and degree Celsius is 273.15. However ACPI
1039  * handles temperature values with a single decimal place. As a consequence,
1040  * some implementations use an offset of 273.1 and others use an offset of
1041  * 273.2. Try to find out which one is being used, to present the most
1042  * accurate and visually appealing number.
1043  *
1044  * The heuristic below should work for all ACPI thermal zones which have a
1045  * critical trip point with a value being a multiple of 0.5 degree Celsius.
1046  */
1047 static void acpi_thermal_guess_offset(struct acpi_thermal *tz)
1048 {
1049         if (tz->trips.critical.flags.valid &&
1050             (tz->trips.critical.temperature % 5) == 1)
1051                 tz->kelvin_offset = 2731;
1052         else
1053                 tz->kelvin_offset = 2732;
1054 }
1055
1056 static void acpi_thermal_check_fn(struct work_struct *work)
1057 {
1058         struct acpi_thermal *tz = container_of(work, struct acpi_thermal,
1059                                                thermal_check_work);
1060         acpi_thermal_check(tz);
1061 }
1062
1063 static int acpi_thermal_add(struct acpi_device *device)
1064 {
1065         int result = 0;
1066         struct acpi_thermal *tz = NULL;
1067
1068
1069         if (!device)
1070                 return -EINVAL;
1071
1072         tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
1073         if (!tz)
1074                 return -ENOMEM;
1075
1076         tz->device = device;
1077         strcpy(tz->name, device->pnp.bus_id);
1078         strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
1079         strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
1080         device->driver_data = tz;
1081
1082         result = acpi_thermal_get_info(tz);
1083         if (result)
1084                 goto free_memory;
1085
1086         acpi_thermal_guess_offset(tz);
1087
1088         result = acpi_thermal_register_thermal_zone(tz);
1089         if (result)
1090                 goto free_memory;
1091
1092         INIT_WORK(&tz->thermal_check_work, acpi_thermal_check_fn);
1093
1094         pr_info(PREFIX "%s [%s] (%ld C)\n", acpi_device_name(device),
1095                 acpi_device_bid(device), DECI_KELVIN_TO_CELSIUS(tz->temperature));
1096         goto end;
1097
1098 free_memory:
1099         kfree(tz);
1100 end:
1101         return result;
1102 }
1103
1104 static int acpi_thermal_remove(struct acpi_device *device)
1105 {
1106         struct acpi_thermal *tz = NULL;
1107
1108         if (!device || !acpi_driver_data(device))
1109                 return -EINVAL;
1110
1111         flush_workqueue(acpi_thermal_pm_queue);
1112         tz = acpi_driver_data(device);
1113
1114         acpi_thermal_unregister_thermal_zone(tz);
1115         kfree(tz);
1116         return 0;
1117 }
1118
1119 #ifdef CONFIG_PM_SLEEP
1120 static int acpi_thermal_suspend(struct device *dev)
1121 {
1122         /* Make sure the previously queued thermal check work has been done */
1123         flush_workqueue(acpi_thermal_pm_queue);
1124         return 0;
1125 }
1126
1127 static int acpi_thermal_resume(struct device *dev)
1128 {
1129         struct acpi_thermal *tz;
1130         int i, j, power_state, result;
1131
1132         if (!dev)
1133                 return -EINVAL;
1134
1135         tz = acpi_driver_data(to_acpi_device(dev));
1136         if (!tz)
1137                 return -EINVAL;
1138
1139         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1140                 if (!(&tz->trips.active[i]))
1141                         break;
1142                 if (!tz->trips.active[i].flags.valid)
1143                         break;
1144                 tz->trips.active[i].flags.enabled = 1;
1145                 for (j = 0; j < tz->trips.active[i].devices.count; j++) {
1146                         result = acpi_bus_update_power(
1147                                         tz->trips.active[i].devices.handles[j],
1148                                         &power_state);
1149                         if (result || (power_state != ACPI_STATE_D0)) {
1150                                 tz->trips.active[i].flags.enabled = 0;
1151                                 break;
1152                         }
1153                 }
1154                 tz->state.active |= tz->trips.active[i].flags.enabled;
1155         }
1156
1157         queue_work(acpi_thermal_pm_queue, &tz->thermal_check_work);
1158
1159         return AE_OK;
1160 }
1161 #endif
1162
1163 static int thermal_act(const struct dmi_system_id *d) {
1164
1165         if (act == 0) {
1166                 pr_notice(PREFIX "%s detected: "
1167                           "disabling all active thermal trip points\n", d->ident);
1168                 act = -1;
1169         }
1170         return 0;
1171 }
1172 static int thermal_nocrt(const struct dmi_system_id *d) {
1173
1174         pr_notice(PREFIX "%s detected: "
1175                   "disabling all critical thermal trip point actions.\n", d->ident);
1176         nocrt = 1;
1177         return 0;
1178 }
1179 static int thermal_tzp(const struct dmi_system_id *d) {
1180
1181         if (tzp == 0) {
1182                 pr_notice(PREFIX "%s detected: "
1183                           "enabling thermal zone polling\n", d->ident);
1184                 tzp = 300;      /* 300 dS = 30 Seconds */
1185         }
1186         return 0;
1187 }
1188 static int thermal_psv(const struct dmi_system_id *d) {
1189
1190         if (psv == 0) {
1191                 pr_notice(PREFIX "%s detected: "
1192                           "disabling all passive thermal trip points\n", d->ident);
1193                 psv = -1;
1194         }
1195         return 0;
1196 }
1197
1198 static const struct dmi_system_id thermal_dmi_table[] __initconst = {
1199         /*
1200          * Award BIOS on this AOpen makes thermal control almost worthless.
1201          * http://bugzilla.kernel.org/show_bug.cgi?id=8842
1202          */
1203         {
1204          .callback = thermal_act,
1205          .ident = "AOpen i915GMm-HFS",
1206          .matches = {
1207                 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1208                 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1209                 },
1210         },
1211         {
1212          .callback = thermal_psv,
1213          .ident = "AOpen i915GMm-HFS",
1214          .matches = {
1215                 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1216                 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1217                 },
1218         },
1219         {
1220          .callback = thermal_tzp,
1221          .ident = "AOpen i915GMm-HFS",
1222          .matches = {
1223                 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1224                 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1225                 },
1226         },
1227         {
1228          .callback = thermal_nocrt,
1229          .ident = "Gigabyte GA-7ZX",
1230          .matches = {
1231                 DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
1232                 DMI_MATCH(DMI_BOARD_NAME, "7ZX"),
1233                 },
1234         },
1235         {}
1236 };
1237
1238 static int __init acpi_thermal_init(void)
1239 {
1240         int result = 0;
1241
1242         dmi_check_system(thermal_dmi_table);
1243
1244         if (off) {
1245                 pr_notice(PREFIX "thermal control disabled\n");
1246                 return -ENODEV;
1247         }
1248
1249         acpi_thermal_pm_queue = alloc_workqueue("acpi_thermal_pm",
1250                                                 WQ_HIGHPRI | WQ_MEM_RECLAIM, 0);
1251         if (!acpi_thermal_pm_queue)
1252                 return -ENODEV;
1253
1254         result = acpi_bus_register_driver(&acpi_thermal_driver);
1255         if (result < 0) {
1256                 destroy_workqueue(acpi_thermal_pm_queue);
1257                 return -ENODEV;
1258         }
1259
1260         return 0;
1261 }
1262
1263 static void __exit acpi_thermal_exit(void)
1264 {
1265         acpi_bus_unregister_driver(&acpi_thermal_driver);
1266         destroy_workqueue(acpi_thermal_pm_queue);
1267
1268         return;
1269 }
1270
1271 module_init(acpi_thermal_init);
1272 module_exit(acpi_thermal_exit);