2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* (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/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 <linux/device.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
2006-01-11 15:55:29 +01:00
|
|
|
#include <linux/mutex.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/byteorder.h>
|
2008-01-23 07:58:35 +01:00
|
|
|
#include <asm/unaligned.h>
|
USB: Properly unregister reboot notifier in case of failure in ehci hcd
If some problem occurs during ehci startup, for instance, request_irq fails,
echi hcd driver tries it best to cleanup, but fails to unregister reboot
notifier, which in turn leads to crash on reboot/poweroff.
The following patch resolves this problem by not using reboot notifiers
anymore, but instead making ehci/ohci driver get its own shutdown method. For
PCI, it is done through pci glue, for everything else through platform driver
glue.
One downside: sa1111 does not use platform driver stuff, and does not have its
own shutdown hook, so no 'shutdown' is called for it now. I'm not sure if it
is really necessary on that platform, though.
Signed-off-by: Aleks Gorelov <dared1st@yahoo.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: David Brownell <david-b@pacbell.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-08-09 02:24:08 +02:00
|
|
|
#include <linux/platform_device.h>
|
2007-03-13 21:37:30 +01:00
|
|
|
#include <linux/workqueue.h>
|
2010-01-08 18:57:28 +01:00
|
|
|
#include <linux/pm_runtime.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#include <linux/usb.h>
|
2010-04-24 23:21:52 +02:00
|
|
|
#include <linux/usb/hcd.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#include "usb.h"
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2008-10-02 17:48:13 +02:00
|
|
|
/* Keep track of which host controller drivers are loaded */
|
|
|
|
unsigned long usb_hcds_loaded;
|
|
|
|
EXPORT_SYMBOL_GPL(usb_hcds_loaded);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* 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 */
|
2006-01-11 15:55:29 +01:00
|
|
|
DEFINE_MUTEX(usb_bus_list_lock); /* exported only for usbfs */
|
2005-04-17 00:20:36 +02:00
|
|
|
EXPORT_SYMBOL_GPL (usb_bus_list_lock);
|
|
|
|
|
|
|
|
/* used for controlling access to virtual root hubs */
|
|
|
|
static DEFINE_SPINLOCK(hcd_root_hub_lock);
|
|
|
|
|
2007-07-18 18:14:24 +02:00
|
|
|
/* used when updating an endpoint's URB list */
|
|
|
|
static DEFINE_SPINLOCK(hcd_urb_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-10-21 21:28:46 +02:00
|
|
|
/* used to protect against unlinking URBs after the device is gone */
|
|
|
|
static DEFINE_SPINLOCK(hcd_urb_unlink_lock);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* wait queue for synchronous unlinks */
|
|
|
|
DECLARE_WAIT_QUEUE_HEAD(usb_kill_urb_queue);
|
|
|
|
|
2007-07-18 18:14:24 +02:00
|
|
|
static inline int is_root_hub(struct usb_device *udev)
|
|
|
|
{
|
|
|
|
return (udev->parent == NULL);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sharable chunks of root hub code.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
#define KERNEL_REL ((LINUX_VERSION_CODE >> 16) & 0x0ff)
|
|
|
|
#define KERNEL_VER ((LINUX_VERSION_CODE >> 8) & 0x0ff)
|
|
|
|
|
2009-04-28 04:55:01 +02:00
|
|
|
/* usb 3.0 root hub device descriptor */
|
|
|
|
static const u8 usb3_rh_dev_descriptor[18] = {
|
|
|
|
0x12, /* __u8 bLength; */
|
|
|
|
0x01, /* __u8 bDescriptorType; Device */
|
|
|
|
0x00, 0x03, /* __le16 bcdUSB; v3.0 */
|
|
|
|
|
|
|
|
0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
|
|
|
|
0x00, /* __u8 bDeviceSubClass; */
|
|
|
|
0x03, /* __u8 bDeviceProtocol; USB 3.0 hub */
|
|
|
|
0x09, /* __u8 bMaxPacketSize0; 2^9 = 512 Bytes */
|
|
|
|
|
|
|
|
0x6b, 0x1d, /* __le16 idVendor; Linux Foundation */
|
2010-02-25 19:19:37 +01:00
|
|
|
0x03, 0x00, /* __le16 idProduct; device 0x0003 */
|
2009-04-28 04:55:01 +02:00
|
|
|
KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */
|
|
|
|
|
|
|
|
0x03, /* __u8 iManufacturer; */
|
|
|
|
0x02, /* __u8 iProduct; */
|
|
|
|
0x01, /* __u8 iSerialNumber; */
|
|
|
|
0x01 /* __u8 bNumConfigurations; */
|
|
|
|
};
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* 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; */
|
2008-04-04 00:02:56 +02:00
|
|
|
0x00, /* __u8 bDeviceProtocol; [ usb 2.0 no TT ] */
|
2005-10-24 21:41:19 +02:00
|
|
|
0x40, /* __u8 bMaxPacketSize0; 64 Bytes */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-01-28 18:50:12 +01:00
|
|
|
0x6b, 0x1d, /* __le16 idVendor; Linux Foundation */
|
|
|
|
0x02, 0x00, /* __le16 idProduct; device 0x0002 */
|
2005-04-17 00:20:36 +02:00
|
|
|
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 ] */
|
2005-10-24 21:41:19 +02:00
|
|
|
0x40, /* __u8 bMaxPacketSize0; 64 Bytes */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-01-28 18:50:12 +01:00
|
|
|
0x6b, 0x1d, /* __le16 idVendor; Linux Foundation */
|
|
|
|
0x01, 0x00, /* __le16 idProduct; device 0x0001 */
|
2005-04-17 00:20:36 +02:00
|
|
|
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 */
|
2006-10-12 05:05:59 +02:00
|
|
|
/* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8)
|
|
|
|
* see hub.c:hub_configure() for details. */
|
|
|
|
(USB_MAXCHILDREN + 1 + 7) / 8, 0x00,
|
2005-04-17 00:20:36 +02:00
|
|
|
0x0c /* __u8 ep_bInterval; (256ms -- usb 2.0 spec) */
|
|
|
|
};
|
|
|
|
|
2009-04-28 04:55:01 +02:00
|
|
|
static const u8 ss_rh_config_descriptor[] = {
|
|
|
|
/* one configuration */
|
|
|
|
0x09, /* __u8 bLength; */
|
|
|
|
0x02, /* __u8 bDescriptorType; Configuration */
|
|
|
|
0x19, 0x00, /* __le16 wTotalLength; FIXME */
|
|
|
|
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; */
|
|
|
|
|
|
|
|
/* 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; */
|
|
|
|
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 */
|
|
|
|
/* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8)
|
|
|
|
* see hub.c:hub_configure() for details. */
|
|
|
|
(USB_MAXCHILDREN + 1 + 7) / 8, 0x00,
|
|
|
|
0x0c /* __u8 ep_bInterval; (256ms -- usb 2.0 spec) */
|
|
|
|
/*
|
|
|
|
* All 3.0 hubs should have an endpoint companion descriptor,
|
|
|
|
* but we're ignoring that for now. FIXME?
|
|
|
|
*/
|
|
|
|
};
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2009-08-25 04:06:41 +02:00
|
|
|
/**
|
|
|
|
* ascii2desc() - Helper routine for producing UTF-16LE string descriptors
|
|
|
|
* @s: Null-terminated ASCII (actually ISO-8859-1) string
|
|
|
|
* @buf: Buffer for USB string descriptor (header + UTF-16LE)
|
|
|
|
* @len: Length (in bytes; may be odd) of descriptor buffer.
|
|
|
|
*
|
|
|
|
* The return value is the number of bytes filled in: 2 + 2*strlen(s) or
|
|
|
|
* buflen, whichever is less.
|
|
|
|
*
|
|
|
|
* USB String descriptors can contain at most 126 characters; input
|
|
|
|
* strings longer than that are truncated.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2009-08-25 04:06:41 +02:00
|
|
|
static unsigned
|
|
|
|
ascii2desc(char const *s, u8 *buf, unsigned len)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2009-08-25 04:06:41 +02:00
|
|
|
unsigned n, t = 2 + 2*strlen(s);
|
|
|
|
|
|
|
|
if (t > 254)
|
|
|
|
t = 254; /* Longest possible UTF string descriptor */
|
|
|
|
if (len > t)
|
|
|
|
len = t;
|
|
|
|
|
|
|
|
t += USB_DT_STRING << 8; /* Now t is first 16 bits to store */
|
|
|
|
|
|
|
|
n = len;
|
|
|
|
while (n--) {
|
|
|
|
*buf++ = t;
|
|
|
|
if (!n--)
|
|
|
|
break;
|
|
|
|
*buf++ = t >> 8;
|
|
|
|
t = (unsigned char)*s++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2009-08-25 04:06:41 +02:00
|
|
|
return len;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-08-25 04:06:41 +02:00
|
|
|
/**
|
|
|
|
* rh_string() - provides string descriptors for root hub
|
|
|
|
* @id: the string ID number (0: langids, 1: serial #, 2: product, 3: vendor)
|
2005-04-17 00:20:36 +02:00
|
|
|
* @hcd: the host controller for this root hub
|
2009-08-25 04:06:41 +02:00
|
|
|
* @data: buffer for output packet
|
|
|
|
* @len: length of the provided buffer
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Produces either a manufacturer, product or serial number string for the
|
|
|
|
* virtual root hub device.
|
2009-08-25 04:06:41 +02:00
|
|
|
* Returns the number of bytes filled in: the length of the descriptor or
|
|
|
|
* of the provided buffer, whichever is less.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2009-08-25 04:06:41 +02:00
|
|
|
static unsigned
|
|
|
|
rh_string(int id, struct usb_hcd const *hcd, u8 *data, unsigned len)
|
2009-03-13 12:19:18 +01:00
|
|
|
{
|
2009-08-25 04:06:41 +02:00
|
|
|
char buf[100];
|
|
|
|
char const *s;
|
|
|
|
static char const langids[4] = {4, USB_DT_STRING, 0x09, 0x04};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
// language ids
|
2009-08-25 04:06:41 +02:00
|
|
|
switch (id) {
|
|
|
|
case 0:
|
|
|
|
/* Array of LANGID codes (0x0409 is MSFT-speak for "en-us") */
|
|
|
|
/* See http://www.usb.org/developers/docs/USB_LANGIDs.pdf */
|
|
|
|
if (len > 4)
|
|
|
|
len = 4;
|
|
|
|
memcpy(data, langids, len);
|
2005-04-17 00:20:36 +02:00
|
|
|
return len;
|
2009-08-25 04:06:41 +02:00
|
|
|
case 1:
|
|
|
|
/* Serial number */
|
|
|
|
s = hcd->self.bus_name;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
/* Product name */
|
|
|
|
s = hcd->product_desc;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
/* Manufacturer */
|
2006-10-02 11:18:13 +02:00
|
|
|
snprintf (buf, sizeof buf, "%s %s %s", init_utsname()->sysname,
|
|
|
|
init_utsname()->release, hcd->driver->description);
|
2009-08-25 04:06:41 +02:00
|
|
|
s = buf;
|
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
default:
|
2009-08-25 04:06:41 +02:00
|
|
|
/* Can't happen; caller guarantees it */
|
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2009-08-25 04:06:41 +02:00
|
|
|
|
|
|
|
return ascii2desc(s, data, len);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* 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;
|
2006-09-24 02:05:31 +02:00
|
|
|
u8 tbuf [sizeof (struct usb_hub_descriptor)]
|
|
|
|
__attribute__((aligned(4)));
|
2005-04-17 00:20:36 +02:00
|
|
|
const u8 *bufp = tbuf;
|
2009-03-13 12:19:18 +01:00
|
|
|
unsigned len = 0;
|
2007-08-08 17:48:02 +02:00
|
|
|
int status;
|
2008-04-04 00:02:56 +02:00
|
|
|
u8 patch_wakeup = 0;
|
|
|
|
u8 patch_protocol = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-02 21:05:45 +02:00
|
|
|
might_sleep();
|
|
|
|
|
2007-08-08 17:48:02 +02:00
|
|
|
spin_lock_irq(&hcd_root_hub_lock);
|
|
|
|
status = usb_hcd_link_urb_to_ep(hcd, urb);
|
|
|
|
spin_unlock_irq(&hcd_root_hub_lock);
|
|
|
|
if (status)
|
|
|
|
return status;
|
2007-08-21 21:39:21 +02:00
|
|
|
urb->hcpriv = hcd; /* Indicate it's queued */
|
2007-08-08 17:48:02 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
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 */
|
|
|
|
|
2006-01-24 17:40:27 +01:00
|
|
|
/* The root hub's remote wakeup enable bit is implemented using
|
|
|
|
* driver model wakeup flags. If this system supports wakeup
|
|
|
|
* through USB, userspace may change the default "allow wakeup"
|
|
|
|
* policy through sysfs or these calls.
|
|
|
|
*
|
|
|
|
* Most root hubs support wakeup from downstream devices, for
|
|
|
|
* runtime power management (disabling USB clocks and reducing
|
|
|
|
* VBUS power usage). However, not all of them do so; silicon,
|
|
|
|
* board, and BIOS bugs here are not uncommon, so these can't
|
|
|
|
* be treated quite like external hubs.
|
|
|
|
*
|
|
|
|
* Likewise, not all root hubs will pass wakeup events upstream,
|
|
|
|
* to wake up the whole system. So don't assume root hub and
|
|
|
|
* controller capabilities are identical.
|
|
|
|
*/
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
case DeviceRequest | USB_REQ_GET_STATUS:
|
2006-01-24 17:40:27 +01:00
|
|
|
tbuf [0] = (device_may_wakeup(&hcd->self.root_hub->dev)
|
|
|
|
<< USB_DEVICE_REMOTE_WAKEUP)
|
2005-04-17 00:20:36 +02:00
|
|
|
| (1 << USB_DEVICE_SELF_POWERED);
|
|
|
|
tbuf [1] = 0;
|
|
|
|
len = 2;
|
|
|
|
break;
|
|
|
|
case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
|
|
|
|
if (wValue == USB_DEVICE_REMOTE_WAKEUP)
|
2006-01-24 17:40:27 +01:00
|
|
|
device_set_wakeup_enable(&hcd->self.root_hub->dev, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
else
|
|
|
|
goto error;
|
|
|
|
break;
|
|
|
|
case DeviceOutRequest | USB_REQ_SET_FEATURE:
|
2006-01-24 17:40:27 +01:00
|
|
|
if (device_can_wakeup(&hcd->self.root_hub->dev)
|
|
|
|
&& wValue == USB_DEVICE_REMOTE_WAKEUP)
|
|
|
|
device_set_wakeup_enable(&hcd->self.root_hub->dev, 1);
|
2005-04-17 00:20:36 +02:00
|
|
|
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:
|
2009-05-05 12:24:23 +02:00
|
|
|
switch (hcd->driver->flags & HCD_MASK) {
|
|
|
|
case HCD_USB3:
|
2009-04-28 04:55:01 +02:00
|
|
|
bufp = usb3_rh_dev_descriptor;
|
2009-05-05 12:24:23 +02:00
|
|
|
break;
|
|
|
|
case HCD_USB2:
|
2005-04-17 00:20:36 +02:00
|
|
|
bufp = usb2_rh_dev_descriptor;
|
2009-05-05 12:24:23 +02:00
|
|
|
break;
|
|
|
|
case HCD_USB11:
|
2005-04-17 00:20:36 +02:00
|
|
|
bufp = usb11_rh_dev_descriptor;
|
2009-05-05 12:24:23 +02:00
|
|
|
break;
|
|
|
|
default:
|
2005-04-17 00:20:36 +02:00
|
|
|
goto error;
|
2009-05-05 12:24:23 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
len = 18;
|
2008-04-04 00:02:56 +02:00
|
|
|
if (hcd->has_tt)
|
|
|
|
patch_protocol = 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case USB_DT_CONFIG << 8:
|
2009-05-05 12:24:23 +02:00
|
|
|
switch (hcd->driver->flags & HCD_MASK) {
|
|
|
|
case HCD_USB3:
|
2009-04-28 04:55:01 +02:00
|
|
|
bufp = ss_rh_config_descriptor;
|
|
|
|
len = sizeof ss_rh_config_descriptor;
|
2009-05-05 12:24:23 +02:00
|
|
|
break;
|
|
|
|
case HCD_USB2:
|
2005-04-17 00:20:36 +02:00
|
|
|
bufp = hs_rh_config_descriptor;
|
|
|
|
len = sizeof hs_rh_config_descriptor;
|
2009-05-05 12:24:23 +02:00
|
|
|
break;
|
|
|
|
case HCD_USB11:
|
2005-04-17 00:20:36 +02:00
|
|
|
bufp = fs_rh_config_descriptor;
|
|
|
|
len = sizeof fs_rh_config_descriptor;
|
2009-05-05 12:24:23 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto error;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-01-24 17:40:27 +01:00
|
|
|
if (device_can_wakeup(&hcd->self.root_hub->dev))
|
2005-04-17 00:20:36 +02:00
|
|
|
patch_wakeup = 1;
|
|
|
|
break;
|
|
|
|
case USB_DT_STRING << 8:
|
2009-03-13 12:19:18 +01:00
|
|
|
if ((wValue & 0xff) < 4)
|
|
|
|
urb->actual_length = rh_string(wValue & 0xff,
|
|
|
|
hcd, ubuf, wLength);
|
|
|
|
else /* unsupported IDs --> "protocol stall" */
|
2005-04-17 00:20:36 +02:00
|
|
|
goto error;
|
|
|
|
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 */
|
2005-09-27 19:38:54 +02:00
|
|
|
switch (typeReq) {
|
|
|
|
case GetHubStatus:
|
|
|
|
case GetPortStatus:
|
|
|
|
len = 4;
|
|
|
|
break;
|
|
|
|
case GetHubDescriptor:
|
|
|
|
len = sizeof (struct usb_hub_descriptor);
|
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2005-09-27 19:38:54 +02:00
|
|
|
status = hcd->driver->hub_control (hcd,
|
|
|
|
typeReq, wValue, wIndex,
|
|
|
|
tbuf, wLength);
|
2005-04-17 00:20:36 +02:00
|
|
|
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,
|
2005-09-27 19:38:54 +02:00
|
|
|
wLength, status);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
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;
|
2008-04-04 00:02:56 +02:00
|
|
|
|
|
|
|
/* report whether RH hardware has an integrated TT */
|
|
|
|
if (patch_protocol &&
|
|
|
|
len > offsetof(struct usb_device_descriptor,
|
|
|
|
bDeviceProtocol))
|
|
|
|
((struct usb_device_descriptor *) ubuf)->
|
|
|
|
bDeviceProtocol = 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* any errors get returned through the urb completion */
|
2007-08-02 21:05:45 +02:00
|
|
|
spin_lock_irq(&hcd_root_hub_lock);
|
2007-08-08 17:48:02 +02:00
|
|
|
usb_hcd_unlink_urb_from_ep(hcd, urb);
|
2007-08-02 21:05:45 +02:00
|
|
|
|
|
|
|
/* This peculiar use of spinlocks echoes what real HC drivers do.
|
|
|
|
* Avoiding calls to local_irq_disable/enable makes the code
|
|
|
|
* RT-friendly.
|
|
|
|
*/
|
|
|
|
spin_unlock(&hcd_root_hub_lock);
|
2007-08-24 21:42:24 +02:00
|
|
|
usb_hcd_giveback_urb(hcd, urb, status);
|
2007-08-02 21:05:45 +02:00
|
|
|
spin_lock(&hcd_root_hub_lock);
|
|
|
|
|
|
|
|
spin_unlock_irq(&hcd_root_hub_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
2005-04-21 21:56:37 +02:00
|
|
|
* 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.
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
2005-04-21 21:56:37 +02:00
|
|
|
* Completions are called in_interrupt(), but they may or may not
|
|
|
|
* be in_irq().
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2005-04-21 21:56:37 +02:00
|
|
|
void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
|
|
|
|
{
|
|
|
|
struct urb *urb;
|
|
|
|
int length;
|
|
|
|
unsigned long flags;
|
2009-07-06 22:05:40 +02:00
|
|
|
char buffer[6]; /* Any root hubs with > 31 ports? */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-06-09 23:34:17 +02:00
|
|
|
if (unlikely(!hcd->rh_pollable))
|
2007-03-13 16:10:52 +01:00
|
|
|
return;
|
2005-04-21 21:56:37 +02:00
|
|
|
if (!hcd->uses_new_polling && !hcd->status_urb)
|
|
|
|
return;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-04-21 21:56:37 +02:00
|
|
|
length = hcd->driver->hub_status_data(hcd, buffer);
|
|
|
|
if (length > 0) {
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-04-21 21:56:37 +02:00
|
|
|
/* try to complete the status urb */
|
2007-08-02 21:05:45 +02:00
|
|
|
spin_lock_irqsave(&hcd_root_hub_lock, flags);
|
2005-04-21 21:56:37 +02:00
|
|
|
urb = hcd->status_urb;
|
|
|
|
if (urb) {
|
2010-06-22 22:39:10 +02:00
|
|
|
clear_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
|
2007-08-08 17:48:02 +02:00
|
|
|
hcd->status_urb = NULL;
|
|
|
|
urb->actual_length = length;
|
|
|
|
memcpy(urb->transfer_buffer, buffer, length);
|
2007-08-02 21:05:45 +02:00
|
|
|
|
2007-08-08 17:48:02 +02:00
|
|
|
usb_hcd_unlink_urb_from_ep(hcd, urb);
|
2007-08-02 21:05:45 +02:00
|
|
|
spin_unlock(&hcd_root_hub_lock);
|
2007-08-24 21:42:24 +02:00
|
|
|
usb_hcd_giveback_urb(hcd, urb, 0);
|
2007-08-02 21:05:45 +02:00
|
|
|
spin_lock(&hcd_root_hub_lock);
|
2007-08-08 17:48:02 +02:00
|
|
|
} else {
|
2005-04-21 21:56:37 +02:00
|
|
|
length = 0;
|
2010-06-22 22:39:10 +02:00
|
|
|
set_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
|
2007-08-08 17:48:02 +02:00
|
|
|
}
|
2007-08-02 21:05:45 +02:00
|
|
|
spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-04-21 21:56:37 +02:00
|
|
|
/* The USB 2.0 spec says 256 ms. This is close enough and won't
|
2007-05-22 21:42:56 +02:00
|
|
|
* exceed that limit if HZ is 100. The math is more clunky than
|
|
|
|
* maybe expected, this is to make sure that all timers for USB devices
|
|
|
|
* fire at the same time to give the CPU a break inbetween */
|
2010-06-22 22:39:10 +02:00
|
|
|
if (hcd->uses_new_polling ? HCD_POLL_RH(hcd) :
|
2005-04-21 21:56:37 +02:00
|
|
|
(length == 0 && hcd->status_urb != NULL))
|
2007-05-22 21:42:56 +02:00
|
|
|
mod_timer (&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2005-04-21 21:56:37 +02:00
|
|
|
EXPORT_SYMBOL_GPL(usb_hcd_poll_rh_status);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* timer callback */
|
2005-04-21 21:56:37 +02:00
|
|
|
static void rh_timer_func (unsigned long _hcd)
|
|
|
|
{
|
|
|
|
usb_hcd_poll_rh_status((struct usb_hcd *) _hcd);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-04-21 21:56:37 +02:00
|
|
|
static int rh_queue_status (struct usb_hcd *hcd, struct urb *urb)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-04-21 21:56:37 +02:00
|
|
|
int retval;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned long flags;
|
2009-03-13 12:19:18 +01:00
|
|
|
unsigned len = 1 + (urb->dev->maxchild / 8);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-04-21 21:56:37 +02:00
|
|
|
spin_lock_irqsave (&hcd_root_hub_lock, flags);
|
2007-08-08 17:48:02 +02:00
|
|
|
if (hcd->status_urb || urb->transfer_buffer_length < len) {
|
2005-04-21 21:56:37 +02:00
|
|
|
dev_dbg (hcd->self.controller, "not queuing rh status urb\n");
|
|
|
|
retval = -EINVAL;
|
2007-08-08 17:48:02 +02:00
|
|
|
goto done;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-08 17:48:02 +02:00
|
|
|
retval = usb_hcd_link_urb_to_ep(hcd, urb);
|
|
|
|
if (retval)
|
|
|
|
goto done;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-08 17:48:02 +02:00
|
|
|
hcd->status_urb = urb;
|
|
|
|
urb->hcpriv = hcd; /* indicate it's queued */
|
|
|
|
if (!hcd->uses_new_polling)
|
|
|
|
mod_timer(&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
|
|
|
|
|
|
|
|
/* If a status change has already occurred, report it ASAP */
|
2010-06-22 22:39:10 +02:00
|
|
|
else if (HCD_POLL_PENDING(hcd))
|
2007-08-08 17:48:02 +02:00
|
|
|
mod_timer(&hcd->rh_timer, jiffies);
|
|
|
|
retval = 0;
|
|
|
|
done:
|
2005-04-21 21:56:37 +02:00
|
|
|
spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
|
|
|
|
return retval;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
|
|
|
|
{
|
2007-07-30 23:07:21 +02:00
|
|
|
if (usb_endpoint_xfer_int(&urb->ep->desc))
|
2005-04-21 21:56:37 +02:00
|
|
|
return rh_queue_status (hcd, urb);
|
2007-07-30 23:07:21 +02:00
|
|
|
if (usb_endpoint_xfer_control(&urb->ep->desc))
|
2005-04-17 00:20:36 +02:00
|
|
|
return rh_call_control (hcd, urb);
|
2005-04-21 21:56:37 +02:00
|
|
|
return -EINVAL;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2006-08-11 22:01:45 +02:00
|
|
|
/* Unlinks of root-hub control URBs are legal, but they don't do anything
|
|
|
|
* since these URBs always execute synchronously.
|
2005-04-21 21:56:37 +02:00
|
|
|
*/
|
2007-08-08 17:48:02 +02:00
|
|
|
static int usb_rh_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-08-11 22:01:45 +02:00
|
|
|
unsigned long flags;
|
2007-08-08 17:48:02 +02:00
|
|
|
int rc;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-02 21:05:45 +02:00
|
|
|
spin_lock_irqsave(&hcd_root_hub_lock, flags);
|
2007-08-08 17:48:02 +02:00
|
|
|
rc = usb_hcd_check_unlink_urb(hcd, urb, status);
|
|
|
|
if (rc)
|
|
|
|
goto done;
|
|
|
|
|
2007-07-30 23:07:21 +02:00
|
|
|
if (usb_endpoint_num(&urb->ep->desc) == 0) { /* Control URB */
|
2006-08-11 22:01:45 +02:00
|
|
|
; /* Do nothing */
|
2005-04-21 21:56:37 +02:00
|
|
|
|
|
|
|
} else { /* Status URB */
|
|
|
|
if (!hcd->uses_new_polling)
|
2006-08-11 22:01:45 +02:00
|
|
|
del_timer (&hcd->rh_timer);
|
2005-04-21 21:56:37 +02:00
|
|
|
if (urb == hcd->status_urb) {
|
|
|
|
hcd->status_urb = NULL;
|
2007-08-08 17:48:02 +02:00
|
|
|
usb_hcd_unlink_urb_from_ep(hcd, urb);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-02 21:05:45 +02:00
|
|
|
spin_unlock(&hcd_root_hub_lock);
|
2007-08-24 21:42:24 +02:00
|
|
|
usb_hcd_giveback_urb(hcd, urb, status);
|
2007-08-02 21:05:45 +02:00
|
|
|
spin_lock(&hcd_root_hub_lock);
|
|
|
|
}
|
|
|
|
}
|
2007-08-08 17:48:02 +02:00
|
|
|
done:
|
2007-08-02 21:05:45 +02:00
|
|
|
spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
|
2007-08-08 17:48:02 +02:00
|
|
|
return rc;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-08-01 05:33:58 +02:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Show & store the current value of authorized_default
|
|
|
|
*/
|
|
|
|
static ssize_t usb_host_authorized_default_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct usb_device *rh_usb_dev = to_usb_device(dev);
|
|
|
|
struct usb_bus *usb_bus = rh_usb_dev->bus;
|
|
|
|
struct usb_hcd *usb_hcd;
|
|
|
|
|
|
|
|
if (usb_bus == NULL) /* FIXME: not sure if this case is possible */
|
|
|
|
return -ENODEV;
|
|
|
|
usb_hcd = bus_to_hcd(usb_bus);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%u\n", usb_hcd->authorized_default);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t usb_host_authorized_default_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t size)
|
|
|
|
{
|
|
|
|
ssize_t result;
|
|
|
|
unsigned val;
|
|
|
|
struct usb_device *rh_usb_dev = to_usb_device(dev);
|
|
|
|
struct usb_bus *usb_bus = rh_usb_dev->bus;
|
|
|
|
struct usb_hcd *usb_hcd;
|
|
|
|
|
|
|
|
if (usb_bus == NULL) /* FIXME: not sure if this case is possible */
|
|
|
|
return -ENODEV;
|
|
|
|
usb_hcd = bus_to_hcd(usb_bus);
|
|
|
|
result = sscanf(buf, "%u\n", &val);
|
|
|
|
if (result == 1) {
|
|
|
|
usb_hcd->authorized_default = val? 1 : 0;
|
|
|
|
result = size;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
result = -EINVAL;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(authorized_default, 0644,
|
|
|
|
usb_host_authorized_default_show,
|
|
|
|
usb_host_authorized_default_store);
|
|
|
|
|
|
|
|
|
|
|
|
/* Group all the USB bus attributes */
|
|
|
|
static struct attribute *usb_bus_attrs[] = {
|
|
|
|
&dev_attr_authorized_default.attr,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group usb_bus_attr_group = {
|
|
|
|
.name = NULL, /* we want them in the same directory */
|
|
|
|
.attrs = usb_bus_attrs,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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->busnum = -1;
|
|
|
|
bus->bandwidth_allocated = 0;
|
|
|
|
bus->bandwidth_int_reqs = 0;
|
|
|
|
bus->bandwidth_isoc_reqs = 0;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD (&bus->bus_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2007-08-01 05:33:59 +02:00
|
|
|
int result = -E2BIG;
|
2005-04-17 00:20:36 +02:00
|
|
|
int busnum;
|
|
|
|
|
2006-01-11 15:55:29 +01:00
|
|
|
mutex_lock(&usb_bus_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1);
|
2007-08-01 05:33:59 +02:00
|
|
|
if (busnum >= USB_MAXBUS) {
|
2005-04-17 00:20:36 +02:00
|
|
|
printk (KERN_ERR "%s: too many buses\n", usbcore_name);
|
2007-08-01 05:33:59 +02:00
|
|
|
goto error_find_busnum;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2007-08-01 05:33:59 +02:00
|
|
|
set_bit (busnum, busmap.busmap);
|
|
|
|
bus->busnum = busnum;
|
2007-09-11 23:07:31 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Add it to the local list of buses */
|
|
|
|
list_add (&bus->bus_list, &usb_bus_list);
|
2006-01-11 15:55:29 +01:00
|
|
|
mutex_unlock(&usb_bus_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-06-21 06:15:16 +02:00
|
|
|
usb_notify_add_bus(bus);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-01 05:33:59 +02:00
|
|
|
dev_info (bus->controller, "new USB bus registered, assigned bus "
|
|
|
|
"number %d\n", bus->busnum);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
2007-08-01 05:33:59 +02:00
|
|
|
|
|
|
|
error_find_busnum:
|
|
|
|
mutex_unlock(&usb_bus_list_lock);
|
|
|
|
return result;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*/
|
2006-01-11 15:55:29 +01:00
|
|
|
mutex_lock(&usb_bus_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
list_del (&bus->bus_list);
|
2006-01-11 15:55:29 +01:00
|
|
|
mutex_unlock(&usb_bus_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-06-21 06:15:16 +02:00
|
|
|
usb_notify_remove_bus(bus);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
clear_bit (bus->busnum, busmap.busmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2005-04-25 17:25:17 +02:00
|
|
|
* register_root_hub - called by usb_add_hcd() to register a root hub
|
2005-04-17 00:20:36 +02:00
|
|
|
* @hcd: host controller for this root hub
|
|
|
|
*
|
2005-04-25 17:25:17 +02:00
|
|
|
* This function registers the root hub with the USB subsystem. It sets up
|
2006-01-24 00:25:40 +01:00
|
|
|
* the device properly in the device tree and then calls usb_new_device()
|
|
|
|
* to register the usb device. It also assigns the root hub's USB address
|
|
|
|
* (always 1).
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2006-01-24 00:25:40 +01:00
|
|
|
static int register_root_hub(struct usb_hcd *hcd)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct device *parent_dev = hcd->self.controller;
|
2006-01-24 00:25:40 +01:00
|
|
|
struct usb_device *usb_dev = hcd->self.root_hub;
|
2005-04-17 00:20:36 +02:00
|
|
|
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);
|
|
|
|
|
2006-01-11 15:55:29 +01:00
|
|
|
mutex_lock(&usb_bus_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-02-11 23:11:36 +01:00
|
|
|
usb_dev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
|
2005-04-17 00:20:36 +02:00
|
|
|
retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE);
|
|
|
|
if (retval != sizeof usb_dev->descriptor) {
|
2006-01-11 15:55:29 +01:00
|
|
|
mutex_unlock(&usb_bus_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
dev_dbg (parent_dev, "can't read %s device descriptor %d\n",
|
2008-05-02 06:02:41 +02:00
|
|
|
dev_name(&usb_dev->dev), retval);
|
2005-04-17 00:20:36 +02:00
|
|
|
return (retval < 0) ? retval : -EMSGSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
retval = usb_new_device (usb_dev);
|
|
|
|
if (retval) {
|
|
|
|
dev_err (parent_dev, "can't register root hub for %s, %d\n",
|
2008-05-02 06:02:41 +02:00
|
|
|
dev_name(&usb_dev->dev), retval);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-01-11 15:55:29 +01:00
|
|
|
mutex_unlock(&usb_bus_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
2005-07-29 21:18:28 +02:00
|
|
|
tmp = HS_NSECS_ISO (bytecount);
|
2005-04-17 00:20:36 +02:00
|
|
|
else
|
2005-07-29 21:18:28 +02:00
|
|
|
tmp = HS_NSECS (bytecount);
|
2005-04-17 00:20:36 +02:00
|
|
|
return tmp;
|
|
|
|
default:
|
|
|
|
pr_debug ("%s: bogus device speed!\n", usbcore_name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2008-01-25 18:12:21 +01:00
|
|
|
EXPORT_SYMBOL_GPL(usb_calc_bus_time);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Generic HC operations.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2007-08-08 17:48:02 +02:00
|
|
|
/**
|
|
|
|
* usb_hcd_link_urb_to_ep - add an URB to its endpoint queue
|
|
|
|
* @hcd: host controller to which @urb was submitted
|
|
|
|
* @urb: URB being submitted
|
|
|
|
*
|
|
|
|
* Host controller drivers should call this routine in their enqueue()
|
|
|
|
* method. The HCD's private spinlock must be held and interrupts must
|
|
|
|
* be disabled. The actions carried out here are required for URB
|
|
|
|
* submission, as well as for endpoint shutdown and for usb_kill_urb.
|
|
|
|
*
|
|
|
|
* Returns 0 for no error, otherwise a negative error code (in which case
|
|
|
|
* the enqueue() method must fail). If no error occurs but enqueue() fails
|
|
|
|
* anyway, it must call usb_hcd_unlink_urb_from_ep() before releasing
|
|
|
|
* the private spinlock and returning.
|
|
|
|
*/
|
|
|
|
int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-08-02 21:06:54 +02:00
|
|
|
int rc = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-08 17:48:02 +02:00
|
|
|
spin_lock(&hcd_urb_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-02 21:06:54 +02:00
|
|
|
/* Check that the URB isn't being killed */
|
2008-12-12 14:38:45 +01:00
|
|
|
if (unlikely(atomic_read(&urb->reject))) {
|
2007-08-02 21:06:54 +02:00
|
|
|
rc = -EPERM;
|
|
|
|
goto done;
|
2007-06-08 22:37:49 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-02 21:06:54 +02:00
|
|
|
if (unlikely(!urb->ep->enabled)) {
|
|
|
|
rc = -ENOENT;
|
|
|
|
goto done;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-09-10 17:34:26 +02:00
|
|
|
if (unlikely(!urb->dev->can_submit)) {
|
|
|
|
rc = -EHOSTUNREACH;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
2007-08-02 21:06:54 +02:00
|
|
|
* Check the host controller's state and add the URB to the
|
|
|
|
* endpoint's queue.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2007-08-02 21:06:54 +02:00
|
|
|
switch (hcd->state) {
|
2005-04-17 00:20:36 +02:00
|
|
|
case HC_STATE_RUNNING:
|
|
|
|
case HC_STATE_RESUMING:
|
2007-08-21 21:40:36 +02:00
|
|
|
urb->unlinked = 0;
|
2007-08-02 21:06:54 +02:00
|
|
|
list_add_tail(&urb->urb_list, &urb->ep->urb_list);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
default:
|
2007-08-02 21:06:54 +02:00
|
|
|
rc = -ESHUTDOWN;
|
|
|
|
goto done;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2007-08-02 21:06:54 +02:00
|
|
|
done:
|
2007-08-08 17:48:02 +02:00
|
|
|
spin_unlock(&hcd_urb_list_lock);
|
2007-08-02 21:06:54 +02:00
|
|
|
return rc;
|
|
|
|
}
|
2007-08-08 17:48:02 +02:00
|
|
|
EXPORT_SYMBOL_GPL(usb_hcd_link_urb_to_ep);
|
2007-08-02 21:06:54 +02:00
|
|
|
|
2007-08-08 17:48:02 +02:00
|
|
|
/**
|
|
|
|
* usb_hcd_check_unlink_urb - check whether an URB may be unlinked
|
|
|
|
* @hcd: host controller to which @urb was submitted
|
|
|
|
* @urb: URB being checked for unlinkability
|
|
|
|
* @status: error code to store in @urb if the unlink succeeds
|
|
|
|
*
|
|
|
|
* Host controller drivers should call this routine in their dequeue()
|
|
|
|
* method. The HCD's private spinlock must be held and interrupts must
|
|
|
|
* be disabled. The actions carried out here are required for making
|
|
|
|
* sure than an unlink is valid.
|
|
|
|
*
|
|
|
|
* Returns 0 for no error, otherwise a negative error code (in which case
|
|
|
|
* the dequeue() method must fail). The possible error codes are:
|
|
|
|
*
|
|
|
|
* -EIDRM: @urb was not submitted or has already completed.
|
|
|
|
* The completion function may not have been called yet.
|
|
|
|
*
|
|
|
|
* -EBUSY: @urb has already been unlinked.
|
|
|
|
*/
|
|
|
|
int usb_hcd_check_unlink_urb(struct usb_hcd *hcd, struct urb *urb,
|
2007-08-02 21:06:54 +02:00
|
|
|
int status)
|
|
|
|
{
|
|
|
|
struct list_head *tmp;
|
|
|
|
|
|
|
|
/* insist the urb is still queued */
|
|
|
|
list_for_each(tmp, &urb->ep->urb_list) {
|
|
|
|
if (tmp == &urb->urb_list)
|
|
|
|
break;
|
|
|
|
}
|
2007-08-08 17:48:02 +02:00
|
|
|
if (tmp != &urb->urb_list)
|
|
|
|
return -EIDRM;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-02 21:06:54 +02:00
|
|
|
/* Any status except -EINPROGRESS means something already started to
|
|
|
|
* unlink this URB from the hardware. So there's no more work to do.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2007-08-21 21:40:36 +02:00
|
|
|
if (urb->unlinked)
|
2007-08-08 17:48:02 +02:00
|
|
|
return -EBUSY;
|
2007-08-21 21:40:36 +02:00
|
|
|
urb->unlinked = status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-02 21:06:54 +02:00
|
|
|
/* 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.
|
|
|
|
*/
|
2010-06-22 22:39:10 +02:00
|
|
|
if (!HCD_SAW_IRQ(hcd) && !is_root_hub(urb->dev)) {
|
2007-08-02 21:06:54 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2007-08-08 17:48:02 +02:00
|
|
|
return 0;
|
2007-08-02 21:06:54 +02:00
|
|
|
}
|
2007-08-08 17:48:02 +02:00
|
|
|
EXPORT_SYMBOL_GPL(usb_hcd_check_unlink_urb);
|
2007-08-02 21:06:54 +02:00
|
|
|
|
2007-08-08 17:48:02 +02:00
|
|
|
/**
|
|
|
|
* usb_hcd_unlink_urb_from_ep - remove an URB from its endpoint queue
|
|
|
|
* @hcd: host controller to which @urb was submitted
|
|
|
|
* @urb: URB being unlinked
|
|
|
|
*
|
|
|
|
* Host controller drivers should call this routine before calling
|
|
|
|
* usb_hcd_giveback_urb(). The HCD's private spinlock must be held and
|
|
|
|
* interrupts must be disabled. The actions carried out here are required
|
|
|
|
* for URB completion.
|
|
|
|
*/
|
|
|
|
void usb_hcd_unlink_urb_from_ep(struct usb_hcd *hcd, struct urb *urb)
|
2007-08-02 21:06:54 +02:00
|
|
|
{
|
|
|
|
/* clear all state linking urb to this dev (and hcd) */
|
2007-08-08 17:48:02 +02:00
|
|
|
spin_lock(&hcd_urb_list_lock);
|
2007-08-02 21:06:54 +02:00
|
|
|
list_del_init(&urb->urb_list);
|
2007-08-08 17:48:02 +02:00
|
|
|
spin_unlock(&hcd_urb_list_lock);
|
2007-08-02 21:06:54 +02:00
|
|
|
}
|
2007-08-08 17:48:02 +02:00
|
|
|
EXPORT_SYMBOL_GPL(usb_hcd_unlink_urb_from_ep);
|
2007-08-02 21:06:54 +02:00
|
|
|
|
2008-01-23 07:58:35 +01:00
|
|
|
/*
|
|
|
|
* Some usb host controllers can only perform dma using a small SRAM area.
|
|
|
|
* The usb core itself is however optimized for host controllers that can dma
|
|
|
|
* using regular system memory - like pci devices doing bus mastering.
|
|
|
|
*
|
|
|
|
* To support host controllers with limited dma capabilites we provide dma
|
|
|
|
* bounce buffers. This feature can be enabled using the HCD_LOCAL_MEM flag.
|
|
|
|
* For this to work properly the host controller code must first use the
|
|
|
|
* function dma_declare_coherent_memory() to point out which memory area
|
|
|
|
* that should be used for dma allocations.
|
|
|
|
*
|
|
|
|
* The HCD_LOCAL_MEM flag then tells the usb code to allocate all data for
|
|
|
|
* dma using dma_alloc_coherent() which in turn allocates from the memory
|
|
|
|
* area pointed out with dma_declare_coherent_memory().
|
|
|
|
*
|
|
|
|
* So, to summarize...
|
|
|
|
*
|
|
|
|
* - We need "local" memory, canonical example being
|
|
|
|
* a small SRAM on a discrete controller being the
|
|
|
|
* only memory that the controller can read ...
|
|
|
|
* (a) "normal" kernel memory is no good, and
|
|
|
|
* (b) there's not enough to share
|
|
|
|
*
|
|
|
|
* - The only *portable* hook for such stuff in the
|
|
|
|
* DMA framework is dma_declare_coherent_memory()
|
|
|
|
*
|
|
|
|
* - So we use that, even though the primary requirement
|
|
|
|
* is that the memory be "local" (hence addressible
|
|
|
|
* by that device), not "coherent".
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int hcd_alloc_coherent(struct usb_bus *bus,
|
|
|
|
gfp_t mem_flags, dma_addr_t *dma_handle,
|
|
|
|
void **vaddr_handle, size_t size,
|
|
|
|
enum dma_data_direction dir)
|
|
|
|
{
|
|
|
|
unsigned char *vaddr;
|
|
|
|
|
2010-06-28 16:56:45 +02:00
|
|
|
if (*vaddr_handle == NULL) {
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
2008-01-23 07:58:35 +01:00
|
|
|
vaddr = hcd_buffer_alloc(bus, size + sizeof(vaddr),
|
|
|
|
mem_flags, dma_handle);
|
|
|
|
if (!vaddr)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Store the virtual address of the buffer at the end
|
|
|
|
* of the allocated dma buffer. The size of the buffer
|
|
|
|
* may be uneven so use unaligned functions instead
|
|
|
|
* of just rounding up. It makes sense to optimize for
|
|
|
|
* memory footprint over access speed since the amount
|
|
|
|
* of memory available for dma may be limited.
|
|
|
|
*/
|
|
|
|
put_unaligned((unsigned long)*vaddr_handle,
|
|
|
|
(unsigned long *)(vaddr + size));
|
|
|
|
|
|
|
|
if (dir == DMA_TO_DEVICE)
|
|
|
|
memcpy(vaddr, *vaddr_handle, size);
|
|
|
|
|
|
|
|
*vaddr_handle = vaddr;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hcd_free_coherent(struct usb_bus *bus, dma_addr_t *dma_handle,
|
|
|
|
void **vaddr_handle, size_t size,
|
|
|
|
enum dma_data_direction dir)
|
|
|
|
{
|
|
|
|
unsigned char *vaddr = *vaddr_handle;
|
|
|
|
|
|
|
|
vaddr = (void *)get_unaligned((unsigned long *)(vaddr + size));
|
|
|
|
|
|
|
|
if (dir == DMA_FROM_DEVICE)
|
|
|
|
memcpy(vaddr, *vaddr_handle, size);
|
|
|
|
|
|
|
|
hcd_buffer_free(bus, size + sizeof(vaddr), *vaddr_handle, *dma_handle);
|
|
|
|
|
|
|
|
*vaddr_handle = vaddr;
|
|
|
|
*dma_handle = 0;
|
|
|
|
}
|
|
|
|
|
2010-04-02 19:27:28 +02:00
|
|
|
static void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
|
|
|
|
{
|
|
|
|
enum dma_data_direction dir;
|
|
|
|
|
|
|
|
if (urb->transfer_flags & URB_SETUP_MAP_SINGLE)
|
|
|
|
dma_unmap_single(hcd->self.controller,
|
|
|
|
urb->setup_dma,
|
|
|
|
sizeof(struct usb_ctrlrequest),
|
|
|
|
DMA_TO_DEVICE);
|
|
|
|
else if (urb->transfer_flags & URB_SETUP_MAP_LOCAL)
|
|
|
|
hcd_free_coherent(urb->dev->bus,
|
|
|
|
&urb->setup_dma,
|
|
|
|
(void **) &urb->setup_packet,
|
|
|
|
sizeof(struct usb_ctrlrequest),
|
|
|
|
DMA_TO_DEVICE);
|
|
|
|
|
|
|
|
dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
|
|
|
|
if (urb->transfer_flags & URB_DMA_MAP_SG)
|
|
|
|
dma_unmap_sg(hcd->self.controller,
|
2010-05-01 20:20:01 +02:00
|
|
|
urb->sg,
|
2010-04-02 19:27:28 +02:00
|
|
|
urb->num_sgs,
|
|
|
|
dir);
|
|
|
|
else if (urb->transfer_flags & URB_DMA_MAP_PAGE)
|
|
|
|
dma_unmap_page(hcd->self.controller,
|
|
|
|
urb->transfer_dma,
|
|
|
|
urb->transfer_buffer_length,
|
|
|
|
dir);
|
|
|
|
else if (urb->transfer_flags & URB_DMA_MAP_SINGLE)
|
|
|
|
dma_unmap_single(hcd->self.controller,
|
|
|
|
urb->transfer_dma,
|
|
|
|
urb->transfer_buffer_length,
|
|
|
|
dir);
|
|
|
|
else if (urb->transfer_flags & URB_MAP_LOCAL)
|
|
|
|
hcd_free_coherent(urb->dev->bus,
|
|
|
|
&urb->transfer_dma,
|
|
|
|
&urb->transfer_buffer,
|
|
|
|
urb->transfer_buffer_length,
|
|
|
|
dir);
|
|
|
|
|
|
|
|
/* Make it safe to call this routine more than once */
|
|
|
|
urb->transfer_flags &= ~(URB_SETUP_MAP_SINGLE | URB_SETUP_MAP_LOCAL |
|
|
|
|
URB_DMA_MAP_SG | URB_DMA_MAP_PAGE |
|
|
|
|
URB_DMA_MAP_SINGLE | URB_MAP_LOCAL);
|
|
|
|
}
|
|
|
|
|
2008-01-23 07:58:35 +01:00
|
|
|
static int map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
|
|
|
|
gfp_t mem_flags)
|
2007-08-02 21:06:54 +02:00
|
|
|
{
|
2008-01-23 07:58:35 +01:00
|
|
|
enum dma_data_direction dir;
|
|
|
|
int ret = 0;
|
|
|
|
|
2007-08-02 21:06:54 +02:00
|
|
|
/* Map the URB's buffers for DMA access.
|
|
|
|
* Lower level HCD code should use *_dma exclusively,
|
2009-04-28 04:59:01 +02:00
|
|
|
* unless it uses pio or talks to another transport,
|
|
|
|
* or uses the provided scatter gather list for bulk.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2008-01-23 07:58:35 +01:00
|
|
|
|
2010-04-30 22:35:37 +02:00
|
|
|
if (usb_endpoint_xfer_control(&urb->ep->desc)) {
|
2009-11-05 17:37:03 +01:00
|
|
|
if (hcd->self.uses_dma) {
|
2008-01-23 07:58:35 +01:00
|
|
|
urb->setup_dma = dma_map_single(
|
2005-04-17 00:20:36 +02:00
|
|
|
hcd->self.controller,
|
|
|
|
urb->setup_packet,
|
2008-01-23 07:58:35 +01:00
|
|
|
sizeof(struct usb_ctrlrequest),
|
2005-04-17 00:20:36 +02:00
|
|
|
DMA_TO_DEVICE);
|
2009-11-05 17:37:03 +01:00
|
|
|
if (dma_mapping_error(hcd->self.controller,
|
|
|
|
urb->setup_dma))
|
|
|
|
return -EAGAIN;
|
2010-04-02 19:27:28 +02:00
|
|
|
urb->transfer_flags |= URB_SETUP_MAP_SINGLE;
|
2010-05-12 17:38:12 +02:00
|
|
|
} else if (hcd->driver->flags & HCD_LOCAL_MEM) {
|
2008-01-23 07:58:35 +01:00
|
|
|
ret = hcd_alloc_coherent(
|
|
|
|
urb->dev->bus, mem_flags,
|
|
|
|
&urb->setup_dma,
|
|
|
|
(void **)&urb->setup_packet,
|
|
|
|
sizeof(struct usb_ctrlrequest),
|
|
|
|
DMA_TO_DEVICE);
|
2010-04-02 19:27:28 +02:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
urb->transfer_flags |= URB_SETUP_MAP_LOCAL;
|
2010-05-12 17:38:12 +02:00
|
|
|
}
|
2008-01-23 07:58:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
|
2010-04-02 19:27:28 +02:00
|
|
|
if (urb->transfer_buffer_length != 0
|
2008-01-23 07:58:35 +01:00
|
|
|
&& !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) {
|
2009-11-05 17:37:03 +01:00
|
|
|
if (hcd->self.uses_dma) {
|
2010-04-02 19:27:28 +02:00
|
|
|
if (urb->num_sgs) {
|
|
|
|
int n = dma_map_sg(
|
|
|
|
hcd->self.controller,
|
2010-05-01 20:20:01 +02:00
|
|
|
urb->sg,
|
2010-04-02 19:27:28 +02:00
|
|
|
urb->num_sgs,
|
|
|
|
dir);
|
|
|
|
if (n <= 0)
|
|
|
|
ret = -EAGAIN;
|
|
|
|
else
|
|
|
|
urb->transfer_flags |= URB_DMA_MAP_SG;
|
|
|
|
if (n != urb->num_sgs) {
|
|
|
|
urb->num_sgs = n;
|
|
|
|
urb->transfer_flags |=
|
|
|
|
URB_DMA_SG_COMBINED;
|
|
|
|
}
|
|
|
|
} else if (urb->sg) {
|
2010-05-01 20:20:01 +02:00
|
|
|
struct scatterlist *sg = urb->sg;
|
2010-04-02 19:27:28 +02:00
|
|
|
urb->transfer_dma = dma_map_page(
|
|
|
|
hcd->self.controller,
|
|
|
|
sg_page(sg),
|
|
|
|
sg->offset,
|
|
|
|
urb->transfer_buffer_length,
|
|
|
|
dir);
|
|
|
|
if (dma_mapping_error(hcd->self.controller,
|
2009-11-05 17:37:03 +01:00
|
|
|
urb->transfer_dma))
|
2010-04-02 19:27:28 +02:00
|
|
|
ret = -EAGAIN;
|
|
|
|
else
|
|
|
|
urb->transfer_flags |= URB_DMA_MAP_PAGE;
|
|
|
|
} else {
|
|
|
|
urb->transfer_dma = dma_map_single(
|
|
|
|
hcd->self.controller,
|
|
|
|
urb->transfer_buffer,
|
|
|
|
urb->transfer_buffer_length,
|
|
|
|
dir);
|
|
|
|
if (dma_mapping_error(hcd->self.controller,
|
|
|
|
urb->transfer_dma))
|
|
|
|
ret = -EAGAIN;
|
|
|
|
else
|
|
|
|
urb->transfer_flags |= URB_DMA_MAP_SINGLE;
|
|
|
|
}
|
2009-11-05 17:37:03 +01:00
|
|
|
} else if (hcd->driver->flags & HCD_LOCAL_MEM) {
|
2008-01-23 07:58:35 +01:00
|
|
|
ret = hcd_alloc_coherent(
|
|
|
|
urb->dev->bus, mem_flags,
|
|
|
|
&urb->transfer_dma,
|
|
|
|
&urb->transfer_buffer,
|
|
|
|
urb->transfer_buffer_length,
|
|
|
|
dir);
|
2010-04-02 19:27:28 +02:00
|
|
|
if (ret == 0)
|
|
|
|
urb->transfer_flags |= URB_MAP_LOCAL;
|
2008-01-23 07:58:35 +01:00
|
|
|
}
|
2010-04-02 19:27:28 +02:00
|
|
|
if (ret && (urb->transfer_flags & (URB_SETUP_MAP_SINGLE |
|
|
|
|
URB_SETUP_MAP_LOCAL)))
|
|
|
|
unmap_urb_for_dma(hcd, urb);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-01-23 07:58:35 +01:00
|
|
|
return ret;
|
2007-08-02 21:06:54 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-02 21:06:54 +02:00
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* 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
|
|
|
|
*/
|
|
|
|
int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
struct usb_hcd *hcd = bus_to_hcd(urb->dev->bus);
|
|
|
|
|
|
|
|
/* increment urb's reference count as part of giving it to the HCD
|
|
|
|
* (which will control it). HCD guarantees that it either returns
|
|
|
|
* an error or calls giveback(), but not both.
|
|
|
|
*/
|
|
|
|
usb_get_urb(urb);
|
|
|
|
atomic_inc(&urb->use_count);
|
2007-10-03 23:56:03 +02:00
|
|
|
atomic_inc(&urb->dev->urbnum);
|
2007-08-02 21:06:54 +02:00
|
|
|
usbmon_urb_submit(&hcd->self, urb);
|
|
|
|
|
|
|
|
/* NOTE requirements on root-hub callers (usbfs and the hub
|
|
|
|
* driver, for now): URBs' urb->transfer_buffer must be
|
|
|
|
* valid and usb_buffer_{sync,unmap}() not be needed, since
|
|
|
|
* they could clobber root hub response data. Also, control
|
|
|
|
* URBs must be submitted in process context with interrupts
|
|
|
|
* enabled.
|
|
|
|
*/
|
2008-01-23 07:58:35 +01:00
|
|
|
|
2010-04-02 19:27:28 +02:00
|
|
|
if (is_root_hub(urb->dev)) {
|
2007-08-08 17:48:02 +02:00
|
|
|
status = rh_urb_enqueue(hcd, urb);
|
2010-04-02 19:27:28 +02:00
|
|
|
} else {
|
|
|
|
status = map_urb_for_dma(hcd, urb, mem_flags);
|
|
|
|
if (likely(status == 0)) {
|
|
|
|
status = hcd->driver->urb_enqueue(hcd, urb, mem_flags);
|
|
|
|
if (unlikely(status))
|
|
|
|
unmap_urb_for_dma(hcd, urb);
|
|
|
|
}
|
|
|
|
}
|
2007-08-02 21:06:54 +02:00
|
|
|
|
|
|
|
if (unlikely(status)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
usbmon_urb_submit_error(&hcd->self, urb, status);
|
2007-08-21 21:39:21 +02:00
|
|
|
urb->hcpriv = NULL;
|
2007-08-02 21:06:54 +02:00
|
|
|
INIT_LIST_HEAD(&urb->urb_list);
|
|
|
|
atomic_dec(&urb->use_count);
|
2007-10-03 23:56:03 +02:00
|
|
|
atomic_dec(&urb->dev->urbnum);
|
2008-12-12 14:38:45 +01:00
|
|
|
if (atomic_read(&urb->reject))
|
2007-08-02 21:06:54 +02:00
|
|
|
wake_up(&usb_kill_urb_queue);
|
|
|
|
usb_put_urb(urb);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* 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.
|
|
|
|
*/
|
2007-08-08 17:48:02 +02:00
|
|
|
static int unlink1(struct usb_hcd *hcd, struct urb *urb, int status)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int value;
|
|
|
|
|
2007-07-18 18:14:24 +02:00
|
|
|
if (is_root_hub(urb->dev))
|
2007-08-08 17:48:02 +02:00
|
|
|
value = usb_rh_urb_dequeue(hcd, urb, status);
|
2005-04-17 00:20:36 +02:00
|
|
|
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. */
|
2007-08-08 17:48:02 +02:00
|
|
|
value = hcd->driver->urb_dequeue(hcd, urb, status);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* called in any context
|
|
|
|
*
|
|
|
|
* caller guarantees urb won't be recycled till both unlink()
|
|
|
|
* and the urb's completion function return
|
|
|
|
*/
|
2006-08-30 17:27:36 +02:00
|
|
|
int usb_hcd_unlink_urb (struct urb *urb, int status)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-08-02 21:06:54 +02:00
|
|
|
struct usb_hcd *hcd;
|
2008-10-21 21:28:46 +02:00
|
|
|
int retval = -EIDRM;
|
|
|
|
unsigned long flags;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-10-21 21:28:46 +02:00
|
|
|
/* Prevent the device and bus from going away while
|
|
|
|
* the unlink is carried out. If they are already gone
|
|
|
|
* then urb->use_count must be 0, since disconnected
|
|
|
|
* devices can't have any active URBs.
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&hcd_urb_unlink_lock, flags);
|
|
|
|
if (atomic_read(&urb->use_count) > 0) {
|
|
|
|
retval = 0;
|
|
|
|
usb_get_dev(urb->dev);
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&hcd_urb_unlink_lock, flags);
|
|
|
|
if (retval == 0) {
|
|
|
|
hcd = bus_to_hcd(urb->dev->bus);
|
|
|
|
retval = unlink1(hcd, urb, status);
|
|
|
|
usb_put_dev(urb->dev);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (retval == 0)
|
|
|
|
retval = -EINPROGRESS;
|
2007-08-08 17:48:02 +02:00
|
|
|
else if (retval != -EIDRM && retval != -EBUSY)
|
2007-08-02 21:06:54 +02:00
|
|
|
dev_dbg(&urb->dev->dev, "hcd_unlink_urb %p fail %d\n",
|
|
|
|
urb, retval);
|
2005-04-17 00:20:36 +02:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2007-07-18 18:08:02 +02:00
|
|
|
/**
|
|
|
|
* 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.
|
2007-08-24 21:42:24 +02:00
|
|
|
* @status: completion status code for the URB.
|
2007-07-18 18:08:02 +02:00
|
|
|
* 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.
|
2007-08-21 21:40:36 +02:00
|
|
|
*
|
2007-08-24 21:42:24 +02:00
|
|
|
* If @urb was unlinked, the value of @status will be overridden by
|
2007-08-21 21:40:36 +02:00
|
|
|
* @urb->unlinked. Erroneous short transfers are detected in case
|
|
|
|
* the HCD hasn't checked for them.
|
2007-07-18 18:08:02 +02:00
|
|
|
*/
|
2007-08-24 21:42:24 +02:00
|
|
|
void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb, int status)
|
2007-07-18 18:08:02 +02:00
|
|
|
{
|
2007-08-21 21:39:21 +02:00
|
|
|
urb->hcpriv = NULL;
|
2007-08-21 21:40:36 +02:00
|
|
|
if (unlikely(urb->unlinked))
|
2007-08-24 21:42:24 +02:00
|
|
|
status = urb->unlinked;
|
2007-08-21 21:40:36 +02:00
|
|
|
else if (unlikely((urb->transfer_flags & URB_SHORT_NOT_OK) &&
|
2007-08-21 21:39:21 +02:00
|
|
|
urb->actual_length < urb->transfer_buffer_length &&
|
2007-08-24 21:42:24 +02:00
|
|
|
!status))
|
|
|
|
status = -EREMOTEIO;
|
2007-07-18 18:08:02 +02:00
|
|
|
|
2007-08-22 19:06:53 +02:00
|
|
|
unmap_urb_for_dma(hcd, urb);
|
2007-08-24 21:42:24 +02:00
|
|
|
usbmon_urb_complete(&hcd->self, urb, status);
|
2007-08-22 19:06:53 +02:00
|
|
|
usb_unanchor_urb(urb);
|
|
|
|
|
2007-07-18 18:08:02 +02:00
|
|
|
/* pass ownership to the completion handler */
|
2007-08-24 21:42:24 +02:00
|
|
|
urb->status = status;
|
2007-07-18 18:08:02 +02:00
|
|
|
urb->complete (urb);
|
|
|
|
atomic_dec (&urb->use_count);
|
2008-12-12 14:38:45 +01:00
|
|
|
if (unlikely(atomic_read(&urb->reject)))
|
2007-07-18 18:08:02 +02:00
|
|
|
wake_up (&usb_kill_urb_queue);
|
|
|
|
usb_put_urb (urb);
|
|
|
|
}
|
2008-01-25 18:12:21 +01:00
|
|
|
EXPORT_SYMBOL_GPL(usb_hcd_giveback_urb);
|
2007-07-18 18:08:02 +02:00
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2007-09-10 17:33:05 +02:00
|
|
|
/* Cancel all URBs pending on this endpoint and wait for the endpoint's
|
|
|
|
* queue to drain completely. The caller must first insure that no more
|
|
|
|
* URBs can be submitted for this endpoint.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2007-09-10 17:33:05 +02:00
|
|
|
void usb_hcd_flush_endpoint(struct usb_device *udev,
|
2006-08-30 17:27:36 +02:00
|
|
|
struct usb_host_endpoint *ep)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct usb_hcd *hcd;
|
|
|
|
struct urb *urb;
|
|
|
|
|
2007-09-10 17:33:05 +02:00
|
|
|
if (!ep)
|
|
|
|
return;
|
2007-08-02 21:06:54 +02:00
|
|
|
might_sleep();
|
2006-08-30 17:32:52 +02:00
|
|
|
hcd = bus_to_hcd(udev->bus);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-09-10 17:33:05 +02:00
|
|
|
/* No more submits can occur */
|
2007-08-02 21:06:54 +02:00
|
|
|
spin_lock_irq(&hcd_urb_list_lock);
|
2007-11-22 00:13:10 +01:00
|
|
|
rescan:
|
2005-04-17 00:20:36 +02:00
|
|
|
list_for_each_entry (urb, &ep->urb_list, urb_list) {
|
2007-07-30 23:07:21 +02:00
|
|
|
int is_in;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-21 21:40:36 +02:00
|
|
|
if (urb->unlinked)
|
2005-04-17 00:20:36 +02:00
|
|
|
continue;
|
|
|
|
usb_get_urb (urb);
|
2007-07-30 23:07:21 +02:00
|
|
|
is_in = usb_urb_dir_in(urb);
|
2007-07-18 18:14:24 +02:00
|
|
|
spin_unlock(&hcd_urb_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-08-08 17:48:02 +02:00
|
|
|
/* kick hcd */
|
|
|
|
unlink1(hcd, urb, -ESHUTDOWN);
|
|
|
|
dev_dbg (hcd->self.controller,
|
|
|
|
"shutdown urb %p ep%d%s%s\n",
|
|
|
|
urb, usb_endpoint_num(&ep->desc),
|
|
|
|
is_in ? "in" : "out",
|
|
|
|
({ char *s;
|
|
|
|
|
|
|
|
switch (usb_endpoint_type(&ep->desc)) {
|
|
|
|
case USB_ENDPOINT_XFER_CONTROL:
|
|
|
|
s = ""; break;
|
|
|
|
case USB_ENDPOINT_XFER_BULK:
|
|
|
|
s = "-bulk"; break;
|
|
|
|
case USB_ENDPOINT_XFER_INT:
|
|
|
|
s = "-intr"; break;
|
|
|
|
default:
|
|
|
|
s = "-iso"; break;
|
|
|
|
};
|
|
|
|
s;
|
|
|
|
}));
|
2005-04-17 00:20:36 +02:00
|
|
|
usb_put_urb (urb);
|
|
|
|
|
|
|
|
/* list contents may have changed */
|
2007-11-22 00:13:10 +01:00
|
|
|
spin_lock(&hcd_urb_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
goto rescan;
|
|
|
|
}
|
2007-08-02 21:06:54 +02:00
|
|
|
spin_unlock_irq(&hcd_urb_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-09-10 17:33:05 +02:00
|
|
|
/* Wait until the endpoint queue is completely empty */
|
2006-08-11 22:01:45 +02:00
|
|
|
while (!list_empty (&ep->urb_list)) {
|
2007-07-18 18:14:24 +02:00
|
|
|
spin_lock_irq(&hcd_urb_list_lock);
|
2006-08-11 22:01:45 +02:00
|
|
|
|
|
|
|
/* The list may have changed while we acquired the spinlock */
|
|
|
|
urb = NULL;
|
|
|
|
if (!list_empty (&ep->urb_list)) {
|
|
|
|
urb = list_entry (ep->urb_list.prev, struct urb,
|
|
|
|
urb_list);
|
|
|
|
usb_get_urb (urb);
|
|
|
|
}
|
2007-07-18 18:14:24 +02:00
|
|
|
spin_unlock_irq(&hcd_urb_list_lock);
|
2006-08-11 22:01:45 +02:00
|
|
|
|
|
|
|
if (urb) {
|
|
|
|
usb_kill_urb (urb);
|
|
|
|
usb_put_urb (urb);
|
|
|
|
}
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
USB: Check bandwidth when switching alt settings.
Make the USB core check the bandwidth when switching from one
interface alternate setting to another. Also check the bandwidth
when resetting a configuration (so that alt setting 0 is used). If
this check fails, the device's state is unchanged. If the device
refuses the new alt setting, re-instate the old alt setting in the
host controller hardware.
If a USB device doesn't have an alternate interface setting 0, install
the first alt setting in its descriptors when a new configuration is
requested, or the device is reset.
Add a mutex per root hub to protect bandwidth operations:
adding/reseting/changing configurations, and changing alternate interface
settings. We want to ensure that the xHCI host controller and the USB
device are set up for the same configurations and alternate settings.
There are two (possibly three) steps to do this:
1. The host controller needs to check that bandwidth is available for a
different setting, by issuing and waiting for a configure endpoint
command.
2. Once that returns successfully, a control message is sent to the
device.
3. If that fails, the host controller must be notified through another
configure endpoint command.
The mutex is used to make these three operations seem atomic, to prevent
another driver from using more bandwidth for a different device while
we're in the middle of these operations.
While we're touching the bandwidth code, rename usb_hcd_check_bandwidth()
to usb_hcd_alloc_bandwidth(). This function does more than just check
that the bandwidth change won't exceed the bus bandwidth; it actually
changes the bandwidth configuration in the xHCI host controller.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-12-03 18:44:36 +01:00
|
|
|
/**
|
2009-12-13 19:17:16 +01:00
|
|
|
* usb_hcd_alloc_bandwidth - check whether a new bandwidth setting exceeds
|
|
|
|
* the bus bandwidth
|
|
|
|
* @udev: target &usb_device
|
USB: Check bandwidth when switching alt settings.
Make the USB core check the bandwidth when switching from one
interface alternate setting to another. Also check the bandwidth
when resetting a configuration (so that alt setting 0 is used). If
this check fails, the device's state is unchanged. If the device
refuses the new alt setting, re-instate the old alt setting in the
host controller hardware.
If a USB device doesn't have an alternate interface setting 0, install
the first alt setting in its descriptors when a new configuration is
requested, or the device is reset.
Add a mutex per root hub to protect bandwidth operations:
adding/reseting/changing configurations, and changing alternate interface
settings. We want to ensure that the xHCI host controller and the USB
device are set up for the same configurations and alternate settings.
There are two (possibly three) steps to do this:
1. The host controller needs to check that bandwidth is available for a
different setting, by issuing and waiting for a configure endpoint
command.
2. Once that returns successfully, a control message is sent to the
device.
3. If that fails, the host controller must be notified through another
configure endpoint command.
The mutex is used to make these three operations seem atomic, to prevent
another driver from using more bandwidth for a different device while
we're in the middle of these operations.
While we're touching the bandwidth code, rename usb_hcd_check_bandwidth()
to usb_hcd_alloc_bandwidth(). This function does more than just check
that the bandwidth change won't exceed the bus bandwidth; it actually
changes the bandwidth configuration in the xHCI host controller.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-12-03 18:44:36 +01:00
|
|
|
* @new_config: new configuration to install
|
|
|
|
* @cur_alt: the current alternate interface setting
|
|
|
|
* @new_alt: alternate interface setting that is being installed
|
|
|
|
*
|
|
|
|
* To change configurations, pass in the new configuration in new_config,
|
|
|
|
* and pass NULL for cur_alt and new_alt.
|
|
|
|
*
|
|
|
|
* To reset a device's configuration (put the device in the ADDRESSED state),
|
|
|
|
* pass in NULL for new_config, cur_alt, and new_alt.
|
|
|
|
*
|
|
|
|
* To change alternate interface settings, pass in NULL for new_config,
|
|
|
|
* pass in the current alternate interface setting in cur_alt,
|
|
|
|
* and pass in the new alternate interface setting in new_alt.
|
|
|
|
*
|
|
|
|
* Returns an error if the requested bandwidth change exceeds the
|
|
|
|
* bus bandwidth or host controller internal resources.
|
USB: Support for bandwidth allocation.
Originally, the USB core had no support for allocating bandwidth when a
particular configuration or alternate setting for an interface was
selected. Instead, the device driver's URB submission would fail if
there was not enough bandwidth for a periodic endpoint. Drivers could
work around this, by using the scatter-gather list API to guarantee
bandwidth.
This patch adds host controller API to allow the USB core to allocate or
deallocate bandwidth for an endpoint. Endpoints are added to or dropped
from a copy of the current schedule by calling add_endpoint() or
drop_endpoint(), and then the schedule is atomically evaluated with a
call to check_bandwidth(). This allows all the endpoints for a new
configuration or alternate setting to be added at the same time that the
endpoints from the old configuration or alt setting are dropped.
Endpoints must be added to the schedule before any URBs are submitted to
them. The HCD must be allowed to reject a new configuration or alt
setting before the control transfer is sent to the device requesting the
change. It may reject the change because there is not enough bandwidth,
not enough internal resources (such as memory on an embedded host
controller), or perhaps even for security reasons in a virtualized
environment.
If the call to check_bandwidth() fails, the USB core must call
reset_bandwidth(). This causes the schedule to be reverted back to the
state it was in just after the last successful check_bandwidth() call.
If the call succeeds, the host controller driver (and hardware) will have
changed its internal state to match the new configuration or alternate
setting. The USB core can then issue a control transfer to the device to
change the configuration or alt setting. This allows the core to test new
configurations or alternate settings before unbinding drivers bound to
interfaces in the old configuration.
WIP:
The USB core must add endpoints from all interfaces in a configuration
to the schedule, because a driver may claim that interface at any time.
A slight optimization might be to add the endpoints to the schedule once
a driver claims that interface. FIXME
This patch does not cover changing alternate settings, but it does
handle a configuration change or de-configuration. FIXME
The code for managing the schedule is currently HCD specific. A generic
scheduling algorithm could be added for host controllers without
built-in scheduling support. For now, if a host controller does not
define the check_bandwidth() function, the call to
usb_hcd_check_bandwidth() will always succeed.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-04-28 04:58:26 +02:00
|
|
|
*/
|
USB: Check bandwidth when switching alt settings.
Make the USB core check the bandwidth when switching from one
interface alternate setting to another. Also check the bandwidth
when resetting a configuration (so that alt setting 0 is used). If
this check fails, the device's state is unchanged. If the device
refuses the new alt setting, re-instate the old alt setting in the
host controller hardware.
If a USB device doesn't have an alternate interface setting 0, install
the first alt setting in its descriptors when a new configuration is
requested, or the device is reset.
Add a mutex per root hub to protect bandwidth operations:
adding/reseting/changing configurations, and changing alternate interface
settings. We want to ensure that the xHCI host controller and the USB
device are set up for the same configurations and alternate settings.
There are two (possibly three) steps to do this:
1. The host controller needs to check that bandwidth is available for a
different setting, by issuing and waiting for a configure endpoint
command.
2. Once that returns successfully, a control message is sent to the
device.
3. If that fails, the host controller must be notified through another
configure endpoint command.
The mutex is used to make these three operations seem atomic, to prevent
another driver from using more bandwidth for a different device while
we're in the middle of these operations.
While we're touching the bandwidth code, rename usb_hcd_check_bandwidth()
to usb_hcd_alloc_bandwidth(). This function does more than just check
that the bandwidth change won't exceed the bus bandwidth; it actually
changes the bandwidth configuration in the xHCI host controller.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-12-03 18:44:36 +01:00
|
|
|
int usb_hcd_alloc_bandwidth(struct usb_device *udev,
|
USB: Support for bandwidth allocation.
Originally, the USB core had no support for allocating bandwidth when a
particular configuration or alternate setting for an interface was
selected. Instead, the device driver's URB submission would fail if
there was not enough bandwidth for a periodic endpoint. Drivers could
work around this, by using the scatter-gather list API to guarantee
bandwidth.
This patch adds host controller API to allow the USB core to allocate or
deallocate bandwidth for an endpoint. Endpoints are added to or dropped
from a copy of the current schedule by calling add_endpoint() or
drop_endpoint(), and then the schedule is atomically evaluated with a
call to check_bandwidth(). This allows all the endpoints for a new
configuration or alternate setting to be added at the same time that the
endpoints from the old configuration or alt setting are dropped.
Endpoints must be added to the schedule before any URBs are submitted to
them. The HCD must be allowed to reject a new configuration or alt
setting before the control transfer is sent to the device requesting the
change. It may reject the change because there is not enough bandwidth,
not enough internal resources (such as memory on an embedded host
controller), or perhaps even for security reasons in a virtualized
environment.
If the call to check_bandwidth() fails, the USB core must call
reset_bandwidth(). This causes the schedule to be reverted back to the
state it was in just after the last successful check_bandwidth() call.
If the call succeeds, the host controller driver (and hardware) will have
changed its internal state to match the new configuration or alternate
setting. The USB core can then issue a control transfer to the device to
change the configuration or alt setting. This allows the core to test new
configurations or alternate settings before unbinding drivers bound to
interfaces in the old configuration.
WIP:
The USB core must add endpoints from all interfaces in a configuration
to the schedule, because a driver may claim that interface at any time.
A slight optimization might be to add the endpoints to the schedule once
a driver claims that interface. FIXME
This patch does not cover changing alternate settings, but it does
handle a configuration change or de-configuration. FIXME
The code for managing the schedule is currently HCD specific. A generic
scheduling algorithm could be added for host controllers without
built-in scheduling support. For now, if a host controller does not
define the check_bandwidth() function, the call to
usb_hcd_check_bandwidth() will always succeed.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-04-28 04:58:26 +02:00
|
|
|
struct usb_host_config *new_config,
|
USB: Check bandwidth when switching alt settings.
Make the USB core check the bandwidth when switching from one
interface alternate setting to another. Also check the bandwidth
when resetting a configuration (so that alt setting 0 is used). If
this check fails, the device's state is unchanged. If the device
refuses the new alt setting, re-instate the old alt setting in the
host controller hardware.
If a USB device doesn't have an alternate interface setting 0, install
the first alt setting in its descriptors when a new configuration is
requested, or the device is reset.
Add a mutex per root hub to protect bandwidth operations:
adding/reseting/changing configurations, and changing alternate interface
settings. We want to ensure that the xHCI host controller and the USB
device are set up for the same configurations and alternate settings.
There are two (possibly three) steps to do this:
1. The host controller needs to check that bandwidth is available for a
different setting, by issuing and waiting for a configure endpoint
command.
2. Once that returns successfully, a control message is sent to the
device.
3. If that fails, the host controller must be notified through another
configure endpoint command.
The mutex is used to make these three operations seem atomic, to prevent
another driver from using more bandwidth for a different device while
we're in the middle of these operations.
While we're touching the bandwidth code, rename usb_hcd_check_bandwidth()
to usb_hcd_alloc_bandwidth(). This function does more than just check
that the bandwidth change won't exceed the bus bandwidth; it actually
changes the bandwidth configuration in the xHCI host controller.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-12-03 18:44:36 +01:00
|
|
|
struct usb_host_interface *cur_alt,
|
|
|
|
struct usb_host_interface *new_alt)
|
USB: Support for bandwidth allocation.
Originally, the USB core had no support for allocating bandwidth when a
particular configuration or alternate setting for an interface was
selected. Instead, the device driver's URB submission would fail if
there was not enough bandwidth for a periodic endpoint. Drivers could
work around this, by using the scatter-gather list API to guarantee
bandwidth.
This patch adds host controller API to allow the USB core to allocate or
deallocate bandwidth for an endpoint. Endpoints are added to or dropped
from a copy of the current schedule by calling add_endpoint() or
drop_endpoint(), and then the schedule is atomically evaluated with a
call to check_bandwidth(). This allows all the endpoints for a new
configuration or alternate setting to be added at the same time that the
endpoints from the old configuration or alt setting are dropped.
Endpoints must be added to the schedule before any URBs are submitted to
them. The HCD must be allowed to reject a new configuration or alt
setting before the control transfer is sent to the device requesting the
change. It may reject the change because there is not enough bandwidth,
not enough internal resources (such as memory on an embedded host
controller), or perhaps even for security reasons in a virtualized
environment.
If the call to check_bandwidth() fails, the USB core must call
reset_bandwidth(). This causes the schedule to be reverted back to the
state it was in just after the last successful check_bandwidth() call.
If the call succeeds, the host controller driver (and hardware) will have
changed its internal state to match the new configuration or alternate
setting. The USB core can then issue a control transfer to the device to
change the configuration or alt setting. This allows the core to test new
configurations or alternate settings before unbinding drivers bound to
interfaces in the old configuration.
WIP:
The USB core must add endpoints from all interfaces in a configuration
to the schedule, because a driver may claim that interface at any time.
A slight optimization might be to add the endpoints to the schedule once
a driver claims that interface. FIXME
This patch does not cover changing alternate settings, but it does
handle a configuration change or de-configuration. FIXME
The code for managing the schedule is currently HCD specific. A generic
scheduling algorithm could be added for host controllers without
built-in scheduling support. For now, if a host controller does not
define the check_bandwidth() function, the call to
usb_hcd_check_bandwidth() will always succeed.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-04-28 04:58:26 +02:00
|
|
|
{
|
|
|
|
int num_intfs, i, j;
|
2009-11-17 23:53:41 +01:00
|
|
|
struct usb_host_interface *alt = NULL;
|
USB: Support for bandwidth allocation.
Originally, the USB core had no support for allocating bandwidth when a
particular configuration or alternate setting for an interface was
selected. Instead, the device driver's URB submission would fail if
there was not enough bandwidth for a periodic endpoint. Drivers could
work around this, by using the scatter-gather list API to guarantee
bandwidth.
This patch adds host controller API to allow the USB core to allocate or
deallocate bandwidth for an endpoint. Endpoints are added to or dropped
from a copy of the current schedule by calling add_endpoint() or
drop_endpoint(), and then the schedule is atomically evaluated with a
call to check_bandwidth(). This allows all the endpoints for a new
configuration or alternate setting to be added at the same time that the
endpoints from the old configuration or alt setting are dropped.
Endpoints must be added to the schedule before any URBs are submitted to
them. The HCD must be allowed to reject a new configuration or alt
setting before the control transfer is sent to the device requesting the
change. It may reject the change because there is not enough bandwidth,
not enough internal resources (such as memory on an embedded host
controller), or perhaps even for security reasons in a virtualized
environment.
If the call to check_bandwidth() fails, the USB core must call
reset_bandwidth(). This causes the schedule to be reverted back to the
state it was in just after the last successful check_bandwidth() call.
If the call succeeds, the host controller driver (and hardware) will have
changed its internal state to match the new configuration or alternate
setting. The USB core can then issue a control transfer to the device to
change the configuration or alt setting. This allows the core to test new
configurations or alternate settings before unbinding drivers bound to
interfaces in the old configuration.
WIP:
The USB core must add endpoints from all interfaces in a configuration
to the schedule, because a driver may claim that interface at any time.
A slight optimization might be to add the endpoints to the schedule once
a driver claims that interface. FIXME
This patch does not cover changing alternate settings, but it does
handle a configuration change or de-configuration. FIXME
The code for managing the schedule is currently HCD specific. A generic
scheduling algorithm could be added for host controllers without
built-in scheduling support. For now, if a host controller does not
define the check_bandwidth() function, the call to
usb_hcd_check_bandwidth() will always succeed.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-04-28 04:58:26 +02:00
|
|
|
int ret = 0;
|
|
|
|
struct usb_hcd *hcd;
|
|
|
|
struct usb_host_endpoint *ep;
|
|
|
|
|
|
|
|
hcd = bus_to_hcd(udev->bus);
|
|
|
|
if (!hcd->driver->check_bandwidth)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Configuration is being removed - set configuration 0 */
|
USB: Check bandwidth when switching alt settings.
Make the USB core check the bandwidth when switching from one
interface alternate setting to another. Also check the bandwidth
when resetting a configuration (so that alt setting 0 is used). If
this check fails, the device's state is unchanged. If the device
refuses the new alt setting, re-instate the old alt setting in the
host controller hardware.
If a USB device doesn't have an alternate interface setting 0, install
the first alt setting in its descriptors when a new configuration is
requested, or the device is reset.
Add a mutex per root hub to protect bandwidth operations:
adding/reseting/changing configurations, and changing alternate interface
settings. We want to ensure that the xHCI host controller and the USB
device are set up for the same configurations and alternate settings.
There are two (possibly three) steps to do this:
1. The host controller needs to check that bandwidth is available for a
different setting, by issuing and waiting for a configure endpoint
command.
2. Once that returns successfully, a control message is sent to the
device.
3. If that fails, the host controller must be notified through another
configure endpoint command.
The mutex is used to make these three operations seem atomic, to prevent
another driver from using more bandwidth for a different device while
we're in the middle of these operations.
While we're touching the bandwidth code, rename usb_hcd_check_bandwidth()
to usb_hcd_alloc_bandwidth(). This function does more than just check
that the bandwidth change won't exceed the bus bandwidth; it actually
changes the bandwidth configuration in the xHCI host controller.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-12-03 18:44:36 +01:00
|
|
|
if (!new_config && !cur_alt) {
|
USB: Support for bandwidth allocation.
Originally, the USB core had no support for allocating bandwidth when a
particular configuration or alternate setting for an interface was
selected. Instead, the device driver's URB submission would fail if
there was not enough bandwidth for a periodic endpoint. Drivers could
work around this, by using the scatter-gather list API to guarantee
bandwidth.
This patch adds host controller API to allow the USB core to allocate or
deallocate bandwidth for an endpoint. Endpoints are added to or dropped
from a copy of the current schedule by calling add_endpoint() or
drop_endpoint(), and then the schedule is atomically evaluated with a
call to check_bandwidth(). This allows all the endpoints for a new
configuration or alternate setting to be added at the same time that the
endpoints from the old configuration or alt setting are dropped.
Endpoints must be added to the schedule before any URBs are submitted to
them. The HCD must be allowed to reject a new configuration or alt
setting before the control transfer is sent to the device requesting the
change. It may reject the change because there is not enough bandwidth,
not enough internal resources (such as memory on an embedded host
controller), or perhaps even for security reasons in a virtualized
environment.
If the call to check_bandwidth() fails, the USB core must call
reset_bandwidth(). This causes the schedule to be reverted back to the
state it was in just after the last successful check_bandwidth() call.
If the call succeeds, the host controller driver (and hardware) will have
changed its internal state to match the new configuration or alternate
setting. The USB core can then issue a control transfer to the device to
change the configuration or alt setting. This allows the core to test new
configurations or alternate settings before unbinding drivers bound to
interfaces in the old configuration.
WIP:
The USB core must add endpoints from all interfaces in a configuration
to the schedule, because a driver may claim that interface at any time.
A slight optimization might be to add the endpoints to the schedule once
a driver claims that interface. FIXME
This patch does not cover changing alternate settings, but it does
handle a configuration change or de-configuration. FIXME
The code for managing the schedule is currently HCD specific. A generic
scheduling algorithm could be added for host controllers without
built-in scheduling support. For now, if a host controller does not
define the check_bandwidth() function, the call to
usb_hcd_check_bandwidth() will always succeed.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-04-28 04:58:26 +02:00
|
|
|
for (i = 1; i < 16; ++i) {
|
|
|
|
ep = udev->ep_out[i];
|
|
|
|
if (ep)
|
|
|
|
hcd->driver->drop_endpoint(hcd, udev, ep);
|
|
|
|
ep = udev->ep_in[i];
|
|
|
|
if (ep)
|
|
|
|
hcd->driver->drop_endpoint(hcd, udev, ep);
|
|
|
|
}
|
|
|
|
hcd->driver->check_bandwidth(hcd, udev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* Check if the HCD says there's enough bandwidth. Enable all endpoints
|
|
|
|
* each interface's alt setting 0 and ask the HCD to check the bandwidth
|
|
|
|
* of the bus. There will always be bandwidth for endpoint 0, so it's
|
|
|
|
* ok to exclude it.
|
|
|
|
*/
|
|
|
|
if (new_config) {
|
|
|
|
num_intfs = new_config->desc.bNumInterfaces;
|
|
|
|
/* Remove endpoints (except endpoint 0, which is always on the
|
|
|
|
* schedule) from the old config from the schedule
|
|
|
|
*/
|
|
|
|
for (i = 1; i < 16; ++i) {
|
|
|
|
ep = udev->ep_out[i];
|
|
|
|
if (ep) {
|
|
|
|
ret = hcd->driver->drop_endpoint(hcd, udev, ep);
|
|
|
|
if (ret < 0)
|
|
|
|
goto reset;
|
|
|
|
}
|
|
|
|
ep = udev->ep_in[i];
|
|
|
|
if (ep) {
|
|
|
|
ret = hcd->driver->drop_endpoint(hcd, udev, ep);
|
|
|
|
if (ret < 0)
|
|
|
|
goto reset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (i = 0; i < num_intfs; ++i) {
|
2010-01-05 23:33:29 +01:00
|
|
|
struct usb_host_interface *first_alt;
|
|
|
|
int iface_num;
|
|
|
|
|
|
|
|
first_alt = &new_config->intf_cache[i]->altsetting[0];
|
|
|
|
iface_num = first_alt->desc.bInterfaceNumber;
|
2009-12-03 18:44:34 +01:00
|
|
|
/* Set up endpoints for alternate interface setting 0 */
|
2010-01-05 23:33:29 +01:00
|
|
|
alt = usb_find_alt_setting(new_config, iface_num, 0);
|
USB: Check bandwidth when switching alt settings.
Make the USB core check the bandwidth when switching from one
interface alternate setting to another. Also check the bandwidth
when resetting a configuration (so that alt setting 0 is used). If
this check fails, the device's state is unchanged. If the device
refuses the new alt setting, re-instate the old alt setting in the
host controller hardware.
If a USB device doesn't have an alternate interface setting 0, install
the first alt setting in its descriptors when a new configuration is
requested, or the device is reset.
Add a mutex per root hub to protect bandwidth operations:
adding/reseting/changing configurations, and changing alternate interface
settings. We want to ensure that the xHCI host controller and the USB
device are set up for the same configurations and alternate settings.
There are two (possibly three) steps to do this:
1. The host controller needs to check that bandwidth is available for a
different setting, by issuing and waiting for a configure endpoint
command.
2. Once that returns successfully, a control message is sent to the
device.
3. If that fails, the host controller must be notified through another
configure endpoint command.
The mutex is used to make these three operations seem atomic, to prevent
another driver from using more bandwidth for a different device while
we're in the middle of these operations.
While we're touching the bandwidth code, rename usb_hcd_check_bandwidth()
to usb_hcd_alloc_bandwidth(). This function does more than just check
that the bandwidth change won't exceed the bus bandwidth; it actually
changes the bandwidth configuration in the xHCI host controller.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-12-03 18:44:36 +01:00
|
|
|
if (!alt)
|
|
|
|
/* No alt setting 0? Pick the first setting. */
|
2010-01-05 23:33:29 +01:00
|
|
|
alt = first_alt;
|
USB: Check bandwidth when switching alt settings.
Make the USB core check the bandwidth when switching from one
interface alternate setting to another. Also check the bandwidth
when resetting a configuration (so that alt setting 0 is used). If
this check fails, the device's state is unchanged. If the device
refuses the new alt setting, re-instate the old alt setting in the
host controller hardware.
If a USB device doesn't have an alternate interface setting 0, install
the first alt setting in its descriptors when a new configuration is
requested, or the device is reset.
Add a mutex per root hub to protect bandwidth operations:
adding/reseting/changing configurations, and changing alternate interface
settings. We want to ensure that the xHCI host controller and the USB
device are set up for the same configurations and alternate settings.
There are two (possibly three) steps to do this:
1. The host controller needs to check that bandwidth is available for a
different setting, by issuing and waiting for a configure endpoint
command.
2. Once that returns successfully, a control message is sent to the
device.
3. If that fails, the host controller must be notified through another
configure endpoint command.
The mutex is used to make these three operations seem atomic, to prevent
another driver from using more bandwidth for a different device while
we're in the middle of these operations.
While we're touching the bandwidth code, rename usb_hcd_check_bandwidth()
to usb_hcd_alloc_bandwidth(). This function does more than just check
that the bandwidth change won't exceed the bus bandwidth; it actually
changes the bandwidth configuration in the xHCI host controller.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-12-03 18:44:36 +01:00
|
|
|
|
USB: Support for bandwidth allocation.
Originally, the USB core had no support for allocating bandwidth when a
particular configuration or alternate setting for an interface was
selected. Instead, the device driver's URB submission would fail if
there was not enough bandwidth for a periodic endpoint. Drivers could
work around this, by using the scatter-gather list API to guarantee
bandwidth.
This patch adds host controller API to allow the USB core to allocate or
deallocate bandwidth for an endpoint. Endpoints are added to or dropped
from a copy of the current schedule by calling add_endpoint() or
drop_endpoint(), and then the schedule is atomically evaluated with a
call to check_bandwidth(). This allows all the endpoints for a new
configuration or alternate setting to be added at the same time that the
endpoints from the old configuration or alt setting are dropped.
Endpoints must be added to the schedule before any URBs are submitted to
them. The HCD must be allowed to reject a new configuration or alt
setting before the control transfer is sent to the device requesting the
change. It may reject the change because there is not enough bandwidth,
not enough internal resources (such as memory on an embedded host
controller), or perhaps even for security reasons in a virtualized
environment.
If the call to check_bandwidth() fails, the USB core must call
reset_bandwidth(). This causes the schedule to be reverted back to the
state it was in just after the last successful check_bandwidth() call.
If the call succeeds, the host controller driver (and hardware) will have
changed its internal state to match the new configuration or alternate
setting. The USB core can then issue a control transfer to the device to
change the configuration or alt setting. This allows the core to test new
configurations or alternate settings before unbinding drivers bound to
interfaces in the old configuration.
WIP:
The USB core must add endpoints from all interfaces in a configuration
to the schedule, because a driver may claim that interface at any time.
A slight optimization might be to add the endpoints to the schedule once
a driver claims that interface. FIXME
This patch does not cover changing alternate settings, but it does
handle a configuration change or de-configuration. FIXME
The code for managing the schedule is currently HCD specific. A generic
scheduling algorithm could be added for host controllers without
built-in scheduling support. For now, if a host controller does not
define the check_bandwidth() function, the call to
usb_hcd_check_bandwidth() will always succeed.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-04-28 04:58:26 +02:00
|
|
|
for (j = 0; j < alt->desc.bNumEndpoints; j++) {
|
|
|
|
ret = hcd->driver->add_endpoint(hcd, udev, &alt->endpoint[j]);
|
|
|
|
if (ret < 0)
|
|
|
|
goto reset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
USB: Check bandwidth when switching alt settings.
Make the USB core check the bandwidth when switching from one
interface alternate setting to another. Also check the bandwidth
when resetting a configuration (so that alt setting 0 is used). If
this check fails, the device's state is unchanged. If the device
refuses the new alt setting, re-instate the old alt setting in the
host controller hardware.
If a USB device doesn't have an alternate interface setting 0, install
the first alt setting in its descriptors when a new configuration is
requested, or the device is reset.
Add a mutex per root hub to protect bandwidth operations:
adding/reseting/changing configurations, and changing alternate interface
settings. We want to ensure that the xHCI host controller and the USB
device are set up for the same configurations and alternate settings.
There are two (possibly three) steps to do this:
1. The host controller needs to check that bandwidth is available for a
different setting, by issuing and waiting for a configure endpoint
command.
2. Once that returns successfully, a control message is sent to the
device.
3. If that fails, the host controller must be notified through another
configure endpoint command.
The mutex is used to make these three operations seem atomic, to prevent
another driver from using more bandwidth for a different device while
we're in the middle of these operations.
While we're touching the bandwidth code, rename usb_hcd_check_bandwidth()
to usb_hcd_alloc_bandwidth(). This function does more than just check
that the bandwidth change won't exceed the bus bandwidth; it actually
changes the bandwidth configuration in the xHCI host controller.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-12-03 18:44:36 +01:00
|
|
|
if (cur_alt && new_alt) {
|
USB: Fix duplicate sysfs problem after device reset.
Borislav Petkov reports issues with duplicate sysfs endpoint files after a
resume from a hibernate. It turns out that the code to support alternate
settings under xHCI has issues when a device with a non-default alternate
setting is reset during the hibernate:
[ 427.681810] Restarting tasks ...
[ 427.681995] hub 1-0:1.0: state 7 ports 6 chg 0004 evt 0000
[ 427.682019] usb usb3: usb resume
[ 427.682030] ohci_hcd 0000:00:12.0: wakeup root hub
[ 427.682191] hub 1-0:1.0: port 2, status 0501, change 0000, 480 Mb/s
[ 427.682205] usb 1-2: usb wakeup-resume
[ 427.682226] usb 1-2: finish reset-resume
[ 427.682886] done.
[ 427.734658] ehci_hcd 0000:00:12.2: port 2 high speed
[ 427.734663] ehci_hcd 0000:00:12.2: GetStatus port 2 status 001005 POWER sig=se0 PE CONNECT
[ 427.746682] hub 3-0:1.0: hub_reset_resume
[ 427.746693] hub 3-0:1.0: trying to enable port power on non-switchable hub
[ 427.786715] usb 1-2: reset high speed USB device using ehci_hcd and address 2
[ 427.839653] ehci_hcd 0000:00:12.2: port 2 high speed
[ 427.839666] ehci_hcd 0000:00:12.2: GetStatus port 2 status 001005 POWER sig=se0 PE CONNECT
[ 427.847717] ohci_hcd 0000:00:12.0: GetStatus roothub.portstatus [1] = 0x00010100 CSC PPS
[ 427.915497] hub 1-2:1.0: remove_intf_ep_devs: if: ffff88022f9e8800 ->ep_devs_created: 1
[ 427.915774] hub 1-2:1.0: remove_intf_ep_devs: bNumEndpoints: 1
[ 427.915934] hub 1-2:1.0: if: ffff88022f9e8800: endpoint devs removed.
[ 427.916158] hub 1-2:1.0: create_intf_ep_devs: if: ffff88022f9e8800 ->ep_devs_created: 0, ->unregistering: 0
[ 427.916434] hub 1-2:1.0: create_intf_ep_devs: bNumEndpoints: 1
[ 427.916609] ep_81: create, parent hub
[ 427.916632] ------------[ cut here ]------------
[ 427.916644] WARNING: at fs/sysfs/dir.c:477 sysfs_add_one+0x82/0x96()
[ 427.916649] Hardware name: System Product Name
[ 427.916653] sysfs: cannot create duplicate filename '/devices/pci0000:00/0000:00:12.2/usb1/1-2/1-2:1.0/ep_81'
[ 427.916658] Modules linked in: binfmt_misc kvm_amd kvm powernow_k8 cpufreq_ondemand cpufreq_powersave cpufreq_userspace freq_table cpufreq_conservative ipv6 vfat fat
+8250_pnp 8250 pcspkr ohci_hcd serial_core k10temp edac_core
[ 427.916694] Pid: 278, comm: khubd Not tainted 2.6.33-rc2-00187-g08d869a-dirty #13
[ 427.916699] Call Trace:
The problem is caused by a mismatch between the USB core's view of the
device state and the USB device and xHCI host's view of the device state.
After the device reset and re-configuration, the device and the xHCI host
think they are using alternate setting 0 of all interfaces. However, the
USB core keeps track of the old state, which may include non-zero
alternate settings. It uses intf->cur_altsetting to keep the endpoint
sysfs files for the old state across the reset.
The bandwidth allocation functions need to know what the xHCI host thinks
the current alternate settings are, so original patch set
intf->cur_altsetting to the alternate setting 0. This caused duplicate
endpoint files to be created.
The solution is to not set intf->cur_altsetting before calling
usb_set_interface() in usb_reset_and_verify_device(). Instead, we add a
new flag to struct usb_interface to tell usb_hcd_alloc_bandwidth() to use
alternate setting 0 as the currently installed alternate setting.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Tested-by: Borislav Petkov <petkovbb@googlemail.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2010-01-06 19:16:51 +01:00
|
|
|
struct usb_interface *iface = usb_ifnum_to_if(udev,
|
|
|
|
cur_alt->desc.bInterfaceNumber);
|
|
|
|
|
|
|
|
if (iface->resetting_device) {
|
|
|
|
/*
|
|
|
|
* The USB core just reset the device, so the xHCI host
|
|
|
|
* and the device will think alt setting 0 is installed.
|
|
|
|
* However, the USB core will pass in the alternate
|
|
|
|
* setting installed before the reset as cur_alt. Dig
|
|
|
|
* out the alternate setting 0 structure, or the first
|
|
|
|
* alternate setting if a broken device doesn't have alt
|
|
|
|
* setting 0.
|
|
|
|
*/
|
|
|
|
cur_alt = usb_altnum_to_altsetting(iface, 0);
|
|
|
|
if (!cur_alt)
|
|
|
|
cur_alt = &iface->altsetting[0];
|
|
|
|
}
|
|
|
|
|
USB: Check bandwidth when switching alt settings.
Make the USB core check the bandwidth when switching from one
interface alternate setting to another. Also check the bandwidth
when resetting a configuration (so that alt setting 0 is used). If
this check fails, the device's state is unchanged. If the device
refuses the new alt setting, re-instate the old alt setting in the
host controller hardware.
If a USB device doesn't have an alternate interface setting 0, install
the first alt setting in its descriptors when a new configuration is
requested, or the device is reset.
Add a mutex per root hub to protect bandwidth operations:
adding/reseting/changing configurations, and changing alternate interface
settings. We want to ensure that the xHCI host controller and the USB
device are set up for the same configurations and alternate settings.
There are two (possibly three) steps to do this:
1. The host controller needs to check that bandwidth is available for a
different setting, by issuing and waiting for a configure endpoint
command.
2. Once that returns successfully, a control message is sent to the
device.
3. If that fails, the host controller must be notified through another
configure endpoint command.
The mutex is used to make these three operations seem atomic, to prevent
another driver from using more bandwidth for a different device while
we're in the middle of these operations.
While we're touching the bandwidth code, rename usb_hcd_check_bandwidth()
to usb_hcd_alloc_bandwidth(). This function does more than just check
that the bandwidth change won't exceed the bus bandwidth; it actually
changes the bandwidth configuration in the xHCI host controller.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-12-03 18:44:36 +01:00
|
|
|
/* Drop all the endpoints in the current alt setting */
|
|
|
|
for (i = 0; i < cur_alt->desc.bNumEndpoints; i++) {
|
|
|
|
ret = hcd->driver->drop_endpoint(hcd, udev,
|
|
|
|
&cur_alt->endpoint[i]);
|
|
|
|
if (ret < 0)
|
|
|
|
goto reset;
|
|
|
|
}
|
|
|
|
/* Add all the endpoints in the new alt setting */
|
|
|
|
for (i = 0; i < new_alt->desc.bNumEndpoints; i++) {
|
|
|
|
ret = hcd->driver->add_endpoint(hcd, udev,
|
|
|
|
&new_alt->endpoint[i]);
|
|
|
|
if (ret < 0)
|
|
|
|
goto reset;
|
|
|
|
}
|
|
|
|
}
|
USB: Support for bandwidth allocation.
Originally, the USB core had no support for allocating bandwidth when a
particular configuration or alternate setting for an interface was
selected. Instead, the device driver's URB submission would fail if
there was not enough bandwidth for a periodic endpoint. Drivers could
work around this, by using the scatter-gather list API to guarantee
bandwidth.
This patch adds host controller API to allow the USB core to allocate or
deallocate bandwidth for an endpoint. Endpoints are added to or dropped
from a copy of the current schedule by calling add_endpoint() or
drop_endpoint(), and then the schedule is atomically evaluated with a
call to check_bandwidth(). This allows all the endpoints for a new
configuration or alternate setting to be added at the same time that the
endpoints from the old configuration or alt setting are dropped.
Endpoints must be added to the schedule before any URBs are submitted to
them. The HCD must be allowed to reject a new configuration or alt
setting before the control transfer is sent to the device requesting the
change. It may reject the change because there is not enough bandwidth,
not enough internal resources (such as memory on an embedded host
controller), or perhaps even for security reasons in a virtualized
environment.
If the call to check_bandwidth() fails, the USB core must call
reset_bandwidth(). This causes the schedule to be reverted back to the
state it was in just after the last successful check_bandwidth() call.
If the call succeeds, the host controller driver (and hardware) will have
changed its internal state to match the new configuration or alternate
setting. The USB core can then issue a control transfer to the device to
change the configuration or alt setting. This allows the core to test new
configurations or alternate settings before unbinding drivers bound to
interfaces in the old configuration.
WIP:
The USB core must add endpoints from all interfaces in a configuration
to the schedule, because a driver may claim that interface at any time.
A slight optimization might be to add the endpoints to the schedule once
a driver claims that interface. FIXME
This patch does not cover changing alternate settings, but it does
handle a configuration change or de-configuration. FIXME
The code for managing the schedule is currently HCD specific. A generic
scheduling algorithm could be added for host controllers without
built-in scheduling support. For now, if a host controller does not
define the check_bandwidth() function, the call to
usb_hcd_check_bandwidth() will always succeed.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-04-28 04:58:26 +02:00
|
|
|
ret = hcd->driver->check_bandwidth(hcd, udev);
|
|
|
|
reset:
|
|
|
|
if (ret < 0)
|
|
|
|
hcd->driver->reset_bandwidth(hcd, udev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-09-10 17:33:05 +02:00
|
|
|
/* Disables the endpoint: synchronizes with the hcd to make sure all
|
|
|
|
* endpoint state is gone from hardware. usb_hcd_flush_endpoint() must
|
|
|
|
* have been called previously. 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.
|
|
|
|
*/
|
|
|
|
void usb_hcd_disable_endpoint(struct usb_device *udev,
|
|
|
|
struct usb_host_endpoint *ep)
|
|
|
|
{
|
|
|
|
struct usb_hcd *hcd;
|
|
|
|
|
|
|
|
might_sleep();
|
|
|
|
hcd = bus_to_hcd(udev->bus);
|
|
|
|
if (hcd->driver->endpoint_disable)
|
|
|
|
hcd->driver->endpoint_disable(hcd, ep);
|
|
|
|
}
|
|
|
|
|
2009-04-08 19:36:28 +02:00
|
|
|
/**
|
|
|
|
* usb_hcd_reset_endpoint - reset host endpoint state
|
|
|
|
* @udev: USB device.
|
|
|
|
* @ep: the endpoint to reset.
|
|
|
|
*
|
|
|
|
* Resets any host endpoint state such as the toggle bit, sequence
|
|
|
|
* number and current window.
|
|
|
|
*/
|
|
|
|
void usb_hcd_reset_endpoint(struct usb_device *udev,
|
|
|
|
struct usb_host_endpoint *ep)
|
|
|
|
{
|
|
|
|
struct usb_hcd *hcd = bus_to_hcd(udev->bus);
|
|
|
|
|
|
|
|
if (hcd->driver->endpoint_reset)
|
|
|
|
hcd->driver->endpoint_reset(hcd, ep);
|
|
|
|
else {
|
|
|
|
int epnum = usb_endpoint_num(&ep->desc);
|
|
|
|
int is_out = usb_endpoint_dir_out(&ep->desc);
|
|
|
|
int is_control = usb_endpoint_xfer_control(&ep->desc);
|
|
|
|
|
|
|
|
usb_settoggle(udev, epnum, is_out, 0);
|
|
|
|
if (is_control)
|
|
|
|
usb_settoggle(udev, epnum, !is_out, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-05 19:55:58 +02:00
|
|
|
/**
|
|
|
|
* usb_alloc_streams - allocate bulk endpoint stream IDs.
|
|
|
|
* @interface: alternate setting that includes all endpoints.
|
|
|
|
* @eps: array of endpoints that need streams.
|
|
|
|
* @num_eps: number of endpoints in the array.
|
|
|
|
* @num_streams: number of streams to allocate.
|
|
|
|
* @mem_flags: flags hcd should use to allocate memory.
|
|
|
|
*
|
|
|
|
* Sets up a group of bulk endpoints to have num_streams stream IDs available.
|
|
|
|
* Drivers may queue multiple transfers to different stream IDs, which may
|
|
|
|
* complete in a different order than they were queued.
|
|
|
|
*/
|
|
|
|
int usb_alloc_streams(struct usb_interface *interface,
|
|
|
|
struct usb_host_endpoint **eps, unsigned int num_eps,
|
|
|
|
unsigned int num_streams, gfp_t mem_flags)
|
|
|
|
{
|
|
|
|
struct usb_hcd *hcd;
|
|
|
|
struct usb_device *dev;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
dev = interface_to_usbdev(interface);
|
|
|
|
hcd = bus_to_hcd(dev->bus);
|
|
|
|
if (!hcd->driver->alloc_streams || !hcd->driver->free_streams)
|
|
|
|
return -EINVAL;
|
|
|
|
if (dev->speed != USB_SPEED_SUPER)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* Streams only apply to bulk endpoints. */
|
|
|
|
for (i = 0; i < num_eps; i++)
|
|
|
|
if (!usb_endpoint_xfer_bulk(&eps[i]->desc))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return hcd->driver->alloc_streams(hcd, dev, eps, num_eps,
|
|
|
|
num_streams, mem_flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(usb_alloc_streams);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_free_streams - free bulk endpoint stream IDs.
|
|
|
|
* @interface: alternate setting that includes all endpoints.
|
|
|
|
* @eps: array of endpoints to remove streams from.
|
|
|
|
* @num_eps: number of endpoints in the array.
|
|
|
|
* @mem_flags: flags hcd should use to allocate memory.
|
|
|
|
*
|
|
|
|
* Reverts a group of bulk endpoints back to not using stream IDs.
|
|
|
|
* Can fail if we are given bad arguments, or HCD is broken.
|
|
|
|
*/
|
|
|
|
void usb_free_streams(struct usb_interface *interface,
|
|
|
|
struct usb_host_endpoint **eps, unsigned int num_eps,
|
|
|
|
gfp_t mem_flags)
|
|
|
|
{
|
|
|
|
struct usb_hcd *hcd;
|
|
|
|
struct usb_device *dev;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
dev = interface_to_usbdev(interface);
|
|
|
|
hcd = bus_to_hcd(dev->bus);
|
|
|
|
if (dev->speed != USB_SPEED_SUPER)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Streams only apply to bulk endpoints. */
|
|
|
|
for (i = 0; i < num_eps; i++)
|
|
|
|
if (!usb_endpoint_xfer_bulk(&eps[i]->desc))
|
|
|
|
return;
|
|
|
|
|
|
|
|
hcd->driver->free_streams(hcd, dev, eps, num_eps, mem_flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(usb_free_streams);
|
|
|
|
|
2008-10-21 21:28:46 +02:00
|
|
|
/* Protect against drivers that try to unlink URBs after the device
|
|
|
|
* is gone, by waiting until all unlinks for @udev are finished.
|
|
|
|
* Since we don't currently track URBs by device, simply wait until
|
|
|
|
* nothing is running in the locked region of usb_hcd_unlink_urb().
|
|
|
|
*/
|
|
|
|
void usb_hcd_synchronize_unlinks(struct usb_device *udev)
|
|
|
|
{
|
|
|
|
spin_lock_irq(&hcd_urb_unlink_lock);
|
|
|
|
spin_unlock_irq(&hcd_urb_unlink_lock);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2007-07-18 18:08:02 +02:00
|
|
|
/* called in any context */
|
|
|
|
int usb_hcd_get_frame_number (struct usb_device *udev)
|
|
|
|
{
|
|
|
|
struct usb_hcd *hcd = bus_to_hcd(udev->bus);
|
|
|
|
|
|
|
|
if (!HC_IS_RUNNING (hcd->state))
|
|
|
|
return -ESHUTDOWN;
|
|
|
|
return hcd->driver->get_frame_number (hcd);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2005-09-23 07:32:11 +02:00
|
|
|
#ifdef CONFIG_PM
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-11-25 22:39:18 +01:00
|
|
|
int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-05-30 21:34:36 +02:00
|
|
|
struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self);
|
|
|
|
int status;
|
|
|
|
int old_state = hcd->state;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-05-30 21:34:36 +02:00
|
|
|
dev_dbg(&rhdev->dev, "bus %s%s\n",
|
2008-11-25 22:39:18 +01:00
|
|
|
(msg.event & PM_EVENT_AUTO ? "auto-" : ""), "suspend");
|
2007-05-30 21:34:36 +02:00
|
|
|
if (!hcd->driver->bus_suspend) {
|
|
|
|
status = -ENOENT;
|
|
|
|
} else {
|
|
|
|
hcd->state = HC_STATE_QUIESCING;
|
|
|
|
status = hcd->driver->bus_suspend(hcd);
|
|
|
|
}
|
|
|
|
if (status == 0) {
|
|
|
|
usb_set_device_state(rhdev, USB_STATE_SUSPENDED);
|
2005-09-23 07:32:11 +02:00
|
|
|
hcd->state = HC_STATE_SUSPENDED;
|
2007-05-30 21:34:36 +02:00
|
|
|
} else {
|
|
|
|
hcd->state = old_state;
|
|
|
|
dev_dbg(&rhdev->dev, "bus %s fail, err %d\n",
|
2005-09-23 07:32:11 +02:00
|
|
|
"suspend", status);
|
2007-05-30 21:34:36 +02:00
|
|
|
}
|
2005-09-23 07:32:11 +02:00
|
|
|
return status;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-11-25 22:39:18 +01:00
|
|
|
int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-05-30 21:34:36 +02:00
|
|
|
struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self);
|
|
|
|
int status;
|
2007-06-21 22:25:35 +02:00
|
|
|
int old_state = hcd->state;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-05-30 21:34:36 +02:00
|
|
|
dev_dbg(&rhdev->dev, "usb %s%s\n",
|
2008-11-25 22:39:18 +01:00
|
|
|
(msg.event & PM_EVENT_AUTO ? "auto-" : ""), "resume");
|
2010-06-25 20:02:35 +02:00
|
|
|
clear_bit(HCD_FLAG_WAKEUP_PENDING, &hcd->flags);
|
2005-10-13 23:08:02 +02:00
|
|
|
if (!hcd->driver->bus_resume)
|
2005-09-23 07:32:11 +02:00
|
|
|
return -ENOENT;
|
2005-09-23 07:32:24 +02:00
|
|
|
if (hcd->state == HC_STATE_RUNNING)
|
|
|
|
return 0;
|
2007-05-30 21:34:36 +02:00
|
|
|
|
2005-09-23 07:32:11 +02:00
|
|
|
hcd->state = HC_STATE_RESUMING;
|
2007-05-30 21:34:36 +02:00
|
|
|
status = hcd->driver->bus_resume(hcd);
|
|
|
|
if (status == 0) {
|
|
|
|
/* TRSMRCY = 10 msec */
|
|
|
|
msleep(10);
|
|
|
|
usb_set_device_state(rhdev, rhdev->actconfig
|
|
|
|
? USB_STATE_CONFIGURED
|
|
|
|
: USB_STATE_ADDRESS);
|
2005-09-23 07:32:11 +02:00
|
|
|
hcd->state = HC_STATE_RUNNING;
|
2007-05-30 21:34:36 +02:00
|
|
|
} else {
|
2007-06-21 22:25:35 +02:00
|
|
|
hcd->state = old_state;
|
2007-05-30 21:34:36 +02:00
|
|
|
dev_dbg(&rhdev->dev, "bus %s fail, err %d\n",
|
2005-09-23 07:32:11 +02:00
|
|
|
"resume", status);
|
2007-06-21 22:25:35 +02:00
|
|
|
if (status != -ESHUTDOWN)
|
|
|
|
usb_hc_died(hcd);
|
2005-09-23 07:32:11 +02:00
|
|
|
}
|
|
|
|
return status;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2010-01-08 18:57:28 +01:00
|
|
|
#endif /* CONFIG_PM */
|
|
|
|
|
|
|
|
#ifdef CONFIG_USB_SUSPEND
|
|
|
|
|
2007-03-13 21:37:30 +01:00
|
|
|
/* Workqueue routine for root-hub remote wakeup */
|
|
|
|
static void hcd_resume_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct usb_hcd *hcd = container_of(work, struct usb_hcd, wakeup_work);
|
|
|
|
struct usb_device *udev = hcd->self.root_hub;
|
|
|
|
|
|
|
|
usb_lock_device(udev);
|
2010-01-08 18:56:30 +01:00
|
|
|
usb_remote_wakeup(udev);
|
2007-03-13 21:37:30 +01:00
|
|
|
usb_unlock_device(udev);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
|
|
|
* 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
|
2007-03-13 21:37:30 +01:00
|
|
|
* wakeup request is received. The routine submits a workqueue request
|
|
|
|
* to resume the root hub (that is, manage its downstream ports again).
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
void usb_hcd_resume_root_hub (struct usb_hcd *hcd)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave (&hcd_root_hub_lock, flags);
|
2010-06-25 20:02:35 +02:00
|
|
|
if (hcd->rh_registered) {
|
|
|
|
set_bit(HCD_FLAG_WAKEUP_PENDING, &hcd->flags);
|
2010-01-08 18:57:28 +01:00
|
|
|
queue_work(pm_wq, &hcd->wakeup_work);
|
2010-06-25 20:02:35 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
|
|
|
|
}
|
2005-09-23 07:32:11 +02:00
|
|
|
EXPORT_SYMBOL_GPL(usb_hcd_resume_root_hub);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-01-08 18:57:28 +01:00
|
|
|
#endif /* CONFIG_USB_SUSPEND */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
#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;
|
|
|
|
}
|
2008-01-25 18:12:21 +01:00
|
|
|
EXPORT_SYMBOL_GPL(usb_bus_start_enum);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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
|
|
|
|
*
|
|
|
|
* If the controller isn't HALTed, calls the driver's irq handler.
|
|
|
|
* Checks whether the controller is now dead.
|
|
|
|
*/
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 15:55:46 +02:00
|
|
|
irqreturn_t usb_hcd_irq (int irq, void *__hcd)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct usb_hcd *hcd = __hcd;
|
2008-07-01 18:19:22 +02:00
|
|
|
unsigned long flags;
|
|
|
|
irqreturn_t rc;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-07-01 18:19:22 +02:00
|
|
|
/* IRQF_DISABLED doesn't work correctly with shared IRQs
|
|
|
|
* when the first handler doesn't use it. So let's just
|
|
|
|
* assume it's never used.
|
|
|
|
*/
|
|
|
|
local_irq_save(flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-06-22 22:39:10 +02:00
|
|
|
if (unlikely(hcd->state == HC_STATE_HALT || !HCD_HW_ACCESSIBLE(hcd))) {
|
2008-07-01 18:19:22 +02:00
|
|
|
rc = IRQ_NONE;
|
|
|
|
} else if (hcd->driver->irq(hcd) == IRQ_NONE) {
|
|
|
|
rc = IRQ_NONE;
|
|
|
|
} else {
|
|
|
|
set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
|
[PATCH] USB: Fix USB suspend/resume crasher (#2)
This patch closes the IRQ race and makes various other OHCI & EHCI code
path safer vs. suspend/resume.
I've been able to (finally !) successfully suspend and resume various
Mac models, with or without USB mouse plugged, or plugging while asleep,
or unplugging while asleep etc... all without a crash.
Alan, please verify the UHCI bit I did, I only verified that it builds.
It's very simple so I wouldn't expect any issue there. If you aren't
confident, then just drop the hunks that change uhci-hcd.c
I also made the patch a little bit more "safer" by making sure the store
to the interrupt register that disables interrupts is not posted before
I set the flag and drop the spinlock.
Without this patch, you cannot reliably sleep/wakeup any recent Mac, and
I suspect PCs have some more sneaky issues too (they don't frankly crash
with machine checks because x86 tend to silently swallow PCI errors but
that won't last afaik, at least PCI Express will blow up in those
situations, but the USB code may still misbehave).
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-11-24 23:59:46 +01:00
|
|
|
|
2008-07-01 18:19:22 +02:00
|
|
|
if (unlikely(hcd->state == HC_STATE_HALT))
|
|
|
|
usb_hc_died(hcd);
|
|
|
|
rc = IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
local_irq_restore(flags);
|
|
|
|
return rc;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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) {
|
2010-06-22 22:39:10 +02:00
|
|
|
clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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,
|
2008-07-02 21:46:22 +02:00
|
|
|
struct device *dev, const char *bus_name)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct usb_hcd *hcd;
|
|
|
|
|
2005-09-07 00:18:34 +02:00
|
|
|
hcd = kzalloc(sizeof(*hcd) + driver->hcd_priv_size, GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!hcd) {
|
|
|
|
dev_dbg (dev, "hcd alloc failed\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
dev_set_drvdata(dev, hcd);
|
2006-08-30 17:32:52 +02:00
|
|
|
kref_init(&hcd->kref);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
usb_bus_init(&hcd->self);
|
|
|
|
hcd->self.controller = dev;
|
|
|
|
hcd->self.bus_name = bus_name;
|
2006-08-30 17:29:56 +02:00
|
|
|
hcd->self.uses_dma = (dev->dma_mask != NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
init_timer(&hcd->rh_timer);
|
2005-04-21 21:56:37 +02:00
|
|
|
hcd->rh_timer.function = rh_timer_func;
|
|
|
|
hcd->rh_timer.data = (unsigned long) hcd;
|
2010-01-08 18:57:28 +01:00
|
|
|
#ifdef CONFIG_USB_SUSPEND
|
2007-03-13 21:37:30 +01:00
|
|
|
INIT_WORK(&hcd->wakeup_work, hcd_resume_work);
|
|
|
|
#endif
|
USB: Check bandwidth when switching alt settings.
Make the USB core check the bandwidth when switching from one
interface alternate setting to another. Also check the bandwidth
when resetting a configuration (so that alt setting 0 is used). If
this check fails, the device's state is unchanged. If the device
refuses the new alt setting, re-instate the old alt setting in the
host controller hardware.
If a USB device doesn't have an alternate interface setting 0, install
the first alt setting in its descriptors when a new configuration is
requested, or the device is reset.
Add a mutex per root hub to protect bandwidth operations:
adding/reseting/changing configurations, and changing alternate interface
settings. We want to ensure that the xHCI host controller and the USB
device are set up for the same configurations and alternate settings.
There are two (possibly three) steps to do this:
1. The host controller needs to check that bandwidth is available for a
different setting, by issuing and waiting for a configure endpoint
command.
2. Once that returns successfully, a control message is sent to the
device.
3. If that fails, the host controller must be notified through another
configure endpoint command.
The mutex is used to make these three operations seem atomic, to prevent
another driver from using more bandwidth for a different device while
we're in the middle of these operations.
While we're touching the bandwidth code, rename usb_hcd_check_bandwidth()
to usb_hcd_alloc_bandwidth(). This function does more than just check
that the bandwidth change won't exceed the bus bandwidth; it actually
changes the bandwidth configuration in the xHCI host controller.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2009-12-03 18:44:36 +01:00
|
|
|
mutex_init(&hcd->bandwidth_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
hcd->driver = driver;
|
|
|
|
hcd->product_desc = (driver->product_desc) ? driver->product_desc :
|
|
|
|
"USB Host Controller";
|
|
|
|
return hcd;
|
|
|
|
}
|
2008-01-25 18:12:21 +01:00
|
|
|
EXPORT_SYMBOL_GPL(usb_create_hcd);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-08-30 17:32:52 +02:00
|
|
|
static void hcd_release (struct kref *kref)
|
|
|
|
{
|
|
|
|
struct usb_hcd *hcd = container_of (kref, struct usb_hcd, kref);
|
|
|
|
|
|
|
|
kfree(hcd);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct usb_hcd *usb_get_hcd (struct usb_hcd *hcd)
|
|
|
|
{
|
|
|
|
if (hcd)
|
|
|
|
kref_get (&hcd->kref);
|
|
|
|
return hcd;
|
|
|
|
}
|
2008-01-25 18:12:21 +01:00
|
|
|
EXPORT_SYMBOL_GPL(usb_get_hcd);
|
2006-08-30 17:32:52 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void usb_put_hcd (struct usb_hcd *hcd)
|
|
|
|
{
|
2006-08-30 17:32:52 +02:00
|
|
|
if (hcd)
|
|
|
|
kref_put (&hcd->kref, hcd_release);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-01-25 18:12:21 +01:00
|
|
|
EXPORT_SYMBOL_GPL(usb_put_hcd);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2005-04-25 17:25:17 +02:00
|
|
|
int retval;
|
|
|
|
struct usb_device *rhdev;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
|
|
|
|
|
2007-08-01 05:33:58 +02:00
|
|
|
hcd->authorized_default = hcd->wireless? 0 : 1;
|
[PATCH] USB: Fix USB suspend/resume crasher (#2)
This patch closes the IRQ race and makes various other OHCI & EHCI code
path safer vs. suspend/resume.
I've been able to (finally !) successfully suspend and resume various
Mac models, with or without USB mouse plugged, or plugging while asleep,
or unplugging while asleep etc... all without a crash.
Alan, please verify the UHCI bit I did, I only verified that it builds.
It's very simple so I wouldn't expect any issue there. If you aren't
confident, then just drop the hunks that change uhci-hcd.c
I also made the patch a little bit more "safer" by making sure the store
to the interrupt register that disables interrupts is not posted before
I set the flag and drop the spinlock.
Without this patch, you cannot reliably sleep/wakeup any recent Mac, and
I suspect PCs have some more sneaky issues too (they don't frankly crash
with machine checks because x86 tend to silently swallow PCI errors but
that won't last afaik, at least PCI Express will blow up in those
situations, but the USB code may still misbehave).
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2005-11-24 23:59:46 +01:00
|
|
|
set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
|
|
|
|
|
2006-01-24 00:25:40 +01:00
|
|
|
/* HC is in reset state, but accessible. Now do the one-time init,
|
|
|
|
* bottom up so that hcds can customize the root hubs before khubd
|
|
|
|
* starts talking to them. (Note, bus id is assigned early too.)
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
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)
|
2005-04-25 17:25:17 +02:00
|
|
|
goto err_register_bus;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-01-24 00:25:40 +01:00
|
|
|
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;
|
|
|
|
}
|
2010-06-09 23:34:17 +02:00
|
|
|
hcd->self.root_hub = rhdev;
|
2009-04-28 04:54:10 +02:00
|
|
|
|
|
|
|
switch (hcd->driver->flags & HCD_MASK) {
|
|
|
|
case HCD_USB11:
|
|
|
|
rhdev->speed = USB_SPEED_FULL;
|
|
|
|
break;
|
|
|
|
case HCD_USB2:
|
|
|
|
rhdev->speed = USB_SPEED_HIGH;
|
|
|
|
break;
|
|
|
|
case HCD_USB3:
|
|
|
|
rhdev->speed = USB_SPEED_SUPER;
|
|
|
|
break;
|
|
|
|
default:
|
2010-06-09 23:34:05 +02:00
|
|
|
goto err_set_rh_speed;
|
2009-04-28 04:54:10 +02:00
|
|
|
}
|
2006-01-24 00:25:40 +01:00
|
|
|
|
2006-05-02 07:07:13 +02:00
|
|
|
/* wakeup flag init defaults to "everything works" for root hubs,
|
|
|
|
* but drivers can override it in reset() if needed, along with
|
|
|
|
* recording the overall controller's system wakeup capability.
|
|
|
|
*/
|
|
|
|
device_init_wakeup(&rhdev->dev, 1);
|
|
|
|
|
2006-01-24 00:25:40 +01:00
|
|
|
/* "reset" is misnamed; its role is now one-time init. the controller
|
|
|
|
* should already have been reset (and boot firmware kicked off etc).
|
|
|
|
*/
|
|
|
|
if (hcd->driver->reset && (retval = hcd->driver->reset(hcd)) < 0) {
|
|
|
|
dev_err(hcd->self.controller, "can't setup\n");
|
|
|
|
goto err_hcd_driver_setup;
|
|
|
|
}
|
2010-06-09 23:34:17 +02:00
|
|
|
hcd->rh_pollable = 1;
|
2006-01-24 00:25:40 +01:00
|
|
|
|
2006-01-24 17:40:27 +01:00
|
|
|
/* NOTE: root hub and controller capabilities may not be the same */
|
|
|
|
if (device_can_wakeup(hcd->self.controller)
|
|
|
|
&& device_can_wakeup(&hcd->self.root_hub->dev))
|
2006-01-24 00:25:40 +01:00
|
|
|
dev_dbg(hcd->self.controller, "supports USB remote wakeup\n");
|
|
|
|
|
|
|
|
/* enable irqs just before we start the controller */
|
2005-04-17 00:20:36 +02:00
|
|
|
if (hcd->driver->irq) {
|
2008-07-01 18:19:22 +02:00
|
|
|
|
|
|
|
/* IRQF_DISABLED doesn't work as advertised when used together
|
|
|
|
* with IRQF_SHARED. As usb_hcd_irq() will always disable
|
|
|
|
* interrupts we can remove it here.
|
|
|
|
*/
|
2008-08-22 23:13:00 +02:00
|
|
|
if (irqflags & IRQF_SHARED)
|
|
|
|
irqflags &= ~IRQF_DISABLED;
|
2008-07-01 18:19:22 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
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,
|
2006-06-20 10:21:29 +02:00
|
|
|
"request interrupt %d failed\n", irqnum);
|
2005-04-25 17:25:17 +02:00
|
|
|
goto err_request_irq;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
hcd->irq = irqnum;
|
2006-06-20 10:21:29 +02:00
|
|
|
dev_info(hcd->self.controller, "irq %d, %s 0x%08llx\n", irqnum,
|
2005-04-17 00:20:36 +02:00
|
|
|
(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);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((retval = hcd->driver->start(hcd)) < 0) {
|
|
|
|
dev_err(hcd->self.controller, "startup error %d\n", retval);
|
2005-04-25 17:25:17 +02:00
|
|
|
goto err_hcd_driver_start;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-01-24 00:25:40 +01:00
|
|
|
/* starting here, usbcore will pay attention to this root hub */
|
2005-11-23 18:03:12 +01:00
|
|
|
rhdev->bus_mA = min(500u, hcd->power_budget);
|
2006-01-24 00:25:40 +01:00
|
|
|
if ((retval = register_root_hub(hcd)) != 0)
|
2005-04-25 17:25:17 +02:00
|
|
|
goto err_register_root_hub;
|
|
|
|
|
2007-08-01 05:33:58 +02:00
|
|
|
retval = sysfs_create_group(&rhdev->dev.kobj, &usb_bus_attr_group);
|
|
|
|
if (retval < 0) {
|
|
|
|
printk(KERN_ERR "Cannot register USB bus sysfs attributes: %d\n",
|
|
|
|
retval);
|
|
|
|
goto error_create_attr_group;
|
|
|
|
}
|
2010-06-22 22:39:10 +02:00
|
|
|
if (hcd->uses_new_polling && HCD_POLL_RH(hcd))
|
2005-04-21 21:56:37 +02:00
|
|
|
usb_hcd_poll_rh_status(hcd);
|
2005-04-17 00:20:36 +02:00
|
|
|
return retval;
|
|
|
|
|
2007-08-01 05:33:58 +02:00
|
|
|
error_create_attr_group:
|
2010-06-09 23:34:05 +02:00
|
|
|
if (HC_IS_RUNNING(hcd->state))
|
|
|
|
hcd->state = HC_STATE_QUIESCING;
|
|
|
|
spin_lock_irq(&hcd_root_hub_lock);
|
|
|
|
hcd->rh_registered = 0;
|
|
|
|
spin_unlock_irq(&hcd_root_hub_lock);
|
|
|
|
|
|
|
|
#ifdef CONFIG_USB_SUSPEND
|
|
|
|
cancel_work_sync(&hcd->wakeup_work);
|
|
|
|
#endif
|
2007-08-01 05:33:58 +02:00
|
|
|
mutex_lock(&usb_bus_list_lock);
|
2010-06-09 23:34:17 +02:00
|
|
|
usb_disconnect(&rhdev); /* Sets rhdev to NULL */
|
2007-08-01 05:33:58 +02:00
|
|
|
mutex_unlock(&usb_bus_list_lock);
|
2006-01-24 00:25:40 +01:00
|
|
|
err_register_root_hub:
|
2010-06-09 23:34:17 +02:00
|
|
|
hcd->rh_pollable = 0;
|
2010-06-22 22:39:10 +02:00
|
|
|
clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
|
2010-06-09 23:34:17 +02:00
|
|
|
del_timer_sync(&hcd->rh_timer);
|
2005-04-25 17:25:17 +02:00
|
|
|
hcd->driver->stop(hcd);
|
2010-06-09 23:34:05 +02:00
|
|
|
hcd->state = HC_STATE_HALT;
|
2010-06-22 22:39:10 +02:00
|
|
|
clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
|
2010-06-09 23:34:05 +02:00
|
|
|
del_timer_sync(&hcd->rh_timer);
|
2006-01-24 00:25:40 +01:00
|
|
|
err_hcd_driver_start:
|
2005-04-17 00:20:36 +02:00
|
|
|
if (hcd->irq >= 0)
|
|
|
|
free_irq(irqnum, hcd);
|
2006-01-24 00:25:40 +01:00
|
|
|
err_request_irq:
|
|
|
|
err_hcd_driver_setup:
|
2010-06-09 23:34:05 +02:00
|
|
|
err_set_rh_speed:
|
2010-06-09 23:34:17 +02:00
|
|
|
usb_put_dev(hcd->self.root_hub);
|
2006-01-24 00:25:40 +01:00
|
|
|
err_allocate_root_hub:
|
2005-04-17 00:20:36 +02:00
|
|
|
usb_deregister_bus(&hcd->self);
|
2006-01-24 00:25:40 +01:00
|
|
|
err_register_bus:
|
2005-04-17 00:20:36 +02:00
|
|
|
hcd_buffer_destroy(hcd);
|
|
|
|
return retval;
|
|
|
|
}
|
2008-01-25 18:12:21 +01:00
|
|
|
EXPORT_SYMBOL_GPL(usb_add_hcd);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2010-06-09 23:34:17 +02:00
|
|
|
struct usb_device *rhdev = hcd->self.root_hub;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
dev_info(hcd->self.controller, "remove, state %x\n", hcd->state);
|
|
|
|
|
2010-06-09 23:34:17 +02:00
|
|
|
usb_get_dev(rhdev);
|
|
|
|
sysfs_remove_group(&rhdev->dev.kobj, &usb_bus_attr_group);
|
2010-06-09 23:34:05 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
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);
|
2005-11-17 23:10:32 +01:00
|
|
|
|
2010-01-08 18:57:28 +01:00
|
|
|
#ifdef CONFIG_USB_SUSPEND
|
2007-05-29 22:34:52 +02:00
|
|
|
cancel_work_sync(&hcd->wakeup_work);
|
2007-03-13 21:37:30 +01:00
|
|
|
#endif
|
|
|
|
|
2006-01-11 15:55:29 +01:00
|
|
|
mutex_lock(&usb_bus_list_lock);
|
2010-06-09 23:34:17 +02:00
|
|
|
usb_disconnect(&rhdev); /* Sets rhdev to NULL */
|
2006-01-11 15:55:29 +01:00
|
|
|
mutex_unlock(&usb_bus_list_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-06-09 23:34:17 +02:00
|
|
|
/* Prevent any more root-hub status calls from the timer.
|
|
|
|
* The HCD might still restart the timer (if a port status change
|
|
|
|
* interrupt occurs), but usb_hcd_poll_rh_status() won't invoke
|
|
|
|
* the hub_status_data() callback.
|
|
|
|
*/
|
|
|
|
hcd->rh_pollable = 0;
|
2010-06-22 22:39:10 +02:00
|
|
|
clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
|
2010-06-09 23:34:17 +02:00
|
|
|
del_timer_sync(&hcd->rh_timer);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
hcd->driver->stop(hcd);
|
|
|
|
hcd->state = HC_STATE_HALT;
|
|
|
|
|
2010-06-09 23:34:17 +02:00
|
|
|
/* In case the HCD restarted the timer, stop it again. */
|
2010-06-22 22:39:10 +02:00
|
|
|
clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
|
2007-03-13 16:10:52 +01:00
|
|
|
del_timer_sync(&hcd->rh_timer);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (hcd->irq >= 0)
|
|
|
|
free_irq(hcd->irq, hcd);
|
2010-06-09 23:34:17 +02:00
|
|
|
|
|
|
|
usb_put_dev(hcd->self.root_hub);
|
2005-04-17 00:20:36 +02:00
|
|
|
usb_deregister_bus(&hcd->self);
|
|
|
|
hcd_buffer_destroy(hcd);
|
|
|
|
}
|
2008-01-25 18:12:21 +01:00
|
|
|
EXPORT_SYMBOL_GPL(usb_remove_hcd);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
USB: Properly unregister reboot notifier in case of failure in ehci hcd
If some problem occurs during ehci startup, for instance, request_irq fails,
echi hcd driver tries it best to cleanup, but fails to unregister reboot
notifier, which in turn leads to crash on reboot/poweroff.
The following patch resolves this problem by not using reboot notifiers
anymore, but instead making ehci/ohci driver get its own shutdown method. For
PCI, it is done through pci glue, for everything else through platform driver
glue.
One downside: sa1111 does not use platform driver stuff, and does not have its
own shutdown hook, so no 'shutdown' is called for it now. I'm not sure if it
is really necessary on that platform, though.
Signed-off-by: Aleks Gorelov <dared1st@yahoo.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: David Brownell <david-b@pacbell.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-08-09 02:24:08 +02:00
|
|
|
void
|
|
|
|
usb_hcd_platform_shutdown(struct platform_device* dev)
|
|
|
|
{
|
|
|
|
struct usb_hcd *hcd = platform_get_drvdata(dev);
|
|
|
|
|
|
|
|
if (hcd->driver->shutdown)
|
|
|
|
hcd->driver->shutdown(hcd);
|
|
|
|
}
|
2008-01-25 18:12:21 +01:00
|
|
|
EXPORT_SYMBOL_GPL(usb_hcd_platform_shutdown);
|
USB: Properly unregister reboot notifier in case of failure in ehci hcd
If some problem occurs during ehci startup, for instance, request_irq fails,
echi hcd driver tries it best to cleanup, but fails to unregister reboot
notifier, which in turn leads to crash on reboot/poweroff.
The following patch resolves this problem by not using reboot notifiers
anymore, but instead making ehci/ohci driver get its own shutdown method. For
PCI, it is done through pci glue, for everything else through platform driver
glue.
One downside: sa1111 does not use platform driver stuff, and does not have its
own shutdown hook, so no 'shutdown' is called for it now. I'm not sure if it
is really necessary on that platform, though.
Signed-off-by: Aleks Gorelov <dared1st@yahoo.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: David Brownell <david-b@pacbell.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2006-08-09 02:24:08 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2008-11-14 05:31:21 +01:00
|
|
|
#if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2008-11-14 05:31:21 +01:00
|
|
|
#endif /* CONFIG_USB_MON || CONFIG_USB_MON_MODULE */
|