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