Linux之 USB驱动框架-USB鼠标驱动源码分析(5)

一、usbmouse.c

下面我们分析下USB鼠标驱动，鼠标输入HID类型，其数据传输采用中断URB，鼠标端点类型为IN。好了，我们先看看这个驱动的模块加载部分。

路径：drivers/hid/usbhid/usbmouse.c

static const struct usb_device_id usb_mouse_id_table[] = {
        { USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
                USB_INTERFACE_PROTOCOL_MOUSE) },
        { }     /* Terminating entry */
};
 

static struct usb_driver usb_mouse_driver = {
        .name           = "usbmouse",
        .probe          = usb_mouse_probe,
        .disconnect     = usb_mouse_disconnect,
        .id_table       = usb_mouse_id_table,
};

module_usb_driver(usb_mouse_driver);
//注册usb 接口驱动

 再细细看看USB_INTERFACE_INFO宏的定义

 /**
 * USB_INTERFACE_INFO - macro used to describe a class of usb interfaces
 * @cl: bInterfaceClass value
 * @sc: bInterfaceSubClass value
 * @pr: bInterfaceProtocol value
 *
 * This macro is used to create a struct usb_device_id that matches a
 * specific class of interfaces.
 */
#define USB_INTERFACE_INFO(cl, sc, pr) \
        .match_flags = USB_DEVICE_ID_MATCH_INT_INFO, \
        .bInterfaceClass = (cl), \
        .bInterfaceSubClass = (sc), \
        .bInterfaceProtocol = (pr)

 根据宏，我们知道，我们设置的支持项包括接口类，接口子类，接口协议三个匹配项。

 1.2 USB接口设备的创建

当一个USB 鼠标设备插入后，主机USB控制器检测到后，触发USB设备集线器中的"中断"处理函数hub_irq。在hub_irq中会获取USB鼠标设备的设备描述符，根据设备描述符创建USB接口设备，从而和这边的USB接口驱动匹配，调用其probe函数，通过USB总线驱动程序（USB Core和USB HCD）和USB鼠标设备建立联系，进而操作（读写控制）该设备。

hub_irq->
    kick_hub_wq->// 把hub work压入 hub_wq
       hub_event ->// 处理USB设备插入事件
                port_event-> 

                        hub_port_connect_change->

                                                hub_port_connect->

                                                             hub_port_init->

                                                                    usb_get_device_descriptor// 获取设备描述符

                                                                                                                    
                                                 usb_new_device(udev)->   
                                                       usb_enumerate_device// 把所有的描述符都读出来，并解析
                                                 device_add->  // 把device放入usb_bus_type的dev链表, 
                                                                

 把device放入usb_bus_type的dev链表, 从usb_bus_type的driver链表里取出usb_driver，把usb_interface和usb_driver的id_table比较，如果能匹配，调用usb_driver的probe 

 1.3 USB接口驱动和USB接口设备的匹配

USB设备插入后根据获取到的设备描述符所创建的USB 接口设备和开发的USB接口驱动匹配：
对于设备：
将获取到的USB设备描述符信息保存在其id_table中。
对于驱动：
驱动的id_table中存放，期望该驱动适用的USB设备。

static const struct usb_device_id usb_mouse_id_table[] = {
        { USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
                USB_INTERFACE_PROTOCOL_MOUSE) },
        { }     /* Terminating entry */
};
 

  匹配 HID 设备
    USB 设备中有一大类就是 HID 设备，即 Human Interface Devices，人机接口设备。
    这类设备包括鼠标、键盘等，主要用于人与计算机进行交互。 
    它是 USB 协议最早支持的一种设备类。 
    HID 设备可以作为低速、全速、高速设备用。
    由于 HID 设备要求用户输入能得到及时响应，故其传输方式通常采用中断方式。

 匹配成功后调用该驱动的probe函数；

