?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ia64/kvm: compilation fix. export account_system_vtime.
[pv_ops_mirror.git] / drivers / acpi / thermal.c
blob504385b1f2116614bd8e53e598b5c093414b2841
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_COMPONENT 0x04000000
51 #define ACPI_THERMAL_CLASS "thermal_zone"
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
64
65 #define ACPI_THERMAL_MAX_ACTIVE 10
66 #define ACPI_THERMAL_MAX_LIMIT_STR_LEN 65
67
68 #define _COMPONENT ACPI_THERMAL_COMPONENT
69 ACPI_MODULE_NAME("thermal");
70
71 MODULE_AUTHOR("Paul Diefenbaugh");
72 MODULE_DESCRIPTION("ACPI Thermal Zone Driver");
73 MODULE_LICENSE("GPL");
74
75 static int act;
76 module_param(act, int, 0644);
77 MODULE_PARM_DESC(act, "Disable or override all lowest active trip points.");
78
79 static int crt;
80 module_param(crt, int, 0644);
81 MODULE_PARM_DESC(crt, "Disable or lower all critical trip points.");
82
83 static int tzp;
84 module_param(tzp, int, 0444);
85 MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds.");
86
87 static int nocrt;
88 module_param(nocrt, int, 0);
89 MODULE_PARM_DESC(nocrt, "Set to take no action upon ACPI thermal zone critical trips points.");
90
91 static int off;
92 module_param(off, int, 0);
93 MODULE_PARM_DESC(off, "Set to disable ACPI thermal support.");
94
95 static int psv;
96 module_param(psv, int, 0644);
97 MODULE_PARM_DESC(psv, "Disable or override all passive trip points.");
98
99 static int acpi_thermal_add(struct acpi_device *device);
100 static int acpi_thermal_remove(struct acpi_device *device, int type);
101 static int acpi_thermal_resume(struct acpi_device *device);
102 static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file);
103 static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file);
104 static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file);
105 static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file);
106 static ssize_t acpi_thermal_write_cooling_mode(struct file *,
107 const char __user *, size_t,
108 loff_t *);
109 static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
110 static ssize_t acpi_thermal_write_polling(struct file *, const char __user *,
111 size_t, loff_t *);
112
113 static const struct acpi_device_id thermal_device_ids[] = {
114 {ACPI_THERMAL_HID, 0},
115 {"", 0},
116 };
117 MODULE_DEVICE_TABLE(acpi, thermal_device_ids);
118
119 static struct acpi_driver acpi_thermal_driver = {
120 .name = "thermal",
121 .class = ACPI_THERMAL_CLASS,
122 .ids = thermal_device_ids,
123 .ops = {
124 .add = acpi_thermal_add,
125 .remove = acpi_thermal_remove,
126 .resume = acpi_thermal_resume,
127 },
128 };
129
130 struct acpi_thermal_state {
131 u8 critical:1;
132 u8 hot:1;
133 u8 passive:1;
134 u8 active:1;
135 u8 reserved:4;
136 int active_index;
137 };
138
139 struct acpi_thermal_state_flags {
140 u8 valid:1;
141 u8 enabled:1;
142 u8 reserved:6;
143 };
144
145 struct acpi_thermal_critical {
146 struct acpi_thermal_state_flags flags;
147 unsigned long temperature;
148 };
149
150 struct acpi_thermal_hot {
151 struct acpi_thermal_state_flags flags;
152 unsigned long temperature;
153 };
154
155 struct acpi_thermal_passive {
156 struct acpi_thermal_state_flags flags;
157 unsigned long temperature;
158 unsigned long tc1;
159 unsigned long tc2;
160 unsigned long tsp;
161 struct acpi_handle_list devices;
162 };
163
164 struct acpi_thermal_active {
165 struct acpi_thermal_state_flags flags;
166 unsigned long temperature;
167 struct acpi_handle_list devices;
168 };
169
170 struct acpi_thermal_trips {
171 struct acpi_thermal_critical critical;
172 struct acpi_thermal_hot hot;
173 struct acpi_thermal_passive passive;
174 struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE];
175 };
176
177 struct acpi_thermal_flags {
178 u8 cooling_mode:1; /* _SCP */
179 u8 devices:1; /* _TZD */
180 u8 reserved:6;
181 };
182
183 struct acpi_thermal {
184 struct acpi_device * device;
185 acpi_bus_id name;
186 unsigned long temperature;
187 unsigned long last_temperature;
188 unsigned long polling_frequency;
189 volatile u8 zombie;
190 struct acpi_thermal_flags flags;
191 struct acpi_thermal_state state;
192 struct acpi_thermal_trips trips;
193 struct acpi_handle_list devices;
194 struct timer_list timer;
195 struct thermal_zone_device *thermal_zone;
196 int tz_enabled;
197 struct mutex lock;
198 };
199
200 static const struct file_operations acpi_thermal_state_fops = {
201 .owner = THIS_MODULE,
202 .open = acpi_thermal_state_open_fs,
203 .read = seq_read,
204 .llseek = seq_lseek,
205 .release = single_release,
206 };
207
208 static const struct file_operations acpi_thermal_temp_fops = {
209 .owner = THIS_MODULE,
210 .open = acpi_thermal_temp_open_fs,
211 .read = seq_read,
212 .llseek = seq_lseek,
213 .release = single_release,
214 };
215
216 static const struct file_operations acpi_thermal_trip_fops = {
217 .owner = THIS_MODULE,
218 .open = acpi_thermal_trip_open_fs,
219 .read = seq_read,
220 .llseek = seq_lseek,
221 .release = single_release,
222 };
223
224 static const struct file_operations acpi_thermal_cooling_fops = {
225 .owner = THIS_MODULE,
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,
231 };
232
233 static const struct file_operations acpi_thermal_polling_fops = {
234 .owner = THIS_MODULE,
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,
240 };
241
242 /* --------------------------------------------------------------------------
243 Thermal Zone Management
244 -------------------------------------------------------------------------- */
245
246 static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
247 {
248 acpi_status status = AE_OK;
249
250
251 if (!tz)
252 return -EINVAL;
253
254 tz->last_temperature = tz->temperature;
255
256 status =
257 acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tz->temperature);
258 if (ACPI_FAILURE(status))
259 return -ENODEV;
260
261 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n",
262 tz->temperature));
263
264 return 0;
265 }
266
267 static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
268 {
269 acpi_status status = AE_OK;
270
271
272 if (!tz)
273 return -EINVAL;
274
275 status =
276 acpi_evaluate_integer(tz->device->handle, "_TZP", NULL,
277 &tz->polling_frequency);
278 if (ACPI_FAILURE(status))
279 return -ENODEV;
280
281 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n",
282 tz->polling_frequency));
283
284 return 0;
285 }
286
287 static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
288 {
289
290 if (!tz)
291 return -EINVAL;
292
293 tz->polling_frequency = seconds * 10; /* Convert value to deci-seconds */
294
295 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
296 "Polling frequency set to %lu seconds\n",
297 tz->polling_frequency/10));
298
299 return 0;
300 }
301
302 static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
303 {
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;
308
309
310 if (!tz)
311 return -EINVAL;
312
313 status = acpi_get_handle(tz->device->handle, "_SCP", &handle);
314 if (ACPI_FAILURE(status)) {
315 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
316 return -ENODEV;
317 }
318
319 arg0.integer.value = mode;
320
321 status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
322 if (ACPI_FAILURE(status))
323 return -ENODEV;
324
325 return 0;
326 }
327
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
333
334 #define ACPI_TRIPS_REFRESH_THRESHOLDS (ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE)
335 #define ACPI_TRIPS_REFRESH_DEVICES ACPI_TRIPS_DEVICES
336
337 #define ACPI_TRIPS_INIT (ACPI_TRIPS_CRITICAL | ACPI_TRIPS_HOT | \
338 ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE | \
339 ACPI_TRIPS_DEVICES)
340
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) \
349 do { \
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
356 static 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;
362
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)) {
368 tz->trips.critical.flags.valid = 0;
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 }
389 }
390 }
391
392 /* Critical Sleep (optional) */
393 if (flag & ACPI_TRIPS_HOT) {
394 status = acpi_evaluate_integer(tz->device->handle,
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 }
406 }
407
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 }
420
421 if (ACPI_FAILURE(status))
422 tz->trips.passive.flags.valid = 0;
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);
448 if (ACPI_FAILURE(status))
449 tz->trips.passive.flags.valid = 0;
450 else
451 tz->trips.passive.flags.valid = 1;
452
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 }
464
465 /* Active (optional) */
466 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
467 char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
468 valid = tz->trips.active[i].flags.valid;
469
470 if (act == -1)
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));
495 break;
496 } else
497 tz->trips.active[i].flags.valid = 1;
498 }
499
500 name[2] = 'L';
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 }
535 }
536
537 return 0;
538 }
539
540 static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
541 {
542 return acpi_thermal_trips_update(tz, ACPI_TRIPS_INIT);
543 }
544
545 static int acpi_thermal_critical(struct acpi_thermal *tz)
546 {
547 if (!tz || !tz->trips.critical.flags.valid)
548 return -EINVAL;
549
550 if (tz->temperature >= tz->trips.critical.temperature) {
551 printk(KERN_WARNING PREFIX "Critical trip point\n");
552 tz->trips.critical.flags.enabled = 1;
553 } else if (tz->trips.critical.flags.enabled)
554 tz->trips.critical.flags.enabled = 0;
555
556 acpi_bus_generate_proc_event(tz->device, ACPI_THERMAL_NOTIFY_CRITICAL,
557 tz->trips.critical.flags.enabled);
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);
562
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 }
570
571 return 0;
572 }
573
574 static int acpi_thermal_hot(struct acpi_thermal *tz)
575 {
576 if (!tz || !tz->trips.hot.flags.valid)
577 return -EINVAL;
578
579 if (tz->temperature >= tz->trips.hot.temperature) {
580 printk(KERN_WARNING PREFIX "Hot trip point\n");
581 tz->trips.hot.flags.enabled = 1;
582 } else if (tz->trips.hot.flags.enabled)
583 tz->trips.hot.flags.enabled = 0;
584
585 acpi_bus_generate_proc_event(tz->device, ACPI_THERMAL_NOTIFY_HOT,
586 tz->trips.hot.flags.enabled);
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);
591
592 /* TBD: Call user-mode "sleep(S4)" function if nocrt is cleared */
593
594 return 0;
595 }
596
597 static void acpi_thermal_passive(struct acpi_thermal *tz)
598 {
599 int result = 1;
600 struct acpi_thermal_passive *passive = NULL;
601 int trend = 0;
602 int i = 0;
603
604
605 if (!tz || !tz->trips.passive.flags.valid)
606 return;
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) {
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));
626 passive->flags.enabled = 1;
627 /* Heating up? */
628 if (trend > 0)
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);
634 /* Cooling off? */
635 else if (trend < 0) {
636 for (i = 0; i < passive->devices.count; i++)
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;
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 */
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"));
681 }
682 }
683
684 static void acpi_thermal_active(struct acpi_thermal *tz)
685 {
686 int result = 0;
687 struct acpi_thermal_active *active = NULL;
688 int i = 0;
689 int j = 0;
690 unsigned long maxtemp = 0;
691
692
693 if (!tz)
694 return;
695
696 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
697 active = &(tz->trips.active[i]);
698 if (!active || !active->flags.valid)
699 break;
700 if (tz->temperature >= active->temperature) {
701 /*
702 * Above Threshold?
703 * ----------------
704 * If not already enabled, turn ON all cooling devices
705 * associated with this active threshold.
706 */
707 if (active->temperature > maxtemp)
708 tz->state.active_index = i;
709 maxtemp = active->temperature;
710 if (active->flags.enabled)
711 continue;
712 for (j = 0; j < active->devices.count; j++) {
713 result =
714 acpi_bus_set_power(active->devices.
715 handles[j],
716 ACPI_STATE_D0);
717 if (result) {
718 printk(KERN_WARNING PREFIX
719 "Unable to turn cooling device [%p] 'on'\n",
720 active->devices.
721 handles[j]);
722 continue;
723 }
724 active->flags.enabled = 1;
725 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
726 "Cooling device [%p] now 'on'\n",
727 active->devices.handles[j]));
728 }
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) {
743 printk(KERN_WARNING PREFIX
744 "Unable to turn cooling device [%p] 'off'\n",
745 active->devices.handles[j]);
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]));
752 }
753 }
754 }
755
756 static void acpi_thermal_check(void *context);
757
758 static void acpi_thermal_run(unsigned long data)
759 {
760 struct acpi_thermal *tz = (struct acpi_thermal *)data;
761 if (!tz->zombie)
762 acpi_os_execute(OSL_GPE_HANDLER, acpi_thermal_check, (void *)data);
763 }
764
765 static void acpi_thermal_check(void *data)
766 {
767 int result = 0;
768 struct acpi_thermal *tz = data;
769 unsigned long sleep_time = 0;
770 unsigned long timeout_jiffies = 0;
771 int i = 0;
772 struct acpi_thermal_state state;
773
774
775 if (!tz) {
776 printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
777 return;
778 }
779
780 /* Check if someone else is already running */
781 if (!mutex_trylock(&tz->lock))
782 return;
783
784 state = tz->state;
785
786 result = acpi_thermal_get_temperature(tz);
787 if (result)
788 goto unlock;
789
790 if (!tz->tz_enabled)
791 goto unlock;
792
793 memset(&tz->state, 0, sizeof(tz->state));
794
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)
804 state.critical |=
805 (tz->temperature >= tz->trips.critical.temperature);
806 if (tz->trips.hot.flags.valid)
807 state.hot |= (tz->temperature >= tz->trips.hot.temperature);
808 if (tz->trips.passive.flags.valid)
809 state.passive |=
810 (tz->temperature >= tz->trips.passive.temperature);
811 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
812 if (tz->trips.active[i].flags.valid)
813 state.active |=
814 (tz->temperature >=
815 tz->trips.active[i].temperature);
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 */
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;
842 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
843 tz->state.active |= tz->trips.active[i].flags.enabled;
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 */
854 if (tz->state.passive) {
855 sleep_time = tz->trips.passive.tsp * 100;
856 timeout_jiffies = jiffies + (HZ * sleep_time) / 1000;
857 } else if (tz->polling_frequency > 0) {
858 sleep_time = tz->polling_frequency * 100;
859 timeout_jiffies = round_jiffies(jiffies + (HZ * sleep_time) / 1000);
860 }
861
862 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: temperature[%lu] sleep[%lu]\n",
863 tz->name, tz->temperature, sleep_time));
864
865 /*
866 * Schedule Next Poll
867 * ------------------
868 */
869 if (!sleep_time) {
870 if (timer_pending(&(tz->timer)))
871 del_timer(&(tz->timer));
872 } else {
873 if (timer_pending(&(tz->timer)))
874 mod_timer(&(tz->timer), timeout_jiffies);
875 else {
876 tz->timer.data = (unsigned long)tz;
877 tz->timer.function = acpi_thermal_run;
878 tz->timer.expires = timeout_jiffies;
879 add_timer(&(tz->timer));
880 }
881 }
882 unlock:
883 mutex_unlock(&tz->lock);
884 }
885
886 /* sys I/F for generic thermal sysfs support */
887 #define KELVIN_TO_MILLICELSIUS(t) (t * 100 - 273200)
888
889 static int thermal_get_temp(struct thermal_zone_device *thermal, char *buf)
890 {
891 struct acpi_thermal *tz = thermal->devdata;
892 int result;
893
894 if (!tz)
895 return -EINVAL;
896
897 result = acpi_thermal_get_temperature(tz);
898 if (result)
899 return result;
900
901 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(tz->temperature));
902 }
903
904 static const char enabled[] = "kernel";
905 static const char disabled[] = "user";
906 static int thermal_get_mode(struct thermal_zone_device *thermal,
907 char *buf)
908 {
909 struct acpi_thermal *tz = thermal->devdata;
910
911 if (!tz)
912 return -EINVAL;
913
914 return sprintf(buf, "%s\n", tz->tz_enabled ?
915 enabled : disabled);
916 }
917
918 static int thermal_set_mode(struct thermal_zone_device *thermal,
919 const char *buf)
920 {
921 struct acpi_thermal *tz = thermal->devdata;
922 int enable;
923
924 if (!tz)
925 return -EINVAL;
926
927 /*
928 * enable/disable thermal management from ACPI thermal driver
929 */
930 if (!strncmp(buf, enabled, sizeof enabled - 1))
931 enable = 1;
932 else if (!strncmp(buf, disabled, sizeof disabled - 1))
933 enable = 0;
934 else
935 return -EINVAL;
936
937 if (enable != tz->tz_enabled) {
938 tz->tz_enabled = enable;
939 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
940 "%s ACPI thermal control\n",
941 tz->tz_enabled ? enabled : disabled));
942 acpi_thermal_check(tz);
943 }
944 return 0;
945 }
946
947 static int thermal_get_trip_type(struct thermal_zone_device *thermal,
948 int trip, char *buf)
949 {
950 struct acpi_thermal *tz = thermal->devdata;
951 int i;
952
953 if (!tz || trip < 0)
954 return -EINVAL;
955
956 if (tz->trips.critical.flags.valid) {
957 if (!trip)
958 return sprintf(buf, "critical\n");
959 trip--;
960 }
961
962 if (tz->trips.hot.flags.valid) {
963 if (!trip)
964 return sprintf(buf, "hot\n");
965 trip--;
966 }
967
968 if (tz->trips.passive.flags.valid) {
969 if (!trip)
970 return sprintf(buf, "passive\n");
971 trip--;
972 }
973
974 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
975 tz->trips.active[i].flags.valid; i++) {
976 if (!trip)
977 return sprintf(buf, "active%d\n", i);
978 trip--;
979 }
980
981 return -EINVAL;
982 }
983
984 static int thermal_get_trip_temp(struct thermal_zone_device *thermal,
985 int trip, char *buf)
986 {
987 struct acpi_thermal *tz = thermal->devdata;
988 int i;
989
990 if (!tz || trip < 0)
991 return -EINVAL;
992
993 if (tz->trips.critical.flags.valid) {
994 if (!trip)
995 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(
996 tz->trips.critical.temperature));
997 trip--;
998 }
999
1000 if (tz->trips.hot.flags.valid) {
1001 if (!trip)
1002 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(
1003 tz->trips.hot.temperature));
1004 trip--;
1005 }
1006
1007 if (tz->trips.passive.flags.valid) {
1008 if (!trip)
1009 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(
1010 tz->trips.passive.temperature));
1011 trip--;
1012 }
1013
1014 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
1015 tz->trips.active[i].flags.valid; i++) {
1016 if (!trip)
1017 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(
1018 tz->trips.active[i].temperature));
1019 trip--;
1020 }
1021
1022 return -EINVAL;
1023 }
1024
1025 static int thermal_get_crit_temp(struct thermal_zone_device *thermal,
1026 unsigned long *temperature) {
1027 struct acpi_thermal *tz = thermal->devdata;
1028
1029 if (tz->trips.critical.flags.valid) {
1030 *temperature = KELVIN_TO_MILLICELSIUS(
1031 tz->trips.critical.temperature);
1032 return 0;
1033 } else
1034 return -EINVAL;
1035 }
1036
1037 typedef int (*cb)(struct thermal_zone_device *, int,
1038 struct thermal_cooling_device *);
1039 static int acpi_thermal_cooling_device_cb(struct thermal_zone_device *thermal,
1040 struct thermal_cooling_device *cdev,
1041 cb action)
1042 {
1043 struct acpi_device *device = cdev->devdata;
1044 struct acpi_thermal *tz = thermal->devdata;
1045 struct acpi_device *dev;
1046 acpi_status status;
1047 acpi_handle handle;
1048 int i;
1049 int j;
1050 int trip = -1;
1051 int result = 0;
1052
1053 if (tz->trips.critical.flags.valid)
1054 trip++;
1055
1056 if (tz->trips.hot.flags.valid)
1057 trip++;
1058
1059 if (tz->trips.passive.flags.valid) {
1060 trip++;
1061 for (i = 0; i < tz->trips.passive.devices.count;
1062 i++) {
1063 handle = tz->trips.passive.devices.handles[i];
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 }
1070 }
1071 }
1072
1073 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1074 if (!tz->trips.active[i].flags.valid)
1075 break;
1076 trip++;
1077 for (j = 0;
1078 j < tz->trips.active[i].devices.count;
1079 j++) {
1080 handle = tz->trips.active[i].devices.handles[j];
1081 status = acpi_bus_get_device(handle, &dev);
1082 if (ACPI_SUCCESS(status) && (dev == device)) {
1083 result = action(thermal, trip, cdev);
1084 if (result)
1085 goto failed;
1086 }
1087 }
1088 }
1089
1090 for (i = 0; i < tz->devices.count; i++) {
1091 handle = tz->devices.handles[i];
1092 status = acpi_bus_get_device(handle, &dev);
1093 if (ACPI_SUCCESS(status) && (dev == device)) {
1094 result = action(thermal, -1, cdev);
1095 if (result)
1096 goto failed;
1097 }
1098 }
1099
1100 failed:
1101 return result;
1102 }
1103
1104 static int
1105 acpi_thermal_bind_cooling_device(struct thermal_zone_device *thermal,
1106 struct thermal_cooling_device *cdev)
1107 {
1108 return acpi_thermal_cooling_device_cb(thermal, cdev,
1109 thermal_zone_bind_cooling_device);
1110 }
1111
1112 static int
1113 acpi_thermal_unbind_cooling_device(struct thermal_zone_device *thermal,
1114 struct thermal_cooling_device *cdev)
1115 {
1116 return acpi_thermal_cooling_device_cb(thermal, cdev,
1117 thermal_zone_unbind_cooling_device);
1118 }
1119
1120 static struct thermal_zone_device_ops acpi_thermal_zone_ops = {
1121 .bind = acpi_thermal_bind_cooling_device,
1122 .unbind = acpi_thermal_unbind_cooling_device,
1123 .get_temp = thermal_get_temp,
1124 .get_mode = thermal_get_mode,
1125 .set_mode = thermal_set_mode,
1126 .get_trip_type = thermal_get_trip_type,
1127 .get_trip_temp = thermal_get_trip_temp,
1128 .get_crit_temp = thermal_get_crit_temp,
1129 };
1130
1131 static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz)
1132 {
1133 int trips = 0;
1134 int result;
1135 acpi_status status;
1136 int i;
1137
1138 if (tz->trips.critical.flags.valid)
1139 trips++;
1140
1141 if (tz->trips.hot.flags.valid)
1142 trips++;
1143
1144 if (tz->trips.passive.flags.valid)
1145 trips++;
1146
1147 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
1148 tz->trips.active[i].flags.valid; i++, trips++);
1149 tz->thermal_zone = thermal_zone_device_register("acpitz",
1150 trips, tz, &acpi_thermal_zone_ops);
1151 if (IS_ERR(tz->thermal_zone))
1152 return -ENODEV;
1153
1154 result = sysfs_create_link(&tz->device->dev.kobj,
1155 &tz->thermal_zone->device.kobj, "thermal_zone");
1156 if (result)
1157 return result;
1158
1159 result = sysfs_create_link(&tz->thermal_zone->device.kobj,
1160 &tz->device->dev.kobj, "device");
1161 if (result)
1162 return result;
1163
1164 status = acpi_attach_data(tz->device->handle,
1165 acpi_bus_private_data_handler,
1166 tz->thermal_zone);
1167 if (ACPI_FAILURE(status)) {
1168 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1169 "Error attaching device data\n"));
1170 return -ENODEV;
1171 }
1172
1173 tz->tz_enabled = 1;
1174
1175 printk(KERN_INFO PREFIX "%s is registered as thermal_zone%d\n",
1176 tz->device->dev.bus_id, tz->thermal_zone->id);
1177 return 0;
1178 }
1179
1180 static void acpi_thermal_unregister_thermal_zone(struct acpi_thermal *tz)
1181 {
1182 sysfs_remove_link(&tz->device->dev.kobj, "thermal_zone");
1183 sysfs_remove_link(&tz->thermal_zone->device.kobj, "device");
1184 thermal_zone_device_unregister(tz->thermal_zone);
1185 tz->thermal_zone = NULL;
1186 acpi_detach_data(tz->device->handle, acpi_bus_private_data_handler);
1187 }
1188
1189
1190 /* --------------------------------------------------------------------------
1191 FS Interface (/proc)
1192 -------------------------------------------------------------------------- */
1193
1194 static struct proc_dir_entry *acpi_thermal_dir;
1195
1196 static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
1197 {
1198 struct acpi_thermal *tz = seq->private;
1199
1200
1201 if (!tz)
1202 goto end;
1203
1204 seq_puts(seq, "state: ");
1205
1206 if (!tz->state.critical && !tz->state.hot && !tz->state.passive
1207 && !tz->state.active)
1208 seq_puts(seq, "ok\n");
1209 else {
1210 if (tz->state.critical)
1211 seq_puts(seq, "critical ");
1212 if (tz->state.hot)
1213 seq_puts(seq, "hot ");
1214 if (tz->state.passive)
1215 seq_puts(seq, "passive ");
1216 if (tz->state.active)
1217 seq_printf(seq, "active[%d]", tz->state.active_index);
1218 seq_puts(seq, "\n");
1219 }
1220
1221 end:
1222 return 0;
1223 }
1224
1225 static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file)
1226 {
1227 return single_open(file, acpi_thermal_state_seq_show, PDE(inode)->data);
1228 }
1229
1230 static int acpi_thermal_temp_seq_show(struct seq_file *seq, void *offset)
1231 {
1232 int result = 0;
1233 struct acpi_thermal *tz = seq->private;
1234
1235
1236 if (!tz)
1237 goto end;
1238
1239 result = acpi_thermal_get_temperature(tz);
1240 if (result)
1241 goto end;
1242
1243 seq_printf(seq, "temperature: %ld C\n",
1244 KELVIN_TO_CELSIUS(tz->temperature));
1245
1246 end:
1247 return 0;
1248 }
1249
1250 static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file)
1251 {
1252 return single_open(file, acpi_thermal_temp_seq_show, PDE(inode)->data);
1253 }
1254
1255 static int acpi_thermal_trip_seq_show(struct seq_file *seq, void *offset)
1256 {
1257 struct acpi_thermal *tz = seq->private;
1258 struct acpi_device *device;
1259 acpi_status status;
1260
1261 int i = 0;
1262 int j = 0;
1263
1264
1265 if (!tz)
1266 goto end;
1267
1268 if (tz->trips.critical.flags.valid)
1269 seq_printf(seq, "critical (S5): %ld C%s",
1270 KELVIN_TO_CELSIUS(tz->trips.critical.temperature),
1271 nocrt ? " <disabled>\n" : "\n");
1272
1273 if (tz->trips.hot.flags.valid)
1274 seq_printf(seq, "hot (S4): %ld C%s",
1275 KELVIN_TO_CELSIUS(tz->trips.hot.temperature),
1276 nocrt ? " <disabled>\n" : "\n");
1277
1278 if (tz->trips.passive.flags.valid) {
1279 seq_printf(seq,
1280 "passive: %ld C: tc1=%lu tc2=%lu tsp=%lu devices=",
1281 KELVIN_TO_CELSIUS(tz->trips.passive.temperature),
1282 tz->trips.passive.tc1, tz->trips.passive.tc2,
1283 tz->trips.passive.tsp);
1284 for (j = 0; j < tz->trips.passive.devices.count; j++) {
1285 status = acpi_bus_get_device(tz->trips.passive.devices.
1286 handles[j], &device);
1287 seq_printf(seq, "%4.4s ", status ? "" :
1288 acpi_device_bid(device));
1289 }
1290 seq_puts(seq, "\n");
1291 }
1292
1293 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1294 if (!(tz->trips.active[i].flags.valid))
1295 break;
1296 seq_printf(seq, "active[%d]: %ld C: devices=",
1297 i,
1298 KELVIN_TO_CELSIUS(tz->trips.active[i].temperature));
1299 for (j = 0; j < tz->trips.active[i].devices.count; j++){
1300 status = acpi_bus_get_device(tz->trips.active[i].
1301 devices.handles[j],
1302 &device);
1303 seq_printf(seq, "%4.4s ", status ? "" :
1304 acpi_device_bid(device));
1305 }
1306 seq_puts(seq, "\n");
1307 }
1308
1309 end:
1310 return 0;
1311 }
1312
1313 static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file)
1314 {
1315 return single_open(file, acpi_thermal_trip_seq_show, PDE(inode)->data);
1316 }
1317
1318 static int acpi_thermal_cooling_seq_show(struct seq_file *seq, void *offset)
1319 {
1320 struct acpi_thermal *tz = seq->private;
1321
1322
1323 if (!tz)
1324 goto end;
1325
1326 if (!tz->flags.cooling_mode)
1327 seq_puts(seq, "<setting not supported>\n");
1328 else
1329 seq_puts(seq, "0 - Active; 1 - Passive\n");
1330
1331 end:
1332 return 0;
1333 }
1334
1335 static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file)
1336 {
1337 return single_open(file, acpi_thermal_cooling_seq_show,
1338 PDE(inode)->data);
1339 }
1340
1341 static ssize_t
1342 acpi_thermal_write_cooling_mode(struct file *file,
1343 const char __user * buffer,
1344 size_t count, loff_t * ppos)
1345 {
1346 struct seq_file *m = file->private_data;
1347 struct acpi_thermal *tz = m->private;
1348 int result = 0;
1349 char mode_string[12] = { '\0' };
1350
1351
1352 if (!tz || (count > sizeof(mode_string) - 1))
1353 return -EINVAL;
1354
1355 if (!tz->flags.cooling_mode)
1356 return -ENODEV;
1357
1358 if (copy_from_user(mode_string, buffer, count))
1359 return -EFAULT;
1360
1361 mode_string[count] = '\0';
1362
1363 result = acpi_thermal_set_cooling_mode(tz,
1364 simple_strtoul(mode_string, NULL,
1365 0));
1366 if (result)
1367 return result;
1368
1369 acpi_thermal_check(tz);
1370
1371 return count;
1372 }
1373
1374 static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
1375 {
1376 struct acpi_thermal *tz = seq->private;
1377
1378
1379 if (!tz)
1380 goto end;
1381
1382 if (!tz->polling_frequency) {
1383 seq_puts(seq, "<polling disabled>\n");
1384 goto end;
1385 }
1386
1387 seq_printf(seq, "polling frequency: %lu seconds\n",
1388 (tz->polling_frequency / 10));
1389
1390 end:
1391 return 0;
1392 }
1393
1394 static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file)
1395 {
1396 return single_open(file, acpi_thermal_polling_seq_show,
1397 PDE(inode)->data);
1398 }
1399
1400 static ssize_t
1401 acpi_thermal_write_polling(struct file *file,
1402 const char __user * buffer,
1403 size_t count, loff_t * ppos)
1404 {
1405 struct seq_file *m = file->private_data;
1406 struct acpi_thermal *tz = m->private;
1407 int result = 0;
1408 char polling_string[12] = { '\0' };
1409 int seconds = 0;
1410
1411
1412 if (!tz || (count > sizeof(polling_string) - 1))
1413 return -EINVAL;
1414
1415 if (copy_from_user(polling_string, buffer, count))
1416 return -EFAULT;
1417
1418 polling_string[count] = '\0';
1419
1420 seconds = simple_strtoul(polling_string, NULL, 0);
1421
1422 result = acpi_thermal_set_polling(tz, seconds);
1423 if (result)
1424 return result;
1425
1426 acpi_thermal_check(tz);
1427
1428 return count;
1429 }
1430
1431 static int acpi_thermal_add_fs(struct acpi_device *device)
1432 {
1433 struct proc_dir_entry *entry = NULL;
1434
1435
1436 if (!acpi_device_dir(device)) {
1437 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1438 acpi_thermal_dir);
1439 if (!acpi_device_dir(device))
1440 return -ENODEV;
1441 acpi_device_dir(device)->owner = THIS_MODULE;
1442 }
1443
1444 /* 'state' [R] */
1445 entry = proc_create_data(ACPI_THERMAL_FILE_STATE,
1446 S_IRUGO, acpi_device_dir(device),
1447 &acpi_thermal_state_fops,
1448 acpi_driver_data(device));
1449 if (!entry)
1450 return -ENODEV;
1451
1452 /* 'temperature' [R] */
1453 entry = proc_create_data(ACPI_THERMAL_FILE_TEMPERATURE,
1454 S_IRUGO, acpi_device_dir(device),
1455 &acpi_thermal_temp_fops,
1456 acpi_driver_data(device));
1457 if (!entry)
1458 return -ENODEV;
1459
1460 /* 'trip_points' [R] */
1461 entry = proc_create_data(ACPI_THERMAL_FILE_TRIP_POINTS,
1462 S_IRUGO,
1463 acpi_device_dir(device),
1464 &acpi_thermal_trip_fops,
1465 acpi_driver_data(device));
1466 if (!entry)
1467 return -ENODEV;
1468
1469 /* 'cooling_mode' [R/W] */
1470 entry = proc_create_data(ACPI_THERMAL_FILE_COOLING_MODE,
1471 S_IFREG | S_IRUGO | S_IWUSR,
1472 acpi_device_dir(device),
1473 &acpi_thermal_cooling_fops,
1474 acpi_driver_data(device));
1475 if (!entry)
1476 return -ENODEV;
1477
1478 /* 'polling_frequency' [R/W] */
1479 entry = proc_create_data(ACPI_THERMAL_FILE_POLLING_FREQ,
1480 S_IFREG | S_IRUGO | S_IWUSR,
1481 acpi_device_dir(device),
1482 &acpi_thermal_polling_fops,
1483 acpi_driver_data(device));
1484 if (!entry)
1485 return -ENODEV;
1486 return 0;
1487 }
1488
1489 static int acpi_thermal_remove_fs(struct acpi_device *device)
1490 {
1491
1492 if (acpi_device_dir(device)) {
1493 remove_proc_entry(ACPI_THERMAL_FILE_POLLING_FREQ,
1494 acpi_device_dir(device));
1495 remove_proc_entry(ACPI_THERMAL_FILE_COOLING_MODE,
1496 acpi_device_dir(device));
1497 remove_proc_entry(ACPI_THERMAL_FILE_TRIP_POINTS,
1498 acpi_device_dir(device));
1499 remove_proc_entry(ACPI_THERMAL_FILE_TEMPERATURE,
1500 acpi_device_dir(device));
1501 remove_proc_entry(ACPI_THERMAL_FILE_STATE,
1502 acpi_device_dir(device));
1503 remove_proc_entry(acpi_device_bid(device), acpi_thermal_dir);
1504 acpi_device_dir(device) = NULL;
1505 }
1506
1507 return 0;
1508 }
1509
1510 /* --------------------------------------------------------------------------
1511 Driver Interface
1512 -------------------------------------------------------------------------- */
1513
1514 static void acpi_thermal_notify(acpi_handle handle, u32 event, void *data)
1515 {
1516 struct acpi_thermal *tz = data;
1517 struct acpi_device *device = NULL;
1518
1519
1520 if (!tz)
1521 return;
1522
1523 device = tz->device;
1524
1525 switch (event) {
1526 case ACPI_THERMAL_NOTIFY_TEMPERATURE:
1527 acpi_thermal_check(tz);
1528 break;
1529 case ACPI_THERMAL_NOTIFY_THRESHOLDS:
1530 acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_THRESHOLDS);
1531 acpi_thermal_check(tz);
1532 acpi_bus_generate_proc_event(device, event, 0);
1533 acpi_bus_generate_netlink_event(device->pnp.device_class,
1534 device->dev.bus_id, event, 0);
1535 break;
1536 case ACPI_THERMAL_NOTIFY_DEVICES:
1537 acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_DEVICES);
1538 acpi_thermal_check(tz);
1539 acpi_bus_generate_proc_event(device, event, 0);
1540 acpi_bus_generate_netlink_event(device->pnp.device_class,
1541 device->dev.bus_id, event, 0);
1542 break;
1543 default:
1544 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1545 "Unsupported event [0x%x]\n", event));
1546 break;
1547 }
1548
1549 return;
1550 }
1551
1552 static int acpi_thermal_get_info(struct acpi_thermal *tz)
1553 {
1554 int result = 0;
1555
1556
1557 if (!tz)
1558 return -EINVAL;
1559
1560 /* Get temperature [_TMP] (required) */
1561 result = acpi_thermal_get_temperature(tz);
1562 if (result)
1563 return result;
1564
1565 /* Get trip points [_CRT, _PSV, etc.] (required) */
1566 result = acpi_thermal_get_trip_points(tz);
1567 if (result)
1568 return result;
1569
1570 /* Set the cooling mode [_SCP] to active cooling (default) */
1571 result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
1572 if (!result)
1573 tz->flags.cooling_mode = 1;
1574
1575 /* Get default polling frequency [_TZP] (optional) */
1576 if (tzp)
1577 tz->polling_frequency = tzp;
1578 else
1579 acpi_thermal_get_polling_frequency(tz);
1580
1581 return 0;
1582 }
1583
1584 static int acpi_thermal_add(struct acpi_device *device)
1585 {
1586 int result = 0;
1587 acpi_status status = AE_OK;
1588 struct acpi_thermal *tz = NULL;
1589
1590
1591 if (!device)
1592 return -EINVAL;
1593
1594 tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
1595 if (!tz)
1596 return -ENOMEM;
1597
1598 tz->device = device;
1599 strcpy(tz->name, device->pnp.bus_id);
1600 strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
1601 strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
1602 acpi_driver_data(device) = tz;
1603 mutex_init(&tz->lock);
1604
1605
1606 result = acpi_thermal_get_info(tz);
1607 if (result)
1608 goto free_memory;
1609
1610 result = acpi_thermal_register_thermal_zone(tz);
1611 if (result)
1612 goto free_memory;
1613
1614 result = acpi_thermal_add_fs(device);
1615 if (result)
1616 goto unregister_thermal_zone;
1617
1618 init_timer(&tz->timer);
1619
1620 acpi_thermal_check(tz);
1621
1622 status = acpi_install_notify_handler(device->handle,
1623 ACPI_DEVICE_NOTIFY,
1624 acpi_thermal_notify, tz);
1625 if (ACPI_FAILURE(status)) {
1626 result = -ENODEV;
1627 goto remove_fs;
1628 }
1629
1630 printk(KERN_INFO PREFIX "%s [%s] (%ld C)\n",
1631 acpi_device_name(device), acpi_device_bid(device),
1632 KELVIN_TO_CELSIUS(tz->temperature));
1633 goto end;
1634
1635 remove_fs:
1636 acpi_thermal_remove_fs(device);
1637 unregister_thermal_zone:
1638 thermal_zone_device_unregister(tz->thermal_zone);
1639 free_memory:
1640 kfree(tz);
1641 end:
1642 return result;
1643 }
1644
1645 static int acpi_thermal_remove(struct acpi_device *device, int type)
1646 {
1647 acpi_status status = AE_OK;
1648 struct acpi_thermal *tz = NULL;
1649
1650
1651 if (!device || !acpi_driver_data(device))
1652 return -EINVAL;
1653
1654 tz = acpi_driver_data(device);
1655
1656 /* avoid timer adding new defer task */
1657 tz->zombie = 1;
1658 /* wait for running timer (on other CPUs) finish */
1659 del_timer_sync(&(tz->timer));
1660 /* synchronize deferred task */
1661 acpi_os_wait_events_complete(NULL);
1662 /* deferred task may reinsert timer */
1663 del_timer_sync(&(tz->timer));
1664
1665 status = acpi_remove_notify_handler(device->handle,
1666 ACPI_DEVICE_NOTIFY,
1667 acpi_thermal_notify);
1668
1669 /* Terminate policy */
1670 if (tz->trips.passive.flags.valid && tz->trips.passive.flags.enabled) {
1671 tz->trips.passive.flags.enabled = 0;
1672 acpi_thermal_passive(tz);
1673 }
1674 if (tz->trips.active[0].flags.valid
1675 && tz->trips.active[0].flags.enabled) {
1676 tz->trips.active[0].flags.enabled = 0;
1677 acpi_thermal_active(tz);
1678 }
1679
1680 acpi_thermal_remove_fs(device);
1681 acpi_thermal_unregister_thermal_zone(tz);
1682 mutex_destroy(&tz->lock);
1683 kfree(tz);
1684 return 0;
1685 }
1686
1687 static int acpi_thermal_resume(struct acpi_device *device)
1688 {
1689 struct acpi_thermal *tz = NULL;
1690 int i, j, power_state, result;
1691
1692
1693 if (!device || !acpi_driver_data(device))
1694 return -EINVAL;
1695
1696 tz = acpi_driver_data(device);
1697
1698 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1699 if (!(&tz->trips.active[i]))
1700 break;
1701 if (!tz->trips.active[i].flags.valid)
1702 break;
1703 tz->trips.active[i].flags.enabled = 1;
1704 for (j = 0; j < tz->trips.active[i].devices.count; j++) {
1705 result = acpi_bus_get_power(tz->trips.active[i].devices.
1706 handles[j], &power_state);
1707 if (result || (power_state != ACPI_STATE_D0)) {
1708 tz->trips.active[i].flags.enabled = 0;
1709 break;
1710 }
1711 }
1712 tz->state.active |= tz->trips.active[i].flags.enabled;
1713 }
1714
1715 acpi_thermal_check(tz);
1716
1717 return AE_OK;
1718 }
1719
1720 static int thermal_act(const struct dmi_system_id *d) {
1721
1722 if (act == 0) {
1723 printk(KERN_NOTICE "ACPI: %s detected: "
1724 "disabling all active thermal trip points\n", d->ident);
1725 act = -1;
1726 }
1727 return 0;
1728 }
1729 static int thermal_nocrt(const struct dmi_system_id *d) {
1730
1731 printk(KERN_NOTICE "ACPI: %s detected: "
1732 "disabling all critical thermal trip point actions.\n", d->ident);
1733 nocrt = 1;
1734 return 0;
1735 }
1736 static int thermal_tzp(const struct dmi_system_id *d) {
1737
1738 if (tzp == 0) {
1739 printk(KERN_NOTICE "ACPI: %s detected: "
1740 "enabling thermal zone polling\n", d->ident);
1741 tzp = 300; /* 300 dS = 30 Seconds */
1742 }
1743 return 0;
1744 }
1745 static int thermal_psv(const struct dmi_system_id *d) {
1746
1747 if (psv == 0) {
1748 printk(KERN_NOTICE "ACPI: %s detected: "
1749 "disabling all passive thermal trip points\n", d->ident);
1750 psv = -1;
1751 }
1752 return 0;
1753 }
1754
1755 static struct dmi_system_id thermal_dmi_table[] __initdata = {
1756 /*
1757 * Award BIOS on this AOpen makes thermal control almost worthless.
1758 * http://bugzilla.kernel.org/show_bug.cgi?id=8842
1759 */
1760 {
1761 .callback = thermal_act,
1762 .ident = "AOpen i915GMm-HFS",
1763 .matches = {
1764 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1765 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1766 },
1767 },
1768 {
1769 .callback = thermal_psv,
1770 .ident = "AOpen i915GMm-HFS",
1771 .matches = {
1772 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1773 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1774 },
1775 },
1776 {
1777 .callback = thermal_tzp,
1778 .ident = "AOpen i915GMm-HFS",
1779 .matches = {
1780 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1781 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1782 },
1783 },
1784 {
1785 .callback = thermal_nocrt,
1786 .ident = "Gigabyte GA-7ZX",
1787 .matches = {
1788 DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
1789 DMI_MATCH(DMI_BOARD_NAME, "7ZX"),
1790 },
1791 },
1792 {}
1793 };
1794
1795 static int __init acpi_thermal_init(void)
1796 {
1797 int result = 0;
1798
1799 dmi_check_system(thermal_dmi_table);
1800
1801 if (off) {
1802 printk(KERN_NOTICE "ACPI: thermal control disabled\n");
1803 return -ENODEV;
1804 }
1805 acpi_thermal_dir = proc_mkdir(ACPI_THERMAL_CLASS, acpi_root_dir);
1806 if (!acpi_thermal_dir)
1807 return -ENODEV;
1808 acpi_thermal_dir->owner = THIS_MODULE;
1809
1810 result = acpi_bus_register_driver(&acpi_thermal_driver);
1811 if (result < 0) {
1812 remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
1813 return -ENODEV;
1814 }
1815
1816 return 0;
1817 }
1818
1819 static void __exit acpi_thermal_exit(void)
1820 {
1821
1822 acpi_bus_unregister_driver(&acpi_thermal_driver);
1823
1824 remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
1825
1826 return;
1827 }
1828
1829 module_init(acpi_thermal_init);
1830 module_exit(acpi_thermal_exit);
Mirror for ia64_pv_ops.git