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