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