[linux-2.6-block.git] / drivers / input / tablet / hanwang.c

/*
 *  USB Hanwang tablet support
 *
 *  Copyright (c) 2010 Xing Wei <weixing@hanwang.com.cn>
 *
 */

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

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/usb/input.h>

MODULE_AUTHOR("Xing Wei <weixing@hanwang.com.cn>");
MODULE_DESCRIPTION("USB Hanwang tablet driver");
MODULE_LICENSE("GPL");

#define USB_VENDOR_ID_HANWANG		0x0b57
#define HANWANG_TABLET_INT_CLASS	0x0003
#define HANWANG_TABLET_INT_SUB_CLASS	0x0001
#define HANWANG_TABLET_INT_PROTOCOL	0x0002

#define ART_MASTER_PKGLEN_MAX	10

/* device IDs */
#define STYLUS_DEVICE_ID	0x02
#define TOUCH_DEVICE_ID		0x03
#define CURSOR_DEVICE_ID	0x06
#define ERASER_DEVICE_ID	0x0A
#define PAD_DEVICE_ID		0x0F

/* match vendor and interface info  */
#define HANWANG_TABLET_DEVICE(vend, cl, sc, pr) \
	.match_flags = USB_DEVICE_ID_MATCH_VENDOR \
		| USB_DEVICE_ID_MATCH_INT_INFO, \
	.idVendor = (vend), \
	.bInterfaceClass = (cl), \
	.bInterfaceSubClass = (sc), \
	.bInterfaceProtocol = (pr)

enum hanwang_tablet_type {
	HANWANG_ART_MASTER_III,
	HANWANG_ART_MASTER_HD,
	HANWANG_ART_MASTER_II,
};

struct hanwang {
	unsigned char *data;
	dma_addr_t data_dma;
	struct input_dev *dev;
	struct usb_device *usbdev;
	struct urb *irq;
	const struct hanwang_features *features;
	unsigned int current_tool;
	unsigned int current_id;
	char name[64];
	char phys[32];
};

struct hanwang_features {
	unsigned short pid;
	char *name;
	enum hanwang_tablet_type type;
	int pkg_len;
	int max_x;
	int max_y;
	int max_tilt_x;
	int max_tilt_y;
	int max_pressure;
};

static const struct hanwang_features features_array[] = {
	{ 0x8528, "Hanwang Art Master III 0906", HANWANG_ART_MASTER_III,
	  ART_MASTER_PKGLEN_MAX, 0x5757, 0x3692, 0x3f, 0x7f, 2048 },
	{ 0x8529, "Hanwang Art Master III 0604", HANWANG_ART_MASTER_III,
	  ART_MASTER_PKGLEN_MAX, 0x3d84, 0x2672, 0x3f, 0x7f, 2048 },
	{ 0x852a, "Hanwang Art Master III 1308", HANWANG_ART_MASTER_III,
	  ART_MASTER_PKGLEN_MAX, 0x7f00, 0x4f60, 0x3f, 0x7f, 2048 },
	{ 0x8401, "Hanwang Art Master HD 5012", HANWANG_ART_MASTER_HD,
	  ART_MASTER_PKGLEN_MAX, 0x678e, 0x4150, 0x3f, 0x7f, 1024 },
	{ 0x8503, "Hanwang Art Master II", HANWANG_ART_MASTER_II,
	  ART_MASTER_PKGLEN_MAX, 0x27de, 0x1cfe, 0x3f, 0x7f, 1024 },
};

static const int hw_eventtypes[] = {
	EV_KEY, EV_ABS, EV_MSC,
};

static const int hw_absevents[] = {
	ABS_X, ABS_Y, ABS_TILT_X, ABS_TILT_Y, ABS_WHEEL,
	ABS_RX, ABS_RY, ABS_PRESSURE, ABS_MISC,
};

static const int hw_btnevents[] = {
	BTN_STYLUS, BTN_STYLUS2, BTN_TOOL_PEN, BTN_TOOL_RUBBER,
	BTN_TOOL_MOUSE, BTN_TOOL_FINGER,
	BTN_0, BTN_1, BTN_2, BTN_3, BTN_4, BTN_5, BTN_6, BTN_7, BTN_8,
};

static const int hw_mscevents[] = {
	MSC_SERIAL,
};

