hub.c 165.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * 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>
22
#include <linux/usb/hcd.h>
23
#include <linux/usb/otg.h>
24
#include <linux/usb/quirks.h>
25
#include <linux/workqueue.h>
26
#include <linux/mutex.h>
27
#include <linux/random.h>
28
#include <linux/pm_qos.h>
L
Linus Torvalds 已提交
29 30 31 32

#include <asm/uaccess.h>
#include <asm/byteorder.h>

33
#include "hub.h"
34
#include "otg_whitelist.h"
L
Linus Torvalds 已提交
35

36 37 38
#define USB_VENDOR_GENESYS_LOGIC		0x05e3
#define HUB_QUIRK_CHECK_PORT_AUTOSUSPEND	0x01

39
/* Protect struct usb_device->state and ->children members
40
 * Note: Both are also protected by ->dev.sem, except that ->state can
L
Linus Torvalds 已提交
41 42 43
 * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */
static DEFINE_SPINLOCK(device_state_lock);

44 45 46
/* workqueue to process hub events */
static struct workqueue_struct *hub_wq;
static void hub_event(struct work_struct *work);
L
Linus Torvalds 已提交
47

48 49 50
/* synchronize hub-port add/remove and peering operations */
DEFINE_MUTEX(usb_port_peer_mutex);

L
Linus Torvalds 已提交
51
/* cycle leds on hubs that aren't blinking for attention */
52
static bool blinkenlights;
53 54
module_param(blinkenlights, bool, S_IRUGO);
MODULE_PARM_DESC(blinkenlights, "true to cycle leds on hubs");
L
Linus Torvalds 已提交
55

56 57 58 59 60 61 62
/*
 * 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);
63 64 65
MODULE_PARM_DESC(initial_descriptor_timeout,
		"initial 64-byte descriptor request timeout in milliseconds "
		"(default 5000 - 5.0 seconds)");
66

L
Linus Torvalds 已提交
67 68 69 70 71 72 73 74 75 76 77 78 79 80
/*
 * 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.
 */
81
static bool old_scheme_first;
L
Linus Torvalds 已提交
82 83 84 85
module_param(old_scheme_first, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(old_scheme_first,
		 "start with the old device initialization scheme");

86
static bool use_both_schemes = 1;
L
Linus Torvalds 已提交
87 88 89 90 91
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");

92 93 94 95 96 97
/* 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);

98
#define HUB_DEBOUNCE_TIMEOUT	2000
99 100 101
#define HUB_DEBOUNCE_STEP	  25
#define HUB_DEBOUNCE_STABLE	 100

102
static void hub_release(struct kref *kref);
103 104
static int usb_reset_and_verify_device(struct usb_device *udev);

105
static inline char *portspeed(struct usb_hub *hub, int portstatus)
L
Linus Torvalds 已提交
106
{
O
Oliver Neukum 已提交
107 108
	if (hub_is_superspeedplus(hub->hdev))
		return "10.0 Gb/s";
109 110
	if (hub_is_superspeed(hub->hdev))
		return "5.0 Gb/s";
111
	if (portstatus & USB_PORT_STAT_HIGH_SPEED)
112
		return "480 Mb/s";
113
	else if (portstatus & USB_PORT_STAT_LOW_SPEED)
L
Linus Torvalds 已提交
114 115 116 117 118 119
		return "1.5 Mb/s";
	else
		return "12 Mb/s";
}

/* Note that hdev or one of its children must be locked! */
120
struct usb_hub *usb_hub_to_struct_hub(struct usb_device *hdev)
L
Linus Torvalds 已提交
121
{
122
	if (!hdev || !hdev->actconfig || !hdev->maxchild)
123
		return NULL;
L
Linus Torvalds 已提交
124 125 126
	return usb_get_intfdata(hdev->actconfig->interface[0]);
}

127
int usb_device_supports_lpm(struct usb_device *udev)
128
{
129 130 131 132
	/* Some devices have trouble with LPM */
	if (udev->quirks & USB_QUIRK_NO_LPM)
		return 0;

133 134 135
	/* USB 2.1 (and greater) devices indicate LPM support through
	 * their USB 2.0 Extended Capabilities BOS descriptor.
	 */
136
	if (udev->speed == USB_SPEED_HIGH || udev->speed == USB_SPEED_FULL) {
137 138 139 140 141 142
		if (udev->bos->ext_cap &&
			(USB_LPM_SUPPORT &
			 le32_to_cpu(udev->bos->ext_cap->bmAttributes)))
			return 1;
		return 0;
	}
143

144 145 146 147
	/*
	 * According to the USB 3.0 spec, all USB 3.0 devices must support LPM.
	 * However, there are some that don't, and they set the U1/U2 exit
	 * latencies to zero.
148 149
	 */
	if (!udev->bos->ss_cap) {
150
		dev_info(&udev->dev, "No LPM exit latency info found, disabling LPM.\n");
151 152 153
		return 0;
	}

154 155 156 157 158 159
	if (udev->bos->ss_cap->bU1devExitLat == 0 &&
			udev->bos->ss_cap->bU2DevExitLat == 0) {
		if (udev->parent)
			dev_info(&udev->dev, "LPM exit latency is zeroed, disabling LPM.\n");
		else
			dev_info(&udev->dev, "We don't know the algorithms for LPM for this host, disabling LPM.\n");
160 161 162
		return 0;
	}

163 164
	if (!udev->parent || udev->parent->lpm_capable)
		return 1;
165 166 167
	return 0;
}

168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
/*
 * Set the Maximum Exit Latency (MEL) for the host to initiate a transition from
 * either U1 or U2.
 */
static void usb_set_lpm_mel(struct usb_device *udev,
		struct usb3_lpm_parameters *udev_lpm_params,
		unsigned int udev_exit_latency,
		struct usb_hub *hub,
		struct usb3_lpm_parameters *hub_lpm_params,
		unsigned int hub_exit_latency)
{
	unsigned int total_mel;
	unsigned int device_mel;
	unsigned int hub_mel;

	/*
	 * Calculate the time it takes to transition all links from the roothub
	 * to the parent hub into U0.  The parent hub must then decode the
	 * packet (hub header decode latency) to figure out which port it was
	 * bound for.
	 *
	 * The Hub Header decode latency is expressed in 0.1us intervals (0x1
	 * means 0.1us).  Multiply that by 100 to get nanoseconds.
	 */
	total_mel = hub_lpm_params->mel +
		(hub->descriptor->u.ss.bHubHdrDecLat * 100);

	/*
	 * How long will it take to transition the downstream hub's port into
	 * U0?  The greater of either the hub exit latency or the device exit
	 * latency.
	 *
	 * The BOS U1/U2 exit latencies are expressed in 1us intervals.
	 * Multiply that by 1000 to get nanoseconds.
	 */
	device_mel = udev_exit_latency * 1000;
	hub_mel = hub_exit_latency * 1000;
	if (device_mel > hub_mel)
		total_mel += device_mel;
	else
		total_mel += hub_mel;

	udev_lpm_params->mel = total_mel;
}

/*
 * Set the maximum Device to Host Exit Latency (PEL) for the device to initiate
 * a transition from either U1 or U2.
 */
static void usb_set_lpm_pel(struct usb_device *udev,
		struct usb3_lpm_parameters *udev_lpm_params,
		unsigned int udev_exit_latency,
		struct usb_hub *hub,
		struct usb3_lpm_parameters *hub_lpm_params,
		unsigned int hub_exit_latency,
		unsigned int port_to_port_exit_latency)
{
	unsigned int first_link_pel;
	unsigned int hub_pel;

	/*
	 * First, the device sends an LFPS to transition the link between the
	 * device and the parent hub into U0.  The exit latency is the bigger of
	 * the device exit latency or the hub exit latency.
	 */
	if (udev_exit_latency > hub_exit_latency)
		first_link_pel = udev_exit_latency * 1000;
	else
		first_link_pel = hub_exit_latency * 1000;

	/*
	 * When the hub starts to receive the LFPS, there is a slight delay for
	 * it to figure out that one of the ports is sending an LFPS.  Then it
	 * will forward the LFPS to its upstream link.  The exit latency is the
	 * delay, plus the PEL that we calculated for this hub.
	 */
	hub_pel = port_to_port_exit_latency * 1000 + hub_lpm_params->pel;

	/*
	 * According to figure C-7 in the USB 3.0 spec, the PEL for this device
	 * is the greater of the two exit latencies.
	 */
	if (first_link_pel > hub_pel)
		udev_lpm_params->pel = first_link_pel;
	else
		udev_lpm_params->pel = hub_pel;
}

/*
 * Set the System Exit Latency (SEL) to indicate the total worst-case time from
 * when a device initiates a transition to U0, until when it will receive the
 * first packet from the host controller.
 *
 * Section C.1.5.1 describes the four components to this:
 *  - t1: device PEL
 *  - t2: time for the ERDY to make it from the device to the host.
 *  - t3: a host-specific delay to process the ERDY.
 *  - t4: time for the packet to make it from the host to the device.
 *
 * t3 is specific to both the xHCI host and the platform the host is integrated
 * into.  The Intel HW folks have said it's negligible, FIXME if a different
 * vendor says otherwise.
 */
static void usb_set_lpm_sel(struct usb_device *udev,
		struct usb3_lpm_parameters *udev_lpm_params)
{
	struct usb_device *parent;
	unsigned int num_hubs;
	unsigned int total_sel;

	/* t1 = device PEL */
	total_sel = udev_lpm_params->pel;
	/* How many external hubs are in between the device & the root port. */
	for (parent = udev->parent, num_hubs = 0; parent->parent;
			parent = parent->parent)
		num_hubs++;
	/* t2 = 2.1us + 250ns * (num_hubs - 1) */
	if (num_hubs > 0)
		total_sel += 2100 + 250 * (num_hubs - 1);

	/* t4 = 250ns * num_hubs */
	total_sel += 250 * num_hubs;

	udev_lpm_params->sel = total_sel;
}

static void usb_set_lpm_parameters(struct usb_device *udev)
{
	struct usb_hub *hub;
	unsigned int port_to_port_delay;
	unsigned int udev_u1_del;
	unsigned int udev_u2_del;
	unsigned int hub_u1_del;
	unsigned int hub_u2_del;

303
	if (!udev->lpm_capable || udev->speed < USB_SPEED_SUPER)
304 305
		return;

306
	hub = usb_hub_to_struct_hub(udev->parent);
307 308 309 310 311 312 313
	/* It doesn't take time to transition the roothub into U0, since it
	 * doesn't have an upstream link.
	 */
	if (!hub)
		return;

	udev_u1_del = udev->bos->ss_cap->bU1devExitLat;
314
	udev_u2_del = le16_to_cpu(udev->bos->ss_cap->bU2DevExitLat);
315
	hub_u1_del = udev->parent->bos->ss_cap->bU1devExitLat;
316
	hub_u2_del = le16_to_cpu(udev->parent->bos->ss_cap->bU2DevExitLat);
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360

	usb_set_lpm_mel(udev, &udev->u1_params, udev_u1_del,
			hub, &udev->parent->u1_params, hub_u1_del);

	usb_set_lpm_mel(udev, &udev->u2_params, udev_u2_del,
			hub, &udev->parent->u2_params, hub_u2_del);

	/*
	 * Appendix C, section C.2.2.2, says that there is a slight delay from
	 * when the parent hub notices the downstream port is trying to
	 * transition to U0 to when the hub initiates a U0 transition on its
	 * upstream port.  The section says the delays are tPort2PortU1EL and
	 * tPort2PortU2EL, but it doesn't define what they are.
	 *
	 * The hub chapter, sections 10.4.2.4 and 10.4.2.5 seem to be talking
	 * about the same delays.  Use the maximum delay calculations from those
	 * sections.  For U1, it's tHubPort2PortExitLat, which is 1us max.  For
	 * U2, it's tHubPort2PortExitLat + U2DevExitLat - U1DevExitLat.  I
	 * assume the device exit latencies they are talking about are the hub
	 * exit latencies.
	 *
	 * What do we do if the U2 exit latency is less than the U1 exit
	 * latency?  It's possible, although not likely...
	 */
	port_to_port_delay = 1;

	usb_set_lpm_pel(udev, &udev->u1_params, udev_u1_del,
			hub, &udev->parent->u1_params, hub_u1_del,
			port_to_port_delay);

	if (hub_u2_del > hub_u1_del)
		port_to_port_delay = 1 + hub_u2_del - hub_u1_del;
	else
		port_to_port_delay = 1 + hub_u1_del;

	usb_set_lpm_pel(udev, &udev->u2_params, udev_u2_del,
			hub, &udev->parent->u2_params, hub_u2_del,
			port_to_port_delay);

	/* Now that we've got PEL, calculate SEL. */
	usb_set_lpm_sel(udev, &udev->u1_params);
	usb_set_lpm_sel(udev, &udev->u2_params);
}

L
Linus Torvalds 已提交
361
/* USB 2.0 spec Section 11.24.4.5 */
J
John Youn 已提交
362
static int get_hub_descriptor(struct usb_device *hdev, void *data)
L
Linus Torvalds 已提交
363
{
J
John Youn 已提交
364 365 366 367 368 369 370 371 372 373
	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);
	}
L
Linus Torvalds 已提交
374 375 376 377

	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,
J
John Youn 已提交
378
			dtype << 8, 0, data, size,
L
Linus Torvalds 已提交
379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
			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
 */
398
int usb_clear_port_feature(struct usb_device *hdev, int port1, int feature)
L
Linus Torvalds 已提交
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414
{
	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);
}

415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430
static char *to_led_name(int selector)
{
	switch (selector) {
	case HUB_LED_AMBER:
		return "amber";
	case HUB_LED_GREEN:
		return "green";
	case HUB_LED_OFF:
		return "off";
	case HUB_LED_AUTO:
		return "auto";
	default:
		return "??";
	}
}

L
Linus Torvalds 已提交
431 432 433 434
/*
 * USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7
 * for info about using port indicators
 */
435
static void set_port_led(struct usb_hub *hub, int port1, int selector)
L
Linus Torvalds 已提交
436
{
437 438 439 440
	struct usb_port *port_dev = hub->ports[port1 - 1];
	int status;

	status = set_port_feature(hub->hdev, (selector << 8) | port1,
L
Linus Torvalds 已提交
441
			USB_PORT_FEAT_INDICATOR);
442 443
	dev_dbg(&port_dev->dev, "indicator %s status %d\n",
		to_led_name(selector), status);
L
Linus Torvalds 已提交
444 445 446 447
}

#define	LED_CYCLE_PERIOD	((2*HZ)/3)

448
static void led_work(struct work_struct *work)
L
Linus Torvalds 已提交
449
{
D
David Howells 已提交
450 451
	struct usb_hub		*hub =
		container_of(work, struct usb_hub, leds.work);
L
Linus Torvalds 已提交
452 453 454 455 456 457 458 459
	struct usb_device	*hdev = hub->hdev;
	unsigned		i;
	unsigned		changed = 0;
	int			cursor = -1;

	if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing)
		return;

460
	for (i = 0; i < hdev->maxchild; i++) {
L
Linus Torvalds 已提交
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
		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++;
509
		cursor %= hdev->maxchild;
L
Linus Torvalds 已提交
510 511 512 513 514
		set_port_led(hub, cursor + 1, HUB_LED_GREEN);
		hub->indicator[cursor] = INDICATOR_CYCLE;
		changed++;
	}
	if (changed)
515 516
		queue_delayed_work(system_power_efficient_wq,
				&hub->leds, LED_CYCLE_PERIOD);
L
Linus Torvalds 已提交
517 518 519 520 521 522 523 524 525 526 527 528 529 530
}

/* 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;

531 532
	for (i = 0; i < USB_STS_RETRIES &&
			(status == -ETIMEDOUT || status == -EPIPE); i++) {
L
Linus Torvalds 已提交
533 534 535 536 537 538 539 540 541
		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
542
 * USB 3.1 takes into use the wValue and wLength fields, spec Section 10.16.2.6
L
Linus Torvalds 已提交
543 544
 */
static int get_port_status(struct usb_device *hdev, int port1,
545
			   void *data, u16 value, u16 length)
L
Linus Torvalds 已提交
546 547 548
{
	int i, status = -ETIMEDOUT;

549 550
	for (i = 0; i < USB_STS_RETRIES &&
			(status == -ETIMEDOUT || status == -EPIPE); i++) {
L
Linus Torvalds 已提交
551
		status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
552 553
			USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, value,
			port1, data, length, USB_STS_TIMEOUT);
L
Linus Torvalds 已提交
554 555 556 557
	}
	return status;
}

558 559
static int hub_ext_port_status(struct usb_hub *hub, int port1, int type,
			       u16 *status, u16 *change, u32 *ext_status)
A
Alan Stern 已提交
560 561
{
	int ret;
562 563 564 565
	int len = 4;

	if (type != HUB_PORT_STATUS)
		len = 8;
A
Alan Stern 已提交
566 567

	mutex_lock(&hub->status_mutex);
568 569
	ret = get_port_status(hub->hdev, port1, &hub->status->port, type, len);
	if (ret < len) {
570 571 572
		if (ret != -ENODEV)
			dev_err(hub->intfdev,
				"%s failed (err = %d)\n", __func__, ret);
A
Alan Stern 已提交
573 574 575 576 577
		if (ret >= 0)
			ret = -EIO;
	} else {
		*status = le16_to_cpu(hub->status->port.wPortStatus);
		*change = le16_to_cpu(hub->status->port.wPortChange);
578 579 580
		if (type != HUB_PORT_STATUS && ext_status)
			*ext_status = le32_to_cpu(
				hub->status->port.dwExtPortStatus);
A
Alan Stern 已提交
581 582 583 584 585 586
		ret = 0;
	}
	mutex_unlock(&hub->status_mutex);
	return ret;
}

587 588 589 590 591 592 593
static int hub_port_status(struct usb_hub *hub, int port1,
		u16 *status, u16 *change)
{
	return hub_ext_port_status(hub, port1, HUB_PORT_STATUS,
				   status, change, NULL);
}

594
static void kick_hub_wq(struct usb_hub *hub)
L
Linus Torvalds 已提交
595
{
596
	struct usb_interface *intf;
L
Linus Torvalds 已提交
597

598 599
	if (hub->disconnected || work_pending(&hub->events))
		return;
600

601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
	/*
	 * Suppress autosuspend until the event is proceed.
	 *
	 * Be careful and make sure that the symmetric operation is
	 * always called. We are here only when there is no pending
	 * work for this hub. Therefore put the interface either when
	 * the new work is called or when it is canceled.
	 */
	intf = to_usb_interface(hub->intfdev);
	usb_autopm_get_interface_no_resume(intf);
	kref_get(&hub->kref);

	if (queue_work(hub_wq, &hub->events))
		return;

	/* the work has already been scheduled */
	usb_autopm_put_interface_async(intf);
	kref_put(&hub->kref, hub_release);
L
Linus Torvalds 已提交
619 620
}

621
void usb_kick_hub_wq(struct usb_device *hdev)
L
Linus Torvalds 已提交
622
{
623
	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
624 625

	if (hub)
626
		kick_hub_wq(hub);
L
Linus Torvalds 已提交
627 628
}

629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
/*
 * Let the USB core know that a USB 3.0 device has sent a Function Wake Device
 * Notification, which indicates it had initiated remote wakeup.
 *
 * USB 3.0 hubs do not report the port link state change from U3 to U0 when the
 * device initiates resume, so the USB core will not receive notice of the
 * resume through the normal hub interrupt URB.
 */
void usb_wakeup_notification(struct usb_device *hdev,
		unsigned int portnum)
{
	struct usb_hub *hub;

	if (!hdev)
		return;

645
	hub = usb_hub_to_struct_hub(hdev);
646 647
	if (hub) {
		set_bit(portnum, hub->wakeup_bits);
648
		kick_hub_wq(hub);
649 650 651
	}
}
EXPORT_SYMBOL_GPL(usb_wakeup_notification);
L
Linus Torvalds 已提交
652 653

/* completion function, fires on port status changes and various faults */
654
static void hub_irq(struct urb *urb)
L
Linus Torvalds 已提交
655
{
656
	struct usb_hub *hub = urb->context;
657
	int status = urb->status;
658
	unsigned i;
L
Linus Torvalds 已提交
659 660
	unsigned long bits;

661
	switch (status) {
L
Linus Torvalds 已提交
662 663 664 665 666 667 668
	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 */
669
		dev_dbg(hub->intfdev, "transfer --> %d\n", status);
L
Linus Torvalds 已提交
670 671
		if ((++hub->nerrors < 10) || hub->error)
			goto resubmit;
672
		hub->error = status;
L
Linus Torvalds 已提交
673
		/* FALL THROUGH */
674

675
	/* let hub_wq handle things */
L
Linus Torvalds 已提交
676 677 678 679 680 681 682 683 684 685 686
	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;

687
	/* Something happened, let hub_wq figure it out */
688
	kick_hub_wq(hub);
L
Linus Torvalds 已提交
689 690 691 692 693

resubmit:
	if (hub->quiescing)
		return;

694 695
	status = usb_submit_urb(hub->urb, GFP_ATOMIC);
	if (status != 0 && status != -ENODEV && status != -EPERM)
696
		dev_err(hub->intfdev, "resubmit --> %d\n", status);
L
Linus Torvalds 已提交
697 698 699 700
}

/* USB 2.0 spec Section 11.24.2.3 */
static inline int
701
hub_clear_tt_buffer(struct usb_device *hdev, u16 devinfo, u16 tt)
L
Linus Torvalds 已提交
702
{
703 704 705 706 707 708 709 710 711
	/* Need to clear both directions for control ep */
	if (((devinfo >> 11) & USB_ENDPOINT_XFERTYPE_MASK) ==
			USB_ENDPOINT_XFER_CONTROL) {
		int status = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
				HUB_CLEAR_TT_BUFFER, USB_RT_PORT,
				devinfo ^ 0x8000, tt, NULL, 0, 1000);
		if (status)
			return status;
	}
712
	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
L
Linus Torvalds 已提交
713 714 715 716 717
			       HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo,
			       tt, NULL, 0, 1000);
}

/*
718
 * enumeration blocks hub_wq for a long time. we use keventd instead, since
L
Linus Torvalds 已提交
719 720 721 722
 * 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.
 */
723
static void hub_tt_work(struct work_struct *work)
L
Linus Torvalds 已提交
724
{
D
David Howells 已提交
725
	struct usb_hub		*hub =
726
		container_of(work, struct usb_hub, tt.clear_work);
L
Linus Torvalds 已提交
727 728
	unsigned long		flags;

729
	spin_lock_irqsave(&hub->tt.lock, flags);
730
	while (!list_empty(&hub->tt.clear_list)) {
731
		struct list_head	*next;
L
Linus Torvalds 已提交
732 733
		struct usb_tt_clear	*clear;
		struct usb_device	*hdev = hub->hdev;
734
		const struct hc_driver	*drv;
L
Linus Torvalds 已提交
735 736
		int			status;

737
		next = hub->tt.clear_list.next;
738 739
		clear = list_entry(next, struct usb_tt_clear, clear_list);
		list_del(&clear->clear_list);
L
Linus Torvalds 已提交
740 741

		/* drop lock so HCD can concurrently report other TT errors */
742 743
		spin_unlock_irqrestore(&hub->tt.lock, flags);
		status = hub_clear_tt_buffer(hdev, clear->devinfo, clear->tt);
744
		if (status && status != -ENODEV)
745
			dev_err(&hdev->dev,
L
Linus Torvalds 已提交
746 747
				"clear tt %d (%04x) error %d\n",
				clear->tt, clear->devinfo, status);
748 749 750 751 752 753

		/* 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);

754
		kfree(clear);
755
		spin_lock_irqsave(&hub->tt.lock, flags);
L
Linus Torvalds 已提交
756
	}
757
	spin_unlock_irqrestore(&hub->tt.lock, flags);
L
Linus Torvalds 已提交
758 759
}

760 761
/**
 * usb_hub_set_port_power - control hub port's power state
762 763
 * @hdev: USB device belonging to the usb hub
 * @hub: target hub
764 765 766 767 768
 * @port1: port index
 * @set: expected status
 *
 * call this function to control port's power via setting or
 * clearing the port's PORT_POWER feature.
769 770
 *
 * Return: 0 if successful. A negative error code otherwise.
771
 */
772 773
int usb_hub_set_port_power(struct usb_device *hdev, struct usb_hub *hub,
			   int port1, bool set)
774 775 776 777 778 779
{
	int ret;

	if (set)
		ret = set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
	else
780 781
		ret = usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_POWER);

782 783 784 785 786 787 788 789
	if (ret)
		return ret;

	if (set)
		set_bit(port1, hub->power_bits);
	else
		clear_bit(port1, hub->power_bits);
	return 0;
790 791
}

L
Linus Torvalds 已提交
792
/**
793 794
 * 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
L
Linus Torvalds 已提交
795 796 797 798 799 800 801 802
 *
 * 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.
803 804
 *
 * Return: 0 if successful. A negative error code otherwise.
L
Linus Torvalds 已提交
805
 */
806
int usb_hub_clear_tt_buffer(struct urb *urb)
L
Linus Torvalds 已提交
807
{
808 809
	struct usb_device	*udev = urb->dev;
	int			pipe = urb->pipe;
L
Linus Torvalds 已提交
810 811 812 813 814 815 816 817
	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.
	 */
818 819
	clear = kmalloc(sizeof *clear, GFP_ATOMIC);
	if (clear == NULL) {
820
		dev_err(&udev->dev, "can't save CLEAR_TT_BUFFER state\n");
L
Linus Torvalds 已提交
821
		/* FIXME recover somehow ... RESET_TT? */
822
		return -ENOMEM;
L
Linus Torvalds 已提交
823 824 825 826 827 828
	}

	/* info that CLEAR_TT_BUFFER needs */
	clear->tt = tt->multi ? udev->ttport : 1;
	clear->devinfo = usb_pipeendpoint (pipe);
	clear->devinfo |= udev->devnum << 4;
829
	clear->devinfo |= usb_pipecontrol(pipe)
L
Linus Torvalds 已提交
830 831
			? (USB_ENDPOINT_XFER_CONTROL << 11)
			: (USB_ENDPOINT_XFER_BULK << 11);
832
	if (usb_pipein(pipe))
L
Linus Torvalds 已提交
833
		clear->devinfo |= 1 << 15;
834 835 836 837 838

	/* info for completion callback */
	clear->hcd = bus_to_hcd(udev->bus);
	clear->ep = urb->ep;

L
Linus Torvalds 已提交
839
	/* tell keventd to clear state for this TT */
840 841
	spin_lock_irqsave(&tt->lock, flags);
	list_add_tail(&clear->clear_list, &tt->clear_list);
842
	schedule_work(&tt->clear_work);
843
	spin_unlock_irqrestore(&tt->lock, flags);
844
	return 0;
L
Linus Torvalds 已提交
845
}
846
EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer);
L
Linus Torvalds 已提交
847

