[net-next-2.6.git] / drivers / hwmon / hdaps.c

/*
 * drivers/hwmon/hdaps.c - driver for IBM's Hard Drive Active Protection System
 *
 * Copyright (C) 2005 Robert Love <rml@novell.com>
 * Copyright (C) 2005 Jesper Juhl <jesper.juhl@gmail.com>
 *
 * The HardDisk Active Protection System (hdaps) is present in IBM ThinkPads
 * starting with the R40, T41, and X40.  It provides a basic two-axis
 * accelerometer and other data, such as the device's temperature.
 *
 * This driver is based on the document by Mark A. Smith available at
 * http://www.almaden.ibm.com/cs/people/marksmith/tpaps.html and a lot of trial
 * and error.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License v2 as published by the
 * Free Software Foundation.
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */

#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/input-polldev.h>
#include <linux/kernel.h>
#include <linux/mutex.h>
#include <linux/module.h>
#include <linux/timer.h>
#include <linux/dmi.h>
#include <linux/jiffies.h>
#include <linux/io.h>

#define HDAPS_LOW_PORT		0x1600	/* first port used by hdaps */
#define HDAPS_NR_PORTS		0x30	/* number of ports: 0x1600 - 0x162f */

#define HDAPS_PORT_STATE	0x1611	/* device state */
#define HDAPS_PORT_YPOS		0x1612	/* y-axis position */
#define	HDAPS_PORT_XPOS		0x1614	/* x-axis position */
#define HDAPS_PORT_TEMP1	0x1616	/* device temperature, in Celsius */
#define HDAPS_PORT_YVAR		0x1617	/* y-axis variance (what is this?) */
#define HDAPS_PORT_XVAR		0x1619	/* x-axis variance (what is this?) */
#define HDAPS_PORT_TEMP2	0x161b	/* device temperature (again?) */
#define HDAPS_PORT_UNKNOWN	0x161c	/* what is this? */
#define HDAPS_PORT_KMACT	0x161d	/* keyboard or mouse activity */

#define STATE_FRESH		0x50	/* accelerometer data is fresh */

#define KEYBD_MASK		0x20	/* set if keyboard activity */
#define MOUSE_MASK		0x40	/* set if mouse activity */
#define KEYBD_ISSET(n)		(!! (n & KEYBD_MASK))	/* keyboard used? */
#define MOUSE_ISSET(n)		(!! (n & MOUSE_MASK))	/* mouse used? */

#define INIT_TIMEOUT_MSECS	4000	/* wait up to 4s for device init ... */
#define INIT_WAIT_MSECS		200	/* ... in 200ms increments */

#define HDAPS_POLL_INTERVAL	50	/* poll for input every 1/20s (50 ms)*/
#define HDAPS_INPUT_FUZZ	4	/* input event threshold */
#define HDAPS_INPUT_FLAT	4

#define HDAPS_X_AXIS		(1 << 0)
#define HDAPS_Y_AXIS		(1 << 1)
#define HDAPS_BOTH_AXES		(HDAPS_X_AXIS | HDAPS_Y_AXIS)

static struct platform_device *pdev;
static struct input_polled_dev *hdaps_idev;
static unsigned int hdaps_invert;
static u8 km_activity;
static int rest_x;
static int rest_y;

static DEFINE_MUTEX(hdaps_mtx);

/*
 * __get_latch - Get the value from a given port.  Callers must hold hdaps_mtx.
 */
static inline u8 __get_latch(u16 port)
{
	return inb(port) & 0xff;
}

/*
 * __check_latch - Check a port latch for a given value.  Returns zero if the
 * port contains the given value.  Callers must hold hdaps_mtx.
 */
static inline int __check_latch(u16 port, u8 val)
{
	if (__get_latch(port) == val)
		return 0;
	return -EINVAL;
}

/*
 * __wait_latch - Wait up to 100us for a port latch to get a certain value,
 * returning zero if the value is obtained.  Callers must hold hdaps_mtx.
 */
static int __wait_latch(u16 port, u8 val)
{
	unsigned int i;

	for (i = 0; i < 20; i++) {
		if (!__check_latch(port, val))
			return 0;
		udelay(5);
	}

	return -EIO;
}

/*
 * __device_refresh - request a refresh from the accelerometer.  Does not wait
 * for refresh to complete.  Callers must hold hdaps_mtx.
 */
static void __device_refresh(void)
{
	udelay(200);
	if (inb(0x1604) != STATE_FRESH) {
		outb(0x11, 0x1610);
		outb(0x01, 0x161f);
	}
}

/*
 * __device_refresh_sync - request a synchronous refresh from the
 * accelerometer.  We wait for the refresh to complete.  Returns zero if
 * successful and nonzero on error.  Callers must hold hdaps_mtx.
 */
static int __device_refresh_sync(void)
{
	__device_refresh();
	return __wait_latch(0x1604, STATE_FRESH);
}

/*
 * __device_complete - indicate to the accelerometer that we are done reading
 * data, and then initiate an async refresh.  Callers must hold hdaps_mtx.
 */
static inline void __device_complete(void)
{
	inb(0x161f);
	inb(0x1604);
	__device_refresh();
}

/*
 * hdaps_readb_one - reads a byte from a single I/O port, placing the value in
 * the given pointer.  Returns zero on success or a negative error on failure.
 * Can sleep.
 */
static int hdaps_readb_one(unsigned int port, u8 *val)
{
	int ret;

	mutex_lock(&hdaps_mtx);

	/* do a sync refresh -- we need to be sure that we read fresh data */
	ret = __device_refresh_sync();
	if (ret)
		goto out;

	*val = inb(port);
	__device_complete();

out:
	mutex_unlock(&hdaps_mtx);
	return ret;
}

