/*
 * Init
 */
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;
}

subsys_initcall(usb_init);

/*
 * Notifications of device and interface registration
 */
static int usb_bus_notify(struct notifier_block *nb, unsigned long action,
        void *data)
{
    struct device *dev = data;

    switch (action) {
    case BUS_NOTIFY_ADD_DEVICE:
        if (dev->type == &usb_device_type)//usb 設(shè)備   
            (void) usb_create_sysfs_dev_files(to_usb_device(dev)); //創(chuàng)建descriptors文件
        else if (dev->type == &usb_if_device_type) //usb接口
            (void) usb_create_sysfs_intf_files(
                    to_usb_interface(dev));//創(chuàng)建interface文件
        break;

    case BUS_NOTIFY_DEL_DEVICE:
        if (dev->type == &usb_device_type)//usb設(shè)備
            usb_remove_sysfs_dev_files(to_usb_device(dev));//刪除descriptors文件
        else if (dev->type == &usb_if_device_type)//usb接口
            usb_remove_sysfs_intf_files(to_usb_interface(dev));//刪除interface文件
        break;
    }
    return 0;
}

struct usb_driver usbfs_driver = {  
    .name =     "usbfs",  
    .probe =    driver_probe,  
    .disconnect =   driver_disconnect,  
    .suspend =  driver_suspend,  
    .resume =   driver_resume,  
}; 

/**
 * usb_register_driver - register a USB interface driver
 * @new_driver: USB operations for the interface driver
 * @owner: module owner of this driver.
 * @mod_name: module name string
 *
 * Registers a USB interface driver with the USB core.  The list of
 * unattached interfaces will be rescanned whenever a new driver is
 * added, allowing the new driver to attach to any recognized interfaces.
 * Returns a negative error code on failure and 0 on success.
 *
 * NOTE: if you want your driver to use the USB major number, you must call
 * usb_register_dev() to enable that functionality.  This function no longer
 * takes care of that.
 */
int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
            const char *mod_name)
{
    int retval = 0;

    if (usb_disabled())
        return -ENODEV;

    new_driver->drvwrap.for_devices = 0;
    new_driver->drvwrap.driver.name = (char *) new_driver->name;
    new_driver->drvwrap.driver.bus = &usb_bus_type;
    new_driver->drvwrap.driver.probe = usb_probe_interface;
    new_driver->drvwrap.driver.remove = usb_unbind_interface;
    new_driver->drvwrap.driver.owner = owner;
    new_driver->drvwrap.driver.mod_name = mod_name;
    spin_lock_init(&new_driver->dynids.lock);
    INIT_LIST_HEAD(&new_driver->dynids.list);

    retval = driver_register(&new_driver->drvwrap.driver);
    if (retval)
        goto out;

    usbfs_update_special();

    retval = usb_create_newid_file(new_driver);
    if (retval)
        goto out_newid;

    retval = usb_create_removeid_file(new_driver);
    if (retval)
        goto out_removeid;

    pr_info("%s: registered new interface driver %s\n",
            usbcore_name, new_driver->name);

out:
    return retval;

out_removeid:
    usb_remove_newid_file(new_driver);
out_newid:
    driver_unregister(&new_driver->drvwrap.driver);

    printk(KERN_ERR "%s: error %d registering interface "
            "    driver %s\n",
            usbcore_name, retval, new_driver->name);
    goto out;
}
EXPORT_SYMBOL_GPL(usb_register_driver);

/**
 * bus_add_driver - Add a driver to the bus.
 * @drv: driver.
 */
int bus_add_driver(struct device_driver *drv)
{
    struct bus_type *bus;
    struct driver_private *priv;
    int error = 0;

    bus = bus_get(drv->bus);
    if (!bus)
        return -EINVAL;

    pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);

    priv = kzalloc(sizeof(*priv), GFP_KERNEL);
    if (!priv) {
        error = -ENOMEM;
        goto out_put_bus;
    }
    klist_init(&priv->klist_devices, NULL, NULL);
    priv->driver = drv;
    drv->p = priv;
    priv->kobj.kset = bus->p->drivers_kset;
    error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
                     "%s", drv->name);
    if (error)
        goto out_unregister;

    if (drv->bus->p->drivers_autoprobe) {
        error = driver_attach(drv);
        if (error)
            goto out_unregister;
    }
    klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
    module_add_driver(drv->owner, drv);

    error = driver_create_file(drv, &driver_attr_uevent);
    if (error) {
        printk(KERN_ERR "%s: uevent attr (%s) failed\n",
            __func__, drv->name);
    }
    error = driver_add_attrs(bus, drv);
    if (error) {
        /* How the hell do we get out of this pickle? Give up */
        printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",
            __func__, drv->name);
    }

    if (!drv->suppress_bind_attrs) {
        error = add_bind_files(drv);
        if (error) {
            /* Ditto */
            printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
                __func__, drv->name);
        }
    }

    kobject_uevent(&priv->kobj, KOBJ_ADD);
    return 0;

