Chinaunix首页 | 论坛 | 博客

CUfans-lelee's-linux-lvlj

首页　| 　博文目录　| 　关于我

lelee007

  • 博客访问： 260850
  • 博文数量： 49
  • 博客积分： 1684
  • 博客等级： 上尉
  • 技术积分： 458
  • 用 户 组： 普通用户
  • 注册时间： 2009-03-09 22:45
文章分类

全部博文（49）

文章存档

2023年（1）

2021年（2）

2018年（2）

2017年（7）

2016年（2）

2015年（6）

2014年（13）

2013年（7）

2012年（7）

2011年（1）

2010年（1）

我的朋友
最近访客
推荐博文
相关博文
以前写的一个小USB的调试代码

分类： LINUX

2014-09-06 16:29:37

主要作用是何2410上的usb device对接，然后往2410上读写数据的

这个是PC上linux下的驱动代码：

点击(此处)折叠或打开

  1. /*
  2.  * USB led driver - 0.1
  3.  *
  4.  * Copyright (C) 2001-2004 Alex Woo (lelee1949@163.com)
  5.  *
  6.  *    This program is free software; you can redistribute it and/or
  7.  *    modify it under the terms of the GNU General Public License as
  8.  *    published by the Free Software Foundation, version 0.1.
  9.  *
  10.  * This driver is based on the 2.6.3 version of drivers/usb/usb-usbdeton.c
  11.  * just be written to light the led to test the firmware of
  12.  * s3c2410 usb device controller.
  13.  *
  14.  */

  16. #include <linux/kernel.h>
  17. #include <linux/errno.h>
  18. #include <linux/init.h>
  19. #include <linux/slab.h>
  20. #include <linux/module.h>
  21. #include <linux/kref.h>
  22. #include <asm/uaccess.h>
  23. #include <linux/usb.h>
  24. #include <linux/mutex.h>

  26. #include <linux/types.h>
  27. #include <linux/miscdevice.h>
  28. #include <linux/ioport.h>
  29. #include <linux/fcntl.h>
  30. #include <asm/io.h>
  31. //#include <mach/regs-gpio.h>
  32. #include <linux/device.h> /* creat_class() */
  33. #include <linux/cdev.h>
  34. //#include <mach/regs-gpio.h>




  39. /* Define these values to match your devices */
  40. #define USBD_2410_VENDOR_ID    0x5345
  41. #define USBD_2410_PRODUCT_ID    0x1234

  43. /* table of devices that work with this driver */
  44. static struct usb_device_id usbd_2410_table [] = {
  45.     { USB_DEVICE(USBD_2410_VENDOR_ID, USBD_2410_PRODUCT_ID) },
  46.     { }                    /* Terminating entry */
  47. };
  48. MODULE_DEVICE_TABLE(usb, usbd_2410_table);


  51. /* Get a minor range for your devices from the usb maintainer */
  52. //#define USB_SKEL_MINOR_BASE    192
  53. //#define USBD2410_MAJOR 0//不使用USB的主设备号，申请动态分配一个主设备号，字符设备
  54. #define    usbd2410_major 0
  55. int        usbd2410_devno;
  56. /* our private defines. if this grows any larger, use your own .h file */
  57. #define MAX_TRANSFER        (PAGE_SIZE - 512)
  58. /* MAX_TRANSFER is chosen so that the VM is not stressed by
  59.    allocations > PAGE_SIZE and the number of packets in a page
  60.    is an integer 512 is the largest possible packet on EHCI */
  61. #define WRITES_IN_FLIGHT    8
  62. /* arbitrarily chosen */

  64. struct class *usbled_class;

  66. /* Structure to hold all of our device specific stuff */
  67. struct usbd_2410 {
  68.     struct usb_device    *udev;            /* the usb device for this device */
  69.                         //看看程序中udev都用来作什么用，
  70.                         //如果是一个普通的USB接口的字符设备，usb_device有木有必要！！！
  71.     struct usb_interface    *interface;        /* the interface for this device */
  72.     struct semaphore    limit_sem;        /* limiting the number of writes in progress */
  73.     struct usb_anchor    submitted;        /* in case we need to retract our submissions */
  74.     unsigned char *bulk_in_buffer;    /* the buffer to receive data */
  75.     size_t            bulk_in_size;        /* the size of the receive buffer */
  76.     __u8            bulk_in_endpointAddr;    /* the address of the bulk in endpoint */
  77.     __u8            bulk_out_endpointAddr;    /* the address of the bulk out endpoint */
  78.     int            errors;            /* the last request tanked */
  79.     int            open_count;        /* count the number of openers */
  80.     spinlock_t        err_lock;        /* lock for errors */
  81.     struct kref        kref;
  82.     struct mutex        io_mutex;        /* synchronize I/O with disconnect */

  84.     //added by lelee for led
  85.     struct cdev led_dev;
  86.     unsigned int led_value;
  87. };
  88. #define to_usbd_dev(d) container_of(d, struct usbd_2410, kref)

  90. static struct usb_driver usbd_driver;
  91. static void usbd_draw_down(struct usbd_2410 *dev);

  93. static void usbd_delete(struct kref *kref)
  94. {
  95.     struct usbd_2410 *dev = to_usbd_dev(kref);

  97.     usb_put_dev(dev->udev);
  98.     kfree(dev->bulk_in_buffer);
  99.     kfree(dev);
  100. }

  102. static int usbd_open(struct inode *inode, struct file *file)
  103. {
  104.     struct usbd_2410 *dev;
  105.     struct usb_interface *interface;
  106.     int subminor;
  107.     int retval = 0;

  109.     subminor = iminor(inode);

  111.     interface = usb_find_interface(&usbd_driver, subminor);
  112.     if (!interface) {
  113.         err ("%s - error, can't find device for minor %d",
  114.          __func__, subminor);
  115.         retval = -ENODEV;
  116.         goto exit;
  117.     }

  119.     dev = usb_get_intfdata(interface);
  120.     if (!dev) {
  121.         retval = -ENODEV;
  122.         goto exit;
  123.     }

  125.     /* increment our usage count for the device */
  126.     kref_get(&dev->kref);

  128.     /* lock the device to allow correctly handling errors
  129.      * in resumption */
  130.     mutex_lock(&dev->io_mutex);

  132.     if (!dev->open_count++) {
  133.         retval = usb_autopm_get_interface(interface);
  134.             if (retval) {
  135.                 dev->open_count--;
  136.                 mutex_unlock(&dev->io_mutex);
  137.                 kref_put(&dev->kref, usbd_delete);
  138.                 goto exit;
  139.             }
  140.     } /* else { //uncomment this block if you want exclusive open
  141.         retval = -EBUSY;
  142.         dev->open_count--;
  143.         mutex_unlock(&dev->io_mutex);
  144.         kref_put(&dev->kref, usbd_delete);
  145.         goto exit;
  146.     } */
  147.     /* prevent the device from being autosuspended */

  149.     /* save our object in the file's private structure */
  150.     file->private_data = dev;
  151.     mutex_unlock(&dev->io_mutex);

  153. exit:
  154.     return retval;
  155. }

  157. static int usbd_release(struct inode *inode, struct file *file)
  158. {
  159.     struct usbd_2410 *dev;

  161.     dev = (struct usbd_2410 *)file->private_data;
  162.     if (dev == NULL)
  163.         return -ENODEV;

  165.     /* allow the device to be autosuspended */
  166.     mutex_lock(&dev->io_mutex);
  167.     if (!--dev->open_count && dev->interface)
  168.         usb_autopm_put_interface(dev->interface);
  169.     mutex_unlock(&dev->io_mutex);

  171.     /* decrement the count on our device */
  172.     kref_put(&dev->kref, usbd_delete);
  173.     return 0;
  174. }

  176. static int usbd_flush(struct file *file, fl_owner_t id)
  177. {
  178.     struct usbd_2410 *dev;
  179.     int res;

  181.     dev = (struct usbd_2410 *)file->private_data;
  182.     if (dev == NULL)
  183.         return -ENODEV;

  185.     /* wait for io to stop */
  186.     mutex_lock(&dev->io_mutex);
  187.     usbd_draw_down(dev);

  189.     /* read out errors, leave subsequent opens a clean slate */
  190.     spin_lock_irq(&dev->err_lock);
  191.     res = dev->errors ? (dev->errors == -EPIPE ? -EPIPE : -EIO) : 0;
  192.     dev->errors = 0;
  193.     spin_unlock_irq(&dev->err_lock);

  195.     mutex_unlock(&dev->io_mutex);

  197.     return res;
  198. }

  200. static ssize_t usbd_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
  201. {
  202.     struct usbd_2410 *dev;
  203.     int retval;
  204.     int bytes_read;

  206.     dev = (struct usbd_2410 *)file->private_data;

  208.     mutex_lock(&dev->io_mutex);
  209.     if (!dev->interface) {        /* disconnect() was called */
  210.         retval = -ENODEV;
  211.         goto exit;
  212.     }

  214.     /* do a blocking bulk read to get data from the device */
  215.     retval = usb_bulk_msg(dev->udev,
  216.              usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
  217.              dev->bulk_in_buffer,
  218.              min(dev->bulk_in_size, count),
  219.              &bytes_read, 10000);

  221.     /* if the read was successful, copy the data to userspace */
  222.     if (!retval) {
  223.         if (copy_to_user(buffer, dev->bulk_in_buffer, bytes_read))
  224.             retval = -EFAULT;
  225.         else
  226.             retval = bytes_read;
  227.     }

  229. exit:
  230.     mutex_unlock(&dev->io_mutex);
  231.     return retval;
  232. }

  234. static void usbd_write_bulk_callback(struct urb *urb)
  235. {
  236.     struct usbd_2410 *dev;

  238.     dev = urb->context;

  240.     /* sync/async unlink faults aren't errors */
  241.     if (urb->status) {
  242.         if(!(urb->status == -ENOENT ||
  243.          urb->status == -ECONNRESET ||
  244.          urb->status == -ESHUTDOWN))
  245.             err("%s - nonzero write bulk status received: %d",
  246.              __func__, urb->status);

  248.         spin_lock(&dev->err_lock);
  249.         dev->errors = urb->status;
  250.         spin_unlock(&dev->err_lock);
  251.     }

  253.     /* free up our allocated buffer */
  254.     usb_buffer_free(urb->dev, urb->transfer_buffer_length,
  255.             urb->transfer_buffer, urb->transfer_dma);
  256.     up(&dev->limit_sem);
  257. }

  259. static ssize_t usbd_write(struct file *file, const char *user_buffer, size_t count, loff_t *ppos)
  260. {
  261.     struct usbd_2410 *dev;
  262.     int retval = 0;
  263.     struct urb *urb = NULL;
  264.     char *buf = NULL;
  265.     size_t writesize = min(count, (size_t)MAX_TRANSFER);
  266.     printk(KERN_ALERT"the num of bytes to usbd_write is:%u\n", count);
  267.     printk(KERN_ALERT"the num of bytes been sent to usbd2410 is:%u\n", writesize);


  270.     dev = (struct usbd_2410 *)file->private_data;

  272.     /* verify that we actually have some data to write */
  273.     if (count == 0)
  274.         goto exit;

  276.     /* limit the number of URBs in flight to stop a user from using up all RAM */
  277.     if (down_interruptible(&dev->limit_sem)) {
  278.         retval = -ERESTARTSYS;
  279.         goto exit;
  280.     }

  282.     spin_lock_irq(&dev->err_lock);
  283.     if ((retval = dev->errors) < 0) {
  284.         /* any error is reported once */
  285.         dev->errors = 0;
  286.         /* to preserve notifications about reset */
  287.         retval = (retval == -EPIPE) ? retval : -EIO;
  288.     }
  289.     spin_unlock_irq(&dev->err_lock);
  290.     if (retval < 0)
  291.         goto error;

  293.     /* create a urb, and a buffer for it, and copy the data to the urb */
  294.     urb = usb_alloc_urb(0, GFP_KERNEL);
  295.     if (!urb) {
  296.         retval = -ENOMEM;
  297.         goto error;
  298.     }

  300.     buf = usb_buffer_alloc(dev->udev, writesize, GFP_KERNEL, &urb->transfer_dma);
  301.     if (!buf) {
  302.         retval = -ENOMEM;
  303.         goto error;
  304.     }

  306.     if (copy_from_user(buf, user_buffer, writesize)) {
  307.         retval = -EFAULT;
  308.         goto error;
  309.     }
  310.     //
  311.     printk(KERN_ALERT"The user_buffer's data is %u,%u,%u\n", user_buffer[0],user_buffer[1],user_buffer[2]);
  312.     printk(KERN_ALERT"The kernel_buff's data is %u,%u,%u\n", buf[0],buf[1],buf[2]);


  315.     /* this lock makes sure we don't submit URBs to gone devices */
  316.     mutex_lock(&dev->io_mutex);
  317.     if (!dev->interface) {        /* disconnect() was called */
  318.         mutex_unlock(&dev->io_mutex);
  319.         retval = -ENODEV;
  320.         goto error;
  321.     }

  323.     /* initialize the urb properly */
  324.     usb_fill_bulk_urb(urb, dev->udev,
  325.              usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
  326.              buf, writesize, usbd_write_bulk_callback, dev);
  327.     urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  328.     usb_anchor_urb(urb, &dev->submitted);

  330.     printk(KERN_ALERT"----------after fill urb----------\n" );

  332.     printk(KERN_ALERT"The user_buffer's data is %u,%u,%u", user_buffer[0],user_buffer[1],user_buffer[2]);
  333.     printk(KERN_ALERT"The kernel_buff's data is %u,%u,%u", buf[0],buf[1],buf[2]);



  337.     /* send the data out the bulk port */
  338.     retval = usb_submit_urb(urb, GFP_KERNEL);


  341.     printk(KERN_ALERT"=================after submit the urb===============\n");

  343.     printk(KERN_ALERT"The user_buffer's data is %u,%u,%u\n", user_buffer[0],user_buffer[1],user_buffer[2]);
  344.     printk(KERN_ALERT"The kernel_buff's data is %u,%u,%u\n", buf[0],buf[1],buf[2]);



  348.     mutex_unlock(&dev->io_mutex);
  349.     if (retval) {
  350.         err("%s - failed submitting write urb, error %d", __func__, retval);
  351.         goto error_unanchor;
  352.     }

  354.     /* release our reference to this urb, the USB core will eventually free it entirely */
  355.     usb_free_urb(urb);


  358.     return writesize;

  360. error_unanchor:
  361.     usb_unanchor_urb(urb);
  362. error:
  363.     if (urb) {
  364.         usb_buffer_free(dev->udev, writesize, buf, urb->transfer_dma);
  365.         usb_free_urb(urb);
  366.     }
  367.     up(&dev->limit_sem);

  369. exit:
  370.     return retval;
  371. }

  373. static const struct file_operations usbd_fops = {
  374.     .owner =    THIS_MODULE,
  375.     .read =        usbd_read,
  376.     .write =    usbd_write,
  377.     .open =        usbd_open,
  378.     .release =    usbd_release,
  379.     .flush =    usbd_flush,
  380. };

  382. /*
  383.  * usb class driver info in order to get a minor number from the usb core,
  384.  * and to have the device registered with the driver core
  385.  */
  386. /*
  387. static struct usb_class_driver usbd_class = {
  388.     .name =        "usbd%d",
  389.     .fops =        &usbd_fops,
  390.     .minor_base =    USB_SKEL_MINOR_BASE,//lelee
  391. };
  392. */


  395. static int usbd_probe(struct usb_interface *interface, const struct usb_device_id *id)
  396. {
  397.     struct usbd_2410 *dev;
  398.     struct usb_host_interface *iface_desc;
  399.     struct usb_endpoint_descriptor *endpoint;
  400.     size_t buffer_size;
  401.     int i;
  402.     int retval = -ENOMEM;

  404.     /* allocate memory for our device state and initialize it */
  405.     dev = kzalloc(sizeof(*dev), GFP_KERNEL);
  406.     if (!dev) {
  407.         err("Out of memory");
  408.         goto error;
  409.     }
  410.     kref_init(&dev->kref);
  411.     sema_init(&dev->limit_sem, WRITES_IN_FLIGHT);
  412.     mutex_init(&dev->io_mutex);
  413.     spin_lock_init(&dev->err_lock);
  414.     init_usb_anchor(&dev->submitted);

  416.     dev->udev = usb_get_dev(interface_to_usbdev(interface));//usb_get_dev()就是为了看看usb_device->dev(device结构)是否为空
  417.     dev->interface = interface;

  419.     /* set up the endpoint information */
  420.     /* use only the first bulk-in and bulk-out endpoints */
  421.     iface_desc = interface->cur_altsetting;
  422.     for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
  423.         endpoint = &iface_desc->endpoint[i].desc;

  425.         if (!dev->bulk_in_endpointAddr &&
  426.          usb_endpoint_is_bulk_in(endpoint)) {
  427.             /* we found a bulk in endpoint */
  428.             buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
  429.             dev->bulk_in_size = buffer_size;
  430.             dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
  431.             dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
  432.             if (!dev->bulk_in_buffer) {
  433.                 err("Could not allocate bulk_in_buffer");
  434.                 goto error;
  435.             }
  436.         }

  438.         if (!dev->bulk_out_endpointAddr &&
  439.          usb_endpoint_is_bulk_out(endpoint)) {
  440.             /* we found a bulk out endpoint */
  441.             dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
  442.         }
  443.     }
  444.     if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
  445.         err("Could not find both bulk-in and bulk-out endpoints");
  446.         goto error;
  447.     }

  449.     /* save our data pointer in this interface device */
  450.     usb_set_intfdata(interface, dev);
  451. //看看usb_serial的设备注册里边，需不需要设置接口！！！lelee001

  453.     
  454.     /*
  455.      * we can register the device now, as it is ready /
  456.     retval = usb_register_dev(interface, &usbd_class);
  457.     //设备注册，此处需要改成字符设备的注册，调用cdev_add！！！lelee002
  458.     if (retval) {
  459.         // something prevented us from registering this driver
  460.         err("Not able to get a minor for this device.");
  461.         usb_set_intfdata(interface, NULL);
  462.         goto error;
  463.     }
  464.     */
  465.     //led作为字符设备的注册
  466.     //led作为字符设备的注册
  467.     //led作为字符设备的注册
  468.     //led作为字符设备的注册
  469.     //led作为字符设备的注册
  470.     //led作为字符设备的注册
  471.     //led作为字符设备的注册
  472.     //led作为字符设备的注册
  473.     //led作为字符设备的注册
  474.     //led作为字符设备的注册
  475.     int usbd_major;
  476.     dev_t devnumb = MKDEV(usbd2410_major, 0);

  478.     if(usbd2410_major)
  479.         retval = register_chrdev_region(devnumb, 1, "USB-LED");
  480.     else
  481.     {
  482.         retval = alloc_chrdev_region(&devnumb, 0, 1, "USB-LED");
  483.         usbd_major = MAJOR(devnumb);
  484.         usbd2410_devno = MKDEV(usbd_major,0);//生成设备号，以备驱动模块退出注销时使用
  485.     }
  486.     if(retval<0)
  487.         goto err_devno;

  489.     memset(&dev->led_dev, 0, sizeof(struct cdev));//将dev结构（struct usbd_2410）中的struct cdev led_dev区域清零
  490.     cdev_init(&dev->led_dev, &usbd_fops);
  491.     dev->led_dev.owner = THIS_MODULE;
  492.     dev->led_dev.ops = &usbd_fops;

  494.     retval = cdev_add(&dev->led_dev, usbd2410_devno, 1);
  495.     if(retval)
  496.         printk(KERN_NOTICE"Error %d adding LED %d ", retval, 0);

  498.     usbled_class = class_create(THIS_MODULE, "USB-LED");
  499.     if(IS_ERR(usbled_class))
  500.     {
  501.         printk(KERN_NOTICE"failed to create usbled_class!!!-lelee");
  502.         return -1;//fuck the mumu!!!直接返回吧，分配的内存什么的，不用去管了，反正那又没出错
  503.     }

  505.     device_create(usbled_class, NULL, devnumb, NULL, "USB-LED");

  507.     //led作为字符设备的注册
  508.     //led作为字符设备的注册
  509.     //led作为字符设备的注册
  510.     //led作为字符设备的注册
  511.     //led作为字符设备的注册
  512.     //led作为字符设备的注册
  513.     //led作为字符设备的注册
  514.     //led作为字符设备的注册
  515.     //led作为字符设备的注册
  516.     //led作为字符设备的注册

  518.     /* let the user know what node this device is now attached to */
  519.     info("USB Skeleton device now attached to USBSkel-%d", interface->minor);
  520.     return 0;

  522. //////////////////////////////////////////////////////////////////////////////////////
  523. err_devno:
  524.     kref_put(&dev->kref, usbd_delete);
  525.     return retval;//返回错误号

  527. error:
  528.     if (dev)
  529.         /* this frees allocated memory */
  530.         kref_put(&dev->kref, usbd_delete);
  531.     return retval;
  532. //////////////////////////////////////////////////////////////////////////////////////
  533. }

  535. static void usbd_disconnect(struct usb_interface *interface)
  536. {
  537.     struct usbd_2410 *dev;
  538.     int minor = interface->minor;

  540.     dev = usb_get_intfdata(interface);//在此之前，应该是已经将open里边打开的那个usbd_2410类型的dev结构赋给interface->dev->driver_data了，然后可以由此再获得他，所以后面的注销完全可以由该dev来获取已注册的cdev类型的led_dev结构
  541.     usb_set_intfdata(interface, NULL);

  543.     /* give back our minor */
  544.     //usb_deregister_dev(interface, &usbd_class);
  545.     //注销我们的字符设备，应用程序里边根据设备文件是否存在来判断USB是否已经插入
  546.     cdev_del(&dev->led_dev);//此处的dev是打开函数中赋予private的那个dev么？如果不是，应该其中不包含led_dev
  547.     unregister_chrdev_region(MKDEV(usbd2410_major, 0), 1);
  548.     device_destroy(usbled_class, usbd2410_devno);
  549.     class_destroy(usbled_class);
  550.     //注销完毕，每次USB设备拔出以后，驱动就将已注册的字符设备也注销；
  551.     //当系统检测到USB设备插入或者再次插入的时候，再重新注册一次字符设备
  552.     //－－－－－＋＋＋＋－－－－－＋＋＋＋－－－－－
  553.     //OK啦，至此，USB接口的字符型设备的驱动完美啦
  554.     //－－－－－＋＋＋＋－－－－－＋＋＋＋－－－－－



  558.     /* prevent more I/O from starting */
  559.     mutex_lock(&dev->io_mutex);
  560.     dev->interface = NULL;
  561.     mutex_unlock(&dev->io_mutex);

  563.     usb_kill_anchored_urbs(&dev->submitted);

  565.     /* decrement our usage count */
  566.     kref_put(&dev->kref, usbd_delete);

  568.     info("USB Skeleton #%d now disconnected", minor);
  569. }

  571. static void usbd_draw_down(struct usbd_2410 *dev)
  572. {
  573.     int time;

  575.     time = usb_wait_anchor_empty_timeout(&dev->submitted, 1000);
  576.     if (!time)
  577.         usb_kill_anchored_urbs(&dev->submitted);
  578. }

  580. static int usbd_suspend(struct usb_interface *intf, pm_message_t message)
  581. {
  582.     struct usbd_2410 *dev = usb_get_intfdata(intf);

  584.     if (!dev)
  585.         return 0;
  586.     usbd_draw_down(dev);
  587.     return 0;
  588. }

  590. static int usbd_resume (struct usb_interface *intf)
  591. {
  592.     return 0;
  593. }

  595. static int usbd_pre_reset(struct usb_interface *intf)
  596. {
  597.     struct usbd_2410 *dev = usb_get_intfdata(intf);

  599.     mutex_lock(&dev->io_mutex);
  600.     usbd_draw_down(dev);

  602.     return 0;
  603. }

  605. static int usbd_post_reset(struct usb_interface *intf)
  606. {
  607.     struct usbd_2410 *dev = usb_get_intfdata(intf);

  609.     /* we are sure no URBs are active - no locking needed */
  610.     dev->errors = -EPIPE;
  611.     mutex_unlock(&dev->io_mutex);

  613.     return 0;
  614. }

  616. static struct usb_driver usbd_driver = {
  617.     .name =        "usbd_2410",
  618.     .probe =    usbd_probe,
  619.     .disconnect =    usbd_disconnect,
  620.     .suspend =    usbd_suspend,
  621.     .resume =    usbd_resume,
  622.     .pre_reset =    usbd_pre_reset,
  623.     .post_reset =    usbd_post_reset,
  624.     .id_table =    usbd_2410_table,
  625.     .supports_autosuspend = 1,
  626. };

  628. static int __init usbd_2410_init(void)
  629. {
  630.     int result;

  632.     /* register this driver with the USB subsystem */
  633.     result = usb_register(&usbd_driver);
  634.     if (result)
  635.         err("usb_register failed. Error number %d", result);

  637.     return result;
  638. }

  640. static void __exit usbd_2410_exit(void)
  641. {
  642.     /* deregister this driver with the USB subsystem */
  643.     usb_deregister(&usbd_driver);
  644. }

  646. module_init(usbd_2410_init);
  647. module_exit(usbd_2410_exit);

  649. MODULE_LICENSE("GPL");
这个当时是练手USB驱动做的，记得当时有一个《linux那些事之我是USB》的读书活动，刚好那阵子在研究USB，当时已经把USB协议基本研究透了，刚好又赶上那个读书活动，于是申请了书，回来一通饱读，然后就跃跃欲试要搞linux驱动，然后发现那本书还真的是挺有用。于是很快程序就基本调通了，后来发现居然能当一个很顺手的小工具，每次需要验证什么东东，在PC上通过USB发数据到2410上，然后2410上加载哥命令解析的操作，然后就可以控制2410干各种想干的事情了。主要是因为当时2410裸奔的一些程序没做好，后来想想，其实完全可以通过串口发同样的命令，哈哈

2410上的固件代码当时记得是移植的三爽的代码，然后做了一些修改

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

上一篇：复习一下驱动开发中所要使用到的一些东西

下一篇：u_boot移植(九)之引导Linux 内核

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

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

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

16024965号-6