static void hanwang_parse_packet(struct hanwang *hanwang)
{
	unsigned char *data = hanwang->data;
	struct input_dev *input_dev = hanwang->dev;
	struct usb_device *dev = hanwang->usbdev;
	enum hanwang_tablet_type type = hanwang->features->type;
	int i;
	u16 p;

	if (type == HANWANG_ART_MASTER_II) {
		hanwang->current_tool = BTN_TOOL_PEN;
		hanwang->current_id = STYLUS_DEVICE_ID;
	}

	switch (data[0]) {
	case 0x02:	/* data packet */
		switch (data[1]) {
		case 0x80:	/* tool prox out */
			if (type != HANWANG_ART_MASTER_II) {
				hanwang->current_id = 0;
				input_report_key(input_dev,
						 hanwang->current_tool, 0);
			}
			break;

		case 0x00:	/* artmaster ii pen leave */
			if (type == HANWANG_ART_MASTER_II) {
				hanwang->current_id = 0;
				input_report_key(input_dev,
						 hanwang->current_tool, 0);
			}
			break;

		case 0xc2:	/* first time tool prox in */
			switch (data[3] & 0xf0) {
			case 0x20:	/* art_master III */
			case 0x30:	/* art_master_HD */
				hanwang->current_id = STYLUS_DEVICE_ID;
				hanwang->current_tool = BTN_TOOL_PEN;
				input_report_key(input_dev, BTN_TOOL_PEN, 1);
				break;
			case 0xa0:	/* art_master III */
			case 0xb0:	/* art_master_HD */
				hanwang->current_id = ERASER_DEVICE_ID;
				hanwang->current_tool = BTN_TOOL_RUBBER;
				input_report_key(input_dev, BTN_TOOL_RUBBER, 1);
				break;
			default:
				hanwang->current_id = 0;
				dev_dbg(&dev->dev,
					"unknown tablet tool %02x\n", data[0]);
				break;
			}
			break;

		default:	/* tool data packet */
			switch (type) {
			case HANWANG_ART_MASTER_III:
				p = (data[6] << 3) |
				    ((data[7] & 0xc0) >> 5) |
				    (data[1] & 0x01);
				break;

			case HANWANG_ART_MASTER_HD:
			case HANWANG_ART_MASTER_II:
				p = (data[7] >> 6) | (data[6] << 2);
				break;

			default:
				p = 0;
				break;
			}

			input_report_abs(input_dev, ABS_X,
					 be16_to_cpup((__be16 *)&data[2]));
			input_report_abs(input_dev, ABS_Y,
					 be16_to_cpup((__be16 *)&data[4]));
			input_report_abs(input_dev, ABS_PRESSURE, p);
			input_report_abs(input_dev, ABS_TILT_X, data[7] & 0x3f);
			input_report_abs(input_dev, ABS_TILT_Y, data[8] & 0x7f);
			input_report_key(input_dev, BTN_STYLUS, data[1] & 0x02);

			if (type != HANWANG_ART_MASTER_II)
				input_report_key(input_dev, BTN_STYLUS2,
						 data[1] & 0x04);
			else
				input_report_key(input_dev, BTN_TOOL_PEN, 1);

			break;
		}

		input_report_abs(input_dev, ABS_MISC, hanwang->current_id);
		input_event(input_dev, EV_MSC, MSC_SERIAL,
				hanwang->features->pid);
		break;

	case 0x0c:
		/* roll wheel */
		hanwang->current_id = PAD_DEVICE_ID;

		switch (type) {
		case HANWANG_ART_MASTER_III:
			input_report_key(input_dev, BTN_TOOL_FINGER,
					 data[1] || data[2] || data[3]);
			input_report_abs(input_dev, ABS_WHEEL, data[1]);
			input_report_key(input_dev, BTN_0, data[2]);
			for (i = 0; i < 8; i++)
				input_report_key(input_dev,
					 BTN_1 + i, data[3] & (1 << i));
			break;

		case HANWANG_ART_MASTER_HD:
			input_report_key(input_dev, BTN_TOOL_FINGER, data[1] ||
					data[2] || data[3] || data[4] ||
					data[5] || data[6]);
			input_report_abs(input_dev, ABS_RX,
					((data[1] & 0x1f) << 8) | data[2]);
			input_report_abs(input_dev, ABS_RY,
					((data[3] & 0x1f) << 8) | data[4]);
			input_report_key(input_dev, BTN_0, data[5] & 0x01);
			for (i = 0; i < 4; i++) {
				input_report_key(input_dev,
					 BTN_1 + i, data[5] & (1 << i));
				input_report_key(input_dev,
					 BTN_5 + i, data[6] & (1 << i));
			}
			break;

		case HANWANG_ART_MASTER_II:
			dev_dbg(&dev->dev, "error packet  %02x\n", data[0]);
			return;
		}

		input_report_abs(input_dev, ABS_MISC, hanwang->current_id);
		input_event(input_dev, EV_MSC, MSC_SERIAL, 0xffffffff);
		break;

	default:
		dev_dbg(&dev->dev, "error packet  %02x\n", data[0]);
		break;
	}

	input_sync(input_dev);
}

