Linux那些事儿 之 戏说USB(25)设备的生命线(八)

回到struct usb_hcd，继续努力的往下看。

7行，又见kref，usb主机控制器的引用计数。struct usb_hcd也有自己专用的引用计数函数，看drivers/usb/core/hcd.c文件

static void hcd_release(struct kref *kref)
{
	struct usb_hcd *hcd = container_of (kref, struct usb_hcd, kref);

	mutex_lock(&usb_port_peer_mutex);
	if (usb_hcd_is_primary_hcd(hcd))
		kfree(hcd->bandwidth_mutex);
	if (hcd->shared_hcd) {
		struct usb_hcd *peer = hcd->shared_hcd;

		peer->shared_hcd = NULL;
		if (peer->primary_hcd == hcd)
			peer->primary_hcd = NULL;
	}
	mutex_unlock(&usb_port_peer_mutex);
	kfree(hcd);
}

struct usb_hcd *usb_get_hcd (struct usb_hcd *hcd)
{
	if (hcd)
		kref_get (&hcd->kref);
	return hcd;
}
EXPORT_SYMBOL_GPL(usb_get_hcd);

void usb_put_hcd (struct usb_hcd *hcd)
{
	if (hcd)
		kref_put (&hcd->kref, hcd_release);
}
EXPORT_SYMBOL_GPL(usb_put_hcd);

和struct urb的那几个长的也忒像了，像的俺都不好意思多介绍它们了，如果不明白就回去看看聊struct urb的时候怎么说的吧。
9行，product_desc，主机控制器的产品描述字符串，对于UHCI，它为“UHCI Host Controller”，对于EHCI，它为“EHCI Host Controller”。
14行，irq_descr[24]，这里边儿保存的是“ehci-hcd:usb1”之类的字符串，也就是驱动的大名再加上总线编号。
18~20行，电源管理的，飘过。
25行，driver，每个男人心中都有一个狐狸精，每个女人心里都有一个洛丽塔，每个主机控制器驱动都有一个struct hc_driver结构体。看看它在hcd.h里的定义

struct hc_driver {
	const char	*description;	/* "ehci-hcd" etc */
	const char	*product_desc;	/* product/vendor string */
	size_t		hcd_priv_size;	/* size of private data */

	/* irq handler */
	irqreturn_t	(*irq) (struct usb_hcd *hcd);

	int	flags;
#define	HCD_MEMORY	0x0001		/* HC regs use memory (else I/O) */
#define	HCD_LOCAL_MEM	0x0002		/* HC needs local memory */
#define	HCD_SHARED	0x0004		/* Two (or more) usb_hcds share HW */
#define	HCD_USB11	0x0010		/* USB 1.1 */
#define	HCD_USB2	0x0020		/* USB 2.0 */
#define	HCD_USB25	0x0030		/* Wireless USB 1.0 (USB 2.5)*/
#define	HCD_USB3	0x0040		/* USB 3.0 */
#define	HCD_MASK	0x0070
#define	HCD_BH		0x0100		/* URB complete in BH context */

	/* called to init HCD and root hub */
	int	(*reset) (struct usb_hcd *hcd);
	int	(*start) (struct usb_hcd *hcd);

	/* NOTE:  these suspend/resume calls relate to the HC as
	 * a whole, not just the root hub; they're for PCI bus glue.
	 */
	/* called after suspending the hub, before entering D3 etc */
	int	(*pci_suspend)(struct usb_hcd *hcd, bool do_wakeup);

	/* called after entering D0 (etc), before resuming the hub */
	int	(*pci_resume)(struct usb_hcd *hcd, bool hibernated);

	/* cleanly make HCD stop writing memory and doing I/O */
	void	(*stop) (struct usb_hcd *hcd);

	/* shutdown HCD */
	void	(*shutdown) (struct usb_hcd *hcd);

	/* return current frame number */
	int	(*get_frame_number) (struct usb_hcd *hcd);

	/* manage i/o requests, device state */
	int	(*urb_enqueue)(struct usb_hcd *hcd,
				struct urb *urb, gfp_t mem_flags);
	int	(*urb_dequeue)(struct usb_hcd *hcd,
				struct urb *urb, int status);

