[linux.git] / drivers / hid / hid-udraw-ps3.c

/*
 * HID driver for THQ PS3 uDraw tablet
 *
 * Copyright (C) 2016 Red Hat Inc. All Rights Reserved
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/device.h>
#include <linux/hid.h>
#include <linux/module.h>
#include "hid-ids.h"

MODULE_AUTHOR("Bastien Nocera <[email protected]>");
MODULE_DESCRIPTION("PS3 uDraw tablet driver");
MODULE_LICENSE("GPL");

/*
 * Protocol information from:
 * http://brandonw.net/udraw/
 * and the source code of:
 * https://vvvv.org/contribution/udraw-hid
 */

/*
 * The device is setup with multiple input devices:
 * - the touch area which works as a touchpad
 * - the tablet area which works as a touchpad/drawing tablet
 * - a joypad with a d-pad, and 7 buttons
 * - an accelerometer device
 */

enum {
	TOUCH_NONE,
	TOUCH_PEN,
	TOUCH_FINGER,
	TOUCH_TWOFINGER
};

enum {
	AXIS_X,
	AXIS_Y,
	AXIS_Z
};

/*
 * Accelerometer min/max values
 * in order, X, Y and Z
 */
static struct {
	int min;
	int max;
} accel_limits[] = {
	[AXIS_X] = { 490, 534 },
	[AXIS_Y] = { 490, 534 },
	[AXIS_Z] = { 492, 536 }
};

#define DEVICE_NAME "THQ uDraw Game Tablet for PS3"
/* resolution in pixels */
#define RES_X 1920
#define RES_Y 1080
/* size in mm */
#define WIDTH  160
#define HEIGHT 90
#define PRESSURE_OFFSET 113
#define MAX_PRESSURE (255 - PRESSURE_OFFSET)

struct udraw {
	struct input_dev *joy_input_dev;
	struct input_dev *touch_input_dev;
	struct input_dev *pen_input_dev;
	struct input_dev *accel_input_dev;
	struct hid_device *hdev;

	/*
	 * The device's two-finger support is pretty unreliable, as
	 * the device could report a single touch when the two fingers
	 * are too close together, and the distance between fingers, even
	 * though reported is not in the same unit as the touches.
	 *
	 * We'll make do without it, and try to report the first touch
	 * as reliably as possible.
	 */
	int last_one_finger_x;
	int last_one_finger_y;
	int last_two_finger_x;
	int last_two_finger_y;
};

static int clamp_accel(int axis, int offset)
{
	axis = clamp(axis,
			accel_limits[offset].min,
			accel_limits[offset].max);
	axis = (axis - accel_limits[offset].min) /
			((accel_limits[offset].max -
			  accel_limits[offset].min) * 0xFF);
	return axis;
}

