Linux USB驱动框架分析（2）【转】

2022-10-17 11:57:19

 
看了http://blog.chinaunix.net/uid-11848011-id-96188.html的驱动框架分析，感觉受益匪浅。对于一些内容，我自己查漏补缺。
首先我们按照顺序，看内核模块的注册以及释放函数如下：

点击(此处)折叠或打开

  1. static int __init usb_skel_init(void)
  2. {
  3. int result;
  4. /* register this driver with the USB subsystem */
  5. result = usb_register(&skel_driver);
  6. if (result)
  7. err("usb_register failed. Error number %d", result);
  8. return result;
  9. }
  10. static void __exit usb_skel_exit(void)
  11. {
  12. /* deregister this driver with the USB subsystem */
  13. usb_deregister(&skel_driver);
  14. }
  15. module_init (usb_skel_init);
  16. module_exit (usb_skel_exit);
  17. MODULE_LICENSE("GPL");

这个注册与销毁使用了usb_register(struct *usb_driver)以及usb_deregister(struct *usb_driver);那这个结构体需要做些什么呢？他要向系统提供几个函数入口，跟驱动的名字：

 

点击(此处)折叠或打开

  1. static struct usb_driver skel_driver = {
  2. .owner = THIS_MODULE,
  3. .name = "skeleton",
  4. .id_table = skel_table,
  5. .probe = skel_probe,
  6. .disconnect = skel_disconnect,
  7. };
从代码看来，usb_driver需要初始化四个东西：模块的名字skeleton，probe函数kel_probe, disconnect函数skel_disconnect,以及id_table。对于id_table，有如下函数入口：

