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