	/*
	 * (optional) these hooks allow an HCD to override the default DMA
	 * mapping and unmapping routines.  In general, they shouldn't be
	 * necessary unless the host controller has special DMA requirements,
	 * such as alignment contraints.  If these are not specified, the
	 * general usb_hcd_(un)?map_urb_for_dma functions will be used instead
	 * (and it may be a good idea to call these functions in your HCD
	 * implementation)
	 */
	int	(*map_urb_for_dma)(struct usb_hcd *hcd, struct urb *urb,
				   gfp_t mem_flags);
	void    (*unmap_urb_for_dma)(struct usb_hcd *hcd, struct urb *urb);

	/* hw synch, freeing endpoint resources that urb_dequeue can't */
	void	(*endpoint_disable)(struct usb_hcd *hcd,
			struct usb_host_endpoint *ep);

	/* (optional) reset any endpoint state such as sequence number
	   and current window */
	void	(*endpoint_reset)(struct usb_hcd *hcd,
			struct usb_host_endpoint *ep);

	/* root hub support */
	int	(*hub_status_data) (struct usb_hcd *hcd, char *buf);
	int	(*hub_control) (struct usb_hcd *hcd,
				u16 typeReq, u16 wValue, u16 wIndex,
				char *buf, u16 wLength);
	int	(*bus_suspend)(struct usb_hcd *);
	int	(*bus_resume)(struct usb_hcd *);
	int	(*start_port_reset)(struct usb_hcd *, unsigned port_num);

		/* force handover of high-speed port to full-speed companion */
	void	(*relinquish_port)(struct usb_hcd *, int);
		/* has a port been handed over to a companion? */
	int	(*port_handed_over)(struct usb_hcd *, int);

		/* CLEAR_TT_BUFFER completion callback */
	void	(*clear_tt_buffer_complete)(struct usb_hcd *,
				struct usb_host_endpoint *);

	/* xHCI specific functions */
		/* Called by usb_alloc_dev to alloc HC device structures */
	int	(*alloc_dev)(struct usb_hcd *, struct usb_device *);
		/* Called by usb_disconnect to free HC device structures */
	void	(*free_dev)(struct usb_hcd *, struct usb_device *);
	/* Change a group of bulk endpoints to support multiple stream IDs */
	int	(*alloc_streams)(struct usb_hcd *hcd, struct usb_device *udev,
		struct usb_host_endpoint **eps, unsigned int num_eps,
		unsigned int num_streams, gfp_t mem_flags);
	/* Reverts a group of bulk endpoints back to not using stream IDs.
	 * Can fail if we run out of memory.
	 */
	int	(*free_streams)(struct usb_hcd *hcd, struct usb_device *udev,
		struct usb_host_endpoint **eps, unsigned int num_eps,
		gfp_t mem_flags);

	/* Bandwidth computation functions */
	/* Note that add_endpoint() can only be called once per endpoint before
	 * check_bandwidth() or reset_bandwidth() must be called.
	 * drop_endpoint() can only be called once per endpoint also.
	 * A call to xhci_drop_endpoint() followed by a call to
	 * xhci_add_endpoint() will add the endpoint to the schedule with
	 * possibly new parameters denoted by a different endpoint descriptor
	 * in usb_host_endpoint.  A call to xhci_add_endpoint() followed by a
	 * call to xhci_drop_endpoint() is not allowed.
	 */
		/* Allocate endpoint resources and add them to a new schedule */
	int	(*add_endpoint)(struct usb_hcd *, struct usb_device *,
				struct usb_host_endpoint *);
		/* Drop an endpoint from a new schedule */
	int	(*drop_endpoint)(struct usb_hcd *, struct usb_device *,
				 struct usb_host_endpoint *);
		/* Check that a new hardware configuration, set using
		 * endpoint_enable and endpoint_disable, does not exceed bus
		 * bandwidth.  This must be called before any set configuration
		 * or set interface requests are sent to the device.
		 */
	int	(*check_bandwidth)(struct usb_hcd *, struct usb_device *);
		/* Reset the device schedule to the last known good schedule,
		 * which was set from a previous successful call to
		 * check_bandwidth().  This reverts any add_endpoint() and
		 * drop_endpoint() calls since that last successful call.
		 * Used for when a check_bandwidth() call fails due to resource
		 * or bandwidth constraints.
		 */
	void	(*reset_bandwidth)(struct usb_hcd *, struct usb_device *);
		/* Returns the hardware-chosen device address */
	int	(*address_device)(struct usb_hcd *, struct usb_device *udev);
		/* prepares the hardware to send commands to the device */
	int	(*enable_device)(struct usb_hcd *, struct usb_device *udev);
		/* Notifies the HCD after a hub descriptor is fetched.
		 * Will block.
		 */
	int	(*update_hub_device)(struct usb_hcd *, struct usb_device *hdev,
			struct usb_tt *tt, gfp_t mem_flags);
	int	(*reset_device)(struct usb_hcd *, struct usb_device *);
		/* Notifies the HCD after a device is connected and its
		 * address is set
		 */
	int	(*update_device)(struct usb_hcd *, struct usb_device *);
	int	(*set_usb2_hw_lpm)(struct usb_hcd *, struct usb_device *, int);
	/* USB 3.0 Link Power Management */
		/* Returns the USB3 hub-encoded value for the U1/U2 timeout. */
	int	(*enable_usb3_lpm_timeout)(struct usb_hcd *,
			struct usb_device *, enum usb3_link_state state);
		/* The xHCI host controller can still fail the command to
		 * disable the LPM timeouts, so this can return an error code.
		 */
	int	(*disable_usb3_lpm_timeout)(struct usb_hcd *,
			struct usb_device *, enum usb3_link_state state);
	int	(*find_raw_port_number)(struct usb_hcd *, int);
};

