[deliverable/linux.git] / drivers / input / mouse / vsxxxaa.c

/*
 * Driver for	DEC VSXXX-AA mouse (hockey-puck mouse, ball or two rollers)
 *		DEC VSXXX-GA mouse (rectangular mouse, with ball)
 *		DEC VSXXX-AB tablet (digitizer with hair cross or stylus)
 *
 * Copyright (C) 2003-2004 by Jan-Benedict Glaw <jbglaw@lug-owl.de>
 *
 * The packet format was initially taken from a patch to GPM which is (C) 2001
 * by	Karsten Merker <merker@linuxtag.org>
 * and	Maciej W. Rozycki <macro@ds2.pg.gda.pl>
 * Later on, I had access to the device's documentation (referenced below).
 */

/*
 * 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
 */

/*
 * Building an adaptor to DE9 / DB25 RS232
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 * DISCLAIMER: Use this description AT YOUR OWN RISK! I'll not pay for
 * anything if you break your mouse, your computer or whatever!
 *
 * In theory, this mouse is a simple RS232 device. In practice, it has got
 * a quite uncommon plug and the requirement to additionally get a power
 * supply at +5V and -12V.
 *
 * If you look at the socket/jack (_not_ at the plug), we use this pin
 * numbering:
 *    _______
 *   / 7 6 5 \
 *  | 4 --- 3 |
 *   \  2 1  /
 *    -------
 *
 *	DEC socket	DE9	DB25	Note
 *	1 (GND)		5	7	-
 *	2 (RxD)		2	3	-
 *	3 (TxD)		3	2	-
 *	4 (-12V)	-	-	Somewhere from the PSU. At ATX, it's
 *					the thin blue wire at pin 12 of the
 *					ATX power connector. Only required for
 *					VSXXX-AA/-GA mice.
 *	5 (+5V)		-	-	PSU (red wires of ATX power connector
 *					on pin 4, 6, 19 or 20) or HDD power
 *					connector (also red wire).
 *	6 (+12V)	-	-	HDD power connector, yellow wire. Only
 *					required for VSXXX-AB digitizer.
 *	7 (dev. avail.)	-	-	The mouse shorts this one to pin 1.
 *					This way, the host computer can detect
 *					the mouse. To use it with the adaptor,
 *					simply don't connect this pin.
 *
 * So to get a working adaptor, you need to connect the mouse with three
 * wires to a RS232 port and two or three additional wires for +5V, +12V and
 * -12V to the PSU.
 *
 * Flow specification for the link is 4800, 8o1.
 *
 * The mice and tablet are described in "VCB02 Video Subsystem - Technical
 * Manual", DEC EK-104AA-TM-001. You'll find it at MANX, a search engine
 * specific for DEC documentation. Try
 * http://www.vt100.net/manx/details?pn=EK-104AA-TM-001;id=21;cp=1
 */

#include <linux/delay.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/input.h>
#include <linux/serio.h>

#define DRIVER_DESC "Driver for DEC VSXXX-AA and -GA mice and VSXXX-AB tablet"

MODULE_AUTHOR("Jan-Benedict Glaw <jbglaw@lug-owl.de>");
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");

#undef VSXXXAA_DEBUG
#ifdef VSXXXAA_DEBUG
#define DBG(x...) printk(x)
#else
#define DBG(x...) do {} while (0)
#endif

#define VSXXXAA_INTRO_MASK	0x80
#define VSXXXAA_INTRO_HEAD	0x80
#define IS_HDR_BYTE(x)			\
	(((x) & VSXXXAA_INTRO_MASK) == VSXXXAA_INTRO_HEAD)

#define VSXXXAA_PACKET_MASK	0xe0
#define VSXXXAA_PACKET_REL	0x80
#define VSXXXAA_PACKET_ABS	0xc0
#define VSXXXAA_PACKET_POR	0xa0
#define MATCH_PACKET_TYPE(data, type)	\
	(((data) & VSXXXAA_PACKET_MASK) == (type))


struct vsxxxaa {
	struct input_dev *dev;
	struct serio *serio;
#define BUFLEN 15 /* At least 5 is needed for a full tablet packet */
	unsigned char buf[BUFLEN];
	unsigned char count;
	unsigned char version;
	unsigned char country;
	unsigned char type;
	char name[64];
	char phys[32];
};

static void vsxxxaa_drop_bytes(struct vsxxxaa *mouse, int num)
{
	if (num >= mouse->count) {
		mouse->count = 0;
	} else {
		memmove(mouse->buf, mouse->buf + num, BUFLEN - num);
		mouse->count -= num;
	}
}

static void vsxxxaa_queue_byte(struct vsxxxaa *mouse, unsigned char byte)
{
	if (mouse->count == BUFLEN) {
		printk(KERN_ERR "%s on %s: Dropping a byte of full buffer.\n",
			mouse->name, mouse->phys);
		vsxxxaa_drop_bytes(mouse, 1);
	}

	DBG(KERN_INFO "Queueing byte 0x%02x\n", byte);

	mouse->buf[mouse->count++] = byte;
}

static void vsxxxaa_detection_done(struct vsxxxaa *mouse)
{
	switch (mouse->type) {
	case 0x02:
		strlcpy(mouse->name, "DEC VSXXX-AA/-GA mouse",
			sizeof(mouse->name));
		break;

	case 0x04:
		strlcpy(mouse->name, "DEC VSXXX-AB digitizer",
			sizeof(mouse->name));
		break;

	default:
		snprintf(mouse->name, sizeof(mouse->name),
			 "unknown DEC pointer device (type = 0x%02x)",
			 mouse->type);
		break;
	}

	printk(KERN_INFO
		"Found %s version 0x%02x from country 0x%02x on port %s\n",
		mouse->name, mouse->version, mouse->country, mouse->phys);
}

