2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* USB hub driver.
|
|
|
|
*
|
|
|
|
* (C) Copyright 1999 Linus Torvalds
|
|
|
|
* (C) Copyright 1999 Johannes Erdfelt
|
|
|
|
* (C) Copyright 1999 Gregory P. Smith
|
|
|
|
* (C) Copyright 2001 Brad Hards (bhards@bigpond.net.au)
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/ioctl.h>
|
|
|
|
#include <linux/usb.h>
|
|
|
|
#include <linux/usbdevice_fs.h>
|
2010-04-24 21:21:52 +00:00
|
|
|
#include <linux/usb/hcd.h>
|
2010-07-21 22:05:01 +00:00
|
|
|
#include <linux/usb/quirks.h>
|
2005-06-20 21:29:58 +00:00
|
|
|
#include <linux/kthread.h>
|
2006-01-11 14:55:29 +00:00
|
|
|
#include <linux/mutex.h>
|
2006-12-07 04:34:23 +00:00
|
|
|
#include <linux/freezer.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/byteorder.h>
|
|
|
|
|
|
|
|
#include "usb.h"
|
|
|
|
|
2007-11-27 06:11:55 +00:00
|
|
|
/* if we are in debug mode, always announce new devices */
|
|
|
|
#ifdef DEBUG
|
|
|
|
#ifndef CONFIG_USB_ANNOUNCE_NEW_DEVICES
|
|
|
|
#define CONFIG_USB_ANNOUNCE_NEW_DEVICES
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2006-11-06 16:56:13 +00:00
|
|
|
struct usb_hub {
|
|
|
|
struct device *intfdev; /* the "interface" device */
|
|
|
|
struct usb_device *hdev;
|
2007-05-04 15:55:11 +00:00
|
|
|
struct kref kref;
|
2006-11-06 16:56:13 +00:00
|
|
|
struct urb *urb; /* for interrupt polling pipe */
|
|
|
|
|
|
|
|
/* buffer for urb ... with extra space in case of babble */
|
|
|
|
char (*buffer)[8];
|
|
|
|
union {
|
|
|
|
struct usb_hub_status hub;
|
|
|
|
struct usb_port_status port;
|
|
|
|
} *status; /* buffer for status reports */
|
2007-02-05 14:56:15 +00:00
|
|
|
struct mutex status_mutex; /* for the status buffer */
|
2006-11-06 16:56:13 +00:00
|
|
|
|
|
|
|
int error; /* last reported error */
|
|
|
|
int nerrors; /* track consecutive errors */
|
|
|
|
|
|
|
|
struct list_head event_list; /* hubs w/data or errs ready */
|
|
|
|
unsigned long event_bits[1]; /* status change bitmask */
|
|
|
|
unsigned long change_bits[1]; /* ports with logical connect
|
|
|
|
status change */
|
|
|
|
unsigned long busy_bits[1]; /* ports being reset or
|
|
|
|
resumed */
|
2009-10-27 19:20:13 +00:00
|
|
|
unsigned long removed_bits[1]; /* ports with a "removed"
|
|
|
|
device present */
|
2006-11-06 16:56:13 +00:00
|
|
|
#if USB_MAXCHILDREN > 31 /* 8*sizeof(unsigned long) - 1 */
|
|
|
|
#error event_bits[] is too short!
|
|
|
|
#endif
|
|
|
|
|
|
|
|
struct usb_hub_descriptor *descriptor; /* class descriptor */
|
|
|
|
struct usb_tt tt; /* Transaction Translator */
|
|
|
|
|
|
|
|
unsigned mA_per_port; /* current for each child */
|
|
|
|
|
|
|
|
unsigned limited_power:1;
|
|
|
|
unsigned quiescing:1;
|
2007-05-04 15:55:11 +00:00
|
|
|
unsigned disconnected:1;
|
2006-11-06 16:56:13 +00:00
|
|
|
|
|
|
|
unsigned has_indicators:1;
|
|
|
|
u8 indicator[USB_MAXCHILDREN];
|
2006-12-05 19:36:26 +00:00
|
|
|
struct delayed_work leds;
|
2008-09-22 18:44:26 +00:00
|
|
|
struct delayed_work init_work;
|
2009-06-29 14:56:54 +00:00
|
|
|
void **port_owners;
|
2006-11-06 16:56:13 +00:00
|
|
|
};
|
|
|
|
|
2001-09-17 07:00:00 +00:00
|
|
|
static inline int hub_is_superspeed(struct usb_device *hdev)
|
|
|
|
{
|
|
|
|
return (hdev->descriptor.bDeviceProtocol == 3);
|
|
|
|
}
|
2006-11-06 16:56:13 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Protect struct usb_device->state and ->children members
|
2005-11-17 22:10:32 +00:00
|
|
|
* Note: Both are also protected by ->dev.sem, except that ->state can
|
2005-04-16 22:20:36 +00:00
|
|
|
* change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */
|
|
|
|
static DEFINE_SPINLOCK(device_state_lock);
|
|
|
|
|
|
|
|
/* khubd's worklist and its lock */
|
|
|
|
static DEFINE_SPINLOCK(hub_event_lock);
|
|
|
|
static LIST_HEAD(hub_event_list); /* List of hubs needing servicing */
|
|
|
|
|
|
|
|
/* Wakes up khubd */
|
|
|
|
static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);
|
|
|
|
|
2005-06-20 21:29:58 +00:00
|
|
|
static struct task_struct *khubd_task;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* cycle leds on hubs that aren't blinking for attention */
|
|
|
|
static int blinkenlights = 0;
|
|
|
|
module_param (blinkenlights, bool, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC (blinkenlights, "true to cycle leds on hubs");
|
|
|
|
|
2008-10-10 14:24:45 +00:00
|
|
|
/*
|
|
|
|
* Device SATA8000 FW1.0 from DATAST0R Technology Corp requires about
|
|
|
|
* 10 seconds to send reply for the initial 64-byte descriptor request.
|
|
|
|
*/
|
|
|
|
/* define initial 64-byte descriptor request timeout in milliseconds */
|
|
|
|
static int initial_descriptor_timeout = USB_CTRL_GET_TIMEOUT;
|
|
|
|
module_param(initial_descriptor_timeout, int, S_IRUGO|S_IWUSR);
|
2008-12-15 07:32:01 +00:00
|
|
|
MODULE_PARM_DESC(initial_descriptor_timeout,
|
|
|
|
"initial 64-byte descriptor request timeout in milliseconds "
|
|
|
|
"(default 5000 - 5.0 seconds)");
|
2008-10-10 14:24:45 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* As of 2.6.10 we introduce a new USB device initialization scheme which
|
|
|
|
* closely resembles the way Windows works. Hopefully it will be compatible
|
|
|
|
* with a wider range of devices than the old scheme. However some previously
|
|
|
|
* working devices may start giving rise to "device not accepting address"
|
|
|
|
* errors; if that happens the user can try the old scheme by adjusting the
|
|
|
|
* following module parameters.
|
|
|
|
*
|
|
|
|
* For maximum flexibility there are two boolean parameters to control the
|
|
|
|
* hub driver's behavior. On the first initialization attempt, if the
|
|
|
|
* "old_scheme_first" parameter is set then the old scheme will be used,
|
|
|
|
* otherwise the new scheme is used. If that fails and "use_both_schemes"
|
|
|
|
* is set, then the driver will make another attempt, using the other scheme.
|
|
|
|
*/
|
|
|
|
static int old_scheme_first = 0;
|
|
|
|
module_param(old_scheme_first, bool, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(old_scheme_first,
|
|
|
|
"start with the old device initialization scheme");
|
|
|
|
|
|
|
|
static int use_both_schemes = 1;
|
|
|
|
module_param(use_both_schemes, bool, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(use_both_schemes,
|
|
|
|
"try the other device initialization scheme if the "
|
|
|
|
"first one fails");
|
|
|
|
|
2007-10-10 20:27:07 +00:00
|
|
|
/* Mutual exclusion for EHCI CF initialization. This interferes with
|
|
|
|
* port reset on some companion controllers.
|
|
|
|
*/
|
|
|
|
DECLARE_RWSEM(ehci_cf_port_reset_rwsem);
|
|
|
|
EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
|
|
|
|
|
2008-04-28 15:07:07 +00:00
|
|
|
#define HUB_DEBOUNCE_TIMEOUT 1500
|
|
|
|
#define HUB_DEBOUNCE_STEP 25
|
|
|
|
#define HUB_DEBOUNCE_STABLE 100
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-18 14:00:29 +00:00
|
|
|
static int usb_reset_and_verify_device(struct usb_device *udev);
|
|
|
|
|
2010-12-07 05:00:19 +00:00
|
|
|
static inline char *portspeed(struct usb_hub *hub, int portstatus)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-12-07 05:00:19 +00:00
|
|
|
if (hub_is_superspeed(hub->hdev))
|
|
|
|
return "5.0 Gb/s";
|
2010-03-04 16:32:30 +00:00
|
|
|
if (portstatus & USB_PORT_STAT_HIGH_SPEED)
|
2005-04-16 22:20:36 +00:00
|
|
|
return "480 Mb/s";
|
2010-03-04 16:32:30 +00:00
|
|
|
else if (portstatus & USB_PORT_STAT_LOW_SPEED)
|
2005-04-16 22:20:36 +00:00
|
|
|
return "1.5 Mb/s";
|
|
|
|
else
|
|
|
|
return "12 Mb/s";
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Note that hdev or one of its children must be locked! */
|
2009-07-22 18:41:18 +00:00
|
|
|
static struct usb_hub *hdev_to_hub(struct usb_device *hdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-07-22 18:41:18 +00:00
|
|
|
if (!hdev || !hdev->actconfig)
|
|
|
|
return NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
return usb_get_intfdata(hdev->actconfig->interface[0]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* USB 2.0 spec Section 11.24.4.5 */
|
2001-09-17 07:00:00 +00:00
|
|
|
static int get_hub_descriptor(struct usb_device *hdev, void *data)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2001-09-17 07:00:00 +00:00
|
|
|
int i, ret, size;
|
|
|
|
unsigned dtype;
|
|
|
|
|
|
|
|
if (hub_is_superspeed(hdev)) {
|
|
|
|
dtype = USB_DT_SS_HUB;
|
|
|
|
size = USB_DT_SS_HUB_SIZE;
|
|
|
|
} else {
|
|
|
|
dtype = USB_DT_HUB;
|
|
|
|
size = sizeof(struct usb_hub_descriptor);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
|
|
ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
|
|
|
|
USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
|
2001-09-17 07:00:00 +00:00
|
|
|
dtype << 8, 0, data, size,
|
2005-04-16 22:20:36 +00:00
|
|
|
USB_CTRL_GET_TIMEOUT);
|
|
|
|
if (ret >= (USB_DT_HUB_NONVAR_SIZE + 2))
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* USB 2.0 spec Section 11.24.2.1
|
|
|
|
*/
|
|
|
|
static int clear_hub_feature(struct usb_device *hdev, int feature)
|
|
|
|
{
|
|
|
|
return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
|
|
|
|
USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* USB 2.0 spec Section 11.24.2.2
|
|
|
|
*/
|
|
|
|
static int clear_port_feature(struct usb_device *hdev, int port1, int feature)
|
|
|
|
{
|
|
|
|
return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
|
|
|
|
USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
|
|
|
|
NULL, 0, 1000);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* USB 2.0 spec Section 11.24.2.13
|
|
|
|
*/
|
|
|
|
static int set_port_feature(struct usb_device *hdev, int port1, int feature)
|
|
|
|
{
|
|
|
|
return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
|
|
|
|
USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
|
|
|
|
NULL, 0, 1000);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7
|
|
|
|
* for info about using port indicators
|
|
|
|
*/
|
|
|
|
static void set_port_led(
|
|
|
|
struct usb_hub *hub,
|
|
|
|
int port1,
|
|
|
|
int selector
|
|
|
|
)
|
|
|
|
{
|
|
|
|
int status = set_port_feature(hub->hdev, (selector << 8) | port1,
|
|
|
|
USB_PORT_FEAT_INDICATOR);
|
|
|
|
if (status < 0)
|
|
|
|
dev_dbg (hub->intfdev,
|
|
|
|
"port %d indicator %s status %d\n",
|
|
|
|
port1,
|
|
|
|
({ char *s; switch (selector) {
|
|
|
|
case HUB_LED_AMBER: s = "amber"; break;
|
|
|
|
case HUB_LED_GREEN: s = "green"; break;
|
|
|
|
case HUB_LED_OFF: s = "off"; break;
|
|
|
|
case HUB_LED_AUTO: s = "auto"; break;
|
|
|
|
default: s = "??"; break;
|
|
|
|
}; s; }),
|
|
|
|
status);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define LED_CYCLE_PERIOD ((2*HZ)/3)
|
|
|
|
|
2006-11-22 14:57:56 +00:00
|
|
|
static void led_work (struct work_struct *work)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-11-22 14:57:56 +00:00
|
|
|
struct usb_hub *hub =
|
|
|
|
container_of(work, struct usb_hub, leds.work);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct usb_device *hdev = hub->hdev;
|
|
|
|
unsigned i;
|
|
|
|
unsigned changed = 0;
|
|
|
|
int cursor = -1;
|
|
|
|
|
|
|
|
if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < hub->descriptor->bNbrPorts; i++) {
|
|
|
|
unsigned selector, mode;
|
|
|
|
|
|
|
|
/* 30%-50% duty cycle */
|
|
|
|
|
|
|
|
switch (hub->indicator[i]) {
|
|
|
|
/* cycle marker */
|
|
|
|
case INDICATOR_CYCLE:
|
|
|
|
cursor = i;
|
|
|
|
selector = HUB_LED_AUTO;
|
|
|
|
mode = INDICATOR_AUTO;
|
|
|
|
break;
|
|
|
|
/* blinking green = sw attention */
|
|
|
|
case INDICATOR_GREEN_BLINK:
|
|
|
|
selector = HUB_LED_GREEN;
|
|
|
|
mode = INDICATOR_GREEN_BLINK_OFF;
|
|
|
|
break;
|
|
|
|
case INDICATOR_GREEN_BLINK_OFF:
|
|
|
|
selector = HUB_LED_OFF;
|
|
|
|
mode = INDICATOR_GREEN_BLINK;
|
|
|
|
break;
|
|
|
|
/* blinking amber = hw attention */
|
|
|
|
case INDICATOR_AMBER_BLINK:
|
|
|
|
selector = HUB_LED_AMBER;
|
|
|
|
mode = INDICATOR_AMBER_BLINK_OFF;
|
|
|
|
break;
|
|
|
|
case INDICATOR_AMBER_BLINK_OFF:
|
|
|
|
selector = HUB_LED_OFF;
|
|
|
|
mode = INDICATOR_AMBER_BLINK;
|
|
|
|
break;
|
|
|
|
/* blink green/amber = reserved */
|
|
|
|
case INDICATOR_ALT_BLINK:
|
|
|
|
selector = HUB_LED_GREEN;
|
|
|
|
mode = INDICATOR_ALT_BLINK_OFF;
|
|
|
|
break;
|
|
|
|
case INDICATOR_ALT_BLINK_OFF:
|
|
|
|
selector = HUB_LED_AMBER;
|
|
|
|
mode = INDICATOR_ALT_BLINK;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (selector != HUB_LED_AUTO)
|
|
|
|
changed = 1;
|
|
|
|
set_port_led(hub, i + 1, selector);
|
|
|
|
hub->indicator[i] = mode;
|
|
|
|
}
|
|
|
|
if (!changed && blinkenlights) {
|
|
|
|
cursor++;
|
|
|
|
cursor %= hub->descriptor->bNbrPorts;
|
|
|
|
set_port_led(hub, cursor + 1, HUB_LED_GREEN);
|
|
|
|
hub->indicator[cursor] = INDICATOR_CYCLE;
|
|
|
|
changed++;
|
|
|
|
}
|
|
|
|
if (changed)
|
|
|
|
schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* use a short timeout for hub/port status fetches */
|
|
|
|
#define USB_STS_TIMEOUT 1000
|
|
|
|
#define USB_STS_RETRIES 5
|
|
|
|
|
|
|
|
/*
|
|
|
|
* USB 2.0 spec Section 11.24.2.6
|
|
|
|
*/
|
|
|
|
static int get_hub_status(struct usb_device *hdev,
|
|
|
|
struct usb_hub_status *data)
|
|
|
|
{
|
|
|
|
int i, status = -ETIMEDOUT;
|
|
|
|
|
2011-05-20 12:53:25 +00:00
|
|
|
for (i = 0; i < USB_STS_RETRIES &&
|
|
|
|
(status == -ETIMEDOUT || status == -EPIPE); i++) {
|
2005-04-16 22:20:36 +00:00
|
|
|
status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
|
|
|
|
USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
|
|
|
|
data, sizeof(*data), USB_STS_TIMEOUT);
|
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* USB 2.0 spec Section 11.24.2.7
|
|
|
|
*/
|
|
|
|
static int get_port_status(struct usb_device *hdev, int port1,
|
|
|
|
struct usb_port_status *data)
|
|
|
|
{
|
|
|
|
int i, status = -ETIMEDOUT;
|
|
|
|
|
2011-05-20 12:53:25 +00:00
|
|
|
for (i = 0; i < USB_STS_RETRIES &&
|
|
|
|
(status == -ETIMEDOUT || status == -EPIPE); i++) {
|
2005-04-16 22:20:36 +00:00
|
|
|
status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
|
|
|
|
USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port1,
|
|
|
|
data, sizeof(*data), USB_STS_TIMEOUT);
|
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2008-03-03 20:15:43 +00:00
|
|
|
static int hub_port_status(struct usb_hub *hub, int port1,
|
|
|
|
u16 *status, u16 *change)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&hub->status_mutex);
|
|
|
|
ret = get_port_status(hub->hdev, port1, &hub->status->port);
|
|
|
|
if (ret < 4) {
|
|
|
|
dev_err(hub->intfdev,
|
|
|
|
"%s failed (err = %d)\n", __func__, ret);
|
|
|
|
if (ret >= 0)
|
|
|
|
ret = -EIO;
|
|
|
|
} else {
|
|
|
|
*status = le16_to_cpu(hub->status->port.wPortStatus);
|
|
|
|
*change = le16_to_cpu(hub->status->port.wPortChange);
|
2001-09-17 07:00:00 +00:00
|
|
|
|
2008-03-03 20:15:43 +00:00
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
mutex_unlock(&hub->status_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static void kick_khubd(struct usb_hub *hub)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&hub_event_lock, flags);
|
2007-10-26 21:54:35 +00:00
|
|
|
if (!hub->disconnected && list_empty(&hub->event_list)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
list_add_tail(&hub->event_list, &hub_event_list);
|
2009-12-07 18:01:37 +00:00
|
|
|
|
|
|
|
/* Suppress autosuspend until khubd runs */
|
|
|
|
usb_autopm_get_interface_no_resume(
|
|
|
|
to_usb_interface(hub->intfdev));
|
2005-04-16 22:20:36 +00:00
|
|
|
wake_up(&khubd_wait);
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&hub_event_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void usb_kick_khubd(struct usb_device *hdev)
|
|
|
|
{
|
2009-07-22 18:41:18 +00:00
|
|
|
struct usb_hub *hub = hdev_to_hub(hdev);
|
|
|
|
|
|
|
|
if (hub)
|
|
|
|
kick_khubd(hub);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* completion function, fires on port status changes and various faults */
|
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 13:55:46 +00:00
|
|
|
static void hub_irq(struct urb *urb)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-09-13 19:38:41 +00:00
|
|
|
struct usb_hub *hub = urb->context;
|
2007-08-24 19:42:52 +00:00
|
|
|
int status = urb->status;
|
2009-03-13 11:19:18 +00:00
|
|
|
unsigned i;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long bits;
|
|
|
|
|
2007-08-24 19:42:52 +00:00
|
|
|
switch (status) {
|
2005-04-16 22:20:36 +00:00
|
|
|
case -ENOENT: /* synchronous unlink */
|
|
|
|
case -ECONNRESET: /* async unlink */
|
|
|
|
case -ESHUTDOWN: /* hardware going away */
|
|
|
|
return;
|
|
|
|
|
|
|
|
default: /* presumably an error */
|
|
|
|
/* Cause a hub reset after 10 consecutive errors */
|
2007-08-24 19:42:52 +00:00
|
|
|
dev_dbg (hub->intfdev, "transfer --> %d\n", status);
|
2005-04-16 22:20:36 +00:00
|
|
|
if ((++hub->nerrors < 10) || hub->error)
|
|
|
|
goto resubmit;
|
2007-08-24 19:42:52 +00:00
|
|
|
hub->error = status;
|
2005-04-16 22:20:36 +00:00
|
|
|
/* FALL THROUGH */
|
2006-09-13 19:38:41 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* let khubd handle things */
|
|
|
|
case 0: /* we got data: port status changed */
|
|
|
|
bits = 0;
|
|
|
|
for (i = 0; i < urb->actual_length; ++i)
|
|
|
|
bits |= ((unsigned long) ((*hub->buffer)[i]))
|
|
|
|
<< (i*8);
|
|
|
|
hub->event_bits[0] = bits;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
hub->nerrors = 0;
|
|
|
|
|
|
|
|
/* Something happened, let khubd figure it out */
|
|
|
|
kick_khubd(hub);
|
|
|
|
|
|
|
|
resubmit:
|
|
|
|
if (hub->quiescing)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if ((status = usb_submit_urb (hub->urb, GFP_ATOMIC)) != 0
|
|
|
|
&& status != -ENODEV && status != -EPERM)
|
|
|
|
dev_err (hub->intfdev, "resubmit --> %d\n", status);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* USB 2.0 spec Section 11.24.2.3 */
|
|
|
|
static inline int
|
|
|
|
hub_clear_tt_buffer (struct usb_device *hdev, u16 devinfo, u16 tt)
|
|
|
|
{
|
2009-11-18 16:37:15 +00:00
|
|
|
return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
|
2005-04-16 22:20:36 +00:00
|
|
|
HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo,
|
|
|
|
tt, NULL, 0, 1000);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* enumeration blocks khubd for a long time. we use keventd instead, since
|
|
|
|
* long blocking there is the exception, not the rule. accordingly, HCDs
|
|
|
|
* talking to TTs must queue control transfers (not just bulk and iso), so
|
|
|
|
* both can talk to the same hub concurrently.
|
|
|
|
*/
|
2009-06-29 14:43:32 +00:00
|
|
|
static void hub_tt_work(struct work_struct *work)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-11-22 14:57:56 +00:00
|
|
|
struct usb_hub *hub =
|
2009-06-29 14:43:32 +00:00
|
|
|
container_of(work, struct usb_hub, tt.clear_work);
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags;
|
2007-05-14 23:48:02 +00:00
|
|
|
int limit = 100;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave (&hub->tt.lock, flags);
|
2007-05-14 23:48:02 +00:00
|
|
|
while (--limit && !list_empty (&hub->tt.clear_list)) {
|
2009-04-22 20:03:05 +00:00
|
|
|
struct list_head *next;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct usb_tt_clear *clear;
|
|
|
|
struct usb_device *hdev = hub->hdev;
|
2009-06-29 14:43:32 +00:00
|
|
|
const struct hc_driver *drv;
|
2005-04-16 22:20:36 +00:00
|
|
|
int status;
|
|
|
|
|
2009-04-22 20:03:05 +00:00
|
|
|
next = hub->tt.clear_list.next;
|
|
|
|
clear = list_entry (next, struct usb_tt_clear, clear_list);
|
2005-04-16 22:20:36 +00:00
|
|
|
list_del (&clear->clear_list);
|
|
|
|
|
|
|
|
/* drop lock so HCD can concurrently report other TT errors */
|
|
|
|
spin_unlock_irqrestore (&hub->tt.lock, flags);
|
|
|
|
status = hub_clear_tt_buffer (hdev, clear->devinfo, clear->tt);
|
|
|
|
if (status)
|
|
|
|
dev_err (&hdev->dev,
|
|
|
|
"clear tt %d (%04x) error %d\n",
|
|
|
|
clear->tt, clear->devinfo, status);
|
2009-06-29 14:43:32 +00:00
|
|
|
|
|
|
|
/* Tell the HCD, even if the operation failed */
|
|
|
|
drv = clear->hcd->driver;
|
|
|
|
if (drv->clear_tt_buffer_complete)
|
|
|
|
(drv->clear_tt_buffer_complete)(clear->hcd, clear->ep);
|
|
|
|
|
2005-04-19 00:39:34 +00:00
|
|
|
kfree(clear);
|
2009-06-29 14:43:32 +00:00
|
|
|
spin_lock_irqsave(&hub->tt.lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore (&hub->tt.lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-06-29 14:43:32 +00:00
|
|
|
* usb_hub_clear_tt_buffer - clear control/bulk TT state in high speed hub
|
|
|
|
* @urb: an URB associated with the failed or incomplete split transaction
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* High speed HCDs use this to tell the hub driver that some split control or
|
|
|
|
* bulk transaction failed in a way that requires clearing internal state of
|
|
|
|
* a transaction translator. This is normally detected (and reported) from
|
|
|
|
* interrupt context.
|
|
|
|
*
|
|
|
|
* It may not be possible for that hub to handle additional full (or low)
|
|
|
|
* speed transactions until that state is fully cleared out.
|
|
|
|
*/
|
2009-06-29 14:43:32 +00:00
|
|
|
int usb_hub_clear_tt_buffer(struct urb *urb)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-06-29 14:43:32 +00:00
|
|
|
struct usb_device *udev = urb->dev;
|
|
|
|
int pipe = urb->pipe;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct usb_tt *tt = udev->tt;
|
|
|
|
unsigned long flags;
|
|
|
|
struct usb_tt_clear *clear;
|
|
|
|
|
|
|
|
/* we've got to cope with an arbitrary number of pending TT clears,
|
|
|
|
* since each TT has "at least two" buffers that can need it (and
|
|
|
|
* there can be many TTs per hub). even if they're uncommon.
|
|
|
|
*/
|
2006-12-07 04:33:16 +00:00
|
|
|
if ((clear = kmalloc (sizeof *clear, GFP_ATOMIC)) == NULL) {
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_err (&udev->dev, "can't save CLEAR_TT_BUFFER state\n");
|
|
|
|
/* FIXME recover somehow ... RESET_TT? */
|
2009-06-29 14:43:32 +00:00
|
|
|
return -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* info that CLEAR_TT_BUFFER needs */
|
|
|
|
clear->tt = tt->multi ? udev->ttport : 1;
|
|
|
|
clear->devinfo = usb_pipeendpoint (pipe);
|
|
|
|
clear->devinfo |= udev->devnum << 4;
|
|
|
|
clear->devinfo |= usb_pipecontrol (pipe)
|
|
|
|
? (USB_ENDPOINT_XFER_CONTROL << 11)
|
|
|
|
: (USB_ENDPOINT_XFER_BULK << 11);
|
|
|
|
if (usb_pipein (pipe))
|
|
|
|
clear->devinfo |= 1 << 15;
|
2009-06-29 14:43:32 +00:00
|
|
|
|
|
|
|
/* info for completion callback */
|
|
|
|
clear->hcd = bus_to_hcd(udev->bus);
|
|
|
|
clear->ep = urb->ep;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* tell keventd to clear state for this TT */
|
|
|
|
spin_lock_irqsave (&tt->lock, flags);
|
|
|
|
list_add_tail (&clear->clear_list, &tt->clear_list);
|
2009-06-29 14:43:32 +00:00
|
|
|
schedule_work(&tt->clear_work);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irqrestore (&tt->lock, flags);
|
2009-06-29 14:43:32 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-06-29 14:43:32 +00:00
|
|
|
EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-09-22 18:44:26 +00:00
|
|
|
/* If do_delay is false, return the number of milliseconds the caller
|
|
|
|
* needs to delay.
|
|
|
|
*/
|
|
|
|
static unsigned hub_power_on(struct usb_hub *hub, bool do_delay)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int port1;
|
2005-08-31 17:41:44 +00:00
|
|
|
unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;
|
2008-09-22 18:44:26 +00:00
|
|
|
unsigned delay;
|
2006-04-27 19:54:22 +00:00
|
|
|
u16 wHubCharacteristics =
|
|
|
|
le16_to_cpu(hub->descriptor->wHubCharacteristics);
|
|
|
|
|
|
|
|
/* Enable power on each port. Some hubs have reserved values
|
|
|
|
* of LPSM (> 2) in their descriptors, even though they are
|
|
|
|
* USB 2.0 hubs. Some hubs do not implement port-power switching
|
|
|
|
* but only emulate it. In all cases, the ports won't work
|
|
|
|
* unless we send these messages to the hub.
|
|
|
|
*/
|
|
|
|
if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2)
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_dbg(hub->intfdev, "enabling power on all ports\n");
|
2006-04-27 19:54:22 +00:00
|
|
|
else
|
|
|
|
dev_dbg(hub->intfdev, "trying to enable port power on "
|
|
|
|
"non-switchable hub\n");
|
|
|
|
for (port1 = 1; port1 <= hub->descriptor->bNbrPorts; port1++)
|
|
|
|
set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-08-31 17:41:44 +00:00
|
|
|
/* Wait at least 100 msec for power to become stable */
|
2008-09-22 18:44:26 +00:00
|
|
|
delay = max(pgood_delay, (unsigned) 100);
|
|
|
|
if (do_delay)
|
|
|
|
msleep(delay);
|
|
|
|
return delay;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hub_hub_status(struct usb_hub *hub,
|
|
|
|
u16 *status, u16 *change)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2007-02-05 14:56:15 +00:00
|
|
|
mutex_lock(&hub->status_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
ret = get_hub_status(hub->hdev, &hub->status->hub);
|
|
|
|
if (ret < 0)
|
|
|
|
dev_err (hub->intfdev,
|
2008-03-04 00:08:34 +00:00
|
|
|
"%s failed (err = %d)\n", __func__, ret);
|
2005-04-16 22:20:36 +00:00
|
|
|
else {
|
|
|
|
*status = le16_to_cpu(hub->status->hub.wHubStatus);
|
|
|
|
*change = le16_to_cpu(hub->status->hub.wHubChange);
|
|
|
|
ret = 0;
|
|
|
|
}
|
2007-02-05 14:56:15 +00:00
|
|
|
mutex_unlock(&hub->status_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-08-10 21:04:13 +00:00
|
|
|
static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
|
|
|
|
{
|
|
|
|
struct usb_device *hdev = hub->hdev;
|
2007-05-04 15:52:20 +00:00
|
|
|
int ret = 0;
|
2005-08-10 21:04:13 +00:00
|
|
|
|
2007-05-04 15:52:20 +00:00
|
|
|
if (hdev->children[port1-1] && set_state)
|
2005-08-10 21:04:13 +00:00
|
|
|
usb_set_device_state(hdev->children[port1-1],
|
|
|
|
USB_STATE_NOTATTACHED);
|
2001-09-17 07:00:00 +00:00
|
|
|
if (!hub->error && !hub_is_superspeed(hub->hdev))
|
2007-05-04 15:52:20 +00:00
|
|
|
ret = clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);
|
2005-08-10 21:04:13 +00:00
|
|
|
if (ret)
|
|
|
|
dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
|
2007-05-04 15:52:20 +00:00
|
|
|
port1, ret);
|
2005-08-10 21:04:13 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-05-04 15:52:20 +00:00
|
|
|
/*
|
2011-02-27 04:33:56 +00:00
|
|
|
* Disable a port and mark a logical connect-change event, so that some
|
2007-05-04 15:52:20 +00:00
|
|
|
* time later khubd will disconnect() any existing usb_device on the port
|
|
|
|
* and will re-enumerate if there actually is a device attached.
|
|
|
|
*/
|
|
|
|
static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
|
|
|
|
{
|
|
|
|
dev_dbg(hub->intfdev, "logical disconnect on port %d\n", port1);
|
|
|
|
hub_port_disable(hub, port1, 1);
|
2005-11-18 17:06:34 +00:00
|
|
|
|
2007-05-04 15:52:20 +00:00
|
|
|
/* FIXME let caller ask to power down the port:
|
|
|
|
* - some devices won't enumerate without a VBUS power cycle
|
|
|
|
* - SRP saves power that way
|
|
|
|
* - ... new call, TBD ...
|
|
|
|
* That's easy if this hub can switch power per-port, and
|
|
|
|
* khubd reactivates the port later (timer, SRP, etc).
|
|
|
|
* Powerdown must be optional, because of reset/DFU.
|
|
|
|
*/
|
|
|
|
|
|
|
|
set_bit(port1, hub->change_bits);
|
|
|
|
kick_khubd(hub);
|
|
|
|
}
|
|
|
|
|
2009-10-27 19:20:13 +00:00
|
|
|
/**
|
|
|
|
* usb_remove_device - disable a device's port on its parent hub
|
|
|
|
* @udev: device to be disabled and removed
|
|
|
|
* Context: @udev locked, must be able to sleep.
|
|
|
|
*
|
|
|
|
* After @udev's port has been disabled, khubd is notified and it will
|
|
|
|
* see that the device has been disconnected. When the device is
|
|
|
|
* physically unplugged and something is plugged in, the events will
|
|
|
|
* be received and processed normally.
|
|
|
|
*/
|
|
|
|
int usb_remove_device(struct usb_device *udev)
|
|
|
|
{
|
|
|
|
struct usb_hub *hub;
|
|
|
|
struct usb_interface *intf;
|
|
|
|
|
|
|
|
if (!udev->parent) /* Can't remove a root hub */
|
|
|
|
return -EINVAL;
|
|
|
|
hub = hdev_to_hub(udev->parent);
|
|
|
|
intf = to_usb_interface(hub->intfdev);
|
|
|
|
|
|
|
|
usb_autopm_get_interface(intf);
|
|
|
|
set_bit(udev->portnum, hub->removed_bits);
|
|
|
|
hub_port_logical_disconnect(hub, udev->portnum);
|
|
|
|
usb_autopm_put_interface(intf);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-28 15:06:42 +00:00
|
|
|
enum hub_activation_type {
|
2009-12-07 18:01:37 +00:00
|
|
|
HUB_INIT, HUB_INIT2, HUB_INIT3, /* INITs must come first */
|
2008-09-22 18:44:26 +00:00
|
|
|
HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME,
|
2008-04-28 15:06:42 +00:00
|
|
|
};
|
2008-03-03 20:15:51 +00:00
|
|
|
|
2008-09-22 18:44:26 +00:00
|
|
|
static void hub_init_func2(struct work_struct *ws);
|
|
|
|
static void hub_init_func3(struct work_struct *ws);
|
|
|
|
|
2008-04-28 15:07:17 +00:00
|
|
|
static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
|
2008-03-03 20:15:51 +00:00
|
|
|
{
|
|
|
|
struct usb_device *hdev = hub->hdev;
|
2010-12-23 19:12:42 +00:00
|
|
|
struct usb_hcd *hcd;
|
|
|
|
int ret;
|
2008-03-03 20:15:51 +00:00
|
|
|
int port1;
|
2008-04-28 15:07:17 +00:00
|
|
|
int status;
|
2008-04-28 15:07:07 +00:00
|
|
|
bool need_debounce_delay = false;
|
2008-09-22 18:44:26 +00:00
|
|
|
unsigned delay;
|
|
|
|
|
|
|
|
/* Continue a partial initialization */
|
|
|
|
if (type == HUB_INIT2)
|
|
|
|
goto init2;
|
|
|
|
if (type == HUB_INIT3)
|
|
|
|
goto init3;
|
2008-03-03 20:15:51 +00:00
|
|
|
|
2008-04-28 15:07:17 +00:00
|
|
|
/* After a resume, port power should still be on.
|
|
|
|
* For any other type of activation, turn it on.
|
|
|
|
*/
|
2008-09-22 18:44:26 +00:00
|
|
|
if (type != HUB_RESUME) {
|
|
|
|
|
|
|
|
/* Speed up system boot by using a delayed_work for the
|
|
|
|
* hub's initial power-up delays. This is pretty awkward
|
|
|
|
* and the implementation looks like a home-brewed sort of
|
|
|
|
* setjmp/longjmp, but it saves at least 100 ms for each
|
|
|
|
* root hub (assuming usbcore is compiled into the kernel
|
|
|
|
* rather than as a module). It adds up.
|
|
|
|
*
|
|
|
|
* This can't be done for HUB_RESUME or HUB_RESET_RESUME
|
|
|
|
* because for those activation types the ports have to be
|
|
|
|
* operational when we return. In theory this could be done
|
|
|
|
* for HUB_POST_RESET, but it's easier not to.
|
|
|
|
*/
|
|
|
|
if (type == HUB_INIT) {
|
|
|
|
delay = hub_power_on(hub, false);
|
|
|
|
PREPARE_DELAYED_WORK(&hub->init_work, hub_init_func2);
|
|
|
|
schedule_delayed_work(&hub->init_work,
|
|
|
|
msecs_to_jiffies(delay));
|
2008-10-27 16:07:44 +00:00
|
|
|
|
|
|
|
/* Suppress autosuspend until init is done */
|
2009-12-07 18:01:37 +00:00
|
|
|
usb_autopm_get_interface_no_resume(
|
|
|
|
to_usb_interface(hub->intfdev));
|
2008-09-22 18:44:26 +00:00
|
|
|
return; /* Continues at init2: below */
|
2010-12-23 19:12:42 +00:00
|
|
|
} else if (type == HUB_RESET_RESUME) {
|
|
|
|
/* The internal host controller state for the hub device
|
|
|
|
* may be gone after a host power loss on system resume.
|
|
|
|
* Update the device's info so the HW knows it's a hub.
|
|
|
|
*/
|
|
|
|
hcd = bus_to_hcd(hdev->bus);
|
|
|
|
if (hcd->driver->update_hub_device) {
|
|
|
|
ret = hcd->driver->update_hub_device(hcd, hdev,
|
|
|
|
&hub->tt, GFP_NOIO);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(hub->intfdev, "Host not "
|
|
|
|
"accepting hub info "
|
|
|
|
"update.\n");
|
|
|
|
dev_err(hub->intfdev, "LS/FS devices "
|
|
|
|
"and hubs may not work "
|
|
|
|
"under this hub\n.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
hub_power_on(hub, true);
|
2008-09-22 18:44:26 +00:00
|
|
|
} else {
|
|
|
|
hub_power_on(hub, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
init2:
|
2008-04-28 15:07:17 +00:00
|
|
|
|
2008-04-28 15:06:42 +00:00
|
|
|
/* Check each port and set hub->change_bits to let khubd know
|
|
|
|
* which ports need attention.
|
2008-03-03 20:15:51 +00:00
|
|
|
*/
|
|
|
|
for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
|
|
|
|
struct usb_device *udev = hdev->children[port1-1];
|
|
|
|
u16 portstatus, portchange;
|
|
|
|
|
2008-04-28 15:06:42 +00:00
|
|
|
portstatus = portchange = 0;
|
|
|
|
status = hub_port_status(hub, port1, &portstatus, &portchange);
|
|
|
|
if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
|
|
|
|
dev_dbg(hub->intfdev,
|
|
|
|
"port %d: status %04x change %04x\n",
|
|
|
|
port1, portstatus, portchange);
|
|
|
|
|
|
|
|
/* After anything other than HUB_RESUME (i.e., initialization
|
|
|
|
* or any sort of reset), every port should be disabled.
|
|
|
|
* Unconnected ports should likewise be disabled (paranoia),
|
|
|
|
* and so should ports for which we have no usb_device.
|
|
|
|
*/
|
|
|
|
if ((portstatus & USB_PORT_STAT_ENABLE) && (
|
|
|
|
type != HUB_RESUME ||
|
|
|
|
!(portstatus & USB_PORT_STAT_CONNECTION) ||
|
|
|
|
!udev ||
|
|
|
|
udev->state == USB_STATE_NOTATTACHED)) {
|
2010-05-07 10:09:27 +00:00
|
|
|
/*
|
|
|
|
* USB3 protocol ports will automatically transition
|
|
|
|
* to Enabled state when detect an USB3.0 device attach.
|
|
|
|
* Do not disable USB3 protocol ports.
|
|
|
|
*/
|
2010-12-07 05:00:19 +00:00
|
|
|
if (!hub_is_superspeed(hdev)) {
|
2010-05-07 10:09:27 +00:00
|
|
|
clear_port_feature(hdev, port1,
|
|
|
|
USB_PORT_FEAT_ENABLE);
|
|
|
|
portstatus &= ~USB_PORT_STAT_ENABLE;
|
usb: Fix issue with USB 3.0 devices after system resume
When the system suspends and a host controller's power is lost, the USB
core attempts to revive any USB devices that had the persist_enabled flag
set. For non-SuperSpeed devices, it will disable the port, and then set
the udev->reset_resume flag. This will cause the USB core to reset the
device, verify the device descriptors to make sure it's the same device,
and re-install any non-default configurations or alternate interface
settings.
However, we can't disable SuperSpeed root hub ports because that turns off
SuperSpeed terminations, which will inhibit any devices connecting at USB
3.0 speeds. (Plus external hubs don't allow SuperSpeed ports to be
disabled.)
Because of this logic in hub_activate():
/* We can forget about a "removed" device when there's a
* physical disconnect or the connect status changes.
*/
if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
(portchange & USB_PORT_STAT_C_CONNECTION))
clear_bit(port1, hub->removed_bits);
if (!udev || udev->state == USB_STATE_NOTATTACHED) {
/* Tell khubd to disconnect the device or
* check for a new connection
*/
if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
set_bit(port1, hub->change_bits);
} else if (portstatus & USB_PORT_STAT_ENABLE) {
/* The power session apparently survived the resume.
* If there was an overcurrent or suspend change
* (i.e., remote wakeup request), have khubd
* take care of it.
*/
if (portchange)
set_bit(port1, hub->change_bits);
} else if (udev->persist_enabled) {
udev->reset_resume = 1;
set_bit(port1, hub->change_bits);
} else {
/* The power session is gone; tell khubd */
usb_set_device_state(udev, USB_STATE_NOTATTACHED);
set_bit(port1, hub->change_bits);
}
a SuperSpeed device after a resume with a loss of power will never get the
reset_resume flag set. Instead the core will assume the power session
survived and that the device still has the same address, configuration,
and alternate interface settings. The xHCI host controller will have no
knowledge of the device (since all xhci_virt_devices were destroyed when
power loss was discovered, and xhci_discover_or_reset_device() has not
been called), and all URBs to the device will fail.
If the device driver responds by resetting the device, everything will
continue smoothly. However, if lsusb is used before the device driver
resets the device (or there is no driver), then all lsusb descriptor
fetches will fail.
The quick fix is to pretend the port is disabled in hub_activate(), by
clearing the local variable. But I'm not sure what other parts of the hub
driver need to be changed because they have assumptions about when ports
will be disabled.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Signed-off-by: Andiry Xu <andiry.xu@amd.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2010-10-14 14:22:54 +00:00
|
|
|
} else {
|
|
|
|
/* Pretend that power was lost for USB3 devs */
|
|
|
|
portstatus &= ~USB_PORT_STAT_ENABLE;
|
2010-05-07 10:09:27 +00:00
|
|
|
}
|
2008-03-03 20:15:51 +00:00
|
|
|
}
|
|
|
|
|
2008-04-28 15:07:07 +00:00
|
|
|
/* Clear status-change flags; we'll debounce later */
|
|
|
|
if (portchange & USB_PORT_STAT_C_CONNECTION) {
|
|
|
|
need_debounce_delay = true;
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_CONNECTION);
|
|
|
|
}
|
|
|
|
if (portchange & USB_PORT_STAT_C_ENABLE) {
|
|
|
|
need_debounce_delay = true;
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_ENABLE);
|
|
|
|
}
|
2001-09-17 07:00:00 +00:00
|
|
|
if (portchange & USB_PORT_STAT_C_LINK_STATE) {
|
|
|
|
need_debounce_delay = true;
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_PORT_LINK_STATE);
|
|
|
|
}
|
2008-04-28 15:07:07 +00:00
|
|
|
|
2011-11-03 13:07:18 +00:00
|
|
|
if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
|
|
|
|
hub_is_superspeed(hub->hdev)) {
|
|
|
|
need_debounce_delay = true;
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_BH_PORT_RESET);
|
|
|
|
}
|
2009-10-27 19:20:13 +00:00
|
|
|
/* We can forget about a "removed" device when there's a
|
|
|
|
* physical disconnect or the connect status changes.
|
|
|
|
*/
|
|
|
|
if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
|
|
|
|
(portchange & USB_PORT_STAT_C_CONNECTION))
|
|
|
|
clear_bit(port1, hub->removed_bits);
|
|
|
|
|
2008-04-28 15:06:42 +00:00
|
|
|
if (!udev || udev->state == USB_STATE_NOTATTACHED) {
|
|
|
|
/* Tell khubd to disconnect the device or
|
|
|
|
* check for a new connection
|
|
|
|
*/
|
|
|
|
if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
|
|
|
|
set_bit(port1, hub->change_bits);
|
|
|
|
|
|
|
|
} else if (portstatus & USB_PORT_STAT_ENABLE) {
|
|
|
|
/* The power session apparently survived the resume.
|
|
|
|
* If there was an overcurrent or suspend change
|
|
|
|
* (i.e., remote wakeup request), have khubd
|
|
|
|
* take care of it.
|
|
|
|
*/
|
|
|
|
if (portchange)
|
|
|
|
set_bit(port1, hub->change_bits);
|
2008-03-03 20:15:51 +00:00
|
|
|
|
2008-04-28 15:06:42 +00:00
|
|
|
} else if (udev->persist_enabled) {
|
|
|
|
#ifdef CONFIG_PM
|
2008-03-03 20:15:51 +00:00
|
|
|
udev->reset_resume = 1;
|
2008-04-28 15:06:42 +00:00
|
|
|
#endif
|
2008-04-28 15:06:55 +00:00
|
|
|
set_bit(port1, hub->change_bits);
|
|
|
|
|
2008-04-28 15:06:42 +00:00
|
|
|
} else {
|
|
|
|
/* The power session is gone; tell khubd */
|
|
|
|
usb_set_device_state(udev, USB_STATE_NOTATTACHED);
|
|
|
|
set_bit(port1, hub->change_bits);
|
2008-03-03 20:15:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-28 15:07:07 +00:00
|
|
|
/* If no port-status-change flags were set, we don't need any
|
|
|
|
* debouncing. If flags were set we can try to debounce the
|
|
|
|
* ports all at once right now, instead of letting khubd do them
|
|
|
|
* one at a time later on.
|
|
|
|
*
|
|
|
|
* If any port-status changes do occur during this delay, khubd
|
|
|
|
* will see them later and handle them normally.
|
|
|
|
*/
|
2008-09-22 18:44:26 +00:00
|
|
|
if (need_debounce_delay) {
|
|
|
|
delay = HUB_DEBOUNCE_STABLE;
|
|
|
|
|
|
|
|
/* Don't do a long sleep inside a workqueue routine */
|
|
|
|
if (type == HUB_INIT2) {
|
|
|
|
PREPARE_DELAYED_WORK(&hub->init_work, hub_init_func3);
|
|
|
|
schedule_delayed_work(&hub->init_work,
|
|
|
|
msecs_to_jiffies(delay));
|
|
|
|
return; /* Continues at init3: below */
|
|
|
|
} else {
|
|
|
|
msleep(delay);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
init3:
|
2008-04-28 15:07:17 +00:00
|
|
|
hub->quiescing = 0;
|
|
|
|
|
|
|
|
status = usb_submit_urb(hub->urb, GFP_NOIO);
|
|
|
|
if (status < 0)
|
|
|
|
dev_err(hub->intfdev, "activate --> %d\n", status);
|
|
|
|
if (hub->has_indicators && blinkenlights)
|
|
|
|
schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
|
|
|
|
|
|
|
|
/* Scan all ports that need attention */
|
|
|
|
kick_khubd(hub);
|
2009-12-07 18:01:37 +00:00
|
|
|
|
|
|
|
/* Allow autosuspend if it was suppressed */
|
|
|
|
if (type <= HUB_INIT3)
|
|
|
|
usb_autopm_put_interface_async(to_usb_interface(hub->intfdev));
|
2008-03-03 20:15:51 +00:00
|
|
|
}
|
|
|
|
|
2008-09-22 18:44:26 +00:00
|
|
|
/* Implement the continuations for the delays above */
|
|
|
|
static void hub_init_func2(struct work_struct *ws)
|
|
|
|
{
|
|
|
|
struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
|
|
|
|
|
|
|
|
hub_activate(hub, HUB_INIT2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hub_init_func3(struct work_struct *ws)
|
|
|
|
{
|
|
|
|
struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
|
|
|
|
|
|
|
|
hub_activate(hub, HUB_INIT3);
|
|
|
|
}
|
|
|
|
|
2008-04-28 15:07:31 +00:00
|
|
|
enum hub_quiescing_type {
|
|
|
|
HUB_DISCONNECT, HUB_PRE_RESET, HUB_SUSPEND
|
|
|
|
};
|
|
|
|
|
|
|
|
static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
|
|
|
|
{
|
|
|
|
struct usb_device *hdev = hub->hdev;
|
|
|
|
int i;
|
|
|
|
|
2008-09-22 18:44:26 +00:00
|
|
|
cancel_delayed_work_sync(&hub->init_work);
|
|
|
|
|
2008-04-28 15:07:31 +00:00
|
|
|
/* khubd and related activity won't re-trigger */
|
|
|
|
hub->quiescing = 1;
|
|
|
|
|
|
|
|
if (type != HUB_SUSPEND) {
|
|
|
|
/* Disconnect all the children */
|
|
|
|
for (i = 0; i < hdev->maxchild; ++i) {
|
|
|
|
if (hdev->children[i])
|
|
|
|
usb_disconnect(&hdev->children[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Stop khubd and related activity */
|
|
|
|
usb_kill_urb(hub->urb);
|
|
|
|
if (hub->has_indicators)
|
|
|
|
cancel_delayed_work_sync(&hub->leds);
|
|
|
|
if (hub->tt.hub)
|
2009-06-29 14:43:32 +00:00
|
|
|
cancel_work_sync(&hub->tt.clear_work);
|
2008-04-28 15:07:31 +00:00
|
|
|
}
|
|
|
|
|
2008-03-03 20:15:43 +00:00
|
|
|
/* caller has locked the hub device */
|
|
|
|
static int hub_pre_reset(struct usb_interface *intf)
|
|
|
|
{
|
|
|
|
struct usb_hub *hub = usb_get_intfdata(intf);
|
|
|
|
|
2008-04-28 15:07:31 +00:00
|
|
|
hub_quiesce(hub, HUB_PRE_RESET);
|
2007-05-30 19:38:16 +00:00
|
|
|
return 0;
|
2005-11-18 17:06:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* caller has locked the hub device */
|
2007-05-30 19:38:16 +00:00
|
|
|
static int hub_post_reset(struct usb_interface *intf)
|
2005-11-18 17:06:34 +00:00
|
|
|
{
|
2006-06-01 17:37:24 +00:00
|
|
|
struct usb_hub *hub = usb_get_intfdata(intf);
|
|
|
|
|
2008-04-28 15:07:17 +00:00
|
|
|
hub_activate(hub, HUB_POST_RESET);
|
2007-05-30 19:38:16 +00:00
|
|
|
return 0;
|
2005-11-18 17:06:34 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int hub_configure(struct usb_hub *hub,
|
|
|
|
struct usb_endpoint_descriptor *endpoint)
|
|
|
|
{
|
2009-09-04 17:53:24 +00:00
|
|
|
struct usb_hcd *hcd;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct usb_device *hdev = hub->hdev;
|
|
|
|
struct device *hub_dev = hub->intfdev;
|
|
|
|
u16 hubstatus, hubchange;
|
2005-06-21 04:15:16 +00:00
|
|
|
u16 wHubCharacteristics;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int pipe;
|
|
|
|
int maxp, ret;
|
2009-06-29 14:56:54 +00:00
|
|
|
char *message = "out of memory";
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-10-27 19:18:46 +00:00
|
|
|
hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!hub->buffer) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
|
|
|
|
if (!hub->status) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
2007-02-05 14:56:15 +00:00
|
|
|
mutex_init(&hub->status_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
|
|
|
|
if (!hub->descriptor) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2001-09-17 07:00:00 +00:00
|
|
|
if (hub_is_superspeed(hdev) && (hdev->parent != NULL)) {
|
|
|
|
ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
|
|
|
|
HUB_SET_DEPTH, USB_RT_HUB,
|
|
|
|
hdev->level - 1, 0, NULL, 0,
|
|
|
|
USB_CTRL_SET_TIMEOUT);
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
message = "can't set hub depth";
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Request the entire hub descriptor.
|
|
|
|
* hub->descriptor can handle USB_MAXCHILDREN ports,
|
|
|
|
* but the hub can/will return fewer bytes here.
|
|
|
|
*/
|
2001-09-17 07:00:00 +00:00
|
|
|
ret = get_hub_descriptor(hdev, hub->descriptor);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
message = "can't read hub descriptor";
|
|
|
|
goto fail;
|
|
|
|
} else if (hub->descriptor->bNbrPorts > USB_MAXCHILDREN) {
|
|
|
|
message = "hub has too many ports!";
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
hdev->maxchild = hub->descriptor->bNbrPorts;
|
|
|
|
dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
|
|
|
|
(hdev->maxchild == 1) ? "" : "s");
|
|
|
|
|
2009-06-29 14:56:54 +00:00
|
|
|
hub->port_owners = kzalloc(hdev->maxchild * sizeof(void *), GFP_KERNEL);
|
|
|
|
if (!hub->port_owners) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2005-06-21 04:15:16 +00:00
|
|
|
wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2001-09-17 07:00:00 +00:00
|
|
|
/* FIXME for USB 3.0, skip for now */
|
|
|
|
if ((wHubCharacteristics & HUB_CHAR_COMPOUND) &&
|
|
|
|
!(hub_is_superspeed(hdev))) {
|
2005-04-16 22:20:36 +00:00
|
|
|
int i;
|
|
|
|
char portstr [USB_MAXCHILDREN + 1];
|
|
|
|
|
|
|
|
for (i = 0; i < hdev->maxchild; i++)
|
2001-09-17 07:00:00 +00:00
|
|
|
portstr[i] = hub->descriptor->u.hs.DeviceRemovable
|
2005-04-16 22:20:36 +00:00
|
|
|
[((i + 1) / 8)] & (1 << ((i + 1) % 8))
|
|
|
|
? 'F' : 'R';
|
|
|
|
portstr[hdev->maxchild] = 0;
|
|
|
|
dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
|
|
|
|
} else
|
|
|
|
dev_dbg(hub_dev, "standalone hub\n");
|
|
|
|
|
2005-06-21 04:15:16 +00:00
|
|
|
switch (wHubCharacteristics & HUB_CHAR_LPSM) {
|
2005-04-16 22:20:36 +00:00
|
|
|
case 0x00:
|
|
|
|
dev_dbg(hub_dev, "ganged power switching\n");
|
|
|
|
break;
|
|
|
|
case 0x01:
|
|
|
|
dev_dbg(hub_dev, "individual port power switching\n");
|
|
|
|
break;
|
|
|
|
case 0x02:
|
|
|
|
case 0x03:
|
|
|
|
dev_dbg(hub_dev, "no power switching (usb 1.0)\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-06-21 04:15:16 +00:00
|
|
|
switch (wHubCharacteristics & HUB_CHAR_OCPM) {
|
2005-04-16 22:20:36 +00:00
|
|
|
case 0x00:
|
|
|
|
dev_dbg(hub_dev, "global over-current protection\n");
|
|
|
|
break;
|
|
|
|
case 0x08:
|
|
|
|
dev_dbg(hub_dev, "individual port over-current protection\n");
|
|
|
|
break;
|
|
|
|
case 0x10:
|
|
|
|
case 0x18:
|
|
|
|
dev_dbg(hub_dev, "no over-current protection\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_init (&hub->tt.lock);
|
|
|
|
INIT_LIST_HEAD (&hub->tt.clear_list);
|
2009-06-29 14:43:32 +00:00
|
|
|
INIT_WORK(&hub->tt.clear_work, hub_tt_work);
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (hdev->descriptor.bDeviceProtocol) {
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
dev_dbg(hub_dev, "Single TT\n");
|
|
|
|
hub->tt.hub = hdev;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
ret = usb_set_interface(hdev, 0, 1);
|
|
|
|
if (ret == 0) {
|
|
|
|
dev_dbg(hub_dev, "TT per port\n");
|
|
|
|
hub->tt.multi = 1;
|
|
|
|
} else
|
|
|
|
dev_err(hub_dev, "Using single TT (err %d)\n",
|
|
|
|
ret);
|
|
|
|
hub->tt.hub = hdev;
|
|
|
|
break;
|
2009-04-28 02:55:01 +00:00
|
|
|
case 3:
|
|
|
|
/* USB 3.0 hubs don't have a TT */
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
default:
|
|
|
|
dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",
|
|
|
|
hdev->descriptor.bDeviceProtocol);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-08-14 01:41:04 +00:00
|
|
|
/* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
|
2005-06-21 04:15:16 +00:00
|
|
|
switch (wHubCharacteristics & HUB_CHAR_TTTT) {
|
2005-08-14 01:41:04 +00:00
|
|
|
case HUB_TTTT_8_BITS:
|
|
|
|
if (hdev->descriptor.bDeviceProtocol != 0) {
|
|
|
|
hub->tt.think_time = 666;
|
|
|
|
dev_dbg(hub_dev, "TT requires at most %d "
|
|
|
|
"FS bit times (%d ns)\n",
|
|
|
|
8, hub->tt.think_time);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2005-08-14 01:41:04 +00:00
|
|
|
case HUB_TTTT_16_BITS:
|
|
|
|
hub->tt.think_time = 666 * 2;
|
|
|
|
dev_dbg(hub_dev, "TT requires at most %d "
|
|
|
|
"FS bit times (%d ns)\n",
|
|
|
|
16, hub->tt.think_time);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2005-08-14 01:41:04 +00:00
|
|
|
case HUB_TTTT_24_BITS:
|
|
|
|
hub->tt.think_time = 666 * 3;
|
|
|
|
dev_dbg(hub_dev, "TT requires at most %d "
|
|
|
|
"FS bit times (%d ns)\n",
|
|
|
|
24, hub->tt.think_time);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2005-08-14 01:41:04 +00:00
|
|
|
case HUB_TTTT_32_BITS:
|
|
|
|
hub->tt.think_time = 666 * 4;
|
|
|
|
dev_dbg(hub_dev, "TT requires at most %d "
|
|
|
|
"FS bit times (%d ns)\n",
|
|
|
|
32, hub->tt.think_time);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* probe() zeroes hub->indicator[] */
|
2005-06-21 04:15:16 +00:00
|
|
|
if (wHubCharacteristics & HUB_CHAR_PORTIND) {
|
2005-04-16 22:20:36 +00:00
|
|
|
hub->has_indicators = 1;
|
|
|
|
dev_dbg(hub_dev, "Port indicators are supported\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(hub_dev, "power on to power good time: %dms\n",
|
|
|
|
hub->descriptor->bPwrOn2PwrGood * 2);
|
|
|
|
|
|
|
|
/* power budgeting mostly matters with bus-powered hubs,
|
|
|
|
* and battery-powered root hubs (may provide just 8 mA).
|
|
|
|
*/
|
|
|
|
ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);
|
2005-11-23 17:03:12 +00:00
|
|
|
if (ret < 2) {
|
2005-04-16 22:20:36 +00:00
|
|
|
message = "can't get hub status";
|
|
|
|
goto fail;
|
|
|
|
}
|
2005-04-25 15:18:32 +00:00
|
|
|
le16_to_cpus(&hubstatus);
|
|
|
|
if (hdev == hdev->bus->root_hub) {
|
2005-11-23 17:03:12 +00:00
|
|
|
if (hdev->bus_mA == 0 || hdev->bus_mA >= 500)
|
|
|
|
hub->mA_per_port = 500;
|
|
|
|
else {
|
|
|
|
hub->mA_per_port = hdev->bus_mA;
|
|
|
|
hub->limited_power = 1;
|
|
|
|
}
|
2005-04-25 15:18:32 +00:00
|
|
|
} else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
|
|
|
|
hub->descriptor->bHubContrCurrent);
|
2005-11-23 17:03:12 +00:00
|
|
|
hub->limited_power = 1;
|
|
|
|
if (hdev->maxchild > 0) {
|
|
|
|
int remaining = hdev->bus_mA -
|
|
|
|
hub->descriptor->bHubContrCurrent;
|
|
|
|
|
|
|
|
if (remaining < hdev->maxchild * 100)
|
|
|
|
dev_warn(hub_dev,
|
|
|
|
"insufficient power available "
|
|
|
|
"to use all downstream ports\n");
|
|
|
|
hub->mA_per_port = 100; /* 7.2.1.1 */
|
|
|
|
}
|
|
|
|
} else { /* Self-powered external hub */
|
|
|
|
/* FIXME: What about battery-powered external hubs that
|
|
|
|
* provide less current per port? */
|
|
|
|
hub->mA_per_port = 500;
|
2005-04-25 15:18:32 +00:00
|
|
|
}
|
2005-11-23 17:03:12 +00:00
|
|
|
if (hub->mA_per_port < 500)
|
|
|
|
dev_dbg(hub_dev, "%umA bus power budget for each child\n",
|
|
|
|
hub->mA_per_port);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-09-04 17:53:24 +00:00
|
|
|
/* Update the HCD's internal representation of this hub before khubd
|
|
|
|
* starts getting port status changes for devices under the hub.
|
|
|
|
*/
|
|
|
|
hcd = bus_to_hcd(hdev->bus);
|
|
|
|
if (hcd->driver->update_hub_device) {
|
|
|
|
ret = hcd->driver->update_hub_device(hcd, hdev,
|
|
|
|
&hub->tt, GFP_KERNEL);
|
|
|
|
if (ret < 0) {
|
|
|
|
message = "can't update HCD hub info";
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
ret = hub_hub_status(hub, &hubstatus, &hubchange);
|
|
|
|
if (ret < 0) {
|
|
|
|
message = "can't get hub status";
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* local power status reports aren't always correct */
|
|
|
|
if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER)
|
|
|
|
dev_dbg(hub_dev, "local power source is %s\n",
|
|
|
|
(hubstatus & HUB_STATUS_LOCAL_POWER)
|
|
|
|
? "lost (inactive)" : "good");
|
|
|
|
|
2005-06-21 04:15:16 +00:00
|
|
|
if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_dbg(hub_dev, "%sover-current condition exists\n",
|
|
|
|
(hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
|
|
|
|
|
2006-10-12 03:05:59 +00:00
|
|
|
/* set up the interrupt endpoint
|
|
|
|
* We use the EP's maxpacket size instead of (PORTS+1+7)/8
|
|
|
|
* bytes as USB2.0[11.12.3] says because some hubs are known
|
|
|
|
* to send more data (and thus cause overflow). For root hubs,
|
|
|
|
* maxpktsize is defined in hcd.c's fake endpoint descriptors
|
|
|
|
* to be big enough for at least USB_MAXCHILDREN ports. */
|
2005-04-16 22:20:36 +00:00
|
|
|
pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
|
|
|
|
maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
|
|
|
|
|
|
|
|
if (maxp > sizeof(*hub->buffer))
|
|
|
|
maxp = sizeof(*hub->buffer);
|
|
|
|
|
|
|
|
hub->urb = usb_alloc_urb(0, GFP_KERNEL);
|
|
|
|
if (!hub->urb) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
|
|
|
|
hub, endpoint->bInterval);
|
|
|
|
|
|
|
|
/* maybe cycle the hub leds */
|
|
|
|
if (hub->has_indicators && blinkenlights)
|
|
|
|
hub->indicator [0] = INDICATOR_CYCLE;
|
|
|
|
|
2008-04-28 15:07:17 +00:00
|
|
|
hub_activate(hub, HUB_INIT);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
dev_err (hub_dev, "config failed, %s (err %d)\n",
|
|
|
|
message, ret);
|
|
|
|
/* hub_disconnect() frees urb and descriptor */
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-05-04 15:55:11 +00:00
|
|
|
static void hub_release(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct usb_hub *hub = container_of(kref, struct usb_hub, kref);
|
|
|
|
|
|
|
|
usb_put_intf(to_usb_interface(hub->intfdev));
|
|
|
|
kfree(hub);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static unsigned highspeed_hubs;
|
|
|
|
|
|
|
|
static void hub_disconnect(struct usb_interface *intf)
|
|
|
|
{
|
|
|
|
struct usb_hub *hub = usb_get_intfdata (intf);
|
2007-05-04 15:55:11 +00:00
|
|
|
|
|
|
|
/* Take the hub off the event list and don't let it be added again */
|
|
|
|
spin_lock_irq(&hub_event_lock);
|
2009-12-07 18:01:37 +00:00
|
|
|
if (!list_empty(&hub->event_list)) {
|
|
|
|
list_del_init(&hub->event_list);
|
|
|
|
usb_autopm_put_interface_no_suspend(intf);
|
|
|
|
}
|
2007-05-04 15:55:11 +00:00
|
|
|
hub->disconnected = 1;
|
|
|
|
spin_unlock_irq(&hub_event_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-01 17:37:24 +00:00
|
|
|
/* Disconnect all children and quiesce the hub */
|
|
|
|
hub->error = 0;
|
2008-04-28 15:07:31 +00:00
|
|
|
hub_quiesce(hub, HUB_DISCONNECT);
|
2006-06-01 17:37:24 +00:00
|
|
|
|
2005-08-10 21:04:13 +00:00
|
|
|
usb_set_intfdata (intf, NULL);
|
2009-06-29 14:56:54 +00:00
|
|
|
hub->hdev->maxchild = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-04 15:55:11 +00:00
|
|
|
if (hub->hdev->speed == USB_SPEED_HIGH)
|
2005-04-16 22:20:36 +00:00
|
|
|
highspeed_hubs--;
|
|
|
|
|
|
|
|
usb_free_urb(hub->urb);
|
2009-06-29 14:56:54 +00:00
|
|
|
kfree(hub->port_owners);
|
2005-04-19 00:39:34 +00:00
|
|
|
kfree(hub->descriptor);
|
|
|
|
kfree(hub->status);
|
2009-10-27 19:18:46 +00:00
|
|
|
kfree(hub->buffer);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-04 15:55:11 +00:00
|
|
|
kref_put(&hub->kref, hub_release);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
|
|
|
|
{
|
|
|
|
struct usb_host_interface *desc;
|
|
|
|
struct usb_endpoint_descriptor *endpoint;
|
|
|
|
struct usb_device *hdev;
|
|
|
|
struct usb_hub *hub;
|
|
|
|
|
|
|
|
desc = intf->cur_altsetting;
|
|
|
|
hdev = interface_to_usbdev(intf);
|
|
|
|
|
2010-12-30 21:27:36 +00:00
|
|
|
/* Hubs have proper suspend/resume support. USB 3.0 device suspend is
|
|
|
|
* different from USB 2.0/1.1 device suspend, and unfortunately we
|
|
|
|
* don't support it yet. So leave autosuspend disabled for USB 3.0
|
|
|
|
* external hubs for now. Enable autosuspend for USB 3.0 roothubs,
|
|
|
|
* since that isn't a "real" hub.
|
|
|
|
*/
|
|
|
|
if (!hub_is_superspeed(hdev) || !hdev->parent)
|
|
|
|
usb_enable_autosuspend(hdev);
|
2010-01-08 17:56:54 +00:00
|
|
|
|
2008-06-12 07:49:47 +00:00
|
|
|
if (hdev->level == MAX_TOPO_LEVEL) {
|
2008-12-15 07:32:01 +00:00
|
|
|
dev_err(&intf->dev,
|
|
|
|
"Unsupported bus topology: hub nested too deep\n");
|
2008-06-12 07:49:47 +00:00
|
|
|
return -E2BIG;
|
|
|
|
}
|
|
|
|
|
2006-04-02 18:18:09 +00:00
|
|
|
#ifdef CONFIG_USB_OTG_BLACKLIST_HUB
|
|
|
|
if (hdev->parent) {
|
|
|
|
dev_warn(&intf->dev, "ignoring external hub\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Some hubs have a subclass of 1, which AFAICT according to the */
|
|
|
|
/* specs is not defined, but it works */
|
|
|
|
if ((desc->desc.bInterfaceSubClass != 0) &&
|
|
|
|
(desc->desc.bInterfaceSubClass != 1)) {
|
|
|
|
descriptor_error:
|
|
|
|
dev_err (&intf->dev, "bad descriptor, ignoring hub\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Multiple endpoints? What kind of mutant ninja-hub is this? */
|
|
|
|
if (desc->desc.bNumEndpoints != 1)
|
|
|
|
goto descriptor_error;
|
|
|
|
|
|
|
|
endpoint = &desc->endpoint[0].desc;
|
|
|
|
|
2006-09-27 18:58:53 +00:00
|
|
|
/* If it's not an interrupt in endpoint, we'd better punt! */
|
|
|
|
if (!usb_endpoint_is_int_in(endpoint))
|
2005-04-16 22:20:36 +00:00
|
|
|
goto descriptor_error;
|
|
|
|
|
|
|
|
/* We found a hub */
|
|
|
|
dev_info (&intf->dev, "USB hub found\n");
|
|
|
|
|
2005-10-24 19:38:24 +00:00
|
|
|
hub = kzalloc(sizeof(*hub), GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!hub) {
|
|
|
|
dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2007-05-04 15:55:11 +00:00
|
|
|
kref_init(&hub->kref);
|
2005-04-16 22:20:36 +00:00
|
|
|
INIT_LIST_HEAD(&hub->event_list);
|
|
|
|
hub->intfdev = &intf->dev;
|
|
|
|
hub->hdev = hdev;
|
2006-11-22 14:57:56 +00:00
|
|
|
INIT_DELAYED_WORK(&hub->leds, led_work);
|
2008-09-22 18:44:26 +00:00
|
|
|
INIT_DELAYED_WORK(&hub->init_work, NULL);
|
2007-05-04 15:55:11 +00:00
|
|
|
usb_get_intf(intf);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
usb_set_intfdata (intf, hub);
|
2006-11-09 19:44:33 +00:00
|
|
|
intf->needs_remote_wakeup = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (hdev->speed == USB_SPEED_HIGH)
|
|
|
|
highspeed_hubs++;
|
|
|
|
|
|
|
|
if (hub_configure(hub, endpoint) >= 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
hub_disconnect (intf);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2010-06-01 21:04:41 +00:00
|
|
|
/* No BKL needed */
|
2005-04-16 22:20:36 +00:00
|
|
|
static int
|
|
|
|
hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
|
|
|
|
{
|
|
|
|
struct usb_device *hdev = interface_to_usbdev (intf);
|
|
|
|
|
|
|
|
/* assert ifno == 0 (part of hub spec) */
|
|
|
|
switch (code) {
|
|
|
|
case USBDEVFS_HUB_PORTINFO: {
|
|
|
|
struct usbdevfs_hub_portinfo *info = user_data;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
spin_lock_irq(&device_state_lock);
|
|
|
|
if (hdev->devnum <= 0)
|
|
|
|
info->nports = 0;
|
|
|
|
else {
|
|
|
|
info->nports = hdev->maxchild;
|
|
|
|
for (i = 0; i < info->nports; i++) {
|
|
|
|
if (hdev->children[i] == NULL)
|
|
|
|
info->port[i] = 0;
|
|
|
|
else
|
|
|
|
info->port[i] =
|
|
|
|
hdev->children[i]->devnum;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&device_state_lock);
|
|
|
|
|
|
|
|
return info->nports + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-29 14:56:54 +00:00
|
|
|
/*
|
|
|
|
* Allow user programs to claim ports on a hub. When a device is attached
|
|
|
|
* to one of these "claimed" ports, the program will "own" the device.
|
|
|
|
*/
|
|
|
|
static int find_port_owner(struct usb_device *hdev, unsigned port1,
|
|
|
|
void ***ppowner)
|
|
|
|
{
|
|
|
|
if (hdev->state == USB_STATE_NOTATTACHED)
|
|
|
|
return -ENODEV;
|
|
|
|
if (port1 == 0 || port1 > hdev->maxchild)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* This assumes that devices not managed by the hub driver
|
|
|
|
* will always have maxchild equal to 0.
|
|
|
|
*/
|
|
|
|
*ppowner = &(hdev_to_hub(hdev)->port_owners[port1 - 1]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* In the following three functions, the caller must hold hdev's lock */
|
|
|
|
int usb_hub_claim_port(struct usb_device *hdev, unsigned port1, void *owner)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
void **powner;
|
|
|
|
|
|
|
|
rc = find_port_owner(hdev, port1, &powner);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
if (*powner)
|
|
|
|
return -EBUSY;
|
|
|
|
*powner = owner;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int usb_hub_release_port(struct usb_device *hdev, unsigned port1, void *owner)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
void **powner;
|
|
|
|
|
|
|
|
rc = find_port_owner(hdev, port1, &powner);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
if (*powner != owner)
|
|
|
|
return -ENOENT;
|
|
|
|
*powner = NULL;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
void usb_hub_release_all_ports(struct usb_device *hdev, void *owner)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
void **powner;
|
|
|
|
|
|
|
|
n = find_port_owner(hdev, 1, &powner);
|
|
|
|
if (n == 0) {
|
|
|
|
for (; n < hdev->maxchild; (++n, ++powner)) {
|
|
|
|
if (*powner == owner)
|
|
|
|
*powner = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The caller must hold udev's lock */
|
|
|
|
bool usb_device_is_owned(struct usb_device *udev)
|
|
|
|
{
|
|
|
|
struct usb_hub *hub;
|
|
|
|
|
|
|
|
if (udev->state == USB_STATE_NOTATTACHED || !udev->parent)
|
|
|
|
return false;
|
|
|
|
hub = hdev_to_hub(udev->parent);
|
|
|
|
return !!hub->port_owners[udev->portnum - 1];
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static void recursively_mark_NOTATTACHED(struct usb_device *udev)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < udev->maxchild; ++i) {
|
|
|
|
if (udev->children[i])
|
|
|
|
recursively_mark_NOTATTACHED(udev->children[i]);
|
|
|
|
}
|
2010-01-08 17:57:28 +00:00
|
|
|
if (udev->state == USB_STATE_SUSPENDED)
|
2007-12-22 00:54:15 +00:00
|
|
|
udev->active_duration -= jiffies;
|
2005-04-16 22:20:36 +00:00
|
|
|
udev->state = USB_STATE_NOTATTACHED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_set_device_state - change a device's current state (usbcore, hcds)
|
|
|
|
* @udev: pointer to device whose state should be changed
|
|
|
|
* @new_state: new state value to be stored
|
|
|
|
*
|
|
|
|
* udev->state is _not_ fully protected by the device lock. Although
|
|
|
|
* most transitions are made only while holding the lock, the state can
|
|
|
|
* can change to USB_STATE_NOTATTACHED at almost any time. This
|
|
|
|
* is so that devices can be marked as disconnected as soon as possible,
|
|
|
|
* without having to wait for any semaphores to be released. As a result,
|
|
|
|
* all changes to any device's state must be protected by the
|
|
|
|
* device_state_lock spinlock.
|
|
|
|
*
|
|
|
|
* Once a device has been added to the device tree, all changes to its state
|
|
|
|
* should be made using this routine. The state should _not_ be set directly.
|
|
|
|
*
|
|
|
|
* If udev->state is already USB_STATE_NOTATTACHED then no change is made.
|
|
|
|
* Otherwise udev->state is set to new_state, and if new_state is
|
|
|
|
* USB_STATE_NOTATTACHED then all of udev's descendants' states are also set
|
|
|
|
* to USB_STATE_NOTATTACHED.
|
|
|
|
*/
|
|
|
|
void usb_set_device_state(struct usb_device *udev,
|
|
|
|
enum usb_device_state new_state)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
2011-02-08 22:25:48 +00:00
|
|
|
int wakeup = -1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&device_state_lock, flags);
|
|
|
|
if (udev->state == USB_STATE_NOTATTACHED)
|
|
|
|
; /* do nothing */
|
2005-09-13 02:39:39 +00:00
|
|
|
else if (new_state != USB_STATE_NOTATTACHED) {
|
2006-01-24 16:40:27 +00:00
|
|
|
|
|
|
|
/* root hub wakeup capabilities are managed out-of-band
|
|
|
|
* and may involve silicon errata ... ignore them here.
|
|
|
|
*/
|
|
|
|
if (udev->parent) {
|
2006-08-30 19:47:02 +00:00
|
|
|
if (udev->state == USB_STATE_SUSPENDED
|
|
|
|
|| new_state == USB_STATE_SUSPENDED)
|
|
|
|
; /* No change to wakeup settings */
|
|
|
|
else if (new_state == USB_STATE_CONFIGURED)
|
2011-02-08 22:25:48 +00:00
|
|
|
wakeup = udev->actconfig->desc.bmAttributes
|
|
|
|
& USB_CONFIG_ATT_WAKEUP;
|
2006-08-30 19:47:02 +00:00
|
|
|
else
|
2011-02-08 22:25:48 +00:00
|
|
|
wakeup = 0;
|
2006-01-24 16:40:27 +00:00
|
|
|
}
|
2007-12-22 00:54:15 +00:00
|
|
|
if (udev->state == USB_STATE_SUSPENDED &&
|
|
|
|
new_state != USB_STATE_SUSPENDED)
|
|
|
|
udev->active_duration -= jiffies;
|
|
|
|
else if (new_state == USB_STATE_SUSPENDED &&
|
|
|
|
udev->state != USB_STATE_SUSPENDED)
|
|
|
|
udev->active_duration += jiffies;
|
2006-08-30 19:47:02 +00:00
|
|
|
udev->state = new_state;
|
2005-09-13 02:39:39 +00:00
|
|
|
} else
|
2005-04-16 22:20:36 +00:00
|
|
|
recursively_mark_NOTATTACHED(udev);
|
|
|
|
spin_unlock_irqrestore(&device_state_lock, flags);
|
2011-02-08 22:25:48 +00:00
|
|
|
if (wakeup >= 0)
|
|
|
|
device_set_wakeup_capable(&udev->dev, wakeup);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-02-18 14:43:47 +00:00
|
|
|
EXPORT_SYMBOL_GPL(usb_set_device_state);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-08 20:24:46 +00:00
|
|
|
/*
|
2011-02-22 14:53:41 +00:00
|
|
|
* Choose a device number.
|
|
|
|
*
|
|
|
|
* Device numbers are used as filenames in usbfs. On USB-1.1 and
|
|
|
|
* USB-2.0 buses they are also used as device addresses, however on
|
|
|
|
* USB-3.0 buses the address is assigned by the controller hardware
|
|
|
|
* and it usually is not the same as the device number.
|
|
|
|
*
|
2008-04-08 20:24:46 +00:00
|
|
|
* WUSB devices are simple: they have no hubs behind, so the mapping
|
|
|
|
* device <-> virtual port number becomes 1:1. Why? to simplify the
|
|
|
|
* life of the device connection logic in
|
|
|
|
* drivers/usb/wusbcore/devconnect.c. When we do the initial secret
|
|
|
|
* handshake we need to assign a temporary address in the unauthorized
|
|
|
|
* space. For simplicity we use the first virtual port number found to
|
|
|
|
* be free [drivers/usb/wusbcore/devconnect.c:wusbhc_devconnect_ack()]
|
|
|
|
* and that becomes it's address [X < 128] or its unauthorized address
|
|
|
|
* [X | 0x80].
|
|
|
|
*
|
|
|
|
* We add 1 as an offset to the one-based USB-stack port number
|
|
|
|
* (zero-based wusb virtual port index) for two reasons: (a) dev addr
|
|
|
|
* 0 is reserved by USB for default address; (b) Linux's USB stack
|
|
|
|
* uses always #1 for the root hub of the controller. So USB stack's
|
|
|
|
* port #1, which is wusb virtual-port #0 has address #2.
|
2009-04-28 02:57:26 +00:00
|
|
|
*
|
|
|
|
* Devices connected under xHCI are not as simple. The host controller
|
|
|
|
* supports virtualization, so the hardware assigns device addresses and
|
|
|
|
* the HCD must setup data structures before issuing a set address
|
|
|
|
* command to the hardware.
|
2008-04-08 20:24:46 +00:00
|
|
|
*/
|
2011-02-22 14:53:41 +00:00
|
|
|
static void choose_devnum(struct usb_device *udev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int devnum;
|
|
|
|
struct usb_bus *bus = udev->bus;
|
|
|
|
|
|
|
|
/* If khubd ever becomes multithreaded, this will need a lock */
|
2008-04-08 20:24:46 +00:00
|
|
|
if (udev->wusb) {
|
|
|
|
devnum = udev->portnum + 1;
|
|
|
|
BUG_ON(test_bit(devnum, bus->devmap.devicemap));
|
|
|
|
} else {
|
|
|
|
/* Try to allocate the next devnum beginning at
|
|
|
|
* bus->devnum_next. */
|
|
|
|
devnum = find_next_zero_bit(bus->devmap.devicemap, 128,
|
|
|
|
bus->devnum_next);
|
|
|
|
if (devnum >= 128)
|
|
|
|
devnum = find_next_zero_bit(bus->devmap.devicemap,
|
|
|
|
128, 1);
|
|
|
|
bus->devnum_next = ( devnum >= 127 ? 1 : devnum + 1);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
if (devnum < 128) {
|
|
|
|
set_bit(devnum, bus->devmap.devicemap);
|
|
|
|
udev->devnum = devnum;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-22 14:53:41 +00:00
|
|
|
static void release_devnum(struct usb_device *udev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
if (udev->devnum > 0) {
|
|
|
|
clear_bit(udev->devnum, udev->bus->devmap.devicemap);
|
|
|
|
udev->devnum = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-22 14:53:41 +00:00
|
|
|
static void update_devnum(struct usb_device *udev, int devnum)
|
2008-04-08 20:24:46 +00:00
|
|
|
{
|
|
|
|
/* The address for a WUSB device is managed by wusbcore. */
|
|
|
|
if (!udev->wusb)
|
|
|
|
udev->devnum = devnum;
|
|
|
|
}
|
|
|
|
|
2010-01-10 09:15:03 +00:00
|
|
|
static void hub_free_dev(struct usb_device *udev)
|
|
|
|
{
|
|
|
|
struct usb_hcd *hcd = bus_to_hcd(udev->bus);
|
|
|
|
|
|
|
|
/* Root hubs aren't real devices, so don't free HCD resources */
|
|
|
|
if (hcd->driver->free_dev && udev->parent)
|
|
|
|
hcd->driver->free_dev(hcd, udev);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* usb_disconnect - disconnect a device (usbcore-internal)
|
|
|
|
* @pdev: pointer to device being disconnected
|
|
|
|
* Context: !in_interrupt ()
|
|
|
|
*
|
|
|
|
* Something got disconnected. Get rid of it and all of its children.
|
|
|
|
*
|
|
|
|
* If *pdev is a normal device then the parent hub must already be locked.
|
|
|
|
* If *pdev is a root hub then this routine will acquire the
|
|
|
|
* usb_bus_list_lock on behalf of the caller.
|
|
|
|
*
|
|
|
|
* Only hub drivers (including virtual root hub drivers for host
|
|
|
|
* controllers) should ever call this.
|
|
|
|
*
|
|
|
|
* This call is synchronous, and may not be used in an interrupt context.
|
|
|
|
*/
|
|
|
|
void usb_disconnect(struct usb_device **pdev)
|
|
|
|
{
|
|
|
|
struct usb_device *udev = *pdev;
|
|
|
|
int i;
|
USB: Free bandwidth when usb_disable_device is called.
Tanya ran into an issue when trying to switch a UAS device from the BOT
configuration to the UAS configuration via the bConfigurationValue sysfs
file. Before installing the UAS configuration, set_bConfigurationValue()
calls usb_disable_device(). That function is supposed to remove all host
controller resources associated with that device, but it leaves some state
in the xHCI host controller.
Commit 0791971ba8fbc44e4f476079f856335ed45e6324
usb: allow drivers to use allocated bandwidth until unbound
added a call to usb_disable_device() in usb_set_configuration(), before
the xHCI bandwidth functions were invoked. That commit fixed a bug, but
also introduced a bug that is triggered when a configured device is
switched to a new configuration.
usb_disable_device() goes through all the motions of unbinding the drivers
attached to active interfaces and removing the USB core structures
associated with those interfaces, but it doesn't actually remove the
endpoints from the internal xHCI host controller bandwidth structures.
When usb_disable_device() calls usb_disable_endpoint() with reset_hardware
set to true, the entries in udev->ep_out and udev->ep_in will be set to
NULL. Usually, when the USB core installs a new configuration,
usb_hcd_alloc_bandwidth() will drop all non-NULL endpoints in udev->ep_out
and udev->ep_in before adding any new endpoints. However, when the new
UAS configuration was added, all those entries were null, so none of the
old endpoints in the BOT configuration were dropped.
The xHCI driver blindly added the UAS configuration endpoints, and some of
the endpoint addresses overlapped with the old BOT configuration
endpoints. This caused the xHCI host to reject the Configure Endpoint
command. Now that the xHCI driver code is cleaned up to reject a
double-add of active endpoints, we need to fix the USB core to properly
drop old endpoints in usb_disable_device().
If the host controller driver needs bandwidth checking support, make
usb_disable_device() call usb_disable_endpoint() with
reset_hardware set to false, drop the endpoints from the xHCI host
controller, and then call usb_disable_endpoint() again with
reset_hardware set to true.
The first call to usb_disable_endpoint() will cancel any pending URBs and
wait on them to be freed in usb_hcd_disable_endpoint(), but will keep the
pointers in udev->ep_out and udev->ep in intact. Then
usb_hcd_alloc_bandwidth() will use those pointers to know which endpoints
to drop.
The final call to usb_disable_endpoint() will do two things:
1. It will call usb_hcd_disable_endpoint() again, which should be harmless
since the ep->urb_list should be empty after the first call to
usb_disable_endpoint() returns.
2. It will set the entries in udev->ep_out and udev->ep in to NULL, and call
usb_hcd_disable_endpoint(). That call will have no effect, since the xHCI
driver doesn't set the endpoint_disable function pointer.
Note that usb_disable_device() will now need to be called with
hcd->bandwidth_mutex held.
This should be backported to kernels as old as 2.6.32.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Reported-by: Tanya Brokhman <tlinder@codeaurora.org>
Cc: ablay@codeaurora.org
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: stable@kernel.org
2011-06-06 06:22:22 +00:00
|
|
|
struct usb_hcd *hcd = bus_to_hcd(udev->bus);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* mark the device as inactive, so any further urb submissions for
|
|
|
|
* this device (and any of its children) will fail immediately.
|
2011-03-31 01:57:33 +00:00
|
|
|
* this quiesces everything except pending urbs.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
usb_set_device_state(udev, USB_STATE_NOTATTACHED);
|
2011-02-22 14:53:41 +00:00
|
|
|
dev_info(&udev->dev, "USB disconnect, device number %d\n",
|
|
|
|
udev->devnum);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-11-17 22:10:32 +00:00
|
|
|
usb_lock_device(udev);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Free up all the children before we remove this device */
|
|
|
|
for (i = 0; i < USB_MAXCHILDREN; i++) {
|
|
|
|
if (udev->children[i])
|
|
|
|
usb_disconnect(&udev->children[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* deallocate hcd/hardware state ... nuking all pending urbs and
|
|
|
|
* cleaning up all state associated with the current configuration
|
|
|
|
* so that the hardware is now fully quiesced.
|
|
|
|
*/
|
2006-07-02 02:09:35 +00:00
|
|
|
dev_dbg (&udev->dev, "unregistering device\n");
|
USB: Free bandwidth when usb_disable_device is called.
Tanya ran into an issue when trying to switch a UAS device from the BOT
configuration to the UAS configuration via the bConfigurationValue sysfs
file. Before installing the UAS configuration, set_bConfigurationValue()
calls usb_disable_device(). That function is supposed to remove all host
controller resources associated with that device, but it leaves some state
in the xHCI host controller.
Commit 0791971ba8fbc44e4f476079f856335ed45e6324
usb: allow drivers to use allocated bandwidth until unbound
added a call to usb_disable_device() in usb_set_configuration(), before
the xHCI bandwidth functions were invoked. That commit fixed a bug, but
also introduced a bug that is triggered when a configured device is
switched to a new configuration.
usb_disable_device() goes through all the motions of unbinding the drivers
attached to active interfaces and removing the USB core structures
associated with those interfaces, but it doesn't actually remove the
endpoints from the internal xHCI host controller bandwidth structures.
When usb_disable_device() calls usb_disable_endpoint() with reset_hardware
set to true, the entries in udev->ep_out and udev->ep_in will be set to
NULL. Usually, when the USB core installs a new configuration,
usb_hcd_alloc_bandwidth() will drop all non-NULL endpoints in udev->ep_out
and udev->ep_in before adding any new endpoints. However, when the new
UAS configuration was added, all those entries were null, so none of the
old endpoints in the BOT configuration were dropped.
The xHCI driver blindly added the UAS configuration endpoints, and some of
the endpoint addresses overlapped with the old BOT configuration
endpoints. This caused the xHCI host to reject the Configure Endpoint
command. Now that the xHCI driver code is cleaned up to reject a
double-add of active endpoints, we need to fix the USB core to properly
drop old endpoints in usb_disable_device().
If the host controller driver needs bandwidth checking support, make
usb_disable_device() call usb_disable_endpoint() with
reset_hardware set to false, drop the endpoints from the xHCI host
controller, and then call usb_disable_endpoint() again with
reset_hardware set to true.
The first call to usb_disable_endpoint() will cancel any pending URBs and
wait on them to be freed in usb_hcd_disable_endpoint(), but will keep the
pointers in udev->ep_out and udev->ep in intact. Then
usb_hcd_alloc_bandwidth() will use those pointers to know which endpoints
to drop.
The final call to usb_disable_endpoint() will do two things:
1. It will call usb_hcd_disable_endpoint() again, which should be harmless
since the ep->urb_list should be empty after the first call to
usb_disable_endpoint() returns.
2. It will set the entries in udev->ep_out and udev->ep in to NULL, and call
usb_hcd_disable_endpoint(). That call will have no effect, since the xHCI
driver doesn't set the endpoint_disable function pointer.
Note that usb_disable_device() will now need to be called with
hcd->bandwidth_mutex held.
This should be backported to kernels as old as 2.6.32.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Reported-by: Tanya Brokhman <tlinder@codeaurora.org>
Cc: ablay@codeaurora.org
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: stable@kernel.org
2011-06-06 06:22:22 +00:00
|
|
|
mutex_lock(hcd->bandwidth_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
usb_disable_device(udev, 0);
|
USB: Free bandwidth when usb_disable_device is called.
Tanya ran into an issue when trying to switch a UAS device from the BOT
configuration to the UAS configuration via the bConfigurationValue sysfs
file. Before installing the UAS configuration, set_bConfigurationValue()
calls usb_disable_device(). That function is supposed to remove all host
controller resources associated with that device, but it leaves some state
in the xHCI host controller.
Commit 0791971ba8fbc44e4f476079f856335ed45e6324
usb: allow drivers to use allocated bandwidth until unbound
added a call to usb_disable_device() in usb_set_configuration(), before
the xHCI bandwidth functions were invoked. That commit fixed a bug, but
also introduced a bug that is triggered when a configured device is
switched to a new configuration.
usb_disable_device() goes through all the motions of unbinding the drivers
attached to active interfaces and removing the USB core structures
associated with those interfaces, but it doesn't actually remove the
endpoints from the internal xHCI host controller bandwidth structures.
When usb_disable_device() calls usb_disable_endpoint() with reset_hardware
set to true, the entries in udev->ep_out and udev->ep_in will be set to
NULL. Usually, when the USB core installs a new configuration,
usb_hcd_alloc_bandwidth() will drop all non-NULL endpoints in udev->ep_out
and udev->ep_in before adding any new endpoints. However, when the new
UAS configuration was added, all those entries were null, so none of the
old endpoints in the BOT configuration were dropped.
The xHCI driver blindly added the UAS configuration endpoints, and some of
the endpoint addresses overlapped with the old BOT configuration
endpoints. This caused the xHCI host to reject the Configure Endpoint
command. Now that the xHCI driver code is cleaned up to reject a
double-add of active endpoints, we need to fix the USB core to properly
drop old endpoints in usb_disable_device().
If the host controller driver needs bandwidth checking support, make
usb_disable_device() call usb_disable_endpoint() with
reset_hardware set to false, drop the endpoints from the xHCI host
controller, and then call usb_disable_endpoint() again with
reset_hardware set to true.
The first call to usb_disable_endpoint() will cancel any pending URBs and
wait on them to be freed in usb_hcd_disable_endpoint(), but will keep the
pointers in udev->ep_out and udev->ep in intact. Then
usb_hcd_alloc_bandwidth() will use those pointers to know which endpoints
to drop.
The final call to usb_disable_endpoint() will do two things:
1. It will call usb_hcd_disable_endpoint() again, which should be harmless
since the ep->urb_list should be empty after the first call to
usb_disable_endpoint() returns.
2. It will set the entries in udev->ep_out and udev->ep in to NULL, and call
usb_hcd_disable_endpoint(). That call will have no effect, since the xHCI
driver doesn't set the endpoint_disable function pointer.
Note that usb_disable_device() will now need to be called with
hcd->bandwidth_mutex held.
This should be backported to kernels as old as 2.6.32.
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Reported-by: Tanya Brokhman <tlinder@codeaurora.org>
Cc: ablay@codeaurora.org
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: stable@kernel.org
2011-06-06 06:22:22 +00:00
|
|
|
mutex_unlock(hcd->bandwidth_mutex);
|
2008-10-21 19:28:46 +00:00
|
|
|
usb_hcd_synchronize_unlinks(udev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-05 19:10:34 +00:00
|
|
|
usb_remove_ep_devs(&udev->ep0);
|
2006-07-02 02:09:35 +00:00
|
|
|
usb_unlock_device(udev);
|
|
|
|
|
|
|
|
/* Unregister the device. The device driver is responsible
|
2008-12-05 19:10:34 +00:00
|
|
|
* for de-configuring the device and invoking the remove-device
|
|
|
|
* notifier chain (used by usbfs and possibly others).
|
2006-07-02 02:09:35 +00:00
|
|
|
*/
|
|
|
|
device_del(&udev->dev);
|
2005-06-21 04:15:16 +00:00
|
|
|
|
2006-07-02 02:09:35 +00:00
|
|
|
/* Free the device number and delete the parent's children[]
|
2005-04-16 22:20:36 +00:00
|
|
|
* (or root_hub) pointer.
|
|
|
|
*/
|
2011-02-22 14:53:41 +00:00
|
|
|
release_devnum(udev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Avoid races with recursively_mark_NOTATTACHED() */
|
|
|
|
spin_lock_irq(&device_state_lock);
|
|
|
|
*pdev = NULL;
|
|
|
|
spin_unlock_irq(&device_state_lock);
|
|
|
|
|
2010-01-10 09:15:03 +00:00
|
|
|
hub_free_dev(udev);
|
|
|
|
|
2006-07-02 02:09:35 +00:00
|
|
|
put_device(&udev->dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-11-27 06:11:55 +00:00
|
|
|
#ifdef CONFIG_USB_ANNOUNCE_NEW_DEVICES
|
2005-04-16 22:20:36 +00:00
|
|
|
static void show_string(struct usb_device *udev, char *id, char *string)
|
|
|
|
{
|
|
|
|
if (!string)
|
|
|
|
return;
|
|
|
|
dev_printk(KERN_INFO, &udev->dev, "%s: %s\n", id, string);
|
|
|
|
}
|
|
|
|
|
2007-11-27 06:11:55 +00:00
|
|
|
static void announce_device(struct usb_device *udev)
|
|
|
|
{
|
|
|
|
dev_info(&udev->dev, "New USB device found, idVendor=%04x, idProduct=%04x\n",
|
|
|
|
le16_to_cpu(udev->descriptor.idVendor),
|
|
|
|
le16_to_cpu(udev->descriptor.idProduct));
|
2008-12-15 07:32:01 +00:00
|
|
|
dev_info(&udev->dev,
|
|
|
|
"New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
|
2007-11-27 06:11:55 +00:00
|
|
|
udev->descriptor.iManufacturer,
|
|
|
|
udev->descriptor.iProduct,
|
|
|
|
udev->descriptor.iSerialNumber);
|
|
|
|
show_string(udev, "Product", udev->product);
|
|
|
|
show_string(udev, "Manufacturer", udev->manufacturer);
|
|
|
|
show_string(udev, "SerialNumber", udev->serial);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
#else
|
2007-11-27 06:11:55 +00:00
|
|
|
static inline void announce_device(struct usb_device *udev) { }
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_USB_OTG
|
|
|
|
#include "otg_whitelist.h"
|
|
|
|
#endif
|
|
|
|
|
2007-01-11 13:35:50 +00:00
|
|
|
/**
|
2009-12-08 20:50:41 +00:00
|
|
|
* usb_enumerate_device_otg - FIXME (usbcore-internal)
|
2007-01-11 13:35:50 +00:00
|
|
|
* @udev: newly addressed device (in ADDRESS state)
|
|
|
|
*
|
2009-12-08 20:50:41 +00:00
|
|
|
* Finish enumeration for On-The-Go devices
|
2007-01-11 13:35:50 +00:00
|
|
|
*/
|
2009-12-08 20:50:41 +00:00
|
|
|
static int usb_enumerate_device_otg(struct usb_device *udev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-08-01 03:34:05 +00:00
|
|
|
int err = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_USB_OTG
|
|
|
|
/*
|
|
|
|
* OTG-aware devices on OTG-capable root hubs may be able to use SRP,
|
|
|
|
* to wake us after we've powered off VBUS; and HNP, switching roles
|
|
|
|
* "host" to "peripheral". The OTG descriptor helps figure this out.
|
|
|
|
*/
|
|
|
|
if (!udev->bus->is_b_host
|
|
|
|
&& udev->config
|
|
|
|
&& udev->parent == udev->bus->root_hub) {
|
2009-12-04 13:47:43 +00:00
|
|
|
struct usb_otg_descriptor *desc = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct usb_bus *bus = udev->bus;
|
|
|
|
|
|
|
|
/* descriptor may appear anywhere in config */
|
|
|
|
if (__usb_get_extra_descriptor (udev->rawdescriptors[0],
|
|
|
|
le16_to_cpu(udev->config[0].desc.wTotalLength),
|
|
|
|
USB_DT_OTG, (void **) &desc) == 0) {
|
|
|
|
if (desc->bmAttributes & USB_OTG_HNP) {
|
2005-11-23 17:09:52 +00:00
|
|
|
unsigned port1 = udev->portnum;
|
2006-09-18 23:53:26 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_info(&udev->dev,
|
|
|
|
"Dual-Role OTG device on %sHNP port\n",
|
|
|
|
(port1 == bus->otg_port)
|
|
|
|
? "" : "non-");
|
|
|
|
|
|
|
|
/* enable HNP before suspend, it's simpler */
|
|
|
|
if (port1 == bus->otg_port)
|
|
|
|
bus->b_hnp_enable = 1;
|
|
|
|
err = usb_control_msg(udev,
|
|
|
|
usb_sndctrlpipe(udev, 0),
|
|
|
|
USB_REQ_SET_FEATURE, 0,
|
|
|
|
bus->b_hnp_enable
|
|
|
|
? USB_DEVICE_B_HNP_ENABLE
|
|
|
|
: USB_DEVICE_A_ALT_HNP_SUPPORT,
|
|
|
|
0, NULL, 0, USB_CTRL_SET_TIMEOUT);
|
|
|
|
if (err < 0) {
|
|
|
|
/* OTG MESSAGE: report errors here,
|
|
|
|
* customize to match your product.
|
|
|
|
*/
|
|
|
|
dev_info(&udev->dev,
|
2008-12-15 07:32:01 +00:00
|
|
|
"can't set HNP mode: %d\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
err);
|
|
|
|
bus->b_hnp_enable = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_targeted(udev)) {
|
|
|
|
|
|
|
|
/* Maybe it can talk to us, though we can't talk to it.
|
|
|
|
* (Includes HNP test device.)
|
|
|
|
*/
|
|
|
|
if (udev->bus->b_hnp_enable || udev->bus->is_b_host) {
|
2009-01-15 21:51:28 +00:00
|
|
|
err = usb_port_suspend(udev, PMSG_SUSPEND);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (err < 0)
|
|
|
|
dev_dbg(&udev->dev, "HNP fail, %d\n", err);
|
|
|
|
}
|
2007-05-26 04:31:07 +00:00
|
|
|
err = -ENOTSUPP;
|
2005-04-16 22:20:36 +00:00
|
|
|
goto fail;
|
|
|
|
}
|
2007-08-01 03:34:05 +00:00
|
|
|
fail:
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
2007-08-01 03:34:05 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2009-12-08 20:50:41 +00:00
|
|
|
* usb_enumerate_device - Read device configs/intfs/otg (usbcore-internal)
|
2007-08-01 03:34:05 +00:00
|
|
|
* @udev: newly addressed device (in ADDRESS state)
|
|
|
|
*
|
|
|
|
* This is only called by usb_new_device() and usb_authorize_device()
|
|
|
|
* and FIXME -- all comments that apply to them apply here wrt to
|
|
|
|
* environment.
|
|
|
|
*
|
|
|
|
* If the device is WUSB and not authorized, we don't attempt to read
|
|
|
|
* the string descriptors, as they will be errored out by the device
|
|
|
|
* until it has been authorized.
|
|
|
|
*/
|
2009-12-08 20:50:41 +00:00
|
|
|
static int usb_enumerate_device(struct usb_device *udev)
|
2007-08-01 03:34:05 +00:00
|
|
|
{
|
|
|
|
int err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-08-01 03:34:05 +00:00
|
|
|
if (udev->config == NULL) {
|
|
|
|
err = usb_get_configuration(udev);
|
|
|
|
if (err < 0) {
|
|
|
|
dev_err(&udev->dev, "can't read configurations, error %d\n",
|
|
|
|
err);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (udev->wusb == 1 && udev->authorized == 0) {
|
|
|
|
udev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
|
|
|
|
udev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
|
|
|
|
udev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* read the standard strings and cache them if present */
|
|
|
|
udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
|
|
|
|
udev->manufacturer = usb_cache_string(udev,
|
|
|
|
udev->descriptor.iManufacturer);
|
|
|
|
udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
|
|
|
|
}
|
2009-12-08 20:50:41 +00:00
|
|
|
err = usb_enumerate_device_otg(udev);
|
2007-08-01 03:34:05 +00:00
|
|
|
fail:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_new_device - perform initial device setup (usbcore-internal)
|
|
|
|
* @udev: newly addressed device (in ADDRESS state)
|
|
|
|
*
|
2009-12-08 20:50:41 +00:00
|
|
|
* This is called with devices which have been detected but not fully
|
|
|
|
* enumerated. The device descriptor is available, but not descriptors
|
2007-08-01 03:34:05 +00:00
|
|
|
* for any device configuration. The caller must have locked either
|
|
|
|
* the parent hub (if udev is a normal device) or else the
|
|
|
|
* usb_bus_list_lock (if udev is a root hub). The parent's pointer to
|
|
|
|
* udev has already been installed, but udev is not yet visible through
|
|
|
|
* sysfs or other filesystem code.
|
|
|
|
*
|
|
|
|
* It will return if the device is configured properly or not. Zero if
|
|
|
|
* the interface was registered with the driver core; else a negative
|
|
|
|
* errno value.
|
|
|
|
*
|
|
|
|
* This call is synchronous, and may not be used in an interrupt context.
|
|
|
|
*
|
|
|
|
* Only the hub driver or root-hub registrar should ever call this.
|
|
|
|
*/
|
|
|
|
int usb_new_device(struct usb_device *udev)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2010-01-06 14:56:53 +00:00
|
|
|
if (udev->parent) {
|
|
|
|
/* Initialize non-root-hub device wakeup to disabled;
|
|
|
|
* device (un)configuration controls wakeup capable
|
|
|
|
* sysfs power/wakeup controls wakeup enabled/disabled
|
|
|
|
*/
|
|
|
|
device_init_wakeup(&udev->dev, 0);
|
|
|
|
}
|
|
|
|
|
2010-01-08 17:57:28 +00:00
|
|
|
/* Tell the runtime-PM framework the device is active */
|
|
|
|
pm_runtime_set_active(&udev->dev);
|
2010-11-15 20:57:58 +00:00
|
|
|
pm_runtime_get_noresume(&udev->dev);
|
2010-11-15 20:57:51 +00:00
|
|
|
pm_runtime_use_autosuspend(&udev->dev);
|
2010-01-08 17:57:28 +00:00
|
|
|
pm_runtime_enable(&udev->dev);
|
|
|
|
|
2010-11-15 20:57:58 +00:00
|
|
|
/* By default, forbid autosuspend for all devices. It will be
|
|
|
|
* allowed for hubs during binding.
|
|
|
|
*/
|
|
|
|
usb_disable_autosuspend(udev);
|
|
|
|
|
2009-12-08 20:50:41 +00:00
|
|
|
err = usb_enumerate_device(udev); /* Read descriptors */
|
2007-08-01 03:34:05 +00:00
|
|
|
if (err < 0)
|
|
|
|
goto fail;
|
2009-04-28 02:57:26 +00:00
|
|
|
dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n",
|
|
|
|
udev->devnum, udev->bus->busnum,
|
|
|
|
(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
|
2007-03-13 14:59:31 +00:00
|
|
|
/* export the usbdev device-node for libusb */
|
|
|
|
udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
|
|
|
|
(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
|
|
|
|
|
2008-11-13 20:08:30 +00:00
|
|
|
/* Tell the world! */
|
|
|
|
announce_device(udev);
|
2007-07-16 19:28:19 +00:00
|
|
|
|
2010-02-08 18:18:16 +00:00
|
|
|
device_enable_async_suspend(&udev->dev);
|
2006-07-02 02:09:35 +00:00
|
|
|
/* Register the device. The device driver is responsible
|
2008-12-05 19:10:34 +00:00
|
|
|
* for configuring the device and invoking the add-device
|
|
|
|
* notifier chain (used by usbfs and possibly others).
|
2006-07-02 02:09:35 +00:00
|
|
|
*/
|
2007-03-13 14:59:31 +00:00
|
|
|
err = device_add(&udev->dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (err) {
|
|
|
|
dev_err(&udev->dev, "can't device_add, error %d\n", err);
|
|
|
|
goto fail;
|
|
|
|
}
|
2005-11-17 22:10:32 +00:00
|
|
|
|
2008-12-05 19:10:34 +00:00
|
|
|
(void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
|
2010-11-15 20:57:58 +00:00
|
|
|
usb_mark_last_busy(udev);
|
|
|
|
pm_runtime_put_sync_autosuspend(&udev->dev);
|
2006-08-11 08:55:12 +00:00
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
fail:
|
|
|
|
usb_set_device_state(udev, USB_STATE_NOTATTACHED);
|
2010-01-08 17:57:28 +00:00
|
|
|
pm_runtime_disable(&udev->dev);
|
|
|
|
pm_runtime_set_suspended(&udev->dev);
|
2007-08-01 03:34:05 +00:00
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-08-01 03:34:06 +00:00
|
|
|
|
|
|
|
/**
|
2007-10-16 00:30:02 +00:00
|
|
|
* usb_deauthorize_device - deauthorize a device (usbcore-internal)
|
|
|
|
* @usb_dev: USB device
|
|
|
|
*
|
|
|
|
* Move the USB device to a very basic state where interfaces are disabled
|
|
|
|
* and the device is in fact unconfigured and unusable.
|
2007-08-01 03:34:06 +00:00
|
|
|
*
|
|
|
|
* We share a lock (that we have) with device_del(), so we need to
|
|
|
|
* defer its call.
|
|
|
|
*/
|
|
|
|
int usb_deauthorize_device(struct usb_device *usb_dev)
|
|
|
|
{
|
|
|
|
usb_lock_device(usb_dev);
|
|
|
|
if (usb_dev->authorized == 0)
|
|
|
|
goto out_unauthorized;
|
2009-12-08 20:54:44 +00:00
|
|
|
|
2007-08-01 03:34:06 +00:00
|
|
|
usb_dev->authorized = 0;
|
|
|
|
usb_set_configuration(usb_dev, -1);
|
2009-12-08 20:54:44 +00:00
|
|
|
|
|
|
|
kfree(usb_dev->product);
|
2007-08-01 03:34:06 +00:00
|
|
|
usb_dev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
|
2009-12-08 20:54:44 +00:00
|
|
|
kfree(usb_dev->manufacturer);
|
2007-08-01 03:34:06 +00:00
|
|
|
usb_dev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
|
2009-12-08 20:54:44 +00:00
|
|
|
kfree(usb_dev->serial);
|
2007-08-01 03:34:06 +00:00
|
|
|
usb_dev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
|
2009-12-08 20:54:44 +00:00
|
|
|
|
|
|
|
usb_destroy_configuration(usb_dev);
|
2007-08-01 03:34:06 +00:00
|
|
|
usb_dev->descriptor.bNumConfigurations = 0;
|
2009-12-08 20:54:44 +00:00
|
|
|
|
2007-08-01 03:34:06 +00:00
|
|
|
out_unauthorized:
|
|
|
|
usb_unlock_device(usb_dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int usb_authorize_device(struct usb_device *usb_dev)
|
|
|
|
{
|
|
|
|
int result = 0, c;
|
2009-12-08 20:54:44 +00:00
|
|
|
|
2007-08-01 03:34:06 +00:00
|
|
|
usb_lock_device(usb_dev);
|
|
|
|
if (usb_dev->authorized == 1)
|
|
|
|
goto out_authorized;
|
2009-12-08 20:54:44 +00:00
|
|
|
|
2007-08-01 03:34:06 +00:00
|
|
|
result = usb_autoresume_device(usb_dev);
|
|
|
|
if (result < 0) {
|
|
|
|
dev_err(&usb_dev->dev,
|
|
|
|
"can't autoresume for authorization: %d\n", result);
|
|
|
|
goto error_autoresume;
|
|
|
|
}
|
|
|
|
result = usb_get_device_descriptor(usb_dev, sizeof(usb_dev->descriptor));
|
|
|
|
if (result < 0) {
|
|
|
|
dev_err(&usb_dev->dev, "can't re-read device descriptor for "
|
|
|
|
"authorization: %d\n", result);
|
|
|
|
goto error_device_descriptor;
|
|
|
|
}
|
2009-12-08 20:54:44 +00:00
|
|
|
|
|
|
|
kfree(usb_dev->product);
|
|
|
|
usb_dev->product = NULL;
|
|
|
|
kfree(usb_dev->manufacturer);
|
|
|
|
usb_dev->manufacturer = NULL;
|
|
|
|
kfree(usb_dev->serial);
|
|
|
|
usb_dev->serial = NULL;
|
|
|
|
|
2007-08-01 03:34:06 +00:00
|
|
|
usb_dev->authorized = 1;
|
2009-12-08 20:50:41 +00:00
|
|
|
result = usb_enumerate_device(usb_dev);
|
2007-08-01 03:34:06 +00:00
|
|
|
if (result < 0)
|
2009-12-08 20:50:41 +00:00
|
|
|
goto error_enumerate;
|
2007-08-01 03:34:06 +00:00
|
|
|
/* Choose and set the configuration. This registers the interfaces
|
|
|
|
* with the driver core and lets interface drivers bind to them.
|
|
|
|
*/
|
2007-08-03 04:44:27 +00:00
|
|
|
c = usb_choose_configuration(usb_dev);
|
2007-08-01 03:34:06 +00:00
|
|
|
if (c >= 0) {
|
|
|
|
result = usb_set_configuration(usb_dev, c);
|
|
|
|
if (result) {
|
|
|
|
dev_err(&usb_dev->dev,
|
|
|
|
"can't set config #%d, error %d\n", c, result);
|
|
|
|
/* This need not be fatal. The user can try to
|
|
|
|
* set other configurations. */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
dev_info(&usb_dev->dev, "authorized to connect\n");
|
2009-12-08 20:54:44 +00:00
|
|
|
|
2009-12-08 20:50:41 +00:00
|
|
|
error_enumerate:
|
2007-08-01 03:34:06 +00:00
|
|
|
error_device_descriptor:
|
2009-12-08 20:54:44 +00:00
|
|
|
usb_autosuspend_device(usb_dev);
|
2007-08-01 03:34:06 +00:00
|
|
|
error_autoresume:
|
|
|
|
out_authorized:
|
|
|
|
usb_unlock_device(usb_dev); // complements locktree
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-08-26 02:35:29 +00:00
|
|
|
/* Returns 1 if @hub is a WUSB root hub, 0 otherwise */
|
|
|
|
static unsigned hub_is_wusb(struct usb_hub *hub)
|
|
|
|
{
|
|
|
|
struct usb_hcd *hcd;
|
|
|
|
if (hub->hdev->parent != NULL) /* not a root hub? */
|
|
|
|
return 0;
|
|
|
|
hcd = container_of(hub->hdev->bus, struct usb_hcd, self);
|
|
|
|
return hcd->wireless;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define PORT_RESET_TRIES 5
|
|
|
|
#define SET_ADDRESS_TRIES 2
|
|
|
|
#define GET_DESCRIPTOR_TRIES 2
|
|
|
|
#define SET_CONFIG_TRIES (2 * (use_both_schemes + 1))
|
|
|
|
#define USE_NEW_SCHEME(i) ((i) / 2 == old_scheme_first)
|
|
|
|
|
|
|
|
#define HUB_ROOT_RESET_TIME 50 /* times are in msec */
|
|
|
|
#define HUB_SHORT_RESET_TIME 10
|
2011-09-13 23:41:11 +00:00
|
|
|
#define HUB_BH_RESET_TIME 50
|
2005-04-16 22:20:36 +00:00
|
|
|
#define HUB_LONG_RESET_TIME 200
|
|
|
|
#define HUB_RESET_TIMEOUT 500
|
|
|
|
|
USB: When hot reset for USB3 fails, try warm reset.
When a hot reset (standard USB port reset) fails on a USB 3.0 port, the
host controller transitions to the "Error" state. It reports the port
link state as "Inactive", sets the link state change flag, and (if the
device disconnects) also reports the disconnect and connect change status.
It's also supposed to transition the link state to "RxDetect", but the NEC
µPD720200 xHCI host does not.
Unfortunately, Harald found that the combination of the NEC µPD720200 and
a LogiLink USB 3.0 to SATA adapter triggered this issue. The USB core
would reset the device, the port would go into this error state, and the
device would never be enumerated. This combination works under Windows,
but not under Linux.
When a hot reset fails on a USB 3.0 port, and the link state is reported
as Inactive, fall back to a warm port reset instead. Harald confirms that
with a warm port reset (along with all the change bits being correctly
cleared), the USB 3.0 device will successfully enumerate.
Harald also had to add two other patches ("xhci: Set change bit when warm
reset change is set." and "usbcore: refine warm reset logic") to make this
setup work. Since the warm reset refinement patch is not destined for the
stable kernels (it's too big), this patch should not be backported either.
This fixes https://bugzilla.kernel.org/show_bug.cgi?id=41752
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Tested-by: Harald Brennich <harald.brennich@gmx.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-09-14 21:24:52 +00:00
|
|
|
static int hub_port_reset(struct usb_hub *hub, int port1,
|
|
|
|
struct usb_device *udev, unsigned int delay, bool warm);
|
|
|
|
|
|
|
|
/* Is a USB 3.0 port in the Inactive state? */
|
|
|
|
static bool hub_port_inactive(struct usb_hub *hub, u16 portstatus)
|
|
|
|
{
|
|
|
|
return hub_is_superspeed(hub->hdev) &&
|
|
|
|
(portstatus & USB_PORT_STAT_LINK_STATE) ==
|
|
|
|
USB_SS_PORT_LS_SS_INACTIVE;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int hub_port_wait_reset(struct usb_hub *hub, int port1,
|
2011-09-13 23:41:11 +00:00
|
|
|
struct usb_device *udev, unsigned int delay, bool warm)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int delay_time, ret;
|
|
|
|
u16 portstatus;
|
|
|
|
u16 portchange;
|
|
|
|
|
|
|
|
for (delay_time = 0;
|
|
|
|
delay_time < HUB_RESET_TIMEOUT;
|
|
|
|
delay_time += delay) {
|
|
|
|
/* wait to give the device a chance to reset */
|
|
|
|
msleep(delay);
|
|
|
|
|
|
|
|
/* read and decode port status */
|
|
|
|
ret = hub_port_status(hub, port1, &portstatus, &portchange);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2011-09-13 23:41:11 +00:00
|
|
|
/*
|
|
|
|
* Some buggy devices require a warm reset to be issued even
|
|
|
|
* when the port appears not to be connected.
|
|
|
|
*/
|
|
|
|
if (!warm) {
|
USB: When hot reset for USB3 fails, try warm reset.
When a hot reset (standard USB port reset) fails on a USB 3.0 port, the
host controller transitions to the "Error" state. It reports the port
link state as "Inactive", sets the link state change flag, and (if the
device disconnects) also reports the disconnect and connect change status.
It's also supposed to transition the link state to "RxDetect", but the NEC
µPD720200 xHCI host does not.
Unfortunately, Harald found that the combination of the NEC µPD720200 and
a LogiLink USB 3.0 to SATA adapter triggered this issue. The USB core
would reset the device, the port would go into this error state, and the
device would never be enumerated. This combination works under Windows,
but not under Linux.
When a hot reset fails on a USB 3.0 port, and the link state is reported
as Inactive, fall back to a warm port reset instead. Harald confirms that
with a warm port reset (along with all the change bits being correctly
cleared), the USB 3.0 device will successfully enumerate.
Harald also had to add two other patches ("xhci: Set change bit when warm
reset change is set." and "usbcore: refine warm reset logic") to make this
setup work. Since the warm reset refinement patch is not destined for the
stable kernels (it's too big), this patch should not be backported either.
This fixes https://bugzilla.kernel.org/show_bug.cgi?id=41752
Signed-off-by: Sarah Sharp <sarah.a.sharp@linux.intel.com>
Tested-by: Harald Brennich <harald.brennich@gmx.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-09-14 21:24:52 +00:00
|
|
|
/*
|
|
|
|
* Some buggy devices can cause an NEC host controller
|
|
|
|
* to transition to the "Error" state after a hot port
|
|
|
|
* reset. This will show up as the port state in
|
|
|
|
* "Inactive", and the port may also report a
|
|
|
|
* disconnect. Forcing a warm port reset seems to make
|
|
|
|
* the device work.
|
|
|
|
*
|
|
|
|
* See https://bugzilla.kernel.org/show_bug.cgi?id=41752
|
|
|
|
*/
|
|
|
|
if (hub_port_inactive(hub, portstatus)) {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if ((portchange & USB_PORT_STAT_C_CONNECTION))
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_CONNECTION);
|
|
|
|
if (portchange & USB_PORT_STAT_C_LINK_STATE)
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_PORT_LINK_STATE);
|
|
|
|
if (portchange & USB_PORT_STAT_C_RESET)
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_RESET);
|
|
|
|
dev_dbg(hub->intfdev, "hot reset failed, warm reset port %d\n",
|
|
|
|
port1);
|
|
|
|
ret = hub_port_reset(hub, port1,
|
|
|
|
udev, HUB_BH_RESET_TIME,
|
|
|
|
true);
|
|
|
|
if ((portchange & USB_PORT_STAT_C_CONNECTION))
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_CONNECTION);
|
|
|
|
return ret;
|
|
|
|
}
|
2011-09-13 23:41:11 +00:00
|
|
|
/* Device went away? */
|
|
|
|
if (!(portstatus & USB_PORT_STAT_CONNECTION))
|
|
|
|
return -ENOTCONN;
|
|
|
|
|
|
|
|
/* bomb out completely if the connection bounced */
|
|
|
|
if ((portchange & USB_PORT_STAT_C_CONNECTION))
|
|
|
|
return -ENOTCONN;
|
|
|
|
|
|
|
|
/* if we`ve finished resetting, then break out of
|
|
|
|
* the loop
|
|
|
|
*/
|
|
|
|
if (!(portstatus & USB_PORT_STAT_RESET) &&
|
|
|
|
(portstatus & USB_PORT_STAT_ENABLE)) {
|
|
|
|
if (hub_is_wusb(hub))
|
|
|
|
udev->speed = USB_SPEED_WIRELESS;
|
|
|
|
else if (hub_is_superspeed(hub->hdev))
|
|
|
|
udev->speed = USB_SPEED_SUPER;
|
|
|
|
else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
|
|
|
|
udev->speed = USB_SPEED_HIGH;
|
|
|
|
else if (portstatus & USB_PORT_STAT_LOW_SPEED)
|
|
|
|
udev->speed = USB_SPEED_LOW;
|
|
|
|
else
|
|
|
|
udev->speed = USB_SPEED_FULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (portchange & USB_PORT_STAT_C_BH_RESET)
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* switch to the long delay after two short delay failures */
|
|
|
|
if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
|
|
|
|
delay = HUB_LONG_RESET_TIME;
|
|
|
|
|
|
|
|
dev_dbg (hub->intfdev,
|
2011-09-13 23:41:11 +00:00
|
|
|
"port %d not %sreset yet, waiting %dms\n",
|
|
|
|
port1, warm ? "warm " : "", delay);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2011-09-13 23:41:11 +00:00
|
|
|
static void hub_port_finish_reset(struct usb_hub *hub, int port1,
|
|
|
|
struct usb_device *udev, int *status, bool warm)
|
|
|
|
{
|
|
|
|
switch (*status) {
|
|
|
|
case 0:
|
|
|
|
if (!warm) {
|
|
|
|
struct usb_hcd *hcd;
|
|
|
|
/* TRSTRCY = 10 ms; plus some extra */
|
|
|
|
msleep(10 + 40);
|
|
|
|
update_devnum(udev, 0);
|
|
|
|
hcd = bus_to_hcd(udev->bus);
|
|
|
|
if (hcd->driver->reset_device) {
|
|
|
|
*status = hcd->driver->reset_device(hcd, udev);
|
|
|
|
if (*status < 0) {
|
|
|
|
dev_err(&udev->dev, "Cannot reset "
|
|
|
|
"HCD device state\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* FALL THROUGH */
|
|
|
|
case -ENOTCONN:
|
|
|
|
case -ENODEV:
|
|
|
|
clear_port_feature(hub->hdev,
|
|
|
|
port1, USB_PORT_FEAT_C_RESET);
|
|
|
|
/* FIXME need disconnect() for NOTATTACHED device */
|
|
|
|
if (warm) {
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_BH_PORT_RESET);
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_PORT_LINK_STATE);
|
|
|
|
} else {
|
|
|
|
usb_set_device_state(udev, *status
|
|
|
|
? USB_STATE_NOTATTACHED
|
|
|
|
: USB_STATE_DEFAULT);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle port reset and port warm(BH) reset (for USB3 protocol ports) */
|
2005-04-16 22:20:36 +00:00
|
|
|
static int hub_port_reset(struct usb_hub *hub, int port1,
|
2011-09-13 23:41:11 +00:00
|
|
|
struct usb_device *udev, unsigned int delay, bool warm)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int i, status;
|
|
|
|
|
2011-09-13 23:41:11 +00:00
|
|
|
if (!warm) {
|
|
|
|
/* Block EHCI CF initialization during the port reset.
|
|
|
|
* Some companion controllers don't like it when they mix.
|
|
|
|
*/
|
|
|
|
down_read(&ehci_cf_port_reset_rwsem);
|
|
|
|
} else {
|
|
|
|
if (!hub_is_superspeed(hub->hdev)) {
|
|
|
|
dev_err(hub->intfdev, "only USB3 hub support "
|
|
|
|
"warm reset\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
2007-10-10 20:27:07 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Reset the port */
|
|
|
|
for (i = 0; i < PORT_RESET_TRIES; i++) {
|
2011-09-13 23:41:11 +00:00
|
|
|
status = set_port_feature(hub->hdev, port1, (warm ?
|
|
|
|
USB_PORT_FEAT_BH_PORT_RESET :
|
|
|
|
USB_PORT_FEAT_RESET));
|
|
|
|
if (status) {
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_err(hub->intfdev,
|
2011-09-13 23:41:11 +00:00
|
|
|
"cannot %sreset port %d (err = %d)\n",
|
|
|
|
warm ? "warm " : "", port1, status);
|
|
|
|
} else {
|
|
|
|
status = hub_port_wait_reset(hub, port1, udev, delay,
|
|
|
|
warm);
|
2005-08-31 17:45:25 +00:00
|
|
|
if (status && status != -ENOTCONN)
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_dbg(hub->intfdev,
|
|
|
|
"port_wait_reset: err = %d\n",
|
|
|
|
status);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* return on disconnect or reset */
|
2011-09-13 23:41:11 +00:00
|
|
|
if (status == 0 || status == -ENOTCONN || status == -ENODEV) {
|
|
|
|
hub_port_finish_reset(hub, port1, udev, &status, warm);
|
2007-10-10 20:27:07 +00:00
|
|
|
goto done;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg (hub->intfdev,
|
2011-09-13 23:41:11 +00:00
|
|
|
"port %d not enabled, trying %sreset again...\n",
|
|
|
|
port1, warm ? "warm " : "");
|
2005-04-16 22:20:36 +00:00
|
|
|
delay = HUB_LONG_RESET_TIME;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_err (hub->intfdev,
|
|
|
|
"Cannot enable port %i. Maybe the USB cable is bad?\n",
|
|
|
|
port1);
|
|
|
|
|
2011-09-13 23:41:11 +00:00
|
|
|
done:
|
|
|
|
if (!warm)
|
|
|
|
up_read(&ehci_cf_port_reset_rwsem);
|
2011-04-27 10:07:54 +00:00
|
|
|
|
2011-09-13 23:41:11 +00:00
|
|
|
return status;
|
2011-04-27 10:07:54 +00:00
|
|
|
}
|
|
|
|
|
2011-04-27 10:07:43 +00:00
|
|
|
/* Check if a port is power on */
|
|
|
|
static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (hub_is_superspeed(hub->hdev)) {
|
|
|
|
if (portstatus & USB_SS_PORT_STAT_POWER)
|
|
|
|
ret = 1;
|
|
|
|
} else {
|
|
|
|
if (portstatus & USB_PORT_STAT_POWER)
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-07-02 02:14:24 +00:00
|
|
|
#ifdef CONFIG_PM
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-04-27 10:07:43 +00:00
|
|
|
/* Check if a port is suspended(USB2.0 port) or in U3 state(USB3.0 port) */
|
|
|
|
static int port_is_suspended(struct usb_hub *hub, unsigned portstatus)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (hub_is_superspeed(hub->hdev)) {
|
|
|
|
if ((portstatus & USB_PORT_STAT_LINK_STATE)
|
|
|
|
== USB_SS_PORT_LS_U3)
|
|
|
|
ret = 1;
|
|
|
|
} else {
|
|
|
|
if (portstatus & USB_PORT_STAT_SUSPEND)
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2008-04-28 15:06:11 +00:00
|
|
|
|
|
|
|
/* Determine whether the device on a port is ready for a normal resume,
|
|
|
|
* is ready for a reset-resume, or should be disconnected.
|
|
|
|
*/
|
|
|
|
static int check_port_resume_type(struct usb_device *udev,
|
|
|
|
struct usb_hub *hub, int port1,
|
|
|
|
int status, unsigned portchange, unsigned portstatus)
|
|
|
|
{
|
|
|
|
/* Is the device still present? */
|
2011-04-27 10:07:43 +00:00
|
|
|
if (status || port_is_suspended(hub, portstatus) ||
|
|
|
|
!port_is_power_on(hub, portstatus) ||
|
|
|
|
!(portstatus & USB_PORT_STAT_CONNECTION)) {
|
2008-04-28 15:06:11 +00:00
|
|
|
if (status >= 0)
|
|
|
|
status = -ENODEV;
|
|
|
|
}
|
|
|
|
|
2008-06-30 15:14:43 +00:00
|
|
|
/* Can't do a normal resume if the port isn't enabled,
|
|
|
|
* so try a reset-resume instead.
|
|
|
|
*/
|
|
|
|
else if (!(portstatus & USB_PORT_STAT_ENABLE) && !udev->reset_resume) {
|
|
|
|
if (udev->persist_enabled)
|
|
|
|
udev->reset_resume = 1;
|
|
|
|
else
|
|
|
|
status = -ENODEV;
|
|
|
|
}
|
2008-04-28 15:06:11 +00:00
|
|
|
|
|
|
|
if (status) {
|
|
|
|
dev_dbg(hub->intfdev,
|
|
|
|
"port %d status %04x.%04x after resume, %d\n",
|
|
|
|
port1, portchange, portstatus, status);
|
|
|
|
} else if (udev->reset_resume) {
|
|
|
|
|
|
|
|
/* Late port handoff can set status-change bits */
|
|
|
|
if (portchange & USB_PORT_STAT_C_CONNECTION)
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_CONNECTION);
|
|
|
|
if (portchange & USB_PORT_STAT_C_ENABLE)
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_ENABLE);
|
|
|
|
}
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_USB_SUSPEND
|
|
|
|
|
|
|
|
/*
|
2007-05-30 19:35:16 +00:00
|
|
|
* usb_port_suspend - suspend a usb device's upstream port
|
|
|
|
* @udev: device that's no longer in active use, not a root hub
|
|
|
|
* Context: must be able to sleep; device not locked; pm locks held
|
|
|
|
*
|
|
|
|
* Suspends a USB device that isn't in active use, conserving power.
|
|
|
|
* Devices may wake out of a suspend, if anything important happens,
|
|
|
|
* using the remote wakeup mechanism. They may also be taken out of
|
|
|
|
* suspend by the host, using usb_port_resume(). It's also routine
|
|
|
|
* to disconnect devices while they are suspended.
|
|
|
|
*
|
|
|
|
* This only affects the USB hardware for a device; its interfaces
|
|
|
|
* (and, for hubs, child devices) must already have been suspended.
|
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Selective port suspend reduces power; most suspended devices draw
|
|
|
|
* less than 500 uA. It's also used in OTG, along with remote wakeup.
|
|
|
|
* All devices below the suspended port are also suspended.
|
|
|
|
*
|
|
|
|
* Devices leave suspend state when the host wakes them up. Some devices
|
|
|
|
* also support "remote wakeup", where the device can activate the USB
|
|
|
|
* tree above them to deliver data, such as a keypress or packet. In
|
|
|
|
* some cases, this wakes the USB host.
|
2007-05-30 19:35:16 +00:00
|
|
|
*
|
|
|
|
* Suspending OTG devices may trigger HNP, if that's been enabled
|
|
|
|
* between a pair of dual-role devices. That will change roles, such
|
|
|
|
* as from A-Host to A-Peripheral or from B-Host back to B-Peripheral.
|
|
|
|
*
|
|
|
|
* Devices on USB hub ports have only one "suspend" state, corresponding
|
|
|
|
* to ACPI D2, "may cause the device to lose some context".
|
|
|
|
* State transitions include:
|
|
|
|
*
|
|
|
|
* - suspend, resume ... when the VBUS power link stays live
|
|
|
|
* - suspend, disconnect ... VBUS lost
|
|
|
|
*
|
|
|
|
* Once VBUS drop breaks the circuit, the port it's using has to go through
|
|
|
|
* normal re-enumeration procedures, starting with enabling VBUS power.
|
|
|
|
* Other than re-initializing the hub (plug/unplug, except for root hubs),
|
|
|
|
* Linux (2.6) currently has NO mechanisms to initiate that: no khubd
|
|
|
|
* timer, no SRP, no requests through sysfs.
|
|
|
|
*
|
|
|
|
* If CONFIG_USB_SUSPEND isn't enabled, devices only really suspend when
|
|
|
|
* the root hub for their bus goes into global suspend ... so we don't
|
|
|
|
* (falsely) update the device power state to say it suspended.
|
|
|
|
*
|
|
|
|
* Returns 0 on success, else negative errno.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-11-25 21:39:18 +00:00
|
|
|
int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-05-30 19:35:16 +00:00
|
|
|
struct usb_hub *hub = hdev_to_hub(udev->parent);
|
|
|
|
int port1 = udev->portnum;
|
|
|
|
int status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* enable remote wakeup when appropriate; this lets the device
|
|
|
|
* wake up the upstream hub (including maybe the root hub).
|
|
|
|
*
|
|
|
|
* NOTE: OTG devices may issue remote wakeup (or SRP) even when
|
|
|
|
* we don't explicitly enable it here.
|
|
|
|
*/
|
2006-08-30 19:47:02 +00:00
|
|
|
if (udev->do_remote_wakeup) {
|
2005-04-16 22:20:36 +00:00
|
|
|
status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
|
|
|
|
USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
|
|
|
|
USB_DEVICE_REMOTE_WAKEUP, 0,
|
|
|
|
NULL, 0,
|
|
|
|
USB_CTRL_SET_TIMEOUT);
|
2009-10-19 11:19:41 +00:00
|
|
|
if (status) {
|
2007-05-30 19:35:16 +00:00
|
|
|
dev_dbg(&udev->dev, "won't remote wakeup, status %d\n",
|
|
|
|
status);
|
2009-10-19 11:19:41 +00:00
|
|
|
/* bail if autosuspend is requested */
|
2011-08-19 21:49:48 +00:00
|
|
|
if (PMSG_IS_AUTO(msg))
|
2009-10-19 11:19:41 +00:00
|
|
|
return status;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-09-23 21:19:52 +00:00
|
|
|
/* disable USB2 hardware LPM */
|
|
|
|
if (udev->usb2_hw_lpm_enabled == 1)
|
|
|
|
usb_set_usb2_hardware_lpm(udev, 0);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* see 7.1.7.6 */
|
2011-04-27 10:07:50 +00:00
|
|
|
if (hub_is_superspeed(hub->hdev))
|
|
|
|
status = set_port_feature(hub->hdev,
|
|
|
|
port1 | (USB_SS_PORT_LS_U3 << 3),
|
|
|
|
USB_PORT_FEAT_LINK_STATE);
|
2011-03-31 06:56:50 +00:00
|
|
|
else
|
|
|
|
status = set_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_SUSPEND);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (status) {
|
2007-05-30 19:35:16 +00:00
|
|
|
dev_dbg(hub->intfdev, "can't suspend port %d, status %d\n",
|
|
|
|
port1, status);
|
2005-04-16 22:20:36 +00:00
|
|
|
/* paranoia: "should not happen" */
|
2009-10-19 11:19:41 +00:00
|
|
|
if (udev->do_remote_wakeup)
|
|
|
|
(void) usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
|
2005-04-16 22:20:36 +00:00
|
|
|
USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
|
|
|
|
USB_DEVICE_REMOTE_WAKEUP, 0,
|
|
|
|
NULL, 0,
|
|
|
|
USB_CTRL_SET_TIMEOUT);
|
2011-06-15 20:29:16 +00:00
|
|
|
|
|
|
|
/* System sleep transitions should never fail */
|
2011-08-19 21:49:48 +00:00
|
|
|
if (!PMSG_IS_AUTO(msg))
|
2011-06-15 20:29:16 +00:00
|
|
|
status = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
|
|
|
/* device has up to 10 msec to fully suspend */
|
2011-09-27 19:54:22 +00:00
|
|
|
dev_dbg(&udev->dev, "usb %ssuspend, wakeup %d\n",
|
|
|
|
(PMSG_IS_AUTO(msg) ? "auto-" : ""),
|
|
|
|
udev->do_remote_wakeup);
|
2005-04-16 22:20:36 +00:00
|
|
|
usb_set_device_state(udev, USB_STATE_SUSPENDED);
|
|
|
|
msleep(10);
|
|
|
|
}
|
2010-11-15 20:57:58 +00:00
|
|
|
usb_mark_last_busy(hub->hdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2005-09-14 02:57:27 +00:00
|
|
|
* If the USB "suspend" state is in use (rather than "global suspend"),
|
|
|
|
* many devices will be individually taken out of suspend state using
|
2007-05-30 19:38:58 +00:00
|
|
|
* special "resume" signaling. This routine kicks in shortly after
|
2005-04-16 22:20:36 +00:00
|
|
|
* hardware resume signaling is finished, either because of selective
|
|
|
|
* resume (by host) or remote wakeup (by device) ... now see what changed
|
|
|
|
* in the tree that's rooted at this device.
|
2007-05-30 19:38:58 +00:00
|
|
|
*
|
|
|
|
* If @udev->reset_resume is set then the device is reset before the
|
|
|
|
* status check is done.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2006-07-02 02:07:21 +00:00
|
|
|
static int finish_port_resume(struct usb_device *udev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-05-30 19:38:58 +00:00
|
|
|
int status = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
u16 devstatus;
|
|
|
|
|
|
|
|
/* caller owns the udev device lock */
|
2008-12-15 07:32:01 +00:00
|
|
|
dev_dbg(&udev->dev, "%s\n",
|
|
|
|
udev->reset_resume ? "finish reset-resume" : "finish resume");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* usb ch9 identifies four variants of SUSPENDED, based on what
|
|
|
|
* state the device resumes to. Linux currently won't see the
|
|
|
|
* first two on the host side; they'd be inside hub_port_init()
|
|
|
|
* during many timeouts, but khubd can't suspend until later.
|
|
|
|
*/
|
|
|
|
usb_set_device_state(udev, udev->actconfig
|
|
|
|
? USB_STATE_CONFIGURED
|
|
|
|
: USB_STATE_ADDRESS);
|
|
|
|
|
2007-05-30 19:38:58 +00:00
|
|
|
/* 10.5.4.5 says not to reset a suspended port if the attached
|
|
|
|
* device is enabled for remote wakeup. Hence the reset
|
|
|
|
* operation is carried out here, after the port has been
|
|
|
|
* resumed.
|
|
|
|
*/
|
|
|
|
if (udev->reset_resume)
|
2008-06-30 15:14:43 +00:00
|
|
|
retry_reset_resume:
|
2008-06-18 14:00:29 +00:00
|
|
|
status = usb_reset_and_verify_device(udev);
|
2007-05-30 19:38:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* 10.5.4.5 says be sure devices in the tree are still there.
|
|
|
|
* For now let's assume the device didn't go crazy on resume,
|
|
|
|
* and device drivers will know about any resume quirks.
|
|
|
|
*/
|
2007-05-30 19:38:58 +00:00
|
|
|
if (status == 0) {
|
2007-08-14 14:56:10 +00:00
|
|
|
devstatus = 0;
|
2007-05-30 19:38:58 +00:00
|
|
|
status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
|
|
|
|
if (status >= 0)
|
2007-08-14 14:56:10 +00:00
|
|
|
status = (status > 0 ? 0 : -ENODEV);
|
2008-06-30 15:14:43 +00:00
|
|
|
|
|
|
|
/* If a normal resume failed, try doing a reset-resume */
|
|
|
|
if (status && !udev->reset_resume && udev->persist_enabled) {
|
|
|
|
dev_dbg(&udev->dev, "retry with reset-resume\n");
|
|
|
|
udev->reset_resume = 1;
|
|
|
|
goto retry_reset_resume;
|
|
|
|
}
|
2007-05-30 19:38:58 +00:00
|
|
|
}
|
2006-06-19 19:12:38 +00:00
|
|
|
|
2007-05-30 19:35:16 +00:00
|
|
|
if (status) {
|
|
|
|
dev_dbg(&udev->dev, "gone after usb resume? status %d\n",
|
|
|
|
status);
|
|
|
|
} else if (udev->actconfig) {
|
2005-04-16 22:20:36 +00:00
|
|
|
le16_to_cpus(&devstatus);
|
2007-05-30 19:34:36 +00:00
|
|
|
if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
status = usb_control_msg(udev,
|
|
|
|
usb_sndctrlpipe(udev, 0),
|
|
|
|
USB_REQ_CLEAR_FEATURE,
|
|
|
|
USB_RECIP_DEVICE,
|
|
|
|
USB_DEVICE_REMOTE_WAKEUP, 0,
|
|
|
|
NULL, 0,
|
|
|
|
USB_CTRL_SET_TIMEOUT);
|
2006-07-02 02:11:02 +00:00
|
|
|
if (status)
|
2008-12-15 07:32:01 +00:00
|
|
|
dev_dbg(&udev->dev,
|
|
|
|
"disable remote wakeup, status %d\n",
|
|
|
|
status);
|
2005-11-21 16:58:07 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
status = 0;
|
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2007-05-30 19:35:16 +00:00
|
|
|
/*
|
|
|
|
* usb_port_resume - re-activate a suspended usb device's upstream port
|
|
|
|
* @udev: device to re-activate, not a root hub
|
|
|
|
* Context: must be able to sleep; device not locked; pm locks held
|
|
|
|
*
|
|
|
|
* This will re-activate the suspended device, increasing power usage
|
|
|
|
* while letting drivers communicate again with its endpoints.
|
|
|
|
* USB resume explicitly guarantees that the power session between
|
|
|
|
* the host and the device is the same as it was when the device
|
|
|
|
* suspended.
|
|
|
|
*
|
2008-03-03 20:15:59 +00:00
|
|
|
* If @udev->reset_resume is set then this routine won't check that the
|
|
|
|
* port is still enabled. Furthermore, finish_port_resume() above will
|
2007-05-30 19:38:58 +00:00
|
|
|
* reset @udev. The end result is that a broken power session can be
|
|
|
|
* recovered and @udev will appear to persist across a loss of VBUS power.
|
|
|
|
*
|
|
|
|
* For example, if a host controller doesn't maintain VBUS suspend current
|
|
|
|
* during a system sleep or is reset when the system wakes up, all the USB
|
|
|
|
* power sessions below it will be broken. This is especially troublesome
|
|
|
|
* for mass-storage devices containing mounted filesystems, since the
|
|
|
|
* device will appear to have disconnected and all the memory mappings
|
|
|
|
* to it will be lost. Using the USB_PERSIST facility, the device can be
|
|
|
|
* made to appear as if it had not disconnected.
|
|
|
|
*
|
2008-06-18 14:00:29 +00:00
|
|
|
* This facility can be dangerous. Although usb_reset_and_verify_device() makes
|
2008-03-03 20:15:59 +00:00
|
|
|
* every effort to insure that the same device is present after the
|
2007-05-30 19:38:58 +00:00
|
|
|
* reset as before, it cannot provide a 100% guarantee. Furthermore it's
|
|
|
|
* quite possible for a device to remain unaltered but its media to be
|
|
|
|
* changed. If the user replaces a flash memory card while the system is
|
|
|
|
* asleep, he will have only himself to blame when the filesystem on the
|
|
|
|
* new card is corrupted and the system crashes.
|
|
|
|
*
|
2007-05-30 19:35:16 +00:00
|
|
|
* Returns 0 on success, else negative errno.
|
|
|
|
*/
|
2008-11-25 21:39:18 +00:00
|
|
|
int usb_port_resume(struct usb_device *udev, pm_message_t msg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-05-30 19:35:16 +00:00
|
|
|
struct usb_hub *hub = hdev_to_hub(udev->parent);
|
|
|
|
int port1 = udev->portnum;
|
|
|
|
int status;
|
|
|
|
u16 portchange, portstatus;
|
2006-11-20 16:14:30 +00:00
|
|
|
|
|
|
|
/* Skip the initial Clear-Suspend step for a remote wakeup */
|
|
|
|
status = hub_port_status(hub, port1, &portstatus, &portchange);
|
2011-04-27 10:07:43 +00:00
|
|
|
if (status == 0 && !port_is_suspended(hub, portstatus))
|
2006-11-20 16:14:30 +00:00
|
|
|
goto SuspendCleared;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
// dev_dbg(hub->intfdev, "resume port %d\n", port1);
|
|
|
|
|
2006-08-11 20:52:39 +00:00
|
|
|
set_bit(port1, hub->busy_bits);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* see 7.1.7.7; affects power usage, but not budgeting */
|
2011-04-27 10:07:50 +00:00
|
|
|
if (hub_is_superspeed(hub->hdev))
|
|
|
|
status = set_port_feature(hub->hdev,
|
|
|
|
port1 | (USB_SS_PORT_LS_U0 << 3),
|
|
|
|
USB_PORT_FEAT_LINK_STATE);
|
|
|
|
else
|
|
|
|
status = clear_port_feature(hub->hdev,
|
|
|
|
port1, USB_PORT_FEAT_SUSPEND);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (status) {
|
2007-05-30 19:35:16 +00:00
|
|
|
dev_dbg(hub->intfdev, "can't resume port %d, status %d\n",
|
|
|
|
port1, status);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
|
|
|
/* drive resume for at least 20 msec */
|
2007-05-30 19:34:36 +00:00
|
|
|
dev_dbg(&udev->dev, "usb %sresume\n",
|
2011-08-19 21:49:48 +00:00
|
|
|
(PMSG_IS_AUTO(msg) ? "auto-" : ""));
|
2005-04-16 22:20:36 +00:00
|
|
|
msleep(25);
|
|
|
|
|
|
|
|
/* Virtual root hubs can trigger on GET_PORT_STATUS to
|
|
|
|
* stop resume signaling. Then finish the resume
|
|
|
|
* sequence.
|
|
|
|
*/
|
2006-11-20 16:14:30 +00:00
|
|
|
status = hub_port_status(hub, port1, &portstatus, &portchange);
|
2007-05-30 19:38:58 +00:00
|
|
|
|
2008-04-28 15:06:11 +00:00
|
|
|
/* TRSMRCY = 10 msec */
|
|
|
|
msleep(10);
|
|
|
|
}
|
|
|
|
|
2007-05-30 19:38:58 +00:00
|
|
|
SuspendCleared:
|
2008-04-28 15:06:11 +00:00
|
|
|
if (status == 0) {
|
2011-04-27 10:07:50 +00:00
|
|
|
if (hub_is_superspeed(hub->hdev)) {
|
|
|
|
if (portchange & USB_PORT_STAT_C_LINK_STATE)
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_PORT_LINK_STATE);
|
|
|
|
} else {
|
|
|
|
if (portchange & USB_PORT_STAT_C_SUSPEND)
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_SUSPEND);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-08-11 20:52:39 +00:00
|
|
|
clear_bit(port1, hub->busy_bits);
|
|
|
|
|
2008-04-28 15:06:11 +00:00
|
|
|
status = check_port_resume_type(udev,
|
|
|
|
hub, port1, status, portchange, portstatus);
|
2007-05-30 19:38:58 +00:00
|
|
|
if (status == 0)
|
|
|
|
status = finish_port_resume(udev);
|
|
|
|
if (status < 0) {
|
|
|
|
dev_dbg(&udev->dev, "can't resume, status %d\n", status);
|
|
|
|
hub_port_logical_disconnect(hub, port1);
|
2011-09-23 21:19:52 +00:00
|
|
|
} else {
|
|
|
|
/* Try to enable USB2 hardware LPM */
|
|
|
|
if (udev->usb2_hw_lpm_capable == 1)
|
|
|
|
usb_set_usb2_hardware_lpm(udev, 1);
|
2007-05-30 19:38:58 +00:00
|
|
|
}
|
2011-09-23 21:19:52 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2008-04-28 15:06:55 +00:00
|
|
|
/* caller has locked udev */
|
2010-01-08 17:56:30 +00:00
|
|
|
int usb_remote_wakeup(struct usb_device *udev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
if (udev->state == USB_STATE_SUSPENDED) {
|
2006-08-30 19:47:02 +00:00
|
|
|
dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
|
2010-01-08 17:57:28 +00:00
|
|
|
status = usb_autoresume_device(udev);
|
|
|
|
if (status == 0) {
|
|
|
|
/* Let the drivers do their thing, then... */
|
|
|
|
usb_autosuspend_device(udev);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-07-02 02:14:24 +00:00
|
|
|
#else /* CONFIG_USB_SUSPEND */
|
|
|
|
|
|
|
|
/* When CONFIG_USB_SUSPEND isn't set, we never suspend or resume any ports. */
|
|
|
|
|
2008-11-25 21:39:18 +00:00
|
|
|
int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
|
2006-07-02 02:14:24 +00:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-28 15:06:11 +00:00
|
|
|
/* However we may need to do a reset-resume */
|
|
|
|
|
2008-11-25 21:39:18 +00:00
|
|
|
int usb_port_resume(struct usb_device *udev, pm_message_t msg)
|
2006-07-02 02:14:24 +00:00
|
|
|
{
|
2008-04-28 15:06:11 +00:00
|
|
|
struct usb_hub *hub = hdev_to_hub(udev->parent);
|
|
|
|
int port1 = udev->portnum;
|
|
|
|
int status;
|
|
|
|
u16 portchange, portstatus;
|
|
|
|
|
|
|
|
status = hub_port_status(hub, port1, &portstatus, &portchange);
|
|
|
|
status = check_port_resume_type(udev,
|
|
|
|
hub, port1, status, portchange, portstatus);
|
2007-05-30 19:38:58 +00:00
|
|
|
|
2008-04-28 15:06:11 +00:00
|
|
|
if (status) {
|
|
|
|
dev_dbg(&udev->dev, "can't resume, status %d\n", status);
|
|
|
|
hub_port_logical_disconnect(hub, port1);
|
|
|
|
} else if (udev->reset_resume) {
|
2007-05-30 19:38:58 +00:00
|
|
|
dev_dbg(&udev->dev, "reset-resume\n");
|
2008-06-18 14:00:29 +00:00
|
|
|
status = usb_reset_and_verify_device(udev);
|
2007-05-30 19:38:58 +00:00
|
|
|
}
|
|
|
|
return status;
|
2006-07-02 02:14:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2005-09-14 02:56:33 +00:00
|
|
|
static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct usb_hub *hub = usb_get_intfdata (intf);
|
|
|
|
struct usb_device *hdev = hub->hdev;
|
|
|
|
unsigned port1;
|
|
|
|
|
2011-06-15 20:29:16 +00:00
|
|
|
/* Warn if children aren't already suspended */
|
2005-04-16 22:20:36 +00:00
|
|
|
for (port1 = 1; port1 <= hdev->maxchild; port1++) {
|
|
|
|
struct usb_device *udev;
|
|
|
|
|
|
|
|
udev = hdev->children [port1-1];
|
2007-09-10 15:34:26 +00:00
|
|
|
if (udev && udev->can_submit) {
|
2011-06-15 20:29:16 +00:00
|
|
|
dev_warn(&intf->dev, "port %d nyet suspended\n", port1);
|
2011-08-19 21:49:48 +00:00
|
|
|
if (PMSG_IS_AUTO(msg))
|
2011-06-15 20:29:16 +00:00
|
|
|
return -EBUSY;
|
2005-09-14 02:57:04 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-03-04 00:08:34 +00:00
|
|
|
dev_dbg(&intf->dev, "%s\n", __func__);
|
2006-11-09 19:44:33 +00:00
|
|
|
|
2007-02-01 21:08:41 +00:00
|
|
|
/* stop khubd and related activity */
|
2008-04-28 15:07:31 +00:00
|
|
|
hub_quiesce(hub, HUB_SUSPEND);
|
2007-05-04 15:51:54 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hub_resume(struct usb_interface *intf)
|
|
|
|
{
|
2008-03-03 20:15:51 +00:00
|
|
|
struct usb_hub *hub = usb_get_intfdata(intf);
|
2006-11-09 19:44:33 +00:00
|
|
|
|
2008-03-03 20:15:51 +00:00
|
|
|
dev_dbg(&intf->dev, "%s\n", __func__);
|
2008-04-28 15:07:17 +00:00
|
|
|
hub_activate(hub, HUB_RESUME);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-05-30 19:39:33 +00:00
|
|
|
static int hub_reset_resume(struct usb_interface *intf)
|
2007-05-30 19:38:16 +00:00
|
|
|
{
|
2007-05-30 19:39:33 +00:00
|
|
|
struct usb_hub *hub = usb_get_intfdata(intf);
|
2007-05-30 19:38:16 +00:00
|
|
|
|
2008-03-03 20:15:51 +00:00
|
|
|
dev_dbg(&intf->dev, "%s\n", __func__);
|
2008-04-28 15:07:17 +00:00
|
|
|
hub_activate(hub, HUB_RESET_RESUME);
|
2007-05-30 19:38:16 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-05-30 19:38:58 +00:00
|
|
|
/**
|
|
|
|
* usb_root_hub_lost_power - called by HCD if the root hub lost Vbus power
|
|
|
|
* @rhdev: struct usb_device for the root hub
|
|
|
|
*
|
|
|
|
* The USB host controller driver calls this function when its root hub
|
|
|
|
* is resumed and Vbus power has been interrupted or the controller
|
2008-03-03 20:15:59 +00:00
|
|
|
* has been reset. The routine marks @rhdev as having lost power.
|
|
|
|
* When the hub driver is resumed it will take notice and carry out
|
|
|
|
* power-session recovery for all the "USB-PERSIST"-enabled child devices;
|
|
|
|
* the others will be disconnected.
|
2007-05-30 19:38:58 +00:00
|
|
|
*/
|
|
|
|
void usb_root_hub_lost_power(struct usb_device *rhdev)
|
|
|
|
{
|
|
|
|
dev_warn(&rhdev->dev, "root hub lost power or was reset\n");
|
|
|
|
rhdev->reset_resume = 1;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);
|
|
|
|
|
2006-07-02 02:14:24 +00:00
|
|
|
#else /* CONFIG_PM */
|
|
|
|
|
2007-05-30 19:38:16 +00:00
|
|
|
#define hub_suspend NULL
|
|
|
|
#define hub_resume NULL
|
|
|
|
#define hub_reset_resume NULL
|
2006-07-02 02:14:24 +00:00
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* USB 2.0 spec, 7.1.7.3 / fig 7-29:
|
|
|
|
*
|
|
|
|
* Between connect detection and reset signaling there must be a delay
|
|
|
|
* of 100ms at least for debounce and power-settling. The corresponding
|
|
|
|
* timer shall restart whenever the downstream port detects a disconnect.
|
|
|
|
*
|
|
|
|
* Apparently there are some bluetooth and irda-dongles and a number of
|
|
|
|
* low-speed devices for which this debounce period may last over a second.
|
|
|
|
* Not covered by the spec - but easy to deal with.
|
|
|
|
*
|
|
|
|
* This implementation uses a 1500ms total debounce timeout; if the
|
|
|
|
* connection isn't stable by then it returns -ETIMEDOUT. It checks
|
|
|
|
* every 25ms for transient disconnects. When the port status has been
|
|
|
|
* unchanged for 100ms it returns the port status.
|
|
|
|
*/
|
|
|
|
static int hub_port_debounce(struct usb_hub *hub, int port1)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int total_time, stable_time = 0;
|
|
|
|
u16 portchange, portstatus;
|
|
|
|
unsigned connection = 0xffff;
|
|
|
|
|
|
|
|
for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
|
|
|
|
ret = hub_port_status(hub, port1, &portstatus, &portchange);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (!(portchange & USB_PORT_STAT_C_CONNECTION) &&
|
|
|
|
(portstatus & USB_PORT_STAT_CONNECTION) == connection) {
|
|
|
|
stable_time += HUB_DEBOUNCE_STEP;
|
|
|
|
if (stable_time >= HUB_DEBOUNCE_STABLE)
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
stable_time = 0;
|
|
|
|
connection = portstatus & USB_PORT_STAT_CONNECTION;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (portchange & USB_PORT_STAT_C_CONNECTION) {
|
|
|
|
clear_port_feature(hub->hdev, port1,
|
|
|
|
USB_PORT_FEAT_C_CONNECTION);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (total_time >= HUB_DEBOUNCE_TIMEOUT)
|
|
|
|
break;
|
|
|
|
msleep(HUB_DEBOUNCE_STEP);
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg (hub->intfdev,
|
|
|
|
"debounce: port %d: total %dms stable %dms status 0x%x\n",
|
|
|
|
port1, total_time, stable_time, portstatus);
|
|
|
|
|
|
|
|
if (stable_time < HUB_DEBOUNCE_STABLE)
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
return portstatus;
|
|
|
|
}
|
|
|
|
|
2008-04-08 20:24:46 +00:00
|
|
|
void usb_ep0_reinit(struct usb_device *udev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-01-15 22:03:33 +00:00
|
|
|
usb_disable_endpoint(udev, 0 + USB_DIR_IN, true);
|
|
|
|
usb_disable_endpoint(udev, 0 + USB_DIR_OUT, true);
|
2008-12-31 16:31:33 +00:00
|
|
|
usb_enable_endpoint(udev, &udev->ep0, true);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-04-08 20:24:46 +00:00
|
|
|
EXPORT_SYMBOL_GPL(usb_ep0_reinit);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define usb_sndaddr0pipe() (PIPE_CONTROL << 30)
|
|
|
|
#define usb_rcvaddr0pipe() ((PIPE_CONTROL << 30) | USB_DIR_IN)
|
|
|
|
|
2007-07-30 21:08:43 +00:00
|
|
|
static int hub_set_address(struct usb_device *udev, int devnum)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int retval;
|
2009-04-28 02:57:26 +00:00
|
|
|
struct usb_hcd *hcd = bus_to_hcd(udev->bus);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-28 02:57:26 +00:00
|
|
|
/*
|
|
|
|
* The host controller will choose the device address,
|
|
|
|
* instead of the core having chosen it earlier
|
|
|
|
*/
|
|
|
|
if (!hcd->driver->address_device && devnum <= 1)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
if (udev->state == USB_STATE_ADDRESS)
|
|
|
|
return 0;
|
|
|
|
if (udev->state != USB_STATE_DEFAULT)
|
|
|
|
return -EINVAL;
|
2010-10-14 14:22:51 +00:00
|
|
|
if (hcd->driver->address_device)
|
2009-04-28 02:57:26 +00:00
|
|
|
retval = hcd->driver->address_device(hcd, udev);
|
2010-10-14 14:22:51 +00:00
|
|
|
else
|
2009-04-28 02:57:26 +00:00
|
|
|
retval = usb_control_msg(udev, usb_sndaddr0pipe(),
|
|
|
|
USB_REQ_SET_ADDRESS, 0, devnum, 0,
|
|
|
|
NULL, 0, USB_CTRL_SET_TIMEOUT);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (retval == 0) {
|
2011-02-22 14:53:41 +00:00
|
|
|
update_devnum(udev, devnum);
|
2008-04-08 20:24:46 +00:00
|
|
|
/* Device now using proper address. */
|
2005-04-16 22:20:36 +00:00
|
|
|
usb_set_device_state(udev, USB_STATE_ADDRESS);
|
2008-04-08 20:24:46 +00:00
|
|
|
usb_ep0_reinit(udev);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Reset device, (re)assign address, get device descriptor.
|
|
|
|
* Device connection must be stable, no more debouncing needed.
|
|
|
|
* Returns device in USB_STATE_ADDRESS, except on error.
|
|
|
|
*
|
|
|
|
* If this is called for an already-existing device (as part of
|
2008-06-18 14:00:29 +00:00
|
|
|
* usb_reset_and_verify_device), the caller must own the device lock. For a
|
2005-04-16 22:20:36 +00:00
|
|
|
* newly detected device that is not accessible through any global
|
|
|
|
* pointers, it's not necessary to lock the device.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
|
|
|
|
int retry_counter)
|
|
|
|
{
|
2006-01-11 14:55:29 +00:00
|
|
|
static DEFINE_MUTEX(usb_address0_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
struct usb_device *hdev = hub->hdev;
|
2009-04-28 02:54:26 +00:00
|
|
|
struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
|
2005-04-16 22:20:36 +00:00
|
|
|
int i, j, retval;
|
|
|
|
unsigned delay = HUB_SHORT_RESET_TIME;
|
|
|
|
enum usb_device_speed oldspeed = udev->speed;
|
2011-08-30 15:11:19 +00:00
|
|
|
const char *speed;
|
2007-07-30 21:08:43 +00:00
|
|
|
int devnum = udev->devnum;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* root hub ports have a slightly longer reset period
|
|
|
|
* (from USB 2.0 spec, section 7.1.7.5)
|
|
|
|
*/
|
|
|
|
if (!hdev->parent) {
|
|
|
|
delay = HUB_ROOT_RESET_TIME;
|
|
|
|
if (port1 == hdev->bus->otg_port)
|
|
|
|
hdev->bus->b_hnp_enable = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Some low speed devices have problems with the quick delay, so */
|
|
|
|
/* be a bit pessimistic with those devices. RHbug #23670 */
|
|
|
|
if (oldspeed == USB_SPEED_LOW)
|
|
|
|
delay = HUB_LONG_RESET_TIME;
|
|
|
|
|
2006-01-11 14:55:29 +00:00
|
|
|
mutex_lock(&usb_address0_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-02-11 19:33:10 +00:00
|
|
|
/* Reset the device; full speed may morph to high speed */
|
|
|
|
/* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */
|
2011-09-13 23:41:11 +00:00
|
|
|
retval = hub_port_reset(hub, port1, udev, delay, false);
|
2011-02-11 19:33:10 +00:00
|
|
|
if (retval < 0) /* error or disconnect */
|
|
|
|
goto fail;
|
|
|
|
/* success, speed is known */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
retval = -ENODEV;
|
|
|
|
|
|
|
|
if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed) {
|
|
|
|
dev_dbg(&udev->dev, "device reset changed speed!\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
oldspeed = udev->speed;
|
2007-07-30 21:08:43 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* USB 2.0 section 5.5.3 talks about ep0 maxpacket ...
|
|
|
|
* it's fixed size except for full speed devices.
|
2006-08-26 02:35:30 +00:00
|
|
|
* For Wireless USB devices, ep0 max packet is always 512 (tho
|
|
|
|
* reported as 0xff in the device descriptor). WUSB1.0[4.8.1].
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
switch (udev->speed) {
|
2009-04-28 02:54:10 +00:00
|
|
|
case USB_SPEED_SUPER:
|
2010-01-14 19:08:04 +00:00
|
|
|
case USB_SPEED_WIRELESS: /* fixed at 512 */
|
2009-02-11 22:11:36 +00:00
|
|
|
udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
|
2006-08-26 02:35:30 +00:00
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
case USB_SPEED_HIGH: /* fixed at 64 */
|
2009-02-11 22:11:36 +00:00
|
|
|
udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case USB_SPEED_FULL: /* 8, 16, 32, or 64 */
|
|
|
|
/* to determine the ep0 maxpacket size, try to read
|
|
|
|
* the device descriptor to get bMaxPacketSize0 and
|
|
|
|
* then correct our initial guess.
|
|
|
|
*/
|
2009-02-11 22:11:36 +00:00
|
|
|
udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case USB_SPEED_LOW: /* fixed at 8 */
|
2009-02-11 22:11:36 +00:00
|
|
|
udev->ep0.desc.wMaxPacketSize = cpu_to_le16(8);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto fail;
|
|
|
|
}
|
2011-08-30 15:11:19 +00:00
|
|
|
|
|
|
|
if (udev->speed == USB_SPEED_WIRELESS)
|
|
|
|
speed = "variable speed Wireless";
|
|
|
|
else
|
|
|
|
speed = usb_speed_string(udev->speed);
|
|
|
|
|
2009-04-28 02:57:26 +00:00
|
|
|
if (udev->speed != USB_SPEED_SUPER)
|
|
|
|
dev_info(&udev->dev,
|
2011-08-30 15:11:19 +00:00
|
|
|
"%s %s USB device number %d using %s\n",
|
|
|
|
(udev->config) ? "reset" : "new", speed,
|
2011-02-22 14:53:41 +00:00
|
|
|
devnum, udev->bus->controller->driver->name);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Set up TT records, if needed */
|
|
|
|
if (hdev->tt) {
|
|
|
|
udev->tt = hdev->tt;
|
|
|
|
udev->ttport = hdev->ttport;
|
|
|
|
} else if (udev->speed != USB_SPEED_HIGH
|
|
|
|
&& hdev->speed == USB_SPEED_HIGH) {
|
2011-01-31 15:56:37 +00:00
|
|
|
if (!hub->tt.hub) {
|
|
|
|
dev_err(&udev->dev, "parent hub has no TT\n");
|
|
|
|
retval = -EINVAL;
|
|
|
|
goto fail;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
udev->tt = &hub->tt;
|
|
|
|
udev->ttport = port1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Why interleave GET_DESCRIPTOR and SET_ADDRESS this way?
|
|
|
|
* Because device hardware and firmware is sometimes buggy in
|
|
|
|
* this area, and this is how Linux has done it for ages.
|
|
|
|
* Change it cautiously.
|
|
|
|
*
|
|
|
|
* NOTE: If USE_NEW_SCHEME() is true we will start by issuing
|
|
|
|
* a 64-byte GET_DESCRIPTOR request. This is what Windows does,
|
|
|
|
* so it may help with some non-standards-compliant devices.
|
|
|
|
* Otherwise we start with SET_ADDRESS and then try to read the
|
|
|
|
* first 8 bytes of the device descriptor to get the ep0 maxpacket
|
|
|
|
* value.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) {
|
2009-04-28 02:57:26 +00:00
|
|
|
if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
struct usb_device_descriptor *buf;
|
|
|
|
int r = 0;
|
|
|
|
|
|
|
|
#define GET_DESCRIPTOR_BUFSIZE 64
|
|
|
|
buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);
|
|
|
|
if (!buf) {
|
|
|
|
retval = -ENOMEM;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2007-05-11 14:19:04 +00:00
|
|
|
/* Retry on all errors; some devices are flakey.
|
|
|
|
* 255 is for WUSB devices, we actually need to use
|
|
|
|
* 512 (WUSB1.0[4.8.1]).
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
for (j = 0; j < 3; ++j) {
|
|
|
|
buf->bMaxPacketSize0 = 0;
|
|
|
|
r = usb_control_msg(udev, usb_rcvaddr0pipe(),
|
|
|
|
USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
|
|
|
|
USB_DT_DEVICE << 8, 0,
|
|
|
|
buf, GET_DESCRIPTOR_BUFSIZE,
|
2008-10-10 14:24:45 +00:00
|
|
|
initial_descriptor_timeout);
|
2005-04-16 22:20:36 +00:00
|
|
|
switch (buf->bMaxPacketSize0) {
|
2006-08-26 02:35:30 +00:00
|
|
|
case 8: case 16: case 32: case 64: case 255:
|
2005-04-16 22:20:36 +00:00
|
|
|
if (buf->bDescriptorType ==
|
|
|
|
USB_DT_DEVICE) {
|
|
|
|
r = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* FALL THROUGH */
|
|
|
|
default:
|
|
|
|
if (r == 0)
|
|
|
|
r = -EPROTO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (r == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
udev->descriptor.bMaxPacketSize0 =
|
|
|
|
buf->bMaxPacketSize0;
|
|
|
|
kfree(buf);
|
|
|
|
|
2011-09-13 23:41:11 +00:00
|
|
|
retval = hub_port_reset(hub, port1, udev, delay, false);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (retval < 0) /* error or disconnect */
|
|
|
|
goto fail;
|
|
|
|
if (oldspeed != udev->speed) {
|
|
|
|
dev_dbg(&udev->dev,
|
|
|
|
"device reset changed speed!\n");
|
|
|
|
retval = -ENODEV;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
if (r) {
|
2008-12-15 07:32:01 +00:00
|
|
|
dev_err(&udev->dev,
|
|
|
|
"device descriptor read/64, error %d\n",
|
|
|
|
r);
|
2005-04-16 22:20:36 +00:00
|
|
|
retval = -EMSGSIZE;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#undef GET_DESCRIPTOR_BUFSIZE
|
|
|
|
}
|
|
|
|
|
2008-04-08 20:24:46 +00:00
|
|
|
/*
|
|
|
|
* If device is WUSB, we already assigned an
|
|
|
|
* unauthorized address in the Connect Ack sequence;
|
|
|
|
* authorization will assign the final address.
|
|
|
|
*/
|
2009-04-28 02:57:26 +00:00
|
|
|
if (udev->wusb == 0) {
|
2008-04-08 20:24:46 +00:00
|
|
|
for (j = 0; j < SET_ADDRESS_TRIES; ++j) {
|
|
|
|
retval = hub_set_address(udev, devnum);
|
|
|
|
if (retval >= 0)
|
|
|
|
break;
|
|
|
|
msleep(200);
|
|
|
|
}
|
|
|
|
if (retval < 0) {
|
|
|
|
dev_err(&udev->dev,
|
|
|
|
"device not accepting address %d, error %d\n",
|
|
|
|
devnum, retval);
|
|
|
|
goto fail;
|
|
|
|
}
|
2009-04-28 02:57:26 +00:00
|
|
|
if (udev->speed == USB_SPEED_SUPER) {
|
|
|
|
devnum = udev->devnum;
|
|
|
|
dev_info(&udev->dev,
|
2011-02-22 14:53:41 +00:00
|
|
|
"%s SuperSpeed USB device number %d using %s\n",
|
2009-04-28 02:57:26 +00:00
|
|
|
(udev->config) ? "reset" : "new",
|
2011-02-22 14:53:41 +00:00
|
|
|
devnum, udev->bus->controller->driver->name);
|
2009-04-28 02:57:26 +00:00
|
|
|
}
|
2008-04-08 20:24:46 +00:00
|
|
|
|
|
|
|
/* cope with hardware quirkiness:
|
|
|
|
* - let SET_ADDRESS settle, some device hardware wants it
|
|
|
|
* - read ep0 maxpacket even for high and low speed,
|
|
|
|
*/
|
|
|
|
msleep(10);
|
2009-04-28 02:57:26 +00:00
|
|
|
if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3))
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2008-04-08 20:24:46 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
retval = usb_get_device_descriptor(udev, 8);
|
|
|
|
if (retval < 8) {
|
2008-12-15 07:32:01 +00:00
|
|
|
dev_err(&udev->dev,
|
|
|
|
"device descriptor read/8, error %d\n",
|
|
|
|
retval);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (retval >= 0)
|
|
|
|
retval = -EMSGSIZE;
|
|
|
|
} else {
|
|
|
|
retval = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (retval)
|
|
|
|
goto fail;
|
|
|
|
|
2009-04-28 02:54:10 +00:00
|
|
|
if (udev->descriptor.bMaxPacketSize0 == 0xff ||
|
|
|
|
udev->speed == USB_SPEED_SUPER)
|
|
|
|
i = 512;
|
|
|
|
else
|
|
|
|
i = udev->descriptor.bMaxPacketSize0;
|
2011-08-23 10:12:03 +00:00
|
|
|
if (usb_endpoint_maxp(&udev->ep0.desc) != i) {
|
2010-10-14 19:25:21 +00:00
|
|
|
if (udev->speed == USB_SPEED_LOW ||
|
2005-04-16 22:20:36 +00:00
|
|
|
!(i == 8 || i == 16 || i == 32 || i == 64)) {
|
2010-10-14 19:25:21 +00:00
|
|
|
dev_err(&udev->dev, "Invalid ep0 maxpacket: %d\n", i);
|
2005-04-16 22:20:36 +00:00
|
|
|
retval = -EMSGSIZE;
|
|
|
|
goto fail;
|
|
|
|
}
|
2010-10-14 19:25:21 +00:00
|
|
|
if (udev->speed == USB_SPEED_FULL)
|
|
|
|
dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
|
|
|
|
else
|
|
|
|
dev_warn(&udev->dev, "Using ep0 maxpacket: %d\n", i);
|
2005-04-16 22:20:36 +00:00
|
|
|
udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
|
2008-04-08 20:24:46 +00:00
|
|
|
usb_ep0_reinit(udev);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
|
|
|
|
if (retval < (signed)sizeof(udev->descriptor)) {
|
2008-12-15 07:32:01 +00:00
|
|
|
dev_err(&udev->dev, "device descriptor read/all, error %d\n",
|
|
|
|
retval);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (retval >= 0)
|
|
|
|
retval = -ENOMSG;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2011-09-23 21:19:48 +00:00
|
|
|
if (udev->wusb == 0 && le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0201) {
|
|
|
|
retval = usb_get_bos_descriptor(udev);
|
|
|
|
if (!retval) {
|
|
|
|
if (udev->bos->ext_cap && (USB_LPM_SUPPORT &
|
|
|
|
le32_to_cpu(udev->bos->ext_cap->bmAttributes)))
|
|
|
|
udev->lpm_capable = 1;
|
|
|
|
}
|
|
|
|
}
|
2011-09-23 21:19:47 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
retval = 0;
|
2010-06-04 07:47:55 +00:00
|
|
|
/* notify HCD that we have a device connected and addressed */
|
|
|
|
if (hcd->driver->update_device)
|
|
|
|
hcd->driver->update_device(hcd, udev);
|
2005-04-16 22:20:36 +00:00
|
|
|
fail:
|
2007-07-30 21:08:43 +00:00
|
|
|
if (retval) {
|
2005-04-16 22:20:36 +00:00
|
|
|
hub_port_disable(hub, port1, 0);
|
2011-02-22 14:53:41 +00:00
|
|
|
update_devnum(udev, devnum); /* for disconnect processing */
|
2007-07-30 21:08:43 +00:00
|
|
|
}
|
2006-01-11 14:55:29 +00:00
|
|
|
mutex_unlock(&usb_address0_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
check_highspeed (struct usb_hub *hub, struct usb_device *udev, int port1)
|
|
|
|
{
|
|
|
|
struct usb_qualifier_descriptor *qual;
|
|
|
|
int status;
|
|
|
|
|
2006-12-07 04:33:17 +00:00
|
|
|
qual = kmalloc (sizeof *qual, GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (qual == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
status = usb_get_descriptor (udev, USB_DT_DEVICE_QUALIFIER, 0,
|
|
|
|
qual, sizeof *qual);
|
|
|
|
if (status == sizeof *qual) {
|
|
|
|
dev_info(&udev->dev, "not running at top speed; "
|
|
|
|
"connect to a high speed hub\n");
|
|
|
|
/* hub LEDs are probably harder to miss than syslog */
|
|
|
|
if (hub->has_indicators) {
|
|
|
|
hub->indicator[port1-1] = INDICATOR_GREEN_BLINK;
|
2006-11-22 14:57:56 +00:00
|
|
|
schedule_delayed_work (&hub->leds, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
2005-04-19 00:39:34 +00:00
|
|
|
kfree(qual);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned
|
|
|
|
hub_power_remaining (struct usb_hub *hub)
|
|
|
|
{
|
|
|
|
struct usb_device *hdev = hub->hdev;
|
|
|
|
int remaining;
|
2005-11-23 17:03:12 +00:00
|
|
|
int port1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-11-23 17:03:12 +00:00
|
|
|
if (!hub->limited_power)
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
2005-11-23 17:03:12 +00:00
|
|
|
remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;
|
|
|
|
for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
|
|
|
|
struct usb_device *udev = hdev->children[port1 - 1];
|
|
|
|
int delta;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!udev)
|
|
|
|
continue;
|
|
|
|
|
2005-11-23 17:03:12 +00:00
|
|
|
/* Unconfigured devices may not use more than 100mA,
|
|
|
|
* or 8mA for OTG ports */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (udev->actconfig)
|
2005-11-23 17:03:12 +00:00
|
|
|
delta = udev->actconfig->desc.bMaxPower * 2;
|
|
|
|
else if (port1 != udev->bus->otg_port || hdev->parent)
|
|
|
|
delta = 100;
|
2005-04-16 22:20:36 +00:00
|
|
|
else
|
2005-11-23 17:03:12 +00:00
|
|
|
delta = 8;
|
|
|
|
if (delta > hub->mA_per_port)
|
2008-12-15 07:32:01 +00:00
|
|
|
dev_warn(&udev->dev,
|
|
|
|
"%dmA is over %umA budget for port %d!\n",
|
|
|
|
delta, hub->mA_per_port, port1);
|
2005-04-16 22:20:36 +00:00
|
|
|
remaining -= delta;
|
|
|
|
}
|
|
|
|
if (remaining < 0) {
|
2005-11-23 17:03:12 +00:00
|
|
|
dev_warn(hub->intfdev, "%dmA over power budget!\n",
|
|
|
|
- remaining);
|
2005-04-16 22:20:36 +00:00
|
|
|
remaining = 0;
|
|
|
|
}
|
|
|
|
return remaining;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle physical or logical connection change events.
|
|
|
|
* This routine is called when:
|
|
|
|
* a port connection-change occurs;
|
|
|
|
* a port enable-change occurs (often caused by EMI);
|
2008-06-18 14:00:29 +00:00
|
|
|
* usb_reset_and_verify_device() encounters changed descriptors (as from
|
2005-04-16 22:20:36 +00:00
|
|
|
* a firmware download)
|
|
|
|
* caller already locked the hub
|
|
|
|
*/
|
|
|
|
static void hub_port_connect_change(struct usb_hub *hub, int port1,
|
|
|
|
u16 portstatus, u16 portchange)
|
|
|
|
{
|
|
|
|
struct usb_device *hdev = hub->hdev;
|
|
|
|
struct device *hub_dev = hub->intfdev;
|
2007-11-21 20:28:14 +00:00
|
|
|
struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
|
2008-04-28 15:06:28 +00:00
|
|
|
unsigned wHubCharacteristics =
|
|
|
|
le16_to_cpu(hub->descriptor->wHubCharacteristics);
|
2008-04-28 15:06:55 +00:00
|
|
|
struct usb_device *udev;
|
2005-04-16 22:20:36 +00:00
|
|
|
int status, i;
|
2008-04-28 15:06:28 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_dbg (hub_dev,
|
|
|
|
"port %d, status %04x, change %04x, %s\n",
|
2010-12-07 05:00:19 +00:00
|
|
|
port1, portstatus, portchange, portspeed(hub, portstatus));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (hub->has_indicators) {
|
|
|
|
set_port_led(hub, port1, HUB_LED_AUTO);
|
|
|
|
hub->indicator[port1-1] = INDICATOR_AUTO;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_USB_OTG
|
|
|
|
/* during HNP, don't repeat the debounce */
|
|
|
|
if (hdev->bus->is_b_host)
|
2008-04-28 15:06:28 +00:00
|
|
|
portchange &= ~(USB_PORT_STAT_C_CONNECTION |
|
|
|
|
USB_PORT_STAT_C_ENABLE);
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
2008-04-28 15:06:55 +00:00
|
|
|
/* Try to resuscitate an existing device */
|
|
|
|
udev = hdev->children[port1-1];
|
|
|
|
if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
|
|
|
|
udev->state != USB_STATE_NOTATTACHED) {
|
|
|
|
usb_lock_device(udev);
|
|
|
|
if (portstatus & USB_PORT_STAT_ENABLE) {
|
|
|
|
status = 0; /* Nothing to do */
|
|
|
|
|
|
|
|
#ifdef CONFIG_USB_SUSPEND
|
2008-09-22 18:43:08 +00:00
|
|
|
} else if (udev->state == USB_STATE_SUSPENDED &&
|
|
|
|
udev->persist_enabled) {
|
2008-04-28 15:06:55 +00:00
|
|
|
/* For a suspended device, treat this as a
|
|
|
|
* remote wakeup event.
|
|
|
|
*/
|
2010-01-08 17:56:30 +00:00
|
|
|
status = usb_remote_wakeup(udev);
|
2008-04-28 15:06:55 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
} else {
|
2008-09-22 18:43:08 +00:00
|
|
|
status = -ENODEV; /* Don't resuscitate */
|
2008-04-28 15:06:55 +00:00
|
|
|
}
|
|
|
|
usb_unlock_device(udev);
|
|
|
|
|
|
|
|
if (status == 0) {
|
|
|
|
clear_bit(port1, hub->change_bits);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-28 15:06:28 +00:00
|
|
|
/* Disconnect any existing devices under this port */
|
2008-04-28 15:06:55 +00:00
|
|
|
if (udev)
|
2008-04-28 15:06:28 +00:00
|
|
|
usb_disconnect(&hdev->children[port1-1]);
|
|
|
|
clear_bit(port1, hub->change_bits);
|
|
|
|
|
2009-10-27 19:20:13 +00:00
|
|
|
/* We can forget about a "removed" device when there's a physical
|
|
|
|
* disconnect or the connect status changes.
|
|
|
|
*/
|
|
|
|
if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
|
|
|
|
(portchange & USB_PORT_STAT_C_CONNECTION))
|
|
|
|
clear_bit(port1, hub->removed_bits);
|
|
|
|
|
2008-09-22 18:43:08 +00:00
|
|
|
if (portchange & (USB_PORT_STAT_C_CONNECTION |
|
|
|
|
USB_PORT_STAT_C_ENABLE)) {
|
|
|
|
status = hub_port_debounce(hub, port1);
|
|
|
|
if (status < 0) {
|
|
|
|
if (printk_ratelimit())
|
|
|
|
dev_err(hub_dev, "connect-debounce failed, "
|
|
|
|
"port %d disabled\n", port1);
|
|
|
|
portstatus &= ~USB_PORT_STAT_CONNECTION;
|
|
|
|
} else {
|
|
|
|
portstatus = status;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-27 19:20:13 +00:00
|
|
|
/* Return now if debouncing failed or nothing is connected or
|
|
|
|
* the device was "removed".
|
|
|
|
*/
|
|
|
|
if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
|
|
|
|
test_bit(port1, hub->removed_bits)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* maybe switch power back on (e.g. root hub was reset) */
|
2005-06-21 04:15:16 +00:00
|
|
|
if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
|
2011-04-27 10:07:43 +00:00
|
|
|
&& !port_is_power_on(hub, portstatus))
|
2005-04-16 22:20:36 +00:00
|
|
|
set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
|
2008-09-22 18:43:08 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (portstatus & USB_PORT_STAT_ENABLE)
|
|
|
|
goto done;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < SET_CONFIG_TRIES; i++) {
|
|
|
|
|
|
|
|
/* reallocate for each attempt, since references
|
|
|
|
* to the previous one can escape in various ways
|
|
|
|
*/
|
|
|
|
udev = usb_alloc_dev(hdev, hdev->bus, port1);
|
|
|
|
if (!udev) {
|
|
|
|
dev_err (hub_dev,
|
|
|
|
"couldn't allocate port %d usb_device\n",
|
|
|
|
port1);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
usb_set_device_state(udev, USB_STATE_POWERED);
|
2005-11-23 17:03:12 +00:00
|
|
|
udev->bus_mA = hub->mA_per_port;
|
2006-08-30 19:46:48 +00:00
|
|
|
udev->level = hdev->level + 1;
|
2008-04-08 20:24:46 +00:00
|
|
|
udev->wusb = hub_is_wusb(hub);
|
2005-11-23 17:03:12 +00:00
|
|
|
|
2010-12-07 05:00:19 +00:00
|
|
|
/* Only USB 3.0 devices are connected to SuperSpeed hubs. */
|
|
|
|
if (hub_is_superspeed(hub->hdev))
|
2009-04-28 02:54:26 +00:00
|
|
|
udev->speed = USB_SPEED_SUPER;
|
|
|
|
else
|
|
|
|
udev->speed = USB_SPEED_UNKNOWN;
|
|
|
|
|
2011-02-22 14:53:41 +00:00
|
|
|
choose_devnum(udev);
|
2010-10-14 14:22:51 +00:00
|
|
|
if (udev->devnum <= 0) {
|
|
|
|
status = -ENOTCONN; /* Don't retry */
|
|
|
|
goto loop;
|
2009-04-28 02:57:26 +00:00
|
|
|
}
|
|
|
|
|
2009-04-28 02:54:26 +00:00
|
|
|
/* reset (non-USB 3.0 devices) and get descriptor */
|
2005-04-16 22:20:36 +00:00
|
|
|
status = hub_port_init(hub, udev, port1, i);
|
|
|
|
if (status < 0)
|
|
|
|
goto loop;
|
|
|
|
|
2010-07-21 22:05:01 +00:00
|
|
|
usb_detect_quirks(udev);
|
|
|
|
if (udev->quirks & USB_QUIRK_DELAY_INIT)
|
|
|
|
msleep(1000);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* consecutive bus-powered hubs aren't reliable; they can
|
|
|
|
* violate the voltage drop budget. if the new child has
|
|
|
|
* a "powered" LED, users should notice we didn't enable it
|
|
|
|
* (without reading syslog), even without per-port LEDs
|
|
|
|
* on the parent.
|
|
|
|
*/
|
|
|
|
if (udev->descriptor.bDeviceClass == USB_CLASS_HUB
|
2005-11-23 17:03:12 +00:00
|
|
|
&& udev->bus_mA <= 100) {
|
2005-04-16 22:20:36 +00:00
|
|
|
u16 devstat;
|
|
|
|
|
|
|
|
status = usb_get_status(udev, USB_RECIP_DEVICE, 0,
|
|
|
|
&devstat);
|
2005-11-23 17:03:12 +00:00
|
|
|
if (status < 2) {
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_dbg(&udev->dev, "get status %d ?\n", status);
|
|
|
|
goto loop_disable;
|
|
|
|
}
|
2005-11-23 17:03:12 +00:00
|
|
|
le16_to_cpus(&devstat);
|
2005-04-16 22:20:36 +00:00
|
|
|
if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
|
|
|
|
dev_err(&udev->dev,
|
|
|
|
"can't connect bus-powered hub "
|
|
|
|
"to this port\n");
|
|
|
|
if (hub->has_indicators) {
|
|
|
|
hub->indicator[port1-1] =
|
|
|
|
INDICATOR_AMBER_BLINK;
|
2006-11-22 14:57:56 +00:00
|
|
|
schedule_delayed_work (&hub->leds, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
status = -ENOTCONN; /* Don't retry */
|
|
|
|
goto loop_disable;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check for devices running slower than they could */
|
|
|
|
if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200
|
|
|
|
&& udev->speed == USB_SPEED_FULL
|
|
|
|
&& highspeed_hubs != 0)
|
|
|
|
check_highspeed (hub, udev, port1);
|
|
|
|
|
|
|
|
/* Store the parent's children[] pointer. At this point
|
|
|
|
* udev becomes globally accessible, although presumably
|
|
|
|
* no one will look at it until hdev is unlocked.
|
|
|
|
*/
|
|
|
|
status = 0;
|
|
|
|
|
|
|
|
/* We mustn't add new devices if the parent hub has
|
|
|
|
* been disconnected; we would race with the
|
|
|
|
* recursively_mark_NOTATTACHED() routine.
|
|
|
|
*/
|
|
|
|
spin_lock_irq(&device_state_lock);
|
|
|
|
if (hdev->state == USB_STATE_NOTATTACHED)
|
|
|
|
status = -ENOTCONN;
|
|
|
|
else
|
|
|
|
hdev->children[port1-1] = udev;
|
|
|
|
spin_unlock_irq(&device_state_lock);
|
|
|
|
|
|
|
|
/* Run it through the hoops (find a driver, etc) */
|
|
|
|
if (!status) {
|
|
|
|
status = usb_new_device(udev);
|
|
|
|
if (status) {
|
|
|
|
spin_lock_irq(&device_state_lock);
|
|
|
|
hdev->children[port1-1] = NULL;
|
|
|
|
spin_unlock_irq(&device_state_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (status)
|
|
|
|
goto loop_disable;
|
|
|
|
|
|
|
|
status = hub_power_remaining(hub);
|
|
|
|
if (status)
|
2005-11-23 17:03:12 +00:00
|
|
|
dev_dbg(hub_dev, "%dmA power budget left\n", status);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
loop_disable:
|
|
|
|
hub_port_disable(hub, port1, 1);
|
|
|
|
loop:
|
2008-04-08 20:24:46 +00:00
|
|
|
usb_ep0_reinit(udev);
|
2011-02-22 14:53:41 +00:00
|
|
|
release_devnum(udev);
|
2010-01-10 09:15:03 +00:00
|
|
|
hub_free_dev(udev);
|
2005-04-16 22:20:36 +00:00
|
|
|
usb_put_dev(udev);
|
2007-05-26 04:31:07 +00:00
|
|
|
if ((status == -ENOTCONN) || (status == -ENOTSUPP))
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-05-20 20:58:29 +00:00
|
|
|
if (hub->hdev->parent ||
|
|
|
|
!hcd->driver->port_handed_over ||
|
|
|
|
!(hcd->driver->port_handed_over)(hcd, port1))
|
|
|
|
dev_err(hub_dev, "unable to enumerate USB device on port %d\n",
|
|
|
|
port1);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
done:
|
|
|
|
hub_port_disable(hub, port1, 1);
|
2007-11-21 20:28:14 +00:00
|
|
|
if (hcd->driver->relinquish_port && !hub->hdev->parent)
|
|
|
|
hcd->driver->relinquish_port(hcd, port1);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hub_events(void)
|
|
|
|
{
|
|
|
|
struct list_head *tmp;
|
|
|
|
struct usb_device *hdev;
|
|
|
|
struct usb_interface *intf;
|
|
|
|
struct usb_hub *hub;
|
|
|
|
struct device *hub_dev;
|
|
|
|
u16 hubstatus;
|
|
|
|
u16 hubchange;
|
|
|
|
u16 portstatus;
|
|
|
|
u16 portchange;
|
|
|
|
int i, ret;
|
|
|
|
int connect_change;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We restart the list every time to avoid a deadlock with
|
|
|
|
* deleting hubs downstream from this one. This should be
|
|
|
|
* safe since we delete the hub from the event list.
|
|
|
|
* Not the most efficient, but avoids deadlocks.
|
|
|
|
*/
|
|
|
|
while (1) {
|
|
|
|
|
|
|
|
/* Grab the first entry at the beginning of the list */
|
|
|
|
spin_lock_irq(&hub_event_lock);
|
|
|
|
if (list_empty(&hub_event_list)) {
|
|
|
|
spin_unlock_irq(&hub_event_lock);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = hub_event_list.next;
|
|
|
|
list_del_init(tmp);
|
|
|
|
|
|
|
|
hub = list_entry(tmp, struct usb_hub, event_list);
|
2007-05-04 15:55:11 +00:00
|
|
|
kref_get(&hub->kref);
|
|
|
|
spin_unlock_irq(&hub_event_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-04 15:55:11 +00:00
|
|
|
hdev = hub->hdev;
|
|
|
|
hub_dev = hub->intfdev;
|
|
|
|
intf = to_usb_interface(hub_dev);
|
2006-11-09 19:44:33 +00:00
|
|
|
dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
hdev->state, hub->descriptor
|
|
|
|
? hub->descriptor->bNbrPorts
|
|
|
|
: 0,
|
|
|
|
/* NOTE: expects max 15 ports... */
|
|
|
|
(u16) hub->change_bits[0],
|
2006-11-09 19:44:33 +00:00
|
|
|
(u16) hub->event_bits[0]);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Lock the device, then check to see if we were
|
|
|
|
* disconnected while waiting for the lock to succeed. */
|
2007-05-04 15:54:50 +00:00
|
|
|
usb_lock_device(hdev);
|
2007-05-04 15:55:11 +00:00
|
|
|
if (unlikely(hub->disconnected))
|
2010-01-08 17:57:28 +00:00
|
|
|
goto loop_disconnected;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* If the hub has died, clean up after it */
|
|
|
|
if (hdev->state == USB_STATE_NOTATTACHED) {
|
2006-06-01 17:37:24 +00:00
|
|
|
hub->error = -ENODEV;
|
2008-04-28 15:07:31 +00:00
|
|
|
hub_quiesce(hub, HUB_DISCONNECT);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
|
2006-11-09 19:44:33 +00:00
|
|
|
/* Autoresume */
|
|
|
|
ret = usb_autopm_get_interface(intf);
|
|
|
|
if (ret) {
|
|
|
|
dev_dbg(hub_dev, "Can't autoresume: %d\n", ret);
|
|
|
|
goto loop;
|
|
|
|
}
|
2006-07-02 02:11:02 +00:00
|
|
|
|
2006-11-09 19:44:33 +00:00
|
|
|
/* If this is an inactive hub, do nothing */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (hub->quiescing)
|
2006-11-09 19:44:33 +00:00
|
|
|
goto loop_autopm;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (hub->error) {
|
|
|
|
dev_dbg (hub_dev, "resetting for error %d\n",
|
|
|
|
hub->error);
|
|
|
|
|
2008-06-18 14:00:29 +00:00
|
|
|
ret = usb_reset_device(hdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ret) {
|
|
|
|
dev_dbg (hub_dev,
|
|
|
|
"error resetting hub: %d\n", ret);
|
2006-11-09 19:44:33 +00:00
|
|
|
goto loop_autopm;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
hub->nerrors = 0;
|
|
|
|
hub->error = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* deal with port status changes */
|
|
|
|
for (i = 1; i <= hub->descriptor->bNbrPorts; i++) {
|
|
|
|
if (test_bit(i, hub->busy_bits))
|
|
|
|
continue;
|
|
|
|
connect_change = test_bit(i, hub->change_bits);
|
|
|
|
if (!test_and_clear_bit(i, hub->event_bits) &&
|
2008-04-28 15:06:42 +00:00
|
|
|
!connect_change)
|
2005-04-16 22:20:36 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = hub_port_status(hub, i,
|
|
|
|
&portstatus, &portchange);
|
|
|
|
if (ret < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (portchange & USB_PORT_STAT_C_CONNECTION) {
|
|
|
|
clear_port_feature(hdev, i,
|
|
|
|
USB_PORT_FEAT_C_CONNECTION);
|
|
|
|
connect_change = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (portchange & USB_PORT_STAT_C_ENABLE) {
|
|
|
|
if (!connect_change)
|
|
|
|
dev_dbg (hub_dev,
|
|
|
|
"port %d enable change, "
|
|
|
|
"status %08x\n",
|
|
|
|
i, portstatus);
|
|
|
|
clear_port_feature(hdev, i,
|
|
|
|
USB_PORT_FEAT_C_ENABLE);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* EM interference sometimes causes badly
|
|
|
|
* shielded USB devices to be shutdown by
|
|
|
|
* the hub, this hack enables them again.
|
|
|
|
* Works at least with mouse driver.
|
|
|
|
*/
|
|
|
|
if (!(portstatus & USB_PORT_STAT_ENABLE)
|
|
|
|
&& !connect_change
|
|
|
|
&& hdev->children[i-1]) {
|
|
|
|
dev_err (hub_dev,
|
|
|
|
"port %i "
|
|
|
|
"disabled by hub (EMI?), "
|
|
|
|
"re-enabling...\n",
|
|
|
|
i);
|
|
|
|
connect_change = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (portchange & USB_PORT_STAT_C_SUSPEND) {
|
2008-04-28 15:06:55 +00:00
|
|
|
struct usb_device *udev;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
clear_port_feature(hdev, i,
|
|
|
|
USB_PORT_FEAT_C_SUSPEND);
|
2008-04-28 15:06:55 +00:00
|
|
|
udev = hdev->children[i-1];
|
|
|
|
if (udev) {
|
2010-01-08 16:18:38 +00:00
|
|
|
/* TRSMRCY = 10 msec */
|
|
|
|
msleep(10);
|
|
|
|
|
2008-04-28 15:06:55 +00:00
|
|
|
usb_lock_device(udev);
|
2010-01-08 17:56:30 +00:00
|
|
|
ret = usb_remote_wakeup(hdev->
|
2005-04-16 22:20:36 +00:00
|
|
|
children[i-1]);
|
2008-04-28 15:06:55 +00:00
|
|
|
usb_unlock_device(udev);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ret < 0)
|
|
|
|
connect_change = 1;
|
|
|
|
} else {
|
|
|
|
ret = -ENODEV;
|
|
|
|
hub_port_disable(hub, i, 1);
|
|
|
|
}
|
|
|
|
dev_dbg (hub_dev,
|
|
|
|
"resume on port %d, status %d\n",
|
|
|
|
i, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
|
2011-03-11 17:03:52 +00:00
|
|
|
u16 status = 0;
|
|
|
|
u16 unused;
|
|
|
|
|
|
|
|
dev_dbg(hub_dev, "over-current change on port "
|
|
|
|
"%d\n", i);
|
2005-04-16 22:20:36 +00:00
|
|
|
clear_port_feature(hdev, i,
|
|
|
|
USB_PORT_FEAT_C_OVER_CURRENT);
|
2011-03-11 17:03:52 +00:00
|
|
|
msleep(100); /* Cool down */
|
2008-09-22 18:44:26 +00:00
|
|
|
hub_power_on(hub, true);
|
2011-03-11 17:03:52 +00:00
|
|
|
hub_port_status(hub, i, &status, &unused);
|
|
|
|
if (status & USB_PORT_STAT_OVERCURRENT)
|
|
|
|
dev_err(hub_dev, "over-current "
|
|
|
|
"condition on port %d\n", i);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (portchange & USB_PORT_STAT_C_RESET) {
|
|
|
|
dev_dbg (hub_dev,
|
|
|
|
"reset change on port %d\n",
|
|
|
|
i);
|
|
|
|
clear_port_feature(hdev, i,
|
|
|
|
USB_PORT_FEAT_C_RESET);
|
|
|
|
}
|
2010-12-06 23:08:20 +00:00
|
|
|
if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
|
|
|
|
hub_is_superspeed(hub->hdev)) {
|
|
|
|
dev_dbg(hub_dev,
|
|
|
|
"warm reset change on port %d\n",
|
|
|
|
i);
|
|
|
|
clear_port_feature(hdev, i,
|
|
|
|
USB_PORT_FEAT_C_BH_PORT_RESET);
|
|
|
|
}
|
2001-09-17 07:00:00 +00:00
|
|
|
if (portchange & USB_PORT_STAT_C_LINK_STATE) {
|
|
|
|
clear_port_feature(hub->hdev, i,
|
|
|
|
USB_PORT_FEAT_C_PORT_LINK_STATE);
|
|
|
|
}
|
|
|
|
if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
|
|
|
|
dev_warn(hub_dev,
|
|
|
|
"config error on port %d\n",
|
|
|
|
i);
|
|
|
|
clear_port_feature(hub->hdev, i,
|
|
|
|
USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-04-27 10:07:54 +00:00
|
|
|
/* Warm reset a USB3 protocol port if it's in
|
|
|
|
* SS.Inactive state.
|
|
|
|
*/
|
|
|
|
if (hub_is_superspeed(hub->hdev) &&
|
|
|
|
(portstatus & USB_PORT_STAT_LINK_STATE)
|
|
|
|
== USB_SS_PORT_LS_SS_INACTIVE) {
|
|
|
|
dev_dbg(hub_dev, "warm reset port %d\n", i);
|
2011-09-13 23:41:11 +00:00
|
|
|
hub_port_reset(hub, i, NULL,
|
|
|
|
HUB_BH_RESET_TIME, true);
|
2011-04-27 10:07:54 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (connect_change)
|
|
|
|
hub_port_connect_change(hub, i,
|
|
|
|
portstatus, portchange);
|
|
|
|
} /* end for i */
|
|
|
|
|
|
|
|
/* deal with hub status changes */
|
|
|
|
if (test_and_clear_bit(0, hub->event_bits) == 0)
|
|
|
|
; /* do nothing */
|
|
|
|
else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
|
|
|
|
dev_err (hub_dev, "get_hub_status failed\n");
|
|
|
|
else {
|
|
|
|
if (hubchange & HUB_CHANGE_LOCAL_POWER) {
|
|
|
|
dev_dbg (hub_dev, "power change\n");
|
|
|
|
clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
|
2005-11-23 17:03:12 +00:00
|
|
|
if (hubstatus & HUB_STATUS_LOCAL_POWER)
|
|
|
|
/* FIXME: Is this always true? */
|
|
|
|
hub->limited_power = 1;
|
2007-09-13 16:08:51 +00:00
|
|
|
else
|
|
|
|
hub->limited_power = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (hubchange & HUB_CHANGE_OVERCURRENT) {
|
2011-03-11 17:03:52 +00:00
|
|
|
u16 status = 0;
|
|
|
|
u16 unused;
|
|
|
|
|
|
|
|
dev_dbg(hub_dev, "over-current change\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
|
2011-03-11 17:03:52 +00:00
|
|
|
msleep(500); /* Cool down */
|
2008-09-22 18:44:26 +00:00
|
|
|
hub_power_on(hub, true);
|
2011-03-11 17:03:52 +00:00
|
|
|
hub_hub_status(hub, &status, &unused);
|
|
|
|
if (status & HUB_STATUS_OVERCURRENT)
|
|
|
|
dev_err(hub_dev, "over-current "
|
|
|
|
"condition\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-07 18:01:37 +00:00
|
|
|
loop_autopm:
|
|
|
|
/* Balance the usb_autopm_get_interface() above */
|
|
|
|
usb_autopm_put_interface_no_suspend(intf);
|
|
|
|
loop:
|
|
|
|
/* Balance the usb_autopm_get_interface_no_resume() in
|
|
|
|
* kick_khubd() and allow autosuspend.
|
|
|
|
*/
|
|
|
|
usb_autopm_put_interface(intf);
|
2010-01-08 17:57:28 +00:00
|
|
|
loop_disconnected:
|
2005-04-16 22:20:36 +00:00
|
|
|
usb_unlock_device(hdev);
|
2007-05-04 15:55:11 +00:00
|
|
|
kref_put(&hub->kref, hub_release);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
} /* end while (1) */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hub_thread(void *__unused)
|
|
|
|
{
|
2008-03-03 20:15:36 +00:00
|
|
|
/* khubd needs to be freezable to avoid intefering with USB-PERSIST
|
|
|
|
* port handover. Otherwise it might see that a full-speed device
|
|
|
|
* was gone before the EHCI controller had handed its port over to
|
|
|
|
* the companion full-speed controller.
|
|
|
|
*/
|
2007-07-17 11:03:35 +00:00
|
|
|
set_freezable();
|
2008-03-03 20:15:36 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
do {
|
|
|
|
hub_events();
|
2007-10-18 10:04:45 +00:00
|
|
|
wait_event_freezable(khubd_wait,
|
2005-06-20 21:29:58 +00:00
|
|
|
!list_empty(&hub_event_list) ||
|
|
|
|
kthread_should_stop());
|
|
|
|
} while (!kthread_should_stop() || !list_empty(&hub_event_list));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-06-20 21:29:58 +00:00
|
|
|
pr_debug("%s: khubd exiting\n", usbcore_name);
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-01-10 14:34:53 +00:00
|
|
|
static const struct usb_device_id hub_id_table[] = {
|
2005-04-16 22:20:36 +00:00
|
|
|
{ .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
|
|
|
|
.bDeviceClass = USB_CLASS_HUB},
|
|
|
|
{ .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
|
|
|
|
.bInterfaceClass = USB_CLASS_HUB},
|
|
|
|
{ } /* Terminating entry */
|
|
|
|
};
|
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE (usb, hub_id_table);
|
|
|
|
|
|
|
|
static struct usb_driver hub_driver = {
|
|
|
|
.name = "hub",
|
|
|
|
.probe = hub_probe,
|
|
|
|
.disconnect = hub_disconnect,
|
|
|
|
.suspend = hub_suspend,
|
|
|
|
.resume = hub_resume,
|
2007-05-30 19:38:16 +00:00
|
|
|
.reset_resume = hub_reset_resume,
|
2006-06-01 17:37:24 +00:00
|
|
|
.pre_reset = hub_pre_reset,
|
|
|
|
.post_reset = hub_post_reset,
|
2010-06-01 21:04:41 +00:00
|
|
|
.unlocked_ioctl = hub_ioctl,
|
2005-04-16 22:20:36 +00:00
|
|
|
.id_table = hub_id_table,
|
2006-11-09 19:44:33 +00:00
|
|
|
.supports_autosuspend = 1,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
int usb_hub_init(void)
|
|
|
|
{
|
|
|
|
if (usb_register(&hub_driver) < 0) {
|
|
|
|
printk(KERN_ERR "%s: can't register hub driver\n",
|
|
|
|
usbcore_name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2005-06-20 21:29:58 +00:00
|
|
|
khubd_task = kthread_run(hub_thread, NULL, "khubd");
|
|
|
|
if (!IS_ERR(khubd_task))
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Fall through if kernel_thread failed */
|
|
|
|
usb_deregister(&hub_driver);
|
|
|
|
printk(KERN_ERR "%s: can't start khubd\n", usbcore_name);
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void usb_hub_cleanup(void)
|
|
|
|
{
|
2005-06-20 21:29:58 +00:00
|
|
|
kthread_stop(khubd_task);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Hub resources are freed for us by usb_deregister. It calls
|
|
|
|
* usb_driver_purge on every device which in turn calls that
|
|
|
|
* devices disconnect function if it is using this driver.
|
|
|
|
* The hub_disconnect function takes care of releasing the
|
|
|
|
* individual hub resources. -greg
|
|
|
|
*/
|
|
|
|
usb_deregister(&hub_driver);
|
|
|
|
} /* usb_hub_cleanup() */
|
|
|
|
|
2008-03-03 20:16:04 +00:00
|
|
|
static int descriptors_changed(struct usb_device *udev,
|
|
|
|
struct usb_device_descriptor *old_device_descriptor)
|
|
|
|
{
|
|
|
|
int changed = 0;
|
|
|
|
unsigned index;
|
|
|
|
unsigned serial_len = 0;
|
|
|
|
unsigned len;
|
|
|
|
unsigned old_length;
|
|
|
|
int length;
|
|
|
|
char *buf;
|
|
|
|
|
|
|
|
if (memcmp(&udev->descriptor, old_device_descriptor,
|
|
|
|
sizeof(*old_device_descriptor)) != 0)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* Since the idVendor, idProduct, and bcdDevice values in the
|
|
|
|
* device descriptor haven't changed, we will assume the
|
|
|
|
* Manufacturer and Product strings haven't changed either.
|
|
|
|
* But the SerialNumber string could be different (e.g., a
|
|
|
|
* different flash card of the same brand).
|
|
|
|
*/
|
|
|
|
if (udev->serial)
|
|
|
|
serial_len = strlen(udev->serial) + 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-03 20:16:04 +00:00
|
|
|
len = serial_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
|
2008-03-03 20:16:04 +00:00
|
|
|
old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
|
|
|
|
len = max(len, old_length);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-03-03 20:16:04 +00:00
|
|
|
|
2008-01-10 09:31:48 +00:00
|
|
|
buf = kmalloc(len, GFP_NOIO);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (buf == NULL) {
|
|
|
|
dev_err(&udev->dev, "no mem to re-read configs after reset\n");
|
|
|
|
/* assume the worst */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
|
2008-03-03 20:16:04 +00:00
|
|
|
old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
|
2005-04-16 22:20:36 +00:00
|
|
|
length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf,
|
|
|
|
old_length);
|
2008-03-03 20:16:04 +00:00
|
|
|
if (length != old_length) {
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_dbg(&udev->dev, "config index %d, error %d\n",
|
|
|
|
index, length);
|
2008-03-03 20:16:04 +00:00
|
|
|
changed = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (memcmp (buf, udev->rawdescriptors[index], old_length)
|
|
|
|
!= 0) {
|
|
|
|
dev_dbg(&udev->dev, "config index %d changed (#%d)\n",
|
2008-03-03 20:16:04 +00:00
|
|
|
index,
|
|
|
|
((struct usb_config_descriptor *) buf)->
|
|
|
|
bConfigurationValue);
|
|
|
|
changed = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-03-03 20:16:04 +00:00
|
|
|
|
|
|
|
if (!changed && serial_len) {
|
|
|
|
length = usb_string(udev, udev->descriptor.iSerialNumber,
|
|
|
|
buf, serial_len);
|
|
|
|
if (length + 1 != serial_len) {
|
|
|
|
dev_dbg(&udev->dev, "serial string error %d\n",
|
|
|
|
length);
|
|
|
|
changed = 1;
|
|
|
|
} else if (memcmp(buf, udev->serial, length) != 0) {
|
|
|
|
dev_dbg(&udev->dev, "serial string changed\n");
|
|
|
|
changed = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(buf);
|
2008-03-03 20:16:04 +00:00
|
|
|
return changed;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-06-18 14:00:29 +00:00
|
|
|
* usb_reset_and_verify_device - perform a USB port reset to reinitialize a device
|
2005-04-16 22:20:36 +00:00
|
|
|
* @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
|
|
|
|
*
|
2006-06-01 17:33:42 +00:00
|
|
|
* WARNING - don't use this routine to reset a composite device
|
|
|
|
* (one with multiple interfaces owned by separate drivers)!
|
2008-06-18 14:00:29 +00:00
|
|
|
* Use usb_reset_device() instead.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Do a port reset, reassign the device's address, and establish its
|
|
|
|
* former operating configuration. If the reset fails, or the device's
|
|
|
|
* descriptors change from their values before the reset, or the original
|
|
|
|
* configuration and altsettings cannot be restored, a flag will be set
|
|
|
|
* telling khubd to pretend the device has been disconnected and then
|
|
|
|
* re-connected. All drivers will be unbound, and the device will be
|
|
|
|
* re-enumerated and probed all over again.
|
|
|
|
*
|
|
|
|
* Returns 0 if the reset succeeded, -ENODEV if the device has been
|
|
|
|
* flagged for logical disconnection, or some other negative error code
|
|
|
|
* if the reset wasn't even attempted.
|
|
|
|
*
|
|
|
|
* The caller must own the device lock. For example, it's safe to use
|
|
|
|
* this from a driver probe() routine after downloading new firmware.
|
|
|
|
* For calls that might not occur during probe(), drivers should lock
|
|
|
|
* the device using usb_lock_device_for_reset().
|
2007-05-04 15:53:03 +00:00
|
|
|
*
|
|
|
|
* Locking exception: This routine may also be called from within an
|
|
|
|
* autoresume handler. Such usage won't conflict with other tasks
|
|
|
|
* holding the device lock because these tasks should always call
|
|
|
|
* usb_autopm_resume_device(), thereby preventing any unwanted autoresume.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-06-18 14:00:29 +00:00
|
|
|
static int usb_reset_and_verify_device(struct usb_device *udev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct usb_device *parent_hdev = udev->parent;
|
|
|
|
struct usb_hub *parent_hub;
|
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 17:44:36 +00:00
|
|
|
struct usb_hcd *hcd = bus_to_hcd(udev->bus);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct usb_device_descriptor descriptor = udev->descriptor;
|
2005-11-23 17:09:52 +00:00
|
|
|
int i, ret = 0;
|
|
|
|
int port1 = udev->portnum;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (udev->state == USB_STATE_NOTATTACHED ||
|
|
|
|
udev->state == USB_STATE_SUSPENDED) {
|
|
|
|
dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
|
|
|
|
udev->state);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!parent_hdev) {
|
2010-08-29 16:17:14 +00:00
|
|
|
/* this requires hcd-specific logic; see ohci_restart() */
|
2008-03-04 00:08:34 +00:00
|
|
|
dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EISDIR;
|
|
|
|
}
|
|
|
|
parent_hub = hdev_to_hub(parent_hdev);
|
|
|
|
|
|
|
|
set_bit(port1, parent_hub->busy_bits);
|
|
|
|
for (i = 0; i < SET_CONFIG_TRIES; ++i) {
|
|
|
|
|
|
|
|
/* ep0 maxpacket size may change; let the HCD know about it.
|
|
|
|
* Other endpoints will be handled by re-enumeration. */
|
2008-04-08 20:24:46 +00:00
|
|
|
usb_ep0_reinit(udev);
|
2005-04-16 22:20:36 +00:00
|
|
|
ret = hub_port_init(parent_hub, udev, port1, i);
|
2007-05-04 15:55:54 +00:00
|
|
|
if (ret >= 0 || ret == -ENOTCONN || ret == -ENODEV)
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
clear_bit(port1, parent_hub->busy_bits);
|
2006-08-11 20:52:39 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto re_enumerate;
|
|
|
|
|
|
|
|
/* Device might have changed firmware (DFU or similar) */
|
2008-03-03 20:16:04 +00:00
|
|
|
if (descriptors_changed(udev, &descriptor)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
dev_info(&udev->dev, "device firmware changed\n");
|
|
|
|
udev->descriptor = descriptor; /* for disconnect() calls */
|
|
|
|
goto re_enumerate;
|
|
|
|
}
|
2009-02-26 15:21:02 +00:00
|
|
|
|
|
|
|
/* Restore the device's previous configuration */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!udev->actconfig)
|
|
|
|
goto done;
|
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 17:44:36 +00:00
|
|
|
|
2010-10-15 15:55:24 +00:00
|
|
|
mutex_lock(hcd->bandwidth_mutex);
|
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 17:44:36 +00:00
|
|
|
ret = usb_hcd_alloc_bandwidth(udev, udev->actconfig, NULL, NULL);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_warn(&udev->dev,
|
|
|
|
"Busted HC? Not enough HCD resources for "
|
|
|
|
"old configuration.\n");
|
2010-10-15 15:55:24 +00:00
|
|
|
mutex_unlock(hcd->bandwidth_mutex);
|
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 17:44:36 +00:00
|
|
|
goto re_enumerate;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
|
|
|
|
USB_REQ_SET_CONFIGURATION, 0,
|
|
|
|
udev->actconfig->desc.bConfigurationValue, 0,
|
|
|
|
NULL, 0, USB_CTRL_SET_TIMEOUT);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(&udev->dev,
|
|
|
|
"can't restore configuration #%d (error=%d)\n",
|
|
|
|
udev->actconfig->desc.bConfigurationValue, ret);
|
2010-10-15 15:55:24 +00:00
|
|
|
mutex_unlock(hcd->bandwidth_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto re_enumerate;
|
|
|
|
}
|
2010-10-15 15:55:24 +00:00
|
|
|
mutex_unlock(hcd->bandwidth_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
usb_set_device_state(udev, USB_STATE_CONFIGURED);
|
|
|
|
|
2009-02-26 15:21:02 +00:00
|
|
|
/* Put interfaces back into the same altsettings as before.
|
|
|
|
* Don't bother to send the Set-Interface request for interfaces
|
|
|
|
* that were already in altsetting 0; besides being unnecessary,
|
|
|
|
* many devices can't handle it. Instead just reset the host-side
|
|
|
|
* endpoint state.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
|
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 17:44:36 +00:00
|
|
|
struct usb_host_config *config = udev->actconfig;
|
|
|
|
struct usb_interface *intf = config->interface[i];
|
2005-04-16 22:20:36 +00:00
|
|
|
struct usb_interface_descriptor *desc;
|
|
|
|
|
|
|
|
desc = &intf->cur_altsetting->desc;
|
2009-02-26 15:21:02 +00:00
|
|
|
if (desc->bAlternateSetting == 0) {
|
|
|
|
usb_disable_interface(udev, intf, true);
|
|
|
|
usb_enable_interface(udev, intf, true);
|
|
|
|
ret = 0;
|
|
|
|
} else {
|
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 18:16:51 +00:00
|
|
|
/* Let the bandwidth allocation function know that this
|
|
|
|
* device has been reset, and it will have to use
|
|
|
|
* alternate setting 0 as the current alternate setting.
|
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 17:44:36 +00:00
|
|
|
*/
|
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 18:16:51 +00:00
|
|
|
intf->resetting_device = 1;
|
2009-02-26 15:21:02 +00:00
|
|
|
ret = usb_set_interface(udev, desc->bInterfaceNumber,
|
|
|
|
desc->bAlternateSetting);
|
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 18:16:51 +00:00
|
|
|
intf->resetting_device = 0;
|
2009-02-26 15:21:02 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(&udev->dev, "failed to restore interface %d "
|
|
|
|
"altsetting %d (error=%d)\n",
|
|
|
|
desc->bInterfaceNumber,
|
|
|
|
desc->bAlternateSetting,
|
|
|
|
ret);
|
|
|
|
goto re_enumerate;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
re_enumerate:
|
|
|
|
hub_port_logical_disconnect(parent_hub, port1);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
2006-06-01 17:33:42 +00:00
|
|
|
|
|
|
|
/**
|
2008-06-18 14:00:29 +00:00
|
|
|
* usb_reset_device - warn interface drivers and perform a USB port reset
|
2006-06-01 17:33:42 +00:00
|
|
|
* @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
|
|
|
|
*
|
|
|
|
* Warns all drivers bound to registered interfaces (using their pre_reset
|
|
|
|
* method), performs the port reset, and then lets the drivers know that
|
|
|
|
* the reset is over (using their post_reset method).
|
|
|
|
*
|
2008-06-18 14:00:29 +00:00
|
|
|
* Return value is the same as for usb_reset_and_verify_device().
|
2006-06-01 17:33:42 +00:00
|
|
|
*
|
|
|
|
* The caller must own the device lock. For example, it's safe to use
|
|
|
|
* this from a driver probe() routine after downloading new firmware.
|
|
|
|
* For calls that might not occur during probe(), drivers should lock
|
|
|
|
* the device using usb_lock_device_for_reset().
|
2008-06-23 20:00:40 +00:00
|
|
|
*
|
|
|
|
* If an interface is currently being probed or disconnected, we assume
|
|
|
|
* its driver knows how to handle resets. For all other interfaces,
|
|
|
|
* if the driver doesn't have pre_reset and post_reset methods then
|
|
|
|
* we attempt to unbind it and rebind afterward.
|
2006-06-01 17:33:42 +00:00
|
|
|
*/
|
2008-06-18 14:00:29 +00:00
|
|
|
int usb_reset_device(struct usb_device *udev)
|
2006-06-01 17:33:42 +00:00
|
|
|
{
|
|
|
|
int ret;
|
2007-12-03 20:44:29 +00:00
|
|
|
int i;
|
2006-06-01 17:33:42 +00:00
|
|
|
struct usb_host_config *config = udev->actconfig;
|
|
|
|
|
|
|
|
if (udev->state == USB_STATE_NOTATTACHED ||
|
|
|
|
udev->state == USB_STATE_SUSPENDED) {
|
|
|
|
dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
|
|
|
|
udev->state);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2006-08-30 19:47:02 +00:00
|
|
|
/* Prevent autosuspend during the reset */
|
2006-11-20 16:38:46 +00:00
|
|
|
usb_autoresume_device(udev);
|
2006-08-30 19:47:02 +00:00
|
|
|
|
2006-06-01 17:33:42 +00:00
|
|
|
if (config) {
|
|
|
|
for (i = 0; i < config->desc.bNumInterfaces; ++i) {
|
2007-12-03 20:44:29 +00:00
|
|
|
struct usb_interface *cintf = config->interface[i];
|
|
|
|
struct usb_driver *drv;
|
2008-06-23 20:00:40 +00:00
|
|
|
int unbind = 0;
|
2007-12-03 20:44:29 +00:00
|
|
|
|
|
|
|
if (cintf->dev.driver) {
|
2006-06-01 17:33:42 +00:00
|
|
|
drv = to_usb_driver(cintf->dev.driver);
|
2008-06-23 20:00:40 +00:00
|
|
|
if (drv->pre_reset && drv->post_reset)
|
|
|
|
unbind = (drv->pre_reset)(cintf);
|
|
|
|
else if (cintf->condition ==
|
|
|
|
USB_INTERFACE_BOUND)
|
|
|
|
unbind = 1;
|
|
|
|
if (unbind)
|
|
|
|
usb_forced_unbind_intf(cintf);
|
2006-06-01 17:33:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-06-18 14:00:29 +00:00
|
|
|
ret = usb_reset_and_verify_device(udev);
|
2006-06-01 17:33:42 +00:00
|
|
|
|
|
|
|
if (config) {
|
|
|
|
for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
|
2007-12-03 20:44:29 +00:00
|
|
|
struct usb_interface *cintf = config->interface[i];
|
|
|
|
struct usb_driver *drv;
|
2008-06-23 20:00:40 +00:00
|
|
|
int rebind = cintf->needs_binding;
|
2007-12-03 20:44:29 +00:00
|
|
|
|
2008-06-23 20:00:40 +00:00
|
|
|
if (!rebind && cintf->dev.driver) {
|
2006-06-01 17:33:42 +00:00
|
|
|
drv = to_usb_driver(cintf->dev.driver);
|
|
|
|
if (drv->post_reset)
|
2008-06-23 20:00:40 +00:00
|
|
|
rebind = (drv->post_reset)(cintf);
|
|
|
|
else if (cintf->condition ==
|
|
|
|
USB_INTERFACE_BOUND)
|
|
|
|
rebind = 1;
|
2006-06-01 17:33:42 +00:00
|
|
|
}
|
2008-10-21 19:40:03 +00:00
|
|
|
if (ret == 0 && rebind)
|
2008-06-23 20:00:40 +00:00
|
|
|
usb_rebind_intf(cintf);
|
2006-06-01 17:33:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-20 16:38:46 +00:00
|
|
|
usb_autosuspend_device(udev);
|
2006-06-01 17:33:42 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2008-06-18 14:00:29 +00:00
|
|
|
EXPORT_SYMBOL_GPL(usb_reset_device);
|
2008-11-13 18:31:35 +00:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* usb_queue_reset_device - Reset a USB device from an atomic context
|
|
|
|
* @iface: USB interface belonging to the device to reset
|
|
|
|
*
|
|
|
|
* This function can be used to reset a USB device from an atomic
|
|
|
|
* context, where usb_reset_device() won't work (as it blocks).
|
|
|
|
*
|
|
|
|
* Doing a reset via this method is functionally equivalent to calling
|
|
|
|
* usb_reset_device(), except for the fact that it is delayed to a
|
|
|
|
* workqueue. This means that any drivers bound to other interfaces
|
|
|
|
* might be unbound, as well as users from usbfs in user space.
|
|
|
|
*
|
|
|
|
* Corner cases:
|
|
|
|
*
|
|
|
|
* - Scheduling two resets at the same time from two different drivers
|
|
|
|
* attached to two different interfaces of the same device is
|
|
|
|
* possible; depending on how the driver attached to each interface
|
|
|
|
* handles ->pre_reset(), the second reset might happen or not.
|
|
|
|
*
|
|
|
|
* - If a driver is unbound and it had a pending reset, the reset will
|
|
|
|
* be cancelled.
|
|
|
|
*
|
|
|
|
* - This function can be called during .probe() or .disconnect()
|
|
|
|
* times. On return from .disconnect(), any pending resets will be
|
|
|
|
* cancelled.
|
|
|
|
*
|
|
|
|
* There is no no need to lock/unlock the @reset_ws as schedule_work()
|
|
|
|
* does its own.
|
|
|
|
*
|
|
|
|
* NOTE: We don't do any reference count tracking because it is not
|
|
|
|
* needed. The lifecycle of the work_struct is tied to the
|
|
|
|
* usb_interface. Before destroying the interface we cancel the
|
|
|
|
* work_struct, so the fact that work_struct is queued and or
|
|
|
|
* running means the interface (and thus, the device) exist and
|
|
|
|
* are referenced.
|
|
|
|
*/
|
|
|
|
void usb_queue_reset_device(struct usb_interface *iface)
|
|
|
|
{
|
|
|
|
schedule_work(&iface->reset_ws);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(usb_queue_reset_device);
|