和usb_driver一样，和pci_driver也一样，所有的xxx_driver都有一堆函数指针，具体的主机控制器驱动就靠它们来活的，不多说了，太深入了，做人要懂得适可而止，这里只说下函数指针之外的东西，也就是开头儿的那三个。description直白点说就是驱动的大名，比如对于UHCI，它是“uhci_hcd”，对于EHCI，它就是“ehci_hcd”。product_desc和struct usb_hcd里的那个是一个样儿。hcd_priv_size还是有点儿意思的，前面喝那杯茶的时候提到过，每个主机控制器驱动都会有一个私有结构体，藏在struct usb_hcd最后的那个变长数组里，这个变也是相对的，在创建usb_hcd的时候也得知道它能变多长，不然谁知道要申请多少内存啊，这个长度就hcd_priv_size。

38行，flags，属于HCD的一些标志，可用值就在39~44行。它们什么意思？书到用时方恨少，flags到用时才可知。

16，17，57~64，这几行都是专为root hub服务的。佛说，一花一世界，一叶一如来。一个host controller对应一个root hub，即使某些嵌入式系统里，硬件上host controller没有集成root hub，软件上也需要虚拟一个出来，也就是所谓的virtual root hub。它位置是特殊的，但需要提供的功能和其它hub是没有什么差别的，仅仅是在和host controller的软硬件接口上有一些特别的规定。root hub再怎么特别也始终是一个hub，是一个usb设备，也不能脱离usb这个大家庭，也要向组织注册，也要有自己的设备生命线，既然这里遇到了，就说说它的这条线。

