Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 98d9a82e5f753a2483d7b4638802d60e94e5d2e4

Authored by Oliver Neukum 2012-01-11 15:38:35 +0800

Committed by Greg Kroah-Hartman 2012-01-25 06:23:49 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

USB: cleanup the handling of the PM complete call

This eliminates the last instance of a function's behavior
controlled by a parameter as Linus hates such things.

Signed-off-by: Oliver Neukum <oneukum@suse.de>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

Showing 3 changed files with 22 additions and 18 deletions Inline Diff

drivers/usb/core/driver.c
drivers/usb/core/usb.c
drivers/usb/core/usb.h

drivers/usb/core/driver.c

Diff comments View file @ 98d9a82

 /*
  * drivers/usb/driver.c - most of the driver model stuff for usb
  *
  * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de>
  *
  * based on drivers/usb/usb.c which had the following copyrights:
  *	(C) Copyright Linus Torvalds 1999
  *	(C) Copyright Johannes Erdfelt 1999-2001
  *	(C) Copyright Andreas Gal 1999
  *	(C) Copyright Gregory P. Smith 1999
  *	(C) Copyright Deti Fliegl 1999 (new USB architecture)
  *	(C) Copyright Randy Dunlap 2000
  *	(C) Copyright David Brownell 2000-2004
  *	(C) Copyright Yggdrasil Computing, Inc. 2000
  *		(usb_device_id matching changes by Adam J. Richter)
  *	(C) Copyright Greg Kroah-Hartman 2002-2003
  *
  * NOTE! This is not actually a driver at all, rather this is
  * just a collection of helper routines that implement the
  * matching, probing, releasing, suspending and resuming for
  * real drivers.
  *
  */
 #include <linux/device.h>
 #include <linux/slab.h>
 #include <linux/export.h>
 #include <linux/usb.h>
 #include <linux/usb/quirks.h>
 #include <linux/usb/hcd.h>
 #include "usb.h"
 #ifdef CONFIG_HOTPLUG
 /*
  * Adds a new dynamic USBdevice ID to this driver,
  * and cause the driver to probe for all devices again.
  */
 ssize_t usb_store_new_id(struct usb_dynids *dynids,
 			 struct device_driver *driver,
 			 const char *buf, size_t count)
 {
 	struct usb_dynid *dynid;
 	u32 idVendor = 0;
 	u32 idProduct = 0;
 	unsigned int bInterfaceClass = 0;
 	int fields = 0;
 	int retval = 0;
 	fields = sscanf(buf, "%x %x %x", &idVendor, &idProduct,
 					&bInterfaceClass);
 	if (fields < 2)
 		return -EINVAL;
 	dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
 	if (!dynid)
 		return -ENOMEM;
 	INIT_LIST_HEAD(&dynid->node);
 	dynid->id.idVendor = idVendor;
 	dynid->id.idProduct = idProduct;
 	dynid->id.match_flags = USB_DEVICE_ID_MATCH_DEVICE;
 	if (fields == 3) {
 		dynid->id.bInterfaceClass = (u8)bInterfaceClass;
 		dynid->id.match_flags |= USB_DEVICE_ID_MATCH_INT_CLASS;
 	}
 	spin_lock(&dynids->lock);
 	list_add_tail(&dynid->node, &dynids->list);
 	spin_unlock(&dynids->lock);
 	if (get_driver(driver)) {
 		retval = driver_attach(driver);
 		put_driver(driver);
 	}
 	if (retval)
 		return retval;
 	return count;
 }
 EXPORT_SYMBOL_GPL(usb_store_new_id);
 static ssize_t store_new_id(struct device_driver *driver,
 			    const char *buf, size_t count)
 {
 	struct usb_driver *usb_drv = to_usb_driver(driver);
 	return usb_store_new_id(&usb_drv->dynids, driver, buf, count);
 }
 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
 /**
  * store_remove_id - remove a USB device ID from this driver
  * @driver: target device driver
  * @buf: buffer for scanning device ID data
  * @count: input size
  *
  * Removes a dynamic usb device ID from this driver.
  */
 static ssize_t
 store_remove_id(struct device_driver *driver, const char *buf, size_t count)
 {
 	struct usb_dynid *dynid, *n;
 	struct usb_driver *usb_driver = to_usb_driver(driver);
 	u32 idVendor = 0;
 	u32 idProduct = 0;
 	int fields = 0;
 	int retval = 0;
 	fields = sscanf(buf, "%x %x", &idVendor, &idProduct);
 	if (fields < 2)
 		return -EINVAL;
 	spin_lock(&usb_driver->dynids.lock);
 	list_for_each_entry_safe(dynid, n, &usb_driver->dynids.list, node) {
 		struct usb_device_id *id = &dynid->id;
 		if ((id->idVendor == idVendor) &&
 		    (id->idProduct == idProduct)) {
 			list_del(&dynid->node);
 			kfree(dynid);
 			retval = 0;
 			break;
 		}
 	}
 	spin_unlock(&usb_driver->dynids.lock);
 	if (retval)
 		return retval;
 	return count;
 }
 static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
 static int usb_create_newid_file(struct usb_driver *usb_drv)
 {
 	int error = 0;
 	if (usb_drv->no_dynamic_id)
 		goto exit;
 	if (usb_drv->probe != NULL)
 		error = driver_create_file(&usb_drv->drvwrap.driver,
 					   &driver_attr_new_id);
 exit:
 	return error;
 }
 static void usb_remove_newid_file(struct usb_driver *usb_drv)
 {
 	if (usb_drv->no_dynamic_id)
 		return;
 	if (usb_drv->probe != NULL)
 		driver_remove_file(&usb_drv->drvwrap.driver,
 				   &driver_attr_new_id);
 }
 static int
 usb_create_removeid_file(struct usb_driver *drv)
 {
 	int error = 0;
 	if (drv->probe != NULL)
 		error = driver_create_file(&drv->drvwrap.driver,
 				&driver_attr_remove_id);
 	return error;
 }
 static void usb_remove_removeid_file(struct usb_driver *drv)
 {
 	driver_remove_file(&drv->drvwrap.driver, &driver_attr_remove_id);
 }
 static void usb_free_dynids(struct usb_driver *usb_drv)
 {
 	struct usb_dynid *dynid, *n;
 	spin_lock(&usb_drv->dynids.lock);
 	list_for_each_entry_safe(dynid, n, &usb_drv->dynids.list, node) {
 		list_del(&dynid->node);
 		kfree(dynid);
 	}
 	spin_unlock(&usb_drv->dynids.lock);
 }
 #else
 static inline int usb_create_newid_file(struct usb_driver *usb_drv)
 {
 	return 0;
 }
 static void usb_remove_newid_file(struct usb_driver *usb_drv)
 {
 }
 static int
 usb_create_removeid_file(struct usb_driver *drv)
 {
 	return 0;
 }
 static void usb_remove_removeid_file(struct usb_driver *drv)
 {
 }
 static inline void usb_free_dynids(struct usb_driver *usb_drv)
 {
 }
 #endif
 static const struct usb_device_id *usb_match_dynamic_id(struct usb_interface *intf,
 							struct usb_driver *drv)
 {
 	struct usb_dynid *dynid;
 	spin_lock(&drv->dynids.lock);
 	list_for_each_entry(dynid, &drv->dynids.list, node) {
 		if (usb_match_one_id(intf, &dynid->id)) {
 			spin_unlock(&drv->dynids.lock);
 			return &dynid->id;
 		}
 	}
 	spin_unlock(&drv->dynids.lock);
 	return NULL;
 }
 /* called from driver core with dev locked */
 static int usb_probe_device(struct device *dev)
 {
 	struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
 	struct usb_device *udev = to_usb_device(dev);
 	int error = 0;
 	dev_dbg(dev, "%s\n", __func__);
 	/* TODO: Add real matching code */
 	/* The device should always appear to be in use
 	 * unless the driver suports autosuspend.
 	 */
 	if (!udriver->supports_autosuspend)
 		error = usb_autoresume_device(udev);
 	if (!error)
 		error = udriver->probe(udev);
 	return error;
 }
 /* called from driver core with dev locked */
 static int usb_unbind_device(struct device *dev)
 {
 	struct usb_device *udev = to_usb_device(dev);
 	struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
 	udriver->disconnect(udev);
 	if (!udriver->supports_autosuspend)
 		usb_autosuspend_device(udev);
 	return 0;
 }
 /*
  * Cancel any pending scheduled resets
  *
  * [see usb_queue_reset_device()]
  *
  * Called after unconfiguring / when releasing interfaces. See
  * comments in __usb_queue_reset_device() regarding
  * udev->reset_running.
  */
 static void usb_cancel_queued_reset(struct usb_interface *iface)
 {
 	if (iface->reset_running == 0)
 		cancel_work_sync(&iface->reset_ws);
 }
 /* called from driver core with dev locked */
 static int usb_probe_interface(struct device *dev)
 {
 	struct usb_driver *driver = to_usb_driver(dev->driver);
 	struct usb_interface *intf = to_usb_interface(dev);
 	struct usb_device *udev = interface_to_usbdev(intf);
 	const struct usb_device_id *id;
 	int error = -ENODEV;
 	dev_dbg(dev, "%s\n", __func__);
 	intf->needs_binding = 0;
 	if (usb_device_is_owned(udev))
 		return error;
 	if (udev->authorized == 0) {
 		dev_err(&intf->dev, "Device is not authorized for usage\n");
 		return error;
 	}
 	id = usb_match_id(intf, driver->id_table);
 	if (!id)
 		id = usb_match_dynamic_id(intf, driver);
 	if (!id)
 		return error;
 	dev_dbg(dev, "%s - got id\n", __func__);
 	error = usb_autoresume_device(udev);
 	if (error)
 		return error;
 	intf->condition = USB_INTERFACE_BINDING;
 	/* Probed interfaces are initially active.  They are
 	 * runtime-PM-enabled only if the driver has autosuspend support.
 	 * They are sensitive to their children's power states.
 	 */
 	pm_runtime_set_active(dev);
 	pm_suspend_ignore_children(dev, false);
 	if (driver->supports_autosuspend)
 		pm_runtime_enable(dev);
 	/* Carry out a deferred switch to altsetting 0 */
 	if (intf->needs_altsetting0) {
 		error = usb_set_interface(udev, intf->altsetting[0].
 				desc.bInterfaceNumber, 0);
 		if (error < 0)
 			goto err;
 		intf->needs_altsetting0 = 0;
 	}
 	error = driver->probe(intf, id);
 	if (error)
 		goto err;
 	intf->condition = USB_INTERFACE_BOUND;
 	usb_autosuspend_device(udev);
 	return error;
  err:
 	intf->needs_remote_wakeup = 0;
 	intf->condition = USB_INTERFACE_UNBOUND;
 	usb_cancel_queued_reset(intf);
 	/* Unbound interfaces are always runtime-PM-disabled and -suspended */
 	if (driver->supports_autosuspend)
 		pm_runtime_disable(dev);
 	pm_runtime_set_suspended(dev);
 	usb_autosuspend_device(udev);
 	return error;
 }
 /* called from driver core with dev locked */
 static int usb_unbind_interface(struct device *dev)
 {
 	struct usb_driver *driver = to_usb_driver(dev->driver);
 	struct usb_interface *intf = to_usb_interface(dev);
 	struct usb_device *udev;
 	int error, r;
 	intf->condition = USB_INTERFACE_UNBINDING;
 	/* Autoresume for set_interface call below */
 	udev = interface_to_usbdev(intf);
 	error = usb_autoresume_device(udev);
 	/* Terminate all URBs for this interface unless the driver
 	 * supports "soft" unbinding.
 	 */
 	if (!driver->soft_unbind)
 		usb_disable_interface(udev, intf, false);
 	driver->disconnect(intf);
 	usb_cancel_queued_reset(intf);
 	/* Reset other interface state.
 	 * We cannot do a Set-Interface if the device is suspended or
 	 * if it is prepared for a system sleep (since installing a new
 	 * altsetting means creating new endpoint device entries).
 	 * When either of these happens, defer the Set-Interface.
 	 */
 	if (intf->cur_altsetting->desc.bAlternateSetting == 0) {
 		/* Already in altsetting 0 so skip Set-Interface.
 		 * Just re-enable it without affecting the endpoint toggles.
 		 */
 		usb_enable_interface(udev, intf, false);
 	} else if (!error && !intf->dev.power.is_prepared) {
 		r = usb_set_interface(udev, intf->altsetting[0].
 				desc.bInterfaceNumber, 0);
 		if (r < 0)
 			intf->needs_altsetting0 = 1;
 	} else {
 		intf->needs_altsetting0 = 1;
 	}
 	usb_set_intfdata(intf, NULL);
 	intf->condition = USB_INTERFACE_UNBOUND;
 	intf->needs_remote_wakeup = 0;
 	/* Unbound interfaces are always runtime-PM-disabled and -suspended */
 	if (driver->supports_autosuspend)
 		pm_runtime_disable(dev);
 	pm_runtime_set_suspended(dev);
 	/* Undo any residual pm_autopm_get_interface_* calls */
 	for (r = atomic_read(&intf->pm_usage_cnt); r > 0; --r)
 		usb_autopm_put_interface_no_suspend(intf);
 	atomic_set(&intf->pm_usage_cnt, 0);
 	if (!error)
 		usb_autosuspend_device(udev);
 	return 0;
 }
 /**
  * usb_driver_claim_interface - bind a driver to an interface
  * @driver: the driver to be bound
  * @iface: the interface to which it will be bound; must be in the
  *	usb device's active configuration
  * @priv: driver data associated with that interface
  *
  * This is used by usb device drivers that need to claim more than one
  * interface on a device when probing (audio and acm are current examples).
  * No device driver should directly modify internal usb_interface or
  * usb_device structure members.
  *
  * Few drivers should need to use this routine, since the most natural
  * way to bind to an interface is to return the private data from
  * the driver's probe() method.
  *
  * Callers must own the device lock, so driver probe() entries don't need
  * extra locking, but other call contexts may need to explicitly claim that
  * lock.
  */
 int usb_driver_claim_interface(struct usb_driver *driver,
 				struct usb_interface *iface, void *priv)
 {
 	struct device *dev = &iface->dev;
 	int retval = 0;
 	if (dev->driver)
 		return -EBUSY;
 	dev->driver = &driver->drvwrap.driver;
 	usb_set_intfdata(iface, priv);
 	iface->needs_binding = 0;
 	iface->condition = USB_INTERFACE_BOUND;
 	/* Claimed interfaces are initially inactive (suspended) and
 	 * runtime-PM-enabled, but only if the driver has autosuspend
 	 * support.  Otherwise they are marked active, to prevent the
 	 * device from being autosuspended, but left disabled.  In either
 	 * case they are sensitive to their children's power states.
 	 */
 	pm_suspend_ignore_children(dev, false);
 	if (driver->supports_autosuspend)
 		pm_runtime_enable(dev);
 	else
 		pm_runtime_set_active(dev);
 	/* if interface was already added, bind now; else let
 	 * the future device_add() bind it, bypassing probe()
 	 */
 	if (device_is_registered(dev))
 		retval = device_bind_driver(dev);
 	return retval;
 }
 EXPORT_SYMBOL_GPL(usb_driver_claim_interface);
 /**
  * usb_driver_release_interface - unbind a driver from an interface
  * @driver: the driver to be unbound
  * @iface: the interface from which it will be unbound
  *
  * This can be used by drivers to release an interface without waiting
  * for their disconnect() methods to be called.  In typical cases this
  * also causes the driver disconnect() method to be called.
  *
  * This call is synchronous, and may not be used in an interrupt context.
  * Callers must own the device lock, so driver disconnect() entries don't
  * need extra locking, but other call contexts may need to explicitly claim
  * that lock.
  */
 void usb_driver_release_interface(struct usb_driver *driver,
 					struct usb_interface *iface)
 {
 	struct device *dev = &iface->dev;
 	/* this should never happen, don't release something that's not ours */
 	if (!dev->driver || dev->driver != &driver->drvwrap.driver)
 		return;
 	/* don't release from within disconnect() */
 	if (iface->condition != USB_INTERFACE_BOUND)
 		return;
 	iface->condition = USB_INTERFACE_UNBINDING;
 	/* Release via the driver core only if the interface
 	 * has already been registered
 	 */
 	if (device_is_registered(dev)) {
 		device_release_driver(dev);
 	} else {
 		device_lock(dev);
 		usb_unbind_interface(dev);
 		dev->driver = NULL;
 		device_unlock(dev);
 	}
 }
 EXPORT_SYMBOL_GPL(usb_driver_release_interface);
 /* returns 0 if no match, 1 if match */
 int usb_match_device(struct usb_device *dev, const struct usb_device_id *id)
 {
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
 	    id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
 	    id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
 		return 0;
 	/* No need to test id->bcdDevice_lo != 0, since 0 is never
 	   greater than any unsigned number. */
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
 	    (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
 	    (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
 	    (id->bDeviceClass != dev->descriptor.bDeviceClass))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
 	    (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
 	    (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
 		return 0;
 	return 1;
 }
 /* returns 0 if no match, 1 if match */
 int usb_match_one_id(struct usb_interface *interface,
 		     const struct usb_device_id *id)
 {
 	struct usb_host_interface *intf;
 	struct usb_device *dev;
 	/* proc_connectinfo in devio.c may call us with id == NULL. */
 	if (id == NULL)
 		return 0;
 	intf = interface->cur_altsetting;
 	dev = interface_to_usbdev(interface);
 	if (!usb_match_device(dev, id))
 		return 0;
 	/* The interface class, subclass, and protocol should never be
 	 * checked for a match if the device class is Vendor Specific,
 	 * unless the match record specifies the Vendor ID. */
 	if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
 			!(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
 			(id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
 				USB_DEVICE_ID_MATCH_INT_SUBCLASS |
 				USB_DEVICE_ID_MATCH_INT_PROTOCOL)))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
 	    (id->bInterfaceClass != intf->desc.bInterfaceClass))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
 	    (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
 		return 0;
 	if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
 	    (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
 		return 0;
 	return 1;
 }
 EXPORT_SYMBOL_GPL(usb_match_one_id);
 /**
  * usb_match_id - find first usb_device_id matching device or interface
  * @interface: the interface of interest
  * @id: array of usb_device_id structures, terminated by zero entry
  *
  * usb_match_id searches an array of usb_device_id's and returns
  * the first one matching the device or interface, or null.
  * This is used when binding (or rebinding) a driver to an interface.
  * Most USB device drivers will use this indirectly, through the usb core,
  * but some layered driver frameworks use it directly.
  * These device tables are exported with MODULE_DEVICE_TABLE, through
  * modutils, to support the driver loading functionality of USB hotplugging.
  *
  * What Matches:
  *
  * The "match_flags" element in a usb_device_id controls which
  * members are used.  If the corresponding bit is set, the
  * value in the device_id must match its corresponding member
  * in the device or interface descriptor, or else the device_id
  * does not match.
  *
  * "driver_info" is normally used only by device drivers,
  * but you can create a wildcard "matches anything" usb_device_id
  * as a driver's "modules.usbmap" entry if you provide an id with
  * only a nonzero "driver_info" field.  If you do this, the USB device
  * driver's probe() routine should use additional intelligence to
  * decide whether to bind to the specified interface.
  *
  * What Makes Good usb_device_id Tables:
  *
  * The match algorithm is very simple, so that intelligence in
  * driver selection must come from smart driver id records.
  * Unless you have good reasons to use another selection policy,
  * provide match elements only in related groups, and order match
  * specifiers from specific to general.  Use the macros provided
  * for that purpose if you can.
  *
  * The most specific match specifiers use device descriptor
  * data.  These are commonly used with product-specific matches;
  * the USB_DEVICE macro lets you provide vendor and product IDs,
  * and you can also match against ranges of product revisions.
  * These are widely used for devices with application or vendor
  * specific bDeviceClass values.
  *
  * Matches based on device class/subclass/protocol specifications
  * are slightly more general; use the USB_DEVICE_INFO macro, or
  * its siblings.  These are used with single-function devices
  * where bDeviceClass doesn't specify that each interface has
  * its own class.
  *
  * Matches based on interface class/subclass/protocol are the
  * most general; they let drivers bind to any interface on a
  * multiple-function device.  Use the USB_INTERFACE_INFO
  * macro, or its siblings, to match class-per-interface style
  * devices (as recorded in bInterfaceClass).
  *
  * Note that an entry created by USB_INTERFACE_INFO won't match
  * any interface if the device class is set to Vendor-Specific.
  * This is deliberate; according to the USB spec the meanings of
  * the interface class/subclass/protocol for these devices are also
  * vendor-specific, and hence matching against a standard product
  * class wouldn't work anyway.  If you really want to use an
  * interface-based match for such a device, create a match record
  * that also specifies the vendor ID.  (Unforunately there isn't a
  * standard macro for creating records like this.)
  *
  * Within those groups, remember that not all combinations are
  * meaningful.  For example, don't give a product version range
  * without vendor and product IDs; or specify a protocol without
  * its associated class and subclass.
  */
 const struct usb_device_id *usb_match_id(struct usb_interface *interface,
 					 const struct usb_device_id *id)
 {
 	/* proc_connectinfo in devio.c may call us with id == NULL. */
 	if (id == NULL)
 		return NULL;
 	/* It is important to check that id->driver_info is nonzero,
 	   since an entry that is all zeroes except for a nonzero
 	   id->driver_info is the way to create an entry that
 	   indicates that the driver want to examine every
 	   device and interface. */
 	for (; id->idVendor || id->idProduct || id->bDeviceClass ||
 	       id->bInterfaceClass || id->driver_info; id++) {
 		if (usb_match_one_id(interface, id))
 			return id;
 	}
 	return NULL;
 }
 EXPORT_SYMBOL_GPL(usb_match_id);
 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;
 }
 #ifdef	CONFIG_HOTPLUG
 static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
 	struct usb_device *usb_dev;
 	if (is_usb_device(dev)) {
 		usb_dev = to_usb_device(dev);
 	} else if (is_usb_interface(dev)) {
 		struct usb_interface *intf = to_usb_interface(dev);
 		usb_dev = interface_to_usbdev(intf);
 	} else {
 		return 0;
 	}
 	if (usb_dev->devnum < 0) {
 		/* driver is often null here; dev_dbg() would oops */
 		pr_debug("usb %s: already deleted?\n", dev_name(dev));
 		return -ENODEV;
 	}
 	if (!usb_dev->bus) {
 		pr_debug("usb %s: bus removed?\n", dev_name(dev));
 		return -ENODEV;
 	}
 #ifdef	CONFIG_USB_DEVICEFS
 	/* If this is available, userspace programs can directly read
 	 * all the device descriptors we don't tell them about.  Or
 	 * act as usermode drivers.
 	 */
 	if (add_uevent_var(env, "DEVICE=/proc/bus/usb/%03d/%03d",
 			   usb_dev->bus->busnum, usb_dev->devnum))
 		return -ENOMEM;
 #endif
 	/* per-device configurations are common */
 	if (add_uevent_var(env, "PRODUCT=%x/%x/%x",
 			   le16_to_cpu(usb_dev->descriptor.idVendor),
 			   le16_to_cpu(usb_dev->descriptor.idProduct),
 			   le16_to_cpu(usb_dev->descriptor.bcdDevice)))
 		return -ENOMEM;
 	/* class-based driver binding models */
 	if (add_uevent_var(env, "TYPE=%d/%d/%d",
 			   usb_dev->descriptor.bDeviceClass,
 			   usb_dev->descriptor.bDeviceSubClass,
 			   usb_dev->descriptor.bDeviceProtocol))
 		return -ENOMEM;
 	return 0;
 }
 #else
 static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
 	return -ENODEV;
 }
 #endif	/* CONFIG_HOTPLUG */
 /**
  * usb_register_device_driver - register a USB device (not interface) driver
  * @new_udriver: USB operations for the device driver
  * @owner: module owner of this driver.
  *
  * Registers a USB device driver with the USB core.  The list of
  * unattached devices will be rescanned whenever a new driver is
  * added, allowing the new driver to attach to any recognized devices.
  * Returns a negative error code on failure and 0 on success.
  */
 int usb_register_device_driver(struct usb_device_driver *new_udriver,
 		struct module *owner)
 {
 	int retval = 0;
 	if (usb_disabled())
 		return -ENODEV;
 	new_udriver->drvwrap.for_devices = 1;
 	new_udriver->drvwrap.driver.name = (char *) new_udriver->name;
 	new_udriver->drvwrap.driver.bus = &usb_bus_type;
 	new_udriver->drvwrap.driver.probe = usb_probe_device;
 	new_udriver->drvwrap.driver.remove = usb_unbind_device;
 	new_udriver->drvwrap.driver.owner = owner;
 	retval = driver_register(&new_udriver->drvwrap.driver);
 	if (!retval) {
 		pr_info("%s: registered new device driver %s\n",
 			usbcore_name, new_udriver->name);
 		usbfs_update_special();
 	} else {
 		printk(KERN_ERR "%s: error %d registering device "
 			"	driver %s\n",
 			usbcore_name, retval, new_udriver->name);
 	}
 	return retval;
 }
 EXPORT_SYMBOL_GPL(usb_register_device_driver);
 /**
  * usb_deregister_device_driver - unregister a USB device (not interface) driver
  * @udriver: USB operations of the device driver to unregister
  * Context: must be able to sleep
  *
  * Unlinks the specified driver from the internal USB driver list.
  */
 void usb_deregister_device_driver(struct usb_device_driver *udriver)
 {
 	pr_info("%s: deregistering device driver %s\n",
 			usbcore_name, udriver->name);
 	driver_unregister(&udriver->drvwrap.driver);
 	usbfs_update_special();
 }
 EXPORT_SYMBOL_GPL(usb_deregister_device_driver);
 /**
  * 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);
 /**
  * usb_deregister - unregister a USB interface driver
  * @driver: USB operations of the interface driver to unregister
  * Context: must be able to sleep
  *
  * Unlinks the specified driver from the internal USB driver list.
  *
  * NOTE: If you called usb_register_dev(), you still need to call
  * usb_deregister_dev() to clean up your driver's allocated minor numbers,
  * this * call will no longer do it for you.
  */
 void usb_deregister(struct usb_driver *driver)
 {
 	pr_info("%s: deregistering interface driver %s\n",
 			usbcore_name, driver->name);
 	usb_remove_removeid_file(driver);
 	usb_remove_newid_file(driver);
 	usb_free_dynids(driver);
 	driver_unregister(&driver->drvwrap.driver);
 	usbfs_update_special();
 }
 EXPORT_SYMBOL_GPL(usb_deregister);
 /* Forced unbinding of a USB interface driver, either because
  * it doesn't support pre_reset/post_reset/reset_resume or
  * because it doesn't support suspend/resume.
  *
  * The caller must hold @intf's device's lock, but not its pm_mutex
  * and not @intf->dev.sem.
  */
 void usb_forced_unbind_intf(struct usb_interface *intf)
 {
 	struct usb_driver *driver = to_usb_driver(intf->dev.driver);
 	dev_dbg(&intf->dev, "forced unbind\n");
 	usb_driver_release_interface(driver, intf);
 	/* Mark the interface for later rebinding */
 	intf->needs_binding = 1;
 }
 /* Delayed forced unbinding of a USB interface driver and scan
  * for rebinding.
  *
  * The caller must hold @intf's device's lock, but not its pm_mutex
  * and not @intf->dev.sem.
  *
  * Note: Rebinds will be skipped if a system sleep transition is in
  * progress and the PM "complete" callback hasn't occurred yet.
  */
 void usb_rebind_intf(struct usb_interface *intf)
 {
 	int rc;
 	/* Delayed unbind of an existing driver */
 	if (intf->dev.driver)
 		usb_forced_unbind_intf(intf);
 	/* Try to rebind the interface */
 	if (!intf->dev.power.is_prepared) {
 		intf->needs_binding = 0;
 		rc = device_attach(&intf->dev);
 		if (rc < 0)
 			dev_warn(&intf->dev, "rebind failed: %d\n", rc);
 	}
 }
 #ifdef CONFIG_PM
 /* Unbind drivers for @udev's interfaces that don't support suspend/resume
  * There is no check for reset_resume here because it can be determined
  * only during resume whether reset_resume is needed.
  *
  * The caller must hold @udev's device lock.
  */
 static void unbind_no_pm_drivers_interfaces(struct usb_device *udev)
 {
 	struct usb_host_config	*config;
 	int			i;
 	struct usb_interface	*intf;
 	struct usb_driver	*drv;
 	config = udev->actconfig;
 	if (config) {
 		for (i = 0; i < config->desc.bNumInterfaces; ++i) {
 			intf = config->interface[i];
 			if (intf->dev.driver) {
 				drv = to_usb_driver(intf->dev.driver);
 				if (!drv->suspend || !drv->resume)
 					usb_forced_unbind_intf(intf);
 			}
 		}
 	}
 }
 /* Unbind drivers for @udev's interfaces that failed to support reset-resume.
  * These interfaces have the needs_binding flag set by usb_resume_interface().
  *
  * The caller must hold @udev's device lock.
  */
 static void unbind_no_reset_resume_drivers_interfaces(struct usb_device *udev)
 {
 	struct usb_host_config	*config;
 	int			i;
 	struct usb_interface	*intf;
 	config = udev->actconfig;
 	if (config) {
 		for (i = 0; i < config->desc.bNumInterfaces; ++i) {
 			intf = config->interface[i];
 			if (intf->dev.driver && intf->needs_binding)
 				usb_forced_unbind_intf(intf);
 		}
 	}
 }
 static void do_rebind_interfaces(struct usb_device *udev)
 {
 	struct usb_host_config	*config;
 	int			i;
 	struct usb_interface	*intf;
 	config = udev->actconfig;
 	if (config) {
 		for (i = 0; i < config->desc.bNumInterfaces; ++i) {
 			intf = config->interface[i];
 			if (intf->needs_binding)
 				usb_rebind_intf(intf);
 		}
 	}
 }
 static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
 {
 	struct usb_device_driver	*udriver;
 	int				status = 0;
 	if (udev->state == USB_STATE_NOTATTACHED ||
 			udev->state == USB_STATE_SUSPENDED)
 		goto done;
 	/* For devices that don't have a driver, we do a generic suspend. */
 	if (udev->dev.driver)
 		udriver = to_usb_device_driver(udev->dev.driver);
 	else {
 		udev->do_remote_wakeup = 0;
 		udriver = &usb_generic_driver;
 	}
 	status = udriver->suspend(udev, msg);
  done:
 	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
 	return status;
 }
 static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
 {
 	struct usb_device_driver	*udriver;
 	int				status = 0;
 	if (udev->state == USB_STATE_NOTATTACHED)
 		goto done;
 	/* Can't resume it if it doesn't have a driver. */
 	if (udev->dev.driver == NULL) {
 		status = -ENOTCONN;
 		goto done;
 	}
 	/* Non-root devices on a full/low-speed bus must wait for their
 	 * companion high-speed root hub, in case a handoff is needed.
 	 */
 	if (!PMSG_IS_AUTO(msg) && udev->parent && udev->bus->hs_companion)
 		device_pm_wait_for_dev(&udev->dev,
 				&udev->bus->hs_companion->root_hub->dev);
 	if (udev->quirks & USB_QUIRK_RESET_RESUME)
 		udev->reset_resume = 1;
 	udriver = to_usb_device_driver(udev->dev.driver);
 	status = udriver->resume(udev, msg);
  done:
 	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
 	return status;
 }
 static int usb_suspend_interface(struct usb_device *udev,
 		struct usb_interface *intf, pm_message_t msg)
 {
 	struct usb_driver	*driver;
 	int			status = 0;
 	if (udev->state == USB_STATE_NOTATTACHED ||
 			intf->condition == USB_INTERFACE_UNBOUND)
 		goto done;
 	driver = to_usb_driver(intf->dev.driver);
 	/* at this time we know the driver supports suspend */
 	status = driver->suspend(intf, msg);
 	if (status && !PMSG_IS_AUTO(msg))
 		dev_err(&intf->dev, "suspend error %d\n", status);
  done:
 	dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
 	return status;
 }
 static int usb_resume_interface(struct usb_device *udev,
 		struct usb_interface *intf, pm_message_t msg, int reset_resume)
 {
 	struct usb_driver	*driver;
 	int			status = 0;
 	if (udev->state == USB_STATE_NOTATTACHED)
 		goto done;
 	/* Don't let autoresume interfere with unbinding */
 	if (intf->condition == USB_INTERFACE_UNBINDING)
 		goto done;
 	/* Can't resume it if it doesn't have a driver. */
 	if (intf->condition == USB_INTERFACE_UNBOUND) {
 		/* Carry out a deferred switch to altsetting 0 */
 		if (intf->needs_altsetting0 && !intf->dev.power.is_prepared) {
 			usb_set_interface(udev, intf->altsetting[0].
 					desc.bInterfaceNumber, 0);
 			intf->needs_altsetting0 = 0;
 		}
 		goto done;
 	}
 	/* Don't resume if the interface is marked for rebinding */
 	if (intf->needs_binding)
 		goto done;
 	driver = to_usb_driver(intf->dev.driver);
 	if (reset_resume) {
 		if (driver->reset_resume) {
 			status = driver->reset_resume(intf);
 			if (status)
 				dev_err(&intf->dev, "%s error %d\n",
 						"reset_resume", status);
 		} else {
 			intf->needs_binding = 1;
 			dev_warn(&intf->dev, "no %s for driver %s?\n",
 					"reset_resume", driver->name);
 		}
 	} else {
 		status = driver->resume(intf);
 		if (status)
 			dev_err(&intf->dev, "resume error %d\n", status);
 	}
 done:
 	dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
 	/* Later we will unbind the driver and/or reprobe, if necessary */
 	return status;
 }
 /**
  * usb_suspend_both - suspend a USB device and its interfaces
  * @udev: the usb_device to suspend
  * @msg: Power Management message describing this state transition
  *
  * This is the central routine for suspending USB devices.  It calls the
  * suspend methods for all the interface drivers in @udev and then calls
  * the suspend method for @udev itself.  If an error occurs at any stage,
  * all the interfaces which were suspended are resumed so that they remain
  * in the same state as the device.
  *
  * Autosuspend requests originating from a child device or an interface
  * driver may be made without the protection of @udev's device lock, but
  * all other suspend calls will hold the lock.  Usbcore will insure that
  * method calls do not arrive during bind, unbind, or reset operations.
  * However drivers must be prepared to handle suspend calls arriving at
  * unpredictable times.
  *
  * This routine can run only in process context.
  */
 static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
 {
 	int			status = 0;
 	int			i = 0, n = 0;
 	struct usb_interface	*intf;
 	if (udev->state == USB_STATE_NOTATTACHED ||
 			udev->state == USB_STATE_SUSPENDED)
 		goto done;
 	/* Suspend all the interfaces and then udev itself */
 	if (udev->actconfig) {
 		n = udev->actconfig->desc.bNumInterfaces;
 		for (i = n - 1; i >= 0; --i) {
 			intf = udev->actconfig->interface[i];
 			status = usb_suspend_interface(udev, intf, msg);
 			/* Ignore errors during system sleep transitions */
 			if (!PMSG_IS_AUTO(msg))
 				status = 0;
 			if (status != 0)
 				break;
 		}
 	}
 	if (status == 0) {
 		status = usb_suspend_device(udev, msg);
 		/* Again, ignore errors during system sleep transitions */
 		if (!PMSG_IS_AUTO(msg))
 			status = 0;
 	}
 	/* If the suspend failed, resume interfaces that did get suspended */
 	if (status != 0) {
 		msg.event ^= (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
 		while (++i < n) {
 			intf = udev->actconfig->interface[i];
 			usb_resume_interface(udev, intf, msg, 0);
 		}
 	/* If the suspend succeeded then prevent any more URB submissions
 	 * and flush any outstanding URBs.
 	 */
 	} else {
 		udev->can_submit = 0;
 		for (i = 0; i < 16; ++i) {
 			usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
 			usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
 		}
 	}
  done:
 	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
 	return status;
 }
 /**
  * usb_resume_both - resume a USB device and its interfaces
  * @udev: the usb_device to resume
  * @msg: Power Management message describing this state transition
  *
  * This is the central routine for resuming USB devices.  It calls the
  * the resume method for @udev and then calls the resume methods for all
  * the interface drivers in @udev.
  *
  * Autoresume requests originating from a child device or an interface
  * driver may be made without the protection of @udev's device lock, but
  * all other resume calls will hold the lock.  Usbcore will insure that
  * method calls do not arrive during bind, unbind, or reset operations.
  * However drivers must be prepared to handle resume calls arriving at
  * unpredictable times.
  *
  * This routine can run only in process context.
  */
 static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
 {
 	int			status = 0;
 	int			i;
 	struct usb_interface	*intf;
 	if (udev->state == USB_STATE_NOTATTACHED) {
 		status = -ENODEV;
 		goto done;
 	}
 	udev->can_submit = 1;
 	/* Resume the device */
 	if (udev->state == USB_STATE_SUSPENDED || udev->reset_resume)
 		status = usb_resume_device(udev, msg);
 	/* Resume the interfaces */
 	if (status == 0 && udev->actconfig) {
 		for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
 			intf = udev->actconfig->interface[i];
 			usb_resume_interface(udev, intf, msg,
 					udev->reset_resume);
 		}
 	}
 	usb_mark_last_busy(udev);
  done:
 	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
 	if (!status)
 		udev->reset_resume = 0;
 	return status;
 }
 static void choose_wakeup(struct usb_device *udev, pm_message_t msg)
 {
 	int	w;
 	/* Remote wakeup is needed only when we actually go to sleep.
 	 * For things like FREEZE and QUIESCE, if the device is already
 	 * autosuspended then its current wakeup setting is okay.
 	 */
 	if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_QUIESCE) {
 		if (udev->state != USB_STATE_SUSPENDED)
 			udev->do_remote_wakeup = 0;
 		return;
 	}
 	/* Enable remote wakeup if it is allowed, even if no interface drivers
 	 * actually want it.
 	 */
 	w = device_may_wakeup(&udev->dev);
 	/* If the device is autosuspended with the wrong wakeup setting,
 	 * autoresume now so the setting can be changed.
 	 */
 	if (udev->state == USB_STATE_SUSPENDED && w != udev->do_remote_wakeup)
 		pm_runtime_resume(&udev->dev);
 	udev->do_remote_wakeup = w;
 }
 /* The device lock is held by the PM core */
 int usb_suspend(struct device *dev, pm_message_t msg)
 {
 	struct usb_device	*udev = to_usb_device(dev);
 	unbind_no_pm_drivers_interfaces(udev);
 	/* From now on we are sure all drivers support suspend/resume
 	 * but not necessarily reset_resume()
 	 * so we may still need to unbind and rebind upon resume
 	 */
 	choose_wakeup(udev, msg);
 	return usb_suspend_both(udev, msg);
 }
 /* The device lock is held by the PM core */
