1/*
   2 * drivers/usb/driver.c - most of the driver model stuff for usb
   3 *
   4 * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de>
   5 *
   6 * based on drivers/usb/usb.c which had the following copyrights:
   7 *	(C) Copyright Linus Torvalds 1999
   8 *	(C) Copyright Johannes Erdfelt 1999-2001
   9 *	(C) Copyright Andreas Gal 1999
  10 *	(C) Copyright Gregory P. Smith 1999
  11 *	(C) Copyright Deti Fliegl 1999 (new USB architecture)
  12 *	(C) Copyright Randy Dunlap 2000
  13 *	(C) Copyright David Brownell 2000-2004
  14 *	(C) Copyright Yggdrasil Computing, Inc. 2000
  15 *		(usb_device_id matching changes by Adam J. Richter)
  16 *	(C) Copyright Greg Kroah-Hartman 2002-2003
  17 *
  18 * NOTE! This is not actually a driver at all, rather this is
  19 * just a collection of helper routines that implement the
  20 * matching, probing, releasing, suspending and resuming for
  21 * real drivers.
  22 *
  23 */
  24
  25#include <linux/device.h>
  26#include <linux/slab.h>
 
  27#include <linux/usb.h>
  28#include <linux/usb/quirks.h>
  29#include <linux/usb/hcd.h>
  30
  31#include "usb.h"
  32
  33
  34#ifdef CONFIG_HOTPLUG
  35
  36/*
  37 * Adds a new dynamic USBdevice ID to this driver,
  38 * and cause the driver to probe for all devices again.
  39 */
  40ssize_t usb_store_new_id(struct usb_dynids *dynids,
  41			 struct device_driver *driver,
  42			 const char *buf, size_t count)
  43{
  44	struct usb_dynid *dynid;
  45	u32 idVendor = 0;
  46	u32 idProduct = 0;
 
  47	int fields = 0;
  48	int retval = 0;
  49
  50	fields = sscanf(buf, "%x %x", &idVendor, &idProduct);
 
  51	if (fields < 2)
  52		return -EINVAL;
  53
  54	dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
  55	if (!dynid)
  56		return -ENOMEM;
  57
  58	INIT_LIST_HEAD(&dynid->node);
  59	dynid->id.idVendor = idVendor;
  60	dynid->id.idProduct = idProduct;
  61	dynid->id.match_flags = USB_DEVICE_ID_MATCH_DEVICE;
 
 
 
 
  62
  63	spin_lock(&dynids->lock);
  64	list_add_tail(&dynid->node, &dynids->list);
  65	spin_unlock(&dynids->lock);
  66
  67	if (get_driver(driver)) {
  68		retval = driver_attach(driver);
  69		put_driver(driver);
  70	}
  71
  72	if (retval)
  73		return retval;
  74	return count;
  75}
  76EXPORT_SYMBOL_GPL(usb_store_new_id);
  77
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  78static ssize_t store_new_id(struct device_driver *driver,
  79			    const char *buf, size_t count)
  80{
  81	struct usb_driver *usb_drv = to_usb_driver(driver);
  82
  83	return usb_store_new_id(&usb_drv->dynids, driver, buf, count);
  84}
  85static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
  86
  87/**
  88 * store_remove_id - remove a USB device ID from this driver
  89 * @driver: target device driver
  90 * @buf: buffer for scanning device ID data
  91 * @count: input size
  92 *
  93 * Removes a dynamic usb device ID from this driver.
  94 */
  95static ssize_t
  96store_remove_id(struct device_driver *driver, const char *buf, size_t count)
  97{
  98	struct usb_dynid *dynid, *n;
  99	struct usb_driver *usb_driver = to_usb_driver(driver);
 100	u32 idVendor = 0;
 101	u32 idProduct = 0;
 102	int fields = 0;
 103	int retval = 0;
 104
 105	fields = sscanf(buf, "%x %x", &idVendor, &idProduct);
 106	if (fields < 2)
 107		return -EINVAL;
 108
 109	spin_lock(&usb_driver->dynids.lock);
 110	list_for_each_entry_safe(dynid, n, &usb_driver->dynids.list, node) {
 111		struct usb_device_id *id = &dynid->id;
 112		if ((id->idVendor == idVendor) &&
 113		    (id->idProduct == idProduct)) {
 114			list_del(&dynid->node);
 115			kfree(dynid);
 116			retval = 0;
 117			break;
 118		}
 119	}
 120	spin_unlock(&usb_driver->dynids.lock);
 121
 122	if (retval)
 123		return retval;
 124	return count;
 125}
 126static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
 127
 128static int usb_create_newid_file(struct usb_driver *usb_drv)
 129{
 130	int error = 0;
 131
 132	if (usb_drv->no_dynamic_id)
 133		goto exit;
 134
 135	if (usb_drv->probe != NULL)
 136		error = driver_create_file(&usb_drv->drvwrap.driver,
 137					   &driver_attr_new_id);
 
 
 
 
 
 
 
 
 138exit:
 139	return error;
 140}
 141
 142static void usb_remove_newid_file(struct usb_driver *usb_drv)
 143{
 144	if (usb_drv->no_dynamic_id)
 145		return;
 146
 147	if (usb_drv->probe != NULL)
 148		driver_remove_file(&usb_drv->drvwrap.driver,
 149				   &driver_attr_new_id);
 150}
 151
 152static int
 153usb_create_removeid_file(struct usb_driver *drv)
 154{
 155	int error = 0;
 156	if (drv->probe != NULL)
 157		error = driver_create_file(&drv->drvwrap.driver,
 158				&driver_attr_remove_id);
 159	return error;
 160}
 161
 162static void usb_remove_removeid_file(struct usb_driver *drv)
 163{
 164	driver_remove_file(&drv->drvwrap.driver, &driver_attr_remove_id);
 165}
 166
 167static void usb_free_dynids(struct usb_driver *usb_drv)
 168{
 169	struct usb_dynid *dynid, *n;
 170
 171	spin_lock(&usb_drv->dynids.lock);
 172	list_for_each_entry_safe(dynid, n, &usb_drv->dynids.list, node) {
 173		list_del(&dynid->node);
 174		kfree(dynid);
 175	}
 176	spin_unlock(&usb_drv->dynids.lock);
 177}
 178#else
 179static inline int usb_create_newid_file(struct usb_driver *usb_drv)
 180{
 181	return 0;
 182}
 183
 184static void usb_remove_newid_file(struct usb_driver *usb_drv)
 185{
 186}
 187
 188static int
 189usb_create_removeid_file(struct usb_driver *drv)
 190{
 191	return 0;
 192}
 193
 194static void usb_remove_removeid_file(struct usb_driver *drv)
 195{
 196}
 197
 198static inline void usb_free_dynids(struct usb_driver *usb_drv)
 199{
 200}
 201#endif
 202
 203static const struct usb_device_id *usb_match_dynamic_id(struct usb_interface *intf,
 204							struct usb_driver *drv)
 205{
 206	struct usb_dynid *dynid;
 207
 208	spin_lock(&drv->dynids.lock);
 209	list_for_each_entry(dynid, &drv->dynids.list, node) {
 210		if (usb_match_one_id(intf, &dynid->id)) {
 211			spin_unlock(&drv->dynids.lock);
 212			return &dynid->id;
 213		}
 214	}
 215	spin_unlock(&drv->dynids.lock);
 216	return NULL;
 217}
 218
 219
 220/* called from driver core with dev locked */
 221static int usb_probe_device(struct device *dev)
 222{
 223	struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
 224	struct usb_device *udev = to_usb_device(dev);
 225	int error = 0;
 226
 227	dev_dbg(dev, "%s\n", __func__);
 228
 229	/* TODO: Add real matching code */
 230
 231	/* The device should always appear to be in use
 232	 * unless the driver suports autosuspend.
 233	 */
 234	if (!udriver->supports_autosuspend)
 235		error = usb_autoresume_device(udev);
 236
 237	if (!error)
 238		error = udriver->probe(udev);
 239	return error;
 240}
 241
 242/* called from driver core with dev locked */
 243static int usb_unbind_device(struct device *dev)
 244{
 245	struct usb_device *udev = to_usb_device(dev);
 246	struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
 247
 248	udriver->disconnect(udev);
 249	if (!udriver->supports_autosuspend)
 250		usb_autosuspend_device(udev);
 251	return 0;
 252}
 253
 254/*
 255 * Cancel any pending scheduled resets
 256 *
 257 * [see usb_queue_reset_device()]
 258 *
 259 * Called after unconfiguring / when releasing interfaces. See
 260 * comments in __usb_queue_reset_device() regarding
 261 * udev->reset_running.
 262 */
 263static void usb_cancel_queued_reset(struct usb_interface *iface)
 264{
 265	if (iface->reset_running == 0)
 266		cancel_work_sync(&iface->reset_ws);
 267}
 268
 269/* called from driver core with dev locked */
 270static int usb_probe_interface(struct device *dev)
 271{
 272	struct usb_driver *driver = to_usb_driver(dev->driver);
 273	struct usb_interface *intf = to_usb_interface(dev);
 274	struct usb_device *udev = interface_to_usbdev(intf);
 275	const struct usb_device_id *id;
 276	int error = -ENODEV;
 
 277
 278	dev_dbg(dev, "%s\n", __func__);
 279
 280	intf->needs_binding = 0;
 281
 282	if (usb_device_is_owned(udev))
 283		return error;
 284
 285	if (udev->authorized == 0) {
 286		dev_err(&intf->dev, "Device is not authorized for usage\n");
 287		return error;
 288	}
 289
 290	id = usb_match_id(intf, driver->id_table);
 291	if (!id)
 292		id = usb_match_dynamic_id(intf, driver);
 293	if (!id)
 294		return error;
 295
 296	dev_dbg(dev, "%s - got id\n", __func__);
 297
 298	error = usb_autoresume_device(udev);
 299	if (error)
 300		return error;
 301
 302	intf->condition = USB_INTERFACE_BINDING;
 303
 304	/* Probed interfaces are initially active.  They are
 305	 * runtime-PM-enabled only if the driver has autosuspend support.
 306	 * They are sensitive to their children's power states.
 307	 */
 308	pm_runtime_set_active(dev);
 309	pm_suspend_ignore_children(dev, false);
 310	if (driver->supports_autosuspend)
 311		pm_runtime_enable(dev);
 312
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 313	/* Carry out a deferred switch to altsetting 0 */
 314	if (intf->needs_altsetting0) {
 315		error = usb_set_interface(udev, intf->altsetting[0].
 316				desc.bInterfaceNumber, 0);
 317		if (error < 0)
 318			goto err;
 319		intf->needs_altsetting0 = 0;
 320	}
 321
 322	error = driver->probe(intf, id);
 323	if (error)
 324		goto err;
 325
 326	intf->condition = USB_INTERFACE_BOUND;
 
 
 
 
 
 327	usb_autosuspend_device(udev);
 328	return error;
 329
 330 err:
 331	intf->needs_remote_wakeup = 0;
 332	intf->condition = USB_INTERFACE_UNBOUND;
 333	usb_cancel_queued_reset(intf);
 334
 335	/* Unbound interfaces are always runtime-PM-disabled and -suspended */
 336	if (driver->supports_autosuspend)
 337		pm_runtime_disable(dev);
 338	pm_runtime_set_suspended(dev);
 339
 340	usb_autosuspend_device(udev);
 341	return error;
 342}
 343
 344/* called from driver core with dev locked */
 345static int usb_unbind_interface(struct device *dev)
 346{
 347	struct usb_driver *driver = to_usb_driver(dev->driver);
 348	struct usb_interface *intf = to_usb_interface(dev);
 349	struct usb_device *udev;
 350	int error, r;
 351
 352	intf->condition = USB_INTERFACE_UNBINDING;
 353
 354	/* Autoresume for set_interface call below */
 355	udev = interface_to_usbdev(intf);
 356	error = usb_autoresume_device(udev);
 357
 
 
 
 
 
 
 
 358	/* Terminate all URBs for this interface unless the driver
 359	 * supports "soft" unbinding.
 360	 */
 361	if (!driver->soft_unbind)
 362		usb_disable_interface(udev, intf, false);
 363
 364	driver->disconnect(intf);
 365	usb_cancel_queued_reset(intf);
 366
 367	/* Reset other interface state.
 368	 * We cannot do a Set-Interface if the device is suspended or
 369	 * if it is prepared for a system sleep (since installing a new
 370	 * altsetting means creating new endpoint device entries).
 371	 * When either of these happens, defer the Set-Interface.
 372	 */
 373	if (intf->cur_altsetting->desc.bAlternateSetting == 0) {
 374		/* Already in altsetting 0 so skip Set-Interface.
 375		 * Just re-enable it without affecting the endpoint toggles.
 376		 */
 377		usb_enable_interface(udev, intf, false);
 378	} else if (!error && !intf->dev.power.is_prepared) {
 379		r = usb_set_interface(udev, intf->altsetting[0].
 380				desc.bInterfaceNumber, 0);
 381		if (r < 0)
 382			intf->needs_altsetting0 = 1;
 383	} else {
 384		intf->needs_altsetting0 = 1;
 385	}
 386	usb_set_intfdata(intf, NULL);
 387
 388	intf->condition = USB_INTERFACE_UNBOUND;
 389	intf->needs_remote_wakeup = 0;
 390
 
 
 
 
 391	/* Unbound interfaces are always runtime-PM-disabled and -suspended */
 392	if (driver->supports_autosuspend)
 393		pm_runtime_disable(dev);
 394	pm_runtime_set_suspended(dev);
 395
 396	/* Undo any residual pm_autopm_get_interface_* calls */
 397	for (r = atomic_read(&intf->pm_usage_cnt); r > 0; --r)
 398		usb_autopm_put_interface_no_suspend(intf);
 399	atomic_set(&intf->pm_usage_cnt, 0);
 400
 401	if (!error)
 402		usb_autosuspend_device(udev);
 403
 404	return 0;
 405}
 406
 407/**
 408 * usb_driver_claim_interface - bind a driver to an interface
 409 * @driver: the driver to be bound
 410 * @iface: the interface to which it will be bound; must be in the
 411 *	usb device's active configuration
 412 * @priv: driver data associated with that interface
 413 *
 414 * This is used by usb device drivers that need to claim more than one
 415 * interface on a device when probing (audio and acm are current examples).
 416 * No device driver should directly modify internal usb_interface or
 417 * usb_device structure members.
 418 *
 419 * Few drivers should need to use this routine, since the most natural
 420 * way to bind to an interface is to return the private data from
 421 * the driver's probe() method.
 422 *
 423 * Callers must own the device lock, so driver probe() entries don't need
 424 * extra locking, but other call contexts may need to explicitly claim that
 425 * lock.
 426 */
 427int usb_driver_claim_interface(struct usb_driver *driver,
 428				struct usb_interface *iface, void *priv)
 429{
 430	struct device *dev = &iface->dev;
 
 431	int retval = 0;
 
 432
 433	if (dev->driver)
 434		return -EBUSY;
 435
 
 
 436	dev->driver = &driver->drvwrap.driver;
 437	usb_set_intfdata(iface, priv);
 438	iface->needs_binding = 0;
 439
 440	iface->condition = USB_INTERFACE_BOUND;
 441
 
 
 
 
 
 
 
 
 442	/* Claimed interfaces are initially inactive (suspended) and
 443	 * runtime-PM-enabled, but only if the driver has autosuspend
 444	 * support.  Otherwise they are marked active, to prevent the
 445	 * device from being autosuspended, but left disabled.  In either
 446	 * case they are sensitive to their children's power states.
 447	 */
 448	pm_suspend_ignore_children(dev, false);
 449	if (driver->supports_autosuspend)
 450		pm_runtime_enable(dev);
 451	else
 452		pm_runtime_set_active(dev);
 453
 454	/* if interface was already added, bind now; else let
 455	 * the future device_add() bind it, bypassing probe()
 456	 */
 457	if (device_is_registered(dev))
 458		retval = device_bind_driver(dev);
 459
 
 
 
 
 460	return retval;
 461}
 462EXPORT_SYMBOL_GPL(usb_driver_claim_interface);
 463
 464/**
 465 * usb_driver_release_interface - unbind a driver from an interface
 466 * @driver: the driver to be unbound
 467 * @iface: the interface from which it will be unbound
 468 *
 469 * This can be used by drivers to release an interface without waiting
 470 * for their disconnect() methods to be called.  In typical cases this
 471 * also causes the driver disconnect() method to be called.
 472 *
 473 * This call is synchronous, and may not be used in an interrupt context.
 474 * Callers must own the device lock, so driver disconnect() entries don't
 475 * need extra locking, but other call contexts may need to explicitly claim
 476 * that lock.
 477 */
 478void usb_driver_release_interface(struct usb_driver *driver,
 479					struct usb_interface *iface)
 480{
 481	struct device *dev = &iface->dev;
 482
 483	/* this should never happen, don't release something that's not ours */
 484	if (!dev->driver || dev->driver != &driver->drvwrap.driver)
 485		return;
 486
 487	/* don't release from within disconnect() */
 488	if (iface->condition != USB_INTERFACE_BOUND)
 489		return;
 490	iface->condition = USB_INTERFACE_UNBINDING;
 491
 492	/* Release via the driver core only if the interface
 493	 * has already been registered
 494	 */
 495	if (device_is_registered(dev)) {
 496		device_release_driver(dev);
 497	} else {
 498		device_lock(dev);
 499		usb_unbind_interface(dev);
 500		dev->driver = NULL;
 501		device_unlock(dev);
 502	}
 503}
 504EXPORT_SYMBOL_GPL(usb_driver_release_interface);
 505
 506/* returns 0 if no match, 1 if match */
 507int usb_match_device(struct usb_device *dev, const struct usb_device_id *id)
 508{
 509	if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
 510	    id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
 511		return 0;
 512
 513	if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
 514	    id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
 515		return 0;
 516
 517	/* No need to test id->bcdDevice_lo != 0, since 0 is never
 518	   greater than any unsigned number. */
 519	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
 520	    (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
 521		return 0;
 522
 523	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
 524	    (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
 525		return 0;
 526
 527	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
 528	    (id->bDeviceClass != dev->descriptor.bDeviceClass))
 529		return 0;
 530
 531	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
 532	    (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass))
 533		return 0;
 534
 535	if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
 536	    (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
 537		return 0;
 538
 539	return 1;
 540}
 541
 542/* returns 0 if no match, 1 if match */
 543int usb_match_one_id(struct usb_interface *interface,
 544		     const struct usb_device_id *id)
 545{
 546	struct usb_host_interface *intf;
 547	struct usb_device *dev;
 548
 549	/* proc_connectinfo in devio.c may call us with id == NULL. */
 550	if (id == NULL)
 551		return 0;
 552
 553	intf = interface->cur_altsetting;
 554	dev = interface_to_usbdev(interface);
 555
 556	if (!usb_match_device(dev, id))
 557		return 0;
 558
 559	/* The interface class, subclass, and protocol should never be
 560	 * checked for a match if the device class is Vendor Specific,
 561	 * unless the match record specifies the Vendor ID. */
 562	if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
 563			!(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
 564			(id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
 565				USB_DEVICE_ID_MATCH_INT_SUBCLASS |
 566				USB_DEVICE_ID_MATCH_INT_PROTOCOL)))
 567		return 0;
 568
 569	if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
 570	    (id->bInterfaceClass != intf->desc.bInterfaceClass))
 571		return 0;
 572
 573	if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
 574	    (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
 575		return 0;
 576
 577	if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
 578	    (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
 579		return 0;
 580
 581	return 1;
 582}
 583EXPORT_SYMBOL_GPL(usb_match_one_id);
 584
 585/**
 586 * usb_match_id - find first usb_device_id matching device or interface
 587 * @interface: the interface of interest
 588 * @id: array of usb_device_id structures, terminated by zero entry
 589 *
 590 * usb_match_id searches an array of usb_device_id's and returns
 591 * the first one matching the device or interface, or null.
 592 * This is used when binding (or rebinding) a driver to an interface.
 593 * Most USB device drivers will use this indirectly, through the usb core,
 594 * but some layered driver frameworks use it directly.
 595 * These device tables are exported with MODULE_DEVICE_TABLE, through
 596 * modutils, to support the driver loading functionality of USB hotplugging.
 597 *
 598 * What Matches:
 599 *
 600 * The "match_flags" element in a usb_device_id controls which
 601 * members are used.  If the corresponding bit is set, the
 602 * value in the device_id must match its corresponding member
 603 * in the device or interface descriptor, or else the device_id
 604 * does not match.
 605 *
 606 * "driver_info" is normally used only by device drivers,
 607 * but you can create a wildcard "matches anything" usb_device_id
 608 * as a driver's "modules.usbmap" entry if you provide an id with
 609 * only a nonzero "driver_info" field.  If you do this, the USB device
 610 * driver's probe() routine should use additional intelligence to
 611 * decide whether to bind to the specified interface.
 612 *
 613 * What Makes Good usb_device_id Tables:
 614 *
 615 * The match algorithm is very simple, so that intelligence in
 616 * driver selection must come from smart driver id records.
 617 * Unless you have good reasons to use another selection policy,
 618 * provide match elements only in related groups, and order match
 619 * specifiers from specific to general.  Use the macros provided
 620 * for that purpose if you can.
 621 *
 622 * The most specific match specifiers use device descriptor
 623 * data.  These are commonly used with product-specific matches;
 624 * the USB_DEVICE macro lets you provide vendor and product IDs,
 625 * and you can also match against ranges of product revisions.
 626 * These are widely used for devices with application or vendor
 627 * specific bDeviceClass values.
 628 *
 629 * Matches based on device class/subclass/protocol specifications
 630 * are slightly more general; use the USB_DEVICE_INFO macro, or
 631 * its siblings.  These are used with single-function devices
 632 * where bDeviceClass doesn't specify that each interface has
 633 * its own class.
 634 *
 635 * Matches based on interface class/subclass/protocol are the
 636 * most general; they let drivers bind to any interface on a
 637 * multiple-function device.  Use the USB_INTERFACE_INFO
 638 * macro, or its siblings, to match class-per-interface style
 639 * devices (as recorded in bInterfaceClass).
 640 *
 641 * Note that an entry created by USB_INTERFACE_INFO won't match
 642 * any interface if the device class is set to Vendor-Specific.
 643 * This is deliberate; according to the USB spec the meanings of
 644 * the interface class/subclass/protocol for these devices are also
 645 * vendor-specific, and hence matching against a standard product
 646 * class wouldn't work anyway.  If you really want to use an
 647 * interface-based match for such a device, create a match record
 648 * that also specifies the vendor ID.  (Unforunately there isn't a
 649 * standard macro for creating records like this.)
 650 *
 651 * Within those groups, remember that not all combinations are
 652 * meaningful.  For example, don't give a product version range
 653 * without vendor and product IDs; or specify a protocol without
 654 * its associated class and subclass.
 655 */
 656const struct usb_device_id *usb_match_id(struct usb_interface *interface,
 657					 const struct usb_device_id *id)
 658{
 659	/* proc_connectinfo in devio.c may call us with id == NULL. */
 660	if (id == NULL)
 661		return NULL;
 662
 663	/* It is important to check that id->driver_info is nonzero,
 664	   since an entry that is all zeroes except for a nonzero
 665	   id->driver_info is the way to create an entry that
 666	   indicates that the driver want to examine every
 667	   device and interface. */
 668	for (; id->idVendor || id->idProduct || id->bDeviceClass ||
 669	       id->bInterfaceClass || id->driver_info; id++) {
 670		if (usb_match_one_id(interface, id))
 671			return id;
 672	}
 673
 674	return NULL;
 675}
 676EXPORT_SYMBOL_GPL(usb_match_id);
 677
 678static int usb_device_match(struct device *dev, struct device_driver *drv)
 679{
 680	/* devices and interfaces are handled separately */
 681	if (is_usb_device(dev)) {
 682
 683		/* interface drivers never match devices */
 684		if (!is_usb_device_driver(drv))
 685			return 0;
 686
 687		/* TODO: Add real matching code */
 688		return 1;
 689
 690	} else if (is_usb_interface(dev)) {
 691		struct usb_interface *intf;
 692		struct usb_driver *usb_drv;
 693		const struct usb_device_id *id;
 694
 695		/* device drivers never match interfaces */
 696		if (is_usb_device_driver(drv))
 697			return 0;
 698
 699		intf = to_usb_interface(dev);
 700		usb_drv = to_usb_driver(drv);
 701
 702		id = usb_match_id(intf, usb_drv->id_table);
 703		if (id)
 704			return 1;
 705
 706		id = usb_match_dynamic_id(intf, usb_drv);
 707		if (id)
 708			return 1;
 709	}
 710
 711	return 0;
 712}
 713
 714#ifdef	CONFIG_HOTPLUG
 715static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
 716{
 717	struct usb_device *usb_dev;
 718
 719	if (is_usb_device(dev)) {
 720		usb_dev = to_usb_device(dev);
 721	} else if (is_usb_interface(dev)) {
 722		struct usb_interface *intf = to_usb_interface(dev);
 723
 724		usb_dev = interface_to_usbdev(intf);
 725	} else {
 726		return 0;
 727	}
 728
 729	if (usb_dev->devnum < 0) {
 730		/* driver is often null here; dev_dbg() would oops */
 731		pr_debug("usb %s: already deleted?\n", dev_name(dev));
 732		return -ENODEV;
 733	}
 734	if (!usb_dev->bus) {
 735		pr_debug("usb %s: bus removed?\n", dev_name(dev));
 736		return -ENODEV;
 737	}
 738
 739#ifdef	CONFIG_USB_DEVICEFS
 740	/* If this is available, userspace programs can directly read
 741	 * all the device descriptors we don't tell them about.  Or
 742	 * act as usermode drivers.
 743	 */
 744	if (add_uevent_var(env, "DEVICE=/proc/bus/usb/%03d/%03d",
 745			   usb_dev->bus->busnum, usb_dev->devnum))
 746		return -ENOMEM;
 747#endif
 748
 749	/* per-device configurations are common */
 750	if (add_uevent_var(env, "PRODUCT=%x/%x/%x",
 751			   le16_to_cpu(usb_dev->descriptor.idVendor),
 752			   le16_to_cpu(usb_dev->descriptor.idProduct),
 753			   le16_to_cpu(usb_dev->descriptor.bcdDevice)))
 754		return -ENOMEM;
 755
 756	/* class-based driver binding models */
 757	if (add_uevent_var(env, "TYPE=%d/%d/%d",
 758			   usb_dev->descriptor.bDeviceClass,
 759			   usb_dev->descriptor.bDeviceSubClass,
 760			   usb_dev->descriptor.bDeviceProtocol))
 761		return -ENOMEM;
 762
 763	return 0;
 764}
 765
 766#else
 767
 768static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
 769{
 770	return -ENODEV;
 771}
 772#endif	/* CONFIG_HOTPLUG */
 773
 774/**
 775 * usb_register_device_driver - register a USB device (not interface) driver
 776 * @new_udriver: USB operations for the device driver
 777 * @owner: module owner of this driver.
 778 *
 779 * Registers a USB device driver with the USB core.  The list of
 780 * unattached devices will be rescanned whenever a new driver is
 781 * added, allowing the new driver to attach to any recognized devices.
 782 * Returns a negative error code on failure and 0 on success.
 783 */
 784int usb_register_device_driver(struct usb_device_driver *new_udriver,
 785		struct module *owner)
 786{
 787	int retval = 0;
 788
 789	if (usb_disabled())
 790		return -ENODEV;
 791
 792	new_udriver->drvwrap.for_devices = 1;
 793	new_udriver->drvwrap.driver.name = (char *) new_udriver->name;
 794	new_udriver->drvwrap.driver.bus = &usb_bus_type;
 795	new_udriver->drvwrap.driver.probe = usb_probe_device;
 796	new_udriver->drvwrap.driver.remove = usb_unbind_device;
 797	new_udriver->drvwrap.driver.owner = owner;
 798
 799	retval = driver_register(&new_udriver->drvwrap.driver);
 800
 801	if (!retval) {
 802		pr_info("%s: registered new device driver %s\n",
 803			usbcore_name, new_udriver->name);
 804		usbfs_update_special();
 805	} else {
 806		printk(KERN_ERR "%s: error %d registering device "
 807			"	driver %s\n",
 808			usbcore_name, retval, new_udriver->name);
 809	}
 810
 811	return retval;
 812}
 813EXPORT_SYMBOL_GPL(usb_register_device_driver);
 814
 815/**
 816 * usb_deregister_device_driver - unregister a USB device (not interface) driver
 817 * @udriver: USB operations of the device driver to unregister
 818 * Context: must be able to sleep
 819 *
 820 * Unlinks the specified driver from the internal USB driver list.
 821 */
 822void usb_deregister_device_driver(struct usb_device_driver *udriver)
 823{
 824	pr_info("%s: deregistering device driver %s\n",
 825			usbcore_name, udriver->name);
 826
 827	driver_unregister(&udriver->drvwrap.driver);
 828	usbfs_update_special();
 829}
 830EXPORT_SYMBOL_GPL(usb_deregister_device_driver);
 831
 832/**
 833 * usb_register_driver - register a USB interface driver
 834 * @new_driver: USB operations for the interface driver
 835 * @owner: module owner of this driver.
 836 * @mod_name: module name string
 837 *
 838 * Registers a USB interface driver with the USB core.  The list of
 839 * unattached interfaces will be rescanned whenever a new driver is
 840 * added, allowing the new driver to attach to any recognized interfaces.
 841 * Returns a negative error code on failure and 0 on success.
 842 *
 843 * NOTE: if you want your driver to use the USB major number, you must call
 844 * usb_register_dev() to enable that functionality.  This function no longer
 845 * takes care of that.
 846 */
 847int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
 848			const char *mod_name)
 849{
 850	int retval = 0;
 851
 852	if (usb_disabled())
 853		return -ENODEV;
 854
 855	new_driver->drvwrap.for_devices = 0;
 856	new_driver->drvwrap.driver.name = (char *) new_driver->name;
 857	new_driver->drvwrap.driver.bus = &usb_bus_type;
 858	new_driver->drvwrap.driver.probe = usb_probe_interface;
 859	new_driver->drvwrap.driver.remove = usb_unbind_interface;
 860	new_driver->drvwrap.driver.owner = owner;
 861	new_driver->drvwrap.driver.mod_name = mod_name;
 862	spin_lock_init(&new_driver->dynids.lock);
 863	INIT_LIST_HEAD(&new_driver->dynids.list);
 864
 865	retval = driver_register(&new_driver->drvwrap.driver);
 866	if (retval)
 867		goto out;
 868
 869	usbfs_update_special();
 870
 871	retval = usb_create_newid_file(new_driver);
 872	if (retval)
 873		goto out_newid;
 874
 875	retval = usb_create_removeid_file(new_driver);
 876	if (retval)
 877		goto out_removeid;
 878
 879	pr_info("%s: registered new interface driver %s\n",
 880			usbcore_name, new_driver->name);
 881
 882out:
 883	return retval;
 884
 885out_removeid:
 886	usb_remove_newid_file(new_driver);
 887out_newid:
 888	driver_unregister(&new_driver->drvwrap.driver);
 889
 890	printk(KERN_ERR "%s: error %d registering interface "
 891			"	driver %s\n",
 892			usbcore_name, retval, new_driver->name);
 893	goto out;
 894}
 895EXPORT_SYMBOL_GPL(usb_register_driver);
 896
 897/**
 898 * usb_deregister - unregister a USB interface driver
 899 * @driver: USB operations of the interface driver to unregister
 900 * Context: must be able to sleep
 901 *
 902 * Unlinks the specified driver from the internal USB driver list.
 903 *
 904 * NOTE: If you called usb_register_dev(), you still need to call
 905 * usb_deregister_dev() to clean up your driver's allocated minor numbers,
 906 * this * call will no longer do it for you.
 907 */
 908void usb_deregister(struct usb_driver *driver)
 909{
 910	pr_info("%s: deregistering interface driver %s\n",
 911			usbcore_name, driver->name);
 912
 913	usb_remove_removeid_file(driver);
 914	usb_remove_newid_file(driver);
 915	usb_free_dynids(driver);
 916	driver_unregister(&driver->drvwrap.driver);
 917
 918	usbfs_update_special();
 919}
 920EXPORT_SYMBOL_GPL(usb_deregister);
 921
 922/* Forced unbinding of a USB interface driver, either because
 923 * it doesn't support pre_reset/post_reset/reset_resume or
 924 * because it doesn't support suspend/resume.
 925 *
 926 * The caller must hold @intf's device's lock, but not its pm_mutex
 927 * and not @intf->dev.sem.
 928 */
 929void usb_forced_unbind_intf(struct usb_interface *intf)
 930{
 931	struct usb_driver *driver = to_usb_driver(intf->dev.driver);
 932
 933	dev_dbg(&intf->dev, "forced unbind\n");
 934	usb_driver_release_interface(driver, intf);
 935
 936	/* Mark the interface for later rebinding */
 937	intf->needs_binding = 1;
 938}
 939
 940/* Delayed forced unbinding of a USB interface driver and scan
 941 * for rebinding.
 942 *
 943 * The caller must hold @intf's device's lock, but not its pm_mutex
 944 * and not @intf->dev.sem.
 945 *
 946 * Note: Rebinds will be skipped if a system sleep transition is in
 947 * progress and the PM "complete" callback hasn't occurred yet.
 948 */
 949void usb_rebind_intf(struct usb_interface *intf)
 950{
 951	int rc;
 952
 953	/* Delayed unbind of an existing driver */
 954	if (intf->dev.driver) {
 955		struct usb_driver *driver =
 956				to_usb_driver(intf->dev.driver);
 957
 958		dev_dbg(&intf->dev, "forced unbind\n");
 959		usb_driver_release_interface(driver, intf);
 960	}
 961
 962	/* Try to rebind the interface */
 963	if (!intf->dev.power.is_prepared) {
 964		intf->needs_binding = 0;
 965		rc = device_attach(&intf->dev);
 966		if (rc < 0)
 967			dev_warn(&intf->dev, "rebind failed: %d\n", rc);
 968	}
 969}
 970
 971#ifdef CONFIG_PM
 972
 973#define DO_UNBIND	0
 974#define DO_REBIND	1
 975
 976/* Unbind drivers for @udev's interfaces that don't support suspend/resume,
 977 * or rebind interfaces that have been unbound, according to @action.
 978 *
 979 * The caller must hold @udev's device lock.
 980 */
 981static void do_unbind_rebind(struct usb_device *udev, int action)
 982{
 983	struct usb_host_config	*config;
 984	int			i;
 985	struct usb_interface	*intf;
 986	struct usb_driver	*drv;
 987
 988	config = udev->actconfig;
 989	if (config) {
 990		for (i = 0; i < config->desc.bNumInterfaces; ++i) {
 991			intf = config->interface[i];
 992			switch (action) {
 993			case DO_UNBIND:
 994				if (intf->dev.driver) {
 995					drv = to_usb_driver(intf->dev.driver);
 996					if (!drv->suspend || !drv->resume)
 997						usb_forced_unbind_intf(intf);
 998				}
 999				break;
1000			case DO_REBIND:
1001				if (intf->needs_binding)
1002					usb_rebind_intf(intf);
1003				break;
1004			}
1005		}
1006	}
1007}
1008
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1009static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
1010{
1011	struct usb_device_driver	*udriver;
1012	int				status = 0;
1013
1014	if (udev->state == USB_STATE_NOTATTACHED ||
1015			udev->state == USB_STATE_SUSPENDED)
1016		goto done;
1017
1018	/* For devices that don't have a driver, we do a generic suspend. */
1019	if (udev->dev.driver)
1020		udriver = to_usb_device_driver(udev->dev.driver);
1021	else {
1022		udev->do_remote_wakeup = 0;
1023		udriver = &usb_generic_driver;
1024	}
1025	status = udriver->suspend(udev, msg);
1026
1027 done:
1028	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1029	return status;
1030}
1031
1032static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
1033{
1034	struct usb_device_driver	*udriver;
1035	int				status = 0;
1036
1037	if (udev->state == USB_STATE_NOTATTACHED)
1038		goto done;
1039
1040	/* Can't resume it if it doesn't have a driver. */
1041	if (udev->dev.driver == NULL) {
1042		status = -ENOTCONN;
1043		goto done;
1044	}
1045
1046	/* Non-root devices on a full/low-speed bus must wait for their
1047	 * companion high-speed root hub, in case a handoff is needed.
1048	 */
1049	if (!(msg.event & PM_EVENT_AUTO) && udev->parent &&
1050			udev->bus->hs_companion)
1051		device_pm_wait_for_dev(&udev->dev,
1052				&udev->bus->hs_companion->root_hub->dev);
1053
1054	if (udev->quirks & USB_QUIRK_RESET_RESUME)
1055		udev->reset_resume = 1;
1056
1057	udriver = to_usb_device_driver(udev->dev.driver);
1058	status = udriver->resume(udev, msg);
1059
1060 done:
1061	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1062	return status;
1063}
1064
1065static int usb_suspend_interface(struct usb_device *udev,
1066		struct usb_interface *intf, pm_message_t msg)
1067{
1068	struct usb_driver	*driver;
1069	int			status = 0;
1070
1071	if (udev->state == USB_STATE_NOTATTACHED ||
1072			intf->condition == USB_INTERFACE_UNBOUND)
1073		goto done;
1074	driver = to_usb_driver(intf->dev.driver);
1075
1076	if (driver->suspend) {
1077		status = driver->suspend(intf, msg);
1078		if (status && !(msg.event & PM_EVENT_AUTO))
1079			dev_err(&intf->dev, "%s error %d\n",
1080					"suspend", status);
1081	} else {
1082		/* Later we will unbind the driver and reprobe */
1083		intf->needs_binding = 1;
1084		dev_warn(&intf->dev, "no %s for driver %s?\n",
1085				"suspend", driver->name);
1086	}
1087
1088 done:
1089	dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
1090	return status;
1091}
1092
1093static int usb_resume_interface(struct usb_device *udev,
1094		struct usb_interface *intf, pm_message_t msg, int reset_resume)
1095{
1096	struct usb_driver	*driver;
1097	int			status = 0;
1098
1099	if (udev->state == USB_STATE_NOTATTACHED)
1100		goto done;
1101
1102	/* Don't let autoresume interfere with unbinding */
1103	if (intf->condition == USB_INTERFACE_UNBINDING)
1104		goto done;
1105
1106	/* Can't resume it if it doesn't have a driver. */
1107	if (intf->condition == USB_INTERFACE_UNBOUND) {
1108
1109		/* Carry out a deferred switch to altsetting 0 */
1110		if (intf->needs_altsetting0 && !intf->dev.power.is_prepared) {
1111			usb_set_interface(udev, intf->altsetting[0].
1112					desc.bInterfaceNumber, 0);
1113			intf->needs_altsetting0 = 0;
1114		}
1115		goto done;
1116	}
1117
1118	/* Don't resume if the interface is marked for rebinding */
1119	if (intf->needs_binding)
1120		goto done;
1121	driver = to_usb_driver(intf->dev.driver);
1122
1123	if (reset_resume) {
1124		if (driver->reset_resume) {
1125			status = driver->reset_resume(intf);
1126			if (status)
1127				dev_err(&intf->dev, "%s error %d\n",
1128						"reset_resume", status);
1129		} else {
1130			intf->needs_binding = 1;
1131			dev_warn(&intf->dev, "no %s for driver %s?\n",
1132					"reset_resume", driver->name);
1133		}
1134	} else {
1135		if (driver->resume) {
1136			status = driver->resume(intf);
1137			if (status)
1138				dev_err(&intf->dev, "%s error %d\n",
1139						"resume", status);
1140		} else {
1141			intf->needs_binding = 1;
1142			dev_warn(&intf->dev, "no %s for driver %s?\n",
1143					"resume", driver->name);
1144		}
1145	}
1146
1147done:
1148	dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
1149
1150	/* Later we will unbind the driver and/or reprobe, if necessary */
1151	return status;
1152}
1153
1154/**
1155 * usb_suspend_both - suspend a USB device and its interfaces
1156 * @udev: the usb_device to suspend
1157 * @msg: Power Management message describing this state transition
1158 *
1159 * This is the central routine for suspending USB devices.  It calls the
1160 * suspend methods for all the interface drivers in @udev and then calls
1161 * the suspend method for @udev itself.  If an error occurs at any stage,
1162 * all the interfaces which were suspended are resumed so that they remain
1163 * in the same state as the device.
1164 *
1165 * Autosuspend requests originating from a child device or an interface
1166 * driver may be made without the protection of @udev's device lock, but
1167 * all other suspend calls will hold the lock.  Usbcore will insure that
1168 * method calls do not arrive during bind, unbind, or reset operations.
1169 * However drivers must be prepared to handle suspend calls arriving at
1170 * unpredictable times.
1171 *
1172 * This routine can run only in process context.
1173 */
1174static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
1175{
1176	int			status = 0;
1177	int			i = 0, n = 0;
1178	struct usb_interface	*intf;
1179
1180	if (udev->state == USB_STATE_NOTATTACHED ||
1181			udev->state == USB_STATE_SUSPENDED)
1182		goto done;
1183
1184	/* Suspend all the interfaces and then udev itself */
1185	if (udev->actconfig) {
1186		n = udev->actconfig->desc.bNumInterfaces;
1187		for (i = n - 1; i >= 0; --i) {
1188			intf = udev->actconfig->interface[i];
1189			status = usb_suspend_interface(udev, intf, msg);
1190
1191			/* Ignore errors during system sleep transitions */
1192			if (!(msg.event & PM_EVENT_AUTO))
1193				status = 0;
1194			if (status != 0)
1195				break;
1196		}
1197	}
1198	if (status == 0) {
1199		status = usb_suspend_device(udev, msg);
1200
1201		/* Again, ignore errors during system sleep transitions */
1202		if (!(msg.event & PM_EVENT_AUTO))
 
 
 
 
 
1203			status = 0;
1204	}
1205
1206	/* If the suspend failed, resume interfaces that did get suspended */
1207	if (status != 0) {
1208		msg.event ^= (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
1209		while (++i < n) {
1210			intf = udev->actconfig->interface[i];
1211			usb_resume_interface(udev, intf, msg, 0);
1212		}
1213
1214	/* If the suspend succeeded then prevent any more URB submissions
1215	 * and flush any outstanding URBs.
1216	 */
1217	} else {
1218		udev->can_submit = 0;
1219		for (i = 0; i < 16; ++i) {
1220			usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
1221			usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
1222		}
1223	}
1224
1225 done:
1226	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1227	return status;
1228}
1229
1230/**
1231 * usb_resume_both - resume a USB device and its interfaces
1232 * @udev: the usb_device to resume
1233 * @msg: Power Management message describing this state transition
1234 *
1235 * This is the central routine for resuming USB devices.  It calls the
1236 * the resume method for @udev and then calls the resume methods for all
1237 * the interface drivers in @udev.
1238 *
1239 * Autoresume requests originating from a child device or an interface
1240 * driver may be made without the protection of @udev's device lock, but
1241 * all other resume calls will hold the lock.  Usbcore will insure that
1242 * method calls do not arrive during bind, unbind, or reset operations.
1243 * However drivers must be prepared to handle resume calls arriving at
1244 * unpredictable times.
1245 *
1246 * This routine can run only in process context.
1247 */
1248static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
1249{
1250	int			status = 0;
1251	int			i;
1252	struct usb_interface	*intf;
1253
1254	if (udev->state == USB_STATE_NOTATTACHED) {
1255		status = -ENODEV;
1256		goto done;
1257	}
1258	udev->can_submit = 1;
1259
1260	/* Resume the device */
1261	if (udev->state == USB_STATE_SUSPENDED || udev->reset_resume)
1262		status = usb_resume_device(udev, msg);
1263
1264	/* Resume the interfaces */
1265	if (status == 0 && udev->actconfig) {
1266		for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1267			intf = udev->actconfig->interface[i];
1268			usb_resume_interface(udev, intf, msg,
1269					udev->reset_resume);
1270		}
1271	}
1272	usb_mark_last_busy(udev);
1273
1274 done:
1275	dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1276	if (!status)
1277		udev->reset_resume = 0;
1278	return status;
1279}
1280
1281static void choose_wakeup(struct usb_device *udev, pm_message_t msg)
1282{
1283	int	w;
1284
1285	/* Remote wakeup is needed only when we actually go to sleep.
1286	 * For things like FREEZE and QUIESCE, if the device is already
1287	 * autosuspended then its current wakeup setting is okay.
1288	 */
1289	if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_QUIESCE) {
1290		if (udev->state != USB_STATE_SUSPENDED)
1291			udev->do_remote_wakeup = 0;
1292		return;
1293	}
1294
1295	/* Enable remote wakeup if it is allowed, even if no interface drivers
1296	 * actually want it.
1297	 */
1298	w = device_may_wakeup(&udev->dev);
1299
1300	/* If the device is autosuspended with the wrong wakeup setting,
1301	 * autoresume now so the setting can be changed.
1302	 */
1303	if (udev->state == USB_STATE_SUSPENDED && w != udev->do_remote_wakeup)
1304		pm_runtime_resume(&udev->dev);
1305	udev->do_remote_wakeup = w;
1306}
1307
1308/* The device lock is held by the PM core */
1309int usb_suspend(struct device *dev, pm_message_t msg)
1310{
1311	struct usb_device	*udev = to_usb_device(dev);
1312
1313	do_unbind_rebind(udev, DO_UNBIND);
 
 
 
 
 
1314	choose_wakeup(udev, msg);
1315	return usb_suspend_both(udev, msg);
1316}
1317
1318/* The device lock is held by the PM core */
 
 
 
 
 
 
 
 
 
 
 
 
 
