usb驅動程式分析

usb驅動是linux核心中比較複雜的驅動之一，是以，大多數usb教程建議從usb-skeleton開始學習usb驅動。個人認為這是相當正确的，usb-sekelton提供了一個usb驅動開發的模闆，而且代碼量較少，很适合初學者的學習。

    記住，對于c語言的程式設計說，資料結構是整個程式的靈魂。是以，分析别人編寫的代碼的簡潔的入口點就是高清代碼中主要資料結構之間的關系。分析以usb-skeleton為例的完整的usb驅動架構，我們就從主要的幾個資料結構入手。   一、usb驅動架構的主要資料結構 usb驅動架構主要包括裝置，配置，接口和端點幾個組成部分，相對應的資料結構為：

1. struct usb_device;               //usb裝置
2. struct usb_host_config;           //usb配置
3. struct usb_host_interface;       //usb接口
4. struct usb_host_endpoit;          //usb端口

它們之間的關系可以形象的表示為圖1。

上圖描述的usb各組成部分的關系可以描述為：

（1）一個usb裝置可以有多個usb配置，多個配置之間可以互相切換，某個時刻隻能對應一個配置；

（2）一個usb配置可以有多個usb接口，一個usb接口代表了一個基本功能，對以一個usb用戶端驅動程式；

（3）一個usb接口可以有多個usb端點；

就像我們平時程式設計經常使用的方法一樣，一個對象由一個結構體來表示，但還會再用來一個結構體來描述這個對象的一些屬性。usb驅動架構也采用了這樣的設計思想，usb架構中每一個組成部分都用兩個結構體來描述：一個結構體表示成員組成，另一個結構體表示屬性組成。Linux-USB核心定義了4個usb描述符。

1. struct usb_device_descriptor;<-->struct usb_device;
2. struct usb_host_config;<-->struct usb_config_descriptor;
3. struct usb_host_interface;<-->struct usb_interface_descriptor;
4. struct usb_host_endpoint;<-->struct usb_endpoint_descriptor;

另外，還有一個比較特殊的資料結構是URB(USB Request Block),被USB協定棧使用，是USB資料傳輸機制的核心資料結構，具體的URB的類型，URB的使用步驟等讀者可以參考《Linux裝置驅動程式》一書，本文不做詳細介紹。

二、USB裝置的枚舉過程

    USB裝置是一種典型的熱插拔裝置，與PCI裝置類似，當總線檢測到有裝置插入的時候，總線驅動程式就會去周遊總線上已經挂載的所有的裝置驅動程式，檢視有沒有驅動程式與剛插入的裝置比對，如果比對成功，則去執行驅動程式中的probe函數。這是Linux核心中經典的驅動和裝置挂鈎的方式之一。

三、分析代碼的執行過程

    要了解代碼的含義，最關鍵的是理清代碼的執行路徑，即代碼中函數的調用關系。光靠source insight或eclipse代碼分析工具有時候略顯不夠，對于那些沒有直接調用關系的函數這些靜态代碼分析工具愛莫能助。最好方法是能看到代碼一步一步的執行流程，那麼，單步調試就是比較好的選擇了。本文采用KVM+GDB的方式對usb-skeleton子產品進行了單步調試。Linux核心調試環境的搭建參考文章《qemu+eclipse核心調試》，這裡僅需要建立一個Makefile檔案，編譯usb-skeleton.c即可。KVM中usb裝置的使用參考文章《KVM中使用usb裝置》。需要注意的是，Linux内中預設的usb儲存設備的驅動子產品名稱為usb-storage，在調試前，先解除安裝該子產品。

四、usb-skeleton主要代碼分析(Linux-2.6.35)

1 skel_probe函數