848
static void hub_power_on(struct usb_hub *hub, bool do_delay)
L
Linus Torvalds 已提交
849 850
{
	int port1;
851 852 853 854 855 856 857

	/* 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.
	 */
858
	if (hub_is_port_power_switchable(hub))
L
Linus Torvalds 已提交
859
		dev_dbg(hub->intfdev, "enabling power on all ports\n");
860 861 862
	else
		dev_dbg(hub->intfdev, "trying to enable port power on "
				"non-switchable hub\n");
863
	for (port1 = 1; port1 <= hub->hdev->maxchild; port1++)
864
		if (test_bit(port1, hub->power_bits))
865 866 867 868
			set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
		else
			usb_clear_port_feature(hub->hdev, port1,
						USB_PORT_FEAT_POWER);
869
	if (do_delay)
870
		msleep(hub_power_on_good_delay(hub));
L
Linus Torvalds 已提交
871 872 873 874 875 876 877
}

static int hub_hub_status(struct usb_hub *hub,
		u16 *status, u16 *change)
{
	int ret;

878
	mutex_lock(&hub->status_mutex);
L
Linus Torvalds 已提交
879
	ret = get_hub_status(hub->hdev, &hub->status->hub);
880 881 882 883 884
	if (ret < 0) {
		if (ret != -ENODEV)
			dev_err(hub->intfdev,
				"%s failed (err = %d)\n", __func__, ret);
	} else {
L
Linus Torvalds 已提交
885
		*status = le16_to_cpu(hub->status->hub.wHubStatus);
886
		*change = le16_to_cpu(hub->status->hub.wHubChange);
L
Linus Torvalds 已提交
887 888
		ret = 0;
	}
889
	mutex_unlock(&hub->status_mutex);
L
Linus Torvalds 已提交
890 891 892
	return ret;
}

893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919
static int hub_set_port_link_state(struct usb_hub *hub, int port1,
			unsigned int link_status)
{
	return set_port_feature(hub->hdev,
			port1 | (link_status << 3),
			USB_PORT_FEAT_LINK_STATE);
}

/*
 * If USB 3.0 ports are placed into the Disabled state, they will no longer
 * detect any device connects or disconnects.  This is generally not what the
 * USB core wants, since it expects a disabled port to produce a port status
 * change event when a new device connects.
 *
 * Instead, set the link state to Disabled, wait for the link to settle into
 * that state, clear any change bits, and then put the port into the RxDetect
 * state.
 */
static int hub_usb3_port_disable(struct usb_hub *hub, int port1)
{
	int ret;
	int total_time;
	u16 portchange, portstatus;

	if (!hub_is_superspeed(hub->hdev))
		return -EINVAL;

920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938
	ret = hub_port_status(hub, port1, &portstatus, &portchange);
	if (ret < 0)
		return ret;

	/*
	 * USB controller Advanced Micro Devices, Inc. [AMD] FCH USB XHCI
	 * Controller [1022:7814] will have spurious result making the following
	 * usb 3.0 device hotplugging route to the 2.0 root hub and recognized
	 * as high-speed device if we set the usb 3.0 port link state to
	 * Disabled. Since it's already in USB_SS_PORT_LS_RX_DETECT state, we
	 * check the state here to avoid the bug.
	 */
	if ((portstatus & USB_PORT_STAT_LINK_STATE) ==
				USB_SS_PORT_LS_RX_DETECT) {
		dev_dbg(&hub->ports[port1 - 1]->dev,
			 "Not disabling port; link state is RxDetect\n");
		return ret;
	}

939
	ret = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_SS_DISABLED);
940
	if (ret)
941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956
		return ret;

	/* Wait for the link to enter the disabled state. */
	for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
		ret = hub_port_status(hub, port1, &portstatus, &portchange);
		if (ret < 0)
			return ret;

		if ((portstatus & USB_PORT_STAT_LINK_STATE) ==
				USB_SS_PORT_LS_SS_DISABLED)
			break;
		if (total_time >= HUB_DEBOUNCE_TIMEOUT)
			break;
		msleep(HUB_DEBOUNCE_STEP);
	}
	if (total_time >= HUB_DEBOUNCE_TIMEOUT)
957 958
		dev_warn(&hub->ports[port1 - 1]->dev,
				"Could not disable after %d ms\n", total_time);
959 960 961 962

	return hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_RX_DETECT);
}

963 964
static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
{
965
	struct usb_port *port_dev = hub->ports[port1 - 1];
966
	struct usb_device *hdev = hub->hdev;
A
Alan Stern 已提交
967
	int ret = 0;
968

969 970
	if (port_dev->child && set_state)
		usb_set_device_state(port_dev->child, USB_STATE_NOTATTACHED);
971 972 973 974
	if (!hub->error) {
		if (hub_is_superspeed(hub->hdev))
			ret = hub_usb3_port_disable(hub, port1);
		else
975
			ret = usb_clear_port_feature(hdev, port1,
976 977
					USB_PORT_FEAT_ENABLE);
	}
978
	if (ret && ret != -ENODEV)
979
		dev_err(&port_dev->dev, "cannot disable (err = %d)\n", ret);
980 981 982
	return ret;
}

A
Alan Stern 已提交
983
/*
984
 * Disable a port and mark a logical connect-change event, so that some
985
 * time later hub_wq will disconnect() any existing usb_device on the port
A
Alan Stern 已提交
986 987 988 989
 * and will re-enumerate if there actually is a device attached.
 */
static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
{
990
	dev_dbg(&hub->ports[port1 - 1]->dev, "logical disconnect\n");
A
Alan Stern 已提交
991
	hub_port_disable(hub, port1, 1);
992

A
Alan Stern 已提交
993 994 995 996 997
	/* 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
998
	 * hub_wq reactivates the port later (timer, SRP, etc).
A
Alan Stern 已提交
999 1000 1001 1002
	 * Powerdown must be optional, because of reset/DFU.
	 */

	set_bit(port1, hub->change_bits);
1003
	kick_hub_wq(hub);
A
Alan Stern 已提交
1004 1005
}

1006 1007 1008 1009 1010
/**
 * 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.
 *
1011
 * After @udev's port has been disabled, hub_wq is notified and it will
1012 1013 1014
 * 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.
1015 1016
 *
 * Return: 0 if successful. A negative error code otherwise.
1017 1018 1019 1020 1021 1022 1023 1024
 */
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;
1025
	hub = usb_hub_to_struct_hub(udev->parent);
1026 1027 1028 1029 1030 1031 1032 1033 1034
	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;
}

A
Alan Stern 已提交
1035
enum hub_activation_type {
1036
	HUB_INIT, HUB_INIT2, HUB_INIT3,		/* INITs must come first */
1037
	HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME,
A
Alan Stern 已提交
1038
};
1039

1040 1041 1042
static void hub_init_func2(struct work_struct *ws);
static void hub_init_func3(struct work_struct *ws);

1043
static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
1044 1045
{
	struct usb_device *hdev = hub->hdev;
1046 1047
	struct usb_hcd *hcd;
	int ret;
1048
	int port1;
1049
	int status;
1050
	bool need_debounce_delay = false;
1051 1052 1053
	unsigned delay;

	/* Continue a partial initialization */
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
	if (type == HUB_INIT2 || type == HUB_INIT3) {
		device_lock(hub->intfdev);

		/* Was the hub disconnected while we were waiting? */
		if (hub->disconnected) {
			device_unlock(hub->intfdev);
			kref_put(&hub->kref, hub_release);
			return;
		}
		if (type == HUB_INIT2)
			goto init2;
1065
		goto init3;
1066 1067
	}
	kref_get(&hub->kref);
1068

1069 1070 1071 1072 1073 1074 1075 1076
	/* The superspeed hub except for root hub has to use Hub Depth
	 * value as an offset into the route string to locate the bits
	 * it uses to determine the downstream port number. So hub driver
	 * should send a set hub depth request to superspeed hub after
	 * the superspeed hub is set configuration in initialization or
	 * reset procedure.
	 *
	 * After a resume, port power should still be on.
1077 1078
	 * For any other type of activation, turn it on.
	 */
1079
	if (type != HUB_RESUME) {
1080 1081 1082 1083 1084 1085 1086 1087 1088
		if (hdev->parent && hub_is_superspeed(hdev)) {
			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)
				dev_err(hub->intfdev,
						"set hub depth failed\n");
		}
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102

		/* 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) {
1103
			delay = hub_power_on_good_delay(hub);
1104 1105

			hub_power_on(hub, false);
T
Tejun Heo 已提交
1106
			INIT_DELAYED_WORK(&hub->init_work, hub_init_func2);
1107 1108
			queue_delayed_work(system_power_efficient_wq,
					&hub->init_work,
1109
					msecs_to_jiffies(delay));
1110 1111

			/* Suppress autosuspend until init is done */
1112 1113
			usb_autopm_get_interface_no_resume(
					to_usb_interface(hub->intfdev));
1114
			return;		/* Continues at init2: below */
1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
		} 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);
1134 1135 1136 1137 1138
		} else {
			hub_power_on(hub, true);
		}
	}
 init2:
1139

1140
	/*
1141
	 * Check each port and set hub->change_bits to let hub_wq know
A
Alan Stern 已提交
1142
	 * which ports need attention.
1143 1144
	 */
	for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
1145 1146
		struct usb_port *port_dev = hub->ports[port1 - 1];
		struct usb_device *udev = port_dev->child;
1147 1148
		u16 portstatus, portchange;

A
Alan Stern 已提交
1149 1150 1151
		portstatus = portchange = 0;
		status = hub_port_status(hub, port1, &portstatus, &portchange);
		if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
1152 1153
			dev_dbg(&port_dev->dev, "status %04x change %04x\n",
					portstatus, portchange);
A
Alan Stern 已提交
1154

1155 1156
		/*
		 * After anything other than HUB_RESUME (i.e., initialization
A
Alan Stern 已提交
1157 1158 1159 1160 1161 1162 1163 1164 1165
		 * 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)) {
1166 1167 1168
			/*
			 * USB3 protocol ports will automatically transition
			 * to Enabled state when detect an USB3.0 device attach.
D
Dan Williams 已提交
1169 1170
			 * Do not disable USB3 protocol ports, just pretend
			 * power was lost
1171
			 */
D
Dan Williams 已提交
1172 1173
			portstatus &= ~USB_PORT_STAT_ENABLE;
			if (!hub_is_superspeed(hdev))
1174
				usb_clear_port_feature(hdev, port1,
1175
						   USB_PORT_FEAT_ENABLE);
1176 1177
		}

1178 1179 1180
		/* Clear status-change flags; we'll debounce later */
		if (portchange & USB_PORT_STAT_C_CONNECTION) {
			need_debounce_delay = true;
1181
			usb_clear_port_feature(hub->hdev, port1,
1182 1183 1184 1185
					USB_PORT_FEAT_C_CONNECTION);
		}
		if (portchange & USB_PORT_STAT_C_ENABLE) {
			need_debounce_delay = true;
1186
			usb_clear_port_feature(hub->hdev, port1,
1187 1188
					USB_PORT_FEAT_C_ENABLE);
		}
1189 1190 1191 1192 1193
		if (portchange & USB_PORT_STAT_C_RESET) {
			need_debounce_delay = true;
			usb_clear_port_feature(hub->hdev, port1,
					USB_PORT_FEAT_C_RESET);
		}
1194 1195 1196
		if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
				hub_is_superspeed(hub->hdev)) {
			need_debounce_delay = true;
1197
			usb_clear_port_feature(hub->hdev, port1,
1198 1199
					USB_PORT_FEAT_C_BH_PORT_RESET);
		}
1200 1201 1202 1203 1204 1205 1206
		/* 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);

A
Alan Stern 已提交
1207
		if (!udev || udev->state == USB_STATE_NOTATTACHED) {
1208
			/* Tell hub_wq to disconnect the device or
A
Alan Stern 已提交
1209 1210
			 * check for a new connection
			 */
1211 1212
			if (udev || (portstatus & USB_PORT_STAT_CONNECTION) ||
			    (portstatus & USB_PORT_STAT_OVERCURRENT))
A
Alan Stern 已提交
1213 1214 1215
				set_bit(port1, hub->change_bits);

		} else if (portstatus & USB_PORT_STAT_ENABLE) {
1216 1217 1218
			bool port_resumed = (portstatus &
					USB_PORT_STAT_LINK_STATE) ==
				USB_SS_PORT_LS_U0;
A
Alan Stern 已提交
1219 1220
			/* The power session apparently survived the resume.
			 * If there was an overcurrent or suspend change
1221
			 * (i.e., remote wakeup request), have hub_wq
1222 1223 1224 1225
			 * take care of it.  Look at the port link state
			 * for USB 3.0 hubs, since they don't have a suspend
			 * change bit, and they don't set the port link change
			 * bit on device-initiated resume.
A
Alan Stern 已提交
1226
			 */
1227 1228
			if (portchange || (hub_is_superspeed(hub->hdev) &&
						port_resumed))
A
Alan Stern 已提交
1229
				set_bit(port1, hub->change_bits);
1230

A
Alan Stern 已提交
1231 1232
		} else if (udev->persist_enabled) {
#ifdef CONFIG_PM
1233
			udev->reset_resume = 1;
A
Alan Stern 已提交
1234
#endif
1235 1236 1237
			/* Don't set the change_bits when the device
			 * was powered off.
			 */
1238
			if (test_bit(port1, hub->power_bits))
1239
				set_bit(port1, hub->change_bits);
1240

A
Alan Stern 已提交
1241
		} else {
1242
			/* The power session is gone; tell hub_wq */
A
Alan Stern 已提交
1243 1244
			usb_set_device_state(udev, USB_STATE_NOTATTACHED);
			set_bit(port1, hub->change_bits);
1245 1246 1247
		}
	}

1248 1249
	/* If no port-status-change flags were set, we don't need any
	 * debouncing.  If flags were set we can try to debounce the
1250
	 * ports all at once right now, instead of letting hub_wq do them
1251 1252
	 * one at a time later on.
	 *
1253
	 * If any port-status changes do occur during this delay, hub_wq
1254 1255
	 * will see them later and handle them normally.
	 */
1256 1257 1258 1259 1260
	if (need_debounce_delay) {
		delay = HUB_DEBOUNCE_STABLE;

		/* Don't do a long sleep inside a workqueue routine */
		if (type == HUB_INIT2) {
T
Tejun Heo 已提交
1261
			INIT_DELAYED_WORK(&hub->init_work, hub_init_func3);
1262 1263
			queue_delayed_work(system_power_efficient_wq,
					&hub->init_work,
1264
					msecs_to_jiffies(delay));
1265
			device_unlock(hub->intfdev);
1266 1267 1268 1269 1270 1271
			return;		/* Continues at init3: below */
		} else {
			msleep(delay);
		}
	}
 init3:
1272 1273 1274 1275 1276 1277
	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)
1278 1279
		queue_delayed_work(system_power_efficient_wq,
				&hub->leds, LED_CYCLE_PERIOD);
1280 1281

	/* Scan all ports that need attention */
1282
	kick_hub_wq(hub);
1283 1284 1285 1286

	/* Allow autosuspend if it was suppressed */
	if (type <= HUB_INIT3)
		usb_autopm_put_interface_async(to_usb_interface(hub->intfdev));
1287 1288 1289 1290 1291

	if (type == HUB_INIT2 || type == HUB_INIT3)
		device_unlock(hub->intfdev);

	kref_put(&hub->kref, hub_release);
1292 1293
}

1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
/* 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);
}

1309 1310 1311 1312 1313 1314 1315 1316 1317
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;

1318
	/* hub_wq and related activity won't re-trigger */
1319 1320 1321 1322 1323
	hub->quiescing = 1;

	if (type != HUB_SUSPEND) {
		/* Disconnect all the children */
		for (i = 0; i < hdev->maxchild; ++i) {
1324 1325
			if (hub->ports[i]->child)
				usb_disconnect(&hub->ports[i]->child);
1326 1327 1328
		}
	}

1329
	/* Stop hub_wq and related activity */
1330 1331 1332 1333
	usb_kill_urb(hub->urb);
	if (hub->has_indicators)
		cancel_delayed_work_sync(&hub->leds);
	if (hub->tt.hub)
1334
		flush_work(&hub->tt.clear_work);
1335 1336
}

1337 1338 1339 1340 1341 1342 1343 1344
static void hub_pm_barrier_for_all_ports(struct usb_hub *hub)
{
	int i;

	for (i = 0; i < hub->hdev->maxchild; ++i)
		pm_runtime_barrier(&hub->ports[i]->dev);
}

A
Alan Stern 已提交
1345 1346 1347 1348 1349
/* caller has locked the hub device */
static int hub_pre_reset(struct usb_interface *intf)
{
	struct usb_hub *hub = usb_get_intfdata(intf);

1350
	hub_quiesce(hub, HUB_PRE_RESET);
1351 1352
	hub->in_reset = 1;
	hub_pm_barrier_for_all_ports(hub);
A
Alan Stern 已提交
1353
	return 0;
1354 1355 1356
}

/* caller has locked the hub device */
A
Alan Stern 已提交
1357
static int hub_post_reset(struct usb_interface *intf)
1358
{
1359 1360
	struct usb_hub *hub = usb_get_intfdata(intf);

1361 1362
	hub->in_reset = 0;
	hub_pm_barrier_for_all_ports(hub);
1363
	hub_activate(hub, HUB_POST_RESET);
A
Alan Stern 已提交
1364
	return 0;
1365 1366
}

L
Linus Torvalds 已提交
1367 1368 1369
static int hub_configure(struct usb_hub *hub,
	struct usb_endpoint_descriptor *endpoint)
{
1370
	struct usb_hcd *hcd;
L
Linus Torvalds 已提交
1371 1372 1373
	struct usb_device *hdev = hub->hdev;
	struct device *hub_dev = hub->intfdev;
	u16 hubstatus, hubchange;
1374
	u16 wHubCharacteristics;
L
Linus Torvalds 已提交
1375
	unsigned int pipe;
L
Lan Tianyu 已提交
1376
	int maxp, ret, i;
1377
	char *message = "out of memory";
1378 1379
	unsigned unit_load;
	unsigned full_load;
1380
	unsigned maxchild;
L
Linus Torvalds 已提交
1381

1382
	hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
L
Linus Torvalds 已提交
1383 1384 1385 1386 1387 1388 1389 1390 1391 1392
	if (!hub->buffer) {
		ret = -ENOMEM;
		goto fail;
	}

	hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
	if (!hub->status) {
		ret = -ENOMEM;
		goto fail;
	}
1393
	mutex_init(&hub->status_mutex);
L
Linus Torvalds 已提交
1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404

	hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
	if (!hub->descriptor) {
		ret = -ENOMEM;
		goto fail;
	}

	/* Request the entire hub descriptor.
	 * hub->descriptor can handle USB_MAXCHILDREN ports,
	 * but the hub can/will return fewer bytes here.
	 */
J
John Youn 已提交
1405
	ret = get_hub_descriptor(hdev, hub->descriptor);
L
Linus Torvalds 已提交
1406 1407 1408 1409 1410 1411 1412
	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;
1413 1414 1415 1416
	} else if (hub->descriptor->bNbrPorts == 0) {
		message = "hub doesn't have any ports!";
		ret = -ENODEV;
		goto fail;
L
Linus Torvalds 已提交
1417 1418
	}

1419 1420 1421
	maxchild = hub->descriptor->bNbrPorts;
	dev_info(hub_dev, "%d port%s detected\n", maxchild,
			(maxchild == 1) ? "" : "s");
L
Linus Torvalds 已提交
1422

1423
	hub->ports = kzalloc(maxchild * sizeof(struct usb_port *), GFP_KERNEL);
1424
	if (!hub->ports) {
1425 1426 1427 1428
		ret = -ENOMEM;
		goto fail;
	}

1429
	wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
1430 1431 1432 1433 1434 1435 1436
	if (hub_is_superspeed(hdev)) {
		unit_load = 150;
		full_load = 900;
	} else {
		unit_load = 100;
		full_load = 500;
	}
L
Linus Torvalds 已提交
1437

J
John Youn 已提交
1438 1439 1440
	/* FIXME for USB 3.0, skip for now */
	if ((wHubCharacteristics & HUB_CHAR_COMPOUND) &&
			!(hub_is_superspeed(hdev))) {
1441
		char	portstr[USB_MAXCHILDREN + 1];
L
Linus Torvalds 已提交
1442

1443
		for (i = 0; i < maxchild; i++)
J
John Youn 已提交
1444
			portstr[i] = hub->descriptor->u.hs.DeviceRemovable
L
Linus Torvalds 已提交
1445 1446
				    [((i + 1) / 8)] & (1 << ((i + 1) % 8))
				? 'F' : 'R';
1447
		portstr[maxchild] = 0;
L
Linus Torvalds 已提交
1448 1449 1450 1451
		dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
	} else
		dev_dbg(hub_dev, "standalone hub\n");

1452
	switch (wHubCharacteristics & HUB_CHAR_LPSM) {
1453 1454 1455 1456 1457 1458 1459 1460 1461 1462
	case HUB_CHAR_COMMON_LPSM:
		dev_dbg(hub_dev, "ganged power switching\n");
		break;
	case HUB_CHAR_INDV_PORT_LPSM:
		dev_dbg(hub_dev, "individual port power switching\n");
		break;
	case HUB_CHAR_NO_LPSM:
	case HUB_CHAR_LPSM:
		dev_dbg(hub_dev, "no power switching (usb 1.0)\n");
		break;
L
Linus Torvalds 已提交
1463 1464
	}

1465
	switch (wHubCharacteristics & HUB_CHAR_OCPM) {
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475
	case HUB_CHAR_COMMON_OCPM:
		dev_dbg(hub_dev, "global over-current protection\n");
		break;
	case HUB_CHAR_INDV_PORT_OCPM:
		dev_dbg(hub_dev, "individual port over-current protection\n");
		break;
	case HUB_CHAR_NO_OCPM:
	case HUB_CHAR_OCPM:
		dev_dbg(hub_dev, "no over-current protection\n");
		break;
L
Linus Torvalds 已提交
1476 1477
	}

1478 1479
	spin_lock_init(&hub->tt.lock);
	INIT_LIST_HEAD(&hub->tt.clear_list);
1480
	INIT_WORK(&hub->tt.clear_work, hub_tt_work);
L
Linus Torvalds 已提交
1481
	switch (hdev->descriptor.bDeviceProtocol) {
1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
	case USB_HUB_PR_FS:
		break;
	case USB_HUB_PR_HS_SINGLE_TT:
		dev_dbg(hub_dev, "Single TT\n");
		hub->tt.hub = hdev;
		break;
	case USB_HUB_PR_HS_MULTI_TT:
		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;
	case USB_HUB_PR_SS:
		/* USB 3.0 hubs don't have a TT */
		break;
	default:
		dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",
			hdev->descriptor.bDeviceProtocol);
		break;