out_unregister:
    kobject_put(&priv->kobj);
    kfree(drv->p);
    drv->p = NULL;
out_put_bus:
    bus_put(bus);
    return error;
}

int __init usbfs_init(void)
{
    int retval;

    retval = register_filesystem(&usb_fs_type);
    if (retval)
        return retval;

    usb_register_notify(&usbfs_nb);

    /* create mount point for usbfs */
    usbdir = proc_mkdir("bus/usb", NULL);

    return 0;
}

static int usbfs_notify(struct notifier_block *self, unsigned long action, void *dev)
{
    switch (action) {
    case USB_DEVICE_ADD:
        usbfs_add_device(dev);//在bus號創(chuàng)建的目錄下，根據(jù)設(shè)備號創(chuàng)建設(shè)備文件
        break;
    case USB_DEVICE_REMOVE:
        usbfs_remove_device(dev);//刪除bus號創(chuàng)建的目錄下的設(shè)備文件
        break;
    case USB_BUS_ADD:
        usbfs_add_bus(dev);//根據(jù)bus號創(chuàng)建目錄
        break;
    case USB_BUS_REMOVE:
        usbfs_remove_bus(dev);//刪除bus號創(chuàng)建的目錄
    }

    usbfs_update_special();//更新文件系統(tǒng)節(jié)點
    usbfs_conn_disc_event();

    return NOTIFY_OK;
}

static int usb_device_match(struct device *dev, struct device_driver *drv)
{
    /* devices and interfaces are handled separately */
    if (is_usb_device(dev)) {

        /* interface drivers never match devices */
        if (!is_usb_device_driver(drv))
            return 0;

        /* TODO: Add real matching code */
        return 1;

    } else if (is_usb_interface(dev)) {
        struct usb_interface *intf;
        struct usb_driver *usb_drv;
        const struct usb_device_id *id;

        /* device drivers never match interfaces */
        if (is_usb_device_driver(drv))
            return 0;

        intf = to_usb_interface(dev);
        usb_drv = to_usb_driver(drv);

        id = usb_match_id(intf, usb_drv->id_table);
        if (id)
            return 1;

        id = usb_match_dynamic_id(intf, usb_drv);
        if (id)
            return 1;
    }

    return 0;
}

struct usb_device_driver usb_generic_driver = {
    .name =    "usb",
    .probe = generic_probe,
    .disconnect = generic_disconnect,
#ifdef    CONFIG_PM
    .suspend = generic_suspend,
    .resume = generic_resume,
#endif
    .supports_autosuspend = 1,
};

static int generic_probe(struct usb_device *udev)
{
    int err, c;

    if (udev->authorized == 0)
        dev_err(&udev->dev, "Device is not authorized for usage\n");
    else {
        c = usb_choose_configuration(udev);
        if (c >= 0) {
            err = usb_set_configuration(udev, c);
            if (err) {
                dev_err(&udev->dev, "can't set config #%d, error %d\n",
                    c, err);
                /* This need not be fatal.  The user can try to
                 * set other configurations. */
            }
        }
    }
    usb_notify_add_device(udev);
    return 0;
}

//為usb device選擇一個合適的配置
int usb_choose_configuration(struct usb_device *udev)
{
    int i;
    int num_configs;
    int insufficient_power = 0;
    struct usb_host_config *c, *best;
 
    best = NULL;
    //udev->config,其實是一個數(shù)組,存放設(shè)備的配置.usb_dev->config[m]-> interface[n]表示第m個配置的第n個接口的intercace結(jié)構(gòu).(m,n不是配置序號和接口序號).
    c = udev->config;
    //config項數(shù)
    num_configs = udev->descriptor.bNumConfigurations;
    //遍歷所有配置項
    for (i = 0; i < num_configs; (i++, c++)) {
        struct usb_interface_descriptor *desc = NULL;
 
        //配置項的接口數(shù)目
        //取配置項的第一個接口
        if (c->desc.bNumInterfaces > 0)
            desc = &c->intf_cache[0]->altsetting->desc;
 
        ... ...

        //電源不足.配置描述符中的電力是所需電力的1/2
        if (c->desc.bMaxPower * 2 > udev->bus_mA) {
            insufficient_power++;
            continue;
        }
   
         //非標(biāo)準Ethernet-over-USB協(xié)議
　　　if (i == 0 && num_configs > 1 && desc &&
　　　　        (is_rndis(desc) || is_activesync(desc))){
        
　　　　　　... ...

　　　　 }
        //選擇一個不是USB_CLASS_VENDOR_SPEC的配置
　　　　　else if (udev->descriptor.bDeviceClass !=
                        USB_CLASS_VENDOR_SPEC &&
                (!desc || desc->bInterfaceClass !=
                        USB_CLASS_VENDOR_SPEC)) {
            best = c;
            break;
        }
 
        /*如果所有剩下的配置是特殊的vendor,選擇第一個*/
        else if (!best)
            best = c;
    }
 
    ... ...

    //如果選擇好了配置,返回配置的序號,否則,返回-1
    if (best) {
        i = best->desc.bConfigurationValue;
        dev_info(&udev->dev,
            "configuration #%d chosen from %d choice%s\n",
            i, num_configs, plural(num_configs));
    } else {
        i = -1;
        dev_warn(&udev->dev,
            "no configuration chosen from %d choice%s\n",
            num_configs, plural(num_configs));
    }

    return i;
}    

