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