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