static void hanwang_irq(struct urb *urb)
{
	struct hanwang *hanwang = urb->context;
	struct usb_device *dev = hanwang->usbdev;
	int retval;

	switch (urb->status) {
	case 0:
		/* success */;
		hanwang_parse_packet(hanwang);
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
		dev_err(&dev->dev, "%s - urb shutting down with status: %d",
			__func__, urb->status);
		return;
	default:
		dev_err(&dev->dev, "%s - nonzero urb status received: %d",
			__func__, urb->status);
		break;
	}

	retval = usb_submit_urb(urb, GFP_ATOMIC);
	if (retval)
		dev_err(&dev->dev, "%s - usb_submit_urb failed with result %d",
			__func__, retval);
}

static int hanwang_open(struct input_dev *dev)
{
	struct hanwang *hanwang = input_get_drvdata(dev);

	hanwang->irq->dev = hanwang->usbdev;
	if (usb_submit_urb(hanwang->irq, GFP_KERNEL))
		return -EIO;

	return 0;
}

static void hanwang_close(struct input_dev *dev)
{
	struct hanwang *hanwang = input_get_drvdata(dev);

	usb_kill_urb(hanwang->irq);
}

static bool get_features(struct usb_device *dev, struct hanwang *hanwang)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(features_array); i++) {
		if (le16_to_cpu(dev->descriptor.idProduct) ==
				features_array[i].pid) {
			hanwang->features = &features_array[i];
			return true;
		}
	}

	return false;
}


static int hanwang_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
	struct usb_device *dev = interface_to_usbdev(intf);
	struct usb_endpoint_descriptor *endpoint;
	struct hanwang *hanwang;
	struct input_dev *input_dev;
	int error;
	int i;

	if (intf->cur_altsetting->desc.bNumEndpoints < 1)
		return -ENODEV;

	hanwang = kzalloc(sizeof(struct hanwang), GFP_KERNEL);
	input_dev = input_allocate_device();
	if (!hanwang || !input_dev) {
		error = -ENOMEM;
		goto fail1;
	}

	if (!get_features(dev, hanwang)) {
		error = -ENXIO;
		goto fail1;
	}

	hanwang->data = usb_alloc_coherent(dev, hanwang->features->pkg_len,
					GFP_KERNEL, &hanwang->data_dma);
	if (!hanwang->data) {
		error = -ENOMEM;
		goto fail1;
	}

	hanwang->irq = usb_alloc_urb(0, GFP_KERNEL);
	if (!hanwang->irq) {
		error = -ENOMEM;
		goto fail2;
	}

	hanwang->usbdev = dev;
	hanwang->dev = input_dev;

	usb_make_path(dev, hanwang->phys, sizeof(hanwang->phys));
	strlcat(hanwang->phys, "/input0", sizeof(hanwang->phys));

	strlcpy(hanwang->name, hanwang->features->name, sizeof(hanwang->name));
	input_dev->name = hanwang->name;
	input_dev->phys = hanwang->phys;
	usb_to_input_id(dev, &input_dev->id);
	input_dev->dev.parent = &intf->dev;

	input_set_drvdata(input_dev, hanwang);

	input_dev->open = hanwang_open;
	input_dev->close = hanwang_close;

	for (i = 0; i < ARRAY_SIZE(hw_eventtypes); ++i)
		__set_bit(hw_eventtypes[i], input_dev->evbit);

	for (i = 0; i < ARRAY_SIZE(hw_absevents); ++i)
		__set_bit(hw_absevents[i], input_dev->absbit);

	for (i = 0; i < ARRAY_SIZE(hw_btnevents); ++i)
		__set_bit(hw_btnevents[i], input_dev->keybit);

	for (i = 0; i < ARRAY_SIZE(hw_mscevents); ++i)
		__set_bit(hw_mscevents[i], input_dev->mscbit);

	input_set_abs_params(input_dev, ABS_X,
			     0, hanwang->features->max_x, 4, 0);
	input_set_abs_params(input_dev, ABS_Y,
			     0, hanwang->features->max_y, 4, 0);
	input_set_abs_params(input_dev, ABS_TILT_X,
			     0, hanwang->features->max_tilt_x, 0, 0);
	input_set_abs_params(input_dev, ABS_TILT_Y,
			     0, hanwang->features->max_tilt_y, 0, 0);
	input_set_abs_params(input_dev, ABS_PRESSURE,
			     0, hanwang->features->max_pressure, 0, 0);

	endpoint = &intf->cur_altsetting->endpoint[0].desc;
	usb_fill_int_urb(hanwang->irq, dev,
			usb_rcvintpipe(dev, endpoint->bEndpointAddress),
			hanwang->data, hanwang->features->pkg_len,
			hanwang_irq, hanwang, endpoint->bInterval);
	hanwang->irq->transfer_dma = hanwang->data_dma;
	hanwang->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

	error = input_register_device(hanwang->dev);
	if (error)
		goto fail3;

	usb_set_intfdata(intf, hanwang);

	return 0;

 fail3:	usb_free_urb(hanwang->irq);
 fail2:	usb_free_coherent(dev, hanwang->features->pkg_len,
			hanwang->data, hanwang->data_dma);
 fail1:	input_free_device(input_dev);
	kfree(hanwang);
	return error;

}

