Chinaunix首页 | 论坛 | 博客

学而不思则罔，思而不学则贻shawn.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

myfaxmail

  • 博客访问： 1490614
  • 博文数量： 267
  • 博客积分： 3010
  • 博客等级： 少校
  • 技术积分： 3089
  • 用 户 组： 普通用户
  • 注册时间： 2011-06-05 17:09
个人简介

尊天命，尽人事

文章分类

全部博文（267）

文章存档

2017年（6）

2015年（4）

2014年（27）

2013年（52）

2012年（59）

2011年（120）

我的朋友
最近访客
推荐博文
相关博文
Linux USB驱动框架分析（2）

分类： LINUX

2013-03-26 20:05:17

原文地址：Linux USB驱动框架分析（2） 作者：huhuwang724116

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

点击(此处)折叠或打开

  1. static int __init usb_skel_init(void)
  2. {
  3.     int result;

  5.     /* register this driver with the USB subsystem */
  6.     result = usb_register(&skel_driver);
  7.     if (result)
  8.         err("usb_register failed. Error number %d", result);

  10.     return result;
  11. }

  13. static void __exit usb_skel_exit(void)
  14. {
  15.     /* deregister this driver with the USB subsystem */
  16.     usb_deregister(&skel_driver);
  17. }

  19. module_init (usb_skel_init);
  20. module_exit (usb_skel_exit);

  22. 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

  5. /* table of devices that work with this driver */
  6. static struct usb_device_id skel_table [] = {
  7.     { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
  8.     { }                    /* Terminating entry */
  9. };
  10. 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;

  10.     /* allocate memory for our device state and initialize it */
  11.     dev = kmalloc(sizeof(struct usb_skel), GFP_KERNEL);
  12.     if (dev == NULL) {
  13.         err("Out of memory");
  14.         goto error;
  15.     }
  16.     memset(dev, 0x00, sizeof (*dev));
  17.     kref_init(&dev->kref);

  19.     dev->udev = usb_get_dev(interface_to_usbdev(interface));
  20.     dev->interface = interface;

  22.     /* set up the endpoint information */
  23.     /* use only the first bulk-in and bulk-out endpoints */
  24.     iface_desc = interface->cur_altsetting;
  25.     for (i = 0; i < iface_desc->desc.bNumEndpoints; i) {
  26.         endpoint = &iface_desc->endpoint[i].desc;

  28.         if (!dev->bulk_in_endpointAddr &&
  29.          (endpoint->bEndpointAddress & USB_DIR_IN) &&
  30.          ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
  31.                     == USB_ENDPOINT_XFER_BULK)) {
  32.             /* we found a bulk in endpoint */
  33.             buffer_size = endpoint->wMaxPacketSize;
  34.             dev->bulk_in_size = buffer_size;
  35.             dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
  36.             dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
  37.             if (!dev->bulk_in_buffer) {
  38.                 err("Could not allocate bulk_in_buffer");
  39.                 goto error;
  40.             }
  41.         }

  43.         if (!dev->bulk_out_endpointAddr &&
  44.          !(endpoint->bEndpointAddress & USB_DIR_IN) &&
  45.          ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
  46.                     == USB_ENDPOINT_XFER_BULK)) {
  47.             /* we found a bulk out endpoint */
  48.             dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
  49.         }
  50.     }
  51.     if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
  52.         err("Could not find both bulk-in and bulk-out endpoints");
  53.         goto error;
  54.     }

  56.     /* save our data pointer in this interface device */
  57.     usb_set_intfdata(interface, dev);

  59.     /* we can register the device now, as it is ready */
  60.     retval = usb_register_dev(interface, &skel_class);
  61.     if (retval) {
  62.         /* something prevented us from registering this driver */
  63.         err("Not able to get a minor for this device.");
  64.         usb_set_intfdata(interface, NULL);
  65.         goto error;
  66.     }

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

  72. error:
  73.     if (dev)
  74.         kref_put(&dev->kref, skel_delete);
  75.     return retval;
  76. }
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.   */

  6.  void kref_init(struct kref *kref)
  7.  {
  8.    atomic_set(&kref->refcount,1);
  9.    smp_mb();
  10. }
