文章目录

• 1. 简介
• 2. Usb Core 驱动设备模型
• * 2.1 Usb Device Layer
  • * 2.1.1 device (struct usb_device)
    • 2.1.2 driver (struct usb_device_driver)
    • 2.1.3 bus (usb_bus_type)
  • 2.2 Usb Interface Layer
  • * 2.2.1 device (struct usb_interface)
    • 2.2.2 driver (struct usb_driver)
    • 2.2.3 bus (usb_bus_type)
• 3. USB Request Block
• * 3.1 urb
  • 3.2 normal device urb_enqueue
  • 3.3 roothub device urb_enqueue
• 3. Usb Hub Driver
• * 3.1 normal hub port op
  • 3.2 rootHub port op
  • 3.3 device attach
  • 3.4 device deattach
• 4. Usb Host Controller Driver
• * 4.1 ehci hardware
  • * 4.1.1 compatible usb1.0
    • 4.1.2 Periodic Schedule
    • 4.1.3 Asynchronous Schedule
  • 4.2 ehci driver
  • * 4.2.1 urb transfer
    • 4.2.2 roothub
• 5. Usb Client Software
• 参考资料

1. 简介

整个 USB 系统的通讯模型如上图所示，本文详细解析其中 Host 各模块的架构和原理 (图中彩色部分)。

2. Usb Core 驱动设备模型

由前几节可知USB将Device进一步细分成了3个层级：Configuration 配置、Interface 接口、Endpoint 端点。

Usb Core 为其中两个层次提供了 Device + Driver 的设备驱动模型，这两个层次分别是 Usb Device Layer 和 Usb Interface Layer 层，一个Usb Device包含一个或多个Usb Interface。其中：

• Usb Device Layer层。这一层的 Device 由 Hub 创建，Hub 本身也是一种 Usb Device；这一层的 Driver 完成的功能非常简单，基本就是帮 Usb Device 创建其包含的所有子 Usb Interface 的 Device，大部分场景下都是使用 usb_generic_driver。
• Usb Interface Layer层。这一层的 Device 由上一级 Usb Device 在驱动 probe() 时创建；而这一层的 Driver 就是普通的业务 Usb 驱动，即 Usb 协议中所说的 Client Software。

2.1.1 device (struct usb_device)

Usb Device Device 对应的数据结构为 struct usb_device，会在两种情况下被创建：

• 1、roothub device。在 HCD 驱动注册时创建：

  /* (1) 首先创建和初始化 usb_device 结构： */
  usb_add_hcd() → usb_alloc_dev():
  struct usb_device *usb_alloc_dev(struct usb_device *parent,
  struct usb_bus *bus, unsigned port1)
  {

  /* (1.1) dev 总线初始化为 usb_bus_type */
  dev->dev.bus = &usb_bus_type;
  /* (1.2) dev 类型初始化为 usb_device_type，标明自己是一个 usb device */
  dev->dev.type = &usb_device_type;
  dev->dev.groups = usb_device_groups;

  }

  /* (2) 然后注册 usb_device 结构： */
  usb_add_hcd() → register_root_hub() → usb_new_device() → device_add()

• 2、普通 usb device。在 Hub 检测到端口有设备 attach 时创建：

  /* (1) 首先创建和初始化 usb_device 结构： */
  hub_event() → port_event() → hub_port_connect_change() → hub_port_connect() → usb_alloc_dev()

  /* (2) 然后注册 usb_device 结构： */
  hub_event() → port_event() → hub_port_connect_change() → hub_port_connect() → usb_new_device() → device_add()

2.1.2 driver (struct usb_device_driver)

Usb Device Driver 对应的数据结构为 struct usb_device_driver，使用 usb_register_device_driver() 函数进行注册：

int usb_register_device_driver(struct usb_device_driver *new_udriver,
        struct module *owner)
{

    /* (1) 设置for_devices标志为1，表面这个驱动时给 usb device 使用的 */
    new_udriver->drvwrap.for_devices = 1;
    new_udriver->drvwrap.driver.name = new_udriver->name;
    new_udriver->drvwrap.driver.bus = &usb_bus_type;
    new_udriver->drvwrap.driver.probe = usb_probe_device;
    new_udriver->drvwrap.driver.remove = usb_unbind_device;
    new_udriver->drvwrap.driver.owner = owner;
    new_udriver->drvwrap.driver.dev_groups = new_udriver->dev_groups;

    retval = driver_register(&new_udriver->drvwrap.driver);

}