static int udraw_raw_event(struct hid_device *hdev, struct hid_report *report,
	 u8 *data, int len)
{
	struct udraw *udraw = hid_get_drvdata(hdev);
	int touch;
	int x, y, z;

	if (len != 27)
		return 0;

	if (data[11] == 0x00)
		touch = TOUCH_NONE;
	else if (data[11] == 0x40)
		touch = TOUCH_PEN;
	else if (data[11] == 0x80)
		touch = TOUCH_FINGER;
	else
		touch = TOUCH_TWOFINGER;

	/* joypad */
	input_report_key(udraw->joy_input_dev, BTN_WEST, data[0] & 1);
	input_report_key(udraw->joy_input_dev, BTN_SOUTH, !!(data[0] & 2));
	input_report_key(udraw->joy_input_dev, BTN_EAST, !!(data[0] & 4));
	input_report_key(udraw->joy_input_dev, BTN_NORTH, !!(data[0] & 8));

	input_report_key(udraw->joy_input_dev, BTN_SELECT, !!(data[1] & 1));
	input_report_key(udraw->joy_input_dev, BTN_START, !!(data[1] & 2));
	input_report_key(udraw->joy_input_dev, BTN_MODE, !!(data[1] & 16));

	x = y = 0;
	switch (data[2]) {
	case 0x0:
		y = -127;
		break;
	case 0x1:
		y = -127;
		x = 127;
		break;
	case 0x2:
		x = 127;
		break;
	case 0x3:
		y = 127;
		x = 127;
		break;
	case 0x4:
		y = 127;
		break;
	case 0x5:
		y = 127;
		x = -127;
		break;
	case 0x6:
		x = -127;
		break;
	case 0x7:
		y = -127;
		x = -127;
		break;
	default:
		break;
	}

	input_report_abs(udraw->joy_input_dev, ABS_X, x);
	input_report_abs(udraw->joy_input_dev, ABS_Y, y);

	input_sync(udraw->joy_input_dev);

	/* For pen and touchpad */
	x = y = 0;
	if (touch != TOUCH_NONE) {
		if (data[15] != 0x0F)
			x = data[15] * 256 + data[17];
		if (data[16] != 0x0F)
			y = data[16] * 256 + data[18];
	}

	if (touch == TOUCH_FINGER) {
		/* Save the last one-finger touch */
		udraw->last_one_finger_x = x;
		udraw->last_one_finger_y = y;
		udraw->last_two_finger_x = -1;
		udraw->last_two_finger_y = -1;
	} else if (touch == TOUCH_TWOFINGER) {
		/*
		 * We have a problem because x/y is the one for the
		 * second finger but we want the first finger given
		 * to user-space otherwise it'll look as if it jumped.
		 *
		 * See the udraw struct definition for why this was
		 * implemented this way.
		 */
		if (udraw->last_two_finger_x == -1) {
			/* Save the position of the 2nd finger */
			udraw->last_two_finger_x = x;
			udraw->last_two_finger_y = y;

			x = udraw->last_one_finger_x;
			y = udraw->last_one_finger_y;
		} else {
			/*
			 * Offset the 2-finger coords using the
			 * saved data from the first finger
			 */
			x = x - (udraw->last_two_finger_x
				- udraw->last_one_finger_x);
			y = y - (udraw->last_two_finger_y
				- udraw->last_one_finger_y);
		}
	}

	/* touchpad */
	if (touch == TOUCH_FINGER || touch == TOUCH_TWOFINGER) {
		input_report_key(udraw->touch_input_dev, BTN_TOUCH, 1);
		input_report_key(udraw->touch_input_dev, BTN_TOOL_FINGER,
				touch == TOUCH_FINGER);
		input_report_key(udraw->touch_input_dev, BTN_TOOL_DOUBLETAP,
				touch == TOUCH_TWOFINGER);

		input_report_abs(udraw->touch_input_dev, ABS_X, x);
		input_report_abs(udraw->touch_input_dev, ABS_Y, y);
	} else {
		input_report_key(udraw->touch_input_dev, BTN_TOUCH, 0);
		input_report_key(udraw->touch_input_dev, BTN_TOOL_FINGER, 0);
		input_report_key(udraw->touch_input_dev, BTN_TOOL_DOUBLETAP, 0);
	}
	input_sync(udraw->touch_input_dev);

	/* pen */
	if (touch == TOUCH_PEN) {
		int level;

		level = clamp(data[13] - PRESSURE_OFFSET,
				0, MAX_PRESSURE);

		input_report_key(udraw->pen_input_dev, BTN_TOUCH, (level != 0));
		input_report_key(udraw->pen_input_dev, BTN_TOOL_PEN, 1);
		input_report_abs(udraw->pen_input_dev, ABS_PRESSURE, level);
		input_report_abs(udraw->pen_input_dev, ABS_X, x);
		input_report_abs(udraw->pen_input_dev, ABS_Y, y);
	} else {
		input_report_key(udraw->pen_input_dev, BTN_TOUCH, 0);
		input_report_key(udraw->pen_input_dev, BTN_TOOL_PEN, 0);
		input_report_abs(udraw->pen_input_dev, ABS_PRESSURE, 0);
	}
	input_sync(udraw->pen_input_dev);

	/* accel */
	x = (data[19] + (data[20] << 8));
	x = clamp_accel(x, AXIS_X);
	y = (data[21] + (data[22] << 8));
	y = clamp_accel(y, AXIS_Y);
	z = (data[23] + (data[24] << 8));
	z = clamp_accel(z, AXIS_Z);
	input_report_abs(udraw->accel_input_dev, ABS_X, x);
	input_report_abs(udraw->accel_input_dev, ABS_Y, y);
	input_report_abs(udraw->accel_input_dev, ABS_Z, z);
	input_sync(udraw->accel_input_dev);

	/* let hidraw and hiddev handle the report */
	return 0;
}

