============= 本系列参考 =============
《圈圈教你玩USB》、《Linux那些事儿之我是USB》
协议文档：https://www.usb.org/document-library/usb-20-specification usb_20_20190524/usb_20.pdf
调试工具：Beagle USB 480 逻辑分析仪、sys/kernel/debug/usb/usbmon/
代码：linux-3.10.65/drivers/usb/core/hub.c
====================================
前言
由于USB设备是先被hub识别的， 所以这次先分析hub代码， 与前面两篇博文连贯起来
一、 hub加载
在USB子系统核心模块被调用：
/* drivers/usb/core/usb.c */ static int __init usb_init(void) { int retval; if (nousb) { pr_info("%s: USB support disabled\n", usbcore_name); return 0; } retval = usb_debugfs_init(); if (retval) goto out; usb_acpi_register(); retval = bus_register(&usb_bus_type); if (retval) goto bus_register_failed; retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb); if (retval) goto bus_notifier_failed; retval = usb_major_init(); if (retval) goto major_init_failed; retval = usb_register(&usbfs_driver); if (retval) goto driver_register_failed; retval = usb_devio_init(); if (retval) goto usb_devio_init_failed; retval = usb_hub_init(); if (retval) goto hub_init_failed; retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE); if (!retval) goto out; usb_hub_cleanup(); hub_init_failed: usb_devio_cleanup(); usb_devio_init_failed: usb_deregister(&usbfs_driver); driver_register_failed: usb_major_cleanup(); major_init_failed: bus_unregister_notifier(&usb_bus_type, &usb_bus_nb); bus_notifier_failed: bus_unregister(&usb_bus_type); bus_register_failed: usb_acpi_unregister(); usb_debugfs_cleanup(); out: return retval; } /* * Cleanup */ static void __exit usb_exit(void) { /* This will matter if shutdown/reboot does exitcalls. */ if (nousb) return; usb_deregister_device_driver(&usb_generic_driver); usb_major_cleanup(); usb_deregister(&usbfs_driver); usb_devio_cleanup(); usb_hub_cleanup(); bus_unregister_notifier(&usb_bus_type, &usb_bus_nb); bus_unregister(&usb_bus_type); usb_acpi_unregister(); usb_debugfs_cleanup(); } subsys_initcall(usb_init); module_exit(usb_exit); MODULE_LICENSE("GPL");
/* drivers/usb/core/hub.c */ 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, }; int usb_hub_init(void) { if (usb_register(&hub_driver) < 0) { printk(KERN_ERR "%s: can't register hub driver\n", usbcore_name); return -1; } khubd_task = kthread_run(hub_thread, NULL, "khubd"); if (!IS_ERR(khubd_task)) return 0; /* Fall through if kernel_thread failed */ usb_deregister(&hub_driver); printk(KERN_ERR "%s: can't start khubd\n", usbcore_name); return -1; }
usb_hub_init()就做两件事， 一是注册驱动--针对hub接口设备的驱动， 二是创建内核线程“khubd”， 我们后续会详解
记住hub本省也是个usb设备， 跟普通的U盘使用的都是同样的结构体， 当有hub设备被创建时，hub驱动的probe()将会match调用， 那问题来了，一个普通设备是被hub创建的， 那hub设备是谁创建的呢？
很显然最初的root hub设备必须是静态创建的， 且这部分代码没放在hub.c， 而是放到了hcd.c， 可以看出一个Host必然有一个root hub， 是绑定的！
int usb_add_hcd(struct usb_hcd *hcd, unsigned int irqnum, unsigned long irqflags) { int retval; struct usb_device *rhdev; /* 1. 创建一个root hub设备 */ 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; } /* 2. 让hcd与root hub 紧紧地绑在一起！ */ hcd->self.root_hub = rhdev; /* 3. 注册usb设备 */ if ((retval = register_root_hub(hcd)) != 0) goto err_register_root_hub; return retval; } EXPORT_SYMBOL_GPL(usb_add_hcd); ========================================= /* root hub 设备默认就接在Host， 不是热拔插 */ static int register_root_hub(struct usb_hcd *hcd) { struct device *parent_dev = hcd->self.controller; struct usb_device *usb_dev = hcd->self.root_hub; int retval; /* 4. 有效设备地址1~127， root hub默认使用地址1 */ usb_dev->devnum = 1; /* 5. 直接进入地址阶段 */ usb_set_device_state(usb_dev, USB_STATE_ADDRESS); /* 6. 直接设置ep0 size=64， 看来是协议规定的了 */ usb_dev->ep0.desc.wMaxPacketSize = cpu_to_le16(64); /* 7. root hub 也是设备， 也要获取各种描述符 */ retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE); retval = usb_get_bos_descriptor(usb_dev); /* 8. 注册设备（是注册usb_device， 不是usb_interface） */ retval = usb_new_device (usb_dev); return retval; }
着重说明usb_generic_driver会与所有的usb_device进行match， 然后选择合适的配置描述符，设置配置描述符时自然就设置interace， 也即创建usb_interface， 这个接口设备才是各个驱动对应的设备， 比如我们现在讨论的hub_driver
就是针对hub的usb_interface， 不是hub的usb_device， usb_device代表是这个设备整体抽象， usb_interface代表是具体的某样功能， 需要具体的驱动操作。
当注册一个USB Host时就静态创建root hub设备， 经过简单初始化后注册就会与usb_generic_driver 进行match创建具体的usb_interface， 当注册接口设备时就会match到hub_driver.probe()， 我们继续看看probe做了啥
二、hub驱动probe()
static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id) { struct usb_host_interface *desc; struct usb_endpoint_descriptor *endpoint; struct usb_device *hdev; struct usb_hub *hub; desc = intf->cur_altsetting; /* 1. 要求除了ep0， 必须有且只有一个ep 还是INT型 */ if (desc->desc.bNumEndpoints != 1) goto descriptor_error; endpoint = &desc->endpoint[0].desc; if (!usb_endpoint_is_int_in(endpoint)) goto descriptor_error; /* 2. 这是和普通设备的区别， 除了用usb_device描述外，hub还会创建usb_hub和usb_port */ hub = kzalloc(sizeof(*hub), GFP_KERNEL); dev_info (&intf->dev, "USB hub found\n"); if (hub_configure(hub, endpoint) >= 0) return 0; } static int hub_configure(struct usb_hub *hub, struct usb_endpoint_descriptor *endpoint) { /* 3. 主要获取hub有多少个port */ ret = get_hub_descriptor(hdev, hub->descriptor); hdev->maxchild = hub->descriptor->bNbrPorts; /* 4. 这也是和普通外设的区别， 会创建port， 这里只是创建指针， 真正创建在后面 */ hub->ports = kzalloc(hdev->maxchild * sizeof(struct usb_port *), GFP_KERNEL); /* 5. hub内部高速与全/低速不可兼容， 所以需要两部分传输电路， 根据需要进行切换 SINGLE_TT指的是hub只有一个转换电路针对整个hub，MULTI_TT表示每个port都有个TT转换电路可以针对每个port（土豪） TTTT指的是转换电路后需要多少时间才稳定， 只有稳定了才可以传输数据*/ switch (hdev->descriptor.bDeviceProtocol) { case USB_HUB_PR_FS: break; case USB_HUB_PR_HS_SINGLE_TT: dev_dbg(hub_dev, "Single TT\n"); hub->tt.hub = hdev; break; case USB_HUB_PR_HS_MULTI_TT: ret = usb_set_interface(hdev, 0, 1); if (ret == 0) { dev_dbg(hub_dev, "TT per port\n"); hub->tt.multi = 1; } else dev_err(hub_dev, "Using single TT (err %d)\n", ret); hub->tt.hub = hdev; break; case USB_HUB_PR_SS: /* USB 3.0 hubs don't have a TT */ break; default: dev_dbg(hub_dev, "Unrecognized hub protocol %d\n", hdev->descriptor.bDeviceProtocol); break; } /* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */ switch (wHubCharacteristics & HUB_CHAR_TTTT) { case HUB_TTTT_8_BITS: if (hdev->descriptor.bDeviceProtocol != 0) { hub->tt.think_time = 666; dev_dbg(hub_dev, "TT requires at most %d " "FS bit times (%d ns)\n", 8, hub->tt.think_time); } break; case HUB_TTTT_16_BITS: hub->tt.think_time = 666 * 2; dev_dbg(hub_dev, "TT requires at most %d " "FS bit times (%d ns)\n", 16, hub->tt.think_time); break; case HUB_TTTT_24_BITS: hub->tt.think_time = 666 * 3; dev_dbg(hub_dev, "TT requires at most %d " "FS bit times (%d ns)\n", 24, hub->tt.think_time); break; case HUB_TTTT_32_BITS: hub->tt.think_time = 666 * 4; dev_dbg(hub_dev, "TT requires at most %d " "FS bit times (%d ns)\n", 32, hub->tt.think_time); break; } /* 7. 申请一个urb并填充， 后续在hub_activate会调用usb_submit_urb */ hub->urb = usb_alloc_urb(0, GFP_KERNEL); usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq, hub, endpoint->bInterval); /* 8. 真正创建usb_port设备 */ for (i = 0; i < hdev->maxchild; i++) { ret = usb_hub_create_port_device(hub, i + 1); if (ret < 0) { dev_err(hub->intfdev, "couldn't create port%d device.\n", i + 1); hdev->maxchild = i; goto fail_keep_maxchild; } } /* 9. 激活 */ hub_activate(hub, HUB_INIT); return 0; } static void hub_activate(struct usb_hub *hub, enum hub_activation_type type) { struct usb_device *hdev = hub->hdev; for (port1 = 1; port1 <= hdev->maxchild; ++port1) { struct usb_device *udev = hub->ports[port1 - 1]->child; u16 portstatus, portchange; portstatus = portchange = 0; status = hub_port_status(hub, port1, &portstatus, &portchange); if (udev || (portstatus & USB_PORT_STAT_CONNECTION) || (portstatus & USB_PORT_STAT_OVERCURRENT)) /* 10. 前面读取portstatus&portchange 就是为了标志change_bits， 因为内核线程会读取看有没有变化 其实内核线程也会调用hub_port_status，我觉得可以不需要change_bits， 之所以存在是线程khubd 一运行就第一时间知道有没有设备插入， 或者线程读之前是不是状态又发生了变化*/ set_bit(port1, hub->change_bits); } /* 11. 第一次提交urb，后续的提交就在urb的回调函数hub_irq()里调用 */ status = usb_submit_urb(hub->urb, GFP_NOIO); /* 12. 其实submit后就会调用回调函数hub_irq(), 里面就会调用kick_khubd(hub)，不知道为何这里重复调用一次 */ kick_khubd(hub); }
整个核心就是创建usb_hub结构体、获取hub描述符知道多少个port后又创建usb_port结构体、初始化TT转换电路、然后顺便读取状态看有没有外设插入， 之所以说是顺便是因为内核线程khubd才是主业做这个查询状态的， 无论是这次顺带读还是
khubd读总得有个urb， 所以就申请一个urb，采用中断传输模式， 并触发第一次submit提交， 然后在回调函数再次提交urb
三、 内核线程khubd
上面probe()是针对每个hub设备都会有的行为， 创建usb_hub、usb_port，申请一个urb， 但有一个共同操作， 就是内核线程khubd， 所以它放在usb_hub_init()
hub_thread() -> hub_events()： /* 1. 处理每个hub， 并从链表删除这个hub */ while (1) { /* 2. 如果链表空了就退出 */ if (list_empty(&hub_event_list)) { spin_unlock_irq(&hub_event_lock); break; } tmp = hub_event_list.next; list_del_init(tmp); hub = list_entry(tmp, struct usb_hub, event_list); hub_dev = hub->intfdev; intf = to_usb_interface(hub_dev); /* 3. 处理每个hub的每个port */ for (i = 1; i <= hub->descriptor->bNbrPorts; i++) { /* 4. 早前提到的顺带读取状态会操作change_bits */ connect_change = test_bit(i, hub->change_bits); ret = hub_port_status(hub, i, &portstatus, &portchange); printk("ret=%d, portstatus=0x%x, portchange=0x%x\n", ret, portstatus, portchange); if (portchange & USB_PORT_STAT_C_CONNECTION) { usb_clear_port_feature(hdev, i, USB_PORT_FEAT_C_CONNECTION); connect_change = 1; } /* 5. 如果有设备插入， 则创建新的设备 */ if (connect_change) hub_port_connect_change(hub, i, portstatus, portchange); } /* end for i */ } /* end while (1) */
线程就是不断从链表取出hub， 然后扫描hub的所有port看有没有外设插入， 有的话就通过hub_port_connect_change()创建， 这样所有的hub，所有的port就都被访问到了， 那链表的hub是什么时候挂上去的呢？
这就是上面提到的urb， 每个hub外设都会申请一个urb， 采用中断传输， 传输的内容就是读取hub的状态， 如果状态改变， 则将这个hub挂到链表上去， 同时启动内核线程， 线程自然就会处理这些hub了！
static void hub_port_connect_change(struct usb_hub *hub, int port1, u16 portstatus, u16 portchange) { udev = usb_alloc_dev(hdev, hdev->bus, port1); choose_devnum(udev); hub_port_init(hub, udev, port1, i); -> hub_port_reset() -> usb_get_device_descriptor -> hub_port_reset -> usb_get_device_descriptor usb_new_device(udev); }