点击(此处)折叠或打开

  1. /* Define these values to match your devices */
  2. #define USB_SKEL_VENDOR_ID    0xfff0
  3. #define USB_SKEL_PRODUCT_ID    0xfff0
  4. /* table of devices that work with this driver */
  5. static struct usb_device_id skel_table [] = {
  6. { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
  7. { }                    /* Terminating entry */
  8. };
  9. MODULE_DEVICE_TABLE (usb, skel_table);
打个比方就是我们要出去走亲戚，肯定知道是去看哪个亲戚，当然我们也肯定知道去他家的路怎么走，而这个函数，就是在我们插入usb设备时，usb子系统就会检查设备的vendor ID和product ID，如果它们的值是0xfff0时，那么子系统就会调用这个skeleton模块作为设备的驱动。
于是，就开始调用prode函数，做一些int (*probe) (struct usb_interface *intf,const struct usb_device_id *id);函数作用如下：
Called to see if the driver is willing to manage a particular interface on a device.  If it is, probe returns zero and uses * usb_set_intfdata() to associate driver-specific data with the * interface.  It may also use usb_set_interface() to specify the appropriate altsetting.  If unwilling to manage the interface,return  -ENODEV, if genuine IO errors occured, an appropriate negative errno value.
就是根据id_table入口中的内容与插入的设备是否匹配，来决定是否处理设备上的特定接口。
probe是usb子系统自动调用的一个函数，有USB设备接到硬件集线器时，usb子系统会根据production ID和vendor ID的组合或者设备的class、subclass跟protocol的组合来识别设备调用相应驱动程序的probe（探测）函数，对于skeleton来说，就是skel_probe。系统会传递给探测函数一个usb_interface *跟一个struct usb_device_id *作为参数。他们分别是该USB设备的接口描述（一般会是该设备的第0号接口，该接口的默认设置也是第0号设置）跟它的设备ID描述（包括Vendor ID、Production ID等）。
 
(2)我们来看prode函数：

点击(此处)折叠或打开

  1. static int skel_probe(struct usb_interface *interface, const struct usb_device_id *id)
  2. {
  3. struct usb_skel *dev = NULL;
  4. struct usb_host_interface *iface_desc;
  5. struct usb_endpoint_descriptor *endpoint;
  6. size_t buffer_size;
  7. int i;
  8. int retval = -ENOMEM;
  9. /* allocate memory for our device state and initialize it */
  10. dev = kmalloc(sizeof(struct usb_skel), GFP_KERNEL);
  11. if (dev == NULL) {
  12. err("Out of memory");
  13. goto error;
  14. }
  15. memset(dev, 0x00, sizeof (*dev));
  16. kref_init(&dev->kref);
  17. dev->udev = usb_get_dev(interface_to_usbdev(interface));
  18. dev->interface = interface;
  19. /* set up the endpoint information */
  20. /* use only the first bulk-in and bulk-out endpoints */
  21. iface_desc = interface->cur_altsetting;
  22. for (i = 0; i < iface_desc->desc.bNumEndpoints; i) {
  23. endpoint = &iface_desc->endpoint[i].desc;
  24. if (!dev->bulk_in_endpointAddr &&
  25. (endpoint->bEndpointAddress & USB_DIR_IN) &&
  26. ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
  27. == USB_ENDPOINT_XFER_BULK)) {
  28. /* we found a bulk in endpoint */
  29. buffer_size = endpoint->wMaxPacketSize;
  30. dev->bulk_in_size = buffer_size;
  31. dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
  32. dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
  33. if (!dev->bulk_in_buffer) {
  34. err("Could not allocate bulk_in_buffer");
  35. goto error;
  36. }
  37. }
  38. if (!dev->bulk_out_endpointAddr &&
  39. !(endpoint->bEndpointAddress & USB_DIR_IN) &&
  40. ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
  41. == USB_ENDPOINT_XFER_BULK)) {
  42. /* we found a bulk out endpoint */
  43. dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
  44. }
  45. }
  46. if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
  47. err("Could not find both bulk-in and bulk-out endpoints");
  48. goto error;
  49. }
  50. /* save our data pointer in this interface device */
  51. usb_set_intfdata(interface, dev);
  52. /* we can register the device now, as it is ready */
  53. retval = usb_register_dev(interface, &skel_class);
  54. if (retval) {
  55. /* something prevented us from registering this driver */
  56. err("Not able to get a minor for this device.");
  57. usb_set_intfdata(interface, NULL);
  58. goto error;
  59. }
  60. /* let the user know what node this device is now attached to */
  61. info("USB Skeleton device now attached to USBSkel-%d", interface->minor);
  62. return 0;
  63. error:
  64. if (dev)
  65. kref_put(&dev->kref, skel_delete);
  66. return retval;
  67. }
2-9：对函数的变量定义以及初始化。
10-16：对设备的申请内存处理。
首先我们看下skeleton函数的自定义结构体：

点击(此处)折叠或打开

  1. /* Structure to hold all of our device specific stuff */
  2. struct usb_skel {
  3. struct usb_device *    udev;            /* the usb device for this device */
  4. struct usb_interface *    interface;        /* the interface for this device */
  5. unsigned char *        bulk_in_buffer;        /* the buffer to receive data */
  6. size_t            bulk_in_size;        /* the size of the receive buffer */
  7. __u8            bulk_in_endpointAddr;    /* the address of the bulk in endpoint */
  8. __u8            bulk_out_endpointAddr;    /* the address of the bulk out endpoint */
  9. struct kref        kref;
  10. };
我们先来对这个usb_skel作个简单分析，他拥有一个描述usb设备的结构体udev，一个接口interface，用于并发访问控制的semaphore(信号量) limit_sem，用于接收数据的缓冲bulk_in_buffer及其尺寸bulk_in_size，然后是批量输入输出端口地址bulk_in_endpointAddr、bulk_out_endpointAddr，最后是一个内核使用的引用计数器kref。这个引用计数在我们的prode函数中正好被设置，
17:kref_init(&dev->kref);
19:dev->udev = usb_get_dev(interface_to_usbdev(interface));
20:dev->interface = interface;
在17行，我们对usb_skel中的kref结构体进行初始化，设置这个引用计数器的值，这个值用来说明对模块的引用次数，初始化函数如下：
 

