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