注册的 Usb Device Driver 驱动非常少，一般情况下所有的 Usb Device Device 都会适配到 usb_generic_driver。因为这一层次驱动的目的很单纯，就是给 Usb Device 下所有的 Interface 创建对应的 Usb Interface Device。

usb_init() → usb_register_device_driver() :

static int __init usb_init(void)
{

    retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);

}

struct usb_device_driver usb_generic_driver = {
    .name = "usb",
    .match = usb_generic_driver_match,
    .probe = usb_generic_driver_probe,
    .disconnect = usb_generic_driver_disconnect,
#ifdef    CONFIG_PM
    .suspend = usb_generic_driver_suspend,
    .resume = usb_generic_driver_resume,
#endif
    .supports_autosuspend = 1,
};

驱动 probe() 过程：

usb_probe_device() → usb_generic_driver_probe() → usb_set_configuration():

int usb_set_configuration(struct usb_device *dev, int configuration)
{

    /* (1) 创建和初始化 `struct usb_interface` */
    for (i = 0; i < nintf; ++i) {
        /* (1.1) dev 总线初始化为 usb_bus_type */
        intf->dev.bus = &usb_bus_type;
        /* (1.2) dev 类型初始化为 usb_if_device_type，标明自己是一个 usb interface */
        intf->dev.type = &usb_if_device_type;
        intf->dev.groups = usb_interface_groups;
    }

    /* (2) 注册 `struct usb_interface` */
    for (i = 0; i < nintf; ++i) {
        ret = device_add(&intf->dev);
    }

}

2.1.3 bus (usb_bus_type)

可以看到 struct usb_device 和 struct usb_interface 使用的总线都是 usb_bus_type。他们是通过字段 dev.type 来区分的：

/* (1) `struct usb_device` 的 `dev.type` 值为 `usb_device_type`： */
usb_add_hcd() → usb_alloc_dev():
struct usb_device *usb_alloc_dev(struct usb_device *parent,
                 struct usb_bus *bus, unsigned port1)
{
    dev->dev.type = &usb_device_type;
}

/* (2) `struct usb_interface` 的 `dev.type` 值为 `usb_if_device_type` */
usb_probe_device() → usb_generic_driver_probe() → usb_set_configuration():
int usb_set_configuration(struct usb_device *dev, int configuration)
{
    for (i = 0; i < nintf; ++i) {
        intf->dev.type = &usb_if_device_type;
    }
}

static inline int is_usb_device(const struct device *dev)
{
    /* (3) 判断当前 Device 是否为 Usb Device */
    return dev->type == &usb_device_type;
}

static inline int is_usb_interface(const struct device *dev)
{
    /* (4) 判断当前 Device 是否为 Usb Interface */
    return dev->type == &usb_if_device_type;
}

另外 struct usb_device_driver 和 struct usb_driver 使用的总线都是 usb_bus_type。他们是通过字段 drvwrap.for_devices 来区分的：

/* (1) `struct usb_device_driver` 的 `drvwrap.for_devices` 值为 1： */
int usb_register_device_driver(struct usb_device_driver *new_udriver,
        struct module *owner)
{
    new_udriver->drvwrap.for_devices = 1;
}

/* (2) `struct usb_driver` 的 `drvwrap.for_devices` 值为 0： */
int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
            const char *mod_name)
{
    new_driver->drvwrap.for_devices = 0;
}

/* (3) 判断当前 Driver 是适配 Usb Device 还是 Usb Interface */
static inline int is_usb_device_driver(struct device_driver *drv)
{
    return container_of(drv, struct usbdrv_wrap, driver)->
            for_devices;
}

在 usb_bus_type 的 match() 函数中利用 dev.type 进行判别分开处理：

struct bus_type usb_bus_type = {
    .name =     "usb",
    .match =    usb_device_match,
    .uevent =   usb_uevent,
    .need_parent_lock = true,
};

static int usb_device_match(struct device *dev, struct device_driver *drv)
{
    /* devices and interfaces are handled separately */
    /* (1) Device 是 `Usb Device` 的处理 */
    if (is_usb_device(dev)) {
        struct usb_device *udev;
        struct usb_device_driver *udrv;

        /* interface drivers never match devices */
        /* (1.1) 只查找 `Usb Device` 的 Driver */
        if (!is_usb_device_driver(drv))
            return 0;

        udev = to_usb_device(dev);
        udrv = to_usb_device_driver(drv);

        /* If the device driver under consideration does not have a
         * id_table or a match function, then let the driver's probe
         * function decide.
         */
        if (!udrv->id_table && !udrv->match)
            return 1;

        return usb_driver_applicable(udev, udrv);

    /* (2) Device 是 `Usb Interface` 的处理 */
    } else if (is_usb_interface(dev)) {
        struct usb_interface *intf;
        struct usb_driver *usb_drv;
        const struct usb_device_id *id;

        /* device drivers never match interfaces */
        /* (2.1) 只查找 `Usb Interface` 的 Driver */
        if (is_usb_device_driver(drv))
            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;

        id = usb_match_dynamic_id(intf, usb_drv);
        if (id)
            return 1;
    }

    return 0;
}

