我们先讲解vhci-hcd驱动（linux-4.20.14的usbip驱动）。

      usb主机控制器驱动hcd学习心得：可以阅读某款SOC的主机控制器驱动代码，譬如TI的am3358芯片，可以看musb驱动代码（drivers/usb/musb/musb_host.c），或者阅读虚拟主机控制器（代码在drivers/usb/gadget/udc/dummy_hcd.c）,该虚拟USB主机控制器驱动内还包含一个虚拟USB设备控制器驱动（dummy_udc）供写gadget驱动时测试使用。但无论你阅读hcd、udc还是gadget都好，都要阅读usb core代码。

      vhci_hcd是一个platform驱动：

static struct platform_driver vhci_driver = {
    .probe    = vhci_hcd_probe,
    .remove    = vhci_hcd_remove,
    .suspend = vhci_hcd_suspend,
    .resume    = vhci_hcd_resume,
    .driver    = {
        .name = driver_name,
    },
};
...
...
ret = platform_driver_register(&vhci_driver);

//为了方便说明，代码做了简化，vhci_num_controllers固定设为1，错误处理忽略
static int __init vhci_hcd_init(void)
{
  int i, ret;
  if (usb_disabled())
   return -ENODEV;

  vhci_num_controllers = 1;

  vhcis = kcalloc(vhci_num_controllers, sizeof(struct vhci), GFP_KERNEL);
  if (vhcis == NULL)
    return -ENOMEM;

  vhcis->pdev = platform_device_alloc(driver_name, i);
  if (!vhcis->pdev) {
    ...
  }

  ret = platform_device_add_data(vhcis->pdev, &vhcis, sizeof(void *));
  ...
  
  ret = platform_driver_register(&vhci_driver);
  ...
  
  ret = platform_device_add(vhcis->pdev);
	...

	return ret;
}

      为了方便说明，vhci_hcd_init()代码做了简化，vhci_num_controllers固定设为1，错误处理忽略。但platform驱动不是本文的重点，我们可以认为，在vhci_hcd_init()中先malloc一块内存，用来存储struct vhci结构，该结构是记录了本驱动平台设备指针（struct platform_device）和本驱动的重要数据结构指针（struct vhci_hcd），用于相互关联，便于利用container_of()找到对方：

struct vhci {
	spinlock_t lock;

	struct platform_device *pdev;

	struct vhci_hcd *vhci_hcd_hs;
	struct vhci_hcd *vhci_hcd_ss;
};

        因为struct vhci结构是创建“平台设备”（platform_device_alloc()）时添加进去作为“私有数据”（platform_device_add_data）的，所以能很方便与平台驱动关联起来，有现成接口获取平台私有数据。底层platform驱动框架会利用driver_name进行匹配（match），找到具体的平台驱动实例，也就是我们的vhci-hcd驱动，最后框架会回调我们定义的vhci_hcd_probe(struct platform_device *pdev)，其中参数pdev就是我们自己在vhci_hcd_init()中分配的，从pdev->dev我们可以很轻易拿到struct vhci结构体指针，这一步就是“从平台设备找struct vhci对象”，反过来更容易，struct vhci结构本身包含平台设备指针pdev，初始化时填充进去就ok了。Linux内核是面向对象的，实例（对象）不止一个，而且是分层的，有很多core层或者框架层，经常被“某驱动框架”回调，所以阅读linux内核代码最主要的是搞清楚各个结构体指针究竟是从哪里分配的，到哪里去，怎么根据这个结构体找另外一个关联的结构体等。

       我们从入口函数vhci_hcd_probe()开始分析：

