參考2.6.14版本中的driver/usb/input/usbmouse.c。鼠標驅動可分為幾個部分：驅動加載部分、probe部分、open部分、urb回調函數處理部分。

下文陰影部分為注解。

一、   驅動加載部分

static int __init usb_mouse_init(void)

{

       int retval = usb_register(&usb_mouse_driver);//注冊鼠標驅動

       if (retval == 0)

           info(DRIVER_VERSION ":" DRIVER_DESC);

       return retval;

}

其中usb_mouse_driver的定義為：

static struct usb_driver usb_mouse_driver = {

  .owner      = THIS_MODULE,

  .name       = "usbmouse",

  .probe      = usb_mouse_probe,

  .disconnect = usb_mouse_disconnect,

  .id_table   = usb_mouse_id_table,

};

如果注冊成功的話，將會調用usb_mouse_probe。那么什么時候才算注冊成功呢？

和其它驅動注冊過程一樣，只有在其對應的“總線”上發現匹配的“設備”才會調用probe。總線匹配的方法和具體總線相關，如：platform_bus_type中是判斷驅動名稱和平臺設備名稱是否相同；那如何確認usb總線的匹配方法呢？

Usb設備是注冊在usb_bus_type總線下的。查看usb_bus_type的匹配方法。

struct bus_type usb_bus_type = {

    .name =     "usb",

    .match =    usb_device_match,

    .hotplug =  usb_hotplug,

    .suspend =  usb_generic_suspend,

    .resume =   usb_generic_resume,

};

其中usb_device_match定義了匹配方法

static int usb_device_match (struct device *dev, struct device_driver *drv)

{

    struct usb_interface *intf;

    struct usb_driver *usb_drv;

    const struct usb_device_id *id;

    /* check for generic driver, which we don''t match any device with */

    if (drv == &usb_generic_driver)

        return 0;

    intf = to_usb_interface(dev);

    usb_drv = to_usb_driver(drv);

    id = usb_match_id (intf, usb_drv->id_table);

    if (id)

        return 1;

    return 0;

}

可以看出usb的匹配方法是usb_match_id (intf, usb_drv->id_table)，也就是說通過比對“dev中intf信息”和“usb_drv->id_table信息”，如果匹配則說明驅動所對應的設備已經添加到總線上了，所以接下了就會調用drv中的probe方法注冊usb設備驅動。

usb_mouse_id_table的定義為：

static struct usb_device_id usb_mouse_id_table[] = {

    { USB_INTERFACE_INFO(3, 1, 2) },

    { }                     /* Terminating entry */

};

#define USB_INTERFACE_INFO(cl,sc,pr) \

.match_flags = USB_DEVICE_ID_MATCH_INT_INFO, \

.bInterfaceClass = (cl), \

.bInterfaceSubClass = (sc), \

.bInterfaceProtocol = (pr)

鼠標設備遵循USB人機接口設備（HID），在HID規范中規定鼠標接口類碼為：

接口類：0x03

接口子類：0x01

接口協議：0x02

這樣分類的好處是設備廠商可以直接利用標準的驅動程序。除了HID類以外還有Mass storage、printer、audio等

#define USB_DEVICE_ID_MATCH_INT_INFO \

(USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS | USB_DEVICE_ID_MATCH_INT_PROTOCOL)

    匹配的過程為：

usb_match_id(struct usb_interface *interface, const struct usb_device_id *id)