2.2.1 device (struct usb_interface)

如上一节描述，Usb Interface Device 对应的数据结构为 struct usb_interface，会在 Usb Device Driver 驱动 probe() 时 被创建：

usb_probe_device() → usb_generic_driver_probe() → usb_set_configuration():

int usb_set_configuration(struct usb_device *dev, int configuration)
{

    /* (1) 创建和初始化 `struct usb_interface` */
    for (i = 0; i < nintf; ++i) {
        /* (1.1) dev 总线初始化为 usb_bus_type */
        intf->dev.bus = &usb_bus_type;
        /* (1.2) dev 类型初始化为 usb_if_device_type，标明自己是一个 usb interface */
        intf->dev.type = &usb_if_device_type;
        intf->dev.groups = usb_interface_groups;
    }

    /* (2) 注册 `struct usb_interface` */
    for (i = 0; i < nintf; ++i) {
        ret = device_add(&intf->dev);
    }

}

2.2.2 driver (struct usb_driver)

Usb Interface 这一层次的驱动就非常的多了，这一层主要是在 USB 传输层之上，针对 USB Device 的某个功能 Function 开发对应的 USB 功能业务驱动，即常说的 USB Client Software。在 USB 定义中，一个 Interface 就是一个 Function。

Usb Interface Driver 对应的数据结构为 struct usb_driver，使用 usb_register_driver() 函数进行注册：

int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
            const char *mod_name)
{

    /* (1) 设置for_devices标志为0，表面这个驱动时给 usb interface 使用的 */
    new_driver->drvwrap.for_devices = 0;
    new_driver->drvwrap.driver.name = new_driver->name;
    new_driver->drvwrap.driver.bus = &usb_bus_type;
    new_driver->drvwrap.driver.probe = usb_probe_interface;
    new_driver->drvwrap.driver.remove = usb_unbind_interface;
    new_driver->drvwrap.driver.owner = owner;
    new_driver->drvwrap.driver.mod_name = mod_name;
    new_driver->drvwrap.driver.dev_groups = new_driver->dev_groups;
    spin_lock_init(&new_driver->dynids.lock);
    INIT_LIST_HEAD(&new_driver->dynids.list);

    retval = driver_register(&new_driver->drvwrap.driver);

}

一个最简单的 Usb Interface Driver 是 usb_mouse_driver:

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 */
};
MODULE_DEVICE_TABLE (usb, usb_mouse_id_table);

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);

在后面的章节中会进一步详细分析这个驱动的实现。

2.2.3 bus (usb_bus_type)

Usb Interface 这一层次总线也是 usb_bus_type，上一节已经分析，这里就不重复解析了。

3. USB Request Block

Usb Core 除了提供上一节描述的设备驱动模型以外，另一个重要的作用就是要给 Usb Interface Driver 提供读写 USB 数据的 API，这一任务是围绕着 USB Request Block 来完成的。

Usb Interface Driver 适配成功以后，会从配置信息中获取到当前 Interface 包含了多少个 Endpoint，以及每个 Endpoint 的地址、传输类型、最大包长等其他信息。Endpoint 是 USB 总线传输中最小的寻址单位，Interface Driver 利用对几个 Endpoint 的读写来驱动具体的设备功能。

对某个 Endpoint 发起一次读写操作，具体工作使用 struct urb 数据结构来承担。

以下是一个对 Endpoint 0 使用 urb 发起读写的一个简单实例：

static int usb_internal_control_msg(struct usb_device *usb_dev,
                    unsigned int pipe,
                    struct usb_ctrlrequest *cmd,
                    void *data, int len, int timeout)
{
    struct urb *urb;
    int retv;
    int length;

    /* (1) 分配一个 urb 内存空间 */
    urb = usb_alloc_urb(0, GFP_NOIO);
    if (!urb)
        return -ENOMEM;

    /* (2) 填充 urb 内容，最核心的有3方面：
            1、总线地址：Device Num + Endpoint Num
            2、数据：data + len
            3、回调函数：usb_api_blocking_completion
     */
    usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char *)cmd, data,
                 len, usb_api_blocking_completion, NULL);

    /* (3) 发送 urb 请求，并且等待请求完成 */
    retv = usb_start_wait_urb(urb, timeout, &length);
    if (retv < 0)
        return retv;
    else
        return length;
}