/*
 * Returns number of bytes to be dropped, 0 if packet is okay.
 */
static int vsxxxaa_check_packet(struct vsxxxaa *mouse, int packet_len)
{
	int i;

	/* First byte must be a header byte */
	if (!IS_HDR_BYTE(mouse->buf[0])) {
		DBG("vsck: len=%d, 1st=0x%02x\n", packet_len, mouse->buf[0]);
		return 1;
	}

	/* Check all following bytes */
	for (i = 1; i < packet_len; i++) {
		if (IS_HDR_BYTE(mouse->buf[i])) {
			printk(KERN_ERR
				"Need to drop %d bytes of a broken packet.\n",
				i - 1);
			DBG(KERN_INFO "check: len=%d, b[%d]=0x%02x\n",
			    packet_len, i, mouse->buf[i]);
			return i - 1;
		}
	}

	return 0;
}

static inline int vsxxxaa_smells_like_packet(struct vsxxxaa *mouse,
					     unsigned char type, size_t len)
{
	return mouse->count >= len && MATCH_PACKET_TYPE(mouse->buf[0], type);
}

static void vsxxxaa_handle_REL_packet(struct vsxxxaa *mouse)
{
	struct input_dev *dev = mouse->dev;
	unsigned char *buf = mouse->buf;
	int left, middle, right;
	int dx, dy;

	/*
	 * Check for normal stream packets. This is three bytes,
	 * with the first byte's 3 MSB set to 100.
	 *
	 * [0]:	1	0	0	SignX	SignY	Left	Middle	Right
	 * [1]: 0	dx	dx	dx	dx	dx	dx	dx
	 * [2]:	0	dy	dy	dy	dy	dy	dy	dy
	 */

	/*
	 * Low 7 bit of byte 1 are abs(dx), bit 7 is
	 * 0, bit 4 of byte 0 is direction.
	 */
	dx = buf[1] & 0x7f;
	dx *= ((buf[0] >> 4) & 0x01) ? 1 : -1;

	/*
	 * Low 7 bit of byte 2 are abs(dy), bit 7 is
	 * 0, bit 3 of byte 0 is direction.
	 */
	dy = buf[2] & 0x7f;
	dy *= ((buf[0] >> 3) & 0x01) ? -1 : 1;

	/*
	 * Get button state. It's the low three bits
	 * (for three buttons) of byte 0.
	 */
	left	= buf[0] & 0x04;
	middle	= buf[0] & 0x02;
	right	= buf[0] & 0x01;

	vsxxxaa_drop_bytes(mouse, 3);

	DBG(KERN_INFO "%s on %s: dx=%d, dy=%d, buttons=%s%s%s\n",
	    mouse->name, mouse->phys, dx, dy,
	    left ? "L" : "l", middle ? "M" : "m", right ? "R" : "r");

	/*
	 * Report what we've found so far...
	 */
	input_report_key(dev, BTN_LEFT, left);
	input_report_key(dev, BTN_MIDDLE, middle);
	input_report_key(dev, BTN_RIGHT, right);
	input_report_key(dev, BTN_TOUCH, 0);
	input_report_rel(dev, REL_X, dx);
	input_report_rel(dev, REL_Y, dy);
	input_sync(dev);
}

static void vsxxxaa_handle_ABS_packet(struct vsxxxaa *mouse)
{
	struct input_dev *dev = mouse->dev;
	unsigned char *buf = mouse->buf;
	int left, middle, right, touch;
	int x, y;

	/*
	 * Tablet position / button packet
	 *
	 * [0]:	1	1	0	B4	B3	B2	B1	Pr
	 * [1]:	0	0	X5	X4	X3	X2	X1	X0
	 * [2]:	0	0	X11	X10	X9	X8	X7	X6
	 * [3]:	0	0	Y5	Y4	Y3	Y2	Y1	Y0
	 * [4]:	0	0	Y11	Y10	Y9	Y8	Y7	Y6
	 */

	/*
	 * Get X/Y position. Y axis needs to be inverted since VSXXX-AB
	 * counts down->top while monitor counts top->bottom.
	 */
	x = ((buf[2] & 0x3f) << 6) | (buf[1] & 0x3f);
	y = ((buf[4] & 0x3f) << 6) | (buf[3] & 0x3f);
	y = 1023 - y;

	/*
	 * Get button state. It's bits <4..1> of byte 0.
	 */
	left	= buf[0] & 0x02;
	middle	= buf[0] & 0x04;
	right	= buf[0] & 0x08;
	touch	= buf[0] & 0x10;

	vsxxxaa_drop_bytes(mouse, 5);

	DBG(KERN_INFO "%s on %s: x=%d, y=%d, buttons=%s%s%s%s\n",
	    mouse->name, mouse->phys, x, y,
	    left ? "L" : "l", middle ? "M" : "m",
	    right ? "R" : "r", touch ? "T" : "t");

	/*
	 * Report what we've found so far...
	 */
	input_report_key(dev, BTN_LEFT, left);
	input_report_key(dev, BTN_MIDDLE, middle);
	input_report_key(dev, BTN_RIGHT, right);
	input_report_key(dev, BTN_TOUCH, touch);
	input_report_abs(dev, ABS_X, x);
	input_report_abs(dev, ABS_Y, y);
	input_sync(dev);
}

