drivers/input/touchscreen/usbtouchscreen.c

   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  *
  19  * Copyright (C) 2004-2007 by Daniel Ritz <daniel.ritz@gmx.ch>
  20  * Copyright (C) by Todd E. Johnson (mtouchusb.c)
  21  *
  22  * This program is free software; you can redistribute it and/or
  23  * modify it under the terms of the GNU General Public License as
  24  * published by the Free Software Foundation; either version 2 of the
  25  * License, or (at your option) any later version.
  26  *
  27  * This program is distributed in the hope that it will be useful, but
  28  * WITHOUT ANY WARRANTY; without even the implied warranty of
  29  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  30  * General Public License for more details.
  31  *
  32  * You should have received a copy of the GNU General Public License
  33  * along with this program; if not, write to the Free Software
  34  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  35  *
  36  * Driver is based on touchkitusb.c
  37  * - ITM parts are from itmtouch.c
  38  * - 3M parts are from mtouchusb.c
  39  * - PanJit parts are from an unmerged driver by Lanslott Gish
  40  * - DMC TSC 10/25 are from Holger Schurig, with ideas from an unmerged
  41  *   driver from Marius Vollmer
  42  *
  43  *****************************************************************************/
  44
  45 //#define DEBUG
  46
  47 #include <linux/kernel.h>
  48 #include <linux/slab.h>
  49 #include <linux/input.h>
  50 #include <linux/module.h>
  51 #include <linux/init.h>
  52 #include <linux/usb.h>
  53 #include <linux/usb/input.h>
  54 #include <linux/hid.h>
  55
  56
  57 #define DRIVER_VERSION          "v0.6"
  58 #define DRIVER_AUTHOR           "Daniel Ritz <daniel.ritz@gmx.ch>"
  59 #define DRIVER_DESC             "USB Touchscreen Driver"
  60
  61 static int swap_xy;
  62 module_param(swap_xy, bool, 0644);
  63 MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped.");
  64
  65 static int hwcalib_xy;
  66 module_param(hwcalib_xy, bool, 0644);
  67 MODULE_PARM_DESC(hwcalib_xy, "If set hw-calibrated X/Y are used if available");
  68
  69 /* device specifc data/functions */
  70 struct usbtouch_usb;
  71 struct usbtouch_device_info {
  72         int min_xc, max_xc;
  73         int min_yc, max_yc;
  74         int min_press, max_press;
  75         int rept_size;
  76
  77         /*
  78          * Always service the USB devices irq not just when the input device is
  79          * open. This is useful when devices have a watchdog which prevents us
  80          * from periodically polling the device. Leave this unset unless your
  81          * touchscreen device requires it, as it does consume more of the USB
  82          * bandwidth.
  83          */
  84         bool irq_always;
  85
  86         void (*process_pkt) (struct usbtouch_usb *usbtouch, unsigned char *pkt, int len);
  87
  88         /*
  89          * used to get the packet len. possible return values:
  90          * > 0: packet len
  91          * = 0: skip one byte
  92          * < 0: -return value more bytes needed
  93          */
  94         int  (*get_pkt_len) (unsigned char *pkt, int len);
  95
  96         int  (*read_data)   (struct usbtouch_usb *usbtouch, unsigned char *pkt);
  97         int  (*init)        (struct usbtouch_usb *usbtouch);
  98 };
  99
 100 /* a usbtouch device */
 101 struct usbtouch_usb {
 102         unsigned char *data;
 103         dma_addr_t data_dma;
 104         unsigned char *buffer;
 105         int buf_len;
 106         struct urb *irq;
 107         struct usb_device *udev;
 108         struct input_dev *input;
 109         struct usbtouch_device_info *type;
 110         char name[128];
 111         char phys[64];
 112
 113         int x, y;
 114         int touch, press;
 115 };
 116
 117
 118 /* device types */
 119 enum {
 120         DEVTYPE_IGNORE = -1,
 121         DEVTYPE_EGALAX,
 122         DEVTYPE_PANJIT,
 123         DEVTYPE_3M,
 124         DEVTYPE_ITM,
 125         DEVTYPE_ETURBO,
 126         DEVTYPE_GUNZE,
 127         DEVTYPE_DMC_TSC10,
 128         DEVTYPE_IRTOUCH,
 129         DEVTYPE_IDEALTEK,
 130         DEVTYPE_GENERAL_TOUCH,
 131         DEVTYPE_GOTOP,
 132         DEVTYPE_JASTEC,
 133         DEVTYPE_E2I,
 134         DEVTYPE_ZYTRONIC,
 135 };
 136
 137 #define USB_DEVICE_HID_CLASS(vend, prod) \
 138         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS \
 139                 | USB_DEVICE_ID_MATCH_INT_PROTOCOL \
 140                 | USB_DEVICE_ID_MATCH_DEVICE, \
 141         .idVendor = (vend), \
 142         .idProduct = (prod), \
 143         .bInterfaceClass = USB_INTERFACE_CLASS_HID, \
 144         .bInterfaceProtocol = USB_INTERFACE_PROTOCOL_MOUSE
 145
 146 static struct usb_device_id usbtouch_devices[] = {
 147 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
 148         /* ignore the HID capable devices, handled by usbhid */
 149         {USB_DEVICE_HID_CLASS(0x0eef, 0x0001), .driver_info = DEVTYPE_IGNORE},
 150         {USB_DEVICE_HID_CLASS(0x0eef, 0x0002), .driver_info = DEVTYPE_IGNORE},
 151
 152         /* normal device IDs */
 153         {USB_DEVICE(0x3823, 0x0001), .driver_info = DEVTYPE_EGALAX},
 154         {USB_DEVICE(0x3823, 0x0002), .driver_info = DEVTYPE_EGALAX},
 155         {USB_DEVICE(0x0123, 0x0001), .driver_info = DEVTYPE_EGALAX},
 156         {USB_DEVICE(0x0eef, 0x0001), .driver_info = DEVTYPE_EGALAX},
 157         {USB_DEVICE(0x0eef, 0x0002), .driver_info = DEVTYPE_EGALAX},
 158         {USB_DEVICE(0x1234, 0x0001), .driver_info = DEVTYPE_EGALAX},
 159         {USB_DEVICE(0x1234, 0x0002), .driver_info = DEVTYPE_EGALAX},
 160 #endif
 161
 162 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
 163         {USB_DEVICE(0x134c, 0x0001), .driver_info = DEVTYPE_PANJIT},
 164         {USB_DEVICE(0x134c, 0x0002), .driver_info = DEVTYPE_PANJIT},
 165         {USB_DEVICE(0x134c, 0x0003), .driver_info = DEVTYPE_PANJIT},
 166         {USB_DEVICE(0x134c, 0x0004), .driver_info = DEVTYPE_PANJIT},
 167 #endif
 168
 169 #ifdef CONFIG_TOUCHSCREEN_USB_3M
 170         {USB_DEVICE(0x0596, 0x0001), .driver_info = DEVTYPE_3M},
 171 #endif
 172
 173 #ifdef CONFIG_TOUCHSCREEN_USB_ITM
 174         {USB_DEVICE(0x0403, 0xf9e9), .driver_info = DEVTYPE_ITM},
 175 #endif
 176
 177 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
 178         {USB_DEVICE(0x1234, 0x5678), .driver_info = DEVTYPE_ETURBO},
 179 #endif
 180
 181 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
 182         {USB_DEVICE(0x0637, 0x0001), .driver_info = DEVTYPE_GUNZE},
 183 #endif
 184
 185 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
 186         {USB_DEVICE(0x0afa, 0x03e8), .driver_info = DEVTYPE_DMC_TSC10},
 187 #endif
 188
 189 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
 190         {USB_DEVICE(0x595a, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
 191         {USB_DEVICE(0x6615, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
 192 #endif
 193
 194 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
 195         {USB_DEVICE(0x1391, 0x1000), .driver_info = DEVTYPE_IDEALTEK},
 196 #endif
 197
 198 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
 199         {USB_DEVICE(0x0dfc, 0x0001), .driver_info = DEVTYPE_GENERAL_TOUCH},
 200 #endif
 201
 202 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
 203         {USB_DEVICE(0x08f2, 0x007f), .driver_info = DEVTYPE_GOTOP},
 204         {USB_DEVICE(0x08f2, 0x00ce), .driver_info = DEVTYPE_GOTOP},
 205         {USB_DEVICE(0x08f2, 0x00f4), .driver_info = DEVTYPE_GOTOP},
 206 #endif
 207
 208 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC
 209         {USB_DEVICE(0x0f92, 0x0001), .driver_info = DEVTYPE_JASTEC},
 210 #endif
 211
 212 #ifdef CONFIG_TOUCHSCREEN_USB_E2I
 213         {USB_DEVICE(0x1ac7, 0x0001), .driver_info = DEVTYPE_E2I},
 214 #endif
 215
 216 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC
 217         {USB_DEVICE(0x14c8, 0x0003), .driver_info = DEVTYPE_ZYTRONIC},
 218 #endif
 219
 220         {}
 221 };
 222
 223
 224 /*****************************************************************************
 225  * e2i Part
 226  */
 227
 228 #ifdef CONFIG_TOUCHSCREEN_USB_E2I
 229 static int e2i_init(struct usbtouch_usb *usbtouch)
 230 {
 231         int ret;
 232
 233         ret = usb_control_msg(usbtouch->udev, usb_rcvctrlpipe(usbtouch->udev, 0),
 234                               0x01, 0x02, 0x0000, 0x0081,
 235                               NULL, 0, USB_CTRL_SET_TIMEOUT);
 236
 237         dbg("%s - usb_control_msg - E2I_RESET - bytes|err: %d",
 238             __func__, ret);
 239         return ret;
 240 }
 241
 242 static int e2i_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 243 {
 244         int tmp = (pkt[0] << 8) | pkt[1];
 245         dev->x  = (pkt[2] << 8) | pkt[3];
 246         dev->y  = (pkt[4] << 8) | pkt[5];
 247
 248         tmp = tmp - 0xA000;
 249         dev->touch = (tmp > 0);
 250         dev->press = (tmp > 0 ? tmp : 0);
 251
 252         return 1;
 253 }
 254 #endif
 255
 256
 257 /*****************************************************************************
 258  * eGalax part
 259  */
 260
 261 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
 262
 263 #ifndef MULTI_PACKET
 264 #define MULTI_PACKET
 265 #endif
 266
 267 #define EGALAX_PKT_TYPE_MASK            0xFE
 268 #define EGALAX_PKT_TYPE_REPT            0x80
 269 #define EGALAX_PKT_TYPE_DIAG            0x0A
 270
 271 static int egalax_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 272 {
 273         if ((pkt[0] & EGALAX_PKT_TYPE_MASK) != EGALAX_PKT_TYPE_REPT)
 274                 return 0;
 275
 276         dev->x = ((pkt[3] & 0x0F) << 7) | (pkt[4] & 0x7F);
 277         dev->y = ((pkt[1] & 0x0F) << 7) | (pkt[2] & 0x7F);
 278         dev->touch = pkt[0] & 0x01;
 279
 280         return 1;
 281 }
 282
 283 static int egalax_get_pkt_len(unsigned char *buf, int len)
 284 {
 285         switch (buf[0] & EGALAX_PKT_TYPE_MASK) {
 286         case EGALAX_PKT_TYPE_REPT:
 287                 return 5;
 288
 289         case EGALAX_PKT_TYPE_DIAG:
 290                 if (len < 2)
 291                         return -1;
 292
 293                 return buf[1] + 2;
 294         }
 295
 296         return 0;
 297 }
 298 #endif
 299
 300
 301 /*****************************************************************************
 302  * PanJit Part
 303  */
 304 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
 305 static int panjit_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 306 {
 307         dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1];
 308         dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3];
 309         dev->touch = pkt[0] & 0x01;
 310
 311         return 1;
 312 }
 313 #endif
 314
 315
 316 /*****************************************************************************
 317  * 3M/Microtouch Part
 318  */
 319 #ifdef CONFIG_TOUCHSCREEN_USB_3M
 320
 321 #define MTOUCHUSB_ASYNC_REPORT          1
 322 #define MTOUCHUSB_RESET                 7
 323 #define MTOUCHUSB_REQ_CTRLLR_ID         10
 324
 325 static int mtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 326 {
 327         if (hwcalib_xy) {
 328                 dev->x = (pkt[4] << 8) | pkt[3];
 329                 dev->y = 0xffff - ((pkt[6] << 8) | pkt[5]);
 330         } else {
 331                 dev->x = (pkt[8] << 8) | pkt[7];
 332                 dev->y = (pkt[10] << 8) | pkt[9];
 333         }
 334         dev->touch = (pkt[2] & 0x40) ? 1 : 0;
 335
 336         return 1;
 337 }
 338
 339 static int mtouch_init(struct usbtouch_usb *usbtouch)
 340 {
 341         int ret, i;
 342
 343         ret = usb_control_msg(usbtouch->udev, usb_rcvctrlpipe(usbtouch->udev, 0),
 344                               MTOUCHUSB_RESET,
 345                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 346                               1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
 347         dbg("%s - usb_control_msg - MTOUCHUSB_RESET - bytes|err: %d",
 348             __func__, ret);
 349         if (ret < 0)
 350                 return ret;
 351         msleep(150);
 352
 353         for (i = 0; i < 3; i++) {
 354                 ret = usb_control_msg(usbtouch->udev, usb_rcvctrlpipe(usbtouch->udev, 0),
 355                                       MTOUCHUSB_ASYNC_REPORT,
 356                                       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 357                                       1, 1, NULL, 0, USB_CTRL_SET_TIMEOUT);
 358                 dbg("%s - usb_control_msg - MTOUCHUSB_ASYNC_REPORT - bytes|err: %d",
 359                     __func__, ret);
 360                 if (ret >= 0)
 361                         break;
 362                 if (ret != -EPIPE)
 363                         return ret;
 364         }
 365
 366         /* Default min/max xy are the raw values, override if using hw-calib */
 367         if (hwcalib_xy) {
 368                 input_set_abs_params(usbtouch->input, ABS_X, 0, 0xffff, 0, 0);
 369                 input_set_abs_params(usbtouch->input, ABS_Y, 0, 0xffff, 0, 0);
 370         }
 371
 372         return 0;
 373 }
 374 #endif
 375
 376
 377 /*****************************************************************************
 378  * ITM Part
 379  */
 380 #ifdef CONFIG_TOUCHSCREEN_USB_ITM
 381 static int itm_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 382 {
 383         int touch;
 384         /*
 385          * ITM devices report invalid x/y data if not touched.
 386          * if the screen was touched before but is not touched any more
 387          * report touch as 0 with the last valid x/y data once. then stop
 388          * reporting data until touched again.
 389          */
 390         dev->press = ((pkt[2] & 0x01) << 7) | (pkt[5] & 0x7F);
 391
 392         touch = ~pkt[7] & 0x20;
 393         if (!touch) {
 394                 if (dev->touch) {
 395                         dev->touch = 0;
 396                         return 1;
 397                 }
 398
 399                 return 0;
 400         }
 401
 402         dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[3] & 0x7F);
 403         dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[4] & 0x7F);
 404         dev->touch = touch;
 405
 406         return 1;
 407 }
 408 #endif
 409
 410
 411 /*****************************************************************************
 412  * eTurboTouch part
 413  */
 414 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
 415 #ifndef MULTI_PACKET
 416 #define MULTI_PACKET
 417 #endif
 418 static int eturbo_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 419 {
 420         unsigned int shift;
 421
 422         /* packets should start with sync */
 423         if (!(pkt[0] & 0x80))
 424                 return 0;
 425
 426         shift = (6 - (pkt[0] & 0x03));
 427         dev->x = ((pkt[3] << 7) | pkt[4]) >> shift;
 428         dev->y = ((pkt[1] << 7) | pkt[2]) >> shift;
 429         dev->touch = (pkt[0] & 0x10) ? 1 : 0;
 430
 431         return 1;
 432 }
 433
 434 static int eturbo_get_pkt_len(unsigned char *buf, int len)
 435 {
 436         if (buf[0] & 0x80)
 437                 return 5;
 438         if (buf[0] == 0x01)
 439                 return 3;
 440         return 0;
 441 }
 442 #endif
 443
 444
 445 /*****************************************************************************
 446  * Gunze part
 447  */
 448 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
 449 static int gunze_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 450 {
 451         if (!(pkt[0] & 0x80) || ((pkt[1] | pkt[2] | pkt[3]) & 0x80))
 452                 return 0;
 453
 454         dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[2] & 0x7F);
 455         dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[3] & 0x7F);
 456         dev->touch = pkt[0] & 0x20;
 457
 458         return 1;
 459 }
 460 #endif
 461
 462 /*****************************************************************************
 463  * DMC TSC-10/25 Part
 464  *
 465  * Documentation about the controller and it's protocol can be found at
 466  *   http://www.dmccoltd.com/files/controler/tsc10usb_pi_e.pdf
 467  *   http://www.dmccoltd.com/files/controler/tsc25_usb_e.pdf
 468  */
 469 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
 470
 471 /* supported data rates. currently using 130 */
 472 #define TSC10_RATE_POINT        0x50
 473 #define TSC10_RATE_30           0x40
 474 #define TSC10_RATE_50           0x41
 475 #define TSC10_RATE_80           0x42
 476 #define TSC10_RATE_100          0x43
 477 #define TSC10_RATE_130          0x44
 478 #define TSC10_RATE_150          0x45
 479
 480 /* commands */
 481 #define TSC10_CMD_RESET         0x55
 482 #define TSC10_CMD_RATE          0x05
 483 #define TSC10_CMD_DATA1         0x01
 484
 485 static int dmc_tsc10_init(struct usbtouch_usb *usbtouch)
 486 {
 487         struct usb_device *dev = usbtouch->udev;
 488         int ret = -ENOMEM;
 489         unsigned char *buf;
 490
 491         buf = kmalloc(2, GFP_KERNEL);
 492         if (!buf)
 493                 goto err_nobuf;
 494         /* reset */
 495         buf[0] = buf[1] = 0xFF;
 496         ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
 497                               TSC10_CMD_RESET,
 498                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 499                               0, 0, buf, 2, USB_CTRL_SET_TIMEOUT);
 500         if (ret < 0)
 501                 goto err_out;
 502         if (buf[0] != 0x06) {
 503                 ret = -ENODEV;
 504                 goto err_out;
 505         }
 506
 507         /* set coordinate output rate */
 508         buf[0] = buf[1] = 0xFF;
 509         ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
 510                               TSC10_CMD_RATE,
 511                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 512                               TSC10_RATE_150, 0, buf, 2, USB_CTRL_SET_TIMEOUT);
 513         if (ret < 0)
 514                 goto err_out;
 515         if ((buf[0] != 0x06) && (buf[0] != 0x15 || buf[1] != 0x01)) {
 516                 ret = -ENODEV;
 517                 goto err_out;
 518         }
 519
 520         /* start sending data */
 521         ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
 522                               TSC10_CMD_DATA1,
 523                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 524                               0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
 525 err_out:
 526         kfree(buf);
 527 err_nobuf:
 528         return ret;
 529 }
 530
 531
 532 static int dmc_tsc10_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 533 {
 534         dev->x = ((pkt[2] & 0x03) << 8) | pkt[1];
 535         dev->y = ((pkt[4] & 0x03) << 8) | pkt[3];
 536         dev->touch = pkt[0] & 0x01;
 537
 538         return 1;
 539 }
 540 #endif
 541
 542
 543 /*****************************************************************************
 544  * IRTOUCH Part
 545  */
 546 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
 547 static int irtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 548 {
 549         dev->x = (pkt[3] << 8) | pkt[2];
 550         dev->y = (pkt[5] << 8) | pkt[4];
 551         dev->touch = (pkt[1] & 0x03) ? 1 : 0;
 552
 553         return 1;
 554 }
 555 #endif
 556
 557
 558 /*****************************************************************************
 559  * IdealTEK URTC1000 Part
 560  */
 561 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
 562 #ifndef MULTI_PACKET
 563 #define MULTI_PACKET
 564 #endif
 565 static int idealtek_get_pkt_len(unsigned char *buf, int len)
 566 {
 567         if (buf[0] & 0x80)
 568                 return 5;
 569         if (buf[0] == 0x01)
 570                 return len;
 571         return 0;
 572 }
 573
 574 static int idealtek_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 575 {
 576         switch (pkt[0] & 0x98) {
 577         case 0x88:
 578                 /* touch data in IdealTEK mode */
 579                 dev->x = (pkt[1] << 5) | (pkt[2] >> 2);
 580                 dev->y = (pkt[3] << 5) | (pkt[4] >> 2);
 581                 dev->touch = (pkt[0] & 0x40) ? 1 : 0;
 582                 return 1;
 583
 584         case 0x98:
 585                 /* touch data in MT emulation mode */
 586                 dev->x = (pkt[2] << 5) | (pkt[1] >> 2);
 587                 dev->y = (pkt[4] << 5) | (pkt[3] >> 2);
 588                 dev->touch = (pkt[0] & 0x40) ? 1 : 0;
 589                 return 1;
 590
 591         default:
 592                 return 0;
 593         }
 594 }
 595 #endif
 596
 597 /*****************************************************************************
 598  * General Touch Part
 599  */
 600 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
 601 static int general_touch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 602 {
 603         dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1] ;
 604         dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3] ;
 605         dev->press = pkt[5] & 0xff;
 606         dev->touch = pkt[0] & 0x01;
 607
 608         return 1;
 609 }
 610 #endif
 611
 612 /*****************************************************************************
 613  * GoTop Part
 614  */
 615 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
 616 static int gotop_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 617 {
 618         dev->x = ((pkt[1] & 0x38) << 4) | pkt[2];
 619         dev->y = ((pkt[1] & 0x07) << 7) | pkt[3];
 620         dev->touch = pkt[0] & 0x01;
 621
 622         return 1;
 623 }
 624 #endif
 625
 626 /*****************************************************************************
 627  * JASTEC Part
 628  */
 629 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC
 630 static int jastec_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 631 {
 632         dev->x = ((pkt[0] & 0x3f) << 6) | (pkt[2] & 0x3f);
 633         dev->y = ((pkt[1] & 0x3f) << 6) | (pkt[3] & 0x3f);
 634         dev->touch = (pkt[0] & 0x40) >> 6;
 635
 636         return 1;
 637 }
 638 #endif
 639
 640 /*****************************************************************************
 641  * Zytronic Part
 642  */
 643 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC
 644 static int zytronic_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 645 {
 646         switch (pkt[0]) {
 647         case 0x3A: /* command response */
 648                 dbg("%s: Command response %d", __func__, pkt[1]);
 649                 break;
 650
 651         case 0xC0: /* down */
 652                 dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7);
 653                 dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7);
 654                 dev->touch = 1;
 655                 dbg("%s: down %d,%d", __func__, dev->x, dev->y);
 656                 return 1;
 657
 658         case 0x80: /* up */
 659                 dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7);
 660                 dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7);
 661                 dev->touch = 0;
 662                 dbg("%s: up %d,%d", __func__, dev->x, dev->y);
 663                 return 1;
 664
 665         default:
 666                 dbg("%s: Unknown return %d", __func__, pkt[0]);
 667                 break;
 668         }
 669
 670         return 0;
 671 }
 672 #endif
 673
 674 /*****************************************************************************
 675  * the different device descriptors
 676  */
 677 #ifdef MULTI_PACKET
 678 static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
 679                                    unsigned char *pkt, int len);
 680 #endif
 681
 682 static struct usbtouch_device_info usbtouch_dev_info[] = {
 683 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
 684         [DEVTYPE_EGALAX] = {
 685                 .min_xc         = 0x0,
 686                 .max_xc         = 0x07ff,
 687                 .min_yc         = 0x0,
 688                 .max_yc         = 0x07ff,
 689                 .rept_size      = 16,
 690                 .process_pkt    = usbtouch_process_multi,
 691                 .get_pkt_len    = egalax_get_pkt_len,
 692                 .read_data      = egalax_read_data,
 693         },
 694 #endif
 695
 696 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
 697         [DEVTYPE_PANJIT] = {
 698                 .min_xc         = 0x0,
 699                 .max_xc         = 0x0fff,
 700                 .min_yc         = 0x0,
 701                 .max_yc         = 0x0fff,
 702                 .rept_size      = 8,
 703                 .read_data      = panjit_read_data,
 704         },
 705 #endif
 706
 707 #ifdef CONFIG_TOUCHSCREEN_USB_3M
 708         [DEVTYPE_3M] = {
 709                 .min_xc         = 0x0,
 710                 .max_xc         = 0x4000,
 711                 .min_yc         = 0x0,
 712                 .max_yc         = 0x4000,
 713                 .rept_size      = 11,
 714                 .read_data      = mtouch_read_data,
 715                 .init           = mtouch_init,
 716         },
 717 #endif
 718
 719 #ifdef CONFIG_TOUCHSCREEN_USB_ITM
 720         [DEVTYPE_ITM] = {
 721                 .min_xc         = 0x0,
 722                 .max_xc         = 0x0fff,
 723                 .min_yc         = 0x0,
 724                 .max_yc         = 0x0fff,
 725                 .max_press      = 0xff,
 726                 .rept_size      = 8,
 727                 .read_data      = itm_read_data,
 728         },
 729 #endif
 730
 731 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
 732         [DEVTYPE_ETURBO] = {
 733                 .min_xc         = 0x0,
 734                 .max_xc         = 0x07ff,
 735                 .min_yc         = 0x0,
 736                 .max_yc         = 0x07ff,
 737                 .rept_size      = 8,
 738                 .process_pkt    = usbtouch_process_multi,
 739                 .get_pkt_len    = eturbo_get_pkt_len,
 740                 .read_data      = eturbo_read_data,
 741         },
 742 #endif
 743
 744 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
 745         [DEVTYPE_GUNZE] = {
 746                 .min_xc         = 0x0,
 747                 .max_xc         = 0x0fff,
 748                 .min_yc         = 0x0,
 749                 .max_yc         = 0x0fff,
 750                 .rept_size      = 4,
 751                 .read_data      = gunze_read_data,
 752         },
 753 #endif
 754
 755 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
 756         [DEVTYPE_DMC_TSC10] = {
 757                 .min_xc         = 0x0,
 758                 .max_xc         = 0x03ff,
 759                 .min_yc         = 0x0,
 760                 .max_yc         = 0x03ff,
 761                 .rept_size      = 5,
 762                 .init           = dmc_tsc10_init,
 763                 .read_data      = dmc_tsc10_read_data,
 764         },
 765 #endif
 766
 767 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
 768         [DEVTYPE_IRTOUCH] = {
 769                 .min_xc         = 0x0,
 770                 .max_xc         = 0x0fff,
 771                 .min_yc         = 0x0,
 772                 .max_yc         = 0x0fff,
 773                 .rept_size      = 8,
 774                 .read_data      = irtouch_read_data,
 775         },
 776 #endif
 777
 778 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
 779         [DEVTYPE_IDEALTEK] = {
 780                 .min_xc         = 0x0,
 781                 .max_xc         = 0x0fff,
 782                 .min_yc         = 0x0,
 783                 .max_yc         = 0x0fff,
 784                 .rept_size      = 8,
 785                 .process_pkt    = usbtouch_process_multi,
 786                 .get_pkt_len    = idealtek_get_pkt_len,
 787                 .read_data      = idealtek_read_data,
 788         },
 789 #endif
 790
 791 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
 792         [DEVTYPE_GENERAL_TOUCH] = {
 793                 .min_xc         = 0x0,
 794                 .max_xc         = 0x0500,
 795                 .min_yc         = 0x0,
 796                 .max_yc         = 0x0500,
 797                 .rept_size      = 7,
 798                 .read_data      = general_touch_read_data,
 799         },
 800 #endif
 801
 802 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
 803         [DEVTYPE_GOTOP] = {
 804                 .min_xc         = 0x0,
 805                 .max_xc         = 0x03ff,
 806                 .min_yc         = 0x0,
 807                 .max_yc         = 0x03ff,
 808                 .rept_size      = 4,
 809                 .read_data      = gotop_read_data,
 810         },
 811 #endif
 812
 813 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC
 814         [DEVTYPE_JASTEC] = {
 815                 .min_xc         = 0x0,
 816                 .max_xc         = 0x0fff,
 817                 .min_yc         = 0x0,
 818                 .max_yc         = 0x0fff,
 819                 .rept_size      = 4,
 820                 .read_data      = jastec_read_data,
 821         },
 822 #endif
 823
 824 #ifdef CONFIG_TOUCHSCREEN_USB_E2I
 825         [DEVTYPE_E2I] = {
 826                 .min_xc         = 0x0,
 827                 .max_xc         = 0x7fff,
 828                 .min_yc         = 0x0,
 829                 .max_yc         = 0x7fff,
 830                 .rept_size      = 6,
 831                 .init           = e2i_init,
 832                 .read_data      = e2i_read_data,
 833         },
 834 #endif
 835
 836 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC
 837         [DEVTYPE_ZYTRONIC] = {
 838                 .min_xc         = 0x0,
 839                 .max_xc         = 0x03ff,
 840                 .min_yc         = 0x0,
 841                 .max_yc         = 0x03ff,
 842                 .rept_size      = 5,
 843                 .read_data      = zytronic_read_data,
 844                 .irq_always     = true,
 845         },
 846 #endif
 847 };
 848
 849
 850 /*****************************************************************************
 851  * Generic Part
 852  */
 853 static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch,
 854                                  unsigned char *pkt, int len)
 855 {
 856         struct usbtouch_device_info *type = usbtouch->type;
 857
 858         if (!type->read_data(usbtouch, pkt))
 859                         return;
 860
 861         input_report_key(usbtouch->input, BTN_TOUCH, usbtouch->touch);
 862
 863         if (swap_xy) {
 864                 input_report_abs(usbtouch->input, ABS_X, usbtouch->y);
 865                 input_report_abs(usbtouch->input, ABS_Y, usbtouch->x);
 866         } else {
 867                 input_report_abs(usbtouch->input, ABS_X, usbtouch->x);
 868                 input_report_abs(usbtouch->input, ABS_Y, usbtouch->y);
 869         }
 870         if (type->max_press)
 871                 input_report_abs(usbtouch->input, ABS_PRESSURE, usbtouch->press);
 872         input_sync(usbtouch->input);
 873 }
 874
 875
 876 #ifdef MULTI_PACKET
 877 static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
 878                                    unsigned char *pkt, int len)
 879 {
 880         unsigned char *buffer;
 881         int pkt_len, pos, buf_len, tmp;
 882
 883         /* process buffer */
 884         if (unlikely(usbtouch->buf_len)) {
 885                 /* try to get size */
 886                 pkt_len = usbtouch->type->get_pkt_len(
 887                                 usbtouch->buffer, usbtouch->buf_len);
 888
 889                 /* drop? */
 890                 if (unlikely(!pkt_len))
 891                         goto out_flush_buf;
 892
 893                 /* need to append -pkt_len bytes before able to get size */
 894                 if (unlikely(pkt_len < 0)) {
 895                         int append = -pkt_len;
 896                         if (unlikely(append > len))
 897                                append = len;
 898                         if (usbtouch->buf_len + append >= usbtouch->type->rept_size)
 899                                 goto out_flush_buf;
 900                         memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, append);
 901                         usbtouch->buf_len += append;
 902
 903                         pkt_len = usbtouch->type->get_pkt_len(
 904                                         usbtouch->buffer, usbtouch->buf_len);
 905                         if (pkt_len < 0)
 906                                 return;
 907                 }
 908
 909                 /* append */
 910                 tmp = pkt_len - usbtouch->buf_len;
 911                 if (usbtouch->buf_len + tmp >= usbtouch->type->rept_size)
 912                         goto out_flush_buf;
 913                 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, tmp);
 914                 usbtouch_process_pkt(usbtouch, usbtouch->buffer, pkt_len);
 915
 916                 buffer = pkt + tmp;
 917                 buf_len = len - tmp;
 918         } else {
 919                 buffer = pkt;
 920                 buf_len = len;
 921         }
 922
 923         /* loop over the received packet, process */
 924         pos = 0;
 925         while (pos < buf_len) {
 926                 /* get packet len */
 927                 pkt_len = usbtouch->type->get_pkt_len(buffer + pos,
 928                                                         buf_len - pos);
 929
 930                 /* unknown packet: skip one byte */
 931                 if (unlikely(!pkt_len)) {
 932                         pos++;
 933                         continue;
 934                 }
 935
 936                 /* full packet: process */
 937                 if (likely((pkt_len > 0) && (pkt_len <= buf_len - pos))) {
 938                         usbtouch_process_pkt(usbtouch, buffer + pos, pkt_len);
 939                 } else {
 940                         /* incomplete packet: save in buffer */
 941                         memcpy(usbtouch->buffer, buffer + pos, buf_len - pos);
 942                         usbtouch->buf_len = buf_len - pos;
 943                         return;
 944                 }
 945                 pos += pkt_len;
 946         }
 947
 948 out_flush_buf:
 949         usbtouch->buf_len = 0;
 950         return;
 951 }
 952 #endif
 953
 954
 955 static void usbtouch_irq(struct urb *urb)
 956 {
 957         struct usbtouch_usb *usbtouch = urb->context;
 958         int retval;
 959
 960         switch (urb->status) {
 961         case 0:
 962                 /* success */
 963                 break;
 964         case -ETIME:
 965                 /* this urb is timing out */
 966                 dbg("%s - urb timed out - was the device unplugged?",
 967                     __func__);
 968                 return;
 969         case -ECONNRESET:
 970         case -ENOENT:
 971         case -ESHUTDOWN:
 972                 /* this urb is terminated, clean up */
 973                 dbg("%s - urb shutting down with status: %d",
 974                     __func__, urb->status);
 975                 return;
 976         default:
 977                 dbg("%s - nonzero urb status received: %d",
 978                     __func__, urb->status);
 979                 goto exit;
 980         }
 981
 982         usbtouch->type->process_pkt(usbtouch, usbtouch->data, urb->actual_length);
 983
 984 exit:
 985         retval = usb_submit_urb(urb, GFP_ATOMIC);
 986         if (retval)
 987                 err("%s - usb_submit_urb failed with result: %d",
 988                     __func__, retval);
 989 }
 990
 991 static int usbtouch_open(struct input_dev *input)
 992 {
 993         struct usbtouch_usb *usbtouch = input_get_drvdata(input);
 994
 995         usbtouch->irq->dev = usbtouch->udev;
 996
 997         if (!usbtouch->type->irq_always) {
 998                 if (usb_submit_urb(usbtouch->irq, GFP_KERNEL))
 999                   return -EIO;
1000         }
1001
1002         return 0;
1003 }
1004
1005 static void usbtouch_close(struct input_dev *input)
1006 {
1007         struct usbtouch_usb *usbtouch = input_get_drvdata(input);
1008
1009         if (!usbtouch->type->irq_always)
1010                 usb_kill_urb(usbtouch->irq);
1011 }
1012
1013
1014 static void usbtouch_free_buffers(struct usb_device *udev,
1015                                   struct usbtouch_usb *usbtouch)
1016 {
1017         usb_buffer_free(udev, usbtouch->type->rept_size,
1018                         usbtouch->data, usbtouch->data_dma);
1019         kfree(usbtouch->buffer);
1020 }
1021
1022
1023 static int usbtouch_probe(struct usb_interface *intf,
1024                           const struct usb_device_id *id)
1025 {
1026         struct usbtouch_usb *usbtouch;
1027         struct input_dev *input_dev;
1028         struct usb_host_interface *interface;
1029         struct usb_endpoint_descriptor *endpoint;
1030         struct usb_device *udev = interface_to_usbdev(intf);
1031         struct usbtouch_device_info *type;
1032         int err = -ENOMEM;
1033
1034         /* some devices are ignored */
1035         if (id->driver_info == DEVTYPE_IGNORE)
1036                 return -ENODEV;
1037
1038         interface = intf->cur_altsetting;
1039         endpoint = &interface->endpoint[0].desc;
1040
1041         usbtouch = kzalloc(sizeof(struct usbtouch_usb), GFP_KERNEL);
1042         input_dev = input_allocate_device();
1043         if (!usbtouch || !input_dev)
1044                 goto out_free;
1045
1046         type = &usbtouch_dev_info[id->driver_info];
1047         usbtouch->type = type;
1048         if (!type->process_pkt)
1049                 type->process_pkt = usbtouch_process_pkt;
1050
1051         usbtouch->data = usb_buffer_alloc(udev, type->rept_size,
1052                                           GFP_KERNEL, &usbtouch->data_dma);
1053         if (!usbtouch->data)
1054                 goto out_free;
1055
1056         if (type->get_pkt_len) {
1057                 usbtouch->buffer = kmalloc(type->rept_size, GFP_KERNEL);
1058                 if (!usbtouch->buffer)
1059                         goto out_free_buffers;
1060         }
1061
1062         usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL);
1063         if (!usbtouch->irq) {
1064                 dbg("%s - usb_alloc_urb failed: usbtouch->irq", __func__);
1065                 goto out_free_buffers;
1066         }
1067
1068         usbtouch->udev = udev;
1069         usbtouch->input = input_dev;
1070
1071         if (udev->manufacturer)
1072                 strlcpy(usbtouch->name, udev->manufacturer, sizeof(usbtouch->name));
1073
1074         if (udev->product) {
1075                 if (udev->manufacturer)
1076                         strlcat(usbtouch->name, " ", sizeof(usbtouch->name));
1077                 strlcat(usbtouch->name, udev->product, sizeof(usbtouch->name));
1078         }
1079
1080         if (!strlen(usbtouch->name))
1081                 snprintf(usbtouch->name, sizeof(usbtouch->name),
1082                         "USB Touchscreen %04x:%04x",
1083                          le16_to_cpu(udev->descriptor.idVendor),
1084                          le16_to_cpu(udev->descriptor.idProduct));
1085
1086         usb_make_path(udev, usbtouch->phys, sizeof(usbtouch->phys));
1087         strlcat(usbtouch->phys, "/input0", sizeof(usbtouch->phys));
1088
1089         input_dev->name = usbtouch->name;
1090         input_dev->phys = usbtouch->phys;
1091         usb_to_input_id(udev, &input_dev->id);
1092         input_dev->dev.parent = &intf->dev;
1093
1094         input_set_drvdata(input_dev, usbtouch);
1095
1096         input_dev->open = usbtouch_open;
1097         input_dev->close = usbtouch_close;
1098
1099         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
1100         input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
1101         input_set_abs_params(input_dev, ABS_X, type->min_xc, type->max_xc, 0, 0);
1102         input_set_abs_params(input_dev, ABS_Y, type->min_yc, type->max_yc, 0, 0);
1103         if (type->max_press)
1104                 input_set_abs_params(input_dev, ABS_PRESSURE, type->min_press,
1105                                      type->max_press, 0, 0);
1106
1107         usb_fill_int_urb(usbtouch->irq, usbtouch->udev,
1108                          usb_rcvintpipe(usbtouch->udev, endpoint->bEndpointAddress),
1109                          usbtouch->data, type->rept_size,
1110                          usbtouch_irq, usbtouch, endpoint->bInterval);
1111
1112         usbtouch->irq->dev = usbtouch->udev;
1113         usbtouch->irq->transfer_dma = usbtouch->data_dma;
1114         usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1115
1116         /* device specific init */
1117         if (type->init) {
1118                 err = type->init(usbtouch);
1119                 if (err) {
1120                         dbg("%s - type->init() failed, err: %d", __func__, err);
1121                         goto out_free_buffers;
1122                 }
1123         }
1124
1125         err = input_register_device(usbtouch->input);
1126         if (err) {
1127                 dbg("%s - input_register_device failed, err: %d", __func__, err);
1128                 goto out_free_buffers;
1129         }
1130
1131         usb_set_intfdata(intf, usbtouch);
1132
1133         if (usbtouch->type->irq_always)
1134                 usb_submit_urb(usbtouch->irq, GFP_KERNEL);
1135
1136         return 0;
1137
1138 out_free_buffers:
1139         usbtouch_free_buffers(udev, usbtouch);
1140 out_free:
1141         input_free_device(input_dev);
1142         kfree(usbtouch);
1143         return err;
1144 }
1145
1146 static void usbtouch_disconnect(struct usb_interface *intf)
1147 {
1148         struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
1149
1150         dbg("%s - called", __func__);
1151
1152         if (!usbtouch)
1153                 return;
1154
1155         dbg("%s - usbtouch is initialized, cleaning up", __func__);
1156         usb_set_intfdata(intf, NULL);
1157         /* this will stop IO via close */
1158         input_unregister_device(usbtouch->input);
1159         usb_free_urb(usbtouch->irq);
1160         usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch);
1161         kfree(usbtouch);
1162 }
1163
1164 MODULE_DEVICE_TABLE(usb, usbtouch_devices);
1165
1166 static struct usb_driver usbtouch_driver = {
1167         .name           = "usbtouchscreen",
1168         .probe          = usbtouch_probe,
1169         .disconnect     = usbtouch_disconnect,
1170         .id_table       = usbtouch_devices,
1171 };
1172
1173 static int __init usbtouch_init(void)
1174 {
1175         return usb_register(&usbtouch_driver);
1176 }
1177
1178 static void __exit usbtouch_cleanup(void)
1179 {
1180         usb_deregister(&usbtouch_driver);
1181 }
1182
1183 module_init(usbtouch_init);
1184 module_exit(usbtouch_cleanup);
1185
1186 MODULE_AUTHOR(DRIVER_AUTHOR);
1187 MODULE_DESCRIPTION(DRIVER_DESC);
1188 MODULE_LICENSE("GPL");
1189
1190 MODULE_ALIAS("touchkitusb");
1191 MODULE_ALIAS("itmtouch");
1192 MODULE_ALIAS("mtouchusb");