static int usb_mouse_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
        struct usb_device *dev = interface_to_usbdev(intf);//由接口获取 usb_device 
        struct usb_host_interface *interface;
        struct usb_endpoint_descriptor *endpoint;//端点描述符
        struct usb_mouse *mouse;//本驱动私有结构体
        struct input_dev *input_dev; //输入结构体
        int pipe, maxp;
        int error = -ENOMEM;

        interface = intf->cur_altsetting;//获取设置

        if (interface->desc.bNumEndpoints != 1)            //鼠标端点只有 1个
                return -ENODEV;

        endpoint = &interface->endpoint[0].desc;           //获得端点描述符
        if (!usb_endpoint_is_int_in(endpoint))                //检查该端点是否是中断输入端点
                return -ENODEV;

        pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);   //建立中断输入端点
        maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));//返回端点能传输的最大的数据包，鼠标的返回的最大数据包为 4个字节

        mouse = kzalloc(sizeof(struct usb_mouse), GFP_KERNEL);//分配 mouse结构体
        input_dev = input_allocate_device();  //分配 input设备空间
        if (!mouse || !input_dev)
                goto fail1;

        mouse->data = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &mouse->data_dma);//分配缓冲区

        if (!mouse->data)
                goto fail1;

        mouse->irq = usb_alloc_urb(0, GFP_KERNEL);  //分配 urb
        if (!mouse->irq)
                goto fail2;

        mouse->usbdev = dev;    //填充 mouse的 usb_device结构体
        mouse->dev = input_dev;  //填充 mouse的 input结构体

        if (dev->manufacturer)//拷贝厂商 ID
                strlcpy(mouse->name, dev->manufacturer, sizeof(mouse->name));

        if (dev->product) {//拷贝产品 ID
                if (dev->manufacturer)
                        strlcat(mouse->name, " ", sizeof(mouse->name));
                strlcat(mouse->name, dev->product, sizeof(mouse->name));
        }

        if (!strlen(mouse->name))//拷贝产品 ID
                snprintf(mouse->name, sizeof(mouse->name),
                         "USB HIDBP Mouse %04x:%04x",
                         le16_to_cpu(dev->descriptor.idVendor),
                         le16_to_cpu(dev->descriptor.idProduct));

        usb_make_path(dev, mouse->phys, sizeof(mouse->phys));
        strlcat(mouse->phys, "/input0", sizeof(mouse->phys));

        input_dev->name = mouse->name;//将鼠标名赋给内嵌 input结构体
        input_dev->phys = mouse->phys;//将鼠标设备节点名赋给内嵌 input结构体
        usb_to_input_id(dev, &input_dev->id); //将 usb设备信息拷贝给 input_id
        input_dev->dev.parent = &intf->dev;     //设置父节点

       //evbit表明支持按键事件 (EV_KEY)和相对坐标事件 (EV_REL)             

        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);

         //keybit表明按键值包括左键、右键和中键
        input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
                BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);

        //relbit表明相对坐标事件值包括 X坐标和 Y坐标
        input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);

         //keybit表明除了左键、右键和中键，还支持其他按键
        input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |
                BIT_MASK(BTN_EXTRA);

         //relbit表明除了 X坐标和 Y坐标，还支持中键滚轮的滚动值
        input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);

        input_set_drvdata(input_dev, mouse);//将 mouse设置为 input的私有数据

        input_dev->open = usb_mouse_open;//input设备的 open
        input_dev->close = usb_mouse_close;

        usb_fill_int_urb(mouse->irq, dev, pipe, mouse->data,
                         (maxp > 8 ? 8 : maxp),
                         usb_mouse_irq, mouse, endpoint->bInterval); //填充 urb

        mouse->irq->transfer_dma = mouse->data_dma;
        mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; /使用 transfer_dma

        error = input_register_device(mouse->dev); //注册 input设备
        if (error)
                goto fail3;

        usb_set_intfdata(intf, mouse);
        return 0;

fail3:
        usb_free_urb(mouse->irq);
fail2:
        usb_free_coherent(dev, 8, mouse->data, mouse->data_dma);
fail1:
        input_free_device(input_dev);
        kfree(mouse);
        return error;
}
 

 其实上面这个probe主要是初始化usb设备和input设备，终极目标是为了完成urb的提交和input设备的注册。由于注册为input设备类型，那么当用户层open打开设备时候，最终会调用input中的open实现打开，我们看看input中open的实现。

usb_mouse_open

static int usb_mouse_open(struct input_dev *dev)
{
        struct usb_mouse *mouse = input_get_drvdata(dev);

        mouse->irq->dev = mouse->usbdev;
        if (usb_submit_urb(mouse->irq, GFP_KERNEL))
                return -EIO;

        return 0;
}
 

usb_submit_urb 的调用流程

usb_submit_urb->

               usb_hcd_submit_urb->

                                       ①root hub ->     rh_urb_enqueue

                                       ②非root hub ->  urb_enqueue             

urb_enqueue 的函数实现，以OHCI举例：

urb_enqueue   ->

                ohci_urb_enqueue

当用户层open打开这个USB鼠标后，我们就已经将urb提交给了USB核心，那么根据USB数据处理流程知道，当处理完毕后，USB核心会通知USB设备驱动程序，这里我们是响应中断服务程序，这就相当于该URB的回调函数。我们在提交urb时候定义了中断服务程序usb_mouse_irq，我们跟踪看看

 usb_mouse_irq：

static void usb_mouse_irq(struct urb *urb)
{
        struct usb_mouse *mouse = 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_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_report_rel(dev, REL_X,     data[1]);
        input_report_rel(dev, REL_Y,     data[2]);
        input_report_rel(dev, REL_WHEEL, data[3]);

        input_sync(dev);
resubmit:
        status = usb_submit_urb (urb, GFP_ATOMIC);//再次提交urb，等待下次响应
        if (status)
                dev_err(&mouse->usbdev->dev,
                        "can't resubmit intr, %s-%s/input0, status %d\n",
                        mouse->usbdev->bus->bus_name,
                        mouse->usbdev->devpath, status);
}

根据上面的中断服务程序，我们应该知道，系统是周期性地获取鼠标的事件信息，因此在URB回调函数的末尾再次提交URB请求块，这样又会调用新的回调函数，周而复始。在回调函数中提交URB只能是GFP_ATOMIC优先级，因为URB回调函数运行于中断上下文中禁止导致睡眠的行为。而在提交URB过程中可能会需要申请内存、保持信号量，这些操作或许会导致USB内核睡眠。

看一下 usb_mouse 私有的设备结构体

struct usb_mouse {
        char name[128];//名字
        char phys[64]; //设备节点
        struct usb_device *usbdev; //内嵌usb_device设备
        struct input_dev *dev; //内嵌input_dev设备
        struct urb *irq; //urb结构体指针

        signed char *data;   //transfer_buffer缓冲区
        dma_addr_t data_dma;  // transfer _dma缓冲区
};

 在上面这个结构体中，每一个成员的作用都应该很清楚了，上面使用了内嵌的内核子系统的结构体，这是继承的开发思想。