static void vsxxxaa_handle_POR_packet(struct vsxxxaa *mouse)
{
	struct input_dev *dev = mouse->dev;
	unsigned char *buf = mouse->buf;
	int left, middle, right;
	unsigned char error;

	/*
	 * Check for Power-On-Reset packets. These are sent out
	 * after plugging the mouse in, or when explicitly
	 * requested by sending 'T'.
	 *
	 * [0]:	1	0	1	0	R3	R2	R1	R0
	 * [1]:	0	M2	M1	M0	D3	D2	D1	D0
	 * [2]:	0	E6	E5	E4	E3	E2	E1	E0
	 * [3]:	0	0	0	0	0	Left	Middle	Right
	 *
	 * M: manufacturer location code
	 * R: revision code
	 * E: Error code. If it's in the range of 0x00..0x1f, only some
	 *    minor problem occurred. Errors >= 0x20 are considered bad
	 *    and the device may not work properly...
	 * D: <0010> == mouse, <0100> == tablet
	 */

	mouse->version = buf[0] & 0x0f;
	mouse->country = (buf[1] >> 4) & 0x07;
	mouse->type = buf[1] & 0x0f;
	error = buf[2] & 0x7f;

	/*
	 * Get button state. It's the low three bits
	 * (for three buttons) of byte 0. Maybe even the bit <3>
	 * has some meaning if a tablet is attached.
	 */
	left	= buf[0] & 0x04;
	middle	= buf[0] & 0x02;
	right	= buf[0] & 0x01;

	vsxxxaa_drop_bytes(mouse, 4);
	vsxxxaa_detection_done(mouse);

	if (error <= 0x1f) {
		/* No (serious) error. Report buttons */
		input_report_key(dev, BTN_LEFT, left);
		input_report_key(dev, BTN_MIDDLE, middle);
		input_report_key(dev, BTN_RIGHT, right);
		input_report_key(dev, BTN_TOUCH, 0);
		input_sync(dev);

		if (error != 0)
			printk(KERN_INFO "Your %s on %s reports error=0x%02x\n",
				mouse->name, mouse->phys, error);

	}

	/*
	 * If the mouse was hot-plugged, we need to force differential mode
	 * now... However, give it a second to recover from it's reset.
	 */
	printk(KERN_NOTICE
		"%s on %s: Forcing standard packet format, "
		"incremental streaming mode and 72 samples/sec\n",
		mouse->name, mouse->phys);
	serio_write(mouse->serio, 'S');	/* Standard format */
	mdelay(50);
	serio_write(mouse->serio, 'R');	/* Incremental */
	mdelay(50);
	serio_write(mouse->serio, 'L');	/* 72 samples/sec */
}

static void vsxxxaa_parse_buffer(struct vsxxxaa *mouse)
{
	unsigned char *buf = mouse->buf;
	int stray_bytes;

	/*
	 * Parse buffer to death...
	 */
	do {
		/*
		 * Out of sync? Throw away what we don't understand. Each
		 * packet starts with a byte whose bit 7 is set. Unhandled
		 * packets (ie. which we don't know about or simply b0rk3d
		 * data...) will get shifted out of the buffer after some
		 * activity on the mouse.
		 */
		while (mouse->count > 0 && !IS_HDR_BYTE(buf[0])) {
			printk(KERN_ERR "%s on %s: Dropping a byte to regain "
				"sync with mouse data stream...\n",
				mouse->name, mouse->phys);
			vsxxxaa_drop_bytes(mouse, 1);
		}

		/*
		 * Check for packets we know about.
		 */

		if (vsxxxaa_smells_like_packet(mouse, VSXXXAA_PACKET_REL, 3)) {
			/* Check for broken packet */
			stray_bytes = vsxxxaa_check_packet(mouse, 3);
			if (!stray_bytes)
				vsxxxaa_handle_REL_packet(mouse);

		} else if (vsxxxaa_smells_like_packet(mouse,
						      VSXXXAA_PACKET_ABS, 5)) {
			/* Check for broken packet */
			stray_bytes = vsxxxaa_check_packet(mouse, 5);
			if (!stray_bytes)
				vsxxxaa_handle_ABS_packet(mouse);

		} else if (vsxxxaa_smells_like_packet(mouse,
						      VSXXXAA_PACKET_POR, 4)) {
			/* Check for broken packet */
			stray_bytes = vsxxxaa_check_packet(mouse, 4);
			if (!stray_bytes)
				vsxxxaa_handle_POR_packet(mouse);

		} else {
			break; /* No REL, ABS or POR packet found */
		}

		if (stray_bytes > 0) {
			printk(KERN_ERR "Dropping %d bytes now...\n",
				stray_bytes);
			vsxxxaa_drop_bytes(mouse, stray_bytes);
		}

	} while (1);
}

static irqreturn_t vsxxxaa_interrupt(struct serio *serio,
				     unsigned char data, unsigned int flags)
{
	struct vsxxxaa *mouse = serio_get_drvdata(serio);

	vsxxxaa_queue_byte(mouse, data);
	vsxxxaa_parse_buffer(mouse);

	return IRQ_HANDLED;
}

static void vsxxxaa_disconnect(struct serio *serio)
{
	struct vsxxxaa *mouse = serio_get_drvdata(serio);

	serio_close(serio);
	serio_set_drvdata(serio, NULL);
	input_unregister_device(mouse->dev);
	kfree(mouse);
}