static int vhci_hcd_probe(struct platform_device *pdev)
{
	struct vhci             *vhci = *((void **)dev_get_platdata(&pdev->dev));
	struct usb_hcd		*hcd_hs;
	struct usb_hcd		*hcd_ss;
	int			ret;

	usbip_dbg_vhci_hc("name %s id %d\n", pdev->name, pdev->id);

	/*
	 * Allocate and initialize hcd.
	 * Our private data is also allocated automatically.
	 */
	hcd_hs = usb_create_hcd(&vhci_hc_driver, &pdev->dev, dev_name(&pdev->dev));
	if (!hcd_hs) {
		pr_err("create primary hcd failed\n");
		return -ENOMEM;
	}
	hcd_hs->has_tt = 1;

	/*
	 * Finish generic HCD structure initialization and register.
	 * Call the driver's reset() and start() routines.
	 */
	ret = usb_add_hcd(hcd_hs, 0, 0);
	if (ret != 0) {
		pr_err("usb_add_hcd hs failed %d\n", ret);
		goto put_usb2_hcd;
	}
        
        //USB super speed本文不关注，有兴趣自己阅读linux-4.20.14源码
	hcd_ss = usb_create_shared_hcd(&vhci_hc_driver, &pdev->dev,
				       dev_name(&pdev->dev), hcd_hs);
	
	...
        ...
}

usbip_dbg_vhci_hc()是用于调试使用的，可在make menuconfig时开启usbip的debug功能，开启了之后，会影响usb数据传输的速度，仅作调试使用。

hcd_hs = usb_create_hcd(&vhci_hc_driver, &pdev->dev, dev_name(&pdev->dev));

这个就是hcd的重要接口。用于注册一个USB主机控制器驱动实例：

static const struct hc_driver vhci_hc_driver = {
	.description	= driver_name,
	.product_desc	= driver_desc,
	.hcd_priv_size	= sizeof(struct vhci_hcd),

	.flags		= HCD_USB3 | HCD_SHARED,

	.reset		= vhci_setup,
	.start		= vhci_start,
	.stop		= vhci_stop,

	.urb_enqueue	= vhci_urb_enqueue,
	.urb_dequeue	= vhci_urb_dequeue,

	.get_frame_number = vhci_get_frame_number,

	.hub_status_data = vhci_hub_status,
	.hub_control    = vhci_hub_control,
	.bus_suspend	= vhci_bus_suspend,
	.bus_resume	= vhci_bus_resume,

	.alloc_streams	= vhci_alloc_streams,
	.free_streams	= vhci_free_streams,
};

因为框架已经有了，我们的工作归结为：“为struct hc_driver对象注册回调函数”，以实现多态，不同实例有不同实现。

我们只关注vhci-hcd使用到的、比较重要的成员函数和成员变量：

.flags        = HCD_USB3 | HCD_SHARED代表vhci-hcd支持usb3.0设备，同时指定usb2.0和usb3.x的两个hcd使用相同的硬件。因为此处（上面的vhci_hcd_probe）定义了两个hcd：/* Each VHCI has 2 hubs (USB2 and USB3), each has VHCI_HC_PORTS ports */

hcd_hs = usb_create_hcd(&vhci_hc_driver, &pdev->dev, dev_name(&pdev->dev));
...
hcd_ss = usb_create_shared_hcd(&vhci_hc_driver, &pdev->dev,
				       dev_name(&pdev->dev), hcd_hs);

hcd_hs->has_tt = 1;开启root hub的TT（Integrated TT），TT应该是高速HUB也能支持传输低速和全速的usb设备，详情阅读CH11章节，看hub底层数据包的传输原理。

      很例牌，调用完usb_add_hcd()后，系统就认为存在一个主机控制器了，我主要讲usb2.0部分（hcd_hs），usb3.0部分有兴趣的朋友自行阅读代码。

      我们发现整个vhci_hcd_probe函数都没有看到创建的struct usb_hcd  *hcd_hs保存到哪，毕竟我们后面肯定会用到这个usb主机控制器驱动，但怎么找回来呢？它没有单纯使用全局变量保存，而是利用了平台驱动的“私有数据”来传递，以后用到struct usb_hcd对象也能找回来。它是在usb_create_hcd()中调用了dev_set_drvdata(dev, hcd);

static inline void dev_set_drvdata(struct device *dev, void *data)
{
	dev->driver_data = data;
}

      放到平台驱动的driver_data中了，到时可以根据struct vhci找到平台设备（struct platform_device *pdev），就能找到对应的平台驱动，最后找到struct usb_hcd ，或者反过来，即可以从struct usb_hcd找到struct vhci指针，container_of()功能强大。

      我们继续struct hc_driver结构体的其他成员说明，看usb_add_hcd()的官方注释可以知道，reset和start这个成员函数会在usb_add_hcd()中被回调，用于基本的初始化工作。其中，reset比start先执行。

