extern struct device_type usb_device_type;
    extern struct device_type usb_if_device_type;
    extern struct device_type usb_ep_device_type;
    extern struct device_type usb_port_device_type;

    static inline int is_usb_device(const struct device *dev)
    {
        return dev->type == &usb_device_type;
    }

    static inline int is_usb_interface(const struct device *dev)
    {
        return dev->type == &usb_if_device_type;
    }

    static inline int is_usb_endpoint(const struct device *dev)
    {
    return dev->type == &usb_ep_device_type;
    }

    static inline int is_usb_port(const struct device *dev)
    {
        return dev->type == &usb_port_device_type;
    }

    /*
     * Init
     */
    static int __init usb_init(void)
    {
    	int retval;
    	if (nousb) {
    		pr_info("%s: USB support disabled\n", usbcore_name);
    		return 0;
    	}
    	usb_init_pool_max();
    
    	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;
    }
    ……
    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设备
    			(void) usb_create_sysfs_dev_files(to_usb_device(dev));
    		else if (dev->type == &usb_if_device_type)	//接口设备
    			usb_create_sysfs_intf_files(to_usb_interface(dev));
    		break;
    
    	case BUS_NOTIFY_DEL_DEVICE:
    		if (dev->type == &usb_device_type)
    			usb_remove_sysfs_dev_files(to_usb_device(dev));
    		else if (dev->type == &usb_if_device_type)
    			usb_remove_sysfs_intf_files(to_usb_interface(dev));
    		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.
     *
     * Return: 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 = 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;
    
    	retval = usb_create_newid_files(new_driver);
    	if (retval)
    		goto out_newid;
    
    	pr_info("%s: registered new interface driver %s\n",
    			usbcore_name, new_driver->name);
    
    out:
    	return retval;
    
    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);

    /* workqueue to process hub events */
    static struct workqueue_struct *hub_wq;
    ……
    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;
    	}
    
    	/*
    	 * The workqueue needs to be freezable to avoid interfering 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.
    	 */
    	hub_wq = alloc_workqueue("usb_hub_wq", WQ_FREEZABLE, 0);
    	if (hub_wq)
    		return 0;
    
    	/* Fall through if kernel_thread failed */
    	usb_deregister(&hub_driver);
    	pr_err("%s: can't allocate workqueue for usb hub\n", usbcore_name);
    
    	return -1;
    }

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

    struct bus_type usb_bus_type = {
    	.name =		"usb",
    	.match =	usb_device_match,
    	.uevent =	usb_uevent,
    };

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

    static int generic_probe(struct usb_device *udev)
    {
    	int err, c;
    
    	/* Choose and set the configuration.  This registers the interfaces
    	 * with the driver core and lets interface drivers bind to them.
    	 */
    	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 && err != -ENODEV) {
    				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 device state == configured ... usable */
    	usb_notify_add_device(udev);
    
    	return 0;
    }

    int usb_set_configuration(struct usb_device *dev, int configuration)
    {
    	int i, ret;
    	struct usb_host_config *cp = NULL;
    	struct usb_interface **new_interfaces = NULL;
    	struct usb_hcd *hcd = bus_to_hcd(dev->bus);
    	int n, nintf;
    
        //找到对应的config并赋值给cp
    ……
    	if ((!cp && configuration != 0))
    		return -EINVAL;
    
    	/* The USB spec says configuration 0 means unconfigured.
    	 * But if a device includes a configuration numbered 0,
    	 * we will accept it as a correctly configured state.
    	 * Use -1 if you really want to unconfigure the device.
    	 */
    	if (cp && configuration == 0)
    		dev_warn(&dev->dev, "config 0 descriptor??\n");
    
    	/* Allocate memory for new interfaces before doing anything else,
    	 * so that if we run out then nothing will have changed. */
    	n = nintf = 0;
    	if (cp) {
            //接口总数
    		nintf = cp->desc.bNumInterfaces;
            //申请空间
    		new_interfaces = kmalloc(nintf * sizeof(*new_interfaces),
    				GFP_NOIO);
    		……
    
    		for (; n < nintf; ++n) {
    			new_interfaces[n] = kzalloc(
    					sizeof(struct usb_interface),
    					GFP_NOIO);
    			……
    		}
    
    		i = dev->bus_mA - usb_get_max_power(dev, cp);
    		……
    	}
    
    	/* Wake up the device so we can send it the Set-Config request */
    	ret = usb_autoresume_device(dev);
    	if (ret)
    		goto free_interfaces;
    
    	/* if it's already configured, clear out old state first.
    	 * getting rid of old interfaces means unbinding their drivers.
    	 */
    	if (dev->state != USB_STATE_ADDRESS)
    		usb_disable_device(dev, 1);	/* Skip ep0 */
    
    	/* Get rid of pending async Set-Config requests for this device */
    	cancel_async_set_config(dev);
    
    	/* Make sure we have bandwidth (and available HCD resources) for this
    	 * configuration.  Remove endpoints from the schedule if we're dropping
    	 * this configuration to set configuration 0.  After this point, the
    	 * host controller will not allow submissions to dropped endpoints.  If
    	 * this call fails, the device state is unchanged.
    	 */
    	mutex_lock(hcd->bandwidth_mutex);
    	/* Disable LPM, and re-enable it once the new configuration is
    	 * installed, so that the xHCI driver can recalculate the U1/U2
    	 * timeouts.
    	 */
    	if (dev->actconfig && usb_disable_lpm(dev)) {
    		……
    	}
    	//alloc bandwidth用不到
    	……
    
    	/*
    	 * Initialize the new interface structures and the
    	 * hc/hcd/usbcore interface/endpoint state.
    	 */
    	for (i = 0; i < nintf; ++i) {
    		……
           intf->dev.parent = &dev->dev;
    		intf->dev.driver = NULL;
    		intf->dev.bus = &usb_bus_type;
    		intf->dev.type = &usb_if_device_type;
    		intf->dev.groups = usb_interface_groups;
    		intf->dev.dma_mask = dev->dev.dma_mask;
    		INIT_WORK(&intf->reset_ws, __usb_queue_reset_device);
    		intf->minor = -1;
    		device_initialize(&intf->dev);
           ……
    	}
    	kfree(new_interfaces);
        //控制传输，SET_CONFIGURATION
    	ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
    			      USB_REQ_SET_CONFIGURATION, 0, configuration, 0,
    			      NULL, 0, USB_CTRL_SET_TIMEOUT);
    	……
    
    	dev->actconfig = cp;
    	mutex_unlock(hcd->bandwidth_mutex);
    
    	……
        //USB状态设置为CONFIGURED
    	usb_set_device_state(dev, USB_STATE_CONFIGURED);
    
    	if (cp->string == NULL &&
    			!(dev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
    		cp->string = usb_cache_string(dev, cp->desc.iConfiguration);
    
    	/* Now that the interfaces are installed, re-enable LPM. */
    	usb_unlocked_enable_lpm(dev);
    	/* Enable LTM if it was turned off by usb_disable_device. */
    	usb_enable_ltm(dev);
    
    	/* Now that all the interfaces are set up, register them
    	 * to trigger binding of drivers to interfaces.  probe()
    	 * routines may install different altsettings and may
    	 * claim() any interfaces not yet bound.  Many class drivers
    	 * need that: CDC, audio, video, etc.
    	 */
    	for (i = 0; i < nintf; ++i) {
    		struct usb_interface *intf = cp->interface[i];
    
    		dev_dbg(&dev->dev,
    			"adding %s (config #%d, interface %d)\n",
    			dev_name(&intf->dev), configuration,
    			intf->cur_altsetting->desc.bInterfaceNumber);
    		device_enable_async_suspend(&intf->dev);
    		ret = device_add(&intf->dev);
    		if (ret != 0) {
    			dev_err(&dev->dev, "device_add(%s) --> %d\n",
    				dev_name(&intf->dev), ret);
    			continue;
    		}
    		create_intf_ep_devs(intf);
    	}
    
    	usb_autosuspend_device(dev);
    	return 0;
    }
    EXPORT_SYMBOL_GPL(usb_set_configuration);

    static const struct usb_device_id hub_id_table[] = {
        { .match_flags = USB_DEVICE_ID_MATCH_VENDOR
    			| USB_DEVICE_ID_MATCH_INT_CLASS,
          .idVendor = USB_VENDOR_GENESYS_LOGIC,
          .bInterfaceClass = USB_CLASS_HUB,
          .driver_info = HUB_QUIRK_CHECK_PORT_AUTOSUSPEND},
        { .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
          .bDeviceClass = USB_CLASS_HUB},
        { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
          .bInterfaceClass = USB_CLASS_HUB},
        { }						/* Terminating entry */
    };
    
    MODULE_DEVICE_TABLE (usb, hub_id_table);
    
    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,
    };

    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;
    	hdev = interface_to_usbdev(intf);
    	……
    	if (hdev->level == MAX_TOPO_LEVEL) {
    		dev_err(&intf->dev,
    			"Unsupported bus topology: hub nested too deep\n");
    		return -E2BIG;
    	}
    
        ……
    	/* Multiple endpoints? What kind of mutant ninja-hub is this? */
    	if (desc->desc.bNumEndpoints != 1)
    		goto descriptor_error;
    
    	endpoint = &desc->endpoint[0].desc;
    
    	/* If it's not an interrupt in endpoint, we'd better punt! */
    	if (!usb_endpoint_is_int_in(endpoint))
    		goto descriptor_error;
    
    	/* We found a hub */
    	dev_info (&intf->dev, "USB hub found\n");
    
    	hub = kzalloc(sizeof(*hub), GFP_KERNEL);
    	if (!hub) {
    		dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n");
    		return -ENOMEM;
    	}
    
    	kref_init(&hub->kref);
    	hub->intfdev = &intf->dev;
    	hub->hdev = hdev;
    	INIT_DELAYED_WORK(&hub->leds, led_work);
    	INIT_DELAYED_WORK(&hub->init_work, NULL);
    	INIT_WORK(&hub->events, hub_event);
    	usb_get_intf(intf);
    	usb_get_dev(hdev);
    
    	usb_set_intfdata (intf, hub);
    	intf->needs_remote_wakeup = 1;
    	pm_suspend_ignore_children(&intf->dev, true);
    
    	if (hdev->speed == USB_SPEED_HIGH)
    		highspeed_hubs++;
    
    	if (id->driver_info & HUB_QUIRK_CHECK_PORT_AUTOSUSPEND)
    		hub->quirk_check_port_auto_suspend = 1;
    
    	if (hub_configure(hub, endpoint) >= 0)
    		return 0;
    
    	hub_disconnect (intf);
    	return -ENODEV;
    }

    static const struct of_device_id dwc2_of_match_table[] = {
    	{ .compatible = "brcm,bcm2835-usb", .data = &params_bcm2835 },
    	{ .compatible = "rockchip,rk3066-usb", .data = &params_rk3066 },
    	{ .compatible = "snps,dwc2", .data = NULL },
    	{ .compatible = "samsung,s3c6400-hsotg", .data = NULL},
    	{ .compatible = "siflower,sfax8-usb", .data = &params_sfax8 },
    	{},
    };
    MODULE_DEVICE_TABLE(of, dwc2_of_match_table);
    static struct platform_driver dwc2_platform_driver = {
    	.driver = {
    		.name = dwc2_driver_name,
    		.of_match_table = dwc2_of_match_table,
    		.pm = &dwc2_dev_pm_ops,
    	},
    	.probe = dwc2_driver_probe,
    	.remove = dwc2_driver_remove,
    };
    
    module_platform_driver(dwc2_platform_driver);

    /*
     * Initializes the HCD. This function allocates memory for and initializes the
     * static parts of the usb_hcd and dwc2_hsotg structures. It also registers the
     * USB bus with the core and calls the hc_driver->start() function. It returns
     * a negative error on failure.
     */
    int dwc2_hcd_init(struct dwc2_hsotg *hsotg, int irq)
    {
    	struct usb_hcd *hcd;
    	struct dwc2_host_chan *channel;
    	u32 hcfg;
    	int i, num_channels;
    	int retval;
    	……
    	hcd = usb_create_hcd(&dwc2_hc_driver, hsotg->dev, dev_name(hsotg->dev));
    	……
    	/*
    	 * Disable the global interrupt until all the interrupt handlers are
    	 * installed
    	 */
    	dwc2_disable_global_interrupts(hsotg);
    
    	/* Initialize the DWC_otg core, and select the Phy type */
    	retval = dwc2_core_init(hsotg, true, irq);
    	……
    	/* Create new workqueue and init work */
    	retval = -ENOMEM;
    	hsotg->wq_otg = create_singlethread_workqueue("dwc2");
    	if (!hsotg->wq_otg) {
    		dev_err(hsotg->dev, "Failed to create workqueue\n");
    		goto error2;
    	}
    	INIT_WORK(&hsotg->wf_otg, dwc2_conn_id_status_change);
    
    	setup_timer(&hsotg->wkp_timer, dwc2_wakeup_detected,
    		    (unsigned long)hsotg);
    
    	/* Initialize the non-periodic schedule */
    	……
    	/* Initialize the periodic schedule */
    	……
    	/*
    	 * Create a host channel descriptor for each host channel implemented
    	 * in the controller. Initialize the channel descriptor array.
    	 */
    	……
    	/* Initialize hsotg start work */
    	INIT_DELAYED_WORK(&hsotg->start_work, dwc2_hcd_start_func);
    
    	/* Initialize port reset work */
    	INIT_DELAYED_WORK(&hsotg->reset_work, dwc2_hcd_reset_func);
        ……
    	/*
    	 * Finish generic HCD initialization and start the HCD. This function
    	 * allocates the DMA buffer pool, registers the USB bus, requests the
    	 * IRQ line, and calls hcd_start method.
    	 */
    	retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
    	……
    	return 0;
        ……
    }

