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