1. static int skel_probe(struct usb_interface*interface,
2.          const struct usb_device_id *id)
3. {
4.     struct usb_skel *dev;
5.     struct usb_host_interface *iface_desc;
6.     struct usb_endpoint_descriptor *endpoint;
7.     size_t buffer_size;
8.     int i;
9.     int retval = -ENOMEM;
10.     dev = kzalloc(sizeof(*dev), GFP_KERNEL);
11.     if (!dev){
12.         err("Out of memory");
13.         goto error;
14.     }
15.     kref_init(&dev->kref);
16.     sema_init(&dev->limit_sem, WRITES_IN_FLIGHT);
17.     mutex_init(&dev->io_mutex);/IO操作互斥鎖，在進行IO操作時，不允許進行其他操作，如資料拷貝，後面會提到/
18.     spin_lock_init(&dev->err_lock);
19.     init_usb_anchor(&dev->submitted);
20.     init_completion(&dev->bulk_in_completion);
21.     dev->udev= usb_get_dev(interface_to_usbdev(interface));
22.     dev->interface= interface;
23.     iface_desc = interface->cur_altsetting;
24.     for (i= 0; i < iface_desc->desc.bNumEndpoints;++i){
25.         endpoint = &iface_desc->endpoint[i].desc;
26.         if (!dev->bulk_in_endpointAddr&&
27.          usb_endpoint_is_bulk_in(endpoint)){
28.             buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
29.             dev->bulk_in_size= buffer_size;
30.             dev->bulk_in_endpointAddr= endpoint->bEndpointAddress;
31.             dev->bulk_in_buffer= kmalloc(buffer_size, GFP_KERNEL);
32.             if (!dev->bulk_in_buffer){
33.                 err("Could not allocate bulk_in_buffer");
34.                 goto error;
35.             }
36.             dev->bulk_in_urb= usb_alloc_urb(0, GFP_KERNEL);
37.             if (!dev->bulk_in_urb){
38.                 err("Could not allocate bulk_in_urb");
39.                 goto error;
40.             }
41.         }
42.         if (!dev->bulk_out_endpointAddr&&
43.          usb_endpoint_is_bulk_out(endpoint)){
44.             dev->bulk_out_endpointAddr= endpoint->bEndpointAddress;
45.         }
46.     }
47.     if (!(dev->bulk_in_endpointAddr&& dev->bulk_out_endpointAddr)){
48.         err("Could not find both bulk-in and bulk-out endpoints");
49.         goto error;
50.     }
51.     usb_set_intfdata(interface, dev);
52.     retval = usb_register_dev(interface,&skel_class);
53.     if (retval){
54.         err("Not able to get a minor for this device.");
55.         usb_set_intfdata(interface,NULL);
56.         goto error;
57.     }
58.     dev_info(&interface->dev,
59.          "USB Skeleton device now attached to USBSkel-%d",
60.          interface->minor);
61.     return 0;
62. error:
63.     if (dev)
64.         kref_put(&dev->kref, skel_delete);
65.     return retval;
66. }

此函數主要完成usb使用者态驅動的注冊即usb_class_driver的注冊，即skel_class結構體的注冊。另外，需要注意的是在驅動程式設計中probe()和open()兩個函數的差別，即它們各自應該實作什麼功能？個人認為主要了解以下幾點：

（1）對每個驅動來講probe函數隻會執行一次，執行時機為驅動加載或裝置枚舉的時候，用來實作裝置和驅動的比對。從這方面來講，probe函數的執行函數應該盡可能的短，是以，操作越少越好。

（2）open()函數是每次打開某裝置時都要執行的函數，如果系統中有多個程序都在使用某個裝置，那麼，open()函數就有可能執行多次，從這個角度來講，open()函數主要應該坐與可沖入相關的操作，即讓每個程序看來都是像第一次打開裝置一樣，其他程序對裝置的某些值的修改不應該被其他程序看到。即相當于每次都虛拟了一個實際的硬體裝置。

從這兩方面将，如果不考慮probe的執行時間，如果不會存在多個使用同一裝置的程序，完全可以将probe和open合并。

2 skel_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.          __func__, subminor);
12.         retval = -ENODEV;
13.         goto exit;
14.     }
15.     dev = usb_get_intfdata(interface);
16.     if (!dev){
17.         retval = -ENODEV;
18.         goto exit;
19.     }
20.     kref_get(&dev->kref);
21.     mutex_lock(&dev->io_mutex);
22.     if (!dev->open_count++){
23.         retval = usb_autopm_get_interface(interface);
24.             if (retval) {
25.                 dev->open_count--;
26.                 mutex_unlock(&dev->io_mutex);
27.                 kref_put(&dev->kref, skel_delete);
28.                 goto exit;
29.             }
30.     }
31.     file->private_data= dev;
32.     mutex_unlock(&dev->io_mutex);
33. exit:
34.     return retval;
35. }

從上面的代碼我們可以發現，open函數歸根結底其實隻做了一件事情：儲存了私有變量usb_skel dev,是的其他檔案操作函數可用。

3.skel_read()函數

