[deliverable/linux.git] / drivers / misc / eeepc-laptop.c

/*
 *  eepc-laptop.c - Asus Eee PC extras
 *
 *  Based on asus_acpi.c as patched for the Eee PC by Asus:
 *  ftp://ftp.asus.com/pub/ASUS/EeePC/701/ASUS_ACPI_071126.rar
 *  Based on eee.c from eeepc-linux
 *
 *  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.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/platform_device.h>
#include <linux/backlight.h>
#include <linux/fb.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <acpi/acpi_drivers.h>
#include <acpi/acpi_bus.h>
#include <linux/uaccess.h>

#define EEEPC_LAPTOP_VERSION	"0.1"

#define EEEPC_HOTK_NAME		"Eee PC Hotkey Driver"
#define EEEPC_HOTK_FILE		"eeepc"
#define EEEPC_HOTK_CLASS	"hotkey"
#define EEEPC_HOTK_DEVICE_NAME	"Hotkey"
#define EEEPC_HOTK_HID		"ASUS010"

#define EEEPC_LOG	EEEPC_HOTK_FILE ": "
#define EEEPC_ERR	KERN_ERR	EEEPC_LOG
#define EEEPC_WARNING	KERN_WARNING	EEEPC_LOG
#define EEEPC_NOTICE	KERN_NOTICE	EEEPC_LOG
#define EEEPC_INFO	KERN_INFO	EEEPC_LOG

/*
 * Definitions for Asus EeePC
 */
#define	NOTIFY_WLAN_ON	0x10
#define NOTIFY_BRN_MIN	0x20
#define NOTIFY_BRN_MAX	0x2f

enum {
	DISABLE_ASL_WLAN = 0x0001,
	DISABLE_ASL_BLUETOOTH = 0x0002,
	DISABLE_ASL_IRDA = 0x0004,
	DISABLE_ASL_CAMERA = 0x0008,
	DISABLE_ASL_TV = 0x0010,
	DISABLE_ASL_GPS = 0x0020,
	DISABLE_ASL_DISPLAYSWITCH = 0x0040,
	DISABLE_ASL_MODEM = 0x0080,
	DISABLE_ASL_CARDREADER = 0x0100
};

enum {
	CM_ASL_WLAN = 0,
	CM_ASL_BLUETOOTH,
	CM_ASL_IRDA,
	CM_ASL_1394,
	CM_ASL_CAMERA,
	CM_ASL_TV,
	CM_ASL_GPS,
	CM_ASL_DVDROM,
	CM_ASL_DISPLAYSWITCH,
	CM_ASL_PANELBRIGHT,
	CM_ASL_BIOSFLASH,
	CM_ASL_ACPIFLASH,
	CM_ASL_CPUFV,
	CM_ASL_CPUTEMPERATURE,
	CM_ASL_FANCPU,
	CM_ASL_FANCHASSIS,
	CM_ASL_USBPORT1,
	CM_ASL_USBPORT2,
	CM_ASL_USBPORT3,
	CM_ASL_MODEM,
	CM_ASL_CARDREADER,
	CM_ASL_LID
};

const char *cm_getv[] = {
	"WLDG", NULL, NULL, NULL,
	"CAMG", NULL, NULL, NULL,
	NULL, "PBLG", NULL, NULL,
	"CFVG", NULL, NULL, NULL,
	"USBG", NULL, NULL, "MODG",
	"CRDG", "LIDG"
};

const char *cm_setv[] = {
	"WLDS", NULL, NULL, NULL,
	"CAMS", NULL, NULL, NULL,
	"SDSP", "PBLS", "HDPS", NULL,
	"CFVS", NULL, NULL, NULL,
	"USBG", NULL, NULL, "MODS",
	"CRDS", NULL
};

#define EEEPC_EC	"\\_SB.PCI0.SBRG.EC0."

#define EEEPC_EC_FAN_PWM	EEEPC_EC "SC02" /* Fan PWM duty cycle (%) */
#define EEEPC_EC_SC02		0x63
#define EEEPC_EC_FAN_HRPM	EEEPC_EC "SC05" /* High byte, fan speed (RPM) */
#define EEEPC_EC_FAN_LRPM	EEEPC_EC "SC06" /* Low byte, fan speed (RPM) */
#define EEEPC_EC_FAN_CTRL	EEEPC_EC "SFB3" /* Byte containing SF25  */
#define EEEPC_EC_SFB3		0xD3

/*
 * This is the main structure, we can use it to store useful information
 * about the hotk device
 */
struct eeepc_hotk {
	struct acpi_device *device;	/* the device we are in */
	acpi_handle handle;		/* the handle of the hotk device */
	u32 cm_supported;		/* the control methods supported
					   by this BIOS */
	uint init_flag;			/* Init flags */
	u16 event_count[128];		/* count for each event */
};

/* The actual device the driver binds to */
static struct eeepc_hotk *ehotk;

/* Platform device/driver */
static struct platform_driver platform_driver = {
	.driver = {
		.name = EEEPC_HOTK_FILE,
		.owner = THIS_MODULE,
	}
};

static struct platform_device *platform_device;

/*
 * The hotkey driver declaration
 */
static int eeepc_hotk_add(struct acpi_device *device);
static int eeepc_hotk_remove(struct acpi_device *device, int type);

static const struct acpi_device_id eeepc_device_ids[] = {
	{EEEPC_HOTK_HID, 0},
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, eeepc_device_ids);

static struct acpi_driver eeepc_hotk_driver = {
	.name = EEEPC_HOTK_NAME,
	.class = EEEPC_HOTK_CLASS,
	.ids = eeepc_device_ids,
	.ops = {
		.add = eeepc_hotk_add,
		.remove = eeepc_hotk_remove,
	},
};

/* The backlight device /sys/class/backlight */
static struct backlight_device *eeepc_backlight_device;

