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_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 308 { 309 if ((pkt[0] & EGALAX_PKT_TYPE_MASK) != EGALAX_PKT_TYPE_REPT) 310 return 0; 311 312 dev->x = ((pkt[3] & 0x0F) << 7) | (pkt[4] & 0x7F); 313 dev->y = ((pkt[1] & 0x0F) << 7) | (pkt[2] & 0x7F); 314 dev->touch = pkt[0] & 0x01; 315 316 return 1; 317 } 318 319 static int egalax_get_pkt_len(unsigned char *buf, int len) 320 { 321 switch (buf[0] & EGALAX_PKT_TYPE_MASK) { 322 case EGALAX_PKT_TYPE_REPT: 323 return 5; 324 325 case EGALAX_PKT_TYPE_DIAG: 326 if (len < 2) 327 return -1; 328 329 return buf[1] + 2; 330 } 331 332 return 0; 333 } 334 #endif 335 336 /***************************************************************************** 337 * EasyTouch part 338 */ 339 340 #ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH 341 342 #ifndef MULTI_PACKET 343 #define MULTI_PACKET 344 #endif 345 346 #define ETOUCH_PKT_TYPE_MASK 0xFE 347 #define ETOUCH_PKT_TYPE_REPT 0x80 348 #define ETOUCH_PKT_TYPE_REPT2 0xB0 349 #define ETOUCH_PKT_TYPE_DIAG 0x0A 350 351 static int etouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 352 { 353 if ((pkt[0] & ETOUCH_PKT_TYPE_MASK) != ETOUCH_PKT_TYPE_REPT && 354 (pkt[0] & ETOUCH_PKT_TYPE_MASK) != ETOUCH_PKT_TYPE_REPT2) 355 return 0; 356 357 dev->x = ((pkt[1] & 0x1F) << 7) | (pkt[2] & 0x7F); 358 dev->y = ((pkt[3] & 0x1F) << 7) | (pkt[4] & 0x7F); 359 dev->touch = pkt[0] & 0x01; 360 361 return 1; 362 } 363 364 static int etouch_get_pkt_len(unsigned char *buf, int len) 365 { 366 switch (buf[0] & ETOUCH_PKT_TYPE_MASK) { 367 case ETOUCH_PKT_TYPE_REPT: 368 case ETOUCH_PKT_TYPE_REPT2: 369 return 5; 370 371 case ETOUCH_PKT_TYPE_DIAG: 372 if (len < 2) 373 return -1; 374 375 return buf[1] + 2; 376 } 377 378 return 0; 379 } 380 #endif 381 382 /***************************************************************************** 383 * PanJit Part 384 */ 385 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT 386 static int panjit_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 387 { 388 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1]; 389 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3]; 390 dev->touch = pkt[0] & 0x01; 391 392 return 1; 393 } 394 #endif 395 396 397 /***************************************************************************** 398 * 3M/Microtouch Part 399 */ 400 #ifdef CONFIG_TOUCHSCREEN_USB_3M 401 402 #define MTOUCHUSB_ASYNC_REPORT 1 403 #define MTOUCHUSB_RESET 7 404 #define MTOUCHUSB_REQ_CTRLLR_ID 10 405 406 static int mtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 407 { 408 if (hwcalib_xy) { 409 dev->x = (pkt[4] << 8) | pkt[3]; 410 dev->y = 0xffff - ((pkt[6] << 8) | pkt[5]); 411 } else { 412 dev->x = (pkt[8] << 8) | pkt[7]; 413 dev->y = (pkt[10] << 8) | pkt[9]; 414 } 415 dev->touch = (pkt[2] & 0x40) ? 1 : 0; 416 417 return 1; 418 } 419 420 static int mtouch_init(struct usbtouch_usb *usbtouch) 421 { 422 int ret, i; 423 struct usb_device *udev = interface_to_usbdev(usbtouch->interface); 424 425 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 426 MTOUCHUSB_RESET, 427 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 428 1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT); 429 dev_dbg(&usbtouch->interface->dev, 430 "%s - usb_control_msg - MTOUCHUSB_RESET - bytes|err: %d\n", 431 __func__, ret); 432 if (ret < 0) 433 return ret; 434 msleep(150); 435 436 for (i = 0; i < 3; i++) { 437 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 438 MTOUCHUSB_ASYNC_REPORT, 439 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 440 1, 1, NULL, 0, USB_CTRL_SET_TIMEOUT); 441 dev_dbg(&usbtouch->interface->dev, 442 "%s - usb_control_msg - MTOUCHUSB_ASYNC_REPORT - bytes|err: %d\n", 443 __func__, ret); 444 if (ret >= 0) 445 break; 446 if (ret != -EPIPE) 447 return ret; 448 } 449 450 /* Default min/max xy are the raw values, override if using hw-calib */ 451 if (hwcalib_xy) { 452 input_set_abs_params(usbtouch->input, ABS_X, 0, 0xffff, 0, 0); 453 input_set_abs_params(usbtouch->input, ABS_Y, 0, 0xffff, 0, 0); 454 } 455 456 return 0; 457 } 458 #endif 459 460 461 /***************************************************************************** 462 * ITM Part 463 */ 464 #ifdef CONFIG_TOUCHSCREEN_USB_ITM 465 static int itm_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 466 { 467 int touch; 468 /* 469 * ITM devices report invalid x/y data if not touched. 470 * if the screen was touched before but is not touched any more 471 * report touch as 0 with the last valid x/y data once. then stop 472 * reporting data until touched again. 473 */ 474 dev->press = ((pkt[2] & 0x01) << 7) | (pkt[5] & 0x7F); 475 476 touch = ~pkt[7] & 0x20; 477 if (!touch) { 478 if (dev->touch) { 479 dev->touch = 0; 480 return 1; 481 } 482 483 return 0; 484 } 485 486 dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[3] & 0x7F); 487 dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[4] & 0x7F); 488 dev->touch = touch; 489 490 return 1; 491 } 492 #endif 493 494 495 /***************************************************************************** 496 * eTurboTouch part 497 */ 498 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO 499 #ifndef MULTI_PACKET 500 #define MULTI_PACKET 501 #endif 502 static int eturbo_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 503 { 504 unsigned int shift; 505 506 /* packets should start with sync */ 507 if (!(pkt[0] & 0x80)) 508 return 0; 509 510 shift = (6 - (pkt[0] & 0x03)); 511 dev->x = ((pkt[3] << 7) | pkt[4]) >> shift; 512 dev->y = ((pkt[1] << 7) | pkt[2]) >> shift; 513 dev->touch = (pkt[0] & 0x10) ? 1 : 0; 514 515 return 1; 516 } 517 518 static int eturbo_get_pkt_len(unsigned char *buf, int len) 519 { 520 if (buf[0] & 0x80) 521 return 5; 522 if (buf[0] == 0x01) 523 return 3; 524 return 0; 525 } 526 #endif 527 528 529 /***************************************************************************** 530 * Gunze part 531 */ 532 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE 533 static int gunze_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 534 { 535 if (!(pkt[0] & 0x80) || ((pkt[1] | pkt[2] | pkt[3]) & 0x80)) 536 return 0; 537 538 dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[2] & 0x7F); 539 dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[3] & 0x7F); 540 dev->touch = pkt[0] & 0x20; 541 542 return 1; 543 } 544 #endif 545 546 /***************************************************************************** 547 * DMC TSC-10/25 Part 548 * 549 * Documentation about the controller and it's protocol can be found at 550 * http://www.dmccoltd.com/files/controler/tsc10usb_pi_e.pdf 551 * http://www.dmccoltd.com/files/controler/tsc25_usb_e.pdf 552 */ 553 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10 554 555 /* supported data rates. currently using 130 */ 556 #define TSC10_RATE_POINT 0x50 557 #define TSC10_RATE_30 0x40 558 #define TSC10_RATE_50 0x41 559 #define TSC10_RATE_80 0x42 560 #define TSC10_RATE_100 0x43 561 #define TSC10_RATE_130 0x44 562 #define TSC10_RATE_150 0x45 563 564 /* commands */ 565 #define TSC10_CMD_RESET 0x55 566 #define TSC10_CMD_RATE 0x05 567 #define TSC10_CMD_DATA1 0x01 568 569 static int dmc_tsc10_init(struct usbtouch_usb *usbtouch) 570 { 571 struct usb_device *dev = interface_to_usbdev(usbtouch->interface); 572 int ret = -ENOMEM; 573 unsigned char *buf; 574 575 buf = kmalloc(2, GFP_NOIO); 576 if (!buf) 577 goto err_nobuf; 578 /* reset */ 579 buf[0] = buf[1] = 0xFF; 580 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 581 TSC10_CMD_RESET, 582 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 583 0, 0, buf, 2, USB_CTRL_SET_TIMEOUT); 584 if (ret < 0) 585 goto err_out; 586 if (buf[0] != 0x06) { 587 ret = -ENODEV; 588 goto err_out; 589 } 590 591 /* set coordinate output rate */ 592 buf[0] = buf[1] = 0xFF; 593 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 594 TSC10_CMD_RATE, 595 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 596 TSC10_RATE_150, 0, buf, 2, USB_CTRL_SET_TIMEOUT); 597 if (ret < 0) 598 goto err_out; 599 if ((buf[0] != 0x06) && (buf[0] != 0x15 || buf[1] != 0x01)) { 600 ret = -ENODEV; 601 goto err_out; 602 } 603 604 /* start sending data */ 605 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 606 TSC10_CMD_DATA1, 607 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 608 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT); 609 err_out: 610 kfree(buf); 611 err_nobuf: 612 return ret; 613 } 614 615 616 static int dmc_tsc10_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 617 { 618 dev->x = ((pkt[2] & 0x03) << 8) | pkt[1]; 619 dev->y = ((pkt[4] & 0x03) << 8) | pkt[3]; 620 dev->touch = pkt[0] & 0x01; 621 622 return 1; 623 } 624 #endif 625 626 627 /***************************************************************************** 628 * IRTOUCH Part 629 */ 630 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 631 static int irtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 632 { 633 dev->x = (pkt[3] << 8) | pkt[2]; 634 dev->y = (pkt[5] << 8) | pkt[4]; 635 dev->touch = (pkt[1] & 0x03) ? 1 : 0; 636 637 return 1; 638 } 639 #endif 640 641 /***************************************************************************** 642 * ET&T TC5UH/TC4UM part 643 */ 644 #ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB 645 static int tc45usb_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 646 { 647 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1]; 648 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3]; 649 dev->touch = pkt[0] & 0x01; 650 651 return 1; 652 } 653 #endif 654 655 /***************************************************************************** 656 * IdealTEK URTC1000 Part 657 */ 658 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 659 #ifndef MULTI_PACKET 660 #define MULTI_PACKET 661 #endif 662 static int idealtek_get_pkt_len(unsigned char *buf, int len) 663 { 664 if (buf[0] & 0x80) 665 return 5; 666 if (buf[0] == 0x01) 667 return len; 668 return 0; 669 } 670 671 static int idealtek_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 672 { 673 switch (pkt[0] & 0x98) { 674 case 0x88: 675 /* touch data in IdealTEK mode */ 676 dev->x = (pkt[1] << 5) | (pkt[2] >> 2); 677 dev->y = (pkt[3] << 5) | (pkt[4] >> 2); 678 dev->touch = (pkt[0] & 0x40) ? 1 : 0; 679 return 1; 680 681 case 0x98: 682 /* touch data in MT emulation mode */ 683 dev->x = (pkt[2] << 5) | (pkt[1] >> 2); 684 dev->y = (pkt[4] << 5) | (pkt[3] >> 2); 685 dev->touch = (pkt[0] & 0x40) ? 1 : 0; 686 return 1; 687 688 default: 689 return 0; 690 } 691 } 692 #endif 693 694 /***************************************************************************** 695 * General Touch Part 696 */ 697 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 698 static int general_touch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 699 { 700 dev->x = (pkt[2] << 8) | pkt[1]; 701 dev->y = (pkt[4] << 8) | pkt[3]; 702 dev->press = pkt[5] & 0xff; 703 dev->touch = pkt[0] & 0x01; 704 705 return 1; 706 } 707 #endif 708 709 /***************************************************************************** 710 * GoTop Part 711 */ 712 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 713 static int gotop_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 714 { 715 dev->x = ((pkt[1] & 0x38) << 4) | pkt[2]; 716 dev->y = ((pkt[1] & 0x07) << 7) | pkt[3]; 717 dev->touch = pkt[0] & 0x01; 718 719 return 1; 720 } 721 #endif 722 723 /***************************************************************************** 724 * JASTEC Part 725 */ 726 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC 727 static int jastec_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 728 { 729 dev->x = ((pkt[0] & 0x3f) << 6) | (pkt[2] & 0x3f); 730 dev->y = ((pkt[1] & 0x3f) << 6) | (pkt[3] & 0x3f); 731 dev->touch = (pkt[0] & 0x40) >> 6; 732 733 return 1; 734 } 735 #endif 736 737 /***************************************************************************** 738 * Zytronic Part 739 */ 740 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC 741 static int zytronic_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 742 { 743 struct usb_interface *intf = dev->interface; 744 745 switch (pkt[0]) { 746 case 0x3A: /* command response */ 747 dev_dbg(&intf->dev, "%s: Command response %d\n", __func__, pkt[1]); 748 break; 749 750 case 0xC0: /* down */ 751 dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7); 752 dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7); 753 dev->touch = 1; 754 dev_dbg(&intf->dev, "%s: down %d,%d\n", __func__, dev->x, dev->y); 755 return 1; 756 757 case 0x80: /* up */ 758 dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7); 759 dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7); 760 dev->touch = 0; 761 dev_dbg(&intf->dev, "%s: up %d,%d\n", __func__, dev->x, dev->y); 762 return 1; 763 764 default: 765 dev_dbg(&intf->dev, "%s: Unknown return %d\n", __func__, pkt[0]); 766 break; 767 } 768 769 return 0; 770 } 771 #endif 772 773 /***************************************************************************** 774 * NEXIO Part 775 */ 776 #ifdef CONFIG_TOUCHSCREEN_USB_NEXIO 777 778 #define NEXIO_TIMEOUT 5000 779 #define NEXIO_BUFSIZE 1024 780 #define NEXIO_THRESHOLD 50 781 782 struct nexio_priv { 783 struct urb *ack; 784 unsigned char *ack_buf; 785 }; 786 787 struct nexio_touch_packet { 788 u8 flags; /* 0xe1 = touch, 0xe1 = release */ 789 __be16 data_len; /* total bytes of touch data */ 790 __be16 x_len; /* bytes for X axis */ 791 __be16 y_len; /* bytes for Y axis */ 792 u8 data[]; 793 } __attribute__ ((packed)); 794 795 static unsigned char nexio_ack_pkt[2] = { 0xaa, 0x02 }; 796 static unsigned char nexio_init_pkt[4] = { 0x82, 0x04, 0x0a, 0x0f }; 797 798 static void nexio_ack_complete(struct urb *urb) 799 { 800 } 801 802 static int nexio_alloc(struct usbtouch_usb *usbtouch) 803 { 804 struct nexio_priv *priv; 805 int ret = -ENOMEM; 806 807 usbtouch->priv = kmalloc(sizeof(struct nexio_priv), GFP_KERNEL); 808 if (!usbtouch->priv) 809 goto out_buf; 810 811 priv = usbtouch->priv; 812 813 priv->ack_buf = kmemdup(nexio_ack_pkt, sizeof(nexio_ack_pkt), 814 GFP_KERNEL); 815 if (!priv->ack_buf) 816 goto err_priv; 817 818 priv->ack = usb_alloc_urb(0, GFP_KERNEL); 819 if (!priv->ack) { 820 dev_dbg(&usbtouch->interface->dev, 821 "%s - usb_alloc_urb failed: usbtouch->ack\n", __func__); 822 goto err_ack_buf; 823 } 824 825 return 0; 826 827 err_ack_buf: 828 kfree(priv->ack_buf); 829 err_priv: 830 kfree(priv); 831 out_buf: 832 return ret; 833 } 834 835 static int nexio_init(struct usbtouch_usb *usbtouch) 836 { 837 struct usb_device *dev = interface_to_usbdev(usbtouch->interface); 838 struct usb_host_interface *interface = usbtouch->interface->cur_altsetting; 839 struct nexio_priv *priv = usbtouch->priv; 840 int ret = -ENOMEM; 841 int actual_len, i; 842 unsigned char *buf; 843 char *firmware_ver = NULL, *device_name = NULL; 844 int input_ep = 0, output_ep = 0; 845 846 /* find first input and output endpoint */ 847 for (i = 0; i < interface->desc.bNumEndpoints; i++) { 848 if (!input_ep && 849 usb_endpoint_dir_in(&interface->endpoint[i].desc)) 850 input_ep = interface->endpoint[i].desc.bEndpointAddress; 851 if (!output_ep && 852 usb_endpoint_dir_out(&interface->endpoint[i].desc)) 853 output_ep = interface->endpoint[i].desc.bEndpointAddress; 854 } 855 if (!input_ep || !output_ep) 856 return -ENXIO; 857 858 buf = kmalloc(NEXIO_BUFSIZE, GFP_NOIO); 859 if (!buf) 860 goto out_buf; 861 862 /* two empty reads */ 863 for (i = 0; i < 2; i++) { 864 ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, input_ep), 865 buf, NEXIO_BUFSIZE, &actual_len, 866 NEXIO_TIMEOUT); 867 if (ret < 0) 868 goto out_buf; 869 } 870 871 /* send init command */ 872 memcpy(buf, nexio_init_pkt, sizeof(nexio_init_pkt)); 873 ret = usb_bulk_msg(dev, usb_sndbulkpipe(dev, output_ep), 874 buf, sizeof(nexio_init_pkt), &actual_len, 875 NEXIO_TIMEOUT); 876 if (ret < 0) 877 goto out_buf; 878 879 /* read replies */ 880 for (i = 0; i < 3; i++) { 881 memset(buf, 0, NEXIO_BUFSIZE); 882 ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, input_ep), 883 buf, NEXIO_BUFSIZE, &actual_len, 884 NEXIO_TIMEOUT); 885 if (ret < 0 || actual_len < 1 || buf[1] != actual_len) 886 continue; 887 switch (buf[0]) { 888 case 0x83: /* firmware version */ 889 if (!firmware_ver) 890 firmware_ver = kstrdup(&buf[2], GFP_NOIO); 891 break; 892 case 0x84: /* device name */ 893 if (!device_name) 894 device_name = kstrdup(&buf[2], GFP_NOIO); 895 break; 896 } 897 } 898 899 printk(KERN_INFO "Nexio device: %s, firmware version: %s\n", 900 device_name, firmware_ver); 901 902 kfree(firmware_ver); 903 kfree(device_name); 904 905 usb_fill_bulk_urb(priv->ack, dev, usb_sndbulkpipe(dev, output_ep), 906 priv->ack_buf, sizeof(nexio_ack_pkt), 907 nexio_ack_complete, usbtouch); 908 ret = 0; 909 910 out_buf: 911 kfree(buf); 912 return ret; 913 } 914 915 static void nexio_exit(struct usbtouch_usb *usbtouch) 916 { 917 struct nexio_priv *priv = usbtouch->priv; 918 919 usb_kill_urb(priv->ack); 920 usb_free_urb(priv->ack); 921 kfree(priv->ack_buf); 922 kfree(priv); 923 } 924 925 static int nexio_read_data(struct usbtouch_usb *usbtouch, unsigned char *pkt) 926 { 927 struct nexio_touch_packet *packet = (void *) pkt; 928 struct nexio_priv *priv = usbtouch->priv; 929 unsigned int data_len = be16_to_cpu(packet->data_len); 930 unsigned int x_len = be16_to_cpu(packet->x_len); 931 unsigned int y_len = be16_to_cpu(packet->y_len); 932 int x, y, begin_x, begin_y, end_x, end_y, w, h, ret; 933 934 /* got touch data? */ 935 if ((pkt[0] & 0xe0) != 0xe0) 936 return 0; 937 938 if (data_len > 0xff) 939 data_len -= 0x100; 940 if (x_len > 0xff) 941 x_len -= 0x80; 942 943 /* send ACK */ 944 ret = usb_submit_urb(priv->ack, GFP_ATOMIC); 945 946 if (!usbtouch->type->max_xc) { 947 usbtouch->type->max_xc = 2 * x_len; 948 input_set_abs_params(usbtouch->input, ABS_X, 949 0, usbtouch->type->max_xc, 0, 0); 950 usbtouch->type->max_yc = 2 * y_len; 951 input_set_abs_params(usbtouch->input, ABS_Y, 952 0, usbtouch->type->max_yc, 0, 0); 953 } 954 /* 955 * The device reports state of IR sensors on X and Y axes. 956 * Each byte represents "darkness" percentage (0-100) of one element. 957 * 17" touchscreen reports only 64 x 52 bytes so the resolution is low. 958 * This also means that there's a limited multi-touch capability but 959 * it's disabled (and untested) here as there's no X driver for that. 960 */ 961 begin_x = end_x = begin_y = end_y = -1; 962 for (x = 0; x < x_len; x++) { 963 if (begin_x == -1 && packet->data[x] > NEXIO_THRESHOLD) { 964 begin_x = x; 965 continue; 966 } 967 if (end_x == -1 && begin_x != -1 && packet->data[x] < NEXIO_THRESHOLD) { 968 end_x = x - 1; 969 for (y = x_len; y < data_len; y++) { 970 if (begin_y == -1 && packet->data[y] > NEXIO_THRESHOLD) { 971 begin_y = y - x_len; 972 continue; 973 } 974 if (end_y == -1 && 975 begin_y != -1 && packet->data[y] < NEXIO_THRESHOLD) { 976 end_y = y - 1 - x_len; 977 w = end_x - begin_x; 978 h = end_y - begin_y; 979 #if 0 980 /* multi-touch */ 981 input_report_abs(usbtouch->input, 982 ABS_MT_TOUCH_MAJOR, max(w,h)); 983 input_report_abs(usbtouch->input, 984 ABS_MT_TOUCH_MINOR, min(x,h)); 985 input_report_abs(usbtouch->input, 986 ABS_MT_POSITION_X, 2*begin_x+w); 987 input_report_abs(usbtouch->input, 988 ABS_MT_POSITION_Y, 2*begin_y+h); 989 input_report_abs(usbtouch->input, 990 ABS_MT_ORIENTATION, w > h); 991 input_mt_sync(usbtouch->input); 992 #endif 993 /* single touch */ 994 usbtouch->x = 2 * begin_x + w; 995 usbtouch->y = 2 * begin_y + h; 996 usbtouch->touch = packet->flags & 0x01; 997 begin_y = end_y = -1; 998 return 1; 999 } 1000 } 1001 begin_x = end_x = -1; 1002 } 1003 1004 } 1005 return 0; 1006 } 1007 #endif 1008 1009 1010 /***************************************************************************** 1011 * ELO part 1012 */ 1013 1014 #ifdef CONFIG_TOUCHSCREEN_USB_ELO 1015 1016 static int elo_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 1017 { 1018 dev->x = (pkt[3] << 8) | pkt[2]; 1019 dev->y = (pkt[5] << 8) | pkt[4]; 1020 dev->touch = pkt[6] > 0; 1021 dev->press = pkt[6]; 1022 1023 return 1; 1024 } 1025 #endif 1026 1027 1028 /***************************************************************************** 1029 * the different device descriptors 1030 */ 1031 #ifdef MULTI_PACKET 1032 static void usbtouch_process_multi(struct usbtouch_usb *usbtouch, 1033 unsigned char *pkt, int len); 1034 #endif 1035 1036 static struct usbtouch_device_info usbtouch_dev_info[] = { 1037 #ifdef CONFIG_TOUCHSCREEN_USB_ELO 1038 [DEVTYPE_ELO] = { 1039 .min_xc = 0x0, 1040 .max_xc = 0x0fff, 1041 .min_yc = 0x0, 1042 .max_yc = 0x0fff, 1043 .max_press = 0xff, 1044 .rept_size = 8, 1045 .read_data = elo_read_data, 1046 }, 1047 #endif 1048 1049 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX 1050 [DEVTYPE_EGALAX] = { 1051 .min_xc = 0x0, 1052 .max_xc = 0x07ff, 1053 .min_yc = 0x0, 1054 .max_yc = 0x07ff, 1055 .rept_size = 16, 1056 .process_pkt = usbtouch_process_multi, 1057 .get_pkt_len = egalax_get_pkt_len, 1058 .read_data = egalax_read_data, 1059 }, 1060 #endif 1061 1062 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT 1063 [DEVTYPE_PANJIT] = { 1064 .min_xc = 0x0, 1065 .max_xc = 0x0fff, 1066 .min_yc = 0x0, 1067 .max_yc = 0x0fff, 1068 .rept_size = 8, 1069 .read_data = panjit_read_data, 1070 }, 1071 #endif 1072 1073 #ifdef CONFIG_TOUCHSCREEN_USB_3M 1074 [DEVTYPE_3M] = { 1075 .min_xc = 0x0, 1076 .max_xc = 0x4000, 1077 .min_yc = 0x0, 1078 .max_yc = 0x4000, 1079 .rept_size = 11, 1080 .read_data = mtouch_read_data, 1081 .init = mtouch_init, 1082 }, 1083 #endif 1084 1085 #ifdef CONFIG_TOUCHSCREEN_USB_ITM 1086 [DEVTYPE_ITM] = { 1087 .min_xc = 0x0, 1088 .max_xc = 0x0fff, 1089 .min_yc = 0x0, 1090 .max_yc = 0x0fff, 1091 .max_press = 0xff, 1092 .rept_size = 8, 1093 .read_data = itm_read_data, 1094 }, 1095 #endif 1096 1097 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO 1098 [DEVTYPE_ETURBO] = { 1099 .min_xc = 0x0, 1100 .max_xc = 0x07ff, 1101 .min_yc = 0x0, 1102 .max_yc = 0x07ff, 1103 .rept_size = 8, 1104 .process_pkt = usbtouch_process_multi, 1105 .get_pkt_len = eturbo_get_pkt_len, 1106 .read_data = eturbo_read_data, 1107 }, 1108 #endif 1109 1110 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE 1111 [DEVTYPE_GUNZE] = { 1112 .min_xc = 0x0, 1113 .max_xc = 0x0fff, 1114 .min_yc = 0x0, 1115 .max_yc = 0x0fff, 1116 .rept_size = 4, 1117 .read_data = gunze_read_data, 1118 }, 1119 #endif 1120 1121 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10 1122 [DEVTYPE_DMC_TSC10] = { 1123 .min_xc = 0x0, 1124 .max_xc = 0x03ff, 1125 .min_yc = 0x0, 1126 .max_yc = 0x03ff, 1127 .rept_size = 5, 1128 .init = dmc_tsc10_init, 1129 .read_data = dmc_tsc10_read_data, 1130 }, 1131 #endif 1132 1133 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 1134 [DEVTYPE_IRTOUCH] = { 1135 .min_xc = 0x0, 1136 .max_xc = 0x0fff, 1137 .min_yc = 0x0, 1138 .max_yc = 0x0fff, 1139 .rept_size = 8, 1140 .read_data = irtouch_read_data, 1141 }, 1142 #endif 1143 1144 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 1145 [DEVTYPE_IDEALTEK] = { 1146 .min_xc = 0x0, 1147 .max_xc = 0x0fff, 1148 .min_yc = 0x0, 1149 .max_yc = 0x0fff, 1150 .rept_size = 8, 1151 .process_pkt = usbtouch_process_multi, 1152 .get_pkt_len = idealtek_get_pkt_len, 1153 .read_data = idealtek_read_data, 1154 }, 1155 #endif 1156 1157 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 1158 [DEVTYPE_GENERAL_TOUCH] = { 1159 .min_xc = 0x0, 1160 .max_xc = 0x7fff, 1161 .min_yc = 0x0, 1162 .max_yc = 0x7fff, 1163 .rept_size = 7, 1164 .read_data = general_touch_read_data, 1165 }, 1166 #endif 1167 1168 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 1169 [DEVTYPE_GOTOP] = { 1170 .min_xc = 0x0, 1171 .max_xc = 0x03ff, 1172 .min_yc = 0x0, 1173 .max_yc = 0x03ff, 1174 .rept_size = 4, 1175 .read_data = gotop_read_data, 1176 }, 1177 #endif 1178 1179 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC 1180 [DEVTYPE_JASTEC] = { 1181 .min_xc = 0x0, 1182 .max_xc = 0x0fff, 1183 .min_yc = 0x0, 1184 .max_yc = 0x0fff, 1185 .rept_size = 4, 1186 .read_data = jastec_read_data, 1187 }, 1188 #endif 1189 1190 #ifdef CONFIG_TOUCHSCREEN_USB_E2I 1191 [DEVTYPE_E2I] = { 1192 .min_xc = 0x0, 1193 .max_xc = 0x7fff, 1194 .min_yc = 0x0, 1195 .max_yc = 0x7fff, 1196 .rept_size = 6, 1197 .init = e2i_init, 1198 .read_data = e2i_read_data, 1199 }, 1200 #endif 1201 1202 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC 1203 [DEVTYPE_ZYTRONIC] = { 1204 .min_xc = 0x0, 1205 .max_xc = 0x03ff, 1206 .min_yc = 0x0, 1207 .max_yc = 0x03ff, 1208 .rept_size = 5, 1209 .read_data = zytronic_read_data, 1210 .irq_always = true, 1211 }, 1212 #endif 1213 1214 #ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB 1215 [DEVTYPE_TC45USB] = { 1216 .min_xc = 0x0, 1217 .max_xc = 0x0fff, 1218 .min_yc = 0x0, 1219 .max_yc = 0x0fff, 1220 .rept_size = 5, 1221 .read_data = tc45usb_read_data, 1222 }, 1223 #endif 1224 1225 #ifdef CONFIG_TOUCHSCREEN_USB_NEXIO 1226 [DEVTYPE_NEXIO] = { 1227 .rept_size = 1024, 1228 .irq_always = true, 1229 .read_data = nexio_read_data, 1230 .alloc = nexio_alloc, 1231 .init = nexio_init, 1232 .exit = nexio_exit, 1233 }, 1234 #endif 1235 #ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH 1236 [DEVTYPE_ETOUCH] = { 1237 .min_xc = 0x0, 1238 .max_xc = 0x07ff, 1239 .min_yc = 0x0, 1240 .max_yc = 0x07ff, 1241 .rept_size = 16, 1242 .process_pkt = usbtouch_process_multi, 1243 .get_pkt_len = etouch_get_pkt_len, 1244 .read_data = etouch_read_data, 1245 }, 1246 #endif 1247 }; 1248 1249 1250 /***************************************************************************** 1251 * Generic Part 1252 */ 1253 static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch, 1254 unsigned char *pkt, int len) 1255 { 1256 struct usbtouch_device_info *type = usbtouch->type; 1257 1258 if (!type->read_data(usbtouch, pkt)) 1259 return; 1260 1261 input_report_key(usbtouch->input, BTN_TOUCH, usbtouch->touch); 1262 1263 if (swap_xy) { 1264 input_report_abs(usbtouch->input, ABS_X, usbtouch->y); 1265 input_report_abs(usbtouch->input, ABS_Y, usbtouch->x); 1266 } else { 1267 input_report_abs(usbtouch->input, ABS_X, usbtouch->x); 1268 input_report_abs(usbtouch->input, ABS_Y, usbtouch->y); 1269 } 1270 if (type->max_press) 1271 input_report_abs(usbtouch->input, ABS_PRESSURE, usbtouch->press); 1272 input_sync(usbtouch->input); 1273 } 1274 1275 1276 #ifdef MULTI_PACKET 1277 static void usbtouch_process_multi(struct usbtouch_usb *usbtouch, 1278 unsigned char *pkt, int len) 1279 { 1280 unsigned char *buffer; 1281 int pkt_len, pos, buf_len, tmp; 1282 1283 /* process buffer */ 1284 if (unlikely(usbtouch->buf_len)) { 1285 /* try to get size */ 1286 pkt_len = usbtouch->type->get_pkt_len( 1287 usbtouch->buffer, usbtouch->buf_len); 1288 1289 /* drop? */ 1290 if (unlikely(!pkt_len)) 1291 goto out_flush_buf; 1292 1293 /* need to append -pkt_len bytes before able to get size */ 1294 if (unlikely(pkt_len < 0)) { 1295 int append = -pkt_len; 1296 if (unlikely(append > len)) 1297 append = len; 1298 if (usbtouch->buf_len + append >= usbtouch->type->rept_size) 1299 goto out_flush_buf; 1300 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, append); 1301 usbtouch->buf_len += append; 1302 1303 pkt_len = usbtouch->type->get_pkt_len( 1304 usbtouch->buffer, usbtouch->buf_len); 1305 if (pkt_len < 0) 1306 return; 1307 } 1308 1309 /* append */ 1310 tmp = pkt_len - usbtouch->buf_len; 1311 if (usbtouch->buf_len + tmp >= usbtouch->type->rept_size) 1312 goto out_flush_buf; 1313 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, tmp); 1314 usbtouch_process_pkt(usbtouch, usbtouch->buffer, pkt_len); 1315 1316 buffer = pkt + tmp; 1317 buf_len = len - tmp; 1318 } else { 1319 buffer = pkt; 1320 buf_len = len; 1321 } 1322 1323 /* loop over the received packet, process */ 1324 pos = 0; 1325 while (pos < buf_len) { 1326 /* get packet len */ 1327 pkt_len = usbtouch->type->get_pkt_len(buffer + pos, 1328 buf_len - pos); 1329 1330 /* unknown packet: skip one byte */ 1331 if (unlikely(!pkt_len)) { 1332 pos++; 1333 continue; 1334 } 1335 1336 /* full packet: process */ 1337 if (likely((pkt_len > 0) && (pkt_len <= buf_len - pos))) { 1338 usbtouch_process_pkt(usbtouch, buffer + pos, pkt_len); 1339 } else { 1340 /* incomplete packet: save in buffer */ 1341 memcpy(usbtouch->buffer, buffer + pos, buf_len - pos); 1342 usbtouch->buf_len = buf_len - pos; 1343 return; 1344 } 1345 pos += pkt_len; 1346 } 1347 1348 out_flush_buf: 1349 usbtouch->buf_len = 0; 1350 return; 1351 } 1352 #endif 1353 1354 1355 static void usbtouch_irq(struct urb *urb) 1356 { 1357 struct usbtouch_usb *usbtouch = urb->context; 1358 struct device *dev = &usbtouch->interface->dev; 1359 int retval; 1360 1361 switch (urb->status) { 1362 case 0: 1363 /* success */ 1364 break; 1365 case -ETIME: 1366 /* this urb is timing out */ 1367 dev_dbg(dev, 1368 "%s - urb timed out - was the device unplugged?\n", 1369 __func__); 1370 return; 1371 case -ECONNRESET: 1372 case -ENOENT: 1373 case -ESHUTDOWN: 1374 case -EPIPE: 1375 /* this urb is terminated, clean up */ 1376 dev_dbg(dev, "%s - urb shutting down with status: %d\n", 1377 __func__, urb->status); 1378 return; 1379 default: 1380 dev_dbg(dev, "%s - nonzero urb status received: %d\n", 1381 __func__, urb->status); 1382 goto exit; 1383 } 1384 1385 usbtouch->type->process_pkt(usbtouch, usbtouch->data, urb->actual_length); 1386 1387 exit: 1388 usb_mark_last_busy(interface_to_usbdev(usbtouch->interface)); 1389 retval = usb_submit_urb(urb, GFP_ATOMIC); 1390 if (retval) 1391 dev_err(dev, "%s - usb_submit_urb failed with result: %d\n", 1392 __func__, retval); 1393 } 1394 1395 static int usbtouch_open(struct input_dev *input) 1396 { 1397 struct usbtouch_usb *usbtouch = input_get_drvdata(input); 1398 int r; 1399 1400 usbtouch->irq->dev = interface_to_usbdev(usbtouch->interface); 1401 1402 r = usb_autopm_get_interface(usbtouch->interface) ? -EIO : 0; 1403 if (r < 0) 1404 goto out; 1405 1406 if (!usbtouch->type->irq_always) { 1407 if (usb_submit_urb(usbtouch->irq, GFP_KERNEL)) { 1408 r = -EIO; 1409 goto out_put; 1410 } 1411 } 1412 1413 usbtouch->interface->needs_remote_wakeup = 1; 1414 out_put: 1415 usb_autopm_put_interface(usbtouch->interface); 1416 out: 1417 return r; 1418 } 1419 1420 static void usbtouch_close(struct input_dev *input) 1421 { 1422 struct usbtouch_usb *usbtouch = input_get_drvdata(input); 1423 int r; 1424 1425 if (!usbtouch->type->irq_always) 1426 usb_kill_urb(usbtouch->irq); 1427 r = usb_autopm_get_interface(usbtouch->interface); 1428 usbtouch->interface->needs_remote_wakeup = 0; 1429 if (!r) 1430 usb_autopm_put_interface(usbtouch->interface); 1431 } 1432 1433 static int usbtouch_suspend 1434 (struct usb_interface *intf, pm_message_t message) 1435 { 1436 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1437 1438 usb_kill_urb(usbtouch->irq); 1439 1440 return 0; 1441 } 1442 1443 static int usbtouch_resume(struct usb_interface *intf) 1444 { 1445 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1446 struct input_dev *input = usbtouch->input; 1447 int result = 0; 1448 1449 mutex_lock(&input->mutex); 1450 if (input->users || usbtouch->type->irq_always) 1451 result = usb_submit_urb(usbtouch->irq, GFP_NOIO); 1452 mutex_unlock(&input->mutex); 1453 1454 return result; 1455 } 1456 1457 static int usbtouch_reset_resume(struct usb_interface *intf) 1458 { 1459 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1460 struct input_dev *input = usbtouch->input; 1461 int err = 0; 1462 1463 /* reinit the device */ 1464 if (usbtouch->type->init) { 1465 err = usbtouch->type->init(usbtouch); 1466 if (err) { 1467 dev_dbg(&intf->dev, 1468 "%s - type->init() failed, err: %d\n", 1469 __func__, err); 1470 return err; 1471 } 1472 } 1473 1474 /* restart IO if needed */ 1475 mutex_lock(&input->mutex); 1476 if (input->users) 1477 err = usb_submit_urb(usbtouch->irq, GFP_NOIO); 1478 mutex_unlock(&input->mutex); 1479 1480 return err; 1481 } 1482 1483 static void usbtouch_free_buffers(struct usb_device *udev, 1484 struct usbtouch_usb *usbtouch) 1485 { 1486 usb_free_coherent(udev, usbtouch->type->rept_size, 1487 usbtouch->data, usbtouch->data_dma); 1488 kfree(usbtouch->buffer); 1489 } 1490 1491 static struct usb_endpoint_descriptor * 1492 usbtouch_get_input_endpoint(struct usb_host_interface *interface) 1493 { 1494 int i; 1495 1496 for (i = 0; i < interface->desc.bNumEndpoints; i++) 1497 if (usb_endpoint_dir_in(&interface->endpoint[i].desc)) 1498 return &interface->endpoint[i].desc; 1499 1500 return NULL; 1501 } 1502 1503 static int usbtouch_probe(struct usb_interface *intf, 1504 const struct usb_device_id *id) 1505 { 1506 struct usbtouch_usb *usbtouch; 1507 struct input_dev *input_dev; 1508 struct usb_endpoint_descriptor *endpoint; 1509 struct usb_device *udev = interface_to_usbdev(intf); 1510 struct usbtouch_device_info *type; 1511 int err = -ENOMEM; 1512 1513 /* some devices are ignored */ 1514 if (id->driver_info == DEVTYPE_IGNORE) 1515 return -ENODEV; 1516 1517 endpoint = usbtouch_get_input_endpoint(intf->cur_altsetting); 1518 if (!endpoint) 1519 return -ENXIO; 1520 1521 usbtouch = kzalloc(sizeof(struct usbtouch_usb), GFP_KERNEL); 1522 input_dev = input_allocate_device(); 1523 if (!usbtouch || !input_dev) 1524 goto out_free; 1525 1526 type = &usbtouch_dev_info[id->driver_info]; 1527 usbtouch->type = type; 1528 if (!type->process_pkt) 1529 type->process_pkt = usbtouch_process_pkt; 1530 1531 usbtouch->data = usb_alloc_coherent(udev, type->rept_size, 1532 GFP_KERNEL, &usbtouch->data_dma); 1533 if (!usbtouch->data) 1534 goto out_free; 1535 1536 if (type->get_pkt_len) { 1537 usbtouch->buffer = kmalloc(type->rept_size, GFP_KERNEL); 1538 if (!usbtouch->buffer) 1539 goto out_free_buffers; 1540 } 1541 1542 usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL); 1543 if (!usbtouch->irq) { 1544 dev_dbg(&intf->dev, 1545 "%s - usb_alloc_urb failed: usbtouch->irq\n", __func__); 1546 goto out_free_buffers; 1547 } 1548 1549 usbtouch->interface = intf; 1550 usbtouch->input = input_dev; 1551 1552 if (udev->manufacturer) 1553 strlcpy(usbtouch->name, udev->manufacturer, sizeof(usbtouch->name)); 1554 1555 if (udev->product) { 1556 if (udev->manufacturer) 1557 strlcat(usbtouch->name, " ", sizeof(usbtouch->name)); 1558 strlcat(usbtouch->name, udev->product, sizeof(usbtouch->name)); 1559 } 1560 1561 if (!strlen(usbtouch->name)) 1562 snprintf(usbtouch->name, sizeof(usbtouch->name), 1563 "USB Touchscreen %04x:%04x", 1564 le16_to_cpu(udev->descriptor.idVendor), 1565 le16_to_cpu(udev->descriptor.idProduct)); 1566 1567 usb_make_path(udev, usbtouch->phys, sizeof(usbtouch->phys)); 1568 strlcat(usbtouch->phys, "/input0", sizeof(usbtouch->phys)); 1569 1570 input_dev->name = usbtouch->name; 1571 input_dev->phys = usbtouch->phys; 1572 usb_to_input_id(udev, &input_dev->id); 1573 input_dev->dev.parent = &intf->dev; 1574 1575 input_set_drvdata(input_dev, usbtouch); 1576 1577 input_dev->open = usbtouch_open; 1578 input_dev->close = usbtouch_close; 1579 1580 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 1581 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 1582 input_set_abs_params(input_dev, ABS_X, type->min_xc, type->max_xc, 0, 0); 1583 input_set_abs_params(input_dev, ABS_Y, type->min_yc, type->max_yc, 0, 0); 1584 if (type->max_press) 1585 input_set_abs_params(input_dev, ABS_PRESSURE, type->min_press, 1586 type->max_press, 0, 0); 1587 1588 if (usb_endpoint_type(endpoint) == USB_ENDPOINT_XFER_INT) 1589 usb_fill_int_urb(usbtouch->irq, udev, 1590 usb_rcvintpipe(udev, endpoint->bEndpointAddress), 1591 usbtouch->data, type->rept_size, 1592 usbtouch_irq, usbtouch, endpoint->bInterval); 1593 else 1594 usb_fill_bulk_urb(usbtouch->irq, udev, 1595 usb_rcvbulkpipe(udev, endpoint->bEndpointAddress), 1596 usbtouch->data, type->rept_size, 1597 usbtouch_irq, usbtouch); 1598 1599 usbtouch->irq->dev = udev; 1600 usbtouch->irq->transfer_dma = usbtouch->data_dma; 1601 usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1602 1603 /* device specific allocations */ 1604 if (type->alloc) { 1605 err = type->alloc(usbtouch); 1606 if (err) { 1607 dev_dbg(&intf->dev, 1608 "%s - type->alloc() failed, err: %d\n", 1609 __func__, err); 1610 goto out_free_urb; 1611 } 1612 } 1613 1614 /* device specific initialisation*/ 1615 if (type->init) { 1616 err = type->init(usbtouch); 1617 if (err) { 1618 dev_dbg(&intf->dev, 1619 "%s - type->init() failed, err: %d\n", 1620 __func__, err); 1621 goto out_do_exit; 1622 } 1623 } 1624 1625 err = input_register_device(usbtouch->input); 1626 if (err) { 1627 dev_dbg(&intf->dev, 1628 "%s - input_register_device failed, err: %d\n", 1629 __func__, err); 1630 goto out_do_exit; 1631 } 1632 1633 usb_set_intfdata(intf, usbtouch); 1634 1635 if (usbtouch->type->irq_always) { 1636 /* this can't fail */ 1637 usb_autopm_get_interface(intf); 1638 err = usb_submit_urb(usbtouch->irq, GFP_KERNEL); 1639 if (err) { 1640 usb_autopm_put_interface(intf); 1641 dev_err(&intf->dev, 1642 "%s - usb_submit_urb failed with result: %d\n", 1643 __func__, err); 1644 goto out_unregister_input; 1645 } 1646 } 1647 1648 return 0; 1649 1650 out_unregister_input: 1651 input_unregister_device(input_dev); 1652 input_dev = NULL; 1653 out_do_exit: 1654 if (type->exit) 1655 type->exit(usbtouch); 1656 out_free_urb: 1657 usb_free_urb(usbtouch->irq); 1658 out_free_buffers: 1659 usbtouch_free_buffers(udev, usbtouch); 1660 out_free: 1661 input_free_device(input_dev); 1662 kfree(usbtouch); 1663 return err; 1664 } 1665 1666 static void usbtouch_disconnect(struct usb_interface *intf) 1667 { 1668 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1669 1670 if (!usbtouch) 1671 return; 1672 1673 dev_dbg(&intf->dev, 1674 "%s - usbtouch is initialized, cleaning up\n", __func__); 1675 1676 usb_set_intfdata(intf, NULL); 1677 /* this will stop IO via close */ 1678 input_unregister_device(usbtouch->input); 1679 usb_free_urb(usbtouch->irq); 1680 if (usbtouch->type->exit) 1681 usbtouch->type->exit(usbtouch); 1682 usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch); 1683 kfree(usbtouch); 1684 } 1685 1686 MODULE_DEVICE_TABLE(usb, usbtouch_devices); 1687 1688 static struct usb_driver usbtouch_driver = { 1689 .name = "usbtouchscreen", 1690 .probe = usbtouch_probe, 1691 .disconnect = usbtouch_disconnect, 1692 .suspend = usbtouch_suspend, 1693 .resume = usbtouch_resume, 1694 .reset_resume = usbtouch_reset_resume, 1695 .id_table = usbtouch_devices, 1696 .supports_autosuspend = 1, 1697 }; 1698 1699 module_usb_driver(usbtouch_driver); 1700 1701 MODULE_AUTHOR(DRIVER_AUTHOR); 1702 MODULE_DESCRIPTION(DRIVER_DESC); 1703 MODULE_LICENSE("GPL"); 1704 1705 MODULE_ALIAS("touchkitusb"); 1706 MODULE_ALIAS("itmtouch"); 1707 MODULE_ALIAS("mtouchusb"); 1708