我们先讲解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;
intret;
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 -b ”命令下发后，vhci-hcd驱动做了什么，导致能共享远端的真实U盘。