/* __hdaps_read_pair - internal lockless helper for hdaps_read_pair(). */
static int __hdaps_read_pair(unsigned int port1, unsigned int port2,
			     int *x, int *y)
{
	/* do a sync refresh -- we need to be sure that we read fresh data */
	if (__device_refresh_sync())
		return -EIO;

	*y = inw(port2);
	*x = inw(port1);
	km_activity = inb(HDAPS_PORT_KMACT);
	__device_complete();

	/* hdaps_invert is a bitvector to negate the axes */
	if (hdaps_invert & HDAPS_X_AXIS)
		*x = -*x;
	if (hdaps_invert & HDAPS_Y_AXIS)
		*y = -*y;

	return 0;
}

/*
 * hdaps_read_pair - reads the values from a pair of ports, placing the values
 * in the given pointers.  Returns zero on success.  Can sleep.
 */
static int hdaps_read_pair(unsigned int port1, unsigned int port2,
			   int *val1, int *val2)
{
	int ret;

	mutex_lock(&hdaps_mtx);
	ret = __hdaps_read_pair(port1, port2, val1, val2);
	mutex_unlock(&hdaps_mtx);

	return ret;
}

/*
 * hdaps_device_init - initialize the accelerometer.  Returns zero on success
 * and negative error code on failure.  Can sleep.
 */
static int hdaps_device_init(void)
{
	int total, ret = -ENXIO;

	mutex_lock(&hdaps_mtx);

	outb(0x13, 0x1610);
	outb(0x01, 0x161f);
	if (__wait_latch(0x161f, 0x00))
		goto out;

	/*
	 * Most ThinkPads return 0x01.
	 *
	 * Others--namely the R50p, T41p, and T42p--return 0x03.  These laptops
	 * have "inverted" axises.
	 *
	 * The 0x02 value occurs when the chip has been previously initialized.
	 */
	if (__check_latch(0x1611, 0x03) &&
		     __check_latch(0x1611, 0x02) &&
		     __check_latch(0x1611, 0x01))
		goto out;

	printk(KERN_DEBUG "hdaps: initial latch check good (0x%02x).\n",
	       __get_latch(0x1611));

	outb(0x17, 0x1610);
	outb(0x81, 0x1611);
	outb(0x01, 0x161f);
	if (__wait_latch(0x161f, 0x00))
		goto out;
	if (__wait_latch(0x1611, 0x00))
		goto out;
	if (__wait_latch(0x1612, 0x60))
		goto out;
	if (__wait_latch(0x1613, 0x00))
		goto out;
	outb(0x14, 0x1610);
	outb(0x01, 0x1611);
	outb(0x01, 0x161f);
	if (__wait_latch(0x161f, 0x00))
		goto out;
	outb(0x10, 0x1610);
	outb(0xc8, 0x1611);
	outb(0x00, 0x1612);
	outb(0x02, 0x1613);
	outb(0x01, 0x161f);
	if (__wait_latch(0x161f, 0x00))
		goto out;
	if (__device_refresh_sync())
		goto out;
	if (__wait_latch(0x1611, 0x00))
		goto out;

	/* we have done our dance, now let's wait for the applause */
	for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
		int x, y;

		/* a read of the device helps push it into action */
		__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
		if (!__wait_latch(0x1611, 0x02)) {
			ret = 0;
			break;
		}

		msleep(INIT_WAIT_MSECS);
	}

out:
	mutex_unlock(&hdaps_mtx);
	return ret;
}


/* Device model stuff */

static int hdaps_probe(struct platform_device *dev)
{
	int ret;

	ret = hdaps_device_init();
	if (ret)
		return ret;

	printk(KERN_INFO "hdaps: device successfully initialized.\n");
	return 0;
}

static int hdaps_resume(struct platform_device *dev)
{
	return hdaps_device_init();
}

static struct platform_driver hdaps_driver = {
	.probe = hdaps_probe,
	.resume = hdaps_resume,
	.driver	= {
		.name = "hdaps",
		.owner = THIS_MODULE,
	},
};

/*
 * hdaps_calibrate - Set our "resting" values.  Callers must hold hdaps_mtx.
 */
static void hdaps_calibrate(void)
{
	__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &rest_x, &rest_y);
}

static void hdaps_mousedev_poll(struct input_polled_dev *dev)
{
	struct input_dev *input_dev = dev->input;
	int x, y;

	mutex_lock(&hdaps_mtx);

	if (__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y))
		goto out;

	input_report_abs(input_dev, ABS_X, x - rest_x);
	input_report_abs(input_dev, ABS_Y, y - rest_y);
	input_sync(input_dev);

out:
	mutex_unlock(&hdaps_mtx);
}


/* Sysfs Files */

static ssize_t hdaps_position_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	int ret, x, y;

	ret = hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
	if (ret)
		return ret;

	return sprintf(buf, "(%d,%d)\n", x, y);
}

static ssize_t hdaps_variance_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	int ret, x, y;

	ret = hdaps_read_pair(HDAPS_PORT_XVAR, HDAPS_PORT_YVAR, &x, &y);
	if (ret)
		return ret;

	return sprintf(buf, "(%d,%d)\n", x, y);
}

static ssize_t hdaps_temp1_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	u8 temp;
	int ret;

	ret = hdaps_readb_one(HDAPS_PORT_TEMP1, &temp);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%u\n", temp);
}

static ssize_t hdaps_temp2_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	u8 temp;
	int ret;

	ret = hdaps_readb_one(HDAPS_PORT_TEMP2, &temp);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%u\n", temp);
}

static ssize_t hdaps_keyboard_activity_show(struct device *dev,
					    struct device_attribute *attr,
					    char *buf)
{
	return sprintf(buf, "%u\n", KEYBD_ISSET(km_activity));
}

static ssize_t hdaps_mouse_activity_show(struct device *dev,
					 struct device_attribute *attr,
					 char *buf)
{
	return sprintf(buf, "%u\n", MOUSE_ISSET(km_activity));
}

static ssize_t hdaps_calibrate_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "(%d,%d)\n", rest_x, rest_y);
}

