Linux usb 3. Host 详解

文章目录

• 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 Usb Device Layer

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 Usb Interface Layer

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 的读写来驱动具体的设备功能。

3.1 urb

对某个 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;
}

3.2 normal device urb_enqueue

对普通的 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);
		}
	}

}

3.3 roothub device urb_enqueue

特别需要注意的是 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);
}

3.1 normal hub port op

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

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

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

3.2 rootHub port op

而对于 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 的端口 */
}

3.3 device attach

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->bus, port1);
		if (!udev) {
			dev_err(&port_dev->dev,
					"couldn't allocate usb_device\n");
			goto done;
		}

		/* (2) 给新的 Device 分配一个新的 Address */
		choose_devnum(udev);
		if (udev->devnum <= 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);

	}

}

3.4 device deattach

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 ehci hardware

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 数据即可。

4.2 ehci driver

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