drivers/acpi/thermal.c

   1 /*
   2  *  acpi_thermal.c - ACPI Thermal Zone Driver ($Revision: 41 $)
   3  *
   4  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
   5  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   6  *
   7  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or (at
  12  *  your option) any later version.
  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  *  This driver fully implements the ACPI thermal policy as described in the
  26  *  ACPI 2.0 Specification.
  27  *
  28  *  TBD: 1. Implement passive cooling hysteresis.
  29  *       2. Enhance passive cooling (CPU) states/limit interface to support
  30  *          concepts of 'multiple limiters', upper/lower limits, etc.
  31  *
  32  */
  33
  34 #include <linux/kernel.h>
  35 #include <linux/module.h>
  36 #include <linux/dmi.h>
  37 #include <linux/init.h>
  38 #include <linux/slab.h>
  39 #include <linux/types.h>
  40 #include <linux/proc_fs.h>
  41 #include <linux/jiffies.h>
  42 #include <linux/kmod.h>
  43 #include <linux/seq_file.h>
  44 #include <linux/reboot.h>
  45 #include <linux/device.h>
  46 #include <asm/uaccess.h>
  47 #include <linux/thermal.h>
  48 #include <acpi/acpi_bus.h>
  49 #include <acpi/acpi_drivers.h>
  50
  51 #define PREFIX "ACPI: "
  52
  53 #define ACPI_THERMAL_CLASS              "thermal_zone"
  54 #define ACPI_THERMAL_DEVICE_NAME        "Thermal Zone"
  55 #define ACPI_THERMAL_FILE_STATE         "state"
  56 #define ACPI_THERMAL_FILE_TEMPERATURE   "temperature"
  57 #define ACPI_THERMAL_FILE_TRIP_POINTS   "trip_points"
  58 #define ACPI_THERMAL_FILE_COOLING_MODE  "cooling_mode"
  59 #define ACPI_THERMAL_FILE_POLLING_FREQ  "polling_frequency"
  60 #define ACPI_THERMAL_NOTIFY_TEMPERATURE 0x80
  61 #define ACPI_THERMAL_NOTIFY_THRESHOLDS  0x81
  62 #define ACPI_THERMAL_NOTIFY_DEVICES     0x82
  63 #define ACPI_THERMAL_NOTIFY_CRITICAL    0xF0
  64 #define ACPI_THERMAL_NOTIFY_HOT         0xF1
  65 #define ACPI_THERMAL_MODE_ACTIVE        0x00
  66
  67 #define ACPI_THERMAL_MAX_ACTIVE 10
  68 #define ACPI_THERMAL_MAX_LIMIT_STR_LEN 65
  69
  70 #define _COMPONENT              ACPI_THERMAL_COMPONENT
  71 ACPI_MODULE_NAME("thermal");
  72
  73 MODULE_AUTHOR("Paul Diefenbaugh");
  74 MODULE_DESCRIPTION("ACPI Thermal Zone Driver");
  75 MODULE_LICENSE("GPL");
  76
  77 static int act;
  78 module_param(act, int, 0644);
  79 MODULE_PARM_DESC(act, "Disable or override all lowest active trip points.");
  80
  81 static int crt;
  82 module_param(crt, int, 0644);
  83 MODULE_PARM_DESC(crt, "Disable or lower all critical trip points.");
  84
  85 static int tzp;
  86 module_param(tzp, int, 0444);
  87 MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds.");
  88
  89 static int nocrt;
  90 module_param(nocrt, int, 0);
  91 MODULE_PARM_DESC(nocrt, "Set to take no action upon ACPI thermal zone critical trips points.");
  92
  93 static int off;
  94 module_param(off, int, 0);
  95 MODULE_PARM_DESC(off, "Set to disable ACPI thermal support.");
  96
  97 static int psv;
  98 module_param(psv, int, 0644);
  99 MODULE_PARM_DESC(psv, "Disable or override all passive trip points.");
 100
 101 static int acpi_thermal_add(struct acpi_device *device);
 102 static int acpi_thermal_remove(struct acpi_device *device, int type);
 103 static int acpi_thermal_resume(struct acpi_device *device);
 104 static void acpi_thermal_notify(struct acpi_device *device, u32 event);
 105 static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file);
 106 static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file);
 107 static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file);
 108 static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file);
 109 static ssize_t acpi_thermal_write_cooling_mode(struct file *,
 110                                                const char __user *, size_t,
 111                                                loff_t *);
 112 static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
 113 static ssize_t acpi_thermal_write_polling(struct file *, const char __user *,
 114                                           size_t, loff_t *);
 115
 116 static const struct acpi_device_id  thermal_device_ids[] = {
 117         {ACPI_THERMAL_HID, 0},
 118         {"", 0},
 119 };
 120 MODULE_DEVICE_TABLE(acpi, thermal_device_ids);
 121
 122 static struct acpi_driver acpi_thermal_driver = {
 123         .name = "thermal",
 124         .class = ACPI_THERMAL_CLASS,
 125         .ids = thermal_device_ids,
 126         .ops = {
 127                 .add = acpi_thermal_add,
 128                 .remove = acpi_thermal_remove,
 129                 .resume = acpi_thermal_resume,
 130                 .notify = acpi_thermal_notify,
 131                 },
 132 };
 133
 134 struct acpi_thermal_state {
 135         u8 critical:1;
 136         u8 hot:1;
 137         u8 passive:1;
 138         u8 active:1;
 139         u8 reserved:4;
 140         int active_index;
 141 };
 142
 143 struct acpi_thermal_state_flags {
 144         u8 valid:1;
 145         u8 enabled:1;
 146         u8 reserved:6;
 147 };
 148
 149 struct acpi_thermal_critical {
 150         struct acpi_thermal_state_flags flags;
 151         unsigned long temperature;
 152 };
 153
 154 struct acpi_thermal_hot {
 155         struct acpi_thermal_state_flags flags;
 156         unsigned long temperature;
 157 };
 158
 159 struct acpi_thermal_passive {
 160         struct acpi_thermal_state_flags flags;
 161         unsigned long temperature;
 162         unsigned long tc1;
 163         unsigned long tc2;
 164         unsigned long tsp;
 165         struct acpi_handle_list devices;
 166 };
 167
 168 struct acpi_thermal_active {
 169         struct acpi_thermal_state_flags flags;
 170         unsigned long temperature;
 171         struct acpi_handle_list devices;
 172 };
 173
 174 struct acpi_thermal_trips {
 175         struct acpi_thermal_critical critical;
 176         struct acpi_thermal_hot hot;
 177         struct acpi_thermal_passive passive;
 178         struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE];
 179 };
 180
 181 struct acpi_thermal_flags {
 182         u8 cooling_mode:1;      /* _SCP */
 183         u8 devices:1;           /* _TZD */
 184         u8 reserved:6;
 185 };
 186
 187 struct acpi_thermal {
 188         struct acpi_device * device;
 189         acpi_bus_id name;
 190         unsigned long temperature;
 191         unsigned long last_temperature;
 192         unsigned long polling_frequency;
 193         volatile u8 zombie;
 194         struct acpi_thermal_flags flags;
 195         struct acpi_thermal_state state;
 196         struct acpi_thermal_trips trips;
 197         struct acpi_handle_list devices;
 198         struct thermal_zone_device *thermal_zone;
 199         int tz_enabled;
 200         int kelvin_offset;
 201         struct mutex lock;
 202 };
 203
 204 static const struct file_operations acpi_thermal_state_fops = {
 205         .owner = THIS_MODULE,
 206         .open = acpi_thermal_state_open_fs,
 207         .read = seq_read,
 208         .llseek = seq_lseek,
 209         .release = single_release,
 210 };
 211
 212 static const struct file_operations acpi_thermal_temp_fops = {
 213         .owner = THIS_MODULE,
 214         .open = acpi_thermal_temp_open_fs,
 215         .read = seq_read,
 216         .llseek = seq_lseek,
 217         .release = single_release,
 218 };
 219
 220 static const struct file_operations acpi_thermal_trip_fops = {
 221         .owner = THIS_MODULE,
 222         .open = acpi_thermal_trip_open_fs,
 223         .read = seq_read,
 224         .llseek = seq_lseek,
 225         .release = single_release,
 226 };
 227
 228 static const struct file_operations acpi_thermal_cooling_fops = {
 229         .owner = THIS_MODULE,
 230         .open = acpi_thermal_cooling_open_fs,
 231         .read = seq_read,
 232         .write = acpi_thermal_write_cooling_mode,
 233         .llseek = seq_lseek,
 234         .release = single_release,
 235 };
 236
 237 static const struct file_operations acpi_thermal_polling_fops = {
 238         .owner = THIS_MODULE,
 239         .open = acpi_thermal_polling_open_fs,
 240         .read = seq_read,
 241         .write = acpi_thermal_write_polling,
 242         .llseek = seq_lseek,
 243         .release = single_release,
 244 };
 245
 246 /* --------------------------------------------------------------------------
 247                              Thermal Zone Management
 248    -------------------------------------------------------------------------- */
 249
 250 static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
 251 {
 252         acpi_status status = AE_OK;
 253         unsigned long long tmp;
 254
 255         if (!tz)
 256                 return -EINVAL;
 257
 258         tz->last_temperature = tz->temperature;
 259
 260         status = acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tmp);
 261         if (ACPI_FAILURE(status))
 262                 return -ENODEV;
 263
 264         tz->temperature = tmp;
 265         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n",
 266                           tz->temperature));
 267
 268         return 0;
 269 }
 270
 271 static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
 272 {
 273         acpi_status status = AE_OK;
 274         unsigned long long tmp;
 275
 276         if (!tz)
 277                 return -EINVAL;
 278
 279         status = acpi_evaluate_integer(tz->device->handle, "_TZP", NULL, &tmp);
 280         if (ACPI_FAILURE(status))
 281                 return -ENODEV;
 282
 283         tz->polling_frequency = tmp;
 284         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n",
 285                           tz->polling_frequency));
 286
 287         return 0;
 288 }
 289
 290 static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
 291 {
 292
 293         if (!tz)
 294                 return -EINVAL;
 295
 296         tz->polling_frequency = seconds * 10;   /* Convert value to deci-seconds */
 297
 298         tz->thermal_zone->polling_delay = seconds * 1000;
 299
 300         if (tz->tz_enabled)
 301                 thermal_zone_device_update(tz->thermal_zone);
 302
 303         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 304                           "Polling frequency set to %lu seconds\n",
 305                           tz->polling_frequency/10));
 306
 307         return 0;
 308 }
 309
 310 static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
 311 {
 312         acpi_status status = AE_OK;
 313         union acpi_object arg0 = { ACPI_TYPE_INTEGER };
 314         struct acpi_object_list arg_list = { 1, &arg0 };
 315         acpi_handle handle = NULL;
 316
 317
 318         if (!tz)
 319                 return -EINVAL;
 320
 321         status = acpi_get_handle(tz->device->handle, "_SCP", &handle);
 322         if (ACPI_FAILURE(status)) {
 323                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
 324                 return -ENODEV;
 325         }
 326
 327         arg0.integer.value = mode;
 328
 329         status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
 330         if (ACPI_FAILURE(status))
 331                 return -ENODEV;
 332
 333         return 0;
 334 }
 335
 336 #define ACPI_TRIPS_CRITICAL     0x01
 337 #define ACPI_TRIPS_HOT          0x02
 338 #define ACPI_TRIPS_PASSIVE      0x04
 339 #define ACPI_TRIPS_ACTIVE       0x08
 340 #define ACPI_TRIPS_DEVICES      0x10
 341
 342 #define ACPI_TRIPS_REFRESH_THRESHOLDS   (ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE)
 343 #define ACPI_TRIPS_REFRESH_DEVICES      ACPI_TRIPS_DEVICES
 344
 345 #define ACPI_TRIPS_INIT      (ACPI_TRIPS_CRITICAL | ACPI_TRIPS_HOT |    \
 346                               ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE |  \
 347                               ACPI_TRIPS_DEVICES)
 348
 349 /*
 350  * This exception is thrown out in two cases:
 351  * 1.An invalid trip point becomes invalid or a valid trip point becomes invalid
 352  *   when re-evaluating the AML code.
 353  * 2.TODO: Devices listed in _PSL, _ALx, _TZD may change.
 354  *   We need to re-bind the cooling devices of a thermal zone when this occurs.
 355  */
 356 #define ACPI_THERMAL_TRIPS_EXCEPTION(flags, str)        \
 357 do {    \
 358         if (flags != ACPI_TRIPS_INIT)   \
 359                 ACPI_EXCEPTION((AE_INFO, AE_ERROR,      \
 360                 "ACPI thermal trip point %s changed\n"  \
 361                 "Please send acpidump to linux-acpi@vger.kernel.org\n", str)); \
 362 } while (0)
 363
 364 static int acpi_thermal_trips_update(struct acpi_thermal *tz, int flag)
 365 {
 366         acpi_status status = AE_OK;
 367         unsigned long long tmp;
 368         struct acpi_handle_list devices;
 369         int valid = 0;
 370         int i;
 371
 372         /* Critical Shutdown */
 373         if (flag & ACPI_TRIPS_CRITICAL) {
 374                 status = acpi_evaluate_integer(tz->device->handle,
 375                                 "_CRT", NULL, &tmp);
 376                 tz->trips.critical.temperature = tmp;
 377                 /*
 378                  * Treat freezing temperatures as invalid as well; some
 379                  * BIOSes return really low values and cause reboots at startup.
 380                  * Below zero (Celsius) values clearly aren't right for sure..
 381                  * ... so lets discard those as invalid.
 382                  */
 383                 if (ACPI_FAILURE(status)) {
 384                         tz->trips.critical.flags.valid = 0;
 385                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 386                                           "No critical threshold\n"));
 387                 } else if (tmp <= 2732) {
 388                         printk(KERN_WARNING FW_BUG "Invalid critical threshold "
 389                                "(%llu)\n", tmp);
 390                         tz->trips.critical.flags.valid = 0;
 391                 } else {
 392                         tz->trips.critical.flags.valid = 1;
 393                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 394                                           "Found critical threshold [%lu]\n",
 395                                           tz->trips.critical.temperature));
 396                 }
 397                 if (tz->trips.critical.flags.valid == 1) {
 398                         if (crt == -1) {
 399                                 tz->trips.critical.flags.valid = 0;
 400                         } else if (crt > 0) {
 401                                 unsigned long crt_k = CELSIUS_TO_KELVIN(crt);
 402                                 /*
 403                                  * Allow override critical threshold
 404                                  */
 405                                 if (crt_k > tz->trips.critical.temperature)
 406                                         printk(KERN_WARNING PREFIX
 407                                                 "Critical threshold %d C\n", crt);
 408                                 tz->trips.critical.temperature = crt_k;
 409                         }
 410                 }
 411         }
 412
 413         /* Critical Sleep (optional) */
 414         if (flag & ACPI_TRIPS_HOT) {
 415                 status = acpi_evaluate_integer(tz->device->handle,
 416                                 "_HOT", NULL, &tmp);
 417                 if (ACPI_FAILURE(status)) {
 418                         tz->trips.hot.flags.valid = 0;
 419                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 420                                         "No hot threshold\n"));
 421                 } else {
 422                         tz->trips.hot.temperature = tmp;
 423                         tz->trips.hot.flags.valid = 1;
 424                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 425                                         "Found hot threshold [%lu]\n",
 426                                         tz->trips.critical.temperature));
 427                 }
 428         }
 429
 430         /* Passive (optional) */
 431         if (((flag & ACPI_TRIPS_PASSIVE) && tz->trips.passive.flags.valid) ||
 432                 (flag == ACPI_TRIPS_INIT)) {
 433                 valid = tz->trips.passive.flags.valid;
 434                 if (psv == -1) {
 435                         status = AE_SUPPORT;
 436                 } else if (psv > 0) {
 437                         tmp = CELSIUS_TO_KELVIN(psv);
 438                         status = AE_OK;
 439                 } else {
 440                         status = acpi_evaluate_integer(tz->device->handle,
 441                                 "_PSV", NULL, &tmp);
 442                 }
 443
 444                 if (ACPI_FAILURE(status))
 445                         tz->trips.passive.flags.valid = 0;
 446                 else {
 447                         tz->trips.passive.temperature = tmp;
 448                         tz->trips.passive.flags.valid = 1;
 449                         if (flag == ACPI_TRIPS_INIT) {
 450                                 status = acpi_evaluate_integer(
 451                                                 tz->device->handle, "_TC1",
 452                                                 NULL, &tmp);
 453                                 if (ACPI_FAILURE(status))
 454                                         tz->trips.passive.flags.valid = 0;
 455                                 else
 456                                         tz->trips.passive.tc1 = tmp;
 457                                 status = acpi_evaluate_integer(
 458                                                 tz->device->handle, "_TC2",
 459                                                 NULL, &tmp);
 460                                 if (ACPI_FAILURE(status))
 461                                         tz->trips.passive.flags.valid = 0;
 462                                 else
 463                                         tz->trips.passive.tc2 = tmp;
 464                                 status = acpi_evaluate_integer(
 465                                                 tz->device->handle, "_TSP",
 466                                                 NULL, &tmp);
 467                                 if (ACPI_FAILURE(status))
 468                                         tz->trips.passive.flags.valid = 0;
 469                                 else
 470                                         tz->trips.passive.tsp = tmp;
 471                         }
 472                 }
 473         }
 474         if ((flag & ACPI_TRIPS_DEVICES) && tz->trips.passive.flags.valid) {
 475                 memset(&devices, 0, sizeof(struct acpi_handle_list));
 476                 status = acpi_evaluate_reference(tz->device->handle, "_PSL",
 477                                                         NULL, &devices);
 478                 if (ACPI_FAILURE(status)) {
 479                         printk(KERN_WARNING PREFIX
 480                                 "Invalid passive threshold\n");
 481                         tz->trips.passive.flags.valid = 0;
 482                 }
 483                 else
 484                         tz->trips.passive.flags.valid = 1;
 485
 486                 if (memcmp(&tz->trips.passive.devices, &devices,
 487                                 sizeof(struct acpi_handle_list))) {
 488                         memcpy(&tz->trips.passive.devices, &devices,
 489                                 sizeof(struct acpi_handle_list));
 490                         ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
 491                 }
 492         }
 493         if ((flag & ACPI_TRIPS_PASSIVE) || (flag & ACPI_TRIPS_DEVICES)) {
 494                 if (valid != tz->trips.passive.flags.valid)
 495                                 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "state");
 496         }
 497
 498         /* Active (optional) */
 499         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
 500                 char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
 501                 valid = tz->trips.active[i].flags.valid;
 502
 503                 if (act == -1)
 504                         break; /* disable all active trip points */
 505
 506                 if ((flag == ACPI_TRIPS_INIT) || ((flag & ACPI_TRIPS_ACTIVE) &&
 507                         tz->trips.active[i].flags.valid)) {
 508                         status = acpi_evaluate_integer(tz->device->handle,
 509                                                         name, NULL, &tmp);
 510                         if (ACPI_FAILURE(status)) {
 511                                 tz->trips.active[i].flags.valid = 0;
 512                                 if (i == 0)
 513                                         break;
 514                                 if (act <= 0)
 515                                         break;
 516                                 if (i == 1)
 517                                         tz->trips.active[0].temperature =
 518                                                 CELSIUS_TO_KELVIN(act);
 519                                 else
 520                                         /*
 521                                          * Don't allow override higher than
 522                                          * the next higher trip point
 523                                          */
 524                                         tz->trips.active[i - 1].temperature =
 525                                                 (tz->trips.active[i - 2].temperature <
 526                                                 CELSIUS_TO_KELVIN(act) ?
 527                                                 tz->trips.active[i - 2].temperature :
 528                                                 CELSIUS_TO_KELVIN(act));
 529                                 break;
 530                         } else {
 531                                 tz->trips.active[i].temperature = tmp;
 532                                 tz->trips.active[i].flags.valid = 1;
 533                         }
 534                 }
 535
 536                 name[2] = 'L';
 537                 if ((flag & ACPI_TRIPS_DEVICES) && tz->trips.active[i].flags.valid ) {
 538                         memset(&devices, 0, sizeof(struct acpi_handle_list));
 539                         status = acpi_evaluate_reference(tz->device->handle,
 540                                                 name, NULL, &devices);
 541                         if (ACPI_FAILURE(status)) {
 542                                 printk(KERN_WARNING PREFIX
 543                                         "Invalid active%d threshold\n", i);
 544                                 tz->trips.active[i].flags.valid = 0;
 545                         }
 546                         else
 547                                 tz->trips.active[i].flags.valid = 1;
 548
 549                         if (memcmp(&tz->trips.active[i].devices, &devices,
 550                                         sizeof(struct acpi_handle_list))) {
 551                                 memcpy(&tz->trips.active[i].devices, &devices,
 552                                         sizeof(struct acpi_handle_list));
 553                                 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
 554                         }
 555                 }
 556                 if ((flag & ACPI_TRIPS_ACTIVE) || (flag & ACPI_TRIPS_DEVICES))
 557                         if (valid != tz->trips.active[i].flags.valid)
 558                                 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "state");
 559
 560                 if (!tz->trips.active[i].flags.valid)
 561                         break;
 562         }
 563
 564         if (flag & ACPI_TRIPS_DEVICES) {
 565                 memset(&devices, 0, sizeof(struct acpi_handle_list));
 566                 status = acpi_evaluate_reference(tz->device->handle, "_TZD",
 567                                                 NULL, &devices);
 568                 if (memcmp(&tz->devices, &devices,
 569                                 sizeof(struct acpi_handle_list))) {
 570                         memcpy(&tz->devices, &devices,
 571                                 sizeof(struct acpi_handle_list));
 572                         ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
 573                 }
 574         }
 575
 576         return 0;
 577 }
 578
 579 static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
 580 {
 581         int i, valid, ret = acpi_thermal_trips_update(tz, ACPI_TRIPS_INIT);
 582
 583         if (ret)
 584                 return ret;
 585
 586         valid = tz->trips.critical.flags.valid |
 587                 tz->trips.hot.flags.valid |
 588                 tz->trips.passive.flags.valid;
 589
 590         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
 591                 valid |= tz->trips.active[i].flags.valid;
 592
 593         if (!valid) {
 594                 printk(KERN_WARNING FW_BUG "No valid trip found\n");
 595                 return -ENODEV;
 596         }
 597         return 0;
 598 }
 599
 600 static void acpi_thermal_check(void *data)
 601 {
 602         struct acpi_thermal *tz = data;
 603
 604         thermal_zone_device_update(tz->thermal_zone);
 605 }
 606
 607 /* sys I/F for generic thermal sysfs support */
 608 #define KELVIN_TO_MILLICELSIUS(t, off) (((t) - (off)) * 100)
 609
 610 static int thermal_get_temp(struct thermal_zone_device *thermal,
 611                             unsigned long *temp)
 612 {
 613         struct acpi_thermal *tz = thermal->devdata;
 614         int result;
 615
 616         if (!tz)
 617                 return -EINVAL;
 618
 619         result = acpi_thermal_get_temperature(tz);
 620         if (result)
 621                 return result;
 622
 623         *temp = KELVIN_TO_MILLICELSIUS(tz->temperature, tz->kelvin_offset);
 624         return 0;
 625 }
 626
 627 static const char enabled[] = "kernel";
 628 static const char disabled[] = "user";
 629 static int thermal_get_mode(struct thermal_zone_device *thermal,
 630                                 enum thermal_device_mode *mode)
 631 {
 632         struct acpi_thermal *tz = thermal->devdata;
 633
 634         if (!tz)
 635                 return -EINVAL;
 636
 637         *mode = tz->tz_enabled ? THERMAL_DEVICE_ENABLED :
 638                 THERMAL_DEVICE_DISABLED;
 639
 640         return 0;
 641 }
 642
 643 static int thermal_set_mode(struct thermal_zone_device *thermal,
 644                                 enum thermal_device_mode mode)
 645 {
 646         struct acpi_thermal *tz = thermal->devdata;
 647         int enable;
 648
 649         if (!tz)
 650                 return -EINVAL;
 651
 652         /*
 653          * enable/disable thermal management from ACPI thermal driver
 654          */
 655         if (mode == THERMAL_DEVICE_ENABLED)
 656                 enable = 1;
 657         else if (mode == THERMAL_DEVICE_DISABLED)
 658                 enable = 0;
 659         else
 660                 return -EINVAL;
 661
 662         if (enable != tz->tz_enabled) {
 663                 tz->tz_enabled = enable;
 664                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 665                         "%s ACPI thermal control\n",
 666                         tz->tz_enabled ? enabled : disabled));
 667                 acpi_thermal_check(tz);
 668         }
 669         return 0;
 670 }
 671
 672 static int thermal_get_trip_type(struct thermal_zone_device *thermal,
 673                                  int trip, enum thermal_trip_type *type)
 674 {
 675         struct acpi_thermal *tz = thermal->devdata;
 676         int i;
 677
 678         if (!tz || trip < 0)
 679                 return -EINVAL;
 680
 681         if (tz->trips.critical.flags.valid) {
 682                 if (!trip) {
 683                         *type = THERMAL_TRIP_CRITICAL;
 684                         return 0;
 685                 }
 686                 trip--;
 687         }
 688
 689         if (tz->trips.hot.flags.valid) {
 690                 if (!trip) {
 691                         *type = THERMAL_TRIP_HOT;
 692                         return 0;
 693                 }
 694                 trip--;
 695         }
 696
 697         if (tz->trips.passive.flags.valid) {
 698                 if (!trip) {
 699                         *type = THERMAL_TRIP_PASSIVE;
 700                         return 0;
 701                 }
 702                 trip--;
 703         }
 704
 705         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
 706                 tz->trips.active[i].flags.valid; i++) {
 707                 if (!trip) {
 708                         *type = THERMAL_TRIP_ACTIVE;
 709                         return 0;
 710                 }
 711                 trip--;
 712         }
 713
 714         return -EINVAL;
 715 }
 716
 717 static int thermal_get_trip_temp(struct thermal_zone_device *thermal,
 718                                  int trip, unsigned long *temp)
 719 {
 720         struct acpi_thermal *tz = thermal->devdata;
 721         int i;
 722
 723         if (!tz || trip < 0)
 724                 return -EINVAL;
 725
 726         if (tz->trips.critical.flags.valid) {
 727                 if (!trip) {
 728                         *temp = KELVIN_TO_MILLICELSIUS(
 729                                 tz->trips.critical.temperature,
 730                                 tz->kelvin_offset);
 731                         return 0;
 732                 }
 733                 trip--;
 734         }
 735
 736         if (tz->trips.hot.flags.valid) {
 737                 if (!trip) {
 738                         *temp = KELVIN_TO_MILLICELSIUS(
 739                                 tz->trips.hot.temperature,
 740                                 tz->kelvin_offset);
 741                         return 0;
 742                 }
 743                 trip--;
 744         }
 745
 746         if (tz->trips.passive.flags.valid) {
 747                 if (!trip) {
 748                         *temp = KELVIN_TO_MILLICELSIUS(
 749                                 tz->trips.passive.temperature,
 750                                 tz->kelvin_offset);
 751                         return 0;
 752                 }
 753                 trip--;
 754         }
 755
 756         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
 757                 tz->trips.active[i].flags.valid; i++) {
 758                 if (!trip) {
 759                         *temp = KELVIN_TO_MILLICELSIUS(
 760                                 tz->trips.active[i].temperature,
 761                                 tz->kelvin_offset);
 762                         return 0;
 763                 }
 764                 trip--;
 765         }
 766
 767         return -EINVAL;
 768 }
 769
 770 static int thermal_get_crit_temp(struct thermal_zone_device *thermal,
 771                                 unsigned long *temperature) {
 772         struct acpi_thermal *tz = thermal->devdata;
 773
 774         if (tz->trips.critical.flags.valid) {
 775                 *temperature = KELVIN_TO_MILLICELSIUS(
 776                                 tz->trips.critical.temperature,
 777                                 tz->kelvin_offset);
 778                 return 0;
 779         } else
 780                 return -EINVAL;
 781 }
 782
 783 static int thermal_notify(struct thermal_zone_device *thermal, int trip,
 784                            enum thermal_trip_type trip_type)
 785 {
 786         u8 type = 0;
 787         struct acpi_thermal *tz = thermal->devdata;
 788
 789         if (trip_type == THERMAL_TRIP_CRITICAL)
 790                 type = ACPI_THERMAL_NOTIFY_CRITICAL;
 791         else if (trip_type == THERMAL_TRIP_HOT)
 792                 type = ACPI_THERMAL_NOTIFY_HOT;
 793         else
 794                 return 0;
 795
 796         acpi_bus_generate_proc_event(tz->device, type, 1);
 797         acpi_bus_generate_netlink_event(tz->device->pnp.device_class,
 798                                         dev_name(&tz->device->dev), type, 1);
 799
 800         if (trip_type == THERMAL_TRIP_CRITICAL && nocrt)
 801                 return 1;
 802
 803         return 0;
 804 }
 805
 806 typedef int (*cb)(struct thermal_zone_device *, int,
 807                   struct thermal_cooling_device *);
 808 static int acpi_thermal_cooling_device_cb(struct thermal_zone_device *thermal,
 809                                         struct thermal_cooling_device *cdev,
 810                                         cb action)
 811 {
 812         struct acpi_device *device = cdev->devdata;
 813         struct acpi_thermal *tz = thermal->devdata;
 814         struct acpi_device *dev;
 815         acpi_status status;
 816         acpi_handle handle;
 817         int i;
 818         int j;
 819         int trip = -1;
 820         int result = 0;
 821
 822         if (tz->trips.critical.flags.valid)
 823                 trip++;
 824
 825         if (tz->trips.hot.flags.valid)
 826                 trip++;
 827
 828         if (tz->trips.passive.flags.valid) {
 829                 trip++;
 830                 for (i = 0; i < tz->trips.passive.devices.count;
 831                     i++) {
 832                         handle = tz->trips.passive.devices.handles[i];
 833                         status = acpi_bus_get_device(handle, &dev);
 834                         if (ACPI_SUCCESS(status) && (dev == device)) {
 835                                 result = action(thermal, trip, cdev);
 836                                 if (result)
 837                                         goto failed;
 838                         }
 839                 }
 840         }
 841
 842         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
 843                 if (!tz->trips.active[i].flags.valid)
 844                         break;
 845                 trip++;
 846                 for (j = 0;
 847                     j < tz->trips.active[i].devices.count;
 848                     j++) {
 849                         handle = tz->trips.active[i].devices.handles[j];
 850                         status = acpi_bus_get_device(handle, &dev);
 851                         if (ACPI_SUCCESS(status) && (dev == device)) {
 852                                 result = action(thermal, trip, cdev);
 853                                 if (result)
 854                                         goto failed;
 855                         }
 856                 }
 857         }
 858
 859         for (i = 0; i < tz->devices.count; i++) {
 860                 handle = tz->devices.handles[i];
 861                 status = acpi_bus_get_device(handle, &dev);
 862                 if (ACPI_SUCCESS(status) && (dev == device)) {
 863                         result = action(thermal, -1, cdev);
 864                         if (result)
 865                                 goto failed;
 866                 }
 867         }
 868
 869 failed:
 870         return result;
 871 }
 872
 873 static int
 874 acpi_thermal_bind_cooling_device(struct thermal_zone_device *thermal,
 875                                         struct thermal_cooling_device *cdev)
 876 {
 877         return acpi_thermal_cooling_device_cb(thermal, cdev,
 878                                 thermal_zone_bind_cooling_device);
 879 }
 880
 881 static int
 882 acpi_thermal_unbind_cooling_device(struct thermal_zone_device *thermal,
 883                                         struct thermal_cooling_device *cdev)
 884 {
 885         return acpi_thermal_cooling_device_cb(thermal, cdev,
 886                                 thermal_zone_unbind_cooling_device);
 887 }
 888
 889 static struct thermal_zone_device_ops acpi_thermal_zone_ops = {
 890         .bind = acpi_thermal_bind_cooling_device,
 891         .unbind = acpi_thermal_unbind_cooling_device,
 892         .get_temp = thermal_get_temp,
 893         .get_mode = thermal_get_mode,
 894         .set_mode = thermal_set_mode,
 895         .get_trip_type = thermal_get_trip_type,
 896         .get_trip_temp = thermal_get_trip_temp,
 897         .get_crit_temp = thermal_get_crit_temp,
 898         .notify = thermal_notify,
 899 };
 900
 901 static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz)
 902 {
 903         int trips = 0;
 904         int result;
 905         acpi_status status;
 906         int i;
 907
 908         if (tz->trips.critical.flags.valid)
 909                 trips++;
 910
 911         if (tz->trips.hot.flags.valid)
 912                 trips++;
 913
 914         if (tz->trips.passive.flags.valid)
 915                 trips++;
 916
 917         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
 918                         tz->trips.active[i].flags.valid; i++, trips++);
 919
 920         if (tz->trips.passive.flags.valid)
 921                 tz->thermal_zone =
 922                         thermal_zone_device_register("acpitz", trips, tz,
 923                                                      &acpi_thermal_zone_ops,
 924                                                      tz->trips.passive.tc1,
 925                                                      tz->trips.passive.tc2,
 926                                                      tz->trips.passive.tsp*100,
 927                                                      tz->polling_frequency*100);
 928         else
 929                 tz->thermal_zone =
 930                         thermal_zone_device_register("acpitz", trips, tz,
 931                                                      &acpi_thermal_zone_ops,
 932                                                      0, 0, 0,
 933                                                      tz->polling_frequency*100);
 934         if (IS_ERR(tz->thermal_zone))
 935                 return -ENODEV;
 936
 937         result = sysfs_create_link(&tz->device->dev.kobj,
 938                                    &tz->thermal_zone->device.kobj, "thermal_zone");
 939         if (result)
 940                 return result;
 941
 942         result = sysfs_create_link(&tz->thermal_zone->device.kobj,
 943                                    &tz->device->dev.kobj, "device");
 944         if (result)
 945                 return result;
 946
 947         status = acpi_attach_data(tz->device->handle,
 948                                   acpi_bus_private_data_handler,
 949                                   tz->thermal_zone);
 950         if (ACPI_FAILURE(status)) {
 951                 printk(KERN_ERR PREFIX
 952                                 "Error attaching device data\n");
 953                 return -ENODEV;
 954         }
 955
 956         tz->tz_enabled = 1;
 957
 958         dev_info(&tz->device->dev, "registered as thermal_zone%d\n",
 959                  tz->thermal_zone->id);
 960         return 0;
 961 }
 962
 963 static void acpi_thermal_unregister_thermal_zone(struct acpi_thermal *tz)
 964 {
 965         sysfs_remove_link(&tz->device->dev.kobj, "thermal_zone");
 966         sysfs_remove_link(&tz->thermal_zone->device.kobj, "device");
 967         thermal_zone_device_unregister(tz->thermal_zone);
 968         tz->thermal_zone = NULL;
 969         acpi_detach_data(tz->device->handle, acpi_bus_private_data_handler);
 970 }
 971
 972
 973 /* --------------------------------------------------------------------------
 974                               FS Interface (/proc)
 975    -------------------------------------------------------------------------- */
 976
 977 static struct proc_dir_entry *acpi_thermal_dir;
 978
 979 static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
 980 {
 981         struct acpi_thermal *tz = seq->private;
 982
 983
 984         if (!tz)
 985                 goto end;
 986
 987         seq_puts(seq, "state:                   ");
 988
 989         if (!tz->state.critical && !tz->state.hot && !tz->state.passive
 990             && !tz->state.active)
 991                 seq_puts(seq, "ok\n");
 992         else {
 993                 if (tz->state.critical)
 994                         seq_puts(seq, "critical ");
 995                 if (tz->state.hot)
 996                         seq_puts(seq, "hot ");
 997                 if (tz->state.passive)
 998                         seq_puts(seq, "passive ");
 999                 if (tz->state.active)
1000                         seq_printf(seq, "active[%d]", tz->state.active_index);
1001                 seq_puts(seq, "\n");
1002         }
1003
1004       end:
1005         return 0;
1006 }
1007
1008 static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file)
1009 {
1010         return single_open(file, acpi_thermal_state_seq_show, PDE(inode)->data);
1011 }
1012
1013 static int acpi_thermal_temp_seq_show(struct seq_file *seq, void *offset)
1014 {
1015         int result = 0;
1016         struct acpi_thermal *tz = seq->private;
1017
1018
1019         if (!tz)
1020                 goto end;
1021
1022         result = acpi_thermal_get_temperature(tz);
1023         if (result)
1024                 goto end;
1025
1026         seq_printf(seq, "temperature:             %ld C\n",
1027                    KELVIN_TO_CELSIUS(tz->temperature));
1028
1029       end:
1030         return 0;
1031 }
1032
1033 static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file)
1034 {
1035         return single_open(file, acpi_thermal_temp_seq_show, PDE(inode)->data);
1036 }
1037
1038 static int acpi_thermal_trip_seq_show(struct seq_file *seq, void *offset)
1039 {
1040         struct acpi_thermal *tz = seq->private;
1041         struct acpi_device *device;
1042         acpi_status status;
1043
1044         int i = 0;
1045         int j = 0;
1046
1047
1048         if (!tz)
1049                 goto end;
1050
1051         if (tz->trips.critical.flags.valid)
1052                 seq_printf(seq, "critical (S5):           %ld C%s",
1053                            KELVIN_TO_CELSIUS(tz->trips.critical.temperature),
1054                            nocrt ? " <disabled>\n" : "\n");
1055
1056         if (tz->trips.hot.flags.valid)
1057                 seq_printf(seq, "hot (S4):                %ld C%s",
1058                            KELVIN_TO_CELSIUS(tz->trips.hot.temperature),
1059                            nocrt ? " <disabled>\n" : "\n");
1060
1061         if (tz->trips.passive.flags.valid) {
1062                 seq_printf(seq,
1063                            "passive:                 %ld C: tc1=%lu tc2=%lu tsp=%lu devices=",
1064                            KELVIN_TO_CELSIUS(tz->trips.passive.temperature),
1065                            tz->trips.passive.tc1, tz->trips.passive.tc2,
1066                            tz->trips.passive.tsp);
1067                 for (j = 0; j < tz->trips.passive.devices.count; j++) {
1068                         status = acpi_bus_get_device(tz->trips.passive.devices.
1069                                                      handles[j], &device);
1070                         seq_printf(seq, "%4.4s ", status ? "" :
1071                                    acpi_device_bid(device));
1072                 }
1073                 seq_puts(seq, "\n");
1074         } else {
1075                 seq_printf(seq, "passive (forced):");
1076                 if (tz->thermal_zone->forced_passive)
1077                         seq_printf(seq, "        %i C\n",
1078                                    tz->thermal_zone->forced_passive / 1000);
1079                 else
1080                         seq_printf(seq, "<not set>\n");
1081         }
1082
1083         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1084                 if (!(tz->trips.active[i].flags.valid))
1085                         break;
1086                 seq_printf(seq, "active[%d]:               %ld C: devices=",
1087                            i,
1088                            KELVIN_TO_CELSIUS(tz->trips.active[i].temperature));
1089                 for (j = 0; j < tz->trips.active[i].devices.count; j++){
1090                         status = acpi_bus_get_device(tz->trips.active[i].
1091                                                      devices.handles[j],
1092                                                      &device);
1093                         seq_printf(seq, "%4.4s ", status ? "" :
1094                                    acpi_device_bid(device));
1095                 }
1096                 seq_puts(seq, "\n");
1097         }
1098
1099       end:
1100         return 0;
1101 }
1102
1103 static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file)
1104 {
1105         return single_open(file, acpi_thermal_trip_seq_show, PDE(inode)->data);
1106 }
1107
1108 static int acpi_thermal_cooling_seq_show(struct seq_file *seq, void *offset)
1109 {
1110         struct acpi_thermal *tz = seq->private;
1111
1112
1113         if (!tz)
1114                 goto end;
1115
1116         if (!tz->flags.cooling_mode)
1117                 seq_puts(seq, "<setting not supported>\n");
1118         else
1119                 seq_puts(seq, "0 - Active; 1 - Passive\n");
1120
1121       end:
1122         return 0;
1123 }
1124
1125 static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file)
1126 {
1127         return single_open(file, acpi_thermal_cooling_seq_show,
1128                            PDE(inode)->data);
1129 }
1130
1131 static ssize_t
1132 acpi_thermal_write_cooling_mode(struct file *file,
1133                                 const char __user * buffer,
1134                                 size_t count, loff_t * ppos)
1135 {
1136         struct seq_file *m = file->private_data;
1137         struct acpi_thermal *tz = m->private;
1138         int result = 0;
1139         char mode_string[12] = { '\0' };
1140
1141
1142         if (!tz || (count > sizeof(mode_string) - 1))
1143                 return -EINVAL;
1144
1145         if (!tz->flags.cooling_mode)
1146                 return -ENODEV;
1147
1148         if (copy_from_user(mode_string, buffer, count))
1149                 return -EFAULT;
1150
1151         mode_string[count] = '\0';
1152
1153         result = acpi_thermal_set_cooling_mode(tz,
1154                                                simple_strtoul(mode_string, NULL,
1155                                                               0));
1156         if (result)
1157                 return result;
1158
1159         acpi_thermal_check(tz);
1160
1161         return count;
1162 }
1163
1164 static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
1165 {
1166         struct acpi_thermal *tz = seq->private;
1167
1168
1169         if (!tz)
1170                 goto end;
1171
1172         if (!tz->thermal_zone->polling_delay) {
1173                 seq_puts(seq, "<polling disabled>\n");
1174                 goto end;
1175         }
1176
1177         seq_printf(seq, "polling frequency:       %d seconds\n",
1178                    (tz->thermal_zone->polling_delay / 1000));
1179
1180       end:
1181         return 0;
1182 }
1183
1184 static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file)
1185 {
1186         return single_open(file, acpi_thermal_polling_seq_show,
1187                            PDE(inode)->data);
1188 }
1189
1190 static ssize_t
1191 acpi_thermal_write_polling(struct file *file,
1192                            const char __user * buffer,
1193                            size_t count, loff_t * ppos)
1194 {
1195         struct seq_file *m = file->private_data;
1196         struct acpi_thermal *tz = m->private;
1197         int result = 0;
1198         char polling_string[12] = { '\0' };
1199         int seconds = 0;
1200
1201
1202         if (!tz || (count > sizeof(polling_string) - 1))
1203                 return -EINVAL;
1204
1205         if (copy_from_user(polling_string, buffer, count))
1206                 return -EFAULT;
1207
1208         polling_string[count] = '\0';
1209
1210         seconds = simple_strtoul(polling_string, NULL, 0);
1211
1212         result = acpi_thermal_set_polling(tz, seconds);
1213         if (result)
1214                 return result;
1215
1216         acpi_thermal_check(tz);
1217
1218         return count;
1219 }
1220
1221 static int acpi_thermal_add_fs(struct acpi_device *device)
1222 {
1223         struct proc_dir_entry *entry = NULL;
1224
1225
1226         if (!acpi_device_dir(device)) {
1227                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1228                                                      acpi_thermal_dir);
1229                 if (!acpi_device_dir(device))
1230                         return -ENODEV;
1231         }
1232
1233         /* 'state' [R] */
1234         entry = proc_create_data(ACPI_THERMAL_FILE_STATE,
1235                                  S_IRUGO, acpi_device_dir(device),
1236                                  &acpi_thermal_state_fops,
1237                                  acpi_driver_data(device));
1238         if (!entry)
1239                 return -ENODEV;
1240
1241         /* 'temperature' [R] */
1242         entry = proc_create_data(ACPI_THERMAL_FILE_TEMPERATURE,
1243                                  S_IRUGO, acpi_device_dir(device),
1244                                  &acpi_thermal_temp_fops,
1245                                  acpi_driver_data(device));
1246         if (!entry)
1247                 return -ENODEV;
1248
1249         /* 'trip_points' [R] */
1250         entry = proc_create_data(ACPI_THERMAL_FILE_TRIP_POINTS,
1251                                  S_IRUGO,
1252                                  acpi_device_dir(device),
1253                                  &acpi_thermal_trip_fops,
1254                                  acpi_driver_data(device));
1255         if (!entry)
1256                 return -ENODEV;
1257
1258         /* 'cooling_mode' [R/W] */
1259         entry = proc_create_data(ACPI_THERMAL_FILE_COOLING_MODE,
1260                                  S_IFREG | S_IRUGO | S_IWUSR,
1261                                  acpi_device_dir(device),
1262                                  &acpi_thermal_cooling_fops,
1263                                  acpi_driver_data(device));
1264         if (!entry)
1265                 return -ENODEV;
1266
1267         /* 'polling_frequency' [R/W] */
1268         entry = proc_create_data(ACPI_THERMAL_FILE_POLLING_FREQ,
1269                                  S_IFREG | S_IRUGO | S_IWUSR,
1270                                  acpi_device_dir(device),
1271                                  &acpi_thermal_polling_fops,
1272                                  acpi_driver_data(device));
1273         if (!entry)
1274                 return -ENODEV;
1275         return 0;
1276 }
1277
1278 static int acpi_thermal_remove_fs(struct acpi_device *device)
1279 {
1280
1281         if (acpi_device_dir(device)) {
1282                 remove_proc_entry(ACPI_THERMAL_FILE_POLLING_FREQ,
1283                                   acpi_device_dir(device));
1284                 remove_proc_entry(ACPI_THERMAL_FILE_COOLING_MODE,
1285                                   acpi_device_dir(device));
1286                 remove_proc_entry(ACPI_THERMAL_FILE_TRIP_POINTS,
1287                                   acpi_device_dir(device));
1288                 remove_proc_entry(ACPI_THERMAL_FILE_TEMPERATURE,
1289                                   acpi_device_dir(device));
1290                 remove_proc_entry(ACPI_THERMAL_FILE_STATE,
1291                                   acpi_device_dir(device));
1292                 remove_proc_entry(acpi_device_bid(device), acpi_thermal_dir);
1293                 acpi_device_dir(device) = NULL;
1294         }
1295
1296         return 0;
1297 }
1298
1299 /* --------------------------------------------------------------------------
1300                                  Driver Interface
1301    -------------------------------------------------------------------------- */
1302
1303 static void acpi_thermal_notify(struct acpi_device *device, u32 event)
1304 {
1305         struct acpi_thermal *tz = acpi_driver_data(device);
1306
1307
1308         if (!tz)
1309                 return;
1310
1311         switch (event) {
1312         case ACPI_THERMAL_NOTIFY_TEMPERATURE:
1313                 acpi_thermal_check(tz);
1314                 break;
1315         case ACPI_THERMAL_NOTIFY_THRESHOLDS:
1316                 acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_THRESHOLDS);
1317                 acpi_thermal_check(tz);
1318                 acpi_bus_generate_proc_event(device, event, 0);
1319                 acpi_bus_generate_netlink_event(device->pnp.device_class,
1320                                                   dev_name(&device->dev), event, 0);
1321                 break;
1322         case ACPI_THERMAL_NOTIFY_DEVICES:
1323                 acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_DEVICES);
1324                 acpi_thermal_check(tz);
1325                 acpi_bus_generate_proc_event(device, event, 0);
1326                 acpi_bus_generate_netlink_event(device->pnp.device_class,
1327                                                   dev_name(&device->dev), event, 0);
1328                 break;
1329         default:
1330                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1331                                   "Unsupported event [0x%x]\n", event));
1332                 break;
1333         }
1334 }
1335
1336 static int acpi_thermal_get_info(struct acpi_thermal *tz)
1337 {
1338         int result = 0;
1339
1340
1341         if (!tz)
1342                 return -EINVAL;
1343
1344         /* Get temperature [_TMP] (required) */
1345         result = acpi_thermal_get_temperature(tz);
1346         if (result)
1347                 return result;
1348
1349         /* Get trip points [_CRT, _PSV, etc.] (required) */
1350         result = acpi_thermal_get_trip_points(tz);
1351         if (result)
1352                 return result;
1353
1354         /* Set the cooling mode [_SCP] to active cooling (default) */
1355         result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
1356         if (!result)
1357                 tz->flags.cooling_mode = 1;
1358
1359         /* Get default polling frequency [_TZP] (optional) */
1360         if (tzp)
1361                 tz->polling_frequency = tzp;
1362         else
1363                 acpi_thermal_get_polling_frequency(tz);
1364
1365         return 0;
1366 }
1367
1368 /*
1369  * The exact offset between Kelvin and degree Celsius is 273.15. However ACPI
1370  * handles temperature values with a single decimal place. As a consequence,
1371  * some implementations use an offset of 273.1 and others use an offset of
1372  * 273.2. Try to find out which one is being used, to present the most
1373  * accurate and visually appealing number.
1374  *
1375  * The heuristic below should work for all ACPI thermal zones which have a
1376  * critical trip point with a value being a multiple of 0.5 degree Celsius.
1377  */
1378 static void acpi_thermal_guess_offset(struct acpi_thermal *tz)
1379 {
1380         if (tz->trips.critical.flags.valid &&
1381             (tz->trips.critical.temperature % 5) == 1)
1382                 tz->kelvin_offset = 2731;
1383         else
1384                 tz->kelvin_offset = 2732;
1385 }
1386
1387 static int acpi_thermal_add(struct acpi_device *device)
1388 {
1389         int result = 0;
1390         struct acpi_thermal *tz = NULL;
1391
1392
1393         if (!device)
1394                 return -EINVAL;
1395
1396         tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
1397         if (!tz)
1398                 return -ENOMEM;
1399
1400         tz->device = device;
1401         strcpy(tz->name, device->pnp.bus_id);
1402         strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
1403         strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
1404         device->driver_data = tz;
1405         mutex_init(&tz->lock);
1406
1407
1408         result = acpi_thermal_get_info(tz);
1409         if (result)
1410                 goto free_memory;
1411
1412         acpi_thermal_guess_offset(tz);
1413
1414         result = acpi_thermal_register_thermal_zone(tz);
1415         if (result)
1416                 goto free_memory;
1417
1418         result = acpi_thermal_add_fs(device);
1419         if (result)
1420                 goto unregister_thermal_zone;
1421
1422         printk(KERN_INFO PREFIX "%s [%s] (%ld C)\n",
1423                acpi_device_name(device), acpi_device_bid(device),
1424                KELVIN_TO_CELSIUS(tz->temperature));
1425         goto end;
1426
1427 unregister_thermal_zone:
1428         thermal_zone_device_unregister(tz->thermal_zone);
1429 free_memory:
1430         kfree(tz);
1431 end:
1432         return result;
1433 }
1434
1435 static int acpi_thermal_remove(struct acpi_device *device, int type)
1436 {
1437         struct acpi_thermal *tz = NULL;
1438
1439         if (!device || !acpi_driver_data(device))
1440                 return -EINVAL;
1441
1442         tz = acpi_driver_data(device);
1443
1444         acpi_thermal_remove_fs(device);
1445         acpi_thermal_unregister_thermal_zone(tz);
1446         mutex_destroy(&tz->lock);
1447         kfree(tz);
1448         return 0;
1449 }
1450
1451 static int acpi_thermal_resume(struct acpi_device *device)
1452 {
1453         struct acpi_thermal *tz = NULL;
1454         int i, j, power_state, result;
1455
1456
1457         if (!device || !acpi_driver_data(device))
1458                 return -EINVAL;
1459
1460         tz = acpi_driver_data(device);
1461
1462         for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1463                 if (!(&tz->trips.active[i]))
1464                         break;
1465                 if (!tz->trips.active[i].flags.valid)
1466                         break;
1467                 tz->trips.active[i].flags.enabled = 1;
1468                 for (j = 0; j < tz->trips.active[i].devices.count; j++) {
1469                         result = acpi_bus_get_power(tz->trips.active[i].devices.
1470                             handles[j], &power_state);
1471                         if (result || (power_state != ACPI_STATE_D0)) {
1472                                 tz->trips.active[i].flags.enabled = 0;
1473                                 break;
1474                         }
1475                 }
1476                 tz->state.active |= tz->trips.active[i].flags.enabled;
1477         }
1478
1479         acpi_thermal_check(tz);
1480
1481         return AE_OK;
1482 }
1483
1484 static int thermal_act(const struct dmi_system_id *d) {
1485
1486         if (act == 0) {
1487                 printk(KERN_NOTICE "ACPI: %s detected: "
1488                         "disabling all active thermal trip points\n", d->ident);
1489                 act = -1;
1490         }
1491         return 0;
1492 }
1493 static int thermal_nocrt(const struct dmi_system_id *d) {
1494
1495         printk(KERN_NOTICE "ACPI: %s detected: "
1496                 "disabling all critical thermal trip point actions.\n", d->ident);
1497         nocrt = 1;
1498         return 0;
1499 }
1500 static int thermal_tzp(const struct dmi_system_id *d) {
1501
1502         if (tzp == 0) {
1503                 printk(KERN_NOTICE "ACPI: %s detected: "
1504                         "enabling thermal zone polling\n", d->ident);
1505                 tzp = 300;      /* 300 dS = 30 Seconds */
1506         }
1507         return 0;
1508 }
1509 static int thermal_psv(const struct dmi_system_id *d) {
1510
1511         if (psv == 0) {
1512                 printk(KERN_NOTICE "ACPI: %s detected: "
1513                         "disabling all passive thermal trip points\n", d->ident);
1514                 psv = -1;
1515         }
1516         return 0;
1517 }
1518
1519 static struct dmi_system_id thermal_dmi_table[] __initdata = {
1520         /*
1521          * Award BIOS on this AOpen makes thermal control almost worthless.
1522          * http://bugzilla.kernel.org/show_bug.cgi?id=8842
1523          */
1524         {
1525          .callback = thermal_act,
1526          .ident = "AOpen i915GMm-HFS",
1527          .matches = {
1528                 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1529                 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1530                 },
1531         },
1532         {
1533          .callback = thermal_psv,
1534          .ident = "AOpen i915GMm-HFS",
1535          .matches = {
1536                 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1537                 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1538                 },
1539         },
1540         {
1541          .callback = thermal_tzp,
1542          .ident = "AOpen i915GMm-HFS",
1543          .matches = {
1544                 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1545                 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1546                 },
1547         },
1548         {
1549          .callback = thermal_nocrt,
1550          .ident = "Gigabyte GA-7ZX",
1551          .matches = {
1552                 DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
1553                 DMI_MATCH(DMI_BOARD_NAME, "7ZX"),
1554                 },
1555         },
1556         {}
1557 };
1558
1559 static int __init acpi_thermal_init(void)
1560 {
1561         int result = 0;
1562
1563         dmi_check_system(thermal_dmi_table);
1564
1565         if (off) {
1566                 printk(KERN_NOTICE "ACPI: thermal control disabled\n");
1567                 return -ENODEV;
1568         }
1569         acpi_thermal_dir = proc_mkdir(ACPI_THERMAL_CLASS, acpi_root_dir);
1570         if (!acpi_thermal_dir)
1571                 return -ENODEV;
1572
1573         result = acpi_bus_register_driver(&acpi_thermal_driver);
1574         if (result < 0) {
1575                 remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
1576                 return -ENODEV;
1577         }
1578
1579         return 0;
1580 }
1581
1582 static void __exit acpi_thermal_exit(void)
1583 {
1584
1585         acpi_bus_unregister_driver(&acpi_thermal_driver);
1586
1587         remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
1588
1589         return;
1590 }
1591
1592 module_init(acpi_thermal_init);
1593 module_exit(acpi_thermal_exit);