/* The hwmon device */
static struct device *eeepc_hwmon_device;

/*
 * The backlight class declaration
 */
static int read_brightness(struct backlight_device *bd);
static int update_bl_status(struct backlight_device *bd);
static struct backlight_ops eeepcbl_ops = {
	.get_brightness = read_brightness,
	.update_status = update_bl_status,
};

MODULE_AUTHOR("Corentin Chary, Eric Cooper");
MODULE_DESCRIPTION(EEEPC_HOTK_NAME);
MODULE_LICENSE("GPL");

/*
 * ACPI Helpers
 */
static int write_acpi_int(acpi_handle handle, const char *method, int val,
			  struct acpi_buffer *output)
{
	struct acpi_object_list params;
	union acpi_object in_obj;
	acpi_status status;

	params.count = 1;
	params.pointer = &in_obj;
	in_obj.type = ACPI_TYPE_INTEGER;
	in_obj.integer.value = val;

	status = acpi_evaluate_object(handle, (char *)method, &params, output);
	return (status == AE_OK ? 0 : -1);
}

static int read_acpi_int(acpi_handle handle, const char *method, int *val)
{
	acpi_status status;
	ulong result;

	status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
	if (ACPI_FAILURE(status)) {
		*val = -1;
		return -1;
	} else {
		*val = result;
		return 0;
	}
}

static int set_acpi(int cm, int value)
{
	if (ehotk->cm_supported & (0x1 << cm)) {
		const char *method = cm_setv[cm];
		if (method == NULL)
			return -ENODEV;
		if (write_acpi_int(ehotk->handle, method, value, NULL))
			printk(EEEPC_WARNING "Error writing %s\n", method);
	}
	return 0;
}

static int get_acpi(int cm)
{
	int value = -1;
	if ((ehotk->cm_supported & (0x1 << cm))) {
		const char *method = cm_getv[cm];
		if (method == NULL)
			return -ENODEV;
		if (read_acpi_int(ehotk->handle, method, &value))
			printk(EEEPC_WARNING "Error reading %s\n", method);
	}
	return value;
}

/*
 * Backlight
 */
static int read_brightness(struct backlight_device *bd)
{
	return get_acpi(CM_ASL_PANELBRIGHT);
}

static int set_brightness(struct backlight_device *bd, int value)
{
	value = max(0, min(15, value));
	return set_acpi(CM_ASL_PANELBRIGHT, value);
}

static int update_bl_status(struct backlight_device *bd)
{
	return set_brightness(bd, bd->props.brightness);
}

/*
 * Sys helpers
 */
static int parse_arg(const char *buf, unsigned long count, int *val)
{
	if (!count)
		return 0;
	if (sscanf(buf, "%i", val) != 1)
		return -EINVAL;
	return count;
}

static ssize_t store_sys_acpi(int cm, const char *buf, size_t count)
{
	int rv, value;

	rv = parse_arg(buf, count, &value);
	if (rv > 0)
		set_acpi(cm, value);
	return rv;
}

static ssize_t show_sys_acpi(int cm, char *buf)
{
	return sprintf(buf, "%d\n", get_acpi(cm));
}

#define EEEPC_CREATE_DEVICE_ATTR(_name, _cm)				\
	static ssize_t show_##_name(struct device *dev,			\
				    struct device_attribute *attr,	\
				    char *buf)				\
	{								\
		return show_sys_acpi(_cm, buf);				\
	}								\
	static ssize_t store_##_name(struct device *dev,		\
				     struct device_attribute *attr,	\
				     const char *buf, size_t count)	\
	{								\
		return store_sys_acpi(_cm, buf, count);			\
	}								\
	static struct device_attribute dev_attr_##_name = {		\
		.attr = {						\
			.name = __stringify(_name),			\
			.mode = 0644 },					\
		.show   = show_##_name,					\
		.store  = store_##_name,				\
	}

EEEPC_CREATE_DEVICE_ATTR(camera, CM_ASL_CAMERA);
EEEPC_CREATE_DEVICE_ATTR(cardr, CM_ASL_CARDREADER);
EEEPC_CREATE_DEVICE_ATTR(disp, CM_ASL_DISPLAYSWITCH);
EEEPC_CREATE_DEVICE_ATTR(wlan, CM_ASL_WLAN);

static struct attribute *platform_attributes[] = {
	&dev_attr_camera.attr,
	&dev_attr_cardr.attr,
	&dev_attr_disp.attr,
	&dev_attr_wlan.attr,
	NULL
};

static struct attribute_group platform_attribute_group = {
	.attrs = platform_attributes
};

/*
 * Hotkey functions
 */
static int eeepc_hotk_check(void)
{
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	int result;

	result = acpi_bus_get_status(ehotk->device);
	if (result)
		return result;
	if (ehotk->device->status.present) {
		if (write_acpi_int(ehotk->handle, "INIT", ehotk->init_flag,
				    &buffer)) {
			printk(EEEPC_ERR "Hotkey initialization failed\n");
			return -ENODEV;
		} else {
			printk(EEEPC_NOTICE "Hotkey init flags 0x%x\n",
			       ehotk->init_flag);
		}
		/* get control methods supported */
		if (read_acpi_int(ehotk->handle, "CMSG"
				   , &ehotk->cm_supported)) {
			printk(EEEPC_ERR
			       "Get control methods supported failed\n");
			return -ENODEV;
		} else {
			printk(EEEPC_INFO
			       "Get control methods supported: 0x%x\n",
			       ehotk->cm_supported);
		}
	} else {
		printk(EEEPC_ERR "Hotkey device not present, aborting\n");
		return -EINVAL;
	}
	return 0;
}

