usbtouchscreen.c revision 76d057ce5a48034c97f604a0a25a87093e072c71
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 58static int swap_xy; 59module_param(swap_xy, bool, 0644); 60MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped."); 61 62/* device specifc data/functions */ 63struct usbtouch_usb; 64struct 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 */ 85struct 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 */ 103enum { 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 118static 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 193static 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 205static 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 227static 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 247static 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 256static 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 292static 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 329static 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 345static 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 360static 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 396static int dmc_tsc10_init(struct usbtouch_usb *usbtouch) 397{ 398 struct usb_device *dev = usbtouch->udev; 399 int ret = -ENOMEM; 400 unsigned char *buf; 401 402 buf = kmalloc(2, GFP_KERNEL); 403 if (!buf) 404 goto err_nobuf; 405 /* reset */ 406 buf[0] = buf[1] = 0xFF; 407 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 408 TSC10_CMD_RESET, 409 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 410 0, 0, buf, 2, USB_CTRL_SET_TIMEOUT); 411 if (ret < 0) 412 goto err_out; 413 if (buf[0] != 0x06 || buf[1] != 0x00) { 414 ret = -ENODEV; 415 goto err_out; 416 } 417 418 /* set coordinate output rate */ 419 buf[0] = buf[1] = 0xFF; 420 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 421 TSC10_CMD_RATE, 422 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 423 TSC10_RATE_150, 0, buf, 2, USB_CTRL_SET_TIMEOUT); 424 if (ret < 0) 425 goto err_out; 426 if ((buf[0] != 0x06 || buf[1] != 0x00) && 427 (buf[0] != 0x15 || buf[1] != 0x01)) { 428 ret = -ENODEV; 429 goto err_out; 430 } 431 432 /* start sending data */ 433 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 434 TSC10_CMD_DATA1, 435 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 436 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT); 437err_out: 438 kfree(buf); 439err_nobuf: 440 return ret; 441} 442 443 444static int dmc_tsc10_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 445{ 446 dev->x = ((pkt[2] & 0x03) << 8) | pkt[1]; 447 dev->y = ((pkt[4] & 0x03) << 8) | pkt[3]; 448 dev->touch = pkt[0] & 0x01; 449 450 return 1; 451} 452#endif 453 454 455/***************************************************************************** 456 * IRTOUCH Part 457 */ 458#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 459static int irtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 460{ 461 dev->x = (pkt[3] << 8) | pkt[2]; 462 dev->y = (pkt[5] << 8) | pkt[4]; 463 dev->touch = (pkt[1] & 0x03) ? 1 : 0; 464 465 return 1; 466} 467#endif 468 469 470/***************************************************************************** 471 * IdealTEK URTC1000 Part 472 */ 473#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 474#ifndef MULTI_PACKET 475#define MULTI_PACKET 476#endif 477static int idealtek_get_pkt_len(unsigned char *buf, int len) 478{ 479 if (buf[0] & 0x80) 480 return 5; 481 if (buf[0] == 0x01) 482 return len; 483 return 0; 484} 485 486static int idealtek_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 487{ 488 switch (pkt[0] & 0x98) { 489 case 0x88: 490 /* touch data in IdealTEK mode */ 491 dev->x = (pkt[1] << 5) | (pkt[2] >> 2); 492 dev->y = (pkt[3] << 5) | (pkt[4] >> 2); 493 dev->touch = (pkt[0] & 0x40) ? 1 : 0; 494 return 1; 495 496 case 0x98: 497 /* touch data in MT emulation mode */ 498 dev->x = (pkt[2] << 5) | (pkt[1] >> 2); 499 dev->y = (pkt[4] << 5) | (pkt[3] >> 2); 500 dev->touch = (pkt[0] & 0x40) ? 1 : 0; 501 return 1; 502 503 default: 504 return 0; 505 } 506} 507#endif 508 509/***************************************************************************** 510 * General Touch Part 511 */ 512#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 513static int general_touch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 514{ 515 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1] ; 516 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3] ; 517 dev->press = pkt[5] & 0xff; 518 dev->touch = pkt[0] & 0x01; 519 520 return 1; 521} 522#endif 523 524/***************************************************************************** 525 * GoTop Part 526 */ 527#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 528static int gotop_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 529{ 530 dev->x = ((pkt[1] & 0x38) << 4) | pkt[2]; 531 dev->y = ((pkt[1] & 0x07) << 7) | pkt[3]; 532 dev->touch = pkt[0] & 0x01; 533 return 1; 534} 535#endif 536 537 538/***************************************************************************** 539 * the different device descriptors 540 */ 541#ifdef MULTI_PACKET 542static void usbtouch_process_multi(struct usbtouch_usb *usbtouch, 543 unsigned char *pkt, int len); 544#endif 545 546static struct usbtouch_device_info usbtouch_dev_info[] = { 547#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX 548 [DEVTYPE_EGALAX] = { 549 .min_xc = 0x0, 550 .max_xc = 0x07ff, 551 .min_yc = 0x0, 552 .max_yc = 0x07ff, 553 .rept_size = 16, 554 .process_pkt = usbtouch_process_multi, 555 .get_pkt_len = egalax_get_pkt_len, 556 .read_data = egalax_read_data, 557 }, 558#endif 559 560#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT 561 [DEVTYPE_PANJIT] = { 562 .min_xc = 0x0, 563 .max_xc = 0x0fff, 564 .min_yc = 0x0, 565 .max_yc = 0x0fff, 566 .rept_size = 8, 567 .read_data = panjit_read_data, 568 }, 569#endif 570 571#ifdef CONFIG_TOUCHSCREEN_USB_3M 572 [DEVTYPE_3M] = { 573 .min_xc = 0x0, 574 .max_xc = 0x4000, 575 .min_yc = 0x0, 576 .max_yc = 0x4000, 577 .rept_size = 11, 578 .read_data = mtouch_read_data, 579 .init = mtouch_init, 580 }, 581#endif 582 583#ifdef CONFIG_TOUCHSCREEN_USB_ITM 584 [DEVTYPE_ITM] = { 585 .min_xc = 0x0, 586 .max_xc = 0x0fff, 587 .min_yc = 0x0, 588 .max_yc = 0x0fff, 589 .max_press = 0xff, 590 .rept_size = 8, 591 .read_data = itm_read_data, 592 }, 593#endif 594 595#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO 596 [DEVTYPE_ETURBO] = { 597 .min_xc = 0x0, 598 .max_xc = 0x07ff, 599 .min_yc = 0x0, 600 .max_yc = 0x07ff, 601 .rept_size = 8, 602 .process_pkt = usbtouch_process_multi, 603 .get_pkt_len = eturbo_get_pkt_len, 604 .read_data = eturbo_read_data, 605 }, 606#endif 607 608#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE 609 [DEVTYPE_GUNZE] = { 610 .min_xc = 0x0, 611 .max_xc = 0x0fff, 612 .min_yc = 0x0, 613 .max_yc = 0x0fff, 614 .rept_size = 4, 615 .read_data = gunze_read_data, 616 }, 617#endif 618 619#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10 620 [DEVTYPE_DMC_TSC10] = { 621 .min_xc = 0x0, 622 .max_xc = 0x03ff, 623 .min_yc = 0x0, 624 .max_yc = 0x03ff, 625 .rept_size = 5, 626 .init = dmc_tsc10_init, 627 .read_data = dmc_tsc10_read_data, 628 }, 629#endif 630 631#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 632 [DEVTYPE_IRTOUCH] = { 633 .min_xc = 0x0, 634 .max_xc = 0x0fff, 635 .min_yc = 0x0, 636 .max_yc = 0x0fff, 637 .rept_size = 8, 638 .read_data = irtouch_read_data, 639 }, 640#endif 641 642#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 643 [DEVTYPE_IDEALTEK] = { 644 .min_xc = 0x0, 645 .max_xc = 0x0fff, 646 .min_yc = 0x0, 647 .max_yc = 0x0fff, 648 .rept_size = 8, 649 .process_pkt = usbtouch_process_multi, 650 .get_pkt_len = idealtek_get_pkt_len, 651 .read_data = idealtek_read_data, 652 }, 653#endif 654 655#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 656 [DEVTYPE_GENERAL_TOUCH] = { 657 .min_xc = 0x0, 658 .max_xc = 0x0500, 659 .min_yc = 0x0, 660 .max_yc = 0x0500, 661 .rept_size = 7, 662 .read_data = general_touch_read_data, 663 }, 664#endif 665 666#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 667 [DEVTYPE_GOTOP] = { 668 .min_xc = 0x0, 669 .max_xc = 0x03ff, 670 .min_yc = 0x0, 671 .max_yc = 0x03ff, 672 .rept_size = 4, 673 .read_data = gotop_read_data, 674 }, 675#endif 676}; 677 678 679/***************************************************************************** 680 * Generic Part 681 */ 682static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch, 683 unsigned char *pkt, int len) 684{ 685 struct usbtouch_device_info *type = usbtouch->type; 686 687 if (!type->read_data(usbtouch, pkt)) 688 return; 689 690 input_report_key(usbtouch->input, BTN_TOUCH, usbtouch->touch); 691 692 if (swap_xy) { 693 input_report_abs(usbtouch->input, ABS_X, usbtouch->y); 694 input_report_abs(usbtouch->input, ABS_Y, usbtouch->x); 695 } else { 696 input_report_abs(usbtouch->input, ABS_X, usbtouch->x); 697 input_report_abs(usbtouch->input, ABS_Y, usbtouch->y); 698 } 699 if (type->max_press) 700 input_report_abs(usbtouch->input, ABS_PRESSURE, usbtouch->press); 701 input_sync(usbtouch->input); 702} 703 704 705#ifdef MULTI_PACKET 706static void usbtouch_process_multi(struct usbtouch_usb *usbtouch, 707 unsigned char *pkt, int len) 708{ 709 unsigned char *buffer; 710 int pkt_len, pos, buf_len, tmp; 711 712 /* process buffer */ 713 if (unlikely(usbtouch->buf_len)) { 714 /* try to get size */ 715 pkt_len = usbtouch->type->get_pkt_len( 716 usbtouch->buffer, usbtouch->buf_len); 717 718 /* drop? */ 719 if (unlikely(!pkt_len)) 720 goto out_flush_buf; 721 722 /* need to append -pkt_len bytes before able to get size */ 723 if (unlikely(pkt_len < 0)) { 724 int append = -pkt_len; 725 if (unlikely(append > len)) 726 append = len; 727 if (usbtouch->buf_len + append >= usbtouch->type->rept_size) 728 goto out_flush_buf; 729 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, append); 730 usbtouch->buf_len += append; 731 732 pkt_len = usbtouch->type->get_pkt_len( 733 usbtouch->buffer, usbtouch->buf_len); 734 if (pkt_len < 0) 735 return; 736 } 737 738 /* append */ 739 tmp = pkt_len - usbtouch->buf_len; 740 if (usbtouch->buf_len + tmp >= usbtouch->type->rept_size) 741 goto out_flush_buf; 742 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, tmp); 743 usbtouch_process_pkt(usbtouch, usbtouch->buffer, pkt_len); 744 745 buffer = pkt + tmp; 746 buf_len = len - tmp; 747 } else { 748 buffer = pkt; 749 buf_len = len; 750 } 751 752 /* loop over the received packet, process */ 753 pos = 0; 754 while (pos < buf_len) { 755 /* get packet len */ 756 pkt_len = usbtouch->type->get_pkt_len(buffer + pos, 757 buf_len - pos); 758 759 /* unknown packet: skip one byte */ 760 if (unlikely(!pkt_len)) { 761 pos++; 762 continue; 763 } 764 765 /* full packet: process */ 766 if (likely((pkt_len > 0) && (pkt_len <= buf_len - pos))) { 767 usbtouch_process_pkt(usbtouch, buffer + pos, pkt_len); 768 } else { 769 /* incomplete packet: save in buffer */ 770 memcpy(usbtouch->buffer, buffer + pos, buf_len - pos); 771 usbtouch->buf_len = buf_len - pos; 772 return; 773 } 774 pos += pkt_len; 775 } 776 777out_flush_buf: 778 usbtouch->buf_len = 0; 779 return; 780} 781#endif 782 783 784static void usbtouch_irq(struct urb *urb) 785{ 786 struct usbtouch_usb *usbtouch = urb->context; 787 int retval; 788 789 switch (urb->status) { 790 case 0: 791 /* success */ 792 break; 793 case -ETIME: 794 /* this urb is timing out */ 795 dbg("%s - urb timed out - was the device unplugged?", 796 __FUNCTION__); 797 return; 798 case -ECONNRESET: 799 case -ENOENT: 800 case -ESHUTDOWN: 801 /* this urb is terminated, clean up */ 802 dbg("%s - urb shutting down with status: %d", 803 __FUNCTION__, urb->status); 804 return; 805 default: 806 dbg("%s - nonzero urb status received: %d", 807 __FUNCTION__, urb->status); 808 goto exit; 809 } 810 811 usbtouch->type->process_pkt(usbtouch, usbtouch->data, urb->actual_length); 812 813exit: 814 retval = usb_submit_urb(urb, GFP_ATOMIC); 815 if (retval) 816 err("%s - usb_submit_urb failed with result: %d", 817 __FUNCTION__, retval); 818} 819 820static int usbtouch_open(struct input_dev *input) 821{ 822 struct usbtouch_usb *usbtouch = input_get_drvdata(input); 823 824 usbtouch->irq->dev = usbtouch->udev; 825 826 if (usb_submit_urb(usbtouch->irq, GFP_KERNEL)) 827 return -EIO; 828 829 return 0; 830} 831 832static void usbtouch_close(struct input_dev *input) 833{ 834 struct usbtouch_usb *usbtouch = input_get_drvdata(input); 835 836 usb_kill_urb(usbtouch->irq); 837} 838 839 840static void usbtouch_free_buffers(struct usb_device *udev, 841 struct usbtouch_usb *usbtouch) 842{ 843 usb_buffer_free(udev, usbtouch->type->rept_size, 844 usbtouch->data, usbtouch->data_dma); 845 kfree(usbtouch->buffer); 846} 847 848 849static int usbtouch_probe(struct usb_interface *intf, 850 const struct usb_device_id *id) 851{ 852 struct usbtouch_usb *usbtouch; 853 struct input_dev *input_dev; 854 struct usb_host_interface *interface; 855 struct usb_endpoint_descriptor *endpoint; 856 struct usb_device *udev = interface_to_usbdev(intf); 857 struct usbtouch_device_info *type; 858 int err = -ENOMEM; 859 860 interface = intf->cur_altsetting; 861 endpoint = &interface->endpoint[0].desc; 862 863 usbtouch = kzalloc(sizeof(struct usbtouch_usb), GFP_KERNEL); 864 input_dev = input_allocate_device(); 865 if (!usbtouch || !input_dev) 866 goto out_free; 867 868 type = &usbtouch_dev_info[id->driver_info]; 869 usbtouch->type = type; 870 if (!type->process_pkt) 871 type->process_pkt = usbtouch_process_pkt; 872 873 usbtouch->data = usb_buffer_alloc(udev, type->rept_size, 874 GFP_KERNEL, &usbtouch->data_dma); 875 if (!usbtouch->data) 876 goto out_free; 877 878 if (type->get_pkt_len) { 879 usbtouch->buffer = kmalloc(type->rept_size, GFP_KERNEL); 880 if (!usbtouch->buffer) 881 goto out_free_buffers; 882 } 883 884 usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL); 885 if (!usbtouch->irq) { 886 dbg("%s - usb_alloc_urb failed: usbtouch->irq", __FUNCTION__); 887 goto out_free_buffers; 888 } 889 890 usbtouch->udev = udev; 891 usbtouch->input = input_dev; 892 893 if (udev->manufacturer) 894 strlcpy(usbtouch->name, udev->manufacturer, sizeof(usbtouch->name)); 895 896 if (udev->product) { 897 if (udev->manufacturer) 898 strlcat(usbtouch->name, " ", sizeof(usbtouch->name)); 899 strlcat(usbtouch->name, udev->product, sizeof(usbtouch->name)); 900 } 901 902 if (!strlen(usbtouch->name)) 903 snprintf(usbtouch->name, sizeof(usbtouch->name), 904 "USB Touchscreen %04x:%04x", 905 le16_to_cpu(udev->descriptor.idVendor), 906 le16_to_cpu(udev->descriptor.idProduct)); 907 908 usb_make_path(udev, usbtouch->phys, sizeof(usbtouch->phys)); 909 strlcat(usbtouch->phys, "/input0", sizeof(usbtouch->phys)); 910 911 input_dev->name = usbtouch->name; 912 input_dev->phys = usbtouch->phys; 913 usb_to_input_id(udev, &input_dev->id); 914 input_dev->dev.parent = &intf->dev; 915 916 input_set_drvdata(input_dev, usbtouch); 917 918 input_dev->open = usbtouch_open; 919 input_dev->close = usbtouch_close; 920 921 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 922 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 923 input_set_abs_params(input_dev, ABS_X, type->min_xc, type->max_xc, 0, 0); 924 input_set_abs_params(input_dev, ABS_Y, type->min_yc, type->max_yc, 0, 0); 925 if (type->max_press) 926 input_set_abs_params(input_dev, ABS_PRESSURE, type->min_press, 927 type->max_press, 0, 0); 928 929 usb_fill_int_urb(usbtouch->irq, usbtouch->udev, 930 usb_rcvintpipe(usbtouch->udev, endpoint->bEndpointAddress), 931 usbtouch->data, type->rept_size, 932 usbtouch_irq, usbtouch, endpoint->bInterval); 933 934 usbtouch->irq->dev = usbtouch->udev; 935 usbtouch->irq->transfer_dma = usbtouch->data_dma; 936 usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 937 938 /* device specific init */ 939 if (type->init) { 940 err = type->init(usbtouch); 941 if (err) { 942 dbg("%s - type->init() failed, err: %d", __FUNCTION__, err); 943 goto out_free_buffers; 944 } 945 } 946 947 err = input_register_device(usbtouch->input); 948 if (err) { 949 dbg("%s - input_register_device failed, err: %d", __FUNCTION__, err); 950 goto out_free_buffers; 951 } 952 953 usb_set_intfdata(intf, usbtouch); 954 955 return 0; 956 957out_free_buffers: 958 usbtouch_free_buffers(udev, usbtouch); 959out_free: 960 input_free_device(input_dev); 961 kfree(usbtouch); 962 return err; 963} 964 965static void usbtouch_disconnect(struct usb_interface *intf) 966{ 967 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 968 969 dbg("%s - called", __FUNCTION__); 970 971 if (!usbtouch) 972 return; 973 974 dbg("%s - usbtouch is initialized, cleaning up", __FUNCTION__); 975 usb_set_intfdata(intf, NULL); 976 usb_kill_urb(usbtouch->irq); 977 input_unregister_device(usbtouch->input); 978 usb_free_urb(usbtouch->irq); 979 usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch); 980 kfree(usbtouch); 981} 982 983MODULE_DEVICE_TABLE(usb, usbtouch_devices); 984 985static struct usb_driver usbtouch_driver = { 986 .name = "usbtouchscreen", 987 .probe = usbtouch_probe, 988 .disconnect = usbtouch_disconnect, 989 .id_table = usbtouch_devices, 990}; 991 992static int __init usbtouch_init(void) 993{ 994 return usb_register(&usbtouch_driver); 995} 996 997static void __exit usbtouch_cleanup(void) 998{ 999 usb_deregister(&usbtouch_driver); 1000} 1001 1002module_init(usbtouch_init); 1003module_exit(usbtouch_cleanup); 1004 1005MODULE_AUTHOR(DRIVER_AUTHOR); 1006MODULE_DESCRIPTION(DRIVER_DESC); 1007MODULE_LICENSE("GPL"); 1008 1009MODULE_ALIAS("touchkitusb"); 1010MODULE_ALIAS("itmtouch"); 1011MODULE_ALIAS("mtouchusb"); 1012