L
Linus Torvalds 已提交
1505 1506
	}

1507
	/* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
1508
	switch (wHubCharacteristics & HUB_CHAR_TTTT) {
1509 1510 1511
	case HUB_TTTT_8_BITS:
		if (hdev->descriptor.bDeviceProtocol != 0) {
			hub->tt.think_time = 666;
1512 1513
			dev_dbg(hub_dev, "TT requires at most %d "
					"FS bit times (%d ns)\n",
1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534
				8, hub->tt.think_time);
		}
		break;
	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);
		break;
	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);
		break;
	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);
		break;
L
Linus Torvalds 已提交
1535 1536 1537
	}

	/* probe() zeroes hub->indicator[] */
1538
	if (wHubCharacteristics & HUB_CHAR_PORTIND) {
L
Linus Torvalds 已提交
1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549
		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);
1550
	if (ret) {
L
Linus Torvalds 已提交
1551 1552 1553
		message = "can't get hub status";
		goto fail;
	}
1554
	hcd = bus_to_hcd(hdev->bus);
1555
	if (hdev == hdev->bus->root_hub) {
1556 1557 1558
		if (hcd->power_budget > 0)
			hdev->bus_mA = hcd->power_budget;
		else
1559
			hdev->bus_mA = full_load * maxchild;
1560 1561
		if (hdev->bus_mA >= full_load)
			hub->mA_per_port = full_load;
1562 1563 1564 1565
		else {
			hub->mA_per_port = hdev->bus_mA;
			hub->limited_power = 1;
		}
1566
	} else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
1567 1568 1569
		int remaining = hdev->bus_mA -
			hub->descriptor->bHubContrCurrent;

L
Linus Torvalds 已提交
1570 1571
		dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
			hub->descriptor->bHubContrCurrent);
1572 1573
		hub->limited_power = 1;

1574
		if (remaining < maxchild * unit_load)
1575
			dev_warn(hub_dev,
1576 1577
					"insufficient power available "
					"to use all downstream ports\n");
1578 1579
		hub->mA_per_port = unit_load;	/* 7.2.1 */

1580 1581 1582
	} else {	/* Self-powered external hub */
		/* FIXME: What about battery-powered external hubs that
		 * provide less current per port? */
1583
		hub->mA_per_port = full_load;
1584
	}
1585
	if (hub->mA_per_port < full_load)
1586 1587
		dev_dbg(hub_dev, "%umA bus power budget for each child\n",
				hub->mA_per_port);
L
Linus Torvalds 已提交
1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600

	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");

1601
	if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
L
Linus Torvalds 已提交
1602 1603 1604
		dev_dbg(hub_dev, "%sover-current condition exists\n",
			(hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");

1605 1606 1607 1608 1609 1610
	/* 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. */
L
Linus Torvalds 已提交
1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
	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)
1628
		hub->indicator[0] = INDICATOR_CYCLE;
L
Linus Torvalds 已提交
1629

1630 1631
	mutex_lock(&usb_port_peer_mutex);
	for (i = 0; i < maxchild; i++) {
1632 1633
		ret = usb_hub_create_port_device(hub, i + 1);
		if (ret < 0) {
L
Lan Tianyu 已提交
1634 1635
			dev_err(hub->intfdev,
				"couldn't create port%d device.\n", i + 1);
1636
			break;
1637 1638
		}
	}
1639
	hdev->maxchild = i;
1640 1641 1642 1643 1644 1645
	for (i = 0; i < hdev->maxchild; i++) {
		struct usb_port *port_dev = hub->ports[i];

		pm_runtime_put(&port_dev->dev);
	}

1646 1647 1648
	mutex_unlock(&usb_port_peer_mutex);
	if (ret < 0)
		goto fail;
L
Lan Tianyu 已提交
1649

1650
	/* Update the HCD's internal representation of this hub before hub_wq
1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661
	 * starts getting port status changes for devices under the hub.
	 */
	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;
		}
	}

1662 1663
	usb_hub_adjust_deviceremovable(hdev, hub->descriptor);

1664
	hub_activate(hub, HUB_INIT);
L
Linus Torvalds 已提交
1665 1666 1667
	return 0;

fail:
1668
	dev_err(hub_dev, "config failed, %s (err %d)\n",
L
Linus Torvalds 已提交
1669 1670 1671 1672 1673
			message, ret);
	/* hub_disconnect() frees urb and descriptor */
	return ret;
}

1674 1675 1676 1677
static void hub_release(struct kref *kref)
{
	struct usb_hub *hub = container_of(kref, struct usb_hub, kref);

1678
	usb_put_dev(hub->hdev);
1679 1680 1681 1682
	usb_put_intf(to_usb_interface(hub->intfdev));
	kfree(hub);
}

L
Linus Torvalds 已提交
1683 1684 1685 1686
static unsigned highspeed_hubs;

static void hub_disconnect(struct usb_interface *intf)
{
1687
	struct usb_hub *hub = usb_get_intfdata(intf);
1688
	struct usb_device *hdev = interface_to_usbdev(intf);
1689
	int port1;
L
Lan Tianyu 已提交
1690

1691 1692 1693 1694
	/*
	 * Stop adding new hub events. We do not want to block here and thus
	 * will not try to remove any pending work item.
	 */
1695
	hub->disconnected = 1;
L
Linus Torvalds 已提交
1696

1697 1698
	/* Disconnect all children and quiesce the hub */
	hub->error = 0;
1699
	hub_quiesce(hub, HUB_DISCONNECT);
1700

1701 1702
	mutex_lock(&usb_port_peer_mutex);

1703 1704 1705 1706 1707 1708
	/* Avoid races with recursively_mark_NOTATTACHED() */
	spin_lock_irq(&device_state_lock);
	port1 = hdev->maxchild;
	hdev->maxchild = 0;
	usb_set_intfdata(intf, NULL);
	spin_unlock_irq(&device_state_lock);
1709

1710 1711
	for (; port1 > 0; --port1)
		usb_hub_remove_port_device(hub, port1);
L
Linus Torvalds 已提交
1712

1713 1714
	mutex_unlock(&usb_port_peer_mutex);

1715
	if (hub->hdev->speed == USB_SPEED_HIGH)
L
Linus Torvalds 已提交
1716 1717 1718
		highspeed_hubs--;

	usb_free_urb(hub->urb);
L
Lan Tianyu 已提交
1719
	kfree(hub->ports);
1720 1721
	kfree(hub->descriptor);
	kfree(hub->status);
1722
	kfree(hub->buffer);
L
Linus Torvalds 已提交
1723

1724
	pm_suspend_ignore_children(&intf->dev, false);
1725
	kref_put(&hub->kref, hub_release);
L
Linus Torvalds 已提交
1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737
}

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);

1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
	/*
	 * Set default autosuspend delay as 0 to speedup bus suspend,
	 * based on the below considerations:
	 *
	 * - Unlike other drivers, the hub driver does not rely on the
	 *   autosuspend delay to provide enough time to handle a wakeup
	 *   event, and the submitted status URB is just to check future
	 *   change on hub downstream ports, so it is safe to do it.
	 *
	 * - The patch might cause one or more auto supend/resume for
	 *   below very rare devices when they are plugged into hub
	 *   first time:
	 *
	 *   	devices having trouble initializing, and disconnect
	 *   	themselves from the bus and then reconnect a second
	 *   	or so later
	 *
	 *   	devices just for downloading firmware, and disconnects
	 *   	themselves after completing it
	 *
	 *   For these quite rare devices, their drivers may change the
	 *   autosuspend delay of their parent hub in the probe() to one
	 *   appropriate value to avoid the subtle problem if someone
	 *   does care it.
	 *
	 * - The patch may cause one or more auto suspend/resume on
	 *   hub during running 'lsusb', but it is probably too
	 *   infrequent to worry about.
	 *
	 * - Change autosuspend delay of hub can avoid unnecessary auto
	 *   suspend timer for hub, also may decrease power consumption
	 *   of USB bus.
1770 1771 1772
	 *
	 * - If user has indicated to prevent autosuspend by passing
	 *   usbcore.autosuspend = -1 then keep autosuspend disabled.
1773
	 */
1774
#ifdef CONFIG_PM
1775 1776
	if (hdev->dev.power.autosuspend_delay >= 0)
		pm_runtime_set_autosuspend_delay(&hdev->dev, 0);
1777
#endif
1778

1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791
	/*
	 * Hubs have proper suspend/resume support, except for root hubs
	 * where the controller driver doesn't have bus_suspend and
	 * bus_resume methods.
	 */
	if (hdev->parent) {		/* normal device */
		usb_enable_autosuspend(hdev);
	} else {			/* root hub */
		const struct hc_driver *drv = bus_to_hcd(hdev->bus)->driver;

		if (drv->bus_suspend && drv->bus_resume)
			usb_enable_autosuspend(hdev);
	}
1792

1793
	if (hdev->level == MAX_TOPO_LEVEL) {
1794 1795
		dev_err(&intf->dev,
			"Unsupported bus topology: hub nested too deep\n");
1796 1797 1798
		return -E2BIG;
	}

1799 1800 1801 1802 1803 1804 1805
#ifdef	CONFIG_USB_OTG_BLACKLIST_HUB
	if (hdev->parent) {
		dev_warn(&intf->dev, "ignoring external hub\n");
		return -ENODEV;
	}
#endif

L
Linus Torvalds 已提交
1806 1807 1808 1809 1810
	/* 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:
1811
		dev_err(&intf->dev, "bad descriptor, ignoring hub\n");
L
Linus Torvalds 已提交
1812 1813 1814 1815 1816 1817 1818 1819 1820
		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;

1821 1822
	/* If it's not an interrupt in endpoint, we'd better punt! */
	if (!usb_endpoint_is_int_in(endpoint))
L
Linus Torvalds 已提交
1823 1824 1825
		goto descriptor_error;

	/* We found a hub */
1826
	dev_info(&intf->dev, "USB hub found\n");
L
Linus Torvalds 已提交
1827

1828
	hub = kzalloc(sizeof(*hub), GFP_KERNEL);
L
Linus Torvalds 已提交
1829
	if (!hub) {
1830
		dev_dbg(&intf->dev, "couldn't kmalloc hub struct\n");
L
Linus Torvalds 已提交
1831 1832 1833
		return -ENOMEM;
	}

1834
	kref_init(&hub->kref);
L
Linus Torvalds 已提交
1835 1836
	hub->intfdev = &intf->dev;
	hub->hdev = hdev;
D
David Howells 已提交
1837
	INIT_DELAYED_WORK(&hub->leds, led_work);
1838
	INIT_DELAYED_WORK(&hub->init_work, NULL);
1839
	INIT_WORK(&hub->events, hub_event);
1840
	usb_get_intf(intf);
1841
	usb_get_dev(hdev);
L
Linus Torvalds 已提交
1842

1843
	usb_set_intfdata(intf, hub);
1844
	intf->needs_remote_wakeup = 1;
1845
	pm_suspend_ignore_children(&intf->dev, true);
L
Linus Torvalds 已提交
1846 1847 1848 1849

	if (hdev->speed == USB_SPEED_HIGH)
		highspeed_hubs++;

1850 1851 1852
	if (id->driver_info & HUB_QUIRK_CHECK_PORT_AUTOSUSPEND)
		hub->quirk_check_port_auto_suspend = 1;

L
Linus Torvalds 已提交
1853 1854 1855
	if (hub_configure(hub, endpoint) >= 0)
		return 0;

1856
	hub_disconnect(intf);
L
Linus Torvalds 已提交
1857 1858 1859 1860 1861 1862
	return -ENODEV;
}

static int
hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
{
1863
	struct usb_device *hdev = interface_to_usbdev(intf);
1864
	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
L
Linus Torvalds 已提交
1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877

	/* 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++) {
1878
				if (hub->ports[i]->child == NULL)
L
Linus Torvalds 已提交
1879 1880 1881
					info->port[i] = 0;
				else
					info->port[i] =
1882
						hub->ports[i]->child->devnum;
L
Linus Torvalds 已提交
1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894
			}
		}
		spin_unlock_irq(&device_state_lock);

		return info->nports + 1;
		}

	default:
		return -ENOSYS;
	}
}

1895 1896 1897 1898 1899
/*
 * 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,
1900
		struct usb_dev_state ***ppowner)
1901
{
1902 1903
	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);

1904 1905 1906 1907 1908
	if (hdev->state == USB_STATE_NOTATTACHED)
		return -ENODEV;
	if (port1 == 0 || port1 > hdev->maxchild)
		return -EINVAL;

1909
	/* Devices not managed by the hub driver
1910 1911
	 * will always have maxchild equal to 0.
	 */
1912
	*ppowner = &(hub->ports[port1 - 1]->port_owner);
1913 1914 1915 1916
	return 0;
}

/* In the following three functions, the caller must hold hdev's lock */
1917
int usb_hub_claim_port(struct usb_device *hdev, unsigned port1,
1918
		       struct usb_dev_state *owner)
1919 1920
{
	int rc;
1921
	struct usb_dev_state **powner;
1922 1923 1924 1925 1926 1927 1928 1929 1930

	rc = find_port_owner(hdev, port1, &powner);
	if (rc)
		return rc;
	if (*powner)
		return -EBUSY;
	*powner = owner;
	return rc;
}
1931
EXPORT_SYMBOL_GPL(usb_hub_claim_port);
1932

1933
int usb_hub_release_port(struct usb_device *hdev, unsigned port1,
1934
			 struct usb_dev_state *owner)
1935 1936
{
	int rc;
1937
	struct usb_dev_state **powner;
1938 1939 1940 1941 1942 1943 1944 1945 1946

	rc = find_port_owner(hdev, port1, &powner);
	if (rc)
		return rc;
	if (*powner != owner)
		return -ENOENT;
	*powner = NULL;
	return rc;
}
1947
EXPORT_SYMBOL_GPL(usb_hub_release_port);
1948

1949
void usb_hub_release_all_ports(struct usb_device *hdev, struct usb_dev_state *owner)
1950
{
1951
	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
1952 1953
	int n;

L
Lan Tianyu 已提交
1954 1955 1956
	for (n = 0; n < hdev->maxchild; n++) {
		if (hub->ports[n]->port_owner == owner)
			hub->ports[n]->port_owner = NULL;
1957
	}
L
Lan Tianyu 已提交
1958

1959 1960 1961 1962 1963 1964 1965 1966 1967
}

/* 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;
1968
	hub = usb_hub_to_struct_hub(udev->parent);
L
Lan Tianyu 已提交
1969
	return !!hub->ports[udev->portnum - 1]->port_owner;
1970 1971
}

L
Linus Torvalds 已提交
1972 1973
static void recursively_mark_NOTATTACHED(struct usb_device *udev)
{
1974
	struct usb_hub *hub = usb_hub_to_struct_hub(udev);
L
Linus Torvalds 已提交
1975 1976 1977
	int i;

	for (i = 0; i < udev->maxchild; ++i) {
1978 1979
		if (hub->ports[i]->child)
			recursively_mark_NOTATTACHED(hub->ports[i]->child);
L
Linus Torvalds 已提交
1980
	}
1981
	if (udev->state == USB_STATE_SUSPENDED)
S
Sarah Sharp 已提交
1982
		udev->active_duration -= jiffies;
L
Linus Torvalds 已提交
1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
	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
	int wakeup = -1;
L
Linus Torvalds 已提交
2012 2013 2014 2015

	spin_lock_irqsave(&device_state_lock, flags);
	if (udev->state == USB_STATE_NOTATTACHED)
		;	/* do nothing */
D
David Brownell 已提交
2016
	else if (new_state != USB_STATE_NOTATTACHED) {
2017 2018 2019 2020 2021

		/* root hub wakeup capabilities are managed out-of-band
		 * and may involve silicon errata ... ignore them here.
		 */
		if (udev->parent) {
2022 2023 2024 2025
			if (udev->state == USB_STATE_SUSPENDED
					|| new_state == USB_STATE_SUSPENDED)
				;	/* No change to wakeup settings */
			else if (new_state == USB_STATE_CONFIGURED)
2026 2027 2028 2029
				wakeup = (udev->quirks &
					USB_QUIRK_IGNORE_REMOTE_WAKEUP) ? 0 :
					udev->actconfig->desc.bmAttributes &
					USB_CONFIG_ATT_WAKEUP;
2030
			else
2031
				wakeup = 0;
2032
		}
S
Sarah Sharp 已提交
2033 2034 2035 2036 2037 2038
		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;
2039
		udev->state = new_state;
D
David Brownell 已提交
2040
	} else
L
Linus Torvalds 已提交
2041 2042
		recursively_mark_NOTATTACHED(udev);
	spin_unlock_irqrestore(&device_state_lock, flags);
2043 2044
	if (wakeup >= 0)
		device_set_wakeup_capable(&udev->dev, wakeup);
L
Linus Torvalds 已提交
2045
}
2046
EXPORT_SYMBOL_GPL(usb_set_device_state);
L
Linus Torvalds 已提交
2047

2048
/*
2049 2050 2051 2052 2053 2054 2055
 * 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.
 *
2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070
 * 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.
2071 2072 2073 2074 2075
 *
 * 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.
2076
 */
2077
static void choose_devnum(struct usb_device *udev)
L
Linus Torvalds 已提交
2078 2079 2080 2081
{
	int		devnum;
	struct usb_bus	*bus = udev->bus;

2082
	/* be safe when more hub events are proceed in parallel */
2083
	mutex_lock(&bus->devnum_next_mutex);
2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094
	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);
2095
		bus->devnum_next = (devnum >= 127 ? 1 : devnum + 1);
2096
	}
L
Linus Torvalds 已提交
2097 2098 2099 2100
	if (devnum < 128) {
		set_bit(devnum, bus->devmap.devicemap);
		udev->devnum = devnum;
	}
2101
	mutex_unlock(&bus->devnum_next_mutex);
L
Linus Torvalds 已提交
2102 2103
}

2104
static void release_devnum(struct usb_device *udev)
L
Linus Torvalds 已提交
2105 2106 2107 2108 2109 2110 2111
{
	if (udev->devnum > 0) {
		clear_bit(udev->devnum, udev->bus->devmap.devicemap);
		udev->devnum = -1;
	}
}

2112
static void update_devnum(struct usb_device *udev, int devnum)
2113 2114 2115 2116 2117 2118
{
	/* The address for a WUSB device is managed by wusbcore. */
	if (!udev->wusb)
		udev->devnum = devnum;
}

2119 2120 2121 2122 2123 2124 2125 2126 2127
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);
}

2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139
static void hub_disconnect_children(struct usb_device *udev)
{
	struct usb_hub *hub = usb_hub_to_struct_hub(udev);
	int i;

	/* Free up all the children before we remove this device */
	for (i = 0; i < udev->maxchild; i++) {
		if (hub->ports[i]->child)
			usb_disconnect(&hub->ports[i]->child);
	}
}

L
Linus Torvalds 已提交
2140 2141 2142 2143 2144 2145 2146 2147
/**
 * 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.
2148
 * If *pdev is a root hub then the caller must hold the usb_bus_idr_lock,
2149
 * which protects the set of root hubs as well as the list of buses.
L
Linus Torvalds 已提交
2150 2151 2152 2153 2154 2155 2156 2157
 *
 * 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)
{
2158 2159
	struct usb_port *port_dev = NULL;
	struct usb_device *udev = *pdev;
P
Peter Chen 已提交
2160 2161
	struct usb_hub *hub = NULL;
	int port1 = 1;
L
Linus Torvalds 已提交
2162 2163 2164

	/* mark the device as inactive, so any further urb submissions for
	 * this device (and any of its children) will fail immediately.
L
Lucas De Marchi 已提交
2165
	 * this quiesces everything except pending urbs.
L
Linus Torvalds 已提交
2166 2167
	 */
	usb_set_device_state(udev, USB_STATE_NOTATTACHED);
2168 2169
	dev_info(&udev->dev, "USB disconnect, device number %d\n",
			udev->devnum);
L
Linus Torvalds 已提交
2170

2171 2172
	usb_lock_device(udev);

2173
	hub_disconnect_children(udev);
L
Linus Torvalds 已提交
2174 2175 2176 2177 2178

	/* 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.
	 */
2179
	dev_dbg(&udev->dev, "unregistering device\n");
L
Linus Torvalds 已提交
2180
	usb_disable_device(udev, 0);
2181
	usb_hcd_synchronize_unlinks(udev);
L
Linus Torvalds 已提交
2182

2183
	if (udev->parent) {
2184 2185 2186
		port1 = udev->portnum;
		hub = usb_hub_to_struct_hub(udev->parent);
		port_dev = hub->ports[port1 - 1];
2187 2188 2189

		sysfs_remove_link(&udev->dev.kobj, "port");
		sysfs_remove_link(&port_dev->dev.kobj, "device");
2190

2191 2192 2193 2194 2195 2196
		/*
		 * As usb_port_runtime_resume() de-references udev, make
		 * sure no resumes occur during removal
		 */
		if (!test_and_set_bit(port1, hub->child_usage_bits))
			pm_runtime_get_sync(&port_dev->dev);
2197 2198
	}

A
Alan Stern 已提交
2199
	usb_remove_ep_devs(&udev->ep0);
2200 2201 2202
	usb_unlock_device(udev);

	/* Unregister the device.  The device driver is responsible
A
Alan Stern 已提交
2203 2204
	 * for de-configuring the device and invoking the remove-device
	 * notifier chain (used by usbfs and possibly others).
2205 2206
	 */
	device_del(&udev->dev);
2207

2208
	/* Free the device number and delete the parent's children[]
L
Linus Torvalds 已提交
2209 2210
	 * (or root_hub) pointer.
	 */
2211
	release_devnum(udev);
L
Linus Torvalds 已提交
2212 2213 2214 2215 2216 2217

	/* Avoid races with recursively_mark_NOTATTACHED() */
	spin_lock_irq(&device_state_lock);
	*pdev = NULL;
	spin_unlock_irq(&device_state_lock);

2218 2219 2220
	if (port_dev && test_and_clear_bit(port1, hub->child_usage_bits))
		pm_runtime_put(&port_dev->dev);

2221 2222
	hub_free_dev(udev);

2223
	put_device(&udev->dev);
L
Linus Torvalds 已提交
2224 2225
}

2226
#ifdef CONFIG_USB_ANNOUNCE_NEW_DEVICES
L
Linus Torvalds 已提交
2227 2228 2229 2230
static void show_string(struct usb_device *udev, char *id, char *string)
{
	if (!string)
		return;
2231
	dev_info(&udev->dev, "%s: %s\n", id, string);
L
Linus Torvalds 已提交
2232 2233
}

2234 2235 2236 2237 2238
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));
2239 2240
	dev_info(&udev->dev,
		"New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
2241 2242 2243 2244 2245 2246 2247
		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);
}
L
Linus Torvalds 已提交
2248
#else
2249
static inline void announce_device(struct usb_device *udev) { }
L
Linus Torvalds 已提交
2250 2251 2252
#endif


2253
/**
A
Alan Stern 已提交
2254
 * usb_enumerate_device_otg - FIXME (usbcore-internal)
2255 2256
 * @udev: newly addressed device (in ADDRESS state)
 *
A
Alan Stern 已提交
2257
 * Finish enumeration for On-The-Go devices
2258 2259
 *
 * Return: 0 if successful. A negative error code otherwise.
2260
 */
A
Alan Stern 已提交
2261
static int usb_enumerate_device_otg(struct usb_device *udev)
L
Linus Torvalds 已提交
2262
{
2263
	int err = 0;
L
Linus Torvalds 已提交
2264 2265 2266 2267 2268 2269 2270 2271 2272 2273

#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) {
F
Felipe Balbi 已提交
2274
		struct usb_otg_descriptor	*desc = NULL;
L
Linus Torvalds 已提交
2275
		struct usb_bus			*bus = udev->bus;
2276
		unsigned			port1 = udev->portnum;
L
Linus Torvalds 已提交
2277 2278

		/* descriptor may appear anywhere in config */
2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304
		err = __usb_get_extra_descriptor(udev->rawdescriptors[0],
				le16_to_cpu(udev->config[0].desc.wTotalLength),
				USB_DT_OTG, (void **) &desc);
		if (err || !(desc->bmAttributes & USB_OTG_HNP))
			return 0;

		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,
				USB_DEVICE_B_HNP_ENABLE,
				0, NULL, 0,
				USB_CTRL_SET_TIMEOUT);
			if (err < 0) {
				/*
				 * OTG MESSAGE: report errors here,
				 * customize to match your product.
				 */
				dev_err(&udev->dev, "can't set HNP mode: %d\n",
									err);
				bus->b_hnp_enable = 0;
L
Linus Torvalds 已提交
2305
			}
