1 /****************************************************************************** 2 * usbtouchscreen.c 3 * Driver for USB Touchscreens, supporting those devices: 4 * - eGalax Touchkit 5 * includes eTurboTouch CT-410/510/700 6 * - 3M/Microtouch EX II series 7 * - ITM 8 * - PanJit TouchSet 9 * - eTurboTouch 10 * - Gunze AHL61 11 * - DMC TSC-10/25 12 * - IRTOUCHSYSTEMS/UNITOP 13 * - IdealTEK URTC1000 14 * - General Touch 15 * - GoTop Super_Q2/GogoPen/PenPower tablets 16 * - JASTEC USB touch controller/DigiTech DTR-02U 17 * - Zytronic capacitive touchscreen 18 * - NEXIO/iNexio 19 * - Elo TouchSystems 2700 IntelliTouch 20 * - EasyTouch USB Dual/Multi touch controller from Data Modul 21 * 22 * Copyright (C) 2004-2007 by Daniel Ritz <daniel.ritz@gmx.ch> 23 * Copyright (C) by Todd E. Johnson (mtouchusb.c) 24 * 25 * This program is free software; you can redistribute it and/or 26 * modify it under the terms of the GNU General Public License as 27 * published by the Free Software Foundation; either version 2 of the 28 * License, or (at your option) any later version. 29 * 30 * This program is distributed in the hope that it will be useful, but 31 * WITHOUT ANY WARRANTY; without even the implied warranty of 32 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 33 * General Public License for more details. 34 * 35 * You should have received a copy of the GNU General Public License 36 * along with this program; if not, write to the Free Software 37 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 38 * 39 * Driver is based on touchkitusb.c 40 * - ITM parts are from itmtouch.c 41 * - 3M parts are from mtouchusb.c 42 * - PanJit parts are from an unmerged driver by Lanslott Gish 43 * - DMC TSC 10/25 are from Holger Schurig, with ideas from an unmerged 44 * driver from Marius Vollmer 45 * 46 *****************************************************************************/ 47 48 //#define DEBUG 49 50 #include <linux/kernel.h> 51 #include <linux/slab.h> 52 #include <linux/input.h> 53 #include <linux/module.h> 54 #include <linux/init.h> 55 #include <linux/usb.h> 56 #include <linux/usb/input.h> 57 #include <linux/hid.h> 58 59 60 #define DRIVER_VERSION "v0.6" 61 #define DRIVER_AUTHOR "Daniel Ritz <daniel.ritz@gmx.ch>" 62 #define DRIVER_DESC "USB Touchscreen Driver" 63 64 static bool swap_xy; 65 module_param(swap_xy, bool, 0644); 66 MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped."); 67 68 static bool hwcalib_xy; 69 module_param(hwcalib_xy, bool, 0644); 70 MODULE_PARM_DESC(hwcalib_xy, "If set hw-calibrated X/Y are used if available"); 71 72 /* device specifc data/functions */ 73 struct usbtouch_usb; 74 struct usbtouch_device_info { 75 int min_xc, max_xc; 76 int min_yc, max_yc; 77 int min_press, max_press; 78 int rept_size; 79 80 /* 81 * Always service the USB devices irq not just when the input device is 82 * open. This is useful when devices have a watchdog which prevents us 83 * from periodically polling the device. Leave this unset unless your 84 * touchscreen device requires it, as it does consume more of the USB 85 * bandwidth. 86 */ 87 bool irq_always; 88 89 void (*process_pkt) (struct usbtouch_usb *usbtouch, unsigned char *pkt, int len); 90 91 /* 92 * used to get the packet len. possible return values: 93 * > 0: packet len 94 * = 0: skip one byte 95 * < 0: -return value more bytes needed 96 */ 97 int (*get_pkt_len) (unsigned char *pkt, int len); 98 99 int (*read_data) (struct usbtouch_usb *usbtouch, unsigned char *pkt); 100 int (*alloc) (struct usbtouch_usb *usbtouch); 101 int (*init) (struct usbtouch_usb *usbtouch); 102 void (*exit) (struct usbtouch_usb *usbtouch); 103 }; 104 105 /* a usbtouch device */ 106 struct usbtouch_usb { 107 unsigned char *data; 108 dma_addr_t data_dma; 109 unsigned char *buffer; 110 int buf_len; 111 struct urb *irq; 112 struct usb_interface *interface; 113 struct input_dev *input; 114 struct usbtouch_device_info *type; 115 char name[128]; 116 char phys[64]; 117 void *priv; 118 119 int x, y; 120 int touch, press; 121 }; 122 123 124 /* device types */ 125 enum { 126 DEVTYPE_IGNORE = -1, 127 DEVTYPE_EGALAX, 128 DEVTYPE_PANJIT, 129 DEVTYPE_3M, 130 DEVTYPE_ITM, 131 DEVTYPE_ETURBO, 132 DEVTYPE_GUNZE, 133 DEVTYPE_DMC_TSC10, 134 DEVTYPE_IRTOUCH, 135 DEVTYPE_IDEALTEK, 136 DEVTYPE_GENERAL_TOUCH, 137 DEVTYPE_GOTOP, 138 DEVTYPE_JASTEC, 139 DEVTYPE_E2I, 140 DEVTYPE_ZYTRONIC, 141 DEVTYPE_TC45USB, 142 DEVTYPE_NEXIO, 143 DEVTYPE_ELO, 144 DEVTYPE_ETOUCH, 145 }; 146 147 #define USB_DEVICE_HID_CLASS(vend, prod) \ 148 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS \ 149 | USB_DEVICE_ID_MATCH_INT_PROTOCOL \ 150 | USB_DEVICE_ID_MATCH_DEVICE, \ 151 .idVendor = (vend), \ 152 .idProduct = (prod), \ 153 .bInterfaceClass = USB_INTERFACE_CLASS_HID, \ 154 .bInterfaceProtocol = USB_INTERFACE_PROTOCOL_MOUSE 155 156 static const struct usb_device_id usbtouch_devices[] = { 157 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX 158 /* ignore the HID capable devices, handled by usbhid */ 159 {USB_DEVICE_HID_CLASS(0x0eef, 0x0001), .driver_info = DEVTYPE_IGNORE}, 160 {USB_DEVICE_HID_CLASS(0x0eef, 0x0002), .driver_info = DEVTYPE_IGNORE}, 161 162 /* normal device IDs */ 163 {USB_DEVICE(0x3823, 0x0001), .driver_info = DEVTYPE_EGALAX}, 164 {USB_DEVICE(0x3823, 0x0002), .driver_info = DEVTYPE_EGALAX}, 165 {USB_DEVICE(0x0123, 0x0001), .driver_info = DEVTYPE_EGALAX}, 166 {USB_DEVICE(0x0eef, 0x0001), .driver_info = DEVTYPE_EGALAX}, 167 {USB_DEVICE(0x0eef, 0x0002), .driver_info = DEVTYPE_EGALAX}, 168 {USB_DEVICE(0x1234, 0x0001), .driver_info = DEVTYPE_EGALAX}, 169 {USB_DEVICE(0x1234, 0x0002), .driver_info = DEVTYPE_EGALAX}, 170 #endif 171 172 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT 173 {USB_DEVICE(0x134c, 0x0001), .driver_info = DEVTYPE_PANJIT}, 174 {USB_DEVICE(0x134c, 0x0002), .driver_info = DEVTYPE_PANJIT}, 175 {USB_DEVICE(0x134c, 0x0003), .driver_info = DEVTYPE_PANJIT}, 176 {USB_DEVICE(0x134c, 0x0004), .driver_info = DEVTYPE_PANJIT}, 177 #endif 178 179 #ifdef CONFIG_TOUCHSCREEN_USB_3M 180 {USB_DEVICE(0x0596, 0x0001), .driver_info = DEVTYPE_3M}, 181 #endif 182 183 #ifdef CONFIG_TOUCHSCREEN_USB_ITM 184 {USB_DEVICE(0x0403, 0xf9e9), .driver_info = DEVTYPE_ITM}, 185 {USB_DEVICE(0x16e3, 0xf9e9), .driver_info = DEVTYPE_ITM}, 186 #endif 187 188 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO 189 {USB_DEVICE(0x1234, 0x5678), .driver_info = DEVTYPE_ETURBO}, 190 #endif 191 192 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE 193 {USB_DEVICE(0x0637, 0x0001), .driver_info = DEVTYPE_GUNZE}, 194 #endif 195 196 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10 197 {USB_DEVICE(0x0afa, 0x03e8), .driver_info = DEVTYPE_DMC_TSC10}, 198 #endif 199 200 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 201 {USB_DEVICE(0x595a, 0x0001), .driver_info = DEVTYPE_IRTOUCH}, 202 {USB_DEVICE(0x6615, 0x0001), .driver_info = DEVTYPE_IRTOUCH}, 203 #endif 204 205 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 206 {USB_DEVICE(0x1391, 0x1000), .driver_info = DEVTYPE_IDEALTEK}, 207 #endif 208 209 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 210 {USB_DEVICE(0x0dfc, 0x0001), .driver_info = DEVTYPE_GENERAL_TOUCH}, 211 #endif 212 213 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 214 {USB_DEVICE(0x08f2, 0x007f), .driver_info = DEVTYPE_GOTOP}, 215 {USB_DEVICE(0x08f2, 0x00ce), .driver_info = DEVTYPE_GOTOP}, 216 {USB_DEVICE(0x08f2, 0x00f4), .driver_info = DEVTYPE_GOTOP}, 217 #endif 218 219 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC 220 {USB_DEVICE(0x0f92, 0x0001), .driver_info = DEVTYPE_JASTEC}, 221 #endif 222 223 #ifdef CONFIG_TOUCHSCREEN_USB_E2I 224 {USB_DEVICE(0x1ac7, 0x0001), .driver_info = DEVTYPE_E2I}, 225 #endif 226 227 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC 228 {USB_DEVICE(0x14c8, 0x0003), .driver_info = DEVTYPE_ZYTRONIC}, 229 #endif 230 231 #ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB 232 /* TC5UH */ 233 {USB_DEVICE(0x0664, 0x0309), .driver_info = DEVTYPE_TC45USB}, 234 /* TC4UM */ 235 {USB_DEVICE(0x0664, 0x0306), .driver_info = DEVTYPE_TC45USB}, 236 #endif 237 238 #ifdef CONFIG_TOUCHSCREEN_USB_NEXIO 239 /* data interface only */ 240 {USB_DEVICE_AND_INTERFACE_INFO(0x10f0, 0x2002, 0x0a, 0x00, 0x00), 241 .driver_info = DEVTYPE_NEXIO}, 242 {USB_DEVICE_AND_INTERFACE_INFO(0x1870, 0x0001, 0x0a, 0x00, 0x00), 243 .driver_info = DEVTYPE_NEXIO}, 244 #endif 245 246 #ifdef CONFIG_TOUCHSCREEN_USB_ELO 247 {USB_DEVICE(0x04e7, 0x0020), .driver_info = DEVTYPE_ELO}, 248 #endif 249 250 #ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH 251 {USB_DEVICE(0x7374, 0x0001), .driver_info = DEVTYPE_ETOUCH}, 252 #endif 253 254 {} 255 }; 256 257 258 /***************************************************************************** 259 * e2i Part 260 */ 261 262 #ifdef CONFIG_TOUCHSCREEN_USB_E2I 263 static int e2i_init(struct usbtouch_usb *usbtouch) 264 { 265 int ret; 266 struct usb_device *udev = interface_to_usbdev(usbtouch->interface); 267 268 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 269 0x01, 0x02, 0x0000, 0x0081, 270 NULL, 0, USB_CTRL_SET_TIMEOUT); 271 272 dev_dbg(&usbtouch->interface->dev, 273 "%s - usb_control_msg - E2I_RESET - bytes|err: %d\n", 274 __func__, ret); 275 return ret; 276 } 277 278 static int e2i_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 279 { 280 int tmp = (pkt[0] << 8) | pkt[1]; 281 dev->x = (pkt[2] << 8) | pkt[3]; 282 dev->y = (pkt[4] << 8) | pkt[5]; 283 284 tmp = tmp - 0xA000; 285 dev->touch = (tmp > 0); 286 dev->press = (tmp > 0 ? tmp : 0); 287 288 return 1; 289 } 290 #endif 291 292 293 /***************************************************************************** 294 * eGalax part 295 */ 296 297 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX 298 299 #ifndef MULTI_PACKET 300 #define MULTI_PACKET 301 #endif 302 303 #define EGALAX_PKT_TYPE_MASK 0xFE 304 #define EGALAX_PKT_TYPE_REPT 0x80 305 #define EGALAX_PKT_TYPE_DIAG 0x0A 306 307 static int egalax_init(struct usbtouch_usb *usbtouch) 308 { 309 int ret, i; 310 unsigned char *buf; 311 struct usb_device *udev = interface_to_usbdev(usbtouch->interface); 312 313 /* 314 * An eGalax diagnostic packet kicks the device into using the right 315 * protocol. We send a "check active" packet. The response will be 316 * read later and ignored. 317 */ 318 319 buf = kmalloc(3, GFP_KERNEL); 320 if (!buf) 321 return -ENOMEM; 322 323 buf[0] = EGALAX_PKT_TYPE_DIAG; 324 buf[1] = 1; /* length */ 325 buf[2] = 'A'; /* command - check active */ 326 327 for (i = 0; i < 3; i++) { 328 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 329 0, 330 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 331 0, 0, buf, 3, 332 USB_CTRL_SET_TIMEOUT); 333 if (ret >= 0) { 334 ret = 0; 335 break; 336 } 337 if (ret != -EPIPE) 338 break; 339 } 340 341 kfree(buf); 342 343 return ret; 344 } 345 346 static int egalax_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 347 { 348 if ((pkt[0] & EGALAX_PKT_TYPE_MASK) != EGALAX_PKT_TYPE_REPT) 349 return 0; 350 351 dev->x = ((pkt[3] & 0x0F) << 7) | (pkt[4] & 0x7F); 352 dev->y = ((pkt[1] & 0x0F) << 7) | (pkt[2] & 0x7F); 353 dev->touch = pkt[0] & 0x01; 354 355 return 1; 356 } 357 358 static int egalax_get_pkt_len(unsigned char *buf, int len) 359 { 360 switch (buf[0] & EGALAX_PKT_TYPE_MASK) { 361 case EGALAX_PKT_TYPE_REPT: 362 return 5; 363 364 case EGALAX_PKT_TYPE_DIAG: 365 if (len < 2) 366 return -1; 367 368 return buf[1] + 2; 369 } 370 371 return 0; 372 } 373 #endif 374 375 /***************************************************************************** 376 * EasyTouch part 377 */ 378 379 #ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH 380 381 #ifndef MULTI_PACKET 382 #define MULTI_PACKET 383 #endif 384 385 #define ETOUCH_PKT_TYPE_MASK 0xFE 386 #define ETOUCH_PKT_TYPE_REPT 0x80 387 #define ETOUCH_PKT_TYPE_REPT2 0xB0 388 #define ETOUCH_PKT_TYPE_DIAG 0x0A 389 390 static int etouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 391 { 392 if ((pkt[0] & ETOUCH_PKT_TYPE_MASK) != ETOUCH_PKT_TYPE_REPT && 393 (pkt[0] & ETOUCH_PKT_TYPE_MASK) != ETOUCH_PKT_TYPE_REPT2) 394 return 0; 395 396 dev->x = ((pkt[1] & 0x1F) << 7) | (pkt[2] & 0x7F); 397 dev->y = ((pkt[3] & 0x1F) << 7) | (pkt[4] & 0x7F); 398 dev->touch = pkt[0] & 0x01; 399 400 return 1; 401 } 402 403 static int etouch_get_pkt_len(unsigned char *buf, int len) 404 { 405 switch (buf[0] & ETOUCH_PKT_TYPE_MASK) { 406 case ETOUCH_PKT_TYPE_REPT: 407 case ETOUCH_PKT_TYPE_REPT2: 408 return 5; 409 410 case ETOUCH_PKT_TYPE_DIAG: 411 if (len < 2) 412 return -1; 413 414 return buf[1] + 2; 415 } 416 417 return 0; 418 } 419 #endif 420 421 /***************************************************************************** 422 * PanJit Part 423 */ 424 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT 425 static int panjit_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 426 { 427 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1]; 428 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3]; 429 dev->touch = pkt[0] & 0x01; 430 431 return 1; 432 } 433 #endif 434 435 436 /***************************************************************************** 437 * 3M/Microtouch Part 438 */ 439 #ifdef CONFIG_TOUCHSCREEN_USB_3M 440 441 #define MTOUCHUSB_ASYNC_REPORT 1 442 #define MTOUCHUSB_RESET 7 443 #define MTOUCHUSB_REQ_CTRLLR_ID 10 444 445 static int mtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 446 { 447 if (hwcalib_xy) { 448 dev->x = (pkt[4] << 8) | pkt[3]; 449 dev->y = 0xffff - ((pkt[6] << 8) | pkt[5]); 450 } else { 451 dev->x = (pkt[8] << 8) | pkt[7]; 452 dev->y = (pkt[10] << 8) | pkt[9]; 453 } 454 dev->touch = (pkt[2] & 0x40) ? 1 : 0; 455 456 return 1; 457 } 458 459 static int mtouch_init(struct usbtouch_usb *usbtouch) 460 { 461 int ret, i; 462 struct usb_device *udev = interface_to_usbdev(usbtouch->interface); 463 464 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 465 MTOUCHUSB_RESET, 466 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 467 1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT); 468 dev_dbg(&usbtouch->interface->dev, 469 "%s - usb_control_msg - MTOUCHUSB_RESET - bytes|err: %d\n", 470 __func__, ret); 471 if (ret < 0) 472 return ret; 473 msleep(150); 474 475 for (i = 0; i < 3; i++) { 476 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 477 MTOUCHUSB_ASYNC_REPORT, 478 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 479 1, 1, NULL, 0, USB_CTRL_SET_TIMEOUT); 480 dev_dbg(&usbtouch->interface->dev, 481 "%s - usb_control_msg - MTOUCHUSB_ASYNC_REPORT - bytes|err: %d\n", 482 __func__, ret); 483 if (ret >= 0) 484 break; 485 if (ret != -EPIPE) 486 return ret; 487 } 488 489 /* Default min/max xy are the raw values, override if using hw-calib */ 490 if (hwcalib_xy) { 491 input_set_abs_params(usbtouch->input, ABS_X, 0, 0xffff, 0, 0); 492 input_set_abs_params(usbtouch->input, ABS_Y, 0, 0xffff, 0, 0); 493 } 494 495 return 0; 496 } 497 #endif 498 499 500 /***************************************************************************** 501 * ITM Part 502 */ 503 #ifdef CONFIG_TOUCHSCREEN_USB_ITM 504 static int itm_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 505 { 506 int touch; 507 /* 508 * ITM devices report invalid x/y data if not touched. 509 * if the screen was touched before but is not touched any more 510 * report touch as 0 with the last valid x/y data once. then stop 511 * reporting data until touched again. 512 */ 513 dev->press = ((pkt[2] & 0x01) << 7) | (pkt[5] & 0x7F); 514 515 touch = ~pkt[7] & 0x20; 516 if (!touch) { 517 if (dev->touch) { 518 dev->touch = 0; 519 return 1; 520 } 521 522 return 0; 523 } 524 525 dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[3] & 0x7F); 526 dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[4] & 0x7F); 527 dev->touch = touch; 528 529 return 1; 530 } 531 #endif 532 533 534 /***************************************************************************** 535 * eTurboTouch part 536 */ 537 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO 538 #ifndef MULTI_PACKET 539 #define MULTI_PACKET 540 #endif 541 static int eturbo_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 542 { 543 unsigned int shift; 544 545 /* packets should start with sync */ 546 if (!(pkt[0] & 0x80)) 547 return 0; 548 549 shift = (6 - (pkt[0] & 0x03)); 550 dev->x = ((pkt[3] << 7) | pkt[4]) >> shift; 551 dev->y = ((pkt[1] << 7) | pkt[2]) >> shift; 552 dev->touch = (pkt[0] & 0x10) ? 1 : 0; 553 554 return 1; 555 } 556 557 static int eturbo_get_pkt_len(unsigned char *buf, int len) 558 { 559 if (buf[0] & 0x80) 560 return 5; 561 if (buf[0] == 0x01) 562 return 3; 563 return 0; 564 } 565 #endif 566 567 568 /***************************************************************************** 569 * Gunze part 570 */ 571 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE 572 static int gunze_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 573 { 574 if (!(pkt[0] & 0x80) || ((pkt[1] | pkt[2] | pkt[3]) & 0x80)) 575 return 0; 576 577 dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[2] & 0x7F); 578 dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[3] & 0x7F); 579 dev->touch = pkt[0] & 0x20; 580 581 return 1; 582 } 583 #endif 584 585 /***************************************************************************** 586 * DMC TSC-10/25 Part 587 * 588 * Documentation about the controller and it's protocol can be found at 589 * http://www.dmccoltd.com/files/controler/tsc10usb_pi_e.pdf 590 * http://www.dmccoltd.com/files/controler/tsc25_usb_e.pdf 591 */ 592 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10 593 594 /* supported data rates. currently using 130 */ 595 #define TSC10_RATE_POINT 0x50 596 #define TSC10_RATE_30 0x40 597 #define TSC10_RATE_50 0x41 598 #define TSC10_RATE_80 0x42 599 #define TSC10_RATE_100 0x43 600 #define TSC10_RATE_130 0x44 601 #define TSC10_RATE_150 0x45 602 603 /* commands */ 604 #define TSC10_CMD_RESET 0x55 605 #define TSC10_CMD_RATE 0x05 606 #define TSC10_CMD_DATA1 0x01 607 608 static int dmc_tsc10_init(struct usbtouch_usb *usbtouch) 609 { 610 struct usb_device *dev = interface_to_usbdev(usbtouch->interface); 611 int ret = -ENOMEM; 612 unsigned char *buf; 613 614 buf = kmalloc(2, GFP_NOIO); 615 if (!buf) 616 goto err_nobuf; 617 /* reset */ 618 buf[0] = buf[1] = 0xFF; 619 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 620 TSC10_CMD_RESET, 621 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 622 0, 0, buf, 2, USB_CTRL_SET_TIMEOUT); 623 if (ret < 0) 624 goto err_out; 625 if (buf[0] != 0x06) { 626 ret = -ENODEV; 627 goto err_out; 628 } 629 630 /* set coordinate output rate */ 631 buf[0] = buf[1] = 0xFF; 632 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 633 TSC10_CMD_RATE, 634 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 635 TSC10_RATE_150, 0, buf, 2, USB_CTRL_SET_TIMEOUT); 636 if (ret < 0) 637 goto err_out; 638 if ((buf[0] != 0x06) && (buf[0] != 0x15 || buf[1] != 0x01)) { 639 ret = -ENODEV; 640 goto err_out; 641 } 642 643 /* start sending data */ 644 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 645 TSC10_CMD_DATA1, 646 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 647 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT); 648 err_out: 649 kfree(buf); 650 err_nobuf: 651 return ret; 652 } 653 654 655 static int dmc_tsc10_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 656 { 657 dev->x = ((pkt[2] & 0x03) << 8) | pkt[1]; 658 dev->y = ((pkt[4] & 0x03) << 8) | pkt[3]; 659 dev->touch = pkt[0] & 0x01; 660 661 return 1; 662 } 663 #endif 664 665 666 /***************************************************************************** 667 * IRTOUCH Part 668 */ 669 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 670 static int irtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 671 { 672 dev->x = (pkt[3] << 8) | pkt[2]; 673 dev->y = (pkt[5] << 8) | pkt[4]; 674 dev->touch = (pkt[1] & 0x03) ? 1 : 0; 675 676 return 1; 677 } 678 #endif 679 680 /***************************************************************************** 681 * ET&T TC5UH/TC4UM part 682 */ 683 #ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB 684 static int tc45usb_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 685 { 686 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1]; 687 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3]; 688 dev->touch = pkt[0] & 0x01; 689 690 return 1; 691 } 692 #endif 693 694 /***************************************************************************** 695 * IdealTEK URTC1000 Part 696 */ 697 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 698 #ifndef MULTI_PACKET 699 #define MULTI_PACKET 700 #endif 701 static int idealtek_get_pkt_len(unsigned char *buf, int len) 702 { 703 if (buf[0] & 0x80) 704 return 5; 705 if (buf[0] == 0x01) 706 return len; 707 return 0; 708 } 709 710 static int idealtek_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 711 { 712 switch (pkt[0] & 0x98) { 713 case 0x88: 714 /* touch data in IdealTEK mode */ 715 dev->x = (pkt[1] << 5) | (pkt[2] >> 2); 716 dev->y = (pkt[3] << 5) | (pkt[4] >> 2); 717 dev->touch = (pkt[0] & 0x40) ? 1 : 0; 718 return 1; 719 720 case 0x98: 721 /* touch data in MT emulation mode */ 722 dev->x = (pkt[2] << 5) | (pkt[1] >> 2); 723 dev->y = (pkt[4] << 5) | (pkt[3] >> 2); 724 dev->touch = (pkt[0] & 0x40) ? 1 : 0; 725 return 1; 726 727 default: 728 return 0; 729 } 730 } 731 #endif 732 733 /***************************************************************************** 734 * General Touch Part 735 */ 736 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 737 static int general_touch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 738 { 739 dev->x = (pkt[2] << 8) | pkt[1]; 740 dev->y = (pkt[4] << 8) | pkt[3]; 741 dev->press = pkt[5] & 0xff; 742 dev->touch = pkt[0] & 0x01; 743 744 return 1; 745 } 746 #endif 747 748 /***************************************************************************** 749 * GoTop Part 750 */ 751 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 752 static int gotop_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 753 { 754 dev->x = ((pkt[1] & 0x38) << 4) | pkt[2]; 755 dev->y = ((pkt[1] & 0x07) << 7) | pkt[3]; 756 dev->touch = pkt[0] & 0x01; 757 758 return 1; 759 } 760 #endif 761 762 /***************************************************************************** 763 * JASTEC Part 764 */ 765 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC 766 static int jastec_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 767 { 768 dev->x = ((pkt[0] & 0x3f) << 6) | (pkt[2] & 0x3f); 769 dev->y = ((pkt[1] & 0x3f) << 6) | (pkt[3] & 0x3f); 770 dev->touch = (pkt[0] & 0x40) >> 6; 771 772 return 1; 773 } 774 #endif 775 776 /***************************************************************************** 777 * Zytronic Part 778 */ 779 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC 780 static int zytronic_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 781 { 782 struct usb_interface *intf = dev->interface; 783 784 switch (pkt[0]) { 785 case 0x3A: /* command response */ 786 dev_dbg(&intf->dev, "%s: Command response %d\n", __func__, pkt[1]); 787 break; 788 789 case 0xC0: /* down */ 790 dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7); 791 dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7); 792 dev->touch = 1; 793 dev_dbg(&intf->dev, "%s: down %d,%d\n", __func__, dev->x, dev->y); 794 return 1; 795 796 case 0x80: /* up */ 797 dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7); 798 dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7); 799 dev->touch = 0; 800 dev_dbg(&intf->dev, "%s: up %d,%d\n", __func__, dev->x, dev->y); 801 return 1; 802 803 default: 804 dev_dbg(&intf->dev, "%s: Unknown return %d\n", __func__, pkt[0]); 805 break; 806 } 807 808 return 0; 809 } 810 #endif 811 812 /***************************************************************************** 813 * NEXIO Part 814 */ 815 #ifdef CONFIG_TOUCHSCREEN_USB_NEXIO 816 817 #define NEXIO_TIMEOUT 5000 818 #define NEXIO_BUFSIZE 1024 819 #define NEXIO_THRESHOLD 50 820 821 struct nexio_priv { 822 struct urb *ack; 823 unsigned char *ack_buf; 824 }; 825 826 struct nexio_touch_packet { 827 u8 flags; /* 0xe1 = touch, 0xe1 = release */ 828 __be16 data_len; /* total bytes of touch data */ 829 __be16 x_len; /* bytes for X axis */ 830 __be16 y_len; /* bytes for Y axis */ 831 u8 data[]; 832 } __attribute__ ((packed)); 833 834 static unsigned char nexio_ack_pkt[2] = { 0xaa, 0x02 }; 835 static unsigned char nexio_init_pkt[4] = { 0x82, 0x04, 0x0a, 0x0f }; 836 837 static void nexio_ack_complete(struct urb *urb) 838 { 839 } 840 841 static int nexio_alloc(struct usbtouch_usb *usbtouch) 842 { 843 struct nexio_priv *priv; 844 int ret = -ENOMEM; 845 846 usbtouch->priv = kmalloc(sizeof(struct nexio_priv), GFP_KERNEL); 847 if (!usbtouch->priv) 848 goto out_buf; 849 850 priv = usbtouch->priv; 851 852 priv->ack_buf = kmemdup(nexio_ack_pkt, sizeof(nexio_ack_pkt), 853 GFP_KERNEL); 854 if (!priv->ack_buf) 855 goto err_priv; 856 857 priv->ack = usb_alloc_urb(0, GFP_KERNEL); 858 if (!priv->ack) { 859 dev_dbg(&usbtouch->interface->dev, 860 "%s - usb_alloc_urb failed: usbtouch->ack\n", __func__); 861 goto err_ack_buf; 862 } 863 864 return 0; 865 866 err_ack_buf: 867 kfree(priv->ack_buf); 868 err_priv: 869 kfree(priv); 870 out_buf: 871 return ret; 872 } 873 874 static int nexio_init(struct usbtouch_usb *usbtouch) 875 { 876 struct usb_device *dev = interface_to_usbdev(usbtouch->interface); 877 struct usb_host_interface *interface = usbtouch->interface->cur_altsetting; 878 struct nexio_priv *priv = usbtouch->priv; 879 int ret = -ENOMEM; 880 int actual_len, i; 881 unsigned char *buf; 882 char *firmware_ver = NULL, *device_name = NULL; 883 int input_ep = 0, output_ep = 0; 884 885 /* find first input and output endpoint */ 886 for (i = 0; i < interface->desc.bNumEndpoints; i++) { 887 if (!input_ep && 888 usb_endpoint_dir_in(&interface->endpoint[i].desc)) 889 input_ep = interface->endpoint[i].desc.bEndpointAddress; 890 if (!output_ep && 891 usb_endpoint_dir_out(&interface->endpoint[i].desc)) 892 output_ep = interface->endpoint[i].desc.bEndpointAddress; 893 } 894 if (!input_ep || !output_ep) 895 return -ENXIO; 896 897 buf = kmalloc(NEXIO_BUFSIZE, GFP_NOIO); 898 if (!buf) 899 goto out_buf; 900 901 /* two empty reads */ 902 for (i = 0; i < 2; i++) { 903 ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, input_ep), 904 buf, NEXIO_BUFSIZE, &actual_len, 905 NEXIO_TIMEOUT); 906 if (ret < 0) 907 goto out_buf; 908 } 909 910 /* send init command */ 911 memcpy(buf, nexio_init_pkt, sizeof(nexio_init_pkt)); 912 ret = usb_bulk_msg(dev, usb_sndbulkpipe(dev, output_ep), 913 buf, sizeof(nexio_init_pkt), &actual_len, 914 NEXIO_TIMEOUT); 915 if (ret < 0) 916 goto out_buf; 917 918 /* read replies */ 919 for (i = 0; i < 3; i++) { 920 memset(buf, 0, NEXIO_BUFSIZE); 921 ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, input_ep), 922 buf, NEXIO_BUFSIZE, &actual_len, 923 NEXIO_TIMEOUT); 924 if (ret < 0 || actual_len < 1 || buf[1] != actual_len) 925 continue; 926 switch (buf[0]) { 927 case 0x83: /* firmware version */ 928 if (!firmware_ver) 929 firmware_ver = kstrdup(&buf[2], GFP_NOIO); 930 break; 931 case 0x84: /* device name */ 932 if (!device_name) 933 device_name = kstrdup(&buf[2], GFP_NOIO); 934 break; 935 } 936 } 937 938 printk(KERN_INFO "Nexio device: %s, firmware version: %s\n", 939 device_name, firmware_ver); 940 941 kfree(firmware_ver); 942 kfree(device_name); 943 944 usb_fill_bulk_urb(priv->ack, dev, usb_sndbulkpipe(dev, output_ep), 945 priv->ack_buf, sizeof(nexio_ack_pkt), 946 nexio_ack_complete, usbtouch); 947 ret = 0; 948 949 out_buf: 950 kfree(buf); 951 return ret; 952 } 953 954 static void nexio_exit(struct usbtouch_usb *usbtouch) 955 { 956 struct nexio_priv *priv = usbtouch->priv; 957 958 usb_kill_urb(priv->ack); 959 usb_free_urb(priv->ack); 960 kfree(priv->ack_buf); 961 kfree(priv); 962 } 963 964 static int nexio_read_data(struct usbtouch_usb *usbtouch, unsigned char *pkt) 965 { 966 struct nexio_touch_packet *packet = (void *) pkt; 967 struct nexio_priv *priv = usbtouch->priv; 968 unsigned int data_len = be16_to_cpu(packet->data_len); 969 unsigned int x_len = be16_to_cpu(packet->x_len); 970 unsigned int y_len = be16_to_cpu(packet->y_len); 971 int x, y, begin_x, begin_y, end_x, end_y, w, h, ret; 972 973 /* got touch data? */ 974 if ((pkt[0] & 0xe0) != 0xe0) 975 return 0; 976 977 if (data_len > 0xff) 978 data_len -= 0x100; 979 if (x_len > 0xff) 980 x_len -= 0x80; 981 982 /* send ACK */ 983 ret = usb_submit_urb(priv->ack, GFP_ATOMIC); 984 985 if (!usbtouch->type->max_xc) { 986 usbtouch->type->max_xc = 2 * x_len; 987 input_set_abs_params(usbtouch->input, ABS_X, 988 0, usbtouch->type->max_xc, 0, 0); 989 usbtouch->type->max_yc = 2 * y_len; 990 input_set_abs_params(usbtouch->input, ABS_Y, 991 0, usbtouch->type->max_yc, 0, 0); 992 } 993 /* 994 * The device reports state of IR sensors on X and Y axes. 995 * Each byte represents "darkness" percentage (0-100) of one element. 996 * 17" touchscreen reports only 64 x 52 bytes so the resolution is low. 997 * This also means that there's a limited multi-touch capability but 998 * it's disabled (and untested) here as there's no X driver for that. 999 */ 1000 begin_x = end_x = begin_y = end_y = -1; 1001 for (x = 0; x < x_len; x++) { 1002 if (begin_x == -1 && packet->data[x] > NEXIO_THRESHOLD) { 1003 begin_x = x; 1004 continue; 1005 } 1006 if (end_x == -1 && begin_x != -1 && packet->data[x] < NEXIO_THRESHOLD) { 1007 end_x = x - 1; 1008 for (y = x_len; y < data_len; y++) { 1009 if (begin_y == -1 && packet->data[y] > NEXIO_THRESHOLD) { 1010 begin_y = y - x_len; 1011 continue; 1012 } 1013 if (end_y == -1 && 1014 begin_y != -1 && packet->data[y] < NEXIO_THRESHOLD) { 1015 end_y = y - 1 - x_len; 1016 w = end_x - begin_x; 1017 h = end_y - begin_y; 1018 #if 0 1019 /* multi-touch */ 1020 input_report_abs(usbtouch->input, 1021 ABS_MT_TOUCH_MAJOR, max(w,h)); 1022 input_report_abs(usbtouch->input, 1023 ABS_MT_TOUCH_MINOR, min(x,h)); 1024 input_report_abs(usbtouch->input, 1025 ABS_MT_POSITION_X, 2*begin_x+w); 1026 input_report_abs(usbtouch->input, 1027 ABS_MT_POSITION_Y, 2*begin_y+h); 1028 input_report_abs(usbtouch->input, 1029 ABS_MT_ORIENTATION, w > h); 1030 input_mt_sync(usbtouch->input); 1031 #endif 1032 /* single touch */ 1033 usbtouch->x = 2 * begin_x + w; 1034 usbtouch->y = 2 * begin_y + h; 1035 usbtouch->touch = packet->flags & 0x01; 1036 begin_y = end_y = -1; 1037 return 1; 1038 } 1039 } 1040 begin_x = end_x = -1; 1041 } 1042 1043 } 1044 return 0; 1045 } 1046 #endif 1047 1048 1049 /***************************************************************************** 1050 * ELO part 1051 */ 1052 1053 #ifdef CONFIG_TOUCHSCREEN_USB_ELO 1054 1055 static int elo_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 1056 { 1057 dev->x = (pkt[3] << 8) | pkt[2]; 1058 dev->y = (pkt[5] << 8) | pkt[4]; 1059 dev->touch = pkt[6] > 0; 1060 dev->press = pkt[6]; 1061 1062 return 1; 1063 } 1064 #endif 1065 1066 1067 /***************************************************************************** 1068 * the different device descriptors 1069 */ 1070 #ifdef MULTI_PACKET 1071 static void usbtouch_process_multi(struct usbtouch_usb *usbtouch, 1072 unsigned char *pkt, int len); 1073 #endif 1074 1075 static struct usbtouch_device_info usbtouch_dev_info[] = { 1076 #ifdef CONFIG_TOUCHSCREEN_USB_ELO 1077 [DEVTYPE_ELO] = { 1078 .min_xc = 0x0, 1079 .max_xc = 0x0fff, 1080 .min_yc = 0x0, 1081 .max_yc = 0x0fff, 1082 .max_press = 0xff, 1083 .rept_size = 8, 1084 .read_data = elo_read_data, 1085 }, 1086 #endif 1087 1088 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX 1089 [DEVTYPE_EGALAX] = { 1090 .min_xc = 0x0, 1091 .max_xc = 0x07ff, 1092 .min_yc = 0x0, 1093 .max_yc = 0x07ff, 1094 .rept_size = 16, 1095 .process_pkt = usbtouch_process_multi, 1096 .get_pkt_len = egalax_get_pkt_len, 1097 .read_data = egalax_read_data, 1098 .init = egalax_init, 1099 }, 1100 #endif 1101 1102 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT 1103 [DEVTYPE_PANJIT] = { 1104 .min_xc = 0x0, 1105 .max_xc = 0x0fff, 1106 .min_yc = 0x0, 1107 .max_yc = 0x0fff, 1108 .rept_size = 8, 1109 .read_data = panjit_read_data, 1110 }, 1111 #endif 1112 1113 #ifdef CONFIG_TOUCHSCREEN_USB_3M 1114 [DEVTYPE_3M] = { 1115 .min_xc = 0x0, 1116 .max_xc = 0x4000, 1117 .min_yc = 0x0, 1118 .max_yc = 0x4000, 1119 .rept_size = 11, 1120 .read_data = mtouch_read_data, 1121 .init = mtouch_init, 1122 }, 1123 #endif 1124 1125 #ifdef CONFIG_TOUCHSCREEN_USB_ITM 1126 [DEVTYPE_ITM] = { 1127 .min_xc = 0x0, 1128 .max_xc = 0x0fff, 1129 .min_yc = 0x0, 1130 .max_yc = 0x0fff, 1131 .max_press = 0xff, 1132 .rept_size = 8, 1133 .read_data = itm_read_data, 1134 }, 1135 #endif 1136 1137 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO 1138 [DEVTYPE_ETURBO] = { 1139 .min_xc = 0x0, 1140 .max_xc = 0x07ff, 1141 .min_yc = 0x0, 1142 .max_yc = 0x07ff, 1143 .rept_size = 8, 1144 .process_pkt = usbtouch_process_multi, 1145 .get_pkt_len = eturbo_get_pkt_len, 1146 .read_data = eturbo_read_data, 1147 }, 1148 #endif 1149 1150 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE 1151 [DEVTYPE_GUNZE] = { 1152 .min_xc = 0x0, 1153 .max_xc = 0x0fff, 1154 .min_yc = 0x0, 1155 .max_yc = 0x0fff, 1156 .rept_size = 4, 1157 .read_data = gunze_read_data, 1158 }, 1159 #endif 1160 1161 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10 1162 [DEVTYPE_DMC_TSC10] = { 1163 .min_xc = 0x0, 1164 .max_xc = 0x03ff, 1165 .min_yc = 0x0, 1166 .max_yc = 0x03ff, 1167 .rept_size = 5, 1168 .init = dmc_tsc10_init, 1169 .read_data = dmc_tsc10_read_data, 1170 }, 1171 #endif 1172 1173 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 1174 [DEVTYPE_IRTOUCH] = { 1175 .min_xc = 0x0, 1176 .max_xc = 0x0fff, 1177 .min_yc = 0x0, 1178 .max_yc = 0x0fff, 1179 .rept_size = 8, 1180 .read_data = irtouch_read_data, 1181 }, 1182 #endif 1183 1184 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 1185 [DEVTYPE_IDEALTEK] = { 1186 .min_xc = 0x0, 1187 .max_xc = 0x0fff, 1188 .min_yc = 0x0, 1189 .max_yc = 0x0fff, 1190 .rept_size = 8, 1191 .process_pkt = usbtouch_process_multi, 1192 .get_pkt_len = idealtek_get_pkt_len, 1193 .read_data = idealtek_read_data, 1194 }, 1195 #endif 1196 1197 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 1198 [DEVTYPE_GENERAL_TOUCH] = { 1199 .min_xc = 0x0, 1200 .max_xc = 0x7fff, 1201 .min_yc = 0x0, 1202 .max_yc = 0x7fff, 1203 .rept_size = 7, 1204 .read_data = general_touch_read_data, 1205 }, 1206 #endif 1207 1208 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 1209 [DEVTYPE_GOTOP] = { 1210 .min_xc = 0x0, 1211 .max_xc = 0x03ff, 1212 .min_yc = 0x0, 1213 .max_yc = 0x03ff, 1214 .rept_size = 4, 1215 .read_data = gotop_read_data, 1216 }, 1217 #endif 1218 1219 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC 1220 [DEVTYPE_JASTEC] = { 1221 .min_xc = 0x0, 1222 .max_xc = 0x0fff, 1223 .min_yc = 0x0, 1224 .max_yc = 0x0fff, 1225 .rept_size = 4, 1226 .read_data = jastec_read_data, 1227 }, 1228 #endif 1229 1230 #ifdef CONFIG_TOUCHSCREEN_USB_E2I 1231 [DEVTYPE_E2I] = { 1232 .min_xc = 0x0, 1233 .max_xc = 0x7fff, 1234 .min_yc = 0x0, 1235 .max_yc = 0x7fff, 1236 .rept_size = 6, 1237 .init = e2i_init, 1238 .read_data = e2i_read_data, 1239 }, 1240 #endif 1241 1242 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC 1243 [DEVTYPE_ZYTRONIC] = { 1244 .min_xc = 0x0, 1245 .max_xc = 0x03ff, 1246 .min_yc = 0x0, 1247 .max_yc = 0x03ff, 1248 .rept_size = 5, 1249 .read_data = zytronic_read_data, 1250 .irq_always = true, 1251 }, 1252 #endif 1253 1254 #ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB 1255 [DEVTYPE_TC45USB] = { 1256 .min_xc = 0x0, 1257 .max_xc = 0x0fff, 1258 .min_yc = 0x0, 1259 .max_yc = 0x0fff, 1260 .rept_size = 5, 1261 .read_data = tc45usb_read_data, 1262 }, 1263 #endif 1264 1265 #ifdef CONFIG_TOUCHSCREEN_USB_NEXIO 1266 [DEVTYPE_NEXIO] = { 1267 .rept_size = 1024, 1268 .irq_always = true, 1269 .read_data = nexio_read_data, 1270 .alloc = nexio_alloc, 1271 .init = nexio_init, 1272 .exit = nexio_exit, 1273 }, 1274 #endif 1275 #ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH 1276 [DEVTYPE_ETOUCH] = { 1277 .min_xc = 0x0, 1278 .max_xc = 0x07ff, 1279 .min_yc = 0x0, 1280 .max_yc = 0x07ff, 1281 .rept_size = 16, 1282 .process_pkt = usbtouch_process_multi, 1283 .get_pkt_len = etouch_get_pkt_len, 1284 .read_data = etouch_read_data, 1285 }, 1286 #endif 1287 }; 1288 1289 1290 /***************************************************************************** 1291 * Generic Part 1292 */ 1293 static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch, 1294 unsigned char *pkt, int len) 1295 { 1296 struct usbtouch_device_info *type = usbtouch->type; 1297 1298 if (!type->read_data(usbtouch, pkt)) 1299 return; 1300 1301 input_report_key(usbtouch->input, BTN_TOUCH, usbtouch->touch); 1302 1303 if (swap_xy) { 1304 input_report_abs(usbtouch->input, ABS_X, usbtouch->y); 1305 input_report_abs(usbtouch->input, ABS_Y, usbtouch->x); 1306 } else { 1307 input_report_abs(usbtouch->input, ABS_X, usbtouch->x); 1308 input_report_abs(usbtouch->input, ABS_Y, usbtouch->y); 1309 } 1310 if (type->max_press) 1311 input_report_abs(usbtouch->input, ABS_PRESSURE, usbtouch->press); 1312 input_sync(usbtouch->input); 1313 } 1314 1315 1316 #ifdef MULTI_PACKET 1317 static void usbtouch_process_multi(struct usbtouch_usb *usbtouch, 1318 unsigned char *pkt, int len) 1319 { 1320 unsigned char *buffer; 1321 int pkt_len, pos, buf_len, tmp; 1322 1323 /* process buffer */ 1324 if (unlikely(usbtouch->buf_len)) { 1325 /* try to get size */ 1326 pkt_len = usbtouch->type->get_pkt_len( 1327 usbtouch->buffer, usbtouch->buf_len); 1328 1329 /* drop? */ 1330 if (unlikely(!pkt_len)) 1331 goto out_flush_buf; 1332 1333 /* need to append -pkt_len bytes before able to get size */ 1334 if (unlikely(pkt_len < 0)) { 1335 int append = -pkt_len; 1336 if (unlikely(append > len)) 1337 append = len; 1338 if (usbtouch->buf_len + append >= usbtouch->type->rept_size) 1339 goto out_flush_buf; 1340 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, append); 1341 usbtouch->buf_len += append; 1342 1343 pkt_len = usbtouch->type->get_pkt_len( 1344 usbtouch->buffer, usbtouch->buf_len); 1345 if (pkt_len < 0) 1346 return; 1347 } 1348 1349 /* append */ 1350 tmp = pkt_len - usbtouch->buf_len; 1351 if (usbtouch->buf_len + tmp >= usbtouch->type->rept_size) 1352 goto out_flush_buf; 1353 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, tmp); 1354 usbtouch_process_pkt(usbtouch, usbtouch->buffer, pkt_len); 1355 1356 buffer = pkt + tmp; 1357 buf_len = len - tmp; 1358 } else { 1359 buffer = pkt; 1360 buf_len = len; 1361 } 1362 1363 /* loop over the received packet, process */ 1364 pos = 0; 1365 while (pos < buf_len) { 1366 /* get packet len */ 1367 pkt_len = usbtouch->type->get_pkt_len(buffer + pos, 1368 buf_len - pos); 1369 1370 /* unknown packet: skip one byte */ 1371 if (unlikely(!pkt_len)) { 1372 pos++; 1373 continue; 1374 } 1375 1376 /* full packet: process */ 1377 if (likely((pkt_len > 0) && (pkt_len <= buf_len - pos))) { 1378 usbtouch_process_pkt(usbtouch, buffer + pos, pkt_len); 1379 } else { 1380 /* incomplete packet: save in buffer */ 1381 memcpy(usbtouch->buffer, buffer + pos, buf_len - pos); 1382 usbtouch->buf_len = buf_len - pos; 1383 return; 1384 } 1385 pos += pkt_len; 1386 } 1387 1388 out_flush_buf: 1389 usbtouch->buf_len = 0; 1390 return; 1391 } 1392 #endif 1393 1394 1395 static void usbtouch_irq(struct urb *urb) 1396 { 1397 struct usbtouch_usb *usbtouch = urb->context; 1398 struct device *dev = &usbtouch->interface->dev; 1399 int retval; 1400 1401 switch (urb->status) { 1402 case 0: 1403 /* success */ 1404 break; 1405 case -ETIME: 1406 /* this urb is timing out */ 1407 dev_dbg(dev, 1408 "%s - urb timed out - was the device unplugged?\n", 1409 __func__); 1410 return; 1411 case -ECONNRESET: 1412 case -ENOENT: 1413 case -ESHUTDOWN: 1414 case -EPIPE: 1415 /* this urb is terminated, clean up */ 1416 dev_dbg(dev, "%s - urb shutting down with status: %d\n", 1417 __func__, urb->status); 1418 return; 1419 default: 1420 dev_dbg(dev, "%s - nonzero urb status received: %d\n", 1421 __func__, urb->status); 1422 goto exit; 1423 } 1424 1425 usbtouch->type->process_pkt(usbtouch, usbtouch->data, urb->actual_length); 1426 1427 exit: 1428 usb_mark_last_busy(interface_to_usbdev(usbtouch->interface)); 1429 retval = usb_submit_urb(urb, GFP_ATOMIC); 1430 if (retval) 1431 dev_err(dev, "%s - usb_submit_urb failed with result: %d\n", 1432 __func__, retval); 1433 } 1434 1435 static int usbtouch_open(struct input_dev *input) 1436 { 1437 struct usbtouch_usb *usbtouch = input_get_drvdata(input); 1438 int r; 1439 1440 usbtouch->irq->dev = interface_to_usbdev(usbtouch->interface); 1441 1442 r = usb_autopm_get_interface(usbtouch->interface) ? -EIO : 0; 1443 if (r < 0) 1444 goto out; 1445 1446 if (!usbtouch->type->irq_always) { 1447 if (usb_submit_urb(usbtouch->irq, GFP_KERNEL)) { 1448 r = -EIO; 1449 goto out_put; 1450 } 1451 } 1452 1453 usbtouch->interface->needs_remote_wakeup = 1; 1454 out_put: 1455 usb_autopm_put_interface(usbtouch->interface); 1456 out: 1457 return r; 1458 } 1459 1460 static void usbtouch_close(struct input_dev *input) 1461 { 1462 struct usbtouch_usb *usbtouch = input_get_drvdata(input); 1463 int r; 1464 1465 if (!usbtouch->type->irq_always) 1466 usb_kill_urb(usbtouch->irq); 1467 r = usb_autopm_get_interface(usbtouch->interface); 1468 usbtouch->interface->needs_remote_wakeup = 0; 1469 if (!r) 1470 usb_autopm_put_interface(usbtouch->interface); 1471 } 1472 1473 static int usbtouch_suspend 1474 (struct usb_interface *intf, pm_message_t message) 1475 { 1476 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1477 1478 usb_kill_urb(usbtouch->irq); 1479 1480 return 0; 1481 } 1482 1483 static int usbtouch_resume(struct usb_interface *intf) 1484 { 1485 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1486 struct input_dev *input = usbtouch->input; 1487 int result = 0; 1488 1489 mutex_lock(&input->mutex); 1490 if (input->users || usbtouch->type->irq_always) 1491 result = usb_submit_urb(usbtouch->irq, GFP_NOIO); 1492 mutex_unlock(&input->mutex); 1493 1494 return result; 1495 } 1496 1497 static int usbtouch_reset_resume(struct usb_interface *intf) 1498 { 1499 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1500 struct input_dev *input = usbtouch->input; 1501 int err = 0; 1502 1503 /* reinit the device */ 1504 if (usbtouch->type->init) { 1505 err = usbtouch->type->init(usbtouch); 1506 if (err) { 1507 dev_dbg(&intf->dev, 1508 "%s - type->init() failed, err: %d\n", 1509 __func__, err); 1510 return err; 1511 } 1512 } 1513 1514 /* restart IO if needed */ 1515 mutex_lock(&input->mutex); 1516 if (input->users) 1517 err = usb_submit_urb(usbtouch->irq, GFP_NOIO); 1518 mutex_unlock(&input->mutex); 1519 1520 return err; 1521 } 1522 1523 static void usbtouch_free_buffers(struct usb_device *udev, 1524 struct usbtouch_usb *usbtouch) 1525 { 1526 usb_free_coherent(udev, usbtouch->type->rept_size, 1527 usbtouch->data, usbtouch->data_dma); 1528 kfree(usbtouch->buffer); 1529 } 1530 1531 static struct usb_endpoint_descriptor * 1532 usbtouch_get_input_endpoint(struct usb_host_interface *interface) 1533 { 1534 int i; 1535 1536 for (i = 0; i < interface->desc.bNumEndpoints; i++) 1537 if (usb_endpoint_dir_in(&interface->endpoint[i].desc)) 1538 return &interface->endpoint[i].desc; 1539 1540 return NULL; 1541 } 1542 1543 static int usbtouch_probe(struct usb_interface *intf, 1544 const struct usb_device_id *id) 1545 { 1546 struct usbtouch_usb *usbtouch; 1547 struct input_dev *input_dev; 1548 struct usb_endpoint_descriptor *endpoint; 1549 struct usb_device *udev = interface_to_usbdev(intf); 1550 struct usbtouch_device_info *type; 1551 int err = -ENOMEM; 1552 1553 /* some devices are ignored */ 1554 if (id->driver_info == DEVTYPE_IGNORE) 1555 return -ENODEV; 1556 1557 endpoint = usbtouch_get_input_endpoint(intf->cur_altsetting); 1558 if (!endpoint) 1559 return -ENXIO; 1560 1561 usbtouch = kzalloc(sizeof(struct usbtouch_usb), GFP_KERNEL); 1562 input_dev = input_allocate_device(); 1563 if (!usbtouch || !input_dev) 1564 goto out_free; 1565 1566 type = &usbtouch_dev_info[id->driver_info]; 1567 usbtouch->type = type; 1568 if (!type->process_pkt) 1569 type->process_pkt = usbtouch_process_pkt; 1570 1571 usbtouch->data = usb_alloc_coherent(udev, type->rept_size, 1572 GFP_KERNEL, &usbtouch->data_dma); 1573 if (!usbtouch->data) 1574 goto out_free; 1575 1576 if (type->get_pkt_len) { 1577 usbtouch->buffer = kmalloc(type->rept_size, GFP_KERNEL); 1578 if (!usbtouch->buffer) 1579 goto out_free_buffers; 1580 } 1581 1582 usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL); 1583 if (!usbtouch->irq) { 1584 dev_dbg(&intf->dev, 1585 "%s - usb_alloc_urb failed: usbtouch->irq\n", __func__); 1586 goto out_free_buffers; 1587 } 1588 1589 usbtouch->interface = intf; 1590 usbtouch->input = input_dev; 1591 1592 if (udev->manufacturer) 1593 strlcpy(usbtouch->name, udev->manufacturer, sizeof(usbtouch->name)); 1594 1595 if (udev->product) { 1596 if (udev->manufacturer) 1597 strlcat(usbtouch->name, " ", sizeof(usbtouch->name)); 1598 strlcat(usbtouch->name, udev->product, sizeof(usbtouch->name)); 1599 } 1600 1601 if (!strlen(usbtouch->name)) 1602 snprintf(usbtouch->name, sizeof(usbtouch->name), 1603 "USB Touchscreen %04x:%04x", 1604 le16_to_cpu(udev->descriptor.idVendor), 1605 le16_to_cpu(udev->descriptor.idProduct)); 1606 1607 usb_make_path(udev, usbtouch->phys, sizeof(usbtouch->phys)); 1608 strlcat(usbtouch->phys, "/input0", sizeof(usbtouch->phys)); 1609 1610 input_dev->name = usbtouch->name; 1611 input_dev->phys = usbtouch->phys; 1612 usb_to_input_id(udev, &input_dev->id); 1613 input_dev->dev.parent = &intf->dev; 1614 1615 input_set_drvdata(input_dev, usbtouch); 1616 1617 input_dev->open = usbtouch_open; 1618 input_dev->close = usbtouch_close; 1619 1620 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 1621 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 1622 input_set_abs_params(input_dev, ABS_X, type->min_xc, type->max_xc, 0, 0); 1623 input_set_abs_params(input_dev, ABS_Y, type->min_yc, type->max_yc, 0, 0); 1624 if (type->max_press) 1625 input_set_abs_params(input_dev, ABS_PRESSURE, type->min_press, 1626 type->max_press, 0, 0); 1627 1628 if (usb_endpoint_type(endpoint) == USB_ENDPOINT_XFER_INT) 1629 usb_fill_int_urb(usbtouch->irq, udev, 1630 usb_rcvintpipe(udev, endpoint->bEndpointAddress), 1631 usbtouch->data, type->rept_size, 1632 usbtouch_irq, usbtouch, endpoint->bInterval); 1633 else 1634 usb_fill_bulk_urb(usbtouch->irq, udev, 1635 usb_rcvbulkpipe(udev, endpoint->bEndpointAddress), 1636 usbtouch->data, type->rept_size, 1637 usbtouch_irq, usbtouch); 1638 1639 usbtouch->irq->dev = udev; 1640 usbtouch->irq->transfer_dma = usbtouch->data_dma; 1641 usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1642 1643 /* device specific allocations */ 1644 if (type->alloc) { 1645 err = type->alloc(usbtouch); 1646 if (err) { 1647 dev_dbg(&intf->dev, 1648 "%s - type->alloc() failed, err: %d\n", 1649 __func__, err); 1650 goto out_free_urb; 1651 } 1652 } 1653 1654 /* device specific initialisation*/ 1655 if (type->init) { 1656 err = type->init(usbtouch); 1657 if (err) { 1658 dev_dbg(&intf->dev, 1659 "%s - type->init() failed, err: %d\n", 1660 __func__, err); 1661 goto out_do_exit; 1662 } 1663 } 1664 1665 err = input_register_device(usbtouch->input); 1666 if (err) { 1667 dev_dbg(&intf->dev, 1668 "%s - input_register_device failed, err: %d\n", 1669 __func__, err); 1670 goto out_do_exit; 1671 } 1672 1673 usb_set_intfdata(intf, usbtouch); 1674 1675 if (usbtouch->type->irq_always) { 1676 /* this can't fail */ 1677 usb_autopm_get_interface(intf); 1678 err = usb_submit_urb(usbtouch->irq, GFP_KERNEL); 1679 if (err) { 1680 usb_autopm_put_interface(intf); 1681 dev_err(&intf->dev, 1682 "%s - usb_submit_urb failed with result: %d\n", 1683 __func__, err); 1684 goto out_unregister_input; 1685 } 1686 } 1687 1688 return 0; 1689 1690 out_unregister_input: 1691 input_unregister_device(input_dev); 1692 input_dev = NULL; 1693 out_do_exit: 1694 if (type->exit) 1695 type->exit(usbtouch); 1696 out_free_urb: 1697 usb_free_urb(usbtouch->irq); 1698 out_free_buffers: 1699 usbtouch_free_buffers(udev, usbtouch); 1700 out_free: 1701 input_free_device(input_dev); 1702 kfree(usbtouch); 1703 return err; 1704 } 1705 1706 static void usbtouch_disconnect(struct usb_interface *intf) 1707 { 1708 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1709 1710 if (!usbtouch) 1711 return; 1712 1713 dev_dbg(&intf->dev, 1714 "%s - usbtouch is initialized, cleaning up\n", __func__); 1715 1716 usb_set_intfdata(intf, NULL); 1717 /* this will stop IO via close */ 1718 input_unregister_device(usbtouch->input); 1719 usb_free_urb(usbtouch->irq); 1720 if (usbtouch->type->exit) 1721 usbtouch->type->exit(usbtouch); 1722 usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch); 1723 kfree(usbtouch); 1724 } 1725 1726 MODULE_DEVICE_TABLE(usb, usbtouch_devices); 1727 1728 static struct usb_driver usbtouch_driver = { 1729 .name = "usbtouchscreen", 1730 .probe = usbtouch_probe, 1731 .disconnect = usbtouch_disconnect, 1732 .suspend = usbtouch_suspend, 1733 .resume = usbtouch_resume, 1734 .reset_resume = usbtouch_reset_resume, 1735 .id_table = usbtouch_devices, 1736 .supports_autosuspend = 1, 1737 }; 1738 1739 module_usb_driver(usbtouch_driver); 1740 1741 MODULE_AUTHOR(DRIVER_AUTHOR); 1742 MODULE_DESCRIPTION(DRIVER_DESC); 1743 MODULE_LICENSE("GPL"); 1744 1745 MODULE_ALIAS("touchkitusb"); 1746 MODULE_ALIAS("itmtouch"); 1747 MODULE_ALIAS("mtouchusb"); 1748