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