static void hanwang_disconnect(struct usb_interface *intf)
{
	struct hanwang *hanwang = usb_get_intfdata(intf);

	input_unregister_device(hanwang->dev);
	usb_free_urb(hanwang->irq);
	usb_free_coherent(interface_to_usbdev(intf),
			hanwang->features->pkg_len, hanwang->data,
			hanwang->data_dma);
	kfree(hanwang);
	usb_set_intfdata(intf, NULL);
}

static const struct usb_device_id hanwang_ids[] = {
	{ HANWANG_TABLET_DEVICE(USB_VENDOR_ID_HANWANG, HANWANG_TABLET_INT_CLASS,
		HANWANG_TABLET_INT_SUB_CLASS, HANWANG_TABLET_INT_PROTOCOL) },
	{}
};

MODULE_DEVICE_TABLE(usb, hanwang_ids);

static struct usb_driver hanwang_driver = {
	.name		= "hanwang",
	.probe		= hanwang_probe,
	.disconnect	= hanwang_disconnect,
	.id_table	= hanwang_ids,
};

module_usb_driver(hanwang_driver);
Commit	Line	Data
bba5394a XW	1	/*
	2	* USB Hanwang tablet support
	3	*
	4	* Copyright (c) 2010 Xing Wei <weixing@hanwang.com.cn>
	5	*
	6	*/
	7
	8	/*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	22	*
	23	*/
	24
	25	#include <linux/types.h>
	26	#include <linux/kernel.h>
	27	#include <linux/slab.h>
	28	#include <linux/module.h>
bba5394a XW	29	#include <linux/usb/input.h>
bba5394a XW	30
698c03b4 JL	31	MODULE_AUTHOR("Xing Wei <weixing@hanwang.com.cn>");
698c03b4 JL	32	MODULE_DESCRIPTION("USB Hanwang tablet driver");
9f1d1ea3	33	MODULE_LICENSE("GPL");
bba5394a XW	34
	35	#define USB_VENDOR_ID_HANWANG 0x0b57
	36	#define HANWANG_TABLET_INT_CLASS 0x0003
	37	#define HANWANG_TABLET_INT_SUB_CLASS 0x0001
	38	#define HANWANG_TABLET_INT_PROTOCOL 0x0002
	39
727eeb7d	40	#define ART_MASTER_PKGLEN_MAX 10
bba5394a	41
24dd3b58 XW	42	/* device IDs */
	43	#define STYLUS_DEVICE_ID 0x02
	44	#define TOUCH_DEVICE_ID 0x03
	45	#define CURSOR_DEVICE_ID 0x06
	46	#define ERASER_DEVICE_ID 0x0A
	47	#define PAD_DEVICE_ID 0x0F
	48
bba5394a XW	49	/* match vendor and interface info */
	50	#define HANWANG_TABLET_DEVICE(vend, cl, sc, pr) \
	51	.match_flags = USB_DEVICE_ID_MATCH_VENDOR \
	52	\| USB_DEVICE_ID_MATCH_INT_INFO, \
	53	.idVendor = (vend), \
	54	.bInterfaceClass = (cl), \
	55	.bInterfaceSubClass = (sc), \
	56	.bInterfaceProtocol = (pr)
	57
