好，了解過USB一些規(guī)范細節(jié)之后，我們現(xiàn)在來看看Linux的驅(qū)動框架。事實上，Linux的設(shè)備驅(qū)動，特別是這種hotplug的USB設(shè)備驅(qū)動，會被編譯成模塊，然后在需要時掛在到內(nèi)核。要寫一個Linux的模塊并不復(fù)雜，以一個helloworld為例：
#include
#include
MODULE_LICENSE(“GPL”);

static int hello_init(void)
{
     printk(KERN_ALERT “Hello World!\n”);
     return 0;
}
static int hello_exit(void)
{
     printk(KERN_ALERT “GOODBYE!\n”);
}
module_init(hello_init);
module_exit(hello_exit);

這個簡單的程序告訴大家應(yīng)該怎么寫一個模塊，MODULE_LICENSE告訴內(nèi)核該模塊的
版權(quán)信息，很多情況下，用GPL或者BSD，或者兩個，因為一個私有模塊一般很難得到社區(qū)的幫助。module_init和module_exit用于向
內(nèi)核注冊模塊的初始化函數(shù)和模塊推出函數(shù)。如程序所示，初始化函數(shù)是hello_init，而退出函數(shù)是hello_exit。
     另外，要編譯一個模塊通常還需要用到內(nèi)核源碼樹種的makefile，所以模塊的Makefile可以寫成：
ifneq ($(KERNELRELEASE),)
obj-m:= hello.o#usb-dongle.o

else
KDIR:= /usr/src/linux-headers-$(shell uname -r)
BDIR:= $(shell pwd)

default:
     $(MAKE) -C $(KDIR) M=$(PWD) modules
.PHONY: clean

clean:
     make -C $(KDIR) M=$(BDIR) clean
endif
可以用insmod跟rmmod來驗證模塊的掛在跟卸載，但必須用root的身份登陸命令行，用普通用戶加su或者sudo在Ubuntu上的測試是不行的。

下面我們來分析一下usb-skeleton的源碼吧。這個范例程序可以在linux-2.6.17/drivers/usb下找到，其他版本的內(nèi)核程序源碼可能有所不同，但相差不大。大家可以先找到源碼看一看，先有個整體印象。
     之前已經(jīng)提到，模塊先要向內(nèi)核注冊初始化跟銷毀函數(shù)：
static int __init usb_skel_init(void)
{
     int result;

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

     return result;
}

static void __exit usb_skel_exit(void)
{
     /* deregister this driver with the USB subsystem */
     usb_deregister(&skel_driver);
}

module_init (usb_skel_init);
module_exit (usb_skel_exit);

MODULE_LICENSE("GPL");
從代碼開來，這個init跟exit函數(shù)的作用只是用來注冊驅(qū)動程序，這個描述驅(qū)動程序的結(jié)
構(gòu)體是系統(tǒng)定義的標準結(jié)構(gòu)struct usb_driver,注冊和注銷的方法很簡單，usb_register（struct
*usb_driver）, usb_unregister（struct
*usb_driver）。那這個結(jié)構(gòu)體需要做些什么呢？他要向系統(tǒng)提供幾個函數(shù)入口，跟驅(qū)動的名字：
static struct usb_driver skel_driver = {
     .name =       "skeleton",
     .probe = skel_probe,
     .disconnect = skel_disconnect,
     .id_table =   skel_table,
};
從代碼看來，usb_driver需要初始化四個東西：模塊的名字skeleton，probe函數(shù)skel_probe,disconnect函數(shù)skel_disconnect,id_table。
     在解釋skel_driver各個成員之前，我們先來看看另外一個結(jié)構(gòu)體。這個結(jié)構(gòu)體的名字有開發(fā)人員自定義，它描述的是該驅(qū)動擁有的所有資源及狀態(tài)：
     struct usb_skel {
     struct usb_device *    udev;              /* the usb device for this device */
     struct usb_interface * interface;         /* the interface for this device */
     struct semaphore   limit_sem;         /* limiting the number of writes in progress */
     unsigned char *        bulk_in_buffer;        /* the buffer to receive data */
     size_t             bulk_in_size;      /* the size of the receive buffer */
     __u8          bulk_in_endpointAddr;  /* the address of the bulk in endpoint */
     __u8          bulk_out_endpointAddr; /* the address of the bulk out endpoint */
     struct kref        kref;
};
   