-int usb_resume(struct device *dev, pm_message_t msg)
+int usb_resume_complete(struct device *dev)
 {
-	struct usb_device	*udev = to_usb_device(dev);
+	struct usb_device *udev = to_usb_device(dev);
-	int			status;
 	/* For PM complete calls, all we do is rebind interfaces
 	 * whose needs_binding flag is set
 	 */
-	if (msg.event == PM_EVENT_ON) {
+	if (udev->state != USB_STATE_NOTATTACHED)
-		if (udev->state != USB_STATE_NOTATTACHED)
+		do_rebind_interfaces(udev);
-			do_rebind_interfaces(udev);
+	return 0;
-		status = 0;
+}
-	/* For all other calls, take the device back to full power and
+/* The device lock is held by the PM core */
+int usb_resume(struct device *dev, pm_message_t msg)
+{
+	struct usb_device	*udev = to_usb_device(dev);
+	int			status;
+	/* For all calls, take the device back to full power and
 	 * tell the PM core in case it was autosuspended previously.
 	 * Unbind the interfaces that will need rebinding later,
 	 * because they fail to support reset_resume.
 	 * (This can't be done in usb_resume_interface()
-         * above because it doesn't own the right set of locks.)
+	 * above because it doesn't own the right set of locks.)
 	 */
-	} else {
+	status = usb_resume_both(udev, msg);
-		status = usb_resume_both(udev, msg);
+	if (status == 0) {
-		if (status == 0) {
+		pm_runtime_disable(dev);
-			pm_runtime_disable(dev);
+		pm_runtime_set_active(dev);
-			pm_runtime_set_active(dev);
+		pm_runtime_enable(dev);
-			pm_runtime_enable(dev);
+		unbind_no_reset_resume_drivers_interfaces(udev);
-			unbind_no_reset_resume_drivers_interfaces(udev);
-		}
 	}
 	/* Avoid PM error messages for devices disconnected while suspended
 	 * as we'll display regular disconnect messages just a bit later.
 	 */
 	if (status == -ENODEV || status == -ESHUTDOWN)
 		status = 0;
 	return status;
 }
 #endif /* CONFIG_PM */
 #ifdef CONFIG_USB_SUSPEND
 /**
  * usb_enable_autosuspend - allow a USB device to be autosuspended
  * @udev: the USB device which may be autosuspended
  *
  * This routine allows @udev to be autosuspended.  An autosuspend won't
  * take place until the autosuspend_delay has elapsed and all the other
  * necessary conditions are satisfied.
  *
  * The caller must hold @udev's device lock.
  */
 void usb_enable_autosuspend(struct usb_device *udev)
 {
 	pm_runtime_allow(&udev->dev);
 }
 EXPORT_SYMBOL_GPL(usb_enable_autosuspend);
 /**
  * usb_disable_autosuspend - prevent a USB device from being autosuspended
  * @udev: the USB device which may not be autosuspended
  *
  * This routine prevents @udev from being autosuspended and wakes it up
  * if it is already autosuspended.
  *
  * The caller must hold @udev's device lock.
  */
 void usb_disable_autosuspend(struct usb_device *udev)
 {
 	pm_runtime_forbid(&udev->dev);
 }
 EXPORT_SYMBOL_GPL(usb_disable_autosuspend);
 /**
  * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces
  * @udev: the usb_device to autosuspend
  *
  * This routine should be called when a core subsystem is finished using
  * @udev and wants to allow it to autosuspend.  Examples would be when
  * @udev's device file in usbfs is closed or after a configuration change.
  *
  * @udev's usage counter is decremented; if it drops to 0 and all the
  * interfaces are inactive then a delayed autosuspend will be attempted.
  * The attempt may fail (see autosuspend_check()).
  *
  * The caller must hold @udev's device lock.
  *
  * This routine can run only in process context.
  */
 void usb_autosuspend_device(struct usb_device *udev)
 {
 	int	status;
 	usb_mark_last_busy(udev);
 	status = pm_runtime_put_sync_autosuspend(&udev->dev);
 	dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
 			__func__, atomic_read(&udev->dev.power.usage_count),
 			status);
 }
 /**
  * usb_autoresume_device - immediately autoresume a USB device and its interfaces
  * @udev: the usb_device to autoresume
  *
  * This routine should be called when a core subsystem wants to use @udev
  * and needs to guarantee that it is not suspended.  No autosuspend will
  * occur until usb_autosuspend_device() is called.  (Note that this will
  * not prevent suspend events originating in the PM core.)  Examples would
  * be when @udev's device file in usbfs is opened or when a remote-wakeup
  * request is received.
  *
  * @udev's usage counter is incremented to prevent subsequent autosuspends.
  * However if the autoresume fails then the usage counter is re-decremented.
  *
  * The caller must hold @udev's device lock.
  *
  * This routine can run only in process context.
  */
 int usb_autoresume_device(struct usb_device *udev)
 {
 	int	status;
 	status = pm_runtime_get_sync(&udev->dev);
 	if (status < 0)
 		pm_runtime_put_sync(&udev->dev);
 	dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
 			__func__, atomic_read(&udev->dev.power.usage_count),
 			status);
 	if (status > 0)
 		status = 0;
 	return status;
 }
 /**
  * usb_autopm_put_interface - decrement a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be decremented
  *
  * This routine should be called by an interface driver when it is
  * finished using @intf and wants to allow it to autosuspend.  A typical
  * example would be a character-device driver when its device file is
  * closed.
  *
  * The routine decrements @intf's usage counter.  When the counter reaches
  * 0, a delayed autosuspend request for @intf's device is attempted.  The
  * attempt may fail (see autosuspend_check()).
  *
  * This routine can run only in process context.
  */
 void usb_autopm_put_interface(struct usb_interface *intf)
 {
 	struct usb_device	*udev = interface_to_usbdev(intf);
 	int			status;
 	usb_mark_last_busy(udev);
 	atomic_dec(&intf->pm_usage_cnt);
 	status = pm_runtime_put_sync(&intf->dev);
 	dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
 			__func__, atomic_read(&intf->dev.power.usage_count),
 			status);
 }
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
 /**
  * usb_autopm_put_interface_async - decrement a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be decremented
  *
  * This routine does much the same thing as usb_autopm_put_interface():
  * It decrements @intf's usage counter and schedules a delayed
  * autosuspend request if the counter is <= 0.  The difference is that it
  * does not perform any synchronization; callers should hold a private
  * lock and handle all synchronization issues themselves.
  *
  * Typically a driver would call this routine during an URB's completion
  * handler, if no more URBs were pending.
  *
  * This routine can run in atomic context.
  */
 void usb_autopm_put_interface_async(struct usb_interface *intf)
 {
 	struct usb_device	*udev = interface_to_usbdev(intf);
 	int			status;
 	usb_mark_last_busy(udev);
 	atomic_dec(&intf->pm_usage_cnt);
 	status = pm_runtime_put(&intf->dev);
 	dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
 			__func__, atomic_read(&intf->dev.power.usage_count),
 			status);
 }
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
 /**
  * usb_autopm_put_interface_no_suspend - decrement a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be decremented
  *
  * This routine decrements @intf's usage counter but does not carry out an
  * autosuspend.
  *
  * This routine can run in atomic context.
  */
 void usb_autopm_put_interface_no_suspend(struct usb_interface *intf)
 {
 	struct usb_device	*udev = interface_to_usbdev(intf);
 	usb_mark_last_busy(udev);
 	atomic_dec(&intf->pm_usage_cnt);
 	pm_runtime_put_noidle(&intf->dev);
 }
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface_no_suspend);
 /**
  * usb_autopm_get_interface - increment a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be incremented
  *
  * This routine should be called by an interface driver when it wants to
  * use @intf and needs to guarantee that it is not suspended.  In addition,
  * the routine prevents @intf from being autosuspended subsequently.  (Note
  * that this will not prevent suspend events originating in the PM core.)
  * This prevention will persist until usb_autopm_put_interface() is called
  * or @intf is unbound.  A typical example would be a character-device
  * driver when its device file is opened.
  *
  * @intf's usage counter is incremented to prevent subsequent autosuspends.
  * However if the autoresume fails then the counter is re-decremented.
  *
  * This routine can run only in process context.
  */
 int usb_autopm_get_interface(struct usb_interface *intf)
 {
 	int	status;
 	status = pm_runtime_get_sync(&intf->dev);
 	if (status < 0)
 		pm_runtime_put_sync(&intf->dev);
 	else
 		atomic_inc(&intf->pm_usage_cnt);
 	dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
 			__func__, atomic_read(&intf->dev.power.usage_count),
 			status);
 	if (status > 0)
 		status = 0;
 	return status;
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
 /**
  * usb_autopm_get_interface_async - increment a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be incremented
  *
  * This routine does much the same thing as
  * usb_autopm_get_interface(): It increments @intf's usage counter and
  * queues an autoresume request if the device is suspended.  The
  * differences are that it does not perform any synchronization (callers
  * should hold a private lock and handle all synchronization issues
  * themselves), and it does not autoresume the device directly (it only
  * queues a request).  After a successful call, the device may not yet be
  * resumed.
  *
  * This routine can run in atomic context.
  */
 int usb_autopm_get_interface_async(struct usb_interface *intf)
 {
 	int	status;
 	status = pm_runtime_get(&intf->dev);
 	if (status < 0 && status != -EINPROGRESS)
 		pm_runtime_put_noidle(&intf->dev);
 	else
 		atomic_inc(&intf->pm_usage_cnt);
 	dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
 			__func__, atomic_read(&intf->dev.power.usage_count),
 			status);
 	if (status > 0 || status == -EINPROGRESS)
 		status = 0;
 	return status;
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async);
 /**
  * usb_autopm_get_interface_no_resume - increment a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be incremented
  *
  * This routine increments @intf's usage counter but does not carry out an
  * autoresume.
  *
  * This routine can run in atomic context.
  */
 void usb_autopm_get_interface_no_resume(struct usb_interface *intf)
 {
 	struct usb_device	*udev = interface_to_usbdev(intf);
 	usb_mark_last_busy(udev);
 	atomic_inc(&intf->pm_usage_cnt);
 	pm_runtime_get_noresume(&intf->dev);
 }
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface_no_resume);
 /* Internal routine to check whether we may autosuspend a device. */
 static int autosuspend_check(struct usb_device *udev)
 {
 	int			w, i;
 	struct usb_interface	*intf;
 	/* Fail if autosuspend is disabled, or any interfaces are in use, or
 	 * any interface drivers require remote wakeup but it isn't available.
 	 */
 	w = 0;
 	if (udev->actconfig) {
 		for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
 			intf = udev->actconfig->interface[i];
 			/* We don't need to check interfaces that are
 			 * disabled for runtime PM.  Either they are unbound
 			 * or else their drivers don't support autosuspend
 			 * and so they are permanently active.
 			 */
 			if (intf->dev.power.disable_depth)
 				continue;
 			if (atomic_read(&intf->dev.power.usage_count) > 0)
 				return -EBUSY;
 			w |= intf->needs_remote_wakeup;
 			/* Don't allow autosuspend if the device will need
 			 * a reset-resume and any of its interface drivers
 			 * doesn't include support or needs remote wakeup.
 			 */
 			if (udev->quirks & USB_QUIRK_RESET_RESUME) {
 				struct usb_driver *driver;
 				driver = to_usb_driver(intf->dev.driver);
 				if (!driver->reset_resume ||
 						intf->needs_remote_wakeup)
 					return -EOPNOTSUPP;
 			}
 		}
 	}
 	if (w && !device_can_wakeup(&udev->dev)) {
 		dev_dbg(&udev->dev, "remote wakeup needed for autosuspend\n");
 		return -EOPNOTSUPP;
 	}
 	udev->do_remote_wakeup = w;
 	return 0;
 }
 int usb_runtime_suspend(struct device *dev)
 {
 	struct usb_device	*udev = to_usb_device(dev);
 	int			status;
 	/* A USB device can be suspended if it passes the various autosuspend
 	 * checks.  Runtime suspend for a USB device means suspending all the
 	 * interfaces and then the device itself.
 	 */
 	if (autosuspend_check(udev) != 0)
 		return -EAGAIN;
 	status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
 	/* Allow a retry if autosuspend failed temporarily */
 	if (status == -EAGAIN || status == -EBUSY)
 		usb_mark_last_busy(udev);
 	/* The PM core reacts badly unless the return code is 0,
 	 * -EAGAIN, or -EBUSY, so always return -EBUSY on an error.
 	 */
 	if (status != 0)
 		return -EBUSY;
 	return status;
 }
 int usb_runtime_resume(struct device *dev)
 {
 	struct usb_device	*udev = to_usb_device(dev);
 	int			status;
 	/* Runtime resume for a USB device means resuming both the device
 	 * and all its interfaces.
 	 */
 	status = usb_resume_both(udev, PMSG_AUTO_RESUME);
 	return status;
 }
 int usb_runtime_idle(struct device *dev)
 {
 	struct usb_device	*udev = to_usb_device(dev);
 	/* An idle USB device can be suspended if it passes the various
 	 * autosuspend checks.
 	 */
 	if (autosuspend_check(udev) == 0)
 		pm_runtime_autosuspend(dev);
 	return 0;
 }
 int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable)
 {
 	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 	int ret = -EPERM;
 	if (hcd->driver->set_usb2_hw_lpm) {
 		ret = hcd->driver->set_usb2_hw_lpm(hcd, udev, enable);
 		if (!ret)
 			udev->usb2_hw_lpm_enabled = enable;
 	}
 	return ret;
 }
 #endif /* CONFIG_USB_SUSPEND */
 struct bus_type usb_bus_type = {
 	.name =		"usb",
 	.match =	usb_device_match,

drivers/usb/core/usb.c

Diff comments View file @ 98d9a82

1	/*	1	/*
2	* drivers/usb/core/usb.c	2	* drivers/usb/core/usb.c
3	*	3	*
4	* (C) Copyright Linus Torvalds 1999	4	* (C) Copyright Linus Torvalds 1999
5	* (C) Copyright Johannes Erdfelt 1999-2001	5	* (C) Copyright Johannes Erdfelt 1999-2001
6	* (C) Copyright Andreas Gal 1999	6	* (C) Copyright Andreas Gal 1999
7	* (C) Copyright Gregory P. Smith 1999	7	* (C) Copyright Gregory P. Smith 1999
8	* (C) Copyright Deti Fliegl 1999 (new USB architecture)	8	* (C) Copyright Deti Fliegl 1999 (new USB architecture)
9	* (C) Copyright Randy Dunlap 2000	9	* (C) Copyright Randy Dunlap 2000
10	* (C) Copyright David Brownell 2000-2004	10	* (C) Copyright David Brownell 2000-2004
11	* (C) Copyright Yggdrasil Computing, Inc. 2000	11	* (C) Copyright Yggdrasil Computing, Inc. 2000
12	* (usb_device_id matching changes by Adam J. Richter)	12	* (usb_device_id matching changes by Adam J. Richter)
13	* (C) Copyright Greg Kroah-Hartman 2002-2003	13	* (C) Copyright Greg Kroah-Hartman 2002-2003
14	*	14	*
15	* NOTE! This is not actually a driver at all, rather this is	15	* NOTE! This is not actually a driver at all, rather this is
16	* just a collection of helper routines that implement the	16	* just a collection of helper routines that implement the
17	* generic USB things that the real drivers can use..	17	* generic USB things that the real drivers can use..
18	*	18	*
19	* Think of this as a "USB library" rather than anything else.	19	* Think of this as a "USB library" rather than anything else.
20	* It should be considered a slave, with no callbacks. Callbacks	20	* It should be considered a slave, with no callbacks. Callbacks
21	* are evil.	21	* are evil.
22	*/	22	*/
23		23
24	#include <linux/module.h>	24	#include <linux/module.h>
25	#include <linux/moduleparam.h>	25	#include <linux/moduleparam.h>
26	#include <linux/string.h>	26	#include <linux/string.h>
27	#include <linux/bitops.h>	27	#include <linux/bitops.h>
28	#include <linux/slab.h>	28	#include <linux/slab.h>
29	#include <linux/interrupt.h> /* for in_interrupt() */	29	#include <linux/interrupt.h> /* for in_interrupt() */
30	#include <linux/kmod.h>	30	#include <linux/kmod.h>
31	#include <linux/init.h>	31	#include <linux/init.h>
32	#include <linux/spinlock.h>	32	#include <linux/spinlock.h>
33	#include <linux/errno.h>	33	#include <linux/errno.h>
34	#include <linux/usb.h>	34	#include <linux/usb.h>
35	#include <linux/usb/hcd.h>	35	#include <linux/usb/hcd.h>
36	#include <linux/mutex.h>	36	#include <linux/mutex.h>
37	#include <linux/workqueue.h>	37	#include <linux/workqueue.h>
38	#include <linux/debugfs.h>	38	#include <linux/debugfs.h>
39		39
40	#include <asm/io.h>	40	#include <asm/io.h>
41	#include <linux/scatterlist.h>	41	#include <linux/scatterlist.h>
42	#include <linux/mm.h>	42	#include <linux/mm.h>
43	#include <linux/dma-mapping.h>	43	#include <linux/dma-mapping.h>
44		44
45	#include "usb.h"	45	#include "usb.h"
46		46
47		47
48	const char *usbcore_name = "usbcore";	48	const char *usbcore_name = "usbcore";
49		49
50	static bool nousb; /* Disable USB when built into kernel image */	50	static bool nousb; /* Disable USB when built into kernel image */
51		51
52	#ifdef CONFIG_USB_SUSPEND	52	#ifdef CONFIG_USB_SUSPEND
53	static int usb_autosuspend_delay = 2; /* Default delay value,	53	static int usb_autosuspend_delay = 2; /* Default delay value,
54	* in seconds */	54	* in seconds */
55	module_param_named(autosuspend, usb_autosuspend_delay, int, 0644);	55	module_param_named(autosuspend, usb_autosuspend_delay, int, 0644);
56	MODULE_PARM_DESC(autosuspend, "default autosuspend delay");	56	MODULE_PARM_DESC(autosuspend, "default autosuspend delay");
57		57
58	#else	58	#else
59	#define usb_autosuspend_delay 0	59	#define usb_autosuspend_delay 0
60	#endif	60	#endif
61		61
62		62
63	/**	63	/**
64	* usb_find_alt_setting() - Given a configuration, find the alternate setting	64	* usb_find_alt_setting() - Given a configuration, find the alternate setting
65	* for the given interface.	65	* for the given interface.
66	* @config: the configuration to search (not necessarily the current config).	66	* @config: the configuration to search (not necessarily the current config).
67	* @iface_num: interface number to search in	67	* @iface_num: interface number to search in
68	* @alt_num: alternate interface setting number to search for.	68	* @alt_num: alternate interface setting number to search for.
69	*	69	*
70	* Search the configuration's interface cache for the given alt setting.	70	* Search the configuration's interface cache for the given alt setting.
71	*/	71	*/
72	struct usb_host_interface *usb_find_alt_setting(	72	struct usb_host_interface *usb_find_alt_setting(
73	struct usb_host_config *config,	73	struct usb_host_config *config,
74	unsigned int iface_num,	74	unsigned int iface_num,
75	unsigned int alt_num)	75	unsigned int alt_num)
76	{	76	{
77	struct usb_interface_cache *intf_cache = NULL;	77	struct usb_interface_cache *intf_cache = NULL;
78	int i;	78	int i;
79		79
80	for (i = 0; i < config->desc.bNumInterfaces; i++) {	80	for (i = 0; i < config->desc.bNumInterfaces; i++) {
81	if (config->intf_cache[i]->altsetting[0].desc.bInterfaceNumber	81	if (config->intf_cache[i]->altsetting[0].desc.bInterfaceNumber
82	== iface_num) {	82	== iface_num) {
83	intf_cache = config->intf_cache[i];	83	intf_cache = config->intf_cache[i];
84	break;	84	break;
85	}	85	}
86	}	86	}
87	if (!intf_cache)	87	if (!intf_cache)
88	return NULL;	88	return NULL;
89	for (i = 0; i < intf_cache->num_altsetting; i++)	89	for (i = 0; i < intf_cache->num_altsetting; i++)
90	if (intf_cache->altsetting[i].desc.bAlternateSetting == alt_num)	90	if (intf_cache->altsetting[i].desc.bAlternateSetting == alt_num)
91	return &intf_cache->altsetting[i];	91	return &intf_cache->altsetting[i];
92		92
93	printk(KERN_DEBUG "Did not find alt setting %u for intf %u, "	93	printk(KERN_DEBUG "Did not find alt setting %u for intf %u, "
94	"config %u\n", alt_num, iface_num,	94	"config %u\n", alt_num, iface_num,
95	config->desc.bConfigurationValue);	95	config->desc.bConfigurationValue);
96	return NULL;	96	return NULL;
97	}	97	}
98	EXPORT_SYMBOL_GPL(usb_find_alt_setting);	98	EXPORT_SYMBOL_GPL(usb_find_alt_setting);
99		99
100	/**	100	/**
101	* usb_ifnum_to_if - get the interface object with a given interface number	101	* usb_ifnum_to_if - get the interface object with a given interface number
102	* @dev: the device whose current configuration is considered	102	* @dev: the device whose current configuration is considered
103	* @ifnum: the desired interface	103	* @ifnum: the desired interface
104	*	104	*
105	* This walks the device descriptor for the currently active configuration	105	* This walks the device descriptor for the currently active configuration
106	* and returns a pointer to the interface with that particular interface	106	* and returns a pointer to the interface with that particular interface
107	* number, or null.	107	* number, or null.
108	*	108	*
109	* Note that configuration descriptors are not required to assign interface	109	* Note that configuration descriptors are not required to assign interface
110	* numbers sequentially, so that it would be incorrect to assume that	110	* numbers sequentially, so that it would be incorrect to assume that
111	* the first interface in that descriptor corresponds to interface zero.	111	* the first interface in that descriptor corresponds to interface zero.
112	* This routine helps device drivers avoid such mistakes.	112	* This routine helps device drivers avoid such mistakes.
113	* However, you should make sure that you do the right thing with any	113	* However, you should make sure that you do the right thing with any
114	* alternate settings available for this interfaces.	114	* alternate settings available for this interfaces.
115	*	115	*
116	* Don't call this function unless you are bound to one of the interfaces	116	* Don't call this function unless you are bound to one of the interfaces
117	* on this device or you have locked the device!	117	* on this device or you have locked the device!
118	*/	118	*/
119	struct usb_interface usb_ifnum_to_if(const struct usb_device dev,	119	struct usb_interface usb_ifnum_to_if(const struct usb_device dev,
120	unsigned ifnum)	120	unsigned ifnum)
121	{	121	{
122	struct usb_host_config *config = dev->actconfig;	122	struct usb_host_config *config = dev->actconfig;
123	int i;	123	int i;
124		124
125	if (!config)	125	if (!config)
126	return NULL;	126	return NULL;
127	for (i = 0; i < config->desc.bNumInterfaces; i++)	127	for (i = 0; i < config->desc.bNumInterfaces; i++)
128	if (config->interface[i]->altsetting[0]	128	if (config->interface[i]->altsetting[0]
129	.desc.bInterfaceNumber == ifnum)	129	.desc.bInterfaceNumber == ifnum)
130	return config->interface[i];	130	return config->interface[i];
131		131
132	return NULL;	132	return NULL;
133	}	133	}
134	EXPORT_SYMBOL_GPL(usb_ifnum_to_if);	134	EXPORT_SYMBOL_GPL(usb_ifnum_to_if);
135		135
136	/**	136	/**
137	* usb_altnum_to_altsetting - get the altsetting structure with a given alternate setting number.	137	* usb_altnum_to_altsetting - get the altsetting structure with a given alternate setting number.
138	* @intf: the interface containing the altsetting in question	138	* @intf: the interface containing the altsetting in question
139	* @altnum: the desired alternate setting number	139	* @altnum: the desired alternate setting number
140	*	140	*
141	* This searches the altsetting array of the specified interface for	141	* This searches the altsetting array of the specified interface for
142	* an entry with the correct bAlternateSetting value and returns a pointer	142	* an entry with the correct bAlternateSetting value and returns a pointer
143	* to that entry, or null.	143	* to that entry, or null.
144	*	144	*
145	* Note that altsettings need not be stored sequentially by number, so	145	* Note that altsettings need not be stored sequentially by number, so
146	* it would be incorrect to assume that the first altsetting entry in	146	* it would be incorrect to assume that the first altsetting entry in
147	* the array corresponds to altsetting zero. This routine helps device	147	* the array corresponds to altsetting zero. This routine helps device
148	* drivers avoid such mistakes.	148	* drivers avoid such mistakes.
149	*	149	*
150	* Don't call this function unless you are bound to the intf interface	150	* Don't call this function unless you are bound to the intf interface
151	* or you have locked the device!	151	* or you have locked the device!
152	*/	152	*/
153	struct usb_host_interface *usb_altnum_to_altsetting(	153	struct usb_host_interface *usb_altnum_to_altsetting(
154	const struct usb_interface *intf,	154	const struct usb_interface *intf,
155	unsigned int altnum)	155	unsigned int altnum)
156	{	156	{
157	int i;	157	int i;
158		158
159	for (i = 0; i < intf->num_altsetting; i++) {	159	for (i = 0; i < intf->num_altsetting; i++) {
160	if (intf->altsetting[i].desc.bAlternateSetting == altnum)	160	if (intf->altsetting[i].desc.bAlternateSetting == altnum)
161	return &intf->altsetting[i];	161	return &intf->altsetting[i];
162	}	162	}
163	return NULL;	163	return NULL;
164	}	164	}
165	EXPORT_SYMBOL_GPL(usb_altnum_to_altsetting);	165	EXPORT_SYMBOL_GPL(usb_altnum_to_altsetting);
166		166
167	struct find_interface_arg {	167	struct find_interface_arg {
168	int minor;	168	int minor;
169	struct device_driver *drv;	169	struct device_driver *drv;
170	};	170	};
171		171
172	static int __find_interface(struct device dev, void data)	172	static int __find_interface(struct device dev, void data)
173	{	173	{
174	struct find_interface_arg *arg = data;	174	struct find_interface_arg *arg = data;
175	struct usb_interface *intf;	175	struct usb_interface *intf;
176		176
177	if (!is_usb_interface(dev))	177	if (!is_usb_interface(dev))
178	return 0;	178	return 0;
179		179
180	if (dev->driver != arg->drv)	180	if (dev->driver != arg->drv)
181	return 0;	181	return 0;
182	intf = to_usb_interface(dev);	182	intf = to_usb_interface(dev);
183	return intf->minor == arg->minor;	183	return intf->minor == arg->minor;
184	}	184	}
185		185
186	/**	186	/**
187	* usb_find_interface - find usb_interface pointer for driver and device	187	* usb_find_interface - find usb_interface pointer for driver and device
188	* @drv: the driver whose current configuration is considered	188	* @drv: the driver whose current configuration is considered
189	* @minor: the minor number of the desired device	189	* @minor: the minor number of the desired device
190	*	190	*
191	* This walks the bus device list and returns a pointer to the interface	191	* This walks the bus device list and returns a pointer to the interface
192	* with the matching minor and driver. Note, this only works for devices	192	* with the matching minor and driver. Note, this only works for devices
193	* that share the USB major number.	193	* that share the USB major number.
194	*/	194	*/
195	struct usb_interface usb_find_interface(struct usb_driver drv, int minor)	195	struct usb_interface usb_find_interface(struct usb_driver drv, int minor)
196	{	196	{
197	struct find_interface_arg argb;	197	struct find_interface_arg argb;
198	struct device *dev;	198	struct device *dev;
199		199
200	argb.minor = minor;	200	argb.minor = minor;
201	argb.drv = &drv->drvwrap.driver;	201	argb.drv = &drv->drvwrap.driver;
202		202
203	dev = bus_find_device(&usb_bus_type, NULL, &argb, __find_interface);	203	dev = bus_find_device(&usb_bus_type, NULL, &argb, __find_interface);
204		204
205	/* Drop reference count from bus_find_device */	205	/* Drop reference count from bus_find_device */
206	put_device(dev);	206	put_device(dev);
207		207
208	return dev ? to_usb_interface(dev) : NULL;	208	return dev ? to_usb_interface(dev) : NULL;
209	}	209	}
210	EXPORT_SYMBOL_GPL(usb_find_interface);	210	EXPORT_SYMBOL_GPL(usb_find_interface);
211		211
212	/**	212	/**
213	* usb_release_dev - free a usb device structure when all users of it are finished.	213	* usb_release_dev - free a usb device structure when all users of it are finished.
214	* @dev: device that's been disconnected	214	* @dev: device that's been disconnected
215	*	215	*
216	* Will be called only by the device core when all users of this usb device are	216	* Will be called only by the device core when all users of this usb device are
217	* done.	217	* done.
218	*/	218	*/
219	static void usb_release_dev(struct device *dev)	219	static void usb_release_dev(struct device *dev)
220	{	220	{
221	struct usb_device *udev;	221	struct usb_device *udev;
222	struct usb_hcd *hcd;	222	struct usb_hcd *hcd;
223		223
224	udev = to_usb_device(dev);	224	udev = to_usb_device(dev);
225	hcd = bus_to_hcd(udev->bus);	225	hcd = bus_to_hcd(udev->bus);
226		226
227	usb_destroy_configuration(udev);	227	usb_destroy_configuration(udev);
228	usb_release_bos_descriptor(udev);	228	usb_release_bos_descriptor(udev);
229	usb_put_hcd(hcd);	229	usb_put_hcd(hcd);
230	kfree(udev->product);	230	kfree(udev->product);
231	kfree(udev->manufacturer);	231	kfree(udev->manufacturer);
232	kfree(udev->serial);	232	kfree(udev->serial);
233	kfree(udev);	233	kfree(udev);
234	}	234	}
235		235
236	#ifdef CONFIG_HOTPLUG	236	#ifdef CONFIG_HOTPLUG
237	static int usb_dev_uevent(struct device dev, struct kobj_uevent_env env)	237	static int usb_dev_uevent(struct device dev, struct kobj_uevent_env env)
238	{	238	{
239	struct usb_device *usb_dev;	239	struct usb_device *usb_dev;
240		240
241	usb_dev = to_usb_device(dev);	241	usb_dev = to_usb_device(dev);
242		242
243	if (add_uevent_var(env, "BUSNUM=%03d", usb_dev->bus->busnum))	243	if (add_uevent_var(env, "BUSNUM=%03d", usb_dev->bus->busnum))
244	return -ENOMEM;	244	return -ENOMEM;
245		245
246	if (add_uevent_var(env, "DEVNUM=%03d", usb_dev->devnum))	246	if (add_uevent_var(env, "DEVNUM=%03d", usb_dev->devnum))
247	return -ENOMEM;	247	return -ENOMEM;
248		248
249	return 0;	249	return 0;
250	}	250	}
251		251
252	#else	252	#else
253		253
254	static int usb_dev_uevent(struct device dev, struct kobj_uevent_env env)	254	static int usb_dev_uevent(struct device dev, struct kobj_uevent_env env)
255	{	255	{
256	return -ENODEV;	256	return -ENODEV;
257	}	257	}
258	#endif /* CONFIG_HOTPLUG */	258	#endif /* CONFIG_HOTPLUG */
259		259
260	#ifdef CONFIG_PM	260	#ifdef CONFIG_PM
261		261
262	/* USB device Power-Management thunks.	262	/* USB device Power-Management thunks.
263	* There's no need to distinguish here between quiescing a USB device	263	* There's no need to distinguish here between quiescing a USB device
264	* and powering it down; the generic_suspend() routine takes care of	264	* and powering it down; the generic_suspend() routine takes care of
265	* it by skipping the usb_port_suspend() call for a quiesce. And for	265	* it by skipping the usb_port_suspend() call for a quiesce. And for
266	* USB interfaces there's no difference at all.	266	* USB interfaces there's no difference at all.
267	*/	267	*/
268		268
269	static int usb_dev_prepare(struct device *dev)	269	static int usb_dev_prepare(struct device *dev)
270	{	270	{
271	return 0; /* Implement eventually? */	271	return 0; /* Implement eventually? */
272	}	272	}
273		273
274	static void usb_dev_complete(struct device *dev)	274	static void usb_dev_complete(struct device *dev)
275	{	275	{
276	/* Currently used only for rebinding interfaces */	276	/* Currently used only for rebinding interfaces */
277	usb_resume(dev, PMSG_ON); /* FIXME: change to PMSG_COMPLETE */	277	usb_resume_complete(dev);
278	}	278	}
279		279
280	static int usb_dev_suspend(struct device *dev)	280	static int usb_dev_suspend(struct device *dev)
281	{	281	{
282	return usb_suspend(dev, PMSG_SUSPEND);	282	return usb_suspend(dev, PMSG_SUSPEND);
283	}	283	}
284		284
285	static int usb_dev_resume(struct device *dev)	285	static int usb_dev_resume(struct device *dev)
286	{	286	{
287	return usb_resume(dev, PMSG_RESUME);	287	return usb_resume(dev, PMSG_RESUME);
288	}	288	}
289		289
290	static int usb_dev_freeze(struct device *dev)	290	static int usb_dev_freeze(struct device *dev)
291	{	291	{
292	return usb_suspend(dev, PMSG_FREEZE);	292	return usb_suspend(dev, PMSG_FREEZE);
293	}	293	}
294		294
295	static int usb_dev_thaw(struct device *dev)	295	static int usb_dev_thaw(struct device *dev)
296	{	296	{
297	return usb_resume(dev, PMSG_THAW);	297	return usb_resume(dev, PMSG_THAW);
298	}	298	}
299		299
300	static int usb_dev_poweroff(struct device *dev)	300	static int usb_dev_poweroff(struct device *dev)
301	{	301	{
302	return usb_suspend(dev, PMSG_HIBERNATE);	302	return usb_suspend(dev, PMSG_HIBERNATE);
303	}	303	}
304		304
305	static int usb_dev_restore(struct device *dev)	305	static int usb_dev_restore(struct device *dev)
306	{	306	{
307	return usb_resume(dev, PMSG_RESTORE);	307	return usb_resume(dev, PMSG_RESTORE);
308	}	308	}
309		309
310	static const struct dev_pm_ops usb_device_pm_ops = {	310	static const struct dev_pm_ops usb_device_pm_ops = {
311	.prepare = usb_dev_prepare,	311	.prepare = usb_dev_prepare,
312	.complete = usb_dev_complete,	312	.complete = usb_dev_complete,
313	.suspend = usb_dev_suspend,	313	.suspend = usb_dev_suspend,
314	.resume = usb_dev_resume,	314	.resume = usb_dev_resume,
315	.freeze = usb_dev_freeze,	315	.freeze = usb_dev_freeze,
316	.thaw = usb_dev_thaw,	316	.thaw = usb_dev_thaw,
317	.poweroff = usb_dev_poweroff,	317	.poweroff = usb_dev_poweroff,
318	.restore = usb_dev_restore,	318	.restore = usb_dev_restore,
319	#ifdef CONFIG_USB_SUSPEND	319	#ifdef CONFIG_USB_SUSPEND
320	.runtime_suspend = usb_runtime_suspend,	320	.runtime_suspend = usb_runtime_suspend,
321	.runtime_resume = usb_runtime_resume,	321	.runtime_resume = usb_runtime_resume,
322	.runtime_idle = usb_runtime_idle,	322	.runtime_idle = usb_runtime_idle,
323	#endif	323	#endif
324	};	324	};
325		325
326	#endif /* CONFIG_PM */	326	#endif /* CONFIG_PM */
327		327
328		328
329	static char usb_devnode(struct device dev, umode_t *mode)	329	static char usb_devnode(struct device dev, umode_t *mode)
330	{	330	{
331	struct usb_device *usb_dev;	331	struct usb_device *usb_dev;
332		332
333	usb_dev = to_usb_device(dev);	333	usb_dev = to_usb_device(dev);
334	return kasprintf(GFP_KERNEL, "bus/usb/%03d/%03d",	334	return kasprintf(GFP_KERNEL, "bus/usb/%03d/%03d",
335	usb_dev->bus->busnum, usb_dev->devnum);	335	usb_dev->bus->busnum, usb_dev->devnum);
336	}	336	}
337		337
338	struct device_type usb_device_type = {	338	struct device_type usb_device_type = {
339	.name = "usb_device",	339	.name = "usb_device",
340	.release = usb_release_dev,	340	.release = usb_release_dev,
341	.uevent = usb_dev_uevent,	341	.uevent = usb_dev_uevent,
342	.devnode = usb_devnode,	342	.devnode = usb_devnode,
343	#ifdef CONFIG_PM	343	#ifdef CONFIG_PM
344	.pm = &usb_device_pm_ops,	344	.pm = &usb_device_pm_ops,
345	#endif	345	#endif
346	};	346	};
347		347
348		348
349	/* Returns 1 if @usb_bus is WUSB, 0 otherwise */	349	/* Returns 1 if @usb_bus is WUSB, 0 otherwise */
350	static unsigned usb_bus_is_wusb(struct usb_bus *bus)	350	static unsigned usb_bus_is_wusb(struct usb_bus *bus)
351	{	351	{
352	struct usb_hcd *hcd = container_of(bus, struct usb_hcd, self);	352	struct usb_hcd *hcd = container_of(bus, struct usb_hcd, self);
353	return hcd->wireless;	353	return hcd->wireless;
354	}	354	}
355		355
356		356
357	/**	357	/**
358	* usb_alloc_dev - usb device constructor (usbcore-internal)	358	* usb_alloc_dev - usb device constructor (usbcore-internal)
359	* @parent: hub to which device is connected; null to allocate a root hub	359	* @parent: hub to which device is connected; null to allocate a root hub
360	* @bus: bus used to access the device	360	* @bus: bus used to access the device
361	* @port1: one-based index of port; ignored for root hubs	361	* @port1: one-based index of port; ignored for root hubs
362	* Context: !in_interrupt()	362	* Context: !in_interrupt()
363	*	363	*
364	* Only hub drivers (including virtual root hub drivers for host	364	* Only hub drivers (including virtual root hub drivers for host
365	* controllers) should ever call this.	365	* controllers) should ever call this.
366	*	366	*
367	* This call may not be used in a non-sleeping context.	367	* This call may not be used in a non-sleeping context.
368	*/	368	*/
369	struct usb_device usb_alloc_dev(struct usb_device parent,	369	struct usb_device usb_alloc_dev(struct usb_device parent,
370	struct usb_bus *bus, unsigned port1)	370	struct usb_bus *bus, unsigned port1)
371	{	371	{
372	struct usb_device *dev;	372	struct usb_device *dev;
373	struct usb_hcd *usb_hcd = container_of(bus, struct usb_hcd, self);	373	struct usb_hcd *usb_hcd = container_of(bus, struct usb_hcd, self);
374	unsigned root_hub = 0;	374	unsigned root_hub = 0;
375		375
376	dev = kzalloc(sizeof(*dev), GFP_KERNEL);	376	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
377	if (!dev)	377	if (!dev)
378	return NULL;	378	return NULL;
379		379
380	if (!usb_get_hcd(bus_to_hcd(bus))) {	380	if (!usb_get_hcd(bus_to_hcd(bus))) {
381	kfree(dev);	381	kfree(dev);
382	return NULL;	382	return NULL;
383	}	383	}
384	/* Root hubs aren't true devices, so don't allocate HCD resources */	384	/* Root hubs aren't true devices, so don't allocate HCD resources */
385	if (usb_hcd->driver->alloc_dev && parent &&	385	if (usb_hcd->driver->alloc_dev && parent &&
386	!usb_hcd->driver->alloc_dev(usb_hcd, dev)) {	386	!usb_hcd->driver->alloc_dev(usb_hcd, dev)) {
387	usb_put_hcd(bus_to_hcd(bus));	387	usb_put_hcd(bus_to_hcd(bus));
388	kfree(dev);	388	kfree(dev);
389	return NULL;	389	return NULL;
390	}	390	}
391		391
392	device_initialize(&dev->dev);	392	device_initialize(&dev->dev);
393	dev->dev.bus = &usb_bus_type;	393	dev->dev.bus = &usb_bus_type;
394	dev->dev.type = &usb_device_type;	394	dev->dev.type = &usb_device_type;
395	dev->dev.groups = usb_device_groups;	395	dev->dev.groups = usb_device_groups;
396	dev->dev.dma_mask = bus->controller->dma_mask;	396	dev->dev.dma_mask = bus->controller->dma_mask;
397	set_dev_node(&dev->dev, dev_to_node(bus->controller));	397	set_dev_node(&dev->dev, dev_to_node(bus->controller));
398	dev->state = USB_STATE_ATTACHED;	398	dev->state = USB_STATE_ATTACHED;
399	atomic_set(&dev->urbnum, 0);	399	atomic_set(&dev->urbnum, 0);
400		400
401	INIT_LIST_HEAD(&dev->ep0.urb_list);	401	INIT_LIST_HEAD(&dev->ep0.urb_list);
402	dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;	402	dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
403	dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;	403	dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
404	/* ep0 maxpacket comes later, from device descriptor */	404	/* ep0 maxpacket comes later, from device descriptor */
405	usb_enable_endpoint(dev, &dev->ep0, false);	405	usb_enable_endpoint(dev, &dev->ep0, false);
406	dev->can_submit = 1;	406	dev->can_submit = 1;
407		407
408	/* Save readable and stable topology id, distinguishing devices	408	/* Save readable and stable topology id, distinguishing devices
409	* by location for diagnostics, tools, driver model, etc. The	409	* by location for diagnostics, tools, driver model, etc. The
410	* string is a path along hub ports, from the root. Each device's	410	* string is a path along hub ports, from the root. Each device's
411	* dev->devpath will be stable until USB is re-cabled, and hubs	411	* dev->devpath will be stable until USB is re-cabled, and hubs
412	* are often labeled with these port numbers. The name isn't	412	* are often labeled with these port numbers. The name isn't
413	* as stable: bus->busnum changes easily from modprobe order,	413	* as stable: bus->busnum changes easily from modprobe order,
414	* cardbus or pci hotplugging, and so on.	414	* cardbus or pci hotplugging, and so on.
415	*/	415	*/
416	if (unlikely(!parent)) {	416	if (unlikely(!parent)) {
417	dev->devpath[0] = '0';	417	dev->devpath[0] = '0';
418	dev->route = 0;	418	dev->route = 0;
419		419
420	dev->dev.parent = bus->controller;	420	dev->dev.parent = bus->controller;
421	dev_set_name(&dev->dev, "usb%d", bus->busnum);	421	dev_set_name(&dev->dev, "usb%d", bus->busnum);
422	root_hub = 1;	422	root_hub = 1;
423	} else {	423	} else {
424	/* match any labeling on the hubs; it's one-based */	424	/* match any labeling on the hubs; it's one-based */
425	if (parent->devpath[0] == '0') {	425	if (parent->devpath[0] == '0') {
426	snprintf(dev->devpath, sizeof dev->devpath,	426	snprintf(dev->devpath, sizeof dev->devpath,
427	"%d", port1);	427	"%d", port1);
428	/* Root ports are not counted in route string */	428	/* Root ports are not counted in route string */
429	dev->route = 0;	429	dev->route = 0;
430	} else {	430	} else {
431	snprintf(dev->devpath, sizeof dev->devpath,	431	snprintf(dev->devpath, sizeof dev->devpath,
432	"%s.%d", parent->devpath, port1);	432	"%s.%d", parent->devpath, port1);
433	/* Route string assumes hubs have less than 16 ports */	433	/* Route string assumes hubs have less than 16 ports */
434	if (port1 < 15)	434	if (port1 < 15)
435	dev->route = parent->route +	435	dev->route = parent->route +
436	(port1 << ((parent->level - 1)*4));	436	(port1 << ((parent->level - 1)*4));
437	else	437	else
438	dev->route = parent->route +	438	dev->route = parent->route +
439	(15 << ((parent->level - 1)*4));	439	(15 << ((parent->level - 1)*4));
440	}	440	}
441		441
442	dev->dev.parent = &parent->dev;	442	dev->dev.parent = &parent->dev;
443	dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath);	443	dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath);
444		444
445	/* hub driver sets up TT records */	445	/* hub driver sets up TT records */
446	}	446	}
447		447
448	dev->portnum = port1;	448	dev->portnum = port1;
449	dev->bus = bus;	449	dev->bus = bus;
450	dev->parent = parent;	450	dev->parent = parent;
451	INIT_LIST_HEAD(&dev->filelist);	451	INIT_LIST_HEAD(&dev->filelist);
452		452
453	#ifdef CONFIG_PM	453	#ifdef CONFIG_PM
454	pm_runtime_set_autosuspend_delay(&dev->dev,	454	pm_runtime_set_autosuspend_delay(&dev->dev,
455	usb_autosuspend_delay * 1000);	455	usb_autosuspend_delay * 1000);
456	dev->connect_time = jiffies;	456	dev->connect_time = jiffies;
457	dev->active_duration = -jiffies;	457	dev->active_duration = -jiffies;
458	#endif	458	#endif
459	if (root_hub) /* Root hub always ok [and always wired] */	459	if (root_hub) /* Root hub always ok [and always wired] */
460	dev->authorized = 1;	460	dev->authorized = 1;
461	else {	461	else {
462	dev->authorized = usb_hcd->authorized_default;	462	dev->authorized = usb_hcd->authorized_default;
463	dev->wusb = usb_bus_is_wusb(bus)? 1 : 0;	463	dev->wusb = usb_bus_is_wusb(bus)? 1 : 0;
464	}	464	}
465	return dev;	465	return dev;
466	}	466	}
467		467
468	/**	468	/**
469	* usb_get_dev - increments the reference count of the usb device structure	469	* usb_get_dev - increments the reference count of the usb device structure
470	* @dev: the device being referenced	470	* @dev: the device being referenced
471	*	471	*
472	* Each live reference to a device should be refcounted.	472	* Each live reference to a device should be refcounted.
473	*	473	*
474	* Drivers for USB interfaces should normally record such references in	474	* Drivers for USB interfaces should normally record such references in
475	* their probe() methods, when they bind to an interface, and release	475	* their probe() methods, when they bind to an interface, and release
476	* them by calling usb_put_dev(), in their disconnect() methods.	476	* them by calling usb_put_dev(), in their disconnect() methods.
477	*	477	*
478	* A pointer to the device with the incremented reference counter is returned.	478	* A pointer to the device with the incremented reference counter is returned.
479	*/	479	*/
480	struct usb_device usb_get_dev(struct usb_device dev)	480	struct usb_device usb_get_dev(struct usb_device dev)
481	{	481	{
482	if (dev)	482	if (dev)
483	get_device(&dev->dev);	483	get_device(&dev->dev);
484	return dev;	484	return dev;
485	}	485	}
486	EXPORT_SYMBOL_GPL(usb_get_dev);	486	EXPORT_SYMBOL_GPL(usb_get_dev);
487		487
488	/**	488	/**
489	* usb_put_dev - release a use of the usb device structure	489	* usb_put_dev - release a use of the usb device structure
490	* @dev: device that's been disconnected	490	* @dev: device that's been disconnected
491	*	491	*
492	* Must be called when a user of a device is finished with it. When the last	492	* Must be called when a user of a device is finished with it. When the last
493	* user of the device calls this function, the memory of the device is freed.	493	* user of the device calls this function, the memory of the device is freed.
494	*/	494	*/
495	void usb_put_dev(struct usb_device *dev)	495	void usb_put_dev(struct usb_device *dev)
496	{	496	{
497	if (dev)	497	if (dev)
498	put_device(&dev->dev);	498	put_device(&dev->dev);
499	}	499	}
500	EXPORT_SYMBOL_GPL(usb_put_dev);	500	EXPORT_SYMBOL_GPL(usb_put_dev);
501		501
502	/**	502	/**
503	* usb_get_intf - increments the reference count of the usb interface structure	503	* usb_get_intf - increments the reference count of the usb interface structure
504	* @intf: the interface being referenced	504	* @intf: the interface being referenced
505	*	505	*
506	* Each live reference to a interface must be refcounted.	506	* Each live reference to a interface must be refcounted.
507	*	507	*
508	* Drivers for USB interfaces should normally record such references in	508	* Drivers for USB interfaces should normally record such references in
509	* their probe() methods, when they bind to an interface, and release	509	* their probe() methods, when they bind to an interface, and release
510	* them by calling usb_put_intf(), in their disconnect() methods.	510	* them by calling usb_put_intf(), in their disconnect() methods.
511	*	511	*
512	* A pointer to the interface with the incremented reference counter is	512	* A pointer to the interface with the incremented reference counter is
513	* returned.	513	* returned.
514	*/	514	*/
515	struct usb_interface usb_get_intf(struct usb_interface intf)	515	struct usb_interface usb_get_intf(struct usb_interface intf)
516	{	516	{
517	if (intf)	517	if (intf)
518	get_device(&intf->dev);	518	get_device(&intf->dev);
519	return intf;	519	return intf;
520	}	520	}
521	EXPORT_SYMBOL_GPL(usb_get_intf);	521	EXPORT_SYMBOL_GPL(usb_get_intf);
522		522
523	/**	523	/**
524	* usb_put_intf - release a use of the usb interface structure	524	* usb_put_intf - release a use of the usb interface structure
525	* @intf: interface that's been decremented	525	* @intf: interface that's been decremented
526	*	526	*
527	* Must be called when a user of an interface is finished with it. When the	527	* Must be called when a user of an interface is finished with it. When the
528	* last user of the interface calls this function, the memory of the interface	528	* last user of the interface calls this function, the memory of the interface
529	* is freed.	529	* is freed.
530	*/	530	*/
531	void usb_put_intf(struct usb_interface *intf)	531	void usb_put_intf(struct usb_interface *intf)
532	{	532	{
533	if (intf)	533	if (intf)
534	put_device(&intf->dev);	534	put_device(&intf->dev);
535	}	535	}
536	EXPORT_SYMBOL_GPL(usb_put_intf);	536	EXPORT_SYMBOL_GPL(usb_put_intf);
537		537
538	/* USB device locking	538	/* USB device locking
539	*	539	*
540	* USB devices and interfaces are locked using the semaphore in their	540	* USB devices and interfaces are locked using the semaphore in their
541	* embedded struct device. The hub driver guarantees that whenever a	541	* embedded struct device. The hub driver guarantees that whenever a
542	* device is connected or disconnected, drivers are called with the	542	* device is connected or disconnected, drivers are called with the
543	* USB device locked as well as their particular interface.	543	* USB device locked as well as their particular interface.
544	*	544	*
545	* Complications arise when several devices are to be locked at the same	545	* Complications arise when several devices are to be locked at the same
546	* time. Only hub-aware drivers that are part of usbcore ever have to	546	* time. Only hub-aware drivers that are part of usbcore ever have to
547	* do this; nobody else needs to worry about it. The rule for locking	547	* do this; nobody else needs to worry about it. The rule for locking
548	* is simple:	548	* is simple:
549	*	549	*
550	* When locking both a device and its parent, always lock the	550	* When locking both a device and its parent, always lock the
551	* the parent first.	551	* the parent first.
552	*/	552	*/
553		553
554	/**	554	/**
555	* usb_lock_device_for_reset - cautiously acquire the lock for a usb device structure	555	* usb_lock_device_for_reset - cautiously acquire the lock for a usb device structure
556	* @udev: device that's being locked	556	* @udev: device that's being locked
557	* @iface: interface bound to the driver making the request (optional)	557	* @iface: interface bound to the driver making the request (optional)
558	*	558	*
559	* Attempts to acquire the device lock, but fails if the device is	559	* Attempts to acquire the device lock, but fails if the device is
560	* NOTATTACHED or SUSPENDED, or if iface is specified and the interface	560	* NOTATTACHED or SUSPENDED, or if iface is specified and the interface
561	* is neither BINDING nor BOUND. Rather than sleeping to wait for the	561	* is neither BINDING nor BOUND. Rather than sleeping to wait for the
562	* lock, the routine polls repeatedly. This is to prevent deadlock with	562	* lock, the routine polls repeatedly. This is to prevent deadlock with
563	* disconnect; in some drivers (such as usb-storage) the disconnect()	563	* disconnect; in some drivers (such as usb-storage) the disconnect()
564	* or suspend() method will block waiting for a device reset to complete.	564	* or suspend() method will block waiting for a device reset to complete.
565	*	565	*
566	* Returns a negative error code for failure, otherwise 0.	566	* Returns a negative error code for failure, otherwise 0.
567	*/	567	*/
568	int usb_lock_device_for_reset(struct usb_device *udev,	568	int usb_lock_device_for_reset(struct usb_device *udev,
569	const struct usb_interface *iface)	569	const struct usb_interface *iface)
570	{	570	{
571	unsigned long jiffies_expire = jiffies + HZ;	571	unsigned long jiffies_expire = jiffies + HZ;
572		572
573	if (udev->state == USB_STATE_NOTATTACHED)	573	if (udev->state == USB_STATE_NOTATTACHED)
574	return -ENODEV;	574	return -ENODEV;
575	if (udev->state == USB_STATE_SUSPENDED)	575	if (udev->state == USB_STATE_SUSPENDED)
576	return -EHOSTUNREACH;	576	return -EHOSTUNREACH;
577	if (iface && (iface->condition == USB_INTERFACE_UNBINDING \|\|	577	if (iface && (iface->condition == USB_INTERFACE_UNBINDING \|\|
578	iface->condition == USB_INTERFACE_UNBOUND))	578	iface->condition == USB_INTERFACE_UNBOUND))
579	return -EINTR;	579	return -EINTR;
580		580
581	while (!usb_trylock_device(udev)) {	581	while (!usb_trylock_device(udev)) {
582		582
583	/* If we can't acquire the lock after waiting one second,	583	/* If we can't acquire the lock after waiting one second,
584	* we're probably deadlocked */	584	* we're probably deadlocked */
585	if (time_after(jiffies, jiffies_expire))	585	if (time_after(jiffies, jiffies_expire))
586	return -EBUSY;	586	return -EBUSY;
587		587
588	msleep(15);	588	msleep(15);
589	if (udev->state == USB_STATE_NOTATTACHED)	589	if (udev->state == USB_STATE_NOTATTACHED)
590	return -ENODEV;	590	return -ENODEV;
591	if (udev->state == USB_STATE_SUSPENDED)	591	if (udev->state == USB_STATE_SUSPENDED)
592	return -EHOSTUNREACH;	592	return -EHOSTUNREACH;
593	if (iface && (iface->condition == USB_INTERFACE_UNBINDING \|\|	593	if (iface && (iface->condition == USB_INTERFACE_UNBINDING \|\|
594	iface->condition == USB_INTERFACE_UNBOUND))	594	iface->condition == USB_INTERFACE_UNBOUND))
595	return -EINTR;	595	return -EINTR;
596	}	596	}
597	return 0;	597	return 0;
598	}	598	}
599	EXPORT_SYMBOL_GPL(usb_lock_device_for_reset);	599	EXPORT_SYMBOL_GPL(usb_lock_device_for_reset);
600		600
601	/**	601	/**
602	* usb_get_current_frame_number - return current bus frame number	602	* usb_get_current_frame_number - return current bus frame number
603	* @dev: the device whose bus is being queried	603	* @dev: the device whose bus is being queried
604	*	604	*
605	* Returns the current frame number for the USB host controller	605	* Returns the current frame number for the USB host controller
606	* used with the given USB device. This can be used when scheduling	606	* used with the given USB device. This can be used when scheduling
607	* isochronous requests.	607	* isochronous requests.
608	*	608	*
609	* Note that different kinds of host controller have different	609	* Note that different kinds of host controller have different
610	* "scheduling horizons". While one type might support scheduling only	610	* "scheduling horizons". While one type might support scheduling only
611	* 32 frames into the future, others could support scheduling up to	611	* 32 frames into the future, others could support scheduling up to
612	* 1024 frames into the future.	612	* 1024 frames into the future.
613	*/	613	*/
614	int usb_get_current_frame_number(struct usb_device *dev)	614	int usb_get_current_frame_number(struct usb_device *dev)
615	{	615	{
616	return usb_hcd_get_frame_number(dev);	616	return usb_hcd_get_frame_number(dev);
617	}	617	}
618	EXPORT_SYMBOL_GPL(usb_get_current_frame_number);	618	EXPORT_SYMBOL_GPL(usb_get_current_frame_number);
619		619
620	/-------------------------------------------------------------------/	620	/-------------------------------------------------------------------/
621	/*	621	/*
622	* __usb_get_extra_descriptor() finds a descriptor of specific type in the	622	* __usb_get_extra_descriptor() finds a descriptor of specific type in the
623	* extra field of the interface and endpoint descriptor structs.	623	* extra field of the interface and endpoint descriptor structs.
624	*/	624	*/
625		625
626	int __usb_get_extra_descriptor(char *buffer, unsigned size,	626	int __usb_get_extra_descriptor(char *buffer, unsigned size,
627	unsigned char type, void **ptr)	627	unsigned char type, void **ptr)
628	{	628	{
629	struct usb_descriptor_header *header;	629	struct usb_descriptor_header *header;
630		630
631	while (size >= sizeof(struct usb_descriptor_header)) {	631	while (size >= sizeof(struct usb_descriptor_header)) {
632	header = (struct usb_descriptor_header *)buffer;	632	header = (struct usb_descriptor_header *)buffer;
633		633
634	if (header->bLength < 2) {	634	if (header->bLength < 2) {
635	printk(KERN_ERR	635	printk(KERN_ERR
636	"%s: bogus descriptor, type %d length %d\n",	636	"%s: bogus descriptor, type %d length %d\n",
637	usbcore_name,	637	usbcore_name,
638	header->bDescriptorType,	638	header->bDescriptorType,
639	header->bLength);	639	header->bLength);
640	return -1;	640	return -1;
641	}	641	}
642		642
643	if (header->bDescriptorType == type) {	643	if (header->bDescriptorType == type) {
644	*ptr = header;	644	*ptr = header;
645	return 0;	645	return 0;
646	}	646	}
647		647
648	buffer += header->bLength;	648	buffer += header->bLength;
649	size -= header->bLength;	649	size -= header->bLength;
650	}	650	}
651	return -1;	651	return -1;
652	}	652	}
653	EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor);	653	EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor);
654		654
655	/**	655	/**
656	* usb_alloc_coherent - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP	656	* usb_alloc_coherent - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP
657	* @dev: device the buffer will be used with	657	* @dev: device the buffer will be used with
658	* @size: requested buffer size	658	* @size: requested buffer size
659	* @mem_flags: affect whether allocation may block	659	* @mem_flags: affect whether allocation may block
660	* @dma: used to return DMA address of buffer	660	* @dma: used to return DMA address of buffer
661	*	661	*
662	* Return value is either null (indicating no buffer could be allocated), or	662	* Return value is either null (indicating no buffer could be allocated), or
663	* the cpu-space pointer to a buffer that may be used to perform DMA to the	663	* the cpu-space pointer to a buffer that may be used to perform DMA to the
664	* specified device. Such cpu-space buffers are returned along with the DMA	664	* specified device. Such cpu-space buffers are returned along with the DMA
665	* address (through the pointer provided).	665	* address (through the pointer provided).
666	*	666	*
667	* These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags	667	* These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags
668	* to avoid behaviors like using "DMA bounce buffers", or thrashing IOMMU	668	* to avoid behaviors like using "DMA bounce buffers", or thrashing IOMMU
669	* hardware during URB completion/resubmit. The implementation varies between	669	* hardware during URB completion/resubmit. The implementation varies between
670	* platforms, depending on details of how DMA will work to this device.	670	* platforms, depending on details of how DMA will work to this device.
671	* Using these buffers also eliminates cacheline sharing problems on	671	* Using these buffers also eliminates cacheline sharing problems on
672	* architectures where CPU caches are not DMA-coherent. On systems without	672	* architectures where CPU caches are not DMA-coherent. On systems without
673	* bus-snooping caches, these buffers are uncached.	673	* bus-snooping caches, these buffers are uncached.
674	*	674	*
675	* When the buffer is no longer used, free it with usb_free_coherent().	675	* When the buffer is no longer used, free it with usb_free_coherent().
676	*/	676	*/
677	void usb_alloc_coherent(struct usb_device dev, size_t size, gfp_t mem_flags,	677	void usb_alloc_coherent(struct usb_device dev, size_t size, gfp_t mem_flags,
678	dma_addr_t *dma)	678	dma_addr_t *dma)
679	{	679	{
680	if (!dev \|\| !dev->bus)	680	if (!dev \|\| !dev->bus)
681	return NULL;	681	return NULL;
682	return hcd_buffer_alloc(dev->bus, size, mem_flags, dma);	682	return hcd_buffer_alloc(dev->bus, size, mem_flags, dma);
683	}	683	}
684	EXPORT_SYMBOL_GPL(usb_alloc_coherent);	684	EXPORT_SYMBOL_GPL(usb_alloc_coherent);
685		685
686	/**	686	/**
687	* usb_free_coherent - free memory allocated with usb_alloc_coherent()	687	* usb_free_coherent - free memory allocated with usb_alloc_coherent()
688	* @dev: device the buffer was used with	688	* @dev: device the buffer was used with
689	* @size: requested buffer size	689	* @size: requested buffer size
690	* @addr: CPU address of buffer	690	* @addr: CPU address of buffer
691	* @dma: DMA address of buffer	691	* @dma: DMA address of buffer
692	*	692	*
693	* This reclaims an I/O buffer, letting it be reused. The memory must have	693	* This reclaims an I/O buffer, letting it be reused. The memory must have
694	* been allocated using usb_alloc_coherent(), and the parameters must match	694	* been allocated using usb_alloc_coherent(), and the parameters must match
695	* those provided in that allocation request.	695	* those provided in that allocation request.
696	*/	696	*/
697	void usb_free_coherent(struct usb_device dev, size_t size, void addr,	697	void usb_free_coherent(struct usb_device dev, size_t size, void addr,
698	dma_addr_t dma)	698	dma_addr_t dma)
699	{	699	{
700	if (!dev \|\| !dev->bus)	700	if (!dev \|\| !dev->bus)
701	return;	701	return;
702	if (!addr)	702	if (!addr)
703	return;	703	return;
704	hcd_buffer_free(dev->bus, size, addr, dma);	704	hcd_buffer_free(dev->bus, size, addr, dma);
705	}	705	}
706	EXPORT_SYMBOL_GPL(usb_free_coherent);	706	EXPORT_SYMBOL_GPL(usb_free_coherent);
707		707
708	/**	708	/**
709	* usb_buffer_map - create DMA mapping(s) for an urb	709	* usb_buffer_map - create DMA mapping(s) for an urb
710	* @urb: urb whose transfer_buffer/setup_packet will be mapped	710	* @urb: urb whose transfer_buffer/setup_packet will be mapped
711	*	711	*
712	* Return value is either null (indicating no buffer could be mapped), or	712	* Return value is either null (indicating no buffer could be mapped), or
713	* the parameter. URB_NO_TRANSFER_DMA_MAP is	713	* the parameter. URB_NO_TRANSFER_DMA_MAP is
714	* added to urb->transfer_flags if the operation succeeds. If the device	714	* added to urb->transfer_flags if the operation succeeds. If the device
715	* is connected to this system through a non-DMA controller, this operation	715	* is connected to this system through a non-DMA controller, this operation
716	* always succeeds.	716	* always succeeds.
717	*	717	*
718	* This call would normally be used for an urb which is reused, perhaps	718	* This call would normally be used for an urb which is reused, perhaps
719	* as the target of a large periodic transfer, with usb_buffer_dmasync()	719	* as the target of a large periodic transfer, with usb_buffer_dmasync()
720	* calls to synchronize memory and dma state.	720	* calls to synchronize memory and dma state.
721	*	721	*
722	* Reverse the effect of this call with usb_buffer_unmap().	722	* Reverse the effect of this call with usb_buffer_unmap().
723	*/	723	*/
724	#if 0	724	#if 0
725	struct urb usb_buffer_map(struct urb urb)	725	struct urb usb_buffer_map(struct urb urb)
726	{	726	{
727	struct usb_bus *bus;	727	struct usb_bus *bus;
728	struct device *controller;	728	struct device *controller;
729		729
730	if (!urb	730	if (!urb
731	\|\| !urb->dev	731	\|\| !urb->dev
732	\|\| !(bus = urb->dev->bus)	732	\|\| !(bus = urb->dev->bus)
733	\|\| !(controller = bus->controller))	733	\|\| !(controller = bus->controller))
734	return NULL;	734	return NULL;
735		735
736	if (controller->dma_mask) {	736	if (controller->dma_mask) {
737	urb->transfer_dma = dma_map_single(controller,	737	urb->transfer_dma = dma_map_single(controller,
738	urb->transfer_buffer, urb->transfer_buffer_length,	738	urb->transfer_buffer, urb->transfer_buffer_length,
739	usb_pipein(urb->pipe)	739	usb_pipein(urb->pipe)
740	? DMA_FROM_DEVICE : DMA_TO_DEVICE);	740	? DMA_FROM_DEVICE : DMA_TO_DEVICE);
741	/* FIXME generic api broken like pci, can't report errors */	741	/* FIXME generic api broken like pci, can't report errors */
742	/* if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; */	742	/* if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; */
743	} else	743	} else
744	urb->transfer_dma = ~0;	744	urb->transfer_dma = ~0;
745	urb->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;	745	urb->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;
746	return urb;	746	return urb;
747	}	747	}
748	EXPORT_SYMBOL_GPL(usb_buffer_map);	748	EXPORT_SYMBOL_GPL(usb_buffer_map);
749	#endif /* 0 */	749	#endif /* 0 */
750		750
751	/* XXX DISABLED, no users currently. If you wish to re-enable this	751	/* XXX DISABLED, no users currently. If you wish to re-enable this
752	* XXX please determine whether the sync is to transfer ownership of	752	* XXX please determine whether the sync is to transfer ownership of
753	* XXX the buffer from device to cpu or vice verse, and thusly use the	753	* XXX the buffer from device to cpu or vice verse, and thusly use the
754	* XXX appropriate _for_{cpu,device}() method. -DaveM	754	* XXX appropriate _for_{cpu,device}() method. -DaveM
755	*/	755	*/
756	#if 0	756	#if 0
757		757
758	/**	758	/**
759	* usb_buffer_dmasync - synchronize DMA and CPU view of buffer(s)	759	* usb_buffer_dmasync - synchronize DMA and CPU view of buffer(s)
760	* @urb: urb whose transfer_buffer/setup_packet will be synchronized	760	* @urb: urb whose transfer_buffer/setup_packet will be synchronized
761	*/	761	*/
762	void usb_buffer_dmasync(struct urb *urb)	762	void usb_buffer_dmasync(struct urb *urb)
763	{	763	{
764	struct usb_bus *bus;	764	struct usb_bus *bus;
765	struct device *controller;	765	struct device *controller;
766		766
767	if (!urb	767	if (!urb
768	\|\| !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)	768	\|\| !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
769	\|\| !urb->dev	769	\|\| !urb->dev
770	\|\| !(bus = urb->dev->bus)	770	\|\| !(bus = urb->dev->bus)
771	\|\| !(controller = bus->controller))	771	\|\| !(controller = bus->controller))
772	return;	772	return;
773		773
774	if (controller->dma_mask) {	774	if (controller->dma_mask) {
775	dma_sync_single_for_cpu(controller,	775	dma_sync_single_for_cpu(controller,
776	urb->transfer_dma, urb->transfer_buffer_length,	776	urb->transfer_dma, urb->transfer_buffer_length,
777	usb_pipein(urb->pipe)	777	usb_pipein(urb->pipe)
778	? DMA_FROM_DEVICE : DMA_TO_DEVICE);	778	? DMA_FROM_DEVICE : DMA_TO_DEVICE);
779	if (usb_pipecontrol(urb->pipe))	779	if (usb_pipecontrol(urb->pipe))
780	dma_sync_single_for_cpu(controller,	780	dma_sync_single_for_cpu(controller,
781	urb->setup_dma,	781	urb->setup_dma,
782	sizeof(struct usb_ctrlrequest),	782	sizeof(struct usb_ctrlrequest),
783	DMA_TO_DEVICE);	783	DMA_TO_DEVICE);
784	}	784	}
785	}	785	}
786	EXPORT_SYMBOL_GPL(usb_buffer_dmasync);	786	EXPORT_SYMBOL_GPL(usb_buffer_dmasync);
787	#endif	787	#endif
788		788
789	/**	789	/**
790	* usb_buffer_unmap - free DMA mapping(s) for an urb	790	* usb_buffer_unmap - free DMA mapping(s) for an urb
791	* @urb: urb whose transfer_buffer will be unmapped	791	* @urb: urb whose transfer_buffer will be unmapped
792	*	792	*
793	* Reverses the effect of usb_buffer_map().	793	* Reverses the effect of usb_buffer_map().
794	*/	794	*/
795	#if 0	795	#if 0
796	void usb_buffer_unmap(struct urb *urb)	796	void usb_buffer_unmap(struct urb *urb)
797	{	797	{
798	struct usb_bus *bus;	798	struct usb_bus *bus;
799	struct device *controller;	799	struct device *controller;
800		800
801	if (!urb	801	if (!urb
802	\|\| !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)	802	\|\| !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
803	\|\| !urb->dev	803	\|\| !urb->dev
804	\|\| !(bus = urb->dev->bus)	804	\|\| !(bus = urb->dev->bus)
805	\|\| !(controller = bus->controller))	805	\|\| !(controller = bus->controller))
806	return;	806	return;
807		807
808	if (controller->dma_mask) {	808	if (controller->dma_mask) {
809	dma_unmap_single(controller,	809	dma_unmap_single(controller,
810	urb->transfer_dma, urb->transfer_buffer_length,	810	urb->transfer_dma, urb->transfer_buffer_length,
811	usb_pipein(urb->pipe)	811	usb_pipein(urb->pipe)
812	? DMA_FROM_DEVICE : DMA_TO_DEVICE);	812	? DMA_FROM_DEVICE : DMA_TO_DEVICE);
813	}	813	}
814	urb->transfer_flags &= ~URB_NO_TRANSFER_DMA_MAP;	814	urb->transfer_flags &= ~URB_NO_TRANSFER_DMA_MAP;
815	}	815	}
816	EXPORT_SYMBOL_GPL(usb_buffer_unmap);	816	EXPORT_SYMBOL_GPL(usb_buffer_unmap);
817	#endif /* 0 */	817	#endif /* 0 */
818		818
819	#if 0	819	#if 0
820	/**	820	/**
821	* usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint	821	* usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint
822	* @dev: device to which the scatterlist will be mapped	822	* @dev: device to which the scatterlist will be mapped
823	* @is_in: mapping transfer direction	823	* @is_in: mapping transfer direction
824	* @sg: the scatterlist to map	824	* @sg: the scatterlist to map
825	* @nents: the number of entries in the scatterlist	825	* @nents: the number of entries in the scatterlist
826	*	826	*
827	* Return value is either < 0 (indicating no buffers could be mapped), or	827	* Return value is either < 0 (indicating no buffers could be mapped), or
828	* the number of DMA mapping array entries in the scatterlist.	828	* the number of DMA mapping array entries in the scatterlist.
829	*	829	*
830	* The caller is responsible for placing the resulting DMA addresses from	830	* The caller is responsible for placing the resulting DMA addresses from
831	* the scatterlist into URB transfer buffer pointers, and for setting the	831	* the scatterlist into URB transfer buffer pointers, and for setting the
832	* URB_NO_TRANSFER_DMA_MAP transfer flag in each of those URBs.	832	* URB_NO_TRANSFER_DMA_MAP transfer flag in each of those URBs.
833	*	833	*
834	* Top I/O rates come from queuing URBs, instead of waiting for each one	834	* Top I/O rates come from queuing URBs, instead of waiting for each one
835	* to complete before starting the next I/O. This is particularly easy	835	* to complete before starting the next I/O. This is particularly easy
836	* to do with scatterlists. Just allocate and submit one URB for each DMA	836	* to do with scatterlists. Just allocate and submit one URB for each DMA
837	* mapping entry returned, stopping on the first error or when all succeed.	837	* mapping entry returned, stopping on the first error or when all succeed.
838	* Better yet, use the usb_sg_*() calls, which do that (and more) for you.	838	* Better yet, use the usb_sg_*() calls, which do that (and more) for you.
839	*	839	*
840	* This call would normally be used when translating scatterlist requests,	840	* This call would normally be used when translating scatterlist requests,
841	* rather than usb_buffer_map(), since on some hardware (with IOMMUs) it	841	* rather than usb_buffer_map(), since on some hardware (with IOMMUs) it
842	* may be able to coalesce mappings for improved I/O efficiency.	842	* may be able to coalesce mappings for improved I/O efficiency.
843	*	843	*
844	* Reverse the effect of this call with usb_buffer_unmap_sg().	844	* Reverse the effect of this call with usb_buffer_unmap_sg().
845	*/	845	*/
846	int usb_buffer_map_sg(const struct usb_device *dev, int is_in,	846	int usb_buffer_map_sg(const struct usb_device *dev, int is_in,
847	struct scatterlist *sg, int nents)	847	struct scatterlist *sg, int nents)
848	{	848	{
849	struct usb_bus *bus;	849	struct usb_bus *bus;
850	struct device *controller;	850	struct device *controller;
851		851
852	if (!dev	852	if (!dev
853	\|\| !(bus = dev->bus)	853	\|\| !(bus = dev->bus)
854	\|\| !(controller = bus->controller)	854	\|\| !(controller = bus->controller)
855	\|\| !controller->dma_mask)	855	\|\| !controller->dma_mask)
856	return -EINVAL;	856	return -EINVAL;
857		857
858	/* FIXME generic api broken like pci, can't report errors */	858	/* FIXME generic api broken like pci, can't report errors */
859	return dma_map_sg(controller, sg, nents,	859	return dma_map_sg(controller, sg, nents,
860	is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE) ? : -ENOMEM;	860	is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE) ? : -ENOMEM;
861	}	861	}
862	EXPORT_SYMBOL_GPL(usb_buffer_map_sg);	862	EXPORT_SYMBOL_GPL(usb_buffer_map_sg);
863	#endif	863	#endif
864		864
865	/* XXX DISABLED, no users currently. If you wish to re-enable this	865	/* XXX DISABLED, no users currently. If you wish to re-enable this
866	* XXX please determine whether the sync is to transfer ownership of	866	* XXX please determine whether the sync is to transfer ownership of
867	* XXX the buffer from device to cpu or vice verse, and thusly use the	867	* XXX the buffer from device to cpu or vice verse, and thusly use the
868	* XXX appropriate _for_{cpu,device}() method. -DaveM	868	* XXX appropriate _for_{cpu,device}() method. -DaveM
869	*/	869	*/
870	#if 0	870	#if 0
871		871
872	/**	872	/**
873	* usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s)	873	* usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s)
874	* @dev: device to which the scatterlist will be mapped	874	* @dev: device to which the scatterlist will be mapped
875	* @is_in: mapping transfer direction	875	* @is_in: mapping transfer direction
876	* @sg: the scatterlist to synchronize	876	* @sg: the scatterlist to synchronize
877	* @n_hw_ents: the positive return value from usb_buffer_map_sg	877	* @n_hw_ents: the positive return value from usb_buffer_map_sg
878	*	878	*
879	* Use this when you are re-using a scatterlist's data buffers for	879	* Use this when you are re-using a scatterlist's data buffers for
880	* another USB request.	880	* another USB request.
881	*/	881	*/
882	void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in,	882	void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in,
883	struct scatterlist *sg, int n_hw_ents)	883	struct scatterlist *sg, int n_hw_ents)
884	{	884	{
885	struct usb_bus *bus;	885	struct usb_bus *bus;
886	struct device *controller;	886	struct device *controller;
887		887
888	if (!dev	888	if (!dev
889	\|\| !(bus = dev->bus)	889	\|\| !(bus = dev->bus)
890	\|\| !(controller = bus->controller)	890	\|\| !(controller = bus->controller)
891	\|\| !controller->dma_mask)	891	\|\| !controller->dma_mask)
892	return;	892	return;
893		893
894	dma_sync_sg_for_cpu(controller, sg, n_hw_ents,	894	dma_sync_sg_for_cpu(controller, sg, n_hw_ents,
895	is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);	895	is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
896	}	896	}
897	EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg);	897	EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg);
898	#endif	898	#endif
899		899
900	#if 0	900	#if 0
901	/**	901	/**
902	* usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist	902	* usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist
903	* @dev: device to which the scatterlist will be mapped	903	* @dev: device to which the scatterlist will be mapped
904	* @is_in: mapping transfer direction	904	* @is_in: mapping transfer direction
905	* @sg: the scatterlist to unmap	905	* @sg: the scatterlist to unmap
906	* @n_hw_ents: the positive return value from usb_buffer_map_sg	906	* @n_hw_ents: the positive return value from usb_buffer_map_sg
907	*	907	*
908	* Reverses the effect of usb_buffer_map_sg().	908	* Reverses the effect of usb_buffer_map_sg().
909	*/	909	*/
910	void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,	910	void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,
911	struct scatterlist *sg, int n_hw_ents)	911	struct scatterlist *sg, int n_hw_ents)
912	{	912	{
913	struct usb_bus *bus;	913	struct usb_bus *bus;
914	struct device *controller;	914	struct device *controller;
915		915
916	if (!dev	916	if (!dev
917	\|\| !(bus = dev->bus)	917	\|\| !(bus = dev->bus)
918	\|\| !(controller = bus->controller)	918	\|\| !(controller = bus->controller)
919	\|\| !controller->dma_mask)	919	\|\| !controller->dma_mask)
920	return;	920	return;
921		921
922	dma_unmap_sg(controller, sg, n_hw_ents,	922	dma_unmap_sg(controller, sg, n_hw_ents,
923	is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);	923	is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
924	}	924	}
925	EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg);	925	EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg);
926	#endif	926	#endif
927		927
928	/* To disable USB, kernel command line is 'nousb' not 'usbcore.nousb' */	928	/* To disable USB, kernel command line is 'nousb' not 'usbcore.nousb' */
929	#ifdef MODULE	929	#ifdef MODULE
930	module_param(nousb, bool, 0444);	930	module_param(nousb, bool, 0444);
931	#else	931	#else
932	core_param(nousb, nousb, bool, 0444);	932	core_param(nousb, nousb, bool, 0444);
933	#endif	933	#endif
934		934
935	/*	935	/*
936	* for external read access to <nousb>	936	* for external read access to <nousb>
937	*/	937	*/
938	int usb_disabled(void)	938	int usb_disabled(void)
939	{	939	{
940	return nousb;	940	return nousb;
941	}	941	}
942	EXPORT_SYMBOL_GPL(usb_disabled);	942	EXPORT_SYMBOL_GPL(usb_disabled);
943		943
944	/*	944	/*
945	* Notifications of device and interface registration	945	* Notifications of device and interface registration
946	*/	946	*/
947	static int usb_bus_notify(struct notifier_block *nb, unsigned long action,	947	static int usb_bus_notify(struct notifier_block *nb, unsigned long action,
948	void *data)	948	void *data)
949	{	949	{
950	struct device *dev = data;	950	struct device *dev = data;
951		951
952	switch (action) {	952	switch (action) {
953	case BUS_NOTIFY_ADD_DEVICE:	953	case BUS_NOTIFY_ADD_DEVICE:
954	if (dev->type == &usb_device_type)	954	if (dev->type == &usb_device_type)
955	(void) usb_create_sysfs_dev_files(to_usb_device(dev));	955	(void) usb_create_sysfs_dev_files(to_usb_device(dev));
956	else if (dev->type == &usb_if_device_type)	956	else if (dev->type == &usb_if_device_type)
957	usb_create_sysfs_intf_files(to_usb_interface(dev));	957	usb_create_sysfs_intf_files(to_usb_interface(dev));
958	break;	958	break;
959		959
960	case BUS_NOTIFY_DEL_DEVICE:	960	case BUS_NOTIFY_DEL_DEVICE:
961	if (dev->type == &usb_device_type)	961	if (dev->type == &usb_device_type)
962	usb_remove_sysfs_dev_files(to_usb_device(dev));	962	usb_remove_sysfs_dev_files(to_usb_device(dev));
963	else if (dev->type == &usb_if_device_type)	963	else if (dev->type == &usb_if_device_type)
964	usb_remove_sysfs_intf_files(to_usb_interface(dev));	964	usb_remove_sysfs_intf_files(to_usb_interface(dev));
965	break;	965	break;
966	}	966	}
967	return 0;	967	return 0;
968	}	968	}
969		969
970	static struct notifier_block usb_bus_nb = {	970	static struct notifier_block usb_bus_nb = {
971	.notifier_call = usb_bus_notify,	971	.notifier_call = usb_bus_notify,
972	};	972	};
973		973
974	struct dentry *usb_debug_root;	974	struct dentry *usb_debug_root;
975	EXPORT_SYMBOL_GPL(usb_debug_root);	975	EXPORT_SYMBOL_GPL(usb_debug_root);
976		976
977	static struct dentry *usb_debug_devices;	977	static struct dentry *usb_debug_devices;
978		978
979	static int usb_debugfs_init(void)	979	static int usb_debugfs_init(void)
980	{	980	{
981	usb_debug_root = debugfs_create_dir("usb", NULL);	981	usb_debug_root = debugfs_create_dir("usb", NULL);
982	if (!usb_debug_root)	982	if (!usb_debug_root)
983	return -ENOENT;	983	return -ENOENT;
984		984
985	usb_debug_devices = debugfs_create_file("devices", 0444,	985	usb_debug_devices = debugfs_create_file("devices", 0444,
986	usb_debug_root, NULL,	986	usb_debug_root, NULL,
987	&usbfs_devices_fops);	987	&usbfs_devices_fops);
988	if (!usb_debug_devices) {	988	if (!usb_debug_devices) {
989	debugfs_remove(usb_debug_root);	989	debugfs_remove(usb_debug_root);
990	usb_debug_root = NULL;	990	usb_debug_root = NULL;
991	return -ENOENT;	991	return -ENOENT;
992	}	992	}
993		993
994	return 0;	994	return 0;
995	}	995	}
996		996
997	static void usb_debugfs_cleanup(void)	997	static void usb_debugfs_cleanup(void)
998	{	998	{
999	debugfs_remove(usb_debug_devices);	999	debugfs_remove(usb_debug_devices);
1000	debugfs_remove(usb_debug_root);	1000	debugfs_remove(usb_debug_root);
1001	}	1001	}
1002		1002
1003	/*	1003	/*
1004	* Init	1004	* Init
1005	*/	1005	*/
1006	static int __init usb_init(void)	1006	static int __init usb_init(void)
1007	{	1007	{
1008	int retval;	1008	int retval;
1009	if (nousb) {	1009	if (nousb) {
1010	pr_info("%s: USB support disabled\n", usbcore_name);	1010	pr_info("%s: USB support disabled\n", usbcore_name);
1011	return 0;	1011	return 0;
1012	}	1012	}
1013		1013
1014	retval = usb_debugfs_init();	1014	retval = usb_debugfs_init();
1015	if (retval)	1015	if (retval)
1016	goto out;	1016	goto out;
1017		1017
1018	retval = bus_register(&usb_bus_type);	1018	retval = bus_register(&usb_bus_type);
1019	if (retval)	1019	if (retval)
1020	goto bus_register_failed;	1020	goto bus_register_failed;
1021	retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb);	1021	retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb);
1022	if (retval)	1022	if (retval)
1023	goto bus_notifier_failed;	1023	goto bus_notifier_failed;
1024	retval = usb_major_init();	1024	retval = usb_major_init();
1025	if (retval)	1025	if (retval)
1026	goto major_init_failed;	1026	goto major_init_failed;
1027	retval = usb_register(&usbfs_driver);	1027	retval = usb_register(&usbfs_driver);
1028	if (retval)	1028	if (retval)
1029	goto driver_register_failed;	1029	goto driver_register_failed;
1030	retval = usb_devio_init();	1030	retval = usb_devio_init();
1031	if (retval)	1031	if (retval)
1032	goto usb_devio_init_failed;	1032	goto usb_devio_init_failed;
1033	retval = usbfs_init();	1033	retval = usbfs_init();
1034	if (retval)	1034	if (retval)
1035	goto fs_init_failed;	1035	goto fs_init_failed;
1036	retval = usb_hub_init();	1036	retval = usb_hub_init();
1037	if (retval)	1037	if (retval)
1038	goto hub_init_failed;	1038	goto hub_init_failed;
1039	retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);	1039	retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);
1040	if (!retval)	1040	if (!retval)
1041	goto out;	1041	goto out;
1042		1042
1043	usb_hub_cleanup();	1043	usb_hub_cleanup();
1044	hub_init_failed:	1044	hub_init_failed:
1045	usbfs_cleanup();	1045	usbfs_cleanup();
1046	fs_init_failed:	1046	fs_init_failed:
1047	usb_devio_cleanup();	1047	usb_devio_cleanup();
1048	usb_devio_init_failed:	1048	usb_devio_init_failed:
1049	usb_deregister(&usbfs_driver);	1049	usb_deregister(&usbfs_driver);
1050	driver_register_failed:	1050	driver_register_failed:
1051	usb_major_cleanup();	1051	usb_major_cleanup();
1052	major_init_failed:	1052	major_init_failed:
1053	bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);	1053	bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
1054	bus_notifier_failed:	1054	bus_notifier_failed:
1055	bus_unregister(&usb_bus_type);	1055	bus_unregister(&usb_bus_type);
1056	bus_register_failed:	1056	bus_register_failed:
1057	usb_debugfs_cleanup();	1057	usb_debugfs_cleanup();
1058	out:	1058	out:
1059	return retval;	1059	return retval;
1060	}	1060	}
1061		1061
1062	/*	1062	/*
1063	* Cleanup	1063	* Cleanup
1064	*/	1064	*/
1065	static void __exit usb_exit(void)	1065	static void __exit usb_exit(void)
1066	{	1066	{
1067	/* This will matter if shutdown/reboot does exitcalls. */	1067	/* This will matter if shutdown/reboot does exitcalls. */
1068	if (nousb)	1068	if (nousb)
1069	return;	1069	return;
1070		1070
1071	usb_deregister_device_driver(&usb_generic_driver);	1071	usb_deregister_device_driver(&usb_generic_driver);
1072	usb_major_cleanup();	1072	usb_major_cleanup();
1073	usbfs_cleanup();	1073	usbfs_cleanup();
1074	usb_deregister(&usbfs_driver);	1074	usb_deregister(&usbfs_driver);
1075	usb_devio_cleanup();	1075	usb_devio_cleanup();
1076	usb_hub_cleanup();	1076	usb_hub_cleanup();
1077	bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);	1077	bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
1078	bus_unregister(&usb_bus_type);	1078	bus_unregister(&usb_bus_type);
1079	usb_debugfs_cleanup();	1079	usb_debugfs_cleanup();
1080	}	1080	}
1081		1081
1082	subsys_initcall(usb_init);	1082	subsys_initcall(usb_init);
1083	module_exit(usb_exit);	1083	module_exit(usb_exit);
1084	MODULE_LICENSE("GPL");	1084	MODULE_LICENSE("GPL");
1085		1085