↓

static int usb_start_wait_urb(struct urb *urb, int timeout, int *actual_length)
{
    struct api_context ctx;
    unsigned long expire;
    int retval;

    init_completion(&ctx.done);
    urb->context = &ctx;
    urb->actual_length = 0;
    /* (3.1) 把 urb 请求挂载到 hcd 的队列当中 */
    retval = usb_submit_urb(urb, GFP_NOIO);
    if (unlikely(retval))
        goto out;

    expire = timeout ? msecs_to_jiffies(timeout) : MAX_SCHEDULE_TIMEOUT;
    /* (3.2) 当 urb 执行完成后，首先会调用 urb 的回调函数，然后会发送 completion 信号解除这里的阻塞 */
    if (!wait_for_completion_timeout(&ctx.done, expire)) {
        usb_kill_urb(urb);
        retval = (ctx.status == -ENOENT ? -ETIMEDOUT : ctx.status);

        dev_dbg(&urb->dev->dev,
            "%s timed out on ep%d%s len=%u/%u\n",
            current->comm,
            usb_endpoint_num(&urb->ep->desc),
            usb_urb_dir_in(urb) ? "in" : "out",
            urb->actual_length,
            urb->transfer_buffer_length);
    } else
        retval = ctx.status;
out:
    if (actual_length)
        *actual_length = urb->actual_length;

    usb_free_urb(urb);
    return retval;
}

对普通的 Usb device 来说，urb 最后会提交到 Host Controller 的收发队列上面，由 HC 完成实际的 USB 传输：

usb_submit_urb() → usb_hcd_submit_urb():

int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
{

    /* (1) 如果是 roothub 走特殊的路径 */
    if (is_root_hub(urb->dev)) {
        status = rh_urb_enqueue(hcd, urb);
    /* (2) 如果是普通 device 调用对应的 hcd 的 urb_enqueue() 函数 */
    } else {
        status = map_urb_for_dma(hcd, urb, mem_flags);
        if (likely(status == 0)) {
            status = hcd->driver->urb_enqueue(hcd, urb, mem_flags);
            if (unlikely(status))
                unmap_urb_for_dma(hcd, urb);
        }
    }

}

特别需要注意的是 roothub 它是一个虚拟的 usb device，实际上它并不在usb总线上而是在 host 内部，所以相应的 urb 需要特殊处理，而不能使用 hcd 把数据发送到 Usb 总线上去。

usb_submit_urb() → usb_hcd_submit_urb() → rh_urb_enqueue():

static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
{
    /* (1) 对于 int 类型的数据，被挂载到 hcd->status_urb 指针上面
            通常 roothub 驱动用这个 urb 来查询 roothub 的端口状态
     */
    if (usb_endpoint_xfer_int(&urb->ep->desc))
        return rh_queue_status (hcd, urb);

    /* (2) 对于 control 类型的数据，是想读取 roothub ep0 上的配置信息
            使用软件来模拟这类操作的响应
     */
    if (usb_endpoint_xfer_control(&urb->ep->desc))
        return rh_call_control (hcd, urb);
    return -EINVAL;
}

|→

static int rh_queue_status (struct usb_hcd *hcd, struct urb *urb)
{

    /* (1.1) 将 urb 挂载到对应的 ep 链表中 */
    retval = usb_hcd_link_urb_to_ep(hcd, urb);
    if (retval)
        goto done;

    /* (1.2) 将 urb 赋值给 hcd->status_urb
            在 hcd 驱动中，会通过这些接口来通知 roothub 的端口状态变化
     */
    hcd->status_urb = urb;
    urb->hcpriv = hcd;  /* indicate it's queued */
    if (!hcd->uses_new_polling)
        mod_timer(&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));

}

|→

static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
{
    /* (2.1) 软件模拟对 roothub 配置读写的响应 */
}

3. Usb Hub Driver

普通的 Usb Device 通过内部的 Interface 提供各种业务功能。而 Hub 这类特殊的 Usb Device 功能就一种，那就是监控端口的状态变化：

• 在端口上有设备 attach 时，创建新的 usb device，给其适配驱动。如果是 hub device，子 usb 驱动会进一步扫描端口。
• 在端口上有设备 deattach 时，移除掉对应的 usb device。如果是 hub device 进一步移除其所有的子 usb device。

