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

转自：http://blog.chinaunix.net/uid-23046336-id-3243543.html

 

看了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用来接受数据。