{

    struct usb_host_interface *intf;

    struct usb_device *dev;

    /* proc_connectinfo in devio.c may call us with id == NULL. */

    if (id == NULL)

        return NULL;

    intf = interface->cur_altsetting;

    dev = interface_to_usbdev(interface);

    /* It is important to check that id->driver_info is nonzero,

       since an entry that is all zeroes except for a nonzero

       id->driver_info is the way to create an entry that

       indicates that the driver want to examine every

       device and interface. */

    for (; id->idVendor || id->bDeviceClass || id->bInterfaceClass ||

           id->driver_info; id++) {

        if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&

            id->idVendor != le16_to_cpu(dev->descriptor.idVendor))

            continue;

        if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&

            id->idProduct != le16_to_cpu(dev->descriptor.idProduct))

            continue;

        /* No need to test id->bcdDevice_lo != 0, since 0 is never

           greater than any unsigned number. */

        if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&

            (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))

            continue;

        if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&

            (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))

            continue;

        if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&

            (id->bDeviceClass != dev->descriptor.bDeviceClass))

            continue;

        if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&

            (id->bDeviceSubClass!= dev->descriptor.bDeviceSubClass))

            continue;

        if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&

            (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))

            continue;

        //接口類

        if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&

            (id->bInterfaceClass != intf->desc.bInterfaceClass))

            continue;

        //接口子類

        if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&

            (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))

            continue;

        //遵循的協議

        if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&

            (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))

            continue;

        return id;

    }

    return NULL;

}

從中可以看出，只有當設備的接口類、接口子類、接口協議匹配鼠標驅動時鼠標驅動才會調用probe方法。

二、probe部分

static int usb_mouse_probe(struct usb_interface * intf, const struct usb_device_id * id)

{

    struct usb_device * dev = interface_to_usbdev(intf);

    struct usb_host_interface *interface;

    struct usb_endpoint_descriptor *endpoint;

    struct usb_mouse *mouse;

    int pipe, maxp;

    char path[64];

    interface = intf->cur_altsetting;

/* 以下是網絡的一段對cur_altsettin的解釋，下面就借花獻佛。usb 設備有一個configuration 的概念,表示配置，一個設備可以有多個配置，但只能同時激活一個，如：一些設備可以下載固件，或可以設置不同的全局模式，就像手機可以被設定為靜音模式或響鈴模式一樣。而這里又有一個setting,咋一看有些奇怪,這兩個詞不是一回事嗎.還是拿我們最熟悉的手機來打比方,configuration 不說了,setting,一個手機可能各種配置都確定了,是振動還是鈴聲已經確定了,各種功能都確定了,但是聲音的大小還可以變吧,通常手機的音量是一格一格的變動,大概也就5,6 格,那么這個可以算一個setting 吧.這里cur_altsetting 就是表示的當前的這個setting,或者說設置。可以查看原碼中usb_interface 結構定義的說明部分。從說明中可以看到一個接口可以有多種setting*/

    if (interface->desc.bNumEndpoints != 1)    

return -ENODEV;

/*根據HID規則，期望鼠標只有一個端點即中斷端點bNumEndpoints 就是接口描述符中的成員,表示這個接口有多少個端點，不過這其中不包括0 號端點，0號端點是任何一個usb 設備都必須是提供的,這個端點專門用于進行控制傳輸,即它是一個控制端點.正因為如此,所以即使一個設備沒有進行任何設置，usb 主機也可以開始跟它進行一些通信,因為即使不知道其它的端點，但至少知道它一定有一個0號端點，或者說一個控制端點。

*/

    endpoint = &interface->endpoint[0].desc;//端點0描述符，此處的0表示中斷端點

    if (!(endpoint->bEndpointAddress & 0x80))

        return -ENODEV;

/*先看bEndpointAddress,這個struct usb_endpoint_descriptor 中的一個成員,是8個bit，或者說1 個byte，其中bit7 表示的是這個端點的方向，0 表示OUT，1 表示IN，OUT 與IN 是對主機而言。OUT 就是從主機到設備，IN 就是從設備到主機。而宏*USB_DIR_IN 來自

*include/linux/usb_ch9.h

 * USB directions

 * This bit flag is used in endpoint descriptors'' bEndpointAddress field.

 * It''s also one of three fields in control requests bRequestType.

 *#define USB_DIR_OUT 0 /* to device */

 *#define USB_DIR_IN 0x80 /* to host */

*/

    if ((endpoint->bmAttributes & 3) != 3)  //判斷是否是中斷類型

return -ENODEV;

/* bmAttributes 表示屬性,總共8位,其中bit1和bit0 共同稱為Transfer Type,即傳輸類型,即00 表示控制,01 表示等時,10 表示批量,11 表示中斷*/

    pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);//構造中斷端點的輸入pipe

    maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));