static int udraw_open(struct input_dev *dev)
{
	struct udraw *udraw = input_get_drvdata(dev);

	return hid_hw_open(udraw->hdev);
}

static void udraw_close(struct input_dev *dev)
{
	struct udraw *udraw = input_get_drvdata(dev);

	hid_hw_close(udraw->hdev);
}

static struct input_dev *allocate_and_setup(struct hid_device *hdev,
		const char *name)
{
	struct input_dev *input_dev;

	input_dev = devm_input_allocate_device(&hdev->dev);
	if (!input_dev)
		return NULL;

	input_dev->name = name;
	input_dev->phys = hdev->phys;
	input_dev->dev.parent = &hdev->dev;
	input_dev->open = udraw_open;
	input_dev->close = udraw_close;
	input_dev->uniq = hdev->uniq;
	input_dev->id.bustype = hdev->bus;
	input_dev->id.vendor  = hdev->vendor;
	input_dev->id.product = hdev->product;
	input_dev->id.version = hdev->version;
	input_set_drvdata(input_dev, hid_get_drvdata(hdev));

	return input_dev;
}

static bool udraw_setup_touch(struct udraw *udraw,
		struct hid_device *hdev)
{
	struct input_dev *input_dev;

	input_dev = allocate_and_setup(hdev, DEVICE_NAME " Touchpad");
	if (!input_dev)
		return false;

	input_dev->evbit[0] = BIT(EV_ABS) | BIT(EV_KEY);

	input_set_abs_params(input_dev, ABS_X, 0, RES_X, 1, 0);
	input_abs_set_res(input_dev, ABS_X, RES_X / WIDTH);
	input_set_abs_params(input_dev, ABS_Y, 0, RES_Y, 1, 0);
	input_abs_set_res(input_dev, ABS_Y, RES_Y / HEIGHT);

	set_bit(BTN_TOUCH, input_dev->keybit);
	set_bit(BTN_TOOL_FINGER, input_dev->keybit);
	set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);

	set_bit(INPUT_PROP_POINTER, input_dev->propbit);

	udraw->touch_input_dev = input_dev;

	return true;
}

static bool udraw_setup_pen(struct udraw *udraw,
		struct hid_device *hdev)
{
	struct input_dev *input_dev;

	input_dev = allocate_and_setup(hdev, DEVICE_NAME " Pen");
	if (!input_dev)
		return false;

	input_dev->evbit[0] = BIT(EV_ABS) | BIT(EV_KEY);

	input_set_abs_params(input_dev, ABS_X, 0, RES_X, 1, 0);
	input_abs_set_res(input_dev, ABS_X, RES_X / WIDTH);
	input_set_abs_params(input_dev, ABS_Y, 0, RES_Y, 1, 0);
	input_abs_set_res(input_dev, ABS_Y, RES_Y / HEIGHT);
	input_set_abs_params(input_dev, ABS_PRESSURE,
			0, MAX_PRESSURE, 0, 0);

	set_bit(BTN_TOUCH, input_dev->keybit);
	set_bit(BTN_TOOL_PEN, input_dev->keybit);

	set_bit(INPUT_PROP_POINTER, input_dev->propbit);

	udraw->pen_input_dev = input_dev;

	return true;
}

static bool udraw_setup_accel(struct udraw *udraw,
		struct hid_device *hdev)
{
	struct input_dev *input_dev;

	input_dev = allocate_and_setup(hdev, DEVICE_NAME " Accelerometer");
	if (!input_dev)
		return false;

	input_dev->evbit[0] = BIT(EV_ABS);

	/* 1G accel is reported as ~256, so clamp to 2G */
	input_set_abs_params(input_dev, ABS_X, -512, 512, 0, 0);
	input_set_abs_params(input_dev, ABS_Y, -512, 512, 0, 0);
	input_set_abs_params(input_dev, ABS_Z, -512, 512, 0, 0);