点击(此处)折叠或打开

  1. /***
  2. * kref_init - initialize object.
  3. * @kref: object in question.
  4. */
  5. void kref_init(struct kref *kref)
  6. {
  7. atomic_set(&kref->refcount,1);
  8. smp_mb();
  9. }
这个函数不仅用来初始化kref，而且用原子的方式设置refcount的值为1。所以在出错处理代码中有kref_put，它把kref的计数减1，如果kref计数已经为0，那么kref会被释放，kref的释放会在下面分析。
在初始化了一些资源之后，可以看到第一个关键的函数调用——interface_to_usbdev。他同uo一个usb_interface来得到该接口所在设备的设备描述结构。本来，要得到一个usb_device只要用interface_to_usbdev就够了，但因为要增加对该usb_device的引用计数，我们应该在做一个usb_get_dev的操作，来增加引用计数，并在释放设备时用usb_put_dev来减少引用计数。
其中对interface_to_usbdev(interface)函数的定义如下：
 

点击(此处)折叠或打开

  1. #define    interface_to_usbdev(intf) \
  2. container_of(intf->dev.parent, struct usb_device, dev)
这个函数是通过将usb接口的引用计数，通过container函数，指向usb_devices结构。对于container_of函数，参见http://blog.csdn.net/yinkaizhong/article/details/4093795
21-55：对我们自定义的usb_skel各个状态跟资源作初始化。这部分工作的任务主要是向usb_skel注册该usb设备的端点。这里可能要补充以下一些关于usb_interface_descriptor的知识，但因为内核源码对该结构体的注释不多，所以只能靠个人猜测。在一个usb_host_interface结构里面有一个usb_interface_descriptor叫做desc的成员，他应该是用于描述该interface的一些属性，其中bNumEndpoints是一个8位（b for byte）的数字，他代表了该接口的端点数。probe然后遍历所有的端点，检查他们的类型跟方向，注册到usb_skel中。 
56-58：向系统注册一些以后会用的的信息。首先我们来说明一下usb_set_intfdata()，他向内核注册一个data，这个data的结构可以是任意的，这段程序向内核注册了一个usb_skel结构。就是我们刚刚看到的被初始化的那个。之所以要把他注册，是因为我们定义的usb_skel结构不是全局变量，其他的函数需要使用的时候，可以后用usb_get_intfdata来得到。我们可以再内核源码中找到对它的定义：（/linux/usb.h）
 

点击(此处)折叠或打开

  1. static inline void usb_set_intfdata(struct usb_interface *intf, void *data)
  2. {
  3. dev_set_drvdata(&intf->dev, data);
  4. }
这个内联函数又调用了dev_set_drvdata(&intf->dev, data)
我们接着找这个函数的定义：()

点击(此处)折叠或打开

  1. static inline unsigned int dev_set_drvdata(struct device *dev, void *data)
  2. {
  3. dev->driver_data = data;;
  4. }

这下我们就明白，我们是把dev的设备信息保存到了interface->dev->driver_data中。在以后使用的时候，只需要调用usb_get_intfdata就可以得到dev的信息。

59-67：我们向这个interface注册一个skel_class结构。这个结构又是什么？我们就来看看这到底是个什么东西：
 

点击(此处)折叠或打开

  1. static struct usb_class_driver skel_class = {
  2. .name = "usb/skel%d",
  3. .fops = &skel_fops,
  4. .mode = S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH,
  5. .minor_base = USB_SKEL_MINOR_BASE,
  6. };
它其实是一个系统定义的结构，里面包含了一名字、一个文件操作结构体还有一个次设备号的基准值。事实上它才是定义 真正完成对设备IO操作的函数。所以他的核心内容应该是skel_fops。其原形如下：
 

点击(此处)折叠或打开

  1. static struct file_operations skel_fops = {
  2. .owner =    THIS_MODULE,
  3. .read =        skel_read,
  4. .write =    skel_write,
  5. .open =        skel_open,
  6. .release =    skel_release,
  7. };
