projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
acpi: use non-racy method for proc entries creation
[deliverable/linux.git] / drivers / acpi / thermal.c
CommitLineData
1da177e4
LT		 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>
0b5bfa1c 36#include <linux/dmi.h>
1da177e4
LT		 37#include <linux/init.h>
38#include <linux/types.h>
39#include <linux/proc_fs.h>
cd354f1a
TS		 40#include <linux/timer.h>
41#include <linux/jiffies.h>
1da177e4
LT		 42#include <linux/kmod.h>
43#include <linux/seq_file.h>
10a0a8d4 44#include <linux/reboot.h>
1da177e4 45#include <asm/uaccess.h>
3f655ef8 46#include <linux/thermal.h>
1da177e4
LT		 47#include <acpi/acpi_bus.h>
48#include <acpi/acpi_drivers.h>
49
50#define ACPI_THERMAL_COMPONENT 0x04000000
51#define ACPI_THERMAL_CLASS "thermal_zone"
1da177e4
LT		 52#define ACPI_THERMAL_DEVICE_NAME "Thermal Zone"
53#define ACPI_THERMAL_FILE_STATE "state"
54#define ACPI_THERMAL_FILE_TEMPERATURE "temperature"
55#define ACPI_THERMAL_FILE_TRIP_POINTS "trip_points"
56#define ACPI_THERMAL_FILE_COOLING_MODE "cooling_mode"
57#define ACPI_THERMAL_FILE_POLLING_FREQ "polling_frequency"
58#define ACPI_THERMAL_NOTIFY_TEMPERATURE 0x80
59#define ACPI_THERMAL_NOTIFY_THRESHOLDS 0x81
60#define ACPI_THERMAL_NOTIFY_DEVICES 0x82
61#define ACPI_THERMAL_NOTIFY_CRITICAL 0xF0
62#define ACPI_THERMAL_NOTIFY_HOT 0xF1
63#define ACPI_THERMAL_MODE_ACTIVE 0x00
1da177e4
LT		 64
65#define ACPI_THERMAL_MAX_ACTIVE 10
66#define ACPI_THERMAL_MAX_LIMIT_STR_LEN 65
67
1da177e4 68#define _COMPONENT ACPI_THERMAL_COMPONENT
f52fd66d 69ACPI_MODULE_NAME("thermal");
1da177e4 70
1cbf4c56 71MODULE_AUTHOR("Paul Diefenbaugh");
7cda93e0 72MODULE_DESCRIPTION("ACPI Thermal Zone Driver");
1da177e4
LT		 73MODULE_LICENSE("GPL");
74
f8707ec9
LB		 75static int act;
76module_param(act, int, 0644);
3c1d36da 77MODULE_PARM_DESC(act, "Disable or override all lowest active trip points.");
f8707ec9 78
c52a7419
LB		 79static int crt;
80module_param(crt, int, 0644);
81MODULE_PARM_DESC(crt, "Disable or lower all critical trip points.");
82
1da177e4 83static int tzp;
730ff34d 84module_param(tzp, int, 0444);
3c1d36da 85MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds.");
1da177e4 86
f5487145
LB		 87static int nocrt;
88module_param(nocrt, int, 0);
8c99fdce 89MODULE_PARM_DESC(nocrt, "Set to take no action upon ACPI thermal zone critical trips points.");
f5487145 90
72b33ef8
LB		 91static int off;
92module_param(off, int, 0);
3c1d36da 93MODULE_PARM_DESC(off, "Set to disable ACPI thermal support.");
72b33ef8 94
a70cdc52
LB		 95static int psv;
96module_param(psv, int, 0644);
3c1d36da 97MODULE_PARM_DESC(psv, "Disable or override all passive trip points.");
a70cdc52 98
4be44fcd
LB		 99static int acpi_thermal_add(struct acpi_device *device);
100static int acpi_thermal_remove(struct acpi_device *device, int type);
5d9464a4 101static int acpi_thermal_resume(struct acpi_device *device);
1da177e4
LT		 102static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file);
103static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file);
104static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file);
1da177e4 105static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file);
4be44fcd
LB		 106static ssize_t acpi_thermal_write_cooling_mode(struct file *,
107 const char __user *, size_t,
108 loff_t *);
1da177e4 109static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
4be44fcd
LB		 110static ssize_t acpi_thermal_write_polling(struct file *, const char __user *,
111 size_t, loff_t *);
1da177e4 112
1ba90e3a
TR		 113static const struct acpi_device_id thermal_device_ids[] = {
114 {ACPI_THERMAL_HID, 0},
115 {"", 0},
116};
117MODULE_DEVICE_TABLE(acpi, thermal_device_ids);
118
1da177e4 119static struct acpi_driver acpi_thermal_driver = {
c2b6705b 120 .name = "thermal",
4be44fcd 121 .class = ACPI_THERMAL_CLASS,
1ba90e3a 122 .ids = thermal_device_ids,
4be44fcd
LB		 123 .ops = {
124 .add = acpi_thermal_add,
125 .remove = acpi_thermal_remove,
74ce1468 126 .resume = acpi_thermal_resume,
4be44fcd 127 },
1da177e4
LT		 128};
129
130struct acpi_thermal_state {
4be44fcd
LB		 131 u8 critical:1;
132 u8 hot:1;
133 u8 passive:1;
134 u8 active:1;
135 u8 reserved:4;
136 int active_index;
1da177e4
LT		 137};
138
139struct acpi_thermal_state_flags {
4be44fcd
LB		 140 u8 valid:1;
141 u8 enabled:1;
142 u8 reserved:6;
1da177e4
LT		 143};
144
145struct acpi_thermal_critical {
146 struct acpi_thermal_state_flags flags;
4be44fcd 147 unsigned long temperature;
1da177e4
LT		 148};
149
150struct acpi_thermal_hot {
151 struct acpi_thermal_state_flags flags;
4be44fcd 152 unsigned long temperature;
1da177e4
LT		 153};
154
155struct acpi_thermal_passive {
156 struct acpi_thermal_state_flags flags;
4be44fcd
LB		 157 unsigned long temperature;
158 unsigned long tc1;
159 unsigned long tc2;
160 unsigned long tsp;
161 struct acpi_handle_list devices;
1da177e4
LT		 162};
163
164struct acpi_thermal_active {
165 struct acpi_thermal_state_flags flags;
4be44fcd
LB		 166 unsigned long temperature;
167 struct acpi_handle_list devices;
1da177e4
LT		 168};
169
170struct acpi_thermal_trips {
171 struct acpi_thermal_critical critical;
4be44fcd 172 struct acpi_thermal_hot hot;
1da177e4
LT		 173 struct acpi_thermal_passive passive;
174 struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE];
175};
176
177struct acpi_thermal_flags {
4be44fcd
LB		 178 u8 cooling_mode:1; /* _SCP */
179 u8 devices:1; /* _TZD */
180 u8 reserved:6;
1da177e4
LT		 181};
182
183struct acpi_thermal {
8348e1b1 184 struct acpi_device * device;
4be44fcd
LB		 185 acpi_bus_id name;
186 unsigned long temperature;
187 unsigned long last_temperature;
188 unsigned long polling_frequency;
4be44fcd 189 volatile u8 zombie;
1da177e4
LT		 190 struct acpi_thermal_flags flags;
191 struct acpi_thermal_state state;
192 struct acpi_thermal_trips trips;
4be44fcd
LB		 193 struct acpi_handle_list devices;
194 struct timer_list timer;
3f655ef8
ZR		 195 struct thermal_zone_device *thermal_zone;
196 int tz_enabled;
6e215785 197 struct mutex lock;
1da177e4
LT		 198};
199
d7508032 200static const struct file_operations acpi_thermal_state_fops = {
cf7acfab 201 .owner = THIS_MODULE,
4be44fcd
LB		 202 .open = acpi_thermal_state_open_fs,
203 .read = seq_read,
204 .llseek = seq_lseek,
205 .release = single_release,
1da177e4
LT		 206};
207
d7508032 208static const struct file_operations acpi_thermal_temp_fops = {
cf7acfab 209 .owner = THIS_MODULE,
4be44fcd
LB		 210 .open = acpi_thermal_temp_open_fs,
211 .read = seq_read,
212 .llseek = seq_lseek,
213 .release = single_release,
1da177e4
LT		 214};
215
d7508032 216static const struct file_operations acpi_thermal_trip_fops = {
cf7acfab 217 .owner = THIS_MODULE,
4be44fcd
LB		 218 .open = acpi_thermal_trip_open_fs,
219 .read = seq_read,
4be44fcd
LB		 220 .llseek = seq_lseek,
221 .release = single_release,
1da177e4
LT		 222};
223
d7508032 224static const struct file_operations acpi_thermal_cooling_fops = {
cf7acfab 225 .owner = THIS_MODULE,
4be44fcd
LB		 226 .open = acpi_thermal_cooling_open_fs,
227 .read = seq_read,
228 .write = acpi_thermal_write_cooling_mode,
229 .llseek = seq_lseek,
230 .release = single_release,
1da177e4
LT		 231};
232
d7508032 233static const struct file_operations acpi_thermal_polling_fops = {
cf7acfab 234 .owner = THIS_MODULE,
4be44fcd
LB		 235 .open = acpi_thermal_polling_open_fs,
236 .read = seq_read,
237 .write = acpi_thermal_write_polling,
238 .llseek = seq_lseek,
239 .release = single_release,
1da177e4
LT		 240};
241
242/* --------------------------------------------------------------------------
243 Thermal Zone Management
244 -------------------------------------------------------------------------- */
245
4be44fcd 246static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
1da177e4 247{
4be44fcd 248 acpi_status status = AE_OK;
1da177e4 249
1da177e4
LT		 250
251 if (!tz)
d550d98d 252 return -EINVAL;
1da177e4
LT		 253
254 tz->last_temperature = tz->temperature;
255
4be44fcd 256 status =
38ba7c9e 257 acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tz->temperature);
1da177e4 258 if (ACPI_FAILURE(status))
d550d98d 259 return -ENODEV;
1da177e4 260
4be44fcd
LB		 261 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n",
262 tz->temperature));
1da177e4 263
d550d98d 264 return 0;
1da177e4
LT		 265}
266
4be44fcd 267static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
1da177e4 268{
4be44fcd 269 acpi_status status = AE_OK;
1da177e4 270
1da177e4
LT		 271
272 if (!tz)
d550d98d 273 return -EINVAL;
1da177e4 274
4be44fcd 275 status =
38ba7c9e 276 acpi_evaluate_integer(tz->device->handle, "_TZP", NULL,
4be44fcd 277 &tz->polling_frequency);
1da177e4 278 if (ACPI_FAILURE(status))
d550d98d 279 return -ENODEV;
1da177e4 280
4be44fcd
LB		 281 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n",
282 tz->polling_frequency));
1da177e4 283
d550d98d 284 return 0;
1da177e4
LT		 285}
286
4be44fcd 287static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
1da177e4 288{
1da177e4
LT		 289
290 if (!tz)
d550d98d 291 return -EINVAL;
1da177e4
LT		 292
293 tz->polling_frequency = seconds * 10; /* Convert value to deci-seconds */
294
4be44fcd
LB		 295 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
296 "Polling frequency set to %lu seconds\n",
636cedf9 297 tz->polling_frequency/10));
1da177e4 298
d550d98d 299 return 0;
1da177e4
LT		 300}
301
4be44fcd 302static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
1da177e4 303{
4be44fcd
LB		 304 acpi_status status = AE_OK;
305 union acpi_object arg0 = { ACPI_TYPE_INTEGER };
306 struct acpi_object_list arg_list = { 1, &arg0 };
307 acpi_handle handle = NULL;
1da177e4 308
1da177e4
LT		 309
310 if (!tz)
d550d98d 311 return -EINVAL;
1da177e4 312
38ba7c9e 313 status = acpi_get_handle(tz->device->handle, "_SCP", &handle);
1da177e4
LT		 314 if (ACPI_FAILURE(status)) {
315 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
d550d98d 316 return -ENODEV;
1da177e4
LT		 317 }
318
319 arg0.integer.value = mode;
320
321 status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
322 if (ACPI_FAILURE(status))
d550d98d 323 return -ENODEV;
1da177e4 324
d550d98d 325 return 0;
1da177e4
LT		 326}
327
ce44e197
ZR		 328#define ACPI_TRIPS_CRITICAL 0x01
329#define ACPI_TRIPS_HOT 0x02
330#define ACPI_TRIPS_PASSIVE 0x04
331#define ACPI_TRIPS_ACTIVE 0x08
332#define ACPI_TRIPS_DEVICES 0x10
1da177e4 333
ce44e197
ZR		 334#define ACPI_TRIPS_REFRESH_THRESHOLDS (ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE)
335#define ACPI_TRIPS_REFRESH_DEVICES ACPI_TRIPS_DEVICES
1da177e4 336
ce44e197
ZR		 337#define ACPI_TRIPS_INIT (ACPI_TRIPS_CRITICAL | ACPI_TRIPS_HOT | \
338 ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE | \
339 ACPI_TRIPS_DEVICES)
1da177e4 340
ce44e197
ZR		 341/*
342 * This exception is thrown out in two cases:
343 * 1.An invalid trip point becomes invalid or a valid trip point becomes invalid
344 * when re-evaluating the AML code.
345 * 2.TODO: Devices listed in _PSL, _ALx, _TZD may change.
346 * We need to re-bind the cooling devices of a thermal zone when this occurs.
347 */
348#define ACPI_THERMAL_TRIPS_EXCEPTION(flags, str) \
349do { \
350 if (flags != ACPI_TRIPS_INIT) \
351 ACPI_EXCEPTION((AE_INFO, AE_ERROR, \
352 "ACPI thermal trip point %s changed\n" \
353 "Please send acpidump to linux-acpi@vger.kernel.org\n", str)); \
354} while (0)
355
356static int acpi_thermal_trips_update(struct acpi_thermal *tz, int flag)
357{
358 acpi_status status = AE_OK;
359 struct acpi_handle_list devices;
360 int valid = 0;
361 int i;
1da177e4 362
ce44e197
ZR		 363 /* Critical Shutdown (required) */
364 if (flag & ACPI_TRIPS_CRITICAL) {
365 status = acpi_evaluate_integer(tz->device->handle,
366 "_CRT", NULL, &tz->trips.critical.temperature);
367 if (ACPI_FAILURE(status)) {
c52a7419 368 tz->trips.critical.flags.valid = 0;
ce44e197
ZR		 369 ACPI_EXCEPTION((AE_INFO, status,
370 "No critical threshold"));
371 return -ENODEV;
372 } else {
373 tz->trips.critical.flags.valid = 1;
374 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
375 "Found critical threshold [%lu]\n",
376 tz->trips.critical.temperature));
377 }
378 if (tz->trips.critical.flags.valid == 1) {
379 if (crt == -1) {
380 tz->trips.critical.flags.valid = 0;
381 } else if (crt > 0) {
382 unsigned long crt_k = CELSIUS_TO_KELVIN(crt);
383 /*
384 * Allow override to lower critical threshold
385 */
386 if (crt_k < tz->trips.critical.temperature)
387 tz->trips.critical.temperature = crt_k;
388 }
c52a7419
LB		 389 }
390 }
391
1da177e4 392 /* Critical Sleep (optional) */
ce44e197 393 if (flag & ACPI_TRIPS_HOT) {
a70cdc52 394 status = acpi_evaluate_integer(tz->device->handle,
ce44e197
ZR		 395 "_HOT", NULL, &tz->trips.hot.temperature);
396 if (ACPI_FAILURE(status)) {
397 tz->trips.hot.flags.valid = 0;
398 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
399 "No hot threshold\n"));
400 } else {
401 tz->trips.hot.flags.valid = 1;
402 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
403 "Found hot threshold [%lu]\n",
404 tz->trips.critical.temperature));
405 }
a70cdc52
LB		 406 }
407
ce44e197
ZR		 408 /* Passive (optional) */
409 if (flag & ACPI_TRIPS_PASSIVE) {
410 valid = tz->trips.passive.flags.valid;
411 if (psv == -1) {
412 status = AE_SUPPORT;
413 } else if (psv > 0) {
414 tz->trips.passive.temperature = CELSIUS_TO_KELVIN(psv);
415 status = AE_OK;
416 } else {
417 status = acpi_evaluate_integer(tz->device->handle,
418 "_PSV", NULL, &tz->trips.passive.temperature);
419 }
1da177e4 420
1da177e4
LT		 421 if (ACPI_FAILURE(status))
422 tz->trips.passive.flags.valid = 0;
ce44e197
ZR		 423 else {
424 tz->trips.passive.flags.valid = 1;
425 if (flag == ACPI_TRIPS_INIT) {
426 status = acpi_evaluate_integer(
427 tz->device->handle, "_TC1",
428 NULL, &tz->trips.passive.tc1);
429 if (ACPI_FAILURE(status))
430 tz->trips.passive.flags.valid = 0;
431 status = acpi_evaluate_integer(
432 tz->device->handle, "_TC2",
433 NULL, &tz->trips.passive.tc2);
434 if (ACPI_FAILURE(status))
435 tz->trips.passive.flags.valid = 0;
436 status = acpi_evaluate_integer(
437 tz->device->handle, "_TSP",
438 NULL, &tz->trips.passive.tsp);
439 if (ACPI_FAILURE(status))
440 tz->trips.passive.flags.valid = 0;
441 }
442 }
443 }
444 if ((flag & ACPI_TRIPS_DEVICES) && tz->trips.passive.flags.valid) {
445 memset(&devices, 0, sizeof(struct acpi_handle_list));
446 status = acpi_evaluate_reference(tz->device->handle, "_PSL",
447 NULL, &devices);
1da177e4
LT		 448 if (ACPI_FAILURE(status))
449 tz->trips.passive.flags.valid = 0;
1da177e4 450 else
ce44e197 451 tz->trips.passive.flags.valid = 1;
1da177e4 452
ce44e197
ZR		 453 if (memcmp(&tz->trips.passive.devices, &devices,
454 sizeof(struct acpi_handle_list))) {
455 memcpy(&tz->trips.passive.devices, &devices,
456 sizeof(struct acpi_handle_list));
457 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
458 }
459 }
460 if ((flag & ACPI_TRIPS_PASSIVE) || (flag & ACPI_TRIPS_DEVICES)) {
461 if (valid != tz->trips.passive.flags.valid)
462 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "state");
463 }
1da177e4 464
ce44e197 465 /* Active (optional) */
4be44fcd 466 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
4be44fcd 467 char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
ce44e197 468 valid = tz->trips.active[i].flags.valid;
1da177e4 469
f8707ec9 470 if (act == -1)
ce44e197
ZR		 471 break; /* disable all active trip points */
472
473 if (flag & ACPI_TRIPS_ACTIVE) {
474 status = acpi_evaluate_integer(tz->device->handle,
475 name, NULL, &tz->trips.active[i].temperature);
476 if (ACPI_FAILURE(status)) {
477 tz->trips.active[i].flags.valid = 0;
478 if (i == 0)
479 break;
480 if (act <= 0)
481 break;
482 if (i == 1)
483 tz->trips.active[0].temperature =
484 CELSIUS_TO_KELVIN(act);
485 else
486 /*
487 * Don't allow override higher than
488 * the next higher trip point
489 */
490 tz->trips.active[i - 1].temperature =
491 (tz->trips.active[i - 2].temperature <
492 CELSIUS_TO_KELVIN(act) ?
493 tz->trips.active[i - 2].temperature :
494 CELSIUS_TO_KELVIN(act));
f8707ec9 495 break;
ce44e197
ZR		 496 } else
497 tz->trips.active[i].flags.valid = 1;
f8707ec9 498 }
1da177e4
LT		 499
500 name[2] = 'L';
ce44e197
ZR		 501 if ((flag & ACPI_TRIPS_DEVICES) && tz->trips.active[i].flags.valid ) {
502 memset(&devices, 0, sizeof(struct acpi_handle_list));
503 status = acpi_evaluate_reference(tz->device->handle,
504 name, NULL, &devices);
505 if (ACPI_FAILURE(status))
506 tz->trips.active[i].flags.valid = 0;
507 else
508 tz->trips.active[i].flags.valid = 1;
509
510 if (memcmp(&tz->trips.active[i].devices, &devices,
511 sizeof(struct acpi_handle_list))) {
512 memcpy(&tz->trips.active[i].devices, &devices,
513 sizeof(struct acpi_handle_list));
514 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
515 }
516 }
517 if ((flag & ACPI_TRIPS_ACTIVE) || (flag & ACPI_TRIPS_DEVICES))
518 if (valid != tz->trips.active[i].flags.valid)
519 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "state");
520
521 if (!tz->trips.active[i].flags.valid)
522 break;
523 }
524
525 if (flag & ACPI_TRIPS_DEVICES) {
526 memset(&devices, 0, sizeof(struct acpi_handle_list));
527 status = acpi_evaluate_reference(tz->device->handle, "_TZD",
528 NULL, &devices);
529 if (memcmp(&tz->devices, &devices,
530 sizeof(struct acpi_handle_list))) {
531 memcpy(&tz->devices, &devices,
532 sizeof(struct acpi_handle_list));
533 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
534 }
1da177e4
LT		 535 }
536
d550d98d 537 return 0;
1da177e4
LT		 538}
539
ce44e197 540static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
1da177e4 541{
ce44e197 542 return acpi_thermal_trips_update(tz, ACPI_TRIPS_INIT);
1da177e4
LT		 543}
544
4be44fcd 545static int acpi_thermal_critical(struct acpi_thermal *tz)
1da177e4 546{
223630fe 547 if (!tz || !tz->trips.critical.flags.valid)
d550d98d 548 return -EINVAL;
1da177e4
LT		 549
550 if (tz->temperature >= tz->trips.critical.temperature) {
cece9296 551 printk(KERN_WARNING PREFIX "Critical trip point\n");
1da177e4 552 tz->trips.critical.flags.enabled = 1;
4be44fcd 553 } else if (tz->trips.critical.flags.enabled)
1da177e4
LT		 554 tz->trips.critical.flags.enabled = 0;
555
14e04fb3 556 acpi_bus_generate_proc_event(tz->device, ACPI_THERMAL_NOTIFY_CRITICAL,
4be44fcd 557 tz->trips.critical.flags.enabled);
962ce8ca
ZR		 558 acpi_bus_generate_netlink_event(tz->device->pnp.device_class,
559 tz->device->dev.bus_id,
560 ACPI_THERMAL_NOTIFY_CRITICAL,
561 tz->trips.critical.flags.enabled);
1da177e4 562
223630fe
ZR		 563 /* take no action if nocrt is set */
564 if(!nocrt) {
565 printk(KERN_EMERG
566 "Critical temperature reached (%ld C), shutting down.\n",
567 KELVIN_TO_CELSIUS(tz->temperature));
568 orderly_poweroff(true);
569 }
1da177e4 570
d550d98d 571 return 0;
1da177e4
LT		 572}
573
4be44fcd 574static int acpi_thermal_hot(struct acpi_thermal *tz)
1da177e4 575{
223630fe 576 if (!tz || !tz->trips.hot.flags.valid)
d550d98d 577 return -EINVAL;
1da177e4
LT		 578
579 if (tz->temperature >= tz->trips.hot.temperature) {
cece9296 580 printk(KERN_WARNING PREFIX "Hot trip point\n");
1da177e4 581 tz->trips.hot.flags.enabled = 1;
4be44fcd 582 } else if (tz->trips.hot.flags.enabled)
1da177e4
LT		 583 tz->trips.hot.flags.enabled = 0;
584
14e04fb3 585 acpi_bus_generate_proc_event(tz->device, ACPI_THERMAL_NOTIFY_HOT,
4be44fcd 586 tz->trips.hot.flags.enabled);
962ce8ca
ZR		 587 acpi_bus_generate_netlink_event(tz->device->pnp.device_class,
588 tz->device->dev.bus_id,
589 ACPI_THERMAL_NOTIFY_HOT,
590 tz->trips.hot.flags.enabled);
1da177e4 591
223630fe 592 /* TBD: Call user-mode "sleep(S4)" function if nocrt is cleared */
1da177e4 593
d550d98d 594 return 0;
1da177e4
LT		 595}
596
1cbf4c56 597static void acpi_thermal_passive(struct acpi_thermal *tz)
1da177e4 598{
1cbf4c56 599 int result = 1;
1da177e4 600 struct acpi_thermal_passive *passive = NULL;
4be44fcd
LB		 601 int trend = 0;
602 int i = 0;
1da177e4 603
1da177e4
LT		 604
605 if (!tz || !tz->trips.passive.flags.valid)
1cbf4c56 606 return;
1da177e4
LT		 607
608 passive = &(tz->trips.passive);
609
610 /*
611 * Above Trip?
612 * -----------
613 * Calculate the thermal trend (using the passive cooling equation)
614 * and modify the performance limit for all passive cooling devices
615 * accordingly. Note that we assume symmetry.
616 */
617 if (tz->temperature >= passive->temperature) {
4be44fcd
LB		 618 trend =
619 (passive->tc1 * (tz->temperature - tz->last_temperature)) +
620 (passive->tc2 * (tz->temperature - passive->temperature));
621 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
622 "trend[%d]=(tc1[%lu]*(tmp[%lu]-last[%lu]))+(tc2[%lu]*(tmp[%lu]-psv[%lu]))\n",
623 trend, passive->tc1, tz->temperature,
624 tz->last_temperature, passive->tc2,
625 tz->temperature, passive->temperature));
1cbf4c56 626 passive->flags.enabled = 1;
1da177e4
LT		 627 /* Heating up? */
628 if (trend > 0)
4be44fcd
LB		 629 for (i = 0; i < passive->devices.count; i++)
630 acpi_processor_set_thermal_limit(passive->
631 devices.
632 handles[i],
633 ACPI_PROCESSOR_LIMIT_INCREMENT);
1da177e4 634 /* Cooling off? */
1cbf4c56 635 else if (trend < 0) {
4be44fcd 636 for (i = 0; i < passive->devices.count; i++)
1cbf4c56
TR		 637 /*
638 * assume that we are on highest
639 * freq/lowest thrott and can leave
640 * passive mode, even in error case
641 */
642 if (!acpi_processor_set_thermal_limit
643 (passive->devices.handles[i],
644 ACPI_PROCESSOR_LIMIT_DECREMENT))
645 result = 0;
646 /*
647 * Leave cooling mode, even if the temp might
648 * higher than trip point This is because some
649 * machines might have long thermal polling
650 * frequencies (tsp) defined. We will fall back
651 * into passive mode in next cycle (probably quicker)
652 */
653 if (result) {
654 passive->flags.enabled = 0;
655 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
656 "Disabling passive cooling, still above threshold,"
657 " but we are cooling down\n"));
658 }
659 }
660 return;
1da177e4
LT		 661 }
662
663 /*
664 * Below Trip?
665 * -----------
666 * Implement passive cooling hysteresis to slowly increase performance
667 * and avoid thrashing around the passive trip point. Note that we
668 * assume symmetry.
669 */
1cbf4c56
TR		 670 if (!passive->flags.enabled)
671 return;
672 for (i = 0; i < passive->devices.count; i++)
673 if (!acpi_processor_set_thermal_limit
674 (passive->devices.handles[i],
675 ACPI_PROCESSOR_LIMIT_DECREMENT))
676 result = 0;
677 if (result) {
678 passive->flags.enabled = 0;
679 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
680 "Disabling passive cooling (zone is cool)\n"));
1da177e4 681 }
1da177e4
LT		 682}
683
1cbf4c56 684static void acpi_thermal_active(struct acpi_thermal *tz)
1da177e4 685{
4be44fcd 686 int result = 0;
1da177e4 687 struct acpi_thermal_active *active = NULL;
4be44fcd
LB		 688 int i = 0;
689 int j = 0;
690 unsigned long maxtemp = 0;
1da177e4 691
1da177e4
LT		 692
693 if (!tz)
1cbf4c56 694 return;
1da177e4 695
4be44fcd 696 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1da177e4
LT		 697 active = &(tz->trips.active[i]);
698 if (!active || !active->flags.valid)
699 break;
1da177e4 700 if (tz->temperature >= active->temperature) {
1cbf4c56
TR		 701 /*
702 * Above Threshold?
703 * ----------------
704 * If not already enabled, turn ON all cooling devices
705 * associated with this active threshold.
706 */
1da177e4 707 if (active->temperature > maxtemp)
1cbf4c56
TR		 708 tz->state.active_index = i;
709 maxtemp = active->temperature;
710 if (active->flags.enabled)
711 continue;
1da177e4 712 for (j = 0; j < active->devices.count; j++) {
4be44fcd
LB		 713 result =
714 acpi_bus_set_power(active->devices.
715 handles[j],
1cbf4c56 716 ACPI_STATE_D0);
1da177e4 717 if (result) {
cece9296
LB		 718 printk(KERN_WARNING PREFIX
719 "Unable to turn cooling device [%p] 'on'\n",
a6fc6720 720 active->devices.
cece9296 721 handles[j]);
1da177e4
LT		 722 continue;
723 }
1cbf4c56 724 active->flags.enabled = 1;
4be44fcd 725 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1cbf4c56 726 "Cooling device [%p] now 'on'\n",
4be44fcd 727 active->devices.handles[j]));
1da177e4 728 }
1cbf4c56
TR		 729 continue;
730 }
731 if (!active->flags.enabled)
732 continue;
733 /*
734 * Below Threshold?
735 * ----------------
736 * Turn OFF all cooling devices associated with this
737 * threshold.
738 */
739 for (j = 0; j < active->devices.count; j++) {
740 result = acpi_bus_set_power(active->devices.handles[j],
741 ACPI_STATE_D3);
742 if (result) {
cece9296
LB		 743 printk(KERN_WARNING PREFIX
744 "Unable to turn cooling device [%p] 'off'\n",
745 active->devices.handles[j]);
1cbf4c56
TR		 746 continue;
747 }
748 active->flags.enabled = 0;
749 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
750 "Cooling device [%p] now 'off'\n",
751 active->devices.handles[j]));
1da177e4
LT		 752 }
753 }
1da177e4
LT		 754}
755
4be44fcd 756static void acpi_thermal_check(void *context);
1da177e4 757
4be44fcd 758static void acpi_thermal_run(unsigned long data)
1da177e4
LT		 759{
760 struct acpi_thermal *tz = (struct acpi_thermal *)data;
761 if (!tz->zombie)
b8d35192 762 acpi_os_execute(OSL_GPE_HANDLER, acpi_thermal_check, (void *)data);
1da177e4
LT		 763}
764
4be44fcd 765static void acpi_thermal_check(void *data)
1da177e4 766{
4be44fcd 767 int result = 0;
50dd0969 768 struct acpi_thermal *tz = data;
4be44fcd 769 unsigned long sleep_time = 0;
21bc42ab 770 unsigned long timeout_jiffies = 0;
4be44fcd 771 int i = 0;
1da177e4
LT		 772 struct acpi_thermal_state state;
773
1da177e4
LT		 774
775 if (!tz) {
6468463a 776 printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
d550d98d 777 return;
1da177e4
LT		 778 }
779
6e215785
AS		 780 /* Check if someone else is already running */
781 if (!mutex_trylock(&tz->lock))
782 return;
783
1da177e4
LT		 784 state = tz->state;
785
786 result = acpi_thermal_get_temperature(tz);
787 if (result)
6e215785 788 goto unlock;
4be44fcd 789
3f655ef8
ZR		 790 if (!tz->tz_enabled)
791 goto unlock;
792
1da177e4 793 memset(&tz->state, 0, sizeof(tz->state));
4be44fcd 794
1da177e4
LT		 795 /*
796 * Check Trip Points
797 * -----------------
798 * Compare the current temperature to the trip point values to see
799 * if we've entered one of the thermal policy states. Note that
800 * this function determines when a state is entered, but the
801 * individual policy decides when it is exited (e.g. hysteresis).
802 */
803 if (tz->trips.critical.flags.valid)
4be44fcd
LB		 804 state.critical |=
805 (tz->temperature >= tz->trips.critical.temperature);
1da177e4
LT		 806 if (tz->trips.hot.flags.valid)
807 state.hot |= (tz->temperature >= tz->trips.hot.temperature);
808 if (tz->trips.passive.flags.valid)
4be44fcd
LB		 809 state.passive |=
810 (tz->temperature >= tz->trips.passive.temperature);
811 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
1da177e4 812 if (tz->trips.active[i].flags.valid)
4be44fcd
LB		 813 state.active |=
814 (tz->temperature >=
815 tz->trips.active[i].temperature);
1da177e4
LT		 816
817 /*
818 * Invoke Policy
819 * -------------
820 * Separated from the above check to allow individual policy to
821 * determine when to exit a given state.
822 */
823 if (state.critical)
824 acpi_thermal_critical(tz);
825 if (state.hot)
826 acpi_thermal_hot(tz);
827 if (state.passive)
828 acpi_thermal_passive(tz);
829 if (state.active)
830 acpi_thermal_active(tz);
831
832 /*
833 * Calculate State
834 * ---------------
835 * Again, separated from the above two to allow independent policy
836 * decisions.
837 */
1cbf4c56
TR		 838 tz->state.critical = tz->trips.critical.flags.enabled;
839 tz->state.hot = tz->trips.hot.flags.enabled;
840 tz->state.passive = tz->trips.passive.flags.enabled;
841 tz->state.active = 0;
4be44fcd 842 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
1cbf4c56 843 tz->state.active |= tz->trips.active[i].flags.enabled;
1da177e4
LT		 844
845 /*
846 * Calculate Sleep Time
847 * --------------------
848 * If we're in the passive state, use _TSP's value. Otherwise
849 * use the default polling frequency (e.g. _TZP). If no polling
850 * frequency is specified then we'll wait forever (at least until
851 * a thermal event occurs). Note that _TSP and _TZD values are
852 * given in 1/10th seconds (we must covert to milliseconds).
853 */
21bc42ab 854 if (tz->state.passive) {
1da177e4 855 sleep_time = tz->trips.passive.tsp * 100;
21bc42ab
LB		 856 timeout_jiffies = jiffies + (HZ * sleep_time) / 1000;
857 } else if (tz->polling_frequency > 0) {
1da177e4 858 sleep_time = tz->polling_frequency * 100;
21bc42ab
LB		 859 timeout_jiffies = round_jiffies(jiffies + (HZ * sleep_time) / 1000);
860 }
1da177e4 861
4be44fcd
LB		 862 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: temperature[%lu] sleep[%lu]\n",
863 tz->name, tz->temperature, sleep_time));
1da177e4
LT		 864
865 /*
866 * Schedule Next Poll
867 * ------------------
868 */
869 if (!sleep_time) {
870 if (timer_pending(&(tz->timer)))
871 del_timer(&(tz->timer));
4be44fcd 872 } else {
1da177e4 873 if (timer_pending(&(tz->timer)))
21bc42ab 874 mod_timer(&(tz->timer), timeout_jiffies);
1da177e4 875 else {
4be44fcd 876 tz->timer.data = (unsigned long)tz;
1da177e4 877 tz->timer.function = acpi_thermal_run;
21bc42ab 878 tz->timer.expires = timeout_jiffies;
1da177e4
LT		 879 add_timer(&(tz->timer));
880 }
881 }
6e215785
AS		 882 unlock:
883 mutex_unlock(&tz->lock);
1da177e4
LT		 884}
885
3f655ef8 886/* sys I/F for generic thermal sysfs support */
5e012760
ZR		 887#define KELVIN_TO_MILLICELSIUS(t) (t * 100 - 273200)
888
3f655ef8
ZR		 889static int thermal_get_temp(struct thermal_zone_device *thermal, char *buf)
890{
891 struct acpi_thermal *tz = thermal->devdata;
892
893 if (!tz)
894 return -EINVAL;
895
5e012760 896 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(tz->temperature));
3f655ef8
ZR		 897}
898
899static const char enabled[] = "kernel";
900static const char disabled[] = "user";
901static int thermal_get_mode(struct thermal_zone_device *thermal,
902 char *buf)
903{
904 struct acpi_thermal *tz = thermal->devdata;
905
906 if (!tz)
907 return -EINVAL;
908
909 return sprintf(buf, "%s\n", tz->tz_enabled ?
910 enabled : disabled);
911}
912
913static int thermal_set_mode(struct thermal_zone_device *thermal,
914 const char *buf)
915{
916 struct acpi_thermal *tz = thermal->devdata;
917 int enable;
918
919 if (!tz)
920 return -EINVAL;
921
922 /*
923 * enable/disable thermal management from ACPI thermal driver
924 */
925 if (!strncmp(buf, enabled, sizeof enabled - 1))
926 enable = 1;
927 else if (!strncmp(buf, disabled, sizeof disabled - 1))
928 enable = 0;
929 else
930 return -EINVAL;
931
932 if (enable != tz->tz_enabled) {
933 tz->tz_enabled = enable;
934 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
935 "%s ACPI thermal control\n",
936 tz->tz_enabled ? enabled : disabled));
937 acpi_thermal_check(tz);
938 }
939 return 0;
940}
941
942static int thermal_get_trip_type(struct thermal_zone_device *thermal,
943 int trip, char *buf)
944{
945 struct acpi_thermal *tz = thermal->devdata;
946 int i;
947
948 if (!tz || trip < 0)
949 return -EINVAL;
950
951 if (tz->trips.critical.flags.valid) {
952 if (!trip)
953 return sprintf(buf, "critical\n");
954 trip--;
955 }
956
957 if (tz->trips.hot.flags.valid) {
958 if (!trip)
959 return sprintf(buf, "hot\n");
960 trip--;
961 }
962
963 if (tz->trips.passive.flags.valid) {
964 if (!trip)
965 return sprintf(buf, "passive\n");
966 trip--;
967 }
968
969 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
970 tz->trips.active[i].flags.valid; i++) {
971 if (!trip)
972 return sprintf(buf, "active%d\n", i);
973 trip--;
974 }
975
976 return -EINVAL;
977}
978
979static int thermal_get_trip_temp(struct thermal_zone_device *thermal,
980 int trip, char *buf)
981{
982 struct acpi_thermal *tz = thermal->devdata;
983 int i;
984
985 if (!tz || trip < 0)
986 return -EINVAL;
987
988 if (tz->trips.critical.flags.valid) {
989 if (!trip)
5e012760 990 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(
3f655ef8
ZR		 991 tz->trips.critical.temperature));
992 trip--;
993 }
994
995 if (tz->trips.hot.flags.valid) {
996 if (!trip)
5e012760 997 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(
3f655ef8
ZR		 998 tz->trips.hot.temperature));
999 trip--;
1000 }
1001
1002 if (tz->trips.passive.flags.valid) {
1003 if (!trip)
5e012760 1004 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(
3f655ef8
ZR		 1005 tz->trips.passive.temperature));
1006 trip--;
1007 }
1008
1009 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
1010 tz->trips.active[i].flags.valid; i++) {
1011 if (!trip)
5e012760 1012 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(
3f655ef8
ZR		 1013 tz->trips.active[i].temperature));
1014 trip--;
1015 }
1016
1017 return -EINVAL;
1018}
1019
1020typedef int (*cb)(struct thermal_zone_device *, int,
1021 struct thermal_cooling_device *);
1022static int acpi_thermal_cooling_device_cb(struct thermal_zone_device *thermal,
1023 struct thermal_cooling_device *cdev,
1024 cb action)
1025{
1026 struct acpi_device *device = cdev->devdata;
1027 struct acpi_thermal *tz = thermal->devdata;
653a00c9
ZR		 1028 struct acpi_device *dev;
1029 acpi_status status;
1030 acpi_handle handle;
3f655ef8
ZR		 1031 int i;
1032 int j;
1033 int trip = -1;
1034 int result = 0;
1035
1036 if (tz->trips.critical.flags.valid)
1037 trip++;
1038
1039 if (tz->trips.hot.flags.valid)
1040 trip++;
1041
1042 if (tz->trips.passive.flags.valid) {
1043 trip++;
1044 for (i = 0; i < tz->trips.passive.devices.count;
1045 i++) {
653a00c9
ZR		 1046 handle = tz->trips.passive.devices.handles[i];
1047 status = acpi_bus_get_device(handle, &dev);
1048 if (ACPI_SUCCESS(status) && (dev == device)) {
1049 result = action(thermal, trip, cdev);
1050 if (result)
1051 goto failed;
1052 }
3f655ef8
ZR		 1053 }
1054 }
1055
1056 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1057 if (!tz->trips.active[i].flags.valid)
1058 break;
1059 trip++;
1060 for (j = 0;
1061 j < tz->trips.active[i].devices.count;
1062 j++) {
653a00c9
ZR		 1063 handle = tz->trips.active[i].devices.handles[j];
1064 status = acpi_bus_get_device(handle, &dev);
1065 if (ACPI_SUCCESS(status) && (dev == device)) {
1066 result = action(thermal, trip, cdev);
1067 if (result)
1068 goto failed;
1069 }
3f655ef8
ZR		 1070 }
1071 }
1072
1073 for (i = 0; i < tz->devices.count; i++) {
653a00c9
ZR		 1074 handle = tz->devices.handles[i];
1075 status = acpi_bus_get_device(handle, &dev);
1076 if (ACPI_SUCCESS(status) && (dev == device)) {
1077 result = action(thermal, -1, cdev);
1078 if (result)
1079 goto failed;
1080 }
3f655ef8
ZR		 1081 }
1082
1083failed:
1084 return result;
1085}
1086
1087static int
1088acpi_thermal_bind_cooling_device(struct thermal_zone_device *thermal,
1089 struct thermal_cooling_device *cdev)
1090{
1091 return acpi_thermal_cooling_device_cb(thermal, cdev,
1092 thermal_zone_bind_cooling_device);
1093}
1094
1095static int
1096acpi_thermal_unbind_cooling_device(struct thermal_zone_device *thermal,
1097 struct thermal_cooling_device *cdev)
1098{
1099 return acpi_thermal_cooling_device_cb(thermal, cdev,
1100 thermal_zone_unbind_cooling_device);
1101}
1102
1103static struct thermal_zone_device_ops acpi_thermal_zone_ops = {
1104 .bind = acpi_thermal_bind_cooling_device,
1105 .unbind = acpi_thermal_unbind_cooling_device,
1106 .get_temp = thermal_get_temp,
1107 .get_mode = thermal_get_mode,
1108 .set_mode = thermal_set_mode,
1109 .get_trip_type = thermal_get_trip_type,
1110 .get_trip_temp = thermal_get_trip_temp,
1111};
1112
1113static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz)
1114{
1115 int trips = 0;
1116 int result;
20733939 1117 acpi_status status;
3f655ef8
ZR		 1118 int i;
1119
1120 if (tz->trips.critical.flags.valid)
1121 trips++;
1122
1123 if (tz->trips.hot.flags.valid)
1124 trips++;
1125
1126 if (tz->trips.passive.flags.valid)
1127 trips++;
1128
1129 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
1130 tz->trips.active[i].flags.valid; i++, trips++);
1131 tz->thermal_zone = thermal_zone_device_register("ACPI thermal zone",
1132 trips, tz, &acpi_thermal_zone_ops);
bb070e43 1133 if (IS_ERR(tz->thermal_zone))
3f655ef8
ZR		 1134 return -ENODEV;
1135
1136 result = sysfs_create_link(&tz->device->dev.kobj,
1137 &tz->thermal_zone->device.kobj, "thermal_zone");
1138 if (result)
1139 return result;
1140
1141 result = sysfs_create_link(&tz->thermal_zone->device.kobj,
1142 &tz->device->dev.kobj, "device");
1143 if (result)
1144 return result;
1145
20733939
ZR		 1146 status = acpi_attach_data(tz->device->handle,
1147 acpi_bus_private_data_handler,
1148 tz->thermal_zone);
1149 if (ACPI_FAILURE(status)) {
1150 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1151 "Error attaching device data\n"));
1152 return -ENODEV;
1153 }
1154
3f655ef8
ZR		 1155 tz->tz_enabled = 1;
1156
1157 printk(KERN_INFO PREFIX "%s is registered as thermal_zone%d\n",
1158 tz->device->dev.bus_id, tz->thermal_zone->id);
1159 return 0;
1160}
1161
1162static void acpi_thermal_unregister_thermal_zone(struct acpi_thermal *tz)
1163{
1164 sysfs_remove_link(&tz->device->dev.kobj, "thermal_zone");
1165 sysfs_remove_link(&tz->thermal_zone->device.kobj, "device");
1166 thermal_zone_device_unregister(tz->thermal_zone);
1167 tz->thermal_zone = NULL;
20733939 1168 acpi_detach_data(tz->device->handle, acpi_bus_private_data_handler);
3f655ef8
ZR		 1169}
1170
1171
1da177e4
LT		 1172/* --------------------------------------------------------------------------
1173 FS Interface (/proc)
1174 -------------------------------------------------------------------------- */
1175
4be44fcd 1176static struct proc_dir_entry *acpi_thermal_dir;
1da177e4
LT		 1177
1178static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
1179{
50dd0969 1180 struct acpi_thermal *tz = seq->private;
1da177e4 1181
1da177e4
LT		 1182
1183 if (!tz)
1184 goto end;
1185
1186 seq_puts(seq, "state: ");
1187
4be44fcd
LB		 1188 if (!tz->state.critical && !tz->state.hot && !tz->state.passive
1189 && !tz->state.active)
1da177e4
LT		 1190 seq_puts(seq, "ok\n");
1191 else {
1192 if (tz->state.critical)
1193 seq_puts(seq, "critical ");
1194 if (tz->state.hot)
1195 seq_puts(seq, "hot ");
1196 if (tz->state.passive)
1197 seq_puts(seq, "passive ");
1198 if (tz->state.active)
1199 seq_printf(seq, "active[%d]", tz->state.active_index);
1200 seq_puts(seq, "\n");
1201 }
1202
4be44fcd 1203 end:
d550d98d 1204 return 0;
1da177e4
LT		 1205}
1206
1207static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file)
1208{
1209 return single_open(file, acpi_thermal_state_seq_show, PDE(inode)->data);
1210}
1211
1da177e4
LT		 1212static int acpi_thermal_temp_seq_show(struct seq_file *seq, void *offset)
1213{
4be44fcd 1214 int result = 0;
50dd0969 1215 struct acpi_thermal *tz = seq->private;
1da177e4 1216
1da177e4
LT		 1217
1218 if (!tz)
1219 goto end;
1220
1221 result = acpi_thermal_get_temperature(tz);
1222 if (result)
1223 goto end;
1224
4be44fcd
LB		 1225 seq_printf(seq, "temperature: %ld C\n",
1226 KELVIN_TO_CELSIUS(tz->temperature));
1da177e4 1227
4be44fcd 1228 end:
d550d98d 1229 return 0;
1da177e4
LT		 1230}
1231
1232static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file)
1233{
1234 return single_open(file, acpi_thermal_temp_seq_show, PDE(inode)->data);
1235}
1236
1da177e4
LT		 1237static int acpi_thermal_trip_seq_show(struct seq_file *seq, void *offset)
1238{
50dd0969 1239 struct acpi_thermal *tz = seq->private;
68ccfaa8 1240 struct acpi_device *device;
e7c746ef
TR		 1241 acpi_status status;
1242
4be44fcd
LB		 1243 int i = 0;
1244 int j = 0;
1da177e4 1245
1da177e4
LT		 1246
1247 if (!tz)
1248 goto end;
1249
1250 if (tz->trips.critical.flags.valid)
f5487145
LB		 1251 seq_printf(seq, "critical (S5): %ld C%s",
1252 KELVIN_TO_CELSIUS(tz->trips.critical.temperature),
1253 nocrt ? " <disabled>\n" : "\n");
1da177e4
LT		 1254
1255 if (tz->trips.hot.flags.valid)
f5487145
LB		 1256 seq_printf(seq, "hot (S4): %ld C%s",
1257 KELVIN_TO_CELSIUS(tz->trips.hot.temperature),
1258 nocrt ? " <disabled>\n" : "\n");
1da177e4
LT		 1259
1260 if (tz->trips.passive.flags.valid) {
4be44fcd
LB		 1261 seq_printf(seq,
1262 "passive: %ld C: tc1=%lu tc2=%lu tsp=%lu devices=",
1263 KELVIN_TO_CELSIUS(tz->trips.passive.temperature),
1264 tz->trips.passive.tc1, tz->trips.passive.tc2,
1265 tz->trips.passive.tsp);
1266 for (j = 0; j < tz->trips.passive.devices.count; j++) {
e7c746ef
TR		 1267 status = acpi_bus_get_device(tz->trips.passive.devices.
1268 handles[j], &device);
1269 seq_printf(seq, "%4.4s ", status ? "" :
1270 acpi_device_bid(device));
1da177e4
LT		 1271 }
1272 seq_puts(seq, "\n");
1273 }
1274
1275 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1276 if (!(tz->trips.active[i].flags.valid))
1277 break;
1278 seq_printf(seq, "active[%d]: %ld C: devices=",
4be44fcd
LB		 1279 i,
1280 KELVIN_TO_CELSIUS(tz->trips.active[i].temperature));
68ccfaa8 1281 for (j = 0; j < tz->trips.active[i].devices.count; j++){
e7c746ef
TR		 1282 status = acpi_bus_get_device(tz->trips.active[i].
1283 devices.handles[j],
1284 &device);
1285 seq_printf(seq, "%4.4s ", status ? "" :
1286 acpi_device_bid(device));
68ccfaa8 1287 }
1da177e4
LT		 1288 seq_puts(seq, "\n");
1289 }
1290
4be44fcd 1291 end:
d550d98d 1292 return 0;
1da177e4
LT		 1293}
1294
1295static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file)
1296{
1297 return single_open(file, acpi_thermal_trip_seq_show, PDE(inode)->data);
1298}
1299
1da177e4
LT		 1300static int acpi_thermal_cooling_seq_show(struct seq_file *seq, void *offset)
1301{
50dd0969 1302 struct acpi_thermal *tz = seq->private;
1da177e4 1303
1da177e4
LT		 1304
1305 if (!tz)
1306 goto end;
1307
eaca2d3f 1308 if (!tz->flags.cooling_mode)
1da177e4 1309 seq_puts(seq, "<setting not supported>\n");
1da177e4 1310 else
eaca2d3f 1311 seq_puts(seq, "0 - Active; 1 - Passive\n");
1da177e4 1312
4be44fcd 1313 end:
d550d98d 1314 return 0;
1da177e4
LT		 1315}
1316
1317static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file)
1318{
1319 return single_open(file, acpi_thermal_cooling_seq_show,
4be44fcd 1320 PDE(inode)->data);
1da177e4
LT		 1321}
1322
1323static ssize_t
4be44fcd
LB		 1324acpi_thermal_write_cooling_mode(struct file *file,
1325 const char __user * buffer,
1326 size_t count, loff_t * ppos)
1da177e4 1327{
50dd0969
JE		 1328 struct seq_file *m = file->private_data;
1329 struct acpi_thermal *tz = m->private;
4be44fcd
LB		 1330 int result = 0;
1331 char mode_string[12] = { '\0' };
1da177e4 1332
1da177e4
LT		 1333
1334 if (!tz || (count > sizeof(mode_string) - 1))
d550d98d 1335 return -EINVAL;
1da177e4
LT		 1336
1337 if (!tz->flags.cooling_mode)
d550d98d 1338 return -ENODEV;
1da177e4
LT		 1339
1340 if (copy_from_user(mode_string, buffer, count))
d550d98d 1341 return -EFAULT;
4be44fcd 1342
1da177e4 1343 mode_string[count] = '\0';
4be44fcd
LB		 1344
1345 result = acpi_thermal_set_cooling_mode(tz,
1346 simple_strtoul(mode_string, NULL,
1347 0));
1da177e4 1348 if (result)
d550d98d 1349 return result;
1da177e4
LT		 1350
1351 acpi_thermal_check(tz);
1352
d550d98d 1353 return count;
1da177e4
LT		 1354}
1355
1da177e4
LT		 1356static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
1357{
50dd0969 1358 struct acpi_thermal *tz = seq->private;
1da177e4 1359
1da177e4
LT		 1360
1361 if (!tz)
1362 goto end;
1363
1364 if (!tz->polling_frequency) {
1365 seq_puts(seq, "<polling disabled>\n");
1366 goto end;
1367 }
1368
1369 seq_printf(seq, "polling frequency: %lu seconds\n",
4be44fcd 1370 (tz->polling_frequency / 10));
1da177e4 1371
4be44fcd 1372 end:
d550d98d 1373 return 0;
1da177e4
LT		 1374}
1375
1376static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file)
1377{
1378 return single_open(file, acpi_thermal_polling_seq_show,
4be44fcd 1379 PDE(inode)->data);
1da177e4
LT		 1380}
1381
1382static ssize_t
4be44fcd
LB		 1383acpi_thermal_write_polling(struct file *file,
1384 const char __user * buffer,
1385 size_t count, loff_t * ppos)
1da177e4 1386{
50dd0969
JE		 1387 struct seq_file *m = file->private_data;
1388 struct acpi_thermal *tz = m->private;
4be44fcd
LB		 1389 int result = 0;
1390 char polling_string[12] = { '\0' };
1391 int seconds = 0;
1da177e4 1392
1da177e4
LT		 1393
1394 if (!tz || (count > sizeof(polling_string) - 1))
d550d98d 1395 return -EINVAL;
4be44fcd 1396
1da177e4 1397 if (copy_from_user(polling_string, buffer, count))
d550d98d 1398 return -EFAULT;
4be44fcd 1399
1da177e4
LT		 1400 polling_string[count] = '\0';
1401
1402 seconds = simple_strtoul(polling_string, NULL, 0);
4be44fcd 1403
1da177e4
LT		 1404 result = acpi_thermal_set_polling(tz, seconds);
1405 if (result)
d550d98d 1406 return result;
1da177e4
LT		 1407
1408 acpi_thermal_check(tz);
1409
d550d98d 1410 return count;
1da177e4
LT		 1411}
1412
4be44fcd 1413static int acpi_thermal_add_fs(struct acpi_device *device)
1da177e4 1414{
4be44fcd 1415 struct proc_dir_entry *entry = NULL;
1da177e4 1416
1da177e4
LT		 1417
1418 if (!acpi_device_dir(device)) {
1419 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
4be44fcd 1420 acpi_thermal_dir);
1da177e4 1421 if (!acpi_device_dir(device))
d550d98d 1422 return -ENODEV;
1da177e4
LT		 1423 acpi_device_dir(device)->owner = THIS_MODULE;
1424 }
1425
1426 /* 'state' [R] */
cf7acfab
DL		 1427 entry = proc_create_data(ACPI_THERMAL_FILE_STATE,
1428 S_IRUGO, acpi_device_dir(device),
1429 &acpi_thermal_state_fops,
1430 acpi_driver_data(device));
1da177e4 1431 if (!entry)
d550d98d 1432 return -ENODEV;
1da177e4
LT		 1433
1434 /* 'temperature' [R] */
cf7acfab
DL		 1435 entry = proc_create_data(ACPI_THERMAL_FILE_TEMPERATURE,
1436 S_IRUGO, acpi_device_dir(device),
1437 &acpi_thermal_temp_fops,
1438 acpi_driver_data(device));
1da177e4 1439 if (!entry)
d550d98d 1440 return -ENODEV;
1da177e4 1441
2db9ccba 1442 /* 'trip_points' [R] */
cf7acfab
DL		 1443 entry = proc_create_data(ACPI_THERMAL_FILE_TRIP_POINTS,
1444 S_IRUGO,
1445 acpi_device_dir(device),
1446 &acpi_thermal_trip_fops,
1447 acpi_driver_data(device));
1da177e4 1448 if (!entry)
d550d98d 1449 return -ENODEV;
1da177e4
LT		 1450
1451 /* 'cooling_mode' [R/W] */
cf7acfab
DL		 1452 entry = proc_create_data(ACPI_THERMAL_FILE_COOLING_MODE,
1453 S_IFREG | S_IRUGO | S_IWUSR,
1454 acpi_device_dir(device),
1455 &acpi_thermal_cooling_fops,
1456 acpi_driver_data(device));
1da177e4 1457 if (!entry)
d550d98d 1458 return -ENODEV;
1da177e4
LT		 1459
1460 /* 'polling_frequency' [R/W] */
cf7acfab
DL		 1461 entry = proc_create_data(ACPI_THERMAL_FILE_POLLING_FREQ,
1462 S_IFREG | S_IRUGO | S_IWUSR,
1463 acpi_device_dir(device),
1464 &acpi_thermal_polling_fops,
1465 acpi_driver_data(device));
1da177e4 1466 if (!entry)
d550d98d 1467 return -ENODEV;
d550d98d 1468 return 0;
1da177e4
LT		 1469}
1470
4be44fcd 1471static int acpi_thermal_remove_fs(struct acpi_device *device)
1da177e4 1472{
1da177e4
LT		 1473
1474 if (acpi_device_dir(device)) {
1475 remove_proc_entry(ACPI_THERMAL_FILE_POLLING_FREQ,
1476 acpi_device_dir(device));
1477 remove_proc_entry(ACPI_THERMAL_FILE_COOLING_MODE,
1478 acpi_device_dir(device));
1479 remove_proc_entry(ACPI_THERMAL_FILE_TRIP_POINTS,
1480 acpi_device_dir(device));
1481 remove_proc_entry(ACPI_THERMAL_FILE_TEMPERATURE,
1482 acpi_device_dir(device));
1483 remove_proc_entry(ACPI_THERMAL_FILE_STATE,
1484 acpi_device_dir(device));
1485 remove_proc_entry(acpi_device_bid(device), acpi_thermal_dir);
1486 acpi_device_dir(device) = NULL;
1487 }
1488
d550d98d 1489 return 0;
1da177e4
LT		 1490}
1491
1da177e4
LT		 1492/* --------------------------------------------------------------------------
1493 Driver Interface
1494 -------------------------------------------------------------------------- */
1495
4be44fcd 1496static void acpi_thermal_notify(acpi_handle handle, u32 event, void *data)
1da177e4 1497{
50dd0969 1498 struct acpi_thermal *tz = data;
4be44fcd 1499 struct acpi_device *device = NULL;
1da177e4 1500
1da177e4
LT		 1501
1502 if (!tz)
d550d98d 1503 return;
1da177e4 1504
8348e1b1 1505 device = tz->device;
1da177e4
LT		 1506
1507 switch (event) {
1508 case ACPI_THERMAL_NOTIFY_TEMPERATURE:
1509 acpi_thermal_check(tz);
1510 break;
1511 case ACPI_THERMAL_NOTIFY_THRESHOLDS:
ce44e197 1512 acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_THRESHOLDS);
1da177e4 1513 acpi_thermal_check(tz);
14e04fb3 1514 acpi_bus_generate_proc_event(device, event, 0);
962ce8ca
ZR		 1515 acpi_bus_generate_netlink_event(device->pnp.device_class,
1516 device->dev.bus_id, event, 0);
1da177e4
LT		 1517 break;
1518 case ACPI_THERMAL_NOTIFY_DEVICES:
ce44e197
ZR		 1519 acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_DEVICES);
1520 acpi_thermal_check(tz);
14e04fb3 1521 acpi_bus_generate_proc_event(device, event, 0);
962ce8ca
ZR		 1522 acpi_bus_generate_netlink_event(device->pnp.device_class,
1523 device->dev.bus_id, event, 0);
1da177e4
LT		 1524 break;
1525 default:
1526 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
4be44fcd 1527 "Unsupported event [0x%x]\n", event));
1da177e4
LT		 1528 break;
1529 }
1530
d550d98d 1531 return;
1da177e4
LT		 1532}
1533
4be44fcd 1534static int acpi_thermal_get_info(struct acpi_thermal *tz)
1da177e4 1535{
4be44fcd 1536 int result = 0;
1da177e4 1537
1da177e4
LT		 1538
1539 if (!tz)
d550d98d 1540 return -EINVAL;
1da177e4
LT		 1541
1542 /* Get temperature [_TMP] (required) */
1543 result = acpi_thermal_get_temperature(tz);
1544 if (result)
d550d98d 1545 return result;
1da177e4
LT		 1546
1547 /* Get trip points [_CRT, _PSV, etc.] (required) */
1548 result = acpi_thermal_get_trip_points(tz);
1549 if (result)
d550d98d 1550 return result;
1da177e4
LT		 1551
1552 /* Set the cooling mode [_SCP] to active cooling (default) */
1553 result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
4be44fcd 1554 if (!result)
1da177e4 1555 tz->flags.cooling_mode = 1;
1da177e4
LT		 1556
1557 /* Get default polling frequency [_TZP] (optional) */
1558 if (tzp)
1559 tz->polling_frequency = tzp;
1560 else
1561 acpi_thermal_get_polling_frequency(tz);
1562
d550d98d 1563 return 0;
1da177e4
LT		 1564}
1565
4be44fcd 1566static int acpi_thermal_add(struct acpi_device *device)
1da177e4 1567{
4be44fcd
LB		 1568 int result = 0;
1569 acpi_status status = AE_OK;
1570 struct acpi_thermal *tz = NULL;
1da177e4 1571
1da177e4
LT		 1572
1573 if (!device)
d550d98d 1574 return -EINVAL;
1da177e4 1575
36bcbec7 1576 tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
1da177e4 1577 if (!tz)
d550d98d 1578 return -ENOMEM;
1da177e4 1579
8348e1b1 1580 tz->device = device;
1da177e4
LT		 1581 strcpy(tz->name, device->pnp.bus_id);
1582 strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
1583 strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
1584 acpi_driver_data(device) = tz;
6e215785 1585 mutex_init(&tz->lock);
3f655ef8
ZR		 1586
1587
1da177e4
LT		 1588 result = acpi_thermal_get_info(tz);
1589 if (result)
3f655ef8
ZR		 1590 goto free_memory;
1591
1592 result = acpi_thermal_register_thermal_zone(tz);
1593 if (result)
1594 goto free_memory;
1da177e4
LT		 1595
1596 result = acpi_thermal_add_fs(device);
1597 if (result)
3f655ef8 1598 goto unregister_thermal_zone;
1da177e4
LT		 1599
1600 init_timer(&tz->timer);
1601
1602 acpi_thermal_check(tz);
1603
38ba7c9e 1604 status = acpi_install_notify_handler(device->handle,
4be44fcd
LB		 1605 ACPI_DEVICE_NOTIFY,
1606 acpi_thermal_notify, tz);
1da177e4 1607 if (ACPI_FAILURE(status)) {
1da177e4 1608 result = -ENODEV;
3f655ef8 1609 goto remove_fs;
1da177e4
LT		 1610 }
1611
1612 printk(KERN_INFO PREFIX "%s [%s] (%ld C)\n",
4be44fcd
LB		 1613 acpi_device_name(device), acpi_device_bid(device),
1614 KELVIN_TO_CELSIUS(tz->temperature));
3f655ef8 1615 goto end;
1da177e4 1616
3f655ef8
ZR		 1617remove_fs:
1618 acpi_thermal_remove_fs(device);
1619unregister_thermal_zone:
1620 thermal_zone_device_unregister(tz->thermal_zone);
1621free_memory:
1622 kfree(tz);
1623end:
d550d98d 1624 return result;
1da177e4
LT		 1625}
1626
4be44fcd 1627static int acpi_thermal_remove(struct acpi_device *device, int type)
1da177e4 1628{
4be44fcd
LB		 1629 acpi_status status = AE_OK;
1630 struct acpi_thermal *tz = NULL;
1da177e4 1631
1da177e4
LT		 1632
1633 if (!device || !acpi_driver_data(device))
d550d98d 1634 return -EINVAL;
1da177e4 1635
50dd0969 1636 tz = acpi_driver_data(device);
1da177e4
LT		 1637
1638 /* avoid timer adding new defer task */
1639 tz->zombie = 1;
1640 /* wait for running timer (on other CPUs) finish */
1641 del_timer_sync(&(tz->timer));
1642 /* synchronize deferred task */
1643 acpi_os_wait_events_complete(NULL);
1644 /* deferred task may reinsert timer */
1645 del_timer_sync(&(tz->timer));
1646
38ba7c9e 1647 status = acpi_remove_notify_handler(device->handle,
4be44fcd
LB		 1648 ACPI_DEVICE_NOTIFY,
1649 acpi_thermal_notify);
1da177e4
LT		 1650
1651 /* Terminate policy */
4be44fcd 1652 if (tz->trips.passive.flags.valid && tz->trips.passive.flags.enabled) {
1da177e4
LT		 1653 tz->trips.passive.flags.enabled = 0;
1654 acpi_thermal_passive(tz);
1655 }
1656 if (tz->trips.active[0].flags.valid
4be44fcd 1657 && tz->trips.active[0].flags.enabled) {
1da177e4
LT		 1658 tz->trips.active[0].flags.enabled = 0;
1659 acpi_thermal_active(tz);
1660 }
1661
1662 acpi_thermal_remove_fs(device);
3f655ef8 1663 acpi_thermal_unregister_thermal_zone(tz);
6e215785 1664 mutex_destroy(&tz->lock);
1da177e4 1665 kfree(tz);
d550d98d 1666 return 0;
1da177e4
LT		 1667}
1668
5d9464a4 1669static int acpi_thermal_resume(struct acpi_device *device)
74ce1468
KK		 1670{
1671 struct acpi_thermal *tz = NULL;
b1028c54
KK		 1672 int i, j, power_state, result;
1673
74ce1468
KK		 1674
1675 if (!device || !acpi_driver_data(device))
d550d98d 1676 return -EINVAL;
74ce1468 1677
50dd0969 1678 tz = acpi_driver_data(device);
74ce1468 1679
bed936f7 1680 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
b1028c54
KK		 1681 if (!(&tz->trips.active[i]))
1682 break;
1683 if (!tz->trips.active[i].flags.valid)
1684 break;
1685 tz->trips.active[i].flags.enabled = 1;
1686 for (j = 0; j < tz->trips.active[i].devices.count; j++) {
1687 result = acpi_bus_get_power(tz->trips.active[i].devices.
1688 handles[j], &power_state);
1689 if (result || (power_state != ACPI_STATE_D0)) {
1690 tz->trips.active[i].flags.enabled = 0;
1691 break;
1692 }
bed936f7 1693 }
b1028c54 1694 tz->state.active |= tz->trips.active[i].flags.enabled;
bed936f7
KK		 1695 }
1696
b1028c54 1697 acpi_thermal_check(tz);
74ce1468
KK		 1698
1699 return AE_OK;
1700}
1701
1855256c 1702static int thermal_act(const struct dmi_system_id *d) {
0b5bfa1c
LB		 1703
1704 if (act == 0) {
1705 printk(KERN_NOTICE "ACPI: %s detected: "
1706 "disabling all active thermal trip points\n", d->ident);
1707 act = -1;
1708 }
1709 return 0;
1710}
1855256c 1711static int thermal_nocrt(const struct dmi_system_id *d) {
8c99fdce
LB		 1712
1713 printk(KERN_NOTICE "ACPI: %s detected: "
1714 "disabling all critical thermal trip point actions.\n", d->ident);
1715 nocrt = 1;
1716 return 0;
1717}
1855256c 1718static int thermal_tzp(const struct dmi_system_id *d) {
0b5bfa1c
LB		 1719
1720 if (tzp == 0) {
1721 printk(KERN_NOTICE "ACPI: %s detected: "
1722 "enabling thermal zone polling\n", d->ident);
1723 tzp = 300; /* 300 dS = 30 Seconds */
1724 }
1725 return 0;
1726}
1855256c 1727static int thermal_psv(const struct dmi_system_id *d) {
0b5bfa1c
LB		 1728
1729 if (psv == 0) {
1730 printk(KERN_NOTICE "ACPI: %s detected: "
1731 "disabling all passive thermal trip points\n", d->ident);
1732 psv = -1;
1733 }
1734 return 0;
1735}
1736
1737static struct dmi_system_id thermal_dmi_table[] __initdata = {
1738 /*
1739 * Award BIOS on this AOpen makes thermal control almost worthless.
1740 * http://bugzilla.kernel.org/show_bug.cgi?id=8842
1741 */
1742 {
1743 .callback = thermal_act,
1744 .ident = "AOpen i915GMm-HFS",
1745 .matches = {
1746 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1747 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1748 },
1749 },
1750 {
1751 .callback = thermal_psv,
1752 .ident = "AOpen i915GMm-HFS",
1753 .matches = {
1754 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1755 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1756 },
1757 },
1758 {
1759 .callback = thermal_tzp,
1760 .ident = "AOpen i915GMm-HFS",
1761 .matches = {
1762 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1763 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1764 },
1765 },
8c99fdce
LB		 1766 {
1767 .callback = thermal_nocrt,
1768 .ident = "Gigabyte GA-7ZX",
1769 .matches = {
1770 DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
1771 DMI_MATCH(DMI_BOARD_NAME, "7ZX"),
1772 },
1773 },
0b5bfa1c
LB		 1774 {}
1775};
0b5bfa1c 1776
4be44fcd 1777static int __init acpi_thermal_init(void)
1da177e4 1778{
4be44fcd 1779 int result = 0;
1da177e4 1780
0b5bfa1c
LB		 1781 dmi_check_system(thermal_dmi_table);
1782
72b33ef8
LB		 1783 if (off) {
1784 printk(KERN_NOTICE "ACPI: thermal control disabled\n");
1785 return -ENODEV;
1786 }
1da177e4
LT		 1787 acpi_thermal_dir = proc_mkdir(ACPI_THERMAL_CLASS, acpi_root_dir);
1788 if (!acpi_thermal_dir)
d550d98d 1789 return -ENODEV;
1da177e4
LT		 1790 acpi_thermal_dir->owner = THIS_MODULE;
1791
1792 result = acpi_bus_register_driver(&acpi_thermal_driver);
1793 if (result < 0) {
1794 remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
d550d98d 1795 return -ENODEV;
1da177e4
LT		 1796 }
1797
d550d98d 1798 return 0;
1da177e4
LT		 1799}
1800
4be44fcd 1801static void __exit acpi_thermal_exit(void)
1da177e4 1802{
1da177e4
LT		 1803
1804 acpi_bus_unregister_driver(&acpi_thermal_driver);
1805
1806 remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
1807
d550d98d 1808 return;
1da177e4
LT		 1809}
1810
1da177e4
LT		 1811module_init(acpi_thermal_init);
1812module_exit(acpi_thermal_exit);
Linux kernel - Deliverables
This page took 0.377734 seconds and 5 git commands to generate.