static void notify_wlan(u32 *event)
{
	/* if DISABLE_ASL_WLAN is set, the notify code for fn+f2
	   will always be 0x10 */
	if (ehotk->cm_supported & (0x1 << CM_ASL_WLAN)) {
		const char *method = cm_getv[CM_ASL_WLAN];
		int value;
		if (read_acpi_int(ehotk->handle, method, &value))
			printk(EEEPC_WARNING "Error reading %s\n",
			       method);
		else if (value == 1)
			*event = 0x11;
	}
}

static void notify_brn(void)
{
	struct backlight_device *bd = eeepc_backlight_device;
	bd->props.brightness = read_brightness(bd);
}

static void eeepc_hotk_notify(acpi_handle handle, u32 event, void *data)
{
	if (!ehotk)
		return;
	if (event == NOTIFY_WLAN_ON && (DISABLE_ASL_WLAN & ehotk->init_flag))
		notify_wlan(&event);
	if (event >= NOTIFY_BRN_MIN && event <= NOTIFY_BRN_MAX)
		notify_brn();
	acpi_bus_generate_proc_event(ehotk->device, event,
				     ehotk->event_count[event % 128]++);
}

static int eeepc_hotk_add(struct acpi_device *device)
{
	acpi_status status = AE_OK;
	int result;

	if (!device)
		 return -EINVAL;
	printk(EEEPC_NOTICE EEEPC_HOTK_NAME "\n");
	ehotk = kzalloc(sizeof(struct eeepc_hotk), GFP_KERNEL);
	if (!ehotk)
		return -ENOMEM;
	ehotk->init_flag = DISABLE_ASL_WLAN | DISABLE_ASL_DISPLAYSWITCH;
	ehotk->handle = device->handle;
	strcpy(acpi_device_name(device), EEEPC_HOTK_DEVICE_NAME);
	strcpy(acpi_device_class(device), EEEPC_HOTK_CLASS);
	acpi_driver_data(device) = ehotk;
	ehotk->device = device;
	result = eeepc_hotk_check();
	if (result)
		goto end;
	status = acpi_install_notify_handler(ehotk->handle, ACPI_SYSTEM_NOTIFY,
					     eeepc_hotk_notify, ehotk);
	if (ACPI_FAILURE(status))
		printk(EEEPC_ERR "Error installing notify handler\n");
 end:
	if (result) {
		kfree(ehotk);
		ehotk = NULL;
	}
	return result;
}

static int eeepc_hotk_remove(struct acpi_device *device, int type)
{
	acpi_status status = 0;

	if (!device || !acpi_driver_data(device))
		 return -EINVAL;
	status = acpi_remove_notify_handler(ehotk->handle, ACPI_SYSTEM_NOTIFY,
					    eeepc_hotk_notify);
	if (ACPI_FAILURE(status))
		printk(EEEPC_ERR "Error removing notify handler\n");
	kfree(ehotk);
	return 0;
}

/*
 * Hwmon
 */
static int eeepc_get_fan_pwm(void)
{
	int value = 0;

	read_acpi_int(NULL, EEEPC_EC_FAN_PWM, &value);
	return (value);
}

static void eeepc_set_fan_pwm(int value)
{
	value = SENSORS_LIMIT(value, 0, 100);
	ec_write(EEEPC_EC_SC02, value);
}

static int eeepc_get_fan_rpm(void)
{
	int high = 0;
	int low = 0;

	read_acpi_int(NULL, EEEPC_EC_FAN_HRPM, &high);
	read_acpi_int(NULL, EEEPC_EC_FAN_LRPM, &low);
	return (high << 8 | low);
}

static int eeepc_get_fan_ctrl(void)
{
	int value = 0;

	read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value);
	return ((value & 0x02 ? 1 : 0));
}

static void eeepc_set_fan_ctrl(int manual)
{
	int value = 0;

	read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value);
	if (manual)
		value |= 0x02;
	else
		value &= ~0x02;
	ec_write(EEEPC_EC_SFB3, value);
}

static ssize_t store_sys_hwmon(void (*set)(int), const char *buf, size_t count)
{
	int rv, value;

	rv = parse_arg(buf, count, &value);
	if (rv > 0)
		set(value);
	return rv;
}

static ssize_t show_sys_hwmon(int (*get)(void), char *buf)
{
	return sprintf(buf, "%d\n", get());
}

#define EEEPC_CREATE_SENSOR_ATTR(_name, _mode, _set, _get)		\
	static ssize_t show_##_name(struct device *dev,			\
				    struct device_attribute *attr,	\
				    char *buf)				\
	{								\
		return show_sys_hwmon(_set, buf);			\
	}								\
	static ssize_t store_##_name(struct device *dev,		\
				     struct device_attribute *attr,	\
				     const char *buf, size_t count)	\
	{								\
		return store_sys_hwmon(_get, buf, count);		\
	}								\
	static SENSOR_DEVICE_ATTR(_name, _mode, show_##_name, store_##_name, 0);

EEEPC_CREATE_SENSOR_ATTR(fan1_input, S_IRUGO, eeepc_get_fan_rpm, NULL);
EEEPC_CREATE_SENSOR_ATTR(fan1_pwm, S_IRUGO | S_IWUSR,
			 eeepc_get_fan_pwm, eeepc_set_fan_pwm);
EEEPC_CREATE_SENSOR_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
			 eeepc_get_fan_ctrl, eeepc_set_fan_ctrl);

static struct attribute *hwmon_attributes[] = {
	&sensor_dev_attr_fan1_pwm.dev_attr.attr,
	&sensor_dev_attr_fan1_input.dev_attr.attr,
	&sensor_dev_attr_pwm1_enable.dev_attr.attr,
	NULL
};

static struct attribute_group hwmon_attribute_group = {
	.attrs = hwmon_attributes
};

/*
 * exit/init
 */
static void eeepc_backlight_exit(void)
{
	if (eeepc_backlight_device)
		backlight_device_unregister(eeepc_backlight_device);
	eeepc_backlight_device = NULL;
}

