[deliverable/linux.git] / drivers / platform / x86 / acerhdf.c

/*
 * acerhdf - A driver 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
 *     2009 Borislav Petkov <petkovbb@gmail.com>
 *
 * 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
 *  o lkml       - Matthew Garrett
 *               - Borislav Petkov
 *               - Andreas Mohr
 *
 *  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
 */

#define pr_fmt(fmt) "acerhdf: " fmt

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/dmi.h>
#include <acpi/acpi_drivers.h>
#include <linux/sched.h>
#include <linux/thermal.h>
#include <linux/platform_device.h>

/*
 * The driver is started with "kernel mode off" by default. That means, the BIOS
 * is still in control of the fan. In this mode the driver allows to read the
 * temperature of the cpu and a userspace tool may take over control of the fan.
 * If the driver is switched to "kernel mode" (e.g. via module parameter) the
 * driver is in full control of the fan. If you want the module to be started in
 * kernel mode by default, define the following:
 */
#undef START_IN_KERNEL_MODE

#define DRV_VER "0.5.23"

/*
 * According to the Atom N270 datasheet,
 * (http://download.intel.com/design/processor/datashts/320032.pdf) the
 * CPU's optimal operating limits denoted in junction temperature as
 * measured by the on-die thermal monitor are within 0 <= Tj <= 90. So,
 * assume 89°C is critical temperature.
 */
#define ACERHDF_TEMP_CRIT 89000
#define ACERHDF_FAN_OFF 0
#define ACERHDF_FAN_AUTO 1

/*
 * No matter what value the user puts into the fanon variable, turn on the fan
 * at 80 degree Celsius to prevent hardware damage
 */
#define ACERHDF_MAX_FANON 80000

/*
 * Maximum interval between two temperature checks is 15 seconds, as the die
 * can get hot really fast under heavy load (plus we shouldn't forget about
 * possible impact of _external_ aggressive sources such as heaters, sun etc.)
 */
#define ACERHDF_MAX_INTERVAL 15

#ifdef START_IN_KERNEL_MODE
static int kernelmode = 1;
#else
static int kernelmode;
#endif

static unsigned int interval = 10;
static unsigned int fanon = 63000;
static unsigned int fanoff = 58000;
static unsigned int verbose;
static unsigned int fanstate = ACERHDF_FAN_AUTO;
static char force_bios[16];
static char force_product[16];
static unsigned int prev_interval;
struct thermal_zone_device *thz_dev;
struct thermal_cooling_device *cl_dev;
struct platform_device *acerhdf_dev;

module_param(kernelmode, uint, 0);
MODULE_PARM_DESC(kernelmode, "Kernel mode fan control on / off");
module_param(interval, uint, 0600);
MODULE_PARM_DESC(interval, "Polling interval of temperature check");
module_param(fanon, uint, 0600);
MODULE_PARM_DESC(fanon, "Turn the fan on above this temperature");
module_param(fanoff, uint, 0600);
MODULE_PARM_DESC(fanoff, "Turn the fan off below this temperature");
module_param(verbose, uint, 0600);
MODULE_PARM_DESC(verbose, "Enable verbose dmesg output");
module_param_string(force_bios, force_bios, 16, 0);
MODULE_PARM_DESC(force_bios, "Force BIOS version and omit BIOS check");
module_param_string(force_product, force_product, 16, 0);
MODULE_PARM_DESC(force_product, "Force BIOS product and omit BIOS check");

/*
 * cmd_off: to switch the fan completely off and check if the fan is off
 *	cmd_auto: to set the BIOS in control of the fan. The BIOS regulates then
 *		the fan speed depending on the temperature
 */
struct fancmd {
	u8 cmd_off;
	u8 cmd_auto;
};

/* BIOS settings */
struct bios_settings_t {
	const char *vendor;
	const char *product;
	const char *version;
	unsigned char fanreg;
	unsigned char tempreg;
	struct fancmd cmd;
};