2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318
		} else if (desc->bLength == sizeof
				(struct usb_otg_descriptor)) {
			/* Set a_alt_hnp_support for legacy otg device */
			err = usb_control_msg(udev,
				usb_sndctrlpipe(udev, 0),
				USB_REQ_SET_FEATURE, 0,
				USB_DEVICE_A_ALT_HNP_SUPPORT,
				0, NULL, 0,
				USB_CTRL_SET_TIMEOUT);
			if (err < 0)
				dev_err(&udev->dev,
					"set a_alt_hnp_support failed: %d\n",
					err);
L
Linus Torvalds 已提交
2319 2320 2321
		}
	}
#endif
2322 2323 2324 2325 2326
	return err;
}


/**
A
Alan Stern 已提交
2327
 * usb_enumerate_device - Read device configs/intfs/otg (usbcore-internal)
2328 2329 2330 2331 2332 2333 2334 2335 2336
 * @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.
2337 2338
 *
 * Return: 0 if successful. A negative error code otherwise.
2339
 */
A
Alan Stern 已提交
2340
static int usb_enumerate_device(struct usb_device *udev)
2341 2342
{
	int err;
2343
	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
L
Linus Torvalds 已提交
2344

2345 2346 2347
	if (udev->config == NULL) {
		err = usb_get_configuration(udev);
		if (err < 0) {
2348 2349 2350
			if (err != -ENODEV)
				dev_err(&udev->dev, "can't read configurations, error %d\n",
						err);
2351
			return err;
2352 2353
		}
	}
2354 2355 2356 2357 2358 2359 2360

	/* 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);

A
Alan Stern 已提交
2361
	err = usb_enumerate_device_otg(udev);
2362 2363 2364
	if (err < 0)
		return err;

2365
	if (IS_ENABLED(CONFIG_USB_OTG_WHITELIST) && hcd->tpl_support &&
2366
		!is_targeted(udev)) {
2367 2368 2369
		/* Maybe it can talk to us, though we can't talk to it.
		 * (Includes HNP test device.)
		 */
2370 2371
		if (IS_ENABLED(CONFIG_USB_OTG) && (udev->bus->b_hnp_enable
			|| udev->bus->is_b_host)) {
2372 2373 2374 2375 2376 2377 2378
			err = usb_port_suspend(udev, PMSG_AUTO_SUSPEND);
			if (err < 0)
				dev_dbg(&udev->dev, "HNP fail, %d\n", err);
		}
		return -ENOTSUPP;
	}

2379 2380 2381
	usb_detect_interface_quirks(udev);

	return 0;
2382 2383
}

2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394
static void set_usb_port_removable(struct usb_device *udev)
{
	struct usb_device *hdev = udev->parent;
	struct usb_hub *hub;
	u8 port = udev->portnum;
	u16 wHubCharacteristics;
	bool removable = true;

	if (!hdev)
		return;

2395
	hub = usb_hub_to_struct_hub(udev->parent);
2396

2397 2398 2399 2400 2401 2402 2403 2404 2405
	/*
	 * If the platform firmware has provided information about a port,
	 * use that to determine whether it's removable.
	 */
	switch (hub->ports[udev->portnum - 1]->connect_type) {
	case USB_PORT_CONNECT_TYPE_HOT_PLUG:
		udev->removable = USB_DEVICE_REMOVABLE;
		return;
	case USB_PORT_CONNECT_TYPE_HARD_WIRED:
2406
	case USB_PORT_NOT_USED:
2407 2408
		udev->removable = USB_DEVICE_FIXED;
		return;
2409 2410
	default:
		break;
2411 2412 2413 2414 2415 2416
	}

	/*
	 * Otherwise, check whether the hub knows whether a port is removable
	 * or not
	 */
2417 2418 2419 2420 2421 2422
	wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);

	if (!(wHubCharacteristics & HUB_CHAR_COMPOUND))
		return;

	if (hub_is_superspeed(hdev)) {
2423 2424
		if (le16_to_cpu(hub->descriptor->u.ss.DeviceRemovable)
				& (1 << port))
2425 2426 2427 2428 2429 2430 2431 2432 2433 2434
			removable = false;
	} else {
		if (hub->descriptor->u.hs.DeviceRemovable[port / 8] & (1 << (port % 8)))
			removable = false;
	}

	if (removable)
		udev->removable = USB_DEVICE_REMOVABLE;
	else
		udev->removable = USB_DEVICE_FIXED;
2435

2436
}
2437 2438 2439 2440 2441

/**
 * usb_new_device - perform initial device setup (usbcore-internal)
 * @udev: newly addressed device (in ADDRESS state)
 *
A
Alan Stern 已提交
2442 2443
 * This is called with devices which have been detected but not fully
 * enumerated.  The device descriptor is available, but not descriptors
2444 2445
 * for any device configuration.  The caller must have locked either
 * the parent hub (if udev is a normal device) or else the
2446
 * usb_bus_idr_lock (if udev is a root hub).  The parent's pointer to
2447 2448 2449 2450 2451 2452
 * udev has already been installed, but udev is not yet visible through
 * sysfs or other filesystem code.
 *
 * 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.
2453 2454 2455 2456 2457
 *
 * Return: Whether the device is configured properly or not. Zero if the
 * interface was registered with the driver core; else a negative errno
 * value.
 *
2458 2459 2460 2461 2462
 */
int usb_new_device(struct usb_device *udev)
{
	int err;

2463 2464 2465 2466 2467 2468 2469 2470
	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);
	}

2471 2472
	/* Tell the runtime-PM framework the device is active */
	pm_runtime_set_active(&udev->dev);
2473
	pm_runtime_get_noresume(&udev->dev);
2474
	pm_runtime_use_autosuspend(&udev->dev);
2475 2476
	pm_runtime_enable(&udev->dev);

2477 2478 2479 2480 2481
	/* By default, forbid autosuspend for all devices.  It will be
	 * allowed for hubs during binding.
	 */
	usb_disable_autosuspend(udev);

A
Alan Stern 已提交
2482
	err = usb_enumerate_device(udev);	/* Read descriptors */
2483 2484
	if (err < 0)
		goto fail;
2485 2486 2487
	dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n",
			udev->devnum, udev->bus->busnum,
			(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
2488 2489 2490 2491
	/* export the usbdev device-node for libusb */
	udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
			(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));

A
Alan Stern 已提交
2492 2493
	/* Tell the world! */
	announce_device(udev);
2494

2495 2496 2497 2498 2499 2500 2501 2502
	if (udev->serial)
		add_device_randomness(udev->serial, strlen(udev->serial));
	if (udev->product)
		add_device_randomness(udev->product, strlen(udev->product));
	if (udev->manufacturer)
		add_device_randomness(udev->manufacturer,
				      strlen(udev->manufacturer));

2503
	device_enable_async_suspend(&udev->dev);
2504

2505
	/* check whether the hub or firmware marks this port as non-removable */
2506 2507 2508
	if (udev->parent)
		set_usb_port_removable(udev);

2509
	/* Register the device.  The device driver is responsible
A
Alan Stern 已提交
2510 2511
	 * for configuring the device and invoking the add-device
	 * notifier chain (used by usbfs and possibly others).
2512
	 */
2513
	err = device_add(&udev->dev);
L
Linus Torvalds 已提交
2514 2515 2516 2517
	if (err) {
		dev_err(&udev->dev, "can't device_add, error %d\n", err);
		goto fail;
	}
2518

2519 2520
	/* Create link files between child device and usb port device. */
	if (udev->parent) {
2521
		struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
2522 2523
		int port1 = udev->portnum;
		struct usb_port	*port_dev = hub->ports[port1 - 1];
2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535

		err = sysfs_create_link(&udev->dev.kobj,
				&port_dev->dev.kobj, "port");
		if (err)
			goto fail;

		err = sysfs_create_link(&port_dev->dev.kobj,
				&udev->dev.kobj, "device");
		if (err) {
			sysfs_remove_link(&udev->dev.kobj, "port");
			goto fail;
		}
2536

2537 2538
		if (!test_and_set_bit(port1, hub->child_usage_bits))
			pm_runtime_get_sync(&port_dev->dev);
2539 2540
	}

A
Alan Stern 已提交
2541
	(void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
2542 2543
	usb_mark_last_busy(udev);
	pm_runtime_put_sync_autosuspend(&udev->dev);
2544
	return err;
L
Linus Torvalds 已提交
2545 2546 2547

fail:
	usb_set_device_state(udev, USB_STATE_NOTATTACHED);
2548 2549
	pm_runtime_disable(&udev->dev);
	pm_runtime_set_suspended(&udev->dev);
2550
	return err;
L
Linus Torvalds 已提交
2551 2552
}

2553 2554

/**
R
Randy Dunlap 已提交
2555 2556 2557 2558 2559
 * 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.
2560 2561 2562
 *
 * We share a lock (that we have) with device_del(), so we need to
 * defer its call.
2563 2564
 *
 * Return: 0.
2565 2566 2567 2568 2569 2570
 */
int usb_deauthorize_device(struct usb_device *usb_dev)
{
	usb_lock_device(usb_dev);
	if (usb_dev->authorized == 0)
		goto out_unauthorized;
2571

2572 2573
	usb_dev->authorized = 0;
	usb_set_configuration(usb_dev, -1);
2574

2575 2576 2577 2578 2579 2580 2581 2582 2583
out_unauthorized:
	usb_unlock_device(usb_dev);
	return 0;
}


int usb_authorize_device(struct usb_device *usb_dev)
{
	int result = 0, c;
2584

2585 2586 2587
	usb_lock_device(usb_dev);
	if (usb_dev->authorized == 1)
		goto out_authorized;
2588

2589 2590 2591 2592 2593 2594
	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;
	}
2595 2596 2597 2598 2599 2600 2601 2602

	if (usb_dev->wusb) {
		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;
		}
2603
	}
2604

2605 2606 2607 2608
	usb_dev->authorized = 1;
	/* Choose and set the configuration.  This registers the interfaces
	 * with the driver core and lets interface drivers bind to them.
	 */
2609
	c = usb_choose_configuration(usb_dev);
2610 2611 2612 2613 2614 2615 2616 2617 2618 2619
	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");
2620

2621
error_device_descriptor:
2622
	usb_autosuspend_device(usb_dev);
2623 2624
error_autoresume:
out_authorized:
2625
	usb_unlock_device(usb_dev);	/* complements locktree */
2626 2627 2628
	return result;
}

2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654
/*
 * Return 1 if port speed is SuperSpeedPlus, 0 otherwise
 * check it from the link protocol field of the current speed ID attribute.
 * current speed ID is got from ext port status request. Sublink speed attribute
 * table is returned with the hub BOS SSP device capability descriptor
 */
static int port_speed_is_ssp(struct usb_device *hdev, int speed_id)
{
	int ssa_count;
	u32 ss_attr;
	int i;
	struct usb_ssp_cap_descriptor *ssp_cap = hdev->bos->ssp_cap;

	if (!ssp_cap)
		return 0;

	ssa_count = le32_to_cpu(ssp_cap->bmAttributes) &
		USB_SSP_SUBLINK_SPEED_ATTRIBS;

	for (i = 0; i <= ssa_count; i++) {
		ss_attr = le32_to_cpu(ssp_cap->bmSublinkSpeedAttr[i]);
		if (speed_id == (ss_attr & USB_SSP_SUBLINK_SPEED_SSID))
			return !!(ss_attr & USB_SSP_SUBLINK_SPEED_LP);
	}
	return 0;
}
2655

2656 2657 2658 2659 2660 2661
/* 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;
2662
	hcd = bus_to_hcd(hub->hdev->bus);
2663 2664 2665 2666
	return hcd->wireless;
}


L
Linus Torvalds 已提交
2667 2668 2669 2670
#define PORT_RESET_TRIES	5
#define SET_ADDRESS_TRIES	2
#define GET_DESCRIPTOR_TRIES	2
#define SET_CONFIG_TRIES	(2 * (use_both_schemes + 1))
2671
#define USE_NEW_SCHEME(i)	((i) / 2 == (int)old_scheme_first)
L
Linus Torvalds 已提交
2672 2673 2674

#define HUB_ROOT_RESET_TIME	50	/* times are in msec */
#define HUB_SHORT_RESET_TIME	10
A
Andiry Xu 已提交
2675
#define HUB_BH_RESET_TIME	50
L
Linus Torvalds 已提交
2676
#define HUB_LONG_RESET_TIME	200
S
Sarah Sharp 已提交
2677
#define HUB_RESET_TIMEOUT	800
L
Linus Torvalds 已提交
2678

2679 2680 2681 2682 2683 2684 2685 2686 2687
/*
 * "New scheme" enumeration causes an extra state transition to be
 * exposed to an xhci host and causes USB3 devices to receive control
 * commands in the default state.  This has been seen to cause
 * enumeration failures, so disable this enumeration scheme for USB3
 * devices.
 */
static bool use_new_scheme(struct usb_device *udev, int retry)
{
2688
	if (udev->speed >= USB_SPEED_SUPER)
2689 2690 2691 2692 2693
		return false;

	return USE_NEW_SCHEME(retry);
}

2694
/* Is a USB 3.0 port in the Inactive or Compliance Mode state?
2695 2696
 * Port worm reset is required to recover
 */
2697 2698
static bool hub_port_warm_reset_required(struct usb_hub *hub, int port1,
		u16 portstatus)
2699
{
2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710
	u16 link_state;

	if (!hub_is_superspeed(hub->hdev))
		return false;

	if (test_bit(port1, hub->warm_reset_bits))
		return true;

	link_state = portstatus & USB_PORT_STAT_LINK_STATE;
	return link_state == USB_SS_PORT_LS_SS_INACTIVE
		|| link_state == USB_SS_PORT_LS_COMP_MOD;
2711 2712
}

L
Linus Torvalds 已提交
2713
static int hub_port_wait_reset(struct usb_hub *hub, int port1,
A
Andiry Xu 已提交
2714
			struct usb_device *udev, unsigned int delay, bool warm)
L
Linus Torvalds 已提交
2715 2716 2717 2718
{
	int delay_time, ret;
	u16 portstatus;
	u16 portchange;
2719
	u32 ext_portstatus = 0;
L
Linus Torvalds 已提交
2720 2721 2722 2723 2724 2725 2726 2727

	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 */
2728 2729 2730 2731 2732 2733 2734 2735
		if (hub_is_superspeedplus(hub->hdev))
			ret = hub_ext_port_status(hub, port1,
						  HUB_EXT_PORT_STATUS,
						  &portstatus, &portchange,
						  &ext_portstatus);
		else
			ret = hub_port_status(hub, port1, &portstatus,
					      &portchange);
L
Linus Torvalds 已提交
2736 2737 2738
		if (ret < 0)
			return ret;

2739
		/* The port state is unknown until the reset completes. */
S
Sarah Sharp 已提交
2740 2741
		if (!(portstatus & USB_PORT_STAT_RESET))
			break;
L
Linus Torvalds 已提交
2742 2743 2744 2745 2746

		/* switch to the long delay after two short delay failures */
		if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
			delay = HUB_LONG_RESET_TIME;

2747 2748 2749
		dev_dbg(&hub->ports[port1 - 1]->dev,
				"not %sreset yet, waiting %dms\n",
				warm ? "warm " : "", delay);
L
Linus Torvalds 已提交
2750 2751
	}

S
Sarah Sharp 已提交
2752 2753 2754
	if ((portstatus & USB_PORT_STAT_RESET))
		return -EBUSY;

2755
	if (hub_port_warm_reset_required(hub, port1, portstatus))
S
Sarah Sharp 已提交
2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777
		return -ENOTCONN;

	/* Device went away? */
	if (!(portstatus & USB_PORT_STAT_CONNECTION))
		return -ENOTCONN;

	/* bomb out completely if the connection bounced.  A USB 3.0
	 * connection may bounce if multiple warm resets were issued,
	 * but the device may have successfully re-connected. Ignore it.
	 */
	if (!hub_is_superspeed(hub->hdev) &&
			(portchange & USB_PORT_STAT_C_CONNECTION))
		return -ENOTCONN;

	if (!(portstatus & USB_PORT_STAT_ENABLE))
		return -EBUSY;

	if (!udev)
		return 0;

	if (hub_is_wusb(hub))
		udev->speed = USB_SPEED_WIRELESS;
2778 2779 2780 2781
	else if (hub_is_superspeedplus(hub->hdev) &&
		 port_speed_is_ssp(hub->hdev, ext_portstatus &
				   USB_EXT_PORT_STAT_RX_SPEED_ID))
		udev->speed = USB_SPEED_SUPER_PLUS;
S
Sarah Sharp 已提交
2782 2783 2784 2785 2786 2787 2788 2789 2790
	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;
L
Linus Torvalds 已提交
2791 2792
}

A
Andiry Xu 已提交
2793
/* Handle port reset and port warm(BH) reset (for USB3 protocol ports) */
L
Linus Torvalds 已提交
2794
static int hub_port_reset(struct usb_hub *hub, int port1,
A
Andiry Xu 已提交
2795
			struct usb_device *udev, unsigned int delay, bool warm)
L
Linus Torvalds 已提交
2796 2797
{
	int i, status;
2798
	u16 portchange, portstatus;
2799
	struct usb_port *port_dev = hub->ports[port1 - 1];
L
Linus Torvalds 已提交
2800

2801 2802
	if (!hub_is_superspeed(hub->hdev)) {
		if (warm) {
A
Andiry Xu 已提交
2803 2804 2805 2806
			dev_err(hub->intfdev, "only USB3 hub support "
						"warm reset\n");
			return -EINVAL;
		}
2807 2808 2809 2810
		/* 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);
2811 2812 2813 2814 2815
	} else if (!warm) {
		/*
		 * If the caller hasn't explicitly requested a warm reset,
		 * double check and see if one is needed.
		 */
2816 2817 2818 2819
		if (hub_port_status(hub, port1, &portstatus, &portchange) == 0)
			if (hub_port_warm_reset_required(hub, port1,
							portstatus))
				warm = true;
A
Andiry Xu 已提交
2820
	}
2821
	clear_bit(port1, hub->warm_reset_bits);
2822

L
Linus Torvalds 已提交
2823 2824
	/* Reset the port */
	for (i = 0; i < PORT_RESET_TRIES; i++) {
A
Andiry Xu 已提交
2825 2826 2827
		status = set_port_feature(hub->hdev, port1, (warm ?
					USB_PORT_FEAT_BH_PORT_RESET :
					USB_PORT_FEAT_RESET));
2828 2829 2830
		if (status == -ENODEV) {
			;	/* The hub is gone */
		} else if (status) {
2831 2832 2833
			dev_err(&port_dev->dev,
					"cannot %sreset (err = %d)\n",
					warm ? "warm " : "", status);
A
Andiry Xu 已提交
2834 2835 2836
		} else {
			status = hub_port_wait_reset(hub, port1, udev, delay,
								warm);
2837
			if (status && status != -ENOTCONN && status != -ENODEV)
L
Linus Torvalds 已提交
2838 2839 2840 2841 2842
				dev_dbg(hub->intfdev,
						"port_wait_reset: err = %d\n",
						status);
		}

2843
		/* Check for disconnect or reset */
A
Andiry Xu 已提交
2844
		if (status == 0 || status == -ENOTCONN || status == -ENODEV) {
2845 2846
			usb_clear_port_feature(hub->hdev, port1,
					USB_PORT_FEAT_C_RESET);
2847 2848 2849 2850

			if (!hub_is_superspeed(hub->hdev))
				goto done;

2851 2852 2853 2854 2855 2856 2857
			usb_clear_port_feature(hub->hdev, port1,
					USB_PORT_FEAT_C_BH_PORT_RESET);
			usb_clear_port_feature(hub->hdev, port1,
					USB_PORT_FEAT_C_PORT_LINK_STATE);
			usb_clear_port_feature(hub->hdev, port1,
					USB_PORT_FEAT_C_CONNECTION);

2858 2859 2860 2861 2862 2863 2864 2865
			/*
			 * If a USB 3.0 device migrates from reset to an error
			 * state, re-issue the warm reset.
			 */
			if (hub_port_status(hub, port1,
					&portstatus, &portchange) < 0)
				goto done;

2866 2867
			if (!hub_port_warm_reset_required(hub, port1,
					portstatus))
2868 2869 2870 2871 2872 2873 2874
				goto done;

			/*
			 * If the port is in SS.Inactive or Compliance Mode, the
			 * hot or warm reset failed.  Try another warm reset.
			 */
			if (!warm) {
2875 2876
				dev_dbg(&port_dev->dev,
						"hot reset failed, warm reset\n");
2877 2878
				warm = true;
			}
L
Linus Torvalds 已提交
2879 2880
		}

2881 2882 2883
		dev_dbg(&port_dev->dev,
				"not enabled, trying %sreset again...\n",
				warm ? "warm " : "");
L
Linus Torvalds 已提交
2884 2885 2886
		delay = HUB_LONG_RESET_TIME;
	}

2887
	dev_err(&port_dev->dev, "Cannot enable. Maybe the USB cable is bad?\n");
L
Linus Torvalds 已提交
2888

A
Andiry Xu 已提交
2889
done:
2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909
	if (status == 0) {
		/* TRSTRCY = 10 ms; plus some extra */
		msleep(10 + 40);
		if (udev) {
			struct usb_hcd *hcd = bus_to_hcd(udev->bus);

			update_devnum(udev, 0);
			/* The xHC may think the device is already reset,
			 * so ignore the status.
			 */
			if (hcd->driver->reset_device)
				hcd->driver->reset_device(hcd, udev);

			usb_set_device_state(udev, USB_STATE_DEFAULT);
		}
	} else {
		if (udev)
			usb_set_device_state(udev, USB_STATE_NOTATTACHED);
	}

2910
	if (!hub_is_superspeed(hub->hdev))
A
Andiry Xu 已提交
2911
		up_read(&ehci_cf_port_reset_rwsem);
2912

A
Andiry Xu 已提交
2913
	return status;
2914 2915
}

2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931
/* 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;
}

D
Dan Williams 已提交
2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945
static void usb_lock_port(struct usb_port *port_dev)
		__acquires(&port_dev->status_lock)
{
	mutex_lock(&port_dev->status_lock);
	__acquire(&port_dev->status_lock);
}

static void usb_unlock_port(struct usb_port *port_dev)
		__releases(&port_dev->status_lock)
{
	mutex_unlock(&port_dev->status_lock);
	__release(&port_dev->status_lock);
}

A
Alan Stern 已提交
2946
#ifdef	CONFIG_PM
L
Linus Torvalds 已提交
2947

2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963
/* 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;
}
2964 2965 2966 2967 2968 2969

/* 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,
2970
		int status, u16 portchange, u16 portstatus)
2971
{
2972
	struct usb_port *port_dev = hub->ports[port1 - 1];
2973
	int retries = 3;
2974

2975
 retry:
2976 2977 2978 2979 2980
	/* Is a warm reset needed to recover the connection? */
	if (status == 0 && udev->reset_resume
		&& hub_port_warm_reset_required(hub, port1, portstatus)) {
		/* pass */;
	}
2981
	/* Is the device still present? */
2982
	else if (status || port_is_suspended(hub, portstatus) ||
2983
			!port_is_power_on(hub, portstatus)) {
2984 2985
		if (status >= 0)
			status = -ENODEV;
2986 2987 2988 2989 2990 2991 2992 2993
	} else if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
		if (retries--) {
			usleep_range(200, 300);
			status = hub_port_status(hub, port1, &portstatus,
							     &portchange);
			goto retry;
		}
		status = -ENODEV;
2994 2995
	}

2996 2997 2998 2999 3000 3001 3002 3003 3004
	/* 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;
	}
3005 3006

	if (status) {
3007 3008
		dev_dbg(&port_dev->dev, "status %04x.%04x after resume, %d\n",
				portchange, portstatus, status);
3009 3010 3011 3012
	} else if (udev->reset_resume) {

		/* Late port handoff can set status-change bits */
		if (portchange & USB_PORT_STAT_C_CONNECTION)
3013
			usb_clear_port_feature(hub->hdev, port1,
3014 3015
					USB_PORT_FEAT_C_CONNECTION);
		if (portchange & USB_PORT_STAT_C_ENABLE)
3016
			usb_clear_port_feature(hub->hdev, port1,
3017 3018 3019 3020 3021 3022
					USB_PORT_FEAT_C_ENABLE);
	}

	return status;
}

3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066
int usb_disable_ltm(struct usb_device *udev)
{
	struct usb_hcd *hcd = bus_to_hcd(udev->bus);

	/* Check if the roothub and device supports LTM. */
	if (!usb_device_supports_ltm(hcd->self.root_hub) ||
			!usb_device_supports_ltm(udev))
		return 0;

	/* Clear Feature LTM Enable can only be sent if the device is
	 * configured.
	 */
	if (!udev->actconfig)
		return 0;

	return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
			USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
			USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
			USB_CTRL_SET_TIMEOUT);
}
EXPORT_SYMBOL_GPL(usb_disable_ltm);

