概述
本文對USB驅動中的HCD(主機控制器驅動，Host Controller Driver)初始化代碼進行分析，梳理總結其中涉及到的重要資料結構和處理流程。HCD驅動代碼根據USB标準分為OHCI、UHCI、EHCI和XHCI，本文以EHCI标準為主，進行分析，選取freescale驅動代碼
初始化代碼分析
HCD驅動是CPU上USB主機控制器的抽象，HCD驅動代碼位于driver/usb/host路徑下，入口為ehci_hcd.c
static int __init ehci_hcd_init(void)
{
int retval = 0;
set_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
if (test_bit(USB_UHCI_LOADED, &usb_hcds_loaded) ||
test_bit(USB_OHCI_LOADED, &usb_hcds_loaded))
printk(KERN_WARNING "Warning! ehci_hcd should always be loaded"
" before uhci_hcd and ohci_hcd, not after\n");
pr_debug("%s: block sizes: qh %Zd qtd %Zd itd %Zd sitd %Zd\n",
hcd_name,
sizeof(struct ehci_qh), sizeof(struct ehci_qtd),
sizeof(struct ehci_itd), sizeof(struct ehci_sitd));
#ifdef DEBUG
ehci_debug_root = debugfs_create_dir("ehci", NULL);
if (!ehci_debug_root) {
retval = -ENOENT;
goto err_debug;
}
#endif
#ifdef PLATFORM_DRIVER
retval = platform_driver_register(&PLATFORM_DRIVER);
if (retval < 0)
goto clean0;
#endif
#ifdef PCI_DRIVER
retval = pci_register_driver(&PCI_DRIVER);
if (retval < 0)
goto clean1;
#endif
#ifdef PS3_SYSTEM_BUS_DRIVER
retval = ps3_ehci_driver_register(&PS3_SYSTEM_BUS_DRIVER);
if (retval < 0)
goto clean2;
#endif
#ifdef OF_PLATFORM_DRIVER
retval = of_register_platform_driver(&OF_PLATFORM_DRIVER);
if (retval < 0)
goto clean3;
#endif
return retval;
#ifdef OF_PLATFORM_DRIVER
clean3:
#endif
#ifdef PS3_SYSTEM_BUS_DRIVER
ps3_ehci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
clean2:
#endif
#ifdef PCI_DRIVER
pci_unregister_driver(&PCI_DRIVER);
clean1:
#endif
#ifdef PLATFORM_DRIVER
platform_driver_unregister(&PLATFORM_DRIVER);
clean0:
#endif
#ifdef DEBUG
debugfs_remove(ehci_debug_root);
ehci_debug_root = NULL;
err_debug:
#endif
clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
return retval;
}
module_init(ehci_hcd_init);
該函數其實并沒有做什麼實質性的工作，根據宏定義進入具體裝置的驅動程式中，以freescale晶片來分析的話，會調用()向系統注冊ehci_fsl_driver驅動，驅動内容如下
static struct platform_driver ehci_fsl_driver = {
.probe = ehci_fsl_drv_probe,
.remove = ehci_fsl_drv_remove,
.shutdown = usb_hcd_platform_shutdown,
.driver = {
.name = "fsl-ehci",
},
};
其probe函數為ehci_fsl_probe，驅動名稱為"fsl-ehci"。那麼驅動注冊了，怎麼才會調用probe函數呢？當然是要有裝置注冊。那麼裝置是什麼時候注冊的呢？主機控制器裝置屬于CPU片上資源，這些片上資源一般都是在核心啟動的時候注冊到系統的，在arch/powerpc/sysdev/fsl_soc.c檔案中，對裝置進行了注冊操作
usb_dev_mph =
platform_device_register_simple("fsl-ehci", i, r, 2);
if (IS_ERR(usb_dev_mph)) {
ret = PTR_ERR(usb_dev_mph);
goto err;
}
代碼中通過調用platform_device_register_simple()向系統中注冊名為fsl-ehci的裝置。現在就清楚了，不管是裝置先注冊還是驅動先注冊，現在裝置和驅動剛好對應起來了，是以ehci_fsl_drv_probe會馬上調用起來。
在分析echi_fsl_drv_probe之前，我們先來分析一下裝置結構以及内容。fsl_soc.c檔案中通過調用fsl_usb_of_init()函數來注冊USB主機控制器裝置，其裝置資訊和資源從哪裡來的呢？看代碼
for_each_compatible_node(np, NULL, "fsl-usb2-mph") {
struct resource r[2];
struct fsl_usb2_platform_data usb_data;
const unsigned char *prop = NULL;
memset(&r, 0, sizeof(r));
memset(&usb_data, 0, sizeof(usb_data));
ret = of_address_to_resource(np, 0, &r[0]);
if (ret)
goto err;
of_irq_to_resource(np, 0, &r[1]);
usb_dev_mph =
platform_device_register_simple("fsl-ehci", i, r, 2);
if (IS_ERR(usb_dev_mph)) {
ret = PTR_ERR(usb_dev_mph);
goto err;
}
這裡通過調用for_each_compatible_node()，其實要涉及到linux裝置樹的概念，這裡不展開說明。簡單說就是通過平台檔案裡的一個xxx.dts檔案中讀取名字為fsl-usb2-mph的裝置樹結構，從中拿到硬體資源和資訊，是以我們主要分析清楚這些資源和資訊就行。從arch/powerpc/boot/dts/mpc834x_mds.dts檔案中找到這樣一段描述
[email protected] {
compatible = "fsl-usb2-mph";
reg = <0x22000 0x1000>;
#address-cells = <1>;
#size-cells = <0>;
interrupt-parent = ;
interrupts = <39 0x8>;
phy_type = "ulpi";
port1;
};
可以看到寄存器的初始位址為0x22000，長度為1000，中斷号為39，有一個port。
HCD probe
下面來分析ehci_fsl_drv_probe()函數，裡面傳回的是一個usb_hcd_fsl_probe()函數，傳遞了pdev和一個ehci_fsl_hc_driver
static int ehci_fsl_drv_probe(struct platform_device *pdev)
{
if (usb_disabled())
return -ENODEV;
return usb_hcd_fsl_probe(&ehci_fsl_hc_driver, pdev);
}
pdev就是前面分析的向系統注冊的主機控制器裝置“fsl-ehci”，但是ehci_fsl_hc_driver又是什麼呢？
首先，它的類型是struct hc_driver，然後它是一個static類型的靜态變量，其内容如代碼
static const struct hc_driver ehci_fsl_hc_driver = {
.description = hcd_name,
.product_desc = "Freescale On-Chip EHCI Host Controller",
.hcd_priv_size = sizeof(struct ehci_hcd),
.irq = ehci_irq,
.flags = HCD_USB2,
.reset = ehci_fsl_setup,
.start = ehci_run,
.stop = ehci_stop,
.shutdown = ehci_shutdown,
.urb_enqueue = ehci_urb_enqueue,
.urb_dequeue = ehci_urb_dequeue,
.endpoint_disable = ehci_endpoint_disable,
.get_frame_number = ehci_get_frame,
.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,
};
這個ehci_fsl_hc_driver很重要，主要是挂接了很多函數，其中尤其是irq、start、urb_enqueue、urb_dequeue、hub_status_data和hub_control尤為重要，了解清楚什麼時候什麼情況下會調用到這些函數，以及這些函數主要完成什麼操作，基本上就把USB驅動搞清楚了。當然，下面的任務就是分析這些内容。
先抛開這些具體函數接口，回頭分析一下usb_hcd_fsl_probe()這個函數。它傳入了兩個參數，一個是ehci_fsl_hc_driver，另一個是主機控制器裝置。
int usb_hcd_fsl_probe(const struct hc_driver *driver,
struct platform_device *pdev)
{
struct fsl_usb2_platform_data *pdata;
struct usb_hcd *hcd;
struct resource *res;
int irq;
int retval;
unsigned int temp;
pr_debug("initializing FSL-SOC USB Controller\n");
pdata = (struct fsl_usb2_platform_data *)pdev->dev.platform_data;
if (!pdata) {
dev_err(&pdev->dev,
"No platform data for %s.\n", dev_name(&pdev->dev));
return -ENODEV;
}
if (!((pdata->operating_mode == FSL_USB2_DR_HOST) ||
(pdata->operating_mode == FSL_USB2_MPH_HOST) ||
(pdata->operating_mode == FSL_USB2_DR_OTG))) {
dev_err(&pdev->dev,
"Non Host Mode configured for %s. Wrong driver linked.\n",
dev_name(&pdev->dev));
return -ENODEV;
}
res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!res) {
dev_err(&pdev->dev,
"Found HC with no IRQ. Check %s setup!\n",
dev_name(&pdev->dev));
return -ENODEV;
}
irq = res->start;
hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
if (!hcd) {
retval = -ENOMEM;
goto err1;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev,
"Found HC with no register addr. Check %s setup!\n",
dev_name(&pdev->dev));
retval = -ENODEV;
goto err2;
}
hcd->rsrc_start = res->start;
hcd->rsrc_len = res->end - res->start + 1;
if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
driver->description)) {
dev_dbg(&pdev->dev, "controller already in use\n");
retval = -EBUSY;
goto err2;
}
hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
if (hcd->regs == NULL) {
dev_dbg(&pdev->dev, "error mapping memory\n");
retval = -EFAULT;
goto err3;
}
temp = in_be32(hcd->regs + 0x500);
out_be32(hcd->regs + 0x500, temp | 0x4);
temp = in_le32(hcd->regs + 0x1a8);
out_le32(hcd->regs + 0x1a8, temp | 0x3);
retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
if (retval != 0)
goto err4;
return retval;
err4:
iounmap(hcd->regs);
err3:
release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
err2:
usb_put_hcd(hcd);
err1:
dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), retval);
return retval;
}
這個函數并不複雜，通過調用platform_get_resource()擷取裝置的中斷号和寄存器起始位址。調用usb_create_hcd()建立了一個struct usb_hcd類型的hcd，也就是主機控制器資料結構。然後調用ioremap()完成了寄存器的I/O映射。設定了兩個寄存器，使能USB功能，并裝置為主機模式。最後調用了usb_add_hcd()。其中的重點在usb_create_hcd()和usb_add_hcd()這兩個函數上。
建立hcd
建立hcd代碼為
struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,
struct device *dev, const char *bus_name)
{
struct usb_hcd *hcd;
hcd = kzalloc(sizeof(*hcd) + driver->hcd_priv_size, GFP_KERNEL);
if (!hcd) {
dev_dbg (dev, "hcd alloc failed\n");
return NULL;
}
dev_set_drvdata(dev, hcd);
kref_init(&hcd->kref);
usb_bus_init(&hcd->self);
hcd->self.controller = dev;
hcd->self.bus_name = bus_name;
hcd->self.uses_dma = (dev->dma_mask != NULL);
init_timer(&hcd->rh_timer);
hcd->rh_timer.function = rh_timer_func;
hcd->rh_timer.data = (unsigned long) hcd;
#ifdef CONFIG_PM
INIT_WORK(&hcd->wakeup_work, hcd_resume_work);
#endif
hcd->driver = driver;
hcd->product_desc = (driver->product_desc) ? driver->product_desc :
"USB Host Controller";
return hcd;
}
首先通過kzalloc()為hcd配置設定記憶體空間，這裡有一點需要注意，配置設定的大小并不是usb_hcd結構體的大小，而是多配置設定了一個driver->hcd_priv_size，這部分多大呢？前面ehci_fsl_hc_driver的内容中寫的很明白
.hcd_priv_size = sizeof(struct ehci_hcd)
也就是配置設定了一個sizeof(struct usb_hcd) + sizeof(ehci_hcd)的空間，其實在驅動編寫中有很多這種寫法，一部分是通用結構體，另一部分是私有結構體，對于usb core來說，usb_hcd是通用的，其中的一些屬性和成員在整個USB子系統的處理和排程中都可能會用到的，而另一部分私有空間ehci_hcd僅僅在EHCI标準的USB進行中才會使用到。
調用usb_bus_init()對hcd的self成員進行了初始化，還對self的一些參數進行了指派。然後建立了一個定時器任務rh_timer_func，但是還沒有觸發。
這部分涉及到一些資料結構，來梳理一下。
hcd_driver，有一個static的全局結構體ehci_fsl_hc_driver，上面挂接了很多重要的處理函數
usb_hcd，這是描述一個主機控制器的通用型資料結構
ehci_hcd，這是用于描述一個EHCI接口标準主機控制器的私有型資料結構
從資料結構的角度來看，hcd的建立都做了什麼呢？配置設定了一個記憶體空間，包括一個usb_hcd和ehci_hcd，這個空間的指針為hcd，給hcd的self成員指派，如下圖
hcd通過指針連接配接的方式把ehci_fsl_hc_driver的所有操作函數關聯起來
hcd添加
usb_add_hcd()這個名稱其實有些誤導，該函數裡面執行的過程很重要，不僅僅是一個添加操作，代碼如下
int usb_add_hcd(struct usb_hcd *hcd,
unsigned int irqnum, unsigned long irqflags)
{
int retval;
struct usb_device *rhdev;
dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
hcd->authorized_default = hcd->wireless? 0 : 1;
set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
if ((retval = hcd_buffer_create(hcd)) != 0) {
dev_dbg(hcd->self.controller, "pool alloc failed\n");
return retval;
}
if ((retval = usb_register_bus(&hcd->self)) < 0)
goto err_register_bus;
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;
}
rhdev->speed = (hcd->driver->flags & HCD_USB2) ? USB_SPEED_HIGH :
USB_SPEED_FULL;
hcd->self.root_hub = rhdev;
device_init_wakeup(&rhdev->dev, 1);
if (hcd->driver->reset && (retval = hcd->driver->reset(hcd)) < 0) {
dev_err(hcd->self.controller, "can't setup\n");
goto err_hcd_driver_setup;
}
if (device_can_wakeup(hcd->self.controller)
&& device_can_wakeup(&hcd->self.root_hub->dev))
dev_dbg(hcd->self.controller, "supports USB remote wakeup\n");
if (hcd->driver->irq) {
if (irqflags & IRQF_SHARED)
irqflags &= ~IRQF_DISABLED;
snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
hcd->driver->description, hcd->self.busnum);
if ((retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
hcd->irq_descr, hcd)) != 0) {
dev_err(hcd->self.controller,
"request interrupt %d failed\n", irqnum);
goto err_request_irq;
}
hcd->irq = irqnum;
dev_info(hcd->self.controller, "irq %d, %s 0x%08llx\n", irqnum,
(hcd->driver->flags & HCD_MEMORY) ?
"io mem" : "io base",
(unsigned long long)hcd->rsrc_start);
} else {
hcd->irq = -1;
if (hcd->rsrc_start)
dev_info(hcd->self.controller, "%s 0x%08llx\n",
(hcd->driver->flags & HCD_MEMORY) ?
"io mem" : "io base",
(unsigned long long)hcd->rsrc_start);
}
if ((retval = hcd->driver->start(hcd)) < 0) {
dev_err(hcd->self.controller, "startup error %d\n", retval);
goto err_hcd_driver_start;
}
rhdev->bus_mA = min(500u, hcd->power_budget);
if ((retval = register_root_hub(hcd)) != 0)
goto err_register_root_hub;
retval = sysfs_create_group(&rhdev->dev.kobj, &usb_bus_attr_group);
if (retval < 0) {
printk(KERN_ERR "Cannot register USB bus sysfs attributes: %d\n",
retval);
goto error_create_attr_group;
}
if (hcd->uses_new_polling && hcd->poll_rh)
usb_hcd_poll_rh_status(hcd);
return retval;
error_create_attr_group:
mutex_lock(&usb_bus_list_lock);
usb_disconnect(&hcd->self.root_hub);
mutex_unlock(&usb_bus_list_lock);
err_register_root_hub:
hcd->driver->stop(hcd);
err_hcd_driver_start:
if (hcd->irq >= 0)
free_irq(irqnum, hcd);
err_request_irq:
err_hcd_driver_setup:
hcd->self.root_hub = NULL;
usb_put_dev(rhdev);
err_allocate_root_hub:
usb_deregister_bus(&hcd->self);
err_register_bus:
hcd_buffer_destroy(hcd);
return retval;
}
第一件事情就是調用hcd_buffer_create()配置設定一些buffer
int hcd_buffer_create(struct usb_hcd *hcd)
{
charname[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;
}
hcd有一個dma池結構，
#define HCD_BUFFER_POOLS4
struct dma_pool*pool [HCD_BUFFER_POOLS];
pool是一個由4個指針構成的dma池數組，配置設定過程是循環為這個4個dma池配置設定dma空間，而每個空間的大小又是由pool_max[]數組決定的，
static const size_tpool_max [HCD_BUFFER_POOLS] = {
32,
128,
512,
PAGE_SIZE / 2
};
pool_max數組由四個值組成，32、128、512、PAGE_SIZE/2，是以4個dma池大小分别為32、128、512和PAGE_SIZE
配置設定完了dma池之後，調用usb_register_bus()對hcd的self做了注冊，
static int usb_register_bus(struct usb_bus *bus)
{
int result = -E2BIG;
int busnum;
mutex_lock(&usb_bus_list_lock);
busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1);
if (busnum >= USB_MAXBUS) {
printk (KERN_ERR "%s: too many buses\n", usbcore_name);
goto error_find_busnum;
}
set_bit (busnum, busmap.busmap);
bus->busnum = busnum;
bus->dev = device_create_drvdata(usb_host_class, bus->controller,
MKDEV(0, 0), bus,
"usb_host%d", busnum);
result = PTR_ERR(bus->dev);
if (IS_ERR(bus->dev))
goto error_create_class_dev;
list_add (&bus->bus_list, &usb_bus_list);
mutex_unlock(&usb_bus_list_lock);
usb_notify_add_bus(bus);
dev_info (bus->controller, "new USB bus registered, assigned bus "
"number %d\n", bus->busnum);
return 0;
error_create_class_dev:
clear_bit(busnum, busmap.busmap);
error_find_busnum:
mutex_unlock(&usb_bus_list_lock);
return result;
}
其實就是做了一些私有資料建立，然後把self挂到usb_bus_list這個連結清單上
接下來調用usb_alloc_dev()進行了一個usb_device結構的配置設定，這裡的操作非常重要，這個操作就是在為root hub根集線器做記憶體配置設定和一些初始化。
struct usb_device *usb_alloc_dev(struct usb_device *parent,
struct usb_bus *bus, unsigned port1)
{
struct usb_device *dev;
struct usb_hcd *usb_hcd = container_of(bus, struct usb_hcd, self);
unsigned root_hub = 0;
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev)
return NULL;
if (!usb_get_hcd(bus_to_hcd(bus))) {
kfree(dev);
return NULL;
}
device_initialize(&dev->dev);
dev->dev.bus = &usb_bus_type;
dev->dev.type = &usb_device_type;
dev->dev.groups = usb_device_groups;
dev->dev.dma_mask = bus->controller->dma_mask;
set_dev_node(&dev->dev, dev_to_node(bus->controller));
dev->state = USB_STATE_ATTACHED;
atomic_set(&dev->urbnum, 0);
INIT_LIST_HEAD(&dev->ep0.urb_list);
dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
usb_enable_endpoint(dev, &dev->ep0);
dev->can_submit = 1;
if (unlikely(!parent)) {
dev->devpath[0] = '0';
dev->dev.parent = bus->controller;
dev_set_name(&dev->dev, "usb%d", bus->busnum);
root_hub = 1;
} else {
if (parent->devpath[0] == '0')
snprintf(dev->devpath, sizeof dev->devpath,
"%d", port1);
else
snprintf(dev->devpath, sizeof dev->devpath,
"%s.%d", parent->devpath, port1);
dev->dev.parent = &parent->dev;
dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath);
}
dev->portnum = port1;
dev->bus = bus;
dev->parent = parent;
INIT_LIST_HEAD(&dev->filelist);
#ifdefCONFIG_PM
mutex_init(&dev->pm_mutex);
INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work);
dev->autosuspend_delay = usb_autosuspend_delay * HZ;
dev->connect_time = jiffies;
dev->active_duration = -jiffies;
#endif
if (root_hub)
dev->authorized = 1;
else {
dev->authorized = usb_hcd->authorized_default;
dev->wusb = usb_bus_is_wusb(bus)? 1 : 0;
}
return dev;
}
首先調用kzalloc()為根集線器配置設定記憶體空間，然後調用device_initialize()對根集線器的通用裝置結構dev進行初始化，指定其總線類型和裝置類型，以及dma功能，将根集線器的狀态設定為未接入。然後對根集線器的端點進行了初始化，下面重點分析。
根集線器端點初始化
分析代碼之前，先簡單介紹一下端點的概念。在USB标準規定中，端點是用于進行USB通信的基本機關，像管道一樣，端點有兩個方向，一個是由主機向裝置(OUT)，一個是由裝置向主機。端點的種類有4種，分别為控制(controller)、中斷(interrupt)、塊(bluk)和等時(isochronous)。核心中使用struct usb_host_endpoint結構來描述一個端點，其中包含一個struct usb_endpoint_descriptor結構用來描述端點的實際資訊，如端點位址、方向、類型、最大包大小和間隔，如下圖
又因為每個裝置預設情況下都必須有一個控制端點“endpoint0”，是以在根集線器的資料結構0号端點是一個結構體執行個體，而其他端點隻有指針
struct usb_host_endpoint ep0;
struct device dev;
struct usb_device_descriptor descriptor;
struct usb_host_config *config;
struct usb_host_config *actconfig;
struct usb_host_endpoint *ep_in[16];
struct usb_host_endpoint *ep_out[16];
這裡的ep0就是0号端點，并且初始化過程主要就是對ep0進行初始化。代碼中首先初始化了ep0中的一個連結清單urb_list，這個urb_list和資料傳輸有關，現在先不做分析。指定了ep0的長度和類型，類型為中斷。然後調用了usb_enable_endpoint()
void usb_enable_endpoint(struct usb_device *dev, struct usb_host_endpoint *ep)
{
int epnum = usb_endpoint_num(&ep->desc);
int is_out = usb_endpoint_dir_out(&ep->desc);
int is_control = usb_endpoint_xfer_control(&ep->desc);
if (is_out || is_control) {
usb_settoggle(dev, epnum, 1, 0);
dev->ep_out[epnum] = ep;
}
if (!is_out || is_control) {
usb_settoggle(dev, epnum, 0, 0);
dev->ep_in[epnum] = ep;
}
ep->enabled = 1;
}
首先調用usb_endpoint_num()擷取端點号，這裡顯然是0号端點，然後調用usb_endpoint_dir_out()擷取端點方向，因為bEndpointAddress現在是全0，是以方向為OUT，調用usb_endpoint_xfer_control()判斷端點是否為控制端點，因為bmAttributes也為全0，是以是控制端點。如果是方向是OUT或者是控制端點會走第一個if，如果方向不是OUT或者是控制端點會走第二個if，是以這裡兩個if都會執行。
兩個if中都有一個usb_settoggle()操作，
#define usb_settoggle(dev, ep, out, bit) \
((dev)->toggle[out] = ((dev)->toggle[out] & ~(1 << (ep))) | \
((bit) << (ep)))
其實就是為ep0的toggle[2]中的兩個成員指派。然後将dev->ep_out[0]和dev->ep_in[0]這兩個指針指向ep0。ep_in和ep_out是usb_device中的輸入和輸入端點的指針，各16個，說明usb裝置最多有16個輸入輸出端點。
下一步判斷了函數傳入的參數parent是否存在，這裡函數傳入的parent參數為NULL，是以不存在。因為是根集線器，是以不存在父裝置。又有一些結構體指針的關聯，還是用圖來說明
簡單來說就是将根集線器資料結構usb_device與主機控制器資料結構usb_hcd進行了關聯，怎麼關聯的呢？将根集線器的通用裝置成員device dev的父對象設定為usb總線的控制器，也就是主機控制器fsl-ehci，然後将根集線器的總線指針usb_bus *bus指向主機控制器的總線成員self。
至此，usb_alloc_dev()函數執行完成，已經配置設定好一個根集線器資料結構，并進行了一些初始化工作，但是到目前為止，根集線器裝置仍然沒有被注冊到系統，是以其probe函數仍然沒有被調用。
接下來調用了hcd驅動的reset函數，向系統注冊了usb_hcd_irq()作為主機控制器的中斷例程，調用hcd的start函數。調用register_root_hub()向系統注冊根集線器，調用usb_hcd_poll_rh_status()啟動輪詢端口狀态。這些部分内容比較多，關系比較複雜，我們先上一張圖從主機控制和根集線器兩條線來看整個過程和它們之間的關系
後文分别分析register_root_hub()、hcd的reset和start、hcd的中斷函數usb_hcd_irq()以及定時器函數rh_timer_func()主要作用。