static ssize_t hdaps_calibrate_store(struct device *dev,
				     struct device_attribute *attr,
				     const char *buf, size_t count)
{
	mutex_lock(&hdaps_mtx);
	hdaps_calibrate();
	mutex_unlock(&hdaps_mtx);

	return count;
}

static ssize_t hdaps_invert_show(struct device *dev,
				 struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%u\n", hdaps_invert);
}

static ssize_t hdaps_invert_store(struct device *dev,
				  struct device_attribute *attr,
				  const char *buf, size_t count)
{
	int invert;

	if (sscanf(buf, "%d", &invert) != 1 ||
	    invert < 0 || invert > HDAPS_BOTH_AXES)
		return -EINVAL;

	hdaps_invert = invert;
	hdaps_calibrate();

	return count;
}

static DEVICE_ATTR(position, 0444, hdaps_position_show, NULL);
static DEVICE_ATTR(variance, 0444, hdaps_variance_show, NULL);
static DEVICE_ATTR(temp1, 0444, hdaps_temp1_show, NULL);
static DEVICE_ATTR(temp2, 0444, hdaps_temp2_show, NULL);
static DEVICE_ATTR(keyboard_activity, 0444, hdaps_keyboard_activity_show, NULL);
static DEVICE_ATTR(mouse_activity, 0444, hdaps_mouse_activity_show, NULL);
static DEVICE_ATTR(calibrate, 0644, hdaps_calibrate_show,hdaps_calibrate_store);
static DEVICE_ATTR(invert, 0644, hdaps_invert_show, hdaps_invert_store);

static struct attribute *hdaps_attributes[] = {
	&dev_attr_position.attr,
	&dev_attr_variance.attr,
	&dev_attr_temp1.attr,
	&dev_attr_temp2.attr,
	&dev_attr_keyboard_activity.attr,
	&dev_attr_mouse_activity.attr,
	&dev_attr_calibrate.attr,
	&dev_attr_invert.attr,
	NULL,
};

static struct attribute_group hdaps_attribute_group = {
	.attrs = hdaps_attributes,
};


/* Module stuff */

/* hdaps_dmi_match - found a match.  return one, short-circuiting the hunt. */
static int __init hdaps_dmi_match(const struct dmi_system_id *id)
{
	printk(KERN_INFO "hdaps: %s detected.\n", id->ident);
	return 1;
}

/* hdaps_dmi_match_invert - found an inverted match. */
static int __init hdaps_dmi_match_invert(const struct dmi_system_id *id)
{
	hdaps_invert = (unsigned long)id->driver_data;
	printk(KERN_INFO "hdaps: inverting axis (%u) readings.\n",
	       hdaps_invert);
	return hdaps_dmi_match(id);
}

#define HDAPS_DMI_MATCH_INVERT(vendor, model, axes) {	\
	.ident = vendor " " model,			\
	.callback = hdaps_dmi_match_invert,		\
	.driver_data = (void *)axes,			\
	.matches = {					\
		DMI_MATCH(DMI_BOARD_VENDOR, vendor),	\
		DMI_MATCH(DMI_PRODUCT_VERSION, model)	\
	}						\
}

#define HDAPS_DMI_MATCH_NORMAL(vendor, model)		\
	HDAPS_DMI_MATCH_INVERT(vendor, model, 0)

/* Note that HDAPS_DMI_MATCH_NORMAL("ThinkPad T42") would match
   "ThinkPad T42p", so the order of the entries matters.
   If your ThinkPad is not recognized, please update to latest
   BIOS. This is especially the case for some R52 ThinkPads. */
static struct dmi_system_id __initdata hdaps_whitelist[] = {
	HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad R50p", HDAPS_BOTH_AXES),
	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R50"),
	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R51"),
	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R52"),
	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61i", HDAPS_BOTH_AXES),
	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61", HDAPS_BOTH_AXES),
	HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T41p", HDAPS_BOTH_AXES),
	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T41"),
	HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T42p", HDAPS_BOTH_AXES),
	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T42"),
	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T43"),
	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T400", HDAPS_BOTH_AXES),
	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T60", HDAPS_BOTH_AXES),
	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61p", HDAPS_BOTH_AXES),
	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61", HDAPS_BOTH_AXES),
	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad X40"),
	HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad X41", HDAPS_Y_AXIS),
	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X60", HDAPS_BOTH_AXES),
	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61s", HDAPS_BOTH_AXES),
	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61", HDAPS_BOTH_AXES),
	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad Z60m"),
	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61m", HDAPS_BOTH_AXES),
	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61p", HDAPS_BOTH_AXES),
	{ .ident = NULL }
};

static int __init hdaps_init(void)
{
	struct input_dev *idev;
	int ret;

	if (!dmi_check_system(hdaps_whitelist)) {
		printk(KERN_WARNING "hdaps: supported laptop not found!\n");
		ret = -ENODEV;
		goto out;
	}

	if (!request_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS, "hdaps")) {
		ret = -ENXIO;
		goto out;
	}

	ret = platform_driver_register(&hdaps_driver);
	if (ret)
		goto out_region;

	pdev = platform_device_register_simple("hdaps", -1, NULL, 0);
	if (IS_ERR(pdev)) {
		ret = PTR_ERR(pdev);
		goto out_driver;
	}

	ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group);
	if (ret)
		goto out_device;

	hdaps_idev = input_allocate_polled_device();
	if (!hdaps_idev) {
		ret = -ENOMEM;
		goto out_group;
	}

	hdaps_idev->poll = hdaps_mousedev_poll;
	hdaps_idev->poll_interval = HDAPS_POLL_INTERVAL;

	/* initial calibrate for the input device */
	hdaps_calibrate();

	/* initialize the input class */
	idev = hdaps_idev->input;
	idev->name = "hdaps";
	idev->phys = "isa1600/input0";
	idev->id.bustype = BUS_ISA;
	idev->dev.parent = &pdev->dev;
	idev->evbit[0] = BIT_MASK(EV_ABS);
	input_set_abs_params(idev, ABS_X,
			-256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
	input_set_abs_params(idev, ABS_Y,
			-256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);

	ret = input_register_polled_device(hdaps_idev);
	if (ret)
		goto out_idev;

	printk(KERN_INFO "hdaps: driver successfully loaded.\n");
	return 0;

out_idev:
	input_free_polled_device(hdaps_idev);
out_group:
	sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
out_device:
	platform_device_unregister(pdev);
out_driver:
	platform_driver_unregister(&hdaps_driver);
out_region:
	release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
out:
	printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret);
	return ret;
}