　　　	init_timer(&hcd->rh_timer);
　　　	hcd->rh_timer.function = rh_timer_func;
　　　	hcd->rh_timer.data = (unsigned long) hcd;

    /**
     * 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.
     */
    int usb_add_hcd(struct usb_hcd *hcd,
    		unsigned int irqnum, unsigned long irqflags)
    {
    	int retval;
    	struct usb_device *rhdev;
    	……
    /* authorized_default定义在drivers/usb/core/hcd.c+367, 是一个static
    * 的全局变量，默认值为-1
    */
    	/* Keep old behaviour if authorized_default is not in [0, 1]. */
    	if (authorized_default < 0 || authorized_default > 1)
    		hcd->authorized_default = hcd->wireless ? 0 : 1;
    	else
    		hcd->authorized_default = authorized_default;
    	set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
    
    	/* HC is in reset state, but accessible.  Now do the one-time init,
    	 * bottom up so that hcds can customize the root hubs before hub_wq
    	 * starts talking to them.  (Note, bus id is assigned early too.)
    	 */
    	if ((retval = hcd_buffer_create(hcd)) != 0) {
    		dev_dbg(hcd->self.controller, "pool alloc failed\n");
    		goto err_create_buf;
    	}
        //分配bus number，并将usb_bus添加到usb_bus_list中
    	if ((retval = usb_register_bus(&hcd->self)) < 0)
    		goto err_register_bus;
    //申请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;
    	}
    	mutex_lock(&usb_port_peer_mutex);
    	hcd->self.root_hub = rhdev;
    	mutex_unlock(&usb_port_peer_mutex);
    	……
    	hcd->rh_pollable = 1;
    
    	/* NOTE: root hub and controller capabilities may not be the same */
    	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");
    
    	/* initialize tasklets */
    	init_giveback_urb_bh(&hcd->high_prio_bh);
    	init_giveback_urb_bh(&hcd->low_prio_bh);
    
    	/* enable irqs just before we start the controller,
    	 * if the BIOS provides legacy PCI irqs.
    	 */
    	if (usb_hcd_is_primary_hcd(hcd) && irqnum) {
    		retval = usb_hcd_request_irqs(hcd, irqnum, irqflags);
    		if (retval)
    			goto err_request_irq;
    	}
    
    	hcd->state = HC_STATE_RUNNING;
    	retval = hcd->driver->start(hcd);
    	if (retval < 0) {
    		dev_err(hcd->self.controller, "startup error %d\n", retval);
    		goto err_hcd_driver_start;
    	}
    
    	/* starting here, usbcore will pay attention to this root hub */
        //注册root hub
    	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(hcd))
    		usb_hcd_poll_rh_status(hcd);
    
    	return retval;
    ……
    }
    EXPORT_SYMBOL_GPL(usb_add_hcd);

    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;
    	const int devnum = 1;
    	int retval;
        //root hub的设备地址始终为1
    	usb_dev->devnum = devnum;
    	usb_dev->bus->devnum_next = devnum + 1;
    	memset (&usb_dev->bus->devmap.devicemap, 0,
    			sizeof usb_dev->bus->devmap.devicemap);
    	set_bit (devnum, usb_dev->bus->devmap.devicemap);
    	usb_set_device_state(usb_dev, USB_STATE_ADDRESS);
    
    	mutex_lock(&usb_bus_list_lock);
        //读设备描述符
    	usb_dev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
    	retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE);
    	if (retval != sizeof usb_dev->descriptor) {
    		mutex_unlock(&usb_bus_list_lock);
    		dev_dbg (parent_dev, "can't read %s device descriptor %d\n",
    				dev_name(&usb_dev->dev), retval);
    		return (retval < 0) ? retval : -EMSGSIZE;
    	}
    	if (usb_dev->speed == USB_SPEED_SUPER) {
    		……
    	}
        //进行设备初始化设置
    	retval = usb_new_device (usb_dev);
    	if (retval) {
    		dev_err (parent_dev, "can't register root hub for %s, %d\n",
    				dev_name(&usb_dev->dev), retval);
    	} else {
    		spin_lock_irq (&hcd_root_hub_lock);
    		hcd->rh_registered = 1;
    		spin_unlock_irq (&hcd_root_hub_lock);
    
    		/* Did the HC die before the root hub was registered? */
    		if (HCD_DEAD(hcd))
    			usb_hc_died (hcd);	/* This time clean up */
    	}
    	mutex_unlock(&usb_bus_list_lock);
    
    	return retval;
    }

    	if (is_root_hub(urb->dev)) {
    		status = rh_urb_enqueue(hcd, urb);
    	} else {
    		status = map_urb_for_dma(hcd, urb, mem_flags);
    		if (likely(status == 0)) {
    			status = hcd->driver->urb_enqueue(hcd, urb, mem_flags);
    			if (unlikely(status))
    				unmap_urb_for_dma(hcd, urb);
    		}
    	}

    /**
     * usb_new_device - perform initial device setup (usbcore-internal)
     * @udev: newly addressed device (in ADDRESS state)
     *
     * This is called with devices which have been detected but not fully
     * enumerated.  The device descriptor is available, but not descriptors
     * for any device configuration.  The caller must have locked either
     * the parent hub (if udev is a normal device) or else the
     * usb_bus_list_lock (if udev is a root hub).  The parent's pointer to
     * udev has already been installed, but udev is not yet visible through
     * sysfs or other filesystem code.
     *
     * This call is synchronous, and may not be used in an interrupt context.
     *
     * Only the hub driver or root-hub registrar should ever call this.
     *
     * Return: Whether the device is configured properly or not. Zero if the
     * interface was registered with the driver core; else a negative errno
     * value.
     *
     */
    int usb_new_device(struct usb_device *udev)
    {
    	int err;
        ……
        //读取所有的描述符
    	err = usb_enumerate_device(udev);	/* Read descriptors */
    	……
    	/* export the usbdev device-node for libusb */
    	udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
    			(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
    
    	/* Tell the world! */
    	announce_device(udev);
    	……
    	/* Register the device.  The device driver is responsible
    	 * for configuring the device and invoking the add-device
    	 * notifier chain (used by usbfs and possibly others).
    	 */
    	err = device_add(&udev->dev);
    	if (err) {
    		dev_err(&udev->dev, "can't device_add, error %d\n", err);
    		goto fail;
    	}
    
    	/* Create link files between child device and usb port device. */
    	……
    	(void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
    	usb_mark_last_busy(udev);
    	pm_runtime_put_sync_autosuspend(&udev->dev);
    	return err;
        ……
    }

    static int hub_configure(struct usb_hub *hub,
    	struct usb_endpoint_descriptor *endpoint)
    {
    	……
    	/* Request the entire hub descriptor.
    	 * hub->descriptor can handle USB_MAXCHILDREN ports,
    	 * but the hub can/will return fewer bytes here.
    	 */
        //这个描述符是在drivers/usb/dwc2/hcd.c里的dwc2_hcd_hub_control
    　　//函数里返回的
    	ret = get_hub_descriptor(hdev, hub->descriptor);
    	……
    	switch (wHubCharacteristics & HUB_CHAR_LPSM) {
    	case HUB_CHAR_COMMON_LPSM:
    		dev_dbg(hub_dev, "ganged power switching\n");
    		break;
    	    ……
    	}
    
    	switch (wHubCharacteristics & HUB_CHAR_OCPM) {
    	……
    	case HUB_CHAR_INDV_PORT_OCPM:
    		dev_dbg(hub_dev, "individual port over-current protection\n");
    		break;
    	……
    	}
    
    	spin_lock_init (&hub->tt.lock);
    	INIT_LIST_HEAD (&hub->tt.clear_list);
    	INIT_WORK(&hub->tt.clear_work, hub_tt_work);
    	switch (hdev->descriptor.bDeviceProtocol) {
    	case USB_HUB_PR_FS:
    		break;
    	……
    	}
    	……
    	/* power budgeting mostly matters with bus-powered hubs,
    	 * and battery-powered root hubs (may provide just 8 mA).
    	 */
    	……
        //hubstatus和hubchange返回值永远是0
    	ret = hub_hub_status(hub, &hubstatus, &hubchange);
    	……
    
    	/* set up the interrupt endpoint
    	 * We use the EP's maxpacket size instead of (PORTS+1+7)/8
    	 * bytes as USB2.0[11.12.3] says because some hubs are known
    	 * to send more data (and thus cause overflow). For root hubs,
    	 * maxpktsize is defined in hcd.c's fake endpoint descriptors
    	 * to be big enough for at least USB_MAXCHILDREN ports. */
    	pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
    	maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
    
    	if (maxp > sizeof(*hub->buffer))
    		maxp = sizeof(*hub->buffer);
    
    	hub->urb = usb_alloc_urb(0, GFP_KERNEL);
    	……
    
    	usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
    		hub, endpoint->bInterval);
    
    	/* maybe cycle the hub leds */
    	if (hub->has_indicators && blinkenlights)
    		hub->indicator[0] = INDICATOR_CYCLE;
        //注册port设备
    	mutex_lock(&usb_port_peer_mutex);
    	for (i = 0; i < maxchild; i++) {
    		ret = usb_hub_create_port_device(hub, i + 1);
    		……
    	}
    	hdev->maxchild = i;
    	……
    
    	mutex_unlock(&usb_port_peer_mutex);
    	if (ret < 0)
    		goto fail;
    
    	/* Update the HCD's internal representation of this hub before hub_wq
    	 * starts getting port status changes for devices under the hub.
    	 */
    	if (hcd->driver->update_hub_device) {
    		……
    	}
    
    	usb_hub_adjust_deviceremovable(hdev, hub->descriptor);
    
    	hub_activate(hub, HUB_INIT);
    	return 0;
    　　……
    }

     init3:
    	hub->quiescing = 0;
    
    	status = usb_submit_urb(hub->urb, GFP_NOIO);
    	if (status < 0)
    		dev_err(hub->intfdev, "activate --> %d\n", status);
    	if (hub->has_indicators && blinkenlights)
    		queue_delayed_work(system_power_efficient_wq,
    				&hub->leds, LED_CYCLE_PERIOD);
    
    	/* Scan all ports that need attention */
    	kick_hub_wq(hub);
    
    	/* Allow autosuspend if it was suppressed */
    	if (type <= HUB_INIT3)
    		usb_autopm_put_interface_async(to_usb_interface(hub->intfdev));

    static int rh_queue_status (struct usb_hcd *hcd, struct urb *urb)
    {
    	……
    	retval = usb_hcd_link_urb_to_ep(hcd, urb);
    	if (retval)
    		goto done;
    
    	hcd->status_urb = urb;
    	urb->hcpriv = hcd;	/* indicate it's queued */
    	if (!hcd->uses_new_polling)
    		mod_timer(&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
    
    	/* If a status change has already occurred, report it ASAP */
    	else if (HCD_POLL_PENDING(hcd))
    		mod_timer(&hcd->rh_timer, jiffies);
    	retval = 0;
     done:
    	spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
    	return retval;
    }

    /*
     * Root Hub interrupt transfers are polled using a timer if the
     * driver requests it; otherwise the driver is responsible for
     * calling usb_hcd_poll_rh_status() when an event occurs.
     *
     * Completions are called in_interrupt(), but they may or may not
     * be in_irq().
     */
    void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
    {
    	struct urb	*urb;
    	int		length;
    	unsigned long	flags;
    	char		buffer[6];	/* Any root hubs with > 31 ports? */
    
    	if (unlikely(!hcd->rh_pollable))
    		return;
    	if (!hcd->uses_new_polling && !hcd->status_urb)
    		return;
    
    	length = hcd->driver->hub_status_data(hcd, buffer);
    	if (length > 0) {
    
    		/* try to complete the status urb */
    		spin_lock_irqsave(&hcd_root_hub_lock, flags);
    		urb = hcd->status_urb;
    		if (urb) {
    			clear_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
    			hcd->status_urb = NULL;
    			urb->actual_length = length;
    			memcpy(urb->transfer_buffer, buffer, length);
    
    			usb_hcd_unlink_urb_from_ep(hcd, urb);
    			usb_hcd_giveback_urb(hcd, urb, 0);
    		} else {
    			length = 0;
    			set_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
    		}
    		spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
    	}
    
    	/* The USB 2.0 spec says 256 ms.  This is close enough and won't
    	 * exceed that limit if HZ is 100. The math is more clunky than
    	 * maybe expected, this is to make sure that all timers for USB devices
    	 * fire at the same time to give the CPU a break in between */
    	if (hcd->uses_new_polling ? HCD_POLL_RH(hcd) :
    			(length == 0 && hcd->status_urb != NULL))
    		mod_timer (&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
    }
    EXPORT_SYMBOL_GPL(usb_hcd_poll_rh_status);

    /*
     * Creates Status Change bitmap for the root hub and root port. The bitmap is
     * returned in buf. Bit 0 is the status change indicator for the root hub. Bit 1
     * is the status change indicator for the single root port. Returns 1 if either
     * change indicator is 1, otherwise returns 0.
     */
    static int _dwc2_hcd_hub_status_data(struct usb_hcd *hcd, char *buf)
    {
    	struct dwc2_hsotg *hsotg = dwc2_hcd_to_hsotg(hcd);
    
    	buf[0] = dwc2_hcd_is_status_changed(hsotg, 1) << 1;
    	return buf[0] != 0;
    }

    static void hub_event(struct work_struct *work)
    {
    	……
    	/* 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 out_hdev_lock;
    
    	/* If the hub has died, clean up after it */
    	……
    	/* Autoresume */
    	……
    	/* If this is an inactive hub, do nothing */
    	……
    	if (hub->error) {
    		……
    	}
    
    	/* deal with port status changes */
    	for (i = 1; i <= hdev->maxchild; i++) {
    		struct usb_port *port_dev = hub->ports[i - 1];
    
    		if (test_bit(i, hub->event_bits)
    				|| test_bit(i, hub->change_bits)
    				|| test_bit(i, hub->wakeup_bits)) {
    			/*
    			 * The get_noresume and barrier ensure that if
    			 * the port was in the process of resuming, we
    			 * flush that work and keep the port active for
    			 * the duration of the port_event().  However,
    			 * if the port is runtime pm suspended
    			 * (powered-off), we leave it in that state, run
    			 * an abbreviated port_event(), and move on.
    			 */
    			pm_runtime_get_noresume(&port_dev->dev);
    			pm_runtime_barrier(&port_dev->dev);
    			usb_lock_port(port_dev);
    			port_event(hub, i);
    			usb_unlock_port(port_dev);
    			pm_runtime_put_sync(&port_dev->dev);
    		}
    	}
    
    	/* deal with hub status changes */
    	……
    
    out_autopm:
    	/* Balance the usb_autopm_get_interface() above */
    	usb_autopm_put_interface_no_suspend(intf);
    out_hdev_lock:
    	usb_unlock_device(hdev);
    
    	/* Balance the stuff in kick_hub_wq() and allow autosuspend */
    	usb_autopm_put_interface(intf);
    	kref_put(&hub->kref, hub_release);
    }

    subsys_initcall(usb_init);  
    module_exit(usb_exit);  

    register_root_hub(hcd);

    struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags)

    static inline void usb_fill_control_urb(struct urb *urb,
    					struct usb_device *dev,
    					unsigned int pipe,
    					unsigned char *setup_packet,
    					void *transfer_buffer,
    					buffer_length,
    					complete_fn,
    					void *context)
    static inline void usb_fill_bulk_urb(struct urb *urb,
    				     struct usb_device *dev,
     				     unsigned int pipe,
     				     void *transfer_buffer,
     				     int buffer_length,
     				     usb_complete_t complete_fn,
     				     void *context)
    static inline void usb_fill_int_urb(struct urb *urb,
     				    struct usb_device *dev,
     				    unsigned int pipe,
     				    void *transfer_buffer,
     				    int buffer_length,
     				    usb_complete_t complete_fn,
    				    void *context,
    				    int interval)

    usb_start_wait_urb -> usb_submit_urb -> usb_hcd_submit_urb

    static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
    {
        if (usb_endpoint_xfer_int(&urb->ep->desc))
    		return rh_queue_status (hcd, urb);
        if (usb_endpoint_xfer_control(&urb->ep->desc))
    		return rh_call_control (hcd, urb);
    	return -EINVAL;
    }

    status = hcd->driver->urb_enqueue(hcd, urb, mem_flags);