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/usb.h> 55#include <linux/usb/input.h> 56#include <linux/hid.h> 57 58 59#define DRIVER_VERSION "v0.6" 60#define DRIVER_AUTHOR "Daniel Ritz <daniel.ritz@gmx.ch>" 61#define DRIVER_DESC "USB Touchscreen Driver" 62 63static bool swap_xy; 64module_param(swap_xy, bool, 0644); 65MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped."); 66 67static bool hwcalib_xy; 68module_param(hwcalib_xy, bool, 0644); 69MODULE_PARM_DESC(hwcalib_xy, "If set hw-calibrated X/Y are used if available"); 70 71/* device specifc data/functions */ 72struct usbtouch_usb; 73struct usbtouch_device_info { 74 int min_xc, max_xc; 75 int min_yc, max_yc; 76 int min_press, max_press; 77 int rept_size; 78 79 /* 80 * Always service the USB devices irq not just when the input device is 81 * open. This is useful when devices have a watchdog which prevents us 82 * from periodically polling the device. Leave this unset unless your 83 * touchscreen device requires it, as it does consume more of the USB 84 * bandwidth. 85 */ 86 bool irq_always; 87 88 void (*process_pkt) (struct usbtouch_usb *usbtouch, unsigned char *pkt, int len); 89 90 /* 91 * used to get the packet len. possible return values: 92 * > 0: packet len 93 * = 0: skip one byte 94 * < 0: -return value more bytes needed 95 */ 96 int (*get_pkt_len) (unsigned char *pkt, int len); 97 98 int (*read_data) (struct usbtouch_usb *usbtouch, unsigned char *pkt); 99 int (*alloc) (struct usbtouch_usb *usbtouch); 100 int (*init) (struct usbtouch_usb *usbtouch); 101 void (*exit) (struct usbtouch_usb *usbtouch); 102}; 103 104/* a usbtouch device */ 105struct usbtouch_usb { 106 unsigned char *data; 107 dma_addr_t data_dma; 108 int data_size; 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 */ 125enum { 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_IRTOUCH_HIRES, 136 DEVTYPE_IDEALTEK, 137 DEVTYPE_GENERAL_TOUCH, 138 DEVTYPE_GOTOP, 139 DEVTYPE_JASTEC, 140 DEVTYPE_E2I, 141 DEVTYPE_ZYTRONIC, 142 DEVTYPE_TC45USB, 143 DEVTYPE_NEXIO, 144 DEVTYPE_ELO, 145 DEVTYPE_ETOUCH, 146}; 147 148#define USB_DEVICE_HID_CLASS(vend, prod) \ 149 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS \ 150 | USB_DEVICE_ID_MATCH_DEVICE, \ 151 .idVendor = (vend), \ 152 .idProduct = (prod), \ 153 .bInterfaceClass = USB_INTERFACE_CLASS_HID 154 155static const struct usb_device_id usbtouch_devices[] = { 156#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX 157 /* ignore the HID capable devices, handled by usbhid */ 158 {USB_DEVICE_HID_CLASS(0x0eef, 0x0001), .driver_info = DEVTYPE_IGNORE}, 159 {USB_DEVICE_HID_CLASS(0x0eef, 0x0002), .driver_info = DEVTYPE_IGNORE}, 160 161 /* normal device IDs */ 162 {USB_DEVICE(0x3823, 0x0001), .driver_info = DEVTYPE_EGALAX}, 163 {USB_DEVICE(0x3823, 0x0002), .driver_info = DEVTYPE_EGALAX}, 164 {USB_DEVICE(0x0123, 0x0001), .driver_info = DEVTYPE_EGALAX}, 165 {USB_DEVICE(0x0eef, 0x0001), .driver_info = DEVTYPE_EGALAX}, 166 {USB_DEVICE(0x0eef, 0x0002), .driver_info = DEVTYPE_EGALAX}, 167 {USB_DEVICE(0x1234, 0x0001), .driver_info = DEVTYPE_EGALAX}, 168 {USB_DEVICE(0x1234, 0x0002), .driver_info = DEVTYPE_EGALAX}, 169#endif 170 171#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT 172 {USB_DEVICE(0x134c, 0x0001), .driver_info = DEVTYPE_PANJIT}, 173 {USB_DEVICE(0x134c, 0x0002), .driver_info = DEVTYPE_PANJIT}, 174 {USB_DEVICE(0x134c, 0x0003), .driver_info = DEVTYPE_PANJIT}, 175 {USB_DEVICE(0x134c, 0x0004), .driver_info = DEVTYPE_PANJIT}, 176#endif 177 178#ifdef CONFIG_TOUCHSCREEN_USB_3M 179 {USB_DEVICE(0x0596, 0x0001), .driver_info = DEVTYPE_3M}, 180#endif 181 182#ifdef CONFIG_TOUCHSCREEN_USB_ITM 183 {USB_DEVICE(0x0403, 0xf9e9), .driver_info = DEVTYPE_ITM}, 184 {USB_DEVICE(0x16e3, 0xf9e9), .driver_info = DEVTYPE_ITM}, 185#endif 186 187#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO 188 {USB_DEVICE(0x1234, 0x5678), .driver_info = DEVTYPE_ETURBO}, 189#endif 190 191#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE 192 {USB_DEVICE(0x0637, 0x0001), .driver_info = DEVTYPE_GUNZE}, 193#endif 194 195#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10 196 {USB_DEVICE(0x0afa, 0x03e8), .driver_info = DEVTYPE_DMC_TSC10}, 197#endif 198 199#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 200 {USB_DEVICE(0x595a, 0x0001), .driver_info = DEVTYPE_IRTOUCH}, 201 {USB_DEVICE(0x6615, 0x0001), .driver_info = DEVTYPE_IRTOUCH}, 202 {USB_DEVICE(0x6615, 0x0012), .driver_info = DEVTYPE_IRTOUCH_HIRES}, 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 263static 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 278static 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 307static 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 346static 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 358static 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 390static 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 403static 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 425static 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 445static 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 459static 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 504static 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 541static 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 557static 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 572static 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 608static 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 /* TSC-25 data sheet specifies a delay after the RESET command */ 631 msleep(150); 632 633 /* set coordinate output rate */ 634 buf[0] = buf[1] = 0xFF; 635 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 636 TSC10_CMD_RATE, 637 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 638 TSC10_RATE_150, 0, buf, 2, USB_CTRL_SET_TIMEOUT); 639 if (ret < 0) 640 goto err_out; 641 if ((buf[0] != 0x06) && (buf[0] != 0x15 || buf[1] != 0x01)) { 642 ret = -ENODEV; 643 goto err_out; 644 } 645 646 /* start sending data */ 647 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0), 648 TSC10_CMD_DATA1, 649 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 650 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT); 651err_out: 652 kfree(buf); 653err_nobuf: 654 return ret; 655} 656 657 658static int dmc_tsc10_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 659{ 660 dev->x = ((pkt[2] & 0x03) << 8) | pkt[1]; 661 dev->y = ((pkt[4] & 0x03) << 8) | pkt[3]; 662 dev->touch = pkt[0] & 0x01; 663 664 return 1; 665} 666#endif 667 668 669/***************************************************************************** 670 * IRTOUCH Part 671 */ 672#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 673static int irtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 674{ 675 dev->x = (pkt[3] << 8) | pkt[2]; 676 dev->y = (pkt[5] << 8) | pkt[4]; 677 dev->touch = (pkt[1] & 0x03) ? 1 : 0; 678 679 return 1; 680} 681#endif 682 683/***************************************************************************** 684 * ET&T TC5UH/TC4UM part 685 */ 686#ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB 687static int tc45usb_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 688{ 689 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1]; 690 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3]; 691 dev->touch = pkt[0] & 0x01; 692 693 return 1; 694} 695#endif 696 697/***************************************************************************** 698 * IdealTEK URTC1000 Part 699 */ 700#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 701#ifndef MULTI_PACKET 702#define MULTI_PACKET 703#endif 704static int idealtek_get_pkt_len(unsigned char *buf, int len) 705{ 706 if (buf[0] & 0x80) 707 return 5; 708 if (buf[0] == 0x01) 709 return len; 710 return 0; 711} 712 713static int idealtek_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 714{ 715 switch (pkt[0] & 0x98) { 716 case 0x88: 717 /* touch data in IdealTEK mode */ 718 dev->x = (pkt[1] << 5) | (pkt[2] >> 2); 719 dev->y = (pkt[3] << 5) | (pkt[4] >> 2); 720 dev->touch = (pkt[0] & 0x40) ? 1 : 0; 721 return 1; 722 723 case 0x98: 724 /* touch data in MT emulation mode */ 725 dev->x = (pkt[2] << 5) | (pkt[1] >> 2); 726 dev->y = (pkt[4] << 5) | (pkt[3] >> 2); 727 dev->touch = (pkt[0] & 0x40) ? 1 : 0; 728 return 1; 729 730 default: 731 return 0; 732 } 733} 734#endif 735 736/***************************************************************************** 737 * General Touch Part 738 */ 739#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 740static int general_touch_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 741{ 742 dev->x = (pkt[2] << 8) | pkt[1]; 743 dev->y = (pkt[4] << 8) | pkt[3]; 744 dev->press = pkt[5] & 0xff; 745 dev->touch = pkt[0] & 0x01; 746 747 return 1; 748} 749#endif 750 751/***************************************************************************** 752 * GoTop Part 753 */ 754#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 755static int gotop_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 756{ 757 dev->x = ((pkt[1] & 0x38) << 4) | pkt[2]; 758 dev->y = ((pkt[1] & 0x07) << 7) | pkt[3]; 759 dev->touch = pkt[0] & 0x01; 760 761 return 1; 762} 763#endif 764 765/***************************************************************************** 766 * JASTEC Part 767 */ 768#ifdef CONFIG_TOUCHSCREEN_USB_JASTEC 769static int jastec_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 770{ 771 dev->x = ((pkt[0] & 0x3f) << 6) | (pkt[2] & 0x3f); 772 dev->y = ((pkt[1] & 0x3f) << 6) | (pkt[3] & 0x3f); 773 dev->touch = (pkt[0] & 0x40) >> 6; 774 775 return 1; 776} 777#endif 778 779/***************************************************************************** 780 * Zytronic Part 781 */ 782#ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC 783static int zytronic_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 784{ 785 struct usb_interface *intf = dev->interface; 786 787 switch (pkt[0]) { 788 case 0x3A: /* command response */ 789 dev_dbg(&intf->dev, "%s: Command response %d\n", __func__, pkt[1]); 790 break; 791 792 case 0xC0: /* down */ 793 dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7); 794 dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7); 795 dev->touch = 1; 796 dev_dbg(&intf->dev, "%s: down %d,%d\n", __func__, dev->x, dev->y); 797 return 1; 798 799 case 0x80: /* up */ 800 dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7); 801 dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7); 802 dev->touch = 0; 803 dev_dbg(&intf->dev, "%s: up %d,%d\n", __func__, dev->x, dev->y); 804 return 1; 805 806 default: 807 dev_dbg(&intf->dev, "%s: Unknown return %d\n", __func__, pkt[0]); 808 break; 809 } 810 811 return 0; 812} 813#endif 814 815/***************************************************************************** 816 * NEXIO Part 817 */ 818#ifdef CONFIG_TOUCHSCREEN_USB_NEXIO 819 820#define NEXIO_TIMEOUT 5000 821#define NEXIO_BUFSIZE 1024 822#define NEXIO_THRESHOLD 50 823 824struct nexio_priv { 825 struct urb *ack; 826 unsigned char *ack_buf; 827}; 828 829struct nexio_touch_packet { 830 u8 flags; /* 0xe1 = touch, 0xe1 = release */ 831 __be16 data_len; /* total bytes of touch data */ 832 __be16 x_len; /* bytes for X axis */ 833 __be16 y_len; /* bytes for Y axis */ 834 u8 data[]; 835} __attribute__ ((packed)); 836 837static unsigned char nexio_ack_pkt[2] = { 0xaa, 0x02 }; 838static unsigned char nexio_init_pkt[4] = { 0x82, 0x04, 0x0a, 0x0f }; 839 840static void nexio_ack_complete(struct urb *urb) 841{ 842} 843 844static int nexio_alloc(struct usbtouch_usb *usbtouch) 845{ 846 struct nexio_priv *priv; 847 int ret = -ENOMEM; 848 849 usbtouch->priv = kmalloc(sizeof(struct nexio_priv), GFP_KERNEL); 850 if (!usbtouch->priv) 851 goto out_buf; 852 853 priv = usbtouch->priv; 854 855 priv->ack_buf = kmemdup(nexio_ack_pkt, sizeof(nexio_ack_pkt), 856 GFP_KERNEL); 857 if (!priv->ack_buf) 858 goto err_priv; 859 860 priv->ack = usb_alloc_urb(0, GFP_KERNEL); 861 if (!priv->ack) { 862 dev_dbg(&usbtouch->interface->dev, 863 "%s - usb_alloc_urb failed: usbtouch->ack\n", __func__); 864 goto err_ack_buf; 865 } 866 867 return 0; 868 869err_ack_buf: 870 kfree(priv->ack_buf); 871err_priv: 872 kfree(priv); 873out_buf: 874 return ret; 875} 876 877static int nexio_init(struct usbtouch_usb *usbtouch) 878{ 879 struct usb_device *dev = interface_to_usbdev(usbtouch->interface); 880 struct usb_host_interface *interface = usbtouch->interface->cur_altsetting; 881 struct nexio_priv *priv = usbtouch->priv; 882 int ret = -ENOMEM; 883 int actual_len, i; 884 unsigned char *buf; 885 char *firmware_ver = NULL, *device_name = NULL; 886 int input_ep = 0, output_ep = 0; 887 888 /* find first input and output endpoint */ 889 for (i = 0; i < interface->desc.bNumEndpoints; i++) { 890 if (!input_ep && 891 usb_endpoint_dir_in(&interface->endpoint[i].desc)) 892 input_ep = interface->endpoint[i].desc.bEndpointAddress; 893 if (!output_ep && 894 usb_endpoint_dir_out(&interface->endpoint[i].desc)) 895 output_ep = interface->endpoint[i].desc.bEndpointAddress; 896 } 897 if (!input_ep || !output_ep) 898 return -ENXIO; 899 900 buf = kmalloc(NEXIO_BUFSIZE, GFP_NOIO); 901 if (!buf) 902 goto out_buf; 903 904 /* two empty reads */ 905 for (i = 0; i < 2; i++) { 906 ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, input_ep), 907 buf, NEXIO_BUFSIZE, &actual_len, 908 NEXIO_TIMEOUT); 909 if (ret < 0) 910 goto out_buf; 911 } 912 913 /* send init command */ 914 memcpy(buf, nexio_init_pkt, sizeof(nexio_init_pkt)); 915 ret = usb_bulk_msg(dev, usb_sndbulkpipe(dev, output_ep), 916 buf, sizeof(nexio_init_pkt), &actual_len, 917 NEXIO_TIMEOUT); 918 if (ret < 0) 919 goto out_buf; 920 921 /* read replies */ 922 for (i = 0; i < 3; i++) { 923 memset(buf, 0, NEXIO_BUFSIZE); 924 ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, input_ep), 925 buf, NEXIO_BUFSIZE, &actual_len, 926 NEXIO_TIMEOUT); 927 if (ret < 0 || actual_len < 1 || buf[1] != actual_len) 928 continue; 929 switch (buf[0]) { 930 case 0x83: /* firmware version */ 931 if (!firmware_ver) 932 firmware_ver = kstrdup(&buf[2], GFP_NOIO); 933 break; 934 case 0x84: /* device name */ 935 if (!device_name) 936 device_name = kstrdup(&buf[2], GFP_NOIO); 937 break; 938 } 939 } 940 941 printk(KERN_INFO "Nexio device: %s, firmware version: %s\n", 942 device_name, firmware_ver); 943 944 kfree(firmware_ver); 945 kfree(device_name); 946 947 usb_fill_bulk_urb(priv->ack, dev, usb_sndbulkpipe(dev, output_ep), 948 priv->ack_buf, sizeof(nexio_ack_pkt), 949 nexio_ack_complete, usbtouch); 950 ret = 0; 951 952out_buf: 953 kfree(buf); 954 return ret; 955} 956 957static void nexio_exit(struct usbtouch_usb *usbtouch) 958{ 959 struct nexio_priv *priv = usbtouch->priv; 960 961 usb_kill_urb(priv->ack); 962 usb_free_urb(priv->ack); 963 kfree(priv->ack_buf); 964 kfree(priv); 965} 966 967static int nexio_read_data(struct usbtouch_usb *usbtouch, unsigned char *pkt) 968{ 969 struct nexio_touch_packet *packet = (void *) pkt; 970 struct nexio_priv *priv = usbtouch->priv; 971 unsigned int data_len = be16_to_cpu(packet->data_len); 972 unsigned int x_len = be16_to_cpu(packet->x_len); 973 unsigned int y_len = be16_to_cpu(packet->y_len); 974 int x, y, begin_x, begin_y, end_x, end_y, w, h, ret; 975 976 /* got touch data? */ 977 if ((pkt[0] & 0xe0) != 0xe0) 978 return 0; 979 980 if (data_len > 0xff) 981 data_len -= 0x100; 982 if (x_len > 0xff) 983 x_len -= 0x80; 984 985 /* send ACK */ 986 ret = usb_submit_urb(priv->ack, GFP_ATOMIC); 987 988 if (!usbtouch->type->max_xc) { 989 usbtouch->type->max_xc = 2 * x_len; 990 input_set_abs_params(usbtouch->input, ABS_X, 991 0, usbtouch->type->max_xc, 0, 0); 992 usbtouch->type->max_yc = 2 * y_len; 993 input_set_abs_params(usbtouch->input, ABS_Y, 994 0, usbtouch->type->max_yc, 0, 0); 995 } 996 /* 997 * The device reports state of IR sensors on X and Y axes. 998 * Each byte represents "darkness" percentage (0-100) of one element. 999 * 17" touchscreen reports only 64 x 52 bytes so the resolution is low. 1000 * This also means that there's a limited multi-touch capability but 1001 * it's disabled (and untested) here as there's no X driver for that. 1002 */ 1003 begin_x = end_x = begin_y = end_y = -1; 1004 for (x = 0; x < x_len; x++) { 1005 if (begin_x == -1 && packet->data[x] > NEXIO_THRESHOLD) { 1006 begin_x = x; 1007 continue; 1008 } 1009 if (end_x == -1 && begin_x != -1 && packet->data[x] < NEXIO_THRESHOLD) { 1010 end_x = x - 1; 1011 for (y = x_len; y < data_len; y++) { 1012 if (begin_y == -1 && packet->data[y] > NEXIO_THRESHOLD) { 1013 begin_y = y - x_len; 1014 continue; 1015 } 1016 if (end_y == -1 && 1017 begin_y != -1 && packet->data[y] < NEXIO_THRESHOLD) { 1018 end_y = y - 1 - x_len; 1019 w = end_x - begin_x; 1020 h = end_y - begin_y; 1021#if 0 1022 /* multi-touch */ 1023 input_report_abs(usbtouch->input, 1024 ABS_MT_TOUCH_MAJOR, max(w,h)); 1025 input_report_abs(usbtouch->input, 1026 ABS_MT_TOUCH_MINOR, min(x,h)); 1027 input_report_abs(usbtouch->input, 1028 ABS_MT_POSITION_X, 2*begin_x+w); 1029 input_report_abs(usbtouch->input, 1030 ABS_MT_POSITION_Y, 2*begin_y+h); 1031 input_report_abs(usbtouch->input, 1032 ABS_MT_ORIENTATION, w > h); 1033 input_mt_sync(usbtouch->input); 1034#endif 1035 /* single touch */ 1036 usbtouch->x = 2 * begin_x + w; 1037 usbtouch->y = 2 * begin_y + h; 1038 usbtouch->touch = packet->flags & 0x01; 1039 begin_y = end_y = -1; 1040 return 1; 1041 } 1042 } 1043 begin_x = end_x = -1; 1044 } 1045 1046 } 1047 return 0; 1048} 1049#endif 1050 1051 1052/***************************************************************************** 1053 * ELO part 1054 */ 1055 1056#ifdef CONFIG_TOUCHSCREEN_USB_ELO 1057 1058static int elo_read_data(struct usbtouch_usb *dev, unsigned char *pkt) 1059{ 1060 dev->x = (pkt[3] << 8) | pkt[2]; 1061 dev->y = (pkt[5] << 8) | pkt[4]; 1062 dev->touch = pkt[6] > 0; 1063 dev->press = pkt[6]; 1064 1065 return 1; 1066} 1067#endif 1068 1069 1070/***************************************************************************** 1071 * the different device descriptors 1072 */ 1073#ifdef MULTI_PACKET 1074static void usbtouch_process_multi(struct usbtouch_usb *usbtouch, 1075 unsigned char *pkt, int len); 1076#endif 1077 1078static struct usbtouch_device_info usbtouch_dev_info[] = { 1079#ifdef CONFIG_TOUCHSCREEN_USB_ELO 1080 [DEVTYPE_ELO] = { 1081 .min_xc = 0x0, 1082 .max_xc = 0x0fff, 1083 .min_yc = 0x0, 1084 .max_yc = 0x0fff, 1085 .max_press = 0xff, 1086 .rept_size = 8, 1087 .read_data = elo_read_data, 1088 }, 1089#endif 1090 1091#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX 1092 [DEVTYPE_EGALAX] = { 1093 .min_xc = 0x0, 1094 .max_xc = 0x07ff, 1095 .min_yc = 0x0, 1096 .max_yc = 0x07ff, 1097 .rept_size = 16, 1098 .process_pkt = usbtouch_process_multi, 1099 .get_pkt_len = egalax_get_pkt_len, 1100 .read_data = egalax_read_data, 1101 .init = egalax_init, 1102 }, 1103#endif 1104 1105#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT 1106 [DEVTYPE_PANJIT] = { 1107 .min_xc = 0x0, 1108 .max_xc = 0x0fff, 1109 .min_yc = 0x0, 1110 .max_yc = 0x0fff, 1111 .rept_size = 8, 1112 .read_data = panjit_read_data, 1113 }, 1114#endif 1115 1116#ifdef CONFIG_TOUCHSCREEN_USB_3M 1117 [DEVTYPE_3M] = { 1118 .min_xc = 0x0, 1119 .max_xc = 0x4000, 1120 .min_yc = 0x0, 1121 .max_yc = 0x4000, 1122 .rept_size = 11, 1123 .read_data = mtouch_read_data, 1124 .init = mtouch_init, 1125 }, 1126#endif 1127 1128#ifdef CONFIG_TOUCHSCREEN_USB_ITM 1129 [DEVTYPE_ITM] = { 1130 .min_xc = 0x0, 1131 .max_xc = 0x0fff, 1132 .min_yc = 0x0, 1133 .max_yc = 0x0fff, 1134 .max_press = 0xff, 1135 .rept_size = 8, 1136 .read_data = itm_read_data, 1137 }, 1138#endif 1139 1140#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO 1141 [DEVTYPE_ETURBO] = { 1142 .min_xc = 0x0, 1143 .max_xc = 0x07ff, 1144 .min_yc = 0x0, 1145 .max_yc = 0x07ff, 1146 .rept_size = 8, 1147 .process_pkt = usbtouch_process_multi, 1148 .get_pkt_len = eturbo_get_pkt_len, 1149 .read_data = eturbo_read_data, 1150 }, 1151#endif 1152 1153#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE 1154 [DEVTYPE_GUNZE] = { 1155 .min_xc = 0x0, 1156 .max_xc = 0x0fff, 1157 .min_yc = 0x0, 1158 .max_yc = 0x0fff, 1159 .rept_size = 4, 1160 .read_data = gunze_read_data, 1161 }, 1162#endif 1163 1164#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10 1165 [DEVTYPE_DMC_TSC10] = { 1166 .min_xc = 0x0, 1167 .max_xc = 0x03ff, 1168 .min_yc = 0x0, 1169 .max_yc = 0x03ff, 1170 .rept_size = 5, 1171 .init = dmc_tsc10_init, 1172 .read_data = dmc_tsc10_read_data, 1173 }, 1174#endif 1175 1176#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH 1177 [DEVTYPE_IRTOUCH] = { 1178 .min_xc = 0x0, 1179 .max_xc = 0x0fff, 1180 .min_yc = 0x0, 1181 .max_yc = 0x0fff, 1182 .rept_size = 8, 1183 .read_data = irtouch_read_data, 1184 }, 1185 1186 [DEVTYPE_IRTOUCH_HIRES] = { 1187 .min_xc = 0x0, 1188 .max_xc = 0x7fff, 1189 .min_yc = 0x0, 1190 .max_yc = 0x7fff, 1191 .rept_size = 8, 1192 .read_data = irtouch_read_data, 1193 }, 1194#endif 1195 1196#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK 1197 [DEVTYPE_IDEALTEK] = { 1198 .min_xc = 0x0, 1199 .max_xc = 0x0fff, 1200 .min_yc = 0x0, 1201 .max_yc = 0x0fff, 1202 .rept_size = 8, 1203 .process_pkt = usbtouch_process_multi, 1204 .get_pkt_len = idealtek_get_pkt_len, 1205 .read_data = idealtek_read_data, 1206 }, 1207#endif 1208 1209#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH 1210 [DEVTYPE_GENERAL_TOUCH] = { 1211 .min_xc = 0x0, 1212 .max_xc = 0x7fff, 1213 .min_yc = 0x0, 1214 .max_yc = 0x7fff, 1215 .rept_size = 7, 1216 .read_data = general_touch_read_data, 1217 }, 1218#endif 1219 1220#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP 1221 [DEVTYPE_GOTOP] = { 1222 .min_xc = 0x0, 1223 .max_xc = 0x03ff, 1224 .min_yc = 0x0, 1225 .max_yc = 0x03ff, 1226 .rept_size = 4, 1227 .read_data = gotop_read_data, 1228 }, 1229#endif 1230 1231#ifdef CONFIG_TOUCHSCREEN_USB_JASTEC 1232 [DEVTYPE_JASTEC] = { 1233 .min_xc = 0x0, 1234 .max_xc = 0x0fff, 1235 .min_yc = 0x0, 1236 .max_yc = 0x0fff, 1237 .rept_size = 4, 1238 .read_data = jastec_read_data, 1239 }, 1240#endif 1241 1242#ifdef CONFIG_TOUCHSCREEN_USB_E2I 1243 [DEVTYPE_E2I] = { 1244 .min_xc = 0x0, 1245 .max_xc = 0x7fff, 1246 .min_yc = 0x0, 1247 .max_yc = 0x7fff, 1248 .rept_size = 6, 1249 .init = e2i_init, 1250 .read_data = e2i_read_data, 1251 }, 1252#endif 1253 1254#ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC 1255 [DEVTYPE_ZYTRONIC] = { 1256 .min_xc = 0x0, 1257 .max_xc = 0x03ff, 1258 .min_yc = 0x0, 1259 .max_yc = 0x03ff, 1260 .rept_size = 5, 1261 .read_data = zytronic_read_data, 1262 .irq_always = true, 1263 }, 1264#endif 1265 1266#ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB 1267 [DEVTYPE_TC45USB] = { 1268 .min_xc = 0x0, 1269 .max_xc = 0x0fff, 1270 .min_yc = 0x0, 1271 .max_yc = 0x0fff, 1272 .rept_size = 5, 1273 .read_data = tc45usb_read_data, 1274 }, 1275#endif 1276 1277#ifdef CONFIG_TOUCHSCREEN_USB_NEXIO 1278 [DEVTYPE_NEXIO] = { 1279 .rept_size = 1024, 1280 .irq_always = true, 1281 .read_data = nexio_read_data, 1282 .alloc = nexio_alloc, 1283 .init = nexio_init, 1284 .exit = nexio_exit, 1285 }, 1286#endif 1287#ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH 1288 [DEVTYPE_ETOUCH] = { 1289 .min_xc = 0x0, 1290 .max_xc = 0x07ff, 1291 .min_yc = 0x0, 1292 .max_yc = 0x07ff, 1293 .rept_size = 16, 1294 .process_pkt = usbtouch_process_multi, 1295 .get_pkt_len = etouch_get_pkt_len, 1296 .read_data = etouch_read_data, 1297 }, 1298#endif 1299}; 1300 1301 1302/***************************************************************************** 1303 * Generic Part 1304 */ 1305static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch, 1306 unsigned char *pkt, int len) 1307{ 1308 struct usbtouch_device_info *type = usbtouch->type; 1309 1310 if (!type->read_data(usbtouch, pkt)) 1311 return; 1312 1313 input_report_key(usbtouch->input, BTN_TOUCH, usbtouch->touch); 1314 1315 if (swap_xy) { 1316 input_report_abs(usbtouch->input, ABS_X, usbtouch->y); 1317 input_report_abs(usbtouch->input, ABS_Y, usbtouch->x); 1318 } else { 1319 input_report_abs(usbtouch->input, ABS_X, usbtouch->x); 1320 input_report_abs(usbtouch->input, ABS_Y, usbtouch->y); 1321 } 1322 if (type->max_press) 1323 input_report_abs(usbtouch->input, ABS_PRESSURE, usbtouch->press); 1324 input_sync(usbtouch->input); 1325} 1326 1327 1328#ifdef MULTI_PACKET 1329static void usbtouch_process_multi(struct usbtouch_usb *usbtouch, 1330 unsigned char *pkt, int len) 1331{ 1332 unsigned char *buffer; 1333 int pkt_len, pos, buf_len, tmp; 1334 1335 /* process buffer */ 1336 if (unlikely(usbtouch->buf_len)) { 1337 /* try to get size */ 1338 pkt_len = usbtouch->type->get_pkt_len( 1339 usbtouch->buffer, usbtouch->buf_len); 1340 1341 /* drop? */ 1342 if (unlikely(!pkt_len)) 1343 goto out_flush_buf; 1344 1345 /* need to append -pkt_len bytes before able to get size */ 1346 if (unlikely(pkt_len < 0)) { 1347 int append = -pkt_len; 1348 if (unlikely(append > len)) 1349 append = len; 1350 if (usbtouch->buf_len + append >= usbtouch->type->rept_size) 1351 goto out_flush_buf; 1352 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, append); 1353 usbtouch->buf_len += append; 1354 1355 pkt_len = usbtouch->type->get_pkt_len( 1356 usbtouch->buffer, usbtouch->buf_len); 1357 if (pkt_len < 0) 1358 return; 1359 } 1360 1361 /* append */ 1362 tmp = pkt_len - usbtouch->buf_len; 1363 if (usbtouch->buf_len + tmp >= usbtouch->type->rept_size) 1364 goto out_flush_buf; 1365 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, tmp); 1366 usbtouch_process_pkt(usbtouch, usbtouch->buffer, pkt_len); 1367 1368 buffer = pkt + tmp; 1369 buf_len = len - tmp; 1370 } else { 1371 buffer = pkt; 1372 buf_len = len; 1373 } 1374 1375 /* loop over the received packet, process */ 1376 pos = 0; 1377 while (pos < buf_len) { 1378 /* get packet len */ 1379 pkt_len = usbtouch->type->get_pkt_len(buffer + pos, 1380 buf_len - pos); 1381 1382 /* unknown packet: skip one byte */ 1383 if (unlikely(!pkt_len)) { 1384 pos++; 1385 continue; 1386 } 1387 1388 /* full packet: process */ 1389 if (likely((pkt_len > 0) && (pkt_len <= buf_len - pos))) { 1390 usbtouch_process_pkt(usbtouch, buffer + pos, pkt_len); 1391 } else { 1392 /* incomplete packet: save in buffer */ 1393 memcpy(usbtouch->buffer, buffer + pos, buf_len - pos); 1394 usbtouch->buf_len = buf_len - pos; 1395 return; 1396 } 1397 pos += pkt_len; 1398 } 1399 1400out_flush_buf: 1401 usbtouch->buf_len = 0; 1402 return; 1403} 1404#endif 1405 1406 1407static void usbtouch_irq(struct urb *urb) 1408{ 1409 struct usbtouch_usb *usbtouch = urb->context; 1410 struct device *dev = &usbtouch->interface->dev; 1411 int retval; 1412 1413 switch (urb->status) { 1414 case 0: 1415 /* success */ 1416 break; 1417 case -ETIME: 1418 /* this urb is timing out */ 1419 dev_dbg(dev, 1420 "%s - urb timed out - was the device unplugged?\n", 1421 __func__); 1422 return; 1423 case -ECONNRESET: 1424 case -ENOENT: 1425 case -ESHUTDOWN: 1426 case -EPIPE: 1427 /* this urb is terminated, clean up */ 1428 dev_dbg(dev, "%s - urb shutting down with status: %d\n", 1429 __func__, urb->status); 1430 return; 1431 default: 1432 dev_dbg(dev, "%s - nonzero urb status received: %d\n", 1433 __func__, urb->status); 1434 goto exit; 1435 } 1436 1437 usbtouch->type->process_pkt(usbtouch, usbtouch->data, urb->actual_length); 1438 1439exit: 1440 usb_mark_last_busy(interface_to_usbdev(usbtouch->interface)); 1441 retval = usb_submit_urb(urb, GFP_ATOMIC); 1442 if (retval) 1443 dev_err(dev, "%s - usb_submit_urb failed with result: %d\n", 1444 __func__, retval); 1445} 1446 1447static int usbtouch_open(struct input_dev *input) 1448{ 1449 struct usbtouch_usb *usbtouch = input_get_drvdata(input); 1450 int r; 1451 1452 usbtouch->irq->dev = interface_to_usbdev(usbtouch->interface); 1453 1454 r = usb_autopm_get_interface(usbtouch->interface) ? -EIO : 0; 1455 if (r < 0) 1456 goto out; 1457 1458 if (!usbtouch->type->irq_always) { 1459 if (usb_submit_urb(usbtouch->irq, GFP_KERNEL)) { 1460 r = -EIO; 1461 goto out_put; 1462 } 1463 } 1464 1465 usbtouch->interface->needs_remote_wakeup = 1; 1466out_put: 1467 usb_autopm_put_interface(usbtouch->interface); 1468out: 1469 return r; 1470} 1471 1472static void usbtouch_close(struct input_dev *input) 1473{ 1474 struct usbtouch_usb *usbtouch = input_get_drvdata(input); 1475 int r; 1476 1477 if (!usbtouch->type->irq_always) 1478 usb_kill_urb(usbtouch->irq); 1479 r = usb_autopm_get_interface(usbtouch->interface); 1480 usbtouch->interface->needs_remote_wakeup = 0; 1481 if (!r) 1482 usb_autopm_put_interface(usbtouch->interface); 1483} 1484 1485static int usbtouch_suspend 1486(struct usb_interface *intf, pm_message_t message) 1487{ 1488 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1489 1490 usb_kill_urb(usbtouch->irq); 1491 1492 return 0; 1493} 1494 1495static int usbtouch_resume(struct usb_interface *intf) 1496{ 1497 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1498 struct input_dev *input = usbtouch->input; 1499 int result = 0; 1500 1501 mutex_lock(&input->mutex); 1502 if (input->users || usbtouch->type->irq_always) 1503 result = usb_submit_urb(usbtouch->irq, GFP_NOIO); 1504 mutex_unlock(&input->mutex); 1505 1506 return result; 1507} 1508 1509static int usbtouch_reset_resume(struct usb_interface *intf) 1510{ 1511 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1512 struct input_dev *input = usbtouch->input; 1513 int err = 0; 1514 1515 /* reinit the device */ 1516 if (usbtouch->type->init) { 1517 err = usbtouch->type->init(usbtouch); 1518 if (err) { 1519 dev_dbg(&intf->dev, 1520 "%s - type->init() failed, err: %d\n", 1521 __func__, err); 1522 return err; 1523 } 1524 } 1525 1526 /* restart IO if needed */ 1527 mutex_lock(&input->mutex); 1528 if (input->users) 1529 err = usb_submit_urb(usbtouch->irq, GFP_NOIO); 1530 mutex_unlock(&input->mutex); 1531 1532 return err; 1533} 1534 1535static void usbtouch_free_buffers(struct usb_device *udev, 1536 struct usbtouch_usb *usbtouch) 1537{ 1538 usb_free_coherent(udev, usbtouch->data_size, 1539 usbtouch->data, usbtouch->data_dma); 1540 kfree(usbtouch->buffer); 1541} 1542 1543static struct usb_endpoint_descriptor * 1544usbtouch_get_input_endpoint(struct usb_host_interface *interface) 1545{ 1546 int i; 1547 1548 for (i = 0; i < interface->desc.bNumEndpoints; i++) 1549 if (usb_endpoint_dir_in(&interface->endpoint[i].desc)) 1550 return &interface->endpoint[i].desc; 1551 1552 return NULL; 1553} 1554 1555static int usbtouch_probe(struct usb_interface *intf, 1556 const struct usb_device_id *id) 1557{ 1558 struct usbtouch_usb *usbtouch; 1559 struct input_dev *input_dev; 1560 struct usb_endpoint_descriptor *endpoint; 1561 struct usb_device *udev = interface_to_usbdev(intf); 1562 struct usbtouch_device_info *type; 1563 int err = -ENOMEM; 1564 1565 /* some devices are ignored */ 1566 if (id->driver_info == DEVTYPE_IGNORE) 1567 return -ENODEV; 1568 1569 endpoint = usbtouch_get_input_endpoint(intf->cur_altsetting); 1570 if (!endpoint) 1571 return -ENXIO; 1572 1573 usbtouch = kzalloc(sizeof(struct usbtouch_usb), GFP_KERNEL); 1574 input_dev = input_allocate_device(); 1575 if (!usbtouch || !input_dev) 1576 goto out_free; 1577 1578 type = &usbtouch_dev_info[id->driver_info]; 1579 usbtouch->type = type; 1580 if (!type->process_pkt) 1581 type->process_pkt = usbtouch_process_pkt; 1582 1583 usbtouch->data_size = type->rept_size; 1584 if (type->get_pkt_len) { 1585 /* 1586 * When dealing with variable-length packets we should 1587 * not request more than wMaxPacketSize bytes at once 1588 * as we do not know if there is more data coming or 1589 * we filled exactly wMaxPacketSize bytes and there is 1590 * nothing else. 1591 */ 1592 usbtouch->data_size = min(usbtouch->data_size, 1593 usb_endpoint_maxp(endpoint)); 1594 } 1595 1596 usbtouch->data = usb_alloc_coherent(udev, usbtouch->data_size, 1597 GFP_KERNEL, &usbtouch->data_dma); 1598 if (!usbtouch->data) 1599 goto out_free; 1600 1601 if (type->get_pkt_len) { 1602 usbtouch->buffer = kmalloc(type->rept_size, GFP_KERNEL); 1603 if (!usbtouch->buffer) 1604 goto out_free_buffers; 1605 } 1606 1607 usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL); 1608 if (!usbtouch->irq) { 1609 dev_dbg(&intf->dev, 1610 "%s - usb_alloc_urb failed: usbtouch->irq\n", __func__); 1611 goto out_free_buffers; 1612 } 1613 1614 usbtouch->interface = intf; 1615 usbtouch->input = input_dev; 1616 1617 if (udev->manufacturer) 1618 strlcpy(usbtouch->name, udev->manufacturer, sizeof(usbtouch->name)); 1619 1620 if (udev->product) { 1621 if (udev->manufacturer) 1622 strlcat(usbtouch->name, " ", sizeof(usbtouch->name)); 1623 strlcat(usbtouch->name, udev->product, sizeof(usbtouch->name)); 1624 } 1625 1626 if (!strlen(usbtouch->name)) 1627 snprintf(usbtouch->name, sizeof(usbtouch->name), 1628 "USB Touchscreen %04x:%04x", 1629 le16_to_cpu(udev->descriptor.idVendor), 1630 le16_to_cpu(udev->descriptor.idProduct)); 1631 1632 usb_make_path(udev, usbtouch->phys, sizeof(usbtouch->phys)); 1633 strlcat(usbtouch->phys, "/input0", sizeof(usbtouch->phys)); 1634 1635 input_dev->name = usbtouch->name; 1636 input_dev->phys = usbtouch->phys; 1637 usb_to_input_id(udev, &input_dev->id); 1638 input_dev->dev.parent = &intf->dev; 1639 1640 input_set_drvdata(input_dev, usbtouch); 1641 1642 input_dev->open = usbtouch_open; 1643 input_dev->close = usbtouch_close; 1644 1645 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 1646 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 1647 input_set_abs_params(input_dev, ABS_X, type->min_xc, type->max_xc, 0, 0); 1648 input_set_abs_params(input_dev, ABS_Y, type->min_yc, type->max_yc, 0, 0); 1649 if (type->max_press) 1650 input_set_abs_params(input_dev, ABS_PRESSURE, type->min_press, 1651 type->max_press, 0, 0); 1652 1653 if (usb_endpoint_type(endpoint) == USB_ENDPOINT_XFER_INT) 1654 usb_fill_int_urb(usbtouch->irq, udev, 1655 usb_rcvintpipe(udev, endpoint->bEndpointAddress), 1656 usbtouch->data, usbtouch->data_size, 1657 usbtouch_irq, usbtouch, endpoint->bInterval); 1658 else 1659 usb_fill_bulk_urb(usbtouch->irq, udev, 1660 usb_rcvbulkpipe(udev, endpoint->bEndpointAddress), 1661 usbtouch->data, usbtouch->data_size, 1662 usbtouch_irq, usbtouch); 1663 1664 usbtouch->irq->dev = udev; 1665 usbtouch->irq->transfer_dma = usbtouch->data_dma; 1666 usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1667 1668 /* device specific allocations */ 1669 if (type->alloc) { 1670 err = type->alloc(usbtouch); 1671 if (err) { 1672 dev_dbg(&intf->dev, 1673 "%s - type->alloc() failed, err: %d\n", 1674 __func__, err); 1675 goto out_free_urb; 1676 } 1677 } 1678 1679 /* device specific initialisation*/ 1680 if (type->init) { 1681 err = type->init(usbtouch); 1682 if (err) { 1683 dev_dbg(&intf->dev, 1684 "%s - type->init() failed, err: %d\n", 1685 __func__, err); 1686 goto out_do_exit; 1687 } 1688 } 1689 1690 err = input_register_device(usbtouch->input); 1691 if (err) { 1692 dev_dbg(&intf->dev, 1693 "%s - input_register_device failed, err: %d\n", 1694 __func__, err); 1695 goto out_do_exit; 1696 } 1697 1698 usb_set_intfdata(intf, usbtouch); 1699 1700 if (usbtouch->type->irq_always) { 1701 /* this can't fail */ 1702 usb_autopm_get_interface(intf); 1703 err = usb_submit_urb(usbtouch->irq, GFP_KERNEL); 1704 if (err) { 1705 usb_autopm_put_interface(intf); 1706 dev_err(&intf->dev, 1707 "%s - usb_submit_urb failed with result: %d\n", 1708 __func__, err); 1709 goto out_unregister_input; 1710 } 1711 } 1712 1713 return 0; 1714 1715out_unregister_input: 1716 input_unregister_device(input_dev); 1717 input_dev = NULL; 1718out_do_exit: 1719 if (type->exit) 1720 type->exit(usbtouch); 1721out_free_urb: 1722 usb_free_urb(usbtouch->irq); 1723out_free_buffers: 1724 usbtouch_free_buffers(udev, usbtouch); 1725out_free: 1726 input_free_device(input_dev); 1727 kfree(usbtouch); 1728 return err; 1729} 1730 1731static void usbtouch_disconnect(struct usb_interface *intf) 1732{ 1733 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf); 1734 1735 if (!usbtouch) 1736 return; 1737 1738 dev_dbg(&intf->dev, 1739 "%s - usbtouch is initialized, cleaning up\n", __func__); 1740 1741 usb_set_intfdata(intf, NULL); 1742 /* this will stop IO via close */ 1743 input_unregister_device(usbtouch->input); 1744 usb_free_urb(usbtouch->irq); 1745 if (usbtouch->type->exit) 1746 usbtouch->type->exit(usbtouch); 1747 usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch); 1748 kfree(usbtouch); 1749} 1750 1751MODULE_DEVICE_TABLE(usb, usbtouch_devices); 1752 1753static struct usb_driver usbtouch_driver = { 1754 .name = "usbtouchscreen", 1755 .probe = usbtouch_probe, 1756 .disconnect = usbtouch_disconnect, 1757 .suspend = usbtouch_suspend, 1758 .resume = usbtouch_resume, 1759 .reset_resume = usbtouch_reset_resume, 1760 .id_table = usbtouch_devices, 1761 .supports_autosuspend = 1, 1762}; 1763 1764module_usb_driver(usbtouch_driver); 1765 1766MODULE_AUTHOR(DRIVER_AUTHOR); 1767MODULE_DESCRIPTION(DRIVER_DESC); 1768MODULE_LICENSE("GPL"); 1769 1770MODULE_ALIAS("touchkitusb"); 1771MODULE_ALIAS("itmtouch"); 1772MODULE_ALIAS("mtouchusb"); 1773