static void __exit hdaps_exit(void)
{
	input_unregister_polled_device(hdaps_idev);
	input_free_polled_device(hdaps_idev);
	sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
	platform_device_unregister(pdev);
	platform_driver_unregister(&hdaps_driver);
	release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);

	printk(KERN_INFO "hdaps: driver unloaded.\n");
}

module_init(hdaps_init);
module_exit(hdaps_exit);

module_param_named(invert, hdaps_invert, int, 0);
MODULE_PARM_DESC(invert, "invert data along each axis. 1 invert x-axis, "
		 "2 invert y-axis, 3 invert both axes.");

MODULE_AUTHOR("Robert Love");
MODULE_DESCRIPTION("IBM Hard Drive Active Protection System (HDAPS) driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
860e1d6b RL	1	/*
	2	* drivers/hwmon/hdaps.c - driver for IBM's Hard Drive Active Protection System
	3	*
	4	* Copyright (C) 2005 Robert Love <rml@novell.com>
	5	* Copyright (C) 2005 Jesper Juhl <jesper.juhl@gmail.com>
	6	*
4c87b74c RL	7	* The HardDisk Active Protection System (hdaps) is present in IBM ThinkPads
	8	* starting with the R40, T41, and X40. It provides a basic two-axis
	9	* accelerometer and other data, such as the device's temperature.
860e1d6b	10	*
393ad299	11	* This driver is based on the document by Mark A. Smith available at
860e1d6b RL	12	* http://www.almaden.ibm.com/cs/people/marksmith/tpaps.html and a lot of trial
	13	* and error.
	14	*
	15	* This program is free software; you can redistribute it and/or modify it
	16	* under the terms of the GNU General Public License v2 as published by the
	17	* Free Software Foundation.
	18	*
	19	* This program is distributed in the hope that it will be useful, but WITHOUT
	20	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	21	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	22	* more details.
	23	*
	24	* You should have received a copy of the GNU General Public License along with
	25	* this program; if not, write to the Free Software Foundation, Inc.,
	26	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
	27	*/
	28
	29	#include <linux/delay.h>
d052d1be	30	#include <linux/platform_device.h>
aefca8ba	31	#include <linux/input-polldev.h>
860e1d6b	32	#include <linux/kernel.h>
6acc369a	33	#include <linux/mutex.h>
860e1d6b RL	34	#include <linux/module.h>
	35	#include <linux/timer.h>
	36	#include <linux/dmi.h>
914e2637	37	#include <linux/jiffies.h>
6055fae8	38	#include <linux/io.h>
860e1d6b RL	39
860e1d6b RL	40	#define HDAPS_LOW_PORT 0x1600 /* first port used by hdaps */
393ad299	41	#define HDAPS_NR_PORTS 0x30 /* number of ports: 0x1600 - 0x162f */
860e1d6b RL	42
	43	#define HDAPS_PORT_STATE 0x1611 /* device state */
	44	#define HDAPS_PORT_YPOS 0x1612 /* y-axis position */
	45	#define HDAPS_PORT_XPOS 0x1614 /* x-axis position */
0a704681	46	#define HDAPS_PORT_TEMP1 0x1616 /* device temperature, in Celsius */
860e1d6b RL	47	#define HDAPS_PORT_YVAR 0x1617 /* y-axis variance (what is this?) */
	48	#define HDAPS_PORT_XVAR 0x1619 /* x-axis variance (what is this?) */
	49	#define HDAPS_PORT_TEMP2 0x161b /* device temperature (again?) */
	50	#define HDAPS_PORT_UNKNOWN 0x161c /* what is this? */
	51	#define HDAPS_PORT_KMACT 0x161d /* keyboard or mouse activity */
	52
393ad299	53	#define STATE_FRESH 0x50 /* accelerometer data is fresh */
860e1d6b RL	54
	55	#define KEYBD_MASK 0x20 /* set if keyboard activity */
	56	#define MOUSE_MASK 0x40 /* set if mouse activity */
	57	#define KEYBD_ISSET(n) (!! (n & KEYBD_MASK)) /* keyboard used? */
	58	#define MOUSE_ISSET(n) (!! (n & MOUSE_MASK)) /* mouse used? */
	59
	60	#define INIT_TIMEOUT_MSECS 4000 /* wait up to 4s for device init ... */
	61	#define INIT_WAIT_MSECS 200 /* ... in 200ms increments */
	62
aefca8ba	63	#define HDAPS_POLL_INTERVAL 50 /* poll for input every 1/20s (50 ms)*/
393ad299	64	#define HDAPS_INPUT_FUZZ 4 /* input event threshold */
d12eb7e1	65	#define HDAPS_INPUT_FLAT 4
393ad299	66
2b8cf3e8 FS	67	#define HDAPS_X_AXIS (1 << 0)
	68	#define HDAPS_Y_AXIS (1 << 1)
	69	#define HDAPS_BOTH_AXES (HDAPS_X_AXIS \| HDAPS_Y_AXIS)
	70
393ad299	71	static struct platform_device *pdev;
aefca8ba	72	static struct input_polled_dev *hdaps_idev;
860e1d6b RL	73	static unsigned int hdaps_invert;
	74	static u8 km_activity;
	75	static int rest_x;
	76	static int rest_y;
	77
6acc369a	78	static DEFINE_MUTEX(hdaps_mtx);
860e1d6b RL	79
860e1d6b RL	80	/*
6acc369a	81	* __get_latch - Get the value from a given port. Callers must hold hdaps_mtx.
860e1d6b RL	82	*/
	83	static inline u8 __get_latch(u16 port)
	84	{
393ad299	85	return inb(port) & 0xff;
860e1d6b RL	86	}
	87
	88	/*
393ad299	89	* __check_latch - Check a port latch for a given value. Returns zero if the
6acc369a	90	* port contains the given value. Callers must hold hdaps_mtx.
860e1d6b	91	*/
393ad299	92	static inline int __check_latch(u16 port, u8 val)
860e1d6b RL	93	{
	94	if (__get_latch(port) == val)
	95	return 0;
	96	return -EINVAL;
	97	}
	98
	99	/*
	100	* __wait_latch - Wait up to 100us for a port latch to get a certain value,
6acc369a	101	* returning zero if the value is obtained. Callers must hold hdaps_mtx.
860e1d6b	102	*/
393ad299	103	static int __wait_latch(u16 port, u8 val)
860e1d6b RL	104	{
	105	unsigned int i;
	106
	107	for (i = 0; i < 20; i++) {
	108	if (!__check_latch(port, val))
	109	return 0;
	110	udelay(5);
	111	}
	112
393ad299	113	return -EIO;
860e1d6b RL	114	}
	115
	116	/*
393ad299	117	* __device_refresh - request a refresh from the accelerometer. Does not wait
6acc369a	118	* for refresh to complete. Callers must hold hdaps_mtx.
860e1d6b	119	*/
393ad299	120	static void __device_refresh(void)
860e1d6b	121	{
393ad299 RL	122	udelay(200);
	123	if (inb(0x1604) != STATE_FRESH) {
	124	outb(0x11, 0x1610);
	125	outb(0x01, 0x161f);
	126	}
	127	}
860e1d6b	128
393ad299 RL	129	/*
	130	* __device_refresh_sync - request a synchronous refresh from the
	131	* accelerometer. We wait for the refresh to complete. Returns zero if
6acc369a	132	* successful and nonzero on error. Callers must hold hdaps_mtx.
393ad299 RL	133	*/
	134	static int __device_refresh_sync(void)
	135	{
	136	__device_refresh();
860e1d6b RL	137	return __wait_latch(0x1604, STATE_FRESH);
	138	}
	139
	140	/*
393ad299	141	* __device_complete - indicate to the accelerometer that we are done reading
6acc369a	142	* data, and then initiate an async refresh. Callers must hold hdaps_mtx.
860e1d6b RL	143	*/
	144	static inline void __device_complete(void)
	145	{
	146	inb(0x161f);
	147	inb(0x1604);
393ad299	148	__device_refresh();
860e1d6b RL	149	}
	150
	151	/*
	152	* hdaps_readb_one - reads a byte from a single I/O port, placing the value in
	153	* the given pointer. Returns zero on success or a negative error on failure.
	154	* Can sleep.
	155	*/
	156	static int hdaps_readb_one(unsigned int port, u8 *val)
	157	{
	158	int ret;
	159
6acc369a	160	mutex_lock(&hdaps_mtx);
860e1d6b	161
393ad299 RL	162	/* do a sync refresh -- we need to be sure that we read fresh data */
	163	ret = __device_refresh_sync();
	164	if (ret)
	165	goto out;
	166
	167	*val = inb(port);
	168	__device_complete();
	169
	170	out:
6acc369a	171	mutex_unlock(&hdaps_mtx);
860e1d6b RL	172	return ret;
	173	}
	174
393ad299	175	/* __hdaps_read_pair - internal lockless helper for hdaps_read_pair(). */
860e1d6b RL	176	static int __hdaps_read_pair(unsigned int port1, unsigned int port2,
	177	int x, int y)
	178	{
	179	/* do a sync refresh -- we need to be sure that we read fresh data */
393ad299	180	if (__device_refresh_sync())
860e1d6b RL	181	return -EIO;
	182
	183	*y = inw(port2);
	184	*x = inw(port1);
	185	km_activity = inb(HDAPS_PORT_KMACT);
	186	__device_complete();
	187
2b8cf3e8 FS	188	/* hdaps_invert is a bitvector to negate the axes */
2b8cf3e8 FS	189	if (hdaps_invert & HDAPS_X_AXIS)
860e1d6b	190	x = -x;
2b8cf3e8	191	if (hdaps_invert & HDAPS_Y_AXIS)
860e1d6b	192	y = -y;
860e1d6b RL	193
	194	return 0;
	195	}
	196
	197	/*
	198	* hdaps_read_pair - reads the values from a pair of ports, placing the values
	199	* in the given pointers. Returns zero on success. Can sleep.
	200	*/
	201	static int hdaps_read_pair(unsigned int port1, unsigned int port2,
	202	int val1, int val2)
	203	{
	204	int ret;
	205
6acc369a	206	mutex_lock(&hdaps_mtx);
860e1d6b	207	ret = __hdaps_read_pair(port1, port2, val1, val2);
6acc369a	208	mutex_unlock(&hdaps_mtx);
860e1d6b RL	209
	210	return ret;
	211	}
	212
393ad299 RL	213	/*
	214	* hdaps_device_init - initialize the accelerometer. Returns zero on success
	215	* and negative error code on failure. Can sleep.
	216	*/
860e1d6b RL	217	static int hdaps_device_init(void)
860e1d6b RL	218	{
393ad299	219	int total, ret = -ENXIO;
860e1d6b	220
6acc369a	221	mutex_lock(&hdaps_mtx);
860e1d6b RL	222
	223	outb(0x13, 0x1610);
	224	outb(0x01, 0x161f);
	225	if (__wait_latch(0x161f, 0x00))
	226	goto out;
	227
	228	/*
393ad299 RL	229	* Most ThinkPads return 0x01.
	230	*
	231	* Others--namely the R50p, T41p, and T42p--return 0x03. These laptops
	232	* have "inverted" axises.
860e1d6b RL	233	*
	234	* The 0x02 value occurs when the chip has been previously initialized.
	235	*/
	236	if (__check_latch(0x1611, 0x03) &&
	237	__check_latch(0x1611, 0x02) &&
	238	__check_latch(0x1611, 0x01))
	239	goto out;
	240
	241	printk(KERN_DEBUG "hdaps: initial latch check good (0x%02x).\n",
	242	__get_latch(0x1611));
	243
	244	outb(0x17, 0x1610);
	245	outb(0x81, 0x1611);
	246	outb(0x01, 0x161f);
	247	if (__wait_latch(0x161f, 0x00))
	248	goto out;
	249	if (__wait_latch(0x1611, 0x00))
	250	goto out;
	251	if (__wait_latch(0x1612, 0x60))
	252	goto out;
	253	if (__wait_latch(0x1613, 0x00))
	254	goto out;
	255	outb(0x14, 0x1610);
	256	outb(0x01, 0x1611);
	257	outb(0x01, 0x161f);
	258	if (__wait_latch(0x161f, 0x00))
	259	goto out;
	260	outb(0x10, 0x1610);
	261	outb(0xc8, 0x1611);
	262	outb(0x00, 0x1612);
	263	outb(0x02, 0x1613);
	264	outb(0x01, 0x161f);
	265	if (__wait_latch(0x161f, 0x00))
	266	goto out;
393ad299	267	if (__device_refresh_sync())
860e1d6b RL	268	goto out;
	269	if (__wait_latch(0x1611, 0x00))
	270	goto out;
	271
	272	/* we have done our dance, now let's wait for the applause */
393ad299 RL	273	for (total = INIT_TIMEOUT_MSECS; total > 0; total -= INIT_WAIT_MSECS) {
393ad299 RL	274	int x, y;
860e1d6b RL	275
860e1d6b RL	276	/* a read of the device helps push it into action */
393ad299	277	__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
860e1d6b RL	278	if (!__wait_latch(0x1611, 0x02)) {
	279	ret = 0;
	280	break;
	281	}
	282
	283	msleep(INIT_WAIT_MSECS);
860e1d6b RL	284	}
	285
	286	out:
6acc369a	287	mutex_unlock(&hdaps_mtx);
860e1d6b RL	288	return ret;
	289	}
	290
	291
860e1d6b RL	292	/* Device model stuff */
860e1d6b RL	293
3ae5eaec	294	static int hdaps_probe(struct platform_device *dev)
860e1d6b RL	295	{
	296	int ret;
	297
	298	ret = hdaps_device_init();
	299	if (ret)
	300	return ret;
	301
	302	printk(KERN_INFO "hdaps: device successfully initialized.\n");
	303	return 0;
	304	}
	305
3ae5eaec	306	static int hdaps_resume(struct platform_device *dev)
860e1d6b	307	{
9480e307	308	return hdaps_device_init();
860e1d6b RL	309	}
860e1d6b RL	310
3ae5eaec	311	static struct platform_driver hdaps_driver = {
860e1d6b	312	.probe = hdaps_probe,
3ae5eaec RK	313	.resume = hdaps_resume,
	314	.driver = {
	315	.name = "hdaps",
	316	.owner = THIS_MODULE,
	317	},
860e1d6b RL	318	};
860e1d6b RL	319
393ad299	320	/*
6acc369a	321	* hdaps_calibrate - Set our "resting" values. Callers must hold hdaps_mtx.
393ad299 RL	322	*/
	323	static void hdaps_calibrate(void)
	324	{
	325	__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &rest_x, &rest_y);
	326	}
	327
