Chinaunix首页 | 论坛 | 博客

mark_huang

首页　| 　博文目录　| 　关于我

迷路的泥瓦匠

  • 博客访问： 82778
  • 博文数量： 19
  • 博客积分： 325
  • 博客等级： 一等列兵
  • 技术积分： 197
  • 用 户 组： 普通用户
  • 注册时间： 2012-10-29 11:51
文章分类

全部博文（19）

文章存档

2013年（1）

2012年（18）

我的朋友
最近访客
推荐博文
相关博文
USB touch panel

分类： LINUX

2012-11-20 23:10:28

在USB设备的逻辑组织中，包含设备、配置、接口和端点4个层次。


点击(此处)折叠或打开

  1. /* USB_DT_DEVICE: Device descriptor */
  2. struct usb_device_descriptor {
  3.     __u8 bLength;
  4.     __u8 bDescriptorType;

  6.     __le16 bcdUSB;
  7.     __u8 bDeviceClass;
  8.     __u8 bDeviceSubClass;
  9.     __u8 bDeviceProtocol;
  10.     __u8 bMaxPacketSize0;
  11.     __le16 idVendor;
  12.     __le16 idProduct;
  13.     __le16 bcdDevice;
  14.     __u8 iManufacturer;
  15.     __u8 iProduct;
  16.     __u8 iSerialNumber;
  17.     __u8 bNumConfigurations;
  18. } __attribute__ ((packed));

点击(此处)折叠或打开

  1. /* USB_DT_CONFIG: Configuration descriptor information.
  2.  *
  3.  * USB_DT_OTHER_SPEED_CONFIG is the same descriptor, except that the
  4.  * descriptor type is different. Highspeed-capable devices can look
  5.  * different depending on what speed they're currently running. Only
  6.  * devices with a USB_DT_DEVICE_QUALIFIER have any OTHER_SPEED_CONFIG
  7.  * descriptors.
  8.  */
  9. struct usb_config_descriptor {
  10.     __u8 bLength;
  11.     __u8 bDescriptorType;

  13.     __le16 wTotalLength;
  14.     __u8 bNumInterfaces;
  15.     __u8 bConfigurationValue;
  16.     __u8 iConfiguration;
  17.     __u8 bmAttributes;
  18.     __u8 bMaxPower;
  19. } __attribute__ ((packed));

点击(此处)折叠或打开

  1. /* USB_DT_INTERFACE: Interface descriptor */
  2. struct usb_interface_descriptor {
  3.     __u8 bLength;
  4.     __u8 bDescriptorType;

  6.     __u8 bInterfaceNumber;
  7.     __u8 bAlternateSetting;
  8.     __u8 bNumEndpoints;
  9.     __u8 bInterfaceClass;
  10.     __u8 bInterfaceSubClass;
  11.     __u8 bInterfaceProtocol;
  12.     __u8 iInterface;
  13. } __attribute__ ((packed));

点击(此处)折叠或打开

  1. /* USB_DT_ENDPOINT: Endpoint descriptor */
  2. struct usb_endpoint_descriptor {
  3.     __u8 bLength;
  4.     __u8 bDescriptorType;

  6.     __u8 bEndpointAddress;
  7.     __u8 bmAttributes;
  8.     __le16 wMaxPacketSize;
  9.     __u8 bInterval;

  11.     /* NOTE: these two are _only_ in audio endpoints. */
  12.     /* use USB_DT_ENDPOINT*_SIZE in bLength, not sizeof. */
  13.     __u8 bRefresh;
  14.     __u8 bSynchAddress;
  15. } __attribute__ ((packed));

关于usb抓包可以看Document/usb/usbmon.txt