1319int usb_resume(struct device *dev, pm_message_t msg)
1320{
1321	struct usb_device	*udev = to_usb_device(dev);
1322	int			status;
1323
1324	/* For PM complete calls, all we do is rebind interfaces */
1325	if (msg.event == PM_EVENT_ON) {
1326		if (udev->state != USB_STATE_NOTATTACHED)
1327			do_unbind_rebind(udev, DO_REBIND);
1328		status = 0;
1329
1330	/* For all other calls, take the device back to full power and
1331	 * tell the PM core in case it was autosuspended previously.
1332	 * Unbind the interfaces that will need rebinding later.
 
 
 
1333	 */
1334	} else {
1335		status = usb_resume_both(udev, msg);
1336		if (status == 0) {
1337			pm_runtime_disable(dev);
1338			pm_runtime_set_active(dev);
1339			pm_runtime_enable(dev);
1340			do_unbind_rebind(udev, DO_REBIND);
1341		}
1342	}
1343
1344	/* Avoid PM error messages for devices disconnected while suspended
1345	 * as we'll display regular disconnect messages just a bit later.
1346	 */
1347	if (status == -ENODEV || status == -ESHUTDOWN)
1348		status = 0;
1349	return status;
1350}
1351
1352#endif /* CONFIG_PM */
1353
1354#ifdef CONFIG_USB_SUSPEND
1355
1356/**
1357 * usb_enable_autosuspend - allow a USB device to be autosuspended
1358 * @udev: the USB device which may be autosuspended
1359 *
1360 * This routine allows @udev to be autosuspended.  An autosuspend won't
1361 * take place until the autosuspend_delay has elapsed and all the other
1362 * necessary conditions are satisfied.
1363 *
1364 * The caller must hold @udev's device lock.
1365 */
1366void usb_enable_autosuspend(struct usb_device *udev)
1367{
1368	pm_runtime_allow(&udev->dev);
1369}
1370EXPORT_SYMBOL_GPL(usb_enable_autosuspend);
1371
1372/**
1373 * usb_disable_autosuspend - prevent a USB device from being autosuspended
1374 * @udev: the USB device which may not be autosuspended
1375 *
1376 * This routine prevents @udev from being autosuspended and wakes it up
1377 * if it is already autosuspended.
1378 *
1379 * The caller must hold @udev's device lock.
1380 */
1381void usb_disable_autosuspend(struct usb_device *udev)
1382{
1383	pm_runtime_forbid(&udev->dev);
1384}
1385EXPORT_SYMBOL_GPL(usb_disable_autosuspend);
1386
1387/**
1388 * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces
1389 * @udev: the usb_device to autosuspend
1390 *
1391 * This routine should be called when a core subsystem is finished using
1392 * @udev and wants to allow it to autosuspend.  Examples would be when
1393 * @udev's device file in usbfs is closed or after a configuration change.
1394 *
1395 * @udev's usage counter is decremented; if it drops to 0 and all the
1396 * interfaces are inactive then a delayed autosuspend will be attempted.
1397 * The attempt may fail (see autosuspend_check()).
1398 *
1399 * The caller must hold @udev's device lock.
1400 *
1401 * This routine can run only in process context.
1402 */
1403void usb_autosuspend_device(struct usb_device *udev)
1404{
1405	int	status;
1406
1407	usb_mark_last_busy(udev);
1408	status = pm_runtime_put_sync_autosuspend(&udev->dev);
1409	dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
1410			__func__, atomic_read(&udev->dev.power.usage_count),
1411			status);
1412}
1413
1414/**
1415 * usb_autoresume_device - immediately autoresume a USB device and its interfaces
1416 * @udev: the usb_device to autoresume
1417 *
1418 * This routine should be called when a core subsystem wants to use @udev
1419 * and needs to guarantee that it is not suspended.  No autosuspend will
1420 * occur until usb_autosuspend_device() is called.  (Note that this will
1421 * not prevent suspend events originating in the PM core.)  Examples would
1422 * be when @udev's device file in usbfs is opened or when a remote-wakeup
1423 * request is received.
1424 *
1425 * @udev's usage counter is incremented to prevent subsequent autosuspends.
1426 * However if the autoresume fails then the usage counter is re-decremented.
1427 *
1428 * The caller must hold @udev's device lock.
1429 *
1430 * This routine can run only in process context.
1431 */
1432int usb_autoresume_device(struct usb_device *udev)
1433{
1434	int	status;
1435
1436	status = pm_runtime_get_sync(&udev->dev);
1437	if (status < 0)
1438		pm_runtime_put_sync(&udev->dev);
1439	dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
1440			__func__, atomic_read(&udev->dev.power.usage_count),
1441			status);
1442	if (status > 0)
1443		status = 0;
1444	return status;
1445}
1446
1447/**
1448 * usb_autopm_put_interface - decrement a USB interface's PM-usage counter
1449 * @intf: the usb_interface whose counter should be decremented
1450 *
1451 * This routine should be called by an interface driver when it is
1452 * finished using @intf and wants to allow it to autosuspend.  A typical
1453 * example would be a character-device driver when its device file is
1454 * closed.
1455 *
1456 * The routine decrements @intf's usage counter.  When the counter reaches
1457 * 0, a delayed autosuspend request for @intf's device is attempted.  The
1458 * attempt may fail (see autosuspend_check()).
1459 *
1460 * This routine can run only in process context.
1461 */
1462void usb_autopm_put_interface(struct usb_interface *intf)
1463{
1464	struct usb_device	*udev = interface_to_usbdev(intf);
1465	int			status;
1466
1467	usb_mark_last_busy(udev);
1468	atomic_dec(&intf->pm_usage_cnt);
1469	status = pm_runtime_put_sync(&intf->dev);
1470	dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1471			__func__, atomic_read(&intf->dev.power.usage_count),
1472			status);
1473}
1474EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
1475
1476/**
1477 * usb_autopm_put_interface_async - decrement a USB interface's PM-usage counter
1478 * @intf: the usb_interface whose counter should be decremented
1479 *
1480 * This routine does much the same thing as usb_autopm_put_interface():
1481 * It decrements @intf's usage counter and schedules a delayed
1482 * autosuspend request if the counter is <= 0.  The difference is that it
1483 * does not perform any synchronization; callers should hold a private
1484 * lock and handle all synchronization issues themselves.
1485 *
1486 * Typically a driver would call this routine during an URB's completion
1487 * handler, if no more URBs were pending.
1488 *
1489 * This routine can run in atomic context.
1490 */
1491void usb_autopm_put_interface_async(struct usb_interface *intf)
1492{
1493	struct usb_device	*udev = interface_to_usbdev(intf);
1494	int			status;
1495
1496	usb_mark_last_busy(udev);
1497	atomic_dec(&intf->pm_usage_cnt);
1498	status = pm_runtime_put(&intf->dev);
1499	dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1500			__func__, atomic_read(&intf->dev.power.usage_count),
1501			status);
1502}
1503EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
1504
1505/**
1506 * usb_autopm_put_interface_no_suspend - decrement a USB interface's PM-usage counter
1507 * @intf: the usb_interface whose counter should be decremented
1508 *
1509 * This routine decrements @intf's usage counter but does not carry out an
1510 * autosuspend.
1511 *
1512 * This routine can run in atomic context.
1513 */
1514void usb_autopm_put_interface_no_suspend(struct usb_interface *intf)
1515{
1516	struct usb_device	*udev = interface_to_usbdev(intf);
1517
1518	usb_mark_last_busy(udev);
1519	atomic_dec(&intf->pm_usage_cnt);
1520	pm_runtime_put_noidle(&intf->dev);
1521}
1522EXPORT_SYMBOL_GPL(usb_autopm_put_interface_no_suspend);
1523
1524/**
1525 * usb_autopm_get_interface - increment a USB interface's PM-usage counter
1526 * @intf: the usb_interface whose counter should be incremented
1527 *
1528 * This routine should be called by an interface driver when it wants to
1529 * use @intf and needs to guarantee that it is not suspended.  In addition,
1530 * the routine prevents @intf from being autosuspended subsequently.  (Note
1531 * that this will not prevent suspend events originating in the PM core.)
1532 * This prevention will persist until usb_autopm_put_interface() is called
1533 * or @intf is unbound.  A typical example would be a character-device
1534 * driver when its device file is opened.
1535 *
1536 * @intf's usage counter is incremented to prevent subsequent autosuspends.
1537 * However if the autoresume fails then the counter is re-decremented.
1538 *
1539 * This routine can run only in process context.
1540 */
1541int usb_autopm_get_interface(struct usb_interface *intf)
1542{
1543	int	status;
1544
1545	status = pm_runtime_get_sync(&intf->dev);
1546	if (status < 0)
1547		pm_runtime_put_sync(&intf->dev);
1548	else
1549		atomic_inc(&intf->pm_usage_cnt);
1550	dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1551			__func__, atomic_read(&intf->dev.power.usage_count),
1552			status);
1553	if (status > 0)
1554		status = 0;
1555	return status;
1556}
1557EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
1558
1559/**
1560 * usb_autopm_get_interface_async - increment a USB interface's PM-usage counter
1561 * @intf: the usb_interface whose counter should be incremented
1562 *
1563 * This routine does much the same thing as
1564 * usb_autopm_get_interface(): It increments @intf's usage counter and
1565 * queues an autoresume request if the device is suspended.  The
1566 * differences are that it does not perform any synchronization (callers
1567 * should hold a private lock and handle all synchronization issues
1568 * themselves), and it does not autoresume the device directly (it only
1569 * queues a request).  After a successful call, the device may not yet be
1570 * resumed.
1571 *
1572 * This routine can run in atomic context.
1573 */
1574int usb_autopm_get_interface_async(struct usb_interface *intf)
1575{
1576	int	status;
1577
1578	status = pm_runtime_get(&intf->dev);
1579	if (status < 0 && status != -EINPROGRESS)
1580		pm_runtime_put_noidle(&intf->dev);
1581	else
1582		atomic_inc(&intf->pm_usage_cnt);
1583	dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1584			__func__, atomic_read(&intf->dev.power.usage_count),
1585			status);
1586	if (status > 0)
1587		status = 0;
1588	return status;
1589}
1590EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async);
1591
1592/**
1593 * usb_autopm_get_interface_no_resume - increment a USB interface's PM-usage counter
1594 * @intf: the usb_interface whose counter should be incremented
1595 *
1596 * This routine increments @intf's usage counter but does not carry out an
1597 * autoresume.
1598 *
1599 * This routine can run in atomic context.
1600 */
1601void usb_autopm_get_interface_no_resume(struct usb_interface *intf)
1602{
1603	struct usb_device	*udev = interface_to_usbdev(intf);
1604
1605	usb_mark_last_busy(udev);
1606	atomic_inc(&intf->pm_usage_cnt);
1607	pm_runtime_get_noresume(&intf->dev);
1608}
1609EXPORT_SYMBOL_GPL(usb_autopm_get_interface_no_resume);
1610
1611/* Internal routine to check whether we may autosuspend a device. */
1612static int autosuspend_check(struct usb_device *udev)
1613{
1614	int			w, i;
1615	struct usb_interface	*intf;
1616
1617	/* Fail if autosuspend is disabled, or any interfaces are in use, or
1618	 * any interface drivers require remote wakeup but it isn't available.
1619	 */
1620	w = 0;
1621	if (udev->actconfig) {
1622		for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1623			intf = udev->actconfig->interface[i];
1624
1625			/* We don't need to check interfaces that are
1626			 * disabled for runtime PM.  Either they are unbound
1627			 * or else their drivers don't support autosuspend
1628			 * and so they are permanently active.
1629			 */
1630			if (intf->dev.power.disable_depth)
1631				continue;
1632			if (atomic_read(&intf->dev.power.usage_count) > 0)
1633				return -EBUSY;
1634			w |= intf->needs_remote_wakeup;
1635
1636			/* Don't allow autosuspend if the device will need
1637			 * a reset-resume and any of its interface drivers
1638			 * doesn't include support or needs remote wakeup.
1639			 */
1640			if (udev->quirks & USB_QUIRK_RESET_RESUME) {
1641				struct usb_driver *driver;
1642
1643				driver = to_usb_driver(intf->dev.driver);
1644				if (!driver->reset_resume ||
1645						intf->needs_remote_wakeup)
1646					return -EOPNOTSUPP;
1647			}
1648		}
1649	}
1650	if (w && !device_can_wakeup(&udev->dev)) {
1651		dev_dbg(&udev->dev, "remote wakeup needed for autosuspend\n");
1652		return -EOPNOTSUPP;
1653	}
1654	udev->do_remote_wakeup = w;
1655	return 0;
1656}
1657
1658int usb_runtime_suspend(struct device *dev)
1659{
1660	struct usb_device	*udev = to_usb_device(dev);
1661	int			status;
1662
1663	/* A USB device can be suspended if it passes the various autosuspend
1664	 * checks.  Runtime suspend for a USB device means suspending all the
1665	 * interfaces and then the device itself.
1666	 */
1667	if (autosuspend_check(udev) != 0)
1668		return -EAGAIN;
1669
1670	status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
 
 
 
 
 
1671	/* The PM core reacts badly unless the return code is 0,
1672	 * -EAGAIN, or -EBUSY, so always return -EBUSY on an error.
1673	 */
1674	if (status != 0)
1675		return -EBUSY;
1676	return status;
1677}
1678
1679int usb_runtime_resume(struct device *dev)
1680{
1681	struct usb_device	*udev = to_usb_device(dev);
1682	int			status;
1683
1684	/* Runtime resume for a USB device means resuming both the device
1685	 * and all its interfaces.
1686	 */
1687	status = usb_resume_both(udev, PMSG_AUTO_RESUME);
1688	return status;
1689}
1690
1691int usb_runtime_idle(struct device *dev)
1692{
1693	struct usb_device	*udev = to_usb_device(dev);
1694
1695	/* An idle USB device can be suspended if it passes the various
1696	 * autosuspend checks.
1697	 */
1698	if (autosuspend_check(udev) == 0)
1699		pm_runtime_autosuspend(dev);
1700	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1701}
1702
1703#endif /* CONFIG_USB_SUSPEND */
1704
1705struct bus_type usb_bus_type = {
1706	.name =		"usb",
1707	.match =	usb_device_match,
1708	.uevent =	usb_uevent,
1709};