USB hub驱动分析

 hub驱动主要在drivers/usb/core/hub.c文件中，usb设备的初始化、枚举、插拔检测等一般都是由hub发起的。所以要想了解设备的插拔及枚举过程，分析hub是必须的。

 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;

     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 = usbfs_init();
     if (retval)
         goto fs_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:
     usbfs_cleanup();
 fs_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_debugfs_cleanup();
 out:
     return retval;
 }

在USB模块的初始化函数中，会调用usb_hub_init函数对hub进行初始化：

 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;
 }

在该函数中，创建hub_thread线程：

 static int hub_thread(void *__unused)
 {
     /* khubd needs to be freezable to avoid intefering with USB-PERSIST
      * port handover.  Otherwise it might see that a full-speed device
      * was gone before the EHCI controller had handed its port over to
      * the companion full-speed controller.
      */
     set_freezable();

     do {
         hub_events();
         wait_event_freezable(khubd_wait,
                 !list_empty(&hub_event_list) ||
                 kthread_should_stop());
     } while (!kthread_should_stop() || !list_empty(&hub_event_list));

     pr_debug("%s: khubd exiting\n", usbcore_name);
     return 0;
 }

在hub_thread线程中，调用hub_event函数，这个函数非常重要，是hub驱动的核心函数。

 static void hub_events(void)
 {
     struct list_head *tmp;
     struct usb_device *hdev;
     struct usb_interface *intf;
     struct usb_hub *hub;
     struct device *hub_dev;
     u16 hubstatus;
     u16 hubchange;
     u16 portstatus;
     u16 portchange;
     int i, ret;
     int connect_change;

     /*
      *  We restart the list every time to avoid a deadlock with
      * deleting hubs downstream from this one. This should be
      * safe since we delete the hub from the event list.
      * Not the most efficient, but avoids deadlocks.
      */
     while (1) {

         /* Grab the first entry at the beginning of the list */
         spin_lock_irq(&hub_event_lock);
         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);
         kref_get(&hub->kref);
         spin_unlock_irq(&hub_event_lock);

         hdev = hub->hdev;
         hub_dev = hub->intfdev;
         intf = to_usb_interface(hub_dev);
         dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
                 hdev->state, hub->descriptor
                     ? hub->descriptor->bNbrPorts
                     : 0,
                 /* NOTE: expects max 15 ports... */
                 (u16) hub->change_bits[0],
                 (u16) hub->event_bits[0]);

         /* Lock the device, then check to see if we were
          * disconnected while waiting for the lock to succeed. */
         usb_lock_device(hdev);
         if (unlikely(hub->disconnected))
             goto loop_disconnected;

         /* If the hub has died, clean up after it */
         if (hdev->state == USB_STATE_NOTATTACHED) {
             hub->error = -ENODEV;
             hub_quiesce(hub, HUB_DISCONNECT);
             goto loop;
         }

         /* Autoresume */
         ret = usb_autopm_get_interface(intf);
         if (ret) {
             dev_dbg(hub_dev, "Can't autoresume: %d\n", ret);
             goto loop;
         }

         /* If this is an inactive hub, do nothing */
         if (hub->quiescing)
             goto loop_autopm;

         if (hub->error) {
             dev_dbg (hub_dev, "resetting for error %d\n",
                 hub->error);

             ret = usb_reset_device(hdev);
             if (ret) {
                 dev_dbg (hub_dev,
                     "error resetting hub: %d\n", ret);
                 goto loop_autopm;
             }

             hub->nerrors = 0;
             hub->error = 0;
         }

         /* deal with port status changes */
         for (i = 1; i <= hub->descriptor->bNbrPorts; i++) {
             if (test_bit(i, hub->busy_bits))
                 continue;
             connect_change = test_bit(i, hub->change_bits);
             if (!test_and_clear_bit(i, hub->event_bits) &&
                     !connect_change)
                 continue;

             ret = hub_port_status(hub, i,
                     &portstatus, &portchange);
             if (ret < 0)
                 continue;

             if (portchange & USB_PORT_STAT_C_CONNECTION) {
                 clear_port_feature(hdev, i,
                     USB_PORT_FEAT_C_CONNECTION);
                 connect_change = 1;
             }

             if (portchange & USB_PORT_STAT_C_ENABLE) {
                 if (!connect_change)
                     dev_dbg (hub_dev,
                         "port %d enable change, "
                         "status %08x\n",
                         i, portstatus);
                 clear_port_feature(hdev, i,
                     USB_PORT_FEAT_C_ENABLE);

                 /*
                  * EM interference sometimes causes badly
                  * shielded USB devices to be shutdown by
                  * the hub, this hack enables them again.
                  * Works at least with mouse driver.
                  */
                 if (!(portstatus & USB_PORT_STAT_ENABLE)
                     && !connect_change
                     && hdev->children[i-1]) {
                     dev_err (hub_dev,
                         "port %i "
                         "disabled by hub (EMI?), "
                         "re-enabling...\n",
                         i);
                     connect_change = 1;
                 }
             }

             if (portchange & USB_PORT_STAT_C_SUSPEND) {
                 struct usb_device *udev;

                 clear_port_feature(hdev, i,
                     USB_PORT_FEAT_C_SUSPEND);
                 udev = hdev->children[i-1];
                 if (udev) {
                     /* TRSMRCY = 10 msec */
                     msleep(10);

                     usb_lock_device(udev);
                     ret = usb_remote_wakeup(hdev->
                             children[i-1]);
                     usb_unlock_device(udev);
                     if (ret < 0)
                         connect_change = 1;
                 } else {
                     ret = -ENODEV;
                     hub_port_disable(hub, i, 1);
                 }
                 dev_dbg (hub_dev,
                     "resume on port %d, status %d\n",
                     i, ret);
             }

             if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
                 u16 status = 0;
                 u16 unused;

                 dev_dbg(hub_dev, "over-current change on port "
                     "%d\n", i);
                 clear_port_feature(hdev, i,
                     USB_PORT_FEAT_C_OVER_CURRENT);
                 msleep(100);    /* Cool down */
                 hub_power_on(hub, true);
                 hub_port_status(hub, i, &status, &unused);
                 if (status & USB_PORT_STAT_OVERCURRENT)
                     dev_err(hub_dev, "over-current "
                         "condition on port %d\n", i);
             }

             if (portchange & USB_PORT_STAT_C_RESET) {
                 dev_dbg (hub_dev,
                     "reset change on port %d\n",
                     i);
                 clear_port_feature(hdev, i,
                     USB_PORT_FEAT_C_RESET);
             }
             if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
                     hub_is_superspeed(hub->hdev)) {
                 dev_dbg(hub_dev,
                     "warm reset change on port %d\n",
                     i);
                 clear_port_feature(hdev, i,
                     USB_PORT_FEAT_C_BH_PORT_RESET);
             }
             if (portchange & USB_PORT_STAT_C_LINK_STATE) {
                 clear_port_feature(hub->hdev, i,
                         USB_PORT_FEAT_C_PORT_LINK_STATE);
             }
             if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
                 dev_warn(hub_dev,
                     "config error on port %d\n",
                     i);
                 clear_port_feature(hub->hdev, i,
                         USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
             }

             /* Warm reset a USB3 protocol port if it's in
              * SS.Inactive state.
              */
             if (hub_is_superspeed(hub->hdev) &&
                 (portstatus & USB_PORT_STAT_LINK_STATE)
                     == USB_SS_PORT_LS_SS_INACTIVE) {
                 dev_dbg(hub_dev, "warm reset port %d\n", i);
                 hub_port_warm_reset(hub, i);
             }

             if (connect_change)
                 hub_port_connect_change(hub, i,
                         portstatus, portchange);
         } /* end for i */

         /* deal with hub status changes */
         if (test_and_clear_bit(0, hub->event_bits) == 0)
             ;   /* do nothing */
         else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
             dev_err (hub_dev, "get_hub_status failed\n");
         else {
             if (hubchange & HUB_CHANGE_LOCAL_POWER) {
                 dev_dbg (hub_dev, "power change\n");
                 clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
                 if (hubstatus & HUB_STATUS_LOCAL_POWER)
                     /* FIXME: Is this always true? */
                     hub->limited_power = 1;
                 else
                     hub->limited_power = 0;
             }
             if (hubchange & HUB_CHANGE_OVERCURRENT) {
                 u16 status = 0;
                 u16 unused;

                 dev_dbg(hub_dev, "over-current change\n");
                 clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
                 msleep(500);    /* Cool down */
                             hub_power_on(hub, true);
                 hub_hub_status(hub, &status, &unused);
                 if (status & HUB_STATUS_OVERCURRENT)
                     dev_err(hub_dev, "over-current "
                         "condition\n");
             }
         }

  loop_autopm:
         /* Balance the usb_autopm_get_interface() above */
         usb_autopm_put_interface_no_suspend(intf);
  loop:
         /* Balance the usb_autopm_get_interface_no_resume() in
          * kick_khubd() and allow autosuspend.
          */
         usb_autopm_put_interface(intf);
  loop_disconnected:
         usb_unlock_device(hdev);
         kref_put(&hub->kref, hub_release);

         } /* end while (1) */
 }

       每当有设备连接到USB接口时，USB总线在查询hub状态信息的时候会触发hub的中断服务程序hub_irq,在该函数中利用kick_khubd将hub结构通过event_list添加到khubd的队列hub_event_list，然后唤醒khubd。进入hub_e vents函数，该函数用来处理khubd事件队列，从khubd的hub_event_list中的每个usb_hub数据结构。该函数中首先判断hub是否出错，然后通过一个for循环来检测每个端口的状态信息。利用usb_port_status获取端口信息，如果发生变化就调用hub_port_connect_change函数来配置端口等。