aefca8ba	328	static void hdaps_mousedev_poll(struct input_polled_dev *dev)
393ad299	329	{
aefca8ba	330	struct input_dev *input_dev = dev->input;
393ad299 RL	331	int x, y;
393ad299 RL	332
aefca8ba	333	mutex_lock(&hdaps_mtx);
393ad299 RL	334
	335	if (__hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y))
	336	goto out;
	337
aefca8ba DT	338	input_report_abs(input_dev, ABS_X, x - rest_x);
	339	input_report_abs(input_dev, ABS_Y, y - rest_y);
	340	input_sync(input_dev);
393ad299 RL	341
393ad299 RL	342	out:
6acc369a	343	mutex_unlock(&hdaps_mtx);
393ad299 RL	344	}
393ad299 RL	345
860e1d6b RL	346
	347	/* Sysfs Files */
	348
	349	static ssize_t hdaps_position_show(struct device *dev,
	350	struct device_attribute attr, char buf)
	351	{
	352	int ret, x, y;
	353
	354	ret = hdaps_read_pair(HDAPS_PORT_XPOS, HDAPS_PORT_YPOS, &x, &y);
	355	if (ret)
	356	return ret;
	357
	358	return sprintf(buf, "(%d,%d)\n", x, y);
	359	}
	360
	361	static ssize_t hdaps_variance_show(struct device *dev,
	362	struct device_attribute attr, char buf)
	363	{
	364	int ret, x, y;
	365
	366	ret = hdaps_read_pair(HDAPS_PORT_XVAR, HDAPS_PORT_YVAR, &x, &y);
	367	if (ret)
	368	return ret;
	369
	370	return sprintf(buf, "(%d,%d)\n", x, y);
	371	}
	372
	373	static ssize_t hdaps_temp1_show(struct device *dev,
	374	struct device_attribute attr, char buf)
	375	{
	376	u8 temp;
	377	int ret;
	378
	379	ret = hdaps_readb_one(HDAPS_PORT_TEMP1, &temp);
	380	if (ret < 0)
	381	return ret;
	382
	383	return sprintf(buf, "%u\n", temp);
	384	}
	385
	386	static ssize_t hdaps_temp2_show(struct device *dev,
	387	struct device_attribute attr, char buf)
	388	{
	389	u8 temp;
	390	int ret;
	391
	392	ret = hdaps_readb_one(HDAPS_PORT_TEMP2, &temp);
	393	if (ret < 0)
	394	return ret;
	395
	396	return sprintf(buf, "%u\n", temp);
	397	}
	398
	399	static ssize_t hdaps_keyboard_activity_show(struct device *dev,
	400	struct device_attribute *attr,
	401	char *buf)
	402	{
	403	return sprintf(buf, "%u\n", KEYBD_ISSET(km_activity));
	404	}
	405
	406	static ssize_t hdaps_mouse_activity_show(struct device *dev,
	407	struct device_attribute *attr,
	408	char *buf)
	409	{
410	return sprintf(buf, "%u\n", MOUSE_ISSET(km_activity));
411	}
412
413	static ssize_t hdaps_calibrate_show(struct device *dev,
414	struct device_attribute attr, char buf)
415	{
416	return sprintf(buf, "(%d,%d)\n", rest_x, rest_y);
417	}
418
419	static ssize_t hdaps_calibrate_store(struct device *dev,
420	struct device_attribute *attr,
421	const char *buf, size_t count)
422	{
6acc369a	423	mutex_lock(&hdaps_mtx);
860e1d6b	424	hdaps_calibrate();
6acc369a	425	mutex_unlock(&hdaps_mtx);
860e1d6b RL	426
	427	return count;
	428	}
	429
	430	static ssize_t hdaps_invert_show(struct device *dev,
	431	struct device_attribute attr, char buf)
	432	{
	433	return sprintf(buf, "%u\n", hdaps_invert);
	434	}
	435
	436	static ssize_t hdaps_invert_store(struct device *dev,
	437	struct device_attribute *attr,
	438	const char *buf, size_t count)
	439	{
	440	int invert;
	441
2b8cf3e8 FS	442	if (sscanf(buf, "%d", &invert) != 1 \|\|
2b8cf3e8 FS	443	invert < 0 \|\| invert > HDAPS_BOTH_AXES)
860e1d6b RL	444	return -EINVAL;
	445
	446	hdaps_invert = invert;
	447	hdaps_calibrate();
	448
	449	return count;
	450	}
	451
