diff -Naur linux-2.6.28_original/drivers/misc/Kconfig linux-2.6.28_foo/drivers/misc/Kconfig --- linux-2.6.28_original/drivers/misc/Kconfig 2008-12-25 00:26:37.000000000 +0100 +++ linux-2.6.28_foo/drivers/misc/Kconfig 2009-02-24 23:36:34.000000000 +0100 @@ -158,6 +158,16 @@ If you have an ACPI-WMI compatible Acer/ Wistron laptop, say Y or M here. +config ACERHDF + tristate "Acer Aspire One Fan Control (EXPERIMENTAL)" + depends on X86 + depends on EXPERIMENTAL + depends on ACPI_THERMAL + depends on ACPI + depends on SERIO_I8042 + ---help--- + This is the driver for controlling the fan of Acer Aspire One netbooks + config ASUS_LAPTOP tristate "Asus Laptop Extras (EXPERIMENTAL)" depends on X86 diff -Naur linux-2.6.28_original/drivers/misc/Makefile linux-2.6.28_foo/drivers/misc/Makefile --- linux-2.6.28_original/drivers/misc/Makefile 2008-12-25 00:26:37.000000000 +0100 +++ linux-2.6.28_foo/drivers/misc/Makefile 2009-02-19 22:57:16.000000000 +0100 @@ -10,6 +10,7 @@ obj-$(CONFIG_MSI_LAPTOP) += msi-laptop.o obj-$(CONFIG_COMPAL_LAPTOP) += compal-laptop.o obj-$(CONFIG_ACER_WMI) += acer-wmi.o +obj-$(CONFIG_ACERHDF) += acerhdf.o obj-$(CONFIG_ATMEL_PWM) += atmel_pwm.o obj-$(CONFIG_ATMEL_SSC) += atmel-ssc.o obj-$(CONFIG_ATMEL_TCLIB) += atmel_tclib.o diff -Naur linux-2.6.28_original/drivers/misc/acerhdf.c linux-2.6.28_foo/drivers/misc/acerhdf.c --- linux-2.6.28_original/drivers/misc/acerhdf.c 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.28_foo/drivers/misc/acerhdf.c 2009-02-24 23:35:02.000000000 +0100 @@ -0,0 +1,555 @@ +/* + * acerhdf - A kernelmodule which monitors the temperature + * of the aspire one netbook, turns on/off the fan + * as soon as the upper/lower threshold is reached. + * + * (C) 2009 - Peter Feuerer peter (a) piie.net + * http://piie.net + * + * + * + * Inspired by and many thanks to: + * o acerfand - Rachel Greenham + * o acer_ec.pl - Michael Kurz michi.kurz (at) googlemail.com + * - Petr Tomasek tomasek (#) etf,cuni,cz + * - Carlos Corbacho cathectic (at) gmail.com + * + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * 06-February-2009: Version 0.1: + * - first relase, containing absolutely no bugs! ;) + * + * 06-February-2009: Version 0.1.1: + * - found first bug :-) - it didn't check the bios vendor + * - check if the bios vendor is Acer + * - added bios 3301 + * + * 06-February-2009: Version 0.1.2: + * - added fork for deamon mode, now a real daemon is spawned + * - added device vendor "INSYDE" + * + * 13-February-2009: Version 0.2: + * - ported to kernelspace + * + * 19-February-2009: Version 0.2.1: + * - added Bios Version 3308 + * - cleaned up the includes + * + * 21-February-2009: Version 0.2.2: + * - changed settings for Bios 3309 as old settings caused lock ups + * - thanks to Frank Reimann + * + * 21-February-2009: Version 0.2.2-2: + * - added linux/sched.h to includes again, as it won't compile for + * kernel < 2.6.28 without it. + * + * 23-February-20009: Version 0.3: + * - tied to termal layer + * - added parameters to /sys/modules/acerhdf/parameters/ + * + */ + +#include +#include +#include +#include +#include +#include +#include + +#define VERSION "0.3" + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Peter Feuerer"); + +/* thread handling variables */ +static int thread_id=0; +static struct pid * thread_pid=NULL; +static wait_queue_head_t wq; +static DECLARE_COMPLETION( on_exit ); + +/* global variables */ +static int interval=10; +static int fanon=67; +static int fanoff=62; +static int verbose=0; +static int kernelmode=1; +static int fanstate=1; +static int bios_version=-1; +static char force_bios[16]; +struct thermal_zone_device * acerhdf_thz_dev; +struct thermal_cooling_device * acerhdf_cool_dev; + +/* module parameters */ +module_param(interval, int, 0600); +MODULE_PARM_DESC(interval, "Polling interval of temperatur check"); +module_param(fanon, int, 0600); +MODULE_PARM_DESC(fanon, "Above which temperature should the fan be started"); +module_param(fanoff, int, 0600); +MODULE_PARM_DESC(fanoff, "Below which temperature should the fan be stopped"); +module_param(verbose, int, 0600); +MODULE_PARM_DESC(verbose, "Enable verbose dmesg outputs"); +module_param_string(force_bios,force_bios,16,0); +MODULE_PARM_DESC(force_bios, "Force bios version and omit bios check"); + +/* bios settings */ +/**********************************************************************/ +typedef struct +{ + char version[10]; + unsigned char fanreg; + unsigned char tempreg; + unsigned char cmd_off; + unsigned char cmd_auto; + unsigned char state_off; +} bios_settings_t; + +/* some bios versions have different commands and + * maybe also different register addresses */ +static bios_settings_t bios_settings[]= +{ + {"v0.3109",0x55,0x58,0x1f,0x00,0x1f}, + {"v0.3114",0x55,0x58,0x1f,0x00,0x1f}, + {"v0.3301",0x55,0x58,0xaf,0x00,0xaf}, + {"v0.3304",0x55,0x58,0xaf,0x00,0xaf}, + {"v0.3305",0x55,0x58,0xaf,0x00,0xaf}, + {"v0.3308",0x55,0x58,0xaf,0x00,0xaf}, + {"v0.3309",0x55,0x58,0x21,0x00,0x21}, + {"",0,0,0,0,0} +}; + + +/* acer ec functions */ +/**********************************************************************/ +/* switch on/off the fan */ +static void change_fanstate(int state) +{ + if(verbose) + { + printk("acerhdf: fan %s\n",state?"ON":"OFF"); + } + ec_write(bios_settings[bios_version].fanreg, + state? bios_settings[bios_version].cmd_auto: + bios_settings[bios_version].cmd_off); +} + +/* thread to monitor the temperature and control the fan */ +static int acerhdf_thread( void *data ) +{ + unsigned long timeout; + u8 temp=0; + u8 last_temp=0; + int unchanged_cnt=0; + + fanstate=1; + daemonize("acerhdf"); + allow_signal( SIGTERM ); + thread_pid=task_pid(current); + for(;;) + { + if(!ec_read(bios_settings[bios_version].tempreg,&temp)) + { + /* print temperature in verbose mode */ + if(verbose) + { + printk("acerhdf: Temperature is: %d\n",temp); + } + /* if temperature is greater than fanon, switch on fan */ + if(temp>=fanon && fanstate==0) + { + change_fanstate(1); + fanstate=1; + } + /* if temperature is less than fanoff, switch off fan */ + else if(temp= 10) + { + printk("acerhdf: cannot read temperature, switching to user mode\n"); + kernelmode=0; + break; + } + } + else + { + unchanged_cnt=0; + } + last_temp=temp; + } + /* turn on fan before ending the thread */ + change_fanstate(1); + thread_id = 0; + complete_and_exit( &on_exit, 0 ); +} + +/* thermal zone callback functions */ +/**********************************************************************/ +static int get_ec_temp(struct thermal_zone_device *thermal, char *buf) +{ + u8 temp; + /* return temperature */ + if(!ec_read(bios_settings[bios_version].tempreg,&temp)) + { + return sprintf(buf,"%d\n",temp); + } + return -EINVAL; +} + +/* bind the cooling device to the thermal zone */ +static int bind(struct thermal_zone_device *thermal, + struct thermal_cooling_device *cdev) +{ + /* if the cooling device is the one from acerhdf bind it */ + if(cdev==acerhdf_cool_dev) + { + if(thermal_zone_bind_cooling_device(thermal,0,cdev)) + { + printk("acerhdf: error binding cooling dev to trip 0\n"); + return -EINVAL; + } + if(thermal_zone_bind_cooling_device(thermal,1,cdev)) + { + printk("acerhdf: error binding cooling dev to trip 1\n"); + return -EINVAL; + } + } + return 0; +} + +/* unbind cooling device from thermal zone */ +static int unbind(struct thermal_zone_device *thermal, + struct thermal_cooling_device *cdev) +{ + if(cdev==acerhdf_cool_dev) + { + if(thermal_zone_unbind_cooling_device(thermal,0,cdev)) + { + printk("acerhdf: error unbinding cooling dev of trip 0\n"); + return -EINVAL; + } + if(thermal_zone_unbind_cooling_device(thermal,1,cdev)) + { + printk("acerhdf: error unbinding cooling dev of trip 1\n"); + return -EINVAL; + } + } + return 0; +} + +/* print currend operation mode - kernel / user */ +static int get_mode(struct thermal_zone_device *thermal, + char *buf) +{ + if(!kernelmode) + { + return sprintf(buf,"user\n"); + } + else + { + return sprintf(buf,"kernel\n"); + } + return 0; +} + +/* set operation mode; + * kernel: a kernel thread takes care about managing the + * fan (see acerhdf_thread) + * user: kernel thread is stopped and a userspace tool + * should take care about managing the fan + */ +static int set_mode(struct thermal_zone_device *thermal, + const char *buf) +{ + /* set mode to user mode */ + if(!strncmp(buf,"user",4)) + { + if(verbose) + { + printk("acerhdf: set to usermode\n"); + } + /* send SIGTERM to thread and wait until thread died */ + if(thread_pid) + { + kill_pid(thread_pid,SIGTERM,1); + } + wait_for_completion( &on_exit ); + kernelmode=0; + return 0; + } + /* set to kernel mode */ + else if(!strncmp(buf,"kernel",6)) + { + /* start acerhdf_thread */ + if(!kernelmode && !thread_id) + { + thread_id=kernel_thread(acerhdf_thread, NULL, CLONE_KERNEL ); + if( thread_id==0 ) + { + return -EIO; + } + } + if(verbose) + { + printk("acerhdf: set to kernelmode\n"); + } + kernelmode=1; + return 0; + } + return -EINVAL; +} + +/* print the name of the trip point */ +static int get_trip_type(struct thermal_zone_device *thermal, + int trip, char *buf) +{ + if(trip==0) + { + return sprintf(buf,"fanoff\n"); + } + else if(trip==1) + { + return sprintf(buf,"fanon\n"); + } + return 0; +} + +/* print the temperature at which the trip point gets active */ +static int get_trip_temp(struct thermal_zone_device *thermal, + int trip, char *buf) +{ + if(trip==0) + { + return sprintf(buf,"%d\n",fanoff); + } + else if(trip==1) + { + return sprintf(buf,"%d\n",fanon); + } + return 0; +} + +static int get_crit_temp(struct thermal_zone_device *thermal, + unsigned long *temperature) +{ + return 0; +} + +/* bind callback functions to thermalzone */ +struct thermal_zone_device_ops acerhdf_device_ops = +{ + .bind = bind, + .unbind=unbind, + .get_temp=get_ec_temp, + .get_mode = get_mode, + .set_mode = set_mode, + .get_trip_type = get_trip_type, + .get_trip_temp = get_trip_temp, + .get_crit_temp = get_crit_temp, +}; + + +/* cooling device callback functions */ +/**********************************************************************/ +/* print maximal fan cooling state */ +static int get_max_state(struct thermal_cooling_device *cdev, char *buf) +{ + return sprintf(buf,"1\n"); +} + +/* print current fan state */ +static int get_cur_state(struct thermal_cooling_device *cdev, char *buf) +{ + u8 fan; + if(!ec_read(bios_settings[bios_version].fanreg,&fan)) + { + return sprintf(buf,"%d\n", + (fan==bios_settings[bios_version].cmd_auto)?1:0); + } + return 0; +} + +/* change current fan state - is overwritten when running in kernel mode */ +static int set_cur_state(struct thermal_cooling_device *cdev, + unsigned int state) +{ + if(kernelmode) + { + printk("acerhdf: changing the fanstate in kernelmode is not allowed\n"); + return -EINVAL; + } + if(verbose) + { + printk("acerhdf: set fan: %d\n",state); + } + change_fanstate(state); + return 0; +} + +/* bind fan callbacks to fan device */ +struct thermal_cooling_device_ops acerhdf_cooling_ops = +{ + .get_max_state=get_max_state, + .get_cur_state=get_cur_state, + .set_cur_state=set_cur_state, +}; + + +/* kernel module init / exit functions */ +/**********************************************************************/ +/* initialize the module */ +static int __init acerhdf_init(void) +{ + char const *vendor; + char const *version; + char const *release; + char const *product; + int i; + + + /* get bios data */ + vendor=dmi_get_system_info(DMI_SYS_VENDOR); + version=dmi_get_system_info(DMI_BIOS_VERSION); + release=dmi_get_system_info(DMI_BIOS_DATE); + product=dmi_get_system_info(DMI_PRODUCT_NAME); + + + /* print out bios data */ + printk("acerhdf: version: %s compiledate: %s %s\n", + VERSION,__DATE__,__TIME__); + printk("acerhdf: biosvendor:%s\n",vendor); + printk("acerhdf: biosversion:%s\n",version); + printk("acerhdf: biosrelease:%s\n",release); + printk("acerhdf: biosproduct:%s\n",product); + + if(!force_bios[0]) + { + + /* check if vendor of the hardware is Acer */ + if(strcmp(vendor,"Acer")) + { + printk("acerhdf: no Acer hardware found\n"); + return -ENODEV; + } + /* check if product is a AO - Aspire One */ + if(strncmp(product,"AO",2)) + { + printk("acerhdf: no Aspire One hardware found\n"); + return -ENODEV; + } + } + else + { + printk("acerhdf: bios version: %s forced, kernelmode disabled\n",version); + printk("acerhdf: to enable kernelmode:\n"); + printk("acerhdf: echo kernel > /sys/class/thermal/thermal_zone0/mode\n"); + printk("\n"); + printk("acerhdf: please ensure the bios setting is working correctly,\n"); + printk("acerhdf: before enabling kernel mode - read README.txt!!\n"); + version=force_bios; + kernelmode=0; + } + + /* search bios in bios settings table */ + for(i=0;bios_settings[i].version[0];++i) + { + if(!strcmp(bios_settings[i].version,version)) + { + bios_version=i; + break; + } + } + if(bios_version==-1) + { + printk("acerhdf: cannot find bios version\n"); + return -ENODEV; + } + + /* create cooling device */ + acerhdf_cool_dev=thermal_cooling_device_register("acerhdf-fan",NULL, + &acerhdf_cooling_ops); + if(IS_ERR(acerhdf_cool_dev)) + { + return -ENODEV; + } + + /* create thermal zone */ + acerhdf_thz_dev=thermal_zone_device_register("acerhdf",2, + NULL,&acerhdf_device_ops); + if(IS_ERR(acerhdf_thz_dev)) + { + return -ENODEV; + } + + init_waitqueue_head(&wq); + /* start acerhdf_thread */ + thread_id=kernel_thread(acerhdf_thread, NULL, CLONE_KERNEL ); + if( thread_id==0 ) + { + return -EIO; + } + + return 0; +} + +/* exit the module */ +static void __exit acerhdf_exit(void) +{ + /* unregister thermal zone */ + if(acerhdf_thz_dev) + { + thermal_zone_device_unregister(acerhdf_thz_dev); + acerhdf_thz_dev=NULL; + } + /* unregister cooling device */ + if(acerhdf_cool_dev) + { + thermal_cooling_device_unregister(acerhdf_cool_dev); + acerhdf_cool_dev=NULL; + } + /* send SIGTERM to thread */ + if(thread_pid) + { + kill_pid(thread_pid,SIGTERM,1); + } + wait_for_completion( &on_exit ); +} + +/* what are the module init/exit functions */ +module_init( acerhdf_init ); +module_exit( acerhdf_exit );