我們先來對這個usb_skel作個簡單分析，他擁有一個描述usb設(shè)備的結(jié)構(gòu)體udev，一個接口interface，用于并發(fā)訪問控制的
semaphore(信號量)
limit_sem，用于接收數(shù)據(jù)的緩沖bulk_in_buffer及其尺寸bulk_in_size，然后是批量輸入輸出端口地址
bulk_in_endpointAddr、bulk_out_endpointAddr，最后是一個內(nèi)核使用的引用計數(shù)器。他們的作用我們將在后面的代
碼中看到。
我們在回過頭來看看skel_driver。
Name用來告訴內(nèi)核模塊的名字是什么，這個注冊之后有系統(tǒng)來使用，跟我們關(guān)系不大。
id_table用來告訴內(nèi)核該模塊支持的設(shè)備。Usb子系統(tǒng)通過設(shè)備的
production ID和vendor
ID的組合或者設(shè)備的class、subclass跟protocol的組合來識別設(shè)備，并調(diào)用相關(guān)的驅(qū)動程序作處理。我們可以看看這個id_table
到底是什么東西：
/* Define these values to match your devices */
#define USB_SKEL_VENDOR_ID  0xfff0
#define USB_SKEL_PRODUCT_ID 0xfff0

/* table of devices that work with this driver */
static struct usb_device_id skel_table [] = {
     { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
     { }                    /* Terminating entry */
};
MODULE_DEVICE_TABLE (usb, skel_table);
   
MODULE_DEVICE_TABLE的第一個參是設(shè)備的類型，如果是USB設(shè)備，那自然是usb（如果是PCI設(shè)備，那將是pci，這兩個子系統(tǒng)用同
一個宏來注冊所支持的設(shè)備。這設(shè)計PCI設(shè)備的驅(qū)動了，在此先不深究）。后面一個參數(shù)是設(shè)備表，這個設(shè)備表的最后一個元素是空的，用于標識結(jié)束。代碼定義
了USB_SKEL_VENDOR_ID是0xfff0，USB_SKEL_PRODUCT_ID是0xfff0，也就是說，當有一個設(shè)備接到集線器
時，usb子系統(tǒng)就會檢查這個設(shè)備的vendor ID和product
ID，如果它們的值是0xfff0時，那么子系統(tǒng)就會調(diào)用這個skeleton模塊作為設(shè)備的驅(qū)動。

probe是usb子系統(tǒng)自動調(diào)用的一個函數(shù)，有USB設(shè)備接到硬件集線器時，usb子系統(tǒng)
會根據(jù)production ID和vendor
ID的組合或者設(shè)備的class、subclass跟protocol的組合來識別設(shè)備調(diào)用相應(yīng)驅(qū)動程序的probe（探測）函數(shù)，對于skeleton
來說，就是skel_probe。系統(tǒng)會傳遞給探測函數(shù)一個usb_interface *跟一個struct usb_device_id
*作為參數(shù)。他們分別是該USB設(shè)備的接口描述（一般會是該設(shè)備的第0號接口，該接口的默認設(shè)置也是第0號設(shè)置）跟它的設(shè)備ID描述（包括Vendor
ID、Production ID等）。Probe函數(shù)比較長，我們分段來分析這個函數(shù)：
     dev->udev = usb_get_dev(interface_to_usbdev(interface));
     dev->interface = interface;
在初始化了一些資源之后，我們可以看到第一個關(guān)鍵的函數(shù)調(diào)用——
interface_to_usbdev。他同uo一個usb_interface來得到該接口所在設(shè)備的設(shè)備描述結(jié)構(gòu)。本來，要得到一個
usb_device只要用interface_to_usbdev就夠了，但因為要增加對該usb_device的引用計數(shù)，我們應(yīng)該在做一個
usb_get_dev的操作，來增加引用計數(shù)，并在釋放設(shè)備時用usb_put_dev來減少引用計數(shù)。這里要解釋的是，該引用計數(shù)值是對該
usb_device的計數(shù)，并不是對本模塊的計數(shù)，本模塊的計數(shù)要由kref來維護。所以，probe一開始就有初始化kref。事實
上，kref_init操作不單只初始化kref，還將其置設(shè)成1。所以在出錯處理代碼中有kref_put，它把kref的計數(shù)減1，如果kref計數(shù)
已經(jīng)為0，那么kref會被釋放。Kref_put的第二個參數(shù)是一個函數(shù)指針，指向一個清理函數(shù)。注意，該指針不能位空，或者kfree。該函數(shù)會在最
后一個對kref的引用釋放時被調(diào)用（如果我的理解不準確，請指正）。下面是內(nèi)核源碼中的一段注釋及代碼：
/**
* kref_put - decrement refcount for object.
* @kref: object.
* @release: pointer to the function that will clean up the object when the
*        last reference to the object is released.
*        This pointer is required, and it is not acceptable to pass kfree
*        in as this function.
*
* Decrement the refcount, and if 0, call release().
* Return 1 if the object was removed, otherwise return 0.  Beware, if this
* function returns 0, you still can not count on the kref from remaining in
* memory.  Only use the return value if you want to see if the kref is now
* gone, not present.
*/
int kref_put(struct kref *kref, void (*release)(struct kref *kref))
{
     WARN_ON(release == NULL);
     WARN_ON(release == (void (*)(struct kref *))kfree);

     /*
      * if current count is one, we are the last user and can release object
      * right now, avoiding an atomic operation on 'refcount'
      */
     if ((atomic_read(&kref->refcount) == 1) ||
         (atomic_dec_and_test(&kref->refcount))) {
         release(kref);
         return 1;
     }
     return 0;
}
當我們執(zhí)行打開操作時，我們要增加kref的計數(shù)，我們可以用kref_get，來完成。所有對struct kref的操作都有內(nèi)核代碼確保其原子性。
得到了該usb_device之后，我們要對我們自定義的usb_skel各個狀態(tài)跟資源作
初始化。這部分工作的任務(wù)主要是向usb_skel注冊該usb設(shè)備的端點。這里可能要補充以下一些關(guān)于
usb_interface_descriptor的知識，但因為內(nèi)核源碼對該結(jié)構(gòu)體的注釋不多，所以只能靠個人猜測。在一個
usb_host_interface結(jié)構(gòu)里面有一個usb_interface_descriptor叫做desc的成員，他應(yīng)該是用于描述該
interface的一些屬性，其中bNubEndpoints一個8位（b for
byte）的數(shù)字，他代表了該接口的端點數(shù)。Probe然后遍歷所有的端點，檢查他們的類型跟方向，注冊到usb_skel中。
     /* set up the endpoint information */
     /* use only the first bulk-in and bulk-out endpoints */
     iface_desc = interface->cur_altsetting;
     for (i = 0; i desc.bNumEndpoints; ++i) {
         endpoint = &iface_desc->endpoint.desc;

         if (!dev->bulk_in_endpointAddr &&
             ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
                       == USB_DIR_IN) &&
             ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
                       == USB_ENDPOINT_XFER_BULK)) {
              /* we found a bulk in endpoint */
              buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
              dev->bulk_in_size = buffer_size;
              dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
              dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
              if (!dev->bulk_in_buffer) {
                   err("Could not allocate bulk_in_buffer");
                   goto error;
              }
         }

         if (!dev->bulk_out_endpointAddr &&
             ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
                       == USB_DIR_OUT) &&
             ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
                       == USB_ENDPOINT_XFER_BULK)) {
              /* we found a bulk out endpoint */
              dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
         }
     }
     if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
         err("Could not find both bulk-in and bulk-out endpoints");
         goto error;
     }