static void eeepc_hwmon_exit(void)
{
	struct device *hwmon;

	hwmon = eeepc_hwmon_device;
	if (!hwmon)
		return ;
	hwmon_device_unregister(hwmon);
	sysfs_remove_group(&hwmon->kobj,
			   &hwmon_attribute_group);
	eeepc_hwmon_device = NULL;
}

static void __exit eeepc_laptop_exit(void)
{
	eeepc_backlight_exit();
	eeepc_hwmon_exit();
	acpi_bus_unregister_driver(&eeepc_hotk_driver);
	sysfs_remove_group(&platform_device->dev.kobj,
			   &platform_attribute_group);
	platform_device_unregister(platform_device);
	platform_driver_unregister(&platform_driver);
}

static int eeepc_backlight_init(struct device *dev)
{
	struct backlight_device *bd;

	bd = backlight_device_register(EEEPC_HOTK_FILE, dev,
				       NULL, &eeepcbl_ops);
	if (IS_ERR(bd)) {
		printk(EEEPC_ERR
		       "Could not register eeepc backlight device\n");
		eeepc_backlight_device = NULL;
		return PTR_ERR(bd);
	}
	eeepc_backlight_device = bd;
	bd->props.max_brightness = 15;
	bd->props.brightness = read_brightness(NULL);
	bd->props.power = FB_BLANK_UNBLANK;
	backlight_update_status(bd);
	return 0;
}

static int eeepc_hwmon_init(struct device *dev)
{
	struct device *hwmon;
	int result;

	hwmon = hwmon_device_register(dev);
	if (IS_ERR(hwmon)) {
		printk(EEEPC_ERR
		       "Could not register eeepc hwmon device\n");
		eeepc_hwmon_device = NULL;
		return PTR_ERR(hwmon);
	}
	eeepc_hwmon_device = hwmon;
	result = sysfs_create_group(&hwmon->kobj,
				    &hwmon_attribute_group);
	if (result)
		eeepc_hwmon_exit();
	return result;
}

static int __init eeepc_laptop_init(void)
{
	struct device *dev;
	int result;

	if (acpi_disabled)
		return -ENODEV;
	result = acpi_bus_register_driver(&eeepc_hotk_driver);
	if (result < 0)
		return result;
	if (!ehotk) {
		acpi_bus_unregister_driver(&eeepc_hotk_driver);
		return -ENODEV;
	}
	dev = acpi_get_physical_device(ehotk->device->handle);
	result = eeepc_backlight_init(dev);
	if (result)
		goto fail_backlight;
	result = eeepc_hwmon_init(dev);
	if (result)
		goto fail_hwmon;
	/* Register platform stuff */
	result = platform_driver_register(&platform_driver);
	if (result)
		goto fail_platform_driver;
	platform_device = platform_device_alloc(EEEPC_HOTK_FILE, -1);
	if (!platform_device) {
		result = -ENOMEM;
		goto fail_platform_device1;
	}
	result = platform_device_add(platform_device);
	if (result)
		goto fail_platform_device2;
	result = sysfs_create_group(&platform_device->dev.kobj,
				    &platform_attribute_group);
	if (result)
		goto fail_sysfs;
	return 0;
fail_sysfs:
	platform_device_del(platform_device);
fail_platform_device2:
	platform_device_put(platform_device);
fail_platform_device1:
	platform_driver_unregister(&platform_driver);
fail_platform_driver:
	eeepc_hwmon_exit();
fail_hwmon:
	eeepc_backlight_exit();
fail_backlight:
	return result;
}

module_init(eeepc_laptop_init);
module_exit(eeepc_laptop_exit);
Commit	Line	Data
e59f8796 EC	1	/*
	2	* eepc-laptop.c - Asus Eee PC extras
	3	*
	4	* Based on asus_acpi.c as patched for the Eee PC by Asus:
	5	* ftp://ftp.asus.com/pub/ASUS/EeePC/701/ASUS_ACPI_071126.rar
	6	* Based on eee.c from eeepc-linux
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*/
	18
	19	#include <linux/kernel.h>
	20	#include <linux/module.h>
	21	#include <linux/init.h>
	22	#include <linux/types.h>
	23	#include <linux/platform_device.h>
a5fa429b CC	24	#include <linux/backlight.h>
a5fa429b CC	25	#include <linux/fb.h>
e1faa9da CC	26	#include <linux/hwmon.h>
e1faa9da CC	27	#include <linux/hwmon-sysfs.h>
e59f8796 EC	28	#include <acpi/acpi_drivers.h>
	29	#include <acpi/acpi_bus.h>
	30	#include <linux/uaccess.h>
	31
	32	#define EEEPC_LAPTOP_VERSION "0.1"
	33
	34	#define EEEPC_HOTK_NAME "Eee PC Hotkey Driver"
	35	#define EEEPC_HOTK_FILE "eeepc"
	36	#define EEEPC_HOTK_CLASS "hotkey"
	37	#define EEEPC_HOTK_DEVICE_NAME "Hotkey"
	38	#define EEEPC_HOTK_HID "ASUS010"
	39
	40	#define EEEPC_LOG EEEPC_HOTK_FILE ": "
	41	#define EEEPC_ERR KERN_ERR EEEPC_LOG
	42	#define EEEPC_WARNING KERN_WARNING EEEPC_LOG
	43	#define EEEPC_NOTICE KERN_NOTICE EEEPC_LOG
	44	#define EEEPC_INFO KERN_INFO EEEPC_LOG
	45
	46	/*
	47	* Definitions for Asus EeePC
	48	*/
	49	#define NOTIFY_WLAN_ON 0x10
