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 * 18 * Copyright (C) 2004-2007 by Daniel Ritz <daniel.ritz@gmx.ch> 19 * Copyright (C) by Todd E. Johnson (mtouchusb.c) 20 * 21 * This program is free software; you can redistribute it and/or 22 * modify it under the terms of the GNU General Public License as 23 * published by the Free Software Foundation; either version 2 of the 24 * License, or (at your option) any later version. 25 * 26 * This program is distributed in the hope that it will be useful, but 27 * WITHOUT ANY WARRANTY; without even the implied warranty of 28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 29 * General Public License for more details. 30 * 31 * You should have received a copy of the GNU General Public License 32 * along with this program; if not, write to the Free Software 33 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 34 * 35 * Driver is based on touchkitusb.c 36 * - ITM parts are from itmtouch.c 37 * - 3M parts are from mtouchusb.c 38 * - PanJit parts are from an unmerged driver by Lanslott Gish 39 * - DMC TSC 10/25 are from Holger Schurig, with ideas from an unmerged 40 * driver from Marius Vollmer 41 * 42 *****************************************************************************/ 43 44 //#define DEBUG 45 46 #include <linux/kernel.h> 47 #include <linux/slab.h> 48 #include <linux/input.h> 49 #include <linux/module.h> 50 #include <linux/init.h> 51 #include <linux/usb.h> 52 #include <linux/usb/input.h> 53 #include <linux/hid.h> 54 55 56 #define DRIVER_VERSION "v0.6" 57 #define DRIVER_AUTHOR "Daniel Ritz <daniel.ritz@gmx.ch>" 58 #define DRIVER_DESC "USB Touchscreen Driver" 59 60 static int swap_xy; 61 module_param(swap_xy, bool, 0644); 62 MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped."); 63 64 static int hwcalib_xy; 65 module_param(hwcalib_xy, bool, 0644); 66 MODULE_PARM_DESC(hwcalib_xy, "If set hw-calibrated X/Y are used if available"); 67 68 /* device specifc data/functions */ 69 struct usbtouch_usb; 70 struct usbtouch_device_info { 71 int min_xc, max_xc; 72 int min_yc, max_yc; 73 int min_press, max_press; 74 int rept_size; 75 76 void (*process_pkt) (struct usbtouch_usb *usbtouch, unsigned char *pkt, int len); 77 78 /* 79 * used to get the packet len. possible return values: 80 * > 0: packet len 81 * = 0: skip one byte 82 * < 0: -return value more bytes needed 83 */ 84 int (*get_pkt_len) (unsigned char *pkt, int len); 85 86 int (*read_data) (struct usbtouch_usb *usbtouch, unsigned char *pkt); 87 int (*init) (struct usbtouch_usb *usbtouch); 88 }; 89 90 /* a usbtouch device */ 91 struct usbtouch_usb { 92 unsigned char *data; 93 dma_addr_t data_dma; 94 unsigned char *buffer; 95 int buf_len; 96 struct urb *irq; 97 struct usb_device *udev; 98 struct input_dev *input; 99 struct usbtouch_device_info *type; 100 char name[128]; 101 char phys[64]; 102 103 int x, y; 104 int touch, press; 105 }; 106 107 108 /* device types */ 109 enum { 110 DEVTYPE_IGNORE = -1, 111 DEVTYPE_EGALAX, 112 DEVTYPE_PANJIT, 113 DEVTYPE_3M, 114 DEVTYPE_ITM, 115 DEVTYPE_ETURBO, 116 DEVTYPE_GUNZE, 117 DEVTYPE_DMC_TSC10, 118 DEVTYPE_IRTOUCH, 119 DEVTYPE_IDEALTEK, 120 DEVTYPE_GENERAL_TOUCH, 121 DEVTYPE_GOTOP, 122 DEVTYPE_JASTEC, 123 }; 124 125 #define USB_DEVICE_HID_CLASS(vend, prod) \ 126 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS \ 127 | USB_DEVICE_ID_MATCH_INT_PROTOCOL \ 128 | USB_DEVICE_ID_MATCH_DEVICE, \ 129 .idVendor = (vend), \ 130 .idProduct = (prod), \ 131 .bInterfaceClass = USB_INTERFACE_CLASS_HID, \ 132 .bInterfaceProtocol = USB_INTERFACE_PROTOCOL_MOUSE 133 134 static struct usb_device_id usbtouch_devices[] = { 135 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX 136 /* ignore the HID capable devices, handled by usbhid */ 137 {USB_DEVICE_HID_CLASS(0x0eef, 0x0001), .driver_info = DEVTYPE_IGNORE}, 138 {USB_DEVICE_HID_CLASS(0x0eef, 0x0002), .driver_info = DEVTYPE_IGNORE}, 139 140 /* normal device IDs */ 141 {USB_DEVICE(0x3823, 0x0001), .driver_info = DEVTYPE_EGALAX}, 142 {USB_DEVICE(0x3823, 0x0002), .driver_info = DEVTYPE_EGALAX}, 143 {USB_DEVICE(0x0123, 0x0001), .driver_info = DEVTYPE_EGALAX}, 144 {USB_DEVICE(0x0eef, 0x0001), .driver_info = DEVTYPE_EGALAX}, 145 {USB_DEVICE(0x0eef, 0x0002), .driver_info = DEVTYPE_EGALAX}, 146 {USB_DEVICE(0x1234, 0x0001), .driver_info = DEVTYPE_EGALAX}, 147 {USB_DEVICE(0x1234, 0x0002), .driver_info = DEVTYPE_EGALAX}, 148 #endif 149 150 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT 151 {USB_DEVICE(0x134c, 0x0001), .driver_info = DEVTYPE_PANJIT}, 152 {USB_DEVICE(0x134c, 0x0002), .driver_info = DEVTYPE_PANJIT}, 153 {USB_DEVICE(0x134c, 0x0003), .driver_info = DEVTYPE_PANJIT}, 154 {USB_DEVICE(0x134c, 0x0004), .driver_info = DEVTYPE_PANJIT}, 155 #endif 156 157 #ifdef CONFIG_TOUCHSCREEN_USB_3M 158 {USB_DEVICE(0x0596, 0x0001), .driver_info = DEVTYPE_3M}, 159 #endif 160 161 #ifdef CONFIG_TOUCHSCREEN_USB_ITM 162 {USB_DEVICE(0x0403, 0xf9e9), .driver_info = DEVTYPE_ITM}, 163 #endif 164 165 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO 166 {USB_DEVICE(0x1234, 0x5678), .driver_info = DEVTYPE_ETURBO}, 167 #endif 168 169 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE 170 {USB_DEVICE(0x0637, 0x0001), .driver_info = DEVTYPE_GUNZE}, 171 #endif 172 173 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10 174 {USB_DEVICE(0x0afa, 0x03e8), .driver_info = DEVTYPE_DMC_TSC10}, 175 #endif 176 177 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 178 {USB_DEVICE(0x595a, 0x0001), .driver_info = DEVTYPE_IRTOUCH}, 179 {USB_DEVICE(0x6615, 0x0001), .driver_info = DEVTYPE_IRTOUCH}, 180 #endif 181 182 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 183 {USB_DEVICE(0x1391, 0x1000), .driver_info = DEVTYPE_IDEALTEK}, 184 #endif 185 186 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 187 {USB_DEVICE(0x0dfc, 0x0001), .driver_info = DEVTYPE_GENERAL_TOUCH}, 188 #endif 189 190 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 191 {USB_DEVICE(0x08f2, 0x007f), .driver_info = DEVTYPE_GOTOP}, 192 {USB_DEVICE(0x08f2, 0x00ce), .driver_info = DEVTYPE_GOTOP}, 193 {USB_DEVICE(0x08f2, 0x00f4), .driver_info = DEVTYPE_GOTOP}, 194 #endif 195 196 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC 197 {USB_DEVICE(0x0f92, 0x0001), .driver_info = DEVTYPE_JASTEC}, 198 #endif 199 200 {} 201 }; 202 203 204 /***************************************************************************** 205 * eGalax part 206 */ 207 208 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX 209 210 #ifndef MULTI_PACKET 211 #define MULTI_PACKET 212 #endif 213 214 #define EGALAX_PKT_TYPE_MASK 0xFE 215 #define EGALAX_PKT_TYPE_REPT 0x80 216 #define EGALAX_PKT_TYPE_DIAG 0x0A 217 218 static int egalax_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 219 { 220 if ((pkt[0] & EGALAX_PKT_TYPE_MASK) != EGALAX_PKT_TYPE_REPT) 221 return 0; 222 223 dev->x = ((pkt[3] & 0x0F) << 7) | (pkt[4] & 0x7F); 224 dev->y = ((pkt[1] & 0x0F) << 7) | (pkt[2] & 0x7F); 225 dev->touch = pkt[0] & 0x01; 226 227 return 1; 228 } 229 230 static int egalax_get_pkt_len(unsigned char *buf, int len) 231 { 232 switch (buf[0] & EGALAX_PKT_TYPE_MASK) { 233 case EGALAX_PKT_TYPE_REPT: 234 return 5; 235 236 case EGALAX_PKT_TYPE_DIAG: 237 if (len < 2) 238 return -1; 239 240 return buf[1] + 2; 241 } 242 243 return 0; 244 } 245 #endif 246 247 248 /***************************************************************************** 249 * PanJit Part 250 */ 251 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT 252 static int panjit_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 253 { 254 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1]; 255 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3]; 256 dev->touch = pkt[0] & 0x01; 257 258 return 1; 259 } 260 #endif 261 262 263 /***************************************************************************** 264 * 3M/Microtouch Part 265 */ 266 #ifdef CONFIG_TOUCHSCREEN_USB_3M 267 268 #define MTOUCHUSB_ASYNC_REPORT 1 269 #define MTOUCHUSB_RESET 7 270 #define MTOUCHUSB_REQ_CTRLLR_ID 10 271 272 static int mtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 273 { 274 if (hwcalib_xy) { 275 dev->x = (pkt[4] << 8) | pkt[3]; 276 dev->y = 0xffff - ((pkt[6] << 8) | pkt[5]); 277 } else { 278 dev->x = (pkt[8] << 8) | pkt[7]; 279 dev->y = (pkt[10] << 8) | pkt[9]; 280 } 281 dev->touch = (pkt[2] & 0x40) ? 1 : 0; 282 283 return 1; 284 } 285 286 static int mtouch_init(struct usbtouch_usb *usbtouch) 287 { 288 int ret, i; 289 290 ret = usb_control_msg(usbtouch->udev, usb_rcvctrlpipe(usbtouch->udev, 0), 291 MTOUCHUSB_RESET, 292 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 293 1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT); 294 dbg("%s - usb_control_msg - MTOUCHUSB_RESET - bytes|err: %d", 295 __func__, ret); 296 if (ret < 0) 297 return ret; 298 msleep(150); 299 300 for (i = 0; i < 3; i++) { 301 ret = usb_control_msg(usbtouch->udev, usb_rcvctrlpipe(usbtouch->udev, 0), 302 MTOUCHUSB_ASYNC_REPORT, 303 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 304 1, 1, NULL, 0, USB_CTRL_SET_TIMEOUT); 305 dbg("%s - usb_control_msg - MTOUCHUSB_ASYNC_REPORT - bytes|err: %d", 306 __func__, ret); 307 if (ret >= 0) 308 break; 309 if (ret != -EPIPE) 310 return ret; 311 } 312 313 /* Default min/max xy are the raw values, override if using hw-calib */ 314 if (hwcalib_xy) { 315 input_set_abs_params(usbtouch->input, ABS_X, 0, 0xffff, 0, 0); 316 input_set_abs_params(usbtouch->input, ABS_Y, 0, 0xffff, 0, 0); 317 } 318 319 return 0; 320 } 321 #endif 322 323 324 /***************************************************************************** 325 * ITM Part 326 */ 327 #ifdef CONFIG_TOUCHSCREEN_USB_ITM 328 static int itm_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 329 { 330 int touch; 331 /* 332 * ITM devices report invalid x/y data if not touched. 333 * if the screen was touched before but is not touched any more 334 * report touch as 0 with the last valid x/y data once. then stop 335 * reporting data until touched again. 336 */ 337 dev->press = ((pkt[2] & 0x01) << 7) | (pkt[5] & 0x7F); 338 339 touch = ~pkt[7] & 0x20; 340 if (!touch) { 341 if (dev->touch) { 342 dev->touch = 0; 343 return 1; 344 } 345 346 return 0; 347 } 348 349 dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[3] & 0x7F); 350 dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[4] & 0x7F); 351 dev->touch = touch; 352 353 return 1; 354 } 355 #endif 356 357 358 /***************************************************************************** 359 * eTurboTouch part 360 */ 361 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO 362 #ifndef MULTI_PACKET 363 #define MULTI_PACKET 364 #endif 365 static int eturbo_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 366 { 367 unsigned int shift; 368 369 /* packets should start with sync */ 370 if (!(pkt[0] & 0x80)) 371 return 0; 372 373 shift = (6 - (pkt[0] & 0x03)); 374 dev->x = ((pkt[3] << 7) | pkt[4]) >> shift; 375 dev->y = ((pkt[1] << 7) | pkt[2]) >> shift; 376 dev->touch = (pkt[0] & 0x10) ? 1 : 0; 377 378 return 1; 379 } 380 381 static int eturbo_get_pkt_len(unsigned char *buf, int len) 382 { 383 if (buf[0] & 0x80) 384 return 5; 385 if (buf[0] == 0x01) 386 return 3; 387 return 0; 388 } 389 #endif 390 391 392 /***************************************************************************** 393 * Gunze part 394 */ 395 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE 396 static int gunze_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 397 { 398 if (!(pkt[0] & 0x80) || ((pkt[1] | pkt[2] | pkt[3]) & 0x80)) 399 return 0; 400 401 dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[2] & 0x7F); 402 dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[3] & 0x7F); 403 dev->touch = pkt[0] & 0x20; 404 405 return 1; 406 } 407 #endif 408 409 /***************************************************************************** 410 * DMC TSC-10/25 Part 411 * 412 * Documentation about the controller and it's protocol can be found at 413 * http://www.dmccoltd.com/files/controler/tsc10usb_pi_e.pdf 414 * http://www.dmccoltd.com/files/controler/tsc25_usb_e.pdf 415 */ 416 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10 417 418 /* supported data rates. currently using 130 */ 419 #define TSC10_RATE_POINT 0x50 420 #define TSC10_RATE_30 0x40 421 #define TSC10_RATE_50 0x41 422 #define TSC10_RATE_80 0x42 423 #define TSC10_RATE_100 0x43 424 #define TSC10_RATE_130 0x44 425 #define TSC10_RATE_150 0x45 426 427 /* commands */ 428 #define TSC10_CMD_RESET 0x55 429 #define TSC10_CMD_RATE 0x05 430 #define TSC10_CMD_DATA1 0x01 431 432 static int dmc_tsc10_init(struct usbtouch_usb *usbtouch) 433 { 434 struct usb_device *dev = usbtouch->udev; 435 int ret = -ENOMEM; 436 unsigned char *buf; 437 438 buf = kmalloc(2, GFP_KERNEL); 439 if (!buf) 440 goto err_nobuf; 441 /* reset */ 442 buf[0] = buf[1] = 0xFF; 443 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 444 TSC10_CMD_RESET, 445 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 446 0, 0, buf, 2, USB_CTRL_SET_TIMEOUT); 447 if (ret < 0) 448 goto err_out; 449 if (buf[0] != 0x06) { 450 ret = -ENODEV; 451 goto err_out; 452 } 453 454 /* set coordinate output rate */ 455 buf[0] = buf[1] = 0xFF; 456 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 457 TSC10_CMD_RATE, 458 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 459 TSC10_RATE_150, 0, buf, 2, USB_CTRL_SET_TIMEOUT); 460 if (ret < 0) 461 goto err_out; 462 if ((buf[0] != 0x06) && (buf[0] != 0x15 || buf[1] != 0x01)) { 463 ret = -ENODEV; 464 goto err_out; 465 } 466 467 /* start sending data */ 468 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 469 TSC10_CMD_DATA1, 470 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 471 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT); 472 err_out: 473 kfree(buf); 474 err_nobuf: 475 return ret; 476 } 477 478 479 static int dmc_tsc10_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 480 { 481 dev->x = ((pkt[2] & 0x03) << 8) | pkt[1]; 482 dev->y = ((pkt[4] & 0x03) << 8) | pkt[3]; 483 dev->touch = pkt[0] & 0x01; 484 485 return 1; 486 } 487 #endif 488 489 490 /***************************************************************************** 491 * IRTOUCH Part 492 */ 493 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 494 static int irtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 495 { 496 dev->x = (pkt[3] << 8) | pkt[2]; 497 dev->y = (pkt[5] << 8) | pkt[4]; 498 dev->touch = (pkt[1] & 0x03) ? 1 : 0; 499 500 return 1; 501 } 502 #endif 503 504 505 /***************************************************************************** 506 * IdealTEK URTC1000 Part 507 */ 508 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 509 #ifndef MULTI_PACKET 510 #define MULTI_PACKET 511 #endif 512 static int idealtek_get_pkt_len(unsigned char *buf, int len) 513 { 514 if (buf[0] & 0x80) 515 return 5; 516 if (buf[0] == 0x01) 517 return len; 518 return 0; 519 } 520 521 static int idealtek_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 522 { 523 switch (pkt[0] & 0x98) { 524 case 0x88: 525 /* touch data in IdealTEK mode */ 526 dev->x = (pkt[1] << 5) | (pkt[2] >> 2); 527 dev->y = (pkt[3] << 5) | (pkt[4] >> 2); 528 dev->touch = (pkt[0] & 0x40) ? 1 : 0; 529 return 1; 530 531 case 0x98: 532 /* touch data in MT emulation mode */ 533 dev->x = (pkt[2] << 5) | (pkt[1] >> 2); 534 dev->y = (pkt[4] << 5) | (pkt[3] >> 2); 535 dev->touch = (pkt[0] & 0x40) ? 1 : 0; 536 return 1; 537 538 default: 539 return 0; 540 } 541 } 542 #endif 543 544 /***************************************************************************** 545 * General Touch Part 546 */ 547 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 548 static int general_touch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 549 { 550 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1] ; 551 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3] ; 552 dev->press = pkt[5] & 0xff; 553 dev->touch = pkt[0] & 0x01; 554 555 return 1; 556 } 557 #endif 558 559 /***************************************************************************** 560 * GoTop Part 561 */ 562 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 563 static int gotop_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 564 { 565 dev->x = ((pkt[1] & 0x38) << 4) | pkt[2]; 566 dev->y = ((pkt[1] & 0x07) << 7) | pkt[3]; 567 dev->touch = pkt[0] & 0x01; 568 569 return 1; 570 } 571 #endif 572 573 /***************************************************************************** 574 * JASTEC Part 575 */ 576 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC 577 static int jastec_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 578 { 579 dev->x = ((pkt[0] & 0x3f) << 6) | (pkt[2] & 0x3f); 580 dev->y = ((pkt[1] & 0x3f) << 6) | (pkt[3] & 0x3f); 581 dev->touch = (pkt[0] & 0x40) >> 6; 582 583 return 1; 584 } 585 #endif 586 587 588 /***************************************************************************** 589 * the different device descriptors 590 */ 591 #ifdef MULTI_PACKET 592 static void usbtouch_process_multi(struct usbtouch_usb *usbtouch, 593 unsigned char *pkt, int len); 594 #endif 595 596 static struct usbtouch_device_info usbtouch_dev_info[] = { 597 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX 598 [DEVTYPE_EGALAX] = { 599 .min_xc = 0x0, 600 .max_xc = 0x07ff, 601 .min_yc = 0x0, 602 .max_yc = 0x07ff, 603 .rept_size = 16, 604 .process_pkt = usbtouch_process_multi, 605 .get_pkt_len = egalax_get_pkt_len, 606 .read_data = egalax_read_data, 607 }, 608 #endif 609 610 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT 611 [DEVTYPE_PANJIT] = { 612 .min_xc = 0x0, 613 .max_xc = 0x0fff, 614 .min_yc = 0x0, 615 .max_yc = 0x0fff, 616 .rept_size = 8, 617 .read_data = panjit_read_data, 618 }, 619 #endif 620 621 #ifdef CONFIG_TOUCHSCREEN_USB_3M 622 [DEVTYPE_3M] = { 623 .min_xc = 0x0, 624 .max_xc = 0x4000, 625 .min_yc = 0x0, 626 .max_yc = 0x4000, 627 .rept_size = 11, 628 .read_data = mtouch_read_data, 629 .init = mtouch_init, 630 }, 631 #endif 632 633 #ifdef CONFIG_TOUCHSCREEN_USB_ITM 634 [DEVTYPE_ITM] = { 635 .min_xc = 0x0, 636 .max_xc = 0x0fff, 637 .min_yc = 0x0, 638 .max_yc = 0x0fff, 639 .max_press = 0xff, 640 .rept_size = 8, 641 .read_data = itm_read_data, 642 }, 643 #endif 644 645 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO 646 [DEVTYPE_ETURBO] = { 647 .min_xc = 0x0, 648 .max_xc = 0x07ff, 649 .min_yc = 0x0, 650 .max_yc = 0x07ff, 651 .rept_size = 8, 652 .process_pkt = usbtouch_process_multi, 653 .get_pkt_len = eturbo_get_pkt_len, 654 .read_data = eturbo_read_data, 655 }, 656 #endif 657 658 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE 659 [DEVTYPE_GUNZE] = { 660 .min_xc = 0x0, 661 .max_xc = 0x0fff, 662 .min_yc = 0x0, 663 .max_yc = 0x0fff, 664 .rept_size = 4, 665 .read_data = gunze_read_data, 666 }, 667 #endif 668 669 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10 670 [DEVTYPE_DMC_TSC10] = { 671 .min_xc = 0x0, 672 .max_xc = 0x03ff, 673 .min_yc = 0x0, 674 .max_yc = 0x03ff, 675 .rept_size = 5, 676 .init = dmc_tsc10_init, 677 .read_data = dmc_tsc10_read_data, 678 }, 679 #endif 680 681 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 682 [DEVTYPE_IRTOUCH] = { 683 .min_xc = 0x0, 684 .max_xc = 0x0fff, 685 .min_yc = 0x0, 686 .max_yc = 0x0fff, 687 .rept_size = 8, 688 .read_data = irtouch_read_data, 689 }, 690 #endif 691 692 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 693 [DEVTYPE_IDEALTEK] = { 694 .min_xc = 0x0, 695 .max_xc = 0x0fff, 696 .min_yc = 0x0, 697 .max_yc = 0x0fff, 698 .rept_size = 8, 699 .process_pkt = usbtouch_process_multi, 700 .get_pkt_len = idealtek_get_pkt_len, 701 .read_data = idealtek_read_data, 702 }, 703 #endif 704 705 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 706 [DEVTYPE_GENERAL_TOUCH] = { 707 .min_xc = 0x0, 708 .max_xc = 0x0500, 709 .min_yc = 0x0, 710 .max_yc = 0x0500, 711 .rept_size = 7, 712 .read_data = general_touch_read_data, 713 }, 714 #endif 715 716 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 717 [DEVTYPE_GOTOP] = { 718 .min_xc = 0x0, 719 .max_xc = 0x03ff, 720 .min_yc = 0x0, 721 .max_yc = 0x03ff, 722 .rept_size = 4, 723 .read_data = gotop_read_data, 724 }, 725 #endif 726 727 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC 728 [DEVTYPE_JASTEC] = { 729 .min_xc = 0x0, 730 .max_xc = 0x0fff, 731 .min_yc = 0x0, 732 .max_yc = 0x0fff, 733 .rept_size = 4, 734 .read_data = jastec_read_data, 735 }, 736 #endif 737 }; 738 739 740 /***************************************************************************** 741 * Generic Part 742 */ 743 static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch, 744 unsigned char *pkt, int len) 745 { 746 struct usbtouch_device_info *type = usbtouch->type; 747 748 if (!type->read_data(usbtouch, pkt)) 749 return; 750 751 input_report_key(usbtouch->input, BTN_TOUCH, usbtouch->touch); 752 753 if (swap_xy) { 754 input_report_abs(usbtouch->input, ABS_X, usbtouch->y); 755 input_report_abs(usbtouch->input, ABS_Y, usbtouch->x); 756 } else { 757 input_report_abs(usbtouch->input, ABS_X, usbtouch->x); 758 input_report_abs(usbtouch->input, ABS_Y, usbtouch->y); 759 } 760 if (type->max_press) 761 input_report_abs(usbtouch->input, ABS_PRESSURE, usbtouch->press); 762 input_sync(usbtouch->input); 763 } 764 765 766 #ifdef MULTI_PACKET 767 static void usbtouch_process_multi(struct usbtouch_usb *usbtouch, 768 unsigned char *pkt, int len) 769 { 770 unsigned char *buffer; 771 int pkt_len, pos, buf_len, tmp; 772 773 /* process buffer */ 774 if (unlikely(usbtouch->buf_len)) { 775 /* try to get size */ 776 pkt_len = usbtouch->type->get_pkt_len( 777 usbtouch->buffer, usbtouch->buf_len); 778 779 /* drop? */ 780 if (unlikely(!pkt_len)) 781 goto out_flush_buf; 782 783 /* need to append -pkt_len bytes before able to get size */ 784 if (unlikely(pkt_len < 0)) { 785 int append = -pkt_len; 786 if (unlikely(append > len)) 787 append = len; 788 if (usbtouch->buf_len + append >= usbtouch->type->rept_size) 789 goto out_flush_buf; 790 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, append); 791 usbtouch->buf_len += append; 792 793 pkt_len = usbtouch->type->get_pkt_len( 794 usbtouch->buffer, usbtouch->buf_len); 795 if (pkt_len < 0) 796 return; 797 } 798 799 /* append */ 800 tmp = pkt_len - usbtouch->buf_len; 801 if (usbtouch->buf_len + tmp >= usbtouch->type->rept_size) 802 goto out_flush_buf; 803 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, tmp); 804 usbtouch_process_pkt(usbtouch, usbtouch->buffer, pkt_len); 805 806 buffer = pkt + tmp; 807 buf_len = len - tmp; 808 } else { 809 buffer = pkt; 810 buf_len = len; 811 } 812 813 /* loop over the received packet, process */ 814 pos = 0; 815 while (pos < buf_len) { 816 /* get packet len */ 817 pkt_len = usbtouch->type->get_pkt_len(buffer + pos, 818 buf_len - pos); 819 820 /* unknown packet: skip one byte */ 821 if (unlikely(!pkt_len)) { 822 pos++; 823 continue; 824 } 825 826 /* full packet: process */ 827 if (likely((pkt_len > 0) && (pkt_len <= buf_len - pos))) { 828 usbtouch_process_pkt(usbtouch, buffer + pos, pkt_len); 829 } else { 830 /* incomplete packet: save in buffer */ 831 memcpy(usbtouch->buffer, buffer + pos, buf_len - pos); 832 usbtouch->buf_len = buf_len - pos; 833 return; 834 } 835 pos += pkt_len; 836 } 837 838 out_flush_buf: 839 usbtouch->buf_len = 0; 840 return; 841 } 842 #endif 843 844 845 static void usbtouch_irq(struct urb *urb) 846 { 847 struct usbtouch_usb *usbtouch = urb->context; 848 int retval; 849 850 switch (urb->status) { 851 case 0: 852 /* success */ 853 break; 854 case -ETIME: 855 /* this urb is timing out */ 856 dbg("%s - urb timed out - was the device unplugged?", 857 __func__); 858 return; 859 case -ECONNRESET: 860 case -ENOENT: 861 case -ESHUTDOWN: 862 /* this urb is terminated, clean up */ 863 dbg("%s - urb shutting down with status: %d", 864 __func__, urb->status); 865 return; 866 default: 867 dbg("%s - nonzero urb status received: %d", 868 __func__, urb->status); 869 goto exit; 870 } 871 872 usbtouch->type->process_pkt(usbtouch, usbtouch->data, urb->actual_length); 873 874 exit: 875 retval = usb_submit_urb(urb, GFP_ATOMIC); 876 if (retval) 877 err("%s - usb_submit_urb failed with result: %d", 878 __func__, retval); 879 } 880 881 static int usbtouch_open(struct input_dev *input) 882 { 883 struct usbtouch_usb *usbtouch = input_get_drvdata(input); 884 885 usbtouch->irq->dev = usbtouch->udev; 886 887 if (usb_submit_urb(usbtouch->irq, GFP_KERNEL)) 888 return -EIO; 889 890 return 0; 891 } 892 893 static void usbtouch_close(struct input_dev *input) 894 { 895 struct usbtouch_usb *usbtouch = input_get_drvdata(input); 896 897 usb_kill_urb(usbtouch->irq); 898 } 899 900 901 static void usbtouch_free_buffers(struct usb_device *udev, 902 struct usbtouch_usb *usbtouch) 903 { 904 usb_buffer_free(udev, usbtouch->type->rept_size, 905 usbtouch->data, usbtouch->data_dma); 906 kfree(usbtouch->buffer); 907 } 908 909 910 static int usbtouch_probe(struct usb_interface *intf, 911 const struct usb_device_id *id) 912 { 913 struct usbtouch_usb *usbtouch; 914 struct input_dev *input_dev; 915 struct usb_host_interface *interface; 916 struct usb_endpoint_descriptor *endpoint; 917 struct usb_device *udev = interface_to_usbdev(intf); 918 struct usbtouch_device_info *type; 919 int err = -ENOMEM; 920 921 /* some devices are ignored */ 922 if (id->driver_info == DEVTYPE_IGNORE) 923 return -ENODEV; 924 925 interface = intf->cur_altsetting; 926 endpoint = &interface->endpoint[0].desc; 927 928 usbtouch = kzalloc(sizeof(struct usbtouch_usb), GFP_KERNEL); 929 input_dev = input_allocate_device(); 930 if (!usbtouch || !input_dev) 931 goto out_free; 932 933 type = &usbtouch_dev_info[id->driver_info]; 934 usbtouch->type = type; 935 if (!type->process_pkt) 936 type->process_pkt = usbtouch_process_pkt; 937 938 usbtouch->data = usb_buffer_alloc(udev, type->rept_size, 939 GFP_KERNEL, &usbtouch->data_dma); 940 if (!usbtouch->data) 941 goto out_free; 942 943 if (type->get_pkt_len) { 944 usbtouch->buffer = kmalloc(type->rept_size, GFP_KERNEL); 945 if (!usbtouch->buffer) 946 goto out_free_buffers; 947 } 948 949 usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL); 950 if (!usbtouch->irq) { 951 dbg("%s - usb_alloc_urb failed: usbtouch->irq", __func__); 952 goto out_free_buffers; 953 } 954 955 usbtouch->udev = udev; 956 usbtouch->input = input_dev; 957 958 if (udev->manufacturer) 959 strlcpy(usbtouch->name, udev->manufacturer, sizeof(usbtouch->name)); 960 961 if (udev->product) { 962 if (udev->manufacturer) 963 strlcat(usbtouch->name, " ", sizeof(usbtouch->name)); 964 strlcat(usbtouch->name, udev->product, sizeof(usbtouch->name)); 965 } 966 967 if (!strlen(usbtouch->name)) 968 snprintf(usbtouch->name, sizeof(usbtouch->name), 969 "USB Touchscreen %04x:%04x", 970 le16_to_cpu(udev->descriptor.idVendor), 971 le16_to_cpu(udev->descriptor.idProduct)); 972 973 usb_make_path(udev, usbtouch->phys, sizeof(usbtouch->phys)); 974 strlcat(usbtouch->phys, "/input0", sizeof(usbtouch->phys)); 975 976 input_dev->name = usbtouch->name; 977 input_dev->phys = usbtouch->phys; 978 usb_to_input_id(udev, &input_dev->id); 979 input_dev->dev.parent = &intf->dev; 980 981 input_set_drvdata(input_dev, usbtouch); 982 983 input_dev->open = usbtouch_open; 984 input_dev->close = usbtouch_close; 985 986 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 987 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 988 input_set_abs_params(input_dev, ABS_X, type->min_xc, type->max_xc, 0, 0); 989 input_set_abs_params(input_dev, ABS_Y, type->min_yc, type->max_yc, 0, 0); 990 if (type->max_press) 991 input_set_abs_params(input_dev, ABS_PRESSURE, type->min_press, 992 type->max_press, 0, 0); 993 994 usb_fill_int_urb(usbtouch->irq, usbtouch->udev, 995 usb_rcvintpipe(usbtouch->udev, endpoint->bEndpointAddress), 996 usbtouch->data, type->rept_size, 997 usbtouch_irq, usbtouch, endpoint->bInterval); 998 999 usbtouch->irq->dev = usbtouch->udev; 1000 usbtouch->irq->transfer_dma = usbtouch->data_dma; 1001 usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1002 1003 /* device specific init */ 1004 if (type->init) { 1005 err = type->init(usbtouch); 1006 if (err) { 1007 dbg("%s - type->init() failed, err: %d", __func__, err); 1008 goto out_free_buffers; 1009 } 1010 } 1011 1012 err = input_register_device(usbtouch->input); 1013 if (err) { 1014 dbg("%s - input_register_device failed, err: %d", __func__, err); 1015 goto out_free_buffers; 1016 } 1017 1018 usb_set_intfdata(intf, usbtouch); 1019 1020 return 0; 1021 1022 out_free_buffers: 1023 usbtouch_free_buffers(udev, usbtouch); 1024 out_free: 1025 input_free_device(input_dev); 1026 kfree(usbtouch); 1027 return err; 1028 } 1029 1030 static void usbtouch_disconnect(struct usb_interface *intf) 1031 { 1032 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1033 1034 dbg("%s - called", __func__); 1035 1036 if (!usbtouch) 1037 return; 1038 1039 dbg("%s - usbtouch is initialized, cleaning up", __func__); 1040 usb_set_intfdata(intf, NULL); 1041 usb_kill_urb(usbtouch->irq); 1042 input_unregister_device(usbtouch->input); 1043 usb_free_urb(usbtouch->irq); 1044 usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch); 1045 kfree(usbtouch); 1046 } 1047 1048 MODULE_DEVICE_TABLE(usb, usbtouch_devices); 1049 1050 static struct usb_driver usbtouch_driver = { 1051 .name = "usbtouchscreen", 1052 .probe = usbtouch_probe, 1053 .disconnect = usbtouch_disconnect, 1054 .id_table = usbtouch_devices, 1055 }; 1056 1057 static int __init usbtouch_init(void) 1058 { 1059 return usb_register(&usbtouch_driver); 1060 } 1061 1062 static void __exit usbtouch_cleanup(void) 1063 { 1064 usb_deregister(&usbtouch_driver); 1065 } 1066 1067 module_init(usbtouch_init); 1068 module_exit(usbtouch_cleanup); 1069 1070 MODULE_AUTHOR(DRIVER_AUTHOR); 1071 MODULE_DESCRIPTION(DRIVER_DESC); 1072 MODULE_LICENSE("GPL"); 1073 1074 MODULE_ALIAS("touchkitusb"); 1075 MODULE_ALIAS("itmtouch"); 1076 MODULE_ALIAS("mtouchusb"); 1077