/*跟蹤usb_maxpacket

usb_maxpacket(struct usb_device *udev, int pipe, int is_out)

{

    struct usb_host_endpoint    *ep;

    unsigned            epnum = usb_pipeendpoint(pipe);

/*

得到的自然就是原來pipe 里邊的15 至18 位.一個pipe 的15 位至18 位是endpoint 號,(一共16 個endpoint,)所以很顯然,這里就是得到endpoint 號

*/

    if (is_out) {

        WARN_ON(usb_pipein(pipe));

        ep = udev->ep_out[epnum];

    } else {

        WARN_ON(usb_pipeout(pipe));

        ep = udev->ep_in[epnum];

    }

    if (!ep)

        return 0;

    /* NOTE:  only 0x07ff bits are for packet size... */

    return le16_to_cpu(ep->desc.wMaxPacketSize);

}

*/

//返回對應端點能夠傳輸的最大的數據包，鼠標的返回的最大數據包為4個字節，

第0個字節：bit 0、1、2、3、4分別代表左、右、中、SIDE、EXTRA鍵的按下情況

第1個字節：表示鼠標的水平位移

第2個字節：表示鼠標的垂直位移

第3個字節：REL_WHEEL位移

    if (!(mouse = kmalloc(sizeof(struct usb_mouse), GFP_KERNEL)))

        return -ENOMEM;

    memset(mouse, 0, sizeof(struct usb_mouse));

    mouse->data = usb_buffer_alloc(dev, 8, SLAB_ATOMIC, &mouse->data_dma);

/*

申請用于urb用于數據傳輸的內存，注意：這里將返回“mouse->data”和“mouse->data_dma”

mouse->data：記錄了用于普通傳輸用的內存指針

mouse->data_dma：記錄了用于DMA傳輸的內存指針

如果是DMA 方式的傳輸，那么usb core 就應該使用mouse->data_dma

*/

    if (!mouse->data) {

        kfree(mouse);

        return -ENOMEM;

    }

    mouse->irq = usb_alloc_urb(0, GFP_KERNEL);

    if (!mouse->irq) {

        usb_buffer_free(dev, 8, mouse->data, mouse->data_dma);

        kfree(mouse);

        return -ENODEV;

    }

    mouse->usbdev = dev;

    mouse->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REL);

//設置input系統響應按鍵和REL（相對結果）事件

    mouse->dev.keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT) | BIT(BTN_MIDDLE);

    mouse->dev.relbit[0] = BIT(REL_X) | BIT(REL_Y);

    mouse->dev.keybit[LONG(BTN_MOUSE)] |= BIT(BTN_SIDE) | BIT(BTN_EXTRA);

    mouse->dev.relbit[0] |= BIT(REL_WHEEL);

//設置input系統響應的碼表及rel表

    mouse->dev.private = mouse;

    mouse->dev.open = usb_mouse_open;

    mouse->dev.close = usb_mouse_close;

    usb_make_path(dev, path, 64);

    sprintf(mouse->phys, "%s/input0", path);

    mouse->dev.name = mouse->name;

    mouse->dev.phys = mouse->phys;

    usb_to_input_id(dev, &mouse->dev.id);

