[deliverable/linux.git] / drivers / hid / hid-wacom.c

/*
 *  Bluetooth Wacom Tablet support
 *
 *  Copyright (c) 1999 Andreas Gal
 *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
 *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
 *  Copyright (c) 2006-2007 Jiri Kosina
 *  Copyright (c) 2007 Paul Walmsley
 *  Copyright (c) 2008 Jiri Slaby <jirislaby@gmail.com>
 *  Copyright (c) 2006 Andrew Zabolotny <zap@homelink.ru>
 *  Copyright (c) 2009 Bastien Nocera <hadess@hadess.net>
 */

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

#include <linux/device.h>
#include <linux/hid.h>
#include <linux/module.h>

#include "hid-ids.h"

struct wacom_data {
	__u16 tool;
	unsigned char butstate;
};

static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
		u8 *raw_data, int size)
{
	struct wacom_data *wdata = hid_get_drvdata(hdev);
	struct hid_input *hidinput;
	struct input_dev *input;
	unsigned char *data = (unsigned char *) raw_data;
	int tool, x, y, rw;

	if (!(hdev->claimed & HID_CLAIMED_INPUT))
		return 0;

	tool = 0;
	hidinput = list_entry(hdev->inputs.next, struct hid_input, list);
	input = hidinput->input;

	/* Check if this is a tablet report */
	if (data[0] != 0x03)
		return 0;

	/* Get X & Y positions */
	x = le16_to_cpu(*(__le16 *) &data[2]);
	y = le16_to_cpu(*(__le16 *) &data[4]);

	/* Get current tool identifier */
	if (data[1] & 0x90) { /* If pen is in the in/active area */
		switch ((data[1] >> 5) & 3) {
		case 0:	/* Pen */
			tool = BTN_TOOL_PEN;
			break;

		case 1: /* Rubber */
			tool = BTN_TOOL_RUBBER;
			break;

		case 2: /* Mouse with wheel */
		case 3: /* Mouse without wheel */
			tool = BTN_TOOL_MOUSE;
			break;
		}

		/* Reset tool if out of active tablet area */
		if (!(data[1] & 0x10))
			tool = 0;
	}

	/* If tool changed, notify input subsystem */
	if (wdata->tool != tool) {
		if (wdata->tool) {
			/* Completely reset old tool state */
			if (wdata->tool == BTN_TOOL_MOUSE) {
				input_report_key(input, BTN_LEFT, 0);
				input_report_key(input, BTN_RIGHT, 0);
				input_report_key(input, BTN_MIDDLE, 0);
				input_report_abs(input, ABS_DISTANCE,
						input->absmax[ABS_DISTANCE]);
			} else {
				input_report_key(input, BTN_TOUCH, 0);
				input_report_key(input, BTN_STYLUS, 0);
				input_report_key(input, BTN_STYLUS2, 0);
				input_report_abs(input, ABS_PRESSURE, 0);
			}
			input_report_key(input, wdata->tool, 0);
			input_sync(input);
		}
		wdata->tool = tool;
		if (tool)
			input_report_key(input, tool, 1);
	}

	if (tool) {
		input_report_abs(input, ABS_X, x);
		input_report_abs(input, ABS_Y, y);

		switch ((data[1] >> 5) & 3) {
		case 2: /* Mouse with wheel */
			input_report_key(input, BTN_MIDDLE, data[1] & 0x04);
			rw = (data[6] & 0x01) ? -1 :
				(data[6] & 0x02) ? 1 : 0;
			input_report_rel(input, REL_WHEEL, rw);
			/* fall through */

		case 3: /* Mouse without wheel */
			input_report_key(input, BTN_LEFT, data[1] & 0x01);
			input_report_key(input, BTN_RIGHT, data[1] & 0x02);
			/* Compute distance between mouse and tablet */
			rw = 44 - (data[6] >> 2);
			if (rw < 0)
				rw = 0;
			else if (rw > 31)
				rw = 31;
			input_report_abs(input, ABS_DISTANCE, rw);
			break;

		default:
			input_report_abs(input, ABS_PRESSURE,
					data[6] | (((__u16) (data[1] & 0x08)) << 5));
			input_report_key(input, BTN_TOUCH, data[1] & 0x01);
			input_report_key(input, BTN_STYLUS, data[1] & 0x02);
			input_report_key(input, BTN_STYLUS2, (tool == BTN_TOOL_PEN) && data[1] & 0x04);
			break;
		}

		input_sync(input);
	}

	/* Report the state of the two buttons at the top of the tablet
	 * as two extra fingerpad keys (buttons 4 & 5). */
	rw = data[7] & 0x03;
	if (rw != wdata->butstate) {
		wdata->butstate = rw;
		input_report_key(input, BTN_0, rw & 0x02);
		input_report_key(input, BTN_1, rw & 0x01);
		input_report_key(input, BTN_TOOL_FINGER, 0xf0);
		input_event(input, EV_MSC, MSC_SERIAL, 0xf0);
		input_sync(input);
	}

	return 1;
}