int usb_set_configuration(struct usb_device *dev, int configuration)
{
    ... ...

    if (cp && configuration == 0)
        dev_warn(&dev->dev, "config 0 descriptor??\n");

　　/*首先,根據(jù)選擇好的配置號找到相應(yīng)的配置,在這里要注意了, dev->config[]數(shù)組中的配置并不是按照配置的序號來存放的,而是按照遍歷到順序來排序的.因為有些設(shè)備在發(fā)送配置描述符的時候,并不是按照配置序號來發(fā)送的,例如,配置2可能在第一次GET_CONFIGURATION就被發(fā)送了,而配置1可能是在第二次GET_CONFIGURATION才能發(fā)送.
　　  取得配置描述信息之后,要對它進行有效性判斷,注意一下本段代碼的最后幾行代碼:usb2.0 spec上規(guī)定,0號配置是無效配置,但是可能有些廠商的設(shè)備并末按照這一約定,所以在linux中,遇到這種情況只是打印出警告信息,然后嘗試使用這一配置.*/
    n = nintf = 0;
    if (cp) {
        //接口總數(shù)
        nintf = cp->desc.bNumInterfaces;
        //在這里, 注要是為new_interfaces分配空間,要這意的是, new_interfaces是一個二級指針,它的最終指向是struct usb_interface結(jié)構(gòu).特別的,如果總電流數(shù)要小于配置所需電流,則打印出警告消息.實際上,這種情況在usb_choose_configuration()中已經(jīng)進行了過濾.
        new_interfaces = kmalloc(nintf * sizeof(*new_interfaces),
                GFP_KERNEL);
        ... ... 
 
        for (; n < nintf; ++n) {
            new_interfaces[n] = kzalloc(
                    sizeof(struct usb_interface),
                    GFP_KERNEL);
             ... ...
        }
 
        //如果總電源小于所需電流,打印警告信息
        i = dev->bus_mA - cp->desc.bMaxPower * 2;
        ... ...
    }
　
    //要對設(shè)備進行配置了,先喚醒它
    ret = usb_autoresume_device(dev);
    if (ret)
        goto free_interfaces;
 
     //不是處于ADDRESS狀態(tài),先清除設(shè)備的狀態(tài)
    if (dev->state != USB_STATE_ADDRESS)
        usb_disable_device(dev, 1); /* Skip ep0 */
 
    //確定我們有足夠帶寬提供這個配置
    ret = usb_hcd_alloc_bandwidth(dev, cp, NULL, NULL);
    ... ...

    //發(fā)送控制消息,選取配置
    ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
                  USB_REQ_SET_CONFIGURATION, 0, configuration, 0,
                  NULL, 0, USB_CTRL_SET_TIMEOUT);
     ... ...
    }
 
    //dev->actconfig存放的是當(dāng)前設(shè)備選取的配置
    dev->actconfig = cp;
     ... ...
    //將狀態(tài)設(shè)為CONFIGURED
    usb_set_device_state(dev, USB_STATE_CONFIGURED);
    /*接下來,就要對設(shè)備進行配置了,首先,將設(shè)備喚醒.只有在ADDRESS狀態(tài)才能轉(zhuǎn)入到CONFIG狀態(tài).(SUSPEND狀態(tài)除外). 所以,如果設(shè)備當(dāng)前不是處于ADDRESS狀態(tài),就需要將設(shè)備的狀態(tài)初始化
    接著,發(fā)送SET_CONFIGURATION的Control消息給設(shè)備,用來選擇配置最后,將dev->actconfig指向選定的配置,將設(shè)備狀態(tài)設(shè)為CONFIG*/
 
     //遍歷所有的接口
    for (i = 0; i < nintf; ++i) {
        struct usb_interface_cache *intfc;
        struct usb_interface *intf;
        struct usb_host_interface *alt;
　     /*之前初始化的new_interfaces在這里終于要派上用場了.初始化各接口,從上面的初始化過程中,我們可以看出:
　　　　Intf->altsetting,表示接口的各種設(shè)置
　　　　Intf->num_altsetting:表示接口的設(shè)置數(shù)目
　　　　Intf->intf_assoc:接口的關(guān)聯(lián)接口(定義于minor usb 2.0 spec)
　　　　Intf->cur_altsetting:接口的當(dāng)前設(shè)置.*/
        cp->interface[i] = intf = new_interfaces[i];
        intfc = cp->intf_cache[i];
        intf->altsetting = intfc->altsetting;
        intf->num_altsetting = intfc->num_altsetting;
        //是否關(guān)聯(lián)的接口描述符,定義在minor usb 2.0 spec中
        intf->intf_assoc = find_iad(dev, cp, i);
        kref_get(&intfc->ref);
 
        //選擇0號設(shè)置
        alt = usb_altnum_to_altsetting(intf, 0);

        //如果0號設(shè)置不存在,選排在第一個設(shè)置
        if (!alt)
            alt = &intf->altsetting[0];
 
        //當(dāng)前的配置
        intf->cur_altsetting = alt;
　　　　 //用來啟用接口,也就是啟用接口中的每一個endpoint.
        usb_enable_interface(dev, intf);
        //注意這個地方對intf內(nèi)嵌的struct devcie結(jié)構(gòu)賦值,它的type被賦值為了usb_if_device_type.bus還是usb_bus_type.可能你已經(jīng)反應(yīng)過來了,要和這個device匹配的設(shè)備是interface的驅(qū)動.
        intf->dev.parent = &dev->dev;
        intf->dev.driver = NULL;
        intf->dev.bus = &usb_bus_type;
        intf->dev.type = &usb_if_device_type;
        intf->dev.dma_mask = dev->dev.dma_mask;
        device_initialize(&intf->dev);//device 初始化
        mark_quiesced(intf);
　　　　　/*
　　　　　  device的命名:
　　　　　　dev指的是這個接口所屬的usb_dev,結(jié)合我們之前在UHCI中關(guān)于usb設(shè)備命名方式的描述.可得出它的命令方式如下:
　　　　　　USB總線號-設(shè)備路徑:配置號.接口號.
　　　　　　例如,在我的虛擬機上:/sys/bus/usb/devices
　　　　　　1-0:1.0 usb1
　　　　　　可以得知,系統(tǒng)只有一個usb control.
　　　　　　1-0:1.0:表示,第一個usb control下的root hub的1號配置的0號接口.
        */
        sprintf(&intf->dev.bus_id[0], "%d-%s:%d.%d",
            dev->bus->busnum, dev->devpath,
            configuration, alt->desc.bInterfaceNumber);
    }
    kfree(new_interfaces);
 
    if (cp->string == NULL)
        cp->string = usb_cache_string(dev, cp->desc.iConfiguration);

    //注冊每一個接口?
    for (i = 0; i < nintf; ++i) {
        struct usb_interface *intf = cp->interface[i];
 
        dev_dbg(&dev->dev,
            "adding %s (config #%d, interface %d)\n",
            intf->dev.bus_id, configuration,
            intf->cur_altsetting->desc.bInterfaceNumber);
        ret = device_add(&intf->dev);//增加device
        if (ret != 0) {
            dev_err(&dev->dev, "device_add(%s) --> %d\n",
                intf->dev.bus_id, ret);
            continue;
        }
        usb_create_sysfs_intf_files(intf);
    }
 
    //使設(shè)備suspend
    usb_autosuspend_device(dev);

    return 0;
}

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