static int vsxxxaa_connect(struct serio *serio, struct serio_driver *drv)
{
	struct vsxxxaa *mouse;
	struct input_dev *input_dev;
	int err = -ENOMEM;

	mouse = kzalloc(sizeof(struct vsxxxaa), GFP_KERNEL);
	input_dev = input_allocate_device();
	if (!mouse || !input_dev)
		goto fail1;

	mouse->dev = input_dev;
	mouse->serio = serio;
	strlcat(mouse->name, "DEC VSXXX-AA/-GA mouse or VSXXX-AB digitizer",
		 sizeof(mouse->name));
	snprintf(mouse->phys, sizeof(mouse->phys), "%s/input0", serio->phys);

	input_dev->name = mouse->name;
	input_dev->phys = mouse->phys;
	input_dev->id.bustype = BUS_RS232;
	input_dev->dev.parent = &serio->dev;

	__set_bit(EV_KEY, input_dev->evbit);		/* We have buttons */
	__set_bit(EV_REL, input_dev->evbit);
	__set_bit(EV_ABS, input_dev->evbit);
	__set_bit(BTN_LEFT, input_dev->keybit);		/* We have 3 buttons */
	__set_bit(BTN_MIDDLE, input_dev->keybit);
	__set_bit(BTN_RIGHT, input_dev->keybit);
	__set_bit(BTN_TOUCH, input_dev->keybit);	/* ...and Tablet */
	__set_bit(REL_X, input_dev->relbit);
	__set_bit(REL_Y, input_dev->relbit);
	input_set_abs_params(input_dev, ABS_X, 0, 1023, 0, 0);
	input_set_abs_params(input_dev, ABS_Y, 0, 1023, 0, 0);

	serio_set_drvdata(serio, mouse);

	err = serio_open(serio, drv);
	if (err)
		goto fail2;

	/*
	 * Request selftest. Standard packet format and differential
	 * mode will be requested after the device ID'ed successfully.
	 */
	serio_write(serio, 'T'); /* Test */

	err = input_register_device(input_dev);
	if (err)
		goto fail3;

	return 0;

 fail3:	serio_close(serio);
 fail2:	serio_set_drvdata(serio, NULL);
 fail1:	input_free_device(input_dev);
	kfree(mouse);
	return err;
}

static struct serio_device_id vsxxaa_serio_ids[] = {
	{
		.type	= SERIO_RS232,
		.proto	= SERIO_VSXXXAA,
		.id	= SERIO_ANY,
		.extra	= SERIO_ANY,
	},
	{ 0 }
};

MODULE_DEVICE_TABLE(serio, vsxxaa_serio_ids);

static struct serio_driver vsxxxaa_drv = {
	.driver		= {
		.name	= "vsxxxaa",
	},
	.description	= DRIVER_DESC,
	.id_table	= vsxxaa_serio_ids,
	.connect	= vsxxxaa_connect,
	.interrupt	= vsxxxaa_interrupt,
	.disconnect	= vsxxxaa_disconnect,
};

module_serio_driver(vsxxxaa_drv);
Commit	Line	Data
1da177e4 LT	1	/*
1da177e4 LT	2	* Driver for DEC VSXXX-AA mouse (hockey-puck mouse, ball or two rollers)
968ac842 DT	3	* DEC VSXXX-GA mouse (rectangular mouse, with ball)
968ac842 DT	4	* DEC VSXXX-AB tablet (digitizer with hair cross or stylus)
1da177e4 LT	5	*
	6	* Copyright (C) 2003-2004 by Jan-Benedict Glaw <jbglaw@lug-owl.de>
	7	*
	8	* The packet format was initially taken from a patch to GPM which is (C) 2001
	9	* by Karsten Merker <merker@linuxtag.org>
	10	* and Maciej W. Rozycki <macro@ds2.pg.gda.pl>
	11	* Later on, I had access to the device's documentation (referenced below).
	12	*/
	13
	14	/*
	15	* This program is free software; you can redistribute it and/or modify
	16	* it under the terms of the GNU General Public License as published by
	17	* the Free Software Foundation; either version 2 of the License, or
	18	* (at your option) any later version.
	19	*
	20	* This program is distributed in the hope that it will be useful,
	21	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	22	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	23	* GNU General Public License for more details.
	24	*
	25	* You should have received a copy of the GNU General Public License
	26	* along with this program; if not, write to the Free Software
	27	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	28	*/
	29
	30	/*
	31	* Building an adaptor to DE9 / DB25 RS232
	32	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	33	*
	34	* DISCLAIMER: Use this description AT YOUR OWN RISK! I'll not pay for
	35	* anything if you break your mouse, your computer or whatever!
	36	*
	37	* In theory, this mouse is a simple RS232 device. In practice, it has got
	38	* a quite uncommon plug and the requirement to additionally get a power
	39	* supply at +5V and -12V.
	40	*
	41	* If you look at the socket/jack (_not_ at the plug), we use this pin
	42	* numbering:
	43	* _______
	44	* / 7 6 5 \
	45	* \| 4 --- 3 \|
	46	* \ 2 1 /
	47	* -------
	48	*
	49	* DEC socket DE9 DB25 Note
	50	* 1 (GND) 5 7 -
	51	* 2 (RxD) 2 3 -
	52	* 3 (TxD) 3 2 -
	53	* 4 (-12V) - - Somewhere from the PSU. At ATX, it's
	54	* the thin blue wire at pin 12 of the
	55	* ATX power connector. Only required for
	56	* VSXXX-AA/-GA mice.
	57	* 5 (+5V) - - PSU (red wires of ATX power connector
	58	* on pin 4, 6, 19 or 20) or HDD power
	59	* connector (also red wire).
	60	* 6 (+12V) - - HDD power connector, yellow wire. Only
	61	* required for VSXXX-AB digitizer.
	62	* 7 (dev. avail.) - - The mouse shorts this one to pin 1.
	63	* This way, the host computer can detect
	64	* the mouse. To use it with the adaptor,
	65	* simply don't connect this pin.
	66	*
	67	* So to get a working adaptor, you need to connect the mouse with three
	68	* wires to a RS232 port and two or three additional wires for +5V, +12V and
69	* -12V to the PSU.
70	*
71	* Flow specification for the link is 4800, 8o1.
72	*
73	* The mice and tablet are described in "VCB02 Video Subsystem - Technical
74	* Manual", DEC EK-104AA-TM-001. You'll find it at MANX, a search engine
75	* specific for DEC documentation. Try
76	* http://www.vt100.net/manx/details?pn=EK-104AA-TM-001;id=21;cp=1
77	*/
78
79	#include <linux/delay.h>
80	#include <linux/module.h>
81	#include <linux/slab.h>
82	#include <linux/interrupt.h>
83	#include <linux/input.h>
1da177e4	84	#include <linux/serio.h>
1da177e4 LT	85
	86	#define DRIVER_DESC "Driver for DEC VSXXX-AA and -GA mice and VSXXX-AB tablet"
	87