这是我们比较常见的file_operations函数。 这个文件操作结构中定义了对设备的读写、打开、释放（USB设备通常使用这个术语release）。他们都是函数指针，分别指向skel_read、skel_write、skel_open、skel_release这四个函数，这四个函数应该有开发人员自己实现。
prode函数最后部分是对错误的相关处理。此时我们看到了：
kref_put(&dev->kref, skel_delete);它把kref的计数减1，如果kref计数已经为0，那么kref会被释放。kref_put的第二个参数是一个函数指针，指向一个清理函数。注意，该指针不能为空，或者kfree。该函数会在最后一个对kref的引用释放时被调用（如果我的理解不准确，请指正）。下面是内核源码中的一段注释及代码：

点击(此处)折叠或打开

  1. /**
  2. * kref_put - decrement refcount for object.
  3. * @kref: object.
  4. * @release: pointer to the function that will clean up the object when the
  5. * last reference to the object is released.
  6. * This pointer is required, and it is not acceptable to pass kfree
  7. * in as this function.
  8. *
  9. * Decrement the refcount, and if 0, call release().
  10. * Return 1 if the object was removed, otherwise return 0. Beware, if this
  11. * function returns 0, you still can not count on the kref from remaining in
  12. * memory. Only use the return value if you want to see if the kref is now
  13. * gone, not present.
  14. */
  15. int kref_put(struct kref *kref, void (*release)(struct kref *kref))
  16. {
  17. WARN_ON(release == NULL);
  18. WARN_ON(release == (void (*)(struct kref *))kfree);
  19. /*
  20. * if current count is one, we are the last user and can release object
  21. * right now, avoiding an atomic operation on 'refcount'
  22. */
  23. if ((atomic_read(&kref->refcount) == 1) ||
  24. (atomic_dec_and_test(&kref->refcount))) {
  25. release(kref);
  26. return 1;
  27. }
  28. return 0;
  29. }

当我们执行打开操作时，我们要增加kref的计数，我们可以用kref_get，来完成。所有对struct kref的操作都有内核代码确保其原子性。

（2）我们继续来看skel_disconnect函数：

点击(此处)折叠或打开

  1. static void skel_disconnect(struct usb_interface *interface)
  2. {
  3. struct usb_skel *dev;
  4. int minor = interface->minor;
  5. /* prevent skel_open() from racing skel_disconnect() */
  6. lock_kernel();
  7. dev = usb_get_intfdata(interface);
  8. usb_set_intfdata(interface, NULL);
  9. /* give back our minor */
  10. usb_deregister_dev(interface, &skel_class);
  11. unlock_kernel();
  12. /* decrement our usage count */
  13. kref_put(&dev->kref, skel_delete);
  14. info("USB Skeleton #%d now disconnected", minor);
  15. }

当设备被拔出集线器时，usb子系统会自动地调用disconnect，他做的事情不多，最重要的是注销class_driver（交还次设备号）和interface的data:

dev = usb_get_intfdata(interface);
usb_set_intfdata(interface, NULL);
/* give back our minor */
usb_deregister_dev(interface, &skel_class);
    然后他会用kref_put(&dev->kref, skel_delete)进行清理，kref_put的细节参见前文。
    到目前为止，我们已经分析完usb子系统要求的各个主要操作，下一部分我们在讨论一下对USB设备的IO操作。
接下来我们进行IO操作的分析。
（1）open函数：

点击(此处)折叠或打开

  1. static int skel_open(struct inode *inode, struct file *file)
  2. {
  3. struct usb_skel *dev;
  4. struct usb_interface *interface;
  5. int subminor;
  6. int retval = 0;
  7. subminor = iminor(inode); //获取设备的次设备号
  8. interface = usb_find_interface(&skel_driver, subminor);
  9. if (!interface) {
  10. err ("%s - error, can't find device for minor %d",
  11. __FUNCTION__, subminor);
  12. retval = -ENODEV;
  13. goto exit;
  14. }
  15. dev = usb_get_intfdata(interface); //获取注册到接口的usb——skel数据。
  16. if (!dev) {
  17. retval = -ENODEV;
  18. goto exit;
  19. }
  20. /* increment our usage count for the device */
  21. kref_get(&dev->kref); //对usb_skel模块的使用计数
  22. /* save our object in the file's private structure */
  23. file->private_data = dev; //保存usb_skel结构的数据以便read，write函数使用
  24. exit:
  25. return retval;
  26. }