Hub 也是标准的 Usb Device，它也是标准的流程被上一级设备发现后创建 Usb Device → 创建 Usb Interface，然后被 Usb Hub Interface Driver 给适配到。系统中只有一个 Hub 驱动：

static const struct usb_device_id hub_id_table[] = {
    { .match_flags = USB_DEVICE_ID_MATCH_VENDOR
                   | USB_DEVICE_ID_MATCH_PRODUCT
                   | USB_DEVICE_ID_MATCH_INT_CLASS,
      .idVendor = USB_VENDOR_SMSC,
      .idProduct = USB_PRODUCT_USB5534B,
      .bInterfaceClass = USB_CLASS_HUB,
      .driver_info = HUB_QUIRK_DISABLE_AUTOSUSPEND},
    { .match_flags = USB_DEVICE_ID_MATCH_VENDOR
            | USB_DEVICE_ID_MATCH_INT_CLASS,
      .idVendor = USB_VENDOR_GENESYS_LOGIC,
      .bInterfaceClass = USB_CLASS_HUB,
      .driver_info = HUB_QUIRK_CHECK_PORT_AUTOSUSPEND},
    { .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
      .bDeviceClass = USB_CLASS_HUB},
    { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
      .bInterfaceClass = USB_CLASS_HUB},
    { }                        /* Terminating entry */
};

MODULE_DEVICE_TABLE(usb, hub_id_table);

static struct usb_driver hub_driver = {
    .name =     "hub",
    .probe =    hub_probe,
    .disconnect =   hub_disconnect,
    .suspend =  hub_suspend,
    .resume =   hub_resume,
    .reset_resume = hub_reset_resume,
    .pre_reset =    hub_pre_reset,
    .post_reset =   hub_post_reset,
    .unlocked_ioctl = hub_ioctl,
    .id_table = hub_id_table,
    .supports_autosuspend = 1,
};

hub_driver 驱动启动以后，只做一件事情发送一个查询端口状态的 urb ：

hub_probe() → hub_configure():

static int hub_configure(struct usb_hub *hub,
    struct usb_endpoint_descriptor *endpoint)
{

    /* (1) 分配 urb */
    hub->urb = usb_alloc_urb(0, GFP_KERNEL);
    if (!hub->urb) {
        ret = -ENOMEM;
        goto fail;
    }

    /* (2) 初始化 urb，作用就是通过 ep0 查询 hub 的端口状态
            urb 的回调函数是 hub_irq()
     */
    usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
        hub, endpoint->bInterval);

    /* (3) 发送 urb */
    hub_activate(hub, HUB_INIT);

}

↓

static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
{
    /*  (3.1) 提交 urb */
    status = usb_submit_urb(hub->urb, GFP_NOIO);
}

在普通的 hub 中，端口操作是通过标准的 urb 发起 usb ep0 读写。分为两类：

• 1、通过轮询读取 Hub Class-specific Requests 配置来查询端口的状态：
  

• 2、设置和使能端口也是通过 Hub Class-specific Requests 中相应的命令实现的：
  

而对于 roothub 来说，对端口的操作的 urb 都需要特殊处理 (以 EHCI 的驱动为例)：

• 1、端口状态的变化可以通过 HCD 触发中断再上报：

  ehci_irq() → usb_hcd_poll_rh_status() :

  void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
  {

  /* (1) 获取端口状态的变化 */
  length = hcd->driver->hub_status_data(hcd, buffer);
  if (length > 0) {
  /* try to complete the status urb */
  spin_lock_irqsave(&hcd_root_hub_lock, flags);
  
  /* (2) 通过回复 hcd->status_urb 来进行上报 */
  urb = hcd->status_urb;
  if (urb) {
      clear_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
      hcd->status_urb = NULL;
      urb->actual_length = length;
      memcpy(urb->transfer_buffer, buffer, length);
  
      usb_hcd_unlink_urb_from_ep(hcd, urb);
      usb_hcd_giveback_urb(hcd, urb, 0);
  } else {
      length = 0;
      set_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
  }
  spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
  }

  }

  ↓

  hcd->driver->hub_status_data() → ehci_hub_status_data():

  static int
  ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
  {
  /* (1.1) 通过 HCD 驱动，获取 roothub 端口的状态 */
  }

