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