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