	set_bit(INPUT_PROP_ACCELEROMETER, input_dev->propbit);

	udraw->accel_input_dev = input_dev;

	return true;
}

static bool udraw_setup_joypad(struct udraw *udraw,
		struct hid_device *hdev)
{
	struct input_dev *input_dev;

	input_dev = allocate_and_setup(hdev, DEVICE_NAME " Joypad");
	if (!input_dev)
		return false;

	input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);

	set_bit(BTN_SOUTH, input_dev->keybit);
	set_bit(BTN_NORTH, input_dev->keybit);
	set_bit(BTN_EAST, input_dev->keybit);
	set_bit(BTN_WEST, input_dev->keybit);
	set_bit(BTN_SELECT, input_dev->keybit);
	set_bit(BTN_START, input_dev->keybit);
	set_bit(BTN_MODE, input_dev->keybit);

	input_set_abs_params(input_dev, ABS_X, -127, 127, 0, 0);
	input_set_abs_params(input_dev, ABS_Y, -127, 127, 0, 0);

	udraw->joy_input_dev = input_dev;

	return true;
}

static int udraw_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
	struct udraw *udraw;
	int ret;

	udraw = devm_kzalloc(&hdev->dev, sizeof(struct udraw), GFP_KERNEL);
	if (!udraw)
		return -ENOMEM;

	udraw->hdev = hdev;
	udraw->last_two_finger_x = -1;
	udraw->last_two_finger_y = -1;

	hid_set_drvdata(hdev, udraw);

	ret = hid_parse(hdev);
	if (ret) {
		hid_err(hdev, "parse failed\n");
		return ret;
	}

	if (!udraw_setup_joypad(udraw, hdev) ||
	    !udraw_setup_touch(udraw, hdev) ||
	    !udraw_setup_pen(udraw, hdev) ||
	    !udraw_setup_accel(udraw, hdev)) {
		hid_err(hdev, "could not allocate interfaces\n");
		return -ENOMEM;
	}

	ret = input_register_device(udraw->joy_input_dev) ||
		input_register_device(udraw->touch_input_dev) ||
		input_register_device(udraw->pen_input_dev) ||
		input_register_device(udraw->accel_input_dev);
	if (ret) {
		hid_err(hdev, "failed to register interfaces\n");
		return ret;
	}

	ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW | HID_CONNECT_DRIVER);
	if (ret) {
		hid_err(hdev, "hw start failed\n");
		return ret;
	}

	return 0;
}

static const struct hid_device_id udraw_devices[] = {
	{ HID_USB_DEVICE(USB_VENDOR_ID_THQ, USB_DEVICE_ID_THQ_PS3_UDRAW) },
	{ }
};
MODULE_DEVICE_TABLE(hid, udraw_devices);

static struct hid_driver udraw_driver = {
	.name = "hid-udraw",
	.id_table = udraw_devices,
	.raw_event = udraw_raw_event,
	.probe = udraw_probe,
};
module_hid_driver(udraw_driver);
Commit	Line	Data
0edffe65 BN	1	/*
	2	* HID driver for THQ PS3 uDraw tablet
	3	*
	4	* Copyright (C) 2016 Red Hat Inc. All Rights Reserved
	5	*
	6	* This software is licensed under the terms of the GNU General Public
	7	* License version 2, as published by the Free Software Foundation, and
	8	* may be copied, distributed, and modified under those terms.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*/
	15
	16	#include <linux/device.h>
	17	#include <linux/hid.h>
	18	#include <linux/module.h>
	19	#include "hid-ids.h"
	20
	21	MODULE_AUTHOR("Bastien Nocera <[email protected]>");
	22	MODULE_DESCRIPTION("PS3 uDraw tablet driver");
	23	MODULE_LICENSE("GPL");
	24
	25	/*
	26	* Protocol information from:
	27	* http://brandonw.net/udraw/
	28	* and the source code of:
	29	* https://vvvv.org/contribution/udraw-hid
	30	*/
	31
	32	/*
	33	* The device is setup with multiple input devices:
	34	* - the touch area which works as a touchpad
	35	* - the tablet area which works as a touchpad/drawing tablet
	36	* - a joypad with a d-pad, and 7 buttons
	37	* - an accelerometer device
	38	*/
	39
	40	enum {
	41	TOUCH_NONE,
	42	TOUCH_PEN,
	43	TOUCH_FINGER,
	44	TOUCH_TWOFINGER
	45	};
	46
	47	enum {
	48	AXIS_X,
	49	AXIS_Y,
	50	AXIS_Z
	51	};
	52
	53	/*
	54	* Accelerometer min/max values
	55	* in order, X, Y and Z
	56	*/