这个函数不仅用来初始化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;

  6.     /* prevent skel_open() from racing skel_disconnect() */
  7.     lock_kernel();

  9.     dev = usb_get_intfdata(interface);
  10.     usb_set_intfdata(interface, NULL);

  12.     /* give back our minor */
  13.     usb_deregister_dev(interface, &skel_class);

  15.     unlock_kernel();

  17.     /* decrement our usage count */
  18.     kref_put(&dev->kref, skel_delete);

  20.     info("USB Skeleton #%d now disconnected", minor);
  21. }
    当设备被拔出集线器时，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;

  8.     subminor = iminor(inode); //获取设备的次设备号

  10.     interface = usb_find_interface(&skel_driver, subminor);
  11.     if (!interface) {
  12.         err ("%s - error, can't find device for minor %d",
  13.          __FUNCTION__, subminor);
  14.         retval = -ENODEV;
  15.         goto exit;
  16.     }

  18.     dev = usb_get_intfdata(interface); //获取注册到接口的usb——skel数据。
  19.     if (!dev) {
  20.         retval = -ENODEV;
  21.         goto exit;
  22.     }
  23.     
  24.     /* increment our usage count for the device */
  25.     kref_get(&dev->kref); //对usb_skel模块的使用计数

  27.     /* save our object in the file's private structure */
  28.     file->private_data = dev; //保存usb_skel结构的数据以便read，write函数使用

  30. exit:
  31.     return retval;
  32. }
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;

  15.     argb.minor = minor;
  16.     argb.drv = &drv->drvwrap.driver;

  18.     dev = bus_find_device(&usb_bus_type, NULL, &argb, __find_interface);

  20.     /* Drop reference count from bus_find_device */
  21.     put_device(dev);

  23.     return dev ? to_usb_interface(dev) : NULL;
  24. }
  25. 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;

  5.     dev = (struct usb_skel *)file->private_data;
  6.     if (dev == NULL)
  7.         return -ENODEV;

  9.     /* decrement the count on our device */
  10.     kref_put(&dev->kref, skel_delete);
  11.     return 0;
  12. }
release函数做一些清理工作，主要是把对设备的引用计数减1，如果等于零的话，调用skel_delete函数。

点击(此处)折叠或打开

  1. #define to_skel_dev(d) container_of(d, struct usb_skel, kref)
  3. static struct usb_driver skel_driver;
  5. static void skel_delete(struct kref *kref)
  6. {
  7. struct usb_skel *dev = to_skel_dev(kref);
  9. usb_put_dev(dev->udev);
  10. kfree (dev->bulk_in_buffer);
  11. kfree (dev);
  12. }
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;

  6.     dev = (struct usb_skel *)file->private_data; //获取设备的信息
  7.     
  8.     /* do a blocking bulk read to get data from the device */
  9.     retval = usb_bulk_msg(dev->udev,
  10.              usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
  11.              dev->bulk_in_buffer,
  12.              min(dev->bulk_in_size, count),
  13.              &count, HZ*10);

  15.     /* if the read was successful, copy the data to userspace */
  16.     if (!retval) {
  17.         if (copy_to_user(buffer, dev->bulk_in_buffer, count))    
  18.             retval = -EFAULT;
  19.         else
  20.             retval = count;
  21.     }

  23.     return retval;
  24. }

这个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用来接受数据。
 
阅读(580) | 评论(0) | 转发(0) |
0

上一篇：SD/MMC 中的scatterlist

下一篇：Linux设备驱动程序学习（19）－USB 驱动程序（四）

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

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

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

16024965号-6