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