void usb_enable_ltm(struct usb_device *udev)
{
	struct usb_hcd *hcd = bus_to_hcd(udev->bus);

	/* Check if the roothub and device supports LTM. */
	if (!usb_device_supports_ltm(hcd->self.root_hub) ||
			!usb_device_supports_ltm(udev))
		return;

	/* Set Feature LTM Enable can only be sent if the device is
	 * configured.
	 */
	if (!udev->actconfig)
		return;

	usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
			USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
			USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
			USB_CTRL_SET_TIMEOUT);
}
EXPORT_SYMBOL_GPL(usb_enable_ltm);

3067
/*
3068
 * usb_enable_remote_wakeup - enable remote wakeup for a device
3069 3070
 * @udev: target device
 *
3071 3072 3073 3074 3075
 * For USB-2 devices: Set the device's remote wakeup feature.
 *
 * For USB-3 devices: Assume there's only one function on the device and
 * enable remote wake for the first interface.  FIXME if the interface
 * association descriptor shows there's more than one function.
3076
 */
3077
static int usb_enable_remote_wakeup(struct usb_device *udev)
3078
{
3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111
	if (udev->speed < USB_SPEED_SUPER)
		return 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);
	else
		return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
				USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE,
				USB_INTRF_FUNC_SUSPEND,
				USB_INTRF_FUNC_SUSPEND_RW |
					USB_INTRF_FUNC_SUSPEND_LP,
				NULL, 0, USB_CTRL_SET_TIMEOUT);
}

/*
 * usb_disable_remote_wakeup - disable remote wakeup for a device
 * @udev: target device
 *
 * For USB-2 devices: Clear the device's remote wakeup feature.
 *
 * For USB-3 devices: Assume there's only one function on the device and
 * disable remote wake for the first interface.  FIXME if the interface
 * association descriptor shows there's more than one function.
 */
static int usb_disable_remote_wakeup(struct usb_device *udev)
{
	if (udev->speed < USB_SPEED_SUPER)
		return 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);
	else
		return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3112 3113 3114 3115
				USB_REQ_CLEAR_FEATURE, USB_RECIP_INTERFACE,
				USB_INTRF_FUNC_SUSPEND,	0, NULL, 0,
				USB_CTRL_SET_TIMEOUT);
}
L
Linus Torvalds 已提交
3116

3117 3118 3119 3120 3121 3122 3123 3124 3125
/* Count of wakeup-enabled devices at or below udev */
static unsigned wakeup_enabled_descendants(struct usb_device *udev)
{
	struct usb_hub *hub = usb_hub_to_struct_hub(udev);

	return udev->do_remote_wakeup +
			(hub ? hub->wakeup_enabled_descendants : 0);
}

L
Linus Torvalds 已提交
3126
/*
A
Alan Stern 已提交
3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139
 * 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.
 *
L
Linus Torvalds 已提交
3140 3141 3142 3143 3144 3145 3146 3147
 * 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.
A
Alan Stern 已提交
3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162
 *
 * 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),
3163
 * Linux (2.6) currently has NO mechanisms to initiate that:  no hub_wq
A
Alan Stern 已提交
3164 3165
 * timer, no SRP, no requests through sysfs.
 *
3166 3167
 * If Runtime PM isn't enabled or used, non-SuperSpeed devices may not get
 * suspended until their bus goes into global suspend (i.e., the root
3168 3169 3170
 * hub is suspended).  Nevertheless, we change @udev->state to
 * USB_STATE_SUSPENDED as this is the device's "logical" state.  The actual
 * upstream port setting is stored in @udev->port_is_suspended.
A
Alan Stern 已提交
3171 3172
 *
 * Returns 0 on success, else negative errno.
L
Linus Torvalds 已提交
3173
 */
A
Alan Stern 已提交
3174
int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
L
Linus Torvalds 已提交
3175
{
3176 3177
	struct usb_hub	*hub = usb_hub_to_struct_hub(udev->parent);
	struct usb_port *port_dev = hub->ports[udev->portnum - 1];
A
Alan Stern 已提交
3178 3179
	int		port1 = udev->portnum;
	int		status;
3180
	bool		really_suspend = true;
L
Linus Torvalds 已提交
3181

D
Dan Williams 已提交
3182 3183
	usb_lock_port(port_dev);

L
Linus Torvalds 已提交
3184 3185 3186 3187 3188 3189
	/* 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.
	 */
3190
	if (udev->do_remote_wakeup) {
3191
		status = usb_enable_remote_wakeup(udev);
3192
		if (status) {
A
Alan Stern 已提交
3193 3194
			dev_dbg(&udev->dev, "won't remote wakeup, status %d\n",
					status);
3195
			/* bail if autosuspend is requested */
3196
			if (PMSG_IS_AUTO(msg))
3197
				goto err_wakeup;
3198
		}
L
Linus Torvalds 已提交
3199 3200
	}

A
Andiry Xu 已提交
3201 3202 3203 3204
	/* disable USB2 hardware LPM */
	if (udev->usb2_hw_lpm_enabled == 1)
		usb_set_usb2_hardware_lpm(udev, 0);

3205
	if (usb_disable_ltm(udev)) {
3206 3207 3208 3209
		dev_err(&udev->dev, "Failed to disable LTM before suspend\n.");
		status = -ENOMEM;
		if (PMSG_IS_AUTO(msg))
			goto err_ltm;
3210
	}
3211
	if (usb_unlocked_disable_lpm(udev)) {
3212 3213 3214 3215
		dev_err(&udev->dev, "Failed to disable LPM before suspend\n.");
		status = -ENOMEM;
		if (PMSG_IS_AUTO(msg))
			goto err_lpm3;
3216 3217
	}

L
Linus Torvalds 已提交
3218
	/* see 7.1.7.6 */
3219
	if (hub_is_superspeed(hub->hdev))
3220
		status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U3);
3221

3222 3223 3224 3225 3226
	/*
	 * For system suspend, we do not need to enable the suspend feature
	 * on individual USB-2 ports.  The devices will automatically go
	 * into suspend a few ms after the root hub stops sending packets.
	 * The USB 2.0 spec calls this "global suspend".
3227 3228 3229 3230 3231
	 *
	 * However, many USB hubs have a bug: They don't relay wakeup requests
	 * from a downstream port if the port's suspend feature isn't on.
	 * Therefore we will turn on the suspend feature if udev or any of its
	 * descendants is enabled for remote wakeup.
3232
	 */
3233 3234 3235
	else if (PMSG_IS_AUTO(msg) || wakeup_enabled_descendants(udev) > 0)
		status = set_port_feature(hub->hdev, port1,
				USB_PORT_FEAT_SUSPEND);
3236 3237 3238 3239
	else {
		really_suspend = false;
		status = 0;
	}
L
Linus Torvalds 已提交
3240
	if (status) {
3241
		dev_dbg(&port_dev->dev, "can't suspend, status %d\n", status);
3242

3243 3244 3245 3246 3247
		/* Try to enable USB3 LPM and LTM again */
		usb_unlocked_enable_lpm(udev);
 err_lpm3:
		usb_enable_ltm(udev);
 err_ltm:
3248 3249 3250 3251
		/* Try to enable USB2 hardware LPM again */
		if (udev->usb2_hw_lpm_capable == 1)
			usb_set_usb2_hardware_lpm(udev, 1);

3252 3253 3254
		if (udev->do_remote_wakeup)
			(void) usb_disable_remote_wakeup(udev);
 err_wakeup:
3255

3256
		/* System sleep transitions should never fail */
3257
		if (!PMSG_IS_AUTO(msg))
3258
			status = 0;
L
Linus Torvalds 已提交
3259
	} else {
3260 3261 3262
		dev_dbg(&udev->dev, "usb %ssuspend, wakeup %d\n",
				(PMSG_IS_AUTO(msg) ? "auto-" : ""),
				udev->do_remote_wakeup);
3263 3264
		if (really_suspend) {
			udev->port_is_suspended = 1;
3265 3266

			/* device has up to 10 msec to fully suspend */
3267 3268
			msleep(10);
		}
3269
		usb_set_device_state(udev, USB_STATE_SUSPENDED);
L
Linus Torvalds 已提交
3270
	}
3271

3272 3273
	if (status == 0 && !udev->do_remote_wakeup && udev->persist_enabled
			&& test_and_clear_bit(port1, hub->child_usage_bits))
3274
		pm_runtime_put_sync(&port_dev->dev);
3275

3276
	usb_mark_last_busy(hub->hdev);
D
Dan Williams 已提交
3277 3278

	usb_unlock_port(port_dev);
L
Linus Torvalds 已提交
3279 3280 3281 3282
	return status;
}

/*
3283 3284
 * If the USB "suspend" state is in use (rather than "global suspend"),
 * many devices will be individually taken out of suspend state using
3285
 * special "resume" signaling.  This routine kicks in shortly after
L
Linus Torvalds 已提交
3286 3287 3288
 * 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.
3289 3290 3291
 *
 * If @udev->reset_resume is set then the device is reset before the
 * status check is done.
L
Linus Torvalds 已提交
3292
 */
3293
static int finish_port_resume(struct usb_device *udev)
L
Linus Torvalds 已提交
3294
{
3295
	int	status = 0;
3296
	u16	devstatus = 0;
L
Linus Torvalds 已提交
3297 3298

	/* caller owns the udev device lock */
3299 3300
	dev_dbg(&udev->dev, "%s\n",
		udev->reset_resume ? "finish reset-resume" : "finish resume");
L
Linus Torvalds 已提交
3301 3302 3303 3304

	/* 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()
3305
	 * during many timeouts, but hub_wq can't suspend until later.
L
Linus Torvalds 已提交
3306 3307 3308 3309 3310
	 */
	usb_set_device_state(udev, udev->actconfig
			? USB_STATE_CONFIGURED
			: USB_STATE_ADDRESS);

3311 3312 3313 3314 3315
	/* 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.
	 */
3316 3317 3318 3319 3320 3321 3322
	if (udev->reset_resume) {
		/*
		 * If the device morphs or switches modes when it is reset,
		 * we don't want to perform a reset-resume.  We'll fail the
		 * resume, which will cause a logical disconnect, and then
		 * the device will be rediscovered.
		 */
3323
 retry_reset_resume:
3324 3325 3326 3327 3328
		if (udev->quirks & USB_QUIRK_RESET)
			status = -ENODEV;
		else
			status = usb_reset_and_verify_device(udev);
	}
3329

3330 3331
	/* 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,
L
Linus Torvalds 已提交
3332 3333
	 * and device drivers will know about any resume quirks.
	 */
3334
	if (status == 0) {
3335
		devstatus = 0;
3336
		status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
3337 3338 3339 3340 3341 3342 3343

		/* 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;
		}
3344
	}
3345

A
Alan Stern 已提交
3346 3347 3348
	if (status) {
		dev_dbg(&udev->dev, "gone after usb resume? status %d\n",
				status);
3349 3350 3351 3352 3353 3354 3355
	/*
	 * There are a few quirky devices which violate the standard
	 * by claiming to have remote wakeup enabled after a reset,
	 * which crash if the feature is cleared, hence check for
	 * udev->reset_resume
	 */
	} else if (udev->actconfig && !udev->reset_resume) {
3356
		if (udev->speed < USB_SPEED_SUPER) {
3357
			if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP))
3358
				status = usb_disable_remote_wakeup(udev);
3359 3360 3361 3362 3363
		} else {
			status = usb_get_status(udev, USB_RECIP_INTERFACE, 0,
					&devstatus);
			if (!status && devstatus & (USB_INTRF_STAT_FUNC_RW_CAP
					| USB_INTRF_STAT_FUNC_RW))
3364
				status = usb_disable_remote_wakeup(udev);
3365
		}
3366 3367 3368 3369 3370

		if (status)
			dev_dbg(&udev->dev,
				"disable remote wakeup, status %d\n",
				status);
L
Linus Torvalds 已提交
3371 3372 3373 3374 3375
		status = 0;
	}
	return status;
}

3376 3377 3378
/*
 * There are some SS USB devices which take longer time for link training.
 * XHCI specs 4.19.4 says that when Link training is successful, port
3379
 * sets CCS bit to 1. So if SW reads port status before successful link
3380 3381 3382 3383 3384 3385 3386 3387 3388 3389
 * training, then it will not find device to be present.
 * USB Analyzer log with such buggy devices show that in some cases
 * device switch on the RX termination after long delay of host enabling
 * the VBUS. In few other cases it has been seen that device fails to
 * negotiate link training in first attempt. It has been
 * reported till now that few devices take as long as 2000 ms to train
 * the link after host enabling its VBUS and termination. Following
 * routine implements a 2000 ms timeout for link training. If in a case
 * link trains before timeout, loop will exit earlier.
 *
3390 3391 3392 3393
 * There are also some 2.0 hard drive based devices and 3.0 thumb
 * drives that, when plugged into a 2.0 only port, take a long
 * time to set CCS after VBUS enable.
 *
3394 3395 3396 3397
 * FIXME: If a device was connected before suspend, but was removed
 * while system was asleep, then the loop in the following routine will
 * only exit at timeout.
 *
3398
 * This routine should only be called when persist is enabled.
3399
 */
3400
static int wait_for_connected(struct usb_device *udev,
3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412
		struct usb_hub *hub, int *port1,
		u16 *portchange, u16 *portstatus)
{
	int status = 0, delay_ms = 0;

	while (delay_ms < 2000) {
		if (status || *portstatus & USB_PORT_STAT_CONNECTION)
			break;
		msleep(20);
		delay_ms += 20;
		status = hub_port_status(hub, *port1, portstatus, portchange);
	}
3413
	dev_dbg(&udev->dev, "Waited %dms for CONNECT\n", delay_ms);
3414 3415 3416
	return status;
}

A
Alan Stern 已提交
3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427
/*
 * 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.
 *
3428 3429
 * If @udev->reset_resume is set then this routine won't check that the
 * port is still enabled.  Furthermore, finish_port_resume() above will
3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440
 * 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.
 *
3441
 * This facility can be dangerous.  Although usb_reset_and_verify_device() makes
3442
 * every effort to insure that the same device is present after the
3443 3444 3445 3446 3447 3448
 * 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.
 *
A
Alan Stern 已提交
3449 3450
 * Returns 0 on success, else negative errno.
 */
A
Alan Stern 已提交
3451
int usb_port_resume(struct usb_device *udev, pm_message_t msg)
L
Linus Torvalds 已提交
3452
{
3453 3454
	struct usb_hub	*hub = usb_hub_to_struct_hub(udev->parent);
	struct usb_port *port_dev = hub->ports[udev->portnum  - 1];
A
Alan Stern 已提交
3455 3456 3457
	int		port1 = udev->portnum;
	int		status;
	u16		portchange, portstatus;
3458

3459
	if (!test_and_set_bit(port1, hub->child_usage_bits)) {
3460 3461 3462 3463 3464 3465 3466 3467
		status = pm_runtime_get_sync(&port_dev->dev);
		if (status < 0) {
			dev_dbg(&udev->dev, "can't resume usb port, status %d\n",
					status);
			return status;
		}
	}

D
Dan Williams 已提交
3468 3469
	usb_lock_port(port_dev);

3470 3471
	/* Skip the initial Clear-Suspend step for a remote wakeup */
	status = hub_port_status(hub, port1, &portstatus, &portchange);
3472
	if (status == 0 && !port_is_suspended(hub, portstatus))
3473
		goto SuspendCleared;
L
Linus Torvalds 已提交
3474 3475

	/* see 7.1.7.7; affects power usage, but not budgeting */
3476
	if (hub_is_superspeed(hub->hdev))
3477
		status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U0);
3478
	else
3479
		status = usb_clear_port_feature(hub->hdev,
3480
				port1, USB_PORT_FEAT_SUSPEND);
L
Linus Torvalds 已提交
3481
	if (status) {
3482
		dev_dbg(&port_dev->dev, "can't resume, status %d\n", status);
L
Linus Torvalds 已提交
3483
	} else {
3484
		/* drive resume for USB_RESUME_TIMEOUT msec */
3485
		dev_dbg(&udev->dev, "usb %sresume\n",
3486
				(PMSG_IS_AUTO(msg) ? "auto-" : ""));
3487
		msleep(USB_RESUME_TIMEOUT);
L
Linus Torvalds 已提交
3488 3489 3490 3491 3492

		/* Virtual root hubs can trigger on GET_PORT_STATUS to
		 * stop resume signaling.  Then finish the resume
		 * sequence.
		 */
3493
		status = hub_port_status(hub, port1, &portstatus, &portchange);
3494

3495 3496 3497 3498
		/* TRSMRCY = 10 msec */
		msleep(10);
	}

3499
 SuspendCleared:
3500
	if (status == 0) {
A
Alan Stern 已提交
3501
		udev->port_is_suspended = 0;
3502 3503
		if (hub_is_superspeed(hub->hdev)) {
			if (portchange & USB_PORT_STAT_C_LINK_STATE)
3504
				usb_clear_port_feature(hub->hdev, port1,
3505 3506 3507
					USB_PORT_FEAT_C_PORT_LINK_STATE);
		} else {
			if (portchange & USB_PORT_STAT_C_SUSPEND)
3508
				usb_clear_port_feature(hub->hdev, port1,
3509 3510
						USB_PORT_FEAT_C_SUSPEND);
		}
L
Linus Torvalds 已提交
3511 3512
	}

3513 3514
	if (udev->persist_enabled)
		status = wait_for_connected(udev, hub, &port1, &portchange,
3515 3516
				&portstatus);

3517 3518
	status = check_port_resume_type(udev,
			hub, port1, status, portchange, portstatus);
3519 3520 3521 3522 3523
	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);
A
Andiry Xu 已提交
3524 3525 3526 3527
	} else  {
		/* Try to enable USB2 hardware LPM */
		if (udev->usb2_hw_lpm_capable == 1)
			usb_set_usb2_hardware_lpm(udev, 1);
3528

3529 3530
		/* Try to enable USB3 LTM and LPM */
		usb_enable_ltm(udev);
3531
		usb_unlocked_enable_lpm(udev);
3532
	}
A
Andiry Xu 已提交
3533

D
Dan Williams 已提交
3534 3535
	usb_unlock_port(port_dev);

L
Linus Torvalds 已提交
3536 3537 3538
	return status;
}

3539
int usb_remote_wakeup(struct usb_device *udev)
L
Linus Torvalds 已提交
3540 3541 3542
{
	int	status = 0;

D
Dan Williams 已提交
3543
	usb_lock_device(udev);
L
Linus Torvalds 已提交
3544
	if (udev->state == USB_STATE_SUSPENDED) {
3545
		dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
3546 3547 3548 3549 3550
		status = usb_autoresume_device(udev);
		if (status == 0) {
			/* Let the drivers do their thing, then... */
			usb_autosuspend_device(udev);
		}
L
Linus Torvalds 已提交
3551
	}
D
Dan Williams 已提交
3552
	usb_unlock_device(udev);
L
Linus Torvalds 已提交
3553 3554 3555
	return status;
}

3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596
/* Returns 1 if there was a remote wakeup and a connect status change. */
static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
		u16 portstatus, u16 portchange)
		__must_hold(&port_dev->status_lock)
{
	struct usb_port *port_dev = hub->ports[port - 1];
	struct usb_device *hdev;
	struct usb_device *udev;
	int connect_change = 0;
	int ret;

	hdev = hub->hdev;
	udev = port_dev->child;
	if (!hub_is_superspeed(hdev)) {
		if (!(portchange & USB_PORT_STAT_C_SUSPEND))
			return 0;
		usb_clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND);
	} else {
		if (!udev || udev->state != USB_STATE_SUSPENDED ||
				 (portstatus & USB_PORT_STAT_LINK_STATE) !=
				 USB_SS_PORT_LS_U0)
			return 0;
	}

	if (udev) {
		/* TRSMRCY = 10 msec */
		msleep(10);

		usb_unlock_port(port_dev);
		ret = usb_remote_wakeup(udev);
		usb_lock_port(port_dev);
		if (ret < 0)
			connect_change = 1;
	} else {
		ret = -ENODEV;
		hub_port_disable(hub, port, 1);
	}
	dev_dbg(&port_dev->dev, "resume, status %d\n", ret);
	return connect_change;
}

3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611
static int check_ports_changed(struct usb_hub *hub)
{
	int port1;

	for (port1 = 1; port1 <= hub->hdev->maxchild; ++port1) {
		u16 portstatus, portchange;
		int status;

		status = hub_port_status(hub, port1, &portstatus, &portchange);
		if (!status && portchange)
			return 1;
	}
	return 0;
}

D
David Brownell 已提交
3612
static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
L
Linus Torvalds 已提交
3613
{
3614
	struct usb_hub		*hub = usb_get_intfdata(intf);
L
Linus Torvalds 已提交
3615 3616
	struct usb_device	*hdev = hub->hdev;
	unsigned		port1;
3617
	int			status;
L
Linus Torvalds 已提交
3618

3619 3620 3621 3622 3623
	/*
	 * Warn if children aren't already suspended.
	 * Also, add up the number of wakeup-enabled descendants.
	 */
	hub->wakeup_enabled_descendants = 0;
L
Linus Torvalds 已提交
3624
	for (port1 = 1; port1 <= hdev->maxchild; port1++) {
3625 3626
		struct usb_port *port_dev = hub->ports[port1 - 1];
		struct usb_device *udev = port_dev->child;
L
Linus Torvalds 已提交
3627

3628
		if (udev && udev->can_submit) {
3629 3630
			dev_warn(&port_dev->dev, "device %s not suspended yet\n",
					dev_name(&udev->dev));
3631
			if (PMSG_IS_AUTO(msg))
3632
				return -EBUSY;
3633
		}
3634 3635 3636
		if (udev)
			hub->wakeup_enabled_descendants +=
					wakeup_enabled_descendants(udev);
L
Linus Torvalds 已提交
3637
	}
3638 3639 3640 3641 3642 3643 3644 3645 3646 3647

	if (hdev->do_remote_wakeup && hub->quirk_check_port_auto_suspend) {
		/* check if there are changes pending on hub ports */
		if (check_ports_changed(hub)) {
			if (PMSG_IS_AUTO(msg))
				return -EBUSY;
			pm_wakeup_event(&hdev->dev, 2000);
		}
	}

3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658
	if (hub_is_superspeed(hdev) && hdev->do_remote_wakeup) {
		/* Enable hub to send remote wakeup for all ports. */
		for (port1 = 1; port1 <= hdev->maxchild; port1++) {
			status = set_port_feature(hdev,
					port1 |
					USB_PORT_FEAT_REMOTE_WAKE_CONNECT |
					USB_PORT_FEAT_REMOTE_WAKE_DISCONNECT |
					USB_PORT_FEAT_REMOTE_WAKE_OVER_CURRENT,
					USB_PORT_FEAT_REMOTE_WAKE_MASK);
		}
	}
L
Linus Torvalds 已提交
3659

3660
	dev_dbg(&intf->dev, "%s\n", __func__);
3661

3662
	/* stop hub_wq and related activity */
3663
	hub_quiesce(hub, HUB_SUSPEND);
3664
	return 0;
L
Linus Torvalds 已提交
3665 3666 3667 3668
}

static int hub_resume(struct usb_interface *intf)
{
3669
	struct usb_hub *hub = usb_get_intfdata(intf);
3670

3671
	dev_dbg(&intf->dev, "%s\n", __func__);
3672
	hub_activate(hub, HUB_RESUME);
L
Linus Torvalds 已提交
3673 3674 3675
	return 0;
}

3676
static int hub_reset_resume(struct usb_interface *intf)
A
Alan Stern 已提交
3677
{
3678
	struct usb_hub *hub = usb_get_intfdata(intf);
A
Alan Stern 已提交
3679

3680
	dev_dbg(&intf->dev, "%s\n", __func__);
3681
	hub_activate(hub, HUB_RESET_RESUME);
A
Alan Stern 已提交
3682 3683 3684
	return 0;
}

3685 3686 3687 3688 3689 3690
/**
 * 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
3691 3692 3693 3694
 * 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.
3695 3696 3697 3698 3699 3700 3701 3702
 */
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);

3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727
static const char * const usb3_lpm_names[]  = {
	"U0",
	"U1",
	"U2",
	"U3",
};

/*
 * Send a Set SEL control transfer to the device, prior to enabling
 * device-initiated U1 or U2.  This lets the device know the exit latencies from
 * the time the device initiates a U1 or U2 exit, to the time it will receive a
 * packet from the host.
 *
 * This function will fail if the SEL or PEL values for udev are greater than
 * the maximum allowed values for the link state to be enabled.
 */