727eeb7d XW	58	enum hanwang_tablet_type {
	59	HANWANG_ART_MASTER_III,
	60	HANWANG_ART_MASTER_HD,
8a90c034	61	HANWANG_ART_MASTER_II,
727eeb7d XW	62	};
727eeb7d XW	63
bba5394a XW	64	struct hanwang {
	65	unsigned char *data;
	66	dma_addr_t data_dma;
	67	struct input_dev *dev;
	68	struct usb_device *usbdev;
	69	struct urb *irq;
	70	const struct hanwang_features *features;
	71	unsigned int current_tool;
24dd3b58	72	unsigned int current_id;
bba5394a XW	73	char name[64];
	74	char phys[32];
	75	};
	76
	77	struct hanwang_features {
	78	unsigned short pid;
	79	char *name;
727eeb7d	80	enum hanwang_tablet_type type;
bba5394a XW	81	int pkg_len;
	82	int max_x;
	83	int max_y;
	84	int max_tilt_x;
	85	int max_tilt_y;
	86	int max_pressure;
	87	};
	88
	89	static const struct hanwang_features features_array[] = {
727eeb7d XW	90	{ 0x8528, "Hanwang Art Master III 0906", HANWANG_ART_MASTER_III,
	91	ART_MASTER_PKGLEN_MAX, 0x5757, 0x3692, 0x3f, 0x7f, 2048 },
	92	{ 0x8529, "Hanwang Art Master III 0604", HANWANG_ART_MASTER_III,
	93	ART_MASTER_PKGLEN_MAX, 0x3d84, 0x2672, 0x3f, 0x7f, 2048 },
	94	{ 0x852a, "Hanwang Art Master III 1308", HANWANG_ART_MASTER_III,
	95	ART_MASTER_PKGLEN_MAX, 0x7f00, 0x4f60, 0x3f, 0x7f, 2048 },
	96	{ 0x8401, "Hanwang Art Master HD 5012", HANWANG_ART_MASTER_HD,
	97	ART_MASTER_PKGLEN_MAX, 0x678e, 0x4150, 0x3f, 0x7f, 1024 },
8a90c034	98	{ 0x8503, "Hanwang Art Master II", HANWANG_ART_MASTER_II,
8a90c034	99	ART_MASTER_PKGLEN_MAX, 0x27de, 0x1cfe, 0x3f, 0x7f, 1024 },
bba5394a XW	100	};
	101
	102	static const int hw_eventtypes[] = {
24dd3b58	103	EV_KEY, EV_ABS, EV_MSC,
bba5394a XW	104	};
	105
	106	static const int hw_absevents[] = {
24dd3b58	107	ABS_X, ABS_Y, ABS_TILT_X, ABS_TILT_Y, ABS_WHEEL,
727eeb7d	108	ABS_RX, ABS_RY, ABS_PRESSURE, ABS_MISC,
bba5394a XW	109	};
	110
	111	static const int hw_btnevents[] = {
24dd3b58 XW	112	BTN_STYLUS, BTN_STYLUS2, BTN_TOOL_PEN, BTN_TOOL_RUBBER,
	113	BTN_TOOL_MOUSE, BTN_TOOL_FINGER,
	114	BTN_0, BTN_1, BTN_2, BTN_3, BTN_4, BTN_5, BTN_6, BTN_7, BTN_8,
	115	};
	116
	117	static const int hw_mscevents[] = {
	118	MSC_SERIAL,
bba5394a XW	119	};
	120
	121	static void hanwang_parse_packet(struct hanwang *hanwang)
	122	{
	123	unsigned char *data = hanwang->data;
	124	struct input_dev *input_dev = hanwang->dev;
	125	struct usb_device *dev = hanwang->usbdev;
727eeb7d	126	enum hanwang_tablet_type type = hanwang->features->type;
bba5394a	127	int i;
8a90c034	128	u16 p;
	129
	130	if (type == HANWANG_ART_MASTER_II) {
	131	hanwang->current_tool = BTN_TOOL_PEN;
	132	hanwang->current_id = STYLUS_DEVICE_ID;
	133	}
bba5394a XW	134
	135	switch (data[0]) {
	136	case 0x02: /* data packet */
	137	switch (data[1]) {
	138	case 0x80: /* tool prox out */
8a90c034	139	if (type != HANWANG_ART_MASTER_II) {
	140	hanwang->current_id = 0;
	141	input_report_key(input_dev,
	142	hanwang->current_tool, 0);
	143	}
	144	break;
	145
	146	case 0x00: /* artmaster ii pen leave */
	147	if (type == HANWANG_ART_MASTER_II) {
	148	hanwang->current_id = 0;
	149	input_report_key(input_dev,
	150	hanwang->current_tool, 0);
	151	}
bba5394a XW	152	break;
	153
	154	case 0xc2: /* first time tool prox in */
	155	switch (data[3] & 0xf0) {
727eeb7d XW	156	case 0x20: /* art_master III */
727eeb7d XW	157	case 0x30: /* art_master_HD */
24dd3b58	158	hanwang->current_id = STYLUS_DEVICE_ID;
bba5394a XW	159	hanwang->current_tool = BTN_TOOL_PEN;
	160	input_report_key(input_dev, BTN_TOOL_PEN, 1);
	161	break;
727eeb7d XW	162	case 0xa0: /* art_master III */
727eeb7d XW	163	case 0xb0: /* art_master_HD */
24dd3b58	164	hanwang->current_id = ERASER_DEVICE_ID;
bba5394a XW	165	hanwang->current_tool = BTN_TOOL_RUBBER;
	166	input_report_key(input_dev, BTN_TOOL_RUBBER, 1);
	167	break;
	168	default:
24dd3b58	169	hanwang->current_id = 0;
bba5394a	170	dev_dbg(&dev->dev,
8a90c034	171	"unknown tablet tool %02x\n", data[0]);
bba5394a XW	172	break;
	173	}
	174	break;
	175
	176	default: /* tool data packet */
727eeb7d XW	177	switch (type) {
	178	case HANWANG_ART_MASTER_III:
	179	p = (data[6] << 3) \|
	180	((data[7] & 0xc0) >> 5) \|
	181	(data[1] & 0x01);
	182	break;
	183
	184	case HANWANG_ART_MASTER_HD:
8a90c034	185	case HANWANG_ART_MASTER_II:
727eeb7d XW	186	p = (data[7] >> 6) \| (data[6] << 2);
	187	break;
	188
	189	default:
	190	p = 0;
	191	break;
	192	}
	193
bba5394a	194	input_report_abs(input_dev, ABS_X,
8a90c034	195	be16_to_cpup((__be16 *)&data[2]));
bba5394a	196	input_report_abs(input_dev, ABS_Y,
8a90c034	197	be16_to_cpup((__be16 *)&data[4]));
8a90c034	198	input_report_abs(input_dev, ABS_PRESSURE, p);
bba5394a XW	199	input_report_abs(input_dev, ABS_TILT_X, data[7] & 0x3f);
	200	input_report_abs(input_dev, ABS_TILT_Y, data[8] & 0x7f);
	201	input_report_key(input_dev, BTN_STYLUS, data[1] & 0x02);
8a90c034	202
	203	if (type != HANWANG_ART_MASTER_II)
	204	input_report_key(input_dev, BTN_STYLUS2,
	205	data[1] & 0x04);
	206	else
	207	input_report_key(input_dev, BTN_TOOL_PEN, 1);
	208
bba5394a XW	209	break;
bba5394a XW	210	}
8a90c034	211
24dd3b58 XW	212	input_report_abs(input_dev, ABS_MISC, hanwang->current_id);
	213	input_event(input_dev, EV_MSC, MSC_SERIAL,
	214	hanwang->features->pid);
bba5394a XW	215	break;
	216
	217	case 0x0c:
	218	/* roll wheel */
24dd3b58	219	hanwang->current_id = PAD_DEVICE_ID;
727eeb7d XW	220
	221	switch (type) {
	222	case HANWANG_ART_MASTER_III:
8a90c034	223	input_report_key(input_dev, BTN_TOOL_FINGER,
8a90c034	224	data[1] \|\| data[2] \|\| data[3]);
727eeb7d XW	225	input_report_abs(input_dev, ABS_WHEEL, data[1]);
	226	input_report_key(input_dev, BTN_0, data[2]);
	227	for (i = 0; i < 8; i++)
	228	input_report_key(input_dev,
bba5394a	229	BTN_1 + i, data[3] & (1 << i));
727eeb7d XW	230	break;
	231
	232	case HANWANG_ART_MASTER_HD:
	233	input_report_key(input_dev, BTN_TOOL_FINGER, data[1] \|\|
	234	data[2] \|\| data[3] \|\| data[4] \|\|
	235	data[5] \|\| data[6]);
	236	input_report_abs(input_dev, ABS_RX,
	237	((data[1] & 0x1f) << 8) \| data[2]);
	238	input_report_abs(input_dev, ABS_RY,
	239	((data[3] & 0x1f) << 8) \| data[4]);
	240	input_report_key(input_dev, BTN_0, data[5] & 0x01);
	241	for (i = 0; i < 4; i++) {
	242	input_report_key(input_dev,
	243	BTN_1 + i, data[5] & (1 << i));
	244	input_report_key(input_dev,
	245	BTN_5 + i, data[6] & (1 << i));
	246	}
	247	break;
8a90c034	248
	249	case HANWANG_ART_MASTER_II:
	250	dev_dbg(&dev->dev, "error packet %02x\n", data[0]);
	251	return;
727eeb7d XW	252	}
727eeb7d XW	253
24dd3b58 XW	254	input_report_abs(input_dev, ABS_MISC, hanwang->current_id);
24dd3b58 XW	255	input_event(input_dev, EV_MSC, MSC_SERIAL, 0xffffffff);
bba5394a XW	256	break;
	257
	258	default:
8a90c034	259	dev_dbg(&dev->dev, "error packet %02x\n", data[0]);
bba5394a XW	260	break;
	261	}
	262
	263	input_sync(input_dev);
	264	}
	265
	266	static void hanwang_irq(struct urb *urb)
	267	{
	268	struct hanwang *hanwang = urb->context;
	269	struct usb_device *dev = hanwang->usbdev;
	270	int retval;
	271
	272	switch (urb->status) {
	273	case 0:
	274	/* success */;
	275	hanwang_parse_packet(hanwang);
	276	break;
	277	case -ECONNRESET:
	278	case -ENOENT:
	279	case -ESHUTDOWN:
	280	/* this urb is terminated, clean up */
	281	dev_err(&dev->dev, "%s - urb shutting down with status: %d",
	282	__func__, urb->status);
	283	return;
	284	default:
	285	dev_err(&dev->dev, "%s - nonzero urb status received: %d",
	286	__func__, urb->status);
	287	break;
	288	}
	289
	290	retval = usb_submit_urb(urb, GFP_ATOMIC);
	291	if (retval)
	292	dev_err(&dev->dev, "%s - usb_submit_urb failed with result %d",
	293	__func__, retval);
	294	}
	295
	296	static int hanwang_open(struct input_dev *dev)
	297	{
	298	struct hanwang *hanwang = input_get_drvdata(dev);
	299
	300	hanwang->irq->dev = hanwang->usbdev;
	301	if (usb_submit_urb(hanwang->irq, GFP_KERNEL))
	302	return -EIO;
	303
	304	return 0;
	305	}
	306
	307	static void hanwang_close(struct input_dev *dev)
	308	{
	309	struct hanwang *hanwang = input_get_drvdata(dev);
	310
	311	usb_kill_urb(hanwang->irq);
	312	}
	313
	314	static bool get_features(struct usb_device dev, struct hanwang hanwang)
	315	{
	316	int i;
	317
	318	for (i = 0; i < ARRAY_SIZE(features_array); i++) {
	319	if (le16_to_cpu(dev->descriptor.idProduct) ==
	320	features_array[i].pid) {
	321	hanwang->features = &features_array[i];
	322	return true;
	323	}
324	}
325
326	return false;
327	}
328
329
330	static int hanwang_probe(struct usb_interface intf, const struct usb_device_id id)
331	{
332	struct usb_device *dev = interface_to_usbdev(intf);
333	struct usb_endpoint_descriptor *endpoint;
334	struct hanwang *hanwang;
335	struct input_dev *input_dev;
336	int error;
337	int i;
338
ba340d7b JH	339	if (intf->cur_altsetting->desc.bNumEndpoints < 1)
	340	return -ENODEV;
	341
bba5394a XW	342	hanwang = kzalloc(sizeof(struct hanwang), GFP_KERNEL);
	343	input_dev = input_allocate_device();
	344	if (!hanwang \|\| !input_dev) {
	345	error = -ENOMEM;
	346	goto fail1;
	347	}
	348
	349	if (!get_features(dev, hanwang)) {
	350	error = -ENXIO;
	351	goto fail1;
	352	}
	353
	354	hanwang->data = usb_alloc_coherent(dev, hanwang->features->pkg_len,
	355	GFP_KERNEL, &hanwang->data_dma);
	356	if (!hanwang->data) {
	357	error = -ENOMEM;
	358	goto fail1;
	359	}
	360
	361	hanwang->irq = usb_alloc_urb(0, GFP_KERNEL);
	362	if (!hanwang->irq) {
	363	error = -ENOMEM;
	364	goto fail2;
	365	}
	366
	367	hanwang->usbdev = dev;
	368	hanwang->dev = input_dev;
	369
	370	usb_make_path(dev, hanwang->phys, sizeof(hanwang->phys));
	371	strlcat(hanwang->phys, "/input0", sizeof(hanwang->phys));
	372
	373	strlcpy(hanwang->name, hanwang->features->name, sizeof(hanwang->name));
	374	input_dev->name = hanwang->name;
	375	input_dev->phys = hanwang->phys;
	376	usb_to_input_id(dev, &input_dev->id);
	377	input_dev->dev.parent = &intf->dev;
	378
	379	input_set_drvdata(input_dev, hanwang);
	380
	381	input_dev->open = hanwang_open;
	382	input_dev->close = hanwang_close;
	383
	384	for (i = 0; i < ARRAY_SIZE(hw_eventtypes); ++i)
	385	__set_bit(hw_eventtypes[i], input_dev->evbit);
	386
	387	for (i = 0; i < ARRAY_SIZE(hw_absevents); ++i)
	388	__set_bit(hw_absevents[i], input_dev->absbit);
	389
	390	for (i = 0; i < ARRAY_SIZE(hw_btnevents); ++i)
	391	__set_bit(hw_btnevents[i], input_dev->keybit);
	392
24dd3b58 XW	393	for (i = 0; i < ARRAY_SIZE(hw_mscevents); ++i)
	394	__set_bit(hw_mscevents[i], input_dev->mscbit);
	395
bba5394a XW	396	input_set_abs_params(input_dev, ABS_X,
	397	0, hanwang->features->max_x, 4, 0);
	398	input_set_abs_params(input_dev, ABS_Y,
	399	0, hanwang->features->max_y, 4, 0);
	400	input_set_abs_params(input_dev, ABS_TILT_X,
	401	0, hanwang->features->max_tilt_x, 0, 0);
	402	input_set_abs_params(input_dev, ABS_TILT_Y,
	403	0, hanwang->features->max_tilt_y, 0, 0);
	404	input_set_abs_params(input_dev, ABS_PRESSURE,
	405	0, hanwang->features->max_pressure, 0, 0);
	406
	407	endpoint = &intf->cur_altsetting->endpoint[0].desc;
	408	usb_fill_int_urb(hanwang->irq, dev,
	409	usb_rcvintpipe(dev, endpoint->bEndpointAddress),
	410	hanwang->data, hanwang->features->pkg_len,
	411	hanwang_irq, hanwang, endpoint->bInterval);
	412	hanwang->irq->transfer_dma = hanwang->data_dma;
	413	hanwang->irq->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;
	414
	415	error = input_register_device(hanwang->dev);
	416	if (error)
	417	goto fail3;
	418
	419	usb_set_intfdata(intf, hanwang);
	420
	421	return 0;
	422
	423	fail3: usb_free_urb(hanwang->irq);
	424	fail2: usb_free_coherent(dev, hanwang->features->pkg_len,
	425	hanwang->data, hanwang->data_dma);
	426	fail1: input_free_device(input_dev);
	427	kfree(hanwang);
	428	return error;
	429
	430	}
	431
	432	static void hanwang_disconnect(struct usb_interface *intf)
	433	{
	434	struct hanwang *hanwang = usb_get_intfdata(intf);
	435
	436	input_unregister_device(hanwang->dev);
	437	usb_free_urb(hanwang->irq);
	438	usb_free_coherent(interface_to_usbdev(intf),
	439	hanwang->features->pkg_len, hanwang->data,
	440	hanwang->data_dma);
	441	kfree(hanwang);
	442	usb_set_intfdata(intf, NULL);
	443	}
	444
	445	static const struct usb_device_id hanwang_ids[] = {
	446	{ HANWANG_TABLET_DEVICE(USB_VENDOR_ID_HANWANG, HANWANG_TABLET_INT_CLASS,
	447	HANWANG_TABLET_INT_SUB_CLASS, HANWANG_TABLET_INT_PROTOCOL) },
	448	{}
	449	};
	450
	451	MODULE_DEVICE_TABLE(usb, hanwang_ids);
	452
	453	static struct usb_driver hanwang_driver = {
	454	.name = "hanwang",
	455	.probe = hanwang_probe,
	456	.disconnect = hanwang_disconnect,
	457	.id_table = hanwang_ids,
	458	};
	459
08642e7c	460	module_usb_driver(hanwang_driver);