860e1d6b RL	452	static DEVICE_ATTR(position, 0444, hdaps_position_show, NULL);
	453	static DEVICE_ATTR(variance, 0444, hdaps_variance_show, NULL);
	454	static DEVICE_ATTR(temp1, 0444, hdaps_temp1_show, NULL);
	455	static DEVICE_ATTR(temp2, 0444, hdaps_temp2_show, NULL);
	456	static DEVICE_ATTR(keyboard_activity, 0444, hdaps_keyboard_activity_show, NULL);
	457	static DEVICE_ATTR(mouse_activity, 0444, hdaps_mouse_activity_show, NULL);
	458	static DEVICE_ATTR(calibrate, 0644, hdaps_calibrate_show,hdaps_calibrate_store);
	459	static DEVICE_ATTR(invert, 0644, hdaps_invert_show, hdaps_invert_store);
860e1d6b RL	460
	461	static struct attribute *hdaps_attributes[] = {
	462	&dev_attr_position.attr,
	463	&dev_attr_variance.attr,
	464	&dev_attr_temp1.attr,
	465	&dev_attr_temp2.attr,
	466	&dev_attr_keyboard_activity.attr,
	467	&dev_attr_mouse_activity.attr,
	468	&dev_attr_calibrate.attr,
860e1d6b RL	469	&dev_attr_invert.attr,
	470	NULL,
	471	};
	472
	473	static struct attribute_group hdaps_attribute_group = {
	474	.attrs = hdaps_attributes,
	475	};
	476
	477
	478	/* Module stuff */
	479