a5fa429b CC	50	#define NOTIFY_BRN_MIN 0x20
a5fa429b CC	51	#define NOTIFY_BRN_MAX 0x2f
e59f8796 EC	52
	53	enum {
	54	DISABLE_ASL_WLAN = 0x0001,
	55	DISABLE_ASL_BLUETOOTH = 0x0002,
	56	DISABLE_ASL_IRDA = 0x0004,
	57	DISABLE_ASL_CAMERA = 0x0008,
	58	DISABLE_ASL_TV = 0x0010,
	59	DISABLE_ASL_GPS = 0x0020,
	60	DISABLE_ASL_DISPLAYSWITCH = 0x0040,
	61	DISABLE_ASL_MODEM = 0x0080,
	62	DISABLE_ASL_CARDREADER = 0x0100
	63	};
	64
	65	enum {
	66	CM_ASL_WLAN = 0,
	67	CM_ASL_BLUETOOTH,
	68	CM_ASL_IRDA,
	69	CM_ASL_1394,
	70	CM_ASL_CAMERA,
	71	CM_ASL_TV,
	72	CM_ASL_GPS,
	73	CM_ASL_DVDROM,
	74	CM_ASL_DISPLAYSWITCH,
	75	CM_ASL_PANELBRIGHT,
	76	CM_ASL_BIOSFLASH,
	77	CM_ASL_ACPIFLASH,
	78	CM_ASL_CPUFV,
	79	CM_ASL_CPUTEMPERATURE,
	80	CM_ASL_FANCPU,
	81	CM_ASL_FANCHASSIS,
	82	CM_ASL_USBPORT1,
	83	CM_ASL_USBPORT2,
	84	CM_ASL_USBPORT3,
	85	CM_ASL_MODEM,
	86	CM_ASL_CARDREADER,
	87	CM_ASL_LID
	88	};
	89
	90	const char *cm_getv[] = {
	91	"WLDG", NULL, NULL, NULL,
	92	"CAMG", NULL, NULL, NULL,
	93	NULL, "PBLG", NULL, NULL,
	94	"CFVG", NULL, NULL, NULL,
	95	"USBG", NULL, NULL, "MODG",
	96	"CRDG", "LIDG"
	97	};
	98
	99	const char *cm_setv[] = {
	100	"WLDS", NULL, NULL, NULL,
	101	"CAMS", NULL, NULL, NULL,
	102	"SDSP", "PBLS", "HDPS", NULL,
	103	"CFVS", NULL, NULL, NULL,
	104	"USBG", NULL, NULL, "MODS",
	105	"CRDS", NULL
	106	};
	107
e1faa9da CC	108	#define EEEPC_EC "\\_SB.PCI0.SBRG.EC0."
	109
	110	#define EEEPC_EC_FAN_PWM EEEPC_EC "SC02" /* Fan PWM duty cycle (%) */
	111	#define EEEPC_EC_SC02 0x63
	112	#define EEEPC_EC_FAN_HRPM EEEPC_EC "SC05" /* High byte, fan speed (RPM) */
	113	#define EEEPC_EC_FAN_LRPM EEEPC_EC "SC06" /* Low byte, fan speed (RPM) */
	114	#define EEEPC_EC_FAN_CTRL EEEPC_EC "SFB3" /* Byte containing SF25 */
	115	#define EEEPC_EC_SFB3 0xD3
	116
e59f8796 EC	117	/*
	118	* This is the main structure, we can use it to store useful information
	119	* about the hotk device
	120	*/
	121	struct eeepc_hotk {
	122	struct acpi_device device; / the device we are in */
	123	acpi_handle handle; /* the handle of the hotk device */
	124	u32 cm_supported; /* the control methods supported
	125	by this BIOS */
	126	uint init_flag; /* Init flags */
	127	u16 event_count[128]; /* count for each event */
	128	};
	129
	130	/* The actual device the driver binds to */
	131	static struct eeepc_hotk *ehotk;
	132
	133	/* Platform device/driver */
	134	static struct platform_driver platform_driver = {
	135	.driver = {
	136	.name = EEEPC_HOTK_FILE,
	137	.owner = THIS_MODULE,
	138	}
	139	};
	140
	141	static struct platform_device *platform_device;
	142
	143	/*
	144	* The hotkey driver declaration
	145	*/
	146	static int eeepc_hotk_add(struct acpi_device *device);
	147	static int eeepc_hotk_remove(struct acpi_device *device, int type);
	148
	149	static const struct acpi_device_id eeepc_device_ids[] = {
	150	{EEEPC_HOTK_HID, 0},
	151	{"", 0},
	152	};
	153	MODULE_DEVICE_TABLE(acpi, eeepc_device_ids);
	154
	155	static struct acpi_driver eeepc_hotk_driver = {
	156	.name = EEEPC_HOTK_NAME,
	157	.class = EEEPC_HOTK_CLASS,
	158	.ids = eeepc_device_ids,
	159	.ops = {
	160	.add = eeepc_hotk_add,
	161	.remove = eeepc_hotk_remove,
	162	},
	163	};
	164
a5fa429b CC	165	/* The backlight device /sys/class/backlight */
	166	static struct backlight_device *eeepc_backlight_device;
	167
e1faa9da CC	168	/* The hwmon device */
	169	static struct device *eeepc_hwmon_device;
	170
a5fa429b CC	171	/*
	172	* The backlight class declaration
	173	*/
	174	static int read_brightness(struct backlight_device *bd);
	175	static int update_bl_status(struct backlight_device *bd);
	176	static struct backlight_ops eeepcbl_ops = {
	177	.get_brightness = read_brightness,
	178	.update_status = update_bl_status,
	179	};
	180