static void hub_events(void)
{
　　... ...
    while (1) {

        //如果hub_event_list為空，退出
        spin_lock_irq(&hub_event_lock);
        if (list_empty(&hub_event_list)) {
            spin_unlock_irq(&hub_event_lock);
            break;
        }
        //取hub_event_list中的后一個元素，并將其斷鏈
        tmp = hub_event_list.next;
        list_del_init(tmp);
 
　　　　 //根據(jù)tmp獲取hub
        hub = list_entry(tmp, struct usb_hub, event_list);
        //增加hub計數(shù)
        kref_get(&hub->kref);
　　　　 //解鎖
        spin_unlock_irq(&hub_event_lock);
 
        hdev = hub->hdev;
        hub_dev = hub->intfdev;
        intf = to_usb_interface(hub_dev);
　　　　 ... ...
        usb_lock_device(hdev);
        //如果hub斷開了,繼續(xù)hub_event_list中的下一個
        if (unlikely(hub->disconnected))
            goto loop;
 
        //設(shè)備沒有連接上
        if (hdev->state == USB_STATE_NOTATTACHED) {
            hub->error = -ENODEV;
            //將下面的子設(shè)備全部disable
            hub_pre_reset(intf);
            goto loop;
        }
 
        /* 自動恢復(fù) */
        ret = usb_autopm_get_interface(intf);
        if (ret) {
            dev_dbg(hub_dev, "Can't autoresume: %d\n", ret);
            goto loop;
        }
 
        //hub 暫停
        if (hub->quiescing)
            goto loop_autopm;
 
        //hub 有錯誤發(fā)生？
        if (hub->error) {
            dev_dbg (hub_dev, "resetting for error %d\n",
                hub->error);
 
            ret = usb_reset_composite_device(hdev, intf);
            if (ret) {
                dev_dbg (hub_dev,
                    "error resetting hub: %d\n", ret);
                goto loop_autopm;
            }
 
            hub->nerrors = 0;
            hub->error = 0;
        }
　　　　 /*首先,從hub_event_list摘下第一個元素,根據(jù)我們之前在接口驅(qū)動probe過程的kick_khubd()函數(shù)分析中,有將hub-> event_list添加到hub_event_list.因此,就可以順藤摸瓜找到hub,再根據(jù)hub結(jié)構(gòu),找到接口結(jié)構(gòu)和所屬的usb 設(shè)備結(jié)構(gòu).
         然后,進行第一個重要的判斷.如果hub被斷開了,則,斷開hub下面所連接的所有端口,這是在hub_pre_reset()中完成的.
         最后,進行第二個重要的判斷,如果hub發(fā)生了錯誤,則reset它下面的所有端口,這是在usb_reset_composite_device()中完成的.*/
 
        //在這里,它遍歷hub上的每一個端口,如果端口的連接會生了改變(connect_change等于1)的情況,就會調(diào)用hub_port_connect_change()
        for (i = 1; i <= hub->descriptor->bNbrPorts; i++) {
　　　　　　  //檢測端口是否忙
            if (test_bit(i, hub->busy_bits))
                continue;
            //change_bits會在hub 第一次初始化時被賦值。而event_bits則在hub_irq中改變
            connect_change = test_bit(i, hub->change_bits);
            //如果都沒有改變，繼續(xù)測試下一個端口。
            if (!test_and_clear_bit(i, hub->event_bits) &&
                    !connect_change && !hub->activating)
                continue;
 
        //Get_Port_Status:取得端口狀態(tài).
        //會取得port的改變值和狀態(tài)值
            ret = hub_port_status(hub, i,
                    &portstatus, &portchange);
            if (ret < 0)
                continue;
 
　　　　　　　//在struct usb_dev中,有一個struct usb_device *children[USB_MAXCHILDREN]的成員,它是表示對應(yīng)端口序號上所連接的usb設(shè)備.
            //如果對應(yīng)端口沒有在設(shè)備樹上,且端口顯示已經(jīng)連接上
            //將connect_change置為1
            if (hub->activating && !hdev->children[i-1] &&
                    (portstatus &
                        USB_PORT_STAT_CONNECTION))
                connect_change = 1;
            //端口的連接狀態(tài)發(fā)生了改變.需要發(fā)送Clear_Feature
            if (portchange & USB_PORT_STAT_C_CONNECTION) {
                clear_port_feature(hdev, i,
                    USB_PORT_FEAT_C_CONNECTION);
                connect_change = 1;
            }
 
            //端口的狀態(tài)從enable 變?yōu)榱薲isable
            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);

                 //端口已經(jīng)被停止了,且端口已經(jīng)被連在設(shè)備樹中.
                 //需要重啟一下此端口
                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;
                }
            }
 
            //Resume完成   
            if (portchange & USB_PORT_STAT_C_SUSPEND) {
                clear_port_feature(hdev, i,
                    USB_PORT_FEAT_C_SUSPEND);
                //如果端口連接了設(shè)備,就將設(shè)備喚醒
                if (hdev->children[i-1]) {
                    ret = remote_wakeup(hdev->
                            children[i-1]);
                    if (ret < 0)
                        connect_change = 1;
                }
                //如果端口沒有連接設(shè)備,就將端口禁用
                else {
                    ret = -ENODEV;
                    hub_port_disable(hub, i, 1);
                }
                dev_dbg (hub_dev,
                    "resume on port %d, status %d\n",
                    i, ret);
            }
 
            //有過流保護,需要對hub power on
            if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
                dev_err (hub_dev,
                    "over-current change on port %d\n",
                    i);
                clear_port_feature(hdev, i,
                    USB_PORT_FEAT_C_OVER_CURRENT);
                hub_power_on(hub);
            }
 
            //Reset狀態(tài)已經(jīng)完成了
            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);
            }
 　　　　　　
           /*什么情況下, hub_port_connect_change才會被設(shè)為1.
　　　　    1:端口在hub->change_bits中被置位.搜索整個代碼樹,發(fā)生在設(shè)置hub->change_bits的地方,只有在hub_port_logical_disconnect()中手動將端口禁用,會將對應(yīng)位置1.
           2:hub上沒有這個設(shè)備樹上沒有這個端口上的設(shè)備.但顯示端口已經(jīng)連上了設(shè)備
           3:hub這個端口上的連接發(fā)生了改變,從端口有設(shè)備連接變?yōu)闊o設(shè)備連接,或者從無設(shè)備連接變?yōu)橛性O(shè)備連接.
           4:hub的端口變?yōu)榱薲isable,此時這個端口上連接了設(shè)備,但被顯示該端口已經(jīng)變禁用,需要將connect_change設(shè)為1.
           5:端口狀態(tài)從SUSPEND變成了RESUME,遠程喚醒端口上的設(shè)備失敗,就需要將connect_change設(shè)為1.
           另外hub_port_connect_change()函數(shù)我們放在后面再來討論*/
            if (connect_change)
                hub_port_connect_change(hub, i,
                        portstatus, portchange);
        }

         //對HUB的處理
        //如果hub狀態(tài)末變化，不需要做任何處理
        if (test_and_clear_bit(0, hub->event_bits) == 0)
            ;   /* do nothing */
        //Get_hub_status 失敗?
        else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
            dev_err (hub_dev, "get_hub_status failed\n");
        else {
            //這里是對應(yīng)hub 狀態(tài)發(fā)生了改變,且Get_hub_status正常返回的情況
            //如果hub的本地電源供電發(fā)生了改變
            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;
            }
            //如果hub 發(fā)生過電源保護,需要對hub power on
            if (hubchange & HUB_CHANGE_OVERCURRENT) {
                dev_dbg (hub_dev, "overcurrent change\n");
                msleep(500);    /* Cool down */
                clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
                           hub_power_on(hub);
            }
        }
 
        hub->activating = 0;
 
        /* If this is a root hub, tell the HCD it's okay to
         * re-enable port-change interrupts now. */
        if (!hdev->parent && !hub->busy_bits[0])
            usb_enable_root_hub_irq(hdev->bus);
 