• 2、设置和使能端口需要嫁接到 HCD 驱动相关函数上实现：

  usb_hcd_submit_urb() → rh_urb_enqueue() → rh_call_control() → hcd->driver->hub_control() → ehci_hub_control():

  int ehci_hub_control(
  struct usb_hcd *hcd,
  u16 typeReq,
  u16 wValue,
  u16 wIndex,
  char *buf,
  u16 wLength
  ) {
  /* (1) 通过 HCD 驱动，设置 roothub 的端口 */
  }

  hub_event() → port_event() → hub_port_connect_change() → hub_port_connect():

  static void hub_port_connect(struct usb_hub *hub, int port1, u16 portstatus,
  u16 portchange)
  {

  for (i = 0; i < PORT_INIT_TRIES; i++) {
  /* (1) 给端口上新 Device 分配 `struct usb_device` 数据结构 */
  udev = usb_alloc_dev(hdev, hdev-&gt;bus, port1);
  if (!udev) {
      dev_err(&amp;port_dev-&gt;dev,
              "couldn't allocate usb_device\n");
      goto done;
  }
  
  /* (2) 给新的 Device 分配一个新的 Address */
  choose_devnum(udev);
  if (udev-&gt;devnum &lt;= 0) {
      status = -ENOTCONN; /* Don't retry */
      goto loop;
  }
  
  /* reset (non-USB 3.0 devices) and get descriptor */
  usb_lock_port(port_dev);
  /* (3) 使能端口，并且调用 hub_set_address() 给 Device 配置上新分配的 Address */
  status = hub_port_init(hub, udev, port1, i);
  usb_unlock_port(port_dev);
  
  /* (4) 注册 `struct usb_device` */
      status = usb_new_device(udev);
  }

  }

  hub_event() → port_event() → hub_port_connect_change() → hub_port_connect():

  static void hub_port_connect(struct usb_hub *hub, int port1, u16 portstatus,
  u16 portchange)
  {

  /* (1) 移除端口上的 `struct usb_device` */
  if (udev) {
      if (hcd->usb_phy && !hdev->parent)
          usb_phy_notify_disconnect(hcd->usb_phy, udev->speed);
      usb_disconnect(&port_dev->child);
  }

  }

4. Usb Host Controller Driver

Usb Host Controller 是主机侧的硬件实现，主要分为以下种类：

• Usb1.0 有两种控制器标准：OHCI 康柏的开放主机控制器接口，UHCI Intel的通用主机控制器接口。它们的主要区别是UHCI更加依赖软件驱动，因此对CPU要求更高，但是自身的硬件会更廉价。
• Usb2.0 只有一种控制器标准：EHCI。因为 EHCI 只支持高速传输，所以EHCI控制器包括四个虚拟的全速或者慢速控制器。EHCI主要用于usb 2.0，老的Usb1.1用OHCI和UHCI。EHCI为了兼容Usb1.1，将老的OHCI和UHCI合并到EHCI规范里。
• Usb3.0 控制器标准：XHCI。XHCI是Intel最新开发的主机控制器接口，广泛用户Intel六代Skylake处理器对应的100系列主板上，支持USB3.0接口，往下也兼容USB2.0。XHCI英文全称eXtensible Host Controller Interface，是一种可扩展的主机控制器接口，是Intel开发的USB主机控制器。Intel 系列芯片的USB协议采用的就是XHCI主控，主要面向USB 3.0标准的，同时也兼容2.0以下的设备。

我们以应用最广泛的 EHCI 为例，分析其软硬件实现的架构。

4.1.1 compatible usb1.0

对 EHCI 来说，它向下兼容的方案是非常有特点的。因为 EHCI 只支持 Usb2.0 高速传输，为了向下兼容 Usb1.1，它直接在内部集成最多4个全速或者慢速控制器 OHCI。在 EHCI 协议内称这种伴生的 OHCI 控制器为 companion host controllers。

由 EHCI 驱动根据端口速率情况来决定由谁来处理：

• 每个端口有一个 Owner 属性，用来决定是 EHCI 管理还是 OHCI 管理。就是一个 Switch 开关，决定 USB 数据切到哪边处理。
• 初始状态时端口默认属于 OHCI 管理。所以对于硬件上从 OHCI 升级到 EHCI，而软件上只有 OHCI 驱动而没有 EHCI 驱动的系统来说是透明的，它继续把 EHCI 当成 OHCI 硬件来使用就行了，保持完美的向前兼容。
• 如果系统软件上启用了 EHCI 驱动，它首先会把所有端口的Owner配置成 EHCI 管理。如果 EHCI 驱动发现端口连接且速率是全速或者慢速，则把端口的Owner配置成 OHCI 管理。