/**
 * usb_add_hcd - finish generic HCD structure initialization and register
 * @hcd: the usb_hcd structure to initialize
 * @irqnum: Interrupt line to allocate
 * @irqflags: Interrupt type flags
 *
 * Finish the remaining parts of generic HCD initialization: allocate the
 * buffers of consistent memory, register the bus, request the IRQ line,
 * and call the driver's reset() and start() routines.
 * If it is an OTG device then it only registers the HCD with OTG core.
 *
 */
int usb_add_hcd(struct usb_hcd *hcd,
		unsigned int irqnum, unsigned long irqflags)

因为框架（drivers/usb/core/hcd.c）比较复杂，就不跟进去usb_add_hcd()分析了，有兴趣的朋友可以深入研究。

      那对于vhci-hcd驱动实例，它的reset和start究竟做了什么呢？下面我们来一一分析。我们先看reset回调：

static int vhci_setup(struct usb_hcd *hcd)
{
	struct vhci *vhci = *((void **)dev_get_platdata(hcd->self.controller));
	if (usb_hcd_is_primary_hcd(hcd)) {
		vhci->vhci_hcd_hs = hcd_to_vhci_hcd(hcd);
		vhci->vhci_hcd_hs->vhci = vhci;
		/*
		 * Mark the first roothub as being USB 2.0.
		 * The USB 3.0 roothub will be registered later by
		 * vhci_hcd_probe()
		 */
		hcd->speed = HCD_USB2;
		hcd->self.root_hub->speed = USB_SPEED_HIGH;
	} else {
		...
	}
	return 0;
}

      上面也说了，struct vhci结构可以由struct usb_hcd找到，struct vhci *vhci = *((void **)dev_get_platdata(hcd->self.controller));

我们主要看primary_hcd那个分支，因为从vhci_hcd_probe()中我们知道hcd_hs是作为primary_hcd，而hcd_ss作为shared_hcd的，usb3.0我们不看。

      这里有个比较有意思的函数hcd_to_vhci_hcd():

static inline struct vhci_hcd *hcd_to_vhci_hcd(struct usb_hcd *hcd)
{
	return (struct vhci_hcd *) (hcd->hcd_priv);
}

其中hcd_priv在struct usb_hcd中是一个0数组：

/* The HC driver's private data is stored at the end of
	 * this structure.
	 */
	unsigned long hcd_priv[0]
			__attribute__ ((aligned(sizeof(s64))));

早在vhci_hcd_probe()中注册vhci_hc_driver（.hcd_priv_size    = sizeof(struct vhci_hcd)）时，就已经分配好空间了。所以在vhci_setup()被回调时，是可以访问该空间的，在这里初始化了vhci_hcd_hs（struct vhci_hcd结构）：

vhci->vhci_hcd_hs = hcd_to_vhci_hcd(hcd);
vhci->vhci_hcd_hs->vhci = vhci;

这样就关联起来了struct vhci结构中的vhci_hcd_hs，同时也关联了struct vhci_hcd结构与struct vhci结构，方便后续相互找对方。

    ok，我们再来看start回调：

static void vhci_device_init(struct vhci_device *vdev)
{
	memset(vdev, 0, sizeof(struct vhci_device));

	vdev->ud.side   = USBIP_VHCI;
	vdev->ud.status = VDEV_ST_NULL;
	spin_lock_init(&vdev->ud.lock);

	INIT_LIST_HEAD(&vdev->priv_rx);
	INIT_LIST_HEAD(&vdev->priv_tx);
	INIT_LIST_HEAD(&vdev->unlink_tx);
	INIT_LIST_HEAD(&vdev->unlink_rx);
	spin_lock_init(&vdev->priv_lock);

	init_waitqueue_head(&vdev->waitq_tx);

	vdev->ud.eh_ops.shutdown = vhci_shutdown_connection;
	vdev->ud.eh_ops.reset = vhci_device_reset;
	vdev->ud.eh_ops.unusable = vhci_device_unusable;

	usbip_start_eh(&vdev->ud);
}
...
...
static int vhci_start(struct usb_hcd *hcd)
{
	struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd);
	int id, rhport;
	int err;

	usbip_dbg_vhci_hc("enter vhci_start\n");

	if (usb_hcd_is_primary_hcd(hcd))
		spin_lock_init(&vhci_hcd->vhci->lock);

	/* initialize private data of usb_hcd */

	for (rhport = 0; rhport < VHCI_HC_PORTS; rhport++) {
		struct vhci_device *vdev = &vhci_hcd->vdev[rhport];

		vhci_device_init(vdev);
		vdev->rhport = rhport;
	}

	atomic_set(&vhci_hcd->seqnum, 0);

	hcd->power_budget = 0; /* no limit */
	hcd->uses_new_polling = 1;

