2 * acerhdf - A driver which monitors the temperature
3 * of the aspire one netbook, turns on/off the fan
4 * as soon as the upper/lower threshold is reached.
6 * (C) 2009 - Peter Feuerer peter (a) piie.net
8 * 2009 Borislav Petkov <petkovbb@gmail.com>
10 * Inspired by and many thanks to:
11 * o acerfand - Rachel Greenham
12 * o acer_ec.pl - Michael Kurz michi.kurz (at) googlemail.com
13 * - Petr Tomasek tomasek (#) etf,cuni,cz
14 * - Carlos Corbacho cathectic (at) gmail.com
15 * o lkml - Matthew Garrett
19 * This program is free software; you can redistribute it and/or modify
20 * it under the terms of the GNU General Public License as published by
21 * the Free Software Foundation; either version 2 of the License, or
22 * (at your option) any later version.
24 * This program is distributed in the hope that it will be useful,
25 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 * GNU General Public License for more details.
29 * You should have received a copy of the GNU General Public License
30 * along with this program; if not, write to the Free Software
31 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
34 #define pr_fmt(fmt) "acerhdf: " fmt
36 #include <linux/kernel.h>
37 #include <linux/module.h>
39 #include <linux/dmi.h>
40 #include <acpi/acpi_drivers.h>
41 #include <linux/sched.h>
42 #include <linux/thermal.h>
43 #include <linux/platform_device.h>
46 * The driver is started with "kernel mode off" by default. That means, the BIOS
47 * is still in control of the fan. In this mode the driver allows to read the
48 * temperature of the cpu and a userspace tool may take over control of the fan.
49 * If the driver is switched to "kernel mode" (e.g. via module parameter) the
50 * driver is in full control of the fan. If you want the module to be started in
51 * kernel mode by default, define the following:
53 #undef START_IN_KERNEL_MODE
55 #define DRV_VER "0.5.17"
58 * According to the Atom N270 datasheet,
59 * (http://download.intel.com/design/processor/datashts/320032.pdf) the
60 * CPU's optimal operating limits denoted in junction temperature as
61 * measured by the on-die thermal monitor are within 0 <= Tj <= 90. So,
62 * assume 89°C is critical temperature.
64 #define ACERHDF_TEMP_CRIT 89
65 #define ACERHDF_FAN_OFF 0
66 #define ACERHDF_FAN_AUTO 1
69 * No matter what value the user puts into the fanon variable, turn on the fan
70 * at 80 degree Celsius to prevent hardware damage
72 #define ACERHDF_MAX_FANON 80
75 * Maximum interval between two temperature checks is 15 seconds, as the die
76 * can get hot really fast under heavy load (plus we shouldn't forget about
77 * possible impact of _external_ aggressive sources such as heaters, sun etc.)
79 #define ACERHDF_MAX_INTERVAL 15
81 #ifdef START_IN_KERNEL_MODE
82 static int kernelmode
= 1;
84 static int kernelmode
;
87 static unsigned int interval
= 10;
88 static unsigned int fanon
= 63;
89 static unsigned int fanoff
= 58;
90 static unsigned int verbose
;
91 static unsigned int fanstate
= ACERHDF_FAN_AUTO
;
92 static char force_bios
[16];
93 static char force_product
[16];
94 static unsigned int prev_interval
;
95 struct thermal_zone_device
*thz_dev
;
96 struct thermal_cooling_device
*cl_dev
;
97 struct platform_device
*acerhdf_dev
;
99 module_param(kernelmode
, uint
, 0);
100 MODULE_PARM_DESC(kernelmode
, "Kernel mode fan control on / off");
101 module_param(interval
, uint
, 0600);
102 MODULE_PARM_DESC(interval
, "Polling interval of temperature check");
103 module_param(fanon
, uint
, 0600);
104 MODULE_PARM_DESC(fanon
, "Turn the fan on above this temperature");
105 module_param(fanoff
, uint
, 0600);
106 MODULE_PARM_DESC(fanoff
, "Turn the fan off below this temperature");
107 module_param(verbose
, uint
, 0600);
108 MODULE_PARM_DESC(verbose
, "Enable verbose dmesg output");
109 module_param_string(force_bios
, force_bios
, 16, 0);
110 MODULE_PARM_DESC(force_bios
, "Force BIOS version and omit BIOS check");
111 module_param_string(force_product
, force_product
, 16, 0);
112 MODULE_PARM_DESC(force_product
, "Force BIOS product and omit BIOS check");
115 * cmd_off: to switch the fan completely off / to check if the fan is off
116 * cmd_auto: to set the BIOS in control of the fan. The BIOS regulates then
117 * the fan speed depending on the temperature
125 struct bios_settings_t
{
129 unsigned char fanreg
;
130 unsigned char tempreg
;
134 /* Register addresses and values for different BIOS versions */
135 static const struct bios_settings_t bios_tbl
[] = {
137 {"Acer", "AOA110", "v0.3109", 0x55, 0x58, {0x1f, 0x00} },
138 {"Acer", "AOA110", "v0.3114", 0x55, 0x58, {0x1f, 0x00} },
139 {"Acer", "AOA110", "v0.3301", 0x55, 0x58, {0xaf, 0x00} },
140 {"Acer", "AOA110", "v0.3304", 0x55, 0x58, {0xaf, 0x00} },
141 {"Acer", "AOA110", "v0.3305", 0x55, 0x58, {0xaf, 0x00} },
142 {"Acer", "AOA110", "v0.3308", 0x55, 0x58, {0x21, 0x00} },
143 {"Acer", "AOA110", "v0.3309", 0x55, 0x58, {0x21, 0x00} },
144 {"Acer", "AOA110", "v0.3310", 0x55, 0x58, {0x21, 0x00} },
146 {"Acer", "AOA150", "v0.3114", 0x55, 0x58, {0x20, 0x00} },
147 {"Acer", "AOA150", "v0.3304", 0x55, 0x58, {0x20, 0x00} },
148 {"Acer", "AOA150", "v0.3305", 0x55, 0x58, {0x20, 0x00} },
149 {"Acer", "AOA150", "v0.3308", 0x55, 0x58, {0x20, 0x00} },
150 {"Acer", "AOA150", "v0.3309", 0x55, 0x58, {0x20, 0x00} },
151 {"Acer", "AOA150", "v0.3310", 0x55, 0x58, {0x20, 0x00} },
152 /* special BIOS / other */
153 {"Gateway", "AOA110", "v0.3103", 0x55, 0x58, {0x21, 0x00} },
154 {"Gateway", "AOA150", "v0.3103", 0x55, 0x58, {0x20, 0x00} },
155 {"Packard Bell", "DOA150", "v0.3104", 0x55, 0x58, {0x21, 0x00} },
156 {"Packard Bell", "AOA110", "v0.3105", 0x55, 0x58, {0x21, 0x00} },
157 /* pewpew-terminator */
158 {"", "", "", 0, 0, {0, 0} }
161 static const struct bios_settings_t
*bios_cfg __read_mostly
;
163 static int acerhdf_get_temp(int *temp
)
167 if (ec_read(bios_cfg
->tempreg
, &read_temp
))
175 static int acerhdf_get_fanstate(int *state
)
179 if (ec_read(bios_cfg
->fanreg
, &fan
))
182 if (fan
!= bios_cfg
->cmd
.cmd_off
)
183 *state
= ACERHDF_FAN_AUTO
;
185 *state
= ACERHDF_FAN_OFF
;
190 static void acerhdf_change_fanstate(int state
)
195 pr_notice("fan %s\n", (state
== ACERHDF_FAN_OFF
) ?
198 if ((state
!= ACERHDF_FAN_OFF
) && (state
!= ACERHDF_FAN_AUTO
)) {
199 pr_err("invalid fan state %d requested, setting to auto!\n",
201 state
= ACERHDF_FAN_AUTO
;
204 cmd
= (state
== ACERHDF_FAN_OFF
) ? bios_cfg
->cmd
.cmd_off
205 : bios_cfg
->cmd
.cmd_auto
;
208 ec_write(bios_cfg
->fanreg
, cmd
);
211 static void acerhdf_check_param(struct thermal_zone_device
*thermal
)
213 if (fanon
> ACERHDF_MAX_FANON
) {
214 pr_err("fanon temperature too high, set to %d\n",
216 fanon
= ACERHDF_MAX_FANON
;
219 if (kernelmode
&& prev_interval
!= interval
) {
220 if (interval
> ACERHDF_MAX_INTERVAL
) {
221 pr_err("interval too high, set to %d\n",
222 ACERHDF_MAX_INTERVAL
);
223 interval
= ACERHDF_MAX_INTERVAL
;
226 pr_notice("interval changed to: %d\n",
228 thermal
->polling_delay
= interval
*1000;
229 prev_interval
= interval
;
234 * This is the thermal zone callback which does the delayed polling of the fan
235 * state. We do check /sysfs-originating settings here in acerhdf_check_param()
236 * as late as the polling interval is since we can't do that in the respective
237 * accessors of the module parameters.
239 static int acerhdf_get_ec_temp(struct thermal_zone_device
*thermal
,
244 acerhdf_check_param(thermal
);
246 err
= acerhdf_get_temp(&temp
);
251 pr_notice("temp %d\n", temp
);
257 static int acerhdf_bind(struct thermal_zone_device
*thermal
,
258 struct thermal_cooling_device
*cdev
)
260 /* if the cooling device is the one from acerhdf bind it */
264 if (thermal_zone_bind_cooling_device(thermal
, 0, cdev
)) {
265 pr_err("error binding cooling dev\n");
271 static int acerhdf_unbind(struct thermal_zone_device
*thermal
,
272 struct thermal_cooling_device
*cdev
)
277 if (thermal_zone_unbind_cooling_device(thermal
, 0, cdev
)) {
278 pr_err("error unbinding cooling dev\n");
284 static inline void acerhdf_revert_to_bios_mode(void)
286 acerhdf_change_fanstate(ACERHDF_FAN_AUTO
);
289 thz_dev
->polling_delay
= 0;
290 pr_notice("kernel mode fan control OFF\n");
292 static inline void acerhdf_enable_kernelmode(void)
296 thz_dev
->polling_delay
= interval
*1000;
297 thermal_zone_device_update(thz_dev
);
298 pr_notice("kernel mode fan control ON\n");
301 static int acerhdf_get_mode(struct thermal_zone_device
*thermal
,
302 enum thermal_device_mode
*mode
)
305 pr_notice("kernel mode fan control %d\n", kernelmode
);
307 *mode
= (kernelmode
) ? THERMAL_DEVICE_ENABLED
308 : THERMAL_DEVICE_DISABLED
;
314 * set operation mode;
315 * enabled: the thermal layer of the kernel takes care about
316 * the temperature and the fan.
317 * disabled: the BIOS takes control of the fan.
319 static int acerhdf_set_mode(struct thermal_zone_device
*thermal
,
320 enum thermal_device_mode mode
)
322 if (mode
== THERMAL_DEVICE_DISABLED
&& kernelmode
)
323 acerhdf_revert_to_bios_mode();
324 else if (mode
== THERMAL_DEVICE_ENABLED
&& !kernelmode
)
325 acerhdf_enable_kernelmode();
330 static int acerhdf_get_trip_type(struct thermal_zone_device
*thermal
, int trip
,
331 enum thermal_trip_type
*type
)
334 *type
= THERMAL_TRIP_ACTIVE
;
339 static int acerhdf_get_trip_temp(struct thermal_zone_device
*thermal
, int trip
,
348 static int acerhdf_get_crit_temp(struct thermal_zone_device
*thermal
,
349 unsigned long *temperature
)
351 *temperature
= ACERHDF_TEMP_CRIT
;
355 /* bind callback functions to thermalzone */
356 struct thermal_zone_device_ops acerhdf_dev_ops
= {
357 .bind
= acerhdf_bind
,
358 .unbind
= acerhdf_unbind
,
359 .get_temp
= acerhdf_get_ec_temp
,
360 .get_mode
= acerhdf_get_mode
,
361 .set_mode
= acerhdf_set_mode
,
362 .get_trip_type
= acerhdf_get_trip_type
,
363 .get_trip_temp
= acerhdf_get_trip_temp
,
364 .get_crit_temp
= acerhdf_get_crit_temp
,
369 * cooling device callback functions
370 * get maximal fan cooling state
372 static int acerhdf_get_max_state(struct thermal_cooling_device
*cdev
,
373 unsigned long *state
)
380 static int acerhdf_get_cur_state(struct thermal_cooling_device
*cdev
,
381 unsigned long *state
)
385 err
= acerhdf_get_fanstate(&tmp
);
389 *state
= (tmp
== ACERHDF_FAN_AUTO
) ? 1 : 0;
393 /* change current fan state - is overwritten when running in kernel mode */
394 static int acerhdf_set_cur_state(struct thermal_cooling_device
*cdev
,
397 int cur_temp
, cur_state
, err
= 0;
402 err
= acerhdf_get_temp(&cur_temp
);
404 pr_err("error reading temperature, hand off control to BIOS\n");
408 err
= acerhdf_get_fanstate(&cur_state
);
410 pr_err("error reading fan state, hand off control to BIOS\n");
415 /* turn fan off only if below fanoff temperature */
416 if ((cur_state
== ACERHDF_FAN_AUTO
) &&
418 acerhdf_change_fanstate(ACERHDF_FAN_OFF
);
420 if (cur_state
== ACERHDF_FAN_OFF
)
421 acerhdf_change_fanstate(ACERHDF_FAN_AUTO
);
426 acerhdf_revert_to_bios_mode();
430 /* bind fan callbacks to fan device */
431 struct thermal_cooling_device_ops acerhdf_cooling_ops
= {
432 .get_max_state
= acerhdf_get_max_state
,
433 .get_cur_state
= acerhdf_get_cur_state
,
434 .set_cur_state
= acerhdf_set_cur_state
,
437 /* suspend / resume functionality */
438 static int acerhdf_suspend(struct device
*dev
)
441 acerhdf_change_fanstate(ACERHDF_FAN_AUTO
);
444 pr_notice("going suspend\n");
449 static int __devinit
acerhdf_probe(struct platform_device
*device
)
454 static int acerhdf_remove(struct platform_device
*device
)
459 static struct dev_pm_ops acerhdf_pm_ops
= {
460 .suspend
= acerhdf_suspend
,
461 .freeze
= acerhdf_suspend
,
464 static struct platform_driver acerhdf_driver
= {
467 .owner
= THIS_MODULE
,
468 .pm
= &acerhdf_pm_ops
,
470 .probe
= acerhdf_probe
,
471 .remove
= acerhdf_remove
,
476 static int acerhdf_check_hardware(void)
478 char const *vendor
, *version
, *product
;
480 unsigned long prod_len
= 0;
483 vendor
= dmi_get_system_info(DMI_SYS_VENDOR
);
484 version
= dmi_get_system_info(DMI_BIOS_VERSION
);
485 product
= dmi_get_system_info(DMI_PRODUCT_NAME
);
488 pr_info("Acer Aspire One Fan driver, v.%s\n", DRV_VER
);
491 version
= force_bios
;
492 pr_info("forcing BIOS version: %s\n", version
);
496 if (force_product
[0]) {
497 product
= force_product
;
498 pr_info("forcing BIOS product: %s\n", product
);
502 prod_len
= strlen(product
);
505 pr_info("BIOS info: %s %s, product: %s\n",
506 vendor
, version
, product
);
508 /* search BIOS version and vendor in BIOS settings table */
509 for (i
= 0; bios_tbl
[i
].version
[0]; i
++) {
510 if (strlen(bios_tbl
[i
].product
) >= prod_len
&&
511 !strncmp(bios_tbl
[i
].product
, product
,
512 strlen(bios_tbl
[i
].product
)) &&
513 !strcmp(bios_tbl
[i
].vendor
, vendor
) &&
514 !strcmp(bios_tbl
[i
].version
, version
)) {
515 bios_cfg
= &bios_tbl
[i
];
521 pr_err("unknown (unsupported) BIOS version %s/%s/%s, "
522 "please report, aborting!\n", vendor
, product
, version
);
527 * if started with kernel mode off, prevent the kernel from switching
531 pr_notice("Fan control off, to enable do:\n");
532 pr_notice("echo -n \"enabled\" > "
533 "/sys/class/thermal/thermal_zone0/mode\n");
539 static int acerhdf_register_platform(void)
543 err
= platform_driver_register(&acerhdf_driver
);
547 acerhdf_dev
= platform_device_alloc("acerhdf", -1);
548 platform_device_add(acerhdf_dev
);
553 static void acerhdf_unregister_platform(void)
558 platform_device_del(acerhdf_dev
);
559 platform_driver_unregister(&acerhdf_driver
);
562 static int acerhdf_register_thermal(void)
564 cl_dev
= thermal_cooling_device_register("acerhdf-fan", NULL
,
565 &acerhdf_cooling_ops
);
570 thz_dev
= thermal_zone_device_register("acerhdf", 1, NULL
,
571 &acerhdf_dev_ops
, 0, 0, 0,
572 (kernelmode
) ? interval
*1000 : 0);
579 static void acerhdf_unregister_thermal(void)
582 thermal_cooling_device_unregister(cl_dev
);
587 thermal_zone_device_unregister(thz_dev
);
592 static int __init
acerhdf_init(void)
596 err
= acerhdf_check_hardware();
600 err
= acerhdf_register_platform();
604 err
= acerhdf_register_thermal();
611 acerhdf_unregister_thermal();
612 acerhdf_unregister_platform();
618 static void __exit
acerhdf_exit(void)
620 acerhdf_change_fanstate(ACERHDF_FAN_AUTO
);
621 acerhdf_unregister_thermal();
622 acerhdf_unregister_platform();
625 MODULE_LICENSE("GPL");
626 MODULE_AUTHOR("Peter Feuerer");
627 MODULE_DESCRIPTION("Aspire One temperature and fan driver");
628 MODULE_ALIAS("dmi:*:*Acer*:*:");
629 MODULE_ALIAS("dmi:*:*Gateway*:*:");
630 MODULE_ALIAS("dmi:*:*Packard Bell*:*:");
632 module_init(acerhdf_init
);
633 module_exit(acerhdf_exit
);