对于 EHCI 这种包含两种控制器的兼容方式，软件上需要同时启动 EHCI Driver 和 OHCI Driver，才能完整的兼容 Usb1.0 和 Usb2.0：

4.1.2 Periodic Schedule

EHCI 把数据传输分成了两类来进行调度：

• Periodic Schedule。用来传输对时间延迟要求高的 Endpoint 数据，包括 Isochronous Transfer 和 Interrupt Transfer。

• Asynchronous Schedule。用来传输对时间延迟要求不高的 Endpoint 数据，包括 Control Transfer 和 Bulk Transfer。
  
  Periodic Schedule 内部实现如上图所示，核心是两级链表：

• 1、第一级链表如上图绿色所示。是各种传输结构的实际描述符，主要包含以下几种类型的描述符：
  

• 2、第二级链表如上图橙色所示。是一个指针数组，数组中保存的是指向第一级链表的指针。这里每个数组成员代表一个时间分片 Frame/Micro-Frame 的起始位置，每个时间片会根据指针传输第一级链表中的数据，直到第一级链表的结尾。指针的格式如下：
  

这里的调度思想就是：第一级链表是一个传输数据全集，第二级链表决定了某个时间片里要传输的数据。这样合理的安排二级链表的指针，比如间隔8次指向同一位置这部分数据的interval就是8，间隔4次指向同一位置这部分数据的interval就是4。 第一级链表也是要根据interval排序的。

Periodic Schedule 中几个核心的描述符如下：

• 1、Isochronous (High-Speed) Transfer Descriptor (iTD)
  
• 2、Queue Head
  
• 2.1、Queue Element Transfer Descriptor (qTD)
  

4.1.3 Asynchronous Schedule

Asynchronous Schedule 内部实现非常的简单就只有一级链表，链表中只有Queue Head类型的描述符。每个时间片内传输完 Period 数据以后，再尽可能的传输 Asynchronous 数据即可。

ehci driver 负责把 echi 功能封装成标准的 hcd 驱动。它主要完成两项工作：

• 1、注册标准的 hcd 驱动。把 Client Software 传说下来的 urb 映射到 EHCI 的链表中进行传输。

• 2、创建一个虚拟的根 hub 设备，即 roothub。

4.2.1 urb transfer

ehci 注册 hcd 驱动：

static int ehci_platform_probe(struct platform_device *dev)
{

    /* (1) 分配 hcd，并且把 hcd->driver 初始化成 ehci_hc_driver */
    ehci_init_driver(&ehci_platform_hc_driver, &platform_overrides);
    hcd = usb_create_hcd(&ehci_platform_hc_driver, &dev->dev,
                 dev_name(&dev->dev));

    /* (2) 注册标准的 hcd 驱动 */
    err = usb_add_hcd(hcd, irq, IRQF_SHARED);
}

hcd 驱动向上提供了标准接口，最终的实现会调用到 ehci_hc_driver 当中。

static const struct hc_driver ehci_hc_driver = {
    .description =      hcd_name,
    .product_desc =     "EHCI Host Controller",
    .hcd_priv_size =    sizeof(struct ehci_hcd),

    /*
     * generic hardware linkage
     */
    .irq =          ehci_irq,
    .flags =        HCD_MEMORY | HCD_DMA | HCD_USB2 | HCD_BH,

    /*
     * basic lifecycle operations
     */
    .reset =        ehci_setup,
    .start =        ehci_run,
    .stop =         ehci_stop,
    .shutdown =     ehci_shutdown,

    /*
     * managing i/o requests and associated device resources
     */
    .urb_enqueue =      ehci_urb_enqueue,
    .urb_dequeue =      ehci_urb_dequeue,
    .endpoint_disable = ehci_endpoint_disable,
    .endpoint_reset =   ehci_endpoint_reset,
    .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,

    /*
     * scheduling support
     */
    .get_frame_number = ehci_get_frame,

    /*
     * root hub support
     */
    .hub_status_data =  ehci_hub_status_data,
    .hub_control =      ehci_hub_control,
    .bus_suspend =      ehci_bus_suspend,
    .bus_resume =       ehci_bus_resume,
    .relinquish_port =  ehci_relinquish_port,
    .port_handed_over = ehci_port_handed_over,
    .get_resuming_ports =   ehci_get_resuming_ports,

    /*
     * device support
     */
    .free_dev =     ehci_remove_device,
};

在 urb transfer 过程中，最核心的是调用上述的 ehci_urb_enqueue() 和 ehci_urb_dequeue() 函数。