drivers/usb/core/usb.h

Diff comments View file @ 98d9a82

 #include <linux/pm.h>
 /* Functions local to drivers/usb/core/ */
 extern int usb_create_sysfs_dev_files(struct usb_device *dev);
 extern void usb_remove_sysfs_dev_files(struct usb_device *dev);
 extern void usb_create_sysfs_intf_files(struct usb_interface *intf);
 extern void usb_remove_sysfs_intf_files(struct usb_interface *intf);
 extern int usb_create_ep_devs(struct device *parent,
 				struct usb_host_endpoint *endpoint,
 				struct usb_device *udev);
 extern void usb_remove_ep_devs(struct usb_host_endpoint *endpoint);
 extern void usb_enable_endpoint(struct usb_device *dev,
 		struct usb_host_endpoint *ep, bool reset_toggle);
 extern void usb_enable_interface(struct usb_device *dev,
 		struct usb_interface *intf, bool reset_toggles);
 extern void usb_disable_endpoint(struct usb_device *dev, unsigned int epaddr,
 		bool reset_hardware);
 extern void usb_disable_interface(struct usb_device *dev,
 		struct usb_interface *intf, bool reset_hardware);
 extern void usb_release_interface_cache(struct kref *ref);
 extern void usb_disable_device(struct usb_device *dev, int skip_ep0);
 extern int usb_deauthorize_device(struct usb_device *);
 extern int usb_authorize_device(struct usb_device *);
 extern void usb_detect_quirks(struct usb_device *udev);
 extern int usb_remove_device(struct usb_device *udev);
 extern int usb_get_device_descriptor(struct usb_device *dev,
 		unsigned int size);
 extern int usb_get_bos_descriptor(struct usb_device *dev);
 extern void usb_release_bos_descriptor(struct usb_device *dev);
 extern char *usb_cache_string(struct usb_device *udev, int index);
 extern int usb_set_configuration(struct usb_device *dev, int configuration);
 extern int usb_choose_configuration(struct usb_device *udev);
 extern void usb_kick_khubd(struct usb_device *dev);
 extern int usb_match_device(struct usb_device *dev,
 			    const struct usb_device_id *id);
 extern void usb_forced_unbind_intf(struct usb_interface *intf);
 extern void usb_rebind_intf(struct usb_interface *intf);
 extern int usb_hub_claim_port(struct usb_device *hdev, unsigned port,
 		void *owner);
 extern int usb_hub_release_port(struct usb_device *hdev, unsigned port,
 		void *owner);
 extern void usb_hub_release_all_ports(struct usb_device *hdev, void *owner);
 extern bool usb_device_is_owned(struct usb_device *udev);
 extern int  usb_hub_init(void);
 extern void usb_hub_cleanup(void);
 extern int usb_major_init(void);
 extern void usb_major_cleanup(void);
 #ifdef	CONFIG_PM
 extern int usb_suspend(struct device *dev, pm_message_t msg);
 extern int usb_resume(struct device *dev, pm_message_t msg);