点击(此处)折叠或打开

  1. #include <linux/kernel.h>
  2. #include <linux/slab.h>
  3. #include <linux/input.h>
  4. #include <linux/module.h>
  5. #include <linux/init.h>
  6. #include <linux/usb.h>
  7. #include <linux/usb/input.h>
  8. #include <linux/hid.h>

  10. #define DRIVER_VERSION "v1.0"
  11. #define DRIVER_AUTHOR "hacker.do@163.com"
  12. #define DRIVER_DESC "USB Touchscreen Driver"

  14. #define CONFIG_TOUCHSCREEN_USB_IR_TOUCH

  16. #define LCD_X_SIZE 320
  17. #define LCD_Y_SIZE 480

  19. static int swap_xy;
  20. module_param(swap_xy, bool, 0644);
  21. MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped.");

  23. static int hwcalib_xy;
  24. module_param(hwcalib_xy, bool, 0644);
  25. MODULE_PARM_DESC(hwcalib_xy, "If set hw-calibrated X/Y are used if available");

  27. /* device specifc data/functions */
  28. struct usbtouch_usb;
  29. struct usbtouch_device_info {
  30.         int min_xc, max_xc;
  31.         int min_yc, max_yc;
  32.         int min_press, max_press;
  33.         int rept_size;

  35.         /*
  36.          * Always service the USB devices irq not just when the input device is
  37.          * open. This is useful when devices have a watchdog which prevents us
  38.          * from periodically polling the device. Leave this unset unless your
  39.          * touchscreen device requires it, as it does consume more of the USB
  40.          * bandwidth.
  41.          */
  42.         bool irq_always;

  44.         void (*process_pkt) (struct usbtouch_usb *usbtouch, unsigned char *pkt, int len);

  46.         /*
  47.          * used to get the packet len. possible return values:
  48.          * > 0: packet len
  49.          * = 0: skip one byte
  50.          * < 0: -return value more bytes needed
  51.          */
  52.         int (*get_pkt_len) (unsigned char *pkt, int len);

  54.         int (*read_data) (struct usbtouch_usb *usbtouch, unsigned char *pkt);
  55.         int (*alloc) (struct usbtouch_usb *usbtouch);
  56.         int (*init) (struct usbtouch_usb *usbtouch);
  57.         void (*exit) (struct usbtouch_usb *usbtouch);
  58. };

  60. /* a usbtouch device */
  61. struct usbtouch_usb {
  62.         unsigned char *data;
  63.         dma_addr_t data_dma;
  64.         unsigned char *buffer;
  65.         int buf_len;
  66.         struct urb *irq;
  67.         struct usb_interface *interface;
  68.         struct input_dev *input;
  69.         struct usbtouch_device_info *type;
  70.         char name[128];
  71.         char phys[64];
  72.         void *priv;

  74.         int x, y;
  75.         int touch, press;
  76. };


  79. /* device types */
  80. enum {
  81.         DEVTYPE_IGNORE = -1,
  82.         DEVTYPE_EGALAX,
  83.         DEVTYPE_PANJIT,
  84.         DEVTYPE_3M,
  85.         DEVTYPE_ITM,
  86.         DEVTYPE_ETURBO,
  87.         DEVTYPE_GUNZE,
  88.         DEVTYPE_DMC_TSC10,
  89.         DEVTYPE_IRTOUCH,
  90.         DEVTYPE_IDEALTEK,
  91.         DEVTYPE_GENERAL_TOUCH,
  92.         DEVTYPE_GOTOP,
  93.         DEVTYPE_JASTEC,
  94.         DEVTYPE_E2I,
  95.         DEVTYPE_ZYTRONIC,
  96.         DEVTYPE_TC45USB,
  97.         DEVTYPE_NEXIO,
  98. };


  101. static const struct usb_device_id usbtouch_devices[] = {
  102. #ifdef CONFIG_TOUCHSCREEN_USB_IR_TOUCH
  103.         {USB_DEVICE(0x10c4, 0x8002), .driver_info = DEVTYPE_IRTOUCH},
  104. #endif
  105.         {}
  106. };

  108. /*****************************************************************************
  109.  * IRTOUCH Part
  110.  */
  111. #ifdef CONFIG_TOUCHSCREEN_USB_IR_TOUCH
  112. static int irtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
  113. {
  114.         //printk("finger num is %d, P1_x : %d, P1_y : %d\n", pkt[1], pkt[3], pkt[5]);
  115.         //printk("%4d %4d %4d %4d %4d %4d %4d %4d\n", pkt[15], pkt[14], pkt[13], pkt[12], pkt[11], pkt[10], pkt[9], pkt[8]);
  116.         return 1;
  117. }
  118. #endif

  120. static struct usbtouch_device_info usbtouch_dev_info[] = {
  121. #ifdef CONFIG_TOUCHSCREEN_USB_IR_TOUCH
  122.         [DEVTYPE_IRTOUCH] = {
  123.                 .min_xc = 0x0,
  124.                 .max_xc = 0x0fff,
  125.                 .min_yc = 0x0,
  126.                 .max_yc = 0x0fff,
  127.                 .rept_size = 32,
  128.                 .read_data = irtouch_read_data,
  129.         },
  130. #endif
  131. };


  134. /*****************************************************************************
  135.  * Generic Part
  136.  */
  137. static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch,
  138.                                  unsigned char *pkt, int len)
  139. {
  140.         struct usbtouch_device_info *type = usbtouch->type;
  141.         volatile int x, y;

  143.         if (!type->read_data(usbtouch, pkt))
  144.                         return;

  146.         if (!swap_xy) {
  147.                 x = pkt[3] * LCD_X_SIZE / 26;
  148.                 y = pkt[5] * LCD_Y_SIZE / 15;
  149.         } else {
  150.                 y = pkt[3] * LCD_X_SIZE / 26;
  151.                 x = pkt[5] * LCD_Y_SIZE / 15;
  152.         }

  154.         if (pkt[1] == 1) {
  155.                 input_report_abs(usbtouch->input, ABS_MT_TOUCH_MAJOR, 1);
  156.                 input_report_abs(usbtouch->input, ABS_MT_POSITION_X, x);
  157.                 input_report_abs(usbtouch->input, ABS_MT_POSITION_Y, y);
  158.                 input_mt_sync(usbtouch->input);
  159.         } else {
  160.                 input_report_abs(usbtouch->input, ABS_MT_TOUCH_MAJOR, 0);
  161.                 input_mt_sync(usbtouch->input);
  162.         }

  164.         input_sync(usbtouch->input);
  165. }


  168. #ifdef MULTI_PACKET
  169. static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
  170.                                    unsigned char *pkt, int len)
  171. {
  172.         unsigned char *buffer;
  173.         int pkt_len, pos, buf_len, tmp;

  175.         /* process buffer */
  176.         if (unlikely(usbtouch->buf_len)) {
  177.                 /* try to get size */
  178.                 pkt_len = usbtouch->type->get_pkt_len(
  179.                                 usbtouch->buffer, usbtouch->buf_len);

  181.                 /* drop? */
  182.                 if (unlikely(!pkt_len))
  183.                         goto out_flush_buf;

  185.                 /* need to append -pkt_len bytes before able to get size */
  186.                 if (unlikely(pkt_len < 0)) {
  187.                         int append = -pkt_len;
  188.                         if (unlikely(append > len))
  189.                                append = len;
  190.                         if (usbtouch->buf_len + append >= usbtouch->type->rept_size)
  191.                                 goto out_flush_buf;
  192.                         memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, append);
  193.                         usbtouch->buf_len += append;

  195.                         pkt_len = usbtouch->type->get_pkt_len(
  196.                                         usbtouch->buffer, usbtouch->buf_len);
  197.                         if (pkt_len < 0)
  198.                                 return;
  199.                 }

  201.                 /* append */
  202.                 tmp = pkt_len - usbtouch->buf_len;
  203.                 if (usbtouch->buf_len + tmp >= usbtouch->type->rept_size)
  204.                         goto out_flush_buf;
  205.                 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, tmp);
  206.                 usbtouch_process_pkt(usbtouch, usbtouch->buffer, pkt_len);

  208.                 buffer = pkt + tmp;
  209.                 buf_len = len - tmp;
  210.         } else {
  211.                 buffer = pkt;
  212.                 buf_len = len;
  213.         }

  215.         /* loop over the received packet, process */
  216.         pos = 0;
  217.         while (pos < buf_len) {
  218.                 /* get packet len */
  219.                 pkt_len = usbtouch->type->get_pkt_len(buffer + pos,
  220.                                                         buf_len - pos);

  222.                 /* unknown packet: skip one byte */
  223.                 if (unlikely(!pkt_len)) {
  224.                         pos++;
  225.                         continue;
  226.                 }

  228.                 /* full packet: process */
  229.                 if (likely((pkt_len > 0) && (pkt_len <= buf_len - pos))) {
  230.                         usbtouch_process_pkt(usbtouch, buffer + pos, pkt_len);
  231.                 } else {
  232.                         /* incomplete packet: save in buffer */
  233.                         memcpy(usbtouch->buffer, buffer + pos, buf_len - pos);
  234.                         usbtouch->buf_len = buf_len - pos;
  235.                         return;
  236.                 }
  237.                 pos += pkt_len;
  238.         }

  240. out_flush_buf:
  241.         usbtouch->buf_len = 0;
  242.         return;
  243. }
  244. #endif


  247. static void usbtouch_irq(struct urb *urb)
  248. {
  249.         struct usbtouch_usb *usbtouch = urb->context;
  250.         int retval;

  252.         switch (urb->status) {
  253.         case 0:
  254.                 /* success */
  255.                 break;
  256.         case -ETIME:
  257.                 /* this urb is timing out */
  258.                 dbg("%s - urb timed out - was the device unplugged?",
  259.                     __func__);
  260.                 return;
  261.         case -ECONNRESET:
  262.         case -ENOENT:
  263.         case -ESHUTDOWN:
  264.         case -EPIPE:
  265.                 /* this urb is terminated, clean up */
  266.                 dbg("%s - urb shutting down with status: %d",
  267.                     __func__, urb->status);
  268.                 return;
  269.         default:
  270.                 dbg("%s - nonzero urb status received: %d",
  271.                     __func__, urb->status);
  272.                 goto exit;
  273.         }

  275.         usbtouch->type->process_pkt(usbtouch, usbtouch->data, urb->actual_length);

  277. exit:
  278.         usb_mark_last_busy(interface_to_usbdev(usbtouch->interface));
  279.         retval = usb_submit_urb(urb, GFP_ATOMIC);
  280.         if (retval)
  281.                 err("%s - usb_submit_urb failed with result: %d",
  282.                     __func__, retval);
  283. }

  285. static int usbtouch_open(struct input_dev *input)
  286. {
  287.         struct usbtouch_usb *usbtouch = input_get_drvdata(input);
  288.         int r;

  290.         usbtouch->irq->dev = interface_to_usbdev(usbtouch->interface);

  292.         r = usb_autopm_get_interface(usbtouch->interface) ? -EIO : 0;
  293.         if (r < 0)
  294.                 goto out;

  296.         if (!usbtouch->type->irq_always) {
  297.                 if (usb_submit_urb(usbtouch->irq, GFP_KERNEL)) {
  298.                         r = -EIO;
  299.                         goto out_put;
  300.                 }
  301.         }

  303.         usbtouch->interface->needs_remote_wakeup = 1;
  304. out_put:
  305.         usb_autopm_put_interface(usbtouch->interface);
  306. out:
  307.         return r;
  308. }

  310. static void usbtouch_close(struct input_dev *input)
  311. {
  312.         struct usbtouch_usb *usbtouch = input_get_drvdata(input);
  313.         int r;

  315.         if (!usbtouch->type->irq_always)
  316.                 usb_kill_urb(usbtouch->irq);
  317.         r = usb_autopm_get_interface(usbtouch->interface);
  318.         usbtouch->interface->needs_remote_wakeup = 0;
  319.         if (!r)
  320.                 usb_autopm_put_interface(usbtouch->interface);
  321. }

  323. static int usbtouch_suspend
  324. (struct usb_interface *intf, pm_message_t message)
  325. {
  326.         struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);

  328.         usb_kill_urb(usbtouch->irq);

  330.         return 0;
  331. }

  333. static int usbtouch_resume(struct usb_interface *intf)
  334. {
  335.         struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
  336.         struct input_dev *input = usbtouch->input;
  337.         int result = 0;

  339.         mutex_lock(&input->mutex);
  340.         if (input->users || usbtouch->type->irq_always)
  341.                 result = usb_submit_urb(usbtouch->irq, GFP_NOIO);
  342.         mutex_unlock(&input->mutex);

  344.         return result;
  345. }

  347. static int usbtouch_reset_resume(struct usb_interface *intf)
  348. {
  349.         struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
  350.         struct input_dev *input = usbtouch->input;
  351.         int err = 0;

  353.         /* reinit the device */
  354.         if (usbtouch->type->init) {
  355.                 err = usbtouch->type->init(usbtouch);
  356.                 if (err) {
  357.                         dbg("%s - type->init() failed, err: %d",
  358.                             __func__, err);
  359.                         return err;
  360.                 }
  361.         }

  363.         /* restart IO if needed */
  364.         mutex_lock(&input->mutex);
  365.         if (input->users)
  366.                 err = usb_submit_urb(usbtouch->irq, GFP_NOIO);
  367.         mutex_unlock(&input->mutex);

  369.         return err;
  370. }

  372. static void usbtouch_free_buffers(struct usb_device *udev,
  373.                                   struct usbtouch_usb *usbtouch)
  374. {
  375.         usb_free_coherent(udev, usbtouch->type->rept_size,
  376.                           usbtouch->data, usbtouch->data_dma);
  377.         kfree(usbtouch->buffer);
  378. }

  380. static struct usb_endpoint_descriptor *
  381. usbtouch_get_input_endpoint(struct usb_host_interface *interface)
  382. {
  383.         int i;

  385.         for (i = 0; i < interface->desc.bNumEndpoints; i++)
  386.                 if (usb_endpoint_dir_in(&interface->endpoint[i].desc))
  387.                         return &interface->endpoint[i].desc;

  389.         return NULL;
  390. }

  392. static int usbtouch_probe(struct usb_interface *intf,
  393.                           const struct usb_device_id *id)
  394. {
  395.         struct usbtouch_usb *usbtouch;
  396.         struct input_dev *input_dev;
  397.         struct usb_endpoint_descriptor *endpoint;
  398.         struct usb_device *udev = interface_to_usbdev(intf);
  399.         struct usbtouch_device_info *type;
  400.         int err = -ENOMEM;

  402.         /* some devices are ignored */
  403.         if (id->driver_info == DEVTYPE_IGNORE)
  404.                 return -ENODEV;

  406.         endpoint = usbtouch_get_input_endpoint(intf->cur_altsetting);
  407.         if (!endpoint)
  408.                 return -ENXIO;

  410.         usbtouch = kzalloc(sizeof(struct usbtouch_usb), GFP_KERNEL);
  411.         input_dev = input_allocate_device();
  412.         if (!usbtouch || !input_dev)
  413.                 goto out_free;

  415.         type = &usbtouch_dev_info[id->driver_info];
  416.         usbtouch->type = type;
  417.         if (!type->process_pkt)
  418.                 type->process_pkt = usbtouch_process_pkt;

  420.         usbtouch->data = usb_alloc_coherent(udev, type->rept_size,
  421.                                             GFP_KERNEL, &usbtouch->data_dma);
  422.         if (!usbtouch->data)
  423.                 goto out_free;

  425.         if (type->get_pkt_len) {
  426.                 usbtouch->buffer = kmalloc(type->rept_size, GFP_KERNEL);
  427.                 if (!usbtouch->buffer)
  428.                         goto out_free_buffers;
  429.         }

  431.         usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL);
  432.         if (!usbtouch->irq) {
  433.                 dbg("%s - usb_alloc_urb failed: usbtouch->irq", __func__);
  434.                 goto out_free_buffers;
  435.         }

  437.         usbtouch->interface = intf;
  438.         usbtouch->input = input_dev;

  440.         if (udev->manufacturer)
  441.                 strlcpy(usbtouch->name, udev->manufacturer, sizeof(usbtouch->name));

  443.         if (udev->product) {
  444.                 if (udev->manufacturer)
  445.                         strlcat(usbtouch->name, " ", sizeof(usbtouch->name));
  446.                 strlcat(usbtouch->name, udev->product, sizeof(usbtouch->name));
  447.         }

  449.         if (!strlen(usbtouch->name))
  450.                 snprintf(usbtouch->name, sizeof(usbtouch->name),
  451.                         "USB Touchscreen %04x:%04x",
  452.                          le16_to_cpu(udev->descriptor.idVendor),
  453.                          le16_to_cpu(udev->descriptor.idProduct));

  455.         usb_make_path(udev, usbtouch->phys, sizeof(usbtouch->phys));
  456.         strlcat(usbtouch->phys, "/input0", sizeof(usbtouch->phys));

  458.         input_dev->name = usbtouch->name;
  459.         input_dev->phys = usbtouch->phys;
  460.         usb_to_input_id(udev, &input_dev->id);
  461.         input_dev->dev.parent = &intf->dev;

  463.         input_set_drvdata(input_dev, usbtouch);

  465.         input_dev->open = usbtouch_open;
  466.         input_dev->close = usbtouch_close;

  468.         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
  469.         input_set_abs_params(input_dev, ABS_MT_POSITION_X, type->min_xc, type->max_xc, 0, 0);
  470.         input_set_abs_params(input_dev, ABS_MT_POSITION_Y, type->min_yc, type->max_yc, 0, 0);
  471.         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 1, 0, 0);

  473.         if (usb_endpoint_type(endpoint) == USB_ENDPOINT_XFER_INT)
  474.                 usb_fill_int_urb(usbtouch->irq, udev,
  475.                          usb_rcvintpipe(udev, endpoint->bEndpointAddress),
  476.                          usbtouch->data, type->rept_size,
  477.                          usbtouch_irq, usbtouch, endpoint->bInterval);
  478.         else
  479.                 usb_fill_bulk_urb(usbtouch->irq, udev,
  480.                          usb_rcvbulkpipe(udev, endpoint->bEndpointAddress),
  481.                          usbtouch->data, type->rept_size,
  482.                          usbtouch_irq, usbtouch);

  484.         usbtouch->irq->dev = udev;
  485.         usbtouch->irq->transfer_dma = usbtouch->data_dma;
  486.         usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

  488.         /* device specific allocations */
  489.         if (type->alloc) {
  490.                 err = type->alloc(usbtouch);
  491.                 if (err) {
  492.                         dbg("%s - type->alloc() failed, err: %d", __func__, err);
  493.                         goto out_free_urb;
  494.                 }
  495.         }

  497.         /* device specific initialisation*/
  498.         if (type->init) {
  499.                 err = type->init(usbtouch);
  500.                 if (err) {
  501.                         dbg("%s - type->init() failed, err: %d", __func__, err);
  502.                         goto out_do_exit;
  503.                 }
  504.         }

  506.         err = input_register_device(usbtouch->input);
  507.         if (err) {
  508.                 dbg("%s - input_register_device failed, err: %d", __func__, err);
  509.                 goto out_do_exit;
  510.         }

  512.         usb_set_intfdata(intf, usbtouch);

  514.         if (usbtouch->type->irq_always) {
  515.                 /* this can't fail */
  516.                 usb_autopm_get_interface(intf);
  517.                 err = usb_submit_urb(usbtouch->irq, GFP_KERNEL);
  518.                 if (err) {
  519.                         usb_autopm_put_interface(intf);
  520.                         err("%s - usb_submit_urb failed with result: %d",
  521.                             __func__, err);
  522.                         goto out_unregister_input;
  523.                 }
  524.         }

  526.         return 0;

  528. out_unregister_input:
  529.         input_unregister_device(input_dev);
  530.         input_dev = NULL;
  531. out_do_exit:
  532.         if (type->exit)
  533.                 type->exit(usbtouch);
  534. out_free_urb:
  535.         usb_free_urb(usbtouch->irq);
  536. out_free_buffers:
  537.         usbtouch_free_buffers(udev, usbtouch);
  538. out_free:
  539.         input_free_device(input_dev);
  540.         kfree(usbtouch);
  541.         return err;
  542. }

  544. static void usbtouch_disconnect(struct usb_interface *intf)
  545. {
  546.         struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);

  548.         dbg("%s - called", __func__);

  550.         if (!usbtouch)
  551.                 return;

  553.         dbg("%s - usbtouch is initialized, cleaning up", __func__);
  554.         usb_set_intfdata(intf, NULL);
  555.         /* this will stop IO via close */
  556.         input_unregister_device(usbtouch->input);
  557.         usb_free_urb(usbtouch->irq);
  558.         if (usbtouch->type->exit)
  559.                 usbtouch->type->exit(usbtouch);
  560.         usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch);
  561.         kfree(usbtouch);
  562. }

  564. MODULE_DEVICE_TABLE(usb, usbtouch_devices);

  566. static struct usb_driver usbtouch_driver = {
  567.         .name = "usbtouchscreen",
  568.         .probe = usbtouch_probe,
  569.         .disconnect = usbtouch_disconnect,
  570.         .suspend = usbtouch_suspend,
  571.         .resume = usbtouch_resume,
  572.         .reset_resume = usbtouch_reset_resume,
  573.         .id_table = usbtouch_devices,
  574.         .supports_autosuspend = 1,
  575. };

  577. static int __init usbtouch_init(void)
  578. {
  579.         return usb_register(&usbtouch_driver);
  580. }

  582. static void __exit usbtouch_cleanup(void)
  583. {
  584.         usb_deregister(&usbtouch_driver);
  585. }

  587. module_init(usbtouch_init);
  588. module_exit(usbtouch_cleanup);

  590. MODULE_AUTHOR(DRIVER_AUTHOR);
  591. MODULE_DESCRIPTION(DRIVER_DESC);
  592. MODULE_LICENSE("GPL");

  594. MODULE_ALIAS("touchkitusb");
  595. MODULE_ALIAS("itmtouch");
  596. MODULE_ALIAS("mtouchusb");

阅读(1172) | 评论(0) | 转发(0) |
0

上一篇：MMU简介[转帖]

下一篇：Ubuntu 12.10设置ramdisk

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6