Chinaunix首页 | 论坛 | 博客
  • 博客访问: 660913
  • 博文数量: 90
  • 博客积分: 1201
  • 博客等级: 少尉
  • 技术积分: 2048
  • 用 户 组: 普通用户
  • 注册时间: 2010-07-09 14:28
文章分类

全部博文(90)

文章存档

2013年(10)

2012年(80)

分类:

2012-06-14 17:39:07

看了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需要初始化四个东西:模块的名字skeletonprobe函数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 IDproduct 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入口中的内容与插入的设备是否匹配,来决定是否处理设备上的特定接口。
probeusb子系统自动调用的一个函数,有USB设备接到硬件集线器时,usb子系统会根据production IDvendor ID的组合或者设备的classsubclassprotocol的组合来识别设备调用相应驱动程序的probe(探测)函数,对于skeleton来说,就是skel_probe。系统会传递给探测函数一个usb_interface *跟一个struct usb_device_id *作为参数。他们分别是该USB设备的接口描述(一般会是该设备的第0号接口,该接口的默认设置也是第0号设置)跟它的设备ID描述(包括Vendor IDProduction 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_endpointAddrbulk_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_readskel_writeskel_openskel_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(交还次设备号)和interfacedata:
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.     
  21.     /* increment our usage count for the device */
  22.     kref_get(&dev->kref); //对usb_skel模块的使用计数

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

  25. exit:
  26.     return retval;
  27. }
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规范细节的介绍,我们就说过USBendpoint4种不同类型,也就是说能在这条高速公路上流动的数据就有四种。但是这对汽车是没有要求的,所以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是它的长度,completeurb完成回调函数的入口,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_ATOMICGFP_NOIOGFP_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.     
  7.     /* do a blocking bulk read to get data from the device */
  8.     retval = usb_bulk_msg(dev->udev,
  9.              usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
  10.              dev->bulk_in_buffer,
  11.              min(dev->bulk_in_size, count),
  12.              &count, HZ*10);

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

  20.     return retval;
  21. }

这个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用来接受数据。
 
阅读(1470) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~