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

Commit 55c527187c9d78f840b284d596a0b298bc1493af

Authored by Alan Stern 2005-11-24 01:03:12 +0800

Committed by Greg Kroah-Hartman 2006-01-05 05:48:34 +0800

Exists in master and in 7 other branches

[PATCH] USB: Consider power budget when choosing configuration

This patch (as609) changes the way we keep track of power budgeting for
USB hubs and devices, and it updates the choose_configuration routine to
take this information into account.  (This is something we should have
been doing all along.)  A new field in struct usb_device holds the amount
of bus current available from the upstream port, and the usb_hub structure
keeps track of the current available for each downstream port.

Two new rules for configuration selection are added:

	Don't select a self-powered configuration when only bus power
	is available.

	Don't select a configuration requiring more bus power than is
	available.

However the first rule is #if-ed out, because I found that the internal
hub in my HP USB keyboard claims that its only configuration is
self-powered.  The rule would prevent the configuration from being chosen,
leaving the hub & keyboard unconfigured.  Since similar descriptor errors
may turn out to be fairly common, it seemed wise not to include a rule
that would break automatic configuration unnecessarily for such devices.

The second rule may also trigger unnecessarily, although this should be
less common.  More likely it will annoy people by sometimes failing to
accept configurations that should never have been chosen in the first
place.

The patch also changes usbcore's reaction when no configuration is
suitable.  Instead of raising an error and rejecting the device, now
the core will simply leave the device unconfigured.  People can always
work around such problems by installing configurations manually through
sysfs.

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

Showing 5 changed files with 164 additions and 81 deletions Inline Diff

drivers/usb/core/hcd.c
drivers/usb/core/hub.c
drivers/usb/core/hub.h
drivers/usb/core/message.c
include/linux/usb.h

drivers/usb/core/hcd.c

Diff comments View file @ 55c5271

 /*
  * (C) Copyright Linus Torvalds 1999
  * (C) Copyright Johannes Erdfelt 1999-2001
  * (C) Copyright Andreas Gal 1999
  * (C) Copyright Gregory P. Smith 1999
  * (C) Copyright Deti Fliegl 1999
  * (C) Copyright Randy Dunlap 2000
  * (C) Copyright David Brownell 2000-2002
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
  * Free Software Foundation; either version 2 of the License, or (at your
  * option) any later version.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/version.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/completion.h>
 #include <linux/utsname.h>
 #include <linux/mm.h>
 #include <asm/io.h>
 #include <asm/scatterlist.h>
 #include <linux/device.h>
 #include <linux/dma-mapping.h>
 #include <asm/irq.h>
 #include <asm/byteorder.h>
 #include <linux/usb.h>
 #include "usb.h"
 #include "hcd.h"
 #include "hub.h"
 // #define USB_BANDWIDTH_MESSAGES
 /*-------------------------------------------------------------------------*/
 /*
  * USB Host Controller Driver framework
  *
  * Plugs into usbcore (usb_bus) and lets HCDs share code, minimizing
  * HCD-specific behaviors/bugs.
  *
  * This does error checks, tracks devices and urbs, and delegates to a
  * "hc_driver" only for code (and data) that really needs to know about
  * hardware differences.  That includes root hub registers, i/o queues,
  * and so on ... but as little else as possible.
  *
  * Shared code includes most of the "root hub" code (these are emulated,
  * though each HC's hardware works differently) and PCI glue, plus request
  * tracking overhead.  The HCD code should only block on spinlocks or on
  * hardware handshaking; blocking on software events (such as other kernel
  * threads releasing resources, or completing actions) is all generic.
  *
  * Happens the USB 2.0 spec says this would be invisible inside the "USBD",
  * and includes mostly a "HCDI" (HCD Interface) along with some APIs used
  * only by the hub driver ... and that neither should be seen or used by
  * usb client device drivers.
  *
  * Contributors of ideas or unattributed patches include: David Brownell,
  * Roman Weissgaerber, Rory Bolt, Greg Kroah-Hartman, ...
  *
  * HISTORY:
  * 2002-02-21	Pull in most of the usb_bus support from usb.c; some
  *		associated cleanup.  "usb_hcd" still != "usb_bus".
  * 2001-12-12	Initial patch version for Linux 2.5.1 kernel.
  */
 /*-------------------------------------------------------------------------*/
 /* host controllers we manage */
 LIST_HEAD (usb_bus_list);
 EXPORT_SYMBOL_GPL (usb_bus_list);
 /* used when allocating bus numbers */
 #define USB_MAXBUS		64
 struct usb_busmap {
 	unsigned long busmap [USB_MAXBUS / (8*sizeof (unsigned long))];
 };
 static struct usb_busmap busmap;
 /* used when updating list of hcds */
 DECLARE_MUTEX (usb_bus_list_lock);	/* exported only for usbfs */
 EXPORT_SYMBOL_GPL (usb_bus_list_lock);
 /* used for controlling access to virtual root hubs */
 static DEFINE_SPINLOCK(hcd_root_hub_lock);
 /* used when updating hcd data */
 static DEFINE_SPINLOCK(hcd_data_lock);
 /* wait queue for synchronous unlinks */
 DECLARE_WAIT_QUEUE_HEAD(usb_kill_urb_queue);
 /*-------------------------------------------------------------------------*/
 /*
  * Sharable chunks of root hub code.
  */
 /*-------------------------------------------------------------------------*/
 #define KERNEL_REL	((LINUX_VERSION_CODE >> 16) & 0x0ff)
 #define KERNEL_VER	((LINUX_VERSION_CODE >> 8) & 0x0ff)
 /* usb 2.0 root hub device descriptor */
 static const u8 usb2_rh_dev_descriptor [18] = {
 	0x12,       /*  __u8  bLength; */
 	0x01,       /*  __u8  bDescriptorType; Device */
 	0x00, 0x02, /*  __le16 bcdUSB; v2.0 */
 	0x09,	    /*  __u8  bDeviceClass; HUB_CLASSCODE */
 	0x00,	    /*  __u8  bDeviceSubClass; */
 	0x01,       /*  __u8  bDeviceProtocol; [ usb 2.0 single TT ]*/
 	0x40,       /*  __u8  bMaxPacketSize0; 64 Bytes */
 	0x00, 0x00, /*  __le16 idVendor; */
  	0x00, 0x00, /*  __le16 idProduct; */
 	KERNEL_VER, KERNEL_REL, /*  __le16 bcdDevice */
 	0x03,       /*  __u8  iManufacturer; */
 	0x02,       /*  __u8  iProduct; */
 	0x01,       /*  __u8  iSerialNumber; */
 	0x01        /*  __u8  bNumConfigurations; */
 };
 /* no usb 2.0 root hub "device qualifier" descriptor: one speed only */
 /* usb 1.1 root hub device descriptor */
 static const u8 usb11_rh_dev_descriptor [18] = {
 	0x12,       /*  __u8  bLength; */
 	0x01,       /*  __u8  bDescriptorType; Device */
 	0x10, 0x01, /*  __le16 bcdUSB; v1.1 */
 	0x09,	    /*  __u8  bDeviceClass; HUB_CLASSCODE */
 	0x00,	    /*  __u8  bDeviceSubClass; */
 	0x00,       /*  __u8  bDeviceProtocol; [ low/full speeds only ] */
 	0x40,       /*  __u8  bMaxPacketSize0; 64 Bytes */
 	0x00, 0x00, /*  __le16 idVendor; */
  	0x00, 0x00, /*  __le16 idProduct; */
 	KERNEL_VER, KERNEL_REL, /*  __le16 bcdDevice */
 	0x03,       /*  __u8  iManufacturer; */
 	0x02,       /*  __u8  iProduct; */
 	0x01,       /*  __u8  iSerialNumber; */
 	0x01        /*  __u8  bNumConfigurations; */
 };
 /*-------------------------------------------------------------------------*/
 /* Configuration descriptors for our root hubs */
 static const u8 fs_rh_config_descriptor [] = {
 	/* one configuration */
 	0x09,       /*  __u8  bLength; */
 	0x02,       /*  __u8  bDescriptorType; Configuration */
 	0x19, 0x00, /*  __le16 wTotalLength; */
 	0x01,       /*  __u8  bNumInterfaces; (1) */
 	0x01,       /*  __u8  bConfigurationValue; */
 	0x00,       /*  __u8  iConfiguration; */
 	0xc0,       /*  __u8  bmAttributes;
 				 Bit 7: must be set,
 				     6: Self-powered,
 				     5: Remote wakeup,
 				     4..0: resvd */
 	0x00,       /*  __u8  MaxPower; */
 	/* USB 1.1:
 	 * USB 2.0, single TT organization (mandatory):
 	 *	one interface, protocol 0
 	 *
 	 * USB 2.0, multiple TT organization (optional):
 	 *	two interfaces, protocols 1 (like single TT)
 	 *	and 2 (multiple TT mode) ... config is
 	 *	sometimes settable
 	 *	NOT IMPLEMENTED
 	 */
 	/* one interface */
 	0x09,       /*  __u8  if_bLength; */
 	0x04,       /*  __u8  if_bDescriptorType; Interface */
 	0x00,       /*  __u8  if_bInterfaceNumber; */
 	0x00,       /*  __u8  if_bAlternateSetting; */
 	0x01,       /*  __u8  if_bNumEndpoints; */
 	0x09,       /*  __u8  if_bInterfaceClass; HUB_CLASSCODE */
 	0x00,       /*  __u8  if_bInterfaceSubClass; */
 	0x00,       /*  __u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
 	0x00,       /*  __u8  if_iInterface; */
 	/* one endpoint (status change endpoint) */
 	0x07,       /*  __u8  ep_bLength; */
 	0x05,       /*  __u8  ep_bDescriptorType; Endpoint */
 	0x81,       /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */
  	0x03,       /*  __u8  ep_bmAttributes; Interrupt */
  	0x02, 0x00, /*  __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
 	0xff        /*  __u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 };
 static const u8 hs_rh_config_descriptor [] = {
 	/* one configuration */
 	0x09,       /*  __u8  bLength; */
 	0x02,       /*  __u8  bDescriptorType; Configuration */
 	0x19, 0x00, /*  __le16 wTotalLength; */
 	0x01,       /*  __u8  bNumInterfaces; (1) */
 	0x01,       /*  __u8  bConfigurationValue; */
 	0x00,       /*  __u8  iConfiguration; */
 	0xc0,       /*  __u8  bmAttributes;
 				 Bit 7: must be set,
 				     6: Self-powered,
 				     5: Remote wakeup,
 				     4..0: resvd */
 	0x00,       /*  __u8  MaxPower; */
 	/* USB 1.1:
 	 * USB 2.0, single TT organization (mandatory):
 	 *	one interface, protocol 0
 	 *
 	 * USB 2.0, multiple TT organization (optional):
 	 *	two interfaces, protocols 1 (like single TT)
 	 *	and 2 (multiple TT mode) ... config is
 	 *	sometimes settable
 	 *	NOT IMPLEMENTED
 	 */
 	/* one interface */
 	0x09,       /*  __u8  if_bLength; */
 	0x04,       /*  __u8  if_bDescriptorType; Interface */
 	0x00,       /*  __u8  if_bInterfaceNumber; */
 	0x00,       /*  __u8  if_bAlternateSetting; */
 	0x01,       /*  __u8  if_bNumEndpoints; */
 	0x09,       /*  __u8  if_bInterfaceClass; HUB_CLASSCODE */
 	0x00,       /*  __u8  if_bInterfaceSubClass; */
 	0x00,       /*  __u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
 	0x00,       /*  __u8  if_iInterface; */
 	/* one endpoint (status change endpoint) */
 	0x07,       /*  __u8  ep_bLength; */
 	0x05,       /*  __u8  ep_bDescriptorType; Endpoint */
 	0x81,       /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */
  	0x03,       /*  __u8  ep_bmAttributes; Interrupt */
  	0x02, 0x00, /*  __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
 	0x0c        /*  __u8  ep_bInterval; (256ms -- usb 2.0 spec) */
 };
 /*-------------------------------------------------------------------------*/
 /*
  * helper routine for returning string descriptors in UTF-16LE
  * input can actually be ISO-8859-1; ASCII is its 7-bit subset
  */
 static int ascii2utf (char *s, u8 *utf, int utfmax)
 {
 	int retval;
 	for (retval = 0; *s && utfmax > 1; utfmax -= 2, retval += 2) {
 		*utf++ = *s++;
 		*utf++ = 0;
 	}
 	if (utfmax > 0) {
 		*utf = *s;
 		++retval;
 	}
 	return retval;
 }
 /*
  * rh_string - provides manufacturer, product and serial strings for root hub
  * @id: the string ID number (1: serial number, 2: product, 3: vendor)
  * @hcd: the host controller for this root hub
  * @type: string describing our driver
  * @data: return packet in UTF-16 LE
  * @len: length of the return packet
  *
  * Produces either a manufacturer, product or serial number string for the
  * virtual root hub device.
  */
 static int rh_string (
 	int		id,
 	struct usb_hcd	*hcd,
 	u8		*data,
 	int		len
 ) {
 	char buf [100];
 	// language ids
 	if (id == 0) {
 		buf[0] = 4;    buf[1] = 3;	/* 4 bytes string data */
 		buf[2] = 0x09; buf[3] = 0x04;	/* MSFT-speak for "en-us" */
 		len = min (len, 4);
 		memcpy (data, buf, len);
 		return len;
 	// serial number
 	} else if (id == 1) {
 		strlcpy (buf, hcd->self.bus_name, sizeof buf);
 	// product description
 	} else if (id == 2) {
 		strlcpy (buf, hcd->product_desc, sizeof buf);
  	// id 3 == vendor description
 	} else if (id == 3) {
 		snprintf (buf, sizeof buf, "%s %s %s", system_utsname.sysname,
 			system_utsname.release, hcd->driver->description);
 	// unsupported IDs --> "protocol stall"
 	} else
 		return -EPIPE;
 	switch (len) {		/* All cases fall through */
 	default:
 		len = 2 + ascii2utf (buf, data + 2, len - 2);
 	case 2:
 		data [1] = 3;	/* type == string */
 	case 1:
 		data [0] = 2 * (strlen (buf) + 1);
 	case 0:
 		;		/* Compiler wants a statement here */
 	}
 	return len;
 }
 /* Root hub control transfers execute synchronously */
 static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
 {
 	struct usb_ctrlrequest *cmd;
  	u16		typeReq, wValue, wIndex, wLength;
 	u8		*ubuf = urb->transfer_buffer;
 	u8		tbuf [sizeof (struct usb_hub_descriptor)];
 	const u8	*bufp = tbuf;
 	int		len = 0;
 	int		patch_wakeup = 0;
 	unsigned long	flags;
 	int		status = 0;
 	int		n;
 	cmd = (struct usb_ctrlrequest *) urb->setup_packet;
 	typeReq  = (cmd->bRequestType << 8) | cmd->bRequest;
 	wValue   = le16_to_cpu (cmd->wValue);
 	wIndex   = le16_to_cpu (cmd->wIndex);
 	wLength  = le16_to_cpu (cmd->wLength);
 	if (wLength > urb->transfer_buffer_length)
 		goto error;
 	urb->actual_length = 0;
 	switch (typeReq) {
 	/* DEVICE REQUESTS */
 	case DeviceRequest | USB_REQ_GET_STATUS:
 		tbuf [0] = (hcd->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP)
 				| (1 << USB_DEVICE_SELF_POWERED);
 		tbuf [1] = 0;
 		len = 2;
 		break;
 	case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
 		if (wValue == USB_DEVICE_REMOTE_WAKEUP)
 			hcd->remote_wakeup = 0;
 		else
 			goto error;
 		break;
 	case DeviceOutRequest | USB_REQ_SET_FEATURE:
 		if (hcd->can_wakeup && wValue == USB_DEVICE_REMOTE_WAKEUP)
 			hcd->remote_wakeup = 1;
 		else
 			goto error;
 		break;
 	case DeviceRequest | USB_REQ_GET_CONFIGURATION:
 		tbuf [0] = 1;
 		len = 1;
 			/* FALLTHROUGH */
 	case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
 		break;
 	case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
 		switch (wValue & 0xff00) {
 		case USB_DT_DEVICE << 8:
 			if (hcd->driver->flags & HCD_USB2)
 				bufp = usb2_rh_dev_descriptor;
 			else if (hcd->driver->flags & HCD_USB11)
 				bufp = usb11_rh_dev_descriptor;
 			else
 				goto error;
 			len = 18;
 			break;
 		case USB_DT_CONFIG << 8:
 			if (hcd->driver->flags & HCD_USB2) {
 				bufp = hs_rh_config_descriptor;
 				len = sizeof hs_rh_config_descriptor;
 			} else {
 				bufp = fs_rh_config_descriptor;
 				len = sizeof fs_rh_config_descriptor;
 			}
 			if (hcd->can_wakeup)
 				patch_wakeup = 1;
 			break;
 		case USB_DT_STRING << 8:
 			n = rh_string (wValue & 0xff, hcd, ubuf, wLength);
 			if (n < 0)
 				goto error;
 			urb->actual_length = n;
 			break;
 		default:
 			goto error;
 		}
 		break;
 	case DeviceRequest | USB_REQ_GET_INTERFACE:
 		tbuf [0] = 0;
 		len = 1;
 			/* FALLTHROUGH */
 	case DeviceOutRequest | USB_REQ_SET_INTERFACE:
 		break;
 	case DeviceOutRequest | USB_REQ_SET_ADDRESS:
 		// wValue == urb->dev->devaddr
 		dev_dbg (hcd->self.controller, "root hub device address %d\n",
 			wValue);
 		break;
 	/* INTERFACE REQUESTS (no defined feature/status flags) */
 	/* ENDPOINT REQUESTS */
 	case EndpointRequest | USB_REQ_GET_STATUS:
 		// ENDPOINT_HALT flag
 		tbuf [0] = 0;
 		tbuf [1] = 0;
 		len = 2;
 			/* FALLTHROUGH */
 	case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
 	case EndpointOutRequest | USB_REQ_SET_FEATURE:
 		dev_dbg (hcd->self.controller, "no endpoint features yet\n");
 		break;
 	/* CLASS REQUESTS (and errors) */
 	default:
 		/* non-generic request */
 		switch (typeReq) {
 		case GetHubStatus:
 		case GetPortStatus:
 			len = 4;
 			break;
 		case GetHubDescriptor:
 			len = sizeof (struct usb_hub_descriptor);
 			break;
 		}
 		status = hcd->driver->hub_control (hcd,
 			typeReq, wValue, wIndex,
 			tbuf, wLength);
 		break;
 error:
 		/* "protocol stall" on error */
 		status = -EPIPE;
 	}
 	if (status) {
 		len = 0;
 		if (status != -EPIPE) {
 			dev_dbg (hcd->self.controller,
 				"CTRL: TypeReq=0x%x val=0x%x "
 				"idx=0x%x len=%d ==> %d\n",
 				typeReq, wValue, wIndex,
 				wLength, status);
 		}
 	}
 	if (len) {
 		if (urb->transfer_buffer_length < len)
 			len = urb->transfer_buffer_length;
 		urb->actual_length = len;
 		// always USB_DIR_IN, toward host
 		memcpy (ubuf, bufp, len);
 		/* report whether RH hardware supports remote wakeup */
 		if (patch_wakeup &&
 				len > offsetof (struct usb_config_descriptor,
 						bmAttributes))
 			((struct usb_config_descriptor *)ubuf)->bmAttributes
 				|= USB_CONFIG_ATT_WAKEUP;
 	}
 	/* any errors get returned through the urb completion */
 	local_irq_save (flags);
 	spin_lock (&urb->lock);
 	if (urb->status == -EINPROGRESS)
 		urb->status = status;
 	spin_unlock (&urb->lock);
 	usb_hcd_giveback_urb (hcd, urb, NULL);
 	local_irq_restore (flags);
 	return 0;
 }
 /*-------------------------------------------------------------------------*/
 /*
  * Root Hub interrupt transfers are polled using a timer if the
  * driver requests it; otherwise the driver is responsible for
  * calling usb_hcd_poll_rh_status() when an event occurs.
  *
  * Completions are called in_interrupt(), but they may or may not
  * be in_irq().
  */
 void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
 {
 	struct urb	*urb;
 	int		length;
 	unsigned long	flags;
 	char		buffer[4];	/* Any root hubs with > 31 ports? */
 	if (!hcd->uses_new_polling && !hcd->status_urb)
 		return;
 	length = hcd->driver->hub_status_data(hcd, buffer);
 	if (length > 0) {
 		/* try to complete the status urb */
 		local_irq_save (flags);
 		spin_lock(&hcd_root_hub_lock);
 		urb = hcd->status_urb;
 		if (urb) {
 			spin_lock(&urb->lock);
 			if (urb->status == -EINPROGRESS) {
 				hcd->poll_pending = 0;
 				hcd->status_urb = NULL;
 				urb->status = 0;
 				urb->hcpriv = NULL;
 				urb->actual_length = length;
 				memcpy(urb->transfer_buffer, buffer, length);
 			} else		/* urb has been unlinked */
 				length = 0;
 			spin_unlock(&urb->lock);
 		} else
 			length = 0;
 		spin_unlock(&hcd_root_hub_lock);
 		/* local irqs are always blocked in completions */
 		if (length > 0)
 			usb_hcd_giveback_urb (hcd, urb, NULL);
 		else
 			hcd->poll_pending = 1;
 		local_irq_restore (flags);
 	}
 	/* The USB 2.0 spec says 256 ms.  This is close enough and won't
 	 * exceed that limit if HZ is 100. */
 	if (hcd->uses_new_polling ? hcd->poll_rh :
 			(length == 0 && hcd->status_urb != NULL))
 		mod_timer (&hcd->rh_timer, jiffies + msecs_to_jiffies(250));
 }
 EXPORT_SYMBOL_GPL(usb_hcd_poll_rh_status);
 /* timer callback */
 static void rh_timer_func (unsigned long _hcd)
 {
 	usb_hcd_poll_rh_status((struct usb_hcd *) _hcd);
 }
 /*-------------------------------------------------------------------------*/
 static int rh_queue_status (struct usb_hcd *hcd, struct urb *urb)
 {
 	int		retval;
 	unsigned long	flags;
 	int		len = 1 + (urb->dev->maxchild / 8);
 	spin_lock_irqsave (&hcd_root_hub_lock, flags);
 	if (urb->status != -EINPROGRESS)	/* already unlinked */
 		retval = urb->status;
 	else if (hcd->status_urb || urb->transfer_buffer_length < len) {
 		dev_dbg (hcd->self.controller, "not queuing rh status urb\n");
 		retval = -EINVAL;
 	} else {
 		hcd->status_urb = urb;
 		urb->hcpriv = hcd;	/* indicate it's queued */
 		if (!hcd->uses_new_polling)
 			mod_timer (&hcd->rh_timer, jiffies +
 					msecs_to_jiffies(250));
 		/* If a status change has already occurred, report it ASAP */
 		else if (hcd->poll_pending)
 			mod_timer (&hcd->rh_timer, jiffies);
 		retval = 0;
 	}
 	spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
 	return retval;
 }
 static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
 {
 	if (usb_pipeint (urb->pipe))
 		return rh_queue_status (hcd, urb);
 	if (usb_pipecontrol (urb->pipe))
 		return rh_call_control (hcd, urb);
 	return -EINVAL;
 }
 /*-------------------------------------------------------------------------*/
 /* Asynchronous unlinks of root-hub control URBs are legal, but they
  * don't do anything.  Status URB unlinks must be made in process context
  * with interrupts enabled.
  */
 static int usb_rh_urb_dequeue (struct usb_hcd *hcd, struct urb *urb)
 {
 	if (usb_pipeendpoint(urb->pipe) == 0) {	/* Control URB */
 		if (in_interrupt())
 			return 0;		/* nothing to do */
 		spin_lock_irq(&urb->lock);	/* from usb_kill_urb */
 		++urb->reject;
 		spin_unlock_irq(&urb->lock);
 		wait_event(usb_kill_urb_queue,
 				atomic_read(&urb->use_count) == 0);
 		spin_lock_irq(&urb->lock);
 		--urb->reject;
 		spin_unlock_irq(&urb->lock);
 	} else {				/* Status URB */
 		if (!hcd->uses_new_polling)
 			del_timer_sync (&hcd->rh_timer);
 		local_irq_disable ();
 		spin_lock (&hcd_root_hub_lock);
 		if (urb == hcd->status_urb) {
 			hcd->status_urb = NULL;
 			urb->hcpriv = NULL;
 		} else
 			urb = NULL;		/* wasn't fully queued */
 		spin_unlock (&hcd_root_hub_lock);
 		if (urb)
 			usb_hcd_giveback_urb (hcd, urb, NULL);
 		local_irq_enable ();
 	}
 	return 0;
 }
 /*-------------------------------------------------------------------------*/
 /* exported only within usbcore */
 struct usb_bus *usb_bus_get(struct usb_bus *bus)
 {
 	if (bus)
 		kref_get(&bus->kref);
 	return bus;
 }
 static void usb_host_release(struct kref *kref)
 {
 	struct usb_bus *bus = container_of(kref, struct usb_bus, kref);
 	if (bus->release)
 		bus->release(bus);
 }
 /* exported only within usbcore */
 void usb_bus_put(struct usb_bus *bus)
 {
 	if (bus)
 		kref_put(&bus->kref, usb_host_release);
 }
 /*-------------------------------------------------------------------------*/
 static struct class *usb_host_class;
 int usb_host_init(void)
 {
 	int retval = 0;
 	usb_host_class = class_create(THIS_MODULE, "usb_host");
 	if (IS_ERR(usb_host_class))
 		retval = PTR_ERR(usb_host_class);
 	return retval;
 }
 void usb_host_cleanup(void)
 {
 	class_destroy(usb_host_class);
 }
 /**
  * usb_bus_init - shared initialization code
  * @bus: the bus structure being initialized
  *
  * This code is used to initialize a usb_bus structure, memory for which is
  * separately managed.
  */
 static void usb_bus_init (struct usb_bus *bus)
 {
 	memset (&bus->devmap, 0, sizeof(struct usb_devmap));
 	bus->devnum_next = 1;
 	bus->root_hub = NULL;
 	bus->hcpriv = NULL;
 	bus->busnum = -1;
 	bus->bandwidth_allocated = 0;
 	bus->bandwidth_int_reqs  = 0;
 	bus->bandwidth_isoc_reqs = 0;
 	INIT_LIST_HEAD (&bus->bus_list);
 	kref_init(&bus->kref);
 }
 /**
  * usb_alloc_bus - creates a new USB host controller structure
  * @op: pointer to a struct usb_operations that this bus structure should use
  * Context: !in_interrupt()
  *
  * Creates a USB host controller bus structure with the specified
  * usb_operations and initializes all the necessary internal objects.
  *
  * If no memory is available, NULL is returned.
  *
  * The caller should call usb_put_bus() when it is finished with the structure.
  */
 struct usb_bus *usb_alloc_bus (struct usb_operations *op)
 {
 	struct usb_bus *bus;
 	bus = kzalloc (sizeof *bus, GFP_KERNEL);
 	if (!bus)
 		return NULL;
 	usb_bus_init (bus);
 	bus->op = op;
 	return bus;
 }
 /*-------------------------------------------------------------------------*/
 /**
  * usb_register_bus - registers the USB host controller with the usb core
  * @bus: pointer to the bus to register
  * Context: !in_interrupt()
  *
  * Assigns a bus number, and links the controller into usbcore data
  * structures so that it can be seen by scanning the bus list.
  */
 static int usb_register_bus(struct usb_bus *bus)
 {
 	int busnum;
 	down (&usb_bus_list_lock);
 	busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1);
 	if (busnum < USB_MAXBUS) {
 		set_bit (busnum, busmap.busmap);
 		bus->busnum = busnum;
 	} else {
 		printk (KERN_ERR "%s: too many buses\n", usbcore_name);
 		up(&usb_bus_list_lock);
 		return -E2BIG;
 	}
 	bus->class_dev = class_device_create(usb_host_class, NULL, MKDEV(0,0),
 					     bus->controller, "usb_host%d", busnum);
 	if (IS_ERR(bus->class_dev)) {
 		clear_bit(busnum, busmap.busmap);
 		up(&usb_bus_list_lock);
 		return PTR_ERR(bus->class_dev);
 	}
 	class_set_devdata(bus->class_dev, bus);
 	/* Add it to the local list of buses */
 	list_add (&bus->bus_list, &usb_bus_list);
 	up (&usb_bus_list_lock);
 	usb_notify_add_bus(bus);
 	dev_info (bus->controller, "new USB bus registered, assigned bus number %d\n", bus->busnum);
 	return 0;
 }
 /**
  * usb_deregister_bus - deregisters the USB host controller
  * @bus: pointer to the bus to deregister
  * Context: !in_interrupt()
  *
  * Recycles the bus number, and unlinks the controller from usbcore data
  * structures so that it won't be seen by scanning the bus list.
  */
 static void usb_deregister_bus (struct usb_bus *bus)
 {
 	dev_info (bus->controller, "USB bus %d deregistered\n", bus->busnum);
 	/*
 	 * NOTE: make sure that all the devices are removed by the
 	 * controller code, as well as having it call this when cleaning
 	 * itself up
 	 */
 	down (&usb_bus_list_lock);
 	list_del (&bus->bus_list);
 	up (&usb_bus_list_lock);
 	usb_notify_remove_bus(bus);
 	clear_bit (bus->busnum, busmap.busmap);
 	class_device_unregister(bus->class_dev);
 }
 /**
  * register_root_hub - called by usb_add_hcd() to register a root hub
  * @usb_dev: the usb root hub device to be registered.
  * @hcd: host controller for this root hub
  *
  * This function registers the root hub with the USB subsystem.  It sets up
  * the device properly in the device tree and stores the root_hub pointer
  * in the bus structure, then calls usb_new_device() to register the usb
  * device.  It also assigns the root hub's USB address (always 1).
  */
 static int register_root_hub (struct usb_device *usb_dev,
 		struct usb_hcd *hcd)
 {
 	struct device *parent_dev = hcd->self.controller;
 	const int devnum = 1;
 	int retval;
 	usb_dev->devnum = devnum;
 	usb_dev->bus->devnum_next = devnum + 1;
 	memset (&usb_dev->bus->devmap.devicemap, 0,
 			sizeof usb_dev->bus->devmap.devicemap);
 	set_bit (devnum, usb_dev->bus->devmap.devicemap);
 	usb_set_device_state(usb_dev, USB_STATE_ADDRESS);
 	down (&usb_bus_list_lock);
 	usb_dev->bus->root_hub = usb_dev;
 	usb_dev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);
 	retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE);
 	if (retval != sizeof usb_dev->descriptor) {
 		usb_dev->bus->root_hub = NULL;
 		up (&usb_bus_list_lock);
 		dev_dbg (parent_dev, "can't read %s device descriptor %d\n",
 				usb_dev->dev.bus_id, retval);
 		return (retval < 0) ? retval : -EMSGSIZE;
 	}
 	retval = usb_new_device (usb_dev);
 	if (retval) {
 		usb_dev->bus->root_hub = NULL;
 		dev_err (parent_dev, "can't register root hub for %s, %d\n",
 				usb_dev->dev.bus_id, retval);
 	}
 	up (&usb_bus_list_lock);
 	if (retval == 0) {
 		spin_lock_irq (&hcd_root_hub_lock);
 		hcd->rh_registered = 1;
 		spin_unlock_irq (&hcd_root_hub_lock);
 		/* Did the HC die before the root hub was registered? */
 		if (hcd->state == HC_STATE_HALT)
 			usb_hc_died (hcd);	/* This time clean up */
 	}
 	return retval;
 }
 void usb_enable_root_hub_irq (struct usb_bus *bus)
 {
 	struct usb_hcd *hcd;
 	hcd = container_of (bus, struct usb_hcd, self);
 	if (hcd->driver->hub_irq_enable && !hcd->poll_rh &&
 			hcd->state != HC_STATE_HALT)
 		hcd->driver->hub_irq_enable (hcd);
 }
 /*-------------------------------------------------------------------------*/
 /**
  * usb_calc_bus_time - approximate periodic transaction time in nanoseconds
  * @speed: from dev->speed; USB_SPEED_{LOW,FULL,HIGH}
  * @is_input: true iff the transaction sends data to the host
  * @isoc: true for isochronous transactions, false for interrupt ones
  * @bytecount: how many bytes in the transaction.
  *
  * Returns approximate bus time in nanoseconds for a periodic transaction.
  * See USB 2.0 spec section 5.11.3; only periodic transfers need to be
  * scheduled in software, this function is only used for such scheduling.
  */
 long usb_calc_bus_time (int speed, int is_input, int isoc, int bytecount)
 {
 	unsigned long	tmp;
 	switch (speed) {
 	case USB_SPEED_LOW: 	/* INTR only */
 		if (is_input) {
 			tmp = (67667L * (31L + 10L * BitTime (bytecount))) / 1000L;
 			return (64060L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
 		} else {
 			tmp = (66700L * (31L + 10L * BitTime (bytecount))) / 1000L;
 			return (64107L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
 		}
 	case USB_SPEED_FULL:	/* ISOC or INTR */
 		if (isoc) {
 			tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
 			return (((is_input) ? 7268L : 6265L) + BW_HOST_DELAY + tmp);
 		} else {
 			tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
 			return (9107L + BW_HOST_DELAY + tmp);
 		}
 	case USB_SPEED_HIGH:	/* ISOC or INTR */
 		// FIXME adjust for input vs output
 		if (isoc)
 			tmp = HS_NSECS_ISO (bytecount);
 		else
 			tmp = HS_NSECS (bytecount);
 		return tmp;
 	default:
 		pr_debug ("%s: bogus device speed!\n", usbcore_name);
 		return -1;
 	}
 }
 EXPORT_SYMBOL (usb_calc_bus_time);
 /*
  * usb_check_bandwidth():
  *
  * old_alloc is from host_controller->bandwidth_allocated in microseconds;
  * bustime is from calc_bus_time(), but converted to microseconds.
  *
  * returns <bustime in us> if successful,
  * or -ENOSPC if bandwidth request fails.
  *
  * FIXME:
  * This initial implementation does not use Endpoint.bInterval
  * in managing bandwidth allocation.
  * It probably needs to be expanded to use Endpoint.bInterval.
  * This can be done as a later enhancement (correction).
  *
  * This will also probably require some kind of
  * frame allocation tracking...meaning, for example,
  * that if multiple drivers request interrupts every 10 USB frames,
  * they don't all have to be allocated at
  * frame numbers N, N+10, N+20, etc.  Some of them could be at
  * N+11, N+21, N+31, etc., and others at
  * N+12, N+22, N+32, etc.
  *
  * Similarly for isochronous transfers...
  *
  * Individual HCDs can schedule more directly ... this logic
  * is not correct for high speed transfers.
  */
 int usb_check_bandwidth (struct usb_device *dev, struct urb *urb)
 {
 	unsigned int	pipe = urb->pipe;
 	long		bustime;
 	int		is_in = usb_pipein (pipe);
 	int		is_iso = usb_pipeisoc (pipe);
 	int		old_alloc = dev->bus->bandwidth_allocated;
 	int		new_alloc;
 	bustime = NS_TO_US (usb_calc_bus_time (dev->speed, is_in, is_iso,
 			usb_maxpacket (dev, pipe, !is_in)));
 	if (is_iso)
 		bustime /= urb->number_of_packets;
 	new_alloc = old_alloc + (int) bustime;
 	if (new_alloc > FRAME_TIME_MAX_USECS_ALLOC) {
 #ifdef	DEBUG
 		char	*mode =
 #ifdef CONFIG_USB_BANDWIDTH
 			"";
 #else
 			"would have ";
 #endif
 		dev_dbg (&dev->dev, "usb_check_bandwidth %sFAILED: %d + %ld = %d usec\n",
 			mode, old_alloc, bustime, new_alloc);
 #endif
 #ifdef CONFIG_USB_BANDWIDTH
 		bustime = -ENOSPC;	/* report error */
 #endif
 	}
 	return bustime;
 }
 EXPORT_SYMBOL (usb_check_bandwidth);
 /**
  * usb_claim_bandwidth - records bandwidth for a periodic transfer
  * @dev: source/target of request
  * @urb: request (urb->dev == dev)
  * @bustime: bandwidth consumed, in (average) microseconds per frame
  * @isoc: true iff the request is isochronous
  *
  * Bus bandwidth reservations are recorded purely for diagnostic purposes.
  * HCDs are expected not to overcommit periodic bandwidth, and to record such
  * reservations whenever endpoints are added to the periodic schedule.
  *
  * FIXME averaging per-frame is suboptimal.  Better to sum over the HCD's
  * entire periodic schedule ... 32 frames for OHCI, 1024 for UHCI, settable
  * for EHCI (256/512/1024 frames, default 1024) and have the bus expose how
  * large its periodic schedule is.
  */
 void usb_claim_bandwidth (struct usb_device *dev, struct urb *urb, int bustime, int isoc)
 {
 	dev->bus->bandwidth_allocated += bustime;
 	if (isoc)
 		dev->bus->bandwidth_isoc_reqs++;
 	else
 		dev->bus->bandwidth_int_reqs++;
 	urb->bandwidth = bustime;
 #ifdef USB_BANDWIDTH_MESSAGES
 	dev_dbg (&dev->dev, "bandwidth alloc increased by %d (%s) to %d for %d requesters\n",
 		bustime,
 		isoc ? "ISOC" : "INTR",
 		dev->bus->bandwidth_allocated,
 		dev->bus->bandwidth_int_reqs + dev->bus->bandwidth_isoc_reqs);
 #endif
 }
 EXPORT_SYMBOL (usb_claim_bandwidth);
 /**
  * usb_release_bandwidth - reverses effect of usb_claim_bandwidth()
  * @dev: source/target of request
  * @urb: request (urb->dev == dev)
  * @isoc: true iff the request is isochronous
  *
  * This records that previously allocated bandwidth has been released.
  * Bandwidth is released when endpoints are removed from the host controller's
  * periodic schedule.
  */
 void usb_release_bandwidth (struct usb_device *dev, struct urb *urb, int isoc)
 {
 	dev->bus->bandwidth_allocated -= urb->bandwidth;
 	if (isoc)
 		dev->bus->bandwidth_isoc_reqs--;
 	else
 		dev->bus->bandwidth_int_reqs--;
 #ifdef USB_BANDWIDTH_MESSAGES
 	dev_dbg (&dev->dev, "bandwidth alloc reduced by %d (%s) to %d for %d requesters\n",
 		urb->bandwidth,
 		isoc ? "ISOC" : "INTR",
 		dev->bus->bandwidth_allocated,
 		dev->bus->bandwidth_int_reqs + dev->bus->bandwidth_isoc_reqs);
 #endif
 	urb->bandwidth = 0;
 }
 EXPORT_SYMBOL (usb_release_bandwidth);
 /*-------------------------------------------------------------------------*/
 /*
  * Generic HC operations.
  */
 /*-------------------------------------------------------------------------*/
 static void urb_unlink (struct urb *urb)
 {
 	unsigned long		flags;
 	/* Release any periodic transfer bandwidth */
 	if (urb->bandwidth)
 		usb_release_bandwidth (urb->dev, urb,
 			usb_pipeisoc (urb->pipe));
 	/* clear all state linking urb to this dev (and hcd) */
 	spin_lock_irqsave (&hcd_data_lock, flags);
 	list_del_init (&urb->urb_list);
 	spin_unlock_irqrestore (&hcd_data_lock, flags);
 	usb_put_dev (urb->dev);
 }
 /* may be called in any context with a valid urb->dev usecount
  * caller surrenders "ownership" of urb
  * expects usb_submit_urb() to have sanity checked and conditioned all
  * inputs in the urb
  */
 static int hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
 {
 	int			status;
 	struct usb_hcd		*hcd = urb->dev->bus->hcpriv;
 	struct usb_host_endpoint *ep;
 	unsigned long		flags;
 	if (!hcd)
 		return -ENODEV;
 	usbmon_urb_submit(&hcd->self, urb);
 	/*
 	 * Atomically queue the urb,  first to our records, then to the HCD.
 	 * Access to urb->status is controlled by urb->lock ... changes on
 	 * i/o completion (normal or fault) or unlinking.
 	 */
 	// FIXME:  verify that quiescing hc works right (RH cleans up)
 	spin_lock_irqsave (&hcd_data_lock, flags);
 	ep = (usb_pipein(urb->pipe) ? urb->dev->ep_in : urb->dev->ep_out)
 			[usb_pipeendpoint(urb->pipe)];
 	if (unlikely (!ep))
 		status = -ENOENT;
 	else if (unlikely (urb->reject))
 		status = -EPERM;
 	else switch (hcd->state) {
 	case HC_STATE_RUNNING:
 	case HC_STATE_RESUMING:
 doit:
 		usb_get_dev (urb->dev);
 		list_add_tail (&urb->urb_list, &ep->urb_list);
 		status = 0;
 		break;
 	case HC_STATE_SUSPENDED:
 		/* HC upstream links (register access, wakeup signaling) can work
 		 * even when the downstream links (and DMA etc) are quiesced; let
 		 * usbcore talk to the root hub.
 		 */
 		if (hcd->self.controller->power.power_state.event == PM_EVENT_ON
 				&& urb->dev->parent == NULL)
 			goto doit;
 		/* FALL THROUGH */
 	default:
 		status = -ESHUTDOWN;
 		break;
 	}
 	spin_unlock_irqrestore (&hcd_data_lock, flags);
 	if (status) {
 		INIT_LIST_HEAD (&urb->urb_list);
 		usbmon_urb_submit_error(&hcd->self, urb, status);
 		return status;
 	}
 	/* increment urb's reference count as part of giving it to the HCD
 	 * (which now controls it).  HCD guarantees that it either returns
 	 * an error or calls giveback(), but not both.
 	 */
 	urb = usb_get_urb (urb);
 	atomic_inc (&urb->use_count);
 	if (urb->dev == hcd->self.root_hub) {
 		/* NOTE:  requirement on hub callers (usbfs and the hub
 		 * driver, for now) that URBs' urb->transfer_buffer be
 		 * valid and usb_buffer_{sync,unmap}() not be needed, since
 		 * they could clobber root hub response data.
 		 */
 		status = rh_urb_enqueue (hcd, urb);
 		goto done;
 	}
 	/* lower level hcd code should use *_dma exclusively,
 	 * unless it uses pio or talks to another transport.
 	 */
 	if (hcd->self.controller->dma_mask) {
 		if (usb_pipecontrol (urb->pipe)
 			&& !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP))
 			urb->setup_dma = dma_map_single (
 					hcd->self.controller,
 					urb->setup_packet,
 					sizeof (struct usb_ctrlrequest),
 					DMA_TO_DEVICE);
 		if (urb->transfer_buffer_length != 0
 			&& !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP))
 			urb->transfer_dma = dma_map_single (
 					hcd->self.controller,
 					urb->transfer_buffer,
 					urb->transfer_buffer_length,
 					usb_pipein (urb->pipe)
 					    ? DMA_FROM_DEVICE
 					    : DMA_TO_DEVICE);
 	}
 	status = hcd->driver->urb_enqueue (hcd, ep, urb, mem_flags);
 done:
 	if (unlikely (status)) {
 		urb_unlink (urb);
 		atomic_dec (&urb->use_count);
 		if (urb->reject)
 			wake_up (&usb_kill_urb_queue);
 		usb_put_urb (urb);
 		usbmon_urb_submit_error(&hcd->self, urb, status);
 	}
 	return status;
 }
 /*-------------------------------------------------------------------------*/
 /* called in any context */
 static int hcd_get_frame_number (struct usb_device *udev)
 {
 	struct usb_hcd	*hcd = (struct usb_hcd *)udev->bus->hcpriv;
 	if (!HC_IS_RUNNING (hcd->state))
 		return -ESHUTDOWN;
 	return hcd->driver->get_frame_number (hcd);
 }
 /*-------------------------------------------------------------------------*/
 /* this makes the hcd giveback() the urb more quickly, by kicking it
  * off hardware queues (which may take a while) and returning it as
  * soon as practical.  we've already set up the urb's return status,
  * but we can't know if the callback completed already.
  */
 static int
 unlink1 (struct usb_hcd *hcd, struct urb *urb)
 {
 	int		value;
 	if (urb->dev == hcd->self.root_hub)
 		value = usb_rh_urb_dequeue (hcd, urb);
 	else {
 		/* The only reason an HCD might fail this call is if
 		 * it has not yet fully queued the urb to begin with.
 		 * Such failures should be harmless. */
 		value = hcd->driver->urb_dequeue (hcd, urb);
 	}
 	if (value != 0)
 		dev_dbg (hcd->self.controller, "dequeue %p --> %d\n",
 				urb, value);
 	return value;
 }
 /*
  * called in any context
  *
  * caller guarantees urb won't be recycled till both unlink()
  * and the urb's completion function return
  */
 static int hcd_unlink_urb (struct urb *urb, int status)
 {
 	struct usb_host_endpoint	*ep;
 	struct usb_hcd			*hcd = NULL;
 	struct device			*sys = NULL;
 	unsigned long			flags;
 	struct list_head		*tmp;
 	int				retval;
 	if (!urb)
 		return -EINVAL;
 	if (!urb->dev || !urb->dev->bus)
 		return -ENODEV;
 	ep = (usb_pipein(urb->pipe) ? urb->dev->ep_in : urb->dev->ep_out)
 			[usb_pipeendpoint(urb->pipe)];
 	if (!ep)
 		return -ENODEV;
 	/*
 	 * we contend for urb->status with the hcd core,
 	 * which changes it while returning the urb.
 	 *
 	 * Caller guaranteed that the urb pointer hasn't been freed, and
 	 * that it was submitted.  But as a rule it can't know whether or
 	 * not it's already been unlinked ... so we respect the reversed
 	 * lock sequence needed for the usb_hcd_giveback_urb() code paths
 	 * (urb lock, then hcd_data_lock) in case some other CPU is now
 	 * unlinking it.
 	 */
 	spin_lock_irqsave (&urb->lock, flags);
 	spin_lock (&hcd_data_lock);
 	sys = &urb->dev->dev;
 	hcd = urb->dev->bus->hcpriv;
 	if (hcd == NULL) {
 		retval = -ENODEV;
 		goto done;
 	}
 	/* insist the urb is still queued */
 	list_for_each(tmp, &ep->urb_list) {
 		if (tmp == &urb->urb_list)
 			break;
 	}
 	if (tmp != &urb->urb_list) {
 		retval = -EIDRM;
 		goto done;
 	}
 	/* Any status except -EINPROGRESS means something already started to
 	 * unlink this URB from the hardware.  So there's no more work to do.
 	 */
 	if (urb->status != -EINPROGRESS) {
 		retval = -EBUSY;
 		goto done;
 	}
 	/* IRQ setup can easily be broken so that USB controllers
 	 * never get completion IRQs ... maybe even the ones we need to
 	 * finish unlinking the initial failed usb_set_address()
 	 * or device descriptor fetch.
 	 */
 	if (!test_bit(HCD_FLAG_SAW_IRQ, &hcd->flags)
 	    && hcd->self.root_hub != urb->dev) {
 		dev_warn (hcd->self.controller, "Unlink after no-IRQ?  "
 			"Controller is probably using the wrong IRQ."
 			"\n");
 		set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
 	}
 	urb->status = status;
 	spin_unlock (&hcd_data_lock);
 	spin_unlock_irqrestore (&urb->lock, flags);
 	retval = unlink1 (hcd, urb);
 	if (retval == 0)
 		retval = -EINPROGRESS;
 	return retval;
 done:
 	spin_unlock (&hcd_data_lock);
 	spin_unlock_irqrestore (&urb->lock, flags);
 	if (retval != -EIDRM && sys && sys->driver)
 		dev_dbg (sys, "hcd_unlink_urb %p fail %d\n", urb, retval);
 	return retval;
 }
 /*-------------------------------------------------------------------------*/
 /* disables the endpoint: cancels any pending urbs, then synchronizes with
  * the hcd to make sure all endpoint state is gone from hardware. use for
  * set_configuration, set_interface, driver removal, physical disconnect.
  *
  * example:  a qh stored in ep->hcpriv, holding state related to endpoint
  * type, maxpacket size, toggle, halt status, and scheduling.
  */
 static void
 hcd_endpoint_disable (struct usb_device *udev, struct usb_host_endpoint *ep)
 {
 	struct usb_hcd		*hcd;
 	struct urb		*urb;
 	hcd = udev->bus->hcpriv;
 	WARN_ON (!HC_IS_RUNNING (hcd->state) && hcd->state != HC_STATE_HALT &&
 			udev->state != USB_STATE_NOTATTACHED);
 	local_irq_disable ();
 	/* FIXME move most of this into message.c as part of its
 	 * endpoint disable logic
 	 */
 	/* ep is already gone from udev->ep_{in,out}[]; no more submits */
 rescan:
 	spin_lock (&hcd_data_lock);
 	list_for_each_entry (urb, &ep->urb_list, urb_list) {
 		int	tmp;
 		/* another cpu may be in hcd, spinning on hcd_data_lock
 		 * to giveback() this urb.  the races here should be
 		 * small, but a full fix needs a new "can't submit"
 		 * urb state.
 		 * FIXME urb->reject should allow that...
 		 */
 		if (urb->status != -EINPROGRESS)
 			continue;
 		usb_get_urb (urb);
 		spin_unlock (&hcd_data_lock);
 		spin_lock (&urb->lock);
 		tmp = urb->status;
 		if (tmp == -EINPROGRESS)
 			urb->status = -ESHUTDOWN;
 		spin_unlock (&urb->lock);
 		/* kick hcd unless it's already returning this */
 		if (tmp == -EINPROGRESS) {
 			tmp = urb->pipe;
 			unlink1 (hcd, urb);
 			dev_dbg (hcd->self.controller,
 				"shutdown urb %p pipe %08x ep%d%s%s\n",
 				urb, tmp, usb_pipeendpoint (tmp),
 				(tmp & USB_DIR_IN) ? "in" : "out",
 				({ char *s; \
 				 switch (usb_pipetype (tmp)) { \
 				 case PIPE_CONTROL:	s = ""; break; \
 				 case PIPE_BULK:	s = "-bulk"; break; \
 				 case PIPE_INTERRUPT:	s = "-intr"; break; \
 				 default: 		s = "-iso"; break; \
 				}; s;}));
 		}
 		usb_put_urb (urb);
 		/* list contents may have changed */
 		goto rescan;
 	}
 	spin_unlock (&hcd_data_lock);
 	local_irq_enable ();
 	/* synchronize with the hardware, so old configuration state
 	 * clears out immediately (and will be freed).
 	 */
 	might_sleep ();
 	if (hcd->driver->endpoint_disable)
 		hcd->driver->endpoint_disable (hcd, ep);
 }
 /*-------------------------------------------------------------------------*/
 #ifdef	CONFIG_PM
 int hcd_bus_suspend (struct usb_bus *bus)
 {
 	struct usb_hcd		*hcd;
 	int			status;
 	hcd = container_of (bus, struct usb_hcd, self);
 	if (!hcd->driver->bus_suspend)
 		return -ENOENT;
 	hcd->state = HC_STATE_QUIESCING;
 	status = hcd->driver->bus_suspend (hcd);
 	if (status == 0)
 		hcd->state = HC_STATE_SUSPENDED;
 	else
 		dev_dbg(&bus->root_hub->dev, "%s fail, err %d\n",
 				"suspend", status);
 	return status;
 }
 int hcd_bus_resume (struct usb_bus *bus)
 {
 	struct usb_hcd		*hcd;
 	int			status;
 	hcd = container_of (bus, struct usb_hcd, self);
 	if (!hcd->driver->bus_resume)
 		return -ENOENT;
 	if (hcd->state == HC_STATE_RUNNING)
 		return 0;
 	hcd->state = HC_STATE_RESUMING;
 	status = hcd->driver->bus_resume (hcd);
 	if (status == 0)
 		hcd->state = HC_STATE_RUNNING;
 	else {
 		dev_dbg(&bus->root_hub->dev, "%s fail, err %d\n",
 				"resume", status);
 		usb_hc_died(hcd);
 	}
 	return status;
 }
 /*
  * usb_hcd_suspend_root_hub - HCD autosuspends downstream ports
  * @hcd: host controller for this root hub
  *
  * This call arranges that usb_hcd_resume_root_hub() is safe to call later;
  * that the HCD's root hub polling is deactivated; and that the root's hub
  * driver is suspended.  HCDs may call this to autosuspend when their root
  * hub's downstream ports are all inactive:  unpowered, disconnected,
  * disabled, or suspended.
  *
  * The HCD will autoresume on device connect change detection (using SRP
  * or a D+/D- pullup).  The HCD also autoresumes on remote wakeup signaling
  * from any ports that are suspended (if that is enabled).  In most cases,
  * overcurrent signaling (on powered ports) will also start autoresume.
  *
  * Always called with IRQs blocked.
  */
 void usb_hcd_suspend_root_hub (struct usb_hcd *hcd)
 {
 	struct urb	*urb;
 	spin_lock (&hcd_root_hub_lock);
 	usb_suspend_root_hub (hcd->self.root_hub);
 	/* force status urb to complete/unlink while suspended */
 	if (hcd->status_urb) {
 		urb = hcd->status_urb;
 		urb->status = -ECONNRESET;
 		urb->hcpriv = NULL;
 		urb->actual_length = 0;
 		del_timer (&hcd->rh_timer);
 		hcd->poll_pending = 0;
 		hcd->status_urb = NULL;
 	} else
 		urb = NULL;
 	spin_unlock (&hcd_root_hub_lock);
 	hcd->state = HC_STATE_SUSPENDED;
 	if (urb)
 		usb_hcd_giveback_urb (hcd, urb, NULL);
 }
 EXPORT_SYMBOL_GPL(usb_hcd_suspend_root_hub);
 /**
  * usb_hcd_resume_root_hub - called by HCD to resume its root hub
  * @hcd: host controller for this root hub
  *
  * The USB host controller calls this function when its root hub is
  * suspended (with the remote wakeup feature enabled) and a remote
  * wakeup request is received.  It queues a request for khubd to
  * resume the root hub (that is, manage its downstream ports again).
  */
 void usb_hcd_resume_root_hub (struct usb_hcd *hcd)
 {
 	unsigned long flags;
 	spin_lock_irqsave (&hcd_root_hub_lock, flags);
 	if (hcd->rh_registered)
 		usb_resume_root_hub (hcd->self.root_hub);
 	spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
 }
 EXPORT_SYMBOL_GPL(usb_hcd_resume_root_hub);
 #endif
 /*-------------------------------------------------------------------------*/
 #ifdef	CONFIG_USB_OTG
 /**
  * usb_bus_start_enum - start immediate enumeration (for OTG)
  * @bus: the bus (must use hcd framework)
  * @port_num: 1-based number of port; usually bus->otg_port
  * Context: in_interrupt()
  *
  * Starts enumeration, with an immediate reset followed later by
  * khubd identifying and possibly configuring the device.
  * This is needed by OTG controller drivers, where it helps meet
  * HNP protocol timing requirements for starting a port reset.
  */
 int usb_bus_start_enum(struct usb_bus *bus, unsigned port_num)
 {
 	struct usb_hcd		*hcd;
 	int			status = -EOPNOTSUPP;
 	/* NOTE: since HNP can't start by grabbing the bus's address0_sem,
 	 * boards with root hubs hooked up to internal devices (instead of
 	 * just the OTG port) may need more attention to resetting...
 	 */
 	hcd = container_of (bus, struct usb_hcd, self);
 	if (port_num && hcd->driver->start_port_reset)
 		status = hcd->driver->start_port_reset(hcd, port_num);
 	/* run khubd shortly after (first) root port reset finishes;
 	 * it may issue others, until at least 50 msecs have passed.
 	 */
 	if (status == 0)
 		mod_timer(&hcd->rh_timer, jiffies + msecs_to_jiffies(10));
 	return status;
 }
 EXPORT_SYMBOL (usb_bus_start_enum);
 #endif
 /*-------------------------------------------------------------------------*/
 /*
  * usb_hcd_operations - adapts usb_bus framework to HCD framework (bus glue)
  */
 static struct usb_operations usb_hcd_operations = {
 	.get_frame_number =	hcd_get_frame_number,
 	.submit_urb =		hcd_submit_urb,
 	.unlink_urb =		hcd_unlink_urb,
 	.buffer_alloc =		hcd_buffer_alloc,
 	.buffer_free =		hcd_buffer_free,
 	.disable =		hcd_endpoint_disable,
 };
 /*-------------------------------------------------------------------------*/
 /**
  * usb_hcd_giveback_urb - return URB from HCD to device driver
  * @hcd: host controller returning the URB
  * @urb: urb being returned to the USB device driver.
  * @regs: pt_regs, passed down to the URB completion handler
  * Context: in_interrupt()
  *
  * This hands the URB from HCD to its USB device driver, using its
  * completion function.  The HCD has freed all per-urb resources
  * (and is done using urb->hcpriv).  It also released all HCD locks;
  * the device driver won't cause problems if it frees, modifies,
  * or resubmits this URB.
  */
 void usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb, struct pt_regs *regs)
 {
 	int at_root_hub;
 	at_root_hub = (urb->dev == hcd->self.root_hub);
 	urb_unlink (urb);
 	/* lower level hcd code should use *_dma exclusively */
 	if (hcd->self.controller->dma_mask && !at_root_hub) {
 		if (usb_pipecontrol (urb->pipe)
 			&& !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP))
 			dma_unmap_single (hcd->self.controller, urb->setup_dma,
 					sizeof (struct usb_ctrlrequest),
 					DMA_TO_DEVICE);
 		if (urb->transfer_buffer_length != 0
 			&& !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP))
 			dma_unmap_single (hcd->self.controller,
 					urb->transfer_dma,
 					urb->transfer_buffer_length,
 					usb_pipein (urb->pipe)
 					    ? DMA_FROM_DEVICE
 					    : DMA_TO_DEVICE);
 	}
 	usbmon_urb_complete (&hcd->self, urb);
 	/* pass ownership to the completion handler */
 	urb->complete (urb, regs);
 	atomic_dec (&urb->use_count);
 	if (unlikely (urb->reject))
 		wake_up (&usb_kill_urb_queue);
 	usb_put_urb (urb);
 }
 EXPORT_SYMBOL (usb_hcd_giveback_urb);
 /*-------------------------------------------------------------------------*/
 /**
  * usb_hcd_irq - hook IRQs to HCD framework (bus glue)
  * @irq: the IRQ being raised
  * @__hcd: pointer to the HCD whose IRQ is being signaled
  * @r: saved hardware registers
  *
  * If the controller isn't HALTed, calls the driver's irq handler.
  * Checks whether the controller is now dead.
  */
 irqreturn_t usb_hcd_irq (int irq, void *__hcd, struct pt_regs * r)
 {
 	struct usb_hcd		*hcd = __hcd;
 	int			start = hcd->state;
 	if (unlikely(start == HC_STATE_HALT ||
 	    !test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
 		return IRQ_NONE;
 	if (hcd->driver->irq (hcd, r) == IRQ_NONE)
 		return IRQ_NONE;
 	set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
 	if (unlikely(hcd->state == HC_STATE_HALT))
 		usb_hc_died (hcd);
 	return IRQ_HANDLED;
 }
 /*-------------------------------------------------------------------------*/
 /**
  * usb_hc_died - report abnormal shutdown of a host controller (bus glue)
  * @hcd: pointer to the HCD representing the controller
  *
  * This is called by bus glue to report a USB host controller that died
  * while operations may still have been pending.  It's called automatically
  * by the PCI glue, so only glue for non-PCI busses should need to call it.
  */
 void usb_hc_died (struct usb_hcd *hcd)
 {
 	unsigned long flags;
 	dev_err (hcd->self.controller, "HC died; cleaning up\n");
 	spin_lock_irqsave (&hcd_root_hub_lock, flags);
 	if (hcd->rh_registered) {
 		hcd->poll_rh = 0;
 		/* make khubd clean up old urbs and devices */
 		usb_set_device_state (hcd->self.root_hub,
 				USB_STATE_NOTATTACHED);
 		usb_kick_khubd (hcd->self.root_hub);
 	}
 	spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
 }
 EXPORT_SYMBOL_GPL (usb_hc_died);
 /*-------------------------------------------------------------------------*/
 static void hcd_release (struct usb_bus *bus)
 {
 	struct usb_hcd *hcd;
 	hcd = container_of(bus, struct usb_hcd, self);
 	kfree(hcd);
 }
 /**
  * usb_create_hcd - create and initialize an HCD structure
  * @driver: HC driver that will use this hcd
  * @dev: device for this HC, stored in hcd->self.controller
  * @bus_name: value to store in hcd->self.bus_name
  * Context: !in_interrupt()
  *
  * Allocate a struct usb_hcd, with extra space at the end for the
  * HC driver's private data.  Initialize the generic members of the
  * hcd structure.
  *
  * If memory is unavailable, returns NULL.
  */
 struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,
 		struct device *dev, char *bus_name)
 {
 	struct usb_hcd *hcd;
 	hcd = kzalloc(sizeof(*hcd) + driver->hcd_priv_size, GFP_KERNEL);
 	if (!hcd) {
 		dev_dbg (dev, "hcd alloc failed\n");
 		return NULL;
 	}
 	dev_set_drvdata(dev, hcd);
 	usb_bus_init(&hcd->self);
 	hcd->self.op = &usb_hcd_operations;
 	hcd->self.hcpriv = hcd;
 	hcd->self.release = &hcd_release;
 	hcd->self.controller = dev;
 	hcd->self.bus_name = bus_name;
 	init_timer(&hcd->rh_timer);
 	hcd->rh_timer.function = rh_timer_func;
 	hcd->rh_timer.data = (unsigned long) hcd;
 	hcd->driver = driver;
 	hcd->product_desc = (driver->product_desc) ? driver->product_desc :
 			"USB Host Controller";
 	return hcd;
 }
 EXPORT_SYMBOL (usb_create_hcd);
 void usb_put_hcd (struct usb_hcd *hcd)
 {
 	dev_set_drvdata(hcd->self.controller, NULL);
 	usb_bus_put(&hcd->self);
 }
 EXPORT_SYMBOL (usb_put_hcd);
 /**
  * usb_add_hcd - finish generic HCD structure initialization and register
  * @hcd: the usb_hcd structure to initialize
  * @irqnum: Interrupt line to allocate
  * @irqflags: Interrupt type flags
  *
  * Finish the remaining parts of generic HCD initialization: allocate the
  * buffers of consistent memory, register the bus, request the IRQ line,
  * and call the driver's reset() and start() routines.
  */
 int usb_add_hcd(struct usb_hcd *hcd,
 		unsigned int irqnum, unsigned long irqflags)
 {
 	int retval;
 	struct usb_device *rhdev;
 	dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
 	set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
 	/* till now HC has been in an indeterminate state ... */
 	if (hcd->driver->reset && (retval = hcd->driver->reset(hcd)) < 0) {
 		dev_err(hcd->self.controller, "can't reset\n");
 		return retval;
 	}
 	if ((retval = hcd_buffer_create(hcd)) != 0) {
 		dev_dbg(hcd->self.controller, "pool alloc failed\n");
 		return retval;
 	}
 	if ((retval = usb_register_bus(&hcd->self)) < 0)
 		goto err_register_bus;
 	if (hcd->driver->irq) {
 		char	buf[8], *bufp = buf;
 #ifdef __sparc__
 		bufp = __irq_itoa(irqnum);
 #else
 		sprintf(buf, "%d", irqnum);
 #endif
 		snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
 				hcd->driver->description, hcd->self.busnum);
 		if ((retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
 				hcd->irq_descr, hcd)) != 0) {
 			dev_err(hcd->self.controller,
 					"request interrupt %s failed\n", bufp);
 			goto err_request_irq;
 		}
 		hcd->irq = irqnum;
 		dev_info(hcd->self.controller, "irq %s, %s 0x%08llx\n", bufp,
 				(hcd->driver->flags & HCD_MEMORY) ?
 					"io mem" : "io base",
 					(unsigned long long)hcd->rsrc_start);
 	} else {
 		hcd->irq = -1;
 		if (hcd->rsrc_start)
 			dev_info(hcd->self.controller, "%s 0x%08llx\n",
 					(hcd->driver->flags & HCD_MEMORY) ?
 					"io mem" : "io base",
 					(unsigned long long)hcd->rsrc_start);
 	}
 	/* Allocate the root hub before calling hcd->driver->start(),
 	 * but don't register it until afterward so that the hardware
 	 * is running.
 	 */
 	if ((rhdev = usb_alloc_dev(NULL, &hcd->self, 0)) == NULL) {
 		dev_err(hcd->self.controller, "unable to allocate root hub\n");
 		retval = -ENOMEM;
 		goto err_allocate_root_hub;
 	}
-	rhdev->speed = (hcd->driver->flags & HCD_USB2) ? USB_SPEED_HIGH :
-			USB_SPEED_FULL;
 	/* Although in principle hcd->driver->start() might need to use rhdev,
 	 * none of the current drivers do.
 	 */
 	if ((retval = hcd->driver->start(hcd)) < 0) {
 		dev_err(hcd->self.controller, "startup error %d\n", retval);
 		goto err_hcd_driver_start;
 	}
 	/* hcd->driver->start() reported can_wakeup, probably with
 	 * assistance from board's boot firmware.
 	 * NOTE:  normal devices won't enable wakeup by default.
 	 */
 	if (hcd->can_wakeup)
 		dev_dbg(hcd->self.controller, "supports USB remote wakeup\n");
 	hcd->remote_wakeup = hcd->can_wakeup;
+	rhdev->speed = (hcd->driver->flags & HCD_USB2) ? USB_SPEED_HIGH :
+			USB_SPEED_FULL;
+	rhdev->bus_mA = min(500u, hcd->power_budget);
 	if ((retval = register_root_hub(rhdev, hcd)) != 0)
 		goto err_register_root_hub;
 	if (hcd->uses_new_polling && hcd->poll_rh)
 		usb_hcd_poll_rh_status(hcd);
 	return retval;
  err_register_root_hub:
 	hcd->driver->stop(hcd);
  err_hcd_driver_start:
 	usb_put_dev(rhdev);
  err_allocate_root_hub:
 	if (hcd->irq >= 0)
 		free_irq(irqnum, hcd);
  err_request_irq:
 	usb_deregister_bus(&hcd->self);
  err_register_bus:
 	hcd_buffer_destroy(hcd);
 	return retval;
 }
 EXPORT_SYMBOL (usb_add_hcd);
 /**
  * usb_remove_hcd - shutdown processing for generic HCDs
  * @hcd: the usb_hcd structure to remove
  * Context: !in_interrupt()
  *
  * Disconnects the root hub, then reverses the effects of usb_add_hcd(),
  * invoking the HCD's stop() method.
  */
 void usb_remove_hcd(struct usb_hcd *hcd)
 {
 	dev_info(hcd->self.controller, "remove, state %x\n", hcd->state);
 	if (HC_IS_RUNNING (hcd->state))
 		hcd->state = HC_STATE_QUIESCING;
 	dev_dbg(hcd->self.controller, "roothub graceful disconnect\n");
 	spin_lock_irq (&hcd_root_hub_lock);
 	hcd->rh_registered = 0;
 	spin_unlock_irq (&hcd_root_hub_lock);
 	down(&usb_bus_list_lock);
 	usb_disconnect(&hcd->self.root_hub);
 	up(&usb_bus_list_lock);
 	hcd->poll_rh = 0;
 	del_timer_sync(&hcd->rh_timer);
 	hcd->driver->stop(hcd);
 	hcd->state = HC_STATE_HALT;
 	if (hcd->irq >= 0)
 		free_irq(hcd->irq, hcd);
 	usb_deregister_bus(&hcd->self);
 	hcd_buffer_destroy(hcd);
 }
 EXPORT_SYMBOL (usb_remove_hcd);
 /*-------------------------------------------------------------------------*/
 #if defined(CONFIG_USB_MON)
 struct usb_mon_operations *mon_ops;
 /*
  * The registration is unlocked.
  * We do it this way because we do not want to lock in hot paths.
  *
  * Notice that the code is minimally error-proof. Because usbmon needs
  * symbols from usbcore, usbcore gets referenced and cannot be unloaded first.
  */
 int usb_mon_register (struct usb_mon_operations *ops)
 {
 	if (mon_ops)
 		return -EBUSY;
 	mon_ops = ops;
 	mb();
 	return 0;
 }
 EXPORT_SYMBOL_GPL (usb_mon_register);
 void usb_mon_deregister (void)
 {
 	if (mon_ops == NULL) {
 		printk(KERN_ERR "USB: monitor was not registered\n");
 		return;
 	}
 	mon_ops = NULL;
 	mb();
 }
 EXPORT_SYMBOL_GPL (usb_mon_deregister);

drivers/usb/core/hub.c

Diff comments View file @ 55c5271

1	/*	1	/*
2	* USB hub driver.	2	* USB hub driver.
3	*	3	*
4	* (C) Copyright 1999 Linus Torvalds	4	* (C) Copyright 1999 Linus Torvalds
5	* (C) Copyright 1999 Johannes Erdfelt	5	* (C) Copyright 1999 Johannes Erdfelt
6	* (C) Copyright 1999 Gregory P. Smith	6	* (C) Copyright 1999 Gregory P. Smith
7	* (C) Copyright 2001 Brad Hards (bhards@bigpond.net.au)	7	* (C) Copyright 2001 Brad Hards (bhards@bigpond.net.au)
8	*	8	*
9	*/	9	*/
10		10
11	#include <linux/config.h>	11	#include <linux/config.h>
12	#include <linux/kernel.h>	12	#include <linux/kernel.h>
13	#include <linux/errno.h>	13	#include <linux/errno.h>
14	#include <linux/module.h>	14	#include <linux/module.h>
15	#include <linux/moduleparam.h>	15	#include <linux/moduleparam.h>
16	#include <linux/completion.h>	16	#include <linux/completion.h>
17	#include <linux/sched.h>	17	#include <linux/sched.h>
18	#include <linux/list.h>	18	#include <linux/list.h>
19	#include <linux/slab.h>	19	#include <linux/slab.h>
20	#include <linux/smp_lock.h>	20	#include <linux/smp_lock.h>
21	#include <linux/ioctl.h>	21	#include <linux/ioctl.h>
22	#include <linux/usb.h>	22	#include <linux/usb.h>
23	#include <linux/usbdevice_fs.h>	23	#include <linux/usbdevice_fs.h>
24	#include <linux/kthread.h>	24	#include <linux/kthread.h>
25		25
26	#include <asm/semaphore.h>	26	#include <asm/semaphore.h>
27	#include <asm/uaccess.h>	27	#include <asm/uaccess.h>
28	#include <asm/byteorder.h>	28	#include <asm/byteorder.h>
29		29
30	#include "usb.h"	30	#include "usb.h"
31	#include "hcd.h"	31	#include "hcd.h"
32	#include "hub.h"	32	#include "hub.h"
33		33
34	/* Protect struct usb_device->state and ->children members	34	/* Protect struct usb_device->state and ->children members
35	* Note: Both are also protected by ->dev.sem, except that ->state can	35	* Note: Both are also protected by ->dev.sem, except that ->state can
36	* change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */	36	* change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */
37	static DEFINE_SPINLOCK(device_state_lock);	37	static DEFINE_SPINLOCK(device_state_lock);
38		38
39	/* khubd's worklist and its lock */	39	/* khubd's worklist and its lock */
40	static DEFINE_SPINLOCK(hub_event_lock);	40	static DEFINE_SPINLOCK(hub_event_lock);
41	static LIST_HEAD(hub_event_list); /* List of hubs needing servicing */	41	static LIST_HEAD(hub_event_list); /* List of hubs needing servicing */
42		42
43	/* Wakes up khubd */	43	/* Wakes up khubd */
44	static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);	44	static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);
45		45
46	static struct task_struct *khubd_task;	46	static struct task_struct *khubd_task;
47		47
48	/* cycle leds on hubs that aren't blinking for attention */	48	/* cycle leds on hubs that aren't blinking for attention */
49	static int blinkenlights = 0;	49	static int blinkenlights = 0;
50	module_param (blinkenlights, bool, S_IRUGO);	50	module_param (blinkenlights, bool, S_IRUGO);
51	MODULE_PARM_DESC (blinkenlights, "true to cycle leds on hubs");	51	MODULE_PARM_DESC (blinkenlights, "true to cycle leds on hubs");
52		52
53	/*	53	/*
54	* As of 2.6.10 we introduce a new USB device initialization scheme which	54	* As of 2.6.10 we introduce a new USB device initialization scheme which
55	* closely resembles the way Windows works. Hopefully it will be compatible	55	* closely resembles the way Windows works. Hopefully it will be compatible
56	* with a wider range of devices than the old scheme. However some previously	56	* with a wider range of devices than the old scheme. However some previously
57	* working devices may start giving rise to "device not accepting address"	57	* working devices may start giving rise to "device not accepting address"
58	* errors; if that happens the user can try the old scheme by adjusting the	58	* errors; if that happens the user can try the old scheme by adjusting the
59	* following module parameters.	59	* following module parameters.
60	*	60	*
61	* For maximum flexibility there are two boolean parameters to control the	61	* For maximum flexibility there are two boolean parameters to control the
62	* hub driver's behavior. On the first initialization attempt, if the	62	* hub driver's behavior. On the first initialization attempt, if the
63	* "old_scheme_first" parameter is set then the old scheme will be used,	63	* "old_scheme_first" parameter is set then the old scheme will be used,
64	* otherwise the new scheme is used. If that fails and "use_both_schemes"	64	* otherwise the new scheme is used. If that fails and "use_both_schemes"
65	* is set, then the driver will make another attempt, using the other scheme.	65	* is set, then the driver will make another attempt, using the other scheme.
66	*/	66	*/
67	static int old_scheme_first = 0;	67	static int old_scheme_first = 0;
68	module_param(old_scheme_first, bool, S_IRUGO \| S_IWUSR);	68	module_param(old_scheme_first, bool, S_IRUGO \| S_IWUSR);
69	MODULE_PARM_DESC(old_scheme_first,	69	MODULE_PARM_DESC(old_scheme_first,
70	"start with the old device initialization scheme");	70	"start with the old device initialization scheme");
71		71
72	static int use_both_schemes = 1;	72	static int use_both_schemes = 1;
73	module_param(use_both_schemes, bool, S_IRUGO \| S_IWUSR);	73	module_param(use_both_schemes, bool, S_IRUGO \| S_IWUSR);
74	MODULE_PARM_DESC(use_both_schemes,	74	MODULE_PARM_DESC(use_both_schemes,
75	"try the other device initialization scheme if the "	75	"try the other device initialization scheme if the "
76	"first one fails");	76	"first one fails");
77		77
78		78
79	#ifdef DEBUG	79	#ifdef DEBUG
80	static inline char *portspeed (int portstatus)	80	static inline char *portspeed (int portstatus)
81	{	81	{
82	if (portstatus & (1 << USB_PORT_FEAT_HIGHSPEED))	82	if (portstatus & (1 << USB_PORT_FEAT_HIGHSPEED))
83	return "480 Mb/s";	83	return "480 Mb/s";
84	else if (portstatus & (1 << USB_PORT_FEAT_LOWSPEED))	84	else if (portstatus & (1 << USB_PORT_FEAT_LOWSPEED))
85	return "1.5 Mb/s";	85	return "1.5 Mb/s";
86	else	86	else
87	return "12 Mb/s";	87	return "12 Mb/s";
88	}	88	}
89	#endif	89	#endif
90		90
91	/* Note that hdev or one of its children must be locked! */	91	/* Note that hdev or one of its children must be locked! */
92	static inline struct usb_hub hdev_to_hub(struct usb_device hdev)	92	static inline struct usb_hub hdev_to_hub(struct usb_device hdev)
93	{	93	{
94	return usb_get_intfdata(hdev->actconfig->interface[0]);	94	return usb_get_intfdata(hdev->actconfig->interface[0]);
95	}	95	}
96		96
97	/* USB 2.0 spec Section 11.24.4.5 */	97	/* USB 2.0 spec Section 11.24.4.5 */
98	static int get_hub_descriptor(struct usb_device hdev, void data, int size)	98	static int get_hub_descriptor(struct usb_device hdev, void data, int size)
99	{	99	{
100	int i, ret;	100	int i, ret;
101		101
102	for (i = 0; i < 3; i++) {	102	for (i = 0; i < 3; i++) {
103	ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),	103	ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
104	USB_REQ_GET_DESCRIPTOR, USB_DIR_IN \| USB_RT_HUB,	104	USB_REQ_GET_DESCRIPTOR, USB_DIR_IN \| USB_RT_HUB,
105	USB_DT_HUB << 8, 0, data, size,	105	USB_DT_HUB << 8, 0, data, size,
106	USB_CTRL_GET_TIMEOUT);	106	USB_CTRL_GET_TIMEOUT);
107	if (ret >= (USB_DT_HUB_NONVAR_SIZE + 2))	107	if (ret >= (USB_DT_HUB_NONVAR_SIZE + 2))
108	return ret;	108	return ret;
109	}	109	}
110	return -EINVAL;	110	return -EINVAL;
111	}	111	}
112		112
113	/*	113	/*
114	* USB 2.0 spec Section 11.24.2.1	114	* USB 2.0 spec Section 11.24.2.1
115	*/	115	*/
116	static int clear_hub_feature(struct usb_device *hdev, int feature)	116	static int clear_hub_feature(struct usb_device *hdev, int feature)
117	{	117	{
118	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),	118	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
119	USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000);	119	USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000);
120	}	120	}
121		121
122	/*	122	/*
123	* USB 2.0 spec Section 11.24.2.2	123	* USB 2.0 spec Section 11.24.2.2
124	*/	124	*/
125	static int clear_port_feature(struct usb_device *hdev, int port1, int feature)	125	static int clear_port_feature(struct usb_device *hdev, int port1, int feature)
126	{	126	{
127	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),	127	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
128	USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,	128	USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
129	NULL, 0, 1000);	129	NULL, 0, 1000);
130	}	130	}
131		131
132	/*	132	/*
133	* USB 2.0 spec Section 11.24.2.13	133	* USB 2.0 spec Section 11.24.2.13
134	*/	134	*/
135	static int set_port_feature(struct usb_device *hdev, int port1, int feature)	135	static int set_port_feature(struct usb_device *hdev, int port1, int feature)
136	{	136	{
137	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),	137	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
138	USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,	138	USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
139	NULL, 0, 1000);	139	NULL, 0, 1000);
140	}	140	}
141		141
142	/*	142	/*
143	* USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7	143	* USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7
144	* for info about using port indicators	144	* for info about using port indicators
145	*/	145	*/
146	static void set_port_led(	146	static void set_port_led(
147	struct usb_hub *hub,	147	struct usb_hub *hub,
148	int port1,	148	int port1,
149	int selector	149	int selector
150	)	150	)
151	{	151	{
152	int status = set_port_feature(hub->hdev, (selector << 8) \| port1,	152	int status = set_port_feature(hub->hdev, (selector << 8) \| port1,
153	USB_PORT_FEAT_INDICATOR);	153	USB_PORT_FEAT_INDICATOR);
154	if (status < 0)	154	if (status < 0)
155	dev_dbg (hub->intfdev,	155	dev_dbg (hub->intfdev,
156	"port %d indicator %s status %d\n",	156	"port %d indicator %s status %d\n",
157	port1,	157	port1,
158	({ char *s; switch (selector) {	158	({ char *s; switch (selector) {
159	case HUB_LED_AMBER: s = "amber"; break;	159	case HUB_LED_AMBER: s = "amber"; break;
160	case HUB_LED_GREEN: s = "green"; break;	160	case HUB_LED_GREEN: s = "green"; break;
161	case HUB_LED_OFF: s = "off"; break;	161	case HUB_LED_OFF: s = "off"; break;
162	case HUB_LED_AUTO: s = "auto"; break;	162	case HUB_LED_AUTO: s = "auto"; break;
163	default: s = "??"; break;	163	default: s = "??"; break;
164	}; s; }),	164	}; s; }),
165	status);	165	status);
166	}	166	}
167		167
168	#define LED_CYCLE_PERIOD ((2*HZ)/3)	168	#define LED_CYCLE_PERIOD ((2*HZ)/3)
169		169
170	static void led_work (void *__hub)	170	static void led_work (void *__hub)
171	{	171	{
172	struct usb_hub *hub = __hub;	172	struct usb_hub *hub = __hub;
173	struct usb_device *hdev = hub->hdev;	173	struct usb_device *hdev = hub->hdev;
174	unsigned i;	174	unsigned i;
175	unsigned changed = 0;	175	unsigned changed = 0;
176	int cursor = -1;	176	int cursor = -1;
177		177
178	if (hdev->state != USB_STATE_CONFIGURED \|\| hub->quiescing)	178	if (hdev->state != USB_STATE_CONFIGURED \|\| hub->quiescing)
179	return;	179	return;
180		180
181	for (i = 0; i < hub->descriptor->bNbrPorts; i++) {	181	for (i = 0; i < hub->descriptor->bNbrPorts; i++) {
182	unsigned selector, mode;	182	unsigned selector, mode;
183		183
184	/* 30%-50% duty cycle */	184	/* 30%-50% duty cycle */
185		185
186	switch (hub->indicator[i]) {	186	switch (hub->indicator[i]) {
187	/* cycle marker */	187	/* cycle marker */
188	case INDICATOR_CYCLE:	188	case INDICATOR_CYCLE:
189	cursor = i;	189	cursor = i;
190	selector = HUB_LED_AUTO;	190	selector = HUB_LED_AUTO;
191	mode = INDICATOR_AUTO;	191	mode = INDICATOR_AUTO;
192	break;	192	break;
193	/* blinking green = sw attention */	193	/* blinking green = sw attention */
194	case INDICATOR_GREEN_BLINK:	194	case INDICATOR_GREEN_BLINK:
195	selector = HUB_LED_GREEN;	195	selector = HUB_LED_GREEN;
196	mode = INDICATOR_GREEN_BLINK_OFF;	196	mode = INDICATOR_GREEN_BLINK_OFF;
197	break;	197	break;
198	case INDICATOR_GREEN_BLINK_OFF:	198	case INDICATOR_GREEN_BLINK_OFF:
199	selector = HUB_LED_OFF;	199	selector = HUB_LED_OFF;
200	mode = INDICATOR_GREEN_BLINK;	200	mode = INDICATOR_GREEN_BLINK;
201	break;	201	break;
202	/* blinking amber = hw attention */	202	/* blinking amber = hw attention */
203	case INDICATOR_AMBER_BLINK:	203	case INDICATOR_AMBER_BLINK:
204	selector = HUB_LED_AMBER;	204	selector = HUB_LED_AMBER;
205	mode = INDICATOR_AMBER_BLINK_OFF;	205	mode = INDICATOR_AMBER_BLINK_OFF;
206	break;	206	break;
207	case INDICATOR_AMBER_BLINK_OFF:	207	case INDICATOR_AMBER_BLINK_OFF:
208	selector = HUB_LED_OFF;	208	selector = HUB_LED_OFF;
209	mode = INDICATOR_AMBER_BLINK;	209	mode = INDICATOR_AMBER_BLINK;
210	break;	210	break;
211	/* blink green/amber = reserved */	211	/* blink green/amber = reserved */
212	case INDICATOR_ALT_BLINK:	212	case INDICATOR_ALT_BLINK:
213	selector = HUB_LED_GREEN;	213	selector = HUB_LED_GREEN;
214	mode = INDICATOR_ALT_BLINK_OFF;	214	mode = INDICATOR_ALT_BLINK_OFF;
215	break;	215	break;
216	case INDICATOR_ALT_BLINK_OFF:	216	case INDICATOR_ALT_BLINK_OFF:
217	selector = HUB_LED_AMBER;	217	selector = HUB_LED_AMBER;
218	mode = INDICATOR_ALT_BLINK;	218	mode = INDICATOR_ALT_BLINK;
219	break;	219	break;
220	default:	220	default:
221	continue;	221	continue;
222	}	222	}
223	if (selector != HUB_LED_AUTO)	223	if (selector != HUB_LED_AUTO)
224	changed = 1;	224	changed = 1;
225	set_port_led(hub, i + 1, selector);	225	set_port_led(hub, i + 1, selector);
226	hub->indicator[i] = mode;	226	hub->indicator[i] = mode;
227	}	227	}
228	if (!changed && blinkenlights) {	228	if (!changed && blinkenlights) {
229	cursor++;	229	cursor++;
230	cursor %= hub->descriptor->bNbrPorts;	230	cursor %= hub->descriptor->bNbrPorts;
231	set_port_led(hub, cursor + 1, HUB_LED_GREEN);	231	set_port_led(hub, cursor + 1, HUB_LED_GREEN);
232	hub->indicator[cursor] = INDICATOR_CYCLE;	232	hub->indicator[cursor] = INDICATOR_CYCLE;
233	changed++;	233	changed++;
234	}	234	}
235	if (changed)	235	if (changed)
236	schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);	236	schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
237	}	237	}
238		238
239	/* use a short timeout for hub/port status fetches */	239	/* use a short timeout for hub/port status fetches */
240	#define USB_STS_TIMEOUT 1000	240	#define USB_STS_TIMEOUT 1000
241	#define USB_STS_RETRIES 5	241	#define USB_STS_RETRIES 5
242		242
243	/*	243	/*
244	* USB 2.0 spec Section 11.24.2.6	244	* USB 2.0 spec Section 11.24.2.6
245	*/	245	*/
246	static int get_hub_status(struct usb_device *hdev,	246	static int get_hub_status(struct usb_device *hdev,
247	struct usb_hub_status *data)	247	struct usb_hub_status *data)
248	{	248	{
249	int i, status = -ETIMEDOUT;	249	int i, status = -ETIMEDOUT;
250		250
251	for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) {	251	for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) {
252	status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),	252	status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
253	USB_REQ_GET_STATUS, USB_DIR_IN \| USB_RT_HUB, 0, 0,	253	USB_REQ_GET_STATUS, USB_DIR_IN \| USB_RT_HUB, 0, 0,
254	data, sizeof(*data), USB_STS_TIMEOUT);	254	data, sizeof(*data), USB_STS_TIMEOUT);
255	}	255	}
256	return status;	256	return status;
257	}	257	}
258		258
259	/*	259	/*
260	* USB 2.0 spec Section 11.24.2.7	260	* USB 2.0 spec Section 11.24.2.7
261	*/	261	*/
262	static int get_port_status(struct usb_device *hdev, int port1,	262	static int get_port_status(struct usb_device *hdev, int port1,
263	struct usb_port_status *data)	263	struct usb_port_status *data)
264	{	264	{
265	int i, status = -ETIMEDOUT;	265	int i, status = -ETIMEDOUT;
266		266
267	for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) {	267	for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) {
268	status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),	268	status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
269	USB_REQ_GET_STATUS, USB_DIR_IN \| USB_RT_PORT, 0, port1,	269	USB_REQ_GET_STATUS, USB_DIR_IN \| USB_RT_PORT, 0, port1,
270	data, sizeof(*data), USB_STS_TIMEOUT);	270	data, sizeof(*data), USB_STS_TIMEOUT);
271	}	271	}
272	return status;	272	return status;
273	}	273	}
274		274
275	static void kick_khubd(struct usb_hub *hub)	275	static void kick_khubd(struct usb_hub *hub)
276	{	276	{
277	unsigned long flags;	277	unsigned long flags;
278		278
279	spin_lock_irqsave(&hub_event_lock, flags);	279	spin_lock_irqsave(&hub_event_lock, flags);
280	if (list_empty(&hub->event_list)) {	280	if (list_empty(&hub->event_list)) {
281	list_add_tail(&hub->event_list, &hub_event_list);	281	list_add_tail(&hub->event_list, &hub_event_list);
282	wake_up(&khubd_wait);	282	wake_up(&khubd_wait);
283	}	283	}
284	spin_unlock_irqrestore(&hub_event_lock, flags);	284	spin_unlock_irqrestore(&hub_event_lock, flags);
285	}	285	}
286		286
287	void usb_kick_khubd(struct usb_device *hdev)	287	void usb_kick_khubd(struct usb_device *hdev)
288	{	288	{
289	kick_khubd(hdev_to_hub(hdev));	289	kick_khubd(hdev_to_hub(hdev));
290	}	290	}
291		291
292		292
293	/* completion function, fires on port status changes and various faults */	293	/* completion function, fires on port status changes and various faults */
294	static void hub_irq(struct urb urb, struct pt_regs regs)	294	static void hub_irq(struct urb urb, struct pt_regs regs)
295	{	295	{
296	struct usb_hub hub = (struct usb_hub )urb->context;	296	struct usb_hub hub = (struct usb_hub )urb->context;
297	int status;	297	int status;
298	int i;	298	int i;
299	unsigned long bits;	299	unsigned long bits;
300		300
301	switch (urb->status) {	301	switch (urb->status) {
302	case -ENOENT: /* synchronous unlink */	302	case -ENOENT: /* synchronous unlink */
303	case -ECONNRESET: /* async unlink */	303	case -ECONNRESET: /* async unlink */
304	case -ESHUTDOWN: /* hardware going away */	304	case -ESHUTDOWN: /* hardware going away */
305	return;	305	return;
306		306
307	default: /* presumably an error */	307	default: /* presumably an error */
308	/* Cause a hub reset after 10 consecutive errors */	308	/* Cause a hub reset after 10 consecutive errors */
309	dev_dbg (hub->intfdev, "transfer --> %d\n", urb->status);	309	dev_dbg (hub->intfdev, "transfer --> %d\n", urb->status);
310	if ((++hub->nerrors < 10) \|\| hub->error)	310	if ((++hub->nerrors < 10) \|\| hub->error)
311	goto resubmit;	311	goto resubmit;
312	hub->error = urb->status;	312	hub->error = urb->status;
313	/* FALL THROUGH */	313	/* FALL THROUGH */
314		314
315	/* let khubd handle things */	315	/* let khubd handle things */
316	case 0: /* we got data: port status changed */	316	case 0: /* we got data: port status changed */
317	bits = 0;	317	bits = 0;
318	for (i = 0; i < urb->actual_length; ++i)	318	for (i = 0; i < urb->actual_length; ++i)
319	bits \|= ((unsigned long) ((*hub->buffer)[i]))	319	bits \|= ((unsigned long) ((*hub->buffer)[i]))
320	<< (i*8);	320	<< (i*8);
321	hub->event_bits[0] = bits;	321	hub->event_bits[0] = bits;
322	break;	322	break;
323	}	323	}
324		324
325	hub->nerrors = 0;	325	hub->nerrors = 0;
326		326
327	/* Something happened, let khubd figure it out */	327	/* Something happened, let khubd figure it out */
328	kick_khubd(hub);	328	kick_khubd(hub);
329		329
330	resubmit:	330	resubmit:
331	if (hub->quiescing)	331	if (hub->quiescing)
332	return;	332	return;
333		333
334	if ((status = usb_submit_urb (hub->urb, GFP_ATOMIC)) != 0	334	if ((status = usb_submit_urb (hub->urb, GFP_ATOMIC)) != 0
335	&& status != -ENODEV && status != -EPERM)	335	&& status != -ENODEV && status != -EPERM)
336	dev_err (hub->intfdev, "resubmit --> %d\n", status);	336	dev_err (hub->intfdev, "resubmit --> %d\n", status);
337	}	337	}
338		338
339	/* USB 2.0 spec Section 11.24.2.3 */	339	/* USB 2.0 spec Section 11.24.2.3 */
340	static inline int	340	static inline int
341	hub_clear_tt_buffer (struct usb_device *hdev, u16 devinfo, u16 tt)	341	hub_clear_tt_buffer (struct usb_device *hdev, u16 devinfo, u16 tt)
342	{	342	{
343	return usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),	343	return usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
344	HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo,	344	HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo,
345	tt, NULL, 0, 1000);	345	tt, NULL, 0, 1000);
346	}	346	}
347		347
348	/*	348	/*
349	* enumeration blocks khubd for a long time. we use keventd instead, since	349	* enumeration blocks khubd for a long time. we use keventd instead, since
350	* long blocking there is the exception, not the rule. accordingly, HCDs	350	* long blocking there is the exception, not the rule. accordingly, HCDs
351	* talking to TTs must queue control transfers (not just bulk and iso), so	351	* talking to TTs must queue control transfers (not just bulk and iso), so
352	* both can talk to the same hub concurrently.	352	* both can talk to the same hub concurrently.
353	*/	353	*/
354	static void hub_tt_kevent (void *arg)	354	static void hub_tt_kevent (void *arg)
355	{	355	{
356	struct usb_hub *hub = arg;	356	struct usb_hub *hub = arg;
357	unsigned long flags;	357	unsigned long flags;
358		358
359	spin_lock_irqsave (&hub->tt.lock, flags);	359	spin_lock_irqsave (&hub->tt.lock, flags);
360	while (!list_empty (&hub->tt.clear_list)) {	360	while (!list_empty (&hub->tt.clear_list)) {
361	struct list_head *temp;	361	struct list_head *temp;
362	struct usb_tt_clear *clear;	362	struct usb_tt_clear *clear;
363	struct usb_device *hdev = hub->hdev;	363	struct usb_device *hdev = hub->hdev;
364	int status;	364	int status;
365		365
366	temp = hub->tt.clear_list.next;	366	temp = hub->tt.clear_list.next;
367	clear = list_entry (temp, struct usb_tt_clear, clear_list);	367	clear = list_entry (temp, struct usb_tt_clear, clear_list);
368	list_del (&clear->clear_list);	368	list_del (&clear->clear_list);
369		369
370	/* drop lock so HCD can concurrently report other TT errors */	370	/* drop lock so HCD can concurrently report other TT errors */
371	spin_unlock_irqrestore (&hub->tt.lock, flags);	371	spin_unlock_irqrestore (&hub->tt.lock, flags);
372	status = hub_clear_tt_buffer (hdev, clear->devinfo, clear->tt);	372	status = hub_clear_tt_buffer (hdev, clear->devinfo, clear->tt);
373	spin_lock_irqsave (&hub->tt.lock, flags);	373	spin_lock_irqsave (&hub->tt.lock, flags);
374		374
375	if (status)	375	if (status)
376	dev_err (&hdev->dev,	376	dev_err (&hdev->dev,
377	"clear tt %d (%04x) error %d\n",	377	"clear tt %d (%04x) error %d\n",
378	clear->tt, clear->devinfo, status);	378	clear->tt, clear->devinfo, status);
379	kfree(clear);	379	kfree(clear);
380	}	380	}
381	spin_unlock_irqrestore (&hub->tt.lock, flags);	381	spin_unlock_irqrestore (&hub->tt.lock, flags);
382	}	382	}
383		383
384	/**	384	/**
385	* usb_hub_tt_clear_buffer - clear control/bulk TT state in high speed hub	385	* usb_hub_tt_clear_buffer - clear control/bulk TT state in high speed hub
386	* @udev: the device whose split transaction failed	386	* @udev: the device whose split transaction failed
387	* @pipe: identifies the endpoint of the failed transaction	387	* @pipe: identifies the endpoint of the failed transaction
388	*	388	*
389	* High speed HCDs use this to tell the hub driver that some split control or	389	* High speed HCDs use this to tell the hub driver that some split control or
390	* bulk transaction failed in a way that requires clearing internal state of	390	* bulk transaction failed in a way that requires clearing internal state of
391	* a transaction translator. This is normally detected (and reported) from	391	* a transaction translator. This is normally detected (and reported) from
392	* interrupt context.	392	* interrupt context.
393	*	393	*
394	* It may not be possible for that hub to handle additional full (or low)	394	* It may not be possible for that hub to handle additional full (or low)
395	* speed transactions until that state is fully cleared out.	395	* speed transactions until that state is fully cleared out.
396	*/	396	*/
397	void usb_hub_tt_clear_buffer (struct usb_device *udev, int pipe)	397	void usb_hub_tt_clear_buffer (struct usb_device *udev, int pipe)
398	{	398	{
399	struct usb_tt *tt = udev->tt;	399	struct usb_tt *tt = udev->tt;
400	unsigned long flags;	400	unsigned long flags;
401	struct usb_tt_clear *clear;	401	struct usb_tt_clear *clear;
402		402
403	/* we've got to cope with an arbitrary number of pending TT clears,	403	/* we've got to cope with an arbitrary number of pending TT clears,
404	* since each TT has "at least two" buffers that can need it (and	404	* since each TT has "at least two" buffers that can need it (and
405	* there can be many TTs per hub). even if they're uncommon.	405	* there can be many TTs per hub). even if they're uncommon.
406	*/	406	*/
407	if ((clear = kmalloc (sizeof *clear, SLAB_ATOMIC)) == NULL) {	407	if ((clear = kmalloc (sizeof *clear, SLAB_ATOMIC)) == NULL) {
408	dev_err (&udev->dev, "can't save CLEAR_TT_BUFFER state\n");	408	dev_err (&udev->dev, "can't save CLEAR_TT_BUFFER state\n");
409	/* FIXME recover somehow ... RESET_TT? */	409	/* FIXME recover somehow ... RESET_TT? */
410	return;	410	return;
411	}	411	}
412		412
413	/* info that CLEAR_TT_BUFFER needs */	413	/* info that CLEAR_TT_BUFFER needs */
414	clear->tt = tt->multi ? udev->ttport : 1;	414	clear->tt = tt->multi ? udev->ttport : 1;
415	clear->devinfo = usb_pipeendpoint (pipe);	415	clear->devinfo = usb_pipeendpoint (pipe);
416	clear->devinfo \|= udev->devnum << 4;	416	clear->devinfo \|= udev->devnum << 4;
417	clear->devinfo \|= usb_pipecontrol (pipe)	417	clear->devinfo \|= usb_pipecontrol (pipe)
418	? (USB_ENDPOINT_XFER_CONTROL << 11)	418	? (USB_ENDPOINT_XFER_CONTROL << 11)
419	: (USB_ENDPOINT_XFER_BULK << 11);	419	: (USB_ENDPOINT_XFER_BULK << 11);
420	if (usb_pipein (pipe))	420	if (usb_pipein (pipe))
421	clear->devinfo \|= 1 << 15;	421	clear->devinfo \|= 1 << 15;
422		422
423	/* tell keventd to clear state for this TT */	423	/* tell keventd to clear state for this TT */
424	spin_lock_irqsave (&tt->lock, flags);	424	spin_lock_irqsave (&tt->lock, flags);
425	list_add_tail (&clear->clear_list, &tt->clear_list);	425	list_add_tail (&clear->clear_list, &tt->clear_list);
426	schedule_work (&tt->kevent);	426	schedule_work (&tt->kevent);
427	spin_unlock_irqrestore (&tt->lock, flags);	427	spin_unlock_irqrestore (&tt->lock, flags);
428	}	428	}
429		429
430	static void hub_power_on(struct usb_hub *hub)	430	static void hub_power_on(struct usb_hub *hub)
431	{	431	{
432	int port1;	432	int port1;
433	unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;	433	unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;
434	u16 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);	434	u16 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
435		435
436	/* if hub supports power switching, enable power on each port */	436	/* if hub supports power switching, enable power on each port */
437	if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2) {	437	if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2) {
438	dev_dbg(hub->intfdev, "enabling power on all ports\n");	438	dev_dbg(hub->intfdev, "enabling power on all ports\n");
439	for (port1 = 1; port1 <= hub->descriptor->bNbrPorts; port1++)	439	for (port1 = 1; port1 <= hub->descriptor->bNbrPorts; port1++)
440	set_port_feature(hub->hdev, port1,	440	set_port_feature(hub->hdev, port1,
441	USB_PORT_FEAT_POWER);	441	USB_PORT_FEAT_POWER);
442	}	442	}
443		443
444	/* Wait at least 100 msec for power to become stable */	444	/* Wait at least 100 msec for power to become stable */
445	msleep(max(pgood_delay, (unsigned) 100));	445	msleep(max(pgood_delay, (unsigned) 100));
446	}	446	}
447		447
448	static inline void __hub_quiesce(struct usb_hub *hub)	448	static inline void __hub_quiesce(struct usb_hub *hub)
449	{	449	{
450	/* (nonblocking) khubd and related activity won't re-trigger */	450	/* (nonblocking) khubd and related activity won't re-trigger */
451	hub->quiescing = 1;	451	hub->quiescing = 1;
452	hub->activating = 0;	452	hub->activating = 0;
453	hub->resume_root_hub = 0;	453	hub->resume_root_hub = 0;
454	}	454	}
455		455
456	static void hub_quiesce(struct usb_hub *hub)	456	static void hub_quiesce(struct usb_hub *hub)
457	{	457	{
458	/* (blocking) stop khubd and related activity */	458	/* (blocking) stop khubd and related activity */
459	__hub_quiesce(hub);	459	__hub_quiesce(hub);
460	usb_kill_urb(hub->urb);	460	usb_kill_urb(hub->urb);
461	if (hub->has_indicators)	461	if (hub->has_indicators)
462	cancel_delayed_work(&hub->leds);	462	cancel_delayed_work(&hub->leds);
463	if (hub->has_indicators \|\| hub->tt.hub)	463	if (hub->has_indicators \|\| hub->tt.hub)
464	flush_scheduled_work();	464	flush_scheduled_work();
465	}	465	}
466		466
467	static void hub_activate(struct usb_hub *hub)	467	static void hub_activate(struct usb_hub *hub)
468	{	468	{
469	int status;	469	int status;
470		470
471	hub->quiescing = 0;	471	hub->quiescing = 0;
472	hub->activating = 1;	472	hub->activating = 1;
473	hub->resume_root_hub = 0;	473	hub->resume_root_hub = 0;
474	status = usb_submit_urb(hub->urb, GFP_NOIO);	474	status = usb_submit_urb(hub->urb, GFP_NOIO);
475	if (status < 0)	475	if (status < 0)
476	dev_err(hub->intfdev, "activate --> %d\n", status);	476	dev_err(hub->intfdev, "activate --> %d\n", status);
477	if (hub->has_indicators && blinkenlights)	477	if (hub->has_indicators && blinkenlights)
478	schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);	478	schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
479		479
480	/* scan all ports ASAP */	480	/* scan all ports ASAP */
481	kick_khubd(hub);	481	kick_khubd(hub);
482	}	482	}
483		483
484	static int hub_hub_status(struct usb_hub *hub,	484	static int hub_hub_status(struct usb_hub *hub,
485	u16 status, u16 change)	485	u16 status, u16 change)
486	{	486	{
487	int ret;	487	int ret;
488		488
489	ret = get_hub_status(hub->hdev, &hub->status->hub);	489	ret = get_hub_status(hub->hdev, &hub->status->hub);
490	if (ret < 0)	490	if (ret < 0)
491	dev_err (hub->intfdev,	491	dev_err (hub->intfdev,
492	"%s failed (err = %d)\n", __FUNCTION__, ret);	492	"%s failed (err = %d)\n", __FUNCTION__, ret);
493	else {	493	else {
494	*status = le16_to_cpu(hub->status->hub.wHubStatus);	494	*status = le16_to_cpu(hub->status->hub.wHubStatus);
495	*change = le16_to_cpu(hub->status->hub.wHubChange);	495	*change = le16_to_cpu(hub->status->hub.wHubChange);
496	ret = 0;	496	ret = 0;
497	}	497	}
498	return ret;	498	return ret;
499	}	499	}
500		500
501	static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)	501	static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
502	{	502	{
503	struct usb_device *hdev = hub->hdev;	503	struct usb_device *hdev = hub->hdev;
504	int ret;	504	int ret;
505		505
506	if (hdev->children[port1-1] && set_state) {	506	if (hdev->children[port1-1] && set_state) {
507	usb_set_device_state(hdev->children[port1-1],	507	usb_set_device_state(hdev->children[port1-1],
508	USB_STATE_NOTATTACHED);	508	USB_STATE_NOTATTACHED);
509	}	509	}
510	ret = clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);	510	ret = clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);
511	if (ret)	511	if (ret)
512	dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",	512	dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
513	port1, ret);	513	port1, ret);
514		514
515	return ret;	515	return ret;
516	}	516	}
517		517
518		518
519	/* caller has locked the hub device */	519	/* caller has locked the hub device */
520	static void hub_pre_reset(struct usb_hub *hub, int disable_ports)	520	static void hub_pre_reset(struct usb_hub *hub, int disable_ports)
521	{	521	{
522	struct usb_device *hdev = hub->hdev;	522	struct usb_device *hdev = hub->hdev;
523	int port1;	523	int port1;
524		524
525	for (port1 = 1; port1 <= hdev->maxchild; ++port1) {	525	for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
526	if (hdev->children[port1 - 1]) {	526	if (hdev->children[port1 - 1]) {
527	usb_disconnect(&hdev->children[port1 - 1]);	527	usb_disconnect(&hdev->children[port1 - 1]);
528	if (disable_ports)	528	if (disable_ports)
529	hub_port_disable(hub, port1, 0);	529	hub_port_disable(hub, port1, 0);
530	}	530	}
531	}	531	}
532	hub_quiesce(hub);	532	hub_quiesce(hub);
533	}	533	}
534		534
535	/* caller has locked the hub device */	535	/* caller has locked the hub device */
536	static void hub_post_reset(struct usb_hub *hub)	536	static void hub_post_reset(struct usb_hub *hub)
537	{	537	{
538	hub_activate(hub);	538	hub_activate(hub);
539	hub_power_on(hub);	539	hub_power_on(hub);
540	}	540	}
541		541
542		542
543	static int hub_configure(struct usb_hub *hub,	543	static int hub_configure(struct usb_hub *hub,
544	struct usb_endpoint_descriptor *endpoint)	544	struct usb_endpoint_descriptor *endpoint)
545	{	545	{
546	struct usb_device *hdev = hub->hdev;	546	struct usb_device *hdev = hub->hdev;
547	struct device *hub_dev = hub->intfdev;	547	struct device *hub_dev = hub->intfdev;
548	u16 hubstatus, hubchange;	548	u16 hubstatus, hubchange;
549	u16 wHubCharacteristics;	549	u16 wHubCharacteristics;
550	unsigned int pipe;	550	unsigned int pipe;
551	int maxp, ret;	551	int maxp, ret;
552	char *message;	552	char *message;
553		553
554	hub->buffer = usb_buffer_alloc(hdev, sizeof(*hub->buffer), GFP_KERNEL,	554	hub->buffer = usb_buffer_alloc(hdev, sizeof(*hub->buffer), GFP_KERNEL,
555	&hub->buffer_dma);	555	&hub->buffer_dma);
556	if (!hub->buffer) {	556	if (!hub->buffer) {
557	message = "can't allocate hub irq buffer";	557	message = "can't allocate hub irq buffer";
558	ret = -ENOMEM;	558	ret = -ENOMEM;
559	goto fail;	559	goto fail;
560	}	560	}
561		561
562	hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);	562	hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
563	if (!hub->status) {	563	if (!hub->status) {
564	message = "can't kmalloc hub status buffer";	564	message = "can't kmalloc hub status buffer";
565	ret = -ENOMEM;	565	ret = -ENOMEM;
566	goto fail;	566	goto fail;
567	}	567	}
568		568
569	hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);	569	hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
570	if (!hub->descriptor) {	570	if (!hub->descriptor) {
571	message = "can't kmalloc hub descriptor";	571	message = "can't kmalloc hub descriptor";
572	ret = -ENOMEM;	572	ret = -ENOMEM;
573	goto fail;	573	goto fail;
574	}	574	}
575		575
576	/* Request the entire hub descriptor.	576	/* Request the entire hub descriptor.
577	* hub->descriptor can handle USB_MAXCHILDREN ports,	577	* hub->descriptor can handle USB_MAXCHILDREN ports,
578	* but the hub can/will return fewer bytes here.	578	* but the hub can/will return fewer bytes here.
579	*/	579	*/
580	ret = get_hub_descriptor(hdev, hub->descriptor,	580	ret = get_hub_descriptor(hdev, hub->descriptor,
581	sizeof(*hub->descriptor));	581	sizeof(*hub->descriptor));
582	if (ret < 0) {	582	if (ret < 0) {
583	message = "can't read hub descriptor";	583	message = "can't read hub descriptor";
584	goto fail;	584	goto fail;
585	} else if (hub->descriptor->bNbrPorts > USB_MAXCHILDREN) {	585	} else if (hub->descriptor->bNbrPorts > USB_MAXCHILDREN) {
586	message = "hub has too many ports!";	586	message = "hub has too many ports!";
587	ret = -ENODEV;	587	ret = -ENODEV;
588	goto fail;	588	goto fail;
589	}	589	}
590		590
591	hdev->maxchild = hub->descriptor->bNbrPorts;	591	hdev->maxchild = hub->descriptor->bNbrPorts;
592	dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,	592	dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
593	(hdev->maxchild == 1) ? "" : "s");	593	(hdev->maxchild == 1) ? "" : "s");
594		594
595	wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);	595	wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
596		596
597	if (wHubCharacteristics & HUB_CHAR_COMPOUND) {	597	if (wHubCharacteristics & HUB_CHAR_COMPOUND) {
598	int i;	598	int i;
599	char portstr [USB_MAXCHILDREN + 1];	599	char portstr [USB_MAXCHILDREN + 1];
600		600
601	for (i = 0; i < hdev->maxchild; i++)	601	for (i = 0; i < hdev->maxchild; i++)
602	portstr[i] = hub->descriptor->DeviceRemovable	602	portstr[i] = hub->descriptor->DeviceRemovable
603	[((i + 1) / 8)] & (1 << ((i + 1) % 8))	603	[((i + 1) / 8)] & (1 << ((i + 1) % 8))
604	? 'F' : 'R';	604	? 'F' : 'R';
605	portstr[hdev->maxchild] = 0;	605	portstr[hdev->maxchild] = 0;
606	dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);	606	dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
607	} else	607	} else
608	dev_dbg(hub_dev, "standalone hub\n");	608	dev_dbg(hub_dev, "standalone hub\n");
609		609
610	switch (wHubCharacteristics & HUB_CHAR_LPSM) {	610	switch (wHubCharacteristics & HUB_CHAR_LPSM) {
611	case 0x00:	611	case 0x00:
612	dev_dbg(hub_dev, "ganged power switching\n");	612	dev_dbg(hub_dev, "ganged power switching\n");
613	break;	613	break;
614	case 0x01:	614	case 0x01:
615	dev_dbg(hub_dev, "individual port power switching\n");	615	dev_dbg(hub_dev, "individual port power switching\n");
616	break;	616	break;
617	case 0x02:	617	case 0x02:
618	case 0x03:	618	case 0x03:
619	dev_dbg(hub_dev, "no power switching (usb 1.0)\n");	619	dev_dbg(hub_dev, "no power switching (usb 1.0)\n");
620	break;	620	break;
621	}	621	}
622		622
623	switch (wHubCharacteristics & HUB_CHAR_OCPM) {	623	switch (wHubCharacteristics & HUB_CHAR_OCPM) {
624	case 0x00:	624	case 0x00:
625	dev_dbg(hub_dev, "global over-current protection\n");	625	dev_dbg(hub_dev, "global over-current protection\n");
626	break;	626	break;
627	case 0x08:	627	case 0x08:
628	dev_dbg(hub_dev, "individual port over-current protection\n");	628	dev_dbg(hub_dev, "individual port over-current protection\n");
629	break;	629	break;
630	case 0x10:	630	case 0x10:
631	case 0x18:	631	case 0x18:
632	dev_dbg(hub_dev, "no over-current protection\n");	632	dev_dbg(hub_dev, "no over-current protection\n");
633	break;	633	break;
634	}	634	}
635		635
636	spin_lock_init (&hub->tt.lock);	636	spin_lock_init (&hub->tt.lock);
637	INIT_LIST_HEAD (&hub->tt.clear_list);	637	INIT_LIST_HEAD (&hub->tt.clear_list);
638	INIT_WORK (&hub->tt.kevent, hub_tt_kevent, hub);	638	INIT_WORK (&hub->tt.kevent, hub_tt_kevent, hub);
639	switch (hdev->descriptor.bDeviceProtocol) {	639	switch (hdev->descriptor.bDeviceProtocol) {
640	case 0:	640	case 0:
641	break;	641	break;
642	case 1:	642	case 1:
643	dev_dbg(hub_dev, "Single TT\n");	643	dev_dbg(hub_dev, "Single TT\n");
644	hub->tt.hub = hdev;	644	hub->tt.hub = hdev;
645	break;	645	break;
646	case 2:	646	case 2:
647	ret = usb_set_interface(hdev, 0, 1);	647	ret = usb_set_interface(hdev, 0, 1);
648	if (ret == 0) {	648	if (ret == 0) {
649	dev_dbg(hub_dev, "TT per port\n");	649	dev_dbg(hub_dev, "TT per port\n");
650	hub->tt.multi = 1;	650	hub->tt.multi = 1;
651	} else	651	} else
652	dev_err(hub_dev, "Using single TT (err %d)\n",	652	dev_err(hub_dev, "Using single TT (err %d)\n",
653	ret);	653	ret);
654	hub->tt.hub = hdev;	654	hub->tt.hub = hdev;
655	break;	655	break;
656	default:	656	default:
657	dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",	657	dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",
658	hdev->descriptor.bDeviceProtocol);	658	hdev->descriptor.bDeviceProtocol);
659	break;	659	break;
660	}	660	}
661		661
662	/* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */	662	/* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
663	switch (wHubCharacteristics & HUB_CHAR_TTTT) {	663	switch (wHubCharacteristics & HUB_CHAR_TTTT) {
664	case HUB_TTTT_8_BITS:	664	case HUB_TTTT_8_BITS:
665	if (hdev->descriptor.bDeviceProtocol != 0) {	665	if (hdev->descriptor.bDeviceProtocol != 0) {
666	hub->tt.think_time = 666;	666	hub->tt.think_time = 666;
667	dev_dbg(hub_dev, "TT requires at most %d "	667	dev_dbg(hub_dev, "TT requires at most %d "
668	"FS bit times (%d ns)\n",	668	"FS bit times (%d ns)\n",
669	8, hub->tt.think_time);	669	8, hub->tt.think_time);
670	}	670	}
671	break;	671	break;
672	case HUB_TTTT_16_BITS:	672	case HUB_TTTT_16_BITS:
673	hub->tt.think_time = 666 * 2;	673	hub->tt.think_time = 666 * 2;
674	dev_dbg(hub_dev, "TT requires at most %d "	674	dev_dbg(hub_dev, "TT requires at most %d "
675	"FS bit times (%d ns)\n",	675	"FS bit times (%d ns)\n",
676	16, hub->tt.think_time);	676	16, hub->tt.think_time);
677	break;	677	break;
678	case HUB_TTTT_24_BITS:	678	case HUB_TTTT_24_BITS:
679	hub->tt.think_time = 666 * 3;	679	hub->tt.think_time = 666 * 3;
680	dev_dbg(hub_dev, "TT requires at most %d "	680	dev_dbg(hub_dev, "TT requires at most %d "
681	"FS bit times (%d ns)\n",	681	"FS bit times (%d ns)\n",
682	24, hub->tt.think_time);	682	24, hub->tt.think_time);
683	break;	683	break;
684	case HUB_TTTT_32_BITS:	684	case HUB_TTTT_32_BITS:
685	hub->tt.think_time = 666 * 4;	685	hub->tt.think_time = 666 * 4;
686	dev_dbg(hub_dev, "TT requires at most %d "	686	dev_dbg(hub_dev, "TT requires at most %d "
687	"FS bit times (%d ns)\n",	687	"FS bit times (%d ns)\n",
688	32, hub->tt.think_time);	688	32, hub->tt.think_time);
689	break;	689	break;
690	}	690	}
691		691
692	/* probe() zeroes hub->indicator[] */	692	/* probe() zeroes hub->indicator[] */
693	if (wHubCharacteristics & HUB_CHAR_PORTIND) {	693	if (wHubCharacteristics & HUB_CHAR_PORTIND) {
694	hub->has_indicators = 1;	694	hub->has_indicators = 1;
695	dev_dbg(hub_dev, "Port indicators are supported\n");	695	dev_dbg(hub_dev, "Port indicators are supported\n");
696	}	696	}
697		697
698	dev_dbg(hub_dev, "power on to power good time: %dms\n",	698	dev_dbg(hub_dev, "power on to power good time: %dms\n",
699	hub->descriptor->bPwrOn2PwrGood * 2);	699	hub->descriptor->bPwrOn2PwrGood * 2);
700		700
701	/* power budgeting mostly matters with bus-powered hubs,	701	/* power budgeting mostly matters with bus-powered hubs,
702	* and battery-powered root hubs (may provide just 8 mA).	702	* and battery-powered root hubs (may provide just 8 mA).
703	*/	703	*/
704	ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);	704	ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);
705	if (ret < 0) {	705	if (ret < 2) {
706	message = "can't get hub status";	706	message = "can't get hub status";
707	goto fail;	707	goto fail;
708	}	708	}
709	le16_to_cpus(&hubstatus);	709	le16_to_cpus(&hubstatus);
710	if (hdev == hdev->bus->root_hub) {	710	if (hdev == hdev->bus->root_hub) {
711	struct usb_hcd *hcd =	711	if (hdev->bus_mA == 0 \|\| hdev->bus_mA >= 500)
712	container_of(hdev->bus, struct usb_hcd, self);	712	hub->mA_per_port = 500;
713		713	else {
714	hub->power_budget = min(500u, hcd->power_budget) / 2;	714	hub->mA_per_port = hdev->bus_mA;
		715	hub->limited_power = 1;
		716	}
715	} else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {	717	} else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
716	dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",	718	dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
717	hub->descriptor->bHubContrCurrent);	719	hub->descriptor->bHubContrCurrent);
718	hub->power_budget = (501 - hub->descriptor->bHubContrCurrent)	720	hub->limited_power = 1;
719	/ 2;	721	if (hdev->maxchild > 0) {
		722	int remaining = hdev->bus_mA -
		723	hub->descriptor->bHubContrCurrent;
		724
		725	if (remaining < hdev->maxchild * 100)
		726	dev_warn(hub_dev,
		727	"insufficient power available "
		728	"to use all downstream ports\n");
		729	hub->mA_per_port = 100; /* 7.2.1.1 */
		730	}
		731	} else { /* Self-powered external hub */
		732	/* FIXME: What about battery-powered external hubs that
		733	* provide less current per port? */
		734	hub->mA_per_port = 500;
720	}	735	}
721	if (hub->power_budget)	736	if (hub->mA_per_port < 500)
722	dev_dbg(hub_dev, "%dmA bus power budget for children\n",	737	dev_dbg(hub_dev, "%umA bus power budget for each child\n",
723	hub->power_budget * 2);	738	hub->mA_per_port);
724		739
725
726	ret = hub_hub_status(hub, &hubstatus, &hubchange);	740	ret = hub_hub_status(hub, &hubstatus, &hubchange);
727	if (ret < 0) {	741	if (ret < 0) {
728	message = "can't get hub status";	742	message = "can't get hub status";
729	goto fail;	743	goto fail;
730	}	744	}
731		745
732	/* local power status reports aren't always correct */	746	/* local power status reports aren't always correct */
733	if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER)	747	if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER)
734	dev_dbg(hub_dev, "local power source is %s\n",	748	dev_dbg(hub_dev, "local power source is %s\n",
735	(hubstatus & HUB_STATUS_LOCAL_POWER)	749	(hubstatus & HUB_STATUS_LOCAL_POWER)
736	? "lost (inactive)" : "good");	750	? "lost (inactive)" : "good");
737		751
738	if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)	752	if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
739	dev_dbg(hub_dev, "%sover-current condition exists\n",	753	dev_dbg(hub_dev, "%sover-current condition exists\n",
740	(hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");	754	(hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
741		755
742	/* set up the interrupt endpoint */	756	/* set up the interrupt endpoint */
743	pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);	757	pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
744	maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));	758	maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
745		759
746	if (maxp > sizeof(*hub->buffer))	760	if (maxp > sizeof(*hub->buffer))
747	maxp = sizeof(*hub->buffer);	761	maxp = sizeof(*hub->buffer);
748		762
749	hub->urb = usb_alloc_urb(0, GFP_KERNEL);	763	hub->urb = usb_alloc_urb(0, GFP_KERNEL);
750	if (!hub->urb) {	764	if (!hub->urb) {
751	message = "couldn't allocate interrupt urb";	765	message = "couldn't allocate interrupt urb";
752	ret = -ENOMEM;	766	ret = -ENOMEM;
753	goto fail;	767	goto fail;
754	}	768	}
755		769
756	usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,	770	usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
757	hub, endpoint->bInterval);	771	hub, endpoint->bInterval);
758	hub->urb->transfer_dma = hub->buffer_dma;	772	hub->urb->transfer_dma = hub->buffer_dma;
759	hub->urb->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;	773	hub->urb->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;
760		774
761	/* maybe cycle the hub leds */	775	/* maybe cycle the hub leds */
762	if (hub->has_indicators && blinkenlights)	776	if (hub->has_indicators && blinkenlights)
763	hub->indicator [0] = INDICATOR_CYCLE;	777	hub->indicator [0] = INDICATOR_CYCLE;
764		778
765	hub_power_on(hub);	779	hub_power_on(hub);
766	hub_activate(hub);	780	hub_activate(hub);
767	return 0;	781	return 0;
768		782
769	fail:	783	fail:
770	dev_err (hub_dev, "config failed, %s (err %d)\n",	784	dev_err (hub_dev, "config failed, %s (err %d)\n",
771	message, ret);	785	message, ret);
772	/* hub_disconnect() frees urb and descriptor */	786	/* hub_disconnect() frees urb and descriptor */
773	return ret;	787	return ret;
774	}	788	}
775		789
776	static unsigned highspeed_hubs;	790	static unsigned highspeed_hubs;
777		791
778	static void hub_disconnect(struct usb_interface *intf)	792	static void hub_disconnect(struct usb_interface *intf)
779	{	793	{
780	struct usb_hub *hub = usb_get_intfdata (intf);	794	struct usb_hub *hub = usb_get_intfdata (intf);
781	struct usb_device *hdev;	795	struct usb_device *hdev;
782		796
783	usb_set_intfdata (intf, NULL);	797	usb_set_intfdata (intf, NULL);
784	hdev = hub->hdev;	798	hdev = hub->hdev;
785		799
786	if (hdev->speed == USB_SPEED_HIGH)	800	if (hdev->speed == USB_SPEED_HIGH)
787	highspeed_hubs--;	801	highspeed_hubs--;
788		802
789	/* Disconnect all children and quiesce the hub */	803	/* Disconnect all children and quiesce the hub */
790	hub_pre_reset(hub, 1);	804	hub_pre_reset(hub, 1);
791		805
792	usb_free_urb(hub->urb);	806	usb_free_urb(hub->urb);
793	hub->urb = NULL;	807	hub->urb = NULL;
794		808
795	spin_lock_irq(&hub_event_lock);	809	spin_lock_irq(&hub_event_lock);
796	list_del_init(&hub->event_list);	810	list_del_init(&hub->event_list);
797	spin_unlock_irq(&hub_event_lock);	811	spin_unlock_irq(&hub_event_lock);
798		812
799	kfree(hub->descriptor);	813	kfree(hub->descriptor);
800	hub->descriptor = NULL;	814	hub->descriptor = NULL;
801		815
802	kfree(hub->status);	816	kfree(hub->status);
803	hub->status = NULL;	817	hub->status = NULL;
804		818
805	if (hub->buffer) {	819	if (hub->buffer) {
806	usb_buffer_free(hdev, sizeof(*hub->buffer), hub->buffer,	820	usb_buffer_free(hdev, sizeof(*hub->buffer), hub->buffer,
807	hub->buffer_dma);	821	hub->buffer_dma);
808	hub->buffer = NULL;	822	hub->buffer = NULL;
809	}	823	}
810		824
811	kfree(hub);	825	kfree(hub);
812	}	826	}
813		827
814	static int hub_probe(struct usb_interface intf, const struct usb_device_id id)	828	static int hub_probe(struct usb_interface intf, const struct usb_device_id id)
815	{	829	{
816	struct usb_host_interface *desc;	830	struct usb_host_interface *desc;
817	struct usb_endpoint_descriptor *endpoint;	831	struct usb_endpoint_descriptor *endpoint;
818	struct usb_device *hdev;	832	struct usb_device *hdev;
819	struct usb_hub *hub;	833	struct usb_hub *hub;
820		834
821	desc = intf->cur_altsetting;	835	desc = intf->cur_altsetting;
822	hdev = interface_to_usbdev(intf);	836	hdev = interface_to_usbdev(intf);
823		837
824	/* Some hubs have a subclass of 1, which AFAICT according to the */	838	/* Some hubs have a subclass of 1, which AFAICT according to the */
825	/* specs is not defined, but it works */	839	/* specs is not defined, but it works */
826	if ((desc->desc.bInterfaceSubClass != 0) &&	840	if ((desc->desc.bInterfaceSubClass != 0) &&
827	(desc->desc.bInterfaceSubClass != 1)) {	841	(desc->desc.bInterfaceSubClass != 1)) {
828	descriptor_error:	842	descriptor_error:
829	dev_err (&intf->dev, "bad descriptor, ignoring hub\n");	843	dev_err (&intf->dev, "bad descriptor, ignoring hub\n");
830	return -EIO;	844	return -EIO;
831	}	845	}
832		846
833	/* Multiple endpoints? What kind of mutant ninja-hub is this? */	847	/* Multiple endpoints? What kind of mutant ninja-hub is this? */
834	if (desc->desc.bNumEndpoints != 1)	848	if (desc->desc.bNumEndpoints != 1)
835	goto descriptor_error;	849	goto descriptor_error;
836		850
837	endpoint = &desc->endpoint[0].desc;	851	endpoint = &desc->endpoint[0].desc;
838		852
839	/* Output endpoint? Curiouser and curiouser.. */	853	/* Output endpoint? Curiouser and curiouser.. */
840	if (!(endpoint->bEndpointAddress & USB_DIR_IN))	854	if (!(endpoint->bEndpointAddress & USB_DIR_IN))
841	goto descriptor_error;	855	goto descriptor_error;
842		856
843	/* If it's not an interrupt endpoint, we'd better punt! */	857	/* If it's not an interrupt endpoint, we'd better punt! */
844	if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)	858	if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
845	!= USB_ENDPOINT_XFER_INT)	859	!= USB_ENDPOINT_XFER_INT)
846	goto descriptor_error;	860	goto descriptor_error;
847		861
848	/* We found a hub */	862	/* We found a hub */
849	dev_info (&intf->dev, "USB hub found\n");	863	dev_info (&intf->dev, "USB hub found\n");
850		864
851	hub = kzalloc(sizeof(*hub), GFP_KERNEL);	865	hub = kzalloc(sizeof(*hub), GFP_KERNEL);
852	if (!hub) {	866	if (!hub) {
853	dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n");	867	dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n");
854	return -ENOMEM;	868	return -ENOMEM;
855	}	869	}
856		870
857	INIT_LIST_HEAD(&hub->event_list);	871	INIT_LIST_HEAD(&hub->event_list);
858	hub->intfdev = &intf->dev;	872	hub->intfdev = &intf->dev;
859	hub->hdev = hdev;	873	hub->hdev = hdev;
860	INIT_WORK(&hub->leds, led_work, hub);	874	INIT_WORK(&hub->leds, led_work, hub);
861		875
862	usb_set_intfdata (intf, hub);	876	usb_set_intfdata (intf, hub);
863		877
864	if (hdev->speed == USB_SPEED_HIGH)	878	if (hdev->speed == USB_SPEED_HIGH)
865	highspeed_hubs++;	879	highspeed_hubs++;
866		880
867	if (hub_configure(hub, endpoint) >= 0)	881	if (hub_configure(hub, endpoint) >= 0)
868	return 0;	882	return 0;
869		883
870	hub_disconnect (intf);	884	hub_disconnect (intf);
871	return -ENODEV;	885	return -ENODEV;
872	}	886	}
873		887
874	static int	888	static int
875	hub_ioctl(struct usb_interface intf, unsigned int code, void user_data)	889	hub_ioctl(struct usb_interface intf, unsigned int code, void user_data)
876	{	890	{
877	struct usb_device *hdev = interface_to_usbdev (intf);	891	struct usb_device *hdev = interface_to_usbdev (intf);
878		892
879	/* assert ifno == 0 (part of hub spec) */	893	/* assert ifno == 0 (part of hub spec) */
880	switch (code) {	894	switch (code) {
881	case USBDEVFS_HUB_PORTINFO: {	895	case USBDEVFS_HUB_PORTINFO: {
882	struct usbdevfs_hub_portinfo *info = user_data;	896	struct usbdevfs_hub_portinfo *info = user_data;
883	int i;	897	int i;
884		898
885	spin_lock_irq(&device_state_lock);	899	spin_lock_irq(&device_state_lock);
886	if (hdev->devnum <= 0)	900	if (hdev->devnum <= 0)
887	info->nports = 0;	901	info->nports = 0;
888	else {	902	else {
889	info->nports = hdev->maxchild;	903	info->nports = hdev->maxchild;
890	for (i = 0; i < info->nports; i++) {	904	for (i = 0; i < info->nports; i++) {
891	if (hdev->children[i] == NULL)	905	if (hdev->children[i] == NULL)
892	info->port[i] = 0;	906	info->port[i] = 0;
893	else	907	else
894	info->port[i] =	908	info->port[i] =
895	hdev->children[i]->devnum;	909	hdev->children[i]->devnum;
896	}	910	}
897	}	911	}
898	spin_unlock_irq(&device_state_lock);	912	spin_unlock_irq(&device_state_lock);
899		913
900	return info->nports + 1;	914	return info->nports + 1;
901	}	915	}
902		916
903	default:	917	default:
904	return -ENOSYS;	918	return -ENOSYS;
905	}	919	}
906	}	920	}
907		921
908		922
909	/* grab device/port lock, returning index of that port (zero based).	923	/* grab device/port lock, returning index of that port (zero based).
910	* protects the upstream link used by this device from concurrent	924	* protects the upstream link used by this device from concurrent
911	* tree operations like suspend, resume, reset, and disconnect, which	925	* tree operations like suspend, resume, reset, and disconnect, which
912	* apply to everything downstream of a given port.	926	* apply to everything downstream of a given port.
913	*/	927	*/
914	static int locktree(struct usb_device *udev)	928	static int locktree(struct usb_device *udev)
915	{	929	{
916	int t;	930	int t;
917	struct usb_device *hdev;	931	struct usb_device *hdev;
918		932
919	if (!udev)	933	if (!udev)
920	return -ENODEV;	934	return -ENODEV;
921		935
922	/* root hub is always the first lock in the series */	936	/* root hub is always the first lock in the series */
923	hdev = udev->parent;	937	hdev = udev->parent;
924	if (!hdev) {	938	if (!hdev) {
925	usb_lock_device(udev);	939	usb_lock_device(udev);
926	return 0;	940	return 0;
927	}	941	}
928		942
929	/* on the path from root to us, lock everything from	943	/* on the path from root to us, lock everything from
930	* top down, dropping parent locks when not needed	944	* top down, dropping parent locks when not needed
931	*/	945	*/
932	t = locktree(hdev);	946	t = locktree(hdev);
933	if (t < 0)	947	if (t < 0)
934	return t;	948	return t;
935	for (t = 0; t < hdev->maxchild; t++) {	949	for (t = 0; t < hdev->maxchild; t++) {
936	if (hdev->children[t] == udev) {	950	if (hdev->children[t] == udev) {
937	/* everything is fail-fast once disconnect	951	/* everything is fail-fast once disconnect
938	* processing starts	952	* processing starts
939	*/	953	*/
940	if (udev->state == USB_STATE_NOTATTACHED)	954	if (udev->state == USB_STATE_NOTATTACHED)
941	break;	955	break;
942		956
943	/* when everyone grabs locks top->bottom,	957	/* when everyone grabs locks top->bottom,
944	* non-overlapping work may be concurrent	958	* non-overlapping work may be concurrent
945	*/	959	*/
946	usb_lock_device(udev);	960	usb_lock_device(udev);
947	usb_unlock_device(hdev);	961	usb_unlock_device(hdev);
948	return t + 1;	962	return t + 1;
949	}	963	}
950	}	964	}
951	usb_unlock_device(hdev);	965	usb_unlock_device(hdev);
952	return -ENODEV;	966	return -ENODEV;
953	}	967	}
954		968
955	static void recursively_mark_NOTATTACHED(struct usb_device *udev)	969	static void recursively_mark_NOTATTACHED(struct usb_device *udev)
956	{	970	{
957	int i;	971	int i;
958		972
959	for (i = 0; i < udev->maxchild; ++i) {	973	for (i = 0; i < udev->maxchild; ++i) {
960	if (udev->children[i])	974	if (udev->children[i])
961	recursively_mark_NOTATTACHED(udev->children[i]);	975	recursively_mark_NOTATTACHED(udev->children[i]);
962	}	976	}
963	udev->state = USB_STATE_NOTATTACHED;	977	udev->state = USB_STATE_NOTATTACHED;
964	}	978	}
965		979
966	/**	980	/**
967	* usb_set_device_state - change a device's current state (usbcore, hcds)	981	* usb_set_device_state - change a device's current state (usbcore, hcds)
968	* @udev: pointer to device whose state should be changed	982	* @udev: pointer to device whose state should be changed
969	* @new_state: new state value to be stored	983	* @new_state: new state value to be stored
970	*	984	*
971	* udev->state is _not_ fully protected by the device lock. Although	985	* udev->state is _not_ fully protected by the device lock. Although
972	* most transitions are made only while holding the lock, the state can	986	* most transitions are made only while holding the lock, the state can
973	* can change to USB_STATE_NOTATTACHED at almost any time. This	987	* can change to USB_STATE_NOTATTACHED at almost any time. This
974	* is so that devices can be marked as disconnected as soon as possible,	988	* is so that devices can be marked as disconnected as soon as possible,
975	* without having to wait for any semaphores to be released. As a result,	989	* without having to wait for any semaphores to be released. As a result,
976	* all changes to any device's state must be protected by the	990	* all changes to any device's state must be protected by the
977	* device_state_lock spinlock.	991	* device_state_lock spinlock.
978	*	992	*
979	* Once a device has been added to the device tree, all changes to its state	993	* Once a device has been added to the device tree, all changes to its state
980	* should be made using this routine. The state should _not_ be set directly.	994	* should be made using this routine. The state should _not_ be set directly.
981	*	995	*
982	* If udev->state is already USB_STATE_NOTATTACHED then no change is made.	996	* If udev->state is already USB_STATE_NOTATTACHED then no change is made.
983	* Otherwise udev->state is set to new_state, and if new_state is	997	* Otherwise udev->state is set to new_state, and if new_state is
984	* USB_STATE_NOTATTACHED then all of udev's descendants' states are also set	998	* USB_STATE_NOTATTACHED then all of udev's descendants' states are also set
985	* to USB_STATE_NOTATTACHED.	999	* to USB_STATE_NOTATTACHED.
986	*/	1000	*/
987	void usb_set_device_state(struct usb_device *udev,	1001	void usb_set_device_state(struct usb_device *udev,
988	enum usb_device_state new_state)	1002	enum usb_device_state new_state)
989	{	1003	{
990	unsigned long flags;	1004	unsigned long flags;
991		1005
992	spin_lock_irqsave(&device_state_lock, flags);	1006	spin_lock_irqsave(&device_state_lock, flags);
993	if (udev->state == USB_STATE_NOTATTACHED)	1007	if (udev->state == USB_STATE_NOTATTACHED)
994	; /* do nothing */	1008	; /* do nothing */
995	else if (new_state != USB_STATE_NOTATTACHED) {	1009	else if (new_state != USB_STATE_NOTATTACHED) {
996	udev->state = new_state;	1010	udev->state = new_state;
997	if (new_state == USB_STATE_CONFIGURED)	1011	if (new_state == USB_STATE_CONFIGURED)
998	device_init_wakeup(&udev->dev,	1012	device_init_wakeup(&udev->dev,
999	(udev->actconfig->desc.bmAttributes	1013	(udev->actconfig->desc.bmAttributes
1000	& USB_CONFIG_ATT_WAKEUP));	1014	& USB_CONFIG_ATT_WAKEUP));
1001	else if (new_state != USB_STATE_SUSPENDED)	1015	else if (new_state != USB_STATE_SUSPENDED)
1002	device_init_wakeup(&udev->dev, 0);	1016	device_init_wakeup(&udev->dev, 0);
1003	} else	1017	} else
1004	recursively_mark_NOTATTACHED(udev);	1018	recursively_mark_NOTATTACHED(udev);
1005	spin_unlock_irqrestore(&device_state_lock, flags);	1019	spin_unlock_irqrestore(&device_state_lock, flags);
1006	}	1020	}
1007	EXPORT_SYMBOL(usb_set_device_state);	1021	EXPORT_SYMBOL(usb_set_device_state);
1008		1022
1009		1023
1010	#ifdef CONFIG_PM	1024	#ifdef CONFIG_PM
1011		1025
1012	/**	1026	/**
1013	* usb_root_hub_lost_power - called by HCD if the root hub lost Vbus power	1027	* usb_root_hub_lost_power - called by HCD if the root hub lost Vbus power
1014	* @rhdev: struct usb_device for the root hub	1028	* @rhdev: struct usb_device for the root hub
1015	*	1029	*
1016	* The USB host controller driver calls this function when its root hub	1030	* The USB host controller driver calls this function when its root hub
1017	* is resumed and Vbus power has been interrupted or the controller	1031	* is resumed and Vbus power has been interrupted or the controller
1018	* has been reset. The routine marks all the children of the root hub	1032	* has been reset. The routine marks all the children of the root hub
1019	* as NOTATTACHED and marks logical connect-change events on their ports.	1033	* as NOTATTACHED and marks logical connect-change events on their ports.
1020	*/	1034	*/
1021	void usb_root_hub_lost_power(struct usb_device *rhdev)	1035	void usb_root_hub_lost_power(struct usb_device *rhdev)
1022	{	1036	{
1023	struct usb_hub *hub;	1037	struct usb_hub *hub;
1024	int port1;	1038	int port1;
1025	unsigned long flags;	1039	unsigned long flags;
1026		1040
1027	dev_warn(&rhdev->dev, "root hub lost power or was reset\n");	1041	dev_warn(&rhdev->dev, "root hub lost power or was reset\n");
1028	spin_lock_irqsave(&device_state_lock, flags);	1042	spin_lock_irqsave(&device_state_lock, flags);
1029	hub = hdev_to_hub(rhdev);	1043	hub = hdev_to_hub(rhdev);
1030	for (port1 = 1; port1 <= rhdev->maxchild; ++port1) {	1044	for (port1 = 1; port1 <= rhdev->maxchild; ++port1) {
1031	if (rhdev->children[port1 - 1]) {	1045	if (rhdev->children[port1 - 1]) {
1032	recursively_mark_NOTATTACHED(	1046	recursively_mark_NOTATTACHED(
1033	rhdev->children[port1 - 1]);	1047	rhdev->children[port1 - 1]);
1034	set_bit(port1, hub->change_bits);	1048	set_bit(port1, hub->change_bits);
1035	}	1049	}
1036	}	1050	}
1037	spin_unlock_irqrestore(&device_state_lock, flags);	1051	spin_unlock_irqrestore(&device_state_lock, flags);
1038	}	1052	}
1039	EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);	1053	EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);
1040		1054
1041	#endif	1055	#endif
1042		1056
1043	static void choose_address(struct usb_device *udev)	1057	static void choose_address(struct usb_device *udev)
1044	{	1058	{
1045	int devnum;	1059	int devnum;
1046	struct usb_bus *bus = udev->bus;	1060	struct usb_bus *bus = udev->bus;
1047		1061
1048	/* If khubd ever becomes multithreaded, this will need a lock */	1062	/* If khubd ever becomes multithreaded, this will need a lock */
1049		1063
1050	/* Try to allocate the next devnum beginning at bus->devnum_next. */	1064	/* Try to allocate the next devnum beginning at bus->devnum_next. */
1051	devnum = find_next_zero_bit(bus->devmap.devicemap, 128,	1065	devnum = find_next_zero_bit(bus->devmap.devicemap, 128,
1052	bus->devnum_next);	1066	bus->devnum_next);
1053	if (devnum >= 128)	1067	if (devnum >= 128)
1054	devnum = find_next_zero_bit(bus->devmap.devicemap, 128, 1);	1068	devnum = find_next_zero_bit(bus->devmap.devicemap, 128, 1);
1055		1069
1056	bus->devnum_next = ( devnum >= 127 ? 1 : devnum + 1);	1070	bus->devnum_next = ( devnum >= 127 ? 1 : devnum + 1);
1057		1071
1058	if (devnum < 128) {	1072	if (devnum < 128) {
1059	set_bit(devnum, bus->devmap.devicemap);	1073	set_bit(devnum, bus->devmap.devicemap);
1060	udev->devnum = devnum;	1074	udev->devnum = devnum;
1061	}	1075	}
1062	}	1076	}
1063		1077
1064	static void release_address(struct usb_device *udev)	1078	static void release_address(struct usb_device *udev)
1065	{	1079	{
1066	if (udev->devnum > 0) {	1080	if (udev->devnum > 0) {
1067	clear_bit(udev->devnum, udev->bus->devmap.devicemap);	1081	clear_bit(udev->devnum, udev->bus->devmap.devicemap);
1068	udev->devnum = -1;	1082	udev->devnum = -1;
1069	}	1083	}
1070	}	1084	}
1071		1085
1072	/**	1086	/**
1073	* usb_disconnect - disconnect a device (usbcore-internal)	1087	* usb_disconnect - disconnect a device (usbcore-internal)
1074	* @pdev: pointer to device being disconnected	1088	* @pdev: pointer to device being disconnected
1075	* Context: !in_interrupt ()	1089	* Context: !in_interrupt ()
1076	*	1090	*
1077	* Something got disconnected. Get rid of it and all of its children.	1091	* Something got disconnected. Get rid of it and all of its children.
1078	*	1092	*
1079	* If *pdev is a normal device then the parent hub must already be locked.	1093	* If *pdev is a normal device then the parent hub must already be locked.
1080	* If *pdev is a root hub then this routine will acquire the	1094	* If *pdev is a root hub then this routine will acquire the
1081	* usb_bus_list_lock on behalf of the caller.	1095	* usb_bus_list_lock on behalf of the caller.
1082	*	1096	*
1083	* Only hub drivers (including virtual root hub drivers for host	1097	* Only hub drivers (including virtual root hub drivers for host
1084	* controllers) should ever call this.	1098	* controllers) should ever call this.
1085	*	1099	*
1086	* This call is synchronous, and may not be used in an interrupt context.	1100	* This call is synchronous, and may not be used in an interrupt context.
1087	*/	1101	*/
1088	void usb_disconnect(struct usb_device **pdev)	1102	void usb_disconnect(struct usb_device **pdev)
1089	{	1103	{
1090	struct usb_device udev = pdev;	1104	struct usb_device udev = pdev;
1091	int i;	1105	int i;
1092		1106
1093	if (!udev) {	1107	if (!udev) {
1094	pr_debug ("%s nodev\n", __FUNCTION__);	1108	pr_debug ("%s nodev\n", __FUNCTION__);
1095	return;	1109	return;
1096	}	1110	}
1097		1111
1098	/* mark the device as inactive, so any further urb submissions for	1112	/* mark the device as inactive, so any further urb submissions for
1099	* this device (and any of its children) will fail immediately.	1113	* this device (and any of its children) will fail immediately.
1100	* this quiesces everyting except pending urbs.	1114	* this quiesces everyting except pending urbs.
1101	*/	1115	*/
1102	usb_set_device_state(udev, USB_STATE_NOTATTACHED);	1116	usb_set_device_state(udev, USB_STATE_NOTATTACHED);
1103	dev_info (&udev->dev, "USB disconnect, address %d\n", udev->devnum);	1117	dev_info (&udev->dev, "USB disconnect, address %d\n", udev->devnum);
1104		1118
1105	usb_lock_device(udev);	1119	usb_lock_device(udev);
1106		1120
1107	/* Free up all the children before we remove this device */	1121	/* Free up all the children before we remove this device */
1108	for (i = 0; i < USB_MAXCHILDREN; i++) {	1122	for (i = 0; i < USB_MAXCHILDREN; i++) {
1109	if (udev->children[i])	1123	if (udev->children[i])
1110	usb_disconnect(&udev->children[i]);	1124	usb_disconnect(&udev->children[i]);
1111	}	1125	}
1112		1126
1113	/* deallocate hcd/hardware state ... nuking all pending urbs and	1127	/* deallocate hcd/hardware state ... nuking all pending urbs and
1114	* cleaning up all state associated with the current configuration	1128	* cleaning up all state associated with the current configuration
1115	* so that the hardware is now fully quiesced.	1129	* so that the hardware is now fully quiesced.
1116	*/	1130	*/
1117	usb_disable_device(udev, 0);	1131	usb_disable_device(udev, 0);
1118		1132
1119	usb_notify_remove_device(udev);	1133	usb_notify_remove_device(udev);
1120		1134
1121	/* Free the device number, remove the /proc/bus/usb entry and	1135	/* Free the device number, remove the /proc/bus/usb entry and
1122	* the sysfs attributes, and delete the parent's children[]	1136	* the sysfs attributes, and delete the parent's children[]
1123	* (or root_hub) pointer.	1137	* (or root_hub) pointer.
1124	*/	1138	*/
1125	dev_dbg (&udev->dev, "unregistering device\n");	1139	dev_dbg (&udev->dev, "unregistering device\n");
1126	release_address(udev);	1140	release_address(udev);
1127	usb_remove_sysfs_dev_files(udev);	1141	usb_remove_sysfs_dev_files(udev);
1128		1142
1129	/* Avoid races with recursively_mark_NOTATTACHED() */	1143	/* Avoid races with recursively_mark_NOTATTACHED() */
1130	spin_lock_irq(&device_state_lock);	1144	spin_lock_irq(&device_state_lock);
1131	*pdev = NULL;	1145	*pdev = NULL;
1132	spin_unlock_irq(&device_state_lock);	1146	spin_unlock_irq(&device_state_lock);
1133		1147
1134	usb_unlock_device(udev);	1148	usb_unlock_device(udev);
1135		1149
1136	device_unregister(&udev->dev);	1150	device_unregister(&udev->dev);
1137	}	1151	}
1138		1152
		1153	static inline const char *plural(int n)
		1154	{
		1155	return (n == 1 ? "" : "s");
		1156	}
		1157
1139	static int choose_configuration(struct usb_device *udev)	1158	static int choose_configuration(struct usb_device *udev)
1140	{	1159	{
1141	int c, i;	1160	int i;
		1161	u16 devstatus;
		1162	int bus_powered;
		1163	int num_configs;
		1164	struct usb_host_config c, best;
1142		1165
1143	/* NOTE: this should interact with hub power budgeting */	1166	/* If this fails, assume the device is bus-powered */
		1167	devstatus = 0;
		1168	usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
		1169	le16_to_cpus(&devstatus);
		1170	bus_powered = ((devstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0);
		1171	dev_dbg(&udev->dev, "device is %s-powered\n",
		1172	bus_powered ? "bus" : "self");
1144		1173
1145	c = udev->config[0].desc.bConfigurationValue;	1174	best = NULL;
1146	if (udev->descriptor.bNumConfigurations != 1) {	1175	c = udev->config;
1147	for (i = 0; i < udev->descriptor.bNumConfigurations; i++) {	1176	num_configs = udev->descriptor.bNumConfigurations;
1148	struct usb_interface_descriptor *desc;	1177	for (i = 0; i < num_configs; (i++, c++)) {
		1178	struct usb_interface_descriptor *desc =
		1179	&c->intf_cache[0]->altsetting->desc;
1149		1180
1150	/* heuristic: Linux is more likely to have class	1181	/*
1151	* drivers, so avoid vendor-specific interfaces.	1182	* HP's USB bus-powered keyboard has only one configuration
1152	*/	1183	* and it claims to be self-powered; other devices may have
1153	desc = &udev->config[i].intf_cache[0]	1184	* similar errors in their descriptors. If the next test
1154	->altsetting->desc;	1185	* were allowed to execute, such configurations would always
1155	if (desc->bInterfaceClass == USB_CLASS_VENDOR_SPEC)	1186	* be rejected and the devices would not work as expected.
1156	continue;	1187	*/
1157	/* COMM/2/all is CDC ACM, except 0xff is MSFT RNDIS.	1188	#if 0
1158	* MSFT needs this to be the first config; never use	1189	/* Rule out self-powered configs for a bus-powered device */
1159	* it as the default unless Linux has host-side RNDIS.	1190	if (bus_powered && (c->desc.bmAttributes &
1160	* A second config would ideally be CDC-Ethernet, but	1191	USB_CONFIG_ATT_SELFPOWER))
1161	* may instead be the "vendor specific" CDC subset	1192	continue;
1162	* long used by ARM Linux for sa1100 or pxa255.	1193	#endif
1163	*/	1194
1164	if (desc->bInterfaceClass == USB_CLASS_COMM	1195	/*
1165	&& desc->bInterfaceSubClass == 2	1196	* The next test may not be as effective as it should be.
1166	&& desc->bInterfaceProtocol == 0xff) {	1197	* Some hubs have errors in their descriptor, claiming
1167	c = udev->config[1].desc.bConfigurationValue;	1198	* to be self-powered when they are really bus-powered.
1168	continue;	1199	* We will overestimate the amount of current such hubs
1169	}	1200	* make available for each port.
1170	c = udev->config[i].desc.bConfigurationValue;	1201	*
		1202	* This is a fairly benign sort of failure. It won't
		1203	* cause us to reject configurations that we should have
		1204	* accepted.
		1205	*/
		1206
		1207	/* Rule out configs that draw too much bus current */
		1208	if (c->desc.bMaxPower * 2 > udev->bus_mA)
		1209	continue;
		1210
		1211	/* If the first config's first interface is COMM/2/0xff
		1212	* (MSFT RNDIS), rule it out unless Linux has host-side
		1213	* RNDIS support. */
		1214	if (i == 0 && desc->bInterfaceClass == USB_CLASS_COMM
		1215	&& desc->bInterfaceSubClass == 2
		1216	&& desc->bInterfaceProtocol == 0xff) {
		1217	#ifndef CONFIG_USB_NET_RNDIS
		1218	continue;
		1219	#else
		1220	best = c;
		1221	#endif
		1222	}
		1223
		1224	/* From the remaining configs, choose the first one whose
		1225	* first interface is for a non-vendor-specific class.
		1226	* Reason: Linux is more likely to have a class driver
		1227	* than a vendor-specific driver. */
		1228	else if (udev->descriptor.bDeviceClass !=
		1229	USB_CLASS_VENDOR_SPEC &&
		1230	desc->bInterfaceClass !=
		1231	USB_CLASS_VENDOR_SPEC) {
		1232	best = c;
1171	break;	1233	break;
1172	}	1234	}
		1235
		1236	/* If all the remaining configs are vendor-specific,
		1237	* choose the first one. */
		1238	else if (!best)
		1239	best = c;
		1240	}
		1241
		1242	if (best) {
		1243	i = best->desc.bConfigurationValue;
1173	dev_info(&udev->dev,	1244	dev_info(&udev->dev,
1174	"configuration #%d chosen from %d choices\n",	1245	"configuration #%d chosen from %d choice%s\n",
1175	c, udev->descriptor.bNumConfigurations);	1246	i, num_configs, plural(num_configs));
		1247	} else {
		1248	i = -1;
		1249	dev_warn(&udev->dev,
		1250	"no configuration chosen from %d choice%s\n",
		1251	num_configs, plural(num_configs));
1176	}	1252	}
1177	return c;	1253	return i;
1178	}	1254	}
1179		1255
1180	#ifdef DEBUG	1256	#ifdef DEBUG
1181	static void show_string(struct usb_device udev, char id, char *string)	1257	static void show_string(struct usb_device udev, char id, char *string)
1182	{	1258	{
1183	if (!string)	1259	if (!string)
1184	return;	1260	return;
1185	dev_printk(KERN_INFO, &udev->dev, "%s: %s\n", id, string);	1261	dev_printk(KERN_INFO, &udev->dev, "%s: %s\n", id, string);
1186	}	1262	}
1187		1263
1188	#else	1264	#else
1189	static inline void show_string(struct usb_device udev, char id, char *string)	1265	static inline void show_string(struct usb_device udev, char id, char *string)
1190	{}	1266	{}
1191	#endif	1267	#endif
1192		1268
1193		1269
1194	#ifdef CONFIG_USB_OTG	1270	#ifdef CONFIG_USB_OTG
1195	#include "otg_whitelist.h"	1271	#include "otg_whitelist.h"
1196	#endif	1272	#endif
1197		1273
1198	/**	1274	/**
1199	* usb_new_device - perform initial device setup (usbcore-internal)	1275	* usb_new_device - perform initial device setup (usbcore-internal)
1200	* @udev: newly addressed device (in ADDRESS state)	1276	* @udev: newly addressed device (in ADDRESS state)
1201	*	1277	*
1202	* This is called with devices which have been enumerated, but not yet	1278	* This is called with devices which have been enumerated, but not yet
1203	* configured. The device descriptor is available, but not descriptors	1279	* configured. The device descriptor is available, but not descriptors
1204	* for any device configuration. The caller must have locked either	1280	* for any device configuration. The caller must have locked either
1205	* the parent hub (if udev is a normal device) or else the	1281	* the parent hub (if udev is a normal device) or else the
1206	* usb_bus_list_lock (if udev is a root hub). The parent's pointer to	1282	* usb_bus_list_lock (if udev is a root hub). The parent's pointer to
1207	* udev has already been installed, but udev is not yet visible through	1283	* udev has already been installed, but udev is not yet visible through
1208	* sysfs or other filesystem code.	1284	* sysfs or other filesystem code.
1209	*	1285	*
1210	* Returns 0 for success (device is configured and listed, with its	1286	* Returns 0 for success (device is configured and listed, with its
1211	* interfaces, in sysfs); else a negative errno value.	1287	* interfaces, in sysfs); else a negative errno value.
1212	*	1288	*
1213	* This call is synchronous, and may not be used in an interrupt context.	1289	* This call is synchronous, and may not be used in an interrupt context.
1214	*	1290	*
1215	* Only the hub driver or root-hub registrar should ever call this.	1291	* Only the hub driver or root-hub registrar should ever call this.
1216	*/	1292	*/
1217	int usb_new_device(struct usb_device *udev)	1293	int usb_new_device(struct usb_device *udev)
1218	{	1294	{
1219	int err;	1295	int err;
1220	int c;	1296	int c;
1221		1297
1222	err = usb_get_configuration(udev);	1298	err = usb_get_configuration(udev);
1223	if (err < 0) {	1299	if (err < 0) {
1224	dev_err(&udev->dev, "can't read configurations, error %d\n",	1300	dev_err(&udev->dev, "can't read configurations, error %d\n",
1225	err);	1301	err);
1226	goto fail;	1302	goto fail;
1227	}	1303	}
1228		1304
1229	/* read the standard strings and cache them if present */	1305	/* read the standard strings and cache them if present */
1230	udev->product = usb_cache_string(udev, udev->descriptor.iProduct);	1306	udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
1231	udev->manufacturer = usb_cache_string(udev,	1307	udev->manufacturer = usb_cache_string(udev,
1232	udev->descriptor.iManufacturer);	1308	udev->descriptor.iManufacturer);
1233	udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);	1309	udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
1234		1310
1235	/* Tell the world! */	1311	/* Tell the world! */
1236	dev_dbg(&udev->dev, "new device strings: Mfr=%d, Product=%d, "	1312	dev_dbg(&udev->dev, "new device strings: Mfr=%d, Product=%d, "
1237	"SerialNumber=%d\n",	1313	"SerialNumber=%d\n",
1238	udev->descriptor.iManufacturer,	1314	udev->descriptor.iManufacturer,
1239	udev->descriptor.iProduct,	1315	udev->descriptor.iProduct,
1240	udev->descriptor.iSerialNumber);	1316	udev->descriptor.iSerialNumber);
1241	show_string(udev, "Product", udev->product);	1317	show_string(udev, "Product", udev->product);
1242	show_string(udev, "Manufacturer", udev->manufacturer);	1318	show_string(udev, "Manufacturer", udev->manufacturer);
1243	show_string(udev, "SerialNumber", udev->serial);	1319	show_string(udev, "SerialNumber", udev->serial);
1244		1320
1245	#ifdef CONFIG_USB_OTG	1321	#ifdef CONFIG_USB_OTG
1246	/*	1322	/*
1247	* OTG-aware devices on OTG-capable root hubs may be able to use SRP,	1323	* OTG-aware devices on OTG-capable root hubs may be able to use SRP,
1248	* to wake us after we've powered off VBUS; and HNP, switching roles	1324	* to wake us after we've powered off VBUS; and HNP, switching roles
1249	* "host" to "peripheral". The OTG descriptor helps figure this out.	1325	* "host" to "peripheral". The OTG descriptor helps figure this out.
1250	*/	1326	*/
1251	if (!udev->bus->is_b_host	1327	if (!udev->bus->is_b_host
1252	&& udev->config	1328	&& udev->config
1253	&& udev->parent == udev->bus->root_hub) {	1329	&& udev->parent == udev->bus->root_hub) {
1254	struct usb_otg_descriptor *desc = 0;	1330	struct usb_otg_descriptor *desc = 0;
1255	struct usb_bus *bus = udev->bus;	1331	struct usb_bus *bus = udev->bus;
1256		1332
1257	/* descriptor may appear anywhere in config */	1333	/* descriptor may appear anywhere in config */
1258	if (__usb_get_extra_descriptor (udev->rawdescriptors[0],	1334	if (__usb_get_extra_descriptor (udev->rawdescriptors[0],
1259	le16_to_cpu(udev->config[0].desc.wTotalLength),	1335	le16_to_cpu(udev->config[0].desc.wTotalLength),
1260	USB_DT_OTG, (void **) &desc) == 0) {	1336	USB_DT_OTG, (void **) &desc) == 0) {
1261	if (desc->bmAttributes & USB_OTG_HNP) {	1337	if (desc->bmAttributes & USB_OTG_HNP) {
1262	unsigned port1;	1338	unsigned port1;
1263	struct usb_device *root = udev->parent;	1339	struct usb_device *root = udev->parent;
1264		1340
1265	for (port1 = 1; port1 <= root->maxchild;	1341	for (port1 = 1; port1 <= root->maxchild;
1266	port1++) {	1342	port1++) {
1267	if (root->children[port1-1] == udev)	1343	if (root->children[port1-1] == udev)
1268	break;	1344	break;
1269	}	1345	}
1270		1346
1271	dev_info(&udev->dev,	1347	dev_info(&udev->dev,
1272	"Dual-Role OTG device on %sHNP port\n",	1348	"Dual-Role OTG device on %sHNP port\n",
1273	(port1 == bus->otg_port)	1349	(port1 == bus->otg_port)
1274	? "" : "non-");	1350	? "" : "non-");
1275		1351
1276	/* enable HNP before suspend, it's simpler */	1352	/* enable HNP before suspend, it's simpler */
1277	if (port1 == bus->otg_port)	1353	if (port1 == bus->otg_port)
1278	bus->b_hnp_enable = 1;	1354	bus->b_hnp_enable = 1;
1279	err = usb_control_msg(udev,	1355	err = usb_control_msg(udev,
1280	usb_sndctrlpipe(udev, 0),	1356	usb_sndctrlpipe(udev, 0),
1281	USB_REQ_SET_FEATURE, 0,	1357	USB_REQ_SET_FEATURE, 0,
1282	bus->b_hnp_enable	1358	bus->b_hnp_enable
1283	? USB_DEVICE_B_HNP_ENABLE	1359	? USB_DEVICE_B_HNP_ENABLE
1284	: USB_DEVICE_A_ALT_HNP_SUPPORT,	1360	: USB_DEVICE_A_ALT_HNP_SUPPORT,
1285	0, NULL, 0, USB_CTRL_SET_TIMEOUT);	1361	0, NULL, 0, USB_CTRL_SET_TIMEOUT);
1286	if (err < 0) {	1362	if (err < 0) {
1287	/* OTG MESSAGE: report errors here,	1363	/* OTG MESSAGE: report errors here,
1288	* customize to match your product.	1364	* customize to match your product.
1289	*/	1365	*/
1290	dev_info(&udev->dev,	1366	dev_info(&udev->dev,
1291	"can't set HNP mode; %d\n",	1367	"can't set HNP mode; %d\n",
1292	err);	1368	err);
1293	bus->b_hnp_enable = 0;	1369	bus->b_hnp_enable = 0;
1294	}	1370	}
1295	}	1371	}
1296	}	1372	}
1297	}	1373	}
1298		1374
1299	if (!is_targeted(udev)) {	1375	if (!is_targeted(udev)) {
1300		1376
1301	/* Maybe it can talk to us, though we can't talk to it.	1377	/* Maybe it can talk to us, though we can't talk to it.
1302	* (Includes HNP test device.)	1378	* (Includes HNP test device.)
1303	*/	1379	*/
1304	if (udev->bus->b_hnp_enable \|\| udev->bus->is_b_host) {	1380	if (udev->bus->b_hnp_enable \|\| udev->bus->is_b_host) {
1305	static int __usb_suspend_device(struct usb_device *,	1381	static int __usb_suspend_device(struct usb_device *,
1306	int port1);	1382	int port1);
1307	err = __usb_suspend_device(udev, udev->bus->otg_port);	1383	err = __usb_suspend_device(udev, udev->bus->otg_port);
1308	if (err < 0)	1384	if (err < 0)
1309	dev_dbg(&udev->dev, "HNP fail, %d\n", err);	1385	dev_dbg(&udev->dev, "HNP fail, %d\n", err);
1310	}	1386	}
1311	err = -ENODEV;	1387	err = -ENODEV;
1312	goto fail;	1388	goto fail;
1313	}	1389	}
1314	#endif	1390	#endif
1315		1391
1316	/* put device-specific files into sysfs */	1392	/* put device-specific files into sysfs */
1317	err = device_add (&udev->dev);	1393	err = device_add (&udev->dev);
1318	if (err) {	1394	if (err) {
1319	dev_err(&udev->dev, "can't device_add, error %d\n", err);	1395	dev_err(&udev->dev, "can't device_add, error %d\n", err);
1320	goto fail;	1396	goto fail;
1321	}	1397	}
1322	usb_create_sysfs_dev_files (udev);	1398	usb_create_sysfs_dev_files (udev);
1323		1399
1324	usb_lock_device(udev);	1400	usb_lock_device(udev);
1325		1401
1326	/* choose and set the configuration. that registers the interfaces	1402	/* choose and set the configuration. that registers the interfaces
1327	* with the driver core, and lets usb device drivers bind to them.	1403	* with the driver core, and lets usb device drivers bind to them.
1328	*/	1404	*/
1329	c = choose_configuration(udev);	1405	c = choose_configuration(udev);
1330	if (c < 0)	1406	if (c >= 0) {
1331	dev_warn(&udev->dev,
1332	"can't choose an initial configuration\n");
1333	else {
1334	err = usb_set_configuration(udev, c);	1407	err = usb_set_configuration(udev, c);
1335	if (err) {	1408	if (err) {
1336	dev_err(&udev->dev, "can't set config #%d, error %d\n",	1409	dev_err(&udev->dev, "can't set config #%d, error %d\n",
1337	c, err);	1410	c, err);
1338	usb_remove_sysfs_dev_files(udev);	1411	/* This need not be fatal. The user can try to
1339	device_del(&udev->dev);	1412	* set other configurations. */
1340	goto fail;
1341	}	1413	}
1342	}	1414	}
1343		1415
1344	/* USB device state == configured ... usable */	1416	/* USB device state == configured ... usable */
1345	usb_notify_add_device(udev);	1417	usb_notify_add_device(udev);
1346		1418
1347	usb_unlock_device(udev);	1419	usb_unlock_device(udev);
1348		1420
1349	return 0;	1421	return 0;
1350		1422
1351	fail:	1423	fail:
1352	usb_set_device_state(udev, USB_STATE_NOTATTACHED);	1424	usb_set_device_state(udev, USB_STATE_NOTATTACHED);
1353	return err;	1425	return err;
1354	}	1426	}
1355		1427
1356		1428
1357	static int hub_port_status(struct usb_hub *hub, int port1,	1429	static int hub_port_status(struct usb_hub *hub, int port1,
1358	u16 status, u16 change)	1430	u16 status, u16 change)
1359	{	1431	{
1360	int ret;	1432	int ret;
1361		1433
1362	ret = get_port_status(hub->hdev, port1, &hub->status->port);	1434	ret = get_port_status(hub->hdev, port1, &hub->status->port);
1363	if (ret < 0)	1435	if (ret < 0)
1364	dev_err (hub->intfdev,	1436	dev_err (hub->intfdev,
1365	"%s failed (err = %d)\n", __FUNCTION__, ret);	1437	"%s failed (err = %d)\n", __FUNCTION__, ret);
1366	else {	1438	else {
1367	*status = le16_to_cpu(hub->status->port.wPortStatus);	1439	*status = le16_to_cpu(hub->status->port.wPortStatus);
1368	*change = le16_to_cpu(hub->status->port.wPortChange);	1440	*change = le16_to_cpu(hub->status->port.wPortChange);
1369	ret = 0;	1441	ret = 0;
1370	}	1442	}
1371	return ret;	1443	return ret;
1372	}	1444	}
1373		1445
1374	#define PORT_RESET_TRIES 5	1446	#define PORT_RESET_TRIES 5
1375	#define SET_ADDRESS_TRIES 2	1447	#define SET_ADDRESS_TRIES 2
1376	#define GET_DESCRIPTOR_TRIES 2	1448	#define GET_DESCRIPTOR_TRIES 2
1377	#define SET_CONFIG_TRIES (2 * (use_both_schemes + 1))	1449	#define SET_CONFIG_TRIES (2 * (use_both_schemes + 1))
1378	#define USE_NEW_SCHEME(i) ((i) / 2 == old_scheme_first)	1450	#define USE_NEW_SCHEME(i) ((i) / 2 == old_scheme_first)
1379		1451
1380	#define HUB_ROOT_RESET_TIME 50 /* times are in msec */	1452	#define HUB_ROOT_RESET_TIME 50 /* times are in msec */
1381	#define HUB_SHORT_RESET_TIME 10	1453	#define HUB_SHORT_RESET_TIME 10
1382	#define HUB_LONG_RESET_TIME 200	1454	#define HUB_LONG_RESET_TIME 200
1383	#define HUB_RESET_TIMEOUT 500	1455	#define HUB_RESET_TIMEOUT 500
1384		1456
1385	static int hub_port_wait_reset(struct usb_hub *hub, int port1,	1457	static int hub_port_wait_reset(struct usb_hub *hub, int port1,
1386	struct usb_device *udev, unsigned int delay)	1458	struct usb_device *udev, unsigned int delay)
1387	{	1459	{
1388	int delay_time, ret;	1460	int delay_time, ret;
1389	u16 portstatus;	1461	u16 portstatus;
1390	u16 portchange;	1462	u16 portchange;
1391		1463
1392	for (delay_time = 0;	1464	for (delay_time = 0;
1393	delay_time < HUB_RESET_TIMEOUT;	1465	delay_time < HUB_RESET_TIMEOUT;
1394	delay_time += delay) {	1466	delay_time += delay) {
1395	/* wait to give the device a chance to reset */	1467	/* wait to give the device a chance to reset */
1396	msleep(delay);	1468	msleep(delay);
1397		1469
1398	/* read and decode port status */	1470	/* read and decode port status */
1399	ret = hub_port_status(hub, port1, &portstatus, &portchange);	1471	ret = hub_port_status(hub, port1, &portstatus, &portchange);
1400	if (ret < 0)	1472	if (ret < 0)
1401	return ret;	1473	return ret;
1402		1474
1403	/* Device went away? */	1475	/* Device went away? */
1404	if (!(portstatus & USB_PORT_STAT_CONNECTION))	1476	if (!(portstatus & USB_PORT_STAT_CONNECTION))
1405	return -ENOTCONN;	1477	return -ENOTCONN;
1406		1478
1407	/* bomb out completely if something weird happened */	1479	/* bomb out completely if something weird happened */
1408	if ((portchange & USB_PORT_STAT_C_CONNECTION))	1480	if ((portchange & USB_PORT_STAT_C_CONNECTION))
1409	return -EINVAL;	1481	return -EINVAL;
1410		1482
1411	/* if we`ve finished resetting, then break out of the loop */	1483	/* if we`ve finished resetting, then break out of the loop */
1412	if (!(portstatus & USB_PORT_STAT_RESET) &&	1484	if (!(portstatus & USB_PORT_STAT_RESET) &&
1413	(portstatus & USB_PORT_STAT_ENABLE)) {	1485	(portstatus & USB_PORT_STAT_ENABLE)) {
1414	if (portstatus & USB_PORT_STAT_HIGH_SPEED)	1486	if (portstatus & USB_PORT_STAT_HIGH_SPEED)
1415	udev->speed = USB_SPEED_HIGH;	1487	udev->speed = USB_SPEED_HIGH;
1416	else if (portstatus & USB_PORT_STAT_LOW_SPEED)	1488	else if (portstatus & USB_PORT_STAT_LOW_SPEED)
1417	udev->speed = USB_SPEED_LOW;	1489	udev->speed = USB_SPEED_LOW;
1418	else	1490	else
1419	udev->speed = USB_SPEED_FULL;	1491	udev->speed = USB_SPEED_FULL;
1420	return 0;	1492	return 0;
1421	}	1493	}
1422		1494
1423	/* switch to the long delay after two short delay failures */	1495	/* switch to the long delay after two short delay failures */
1424	if (delay_time >= 2 * HUB_SHORT_RESET_TIME)	1496	if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
1425	delay = HUB_LONG_RESET_TIME;	1497	delay = HUB_LONG_RESET_TIME;
1426		1498
1427	dev_dbg (hub->intfdev,	1499	dev_dbg (hub->intfdev,
1428	"port %d not reset yet, waiting %dms\n",	1500	"port %d not reset yet, waiting %dms\n",
1429	port1, delay);	1501	port1, delay);
1430	}	1502	}
1431		1503
1432	return -EBUSY;	1504	return -EBUSY;
1433	}	1505	}
1434		1506
1435	static int hub_port_reset(struct usb_hub *hub, int port1,	1507	static int hub_port_reset(struct usb_hub *hub, int port1,
1436	struct usb_device *udev, unsigned int delay)	1508	struct usb_device *udev, unsigned int delay)
1437	{	1509	{
1438	int i, status;	1510	int i, status;
1439		1511
1440	/* Reset the port */	1512	/* Reset the port */
1441	for (i = 0; i < PORT_RESET_TRIES; i++) {	1513	for (i = 0; i < PORT_RESET_TRIES; i++) {
1442	status = set_port_feature(hub->hdev,	1514	status = set_port_feature(hub->hdev,
1443	port1, USB_PORT_FEAT_RESET);	1515	port1, USB_PORT_FEAT_RESET);
1444	if (status)	1516	if (status)
1445	dev_err(hub->intfdev,	1517	dev_err(hub->intfdev,
1446	"cannot reset port %d (err = %d)\n",	1518	"cannot reset port %d (err = %d)\n",
1447	port1, status);	1519	port1, status);
1448	else {	1520	else {
1449	status = hub_port_wait_reset(hub, port1, udev, delay);	1521	status = hub_port_wait_reset(hub, port1, udev, delay);
1450	if (status && status != -ENOTCONN)	1522	if (status && status != -ENOTCONN)
1451	dev_dbg(hub->intfdev,	1523	dev_dbg(hub->intfdev,
1452	"port_wait_reset: err = %d\n",	1524	"port_wait_reset: err = %d\n",
1453	status);	1525	status);
1454	}	1526	}
1455		1527
1456	/* return on disconnect or reset */	1528	/* return on disconnect or reset */
1457	switch (status) {	1529	switch (status) {
1458	case 0:	1530	case 0:
1459	/* TRSTRCY = 10 ms; plus some extra */	1531	/* TRSTRCY = 10 ms; plus some extra */
1460	msleep(10 + 40);	1532	msleep(10 + 40);
1461	/* FALL THROUGH */	1533	/* FALL THROUGH */
1462	case -ENOTCONN:	1534	case -ENOTCONN:
1463	case -ENODEV:	1535	case -ENODEV:
1464	clear_port_feature(hub->hdev,	1536	clear_port_feature(hub->hdev,
1465	port1, USB_PORT_FEAT_C_RESET);	1537	port1, USB_PORT_FEAT_C_RESET);
1466	/* FIXME need disconnect() for NOTATTACHED device */	1538	/* FIXME need disconnect() for NOTATTACHED device */
1467	usb_set_device_state(udev, status	1539	usb_set_device_state(udev, status
1468	? USB_STATE_NOTATTACHED	1540	? USB_STATE_NOTATTACHED
1469	: USB_STATE_DEFAULT);	1541	: USB_STATE_DEFAULT);
1470	return status;	1542	return status;
1471	}	1543	}
1472		1544
1473	dev_dbg (hub->intfdev,	1545	dev_dbg (hub->intfdev,
1474	"port %d not enabled, trying reset again...\n",	1546	"port %d not enabled, trying reset again...\n",
1475	port1);	1547	port1);
1476	delay = HUB_LONG_RESET_TIME;	1548	delay = HUB_LONG_RESET_TIME;
1477	}	1549	}
1478		1550
1479	dev_err (hub->intfdev,	1551	dev_err (hub->intfdev,
1480	"Cannot enable port %i. Maybe the USB cable is bad?\n",	1552	"Cannot enable port %i. Maybe the USB cable is bad?\n",
1481	port1);	1553	port1);
1482		1554
1483	return status;	1555	return status;
1484	}	1556	}
1485		1557
1486	/*	1558	/*
1487	* Disable a port and mark a logical connnect-change event, so that some	1559	* Disable a port and mark a logical connnect-change event, so that some
1488	* time later khubd will disconnect() any existing usb_device on the port	1560	* time later khubd will disconnect() any existing usb_device on the port
1489	* and will re-enumerate if there actually is a device attached.	1561	* and will re-enumerate if there actually is a device attached.
1490	*/	1562	*/
1491	static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)	1563	static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
1492	{	1564	{
1493	dev_dbg(hub->intfdev, "logical disconnect on port %d\n", port1);	1565	dev_dbg(hub->intfdev, "logical disconnect on port %d\n", port1);
1494	hub_port_disable(hub, port1, 1);	1566	hub_port_disable(hub, port1, 1);
1495		1567
1496	/* FIXME let caller ask to power down the port:	1568	/* FIXME let caller ask to power down the port:
1497	* - some devices won't enumerate without a VBUS power cycle	1569	* - some devices won't enumerate without a VBUS power cycle
1498	* - SRP saves power that way	1570	* - SRP saves power that way
1499	* - ... new call, TBD ...	1571	* - ... new call, TBD ...
1500	* That's easy if this hub can switch power per-port, and	1572	* That's easy if this hub can switch power per-port, and
1501	* khubd reactivates the port later (timer, SRP, etc).	1573	* khubd reactivates the port later (timer, SRP, etc).
1502	* Powerdown must be optional, because of reset/DFU.	1574	* Powerdown must be optional, because of reset/DFU.
1503	*/	1575	*/
1504		1576
1505	set_bit(port1, hub->change_bits);	1577	set_bit(port1, hub->change_bits);
1506	kick_khubd(hub);	1578	kick_khubd(hub);
1507	}	1579	}
1508		1580
1509		1581
1510	#ifdef CONFIG_USB_SUSPEND	1582	#ifdef CONFIG_USB_SUSPEND
1511		1583
1512	/*	1584	/*
1513	* Selective port suspend reduces power; most suspended devices draw	1585	* Selective port suspend reduces power; most suspended devices draw
1514	* less than 500 uA. It's also used in OTG, along with remote wakeup.	1586	* less than 500 uA. It's also used in OTG, along with remote wakeup.
1515	* All devices below the suspended port are also suspended.	1587	* All devices below the suspended port are also suspended.
1516	*	1588	*
1517	* Devices leave suspend state when the host wakes them up. Some devices	1589	* Devices leave suspend state when the host wakes them up. Some devices
1518	* also support "remote wakeup", where the device can activate the USB	1590	* also support "remote wakeup", where the device can activate the USB
1519	* tree above them to deliver data, such as a keypress or packet. In	1591	* tree above them to deliver data, such as a keypress or packet. In
1520	* some cases, this wakes the USB host.	1592	* some cases, this wakes the USB host.
1521	*/	1593	*/
1522	static int hub_port_suspend(struct usb_hub *hub, int port1,	1594	static int hub_port_suspend(struct usb_hub *hub, int port1,
1523	struct usb_device *udev)	1595	struct usb_device *udev)
1524	{	1596	{
1525	int status;	1597	int status;
1526		1598
1527	// dev_dbg(hub->intfdev, "suspend port %d\n", port1);	1599	// dev_dbg(hub->intfdev, "suspend port %d\n", port1);
1528		1600
1529	/* enable remote wakeup when appropriate; this lets the device	1601	/* enable remote wakeup when appropriate; this lets the device
1530	* wake up the upstream hub (including maybe the root hub).	1602	* wake up the upstream hub (including maybe the root hub).
1531	*	1603	*
1532	* NOTE: OTG devices may issue remote wakeup (or SRP) even when	1604	* NOTE: OTG devices may issue remote wakeup (or SRP) even when
1533	* we don't explicitly enable it here.	1605	* we don't explicitly enable it here.
1534	*/	1606	*/
1535	if (device_may_wakeup(&udev->dev)) {	1607	if (device_may_wakeup(&udev->dev)) {
1536	status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),	1608	status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
1537	USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,	1609	USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
1538	USB_DEVICE_REMOTE_WAKEUP, 0,	1610	USB_DEVICE_REMOTE_WAKEUP, 0,
1539	NULL, 0,	1611	NULL, 0,
1540	USB_CTRL_SET_TIMEOUT);	1612	USB_CTRL_SET_TIMEOUT);
1541	if (status)	1613	if (status)
1542	dev_dbg(&udev->dev,	1614	dev_dbg(&udev->dev,
1543	"won't remote wakeup, status %d\n",	1615	"won't remote wakeup, status %d\n",
1544	status);	1616	status);
1545	}	1617	}
1546		1618
1547	/* see 7.1.7.6 */	1619	/* see 7.1.7.6 */
1548	status = set_port_feature(hub->hdev, port1, USB_PORT_FEAT_SUSPEND);	1620	status = set_port_feature(hub->hdev, port1, USB_PORT_FEAT_SUSPEND);
1549	if (status) {	1621	if (status) {
1550	dev_dbg(hub->intfdev,	1622	dev_dbg(hub->intfdev,
1551	"can't suspend port %d, status %d\n",	1623	"can't suspend port %d, status %d\n",
1552	port1, status);	1624	port1, status);
1553	/* paranoia: "should not happen" */	1625	/* paranoia: "should not happen" */
1554	(void) usb_control_msg(udev, usb_sndctrlpipe(udev, 0),	1626	(void) usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
1555	USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,	1627	USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
1556	USB_DEVICE_REMOTE_WAKEUP, 0,	1628	USB_DEVICE_REMOTE_WAKEUP, 0,
1557	NULL, 0,	1629	NULL, 0,
1558	USB_CTRL_SET_TIMEOUT);	1630	USB_CTRL_SET_TIMEOUT);
1559	} else {	1631	} else {
1560	/* device has up to 10 msec to fully suspend */	1632	/* device has up to 10 msec to fully suspend */
1561	dev_dbg(&udev->dev, "usb suspend\n");	1633	dev_dbg(&udev->dev, "usb suspend\n");
1562	usb_set_device_state(udev, USB_STATE_SUSPENDED);	1634	usb_set_device_state(udev, USB_STATE_SUSPENDED);
1563	msleep(10);	1635	msleep(10);
1564	}	1636	}
1565	return status;	1637	return status;
1566	}	1638	}
1567		1639
1568	/*	1640	/*
1569	* Devices on USB hub ports have only one "suspend" state, corresponding	1641	* Devices on USB hub ports have only one "suspend" state, corresponding
1570	* to ACPI D2, "may cause the device to lose some context".	1642	* to ACPI D2, "may cause the device to lose some context".
1571	* State transitions include:	1643	* State transitions include:
1572	*	1644	*
1573	* - suspend, resume ... when the VBUS power link stays live	1645	* - suspend, resume ... when the VBUS power link stays live
1574	* - suspend, disconnect ... VBUS lost	1646	* - suspend, disconnect ... VBUS lost
1575	*	1647	*
1576	* Once VBUS drop breaks the circuit, the port it's using has to go through	1648	* Once VBUS drop breaks the circuit, the port it's using has to go through
1577	* normal re-enumeration procedures, starting with enabling VBUS power.	1649	* normal re-enumeration procedures, starting with enabling VBUS power.
1578	* Other than re-initializing the hub (plug/unplug, except for root hubs),	1650	* Other than re-initializing the hub (plug/unplug, except for root hubs),
1579	* Linux (2.6) currently has NO mechanisms to initiate that: no khubd	1651	* Linux (2.6) currently has NO mechanisms to initiate that: no khubd
1580	* timer, no SRP, no requests through sysfs.	1652	* timer, no SRP, no requests through sysfs.
1581	*	1653	*
1582	* If CONFIG_USB_SUSPEND isn't enabled, devices only really suspend when	1654	* If CONFIG_USB_SUSPEND isn't enabled, devices only really suspend when
1583	* the root hub for their bus goes into global suspend ... so we don't	1655	* the root hub for their bus goes into global suspend ... so we don't
1584	* (falsely) update the device power state to say it suspended.	1656	* (falsely) update the device power state to say it suspended.
1585	*/	1657	*/
1586	static int __usb_suspend_device (struct usb_device *udev, int port1)	1658	static int __usb_suspend_device (struct usb_device *udev, int port1)
1587	{	1659	{
1588	int status = 0;	1660	int status = 0;
1589		1661
1590	/* caller owns the udev device lock */	1662	/* caller owns the udev device lock */
1591	if (port1 < 0)	1663	if (port1 < 0)
1592	return port1;	1664	return port1;
1593		1665
1594	if (udev->state == USB_STATE_SUSPENDED	1666	if (udev->state == USB_STATE_SUSPENDED
1595	\|\| udev->state == USB_STATE_NOTATTACHED) {	1667	\|\| udev->state == USB_STATE_NOTATTACHED) {
1596	return 0;	1668	return 0;
1597	}	1669	}
1598		1670
1599	/* all interfaces must already be suspended */	1671	/* all interfaces must already be suspended */
1600	if (udev->actconfig) {	1672	if (udev->actconfig) {
1601	int i;	1673	int i;
1602		1674
1603	for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {	1675	for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1604	struct usb_interface *intf;	1676	struct usb_interface *intf;
1605		1677
1606	intf = udev->actconfig->interface[i];	1678	intf = udev->actconfig->interface[i];
1607	if (is_active(intf)) {	1679	if (is_active(intf)) {
1608	dev_dbg(&intf->dev, "nyet suspended\n");	1680	dev_dbg(&intf->dev, "nyet suspended\n");
1609	return -EBUSY;	1681	return -EBUSY;
1610	}	1682	}
1611	}	1683	}
1612	}	1684	}
1613		1685
1614	/* we only change a device's upstream USB link.	1686	/* we only change a device's upstream USB link.
1615	* root hubs have no upstream USB link.	1687	* root hubs have no upstream USB link.
1616	*/	1688	*/
1617	if (udev->parent)	1689	if (udev->parent)
1618	status = hub_port_suspend(hdev_to_hub(udev->parent), port1,	1690	status = hub_port_suspend(hdev_to_hub(udev->parent), port1,
1619	udev);	1691	udev);
1620		1692
1621	if (status == 0)	1693	if (status == 0)
1622	udev->dev.power.power_state = PMSG_SUSPEND;	1694	udev->dev.power.power_state = PMSG_SUSPEND;
1623	return status;	1695	return status;
1624	}	1696	}
1625		1697
1626	#endif	1698	#endif
1627		1699
1628	/*	1700	/*
1629	* usb_suspend_device - suspend a usb device	1701	* usb_suspend_device - suspend a usb device
1630	* @udev: device that's no longer in active use	1702	* @udev: device that's no longer in active use
1631	* Context: must be able to sleep; device not locked; pm locks held	1703	* Context: must be able to sleep; device not locked; pm locks held
1632	*	1704	*
1633	* Suspends a USB device that isn't in active use, conserving power.	1705	* Suspends a USB device that isn't in active use, conserving power.
1634	* Devices may wake out of a suspend, if anything important happens,	1706	* Devices may wake out of a suspend, if anything important happens,
1635	* using the remote wakeup mechanism. They may also be taken out of	1707	* using the remote wakeup mechanism. They may also be taken out of
1636	* suspend by the host, using usb_resume_device(). It's also routine	1708	* suspend by the host, using usb_resume_device(). It's also routine
1637	* to disconnect devices while they are suspended.	1709	* to disconnect devices while they are suspended.
1638	*	1710	*
1639	* This only affects the USB hardware for a device; its interfaces	1711	* This only affects the USB hardware for a device; its interfaces
1640	* (and, for hubs, child devices) must already have been suspended.	1712	* (and, for hubs, child devices) must already have been suspended.
1641	*	1713	*
1642	* Suspending OTG devices may trigger HNP, if that's been enabled	1714	* Suspending OTG devices may trigger HNP, if that's been enabled
1643	* between a pair of dual-role devices. That will change roles, such	1715	* between a pair of dual-role devices. That will change roles, such
1644	* as from A-Host to A-Peripheral or from B-Host back to B-Peripheral.	1716	* as from A-Host to A-Peripheral or from B-Host back to B-Peripheral.
1645	*	1717	*
1646	* Returns 0 on success, else negative errno.	1718	* Returns 0 on success, else negative errno.
1647	*/	1719	*/
1648	int usb_suspend_device(struct usb_device *udev)	1720	int usb_suspend_device(struct usb_device *udev)
1649	{	1721	{
1650	#ifdef CONFIG_USB_SUSPEND	1722	#ifdef CONFIG_USB_SUSPEND
1651	int port1;	1723	int port1;
1652		1724
1653	if (udev->state == USB_STATE_NOTATTACHED)	1725	if (udev->state == USB_STATE_NOTATTACHED)
1654	return -ENODEV;	1726	return -ENODEV;
1655	if (!udev->parent)	1727	if (!udev->parent)
1656	port1 = 0;	1728	port1 = 0;
1657	else {	1729	else {
1658	for (port1 = udev->parent->maxchild; port1 > 0; --port1) {	1730	for (port1 = udev->parent->maxchild; port1 > 0; --port1) {
1659	if (udev->parent->children[port1-1] == udev)	1731	if (udev->parent->children[port1-1] == udev)
1660	break;	1732	break;
1661	}	1733	}
1662	if (port1 == 0)	1734	if (port1 == 0)
1663	return -ENODEV;	1735	return -ENODEV;
1664	}	1736	}
1665		1737
1666	return __usb_suspend_device(udev, port1);	1738	return __usb_suspend_device(udev, port1);
1667	#else	1739	#else
1668	/* NOTE: udev->state unchanged, it's not lying ... */	1740	/* NOTE: udev->state unchanged, it's not lying ... */
1669	udev->dev.power.power_state = PMSG_SUSPEND;	1741	udev->dev.power.power_state = PMSG_SUSPEND;
1670	return 0;	1742	return 0;
1671	#endif	1743	#endif
1672	}	1744	}
1673		1745
1674	/*	1746	/*
1675	* If the USB "suspend" state is in use (rather than "global suspend"),	1747	* If the USB "suspend" state is in use (rather than "global suspend"),
1676	* many devices will be individually taken out of suspend state using	1748	* many devices will be individually taken out of suspend state using
1677	* special" resume" signaling. These routines kick in shortly after	1749	* special" resume" signaling. These routines kick in shortly after
1678	* hardware resume signaling is finished, either because of selective	1750	* hardware resume signaling is finished, either because of selective
1679	* resume (by host) or remote wakeup (by device) ... now see what changed	1751	* resume (by host) or remote wakeup (by device) ... now see what changed
1680	* in the tree that's rooted at this device.	1752	* in the tree that's rooted at this device.
1681	*/	1753	*/
1682	static int finish_device_resume(struct usb_device *udev)	1754	static int finish_device_resume(struct usb_device *udev)
1683	{	1755	{
1684	int status;	1756	int status;
1685	u16 devstatus;	1757	u16 devstatus;
1686		1758
1687	/* caller owns the udev device lock */	1759	/* caller owns the udev device lock */
1688	dev_dbg(&udev->dev, "finish resume\n");	1760	dev_dbg(&udev->dev, "finish resume\n");
1689		1761
1690	/* usb ch9 identifies four variants of SUSPENDED, based on what	1762	/* usb ch9 identifies four variants of SUSPENDED, based on what
1691	* state the device resumes to. Linux currently won't see the	1763	* state the device resumes to. Linux currently won't see the
1692	* first two on the host side; they'd be inside hub_port_init()	1764	* first two on the host side; they'd be inside hub_port_init()
1693	* during many timeouts, but khubd can't suspend until later.	1765	* during many timeouts, but khubd can't suspend until later.
1694	*/	1766	*/
1695	usb_set_device_state(udev, udev->actconfig	1767	usb_set_device_state(udev, udev->actconfig
1696	? USB_STATE_CONFIGURED	1768	? USB_STATE_CONFIGURED
1697	: USB_STATE_ADDRESS);	1769	: USB_STATE_ADDRESS);
1698	udev->dev.power.power_state = PMSG_ON;	1770	udev->dev.power.power_state = PMSG_ON;
1699		1771
1700	/* 10.5.4.5 says be sure devices in the tree are still there.	1772	/* 10.5.4.5 says be sure devices in the tree are still there.
1701	* For now let's assume the device didn't go crazy on resume,	1773	* For now let's assume the device didn't go crazy on resume,
1702	* and device drivers will know about any resume quirks.	1774	* and device drivers will know about any resume quirks.
1703	*/	1775	*/
1704	status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus);	1776	status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
1705	if (status < 0)	1777	if (status < 2)
1706	dev_dbg(&udev->dev,	1778	dev_dbg(&udev->dev,
1707	"gone after usb resume? status %d\n",	1779	"gone after usb resume? status %d\n",
1708	status);	1780	status);
1709	else if (udev->actconfig) {	1781	else if (udev->actconfig) {
1710	unsigned i;	1782	unsigned i;
1711	int (resume)(struct device );	1783	int (resume)(struct device );
1712		1784
1713	le16_to_cpus(&devstatus);	1785	le16_to_cpus(&devstatus);
1714	if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)	1786	if ((devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP))
1715	&& udev->parent) {	1787	&& udev->parent) {
1716	status = usb_control_msg(udev,	1788	status = usb_control_msg(udev,
1717	usb_sndctrlpipe(udev, 0),	1789	usb_sndctrlpipe(udev, 0),
1718	USB_REQ_CLEAR_FEATURE,	1790	USB_REQ_CLEAR_FEATURE,
1719	USB_RECIP_DEVICE,	1791	USB_RECIP_DEVICE,
1720	USB_DEVICE_REMOTE_WAKEUP, 0,	1792	USB_DEVICE_REMOTE_WAKEUP, 0,
1721	NULL, 0,	1793	NULL, 0,
1722	USB_CTRL_SET_TIMEOUT);	1794	USB_CTRL_SET_TIMEOUT);
1723	if (status) {	1795	if (status) {
1724	dev_dbg(&udev->dev, "disable remote "	1796	dev_dbg(&udev->dev, "disable remote "
1725	"wakeup, status %d\n", status);	1797	"wakeup, status %d\n", status);
1726	status = 0;	1798	status = 0;
1727	}	1799	}
1728	}	1800	}
1729		1801
1730	/* resume interface drivers; if this is a hub, it	1802	/* resume interface drivers; if this is a hub, it
1731	* may have a child resume event to deal with soon	1803	* may have a child resume event to deal with soon
1732	*/	1804	*/
1733	resume = udev->dev.bus->resume;	1805	resume = udev->dev.bus->resume;
1734	for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {	1806	for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1735	struct device *dev =	1807	struct device *dev =
1736	&udev->actconfig->interface[i]->dev;	1808	&udev->actconfig->interface[i]->dev;
1737		1809
1738	down(&dev->sem);	1810	down(&dev->sem);
1739	(void) resume(dev);	1811	(void) resume(dev);
1740	up(&dev->sem);	1812	up(&dev->sem);
1741	}	1813	}
1742	status = 0;	1814	status = 0;
1743		1815
1744	} else if (udev->devnum <= 0) {	1816	} else if (udev->devnum <= 0) {
1745	dev_dbg(&udev->dev, "bogus resume!\n");	1817	dev_dbg(&udev->dev, "bogus resume!\n");
1746	status = -EINVAL;	1818	status = -EINVAL;
1747	}	1819	}
1748	return status;	1820	return status;
1749	}	1821	}
1750		1822
1751	#ifdef CONFIG_USB_SUSPEND	1823	#ifdef CONFIG_USB_SUSPEND
1752		1824
1753	static int	1825	static int
1754	hub_port_resume(struct usb_hub hub, int port1, struct usb_device udev)	1826	hub_port_resume(struct usb_hub hub, int port1, struct usb_device udev)
1755	{	1827	{
1756	int status;	1828	int status;
1757		1829
1758	// dev_dbg(hub->intfdev, "resume port %d\n", port1);	1830	// dev_dbg(hub->intfdev, "resume port %d\n", port1);
1759		1831
1760	/* see 7.1.7.7; affects power usage, but not budgeting */	1832	/* see 7.1.7.7; affects power usage, but not budgeting */
1761	status = clear_port_feature(hub->hdev,	1833	status = clear_port_feature(hub->hdev,
1762	port1, USB_PORT_FEAT_SUSPEND);	1834	port1, USB_PORT_FEAT_SUSPEND);
1763	if (status) {	1835	if (status) {
1764	dev_dbg(hub->intfdev,	1836	dev_dbg(hub->intfdev,
1765	"can't resume port %d, status %d\n",	1837	"can't resume port %d, status %d\n",
1766	port1, status);	1838	port1, status);
1767	} else {	1839	} else {
1768	u16 devstatus;	1840	u16 devstatus;
1769	u16 portchange;	1841	u16 portchange;
1770		1842
1771	/* drive resume for at least 20 msec */	1843	/* drive resume for at least 20 msec */
1772	if (udev)	1844	if (udev)
1773	dev_dbg(&udev->dev, "RESUME\n");	1845	dev_dbg(&udev->dev, "RESUME\n");
1774	msleep(25);	1846	msleep(25);
1775		1847
1776	#define LIVE_FLAGS ( USB_PORT_STAT_POWER \	1848	#define LIVE_FLAGS ( USB_PORT_STAT_POWER \
1777	\| USB_PORT_STAT_ENABLE \	1849	\| USB_PORT_STAT_ENABLE \
1778	\| USB_PORT_STAT_CONNECTION)	1850	\| USB_PORT_STAT_CONNECTION)
1779		1851
1780	/* Virtual root hubs can trigger on GET_PORT_STATUS to	1852	/* Virtual root hubs can trigger on GET_PORT_STATUS to
1781	* stop resume signaling. Then finish the resume	1853	* stop resume signaling. Then finish the resume
1782	* sequence.	1854	* sequence.
1783	*/	1855	*/
1784	devstatus = portchange = 0;	1856	devstatus = portchange = 0;
1785	status = hub_port_status(hub, port1,	1857	status = hub_port_status(hub, port1,
1786	&devstatus, &portchange);	1858	&devstatus, &portchange);
1787	if (status < 0	1859	if (status < 0
1788	\|\| (devstatus & LIVE_FLAGS) != LIVE_FLAGS	1860	\|\| (devstatus & LIVE_FLAGS) != LIVE_FLAGS
1789	\|\| (devstatus & USB_PORT_STAT_SUSPEND) != 0	1861	\|\| (devstatus & USB_PORT_STAT_SUSPEND) != 0
1790	) {	1862	) {
1791	dev_dbg(hub->intfdev,	1863	dev_dbg(hub->intfdev,
1792	"port %d status %04x.%04x after resume, %d\n",	1864	"port %d status %04x.%04x after resume, %d\n",
1793	port1, portchange, devstatus, status);	1865	port1, portchange, devstatus, status);
1794	} else {	1866	} else {
1795	/* TRSMRCY = 10 msec */	1867	/* TRSMRCY = 10 msec */
1796	msleep(10);	1868	msleep(10);
1797	if (udev)	1869	if (udev)
1798	status = finish_device_resume(udev);	1870	status = finish_device_resume(udev);
1799	}	1871	}
1800	}	1872	}
1801	if (status < 0)	1873	if (status < 0)
1802	hub_port_logical_disconnect(hub, port1);	1874	hub_port_logical_disconnect(hub, port1);
1803		1875
1804	return status;	1876	return status;
1805	}	1877	}
1806		1878
1807	#endif	1879	#endif
1808		1880
1809	/*	1881	/*
1810	* usb_resume_device - re-activate a suspended usb device	1882	* usb_resume_device - re-activate a suspended usb device
1811	* @udev: device to re-activate	1883	* @udev: device to re-activate
1812	* Context: must be able to sleep; device not locked; pm locks held	1884	* Context: must be able to sleep; device not locked; pm locks held
1813	*	1885	*
1814	* This will re-activate the suspended device, increasing power usage	1886	* This will re-activate the suspended device, increasing power usage
1815	* while letting drivers communicate again with its endpoints.	1887	* while letting drivers communicate again with its endpoints.
1816	* USB resume explicitly guarantees that the power session between	1888	* USB resume explicitly guarantees that the power session between
1817	* the host and the device is the same as it was when the device	1889	* the host and the device is the same as it was when the device
1818	* suspended.	1890	* suspended.
1819	*	1891	*
1820	* Returns 0 on success, else negative errno.	1892	* Returns 0 on success, else negative errno.
1821	*/	1893	*/
1822	int usb_resume_device(struct usb_device *udev)	1894	int usb_resume_device(struct usb_device *udev)
1823	{	1895	{
1824	int port1, status;	1896	int port1, status;
1825		1897
1826	if (udev->state == USB_STATE_NOTATTACHED)	1898	if (udev->state == USB_STATE_NOTATTACHED)
1827	return -ENODEV;	1899	return -ENODEV;
1828	if (!udev->parent)	1900	if (!udev->parent)
1829	port1 = 0;	1901	port1 = 0;
1830	else {	1902	else {
1831	for (port1 = udev->parent->maxchild; port1 > 0; --port1) {	1903	for (port1 = udev->parent->maxchild; port1 > 0; --port1) {
1832	if (udev->parent->children[port1-1] == udev)	1904	if (udev->parent->children[port1-1] == udev)
1833	break;	1905	break;
1834	}	1906	}
1835	if (port1 == 0)	1907	if (port1 == 0)
1836	return -ENODEV;	1908	return -ENODEV;
1837	}	1909	}
1838		1910
1839	#ifdef CONFIG_USB_SUSPEND	1911	#ifdef CONFIG_USB_SUSPEND
1840	/* selective resume of one downstream hub-to-device port */	1912	/* selective resume of one downstream hub-to-device port */
1841	if (udev->parent) {	1913	if (udev->parent) {
1842	if (udev->state == USB_STATE_SUSPENDED) {	1914	if (udev->state == USB_STATE_SUSPENDED) {
1843	// NOTE swsusp may bork us, device state being wrong...	1915	// NOTE swsusp may bork us, device state being wrong...
1844	// NOTE this fails if parent is also suspended...	1916	// NOTE this fails if parent is also suspended...
1845	status = hub_port_resume(hdev_to_hub(udev->parent),	1917	status = hub_port_resume(hdev_to_hub(udev->parent),
1846	port1, udev);	1918	port1, udev);
1847	} else	1919	} else
1848	status = 0;	1920	status = 0;
1849	} else	1921	} else
1850	#endif	1922	#endif
1851	status = finish_device_resume(udev);	1923	status = finish_device_resume(udev);
1852	if (status < 0)	1924	if (status < 0)
1853	dev_dbg(&udev->dev, "can't resume, status %d\n",	1925	dev_dbg(&udev->dev, "can't resume, status %d\n",
1854	status);	1926	status);
1855		1927
1856	/* rebind drivers that had no suspend() */	1928	/* rebind drivers that had no suspend() */
1857	if (status == 0) {	1929	if (status == 0) {
1858	usb_unlock_device(udev);	1930	usb_unlock_device(udev);
1859	bus_rescan_devices(&usb_bus_type);	1931	bus_rescan_devices(&usb_bus_type);
1860	usb_lock_device(udev);	1932	usb_lock_device(udev);
1861	}	1933	}
1862	return status;	1934	return status;
1863	}	1935	}
1864		1936
1865	static int remote_wakeup(struct usb_device *udev)	1937	static int remote_wakeup(struct usb_device *udev)
1866	{	1938	{
1867	int status = 0;	1939	int status = 0;
1868		1940
1869	#ifdef CONFIG_USB_SUSPEND	1941	#ifdef CONFIG_USB_SUSPEND
1870		1942
1871	/* don't repeat RESUME sequence if this device	1943	/* don't repeat RESUME sequence if this device
1872	* was already woken up by some other task	1944	* was already woken up by some other task
1873	*/	1945	*/
1874	usb_lock_device(udev);	1946	usb_lock_device(udev);
1875	if (udev->state == USB_STATE_SUSPENDED) {	1947	if (udev->state == USB_STATE_SUSPENDED) {
1876	dev_dbg(&udev->dev, "RESUME (wakeup)\n");	1948	dev_dbg(&udev->dev, "RESUME (wakeup)\n");
1877	/* TRSMRCY = 10 msec */	1949	/* TRSMRCY = 10 msec */
1878	msleep(10);	1950	msleep(10);
1879	status = finish_device_resume(udev);	1951	status = finish_device_resume(udev);
1880	}	1952	}
1881	usb_unlock_device(udev);	1953	usb_unlock_device(udev);
1882	#endif	1954	#endif
1883	return status;	1955	return status;
1884	}	1956	}
1885		1957
1886	static int hub_suspend(struct usb_interface *intf, pm_message_t msg)	1958	static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
1887	{	1959	{
1888	struct usb_hub *hub = usb_get_intfdata (intf);	1960	struct usb_hub *hub = usb_get_intfdata (intf);
1889	struct usb_device *hdev = hub->hdev;	1961	struct usb_device *hdev = hub->hdev;
1890	unsigned port1;	1962	unsigned port1;
1891		1963
1892	/* fail if children aren't already suspended */	1964	/* fail if children aren't already suspended */
1893	for (port1 = 1; port1 <= hdev->maxchild; port1++) {	1965	for (port1 = 1; port1 <= hdev->maxchild; port1++) {
1894	struct usb_device *udev;	1966	struct usb_device *udev;
1895		1967
1896	udev = hdev->children [port1-1];	1968	udev = hdev->children [port1-1];
1897	if (udev && (udev->dev.power.power_state.event	1969	if (udev && (udev->dev.power.power_state.event
1898	== PM_EVENT_ON	1970	== PM_EVENT_ON
1899	#ifdef CONFIG_USB_SUSPEND	1971	#ifdef CONFIG_USB_SUSPEND
1900	\|\| udev->state != USB_STATE_SUSPENDED	1972	\|\| udev->state != USB_STATE_SUSPENDED
1901	#endif	1973	#endif
1902	)) {	1974	)) {
1903	dev_dbg(&intf->dev, "port %d nyet suspended\n", port1);	1975	dev_dbg(&intf->dev, "port %d nyet suspended\n", port1);
1904	return -EBUSY;	1976	return -EBUSY;
1905	}	1977	}
1906	}	1978	}
1907		1979
1908	/* "global suspend" of the downstream HC-to-USB interface */	1980	/* "global suspend" of the downstream HC-to-USB interface */
1909	if (!hdev->parent) {	1981	if (!hdev->parent) {
1910	struct usb_bus *bus = hdev->bus;	1982	struct usb_bus *bus = hdev->bus;
1911	if (bus) {	1983	if (bus) {
1912	int status = hcd_bus_suspend (bus);	1984	int status = hcd_bus_suspend (bus);
1913		1985
1914	if (status != 0) {	1986	if (status != 0) {
1915	dev_dbg(&hdev->dev, "'global' suspend %d\n",	1987	dev_dbg(&hdev->dev, "'global' suspend %d\n",
1916	status);	1988	status);
1917	return status;	1989	return status;
1918	}	1990	}
1919	} else	1991	} else
1920	return -EOPNOTSUPP;	1992	return -EOPNOTSUPP;
1921	}	1993	}
1922		1994
1923	/* stop khubd and related activity */	1995	/* stop khubd and related activity */
1924	hub_quiesce(hub);	1996	hub_quiesce(hub);
1925	return 0;	1997	return 0;
1926	}	1998	}
1927		1999
1928	static int hub_resume(struct usb_interface *intf)	2000	static int hub_resume(struct usb_interface *intf)
1929	{	2001	{
1930	struct usb_device *hdev = interface_to_usbdev(intf);	2002	struct usb_device *hdev = interface_to_usbdev(intf);
1931	struct usb_hub *hub = usb_get_intfdata (intf);	2003	struct usb_hub *hub = usb_get_intfdata (intf);
1932	int status;	2004	int status;
1933		2005
1934	/* "global resume" of the downstream HC-to-USB interface */	2006	/* "global resume" of the downstream HC-to-USB interface */
1935	if (!hdev->parent) {	2007	if (!hdev->parent) {
1936	struct usb_bus *bus = hdev->bus;	2008	struct usb_bus *bus = hdev->bus;
1937	if (bus) {	2009	if (bus) {
1938	status = hcd_bus_resume (bus);	2010	status = hcd_bus_resume (bus);
1939	if (status) {	2011	if (status) {
1940	dev_dbg(&intf->dev, "'global' resume %d\n",	2012	dev_dbg(&intf->dev, "'global' resume %d\n",
1941	status);	2013	status);
1942	return status;	2014	return status;
1943	}	2015	}
1944	} else	2016	} else
1945	return -EOPNOTSUPP;	2017	return -EOPNOTSUPP;
1946	if (status == 0) {	2018	if (status == 0) {
1947	/* TRSMRCY = 10 msec */	2019	/* TRSMRCY = 10 msec */
1948	msleep(10);	2020	msleep(10);
1949	}	2021	}
1950	}	2022	}
1951		2023
1952	hub_activate(hub);	2024	hub_activate(hub);
1953		2025
1954	/* REVISIT: this recursion probably shouldn't exist. Remove	2026	/* REVISIT: this recursion probably shouldn't exist. Remove
1955	* this code sometime, after retesting with different root and	2027	* this code sometime, after retesting with different root and
1956	* external hubs.	2028	* external hubs.
1957	*/	2029	*/
1958	#ifdef CONFIG_USB_SUSPEND	2030	#ifdef CONFIG_USB_SUSPEND
1959	{	2031	{
1960	unsigned port1;	2032	unsigned port1;
1961		2033
1962	for (port1 = 1; port1 <= hdev->maxchild; port1++) {	2034	for (port1 = 1; port1 <= hdev->maxchild; port1++) {
1963	struct usb_device *udev;	2035	struct usb_device *udev;
1964	u16 portstat, portchange;	2036	u16 portstat, portchange;
1965		2037
1966	udev = hdev->children [port1-1];	2038	udev = hdev->children [port1-1];
1967	status = hub_port_status(hub, port1, &portstat, &portchange);	2039	status = hub_port_status(hub, port1, &portstat, &portchange);
1968	if (status == 0) {	2040	if (status == 0) {
1969	if (portchange & USB_PORT_STAT_C_SUSPEND) {	2041	if (portchange & USB_PORT_STAT_C_SUSPEND) {
1970	clear_port_feature(hdev, port1,	2042	clear_port_feature(hdev, port1,
1971	USB_PORT_FEAT_C_SUSPEND);	2043	USB_PORT_FEAT_C_SUSPEND);
1972	portchange &= ~USB_PORT_STAT_C_SUSPEND;	2044	portchange &= ~USB_PORT_STAT_C_SUSPEND;
1973	}	2045	}
1974		2046
1975	/* let khubd handle disconnects etc */	2047	/* let khubd handle disconnects etc */
1976	if (portchange)	2048	if (portchange)
1977	continue;	2049	continue;
1978	}	2050	}
1979		2051
1980	if (!udev \|\| status < 0)	2052	if (!udev \|\| status < 0)
1981	continue;	2053	continue;
1982	usb_lock_device(udev);	2054	usb_lock_device(udev);
1983	if (portstat & USB_PORT_STAT_SUSPEND)	2055	if (portstat & USB_PORT_STAT_SUSPEND)
1984	status = hub_port_resume(hub, port1, udev);	2056	status = hub_port_resume(hub, port1, udev);
1985	else {	2057	else {
1986	status = finish_device_resume(udev);	2058	status = finish_device_resume(udev);
1987	if (status < 0) {	2059	if (status < 0) {
1988	dev_dbg(&intf->dev, "resume port %d --> %d\n",	2060	dev_dbg(&intf->dev, "resume port %d --> %d\n",
1989	port1, status);	2061	port1, status);
1990	hub_port_logical_disconnect(hub, port1);	2062	hub_port_logical_disconnect(hub, port1);
1991	}	2063	}
1992	}	2064	}
1993	usb_unlock_device(udev);	2065	usb_unlock_device(udev);
1994	}	2066	}
1995	}	2067	}
1996	#endif	2068	#endif
1997	return 0;	2069	return 0;
1998	}	2070	}
1999		2071
2000	void usb_suspend_root_hub(struct usb_device *hdev)	2072	void usb_suspend_root_hub(struct usb_device *hdev)
2001	{	2073	{
2002	struct usb_hub *hub = hdev_to_hub(hdev);	2074	struct usb_hub *hub = hdev_to_hub(hdev);
2003		2075
2004	/* This also makes any led blinker stop retriggering. We're called	2076	/* This also makes any led blinker stop retriggering. We're called
2005	* from irq, so the blinker might still be scheduled. Caller promises	2077	* from irq, so the blinker might still be scheduled. Caller promises
2006	* that the root hub status URB will be canceled.	2078	* that the root hub status URB will be canceled.
2007	*/	2079	*/
2008	__hub_quiesce(hub);	2080	__hub_quiesce(hub);
2009	mark_quiesced(to_usb_interface(hub->intfdev));	2081	mark_quiesced(to_usb_interface(hub->intfdev));
2010	}	2082	}
2011		2083
2012	void usb_resume_root_hub(struct usb_device *hdev)	2084	void usb_resume_root_hub(struct usb_device *hdev)
2013	{	2085	{
2014	struct usb_hub *hub = hdev_to_hub(hdev);	2086	struct usb_hub *hub = hdev_to_hub(hdev);
2015		2087
2016	hub->resume_root_hub = 1;	2088	hub->resume_root_hub = 1;
2017	kick_khubd(hub);	2089	kick_khubd(hub);
2018	}	2090	}
2019		2091
2020		2092
2021	/* USB 2.0 spec, 7.1.7.3 / fig 7-29:	2093	/* USB 2.0 spec, 7.1.7.3 / fig 7-29:
2022	*	2094	*
2023	* Between connect detection and reset signaling there must be a delay	2095	* Between connect detection and reset signaling there must be a delay
2024	* of 100ms at least for debounce and power-settling. The corresponding	2096	* of 100ms at least for debounce and power-settling. The corresponding
2025	* timer shall restart whenever the downstream port detects a disconnect.	2097	* timer shall restart whenever the downstream port detects a disconnect.
2026	*	2098	*
2027	* Apparently there are some bluetooth and irda-dongles and a number of	2099	* Apparently there are some bluetooth and irda-dongles and a number of
2028	* low-speed devices for which this debounce period may last over a second.	2100	* low-speed devices for which this debounce period may last over a second.
2029	* Not covered by the spec - but easy to deal with.	2101	* Not covered by the spec - but easy to deal with.
2030	*	2102	*
2031	* This implementation uses a 1500ms total debounce timeout; if the	2103	* This implementation uses a 1500ms total debounce timeout; if the
2032	* connection isn't stable by then it returns -ETIMEDOUT. It checks	2104	* connection isn't stable by then it returns -ETIMEDOUT. It checks
2033	* every 25ms for transient disconnects. When the port status has been	2105	* every 25ms for transient disconnects. When the port status has been
2034	* unchanged for 100ms it returns the port status.	2106	* unchanged for 100ms it returns the port status.
2035	*/	2107	*/
2036		2108
2037	#define HUB_DEBOUNCE_TIMEOUT 1500	2109	#define HUB_DEBOUNCE_TIMEOUT 1500
2038	#define HUB_DEBOUNCE_STEP 25	2110	#define HUB_DEBOUNCE_STEP 25
2039	#define HUB_DEBOUNCE_STABLE 100	2111	#define HUB_DEBOUNCE_STABLE 100
2040		2112
2041	static int hub_port_debounce(struct usb_hub *hub, int port1)	2113	static int hub_port_debounce(struct usb_hub *hub, int port1)
2042	{	2114	{
2043	int ret;	2115	int ret;
2044	int total_time, stable_time = 0;	2116	int total_time, stable_time = 0;
2045	u16 portchange, portstatus;	2117	u16 portchange, portstatus;
2046	unsigned connection = 0xffff;	2118	unsigned connection = 0xffff;
2047		2119
2048	for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {	2120	for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
2049	ret = hub_port_status(hub, port1, &portstatus, &portchange);	2121	ret = hub_port_status(hub, port1, &portstatus, &portchange);
2050	if (ret < 0)	2122	if (ret < 0)
2051	return ret;	2123	return ret;
2052		2124
2053	if (!(portchange & USB_PORT_STAT_C_CONNECTION) &&	2125	if (!(portchange & USB_PORT_STAT_C_CONNECTION) &&
2054	(portstatus & USB_PORT_STAT_CONNECTION) == connection) {	2126	(portstatus & USB_PORT_STAT_CONNECTION) == connection) {
2055	stable_time += HUB_DEBOUNCE_STEP;	2127	stable_time += HUB_DEBOUNCE_STEP;
2056	if (stable_time >= HUB_DEBOUNCE_STABLE)	2128	if (stable_time >= HUB_DEBOUNCE_STABLE)
2057	break;	2129	break;
2058	} else {	2130	} else {
2059	stable_time = 0;	2131	stable_time = 0;
2060	connection = portstatus & USB_PORT_STAT_CONNECTION;	2132	connection = portstatus & USB_PORT_STAT_CONNECTION;
2061	}	2133	}
2062		2134
2063	if (portchange & USB_PORT_STAT_C_CONNECTION) {	2135	if (portchange & USB_PORT_STAT_C_CONNECTION) {
2064	clear_port_feature(hub->hdev, port1,	2136	clear_port_feature(hub->hdev, port1,
2065	USB_PORT_FEAT_C_CONNECTION);	2137	USB_PORT_FEAT_C_CONNECTION);
2066	}	2138	}
2067		2139
2068	if (total_time >= HUB_DEBOUNCE_TIMEOUT)	2140	if (total_time >= HUB_DEBOUNCE_TIMEOUT)
2069	break;	2141	break;
2070	msleep(HUB_DEBOUNCE_STEP);	2142	msleep(HUB_DEBOUNCE_STEP);
2071	}	2143	}
2072		2144
2073	dev_dbg (hub->intfdev,	2145	dev_dbg (hub->intfdev,
2074	"debounce: port %d: total %dms stable %dms status 0x%x\n",	2146	"debounce: port %d: total %dms stable %dms status 0x%x\n",
2075	port1, total_time, stable_time, portstatus);	2147	port1, total_time, stable_time, portstatus);
2076		2148
2077	if (stable_time < HUB_DEBOUNCE_STABLE)	2149	if (stable_time < HUB_DEBOUNCE_STABLE)
2078	return -ETIMEDOUT;	2150	return -ETIMEDOUT;
2079	return portstatus;	2151	return portstatus;
2080	}	2152	}
2081		2153
2082	static void ep0_reinit(struct usb_device *udev)	2154	static void ep0_reinit(struct usb_device *udev)
2083	{	2155	{
2084	usb_disable_endpoint(udev, 0 + USB_DIR_IN);	2156	usb_disable_endpoint(udev, 0 + USB_DIR_IN);
2085	usb_disable_endpoint(udev, 0 + USB_DIR_OUT);	2157	usb_disable_endpoint(udev, 0 + USB_DIR_OUT);
2086	udev->ep_in[0] = udev->ep_out[0] = &udev->ep0;	2158	udev->ep_in[0] = udev->ep_out[0] = &udev->ep0;
2087	}	2159	}
2088		2160
2089	#define usb_sndaddr0pipe() (PIPE_CONTROL << 30)	2161	#define usb_sndaddr0pipe() (PIPE_CONTROL << 30)
2090	#define usb_rcvaddr0pipe() ((PIPE_CONTROL << 30) \| USB_DIR_IN)	2162	#define usb_rcvaddr0pipe() ((PIPE_CONTROL << 30) \| USB_DIR_IN)
2091		2163
2092	static int hub_set_address(struct usb_device *udev)	2164	static int hub_set_address(struct usb_device *udev)
2093	{	2165	{
2094	int retval;	2166	int retval;
2095		2167
2096	if (udev->devnum == 0)	2168	if (udev->devnum == 0)
2097	return -EINVAL;	2169	return -EINVAL;
2098	if (udev->state == USB_STATE_ADDRESS)	2170	if (udev->state == USB_STATE_ADDRESS)
2099	return 0;	2171	return 0;
2100	if (udev->state != USB_STATE_DEFAULT)	2172	if (udev->state != USB_STATE_DEFAULT)
2101	return -EINVAL;	2173	return -EINVAL;
2102	retval = usb_control_msg(udev, usb_sndaddr0pipe(),	2174	retval = usb_control_msg(udev, usb_sndaddr0pipe(),
2103	USB_REQ_SET_ADDRESS, 0, udev->devnum, 0,	2175	USB_REQ_SET_ADDRESS, 0, udev->devnum, 0,
2104	NULL, 0, USB_CTRL_SET_TIMEOUT);	2176	NULL, 0, USB_CTRL_SET_TIMEOUT);
2105	if (retval == 0) {	2177	if (retval == 0) {
2106	usb_set_device_state(udev, USB_STATE_ADDRESS);	2178	usb_set_device_state(udev, USB_STATE_ADDRESS);
2107	ep0_reinit(udev);	2179	ep0_reinit(udev);
2108	}	2180	}
2109	return retval;	2181	return retval;
2110	}	2182	}
2111		2183
2112	/* Reset device, (re)assign address, get device descriptor.	2184	/* Reset device, (re)assign address, get device descriptor.
2113	* Device connection must be stable, no more debouncing needed.	2185	* Device connection must be stable, no more debouncing needed.
2114	* Returns device in USB_STATE_ADDRESS, except on error.	2186	* Returns device in USB_STATE_ADDRESS, except on error.
2115	*	2187	*
2116	* If this is called for an already-existing device (as part of	2188	* If this is called for an already-existing device (as part of
2117	* usb_reset_device), the caller must own the device lock. For a	2189	* usb_reset_device), the caller must own the device lock. For a
2118	* newly detected device that is not accessible through any global	2190	* newly detected device that is not accessible through any global
2119	* pointers, it's not necessary to lock the device.	2191	* pointers, it's not necessary to lock the device.
2120	*/	2192	*/
2121	static int	2193	static int
2122	hub_port_init (struct usb_hub hub, struct usb_device udev, int port1,	2194	hub_port_init (struct usb_hub hub, struct usb_device udev, int port1,
2123	int retry_counter)	2195	int retry_counter)
2124	{	2196	{
2125	static DECLARE_MUTEX(usb_address0_sem);	2197	static DECLARE_MUTEX(usb_address0_sem);
2126		2198
2127	struct usb_device *hdev = hub->hdev;	2199	struct usb_device *hdev = hub->hdev;
2128	int i, j, retval;	2200	int i, j, retval;
2129	unsigned delay = HUB_SHORT_RESET_TIME;	2201	unsigned delay = HUB_SHORT_RESET_TIME;
2130	enum usb_device_speed oldspeed = udev->speed;	2202	enum usb_device_speed oldspeed = udev->speed;
2131		2203
2132	/* root hub ports have a slightly longer reset period	2204	/* root hub ports have a slightly longer reset period
2133	* (from USB 2.0 spec, section 7.1.7.5)	2205	* (from USB 2.0 spec, section 7.1.7.5)
2134	*/	2206	*/
2135	if (!hdev->parent) {	2207	if (!hdev->parent) {
2136	delay = HUB_ROOT_RESET_TIME;	2208	delay = HUB_ROOT_RESET_TIME;
2137	if (port1 == hdev->bus->otg_port)	2209	if (port1 == hdev->bus->otg_port)
2138	hdev->bus->b_hnp_enable = 0;	2210	hdev->bus->b_hnp_enable = 0;
2139	}	2211	}
2140		2212
2141	/* Some low speed devices have problems with the quick delay, so */	2213	/* Some low speed devices have problems with the quick delay, so */
2142	/* be a bit pessimistic with those devices. RHbug #23670 */	2214	/* be a bit pessimistic with those devices. RHbug #23670 */
2143	if (oldspeed == USB_SPEED_LOW)	2215	if (oldspeed == USB_SPEED_LOW)
2144	delay = HUB_LONG_RESET_TIME;	2216	delay = HUB_LONG_RESET_TIME;
2145		2217
2146	down(&usb_address0_sem);	2218	down(&usb_address0_sem);
2147		2219
2148	/* Reset the device; full speed may morph to high speed */	2220	/* Reset the device; full speed may morph to high speed */
2149	retval = hub_port_reset(hub, port1, udev, delay);	2221	retval = hub_port_reset(hub, port1, udev, delay);
2150	if (retval < 0) /* error or disconnect */	2222	if (retval < 0) /* error or disconnect */
2151	goto fail;	2223	goto fail;
2152	/* success, speed is known */	2224	/* success, speed is known */
2153	retval = -ENODEV;	2225	retval = -ENODEV;
2154		2226
2155	if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed) {	2227	if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed) {
2156	dev_dbg(&udev->dev, "device reset changed speed!\n");	2228	dev_dbg(&udev->dev, "device reset changed speed!\n");
2157	goto fail;	2229	goto fail;
2158	}	2230	}
2159	oldspeed = udev->speed;	2231	oldspeed = udev->speed;
2160		2232
2161	/* USB 2.0 section 5.5.3 talks about ep0 maxpacket ...	2233	/* USB 2.0 section 5.5.3 talks about ep0 maxpacket ...
2162	* it's fixed size except for full speed devices.	2234	* it's fixed size except for full speed devices.
2163	*/	2235	*/
2164	switch (udev->speed) {	2236	switch (udev->speed) {
2165	case USB_SPEED_HIGH: /* fixed at 64 */	2237	case USB_SPEED_HIGH: /* fixed at 64 */
2166	udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);	2238	udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);
2167	break;	2239	break;
2168	case USB_SPEED_FULL: /* 8, 16, 32, or 64 */	2240	case USB_SPEED_FULL: /* 8, 16, 32, or 64 */
2169	/* to determine the ep0 maxpacket size, try to read	2241	/* to determine the ep0 maxpacket size, try to read
2170	* the device descriptor to get bMaxPacketSize0 and	2242	* the device descriptor to get bMaxPacketSize0 and
2171	* then correct our initial guess.	2243	* then correct our initial guess.
2172	*/	2244	*/
2173	udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);	2245	udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);
2174	break;	2246	break;
2175	case USB_SPEED_LOW: /* fixed at 8 */	2247	case USB_SPEED_LOW: /* fixed at 8 */
2176	udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(8);	2248	udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(8);
2177	break;	2249	break;
2178	default:	2250	default:
2179	goto fail;	2251	goto fail;
2180	}	2252	}
2181		2253
2182	dev_info (&udev->dev,	2254	dev_info (&udev->dev,
2183	"%s %s speed USB device using %s and address %d\n",	2255	"%s %s speed USB device using %s and address %d\n",
2184	(udev->config) ? "reset" : "new",	2256	(udev->config) ? "reset" : "new",
2185	({ char *speed; switch (udev->speed) {	2257	({ char *speed; switch (udev->speed) {
2186	case USB_SPEED_LOW: speed = "low"; break;	2258	case USB_SPEED_LOW: speed = "low"; break;
2187	case USB_SPEED_FULL: speed = "full"; break;	2259	case USB_SPEED_FULL: speed = "full"; break;
2188	case USB_SPEED_HIGH: speed = "high"; break;	2260	case USB_SPEED_HIGH: speed = "high"; break;
2189	default: speed = "?"; break;	2261	default: speed = "?"; break;
2190	}; speed;}),	2262	}; speed;}),
2191	udev->bus->controller->driver->name,	2263	udev->bus->controller->driver->name,
2192	udev->devnum);	2264	udev->devnum);
2193		2265
2194	/* Set up TT records, if needed */	2266	/* Set up TT records, if needed */
2195	if (hdev->tt) {	2267	if (hdev->tt) {
2196	udev->tt = hdev->tt;	2268	udev->tt = hdev->tt;
2197	udev->ttport = hdev->ttport;	2269	udev->ttport = hdev->ttport;
2198	} else if (udev->speed != USB_SPEED_HIGH	2270	} else if (udev->speed != USB_SPEED_HIGH
2199	&& hdev->speed == USB_SPEED_HIGH) {	2271	&& hdev->speed == USB_SPEED_HIGH) {
2200	udev->tt = &hub->tt;	2272	udev->tt = &hub->tt;
2201	udev->ttport = port1;	2273	udev->ttport = port1;
2202	}	2274	}
2203		2275
2204	/* Why interleave GET_DESCRIPTOR and SET_ADDRESS this way?	2276	/* Why interleave GET_DESCRIPTOR and SET_ADDRESS this way?
2205	* Because device hardware and firmware is sometimes buggy in	2277	* Because device hardware and firmware is sometimes buggy in
2206	* this area, and this is how Linux has done it for ages.	2278	* this area, and this is how Linux has done it for ages.
2207	* Change it cautiously.	2279	* Change it cautiously.
2208	*	2280	*
2209	* NOTE: If USE_NEW_SCHEME() is true we will start by issuing	2281	* NOTE: If USE_NEW_SCHEME() is true we will start by issuing
2210	* a 64-byte GET_DESCRIPTOR request. This is what Windows does,	2282	* a 64-byte GET_DESCRIPTOR request. This is what Windows does,
2211	* so it may help with some non-standards-compliant devices.	2283	* so it may help with some non-standards-compliant devices.
2212	* Otherwise we start with SET_ADDRESS and then try to read the	2284	* Otherwise we start with SET_ADDRESS and then try to read the
2213	* first 8 bytes of the device descriptor to get the ep0 maxpacket	2285	* first 8 bytes of the device descriptor to get the ep0 maxpacket
2214	* value.	2286	* value.
2215	*/	2287	*/
2216	for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) {	2288	for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) {
2217	if (USE_NEW_SCHEME(retry_counter)) {	2289	if (USE_NEW_SCHEME(retry_counter)) {
2218	struct usb_device_descriptor *buf;	2290	struct usb_device_descriptor *buf;
2219	int r = 0;	2291	int r = 0;
2220		2292
2221	#define GET_DESCRIPTOR_BUFSIZE 64	2293	#define GET_DESCRIPTOR_BUFSIZE 64
2222	buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);	2294	buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);
2223	if (!buf) {	2295	if (!buf) {
2224	retval = -ENOMEM;	2296	retval = -ENOMEM;
2225	continue;	2297	continue;
2226	}	2298	}
2227		2299
2228	/* Use a short timeout the first time through,	2300	/* Use a short timeout the first time through,
2229	* so that recalcitrant full-speed devices with	2301	* so that recalcitrant full-speed devices with
2230	* 8- or 16-byte ep0-maxpackets won't slow things	2302	* 8- or 16-byte ep0-maxpackets won't slow things
2231	* down tremendously by NAKing the unexpectedly	2303	* down tremendously by NAKing the unexpectedly
2232	* early status stage. Also, retry on all errors;	2304	* early status stage. Also, retry on all errors;
2233	* some devices are flakey.	2305	* some devices are flakey.
2234	*/	2306	*/
2235	for (j = 0; j < 3; ++j) {	2307	for (j = 0; j < 3; ++j) {
2236	buf->bMaxPacketSize0 = 0;	2308	buf->bMaxPacketSize0 = 0;
2237	r = usb_control_msg(udev, usb_rcvaddr0pipe(),	2309	r = usb_control_msg(udev, usb_rcvaddr0pipe(),
2238	USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,	2310	USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
2239	USB_DT_DEVICE << 8, 0,	2311	USB_DT_DEVICE << 8, 0,
2240	buf, GET_DESCRIPTOR_BUFSIZE,	2312	buf, GET_DESCRIPTOR_BUFSIZE,
2241	(i ? USB_CTRL_GET_TIMEOUT : 1000));	2313	(i ? USB_CTRL_GET_TIMEOUT : 1000));
2242	switch (buf->bMaxPacketSize0) {	2314	switch (buf->bMaxPacketSize0) {
2243	case 8: case 16: case 32: case 64:	2315	case 8: case 16: case 32: case 64:
2244	if (buf->bDescriptorType ==	2316	if (buf->bDescriptorType ==
2245	USB_DT_DEVICE) {	2317	USB_DT_DEVICE) {
2246	r = 0;	2318	r = 0;
2247	break;	2319	break;
2248	}	2320	}
2249	/* FALL THROUGH */	2321	/* FALL THROUGH */
2250	default:	2322	default:
2251	if (r == 0)	2323	if (r == 0)
2252	r = -EPROTO;	2324	r = -EPROTO;
2253	break;	2325	break;
2254	}	2326	}
2255	if (r == 0)	2327	if (r == 0)
2256	break;	2328	break;
2257	}	2329	}
2258	udev->descriptor.bMaxPacketSize0 =	2330	udev->descriptor.bMaxPacketSize0 =
2259	buf->bMaxPacketSize0;	2331	buf->bMaxPacketSize0;
2260	kfree(buf);	2332	kfree(buf);
2261		2333
2262	retval = hub_port_reset(hub, port1, udev, delay);	2334	retval = hub_port_reset(hub, port1, udev, delay);
2263	if (retval < 0) /* error or disconnect */	2335	if (retval < 0) /* error or disconnect */
2264	goto fail;	2336	goto fail;
2265	if (oldspeed != udev->speed) {	2337	if (oldspeed != udev->speed) {
2266	dev_dbg(&udev->dev,	2338	dev_dbg(&udev->dev,
2267	"device reset changed speed!\n");	2339	"device reset changed speed!\n");
2268	retval = -ENODEV;	2340	retval = -ENODEV;
2269	goto fail;	2341	goto fail;
2270	}	2342	}
2271	if (r) {	2343	if (r) {
2272	dev_err(&udev->dev, "device descriptor "	2344	dev_err(&udev->dev, "device descriptor "
2273	"read/%s, error %d\n",	2345	"read/%s, error %d\n",
2274	"64", r);	2346	"64", r);
2275	retval = -EMSGSIZE;	2347	retval = -EMSGSIZE;
2276	continue;	2348	continue;
2277	}	2349	}
2278	#undef GET_DESCRIPTOR_BUFSIZE	2350	#undef GET_DESCRIPTOR_BUFSIZE
2279	}	2351	}
2280		2352
2281	for (j = 0; j < SET_ADDRESS_TRIES; ++j) {	2353	for (j = 0; j < SET_ADDRESS_TRIES; ++j) {
2282	retval = hub_set_address(udev);	2354	retval = hub_set_address(udev);
2283	if (retval >= 0)	2355	if (retval >= 0)
2284	break;	2356	break;
2285	msleep(200);	2357	msleep(200);
2286	}	2358	}
2287	if (retval < 0) {	2359	if (retval < 0) {
2288	dev_err(&udev->dev,	2360	dev_err(&udev->dev,
2289	"device not accepting address %d, error %d\n",	2361	"device not accepting address %d, error %d\n",
2290	udev->devnum, retval);	2362	udev->devnum, retval);
2291	goto fail;	2363	goto fail;
2292	}	2364	}
2293		2365
2294	/* cope with hardware quirkiness:	2366	/* cope with hardware quirkiness:
2295	* - let SET_ADDRESS settle, some device hardware wants it	2367	* - let SET_ADDRESS settle, some device hardware wants it
2296	* - read ep0 maxpacket even for high and low speed,	2368	* - read ep0 maxpacket even for high and low speed,
2297	*/	2369	*/
2298	msleep(10);	2370	msleep(10);
2299	if (USE_NEW_SCHEME(retry_counter))	2371	if (USE_NEW_SCHEME(retry_counter))
2300	break;	2372	break;
2301		2373
2302	retval = usb_get_device_descriptor(udev, 8);	2374	retval = usb_get_device_descriptor(udev, 8);
2303	if (retval < 8) {	2375	if (retval < 8) {
2304	dev_err(&udev->dev, "device descriptor "	2376	dev_err(&udev->dev, "device descriptor "
2305	"read/%s, error %d\n",	2377	"read/%s, error %d\n",
2306	"8", retval);	2378	"8", retval);
2307	if (retval >= 0)	2379	if (retval >= 0)
2308	retval = -EMSGSIZE;	2380	retval = -EMSGSIZE;
2309	} else {	2381	} else {
2310	retval = 0;	2382	retval = 0;
2311	break;	2383	break;
2312	}	2384	}
2313	}	2385	}
2314	if (retval)	2386	if (retval)
2315	goto fail;	2387	goto fail;
2316		2388
2317	i = udev->descriptor.bMaxPacketSize0;	2389	i = udev->descriptor.bMaxPacketSize0;
2318	if (le16_to_cpu(udev->ep0.desc.wMaxPacketSize) != i) {	2390	if (le16_to_cpu(udev->ep0.desc.wMaxPacketSize) != i) {
2319	if (udev->speed != USB_SPEED_FULL \|\|	2391	if (udev->speed != USB_SPEED_FULL \|\|
2320	!(i == 8 \|\| i == 16 \|\| i == 32 \|\| i == 64)) {	2392	!(i == 8 \|\| i == 16 \|\| i == 32 \|\| i == 64)) {
2321	dev_err(&udev->dev, "ep0 maxpacket = %d\n", i);	2393	dev_err(&udev->dev, "ep0 maxpacket = %d\n", i);
2322	retval = -EMSGSIZE;	2394	retval = -EMSGSIZE;
2323	goto fail;	2395	goto fail;
2324	}	2396	}
2325	dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);	2397	dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
2326	udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);	2398	udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
2327	ep0_reinit(udev);	2399	ep0_reinit(udev);
2328	}	2400	}
2329		2401
2330	retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);	2402	retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
2331	if (retval < (signed)sizeof(udev->descriptor)) {	2403	if (retval < (signed)sizeof(udev->descriptor)) {
2332	dev_err(&udev->dev, "device descriptor read/%s, error %d\n",	2404	dev_err(&udev->dev, "device descriptor read/%s, error %d\n",
2333	"all", retval);	2405	"all", retval);
2334	if (retval >= 0)	2406	if (retval >= 0)
2335	retval = -ENOMSG;	2407	retval = -ENOMSG;
2336	goto fail;	2408	goto fail;
2337	}	2409	}
2338		2410
2339	retval = 0;	2411	retval = 0;
2340		2412
2341	fail:	2413	fail:
2342	if (retval)	2414	if (retval)
2343	hub_port_disable(hub, port1, 0);	2415	hub_port_disable(hub, port1, 0);
2344	up(&usb_address0_sem);	2416	up(&usb_address0_sem);
2345	return retval;	2417	return retval;
2346	}	2418	}
2347		2419
2348	static void	2420	static void
2349	check_highspeed (struct usb_hub hub, struct usb_device udev, int port1)	2421	check_highspeed (struct usb_hub hub, struct usb_device udev, int port1)
2350	{	2422	{
2351	struct usb_qualifier_descriptor *qual;	2423	struct usb_qualifier_descriptor *qual;
2352	int status;	2424	int status;
2353		2425
2354	qual = kmalloc (sizeof *qual, SLAB_KERNEL);	2426	qual = kmalloc (sizeof *qual, SLAB_KERNEL);
2355	if (qual == NULL)	2427	if (qual == NULL)
2356	return;	2428	return;
2357		2429
2358	status = usb_get_descriptor (udev, USB_DT_DEVICE_QUALIFIER, 0,	2430	status = usb_get_descriptor (udev, USB_DT_DEVICE_QUALIFIER, 0,
2359	qual, sizeof *qual);	2431	qual, sizeof *qual);
2360	if (status == sizeof *qual) {	2432	if (status == sizeof *qual) {
2361	dev_info(&udev->dev, "not running at top speed; "	2433	dev_info(&udev->dev, "not running at top speed; "
2362	"connect to a high speed hub\n");	2434	"connect to a high speed hub\n");
2363	/* hub LEDs are probably harder to miss than syslog */	2435	/* hub LEDs are probably harder to miss than syslog */
2364	if (hub->has_indicators) {	2436	if (hub->has_indicators) {
2365	hub->indicator[port1-1] = INDICATOR_GREEN_BLINK;	2437	hub->indicator[port1-1] = INDICATOR_GREEN_BLINK;
2366	schedule_work (&hub->leds);	2438	schedule_work (&hub->leds);
2367	}	2439	}
2368	}	2440	}
2369	kfree(qual);	2441	kfree(qual);
2370	}	2442	}
2371		2443
2372	static unsigned	2444	static unsigned
2373	hub_power_remaining (struct usb_hub *hub)	2445	hub_power_remaining (struct usb_hub *hub)
2374	{	2446	{
2375	struct usb_device *hdev = hub->hdev;	2447	struct usb_device *hdev = hub->hdev;
2376	int remaining;	2448	int remaining;
2377	unsigned i;	2449	int port1;
2378		2450
2379	remaining = hub->power_budget;	2451	if (!hub->limited_power)
2380	if (!remaining) /* self-powered */
2381	return 0;	2452	return 0;
2382		2453
2383	for (i = 0; i < hdev->maxchild; i++) {	2454	remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;
2384	struct usb_device *udev = hdev->children[i];	2455	for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
2385	int delta, ceiling;	2456	struct usb_device *udev = hdev->children[port1 - 1];
		2457	int delta;
2386		2458
2387	if (!udev)	2459	if (!udev)
2388	continue;	2460	continue;
2389		2461
2390	/* 100mA per-port ceiling, or 8mA for OTG ports */	2462	/* Unconfigured devices may not use more than 100mA,
2391	if (i != (udev->bus->otg_port - 1) \|\| hdev->parent)	2463	* or 8mA for OTG ports */
2392	ceiling = 50;
2393	else
2394	ceiling = 4;
2395
2396	if (udev->actconfig)	2464	if (udev->actconfig)
2397	delta = udev->actconfig->desc.bMaxPower;	2465	delta = udev->actconfig->desc.bMaxPower * 2;
		2466	else if (port1 != udev->bus->otg_port \|\| hdev->parent)
		2467	delta = 100;
2398	else	2468	else
2399	delta = ceiling;	2469	delta = 8;
2400	// dev_dbg(&udev->dev, "budgeted %dmA\n", 2 * delta);	2470	if (delta > hub->mA_per_port)
2401	if (delta > ceiling)	2471	dev_warn(&udev->dev, "%dmA is over %umA budget "
2402	dev_warn(&udev->dev, "%dmA over %dmA budget!\n",	2472	"for port %d!\n",
2403	2 * (delta - ceiling), 2 * ceiling);	2473	delta, hub->mA_per_port, port1);
2404	remaining -= delta;	2474	remaining -= delta;
2405	}	2475	}
2406	if (remaining < 0) {	2476	if (remaining < 0) {
2407	dev_warn(hub->intfdev,	2477	dev_warn(hub->intfdev, "%dmA over power budget!\n",
2408	"%dmA over power budget!\n",	2478	- remaining);
2409	-2 * remaining);
2410	remaining = 0;	2479	remaining = 0;
2411	}	2480	}
2412	return remaining;	2481	return remaining;
2413	}	2482	}
2414		2483
2415	/* Handle physical or logical connection change events.	2484	/* Handle physical or logical connection change events.
2416	* This routine is called when:	2485	* This routine is called when:
2417	* a port connection-change occurs;	2486	* a port connection-change occurs;
2418	* a port enable-change occurs (often caused by EMI);	2487	* a port enable-change occurs (often caused by EMI);
2419	* usb_reset_device() encounters changed descriptors (as from	2488	* usb_reset_device() encounters changed descriptors (as from
2420	* a firmware download)	2489	* a firmware download)
2421	* caller already locked the hub	2490	* caller already locked the hub
2422	*/	2491	*/
2423	static void hub_port_connect_change(struct usb_hub *hub, int port1,	2492	static void hub_port_connect_change(struct usb_hub *hub, int port1,
2424	u16 portstatus, u16 portchange)	2493	u16 portstatus, u16 portchange)
2425	{	2494	{
2426	struct usb_device *hdev = hub->hdev;	2495	struct usb_device *hdev = hub->hdev;
2427	struct device *hub_dev = hub->intfdev;	2496	struct device *hub_dev = hub->intfdev;
2428	u16 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);	2497	u16 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
2429	int status, i;	2498	int status, i;
2430		2499
2431	dev_dbg (hub_dev,	2500	dev_dbg (hub_dev,
2432	"port %d, status %04x, change %04x, %s\n",	2501	"port %d, status %04x, change %04x, %s\n",
2433	port1, portstatus, portchange, portspeed (portstatus));	2502	port1, portstatus, portchange, portspeed (portstatus));
2434		2503
2435	if (hub->has_indicators) {	2504	if (hub->has_indicators) {
2436	set_port_led(hub, port1, HUB_LED_AUTO);	2505	set_port_led(hub, port1, HUB_LED_AUTO);
2437	hub->indicator[port1-1] = INDICATOR_AUTO;	2506	hub->indicator[port1-1] = INDICATOR_AUTO;
2438	}	2507	}
2439		2508
2440	/* Disconnect any existing devices under this port */	2509	/* Disconnect any existing devices under this port */
2441	if (hdev->children[port1-1])	2510	if (hdev->children[port1-1])
2442	usb_disconnect(&hdev->children[port1-1]);	2511	usb_disconnect(&hdev->children[port1-1]);
2443	clear_bit(port1, hub->change_bits);	2512	clear_bit(port1, hub->change_bits);
2444		2513
2445	#ifdef CONFIG_USB_OTG	2514	#ifdef CONFIG_USB_OTG
2446	/* during HNP, don't repeat the debounce */	2515	/* during HNP, don't repeat the debounce */
2447	if (hdev->bus->is_b_host)	2516	if (hdev->bus->is_b_host)
2448	portchange &= ~USB_PORT_STAT_C_CONNECTION;	2517	portchange &= ~USB_PORT_STAT_C_CONNECTION;
2449	#endif	2518	#endif
2450		2519
2451	if (portchange & USB_PORT_STAT_C_CONNECTION) {	2520	if (portchange & USB_PORT_STAT_C_CONNECTION) {
2452	status = hub_port_debounce(hub, port1);	2521	status = hub_port_debounce(hub, port1);
2453	if (status < 0) {	2522	if (status < 0) {
2454	dev_err (hub_dev,	2523	dev_err (hub_dev,
2455	"connect-debounce failed, port %d disabled\n",	2524	"connect-debounce failed, port %d disabled\n",
2456	port1);	2525	port1);
2457	goto done;	2526	goto done;
2458	}	2527	}
2459	portstatus = status;	2528	portstatus = status;
2460	}	2529	}
2461		2530
2462	/* Return now if nothing is connected */	2531	/* Return now if nothing is connected */
2463	if (!(portstatus & USB_PORT_STAT_CONNECTION)) {	2532	if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
2464		2533
2465	/* maybe switch power back on (e.g. root hub was reset) */	2534	/* maybe switch power back on (e.g. root hub was reset) */
2466	if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2	2535	if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
2467	&& !(portstatus & (1 << USB_PORT_FEAT_POWER)))	2536	&& !(portstatus & (1 << USB_PORT_FEAT_POWER)))
2468	set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);	2537	set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
2469		2538
2470	if (portstatus & USB_PORT_STAT_ENABLE)	2539	if (portstatus & USB_PORT_STAT_ENABLE)
2471	goto done;	2540	goto done;
2472	return;	2541	return;
2473	}	2542	}
2474		2543
2475	#ifdef CONFIG_USB_SUSPEND	2544	#ifdef CONFIG_USB_SUSPEND
2476	/* If something is connected, but the port is suspended, wake it up. */	2545	/* If something is connected, but the port is suspended, wake it up. */
2477	if (portstatus & USB_PORT_STAT_SUSPEND) {	2546	if (portstatus & USB_PORT_STAT_SUSPEND) {
2478	status = hub_port_resume(hub, port1, NULL);	2547	status = hub_port_resume(hub, port1, NULL);
2479	if (status < 0) {	2548	if (status < 0) {
2480	dev_dbg(hub_dev,	2549	dev_dbg(hub_dev,
2481	"can't clear suspend on port %d; %d\n",	2550	"can't clear suspend on port %d; %d\n",
2482	port1, status);	2551	port1, status);
2483	goto done;	2552	goto done;
2484	}	2553	}
2485	}	2554	}
2486	#endif	2555	#endif
2487		2556
2488	for (i = 0; i < SET_CONFIG_TRIES; i++) {	2557	for (i = 0; i < SET_CONFIG_TRIES; i++) {
2489	struct usb_device *udev;	2558	struct usb_device *udev;
2490		2559
2491	/* reallocate for each attempt, since references	2560	/* reallocate for each attempt, since references
2492	* to the previous one can escape in various ways	2561	* to the previous one can escape in various ways
2493	*/	2562	*/
2494	udev = usb_alloc_dev(hdev, hdev->bus, port1);	2563	udev = usb_alloc_dev(hdev, hdev->bus, port1);
2495	if (!udev) {	2564	if (!udev) {
2496	dev_err (hub_dev,	2565	dev_err (hub_dev,
2497	"couldn't allocate port %d usb_device\n",	2566	"couldn't allocate port %d usb_device\n",
2498	port1);	2567	port1);
2499	goto done;	2568	goto done;
2500	}	2569	}
2501		2570
2502	usb_set_device_state(udev, USB_STATE_POWERED);	2571	usb_set_device_state(udev, USB_STATE_POWERED);
2503	udev->speed = USB_SPEED_UNKNOWN;	2572	udev->speed = USB_SPEED_UNKNOWN;
2504		2573	udev->bus_mA = hub->mA_per_port;
		2574
2505	/* set the address */	2575	/* set the address */
2506	choose_address(udev);	2576	choose_address(udev);
2507	if (udev->devnum <= 0) {	2577	if (udev->devnum <= 0) {
2508	status = -ENOTCONN; /* Don't retry */	2578	status = -ENOTCONN; /* Don't retry */
2509	goto loop;	2579	goto loop;
2510	}	2580	}
2511		2581
2512	/* reset and get descriptor */	2582	/* reset and get descriptor */
2513	status = hub_port_init(hub, udev, port1, i);	2583	status = hub_port_init(hub, udev, port1, i);
2514	if (status < 0)	2584	if (status < 0)
2515	goto loop;	2585	goto loop;
2516		2586
2517	/* consecutive bus-powered hubs aren't reliable; they can	2587	/* consecutive bus-powered hubs aren't reliable; they can
2518	* violate the voltage drop budget. if the new child has	2588	* violate the voltage drop budget. if the new child has
2519	* a "powered" LED, users should notice we didn't enable it	2589	* a "powered" LED, users should notice we didn't enable it
2520	* (without reading syslog), even without per-port LEDs	2590	* (without reading syslog), even without per-port LEDs
2521	* on the parent.	2591	* on the parent.
2522	*/	2592	*/
2523	if (udev->descriptor.bDeviceClass == USB_CLASS_HUB	2593	if (udev->descriptor.bDeviceClass == USB_CLASS_HUB
2524	&& hub->power_budget) {	2594	&& udev->bus_mA <= 100) {
2525	u16 devstat;	2595	u16 devstat;
2526		2596
2527	status = usb_get_status(udev, USB_RECIP_DEVICE, 0,	2597	status = usb_get_status(udev, USB_RECIP_DEVICE, 0,
2528	&devstat);	2598	&devstat);
2529	if (status < 0) {	2599	if (status < 2) {
2530	dev_dbg(&udev->dev, "get status %d ?\n", status);	2600	dev_dbg(&udev->dev, "get status %d ?\n", status);
2531	goto loop_disable;	2601	goto loop_disable;
2532	}	2602	}
2533	cpu_to_le16s(&devstat);	2603	le16_to_cpus(&devstat);
2534	if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {	2604	if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
2535	dev_err(&udev->dev,	2605	dev_err(&udev->dev,
2536	"can't connect bus-powered hub "	2606	"can't connect bus-powered hub "
2537	"to this port\n");	2607	"to this port\n");
2538	if (hub->has_indicators) {	2608	if (hub->has_indicators) {
2539	hub->indicator[port1-1] =	2609	hub->indicator[port1-1] =
2540	INDICATOR_AMBER_BLINK;	2610	INDICATOR_AMBER_BLINK;
2541	schedule_work (&hub->leds);	2611	schedule_work (&hub->leds);
2542	}	2612	}
2543	status = -ENOTCONN; /* Don't retry */	2613	status = -ENOTCONN; /* Don't retry */
2544	goto loop_disable;	2614	goto loop_disable;
2545	}	2615	}
2546	}	2616	}
2547		2617
2548	/* check for devices running slower than they could */	2618	/* check for devices running slower than they could */
2549	if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200	2619	if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200
2550	&& udev->speed == USB_SPEED_FULL	2620	&& udev->speed == USB_SPEED_FULL
2551	&& highspeed_hubs != 0)	2621	&& highspeed_hubs != 0)
2552	check_highspeed (hub, udev, port1);	2622	check_highspeed (hub, udev, port1);
2553		2623
2554	/* Store the parent's children[] pointer. At this point	2624	/* Store the parent's children[] pointer. At this point
2555	* udev becomes globally accessible, although presumably	2625	* udev becomes globally accessible, although presumably
2556	* no one will look at it until hdev is unlocked.	2626	* no one will look at it until hdev is unlocked.
2557	*/	2627	*/
2558	status = 0;	2628	status = 0;
2559		2629
2560	/* We mustn't add new devices if the parent hub has	2630	/* We mustn't add new devices if the parent hub has
2561	* been disconnected; we would race with the	2631	* been disconnected; we would race with the
2562	* recursively_mark_NOTATTACHED() routine.	2632	* recursively_mark_NOTATTACHED() routine.
2563	*/	2633	*/
2564	spin_lock_irq(&device_state_lock);	2634	spin_lock_irq(&device_state_lock);
2565	if (hdev->state == USB_STATE_NOTATTACHED)	2635	if (hdev->state == USB_STATE_NOTATTACHED)
2566	status = -ENOTCONN;	2636	status = -ENOTCONN;
2567	else	2637	else
2568	hdev->children[port1-1] = udev;	2638	hdev->children[port1-1] = udev;
2569	spin_unlock_irq(&device_state_lock);	2639	spin_unlock_irq(&device_state_lock);
2570		2640
2571	/* Run it through the hoops (find a driver, etc) */	2641	/* Run it through the hoops (find a driver, etc) */
2572	if (!status) {	2642	if (!status) {
2573	status = usb_new_device(udev);	2643	status = usb_new_device(udev);
2574	if (status) {	2644	if (status) {
2575	spin_lock_irq(&device_state_lock);	2645	spin_lock_irq(&device_state_lock);
2576	hdev->children[port1-1] = NULL;	2646	hdev->children[port1-1] = NULL;
2577	spin_unlock_irq(&device_state_lock);	2647	spin_unlock_irq(&device_state_lock);
2578	}	2648	}
2579	}	2649	}
2580		2650
2581	if (status)	2651	if (status)
2582	goto loop_disable;	2652	goto loop_disable;
2583		2653
2584	status = hub_power_remaining(hub);	2654	status = hub_power_remaining(hub);
2585	if (status)	2655	if (status)
2586	dev_dbg(hub_dev,	2656	dev_dbg(hub_dev, "%dmA power budget left\n", status);
2587	"%dmA power budget left\n",
2588	2 * status);
2589		2657
2590	return;	2658	return;
2591		2659
2592	loop_disable:	2660	loop_disable:
2593	hub_port_disable(hub, port1, 1);	2661	hub_port_disable(hub, port1, 1);
2594	loop:	2662	loop:
2595	ep0_reinit(udev);	2663	ep0_reinit(udev);
2596	release_address(udev);	2664	release_address(udev);
2597	usb_put_dev(udev);	2665	usb_put_dev(udev);
2598	if (status == -ENOTCONN)	2666	if (status == -ENOTCONN)
2599	break;	2667	break;
2600	}	2668	}
2601		2669
2602	done:	2670	done:
2603	hub_port_disable(hub, port1, 1);	2671	hub_port_disable(hub, port1, 1);
2604	}	2672	}
2605		2673
2606	static void hub_events(void)	2674	static void hub_events(void)
2607	{	2675	{
2608	struct list_head *tmp;	2676	struct list_head *tmp;
2609	struct usb_device *hdev;	2677	struct usb_device *hdev;
2610	struct usb_interface *intf;	2678	struct usb_interface *intf;
2611	struct usb_hub *hub;	2679	struct usb_hub *hub;
2612	struct device *hub_dev;	2680	struct device *hub_dev;
2613	u16 hubstatus;	2681	u16 hubstatus;
2614	u16 hubchange;	2682	u16 hubchange;
2615	u16 portstatus;	2683	u16 portstatus;
2616	u16 portchange;	2684	u16 portchange;
2617	int i, ret;	2685	int i, ret;
2618	int connect_change;	2686	int connect_change;
2619		2687
2620	/*	2688	/*
2621	* We restart the list every time to avoid a deadlock with	2689	* We restart the list every time to avoid a deadlock with
2622	* deleting hubs downstream from this one. This should be	2690	* deleting hubs downstream from this one. This should be
2623	* safe since we delete the hub from the event list.	2691	* safe since we delete the hub from the event list.
2624	* Not the most efficient, but avoids deadlocks.	2692	* Not the most efficient, but avoids deadlocks.
2625	*/	2693	*/
2626	while (1) {	2694	while (1) {
2627		2695
2628	/* Grab the first entry at the beginning of the list */	2696	/* Grab the first entry at the beginning of the list */
2629	spin_lock_irq(&hub_event_lock);	2697	spin_lock_irq(&hub_event_lock);
2630	if (list_empty(&hub_event_list)) {	2698	if (list_empty(&hub_event_list)) {
2631	spin_unlock_irq(&hub_event_lock);	2699	spin_unlock_irq(&hub_event_lock);
2632	break;	2700	break;
2633	}	2701	}
2634		2702
2635	tmp = hub_event_list.next;	2703	tmp = hub_event_list.next;
2636	list_del_init(tmp);	2704	list_del_init(tmp);
2637		2705
2638	hub = list_entry(tmp, struct usb_hub, event_list);	2706	hub = list_entry(tmp, struct usb_hub, event_list);
2639	hdev = hub->hdev;	2707	hdev = hub->hdev;
2640	intf = to_usb_interface(hub->intfdev);	2708	intf = to_usb_interface(hub->intfdev);
2641	hub_dev = &intf->dev;	2709	hub_dev = &intf->dev;
2642		2710
2643	i = hub->resume_root_hub;	2711	i = hub->resume_root_hub;
2644		2712
2645	dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x%s\n",	2713	dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x%s\n",
2646	hdev->state, hub->descriptor	2714	hdev->state, hub->descriptor
2647	? hub->descriptor->bNbrPorts	2715	? hub->descriptor->bNbrPorts
2648	: 0,	2716	: 0,
2649	/* NOTE: expects max 15 ports... */	2717	/* NOTE: expects max 15 ports... */
2650	(u16) hub->change_bits[0],	2718	(u16) hub->change_bits[0],
2651	(u16) hub->event_bits[0],	2719	(u16) hub->event_bits[0],
2652	i ? ", resume root" : "");	2720	i ? ", resume root" : "");
2653		2721
2654	usb_get_intf(intf);	2722	usb_get_intf(intf);
2655	spin_unlock_irq(&hub_event_lock);	2723	spin_unlock_irq(&hub_event_lock);
2656		2724
2657	/* Is this is a root hub wanting to reactivate the downstream	2725	/* Is this is a root hub wanting to reactivate the downstream
2658	* ports? If so, be sure the interface resumes even if its	2726	* ports? If so, be sure the interface resumes even if its
2659	* stub "device" node was never suspended.	2727	* stub "device" node was never suspended.
2660	*/	2728	*/
2661	if (i) {	2729	if (i) {
2662	dpm_runtime_resume(&hdev->dev);	2730	dpm_runtime_resume(&hdev->dev);
2663	dpm_runtime_resume(&intf->dev);	2731	dpm_runtime_resume(&intf->dev);
2664	}	2732	}
2665		2733
2666	/* Lock the device, then check to see if we were	2734	/* Lock the device, then check to see if we were
2667	* disconnected while waiting for the lock to succeed. */	2735	* disconnected while waiting for the lock to succeed. */
2668	if (locktree(hdev) < 0) {	2736	if (locktree(hdev) < 0) {
2669	usb_put_intf(intf);	2737	usb_put_intf(intf);
2670	continue;	2738	continue;
2671	}	2739	}
2672	if (hub != usb_get_intfdata(intf))	2740	if (hub != usb_get_intfdata(intf))
2673	goto loop;	2741	goto loop;
2674		2742
2675	/* If the hub has died, clean up after it */	2743	/* If the hub has died, clean up after it */
2676	if (hdev->state == USB_STATE_NOTATTACHED) {	2744	if (hdev->state == USB_STATE_NOTATTACHED) {
2677	hub_pre_reset(hub, 0);	2745	hub_pre_reset(hub, 0);
2678	goto loop;	2746	goto loop;
2679	}	2747	}
2680		2748
2681	/* If this is an inactive or suspended hub, do nothing */	2749	/* If this is an inactive or suspended hub, do nothing */
2682	if (hub->quiescing)	2750	if (hub->quiescing)
2683	goto loop;	2751	goto loop;
2684		2752
2685	if (hub->error) {	2753	if (hub->error) {
2686	dev_dbg (hub_dev, "resetting for error %d\n",	2754	dev_dbg (hub_dev, "resetting for error %d\n",
2687	hub->error);	2755	hub->error);
2688		2756
2689	ret = usb_reset_device(hdev);	2757	ret = usb_reset_device(hdev);
2690	if (ret) {	2758	if (ret) {
2691	dev_dbg (hub_dev,	2759	dev_dbg (hub_dev,
2692	"error resetting hub: %d\n", ret);	2760	"error resetting hub: %d\n", ret);
2693	goto loop;	2761	goto loop;
2694	}	2762	}
2695		2763
2696	hub->nerrors = 0;	2764	hub->nerrors = 0;
2697	hub->error = 0;	2765	hub->error = 0;
2698	}	2766	}
2699		2767
2700	/* deal with port status changes */	2768	/* deal with port status changes */
2701	for (i = 1; i <= hub->descriptor->bNbrPorts; i++) {	2769	for (i = 1; i <= hub->descriptor->bNbrPorts; i++) {
2702	if (test_bit(i, hub->busy_bits))	2770	if (test_bit(i, hub->busy_bits))
2703	continue;	2771	continue;
2704	connect_change = test_bit(i, hub->change_bits);	2772	connect_change = test_bit(i, hub->change_bits);
2705	if (!test_and_clear_bit(i, hub->event_bits) &&	2773	if (!test_and_clear_bit(i, hub->event_bits) &&
2706	!connect_change && !hub->activating)	2774	!connect_change && !hub->activating)
2707	continue;	2775	continue;
2708		2776
2709	ret = hub_port_status(hub, i,	2777	ret = hub_port_status(hub, i,
2710	&portstatus, &portchange);	2778	&portstatus, &portchange);
2711	if (ret < 0)	2779	if (ret < 0)
2712	continue;	2780	continue;
2713		2781
2714	if (hub->activating && !hdev->children[i-1] &&	2782	if (hub->activating && !hdev->children[i-1] &&
2715	(portstatus &	2783	(portstatus &
2716	USB_PORT_STAT_CONNECTION))	2784	USB_PORT_STAT_CONNECTION))
2717	connect_change = 1;	2785	connect_change = 1;
2718		2786
2719	if (portchange & USB_PORT_STAT_C_CONNECTION) {	2787	if (portchange & USB_PORT_STAT_C_CONNECTION) {
2720	clear_port_feature(hdev, i,	2788	clear_port_feature(hdev, i,
2721	USB_PORT_FEAT_C_CONNECTION);	2789	USB_PORT_FEAT_C_CONNECTION);
2722	connect_change = 1;	2790	connect_change = 1;
2723	}	2791	}
2724		2792
2725	if (portchange & USB_PORT_STAT_C_ENABLE) {	2793	if (portchange & USB_PORT_STAT_C_ENABLE) {
2726	if (!connect_change)	2794	if (!connect_change)
2727	dev_dbg (hub_dev,	2795	dev_dbg (hub_dev,
2728	"port %d enable change, "	2796	"port %d enable change, "
2729	"status %08x\n",	2797	"status %08x\n",
2730	i, portstatus);	2798	i, portstatus);
2731	clear_port_feature(hdev, i,	2799	clear_port_feature(hdev, i,
2732	USB_PORT_FEAT_C_ENABLE);	2800	USB_PORT_FEAT_C_ENABLE);
2733		2801
2734	/*	2802	/*
2735	* EM interference sometimes causes badly	2803	* EM interference sometimes causes badly
2736	* shielded USB devices to be shutdown by	2804	* shielded USB devices to be shutdown by
2737	* the hub, this hack enables them again.	2805	* the hub, this hack enables them again.
2738	* Works at least with mouse driver.	2806	* Works at least with mouse driver.
2739	*/	2807	*/
2740	if (!(portstatus & USB_PORT_STAT_ENABLE)	2808	if (!(portstatus & USB_PORT_STAT_ENABLE)
2741	&& !connect_change	2809	&& !connect_change
2742	&& hdev->children[i-1]) {	2810	&& hdev->children[i-1]) {
2743	dev_err (hub_dev,	2811	dev_err (hub_dev,
2744	"port %i "	2812	"port %i "
2745	"disabled by hub (EMI?), "	2813	"disabled by hub (EMI?), "
2746	"re-enabling...\n",	2814	"re-enabling...\n",
2747	i);	2815	i);
2748	connect_change = 1;	2816	connect_change = 1;
2749	}	2817	}
2750	}	2818	}
2751		2819
2752	if (portchange & USB_PORT_STAT_C_SUSPEND) {	2820	if (portchange & USB_PORT_STAT_C_SUSPEND) {
2753	clear_port_feature(hdev, i,	2821	clear_port_feature(hdev, i,
2754	USB_PORT_FEAT_C_SUSPEND);	2822	USB_PORT_FEAT_C_SUSPEND);
2755	if (hdev->children[i-1]) {	2823	if (hdev->children[i-1]) {
2756	ret = remote_wakeup(hdev->	2824	ret = remote_wakeup(hdev->
2757	children[i-1]);	2825	children[i-1]);
2758	if (ret < 0)	2826	if (ret < 0)
2759	connect_change = 1;	2827	connect_change = 1;
2760	} else {	2828	} else {
2761	ret = -ENODEV;	2829	ret = -ENODEV;
2762	hub_port_disable(hub, i, 1);	2830	hub_port_disable(hub, i, 1);
2763	}	2831	}
2764	dev_dbg (hub_dev,	2832	dev_dbg (hub_dev,
2765	"resume on port %d, status %d\n",	2833	"resume on port %d, status %d\n",
2766	i, ret);	2834	i, ret);
2767	}	2835	}
2768		2836
2769	if (portchange & USB_PORT_STAT_C_OVERCURRENT) {	2837	if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
2770	dev_err (hub_dev,	2838	dev_err (hub_dev,
2771	"over-current change on port %d\n",	2839	"over-current change on port %d\n",
2772	i);	2840	i);
2773	clear_port_feature(hdev, i,	2841	clear_port_feature(hdev, i,
2774	USB_PORT_FEAT_C_OVER_CURRENT);	2842	USB_PORT_FEAT_C_OVER_CURRENT);
2775	hub_power_on(hub);	2843	hub_power_on(hub);
2776	}	2844	}
2777		2845
2778	if (portchange & USB_PORT_STAT_C_RESET) {	2846	if (portchange & USB_PORT_STAT_C_RESET) {
2779	dev_dbg (hub_dev,	2847	dev_dbg (hub_dev,
2780	"reset change on port %d\n",	2848	"reset change on port %d\n",
2781	i);	2849	i);
2782	clear_port_feature(hdev, i,	2850	clear_port_feature(hdev, i,
2783	USB_PORT_FEAT_C_RESET);	2851	USB_PORT_FEAT_C_RESET);
2784	}	2852	}
2785		2853
2786	if (connect_change)	2854	if (connect_change)
2787	hub_port_connect_change(hub, i,	2855	hub_port_connect_change(hub, i,
2788	portstatus, portchange);	2856	portstatus, portchange);
2789	} /* end for i */	2857	} /* end for i */
2790		2858
2791	/* deal with hub status changes */	2859	/* deal with hub status changes */
2792	if (test_and_clear_bit(0, hub->event_bits) == 0)	2860	if (test_and_clear_bit(0, hub->event_bits) == 0)
2793	; /* do nothing */	2861	; /* do nothing */
2794	else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)	2862	else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
2795	dev_err (hub_dev, "get_hub_status failed\n");	2863	dev_err (hub_dev, "get_hub_status failed\n");
2796	else {	2864	else {
2797	if (hubchange & HUB_CHANGE_LOCAL_POWER) {	2865	if (hubchange & HUB_CHANGE_LOCAL_POWER) {
2798	dev_dbg (hub_dev, "power change\n");	2866	dev_dbg (hub_dev, "power change\n");
2799	clear_hub_feature(hdev, C_HUB_LOCAL_POWER);	2867	clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
		2868	if (hubstatus & HUB_STATUS_LOCAL_POWER)
		2869	/* FIXME: Is this always true? */
		2870	hub->limited_power = 0;
		2871	else
		2872	hub->limited_power = 1;
2800	}	2873	}
2801	if (hubchange & HUB_CHANGE_OVERCURRENT) {	2874	if (hubchange & HUB_CHANGE_OVERCURRENT) {
2802	dev_dbg (hub_dev, "overcurrent change\n");	2875	dev_dbg (hub_dev, "overcurrent change\n");
2803	msleep(500); /* Cool down */	2876	msleep(500); /* Cool down */
2804	clear_hub_feature(hdev, C_HUB_OVER_CURRENT);	2877	clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
2805	hub_power_on(hub);	2878	hub_power_on(hub);
2806	}	2879	}
2807	}	2880	}
2808		2881
2809	hub->activating = 0;	2882	hub->activating = 0;
2810		2883
2811	/* If this is a root hub, tell the HCD it's okay to	2884	/* If this is a root hub, tell the HCD it's okay to
2812	* re-enable port-change interrupts now. */	2885	* re-enable port-change interrupts now. */
2813	if (!hdev->parent)	2886	if (!hdev->parent)
2814	usb_enable_root_hub_irq(hdev->bus);	2887	usb_enable_root_hub_irq(hdev->bus);
2815		2888
2816	loop:	2889	loop:
2817	usb_unlock_device(hdev);	2890	usb_unlock_device(hdev);
2818	usb_put_intf(intf);	2891	usb_put_intf(intf);
2819		2892
2820	} /* end while (1) */	2893	} /* end while (1) */
2821	}	2894	}
2822		2895
2823	static int hub_thread(void *__unused)	2896	static int hub_thread(void *__unused)
2824	{	2897	{
2825	do {	2898	do {
2826	hub_events();	2899	hub_events();
2827	wait_event_interruptible(khubd_wait,	2900	wait_event_interruptible(khubd_wait,
2828	!list_empty(&hub_event_list) \|\|	2901	!list_empty(&hub_event_list) \|\|
2829	kthread_should_stop());	2902	kthread_should_stop());
2830	try_to_freeze();	2903	try_to_freeze();
2831	} while (!kthread_should_stop() \|\| !list_empty(&hub_event_list));	2904	} while (!kthread_should_stop() \|\| !list_empty(&hub_event_list));
2832		2905
2833	pr_debug("%s: khubd exiting\n", usbcore_name);	2906	pr_debug("%s: khubd exiting\n", usbcore_name);
2834	return 0;	2907	return 0;
2835	}	2908	}
2836		2909
2837	static struct usb_device_id hub_id_table [] = {	2910	static struct usb_device_id hub_id_table [] = {
2838	{ .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,	2911	{ .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
2839	.bDeviceClass = USB_CLASS_HUB},	2912	.bDeviceClass = USB_CLASS_HUB},
2840	{ .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,	2913	{ .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
2841	.bInterfaceClass = USB_CLASS_HUB},	2914	.bInterfaceClass = USB_CLASS_HUB},
2842	{ } /* Terminating entry */	2915	{ } /* Terminating entry */
2843	};	2916	};
2844		2917
2845	MODULE_DEVICE_TABLE (usb, hub_id_table);	2918	MODULE_DEVICE_TABLE (usb, hub_id_table);
2846		2919
2847	static struct usb_driver hub_driver = {	2920	static struct usb_driver hub_driver = {
2848	.name = "hub",	2921	.name = "hub",
2849	.probe = hub_probe,	2922	.probe = hub_probe,
2850	.disconnect = hub_disconnect,	2923	.disconnect = hub_disconnect,
2851	.suspend = hub_suspend,	2924	.suspend = hub_suspend,
2852	.resume = hub_resume,	2925	.resume = hub_resume,
2853	.ioctl = hub_ioctl,	2926	.ioctl = hub_ioctl,
2854	.id_table = hub_id_table,	2927	.id_table = hub_id_table,
2855	};	2928	};
2856		2929
2857	int usb_hub_init(void)	2930	int usb_hub_init(void)
2858	{	2931	{
2859	if (usb_register(&hub_driver) < 0) {	2932	if (usb_register(&hub_driver) < 0) {
2860	printk(KERN_ERR "%s: can't register hub driver\n",	2933	printk(KERN_ERR "%s: can't register hub driver\n",
2861	usbcore_name);	2934	usbcore_name);
2862	return -1;	2935	return -1;
2863	}	2936	}
2864		2937
2865	khubd_task = kthread_run(hub_thread, NULL, "khubd");	2938	khubd_task = kthread_run(hub_thread, NULL, "khubd");
2866	if (!IS_ERR(khubd_task))	2939	if (!IS_ERR(khubd_task))
2867	return 0;	2940	return 0;
2868		2941
2869	/* Fall through if kernel_thread failed */	2942	/* Fall through if kernel_thread failed */
2870	usb_deregister(&hub_driver);	2943	usb_deregister(&hub_driver);
2871	printk(KERN_ERR "%s: can't start khubd\n", usbcore_name);	2944	printk(KERN_ERR "%s: can't start khubd\n", usbcore_name);
2872		2945
2873	return -1;	2946	return -1;
2874	}	2947	}
2875		2948
2876	void usb_hub_cleanup(void)	2949	void usb_hub_cleanup(void)
2877	{	2950	{
2878	kthread_stop(khubd_task);	2951	kthread_stop(khubd_task);
2879		2952
2880	/*	2953	/*
2881	* Hub resources are freed for us by usb_deregister. It calls	2954	* Hub resources are freed for us by usb_deregister. It calls
2882	* usb_driver_purge on every device which in turn calls that	2955	* usb_driver_purge on every device which in turn calls that
2883	* devices disconnect function if it is using this driver.	2956	* devices disconnect function if it is using this driver.
2884	* The hub_disconnect function takes care of releasing the	2957	* The hub_disconnect function takes care of releasing the
2885	* individual hub resources. -greg	2958	* individual hub resources. -greg
2886	*/	2959	*/
2887	usb_deregister(&hub_driver);	2960	usb_deregister(&hub_driver);
2888	} /* usb_hub_cleanup() */	2961	} /* usb_hub_cleanup() */
2889		2962
2890	static int config_descriptors_changed(struct usb_device *udev)	2963	static int config_descriptors_changed(struct usb_device *udev)
2891	{	2964	{
2892	unsigned index;	2965	unsigned index;
2893	unsigned len = 0;	2966	unsigned len = 0;
2894	struct usb_config_descriptor *buf;	2967	struct usb_config_descriptor *buf;
2895		2968
2896	for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {	2969	for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
2897	if (len < le16_to_cpu(udev->config[index].desc.wTotalLength))	2970	if (len < le16_to_cpu(udev->config[index].desc.wTotalLength))
2898	len = le16_to_cpu(udev->config[index].desc.wTotalLength);	2971	len = le16_to_cpu(udev->config[index].desc.wTotalLength);
2899	}	2972	}
2900	buf = kmalloc (len, SLAB_KERNEL);	2973	buf = kmalloc (len, SLAB_KERNEL);
2901	if (buf == NULL) {	2974	if (buf == NULL) {
2902	dev_err(&udev->dev, "no mem to re-read configs after reset\n");	2975	dev_err(&udev->dev, "no mem to re-read configs after reset\n");
2903	/* assume the worst */	2976	/* assume the worst */
2904	return 1;	2977	return 1;
2905	}	2978	}
2906	for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {	2979	for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
2907	int length;	2980	int length;
2908	int old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);	2981	int old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
2909		2982
2910	length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf,	2983	length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf,
2911	old_length);	2984	old_length);
2912	if (length < old_length) {	2985	if (length < old_length) {
2913	dev_dbg(&udev->dev, "config index %d, error %d\n",	2986	dev_dbg(&udev->dev, "config index %d, error %d\n",
2914	index, length);	2987	index, length);
2915	break;	2988	break;
2916	}	2989	}
2917	if (memcmp (buf, udev->rawdescriptors[index], old_length)	2990	if (memcmp (buf, udev->rawdescriptors[index], old_length)
2918	!= 0) {	2991	!= 0) {
2919	dev_dbg(&udev->dev, "config index %d changed (#%d)\n",	2992	dev_dbg(&udev->dev, "config index %d changed (#%d)\n",
2920	index, buf->bConfigurationValue);	2993	index, buf->bConfigurationValue);
2921	break;	2994	break;
2922	}	2995	}
2923	}	2996	}
2924	kfree(buf);	2997	kfree(buf);
2925	return index != udev->descriptor.bNumConfigurations;	2998	return index != udev->descriptor.bNumConfigurations;
2926	}	2999	}
2927		3000
2928	/**	3001	/**
2929	* usb_reset_device - perform a USB port reset to reinitialize a device	3002	* usb_reset_device - perform a USB port reset to reinitialize a device
2930	* @udev: device to reset (not in SUSPENDED or NOTATTACHED state)	3003	* @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
2931	*	3004	*
2932	* WARNING - don't reset any device unless drivers for all of its	3005	* WARNING - don't reset any device unless drivers for all of its
2933	* interfaces are expecting that reset! Maybe some driver->reset()	3006	* interfaces are expecting that reset! Maybe some driver->reset()
2934	* method should eventually help ensure sufficient cooperation.	3007	* method should eventually help ensure sufficient cooperation.
2935	*	3008	*
2936	* Do a port reset, reassign the device's address, and establish its	3009	* Do a port reset, reassign the device's address, and establish its
2937	* former operating configuration. If the reset fails, or the device's	3010	* former operating configuration. If the reset fails, or the device's
2938	* descriptors change from their values before the reset, or the original	3011	* descriptors change from their values before the reset, or the original
2939	* configuration and altsettings cannot be restored, a flag will be set	3012	* configuration and altsettings cannot be restored, a flag will be set
2940	* telling khubd to pretend the device has been disconnected and then	3013	* telling khubd to pretend the device has been disconnected and then
2941	* re-connected. All drivers will be unbound, and the device will be	3014	* re-connected. All drivers will be unbound, and the device will be
2942	* re-enumerated and probed all over again.	3015	* re-enumerated and probed all over again.
2943	*	3016	*
2944	* Returns 0 if the reset succeeded, -ENODEV if the device has been	3017	* Returns 0 if the reset succeeded, -ENODEV if the device has been
2945	* flagged for logical disconnection, or some other negative error code	3018	* flagged for logical disconnection, or some other negative error code
2946	* if the reset wasn't even attempted.	3019	* if the reset wasn't even attempted.
2947	*	3020	*
2948	* The caller must own the device lock. For example, it's safe to use	3021	* The caller must own the device lock. For example, it's safe to use
2949	* this from a driver probe() routine after downloading new firmware.	3022	* this from a driver probe() routine after downloading new firmware.
2950	* For calls that might not occur during probe(), drivers should lock	3023	* For calls that might not occur during probe(), drivers should lock
2951	* the device using usb_lock_device_for_reset().	3024	* the device using usb_lock_device_for_reset().
2952	*/	3025	*/
2953	int usb_reset_device(struct usb_device *udev)	3026	int usb_reset_device(struct usb_device *udev)
2954	{	3027	{
2955	struct usb_device *parent_hdev = udev->parent;	3028	struct usb_device *parent_hdev = udev->parent;
2956	struct usb_hub *parent_hub;	3029	struct usb_hub *parent_hub;
2957	struct usb_device_descriptor descriptor = udev->descriptor;	3030	struct usb_device_descriptor descriptor = udev->descriptor;
2958	struct usb_hub *hub = NULL;	3031	struct usb_hub *hub = NULL;
2959	int i, ret = 0, port1 = -1;	3032	int i, ret = 0, port1 = -1;
2960		3033
2961	if (udev->state == USB_STATE_NOTATTACHED \|\|	3034	if (udev->state == USB_STATE_NOTATTACHED \|\|
2962	udev->state == USB_STATE_SUSPENDED) {	3035	udev->state == USB_STATE_SUSPENDED) {
2963	dev_dbg(&udev->dev, "device reset not allowed in state %d\n",	3036	dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
2964	udev->state);	3037	udev->state);
2965	return -EINVAL;	3038	return -EINVAL;
2966	}	3039	}
2967		3040
2968	if (!parent_hdev) {	3041	if (!parent_hdev) {
2969	/* this requires hcd-specific logic; see OHCI hc_restart() */	3042	/* this requires hcd-specific logic; see OHCI hc_restart() */
2970	dev_dbg(&udev->dev, "%s for root hub!\n", __FUNCTION__);	3043	dev_dbg(&udev->dev, "%s for root hub!\n", __FUNCTION__);
2971	return -EISDIR;	3044	return -EISDIR;
2972	}	3045	}
2973		3046
2974	for (i = 0; i < parent_hdev->maxchild; i++)	3047	for (i = 0; i < parent_hdev->maxchild; i++)
2975	if (parent_hdev->children[i] == udev) {	3048	if (parent_hdev->children[i] == udev) {
2976	port1 = i + 1;	3049	port1 = i + 1;
2977	break;	3050	break;
2978	}	3051	}
2979		3052
2980	if (port1 < 0) {	3053	if (port1 < 0) {
2981	/* If this ever happens, it's very bad */	3054	/* If this ever happens, it's very bad */
2982	dev_err(&udev->dev, "Can't locate device's port!\n");	3055	dev_err(&udev->dev, "Can't locate device's port!\n");
2983	return -ENOENT;	3056	return -ENOENT;
2984	}	3057	}
2985	parent_hub = hdev_to_hub(parent_hdev);	3058	parent_hub = hdev_to_hub(parent_hdev);
2986		3059
2987	/* If we're resetting an active hub, take some special actions */	3060	/* If we're resetting an active hub, take some special actions */
2988	if (udev->actconfig &&	3061	if (udev->actconfig &&
2989	udev->actconfig->interface[0]->dev.driver ==	3062	udev->actconfig->interface[0]->dev.driver ==
2990	&hub_driver.driver &&	3063	&hub_driver.driver &&
2991	(hub = hdev_to_hub(udev)) != NULL) {	3064	(hub = hdev_to_hub(udev)) != NULL) {
2992	hub_pre_reset(hub, 0);	3065	hub_pre_reset(hub, 0);
2993	}	3066	}
2994		3067
2995	set_bit(port1, parent_hub->busy_bits);	3068	set_bit(port1, parent_hub->busy_bits);
2996	for (i = 0; i < SET_CONFIG_TRIES; ++i) {	3069	for (i = 0; i < SET_CONFIG_TRIES; ++i) {
2997		3070
2998	/* ep0 maxpacket size may change; let the HCD know about it.	3071	/* ep0 maxpacket size may change; let the HCD know about it.
2999	* Other endpoints will be handled by re-enumeration. */	3072	* Other endpoints will be handled by re-enumeration. */
3000	ep0_reinit(udev);	3073	ep0_reinit(udev);
3001	ret = hub_port_init(parent_hub, udev, port1, i);	3074	ret = hub_port_init(parent_hub, udev, port1, i);
3002	if (ret >= 0)	3075	if (ret >= 0)
3003	break;	3076	break;
3004	}	3077	}
3005	clear_bit(port1, parent_hub->busy_bits);	3078	clear_bit(port1, parent_hub->busy_bits);
3006	if (ret < 0)	3079	if (ret < 0)
3007	goto re_enumerate;	3080	goto re_enumerate;
3008		3081
3009	/* Device might have changed firmware (DFU or similar) */	3082	/* Device might have changed firmware (DFU or similar) */
3010	if (memcmp(&udev->descriptor, &descriptor, sizeof descriptor)	3083	if (memcmp(&udev->descriptor, &descriptor, sizeof descriptor)
3011	\|\| config_descriptors_changed (udev)) {	3084	\|\| config_descriptors_changed (udev)) {
3012	dev_info(&udev->dev, "device firmware changed\n");	3085	dev_info(&udev->dev, "device firmware changed\n");
3013	udev->descriptor = descriptor; /* for disconnect() calls */	3086	udev->descriptor = descriptor; /* for disconnect() calls */
3014	goto re_enumerate;	3087	goto re_enumerate;
3015	}	3088	}
3016		3089
3017	if (!udev->actconfig)	3090	if (!udev->actconfig)
3018	goto done;	3091	goto done;
3019		3092
3020	ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),	3093	ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3021	USB_REQ_SET_CONFIGURATION, 0,	3094	USB_REQ_SET_CONFIGURATION, 0,
3022	udev->actconfig->desc.bConfigurationValue, 0,	3095	udev->actconfig->desc.bConfigurationValue, 0,
3023	NULL, 0, USB_CTRL_SET_TIMEOUT);	3096	NULL, 0, USB_CTRL_SET_TIMEOUT);
3024	if (ret < 0) {	3097	if (ret < 0) {
3025	dev_err(&udev->dev,	3098	dev_err(&udev->dev,
3026	"can't restore configuration #%d (error=%d)\n",	3099	"can't restore configuration #%d (error=%d)\n",
3027	udev->actconfig->desc.bConfigurationValue, ret);	3100	udev->actconfig->desc.bConfigurationValue, ret);
3028	goto re_enumerate;	3101	goto re_enumerate;
3029	}	3102	}
3030	usb_set_device_state(udev, USB_STATE_CONFIGURED);	3103	usb_set_device_state(udev, USB_STATE_CONFIGURED);
3031		3104
3032	for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {	3105	for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
3033	struct usb_interface *intf = udev->actconfig->interface[i];	3106	struct usb_interface *intf = udev->actconfig->interface[i];
3034	struct usb_interface_descriptor *desc;	3107	struct usb_interface_descriptor *desc;
3035		3108
3036	/* set_interface resets host side toggle even	3109	/* set_interface resets host side toggle even
3037	* for altsetting zero. the interface may have no driver.	3110	* for altsetting zero. the interface may have no driver.
3038	*/	3111	*/
3039	desc = &intf->cur_altsetting->desc;	3112	desc = &intf->cur_altsetting->desc;
3040	ret = usb_set_interface(udev, desc->bInterfaceNumber,	3113	ret = usb_set_interface(udev, desc->bInterfaceNumber,
3041	desc->bAlternateSetting);	3114	desc->bAlternateSetting);
3042	if (ret < 0) {	3115	if (ret < 0) {
3043	dev_err(&udev->dev, "failed to restore interface %d "	3116	dev_err(&udev->dev, "failed to restore interface %d "
3044	"altsetting %d (error=%d)\n",	3117	"altsetting %d (error=%d)\n",
3045	desc->bInterfaceNumber,	3118	desc->bInterfaceNumber,
3046	desc->bAlternateSetting,	3119	desc->bAlternateSetting,
3047	ret);	3120	ret);
3048	goto re_enumerate;	3121	goto re_enumerate;

drivers/usb/core/hub.h

Diff comments View file @ 55c5271

 #ifndef __LINUX_HUB_H
 #define __LINUX_HUB_H
 /*
  * Hub protocol and driver data structures.
  *
  * Some of these are known to the "virtual root hub" code
  * in host controller drivers.
  */
 #include <linux/list.h>
 #include <linux/workqueue.h>
 #include <linux/compiler.h>	/* likely()/unlikely() */
 /*
  * Hub request types
  */
 #define USB_RT_HUB	(USB_TYPE_CLASS | USB_RECIP_DEVICE)
 #define USB_RT_PORT	(USB_TYPE_CLASS | USB_RECIP_OTHER)
 /*
  * Hub class requests
  * See USB 2.0 spec Table 11-16
  */
 #define HUB_CLEAR_TT_BUFFER	8
 #define HUB_RESET_TT		9
 #define HUB_GET_TT_STATE	10
 #define HUB_STOP_TT		11
 /*
  * Hub Class feature numbers
  * See USB 2.0 spec Table 11-17
  */
 #define C_HUB_LOCAL_POWER	0
 #define C_HUB_OVER_CURRENT	1
 /*
  * Port feature numbers
  * See USB 2.0 spec Table 11-17
  */
 #define USB_PORT_FEAT_CONNECTION	0
 #define USB_PORT_FEAT_ENABLE		1
 #define USB_PORT_FEAT_SUSPEND		2
 #define USB_PORT_FEAT_OVER_CURRENT	3
 #define USB_PORT_FEAT_RESET		4
 #define USB_PORT_FEAT_POWER		8
 #define USB_PORT_FEAT_LOWSPEED		9
 #define USB_PORT_FEAT_HIGHSPEED		10
 #define USB_PORT_FEAT_C_CONNECTION	16
 #define USB_PORT_FEAT_C_ENABLE		17
 #define USB_PORT_FEAT_C_SUSPEND		18
 #define USB_PORT_FEAT_C_OVER_CURRENT	19
 #define USB_PORT_FEAT_C_RESET		20
 #define USB_PORT_FEAT_TEST              21
 #define USB_PORT_FEAT_INDICATOR         22
 /*
  * Hub Status and Hub Change results
  * See USB 2.0 spec Table 11-19 and Table 11-20
  */
 struct usb_port_status {
 	__le16 wPortStatus;
 	__le16 wPortChange;
 } __attribute__ ((packed));
 /*
  * wPortStatus bit field
  * See USB 2.0 spec Table 11-21
  */
 #define USB_PORT_STAT_CONNECTION	0x0001
 #define USB_PORT_STAT_ENABLE		0x0002
 #define USB_PORT_STAT_SUSPEND		0x0004
 #define USB_PORT_STAT_OVERCURRENT	0x0008
 #define USB_PORT_STAT_RESET		0x0010
 /* bits 5 to 7 are reserved */
 #define USB_PORT_STAT_POWER		0x0100
 #define USB_PORT_STAT_LOW_SPEED		0x0200
 #define USB_PORT_STAT_HIGH_SPEED        0x0400
 #define USB_PORT_STAT_TEST              0x0800
 #define USB_PORT_STAT_INDICATOR         0x1000
 /* bits 13 to 15 are reserved */
 /*
  * wPortChange bit field
  * See USB 2.0 spec Table 11-22
  * Bits 0 to 4 shown, bits 5 to 15 are reserved
  */
 #define USB_PORT_STAT_C_CONNECTION	0x0001
 #define USB_PORT_STAT_C_ENABLE		0x0002
 #define USB_PORT_STAT_C_SUSPEND		0x0004
 #define USB_PORT_STAT_C_OVERCURRENT	0x0008
 #define USB_PORT_STAT_C_RESET		0x0010
 /*
  * wHubCharacteristics (masks)
  * See USB 2.0 spec Table 11-13, offset 3
  */
 #define HUB_CHAR_LPSM		0x0003 /* D1 .. D0 */
 #define HUB_CHAR_COMPOUND	0x0004 /* D2       */
 #define HUB_CHAR_OCPM		0x0018 /* D4 .. D3 */
 #define HUB_CHAR_TTTT           0x0060 /* D6 .. D5 */
 #define HUB_CHAR_PORTIND        0x0080 /* D7       */
 struct usb_hub_status {
 	__le16 wHubStatus;
 	__le16 wHubChange;
 } __attribute__ ((packed));
 /*
  * Hub Status & Hub Change bit masks
  * See USB 2.0 spec Table 11-19 and Table 11-20
  * Bits 0 and 1 for wHubStatus and wHubChange
  * Bits 2 to 15 are reserved for both
  */
 #define HUB_STATUS_LOCAL_POWER	0x0001
 #define HUB_STATUS_OVERCURRENT	0x0002
 #define HUB_CHANGE_LOCAL_POWER	0x0001
 #define HUB_CHANGE_OVERCURRENT	0x0002
 /*
  * Hub descriptor
  * See USB 2.0 spec Table 11-13
  */
 #define USB_DT_HUB			(USB_TYPE_CLASS | 0x09)
 #define USB_DT_HUB_NONVAR_SIZE		7
 struct usb_hub_descriptor {
 	__u8  bDescLength;
 	__u8  bDescriptorType;
 	__u8  bNbrPorts;
 	__le16 wHubCharacteristics;
 	__u8  bPwrOn2PwrGood;
 	__u8  bHubContrCurrent;
 	    	/* add 1 bit for hub status change; round to bytes */
 	__u8  DeviceRemovable[(USB_MAXCHILDREN + 1 + 7) / 8];
 	__u8  PortPwrCtrlMask[(USB_MAXCHILDREN + 1 + 7) / 8];
 } __attribute__ ((packed));
 /* port indicator status selectors, tables 11-7 and 11-25 */
 #define HUB_LED_AUTO	0
 #define HUB_LED_AMBER	1
 #define HUB_LED_GREEN	2
 #define HUB_LED_OFF	3
 enum hub_led_mode {
 	INDICATOR_AUTO = 0,
 	INDICATOR_CYCLE,
 	/* software blinks for attention:  software, hardware, reserved */
 	INDICATOR_GREEN_BLINK, INDICATOR_GREEN_BLINK_OFF,
 	INDICATOR_AMBER_BLINK, INDICATOR_AMBER_BLINK_OFF,
 	INDICATOR_ALT_BLINK, INDICATOR_ALT_BLINK_OFF
 } __attribute__ ((packed));
 struct usb_device;
 /* Transaction Translator Think Times, in bits */
 #define HUB_TTTT_8_BITS		0x00
 #define HUB_TTTT_16_BITS	0x20
 #define HUB_TTTT_24_BITS	0x40
 #define HUB_TTTT_32_BITS	0x60
 /*
  * As of USB 2.0, full/low speed devices are segregated into trees.
  * One type grows from USB 1.1 host controllers (OHCI, UHCI etc).
  * The other type grows from high speed hubs when they connect to
  * full/low speed devices using "Transaction Translators" (TTs).
  *
  * TTs should only be known to the hub driver, and high speed bus
  * drivers (only EHCI for now).  They affect periodic scheduling and
  * sometimes control/bulk error recovery.
  */
 struct usb_tt {
 	struct usb_device	*hub;	/* upstream highspeed hub */
 	int			multi;	/* true means one TT per port */
 	unsigned		think_time;	/* think time in ns */
 	/* for control/bulk error recovery (CLEAR_TT_BUFFER) */
 	spinlock_t		lock;
 	struct list_head	clear_list;	/* of usb_tt_clear */
 	struct work_struct			kevent;
 };
 struct usb_tt_clear {
 	struct list_head	clear_list;
 	unsigned		tt;
 	u16			devinfo;
 };
 extern void usb_hub_tt_clear_buffer (struct usb_device *dev, int pipe);
 struct usb_hub {
 	struct device		*intfdev;	/* the "interface" device */
 	struct usb_device	*hdev;
 	struct urb		*urb;		/* for interrupt polling pipe */
 	/* buffer for urb ... with extra space in case of babble */
 	char			(*buffer)[8];
 	dma_addr_t		buffer_dma;	/* DMA address for buffer */
 	union {
 		struct usb_hub_status	hub;
 		struct usb_port_status	port;
 	}			*status;	/* buffer for status reports */
 	int			error;		/* last reported error */
 	int			nerrors;	/* track consecutive errors */
 	struct list_head	event_list;	/* hubs w/data or errs ready */
 	unsigned long		event_bits[1];	/* status change bitmask */
 	unsigned long		change_bits[1];	/* ports with logical connect
 							status change */
 	unsigned long		busy_bits[1];	/* ports being reset */
 #if USB_MAXCHILDREN > 31 /* 8*sizeof(unsigned long) - 1 */
 #error event_bits[] is too short!
 #endif
 	struct usb_hub_descriptor *descriptor;	/* class descriptor */
 	struct usb_tt		tt;		/* Transaction Translator */
-	u8			power_budget;	/* in 2mA units; or zero */
+	unsigned		mA_per_port;	/* current for each child */
+	unsigned		limited_power:1;
 	unsigned		quiescing:1;
 	unsigned		activating:1;
 	unsigned		resume_root_hub:1;
 	unsigned		has_indicators:1;
 	enum hub_led_mode	indicator[USB_MAXCHILDREN];
 	struct work_struct	leds;
 };
 #endif /* __LINUX_HUB_H */

drivers/usb/core/message.c

Diff comments View file @ 55c5271

 /*
  * message.c - synchronous message handling
  */
 #include <linux/config.h>
 #include <linux/pci.h>	/* for scatterlist macros */
 #include <linux/usb.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/timer.h>
 #include <linux/ctype.h>
 #include <linux/device.h>
 #include <asm/byteorder.h>
 #include "hcd.h"	/* for usbcore internals */
 #include "usb.h"
 static void usb_api_blocking_completion(struct urb *urb, struct pt_regs *regs)
 {
 	complete((struct completion *)urb->context);
 }
 static void timeout_kill(unsigned long data)
 {
 	struct urb	*urb = (struct urb *) data;
 	usb_unlink_urb(urb);
 }
 // Starts urb and waits for completion or timeout
 // note that this call is NOT interruptible, while
 // many device driver i/o requests should be interruptible
 static int usb_start_wait_urb(struct urb *urb, int timeout, int* actual_length)
 {
 	struct completion	done;
 	struct timer_list	timer;
 	int			status;
 	init_completion(&done);
 	urb->context = &done;
 	urb->actual_length = 0;
 	status = usb_submit_urb(urb, GFP_NOIO);
 	if (status == 0) {
 		if (timeout > 0) {
 			init_timer(&timer);
 			timer.expires = jiffies + msecs_to_jiffies(timeout);
 			timer.data = (unsigned long)urb;
 			timer.function = timeout_kill;
 			/* grr.  timeout _should_ include submit delays. */
 			add_timer(&timer);
 		}
 		wait_for_completion(&done);
 		status = urb->status;
 		/* note:  HCDs return ETIMEDOUT for other reasons too */
 		if (status == -ECONNRESET) {
 			dev_dbg(&urb->dev->dev,
 				"%s timed out on ep%d%s len=%d/%d\n",
 				current->comm,
 				usb_pipeendpoint(urb->pipe),
 				usb_pipein(urb->pipe) ? "in" : "out",
 				urb->actual_length,
 				urb->transfer_buffer_length
 				);
 			if (urb->actual_length > 0)
 				status = 0;
 			else
 				status = -ETIMEDOUT;
 		}
 		if (timeout > 0)
 			del_timer_sync(&timer);
 	}
 	if (actual_length)
 		*actual_length = urb->actual_length;
 	usb_free_urb(urb);
 	return status;
 }
 /*-------------------------------------------------------------------*/
 // returns status (negative) or length (positive)
 static int usb_internal_control_msg(struct usb_device *usb_dev,
 				    unsigned int pipe,
 				    struct usb_ctrlrequest *cmd,
 				    void *data, int len, int timeout)
 {
 	struct urb *urb;
 	int retv;
 	int length;
 	urb = usb_alloc_urb(0, GFP_NOIO);
 	if (!urb)
 		return -ENOMEM;
 	usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char *)cmd, data,
 			     len, usb_api_blocking_completion, NULL);
 	retv = usb_start_wait_urb(urb, timeout, &length);
 	if (retv < 0)
 		return retv;
 	else
 		return length;
 }
 /**
  *	usb_control_msg - Builds a control urb, sends it off and waits for completion
  *	@dev: pointer to the usb device to send the message to
  *	@pipe: endpoint "pipe" to send the message to
  *	@request: USB message request value
  *	@requesttype: USB message request type value
  *	@value: USB message value
  *	@index: USB message index value
  *	@data: pointer to the data to send
  *	@size: length in bytes of the data to send
  *	@timeout: time in msecs to wait for the message to complete before
  *		timing out (if 0 the wait is forever)
  *	Context: !in_interrupt ()
  *
  *	This function sends a simple control message to a specified endpoint
  *	and waits for the message to complete, or timeout.
  *
  *	If successful, it returns the number of bytes transferred, otherwise a negative error number.
  *
  *	Don't use this function from within an interrupt context, like a
  *	bottom half handler.  If you need an asynchronous message, or need to send
  *	a message from within interrupt context, use usb_submit_urb()
  *      If a thread in your driver uses this call, make sure your disconnect()
  *      method can wait for it to complete.  Since you don't have a handle on
  *      the URB used, you can't cancel the request.
  */
 int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request, __u8 requesttype,
 			 __u16 value, __u16 index, void *data, __u16 size, int timeout)
 {
 	struct usb_ctrlrequest *dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);
 	int ret;
 	if (!dr)
 		return -ENOMEM;
 	dr->bRequestType= requesttype;
 	dr->bRequest = request;
 	dr->wValue = cpu_to_le16p(&value);
 	dr->wIndex = cpu_to_le16p(&index);
 	dr->wLength = cpu_to_le16p(&size);
 	//dbg("usb_control_msg");
 	ret = usb_internal_control_msg(dev, pipe, dr, data, size, timeout);
 	kfree(dr);
 	return ret;
 }
 /**
  *	usb_bulk_msg - Builds a bulk urb, sends it off and waits for completion
  *	@usb_dev: pointer to the usb device to send the message to
  *	@pipe: endpoint "pipe" to send the message to
  *	@data: pointer to the data to send
  *	@len: length in bytes of the data to send
  *	@actual_length: pointer to a location to put the actual length transferred in bytes
  *	@timeout: time in msecs to wait for the message to complete before
  *		timing out (if 0 the wait is forever)
  *	Context: !in_interrupt ()
  *
  *	This function sends a simple bulk message to a specified endpoint
  *	and waits for the message to complete, or timeout.
  *
  *	If successful, it returns 0, otherwise a negative error number.
  *	The number of actual bytes transferred will be stored in the
  *	actual_length paramater.
  *
  *	Don't use this function from within an interrupt context, like a
  *	bottom half handler.  If you need an asynchronous message, or need to
  *	send a message from within interrupt context, use usb_submit_urb()
  *      If a thread in your driver uses this call, make sure your disconnect()
  *      method can wait for it to complete.  Since you don't have a handle on
  *      the URB used, you can't cancel the request.
  *
  *	Because there is no usb_interrupt_msg() and no USBDEVFS_INTERRUPT
  *	ioctl, users are forced to abuse this routine by using it to submit
  *	URBs for interrupt endpoints.  We will take the liberty of creating
  *	an interrupt URB (with the default interval) if the target is an
  *	interrupt endpoint.
  */
 int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,
 			void *data, int len, int *actual_length, int timeout)
 {
 	struct urb *urb;
 	struct usb_host_endpoint *ep;
 	ep = (usb_pipein(pipe) ? usb_dev->ep_in : usb_dev->ep_out)
 			[usb_pipeendpoint(pipe)];
 	if (!ep || len < 0)
 		return -EINVAL;
 	urb = usb_alloc_urb(0, GFP_KERNEL);
 	if (!urb)
 		return -ENOMEM;
 	if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
 			USB_ENDPOINT_XFER_INT) {
 		pipe = (pipe & ~(3 << 30)) | (PIPE_INTERRUPT << 30);
 		usb_fill_int_urb(urb, usb_dev, pipe, data, len,
 				usb_api_blocking_completion, NULL,
 				ep->desc.bInterval);
 	} else
 		usb_fill_bulk_urb(urb, usb_dev, pipe, data, len,
 				usb_api_blocking_completion, NULL);
 	return usb_start_wait_urb(urb, timeout, actual_length);
 }
 /*-------------------------------------------------------------------*/
 static void sg_clean (struct usb_sg_request *io)
 {
 	if (io->urbs) {
 		while (io->entries--)
 			usb_free_urb (io->urbs [io->entries]);
 		kfree (io->urbs);
 		io->urbs = NULL;
 	}
 	if (io->dev->dev.dma_mask != NULL)
 		usb_buffer_unmap_sg (io->dev, io->pipe, io->sg, io->nents);
 	io->dev = NULL;
 }
 static void sg_complete (struct urb *urb, struct pt_regs *regs)
 {
 	struct usb_sg_request	*io = (struct usb_sg_request *) urb->context;
 	spin_lock (&io->lock);
 	/* In 2.5 we require hcds' endpoint queues not to progress after fault
 	 * reports, until the completion callback (this!) returns.  That lets
 	 * device driver code (like this routine) unlink queued urbs first,
 	 * if it needs to, since the HC won't work on them at all.  So it's
 	 * not possible for page N+1 to overwrite page N, and so on.
 	 *
 	 * That's only for "hard" faults; "soft" faults (unlinks) sometimes
 	 * complete before the HCD can get requests away from hardware,
 	 * though never during cleanup after a hard fault.
 	 */
 	if (io->status
 			&& (io->status != -ECONNRESET
 				|| urb->status != -ECONNRESET)
 			&& urb->actual_length) {
 		dev_err (io->dev->bus->controller,
 			"dev %s ep%d%s scatterlist error %d/%d\n",
 			io->dev->devpath,
 			usb_pipeendpoint (urb->pipe),
 			usb_pipein (urb->pipe) ? "in" : "out",
 			urb->status, io->status);
 		// BUG ();
 	}
 	if (io->status == 0 && urb->status && urb->status != -ECONNRESET) {
 		int		i, found, status;
 		io->status = urb->status;
 		/* the previous urbs, and this one, completed already.
 		 * unlink pending urbs so they won't rx/tx bad data.
 		 * careful: unlink can sometimes be synchronous...
 		 */
 		spin_unlock (&io->lock);
 		for (i = 0, found = 0; i < io->entries; i++) {
 			if (!io->urbs [i] || !io->urbs [i]->dev)
 				continue;
 			if (found) {
 				status = usb_unlink_urb (io->urbs [i]);
 				if (status != -EINPROGRESS
 						&& status != -ENODEV
 						&& status != -EBUSY)
 					dev_err (&io->dev->dev,
 						"%s, unlink --> %d\n",
 						__FUNCTION__, status);
 			} else if (urb == io->urbs [i])
 				found = 1;
 		}
 		spin_lock (&io->lock);
 	}
 	urb->dev = NULL;
 	/* on the last completion, signal usb_sg_wait() */
 	io->bytes += urb->actual_length;
 	io->count--;
 	if (!io->count)
 		complete (&io->complete);
 	spin_unlock (&io->lock);
 }
 /**
  * usb_sg_init - initializes scatterlist-based bulk/interrupt I/O request
  * @io: request block being initialized.  until usb_sg_wait() returns,
  *	treat this as a pointer to an opaque block of memory,
  * @dev: the usb device that will send or receive the data
  * @pipe: endpoint "pipe" used to transfer the data
  * @period: polling rate for interrupt endpoints, in frames or
  * 	(for high speed endpoints) microframes; ignored for bulk
  * @sg: scatterlist entries
  * @nents: how many entries in the scatterlist
  * @length: how many bytes to send from the scatterlist, or zero to
  * 	send every byte identified in the list.
  * @mem_flags: SLAB_* flags affecting memory allocations in this call
  *
  * Returns zero for success, else a negative errno value.  This initializes a
  * scatter/gather request, allocating resources such as I/O mappings and urb
  * memory (except maybe memory used by USB controller drivers).
  *
  * The request must be issued using usb_sg_wait(), which waits for the I/O to
  * complete (or to be canceled) and then cleans up all resources allocated by
  * usb_sg_init().
  *
  * The request may be canceled with usb_sg_cancel(), either before or after
  * usb_sg_wait() is called.
  */
 int usb_sg_init (
 	struct usb_sg_request	*io,
 	struct usb_device	*dev,
 	unsigned		pipe,
 	unsigned		period,
 	struct scatterlist	*sg,
 	int			nents,
 	size_t			length,
 	gfp_t			mem_flags
 )
 {
 	int			i;
 	int			urb_flags;
 	int			dma;
 	if (!io || !dev || !sg
 			|| usb_pipecontrol (pipe)
 			|| usb_pipeisoc (pipe)
 			|| nents <= 0)
 		return -EINVAL;
 	spin_lock_init (&io->lock);
 	io->dev = dev;
 	io->pipe = pipe;
 	io->sg = sg;
 	io->nents = nents;
 	/* not all host controllers use DMA (like the mainstream pci ones);
 	 * they can use PIO (sl811) or be software over another transport.
 	 */
 	dma = (dev->dev.dma_mask != NULL);
 	if (dma)
 		io->entries = usb_buffer_map_sg (dev, pipe, sg, nents);
 	else
 		io->entries = nents;
 	/* initialize all the urbs we'll use */
 	if (io->entries <= 0)
 		return io->entries;
 	io->count = io->entries;
 	io->urbs = kmalloc (io->entries * sizeof *io->urbs, mem_flags);
 	if (!io->urbs)
 		goto nomem;
 	urb_flags = URB_NO_TRANSFER_DMA_MAP | URB_NO_INTERRUPT;
 	if (usb_pipein (pipe))
 		urb_flags |= URB_SHORT_NOT_OK;
 	for (i = 0; i < io->entries; i++) {
 		unsigned		len;
 		io->urbs [i] = usb_alloc_urb (0, mem_flags);
 		if (!io->urbs [i]) {
 			io->entries = i;
 			goto nomem;
 		}
 		io->urbs [i]->dev = NULL;
 		io->urbs [i]->pipe = pipe;
 		io->urbs [i]->interval = period;
 		io->urbs [i]->transfer_flags = urb_flags;
 		io->urbs [i]->complete = sg_complete;
 		io->urbs [i]->context = io;
 		io->urbs [i]->status = -EINPROGRESS;
 		io->urbs [i]->actual_length = 0;
 		if (dma) {
 			/* hc may use _only_ transfer_dma */
 			io->urbs [i]->transfer_dma = sg_dma_address (sg + i);
 			len = sg_dma_len (sg + i);
 		} else {
 			/* hc may use _only_ transfer_buffer */
 			io->urbs [i]->transfer_buffer =
 				page_address (sg [i].page) + sg [i].offset;
 			len = sg [i].length;
 		}
 		if (length) {
 			len = min_t (unsigned, len, length);
 			length -= len;
 			if (length == 0)
 				io->entries = i + 1;
 		}
 		io->urbs [i]->transfer_buffer_length = len;
 	}
 	io->urbs [--i]->transfer_flags &= ~URB_NO_INTERRUPT;
 	/* transaction state */
 	io->status = 0;
 	io->bytes = 0;
 	init_completion (&io->complete);
 	return 0;
 nomem:
 	sg_clean (io);
 	return -ENOMEM;
 }
 /**
  * usb_sg_wait - synchronously execute scatter/gather request
  * @io: request block handle, as initialized with usb_sg_init().
  * 	some fields become accessible when this call returns.
  * Context: !in_interrupt ()
  *
  * This function blocks until the specified I/O operation completes.  It
  * leverages the grouping of the related I/O requests to get good transfer
  * rates, by queueing the requests.  At higher speeds, such queuing can
  * significantly improve USB throughput.
  *
  * There are three kinds of completion for this function.
  * (1) success, where io->status is zero.  The number of io->bytes
  *     transferred is as requested.
  * (2) error, where io->status is a negative errno value.  The number
  *     of io->bytes transferred before the error is usually less
  *     than requested, and can be nonzero.
  * (3) cancellation, a type of error with status -ECONNRESET that
  *     is initiated by usb_sg_cancel().
  *
  * When this function returns, all memory allocated through usb_sg_init() or
  * this call will have been freed.  The request block parameter may still be
  * passed to usb_sg_cancel(), or it may be freed.  It could also be
  * reinitialized and then reused.
  *
  * Data Transfer Rates:
  *
  * Bulk transfers are valid for full or high speed endpoints.
  * The best full speed data rate is 19 packets of 64 bytes each
  * per frame, or 1216 bytes per millisecond.
  * The best high speed data rate is 13 packets of 512 bytes each
  * per microframe, or 52 KBytes per millisecond.
  *
  * The reason to use interrupt transfers through this API would most likely
  * be to reserve high speed bandwidth, where up to 24 KBytes per millisecond
  * could be transferred.  That capability is less useful for low or full
  * speed interrupt endpoints, which allow at most one packet per millisecond,
  * of at most 8 or 64 bytes (respectively).
  */
 void usb_sg_wait (struct usb_sg_request *io)
 {
 	int		i, entries = io->entries;
 	/* queue the urbs.  */
 	spin_lock_irq (&io->lock);
 	for (i = 0; i < entries && !io->status; i++) {
 		int	retval;
 		io->urbs [i]->dev = io->dev;
 		retval = usb_submit_urb (io->urbs [i], SLAB_ATOMIC);
 		/* after we submit, let completions or cancelations fire;
 		 * we handshake using io->status.
 		 */
 		spin_unlock_irq (&io->lock);
 		switch (retval) {
 			/* maybe we retrying will recover */
 		case -ENXIO:	// hc didn't queue this one
 		case -EAGAIN:
 		case -ENOMEM:
 			io->urbs[i]->dev = NULL;
 			retval = 0;
 			i--;
 			yield ();
 			break;
 			/* no error? continue immediately.
 			 *
 			 * NOTE: to work better with UHCI (4K I/O buffer may
 			 * need 3K of TDs) it may be good to limit how many
 			 * URBs are queued at once; N milliseconds?
 			 */
 		case 0:
 			cpu_relax ();
 			break;
 			/* fail any uncompleted urbs */
 		default:
 			io->urbs [i]->dev = NULL;
 			io->urbs [i]->status = retval;
 			dev_dbg (&io->dev->dev, "%s, submit --> %d\n",
 				__FUNCTION__, retval);
 			usb_sg_cancel (io);
 		}
 		spin_lock_irq (&io->lock);
 		if (retval && (io->status == 0 || io->status == -ECONNRESET))
 			io->status = retval;
 	}
 	io->count -= entries - i;
 	if (io->count == 0)
 		complete (&io->complete);
 	spin_unlock_irq (&io->lock);
 	/* OK, yes, this could be packaged as non-blocking.
 	 * So could the submit loop above ... but it's easier to
 	 * solve neither problem than to solve both!
 	 */
 	wait_for_completion (&io->complete);
 	sg_clean (io);
 }
 /**
  * usb_sg_cancel - stop scatter/gather i/o issued by usb_sg_wait()
  * @io: request block, initialized with usb_sg_init()
  *
  * This stops a request after it has been started by usb_sg_wait().
  * It can also prevents one initialized by usb_sg_init() from starting,
  * so that call just frees resources allocated to the request.
  */
 void usb_sg_cancel (struct usb_sg_request *io)
 {
 	unsigned long	flags;
 	spin_lock_irqsave (&io->lock, flags);
 	/* shut everything down, if it didn't already */
 	if (!io->status) {
 		int	i;
 		io->status = -ECONNRESET;
 		spin_unlock (&io->lock);
 		for (i = 0; i < io->entries; i++) {
 			int	retval;
 			if (!io->urbs [i]->dev)
 				continue;
 			retval = usb_unlink_urb (io->urbs [i]);
 			if (retval != -EINPROGRESS && retval != -EBUSY)
 				dev_warn (&io->dev->dev, "%s, unlink --> %d\n",
 					__FUNCTION__, retval);
 		}
 		spin_lock (&io->lock);
 	}
 	spin_unlock_irqrestore (&io->lock, flags);
 }
 /*-------------------------------------------------------------------*/
 /**
  * usb_get_descriptor - issues a generic GET_DESCRIPTOR request
  * @dev: the device whose descriptor is being retrieved
  * @type: the descriptor type (USB_DT_*)
  * @index: the number of the descriptor
  * @buf: where to put the descriptor
  * @size: how big is "buf"?
  * Context: !in_interrupt ()
  *
  * Gets a USB descriptor.  Convenience functions exist to simplify
  * getting some types of descriptors.  Use
  * usb_get_string() or usb_string() for USB_DT_STRING.
  * Device (USB_DT_DEVICE) and configuration descriptors (USB_DT_CONFIG)
  * are part of the device structure.
  * In addition to a number of USB-standard descriptors, some
  * devices also use class-specific or vendor-specific descriptors.
  *
  * This call is synchronous, and may not be used in an interrupt context.
  *
  * Returns the number of bytes received on success, or else the status code
  * returned by the underlying usb_control_msg() call.
  */
 int usb_get_descriptor(struct usb_device *dev, unsigned char type, unsigned char index, void *buf, int size)
 {
 	int i;
 	int result;
 	memset(buf,0,size);	// Make sure we parse really received data
 	for (i = 0; i < 3; ++i) {
 		/* retry on length 0 or stall; some devices are flakey */
 		result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
 				USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
 				(type << 8) + index, 0, buf, size,
 				USB_CTRL_GET_TIMEOUT);
 		if (result == 0 || result == -EPIPE)
 			continue;
 		if (result > 1 && ((u8 *)buf)[1] != type) {
 			result = -EPROTO;
 			continue;
 		}
 		break;
 	}
 	return result;
 }
 /**
  * usb_get_string - gets a string descriptor
  * @dev: the device whose string descriptor is being retrieved
  * @langid: code for language chosen (from string descriptor zero)
  * @index: the number of the descriptor
  * @buf: where to put the string
  * @size: how big is "buf"?
  * Context: !in_interrupt ()
  *
  * Retrieves a string, encoded using UTF-16LE (Unicode, 16 bits per character,
  * in little-endian byte order).
  * The usb_string() function will often be a convenient way to turn
  * these strings into kernel-printable form.
  *
  * Strings may be referenced in device, configuration, interface, or other
  * descriptors, and could also be used in vendor-specific ways.
  *
  * This call is synchronous, and may not be used in an interrupt context.
  *
  * Returns the number of bytes received on success, or else the status code
  * returned by the underlying usb_control_msg() call.
  */
 int usb_get_string(struct usb_device *dev, unsigned short langid,
 		unsigned char index, void *buf, int size)
 {
 	int i;
 	int result;
 	for (i = 0; i < 3; ++i) {
 		/* retry on length 0 or stall; some devices are flakey */
 		result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
 			USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
 			(USB_DT_STRING << 8) + index, langid, buf, size,
 			USB_CTRL_GET_TIMEOUT);
 		if (!(result == 0 || result == -EPIPE))
 			break;
 	}
 	return result;
 }
 static void usb_try_string_workarounds(unsigned char *buf, int *length)
 {
 	int newlength, oldlength = *length;
 	for (newlength = 2; newlength + 1 < oldlength; newlength += 2)
 		if (!isprint(buf[newlength]) || buf[newlength + 1])
 			break;
 	if (newlength > 2) {
 		buf[0] = newlength;
 		*length = newlength;
 	}
 }
 static int usb_string_sub(struct usb_device *dev, unsigned int langid,
 		unsigned int index, unsigned char *buf)
 {
 	int rc;
 	/* Try to read the string descriptor by asking for the maximum
 	 * possible number of bytes */
 	rc = usb_get_string(dev, langid, index, buf, 255);
 	/* If that failed try to read the descriptor length, then
 	 * ask for just that many bytes */
 	if (rc < 2) {
 		rc = usb_get_string(dev, langid, index, buf, 2);
 		if (rc == 2)
 			rc = usb_get_string(dev, langid, index, buf, buf[0]);
 	}
 	if (rc >= 2) {
 		if (!buf[0] && !buf[1])
 			usb_try_string_workarounds(buf, &rc);
 		/* There might be extra junk at the end of the descriptor */
 		if (buf[0] < rc)
 			rc = buf[0];
 		rc = rc - (rc & 1); /* force a multiple of two */
 	}
 	if (rc < 2)
 		rc = (rc < 0 ? rc : -EINVAL);
 	return rc;
 }
 /**
  * usb_string - returns ISO 8859-1 version of a string descriptor
  * @dev: the device whose string descriptor is being retrieved
  * @index: the number of the descriptor
  * @buf: where to put the string
  * @size: how big is "buf"?
  * Context: !in_interrupt ()
  *
  * This converts the UTF-16LE encoded strings returned by devices, from
  * usb_get_string_descriptor(), to null-terminated ISO-8859-1 encoded ones
  * that are more usable in most kernel contexts.  Note that all characters
  * in the chosen descriptor that can't be encoded using ISO-8859-1
  * are converted to the question mark ("?") character, and this function
  * chooses strings in the first language supported by the device.
  *
  * The ASCII (or, redundantly, "US-ASCII") character set is the seven-bit
  * subset of ISO 8859-1. ISO-8859-1 is the eight-bit subset of Unicode,
  * and is appropriate for use many uses of English and several other
  * Western European languages.  (But it doesn't include the "Euro" symbol.)
  *
  * This call is synchronous, and may not be used in an interrupt context.
  *
  * Returns length of the string (>= 0) or usb_control_msg status (< 0).
  */
 int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
 {
 	unsigned char *tbuf;
 	int err;
 	unsigned int u, idx;
 	if (dev->state == USB_STATE_SUSPENDED)
 		return -EHOSTUNREACH;
 	if (size <= 0 || !buf || !index)
 		return -EINVAL;
 	buf[0] = 0;
 	tbuf = kmalloc(256, GFP_KERNEL);
 	if (!tbuf)
 		return -ENOMEM;
 	/* get langid for strings if it's not yet known */
 	if (!dev->have_langid) {
 		err = usb_string_sub(dev, 0, 0, tbuf);
 		if (err < 0) {
 			dev_err (&dev->dev,
 				"string descriptor 0 read error: %d\n",
 				err);
 			goto errout;
 		} else if (err < 4) {
 			dev_err (&dev->dev, "string descriptor 0 too short\n");
 			err = -EINVAL;
 			goto errout;
 		} else {
 			dev->have_langid = -1;
 			dev->string_langid = tbuf[2] | (tbuf[3]<< 8);
 				/* always use the first langid listed */
 			dev_dbg (&dev->dev, "default language 0x%04x\n",
 				dev->string_langid);
 		}
 	}
 	err = usb_string_sub(dev, dev->string_langid, index, tbuf);
 	if (err < 0)
 		goto errout;
 	size--;		/* leave room for trailing NULL char in output buffer */
 	for (idx = 0, u = 2; u < err; u += 2) {
 		if (idx >= size)
 			break;
 		if (tbuf[u+1])			/* high byte */
 			buf[idx++] = '?';  /* non ISO-8859-1 character */
 		else
 			buf[idx++] = tbuf[u];
 	}
 	buf[idx] = 0;
 	err = idx;
 	if (tbuf[1] != USB_DT_STRING)
 		dev_dbg(&dev->dev, "wrong descriptor type %02x for string %d (\"%s\")\n", tbuf[1], index, buf);
  errout:
 	kfree(tbuf);
 	return err;
 }
 /**
  * usb_cache_string - read a string descriptor and cache it for later use
  * @udev: the device whose string descriptor is being read
  * @index: the descriptor index
  *
  * Returns a pointer to a kmalloc'ed buffer containing the descriptor string,
  * or NULL if the index is 0 or the string could not be read.
  */
 char *usb_cache_string(struct usb_device *udev, int index)
 {
 	char *buf;
 	char *smallbuf = NULL;
 	int len;
 	if (index > 0 && (buf = kmalloc(256, GFP_KERNEL)) != NULL) {
 		if ((len = usb_string(udev, index, buf, 256)) > 0) {
 			if ((smallbuf = kmalloc(++len, GFP_KERNEL)) == NULL)
 				return buf;
 			memcpy(smallbuf, buf, len);
 		}
 		kfree(buf);
 	}
 	return smallbuf;
 }
 /*
  * usb_get_device_descriptor - (re)reads the device descriptor (usbcore)
  * @dev: the device whose device descriptor is being updated
  * @size: how much of the descriptor to read
  * Context: !in_interrupt ()
  *
  * Updates the copy of the device descriptor stored in the device structure,
  * which dedicates space for this purpose.  Note that several fields are
  * converted to the host CPU's byte order:  the USB version (bcdUSB), and
  * vendors product and version fields (idVendor, idProduct, and bcdDevice).
  * That lets device drivers compare against non-byteswapped constants.
  *
  * Not exported, only for use by the core.  If drivers really want to read
  * the device descriptor directly, they can call usb_get_descriptor() with
  * type = USB_DT_DEVICE and index = 0.
  *
  * This call is synchronous, and may not be used in an interrupt context.
  *
  * Returns the number of bytes received on success, or else the status code
  * returned by the underlying usb_control_msg() call.
  */
 int usb_get_device_descriptor(struct usb_device *dev, unsigned int size)
 {
 	struct usb_device_descriptor *desc;
 	int ret;
 	if (size > sizeof(*desc))
 		return -EINVAL;
 	desc = kmalloc(sizeof(*desc), GFP_NOIO);
 	if (!desc)
 		return -ENOMEM;
 	ret = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, size);
 	if (ret >= 0)
 		memcpy(&dev->descriptor, desc, size);
 	kfree(desc);
 	return ret;
 }
 /**
  * usb_get_status - issues a GET_STATUS call
  * @dev: the device whose status is being checked
  * @type: USB_RECIP_*; for device, interface, or endpoint
  * @target: zero (for device), else interface or endpoint number
  * @data: pointer to two bytes of bitmap data
  * Context: !in_interrupt ()
  *
  * Returns device, interface, or endpoint status.  Normally only of
  * interest to see if the device is self powered, or has enabled the
  * remote wakeup facility; or whether a bulk or interrupt endpoint
  * is halted ("stalled").
  *
  * Bits in these status bitmaps are set using the SET_FEATURE request,
  * and cleared using the CLEAR_FEATURE request.  The usb_clear_halt()
  * function should be used to clear halt ("stall") status.
  *
  * This call is synchronous, and may not be used in an interrupt context.
  *
  * Returns the number of bytes received on success, or else the status code
  * returned by the underlying usb_control_msg() call.
  */
 int usb_get_status(struct usb_device *dev, int type, int target, void *data)
 {
 	int ret;
 	u16 *status = kmalloc(sizeof(*status), GFP_KERNEL);
 	if (!status)
 		return -ENOMEM;
 	ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
 		USB_REQ_GET_STATUS, USB_DIR_IN | type, 0, target, status,
 		sizeof(*status), USB_CTRL_GET_TIMEOUT);
 	*(u16 *)data = *status;
 	kfree(status);
 	return ret;
 }
 /**
  * usb_clear_halt - tells device to clear endpoint halt/stall condition
  * @dev: device whose endpoint is halted
  * @pipe: endpoint "pipe" being cleared
  * Context: !in_interrupt ()
  *
  * This is used to clear halt conditions for bulk and interrupt endpoints,
  * as reported by URB completion status.  Endpoints that are halted are
  * sometimes referred to as being "stalled".  Such endpoints are unable
  * to transmit or receive data until the halt status is cleared.  Any URBs
  * queued for such an endpoint should normally be unlinked by the driver
  * before clearing the halt condition, as described in sections 5.7.5
  * and 5.8.5 of the USB 2.0 spec.
  *
  * Note that control and isochronous endpoints don't halt, although control
  * endpoints report "protocol stall" (for unsupported requests) using the
  * same status code used to report a true stall.
  *
  * This call is synchronous, and may not be used in an interrupt context.
  *
  * Returns zero on success, or else the status code returned by the
  * underlying usb_control_msg() call.
  */
 int usb_clear_halt(struct usb_device *dev, int pipe)
 {
 	int result;
 	int endp = usb_pipeendpoint(pipe);
 	if (usb_pipein (pipe))
 		endp |= USB_DIR_IN;
 	/* we don't care if it wasn't halted first. in fact some devices
 	 * (like some ibmcam model 1 units) seem to expect hosts to make
 	 * this request for iso endpoints, which can't halt!
 	 */
 	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 		USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT,
 		USB_ENDPOINT_HALT, endp, NULL, 0,
 		USB_CTRL_SET_TIMEOUT);
 	/* don't un-halt or force to DATA0 except on success */
 	if (result < 0)
 		return result;
 	/* NOTE:  seems like Microsoft and Apple don't bother verifying
 	 * the clear "took", so some devices could lock up if you check...
 	 * such as the Hagiwara FlashGate DUAL.  So we won't bother.
 	 *
 	 * NOTE:  make sure the logic here doesn't diverge much from
 	 * the copy in usb-storage, for as long as we need two copies.
 	 */
 	/* toggle was reset by the clear */
 	usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0);
 	return 0;
 }
 /**
  * usb_disable_endpoint -- Disable an endpoint by address
  * @dev: the device whose endpoint is being disabled
  * @epaddr: the endpoint's address.  Endpoint number for output,
  *	endpoint number + USB_DIR_IN for input
  *
  * Deallocates hcd/hardware state for this endpoint ... and nukes all
  * pending urbs.
  *
  * If the HCD hasn't registered a disable() function, this sets the
  * endpoint's maxpacket size to 0 to prevent further submissions.
  */
 void usb_disable_endpoint(struct usb_device *dev, unsigned int epaddr)
 {
 	unsigned int epnum = epaddr & USB_ENDPOINT_NUMBER_MASK;
 	struct usb_host_endpoint *ep;
 	if (!dev)
 		return;
 	if (usb_endpoint_out(epaddr)) {
 		ep = dev->ep_out[epnum];
 		dev->ep_out[epnum] = NULL;
 	} else {
 		ep = dev->ep_in[epnum];
 		dev->ep_in[epnum] = NULL;
 	}
 	if (ep && dev->bus && dev->bus->op && dev->bus->op->disable)
 		dev->bus->op->disable(dev, ep);
 }
 /**
  * usb_disable_interface -- Disable all endpoints for an interface
  * @dev: the device whose interface is being disabled
  * @intf: pointer to the interface descriptor
  *
  * Disables all the endpoints for the interface's current altsetting.
  */
 void usb_disable_interface(struct usb_device *dev, struct usb_interface *intf)
 {
 	struct usb_host_interface *alt = intf->cur_altsetting;
 	int i;
 	for (i = 0; i < alt->desc.bNumEndpoints; ++i) {
 		usb_disable_endpoint(dev,
 				alt->endpoint[i].desc.bEndpointAddress);
 	}
 }
 /*
  * usb_disable_device - Disable all the endpoints for a USB device
  * @dev: the device whose endpoints are being disabled
  * @skip_ep0: 0 to disable endpoint 0, 1 to skip it.
  *
  * Disables all the device's endpoints, potentially including endpoint 0.
  * Deallocates hcd/hardware state for the endpoints (nuking all or most
  * pending urbs) and usbcore state for the interfaces, so that usbcore
  * must usb_set_configuration() before any interfaces could be used.
  */
 void usb_disable_device(struct usb_device *dev, int skip_ep0)
 {
 	int i;
 	dev_dbg(&dev->dev, "%s nuking %s URBs\n", __FUNCTION__,
 			skip_ep0 ? "non-ep0" : "all");
 	for (i = skip_ep0; i < 16; ++i) {
 		usb_disable_endpoint(dev, i);
 		usb_disable_endpoint(dev, i + USB_DIR_IN);
 	}
 	dev->toggle[0] = dev->toggle[1] = 0;
 	/* getting rid of interfaces will disconnect
 	 * any drivers bound to them (a key side effect)
 	 */
 	if (dev->actconfig) {
 		for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
 			struct usb_interface	*interface;
 			/* remove this interface if it has been registered */
 			interface = dev->actconfig->interface[i];
 			if (!device_is_registered(&interface->dev))
 				continue;
 			dev_dbg (&dev->dev, "unregistering interface %s\n",
 				interface->dev.bus_id);
 			usb_remove_sysfs_intf_files(interface);
 			device_del (&interface->dev);
 		}
 		/* Now that the interfaces are unbound, nobody should
 		 * try to access them.
 		 */
 		for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
 			put_device (&dev->actconfig->interface[i]->dev);
 			dev->actconfig->interface[i] = NULL;
 		}
 		dev->actconfig = NULL;
 		if (dev->state == USB_STATE_CONFIGURED)
 			usb_set_device_state(dev, USB_STATE_ADDRESS);
 	}
 }
 /*
  * usb_enable_endpoint - Enable an endpoint for USB communications
  * @dev: the device whose interface is being enabled
  * @ep: the endpoint
  *
  * Resets the endpoint toggle, and sets dev->ep_{in,out} pointers.
  * For control endpoints, both the input and output sides are handled.
  */
 static void
 usb_enable_endpoint(struct usb_device *dev, struct usb_host_endpoint *ep)
 {
 	unsigned int epaddr = ep->desc.bEndpointAddress;
 	unsigned int epnum = epaddr & USB_ENDPOINT_NUMBER_MASK;
 	int is_control;
 	is_control = ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
 			== USB_ENDPOINT_XFER_CONTROL);
 	if (usb_endpoint_out(epaddr) || is_control) {
 		usb_settoggle(dev, epnum, 1, 0);
 		dev->ep_out[epnum] = ep;
 	}
 	if (!usb_endpoint_out(epaddr) || is_control) {
 		usb_settoggle(dev, epnum, 0, 0);
 		dev->ep_in[epnum] = ep;
 	}
 }
 /*
  * usb_enable_interface - Enable all the endpoints for an interface
  * @dev: the device whose interface is being enabled
  * @intf: pointer to the interface descriptor
  *
  * Enables all the endpoints for the interface's current altsetting.
  */
 static void usb_enable_interface(struct usb_device *dev,
 				 struct usb_interface *intf)
 {
 	struct usb_host_interface *alt = intf->cur_altsetting;
 	int i;
 	for (i = 0; i < alt->desc.bNumEndpoints; ++i)
 		usb_enable_endpoint(dev, &alt->endpoint[i]);
 }
 /**
  * usb_set_interface - Makes a particular alternate setting be current
  * @dev: the device whose interface is being updated
  * @interface: the interface being updated
  * @alternate: the setting being chosen.
  * Context: !in_interrupt ()
  *
  * This is used to enable data transfers on interfaces that may not
  * be enabled by default.  Not all devices support such configurability.
  * Only the driver bound to an interface may change its setting.
  *
  * Within any given configuration, each interface may have several
  * alternative settings.  These are often used to control levels of
  * bandwidth consumption.  For example, the default setting for a high
  * speed interrupt endpoint may not send more than 64 bytes per microframe,
  * while interrupt transfers of up to 3KBytes per microframe are legal.
  * Also, isochronous endpoints may never be part of an
  * interface's default setting.  To access such bandwidth, alternate
  * interface settings must be made current.
  *
  * Note that in the Linux USB subsystem, bandwidth associated with
  * an endpoint in a given alternate setting is not reserved until an URB
  * is submitted that needs that bandwidth.  Some other operating systems
  * allocate bandwidth early, when a configuration is chosen.
  *
  * This call is synchronous, and may not be used in an interrupt context.
  * Also, drivers must not change altsettings while urbs are scheduled for
  * endpoints in that interface; all such urbs must first be completed
  * (perhaps forced by unlinking).
  *
  * Returns zero on success, or else the status code returned by the
  * underlying usb_control_msg() call.
  */
 int usb_set_interface(struct usb_device *dev, int interface, int alternate)
 {
 	struct usb_interface *iface;
 	struct usb_host_interface *alt;
 	int ret;
 	int manual = 0;
 	if (dev->state == USB_STATE_SUSPENDED)
 		return -EHOSTUNREACH;
 	iface = usb_ifnum_to_if(dev, interface);
 	if (!iface) {
 		dev_dbg(&dev->dev, "selecting invalid interface %d\n",
 			interface);
 		return -EINVAL;
 	}
 	alt = usb_altnum_to_altsetting(iface, alternate);
 	if (!alt) {
 		warn("selecting invalid altsetting %d", alternate);
 		return -EINVAL;
 	}
 	ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 				   USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
 				   alternate, interface, NULL, 0, 5000);
 	/* 9.4.10 says devices don't need this and are free to STALL the
 	 * request if the interface only has one alternate setting.
 	 */
 	if (ret == -EPIPE && iface->num_altsetting == 1) {
 		dev_dbg(&dev->dev,
 			"manual set_interface for iface %d, alt %d\n",
 			interface, alternate);
 		manual = 1;
 	} else if (ret < 0)
 		return ret;
 	/* FIXME drivers shouldn't need to replicate/bugfix the logic here
 	 * when they implement async or easily-killable versions of this or
 	 * other "should-be-internal" functions (like clear_halt).
 	 * should hcd+usbcore postprocess control requests?
 	 */
 	/* prevent submissions using previous endpoint settings */
 	if (device_is_registered(&iface->dev))
 		usb_remove_sysfs_intf_files(iface);
 	usb_disable_interface(dev, iface);
 	iface->cur_altsetting = alt;
 	/* If the interface only has one altsetting and the device didn't
 	 * accept the request, we attempt to carry out the equivalent action
 	 * by manually clearing the HALT feature for each endpoint in the
 	 * new altsetting.
 	 */
 	if (manual) {
 		int i;
 		for (i = 0; i < alt->desc.bNumEndpoints; i++) {
 			unsigned int epaddr =
 				alt->endpoint[i].desc.bEndpointAddress;
 			unsigned int pipe =
 	__create_pipe(dev, USB_ENDPOINT_NUMBER_MASK & epaddr)
 	| (usb_endpoint_out(epaddr) ? USB_DIR_OUT : USB_DIR_IN);
 			usb_clear_halt(dev, pipe);
 		}
 	}
 	/* 9.1.1.5: reset toggles for all endpoints in the new altsetting
 	 *
 	 * Note:
 	 * Despite EP0 is always present in all interfaces/AS, the list of
 	 * endpoints from the descriptor does not contain EP0. Due to its
 	 * omnipresence one might expect EP0 being considered "affected" by
 	 * any SetInterface request and hence assume toggles need to be reset.
 	 * However, EP0 toggles are re-synced for every individual transfer
 	 * during the SETUP stage - hence EP0 toggles are "don't care" here.
 	 * (Likewise, EP0 never "halts" on well designed devices.)
 	 */
 	usb_enable_interface(dev, iface);
 	if (device_is_registered(&iface->dev))
 		usb_create_sysfs_intf_files(iface);
 	return 0;
 }
 /**
  * usb_reset_configuration - lightweight device reset
  * @dev: the device whose configuration is being reset
  *
  * This issues a standard SET_CONFIGURATION request to the device using
  * the current configuration.  The effect is to reset most USB-related
  * state in the device, including interface altsettings (reset to zero),
  * endpoint halts (cleared), and data toggle (only for bulk and interrupt
  * endpoints).  Other usbcore state is unchanged, including bindings of
  * usb device drivers to interfaces.
  *
  * Because this affects multiple interfaces, avoid using this with composite
  * (multi-interface) devices.  Instead, the driver for each interface may
  * use usb_set_interface() on the interfaces it claims.  Be careful though;
  * some devices don't support the SET_INTERFACE request, and others won't
  * reset all the interface state (notably data toggles).  Resetting the whole
  * configuration would affect other drivers' interfaces.
  *
  * The caller must own the device lock.
  *
  * Returns zero on success, else a negative error code.
  */
 int usb_reset_configuration(struct usb_device *dev)
 {
 	int			i, retval;
 	struct usb_host_config	*config;
 	if (dev->state == USB_STATE_SUSPENDED)
 		return -EHOSTUNREACH;
 	/* caller must have locked the device and must own
 	 * the usb bus readlock (so driver bindings are stable);
 	 * calls during probe() are fine
 	 */
 	for (i = 1; i < 16; ++i) {
 		usb_disable_endpoint(dev, i);
 		usb_disable_endpoint(dev, i + USB_DIR_IN);
 	}
 	config = dev->actconfig;
 	retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 			USB_REQ_SET_CONFIGURATION, 0,
 			config->desc.bConfigurationValue, 0,
 			NULL, 0, USB_CTRL_SET_TIMEOUT);
 	if (retval < 0)
 		return retval;
 	dev->toggle[0] = dev->toggle[1] = 0;
 	/* re-init hc/hcd interface/endpoint state */
 	for (i = 0; i < config->desc.bNumInterfaces; i++) {
 		struct usb_interface *intf = config->interface[i];
 		struct usb_host_interface *alt;
 		if (device_is_registered(&intf->dev))
 			usb_remove_sysfs_intf_files(intf);
 		alt = usb_altnum_to_altsetting(intf, 0);
 		/* No altsetting 0?  We'll assume the first altsetting.
 		 * We could use a GetInterface call, but if a device is
 		 * so non-compliant that it doesn't have altsetting 0
 		 * then I wouldn't trust its reply anyway.
 		 */
 		if (!alt)
 			alt = &intf->altsetting[0];
 		intf->cur_altsetting = alt;
 		usb_enable_interface(dev, intf);
 		if (device_is_registered(&intf->dev))
 			usb_create_sysfs_intf_files(intf);
 	}
 	return 0;
 }
 static void release_interface(struct device *dev)
 {
 	struct usb_interface *intf = to_usb_interface(dev);
 	struct usb_interface_cache *intfc =
 			altsetting_to_usb_interface_cache(intf->altsetting);
 	kref_put(&intfc->ref, usb_release_interface_cache);
 	kfree(intf);
 }
 /*
  * usb_set_configuration - Makes a particular device setting be current
  * @dev: the device whose configuration is being updated
  * @configuration: the configuration being chosen.
  * Context: !in_interrupt(), caller owns the device lock
  *
  * This is used to enable non-default device modes.  Not all devices
  * use this kind of configurability; many devices only have one
  * configuration.
  *
  * USB device configurations may affect Linux interoperability,
  * power consumption and the functionality available.  For example,
  * the default configuration is limited to using 100mA of bus power,
  * so that when certain device functionality requires more power,
  * and the device is bus powered, that functionality should be in some
  * non-default device configuration.  Other device modes may also be
  * reflected as configuration options, such as whether two ISDN
  * channels are available independently; and choosing between open
  * standard device protocols (like CDC) or proprietary ones.
  *
  * Note that USB has an additional level of device configurability,
  * associated with interfaces.  That configurability is accessed using
  * usb_set_interface().
  *
  * This call is synchronous. The calling context must be able to sleep,
  * must own the device lock, and must not hold the driver model's USB
  * bus rwsem; usb device driver probe() methods cannot use this routine.
  *
  * Returns zero on success, or else the status code returned by the
  * underlying call that failed.  On successful completion, each interface
  * in the original device configuration has been destroyed, and each one
  * in the new configuration has been probed by all relevant usb device
  * drivers currently known to the kernel.
  */
 int usb_set_configuration(struct usb_device *dev, int configuration)
 {
 	int i, ret;
 	struct usb_host_config *cp = NULL;
 	struct usb_interface **new_interfaces = NULL;
 	int n, nintf;
 	for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
 		if (dev->config[i].desc.bConfigurationValue == configuration) {
 			cp = &dev->config[i];
 			break;
 		}
 	}
 	if ((!cp && configuration != 0))
 		return -EINVAL;
 	/* The USB spec says configuration 0 means unconfigured.
 	 * But if a device includes a configuration numbered 0,
 	 * we will accept it as a correctly configured state.
 	 */
 	if (cp && configuration == 0)
 		dev_warn(&dev->dev, "config 0 descriptor??\n");
 	if (dev->state == USB_STATE_SUSPENDED)
 		return -EHOSTUNREACH;
 	/* Allocate memory for new interfaces before doing anything else,
 	 * so that if we run out then nothing will have changed. */
 	n = nintf = 0;
 	if (cp) {
 		nintf = cp->desc.bNumInterfaces;
 		new_interfaces = kmalloc(nintf * sizeof(*new_interfaces),
 				GFP_KERNEL);
 		if (!new_interfaces) {
 			dev_err(&dev->dev, "Out of memory");
 			return -ENOMEM;
 		}
 		for (; n < nintf; ++n) {
 			new_interfaces[n] = kzalloc(
 					sizeof(struct usb_interface),
 					GFP_KERNEL);
 			if (!new_interfaces[n]) {
 				dev_err(&dev->dev, "Out of memory");
 				ret = -ENOMEM;
 free_interfaces:
 				while (--n >= 0)
 					kfree(new_interfaces[n]);
 				kfree(new_interfaces);
 				return ret;
 			}
 		}
 	}
 	/* if it's already configured, clear out old state first.
 	 * getting rid of old interfaces means unbinding their drivers.
 	 */
 	if (dev->state != USB_STATE_ADDRESS)
 		usb_disable_device (dev, 1);	// Skip ep0
+	n = dev->bus_mA - cp->desc.bMaxPower * 2;
+	if (n < 0)
+		dev_warn(&dev->dev, "new config #%d exceeds power "
+				"limit by %dmA\n",
+				configuration, -n);
 	if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 			USB_REQ_SET_CONFIGURATION, 0, configuration, 0,
 			NULL, 0, USB_CTRL_SET_TIMEOUT)) < 0)
 		goto free_interfaces;
 	dev->actconfig = cp;
 	if (!cp)
 		usb_set_device_state(dev, USB_STATE_ADDRESS);
 	else {
 		usb_set_device_state(dev, USB_STATE_CONFIGURED);
 		/* Initialize the new interface structures and the
 		 * hc/hcd/usbcore interface/endpoint state.
 		 */
 		for (i = 0; i < nintf; ++i) {
 			struct usb_interface_cache *intfc;
 			struct usb_interface *intf;
 			struct usb_host_interface *alt;
 			cp->interface[i] = intf = new_interfaces[i];
 			intfc = cp->intf_cache[i];
 			intf->altsetting = intfc->altsetting;
 			intf->num_altsetting = intfc->num_altsetting;
 			kref_get(&intfc->ref);
 			alt = usb_altnum_to_altsetting(intf, 0);
 			/* No altsetting 0?  We'll assume the first altsetting.
 			 * We could use a GetInterface call, but if a device is
 			 * so non-compliant that it doesn't have altsetting 0
 			 * then I wouldn't trust its reply anyway.
 			 */
 			if (!alt)
 				alt = &intf->altsetting[0];
 			intf->cur_altsetting = alt;
 			usb_enable_interface(dev, intf);
 			intf->dev.parent = &dev->dev;
 			intf->dev.driver = NULL;
 			intf->dev.bus = &usb_bus_type;
 			intf->dev.dma_mask = dev->dev.dma_mask;
 			intf->dev.release = release_interface;
 			device_initialize (&intf->dev);
 			mark_quiesced(intf);
 			sprintf (&intf->dev.bus_id[0], "%d-%s:%d.%d",
 				 dev->bus->busnum, dev->devpath,
 				 configuration,
 				 alt->desc.bInterfaceNumber);
 		}
 		kfree(new_interfaces);
 		if (cp->string == NULL)
 			cp->string = usb_cache_string(dev,
 					cp->desc.iConfiguration);
 		/* Now that all the interfaces are set up, register them
 		 * to trigger binding of drivers to interfaces.  probe()
 		 * routines may install different altsettings and may
 		 * claim() any interfaces not yet bound.  Many class drivers
 		 * need that: CDC, audio, video, etc.
 		 */
 		for (i = 0; i < nintf; ++i) {
 			struct usb_interface *intf = cp->interface[i];
 			dev_dbg (&dev->dev,
 				"adding %s (config #%d, interface %d)\n",
 				intf->dev.bus_id, configuration,
 				intf->cur_altsetting->desc.bInterfaceNumber);
 			ret = device_add (&intf->dev);
 			if (ret != 0) {
 				dev_err(&dev->dev,
 					"device_add(%s) --> %d\n",
 					intf->dev.bus_id,
 					ret);
 				continue;
 			}
 			usb_create_sysfs_intf_files (intf);
 		}
 	}
 	return 0;
 }
 // synchronous request completion model
 EXPORT_SYMBOL(usb_control_msg);
 EXPORT_SYMBOL(usb_bulk_msg);
 EXPORT_SYMBOL(usb_sg_init);
 EXPORT_SYMBOL(usb_sg_cancel);
 EXPORT_SYMBOL(usb_sg_wait);
 // synchronous control message convenience routines
 EXPORT_SYMBOL(usb_get_descriptor);
 EXPORT_SYMBOL(usb_get_status);
 EXPORT_SYMBOL(usb_get_string);
 EXPORT_SYMBOL(usb_string);
 // synchronous calls that also maintain usbcore state
 EXPORT_SYMBOL(usb_clear_halt);
 EXPORT_SYMBOL(usb_reset_configuration);
 EXPORT_SYMBOL(usb_set_interface);

include/linux/usb.h

Diff comments View file @ 55c5271

 #ifndef __LINUX_USB_H
 #define __LINUX_USB_H
 #include <linux/mod_devicetable.h>
 #include <linux/usb_ch9.h>
 #define USB_MAJOR			180
 #define USB_DEVICE_MAJOR		189
 #ifdef __KERNEL__
 #include <linux/config.h>
 #include <linux/errno.h>        /* for -ENODEV */
 #include <linux/delay.h>	/* for mdelay() */
 #include <linux/interrupt.h>	/* for in_interrupt() */
 #include <linux/list.h>		/* for struct list_head */
 #include <linux/kref.h>		/* for struct kref */
 #include <linux/device.h>	/* for struct device */
 #include <linux/fs.h>		/* for struct file_operations */
 #include <linux/completion.h>	/* for struct completion */
 #include <linux/sched.h>	/* for current && schedule_timeout */
 struct usb_device;
 struct usb_driver;
 /*-------------------------------------------------------------------------*/
 /*
  * Host-side wrappers for standard USB descriptors ... these are parsed
  * from the data provided by devices.  Parsing turns them from a flat
  * sequence of descriptors into a hierarchy:
  *
  *  - devices have one (usually) or more configs;
  *  - configs have one (often) or more interfaces;
  *  - interfaces have one (usually) or more settings;
  *  - each interface setting has zero or (usually) more endpoints.
  *
  * And there might be other descriptors mixed in with those.
  *
  * Devices may also have class-specific or vendor-specific descriptors.
  */
 /**
  * struct usb_host_endpoint - host-side endpoint descriptor and queue
  * @desc: descriptor for this endpoint, wMaxPacketSize in native byteorder
  * @urb_list: urbs queued to this endpoint; maintained by usbcore
  * @hcpriv: for use by HCD; typically holds hardware dma queue head (QH)
  *	with one or more transfer descriptors (TDs) per urb
  * @kobj: kobject for sysfs info
  * @extra: descriptors following this endpoint in the configuration
  * @extralen: how many bytes of "extra" are valid
  *
  * USB requests are always queued to a given endpoint, identified by a
  * descriptor within an active interface in a given USB configuration.
  */
 struct usb_host_endpoint {
 	struct usb_endpoint_descriptor	desc;
 	struct list_head		urb_list;
 	void				*hcpriv;
 	struct kobject			*kobj;	/* For sysfs info */
 	unsigned char *extra;   /* Extra descriptors */
 	int extralen;
 };
 /* host-side wrapper for one interface setting's parsed descriptors */
 struct usb_host_interface {
 	struct usb_interface_descriptor	desc;
 	/* array of desc.bNumEndpoint endpoints associated with this
 	 * interface setting.  these will be in no particular order.
 	 */
 	struct usb_host_endpoint *endpoint;
 	char *string;		/* iInterface string, if present */
 	unsigned char *extra;   /* Extra descriptors */
 	int extralen;
 };
 enum usb_interface_condition {
 	USB_INTERFACE_UNBOUND = 0,
 	USB_INTERFACE_BINDING,
 	USB_INTERFACE_BOUND,
 	USB_INTERFACE_UNBINDING,
 };
 /**
  * struct usb_interface - what usb device drivers talk to
  * @altsetting: array of interface structures, one for each alternate
  * 	setting that may be selected.  Each one includes a set of
  * 	endpoint configurations.  They will be in no particular order.
  * @num_altsetting: number of altsettings defined.
  * @cur_altsetting: the current altsetting.
  * @driver: the USB driver that is bound to this interface.
  * @minor: the minor number assigned to this interface, if this
  *	interface is bound to a driver that uses the USB major number.
  *	If this interface does not use the USB major, this field should
  *	be unused.  The driver should set this value in the probe()
  *	function of the driver, after it has been assigned a minor
  *	number from the USB core by calling usb_register_dev().
  * @condition: binding state of the interface: not bound, binding
  *	(in probe()), bound to a driver, or unbinding (in disconnect())
  * @dev: driver model's view of this device
  * @class_dev: driver model's class view of this device.
  *
  * USB device drivers attach to interfaces on a physical device.  Each
  * interface encapsulates a single high level function, such as feeding
  * an audio stream to a speaker or reporting a change in a volume control.
  * Many USB devices only have one interface.  The protocol used to talk to
  * an interface's endpoints can be defined in a usb "class" specification,
  * or by a product's vendor.  The (default) control endpoint is part of
  * every interface, but is never listed among the interface's descriptors.
  *
  * The driver that is bound to the interface can use standard driver model
  * calls such as dev_get_drvdata() on the dev member of this structure.
  *
  * Each interface may have alternate settings.  The initial configuration
  * of a device sets altsetting 0, but the device driver can change
  * that setting using usb_set_interface().  Alternate settings are often
  * used to control the the use of periodic endpoints, such as by having
  * different endpoints use different amounts of reserved USB bandwidth.
  * All standards-conformant USB devices that use isochronous endpoints
  * will use them in non-default settings.
  *
  * The USB specification says that alternate setting numbers must run from
  * 0 to one less than the total number of alternate settings.  But some
  * devices manage to mess this up, and the structures aren't necessarily
  * stored in numerical order anyhow.  Use usb_altnum_to_altsetting() to
  * look up an alternate setting in the altsetting array based on its number.
  */
 struct usb_interface {
 	/* array of alternate settings for this interface,
 	 * stored in no particular order */
 	struct usb_host_interface *altsetting;
 	struct usb_host_interface *cur_altsetting;	/* the currently
 					 * active alternate setting */
 	unsigned num_altsetting;	/* number of alternate settings */
 	int minor;			/* minor number this interface is
 					 * bound to */
 	enum usb_interface_condition condition;		/* state of binding */
 	struct device dev;		/* interface specific device info */
 	struct class_device *class_dev;
 };
 #define	to_usb_interface(d) container_of(d, struct usb_interface, dev)
 #define	interface_to_usbdev(intf) \
 	container_of(intf->dev.parent, struct usb_device, dev)
 static inline void *usb_get_intfdata (struct usb_interface *intf)
 {
 	return dev_get_drvdata (&intf->dev);
 }
 static inline void usb_set_intfdata (struct usb_interface *intf, void *data)
 {
 	dev_set_drvdata(&intf->dev, data);
 }
 struct usb_interface *usb_get_intf(struct usb_interface *intf);
 void usb_put_intf(struct usb_interface *intf);
 /* this maximum is arbitrary */
 #define USB_MAXINTERFACES	32
 /**
  * struct usb_interface_cache - long-term representation of a device interface
  * @num_altsetting: number of altsettings defined.
  * @ref: reference counter.
  * @altsetting: variable-length array of interface structures, one for
  *	each alternate setting that may be selected.  Each one includes a
  *	set of endpoint configurations.  They will be in no particular order.
  *
  * These structures persist for the lifetime of a usb_device, unlike
  * struct usb_interface (which persists only as long as its configuration
  * is installed).  The altsetting arrays can be accessed through these
  * structures at any time, permitting comparison of configurations and
  * providing support for the /proc/bus/usb/devices pseudo-file.
  */
 struct usb_interface_cache {
 	unsigned num_altsetting;	/* number of alternate settings */
 	struct kref ref;		/* reference counter */
 	/* variable-length array of alternate settings for this interface,
 	 * stored in no particular order */
 	struct usb_host_interface altsetting[0];
 };
 #define	ref_to_usb_interface_cache(r) \
 		container_of(r, struct usb_interface_cache, ref)
 #define	altsetting_to_usb_interface_cache(a) \
 		container_of(a, struct usb_interface_cache, altsetting[0])
 /**
  * struct usb_host_config - representation of a device's configuration
  * @desc: the device's configuration descriptor.
  * @string: pointer to the cached version of the iConfiguration string, if
  *	present for this configuration.
  * @interface: array of pointers to usb_interface structures, one for each
  *	interface in the configuration.  The number of interfaces is stored
  *	in desc.bNumInterfaces.  These pointers are valid only while the
  *	the configuration is active.
  * @intf_cache: array of pointers to usb_interface_cache structures, one
  *	for each interface in the configuration.  These structures exist
  *	for the entire life of the device.
  * @extra: pointer to buffer containing all extra descriptors associated
  *	with this configuration (those preceding the first interface
  *	descriptor).
  * @extralen: length of the extra descriptors buffer.
  *
  * USB devices may have multiple configurations, but only one can be active
  * at any time.  Each encapsulates a different operational environment;
  * for example, a dual-speed device would have separate configurations for
  * full-speed and high-speed operation.  The number of configurations
  * available is stored in the device descriptor as bNumConfigurations.
  *
  * A configuration can contain multiple interfaces.  Each corresponds to
  * a different function of the USB device, and all are available whenever
  * the configuration is active.  The USB standard says that interfaces
  * are supposed to be numbered from 0 to desc.bNumInterfaces-1, but a lot
  * of devices get this wrong.  In addition, the interface array is not
  * guaranteed to be sorted in numerical order.  Use usb_ifnum_to_if() to
  * look up an interface entry based on its number.
  *
  * Device drivers should not attempt to activate configurations.  The choice
  * of which configuration to install is a policy decision based on such
  * considerations as available power, functionality provided, and the user's
  * desires (expressed through hotplug scripts).  However, drivers can call
  * usb_reset_configuration() to reinitialize the current configuration and
  * all its interfaces.
  */
 struct usb_host_config {
 	struct usb_config_descriptor	desc;
 	char *string;		/* iConfiguration string, if present */
 	/* the interfaces associated with this configuration,
 	 * stored in no particular order */
 	struct usb_interface *interface[USB_MAXINTERFACES];
 	/* Interface information available even when this is not the
 	 * active configuration */
 	struct usb_interface_cache *intf_cache[USB_MAXINTERFACES];
 	unsigned char *extra;   /* Extra descriptors */
 	int extralen;
 };
 int __usb_get_extra_descriptor(char *buffer, unsigned size,
 	unsigned char type, void **ptr);
 #define usb_get_extra_descriptor(ifpoint,type,ptr)\
 	__usb_get_extra_descriptor((ifpoint)->extra,(ifpoint)->extralen,\
 		type,(void**)ptr)
 /* ----------------------------------------------------------------------- */
 struct usb_operations;
 /* USB device number allocation bitmap */
 struct usb_devmap {
 	unsigned long devicemap[128 / (8*sizeof(unsigned long))];
 };
 /*
  * Allocated per bus (tree of devices) we have:
  */
 struct usb_bus {
 	struct device *controller;	/* host/master side hardware */
 	int busnum;			/* Bus number (in order of reg) */
 	char *bus_name;			/* stable id (PCI slot_name etc) */
 	u8 otg_port;			/* 0, or number of OTG/HNP port */
 	unsigned is_b_host:1;		/* true during some HNP roleswitches */
 	unsigned b_hnp_enable:1;	/* OTG: did A-Host enable HNP? */
 	int devnum_next;		/* Next open device number in
 					 * round-robin allocation */
 	struct usb_devmap devmap;	/* device address allocation map */
 	struct usb_operations *op;	/* Operations (specific to the HC) */
 	struct usb_device *root_hub;	/* Root hub */
 	struct list_head bus_list;	/* list of busses */
 	void *hcpriv;                   /* Host Controller private data */
 	int bandwidth_allocated;	/* on this bus: how much of the time
 					 * reserved for periodic (intr/iso)
 					 * requests is used, on average?
 					 * Units: microseconds/frame.
 					 * Limits: Full/low speed reserve 90%,
 					 * while high speed reserves 80%.
 					 */
 	int bandwidth_int_reqs;		/* number of Interrupt requests */
 	int bandwidth_isoc_reqs;	/* number of Isoc. requests */
 	struct dentry *usbfs_dentry;	/* usbfs dentry entry for the bus */
 	struct class_device *class_dev;	/* class device for this bus */
 	struct kref kref;		/* reference counting for this bus */
 	void (*release)(struct usb_bus *bus);
 #if defined(CONFIG_USB_MON)
 	struct mon_bus *mon_bus;	/* non-null when associated */
 	int monitored;			/* non-zero when monitored */
 #endif
 };
 /* ----------------------------------------------------------------------- */
 /* This is arbitrary.
  * From USB 2.0 spec Table 11-13, offset 7, a hub can
  * have up to 255 ports. The most yet reported is 10.
  */
 #define USB_MAXCHILDREN		(16)
 struct usb_tt;
 /*
  * struct usb_device - kernel's representation of a USB device
  *
  * FIXME: Write the kerneldoc!
  *
  * Usbcore drivers should not set usbdev->state directly.  Instead use
  * usb_set_device_state().
  */
 struct usb_device {
 	int		devnum;		/* Address on USB bus */
 	char		devpath [16];	/* Use in messages: /port/port/... */
 	enum usb_device_state	state;	/* configured, not attached, etc */
 	enum usb_device_speed	speed;	/* high/full/low (or error) */
 	struct usb_tt	*tt; 		/* low/full speed dev, highspeed hub */
 	int		ttport;		/* device port on that tt hub */
 	unsigned int toggle[2];		/* one bit for each endpoint
 					 * ([0] = IN, [1] = OUT) */
 	struct usb_device *parent;	/* our hub, unless we're the root */
 	struct usb_bus *bus;		/* Bus we're part of */
 	struct usb_host_endpoint ep0;
 	struct device dev;		/* Generic device interface */
 	struct usb_device_descriptor descriptor;/* Descriptor */
 	struct usb_host_config *config;	/* All of the configs */
 	struct usb_host_config *actconfig;/* the active configuration */
 	struct usb_host_endpoint *ep_in[16];
 	struct usb_host_endpoint *ep_out[16];
 	char **rawdescriptors;		/* Raw descriptors for each config */
+	unsigned short bus_mA;		/* Current available from the bus */
 	int have_langid;		/* whether string_langid is valid */
 	int string_langid;		/* language ID for strings */
 	/* static strings from the device */
 	char *product;			/* iProduct string, if present */
 	char *manufacturer;		/* iManufacturer string, if present */
 	char *serial;			/* iSerialNumber string, if present */
 	struct list_head filelist;
 	struct class_device *class_dev;
 	struct dentry *usbfs_dentry;	/* usbfs dentry entry for the device */
 	/*
 	 * Child devices - these can be either new devices
 	 * (if this is a hub device), or different instances
 	 * of this same device.
 	 *
 	 * Each instance needs its own set of data structures.
 	 */
 	int maxchild;			/* Number of ports if hub */
 	struct usb_device *children[USB_MAXCHILDREN];
 };
 #define	to_usb_device(d) container_of(d, struct usb_device, dev)
 extern struct usb_device *usb_get_dev(struct usb_device *dev);
 extern void usb_put_dev(struct usb_device *dev);
 /* USB device locking */
 #define usb_lock_device(udev)		down(&(udev)->dev.sem)
 #define usb_unlock_device(udev)		up(&(udev)->dev.sem)
 #define usb_trylock_device(udev)	down_trylock(&(udev)->dev.sem)
 extern int usb_lock_device_for_reset(struct usb_device *udev,
 		struct usb_interface *iface);
 /* USB port reset for device reinitialization */
 extern int usb_reset_device(struct usb_device *dev);
 extern struct usb_device *usb_find_device(u16 vendor_id, u16 product_id);
 /*-------------------------------------------------------------------------*/
 /* for drivers using iso endpoints */
 extern int usb_get_current_frame_number (struct usb_device *usb_dev);
 /* used these for multi-interface device registration */
 extern int usb_driver_claim_interface(struct usb_driver *driver,
 			struct usb_interface *iface, void* priv);
 /**
  * usb_interface_claimed - returns true iff an interface is claimed
  * @iface: the interface being checked
  *
  * Returns true (nonzero) iff the interface is claimed, else false (zero).
  * Callers must own the driver model's usb bus readlock.  So driver
  * probe() entries don't need extra locking, but other call contexts
  * may need to explicitly claim that lock.
  *
  */
 static inline int usb_interface_claimed(struct usb_interface *iface) {
 	return (iface->dev.driver != NULL);
 }
 extern void usb_driver_release_interface(struct usb_driver *driver,
 			struct usb_interface *iface);
 const struct usb_device_id *usb_match_id(struct usb_interface *interface,
 					 const struct usb_device_id *id);
 extern struct usb_interface *usb_find_interface(struct usb_driver *drv,
 		int minor);
 extern struct usb_interface *usb_ifnum_to_if(struct usb_device *dev,
 		unsigned ifnum);
 extern struct usb_host_interface *usb_altnum_to_altsetting(
 		struct usb_interface *intf, unsigned int altnum);
 /**
  * usb_make_path - returns stable device path in the usb tree
  * @dev: the device whose path is being constructed
  * @buf: where to put the string
  * @size: how big is "buf"?
  *
  * Returns length of the string (> 0) or negative if size was too small.
  *
  * This identifier is intended to be "stable", reflecting physical paths in
  * hardware such as physical bus addresses for host controllers or ports on
  * USB hubs.  That makes it stay the same until systems are physically
  * reconfigured, by re-cabling a tree of USB devices or by moving USB host
  * controllers.  Adding and removing devices, including virtual root hubs
  * in host controller driver modules, does not change these path identifers;
  * neither does rebooting or re-enumerating.  These are more useful identifiers
  * than changeable ("unstable") ones like bus numbers or device addresses.
  *
  * With a partial exception for devices connected to USB 2.0 root hubs, these
  * identifiers are also predictable.  So long as the device tree isn't changed,
  * plugging any USB device into a given hub port always gives it the same path.
  * Because of the use of "companion" controllers, devices connected to ports on
  * USB 2.0 root hubs (EHCI host controllers) will get one path ID if they are
  * high speed, and a different one if they are full or low speed.
  */
 static inline int usb_make_path (struct usb_device *dev, char *buf,
 		size_t size)
 {
 	int actual;
 	actual = snprintf (buf, size, "usb-%s-%s", dev->bus->bus_name,
 			dev->devpath);
 	return (actual >= (int)size) ? -1 : actual;
 }
 /*-------------------------------------------------------------------------*/
 #define USB_DEVICE_ID_MATCH_DEVICE \
 		(USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT)
 #define USB_DEVICE_ID_MATCH_DEV_RANGE \
 		(USB_DEVICE_ID_MATCH_DEV_LO | USB_DEVICE_ID_MATCH_DEV_HI)
 #define USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION \
 		(USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_RANGE)
 #define USB_DEVICE_ID_MATCH_DEV_INFO \
 		(USB_DEVICE_ID_MATCH_DEV_CLASS | \
 		USB_DEVICE_ID_MATCH_DEV_SUBCLASS | \
 		USB_DEVICE_ID_MATCH_DEV_PROTOCOL)
 #define USB_DEVICE_ID_MATCH_INT_INFO \
 		(USB_DEVICE_ID_MATCH_INT_CLASS | \
 		USB_DEVICE_ID_MATCH_INT_SUBCLASS | \
 		USB_DEVICE_ID_MATCH_INT_PROTOCOL)
 /**
  * USB_DEVICE - macro used to describe a specific usb device
  * @vend: the 16 bit USB Vendor ID
  * @prod: the 16 bit USB Product ID
  *
  * This macro is used to create a struct usb_device_id that matches a
  * specific device.
  */
 #define USB_DEVICE(vend,prod) \
 	.match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = (vend), \
 			.idProduct = (prod)
 /**
  * USB_DEVICE_VER - macro used to describe a specific usb device with a
  *		version range
  * @vend: the 16 bit USB Vendor ID
  * @prod: the 16 bit USB Product ID
  * @lo: the bcdDevice_lo value
  * @hi: the bcdDevice_hi value
  *
  * This macro is used to create a struct usb_device_id that matches a
  * specific device, with a version range.
  */
 #define USB_DEVICE_VER(vend,prod,lo,hi) \
 	.match_flags = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION, \
 	.idVendor = (vend), .idProduct = (prod), \
 	.bcdDevice_lo = (lo), .bcdDevice_hi = (hi)
 /**
  * USB_DEVICE_INFO - macro used to describe a class of usb devices
  * @cl: bDeviceClass value
  * @sc: bDeviceSubClass value
  * @pr: bDeviceProtocol value
  *
  * This macro is used to create a struct usb_device_id that matches a
  * specific class of devices.
  */
 #define USB_DEVICE_INFO(cl,sc,pr) \
 	.match_flags = USB_DEVICE_ID_MATCH_DEV_INFO, .bDeviceClass = (cl), \
 	.bDeviceSubClass = (sc), .bDeviceProtocol = (pr)
 /**
  * USB_INTERFACE_INFO - macro used to describe a class of usb interfaces
  * @cl: bInterfaceClass value
  * @sc: bInterfaceSubClass value
  * @pr: bInterfaceProtocol value
  *
  * This macro is used to create a struct usb_device_id that matches a
  * specific class of interfaces.
  */
 #define USB_INTERFACE_INFO(cl,sc,pr) \
 	.match_flags = USB_DEVICE_ID_MATCH_INT_INFO, .bInterfaceClass = (cl), \
 	.bInterfaceSubClass = (sc), .bInterfaceProtocol = (pr)
 /* ----------------------------------------------------------------------- */
 struct usb_dynids {
 	spinlock_t lock;
 	struct list_head list;
 };
 /**
  * struct usb_driver - identifies USB driver to usbcore
  * @name: The driver name should be unique among USB drivers,
  *	and should normally be the same as the module name.
  * @probe: Called to see if the driver is willing to manage a particular
  *	interface on a device.  If it is, probe returns zero and uses
  *	dev_set_drvdata() to associate driver-specific data with the
  *	interface.  It may also use usb_set_interface() to specify the
  *	appropriate altsetting.  If unwilling to manage the interface,
  *	return a negative errno value.
  * @disconnect: Called when the interface is no longer accessible, usually
  *	because its device has been (or is being) disconnected or the
  *	driver module is being unloaded.
  * @ioctl: Used for drivers that want to talk to userspace through
  *	the "usbfs" filesystem.  This lets devices provide ways to
  *	expose information to user space regardless of where they
  *	do (or don't) show up otherwise in the filesystem.
  * @suspend: Called when the device is going to be suspended by the system.
  * @resume: Called when the device is being resumed by the system.
  * @id_table: USB drivers use ID table to support hotplugging.
  *	Export this with MODULE_DEVICE_TABLE(usb,...).  This must be set
  *	or your driver's probe function will never get called.
  * @dynids: used internally to hold the list of dynamically added device
  *	ids for this driver.
  * @driver: the driver model core driver structure.
  * @no_dynamic_id: if set to 1, the USB core will not allow dynamic ids to be
  *	added to this driver by preventing the sysfs file from being created.
  *
  * USB drivers must provide a name, probe() and disconnect() methods,
  * and an id_table.  Other driver fields are optional.
  *
  * The id_table is used in hotplugging.  It holds a set of descriptors,
  * and specialized data may be associated with each entry.  That table
  * is used by both user and kernel mode hotplugging support.
  *
  * The probe() and disconnect() methods are called in a context where
  * they can sleep, but they should avoid abusing the privilege.  Most
  * work to connect to a device should be done when the device is opened,
  * and undone at the last close.  The disconnect code needs to address
  * concurrency issues with respect to open() and close() methods, as
  * well as forcing all pending I/O requests to complete (by unlinking
  * them as necessary, and blocking until the unlinks complete).
  */
 struct usb_driver {
 	const char *name;
 	int (*probe) (struct usb_interface *intf,
 		      const struct usb_device_id *id);
 	void (*disconnect) (struct usb_interface *intf);
 	int (*ioctl) (struct usb_interface *intf, unsigned int code,
 			void *buf);
 	int (*suspend) (struct usb_interface *intf, pm_message_t message);
 	int (*resume) (struct usb_interface *intf);
 	const struct usb_device_id *id_table;
 	struct usb_dynids dynids;
 	struct device_driver driver;
 	unsigned int no_dynamic_id:1;
 };
 #define	to_usb_driver(d) container_of(d, struct usb_driver, driver)
 extern struct bus_type usb_bus_type;
 /**
  * struct usb_class_driver - identifies a USB driver that wants to use the USB major number
  * @name: the usb class device name for this driver.  Will show up in sysfs.
  * @fops: pointer to the struct file_operations of this driver.
  * @minor_base: the start of the minor range for this driver.
  *
  * This structure is used for the usb_register_dev() and
  * usb_unregister_dev() functions, to consolidate a number of the
  * parameters used for them.
  */
 struct usb_class_driver {
 	char *name;
 	struct file_operations *fops;
 	int minor_base;
 };
 /*
  * use these in module_init()/module_exit()
  * and don't forget MODULE_DEVICE_TABLE(usb, ...)
  */
 int usb_register_driver(struct usb_driver *, struct module *);
 static inline int usb_register(struct usb_driver *driver)
 {
 	return usb_register_driver(driver, THIS_MODULE);
 }
 extern void usb_deregister(struct usb_driver *);
 extern int usb_register_dev(struct usb_interface *intf,
 			    struct usb_class_driver *class_driver);
 extern void usb_deregister_dev(struct usb_interface *intf,
 			       struct usb_class_driver *class_driver);
 extern int usb_disabled(void);
 /* ----------------------------------------------------------------------- */
 /*
  * URB support, for asynchronous request completions
  */
 /*
  * urb->transfer_flags:
  */
 #define URB_SHORT_NOT_OK	0x0001	/* report short reads as errors */
 #define URB_ISO_ASAP		0x0002	/* iso-only, urb->start_frame
 					 * ignored */
 #define URB_NO_TRANSFER_DMA_MAP	0x0004	/* urb->transfer_dma valid on submit */
 #define URB_NO_SETUP_DMA_MAP	0x0008	/* urb->setup_dma valid on submit */
 #define URB_NO_FSBR		0x0020	/* UHCI-specific */
 #define URB_ZERO_PACKET		0x0040	/* Finish bulk OUT with short packet */
 #define URB_NO_INTERRUPT	0x0080	/* HINT: no non-error interrupt
 					 * needed */
 struct usb_iso_packet_descriptor {
 	unsigned int offset;
 	unsigned int length;		/* expected length */
 	unsigned int actual_length;
 	unsigned int status;
 };
 struct urb;
 struct pt_regs;
 typedef void (*usb_complete_t)(struct urb *, struct pt_regs *);
 /**
  * struct urb - USB Request Block
  * @urb_list: For use by current owner of the URB.
  * @pipe: Holds endpoint number, direction, type, and more.
  *	Create these values with the eight macros available;
  *	usb_{snd,rcv}TYPEpipe(dev,endpoint), where the TYPE is "ctrl"
  *	(control), "bulk", "int" (interrupt), or "iso" (isochronous).
  *	For example usb_sndbulkpipe() or usb_rcvintpipe().  Endpoint
  *	numbers range from zero to fifteen.  Note that "in" endpoint two
  *	is a different endpoint (and pipe) from "out" endpoint two.
  *	The current configuration controls the existence, type, and
  *	maximum packet size of any given endpoint.
  * @dev: Identifies the USB device to perform the request.
  * @status: This is read in non-iso completion functions to get the
  *	status of the particular request.  ISO requests only use it
  *	to tell whether the URB was unlinked; detailed status for
  *	each frame is in the fields of the iso_frame-desc.
  * @transfer_flags: A variety of flags may be used to affect how URB
  *	submission, unlinking, or operation are handled.  Different
  *	kinds of URB can use different flags.
  * @transfer_buffer:  This identifies the buffer to (or from) which
  * 	the I/O request will be performed (unless URB_NO_TRANSFER_DMA_MAP
  *	is set).  This buffer must be suitable for DMA; allocate it with
  *	kmalloc() or equivalent.  For transfers to "in" endpoints, contents
  *	of this buffer will be modified.  This buffer is used for the data
  *	stage of control transfers.
  * @transfer_dma: When transfer_flags includes URB_NO_TRANSFER_DMA_MAP,
  *	the device driver is saying that it provided this DMA address,
  *	which the host controller driver should use in preference to the
  *	transfer_buffer.
  * @transfer_buffer_length: How big is transfer_buffer.  The transfer may
  *	be broken up into chunks according to the current maximum packet
  *	size for the endpoint, which is a function of the configuration
  *	and is encoded in the pipe.  When the length is zero, neither
  *	transfer_buffer nor transfer_dma is used.
  * @actual_length: This is read in non-iso completion functions, and
  *	it tells how many bytes (out of transfer_buffer_length) were
  *	transferred.  It will normally be the same as requested, unless
  *	either an error was reported or a short read was performed.
  *	The URB_SHORT_NOT_OK transfer flag may be used to make such
  *	short reads be reported as errors.
  * @setup_packet: Only used for control transfers, this points to eight bytes
  *	of setup data.  Control transfers always start by sending this data
  *	to the device.  Then transfer_buffer is read or written, if needed.
  * @setup_dma: For control transfers with URB_NO_SETUP_DMA_MAP set, the
  *	device driver has provided this DMA address for the setup packet.
  *	The host controller driver should use this in preference to
  *	setup_packet.
  * @start_frame: Returns the initial frame for isochronous transfers.
  * @number_of_packets: Lists the number of ISO transfer buffers.
  * @interval: Specifies the polling interval for interrupt or isochronous
  *	transfers.  The units are frames (milliseconds) for for full and low
  *	speed devices, and microframes (1/8 millisecond) for highspeed ones.
  * @error_count: Returns the number of ISO transfers that reported errors.
  * @context: For use in completion functions.  This normally points to
  *	request-specific driver context.
  * @complete: Completion handler. This URB is passed as the parameter to the
  *	completion function.  The completion function may then do what
  *	it likes with the URB, including resubmitting or freeing it.
  * @iso_frame_desc: Used to provide arrays of ISO transfer buffers and to
  *	collect the transfer status for each buffer.
  *
  * This structure identifies USB transfer requests.  URBs must be allocated by
  * calling usb_alloc_urb() and freed with a call to usb_free_urb().
  * Initialization may be done using various usb_fill_*_urb() functions.  URBs
  * are submitted using usb_submit_urb(), and pending requests may be canceled
  * using usb_unlink_urb() or usb_kill_urb().
  *
  * Data Transfer Buffers:
  *
  * Normally drivers provide I/O buffers allocated with kmalloc() or otherwise
  * taken from the general page pool.  That is provided by transfer_buffer
  * (control requests also use setup_packet), and host controller drivers
  * perform a dma mapping (and unmapping) for each buffer transferred.  Those
  * mapping operations can be expensive on some platforms (perhaps using a dma
  * bounce buffer or talking to an IOMMU),
  * although they're cheap on commodity x86 and ppc hardware.
  *
  * Alternatively, drivers may pass the URB_NO_xxx_DMA_MAP transfer flags,
  * which tell the host controller driver that no such mapping is needed since
  * the device driver is DMA-aware.  For example, a device driver might
  * allocate a DMA buffer with usb_buffer_alloc() or call usb_buffer_map().
  * When these transfer flags are provided, host controller drivers will
  * attempt to use the dma addresses found in the transfer_dma and/or
  * setup_dma fields rather than determining a dma address themselves.  (Note
  * that transfer_buffer and setup_packet must still be set because not all
  * host controllers use DMA, nor do virtual root hubs).
  *
  * Initialization:
  *
  * All URBs submitted must initialize the dev, pipe, transfer_flags (may be
  * zero), and complete fields.  All URBs must also initialize
  * transfer_buffer and transfer_buffer_length.  They may provide the
  * URB_SHORT_NOT_OK transfer flag, indicating that short reads are
  * to be treated as errors; that flag is invalid for write requests.
  *
  * Bulk URBs may
  * use the URB_ZERO_PACKET transfer flag, indicating that bulk OUT transfers
  * should always terminate with a short packet, even if it means adding an
  * extra zero length packet.
  *
  * Control URBs must provide a setup_packet.  The setup_packet and
  * transfer_buffer may each be mapped for DMA or not, independently of
  * the other.  The transfer_flags bits URB_NO_TRANSFER_DMA_MAP and
  * URB_NO_SETUP_DMA_MAP indicate which buffers have already been mapped.
  * URB_NO_SETUP_DMA_MAP is ignored for non-control URBs.
  *
  * Interrupt URBs must provide an interval, saying how often (in milliseconds
  * or, for highspeed devices, 125 microsecond units)
  * to poll for transfers.  After the URB has been submitted, the interval
  * field reflects how the transfer was actually scheduled.
  * The polling interval may be more frequent than requested.
  * For example, some controllers have a maximum interval of 32 milliseconds,
  * while others support intervals of up to 1024 milliseconds.
  * Isochronous URBs also have transfer intervals.  (Note that for isochronous
  * endpoints, as well as high speed interrupt endpoints, the encoding of
  * the transfer interval in the endpoint descriptor is logarithmic.
  * Device drivers must convert that value to linear units themselves.)
  *
  * Isochronous URBs normally use the URB_ISO_ASAP transfer flag, telling
  * the host controller to schedule the transfer as soon as bandwidth
  * utilization allows, and then set start_frame to reflect the actual frame
  * selected during submission.  Otherwise drivers must specify the start_frame
  * and handle the case where the transfer can't begin then.  However, drivers
  * won't know how bandwidth is currently allocated, and while they can
  * find the current frame using usb_get_current_frame_number () they can't
  * know the range for that frame number.  (Ranges for frame counter values
  * are HC-specific, and can go from 256 to 65536 frames from "now".)
  *
  * Isochronous URBs have a different data transfer model, in part because
  * the quality of service is only "best effort".  Callers provide specially
  * allocated URBs, with number_of_packets worth of iso_frame_desc structures
  * at the end.  Each such packet is an individual ISO transfer.  Isochronous
  * URBs are normally queued, submitted by drivers to arrange that
  * transfers are at least double buffered, and then explicitly resubmitted
  * in completion handlers, so
  * that data (such as audio or video) streams at as constant a rate as the
  * host controller scheduler can support.
  *
  * Completion Callbacks:
  *
  * The completion callback is made in_interrupt(), and one of the first
  * things that a completion handler should do is check the status field.
  * The status field is provided for all URBs.  It is used to report
  * unlinked URBs, and status for all non-ISO transfers.  It should not
  * be examined before the URB is returned to the completion handler.
  *
  * The context field is normally used to link URBs back to the relevant
  * driver or request state.
  *
  * When the completion callback is invoked for non-isochronous URBs, the
  * actual_length field tells how many bytes were transferred.  This field
  * is updated even when the URB terminated with an error or was unlinked.
  *
  * ISO transfer status is reported in the status and actual_length fields
  * of the iso_frame_desc array, and the number of errors is reported in
  * error_count.  Completion callbacks for ISO transfers will normally
  * (re)submit URBs to ensure a constant transfer rate.
  *
  * Note that even fields marked "public" should not be touched by the driver
  * when the urb is owned by the hcd, that is, since the call to
  * usb_submit_urb() till the entry into the completion routine.
  */
 struct urb
 {
 	/* private: usb core and host controller only fields in the urb */
 	struct kref kref;		/* reference count of the URB */
 	spinlock_t lock;		/* lock for the URB */
 	void *hcpriv;			/* private data for host controller */
 	int bandwidth;			/* bandwidth for INT/ISO request */
 	atomic_t use_count;		/* concurrent submissions counter */
 	u8 reject;			/* submissions will fail */
 	/* public: documented fields in the urb that can be used by drivers */
 	struct list_head urb_list;	/* list head for use by the urb's
 					 * current owner */
 	struct usb_device *dev; 	/* (in) pointer to associated device */
 	unsigned int pipe;		/* (in) pipe information */
 	int status;			/* (return) non-ISO status */
 	unsigned int transfer_flags;	/* (in) URB_SHORT_NOT_OK | ...*/
 	void *transfer_buffer;		/* (in) associated data buffer */
 	dma_addr_t transfer_dma;	/* (in) dma addr for transfer_buffer */
 	int transfer_buffer_length;	/* (in) data buffer length */
 	int actual_length;		/* (return) actual transfer length */
 	unsigned char *setup_packet;	/* (in) setup packet (control only) */
 	dma_addr_t setup_dma;		/* (in) dma addr for setup_packet */
 	int start_frame;		/* (modify) start frame (ISO) */
 	int number_of_packets;		/* (in) number of ISO packets */
 	int interval;			/* (modify) transfer interval
 					 * (INT/ISO) */
 	int error_count;		/* (return) number of ISO errors */
 	void *context;			/* (in) context for completion */
 	usb_complete_t complete;	/* (in) completion routine */
 	struct usb_iso_packet_descriptor iso_frame_desc[0];
 					/* (in) ISO ONLY */
 };
 /* ----------------------------------------------------------------------- */
 /**
  * usb_fill_control_urb - initializes a control urb
  * @urb: pointer to the urb to initialize.
  * @dev: pointer to the struct usb_device for this urb.
  * @pipe: the endpoint pipe
  * @setup_packet: pointer to the setup_packet buffer
  * @transfer_buffer: pointer to the transfer buffer
  * @buffer_length: length of the transfer buffer
  * @complete: pointer to the usb_complete_t function
  * @context: what to set the urb context to.
  *
  * Initializes a control urb with the proper information needed to submit
  * it to a device.
  */
 static inline void usb_fill_control_urb (struct urb *urb,
 					 struct usb_device *dev,
 					 unsigned int pipe,
 					 unsigned char *setup_packet,
 					 void *transfer_buffer,
 					 int buffer_length,
 					 usb_complete_t complete,
 					 void *context)
 {
 	spin_lock_init(&urb->lock);
 	urb->dev = dev;
 	urb->pipe = pipe;
 	urb->setup_packet = setup_packet;
 	urb->transfer_buffer = transfer_buffer;
 	urb->transfer_buffer_length = buffer_length;
 	urb->complete = complete;
 	urb->context = context;
 }
 /**
  * usb_fill_bulk_urb - macro to help initialize a bulk urb
  * @urb: pointer to the urb to initialize.
  * @dev: pointer to the struct usb_device for this urb.
  * @pipe: the endpoint pipe
  * @transfer_buffer: pointer to the transfer buffer
  * @buffer_length: length of the transfer buffer
  * @complete: pointer to the usb_complete_t function
  * @context: what to set the urb context to.
  *
  * Initializes a bulk urb with the proper information needed to submit it
  * to a device.
  */
 static inline void usb_fill_bulk_urb (struct urb *urb,
 				      struct usb_device *dev,
 				      unsigned int pipe,
 				      void *transfer_buffer,
 				      int buffer_length,
 				      usb_complete_t complete,
 				      void *context)
 {
 	spin_lock_init(&urb->lock);
 	urb->dev = dev;
 	urb->pipe = pipe;
 	urb->transfer_buffer = transfer_buffer;
 	urb->transfer_buffer_length = buffer_length;
 	urb->complete = complete;
 	urb->context = context;
 }
 /**
  * usb_fill_int_urb - macro to help initialize a interrupt urb
  * @urb: pointer to the urb to initialize.
  * @dev: pointer to the struct usb_device for this urb.
  * @pipe: the endpoint pipe
  * @transfer_buffer: pointer to the transfer buffer
  * @buffer_length: length of the transfer buffer
  * @complete: pointer to the usb_complete_t function
  * @context: what to set the urb context to.
  * @interval: what to set the urb interval to, encoded like
  *	the endpoint descriptor's bInterval value.
  *
  * Initializes a interrupt urb with the proper information needed to submit
  * it to a device.
  * Note that high speed interrupt endpoints use a logarithmic encoding of
  * the endpoint interval, and express polling intervals in microframes
  * (eight per millisecond) rather than in frames (one per millisecond).
  */
 static inline void usb_fill_int_urb (struct urb *urb,
 				     struct usb_device *dev,
 				     unsigned int pipe,
 				     void *transfer_buffer,
 				     int buffer_length,
 				     usb_complete_t complete,
 				     void *context,
 				     int interval)
 {
 	spin_lock_init(&urb->lock);
 	urb->dev = dev;
 	urb->pipe = pipe;
 	urb->transfer_buffer = transfer_buffer;
 	urb->transfer_buffer_length = buffer_length;
 	urb->complete = complete;
 	urb->context = context;
 	if (dev->speed == USB_SPEED_HIGH)
 		urb->interval = 1 << (interval - 1);
 	else
 		urb->interval = interval;
 	urb->start_frame = -1;
 }
 extern void usb_init_urb(struct urb *urb);
 extern struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags);
 extern void usb_free_urb(struct urb *urb);
 #define usb_put_urb usb_free_urb
 extern struct urb *usb_get_urb(struct urb *urb);
 extern int usb_submit_urb(struct urb *urb, gfp_t mem_flags);
 extern int usb_unlink_urb(struct urb *urb);
 extern void usb_kill_urb(struct urb *urb);
 #define HAVE_USB_BUFFERS
 void *usb_buffer_alloc (struct usb_device *dev, size_t size,
 	gfp_t mem_flags, dma_addr_t *dma);
 void usb_buffer_free (struct usb_device *dev, size_t size,
 	void *addr, dma_addr_t dma);
 #if 0
 struct urb *usb_buffer_map (struct urb *urb);
 void usb_buffer_dmasync (struct urb *urb);
 void usb_buffer_unmap (struct urb *urb);
 #endif
 struct scatterlist;
 int usb_buffer_map_sg (struct usb_device *dev, unsigned pipe,
 		struct scatterlist *sg, int nents);
 #if 0
 void usb_buffer_dmasync_sg (struct usb_device *dev, unsigned pipe,
 		struct scatterlist *sg, int n_hw_ents);
 #endif
 void usb_buffer_unmap_sg (struct usb_device *dev, unsigned pipe,
 		struct scatterlist *sg, int n_hw_ents);
 /*-------------------------------------------------------------------*
  *                         SYNCHRONOUS CALL SUPPORT                  *
  *-------------------------------------------------------------------*/
 extern int usb_control_msg(struct usb_device *dev, unsigned int pipe,
 	__u8 request, __u8 requesttype, __u16 value, __u16 index,
 	void *data, __u16 size, int timeout);
 extern int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,
 	void *data, int len, int *actual_length,
 	int timeout);
 /* wrappers around usb_control_msg() for the most common standard requests */
 extern int usb_get_descriptor(struct usb_device *dev, unsigned char desctype,
 	unsigned char descindex, void *buf, int size);
 extern int usb_get_status(struct usb_device *dev,
 	int type, int target, void *data);
 extern int usb_get_string(struct usb_device *dev,
 	unsigned short langid, unsigned char index, void *buf, int size);
 extern int usb_string(struct usb_device *dev, int index,
 	char *buf, size_t size);
 /* wrappers that also update important state inside usbcore */
 extern int usb_clear_halt(struct usb_device *dev, int pipe);
 extern int usb_reset_configuration(struct usb_device *dev);
 extern int usb_set_interface(struct usb_device *dev, int ifnum, int alternate);
 /*
  * timeouts, in milliseconds, used for sending/receiving control messages
  * they typically complete within a few frames (msec) after they're issued
  * USB identifies 5 second timeouts, maybe more in a few cases, and a few
  * slow devices (like some MGE Ellipse UPSes) actually push that limit.
  */
 #define USB_CTRL_GET_TIMEOUT	5000
 #define USB_CTRL_SET_TIMEOUT	5000
 /**
  * struct usb_sg_request - support for scatter/gather I/O
  * @status: zero indicates success, else negative errno
  * @bytes: counts bytes transferred.
  *
  * These requests are initialized using usb_sg_init(), and then are used
  * as request handles passed to usb_sg_wait() or usb_sg_cancel().  Most
  * members of the request object aren't for driver access.
  *
  * The status and bytecount values are valid only after usb_sg_wait()
  * returns.  If the status is zero, then the bytecount matches the total
  * from the request.
  *
  * After an error completion, drivers may need to clear a halt condition
  * on the endpoint.
  */
 struct usb_sg_request {
 	int			status;
 	size_t			bytes;
 	/*
 	 * members below are private: to usbcore,
 	 * and are not provided for driver access!
 	 */
 	spinlock_t		lock;
 	struct usb_device	*dev;
 	int			pipe;
 	struct scatterlist	*sg;
 	int			nents;
 	int			entries;
 	struct urb		**urbs;
 	int			count;
 	struct completion	complete;
 };
 int usb_sg_init (
 	struct usb_sg_request	*io,
 	struct usb_device	*dev,
 	unsigned		pipe,
 	unsigned		period,
 	struct scatterlist	*sg,
 	int			nents,
 	size_t			length,
 	gfp_t			mem_flags
 );
 void usb_sg_cancel (struct usb_sg_request *io);
 void usb_sg_wait (struct usb_sg_request *io);
 /* ----------------------------------------------------------------------- */
 /*
  * For various legacy reasons, Linux has a small cookie that's paired with
  * a struct usb_device to identify an endpoint queue.  Queue characteristics
  * are defined by the endpoint's descriptor.  This cookie is called a "pipe",
  * an unsigned int encoded as:
  *
  *  - direction:	bit 7		(0 = Host-to-Device [Out],
  *					 1 = Device-to-Host [In] ...
  *					like endpoint bEndpointAddress)
  *  - device address:	bits 8-14       ... bit positions known to uhci-hcd
  *  - endpoint:		bits 15-18      ... bit positions known to uhci-hcd
  *  - pipe type:	bits 30-31	(00 = isochronous, 01 = interrupt,
  *					 10 = control, 11 = bulk)
  *
  * Given the device address and endpoint descriptor, pipes are redundant.
  */
 /* NOTE:  these are not the standard USB_ENDPOINT_XFER_* values!! */
 /* (yet ... they're the values used by usbfs) */
 #define PIPE_ISOCHRONOUS		0
 #define PIPE_INTERRUPT			1
 #define PIPE_CONTROL			2
 #define PIPE_BULK			3
 #define usb_pipein(pipe)	((pipe) & USB_DIR_IN)
 #define usb_pipeout(pipe)	(!usb_pipein(pipe))
 #define usb_pipedevice(pipe)	(((pipe) >> 8) & 0x7f)
 #define usb_pipeendpoint(pipe)	(((pipe) >> 15) & 0xf)
 #define usb_pipetype(pipe)	(((pipe) >> 30) & 3)
 #define usb_pipeisoc(pipe)	(usb_pipetype((pipe)) == PIPE_ISOCHRONOUS)
 #define usb_pipeint(pipe)	(usb_pipetype((pipe)) == PIPE_INTERRUPT)
 #define usb_pipecontrol(pipe)	(usb_pipetype((pipe)) == PIPE_CONTROL)
 #define usb_pipebulk(pipe)	(usb_pipetype((pipe)) == PIPE_BULK)
 /* The D0/D1 toggle bits ... USE WITH CAUTION (they're almost hcd-internal) */
 #define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> (ep)) & 1)
 #define	usb_dotoggle(dev, ep, out)  ((dev)->toggle[out] ^= (1 << (ep)))
 #define usb_settoggle(dev, ep, out, bit) \
 		((dev)->toggle[out] = ((dev)->toggle[out] & ~(1 << (ep))) | \
 		 ((bit) << (ep)))
 static inline unsigned int __create_pipe(struct usb_device *dev,
 		unsigned int endpoint)
 {
 	return (dev->devnum << 8) | (endpoint << 15);
 }
 /* Create various pipes... */
 #define usb_sndctrlpipe(dev,endpoint)	\
 	((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint))
 #define usb_rcvctrlpipe(dev,endpoint)	\
 	((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
 #define usb_sndisocpipe(dev,endpoint)	\
 	((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev,endpoint))
 #define usb_rcvisocpipe(dev,endpoint)	\
 	((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
 #define usb_sndbulkpipe(dev,endpoint)	\
 	((PIPE_BULK << 30) | __create_pipe(dev,endpoint))
 #define usb_rcvbulkpipe(dev,endpoint)	\
 	((PIPE_BULK << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
 #define usb_sndintpipe(dev,endpoint)	\
 	((PIPE_INTERRUPT << 30) | __create_pipe(dev,endpoint))
 #define usb_rcvintpipe(dev,endpoint)	\
 	((PIPE_INTERRUPT << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
 /*-------------------------------------------------------------------------*/
 static inline __u16
 usb_maxpacket(struct usb_device *udev, int pipe, int is_out)
 {
 	struct usb_host_endpoint	*ep;
 	unsigned			epnum = usb_pipeendpoint(pipe);
 	if (is_out) {
 		WARN_ON(usb_pipein(pipe));
 		ep = udev->ep_out[epnum];
 	} else {
 		WARN_ON(usb_pipeout(pipe));
 		ep = udev->ep_in[epnum];
 	}
 	if (!ep)
 		return 0;
 	/* NOTE:  only 0x07ff bits are for packet size... */
 	return le16_to_cpu(ep->desc.wMaxPacketSize);
 }
 /* ----------------------------------------------------------------------- */
 /* Events from the usb core */
 #define USB_DEVICE_ADD		0x0001
 #define USB_DEVICE_REMOVE	0x0002
 #define USB_BUS_ADD		0x0003
 #define USB_BUS_REMOVE		0x0004
 extern void usb_register_notify(struct notifier_block *nb);
 extern void usb_unregister_notify(struct notifier_block *nb);
 #ifdef DEBUG
 #define dbg(format, arg...) printk(KERN_DEBUG "%s: " format "\n" , \
 	__FILE__ , ## arg)
 #else
 #define dbg(format, arg...) do {} while (0)
 #endif
 #define err(format, arg...) printk(KERN_ERR "%s: " format "\n" , \
 	__FILE__ , ## arg)
 #define info(format, arg...) printk(KERN_INFO "%s: " format "\n" , \
 	__FILE__ , ## arg)
 #define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n" , \
 	__FILE__ , ## arg)
 #endif  /* __KERNEL__ */
 #endif