loop_autopm:
        /* Allow autosuspend if we're not going to run again */
        if (list_empty(&hub->event_list))
            usb_autopm_enable(intf);
loop:
        usb_unlock_device(hdev);
        kref_put(&hub->kref, hub_release);
    } /* end while (1) */
}

static void hub_port_connect_change(struct usb_hub *hub, int port1,
                    u16 portstatus, u16 portchange)
{  
    ... ... 

    //hub led
    if (hub->has_indicators) {
        set_port_led(hub, port1, HUB_LED_AUTO);
        hub->indicator[port1-1] = INDICATOR_AUTO;
    }

    //忽略掉CONFIG_USB_OTG的處理
#ifdef    CONFIG_USB_OTG
    /* during HNP, don't repeat the debounce */
    if (hdev->bus->is_b_host)
        portchange &= ~(USB_PORT_STAT_C_CONNECTION |
                USB_PORT_STAT_C_ENABLE);
#endif

    //嘗試喚醒一個存在的設(shè)備
    udev = hdev->children[port1-1];
    if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
            udev->state != USB_STATE_NOTATTACHED) {
        usb_lock_device(udev);
        if (portstatus & USB_PORT_STAT_ENABLE) {
            status = 0;        /* Nothing to do */

#ifdef CONFIG_USB_SUSPEND
        } else if (udev->state == USB_STATE_SUSPENDED &&
                udev->persist_enabled) {
            /* For a suspended device, treat this as a
             * remote wakeup event.
             */
            status = usb_remote_wakeup(udev);
#endif

        } else {
            status = -ENODEV;    /* Don't resuscitate */
        }
        usb_unlock_device(udev);

        if (status == 0) {
            clear_bit(port1, hub->change_bits);
            return;
        }
    }

    //如果對應(yīng)端口已經(jīng)有設(shè)備連接,先將其斷開
    if (udev)
        usb_disconnect(&hdev->children[port1-1]);

    //接下來,將hub->change_bits的對應(yīng)位清掉,該位是在函數(shù)hub_port_logical_disconnect()中被置的,在這里將其清除,免得下次在進入hub_events()的時候,再次檢測到這個位發(fā)生改變.    
    clear_bit(port1, hub->change_bits);

    //如果發(fā)生物理斷開或者連接狀態(tài)改變，我們可能忘記移除設(shè)備
    if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
            (portchange & USB_PORT_STAT_C_CONNECTION))
        clear_bit(port1, hub->removed_bits);

    //連接發(fā)生改變
    //連接反彈的處理,實際上就是除抖動
    if (portchange & (USB_PORT_STAT_C_CONNECTION |
                USB_PORT_STAT_C_ENABLE)) {
        //如果該端口的連接發(fā)生改變(從有連接到無接接,或者從無連接到有連接),就有一個除抖動的過程,usb2.0 spec上規(guī)定,除抖動的時間為100ms.
        //在函數(shù)里,定義的測試時間是1500ms.如果在這個時間內(nèi),端口還末處于穩(wěn)定狀態(tài),就會返回-ETIMEDOUT
        //如果已經(jīng)處于穩(wěn)定狀態(tài)了,就會返回穩(wěn)定狀態(tài)下的portstatus
        status = hub_port_debounce(hub, port1);
        if (status < 0) {
            if (printk_ratelimit())
                dev_err(hub_dev, "connect-debounce failed, "
                        "port %d disabled\n", port1);
            portstatus &= ~USB_PORT_STAT_CONNECTION;
        } else {
            portstatus = status;
        }
    }
    //如果接口上沒有連接了,可以直接退出了
    if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
            test_bit(port1, hub->removed_bits)) {

        /*經(jīng)過去抖后,端口穩(wěn)定的處于斷開連接狀態(tài).說明端口已經(jīng)沒有設(shè)備了.然后,再判斷hub是否有電源開關(guān)((wHubCharacteristics & HUB_CHAR_LPSM) < 2),portstatus 的 USB_PORT_FEAT_POWER位是否被設(shè)置,如果沒有被設(shè)置,則說明該端口斷電了.
          如果hub有電源開關(guān),且端口沒有上電,則需要發(fā)送POWER的Set_Feature來為之上電*/
        if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
                && !(portstatus & USB_PORT_STAT_POWER))
            set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