/*------------------------------------------root hub的生命线-------------------------------------------------

还是要先声明一下，root hub的生命线只是咱们的主线里的一个岔路口，不会沿着它去仔细的走，只会尽量的使用快镜头去展示一下。如果有哪里不明白，等走完了那条主线，你再回过头来看看，很多事情都是在我们蓦然回首的时候才明白的。

基于root hub和host controller这种极为暧昧极为特殊的关系，UHCI、EHCI等主机控制器驱动程序在自己的初始化代码里都有大量的篇幅大量的心思花在root hub上面。不管是UHCI，还是EHCI，一般来说都是PCI设备，是PCI设备都应该有个struct pci_driver结构体，都应该有一个属于自己的probe。在这个probe里，也都会调用usb_create_hcd()来创建一个属于自己的usb_hcd，也都会调用usb_add_hcd()将这个刚刚创建的usb_hcd注册到usb组织里。于是root hub便披着皇帝的新装，走着猫步登场了。这里只贴与root hub相关的一些主要代码

drivers/usb/core/hcd.c

	if ((rhdev = usb_alloc_dev(NULL, &hcd->self, 0)) == NULL) {
		dev_err(hcd->self.controller, "unable to allocate root hub\n");
		retval = -ENOMEM;
		goto err_allocate_root_hub;
	}
	mutex_lock(&usb_port_peer_mutex);
	hcd->self.root_hub = rhdev;
	mutex_unlock(&usb_port_peer_mutex);

	switch (hcd->speed) {
	case HCD_USB11:
		rhdev->speed = USB_SPEED_FULL;
		break;
	case HCD_USB2:
		rhdev->speed = USB_SPEED_HIGH;
		break;
	case HCD_USB25:
		rhdev->speed = USB_SPEED_WIRELESS;
		break;
	case HCD_USB3:
		rhdev->speed = USB_SPEED_SUPER;
		break;
	default:
		retval = -EINVAL;
		goto err_set_rh_speed;
	}

在usb_add_hcd函数里，首先会调用咱们已经亲密接触过的usb_alloc_dev()来为root hub准备一个struct usb_device结构体，我唯一想再提一下的是这时root hub的设备类型被赋值为usb_device_type，所属总线类型赋值为usb_bus_type。然后根据各个host controller的实际情况，设定它的速度。struct usb_device结构体准备妥当之后，就要赋给struct usb_bus的root_hub元素。这些都只不过是准备工作，重头戏都在usb_add_hcd()最后调用的register_root_hub()里面。

register_root_hub()非常肯定的将root hub的设备号devnum设置为1，于是就少了选择地址设置地址的过程，root hub直接跳跃式发展进入了Address状态，咱们耗费几代人，期待数十年才能完成的壮举，root hub轻而易举的就实现了。当然，是个人都知道在Address状态是好处多多便利多多的，不然房地产就支柱不起来了。起码这时可以很方便的获得root hub的设备描述符，可以调用usb_new_device将root hub送给无所不能的设备模型，去寻找它命中的驱动。

drivers/usb/core/hcd.c

	retval = usb_new_device (usb_dev);
	if (retval) {
		dev_err (parent_dev, "can't register root hub for %s, %d\n",
				dev_name(&usb_dev->dev), retval);
	} else {
		spin_lock_irq (&hcd_root_hub_lock);
		hcd->rh_registered = 1;
		spin_unlock_irq (&hcd_root_hub_lock);

		/* Did the HC die before the root hub was registered? */
		if (HCD_DEAD(hcd))
			usb_hc_died (hcd);	/* This time clean up */
	}

如果这些都一切顺利的话，register_root_hub()在最后就会将struct usb_hcd的rh_registered设置为1，表示root hub已经找到组织并加入到革命队伍里了。

Linux设备模型根据root hub所属的总线类型usb_bus_type将它添加到usb总线的那条有名的设备链表里，然后会轮询usb总线的另外一条有名的驱动链表，针对每个找到的驱动去调用usb总线的match函数，也就是咱们以前一再遇到以后不断遇到的usb_device_match()，为root hub牵线搭桥寻找另一个匹配的半圆。要注意，root hub的设备类型是usb_device_type，所以在usb_device_match()里走的设备那条路，匹配成功的是那个对所有usb_device_type类型的设备都来者不拒的花心大萝卜——usb世界里唯一的那个usb设备驱动（不是usb接口驱动）struct device_driver结构体对象usb_generic_driver。所以接下来要调用的就是usb_generic_driver的probe函数generic_probe()，去配置root hub，然后root hub就大步迈进了Configured状态。因为root hub只有一个配置，所以generic_probe()配置root hub时并没有多少选择的烦恼，如果有所疑问，可以look下hcd.c的开头就已经设定好的root hub设备描述符

/* usb 2.0 root hub device descriptor */
static const u8 usb2_rh_dev_descriptor[18] = {
	0x12,       /*  __u8  bLength; */
	0x01,       /*  __u8  bDescriptorType; Device */
	0x00, 0x02, /*  __le16 bcdUSB; v2.0 */

	0x09,	    /*  __u8  bDeviceClass; HUB_CLASSCODE */
	0x00,	    /*  __u8  bDeviceSubClass; */
	0x00,       /*  __u8  bDeviceProtocol; [ usb 2.0 no TT ] */
	0x40,       /*  __u8  bMaxPacketSize0; 64 Bytes */

	0x6b, 0x1d, /*  __le16 idVendor; Linux Foundation 0x1d6b */
	0x02, 0x00, /*  __le16 idProduct; device 0x0002 */
	KERNEL_VER, KERNEL_REL, /*  __le16 bcdDevice */

	0x03,       /*  __u8  iManufacturer; */
	0x02,       /*  __u8  iProduct; */
	0x01,       /*  __u8  iSerialNumber; */
	0x01        /*  __u8  bNumConfigurations; */
};

