1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /****************************************************************************** 3 * usbtouchscreen.c 4 * Driver for USB Touchscreens, supporting those devices: 5 * - eGalax Touchkit 6 * includes eTurboTouch CT-410/510/700 7 * - 3M/Microtouch EX II series 8 * - ITM 9 * - PanJit TouchSet 10 * - eTurboTouch 11 * - Gunze AHL61 12 * - DMC TSC-10/25 13 * - IRTOUCHSYSTEMS/UNITOP 14 * - IdealTEK URTC1000 15 * - General Touch 16 * - GoTop Super_Q2/GogoPen/PenPower tablets 17 * - JASTEC USB touch controller/DigiTech DTR-02U 18 * - Zytronic capacitive touchscreen 19 * - NEXIO/iNexio 20 * - Elo TouchSystems 2700 IntelliTouch 21 * - EasyTouch USB Dual/Multi touch controller from Data Modul 22 * 23 * Copyright (C) 2004-2007 by Daniel Ritz <daniel.ritz@gmx.ch> 24 * Copyright (C) by Todd E. Johnson (mtouchusb.c) 25 * 26 * Driver is based on touchkitusb.c 27 * - ITM parts are from itmtouch.c 28 * - 3M parts are from mtouchusb.c 29 * - PanJit parts are from an unmerged driver by Lanslott Gish 30 * - DMC TSC 10/25 are from Holger Schurig, with ideas from an unmerged 31 * driver from Marius Vollmer 32 * 33 *****************************************************************************/ 34 35 //#define DEBUG 36 37 #include <linux/kernel.h> 38 #include <linux/slab.h> 39 #include <linux/input.h> 40 #include <linux/module.h> 41 #include <linux/usb.h> 42 #include <linux/usb/input.h> 43 #include <linux/hid.h> 44 #include <linux/mutex.h> 45 46 static bool swap_xy; 47 module_param(swap_xy, bool, 0644); 48 MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped."); 49 50 static bool hwcalib_xy; 51 module_param(hwcalib_xy, bool, 0644); 52 MODULE_PARM_DESC(hwcalib_xy, "If set hw-calibrated X/Y are used if available"); 53 54 /* device specifc data/functions */ 55 struct usbtouch_usb; 56 struct usbtouch_device_info { 57 int min_xc, max_xc; 58 int min_yc, max_yc; 59 int min_press, max_press; 60 int rept_size; 61 62 /* 63 * Always service the USB devices irq not just when the input device is 64 * open. This is useful when devices have a watchdog which prevents us 65 * from periodically polling the device. Leave this unset unless your 66 * touchscreen device requires it, as it does consume more of the USB 67 * bandwidth. 68 */ 69 bool irq_always; 70 71 /* 72 * used to get the packet len. possible return values: 73 * > 0: packet len 74 * = 0: skip one byte 75 * < 0: -return value more bytes needed 76 */ 77 int (*get_pkt_len) (unsigned char *pkt, int len); 78 79 int (*read_data) (struct usbtouch_usb *usbtouch, unsigned char *pkt); 80 int (*alloc) (struct usbtouch_usb *usbtouch); 81 int (*init) (struct usbtouch_usb *usbtouch); 82 void (*exit) (struct usbtouch_usb *usbtouch); 83 }; 84 85 /* a usbtouch device */ 86 struct usbtouch_usb { 87 unsigned char *data; 88 dma_addr_t data_dma; 89 int data_size; 90 unsigned char *buffer; 91 int buf_len; 92 struct urb *irq; 93 struct usb_interface *interface; 94 struct input_dev *input; 95 const struct usbtouch_device_info *type; 96 struct mutex pm_mutex; /* serialize access to open/suspend */ 97 bool is_open; 98 char name[128]; 99 char phys[64]; 100 void *priv; 101 102 int x, y; 103 int touch, press; 104 105 void (*process_pkt)(struct usbtouch_usb *usbtouch, unsigned char *pkt, int len); 106 }; 107 108 109 /***************************************************************************** 110 * e2i Part 111 */ 112 113 #ifdef CONFIG_TOUCHSCREEN_USB_E2I 114 static int e2i_init(struct usbtouch_usb *usbtouch) 115 { 116 int ret; 117 struct usb_device *udev = interface_to_usbdev(usbtouch->interface); 118 119 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 120 0x01, 0x02, 0x0000, 0x0081, 121 NULL, 0, USB_CTRL_SET_TIMEOUT); 122 123 dev_dbg(&usbtouch->interface->dev, 124 "%s - usb_control_msg - E2I_RESET - bytes|err: %d\n", 125 __func__, ret); 126 return ret; 127 } 128 129 static int e2i_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 130 { 131 int tmp = (pkt[0] << 8) | pkt[1]; 132 dev->x = (pkt[2] << 8) | pkt[3]; 133 dev->y = (pkt[4] << 8) | pkt[5]; 134 135 tmp = tmp - 0xA000; 136 dev->touch = (tmp > 0); 137 dev->press = (tmp > 0 ? tmp : 0); 138 139 return 1; 140 } 141 142 static const struct usbtouch_device_info e2i_dev_info = { 143 .min_xc = 0x0, 144 .max_xc = 0x7fff, 145 .min_yc = 0x0, 146 .max_yc = 0x7fff, 147 .rept_size = 6, 148 .init = e2i_init, 149 .read_data = e2i_read_data, 150 }; 151 #endif 152 153 154 /***************************************************************************** 155 * eGalax part 156 */ 157 158 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX 159 160 #ifndef MULTI_PACKET 161 #define MULTI_PACKET 162 #endif 163 164 #define EGALAX_PKT_TYPE_MASK 0xFE 165 #define EGALAX_PKT_TYPE_REPT 0x80 166 #define EGALAX_PKT_TYPE_DIAG 0x0A 167 168 static int egalax_init(struct usbtouch_usb *usbtouch) 169 { 170 struct usb_device *udev = interface_to_usbdev(usbtouch->interface); 171 int ret, i; 172 173 /* 174 * An eGalax diagnostic packet kicks the device into using the right 175 * protocol. We send a "check active" packet. The response will be 176 * read later and ignored. 177 */ 178 179 u8 *buf __free(kfree) = kmalloc(3, GFP_KERNEL); 180 if (!buf) 181 return -ENOMEM; 182 183 buf[0] = EGALAX_PKT_TYPE_DIAG; 184 buf[1] = 1; /* length */ 185 buf[2] = 'A'; /* command - check active */ 186 187 for (i = 0; i < 3; i++) { 188 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 189 0, 190 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 191 0, 0, buf, 3, 192 USB_CTRL_SET_TIMEOUT); 193 if (ret != -EPIPE) 194 break; 195 } 196 197 return ret < 0 ? ret : 0; 198 } 199 200 static int egalax_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 201 { 202 if ((pkt[0] & EGALAX_PKT_TYPE_MASK) != EGALAX_PKT_TYPE_REPT) 203 return 0; 204 205 dev->x = ((pkt[3] & 0x0F) << 7) | (pkt[4] & 0x7F); 206 dev->y = ((pkt[1] & 0x0F) << 7) | (pkt[2] & 0x7F); 207 dev->touch = pkt[0] & 0x01; 208 209 return 1; 210 } 211 212 static int egalax_get_pkt_len(unsigned char *buf, int len) 213 { 214 switch (buf[0] & EGALAX_PKT_TYPE_MASK) { 215 case EGALAX_PKT_TYPE_REPT: 216 return 5; 217 218 case EGALAX_PKT_TYPE_DIAG: 219 if (len < 2) 220 return -1; 221 222 return buf[1] + 2; 223 } 224 225 return 0; 226 } 227 228 static const struct usbtouch_device_info egalax_dev_info = { 229 .min_xc = 0x0, 230 .max_xc = 0x07ff, 231 .min_yc = 0x0, 232 .max_yc = 0x07ff, 233 .rept_size = 16, 234 .get_pkt_len = egalax_get_pkt_len, 235 .read_data = egalax_read_data, 236 .init = egalax_init, 237 }; 238 #endif 239 240 /***************************************************************************** 241 * EasyTouch part 242 */ 243 244 #ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH 245 246 #ifndef MULTI_PACKET 247 #define MULTI_PACKET 248 #endif 249 250 #define ETOUCH_PKT_TYPE_MASK 0xFE 251 #define ETOUCH_PKT_TYPE_REPT 0x80 252 #define ETOUCH_PKT_TYPE_REPT2 0xB0 253 #define ETOUCH_PKT_TYPE_DIAG 0x0A 254 255 static int etouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 256 { 257 if ((pkt[0] & ETOUCH_PKT_TYPE_MASK) != ETOUCH_PKT_TYPE_REPT && 258 (pkt[0] & ETOUCH_PKT_TYPE_MASK) != ETOUCH_PKT_TYPE_REPT2) 259 return 0; 260 261 dev->x = ((pkt[1] & 0x1F) << 7) | (pkt[2] & 0x7F); 262 dev->y = ((pkt[3] & 0x1F) << 7) | (pkt[4] & 0x7F); 263 dev->touch = pkt[0] & 0x01; 264 265 return 1; 266 } 267 268 static int etouch_get_pkt_len(unsigned char *buf, int len) 269 { 270 switch (buf[0] & ETOUCH_PKT_TYPE_MASK) { 271 case ETOUCH_PKT_TYPE_REPT: 272 case ETOUCH_PKT_TYPE_REPT2: 273 return 5; 274 275 case ETOUCH_PKT_TYPE_DIAG: 276 if (len < 2) 277 return -1; 278 279 return buf[1] + 2; 280 } 281 282 return 0; 283 } 284 285 static const struct usbtouch_device_info etouch_dev_info = { 286 .min_xc = 0x0, 287 .max_xc = 0x07ff, 288 .min_yc = 0x0, 289 .max_yc = 0x07ff, 290 .rept_size = 16, 291 .get_pkt_len = etouch_get_pkt_len, 292 .read_data = etouch_read_data, 293 }; 294 #endif 295 296 /***************************************************************************** 297 * PanJit Part 298 */ 299 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT 300 static int panjit_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 301 { 302 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1]; 303 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3]; 304 dev->touch = pkt[0] & 0x01; 305 306 return 1; 307 } 308 309 static const struct usbtouch_device_info panjit_dev_info = { 310 .min_xc = 0x0, 311 .max_xc = 0x0fff, 312 .min_yc = 0x0, 313 .max_yc = 0x0fff, 314 .rept_size = 8, 315 .read_data = panjit_read_data, 316 }; 317 #endif 318 319 320 /***************************************************************************** 321 * 3M/Microtouch Part 322 */ 323 #ifdef CONFIG_TOUCHSCREEN_USB_3M 324 325 #define MTOUCHUSB_ASYNC_REPORT 1 326 #define MTOUCHUSB_RESET 7 327 #define MTOUCHUSB_REQ_CTRLLR_ID 10 328 329 #define MTOUCHUSB_REQ_CTRLLR_ID_LEN 16 330 331 static int mtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 332 { 333 if (hwcalib_xy) { 334 dev->x = (pkt[4] << 8) | pkt[3]; 335 dev->y = 0xffff - ((pkt[6] << 8) | pkt[5]); 336 } else { 337 dev->x = (pkt[8] << 8) | pkt[7]; 338 dev->y = (pkt[10] << 8) | pkt[9]; 339 } 340 dev->touch = (pkt[2] & 0x40) ? 1 : 0; 341 342 return 1; 343 } 344 345 struct mtouch_priv { 346 u8 fw_rev_major; 347 u8 fw_rev_minor; 348 }; 349 350 static int mtouch_get_fw_revision(struct usbtouch_usb *usbtouch) 351 { 352 struct usb_device *udev = interface_to_usbdev(usbtouch->interface); 353 struct mtouch_priv *priv = usbtouch->priv; 354 int ret; 355 356 u8 *buf __free(kfree) = kzalloc(MTOUCHUSB_REQ_CTRLLR_ID_LEN, GFP_NOIO); 357 if (!buf) 358 return -ENOMEM; 359 360 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 361 MTOUCHUSB_REQ_CTRLLR_ID, 362 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 363 0, 0, buf, MTOUCHUSB_REQ_CTRLLR_ID_LEN, 364 USB_CTRL_SET_TIMEOUT); 365 if (ret != MTOUCHUSB_REQ_CTRLLR_ID_LEN) { 366 dev_warn(&usbtouch->interface->dev, 367 "Failed to read FW rev: %d\n", ret); 368 return ret < 0 ? ret : -EIO; 369 } 370 371 priv->fw_rev_major = buf[3]; 372 priv->fw_rev_minor = buf[4]; 373 374 return 0; 375 } 376 377 static int mtouch_alloc(struct usbtouch_usb *usbtouch) 378 { 379 struct mtouch_priv *priv; 380 381 priv = kmalloc_obj(*priv); 382 if (!priv) 383 return -ENOMEM; 384 385 usbtouch->priv = priv; 386 return 0; 387 } 388 389 static int mtouch_init(struct usbtouch_usb *usbtouch) 390 { 391 int ret, i; 392 struct usb_device *udev = interface_to_usbdev(usbtouch->interface); 393 394 ret = mtouch_get_fw_revision(usbtouch); 395 if (ret) 396 return ret; 397 398 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 399 MTOUCHUSB_RESET, 400 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 401 1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT); 402 dev_dbg(&usbtouch->interface->dev, 403 "%s - usb_control_msg - MTOUCHUSB_RESET - bytes|err: %d\n", 404 __func__, ret); 405 if (ret < 0) 406 return ret; 407 msleep(150); 408 409 for (i = 0; i < 3; i++) { 410 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 411 MTOUCHUSB_ASYNC_REPORT, 412 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 413 1, 1, NULL, 0, USB_CTRL_SET_TIMEOUT); 414 dev_dbg(&usbtouch->interface->dev, 415 "%s - usb_control_msg - MTOUCHUSB_ASYNC_REPORT - bytes|err: %d\n", 416 __func__, ret); 417 if (ret >= 0) 418 break; 419 if (ret != -EPIPE) 420 return ret; 421 } 422 423 /* Default min/max xy are the raw values, override if using hw-calib */ 424 if (hwcalib_xy) { 425 input_set_abs_params(usbtouch->input, ABS_X, 0, 0xffff, 0, 0); 426 input_set_abs_params(usbtouch->input, ABS_Y, 0, 0xffff, 0, 0); 427 } 428 429 return 0; 430 } 431 432 static void mtouch_exit(struct usbtouch_usb *usbtouch) 433 { 434 struct mtouch_priv *priv = usbtouch->priv; 435 436 kfree(priv); 437 } 438 439 static struct usbtouch_device_info mtouch_dev_info = { 440 .min_xc = 0x0, 441 .max_xc = 0x4000, 442 .min_yc = 0x0, 443 .max_yc = 0x4000, 444 .rept_size = 11, 445 .read_data = mtouch_read_data, 446 .alloc = mtouch_alloc, 447 .init = mtouch_init, 448 .exit = mtouch_exit, 449 }; 450 451 static ssize_t mtouch_firmware_rev_show(struct device *dev, 452 struct device_attribute *attr, char *output) 453 { 454 struct usb_interface *intf = to_usb_interface(dev); 455 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 456 struct mtouch_priv *priv = usbtouch->priv; 457 458 return sysfs_emit(output, "%1x.%1x\n", 459 priv->fw_rev_major, priv->fw_rev_minor); 460 } 461 static DEVICE_ATTR(firmware_rev, 0444, mtouch_firmware_rev_show, NULL); 462 463 static struct attribute *mtouch_attrs[] = { 464 &dev_attr_firmware_rev.attr, 465 NULL 466 }; 467 468 static bool mtouch_group_visible(struct kobject *kobj) 469 { 470 struct device *dev = kobj_to_dev(kobj); 471 struct usb_interface *intf = to_usb_interface(dev); 472 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 473 474 return usbtouch->type == &mtouch_dev_info; 475 } 476 477 DEFINE_SIMPLE_SYSFS_GROUP_VISIBLE(mtouch); 478 479 static const struct attribute_group mtouch_attr_group = { 480 .is_visible = SYSFS_GROUP_VISIBLE(mtouch), 481 .attrs = mtouch_attrs, 482 }; 483 #endif 484 485 486 /***************************************************************************** 487 * ITM Part 488 */ 489 #ifdef CONFIG_TOUCHSCREEN_USB_ITM 490 static int itm_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 491 { 492 int touch; 493 /* 494 * ITM devices report invalid x/y data if not touched. 495 * if the screen was touched before but is not touched any more 496 * report touch as 0 with the last valid x/y data once. then stop 497 * reporting data until touched again. 498 */ 499 dev->press = ((pkt[2] & 0x01) << 7) | (pkt[5] & 0x7F); 500 501 touch = ~pkt[7] & 0x20; 502 if (!touch) { 503 if (dev->touch) { 504 dev->touch = 0; 505 return 1; 506 } 507 508 return 0; 509 } 510 511 dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[3] & 0x7F); 512 dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[4] & 0x7F); 513 dev->touch = touch; 514 515 return 1; 516 } 517 518 static const struct usbtouch_device_info itm_dev_info = { 519 .min_xc = 0x0, 520 .max_xc = 0x0fff, 521 .min_yc = 0x0, 522 .max_yc = 0x0fff, 523 .max_press = 0xff, 524 .rept_size = 8, 525 .read_data = itm_read_data, 526 }; 527 #endif 528 529 530 /***************************************************************************** 531 * eTurboTouch part 532 */ 533 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO 534 #ifndef MULTI_PACKET 535 #define MULTI_PACKET 536 #endif 537 static int eturbo_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 538 { 539 unsigned int shift; 540 541 /* packets should start with sync */ 542 if (!(pkt[0] & 0x80)) 543 return 0; 544 545 shift = (6 - (pkt[0] & 0x03)); 546 dev->x = ((pkt[3] << 7) | pkt[4]) >> shift; 547 dev->y = ((pkt[1] << 7) | pkt[2]) >> shift; 548 dev->touch = (pkt[0] & 0x10) ? 1 : 0; 549 550 return 1; 551 } 552 553 static int eturbo_get_pkt_len(unsigned char *buf, int len) 554 { 555 if (buf[0] & 0x80) 556 return 5; 557 if (buf[0] == 0x01) 558 return 3; 559 return 0; 560 } 561 562 static const struct usbtouch_device_info eturbo_dev_info = { 563 .min_xc = 0x0, 564 .max_xc = 0x07ff, 565 .min_yc = 0x0, 566 .max_yc = 0x07ff, 567 .rept_size = 8, 568 .get_pkt_len = eturbo_get_pkt_len, 569 .read_data = eturbo_read_data, 570 }; 571 #endif 572 573 574 /***************************************************************************** 575 * Gunze part 576 */ 577 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE 578 static int gunze_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 579 { 580 if (!(pkt[0] & 0x80) || ((pkt[1] | pkt[2] | pkt[3]) & 0x80)) 581 return 0; 582 583 dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[2] & 0x7F); 584 dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[3] & 0x7F); 585 dev->touch = pkt[0] & 0x20; 586 587 return 1; 588 } 589 590 static const struct usbtouch_device_info gunze_dev_info = { 591 .min_xc = 0x0, 592 .max_xc = 0x0fff, 593 .min_yc = 0x0, 594 .max_yc = 0x0fff, 595 .rept_size = 4, 596 .read_data = gunze_read_data, 597 }; 598 #endif 599 600 /***************************************************************************** 601 * DMC TSC-10/25 Part 602 * 603 * Documentation about the controller and it's protocol can be found at 604 * http://www.dmccoltd.com/files/controler/tsc10usb_pi_e.pdf 605 * http://www.dmccoltd.com/files/controler/tsc25_usb_e.pdf 606 */ 607 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10 608 609 /* supported data rates. currently using 130 */ 610 #define TSC10_RATE_POINT 0x50 611 #define TSC10_RATE_30 0x40 612 #define TSC10_RATE_50 0x41 613 #define TSC10_RATE_80 0x42 614 #define TSC10_RATE_100 0x43 615 #define TSC10_RATE_130 0x44 616 #define TSC10_RATE_150 0x45 617 618 /* commands */ 619 #define TSC10_CMD_RESET 0x55 620 #define TSC10_CMD_RATE 0x05 621 #define TSC10_CMD_DATA1 0x01 622 623 static int dmc_tsc10_init(struct usbtouch_usb *usbtouch) 624 { 625 struct usb_device *dev = interface_to_usbdev(usbtouch->interface); 626 int ret; 627 628 u8 *buf __free(kfree) = kmalloc(2, GFP_NOIO); 629 if (!buf) 630 return -ENOMEM; 631 632 /* reset */ 633 buf[0] = buf[1] = 0xFF; 634 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 635 TSC10_CMD_RESET, 636 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 637 0, 0, buf, 2, USB_CTRL_SET_TIMEOUT); 638 if (ret < 0) 639 return ret; 640 641 if (buf[0] != 0x06) 642 return -ENODEV; 643 644 /* TSC-25 data sheet specifies a delay after the RESET command */ 645 msleep(150); 646 647 /* set coordinate output rate */ 648 buf[0] = buf[1] = 0xFF; 649 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 650 TSC10_CMD_RATE, 651 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 652 TSC10_RATE_150, 0, buf, 2, USB_CTRL_SET_TIMEOUT); 653 if (ret < 0) 654 return ret; 655 656 if (buf[0] != 0x06 && (buf[0] != 0x15 || buf[1] != 0x01)) 657 return -ENODEV; 658 659 /* start sending data */ 660 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 661 TSC10_CMD_DATA1, 662 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 663 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT); 664 } 665 666 static int dmc_tsc10_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 667 { 668 dev->x = ((pkt[2] & 0x03) << 8) | pkt[1]; 669 dev->y = ((pkt[4] & 0x03) << 8) | pkt[3]; 670 dev->touch = pkt[0] & 0x01; 671 672 return 1; 673 } 674 675 static const struct usbtouch_device_info dmc_tsc10_dev_info = { 676 .min_xc = 0x0, 677 .max_xc = 0x03ff, 678 .min_yc = 0x0, 679 .max_yc = 0x03ff, 680 .rept_size = 5, 681 .init = dmc_tsc10_init, 682 .read_data = dmc_tsc10_read_data, 683 }; 684 #endif 685 686 687 /***************************************************************************** 688 * IRTOUCH Part 689 */ 690 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 691 static int irtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 692 { 693 dev->x = (pkt[3] << 8) | pkt[2]; 694 dev->y = (pkt[5] << 8) | pkt[4]; 695 dev->touch = (pkt[1] & 0x03) ? 1 : 0; 696 697 return 1; 698 } 699 700 static const struct usbtouch_device_info irtouch_dev_info = { 701 .min_xc = 0x0, 702 .max_xc = 0x0fff, 703 .min_yc = 0x0, 704 .max_yc = 0x0fff, 705 .rept_size = 8, 706 .read_data = irtouch_read_data, 707 }; 708 709 static const struct usbtouch_device_info irtouch_hires_dev_info = { 710 .min_xc = 0x0, 711 .max_xc = 0x7fff, 712 .min_yc = 0x0, 713 .max_yc = 0x7fff, 714 .rept_size = 8, 715 .read_data = irtouch_read_data, 716 }; 717 #endif 718 719 /***************************************************************************** 720 * ET&T TC5UH/TC4UM part 721 */ 722 #ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB 723 static int tc45usb_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 724 { 725 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1]; 726 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3]; 727 dev->touch = pkt[0] & 0x01; 728 729 return 1; 730 } 731 732 static const struct usbtouch_device_info tc45usb_dev_info = { 733 .min_xc = 0x0, 734 .max_xc = 0x0fff, 735 .min_yc = 0x0, 736 .max_yc = 0x0fff, 737 .rept_size = 5, 738 .read_data = tc45usb_read_data, 739 }; 740 #endif 741 742 /***************************************************************************** 743 * IdealTEK URTC1000 Part 744 */ 745 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 746 #ifndef MULTI_PACKET 747 #define MULTI_PACKET 748 #endif 749 static int idealtek_get_pkt_len(unsigned char *buf, int len) 750 { 751 if (buf[0] & 0x80) 752 return 5; 753 if (buf[0] == 0x01) 754 return len; 755 return 0; 756 } 757 758 static int idealtek_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 759 { 760 switch (pkt[0] & 0x98) { 761 case 0x88: 762 /* touch data in IdealTEK mode */ 763 dev->x = (pkt[1] << 5) | (pkt[2] >> 2); 764 dev->y = (pkt[3] << 5) | (pkt[4] >> 2); 765 dev->touch = (pkt[0] & 0x40) ? 1 : 0; 766 return 1; 767 768 case 0x98: 769 /* touch data in MT emulation mode */ 770 dev->x = (pkt[2] << 5) | (pkt[1] >> 2); 771 dev->y = (pkt[4] << 5) | (pkt[3] >> 2); 772 dev->touch = (pkt[0] & 0x40) ? 1 : 0; 773 return 1; 774 775 default: 776 return 0; 777 } 778 } 779 780 static const struct usbtouch_device_info idealtek_dev_info = { 781 .min_xc = 0x0, 782 .max_xc = 0x0fff, 783 .min_yc = 0x0, 784 .max_yc = 0x0fff, 785 .rept_size = 8, 786 .get_pkt_len = idealtek_get_pkt_len, 787 .read_data = idealtek_read_data, 788 }; 789 #endif 790 791 /***************************************************************************** 792 * General Touch Part 793 */ 794 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 795 static int general_touch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 796 { 797 dev->x = (pkt[2] << 8) | pkt[1]; 798 dev->y = (pkt[4] << 8) | pkt[3]; 799 dev->press = pkt[5] & 0xff; 800 dev->touch = pkt[0] & 0x01; 801 802 return 1; 803 } 804 805 static const struct usbtouch_device_info general_touch_dev_info = { 806 .min_xc = 0x0, 807 .max_xc = 0x7fff, 808 .min_yc = 0x0, 809 .max_yc = 0x7fff, 810 .rept_size = 7, 811 .read_data = general_touch_read_data, 812 }; 813 #endif 814 815 /***************************************************************************** 816 * GoTop Part 817 */ 818 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 819 static int gotop_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 820 { 821 dev->x = ((pkt[1] & 0x38) << 4) | pkt[2]; 822 dev->y = ((pkt[1] & 0x07) << 7) | pkt[3]; 823 dev->touch = pkt[0] & 0x01; 824 825 return 1; 826 } 827 828 static const struct usbtouch_device_info gotop_dev_info = { 829 .min_xc = 0x0, 830 .max_xc = 0x03ff, 831 .min_yc = 0x0, 832 .max_yc = 0x03ff, 833 .rept_size = 4, 834 .read_data = gotop_read_data, 835 }; 836 #endif 837 838 /***************************************************************************** 839 * JASTEC Part 840 */ 841 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC 842 static int jastec_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 843 { 844 dev->x = ((pkt[0] & 0x3f) << 6) | (pkt[2] & 0x3f); 845 dev->y = ((pkt[1] & 0x3f) << 6) | (pkt[3] & 0x3f); 846 dev->touch = (pkt[0] & 0x40) >> 6; 847 848 return 1; 849 } 850 851 static const struct usbtouch_device_info jastec_dev_info = { 852 .min_xc = 0x0, 853 .max_xc = 0x0fff, 854 .min_yc = 0x0, 855 .max_yc = 0x0fff, 856 .rept_size = 4, 857 .read_data = jastec_read_data, 858 }; 859 #endif 860 861 /***************************************************************************** 862 * Zytronic Part 863 */ 864 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC 865 static int zytronic_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 866 { 867 struct usb_interface *intf = dev->interface; 868 869 switch (pkt[0]) { 870 case 0x3A: /* command response */ 871 dev_dbg(&intf->dev, "%s: Command response %d\n", __func__, pkt[1]); 872 break; 873 874 case 0xC0: /* down */ 875 dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7); 876 dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7); 877 dev->touch = 1; 878 dev_dbg(&intf->dev, "%s: down %d,%d\n", __func__, dev->x, dev->y); 879 return 1; 880 881 case 0x80: /* up */ 882 dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7); 883 dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7); 884 dev->touch = 0; 885 dev_dbg(&intf->dev, "%s: up %d,%d\n", __func__, dev->x, dev->y); 886 return 1; 887 888 default: 889 dev_dbg(&intf->dev, "%s: Unknown return %d\n", __func__, pkt[0]); 890 break; 891 } 892 893 return 0; 894 } 895 896 static const struct usbtouch_device_info zytronic_dev_info = { 897 .min_xc = 0x0, 898 .max_xc = 0x03ff, 899 .min_yc = 0x0, 900 .max_yc = 0x03ff, 901 .rept_size = 5, 902 .read_data = zytronic_read_data, 903 .irq_always = true, 904 }; 905 #endif 906 907 /***************************************************************************** 908 * NEXIO Part 909 */ 910 #ifdef CONFIG_TOUCHSCREEN_USB_NEXIO 911 912 #define NEXIO_TIMEOUT 5000 913 #define NEXIO_BUFSIZE 1024 914 #define NEXIO_THRESHOLD 50 915 916 struct nexio_priv { 917 struct urb *ack; 918 unsigned char *ack_buf; 919 }; 920 921 struct nexio_touch_packet { 922 u8 flags; /* 0xe1 = touch, 0xe1 = release */ 923 __be16 data_len; /* total bytes of touch data */ 924 __be16 x_len; /* bytes for X axis */ 925 __be16 y_len; /* bytes for Y axis */ 926 u8 data[]; 927 } __attribute__ ((packed)); 928 929 static unsigned char nexio_ack_pkt[2] = { 0xaa, 0x02 }; 930 static unsigned char nexio_init_pkt[4] = { 0x82, 0x04, 0x0a, 0x0f }; 931 932 static void nexio_ack_complete(struct urb *urb) 933 { 934 } 935 936 static int nexio_alloc(struct usbtouch_usb *usbtouch) 937 { 938 struct nexio_priv *priv; 939 int ret = -ENOMEM; 940 941 priv = kmalloc_obj(*priv); 942 if (!priv) 943 goto out_buf; 944 945 usbtouch->priv = priv; 946 priv->ack_buf = kmemdup(nexio_ack_pkt, sizeof(nexio_ack_pkt), 947 GFP_KERNEL); 948 if (!priv->ack_buf) 949 goto err_priv; 950 951 priv->ack = usb_alloc_urb(0, GFP_KERNEL); 952 if (!priv->ack) { 953 dev_dbg(&usbtouch->interface->dev, 954 "%s - usb_alloc_urb failed: usbtouch->ack\n", __func__); 955 goto err_ack_buf; 956 } 957 958 return 0; 959 960 err_ack_buf: 961 kfree(priv->ack_buf); 962 err_priv: 963 kfree(priv); 964 out_buf: 965 return ret; 966 } 967 968 static int nexio_init(struct usbtouch_usb *usbtouch) 969 { 970 struct usb_device *dev = interface_to_usbdev(usbtouch->interface); 971 struct usb_host_interface *interface = usbtouch->interface->cur_altsetting; 972 struct usb_endpoint_descriptor *ep_in, *ep_out; 973 struct nexio_priv *priv = usbtouch->priv; 974 int actual_len, i; 975 char *firmware_ver = NULL, *device_name = NULL; 976 int input_ep, output_ep; 977 int ret; 978 979 /* find first input and output endpoint */ 980 ret = usb_find_common_endpoints(interface, &ep_in, &ep_out, NULL, NULL); 981 if (ret) 982 return -ENXIO; 983 984 input_ep = usb_endpoint_num(ep_in); 985 output_ep = usb_endpoint_num(ep_out); 986 987 u8 *buf __free(kfree) = kmalloc(NEXIO_BUFSIZE, GFP_NOIO); 988 if (!buf) 989 return -ENOMEM; 990 991 /* two empty reads */ 992 for (i = 0; i < 2; i++) { 993 ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, input_ep), 994 buf, NEXIO_BUFSIZE, &actual_len, 995 NEXIO_TIMEOUT); 996 if (ret < 0) 997 return ret; 998 } 999 1000 /* send init command */ 1001 memcpy(buf, nexio_init_pkt, sizeof(nexio_init_pkt)); 1002 ret = usb_bulk_msg(dev, usb_sndbulkpipe(dev, output_ep), 1003 buf, sizeof(nexio_init_pkt), &actual_len, 1004 NEXIO_TIMEOUT); 1005 if (ret < 0) 1006 return ret; 1007 1008 /* read replies */ 1009 for (i = 0; i < 3; i++) { 1010 memset(buf, 0, NEXIO_BUFSIZE); 1011 ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, input_ep), 1012 buf, NEXIO_BUFSIZE, &actual_len, 1013 NEXIO_TIMEOUT); 1014 if (ret < 0 || actual_len < 1 || buf[1] != actual_len) 1015 continue; 1016 switch (buf[0]) { 1017 case 0x83: /* firmware version */ 1018 if (!firmware_ver) 1019 firmware_ver = kstrdup(&buf[2], GFP_NOIO); 1020 break; 1021 case 0x84: /* device name */ 1022 if (!device_name) 1023 device_name = kstrdup(&buf[2], GFP_NOIO); 1024 break; 1025 } 1026 } 1027 1028 printk(KERN_INFO "Nexio device: %s, firmware version: %s\n", 1029 device_name, firmware_ver); 1030 1031 kfree(firmware_ver); 1032 kfree(device_name); 1033 1034 usb_fill_bulk_urb(priv->ack, dev, usb_sndbulkpipe(dev, output_ep), 1035 priv->ack_buf, sizeof(nexio_ack_pkt), 1036 nexio_ack_complete, usbtouch); 1037 1038 return 0; 1039 } 1040 1041 static void nexio_exit(struct usbtouch_usb *usbtouch) 1042 { 1043 struct nexio_priv *priv = usbtouch->priv; 1044 1045 usb_kill_urb(priv->ack); 1046 usb_free_urb(priv->ack); 1047 kfree(priv->ack_buf); 1048 kfree(priv); 1049 } 1050 1051 static int nexio_read_data(struct usbtouch_usb *usbtouch, unsigned char *pkt) 1052 { 1053 struct device *dev = &usbtouch->interface->dev; 1054 struct nexio_touch_packet *packet = (void *) pkt; 1055 struct nexio_priv *priv = usbtouch->priv; 1056 unsigned int data_len = be16_to_cpu(packet->data_len); 1057 unsigned int x_len = be16_to_cpu(packet->x_len); 1058 unsigned int y_len = be16_to_cpu(packet->y_len); 1059 int x, y, begin_x, begin_y, end_x, end_y, w, h, ret; 1060 1061 /* got touch data? */ 1062 if ((pkt[0] & 0xe0) != 0xe0) 1063 return 0; 1064 1065 if (data_len > 0xff) 1066 data_len -= 0x100; 1067 if (x_len > 0xff) 1068 x_len -= 0x80; 1069 1070 /* send ACK */ 1071 ret = usb_submit_urb(priv->ack, GFP_ATOMIC); 1072 if (ret) 1073 dev_warn(dev, "Failed to submit ACK URB: %d\n", ret); 1074 1075 if (!input_abs_get_max(usbtouch->input, ABS_X)) { 1076 input_set_abs_params(usbtouch->input, ABS_X, 1077 0, 2 * x_len, 0, 0); 1078 input_set_abs_params(usbtouch->input, ABS_Y, 1079 0, 2 * y_len, 0, 0); 1080 } 1081 /* 1082 * The device reports state of IR sensors on X and Y axes. 1083 * Each byte represents "darkness" percentage (0-100) of one element. 1084 * 17" touchscreen reports only 64 x 52 bytes so the resolution is low. 1085 * This also means that there's a limited multi-touch capability but 1086 * it's disabled (and untested) here as there's no X driver for that. 1087 */ 1088 begin_x = end_x = begin_y = end_y = -1; 1089 for (x = 0; x < x_len; x++) { 1090 if (begin_x == -1 && packet->data[x] > NEXIO_THRESHOLD) { 1091 begin_x = x; 1092 continue; 1093 } 1094 if (end_x == -1 && begin_x != -1 && packet->data[x] < NEXIO_THRESHOLD) { 1095 end_x = x - 1; 1096 for (y = x_len; y < data_len; y++) { 1097 if (begin_y == -1 && packet->data[y] > NEXIO_THRESHOLD) { 1098 begin_y = y - x_len; 1099 continue; 1100 } 1101 if (end_y == -1 && 1102 begin_y != -1 && packet->data[y] < NEXIO_THRESHOLD) { 1103 end_y = y - 1 - x_len; 1104 w = end_x - begin_x; 1105 h = end_y - begin_y; 1106 #if 0 1107 /* multi-touch */ 1108 input_report_abs(usbtouch->input, 1109 ABS_MT_TOUCH_MAJOR, max(w,h)); 1110 input_report_abs(usbtouch->input, 1111 ABS_MT_TOUCH_MINOR, min(x,h)); 1112 input_report_abs(usbtouch->input, 1113 ABS_MT_POSITION_X, 2*begin_x+w); 1114 input_report_abs(usbtouch->input, 1115 ABS_MT_POSITION_Y, 2*begin_y+h); 1116 input_report_abs(usbtouch->input, 1117 ABS_MT_ORIENTATION, w > h); 1118 input_mt_sync(usbtouch->input); 1119 #endif 1120 /* single touch */ 1121 usbtouch->x = 2 * begin_x + w; 1122 usbtouch->y = 2 * begin_y + h; 1123 usbtouch->touch = packet->flags & 0x01; 1124 begin_y = end_y = -1; 1125 return 1; 1126 } 1127 } 1128 begin_x = end_x = -1; 1129 } 1130 1131 } 1132 return 0; 1133 } 1134 1135 static const struct usbtouch_device_info nexio_dev_info = { 1136 .rept_size = 1024, 1137 .irq_always = true, 1138 .read_data = nexio_read_data, 1139 .alloc = nexio_alloc, 1140 .init = nexio_init, 1141 .exit = nexio_exit, 1142 }; 1143 #endif 1144 1145 1146 /***************************************************************************** 1147 * ELO part 1148 */ 1149 1150 #ifdef CONFIG_TOUCHSCREEN_USB_ELO 1151 1152 static int elo_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 1153 { 1154 dev->x = (pkt[3] << 8) | pkt[2]; 1155 dev->y = (pkt[5] << 8) | pkt[4]; 1156 dev->touch = pkt[6] > 0; 1157 dev->press = pkt[6]; 1158 1159 return 1; 1160 } 1161 1162 static const struct usbtouch_device_info elo_dev_info = { 1163 .min_xc = 0x0, 1164 .max_xc = 0x0fff, 1165 .min_yc = 0x0, 1166 .max_yc = 0x0fff, 1167 .max_press = 0xff, 1168 .rept_size = 8, 1169 .read_data = elo_read_data, 1170 }; 1171 #endif 1172 1173 1174 /***************************************************************************** 1175 * Generic Part 1176 */ 1177 static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch, 1178 unsigned char *pkt, int len) 1179 { 1180 const struct usbtouch_device_info *type = usbtouch->type; 1181 1182 if (!type->read_data(usbtouch, pkt)) 1183 return; 1184 1185 input_report_key(usbtouch->input, BTN_TOUCH, usbtouch->touch); 1186 1187 if (swap_xy) { 1188 input_report_abs(usbtouch->input, ABS_X, usbtouch->y); 1189 input_report_abs(usbtouch->input, ABS_Y, usbtouch->x); 1190 } else { 1191 input_report_abs(usbtouch->input, ABS_X, usbtouch->x); 1192 input_report_abs(usbtouch->input, ABS_Y, usbtouch->y); 1193 } 1194 if (type->max_press) 1195 input_report_abs(usbtouch->input, ABS_PRESSURE, usbtouch->press); 1196 input_sync(usbtouch->input); 1197 } 1198 1199 1200 #ifdef MULTI_PACKET 1201 static void usbtouch_process_multi(struct usbtouch_usb *usbtouch, 1202 unsigned char *pkt, int len) 1203 { 1204 unsigned char *buffer; 1205 int pkt_len, pos, buf_len, tmp; 1206 1207 /* process buffer */ 1208 if (unlikely(usbtouch->buf_len)) { 1209 /* try to get size */ 1210 pkt_len = usbtouch->type->get_pkt_len( 1211 usbtouch->buffer, usbtouch->buf_len); 1212 1213 /* drop? */ 1214 if (unlikely(!pkt_len)) 1215 goto out_flush_buf; 1216 1217 /* need to append -pkt_len bytes before able to get size */ 1218 if (unlikely(pkt_len < 0)) { 1219 int append = -pkt_len; 1220 if (unlikely(append > len)) 1221 append = len; 1222 if (usbtouch->buf_len + append >= usbtouch->type->rept_size) 1223 goto out_flush_buf; 1224 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, append); 1225 usbtouch->buf_len += append; 1226 1227 pkt_len = usbtouch->type->get_pkt_len( 1228 usbtouch->buffer, usbtouch->buf_len); 1229 if (pkt_len < 0) 1230 return; 1231 } 1232 1233 /* append */ 1234 tmp = pkt_len - usbtouch->buf_len; 1235 if (usbtouch->buf_len + tmp >= usbtouch->type->rept_size) 1236 goto out_flush_buf; 1237 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, tmp); 1238 usbtouch_process_pkt(usbtouch, usbtouch->buffer, pkt_len); 1239 1240 buffer = pkt + tmp; 1241 buf_len = len - tmp; 1242 } else { 1243 buffer = pkt; 1244 buf_len = len; 1245 } 1246 1247 /* loop over the received packet, process */ 1248 pos = 0; 1249 while (pos < buf_len) { 1250 /* get packet len */ 1251 pkt_len = usbtouch->type->get_pkt_len(buffer + pos, 1252 buf_len - pos); 1253 1254 /* unknown packet: skip one byte */ 1255 if (unlikely(!pkt_len)) { 1256 pos++; 1257 continue; 1258 } 1259 1260 /* full packet: process */ 1261 if (likely((pkt_len > 0) && (pkt_len <= buf_len - pos))) { 1262 usbtouch_process_pkt(usbtouch, buffer + pos, pkt_len); 1263 } else { 1264 /* incomplete packet: save in buffer */ 1265 memcpy(usbtouch->buffer, buffer + pos, buf_len - pos); 1266 usbtouch->buf_len = buf_len - pos; 1267 return; 1268 } 1269 pos += pkt_len; 1270 } 1271 1272 out_flush_buf: 1273 usbtouch->buf_len = 0; 1274 return; 1275 } 1276 #else 1277 static void usbtouch_process_multi(struct usbtouch_usb *usbtouch, 1278 unsigned char *pkt, int len) 1279 { 1280 dev_WARN_ONCE(&usbtouch->interface->dev, 1, 1281 "Protocol has ->get_pkt_len() without #define MULTI_PACKET"); 1282 } 1283 #endif 1284 1285 static void usbtouch_irq(struct urb *urb) 1286 { 1287 struct usbtouch_usb *usbtouch = urb->context; 1288 struct device *dev = &usbtouch->interface->dev; 1289 int retval; 1290 1291 switch (urb->status) { 1292 case 0: 1293 /* success */ 1294 break; 1295 case -ETIME: 1296 /* this urb is timing out */ 1297 dev_dbg(dev, 1298 "%s - urb timed out - was the device unplugged?\n", 1299 __func__); 1300 return; 1301 case -ECONNRESET: 1302 case -ENOENT: 1303 case -ESHUTDOWN: 1304 case -EPIPE: 1305 /* this urb is terminated, clean up */ 1306 dev_dbg(dev, "%s - urb shutting down with status: %d\n", 1307 __func__, urb->status); 1308 return; 1309 default: 1310 dev_dbg(dev, "%s - nonzero urb status received: %d\n", 1311 __func__, urb->status); 1312 goto exit; 1313 } 1314 1315 usbtouch->process_pkt(usbtouch, usbtouch->data, urb->actual_length); 1316 1317 exit: 1318 usb_mark_last_busy(interface_to_usbdev(usbtouch->interface)); 1319 retval = usb_submit_urb(urb, GFP_ATOMIC); 1320 if (retval) 1321 dev_err(dev, "%s - usb_submit_urb failed with result: %d\n", 1322 __func__, retval); 1323 } 1324 1325 static int usbtouch_start_io(struct usbtouch_usb *usbtouch) 1326 { 1327 guard(mutex)(&usbtouch->pm_mutex); 1328 1329 if (!usbtouch->type->irq_always) 1330 if (usb_submit_urb(usbtouch->irq, GFP_KERNEL)) 1331 return -EIO; 1332 1333 usbtouch->interface->needs_remote_wakeup = 1; 1334 usbtouch->is_open = true; 1335 1336 return 0; 1337 } 1338 1339 static int usbtouch_open(struct input_dev *input) 1340 { 1341 struct usbtouch_usb *usbtouch = input_get_drvdata(input); 1342 int r; 1343 1344 usbtouch->irq->dev = interface_to_usbdev(usbtouch->interface); 1345 1346 r = usb_autopm_get_interface(usbtouch->interface) ? -EIO : 0; 1347 if (r) 1348 return r; 1349 1350 r = usbtouch_start_io(usbtouch); 1351 1352 usb_autopm_put_interface(usbtouch->interface); 1353 return r; 1354 } 1355 1356 static void usbtouch_close(struct input_dev *input) 1357 { 1358 struct usbtouch_usb *usbtouch = input_get_drvdata(input); 1359 int r; 1360 1361 scoped_guard(mutex, &usbtouch->pm_mutex) { 1362 if (!usbtouch->type->irq_always) 1363 usb_kill_urb(usbtouch->irq); 1364 usbtouch->is_open = false; 1365 } 1366 1367 r = usb_autopm_get_interface(usbtouch->interface); 1368 usbtouch->interface->needs_remote_wakeup = 0; 1369 if (!r) 1370 usb_autopm_put_interface(usbtouch->interface); 1371 } 1372 1373 static int usbtouch_suspend(struct usb_interface *intf, pm_message_t message) 1374 { 1375 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1376 1377 usb_kill_urb(usbtouch->irq); 1378 1379 return 0; 1380 } 1381 1382 static int usbtouch_resume(struct usb_interface *intf) 1383 { 1384 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1385 1386 guard(mutex)(&usbtouch->pm_mutex); 1387 1388 if (usbtouch->is_open || usbtouch->type->irq_always) 1389 return usb_submit_urb(usbtouch->irq, GFP_NOIO); 1390 1391 return 0; 1392 } 1393 1394 static int usbtouch_reset_resume(struct usb_interface *intf) 1395 { 1396 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1397 int err; 1398 1399 /* reinit the device */ 1400 if (usbtouch->type->init) { 1401 err = usbtouch->type->init(usbtouch); 1402 if (err) { 1403 dev_dbg(&intf->dev, 1404 "%s - type->init() failed, err: %d\n", 1405 __func__, err); 1406 return err; 1407 } 1408 } 1409 1410 /* restart IO if needed */ 1411 guard(mutex)(&usbtouch->pm_mutex); 1412 1413 if (usbtouch->is_open) 1414 return usb_submit_urb(usbtouch->irq, GFP_NOIO); 1415 1416 return 0; 1417 } 1418 1419 static void usbtouch_free_buffers(struct usb_device *udev, 1420 struct usbtouch_usb *usbtouch) 1421 { 1422 usb_free_coherent(udev, usbtouch->data_size, 1423 usbtouch->data, usbtouch->data_dma); 1424 kfree(usbtouch->buffer); 1425 } 1426 1427 static int usbtouch_probe(struct usb_interface *intf, 1428 const struct usb_device_id *id) 1429 { 1430 struct usbtouch_usb *usbtouch; 1431 struct input_dev *input_dev; 1432 struct usb_endpoint_descriptor *endpoint; 1433 struct usb_device *udev = interface_to_usbdev(intf); 1434 const struct usbtouch_device_info *type; 1435 int err; 1436 1437 /* some devices are ignored */ 1438 type = (const struct usbtouch_device_info *)id->driver_info; 1439 if (!type) 1440 return -ENODEV; 1441 1442 err = usb_find_int_in_endpoint(intf->cur_altsetting, &endpoint); 1443 if (err) { 1444 err = usb_find_bulk_in_endpoint(intf->cur_altsetting, &endpoint); 1445 if (err) 1446 return -ENXIO; 1447 } 1448 1449 err = -ENOMEM; 1450 usbtouch = kzalloc_obj(*usbtouch); 1451 input_dev = input_allocate_device(); 1452 if (!usbtouch || !input_dev) 1453 goto out_free; 1454 1455 mutex_init(&usbtouch->pm_mutex); 1456 usbtouch->type = type; 1457 1458 usbtouch->data_size = type->rept_size; 1459 if (type->get_pkt_len) { 1460 /* 1461 * When dealing with variable-length packets we should 1462 * not request more than wMaxPacketSize bytes at once 1463 * as we do not know if there is more data coming or 1464 * we filled exactly wMaxPacketSize bytes and there is 1465 * nothing else. 1466 */ 1467 usbtouch->data_size = min(usbtouch->data_size, 1468 usb_endpoint_maxp(endpoint)); 1469 } 1470 1471 usbtouch->data = usb_alloc_coherent(udev, usbtouch->data_size, 1472 GFP_KERNEL, &usbtouch->data_dma); 1473 if (!usbtouch->data) 1474 goto out_free; 1475 1476 if (type->get_pkt_len) { 1477 usbtouch->buffer = kmalloc(type->rept_size, GFP_KERNEL); 1478 if (!usbtouch->buffer) 1479 goto out_free_buffers; 1480 usbtouch->process_pkt = usbtouch_process_multi; 1481 } else { 1482 usbtouch->process_pkt = usbtouch_process_pkt; 1483 } 1484 1485 usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL); 1486 if (!usbtouch->irq) { 1487 dev_dbg(&intf->dev, 1488 "%s - usb_alloc_urb failed: usbtouch->irq\n", __func__); 1489 goto out_free_buffers; 1490 } 1491 1492 usbtouch->interface = intf; 1493 usbtouch->input = input_dev; 1494 1495 if (udev->manufacturer) 1496 strscpy(usbtouch->name, udev->manufacturer, sizeof(usbtouch->name)); 1497 1498 if (udev->product) { 1499 if (udev->manufacturer) 1500 strlcat(usbtouch->name, " ", sizeof(usbtouch->name)); 1501 strlcat(usbtouch->name, udev->product, sizeof(usbtouch->name)); 1502 } 1503 1504 if (!strlen(usbtouch->name)) 1505 snprintf(usbtouch->name, sizeof(usbtouch->name), 1506 "USB Touchscreen %04x:%04x", 1507 le16_to_cpu(udev->descriptor.idVendor), 1508 le16_to_cpu(udev->descriptor.idProduct)); 1509 1510 usb_make_path(udev, usbtouch->phys, sizeof(usbtouch->phys)); 1511 strlcat(usbtouch->phys, "/input0", sizeof(usbtouch->phys)); 1512 1513 input_dev->name = usbtouch->name; 1514 input_dev->phys = usbtouch->phys; 1515 usb_to_input_id(udev, &input_dev->id); 1516 input_dev->dev.parent = &intf->dev; 1517 1518 input_set_drvdata(input_dev, usbtouch); 1519 1520 input_dev->open = usbtouch_open; 1521 input_dev->close = usbtouch_close; 1522 1523 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 1524 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 1525 input_set_abs_params(input_dev, ABS_X, type->min_xc, type->max_xc, 0, 0); 1526 input_set_abs_params(input_dev, ABS_Y, type->min_yc, type->max_yc, 0, 0); 1527 if (type->max_press) 1528 input_set_abs_params(input_dev, ABS_PRESSURE, type->min_press, 1529 type->max_press, 0, 0); 1530 1531 if (usb_endpoint_type(endpoint) == USB_ENDPOINT_XFER_INT) 1532 usb_fill_int_urb(usbtouch->irq, udev, 1533 usb_rcvintpipe(udev, endpoint->bEndpointAddress), 1534 usbtouch->data, usbtouch->data_size, 1535 usbtouch_irq, usbtouch, endpoint->bInterval); 1536 else 1537 usb_fill_bulk_urb(usbtouch->irq, udev, 1538 usb_rcvbulkpipe(udev, endpoint->bEndpointAddress), 1539 usbtouch->data, usbtouch->data_size, 1540 usbtouch_irq, usbtouch); 1541 1542 usbtouch->irq->dev = udev; 1543 usbtouch->irq->transfer_dma = usbtouch->data_dma; 1544 usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1545 1546 /* device specific allocations */ 1547 if (type->alloc) { 1548 err = type->alloc(usbtouch); 1549 if (err) { 1550 dev_dbg(&intf->dev, 1551 "%s - type->alloc() failed, err: %d\n", 1552 __func__, err); 1553 goto out_free_urb; 1554 } 1555 } 1556 1557 /* device specific initialisation*/ 1558 if (type->init) { 1559 err = type->init(usbtouch); 1560 if (err) { 1561 dev_dbg(&intf->dev, 1562 "%s - type->init() failed, err: %d\n", 1563 __func__, err); 1564 goto out_do_exit; 1565 } 1566 } 1567 1568 err = input_register_device(usbtouch->input); 1569 if (err) { 1570 dev_dbg(&intf->dev, 1571 "%s - input_register_device failed, err: %d\n", 1572 __func__, err); 1573 goto out_do_exit; 1574 } 1575 1576 usb_set_intfdata(intf, usbtouch); 1577 1578 if (usbtouch->type->irq_always) { 1579 /* this can't fail */ 1580 usb_autopm_get_interface(intf); 1581 err = usb_submit_urb(usbtouch->irq, GFP_KERNEL); 1582 if (err) { 1583 usb_autopm_put_interface(intf); 1584 dev_err(&intf->dev, 1585 "%s - usb_submit_urb failed with result: %d\n", 1586 __func__, err); 1587 goto out_unregister_input; 1588 } 1589 } 1590 1591 return 0; 1592 1593 out_unregister_input: 1594 input_unregister_device(input_dev); 1595 input_dev = NULL; 1596 out_do_exit: 1597 if (type->exit) 1598 type->exit(usbtouch); 1599 out_free_urb: 1600 usb_free_urb(usbtouch->irq); 1601 out_free_buffers: 1602 usbtouch_free_buffers(udev, usbtouch); 1603 out_free: 1604 input_free_device(input_dev); 1605 kfree(usbtouch); 1606 return err; 1607 } 1608 1609 static void usbtouch_disconnect(struct usb_interface *intf) 1610 { 1611 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1612 1613 if (!usbtouch) 1614 return; 1615 1616 dev_dbg(&intf->dev, 1617 "%s - usbtouch is initialized, cleaning up\n", __func__); 1618 1619 usb_set_intfdata(intf, NULL); 1620 /* this will stop IO via close */ 1621 input_unregister_device(usbtouch->input); 1622 usb_free_urb(usbtouch->irq); 1623 if (usbtouch->type->exit) 1624 usbtouch->type->exit(usbtouch); 1625 usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch); 1626 kfree(usbtouch); 1627 } 1628 1629 static const struct attribute_group *usbtouch_groups[] = { 1630 #ifdef CONFIG_TOUCHSCREEN_USB_3M 1631 &mtouch_attr_group, 1632 #endif 1633 NULL 1634 }; 1635 1636 static const struct usb_device_id usbtouch_devices[] = { 1637 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX 1638 /* ignore the HID capable devices, handled by usbhid */ 1639 { USB_DEVICE_INTERFACE_CLASS(0x0eef, 0x0001, USB_INTERFACE_CLASS_HID), 1640 .driver_info = 0 }, 1641 { USB_DEVICE_INTERFACE_CLASS(0x0eef, 0x0002, USB_INTERFACE_CLASS_HID), 1642 .driver_info = 0 }, 1643 1644 /* normal device IDs */ 1645 { USB_DEVICE(0x3823, 0x0001), 1646 .driver_info = (kernel_ulong_t)&egalax_dev_info }, 1647 { USB_DEVICE(0x3823, 0x0002), 1648 .driver_info = (kernel_ulong_t)&egalax_dev_info }, 1649 { USB_DEVICE(0x0123, 0x0001), 1650 .driver_info = (kernel_ulong_t)&egalax_dev_info }, 1651 { USB_DEVICE(0x0eef, 0x0001), 1652 .driver_info = (kernel_ulong_t)&egalax_dev_info }, 1653 { USB_DEVICE(0x0eef, 0x0002), 1654 .driver_info = (kernel_ulong_t)&egalax_dev_info }, 1655 { USB_DEVICE(0x1234, 0x0001), 1656 .driver_info = (kernel_ulong_t)&egalax_dev_info }, 1657 { USB_DEVICE(0x1234, 0x0002), 1658 .driver_info = (kernel_ulong_t)&egalax_dev_info }, 1659 #endif 1660 1661 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT 1662 { USB_DEVICE(0x134c, 0x0001), 1663 .driver_info = (kernel_ulong_t)&panjit_dev_info }, 1664 { USB_DEVICE(0x134c, 0x0002), 1665 .driver_info = (kernel_ulong_t)&panjit_dev_info }, 1666 { USB_DEVICE(0x134c, 0x0003), 1667 .driver_info = (kernel_ulong_t)&panjit_dev_info }, 1668 { USB_DEVICE(0x134c, 0x0004), 1669 .driver_info = (kernel_ulong_t)&panjit_dev_info }, 1670 #endif 1671 1672 #ifdef CONFIG_TOUCHSCREEN_USB_3M 1673 { USB_DEVICE(0x0596, 0x0001), 1674 .driver_info = (kernel_ulong_t)&mtouch_dev_info }, 1675 #endif 1676 1677 #ifdef CONFIG_TOUCHSCREEN_USB_ITM 1678 { USB_DEVICE(0x0403, 0xf9e9), 1679 .driver_info = (kernel_ulong_t)&itm_dev_info }, 1680 { USB_DEVICE(0x16e3, 0xf9e9), 1681 .driver_info = (kernel_ulong_t)&itm_dev_info }, 1682 #endif 1683 1684 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO 1685 { USB_DEVICE(0x1234, 0x5678), 1686 .driver_info = (kernel_ulong_t)&eturbo_dev_info }, 1687 #endif 1688 1689 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE 1690 { USB_DEVICE(0x0637, 0x0001), 1691 .driver_info = (kernel_ulong_t)&gunze_dev_info }, 1692 #endif 1693 1694 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10 1695 { USB_DEVICE(0x0afa, 0x03e8), 1696 .driver_info = (kernel_ulong_t)&dmc_tsc10_dev_info }, 1697 #endif 1698 1699 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 1700 { USB_DEVICE(0x255e, 0x0001), 1701 .driver_info = (kernel_ulong_t)&irtouch_dev_info }, 1702 { USB_DEVICE(0x595a, 0x0001), 1703 .driver_info = (kernel_ulong_t)&irtouch_dev_info }, 1704 { USB_DEVICE(0x6615, 0x0001), 1705 .driver_info = (kernel_ulong_t)&irtouch_dev_info }, 1706 { USB_DEVICE(0x6615, 0x0012), 1707 .driver_info = (kernel_ulong_t)&irtouch_hires_dev_info }, 1708 #endif 1709 1710 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 1711 { USB_DEVICE(0x1391, 0x1000), 1712 .driver_info = (kernel_ulong_t)&idealtek_dev_info }, 1713 #endif 1714 1715 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 1716 { USB_DEVICE(0x0dfc, 0x0001), 1717 .driver_info = (kernel_ulong_t)&general_touch_dev_info }, 1718 #endif 1719 1720 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 1721 { USB_DEVICE(0x08f2, 0x007f), 1722 .driver_info = (kernel_ulong_t)&gotop_dev_info }, 1723 { USB_DEVICE(0x08f2, 0x00ce), 1724 .driver_info = (kernel_ulong_t)&gotop_dev_info }, 1725 { USB_DEVICE(0x08f2, 0x00f4), 1726 .driver_info = (kernel_ulong_t)&gotop_dev_info }, 1727 #endif 1728 1729 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC 1730 { USB_DEVICE(0x0f92, 0x0001), 1731 .driver_info = (kernel_ulong_t)&jastec_dev_info }, 1732 #endif 1733 1734 #ifdef CONFIG_TOUCHSCREEN_USB_E2I 1735 { USB_DEVICE(0x1ac7, 0x0001), 1736 .driver_info = (kernel_ulong_t)&e2i_dev_info }, 1737 #endif 1738 1739 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC 1740 { USB_DEVICE(0x14c8, 0x0003), 1741 .driver_info = (kernel_ulong_t)&zytronic_dev_info }, 1742 #endif 1743 1744 #ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB 1745 /* TC5UH */ 1746 { USB_DEVICE(0x0664, 0x0309), 1747 .driver_info = (kernel_ulong_t)&tc45usb_dev_info }, 1748 /* TC4UM */ 1749 { USB_DEVICE(0x0664, 0x0306), 1750 .driver_info = (kernel_ulong_t)&tc45usb_dev_info }, 1751 #endif 1752 1753 #ifdef CONFIG_TOUCHSCREEN_USB_NEXIO 1754 /* data interface only */ 1755 { USB_DEVICE_AND_INTERFACE_INFO(0x10f0, 0x2002, 0x0a, 0x00, 0x00), 1756 .driver_info = (kernel_ulong_t)&nexio_dev_info }, 1757 { USB_DEVICE_AND_INTERFACE_INFO(0x1870, 0x0001, 0x0a, 0x00, 0x00), 1758 .driver_info = (kernel_ulong_t)&nexio_dev_info }, 1759 #endif 1760 1761 #ifdef CONFIG_TOUCHSCREEN_USB_ELO 1762 { USB_DEVICE(0x04e7, 0x0020), 1763 .driver_info = (kernel_ulong_t)&elo_dev_info }, 1764 #endif 1765 1766 #ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH 1767 { USB_DEVICE(0x7374, 0x0001), 1768 .driver_info = (kernel_ulong_t)&etouch_dev_info }, 1769 #endif 1770 1771 { } 1772 }; 1773 MODULE_DEVICE_TABLE(usb, usbtouch_devices); 1774 1775 static struct usb_driver usbtouch_driver = { 1776 .name = "usbtouchscreen", 1777 .probe = usbtouch_probe, 1778 .disconnect = usbtouch_disconnect, 1779 .suspend = usbtouch_suspend, 1780 .resume = usbtouch_resume, 1781 .reset_resume = usbtouch_reset_resume, 1782 .id_table = usbtouch_devices, 1783 .dev_groups = usbtouch_groups, 1784 .supports_autosuspend = 1, 1785 }; 1786 1787 module_usb_driver(usbtouch_driver); 1788 1789 MODULE_AUTHOR("Daniel Ritz <daniel.ritz@gmx.ch>"); 1790 MODULE_DESCRIPTION("USB Touchscreen Driver"); 1791 MODULE_LICENSE("GPL"); 1792 1793 MODULE_ALIAS("touchkitusb"); 1794 MODULE_ALIAS("itmtouch"); 1795 MODULE_ALIAS("mtouchusb"); 1796