1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * HID driver for UC-Logic devices not fully compliant with HID standard 4 * - tablet initialization and parameter retrieval 5 * 6 * Copyright (c) 2018 Nikolai Kondrashov 7 */ 8 9 /* 10 * This program is free software; you can redistribute it and/or modify it 11 * under the terms of the GNU General Public License as published by the Free 12 * Software Foundation; either version 2 of the License, or (at your option) 13 * any later version. 14 */ 15 16 #include "hid-uclogic-params.h" 17 #include "hid-uclogic-rdesc.h" 18 #include "usbhid/usbhid.h" 19 #include "hid-ids.h" 20 #include <linux/ctype.h> 21 #include <asm/unaligned.h> 22 23 /** 24 * uclogic_params_pen_inrange_to_str() - Convert a pen in-range reporting type 25 * to a string. 26 * 27 * @inrange: The in-range reporting type to convert. 28 * 29 * Returns: 30 * The string representing the type, or NULL if the type is unknown. 31 */ 32 static const char *uclogic_params_pen_inrange_to_str( 33 enum uclogic_params_pen_inrange inrange) 34 { 35 switch (inrange) { 36 case UCLOGIC_PARAMS_PEN_INRANGE_NORMAL: 37 return "normal"; 38 case UCLOGIC_PARAMS_PEN_INRANGE_INVERTED: 39 return "inverted"; 40 case UCLOGIC_PARAMS_PEN_INRANGE_NONE: 41 return "none"; 42 default: 43 return NULL; 44 } 45 } 46 47 /** 48 * Dump tablet interface pen parameters with hid_dbg(), indented with one tab. 49 * 50 * @hdev: The HID device the pen parameters describe. 51 * @pen: The pen parameters to dump. 52 */ 53 static void uclogic_params_pen_hid_dbg(const struct hid_device *hdev, 54 const struct uclogic_params_pen *pen) 55 { 56 size_t i; 57 58 hid_dbg(hdev, "\t.usage_invalid = %s\n", 59 (pen->usage_invalid ? "true" : "false")); 60 hid_dbg(hdev, "\t.desc_ptr = %p\n", pen->desc_ptr); 61 hid_dbg(hdev, "\t.desc_size = %u\n", pen->desc_size); 62 hid_dbg(hdev, "\t.id = %u\n", pen->id); 63 hid_dbg(hdev, "\t.subreport_list = {\n"); 64 for (i = 0; i < ARRAY_SIZE(pen->subreport_list); i++) { 65 hid_dbg(hdev, "\t\t{0x%02hhx, %hhu}%s\n", 66 pen->subreport_list[i].value, 67 pen->subreport_list[i].id, 68 i < (ARRAY_SIZE(pen->subreport_list) - 1) ? "," : ""); 69 } 70 hid_dbg(hdev, "\t}\n"); 71 hid_dbg(hdev, "\t.inrange = %s\n", 72 uclogic_params_pen_inrange_to_str(pen->inrange)); 73 hid_dbg(hdev, "\t.fragmented_hires = %s\n", 74 (pen->fragmented_hires ? "true" : "false")); 75 hid_dbg(hdev, "\t.tilt_y_flipped = %s\n", 76 (pen->tilt_y_flipped ? "true" : "false")); 77 } 78 79 /** 80 * Dump tablet interface frame parameters with hid_dbg(), indented with two 81 * tabs. 82 * 83 * @hdev: The HID device the pen parameters describe. 84 * @frame: The frame parameters to dump. 85 */ 86 static void uclogic_params_frame_hid_dbg( 87 const struct hid_device *hdev, 88 const struct uclogic_params_frame *frame) 89 { 90 hid_dbg(hdev, "\t\t.desc_ptr = %p\n", frame->desc_ptr); 91 hid_dbg(hdev, "\t\t.desc_size = %u\n", frame->desc_size); 92 hid_dbg(hdev, "\t\t.id = %u\n", frame->id); 93 hid_dbg(hdev, "\t\t.suffix = %s\n", frame->suffix); 94 hid_dbg(hdev, "\t\t.re_lsb = %u\n", frame->re_lsb); 95 hid_dbg(hdev, "\t\t.dev_id_byte = %u\n", frame->dev_id_byte); 96 hid_dbg(hdev, "\t\t.touch_byte = %u\n", frame->touch_byte); 97 hid_dbg(hdev, "\t\t.touch_max = %hhd\n", frame->touch_max); 98 hid_dbg(hdev, "\t\t.touch_flip_at = %hhd\n", 99 frame->touch_flip_at); 100 hid_dbg(hdev, "\t\t.bitmap_dial_byte = %u\n", 101 frame->bitmap_dial_byte); 102 } 103 104 /** 105 * Dump tablet interface parameters with hid_dbg(). 106 * 107 * @hdev: The HID device the parameters describe. 108 * @params: The parameters to dump. 109 */ 110 void uclogic_params_hid_dbg(const struct hid_device *hdev, 111 const struct uclogic_params *params) 112 { 113 size_t i; 114 115 hid_dbg(hdev, ".invalid = %s\n", 116 params->invalid ? "true" : "false"); 117 hid_dbg(hdev, ".desc_ptr = %p\n", params->desc_ptr); 118 hid_dbg(hdev, ".desc_size = %u\n", params->desc_size); 119 hid_dbg(hdev, ".pen = {\n"); 120 uclogic_params_pen_hid_dbg(hdev, ¶ms->pen); 121 hid_dbg(hdev, "\t}\n"); 122 hid_dbg(hdev, ".frame_list = {\n"); 123 for (i = 0; i < ARRAY_SIZE(params->frame_list); i++) { 124 hid_dbg(hdev, "\t{\n"); 125 uclogic_params_frame_hid_dbg(hdev, ¶ms->frame_list[i]); 126 hid_dbg(hdev, "\t}%s\n", 127 i < (ARRAY_SIZE(params->frame_list) - 1) ? "," : ""); 128 } 129 hid_dbg(hdev, "}\n"); 130 } 131 132 /** 133 * uclogic_params_get_str_desc - retrieve a string descriptor from a HID 134 * device interface, putting it into a kmalloc-allocated buffer as is, without 135 * character encoding conversion. 136 * 137 * @pbuf: Location for the kmalloc-allocated buffer pointer containing 138 * the retrieved descriptor. Not modified in case of error. 139 * Can be NULL to have retrieved descriptor discarded. 140 * @hdev: The HID device of the tablet interface to retrieve the string 141 * descriptor from. Cannot be NULL. 142 * @idx: Index of the string descriptor to request from the device. 143 * @len: Length of the buffer to allocate and the data to retrieve. 144 * 145 * Returns: 146 * number of bytes retrieved (<= len), 147 * -EPIPE, if the descriptor was not found, or 148 * another negative errno code in case of other error. 149 */ 150 static int uclogic_params_get_str_desc(__u8 **pbuf, struct hid_device *hdev, 151 __u8 idx, size_t len) 152 { 153 int rc; 154 struct usb_device *udev; 155 __u8 *buf = NULL; 156 157 /* Check arguments */ 158 if (hdev == NULL) { 159 rc = -EINVAL; 160 goto cleanup; 161 } 162 163 udev = hid_to_usb_dev(hdev); 164 165 buf = kmalloc(len, GFP_KERNEL); 166 if (buf == NULL) { 167 rc = -ENOMEM; 168 goto cleanup; 169 } 170 171 rc = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 172 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, 173 (USB_DT_STRING << 8) + idx, 174 0x0409, buf, len, 175 USB_CTRL_GET_TIMEOUT); 176 if (rc == -EPIPE) { 177 hid_dbg(hdev, "string descriptor #%hhu not found\n", idx); 178 goto cleanup; 179 } else if (rc < 0) { 180 hid_err(hdev, 181 "failed retrieving string descriptor #%u: %d\n", 182 idx, rc); 183 goto cleanup; 184 } 185 186 if (pbuf != NULL) { 187 *pbuf = buf; 188 buf = NULL; 189 } 190 191 cleanup: 192 kfree(buf); 193 return rc; 194 } 195 196 /** 197 * uclogic_params_pen_cleanup - free resources used by struct 198 * uclogic_params_pen (tablet interface's pen input parameters). 199 * Can be called repeatedly. 200 * 201 * @pen: Pen input parameters to cleanup. Cannot be NULL. 202 */ 203 static void uclogic_params_pen_cleanup(struct uclogic_params_pen *pen) 204 { 205 kfree(pen->desc_ptr); 206 memset(pen, 0, sizeof(*pen)); 207 } 208 209 /** 210 * uclogic_params_pen_init_v1() - initialize tablet interface pen 211 * input and retrieve its parameters from the device, using v1 protocol. 212 * 213 * @pen: Pointer to the pen parameters to initialize (to be 214 * cleaned up with uclogic_params_pen_cleanup()). Not modified in 215 * case of error, or if parameters are not found. Cannot be NULL. 216 * @pfound: Location for a flag which is set to true if the parameters 217 * were found, and to false if not (e.g. device was 218 * incompatible). Not modified in case of error. Cannot be NULL. 219 * @hdev: The HID device of the tablet interface to initialize and get 220 * parameters from. Cannot be NULL. 221 * 222 * Returns: 223 * Zero, if successful. A negative errno code on error. 224 */ 225 static int uclogic_params_pen_init_v1(struct uclogic_params_pen *pen, 226 bool *pfound, 227 struct hid_device *hdev) 228 { 229 int rc; 230 bool found = false; 231 /* Buffer for (part of) the string descriptor */ 232 __u8 *buf = NULL; 233 /* Minimum descriptor length required, maximum seen so far is 18 */ 234 const int len = 12; 235 s32 resolution; 236 /* Pen report descriptor template parameters */ 237 s32 desc_params[UCLOGIC_RDESC_PEN_PH_ID_NUM]; 238 __u8 *desc_ptr = NULL; 239 240 /* Check arguments */ 241 if (pen == NULL || pfound == NULL || hdev == NULL) { 242 rc = -EINVAL; 243 goto cleanup; 244 } 245 246 /* 247 * Read string descriptor containing pen input parameters. 248 * The specific string descriptor and data were discovered by sniffing 249 * the Windows driver traffic. 250 * NOTE: This enables fully-functional tablet mode. 251 */ 252 rc = uclogic_params_get_str_desc(&buf, hdev, 100, len); 253 if (rc == -EPIPE) { 254 hid_dbg(hdev, 255 "string descriptor with pen parameters not found, assuming not compatible\n"); 256 goto finish; 257 } else if (rc < 0) { 258 hid_err(hdev, "failed retrieving pen parameters: %d\n", rc); 259 goto cleanup; 260 } else if (rc != len) { 261 hid_dbg(hdev, 262 "string descriptor with pen parameters has invalid length (got %d, expected %d), assuming not compatible\n", 263 rc, len); 264 goto finish; 265 } 266 267 /* 268 * Fill report descriptor parameters from the string descriptor 269 */ 270 desc_params[UCLOGIC_RDESC_PEN_PH_ID_X_LM] = 271 get_unaligned_le16(buf + 2); 272 desc_params[UCLOGIC_RDESC_PEN_PH_ID_Y_LM] = 273 get_unaligned_le16(buf + 4); 274 desc_params[UCLOGIC_RDESC_PEN_PH_ID_PRESSURE_LM] = 275 get_unaligned_le16(buf + 8); 276 resolution = get_unaligned_le16(buf + 10); 277 if (resolution == 0) { 278 desc_params[UCLOGIC_RDESC_PEN_PH_ID_X_PM] = 0; 279 desc_params[UCLOGIC_RDESC_PEN_PH_ID_Y_PM] = 0; 280 } else { 281 desc_params[UCLOGIC_RDESC_PEN_PH_ID_X_PM] = 282 desc_params[UCLOGIC_RDESC_PEN_PH_ID_X_LM] * 1000 / 283 resolution; 284 desc_params[UCLOGIC_RDESC_PEN_PH_ID_Y_PM] = 285 desc_params[UCLOGIC_RDESC_PEN_PH_ID_Y_LM] * 1000 / 286 resolution; 287 } 288 kfree(buf); 289 buf = NULL; 290 291 /* 292 * Generate pen report descriptor 293 */ 294 desc_ptr = uclogic_rdesc_template_apply( 295 uclogic_rdesc_v1_pen_template_arr, 296 uclogic_rdesc_v1_pen_template_size, 297 desc_params, ARRAY_SIZE(desc_params)); 298 if (desc_ptr == NULL) { 299 rc = -ENOMEM; 300 goto cleanup; 301 } 302 303 /* 304 * Fill-in the parameters 305 */ 306 memset(pen, 0, sizeof(*pen)); 307 pen->desc_ptr = desc_ptr; 308 desc_ptr = NULL; 309 pen->desc_size = uclogic_rdesc_v1_pen_template_size; 310 pen->id = UCLOGIC_RDESC_V1_PEN_ID; 311 pen->inrange = UCLOGIC_PARAMS_PEN_INRANGE_INVERTED; 312 found = true; 313 finish: 314 *pfound = found; 315 rc = 0; 316 cleanup: 317 kfree(desc_ptr); 318 kfree(buf); 319 return rc; 320 } 321 322 /** 323 * uclogic_params_get_le24() - get a 24-bit little-endian number from a 324 * buffer. 325 * 326 * @p: The pointer to the number buffer. 327 * 328 * Returns: 329 * The retrieved number 330 */ 331 static s32 uclogic_params_get_le24(const void *p) 332 { 333 const __u8 *b = p; 334 return b[0] | (b[1] << 8UL) | (b[2] << 16UL); 335 } 336 337 /** 338 * uclogic_params_pen_init_v2() - initialize tablet interface pen 339 * input and retrieve its parameters from the device, using v2 protocol. 340 * 341 * @pen: Pointer to the pen parameters to initialize (to be 342 * cleaned up with uclogic_params_pen_cleanup()). Not 343 * modified in case of error, or if parameters are not 344 * found. Cannot be NULL. 345 * @pfound: Location for a flag which is set to true if the 346 * parameters were found, and to false if not (e.g. 347 * device was incompatible). Not modified in case of 348 * error. Cannot be NULL. 349 * @pparams_ptr: Location for a kmalloc'ed pointer to the retrieved raw 350 * parameters, which could be used to identify the tablet 351 * to some extent. Should be freed with kfree after use. 352 * NULL, if not needed. Not modified in case of error. 353 * Only set if *pfound is set to true. 354 * @pparams_len: Location for the length of the retrieved raw 355 * parameters. NULL, if not needed. Not modified in case 356 * of error. Only set if *pfound is set to true. 357 * @hdev: The HID device of the tablet interface to initialize 358 * and get parameters from. Cannot be NULL. 359 * 360 * Returns: 361 * Zero, if successful. A negative errno code on error. 362 */ 363 static int uclogic_params_pen_init_v2(struct uclogic_params_pen *pen, 364 bool *pfound, 365 __u8 **pparams_ptr, 366 size_t *pparams_len, 367 struct hid_device *hdev) 368 { 369 int rc; 370 bool found = false; 371 /* Buffer for (part of) the parameter string descriptor */ 372 __u8 *buf = NULL; 373 /* Parameter string descriptor required length */ 374 const int params_len_min = 18; 375 /* Parameter string descriptor accepted length */ 376 const int params_len_max = 32; 377 /* Parameter string descriptor received length */ 378 int params_len; 379 size_t i; 380 s32 resolution; 381 /* Pen report descriptor template parameters */ 382 s32 desc_params[UCLOGIC_RDESC_PEN_PH_ID_NUM]; 383 __u8 *desc_ptr = NULL; 384 385 /* Check arguments */ 386 if (pen == NULL || pfound == NULL || hdev == NULL) { 387 rc = -EINVAL; 388 goto cleanup; 389 } 390 391 /* 392 * Read string descriptor containing pen input parameters. 393 * The specific string descriptor and data were discovered by sniffing 394 * the Windows driver traffic. 395 * NOTE: This enables fully-functional tablet mode. 396 */ 397 rc = uclogic_params_get_str_desc(&buf, hdev, 200, params_len_max); 398 if (rc == -EPIPE) { 399 hid_dbg(hdev, 400 "string descriptor with pen parameters not found, assuming not compatible\n"); 401 goto finish; 402 } else if (rc < 0) { 403 hid_err(hdev, "failed retrieving pen parameters: %d\n", rc); 404 goto cleanup; 405 } else if (rc < params_len_min) { 406 hid_dbg(hdev, 407 "string descriptor with pen parameters is too short (got %d, expected at least %d), assuming not compatible\n", 408 rc, params_len_min); 409 goto finish; 410 } 411 412 params_len = rc; 413 414 /* 415 * Check it's not just a catch-all UTF-16LE-encoded ASCII 416 * string (such as the model name) some tablets put into all 417 * unknown string descriptors. 418 */ 419 for (i = 2; 420 i < params_len && 421 (buf[i] >= 0x20 && buf[i] < 0x7f && buf[i + 1] == 0); 422 i += 2); 423 if (i >= params_len) { 424 hid_dbg(hdev, 425 "string descriptor with pen parameters seems to contain only text, assuming not compatible\n"); 426 goto finish; 427 } 428 429 /* 430 * Fill report descriptor parameters from the string descriptor 431 */ 432 desc_params[UCLOGIC_RDESC_PEN_PH_ID_X_LM] = 433 uclogic_params_get_le24(buf + 2); 434 desc_params[UCLOGIC_RDESC_PEN_PH_ID_Y_LM] = 435 uclogic_params_get_le24(buf + 5); 436 desc_params[UCLOGIC_RDESC_PEN_PH_ID_PRESSURE_LM] = 437 get_unaligned_le16(buf + 8); 438 resolution = get_unaligned_le16(buf + 10); 439 if (resolution == 0) { 440 desc_params[UCLOGIC_RDESC_PEN_PH_ID_X_PM] = 0; 441 desc_params[UCLOGIC_RDESC_PEN_PH_ID_Y_PM] = 0; 442 } else { 443 desc_params[UCLOGIC_RDESC_PEN_PH_ID_X_PM] = 444 desc_params[UCLOGIC_RDESC_PEN_PH_ID_X_LM] * 1000 / 445 resolution; 446 desc_params[UCLOGIC_RDESC_PEN_PH_ID_Y_PM] = 447 desc_params[UCLOGIC_RDESC_PEN_PH_ID_Y_LM] * 1000 / 448 resolution; 449 } 450 451 /* 452 * Generate pen report descriptor 453 */ 454 desc_ptr = uclogic_rdesc_template_apply( 455 uclogic_rdesc_v2_pen_template_arr, 456 uclogic_rdesc_v2_pen_template_size, 457 desc_params, ARRAY_SIZE(desc_params)); 458 if (desc_ptr == NULL) { 459 rc = -ENOMEM; 460 goto cleanup; 461 } 462 463 /* 464 * Fill-in the parameters 465 */ 466 memset(pen, 0, sizeof(*pen)); 467 pen->desc_ptr = desc_ptr; 468 desc_ptr = NULL; 469 pen->desc_size = uclogic_rdesc_v2_pen_template_size; 470 pen->id = UCLOGIC_RDESC_V2_PEN_ID; 471 pen->inrange = UCLOGIC_PARAMS_PEN_INRANGE_NONE; 472 pen->fragmented_hires = true; 473 pen->tilt_y_flipped = true; 474 found = true; 475 if (pparams_ptr != NULL) { 476 *pparams_ptr = buf; 477 buf = NULL; 478 } 479 if (pparams_len != NULL) 480 *pparams_len = params_len; 481 482 finish: 483 *pfound = found; 484 rc = 0; 485 cleanup: 486 kfree(desc_ptr); 487 kfree(buf); 488 return rc; 489 } 490 491 /** 492 * uclogic_params_frame_cleanup - free resources used by struct 493 * uclogic_params_frame (tablet interface's frame controls input parameters). 494 * Can be called repeatedly. 495 * 496 * @frame: Frame controls input parameters to cleanup. Cannot be NULL. 497 */ 498 static void uclogic_params_frame_cleanup(struct uclogic_params_frame *frame) 499 { 500 kfree(frame->desc_ptr); 501 memset(frame, 0, sizeof(*frame)); 502 } 503 504 /** 505 * uclogic_params_frame_init_with_desc() - initialize tablet's frame control 506 * parameters with a static report descriptor. 507 * 508 * @frame: Pointer to the frame parameters to initialize (to be cleaned 509 * up with uclogic_params_frame_cleanup()). Not modified in case 510 * of error. Cannot be NULL. 511 * @desc_ptr: Report descriptor pointer. Can be NULL, if desc_size is zero. 512 * @desc_size: Report descriptor size. 513 * @id: Report ID used for frame reports, if they should be tweaked, 514 * zero if not. 515 * 516 * Returns: 517 * Zero, if successful. A negative errno code on error. 518 */ 519 static int uclogic_params_frame_init_with_desc( 520 struct uclogic_params_frame *frame, 521 const __u8 *desc_ptr, 522 size_t desc_size, 523 unsigned int id) 524 { 525 __u8 *copy_desc_ptr; 526 527 if (frame == NULL || (desc_ptr == NULL && desc_size != 0)) 528 return -EINVAL; 529 530 copy_desc_ptr = kmemdup(desc_ptr, desc_size, GFP_KERNEL); 531 if (copy_desc_ptr == NULL) 532 return -ENOMEM; 533 534 memset(frame, 0, sizeof(*frame)); 535 frame->desc_ptr = copy_desc_ptr; 536 frame->desc_size = desc_size; 537 frame->id = id; 538 return 0; 539 } 540 541 /** 542 * uclogic_params_frame_init_v1() - initialize v1 tablet interface frame 543 * controls. 544 * 545 * @frame: Pointer to the frame parameters to initialize (to be cleaned 546 * up with uclogic_params_frame_cleanup()). Not modified in case 547 * of error, or if parameters are not found. Cannot be NULL. 548 * @pfound: Location for a flag which is set to true if the parameters 549 * were found, and to false if not (e.g. device was 550 * incompatible). Not modified in case of error. Cannot be NULL. 551 * @hdev: The HID device of the tablet interface to initialize and get 552 * parameters from. Cannot be NULL. 553 * 554 * Returns: 555 * Zero, if successful. A negative errno code on error. 556 */ 557 static int uclogic_params_frame_init_v1(struct uclogic_params_frame *frame, 558 bool *pfound, 559 struct hid_device *hdev) 560 { 561 int rc; 562 bool found = false; 563 struct usb_device *usb_dev; 564 char *str_buf = NULL; 565 const size_t str_len = 16; 566 567 /* Check arguments */ 568 if (frame == NULL || pfound == NULL || hdev == NULL) { 569 rc = -EINVAL; 570 goto cleanup; 571 } 572 573 usb_dev = hid_to_usb_dev(hdev); 574 575 /* 576 * Enable generic button mode 577 */ 578 str_buf = kzalloc(str_len, GFP_KERNEL); 579 if (str_buf == NULL) { 580 rc = -ENOMEM; 581 goto cleanup; 582 } 583 584 rc = usb_string(usb_dev, 123, str_buf, str_len); 585 if (rc == -EPIPE) { 586 hid_dbg(hdev, 587 "generic button -enabling string descriptor not found\n"); 588 } else if (rc < 0) { 589 goto cleanup; 590 } else if (strncmp(str_buf, "HK On", rc) != 0) { 591 hid_dbg(hdev, 592 "invalid response to enabling generic buttons: \"%s\"\n", 593 str_buf); 594 } else { 595 hid_dbg(hdev, "generic buttons enabled\n"); 596 rc = uclogic_params_frame_init_with_desc( 597 frame, 598 uclogic_rdesc_v1_frame_arr, 599 uclogic_rdesc_v1_frame_size, 600 UCLOGIC_RDESC_V1_FRAME_ID); 601 if (rc != 0) 602 goto cleanup; 603 found = true; 604 } 605 606 *pfound = found; 607 rc = 0; 608 cleanup: 609 kfree(str_buf); 610 return rc; 611 } 612 613 /** 614 * uclogic_params_cleanup - free resources used by struct uclogic_params 615 * (tablet interface's parameters). 616 * Can be called repeatedly. 617 * 618 * @params: Input parameters to cleanup. Cannot be NULL. 619 */ 620 void uclogic_params_cleanup(struct uclogic_params *params) 621 { 622 if (!params->invalid) { 623 size_t i; 624 kfree(params->desc_ptr); 625 uclogic_params_pen_cleanup(¶ms->pen); 626 for (i = 0; i < ARRAY_SIZE(params->frame_list); i++) 627 uclogic_params_frame_cleanup(¶ms->frame_list[i]); 628 629 memset(params, 0, sizeof(*params)); 630 } 631 } 632 633 /** 634 * uclogic_params_get_desc() - Get a replacement report descriptor for a 635 * tablet's interface. 636 * 637 * @params: The parameters of a tablet interface to get report 638 * descriptor for. Cannot be NULL. 639 * @pdesc: Location for the resulting, kmalloc-allocated report 640 * descriptor pointer, or for NULL, if there's no replacement 641 * report descriptor. Not modified in case of error. Cannot be 642 * NULL. 643 * @psize: Location for the resulting report descriptor size, not set if 644 * there's no replacement report descriptor. Not modified in case 645 * of error. Cannot be NULL. 646 * 647 * Returns: 648 * Zero, if successful. 649 * -EINVAL, if invalid arguments are supplied. 650 * -ENOMEM, if failed to allocate memory. 651 */ 652 int uclogic_params_get_desc(const struct uclogic_params *params, 653 __u8 **pdesc, 654 unsigned int *psize) 655 { 656 int rc = -ENOMEM; 657 bool present = false; 658 unsigned int size = 0; 659 __u8 *desc = NULL; 660 size_t i; 661 662 /* Check arguments */ 663 if (params == NULL || pdesc == NULL || psize == NULL) 664 return -EINVAL; 665 666 /* Concatenate descriptors */ 667 #define ADD_DESC(_desc_ptr, _desc_size) \ 668 do { \ 669 unsigned int new_size; \ 670 __u8 *new_desc; \ 671 if ((_desc_ptr) == NULL) { \ 672 break; \ 673 } \ 674 new_size = size + (_desc_size); \ 675 new_desc = krealloc(desc, new_size, GFP_KERNEL); \ 676 if (new_desc == NULL) { \ 677 goto cleanup; \ 678 } \ 679 memcpy(new_desc + size, (_desc_ptr), (_desc_size)); \ 680 desc = new_desc; \ 681 size = new_size; \ 682 present = true; \ 683 } while (0) 684 685 ADD_DESC(params->desc_ptr, params->desc_size); 686 ADD_DESC(params->pen.desc_ptr, params->pen.desc_size); 687 for (i = 0; i < ARRAY_SIZE(params->frame_list); i++) { 688 ADD_DESC(params->frame_list[i].desc_ptr, 689 params->frame_list[i].desc_size); 690 } 691 692 #undef ADD_DESC 693 694 if (present) { 695 *pdesc = desc; 696 *psize = size; 697 desc = NULL; 698 } 699 rc = 0; 700 cleanup: 701 kfree(desc); 702 return rc; 703 } 704 705 /** 706 * uclogic_params_init_invalid() - initialize tablet interface parameters, 707 * specifying the interface is invalid. 708 * 709 * @params: Parameters to initialize (to be cleaned with 710 * uclogic_params_cleanup()). Cannot be NULL. 711 */ 712 static void uclogic_params_init_invalid(struct uclogic_params *params) 713 { 714 params->invalid = true; 715 } 716 717 /** 718 * uclogic_params_init_with_opt_desc() - initialize tablet interface 719 * parameters with an optional replacement report descriptor. Only modify 720 * report descriptor, if the original report descriptor matches the expected 721 * size. 722 * 723 * @params: Parameters to initialize (to be cleaned with 724 * uclogic_params_cleanup()). Not modified in case of 725 * error. Cannot be NULL. 726 * @hdev: The HID device of the tablet interface create the 727 * parameters for. Cannot be NULL. 728 * @orig_desc_size: Expected size of the original report descriptor to 729 * be replaced. 730 * @desc_ptr: Pointer to the replacement report descriptor. 731 * Can be NULL, if desc_size is zero. 732 * @desc_size: Size of the replacement report descriptor. 733 * 734 * Returns: 735 * Zero, if successful. -EINVAL if an invalid argument was passed. 736 * -ENOMEM, if failed to allocate memory. 737 */ 738 static int uclogic_params_init_with_opt_desc(struct uclogic_params *params, 739 struct hid_device *hdev, 740 unsigned int orig_desc_size, 741 __u8 *desc_ptr, 742 unsigned int desc_size) 743 { 744 __u8 *desc_copy_ptr = NULL; 745 unsigned int desc_copy_size; 746 int rc; 747 748 /* Check arguments */ 749 if (params == NULL || hdev == NULL || 750 (desc_ptr == NULL && desc_size != 0)) { 751 rc = -EINVAL; 752 goto cleanup; 753 } 754 755 /* Replace report descriptor, if it matches */ 756 if (hdev->dev_rsize == orig_desc_size) { 757 hid_dbg(hdev, 758 "device report descriptor matches the expected size, replacing\n"); 759 desc_copy_ptr = kmemdup(desc_ptr, desc_size, GFP_KERNEL); 760 if (desc_copy_ptr == NULL) { 761 rc = -ENOMEM; 762 goto cleanup; 763 } 764 desc_copy_size = desc_size; 765 } else { 766 hid_dbg(hdev, 767 "device report descriptor doesn't match the expected size (%u != %u), preserving\n", 768 hdev->dev_rsize, orig_desc_size); 769 desc_copy_ptr = NULL; 770 desc_copy_size = 0; 771 } 772 773 /* Output parameters */ 774 memset(params, 0, sizeof(*params)); 775 params->desc_ptr = desc_copy_ptr; 776 desc_copy_ptr = NULL; 777 params->desc_size = desc_copy_size; 778 779 rc = 0; 780 cleanup: 781 kfree(desc_copy_ptr); 782 return rc; 783 } 784 785 /** 786 * uclogic_params_huion_init() - initialize a Huion tablet interface and discover 787 * its parameters. 788 * 789 * @params: Parameters to fill in (to be cleaned with 790 * uclogic_params_cleanup()). Not modified in case of error. 791 * Cannot be NULL. 792 * @hdev: The HID device of the tablet interface to initialize and get 793 * parameters from. Cannot be NULL. 794 * 795 * Returns: 796 * Zero, if successful. A negative errno code on error. 797 */ 798 static int uclogic_params_huion_init(struct uclogic_params *params, 799 struct hid_device *hdev) 800 { 801 int rc; 802 struct usb_device *udev; 803 struct usb_interface *iface; 804 __u8 bInterfaceNumber; 805 bool found; 806 /* The resulting parameters (noop) */ 807 struct uclogic_params p = {0, }; 808 static const char transition_ver[] = "HUION_T153_160607"; 809 char *ver_ptr = NULL; 810 const size_t ver_len = sizeof(transition_ver) + 1; 811 __u8 *params_ptr = NULL; 812 size_t params_len = 0; 813 /* Parameters string descriptor of a model with touch ring (HS610) */ 814 const __u8 touch_ring_model_params_buf[] = { 815 0x13, 0x03, 0x70, 0xC6, 0x00, 0x06, 0x7C, 0x00, 816 0xFF, 0x1F, 0xD8, 0x13, 0x03, 0x0D, 0x10, 0x01, 817 0x04, 0x3C, 0x3E 818 }; 819 820 /* Check arguments */ 821 if (params == NULL || hdev == NULL) { 822 rc = -EINVAL; 823 goto cleanup; 824 } 825 826 udev = hid_to_usb_dev(hdev); 827 iface = to_usb_interface(hdev->dev.parent); 828 bInterfaceNumber = iface->cur_altsetting->desc.bInterfaceNumber; 829 830 /* If it's a custom keyboard interface */ 831 if (bInterfaceNumber == 1) { 832 /* Keep everything intact, but mark pen usage invalid */ 833 p.pen.usage_invalid = true; 834 goto output; 835 /* Else, if it's not a pen interface */ 836 } else if (bInterfaceNumber != 0) { 837 uclogic_params_init_invalid(&p); 838 goto output; 839 } 840 841 /* Try to get firmware version */ 842 ver_ptr = kzalloc(ver_len, GFP_KERNEL); 843 if (ver_ptr == NULL) { 844 rc = -ENOMEM; 845 goto cleanup; 846 } 847 rc = usb_string(udev, 201, ver_ptr, ver_len); 848 if (rc == -EPIPE) { 849 *ver_ptr = '\0'; 850 } else if (rc < 0) { 851 hid_err(hdev, 852 "failed retrieving Huion firmware version: %d\n", rc); 853 goto cleanup; 854 } 855 856 /* If this is a transition firmware */ 857 if (strcmp(ver_ptr, transition_ver) == 0) { 858 hid_dbg(hdev, 859 "transition firmware detected, not probing pen v2 parameters\n"); 860 } else { 861 /* Try to probe v2 pen parameters */ 862 rc = uclogic_params_pen_init_v2(&p.pen, &found, 863 ¶ms_ptr, ¶ms_len, 864 hdev); 865 if (rc != 0) { 866 hid_err(hdev, 867 "failed probing pen v2 parameters: %d\n", rc); 868 goto cleanup; 869 } else if (found) { 870 hid_dbg(hdev, "pen v2 parameters found\n"); 871 /* Create v2 frame button parameters */ 872 rc = uclogic_params_frame_init_with_desc( 873 &p.frame_list[0], 874 uclogic_rdesc_v2_frame_buttons_arr, 875 uclogic_rdesc_v2_frame_buttons_size, 876 UCLOGIC_RDESC_V2_FRAME_BUTTONS_ID); 877 if (rc != 0) { 878 hid_err(hdev, 879 "failed creating v2 frame button parameters: %d\n", 880 rc); 881 goto cleanup; 882 } 883 884 /* Link from pen sub-report */ 885 p.pen.subreport_list[0].value = 0xe0; 886 p.pen.subreport_list[0].id = 887 UCLOGIC_RDESC_V2_FRAME_BUTTONS_ID; 888 889 /* If this is the model with touch ring */ 890 if (params_ptr != NULL && 891 params_len == sizeof(touch_ring_model_params_buf) && 892 memcmp(params_ptr, touch_ring_model_params_buf, 893 params_len) == 0) { 894 /* Create touch ring parameters */ 895 rc = uclogic_params_frame_init_with_desc( 896 &p.frame_list[1], 897 uclogic_rdesc_v2_frame_touch_ring_arr, 898 uclogic_rdesc_v2_frame_touch_ring_size, 899 UCLOGIC_RDESC_V2_FRAME_TOUCH_ID); 900 if (rc != 0) { 901 hid_err(hdev, 902 "failed creating v2 frame touch ring parameters: %d\n", 903 rc); 904 goto cleanup; 905 } 906 p.frame_list[1].suffix = "Touch Ring"; 907 p.frame_list[1].dev_id_byte = 908 UCLOGIC_RDESC_V2_FRAME_TOUCH_DEV_ID_BYTE; 909 p.frame_list[1].touch_byte = 5; 910 p.frame_list[1].touch_max = 12; 911 p.frame_list[1].touch_flip_at = 7; 912 } else { 913 /* Create touch strip parameters */ 914 rc = uclogic_params_frame_init_with_desc( 915 &p.frame_list[1], 916 uclogic_rdesc_v2_frame_touch_strip_arr, 917 uclogic_rdesc_v2_frame_touch_strip_size, 918 UCLOGIC_RDESC_V2_FRAME_TOUCH_ID); 919 if (rc != 0) { 920 hid_err(hdev, 921 "failed creating v2 frame touch strip parameters: %d\n", 922 rc); 923 goto cleanup; 924 } 925 p.frame_list[1].suffix = "Touch Strip"; 926 p.frame_list[1].dev_id_byte = 927 UCLOGIC_RDESC_V2_FRAME_TOUCH_DEV_ID_BYTE; 928 p.frame_list[1].touch_byte = 5; 929 p.frame_list[1].touch_max = 8; 930 } 931 932 /* Link from pen sub-report */ 933 p.pen.subreport_list[1].value = 0xf0; 934 p.pen.subreport_list[1].id = 935 UCLOGIC_RDESC_V2_FRAME_TOUCH_ID; 936 937 /* Create v2 frame dial parameters */ 938 rc = uclogic_params_frame_init_with_desc( 939 &p.frame_list[2], 940 uclogic_rdesc_v2_frame_dial_arr, 941 uclogic_rdesc_v2_frame_dial_size, 942 UCLOGIC_RDESC_V2_FRAME_DIAL_ID); 943 if (rc != 0) { 944 hid_err(hdev, 945 "failed creating v2 frame dial parameters: %d\n", 946 rc); 947 goto cleanup; 948 } 949 p.frame_list[2].suffix = "Dial"; 950 p.frame_list[2].dev_id_byte = 951 UCLOGIC_RDESC_V2_FRAME_DIAL_DEV_ID_BYTE; 952 p.frame_list[2].bitmap_dial_byte = 5; 953 954 /* Link from pen sub-report */ 955 p.pen.subreport_list[2].value = 0xf1; 956 p.pen.subreport_list[2].id = 957 UCLOGIC_RDESC_V2_FRAME_DIAL_ID; 958 959 goto output; 960 } 961 hid_dbg(hdev, "pen v2 parameters not found\n"); 962 } 963 964 /* Try to probe v1 pen parameters */ 965 rc = uclogic_params_pen_init_v1(&p.pen, &found, hdev); 966 if (rc != 0) { 967 hid_err(hdev, 968 "failed probing pen v1 parameters: %d\n", rc); 969 goto cleanup; 970 } else if (found) { 971 hid_dbg(hdev, "pen v1 parameters found\n"); 972 /* Try to probe v1 frame */ 973 rc = uclogic_params_frame_init_v1(&p.frame_list[0], 974 &found, hdev); 975 if (rc != 0) { 976 hid_err(hdev, "v1 frame probing failed: %d\n", rc); 977 goto cleanup; 978 } 979 hid_dbg(hdev, "frame v1 parameters%s found\n", 980 (found ? "" : " not")); 981 if (found) { 982 /* Link frame button subreports from pen reports */ 983 p.pen.subreport_list[0].value = 0xe0; 984 p.pen.subreport_list[0].id = 985 UCLOGIC_RDESC_V1_FRAME_ID; 986 } 987 goto output; 988 } 989 hid_dbg(hdev, "pen v1 parameters not found\n"); 990 991 uclogic_params_init_invalid(&p); 992 993 output: 994 /* Output parameters */ 995 memcpy(params, &p, sizeof(*params)); 996 memset(&p, 0, sizeof(p)); 997 rc = 0; 998 cleanup: 999 kfree(params_ptr); 1000 kfree(ver_ptr); 1001 uclogic_params_cleanup(&p); 1002 return rc; 1003 } 1004 1005 /** 1006 * uclogic_params_init() - initialize a tablet interface and discover its 1007 * parameters. 1008 * 1009 * @params: Parameters to fill in (to be cleaned with 1010 * uclogic_params_cleanup()). Not modified in case of error. 1011 * Cannot be NULL. 1012 * @hdev: The HID device of the tablet interface to initialize and get 1013 * parameters from. Cannot be NULL. Must be using the USB low-level 1014 * driver, i.e. be an actual USB tablet. 1015 * 1016 * Returns: 1017 * Zero, if successful. A negative errno code on error. 1018 */ 1019 int uclogic_params_init(struct uclogic_params *params, 1020 struct hid_device *hdev) 1021 { 1022 int rc; 1023 struct usb_device *udev; 1024 __u8 bNumInterfaces; 1025 struct usb_interface *iface; 1026 __u8 bInterfaceNumber; 1027 bool found; 1028 /* The resulting parameters (noop) */ 1029 struct uclogic_params p = {0, }; 1030 1031 /* Check arguments */ 1032 if (params == NULL || hdev == NULL || !hid_is_usb(hdev)) { 1033 rc = -EINVAL; 1034 goto cleanup; 1035 } 1036 1037 udev = hid_to_usb_dev(hdev); 1038 bNumInterfaces = udev->config->desc.bNumInterfaces; 1039 iface = to_usb_interface(hdev->dev.parent); 1040 bInterfaceNumber = iface->cur_altsetting->desc.bInterfaceNumber; 1041 1042 /* 1043 * Set replacement report descriptor if the original matches the 1044 * specified size. Otherwise keep interface unchanged. 1045 */ 1046 #define WITH_OPT_DESC(_orig_desc_token, _new_desc_token) \ 1047 uclogic_params_init_with_opt_desc( \ 1048 &p, hdev, \ 1049 UCLOGIC_RDESC_##_orig_desc_token##_SIZE, \ 1050 uclogic_rdesc_##_new_desc_token##_arr, \ 1051 uclogic_rdesc_##_new_desc_token##_size) 1052 1053 #define VID_PID(_vid, _pid) \ 1054 (((__u32)(_vid) << 16) | ((__u32)(_pid) & U16_MAX)) 1055 1056 /* 1057 * Handle specific interfaces for specific tablets. 1058 * 1059 * Observe the following logic: 1060 * 1061 * If the interface is recognized as producing certain useful input: 1062 * Mark interface as valid. 1063 * Output interface parameters. 1064 * Else, if the interface is recognized as *not* producing any useful 1065 * input: 1066 * Mark interface as invalid. 1067 * Else: 1068 * Mark interface as valid. 1069 * Output noop parameters. 1070 * 1071 * Rule of thumb: it is better to disable a broken interface than let 1072 * it spew garbage input. 1073 */ 1074 1075 switch (VID_PID(hdev->vendor, hdev->product)) { 1076 case VID_PID(USB_VENDOR_ID_UCLOGIC, 1077 USB_DEVICE_ID_UCLOGIC_TABLET_PF1209): 1078 rc = WITH_OPT_DESC(PF1209_ORIG, pf1209_fixed); 1079 if (rc != 0) 1080 goto cleanup; 1081 break; 1082 case VID_PID(USB_VENDOR_ID_UCLOGIC, 1083 USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U): 1084 rc = WITH_OPT_DESC(WPXXXXU_ORIG, wp4030u_fixed); 1085 if (rc != 0) 1086 goto cleanup; 1087 break; 1088 case VID_PID(USB_VENDOR_ID_UCLOGIC, 1089 USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U): 1090 if (hdev->dev_rsize == UCLOGIC_RDESC_WP5540U_V2_ORIG_SIZE) { 1091 if (bInterfaceNumber == 0) { 1092 /* Try to probe v1 pen parameters */ 1093 rc = uclogic_params_pen_init_v1(&p.pen, 1094 &found, hdev); 1095 if (rc != 0) { 1096 hid_err(hdev, 1097 "pen probing failed: %d\n", 1098 rc); 1099 goto cleanup; 1100 } 1101 if (!found) { 1102 hid_warn(hdev, 1103 "pen parameters not found"); 1104 } 1105 } else { 1106 uclogic_params_init_invalid(&p); 1107 } 1108 } else { 1109 rc = WITH_OPT_DESC(WPXXXXU_ORIG, wp5540u_fixed); 1110 if (rc != 0) 1111 goto cleanup; 1112 } 1113 break; 1114 case VID_PID(USB_VENDOR_ID_UCLOGIC, 1115 USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U): 1116 rc = WITH_OPT_DESC(WPXXXXU_ORIG, wp8060u_fixed); 1117 if (rc != 0) 1118 goto cleanup; 1119 break; 1120 case VID_PID(USB_VENDOR_ID_UCLOGIC, 1121 USB_DEVICE_ID_UCLOGIC_TABLET_WP1062): 1122 rc = WITH_OPT_DESC(WP1062_ORIG, wp1062_fixed); 1123 if (rc != 0) 1124 goto cleanup; 1125 break; 1126 case VID_PID(USB_VENDOR_ID_UCLOGIC, 1127 USB_DEVICE_ID_UCLOGIC_WIRELESS_TABLET_TWHL850): 1128 switch (bInterfaceNumber) { 1129 case 0: 1130 rc = WITH_OPT_DESC(TWHL850_ORIG0, twhl850_fixed0); 1131 if (rc != 0) 1132 goto cleanup; 1133 break; 1134 case 1: 1135 rc = WITH_OPT_DESC(TWHL850_ORIG1, twhl850_fixed1); 1136 if (rc != 0) 1137 goto cleanup; 1138 break; 1139 case 2: 1140 rc = WITH_OPT_DESC(TWHL850_ORIG2, twhl850_fixed2); 1141 if (rc != 0) 1142 goto cleanup; 1143 break; 1144 } 1145 break; 1146 case VID_PID(USB_VENDOR_ID_UCLOGIC, 1147 USB_DEVICE_ID_UCLOGIC_TABLET_TWHA60): 1148 /* 1149 * If it is not a three-interface version, which is known to 1150 * respond to initialization. 1151 */ 1152 if (bNumInterfaces != 3) { 1153 switch (bInterfaceNumber) { 1154 case 0: 1155 rc = WITH_OPT_DESC(TWHA60_ORIG0, 1156 twha60_fixed0); 1157 if (rc != 0) 1158 goto cleanup; 1159 break; 1160 case 1: 1161 rc = WITH_OPT_DESC(TWHA60_ORIG1, 1162 twha60_fixed1); 1163 if (rc != 0) 1164 goto cleanup; 1165 break; 1166 } 1167 break; 1168 } 1169 fallthrough; 1170 case VID_PID(USB_VENDOR_ID_HUION, 1171 USB_DEVICE_ID_HUION_TABLET): 1172 case VID_PID(USB_VENDOR_ID_HUION, 1173 USB_DEVICE_ID_HUION_TABLET2): 1174 case VID_PID(USB_VENDOR_ID_UCLOGIC, 1175 USB_DEVICE_ID_HUION_TABLET): 1176 case VID_PID(USB_VENDOR_ID_UCLOGIC, 1177 USB_DEVICE_ID_YIYNOVA_TABLET): 1178 case VID_PID(USB_VENDOR_ID_UCLOGIC, 1179 USB_DEVICE_ID_UCLOGIC_UGEE_TABLET_81): 1180 case VID_PID(USB_VENDOR_ID_UCLOGIC, 1181 USB_DEVICE_ID_UCLOGIC_DRAWIMAGE_G3): 1182 case VID_PID(USB_VENDOR_ID_UCLOGIC, 1183 USB_DEVICE_ID_UCLOGIC_UGEE_TABLET_45): 1184 case VID_PID(USB_VENDOR_ID_UCLOGIC, 1185 USB_DEVICE_ID_UCLOGIC_UGEE_TABLET_47): 1186 rc = uclogic_params_huion_init(&p, hdev); 1187 if (rc != 0) 1188 goto cleanup; 1189 break; 1190 case VID_PID(USB_VENDOR_ID_UGTIZER, 1191 USB_DEVICE_ID_UGTIZER_TABLET_GP0610): 1192 case VID_PID(USB_VENDOR_ID_UGTIZER, 1193 USB_DEVICE_ID_UGTIZER_TABLET_GT5040): 1194 case VID_PID(USB_VENDOR_ID_UGEE, 1195 USB_DEVICE_ID_UGEE_XPPEN_TABLET_G540): 1196 case VID_PID(USB_VENDOR_ID_UGEE, 1197 USB_DEVICE_ID_UGEE_XPPEN_TABLET_G640): 1198 case VID_PID(USB_VENDOR_ID_UGEE, 1199 USB_DEVICE_ID_UGEE_XPPEN_TABLET_STAR06): 1200 case VID_PID(USB_VENDOR_ID_UGEE, 1201 USB_DEVICE_ID_UGEE_TABLET_RAINBOW_CV720): 1202 /* If this is the pen interface */ 1203 if (bInterfaceNumber == 1) { 1204 /* Probe v1 pen parameters */ 1205 rc = uclogic_params_pen_init_v1(&p.pen, &found, hdev); 1206 if (rc != 0) { 1207 hid_err(hdev, "pen probing failed: %d\n", rc); 1208 goto cleanup; 1209 } 1210 if (!found) { 1211 hid_warn(hdev, "pen parameters not found"); 1212 uclogic_params_init_invalid(&p); 1213 } 1214 } else { 1215 uclogic_params_init_invalid(&p); 1216 } 1217 break; 1218 case VID_PID(USB_VENDOR_ID_UGEE, 1219 USB_DEVICE_ID_UGEE_XPPEN_TABLET_DECO01): 1220 /* If this is the pen and frame interface */ 1221 if (bInterfaceNumber == 1) { 1222 /* Probe v1 pen parameters */ 1223 rc = uclogic_params_pen_init_v1(&p.pen, &found, hdev); 1224 if (rc != 0) { 1225 hid_err(hdev, "pen probing failed: %d\n", rc); 1226 goto cleanup; 1227 } 1228 /* Initialize frame parameters */ 1229 rc = uclogic_params_frame_init_with_desc( 1230 &p.frame_list[0], 1231 uclogic_rdesc_xppen_deco01_frame_arr, 1232 uclogic_rdesc_xppen_deco01_frame_size, 1233 0); 1234 if (rc != 0) 1235 goto cleanup; 1236 } else { 1237 uclogic_params_init_invalid(&p); 1238 } 1239 break; 1240 case VID_PID(USB_VENDOR_ID_TRUST, 1241 USB_DEVICE_ID_TRUST_PANORA_TABLET): 1242 case VID_PID(USB_VENDOR_ID_UGEE, 1243 USB_DEVICE_ID_UGEE_TABLET_G5): 1244 /* Ignore non-pen interfaces */ 1245 if (bInterfaceNumber != 1) { 1246 uclogic_params_init_invalid(&p); 1247 break; 1248 } 1249 1250 rc = uclogic_params_pen_init_v1(&p.pen, &found, hdev); 1251 if (rc != 0) { 1252 hid_err(hdev, "pen probing failed: %d\n", rc); 1253 goto cleanup; 1254 } else if (found) { 1255 rc = uclogic_params_frame_init_with_desc( 1256 &p.frame_list[0], 1257 uclogic_rdesc_ugee_g5_frame_arr, 1258 uclogic_rdesc_ugee_g5_frame_size, 1259 UCLOGIC_RDESC_UGEE_G5_FRAME_ID); 1260 if (rc != 0) { 1261 hid_err(hdev, 1262 "failed creating frame parameters: %d\n", 1263 rc); 1264 goto cleanup; 1265 } 1266 p.frame_list[0].re_lsb = 1267 UCLOGIC_RDESC_UGEE_G5_FRAME_RE_LSB; 1268 p.frame_list[0].dev_id_byte = 1269 UCLOGIC_RDESC_UGEE_G5_FRAME_DEV_ID_BYTE; 1270 } else { 1271 hid_warn(hdev, "pen parameters not found"); 1272 uclogic_params_init_invalid(&p); 1273 } 1274 1275 break; 1276 case VID_PID(USB_VENDOR_ID_UGEE, 1277 USB_DEVICE_ID_UGEE_TABLET_EX07S): 1278 /* Ignore non-pen interfaces */ 1279 if (bInterfaceNumber != 1) { 1280 uclogic_params_init_invalid(&p); 1281 break; 1282 } 1283 1284 rc = uclogic_params_pen_init_v1(&p.pen, &found, hdev); 1285 if (rc != 0) { 1286 hid_err(hdev, "pen probing failed: %d\n", rc); 1287 goto cleanup; 1288 } else if (found) { 1289 rc = uclogic_params_frame_init_with_desc( 1290 &p.frame_list[0], 1291 uclogic_rdesc_ugee_ex07_frame_arr, 1292 uclogic_rdesc_ugee_ex07_frame_size, 1293 0); 1294 if (rc != 0) { 1295 hid_err(hdev, 1296 "failed creating frame parameters: %d\n", 1297 rc); 1298 goto cleanup; 1299 } 1300 } else { 1301 hid_warn(hdev, "pen parameters not found"); 1302 uclogic_params_init_invalid(&p); 1303 } 1304 1305 break; 1306 } 1307 1308 #undef VID_PID 1309 #undef WITH_OPT_DESC 1310 1311 /* Output parameters */ 1312 memcpy(params, &p, sizeof(*params)); 1313 memset(&p, 0, sizeof(p)); 1314 rc = 0; 1315 cleanup: 1316 uclogic_params_cleanup(&p); 1317 return rc; 1318 } 1319