这张表是const的，也就是说在整个usb的世界里它都是只能去读不能去修改的，要用严谨科学的态度去对待root hub。明眼人一眼就能看到躲在它最后的那个0x01，这就是root hub支持的配置数量。在它下边儿还有针对usb 1.1的root hub设备描述符，大同小异就不贴了。

既然进入了Configured状态，就可以无拘无束的使用root hub提供的所有功能了，不过，对于咱们使用usb的劳苦大众来说，实际在起作用的还是设备里的接口，所以generic_probe()接下来就会根据root hub使用的配置，为它所有的接口准备struct usb_interface结构体对象，这时接口所属的总线类型仍然为usb_bus_type，设备类型就不一样了，为usb_if_device_type，早先说过的那句总线有总线的类型，设备有设备的类型到这里就应该再加上一句，接口有接口的类型。usb_if_device_type在message.c里定义

struct device_type usb_if_device_type = {
	.name =		"usb_interface",
	.release =	usb_release_interface,
	.uevent =	usb_if_uevent,
};

为root hub的接口准备struct usb_interface结构体也没费太大功夫，因为spec里规定了hub上除了端点0，就只有一个中断的IN端点，并不用准备太多的东西。root hub的配置描述符也已经在hcd.c的开头儿指定好了，确实只有一个接口，一个设置，一个端点，去look一下

drivers/usb/core/hcd.c

/* Configuration descriptors for our root hubs */

static const u8 fs_rh_config_descriptor[] = {

	/* one configuration */
	0x09,       /*  __u8  bLength; */
	0x02,       /*  __u8  bDescriptorType; Configuration */
	0x19, 0x00, /*  __le16 wTotalLength; */
	0x01,       /*  __u8  bNumInterfaces; (1) */
	0x01,       /*  __u8  bConfigurationValue; */
	0x00,       /*  __u8  iConfiguration; */
	0xc0,       /*  __u8  bmAttributes;
				 Bit 7: must be set,
				     6: Self-powered,
				     5: Remote wakeup,
				     4..0: resvd */
	0x00,       /*  __u8  MaxPower; */

	/* USB 1.1:
	 * USB 2.0, single TT organization (mandatory):
	 *	one interface, protocol 0
	 *
	 * USB 2.0, multiple TT organization (optional):
	 *	two interfaces, protocols 1 (like single TT)
	 *	and 2 (multiple TT mode) ... config is
	 *	sometimes settable
	 *	NOT IMPLEMENTED
	 */

	/* one interface */
	0x09,       /*  __u8  if_bLength; */
	0x04,       /*  __u8  if_bDescriptorType; Interface */
	0x00,       /*  __u8  if_bInterfaceNumber; */
	0x00,       /*  __u8  if_bAlternateSetting; */
	0x01,       /*  __u8  if_bNumEndpoints; */
	0x09,       /*  __u8  if_bInterfaceClass; HUB_CLASSCODE */
	0x00,       /*  __u8  if_bInterfaceSubClass; */
	0x00,       /*  __u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
	0x00,       /*  __u8  if_iInterface; */

	/* one endpoint (status change endpoint) */
	0x07,       /*  __u8  ep_bLength; */
	0x05,       /*  __u8  ep_bDescriptorType; Endpoint */
	0x81,       /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */
	0x03,       /*  __u8  ep_bmAttributes; Interrupt */
	0x02, 0x00, /*  __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
	0xff        /*  __u8  ep_bInterval; (255ms -- usb 2.0 spec) */
};

9行的0x01，34行0x00，35行的0x01，分别指定了接口数量，使用的设置，端点的数目。也就是说，如果加上端点0，root hub只有两个端点，而另外一个端点为IN端点，端点号为1，中断类型，每次可以处理的最大字节数为2，期望host controller访问自己的时间间隔为256ms。这里打个岔问个问题，为什么说这个中断端点的wMaxPacketSize为2，46行不是明确写着0x02，0x00么？呵呵，协议里说了，usb设备的各种描述符都是按照little-endian方式的字节序存储的，先是低字节然后是高字节。