4c87b74c	480	/* hdaps_dmi_match - found a match. return one, short-circuiting the hunt. */
1855256c	481	static int __init hdaps_dmi_match(const struct dmi_system_id *id)
860e1d6b RL	482	{
860e1d6b RL	483	printk(KERN_INFO "hdaps: %s detected.\n", id->ident);
4c87b74c	484	return 1;
860e1d6b RL	485	}
860e1d6b RL	486
4c87b74c	487	/* hdaps_dmi_match_invert - found an inverted match. */
1855256c	488	static int __init hdaps_dmi_match_invert(const struct dmi_system_id *id)
860e1d6b	489	{
2b8cf3e8 FS	490	hdaps_invert = (unsigned long)id->driver_data;
	491	printk(KERN_INFO "hdaps: inverting axis (%u) readings.\n",
	492	hdaps_invert);
4c87b74c	493	return hdaps_dmi_match(id);
860e1d6b RL	494	}
860e1d6b RL	495
2b8cf3e8	496	#define HDAPS_DMI_MATCH_INVERT(vendor, model, axes) { \
509a5e85	497	.ident = vendor " " model, \
860e1d6b	498	.callback = hdaps_dmi_match_invert, \
2b8cf3e8	499	.driver_data = (void *)axes, \
860e1d6b	500	.matches = { \
509a5e85	501	DMI_MATCH(DMI_BOARD_VENDOR, vendor), \
860e1d6b RL	502	DMI_MATCH(DMI_PRODUCT_VERSION, model) \
	503	} \
	504	}
	505
2b8cf3e8 FS	506	#define HDAPS_DMI_MATCH_NORMAL(vendor, model) \
	507	HDAPS_DMI_MATCH_INVERT(vendor, model, 0)
	508
509a5e85	509	/* Note that HDAPS_DMI_MATCH_NORMAL("ThinkPad T42") would match
0f23e50a SB	510	"ThinkPad T42p", so the order of the entries matters.
	511	If your ThinkPad is not recognized, please update to latest
	512	BIOS. This is especially the case for some R52 ThinkPads. */
