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/init.h>
37 #include <linux/types.h>
38 #include <linux/proc_fs.h>
39 #include <linux/sched.h>
40 #include <linux/kmod.h>
41 #include <linux/seq_file.h>
42 #include <asm/uaccess.h>
43
44 #include <acpi/acpi_bus.h>
45 #include <acpi/acpi_drivers.h>
46
47 #define ACPI_THERMAL_COMPONENT 0x04000000
48 #define ACPI_THERMAL_CLASS "thermal_zone"
49 #define ACPI_THERMAL_DRIVER_NAME "ACPI Thermal Zone Driver"
50 #define ACPI_THERMAL_DEVICE_NAME "Thermal Zone"
51 #define ACPI_THERMAL_FILE_STATE "state"
52 #define ACPI_THERMAL_FILE_TEMPERATURE "temperature"
53 #define ACPI_THERMAL_FILE_TRIP_POINTS "trip_points"
54 #define ACPI_THERMAL_FILE_COOLING_MODE "cooling_mode"
55 #define ACPI_THERMAL_FILE_POLLING_FREQ "polling_frequency"
56 #define ACPI_THERMAL_NOTIFY_TEMPERATURE 0x80
57 #define ACPI_THERMAL_NOTIFY_THRESHOLDS 0x81
58 #define ACPI_THERMAL_NOTIFY_DEVICES 0x82
59 #define ACPI_THERMAL_NOTIFY_CRITICAL 0xF0
60 #define ACPI_THERMAL_NOTIFY_HOT 0xF1
61 #define ACPI_THERMAL_MODE_ACTIVE 0x00
62 #define ACPI_THERMAL_MODE_PASSIVE 0x01
63 #define ACPI_THERMAL_MODE_CRITICAL 0xff
64 #define ACPI_THERMAL_PATH_POWEROFF "/sbin/poweroff"
65
66 #define ACPI_THERMAL_MAX_ACTIVE 10
67 #define ACPI_THERMAL_MAX_LIMIT_STR_LEN 65
68
69 #define KELVIN_TO_CELSIUS(t) (long)(((long)t-2732>=0) ? ((long)t-2732+5)/10 : ((long)t-2732-5)/10)
70 #define CELSIUS_TO_KELVIN(t) ((t+273)*10)
71
72 #define _COMPONENT ACPI_THERMAL_COMPONENT
73 ACPI_MODULE_NAME ("acpi_thermal")
74
75 MODULE_AUTHOR("Paul Diefenbaugh");
76 MODULE_DESCRIPTION(ACPI_THERMAL_DRIVER_NAME);
77 MODULE_LICENSE("GPL");
78
79 static int tzp;
80 module_param(tzp, int, 0);
81 MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds.\n");
82
83
84 static int acpi_thermal_add (struct acpi_device *device);
85 static int acpi_thermal_remove (struct acpi_device *device, int type);
86 static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file);
87 static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file);
88 static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file);
89 static ssize_t acpi_thermal_write_trip_points (struct file*,const char __user *,size_t,loff_t *);
90 static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file);
91 static ssize_t acpi_thermal_write_cooling_mode (struct file*,const char __user *,size_t,loff_t *);
92 static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
93 static ssize_t acpi_thermal_write_polling(struct file*,const char __user *,size_t,loff_t *);
94
95 static struct acpi_driver acpi_thermal_driver = {
96 .name = ACPI_THERMAL_DRIVER_NAME,
97 .class = ACPI_THERMAL_CLASS,
98 .ids = ACPI_THERMAL_HID,
99 .ops = {
100 .add = acpi_thermal_add,
101 .remove = acpi_thermal_remove,
102 },
103 };
104
105 struct acpi_thermal_state {
106 u8 critical:1;
107 u8 hot:1;
108 u8 passive:1;
109 u8 active:1;
110 u8 reserved:4;
111 int active_index;
112 };
113
114 struct acpi_thermal_state_flags {
115 u8 valid:1;
116 u8 enabled:1;
117 u8 reserved:6;
118 };
119
120 struct acpi_thermal_critical {
121 struct acpi_thermal_state_flags flags;
122 unsigned long temperature;
123 };
124
125 struct acpi_thermal_hot {
126 struct acpi_thermal_state_flags flags;
127 unsigned long temperature;
128 };
129
130 struct acpi_thermal_passive {
131 struct acpi_thermal_state_flags flags;
132 unsigned long temperature;
133 unsigned long tc1;
134 unsigned long tc2;
135 unsigned long tsp;
136 struct acpi_handle_list devices;
137 };
138
139 struct acpi_thermal_active {
140 struct acpi_thermal_state_flags flags;
141 unsigned long temperature;
142 struct acpi_handle_list devices;
143 };
144
145 struct acpi_thermal_trips {
146 struct acpi_thermal_critical critical;
147 struct acpi_thermal_hot hot;
148 struct acpi_thermal_passive passive;
149 struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE];
150 };
151
152 struct acpi_thermal_flags {
153 u8 cooling_mode:1; /* _SCP */
154 u8 devices:1; /* _TZD */
155 u8 reserved:6;
156 };
157
158 struct acpi_thermal {
159 acpi_handle handle;
160 acpi_bus_id name;
161 unsigned long temperature;
162 unsigned long last_temperature;
163 unsigned long polling_frequency;
164 u8 cooling_mode;
165 volatile u8 zombie;
166 struct acpi_thermal_flags flags;
167 struct acpi_thermal_state state;
168 struct acpi_thermal_trips trips;
169 struct acpi_handle_list devices;
170 struct timer_list timer;
171 };
172
173 static struct file_operations acpi_thermal_state_fops = {
174 .open = acpi_thermal_state_open_fs,
175 .read = seq_read,
176 .llseek = seq_lseek,
177 .release = single_release,
178 };
179
180 static struct file_operations acpi_thermal_temp_fops = {
181 .open = acpi_thermal_temp_open_fs,
182 .read = seq_read,
183 .llseek = seq_lseek,
184 .release = single_release,
185 };
186
187 static struct file_operations acpi_thermal_trip_fops = {
188 .open = acpi_thermal_trip_open_fs,
189 .read = seq_read,
190 .write = acpi_thermal_write_trip_points,
191 .llseek = seq_lseek,
192 .release = single_release,
193 };
194
195 static struct file_operations acpi_thermal_cooling_fops = {
196 .open = acpi_thermal_cooling_open_fs,
197 .read = seq_read,
198 .write = acpi_thermal_write_cooling_mode,
199 .llseek = seq_lseek,
200 .release = single_release,
201 };
202
203 static struct file_operations acpi_thermal_polling_fops = {
204 .open = acpi_thermal_polling_open_fs,
205 .read = seq_read,
206 .write = acpi_thermal_write_polling,
207 .llseek = seq_lseek,
208 .release = single_release,
209 };
210
211 /* --------------------------------------------------------------------------
212 Thermal Zone Management
213 -------------------------------------------------------------------------- */
214
215 static int
216 acpi_thermal_get_temperature (
217 struct acpi_thermal *tz)
218 {
219 acpi_status status = AE_OK;
220
221 ACPI_FUNCTION_TRACE("acpi_thermal_get_temperature");
222
223 if (!tz)
224 return_VALUE(-EINVAL);
225
226 tz->last_temperature = tz->temperature;
227
228 status = acpi_evaluate_integer(tz->handle, "_TMP", NULL, &tz->temperature);
229 if (ACPI_FAILURE(status))
230 return_VALUE(-ENODEV);
231
232 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n", tz->temperature));
233
234 return_VALUE(0);
235 }
236
237
238 static int
239 acpi_thermal_get_polling_frequency (
240 struct acpi_thermal *tz)
241 {
242 acpi_status status = AE_OK;
243
244 ACPI_FUNCTION_TRACE("acpi_thermal_get_polling_frequency");
245
246 if (!tz)
247 return_VALUE(-EINVAL);
248
249 status = acpi_evaluate_integer(tz->handle, "_TZP", NULL, &tz->polling_frequency);
250 if (ACPI_FAILURE(status))
251 return_VALUE(-ENODEV);
252
253 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n", tz->polling_frequency));
254
255 return_VALUE(0);
256 }
257
258
259 static int
260 acpi_thermal_set_polling (
261 struct acpi_thermal *tz,
262 int seconds)
263 {
264 ACPI_FUNCTION_TRACE("acpi_thermal_set_polling");
265
266 if (!tz)
267 return_VALUE(-EINVAL);
268
269 tz->polling_frequency = seconds * 10; /* Convert value to deci-seconds */
270
271 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency set to %lu seconds\n", tz->polling_frequency));
272
273 return_VALUE(0);
274 }
275
276
277 static int
278 acpi_thermal_set_cooling_mode (
279 struct acpi_thermal *tz,
280 int mode)
281 {
282 acpi_status status = AE_OK;
283 union acpi_object arg0 = {ACPI_TYPE_INTEGER};
284 struct acpi_object_list arg_list = {1, &arg0};
285 acpi_handle handle = NULL;
286
287 ACPI_FUNCTION_TRACE("acpi_thermal_set_cooling_mode");
288
289 if (!tz)
290 return_VALUE(-EINVAL);
291
292 status = acpi_get_handle(tz->handle, "_SCP", &handle);
293 if (ACPI_FAILURE(status)) {
294 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
295 return_VALUE(-ENODEV);
296 }
297
298 arg0.integer.value = mode;
299
300 status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
301 if (ACPI_FAILURE(status))
302 return_VALUE(-ENODEV);
303
304 tz->cooling_mode = mode;
305
306 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Cooling mode [%s]\n",
307 mode?"passive":"active"));
308
309 return_VALUE(0);
310 }
311
312
313 static int
314 acpi_thermal_get_trip_points (
315 struct acpi_thermal *tz)
316 {
317 acpi_status status = AE_OK;
318 int i = 0;
319
320 ACPI_FUNCTION_TRACE("acpi_thermal_get_trip_points");
321
322 if (!tz)
323 return_VALUE(-EINVAL);
324
325 /* Critical Shutdown (required) */
326
327 status = acpi_evaluate_integer(tz->handle, "_CRT", NULL,
328 &tz->trips.critical.temperature);
329 if (ACPI_FAILURE(status)) {
330 tz->trips.critical.flags.valid = 0;
331 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "No critical threshold\n"));
332 return_VALUE(-ENODEV);
333 }
334 else {
335 tz->trips.critical.flags.valid = 1;
336 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found critical threshold [%lu]\n", tz->trips.critical.temperature));
337 }
338
339 /* Critical Sleep (optional) */
340
341 status = acpi_evaluate_integer(tz->handle, "_HOT", NULL, &tz->trips.hot.temperature);
342 if (ACPI_FAILURE(status)) {
343 tz->trips.hot.flags.valid = 0;
344 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No hot threshold\n"));
345 }
346 else {
347 tz->trips.hot.flags.valid = 1;
348 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found hot threshold [%lu]\n", tz->trips.hot.temperature));
349 }
350
351 /* Passive: Processors (optional) */
352
353 status = acpi_evaluate_integer(tz->handle, "_PSV", NULL, &tz->trips.passive.temperature);
354 if (ACPI_FAILURE(status)) {
355 tz->trips.passive.flags.valid = 0;
356 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No passive threshold\n"));
357 }
358 else {
359 tz->trips.passive.flags.valid = 1;
360
361 status = acpi_evaluate_integer(tz->handle, "_TC1", NULL, &tz->trips.passive.tc1);
362 if (ACPI_FAILURE(status))
363 tz->trips.passive.flags.valid = 0;
364
365 status = acpi_evaluate_integer(tz->handle, "_TC2", NULL, &tz->trips.passive.tc2);
366 if (ACPI_FAILURE(status))
367 tz->trips.passive.flags.valid = 0;
368
369 status = acpi_evaluate_integer(tz->handle, "_TSP", NULL, &tz->trips.passive.tsp);
370 if (ACPI_FAILURE(status))
371 tz->trips.passive.flags.valid = 0;
372
373 status = acpi_evaluate_reference(tz->handle, "_PSL", NULL, &tz->trips.passive.devices);
374 if (ACPI_FAILURE(status))
375 tz->trips.passive.flags.valid = 0;
376
377 if (!tz->trips.passive.flags.valid)
378 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid passive threshold\n"));
379 else
380 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found passive threshold [%lu]\n", tz->trips.passive.temperature));
381 }
382
383 /* Active: Fans, etc. (optional) */
384
385 for (i=0; i<ACPI_THERMAL_MAX_ACTIVE; i++) {
386
387 char name[5] = {'_','A','C',(''+i),'\0'};
388
389 status = acpi_evaluate_integer(tz->handle, name, NULL, &tz->trips.active[i].temperature);
390 if (ACPI_FAILURE(status))
391 break;
392
393 name[2] = 'L';
394 status = acpi_evaluate_reference(tz->handle, name, NULL, &tz->trips.active[i].devices);
395 if (ACPI_SUCCESS(status)) {
396 tz->trips.active[i].flags.valid = 1;
397 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found active threshold [%d]:[%lu]\n", i, tz->trips.active[i].temperature));
398 }
399 else
400 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid active threshold [%d]\n", i));
401 }
402
403 return_VALUE(0);
404 }
405
406
407 static int
408 acpi_thermal_get_devices (
409 struct acpi_thermal *tz)
410 {
411 acpi_status status = AE_OK;
412
413 ACPI_FUNCTION_TRACE("acpi_thermal_get_devices");
414
415 if (!tz)
416 return_VALUE(-EINVAL);
417
418 status = acpi_evaluate_reference(tz->handle, "_TZD", NULL, &tz->devices);
419 if (ACPI_FAILURE(status))
420 return_VALUE(-ENODEV);
421
422 return_VALUE(0);
423 }
424
425
426 static int
427 acpi_thermal_call_usermode (
428 char *path)
429 {
430 char *argv[2] = {NULL, NULL};
431 char *envp[3] = {NULL, NULL, NULL};
432
433 ACPI_FUNCTION_TRACE("acpi_thermal_call_usermode");
434
435 if (!path)
436 return_VALUE(-EINVAL);
437
438 argv[0] = path;
439
440 /* minimal command environment */
441 envp[0] = "HOME=/";
442 envp[1] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
443
444 call_usermodehelper(argv[0], argv, envp, 0);
445
446 return_VALUE(0);
447 }
448
449
450 static int
451 acpi_thermal_critical (
452 struct acpi_thermal *tz)
453 {
454 int result = 0;
455 struct acpi_device *device = NULL;
456
457 ACPI_FUNCTION_TRACE("acpi_thermal_critical");
458
459 if (!tz || !tz->trips.critical.flags.valid)
460 return_VALUE(-EINVAL);
461
462 if (tz->temperature >= tz->trips.critical.temperature) {
463 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Critical trip point\n"));
464 tz->trips.critical.flags.enabled = 1;
465 }
466 else if (tz->trips.critical.flags.enabled)
467 tz->trips.critical.flags.enabled = 0;
468
469 result = acpi_bus_get_device(tz->handle, &device);
470 if (result)
471 return_VALUE(result);
472
473 printk(KERN_EMERG "Critical temperature reached (%ld C), shutting down.\n", KELVIN_TO_CELSIUS(tz->temperature));
474 acpi_bus_generate_event(device, ACPI_THERMAL_NOTIFY_CRITICAL, tz->trips.critical.flags.enabled);
475
476 acpi_thermal_call_usermode(ACPI_THERMAL_PATH_POWEROFF);
477
478 return_VALUE(0);
479 }
480
481
482 static int
483 acpi_thermal_hot (
484 struct acpi_thermal *tz)
485 {
486 int result = 0;
487 struct acpi_device *device = NULL;
488
489 ACPI_FUNCTION_TRACE("acpi_thermal_hot");
490
491 if (!tz || !tz->trips.hot.flags.valid)
492 return_VALUE(-EINVAL);
493
494 if (tz->temperature >= tz->trips.hot.temperature) {
495 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Hot trip point\n"));
496 tz->trips.hot.flags.enabled = 1;
497 }
498 else if (tz->trips.hot.flags.enabled)
499 tz->trips.hot.flags.enabled = 0;
500
501 result = acpi_bus_get_device(tz->handle, &device);
502 if (result)
503 return_VALUE(result);
504
505 acpi_bus_generate_event(device, ACPI_THERMAL_NOTIFY_HOT, tz->trips.hot.flags.enabled);
506
507 /* TBD: Call user-mode "sleep(S4)" function */
508
509 return_VALUE(0);
510 }
511
512
513 static int
514 acpi_thermal_passive (
515 struct acpi_thermal *tz)
516 {
517 int result = 0;
518 struct acpi_thermal_passive *passive = NULL;
519 int trend = 0;
520 int i = 0;
521
522 ACPI_FUNCTION_TRACE("acpi_thermal_passive");
523
524 if (!tz || !tz->trips.passive.flags.valid)
525 return_VALUE(-EINVAL);
526
527 passive = &(tz->trips.passive);
528
529 /*
530 * Above Trip?
531 * -----------
532 * Calculate the thermal trend (using the passive cooling equation)
533 * and modify the performance limit for all passive cooling devices
534 * accordingly. Note that we assume symmetry.
535 */
536 if (tz->temperature >= passive->temperature) {
537 trend = (passive->tc1 * (tz->temperature - tz->last_temperature)) + (passive->tc2 * (tz->temperature - passive->temperature));
538 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
539 "trend[%d]=(tc1[%lu]*(tmp[%lu]-last[%lu]))+(tc2[%lu]*(tmp[%lu]-psv[%lu]))\n",
540 trend, passive->tc1, tz->temperature,
541 tz->last_temperature, passive->tc2,
542 tz->temperature, passive->temperature));
543 tz->trips.passive.flags.enabled = 1;
544 /* Heating up? */
545 if (trend > 0)
546 for (i=0; i<passive->devices.count; i++)
547 acpi_processor_set_thermal_limit(
548 passive->devices.handles[i],
549 ACPI_PROCESSOR_LIMIT_INCREMENT);
550 /* Cooling off? */
551 else if (trend < 0)
552 for (i=0; i<passive->devices.count; i++)
553 acpi_processor_set_thermal_limit(
554 passive->devices.handles[i],
555 ACPI_PROCESSOR_LIMIT_DECREMENT);
556 }
557
558 /*
559 * Below Trip?
560 * -----------
561 * Implement passive cooling hysteresis to slowly increase performance
562 * and avoid thrashing around the passive trip point. Note that we
563 * assume symmetry.
564 */
565 else if (tz->trips.passive.flags.enabled) {
566 for (i=0; i<passive->devices.count; i++)
567 result = acpi_processor_set_thermal_limit(
568 passive->devices.handles[i],
569 ACPI_PROCESSOR_LIMIT_DECREMENT);
570 if (result == 1) {
571 tz->trips.passive.flags.enabled = 0;
572 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
573 "Disabling passive cooling (zone is cool)\n"));
574 }
575 }
576
577 return_VALUE(0);
578 }
579
580
581 static int
582 acpi_thermal_active (
583 struct acpi_thermal *tz)
584 {
585 int result = 0;
586 struct acpi_thermal_active *active = NULL;
587 int i = 0;
588 int j = 0;
589 unsigned long maxtemp = 0;
590
591 ACPI_FUNCTION_TRACE("acpi_thermal_active");
592
593 if (!tz)
594 return_VALUE(-EINVAL);
595
596 for (i=0; i<ACPI_THERMAL_MAX_ACTIVE; i++) {
597
598 active = &(tz->trips.active[i]);
599 if (!active || !active->flags.valid)
600 break;
601
602 /*
603 * Above Threshold?
604 * ----------------
605 * If not already enabled, turn ON all cooling devices
606 * associated with this active threshold.
607 */
608 if (tz->temperature >= active->temperature) {
609 if (active->temperature > maxtemp)
610 tz->state.active_index = i, maxtemp = active->temperature;
611 if (!active->flags.enabled) {
612 for (j = 0; j < active->devices.count; j++) {
613 result = acpi_bus_set_power(active->devices.handles[j], ACPI_STATE_D0);
614 if (result) {
615 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Unable to turn cooling device [%p] 'on'\n", active->devices.handles[j]));
616 continue;
617 }
618 active->flags.enabled = 1;
619 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Cooling device [%p] now 'on'\n", active->devices.handles[j]));
620 }
621 }
622 }
623 /*
624 * Below Threshold?
625 * ----------------
626 * Turn OFF all cooling devices associated with this
627 * threshold.
628 */
629 else if (active->flags.enabled) {
630 for (j = 0; j < active->devices.count; j++) {
631 result = acpi_bus_set_power(active->devices.handles[j], ACPI_STATE_D3);
632 if (result) {
633 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Unable to turn cooling device [%p] 'off'\n", active->devices.handles[j]));
634 continue;
635 }
636 active->flags.enabled = 0;
637 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Cooling device [%p] now 'off'\n", active->devices.handles[j]));
638 }
639 }
640 }
641
642 return_VALUE(0);
643 }
644
645
646 static void acpi_thermal_check (void *context);
647
648 static void
649 acpi_thermal_run (
650 unsigned long data)
651 {
652 struct acpi_thermal *tz = (struct acpi_thermal *)data;
653 if (!tz->zombie)
654 acpi_os_queue_for_execution(OSD_PRIORITY_GPE,
655 acpi_thermal_check, (void *) data);
656 }
657
658
659 static void
660 acpi_thermal_check (
661 void *data)
662 {
663 int result = 0;
664 struct acpi_thermal *tz = (struct acpi_thermal *) data;
665 unsigned long sleep_time = 0;
666 int i = 0;
667 struct acpi_thermal_state state;
668
669 ACPI_FUNCTION_TRACE("acpi_thermal_check");
670
671 if (!tz) {
672 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid (NULL) context.\n"));
673 return_VOID;
674 }
675
676 state = tz->state;
677
678 result = acpi_thermal_get_temperature(tz);
679 if (result)
680 return_VOID;
681
682 memset(&tz->state, 0, sizeof(tz->state));
683
684 /*
685 * Check Trip Points
686 * -----------------
687 * Compare the current temperature to the trip point values to see
688 * if we've entered one of the thermal policy states. Note that
689 * this function determines when a state is entered, but the
690 * individual policy decides when it is exited (e.g. hysteresis).
691 */
692 if (tz->trips.critical.flags.valid)
693 state.critical |= (tz->temperature >= tz->trips.critical.temperature);
694 if (tz->trips.hot.flags.valid)
695 state.hot |= (tz->temperature >= tz->trips.hot.temperature);
696 if (tz->trips.passive.flags.valid)
697 state.passive |= (tz->temperature >= tz->trips.passive.temperature);
698 for (i=0; i<ACPI_THERMAL_MAX_ACTIVE; i++)
699 if (tz->trips.active[i].flags.valid)
700 state.active |= (tz->temperature >= tz->trips.active[i].temperature);
701
702 /*
703 * Invoke Policy
704 * -------------
705 * Separated from the above check to allow individual policy to
706 * determine when to exit a given state.
707 */
708 if (state.critical)
709 acpi_thermal_critical(tz);
710 if (state.hot)
711 acpi_thermal_hot(tz);
712 if (state.passive)
713 acpi_thermal_passive(tz);
714 if (state.active)
715 acpi_thermal_active(tz);
716
717 /*
718 * Calculate State
719 * ---------------
720 * Again, separated from the above two to allow independent policy
721 * decisions.
722 */
723 if (tz->trips.critical.flags.enabled)
724 tz->state.critical = 1;
725 if (tz->trips.hot.flags.enabled)
726 tz->state.hot = 1;
727 if (tz->trips.passive.flags.enabled)
728 tz->state.passive = 1;
729 for (i=0; i<ACPI_THERMAL_MAX_ACTIVE; i++)
730 if (tz->trips.active[i].flags.enabled)
731 tz->state.active = 1;
732
733 /*
734 * Calculate Sleep Time
735 * --------------------
736 * If we're in the passive state, use _TSP's value. Otherwise
737 * use the default polling frequency (e.g. _TZP). If no polling
738 * frequency is specified then we'll wait forever (at least until
739 * a thermal event occurs). Note that _TSP and _TZD values are
740 * given in 1/10th seconds (we must covert to milliseconds).
741 */
742 if (tz->state.passive)
743 sleep_time = tz->trips.passive.tsp * 100;
744 else if (tz->polling_frequency > 0)
745 sleep_time = tz->polling_frequency * 100;
746
747 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: temperature[%lu] sleep[%lu]\n",
748 tz->name, tz->temperature, sleep_time));
749
750 /*
751 * Schedule Next Poll
752 * ------------------
753 */
754 if (!sleep_time) {
755 if (timer_pending(&(tz->timer)))
756 del_timer(&(tz->timer));
757 }
758 else {
759 if (timer_pending(&(tz->timer)))
760 mod_timer(&(tz->timer), (HZ * sleep_time) / 1000);
761 else {
762 tz->timer.data = (unsigned long) tz;
763 tz->timer.function = acpi_thermal_run;
764 tz->timer.expires = jiffies + (HZ * sleep_time) / 1000;
765 add_timer(&(tz->timer));
766 }
767 }
768
769 return_VOID;
770 }
771
772
773 /* --------------------------------------------------------------------------
774 FS Interface (/proc)
775 -------------------------------------------------------------------------- */
776
777 struct proc_dir_entry *acpi_thermal_dir;
778
779 static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
780 {
781 struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
782
783 ACPI_FUNCTION_TRACE("acpi_thermal_state_seq_show");
784
785 if (!tz)
786 goto end;
787
788 seq_puts(seq, "state: ");
789
790 if (!tz->state.critical && !tz->state.hot && !tz->state.passive && !tz->state.active)
791 seq_puts(seq, "ok\n");
792 else {
793 if (tz->state.critical)
794 seq_puts(seq, "critical ");
795 if (tz->state.hot)
796 seq_puts(seq, "hot ");
797 if (tz->state.passive)
798 seq_puts(seq, "passive ");
799 if (tz->state.active)
800 seq_printf(seq, "active[%d]", tz->state.active_index);
801 seq_puts(seq, "\n");
802 }
803
804 end:
805 return_VALUE(0);
806 }
807
808 static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file)
809 {
810 return single_open(file, acpi_thermal_state_seq_show, PDE(inode)->data);
811 }
812
813
814 static int acpi_thermal_temp_seq_show(struct seq_file *seq, void *offset)
815 {
816 int result = 0;
817 struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
818
819 ACPI_FUNCTION_TRACE("acpi_thermal_temp_seq_show");
820
821 if (!tz)
822 goto end;
823
824 result = acpi_thermal_get_temperature(tz);
825 if (result)
826 goto end;
827
828 seq_printf(seq, "temperature: %ld C\n",
829 KELVIN_TO_CELSIUS(tz->temperature));
830
831 end:
832 return_VALUE(0);
833 }
834
835 static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file)
836 {
837 return single_open(file, acpi_thermal_temp_seq_show, PDE(inode)->data);
838 }
839
840
841 static int acpi_thermal_trip_seq_show(struct seq_file *seq, void *offset)
842 {
843 struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
844 int i = 0;
845 int j = 0;
846
847 ACPI_FUNCTION_TRACE("acpi_thermal_trip_seq_show");
848
849 if (!tz)
850 goto end;
851
852 if (tz->trips.critical.flags.valid)
853 seq_printf(seq, "critical (S5): %ld C\n",
854 KELVIN_TO_CELSIUS(tz->trips.critical.temperature));
855
856 if (tz->trips.hot.flags.valid)
857 seq_printf(seq, "hot (S4): %ld C\n",
858 KELVIN_TO_CELSIUS(tz->trips.hot.temperature));
859
860 if (tz->trips.passive.flags.valid) {
861 seq_printf(seq, "passive: %ld C: tc1=%lu tc2=%lu tsp=%lu devices=",
862 KELVIN_TO_CELSIUS(tz->trips.passive.temperature),
863 tz->trips.passive.tc1,
864 tz->trips.passive.tc2,
865 tz->trips.passive.tsp);
866 for (j=0; j<tz->trips.passive.devices.count; j++) {
867
868 seq_printf(seq, "0x%p ", tz->trips.passive.devices.handles[j]);
869 }
870 seq_puts(seq, "\n");
871 }
872
873 for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
874 if (!(tz->trips.active[i].flags.valid))
875 break;
876 seq_printf(seq, "active[%d]: %ld C: devices=",
877 i, KELVIN_TO_CELSIUS(tz->trips.active[i].temperature));
878 for (j = 0; j < tz->trips.active[i].devices.count; j++)
879 seq_printf(seq, "0x%p ",
880 tz->trips.active[i].devices.handles[j]);
881 seq_puts(seq, "\n");
882 }
883
884 end:
885 return_VALUE(0);
886 }
887
888 static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file)
889 {
890 return single_open(file, acpi_thermal_trip_seq_show, PDE(inode)->data);
891 }
892
893 static ssize_t
894 acpi_thermal_write_trip_points (
895 struct file *file,
896 const char __user *buffer,
897 size_t count,
898 loff_t *ppos)
899 {
900 struct seq_file *m = (struct seq_file *)file->private_data;
901 struct acpi_thermal *tz = (struct acpi_thermal *)m->private;
902
903 char *limit_string;
904 int num, critical, hot, passive;
905 int *active;
906 int i = 0;
907
908 ACPI_FUNCTION_TRACE("acpi_thermal_write_trip_points");
909
910 limit_string = kmalloc(ACPI_THERMAL_MAX_LIMIT_STR_LEN, GFP_KERNEL);
911 if(!limit_string)
912 return_VALUE(-ENOMEM);
913
914 memset(limit_string, 0, ACPI_THERMAL_MAX_LIMIT_STR_LEN);
915
916 active = kmalloc(ACPI_THERMAL_MAX_ACTIVE *sizeof(int), GFP_KERNEL);
917 if(!active)
918 return_VALUE(-ENOMEM);
919
920 if (!tz || (count > ACPI_THERMAL_MAX_LIMIT_STR_LEN - 1)) {
921 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument\n"));
922 count = -EINVAL;
923 goto end;
924 }
925
926 if (copy_from_user(limit_string, buffer, count)) {
927 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data\n"));
928 count = -EFAULT;
929 goto end;
930 }
931
932 limit_string[count] = '\0';
933
934 num = sscanf(limit_string, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d",
935 &critical, &hot, &passive,
936 &active[0], &active[1], &active[2], &active[3], &active[4],
937 &active[5], &active[6], &active[7], &active[8], &active[9]);
938 if(!(num >=5 && num < (ACPI_THERMAL_MAX_ACTIVE + 3))) {
939 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data format\n"));
940 count = -EINVAL;
941 goto end;
942 }
943
944 tz->trips.critical.temperature = CELSIUS_TO_KELVIN(critical);
945 tz->trips.hot.temperature = CELSIUS_TO_KELVIN(hot);
946 tz->trips.passive.temperature = CELSIUS_TO_KELVIN(passive);
947 for (i = 0; i < num - 3; i++) {
948 if (!(tz->trips.active[i].flags.valid))
949 break;
950 tz->trips.active[i].temperature = CELSIUS_TO_KELVIN(active[i]);
951 }
952
953 end:
954 kfree(active);
955 kfree(limit_string);
956 return_VALUE(count);
957 }
958
959
960 static int acpi_thermal_cooling_seq_show(struct seq_file *seq, void *offset)
961 {
962 struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
963
964 ACPI_FUNCTION_TRACE("acpi_thermal_cooling_seq_show");
965
966 if (!tz)
967 goto end;
968
969 if (!tz->flags.cooling_mode) {
970 seq_puts(seq, "<setting not supported>\n");
971 }
972
973 if ( tz->cooling_mode == ACPI_THERMAL_MODE_CRITICAL )
974 seq_printf(seq, "cooling mode: critical\n");
975 else
976 seq_printf(seq, "cooling mode: %s\n",
977 tz->cooling_mode?"passive":"active");
978
979 end:
980 return_VALUE(0);
981 }
982
983 static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file)
984 {
985 return single_open(file, acpi_thermal_cooling_seq_show,
986 PDE(inode)->data);
987 }
988
989 static ssize_t
990 acpi_thermal_write_cooling_mode (
991 struct file *file,
992 const char __user *buffer,
993 size_t count,
994 loff_t *ppos)
995 {
996 struct seq_file *m = (struct seq_file *)file->private_data;
997 struct acpi_thermal *tz = (struct acpi_thermal *)m->private;
998 int result = 0;
999 char mode_string[12] = {'\0'};
1000
1001 ACPI_FUNCTION_TRACE("acpi_thermal_write_cooling_mode");
1002
1003 if (!tz || (count > sizeof(mode_string) - 1))
1004 return_VALUE(-EINVAL);
1005
1006 if (!tz->flags.cooling_mode)
1007 return_VALUE(-ENODEV);
1008
1009 if (copy_from_user(mode_string, buffer, count))
1010 return_VALUE(-EFAULT);
1011
1012 mode_string[count] = '\0';
1013
1014 result = acpi_thermal_set_cooling_mode(tz,
1015 simple_strtoul(mode_string, NULL, 0));
1016 if (result)
1017 return_VALUE(result);
1018
1019 acpi_thermal_check(tz);
1020
1021 return_VALUE(count);
1022 }
1023
1024
1025 static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
1026 {
1027 struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
1028
1029 ACPI_FUNCTION_TRACE("acpi_thermal_polling_seq_show");
1030
1031 if (!tz)
1032 goto end;
1033
1034 if (!tz->polling_frequency) {
1035 seq_puts(seq, "<polling disabled>\n");
1036 goto end;
1037 }
1038
1039 seq_printf(seq, "polling frequency: %lu seconds\n",
1040 (tz->polling_frequency / 10));
1041
1042 end:
1043 return_VALUE(0);
1044 }
1045
1046 static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file)
1047 {
1048 return single_open(file, acpi_thermal_polling_seq_show,
1049 PDE(inode)->data);
1050 }
1051
1052 static ssize_t
1053 acpi_thermal_write_polling (
1054 struct file *file,
1055 const char __user *buffer,
1056 size_t count,
1057 loff_t *ppos)
1058 {
1059 struct seq_file *m = (struct seq_file *)file->private_data;
1060 struct acpi_thermal *tz = (struct acpi_thermal *)m->private;
1061 int result = 0;
1062 char polling_string[12] = {'\0'};
1063 int seconds = 0;
1064
1065 ACPI_FUNCTION_TRACE("acpi_thermal_write_polling");
1066
1067 if (!tz || (count > sizeof(polling_string) - 1))
1068 return_VALUE(-EINVAL);
1069
1070 if (copy_from_user(polling_string, buffer, count))
1071 return_VALUE(-EFAULT);
1072
1073 polling_string[count] = '\0';
1074
1075 seconds = simple_strtoul(polling_string, NULL, 0);
1076
1077 result = acpi_thermal_set_polling(tz, seconds);
1078 if (result)
1079 return_VALUE(result);
1080
1081 acpi_thermal_check(tz);
1082
1083 return_VALUE(count);
1084 }
1085
1086
1087 static int
1088 acpi_thermal_add_fs (
1089 struct acpi_device *device)
1090 {
1091 struct proc_dir_entry *entry = NULL;
1092
1093 ACPI_FUNCTION_TRACE("acpi_thermal_add_fs");
1094
1095 if (!acpi_device_dir(device)) {
1096 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1097 acpi_thermal_dir);
1098 if (!acpi_device_dir(device))
1099 return_VALUE(-ENODEV);
1100 acpi_device_dir(device)->owner = THIS_MODULE;
1101 }
1102
1103 /* 'state' [R] */
1104 entry = create_proc_entry(ACPI_THERMAL_FILE_STATE,
1105 S_IRUGO, acpi_device_dir(device));
1106 if (!entry)
1107 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1108 "Unable to create '%s' fs entry\n",
1109 ACPI_THERMAL_FILE_STATE));
1110 else {
1111 entry->proc_fops = &acpi_thermal_state_fops;
1112 entry->data = acpi_driver_data(device);
1113 entry->owner = THIS_MODULE;
1114 }
1115
1116 /* 'temperature' [R] */
1117 entry = create_proc_entry(ACPI_THERMAL_FILE_TEMPERATURE,
1118 S_IRUGO, acpi_device_dir(device));
1119 if (!entry)
1120 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1121 "Unable to create '%s' fs entry\n",
1122 ACPI_THERMAL_FILE_TEMPERATURE));
1123 else {
1124 entry->proc_fops = &acpi_thermal_temp_fops;
1125 entry->data = acpi_driver_data(device);
1126 entry->owner = THIS_MODULE;
1127 }
1128
1129 /* 'trip_points' [R/W] */
1130 entry = create_proc_entry(ACPI_THERMAL_FILE_TRIP_POINTS,
1131 S_IFREG|S_IRUGO|S_IWUSR, acpi_device_dir(device));
1132 if (!entry)
1133 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1134 "Unable to create '%s' fs entry\n",
1135 ACPI_THERMAL_FILE_TRIP_POINTS));
1136 else {
1137 entry->proc_fops = &acpi_thermal_trip_fops;
1138 entry->data = acpi_driver_data(device);
1139 entry->owner = THIS_MODULE;
1140 }
1141
1142 /* 'cooling_mode' [R/W] */
1143 entry = create_proc_entry(ACPI_THERMAL_FILE_COOLING_MODE,
1144 S_IFREG|S_IRUGO|S_IWUSR, acpi_device_dir(device));
1145 if (!entry)
1146 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1147 "Unable to create '%s' fs entry\n",
1148 ACPI_THERMAL_FILE_COOLING_MODE));
1149 else {
1150 entry->proc_fops = &acpi_thermal_cooling_fops;
1151 entry->data = acpi_driver_data(device);
1152 entry->owner = THIS_MODULE;
1153 }
1154
1155 /* 'polling_frequency' [R/W] */
1156 entry = create_proc_entry(ACPI_THERMAL_FILE_POLLING_FREQ,
1157 S_IFREG|S_IRUGO|S_IWUSR, acpi_device_dir(device));
1158 if (!entry)
1159 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1160 "Unable to create '%s' fs entry\n",
1161 ACPI_THERMAL_FILE_POLLING_FREQ));
1162 else {
1163 entry->proc_fops = &acpi_thermal_polling_fops;
1164 entry->data = acpi_driver_data(device);
1165 entry->owner = THIS_MODULE;
1166 }
1167
1168 return_VALUE(0);
1169 }
1170
1171
1172 static int
1173 acpi_thermal_remove_fs (
1174 struct acpi_device *device)
1175 {
1176 ACPI_FUNCTION_TRACE("acpi_thermal_remove_fs");
1177
1178 if (acpi_device_dir(device)) {
1179 remove_proc_entry(ACPI_THERMAL_FILE_POLLING_FREQ,
1180 acpi_device_dir(device));
1181 remove_proc_entry(ACPI_THERMAL_FILE_COOLING_MODE,
1182 acpi_device_dir(device));
1183 remove_proc_entry(ACPI_THERMAL_FILE_TRIP_POINTS,
1184 acpi_device_dir(device));
1185 remove_proc_entry(ACPI_THERMAL_FILE_TEMPERATURE,
1186 acpi_device_dir(device));
1187 remove_proc_entry(ACPI_THERMAL_FILE_STATE,
1188 acpi_device_dir(device));
1189 remove_proc_entry(acpi_device_bid(device), acpi_thermal_dir);
1190 acpi_device_dir(device) = NULL;
1191 }
1192
1193 return_VALUE(0);
1194 }
1195
1196
1197 /* --------------------------------------------------------------------------
1198 Driver Interface
1199 -------------------------------------------------------------------------- */
1200
1201 static void
1202 acpi_thermal_notify (
1203 acpi_handle handle,
1204 u32 event,
1205 void *data)
1206 {
1207 struct acpi_thermal *tz = (struct acpi_thermal *) data;
1208 struct acpi_device *device = NULL;
1209
1210 ACPI_FUNCTION_TRACE("acpi_thermal_notify");
1211
1212 if (!tz)
1213 return_VOID;
1214
1215 if (acpi_bus_get_device(tz->handle, &device))
1216 return_VOID;
1217
1218 switch (event) {
1219 case ACPI_THERMAL_NOTIFY_TEMPERATURE:
1220 acpi_thermal_check(tz);
1221 break;
1222 case ACPI_THERMAL_NOTIFY_THRESHOLDS:
1223 acpi_thermal_get_trip_points(tz);
1224 acpi_thermal_check(tz);
1225 acpi_bus_generate_event(device, event, 0);
1226 break;
1227 case ACPI_THERMAL_NOTIFY_DEVICES:
1228 if (tz->flags.devices)
1229 acpi_thermal_get_devices(tz);
1230 acpi_bus_generate_event(device, event, 0);
1231 break;
1232 default:
1233 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1234 "Unsupported event [0x%x]\n", event));
1235 break;
1236 }
1237
1238 return_VOID;
1239 }
1240
1241
1242 static int
1243 acpi_thermal_get_info (
1244 struct acpi_thermal *tz)
1245 {
1246 int result = 0;
1247
1248 ACPI_FUNCTION_TRACE("acpi_thermal_get_info");
1249
1250 if (!tz)
1251 return_VALUE(-EINVAL);
1252
1253 /* Get temperature [_TMP] (required) */
1254 result = acpi_thermal_get_temperature(tz);
1255 if (result)
1256 return_VALUE(result);
1257
1258 /* Get trip points [_CRT, _PSV, etc.] (required) */
1259 result = acpi_thermal_get_trip_points(tz);
1260 if (result)
1261 return_VALUE(result);
1262
1263 /* Set the cooling mode [_SCP] to active cooling (default) */
1264 result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
1265 if (!result)
1266 tz->flags.cooling_mode = 1;
1267 else {
1268 /* Oh,we have not _SCP method.
1269 Generally show cooling_mode by _ACx, _PSV,spec 12.2*/
1270 tz->flags.cooling_mode = 0;
1271 if ( tz->trips.active[0].flags.valid && tz->trips.passive.flags.valid ) {
1272 if ( tz->trips.passive.temperature > tz->trips.active[0].temperature )
1273 tz->cooling_mode = ACPI_THERMAL_MODE_ACTIVE;
1274 else
1275 tz->cooling_mode = ACPI_THERMAL_MODE_PASSIVE;
1276 } else if ( !tz->trips.active[0].flags.valid && tz->trips.passive.flags.valid ) {
1277 tz->cooling_mode = ACPI_THERMAL_MODE_PASSIVE;
1278 } else if ( tz->trips.active[0].flags.valid && !tz->trips.passive.flags.valid ) {
1279 tz->cooling_mode = ACPI_THERMAL_MODE_ACTIVE;
1280 } else {
1281 /* _ACx and _PSV are optional, but _CRT is required */
1282 tz->cooling_mode = ACPI_THERMAL_MODE_CRITICAL;
1283 }
1284 }
1285
1286 /* Get default polling frequency [_TZP] (optional) */
1287 if (tzp)
1288 tz->polling_frequency = tzp;
1289 else
1290 acpi_thermal_get_polling_frequency(tz);
1291
1292 /* Get devices in this thermal zone [_TZD] (optional) */
1293 result = acpi_thermal_get_devices(tz);
1294 if (!result)
1295 tz->flags.devices = 1;
1296
1297 return_VALUE(0);
1298 }
1299
1300
1301 static int
1302 acpi_thermal_add (
1303 struct acpi_device *device)
1304 {
1305 int result = 0;
1306 acpi_status status = AE_OK;
1307 struct acpi_thermal *tz = NULL;
1308
1309 ACPI_FUNCTION_TRACE("acpi_thermal_add");
1310
1311 if (!device)
1312 return_VALUE(-EINVAL);
1313
1314 tz = kmalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
1315 if (!tz)
1316 return_VALUE(-ENOMEM);
1317 memset(tz, 0, sizeof(struct acpi_thermal));
1318
1319 tz->handle = device->handle;
1320 strcpy(tz->name, device->pnp.bus_id);
1321 strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
1322 strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
1323 acpi_driver_data(device) = tz;
1324
1325 result = acpi_thermal_get_info(tz);
1326 if (result)
1327 goto end;
1328
1329 result = acpi_thermal_add_fs(device);
1330 if (result)
1331 return_VALUE(result);
1332
1333 init_timer(&tz->timer);
1334
1335 acpi_thermal_check(tz);
1336
1337 status = acpi_install_notify_handler(tz->handle,
1338 ACPI_DEVICE_NOTIFY, acpi_thermal_notify, tz);
1339 if (ACPI_FAILURE(status)) {
1340 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1341 "Error installing notify handler\n"));
1342 result = -ENODEV;
1343 goto end;
1344 }
1345
1346 printk(KERN_INFO PREFIX "%s [%s] (%ld C)\n",
1347 acpi_device_name(device), acpi_device_bid(device),
1348 KELVIN_TO_CELSIUS(tz->temperature));
1349
1350 end:
1351 if (result) {
1352 acpi_thermal_remove_fs(device);
1353 kfree(tz);
1354 }
1355
1356 return_VALUE(result);
1357 }
1358
1359
1360 static int
1361 acpi_thermal_remove (
1362 struct acpi_device *device,
1363 int type)
1364 {
1365 acpi_status status = AE_OK;
1366 struct acpi_thermal *tz = NULL;
1367
1368 ACPI_FUNCTION_TRACE("acpi_thermal_remove");
1369
1370 if (!device || !acpi_driver_data(device))
1371 return_VALUE(-EINVAL);
1372
1373 tz = (struct acpi_thermal *) acpi_driver_data(device);
1374
1375 /* avoid timer adding new defer task */
1376 tz->zombie = 1;
1377 /* wait for running timer (on other CPUs) finish */
1378 del_timer_sync(&(tz->timer));
1379 /* synchronize deferred task */
1380 acpi_os_wait_events_complete(NULL);
1381 /* deferred task may reinsert timer */
1382 del_timer_sync(&(tz->timer));
1383
1384 status = acpi_remove_notify_handler(tz->handle,
1385 ACPI_DEVICE_NOTIFY, acpi_thermal_notify);
1386 if (ACPI_FAILURE(status))
1387 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1388 "Error removing notify handler\n"));
1389
1390 /* Terminate policy */
1391 if (tz->trips.passive.flags.valid
1392 && tz->trips.passive.flags.enabled) {
1393 tz->trips.passive.flags.enabled = 0;
1394 acpi_thermal_passive(tz);
1395 }
1396 if (tz->trips.active[0].flags.valid
1397 && tz->trips.active[0].flags.enabled) {
1398 tz->trips.active[0].flags.enabled = 0;
1399 acpi_thermal_active(tz);
1400 }
1401
1402 acpi_thermal_remove_fs(device);
1403
1404 kfree(tz);
1405 return_VALUE(0);
1406 }
1407
1408
1409 static int __init
1410 acpi_thermal_init (void)
1411 {
1412 int result = 0;
1413
1414 ACPI_FUNCTION_TRACE("acpi_thermal_init");
1415
1416 acpi_thermal_dir = proc_mkdir(ACPI_THERMAL_CLASS, acpi_root_dir);
1417 if (!acpi_thermal_dir)
1418 return_VALUE(-ENODEV);
1419 acpi_thermal_dir->owner = THIS_MODULE;
1420
1421 result = acpi_bus_register_driver(&acpi_thermal_driver);
1422 if (result < 0) {
1423 remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
1424 return_VALUE(-ENODEV);
1425 }
1426
1427 return_VALUE(0);
1428 }
1429
1430
1431 static void __exit
1432 acpi_thermal_exit (void)
1433 {
1434 ACPI_FUNCTION_TRACE("acpi_thermal_exit");
1435
1436 acpi_bus_unregister_driver(&acpi_thermal_driver);
1437
1438 remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
1439
1440 return_VOID;
1441 }
1442
1443
1444 module_init(acpi_thermal_init);
1445 module_exit(acpi_thermal_exit);
1446
|
This page was automatically generated by the
LXR engine.
|