为root hub的那个独苗儿接口准备好struct usb_interface结构体之后应该怎么做？佛又说了，一个接口一个驱动，接下来显然是应该将它送给设备模型去寻找它命中注定的驱动了。然后此处省略2008字，又到了usb_device_match()。不过你说这个时候设备和接口两条路它应该走哪条？它的类型已经设置成usb_if_device_type了，设备那条路把门儿的根本就不会让它进，所以它必须得去走接口那条路。

有关在接口这条路上它怎么去寻找另一半儿，咱现在不多说，日后在主线里说，现在只天马行空的扯一下。首先回头瞧下root hub的设备描述符，它的bDeviceClass 被指定为0x09，在include/linux/usb/ch9.h里，它对应的是USB_CLASS_HUB，再回头看看root hub配置描述符的36行，bInterfaceClass也被指定成0x09，也就是说同样为USB_CLASS_HUB。你再去hub驱动对应的hub.c文件里看看那里的hub_id_table，是不是应该明白点什么了？对头，root hub里的那个接口所对应的驱动就是hub驱动，虽然它很特殊，可它也是个hub啊。root hub一边和host controller相生相依，一边和hub驱动眉来眼去花前月下，多么巨大的讽刺。

接下来要做的就是调用hub驱动里的hub_probe()。不管是root hub还是一般的hub，走到这一步都是必然的，不同的是对于root hub在host controller初始化的过程中就会去调用hub_probe()。再省略2008字后，hub_probe()通过hub_configure()创建并初始化了一个中断的urb，然后在hub_activate()里调用usb_submit_urb()将它提交给core，接着就又回到了HCD。如果觉得省略了这么多让你很不爽，那就再去看看《我是hub》吧。

每个hub都要需要进行中断传输来获得hub的状态变化，不然hub驱动里那个著名的hub_events就活不下去了，你连在hub上的usb设备系统也就察觉不到了，你也就不能用usb摄像头来泡mm了，都走到了21世纪了，都应该知道中断传输不会提交一次就完事儿了，这么一次就完事儿hub不会满意，每个男人女人都不会满意。你需要在你的结束处理函数里提交再提交，host controller都不嫌烦，你烦什么啊。中断传输都是有个间隔时间的，这个时间不由你决定，也不由我决定，咱们只能期待，决定权在host controller那里。host controller就决定了，对于root hub要每隔250ms去访问一次，你再看上面root hub的描述符，里面显示它期待的时间为0xff，也就是256ms，250与256也差不了多少，root hub也应该满意了。这个固定的访问频率host controller是怎么实现的？就是通过struct usb_hcd里的那个定时器rh_timer，定时器就是专门干这种事儿的，root hub每提交一次urb，在HCD里都会对它初始化一次，指定250ms之后去获得root hub的状态，然后就让urb返回给root hub，于是root hub再提交，再250ms后返回，……。

但是这种对root hub的轮询机制是早先版本里的，现在就不一样了。struct usb_hcd里出现了uses_new_polling，看名字就知道是一种新机制出现了。这也是Alan Stern在2005年的阳春三月春心萌动孕育出来的，旧机制主要靠轮询，新机制主要靠中断。在新的机制里，root hub仍然是要提交一个中断urb的，不同的是这时它可以不用再请定时器来帮忙，在有设备插入时，host controller会在自己的中断处理函数里调用一个名叫usb_hcd_poll_rh_status的函数去获得root hub的状态并将urb的所有权归还给hub驱动。

那是不是就可以不需要定时器rh_timer了？事情没这么简单，也不能就这么过河拆桥，由于某些不可言状的原因，原来的机制还必须得保留着，给不同的host controller选择使用。为了让新旧机制和谐的运作，usb_hcd_poll_rh_status多了一个职务，就是作为rh_timer的定时器函数，而且struct usb_hcd里除了uses_new_polling之外就又多了poll_rh等几个元素。如果uses_new_polling没有被设置，则一定会采用旧的轮询机制，如果uses_new_polling已经被设置了，但同时又设置了poll_rh，也是要采用旧机制，否则采用的就是新机制。至于status_urb，其实就是root hub提交的那个urb。

root hub的生命线就还是说到这里吧，适可而止适可而止。
-------------------------------------------------------------------------------------------------------------*/

回到struct usb_hcd，看92行，wireless，是不是无线usb。

72~75这几行都是与主机控制器的娘家PCI有关的，说到PCI就不得不说到那张著名的表。PCI spec说了，要想在我这儿混，谁都必须不能少了那张表。