/*

usb_to_input_id(const struct usb_device *dev, struct input_id *id)

{

    id->bustype = BUS_USB;

    id->vendor = le16_to_cpu(dev->descriptor.idVendor);

    id->product = le16_to_cpu(dev->descriptor.idProduct);

    id->version = le16_to_cpu(dev->descriptor.bcdDevice);

}

struct usb_device 中有一個成員struct usb_device_descriptor,而struct usb_device_descriptor 中的成員__u16 bcdDevice,表示的是制造商指定的產品的版本號,制造商id 和產品id 來標志一個設備.bcdDevice 一共16 位,是以bcd碼的方式保存的信息,也就是說,每4 位代表一個十進制的數,比如0011 0110 1001 0111 就代表的3697.

       業內為每家公司編一個號,這樣便于管理,比如三星的編號就是0x0839,那么三星的產品中就會在其設備描述符中idVendor 的烙上0x0839.而三星自己的每種產品也會有個編號,和Digimax 410 對應的編號就是0x000a,而bcdDevice_lo 和bcdDevice_hi 共同組成一個具體設備的編號(device release

number),bcd 就意味著這個編號是二進制的格式.

*/

    mouse->dev.dev = &intf->dev;

    if (dev->manufacturer)

        strcat(mouse->name, dev->manufacturer);

    if (dev->product)

        sprintf(mouse->name, "%s %s", mouse->name, dev->product);

    if (!strlen(mouse->name))

        sprintf(mouse->name, "USB HIDBP Mouse %04x:%04x",

            mouse->dev.id.vendor, mouse->dev.id.product);

    usb_fill_int_urb(mouse->irq, dev, pipe, mouse->data,

             (maxp > 8 ? 8 : maxp),

             usb_mouse_irq, mouse, endpoint->bInterval);

/*

static inline 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)

{

    spin_lock_init(&urb->lock);

    urb->dev = dev;

    urb->pipe = pipe;

    urb->transfer_buffer = transfer_buffer;//如果不使用DMA傳輸方式，則使用這個緩沖指針。如何用DMA則使用transfer_DMA，這個值會在后面單獨給URB賦

    urb->transfer_buffer_length = buffer_length;

    urb->complete = complete;

    urb->context = context;

    if (dev->speed == USB_SPEED_HIGH)

        urb->interval = 1 << (interval - 1);

    else

        urb->interval = interval;

    urb->start_frame = -1;

}

此處只是構建好一個urb，在open方法中會實現向usb core遞交urb

*/

    mouse->irq->transfer_dma = mouse->data_dma;

    mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

/*

#define URB_NO_TRANSFER_DMA_MAP 0x0004  //urb->transfer_dma valid on submit

#define URB_NO_SETUP_DMA_MAP    0x0008  //urb->setup_dma valid on submit

,這里是兩個DMA 相關的flag,一個是URB_NO_SETUP_DMA_MAP,而另一個是

URB_NO_TRANSFER_DMA_MAP.注意這兩個是不一樣的,前一個是專門為控制傳輸準備的,因為只有控制傳輸需要有這么一個setup 階段需要準備一個setup packet。

transfer_buffer 是給各種傳輸方式中真正用來數據傳輸的,而setup_packet 僅僅是在控制傳輸中發送setup 的包,控制傳輸除了setup 階段之外,也會有數據傳輸階段,這一階段要傳輸數據還是得靠transfer_buffer,而如果使用dma 方式,那么就是使用transfer_dma.

因為這里使用了mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP,所以應該給urb的transfer_dma賦值。所以用了：mouse->irq->transfer_dma = mouse->data_dma;

*/

    input_register_device(&mouse->dev);

//向input系統注冊input設備

    printk(KERN_INFO "input: %s on %s\n", mouse->name, path);

    usb_set_intfdata(intf, mouse);

/*

usb_set_intfdata().的結果就是使得

%intf->dev->driver_data= mouse,而其它函數中會調用usb_get_intfdata(intf)的作用就是把mouse從中取出來

*/

    return 0;

}

三、            open部分

當應用層打開鼠標設備時，usb_mouse_open將被調用

static int usb_mouse_open(struct input_dev *dev)

