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