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