static int usb_req_set_sel(struct usb_device *udev, enum usb3_link_state state)
{
	struct usb_set_sel_req *sel_values;
	unsigned long long u1_sel;
	unsigned long long u1_pel;
	unsigned long long u2_sel;
	unsigned long long u2_pel;
	int ret;

3728 3729 3730
	if (udev->state != USB_STATE_CONFIGURED)
		return 0;

3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750
	/* Convert SEL and PEL stored in ns to us */
	u1_sel = DIV_ROUND_UP(udev->u1_params.sel, 1000);
	u1_pel = DIV_ROUND_UP(udev->u1_params.pel, 1000);
	u2_sel = DIV_ROUND_UP(udev->u2_params.sel, 1000);
	u2_pel = DIV_ROUND_UP(udev->u2_params.pel, 1000);

	/*
	 * Make sure that the calculated SEL and PEL values for the link
	 * state we're enabling aren't bigger than the max SEL/PEL
	 * value that will fit in the SET SEL control transfer.
	 * Otherwise the device would get an incorrect idea of the exit
	 * latency for the link state, and could start a device-initiated
	 * U1/U2 when the exit latencies are too high.
	 */
	if ((state == USB3_LPM_U1 &&
				(u1_sel > USB3_LPM_MAX_U1_SEL_PEL ||
				 u1_pel > USB3_LPM_MAX_U1_SEL_PEL)) ||
			(state == USB3_LPM_U2 &&
			 (u2_sel > USB3_LPM_MAX_U2_SEL_PEL ||
			  u2_pel > USB3_LPM_MAX_U2_SEL_PEL))) {
3751
		dev_dbg(&udev->dev, "Device-initiated %s disabled due to long SEL %llu us or PEL %llu us\n",
3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912
				usb3_lpm_names[state], u1_sel, u1_pel);
		return -EINVAL;
	}

	/*
	 * If we're enabling device-initiated LPM for one link state,
	 * but the other link state has a too high SEL or PEL value,
	 * just set those values to the max in the Set SEL request.
	 */
	if (u1_sel > USB3_LPM_MAX_U1_SEL_PEL)
		u1_sel = USB3_LPM_MAX_U1_SEL_PEL;

	if (u1_pel > USB3_LPM_MAX_U1_SEL_PEL)
		u1_pel = USB3_LPM_MAX_U1_SEL_PEL;

	if (u2_sel > USB3_LPM_MAX_U2_SEL_PEL)
		u2_sel = USB3_LPM_MAX_U2_SEL_PEL;

	if (u2_pel > USB3_LPM_MAX_U2_SEL_PEL)
		u2_pel = USB3_LPM_MAX_U2_SEL_PEL;

	/*
	 * usb_enable_lpm() can be called as part of a failed device reset,
	 * which may be initiated by an error path of a mass storage driver.
	 * Therefore, use GFP_NOIO.
	 */
	sel_values = kmalloc(sizeof *(sel_values), GFP_NOIO);
	if (!sel_values)
		return -ENOMEM;

	sel_values->u1_sel = u1_sel;
	sel_values->u1_pel = u1_pel;
	sel_values->u2_sel = cpu_to_le16(u2_sel);
	sel_values->u2_pel = cpu_to_le16(u2_pel);

	ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
			USB_REQ_SET_SEL,
			USB_RECIP_DEVICE,
			0, 0,
			sel_values, sizeof *(sel_values),
			USB_CTRL_SET_TIMEOUT);
	kfree(sel_values);
	return ret;
}

/*
 * Enable or disable device-initiated U1 or U2 transitions.
 */
static int usb_set_device_initiated_lpm(struct usb_device *udev,
		enum usb3_link_state state, bool enable)
{
	int ret;
	int feature;

	switch (state) {
	case USB3_LPM_U1:
		feature = USB_DEVICE_U1_ENABLE;
		break;
	case USB3_LPM_U2:
		feature = USB_DEVICE_U2_ENABLE;
		break;
	default:
		dev_warn(&udev->dev, "%s: Can't %s non-U1 or U2 state.\n",
				__func__, enable ? "enable" : "disable");
		return -EINVAL;
	}

	if (udev->state != USB_STATE_CONFIGURED) {
		dev_dbg(&udev->dev, "%s: Can't %s %s state "
				"for unconfigured device.\n",
				__func__, enable ? "enable" : "disable",
				usb3_lpm_names[state]);
		return 0;
	}

	if (enable) {
		/*
		 * Now send the control transfer to enable device-initiated LPM
		 * for either U1 or U2.
		 */
		ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
				USB_REQ_SET_FEATURE,
				USB_RECIP_DEVICE,
				feature,
				0, NULL, 0,
				USB_CTRL_SET_TIMEOUT);
	} else {
		ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
				USB_REQ_CLEAR_FEATURE,
				USB_RECIP_DEVICE,
				feature,
				0, NULL, 0,
				USB_CTRL_SET_TIMEOUT);
	}
	if (ret < 0) {
		dev_warn(&udev->dev, "%s of device-initiated %s failed.\n",
				enable ? "Enable" : "Disable",
				usb3_lpm_names[state]);
		return -EBUSY;
	}
	return 0;
}

static int usb_set_lpm_timeout(struct usb_device *udev,
		enum usb3_link_state state, int timeout)
{
	int ret;
	int feature;

	switch (state) {
	case USB3_LPM_U1:
		feature = USB_PORT_FEAT_U1_TIMEOUT;
		break;
	case USB3_LPM_U2:
		feature = USB_PORT_FEAT_U2_TIMEOUT;
		break;
	default:
		dev_warn(&udev->dev, "%s: Can't set timeout for non-U1 or U2 state.\n",
				__func__);
		return -EINVAL;
	}

	if (state == USB3_LPM_U1 && timeout > USB3_LPM_U1_MAX_TIMEOUT &&
			timeout != USB3_LPM_DEVICE_INITIATED) {
		dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x, "
				"which is a reserved value.\n",
				usb3_lpm_names[state], timeout);
		return -EINVAL;
	}

	ret = set_port_feature(udev->parent,
			USB_PORT_LPM_TIMEOUT(timeout) | udev->portnum,
			feature);
	if (ret < 0) {
		dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x,"
				"error code %i\n", usb3_lpm_names[state],
				timeout, ret);
		return -EBUSY;
	}
	if (state == USB3_LPM_U1)
		udev->u1_params.timeout = timeout;
	else
		udev->u2_params.timeout = timeout;
	return 0;
}

/*
 * Enable the hub-initiated U1/U2 idle timeouts, and enable device-initiated
 * U1/U2 entry.
 *
 * We will attempt to enable U1 or U2, but there are no guarantees that the
 * control transfers to set the hub timeout or enable device-initiated U1/U2
 * will be successful.
 *
 * If we cannot set the parent hub U1/U2 timeout, we attempt to let the xHCI
 * driver know about it.  If that call fails, it should be harmless, and just
 * take up more slightly more bus bandwidth for unnecessary U1/U2 exit latency.
 */
static void usb_enable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
		enum usb3_link_state state)
{
3913
	int timeout, ret;
3914 3915 3916 3917 3918 3919 3920 3921 3922 3923
	__u8 u1_mel = udev->bos->ss_cap->bU1devExitLat;
	__le16 u2_mel = udev->bos->ss_cap->bU2DevExitLat;

	/* If the device says it doesn't have *any* exit latency to come out of
	 * U1 or U2, it's probably lying.  Assume it doesn't implement that link
	 * state.
	 */
	if ((state == USB3_LPM_U1 && u1_mel == 0) ||
			(state == USB3_LPM_U2 && u2_mel == 0))
		return;
3924

3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935
	/*
	 * First, let the device know about the exit latencies
	 * associated with the link state we're about to enable.
	 */
	ret = usb_req_set_sel(udev, state);
	if (ret < 0) {
		dev_warn(&udev->dev, "Set SEL for device-initiated %s failed.\n",
				usb3_lpm_names[state]);
		return;
	}

3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953
	/* We allow the host controller to set the U1/U2 timeout internally
	 * first, so that it can change its schedule to account for the
	 * additional latency to send data to a device in a lower power
	 * link state.
	 */
	timeout = hcd->driver->enable_usb3_lpm_timeout(hcd, udev, state);

	/* xHCI host controller doesn't want to enable this LPM state. */
	if (timeout == 0)
		return;

	if (timeout < 0) {
		dev_warn(&udev->dev, "Could not enable %s link state, "
				"xHCI error %i.\n", usb3_lpm_names[state],
				timeout);
		return;
	}

3954
	if (usb_set_lpm_timeout(udev, state, timeout)) {
3955 3956 3957 3958 3959
		/* If we can't set the parent hub U1/U2 timeout,
		 * device-initiated LPM won't be allowed either, so let the xHCI
		 * host know that this link state won't be enabled.
		 */
		hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state);
3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977
	} else {
		/* Only a configured device will accept the Set Feature
		 * U1/U2_ENABLE
		 */
		if (udev->actconfig)
			usb_set_device_initiated_lpm(udev, state, true);

		/* As soon as usb_set_lpm_timeout(timeout) returns 0, the
		 * hub-initiated LPM is enabled. Thus, LPM is enabled no
		 * matter the result of usb_set_device_initiated_lpm().
		 * The only difference is whether device is able to initiate
		 * LPM.
		 */
		if (state == USB3_LPM_U1)
			udev->usb3_lpm_u1_enabled = 1;
		else if (state == USB3_LPM_U2)
			udev->usb3_lpm_u2_enabled = 1;
	}
3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016
}

/*
 * Disable the hub-initiated U1/U2 idle timeouts, and disable device-initiated
 * U1/U2 entry.
 *
 * If this function returns -EBUSY, the parent hub will still allow U1/U2 entry.
 * If zero is returned, the parent will not allow the link to go into U1/U2.
 *
 * If zero is returned, device-initiated U1/U2 entry may still be enabled, but
 * it won't have an effect on the bus link state because the parent hub will
 * still disallow device-initiated U1/U2 entry.
 *
 * If zero is returned, the xHCI host controller may still think U1/U2 entry is
 * possible.  The result will be slightly more bus bandwidth will be taken up
 * (to account for U1/U2 exit latency), but it should be harmless.
 */
static int usb_disable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
		enum usb3_link_state state)
{
	switch (state) {
	case USB3_LPM_U1:
	case USB3_LPM_U2:
		break;
	default:
		dev_warn(&udev->dev, "%s: Can't disable non-U1 or U2 state.\n",
				__func__);
		return -EINVAL;
	}

	if (usb_set_lpm_timeout(udev, state, 0))
		return -EBUSY;

	usb_set_device_initiated_lpm(udev, state, false);

	if (hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state))
		dev_warn(&udev->dev, "Could not disable xHCI %s timeout, "
				"bus schedule bandwidth may be impacted.\n",
				usb3_lpm_names[state]);
4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028

	/* As soon as usb_set_lpm_timeout(0) return 0, hub initiated LPM
	 * is disabled. Hub will disallows link to enter U1/U2 as well,
	 * even device is initiating LPM. Hence LPM is disabled if hub LPM
	 * timeout set to 0, no matter device-initiated LPM is disabled or
	 * not.
	 */
	if (state == USB3_LPM_U1)
		udev->usb3_lpm_u1_enabled = 0;
	else if (state == USB3_LPM_U2)
		udev->usb3_lpm_u2_enabled = 0;

4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043
	return 0;
}

/*
 * Disable hub-initiated and device-initiated U1 and U2 entry.
 * Caller must own the bandwidth_mutex.
 *
 * This will call usb_enable_lpm() on failure, which will decrement
 * lpm_disable_count, and will re-enable LPM if lpm_disable_count reaches zero.
 */
int usb_disable_lpm(struct usb_device *udev)
{
	struct usb_hcd *hcd;

	if (!udev || !udev->parent ||
4044
			udev->speed < USB_SPEED_SUPER ||
4045 4046
			!udev->lpm_capable ||
			udev->state < USB_STATE_DEFAULT)
4047 4048 4049 4050 4051 4052 4053
		return 0;

	hcd = bus_to_hcd(udev->bus);
	if (!hcd || !hcd->driver->disable_usb3_lpm_timeout)
		return 0;

	udev->lpm_disable_count++;
4054
	if ((udev->u1_params.timeout == 0 && udev->u2_params.timeout == 0))
4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098
		return 0;

	/* If LPM is enabled, attempt to disable it. */
	if (usb_disable_link_state(hcd, udev, USB3_LPM_U1))
		goto enable_lpm;
	if (usb_disable_link_state(hcd, udev, USB3_LPM_U2))
		goto enable_lpm;

	return 0;

enable_lpm:
	usb_enable_lpm(udev);
	return -EBUSY;
}
EXPORT_SYMBOL_GPL(usb_disable_lpm);

/* Grab the bandwidth_mutex before calling usb_disable_lpm() */
int usb_unlocked_disable_lpm(struct usb_device *udev)
{
	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
	int ret;

	if (!hcd)
		return -EINVAL;

	mutex_lock(hcd->bandwidth_mutex);
	ret = usb_disable_lpm(udev);
	mutex_unlock(hcd->bandwidth_mutex);

	return ret;
}
EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);

/*
 * Attempt to enable device-initiated and hub-initiated U1 and U2 entry.  The
 * xHCI host policy may prevent U1 or U2 from being enabled.
 *
 * Other callers may have disabled link PM, so U1 and U2 entry will be disabled
 * until the lpm_disable_count drops to zero.  Caller must own the
 * bandwidth_mutex.
 */
void usb_enable_lpm(struct usb_device *udev)
{
	struct usb_hcd *hcd;
4099 4100
	struct usb_hub *hub;
	struct usb_port *port_dev;
4101 4102

	if (!udev || !udev->parent ||
4103
			udev->speed < USB_SPEED_SUPER ||
4104 4105
			!udev->lpm_capable ||
			udev->state < USB_STATE_DEFAULT)
4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119
		return;

	udev->lpm_disable_count--;
	hcd = bus_to_hcd(udev->bus);
	/* Double check that we can both enable and disable LPM.
	 * Device must be configured to accept set feature U1/U2 timeout.
	 */
	if (!hcd || !hcd->driver->enable_usb3_lpm_timeout ||
			!hcd->driver->disable_usb3_lpm_timeout)
		return;

	if (udev->lpm_disable_count > 0)
		return;

4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130
	hub = usb_hub_to_struct_hub(udev->parent);
	if (!hub)
		return;

	port_dev = hub->ports[udev->portnum - 1];

	if (port_dev->usb3_lpm_u1_permit)
		usb_enable_link_state(hcd, udev, USB3_LPM_U1);

	if (port_dev->usb3_lpm_u2_permit)
		usb_enable_link_state(hcd, udev, USB3_LPM_U2);
4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148
}
EXPORT_SYMBOL_GPL(usb_enable_lpm);

/* Grab the bandwidth_mutex before calling usb_enable_lpm() */
void usb_unlocked_enable_lpm(struct usb_device *udev)
{
	struct usb_hcd *hcd = bus_to_hcd(udev->bus);

	if (!hcd)
		return;

	mutex_lock(hcd->bandwidth_mutex);
	usb_enable_lpm(udev);
	mutex_unlock(hcd->bandwidth_mutex);
}
EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);


A
Alan Stern 已提交
4149 4150
#else	/* CONFIG_PM */

A
Alan Stern 已提交
4151 4152 4153
#define hub_suspend		NULL
#define hub_resume		NULL
#define hub_reset_resume	NULL
4154 4155 4156 4157 4158

int usb_disable_lpm(struct usb_device *udev)
{
	return 0;
}
4159
EXPORT_SYMBOL_GPL(usb_disable_lpm);
4160 4161

void usb_enable_lpm(struct usb_device *udev) { }
4162
EXPORT_SYMBOL_GPL(usb_enable_lpm);
4163 4164 4165 4166 4167

int usb_unlocked_disable_lpm(struct usb_device *udev)
{
	return 0;
}
4168
EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
4169 4170

void usb_unlocked_enable_lpm(struct usb_device *udev) { }
4171
EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
4172 4173 4174 4175 4176 4177 4178 4179 4180

int usb_disable_ltm(struct usb_device *udev)
{
	return 0;
}
EXPORT_SYMBOL_GPL(usb_disable_ltm);

void usb_enable_ltm(struct usb_device *udev) { }
EXPORT_SYMBOL_GPL(usb_enable_ltm);
A
Alan Stern 已提交
4181

4182 4183 4184 4185 4186 4187
static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
		u16 portstatus, u16 portchange)
{
	return 0;
}

A
Alan Stern 已提交
4188
#endif	/* CONFIG_PM */
A
Alan Stern 已提交
4189

L
Linus Torvalds 已提交
4190 4191 4192 4193 4194 4195

/* 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.
4196
 *
L
Linus Torvalds 已提交
4197 4198 4199 4200 4201 4202 4203 4204 4205
 * 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.
 */
4206
int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected)
L
Linus Torvalds 已提交
4207 4208 4209 4210
{
	int ret;
	u16 portchange, portstatus;
	unsigned connection = 0xffff;
4211 4212
	int total_time, stable_time = 0;
	struct usb_port *port_dev = hub->ports[port1 - 1];
L
Linus Torvalds 已提交
4213 4214 4215 4216 4217 4218 4219 4220

	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) {
4221 4222 4223
			if (!must_be_connected ||
			     (connection == USB_PORT_STAT_CONNECTION))
				stable_time += HUB_DEBOUNCE_STEP;
L
Linus Torvalds 已提交
4224 4225 4226 4227 4228 4229 4230 4231
			if (stable_time >= HUB_DEBOUNCE_STABLE)
				break;
		} else {
			stable_time = 0;
			connection = portstatus & USB_PORT_STAT_CONNECTION;
		}

		if (portchange & USB_PORT_STAT_C_CONNECTION) {
4232
			usb_clear_port_feature(hub->hdev, port1,
L
Linus Torvalds 已提交
4233 4234 4235 4236 4237 4238 4239 4240
					USB_PORT_FEAT_C_CONNECTION);
		}

		if (total_time >= HUB_DEBOUNCE_TIMEOUT)
			break;
		msleep(HUB_DEBOUNCE_STEP);
	}

4241 4242
	dev_dbg(&port_dev->dev, "debounce total %dms stable %dms status 0x%x\n",
			total_time, stable_time, portstatus);
L
Linus Torvalds 已提交
4243 4244 4245 4246 4247 4248

	if (stable_time < HUB_DEBOUNCE_STABLE)
		return -ETIMEDOUT;
	return portstatus;
}

4249
void usb_ep0_reinit(struct usb_device *udev)
L
Linus Torvalds 已提交
4250
{
4251 4252
	usb_disable_endpoint(udev, 0 + USB_DIR_IN, true);
	usb_disable_endpoint(udev, 0 + USB_DIR_OUT, true);
4253
	usb_enable_endpoint(udev, &udev->ep0, true);
L
Linus Torvalds 已提交
4254
}
4255
EXPORT_SYMBOL_GPL(usb_ep0_reinit);
L
Linus Torvalds 已提交
4256 4257 4258 4259

#define usb_sndaddr0pipe()	(PIPE_CONTROL << 30)
#define usb_rcvaddr0pipe()	((PIPE_CONTROL << 30) | USB_DIR_IN)

4260
static int hub_set_address(struct usb_device *udev, int devnum)
L
Linus Torvalds 已提交
4261 4262
{
	int retval;
4263
	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
L
Linus Torvalds 已提交
4264

4265 4266 4267 4268 4269
	/*
	 * The host controller will choose the device address,
	 * instead of the core having chosen it earlier
	 */
	if (!hcd->driver->address_device && devnum <= 1)
L
Linus Torvalds 已提交
4270 4271 4272 4273 4274
		return -EINVAL;
	if (udev->state == USB_STATE_ADDRESS)
		return 0;
	if (udev->state != USB_STATE_DEFAULT)
		return -EINVAL;
4275
	if (hcd->driver->address_device)
4276
		retval = hcd->driver->address_device(hcd, udev);
4277
	else
4278 4279 4280
		retval = usb_control_msg(udev, usb_sndaddr0pipe(),
				USB_REQ_SET_ADDRESS, 0, devnum, 0,
				NULL, 0, USB_CTRL_SET_TIMEOUT);
L
Linus Torvalds 已提交
4281
	if (retval == 0) {
4282
		update_devnum(udev, devnum);
4283
		/* Device now using proper address. */
L
Linus Torvalds 已提交
4284
		usb_set_device_state(udev, USB_STATE_ADDRESS);
4285
		usb_ep0_reinit(udev);
L
Linus Torvalds 已提交
4286 4287 4288 4289
	}
	return retval;
}

4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300
/*
 * There are reports of USB 3.0 devices that say they support USB 2.0 Link PM
 * when they're plugged into a USB 2.0 port, but they don't work when LPM is
 * enabled.
 *
 * Only enable USB 2.0 Link PM if the port is internal (hardwired), or the
 * device says it supports the new USB 2.0 Link PM errata by setting the BESL
 * support bit in the BOS descriptor.
 */
static void hub_set_initial_usb2_lpm_policy(struct usb_device *udev)
{
4301 4302
	struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
	int connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN;
4303 4304 4305 4306

	if (!udev->usb2_hw_lpm_capable)
		return;

4307 4308
	if (hub)
		connect_type = hub->ports[udev->portnum - 1]->connect_type;
4309

4310
	if ((udev->bos->ext_cap->bmAttributes & cpu_to_le32(USB_BESL_SUPPORT)) ||
4311 4312 4313 4314 4315 4316
			connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
		udev->usb2_hw_lpm_allowed = 1;
		usb_set_usb2_hardware_lpm(udev, 1);
	}
}

4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330
static int hub_enable_device(struct usb_device *udev)
{
	struct usb_hcd *hcd = bus_to_hcd(udev->bus);

	if (!hcd->driver->enable_device)
		return 0;
	if (udev->state == USB_STATE_ADDRESS)
		return 0;
	if (udev->state != USB_STATE_DEFAULT)
		return -EINVAL;

	return hcd->driver->enable_device(hcd, udev);
}

L
Linus Torvalds 已提交
4331 4332 4333 4334 4335
/* 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
D
Dan Williams 已提交
4336 4337 4338 4339
 * usb_reset_and_verify_device), the caller must own the device lock and
 * the port lock.  For a newly detected device that is not accessible
 * through any global pointers, it's not necessary to lock the device,
 * but it is still necessary to lock the port.
L
Linus Torvalds 已提交
4340 4341
 */
static int
4342
hub_port_init(struct usb_hub *hub, struct usb_device *udev, int port1,
L
Linus Torvalds 已提交
4343 4344 4345
		int retry_counter)
{
	struct usb_device	*hdev = hub->hdev;
4346
	struct usb_hcd		*hcd = bus_to_hcd(hdev->bus);
4347
	int			retries, operations, retval, i;
L
Linus Torvalds 已提交
4348 4349
	unsigned		delay = HUB_SHORT_RESET_TIME;
	enum usb_device_speed	oldspeed = udev->speed;
4350
	const char		*speed;
4351
	int			devnum = udev->devnum;
L
Linus Torvalds 已提交
4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366

	/* 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;

4367
	mutex_lock(hcd->address0_mutex);
L
Linus Torvalds 已提交
4368

4369 4370
	/* Reset the device; full speed may morph to high speed */
	/* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */
A
Andiry Xu 已提交
4371
	retval = hub_port_reset(hub, port1, udev, delay, false);
4372 4373 4374 4375
	if (retval < 0)		/* error or disconnect */
		goto fail;
	/* success, speed is known */

L
Linus Torvalds 已提交
4376 4377
	retval = -ENODEV;

4378 4379 4380
	/* Don't allow speed changes at reset, except usb 3.0 to faster */
	if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed &&
	    !(oldspeed == USB_SPEED_SUPER && udev->speed > oldspeed)) {
L
Linus Torvalds 已提交
4381 4382 4383 4384
		dev_dbg(&udev->dev, "device reset changed speed!\n");
		goto fail;
	}
	oldspeed = udev->speed;
4385

L
Linus Torvalds 已提交
4386 4387
	/* USB 2.0 section 5.5.3 talks about ep0 maxpacket ...
	 * it's fixed size except for full speed devices.
4388 4389
	 * For Wireless USB devices, ep0 max packet is always 512 (tho
	 * reported as 0xff in the device descriptor). WUSB1.0[4.8.1].
L
Linus Torvalds 已提交
4390 4391
	 */
	switch (udev->speed) {
4392
	case USB_SPEED_SUPER_PLUS:
4393
	case USB_SPEED_SUPER:
4394
	case USB_SPEED_WIRELESS:	/* fixed at 512 */
4395
		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
4396
		break;
L
Linus Torvalds 已提交
4397
	case USB_SPEED_HIGH:		/* fixed at 64 */
4398
		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
L
Linus Torvalds 已提交
4399 4400 4401 4402 4403 4404
		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.
		 */
4405
		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
L
Linus Torvalds 已提交
4406 4407
		break;
	case USB_SPEED_LOW:		/* fixed at 8 */
4408
		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(8);
L
Linus Torvalds 已提交
4409 4410 4411 4412
		break;
	default:
		goto fail;
	}