e59f8796 EC	181	MODULE_AUTHOR("Corentin Chary, Eric Cooper");
	182	MODULE_DESCRIPTION(EEEPC_HOTK_NAME);
	183	MODULE_LICENSE("GPL");
	184
	185	/*
	186	* ACPI Helpers
	187	*/
	188	static int write_acpi_int(acpi_handle handle, const char *method, int val,
	189	struct acpi_buffer *output)
	190	{
	191	struct acpi_object_list params;
	192	union acpi_object in_obj;
	193	acpi_status status;
	194
	195	params.count = 1;
	196	params.pointer = &in_obj;
	197	in_obj.type = ACPI_TYPE_INTEGER;
	198	in_obj.integer.value = val;
	199
	200	status = acpi_evaluate_object(handle, (char *)method, &params, output);
	201	return (status == AE_OK ? 0 : -1);
	202	}
	203
	204	static int read_acpi_int(acpi_handle handle, const char method, int val)
	205	{
	206	acpi_status status;
	207	ulong result;
	208
	209	status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
	210	if (ACPI_FAILURE(status)) {
	211	*val = -1;
	212	return -1;
	213	} else {
	214	*val = result;
	215	return 0;
	216	}
	217	}
	218
	219	static int set_acpi(int cm, int value)
	220	{
	221	if (ehotk->cm_supported & (0x1 << cm)) {
	222	const char *method = cm_setv[cm];
	223	if (method == NULL)
	224	return -ENODEV;
	225	if (write_acpi_int(ehotk->handle, method, value, NULL))
	226	printk(EEEPC_WARNING "Error writing %s\n", method);
	227	}
	228	return 0;
	229	}
	230
	231	static int get_acpi(int cm)
	232	{
	233	int value = -1;
	234	if ((ehotk->cm_supported & (0x1 << cm))) {
	235	const char *method = cm_getv[cm];
	236	if (method == NULL)
	237	return -ENODEV;
	238	if (read_acpi_int(ehotk->handle, method, &value))
	239	printk(EEEPC_WARNING "Error reading %s\n", method);
	240	}
	241	return value;
	242	}
	243
a5fa429b CC	244	/*
	245	* Backlight
	246	*/
	247	static int read_brightness(struct backlight_device *bd)
	248	{
	249	return get_acpi(CM_ASL_PANELBRIGHT);
	250	}
	251
	252	static int set_brightness(struct backlight_device *bd, int value)
	253	{
	254	value = max(0, min(15, value));
	255	return set_acpi(CM_ASL_PANELBRIGHT, value);
	256	}
	257
	258	static int update_bl_status(struct backlight_device *bd)
	259	{
	260	return set_brightness(bd, bd->props.brightness);
	261	}
	262
e59f8796 EC	263	/*
	264	* Sys helpers
	265	*/
	266	static int parse_arg(const char buf, unsigned long count, int val)
	267	{
	268	if (!count)
	269	return 0;
	270	if (sscanf(buf, "%i", val) != 1)
	271	return -EINVAL;
	272	return count;
	273	}
	274
	275	static ssize_t store_sys_acpi(int cm, const char *buf, size_t count)
	276	{
	277	int rv, value;
	278
	279	rv = parse_arg(buf, count, &value);
	280	if (rv > 0)
	281	set_acpi(cm, value);
	282	return rv;
	283	}
	284
	285	static ssize_t show_sys_acpi(int cm, char *buf)
	286	{
	287	return sprintf(buf, "%d\n", get_acpi(cm));
	288	}
	289
	290	#define EEEPC_CREATE_DEVICE_ATTR(_name, _cm) \
	291	static ssize_t show_##_name(struct device *dev, \
	292	struct device_attribute *attr, \
	293	char *buf) \
	294	{ \
	295	return show_sys_acpi(_cm, buf); \
	296	} \
	297	static ssize_t store_##_name(struct device *dev, \
	298	struct device_attribute *attr, \
	299	const char *buf, size_t count) \
	300	{ \
	301	return store_sys_acpi(_cm, buf, count); \
	302	} \
	303	static struct device_attribute dev_attr_##_name = { \
	304	.attr = { \
	305	.name = __stringify(_name), \
	306	.mode = 0644 }, \
	307	.show = show_##_name, \
	308	.store = store_##_name, \
	309	}
	310
	311	EEEPC_CREATE_DEVICE_ATTR(camera, CM_ASL_CAMERA);
	312	EEEPC_CREATE_DEVICE_ATTR(cardr, CM_ASL_CARDREADER);
	313	EEEPC_CREATE_DEVICE_ATTR(disp, CM_ASL_DISPLAYSWITCH);
	314	EEEPC_CREATE_DEVICE_ATTR(wlan, CM_ASL_WLAN);
	315
	316	static struct attribute *platform_attributes[] = {
	317	&dev_attr_camera.attr,
	318	&dev_attr_cardr.attr,
	319	&dev_attr_disp.attr,
	320	&dev_attr_wlan.attr,
	321	NULL
	322	};
	323
	324	static struct attribute_group platform_attribute_group = {
	325	.attrs = platform_attributes
	326	};
327
328	/*
329	* Hotkey functions
330	*/
331	static int eeepc_hotk_check(void)
332	{
333	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
334	int result;
335
336	result = acpi_bus_get_status(ehotk->device);
337	if (result)
338	return result;
339	if (ehotk->device->status.present) {
340	if (write_acpi_int(ehotk->handle, "INIT", ehotk->init_flag,
341	&buffer)) {
342	printk(EEEPC_ERR "Hotkey initialization failed\n");
343	return -ENODEV;
344	} else {
345	printk(EEEPC_NOTICE "Hotkey init flags 0x%x\n",
346	ehotk->init_flag);
347	}
348	/* get control methods supported */
349	if (read_acpi_int(ehotk->handle, "CMSG"
350	, &ehotk->cm_supported)) {
351	printk(EEEPC_ERR
352	"Get control methods supported failed\n");
353	return -ENODEV;
354	} else {
355	printk(EEEPC_INFO
356	"Get control methods supported: 0x%x\n",
357	ehotk->cm_supported);
358	}
359	} else {
360	printk(EEEPC_ERR "Hotkey device not present, aborting\n");
361	return -EINVAL;
362	}
363	return 0;
364	}
365
366	static void notify_wlan(u32 *event)
367	{
368	/* if DISABLE_ASL_WLAN is set, the notify code for fn+f2
369	will always be 0x10 */
370	if (ehotk->cm_supported & (0x1 << CM_ASL_WLAN)) {
371	const char *method = cm_getv[CM_ASL_WLAN];
372	int value;
373	if (read_acpi_int(ehotk->handle, method, &value))
374	printk(EEEPC_WARNING "Error reading %s\n",
375	method);
376	else if (value == 1)
377	*event = 0x11;
378	}
379	}
380
a5fa429b CC	381	static void notify_brn(void)
	382	{
	383	struct backlight_device *bd = eeepc_backlight_device;
	384	bd->props.brightness = read_brightness(bd);
	385	}
	386