1. static ssize_t skel_read(structfile *file,char *buffer,size_t count,
2. loff_t *ppos)
3. {
4. struct usb_skel *dev;
5. int rv;
6. bool ongoing_io;
7. dev = (struct usb_skel*)file->private_data;
8. if (!dev->bulk_in_urb|| !count)
9. return 0;
10. rv = mutex_lock_interruptible(&dev->io_mutex);
11. if (rv < 0)
12. return rv;
13. if (!dev->interface){
14. rv = -ENODEV;
15. goto exit;
16. }
17. retry:
18. spin_lock_irq(&dev->err_lock);
19. ongoing_io = dev->ongoing_read;
20. spin_unlock_irq(&dev->err_lock);
21. if (ongoing_io){
22. if (file->f_flags& O_NONBLOCK){
23. rv = -EAGAIN;
24. goto exit;
25. }
26. rv = wait_for_completion_interruptible(&dev->bulk_in_completion);
27. if (rv < 0)
28. goto exit;
29. dev->bulk_in_copied= 0;
30. dev->processed_urb= 1;
31. }
32. if (!dev->processed_urb){
33. wait_for_completion(&dev->bulk_in_completion);
34. dev->bulk_in_copied= 0;
35. dev->processed_urb= 1;
36. }
37. rv = dev->errors;
38. if (rv < 0) {
39. dev->errors= 0;
40. rv = (rv== -EPIPE) ? rv: -EIO;
41. dev->bulk_in_filled= 0;
42. goto exit;
43. }
44. if (dev->bulk_in_filled){
45. size_t available = dev->bulk_in_filled- dev->bulk_in_copied;
46. size_t chunk =min(available,count);
47. if (!available){
48. rv = skel_do_read_io(dev,count);
49. if (rv < 0)
50. goto exit;
51. else
52. goto retry;
53. }
54. if (copy_to_user(buffer,
55. dev->bulk_in_buffer+ dev->bulk_in_copied,
56. chunk))
57. rv = -EFAULT;
58. else
59. rv = chunk;
60. dev->bulk_in_copied+= chunk;
61. if (available< count)
62. skel_do_read_io(dev,count - chunk);
63. } else {
64. rv = skel_do_read_io(dev,count);
65. if (rv < 0)
66. goto exit;
67. else if(!(file->f_flags& O_NONBLOCK))
68. goto retry;
69. rv = -EAGAIN;
70. }
71. exit:
72. mutex_unlock(&dev->io_mutex);
73. return rv;
74. }

• 1. static void skel_read_bulk_callback(struct urb*urb)
  2. {
  3. struct usb_skel *dev;
  4. dev = urb->context;
  5. spin_lock(&dev->err_lock);
  6. if (urb->status){
  7. if (!(urb->status== -ENOENT ||
  8. urb->status== -ECONNRESET ||
  9. urb->status== -ESHUTDOWN))
  10. err("%s - nonzero write bulk status received: %d",
  11. __func__, urb->status);
  12. dev->errors= urb->status;
  13. } else {
  14. dev->bulk_in_filled= urb->actual_length;
  15. }
  16. dev->ongoing_read= 0;
  17. spin_unlock(&dev->err_lock);
  18. complete(&dev->bulk_in_completion);
  19. }
  20. static int skel_do_read_io(struct usb_skel*dev, size_t count)
  21. {
  22. int rv;
  23. usb_fill_bulk_urb(dev->bulk_in_urb,
  24. dev->udev,
  25. usb_rcvbulkpipe(dev->udev,
  26. dev->bulk_in_endpointAddr),
  27. dev->bulk_in_buffer,
  28. min(dev->bulk_in_size,count),
  29. skel_read_bulk_callback,
  30. dev);
  31. spin_lock_irq(&dev->err_lock);
  32. dev->ongoing_read= 1;
  33. spin_unlock_irq(&dev->err_lock);
  34. rv = usb_submit_urb(dev->bulk_in_urb, GFP_KERNEL);
  35. if (rv < 0) {
  36. err("%s - failed submitting read urb, error %d",
  37. __func__, rv);
  38. dev->bulk_in_filled= 0;
  39. rv = (rv== -ENOMEM) ? rv: -EIO;
  40. spin_lock_irq(&dev->err_lock);
  41. dev->ongoing_read= 0;
  42. spin_unlock_irq(&dev->err_lock);
  43. }
  44. return rv;
  45. }