接下來的工作是向系統(tǒng)注冊一些以后會用的的信息。首先我們來說明一下usb-
set_intfdata()，他向內(nèi)核注冊一個data，這個data結(jié)構(gòu)可以是任意的，在這段程序用向內(nèi)核注冊了一個usb_skel結(jié)構(gòu)，就是我們
剛剛看到的被初始化的那個，這個data可以在以后用usb_get_intfdata來得到。
     usb_set_intfdata(interface, dev);
     retval = usb_register_dev(interface, &skel_class);
然后我們向這個interface注冊一個skel_class結(jié)構(gòu)。這個結(jié)構(gòu)又是什么？我們就來看看這到底是個什么東西：
static struct usb_class_driver skel_class = {
     .name =       "skel%d",
     .fops =       &skel_fops,
     .minor_base = USB_SKEL_MINOR_BASE,
};
它其實是一個系統(tǒng)定義的結(jié)構(gòu)，里面包含了一名字、一個文件操作結(jié)構(gòu)體還有一個次設(shè)備號的基準
值。事實上它定義真正完成對設(shè)備IO操作的函數(shù)。所以他的核心內(nèi)容應(yīng)該是skel_fops。這里補充一些我個人的估計：因為usb設(shè)備可以有多個
interface，每個interface所定義的IO操作可能不一樣，所以想系統(tǒng)注冊的usb_class_driver要求注冊到某一個
interface，因此usb_register_dev的第一個參數(shù)是interface，而第二個參數(shù)就是某一個
usb_class_driver。通常情況下，linux系統(tǒng)用主設(shè)備好來識別某類設(shè)備的的驅(qū)動程序，用次設(shè)備號管理識別具體的設(shè)備，驅(qū)動程序可以依照
次設(shè)備好來區(qū)分不同的設(shè)備，所以，這里的次設(shè)備好其實是用來管理不同的interface的，但由于這個范例只有一個interface，在代碼上無法求
證這個猜想。
static struct file_operations skel_fops = {
     .owner = THIS_MODULE,
     .read =       skel_read,
     .write = skel_write,
     .open =       skel_open,
     .release =    skel_release,
};
這個文件操作結(jié)構(gòu)中定義了對設(shè)備的讀寫、打開釋放（USB設(shè)備通常使用這個術(shù)語release）。他們都是函數(shù)指針，分別指向skel_read、skel_write、skel_open、skel_release這四個函數(shù)，這四個函數(shù)應(yīng)該有開發(fā)人員自己實現(xiàn)。
當設(shè)備被拔出集線器時，usb子系統(tǒng)會自動地調(diào)用disconnect，他做的事情不多，最重要的是注銷class_driver（交還次設(shè)備號）和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的細節(jié)參見前文。
到目前為止，我們已經(jīng)分析完usb子系統(tǒng)要求的各個主要操作，下一部分我們在討論一下對USB設(shè)備的IO操作。