+extern int usb_resume_complete(struct device *dev);
 extern int usb_port_suspend(struct usb_device *dev, pm_message_t msg);
 extern int usb_port_resume(struct usb_device *dev, pm_message_t msg);
 #else
 static inline int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
 {
 	return 0;
 }
 static inline int usb_port_resume(struct usb_device *udev, pm_message_t msg)
 {
 	return 0;
 }
 #endif
 #ifdef CONFIG_USB_SUSPEND
 extern void usb_autosuspend_device(struct usb_device *udev);
 extern int usb_autoresume_device(struct usb_device *udev);
 extern int usb_remote_wakeup(struct usb_device *dev);
 extern int usb_runtime_suspend(struct device *dev);
 extern int usb_runtime_resume(struct device *dev);
 extern int usb_runtime_idle(struct device *dev);
 extern int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable);
 #else
 #define usb_autosuspend_device(udev)		do {} while (0)
 static inline int usb_autoresume_device(struct usb_device *udev)
 {
 	return 0;
 }
 static inline int usb_remote_wakeup(struct usb_device *udev)
 {
 	return 0;
 }
 static inline int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable)
 {
 	return 0;
 }
 #endif
 extern struct bus_type usb_bus_type;
 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 usb_device_driver usb_generic_driver;
 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;
 }
 /* Do the same for device drivers and interface drivers. */
 static inline int is_usb_device_driver(struct device_driver *drv)
 {
 	return container_of(drv, struct usbdrv_wrap, driver)->
 			for_devices;
 }
 /* for labeling diagnostics */
 extern const char *usbcore_name;
 /* sysfs stuff */
 extern const struct attribute_group *usb_device_groups[];
 extern const struct attribute_group *usb_interface_groups[];
 /* usbfs stuff */
 extern struct mutex usbfs_mutex;
 extern struct usb_driver usbfs_driver;
 extern const struct file_operations usbfs_devices_fops;
 extern const struct file_operations usbdev_file_operations;
 extern void usbfs_conn_disc_event(void);
 extern int usb_devio_init(void);
 extern void usb_devio_cleanup(void);
 /* internal notify stuff */
 extern void usb_notify_add_device(struct usb_device *udev);
 extern void usb_notify_remove_device(struct usb_device *udev);
 extern void usb_notify_add_bus(struct usb_bus *ubus);
 extern void usb_notify_remove_bus(struct usb_bus *ubus);