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 <hadess@hadess.net>");
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  */
57 static struct {
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 
clamp_accel(int axis,int offset)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 
udraw_raw_event(struct hid_device * hdev,struct hid_report * report,u8 * data,int len)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 
udraw_open(struct input_dev * dev)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 
udraw_close(struct input_dev * dev)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 
allocate_and_setup(struct hid_device * hdev,const char * name)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 
udraw_setup_touch(struct udraw * udraw,struct hid_device * hdev)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 
udraw_setup_pen(struct udraw * udraw,struct hid_device * hdev)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 
udraw_setup_accel(struct udraw * udraw,struct hid_device * hdev)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 
udraw_setup_joypad(struct udraw * udraw,struct hid_device * hdev)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 
udraw_probe(struct hid_device * hdev,const struct hid_device_id * id)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);
475