21602325 DT	88	MODULE_AUTHOR("Jan-Benedict Glaw <jbglaw@lug-owl.de>");
	89	MODULE_DESCRIPTION(DRIVER_DESC);
	90	MODULE_LICENSE("GPL");
1da177e4 LT	91
	92	#undef VSXXXAA_DEBUG
	93	#ifdef VSXXXAA_DEBUG
21602325	94	#define DBG(x...) printk(x)
1da177e4 LT	95	#else
	96	#define DBG(x...) do {} while (0)
	97	#endif
	98
	99	#define VSXXXAA_INTRO_MASK 0x80
	100	#define VSXXXAA_INTRO_HEAD 0x80
21602325 DT	101	#define IS_HDR_BYTE(x) \
21602325 DT	102	(((x) & VSXXXAA_INTRO_MASK) == VSXXXAA_INTRO_HEAD)
1da177e4 LT	103
	104	#define VSXXXAA_PACKET_MASK 0xe0
	105	#define VSXXXAA_PACKET_REL 0x80
	106	#define VSXXXAA_PACKET_ABS 0xc0
	107	#define VSXXXAA_PACKET_POR 0xa0
21602325 DT	108	#define MATCH_PACKET_TYPE(data, type) \
21602325 DT	109	(((data) & VSXXXAA_PACKET_MASK) == (type))
1da177e4 LT	110
	111
	112
	113	struct vsxxxaa {
2e5b636b	114	struct input_dev *dev;
1da177e4 LT	115	struct serio *serio;
	116	#define BUFLEN 15 /* At least 5 is needed for a full tablet packet */
	117	unsigned char buf[BUFLEN];
	118	unsigned char count;
	119	unsigned char version;
	120	unsigned char country;
	121	unsigned char type;
	122	char name[64];
	123	char phys[32];
	124	};
	125
21602325	126	static void vsxxxaa_drop_bytes(struct vsxxxaa *mouse, int num)
1da177e4	127	{
21602325	128	if (num >= mouse->count) {
1da177e4	129	mouse->count = 0;
21602325	130	} else {
4db1f47c	131	memmove(mouse->buf, mouse->buf + num, BUFLEN - num);
1da177e4 LT	132	mouse->count -= num;
	133	}
	134	}
	135
21602325	136	static void vsxxxaa_queue_byte(struct vsxxxaa *mouse, unsigned char byte)
1da177e4 LT	137	{
1da177e4 LT	138	if (mouse->count == BUFLEN) {
21602325 DT	139	printk(KERN_ERR "%s on %s: Dropping a byte of full buffer.\n",
	140	mouse->name, mouse->phys);
	141	vsxxxaa_drop_bytes(mouse, 1);
1da177e4	142	}
21602325 DT	143
21602325 DT	144	DBG(KERN_INFO "Queueing byte 0x%02x\n", byte);
1da177e4 LT	145
	146	mouse->buf[mouse->count++] = byte;
	147	}
	148
21602325	149	static void vsxxxaa_detection_done(struct vsxxxaa *mouse)
1da177e4 LT	150	{
1da177e4 LT	151	switch (mouse->type) {
21602325 DT	152	case 0x02:
	153	strlcpy(mouse->name, "DEC VSXXX-AA/-GA mouse",
	154	sizeof(mouse->name));
	155	break;
	156
	157	case 0x04:
	158	strlcpy(mouse->name, "DEC VSXXX-AB digitizer",
	159	sizeof(mouse->name));
	160	break;
	161
	162	default:
	163	snprintf(mouse->name, sizeof(mouse->name),
	164	"unknown DEC pointer device (type = 0x%02x)",
	165	mouse->type);
	166	break;
1da177e4 LT	167	}
1da177e4 LT	168
21602325	169	printk(KERN_INFO
08ffce45 DT	170	"Found %s version 0x%02x from country 0x%02x on port %s\n",
08ffce45 DT	171	mouse->name, mouse->version, mouse->country, mouse->phys);
1da177e4 LT	172	}
	173
	174	/*
	175	* Returns number of bytes to be dropped, 0 if packet is okay.
	176	*/
21602325	177	static int vsxxxaa_check_packet(struct vsxxxaa *mouse, int packet_len)
1da177e4 LT	178	{
	179	int i;
	180
	181	/* First byte must be a header byte */
21602325 DT	182	if (!IS_HDR_BYTE(mouse->buf[0])) {
21602325 DT	183	DBG("vsck: len=%d, 1st=0x%02x\n", packet_len, mouse->buf[0]);
1da177e4 LT	184	return 1;
	185	}
	186
	187	/* Check all following bytes */
21602325 DT	188	for (i = 1; i < packet_len; i++) {
	189	if (IS_HDR_BYTE(mouse->buf[i])) {
	190	printk(KERN_ERR
	191	"Need to drop %d bytes of a broken packet.\n",
	192	i - 1);
	193	DBG(KERN_INFO "check: len=%d, b[%d]=0x%02x\n",
	194	packet_len, i, mouse->buf[i]);
	195	return i - 1;
1da177e4 LT	196	}
	197	}
	198
	199	return 0;
	200	}
	201