9c5dcd72	57	static struct {
0edffe65 BN	58	int min;
	59	int max;
	60	} accel_limits[] = {
	61	[AXIS_X] = { 490, 534 },
	62	[AXIS_Y] = { 490, 534 },
	63	[AXIS_Z] = { 492, 536 }
	64	};
	65
	66	#define DEVICE_NAME "THQ uDraw Game Tablet for PS3"
	67	/* resolution in pixels */
	68	#define RES_X 1920
	69	#define RES_Y 1080
	70	/* size in mm */
	71	#define WIDTH 160
	72	#define HEIGHT 90
	73	#define PRESSURE_OFFSET 113
	74	#define MAX_PRESSURE (255 - PRESSURE_OFFSET)
	75
	76	struct udraw {
	77	struct input_dev *joy_input_dev;
	78	struct input_dev *touch_input_dev;
	79	struct input_dev *pen_input_dev;
	80	struct input_dev *accel_input_dev;
	81	struct hid_device *hdev;
	82
	83	/*
	84	* The device's two-finger support is pretty unreliable, as
	85	* the device could report a single touch when the two fingers
	86	* are too close together, and the distance between fingers, even
	87	* though reported is not in the same unit as the touches.
	88	*
	89	* We'll make do without it, and try to report the first touch
	90	* as reliably as possible.
	91	*/
	92	int last_one_finger_x;
	93	int last_one_finger_y;
	94	int last_two_finger_x;
	95	int last_two_finger_y;
	96	};
	97
	98	static int clamp_accel(int axis, int offset)
	99	{
	100	axis = clamp(axis,
	101	accel_limits[offset].min,
	102	accel_limits[offset].max);
	103	axis = (axis - accel_limits[offset].min) /
	104	((accel_limits[offset].max -
	105	accel_limits[offset].min) * 0xFF);
	106	return axis;
	107	}
	108
	109	static int udraw_raw_event(struct hid_device hdev, struct hid_report report,
	110	u8 *data, int len)
	111	{
	112	struct udraw *udraw = hid_get_drvdata(hdev);
	113	int touch;
	114	int x, y, z;
	115
	116	if (len != 27)
	117	return 0;
	118
	119	if (data[11] == 0x00)
	120	touch = TOUCH_NONE;
	121	else if (data[11] == 0x40)
122	touch = TOUCH_PEN;
123	else if (data[11] == 0x80)
124	touch = TOUCH_FINGER;
125	else
126	touch = TOUCH_TWOFINGER;
127
128	/* joypad */
129	input_report_key(udraw->joy_input_dev, BTN_WEST, data[0] & 1);
130	input_report_key(udraw->joy_input_dev, BTN_SOUTH, !!(data[0] & 2));
131	input_report_key(udraw->joy_input_dev, BTN_EAST, !!(data[0] & 4));
132	input_report_key(udraw->joy_input_dev, BTN_NORTH, !!(data[0] & 8));
133
134	input_report_key(udraw->joy_input_dev, BTN_SELECT, !!(data[1] & 1));
135	input_report_key(udraw->joy_input_dev, BTN_START, !!(data[1] & 2));
136	input_report_key(udraw->joy_input_dev, BTN_MODE, !!(data[1] & 16));
137
138	x = y = 0;
139	switch (data[2]) {
140	case 0x0:
141	y = -127;
142	break;
143	case 0x1:
144	y = -127;
145	x = 127;
146	break;
147	case 0x2:
148	x = 127;
149	break;
150	case 0x3:
151	y = 127;
152	x = 127;
153	break;
154	case 0x4:
155	y = 127;
156	break;
157	case 0x5:
158	y = 127;
159	x = -127;
160	break;
161	case 0x6:
162	x = -127;
163	break;
164	case 0x7:
165	y = -127;
166	x = -127;
167	break;
168	default:
169	break;
170	}
171
172	input_report_abs(udraw->joy_input_dev, ABS_X, x);
173	input_report_abs(udraw->joy_input_dev, ABS_Y, y);
174
175	input_sync(udraw->joy_input_dev);
176
177	/* For pen and touchpad */
178	x = y = 0;
179	if (touch != TOUCH_NONE) {
180	if (data[15] != 0x0F)
181	x = data[15] * 256 + data[17];
182	if (data[16] != 0x0F)
183	y = data[16] * 256 + data[18];
184	}
185
186	if (touch == TOUCH_FINGER) {
187	/* Save the last one-finger touch */
188	udraw->last_one_finger_x = x;
189	udraw->last_one_finger_y = y;
190	udraw->last_two_finger_x = -1;
191	udraw->last_two_finger_y = -1;
192	} else if (touch == TOUCH_TWOFINGER) {
193	/*
194	* We have a problem because x/y is the one for the
195	* second finger but we want the first finger given
196	* to user-space otherwise it'll look as if it jumped.
197	*
198	* See the udraw struct definition for why this was
199	* implemented this way.
200	*/
201	if (udraw->last_two_finger_x == -1) {
202	/* Save the position of the 2nd finger */
203	udraw->last_two_finger_x = x;
204	udraw->last_two_finger_y = y;
205
206	x = udraw->last_one_finger_x;
207	y = udraw->last_one_finger_y;
208	} else {
209	/*
210	* Offset the 2-finger coords using the
211	* saved data from the first finger
212	*/
213	x = x - (udraw->last_two_finger_x
214	- udraw->last_one_finger_x);
215	y = y - (udraw->last_two_finger_y
216	- udraw->last_one_finger_y);
217	}
218	}
219
220	/* touchpad */
221	if (touch == TOUCH_FINGER \|\| touch == TOUCH_TWOFINGER) {
222	input_report_key(udraw->touch_input_dev, BTN_TOUCH, 1);
223	input_report_key(udraw->touch_input_dev, BTN_TOOL_FINGER,
224	touch == TOUCH_FINGER);
225	input_report_key(udraw->touch_input_dev, BTN_TOOL_DOUBLETAP,
226	touch == TOUCH_TWOFINGER);
227
228	input_report_abs(udraw->touch_input_dev, ABS_X, x);
229	input_report_abs(udraw->touch_input_dev, ABS_Y, y);
230	} else {
231	input_report_key(udraw->touch_input_dev, BTN_TOUCH, 0);
232	input_report_key(udraw->touch_input_dev, BTN_TOOL_FINGER, 0);
233	input_report_key(udraw->touch_input_dev, BTN_TOOL_DOUBLETAP, 0);
234	}
235	input_sync(udraw->touch_input_dev);
236
237	/* pen */
238	if (touch == TOUCH_PEN) {
239	int level;
240
241	level = clamp(data[13] - PRESSURE_OFFSET,
242	0, MAX_PRESSURE);
243
244	input_report_key(udraw->pen_input_dev, BTN_TOUCH, (level != 0));
245	input_report_key(udraw->pen_input_dev, BTN_TOOL_PEN, 1);
246	input_report_abs(udraw->pen_input_dev, ABS_PRESSURE, level);
247	input_report_abs(udraw->pen_input_dev, ABS_X, x);
248	input_report_abs(udraw->pen_input_dev, ABS_Y, y);
249	} else {
250	input_report_key(udraw->pen_input_dev, BTN_TOUCH, 0);
251	input_report_key(udraw->pen_input_dev, BTN_TOOL_PEN, 0);
252	input_report_abs(udraw->pen_input_dev, ABS_PRESSURE, 0);
253	}
254	input_sync(udraw->pen_input_dev);
255
256	/* accel */
257	x = (data[19] + (data[20] << 8));
258	x = clamp_accel(x, AXIS_X);
259	y = (data[21] + (data[22] << 8));
260	y = clamp_accel(y, AXIS_Y);
261	z = (data[23] + (data[24] << 8));
262	z = clamp_accel(z, AXIS_Z);
263	input_report_abs(udraw->accel_input_dev, ABS_X, x);
264	input_report_abs(udraw->accel_input_dev, ABS_Y, y);
265	input_report_abs(udraw->accel_input_dev, ABS_Z, z);
266	input_sync(udraw->accel_input_dev);
267
268	/* let hidraw and hiddev handle the report */
269	return 0;
270	}
271
272	static int udraw_open(struct input_dev *dev)
273	{
274	struct udraw *udraw = input_get_drvdata(dev);
275
276	return hid_hw_open(udraw->hdev);
277	}
278
279	static void udraw_close(struct input_dev *dev)
280	{
281	struct udraw *udraw = input_get_drvdata(dev);
282
283	hid_hw_close(udraw->hdev);
284	}
285
286	static struct input_dev allocate_and_setup(struct hid_device hdev,
287	const char *name)
288	{
289	struct input_dev *input_dev;
290
291	input_dev = devm_input_allocate_device(&hdev->dev);
292	if (!input_dev)
293	return NULL;
294
295	input_dev->name = name;
296	input_dev->phys = hdev->phys;
297	input_dev->dev.parent = &hdev->dev;
298	input_dev->open = udraw_open;
299	input_dev->close = udraw_close;
300	input_dev->uniq = hdev->uniq;
301	input_dev->id.bustype = hdev->bus;
302	input_dev->id.vendor = hdev->vendor;
303	input_dev->id.product = hdev->product;
304	input_dev->id.version = hdev->version;
305	input_set_drvdata(input_dev, hid_get_drvdata(hdev));
306
307	return input_dev;
308	}
309
310	static bool udraw_setup_touch(struct udraw *udraw,
311	struct hid_device *hdev)
312	{
313	struct input_dev *input_dev;
314
315	input_dev = allocate_and_setup(hdev, DEVICE_NAME " Touchpad");
316	if (!input_dev)
317	return false;
318
319	input_dev->evbit[0] = BIT(EV_ABS) \| BIT(EV_KEY);
320
321	input_set_abs_params(input_dev, ABS_X, 0, RES_X, 1, 0);
322	input_abs_set_res(input_dev, ABS_X, RES_X / WIDTH);
323	input_set_abs_params(input_dev, ABS_Y, 0, RES_Y, 1, 0);
324	input_abs_set_res(input_dev, ABS_Y, RES_Y / HEIGHT);
325
326	set_bit(BTN_TOUCH, input_dev->keybit);
327	set_bit(BTN_TOOL_FINGER, input_dev->keybit);
328	set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
329
330	set_bit(INPUT_PROP_POINTER, input_dev->propbit);
331
332	udraw->touch_input_dev = input_dev;
333
334	return true;
335	}
336
337	static bool udraw_setup_pen(struct udraw *udraw,
338	struct hid_device *hdev)
339	{
340	struct input_dev *input_dev;
341
342	input_dev = allocate_and_setup(hdev, DEVICE_NAME " Pen");
343	if (!input_dev)
344	return false;
345
346	input_dev->evbit[0] = BIT(EV_ABS) \| BIT(EV_KEY);
347
348	input_set_abs_params(input_dev, ABS_X, 0, RES_X, 1, 0);
349	input_abs_set_res(input_dev, ABS_X, RES_X / WIDTH);
350	input_set_abs_params(input_dev, ABS_Y, 0, RES_Y, 1, 0);
351	input_abs_set_res(input_dev, ABS_Y, RES_Y / HEIGHT);
352	input_set_abs_params(input_dev, ABS_PRESSURE,
353	0, MAX_PRESSURE, 0, 0);
354
355	set_bit(BTN_TOUCH, input_dev->keybit);
356	set_bit(BTN_TOOL_PEN, input_dev->keybit);
357
358	set_bit(INPUT_PROP_POINTER, input_dev->propbit);
359
360	udraw->pen_input_dev = input_dev;
361
362	return true;
363	}
364
365	static bool udraw_setup_accel(struct udraw *udraw,
366	struct hid_device *hdev)
367	{
368	struct input_dev *input_dev;
369
370	input_dev = allocate_and_setup(hdev, DEVICE_NAME " Accelerometer");
371	if (!input_dev)
372	return false;
373
374	input_dev->evbit[0] = BIT(EV_ABS);
375
376	/* 1G accel is reported as ~256, so clamp to 2G */
377	input_set_abs_params(input_dev, ABS_X, -512, 512, 0, 0);
378	input_set_abs_params(input_dev, ABS_Y, -512, 512, 0, 0);
379	input_set_abs_params(input_dev, ABS_Z, -512, 512, 0, 0);
380
381	set_bit(INPUT_PROP_ACCELEROMETER, input_dev->propbit);
382
383	udraw->accel_input_dev = input_dev;
384
385	return true;
386	}
387
388	static bool udraw_setup_joypad(struct udraw *udraw,
389	struct hid_device *hdev)
390	{
391	struct input_dev *input_dev;
392
393	input_dev = allocate_and_setup(hdev, DEVICE_NAME " Joypad");
394	if (!input_dev)
395	return false;
396
397	input_dev->evbit[0] = BIT(EV_KEY) \| BIT(EV_ABS);
398
399	set_bit(BTN_SOUTH, input_dev->keybit);
400	set_bit(BTN_NORTH, input_dev->keybit);
401	set_bit(BTN_EAST, input_dev->keybit);
402	set_bit(BTN_WEST, input_dev->keybit);
403	set_bit(BTN_SELECT, input_dev->keybit);
404	set_bit(BTN_START, input_dev->keybit);
405	set_bit(BTN_MODE, input_dev->keybit);
406
407	input_set_abs_params(input_dev, ABS_X, -127, 127, 0, 0);
408	input_set_abs_params(input_dev, ABS_Y, -127, 127, 0, 0);
409
410	udraw->joy_input_dev = input_dev;
411
412	return true;
413	}
414
415	static int udraw_probe(struct hid_device hdev, const struct hid_device_id id)
416	{
417	struct udraw *udraw;
418	int ret;
419
420	udraw = devm_kzalloc(&hdev->dev, sizeof(struct udraw), GFP_KERNEL);
421	if (!udraw)
422	return -ENOMEM;
423
424	udraw->hdev = hdev;
425	udraw->last_two_finger_x = -1;
426	udraw->last_two_finger_y = -1;
427
428	hid_set_drvdata(hdev, udraw);
429
430	ret = hid_parse(hdev);
431	if (ret) {
432	hid_err(hdev, "parse failed\n");
433	return ret;
434	}
435
436	if (!udraw_setup_joypad(udraw, hdev) \|\|
437	!udraw_setup_touch(udraw, hdev) \|\|
438	!udraw_setup_pen(udraw, hdev) \|\|
439	!udraw_setup_accel(udraw, hdev)) {
440	hid_err(hdev, "could not allocate interfaces\n");
441	return -ENOMEM;
442	}
443
444	ret = input_register_device(udraw->joy_input_dev) \|\|
445	input_register_device(udraw->touch_input_dev) \|\|
446	input_register_device(udraw->pen_input_dev) \|\|
447	input_register_device(udraw->accel_input_dev);
448	if (ret) {
449	hid_err(hdev, "failed to register interfaces\n");
450	return ret;
451	}
452
453	ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW \| HID_CONNECT_DRIVER);
454	if (ret) {
455	hid_err(hdev, "hw start failed\n");
456	return ret;
457	}
458
459	return 0;
460	}
461
462	static const struct hid_device_id udraw_devices[] = {
463	{ HID_USB_DEVICE(USB_VENDOR_ID_THQ, USB_DEVICE_ID_THQ_PS3_UDRAW) },
464	{ }
465	};
466	MODULE_DEVICE_TABLE(hid, udraw_devices);
467
468	static struct hid_driver udraw_driver = {
469	.name = "hid-udraw",
470	.id_table = udraw_devices,
471	.raw_event = udraw_raw_event,
472	.probe = udraw_probe,
473	};
474	module_hid_driver(udraw_driver);