4.2.2 roothub

首先创建虚拟的 roothub:

/* (1) 首先创建和初始化 `usb_device` 结构： */
ehci_platform_probe() → usb_add_hcd() → usb_alloc_dev():
struct usb_device *usb_alloc_dev(struct usb_device *parent,
                 struct usb_bus *bus, unsigned port1)
{

    /* (1.1) dev 总线初始化为 usb_bus_type */
    dev->dev.bus = &usb_bus_type;
    /* (1.2) dev 类型初始化为 usb_device_type，标明自己是一个 usb device */
    dev->dev.type = &usb_device_type;
    dev->dev.groups = usb_device_groups;

}

/* (2) 然后注册  `usb_device` 结构： */
usb_add_hcd() → register_root_hub() → usb_new_device() → device_add()

然后因为 roothub 并不是在 Usb 物理总线上，所以对它的查询和配置需要特殊处理。详见Usb Hub Driver这一节。

5. Usb Client Software

这里再详细分析一下典型的 Usb Client Software 即 usb mouse 驱动，看看它是怎么利用 urb 读取 usb 设备数据的。

static const struct usb_device_id usb_mouse_id_table[] = {
    /* (1) 驱动可以适配的 interface 列表 */
    { USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
        USB_INTERFACE_PROTOCOL_MOUSE) },
    { } /* Terminating entry */
};

MODULE_DEVICE_TABLE (usb, usb_mouse_id_table);

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);

• 1、首先根据得到的 endpoint 准备好 urb，创建好 input 设备：

  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;
  struct input_dev *input_dev;
  int pipe, maxp;
  int error = -ENOMEM;

  interface = intf->cur_altsetting;
  
  if (interface->desc.bNumEndpoints != 1)
      return -ENODEV;
  
  /* (1) 得到当前 interface 中的第一个 endpoint，mouse设备只需一个 endpoint */
  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));
  
  mouse = kzalloc(sizeof(struct usb_mouse), GFP_KERNEL);
  /* (2.1) 分配 input device */
  input_dev = input_allocate_device();
  if (!mouse || !input_dev)
      goto fail1;
  
  mouse->data = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &mouse->data_dma);
  if (!mouse->data)
      goto fail1;
  
  /* (3.1) 分配 urb */
  mouse->irq = usb_alloc_urb(0, GFP_KERNEL);
  if (!mouse->irq)
      goto fail2;
  
  mouse->usbdev = dev;
  mouse->dev = input_dev;
  
  if (dev->manufacturer)
      strlcpy(mouse->name, dev->manufacturer, sizeof(mouse->name));
  
  if (dev->product) {
      if (dev->manufacturer)
          strlcat(mouse->name, " ", sizeof(mouse->name));
      strlcat(mouse->name, dev->product, sizeof(mouse->name));
  }
  
  if (!strlen(mouse->name))
      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));
  
  /* (2.2) 初始化 input device */
  input_dev->name = mouse->name;
  input_dev->phys = mouse->phys;
  usb_to_input_id(dev, &input_dev->id);
  input_dev->dev.parent = &intf->dev;
  
  input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
  input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
      BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
  input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
  input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |
      BIT_MASK(BTN_EXTRA);
  input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);
  
  input_set_drvdata(input_dev, mouse);
  
  input_dev->open = usb_mouse_open;
  input_dev->close = usb_mouse_close;
  
  /* (3.2) 初始化 urb */
  usb_fill_int_urb(mouse->irq, dev, pipe, mouse->data,
           (maxp > 8 ? 8 : maxp),
           usb_mouse_irq, mouse, endpoint->bInterval);
  mouse->irq->transfer_dma = mouse->data_dma;
  mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  
  /* (2.3) 注册 input device */
  error = input_register_device(mouse->dev);
  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;
  }

• 2、在 input device 被 open 时提交 urb 启动传输：

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

  mouse->irq->dev = mouse->usbdev;
  /* (1) 提交初始化好的 usb，开始查询数据 */
  if (usb_submit_urb(mouse->irq, GFP_KERNEL))
      return -EIO;
  
  return 0;

  }

• 3、在传输完 urb 的回调函数中，根据读回的数据上报 input 事件，并且重新提交 urb 继续查询：

  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;
  }
  
  /* (1) 根据 urb 读回的数据，上报 input event */
  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:
  /* (2) 重新提交 urb 继续查询 */
  status = usb_submit_urb (urb, GFP_ATOMIC);
  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);
  }

参考资料

1.Enhanced Host Controller Interface Specification
2.USB 2.0 Specification