不过强制的也不一定都是坏事儿，起码这张表不是，中断号啊等很多有用的东西都在里面准备好了。72行的irq就躲在上面表儿里的倒数第四个byte，HCD可以直接拿来用，根本就不用再去申请，一提到申请个什么，谁都知道那是多么一个艰辛的过程。接下来的regs，rsrc_start，rsrc_len就与中间的那几个Base Address0~5脱不开关系了，牵涉到所谓的I/O内存和I/O端口，简单说一下。

大家都知道CPU牛X，是众人瞩目的焦点，但是它再牛也不可能一个人战斗，电脑运转是个集体项目，有很多千奇百怪的外设。CPU也需要跟各种外设配合交流，它需要访问外设里的那些寄存器或者内存。现在差别就出来了，主要是空间的差别，一些CPU芯片有两个空间，即I/O空间和内存空间，提供有专门访问外设I/O端口的指令，而另外一些只有一个空间，即内存空间。外设的I/O端口可以映射在I/O空间也可以映射到内存空间，CPU通过访问这两个空间来访问外设，I/O空间有I/O空间访问的接口，内存空间有内存空间访问的接口。当然某些外设不但有寄存器，还有内存，也就是I/O内存，比如EHCI/OHCI，它们需要映射到内存空间。但是不管映射到哪个空间，访问I/O端口还是I/O内存，CPU必须知道它们映射后的地址，不然没有办法配合交流。

上面表里中间的那些Base Address保存的就是PCI设备里I/O内存或I/O端口的首尾位置还有长度，驱动里使用时要首先把它们给读出来，如果要映射到I/O空间，则要根据读到的值向系统申请I/O端口资源，如果要映射到内存空间，除了要申请内存资源，还要使用ioremap等进行映射。

74行的rsrc_start和75行的rsrc_len保存的就是从表里读出来的host controller的I/O端口或内存的首地址和长度，73行的regs保存的是调用ioremap_nocache映射后的内存地址。

76行，power_budget，能够提供的电流。

98行，*pool [HCD_BUFFER_POOLS]，几个dma池。因为HCD_BUFFER_POOLS在97行定义为4，所以这里就表示每个主机控制器可以有4个dma池。

我们知道主机控制器是可以进行DMA传输的，镜头再回到前面的struct urb，那里有两个成员transfer_dma和setup_dma，当时只是说你可以使用usb_buffer_alloc分配好dma缓冲区给它们，然后再告诉HCD你的urb已经有了，HCD就可以不用再进行复杂的DMA映射了，并没有提到你这个获取的dma缓冲区是从哪里来的。俺都暗示到这种地步了，你用屁股也能猜出来是从这里所说的dma池子里来的了。

混了这么久，俺对池子还是有比较美好的回忆的，还亲手搭建过线程池、数据库连接池等等池子，像线程啊数据库连接啊什么的创建销毁的时候不是比较的耗资源么，就先建个池子预先创建好一批线程什么的放里边儿，用的时候就从里面取出来，不用的时候就再放里面，用的越多就越划的来，号称将负担均分了。所以说，池子是多么的重要啊。

当然，dma池没这么幼稚，它还有其它的内涵。一般来说DMA映射获得的都是以页为单位的内存，urb需要不了这么大，如果需要比较小的DMA缓冲区，就离不开DMA池了。还是看看主机控制器的这几个池子是怎么创建的，在drivers/usb/core/buffer.c 文件里

int hcd_buffer_create(struct usb_hcd *hcd)
{
	char		name[16];
	int		i, size;

	if (!hcd->self.controller->dma_mask &&
	    !(hcd->driver->flags & HCD_LOCAL_MEM))
		return 0;

	for (i = 0; i < HCD_BUFFER_POOLS; i++) {
		size = pool_max[i];
		if (!size)
			continue;
		snprintf(name, sizeof name, "buffer-%d", size);
		hcd->pool[i] = dma_pool_create(name, hcd->self.controller,
				size, size, 0);
		if (!hcd->pool[i]) {
			hcd_buffer_destroy(hcd);
			return -ENOMEM;
		}
	}
	return 0;
}

这里首先要判断下这个主机控制器支持不支持DMA，如果不支持的话再创建什么DMA池就是纯粹无稽之谈了。如果支持DMA，就逐个适用dma_pool_alloc来创建DMA池，如果创建失败了，就调用同一个文件里的hcd_buffer_destroy来将已经创建成功的池子给销毁掉。

