drivers/input/touchscreen/usbtouchscreen.c

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