open函数很简单。主要是递增usb_skel的kref，并把该结构体存入file的private_data中，以便其他函数（如read、write）调用。

在open函数中有个函数：
     interface = usb_find_interface(&skel_driver, subminor);
我们在/linux/usb.c中找到它的定义，在/driver/usb/core/usb.c中找到对它的源码：

点击(此处)折叠或打开

  1. /**
  2. * usb_find_interface - find usb_interface pointer for driver and device
  3. * @drv: the driver whose current configuration is considered
  4. * @minor: the minor number of the desired device
  5. *
  6. * This walks the bus device list and returns a pointer to the interface
  7. * with the matching minor and driver. Note, this only works for devices
  8. * that share the USB major number.
  9. */
  10. struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor)
  11. {
  12. struct find_interface_arg argb;
  13. struct device *dev;
  14. argb.minor = minor;
  15. argb.drv = &drv->drvwrap.driver;
  16. dev = bus_find_device(&usb_bus_type, NULL, &argb, __find_interface);
  17. /* Drop reference count from bus_find_device */
  18. put_device(dev);
  19. return dev ? to_usb_interface(dev) : NULL;
  20. }
  21. EXPORT_SYMBOL_GPL(usb_find_interface);

由于在open函数中，无法得到在prode函数中注册的设备的详细信息，而我们只能得到注册到接口的次设备号（通过subminor = iminor(inode);）以及我们注册的驱动skel_driver。

通过这个函数，遍历总线设备列表，查找和我们的驱动与次设备号匹配的interface指针。
我们定义了find_interface_arg的结构argb,这个结构如下：
 

点击(此处)折叠或打开

  1. struct find_interface_arg {
  2. int minor;
  3. struct device_driver *drv;
  4. };
我们把传入参数的相关内容传递整合到这个结构体中，如15,16所示。18行就是通过迭代查找设备，寻找我们需要的那个接口设备。
（2）release函数
 

点击(此处)折叠或打开

  1. static int skel_release(struct inode *inode, struct file *file)
  2. {
  3. struct usb_skel *dev;
  4. dev = (struct usb_skel *)file->private_data;
  5. if (dev == NULL)
  6. return -ENODEV;
  7. /* decrement the count on our device */
  8. kref_put(&dev->kref, skel_delete);
  9. return 0;
  10. }
release函数做一些清理工作，主要是把对设备的引用计数减1，如果等于零的话，调用skel_delete函数。

点击(此处)折叠或打开

  1. #define to_skel_dev(d) container_of(d, struct usb_skel, kref)
  2. static struct usb_driver skel_driver;
  3. static void skel_delete(struct kref *kref)
  4. {
  5. struct usb_skel *dev = to_skel_dev(kref);
  6. usb_put_dev(dev->udev);
  7. kfree (dev->bulk_in_buffer);
  8. kfree (dev);
  9. }

5-12行，当引用计数的值（kref->recount）为0值，就会调用这个skel_delete函数，做相应的清理工作。

（3）write函数
 
说到usb子系统的IO操作，不得不说usb request block，简称urb。事实上，可以打一个这样的比喻，usb总线就像一条高速公路，货物、人流之类的可以看成是系统与设备交互的数据，而urb就可以看成是汽车。在一开始对USB规范细节的介绍，我们就说过USB的endpoint有4种不同类型，也就是说能在这条高速公路上流动的数据就有四种。但是这对汽车是没有要求的，所以urb可以运载四种数据，不过你要先告诉司机你要运什么，目的地是什么。我们现在就看看struct urb的具体内容。它的内容很多，为了不让我的理解误导各位，大家最好还是看一看内核源码的注释，具体内容参见源码树下include/linux/usb.h。
    在这里我们重点介绍程序中出现的几个关键字段：