4413 4414 4415 4416 4417 4418

	if (udev->speed == USB_SPEED_WIRELESS)
		speed = "variable speed Wireless";
	else
		speed = usb_speed_string(udev->speed);

4419
	if (udev->speed < USB_SPEED_SUPER)
4420
		dev_info(&udev->dev,
4421 4422
				"%s %s USB device number %d using %s\n",
				(udev->config) ? "reset" : "new", speed,
4423
				devnum, udev->bus->controller->driver->name);
L
Linus Torvalds 已提交
4424 4425 4426 4427 4428 4429 4430

	/* 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) {
4431 4432 4433 4434 4435
		if (!hub->tt.hub) {
			dev_err(&udev->dev, "parent hub has no TT\n");
			retval = -EINVAL;
			goto fail;
		}
L
Linus Torvalds 已提交
4436 4437 4438
		udev->tt = &hub->tt;
		udev->ttport = port1;
	}
4439

L
Linus Torvalds 已提交
4440 4441 4442 4443 4444
	/* 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.
	 *
4445
	 * NOTE:  If use_new_scheme() is true we will start by issuing
L
Linus Torvalds 已提交
4446 4447 4448 4449 4450 4451
	 * 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.
	 */
4452
	for (retries = 0; retries < GET_DESCRIPTOR_TRIES; (++retries, msleep(100))) {
4453 4454 4455
		bool did_new_scheme = false;

		if (use_new_scheme(udev, retry_counter)) {
L
Linus Torvalds 已提交
4456 4457 4458
			struct usb_device_descriptor *buf;
			int r = 0;

4459 4460
			did_new_scheme = true;
			retval = hub_enable_device(udev);
4461 4462 4463 4464
			if (retval < 0) {
				dev_err(&udev->dev,
					"hub failed to enable device, error %d\n",
					retval);
4465
				goto fail;
4466
			}
4467

L
Linus Torvalds 已提交
4468 4469 4470 4471 4472 4473 4474
#define GET_DESCRIPTOR_BUFSIZE	64
			buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);
			if (!buf) {
				retval = -ENOMEM;
				continue;
			}

4475 4476 4477
			/* Retry on all errors; some devices are flakey.
			 * 255 is for WUSB devices, we actually need to use
			 * 512 (WUSB1.0[4.8.1]).
L
Linus Torvalds 已提交
4478
			 */
4479
			for (operations = 0; operations < 3; ++operations) {
L
Linus Torvalds 已提交
4480 4481 4482 4483 4484
				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,
4485
					initial_descriptor_timeout);
L
Linus Torvalds 已提交
4486
				switch (buf->bMaxPacketSize0) {
4487
				case 8: case 16: case 32: case 64: case 255:
L
Linus Torvalds 已提交
4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498
					if (buf->bDescriptorType ==
							USB_DT_DEVICE) {
						r = 0;
						break;
					}
					/* FALL THROUGH */
				default:
					if (r == 0)
						r = -EPROTO;
					break;
				}
4499 4500 4501 4502 4503 4504
				/*
				 * Some devices time out if they are powered on
				 * when already connected. They need a second
				 * reset. But only on the first attempt,
				 * lest we get into a time out/reset loop
				 */
4505
				if (r == 0  || (r == -ETIMEDOUT && retries == 0))
L
Linus Torvalds 已提交
4506 4507 4508 4509 4510 4511
					break;
			}
			udev->descriptor.bMaxPacketSize0 =
					buf->bMaxPacketSize0;
			kfree(buf);

A
Andiry Xu 已提交
4512
			retval = hub_port_reset(hub, port1, udev, delay, false);
L
Linus Torvalds 已提交
4513 4514 4515 4516 4517 4518 4519 4520 4521
			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) {
4522 4523 4524
				if (r != -ENODEV)
					dev_err(&udev->dev, "device descriptor read/64, error %d\n",
							r);
L
Linus Torvalds 已提交
4525 4526 4527 4528 4529 4530
				retval = -EMSGSIZE;
				continue;
			}
#undef GET_DESCRIPTOR_BUFSIZE
		}

4531 4532 4533 4534 4535
		/*
		 * If device is WUSB, we already assigned an
		 * unauthorized address in the Connect Ack sequence;
		 * authorization will assign the final address.
		 */
4536
		if (udev->wusb == 0) {
4537
			for (operations = 0; operations < SET_ADDRESS_TRIES; ++operations) {
4538 4539 4540 4541 4542 4543
				retval = hub_set_address(udev, devnum);
				if (retval >= 0)
					break;
				msleep(200);
			}
			if (retval < 0) {
4544 4545 4546
				if (retval != -ENODEV)
					dev_err(&udev->dev, "device not accepting address %d, error %d\n",
							devnum, retval);
4547 4548
				goto fail;
			}
4549
			if (udev->speed >= USB_SPEED_SUPER) {
4550 4551
				devnum = udev->devnum;
				dev_info(&udev->dev,
4552
						"%s SuperSpeed%s USB device number %d using %s\n",
4553
						(udev->config) ? "reset" : "new",
4554
					 (udev->speed == USB_SPEED_SUPER_PLUS) ? "Plus" : "",
4555
						devnum, udev->bus->controller->driver->name);
4556
			}
4557 4558 4559 4560 4561 4562

			/* cope with hardware quirkiness:
			 *  - let SET_ADDRESS settle, some device hardware wants it
			 *  - read ep0 maxpacket even for high and low speed,
			 */
			msleep(10);
4563 4564 4565 4566 4567
			/* use_new_scheme() checks the speed which may have
			 * changed since the initial look so we cache the result
			 * in did_new_scheme
			 */
			if (did_new_scheme)
L
Linus Torvalds 已提交
4568
				break;
4569
		}
L
Linus Torvalds 已提交
4570 4571 4572

		retval = usb_get_device_descriptor(udev, 8);
		if (retval < 8) {
4573 4574
			if (retval != -ENODEV)
				dev_err(&udev->dev,
4575 4576
					"device descriptor read/8, error %d\n",
					retval);
L
Linus Torvalds 已提交
4577 4578 4579 4580 4581 4582 4583 4584 4585 4586
			if (retval >= 0)
				retval = -EMSGSIZE;
		} else {
			retval = 0;
			break;
		}
	}
	if (retval)
		goto fail;

4587 4588 4589 4590 4591 4592
	/*
	 * Some superspeed devices have finished the link training process
	 * and attached to a superspeed hub port, but the device descriptor
	 * got from those devices show they aren't superspeed devices. Warm
	 * reset the port attached by the devices can fix them.
	 */
4593
	if ((udev->speed >= USB_SPEED_SUPER) &&
4594 4595 4596 4597 4598 4599 4600 4601 4602
			(le16_to_cpu(udev->descriptor.bcdUSB) < 0x0300)) {
		dev_err(&udev->dev, "got a wrong device descriptor, "
				"warm reset device\n");
		hub_port_reset(hub, port1, udev,
				HUB_BH_RESET_TIME, true);
		retval = -EINVAL;
		goto fail;
	}

4603
	if (udev->descriptor.bMaxPacketSize0 == 0xff ||
4604
			udev->speed >= USB_SPEED_SUPER)
4605 4606 4607
		i = 512;
	else
		i = udev->descriptor.bMaxPacketSize0;
4608
	if (usb_endpoint_maxp(&udev->ep0.desc) != i) {
4609
		if (udev->speed == USB_SPEED_LOW ||
L
Linus Torvalds 已提交
4610
				!(i == 8 || i == 16 || i == 32 || i == 64)) {
4611
			dev_err(&udev->dev, "Invalid ep0 maxpacket: %d\n", i);
L
Linus Torvalds 已提交
4612 4613 4614
			retval = -EMSGSIZE;
			goto fail;
		}
4615 4616 4617 4618
		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);
L
Linus Torvalds 已提交
4619
		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
4620
		usb_ep0_reinit(udev);
L
Linus Torvalds 已提交
4621
	}
4622

L
Linus Torvalds 已提交
4623 4624
	retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
	if (retval < (signed)sizeof(udev->descriptor)) {
4625 4626 4627
		if (retval != -ENODEV)
			dev_err(&udev->dev, "device descriptor read/all, error %d\n",
					retval);
L
Linus Torvalds 已提交
4628 4629 4630 4631 4632
		if (retval >= 0)
			retval = -ENOMSG;
		goto fail;
	}

4633 4634
	usb_detect_quirks(udev);

4635 4636
	if (udev->wusb == 0 && le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0201) {
		retval = usb_get_bos_descriptor(udev);
4637
		if (!retval) {
4638
			udev->lpm_capable = usb_device_supports_lpm(udev);
4639 4640
			usb_set_lpm_parameters(udev);
		}
4641
	}
A
Andiry Xu 已提交
4642

L
Linus Torvalds 已提交
4643
	retval = 0;
4644 4645 4646
	/* notify HCD that we have a device connected and addressed */
	if (hcd->driver->update_device)
		hcd->driver->update_device(hcd, udev);
4647
	hub_set_initial_usb2_lpm_policy(udev);
L
Linus Torvalds 已提交
4648
fail:
4649
	if (retval) {
L
Linus Torvalds 已提交
4650
		hub_port_disable(hub, port1, 0);
4651
		update_devnum(udev, devnum);	/* for disconnect processing */
4652
	}
4653
	mutex_unlock(hcd->address0_mutex);
L
Linus Torvalds 已提交
4654 4655 4656 4657
	return retval;
}

static void
4658
check_highspeed(struct usb_hub *hub, struct usb_device *udev, int port1)
L
Linus Torvalds 已提交
4659 4660 4661 4662
{
	struct usb_qualifier_descriptor	*qual;
	int				status;

4663 4664 4665
	if (udev->quirks & USB_QUIRK_DEVICE_QUALIFIER)
		return;

4666
	qual = kmalloc(sizeof *qual, GFP_KERNEL);
L
Linus Torvalds 已提交
4667 4668 4669
	if (qual == NULL)
		return;

4670
	status = usb_get_descriptor(udev, USB_DT_DEVICE_QUALIFIER, 0,
L
Linus Torvalds 已提交
4671 4672 4673 4674 4675 4676 4677
			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;
4678 4679
			queue_delayed_work(system_power_efficient_wq,
					&hub->leds, 0);
L
Linus Torvalds 已提交
4680 4681
		}
	}
4682
	kfree(qual);
L
Linus Torvalds 已提交
4683 4684 4685
}

static unsigned
4686
hub_power_remaining(struct usb_hub *hub)
L
Linus Torvalds 已提交
4687 4688 4689
{
	struct usb_device *hdev = hub->hdev;
	int remaining;
4690
	int port1;
L
Linus Torvalds 已提交
4691

4692
	if (!hub->limited_power)
L
Linus Torvalds 已提交
4693 4694
		return 0;

4695 4696
	remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;
	for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
4697 4698 4699 4700
		struct usb_port *port_dev = hub->ports[port1 - 1];
		struct usb_device *udev = port_dev->child;
		unsigned unit_load;
		int delta;
L
Linus Torvalds 已提交
4701 4702 4703

		if (!udev)
			continue;
4704 4705 4706 4707
		if (hub_is_superspeed(udev))
			unit_load = 150;
		else
			unit_load = 100;
L
Linus Torvalds 已提交
4708

4709 4710 4711 4712
		/*
		 * Unconfigured devices may not use more than one unit load,
		 * or 8mA for OTG ports
		 */
L
Linus Torvalds 已提交
4713
		if (udev->actconfig)
4714
			delta = usb_get_max_power(udev, udev->actconfig);
4715
		else if (port1 != udev->bus->otg_port || hdev->parent)
4716
			delta = unit_load;
L
Linus Torvalds 已提交
4717
		else
4718 4719
			delta = 8;
		if (delta > hub->mA_per_port)
4720 4721
			dev_warn(&port_dev->dev, "%dmA is over %umA budget!\n",
					delta, hub->mA_per_port);
L
Linus Torvalds 已提交
4722 4723 4724
		remaining -= delta;
	}
	if (remaining < 0) {
4725
		dev_warn(hub->intfdev, "%dmA over power budget!\n",
4726
			-remaining);
L
Linus Torvalds 已提交
4727 4728 4729 4730 4731
		remaining = 0;
	}
	return remaining;
}

4732 4733
static void hub_port_connect(struct usb_hub *hub, int port1, u16 portstatus,
		u16 portchange)
L
Linus Torvalds 已提交
4734 4735
{
	int status, i;
4736
	unsigned unit_load;
L
Linus Torvalds 已提交
4737
	struct usb_device *hdev = hub->hdev;
4738
	struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
4739
	struct usb_port *port_dev = hub->ports[port1 - 1];
4740
	struct usb_device *udev = port_dev->child;
4741
	static int unreliable_port = -1;
4742

A
Alan Stern 已提交
4743
	/* Disconnect any existing devices under this port */
4744
	if (udev) {
4745
		if (hcd->usb_phy && !hdev->parent)
4746
			usb_phy_notify_disconnect(hcd->usb_phy, udev->speed);
4747
		usb_disconnect(&port_dev->child);
4748
	}
A
Alan Stern 已提交
4749

4750 4751 4752 4753 4754 4755 4756
	/* 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);

4757 4758
	if (portchange & (USB_PORT_STAT_C_CONNECTION |
				USB_PORT_STAT_C_ENABLE)) {
4759
		status = hub_port_debounce_be_stable(hub, port1);
4760
		if (status < 0) {
4761 4762 4763
			if (status != -ENODEV &&
				port1 != unreliable_port &&
				printk_ratelimit())
4764
				dev_err(&port_dev->dev, "connect-debounce failed\n");
4765
			portstatus &= ~USB_PORT_STAT_CONNECTION;
4766
			unreliable_port = port1;
4767 4768 4769 4770 4771
		} else {
			portstatus = status;
		}
	}

4772 4773 4774 4775 4776
	/* 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)) {
L
Linus Torvalds 已提交
4777

4778 4779 4780 4781
		/*
		 * maybe switch power back on (e.g. root hub was reset)
		 * but only if the port isn't owned by someone else.
		 */
4782
		if (hub_is_port_power_switchable(hub)
4783 4784
				&& !port_is_power_on(hub, portstatus)
				&& !port_dev->port_owner)
L
Linus Torvalds 已提交
4785
			set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
4786

L
Linus Torvalds 已提交
4787
		if (portstatus & USB_PORT_STAT_ENABLE)
4788
			goto done;
L
Linus Torvalds 已提交
4789 4790
		return;
	}
4791 4792 4793 4794
	if (hub_is_superspeed(hub->hdev))
		unit_load = 150;
	else
		unit_load = 100;
L
Linus Torvalds 已提交
4795

4796
	status = 0;
L
Linus Torvalds 已提交
4797 4798 4799 4800 4801 4802 4803
	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) {
4804 4805
			dev_err(&port_dev->dev,
					"couldn't allocate usb_device\n");
L
Linus Torvalds 已提交
4806 4807 4808 4809
			goto done;
		}

		usb_set_device_state(udev, USB_STATE_POWERED);
4810
		udev->bus_mA = hub->mA_per_port;
4811
		udev->level = hdev->level + 1;
4812
		udev->wusb = hub_is_wusb(hub);
4813

4814
		/* Devices connected to SuperSpeed hubs are USB 3.0 or later */
4815
		if (hub_is_superspeed(hub->hdev))
4816 4817 4818 4819
			udev->speed = USB_SPEED_SUPER;
		else
			udev->speed = USB_SPEED_UNKNOWN;

4820
		choose_devnum(udev);
4821 4822 4823
		if (udev->devnum <= 0) {
			status = -ENOTCONN;	/* Don't retry */
			goto loop;
4824 4825
		}

4826
		/* reset (non-USB 3.0 devices) and get descriptor */
D
Dan Williams 已提交
4827
		usb_lock_port(port_dev);
L
Linus Torvalds 已提交
4828
		status = hub_port_init(hub, udev, port1, i);
D
Dan Williams 已提交
4829
		usb_unlock_port(port_dev);
L
Linus Torvalds 已提交
4830 4831 4832
		if (status < 0)
			goto loop;

4833 4834 4835
		if (udev->quirks & USB_QUIRK_DELAY_INIT)
			msleep(1000);

L
Linus Torvalds 已提交
4836 4837 4838 4839 4840 4841 4842
		/* 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
4843
				&& udev->bus_mA <= unit_load) {
L
Linus Torvalds 已提交
4844 4845 4846 4847
			u16	devstat;

			status = usb_get_status(udev, USB_RECIP_DEVICE, 0,
					&devstat);
4848
			if (status) {
L
Linus Torvalds 已提交
4849 4850 4851 4852 4853 4854 4855 4856 4857 4858
				dev_dbg(&udev->dev, "get status %d ?\n", status);
				goto loop_disable;
			}
			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;
4859 4860 4861
					queue_delayed_work(
						system_power_efficient_wq,
						&hub->leds, 0);
L
Linus Torvalds 已提交
4862 4863 4864 4865 4866
				}
				status = -ENOTCONN;	/* Don't retry */
				goto loop_disable;
			}
		}
4867

L
Linus Torvalds 已提交
4868 4869 4870 4871
		/* check for devices running slower than they could */
		if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200
				&& udev->speed == USB_SPEED_FULL
				&& highspeed_hubs != 0)
4872
			check_highspeed(hub, udev, port1);
L
Linus Torvalds 已提交
4873

4874
		/* Store the parent's children[] pointer.  At this point
L
Linus Torvalds 已提交
4875 4876 4877 4878 4879
		 * udev becomes globally accessible, although presumably
		 * no one will look at it until hdev is unlocked.
		 */
		status = 0;

4880 4881
		mutex_lock(&usb_port_peer_mutex);

L
Linus Torvalds 已提交
4882 4883 4884 4885 4886 4887 4888 4889
		/* 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
4890
			port_dev->child = udev;
L
Linus Torvalds 已提交
4891
		spin_unlock_irq(&device_state_lock);
4892
		mutex_unlock(&usb_port_peer_mutex);
L
Linus Torvalds 已提交
4893 4894 4895 4896 4897

		/* Run it through the hoops (find a driver, etc) */
		if (!status) {
			status = usb_new_device(udev);
			if (status) {
4898
				mutex_lock(&usb_port_peer_mutex);
L
Linus Torvalds 已提交
4899
				spin_lock_irq(&device_state_lock);
4900
				port_dev->child = NULL;
L
Linus Torvalds 已提交
4901
				spin_unlock_irq(&device_state_lock);
4902
				mutex_unlock(&usb_port_peer_mutex);
4903 4904 4905 4906
			} else {
				if (hcd->usb_phy && !hdev->parent)
					usb_phy_notify_connect(hcd->usb_phy,
							udev->speed);
L
Linus Torvalds 已提交
4907 4908 4909 4910 4911 4912 4913 4914
			}
		}

		if (status)
			goto loop_disable;

		status = hub_power_remaining(hub);
		if (status)
4915
			dev_dbg(hub->intfdev, "%dmA power budget left\n", status);
L
Linus Torvalds 已提交
4916 4917 4918 4919 4920 4921

		return;

loop_disable:
		hub_port_disable(hub, port1, 1);
loop:
4922
		usb_ep0_reinit(udev);
4923
		release_devnum(udev);
4924
		hub_free_dev(udev);
L
Linus Torvalds 已提交
4925
		usb_put_dev(udev);
4926
		if ((status == -ENOTCONN) || (status == -ENOTSUPP))
L
Linus Torvalds 已提交
4927 4928
			break;
	}
4929 4930
	if (hub->hdev->parent ||
			!hcd->driver->port_handed_over ||
4931 4932
			!(hcd->driver->port_handed_over)(hcd, port1)) {
		if (status != -ENOTCONN && status != -ENODEV)
4933 4934
			dev_err(&port_dev->dev,
					"unable to enumerate USB device\n");
4935
	}
4936

L
Linus Torvalds 已提交
4937 4938
done:
	hub_port_disable(hub, port1, 1);
4939 4940
	if (hcd->driver->relinquish_port && !hub->hdev->parent)
		hcd->driver->relinquish_port(hcd, port1);
4941

L
Linus Torvalds 已提交
4942 4943
}

4944 4945 4946 4947 4948 4949 4950 4951 4952 4953
/* 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);
 *	usb_reset_and_verify_device() encounters changed descriptors (as from
 *		a firmware download)
 * caller already locked the hub
 */
static void hub_port_connect_change(struct usb_hub *hub, int port1,
					u16 portstatus, u16 portchange)
D
Dan Williams 已提交
4954
		__must_hold(&port_dev->status_lock)
4955
{
4956 4957 4958
	struct usb_port *port_dev = hub->ports[port1 - 1];
	struct usb_device *udev = port_dev->child;
	int status = -ENODEV;
4959

4960 4961 4962 4963 4964 4965
	dev_dbg(&port_dev->dev, "status %04x, change %04x, %s\n", portstatus,
			portchange, portspeed(hub, portstatus));

	if (hub->has_indicators) {
		set_port_led(hub, port1, HUB_LED_AUTO);
		hub->indicator[port1-1] = INDICATOR_AUTO;
4966 4967
	}

4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979
#ifdef	CONFIG_USB_OTG
	/* during HNP, don't repeat the debounce */
	if (hub->hdev->bus->is_b_host)
		portchange &= ~(USB_PORT_STAT_C_CONNECTION |
				USB_PORT_STAT_C_ENABLE);
#endif

	/* Try to resuscitate an existing device */
	if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
			udev->state != USB_STATE_NOTATTACHED) {
		if (portstatus & USB_PORT_STAT_ENABLE) {
			status = 0;		/* Nothing to do */
4980
#ifdef CONFIG_PM
4981 4982 4983 4984 4985
		} else if (udev->state == USB_STATE_SUSPENDED &&
				udev->persist_enabled) {
			/* For a suspended device, treat this as a
			 * remote wakeup event.
			 */
D
Dan Williams 已提交
4986
			usb_unlock_port(port_dev);
4987
			status = usb_remote_wakeup(udev);
D
Dan Williams 已提交
4988
			usb_lock_port(port_dev);
4989 4990 4991 4992 4993 4994 4995
#endif
		} else {
			/* Don't resuscitate */;
		}
	}
	clear_bit(port1, hub->change_bits);

D
Dan Williams 已提交
4996
	/* successfully revalidated the connection */
4997 4998 4999
	if (status == 0)
		return;

D
Dan Williams 已提交
5000
	usb_unlock_port(port_dev);
5001
	hub_port_connect(hub, port1, portstatus, portchange);
D
Dan Williams 已提交
5002
	usb_lock_port(port_dev);
L
Linus Torvalds 已提交
5003 5004
}

5005
static void port_event(struct usb_hub *hub, int port1)
D
Dan Williams 已提交
5006
		__must_hold(&port_dev->status_lock)
5007
{
5008
	int connect_change;
5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077
	struct usb_port *port_dev = hub->ports[port1 - 1];
	struct usb_device *udev = port_dev->child;
	struct usb_device *hdev = hub->hdev;
	u16 portstatus, portchange;

	connect_change = test_bit(port1, hub->change_bits);
	clear_bit(port1, hub->event_bits);
	clear_bit(port1, hub->wakeup_bits);

	if (hub_port_status(hub, port1, &portstatus, &portchange) < 0)
		return;

	if (portchange & USB_PORT_STAT_C_CONNECTION) {
		usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION);
		connect_change = 1;
	}

	if (portchange & USB_PORT_STAT_C_ENABLE) {
		if (!connect_change)
			dev_dbg(&port_dev->dev, "enable change, status %08x\n",
					portstatus);
		usb_clear_port_feature(hdev, port1, 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 && udev) {
			dev_err(&port_dev->dev, "disabled by hub (EMI?), re-enabling...\n");
			connect_change = 1;
		}
	}

	if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
		u16 status = 0, unused;

		dev_dbg(&port_dev->dev, "over-current change\n");
		usb_clear_port_feature(hdev, port1,
				USB_PORT_FEAT_C_OVER_CURRENT);
		msleep(100);	/* Cool down */
		hub_power_on(hub, true);
		hub_port_status(hub, port1, &status, &unused);
		if (status & USB_PORT_STAT_OVERCURRENT)
			dev_err(&port_dev->dev, "over-current condition\n");
	}

	if (portchange & USB_PORT_STAT_C_RESET) {
		dev_dbg(&port_dev->dev, "reset change\n");
		usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_RESET);
	}
	if ((portchange & USB_PORT_STAT_C_BH_RESET)
	    && hub_is_superspeed(hdev)) {
		dev_dbg(&port_dev->dev, "warm reset change\n");
		usb_clear_port_feature(hdev, port1,
				USB_PORT_FEAT_C_BH_PORT_RESET);
	}
	if (portchange & USB_PORT_STAT_C_LINK_STATE) {
		dev_dbg(&port_dev->dev, "link state change\n");
		usb_clear_port_feature(hdev, port1,
				USB_PORT_FEAT_C_PORT_LINK_STATE);
	}
	if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
		dev_warn(&port_dev->dev, "config error\n");
		usb_clear_port_feature(hdev, port1,
				USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
	}