說的usb子系統(tǒng)的IO操作，不得不說usb request
block，簡稱urb。事實上，可以打一個這樣的比喻，usb總線就像一條高速公路，貨物、人流之類的可以看成是系統(tǒng)與設(shè)備交互的數(shù)據(jù)，而urb就可以
看成是交通工具。在一開始對USB規(guī)范細節(jié)的介紹，我們就說過USB的endpoint有4種不同類型，于是能在這條高速公路上流動的數(shù)據(jù)也就有四種。但
對車是沒有要求的，urb可以運載四種數(shù)據(jù)，不過你要先告訴司機你要運什么，目的地是什么。我們現(xiàn)在就看看struct
urb的具體內(nèi)容。它的內(nèi)容很多，為了不讓我的理解誤導各位，大家最好還是看一看內(nèi)核源碼的注釋，具體內(nèi)容參見源碼樹下include/linux
/usb.h。
在這里我們重點介紹程序中出現(xiàn)的幾個關(guān)鍵字段：
struct usb_device *dev
urb所發(fā)送的目標設(shè)備。
unsigned int pipe
     一個管道號碼，該管道記錄了目標設(shè)備的端點以及管道的類型。每個管道只有一種類型和一個方向，它與他的目標設(shè)備的端點向?qū)?yīng)，我們可以通過以下幾個函數(shù)來獲得管道號并設(shè)置管道類型：
     unsigned int usb_sndctrlpipe(struct usb_device *dev, unsigned int endpoint)
         把指定USB設(shè)備指定端點設(shè)置為一個控制OUT端點。
     unsigned int usb_rcvctrlpipe(struct usb_device *dev, unsigned int endpoint)
         把指定USB設(shè)備指定端點設(shè)置為一個控制IN端點。
     unsigned int usb_sndbulkpipe(struct usb_device *dev, unsigned int endpoint)
         把指定USB設(shè)備指定端點設(shè)置為一個批量OUT端點。
     unsigned int usb_rcvbulkpipe(struct usb_device *dev, unsigned int endpoint)
         把指定USB設(shè)備指定端點設(shè)置為一個批量OUT端點。
     unsigned int usb_sndintpipe(struct usb_device *dev, unsigned int endpoint)
         把指定USB設(shè)備指定端點設(shè)置為一個中斷OUT端點。
     unsigned int usb_rcvintpipe(struct usb_device *dev, unsigned int endpoint)
         把指定USB設(shè)備指定端點設(shè)置為一個中斷OUT端點。
     unsigned int usb_sndisocpipe(struct usb_device *dev, unsigned int endpoint)
         把指定USB設(shè)備指定端點設(shè)置為一個等時OUT端點。
     unsigned int usb_rcvisocpipe(struct usb_device *dev, unsigned int endpoint)
         把指定USB設(shè)備指定端點設(shè)置為一個等時OUT端點。