21602325 DT	202	static inline int vsxxxaa_smells_like_packet(struct vsxxxaa *mouse,
21602325 DT	203	unsigned char type, size_t len)
1da177e4	204	{
21602325	205	return mouse->count >= len && MATCH_PACKET_TYPE(mouse->buf[0], type);
1da177e4 LT	206	}
1da177e4 LT	207
21602325	208	static void vsxxxaa_handle_REL_packet(struct vsxxxaa *mouse)
1da177e4	209	{
2e5b636b	210	struct input_dev *dev = mouse->dev;
1da177e4 LT	211	unsigned char *buf = mouse->buf;
	212	int left, middle, right;
	213	int dx, dy;
	214
	215	/*
	216	* Check for normal stream packets. This is three bytes,
	217	* with the first byte's 3 MSB set to 100.
	218	*
	219	* [0]: 1 0 0 SignX SignY Left Middle Right
	220	* [1]: 0 dx dx dx dx dx dx dx
	221	* [2]: 0 dy dy dy dy dy dy dy
	222	*/
	223
	224	/*
	225	* Low 7 bit of byte 1 are abs(dx), bit 7 is
	226	* 0, bit 4 of byte 0 is direction.
	227	*/
	228	dx = buf[1] & 0x7f;
21602325	229	dx *= ((buf[0] >> 4) & 0x01) ? 1 : -1;
1da177e4 LT	230
	231	/*
	232	* Low 7 bit of byte 2 are abs(dy), bit 7 is
	233	* 0, bit 3 of byte 0 is direction.
	234	*/
	235	dy = buf[2] & 0x7f;
21602325	236	dy *= ((buf[0] >> 3) & 0x01) ? -1 : 1;
1da177e4 LT	237
	238	/*
	239	* Get button state. It's the low three bits
	240	* (for three buttons) of byte 0.
	241	*/
21602325 DT	242	left = buf[0] & 0x04;
	243	middle = buf[0] & 0x02;
	244	right = buf[0] & 0x01;
1da177e4	245
21602325	246	vsxxxaa_drop_bytes(mouse, 3);
1da177e4	247
21602325 DT	248	DBG(KERN_INFO "%s on %s: dx=%d, dy=%d, buttons=%s%s%s\n",
	249	mouse->name, mouse->phys, dx, dy,
	250	left ? "L" : "l", middle ? "M" : "m", right ? "R" : "r");
1da177e4 LT	251
	252	/*
	253	* Report what we've found so far...
	254	*/
21602325 DT	255	input_report_key(dev, BTN_LEFT, left);
	256	input_report_key(dev, BTN_MIDDLE, middle);
	257	input_report_key(dev, BTN_RIGHT, right);
	258	input_report_key(dev, BTN_TOUCH, 0);
	259	input_report_rel(dev, REL_X, dx);
	260	input_report_rel(dev, REL_Y, dy);
	261	input_sync(dev);
1da177e4 LT	262	}
1da177e4 LT	263
21602325	264	static void vsxxxaa_handle_ABS_packet(struct vsxxxaa *mouse)
1da177e4	265	{
2e5b636b	266	struct input_dev *dev = mouse->dev;
1da177e4 LT	267	unsigned char *buf = mouse->buf;
	268	int left, middle, right, touch;
	269	int x, y;
	270
	271	/*
	272	* Tablet position / button packet
	273	*
	274	* [0]: 1 1 0 B4 B3 B2 B1 Pr
	275	* [1]: 0 0 X5 X4 X3 X2 X1 X0
	276	* [2]: 0 0 X11 X10 X9 X8 X7 X6
	277	* [3]: 0 0 Y5 Y4 Y3 Y2 Y1 Y0
	278	* [4]: 0 0 Y11 Y10 Y9 Y8 Y7 Y6
	279	*/
	280
	281	/*
	282	* Get X/Y position. Y axis needs to be inverted since VSXXX-AB
	283	* counts down->top while monitor counts top->bottom.
	284	*/
	285	x = ((buf[2] & 0x3f) << 6) \| (buf[1] & 0x3f);
	286	y = ((buf[4] & 0x3f) << 6) \| (buf[3] & 0x3f);
	287	y = 1023 - y;
	288
	289	/*
	290	* Get button state. It's bits <4..1> of byte 0.
	291	*/
21602325 DT	292	left = buf[0] & 0x02;
	293	middle = buf[0] & 0x04;
	294	right = buf[0] & 0x08;
	295	touch = buf[0] & 0x10;
1da177e4	296
21602325	297	vsxxxaa_drop_bytes(mouse, 5);
1da177e4	298
21602325 DT	299	DBG(KERN_INFO "%s on %s: x=%d, y=%d, buttons=%s%s%s%s\n",
	300	mouse->name, mouse->phys, x, y,
	301	left ? "L" : "l", middle ? "M" : "m",
	302	right ? "R" : "r", touch ? "T" : "t");
1da177e4 LT	303
	304	/*
	305	* Report what we've found so far...
	306	*/
21602325 DT	307	input_report_key(dev, BTN_LEFT, left);
	308	input_report_key(dev, BTN_MIDDLE, middle);
	309	input_report_key(dev, BTN_RIGHT, right);
	310	input_report_key(dev, BTN_TOUCH, touch);
	311	input_report_abs(dev, ABS_X, x);
	312	input_report_abs(dev, ABS_Y, y);
	313	input_sync(dev);
1da177e4 LT	314	}
1da177e4 LT	315
21602325	316	static void vsxxxaa_handle_POR_packet(struct vsxxxaa *mouse)
1da177e4	317	{
2e5b636b	318	struct input_dev *dev = mouse->dev;
1da177e4 LT	319	unsigned char *buf = mouse->buf;
	320	int left, middle, right;
	321	unsigned char error;
	322
	323	/*
	324	* Check for Power-On-Reset packets. These are sent out
c03983ac	325	* after plugging the mouse in, or when explicitly
1da177e4 LT	326	* requested by sending 'T'.
	327	*
	328	* [0]: 1 0 1 0 R3 R2 R1 R0
	329	* [1]: 0 M2 M1 M0 D3 D2 D1 D0
	330	* [2]: 0 E6 E5 E4 E3 E2 E1 E0
	331	* [3]: 0 0 0 0 0 Left Middle Right
	332	*
	333	* M: manufacturer location code
	334	* R: revision code
	335	* E: Error code. If it's in the range of 0x00..0x1f, only some
25985edc	336	* minor problem occurred. Errors >= 0x20 are considered bad
1da177e4 LT	337	* and the device may not work properly...
	338	* D: <0010> == mouse, <0100> == tablet
	339	*/
	340
	341	mouse->version = buf[0] & 0x0f;
	342	mouse->country = (buf[1] >> 4) & 0x07;
	343	mouse->type = buf[1] & 0x0f;
	344	error = buf[2] & 0x7f;
	345
	346	/*
	347	* Get button state. It's the low three bits
	348	* (for three buttons) of byte 0. Maybe even the bit <3>
	349	* has some meaning if a tablet is attached.
	350	*/
21602325 DT	351	left = buf[0] & 0x04;
	352	middle = buf[0] & 0x02;
	353	right = buf[0] & 0x01;
1da177e4	354
21602325 DT	355	vsxxxaa_drop_bytes(mouse, 4);
21602325 DT	356	vsxxxaa_detection_done(mouse);
1da177e4 LT	357
	358	if (error <= 0x1f) {
	359	/* No (serious) error. Report buttons */
21602325 DT	360	input_report_key(dev, BTN_LEFT, left);
	361	input_report_key(dev, BTN_MIDDLE, middle);
	362	input_report_key(dev, BTN_RIGHT, right);
	363	input_report_key(dev, BTN_TOUCH, 0);
	364	input_sync(dev);
1da177e4 LT	365
1da177e4 LT	366	if (error != 0)
21602325 DT	367	printk(KERN_INFO "Your %s on %s reports error=0x%02x\n",
21602325 DT	368	mouse->name, mouse->phys, error);
1da177e4 LT	369
	370	}
	371
	372	/*
	373	* If the mouse was hot-plugged, we need to force differential mode
	374	* now... However, give it a second to recover from it's reset.
	375	*/
21602325 DT	376	printk(KERN_NOTICE
	377	"%s on %s: Forcing standard packet format, "
	378	"incremental streaming mode and 72 samples/sec\n",
	379	mouse->name, mouse->phys);
	380	serio_write(mouse->serio, 'S'); /* Standard format */
	381	mdelay(50);
	382	serio_write(mouse->serio, 'R'); /* Incremental */
	383	mdelay(50);
	384	serio_write(mouse->serio, 'L'); /* 72 samples/sec */
1da177e4 LT	385	}
1da177e4 LT	386
21602325	387	static void vsxxxaa_parse_buffer(struct vsxxxaa *mouse)
1da177e4 LT	388	{
	389	unsigned char *buf = mouse->buf;
	390	int stray_bytes;
	391
	392	/*
	393	* Parse buffer to death...
	394	*/
	395	do {
	396	/*
	397	* Out of sync? Throw away what we don't understand. Each
	398	* packet starts with a byte whose bit 7 is set. Unhandled
	399	* packets (ie. which we don't know about or simply b0rk3d
	400	* data...) will get shifted out of the buffer after some
	401	* activity on the mouse.
	402	*/
	403	while (mouse->count > 0 && !IS_HDR_BYTE(buf[0])) {
21602325 DT	404	printk(KERN_ERR "%s on %s: Dropping a byte to regain "
	405	"sync with mouse data stream...\n",
	406	mouse->name, mouse->phys);
	407	vsxxxaa_drop_bytes(mouse, 1);
1da177e4 LT	408	}
	409
	410	/*
	411	* Check for packets we know about.
	412	*/
	413
21602325	414	if (vsxxxaa_smells_like_packet(mouse, VSXXXAA_PACKET_REL, 3)) {
1da177e4	415	/* Check for broken packet */
21602325 DT	416	stray_bytes = vsxxxaa_check_packet(mouse, 3);
	417	if (!stray_bytes)
	418	vsxxxaa_handle_REL_packet(mouse);
1da177e4	419
21602325 DT	420	} else if (vsxxxaa_smells_like_packet(mouse,
21602325 DT	421	VSXXXAA_PACKET_ABS, 5)) {
1da177e4	422	/* Check for broken packet */
21602325 DT	423	stray_bytes = vsxxxaa_check_packet(mouse, 5);
	424	if (!stray_bytes)
	425	vsxxxaa_handle_ABS_packet(mouse);
1da177e4	426
21602325 DT	427	} else if (vsxxxaa_smells_like_packet(mouse,
21602325 DT	428	VSXXXAA_PACKET_POR, 4)) {
1da177e4	429	/* Check for broken packet */
21602325 DT	430	stray_bytes = vsxxxaa_check_packet(mouse, 4);
	431	if (!stray_bytes)
	432	vsxxxaa_handle_POR_packet(mouse);
	433
	434	} else {
	435	break; /* No REL, ABS or POR packet found */
	436	}
	437
	438	if (stray_bytes > 0) {
	439	printk(KERN_ERR "Dropping %d bytes now...\n",
	440	stray_bytes);
	441	vsxxxaa_drop_bytes(mouse, stray_bytes);
1da177e4 LT	442	}
1da177e4 LT	443
1da177e4 LT	444	} while (1);
	445	}
	446