5078 5079 5080
	/* skip port actions that require the port to be powered on */
	if (!pm_runtime_active(&port_dev->dev))
		return;
5081

5082 5083 5084 5085 5086 5087 5088
	if (hub_handle_remote_wakeup(hub, port1, portstatus, portchange))
		connect_change = 1;

	/*
	 * Warm reset a USB3 protocol port if it's in
	 * SS.Inactive state.
	 */
5089
	if (hub_port_warm_reset_required(hub, port1, portstatus)) {
5090 5091 5092 5093 5094 5095
		dev_dbg(&port_dev->dev, "do warm reset\n");
		if (!udev || !(portstatus & USB_PORT_STAT_CONNECTION)
				|| udev->state == USB_STATE_NOTATTACHED) {
			if (hub_port_reset(hub, port1, NULL,
					HUB_BH_RESET_TIME, true) < 0)
				hub_port_disable(hub, port1, 1);
5096 5097 5098 5099 5100 5101 5102 5103
		} else {
			usb_unlock_port(port_dev);
			usb_lock_device(udev);
			usb_reset_device(udev);
			usb_unlock_device(udev);
			usb_lock_port(port_dev);
			connect_change = 0;
		}
5104
	}
5105 5106 5107

	if (connect_change)
		hub_port_connect_change(hub, port1, portstatus, portchange);
5108 5109
}

5110
static void hub_event(struct work_struct *work)
L
Linus Torvalds 已提交
5111 5112 5113 5114 5115 5116 5117 5118 5119
{
	struct usb_device *hdev;
	struct usb_interface *intf;
	struct usb_hub *hub;
	struct device *hub_dev;
	u16 hubstatus;
	u16 hubchange;
	int i, ret;

5120
	hub = container_of(work, struct usb_hub, events);
5121 5122 5123
	hdev = hub->hdev;
	hub_dev = hub->intfdev;
	intf = to_usb_interface(hub_dev);
5124

5125 5126 5127 5128 5129 5130 5131 5132 5133 5134
	dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
			hdev->state, hdev->maxchild,
			/* NOTE: expects max 15 ports... */
			(u16) hub->change_bits[0],
			(u16) hub->event_bits[0]);

	/* Lock the device, then check to see if we were
	 * disconnected while waiting for the lock to succeed. */
	usb_lock_device(hdev);
	if (unlikely(hub->disconnected))
5135
		goto out_hdev_lock;
5136 5137 5138 5139 5140

	/* If the hub has died, clean up after it */
	if (hdev->state == USB_STATE_NOTATTACHED) {
		hub->error = -ENODEV;
		hub_quiesce(hub, HUB_DISCONNECT);
5141
		goto out_hdev_lock;
5142 5143 5144 5145 5146 5147
	}

	/* Autoresume */
	ret = usb_autopm_get_interface(intf);
	if (ret) {
		dev_dbg(hub_dev, "Can't autoresume: %d\n", ret);
5148
		goto out_hdev_lock;
5149
	}
L
Linus Torvalds 已提交
5150

5151 5152 5153
	/* If this is an inactive hub, do nothing */
	if (hub->quiescing)
		goto out_autopm;
L
Linus Torvalds 已提交
5154

5155 5156 5157 5158
	if (hub->error) {
		dev_dbg(hub_dev, "resetting for error %d\n", hub->error);

		ret = usb_reset_device(hdev);
5159
		if (ret) {
5160 5161
			dev_dbg(hub_dev, "error resetting hub: %d\n", ret);
			goto out_autopm;
5162
		}
5163

5164 5165 5166
		hub->nerrors = 0;
		hub->error = 0;
	}
L
Linus Torvalds 已提交
5167

5168 5169 5170
	/* deal with port status changes */
	for (i = 1; i <= hdev->maxchild; i++) {
		struct usb_port *port_dev = hub->ports[i - 1];
L
Linus Torvalds 已提交
5171

5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189
		if (test_bit(i, hub->event_bits)
				|| test_bit(i, hub->change_bits)
				|| test_bit(i, hub->wakeup_bits)) {
			/*
			 * The get_noresume and barrier ensure that if
			 * the port was in the process of resuming, we
			 * flush that work and keep the port active for
			 * the duration of the port_event().  However,
			 * if the port is runtime pm suspended
			 * (powered-off), we leave it in that state, run
			 * an abbreviated port_event(), and move on.
			 */
			pm_runtime_get_noresume(&port_dev->dev);
			pm_runtime_barrier(&port_dev->dev);
			usb_lock_port(port_dev);
			port_event(hub, i);
			usb_unlock_port(port_dev);
			pm_runtime_put_sync(&port_dev->dev);
L
Linus Torvalds 已提交
5190
		}
5191
	}
L
Linus Torvalds 已提交
5192

5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206
	/* 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);
			if (hubstatus & HUB_STATUS_LOCAL_POWER)
				/* FIXME: Is this always true? */
				hub->limited_power = 1;
			else
				hub->limited_power = 0;
5207
		}
5208 5209 5210
		if (hubchange & HUB_CHANGE_OVERCURRENT) {
			u16 status = 0;
			u16 unused;
L
Linus Torvalds 已提交
5211

5212 5213 5214 5215 5216 5217 5218
			dev_dbg(hub_dev, "over-current change\n");
			clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
			msleep(500);	/* Cool down */
			hub_power_on(hub, true);
			hub_hub_status(hub, &status, &unused);
			if (status & HUB_STATUS_OVERCURRENT)
				dev_err(hub_dev, "over-current condition\n");
L
Linus Torvalds 已提交
5219
		}
5220
	}
L
Linus Torvalds 已提交
5221

5222 5223 5224
out_autopm:
	/* Balance the usb_autopm_get_interface() above */
	usb_autopm_put_interface_no_suspend(intf);
5225
out_hdev_lock:
5226
	usb_unlock_device(hdev);
L
Linus Torvalds 已提交
5227

5228 5229 5230
	/* Balance the stuff in kick_hub_wq() and allow autosuspend */
	usb_autopm_put_interface(intf);
	kref_put(&hub->kref, hub_release);
L
Linus Torvalds 已提交
5231 5232
}

5233
static const struct usb_device_id hub_id_table[] = {
5234
    { .match_flags = USB_DEVICE_ID_MATCH_VENDOR
5235
			| USB_DEVICE_ID_MATCH_INT_CLASS,
5236 5237 5238
      .idVendor = USB_VENDOR_GENESYS_LOGIC,
      .bInterfaceClass = USB_CLASS_HUB,
      .driver_info = HUB_QUIRK_CHECK_PORT_AUTOSUSPEND},
L
Linus Torvalds 已提交
5239 5240 5241 5242 5243 5244 5245
    { .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 */
};

5246
MODULE_DEVICE_TABLE(usb, hub_id_table);
L
Linus Torvalds 已提交
5247 5248 5249 5250 5251 5252 5253

static struct usb_driver hub_driver = {
	.name =		"hub",
	.probe =	hub_probe,
	.disconnect =	hub_disconnect,
	.suspend =	hub_suspend,
	.resume =	hub_resume,
A
Alan Stern 已提交
5254
	.reset_resume =	hub_reset_resume,
5255 5256
	.pre_reset =	hub_pre_reset,
	.post_reset =	hub_post_reset,
5257
	.unlocked_ioctl = hub_ioctl,
L
Linus Torvalds 已提交
5258
	.id_table =	hub_id_table,
5259
	.supports_autosuspend =	1,
L
Linus Torvalds 已提交
5260 5261 5262 5263 5264 5265 5266 5267 5268 5269
};

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;
	}

5270 5271 5272 5273 5274 5275
	/*
	 * The workqueue needs to be freezable to avoid interfering 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.
	 */
5276
	hub_wq = alloc_workqueue("usb_hub_wq", WQ_FREEZABLE, 0);
5277
	if (hub_wq)
L
Linus Torvalds 已提交
5278 5279 5280 5281
		return 0;

	/* Fall through if kernel_thread failed */
	usb_deregister(&hub_driver);
5282
	pr_err("%s: can't allocate workqueue for usb hub\n", usbcore_name);
L
Linus Torvalds 已提交
5283 5284 5285 5286 5287 5288

	return -1;
}

void usb_hub_cleanup(void)
{
5289
	destroy_workqueue(hub_wq);
L
Linus Torvalds 已提交
5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300

	/*
	 * 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() */

5301
static int descriptors_changed(struct usb_device *udev,
5302 5303
		struct usb_device_descriptor *old_device_descriptor,
		struct usb_host_bos *old_bos)
5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316
{
	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;

5317 5318 5319
	if ((old_bos && !udev->bos) || (!old_bos && udev->bos))
		return 1;
	if (udev->bos) {
5320 5321
		len = le16_to_cpu(udev->bos->desc->wTotalLength);
		if (len != le16_to_cpu(old_bos->desc->wTotalLength))
5322
			return 1;
5323
		if (memcmp(udev->bos->desc, old_bos->desc, len))
5324 5325 5326
			return 1;
	}

5327 5328 5329 5330 5331 5332 5333 5334
	/* 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;
L
Linus Torvalds 已提交
5335

5336
	len = serial_len;
L
Linus Torvalds 已提交
5337
	for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
5338 5339
		old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
		len = max(len, old_length);
L
Linus Torvalds 已提交
5340
	}
5341

O
Oliver Neukum 已提交
5342
	buf = kmalloc(len, GFP_NOIO);
L
Linus Torvalds 已提交
5343 5344 5345 5346 5347 5348
	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++) {
5349
		old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
L
Linus Torvalds 已提交
5350 5351
		length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf,
				old_length);
5352
		if (length != old_length) {
L
Linus Torvalds 已提交
5353 5354
			dev_dbg(&udev->dev, "config index %d, error %d\n",
					index, length);
5355
			changed = 1;
L
Linus Torvalds 已提交
5356 5357
			break;
		}
5358
		if (memcmp(buf, udev->rawdescriptors[index], old_length)
L
Linus Torvalds 已提交
5359 5360
				!= 0) {
			dev_dbg(&udev->dev, "config index %d changed (#%d)\n",
5361 5362 5363 5364
				index,
				((struct usb_config_descriptor *) buf)->
					bConfigurationValue);
			changed = 1;
L
Linus Torvalds 已提交
5365 5366 5367
			break;
		}
	}
5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381

	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;
		}
	}

L
Linus Torvalds 已提交
5382
	kfree(buf);
5383
	return changed;
L
Linus Torvalds 已提交
5384 5385 5386
}

/**
5387
 * usb_reset_and_verify_device - perform a USB port reset to reinitialize a device
L
Linus Torvalds 已提交
5388 5389
 * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
 *
5390 5391
 * WARNING - don't use this routine to reset a composite device
 * (one with multiple interfaces owned by separate drivers)!
5392
 * Use usb_reset_device() instead.
L
Linus Torvalds 已提交
5393 5394 5395 5396 5397
 *
 * 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
5398
 * telling hub_wq to pretend the device has been disconnected and then
L
Linus Torvalds 已提交
5399 5400 5401
 * re-connected.  All drivers will be unbound, and the device will be
 * re-enumerated and probed all over again.
 *
5402
 * Return: 0 if the reset succeeded, -ENODEV if the device has been
L
Linus Torvalds 已提交
5403 5404 5405
 * flagged for logical disconnection, or some other negative error code
 * if the reset wasn't even attempted.
 *
5406
 * Note:
D
Dan Williams 已提交
5407 5408 5409 5410 5411
 * The caller must own the device lock and the port lock, the latter is
 * taken by usb_reset_device().  For example, it's safe to use
 * usb_reset_device() 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().
A
Alan Stern 已提交
5412 5413 5414 5415
 *
 * 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
D
Dan Williams 已提交
5416 5417 5418
 * usb_autopm_resume_device(), thereby preventing any unwanted
 * autoresume.  The autoresume handler is expected to have already
 * acquired the port lock before calling this routine.
L
Linus Torvalds 已提交
5419
 */
5420
static int usb_reset_and_verify_device(struct usb_device *udev)
L
Linus Torvalds 已提交
5421 5422 5423
{
	struct usb_device		*parent_hdev = udev->parent;
	struct usb_hub			*parent_hub;
5424
	struct usb_hcd			*hcd = bus_to_hcd(udev->bus);
L
Linus Torvalds 已提交
5425
	struct usb_device_descriptor	descriptor = udev->descriptor;
5426
	struct usb_host_bos		*bos;
5427
	int				i, j, ret = 0;
5428
	int				port1 = udev->portnum;
L
Linus Torvalds 已提交
5429 5430 5431 5432 5433 5434 5435 5436

	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;
	}

D
Dan Williams 已提交
5437
	if (!parent_hdev)
L
Linus Torvalds 已提交
5438
		return -EISDIR;
D
Dan Williams 已提交
5439

5440
	parent_hub = usb_hub_to_struct_hub(parent_hdev);
L
Linus Torvalds 已提交
5441

5442 5443 5444 5445 5446 5447
	/* Disable USB2 hardware LPM.
	 * It will be re-enabled by the enumeration process.
	 */
	if (udev->usb2_hw_lpm_enabled == 1)
		usb_set_usb2_hardware_lpm(udev, 0);

5448 5449 5450 5451
	/* Disable LPM and LTM while we reset the device and reinstall the alt
	 * settings.  Device-initiated LPM settings, and system exit latency
	 * settings are cleared when the device is reset, so we have to set
	 * them up again.
5452 5453 5454 5455
	 */
	ret = usb_unlocked_disable_lpm(udev);
	if (ret) {
		dev_err(&udev->dev, "%s Failed to disable LPM\n.", __func__);
5456
		goto re_enumerate_no_bos;
5457
	}
5458 5459 5460 5461
	ret = usb_disable_ltm(udev);
	if (ret) {
		dev_err(&udev->dev, "%s Failed to disable LTM\n.",
				__func__);
5462
		goto re_enumerate_no_bos;
5463
	}
5464

5465
	bos = udev->bos;
5466
	udev->bos = NULL;
5467

L
Linus Torvalds 已提交
5468 5469 5470 5471
	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. */
5472
		usb_ep0_reinit(udev);
L
Linus Torvalds 已提交
5473
		ret = hub_port_init(parent_hub, udev, port1, i);
5474
		if (ret >= 0 || ret == -ENOTCONN || ret == -ENODEV)
L
Linus Torvalds 已提交
5475 5476
			break;
	}
5477

L
Linus Torvalds 已提交
5478 5479
	if (ret < 0)
		goto re_enumerate;
5480

L
Linus Torvalds 已提交
5481
	/* Device might have changed firmware (DFU or similar) */
5482
	if (descriptors_changed(udev, &descriptor, bos)) {
L
Linus Torvalds 已提交
5483 5484 5485
		dev_info(&udev->dev, "device firmware changed\n");
		udev->descriptor = descriptor;	/* for disconnect() calls */
		goto re_enumerate;
5486
	}
5487 5488

	/* Restore the device's previous configuration */
L
Linus Torvalds 已提交
5489 5490
	if (!udev->actconfig)
		goto done;
5491

5492
	mutex_lock(hcd->bandwidth_mutex);
5493 5494 5495 5496 5497
	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");
5498
		mutex_unlock(hcd->bandwidth_mutex);
5499 5500
		goto re_enumerate;
	}
L
Linus Torvalds 已提交
5501 5502 5503 5504 5505 5506 5507 5508
	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);
5509
		mutex_unlock(hcd->bandwidth_mutex);
L
Linus Torvalds 已提交
5510
		goto re_enumerate;
5511
	}
5512
	mutex_unlock(hcd->bandwidth_mutex);
L
Linus Torvalds 已提交
5513 5514
	usb_set_device_state(udev, USB_STATE_CONFIGURED);

5515 5516 5517 5518 5519 5520
	/* 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.
	 */
L
Linus Torvalds 已提交
5521
	for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
5522 5523
		struct usb_host_config *config = udev->actconfig;
		struct usb_interface *intf = config->interface[i];
L
Linus Torvalds 已提交
5524 5525 5526
		struct usb_interface_descriptor *desc;

		desc = &intf->cur_altsetting->desc;
5527 5528 5529 5530 5531
		if (desc->bAlternateSetting == 0) {
			usb_disable_interface(udev, intf, true);
			usb_enable_interface(udev, intf, true);
			ret = 0;
		} else {
5532 5533 5534
			/* 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.
5535
			 */
5536
			intf->resetting_device = 1;
5537 5538
			ret = usb_set_interface(udev, desc->bInterfaceNumber,
					desc->bAlternateSetting);
5539
			intf->resetting_device = 0;
5540
		}
L
Linus Torvalds 已提交
5541 5542 5543 5544 5545 5546 5547 5548
		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;
		}
5549 5550 5551
		/* Resetting also frees any allocated streams */
		for (j = 0; j < intf->cur_altsetting->desc.bNumEndpoints; j++)
			intf->cur_altsetting->endpoint[j].streams = 0;
L
Linus Torvalds 已提交
5552 5553 5554
	}

done:
5555
	/* Now that the alt settings are re-installed, enable LTM and LPM. */
5556
	usb_set_usb2_hardware_lpm(udev, 1);
5557
	usb_unlocked_enable_lpm(udev);
5558
	usb_enable_ltm(udev);
5559 5560
	usb_release_bos_descriptor(udev);
	udev->bos = bos;
L
Linus Torvalds 已提交
5561
	return 0;
5562

L
Linus Torvalds 已提交
5563
re_enumerate:
5564 5565
	usb_release_bos_descriptor(udev);
	udev->bos = bos;
5566 5567 5568
re_enumerate_no_bos:
	/* LPM state doesn't matter when we're about to destroy the device. */
	hub_port_logical_disconnect(parent_hub, port1);
L
Linus Torvalds 已提交
5569 5570
	return -ENODEV;
}
5571 5572

/**
5573
 * usb_reset_device - warn interface drivers and perform a USB port reset
5574 5575 5576 5577 5578 5579
 * @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).
 *
5580
 * Return: The same as for usb_reset_and_verify_device().
5581
 *
5582
 * Note:
5583 5584 5585 5586
 * 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().
5587 5588 5589 5590 5591
 *
 * 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.
5592
 */
5593
int usb_reset_device(struct usb_device *udev)
5594 5595
{
	int ret;
5596
	int i;
5597
	unsigned int noio_flag;
D
Dan Williams 已提交
5598
	struct usb_port *port_dev;
5599
	struct usb_host_config *config = udev->actconfig;
D
Dan Williams 已提交
5600
	struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
5601 5602 5603 5604 5605 5606 5607 5608

	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;
	}

D
Dan Williams 已提交
5609 5610 5611 5612 5613 5614 5615 5616
	if (!udev->parent) {
		/* this requires hcd-specific logic; see ohci_restart() */
		dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
		return -EISDIR;
	}

	port_dev = hub->ports[udev->portnum - 1];

5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627
	/*
	 * Don't allocate memory with GFP_KERNEL in current
	 * context to avoid possible deadlock if usb mass
	 * storage interface or usbnet interface(iSCSI case)
	 * is included in current configuration. The easist
	 * approach is to do it for every device reset,
	 * because the device 'memalloc_noio' flag may have
	 * not been set before reseting the usb device.
	 */
	noio_flag = memalloc_noio_save();

5628
	/* Prevent autosuspend during the reset */
5629
	usb_autoresume_device(udev);
5630

5631 5632
	if (config) {
		for (i = 0; i < config->desc.bNumInterfaces; ++i) {
5633 5634
			struct usb_interface *cintf = config->interface[i];
			struct usb_driver *drv;
5635
			int unbind = 0;
5636 5637

			if (cintf->dev.driver) {
5638
				drv = to_usb_driver(cintf->dev.driver);
5639 5640 5641 5642 5643 5644 5645
				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);
5646 5647 5648 5649
			}
		}
	}

D
Dan Williams 已提交
5650
	usb_lock_port(port_dev);
5651
	ret = usb_reset_and_verify_device(udev);
D
Dan Williams 已提交
5652
	usb_unlock_port(port_dev);
5653 5654 5655

	if (config) {
		for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
5656 5657
			struct usb_interface *cintf = config->interface[i];
			struct usb_driver *drv;
5658
			int rebind = cintf->needs_binding;
5659

5660
			if (!rebind && cintf->dev.driver) {
5661 5662
				drv = to_usb_driver(cintf->dev.driver);
				if (drv->post_reset)
5663 5664 5665 5666
					rebind = (drv->post_reset)(cintf);
				else if (cintf->condition ==
						USB_INTERFACE_BOUND)
					rebind = 1;
5667 5668
				if (rebind)
					cintf->needs_binding = 1;
5669 5670
			}
		}
5671
		usb_unbind_and_rebind_marked_interfaces(udev);
5672 5673
	}

5674
	usb_autosuspend_device(udev);
5675
	memalloc_noio_restore(noio_flag);
5676 5677
	return ret;
}
5678
EXPORT_SYMBOL_GPL(usb_reset_device);
5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699


/**
 * 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.
 *
5700 5701
 * - If the reset is delayed so long that the interface is unbound from
 *   its driver, the reset will be skipped.
5702
 *
5703 5704 5705 5706 5707
 * - This function can be called during .probe().  It can also be called
 *   during .disconnect(), but doing so is pointless because the reset
 *   will not occur.  If you really want to reset the device during
 *   .disconnect(), call usb_reset_device() directly -- but watch out
 *   for nested unbinding issues!
5708 5709 5710
 */
void usb_queue_reset_device(struct usb_interface *iface)
{
5711 5712
	if (schedule_work(&iface->reset_ws))
		usb_get_intf(iface);
5713 5714
}
EXPORT_SYMBOL_GPL(usb_queue_reset_device);
5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725

/**
 * usb_hub_find_child - Get the pointer of child device
 * attached to the port which is specified by @port1.
 * @hdev: USB device belonging to the usb hub
 * @port1: port num to indicate which port the child device
 *	is attached to.
 *
 * USB drivers call this function to get hub's child device
 * pointer.
 *
5726
 * Return: %NULL if input param is invalid and
5727 5728 5729 5730 5731
 * child's usb_device pointer if non-NULL.
 */
struct usb_device *usb_hub_find_child(struct usb_device *hdev,
		int port1)
{
5732
	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
5733 5734 5735 5736 5737 5738

	if (port1 < 1 || port1 > hdev->maxchild)
		return NULL;
	return hub->ports[port1 - 1]->child;
}
EXPORT_SYMBOL_GPL(usb_hub_find_child);
5739

5740 5741 5742
void usb_hub_adjust_deviceremovable(struct usb_device *hdev,
		struct usb_hub_descriptor *desc)
{
5743
	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
5744 5745 5746
	enum usb_port_connect_type connect_type;
	int i;

5747 5748 5749
	if (!hub)
		return;

5750 5751
	if (!hub_is_superspeed(hdev)) {
		for (i = 1; i <= hdev->maxchild; i++) {
5752
			struct usb_port *port_dev = hub->ports[i - 1];
5753

5754
			connect_type = port_dev->connect_type;
5755 5756 5757 5758
			if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
				u8 mask = 1 << (i%8);

				if (!(desc->u.hs.DeviceRemovable[i/8] & mask)) {
5759
					dev_dbg(&port_dev->dev, "DeviceRemovable is changed to 1 according to platform information.\n");
5760 5761 5762 5763 5764 5765 5766 5767
					desc->u.hs.DeviceRemovable[i/8]	|= mask;
				}
			}
		}
	} else {
		u16 port_removable = le16_to_cpu(desc->u.ss.DeviceRemovable);

		for (i = 1; i <= hdev->maxchild; i++) {
5768
			struct usb_port *port_dev = hub->ports[i - 1];
5769

5770
			connect_type = port_dev->connect_type;
5771 5772 5773 5774
			if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
				u16 mask = 1 << i;

				if (!(port_removable & mask)) {
5775
					dev_dbg(&port_dev->dev, "DeviceRemovable is changed to 1 according to platform information.\n");
5776 5777 5778 5779 5780 5781 5782 5783 5784
					port_removable |= mask;
				}
			}
		}

		desc->u.ss.DeviceRemovable = cpu_to_le16(port_removable);
	}
}

5785 5786 5787 5788 5789 5790
#ifdef CONFIG_ACPI
/**
 * usb_get_hub_port_acpi_handle - Get the usb port's acpi handle
 * @hdev: USB device belonging to the usb hub
 * @port1: port num of the port
 *
5791 5792
 * Return: Port's acpi handle if successful, %NULL if params are
 * invalid.
5793 5794 5795 5796
 */
acpi_handle usb_get_hub_port_acpi_handle(struct usb_device *hdev,
	int port1)
{
5797
	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
5798

5799 5800 5801
	if (!hub)
		return NULL;

5802
	return ACPI_HANDLE(&hub->ports[port1 - 1]->dev);
5803 5804
}
#endif