struct usb_device  *dev
    urb所发送的目标设备。
unsigned int pipe
    一个管道号码，该管道记录了目标设备的端点以及管道的类型。每个管道只有一种类型和一个方向，它与他的目标设备的端点相对应，我们可以通过以下几个函数来获得管道号并设置管道类型：
     unsigned int usb_sndctrlpipe(struct usb_device *dev, unsigned int endpoint)
           把指定USB设备的指定端点设置为一个控制OUT端点。
     unsigned int usb_rcvctrlpipe(struct usb_device *dev, unsigned int endpoint)
           把指定USB设备的指定端点设置为一个控制IN端点。
     unsigned int usb_sndbulkpipe(struct usb_device *dev, unsigned int endpoint)
           把指定USB设备的指定端点设置为一个批量OUT端点。
     unsigned int usb_rcvbulkpipe(struct usb_device *dev, unsigned int endpoint)
           把指定USB设备的指定端点设置为一个批量OUT端点。
     unsigned int usb_sndintpipe(struct usb_device *dev, unsigned int endpoint)
           把指定USB设备的指定端点设置为一个中断OUT端点。
     unsigned int usb_rcvintpipe(struct usb_device *dev, unsigned int endpoint)
           把指定USB设备的指定端点设置为一个中断OUT端点。
     unsigned int usb_sndisocpipe(struct usb_device *dev, unsigned int endpoint)
           把指定USB设备的指定端点设置为一个等时OUT端点。
     unsigned int usb_rcvisocpipe(struct usb_device *dev, unsigned int endpoint)
           把指定USB设备的指定端点设置为一个等时OUT端点。
unsigned int transfer_flags
    当不使用DMA时，应该transfer_flags |= URB_NO_TRANSFER_DMA_MAP（按照代码的理解，希望没有错）。
int status
    当一个urb把数据送到设备时，这个urb会由系统返回给驱动程序，并调用驱动程序的urb完成回调函数处理。这时，status记录了这次数据传输的有关状态，例如传送成功与否。成功的话会是0。
    要能够运货当然首先要有车，所以第一步当然要创建urb：
    struct urb *usb_alloc_urb(int isoc_packets, int mem_flags);
    第一个参数是等时包的数量，如果不是乘载等时包，应该为0，第二个参数与kmalloc的标志相同。
    要释放一个urb可以用：
    void usb_free_urb(struct urb *urb);
    要承载数据，还要告诉司机目的地信息跟要运的货物，对于不同的数据，系统提供了不同的函数，对于中断urb，我们用
    void usb_fill_int_urb(struct urb *urb, struct usb_device *dev, unsigned int pipe,
                   void *transfer_buffer, int buffer_length,
                   usb_complete_t complete, void *context, int interval);
    这里要解释一下，transfer_buffer是一个要送/收的数据的缓冲，buffer_length是它的长度，complete是urb完成回调函数的入口，context由用户定义，可能会在回调函数中使用的数据，interval就是urb被调度的间隔。
    对于批量urb和控制urb，我们用:
    void usb_fill_bulk_urb(struct urb *urb, struct usb_device *dev, unsigned int pipe,
                                    void *transfer_buffer, int buffer_length, usb_complete_t complete,
                                    void *context);
    void usb_fill_bulk_urb(struct urb *urb, struct usb_device *dev, unsigned int pipe,
                                    unsigned char* setup_packet,void *transfer_buffer,
                     int buffer_length, usb_complete_t complete,void *context);
    控制包有一个特殊参数setup_packet，它指向即将被发送到端点的设置数据报的数据。
    对于等时urb，系统没有专门的fill函数，只能对各urb字段显示赋值。
    有了汽车，有了司机，下一步就是要开始运货了，我们可以用下面的函数来提交urb
    int usb_submit_urb(struct urb *urb, int mem_flags);
    mem_flags有几种：GFP_ATOMIC、GFP_NOIO、GFP_KERNEL，通常在中断上下文环境我们会用GFP_ATOMIC。
    当我们的卡车运货之后，系统会把它调回来，并调用urb完成回调函数，并把这辆车作为函数传递给驱动程序。我们应该在回调函数里面检查status字段，以确定数据的成功传输与否。下面是用urb来传送数据的细节。
