if (t < 0)		return t;	/* everything is fail-fast once disconnect	 * processing starts	 */	if (udev->state == USB_STATE_NOTATTACHED) {		usb_unlock_device(hdev);		return -ENODEV;	}	/* when everyone grabs locks top->bottom,	 * non-overlapping work may be concurrent	 */	usb_lock_device(udev);	usb_unlock_device(hdev);	return udev->portnum;}static void recursively_mark_NOTATTACHED(struct usb_device *udev){	int i;	for (i = 0; i < udev->maxchild; ++i) {		if (udev->children[i])			recursively_mark_NOTATTACHED(udev->children[i]);	}	udev->state = USB_STATE_NOTATTACHED;}/** * usb_set_device_state - change a device's current state (usbcore, hcds) * @udev: pointer to device whose state should be changed * @new_state: new state value to be stored * * udev->state is _not_ fully protected by the device lock.  Although * most transitions are made only while holding the lock, the state can * can change to USB_STATE_NOTATTACHED at almost any time.  This * is so that devices can be marked as disconnected as soon as possible, * without having to wait for any semaphores to be released.  As a result, * all changes to any device's state must be protected by the * device_state_lock spinlock. * * Once a device has been added to the device tree, all changes to its state * should be made using this routine.  The state should _not_ be set directly. * * If udev->state is already USB_STATE_NOTATTACHED then no change is made. * Otherwise udev->state is set to new_state, and if new_state is * USB_STATE_NOTATTACHED then all of udev's descendants' states are also set * to USB_STATE_NOTATTACHED. */void usb_set_device_state(struct usb_device *udev,		enum usb_device_state new_state){	unsigned long flags;	spin_lock_irqsave(&device_state_lock, flags);	if (udev->state == USB_STATE_NOTATTACHED)		;	/* do nothing */	else if (new_state != USB_STATE_NOTATTACHED) {		udev->state = new_state;		/* root hub wakeup capabilities are managed out-of-band		 * and may involve silicon errata ... ignore them here.		 */		if (udev->parent) {			if (new_state == USB_STATE_CONFIGURED)				device_init_wakeup(&udev->dev,					(udev->actconfig->desc.bmAttributes					 & USB_CONFIG_ATT_WAKEUP));			else if (new_state != USB_STATE_SUSPENDED)				device_init_wakeup(&udev->dev, 0);		}	} else		recursively_mark_NOTATTACHED(udev);	spin_unlock_irqrestore(&device_state_lock, flags);}#ifdef CONFIG_PM/** * usb_root_hub_lost_power - called by HCD if the root hub lost Vbus power * @rhdev: struct usb_device for the root hub * * The USB host controller driver calls this function when its root hub * is resumed and Vbus power has been interrupted or the controller * has been reset.  The routine marks all the children of the root hub * as NOTATTACHED and marks logical connect-change events on their ports. */void usb_root_hub_lost_power(struct usb_device *rhdev){	struct usb_hub *hub;	int port1;	unsigned long flags;	dev_warn(&rhdev->dev, "root hub lost power or was reset\n");	spin_lock_irqsave(&device_state_lock, flags);	hub = hdev_to_hub(rhdev);	for (port1 = 1; port1 <= rhdev->maxchild; ++port1) {		if (rhdev->children[port1 - 1]) {			recursively_mark_NOTATTACHED(					rhdev->children[port1 - 1]);			set_bit(port1, hub->change_bits);		}	}	spin_unlock_irqrestore(&device_state_lock, flags);}EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);#endifstatic void choose_address(struct usb_device *udev){	int		devnum;	struct usb_bus	*bus = udev->bus;	/* If khubd ever becomes multithreaded, this will need a lock */	/* Try to allocate the next devnum beginning at bus->devnum_next. */	devnum = find_next_zero_bit(bus->devmap.devicemap, 128,			bus->devnum_next);	if (devnum >= 128)		devnum = find_next_zero_bit(bus->devmap.devicemap, 128, 1);	bus->devnum_next = ( devnum >= 127 ? 1 : devnum + 1);	if (devnum < 128) {		set_bit(devnum, bus->devmap.devicemap);		udev->devnum = devnum;	}}static void release_address(struct usb_device *udev){	if (udev->devnum > 0) {		clear_bit(udev->devnum, udev->bus->devmap.devicemap);		udev->devnum = -1;	}}/** * usb_disconnect - disconnect a device (usbcore-internal) * @pdev: pointer to device being disconnected * Context: !in_interrupt () * * Something got disconnected. Get rid of it and all of its children. * * If *pdev is a normal device then the parent hub must already be locked. * If *pdev is a root hub then this routine will acquire the * usb_bus_list_lock on behalf of the caller. * * Only hub drivers (including virtual root hub drivers for host * controllers) should ever call this. * * This call is synchronous, and may not be used in an interrupt context. */void usb_disconnect(struct usb_device **pdev){	struct usb_device	*udev = *pdev;	int			i;	if (!udev) {		pr_debug ("%s nodev\n", __FUNCTION__);		return;	}	/* mark the device as inactive, so any further urb submissions for	 * this device (and any of its children) will fail immediately.	 * this quiesces everyting except pending urbs.	 */	usb_set_device_state(udev, USB_STATE_NOTATTACHED);	dev_info (&udev->dev, "USB disconnect, address %d\n", udev->devnum);	usb_lock_device(udev);	/* Free up all the children before we remove this device */	for (i = 0; i < USB_MAXCHILDREN; i++) {		if (udev->children[i])			usb_disconnect(&udev->children[i]);	}	/* deallocate hcd/hardware state ... nuking all pending urbs and	 * cleaning up all state associated with the current configuration	 * so that the hardware is now fully quiesced.	 */	usb_disable_device(udev, 0);	usb_notify_remove_device(udev);	/* Free the device number, remove the /proc/bus/usb entry and	 * the sysfs attributes, and delete the parent's children[]	 * (or root_hub) pointer.	 */	dev_dbg (&udev->dev, "unregistering device\n");	release_address(udev);	usb_remove_sysfs_dev_files(udev);	/* Avoid races with recursively_mark_NOTATTACHED() */	spin_lock_irq(&device_state_lock);	*pdev = NULL;	spin_unlock_irq(&device_state_lock);	usb_unlock_device(udev);	device_unregister(&udev->dev);}static inline const char *plural(int n){	return (n == 1 ? "" : "s");}static int choose_configuration(struct usb_device *udev){	int i;	int num_configs;	struct usb_host_config *c, *best;	best = NULL;	c = udev->config;	num_configs = udev->descriptor.bNumConfigurations;	for (i = 0; i < num_configs; (i++, c++)) {		struct usb_interface_descriptor	*desc = NULL;		/* It's possible that a config has no interfaces! */		if (c->desc.bNumInterfaces > 0)			desc = &c->intf_cache[0]->altsetting->desc;		/*		 * HP's USB bus-powered keyboard has only one configuration		 * and it claims to be self-powered; other devices may have		 * similar errors in their descriptors.  If the next test		 * were allowed to execute, such configurations would always		 * be rejected and the devices would not work as expected.		 * In the meantime, we run the risk of selecting a config		 * that requires external power at a time when that power		 * isn't available.  It seems to be the lesser of two evils.		 *		 * Bugzilla #6448 reports a device that appears to crash		 * when it receives a GET_DEVICE_STATUS request!  We don't		 * have any other way to tell whether a device is self-powered,		 * but since we don't use that information anywhere but here,		 * the call has been removed.		 *		 * Maybe the GET_DEVICE_STATUS call and the test below can		 * be reinstated when device firmwares become more reliable.		 * Don't hold your breath.		 */#if 0		/* Rule out self-powered configs for a bus-powered device */		if (bus_powered && (c->desc.bmAttributes &					USB_CONFIG_ATT_SELFPOWER))			continue;#endif		/*		 * The next test may not be as effective as it should be.		 * Some hubs have errors in their descriptor, claiming		 * to be self-powered when they are really bus-powered.		 * We will overestimate the amount of current such hubs		 * make available for each port.		 *		 * This is a fairly benign sort of failure.  It won't		 * cause us to reject configurations that we should have		 * accepted.		 */		/* Rule out configs that draw too much bus current */		if (c->desc.bMaxPower * 2 > udev->bus_mA)			continue;		/* If the first config's first interface is COMM/2/0xff		 * (MSFT RNDIS), rule it out unless Linux has host-side		 * RNDIS support. */		if (i == 0 && desc				&& desc->bInterfaceClass == USB_CLASS_COMM				&& desc->bInterfaceSubClass == 2				&& desc->bInterfaceProtocol == 0xff) {#ifndef CONFIG_USB_NET_RNDIS			continue;#else			best = c;#endif		}		/* From the remaining configs, choose the first one whose		 * first interface is for a non-vendor-specific class.		 * Reason: Linux is more likely to have a class driver		 * than a vendor-specific driver. */		else if (udev->descriptor.bDeviceClass !=						USB_CLASS_VENDOR_SPEC &&				(!desc || desc->bInterfaceClass !=						USB_CLASS_VENDOR_SPEC)) {			best = c;			break;		}		/* If all the remaining configs are vendor-specific,		 * choose the first one. */		else if (!best)			best = c;	}	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;}#ifdef DEBUGstatic void show_string(struct usb_device *udev, char *id, char *string){	if (!string)		return;	dev_printk(KERN_INFO, &udev->dev, "%s: %s\n", id, string);}#elsestatic inline void show_string(struct usb_device *udev, char *id, char *string){}#endif#ifdef	CONFIG_USB_OTG#include "otg_whitelist.h"#endif/** * usb_new_device - perform initial device setup (usbcore-internal) * @udev: newly addressed device (in ADDRESS state) * * This is called with devices which have been enumerated, but not yet * configured.  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. * * Returns 0 for success (device is configured and listed, with its * interfaces, in sysfs); else a negative errno value. * * 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. */int usb_new_device(struct usb_device *udev){	int err;	int c;	err = usb_get_configuration(udev);	if (err < 0) {		dev_err(&udev->dev, "can't read configurations, error %d\n",			err);		goto fail;	}	/* read the standard strings and cache them if present */	udev->product = usb_cache_string(udev, udev->descriptor.iProduct);	udev->manufacturer = usb_cache_string(udev,			udev->descriptor.iManufacturer);	udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);	/* Tell the world! */	dev_dbg(&udev->dev, "new device strings: Mfr=%d, Product=%d, "			"SerialNumber=%d\n",			udev->descriptor.iManufacturer,			udev->descriptor.iProduct,			udev->descriptor.iSerialNumber);	show_string(udev, "Product", udev->product);	show_string(udev, "Manufacturer", udev->manufacturer);	show_string(udev, "SerialNumber", udev->serial);#ifdef	CONFIG_USB_OTG	/*	 * OTG-aware devices on OTG-capable root hubs may be able to use SRP,	 * to wake us after we've powered off VBUS; and HNP, switching roles	 * "host" to "peripheral".  The OTG descriptor helps figure this out.	 */	if (!udev->bus->is_b_host			&& udev->config			&& udev->parent == udev->bus->root_hub) {		struct usb_otg_descriptor	*desc = 0;		struct usb_bus			*bus = udev->bus;		/* descriptor may appear anywhere in config */		if (__usb_get_extra_descriptor (udev->rawdescriptors[0],					le16_to_cpu(udev->config[0].desc.wTotalLength),					USB_DT_OTG, (void **) &desc) == 0) {			if (desc->bmAttributes & USB_OTG_HNP) {				unsigned		port1 = udev->portnum;				struct usb_device	*root = udev->parent;								dev_info(&udev->dev,					"Dual-Role OTG device on %sHNP port\n",					(port1 == bus->otg_port)						? "" : "non-");				/* enable HNP before suspend, it's simpler */				if (port1 == bus->otg_port)					bus->b_hnp_enable = 1;				err = usb_control_msg(udev,					usb_sndctrlpipe(udev, 0),					USB_REQ_SET_FEATURE, 0,					bus->b_hnp_enable						? USB_DEVICE_B_HNP_ENABLE						: USB_DEVICE_A_ALT_HNP_SUPPORT,					0, NULL, 0, USB_CTRL_SET_TIMEOUT);				if (err < 0) {					/* OTG MESSAGE: report errors here,					 * customize to match your product.					 */					dev_info(&udev->dev,						"can't set HNP mode; %d\n",						err);					bus->b_hnp_enable = 0;				}			}		}	}	if (!is_targeted(udev)) {		/* Maybe it can talk to us, though we can't talk to it.		 * (Includes HNP test device.)		 */		if (udev->bus->b_hnp_enable || udev->bus->is_b_host) {			static int __usb_suspend_device(struct usb_device *,						int port1);			err = __usb_suspend_device(udev, udev->bus->otg_port);			if (err < 0)				dev_dbg(&udev->dev, "HNP fail, %d\n", err);		}		err = -ENODEV;		goto fail;	}#endif	/* put device-specific files into sysfs */	err = device_add (&udev->dev);	if (err) {		dev_err(&udev->dev, "can't device_add, error %d\n", err);		goto fail;	}	usb_create_sysfs_dev_files (udev);	usb_lock_device(udev);	/* choose and set the configuration. that registers the interfaces	 * with the driver core, and lets usb device drivers bind to them.	 */	c = 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 device state == configured ... usable */	usb_notify_add_device(udev);	usb_unlock_device(udev);