21602325 DT	447	static irqreturn_t vsxxxaa_interrupt(struct serio *serio,
21602325 DT	448	unsigned char data, unsigned int flags)
1da177e4	449	{
21602325	450	struct vsxxxaa *mouse = serio_get_drvdata(serio);
1da177e4	451
21602325 DT	452	vsxxxaa_queue_byte(mouse, data);
21602325 DT	453	vsxxxaa_parse_buffer(mouse);
1da177e4 LT	454
	455	return IRQ_HANDLED;
	456	}
	457
21602325	458	static void vsxxxaa_disconnect(struct serio *serio)
1da177e4	459	{
21602325	460	struct vsxxxaa *mouse = serio_get_drvdata(serio);
1da177e4	461
21602325 DT	462	serio_close(serio);
	463	serio_set_drvdata(serio, NULL);
	464	input_unregister_device(mouse->dev);
	465	kfree(mouse);
1da177e4 LT	466	}
1da177e4 LT	467
21602325	468	static int vsxxxaa_connect(struct serio serio, struct serio_driver drv)
1da177e4 LT	469	{
1da177e4 LT	470	struct vsxxxaa *mouse;
2e5b636b DT	471	struct input_dev *input_dev;
2e5b636b DT	472	int err = -ENOMEM;
1da177e4	473
21602325 DT	474	mouse = kzalloc(sizeof(struct vsxxxaa), GFP_KERNEL);
21602325 DT	475	input_dev = input_allocate_device();
2e5b636b	476	if (!mouse \|\| !input_dev)
72155615	477	goto fail1;
1da177e4	478
2e5b636b DT	479	mouse->dev = input_dev;
2e5b636b DT	480	mouse->serio = serio;
21602325 DT	481	strlcat(mouse->name, "DEC VSXXX-AA/-GA mouse or VSXXX-AB digitizer",
	482	sizeof(mouse->name));
	483	snprintf(mouse->phys, sizeof(mouse->phys), "%s/input0", serio->phys);
2e5b636b DT	484
	485	input_dev->name = mouse->name;
	486	input_dev->phys = mouse->phys;
	487	input_dev->id.bustype = BUS_RS232;
28aa7f1c	488	input_dev->dev.parent = &serio->dev;
2e5b636b	489
21602325 DT	490	__set_bit(EV_KEY, input_dev->evbit); /* We have buttons */
	491	__set_bit(EV_REL, input_dev->evbit);
	492	__set_bit(EV_ABS, input_dev->evbit);
	493	__set_bit(BTN_LEFT, input_dev->keybit); /* We have 3 buttons */
	494	__set_bit(BTN_MIDDLE, input_dev->keybit);
	495	__set_bit(BTN_RIGHT, input_dev->keybit);
	496	__set_bit(BTN_TOUCH, input_dev->keybit); /* ...and Tablet */
	497	__set_bit(REL_X, input_dev->relbit);
	498	__set_bit(REL_Y, input_dev->relbit);
	499	input_set_abs_params(input_dev, ABS_X, 0, 1023, 0, 0);
	500	input_set_abs_params(input_dev, ABS_Y, 0, 1023, 0, 0);
	501
	502	serio_set_drvdata(serio, mouse);
	503
	504	err = serio_open(serio, drv);
2e5b636b	505	if (err)
72155615	506	goto fail2;
1da177e4 LT	507
	508	/*
	509	* Request selftest. Standard packet format and differential
	510	* mode will be requested after the device ID'ed successfully.
	511	*/
21602325	512	serio_write(serio, 'T'); /* Test */
1da177e4	513
21602325	514	err = input_register_device(input_dev);
72155615 DT	515	if (err)
72155615 DT	516	goto fail3;
1da177e4 LT	517
1da177e4 LT	518	return 0;
2e5b636b	519
21602325 DT	520	fail3: serio_close(serio);
	521	fail2: serio_set_drvdata(serio, NULL);
	522	fail1: input_free_device(input_dev);
	523	kfree(mouse);
2e5b636b	524	return err;
1da177e4 LT	525	}
	526
	527	static struct serio_device_id vsxxaa_serio_ids[] = {
	528	{
	529	.type = SERIO_RS232,
	530	.proto = SERIO_VSXXXAA,
	531	.id = SERIO_ANY,
	532	.extra = SERIO_ANY,
	533	},
	534	{ 0 }
	535	};
	536
	537	MODULE_DEVICE_TABLE(serio, vsxxaa_serio_ids);
	538
	539	static struct serio_driver vsxxxaa_drv = {
	540	.driver = {
	541	.name = "vsxxxaa",
	542	},
	543	.description = DRIVER_DESC,
	544	.id_table = vsxxaa_serio_ids,
	545	.connect = vsxxxaa_connect,
	546	.interrupt = vsxxxaa_interrupt,
	547	.disconnect = vsxxxaa_disconnect,
	548	};
	549
65ac9f7a	550	module_serio_driver(vsxxxaa_drv);