/* initialize the urb properly */
usb_fill_bulk_urb(urb, dev->udev,
                     usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
                     buf, writesize, skel_write_bulk_callback, dev);
urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
/* send the data out the bulk port */
retval = usb_submit_urb(urb, GFP_KERNEL);
    这里skel_write_bulk_callback就是一个完成回调函数，而他做的主要事情就是检查数据传输状态和释放urb：
dev = (struct usb_skel *)urb->context;
/* sync/async unlink faults aren't errors */
if (urb->status && !(urb->status = = -ENOENT || urb->status == -ECONNRESET || urb->status = = -ESHUTDOWN)) {
         dbg("%s - nonzero write bulk status received: %d", __FUNCTION__, urb->status);
}
/* free up our allocated buffer */
usb_buffer_free(urb->dev, urb->transfer_buffer_length,
              urb->transfer_buffer, urb->transfer_dma);
（4）read函数

点击(此处)折叠或打开

  1. static ssize_t skel_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
  2. {
  3. struct usb_skel *dev;
  4. int retval = 0;
  5. dev = (struct usb_skel *)file->private_data; //获取设备的信息
  6. /* do a blocking bulk read to get data from the device */
  7. retval = usb_bulk_msg(dev->udev,
  8. usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
  9. dev->bulk_in_buffer,
  10. min(dev->bulk_in_size, count),
  11. &count, HZ*10);
  12. /* if the read was successful, copy the data to userspace */
  13. if (!retval) {
  14. if (copy_to_user(buffer, dev->bulk_in_buffer, count))
  15. retval = -EFAULT;
  16. else
  17. retval = count;
  18. }
  19. return retval;
  20. }

这个read函数，就是获取设备的信息（6行）以及读设备的信息，传送到用户空间（copy_to_user成功返回0，失败返回没有成功拷贝的字节数）。

值得我们看是8-13行。

/* do a blocking bulk read to get data from the device */
 retval = usb_bulk_msg(dev->udev,  //需要发送的设备
         usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr), //设置端点的信息
         dev->bulk_in_buffer,      //缓存的位置
         min(dev->bulk_in_size, count), //缓存的大小
         &count, HZ*10);   //实际传送数据的大小，以及阻塞超时时间

程序使用了usb_bulk_msg来传送数据，它的原型如下：

    int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,void *data,
                 int len, int *actual length, int timeout)
这个函数会阻塞等待数据传输完成或者等到超时，data是输入/输出缓冲，len是它的大小，actual length是实际传送的数据大小，timeout是阻塞超时。如果成功返回0，失败返回一个负的错误值
介绍下usb_rcvbulkpipe这个函数：
　　该函数建立一个“receive、bulk类型”的pipe。
　　pipe是一个32位的值，记录了如下内容：
　　bit31～30，表示类型，bulk、interrupt、control或isochronous
　　bit23～16，记录usb_device-> devnum，它表示USB总线上的地址。
　　bit15～8，表示目标（要发送给谁）的endpoint地址
　　bit7～0，表示方向，USB_DIR_IN或USB_DIR_OUT
　　这里要说明一下IN和OUT：
　　在USB中，一切都是以Host为中心的，所以，在Host一方，IN是用来收数据的，而在Device一方正好相反，它的IN endpoint是用来发送数据的，OUT endpoint用来接受数据。
上一篇：KiB 、十进制单位转换 、二进制单位转换


下一篇：关于mybatis中一级缓存和二级缓存的简单介绍