Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /******************************************************************************
0003  * usbtouchscreen.c
0004  * Driver for USB Touchscreens, supporting those devices:
0005  *  - eGalax Touchkit
0006  *    includes eTurboTouch CT-410/510/700
0007  *  - 3M/Microtouch  EX II series
0008  *  - ITM
0009  *  - PanJit TouchSet
0010  *  - eTurboTouch
0011  *  - Gunze AHL61
0012  *  - DMC TSC-10/25
0013  *  - IRTOUCHSYSTEMS/UNITOP
0014  *  - IdealTEK URTC1000
0015  *  - General Touch
0016  *  - GoTop Super_Q2/GogoPen/PenPower tablets
0017  *  - JASTEC USB touch controller/DigiTech DTR-02U
0018  *  - Zytronic capacitive touchscreen
0019  *  - NEXIO/iNexio
0020  *  - Elo TouchSystems 2700 IntelliTouch
0021  *  - EasyTouch USB Dual/Multi touch controller from Data Modul
0022  *
0023  * Copyright (C) 2004-2007 by Daniel Ritz <daniel.ritz@gmx.ch>
0024  * Copyright (C) by Todd E. Johnson (mtouchusb.c)
0025  *
0026  * Driver is based on touchkitusb.c
0027  * - ITM parts are from itmtouch.c
0028  * - 3M parts are from mtouchusb.c
0029  * - PanJit parts are from an unmerged driver by Lanslott Gish
0030  * - DMC TSC 10/25 are from Holger Schurig, with ideas from an unmerged
0031  *   driver from Marius Vollmer
0032  *
0033  *****************************************************************************/
0034 
0035 //#define DEBUG
0036 
0037 #include <linux/kernel.h>
0038 #include <linux/slab.h>
0039 #include <linux/input.h>
0040 #include <linux/module.h>
0041 #include <linux/usb.h>
0042 #include <linux/usb/input.h>
0043 #include <linux/hid.h>
0044 #include <linux/mutex.h>
0045 
0046 static bool swap_xy;
0047 module_param(swap_xy, bool, 0644);
0048 MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped.");
0049 
0050 static bool hwcalib_xy;
0051 module_param(hwcalib_xy, bool, 0644);
0052 MODULE_PARM_DESC(hwcalib_xy, "If set hw-calibrated X/Y are used if available");
0053 
0054 /* device specifc data/functions */
0055 struct usbtouch_usb;
0056 struct usbtouch_device_info {
0057     int min_xc, max_xc;
0058     int min_yc, max_yc;
0059     int min_press, max_press;
0060     int rept_size;
0061 
0062     /*
0063      * Always service the USB devices irq not just when the input device is
0064      * open. This is useful when devices have a watchdog which prevents us
0065      * from periodically polling the device. Leave this unset unless your
0066      * touchscreen device requires it, as it does consume more of the USB
0067      * bandwidth.
0068      */
0069     bool irq_always;
0070 
0071     void (*process_pkt) (struct usbtouch_usb *usbtouch, unsigned char *pkt, int len);
0072 
0073     /*
0074      * used to get the packet len. possible return values:
0075      * > 0: packet len
0076      * = 0: skip one byte
0077      * < 0: -return value more bytes needed
0078      */
0079     int  (*get_pkt_len) (unsigned char *pkt, int len);
0080 
0081     int  (*read_data)   (struct usbtouch_usb *usbtouch, unsigned char *pkt);
0082     int  (*alloc)       (struct usbtouch_usb *usbtouch);
0083     int  (*init)        (struct usbtouch_usb *usbtouch);
0084     void (*exit)        (struct usbtouch_usb *usbtouch);
0085 };
0086 
0087 /* a usbtouch device */
0088 struct usbtouch_usb {
0089     unsigned char *data;
0090     dma_addr_t data_dma;
0091     int data_size;
0092     unsigned char *buffer;
0093     int buf_len;
0094     struct urb *irq;
0095     struct usb_interface *interface;
0096     struct input_dev *input;
0097     struct usbtouch_device_info *type;
0098     struct mutex pm_mutex;  /* serialize access to open/suspend */
0099     bool is_open;
0100     char name[128];
0101     char phys[64];
0102     void *priv;
0103 
0104     int x, y;
0105     int touch, press;
0106 };
0107 
0108 
0109 /* device types */
0110 enum {
0111     DEVTYPE_IGNORE = -1,
0112     DEVTYPE_EGALAX,
0113     DEVTYPE_PANJIT,
0114     DEVTYPE_3M,
0115     DEVTYPE_ITM,
0116     DEVTYPE_ETURBO,
0117     DEVTYPE_GUNZE,
0118     DEVTYPE_DMC_TSC10,
0119     DEVTYPE_IRTOUCH,
0120     DEVTYPE_IRTOUCH_HIRES,
0121     DEVTYPE_IDEALTEK,
0122     DEVTYPE_GENERAL_TOUCH,
0123     DEVTYPE_GOTOP,
0124     DEVTYPE_JASTEC,
0125     DEVTYPE_E2I,
0126     DEVTYPE_ZYTRONIC,
0127     DEVTYPE_TC45USB,
0128     DEVTYPE_NEXIO,
0129     DEVTYPE_ELO,
0130     DEVTYPE_ETOUCH,
0131 };
0132 
0133 #define USB_DEVICE_HID_CLASS(vend, prod) \
0134     .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS \
0135         | USB_DEVICE_ID_MATCH_DEVICE, \
0136     .idVendor = (vend), \
0137     .idProduct = (prod), \
0138     .bInterfaceClass = USB_INTERFACE_CLASS_HID
0139 
0140 static const struct usb_device_id usbtouch_devices[] = {
0141 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
0142     /* ignore the HID capable devices, handled by usbhid */
0143     {USB_DEVICE_HID_CLASS(0x0eef, 0x0001), .driver_info = DEVTYPE_IGNORE},
0144     {USB_DEVICE_HID_CLASS(0x0eef, 0x0002), .driver_info = DEVTYPE_IGNORE},
0145 
0146     /* normal device IDs */
0147     {USB_DEVICE(0x3823, 0x0001), .driver_info = DEVTYPE_EGALAX},
0148     {USB_DEVICE(0x3823, 0x0002), .driver_info = DEVTYPE_EGALAX},
0149     {USB_DEVICE(0x0123, 0x0001), .driver_info = DEVTYPE_EGALAX},
0150     {USB_DEVICE(0x0eef, 0x0001), .driver_info = DEVTYPE_EGALAX},
0151     {USB_DEVICE(0x0eef, 0x0002), .driver_info = DEVTYPE_EGALAX},
0152     {USB_DEVICE(0x1234, 0x0001), .driver_info = DEVTYPE_EGALAX},
0153     {USB_DEVICE(0x1234, 0x0002), .driver_info = DEVTYPE_EGALAX},
0154 #endif
0155 
0156 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
0157     {USB_DEVICE(0x134c, 0x0001), .driver_info = DEVTYPE_PANJIT},
0158     {USB_DEVICE(0x134c, 0x0002), .driver_info = DEVTYPE_PANJIT},
0159     {USB_DEVICE(0x134c, 0x0003), .driver_info = DEVTYPE_PANJIT},
0160     {USB_DEVICE(0x134c, 0x0004), .driver_info = DEVTYPE_PANJIT},
0161 #endif
0162 
0163 #ifdef CONFIG_TOUCHSCREEN_USB_3M
0164     {USB_DEVICE(0x0596, 0x0001), .driver_info = DEVTYPE_3M},
0165 #endif
0166 
0167 #ifdef CONFIG_TOUCHSCREEN_USB_ITM
0168     {USB_DEVICE(0x0403, 0xf9e9), .driver_info = DEVTYPE_ITM},
0169     {USB_DEVICE(0x16e3, 0xf9e9), .driver_info = DEVTYPE_ITM},
0170 #endif
0171 
0172 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
0173     {USB_DEVICE(0x1234, 0x5678), .driver_info = DEVTYPE_ETURBO},
0174 #endif
0175 
0176 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
0177     {USB_DEVICE(0x0637, 0x0001), .driver_info = DEVTYPE_GUNZE},
0178 #endif
0179 
0180 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
0181     {USB_DEVICE(0x0afa, 0x03e8), .driver_info = DEVTYPE_DMC_TSC10},
0182 #endif
0183 
0184 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
0185     {USB_DEVICE(0x255e, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
0186     {USB_DEVICE(0x595a, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
0187     {USB_DEVICE(0x6615, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
0188     {USB_DEVICE(0x6615, 0x0012), .driver_info = DEVTYPE_IRTOUCH_HIRES},
0189 #endif
0190 
0191 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
0192     {USB_DEVICE(0x1391, 0x1000), .driver_info = DEVTYPE_IDEALTEK},
0193 #endif
0194 
0195 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
0196     {USB_DEVICE(0x0dfc, 0x0001), .driver_info = DEVTYPE_GENERAL_TOUCH},
0197 #endif
0198 
0199 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
0200     {USB_DEVICE(0x08f2, 0x007f), .driver_info = DEVTYPE_GOTOP},
0201     {USB_DEVICE(0x08f2, 0x00ce), .driver_info = DEVTYPE_GOTOP},
0202     {USB_DEVICE(0x08f2, 0x00f4), .driver_info = DEVTYPE_GOTOP},
0203 #endif
0204 
0205 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC
0206     {USB_DEVICE(0x0f92, 0x0001), .driver_info = DEVTYPE_JASTEC},
0207 #endif
0208 
0209 #ifdef CONFIG_TOUCHSCREEN_USB_E2I
0210     {USB_DEVICE(0x1ac7, 0x0001), .driver_info = DEVTYPE_E2I},
0211 #endif
0212 
0213 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC
0214     {USB_DEVICE(0x14c8, 0x0003), .driver_info = DEVTYPE_ZYTRONIC},
0215 #endif
0216 
0217 #ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB
0218     /* TC5UH */
0219     {USB_DEVICE(0x0664, 0x0309), .driver_info = DEVTYPE_TC45USB},
0220     /* TC4UM */
0221     {USB_DEVICE(0x0664, 0x0306), .driver_info = DEVTYPE_TC45USB},
0222 #endif
0223 
0224 #ifdef CONFIG_TOUCHSCREEN_USB_NEXIO
0225     /* data interface only */
0226     {USB_DEVICE_AND_INTERFACE_INFO(0x10f0, 0x2002, 0x0a, 0x00, 0x00),
0227         .driver_info = DEVTYPE_NEXIO},
0228     {USB_DEVICE_AND_INTERFACE_INFO(0x1870, 0x0001, 0x0a, 0x00, 0x00),
0229         .driver_info = DEVTYPE_NEXIO},
0230 #endif
0231 
0232 #ifdef CONFIG_TOUCHSCREEN_USB_ELO
0233     {USB_DEVICE(0x04e7, 0x0020), .driver_info = DEVTYPE_ELO},
0234 #endif
0235 
0236 #ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH
0237     {USB_DEVICE(0x7374, 0x0001), .driver_info = DEVTYPE_ETOUCH},
0238 #endif
0239 
0240     {}
0241 };
0242 
0243 
0244 /*****************************************************************************
0245  * e2i Part
0246  */
0247 
0248 #ifdef CONFIG_TOUCHSCREEN_USB_E2I
0249 static int e2i_init(struct usbtouch_usb *usbtouch)
0250 {
0251     int ret;
0252     struct usb_device *udev = interface_to_usbdev(usbtouch->interface);
0253 
0254     ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
0255                           0x01, 0x02, 0x0000, 0x0081,
0256                           NULL, 0, USB_CTRL_SET_TIMEOUT);
0257 
0258     dev_dbg(&usbtouch->interface->dev,
0259         "%s - usb_control_msg - E2I_RESET - bytes|err: %d\n",
0260         __func__, ret);
0261     return ret;
0262 }
0263 
0264 static int e2i_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0265 {
0266     int tmp = (pkt[0] << 8) | pkt[1];
0267     dev->x  = (pkt[2] << 8) | pkt[3];
0268     dev->y  = (pkt[4] << 8) | pkt[5];
0269 
0270     tmp = tmp - 0xA000;
0271     dev->touch = (tmp > 0);
0272     dev->press = (tmp > 0 ? tmp : 0);
0273 
0274     return 1;
0275 }
0276 #endif
0277 
0278 
0279 /*****************************************************************************
0280  * eGalax part
0281  */
0282 
0283 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
0284 
0285 #ifndef MULTI_PACKET
0286 #define MULTI_PACKET
0287 #endif
0288 
0289 #define EGALAX_PKT_TYPE_MASK        0xFE
0290 #define EGALAX_PKT_TYPE_REPT        0x80
0291 #define EGALAX_PKT_TYPE_DIAG        0x0A
0292 
0293 static int egalax_init(struct usbtouch_usb *usbtouch)
0294 {
0295     int ret, i;
0296     unsigned char *buf;
0297     struct usb_device *udev = interface_to_usbdev(usbtouch->interface);
0298 
0299     /*
0300      * An eGalax diagnostic packet kicks the device into using the right
0301      * protocol.  We send a "check active" packet.  The response will be
0302      * read later and ignored.
0303      */
0304 
0305     buf = kmalloc(3, GFP_KERNEL);
0306     if (!buf)
0307         return -ENOMEM;
0308 
0309     buf[0] = EGALAX_PKT_TYPE_DIAG;
0310     buf[1] = 1; /* length */
0311     buf[2] = 'A';   /* command - check active */
0312 
0313     for (i = 0; i < 3; i++) {
0314         ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
0315                       0,
0316                       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0317                       0, 0, buf, 3,
0318                       USB_CTRL_SET_TIMEOUT);
0319         if (ret >= 0) {
0320             ret = 0;
0321             break;
0322         }
0323         if (ret != -EPIPE)
0324             break;
0325     }
0326 
0327     kfree(buf);
0328 
0329     return ret;
0330 }
0331 
0332 static int egalax_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0333 {
0334     if ((pkt[0] & EGALAX_PKT_TYPE_MASK) != EGALAX_PKT_TYPE_REPT)
0335         return 0;
0336 
0337     dev->x = ((pkt[3] & 0x0F) << 7) | (pkt[4] & 0x7F);
0338     dev->y = ((pkt[1] & 0x0F) << 7) | (pkt[2] & 0x7F);
0339     dev->touch = pkt[0] & 0x01;
0340 
0341     return 1;
0342 }
0343 
0344 static int egalax_get_pkt_len(unsigned char *buf, int len)
0345 {
0346     switch (buf[0] & EGALAX_PKT_TYPE_MASK) {
0347     case EGALAX_PKT_TYPE_REPT:
0348         return 5;
0349 
0350     case EGALAX_PKT_TYPE_DIAG:
0351         if (len < 2)
0352             return -1;
0353 
0354         return buf[1] + 2;
0355     }
0356 
0357     return 0;
0358 }
0359 #endif
0360 
0361 /*****************************************************************************
0362  * EasyTouch part
0363  */
0364 
0365 #ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH
0366 
0367 #ifndef MULTI_PACKET
0368 #define MULTI_PACKET
0369 #endif
0370 
0371 #define ETOUCH_PKT_TYPE_MASK        0xFE
0372 #define ETOUCH_PKT_TYPE_REPT        0x80
0373 #define ETOUCH_PKT_TYPE_REPT2       0xB0
0374 #define ETOUCH_PKT_TYPE_DIAG        0x0A
0375 
0376 static int etouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0377 {
0378     if ((pkt[0] & ETOUCH_PKT_TYPE_MASK) != ETOUCH_PKT_TYPE_REPT &&
0379         (pkt[0] & ETOUCH_PKT_TYPE_MASK) != ETOUCH_PKT_TYPE_REPT2)
0380         return 0;
0381 
0382     dev->x = ((pkt[1] & 0x1F) << 7) | (pkt[2] & 0x7F);
0383     dev->y = ((pkt[3] & 0x1F) << 7) | (pkt[4] & 0x7F);
0384     dev->touch = pkt[0] & 0x01;
0385 
0386     return 1;
0387 }
0388 
0389 static int etouch_get_pkt_len(unsigned char *buf, int len)
0390 {
0391     switch (buf[0] & ETOUCH_PKT_TYPE_MASK) {
0392     case ETOUCH_PKT_TYPE_REPT:
0393     case ETOUCH_PKT_TYPE_REPT2:
0394         return 5;
0395 
0396     case ETOUCH_PKT_TYPE_DIAG:
0397         if (len < 2)
0398             return -1;
0399 
0400         return buf[1] + 2;
0401     }
0402 
0403     return 0;
0404 }
0405 #endif
0406 
0407 /*****************************************************************************
0408  * PanJit Part
0409  */
0410 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
0411 static int panjit_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0412 {
0413     dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1];
0414     dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3];
0415     dev->touch = pkt[0] & 0x01;
0416 
0417     return 1;
0418 }
0419 #endif
0420 
0421 
0422 /*****************************************************************************
0423  * 3M/Microtouch Part
0424  */
0425 #ifdef CONFIG_TOUCHSCREEN_USB_3M
0426 
0427 #define MTOUCHUSB_ASYNC_REPORT          1
0428 #define MTOUCHUSB_RESET                 7
0429 #define MTOUCHUSB_REQ_CTRLLR_ID         10
0430 
0431 #define MTOUCHUSB_REQ_CTRLLR_ID_LEN 16
0432 
0433 static int mtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0434 {
0435     if (hwcalib_xy) {
0436         dev->x = (pkt[4] << 8) | pkt[3];
0437         dev->y = 0xffff - ((pkt[6] << 8) | pkt[5]);
0438     } else {
0439         dev->x = (pkt[8] << 8) | pkt[7];
0440         dev->y = (pkt[10] << 8) | pkt[9];
0441     }
0442     dev->touch = (pkt[2] & 0x40) ? 1 : 0;
0443 
0444     return 1;
0445 }
0446 
0447 struct mtouch_priv {
0448     u8 fw_rev_major;
0449     u8 fw_rev_minor;
0450 };
0451 
0452 static ssize_t mtouch_firmware_rev_show(struct device *dev,
0453                 struct device_attribute *attr, char *output)
0454 {
0455     struct usb_interface *intf = to_usb_interface(dev);
0456     struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
0457     struct mtouch_priv *priv = usbtouch->priv;
0458 
0459     return scnprintf(output, PAGE_SIZE, "%1x.%1x\n",
0460              priv->fw_rev_major, priv->fw_rev_minor);
0461 }
0462 static DEVICE_ATTR(firmware_rev, 0444, mtouch_firmware_rev_show, NULL);
0463 
0464 static struct attribute *mtouch_attrs[] = {
0465     &dev_attr_firmware_rev.attr,
0466     NULL
0467 };
0468 
0469 static const struct attribute_group mtouch_attr_group = {
0470     .attrs = mtouch_attrs,
0471 };
0472 
0473 static int mtouch_get_fw_revision(struct usbtouch_usb *usbtouch)
0474 {
0475     struct usb_device *udev = interface_to_usbdev(usbtouch->interface);
0476     struct mtouch_priv *priv = usbtouch->priv;
0477     u8 *buf;
0478     int ret;
0479 
0480     buf = kzalloc(MTOUCHUSB_REQ_CTRLLR_ID_LEN, GFP_NOIO);
0481     if (!buf)
0482         return -ENOMEM;
0483 
0484     ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
0485                   MTOUCHUSB_REQ_CTRLLR_ID,
0486                   USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0487                   0, 0, buf, MTOUCHUSB_REQ_CTRLLR_ID_LEN,
0488                   USB_CTRL_SET_TIMEOUT);
0489     if (ret != MTOUCHUSB_REQ_CTRLLR_ID_LEN) {
0490         dev_warn(&usbtouch->interface->dev,
0491              "Failed to read FW rev: %d\n", ret);
0492         ret = ret < 0 ? ret : -EIO;
0493         goto free;
0494     }
0495 
0496     priv->fw_rev_major = buf[3];
0497     priv->fw_rev_minor = buf[4];
0498 
0499     ret = 0;
0500 
0501 free:
0502     kfree(buf);
0503     return ret;
0504 }
0505 
0506 static int mtouch_alloc(struct usbtouch_usb *usbtouch)
0507 {
0508     int ret;
0509 
0510     usbtouch->priv = kmalloc(sizeof(struct mtouch_priv), GFP_KERNEL);
0511     if (!usbtouch->priv)
0512         return -ENOMEM;
0513 
0514     ret = sysfs_create_group(&usbtouch->interface->dev.kobj,
0515                  &mtouch_attr_group);
0516     if (ret) {
0517         kfree(usbtouch->priv);
0518         usbtouch->priv = NULL;
0519         return ret;
0520     }
0521 
0522     return 0;
0523 }
0524 
0525 static int mtouch_init(struct usbtouch_usb *usbtouch)
0526 {
0527     int ret, i;
0528     struct usb_device *udev = interface_to_usbdev(usbtouch->interface);
0529 
0530     ret = mtouch_get_fw_revision(usbtouch);
0531     if (ret)
0532         return ret;
0533 
0534     ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
0535                           MTOUCHUSB_RESET,
0536                           USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0537                           1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
0538     dev_dbg(&usbtouch->interface->dev,
0539         "%s - usb_control_msg - MTOUCHUSB_RESET - bytes|err: %d\n",
0540         __func__, ret);
0541     if (ret < 0)
0542         return ret;
0543     msleep(150);
0544 
0545     for (i = 0; i < 3; i++) {
0546         ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
0547                       MTOUCHUSB_ASYNC_REPORT,
0548                       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0549                       1, 1, NULL, 0, USB_CTRL_SET_TIMEOUT);
0550         dev_dbg(&usbtouch->interface->dev,
0551             "%s - usb_control_msg - MTOUCHUSB_ASYNC_REPORT - bytes|err: %d\n",
0552             __func__, ret);
0553         if (ret >= 0)
0554             break;
0555         if (ret != -EPIPE)
0556             return ret;
0557     }
0558 
0559     /* Default min/max xy are the raw values, override if using hw-calib */
0560     if (hwcalib_xy) {
0561         input_set_abs_params(usbtouch->input, ABS_X, 0, 0xffff, 0, 0);
0562         input_set_abs_params(usbtouch->input, ABS_Y, 0, 0xffff, 0, 0);
0563     }
0564 
0565     return 0;
0566 }
0567 
0568 static void mtouch_exit(struct usbtouch_usb *usbtouch)
0569 {
0570     struct mtouch_priv *priv = usbtouch->priv;
0571 
0572     sysfs_remove_group(&usbtouch->interface->dev.kobj, &mtouch_attr_group);
0573     kfree(priv);
0574 }
0575 #endif
0576 
0577 
0578 /*****************************************************************************
0579  * ITM Part
0580  */
0581 #ifdef CONFIG_TOUCHSCREEN_USB_ITM
0582 static int itm_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0583 {
0584     int touch;
0585     /*
0586      * ITM devices report invalid x/y data if not touched.
0587      * if the screen was touched before but is not touched any more
0588      * report touch as 0 with the last valid x/y data once. then stop
0589      * reporting data until touched again.
0590      */
0591     dev->press = ((pkt[2] & 0x01) << 7) | (pkt[5] & 0x7F);
0592 
0593     touch = ~pkt[7] & 0x20;
0594     if (!touch) {
0595         if (dev->touch) {
0596             dev->touch = 0;
0597             return 1;
0598         }
0599 
0600         return 0;
0601     }
0602 
0603     dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[3] & 0x7F);
0604     dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[4] & 0x7F);
0605     dev->touch = touch;
0606 
0607     return 1;
0608 }
0609 #endif
0610 
0611 
0612 /*****************************************************************************
0613  * eTurboTouch part
0614  */
0615 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
0616 #ifndef MULTI_PACKET
0617 #define MULTI_PACKET
0618 #endif
0619 static int eturbo_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0620 {
0621     unsigned int shift;
0622 
0623     /* packets should start with sync */
0624     if (!(pkt[0] & 0x80))
0625         return 0;
0626 
0627     shift = (6 - (pkt[0] & 0x03));
0628     dev->x = ((pkt[3] << 7) | pkt[4]) >> shift;
0629     dev->y = ((pkt[1] << 7) | pkt[2]) >> shift;
0630     dev->touch = (pkt[0] & 0x10) ? 1 : 0;
0631 
0632     return 1;
0633 }
0634 
0635 static int eturbo_get_pkt_len(unsigned char *buf, int len)
0636 {
0637     if (buf[0] & 0x80)
0638         return 5;
0639     if (buf[0] == 0x01)
0640         return 3;
0641     return 0;
0642 }
0643 #endif
0644 
0645 
0646 /*****************************************************************************
0647  * Gunze part
0648  */
0649 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
0650 static int gunze_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0651 {
0652     if (!(pkt[0] & 0x80) || ((pkt[1] | pkt[2] | pkt[3]) & 0x80))
0653         return 0;
0654 
0655     dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[2] & 0x7F);
0656     dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[3] & 0x7F);
0657     dev->touch = pkt[0] & 0x20;
0658 
0659     return 1;
0660 }
0661 #endif
0662 
0663 /*****************************************************************************
0664  * DMC TSC-10/25 Part
0665  *
0666  * Documentation about the controller and it's protocol can be found at
0667  *   http://www.dmccoltd.com/files/controler/tsc10usb_pi_e.pdf
0668  *   http://www.dmccoltd.com/files/controler/tsc25_usb_e.pdf
0669  */
0670 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
0671 
0672 /* supported data rates. currently using 130 */
0673 #define TSC10_RATE_POINT    0x50
0674 #define TSC10_RATE_30       0x40
0675 #define TSC10_RATE_50       0x41
0676 #define TSC10_RATE_80       0x42
0677 #define TSC10_RATE_100      0x43
0678 #define TSC10_RATE_130      0x44
0679 #define TSC10_RATE_150      0x45
0680 
0681 /* commands */
0682 #define TSC10_CMD_RESET     0x55
0683 #define TSC10_CMD_RATE      0x05
0684 #define TSC10_CMD_DATA1     0x01
0685 
0686 static int dmc_tsc10_init(struct usbtouch_usb *usbtouch)
0687 {
0688     struct usb_device *dev = interface_to_usbdev(usbtouch->interface);
0689     int ret = -ENOMEM;
0690     unsigned char *buf;
0691 
0692     buf = kmalloc(2, GFP_NOIO);
0693     if (!buf)
0694         goto err_nobuf;
0695     /* reset */
0696     buf[0] = buf[1] = 0xFF;
0697     ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
0698                           TSC10_CMD_RESET,
0699                           USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0700                           0, 0, buf, 2, USB_CTRL_SET_TIMEOUT);
0701     if (ret < 0)
0702         goto err_out;
0703     if (buf[0] != 0x06) {
0704         ret = -ENODEV;
0705         goto err_out;
0706     }
0707 
0708     /* TSC-25 data sheet specifies a delay after the RESET command */
0709     msleep(150);
0710 
0711     /* set coordinate output rate */
0712     buf[0] = buf[1] = 0xFF;
0713     ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
0714                           TSC10_CMD_RATE,
0715                           USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0716                           TSC10_RATE_150, 0, buf, 2, USB_CTRL_SET_TIMEOUT);
0717     if (ret < 0)
0718         goto err_out;
0719     if ((buf[0] != 0x06) && (buf[0] != 0x15 || buf[1] != 0x01)) {
0720         ret = -ENODEV;
0721         goto err_out;
0722     }
0723 
0724     /* start sending data */
0725     ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
0726                           TSC10_CMD_DATA1,
0727                           USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0728                           0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
0729 err_out:
0730     kfree(buf);
0731 err_nobuf:
0732     return ret;
0733 }
0734 
0735 
0736 static int dmc_tsc10_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0737 {
0738     dev->x = ((pkt[2] & 0x03) << 8) | pkt[1];
0739     dev->y = ((pkt[4] & 0x03) << 8) | pkt[3];
0740     dev->touch = pkt[0] & 0x01;
0741 
0742     return 1;
0743 }
0744 #endif
0745 
0746 
0747 /*****************************************************************************
0748  * IRTOUCH Part
0749  */
0750 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
0751 static int irtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0752 {
0753     dev->x = (pkt[3] << 8) | pkt[2];
0754     dev->y = (pkt[5] << 8) | pkt[4];
0755     dev->touch = (pkt[1] & 0x03) ? 1 : 0;
0756 
0757     return 1;
0758 }
0759 #endif
0760 
0761 /*****************************************************************************
0762  * ET&T TC5UH/TC4UM part
0763  */
0764 #ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB
0765 static int tc45usb_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0766 {
0767     dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1];
0768     dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3];
0769     dev->touch = pkt[0] & 0x01;
0770 
0771     return 1;
0772 }
0773 #endif
0774 
0775 /*****************************************************************************
0776  * IdealTEK URTC1000 Part
0777  */
0778 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
0779 #ifndef MULTI_PACKET
0780 #define MULTI_PACKET
0781 #endif
0782 static int idealtek_get_pkt_len(unsigned char *buf, int len)
0783 {
0784     if (buf[0] & 0x80)
0785         return 5;
0786     if (buf[0] == 0x01)
0787         return len;
0788     return 0;
0789 }
0790 
0791 static int idealtek_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0792 {
0793     switch (pkt[0] & 0x98) {
0794     case 0x88:
0795         /* touch data in IdealTEK mode */
0796         dev->x = (pkt[1] << 5) | (pkt[2] >> 2);
0797         dev->y = (pkt[3] << 5) | (pkt[4] >> 2);
0798         dev->touch = (pkt[0] & 0x40) ? 1 : 0;
0799         return 1;
0800 
0801     case 0x98:
0802         /* touch data in MT emulation mode */
0803         dev->x = (pkt[2] << 5) | (pkt[1] >> 2);
0804         dev->y = (pkt[4] << 5) | (pkt[3] >> 2);
0805         dev->touch = (pkt[0] & 0x40) ? 1 : 0;
0806         return 1;
0807 
0808     default:
0809         return 0;
0810     }
0811 }
0812 #endif
0813 
0814 /*****************************************************************************
0815  * General Touch Part
0816  */
0817 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
0818 static int general_touch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0819 {
0820     dev->x = (pkt[2] << 8) | pkt[1];
0821     dev->y = (pkt[4] << 8) | pkt[3];
0822     dev->press = pkt[5] & 0xff;
0823     dev->touch = pkt[0] & 0x01;
0824 
0825     return 1;
0826 }
0827 #endif
0828 
0829 /*****************************************************************************
0830  * GoTop Part
0831  */
0832 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
0833 static int gotop_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0834 {
0835     dev->x = ((pkt[1] & 0x38) << 4) | pkt[2];
0836     dev->y = ((pkt[1] & 0x07) << 7) | pkt[3];
0837     dev->touch = pkt[0] & 0x01;
0838 
0839     return 1;
0840 }
0841 #endif
0842 
0843 /*****************************************************************************
0844  * JASTEC Part
0845  */
0846 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC
0847 static int jastec_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0848 {
0849     dev->x = ((pkt[0] & 0x3f) << 6) | (pkt[2] & 0x3f);
0850     dev->y = ((pkt[1] & 0x3f) << 6) | (pkt[3] & 0x3f);
0851     dev->touch = (pkt[0] & 0x40) >> 6;
0852 
0853     return 1;
0854 }
0855 #endif
0856 
0857 /*****************************************************************************
0858  * Zytronic Part
0859  */
0860 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC
0861 static int zytronic_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
0862 {
0863     struct usb_interface *intf = dev->interface;
0864 
0865     switch (pkt[0]) {
0866     case 0x3A: /* command response */
0867         dev_dbg(&intf->dev, "%s: Command response %d\n", __func__, pkt[1]);
0868         break;
0869 
0870     case 0xC0: /* down */
0871         dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7);
0872         dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7);
0873         dev->touch = 1;
0874         dev_dbg(&intf->dev, "%s: down %d,%d\n", __func__, dev->x, dev->y);
0875         return 1;
0876 
0877     case 0x80: /* up */
0878         dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7);
0879         dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7);
0880         dev->touch = 0;
0881         dev_dbg(&intf->dev, "%s: up %d,%d\n", __func__, dev->x, dev->y);
0882         return 1;
0883 
0884     default:
0885         dev_dbg(&intf->dev, "%s: Unknown return %d\n", __func__, pkt[0]);
0886         break;
0887     }
0888 
0889     return 0;
0890 }
0891 #endif
0892 
0893 /*****************************************************************************
0894  * NEXIO Part
0895  */
0896 #ifdef CONFIG_TOUCHSCREEN_USB_NEXIO
0897 
0898 #define NEXIO_TIMEOUT   5000
0899 #define NEXIO_BUFSIZE   1024
0900 #define NEXIO_THRESHOLD 50
0901 
0902 struct nexio_priv {
0903     struct urb *ack;
0904     unsigned char *ack_buf;
0905 };
0906 
0907 struct nexio_touch_packet {
0908     u8  flags;      /* 0xe1 = touch, 0xe1 = release */
0909     __be16  data_len;   /* total bytes of touch data */
0910     __be16  x_len;      /* bytes for X axis */
0911     __be16  y_len;      /* bytes for Y axis */
0912     u8  data[];
0913 } __attribute__ ((packed));
0914 
0915 static unsigned char nexio_ack_pkt[2] = { 0xaa, 0x02 };
0916 static unsigned char nexio_init_pkt[4] = { 0x82, 0x04, 0x0a, 0x0f };
0917 
0918 static void nexio_ack_complete(struct urb *urb)
0919 {
0920 }
0921 
0922 static int nexio_alloc(struct usbtouch_usb *usbtouch)
0923 {
0924     struct nexio_priv *priv;
0925     int ret = -ENOMEM;
0926 
0927     usbtouch->priv = kmalloc(sizeof(struct nexio_priv), GFP_KERNEL);
0928     if (!usbtouch->priv)
0929         goto out_buf;
0930 
0931     priv = usbtouch->priv;
0932 
0933     priv->ack_buf = kmemdup(nexio_ack_pkt, sizeof(nexio_ack_pkt),
0934                 GFP_KERNEL);
0935     if (!priv->ack_buf)
0936         goto err_priv;
0937 
0938     priv->ack = usb_alloc_urb(0, GFP_KERNEL);
0939     if (!priv->ack) {
0940         dev_dbg(&usbtouch->interface->dev,
0941             "%s - usb_alloc_urb failed: usbtouch->ack\n", __func__);
0942         goto err_ack_buf;
0943     }
0944 
0945     return 0;
0946 
0947 err_ack_buf:
0948     kfree(priv->ack_buf);
0949 err_priv:
0950     kfree(priv);
0951 out_buf:
0952     return ret;
0953 }
0954 
0955 static int nexio_init(struct usbtouch_usb *usbtouch)
0956 {
0957     struct usb_device *dev = interface_to_usbdev(usbtouch->interface);
0958     struct usb_host_interface *interface = usbtouch->interface->cur_altsetting;
0959     struct nexio_priv *priv = usbtouch->priv;
0960     int ret = -ENOMEM;
0961     int actual_len, i;
0962     unsigned char *buf;
0963     char *firmware_ver = NULL, *device_name = NULL;
0964     int input_ep = 0, output_ep = 0;
0965 
0966     /* find first input and output endpoint */
0967     for (i = 0; i < interface->desc.bNumEndpoints; i++) {
0968         if (!input_ep &&
0969             usb_endpoint_dir_in(&interface->endpoint[i].desc))
0970             input_ep = interface->endpoint[i].desc.bEndpointAddress;
0971         if (!output_ep &&
0972             usb_endpoint_dir_out(&interface->endpoint[i].desc))
0973             output_ep = interface->endpoint[i].desc.bEndpointAddress;
0974     }
0975     if (!input_ep || !output_ep)
0976         return -ENXIO;
0977 
0978     buf = kmalloc(NEXIO_BUFSIZE, GFP_NOIO);
0979     if (!buf)
0980         goto out_buf;
0981 
0982     /* two empty reads */
0983     for (i = 0; i < 2; i++) {
0984         ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, input_ep),
0985                    buf, NEXIO_BUFSIZE, &actual_len,
0986                    NEXIO_TIMEOUT);
0987         if (ret < 0)
0988             goto out_buf;
0989     }
0990 
0991     /* send init command */
0992     memcpy(buf, nexio_init_pkt, sizeof(nexio_init_pkt));
0993     ret = usb_bulk_msg(dev, usb_sndbulkpipe(dev, output_ep),
0994                buf, sizeof(nexio_init_pkt), &actual_len,
0995                NEXIO_TIMEOUT);
0996     if (ret < 0)
0997         goto out_buf;
0998 
0999     /* read replies */
1000     for (i = 0; i < 3; i++) {
1001         memset(buf, 0, NEXIO_BUFSIZE);
1002         ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, input_ep),
1003                    buf, NEXIO_BUFSIZE, &actual_len,
1004                    NEXIO_TIMEOUT);
1005         if (ret < 0 || actual_len < 1 || buf[1] != actual_len)
1006             continue;
1007         switch (buf[0]) {
1008         case 0x83:  /* firmware version */
1009             if (!firmware_ver)
1010                 firmware_ver = kstrdup(&buf[2], GFP_NOIO);
1011             break;
1012         case 0x84:  /* device name */
1013             if (!device_name)
1014                 device_name = kstrdup(&buf[2], GFP_NOIO);
1015             break;
1016         }
1017     }
1018 
1019     printk(KERN_INFO "Nexio device: %s, firmware version: %s\n",
1020            device_name, firmware_ver);
1021 
1022     kfree(firmware_ver);
1023     kfree(device_name);
1024 
1025     usb_fill_bulk_urb(priv->ack, dev, usb_sndbulkpipe(dev, output_ep),
1026               priv->ack_buf, sizeof(nexio_ack_pkt),
1027               nexio_ack_complete, usbtouch);
1028     ret = 0;
1029 
1030 out_buf:
1031     kfree(buf);
1032     return ret;
1033 }
1034 
1035 static void nexio_exit(struct usbtouch_usb *usbtouch)
1036 {
1037     struct nexio_priv *priv = usbtouch->priv;
1038 
1039     usb_kill_urb(priv->ack);
1040     usb_free_urb(priv->ack);
1041     kfree(priv->ack_buf);
1042     kfree(priv);
1043 }
1044 
1045 static int nexio_read_data(struct usbtouch_usb *usbtouch, unsigned char *pkt)
1046 {
1047     struct device *dev = &usbtouch->interface->dev;
1048     struct nexio_touch_packet *packet = (void *) pkt;
1049     struct nexio_priv *priv = usbtouch->priv;
1050     unsigned int data_len = be16_to_cpu(packet->data_len);
1051     unsigned int x_len = be16_to_cpu(packet->x_len);
1052     unsigned int y_len = be16_to_cpu(packet->y_len);
1053     int x, y, begin_x, begin_y, end_x, end_y, w, h, ret;
1054 
1055     /* got touch data? */
1056     if ((pkt[0] & 0xe0) != 0xe0)
1057         return 0;
1058 
1059     if (data_len > 0xff)
1060         data_len -= 0x100;
1061     if (x_len > 0xff)
1062         x_len -= 0x80;
1063 
1064     /* send ACK */
1065     ret = usb_submit_urb(priv->ack, GFP_ATOMIC);
1066     if (ret)
1067         dev_warn(dev, "Failed to submit ACK URB: %d\n", ret);
1068 
1069     if (!usbtouch->type->max_xc) {
1070         usbtouch->type->max_xc = 2 * x_len;
1071         input_set_abs_params(usbtouch->input, ABS_X,
1072                      0, usbtouch->type->max_xc, 0, 0);
1073         usbtouch->type->max_yc = 2 * y_len;
1074         input_set_abs_params(usbtouch->input, ABS_Y,
1075                      0, usbtouch->type->max_yc, 0, 0);
1076     }
1077     /*
1078      * The device reports state of IR sensors on X and Y axes.
1079      * Each byte represents "darkness" percentage (0-100) of one element.
1080      * 17" touchscreen reports only 64 x 52 bytes so the resolution is low.
1081      * This also means that there's a limited multi-touch capability but
1082      * it's disabled (and untested) here as there's no X driver for that.
1083      */
1084     begin_x = end_x = begin_y = end_y = -1;
1085     for (x = 0; x < x_len; x++) {
1086         if (begin_x == -1 && packet->data[x] > NEXIO_THRESHOLD) {
1087             begin_x = x;
1088             continue;
1089         }
1090         if (end_x == -1 && begin_x != -1 && packet->data[x] < NEXIO_THRESHOLD) {
1091             end_x = x - 1;
1092             for (y = x_len; y < data_len; y++) {
1093                 if (begin_y == -1 && packet->data[y] > NEXIO_THRESHOLD) {
1094                     begin_y = y - x_len;
1095                     continue;
1096                 }
1097                 if (end_y == -1 &&
1098                     begin_y != -1 && packet->data[y] < NEXIO_THRESHOLD) {
1099                     end_y = y - 1 - x_len;
1100                     w = end_x - begin_x;
1101                     h = end_y - begin_y;
1102 #if 0
1103                     /* multi-touch */
1104                     input_report_abs(usbtouch->input,
1105                             ABS_MT_TOUCH_MAJOR, max(w,h));
1106                     input_report_abs(usbtouch->input,
1107                             ABS_MT_TOUCH_MINOR, min(x,h));
1108                     input_report_abs(usbtouch->input,
1109                             ABS_MT_POSITION_X, 2*begin_x+w);
1110                     input_report_abs(usbtouch->input,
1111                             ABS_MT_POSITION_Y, 2*begin_y+h);
1112                     input_report_abs(usbtouch->input,
1113                             ABS_MT_ORIENTATION, w > h);
1114                     input_mt_sync(usbtouch->input);
1115 #endif
1116                     /* single touch */
1117                     usbtouch->x = 2 * begin_x + w;
1118                     usbtouch->y = 2 * begin_y + h;
1119                     usbtouch->touch = packet->flags & 0x01;
1120                     begin_y = end_y = -1;
1121                     return 1;
1122                 }
1123             }
1124             begin_x = end_x = -1;
1125         }
1126 
1127     }
1128     return 0;
1129 }
1130 #endif
1131 
1132 
1133 /*****************************************************************************
1134  * ELO part
1135  */
1136 
1137 #ifdef CONFIG_TOUCHSCREEN_USB_ELO
1138 
1139 static int elo_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
1140 {
1141     dev->x = (pkt[3] << 8) | pkt[2];
1142     dev->y = (pkt[5] << 8) | pkt[4];
1143     dev->touch = pkt[6] > 0;
1144     dev->press = pkt[6];
1145 
1146     return 1;
1147 }
1148 #endif
1149 
1150 
1151 /*****************************************************************************
1152  * the different device descriptors
1153  */
1154 #ifdef MULTI_PACKET
1155 static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
1156                    unsigned char *pkt, int len);
1157 #endif
1158 
1159 static struct usbtouch_device_info usbtouch_dev_info[] = {
1160 #ifdef CONFIG_TOUCHSCREEN_USB_ELO
1161     [DEVTYPE_ELO] = {
1162         .min_xc     = 0x0,
1163         .max_xc     = 0x0fff,
1164         .min_yc     = 0x0,
1165         .max_yc     = 0x0fff,
1166         .max_press  = 0xff,
1167         .rept_size  = 8,
1168         .read_data  = elo_read_data,
1169     },
1170 #endif
1171 
1172 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
1173     [DEVTYPE_EGALAX] = {
1174         .min_xc     = 0x0,
1175         .max_xc     = 0x07ff,
1176         .min_yc     = 0x0,
1177         .max_yc     = 0x07ff,
1178         .rept_size  = 16,
1179         .process_pkt    = usbtouch_process_multi,
1180         .get_pkt_len    = egalax_get_pkt_len,
1181         .read_data  = egalax_read_data,
1182         .init       = egalax_init,
1183     },
1184 #endif
1185 
1186 #ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
1187     [DEVTYPE_PANJIT] = {
1188         .min_xc     = 0x0,
1189         .max_xc     = 0x0fff,
1190         .min_yc     = 0x0,
1191         .max_yc     = 0x0fff,
1192         .rept_size  = 8,
1193         .read_data  = panjit_read_data,
1194     },
1195 #endif
1196 
1197 #ifdef CONFIG_TOUCHSCREEN_USB_3M
1198     [DEVTYPE_3M] = {
1199         .min_xc     = 0x0,
1200         .max_xc     = 0x4000,
1201         .min_yc     = 0x0,
1202         .max_yc     = 0x4000,
1203         .rept_size  = 11,
1204         .read_data  = mtouch_read_data,
1205         .alloc      = mtouch_alloc,
1206         .init       = mtouch_init,
1207         .exit       = mtouch_exit,
1208     },
1209 #endif
1210 
1211 #ifdef CONFIG_TOUCHSCREEN_USB_ITM
1212     [DEVTYPE_ITM] = {
1213         .min_xc     = 0x0,
1214         .max_xc     = 0x0fff,
1215         .min_yc     = 0x0,
1216         .max_yc     = 0x0fff,
1217         .max_press  = 0xff,
1218         .rept_size  = 8,
1219         .read_data  = itm_read_data,
1220     },
1221 #endif
1222 
1223 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
1224     [DEVTYPE_ETURBO] = {
1225         .min_xc     = 0x0,
1226         .max_xc     = 0x07ff,
1227         .min_yc     = 0x0,
1228         .max_yc     = 0x07ff,
1229         .rept_size  = 8,
1230         .process_pkt    = usbtouch_process_multi,
1231         .get_pkt_len    = eturbo_get_pkt_len,
1232         .read_data  = eturbo_read_data,
1233     },
1234 #endif
1235 
1236 #ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
1237     [DEVTYPE_GUNZE] = {
1238         .min_xc     = 0x0,
1239         .max_xc     = 0x0fff,
1240         .min_yc     = 0x0,
1241         .max_yc     = 0x0fff,
1242         .rept_size  = 4,
1243         .read_data  = gunze_read_data,
1244     },
1245 #endif
1246 
1247 #ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
1248     [DEVTYPE_DMC_TSC10] = {
1249         .min_xc     = 0x0,
1250         .max_xc     = 0x03ff,
1251         .min_yc     = 0x0,
1252         .max_yc     = 0x03ff,
1253         .rept_size  = 5,
1254         .init       = dmc_tsc10_init,
1255         .read_data  = dmc_tsc10_read_data,
1256     },
1257 #endif
1258 
1259 #ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
1260     [DEVTYPE_IRTOUCH] = {
1261         .min_xc     = 0x0,
1262         .max_xc     = 0x0fff,
1263         .min_yc     = 0x0,
1264         .max_yc     = 0x0fff,
1265         .rept_size  = 8,
1266         .read_data  = irtouch_read_data,
1267     },
1268 
1269     [DEVTYPE_IRTOUCH_HIRES] = {
1270         .min_xc     = 0x0,
1271         .max_xc     = 0x7fff,
1272         .min_yc     = 0x0,
1273         .max_yc     = 0x7fff,
1274         .rept_size  = 8,
1275         .read_data  = irtouch_read_data,
1276     },
1277 #endif
1278 
1279 #ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
1280     [DEVTYPE_IDEALTEK] = {
1281         .min_xc     = 0x0,
1282         .max_xc     = 0x0fff,
1283         .min_yc     = 0x0,
1284         .max_yc     = 0x0fff,
1285         .rept_size  = 8,
1286         .process_pkt    = usbtouch_process_multi,
1287         .get_pkt_len    = idealtek_get_pkt_len,
1288         .read_data  = idealtek_read_data,
1289     },
1290 #endif
1291 
1292 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
1293     [DEVTYPE_GENERAL_TOUCH] = {
1294         .min_xc     = 0x0,
1295         .max_xc     = 0x7fff,
1296         .min_yc     = 0x0,
1297         .max_yc     = 0x7fff,
1298         .rept_size  = 7,
1299         .read_data  = general_touch_read_data,
1300     },
1301 #endif
1302 
1303 #ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
1304     [DEVTYPE_GOTOP] = {
1305         .min_xc     = 0x0,
1306         .max_xc     = 0x03ff,
1307         .min_yc     = 0x0,
1308         .max_yc     = 0x03ff,
1309         .rept_size  = 4,
1310         .read_data  = gotop_read_data,
1311     },
1312 #endif
1313 
1314 #ifdef CONFIG_TOUCHSCREEN_USB_JASTEC
1315     [DEVTYPE_JASTEC] = {
1316         .min_xc     = 0x0,
1317         .max_xc     = 0x0fff,
1318         .min_yc     = 0x0,
1319         .max_yc     = 0x0fff,
1320         .rept_size  = 4,
1321         .read_data  = jastec_read_data,
1322     },
1323 #endif
1324 
1325 #ifdef CONFIG_TOUCHSCREEN_USB_E2I
1326     [DEVTYPE_E2I] = {
1327         .min_xc     = 0x0,
1328         .max_xc     = 0x7fff,
1329         .min_yc     = 0x0,
1330         .max_yc     = 0x7fff,
1331         .rept_size  = 6,
1332         .init       = e2i_init,
1333         .read_data  = e2i_read_data,
1334     },
1335 #endif
1336 
1337 #ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC
1338     [DEVTYPE_ZYTRONIC] = {
1339         .min_xc     = 0x0,
1340         .max_xc     = 0x03ff,
1341         .min_yc     = 0x0,
1342         .max_yc     = 0x03ff,
1343         .rept_size  = 5,
1344         .read_data  = zytronic_read_data,
1345         .irq_always     = true,
1346     },
1347 #endif
1348 
1349 #ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB
1350     [DEVTYPE_TC45USB] = {
1351         .min_xc     = 0x0,
1352         .max_xc     = 0x0fff,
1353         .min_yc     = 0x0,
1354         .max_yc     = 0x0fff,
1355         .rept_size  = 5,
1356         .read_data  = tc45usb_read_data,
1357     },
1358 #endif
1359 
1360 #ifdef CONFIG_TOUCHSCREEN_USB_NEXIO
1361     [DEVTYPE_NEXIO] = {
1362         .rept_size  = 1024,
1363         .irq_always = true,
1364         .read_data  = nexio_read_data,
1365         .alloc      = nexio_alloc,
1366         .init       = nexio_init,
1367         .exit       = nexio_exit,
1368     },
1369 #endif
1370 #ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH
1371     [DEVTYPE_ETOUCH] = {
1372         .min_xc     = 0x0,
1373         .max_xc     = 0x07ff,
1374         .min_yc     = 0x0,
1375         .max_yc     = 0x07ff,
1376         .rept_size  = 16,
1377         .process_pkt    = usbtouch_process_multi,
1378         .get_pkt_len    = etouch_get_pkt_len,
1379         .read_data  = etouch_read_data,
1380     },
1381 #endif
1382 };
1383 
1384 
1385 /*****************************************************************************
1386  * Generic Part
1387  */
1388 static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch,
1389                                  unsigned char *pkt, int len)
1390 {
1391     struct usbtouch_device_info *type = usbtouch->type;
1392 
1393     if (!type->read_data(usbtouch, pkt))
1394             return;
1395 
1396     input_report_key(usbtouch->input, BTN_TOUCH, usbtouch->touch);
1397 
1398     if (swap_xy) {
1399         input_report_abs(usbtouch->input, ABS_X, usbtouch->y);
1400         input_report_abs(usbtouch->input, ABS_Y, usbtouch->x);
1401     } else {
1402         input_report_abs(usbtouch->input, ABS_X, usbtouch->x);
1403         input_report_abs(usbtouch->input, ABS_Y, usbtouch->y);
1404     }
1405     if (type->max_press)
1406         input_report_abs(usbtouch->input, ABS_PRESSURE, usbtouch->press);
1407     input_sync(usbtouch->input);
1408 }
1409 
1410 
1411 #ifdef MULTI_PACKET
1412 static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
1413                                    unsigned char *pkt, int len)
1414 {
1415     unsigned char *buffer;
1416     int pkt_len, pos, buf_len, tmp;
1417 
1418     /* process buffer */
1419     if (unlikely(usbtouch->buf_len)) {
1420         /* try to get size */
1421         pkt_len = usbtouch->type->get_pkt_len(
1422                 usbtouch->buffer, usbtouch->buf_len);
1423 
1424         /* drop? */
1425         if (unlikely(!pkt_len))
1426             goto out_flush_buf;
1427 
1428         /* need to append -pkt_len bytes before able to get size */
1429         if (unlikely(pkt_len < 0)) {
1430             int append = -pkt_len;
1431             if (unlikely(append > len))
1432                    append = len;
1433             if (usbtouch->buf_len + append >= usbtouch->type->rept_size)
1434                 goto out_flush_buf;
1435             memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, append);
1436             usbtouch->buf_len += append;
1437 
1438             pkt_len = usbtouch->type->get_pkt_len(
1439                     usbtouch->buffer, usbtouch->buf_len);
1440             if (pkt_len < 0)
1441                 return;
1442         }
1443 
1444         /* append */
1445         tmp = pkt_len - usbtouch->buf_len;
1446         if (usbtouch->buf_len + tmp >= usbtouch->type->rept_size)
1447             goto out_flush_buf;
1448         memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, tmp);
1449         usbtouch_process_pkt(usbtouch, usbtouch->buffer, pkt_len);
1450 
1451         buffer = pkt + tmp;
1452         buf_len = len - tmp;
1453     } else {
1454         buffer = pkt;
1455         buf_len = len;
1456     }
1457 
1458     /* loop over the received packet, process */
1459     pos = 0;
1460     while (pos < buf_len) {
1461         /* get packet len */
1462         pkt_len = usbtouch->type->get_pkt_len(buffer + pos,
1463                             buf_len - pos);
1464 
1465         /* unknown packet: skip one byte */
1466         if (unlikely(!pkt_len)) {
1467             pos++;
1468             continue;
1469         }
1470 
1471         /* full packet: process */
1472         if (likely((pkt_len > 0) && (pkt_len <= buf_len - pos))) {
1473             usbtouch_process_pkt(usbtouch, buffer + pos, pkt_len);
1474         } else {
1475             /* incomplete packet: save in buffer */
1476             memcpy(usbtouch->buffer, buffer + pos, buf_len - pos);
1477             usbtouch->buf_len = buf_len - pos;
1478             return;
1479         }
1480         pos += pkt_len;
1481     }
1482 
1483 out_flush_buf:
1484     usbtouch->buf_len = 0;
1485     return;
1486 }
1487 #endif
1488 
1489 
1490 static void usbtouch_irq(struct urb *urb)
1491 {
1492     struct usbtouch_usb *usbtouch = urb->context;
1493     struct device *dev = &usbtouch->interface->dev;
1494     int retval;
1495 
1496     switch (urb->status) {
1497     case 0:
1498         /* success */
1499         break;
1500     case -ETIME:
1501         /* this urb is timing out */
1502         dev_dbg(dev,
1503             "%s - urb timed out - was the device unplugged?\n",
1504             __func__);
1505         return;
1506     case -ECONNRESET:
1507     case -ENOENT:
1508     case -ESHUTDOWN:
1509     case -EPIPE:
1510         /* this urb is terminated, clean up */
1511         dev_dbg(dev, "%s - urb shutting down with status: %d\n",
1512             __func__, urb->status);
1513         return;
1514     default:
1515         dev_dbg(dev, "%s - nonzero urb status received: %d\n",
1516             __func__, urb->status);
1517         goto exit;
1518     }
1519 
1520     usbtouch->type->process_pkt(usbtouch, usbtouch->data, urb->actual_length);
1521 
1522 exit:
1523     usb_mark_last_busy(interface_to_usbdev(usbtouch->interface));
1524     retval = usb_submit_urb(urb, GFP_ATOMIC);
1525     if (retval)
1526         dev_err(dev, "%s - usb_submit_urb failed with result: %d\n",
1527             __func__, retval);
1528 }
1529 
1530 static int usbtouch_open(struct input_dev *input)
1531 {
1532     struct usbtouch_usb *usbtouch = input_get_drvdata(input);
1533     int r;
1534 
1535     usbtouch->irq->dev = interface_to_usbdev(usbtouch->interface);
1536 
1537     r = usb_autopm_get_interface(usbtouch->interface) ? -EIO : 0;
1538     if (r < 0)
1539         goto out;
1540 
1541     mutex_lock(&usbtouch->pm_mutex);
1542     if (!usbtouch->type->irq_always) {
1543         if (usb_submit_urb(usbtouch->irq, GFP_KERNEL)) {
1544             r = -EIO;
1545             goto out_put;
1546         }
1547     }
1548 
1549     usbtouch->interface->needs_remote_wakeup = 1;
1550     usbtouch->is_open = true;
1551 out_put:
1552     mutex_unlock(&usbtouch->pm_mutex);
1553     usb_autopm_put_interface(usbtouch->interface);
1554 out:
1555     return r;
1556 }
1557 
1558 static void usbtouch_close(struct input_dev *input)
1559 {
1560     struct usbtouch_usb *usbtouch = input_get_drvdata(input);
1561     int r;
1562 
1563     mutex_lock(&usbtouch->pm_mutex);
1564     if (!usbtouch->type->irq_always)
1565         usb_kill_urb(usbtouch->irq);
1566     usbtouch->is_open = false;
1567     mutex_unlock(&usbtouch->pm_mutex);
1568 
1569     r = usb_autopm_get_interface(usbtouch->interface);
1570     usbtouch->interface->needs_remote_wakeup = 0;
1571     if (!r)
1572         usb_autopm_put_interface(usbtouch->interface);
1573 }
1574 
1575 static int usbtouch_suspend
1576 (struct usb_interface *intf, pm_message_t message)
1577 {
1578     struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
1579 
1580     usb_kill_urb(usbtouch->irq);
1581 
1582     return 0;
1583 }
1584 
1585 static int usbtouch_resume(struct usb_interface *intf)
1586 {
1587     struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
1588     int result = 0;
1589 
1590     mutex_lock(&usbtouch->pm_mutex);
1591     if (usbtouch->is_open || usbtouch->type->irq_always)
1592         result = usb_submit_urb(usbtouch->irq, GFP_NOIO);
1593     mutex_unlock(&usbtouch->pm_mutex);
1594 
1595     return result;
1596 }
1597 
1598 static int usbtouch_reset_resume(struct usb_interface *intf)
1599 {
1600     struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
1601     int err = 0;
1602 
1603     /* reinit the device */
1604     if (usbtouch->type->init) {
1605         err = usbtouch->type->init(usbtouch);
1606         if (err) {
1607             dev_dbg(&intf->dev,
1608                 "%s - type->init() failed, err: %d\n",
1609                 __func__, err);
1610             return err;
1611         }
1612     }
1613 
1614     /* restart IO if needed */
1615     mutex_lock(&usbtouch->pm_mutex);
1616     if (usbtouch->is_open)
1617         err = usb_submit_urb(usbtouch->irq, GFP_NOIO);
1618     mutex_unlock(&usbtouch->pm_mutex);
1619 
1620     return err;
1621 }
1622 
1623 static void usbtouch_free_buffers(struct usb_device *udev,
1624                   struct usbtouch_usb *usbtouch)
1625 {
1626     usb_free_coherent(udev, usbtouch->data_size,
1627               usbtouch->data, usbtouch->data_dma);
1628     kfree(usbtouch->buffer);
1629 }
1630 
1631 static struct usb_endpoint_descriptor *
1632 usbtouch_get_input_endpoint(struct usb_host_interface *interface)
1633 {
1634     int i;
1635 
1636     for (i = 0; i < interface->desc.bNumEndpoints; i++)
1637         if (usb_endpoint_dir_in(&interface->endpoint[i].desc))
1638             return &interface->endpoint[i].desc;
1639 
1640     return NULL;
1641 }
1642 
1643 static int usbtouch_probe(struct usb_interface *intf,
1644               const struct usb_device_id *id)
1645 {
1646     struct usbtouch_usb *usbtouch;
1647     struct input_dev *input_dev;
1648     struct usb_endpoint_descriptor *endpoint;
1649     struct usb_device *udev = interface_to_usbdev(intf);
1650     struct usbtouch_device_info *type;
1651     int err = -ENOMEM;
1652 
1653     /* some devices are ignored */
1654     if (id->driver_info == DEVTYPE_IGNORE)
1655         return -ENODEV;
1656 
1657     if (id->driver_info >= ARRAY_SIZE(usbtouch_dev_info))
1658         return -ENODEV;
1659 
1660     endpoint = usbtouch_get_input_endpoint(intf->cur_altsetting);
1661     if (!endpoint)
1662         return -ENXIO;
1663 
1664     usbtouch = kzalloc(sizeof(struct usbtouch_usb), GFP_KERNEL);
1665     input_dev = input_allocate_device();
1666     if (!usbtouch || !input_dev)
1667         goto out_free;
1668 
1669     mutex_init(&usbtouch->pm_mutex);
1670 
1671     type = &usbtouch_dev_info[id->driver_info];
1672     usbtouch->type = type;
1673     if (!type->process_pkt)
1674         type->process_pkt = usbtouch_process_pkt;
1675 
1676     usbtouch->data_size = type->rept_size;
1677     if (type->get_pkt_len) {
1678         /*
1679          * When dealing with variable-length packets we should
1680          * not request more than wMaxPacketSize bytes at once
1681          * as we do not know if there is more data coming or
1682          * we filled exactly wMaxPacketSize bytes and there is
1683          * nothing else.
1684          */
1685         usbtouch->data_size = min(usbtouch->data_size,
1686                       usb_endpoint_maxp(endpoint));
1687     }
1688 
1689     usbtouch->data = usb_alloc_coherent(udev, usbtouch->data_size,
1690                         GFP_KERNEL, &usbtouch->data_dma);
1691     if (!usbtouch->data)
1692         goto out_free;
1693 
1694     if (type->get_pkt_len) {
1695         usbtouch->buffer = kmalloc(type->rept_size, GFP_KERNEL);
1696         if (!usbtouch->buffer)
1697             goto out_free_buffers;
1698     }
1699 
1700     usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL);
1701     if (!usbtouch->irq) {
1702         dev_dbg(&intf->dev,
1703             "%s - usb_alloc_urb failed: usbtouch->irq\n", __func__);
1704         goto out_free_buffers;
1705     }
1706 
1707     usbtouch->interface = intf;
1708     usbtouch->input = input_dev;
1709 
1710     if (udev->manufacturer)
1711         strlcpy(usbtouch->name, udev->manufacturer, sizeof(usbtouch->name));
1712 
1713     if (udev->product) {
1714         if (udev->manufacturer)
1715             strlcat(usbtouch->name, " ", sizeof(usbtouch->name));
1716         strlcat(usbtouch->name, udev->product, sizeof(usbtouch->name));
1717     }
1718 
1719     if (!strlen(usbtouch->name))
1720         snprintf(usbtouch->name, sizeof(usbtouch->name),
1721             "USB Touchscreen %04x:%04x",
1722              le16_to_cpu(udev->descriptor.idVendor),
1723              le16_to_cpu(udev->descriptor.idProduct));
1724 
1725     usb_make_path(udev, usbtouch->phys, sizeof(usbtouch->phys));
1726     strlcat(usbtouch->phys, "/input0", sizeof(usbtouch->phys));
1727 
1728     input_dev->name = usbtouch->name;
1729     input_dev->phys = usbtouch->phys;
1730     usb_to_input_id(udev, &input_dev->id);
1731     input_dev->dev.parent = &intf->dev;
1732 
1733     input_set_drvdata(input_dev, usbtouch);
1734 
1735     input_dev->open = usbtouch_open;
1736     input_dev->close = usbtouch_close;
1737 
1738     input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
1739     input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
1740     input_set_abs_params(input_dev, ABS_X, type->min_xc, type->max_xc, 0, 0);
1741     input_set_abs_params(input_dev, ABS_Y, type->min_yc, type->max_yc, 0, 0);
1742     if (type->max_press)
1743         input_set_abs_params(input_dev, ABS_PRESSURE, type->min_press,
1744                              type->max_press, 0, 0);
1745 
1746     if (usb_endpoint_type(endpoint) == USB_ENDPOINT_XFER_INT)
1747         usb_fill_int_urb(usbtouch->irq, udev,
1748              usb_rcvintpipe(udev, endpoint->bEndpointAddress),
1749              usbtouch->data, usbtouch->data_size,
1750              usbtouch_irq, usbtouch, endpoint->bInterval);
1751     else
1752         usb_fill_bulk_urb(usbtouch->irq, udev,
1753              usb_rcvbulkpipe(udev, endpoint->bEndpointAddress),
1754              usbtouch->data, usbtouch->data_size,
1755              usbtouch_irq, usbtouch);
1756 
1757     usbtouch->irq->dev = udev;
1758     usbtouch->irq->transfer_dma = usbtouch->data_dma;
1759     usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1760 
1761     /* device specific allocations */
1762     if (type->alloc) {
1763         err = type->alloc(usbtouch);
1764         if (err) {
1765             dev_dbg(&intf->dev,
1766                 "%s - type->alloc() failed, err: %d\n",
1767                 __func__, err);
1768             goto out_free_urb;
1769         }
1770     }
1771 
1772     /* device specific initialisation*/
1773     if (type->init) {
1774         err = type->init(usbtouch);
1775         if (err) {
1776             dev_dbg(&intf->dev,
1777                 "%s - type->init() failed, err: %d\n",
1778                 __func__, err);
1779             goto out_do_exit;
1780         }
1781     }
1782 
1783     err = input_register_device(usbtouch->input);
1784     if (err) {
1785         dev_dbg(&intf->dev,
1786             "%s - input_register_device failed, err: %d\n",
1787             __func__, err);
1788         goto out_do_exit;
1789     }
1790 
1791     usb_set_intfdata(intf, usbtouch);
1792 
1793     if (usbtouch->type->irq_always) {
1794         /* this can't fail */
1795         usb_autopm_get_interface(intf);
1796         err = usb_submit_urb(usbtouch->irq, GFP_KERNEL);
1797         if (err) {
1798             usb_autopm_put_interface(intf);
1799             dev_err(&intf->dev,
1800                 "%s - usb_submit_urb failed with result: %d\n",
1801                 __func__, err);
1802             goto out_unregister_input;
1803         }
1804     }
1805 
1806     return 0;
1807 
1808 out_unregister_input:
1809     input_unregister_device(input_dev);
1810     input_dev = NULL;
1811 out_do_exit:
1812     if (type->exit)
1813         type->exit(usbtouch);
1814 out_free_urb:
1815     usb_free_urb(usbtouch->irq);
1816 out_free_buffers:
1817     usbtouch_free_buffers(udev, usbtouch);
1818 out_free:
1819     input_free_device(input_dev);
1820     kfree(usbtouch);
1821     return err;
1822 }
1823 
1824 static void usbtouch_disconnect(struct usb_interface *intf)
1825 {
1826     struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
1827 
1828     if (!usbtouch)
1829         return;
1830 
1831     dev_dbg(&intf->dev,
1832         "%s - usbtouch is initialized, cleaning up\n", __func__);
1833 
1834     usb_set_intfdata(intf, NULL);
1835     /* this will stop IO via close */
1836     input_unregister_device(usbtouch->input);
1837     usb_free_urb(usbtouch->irq);
1838     if (usbtouch->type->exit)
1839         usbtouch->type->exit(usbtouch);
1840     usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch);
1841     kfree(usbtouch);
1842 }
1843 
1844 MODULE_DEVICE_TABLE(usb, usbtouch_devices);
1845 
1846 static struct usb_driver usbtouch_driver = {
1847     .name       = "usbtouchscreen",
1848     .probe      = usbtouch_probe,
1849     .disconnect = usbtouch_disconnect,
1850     .suspend    = usbtouch_suspend,
1851     .resume     = usbtouch_resume,
1852     .reset_resume   = usbtouch_reset_resume,
1853     .id_table   = usbtouch_devices,
1854     .supports_autosuspend = 1,
1855 };
1856 
1857 module_usb_driver(usbtouch_driver);
1858 
1859 MODULE_AUTHOR("Daniel Ritz <daniel.ritz@gmx.ch>");
1860 MODULE_DESCRIPTION("USB Touchscreen Driver");
1861 MODULE_LICENSE("GPL");
1862 
1863 MODULE_ALIAS("touchkitusb");
1864 MODULE_ALIAS("itmtouch");
1865 MODULE_ALIAS("mtouchusb");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!