　　　　　//如果端口依然處理enable狀態(tài),就會跳轉(zhuǎn)到標(biāo)號done處,就端口disalbe.
        if (portstatus & USB_PORT_STAT_ENABLE)
              goto done;
        return;
    }

    /*如果端口隱定處于連接狀態(tài),那就需要連接端口下的設(shè)備了.首先看到的是一個for循環(huán),是用來配置設(shè)備的兩種方式.我們知道,在配置設(shè)備的時候,首先要去取設(shè)備的描述符,這個過程是在ep0上完成的.而這個ep0支持的最大傳輸出數(shù)據(jù)又是在設(shè)備描述符的bMaxPacketSize0中所      定義的.因此就對應(yīng)有兩種處理方式:
      第一種是傳輸8個字節(jié),取得描述符的前面一部份,從而就可以取得bMaxPacketSize0.此后再reset設(shè)備,再根據(jù)這個bMaxPacketSize0的長度去取它的設(shè)備描述符.
      第二種是一次傳輸64字節(jié),取得設(shè)備描述符的bMaxPacketSize0字段*/
    for (i = 0; i < SET_CONFIG_TRIES; i++) {

   　　 //為探測到的usb設(shè)備（包括普通hub，u盤等）分配并初始化udev
       // 在為root hub分配struct usb_dev的時候,它的第一個參數(shù),也就是它的父結(jié)點是為NULL.
       /*我們來觀察一下它在sysfs中的命名方式
         在沒有插入U盤之前:/sys/bus/usb/devices
         1-0:1.0  usb1
         插入U盤之后:
         1-0:1.0  1-1  1-1:1.0  usb1
         增加的兩個目是:
         1-1和1-1:1.0
         1-1:1.0 :只有這樣的目錄,表示該U盤只有一個接口,當(dāng)前選取的是第0號設(shè)置項.*/
        udev = usb_alloc_dev(hdev, hdev->bus, port1);
        if (!udev) {
            dev_err (hub_dev,
                "couldn't allocate port %d usb_device\n",
                port1);
            goto done;
        }
        //置為USB_STATE_POWERED狀態(tài)
        usb_set_device_state(udev, USB_STATE_POWERED);
         udev->bus_mA = hub->mA_per_port;
        udev->level = hdev->level + 1;
        udev->wusb = hub_is_wusb(hub);

        /*
         * USB 3.0 devices are reset automatically before the connect
         * port status change appears, and the root hub port status
         * shows the correct speed.  We also get port change
         * notifications for USB 3.0 devices from the USB 3.0 portion of
         * an external USB 3.0 hub, but this isn't handled correctly yet
         * FIXME.
         */
        if (!(hcd->driver->flags & HCD_USB3))
            udev->speed = USB_SPEED_UNKNOWN;
        else if ((hdev->parent == NULL) &&
                (portstatus & USB_PORT_STAT_SUPER_SPEED))
            udev->speed = USB_SPEED_SUPER;
        else
            udev->speed = USB_SPEED_UNKNOWN;

        /*為設(shè)備指定一個地址,是到所屬的usb bus的bus->devmap中找到?jīng)]有使用的那一位,先進行兩次新的策略(i=0和=1時),如果不行就再進行兩次舊的策略(i=2和i=3時).所有這一切只有一個目的,就是為了獲得設(shè)備的描述符，
        設(shè)置了udev->tt、udev->ttport和udev->ep    0.desc.wMaxPacketSize,設(shè)置udev->status= USB_STATE_ADDRESS。*/
        choose_address(udev);
        if (udev->devnum <= 0) {
            status = -ENOTCONN;    /* Don't retry */
            goto loop;
        }

        //hub_port_init()對這個usb_dev結(jié)構(gòu)進行一系的初始化,在這個函數(shù)中會處理:Get_Description,Set_address.等操作
        status = hub_port_init(hub, udev, port1, i);
        if (status < 0)
            goto loop;

        usb_detect_quirks(udev);
        if (udev->quirks & USB_QUIRK_DELAY_INIT)
            msleep(1000);

        /* consecutive bus-powered hubs aren't reliable; they can
         * violate the voltage drop budget.  if the new child has
         * a "powered" LED, users should notice we didn't enable it
         * (without reading syslog), even without per-port LEDs
         * on the parent.
         */
        if (udev->descriptor.bDeviceClass == USB_CLASS_HUB
                && udev->bus_mA <= 100) {
            u16    devstat;

            status = usb_get_status(udev, USB_RECIP_DEVICE, 0,
                    &devstat);
            if (status < 2) {
                dev_dbg(&udev->dev, "get status %d ?\n", status);
                goto loop_disable;
            }
            le16_to_cpus(&devstat);
            if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
                dev_err(&udev->dev,
                    "can't connect bus-powered hub "
                    "to this port\n");
                if (hub->has_indicators) {
                    hub->indicator[port1-1] =
                        INDICATOR_AMBER_BLINK;
                    schedule_delayed_work (&hub->leds, 0);
                }
                status = -ENOTCONN;    /* Don't retry */
                goto loop_disable;
            }
        }
 
        /* check for devices running slower than they could */
        if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200
                && udev->speed == USB_SPEED_FULL
                && highspeed_hubs != 0)
            check_highspeed (hub, udev, port1);

        /* Store the parent's children[] pointer.  At this point
         * udev becomes globally accessible, although presumably
         * no one will look at it until hdev is unlocked.
         */
        status = 0;

        // 將分配的struct usb_dev結(jié)構(gòu)跟他的父結(jié)構(gòu)關(guān)聯(lián)起來,也就是說添加到它的父結(jié)構(gòu)的usb_dev-> children[]數(shù)組.
        spin_lock_irq(&device_state_lock);
        if (hdev->state == USB_STATE_NOTATTACHED)
            status = -ENOTCONN;
        else
            hdev->children[port1-1] = udev;
        spin_unlock_irq(&device_state_lock);

        if (!status) {
          /*usb_configure_device(): 得到設(shè)備的描述符(包括設(shè)備描述符、配置描述符、接口描述符等)，分析以上描述符信息,提取出配置、接口等，并賦值給udev結(jié)構(gòu)里相應(yīng)的字段。
　　　　     device_add() :將usb設(shè)備注冊到系統(tǒng)里，這個動作將觸發(fā)驅(qū)動的匹配，由于這是個usb設(shè)備，所以萬能usb驅(qū)動usb_generic_driver會匹配上，從而generic_probe會得到執(zhí)行，從上面可以看出來，這一次hub_events()調(diào)用是由于主控制器初始化調(diào)用了
            hub_probe，從而引發(fā)hub_events調(diào)用。那root hub初始化完成以后hub_events會如何觸發(fā)呢？答案是通過中斷！而這個中斷的服務(wù)函數(shù)就是hub_irq，也即是說，凡是真正的有端口變化事件發(fā)生，hub_irq就會被調(diào)用,而hub_irq()最終會調(diào)用kick_khubd()，             觸發(fā)hub的event_list,于是再次調(diào)用hub_events().*/
            status = usb_new_device(udev);
            if (status) {
                spin_lock_irq(&device_state_lock);
                hdev->children[port1-1] = NULL;
                spin_unlock_irq(&device_state_lock);
            }
        }

        if (status)
            goto loop_disable;

        status = hub_power_remaining(hub);
        if (status)
            dev_dbg(hub_dev, "%dmA power budget left\n", status);

        return;

loop_disable:
        hub_port_disable(hub, port1, 1);
loop:
        usb_ep0_reinit(udev);
        release_address(udev);
        hub_free_dev(udev);
        usb_put_dev(udev);
        if ((status == -ENOTCONN) || (status == -ENOTSUPP))
            break;
    }
    if (hub->hdev->parent ||
            !hcd->driver->port_handed_over ||
            !(hcd->driver->port_handed_over)(hcd, port1))
        dev_err(hub_dev, "unable to enumerate USB device on port %d\n",
                port1);
// Done標(biāo)號是對應(yīng)上述處理失敗的處理,它禁用掉該端口(因為該端口沒有連接設(shè)備或者是端口上的設(shè)備配置失敗),如果是root hub,且USB控制器器驅(qū)動中又定義了relinquish_port.調(diào)用它.
done:
    hub_port_disable(hub, port1, 1);
    if (hcd->driver->relinquish_port && !hub->hdev->parent)
        hcd->driver->relinquish_port(hcd, port1);
}