{

    struct usb_mouse *mouse = dev->private;

    mouse->irq->dev = mouse->usbdev;

    if (usb_submit_urb(mouse->irq, GFP_KERNEL))

        return -EIO;

//向usb core遞交了在probe中構建好的中斷urb，注意：此處是成功遞交給usb core以后就返回，而不是等到從設備取得鼠標數據。

    return 0;

}

四、            urb回調函數處理部分

當出現傳輸錯誤或獲取到鼠標數據后，urb回調函數將被執行

static void usb_mouse_irq(struct urb *urb, struct pt_regs *regs)

{

    struct usb_mouse *mouse = urb->context;

//在usb_fill_int_urb中有對urb->context賦值

    signed char *data = mouse->data;

    struct input_dev *dev = &mouse->dev;

    int status;

    switch (urb->status) {

    case 0:             /* success */

        break;

    case -ECONNRESET:   /* unlink */

    case -ENOENT:

    case -ESHUTDOWN:

        return;

    /* -EPIPE:  should clear the halt */

    default:        /* error */

        goto resubmit;

    }

    input_regs(dev, regs);

    input_report_key(dev, BTN_LEFT,   data[0] & 0x01);

    input_report_key(dev, BTN_RIGHT,  data[0] & 0x02);

    input_report_key(dev, BTN_MIDDLE, data[0] & 0x04);

    input_report_key(dev, BTN_SIDE,   data[0] & 0x08);

    input_report_key(dev, BTN_EXTRA,  data[0] & 0x10);

//向input系統報告key事件，分別是鼠標LEFT、RIGHT、MIDDLE、SIDE、EXTRA鍵,

static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)中的value非0時表示按下，0表示釋放

    input_report_rel(dev, REL_X,     data[1]);

    input_report_rel(dev, REL_Y,     data[2]);

    input_report_rel(dev, REL_WHEEL, data[3]);

//向input系統報告rel事件，分別是x方向位移、y方向位移、wheel值

    input_sync(dev);

//最后需要向事件接受者發送一個完整的報告。這是input系統的要求。

resubmit:

    status = usb_submit_urb (urb, SLAB_ATOMIC);

//重新遞交urb

    if (status)

        err ("can''t resubmit intr, %s-%s/input0, status %d",

                mouse->usbdev->bus->bus_name,

                mouse->usbdev->devpath, status);

}

五、            應用層測試代碼編寫

在應用層編寫測試鼠標的測試程序，在我的系統中，鼠標設備為/dev/input/event3.

測試代碼如下：

/*

 * usb_mouse_test.c

 *by lht

 */

#include

#include

#include

#include

#include

int main (void)

{

    int fd,i,count;

        struct input_event ev_mouse[2];

    fd = open ("/dev/input/event3",O_RDWR);

    if (fd < 0) {

      printf ("fd open failed\n");

      exit(0);

    }

    printf ("\nmouse opened, fd=%d\n",fd);

        while(1)

        {

        printf("...............................................\n");

            count=read(fd, ev_mouse, sizeof(struct input_event));

        for(i=0;i<(int)count/sizeof(struct input_event);i++)

        {

            printf("type=%d\n",ev_mouse[i].type);

            if(EV_REL==ev_mouse[i].type)

            {

                printf("time:%ld.%d",ev_mouse[i].time.tv_sec,ev_mouse[i].time.tv_usec);

                printf(" type:%d code:%d value:%d\n",ev_mouse[i].type,ev_mouse[i].code,ev_mouse[i].value);

            }

            if(EV_KEY==ev_mouse[i].type)

            {

                printf("time:%ld.%d",ev_mouse[i].time.tv_sec,ev_mouse[i].time.tv_usec);

                printf(" type:%d code:%d value:%d\n",ev_mouse[i].type,ev_mouse[i].code,ev_mouse[i].value);

            }

        }

        }

    close (fd);

    return 0;

}

運行結果如下：

根據type、code、value的值，可以判斷出鼠標的狀態，具體值參考include/linux/input.h