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_rcvctrlpipe(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 scnprintf(output, PAGE_SIZE, "%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_rcvctrlpipe(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_rcvctrlpipe(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_rcvctrlpipe (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 nexio_touch_packet *packet = (void *) pkt; 1048 struct nexio_priv *priv = usbtouch->priv; 1049 unsigned int data_len = be16_to_cpu(packet->data_len); 1050 unsigned int x_len = be16_to_cpu(packet->x_len); 1051 unsigned int y_len = be16_to_cpu(packet->y_len); 1052 int x, y, begin_x, begin_y, end_x, end_y, w, h, ret; 1053 1054 /* got touch data? */ 1055 if ((pkt[0] & 0xe0) != 0xe0) 1056 return 0; 1057 1058 if (data_len > 0xff) 1059 data_len -= 0x100; 1060 if (x_len > 0xff) 1061 x_len -= 0x80; 1062 1063 /* send ACK */ 1064 ret = usb_submit_urb(priv->ack, GFP_ATOMIC); 1065 1066 if (!usbtouch->type->max_xc) { 1067 usbtouch->type->max_xc = 2 * x_len; 1068 input_set_abs_params(usbtouch->input, ABS_X, 1069 0, usbtouch->type->max_xc, 0, 0); 1070 usbtouch->type->max_yc = 2 * y_len; 1071 input_set_abs_params(usbtouch->input, ABS_Y, 1072 0, usbtouch->type->max_yc, 0, 0); 1073 } 1074 /* 1075 * The device reports state of IR sensors on X and Y axes. 1076 * Each byte represents "darkness" percentage (0-100) of one element. 1077 * 17" touchscreen reports only 64 x 52 bytes so the resolution is low. 1078 * This also means that there's a limited multi-touch capability but 1079 * it's disabled (and untested) here as there's no X driver for that. 1080 */ 1081 begin_x = end_x = begin_y = end_y = -1; 1082 for (x = 0; x < x_len; x++) { 1083 if (begin_x == -1 && packet->data[x] > NEXIO_THRESHOLD) { 1084 begin_x = x; 1085 continue; 1086 } 1087 if (end_x == -1 && begin_x != -1 && packet->data[x] < NEXIO_THRESHOLD) { 1088 end_x = x - 1; 1089 for (y = x_len; y < data_len; y++) { 1090 if (begin_y == -1 && packet->data[y] > NEXIO_THRESHOLD) { 1091 begin_y = y - x_len; 1092 continue; 1093 } 1094 if (end_y == -1 && 1095 begin_y != -1 && packet->data[y] < NEXIO_THRESHOLD) { 1096 end_y = y - 1 - x_len; 1097 w = end_x - begin_x; 1098 h = end_y - begin_y; 1099 #if 0 1100 /* multi-touch */ 1101 input_report_abs(usbtouch->input, 1102 ABS_MT_TOUCH_MAJOR, max(w,h)); 1103 input_report_abs(usbtouch->input, 1104 ABS_MT_TOUCH_MINOR, min(x,h)); 1105 input_report_abs(usbtouch->input, 1106 ABS_MT_POSITION_X, 2*begin_x+w); 1107 input_report_abs(usbtouch->input, 1108 ABS_MT_POSITION_Y, 2*begin_y+h); 1109 input_report_abs(usbtouch->input, 1110 ABS_MT_ORIENTATION, w > h); 1111 input_mt_sync(usbtouch->input); 1112 #endif 1113 /* single touch */ 1114 usbtouch->x = 2 * begin_x + w; 1115 usbtouch->y = 2 * begin_y + h; 1116 usbtouch->touch = packet->flags & 0x01; 1117 begin_y = end_y = -1; 1118 return 1; 1119 } 1120 } 1121 begin_x = end_x = -1; 1122 } 1123 1124 } 1125 return 0; 1126 } 1127 #endif 1128 1129 1130 /***************************************************************************** 1131 * ELO part 1132 */ 1133 1134 #ifdef CONFIG_TOUCHSCREEN_USB_ELO 1135 1136 static int elo_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 1137 { 1138 dev->x = (pkt[3] << 8) | pkt[2]; 1139 dev->y = (pkt[5] << 8) | pkt[4]; 1140 dev->touch = pkt[6] > 0; 1141 dev->press = pkt[6]; 1142 1143 return 1; 1144 } 1145 #endif 1146 1147 1148 /***************************************************************************** 1149 * the different device descriptors 1150 */ 1151 #ifdef MULTI_PACKET 1152 static void usbtouch_process_multi(struct usbtouch_usb *usbtouch, 1153 unsigned char *pkt, int len); 1154 #endif 1155 1156 static struct usbtouch_device_info usbtouch_dev_info[] = { 1157 #ifdef CONFIG_TOUCHSCREEN_USB_ELO 1158 [DEVTYPE_ELO] = { 1159 .min_xc = 0x0, 1160 .max_xc = 0x0fff, 1161 .min_yc = 0x0, 1162 .max_yc = 0x0fff, 1163 .max_press = 0xff, 1164 .rept_size = 8, 1165 .read_data = elo_read_data, 1166 }, 1167 #endif 1168 1169 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX 1170 [DEVTYPE_EGALAX] = { 1171 .min_xc = 0x0, 1172 .max_xc = 0x07ff, 1173 .min_yc = 0x0, 1174 .max_yc = 0x07ff, 1175 .rept_size = 16, 1176 .process_pkt = usbtouch_process_multi, 1177 .get_pkt_len = egalax_get_pkt_len, 1178 .read_data = egalax_read_data, 1179 .init = egalax_init, 1180 }, 1181 #endif 1182 1183 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT 1184 [DEVTYPE_PANJIT] = { 1185 .min_xc = 0x0, 1186 .max_xc = 0x0fff, 1187 .min_yc = 0x0, 1188 .max_yc = 0x0fff, 1189 .rept_size = 8, 1190 .read_data = panjit_read_data, 1191 }, 1192 #endif 1193 1194 #ifdef CONFIG_TOUCHSCREEN_USB_3M 1195 [DEVTYPE_3M] = { 1196 .min_xc = 0x0, 1197 .max_xc = 0x4000, 1198 .min_yc = 0x0, 1199 .max_yc = 0x4000, 1200 .rept_size = 11, 1201 .read_data = mtouch_read_data, 1202 .alloc = mtouch_alloc, 1203 .init = mtouch_init, 1204 .exit = mtouch_exit, 1205 }, 1206 #endif 1207 1208 #ifdef CONFIG_TOUCHSCREEN_USB_ITM 1209 [DEVTYPE_ITM] = { 1210 .min_xc = 0x0, 1211 .max_xc = 0x0fff, 1212 .min_yc = 0x0, 1213 .max_yc = 0x0fff, 1214 .max_press = 0xff, 1215 .rept_size = 8, 1216 .read_data = itm_read_data, 1217 }, 1218 #endif 1219 1220 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO 1221 [DEVTYPE_ETURBO] = { 1222 .min_xc = 0x0, 1223 .max_xc = 0x07ff, 1224 .min_yc = 0x0, 1225 .max_yc = 0x07ff, 1226 .rept_size = 8, 1227 .process_pkt = usbtouch_process_multi, 1228 .get_pkt_len = eturbo_get_pkt_len, 1229 .read_data = eturbo_read_data, 1230 }, 1231 #endif 1232 1233 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE 1234 [DEVTYPE_GUNZE] = { 1235 .min_xc = 0x0, 1236 .max_xc = 0x0fff, 1237 .min_yc = 0x0, 1238 .max_yc = 0x0fff, 1239 .rept_size = 4, 1240 .read_data = gunze_read_data, 1241 }, 1242 #endif 1243 1244 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10 1245 [DEVTYPE_DMC_TSC10] = { 1246 .min_xc = 0x0, 1247 .max_xc = 0x03ff, 1248 .min_yc = 0x0, 1249 .max_yc = 0x03ff, 1250 .rept_size = 5, 1251 .init = dmc_tsc10_init, 1252 .read_data = dmc_tsc10_read_data, 1253 }, 1254 #endif 1255 1256 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 1257 [DEVTYPE_IRTOUCH] = { 1258 .min_xc = 0x0, 1259 .max_xc = 0x0fff, 1260 .min_yc = 0x0, 1261 .max_yc = 0x0fff, 1262 .rept_size = 8, 1263 .read_data = irtouch_read_data, 1264 }, 1265 1266 [DEVTYPE_IRTOUCH_HIRES] = { 1267 .min_xc = 0x0, 1268 .max_xc = 0x7fff, 1269 .min_yc = 0x0, 1270 .max_yc = 0x7fff, 1271 .rept_size = 8, 1272 .read_data = irtouch_read_data, 1273 }, 1274 #endif 1275 1276 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 1277 [DEVTYPE_IDEALTEK] = { 1278 .min_xc = 0x0, 1279 .max_xc = 0x0fff, 1280 .min_yc = 0x0, 1281 .max_yc = 0x0fff, 1282 .rept_size = 8, 1283 .process_pkt = usbtouch_process_multi, 1284 .get_pkt_len = idealtek_get_pkt_len, 1285 .read_data = idealtek_read_data, 1286 }, 1287 #endif 1288 1289 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 1290 [DEVTYPE_GENERAL_TOUCH] = { 1291 .min_xc = 0x0, 1292 .max_xc = 0x7fff, 1293 .min_yc = 0x0, 1294 .max_yc = 0x7fff, 1295 .rept_size = 7, 1296 .read_data = general_touch_read_data, 1297 }, 1298 #endif 1299 1300 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 1301 [DEVTYPE_GOTOP] = { 1302 .min_xc = 0x0, 1303 .max_xc = 0x03ff, 1304 .min_yc = 0x0, 1305 .max_yc = 0x03ff, 1306 .rept_size = 4, 1307 .read_data = gotop_read_data, 1308 }, 1309 #endif 1310 1311 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC 1312 [DEVTYPE_JASTEC] = { 1313 .min_xc = 0x0, 1314 .max_xc = 0x0fff, 1315 .min_yc = 0x0, 1316 .max_yc = 0x0fff, 1317 .rept_size = 4, 1318 .read_data = jastec_read_data, 1319 }, 1320 #endif 1321 1322 #ifdef CONFIG_TOUCHSCREEN_USB_E2I 1323 [DEVTYPE_E2I] = { 1324 .min_xc = 0x0, 1325 .max_xc = 0x7fff, 1326 .min_yc = 0x0, 1327 .max_yc = 0x7fff, 1328 .rept_size = 6, 1329 .init = e2i_init, 1330 .read_data = e2i_read_data, 1331 }, 1332 #endif 1333 1334 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC 1335 [DEVTYPE_ZYTRONIC] = { 1336 .min_xc = 0x0, 1337 .max_xc = 0x03ff, 1338 .min_yc = 0x0, 1339 .max_yc = 0x03ff, 1340 .rept_size = 5, 1341 .read_data = zytronic_read_data, 1342 .irq_always = true, 1343 }, 1344 #endif 1345 1346 #ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB 1347 [DEVTYPE_TC45USB] = { 1348 .min_xc = 0x0, 1349 .max_xc = 0x0fff, 1350 .min_yc = 0x0, 1351 .max_yc = 0x0fff, 1352 .rept_size = 5, 1353 .read_data = tc45usb_read_data, 1354 }, 1355 #endif 1356 1357 #ifdef CONFIG_TOUCHSCREEN_USB_NEXIO 1358 [DEVTYPE_NEXIO] = { 1359 .rept_size = 1024, 1360 .irq_always = true, 1361 .read_data = nexio_read_data, 1362 .alloc = nexio_alloc, 1363 .init = nexio_init, 1364 .exit = nexio_exit, 1365 }, 1366 #endif 1367 #ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH 1368 [DEVTYPE_ETOUCH] = { 1369 .min_xc = 0x0, 1370 .max_xc = 0x07ff, 1371 .min_yc = 0x0, 1372 .max_yc = 0x07ff, 1373 .rept_size = 16, 1374 .process_pkt = usbtouch_process_multi, 1375 .get_pkt_len = etouch_get_pkt_len, 1376 .read_data = etouch_read_data, 1377 }, 1378 #endif 1379 }; 1380 1381 1382 /***************************************************************************** 1383 * Generic Part 1384 */ 1385 static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch, 1386 unsigned char *pkt, int len) 1387 { 1388 struct usbtouch_device_info *type = usbtouch->type; 1389 1390 if (!type->read_data(usbtouch, pkt)) 1391 return; 1392 1393 input_report_key(usbtouch->input, BTN_TOUCH, usbtouch->touch); 1394 1395 if (swap_xy) { 1396 input_report_abs(usbtouch->input, ABS_X, usbtouch->y); 1397 input_report_abs(usbtouch->input, ABS_Y, usbtouch->x); 1398 } else { 1399 input_report_abs(usbtouch->input, ABS_X, usbtouch->x); 1400 input_report_abs(usbtouch->input, ABS_Y, usbtouch->y); 1401 } 1402 if (type->max_press) 1403 input_report_abs(usbtouch->input, ABS_PRESSURE, usbtouch->press); 1404 input_sync(usbtouch->input); 1405 } 1406 1407 1408 #ifdef MULTI_PACKET 1409 static void usbtouch_process_multi(struct usbtouch_usb *usbtouch, 1410 unsigned char *pkt, int len) 1411 { 1412 unsigned char *buffer; 1413 int pkt_len, pos, buf_len, tmp; 1414 1415 /* process buffer */ 1416 if (unlikely(usbtouch->buf_len)) { 1417 /* try to get size */ 1418 pkt_len = usbtouch->type->get_pkt_len( 1419 usbtouch->buffer, usbtouch->buf_len); 1420 1421 /* drop? */ 1422 if (unlikely(!pkt_len)) 1423 goto out_flush_buf; 1424 1425 /* need to append -pkt_len bytes before able to get size */ 1426 if (unlikely(pkt_len < 0)) { 1427 int append = -pkt_len; 1428 if (unlikely(append > len)) 1429 append = len; 1430 if (usbtouch->buf_len + append >= usbtouch->type->rept_size) 1431 goto out_flush_buf; 1432 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, append); 1433 usbtouch->buf_len += append; 1434 1435 pkt_len = usbtouch->type->get_pkt_len( 1436 usbtouch->buffer, usbtouch->buf_len); 1437 if (pkt_len < 0) 1438 return; 1439 } 1440 1441 /* append */ 1442 tmp = pkt_len - usbtouch->buf_len; 1443 if (usbtouch->buf_len + tmp >= usbtouch->type->rept_size) 1444 goto out_flush_buf; 1445 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, tmp); 1446 usbtouch_process_pkt(usbtouch, usbtouch->buffer, pkt_len); 1447 1448 buffer = pkt + tmp; 1449 buf_len = len - tmp; 1450 } else { 1451 buffer = pkt; 1452 buf_len = len; 1453 } 1454 1455 /* loop over the received packet, process */ 1456 pos = 0; 1457 while (pos < buf_len) { 1458 /* get packet len */ 1459 pkt_len = usbtouch->type->get_pkt_len(buffer + pos, 1460 buf_len - pos); 1461 1462 /* unknown packet: skip one byte */ 1463 if (unlikely(!pkt_len)) { 1464 pos++; 1465 continue; 1466 } 1467 1468 /* full packet: process */ 1469 if (likely((pkt_len > 0) && (pkt_len <= buf_len - pos))) { 1470 usbtouch_process_pkt(usbtouch, buffer + pos, pkt_len); 1471 } else { 1472 /* incomplete packet: save in buffer */ 1473 memcpy(usbtouch->buffer, buffer + pos, buf_len - pos); 1474 usbtouch->buf_len = buf_len - pos; 1475 return; 1476 } 1477 pos += pkt_len; 1478 } 1479 1480 out_flush_buf: 1481 usbtouch->buf_len = 0; 1482 return; 1483 } 1484 #endif 1485 1486 1487 static void usbtouch_irq(struct urb *urb) 1488 { 1489 struct usbtouch_usb *usbtouch = urb->context; 1490 struct device *dev = &usbtouch->interface->dev; 1491 int retval; 1492 1493 switch (urb->status) { 1494 case 0: 1495 /* success */ 1496 break; 1497 case -ETIME: 1498 /* this urb is timing out */ 1499 dev_dbg(dev, 1500 "%s - urb timed out - was the device unplugged?\n", 1501 __func__); 1502 return; 1503 case -ECONNRESET: 1504 case -ENOENT: 1505 case -ESHUTDOWN: 1506 case -EPIPE: 1507 /* this urb is terminated, clean up */ 1508 dev_dbg(dev, "%s - urb shutting down with status: %d\n", 1509 __func__, urb->status); 1510 return; 1511 default: 1512 dev_dbg(dev, "%s - nonzero urb status received: %d\n", 1513 __func__, urb->status); 1514 goto exit; 1515 } 1516 1517 usbtouch->type->process_pkt(usbtouch, usbtouch->data, urb->actual_length); 1518 1519 exit: 1520 usb_mark_last_busy(interface_to_usbdev(usbtouch->interface)); 1521 retval = usb_submit_urb(urb, GFP_ATOMIC); 1522 if (retval) 1523 dev_err(dev, "%s - usb_submit_urb failed with result: %d\n", 1524 __func__, retval); 1525 } 1526 1527 static int usbtouch_open(struct input_dev *input) 1528 { 1529 struct usbtouch_usb *usbtouch = input_get_drvdata(input); 1530 int r; 1531 1532 usbtouch->irq->dev = interface_to_usbdev(usbtouch->interface); 1533 1534 r = usb_autopm_get_interface(usbtouch->interface) ? -EIO : 0; 1535 if (r < 0) 1536 goto out; 1537 1538 mutex_lock(&usbtouch->pm_mutex); 1539 if (!usbtouch->type->irq_always) { 1540 if (usb_submit_urb(usbtouch->irq, GFP_KERNEL)) { 1541 r = -EIO; 1542 goto out_put; 1543 } 1544 } 1545 1546 usbtouch->interface->needs_remote_wakeup = 1; 1547 usbtouch->is_open = true; 1548 out_put: 1549 mutex_unlock(&usbtouch->pm_mutex); 1550 usb_autopm_put_interface(usbtouch->interface); 1551 out: 1552 return r; 1553 } 1554 1555 static void usbtouch_close(struct input_dev *input) 1556 { 1557 struct usbtouch_usb *usbtouch = input_get_drvdata(input); 1558 int r; 1559 1560 mutex_lock(&usbtouch->pm_mutex); 1561 if (!usbtouch->type->irq_always) 1562 usb_kill_urb(usbtouch->irq); 1563 usbtouch->is_open = false; 1564 mutex_unlock(&usbtouch->pm_mutex); 1565 1566 r = usb_autopm_get_interface(usbtouch->interface); 1567 usbtouch->interface->needs_remote_wakeup = 0; 1568 if (!r) 1569 usb_autopm_put_interface(usbtouch->interface); 1570 } 1571 1572 static int usbtouch_suspend 1573 (struct usb_interface *intf, pm_message_t message) 1574 { 1575 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1576 1577 usb_kill_urb(usbtouch->irq); 1578 1579 return 0; 1580 } 1581 1582 static int usbtouch_resume(struct usb_interface *intf) 1583 { 1584 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1585 int result = 0; 1586 1587 mutex_lock(&usbtouch->pm_mutex); 1588 if (usbtouch->is_open || usbtouch->type->irq_always) 1589 result = usb_submit_urb(usbtouch->irq, GFP_NOIO); 1590 mutex_unlock(&usbtouch->pm_mutex); 1591 1592 return result; 1593 } 1594 1595 static int usbtouch_reset_resume(struct usb_interface *intf) 1596 { 1597 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1598 int err = 0; 1599 1600 /* reinit the device */ 1601 if (usbtouch->type->init) { 1602 err = usbtouch->type->init(usbtouch); 1603 if (err) { 1604 dev_dbg(&intf->dev, 1605 "%s - type->init() failed, err: %d\n", 1606 __func__, err); 1607 return err; 1608 } 1609 } 1610 1611 /* restart IO if needed */ 1612 mutex_lock(&usbtouch->pm_mutex); 1613 if (usbtouch->is_open) 1614 err = usb_submit_urb(usbtouch->irq, GFP_NOIO); 1615 mutex_unlock(&usbtouch->pm_mutex); 1616 1617 return err; 1618 } 1619 1620 static void usbtouch_free_buffers(struct usb_device *udev, 1621 struct usbtouch_usb *usbtouch) 1622 { 1623 usb_free_coherent(udev, usbtouch->data_size, 1624 usbtouch->data, usbtouch->data_dma); 1625 kfree(usbtouch->buffer); 1626 } 1627 1628 static struct usb_endpoint_descriptor * 1629 usbtouch_get_input_endpoint(struct usb_host_interface *interface) 1630 { 1631 int i; 1632 1633 for (i = 0; i < interface->desc.bNumEndpoints; i++) 1634 if (usb_endpoint_dir_in(&interface->endpoint[i].desc)) 1635 return &interface->endpoint[i].desc; 1636 1637 return NULL; 1638 } 1639 1640 static int usbtouch_probe(struct usb_interface *intf, 1641 const struct usb_device_id *id) 1642 { 1643 struct usbtouch_usb *usbtouch; 1644 struct input_dev *input_dev; 1645 struct usb_endpoint_descriptor *endpoint; 1646 struct usb_device *udev = interface_to_usbdev(intf); 1647 struct usbtouch_device_info *type; 1648 int err = -ENOMEM; 1649 1650 /* some devices are ignored */ 1651 if (id->driver_info == DEVTYPE_IGNORE) 1652 return -ENODEV; 1653 1654 endpoint = usbtouch_get_input_endpoint(intf->cur_altsetting); 1655 if (!endpoint) 1656 return -ENXIO; 1657 1658 usbtouch = kzalloc(sizeof(struct usbtouch_usb), GFP_KERNEL); 1659 input_dev = input_allocate_device(); 1660 if (!usbtouch || !input_dev) 1661 goto out_free; 1662 1663 mutex_init(&usbtouch->pm_mutex); 1664 1665 type = &usbtouch_dev_info[id->driver_info]; 1666 usbtouch->type = type; 1667 if (!type->process_pkt) 1668 type->process_pkt = usbtouch_process_pkt; 1669 1670 usbtouch->data_size = type->rept_size; 1671 if (type->get_pkt_len) { 1672 /* 1673 * When dealing with variable-length packets we should 1674 * not request more than wMaxPacketSize bytes at once 1675 * as we do not know if there is more data coming or 1676 * we filled exactly wMaxPacketSize bytes and there is 1677 * nothing else. 1678 */ 1679 usbtouch->data_size = min(usbtouch->data_size, 1680 usb_endpoint_maxp(endpoint)); 1681 } 1682 1683 usbtouch->data = usb_alloc_coherent(udev, usbtouch->data_size, 1684 GFP_KERNEL, &usbtouch->data_dma); 1685 if (!usbtouch->data) 1686 goto out_free; 1687 1688 if (type->get_pkt_len) { 1689 usbtouch->buffer = kmalloc(type->rept_size, GFP_KERNEL); 1690 if (!usbtouch->buffer) 1691 goto out_free_buffers; 1692 } 1693 1694 usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL); 1695 if (!usbtouch->irq) { 1696 dev_dbg(&intf->dev, 1697 "%s - usb_alloc_urb failed: usbtouch->irq\n", __func__); 1698 goto out_free_buffers; 1699 } 1700 1701 usbtouch->interface = intf; 1702 usbtouch->input = input_dev; 1703 1704 if (udev->manufacturer) 1705 strlcpy(usbtouch->name, udev->manufacturer, sizeof(usbtouch->name)); 1706 1707 if (udev->product) { 1708 if (udev->manufacturer) 1709 strlcat(usbtouch->name, " ", sizeof(usbtouch->name)); 1710 strlcat(usbtouch->name, udev->product, sizeof(usbtouch->name)); 1711 } 1712 1713 if (!strlen(usbtouch->name)) 1714 snprintf(usbtouch->name, sizeof(usbtouch->name), 1715 "USB Touchscreen %04x:%04x", 1716 le16_to_cpu(udev->descriptor.idVendor), 1717 le16_to_cpu(udev->descriptor.idProduct)); 1718 1719 usb_make_path(udev, usbtouch->phys, sizeof(usbtouch->phys)); 1720 strlcat(usbtouch->phys, "/input0", sizeof(usbtouch->phys)); 1721 1722 input_dev->name = usbtouch->name; 1723 input_dev->phys = usbtouch->phys; 1724 usb_to_input_id(udev, &input_dev->id); 1725 input_dev->dev.parent = &intf->dev; 1726 1727 input_set_drvdata(input_dev, usbtouch); 1728 1729 input_dev->open = usbtouch_open; 1730 input_dev->close = usbtouch_close; 1731 1732 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 1733 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 1734 input_set_abs_params(input_dev, ABS_X, type->min_xc, type->max_xc, 0, 0); 1735 input_set_abs_params(input_dev, ABS_Y, type->min_yc, type->max_yc, 0, 0); 1736 if (type->max_press) 1737 input_set_abs_params(input_dev, ABS_PRESSURE, type->min_press, 1738 type->max_press, 0, 0); 1739 1740 if (usb_endpoint_type(endpoint) == USB_ENDPOINT_XFER_INT) 1741 usb_fill_int_urb(usbtouch->irq, udev, 1742 usb_rcvintpipe(udev, endpoint->bEndpointAddress), 1743 usbtouch->data, usbtouch->data_size, 1744 usbtouch_irq, usbtouch, endpoint->bInterval); 1745 else 1746 usb_fill_bulk_urb(usbtouch->irq, udev, 1747 usb_rcvbulkpipe(udev, endpoint->bEndpointAddress), 1748 usbtouch->data, usbtouch->data_size, 1749 usbtouch_irq, usbtouch); 1750 1751 usbtouch->irq->dev = udev; 1752 usbtouch->irq->transfer_dma = usbtouch->data_dma; 1753 usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1754 1755 /* device specific allocations */ 1756 if (type->alloc) { 1757 err = type->alloc(usbtouch); 1758 if (err) { 1759 dev_dbg(&intf->dev, 1760 "%s - type->alloc() failed, err: %d\n", 1761 __func__, err); 1762 goto out_free_urb; 1763 } 1764 } 1765 1766 /* device specific initialisation*/ 1767 if (type->init) { 1768 err = type->init(usbtouch); 1769 if (err) { 1770 dev_dbg(&intf->dev, 1771 "%s - type->init() failed, err: %d\n", 1772 __func__, err); 1773 goto out_do_exit; 1774 } 1775 } 1776 1777 err = input_register_device(usbtouch->input); 1778 if (err) { 1779 dev_dbg(&intf->dev, 1780 "%s - input_register_device failed, err: %d\n", 1781 __func__, err); 1782 goto out_do_exit; 1783 } 1784 1785 usb_set_intfdata(intf, usbtouch); 1786 1787 if (usbtouch->type->irq_always) { 1788 /* this can't fail */ 1789 usb_autopm_get_interface(intf); 1790 err = usb_submit_urb(usbtouch->irq, GFP_KERNEL); 1791 if (err) { 1792 usb_autopm_put_interface(intf); 1793 dev_err(&intf->dev, 1794 "%s - usb_submit_urb failed with result: %d\n", 1795 __func__, err); 1796 goto out_unregister_input; 1797 } 1798 } 1799 1800 return 0; 1801 1802 out_unregister_input: 1803 input_unregister_device(input_dev); 1804 input_dev = NULL; 1805 out_do_exit: 1806 if (type->exit) 1807 type->exit(usbtouch); 1808 out_free_urb: 1809 usb_free_urb(usbtouch->irq); 1810 out_free_buffers: 1811 usbtouch_free_buffers(udev, usbtouch); 1812 out_free: 1813 input_free_device(input_dev); 1814 kfree(usbtouch); 1815 return err; 1816 } 1817 1818 static void usbtouch_disconnect(struct usb_interface *intf) 1819 { 1820 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1821 1822 if (!usbtouch) 1823 return; 1824 1825 dev_dbg(&intf->dev, 1826 "%s - usbtouch is initialized, cleaning up\n", __func__); 1827 1828 usb_set_intfdata(intf, NULL); 1829 /* this will stop IO via close */ 1830 input_unregister_device(usbtouch->input); 1831 usb_free_urb(usbtouch->irq); 1832 if (usbtouch->type->exit) 1833 usbtouch->type->exit(usbtouch); 1834 usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch); 1835 kfree(usbtouch); 1836 } 1837 1838 MODULE_DEVICE_TABLE(usb, usbtouch_devices); 1839 1840 static struct usb_driver usbtouch_driver = { 1841 .name = "usbtouchscreen", 1842 .probe = usbtouch_probe, 1843 .disconnect = usbtouch_disconnect, 1844 .suspend = usbtouch_suspend, 1845 .resume = usbtouch_resume, 1846 .reset_resume = usbtouch_reset_resume, 1847 .id_table = usbtouch_devices, 1848 .supports_autosuspend = 1, 1849 }; 1850 1851 module_usb_driver(usbtouch_driver); 1852 1853 MODULE_AUTHOR("Daniel Ritz <daniel.ritz@gmx.ch>"); 1854 MODULE_DESCRIPTION("USB Touchscreen Driver"); 1855 MODULE_LICENSE("GPL"); 1856 1857 MODULE_ALIAS("touchkitusb"); 1858 MODULE_ALIAS("itmtouch"); 1859 MODULE_ALIAS("mtouchusb"); 1860