/* Register addresses and values for different BIOS versions */
static const struct bios_settings_t bios_tbl[] = {
	/* AOA110 */
	{"Acer", "AOA110", "v0.3109", 0x55, 0x58, {0x1f, 0x00} },
	{"Acer", "AOA110", "v0.3114", 0x55, 0x58, {0x1f, 0x00} },
	{"Acer", "AOA110", "v0.3301", 0x55, 0x58, {0xaf, 0x00} },
	{"Acer", "AOA110", "v0.3304", 0x55, 0x58, {0xaf, 0x00} },
	{"Acer", "AOA110", "v0.3305", 0x55, 0x58, {0xaf, 0x00} },
	{"Acer", "AOA110", "v0.3307", 0x55, 0x58, {0xaf, 0x00} },
	{"Acer", "AOA110", "v0.3308", 0x55, 0x58, {0x21, 0x00} },
	{"Acer", "AOA110", "v0.3309", 0x55, 0x58, {0x21, 0x00} },
	{"Acer", "AOA110", "v0.3310", 0x55, 0x58, {0x21, 0x00} },
	/* AOA150 */
	{"Acer", "AOA150", "v0.3114", 0x55, 0x58, {0x1f, 0x00} },
	{"Acer", "AOA150", "v0.3301", 0x55, 0x58, {0x20, 0x00} },
	{"Acer", "AOA150", "v0.3304", 0x55, 0x58, {0x20, 0x00} },
	{"Acer", "AOA150", "v0.3305", 0x55, 0x58, {0x20, 0x00} },
	{"Acer", "AOA150", "v0.3307", 0x55, 0x58, {0x20, 0x00} },
	{"Acer", "AOA150", "v0.3308", 0x55, 0x58, {0x20, 0x00} },
	{"Acer", "AOA150", "v0.3309", 0x55, 0x58, {0x20, 0x00} },
	{"Acer", "AOA150", "v0.3310", 0x55, 0x58, {0x20, 0x00} },
	/* Acer 1410 */
	{"Acer", "Aspire 1410", "v0.3115", 0x55, 0x58, {0x9e, 0x00} },
	{"Acer", "Aspire 1410", "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
	{"Acer", "Aspire 1410", "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
	/* Acer 1810xx */
	{"Acer", "Aspire 1810TZ", "v0.3115", 0x55, 0x58, {0x9e, 0x00} },
	{"Acer", "Aspire 1810T",  "v0.3115", 0x55, 0x58, {0x9e, 0x00} },
	{"Acer", "Aspire 1810TZ", "v0.3119", 0x55, 0x58, {0x9e, 0x00} },
	{"Acer", "Aspire 1810T",  "v0.3119", 0x55, 0x58, {0x9e, 0x00} },
	{"Acer", "Aspire 1810TZ", "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
	{"Acer", "Aspire 1810T",  "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
	{"Acer", "Aspire 1810TZ", "v1.3204", 0x55, 0x58, {0x9e, 0x00} },
	{"Acer", "Aspire 1810T",  "v1.3204", 0x55, 0x58, {0x9e, 0x00} },
	{"Acer", "Aspire 1810TZ", "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
	{"Acer", "Aspire 1810T",  "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
	/* Gateway */
	{"Gateway", "AOA110", "v0.3103", 0x55, 0x58, {0x21, 0x00} },
	{"Gateway", "AOA150", "v0.3103", 0x55, 0x58, {0x20, 0x00} },
	{"Gateway", "LT31",   "v1.3103", 0x55, 0x58, {0x9e, 0x00} },
	{"Gateway", "LT31",   "v1.3201", 0x55, 0x58, {0x9e, 0x00} },
	{"Gateway", "LT31",   "v1.3302", 0x55, 0x58, {0x9e, 0x00} },
	/* Packard Bell */
	{"Packard Bell", "DOA150", "v0.3104", 0x55, 0x58, {0x21, 0x00} },
	{"Packard Bell", "DOA150", "v0.3105", 0x55, 0x58, {0x20, 0x00} },
	{"Packard Bell", "AOA110", "v0.3105", 0x55, 0x58, {0x21, 0x00} },
	{"Packard Bell", "AOA150", "v0.3105", 0x55, 0x58, {0x20, 0x00} },
	{"Packard Bell", "DOTMU",  "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
	{"Packard Bell", "DOTMU",  "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
	{"Packard Bell", "DOTMA",  "v1.3201", 0x55, 0x58, {0x9e, 0x00} },
	/* pewpew-terminator */
	{"", "", "", 0, 0, {0, 0} }
};

static const struct bios_settings_t *bios_cfg __read_mostly;

static int acerhdf_get_temp(int *temp)
{
	u8 read_temp;

	if (ec_read(bios_cfg->tempreg, &read_temp))
		return -EINVAL;

	*temp = read_temp * 1000;

	return 0;
}

static int acerhdf_get_fanstate(int *state)
{
	u8 fan;

	if (ec_read(bios_cfg->fanreg, &fan))
		return -EINVAL;

	if (fan != bios_cfg->cmd.cmd_off)
		*state = ACERHDF_FAN_AUTO;
	else
		*state = ACERHDF_FAN_OFF;

	return 0;
}

static void acerhdf_change_fanstate(int state)
{
	unsigned char cmd;

	if (verbose)
		pr_notice("fan %s\n", (state == ACERHDF_FAN_OFF) ?
				"OFF" : "ON");

	if ((state != ACERHDF_FAN_OFF) && (state != ACERHDF_FAN_AUTO)) {
		pr_err("invalid fan state %d requested, setting to auto!\n",
			state);
		state = ACERHDF_FAN_AUTO;
	}

	cmd = (state == ACERHDF_FAN_OFF) ? bios_cfg->cmd.cmd_off
					 : bios_cfg->cmd.cmd_auto;
	fanstate = state;

	ec_write(bios_cfg->fanreg, cmd);
}

static void acerhdf_check_param(struct thermal_zone_device *thermal)
{
	if (fanon > ACERHDF_MAX_FANON) {
		pr_err("fanon temperature too high, set to %d\n",
				ACERHDF_MAX_FANON);
		fanon = ACERHDF_MAX_FANON;
	}

	if (kernelmode && prev_interval != interval) {
		if (interval > ACERHDF_MAX_INTERVAL) {
			pr_err("interval too high, set to %d\n",
				ACERHDF_MAX_INTERVAL);
			interval = ACERHDF_MAX_INTERVAL;
		}
		if (verbose)
			pr_notice("interval changed to: %d\n",
					interval);
		thermal->polling_delay = interval*1000;
		prev_interval = interval;
	}
}

/*
 * This is the thermal zone callback which does the delayed polling of the fan
 * state. We do check /sysfs-originating settings here in acerhdf_check_param()
 * as late as the polling interval is since we can't do that in the respective
 * accessors of the module parameters.
 */
static int acerhdf_get_ec_temp(struct thermal_zone_device *thermal,
			       unsigned long *t)
{
	int temp, err = 0;

	acerhdf_check_param(thermal);

	err = acerhdf_get_temp(&temp);
	if (err)
		return err;

	if (verbose)
		pr_notice("temp %d\n", temp);

	*t = temp;
	return 0;
}

static int acerhdf_bind(struct thermal_zone_device *thermal,
			struct thermal_cooling_device *cdev)
{
	/* if the cooling device is the one from acerhdf bind it */
	if (cdev != cl_dev)
		return 0;

	if (thermal_zone_bind_cooling_device(thermal, 0, cdev)) {
		pr_err("error binding cooling dev\n");
		return -EINVAL;
	}
	return 0;
}

static int acerhdf_unbind(struct thermal_zone_device *thermal,
			  struct thermal_cooling_device *cdev)
{
	if (cdev != cl_dev)
		return 0;

	if (thermal_zone_unbind_cooling_device(thermal, 0, cdev)) {
		pr_err("error unbinding cooling dev\n");
		return -EINVAL;
	}
	return 0;
}

static inline void acerhdf_revert_to_bios_mode(void)
{
	acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
	kernelmode = 0;
	if (thz_dev)
		thz_dev->polling_delay = 0;
	pr_notice("kernel mode fan control OFF\n");
}
static inline void acerhdf_enable_kernelmode(void)
{
	kernelmode = 1;

	thz_dev->polling_delay = interval*1000;
	thermal_zone_device_update(thz_dev);
	pr_notice("kernel mode fan control ON\n");
}

static int acerhdf_get_mode(struct thermal_zone_device *thermal,
			    enum thermal_device_mode *mode)
{
	if (verbose)
		pr_notice("kernel mode fan control %d\n", kernelmode);

	*mode = (kernelmode) ? THERMAL_DEVICE_ENABLED
			     : THERMAL_DEVICE_DISABLED;

	return 0;
}

/*
 * set operation mode;
 * enabled: the thermal layer of the kernel takes care about
 *          the temperature and the fan.
 * disabled: the BIOS takes control of the fan.
 */
static int acerhdf_set_mode(struct thermal_zone_device *thermal,
			    enum thermal_device_mode mode)
{
	if (mode == THERMAL_DEVICE_DISABLED && kernelmode)
		acerhdf_revert_to_bios_mode();
	else if (mode == THERMAL_DEVICE_ENABLED && !kernelmode)
		acerhdf_enable_kernelmode();

	return 0;
}

static int acerhdf_get_trip_type(struct thermal_zone_device *thermal, int trip,
				 enum thermal_trip_type *type)
{
	if (trip == 0)
		*type = THERMAL_TRIP_ACTIVE;

	return 0;
}

static int acerhdf_get_trip_temp(struct thermal_zone_device *thermal, int trip,
				 unsigned long *temp)
{
	if (trip == 0)
		*temp = fanon;

	return 0;
}

static int acerhdf_get_crit_temp(struct thermal_zone_device *thermal,
				 unsigned long *temperature)
{
	*temperature = ACERHDF_TEMP_CRIT;
	return 0;
}

/* bind callback functions to thermalzone */
struct thermal_zone_device_ops acerhdf_dev_ops = {
	.bind = acerhdf_bind,
	.unbind = acerhdf_unbind,
	.get_temp = acerhdf_get_ec_temp,
	.get_mode = acerhdf_get_mode,
	.set_mode = acerhdf_set_mode,
	.get_trip_type = acerhdf_get_trip_type,
	.get_trip_temp = acerhdf_get_trip_temp,
	.get_crit_temp = acerhdf_get_crit_temp,
};


/*
 * cooling device callback functions
 * get maximal fan cooling state
 */
static int acerhdf_get_max_state(struct thermal_cooling_device *cdev,
				 unsigned long *state)
{
	*state = 1;

	return 0;
}

static int acerhdf_get_cur_state(struct thermal_cooling_device *cdev,
				 unsigned long *state)
{
	int err = 0, tmp;

	err = acerhdf_get_fanstate(&tmp);
	if (err)
		return err;

	*state = (tmp == ACERHDF_FAN_AUTO) ? 1 : 0;
	return 0;
}

/* change current fan state - is overwritten when running in kernel mode */
static int acerhdf_set_cur_state(struct thermal_cooling_device *cdev,
				 unsigned long state)
{
	int cur_temp, cur_state, err = 0;

	if (!kernelmode)
		return 0;

	err = acerhdf_get_temp(&cur_temp);
	if (err) {
		pr_err("error reading temperature, hand off control to BIOS\n");
		goto err_out;
	}

	err = acerhdf_get_fanstate(&cur_state);
	if (err) {
		pr_err("error reading fan state, hand off control to BIOS\n");
		goto err_out;
	}

	if (state == 0) {
		/* turn fan off only if below fanoff temperature */
		if ((cur_state == ACERHDF_FAN_AUTO) &&
		    (cur_temp < fanoff))
			acerhdf_change_fanstate(ACERHDF_FAN_OFF);
	} else {
		if (cur_state == ACERHDF_FAN_OFF)
			acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
	}
	return 0;

err_out:
	acerhdf_revert_to_bios_mode();
	return -EINVAL;
}

/* bind fan callbacks to fan device */
struct thermal_cooling_device_ops acerhdf_cooling_ops = {
	.get_max_state = acerhdf_get_max_state,
	.get_cur_state = acerhdf_get_cur_state,
	.set_cur_state = acerhdf_set_cur_state,
};

/* suspend / resume functionality */
static int acerhdf_suspend(struct device *dev)
{
	if (kernelmode)
		acerhdf_change_fanstate(ACERHDF_FAN_AUTO);

	if (verbose)
		pr_notice("going suspend\n");

	return 0;
}

static int __devinit acerhdf_probe(struct platform_device *device)
{
	return 0;
}

static int acerhdf_remove(struct platform_device *device)
{
	return 0;
}

static const struct dev_pm_ops acerhdf_pm_ops = {
	.suspend = acerhdf_suspend,
	.freeze  = acerhdf_suspend,
};

static struct platform_driver acerhdf_driver = {
	.driver = {
		.name  = "acerhdf",
		.owner = THIS_MODULE,
		.pm    = &acerhdf_pm_ops,
	},
	.probe = acerhdf_probe,
	.remove = acerhdf_remove,
};

/* checks if str begins with start */
static int str_starts_with(const char *str, const char *start)
{
	unsigned long str_len = 0, start_len = 0;

	str_len = strlen(str);
	start_len = strlen(start);

	if (str_len >= start_len &&
			!strncmp(str, start, start_len))
		return 1;

	return 0;
}

/* check hardware */
static int acerhdf_check_hardware(void)
{
	char const *vendor, *version, *product;
	const struct bios_settings_t *bt = NULL;

	/* get BIOS data */
	vendor  = dmi_get_system_info(DMI_SYS_VENDOR);
	version = dmi_get_system_info(DMI_BIOS_VERSION);
	product = dmi_get_system_info(DMI_PRODUCT_NAME);


	pr_info("Acer Aspire One Fan driver, v.%s\n", DRV_VER);

	if (force_bios[0]) {
		version = force_bios;
		pr_info("forcing BIOS version: %s\n", version);
		kernelmode = 0;
	}

	if (force_product[0]) {
		product = force_product;
		pr_info("forcing BIOS product: %s\n", product);
		kernelmode = 0;
	}

	if (verbose)
		pr_info("BIOS info: %s %s, product: %s\n",
			vendor, version, product);

	/* search BIOS version and vendor in BIOS settings table */
	for (bt = bios_tbl; bt->vendor[0]; bt++) {
		/*
		 * check if actual hardware BIOS vendor, product and version
		 * IDs start with the strings of BIOS table entry
		 */
		if (str_starts_with(vendor, bt->vendor) &&
				str_starts_with(product, bt->product) &&
				str_starts_with(version, bt->version)) {
			bios_cfg = bt;
			break;
		}
	}

	if (!bios_cfg) {
		pr_err("unknown (unsupported) BIOS version %s/%s/%s, "
			"please report, aborting!\n", vendor, product, version);
		return -EINVAL;
	}

	/*
	 * if started with kernel mode off, prevent the kernel from switching
	 * off the fan
	 */
	if (!kernelmode) {
		pr_notice("Fan control off, to enable do:\n");
		pr_notice("echo -n \"enabled\" > "
			"/sys/class/thermal/thermal_zone0/mode\n");
	}

	return 0;
}

static int acerhdf_register_platform(void)
{
	int err = 0;

	err = platform_driver_register(&acerhdf_driver);
	if (err)
		return err;

	acerhdf_dev = platform_device_alloc("acerhdf", -1);
	platform_device_add(acerhdf_dev);

	return 0;
}

static void acerhdf_unregister_platform(void)
{
	if (!acerhdf_dev)
		return;

	platform_device_del(acerhdf_dev);
	platform_driver_unregister(&acerhdf_driver);
}

static int acerhdf_register_thermal(void)
{
	cl_dev = thermal_cooling_device_register("acerhdf-fan", NULL,
						 &acerhdf_cooling_ops);

	if (IS_ERR(cl_dev))
		return -EINVAL;

	thz_dev = thermal_zone_device_register("acerhdf", 1, NULL,
					      &acerhdf_dev_ops, 0, 0, 0,
					      (kernelmode) ? interval*1000 : 0);
	if (IS_ERR(thz_dev))
		return -EINVAL;

	return 0;
}

static void acerhdf_unregister_thermal(void)
{
	if (cl_dev) {
		thermal_cooling_device_unregister(cl_dev);
		cl_dev = NULL;
	}

	if (thz_dev) {
		thermal_zone_device_unregister(thz_dev);
		thz_dev = NULL;
	}
}

static int __init acerhdf_init(void)
{
	int err = 0;

	err = acerhdf_check_hardware();
	if (err)
		goto out_err;

	err = acerhdf_register_platform();
	if (err)
		goto err_unreg;

	err = acerhdf_register_thermal();
	if (err)
		goto err_unreg;

	return 0;

err_unreg:
	acerhdf_unregister_thermal();
	acerhdf_unregister_platform();

out_err:
	return -ENODEV;
}

static void __exit acerhdf_exit(void)
{
	acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
	acerhdf_unregister_thermal();
	acerhdf_unregister_platform();
}

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Peter Feuerer");
MODULE_DESCRIPTION("Aspire One temperature and fan driver");
MODULE_ALIAS("dmi:*:*Acer*:pnAOA*:");
MODULE_ALIAS("dmi:*:*Acer*:pnAspire 1410*:");
MODULE_ALIAS("dmi:*:*Acer*:pnAspire 1810*:");
MODULE_ALIAS("dmi:*:*Gateway*:pnAOA*:");
MODULE_ALIAS("dmi:*:*Gateway*:pnLT31*:");
MODULE_ALIAS("dmi:*:*Packard Bell*:pnAOA*:");
MODULE_ALIAS("dmi:*:*Packard Bell*:pnDOA*:");
MODULE_ALIAS("dmi:*:*Packard Bell*:pnDOTMU*:");
MODULE_ALIAS("dmi:*:*Packard Bell*:pnDOTMA*:");

module_init(acerhdf_init);
module_exit(acerhdf_exit);
Commit	Line	Data
e86435eb PF	1	/*
	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.
	5	*
	6	* (C) 2009 - Peter Feuerer peter (a) piie.net
	7	* http://piie.net
	8	* 2009 Borislav Petkov <petkovbb@gmail.com>
	9	*
	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
	16	* - Borislav Petkov
	17	* - Andreas Mohr
	18	*
	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.
	23	*
	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.
	28	*
	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
	32	*/
	33
	34	#define pr_fmt(fmt) "acerhdf: " fmt
	35
	36	#include <linux/kernel.h>
	37	#include <linux/module.h>
	38	#include <linux/fs.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>
	44
	45	/*
	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:
	52	*/
	53	#undef START_IN_KERNEL_MODE
	54
887b7ca9	55	#define DRV_VER "0.5.23"
e86435eb PF	56
	57	/*
	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.
	63	*/
70052917	64	#define ACERHDF_TEMP_CRIT 89000
e86435eb PF	65	#define ACERHDF_FAN_OFF 0
	66	#define ACERHDF_FAN_AUTO 1
	67
	68	/*
	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
	71	*/
70052917	72	#define ACERHDF_MAX_FANON 80000
e86435eb PF	73
	74	/*
	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.)
	78	*/
	79	#define ACERHDF_MAX_INTERVAL 15
	80
	81	#ifdef START_IN_KERNEL_MODE
	82	static int kernelmode = 1;
	83	#else
	84	static int kernelmode;
	85	#endif
	86
	87	static unsigned int interval = 10;
70052917 PF	88	static unsigned int fanon = 63000;
70052917 PF	89	static unsigned int fanoff = 58000;
e86435eb PF	90	static unsigned int verbose;
	91	static unsigned int fanstate = ACERHDF_FAN_AUTO;
	92	static char force_bios[16];
ded0cdfc	93	static char force_product[16];
e86435eb PF	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;
	98
	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");
ded0cdfc PF	111	module_param_string(force_product, force_product, 16, 0);
	112	MODULE_PARM_DESC(force_product, "Force BIOS product and omit BIOS check");
	113
	114	/*
210183d4	115	* cmd_off: to switch the fan completely off and check if the fan is off
ded0cdfc PF	116	* cmd_auto: to set the BIOS in control of the fan. The BIOS regulates then
	117	* the fan speed depending on the temperature
	118	*/
	119	struct fancmd {
	120	u8 cmd_off;
	121	u8 cmd_auto;
	122	};
e86435eb PF	123
	124	/* BIOS settings */
	125	struct bios_settings_t {
	126	const char *vendor;
ded0cdfc	127	const char *product;
e86435eb PF	128	const char *version;
	129	unsigned char fanreg;
	130	unsigned char tempreg;
ded0cdfc	131	struct fancmd cmd;
e86435eb PF	132	};
	133
	134	/* Register addresses and values for different BIOS versions */
	135	static const struct bios_settings_t bios_tbl[] = {
ded0cdfc	136	/* AOA110 */
210183d4 PF	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.3307", 0x55, 0x58, {0xaf, 0x00} },
	143	{"Acer", "AOA110", "v0.3308", 0x55, 0x58, {0x21, 0x00} },
	144	{"Acer", "AOA110", "v0.3309", 0x55, 0x58, {0x21, 0x00} },
	145	{"Acer", "AOA110", "v0.3310", 0x55, 0x58, {0x21, 0x00} },
ded0cdfc	146	/* AOA150 */
210183d4 PF	147	{"Acer", "AOA150", "v0.3114", 0x55, 0x58, {0x1f, 0x00} },
	148	{"Acer", "AOA150", "v0.3301", 0x55, 0x58, {0x20, 0x00} },
	149	{"Acer", "AOA150", "v0.3304", 0x55, 0x58, {0x20, 0x00} },
	150	{"Acer", "AOA150", "v0.3305", 0x55, 0x58, {0x20, 0x00} },
	151	{"Acer", "AOA150", "v0.3307", 0x55, 0x58, {0x20, 0x00} },
	152	{"Acer", "AOA150", "v0.3308", 0x55, 0x58, {0x20, 0x00} },
	153	{"Acer", "AOA150", "v0.3309", 0x55, 0x58, {0x20, 0x00} },
	154	{"Acer", "AOA150", "v0.3310", 0x55, 0x58, {0x20, 0x00} },
36065746	155	/* Acer 1410 */
210183d4 PF	156	{"Acer", "Aspire 1410", "v0.3115", 0x55, 0x58, {0x9e, 0x00} },
	157	{"Acer", "Aspire 1410", "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
	158	{"Acer", "Aspire 1410", "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
94219d79	159	/* Acer 1810xx */
210183d4 PF	160	{"Acer", "Aspire 1810TZ", "v0.3115", 0x55, 0x58, {0x9e, 0x00} },
	161	{"Acer", "Aspire 1810T", "v0.3115", 0x55, 0x58, {0x9e, 0x00} },
	162	{"Acer", "Aspire 1810TZ", "v0.3119", 0x55, 0x58, {0x9e, 0x00} },
	163	{"Acer", "Aspire 1810T", "v0.3119", 0x55, 0x58, {0x9e, 0x00} },
	164	{"Acer", "Aspire 1810TZ", "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
	165	{"Acer", "Aspire 1810T", "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
	166	{"Acer", "Aspire 1810TZ", "v1.3204", 0x55, 0x58, {0x9e, 0x00} },
	167	{"Acer", "Aspire 1810T", "v1.3204", 0x55, 0x58, {0x9e, 0x00} },
	168	{"Acer", "Aspire 1810TZ", "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
	169	{"Acer", "Aspire 1810T", "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
94219d79	170	/* Gateway */
210183d4 PF	171	{"Gateway", "AOA110", "v0.3103", 0x55, 0x58, {0x21, 0x00} },
	172	{"Gateway", "AOA150", "v0.3103", 0x55, 0x58, {0x20, 0x00} },
	173	{"Gateway", "LT31", "v1.3103", 0x55, 0x58, {0x9e, 0x00} },
	174	{"Gateway", "LT31", "v1.3201", 0x55, 0x58, {0x9e, 0x00} },
	175	{"Gateway", "LT31", "v1.3302", 0x55, 0x58, {0x9e, 0x00} },
94219d79	176	/* Packard Bell */
210183d4 PF	177	{"Packard Bell", "DOA150", "v0.3104", 0x55, 0x58, {0x21, 0x00} },
	178	{"Packard Bell", "DOA150", "v0.3105", 0x55, 0x58, {0x20, 0x00} },
	179	{"Packard Bell", "AOA110", "v0.3105", 0x55, 0x58, {0x21, 0x00} },
	180	{"Packard Bell", "AOA150", "v0.3105", 0x55, 0x58, {0x20, 0x00} },
	181	{"Packard Bell", "DOTMU", "v1.3303", 0x55, 0x58, {0x9e, 0x00} },
	182	{"Packard Bell", "DOTMU", "v0.3120", 0x55, 0x58, {0x9e, 0x00} },
	183	{"Packard Bell", "DOTMA", "v1.3201", 0x55, 0x58, {0x9e, 0x00} },
ded0cdfc	184	/* pewpew-terminator */
210183d4	185	{"", "", "", 0, 0, {0, 0} }
e86435eb PF	186	};
	187
	188	static const struct bios_settings_t *bios_cfg __read_mostly;
	189
e86435eb PF	190	static int acerhdf_get_temp(int *temp)
	191	{
	192	u8 read_temp;
	193
	194	if (ec_read(bios_cfg->tempreg, &read_temp))
	195	return -EINVAL;
	196
70052917	197	temp = read_temp 1000;
e86435eb PF	198
	199	return 0;
	200	}
	201
	202	static int acerhdf_get_fanstate(int *state)
	203	{
	204	u8 fan;
e86435eb PF	205
	206	if (ec_read(bios_cfg->fanreg, &fan))
	207	return -EINVAL;
	208
210183d4	209	if (fan != bios_cfg->cmd.cmd_off)
ded0cdfc PF	210	*state = ACERHDF_FAN_AUTO;
	211	else
	212	*state = ACERHDF_FAN_OFF;
e86435eb PF	213
	214	return 0;
	215	}
	216
	217	static void acerhdf_change_fanstate(int state)
	218	{
	219	unsigned char cmd;
	220
	221	if (verbose)
	222	pr_notice("fan %s\n", (state == ACERHDF_FAN_OFF) ?
	223	"OFF" : "ON");
	224
	225	if ((state != ACERHDF_FAN_OFF) && (state != ACERHDF_FAN_AUTO)) {
	226	pr_err("invalid fan state %d requested, setting to auto!\n",
	227	state);
	228	state = ACERHDF_FAN_AUTO;
	229	}
	230
ded0cdfc PF	231	cmd = (state == ACERHDF_FAN_OFF) ? bios_cfg->cmd.cmd_off
ded0cdfc PF	232	: bios_cfg->cmd.cmd_auto;
e86435eb PF	233	fanstate = state;
	234
	235	ec_write(bios_cfg->fanreg, cmd);
	236	}
	237
	238	static void acerhdf_check_param(struct thermal_zone_device *thermal)
	239	{
	240	if (fanon > ACERHDF_MAX_FANON) {
	241	pr_err("fanon temperature too high, set to %d\n",
	242	ACERHDF_MAX_FANON);
	243	fanon = ACERHDF_MAX_FANON;
	244	}
	245
	246	if (kernelmode && prev_interval != interval) {
	247	if (interval > ACERHDF_MAX_INTERVAL) {
	248	pr_err("interval too high, set to %d\n",
	249	ACERHDF_MAX_INTERVAL);
	250	interval = ACERHDF_MAX_INTERVAL;
	251	}
	252	if (verbose)
	253	pr_notice("interval changed to: %d\n",
	254	interval);
	255	thermal->polling_delay = interval*1000;
	256	prev_interval = interval;
	257	}
	258	}
	259
	260	/*
	261	* This is the thermal zone callback which does the delayed polling of the fan
	262	* state. We do check /sysfs-originating settings here in acerhdf_check_param()
	263	* as late as the polling interval is since we can't do that in the respective
	264	* accessors of the module parameters.
	265	*/
	266	static int acerhdf_get_ec_temp(struct thermal_zone_device *thermal,
	267	unsigned long *t)
	268	{
	269	int temp, err = 0;
	270
	271	acerhdf_check_param(thermal);
	272
	273	err = acerhdf_get_temp(&temp);
	274	if (err)
	275	return err;
	276
	277	if (verbose)
	278	pr_notice("temp %d\n", temp);
	279
	280	*t = temp;
	281	return 0;
	282	}
	283
	284	static int acerhdf_bind(struct thermal_zone_device *thermal,
	285	struct thermal_cooling_device *cdev)
	286	{
	287	/* if the cooling device is the one from acerhdf bind it */
	288	if (cdev != cl_dev)
	289	return 0;
	290
	291	if (thermal_zone_bind_cooling_device(thermal, 0, cdev)) {
	292	pr_err("error binding cooling dev\n");
	293	return -EINVAL;
	294	}
	295	return 0;
	296	}
297
298	static int acerhdf_unbind(struct thermal_zone_device *thermal,
299	struct thermal_cooling_device *cdev)
300	{
301	if (cdev != cl_dev)
302	return 0;
303
304	if (thermal_zone_unbind_cooling_device(thermal, 0, cdev)) {
305	pr_err("error unbinding cooling dev\n");
306	return -EINVAL;
307	}
308	return 0;
309	}
310
311	static inline void acerhdf_revert_to_bios_mode(void)
312	{
313	acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
314	kernelmode = 0;
315	if (thz_dev)
316	thz_dev->polling_delay = 0;
317	pr_notice("kernel mode fan control OFF\n");
318	}
319	static inline void acerhdf_enable_kernelmode(void)
320	{
321	kernelmode = 1;
322
323	thz_dev->polling_delay = interval*1000;
324	thermal_zone_device_update(thz_dev);
325	pr_notice("kernel mode fan control ON\n");
326	}
327
328	static int acerhdf_get_mode(struct thermal_zone_device *thermal,
329	enum thermal_device_mode *mode)
330	{
331	if (verbose)
332	pr_notice("kernel mode fan control %d\n", kernelmode);
333
334	*mode = (kernelmode) ? THERMAL_DEVICE_ENABLED
335	: THERMAL_DEVICE_DISABLED;
336
337	return 0;
338	}
339
340	/*
341	* set operation mode;
342	* enabled: the thermal layer of the kernel takes care about
343	* the temperature and the fan.
344	* disabled: the BIOS takes control of the fan.
345	*/
346	static int acerhdf_set_mode(struct thermal_zone_device *thermal,
347	enum thermal_device_mode mode)
348	{
349	if (mode == THERMAL_DEVICE_DISABLED && kernelmode)
350	acerhdf_revert_to_bios_mode();
351	else if (mode == THERMAL_DEVICE_ENABLED && !kernelmode)
352	acerhdf_enable_kernelmode();
353
354	return 0;
355	}
356
357	static int acerhdf_get_trip_type(struct thermal_zone_device *thermal, int trip,
358	enum thermal_trip_type *type)
359	{
360	if (trip == 0)
361	*type = THERMAL_TRIP_ACTIVE;
362
363	return 0;
364	}
365
366	static int acerhdf_get_trip_temp(struct thermal_zone_device *thermal, int trip,
367	unsigned long *temp)
368	{
369	if (trip == 0)
370	*temp = fanon;
371
372	return 0;
373	}
374
375	static int acerhdf_get_crit_temp(struct thermal_zone_device *thermal,
376	unsigned long *temperature)
377	{
378	*temperature = ACERHDF_TEMP_CRIT;
379	return 0;
380	}
381
382	/* bind callback functions to thermalzone */
383	struct thermal_zone_device_ops acerhdf_dev_ops = {
384	.bind = acerhdf_bind,
385	.unbind = acerhdf_unbind,
386	.get_temp = acerhdf_get_ec_temp,
387	.get_mode = acerhdf_get_mode,
388	.set_mode = acerhdf_set_mode,
389	.get_trip_type = acerhdf_get_trip_type,
390	.get_trip_temp = acerhdf_get_trip_temp,
391	.get_crit_temp = acerhdf_get_crit_temp,
392	};
393
394
395	/*
396	* cooling device callback functions
397	* get maximal fan cooling state
398	*/
399	static int acerhdf_get_max_state(struct thermal_cooling_device *cdev,
400	unsigned long *state)
401	{
402	*state = 1;
403
404	return 0;
405	}
406
407	static int acerhdf_get_cur_state(struct thermal_cooling_device *cdev,
408	unsigned long *state)
409	{
410	int err = 0, tmp;
411
412	err = acerhdf_get_fanstate(&tmp);
413	if (err)
414	return err;
415
416	*state = (tmp == ACERHDF_FAN_AUTO) ? 1 : 0;
417	return 0;
418	}
419
420	/* change current fan state - is overwritten when running in kernel mode */
421	static int acerhdf_set_cur_state(struct thermal_cooling_device *cdev,
422	unsigned long state)
423	{
424	int cur_temp, cur_state, err = 0;
425
426	if (!kernelmode)
427	return 0;
428
429	err = acerhdf_get_temp(&cur_temp);
430	if (err) {
431	pr_err("error reading temperature, hand off control to BIOS\n");
432	goto err_out;
433	}
434
435	err = acerhdf_get_fanstate(&cur_state);
436	if (err) {
437	pr_err("error reading fan state, hand off control to BIOS\n");
438	goto err_out;
439	}
440
441	if (state == 0) {
442	/* turn fan off only if below fanoff temperature */
443	if ((cur_state == ACERHDF_FAN_AUTO) &&
444	(cur_temp < fanoff))
445	acerhdf_change_fanstate(ACERHDF_FAN_OFF);
446	} else {
447	if (cur_state == ACERHDF_FAN_OFF)
448	acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
449	}
450	return 0;
451
452	err_out:
453	acerhdf_revert_to_bios_mode();
454	return -EINVAL;
455	}
456
457	/* bind fan callbacks to fan device */
458	struct thermal_cooling_device_ops acerhdf_cooling_ops = {
459	.get_max_state = acerhdf_get_max_state,
460	.get_cur_state = acerhdf_get_cur_state,
461	.set_cur_state = acerhdf_set_cur_state,
462	};
463
464	/* suspend / resume functionality */
ff27e1f3	465	static int acerhdf_suspend(struct device *dev)
e86435eb PF	466	{
	467	if (kernelmode)
	468	acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
	469
	470	if (verbose)
	471	pr_notice("going suspend\n");
	472
	473	return 0;
	474	}
	475
e86435eb PF	476	static int __devinit acerhdf_probe(struct platform_device *device)
	477	{
	478	return 0;
	479	}
	480
	481	static int acerhdf_remove(struct platform_device *device)
	482	{
	483	return 0;
	484	}
	485
47145210	486	static const struct dev_pm_ops acerhdf_pm_ops = {
ff27e1f3 BP	487	.suspend = acerhdf_suspend,
	488	.freeze = acerhdf_suspend,
	489	};
	490
ded0cdfc	491	static struct platform_driver acerhdf_driver = {
e86435eb	492	.driver = {
ff27e1f3	493	.name = "acerhdf",
e86435eb	494	.owner = THIS_MODULE,
ff27e1f3	495	.pm = &acerhdf_pm_ops,
e86435eb PF	496	},
	497	.probe = acerhdf_probe,
	498	.remove = acerhdf_remove,
e86435eb PF	499	};
e86435eb PF	500
dcbfb815 PF	501	/* checks if str begins with start */
	502	static int str_starts_with(const char str, const char start)
	503	{
	504	unsigned long str_len = 0, start_len = 0;
	505
	506	str_len = strlen(str);
	507	start_len = strlen(start);
	508
	509	if (str_len >= start_len &&
	510	!strncmp(str, start, start_len))
	511	return 1;
	512
	513	return 0;
	514	}
e86435eb PF	515
	516	/* check hardware */
	517	static int acerhdf_check_hardware(void)
	518	{
	519	char const vendor, version, *product;
dcbfb815	520	const struct bios_settings_t *bt = NULL;
e86435eb PF	521
	522	/* get BIOS data */
	523	vendor = dmi_get_system_info(DMI_SYS_VENDOR);
	524	version = dmi_get_system_info(DMI_BIOS_VERSION);
	525	product = dmi_get_system_info(DMI_PRODUCT_NAME);
	526
ded0cdfc	527
e86435eb PF	528	pr_info("Acer Aspire One Fan driver, v.%s\n", DRV_VER);
e86435eb PF	529
ded0cdfc	530	if (force_bios[0]) {
e86435eb	531	version = force_bios;
ded0cdfc	532	pr_info("forcing BIOS version: %s\n", version);
e86435eb PF	533	kernelmode = 0;
	534	}
	535
ded0cdfc PF	536	if (force_product[0]) {
	537	product = force_product;
	538	pr_info("forcing BIOS product: %s\n", product);
	539	kernelmode = 0;
	540	}
	541
e86435eb PF	542	if (verbose)
	543	pr_info("BIOS info: %s %s, product: %s\n",
	544	vendor, version, product);
	545
	546	/* search BIOS version and vendor in BIOS settings table */
dcbfb815 PF	547	for (bt = bios_tbl; bt->vendor[0]; bt++) {
	548	/*
	549	* check if actual hardware BIOS vendor, product and version
	550	* IDs start with the strings of BIOS table entry
	551	*/
	552	if (str_starts_with(vendor, bt->vendor) &&
	553	str_starts_with(product, bt->product) &&
	554	str_starts_with(version, bt->version)) {
	555	bios_cfg = bt;
e86435eb PF	556	break;
	557	}
	558	}
	559
	560	if (!bios_cfg) {
ded0cdfc PF	561	pr_err("unknown (unsupported) BIOS version %s/%s/%s, "
ded0cdfc PF	562	"please report, aborting!\n", vendor, product, version);
e86435eb PF	563	return -EINVAL;
	564	}
	565
	566	/*
	567	* if started with kernel mode off, prevent the kernel from switching
	568	* off the fan
	569	*/
	570	if (!kernelmode) {
	571	pr_notice("Fan control off, to enable do:\n");
	572	pr_notice("echo -n \"enabled\" > "
	573	"/sys/class/thermal/thermal_zone0/mode\n");
	574	}
	575
	576	return 0;
	577	}
	578
	579	static int acerhdf_register_platform(void)
	580	{
	581	int err = 0;
	582
ded0cdfc	583	err = platform_driver_register(&acerhdf_driver);
e86435eb PF	584	if (err)
	585	return err;
	586
	587	acerhdf_dev = platform_device_alloc("acerhdf", -1);
	588	platform_device_add(acerhdf_dev);
	589
	590	return 0;
	591	}
	592
	593	static void acerhdf_unregister_platform(void)
	594	{
	595	if (!acerhdf_dev)
	596	return;
	597
	598	platform_device_del(acerhdf_dev);
ded0cdfc	599	platform_driver_unregister(&acerhdf_driver);
e86435eb PF	600	}
	601
	602	static int acerhdf_register_thermal(void)
	603	{
	604	cl_dev = thermal_cooling_device_register("acerhdf-fan", NULL,
	605	&acerhdf_cooling_ops);
	606
	607	if (IS_ERR(cl_dev))
	608	return -EINVAL;
	609
	610	thz_dev = thermal_zone_device_register("acerhdf", 1, NULL,
	611	&acerhdf_dev_ops, 0, 0, 0,
	612	(kernelmode) ? interval*1000 : 0);
	613	if (IS_ERR(thz_dev))
	614	return -EINVAL;
	615
	616	return 0;
	617	}
	618
	619	static void acerhdf_unregister_thermal(void)
	620	{
	621	if (cl_dev) {
	622	thermal_cooling_device_unregister(cl_dev);
	623	cl_dev = NULL;
	624	}
	625
	626	if (thz_dev) {
	627	thermal_zone_device_unregister(thz_dev);
	628	thz_dev = NULL;
	629	}
	630	}
	631
	632	static int __init acerhdf_init(void)
	633	{
	634	int err = 0;
	635
	636	err = acerhdf_check_hardware();
	637	if (err)
	638	goto out_err;
	639
	640	err = acerhdf_register_platform();
	641	if (err)
	642	goto err_unreg;
	643
	644	err = acerhdf_register_thermal();
	645	if (err)
	646	goto err_unreg;
	647
	648	return 0;
	649
	650	err_unreg:
	651	acerhdf_unregister_thermal();
	652	acerhdf_unregister_platform();
	653
	654	out_err:
	655	return -ENODEV;
	656	}
	657
	658	static void __exit acerhdf_exit(void)
	659	{
	660	acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
	661	acerhdf_unregister_thermal();
	662	acerhdf_unregister_platform();
	663	}
664
665	MODULE_LICENSE("GPL");
666	MODULE_AUTHOR("Peter Feuerer");
667	MODULE_DESCRIPTION("Aspire One temperature and fan driver");
bdc731bc	668	MODULE_ALIAS("dmi::Acer:pnAOA:");
94219d79 PF	669	MODULE_ALIAS("dmi::Acer:pnAspire 1410:");
94219d79 PF	670	MODULE_ALIAS("dmi::Acer:pnAspire 1810:");
bdc731bc	671	MODULE_ALIAS("dmi::Gateway:pnAOA:");
94219d79	672	MODULE_ALIAS("dmi::Gateway:pnLT31:");
bdc731bc SB	673	MODULE_ALIAS("dmi::Packard Bell:pnAOA:");
bdc731bc SB	674	MODULE_ALIAS("dmi::Packard Bell:pnDOA:");
94219d79	675	MODULE_ALIAS("dmi::Packard Bell:pnDOTMU:");
887b7ca9	676	MODULE_ALIAS("dmi::Packard Bell:pnDOTMA:");
e86435eb PF	677
	678	module_init(acerhdf_init);
	679	module_exit(acerhdf_exit);