e59f8796 EC	387	static void eeepc_hotk_notify(acpi_handle handle, u32 event, void *data)
	388	{
	389	if (!ehotk)
	390	return;
	391	if (event == NOTIFY_WLAN_ON && (DISABLE_ASL_WLAN & ehotk->init_flag))
	392	notify_wlan(&event);
a5fa429b CC	393	if (event >= NOTIFY_BRN_MIN && event <= NOTIFY_BRN_MAX)
a5fa429b CC	394	notify_brn();
e59f8796 EC	395	acpi_bus_generate_proc_event(ehotk->device, event,
	396	ehotk->event_count[event % 128]++);
	397	}
	398
	399	static int eeepc_hotk_add(struct acpi_device *device)
	400	{
	401	acpi_status status = AE_OK;
	402	int result;
	403
	404	if (!device)
	405	return -EINVAL;
	406	printk(EEEPC_NOTICE EEEPC_HOTK_NAME "\n");
	407	ehotk = kzalloc(sizeof(struct eeepc_hotk), GFP_KERNEL);
	408	if (!ehotk)
	409	return -ENOMEM;
	410	ehotk->init_flag = DISABLE_ASL_WLAN \| DISABLE_ASL_DISPLAYSWITCH;
	411	ehotk->handle = device->handle;
	412	strcpy(acpi_device_name(device), EEEPC_HOTK_DEVICE_NAME);
	413	strcpy(acpi_device_class(device), EEEPC_HOTK_CLASS);
	414	acpi_driver_data(device) = ehotk;
	415	ehotk->device = device;
	416	result = eeepc_hotk_check();
	417	if (result)
	418	goto end;
	419	status = acpi_install_notify_handler(ehotk->handle, ACPI_SYSTEM_NOTIFY,
	420	eeepc_hotk_notify, ehotk);
	421	if (ACPI_FAILURE(status))
	422	printk(EEEPC_ERR "Error installing notify handler\n");
	423	end:
	424	if (result) {
	425	kfree(ehotk);
	426	ehotk = NULL;
	427	}
	428	return result;
	429	}
	430
	431	static int eeepc_hotk_remove(struct acpi_device *device, int type)
	432	{
	433	acpi_status status = 0;
	434
	435	if (!device \|\| !acpi_driver_data(device))
	436	return -EINVAL;
	437	status = acpi_remove_notify_handler(ehotk->handle, ACPI_SYSTEM_NOTIFY,
	438	eeepc_hotk_notify);
	439	if (ACPI_FAILURE(status))
	440	printk(EEEPC_ERR "Error removing notify handler\n");
	441	kfree(ehotk);
	442	return 0;
	443	}
	444
e1faa9da CC	445	/*
	446	* Hwmon
	447	*/
	448	static int eeepc_get_fan_pwm(void)
	449	{
	450	int value = 0;
	451
	452	read_acpi_int(NULL, EEEPC_EC_FAN_PWM, &value);
	453	return (value);
	454	}
	455
	456	static void eeepc_set_fan_pwm(int value)
	457	{
	458	value = SENSORS_LIMIT(value, 0, 100);
	459	ec_write(EEEPC_EC_SC02, value);
	460	}
	461
	462	static int eeepc_get_fan_rpm(void)
	463	{
	464	int high = 0;
	465	int low = 0;
	466
	467	read_acpi_int(NULL, EEEPC_EC_FAN_HRPM, &high);
	468	read_acpi_int(NULL, EEEPC_EC_FAN_LRPM, &low);
	469	return (high << 8 \| low);
	470	}
	471
	472	static int eeepc_get_fan_ctrl(void)
	473	{
	474	int value = 0;
	475
	476	read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value);
	477	return ((value & 0x02 ? 1 : 0));
	478	}
	479
	480	static void eeepc_set_fan_ctrl(int manual)
	481	{
	482	int value = 0;
	483
	484	read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value);
	485	if (manual)
	486	value \|= 0x02;
	487	else
	488	value &= ~0x02;
	489	ec_write(EEEPC_EC_SFB3, value);
	490	}
	491
	492	static ssize_t store_sys_hwmon(void (set)(int), const char buf, size_t count)
	493	{
	494	int rv, value;
	495
	496	rv = parse_arg(buf, count, &value);
	497	if (rv > 0)
	498	set(value);
	499	return rv;
	500	}
	501
	502	static ssize_t show_sys_hwmon(int (get)(void), char buf)
	503	{
	504	return sprintf(buf, "%d\n", get());
	505	}
	506
	507	#define EEEPC_CREATE_SENSOR_ATTR(_name, _mode, _set, _get) \
	508	static ssize_t show_##_name(struct device *dev, \
