?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PRCM: 34XX: Fix wrong shift value used in dpll4_m4x2_ck enable bit
[linux-ginger.git] / drivers / acpi / thermal.c
blob84c795fb9b1ebef3a787907ba372cc368923a6c2
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 /*
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 to lower critical threshold
392 */
393 if (crt_k < tz->trips.critical.temperature)
394 tz->trips.critical.temperature = crt_k;
395 }
396 }
397 }
398
399 /* Critical Sleep (optional) */
400 if (flag & ACPI_TRIPS_HOT) {
401 status = acpi_evaluate_integer(tz->device->handle,
402 "_HOT", NULL, &tz->trips.hot.temperature);
403 if (ACPI_FAILURE(status)) {
404 tz->trips.hot.flags.valid = 0;
405 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
406 "No hot threshold\n"));
407 } else {
408 tz->trips.hot.flags.valid = 1;
409 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
410 "Found hot threshold [%lu]\n",
411 tz->trips.critical.temperature));
412 }
413 }
414
415 /* Passive (optional) */
416 if (flag & ACPI_TRIPS_PASSIVE) {
417 valid = tz->trips.passive.flags.valid;
418 if (psv == -1) {
419 status = AE_SUPPORT;
420 } else if (psv > 0) {
421 tz->trips.passive.temperature = CELSIUS_TO_KELVIN(psv);
422 status = AE_OK;
423 } else {
424 status = acpi_evaluate_integer(tz->device->handle,
425 "_PSV", NULL, &tz->trips.passive.temperature);
426 }
427
428 if (ACPI_FAILURE(status))
429 tz->trips.passive.flags.valid = 0;
430 else {
431 tz->trips.passive.flags.valid = 1;
432 if (flag == ACPI_TRIPS_INIT) {
433 status = acpi_evaluate_integer(
434 tz->device->handle, "_TC1",
435 NULL, &tz->trips.passive.tc1);
436 if (ACPI_FAILURE(status))
437 tz->trips.passive.flags.valid = 0;
438 status = acpi_evaluate_integer(
439 tz->device->handle, "_TC2",
440 NULL, &tz->trips.passive.tc2);
441 if (ACPI_FAILURE(status))
442 tz->trips.passive.flags.valid = 0;
443 status = acpi_evaluate_integer(
444 tz->device->handle, "_TSP",
445 NULL, &tz->trips.passive.tsp);
446 if (ACPI_FAILURE(status))
447 tz->trips.passive.flags.valid = 0;
448 }
449 }
450 }
451 if ((flag & ACPI_TRIPS_DEVICES) && tz->trips.passive.flags.valid) {
452 memset(&devices, 0, sizeof(struct acpi_handle_list));
453 status = acpi_evaluate_reference(tz->device->handle, "_PSL",
454 NULL, &devices);
455 if (ACPI_FAILURE(status))
456 tz->trips.passive.flags.valid = 0;
457 else
458 tz->trips.passive.flags.valid = 1;
459
460 if (memcmp(&tz->trips.passive.devices, &devices,
461 sizeof(struct acpi_handle_list))) {
462 memcpy(&tz->trips.passive.devices, &devices,
463 sizeof(struct acpi_handle_list));
464 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
465 }
466 }
467 if ((flag & ACPI_TRIPS_PASSIVE) || (flag & ACPI_TRIPS_DEVICES)) {
468 if (valid != tz->trips.passive.flags.valid)
469 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "state");
470 }
471
472 /* Active (optional) */
473 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
474 char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
475 valid = tz->trips.active[i].flags.valid;
476
477 if (act == -1)
478 break; /* disable all active trip points */
479
480 if (flag & ACPI_TRIPS_ACTIVE) {
481 status = acpi_evaluate_integer(tz->device->handle,
482 name, NULL, &tz->trips.active[i].temperature);
483 if (ACPI_FAILURE(status)) {
484 tz->trips.active[i].flags.valid = 0;
485 if (i == 0)
486 break;
487 if (act <= 0)
488 break;
489 if (i == 1)
490 tz->trips.active[0].temperature =
491 CELSIUS_TO_KELVIN(act);
492 else
493 /*
494 * Don't allow override higher than
495 * the next higher trip point
496 */
497 tz->trips.active[i - 1].temperature =
498 (tz->trips.active[i - 2].temperature <
499 CELSIUS_TO_KELVIN(act) ?
500 tz->trips.active[i - 2].temperature :
501 CELSIUS_TO_KELVIN(act));
502 break;
503 } else
504 tz->trips.active[i].flags.valid = 1;
505 }
506
507 name[2] = 'L';
508 if ((flag & ACPI_TRIPS_DEVICES) && tz->trips.active[i].flags.valid ) {
509 memset(&devices, 0, sizeof(struct acpi_handle_list));
510 status = acpi_evaluate_reference(tz->device->handle,
511 name, NULL, &devices);
512 if (ACPI_FAILURE(status))
513 tz->trips.active[i].flags.valid = 0;
514 else
515 tz->trips.active[i].flags.valid = 1;
516
517 if (memcmp(&tz->trips.active[i].devices, &devices,
518 sizeof(struct acpi_handle_list))) {
519 memcpy(&tz->trips.active[i].devices, &devices,
520 sizeof(struct acpi_handle_list));
521 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
522 }
523 }
524 if ((flag & ACPI_TRIPS_ACTIVE) || (flag & ACPI_TRIPS_DEVICES))
525 if (valid != tz->trips.active[i].flags.valid)
526 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "state");
527
528 if (!tz->trips.active[i].flags.valid)
529 break;
530 }
531
532 if (flag & ACPI_TRIPS_DEVICES) {
533 memset(&devices, 0, sizeof(struct acpi_handle_list));
534 status = acpi_evaluate_reference(tz->device->handle, "_TZD",
535 NULL, &devices);
536 if (memcmp(&tz->devices, &devices,
537 sizeof(struct acpi_handle_list))) {
538 memcpy(&tz->devices, &devices,
539 sizeof(struct acpi_handle_list));
540 ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
541 }
542 }
543
544 return 0;
545 }
546
547 static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
548 {
549 return acpi_thermal_trips_update(tz, ACPI_TRIPS_INIT);
550 }
551
552 static int acpi_thermal_critical(struct acpi_thermal *tz)
553 {
554 if (!tz || !tz->trips.critical.flags.valid)
555 return -EINVAL;
556
557 if (tz->temperature >= tz->trips.critical.temperature) {
558 printk(KERN_WARNING PREFIX "Critical trip point\n");
559 tz->trips.critical.flags.enabled = 1;
560 } else if (tz->trips.critical.flags.enabled)
561 tz->trips.critical.flags.enabled = 0;
562
563 acpi_bus_generate_proc_event(tz->device, ACPI_THERMAL_NOTIFY_CRITICAL,
564 tz->trips.critical.flags.enabled);
565 acpi_bus_generate_netlink_event(tz->device->pnp.device_class,
566 tz->device->dev.bus_id,
567 ACPI_THERMAL_NOTIFY_CRITICAL,
568 tz->trips.critical.flags.enabled);
569
570 /* take no action if nocrt is set */
571 if(!nocrt) {
572 printk(KERN_EMERG
573 "Critical temperature reached (%ld C), shutting down.\n",
574 KELVIN_TO_CELSIUS(tz->temperature));
575 orderly_poweroff(true);
576 }
577
578 return 0;
579 }
580
581 static int acpi_thermal_hot(struct acpi_thermal *tz)
582 {
583 if (!tz || !tz->trips.hot.flags.valid)
584 return -EINVAL;
585
586 if (tz->temperature >= tz->trips.hot.temperature) {
587 printk(KERN_WARNING PREFIX "Hot trip point\n");
588 tz->trips.hot.flags.enabled = 1;
589 } else if (tz->trips.hot.flags.enabled)
590 tz->trips.hot.flags.enabled = 0;
591
592 acpi_bus_generate_proc_event(tz->device, ACPI_THERMAL_NOTIFY_HOT,
593 tz->trips.hot.flags.enabled);
594 acpi_bus_generate_netlink_event(tz->device->pnp.device_class,
595 tz->device->dev.bus_id,
596 ACPI_THERMAL_NOTIFY_HOT,
597 tz->trips.hot.flags.enabled);
598
599 /* TBD: Call user-mode "sleep(S4)" function if nocrt is cleared */
600
601 return 0;
602 }
603
604 static void acpi_thermal_passive(struct acpi_thermal *tz)
605 {
606 int result = 1;
607 struct acpi_thermal_passive *passive = NULL;
608 int trend = 0;
609 int i = 0;
610
611
612 if (!tz || !tz->trips.passive.flags.valid)
613 return;
614
615 passive = &(tz->trips.passive);
616
617 /*
618 * Above Trip?
619 * -----------
620 * Calculate the thermal trend (using the passive cooling equation)
621 * and modify the performance limit for all passive cooling devices
622 * accordingly. Note that we assume symmetry.
623 */
624 if (tz->temperature >= passive->temperature) {
625 trend =
626 (passive->tc1 * (tz->temperature - tz->last_temperature)) +
627 (passive->tc2 * (tz->temperature - passive->temperature));
628 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
629 "trend[%d]=(tc1[%lu]*(tmp[%lu]-last[%lu]))+(tc2[%lu]*(tmp[%lu]-psv[%lu]))\n",
630 trend, passive->tc1, tz->temperature,
631 tz->last_temperature, passive->tc2,
632 tz->temperature, passive->temperature));
633 passive->flags.enabled = 1;
634 /* Heating up? */
635 if (trend > 0)
636 for (i = 0; i < passive->devices.count; i++)
637 acpi_processor_set_thermal_limit(passive->
638 devices.
639 handles[i],
640 ACPI_PROCESSOR_LIMIT_INCREMENT);
641 /* Cooling off? */
642 else if (trend < 0) {
643 for (i = 0; i < passive->devices.count; i++)
644 /*
645 * assume that we are on highest
646 * freq/lowest thrott and can leave
647 * passive mode, even in error case
648 */
649 if (!acpi_processor_set_thermal_limit
650 (passive->devices.handles[i],
651 ACPI_PROCESSOR_LIMIT_DECREMENT))
652 result = 0;
653 /*
654 * Leave cooling mode, even if the temp might
655 * higher than trip point This is because some
656 * machines might have long thermal polling
657 * frequencies (tsp) defined. We will fall back
658 * into passive mode in next cycle (probably quicker)
659 */
660 if (result) {
661 passive->flags.enabled = 0;
662 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
663 "Disabling passive cooling, still above threshold,"
664 " but we are cooling down\n"));
665 }
666 }
667 return;
668 }
669
670 /*
671 * Below Trip?
672 * -----------
673 * Implement passive cooling hysteresis to slowly increase performance
674 * and avoid thrashing around the passive trip point. Note that we
675 * assume symmetry.
676 */
677 if (!passive->flags.enabled)
678 return;
679 for (i = 0; i < passive->devices.count; i++)
680 if (!acpi_processor_set_thermal_limit
681 (passive->devices.handles[i],
682 ACPI_PROCESSOR_LIMIT_DECREMENT))
683 result = 0;
684 if (result) {
685 passive->flags.enabled = 0;
686 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
687 "Disabling passive cooling (zone is cool)\n"));
688 }
689 }
690
691 static void acpi_thermal_active(struct acpi_thermal *tz)
692 {
693 int result = 0;
694 struct acpi_thermal_active *active = NULL;
695 int i = 0;
696 int j = 0;
697 unsigned long maxtemp = 0;
698
699
700 if (!tz)
701 return;
702
703 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
704 active = &(tz->trips.active[i]);
705 if (!active || !active->flags.valid)
706 break;
707 if (tz->temperature >= active->temperature) {
708 /*
709 * Above Threshold?
710 * ----------------
711 * If not already enabled, turn ON all cooling devices
712 * associated with this active threshold.
713 */
714 if (active->temperature > maxtemp)
715 tz->state.active_index = i;
716 maxtemp = active->temperature;
717 if (active->flags.enabled)
718 continue;
719 for (j = 0; j < active->devices.count; j++) {
720 result =
721 acpi_bus_set_power(active->devices.
722 handles[j],
723 ACPI_STATE_D0);
724 if (result) {
725 printk(KERN_WARNING PREFIX
726 "Unable to turn cooling device [%p] 'on'\n",
727 active->devices.
728 handles[j]);
729 continue;
730 }
731 active->flags.enabled = 1;
732 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
733 "Cooling device [%p] now 'on'\n",
734 active->devices.handles[j]));
735 }
736 continue;
737 }
738 if (!active->flags.enabled)
739 continue;
740 /*
741 * Below Threshold?
742 * ----------------
743 * Turn OFF all cooling devices associated with this
744 * threshold.
745 */
746 for (j = 0; j < active->devices.count; j++) {
747 result = acpi_bus_set_power(active->devices.handles[j],
748 ACPI_STATE_D3);
749 if (result) {
750 printk(KERN_WARNING PREFIX
751 "Unable to turn cooling device [%p] 'off'\n",
752 active->devices.handles[j]);
753 continue;
754 }
755 active->flags.enabled = 0;
756 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
757 "Cooling device [%p] now 'off'\n",
758 active->devices.handles[j]));
759 }
760 }
761 }
762
763 static void acpi_thermal_check(void *context);
764
765 static void acpi_thermal_run(unsigned long data)
766 {
767 struct acpi_thermal *tz = (struct acpi_thermal *)data;
768 if (!tz->zombie)
769 acpi_os_execute(OSL_GPE_HANDLER, acpi_thermal_check, (void *)data);
770 }
771
772 static void acpi_thermal_check(void *data)
773 {
774 int result = 0;
775 struct acpi_thermal *tz = data;
776 unsigned long sleep_time = 0;
777 unsigned long timeout_jiffies = 0;
778 int i = 0;
779 struct acpi_thermal_state state;
780
781
782 if (!tz) {
783 printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
784 return;
785 }
786
787 /* Check if someone else is already running */
788 if (!mutex_trylock(&tz->lock))
789 return;
790
791 state = tz->state;
792
793 result = acpi_thermal_get_temperature(tz);
794 if (result)
795 goto unlock;
796
797 if (!tz->tz_enabled)
798 goto unlock;
799
800 memset(&tz->state, 0, sizeof(tz->state));
801
802 /*
803 * Check Trip Points
804 * -----------------
805 * Compare the current temperature to the trip point values to see
806 * if we've entered one of the thermal policy states. Note that
807 * this function determines when a state is entered, but the
808 * individual policy decides when it is exited (e.g. hysteresis).
809 */
810 if (tz->trips.critical.flags.valid)
811 state.critical |=
812 (tz->temperature >= tz->trips.critical.temperature);
813 if (tz->trips.hot.flags.valid)
814 state.hot |= (tz->temperature >= tz->trips.hot.temperature);
815 if (tz->trips.passive.flags.valid)
816 state.passive |=
817 (tz->temperature >= tz->trips.passive.temperature);
818 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
819 if (tz->trips.active[i].flags.valid)
820 state.active |=
821 (tz->temperature >=
822 tz->trips.active[i].temperature);
823
824 /*
825 * Invoke Policy
826 * -------------
827 * Separated from the above check to allow individual policy to
828 * determine when to exit a given state.
829 */
830 if (state.critical)
831 acpi_thermal_critical(tz);
832 if (state.hot)
833 acpi_thermal_hot(tz);
834 if (state.passive)
835 acpi_thermal_passive(tz);
836 if (state.active)
837 acpi_thermal_active(tz);
838
839 /*
840 * Calculate State
841 * ---------------
842 * Again, separated from the above two to allow independent policy
843 * decisions.
844 */
845 tz->state.critical = tz->trips.critical.flags.enabled;
846 tz->state.hot = tz->trips.hot.flags.enabled;
847 tz->state.passive = tz->trips.passive.flags.enabled;
848 tz->state.active = 0;
849 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
850 tz->state.active |= tz->trips.active[i].flags.enabled;
851
852 /*
853 * Calculate Sleep Time
854 * --------------------
855 * If we're in the passive state, use _TSP's value. Otherwise
856 * use the default polling frequency (e.g. _TZP). If no polling
857 * frequency is specified then we'll wait forever (at least until
858 * a thermal event occurs). Note that _TSP and _TZD values are
859 * given in 1/10th seconds (we must covert to milliseconds).
860 */
861 if (tz->state.passive) {
862 sleep_time = tz->trips.passive.tsp * 100;
863 timeout_jiffies = jiffies + (HZ * sleep_time) / 1000;
864 } else if (tz->polling_frequency > 0) {
865 sleep_time = tz->polling_frequency * 100;
866 timeout_jiffies = round_jiffies(jiffies + (HZ * sleep_time) / 1000);
867 }
868
869 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: temperature[%lu] sleep[%lu]\n",
870 tz->name, tz->temperature, sleep_time));
871
872 /*
873 * Schedule Next Poll
874 * ------------------
875 */
876 if (!sleep_time) {
877 if (timer_pending(&(tz->timer)))
878 del_timer(&(tz->timer));
879 } else {
880 if (timer_pending(&(tz->timer)))
881 mod_timer(&(tz->timer), timeout_jiffies);
882 else {
883 tz->timer.data = (unsigned long)tz;
884 tz->timer.function = acpi_thermal_run;
885 tz->timer.expires = timeout_jiffies;
886 add_timer(&(tz->timer));
887 }
888 }
889 unlock:
890 mutex_unlock(&tz->lock);
891 }
892
893 /* sys I/F for generic thermal sysfs support */
894 #define KELVIN_TO_MILLICELSIUS(t) (t * 100 - 273200)
895
896 static int thermal_get_temp(struct thermal_zone_device *thermal, char *buf)
897 {
898 struct acpi_thermal *tz = thermal->devdata;
899 int result;
900
901 if (!tz)
902 return -EINVAL;
903
904 result = acpi_thermal_get_temperature(tz);
905 if (result)
906 return result;
907
908 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(tz->temperature));
909 }
910
911 static const char enabled[] = "kernel";
912 static const char disabled[] = "user";
913 static int thermal_get_mode(struct thermal_zone_device *thermal,
914 char *buf)
915 {
916 struct acpi_thermal *tz = thermal->devdata;
917
918 if (!tz)
919 return -EINVAL;
920
921 return sprintf(buf, "%s\n", tz->tz_enabled ?
922 enabled : disabled);
923 }
924
925 static int thermal_set_mode(struct thermal_zone_device *thermal,
926 const char *buf)
927 {
928 struct acpi_thermal *tz = thermal->devdata;
929 int enable;
930
931 if (!tz)
932 return -EINVAL;
933
934 /*
935 * enable/disable thermal management from ACPI thermal driver
936 */
937 if (!strncmp(buf, enabled, sizeof enabled - 1))
938 enable = 1;
939 else if (!strncmp(buf, disabled, sizeof disabled - 1))
940 enable = 0;
941 else
942 return -EINVAL;
943
944 if (enable != tz->tz_enabled) {
945 tz->tz_enabled = enable;
946 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
947 "%s ACPI thermal control\n",
948 tz->tz_enabled ? enabled : disabled));
949 acpi_thermal_check(tz);
950 }
951 return 0;
952 }
953
954 static int thermal_get_trip_type(struct thermal_zone_device *thermal,
955 int trip, char *buf)
956 {
957 struct acpi_thermal *tz = thermal->devdata;
958 int i;
959
960 if (!tz || trip < 0)
961 return -EINVAL;
962
963 if (tz->trips.critical.flags.valid) {
964 if (!trip)
965 return sprintf(buf, "critical\n");
966 trip--;
967 }
968
969 if (tz->trips.hot.flags.valid) {
970 if (!trip)
971 return sprintf(buf, "hot\n");
972 trip--;
973 }
974
975 if (tz->trips.passive.flags.valid) {
976 if (!trip)
977 return sprintf(buf, "passive\n");
978 trip--;
979 }
980
981 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
982 tz->trips.active[i].flags.valid; i++) {
983 if (!trip)
984 return sprintf(buf, "active%d\n", i);
985 trip--;
986 }
987
988 return -EINVAL;
989 }
990
991 static int thermal_get_trip_temp(struct thermal_zone_device *thermal,
992 int trip, char *buf)
993 {
994 struct acpi_thermal *tz = thermal->devdata;
995 int i;
996
997 if (!tz || trip < 0)
998 return -EINVAL;
999
1000 if (tz->trips.critical.flags.valid) {
1001 if (!trip)
1002 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(
1003 tz->trips.critical.temperature));
1004 trip--;
1005 }
1006
1007 if (tz->trips.hot.flags.valid) {
1008 if (!trip)
1009 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(
1010 tz->trips.hot.temperature));
1011 trip--;
1012 }
1013
1014 if (tz->trips.passive.flags.valid) {
1015 if (!trip)
1016 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(
1017 tz->trips.passive.temperature));
1018 trip--;
1019 }
1020
1021 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
1022 tz->trips.active[i].flags.valid; i++) {
1023 if (!trip)
1024 return sprintf(buf, "%ld\n", KELVIN_TO_MILLICELSIUS(
1025 tz->trips.active[i].temperature));
1026 trip--;
1027 }
1028
1029 return -EINVAL;
1030 }
1031
1032 static int thermal_get_crit_temp(struct thermal_zone_device *thermal,
1033 unsigned long *temperature) {
1034 struct acpi_thermal *tz = thermal->devdata;
1035
1036 if (tz->trips.critical.flags.valid) {
1037 *temperature = KELVIN_TO_MILLICELSIUS(
1038 tz->trips.critical.temperature);
1039 return 0;
1040 } else
1041 return -EINVAL;
1042 }
1043
1044 typedef int (*cb)(struct thermal_zone_device *, int,
1045 struct thermal_cooling_device *);
1046 static int acpi_thermal_cooling_device_cb(struct thermal_zone_device *thermal,
1047 struct thermal_cooling_device *cdev,
1048 cb action)
1049 {
1050 struct acpi_device *device = cdev->devdata;
1051 struct acpi_thermal *tz = thermal->devdata;
1052 struct acpi_device *dev;
1053 acpi_status status;
1054 acpi_handle handle;
1055 int i;
1056 int j;
1057 int trip = -1;
1058 int result = 0;
1059
1060 if (tz->trips.critical.flags.valid)
1061 trip++;
1062
1063 if (tz->trips.hot.flags.valid)
1064 trip++;
1065
1066 if (tz->trips.passive.flags.valid) {
1067 trip++;
1068 for (i = 0; i < tz->trips.passive.devices.count;
1069 i++) {
1070 handle = tz->trips.passive.devices.handles[i];
1071 status = acpi_bus_get_device(handle, &dev);
1072 if (ACPI_SUCCESS(status) && (dev == device)) {
1073 result = action(thermal, trip, cdev);
1074 if (result)
1075 goto failed;
1076 }
1077 }
1078 }
1079
1080 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1081 if (!tz->trips.active[i].flags.valid)
1082 break;
1083 trip++;
1084 for (j = 0;
1085 j < tz->trips.active[i].devices.count;
1086 j++) {
1087 handle = tz->trips.active[i].devices.handles[j];
1088 status = acpi_bus_get_device(handle, &dev);
1089 if (ACPI_SUCCESS(status) && (dev == device)) {
1090 result = action(thermal, trip, cdev);
1091 if (result)
1092 goto failed;
1093 }
1094 }
1095 }
1096
1097 for (i = 0; i < tz->devices.count; i++) {
1098 handle = tz->devices.handles[i];
1099 status = acpi_bus_get_device(handle, &dev);
1100 if (ACPI_SUCCESS(status) && (dev == device)) {
1101 result = action(thermal, -1, cdev);
1102 if (result)
1103 goto failed;
1104 }
1105 }
1106
1107 failed:
1108 return result;
1109 }
1110
1111 static int
1112 acpi_thermal_bind_cooling_device(struct thermal_zone_device *thermal,
1113 struct thermal_cooling_device *cdev)
1114 {
1115 return acpi_thermal_cooling_device_cb(thermal, cdev,
1116 thermal_zone_bind_cooling_device);
1117 }
1118
1119 static int
1120 acpi_thermal_unbind_cooling_device(struct thermal_zone_device *thermal,
1121 struct thermal_cooling_device *cdev)
1122 {
1123 return acpi_thermal_cooling_device_cb(thermal, cdev,
1124 thermal_zone_unbind_cooling_device);
1125 }
1126
1127 static struct thermal_zone_device_ops acpi_thermal_zone_ops = {
1128 .bind = acpi_thermal_bind_cooling_device,
1129 .unbind = acpi_thermal_unbind_cooling_device,
1130 .get_temp = thermal_get_temp,
1131 .get_mode = thermal_get_mode,
1132 .set_mode = thermal_set_mode,
1133 .get_trip_type = thermal_get_trip_type,
1134 .get_trip_temp = thermal_get_trip_temp,
1135 .get_crit_temp = thermal_get_crit_temp,
1136 };
1137
1138 static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz)
1139 {
1140 int trips = 0;
1141 int result;
1142 acpi_status status;
1143 int i;
1144
1145 if (tz->trips.critical.flags.valid)
1146 trips++;
1147
1148 if (tz->trips.hot.flags.valid)
1149 trips++;
1150
1151 if (tz->trips.passive.flags.valid)
1152 trips++;
1153
1154 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
1155 tz->trips.active[i].flags.valid; i++, trips++);
1156 tz->thermal_zone = thermal_zone_device_register("acpitz",
1157 trips, tz, &acpi_thermal_zone_ops);
1158 if (IS_ERR(tz->thermal_zone))
1159 return -ENODEV;
1160
1161 result = sysfs_create_link(&tz->device->dev.kobj,
1162 &tz->thermal_zone->device.kobj, "thermal_zone");
1163 if (result)
1164 return result;
1165
1166 result = sysfs_create_link(&tz->thermal_zone->device.kobj,
1167 &tz->device->dev.kobj, "device");
1168 if (result)
1169 return result;
1170
1171 status = acpi_attach_data(tz->device->handle,
1172 acpi_bus_private_data_handler,
1173 tz->thermal_zone);
1174 if (ACPI_FAILURE(status)) {
1175 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1176 "Error attaching device data\n"));
1177 return -ENODEV;
1178 }
1179
1180 tz->tz_enabled = 1;
1181
1182 printk(KERN_INFO PREFIX "%s is registered as thermal_zone%d\n",
1183 tz->device->dev.bus_id, tz->thermal_zone->id);
1184 return 0;
1185 }
1186
1187 static void acpi_thermal_unregister_thermal_zone(struct acpi_thermal *tz)
1188 {
1189 sysfs_remove_link(&tz->device->dev.kobj, "thermal_zone");
1190 sysfs_remove_link(&tz->thermal_zone->device.kobj, "device");
1191 thermal_zone_device_unregister(tz->thermal_zone);
1192 tz->thermal_zone = NULL;
1193 acpi_detach_data(tz->device->handle, acpi_bus_private_data_handler);
1194 }
1195
1196
1197 /* --------------------------------------------------------------------------
1198 FS Interface (/proc)
1199 -------------------------------------------------------------------------- */
1200
1201 static struct proc_dir_entry *acpi_thermal_dir;
1202
1203 static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
1204 {
1205 struct acpi_thermal *tz = seq->private;
1206
1207
1208 if (!tz)
1209 goto end;
1210
1211 seq_puts(seq, "state: ");
1212
1213 if (!tz->state.critical && !tz->state.hot && !tz->state.passive
1214 && !tz->state.active)
1215 seq_puts(seq, "ok\n");
1216 else {
1217 if (tz->state.critical)
1218 seq_puts(seq, "critical ");
1219 if (tz->state.hot)
1220 seq_puts(seq, "hot ");
1221 if (tz->state.passive)
1222 seq_puts(seq, "passive ");
1223 if (tz->state.active)
1224 seq_printf(seq, "active[%d]", tz->state.active_index);
1225 seq_puts(seq, "\n");
1226 }
1227
1228 end:
1229 return 0;
1230 }
1231
1232 static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file)
1233 {
1234 return single_open(file, acpi_thermal_state_seq_show, PDE(inode)->data);
1235 }
1236
1237 static int acpi_thermal_temp_seq_show(struct seq_file *seq, void *offset)
1238 {
1239 int result = 0;
1240 struct acpi_thermal *tz = seq->private;
1241
1242
1243 if (!tz)
1244 goto end;
1245
1246 result = acpi_thermal_get_temperature(tz);
1247 if (result)
1248 goto end;
1249
1250 seq_printf(seq, "temperature: %ld C\n",
1251 KELVIN_TO_CELSIUS(tz->temperature));
1252
1253 end:
1254 return 0;
1255 }
1256
1257 static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file)
1258 {
1259 return single_open(file, acpi_thermal_temp_seq_show, PDE(inode)->data);
1260 }
1261
1262 static int acpi_thermal_trip_seq_show(struct seq_file *seq, void *offset)
1263 {
1264 struct acpi_thermal *tz = seq->private;
1265 struct acpi_device *device;
1266 acpi_status status;
1267
1268 int i = 0;
1269 int j = 0;
1270
1271
1272 if (!tz)
1273 goto end;
1274
1275 if (tz->trips.critical.flags.valid)
1276 seq_printf(seq, "critical (S5): %ld C%s",
1277 KELVIN_TO_CELSIUS(tz->trips.critical.temperature),
1278 nocrt ? " <disabled>\n" : "\n");
1279
1280 if (tz->trips.hot.flags.valid)
1281 seq_printf(seq, "hot (S4): %ld C%s",
1282 KELVIN_TO_CELSIUS(tz->trips.hot.temperature),
1283 nocrt ? " <disabled>\n" : "\n");
1284
1285 if (tz->trips.passive.flags.valid) {
1286 seq_printf(seq,
1287 "passive: %ld C: tc1=%lu tc2=%lu tsp=%lu devices=",
1288 KELVIN_TO_CELSIUS(tz->trips.passive.temperature),
1289 tz->trips.passive.tc1, tz->trips.passive.tc2,
1290 tz->trips.passive.tsp);
1291 for (j = 0; j < tz->trips.passive.devices.count; j++) {
1292 status = acpi_bus_get_device(tz->trips.passive.devices.
1293 handles[j], &device);
1294 seq_printf(seq, "%4.4s ", status ? "" :
1295 acpi_device_bid(device));
1296 }
1297 seq_puts(seq, "\n");
1298 }
1299
1300 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1301 if (!(tz->trips.active[i].flags.valid))
1302 break;
1303 seq_printf(seq, "active[%d]: %ld C: devices=",
1304 i,
1305 KELVIN_TO_CELSIUS(tz->trips.active[i].temperature));
1306 for (j = 0; j < tz->trips.active[i].devices.count; j++){
1307 status = acpi_bus_get_device(tz->trips.active[i].
1308 devices.handles[j],
1309 &device);
1310 seq_printf(seq, "%4.4s ", status ? "" :
1311 acpi_device_bid(device));
1312 }
1313 seq_puts(seq, "\n");
1314 }
1315
1316 end:
1317 return 0;
1318 }
1319
1320 static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file)
1321 {
1322 return single_open(file, acpi_thermal_trip_seq_show, PDE(inode)->data);
1323 }
1324
1325 static int acpi_thermal_cooling_seq_show(struct seq_file *seq, void *offset)
1326 {
1327 struct acpi_thermal *tz = seq->private;
1328
1329
1330 if (!tz)
1331 goto end;
1332
1333 if (!tz->flags.cooling_mode)
1334 seq_puts(seq, "<setting not supported>\n");
1335 else
1336 seq_puts(seq, "0 - Active; 1 - Passive\n");
1337
1338 end:
1339 return 0;
1340 }
1341
1342 static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file)
1343 {
1344 return single_open(file, acpi_thermal_cooling_seq_show,
1345 PDE(inode)->data);
1346 }
1347
1348 static ssize_t
1349 acpi_thermal_write_cooling_mode(struct file *file,
1350 const char __user * buffer,
1351 size_t count, loff_t * ppos)
1352 {
1353 struct seq_file *m = file->private_data;
1354 struct acpi_thermal *tz = m->private;
1355 int result = 0;
1356 char mode_string[12] = { '\0' };
1357
1358
1359 if (!tz || (count > sizeof(mode_string) - 1))
1360 return -EINVAL;
1361
1362 if (!tz->flags.cooling_mode)
1363 return -ENODEV;
1364
1365 if (copy_from_user(mode_string, buffer, count))
1366 return -EFAULT;
1367
1368 mode_string[count] = '\0';
1369
1370 result = acpi_thermal_set_cooling_mode(tz,
1371 simple_strtoul(mode_string, NULL,
1372 0));
1373 if (result)
1374 return result;
1375
1376 acpi_thermal_check(tz);
1377
1378 return count;
1379 }
1380
1381 static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
1382 {
1383 struct acpi_thermal *tz = seq->private;
1384
1385
1386 if (!tz)
1387 goto end;
1388
1389 if (!tz->polling_frequency) {
1390 seq_puts(seq, "<polling disabled>\n");
1391 goto end;
1392 }
1393
1394 seq_printf(seq, "polling frequency: %lu seconds\n",
1395 (tz->polling_frequency / 10));
1396
1397 end:
1398 return 0;
1399 }
1400
1401 static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file)
1402 {
1403 return single_open(file, acpi_thermal_polling_seq_show,
1404 PDE(inode)->data);
1405 }
1406
1407 static ssize_t
1408 acpi_thermal_write_polling(struct file *file,
1409 const char __user * buffer,
1410 size_t count, loff_t * ppos)
1411 {
1412 struct seq_file *m = file->private_data;
1413 struct acpi_thermal *tz = m->private;
1414 int result = 0;
1415 char polling_string[12] = { '\0' };
1416 int seconds = 0;
1417
1418
1419 if (!tz || (count > sizeof(polling_string) - 1))
1420 return -EINVAL;
1421
1422 if (copy_from_user(polling_string, buffer, count))
1423 return -EFAULT;
1424
1425 polling_string[count] = '\0';
1426
1427 seconds = simple_strtoul(polling_string, NULL, 0);
1428
1429 result = acpi_thermal_set_polling(tz, seconds);
1430 if (result)
1431 return result;
1432
1433 acpi_thermal_check(tz);
1434
1435 return count;
1436 }
1437
1438 static int acpi_thermal_add_fs(struct acpi_device *device)
1439 {
1440 struct proc_dir_entry *entry = NULL;
1441
1442
1443 if (!acpi_device_dir(device)) {
1444 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1445 acpi_thermal_dir);
1446 if (!acpi_device_dir(device))
1447 return -ENODEV;
1448 acpi_device_dir(device)->owner = THIS_MODULE;
1449 }
1450
1451 /* 'state' [R] */
1452 entry = proc_create_data(ACPI_THERMAL_FILE_STATE,
1453 S_IRUGO, acpi_device_dir(device),
1454 &acpi_thermal_state_fops,
1455 acpi_driver_data(device));
1456 if (!entry)
1457 return -ENODEV;
1458
1459 /* 'temperature' [R] */
1460 entry = proc_create_data(ACPI_THERMAL_FILE_TEMPERATURE,
1461 S_IRUGO, acpi_device_dir(device),
1462 &acpi_thermal_temp_fops,
1463 acpi_driver_data(device));
1464 if (!entry)
1465 return -ENODEV;
1466
1467 /* 'trip_points' [R] */
1468 entry = proc_create_data(ACPI_THERMAL_FILE_TRIP_POINTS,
1469 S_IRUGO,
1470 acpi_device_dir(device),
1471 &acpi_thermal_trip_fops,
1472 acpi_driver_data(device));
1473 if (!entry)
1474 return -ENODEV;
1475
1476 /* 'cooling_mode' [R/W] */
1477 entry = proc_create_data(ACPI_THERMAL_FILE_COOLING_MODE,
1478 S_IFREG | S_IRUGO | S_IWUSR,
1479 acpi_device_dir(device),
1480 &acpi_thermal_cooling_fops,
1481 acpi_driver_data(device));
1482 if (!entry)
1483 return -ENODEV;
1484
1485 /* 'polling_frequency' [R/W] */
1486 entry = proc_create_data(ACPI_THERMAL_FILE_POLLING_FREQ,
1487 S_IFREG | S_IRUGO | S_IWUSR,
1488 acpi_device_dir(device),
1489 &acpi_thermal_polling_fops,
1490 acpi_driver_data(device));
1491 if (!entry)
1492 return -ENODEV;
1493 return 0;
1494 }
1495
1496 static int acpi_thermal_remove_fs(struct acpi_device *device)
1497 {
1498
1499 if (acpi_device_dir(device)) {
1500 remove_proc_entry(ACPI_THERMAL_FILE_POLLING_FREQ,
1501 acpi_device_dir(device));
1502 remove_proc_entry(ACPI_THERMAL_FILE_COOLING_MODE,
1503 acpi_device_dir(device));
1504 remove_proc_entry(ACPI_THERMAL_FILE_TRIP_POINTS,
1505 acpi_device_dir(device));
1506 remove_proc_entry(ACPI_THERMAL_FILE_TEMPERATURE,
1507 acpi_device_dir(device));
1508 remove_proc_entry(ACPI_THERMAL_FILE_STATE,
1509 acpi_device_dir(device));
1510 remove_proc_entry(acpi_device_bid(device), acpi_thermal_dir);
1511 acpi_device_dir(device) = NULL;
1512 }
1513
1514 return 0;
1515 }
1516
1517 /* --------------------------------------------------------------------------
1518 Driver Interface
1519 -------------------------------------------------------------------------- */
1520
1521 static void acpi_thermal_notify(acpi_handle handle, u32 event, void *data)
1522 {
1523 struct acpi_thermal *tz = data;
1524 struct acpi_device *device = NULL;
1525
1526
1527 if (!tz)
1528 return;
1529
1530 device = tz->device;
1531
1532 switch (event) {
1533 case ACPI_THERMAL_NOTIFY_TEMPERATURE:
1534 acpi_thermal_check(tz);
1535 break;
1536 case ACPI_THERMAL_NOTIFY_THRESHOLDS:
1537 acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_THRESHOLDS);
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 case ACPI_THERMAL_NOTIFY_DEVICES:
1544 acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_DEVICES);
1545 acpi_thermal_check(tz);
1546 acpi_bus_generate_proc_event(device, event, 0);
1547 acpi_bus_generate_netlink_event(device->pnp.device_class,
1548 device->dev.bus_id, event, 0);
1549 break;
1550 default:
1551 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1552 "Unsupported event [0x%x]\n", event));
1553 break;
1554 }
1555
1556 return;
1557 }
1558
1559 static int acpi_thermal_get_info(struct acpi_thermal *tz)
1560 {
1561 int result = 0;
1562
1563
1564 if (!tz)
1565 return -EINVAL;
1566
1567 /* Get temperature [_TMP] (required) */
1568 result = acpi_thermal_get_temperature(tz);
1569 if (result)
1570 return result;
1571
1572 /* Get trip points [_CRT, _PSV, etc.] (required) */
1573 result = acpi_thermal_get_trip_points(tz);
1574 if (result)
1575 return result;
1576
1577 /* Set the cooling mode [_SCP] to active cooling (default) */
1578 result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
1579 if (!result)
1580 tz->flags.cooling_mode = 1;
1581
1582 /* Get default polling frequency [_TZP] (optional) */
1583 if (tzp)
1584 tz->polling_frequency = tzp;
1585 else
1586 acpi_thermal_get_polling_frequency(tz);
1587
1588 return 0;
1589 }
1590
1591 static int acpi_thermal_add(struct acpi_device *device)
1592 {
1593 int result = 0;
1594 acpi_status status = AE_OK;
1595 struct acpi_thermal *tz = NULL;
1596
1597
1598 if (!device)
1599 return -EINVAL;
1600
1601 tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
1602 if (!tz)
1603 return -ENOMEM;
1604
1605 tz->device = device;
1606 strcpy(tz->name, device->pnp.bus_id);
1607 strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
1608 strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
1609 acpi_driver_data(device) = tz;
1610 mutex_init(&tz->lock);
1611
1612
1613 result = acpi_thermal_get_info(tz);
1614 if (result)
1615 goto free_memory;
1616
1617 result = acpi_thermal_register_thermal_zone(tz);
1618 if (result)
1619 goto free_memory;
1620
1621 result = acpi_thermal_add_fs(device);
1622 if (result)
1623 goto unregister_thermal_zone;
1624
1625 init_timer(&tz->timer);
1626
1627 acpi_thermal_check(tz);
1628
1629 status = acpi_install_notify_handler(device->handle,
1630 ACPI_DEVICE_NOTIFY,
1631 acpi_thermal_notify, tz);
1632 if (ACPI_FAILURE(status)) {
1633 result = -ENODEV;
1634 goto remove_fs;
1635 }
1636
1637 printk(KERN_INFO PREFIX "%s [%s] (%ld C)\n",
1638 acpi_device_name(device), acpi_device_bid(device),
1639 KELVIN_TO_CELSIUS(tz->temperature));
1640 goto end;
1641
1642 remove_fs:
1643 acpi_thermal_remove_fs(device);
1644 unregister_thermal_zone:
1645 thermal_zone_device_unregister(tz->thermal_zone);
1646 free_memory:
1647 kfree(tz);
1648 end:
1649 return result;
1650 }
1651
1652 static int acpi_thermal_remove(struct acpi_device *device, int type)
1653 {
1654 acpi_status status = AE_OK;
1655 struct acpi_thermal *tz = NULL;
1656
1657
1658 if (!device || !acpi_driver_data(device))
1659 return -EINVAL;
1660
1661 tz = acpi_driver_data(device);
1662
1663 /* avoid timer adding new defer task */
1664 tz->zombie = 1;
1665 /* wait for running timer (on other CPUs) finish */
1666 del_timer_sync(&(tz->timer));
1667 /* synchronize deferred task */
1668 acpi_os_wait_events_complete(NULL);
1669 /* deferred task may reinsert timer */
1670 del_timer_sync(&(tz->timer));
1671
1672 status = acpi_remove_notify_handler(device->handle,
1673 ACPI_DEVICE_NOTIFY,
1674 acpi_thermal_notify);
1675
1676 /* Terminate policy */
1677 if (tz->trips.passive.flags.valid && tz->trips.passive.flags.enabled) {
1678 tz->trips.passive.flags.enabled = 0;
1679 acpi_thermal_passive(tz);
1680 }
1681 if (tz->trips.active[0].flags.valid
1682 && tz->trips.active[0].flags.enabled) {
1683 tz->trips.active[0].flags.enabled = 0;
1684 acpi_thermal_active(tz);
1685 }
1686
1687 acpi_thermal_remove_fs(device);
1688 acpi_thermal_unregister_thermal_zone(tz);
1689 mutex_destroy(&tz->lock);
1690 kfree(tz);
1691 return 0;
1692 }
1693
1694 static int acpi_thermal_resume(struct acpi_device *device)
1695 {
1696 struct acpi_thermal *tz = NULL;
1697 int i, j, power_state, result;
1698
1699
1700 if (!device || !acpi_driver_data(device))
1701 return -EINVAL;
1702
1703 tz = acpi_driver_data(device);
1704
1705 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1706 if (!(&tz->trips.active[i]))
1707 break;
1708 if (!tz->trips.active[i].flags.valid)
1709 break;
1710 tz->trips.active[i].flags.enabled = 1;
1711 for (j = 0; j < tz->trips.active[i].devices.count; j++) {
1712 result = acpi_bus_get_power(tz->trips.active[i].devices.
1713 handles[j], &power_state);
1714 if (result || (power_state != ACPI_STATE_D0)) {
1715 tz->trips.active[i].flags.enabled = 0;
1716 break;
1717 }
1718 }
1719 tz->state.active |= tz->trips.active[i].flags.enabled;
1720 }
1721
1722 acpi_thermal_check(tz);
1723
1724 return AE_OK;
1725 }
1726
1727 static int thermal_act(const struct dmi_system_id *d) {
1728
1729 if (act == 0) {
1730 printk(KERN_NOTICE "ACPI: %s detected: "
1731 "disabling all active thermal trip points\n", d->ident);
1732 act = -1;
1733 }
1734 return 0;
1735 }
1736 static int thermal_nocrt(const struct dmi_system_id *d) {
1737
1738 printk(KERN_NOTICE "ACPI: %s detected: "
1739 "disabling all critical thermal trip point actions.\n", d->ident);
1740 nocrt = 1;
1741 return 0;
1742 }
1743 static int thermal_tzp(const struct dmi_system_id *d) {
1744
1745 if (tzp == 0) {
1746 printk(KERN_NOTICE "ACPI: %s detected: "
1747 "enabling thermal zone polling\n", d->ident);
1748 tzp = 300; /* 300 dS = 30 Seconds */
1749 }
1750 return 0;
1751 }
1752 static int thermal_psv(const struct dmi_system_id *d) {
1753
1754 if (psv == 0) {
1755 printk(KERN_NOTICE "ACPI: %s detected: "
1756 "disabling all passive thermal trip points\n", d->ident);
1757 psv = -1;
1758 }
1759 return 0;
1760 }
1761
1762 static struct dmi_system_id thermal_dmi_table[] __initdata = {
1763 /*
1764 * Award BIOS on this AOpen makes thermal control almost worthless.
1765 * http://bugzilla.kernel.org/show_bug.cgi?id=8842
1766 */
1767 {
1768 .callback = thermal_act,
1769 .ident = "AOpen i915GMm-HFS",
1770 .matches = {
1771 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1772 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1773 },
1774 },
1775 {
1776 .callback = thermal_psv,
1777 .ident = "AOpen i915GMm-HFS",
1778 .matches = {
1779 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1780 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1781 },
1782 },
1783 {
1784 .callback = thermal_tzp,
1785 .ident = "AOpen i915GMm-HFS",
1786 .matches = {
1787 DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1788 DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1789 },
1790 },
1791 {
1792 .callback = thermal_nocrt,
1793 .ident = "Gigabyte GA-7ZX",
1794 .matches = {
1795 DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
1796 DMI_MATCH(DMI_BOARD_NAME, "7ZX"),
1797 },
1798 },
1799 {}
1800 };
1801
1802 static int __init acpi_thermal_init(void)
1803 {
1804 int result = 0;
1805
1806 dmi_check_system(thermal_dmi_table);
1807
1808 if (off) {
1809 printk(KERN_NOTICE "ACPI: thermal control disabled\n");
1810 return -ENODEV;
1811 }
1812 acpi_thermal_dir = proc_mkdir(ACPI_THERMAL_CLASS, acpi_root_dir);
1813 if (!acpi_thermal_dir)
1814 return -ENODEV;
1815 acpi_thermal_dir->owner = THIS_MODULE;
1816
1817 result = acpi_bus_register_driver(&acpi_thermal_driver);
1818 if (result < 0) {
1819 remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
1820 return -ENODEV;
1821 }
1822
1823 return 0;
1824 }
1825
1826 static void __exit acpi_thermal_exit(void)
1827 {
1828
1829 acpi_bus_unregister_driver(&acpi_thermal_driver);
1830
1831 remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
1832
1833 return;
1834 }
1835
1836 module_init(acpi_thermal_init);
1837 module_exit(acpi_thermal_exit);
Linux for Ginger Game Console