void hcd_buffer_destroy(struct usb_hcd *hcd)
{
	int i;

	for (i = 0; i < HCD_BUFFER_POOLS; i++) {
		struct dma_pool *pool = hcd->pool[i];
		if (pool) {
			dma_pool_destroy(pool);
			hcd->pool[i] = NULL;
		}
	}
}

这里调用的dma_pool_destroy和上面的dma_pool_alloc也是相映成趣，都是DMA池子领域的小白领。带翅膀的丘比特说了，每个人的人生都要找到四个人，第一个是自己，第二个是你最爱的人，第三个是最爱你的人，第四个是共度一生的人。他还说了，每个DMA池子都要找到四个函数，一个用来创建，一个用来销毁，一个用来取内存，一个用来放内存。上边儿只遇到了创建和销毁的，还少两个取和放的，再去同一个文件里找找

void *hcd_buffer_alloc(
	struct usb_bus		*bus,
	size_t			size,
	gfp_t			mem_flags,
	dma_addr_t		*dma
)
{
	struct usb_hcd		*hcd = bus_to_hcd(bus);
	int			i;

	/* some USB hosts just use PIO */
	if (!bus->controller->dma_mask &&
	    !(hcd->driver->flags & HCD_LOCAL_MEM)) {
		*dma = ~(dma_addr_t) 0;
		return kmalloc(size, mem_flags);
	}

	for (i = 0; i < HCD_BUFFER_POOLS; i++) {
		if (size <= pool_max[i])
			return dma_pool_alloc(hcd->pool[i], mem_flags, dma);
	}
	return dma_alloc_coherent(hcd->self.controller, size, dma, mem_flags);
}

void hcd_buffer_free(
	struct usb_bus		*bus,
	size_t			size,
	void			*addr,
	dma_addr_t		dma
)
{
	struct usb_hcd		*hcd = bus_to_hcd(bus);
	int			i;

	if (!addr)
		return;

	if (!bus->controller->dma_mask &&
	    !(hcd->driver->flags & HCD_LOCAL_MEM)) {
		kfree(addr);
		return;
	}

	for (i = 0; i < HCD_BUFFER_POOLS; i++) {
		if (size <= pool_max[i]) {
			dma_pool_free(hcd->pool[i], addr, dma);
			return;
		}
	}
	dma_free_coherent(hcd->self.controller, size, addr, dma);
}

又可以找到两个dma_pool_alloc和dma_pool_free，现在可以凑齐四个了。不过咱们不用管它们四个到底什么长相，只要它们能够干活儿就成了，这里要注意的是几个问题。第一个是即使你的主机控制器不支持DMA，这几个函数也是可以用的，只不过创建的不是DMA池子，取的也不是DMA缓冲区，此时，DMA池子不存在，hcd_buffer_alloc获取的只是适用kmalloc申请的普通内存，当然相应的，你必须在它没有利用价值的时候使用hcd_buffer_free将它释放掉。

第二个问题是size的问题，也是每个男人女人的问题。看到它们里面都有个pool_max吧，这是个同一个文件里定义的数组

static const size_t	pool_max[HCD_BUFFER_POOLS] = {
	/* platforms without dma-friendly caches might need to
	 * prevent cacheline sharing...
	 */
	32,
	128,
	512,
	PAGE_SIZE / 2
	/* bigger --> allocate pages */
};

这个数组里定义的就是四个池子中每个池子里保存的DMA缓冲区的size。注意这里虽说只定义了四种size，但是并不说明你使用hcd_buffer_alloc获取DMA缓冲区的时候不能指定更大的size，如果谁谁太贪心了，欲望太强烈了，这几个池子都满足不了她的要求，那就会使用dma_alloc_coherent为她建立一个新的DMA映射。还有，每个人的情况都不一样，不可能都会完全恰好和上面定义的四种size一致，那也不用怕，这不是病，使用这个size获取DMA缓冲区的时候，池子会选择一个略大一些的回馈过去。

还是让咱们抛开size，回到struct usb_hcd中来，100行，state，主机控制器的状态，紧挨着它的下面那些行就是相关的可用值和宏定义。咱们自己的状态还都稀里糊涂的，就先不说它们了。

123行，如果不是有短暂失忆症或选择性失忆症的话，是会知道这是什么意思用来干吗的。