2 * acpi_thermal.c - ACPI Thermal Zone Driver ($Revision: 41 $)
4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.
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.
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.
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 * This driver fully implements the ACPI thermal policy as described in the
26 * ACPI 2.0 Specification.
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.
34 #include <linux/kernel.h>
35 #include <linux/module.h>
36 #include <linux/dmi.h>
37 #include <linux/init.h>
38 #include <linux/slab.h>
39 #include <linux/types.h>
40 #include <linux/jiffies.h>
41 #include <linux/kmod.h>
42 #include <linux/reboot.h>
43 #include <linux/device.h>
44 #include <asm/uaccess.h>
45 #include <linux/thermal.h>
46 #include <acpi/acpi_bus.h>
47 #include <acpi/acpi_drivers.h>
49 #define PREFIX "ACPI: "
51 #define ACPI_THERMAL_CLASS "thermal_zone"
52 #define ACPI_THERMAL_DEVICE_NAME "Thermal Zone"
53 #define ACPI_THERMAL_NOTIFY_TEMPERATURE 0x80
54 #define ACPI_THERMAL_NOTIFY_THRESHOLDS 0x81
55 #define ACPI_THERMAL_NOTIFY_DEVICES 0x82
56 #define ACPI_THERMAL_NOTIFY_CRITICAL 0xF0
57 #define ACPI_THERMAL_NOTIFY_HOT 0xF1
58 #define ACPI_THERMAL_MODE_ACTIVE 0x00
60 #define ACPI_THERMAL_MAX_ACTIVE 10
61 #define ACPI_THERMAL_MAX_LIMIT_STR_LEN 65
63 #define _COMPONENT ACPI_THERMAL_COMPONENT
64 ACPI_MODULE_NAME("thermal");
66 MODULE_AUTHOR("Paul Diefenbaugh");
67 MODULE_DESCRIPTION("ACPI Thermal Zone Driver");
68 MODULE_LICENSE("GPL");
71 module_param(act
, int, 0644);
72 MODULE_PARM_DESC(act
, "Disable or override all lowest active trip points.");
75 module_param(crt
, int, 0644);
76 MODULE_PARM_DESC(crt
, "Disable or lower all critical trip points.");
79 module_param(tzp
, int, 0444);
80 MODULE_PARM_DESC(tzp
, "Thermal zone polling frequency, in 1/10 seconds.");
83 module_param(nocrt
, int, 0);
84 MODULE_PARM_DESC(nocrt
, "Set to take no action upon ACPI thermal zone critical trips points.");
87 module_param(off
, int, 0);
88 MODULE_PARM_DESC(off
, "Set to disable ACPI thermal support.");
91 module_param(psv
, int, 0644);
92 MODULE_PARM_DESC(psv
, "Disable or override all passive trip points.");
94 static int acpi_thermal_add(struct acpi_device
*device
);
95 static int acpi_thermal_remove(struct acpi_device
*device
);
96 static void acpi_thermal_notify(struct acpi_device
*device
, u32 event
);
98 static const struct acpi_device_id thermal_device_ids
[] = {
99 {ACPI_THERMAL_HID
, 0},
102 MODULE_DEVICE_TABLE(acpi
, thermal_device_ids
);
104 #ifdef CONFIG_PM_SLEEP
105 static int acpi_thermal_resume(struct device
*dev
);
107 static SIMPLE_DEV_PM_OPS(acpi_thermal_pm
, NULL
, acpi_thermal_resume
);
109 static struct acpi_driver acpi_thermal_driver
= {
111 .class = ACPI_THERMAL_CLASS
,
112 .ids
= thermal_device_ids
,
114 .add
= acpi_thermal_add
,
115 .remove
= acpi_thermal_remove
,
116 .notify
= acpi_thermal_notify
,
118 .drv
.pm
= &acpi_thermal_pm
,
121 struct acpi_thermal_state
{
130 struct acpi_thermal_state_flags
{
136 struct acpi_thermal_critical
{
137 struct acpi_thermal_state_flags flags
;
138 unsigned long temperature
;
141 struct acpi_thermal_hot
{
142 struct acpi_thermal_state_flags flags
;
143 unsigned long temperature
;
146 struct acpi_thermal_passive
{
147 struct acpi_thermal_state_flags flags
;
148 unsigned long temperature
;
152 struct acpi_handle_list devices
;
155 struct acpi_thermal_active
{
156 struct acpi_thermal_state_flags flags
;
157 unsigned long temperature
;
158 struct acpi_handle_list devices
;
161 struct acpi_thermal_trips
{
162 struct acpi_thermal_critical critical
;
163 struct acpi_thermal_hot hot
;
164 struct acpi_thermal_passive passive
;
165 struct acpi_thermal_active active
[ACPI_THERMAL_MAX_ACTIVE
];
168 struct acpi_thermal_flags
{
169 u8 cooling_mode
:1; /* _SCP */
170 u8 devices
:1; /* _TZD */
174 struct acpi_thermal
{
175 struct acpi_device
* device
;
177 unsigned long temperature
;
178 unsigned long last_temperature
;
179 unsigned long polling_frequency
;
181 struct acpi_thermal_flags flags
;
182 struct acpi_thermal_state state
;
183 struct acpi_thermal_trips trips
;
184 struct acpi_handle_list devices
;
185 struct thermal_zone_device
*thermal_zone
;
190 /* --------------------------------------------------------------------------
191 Thermal Zone Management
192 -------------------------------------------------------------------------- */
194 static int acpi_thermal_get_temperature(struct acpi_thermal
*tz
)
196 acpi_status status
= AE_OK
;
197 unsigned long long tmp
;
202 tz
->last_temperature
= tz
->temperature
;
204 status
= acpi_evaluate_integer(tz
->device
->handle
, "_TMP", NULL
, &tmp
);
205 if (ACPI_FAILURE(status
))
208 tz
->temperature
= tmp
;
209 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Temperature is %lu dK\n",
215 static int acpi_thermal_get_polling_frequency(struct acpi_thermal
*tz
)
217 acpi_status status
= AE_OK
;
218 unsigned long long tmp
;
223 status
= acpi_evaluate_integer(tz
->device
->handle
, "_TZP", NULL
, &tmp
);
224 if (ACPI_FAILURE(status
))
227 tz
->polling_frequency
= tmp
;
228 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Polling frequency is %lu dS\n",
229 tz
->polling_frequency
));
234 static int acpi_thermal_set_cooling_mode(struct acpi_thermal
*tz
, int mode
)
239 if (!acpi_has_method(tz
->device
->handle
, "_SCP")) {
240 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "_SCP not present\n"));
242 } else if (ACPI_FAILURE(acpi_execute_simple_method(tz
->device
->handle
,
250 #define ACPI_TRIPS_CRITICAL 0x01
251 #define ACPI_TRIPS_HOT 0x02
252 #define ACPI_TRIPS_PASSIVE 0x04
253 #define ACPI_TRIPS_ACTIVE 0x08
254 #define ACPI_TRIPS_DEVICES 0x10
256 #define ACPI_TRIPS_REFRESH_THRESHOLDS (ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE)
257 #define ACPI_TRIPS_REFRESH_DEVICES ACPI_TRIPS_DEVICES
259 #define ACPI_TRIPS_INIT (ACPI_TRIPS_CRITICAL | ACPI_TRIPS_HOT | \
260 ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE | \
264 * This exception is thrown out in two cases:
265 * 1.An invalid trip point becomes invalid or a valid trip point becomes invalid
266 * when re-evaluating the AML code.
267 * 2.TODO: Devices listed in _PSL, _ALx, _TZD may change.
268 * We need to re-bind the cooling devices of a thermal zone when this occurs.
270 #define ACPI_THERMAL_TRIPS_EXCEPTION(flags, str) \
272 if (flags != ACPI_TRIPS_INIT) \
273 ACPI_EXCEPTION((AE_INFO, AE_ERROR, \
274 "ACPI thermal trip point %s changed\n" \
275 "Please send acpidump to linux-acpi@vger.kernel.org", str)); \
278 static int acpi_thermal_trips_update(struct acpi_thermal
*tz
, int flag
)
280 acpi_status status
= AE_OK
;
281 unsigned long long tmp
;
282 struct acpi_handle_list devices
;
286 /* Critical Shutdown */
287 if (flag
& ACPI_TRIPS_CRITICAL
) {
288 status
= acpi_evaluate_integer(tz
->device
->handle
,
290 tz
->trips
.critical
.temperature
= tmp
;
292 * Treat freezing temperatures as invalid as well; some
293 * BIOSes return really low values and cause reboots at startup.
294 * Below zero (Celsius) values clearly aren't right for sure..
295 * ... so lets discard those as invalid.
297 if (ACPI_FAILURE(status
)) {
298 tz
->trips
.critical
.flags
.valid
= 0;
299 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
300 "No critical threshold\n"));
301 } else if (tmp
<= 2732) {
302 pr_warn(FW_BUG
"Invalid critical threshold (%llu)\n",
304 tz
->trips
.critical
.flags
.valid
= 0;
306 tz
->trips
.critical
.flags
.valid
= 1;
307 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
308 "Found critical threshold [%lu]\n",
309 tz
->trips
.critical
.temperature
));
311 if (tz
->trips
.critical
.flags
.valid
== 1) {
313 tz
->trips
.critical
.flags
.valid
= 0;
314 } else if (crt
> 0) {
315 unsigned long crt_k
= CELSIUS_TO_KELVIN(crt
);
317 * Allow override critical threshold
319 if (crt_k
> tz
->trips
.critical
.temperature
)
320 pr_warn(PREFIX
"Critical threshold %d C\n",
322 tz
->trips
.critical
.temperature
= crt_k
;
327 /* Critical Sleep (optional) */
328 if (flag
& ACPI_TRIPS_HOT
) {
329 status
= acpi_evaluate_integer(tz
->device
->handle
,
331 if (ACPI_FAILURE(status
)) {
332 tz
->trips
.hot
.flags
.valid
= 0;
333 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
334 "No hot threshold\n"));
336 tz
->trips
.hot
.temperature
= tmp
;
337 tz
->trips
.hot
.flags
.valid
= 1;
338 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
339 "Found hot threshold [%lu]\n",
340 tz
->trips
.critical
.temperature
));
344 /* Passive (optional) */
345 if (((flag
& ACPI_TRIPS_PASSIVE
) && tz
->trips
.passive
.flags
.valid
) ||
346 (flag
== ACPI_TRIPS_INIT
)) {
347 valid
= tz
->trips
.passive
.flags
.valid
;
350 } else if (psv
> 0) {
351 tmp
= CELSIUS_TO_KELVIN(psv
);
354 status
= acpi_evaluate_integer(tz
->device
->handle
,
358 if (ACPI_FAILURE(status
))
359 tz
->trips
.passive
.flags
.valid
= 0;
361 tz
->trips
.passive
.temperature
= tmp
;
362 tz
->trips
.passive
.flags
.valid
= 1;
363 if (flag
== ACPI_TRIPS_INIT
) {
364 status
= acpi_evaluate_integer(
365 tz
->device
->handle
, "_TC1",
367 if (ACPI_FAILURE(status
))
368 tz
->trips
.passive
.flags
.valid
= 0;
370 tz
->trips
.passive
.tc1
= tmp
;
371 status
= acpi_evaluate_integer(
372 tz
->device
->handle
, "_TC2",
374 if (ACPI_FAILURE(status
))
375 tz
->trips
.passive
.flags
.valid
= 0;
377 tz
->trips
.passive
.tc2
= tmp
;
378 status
= acpi_evaluate_integer(
379 tz
->device
->handle
, "_TSP",
381 if (ACPI_FAILURE(status
))
382 tz
->trips
.passive
.flags
.valid
= 0;
384 tz
->trips
.passive
.tsp
= tmp
;
388 if ((flag
& ACPI_TRIPS_DEVICES
) && tz
->trips
.passive
.flags
.valid
) {
389 memset(&devices
, 0, sizeof(struct acpi_handle_list
));
390 status
= acpi_evaluate_reference(tz
->device
->handle
, "_PSL",
392 if (ACPI_FAILURE(status
)) {
393 pr_warn(PREFIX
"Invalid passive threshold\n");
394 tz
->trips
.passive
.flags
.valid
= 0;
397 tz
->trips
.passive
.flags
.valid
= 1;
399 if (memcmp(&tz
->trips
.passive
.devices
, &devices
,
400 sizeof(struct acpi_handle_list
))) {
401 memcpy(&tz
->trips
.passive
.devices
, &devices
,
402 sizeof(struct acpi_handle_list
));
403 ACPI_THERMAL_TRIPS_EXCEPTION(flag
, "device");
406 if ((flag
& ACPI_TRIPS_PASSIVE
) || (flag
& ACPI_TRIPS_DEVICES
)) {
407 if (valid
!= tz
->trips
.passive
.flags
.valid
)
408 ACPI_THERMAL_TRIPS_EXCEPTION(flag
, "state");
411 /* Active (optional) */
412 for (i
= 0; i
< ACPI_THERMAL_MAX_ACTIVE
; i
++) {
413 char name
[5] = { '_', 'A', 'C', ('0' + i
), '\0' };
414 valid
= tz
->trips
.active
[i
].flags
.valid
;
417 break; /* disable all active trip points */
419 if ((flag
== ACPI_TRIPS_INIT
) || ((flag
& ACPI_TRIPS_ACTIVE
) &&
420 tz
->trips
.active
[i
].flags
.valid
)) {
421 status
= acpi_evaluate_integer(tz
->device
->handle
,
423 if (ACPI_FAILURE(status
)) {
424 tz
->trips
.active
[i
].flags
.valid
= 0;
430 tz
->trips
.active
[0].temperature
=
431 CELSIUS_TO_KELVIN(act
);
434 * Don't allow override higher than
435 * the next higher trip point
437 tz
->trips
.active
[i
- 1].temperature
=
438 (tz
->trips
.active
[i
- 2].temperature
<
439 CELSIUS_TO_KELVIN(act
) ?
440 tz
->trips
.active
[i
- 2].temperature
:
441 CELSIUS_TO_KELVIN(act
));
444 tz
->trips
.active
[i
].temperature
= tmp
;
445 tz
->trips
.active
[i
].flags
.valid
= 1;
450 if ((flag
& ACPI_TRIPS_DEVICES
) && tz
->trips
.active
[i
].flags
.valid
) {
451 memset(&devices
, 0, sizeof(struct acpi_handle_list
));
452 status
= acpi_evaluate_reference(tz
->device
->handle
,
453 name
, NULL
, &devices
);
454 if (ACPI_FAILURE(status
)) {
455 pr_warn(PREFIX
"Invalid active%d threshold\n",
457 tz
->trips
.active
[i
].flags
.valid
= 0;
460 tz
->trips
.active
[i
].flags
.valid
= 1;
462 if (memcmp(&tz
->trips
.active
[i
].devices
, &devices
,
463 sizeof(struct acpi_handle_list
))) {
464 memcpy(&tz
->trips
.active
[i
].devices
, &devices
,
465 sizeof(struct acpi_handle_list
));
466 ACPI_THERMAL_TRIPS_EXCEPTION(flag
, "device");
469 if ((flag
& ACPI_TRIPS_ACTIVE
) || (flag
& ACPI_TRIPS_DEVICES
))
470 if (valid
!= tz
->trips
.active
[i
].flags
.valid
)
471 ACPI_THERMAL_TRIPS_EXCEPTION(flag
, "state");
473 if (!tz
->trips
.active
[i
].flags
.valid
)
477 if ((flag
& ACPI_TRIPS_DEVICES
)
478 && acpi_has_method(tz
->device
->handle
, "_TZD")) {
479 memset(&devices
, 0, sizeof(devices
));
480 status
= acpi_evaluate_reference(tz
->device
->handle
, "_TZD",
482 if (ACPI_SUCCESS(status
)
483 && memcmp(&tz
->devices
, &devices
, sizeof(devices
))) {
484 tz
->devices
= devices
;
485 ACPI_THERMAL_TRIPS_EXCEPTION(flag
, "device");
492 static int acpi_thermal_get_trip_points(struct acpi_thermal
*tz
)
494 int i
, valid
, ret
= acpi_thermal_trips_update(tz
, ACPI_TRIPS_INIT
);
499 valid
= tz
->trips
.critical
.flags
.valid
|
500 tz
->trips
.hot
.flags
.valid
|
501 tz
->trips
.passive
.flags
.valid
;
503 for (i
= 0; i
< ACPI_THERMAL_MAX_ACTIVE
; i
++)
504 valid
|= tz
->trips
.active
[i
].flags
.valid
;
507 pr_warn(FW_BUG
"No valid trip found\n");
513 static void acpi_thermal_check(void *data
)
515 struct acpi_thermal
*tz
= data
;
520 thermal_zone_device_update(tz
->thermal_zone
);
523 /* sys I/F for generic thermal sysfs support */
524 #define KELVIN_TO_MILLICELSIUS(t, off) (((t) - (off)) * 100)
526 static int thermal_get_temp(struct thermal_zone_device
*thermal
,
529 struct acpi_thermal
*tz
= thermal
->devdata
;
535 result
= acpi_thermal_get_temperature(tz
);
539 *temp
= KELVIN_TO_MILLICELSIUS(tz
->temperature
, tz
->kelvin_offset
);
543 static int thermal_get_mode(struct thermal_zone_device
*thermal
,
544 enum thermal_device_mode
*mode
)
546 struct acpi_thermal
*tz
= thermal
->devdata
;
551 *mode
= tz
->tz_enabled
? THERMAL_DEVICE_ENABLED
:
552 THERMAL_DEVICE_DISABLED
;
557 static int thermal_set_mode(struct thermal_zone_device
*thermal
,
558 enum thermal_device_mode mode
)
560 struct acpi_thermal
*tz
= thermal
->devdata
;
567 * enable/disable thermal management from ACPI thermal driver
569 if (mode
== THERMAL_DEVICE_ENABLED
)
571 else if (mode
== THERMAL_DEVICE_DISABLED
) {
573 pr_warn("thermal zone will be disabled\n");
577 if (enable
!= tz
->tz_enabled
) {
578 tz
->tz_enabled
= enable
;
579 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
580 "%s kernel ACPI thermal control\n",
581 tz
->tz_enabled
? "Enable" : "Disable"));
582 acpi_thermal_check(tz
);
587 static int thermal_get_trip_type(struct thermal_zone_device
*thermal
,
588 int trip
, enum thermal_trip_type
*type
)
590 struct acpi_thermal
*tz
= thermal
->devdata
;
596 if (tz
->trips
.critical
.flags
.valid
) {
598 *type
= THERMAL_TRIP_CRITICAL
;
604 if (tz
->trips
.hot
.flags
.valid
) {
606 *type
= THERMAL_TRIP_HOT
;
612 if (tz
->trips
.passive
.flags
.valid
) {
614 *type
= THERMAL_TRIP_PASSIVE
;
620 for (i
= 0; i
< ACPI_THERMAL_MAX_ACTIVE
&&
621 tz
->trips
.active
[i
].flags
.valid
; i
++) {
623 *type
= THERMAL_TRIP_ACTIVE
;
632 static int thermal_get_trip_temp(struct thermal_zone_device
*thermal
,
633 int trip
, unsigned long *temp
)
635 struct acpi_thermal
*tz
= thermal
->devdata
;
641 if (tz
->trips
.critical
.flags
.valid
) {
643 *temp
= KELVIN_TO_MILLICELSIUS(
644 tz
->trips
.critical
.temperature
,
651 if (tz
->trips
.hot
.flags
.valid
) {
653 *temp
= KELVIN_TO_MILLICELSIUS(
654 tz
->trips
.hot
.temperature
,
661 if (tz
->trips
.passive
.flags
.valid
) {
663 *temp
= KELVIN_TO_MILLICELSIUS(
664 tz
->trips
.passive
.temperature
,
671 for (i
= 0; i
< ACPI_THERMAL_MAX_ACTIVE
&&
672 tz
->trips
.active
[i
].flags
.valid
; i
++) {
674 *temp
= KELVIN_TO_MILLICELSIUS(
675 tz
->trips
.active
[i
].temperature
,
685 static int thermal_get_crit_temp(struct thermal_zone_device
*thermal
,
686 unsigned long *temperature
) {
687 struct acpi_thermal
*tz
= thermal
->devdata
;
689 if (tz
->trips
.critical
.flags
.valid
) {
690 *temperature
= KELVIN_TO_MILLICELSIUS(
691 tz
->trips
.critical
.temperature
,
698 static int thermal_get_trend(struct thermal_zone_device
*thermal
,
699 int trip
, enum thermal_trend
*trend
)
701 struct acpi_thermal
*tz
= thermal
->devdata
;
702 enum thermal_trip_type type
;
705 if (thermal_get_trip_type(thermal
, trip
, &type
))
708 if (type
== THERMAL_TRIP_ACTIVE
) {
709 unsigned long trip_temp
;
710 unsigned long temp
= KELVIN_TO_MILLICELSIUS(tz
->temperature
,
712 if (thermal_get_trip_temp(thermal
, trip
, &trip_temp
))
715 if (temp
> trip_temp
) {
716 *trend
= THERMAL_TREND_RAISING
;
719 /* Fall back on default trend */
725 * tz->temperature has already been updated by generic thermal layer,
726 * before this callback being invoked
728 i
= (tz
->trips
.passive
.tc1
* (tz
->temperature
- tz
->last_temperature
))
729 + (tz
->trips
.passive
.tc2
730 * (tz
->temperature
- tz
->trips
.passive
.temperature
));
733 *trend
= THERMAL_TREND_RAISING
;
735 *trend
= THERMAL_TREND_DROPPING
;
737 *trend
= THERMAL_TREND_STABLE
;
742 static int thermal_notify(struct thermal_zone_device
*thermal
, int trip
,
743 enum thermal_trip_type trip_type
)
746 struct acpi_thermal
*tz
= thermal
->devdata
;
748 if (trip_type
== THERMAL_TRIP_CRITICAL
)
749 type
= ACPI_THERMAL_NOTIFY_CRITICAL
;
750 else if (trip_type
== THERMAL_TRIP_HOT
)
751 type
= ACPI_THERMAL_NOTIFY_HOT
;
755 acpi_bus_generate_netlink_event(tz
->device
->pnp
.device_class
,
756 dev_name(&tz
->device
->dev
), type
, 1);
758 if (trip_type
== THERMAL_TRIP_CRITICAL
&& nocrt
)
764 static int acpi_thermal_cooling_device_cb(struct thermal_zone_device
*thermal
,
765 struct thermal_cooling_device
*cdev
,
768 struct acpi_device
*device
= cdev
->devdata
;
769 struct acpi_thermal
*tz
= thermal
->devdata
;
770 struct acpi_device
*dev
;
778 if (tz
->trips
.critical
.flags
.valid
)
781 if (tz
->trips
.hot
.flags
.valid
)
784 if (tz
->trips
.passive
.flags
.valid
) {
786 for (i
= 0; i
< tz
->trips
.passive
.devices
.count
;
788 handle
= tz
->trips
.passive
.devices
.handles
[i
];
789 status
= acpi_bus_get_device(handle
, &dev
);
790 if (ACPI_FAILURE(status
) || dev
!= device
)
794 thermal_zone_bind_cooling_device
795 (thermal
, trip
, cdev
,
796 THERMAL_NO_LIMIT
, THERMAL_NO_LIMIT
);
799 thermal_zone_unbind_cooling_device
800 (thermal
, trip
, cdev
);
806 for (i
= 0; i
< ACPI_THERMAL_MAX_ACTIVE
; i
++) {
807 if (!tz
->trips
.active
[i
].flags
.valid
)
811 j
< tz
->trips
.active
[i
].devices
.count
;
813 handle
= tz
->trips
.active
[i
].devices
.handles
[j
];
814 status
= acpi_bus_get_device(handle
, &dev
);
815 if (ACPI_FAILURE(status
) || dev
!= device
)
818 result
= thermal_zone_bind_cooling_device
819 (thermal
, trip
, cdev
,
820 THERMAL_NO_LIMIT
, THERMAL_NO_LIMIT
);
822 result
= thermal_zone_unbind_cooling_device
823 (thermal
, trip
, cdev
);
829 for (i
= 0; i
< tz
->devices
.count
; i
++) {
830 handle
= tz
->devices
.handles
[i
];
831 status
= acpi_bus_get_device(handle
, &dev
);
832 if (ACPI_SUCCESS(status
) && (dev
== device
)) {
834 result
= thermal_zone_bind_cooling_device
835 (thermal
, THERMAL_TRIPS_NONE
,
836 cdev
, THERMAL_NO_LIMIT
,
839 result
= thermal_zone_unbind_cooling_device
840 (thermal
, THERMAL_TRIPS_NONE
,
852 acpi_thermal_bind_cooling_device(struct thermal_zone_device
*thermal
,
853 struct thermal_cooling_device
*cdev
)
855 return acpi_thermal_cooling_device_cb(thermal
, cdev
, true);
859 acpi_thermal_unbind_cooling_device(struct thermal_zone_device
*thermal
,
860 struct thermal_cooling_device
*cdev
)
862 return acpi_thermal_cooling_device_cb(thermal
, cdev
, false);
865 static const struct thermal_zone_device_ops acpi_thermal_zone_ops
= {
866 .bind
= acpi_thermal_bind_cooling_device
,
867 .unbind
= acpi_thermal_unbind_cooling_device
,
868 .get_temp
= thermal_get_temp
,
869 .get_mode
= thermal_get_mode
,
870 .set_mode
= thermal_set_mode
,
871 .get_trip_type
= thermal_get_trip_type
,
872 .get_trip_temp
= thermal_get_trip_temp
,
873 .get_crit_temp
= thermal_get_crit_temp
,
874 .get_trend
= thermal_get_trend
,
875 .notify
= thermal_notify
,
878 static int acpi_thermal_register_thermal_zone(struct acpi_thermal
*tz
)
885 if (tz
->trips
.critical
.flags
.valid
)
888 if (tz
->trips
.hot
.flags
.valid
)
891 if (tz
->trips
.passive
.flags
.valid
)
894 for (i
= 0; i
< ACPI_THERMAL_MAX_ACTIVE
&&
895 tz
->trips
.active
[i
].flags
.valid
; i
++, trips
++);
897 if (tz
->trips
.passive
.flags
.valid
)
899 thermal_zone_device_register("acpitz", trips
, 0, tz
,
900 &acpi_thermal_zone_ops
, NULL
,
901 tz
->trips
.passive
.tsp
*100,
902 tz
->polling_frequency
*100);
905 thermal_zone_device_register("acpitz", trips
, 0, tz
,
906 &acpi_thermal_zone_ops
, NULL
,
907 0, tz
->polling_frequency
*100);
908 if (IS_ERR(tz
->thermal_zone
))
911 result
= sysfs_create_link(&tz
->device
->dev
.kobj
,
912 &tz
->thermal_zone
->device
.kobj
, "thermal_zone");
916 result
= sysfs_create_link(&tz
->thermal_zone
->device
.kobj
,
917 &tz
->device
->dev
.kobj
, "device");
921 status
= acpi_attach_data(tz
->device
->handle
,
922 acpi_bus_private_data_handler
,
924 if (ACPI_FAILURE(status
)) {
925 pr_err(PREFIX
"Error attaching device data\n");
931 dev_info(&tz
->device
->dev
, "registered as thermal_zone%d\n",
932 tz
->thermal_zone
->id
);
936 static void acpi_thermal_unregister_thermal_zone(struct acpi_thermal
*tz
)
938 sysfs_remove_link(&tz
->device
->dev
.kobj
, "thermal_zone");
939 sysfs_remove_link(&tz
->thermal_zone
->device
.kobj
, "device");
940 thermal_zone_device_unregister(tz
->thermal_zone
);
941 tz
->thermal_zone
= NULL
;
942 acpi_detach_data(tz
->device
->handle
, acpi_bus_private_data_handler
);
946 /* --------------------------------------------------------------------------
948 -------------------------------------------------------------------------- */
950 static void acpi_thermal_notify(struct acpi_device
*device
, u32 event
)
952 struct acpi_thermal
*tz
= acpi_driver_data(device
);
959 case ACPI_THERMAL_NOTIFY_TEMPERATURE
:
960 acpi_thermal_check(tz
);
962 case ACPI_THERMAL_NOTIFY_THRESHOLDS
:
963 acpi_thermal_trips_update(tz
, ACPI_TRIPS_REFRESH_THRESHOLDS
);
964 acpi_thermal_check(tz
);
965 acpi_bus_generate_netlink_event(device
->pnp
.device_class
,
966 dev_name(&device
->dev
), event
, 0);
968 case ACPI_THERMAL_NOTIFY_DEVICES
:
969 acpi_thermal_trips_update(tz
, ACPI_TRIPS_REFRESH_DEVICES
);
970 acpi_thermal_check(tz
);
971 acpi_bus_generate_netlink_event(device
->pnp
.device_class
,
972 dev_name(&device
->dev
), event
, 0);
975 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
976 "Unsupported event [0x%x]\n", event
));
982 * On some platforms, the AML code has dependency about
983 * the evaluating order of _TMP and _CRT/_HOT/_PSV/_ACx.
984 * 1. On HP Pavilion G4-1016tx, _TMP must be invoked after
985 * /_CRT/_HOT/_PSV/_ACx, or else system will be power off.
986 * 2. On HP Compaq 6715b/6715s, the return value of _PSV is 0
987 * if _TMP has never been evaluated.
989 * As this dependency is totally transparent to OS, evaluate
990 * all of them once, in the order of _CRT/_HOT/_PSV/_ACx,
991 * _TMP, before they are actually used.
993 static void acpi_thermal_aml_dependency_fix(struct acpi_thermal
*tz
)
995 acpi_handle handle
= tz
->device
->handle
;
996 unsigned long long value
;
999 acpi_evaluate_integer(handle
, "_CRT", NULL
, &value
);
1000 acpi_evaluate_integer(handle
, "_HOT", NULL
, &value
);
1001 acpi_evaluate_integer(handle
, "_PSV", NULL
, &value
);
1002 for (i
= 0; i
< ACPI_THERMAL_MAX_ACTIVE
; i
++) {
1003 char name
[5] = { '_', 'A', 'C', ('0' + i
), '\0' };
1006 status
= acpi_evaluate_integer(handle
, name
, NULL
, &value
);
1007 if (status
== AE_NOT_FOUND
)
1010 acpi_evaluate_integer(handle
, "_TMP", NULL
, &value
);
1013 static int acpi_thermal_get_info(struct acpi_thermal
*tz
)
1021 acpi_thermal_aml_dependency_fix(tz
);
1023 /* Get trip points [_CRT, _PSV, etc.] (required) */
1024 result
= acpi_thermal_get_trip_points(tz
);
1028 /* Get temperature [_TMP] (required) */
1029 result
= acpi_thermal_get_temperature(tz
);
1033 /* Set the cooling mode [_SCP] to active cooling (default) */
1034 result
= acpi_thermal_set_cooling_mode(tz
, ACPI_THERMAL_MODE_ACTIVE
);
1036 tz
->flags
.cooling_mode
= 1;
1038 /* Get default polling frequency [_TZP] (optional) */
1040 tz
->polling_frequency
= tzp
;
1042 acpi_thermal_get_polling_frequency(tz
);
1048 * The exact offset between Kelvin and degree Celsius is 273.15. However ACPI
1049 * handles temperature values with a single decimal place. As a consequence,
1050 * some implementations use an offset of 273.1 and others use an offset of
1051 * 273.2. Try to find out which one is being used, to present the most
1052 * accurate and visually appealing number.
1054 * The heuristic below should work for all ACPI thermal zones which have a
1055 * critical trip point with a value being a multiple of 0.5 degree Celsius.
1057 static void acpi_thermal_guess_offset(struct acpi_thermal
*tz
)
1059 if (tz
->trips
.critical
.flags
.valid
&&
1060 (tz
->trips
.critical
.temperature
% 5) == 1)
1061 tz
->kelvin_offset
= 2731;
1063 tz
->kelvin_offset
= 2732;
1066 static int acpi_thermal_add(struct acpi_device
*device
)
1069 struct acpi_thermal
*tz
= NULL
;
1075 tz
= kzalloc(sizeof(struct acpi_thermal
), GFP_KERNEL
);
1079 tz
->device
= device
;
1080 strcpy(tz
->name
, device
->pnp
.bus_id
);
1081 strcpy(acpi_device_name(device
), ACPI_THERMAL_DEVICE_NAME
);
1082 strcpy(acpi_device_class(device
), ACPI_THERMAL_CLASS
);
1083 device
->driver_data
= tz
;
1085 result
= acpi_thermal_get_info(tz
);
1089 acpi_thermal_guess_offset(tz
);
1091 result
= acpi_thermal_register_thermal_zone(tz
);
1095 pr_info(PREFIX
"%s [%s] (%ld C)\n", acpi_device_name(device
),
1096 acpi_device_bid(device
), KELVIN_TO_CELSIUS(tz
->temperature
));
1105 static int acpi_thermal_remove(struct acpi_device
*device
)
1107 struct acpi_thermal
*tz
= NULL
;
1109 if (!device
|| !acpi_driver_data(device
))
1112 tz
= acpi_driver_data(device
);
1114 acpi_thermal_unregister_thermal_zone(tz
);
1119 #ifdef CONFIG_PM_SLEEP
1120 static int acpi_thermal_resume(struct device
*dev
)
1122 struct acpi_thermal
*tz
;
1123 int i
, j
, power_state
, result
;
1128 tz
= acpi_driver_data(to_acpi_device(dev
));
1132 for (i
= 0; i
< ACPI_THERMAL_MAX_ACTIVE
; i
++) {
1133 if (!(&tz
->trips
.active
[i
]))
1135 if (!tz
->trips
.active
[i
].flags
.valid
)
1137 tz
->trips
.active
[i
].flags
.enabled
= 1;
1138 for (j
= 0; j
< tz
->trips
.active
[i
].devices
.count
; j
++) {
1139 result
= acpi_bus_update_power(
1140 tz
->trips
.active
[i
].devices
.handles
[j
],
1142 if (result
|| (power_state
!= ACPI_STATE_D0
)) {
1143 tz
->trips
.active
[i
].flags
.enabled
= 0;
1147 tz
->state
.active
|= tz
->trips
.active
[i
].flags
.enabled
;
1150 acpi_thermal_check(tz
);
1156 static int thermal_act(const struct dmi_system_id
*d
) {
1159 pr_notice(PREFIX
"%s detected: "
1160 "disabling all active thermal trip points\n", d
->ident
);
1165 static int thermal_nocrt(const struct dmi_system_id
*d
) {
1167 pr_notice(PREFIX
"%s detected: "
1168 "disabling all critical thermal trip point actions.\n", d
->ident
);
1172 static int thermal_tzp(const struct dmi_system_id
*d
) {
1175 pr_notice(PREFIX
"%s detected: "
1176 "enabling thermal zone polling\n", d
->ident
);
1177 tzp
= 300; /* 300 dS = 30 Seconds */
1181 static int thermal_psv(const struct dmi_system_id
*d
) {
1184 pr_notice(PREFIX
"%s detected: "
1185 "disabling all passive thermal trip points\n", d
->ident
);
1191 static struct dmi_system_id thermal_dmi_table
[] __initdata
= {
1193 * Award BIOS on this AOpen makes thermal control almost worthless.
1194 * http://bugzilla.kernel.org/show_bug.cgi?id=8842
1197 .callback
= thermal_act
,
1198 .ident
= "AOpen i915GMm-HFS",
1200 DMI_MATCH(DMI_BOARD_VENDOR
, "AOpen"),
1201 DMI_MATCH(DMI_BOARD_NAME
, "i915GMm-HFS"),
1205 .callback
= thermal_psv
,
1206 .ident
= "AOpen i915GMm-HFS",
1208 DMI_MATCH(DMI_BOARD_VENDOR
, "AOpen"),
1209 DMI_MATCH(DMI_BOARD_NAME
, "i915GMm-HFS"),
1213 .callback
= thermal_tzp
,
1214 .ident
= "AOpen i915GMm-HFS",
1216 DMI_MATCH(DMI_BOARD_VENDOR
, "AOpen"),
1217 DMI_MATCH(DMI_BOARD_NAME
, "i915GMm-HFS"),
1221 .callback
= thermal_nocrt
,
1222 .ident
= "Gigabyte GA-7ZX",
1224 DMI_MATCH(DMI_BOARD_VENDOR
, "Gigabyte Technology Co., Ltd."),
1225 DMI_MATCH(DMI_BOARD_NAME
, "7ZX"),
1231 static int __init
acpi_thermal_init(void)
1235 dmi_check_system(thermal_dmi_table
);
1238 pr_notice(PREFIX
"thermal control disabled\n");
1242 result
= acpi_bus_register_driver(&acpi_thermal_driver
);
1249 static void __exit
acpi_thermal_exit(void)
1252 acpi_bus_unregister_driver(&acpi_thermal_driver
);
1257 module_init(acpi_thermal_init
);
1258 module_exit(acpi_thermal_exit
);