static int wacom_probe(struct hid_device *hdev,
		const struct hid_device_id *id)
{
	struct hid_input *hidinput;
	struct input_dev *input;
	struct wacom_data *wdata;
	char rep_data[2];
	int ret;
	int limit;

	wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
	if (wdata == NULL) {
		dev_err(&hdev->dev, "can't alloc wacom descriptor\n");
		return -ENOMEM;
	}

	hid_set_drvdata(hdev, wdata);

	/* Parse the HID report now */
	ret = hid_parse(hdev);
	if (ret) {
		dev_err(&hdev->dev, "parse failed\n");
		goto err_free;
	}

	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	if (ret) {
		dev_err(&hdev->dev, "hw start failed\n");
		goto err_free;
	}

	/*
	 * Note that if the raw queries fail, it's not a hard failure and it
	 * is safe to continue
	 */

	/* Set Wacom mode2 */
	rep_data[0] = 0x03; rep_data[1] = 0x00;
	limit = 3;
	do {
		ret = hdev->hid_output_raw_report(hdev, rep_data, 2,
				HID_FEATURE_REPORT);
	} while (ret < 0 && limit-- > 0);
	if (ret < 0)
		dev_warn(&hdev->dev, "failed to poke device #1, %d\n", ret);

	/* 0x06 - high reporting speed, 0x05 - low speed */
	rep_data[0] = 0x06; rep_data[1] = 0x00;
	limit = 3;
	do {
		ret = hdev->hid_output_raw_report(hdev, rep_data, 2,
				HID_FEATURE_REPORT);
	} while (ret < 0 && limit-- > 0);
	if (ret < 0)
		dev_warn(&hdev->dev, "failed to poke device #2, %d\n", ret);

	hidinput = list_entry(hdev->inputs.next, struct hid_input, list);
	input = hidinput->input;

	/* Basics */
	input->evbit[0] |= BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_REL);
	input->absbit[0] |= BIT(ABS_X) | BIT(ABS_Y) |
		BIT(ABS_PRESSURE) | BIT(ABS_DISTANCE);
	input->relbit[0] |= BIT(REL_WHEEL);
	set_bit(BTN_TOOL_PEN, input->keybit);
	set_bit(BTN_TOUCH, input->keybit);
	set_bit(BTN_STYLUS, input->keybit);
	set_bit(BTN_STYLUS2, input->keybit);
	set_bit(BTN_LEFT, input->keybit);
	set_bit(BTN_RIGHT, input->keybit);
	set_bit(BTN_MIDDLE, input->keybit);

	/* Pad */
	input->evbit[0] |= BIT(EV_MSC);
	input->mscbit[0] |= BIT(MSC_SERIAL);
	set_bit(BTN_0, input->keybit);
	set_bit(BTN_1, input->keybit);
	set_bit(BTN_TOOL_FINGER, input->keybit);

	/* Distance, rubber and mouse */
	input->absbit[0] |= BIT(ABS_DISTANCE);
	set_bit(BTN_TOOL_RUBBER, input->keybit);
	set_bit(BTN_TOOL_MOUSE, input->keybit);

	input->absmax[ABS_PRESSURE] = 511;
	input->absmax[ABS_DISTANCE] = 32;

	input->absmax[ABS_X] = 16704;
	input->absmax[ABS_Y] = 12064;
	input->absfuzz[ABS_X] = 4;
	input->absfuzz[ABS_Y] = 4;

	return 0;