unsigned int transfer_flags
當不使用DMA時，應(yīng)該transfer_flags |= URB_NO_TRANSFER_DMA_MAP（按照代碼的理解，希望沒有錯）。
Int status
     當一個urb把數(shù)據(jù)送到設(shè)備時，這個urb會由系統(tǒng)返回給驅(qū)動程序，并調(diào)用驅(qū)動程序的urb完成回調(diào)函數(shù)處理。這時，status記錄了這次數(shù)據(jù)傳輸?shù)挠嘘P(guān)狀態(tài)，例如傳送成功與否。成功的話會是0。
     要能夠運貨當然首先要有車，所以第一步當然要創(chuàng)建urb：
     struct urb *usb_alloc_urb(int isoc_packets, int mem_flags);
     第一個參數(shù)是等時包的數(shù)量，如果不是乘載等時包，應(yīng)該為0，第二個參數(shù)與kmalloc的標志相同。
     要釋放一個urb可以用：
     void usb_free_urb(struct urb *urb);
     要承載數(shù)據(jù)，還要告訴司機目的地信息跟要運的貨物，對于不同的數(shù)據(jù)，系統(tǒng)提供了不同的函數(shù)，對于中斷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是一要送/收的數(shù)據(jù)的緩沖，buffer_length是它的長度，complete是urb完成回調(diào)函數(shù)的入口，context有用戶定義，可能會在回調(diào)函數(shù)中使用的數(shù)據(jù)，interval就是urb被調(diào)度的間隔。
     對于批量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);
控制包有一個特殊參數(shù)setup_packet，它指向即將被發(fā)送到端點的設(shè)置數(shù)據(jù)報的數(shù)據(jù)。
對于等時urb，系統(tǒng)沒有專門的fill函數(shù)，只能對各urb字段顯示賦值。
有了汽車，有了司機，下一步就是要開始運貨了，我們可以用下面的函數(shù)來提交urb
     int usb_submit_urb(struct urb *urb, int mem_flags);
mem_flags有幾種：GFP_ATOMIC、GFP_NOIO、GFP_KERNEL，通常在中斷上下文環(huán)境我們會用GFP_ATOMIC。
當我們的卡車運貨之后，系統(tǒng)會把它調(diào)回來，并調(diào)用urb完成回調(diào)函數(shù)，并把這輛車作為函數(shù)傳遞給驅(qū)動程序。我們應(yīng)該在回調(diào)函數(shù)里面檢查status字段，以確定數(shù)據(jù)的成功傳輸與否。下面是用urb來傳送數(shù)據(jù)的細節(jié)。
     /* 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就是一個完成回調(diào)函數(shù)，而他做的主要事情就是檢查數(shù)據(jù)傳輸狀態(tài)和釋放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);
事實上，如果數(shù)據(jù)的量不大，那么可以不一定用卡車來運貨，系統(tǒng)還提供了一種不用urb的傳輸方式，而usb-skeleton的讀操作正是采用這種方式實現(xiàn)：
     /* 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),
                    &bytes_read, 10000);

     /* if the read was successful, copy the data to userspace */
     if (!retval) {
         if (copy_to_user(buffer, dev->bulk_in_buffer, bytes_read))
              retval = -EFAULT;
         else
              retval = bytes_read;
     }
程序使用了usb_bulk_msg來傳送數(shù)據(jù)，它的原型如下：
     int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,void *data,
int len, int *actual length, int timeout)
     這個函數(shù)會阻塞等待數(shù)據(jù)傳輸完成或者等到超時，data是輸入/輸出緩沖，len是它的大小，actual length是實際傳送的數(shù)據(jù)大小，timeout是阻塞超時。
     對于控制數(shù)據(jù)，系統(tǒng)提供了另外一個函數(shù)，他的原型是：
         Int usb_contrl_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
                            __u8 requesttype, __u16 value, __u16 index, void *data,
                            __u16 size, int timeout);
Request是控制消息的USB請求值、requesttype是控制消息的USB請求類型，value是控制消息的USB消息值，index是控制消息的USB消息索引。具體是什么，暫時不是很清楚，希望大家提供說明。
至此，Linux下的USB驅(qū)動框架分析基本完成了。