#ifdef CONFIG_USB_OTG
	hcd->self.otg_port = 1;
#endif

	id = hcd_name_to_id(hcd_name(hcd));
	if (id < 0) {
		pr_err("invalid vhci name %s\n", hcd_name(hcd));
		return -EINVAL;
	}

	/* vhci_hcd is now ready to be controlled through sysfs */
	if (id == 0 && usb_hcd_is_primary_hcd(hcd)) {
		err = vhci_init_attr_group();
		if (err) {
			pr_err("init attr group\n");
			return err;
		}
		err = sysfs_create_group(&hcd_dev(hcd)->kobj, &vhci_attr_group);
		if (err) {
			pr_err("create sysfs files\n");
			vhci_finish_attr_group();
			return err;
		}
		pr_info("created sysfs %s\n", hcd_name(hcd));
	}

	return 0;
}

      vhci_start()函数主要是继续初始化本驱动的两个重要结构体struct vhci_hcd和struct vhci_device：

/* a common structure for stub_device and vhci_device */
struct usbip_device {
	enum usbip_side side;
	enum usbip_device_status status;

	/* lock for status */
	spinlock_t lock;

	int sockfd;
	struct socket *tcp_socket;

	struct task_struct *tcp_rx;
	struct task_struct *tcp_tx;

	unsigned long event;
	wait_queue_head_t eh_waitq;

	struct eh_ops {
		void (*shutdown)(struct usbip_device *);
		void (*reset)(struct usbip_device *);
		void (*unusable)(struct usbip_device *);
	} eh_ops;
};

struct vhci_device {
	struct usb_device *udev;

	/*
	 * devid specifies a remote usb device uniquely instead
	 * of combination of busnum and devnum.
	 */
	__u32 devid;

	/* speed of a remote device */
	enum usb_device_speed speed;

	/* vhci root-hub port to which this device is attached */
	__u32 rhport;

	struct usbip_device ud;

	/* lock for the below link lists */
	spinlock_t priv_lock;

	/* vhci_priv is linked to one of them. */
	struct list_head priv_tx;
	struct list_head priv_rx;

	/* vhci_unlink is linked to one of them */
	struct list_head unlink_tx;
	struct list_head unlink_rx;

	/* vhci_tx thread sleeps for this queue */
	wait_queue_head_t waitq_tx;
};

/* for usb_hcd.hcd_priv[0] */
struct vhci_hcd {
	struct vhci *vhci;

	u32 port_status[VHCI_HC_PORTS];

	unsigned resuming:1;
	unsigned long re_timeout;

	atomic_t seqnum;

	/*
	 * NOTE:
	 * wIndex shows the port number and begins from 1.
	 * But, the index of this array begins from 0.
	 */
	struct vhci_device vdev[VHCI_HC_PORTS];
};

包括初始化里面的队列和自旋锁，原子序列号等，以及最重要的是通过sysfs_create_group(&hcd_dev(hcd)->kobj, &vhci_attr_group)注册了一个sysfs界面，上层就可以用usbip工具进行配置vhci-hcd驱动了，在sysfs中，usbip工具主要配置了如下几个参数：

devid
speed
sockfd

后面再说这几个参数的作用。我们只需要知道vhci_start()只是一个初始化函数即可。

终于把vhci_hcd_probe()流程讲清楚了。完成了vhci-hcdq驱动的全部初始化过程！

 

下篇文章讲解“usbip attach -r <server端ip地址> -b <busid>”命令下发后，vhci-hcd驱动做了什么，导致能共享远端的真实U盘。