err_free:
	kfree(wdata);
	return ret;
}

static void wacom_remove(struct hid_device *hdev)
{
	hid_hw_stop(hdev);
	kfree(hid_get_drvdata(hdev));
}

static const struct hid_device_id wacom_devices[] = {
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH) },

	{ }
};
MODULE_DEVICE_TABLE(hid, wacom_devices);

static struct hid_driver wacom_driver = {
	.name = "wacom",
	.id_table = wacom_devices,
	.probe = wacom_probe,
	.remove = wacom_remove,
	.raw_event = wacom_raw_event,
};

static int __init wacom_init(void)
{
	int ret;

	ret = hid_register_driver(&wacom_driver);
	if (ret)
		printk(KERN_ERR "can't register wacom driver\n");
	printk(KERN_ERR "wacom driver registered\n");
	return ret;
}

static void __exit wacom_exit(void)
{
	hid_unregister_driver(&wacom_driver);
}

module_init(wacom_init);
module_exit(wacom_exit);
MODULE_LICENSE("GPL");
Commit	Line	Data
ca2dcd40 BN	1	/*
	2	* Bluetooth Wacom Tablet support
	3	*
	4	* Copyright (c) 1999 Andreas Gal
	5	* Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
	6	* Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
	7	* Copyright (c) 2006-2007 Jiri Kosina
	8	* Copyright (c) 2007 Paul Walmsley
	9	* Copyright (c) 2008 Jiri Slaby <jirislaby@gmail.com>
	10	* Copyright (c) 2006 Andrew Zabolotny <zap@homelink.ru>
	11	* Copyright (c) 2009 Bastien Nocera <hadess@hadess.net>
	12	*/
	13
	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 as published by the Free
	17	* Software Foundation; either version 2 of the License, or (at your option)
	18	* any later version.
	19	*/
	20
	21	#include <linux/device.h>
	22	#include <linux/hid.h>
	23	#include <linux/module.h>
	24
	25	#include "hid-ids.h"
	26
	27	struct wacom_data {
	28	__u16 tool;
	29	unsigned char butstate;
	30	};
	31
	32	static int wacom_raw_event(struct hid_device hdev, struct hid_report report,
	33	u8 *raw_data, int size)
	34	{
	35	struct wacom_data *wdata = hid_get_drvdata(hdev);
	36	struct hid_input *hidinput;
	37	struct input_dev *input;
	38	unsigned char data = (unsigned char ) raw_data;
	39	int tool, x, y, rw;
	40
	41	if (!(hdev->claimed & HID_CLAIMED_INPUT))
	42	return 0;
	43
	44	tool = 0;
	45	hidinput = list_entry(hdev->inputs.next, struct hid_input, list);
	46	input = hidinput->input;
	47
	48	/* Check if this is a tablet report */
	49	if (data[0] != 0x03)
	50	return 0;
	51
	52	/* Get X & Y positions */
	53	x = le16_to_cpu((__le16 ) &data[2]);
	54	y = le16_to_cpu((__le16 ) &data[4]);
	55
	56	/* Get current tool identifier */
	57	if (data[1] & 0x90) { /* If pen is in the in/active area */
	58	switch ((data[1] >> 5) & 3) {
	59	case 0: /* Pen */
	60	tool = BTN_TOOL_PEN;
	61	break;
	62
	63	case 1: /* Rubber */
	64	tool = BTN_TOOL_RUBBER;
65	break;
66
67	case 2: /* Mouse with wheel */
68	case 3: /* Mouse without wheel */
69	tool = BTN_TOOL_MOUSE;
70	break;
71	}
72
73	/* Reset tool if out of active tablet area */
74	if (!(data[1] & 0x10))
75	tool = 0;
76	}
77
78	/* If tool changed, notify input subsystem */
79	if (wdata->tool != tool) {
80	if (wdata->tool) {
81	/* Completely reset old tool state */
82	if (wdata->tool == BTN_TOOL_MOUSE) {
83	input_report_key(input, BTN_LEFT, 0);
84	input_report_key(input, BTN_RIGHT, 0);
85	input_report_key(input, BTN_MIDDLE, 0);
86	input_report_abs(input, ABS_DISTANCE,
87	input->absmax[ABS_DISTANCE]);
88	} else {
89	input_report_key(input, BTN_TOUCH, 0);
90	input_report_key(input, BTN_STYLUS, 0);
91	input_report_key(input, BTN_STYLUS2, 0);
92	input_report_abs(input, ABS_PRESSURE, 0);
93	}
94	input_report_key(input, wdata->tool, 0);
95	input_sync(input);
96	}
97	wdata->tool = tool;
98	if (tool)
99	input_report_key(input, tool, 1);
100	}
101
102	if (tool) {
103	input_report_abs(input, ABS_X, x);
104	input_report_abs(input, ABS_Y, y);
105
106	switch ((data[1] >> 5) & 3) {
107	case 2: /* Mouse with wheel */
108	input_report_key(input, BTN_MIDDLE, data[1] & 0x04);
109	rw = (data[6] & 0x01) ? -1 :
110	(data[6] & 0x02) ? 1 : 0;
111	input_report_rel(input, REL_WHEEL, rw);
112	/* fall through */
113
114	case 3: /* Mouse without wheel */
115	input_report_key(input, BTN_LEFT, data[1] & 0x01);
116	input_report_key(input, BTN_RIGHT, data[1] & 0x02);
117	/* Compute distance between mouse and tablet */
118	rw = 44 - (data[6] >> 2);
119	if (rw < 0)
120	rw = 0;
121	else if (rw > 31)
122	rw = 31;
123	input_report_abs(input, ABS_DISTANCE, rw);
124	break;
125
126	default:
127	input_report_abs(input, ABS_PRESSURE,
128	data[6] \| (((__u16) (data[1] & 0x08)) << 5));
129	input_report_key(input, BTN_TOUCH, data[1] & 0x01);
130	input_report_key(input, BTN_STYLUS, data[1] & 0x02);
131	input_report_key(input, BTN_STYLUS2, (tool == BTN_TOOL_PEN) && data[1] & 0x04);
132	break;
133	}
134
135	input_sync(input);
136	}
137
138	/* Report the state of the two buttons at the top of the tablet
139	* as two extra fingerpad keys (buttons 4 & 5). */
140	rw = data[7] & 0x03;
141	if (rw != wdata->butstate) {
142	wdata->butstate = rw;
143	input_report_key(input, BTN_0, rw & 0x02);
144	input_report_key(input, BTN_1, rw & 0x01);
0e253fdb	145	input_report_key(input, BTN_TOOL_FINGER, 0xf0);
ca2dcd40 BN	146	input_event(input, EV_MSC, MSC_SERIAL, 0xf0);
	147	input_sync(input);
	148	}
	149
	150	return 1;
	151	}
	152
	153	static int wacom_probe(struct hid_device *hdev,
	154	const struct hid_device_id *id)
	155	{
	156	struct hid_input *hidinput;
	157	struct input_dev *input;
	158	struct wacom_data *wdata;
46a709b9	159	char rep_data[2];
ca2dcd40	160	int ret;
46a709b9	161	int limit;
ca2dcd40 BN	162
	163	wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
	164	if (wdata == NULL) {
	165	dev_err(&hdev->dev, "can't alloc wacom descriptor\n");
	166	return -ENOMEM;
	167	}
	168
	169	hid_set_drvdata(hdev, wdata);
	170
46a709b9	171	/* Parse the HID report now */
ca2dcd40 BN	172	ret = hid_parse(hdev);
	173	if (ret) {
	174	dev_err(&hdev->dev, "parse failed\n");
	175	goto err_free;
	176	}
	177
	178	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	179	if (ret) {
	180	dev_err(&hdev->dev, "hw start failed\n");
	181	goto err_free;
	182	}
	183
342f31e8 JK	184	/*
	185	* Note that if the raw queries fail, it's not a hard failure and it
	186	* is safe to continue
	187	*/
	188
46a709b9 BN	189	/* Set Wacom mode2 */
	190	rep_data[0] = 0x03; rep_data[1] = 0x00;
	191	limit = 3;
	192	do {
	193	ret = hdev->hid_output_raw_report(hdev, rep_data, 2,
	194	HID_FEATURE_REPORT);
	195	} while (ret < 0 && limit-- > 0);
342f31e8 JK	196	if (ret < 0)
342f31e8 JK	197	dev_warn(&hdev->dev, "failed to poke device #1, %d\n", ret);
46a709b9 BN	198
	199	/* 0x06 - high reporting speed, 0x05 - low speed */
	200	rep_data[0] = 0x06; rep_data[1] = 0x00;
	201	limit = 3;
	202	do {
	203	ret = hdev->hid_output_raw_report(hdev, rep_data, 2,
	204	HID_FEATURE_REPORT);
	205	} while (ret < 0 && limit-- > 0);
342f31e8 JK	206	if (ret < 0)
342f31e8 JK	207	dev_warn(&hdev->dev, "failed to poke device #2, %d\n", ret);
46a709b9	208
ca2dcd40 BN	209	hidinput = list_entry(hdev->inputs.next, struct hid_input, list);
	210	input = hidinput->input;
	211
	212	/* Basics */
	213	input->evbit[0] \|= BIT(EV_KEY) \| BIT(EV_ABS) \| BIT(EV_REL);
	214	input->absbit[0] \|= BIT(ABS_X) \| BIT(ABS_Y) \|
	215	BIT(ABS_PRESSURE) \| BIT(ABS_DISTANCE);
	216	input->relbit[0] \|= BIT(REL_WHEEL);
	217	set_bit(BTN_TOOL_PEN, input->keybit);
	218	set_bit(BTN_TOUCH, input->keybit);
	219	set_bit(BTN_STYLUS, input->keybit);
	220	set_bit(BTN_STYLUS2, input->keybit);
	221	set_bit(BTN_LEFT, input->keybit);
	222	set_bit(BTN_RIGHT, input->keybit);
	223	set_bit(BTN_MIDDLE, input->keybit);
	224
	225	/* Pad */
	226	input->evbit[0] \|= BIT(EV_MSC);
	227	input->mscbit[0] \|= BIT(MSC_SERIAL);
d01799b2 PF	228	set_bit(BTN_0, input->keybit);
	229	set_bit(BTN_1, input->keybit);
	230	set_bit(BTN_TOOL_FINGER, input->keybit);
ca2dcd40 BN	231
	232	/* Distance, rubber and mouse */
	233	input->absbit[0] \|= BIT(ABS_DISTANCE);
	234	set_bit(BTN_TOOL_RUBBER, input->keybit);
	235	set_bit(BTN_TOOL_MOUSE, input->keybit);
	236
	237	input->absmax[ABS_PRESSURE] = 511;
	238	input->absmax[ABS_DISTANCE] = 32;
	239
	240	input->absmax[ABS_X] = 16704;
	241	input->absmax[ABS_Y] = 12064;
	242	input->absfuzz[ABS_X] = 4;
	243	input->absfuzz[ABS_Y] = 4;
	244
	245	return 0;
	246	err_free:
	247	kfree(wdata);
	248	return ret;
	249	}
	250
	251	static void wacom_remove(struct hid_device *hdev)
	252	{
	253	hid_hw_stop(hdev);
	254	kfree(hid_get_drvdata(hdev));
	255	}
	256
	257	static const struct hid_device_id wacom_devices[] = {
	258	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE_BLUETOOTH) },
	259
	260	{ }
	261	};
	262	MODULE_DEVICE_TABLE(hid, wacom_devices);
	263
	264	static struct hid_driver wacom_driver = {
	265	.name = "wacom",
	266	.id_table = wacom_devices,
	267	.probe = wacom_probe,
	268	.remove = wacom_remove,
	269	.raw_event = wacom_raw_event,
	270	};
	271
a24f423b	272	static int __init wacom_init(void)
ca2dcd40 BN	273	{
	274	int ret;
	275
	276	ret = hid_register_driver(&wacom_driver);
	277	if (ret)
	278	printk(KERN_ERR "can't register wacom driver\n");
	279	printk(KERN_ERR "wacom driver registered\n");
	280	return ret;
	281	}
	282
a24f423b	283	static void __exit wacom_exit(void)
ca2dcd40 BN	284	{
	285	hid_unregister_driver(&wacom_driver);
	286	}
	287
	288	module_init(wacom_init);
	289	module_exit(wacom_exit);
	290	MODULE_LICENSE("GPL");
	291