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