509	struct device_attribute *attr, \
510	char *buf) \
511	{ \
512	return show_sys_hwmon(_set, buf); \
513	} \
514	static ssize_t store_##_name(struct device *dev, \
515	struct device_attribute *attr, \
516	const char *buf, size_t count) \
517	{ \
518	return store_sys_hwmon(_get, buf, count); \
519	} \
520	static SENSOR_DEVICE_ATTR(_name, _mode, show_##_name, store_##_name, 0);
521
522	EEEPC_CREATE_SENSOR_ATTR(fan1_input, S_IRUGO, eeepc_get_fan_rpm, NULL);
523	EEEPC_CREATE_SENSOR_ATTR(fan1_pwm, S_IRUGO \| S_IWUSR,
524	eeepc_get_fan_pwm, eeepc_set_fan_pwm);
525	EEEPC_CREATE_SENSOR_ATTR(pwm1_enable, S_IRUGO \| S_IWUSR,
526	eeepc_get_fan_ctrl, eeepc_set_fan_ctrl);
527
528	static struct attribute *hwmon_attributes[] = {
529	&sensor_dev_attr_fan1_pwm.dev_attr.attr,
530	&sensor_dev_attr_fan1_input.dev_attr.attr,
531	&sensor_dev_attr_pwm1_enable.dev_attr.attr,
532	NULL
533	};
534
535	static struct attribute_group hwmon_attribute_group = {
536	.attrs = hwmon_attributes
537	};
538
e59f8796 EC	539	/*
	540	* exit/init
	541	*/
a5fa429b CC	542	static void eeepc_backlight_exit(void)
	543	{
	544	if (eeepc_backlight_device)
	545	backlight_device_unregister(eeepc_backlight_device);
	546	eeepc_backlight_device = NULL;
	547	}
	548
e1faa9da CC	549	static void eeepc_hwmon_exit(void)
	550	{
	551	struct device *hwmon;
	552
	553	hwmon = eeepc_hwmon_device;
	554	if (!hwmon)
	555	return ;
	556	hwmon_device_unregister(hwmon);
	557	sysfs_remove_group(&hwmon->kobj,
	558	&hwmon_attribute_group);
	559	eeepc_hwmon_device = NULL;
	560	}
	561
e59f8796 EC	562	static void __exit eeepc_laptop_exit(void)
e59f8796 EC	563	{
a5fa429b	564	eeepc_backlight_exit();
e1faa9da	565	eeepc_hwmon_exit();
e59f8796 EC	566	acpi_bus_unregister_driver(&eeepc_hotk_driver);
	567	sysfs_remove_group(&platform_device->dev.kobj,
	568	&platform_attribute_group);
	569	platform_device_unregister(platform_device);
	570	platform_driver_unregister(&platform_driver);
	571	}
	572
a5fa429b CC	573	static int eeepc_backlight_init(struct device *dev)
	574	{
	575	struct backlight_device *bd;
	576
	577	bd = backlight_device_register(EEEPC_HOTK_FILE, dev,
	578	NULL, &eeepcbl_ops);
	579	if (IS_ERR(bd)) {
	580	printk(EEEPC_ERR
	581	"Could not register eeepc backlight device\n");
	582	eeepc_backlight_device = NULL;
	583	return PTR_ERR(bd);
	584	}
	585	eeepc_backlight_device = bd;
	586	bd->props.max_brightness = 15;
	587	bd->props.brightness = read_brightness(NULL);
	588	bd->props.power = FB_BLANK_UNBLANK;
	589	backlight_update_status(bd);
	590	return 0;
	591	}
	592
e1faa9da CC	593	static int eeepc_hwmon_init(struct device *dev)
	594	{
	595	struct device *hwmon;
	596	int result;
	597
	598	hwmon = hwmon_device_register(dev);
	599	if (IS_ERR(hwmon)) {
	600	printk(EEEPC_ERR
	601	"Could not register eeepc hwmon device\n");
	602	eeepc_hwmon_device = NULL;
	603	return PTR_ERR(hwmon);
	604	}
	605	eeepc_hwmon_device = hwmon;
	606	result = sysfs_create_group(&hwmon->kobj,
	607	&hwmon_attribute_group);
	608	if (result)
	609	eeepc_hwmon_exit();
	610	return result;
	611	}
	612
e59f8796 EC	613	static int __init eeepc_laptop_init(void)
	614	{
	615	struct device *dev;
	616	int result;
	617
	618	if (acpi_disabled)
	619	return -ENODEV;
	620	result = acpi_bus_register_driver(&eeepc_hotk_driver);
	621	if (result < 0)
	622	return result;
	623	if (!ehotk) {
	624	acpi_bus_unregister_driver(&eeepc_hotk_driver);
	625	return -ENODEV;
	626	}
	627	dev = acpi_get_physical_device(ehotk->device->handle);
a5fa429b CC	628	result = eeepc_backlight_init(dev);
	629	if (result)
	630	goto fail_backlight;
e1faa9da CC	631	result = eeepc_hwmon_init(dev);
	632	if (result)
	633	goto fail_hwmon;
e59f8796 EC	634	/* Register platform stuff */
	635	result = platform_driver_register(&platform_driver);
	636	if (result)
	637	goto fail_platform_driver;
	638	platform_device = platform_device_alloc(EEEPC_HOTK_FILE, -1);
	639	if (!platform_device) {
	640	result = -ENOMEM;
	641	goto fail_platform_device1;
	642	}
	643	result = platform_device_add(platform_device);
	644	if (result)
	645	goto fail_platform_device2;
	646	result = sysfs_create_group(&platform_device->dev.kobj,
	647	&platform_attribute_group);
	648	if (result)
	649	goto fail_sysfs;
	650	return 0;
	651	fail_sysfs:
	652	platform_device_del(platform_device);
	653	fail_platform_device2:
	654	platform_device_put(platform_device);
	655	fail_platform_device1:
	656	platform_driver_unregister(&platform_driver);
	657	fail_platform_driver:
e1faa9da CC	658	eeepc_hwmon_exit();
e1faa9da CC	659	fail_hwmon:
a5fa429b CC	660	eeepc_backlight_exit();
a5fa429b CC	661	fail_backlight:
e59f8796 EC	662	return result;
	663	}
	664
	665	module_init(eeepc_laptop_init);
	666	module_exit(eeepc_laptop_exit);