509a5e85	513	static struct dmi_system_id __initdata hdaps_whitelist[] = {
2b8cf3e8	514	HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad R50p", HDAPS_BOTH_AXES),
509a5e85 JD	515	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R50"),
	516	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R51"),
	517	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad R52"),
2b8cf3e8 FS	518	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61i", HDAPS_BOTH_AXES),
	519	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad R61", HDAPS_BOTH_AXES),
	520	HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T41p", HDAPS_BOTH_AXES),
509a5e85	521	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T41"),
2b8cf3e8	522	HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad T42p", HDAPS_BOTH_AXES),
509a5e85 JD	523	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T42"),
509a5e85 JD	524	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad T43"),
5f1209a1	525	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T400", HDAPS_BOTH_AXES),
2b8cf3e8 FS	526	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T60", HDAPS_BOTH_AXES),
	527	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61p", HDAPS_BOTH_AXES),
	528	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad T61", HDAPS_BOTH_AXES),
509a5e85	529	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad X40"),
b6a33fe2	530	HDAPS_DMI_MATCH_INVERT("IBM", "ThinkPad X41", HDAPS_Y_AXIS),
2b8cf3e8 FS	531	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X60", HDAPS_BOTH_AXES),
	532	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61s", HDAPS_BOTH_AXES),
	533	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad X61", HDAPS_BOTH_AXES),
509a5e85	534	HDAPS_DMI_MATCH_NORMAL("IBM", "ThinkPad Z60m"),
2b8cf3e8 FS	535	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61m", HDAPS_BOTH_AXES),
2b8cf3e8 FS	536	HDAPS_DMI_MATCH_INVERT("LENOVO", "ThinkPad Z61p", HDAPS_BOTH_AXES),
509a5e85 JD	537	{ .ident = NULL }
509a5e85 JD	538	};
0f6c840d	539
860e1d6b RL	540	static int __init hdaps_init(void)
860e1d6b RL	541	{
aefca8ba	542	struct input_dev *idev;
860e1d6b RL	543	int ret;
860e1d6b RL	544
860e1d6b RL	545	if (!dmi_check_system(hdaps_whitelist)) {
860e1d6b RL	546	printk(KERN_WARNING "hdaps: supported laptop not found!\n");
b3f28a9a	547	ret = -ENODEV;
860e1d6b RL	548	goto out;
	549	}
	550
	551	if (!request_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS, "hdaps")) {
	552	ret = -ENXIO;
	553	goto out;
	554	}
	555
3ae5eaec	556	ret = platform_driver_register(&hdaps_driver);
860e1d6b RL	557	if (ret)
	558	goto out_region;
	559
	560	pdev = platform_device_register_simple("hdaps", -1, NULL, 0);
	561	if (IS_ERR(pdev)) {
	562	ret = PTR_ERR(pdev);
	563	goto out_driver;
	564	}
	565
	566	ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group);
	567	if (ret)
	568	goto out_device;
	569
aefca8ba	570	hdaps_idev = input_allocate_polled_device();
d12eb7e1 DT	571	if (!hdaps_idev) {
	572	ret = -ENOMEM;
	573	goto out_group;
	574	}
	575
aefca8ba DT	576	hdaps_idev->poll = hdaps_mousedev_poll;
	577	hdaps_idev->poll_interval = HDAPS_POLL_INTERVAL;
	578
393ad299 RL	579	/* initial calibrate for the input device */
	580	hdaps_calibrate();
	581
	582	/* initialize the input class */
aefca8ba DT	583	idev = hdaps_idev->input;
aefca8ba DT	584	idev->name = "hdaps";
d2fc60d6 DT	585	idev->phys = "isa1600/input0";
d2fc60d6 DT	586	idev->id.bustype = BUS_ISA;
aefca8ba	587	idev->dev.parent = &pdev->dev;
7b19ada2	588	idev->evbit[0] = BIT_MASK(EV_ABS);
aefca8ba	589	input_set_abs_params(idev, ABS_X,
d12eb7e1	590	-256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
aefca8ba	591	input_set_abs_params(idev, ABS_Y,
d12eb7e1 DT	592	-256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT);
d12eb7e1 DT	593
aefca8ba	594	ret = input_register_polled_device(hdaps_idev);
b25a1063 DT	595	if (ret)
b25a1063 DT	596	goto out_idev;
393ad299	597
860e1d6b RL	598	printk(KERN_INFO "hdaps: driver successfully loaded.\n");
	599	return 0;
	600
b25a1063	601	out_idev:
aefca8ba	602	input_free_polled_device(hdaps_idev);
d12eb7e1 DT	603	out_group:
d12eb7e1 DT	604	sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
860e1d6b RL	605	out_device:
	606	platform_device_unregister(pdev);
	607	out_driver:
3ae5eaec	608	platform_driver_unregister(&hdaps_driver);
860e1d6b RL	609	out_region:
	610	release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
	611	out:
	612	printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret);
	613	return ret;
	614	}
	615
	616	static void __exit hdaps_exit(void)
	617	{
aefca8ba DT	618	input_unregister_polled_device(hdaps_idev);
aefca8ba DT	619	input_free_polled_device(hdaps_idev);
860e1d6b RL	620	sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group);
860e1d6b RL	621	platform_device_unregister(pdev);
3ae5eaec	622	platform_driver_unregister(&hdaps_driver);
860e1d6b RL	623	release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
	624
	625	printk(KERN_INFO "hdaps: driver unloaded.\n");
	626	}
	627
	628	module_init(hdaps_init);
	629	module_exit(hdaps_exit);
	630
2b8cf3e8 FS	631	module_param_named(invert, hdaps_invert, int, 0);
	632	MODULE_PARM_DESC(invert, "invert data along each axis. 1 invert x-axis, "
	633	"2 invert y-axis, 3 invert both axes.");
860e1d6b RL	634
	635	MODULE_AUTHOR("Robert Love");
	636	MODULE_DESCRIPTION("IBM Hard Drive Active Protection System (HDAPS) driver");
	637	MODULE_LICENSE("GPL v2");