該函數比較容易了解，就是一個從usb裝置讀資料到使用者程式的過程，這裡涉及到一個主要的資料結構URB，對于usb客戶驅動來講，隻需調用usb core提供的API即可，是以，usb驅動開發者隻需了解這個API的功能和如何使用即可。詳見代碼注釋。

4 skel_write()操作

1. static ssize_t skel_write(structfile *file,const char *user_buffer,
2.              size_t count, loff_t *ppos)
3. {
4.     struct usb_skel *dev;
5.     int retval = 0;
6.     struct urb *urb = NULL;
7.     char *buf= NULL;
8.     size_t writesize = min(count,(size_t)MAX_TRANSFER);
9.     dev = (struct usb_skel*)file->private_data;
10.     if (count== 0)
11.         goto exit;
12.     if (!(file->f_flags& O_NONBLOCK)){
13.         if (down_interruptible(&dev->limit_sem)){
14.             retval = -ERESTARTSYS;
15.             goto exit;
16.         }
17.     } else{
18.         if (down_trylock(&dev->limit_sem)){
19.             retval = -EAGAIN;
20.             goto exit;
21.         }
22.     }
23.     spin_lock_irq(&dev->err_lock);
24.     retval = dev->errors;
25.     if (retval< 0) {
26.         dev->errors= 0;
27.         retval = (retval ==-EPIPE) ? retval : -EIO;
28.     }
29.     spin_unlock_irq(&dev->err_lock);
30.     if (retval< 0)
31.         goto error;
32.     urb = usb_alloc_urb(0, GFP_KERNEL);
33.     if (!urb){
34.         retval = -ENOMEM;
35.         goto error;
36.     }
37.     buf = usb_alloc_coherent(dev->udev, writesize, GFP_KERNEL,
38.                  &urb->transfer_dma);
39.     if (!buf){
40.         retval = -ENOMEM;
41.         goto error;
42.     }
43.     if (copy_from_user(buf, user_buffer, writesize)){
44.         retval = -EFAULT;
45.         goto error;
46.     }
47.     mutex_lock(&dev->io_mutex);
48.     if (!dev->interface){
49.         mutex_unlock(&dev->io_mutex);
50.         retval = -ENODEV;
51.         goto error;
52.     }
53.     usb_fill_bulk_urb(urb, dev->udev,
54.              usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
55.              buf, writesize, skel_write_bulk_callback, dev);
56.     urb->transfer_flags|= URB_NO_TRANSFER_DMA_MAP;
57.     usb_anchor_urb(urb,&dev->submitted);
58.     retval = usb_submit_urb(urb, GFP_KERNEL);
59.     mutex_unlock(&dev->io_mutex);
60.     if (retval){
61.         err("%s - failed submitting write urb, error %d",__func__,
62.          retval);
63.         goto error_unanchor;
64.     }
65.     usb_free_urb(urb);
66.     return writesize;
67. }

在函數與skel_read非常類似，唯一不同的是在寫操作過程中需要usb客戶驅動程式來顯示的配置設定和初始化用于寫操作的URB，之是以在讀操作過程中看不到這個過程，是因為，在struct usb_skel dev中已經為寫操作内嵌了一個資料成員：

1. struct usb_skel {
2.     struct usb_device    *udev;            
3.     struct usb_interface    *interface;        
4.     struct semaphore    limit_sem;        
5.     struct usb_anchor    submitted;        
6.     struct urb        *bulk_in_urb;        
7.     unsigned char*bulk_in_buffer;    
8.     size_t            bulk_in_size;        
9.     size_t            bulk_in_filled;        
10.     size_t            bulk_in_copied;        
11.     __u8            bulk_in_endpointAddr;    
12.     __u8            bulk_out_endpointAddr;    
13.     int            errors;            
14.     int            open_count;        
15.     bool            ongoing_read;        
16.     bool            processed_urb;        
17.     spinlock_t        err_lock;        
18.     struct kref        kref;
19.     struct mutex        io_mutex;        
20.     struct completion    bulk_in_completion;    
21. };

而且這個結構體的很多資料成員都與讀操作有關，具體為什麼這麼設計，暫時還沒有搞明白，希望大家指教！

總結：

1. usb客戶驅動還是比較簡單的，主要是因為很多功能都由usb core驅動程式事先完成了，usb用戶端驅動程式僅僅是調用一些API即可。

2. usb客戶驅動程式的開發比較固定，直接套用usb-skeleton的代碼基本就可以完成使用者自定義驅動的編寫