1/*
   2 * USB hub driver.
   3 *
   4 * (C) Copyright 1999 Linus Torvalds
   5 * (C) Copyright 1999 Johannes Erdfelt
   6 * (C) Copyright 1999 Gregory P. Smith
   7 * (C) Copyright 2001 Brad Hards (bhards@bigpond.net.au)
   8 *
   9 * Released under the GPLv2 only.
  10 * SPDX-License-Identifier: GPL-2.0
  11 */
  12
  13#include <linux/kernel.h>
  14#include <linux/errno.h>
  15#include <linux/module.h>
  16#include <linux/moduleparam.h>
  17#include <linux/completion.h>
  18#include <linux/sched.h>
  19#include <linux/list.h>
  20#include <linux/slab.h>
 
  21#include <linux/ioctl.h>
  22#include <linux/usb.h>
  23#include <linux/usbdevice_fs.h>
  24#include <linux/usb/hcd.h>
 
  25#include <linux/usb/otg.h>
  26#include <linux/usb/quirks.h>
  27#include <linux/workqueue.h>
  28#include <linux/mutex.h>
  29#include <linux/random.h>
  30#include <linux/pm_qos.h>
 
  31
 
  32#include <linux/uaccess.h>
  33#include <asm/byteorder.h>
  34
  35#include "hub.h"
  36#include "otg_whitelist.h"
 
  37
  38#define USB_VENDOR_GENESYS_LOGIC		0x05e3
  39#define HUB_QUIRK_CHECK_PORT_AUTOSUSPEND	0x01
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  40
  41/* Protect struct usb_device->state and ->children members
  42 * Note: Both are also protected by ->dev.sem, except that ->state can
  43 * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */
  44static DEFINE_SPINLOCK(device_state_lock);
  45
  46/* workqueue to process hub events */
  47static struct workqueue_struct *hub_wq;
  48static void hub_event(struct work_struct *work);
  49
  50/* synchronize hub-port add/remove and peering operations */
  51DEFINE_MUTEX(usb_port_peer_mutex);
  52
  53/* cycle leds on hubs that aren't blinking for attention */
  54static bool blinkenlights;
  55module_param(blinkenlights, bool, S_IRUGO);
  56MODULE_PARM_DESC(blinkenlights, "true to cycle leds on hubs");
  57
  58/*
  59 * Device SATA8000 FW1.0 from DATAST0R Technology Corp requires about
  60 * 10 seconds to send reply for the initial 64-byte descriptor request.
  61 */
  62/* define initial 64-byte descriptor request timeout in milliseconds */
  63static int initial_descriptor_timeout = USB_CTRL_GET_TIMEOUT;
  64module_param(initial_descriptor_timeout, int, S_IRUGO|S_IWUSR);
  65MODULE_PARM_DESC(initial_descriptor_timeout,
  66		"initial 64-byte descriptor request timeout in milliseconds "
  67		"(default 5000 - 5.0 seconds)");
  68
  69/*
  70 * As of 2.6.10 we introduce a new USB device initialization scheme which
  71 * closely resembles the way Windows works.  Hopefully it will be compatible
  72 * with a wider range of devices than the old scheme.  However some previously
  73 * working devices may start giving rise to "device not accepting address"
  74 * errors; if that happens the user can try the old scheme by adjusting the
  75 * following module parameters.
  76 *
  77 * For maximum flexibility there are two boolean parameters to control the
  78 * hub driver's behavior.  On the first initialization attempt, if the
  79 * "old_scheme_first" parameter is set then the old scheme will be used,
  80 * otherwise the new scheme is used.  If that fails and "use_both_schemes"
  81 * is set, then the driver will make another attempt, using the other scheme.
  82 */
  83static bool old_scheme_first;
  84module_param(old_scheme_first, bool, S_IRUGO | S_IWUSR);
  85MODULE_PARM_DESC(old_scheme_first,
  86		 "start with the old device initialization scheme");
  87
  88static bool use_both_schemes = 1;
  89module_param(use_both_schemes, bool, S_IRUGO | S_IWUSR);
  90MODULE_PARM_DESC(use_both_schemes,
  91		"try the other device initialization scheme if the "
  92		"first one fails");
  93
  94/* Mutual exclusion for EHCI CF initialization.  This interferes with
  95 * port reset on some companion controllers.
  96 */
  97DECLARE_RWSEM(ehci_cf_port_reset_rwsem);
  98EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
  99
 100#define HUB_DEBOUNCE_TIMEOUT	2000
 101#define HUB_DEBOUNCE_STEP	  25
 102#define HUB_DEBOUNCE_STABLE	 100
 103
 104static void hub_release(struct kref *kref);
 105static int usb_reset_and_verify_device(struct usb_device *udev);
 106static int hub_port_disable(struct usb_hub *hub, int port1, int set_state);
 
 
 107
 108static inline char *portspeed(struct usb_hub *hub, int portstatus)
 109{
 110	if (hub_is_superspeedplus(hub->hdev))
 111		return "10.0 Gb/s";
 112	if (hub_is_superspeed(hub->hdev))
 113		return "5.0 Gb/s";
 114	if (portstatus & USB_PORT_STAT_HIGH_SPEED)
 115		return "480 Mb/s";
 116	else if (portstatus & USB_PORT_STAT_LOW_SPEED)
 117		return "1.5 Mb/s";
 118	else
 119		return "12 Mb/s";
 120}
 121
 122/* Note that hdev or one of its children must be locked! */
 123struct usb_hub *usb_hub_to_struct_hub(struct usb_device *hdev)
 124{
 125	if (!hdev || !hdev->actconfig || !hdev->maxchild)
 126		return NULL;
 127	return usb_get_intfdata(hdev->actconfig->interface[0]);
 128}
 129
 130int usb_device_supports_lpm(struct usb_device *udev)
 131{
 132	/* Some devices have trouble with LPM */
 133	if (udev->quirks & USB_QUIRK_NO_LPM)
 134		return 0;
 135
 
 
 
 
 136	/* USB 2.1 (and greater) devices indicate LPM support through
 137	 * their USB 2.0 Extended Capabilities BOS descriptor.
 138	 */
 139	if (udev->speed == USB_SPEED_HIGH || udev->speed == USB_SPEED_FULL) {
 140		if (udev->bos->ext_cap &&
 141			(USB_LPM_SUPPORT &
 142			 le32_to_cpu(udev->bos->ext_cap->bmAttributes)))
 143			return 1;
 144		return 0;
 145	}
 146
 147	/*
 148	 * According to the USB 3.0 spec, all USB 3.0 devices must support LPM.
 149	 * However, there are some that don't, and they set the U1/U2 exit
 150	 * latencies to zero.
 151	 */
 152	if (!udev->bos->ss_cap) {
 153		dev_info(&udev->dev, "No LPM exit latency info found, disabling LPM.\n");
 154		return 0;
 155	}
 156
 157	if (udev->bos->ss_cap->bU1devExitLat == 0 &&
 158			udev->bos->ss_cap->bU2DevExitLat == 0) {
 159		if (udev->parent)
 160			dev_info(&udev->dev, "LPM exit latency is zeroed, disabling LPM.\n");
 161		else
 162			dev_info(&udev->dev, "We don't know the algorithms for LPM for this host, disabling LPM.\n");
 163		return 0;
 164	}
 165
 166	if (!udev->parent || udev->parent->lpm_capable)
 167		return 1;
 168	return 0;
 169}
 170
 171/*
 172 * Set the Maximum Exit Latency (MEL) for the host to initiate a transition from
 173 * either U1 or U2.
 
 174 */
 175static void usb_set_lpm_mel(struct usb_device *udev,
 176		struct usb3_lpm_parameters *udev_lpm_params,
 177		unsigned int udev_exit_latency,
 178		struct usb_hub *hub,
 179		struct usb3_lpm_parameters *hub_lpm_params,
 180		unsigned int hub_exit_latency)
 181{
 182	unsigned int total_mel;
 183	unsigned int device_mel;
 184	unsigned int hub_mel;
 185
 186	/*
 187	 * Calculate the time it takes to transition all links from the roothub
 188	 * to the parent hub into U0.  The parent hub must then decode the
 189	 * packet (hub header decode latency) to figure out which port it was
 190	 * bound for.
 191	 *
 192	 * The Hub Header decode latency is expressed in 0.1us intervals (0x1
 193	 * means 0.1us).  Multiply that by 100 to get nanoseconds.
 194	 */
 195	total_mel = hub_lpm_params->mel +
 196		(hub->descriptor->u.ss.bHubHdrDecLat * 100);
 
 197
 198	/*
 199	 * How long will it take to transition the downstream hub's port into
 200	 * U0?  The greater of either the hub exit latency or the device exit
 201	 * latency.
 202	 *
 203	 * The BOS U1/U2 exit latencies are expressed in 1us intervals.
 204	 * Multiply that by 1000 to get nanoseconds.
 205	 */
 206	device_mel = udev_exit_latency * 1000;
 207	hub_mel = hub_exit_latency * 1000;
 208	if (device_mel > hub_mel)
 209		total_mel += device_mel;
 210	else
 211		total_mel += hub_mel;
 
 
 
 
 
 
 
 212
 213	udev_lpm_params->mel = total_mel;
 214}
 215
 216/*
 217 * Set the maximum Device to Host Exit Latency (PEL) for the device to initiate
 218 * a transition from either U1 or U2.
 219 */
 220static void usb_set_lpm_pel(struct usb_device *udev,
 221		struct usb3_lpm_parameters *udev_lpm_params,
 222		unsigned int udev_exit_latency,
 223		struct usb_hub *hub,
 224		struct usb3_lpm_parameters *hub_lpm_params,
 225		unsigned int hub_exit_latency,
 226		unsigned int port_to_port_exit_latency)
 227{
 228	unsigned int first_link_pel;
 229	unsigned int hub_pel;
 230
 231	/*
 232	 * First, the device sends an LFPS to transition the link between the
 233	 * device and the parent hub into U0.  The exit latency is the bigger of
 234	 * the device exit latency or the hub exit latency.
 235	 */
 236	if (udev_exit_latency > hub_exit_latency)
 237		first_link_pel = udev_exit_latency * 1000;
 238	else
 239		first_link_pel = hub_exit_latency * 1000;
 240
 241	/*
 242	 * When the hub starts to receive the LFPS, there is a slight delay for
 243	 * it to figure out that one of the ports is sending an LFPS.  Then it
 244	 * will forward the LFPS to its upstream link.  The exit latency is the
 245	 * delay, plus the PEL that we calculated for this hub.
 246	 */
 247	hub_pel = port_to_port_exit_latency * 1000 + hub_lpm_params->pel;
 248
 249	/*
 250	 * According to figure C-7 in the USB 3.0 spec, the PEL for this device
 251	 * is the greater of the two exit latencies.
 252	 */
 253	if (first_link_pel > hub_pel)
 254		udev_lpm_params->pel = first_link_pel;
 255	else
 256		udev_lpm_params->pel = hub_pel;
 257}
 258
 259/*
 260 * Set the System Exit Latency (SEL) to indicate the total worst-case time from
 261 * when a device initiates a transition to U0, until when it will receive the
 262 * first packet from the host controller.
 263 *
 264 * Section C.1.5.1 describes the four components to this:
 265 *  - t1: device PEL
 266 *  - t2: time for the ERDY to make it from the device to the host.
 267 *  - t3: a host-specific delay to process the ERDY.
 268 *  - t4: time for the packet to make it from the host to the device.
 269 *
 270 * t3 is specific to both the xHCI host and the platform the host is integrated
 271 * into.  The Intel HW folks have said it's negligible, FIXME if a different
 272 * vendor says otherwise.
 273 */
 274static void usb_set_lpm_sel(struct usb_device *udev,
 275		struct usb3_lpm_parameters *udev_lpm_params)
 276{
 277	struct usb_device *parent;
 278	unsigned int num_hubs;
 279	unsigned int total_sel;
 280
 281	/* t1 = device PEL */
 282	total_sel = udev_lpm_params->pel;
 283	/* How many external hubs are in between the device & the root port. */
 284	for (parent = udev->parent, num_hubs = 0; parent->parent;
 285			parent = parent->parent)
 286		num_hubs++;
 287	/* t2 = 2.1us + 250ns * (num_hubs - 1) */
 288	if (num_hubs > 0)
 289		total_sel += 2100 + 250 * (num_hubs - 1);
 290
 291	/* t4 = 250ns * num_hubs */
 292	total_sel += 250 * num_hubs;
 293
 294	udev_lpm_params->sel = total_sel;
 295}
 296
 297static void usb_set_lpm_parameters(struct usb_device *udev)
 298{
 299	struct usb_hub *hub;
 300	unsigned int port_to_port_delay;
 301	unsigned int udev_u1_del;
 302	unsigned int udev_u2_del;
 303	unsigned int hub_u1_del;
 304	unsigned int hub_u2_del;
 305
 306	if (!udev->lpm_capable || udev->speed < USB_SPEED_SUPER)
 307		return;
 308
 
 
 
 
 309	hub = usb_hub_to_struct_hub(udev->parent);
 310	/* It doesn't take time to transition the roothub into U0, since it
 311	 * doesn't have an upstream link.
 312	 */
 313	if (!hub)
 314		return;
 315
 316	udev_u1_del = udev->bos->ss_cap->bU1devExitLat;
 317	udev_u2_del = le16_to_cpu(udev->bos->ss_cap->bU2DevExitLat);
 318	hub_u1_del = udev->parent->bos->ss_cap->bU1devExitLat;
 319	hub_u2_del = le16_to_cpu(udev->parent->bos->ss_cap->bU2DevExitLat);
 320
 321	usb_set_lpm_mel(udev, &udev->u1_params, udev_u1_del,
 322			hub, &udev->parent->u1_params, hub_u1_del);
 323
 324	usb_set_lpm_mel(udev, &udev->u2_params, udev_u2_del,
 325			hub, &udev->parent->u2_params, hub_u2_del);
 326
 327	/*
 328	 * Appendix C, section C.2.2.2, says that there is a slight delay from
 329	 * when the parent hub notices the downstream port is trying to
 330	 * transition to U0 to when the hub initiates a U0 transition on its
 331	 * upstream port.  The section says the delays are tPort2PortU1EL and
 332	 * tPort2PortU2EL, but it doesn't define what they are.
 333	 *
 334	 * The hub chapter, sections 10.4.2.4 and 10.4.2.5 seem to be talking
 335	 * about the same delays.  Use the maximum delay calculations from those
 336	 * sections.  For U1, it's tHubPort2PortExitLat, which is 1us max.  For
 337	 * U2, it's tHubPort2PortExitLat + U2DevExitLat - U1DevExitLat.  I
 338	 * assume the device exit latencies they are talking about are the hub
 339	 * exit latencies.
 340	 *
 341	 * What do we do if the U2 exit latency is less than the U1 exit
 342	 * latency?  It's possible, although not likely...
 343	 */
 344	port_to_port_delay = 1;
 345
 346	usb_set_lpm_pel(udev, &udev->u1_params, udev_u1_del,
 347			hub, &udev->parent->u1_params, hub_u1_del,
 348			port_to_port_delay);
 349
 350	if (hub_u2_del > hub_u1_del)
 351		port_to_port_delay = 1 + hub_u2_del - hub_u1_del;
 352	else
 353		port_to_port_delay = 1 + hub_u1_del;
 354
 355	usb_set_lpm_pel(udev, &udev->u2_params, udev_u2_del,
 356			hub, &udev->parent->u2_params, hub_u2_del,
 357			port_to_port_delay);
 358
 359	/* Now that we've got PEL, calculate SEL. */
 360	usb_set_lpm_sel(udev, &udev->u1_params);
 361	usb_set_lpm_sel(udev, &udev->u2_params);
 362}
 363
 364/* USB 2.0 spec Section 11.24.4.5 */
 365static int get_hub_descriptor(struct usb_device *hdev, void *data)
 
 366{
 367	int i, ret, size;
 368	unsigned dtype;
 369
 370	if (hub_is_superspeed(hdev)) {
 371		dtype = USB_DT_SS_HUB;
 372		size = USB_DT_SS_HUB_SIZE;
 373	} else {
 374		dtype = USB_DT_HUB;
 375		size = sizeof(struct usb_hub_descriptor);
 376	}
 377
 378	for (i = 0; i < 3; i++) {
 379		ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
 380			USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
 381			dtype << 8, 0, data, size,
 382			USB_CTRL_GET_TIMEOUT);
 383		if (ret >= (USB_DT_HUB_NONVAR_SIZE + 2))
 
 
 
 
 
 
 
 384			return ret;
 
 385	}
 386	return -EINVAL;
 387}
 388
 389/*
 390 * USB 2.0 spec Section 11.24.2.1
 391 */
 392static int clear_hub_feature(struct usb_device *hdev, int feature)
 393{
 394	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 395		USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, 1000);
 396}
 397
 398/*
 399 * USB 2.0 spec Section 11.24.2.2
 400 */
 401int usb_clear_port_feature(struct usb_device *hdev, int port1, int feature)
 402{
 403	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 404		USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
 405		NULL, 0, 1000);
 406}
 407
 408/*
 409 * USB 2.0 spec Section 11.24.2.13
 410 */
 411static int set_port_feature(struct usb_device *hdev, int port1, int feature)
 412{
 413	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 414		USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
 415		NULL, 0, 1000);
 416}
 417
 418static char *to_led_name(int selector)
 419{
 420	switch (selector) {
 421	case HUB_LED_AMBER:
 422		return "amber";
 423	case HUB_LED_GREEN:
 424		return "green";
 425	case HUB_LED_OFF:
 426		return "off";
 427	case HUB_LED_AUTO:
 428		return "auto";
 429	default:
 430		return "??";
 431	}
 432}
 433
 434/*
 435 * USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7
 436 * for info about using port indicators
 437 */
 438static void set_port_led(struct usb_hub *hub, int port1, int selector)
 439{
 440	struct usb_port *port_dev = hub->ports[port1 - 1];
 441	int status;
 442
 443	status = set_port_feature(hub->hdev, (selector << 8) | port1,
 444			USB_PORT_FEAT_INDICATOR);
 445	dev_dbg(&port_dev->dev, "indicator %s status %d\n",
 446		to_led_name(selector), status);
 447}
 448
 449#define	LED_CYCLE_PERIOD	((2*HZ)/3)
 450
 451static void led_work(struct work_struct *work)
 452{
 453	struct usb_hub		*hub =
 454		container_of(work, struct usb_hub, leds.work);
 455	struct usb_device	*hdev = hub->hdev;
 456	unsigned		i;
 457	unsigned		changed = 0;
 458	int			cursor = -1;
 459
 460	if (hdev->state != USB_STATE_CONFIGURED || hub->quiescing)
 461		return;
 462
 463	for (i = 0; i < hdev->maxchild; i++) {
 464		unsigned	selector, mode;
 465
 466		/* 30%-50% duty cycle */
 467
 468		switch (hub->indicator[i]) {
 469		/* cycle marker */
 470		case INDICATOR_CYCLE:
 471			cursor = i;
 472			selector = HUB_LED_AUTO;
 473			mode = INDICATOR_AUTO;
 474			break;
 475		/* blinking green = sw attention */
 476		case INDICATOR_GREEN_BLINK:
 477			selector = HUB_LED_GREEN;
 478			mode = INDICATOR_GREEN_BLINK_OFF;
 479			break;
 480		case INDICATOR_GREEN_BLINK_OFF:
 481			selector = HUB_LED_OFF;
 482			mode = INDICATOR_GREEN_BLINK;
 483			break;
 484		/* blinking amber = hw attention */
 485		case INDICATOR_AMBER_BLINK:
 486			selector = HUB_LED_AMBER;
 487			mode = INDICATOR_AMBER_BLINK_OFF;
 488			break;
 489		case INDICATOR_AMBER_BLINK_OFF:
 490			selector = HUB_LED_OFF;
 491			mode = INDICATOR_AMBER_BLINK;
 492			break;
 493		/* blink green/amber = reserved */
 494		case INDICATOR_ALT_BLINK:
 495			selector = HUB_LED_GREEN;
 496			mode = INDICATOR_ALT_BLINK_OFF;
 497			break;
 498		case INDICATOR_ALT_BLINK_OFF:
 499			selector = HUB_LED_AMBER;
 500			mode = INDICATOR_ALT_BLINK;
 501			break;
 502		default:
 503			continue;
 504		}
 505		if (selector != HUB_LED_AUTO)
 506			changed = 1;
 507		set_port_led(hub, i + 1, selector);
 508		hub->indicator[i] = mode;
 509	}
 510	if (!changed && blinkenlights) {
 511		cursor++;
 512		cursor %= hdev->maxchild;
 513		set_port_led(hub, cursor + 1, HUB_LED_GREEN);
 514		hub->indicator[cursor] = INDICATOR_CYCLE;
 515		changed++;
 516	}
 517	if (changed)
 518		queue_delayed_work(system_power_efficient_wq,
 519				&hub->leds, LED_CYCLE_PERIOD);
 520}
 521
 522/* use a short timeout for hub/port status fetches */
 523#define	USB_STS_TIMEOUT		1000
 524#define	USB_STS_RETRIES		5
 525
 526/*
 527 * USB 2.0 spec Section 11.24.2.6
 528 */
 529static int get_hub_status(struct usb_device *hdev,
 530		struct usb_hub_status *data)
 531{
 532	int i, status = -ETIMEDOUT;
 533
 534	for (i = 0; i < USB_STS_RETRIES &&
 535			(status == -ETIMEDOUT || status == -EPIPE); i++) {
 536		status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
 537			USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
 538			data, sizeof(*data), USB_STS_TIMEOUT);
 539	}
 540	return status;
 541}
 542
 543/*
 544 * USB 2.0 spec Section 11.24.2.7
 545 * USB 3.1 takes into use the wValue and wLength fields, spec Section 10.16.2.6
 546 */
 547static int get_port_status(struct usb_device *hdev, int port1,
 548			   void *data, u16 value, u16 length)
 549{
 550	int i, status = -ETIMEDOUT;
 551
 552	for (i = 0; i < USB_STS_RETRIES &&
 553			(status == -ETIMEDOUT || status == -EPIPE); i++) {
 554		status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
 555			USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, value,
 556			port1, data, length, USB_STS_TIMEOUT);
 557	}
 558	return status;
 559}
 560
 561static int hub_ext_port_status(struct usb_hub *hub, int port1, int type,
 562			       u16 *status, u16 *change, u32 *ext_status)
 563{
 564	int ret;
 565	int len = 4;
 566
 567	if (type != HUB_PORT_STATUS)
 568		len = 8;
 569
 570	mutex_lock(&hub->status_mutex);
 571	ret = get_port_status(hub->hdev, port1, &hub->status->port, type, len);
 572	if (ret < len) {
 573		if (ret != -ENODEV)
 574			dev_err(hub->intfdev,
 575				"%s failed (err = %d)\n", __func__, ret);
 576		if (ret >= 0)
 577			ret = -EIO;
 578	} else {
 579		*status = le16_to_cpu(hub->status->port.wPortStatus);
 580		*change = le16_to_cpu(hub->status->port.wPortChange);
 581		if (type != HUB_PORT_STATUS && ext_status)
 582			*ext_status = le32_to_cpu(
 583				hub->status->port.dwExtPortStatus);
 584		ret = 0;
 585	}
 586	mutex_unlock(&hub->status_mutex);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 587	return ret;
 588}
 589
 590static int hub_port_status(struct usb_hub *hub, int port1,
 591		u16 *status, u16 *change)
 592{
 593	return hub_ext_port_status(hub, port1, HUB_PORT_STATUS,
 594				   status, change, NULL);
 595}
 596
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 597static void kick_hub_wq(struct usb_hub *hub)
 598{
 599	struct usb_interface *intf;
 600
 601	if (hub->disconnected || work_pending(&hub->events))
 602		return;
 603
 604	/*
 605	 * Suppress autosuspend until the event is proceed.
 606	 *
 607	 * Be careful and make sure that the symmetric operation is
 608	 * always called. We are here only when there is no pending
 609	 * work for this hub. Therefore put the interface either when
 610	 * the new work is called or when it is canceled.
 611	 */
 612	intf = to_usb_interface(hub->intfdev);
 613	usb_autopm_get_interface_no_resume(intf);
 614	kref_get(&hub->kref);
 615
 616	if (queue_work(hub_wq, &hub->events))
 617		return;
 618
 619	/* the work has already been scheduled */
 620	usb_autopm_put_interface_async(intf);
 621	kref_put(&hub->kref, hub_release);
 622}
 623
 624void usb_kick_hub_wq(struct usb_device *hdev)
 625{
 626	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
 627
 628	if (hub)
 629		kick_hub_wq(hub);
 630}
 631
 632/*
 633 * Let the USB core know that a USB 3.0 device has sent a Function Wake Device
 634 * Notification, which indicates it had initiated remote wakeup.
 635 *
 636 * USB 3.0 hubs do not report the port link state change from U3 to U0 when the
 637 * device initiates resume, so the USB core will not receive notice of the
 638 * resume through the normal hub interrupt URB.
 639 */
 640void usb_wakeup_notification(struct usb_device *hdev,
 641		unsigned int portnum)
 642{
 643	struct usb_hub *hub;
 
 644
 645	if (!hdev)
 646		return;
 647
 648	hub = usb_hub_to_struct_hub(hdev);
 649	if (hub) {
 
 
 
 
 650		set_bit(portnum, hub->wakeup_bits);
 651		kick_hub_wq(hub);
 652	}
 653}
 654EXPORT_SYMBOL_GPL(usb_wakeup_notification);
 655
 656/* completion function, fires on port status changes and various faults */
 657static void hub_irq(struct urb *urb)
 658{
 659	struct usb_hub *hub = urb->context;
 660	int status = urb->status;
 661	unsigned i;
 662	unsigned long bits;
 663
 664	switch (status) {
 665	case -ENOENT:		/* synchronous unlink */
 666	case -ECONNRESET:	/* async unlink */
 667	case -ESHUTDOWN:	/* hardware going away */
 668		return;
 669
 670	default:		/* presumably an error */
 671		/* Cause a hub reset after 10 consecutive errors */
 672		dev_dbg(hub->intfdev, "transfer --> %d\n", status);
 673		if ((++hub->nerrors < 10) || hub->error)
 674			goto resubmit;
 675		hub->error = status;
 676		/* FALL THROUGH */
 677
 678	/* let hub_wq handle things */
 679	case 0:			/* we got data:  port status changed */
 680		bits = 0;
 681		for (i = 0; i < urb->actual_length; ++i)
 682			bits |= ((unsigned long) ((*hub->buffer)[i]))
 683					<< (i*8);
 684		hub->event_bits[0] = bits;
 685		break;
 686	}
 687
 688	hub->nerrors = 0;
 689
 690	/* Something happened, let hub_wq figure it out */
 691	kick_hub_wq(hub);
 692
 693resubmit:
 694	if (hub->quiescing)
 695		return;
 696
 697	status = usb_submit_urb(hub->urb, GFP_ATOMIC);
 698	if (status != 0 && status != -ENODEV && status != -EPERM)
 699		dev_err(hub->intfdev, "resubmit --> %d\n", status);
 700}
 701
 702/* USB 2.0 spec Section 11.24.2.3 */
 703static inline int
 704hub_clear_tt_buffer(struct usb_device *hdev, u16 devinfo, u16 tt)
 705{
 706	/* Need to clear both directions for control ep */
 707	if (((devinfo >> 11) & USB_ENDPOINT_XFERTYPE_MASK) ==
 708			USB_ENDPOINT_XFER_CONTROL) {
 709		int status = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 710				HUB_CLEAR_TT_BUFFER, USB_RT_PORT,
 711				devinfo ^ 0x8000, tt, NULL, 0, 1000);
 712		if (status)
 713			return status;
 714	}
 715	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
 716			       HUB_CLEAR_TT_BUFFER, USB_RT_PORT, devinfo,
 717			       tt, NULL, 0, 1000);
 718}
 719
 720/*
 721 * enumeration blocks hub_wq for a long time. we use keventd instead, since
 722 * long blocking there is the exception, not the rule.  accordingly, HCDs
 723 * talking to TTs must queue control transfers (not just bulk and iso), so
 724 * both can talk to the same hub concurrently.
 725 */
 726static void hub_tt_work(struct work_struct *work)
 727{
 728	struct usb_hub		*hub =
 729		container_of(work, struct usb_hub, tt.clear_work);
 730	unsigned long		flags;
 731
 732	spin_lock_irqsave(&hub->tt.lock, flags);
 733	while (!list_empty(&hub->tt.clear_list)) {
 734		struct list_head	*next;
 735		struct usb_tt_clear	*clear;
 736		struct usb_device	*hdev = hub->hdev;
 737		const struct hc_driver	*drv;
 738		int			status;
 739
 740		next = hub->tt.clear_list.next;
 741		clear = list_entry(next, struct usb_tt_clear, clear_list);
 742		list_del(&clear->clear_list);
 743
 744		/* drop lock so HCD can concurrently report other TT errors */
 745		spin_unlock_irqrestore(&hub->tt.lock, flags);
 746		status = hub_clear_tt_buffer(hdev, clear->devinfo, clear->tt);
 747		if (status && status != -ENODEV)
 748			dev_err(&hdev->dev,
 749				"clear tt %d (%04x) error %d\n",
 750				clear->tt, clear->devinfo, status);
 751
 752		/* Tell the HCD, even if the operation failed */
 753		drv = clear->hcd->driver;
 754		if (drv->clear_tt_buffer_complete)
 755			(drv->clear_tt_buffer_complete)(clear->hcd, clear->ep);
 756
 757		kfree(clear);
 758		spin_lock_irqsave(&hub->tt.lock, flags);
 759	}
 760	spin_unlock_irqrestore(&hub->tt.lock, flags);
 761}
 762
 763/**
 764 * usb_hub_set_port_power - control hub port's power state
 765 * @hdev: USB device belonging to the usb hub
 766 * @hub: target hub
 767 * @port1: port index
 768 * @set: expected status
 769 *
 770 * call this function to control port's power via setting or
 771 * clearing the port's PORT_POWER feature.
 772 *
 773 * Return: 0 if successful. A negative error code otherwise.
 774 */
 775int usb_hub_set_port_power(struct usb_device *hdev, struct usb_hub *hub,
 776			   int port1, bool set)
 777{
 778	int ret;
 779
 780	if (set)
 781		ret = set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
 782	else
 783		ret = usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
 784
 785	if (ret)
 786		return ret;
 787
 788	if (set)
 789		set_bit(port1, hub->power_bits);
 790	else
 791		clear_bit(port1, hub->power_bits);
 792	return 0;
 793}
 794
 795/**
 796 * usb_hub_clear_tt_buffer - clear control/bulk TT state in high speed hub
 797 * @urb: an URB associated with the failed or incomplete split transaction
 798 *
 799 * High speed HCDs use this to tell the hub driver that some split control or
 800 * bulk transaction failed in a way that requires clearing internal state of
 801 * a transaction translator.  This is normally detected (and reported) from
 802 * interrupt context.
 803 *
 804 * It may not be possible for that hub to handle additional full (or low)
 805 * speed transactions until that state is fully cleared out.
 806 *
 807 * Return: 0 if successful. A negative error code otherwise.
 808 */
 809int usb_hub_clear_tt_buffer(struct urb *urb)
 810{
 811	struct usb_device	*udev = urb->dev;
 812	int			pipe = urb->pipe;
 813	struct usb_tt		*tt = udev->tt;
 814	unsigned long		flags;
 815	struct usb_tt_clear	*clear;
 816
 817	/* we've got to cope with an arbitrary number of pending TT clears,
 818	 * since each TT has "at least two" buffers that can need it (and
 819	 * there can be many TTs per hub).  even if they're uncommon.
 820	 */
 821	clear = kmalloc(sizeof *clear, GFP_ATOMIC);
 822	if (clear == NULL) {
 823		dev_err(&udev->dev, "can't save CLEAR_TT_BUFFER state\n");
 824		/* FIXME recover somehow ... RESET_TT? */
 825		return -ENOMEM;
 826	}
 827
 828	/* info that CLEAR_TT_BUFFER needs */
 829	clear->tt = tt->multi ? udev->ttport : 1;
 830	clear->devinfo = usb_pipeendpoint (pipe);
 831	clear->devinfo |= udev->devnum << 4;
 832	clear->devinfo |= usb_pipecontrol(pipe)
 833			? (USB_ENDPOINT_XFER_CONTROL << 11)
 834			: (USB_ENDPOINT_XFER_BULK << 11);
 835	if (usb_pipein(pipe))
 836		clear->devinfo |= 1 << 15;
 837
 838	/* info for completion callback */
 839	clear->hcd = bus_to_hcd(udev->bus);
 840	clear->ep = urb->ep;
 841
 842	/* tell keventd to clear state for this TT */
 843	spin_lock_irqsave(&tt->lock, flags);
 844	list_add_tail(&clear->clear_list, &tt->clear_list);
 845	schedule_work(&tt->clear_work);
 846	spin_unlock_irqrestore(&tt->lock, flags);
 847	return 0;
 848}
 849EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer);
 850
 851static void hub_power_on(struct usb_hub *hub, bool do_delay)
 852{
 853	int port1;
 854
 855	/* Enable power on each port.  Some hubs have reserved values
 856	 * of LPSM (> 2) in their descriptors, even though they are
 857	 * USB 2.0 hubs.  Some hubs do not implement port-power switching
 858	 * but only emulate it.  In all cases, the ports won't work
 859	 * unless we send these messages to the hub.
 860	 */
 861	if (hub_is_port_power_switchable(hub))
 862		dev_dbg(hub->intfdev, "enabling power on all ports\n");
 863	else
 864		dev_dbg(hub->intfdev, "trying to enable port power on "
 865				"non-switchable hub\n");
 866	for (port1 = 1; port1 <= hub->hdev->maxchild; port1++)
 867		if (test_bit(port1, hub->power_bits))
 868			set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
 869		else
 870			usb_clear_port_feature(hub->hdev, port1,
 871						USB_PORT_FEAT_POWER);
 872	if (do_delay)
 873		msleep(hub_power_on_good_delay(hub));
 874}
 875
 876static int hub_hub_status(struct usb_hub *hub,
 877		u16 *status, u16 *change)
 878{
 879	int ret;
 880
 881	mutex_lock(&hub->status_mutex);
 882	ret = get_hub_status(hub->hdev, &hub->status->hub);
 883	if (ret < 0) {
 884		if (ret != -ENODEV)
 885			dev_err(hub->intfdev,
 886				"%s failed (err = %d)\n", __func__, ret);
 887	} else {
 888		*status = le16_to_cpu(hub->status->hub.wHubStatus);
 889		*change = le16_to_cpu(hub->status->hub.wHubChange);
 890		ret = 0;
 891	}
 892	mutex_unlock(&hub->status_mutex);
 893	return ret;
 894}
 895
 896static int hub_set_port_link_state(struct usb_hub *hub, int port1,
 897			unsigned int link_status)
 898{
 899	return set_port_feature(hub->hdev,
 900			port1 | (link_status << 3),
 901			USB_PORT_FEAT_LINK_STATE);
 902}
 903
 904/*
 905 * Disable a port and mark a logical connect-change event, so that some
 906 * time later hub_wq will disconnect() any existing usb_device on the port
 907 * and will re-enumerate if there actually is a device attached.
 908 */
 909static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
 910{
 911	dev_dbg(&hub->ports[port1 - 1]->dev, "logical disconnect\n");
 912	hub_port_disable(hub, port1, 1);
 913
 914	/* FIXME let caller ask to power down the port:
 915	 *  - some devices won't enumerate without a VBUS power cycle
 916	 *  - SRP saves power that way
 917	 *  - ... new call, TBD ...
 918	 * That's easy if this hub can switch power per-port, and
 919	 * hub_wq reactivates the port later (timer, SRP, etc).
 920	 * Powerdown must be optional, because of reset/DFU.
 921	 */
 922
 923	set_bit(port1, hub->change_bits);
 924	kick_hub_wq(hub);
 925}
 926
 927/**
 928 * usb_remove_device - disable a device's port on its parent hub
 929 * @udev: device to be disabled and removed
 930 * Context: @udev locked, must be able to sleep.
 931 *
 932 * After @udev's port has been disabled, hub_wq is notified and it will
 933 * see that the device has been disconnected.  When the device is
 934 * physically unplugged and something is plugged in, the events will
 935 * be received and processed normally.
 936 *
 937 * Return: 0 if successful. A negative error code otherwise.
 938 */
 939int usb_remove_device(struct usb_device *udev)
 940{
 941	struct usb_hub *hub;
 942	struct usb_interface *intf;
 
 943
 944	if (!udev->parent)	/* Can't remove a root hub */
 945		return -EINVAL;
 946	hub = usb_hub_to_struct_hub(udev->parent);
 947	intf = to_usb_interface(hub->intfdev);
 948
 949	usb_autopm_get_interface(intf);
 
 
 
 950	set_bit(udev->portnum, hub->removed_bits);
 951	hub_port_logical_disconnect(hub, udev->portnum);
 952	usb_autopm_put_interface(intf);
 953	return 0;
 954}
 955
 956enum hub_activation_type {
 957	HUB_INIT, HUB_INIT2, HUB_INIT3,		/* INITs must come first */
 958	HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME,
 959};
 960
 961static void hub_init_func2(struct work_struct *ws);
 962static void hub_init_func3(struct work_struct *ws);
 963
 964static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
 965{
 966	struct usb_device *hdev = hub->hdev;
 967	struct usb_hcd *hcd;
 968	int ret;
 969	int port1;
 970	int status;
 971	bool need_debounce_delay = false;
 972	unsigned delay;
 973
 974	/* Continue a partial initialization */
 975	if (type == HUB_INIT2 || type == HUB_INIT3) {
 976		device_lock(&hdev->dev);
 977
 978		/* Was the hub disconnected while we were waiting? */
 979		if (hub->disconnected)
 980			goto disconnected;
 981		if (type == HUB_INIT2)
 982			goto init2;
 983		goto init3;
 984	}
 985	kref_get(&hub->kref);
 986
 987	/* The superspeed hub except for root hub has to use Hub Depth
 988	 * value as an offset into the route string to locate the bits
 989	 * it uses to determine the downstream port number. So hub driver
 990	 * should send a set hub depth request to superspeed hub after
 991	 * the superspeed hub is set configuration in initialization or
 992	 * reset procedure.
 993	 *
 994	 * After a resume, port power should still be on.
 995	 * For any other type of activation, turn it on.
 996	 */
 997	if (type != HUB_RESUME) {
 998		if (hdev->parent && hub_is_superspeed(hdev)) {
 999			ret = usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
1000					HUB_SET_DEPTH, USB_RT_HUB,
1001					hdev->level - 1, 0, NULL, 0,
1002					USB_CTRL_SET_TIMEOUT);
1003			if (ret < 0)
1004				dev_err(hub->intfdev,
1005						"set hub depth failed\n");
1006		}
1007
1008		/* Speed up system boot by using a delayed_work for the
1009		 * hub's initial power-up delays.  This is pretty awkward
1010		 * and the implementation looks like a home-brewed sort of
1011		 * setjmp/longjmp, but it saves at least 100 ms for each
1012		 * root hub (assuming usbcore is compiled into the kernel
1013		 * rather than as a module).  It adds up.
1014		 *
1015		 * This can't be done for HUB_RESUME or HUB_RESET_RESUME
1016		 * because for those activation types the ports have to be
1017		 * operational when we return.  In theory this could be done
1018		 * for HUB_POST_RESET, but it's easier not to.
1019		 */
1020		if (type == HUB_INIT) {
1021			delay = hub_power_on_good_delay(hub);
1022
1023			hub_power_on(hub, false);
1024			INIT_DELAYED_WORK(&hub->init_work, hub_init_func2);
1025			queue_delayed_work(system_power_efficient_wq,
1026					&hub->init_work,
1027					msecs_to_jiffies(delay));
1028
1029			/* Suppress autosuspend until init is done */
1030			usb_autopm_get_interface_no_resume(
1031					to_usb_interface(hub->intfdev));
1032			return;		/* Continues at init2: below */
1033		} else if (type == HUB_RESET_RESUME) {
1034			/* The internal host controller state for the hub device
1035			 * may be gone after a host power loss on system resume.
1036			 * Update the device's info so the HW knows it's a hub.
1037			 */
1038			hcd = bus_to_hcd(hdev->bus);
1039			if (hcd->driver->update_hub_device) {
1040				ret = hcd->driver->update_hub_device(hcd, hdev,
1041						&hub->tt, GFP_NOIO);
1042				if (ret < 0) {
1043					dev_err(hub->intfdev, "Host not "
1044							"accepting hub info "
1045							"update.\n");
1046					dev_err(hub->intfdev, "LS/FS devices "
1047							"and hubs may not work "
1048							"under this hub\n.");
1049				}
1050			}
1051			hub_power_on(hub, true);
1052		} else {
1053			hub_power_on(hub, true);
1054		}
1055	}
 
 
 
1056 init2:
1057
1058	/*
1059	 * Check each port and set hub->change_bits to let hub_wq know
1060	 * which ports need attention.
1061	 */
1062	for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
1063		struct usb_port *port_dev = hub->ports[port1 - 1];
1064		struct usb_device *udev = port_dev->child;
1065		u16 portstatus, portchange;
1066
1067		portstatus = portchange = 0;
1068		status = hub_port_status(hub, port1, &portstatus, &portchange);
 
 
 
1069		if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
1070			dev_dbg(&port_dev->dev, "status %04x change %04x\n",
1071					portstatus, portchange);
1072
1073		/*
1074		 * After anything other than HUB_RESUME (i.e., initialization
1075		 * or any sort of reset), every port should be disabled.
1076		 * Unconnected ports should likewise be disabled (paranoia),
1077		 * and so should ports for which we have no usb_device.
1078		 */
1079		if ((portstatus & USB_PORT_STAT_ENABLE) && (
1080				type != HUB_RESUME ||
1081				!(portstatus & USB_PORT_STAT_CONNECTION) ||
1082				!udev ||
1083				udev->state == USB_STATE_NOTATTACHED)) {
1084			/*
1085			 * USB3 protocol ports will automatically transition
1086			 * to Enabled state when detect an USB3.0 device attach.
1087			 * Do not disable USB3 protocol ports, just pretend
1088			 * power was lost
1089			 */
1090			portstatus &= ~USB_PORT_STAT_ENABLE;
1091			if (!hub_is_superspeed(hdev))
1092				usb_clear_port_feature(hdev, port1,
1093						   USB_PORT_FEAT_ENABLE);
1094		}
1095
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1096		/* Clear status-change flags; we'll debounce later */
1097		if (portchange & USB_PORT_STAT_C_CONNECTION) {
1098			need_debounce_delay = true;
1099			usb_clear_port_feature(hub->hdev, port1,
1100					USB_PORT_FEAT_C_CONNECTION);
1101		}
1102		if (portchange & USB_PORT_STAT_C_ENABLE) {
1103			need_debounce_delay = true;
1104			usb_clear_port_feature(hub->hdev, port1,
1105					USB_PORT_FEAT_C_ENABLE);
1106		}
1107		if (portchange & USB_PORT_STAT_C_RESET) {
1108			need_debounce_delay = true;
1109			usb_clear_port_feature(hub->hdev, port1,
1110					USB_PORT_FEAT_C_RESET);
1111		}
1112		if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
1113				hub_is_superspeed(hub->hdev)) {
1114			need_debounce_delay = true;
1115			usb_clear_port_feature(hub->hdev, port1,
1116					USB_PORT_FEAT_C_BH_PORT_RESET);
1117		}
1118		/* We can forget about a "removed" device when there's a
1119		 * physical disconnect or the connect status changes.
1120		 */
1121		if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
1122				(portchange & USB_PORT_STAT_C_CONNECTION))
1123			clear_bit(port1, hub->removed_bits);
1124
1125		if (!udev || udev->state == USB_STATE_NOTATTACHED) {
1126			/* Tell hub_wq to disconnect the device or
1127			 * check for a new connection
 
 
 
1128			 */
1129			if (udev || (portstatus & USB_PORT_STAT_CONNECTION) ||
1130			    (portstatus & USB_PORT_STAT_OVERCURRENT))
 
 
1131				set_bit(port1, hub->change_bits);
1132
1133		} else if (portstatus & USB_PORT_STAT_ENABLE) {
1134			bool port_resumed = (portstatus &
1135					USB_PORT_STAT_LINK_STATE) ==
1136				USB_SS_PORT_LS_U0;
1137			/* The power session apparently survived the resume.
1138			 * If there was an overcurrent or suspend change
1139			 * (i.e., remote wakeup request), have hub_wq
1140			 * take care of it.  Look at the port link state
1141			 * for USB 3.0 hubs, since they don't have a suspend
1142			 * change bit, and they don't set the port link change
1143			 * bit on device-initiated resume.
1144			 */
1145			if (portchange || (hub_is_superspeed(hub->hdev) &&
1146						port_resumed))
1147				set_bit(port1, hub->change_bits);
1148
1149		} else if (udev->persist_enabled) {
1150#ifdef CONFIG_PM
1151			udev->reset_resume = 1;
1152#endif
1153			/* Don't set the change_bits when the device
1154			 * was powered off.
1155			 */
1156			if (test_bit(port1, hub->power_bits))
1157				set_bit(port1, hub->change_bits);
1158
1159		} else {
1160			/* The power session is gone; tell hub_wq */
1161			usb_set_device_state(udev, USB_STATE_NOTATTACHED);
1162			set_bit(port1, hub->change_bits);
1163		}
1164	}
1165
1166	/* If no port-status-change flags were set, we don't need any
1167	 * debouncing.  If flags were set we can try to debounce the
1168	 * ports all at once right now, instead of letting hub_wq do them
1169	 * one at a time later on.
1170	 *
1171	 * If any port-status changes do occur during this delay, hub_wq
1172	 * will see them later and handle them normally.
1173	 */
1174	if (need_debounce_delay) {
1175		delay = HUB_DEBOUNCE_STABLE;
1176
1177		/* Don't do a long sleep inside a workqueue routine */
1178		if (type == HUB_INIT2) {
1179			INIT_DELAYED_WORK(&hub->init_work, hub_init_func3);
1180			queue_delayed_work(system_power_efficient_wq,
1181					&hub->init_work,
1182					msecs_to_jiffies(delay));
1183			device_unlock(&hdev->dev);
1184			return;		/* Continues at init3: below */
1185		} else {
1186			msleep(delay);
1187		}
1188	}
1189 init3:
1190	hub->quiescing = 0;
1191
1192	status = usb_submit_urb(hub->urb, GFP_NOIO);
1193	if (status < 0)
1194		dev_err(hub->intfdev, "activate --> %d\n", status);
1195	if (hub->has_indicators && blinkenlights)
1196		queue_delayed_work(system_power_efficient_wq,
1197				&hub->leds, LED_CYCLE_PERIOD);
1198
1199	/* Scan all ports that need attention */
1200	kick_hub_wq(hub);
1201
1202	if (type == HUB_INIT2 || type == HUB_INIT3) {
1203		/* Allow autosuspend if it was suppressed */
1204 disconnected:
1205		usb_autopm_put_interface_async(to_usb_interface(hub->intfdev));
1206		device_unlock(&hdev->dev);
1207	}
1208
1209	kref_put(&hub->kref, hub_release);
1210}
1211
1212/* Implement the continuations for the delays above */
1213static void hub_init_func2(struct work_struct *ws)
1214{
1215	struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
1216
1217	hub_activate(hub, HUB_INIT2);
1218}
1219
1220static void hub_init_func3(struct work_struct *ws)
1221{
1222	struct usb_hub *hub = container_of(ws, struct usb_hub, init_work.work);
1223
1224	hub_activate(hub, HUB_INIT3);
1225}
1226
1227enum hub_quiescing_type {
1228	HUB_DISCONNECT, HUB_PRE_RESET, HUB_SUSPEND
1229};
1230
1231static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
1232{
1233	struct usb_device *hdev = hub->hdev;
 
1234	int i;
1235
1236	/* hub_wq and related activity won't re-trigger */
 
1237	hub->quiescing = 1;
 
1238
1239	if (type != HUB_SUSPEND) {
1240		/* Disconnect all the children */
1241		for (i = 0; i < hdev->maxchild; ++i) {
1242			if (hub->ports[i]->child)
1243				usb_disconnect(&hub->ports[i]->child);
1244		}
1245	}
1246
1247	/* Stop hub_wq and related activity */
 
1248	usb_kill_urb(hub->urb);
1249	if (hub->has_indicators)
1250		cancel_delayed_work_sync(&hub->leds);
1251	if (hub->tt.hub)
1252		flush_work(&hub->tt.clear_work);
1253}
1254
1255static void hub_pm_barrier_for_all_ports(struct usb_hub *hub)
1256{
1257	int i;
1258
1259	for (i = 0; i < hub->hdev->maxchild; ++i)
1260		pm_runtime_barrier(&hub->ports[i]->dev);
1261}
1262
1263/* caller has locked the hub device */
1264static int hub_pre_reset(struct usb_interface *intf)
1265{
1266	struct usb_hub *hub = usb_get_intfdata(intf);
1267
1268	hub_quiesce(hub, HUB_PRE_RESET);
1269	hub->in_reset = 1;
1270	hub_pm_barrier_for_all_ports(hub);
1271	return 0;
1272}
1273
1274/* caller has locked the hub device */
1275static int hub_post_reset(struct usb_interface *intf)
1276{
1277	struct usb_hub *hub = usb_get_intfdata(intf);
1278
1279	hub->in_reset = 0;
1280	hub_pm_barrier_for_all_ports(hub);
1281	hub_activate(hub, HUB_POST_RESET);
1282	return 0;
1283}
1284
1285static int hub_configure(struct usb_hub *hub,
1286	struct usb_endpoint_descriptor *endpoint)
1287{
1288	struct usb_hcd *hcd;
1289	struct usb_device *hdev = hub->hdev;
1290	struct device *hub_dev = hub->intfdev;
1291	u16 hubstatus, hubchange;
1292	u16 wHubCharacteristics;
1293	unsigned int pipe;
1294	int maxp, ret, i;
1295	char *message = "out of memory";
1296	unsigned unit_load;
1297	unsigned full_load;
1298	unsigned maxchild;
1299
1300	hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
1301	if (!hub->buffer) {
1302		ret = -ENOMEM;
1303		goto fail;
1304	}
1305
1306	hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
1307	if (!hub->status) {
1308		ret = -ENOMEM;
1309		goto fail;
1310	}
1311	mutex_init(&hub->status_mutex);
1312
1313	hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
1314	if (!hub->descriptor) {
1315		ret = -ENOMEM;
1316		goto fail;
1317	}
1318
1319	/* Request the entire hub descriptor.
1320	 * hub->descriptor can handle USB_MAXCHILDREN ports,
1321	 * but the hub can/will return fewer bytes here.
1322	 */
1323	ret = get_hub_descriptor(hdev, hub->descriptor);
1324	if (ret < 0) {
1325		message = "can't read hub descriptor";
1326		goto fail;
1327	} else if (hub->descriptor->bNbrPorts > USB_MAXCHILDREN) {
 
 
 
 
 
 
1328		message = "hub has too many ports!";
1329		ret = -ENODEV;
1330		goto fail;
1331	} else if (hub->descriptor->bNbrPorts == 0) {
1332		message = "hub doesn't have any ports!";
1333		ret = -ENODEV;
1334		goto fail;
1335	}
1336
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1337	maxchild = hub->descriptor->bNbrPorts;
1338	dev_info(hub_dev, "%d port%s detected\n", maxchild,
1339			(maxchild == 1) ? "" : "s");
1340
1341	hub->ports = kzalloc(maxchild * sizeof(struct usb_port *), GFP_KERNEL);
1342	if (!hub->ports) {
1343		ret = -ENOMEM;
1344		goto fail;
1345	}
1346
1347	wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
1348	if (hub_is_superspeed(hdev)) {
1349		unit_load = 150;
1350		full_load = 900;
1351	} else {
1352		unit_load = 100;
1353		full_load = 500;
1354	}
1355
1356	/* FIXME for USB 3.0, skip for now */
1357	if ((wHubCharacteristics & HUB_CHAR_COMPOUND) &&
1358			!(hub_is_superspeed(hdev))) {
1359		char	portstr[USB_MAXCHILDREN + 1];
1360
1361		for (i = 0; i < maxchild; i++)
1362			portstr[i] = hub->descriptor->u.hs.DeviceRemovable
1363				    [((i + 1) / 8)] & (1 << ((i + 1) % 8))
1364				? 'F' : 'R';
1365		portstr[maxchild] = 0;
1366		dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
1367	} else
1368		dev_dbg(hub_dev, "standalone hub\n");
1369
1370	switch (wHubCharacteristics & HUB_CHAR_LPSM) {
1371	case HUB_CHAR_COMMON_LPSM:
1372		dev_dbg(hub_dev, "ganged power switching\n");
1373		break;
1374	case HUB_CHAR_INDV_PORT_LPSM:
1375		dev_dbg(hub_dev, "individual port power switching\n");
1376		break;
1377	case HUB_CHAR_NO_LPSM:
1378	case HUB_CHAR_LPSM:
1379		dev_dbg(hub_dev, "no power switching (usb 1.0)\n");
1380		break;
1381	}
1382
1383	switch (wHubCharacteristics & HUB_CHAR_OCPM) {
1384	case HUB_CHAR_COMMON_OCPM:
1385		dev_dbg(hub_dev, "global over-current protection\n");
1386		break;
1387	case HUB_CHAR_INDV_PORT_OCPM:
1388		dev_dbg(hub_dev, "individual port over-current protection\n");
1389		break;
1390	case HUB_CHAR_NO_OCPM:
1391	case HUB_CHAR_OCPM:
1392		dev_dbg(hub_dev, "no over-current protection\n");
1393		break;
1394	}
1395
1396	spin_lock_init(&hub->tt.lock);
1397	INIT_LIST_HEAD(&hub->tt.clear_list);
1398	INIT_WORK(&hub->tt.clear_work, hub_tt_work);
1399	switch (hdev->descriptor.bDeviceProtocol) {
1400	case USB_HUB_PR_FS:
1401		break;
1402	case USB_HUB_PR_HS_SINGLE_TT:
1403		dev_dbg(hub_dev, "Single TT\n");
1404		hub->tt.hub = hdev;
1405		break;
1406	case USB_HUB_PR_HS_MULTI_TT:
1407		ret = usb_set_interface(hdev, 0, 1);
1408		if (ret == 0) {
1409			dev_dbg(hub_dev, "TT per port\n");
1410			hub->tt.multi = 1;
1411		} else
1412			dev_err(hub_dev, "Using single TT (err %d)\n",
1413				ret);
1414		hub->tt.hub = hdev;
1415		break;
1416	case USB_HUB_PR_SS:
1417		/* USB 3.0 hubs don't have a TT */
1418		break;
1419	default:
1420		dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",
1421			hdev->descriptor.bDeviceProtocol);
1422		break;
1423	}
1424
1425	/* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
1426	switch (wHubCharacteristics & HUB_CHAR_TTTT) {
1427	case HUB_TTTT_8_BITS:
1428		if (hdev->descriptor.bDeviceProtocol != 0) {
1429			hub->tt.think_time = 666;
1430			dev_dbg(hub_dev, "TT requires at most %d "
1431					"FS bit times (%d ns)\n",
1432				8, hub->tt.think_time);
1433		}
1434		break;
1435	case HUB_TTTT_16_BITS:
1436		hub->tt.think_time = 666 * 2;
1437		dev_dbg(hub_dev, "TT requires at most %d "
1438				"FS bit times (%d ns)\n",
1439			16, hub->tt.think_time);
1440		break;
1441	case HUB_TTTT_24_BITS:
1442		hub->tt.think_time = 666 * 3;
1443		dev_dbg(hub_dev, "TT requires at most %d "
1444				"FS bit times (%d ns)\n",
1445			24, hub->tt.think_time);
1446		break;
1447	case HUB_TTTT_32_BITS:
1448		hub->tt.think_time = 666 * 4;
1449		dev_dbg(hub_dev, "TT requires at most %d "
1450				"FS bit times (%d ns)\n",
1451			32, hub->tt.think_time);
1452		break;
1453	}
1454
1455	/* probe() zeroes hub->indicator[] */
1456	if (wHubCharacteristics & HUB_CHAR_PORTIND) {
1457		hub->has_indicators = 1;
1458		dev_dbg(hub_dev, "Port indicators are supported\n");
1459	}
1460
1461	dev_dbg(hub_dev, "power on to power good time: %dms\n",
1462		hub->descriptor->bPwrOn2PwrGood * 2);
1463
1464	/* power budgeting mostly matters with bus-powered hubs,
1465	 * and battery-powered root hubs (may provide just 8 mA).
1466	 */
1467	ret = usb_get_status(hdev, USB_RECIP_DEVICE, 0, &hubstatus);
1468	if (ret) {
1469		message = "can't get hub status";
1470		goto fail;
1471	}
1472	hcd = bus_to_hcd(hdev->bus);
1473	if (hdev == hdev->bus->root_hub) {
1474		if (hcd->power_budget > 0)
1475			hdev->bus_mA = hcd->power_budget;
1476		else
1477			hdev->bus_mA = full_load * maxchild;
1478		if (hdev->bus_mA >= full_load)
1479			hub->mA_per_port = full_load;
1480		else {
1481			hub->mA_per_port = hdev->bus_mA;
1482			hub->limited_power = 1;
1483		}
1484	} else if ((hubstatus & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
1485		int remaining = hdev->bus_mA -
1486			hub->descriptor->bHubContrCurrent;
1487
1488		dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
1489			hub->descriptor->bHubContrCurrent);
1490		hub->limited_power = 1;
1491
1492		if (remaining < maxchild * unit_load)
1493			dev_warn(hub_dev,
1494					"insufficient power available "
1495					"to use all downstream ports\n");
1496		hub->mA_per_port = unit_load;	/* 7.2.1 */
1497
1498	} else {	/* Self-powered external hub */
1499		/* FIXME: What about battery-powered external hubs that
1500		 * provide less current per port? */
1501		hub->mA_per_port = full_load;
1502	}
1503	if (hub->mA_per_port < full_load)
1504		dev_dbg(hub_dev, "%umA bus power budget for each child\n",
1505				hub->mA_per_port);
1506
1507	ret = hub_hub_status(hub, &hubstatus, &hubchange);
1508	if (ret < 0) {
1509		message = "can't get hub status";
1510		goto fail;
1511	}
1512
1513	/* local power status reports aren't always correct */
1514	if (hdev->actconfig->desc.bmAttributes & USB_CONFIG_ATT_SELFPOWER)
1515		dev_dbg(hub_dev, "local power source is %s\n",
1516			(hubstatus & HUB_STATUS_LOCAL_POWER)
1517			? "lost (inactive)" : "good");
1518
1519	if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
1520		dev_dbg(hub_dev, "%sover-current condition exists\n",
1521			(hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
1522
1523	/* set up the interrupt endpoint
1524	 * We use the EP's maxpacket size instead of (PORTS+1+7)/8
1525	 * bytes as USB2.0[11.12.3] says because some hubs are known
1526	 * to send more data (and thus cause overflow). For root hubs,
1527	 * maxpktsize is defined in hcd.c's fake endpoint descriptors
1528	 * to be big enough for at least USB_MAXCHILDREN ports. */
1529	pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
1530	maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
1531
1532	if (maxp > sizeof(*hub->buffer))
1533		maxp = sizeof(*hub->buffer);
1534
1535	hub->urb = usb_alloc_urb(0, GFP_KERNEL);
1536	if (!hub->urb) {
1537		ret = -ENOMEM;
1538		goto fail;
1539	}
1540
1541	usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq,
1542		hub, endpoint->bInterval);
1543
1544	/* maybe cycle the hub leds */
1545	if (hub->has_indicators && blinkenlights)
1546		hub->indicator[0] = INDICATOR_CYCLE;
1547
1548	mutex_lock(&usb_port_peer_mutex);
1549	for (i = 0; i < maxchild; i++) {
1550		ret = usb_hub_create_port_device(hub, i + 1);
1551		if (ret < 0) {
1552			dev_err(hub->intfdev,
1553				"couldn't create port%d device.\n", i + 1);
1554			break;
1555		}
1556	}
1557	hdev->maxchild = i;
1558	for (i = 0; i < hdev->maxchild; i++) {
1559		struct usb_port *port_dev = hub->ports[i];
1560
1561		pm_runtime_put(&port_dev->dev);
1562	}
1563
1564	mutex_unlock(&usb_port_peer_mutex);
1565	if (ret < 0)
1566		goto fail;
1567
1568	/* Update the HCD's internal representation of this hub before hub_wq
1569	 * starts getting port status changes for devices under the hub.
1570	 */
1571	if (hcd->driver->update_hub_device) {
1572		ret = hcd->driver->update_hub_device(hcd, hdev,
1573				&hub->tt, GFP_KERNEL);
1574		if (ret < 0) {
1575			message = "can't update HCD hub info";
1576			goto fail;
1577		}
1578	}
1579
1580	usb_hub_adjust_deviceremovable(hdev, hub->descriptor);
1581
1582	hub_activate(hub, HUB_INIT);
1583	return 0;
1584
1585fail:
1586	dev_err(hub_dev, "config failed, %s (err %d)\n",
1587			message, ret);
1588	/* hub_disconnect() frees urb and descriptor */
1589	return ret;
1590}
1591
1592static void hub_release(struct kref *kref)
1593{
1594	struct usb_hub *hub = container_of(kref, struct usb_hub, kref);
1595
1596	usb_put_dev(hub->hdev);
1597	usb_put_intf(to_usb_interface(hub->intfdev));
1598	kfree(hub);
1599}
1600
 
 
 
 
 
 
 
 
 
 
1601static unsigned highspeed_hubs;
1602
1603static void hub_disconnect(struct usb_interface *intf)
1604{
1605	struct usb_hub *hub = usb_get_intfdata(intf);
1606	struct usb_device *hdev = interface_to_usbdev(intf);
1607	int port1;
1608
1609	/*
1610	 * Stop adding new hub events. We do not want to block here and thus
1611	 * will not try to remove any pending work item.
1612	 */
1613	hub->disconnected = 1;
1614
1615	/* Disconnect all children and quiesce the hub */
1616	hub->error = 0;
1617	hub_quiesce(hub, HUB_DISCONNECT);
1618
1619	mutex_lock(&usb_port_peer_mutex);
1620
1621	/* Avoid races with recursively_mark_NOTATTACHED() */
1622	spin_lock_irq(&device_state_lock);
1623	port1 = hdev->maxchild;
1624	hdev->maxchild = 0;
1625	usb_set_intfdata(intf, NULL);
1626	spin_unlock_irq(&device_state_lock);
1627
1628	for (; port1 > 0; --port1)
1629		usb_hub_remove_port_device(hub, port1);
1630
1631	mutex_unlock(&usb_port_peer_mutex);
1632
1633	if (hub->hdev->speed == USB_SPEED_HIGH)
1634		highspeed_hubs--;
1635
1636	usb_free_urb(hub->urb);
1637	kfree(hub->ports);
1638	kfree(hub->descriptor);
1639	kfree(hub->status);
1640	kfree(hub->buffer);
1641
1642	pm_suspend_ignore_children(&intf->dev, false);
1643	kref_put(&hub->kref, hub_release);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1644}
1645
1646static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
1647{
1648	struct usb_host_interface *desc;
1649	struct usb_endpoint_descriptor *endpoint;
1650	struct usb_device *hdev;
1651	struct usb_hub *hub;
1652
1653	desc = intf->cur_altsetting;
1654	hdev = interface_to_usbdev(intf);
1655
1656	/*
1657	 * Set default autosuspend delay as 0 to speedup bus suspend,
1658	 * based on the below considerations:
1659	 *
1660	 * - Unlike other drivers, the hub driver does not rely on the
1661	 *   autosuspend delay to provide enough time to handle a wakeup
1662	 *   event, and the submitted status URB is just to check future
1663	 *   change on hub downstream ports, so it is safe to do it.
1664	 *
1665	 * - The patch might cause one or more auto supend/resume for
1666	 *   below very rare devices when they are plugged into hub
1667	 *   first time:
1668	 *
1669	 *   	devices having trouble initializing, and disconnect
1670	 *   	themselves from the bus and then reconnect a second
1671	 *   	or so later
1672	 *
1673	 *   	devices just for downloading firmware, and disconnects
1674	 *   	themselves after completing it
1675	 *
1676	 *   For these quite rare devices, their drivers may change the
1677	 *   autosuspend delay of their parent hub in the probe() to one
1678	 *   appropriate value to avoid the subtle problem if someone
1679	 *   does care it.
1680	 *
1681	 * - The patch may cause one or more auto suspend/resume on
1682	 *   hub during running 'lsusb', but it is probably too
1683	 *   infrequent to worry about.
1684	 *
1685	 * - Change autosuspend delay of hub can avoid unnecessary auto
1686	 *   suspend timer for hub, also may decrease power consumption
1687	 *   of USB bus.
1688	 *
1689	 * - If user has indicated to prevent autosuspend by passing
1690	 *   usbcore.autosuspend = -1 then keep autosuspend disabled.
1691	 */
1692#ifdef CONFIG_PM
1693	if (hdev->dev.power.autosuspend_delay >= 0)
1694		pm_runtime_set_autosuspend_delay(&hdev->dev, 0);
1695#endif
1696
1697	/*
1698	 * Hubs have proper suspend/resume support, except for root hubs
1699	 * where the controller driver doesn't have bus_suspend and
1700	 * bus_resume methods.
1701	 */
1702	if (hdev->parent) {		/* normal device */
1703		usb_enable_autosuspend(hdev);
1704	} else {			/* root hub */
1705		const struct hc_driver *drv = bus_to_hcd(hdev->bus)->driver;
1706
1707		if (drv->bus_suspend && drv->bus_resume)
1708			usb_enable_autosuspend(hdev);
1709	}
1710
1711	if (hdev->level == MAX_TOPO_LEVEL) {
1712		dev_err(&intf->dev,
1713			"Unsupported bus topology: hub nested too deep\n");
1714		return -E2BIG;
1715	}
1716
1717#ifdef	CONFIG_USB_OTG_BLACKLIST_HUB
1718	if (hdev->parent) {
1719		dev_warn(&intf->dev, "ignoring external hub\n");
1720		return -ENODEV;
1721	}
1722#endif
1723
1724	/* Some hubs have a subclass of 1, which AFAICT according to the */
1725	/*  specs is not defined, but it works */
1726	if ((desc->desc.bInterfaceSubClass != 0) &&
1727	    (desc->desc.bInterfaceSubClass != 1)) {
1728descriptor_error:
1729		dev_err(&intf->dev, "bad descriptor, ignoring hub\n");
1730		return -EIO;
1731	}
1732
1733	/* Multiple endpoints? What kind of mutant ninja-hub is this? */
1734	if (desc->desc.bNumEndpoints != 1)
1735		goto descriptor_error;
1736
1737	endpoint = &desc->endpoint[0].desc;
1738
1739	/* If it's not an interrupt in endpoint, we'd better punt! */
1740	if (!usb_endpoint_is_int_in(endpoint))
1741		goto descriptor_error;
1742
1743	/* We found a hub */
1744	dev_info(&intf->dev, "USB hub found\n");
1745
1746	hub = kzalloc(sizeof(*hub), GFP_KERNEL);
1747	if (!hub)
1748		return -ENOMEM;
1749
1750	kref_init(&hub->kref);
1751	hub->intfdev = &intf->dev;
1752	hub->hdev = hdev;
1753	INIT_DELAYED_WORK(&hub->leds, led_work);
1754	INIT_DELAYED_WORK(&hub->init_work, NULL);
1755	INIT_WORK(&hub->events, hub_event);
 
 
 
1756	usb_get_intf(intf);
1757	usb_get_dev(hdev);
1758
1759	usb_set_intfdata(intf, hub);
1760	intf->needs_remote_wakeup = 1;
1761	pm_suspend_ignore_children(&intf->dev, true);
1762
1763	if (hdev->speed == USB_SPEED_HIGH)
1764		highspeed_hubs++;
1765
1766	if (id->driver_info & HUB_QUIRK_CHECK_PORT_AUTOSUSPEND)
1767		hub->quirk_check_port_auto_suspend = 1;
1768
1769	if (hub_configure(hub, endpoint) >= 0)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1770		return 0;
 
1771
1772	hub_disconnect(intf);
1773	return -ENODEV;
1774}
1775
1776static int
1777hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
1778{
1779	struct usb_device *hdev = interface_to_usbdev(intf);
1780	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
1781
1782	/* assert ifno == 0 (part of hub spec) */
1783	switch (code) {
1784	case USBDEVFS_HUB_PORTINFO: {
1785		struct usbdevfs_hub_portinfo *info = user_data;
1786		int i;
1787
1788		spin_lock_irq(&device_state_lock);
1789		if (hdev->devnum <= 0)
1790			info->nports = 0;
1791		else {
1792			info->nports = hdev->maxchild;
1793			for (i = 0; i < info->nports; i++) {
1794				if (hub->ports[i]->child == NULL)
1795					info->port[i] = 0;
1796				else
1797					info->port[i] =
1798						hub->ports[i]->child->devnum;
1799			}
1800		}
1801		spin_unlock_irq(&device_state_lock);
1802
1803		return info->nports + 1;
1804		}
1805
1806	default:
1807		return -ENOSYS;
1808	}
1809}
1810
1811/*
1812 * Allow user programs to claim ports on a hub.  When a device is attached
1813 * to one of these "claimed" ports, the program will "own" the device.
1814 */
1815static int find_port_owner(struct usb_device *hdev, unsigned port1,
1816		struct usb_dev_state ***ppowner)
1817{
1818	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
1819
1820	if (hdev->state == USB_STATE_NOTATTACHED)
1821		return -ENODEV;
1822	if (port1 == 0 || port1 > hdev->maxchild)
1823		return -EINVAL;
1824
1825	/* Devices not managed by the hub driver
1826	 * will always have maxchild equal to 0.
1827	 */
1828	*ppowner = &(hub->ports[port1 - 1]->port_owner);
1829	return 0;
1830}
1831
1832/* In the following three functions, the caller must hold hdev's lock */
1833int usb_hub_claim_port(struct usb_device *hdev, unsigned port1,
1834		       struct usb_dev_state *owner)
1835{
1836	int rc;
1837	struct usb_dev_state **powner;
1838
1839	rc = find_port_owner(hdev, port1, &powner);
1840	if (rc)
1841		return rc;
1842	if (*powner)
1843		return -EBUSY;
1844	*powner = owner;
1845	return rc;
1846}
1847EXPORT_SYMBOL_GPL(usb_hub_claim_port);
1848
1849int usb_hub_release_port(struct usb_device *hdev, unsigned port1,
1850			 struct usb_dev_state *owner)
1851{
1852	int rc;
1853	struct usb_dev_state **powner;
1854
1855	rc = find_port_owner(hdev, port1, &powner);
1856	if (rc)
1857		return rc;
1858	if (*powner != owner)
1859		return -ENOENT;
1860	*powner = NULL;
1861	return rc;
1862}
1863EXPORT_SYMBOL_GPL(usb_hub_release_port);
1864
1865void usb_hub_release_all_ports(struct usb_device *hdev, struct usb_dev_state *owner)
1866{
1867	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
1868	int n;
1869
1870	for (n = 0; n < hdev->maxchild; n++) {
1871		if (hub->ports[n]->port_owner == owner)
1872			hub->ports[n]->port_owner = NULL;
1873	}
1874
1875}
1876
1877/* The caller must hold udev's lock */
1878bool usb_device_is_owned(struct usb_device *udev)
1879{
1880	struct usb_hub *hub;
1881
1882	if (udev->state == USB_STATE_NOTATTACHED || !udev->parent)
1883		return false;
1884	hub = usb_hub_to_struct_hub(udev->parent);
1885	return !!hub->ports[udev->portnum - 1]->port_owner;
1886}
1887
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1888static void recursively_mark_NOTATTACHED(struct usb_device *udev)
1889{
1890	struct usb_hub *hub = usb_hub_to_struct_hub(udev);
1891	int i;
1892
1893	for (i = 0; i < udev->maxchild; ++i) {
1894		if (hub->ports[i]->child)
1895			recursively_mark_NOTATTACHED(hub->ports[i]->child);
1896	}
1897	if (udev->state == USB_STATE_SUSPENDED)
1898		udev->active_duration -= jiffies;
1899	udev->state = USB_STATE_NOTATTACHED;
 
1900}
1901
1902/**
1903 * usb_set_device_state - change a device's current state (usbcore, hcds)
1904 * @udev: pointer to device whose state should be changed
1905 * @new_state: new state value to be stored
1906 *
1907 * udev->state is _not_ fully protected by the device lock.  Although
1908 * most transitions are made only while holding the lock, the state can
1909 * can change to USB_STATE_NOTATTACHED at almost any time.  This
1910 * is so that devices can be marked as disconnected as soon as possible,
1911 * without having to wait for any semaphores to be released.  As a result,
1912 * all changes to any device's state must be protected by the
1913 * device_state_lock spinlock.
1914 *
1915 * Once a device has been added to the device tree, all changes to its state
1916 * should be made using this routine.  The state should _not_ be set directly.
1917 *
1918 * If udev->state is already USB_STATE_NOTATTACHED then no change is made.
1919 * Otherwise udev->state is set to new_state, and if new_state is
1920 * USB_STATE_NOTATTACHED then all of udev's descendants' states are also set
1921 * to USB_STATE_NOTATTACHED.
1922 */
1923void usb_set_device_state(struct usb_device *udev,
1924		enum usb_device_state new_state)
1925{
1926	unsigned long flags;
1927	int wakeup = -1;
1928
1929	spin_lock_irqsave(&device_state_lock, flags);
1930	if (udev->state == USB_STATE_NOTATTACHED)
1931		;	/* do nothing */
1932	else if (new_state != USB_STATE_NOTATTACHED) {
1933
1934		/* root hub wakeup capabilities are managed out-of-band
1935		 * and may involve silicon errata ... ignore them here.
1936		 */
1937		if (udev->parent) {
1938			if (udev->state == USB_STATE_SUSPENDED
1939					|| new_state == USB_STATE_SUSPENDED)
1940				;	/* No change to wakeup settings */
1941			else if (new_state == USB_STATE_CONFIGURED)
1942				wakeup = (udev->quirks &
1943					USB_QUIRK_IGNORE_REMOTE_WAKEUP) ? 0 :
1944					udev->actconfig->desc.bmAttributes &
1945					USB_CONFIG_ATT_WAKEUP;
1946			else
1947				wakeup = 0;
1948		}
1949		if (udev->state == USB_STATE_SUSPENDED &&
1950			new_state != USB_STATE_SUSPENDED)
1951			udev->active_duration -= jiffies;
1952		else if (new_state == USB_STATE_SUSPENDED &&
1953				udev->state != USB_STATE_SUSPENDED)
1954			udev->active_duration += jiffies;
1955		udev->state = new_state;
 
1956	} else
1957		recursively_mark_NOTATTACHED(udev);
1958	spin_unlock_irqrestore(&device_state_lock, flags);
1959	if (wakeup >= 0)
1960		device_set_wakeup_capable(&udev->dev, wakeup);
1961}
1962EXPORT_SYMBOL_GPL(usb_set_device_state);
1963
1964/*
1965 * Choose a device number.
1966 *
1967 * Device numbers are used as filenames in usbfs.  On USB-1.1 and
1968 * USB-2.0 buses they are also used as device addresses, however on
1969 * USB-3.0 buses the address is assigned by the controller hardware
1970 * and it usually is not the same as the device number.
1971 *
1972 * WUSB devices are simple: they have no hubs behind, so the mapping
1973 * device <-> virtual port number becomes 1:1. Why? to simplify the
1974 * life of the device connection logic in
1975 * drivers/usb/wusbcore/devconnect.c. When we do the initial secret
1976 * handshake we need to assign a temporary address in the unauthorized
1977 * space. For simplicity we use the first virtual port number found to
1978 * be free [drivers/usb/wusbcore/devconnect.c:wusbhc_devconnect_ack()]
1979 * and that becomes it's address [X < 128] or its unauthorized address
1980 * [X | 0x80].
1981 *
1982 * We add 1 as an offset to the one-based USB-stack port number
1983 * (zero-based wusb virtual port index) for two reasons: (a) dev addr
1984 * 0 is reserved by USB for default address; (b) Linux's USB stack
1985 * uses always #1 for the root hub of the controller. So USB stack's
1986 * port #1, which is wusb virtual-port #0 has address #2.
1987 *
1988 * Devices connected under xHCI are not as simple.  The host controller
1989 * supports virtualization, so the hardware assigns device addresses and
1990 * the HCD must setup data structures before issuing a set address
1991 * command to the hardware.
1992 */
1993static void choose_devnum(struct usb_device *udev)
1994{
1995	int		devnum;
1996	struct usb_bus	*bus = udev->bus;
1997
1998	/* be safe when more hub events are proceed in parallel */
1999	mutex_lock(&bus->devnum_next_mutex);
2000	if (udev->wusb) {
2001		devnum = udev->portnum + 1;
2002		BUG_ON(test_bit(devnum, bus->devmap.devicemap));
2003	} else {
2004		/* Try to allocate the next devnum beginning at
2005		 * bus->devnum_next. */
2006		devnum = find_next_zero_bit(bus->devmap.devicemap, 128,
2007					    bus->devnum_next);
2008		if (devnum >= 128)
2009			devnum = find_next_zero_bit(bus->devmap.devicemap,
2010						    128, 1);
2011		bus->devnum_next = (devnum >= 127 ? 1 : devnum + 1);
2012	}
2013	if (devnum < 128) {
2014		set_bit(devnum, bus->devmap.devicemap);
2015		udev->devnum = devnum;
2016	}
2017	mutex_unlock(&bus->devnum_next_mutex);
2018}
2019
2020static void release_devnum(struct usb_device *udev)
2021{
2022	if (udev->devnum > 0) {
2023		clear_bit(udev->devnum, udev->bus->devmap.devicemap);
2024		udev->devnum = -1;
2025	}
2026}
2027
2028static void update_devnum(struct usb_device *udev, int devnum)
2029{
2030	/* The address for a WUSB device is managed by wusbcore. */
2031	if (!udev->wusb)
2032		udev->devnum = devnum;
2033}
2034
2035static void hub_free_dev(struct usb_device *udev)
2036{
2037	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2038
2039	/* Root hubs aren't real devices, so don't free HCD resources */
2040	if (hcd->driver->free_dev && udev->parent)
2041		hcd->driver->free_dev(hcd, udev);
2042}
2043
2044static void hub_disconnect_children(struct usb_device *udev)
2045{
2046	struct usb_hub *hub = usb_hub_to_struct_hub(udev);
2047	int i;
2048
2049	/* Free up all the children before we remove this device */
2050	for (i = 0; i < udev->maxchild; i++) {
2051		if (hub->ports[i]->child)
2052			usb_disconnect(&hub->ports[i]->child);
2053	}
2054}
2055
2056/**
2057 * usb_disconnect - disconnect a device (usbcore-internal)
2058 * @pdev: pointer to device being disconnected
2059 * Context: !in_interrupt ()
 
2060 *
2061 * Something got disconnected. Get rid of it and all of its children.
2062 *
2063 * If *pdev is a normal device then the parent hub must already be locked.
2064 * If *pdev is a root hub then the caller must hold the usb_bus_idr_lock,
2065 * which protects the set of root hubs as well as the list of buses.
2066 *
2067 * Only hub drivers (including virtual root hub drivers for host
2068 * controllers) should ever call this.
2069 *
2070 * This call is synchronous, and may not be used in an interrupt context.
2071 */
2072void usb_disconnect(struct usb_device **pdev)
2073{
2074	struct usb_port *port_dev = NULL;
2075	struct usb_device *udev = *pdev;
2076	struct usb_hub *hub = NULL;
2077	int port1 = 1;
2078
2079	/* mark the device as inactive, so any further urb submissions for
2080	 * this device (and any of its children) will fail immediately.
2081	 * this quiesces everything except pending urbs.
2082	 */
2083	usb_set_device_state(udev, USB_STATE_NOTATTACHED);
2084	dev_info(&udev->dev, "USB disconnect, device number %d\n",
2085			udev->devnum);
2086
 
 
 
 
 
 
2087	usb_lock_device(udev);
2088
2089	hub_disconnect_children(udev);
2090
2091	/* deallocate hcd/hardware state ... nuking all pending urbs and
2092	 * cleaning up all state associated with the current configuration
2093	 * so that the hardware is now fully quiesced.
2094	 */
2095	dev_dbg(&udev->dev, "unregistering device\n");
2096	usb_disable_device(udev, 0);
2097	usb_hcd_synchronize_unlinks(udev);
2098
2099	if (udev->parent) {
2100		port1 = udev->portnum;
2101		hub = usb_hub_to_struct_hub(udev->parent);
2102		port_dev = hub->ports[port1 - 1];
2103
2104		sysfs_remove_link(&udev->dev.kobj, "port");
2105		sysfs_remove_link(&port_dev->dev.kobj, "device");
2106
2107		/*
2108		 * As usb_port_runtime_resume() de-references udev, make
2109		 * sure no resumes occur during removal
2110		 */
2111		if (!test_and_set_bit(port1, hub->child_usage_bits))
2112			pm_runtime_get_sync(&port_dev->dev);
 
 
2113	}
2114
2115	usb_remove_ep_devs(&udev->ep0);
2116	usb_unlock_device(udev);
2117
2118	/* Unregister the device.  The device driver is responsible
2119	 * for de-configuring the device and invoking the remove-device
2120	 * notifier chain (used by usbfs and possibly others).
2121	 */
2122	device_del(&udev->dev);
2123
2124	/* Free the device number and delete the parent's children[]
2125	 * (or root_hub) pointer.
2126	 */
2127	release_devnum(udev);
2128
2129	/* Avoid races with recursively_mark_NOTATTACHED() */
2130	spin_lock_irq(&device_state_lock);
2131	*pdev = NULL;
2132	spin_unlock_irq(&device_state_lock);
2133
2134	if (port_dev && test_and_clear_bit(port1, hub->child_usage_bits))
2135		pm_runtime_put(&port_dev->dev);
2136
2137	hub_free_dev(udev);
2138
2139	put_device(&udev->dev);
2140}
2141
2142#ifdef CONFIG_USB_ANNOUNCE_NEW_DEVICES
2143static void show_string(struct usb_device *udev, char *id, char *string)
2144{
2145	if (!string)
2146		return;
2147	dev_info(&udev->dev, "%s: %s\n", id, string);
2148}
2149
2150static void announce_device(struct usb_device *udev)
2151{
2152	dev_info(&udev->dev, "New USB device found, idVendor=%04x, idProduct=%04x\n",
 
 
 
2153		le16_to_cpu(udev->descriptor.idVendor),
2154		le16_to_cpu(udev->descriptor.idProduct));
 
2155	dev_info(&udev->dev,
2156		"New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
2157		udev->descriptor.iManufacturer,
2158		udev->descriptor.iProduct,
2159		udev->descriptor.iSerialNumber);
2160	show_string(udev, "Product", udev->product);
2161	show_string(udev, "Manufacturer", udev->manufacturer);
2162	show_string(udev, "SerialNumber", udev->serial);
2163}
2164#else
2165static inline void announce_device(struct usb_device *udev) { }
2166#endif
2167
2168
2169/**
2170 * usb_enumerate_device_otg - FIXME (usbcore-internal)
2171 * @udev: newly addressed device (in ADDRESS state)
2172 *
2173 * Finish enumeration for On-The-Go devices
2174 *
2175 * Return: 0 if successful. A negative error code otherwise.
2176 */
2177static int usb_enumerate_device_otg(struct usb_device *udev)
2178{
2179	int err = 0;
2180
2181#ifdef	CONFIG_USB_OTG
2182	/*
2183	 * OTG-aware devices on OTG-capable root hubs may be able to use SRP,
2184	 * to wake us after we've powered off VBUS; and HNP, switching roles
2185	 * "host" to "peripheral".  The OTG descriptor helps figure this out.
2186	 */
2187	if (!udev->bus->is_b_host
2188			&& udev->config
2189			&& udev->parent == udev->bus->root_hub) {
2190		struct usb_otg_descriptor	*desc = NULL;
2191		struct usb_bus			*bus = udev->bus;
2192		unsigned			port1 = udev->portnum;
2193
2194		/* descriptor may appear anywhere in config */
2195		err = __usb_get_extra_descriptor(udev->rawdescriptors[0],
2196				le16_to_cpu(udev->config[0].desc.wTotalLength),
2197				USB_DT_OTG, (void **) &desc);
2198		if (err || !(desc->bmAttributes & USB_OTG_HNP))
2199			return 0;
2200
2201		dev_info(&udev->dev, "Dual-Role OTG device on %sHNP port\n",
2202					(port1 == bus->otg_port) ? "" : "non-");
2203
2204		/* enable HNP before suspend, it's simpler */
2205		if (port1 == bus->otg_port) {
2206			bus->b_hnp_enable = 1;
2207			err = usb_control_msg(udev,
2208				usb_sndctrlpipe(udev, 0),
2209				USB_REQ_SET_FEATURE, 0,
2210				USB_DEVICE_B_HNP_ENABLE,
2211				0, NULL, 0,
2212				USB_CTRL_SET_TIMEOUT);
2213			if (err < 0) {
2214				/*
2215				 * OTG MESSAGE: report errors here,
2216				 * customize to match your product.
2217				 */
2218				dev_err(&udev->dev, "can't set HNP mode: %d\n",
2219									err);
2220				bus->b_hnp_enable = 0;
2221			}
2222		} else if (desc->bLength == sizeof
2223				(struct usb_otg_descriptor)) {
2224			/* Set a_alt_hnp_support for legacy otg device */
2225			err = usb_control_msg(udev,
2226				usb_sndctrlpipe(udev, 0),
2227				USB_REQ_SET_FEATURE, 0,
2228				USB_DEVICE_A_ALT_HNP_SUPPORT,
2229				0, NULL, 0,
2230				USB_CTRL_SET_TIMEOUT);
2231			if (err < 0)
2232				dev_err(&udev->dev,
2233					"set a_alt_hnp_support failed: %d\n",
2234					err);
 
 
 
 
 
 
 
 
2235		}
2236	}
2237#endif
2238	return err;
2239}
2240
2241
2242/**
2243 * usb_enumerate_device - Read device configs/intfs/otg (usbcore-internal)
2244 * @udev: newly addressed device (in ADDRESS state)
2245 *
2246 * This is only called by usb_new_device() and usb_authorize_device()
2247 * and FIXME -- all comments that apply to them apply here wrt to
2248 * environment.
2249 *
2250 * If the device is WUSB and not authorized, we don't attempt to read
2251 * the string descriptors, as they will be errored out by the device
2252 * until it has been authorized.
2253 *
2254 * Return: 0 if successful. A negative error code otherwise.
2255 */
2256static int usb_enumerate_device(struct usb_device *udev)
2257{
2258	int err;
2259	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2260
2261	if (udev->config == NULL) {
2262		err = usb_get_configuration(udev);
2263		if (err < 0) {
2264			if (err != -ENODEV)
2265				dev_err(&udev->dev, "can't read configurations, error %d\n",
2266						err);
2267			return err;
2268		}
2269	}
2270
2271	/* read the standard strings and cache them if present */
2272	udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
2273	udev->manufacturer = usb_cache_string(udev,
2274					      udev->descriptor.iManufacturer);
2275	udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
2276
2277	err = usb_enumerate_device_otg(udev);
2278	if (err < 0)
2279		return err;
2280
2281	if (IS_ENABLED(CONFIG_USB_OTG_WHITELIST) && hcd->tpl_support &&
2282		!is_targeted(udev)) {
2283		/* Maybe it can talk to us, though we can't talk to it.
2284		 * (Includes HNP test device.)
2285		 */
2286		if (IS_ENABLED(CONFIG_USB_OTG) && (udev->bus->b_hnp_enable
2287			|| udev->bus->is_b_host)) {
2288			err = usb_port_suspend(udev, PMSG_AUTO_SUSPEND);
2289			if (err < 0)
2290				dev_dbg(&udev->dev, "HNP fail, %d\n", err);
2291		}
2292		return -ENOTSUPP;
2293	}
2294
2295	usb_detect_interface_quirks(udev);
2296
2297	return 0;
2298}
2299
2300static void set_usb_port_removable(struct usb_device *udev)
2301{
2302	struct usb_device *hdev = udev->parent;
2303	struct usb_hub *hub;
2304	u8 port = udev->portnum;
2305	u16 wHubCharacteristics;
2306	bool removable = true;
2307
 
 
2308	if (!hdev)
2309		return;
2310
2311	hub = usb_hub_to_struct_hub(udev->parent);
2312
2313	/*
2314	 * If the platform firmware has provided information about a port,
2315	 * use that to determine whether it's removable.
2316	 */
2317	switch (hub->ports[udev->portnum - 1]->connect_type) {
2318	case USB_PORT_CONNECT_TYPE_HOT_PLUG:
2319		udev->removable = USB_DEVICE_REMOVABLE;
2320		return;
2321	case USB_PORT_CONNECT_TYPE_HARD_WIRED:
2322	case USB_PORT_NOT_USED:
2323		udev->removable = USB_DEVICE_FIXED;
2324		return;
2325	default:
2326		break;
2327	}
2328
2329	/*
2330	 * Otherwise, check whether the hub knows whether a port is removable
2331	 * or not
2332	 */
2333	wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
2334
2335	if (!(wHubCharacteristics & HUB_CHAR_COMPOUND))
2336		return;
2337
2338	if (hub_is_superspeed(hdev)) {
2339		if (le16_to_cpu(hub->descriptor->u.ss.DeviceRemovable)
2340				& (1 << port))
2341			removable = false;
2342	} else {
2343		if (hub->descriptor->u.hs.DeviceRemovable[port / 8] & (1 << (port % 8)))
2344			removable = false;
2345	}
2346
2347	if (removable)
2348		udev->removable = USB_DEVICE_REMOVABLE;
2349	else
2350		udev->removable = USB_DEVICE_FIXED;
2351
2352}
2353
2354/**
2355 * usb_new_device - perform initial device setup (usbcore-internal)
2356 * @udev: newly addressed device (in ADDRESS state)
2357 *
2358 * This is called with devices which have been detected but not fully
2359 * enumerated.  The device descriptor is available, but not descriptors
2360 * for any device configuration.  The caller must have locked either
2361 * the parent hub (if udev is a normal device) or else the
2362 * usb_bus_idr_lock (if udev is a root hub).  The parent's pointer to
2363 * udev has already been installed, but udev is not yet visible through
2364 * sysfs or other filesystem code.
2365 *
2366 * This call is synchronous, and may not be used in an interrupt context.
2367 *
2368 * Only the hub driver or root-hub registrar should ever call this.
2369 *
2370 * Return: Whether the device is configured properly or not. Zero if the
2371 * interface was registered with the driver core; else a negative errno
2372 * value.
2373 *
2374 */
2375int usb_new_device(struct usb_device *udev)
2376{
2377	int err;
2378
2379	if (udev->parent) {
2380		/* Initialize non-root-hub device wakeup to disabled;
2381		 * device (un)configuration controls wakeup capable
2382		 * sysfs power/wakeup controls wakeup enabled/disabled
2383		 */
2384		device_init_wakeup(&udev->dev, 0);
2385	}
2386
2387	/* Tell the runtime-PM framework the device is active */
2388	pm_runtime_set_active(&udev->dev);
2389	pm_runtime_get_noresume(&udev->dev);
2390	pm_runtime_use_autosuspend(&udev->dev);
2391	pm_runtime_enable(&udev->dev);
2392
2393	/* By default, forbid autosuspend for all devices.  It will be
2394	 * allowed for hubs during binding.
2395	 */
2396	usb_disable_autosuspend(udev);
2397
2398	err = usb_enumerate_device(udev);	/* Read descriptors */
2399	if (err < 0)
2400		goto fail;
2401	dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n",
2402			udev->devnum, udev->bus->busnum,
2403			(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
2404	/* export the usbdev device-node for libusb */
2405	udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
2406			(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
2407
2408	/* Tell the world! */
2409	announce_device(udev);
2410
2411	if (udev->serial)
2412		add_device_randomness(udev->serial, strlen(udev->serial));
2413	if (udev->product)
2414		add_device_randomness(udev->product, strlen(udev->product));
2415	if (udev->manufacturer)
2416		add_device_randomness(udev->manufacturer,
2417				      strlen(udev->manufacturer));
2418
2419	device_enable_async_suspend(&udev->dev);
2420
2421	/* check whether the hub or firmware marks this port as non-removable */
2422	if (udev->parent)
2423		set_usb_port_removable(udev);
2424
2425	/* Register the device.  The device driver is responsible
2426	 * for configuring the device and invoking the add-device
2427	 * notifier chain (used by usbfs and possibly others).
2428	 */
2429	err = device_add(&udev->dev);
2430	if (err) {
2431		dev_err(&udev->dev, "can't device_add, error %d\n", err);
2432		goto fail;
2433	}
2434
2435	/* Create link files between child device and usb port device. */
2436	if (udev->parent) {
2437		struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
2438		int port1 = udev->portnum;
2439		struct usb_port	*port_dev = hub->ports[port1 - 1];
2440
2441		err = sysfs_create_link(&udev->dev.kobj,
2442				&port_dev->dev.kobj, "port");
2443		if (err)
2444			goto fail;
2445
2446		err = sysfs_create_link(&port_dev->dev.kobj,
2447				&udev->dev.kobj, "device");
2448		if (err) {
2449			sysfs_remove_link(&udev->dev.kobj, "port");
2450			goto fail;
2451		}
2452
2453		if (!test_and_set_bit(port1, hub->child_usage_bits))
2454			pm_runtime_get_sync(&port_dev->dev);
 
 
2455	}
2456
2457	(void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
2458	usb_mark_last_busy(udev);
2459	pm_runtime_put_sync_autosuspend(&udev->dev);
2460	return err;
2461
2462fail:
2463	usb_set_device_state(udev, USB_STATE_NOTATTACHED);
2464	pm_runtime_disable(&udev->dev);
2465	pm_runtime_set_suspended(&udev->dev);
2466	return err;
2467}
2468
2469
2470/**
2471 * usb_deauthorize_device - deauthorize a device (usbcore-internal)
2472 * @usb_dev: USB device
2473 *
2474 * Move the USB device to a very basic state where interfaces are disabled
2475 * and the device is in fact unconfigured and unusable.
2476 *
2477 * We share a lock (that we have) with device_del(), so we need to
2478 * defer its call.
2479 *
2480 * Return: 0.
2481 */
2482int usb_deauthorize_device(struct usb_device *usb_dev)
2483{
2484	usb_lock_device(usb_dev);
2485	if (usb_dev->authorized == 0)
2486		goto out_unauthorized;
2487
2488	usb_dev->authorized = 0;
2489	usb_set_configuration(usb_dev, -1);
2490
2491out_unauthorized:
2492	usb_unlock_device(usb_dev);
2493	return 0;
2494}
2495
2496
2497int usb_authorize_device(struct usb_device *usb_dev)
2498{
2499	int result = 0, c;
2500
2501	usb_lock_device(usb_dev);
2502	if (usb_dev->authorized == 1)
2503		goto out_authorized;
2504
2505	result = usb_autoresume_device(usb_dev);
2506	if (result < 0) {
2507		dev_err(&usb_dev->dev,
2508			"can't autoresume for authorization: %d\n", result);
2509		goto error_autoresume;
2510	}
2511
2512	if (usb_dev->wusb) {
2513		result = usb_get_device_descriptor(usb_dev, sizeof(usb_dev->descriptor));
2514		if (result < 0) {
2515			dev_err(&usb_dev->dev, "can't re-read device descriptor for "
2516				"authorization: %d\n", result);
2517			goto error_device_descriptor;
2518		}
2519	}
2520
2521	usb_dev->authorized = 1;
2522	/* Choose and set the configuration.  This registers the interfaces
2523	 * with the driver core and lets interface drivers bind to them.
2524	 */
2525	c = usb_choose_configuration(usb_dev);
2526	if (c >= 0) {
2527		result = usb_set_configuration(usb_dev, c);
2528		if (result) {
2529			dev_err(&usb_dev->dev,
2530				"can't set config #%d, error %d\n", c, result);
2531			/* This need not be fatal.  The user can try to
2532			 * set other configurations. */
2533		}
2534	}
2535	dev_info(&usb_dev->dev, "authorized to connect\n");
2536
2537error_device_descriptor:
2538	usb_autosuspend_device(usb_dev);
2539error_autoresume:
2540out_authorized:
2541	usb_unlock_device(usb_dev);	/* complements locktree */
2542	return result;
2543}
2544
2545/*
2546 * Return 1 if port speed is SuperSpeedPlus, 0 otherwise
2547 * check it from the link protocol field of the current speed ID attribute.
2548 * current speed ID is got from ext port status request. Sublink speed attribute
2549 * table is returned with the hub BOS SSP device capability descriptor
2550 */
2551static int port_speed_is_ssp(struct usb_device *hdev, int speed_id)
2552{
2553	int ssa_count;
2554	u32 ss_attr;
 
 
 
 
 
 
 
2555	int i;
2556	struct usb_ssp_cap_descriptor *ssp_cap = hdev->bos->ssp_cap;
2557
 
 
 
 
2558	if (!ssp_cap)
2559		return 0;
2560
2561	ssa_count = le32_to_cpu(ssp_cap->bmAttributes) &
 
 
 
2562		USB_SSP_SUBLINK_SPEED_ATTRIBS;
2563
2564	for (i = 0; i <= ssa_count; i++) {
2565		ss_attr = le32_to_cpu(ssp_cap->bmSublinkSpeedAttr[i]);
2566		if (speed_id == (ss_attr & USB_SSP_SUBLINK_SPEED_SSID))
2567			return !!(ss_attr & USB_SSP_SUBLINK_SPEED_LP);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2568	}
2569	return 0;
2570}
2571
2572/* Returns 1 if @hub is a WUSB root hub, 0 otherwise */
2573static unsigned hub_is_wusb(struct usb_hub *hub)
2574{
2575	struct usb_hcd *hcd;
2576	if (hub->hdev->parent != NULL)  /* not a root hub? */
2577		return 0;
2578	hcd = bus_to_hcd(hub->hdev->bus);
2579	return hcd->wireless;
2580}
2581
 
 
 
 
 
 
2582
 
2583#define PORT_RESET_TRIES	5
2584#define SET_ADDRESS_TRIES	2
2585#define GET_DESCRIPTOR_TRIES	2
2586#define SET_CONFIG_TRIES	(2 * (use_both_schemes + 1))
2587#define USE_NEW_SCHEME(i)	((i) / 2 == (int)old_scheme_first)
 
2588
2589#define HUB_ROOT_RESET_TIME	50	/* times are in msec */
 
 
2590#define HUB_SHORT_RESET_TIME	10
2591#define HUB_BH_RESET_TIME	50
2592#define HUB_LONG_RESET_TIME	200
2593#define HUB_RESET_TIMEOUT	800
2594
2595/*
2596 * "New scheme" enumeration causes an extra state transition to be
2597 * exposed to an xhci host and causes USB3 devices to receive control
2598 * commands in the default state.  This has been seen to cause
2599 * enumeration failures, so disable this enumeration scheme for USB3
2600 * devices.
2601 */
2602static bool use_new_scheme(struct usb_device *udev, int retry)
2603{
 
 
 
 
 
 
 
 
 
 
 
2604	if (udev->speed >= USB_SPEED_SUPER)
2605		return false;
2606
2607	return USE_NEW_SCHEME(retry);
 
 
 
 
 
 
 
2608}
2609
2610/* Is a USB 3.0 port in the Inactive or Compliance Mode state?
2611 * Port worm reset is required to recover
2612 */
2613static bool hub_port_warm_reset_required(struct usb_hub *hub, int port1,
2614		u16 portstatus)
2615{
2616	u16 link_state;
2617
2618	if (!hub_is_superspeed(hub->hdev))
2619		return false;
2620
2621	if (test_bit(port1, hub->warm_reset_bits))
2622		return true;
2623
2624	link_state = portstatus & USB_PORT_STAT_LINK_STATE;
2625	return link_state == USB_SS_PORT_LS_SS_INACTIVE
2626		|| link_state == USB_SS_PORT_LS_COMP_MOD;
2627}
2628
2629static int hub_port_wait_reset(struct usb_hub *hub, int port1,
2630			struct usb_device *udev, unsigned int delay, bool warm)
2631{
2632	int delay_time, ret;
2633	u16 portstatus;
2634	u16 portchange;
2635	u32 ext_portstatus = 0;
2636
2637	for (delay_time = 0;
2638			delay_time < HUB_RESET_TIMEOUT;
2639			delay_time += delay) {
2640		/* wait to give the device a chance to reset */
2641		msleep(delay);
2642
2643		/* read and decode port status */
2644		if (hub_is_superspeedplus(hub->hdev))
2645			ret = hub_ext_port_status(hub, port1,
2646						  HUB_EXT_PORT_STATUS,
2647						  &portstatus, &portchange,
2648						  &ext_portstatus);
2649		else
2650			ret = hub_port_status(hub, port1, &portstatus,
2651					      &portchange);
2652		if (ret < 0)
2653			return ret;
2654
2655		/*
2656		 * The port state is unknown until the reset completes.
2657		 *
2658		 * On top of that, some chips may require additional time
2659		 * to re-establish a connection after the reset is complete,
2660		 * so also wait for the connection to be re-established.
2661		 */
2662		if (!(portstatus & USB_PORT_STAT_RESET) &&
2663		    (portstatus & USB_PORT_STAT_CONNECTION))
2664			break;
2665
2666		/* switch to the long delay after two short delay failures */
2667		if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
2668			delay = HUB_LONG_RESET_TIME;
2669
2670		dev_dbg(&hub->ports[port1 - 1]->dev,
2671				"not %sreset yet, waiting %dms\n",
2672				warm ? "warm " : "", delay);
2673	}
2674
2675	if ((portstatus & USB_PORT_STAT_RESET))
2676		return -EBUSY;
2677
2678	if (hub_port_warm_reset_required(hub, port1, portstatus))
2679		return -ENOTCONN;
2680
2681	/* Device went away? */
2682	if (!(portstatus & USB_PORT_STAT_CONNECTION))
2683		return -ENOTCONN;
2684
2685	/* bomb out completely if the connection bounced.  A USB 3.0
2686	 * connection may bounce if multiple warm resets were issued,
2687	 * but the device may have successfully re-connected. Ignore it.
2688	 */
2689	if (!hub_is_superspeed(hub->hdev) &&
2690			(portchange & USB_PORT_STAT_C_CONNECTION))
2691		return -ENOTCONN;
 
 
 
2692
2693	if (!(portstatus & USB_PORT_STAT_ENABLE))
2694		return -EBUSY;
2695
2696	if (!udev)
2697		return 0;
2698
2699	if (hub_is_wusb(hub))
2700		udev->speed = USB_SPEED_WIRELESS;
2701	else if (hub_is_superspeedplus(hub->hdev) &&
2702		 port_speed_is_ssp(hub->hdev, ext_portstatus &
2703				   USB_EXT_PORT_STAT_RX_SPEED_ID))
 
 
 
 
 
 
2704		udev->speed = USB_SPEED_SUPER_PLUS;
2705	else if (hub_is_superspeed(hub->hdev))
2706		udev->speed = USB_SPEED_SUPER;
2707	else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
2708		udev->speed = USB_SPEED_HIGH;
2709	else if (portstatus & USB_PORT_STAT_LOW_SPEED)
2710		udev->speed = USB_SPEED_LOW;
2711	else
2712		udev->speed = USB_SPEED_FULL;
2713	return 0;
2714}
2715
2716/* Handle port reset and port warm(BH) reset (for USB3 protocol ports) */
2717static int hub_port_reset(struct usb_hub *hub, int port1,
2718			struct usb_device *udev, unsigned int delay, bool warm)
2719{
2720	int i, status;
2721	u16 portchange, portstatus;
2722	struct usb_port *port_dev = hub->ports[port1 - 1];
 
2723
2724	if (!hub_is_superspeed(hub->hdev)) {
2725		if (warm) {
2726			dev_err(hub->intfdev, "only USB3 hub support "
2727						"warm reset\n");
2728			return -EINVAL;
2729		}
2730		/* Block EHCI CF initialization during the port reset.
2731		 * Some companion controllers don't like it when they mix.
2732		 */
2733		down_read(&ehci_cf_port_reset_rwsem);
2734	} else if (!warm) {
2735		/*
2736		 * If the caller hasn't explicitly requested a warm reset,
2737		 * double check and see if one is needed.
2738		 */
2739		if (hub_port_status(hub, port1, &portstatus, &portchange) == 0)
 
2740			if (hub_port_warm_reset_required(hub, port1,
2741							portstatus))
2742				warm = true;
2743	}
2744	clear_bit(port1, hub->warm_reset_bits);
2745
2746	/* Reset the port */
2747	for (i = 0; i < PORT_RESET_TRIES; i++) {
2748		status = set_port_feature(hub->hdev, port1, (warm ?
2749					USB_PORT_FEAT_BH_PORT_RESET :
2750					USB_PORT_FEAT_RESET));
2751		if (status == -ENODEV) {
2752			;	/* The hub is gone */
2753		} else if (status) {
2754			dev_err(&port_dev->dev,
2755					"cannot %sreset (err = %d)\n",
2756					warm ? "warm " : "", status);
2757		} else {
2758			status = hub_port_wait_reset(hub, port1, udev, delay,
2759								warm);
2760			if (status && status != -ENOTCONN && status != -ENODEV)
2761				dev_dbg(hub->intfdev,
2762						"port_wait_reset: err = %d\n",
2763						status);
2764		}
2765
2766		/* Check for disconnect or reset */
2767		if (status == 0 || status == -ENOTCONN || status == -ENODEV) {
 
 
 
 
2768			usb_clear_port_feature(hub->hdev, port1,
2769					USB_PORT_FEAT_C_RESET);
2770
2771			if (!hub_is_superspeed(hub->hdev))
2772				goto done;
2773
2774			usb_clear_port_feature(hub->hdev, port1,
2775					USB_PORT_FEAT_C_BH_PORT_RESET);
2776			usb_clear_port_feature(hub->hdev, port1,
2777					USB_PORT_FEAT_C_PORT_LINK_STATE);
2778			usb_clear_port_feature(hub->hdev, port1,
 
 
2779					USB_PORT_FEAT_C_CONNECTION);
2780
2781			/*
2782			 * If a USB 3.0 device migrates from reset to an error
2783			 * state, re-issue the warm reset.
2784			 */
2785			if (hub_port_status(hub, port1,
2786					&portstatus, &portchange) < 0)
2787				goto done;
2788
2789			if (!hub_port_warm_reset_required(hub, port1,
2790					portstatus))
2791				goto done;
2792
2793			/*
2794			 * If the port is in SS.Inactive or Compliance Mode, the
2795			 * hot or warm reset failed.  Try another warm reset.
2796			 */
2797			if (!warm) {
2798				dev_dbg(&port_dev->dev,
2799						"hot reset failed, warm reset\n");
2800				warm = true;
2801			}
2802		}
2803
2804		dev_dbg(&port_dev->dev,
2805				"not enabled, trying %sreset again...\n",
2806				warm ? "warm " : "");
2807		delay = HUB_LONG_RESET_TIME;
2808	}
2809
2810	dev_err(&port_dev->dev, "Cannot enable. Maybe the USB cable is bad?\n");
2811
2812done:
2813	if (status == 0) {
2814		/* TRSTRCY = 10 ms; plus some extra */
2815		msleep(10 + 40);
 
 
 
 
 
 
 
 
 
 
 
2816		if (udev) {
2817			struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2818
2819			update_devnum(udev, 0);
2820			/* The xHC may think the device is already reset,
2821			 * so ignore the status.
2822			 */
2823			if (hcd->driver->reset_device)
2824				hcd->driver->reset_device(hcd, udev);
2825
2826			usb_set_device_state(udev, USB_STATE_DEFAULT);
2827		}
2828	} else {
2829		if (udev)
2830			usb_set_device_state(udev, USB_STATE_NOTATTACHED);
2831	}
2832
2833	if (!hub_is_superspeed(hub->hdev))
2834		up_read(&ehci_cf_port_reset_rwsem);
2835
2836	return status;
2837}
2838
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2839/* Check if a port is power on */
2840static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
2841{
2842	int ret = 0;
2843
2844	if (hub_is_superspeed(hub->hdev)) {
2845		if (portstatus & USB_SS_PORT_STAT_POWER)
2846			ret = 1;
2847	} else {
2848		if (portstatus & USB_PORT_STAT_POWER)
2849			ret = 1;
2850	}
2851
2852	return ret;
2853}
2854
2855static void usb_lock_port(struct usb_port *port_dev)
2856		__acquires(&port_dev->status_lock)
2857{
2858	mutex_lock(&port_dev->status_lock);
2859	__acquire(&port_dev->status_lock);
2860}
2861
2862static void usb_unlock_port(struct usb_port *port_dev)
2863		__releases(&port_dev->status_lock)
2864{
2865	mutex_unlock(&port_dev->status_lock);
2866	__release(&port_dev->status_lock);
2867}
2868
2869#ifdef	CONFIG_PM
2870
2871/* Check if a port is suspended(USB2.0 port) or in U3 state(USB3.0 port) */
2872static int port_is_suspended(struct usb_hub *hub, unsigned portstatus)
2873{
2874	int ret = 0;
2875
2876	if (hub_is_superspeed(hub->hdev)) {
2877		if ((portstatus & USB_PORT_STAT_LINK_STATE)
2878				== USB_SS_PORT_LS_U3)
2879			ret = 1;
2880	} else {
2881		if (portstatus & USB_PORT_STAT_SUSPEND)
2882			ret = 1;
2883	}
2884
2885	return ret;
2886}
2887
2888/* Determine whether the device on a port is ready for a normal resume,
2889 * is ready for a reset-resume, or should be disconnected.
2890 */
2891static int check_port_resume_type(struct usb_device *udev,
2892		struct usb_hub *hub, int port1,
2893		int status, u16 portchange, u16 portstatus)
2894{
2895	struct usb_port *port_dev = hub->ports[port1 - 1];
2896	int retries = 3;
2897
2898 retry:
2899	/* Is a warm reset needed to recover the connection? */
2900	if (status == 0 && udev->reset_resume
2901		&& hub_port_warm_reset_required(hub, port1, portstatus)) {
2902		/* pass */;
2903	}
2904	/* Is the device still present? */
2905	else if (status || port_is_suspended(hub, portstatus) ||
2906			!port_is_power_on(hub, portstatus)) {
2907		if (status >= 0)
2908			status = -ENODEV;
2909	} else if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
2910		if (retries--) {
2911			usleep_range(200, 300);
2912			status = hub_port_status(hub, port1, &portstatus,
2913							     &portchange);
2914			goto retry;
2915		}
2916		status = -ENODEV;
2917	}
2918
2919	/* Can't do a normal resume if the port isn't enabled,
2920	 * so try a reset-resume instead.
2921	 */
2922	else if (!(portstatus & USB_PORT_STAT_ENABLE) && !udev->reset_resume) {
2923		if (udev->persist_enabled)
2924			udev->reset_resume = 1;
2925		else
2926			status = -ENODEV;
2927	}
2928
2929	if (status) {
2930		dev_dbg(&port_dev->dev, "status %04x.%04x after resume, %d\n",
2931				portchange, portstatus, status);
2932	} else if (udev->reset_resume) {
2933
2934		/* Late port handoff can set status-change bits */
2935		if (portchange & USB_PORT_STAT_C_CONNECTION)
2936			usb_clear_port_feature(hub->hdev, port1,
2937					USB_PORT_FEAT_C_CONNECTION);
2938		if (portchange & USB_PORT_STAT_C_ENABLE)
2939			usb_clear_port_feature(hub->hdev, port1,
2940					USB_PORT_FEAT_C_ENABLE);
 
 
 
 
 
 
 
 
 
2941	}
2942
2943	return status;
2944}
2945
2946int usb_disable_ltm(struct usb_device *udev)
2947{
2948	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2949
2950	/* Check if the roothub and device supports LTM. */
2951	if (!usb_device_supports_ltm(hcd->self.root_hub) ||
2952			!usb_device_supports_ltm(udev))
2953		return 0;
2954
2955	/* Clear Feature LTM Enable can only be sent if the device is
2956	 * configured.
2957	 */
2958	if (!udev->actconfig)
2959		return 0;
2960
2961	return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2962			USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
2963			USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
2964			USB_CTRL_SET_TIMEOUT);
2965}
2966EXPORT_SYMBOL_GPL(usb_disable_ltm);
2967
2968void usb_enable_ltm(struct usb_device *udev)
2969{
2970	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2971
2972	/* Check if the roothub and device supports LTM. */
2973	if (!usb_device_supports_ltm(hcd->self.root_hub) ||
2974			!usb_device_supports_ltm(udev))
2975		return;
2976
2977	/* Set Feature LTM Enable can only be sent if the device is
2978	 * configured.
2979	 */
2980	if (!udev->actconfig)
2981		return;
2982
2983	usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
2984			USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
2985			USB_DEVICE_LTM_ENABLE, 0, NULL, 0,
2986			USB_CTRL_SET_TIMEOUT);
2987}
2988EXPORT_SYMBOL_GPL(usb_enable_ltm);
2989
2990/*
2991 * usb_enable_remote_wakeup - enable remote wakeup for a device
2992 * @udev: target device
2993 *
2994 * For USB-2 devices: Set the device's remote wakeup feature.
2995 *
2996 * For USB-3 devices: Assume there's only one function on the device and
2997 * enable remote wake for the first interface.  FIXME if the interface
2998 * association descriptor shows there's more than one function.
2999 */
3000static int usb_enable_remote_wakeup(struct usb_device *udev)
3001{
3002	if (udev->speed < USB_SPEED_SUPER)
3003		return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3004				USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
3005				USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0,
3006				USB_CTRL_SET_TIMEOUT);
3007	else
3008		return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3009				USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE,
3010				USB_INTRF_FUNC_SUSPEND,
3011				USB_INTRF_FUNC_SUSPEND_RW |
3012					USB_INTRF_FUNC_SUSPEND_LP,
3013				NULL, 0, USB_CTRL_SET_TIMEOUT);
3014}
3015
3016/*
3017 * usb_disable_remote_wakeup - disable remote wakeup for a device
3018 * @udev: target device
3019 *
3020 * For USB-2 devices: Clear the device's remote wakeup feature.
3021 *
3022 * For USB-3 devices: Assume there's only one function on the device and
3023 * disable remote wake for the first interface.  FIXME if the interface
3024 * association descriptor shows there's more than one function.
3025 */
3026static int usb_disable_remote_wakeup(struct usb_device *udev)
3027{
3028	if (udev->speed < USB_SPEED_SUPER)
3029		return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3030				USB_REQ_CLEAR_FEATURE, USB_RECIP_DEVICE,
3031				USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0,
3032				USB_CTRL_SET_TIMEOUT);
3033	else
3034		return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3035				USB_REQ_SET_FEATURE, USB_RECIP_INTERFACE,
3036				USB_INTRF_FUNC_SUSPEND,	0, NULL, 0,
3037				USB_CTRL_SET_TIMEOUT);
3038}
3039
3040/* Count of wakeup-enabled devices at or below udev */
3041static unsigned wakeup_enabled_descendants(struct usb_device *udev)
3042{
3043	struct usb_hub *hub = usb_hub_to_struct_hub(udev);
3044
3045	return udev->do_remote_wakeup +
3046			(hub ? hub->wakeup_enabled_descendants : 0);
3047}
 
3048
3049/*
3050 * usb_port_suspend - suspend a usb device's upstream port
3051 * @udev: device that's no longer in active use, not a root hub
3052 * Context: must be able to sleep; device not locked; pm locks held
3053 *
3054 * Suspends a USB device that isn't in active use, conserving power.
3055 * Devices may wake out of a suspend, if anything important happens,
3056 * using the remote wakeup mechanism.  They may also be taken out of
3057 * suspend by the host, using usb_port_resume().  It's also routine
3058 * to disconnect devices while they are suspended.
3059 *
3060 * This only affects the USB hardware for a device; its interfaces
3061 * (and, for hubs, child devices) must already have been suspended.
3062 *
3063 * Selective port suspend reduces power; most suspended devices draw
3064 * less than 500 uA.  It's also used in OTG, along with remote wakeup.
3065 * All devices below the suspended port are also suspended.
3066 *
3067 * Devices leave suspend state when the host wakes them up.  Some devices
3068 * also support "remote wakeup", where the device can activate the USB
3069 * tree above them to deliver data, such as a keypress or packet.  In
3070 * some cases, this wakes the USB host.
3071 *
3072 * Suspending OTG devices may trigger HNP, if that's been enabled
3073 * between a pair of dual-role devices.  That will change roles, such
3074 * as from A-Host to A-Peripheral or from B-Host back to B-Peripheral.
3075 *
3076 * Devices on USB hub ports have only one "suspend" state, corresponding
3077 * to ACPI D2, "may cause the device to lose some context".
3078 * State transitions include:
3079 *
3080 *   - suspend, resume ... when the VBUS power link stays live
3081 *   - suspend, disconnect ... VBUS lost
3082 *
3083 * Once VBUS drop breaks the circuit, the port it's using has to go through
3084 * normal re-enumeration procedures, starting with enabling VBUS power.
3085 * Other than re-initializing the hub (plug/unplug, except for root hubs),
3086 * Linux (2.6) currently has NO mechanisms to initiate that:  no hub_wq
3087 * timer, no SRP, no requests through sysfs.
3088 *
3089 * If Runtime PM isn't enabled or used, non-SuperSpeed devices may not get
3090 * suspended until their bus goes into global suspend (i.e., the root
3091 * hub is suspended).  Nevertheless, we change @udev->state to
3092 * USB_STATE_SUSPENDED as this is the device's "logical" state.  The actual
3093 * upstream port setting is stored in @udev->port_is_suspended.
3094 *
3095 * Returns 0 on success, else negative errno.
3096 */
3097int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
3098{
3099	struct usb_hub	*hub = usb_hub_to_struct_hub(udev->parent);
3100	struct usb_port *port_dev = hub->ports[udev->portnum - 1];
3101	int		port1 = udev->portnum;
3102	int		status;
3103	bool		really_suspend = true;
3104
3105	usb_lock_port(port_dev);
3106
3107	/* enable remote wakeup when appropriate; this lets the device
3108	 * wake up the upstream hub (including maybe the root hub).
3109	 *
3110	 * NOTE:  OTG devices may issue remote wakeup (or SRP) even when
3111	 * we don't explicitly enable it here.
3112	 */
3113	if (udev->do_remote_wakeup) {
3114		status = usb_enable_remote_wakeup(udev);
3115		if (status) {
3116			dev_dbg(&udev->dev, "won't remote wakeup, status %d\n",
3117					status);
3118			/* bail if autosuspend is requested */
3119			if (PMSG_IS_AUTO(msg))
3120				goto err_wakeup;
3121		}
3122	}
3123
3124	/* disable USB2 hardware LPM */
3125	if (udev->usb2_hw_lpm_enabled == 1)
3126		usb_set_usb2_hardware_lpm(udev, 0);
3127
3128	if (usb_disable_ltm(udev)) {
3129		dev_err(&udev->dev, "Failed to disable LTM before suspend\n.");
3130		status = -ENOMEM;
3131		if (PMSG_IS_AUTO(msg))
3132			goto err_ltm;
3133	}
3134	if (usb_unlocked_disable_lpm(udev)) {
3135		dev_err(&udev->dev, "Failed to disable LPM before suspend\n.");
3136		status = -ENOMEM;
3137		if (PMSG_IS_AUTO(msg))
3138			goto err_lpm3;
3139	}
3140
3141	/* see 7.1.7.6 */
3142	if (hub_is_superspeed(hub->hdev))
3143		status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U3);
3144
3145	/*
3146	 * For system suspend, we do not need to enable the suspend feature
3147	 * on individual USB-2 ports.  The devices will automatically go
3148	 * into suspend a few ms after the root hub stops sending packets.
3149	 * The USB 2.0 spec calls this "global suspend".
3150	 *
3151	 * However, many USB hubs have a bug: They don't relay wakeup requests
3152	 * from a downstream port if the port's suspend feature isn't on.
3153	 * Therefore we will turn on the suspend feature if udev or any of its
3154	 * descendants is enabled for remote wakeup.
3155	 */
3156	else if (PMSG_IS_AUTO(msg) || wakeup_enabled_descendants(udev) > 0)
3157		status = set_port_feature(hub->hdev, port1,
3158				USB_PORT_FEAT_SUSPEND);
3159	else {
3160		really_suspend = false;
3161		status = 0;
3162	}
3163	if (status) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3164		dev_dbg(&port_dev->dev, "can't suspend, status %d\n", status);
3165
3166		/* Try to enable USB3 LPM and LTM again */
3167		usb_unlocked_enable_lpm(udev);
3168 err_lpm3:
3169		usb_enable_ltm(udev);
3170 err_ltm:
3171		/* Try to enable USB2 hardware LPM again */
3172		if (udev->usb2_hw_lpm_capable == 1)
3173			usb_set_usb2_hardware_lpm(udev, 1);
3174
3175		if (udev->do_remote_wakeup)
3176			(void) usb_disable_remote_wakeup(udev);
3177 err_wakeup:
3178
3179		/* System sleep transitions should never fail */
3180		if (!PMSG_IS_AUTO(msg))
3181			status = 0;
3182	} else {
 
3183		dev_dbg(&udev->dev, "usb %ssuspend, wakeup %d\n",
3184				(PMSG_IS_AUTO(msg) ? "auto-" : ""),
3185				udev->do_remote_wakeup);
3186		if (really_suspend) {
3187			udev->port_is_suspended = 1;
3188
3189			/* device has up to 10 msec to fully suspend */
3190			msleep(10);
3191		}
3192		usb_set_device_state(udev, USB_STATE_SUSPENDED);
3193	}
3194
3195	if (status == 0 && !udev->do_remote_wakeup && udev->persist_enabled
3196			&& test_and_clear_bit(port1, hub->child_usage_bits))
3197		pm_runtime_put_sync(&port_dev->dev);
3198
3199	usb_mark_last_busy(hub->hdev);
3200
3201	usb_unlock_port(port_dev);
3202	return status;
3203}
3204
3205/*
3206 * If the USB "suspend" state is in use (rather than "global suspend"),
3207 * many devices will be individually taken out of suspend state using
3208 * special "resume" signaling.  This routine kicks in shortly after
3209 * hardware resume signaling is finished, either because of selective
3210 * resume (by host) or remote wakeup (by device) ... now see what changed
3211 * in the tree that's rooted at this device.
3212 *
3213 * If @udev->reset_resume is set then the device is reset before the
3214 * status check is done.
3215 */
3216static int finish_port_resume(struct usb_device *udev)
3217{
3218	int	status = 0;
3219	u16	devstatus = 0;
3220
3221	/* caller owns the udev device lock */
3222	dev_dbg(&udev->dev, "%s\n",
3223		udev->reset_resume ? "finish reset-resume" : "finish resume");
3224
3225	/* usb ch9 identifies four variants of SUSPENDED, based on what
3226	 * state the device resumes to.  Linux currently won't see the
3227	 * first two on the host side; they'd be inside hub_port_init()
3228	 * during many timeouts, but hub_wq can't suspend until later.
3229	 */
3230	usb_set_device_state(udev, udev->actconfig
3231			? USB_STATE_CONFIGURED
3232			: USB_STATE_ADDRESS);
3233
3234	/* 10.5.4.5 says not to reset a suspended port if the attached
3235	 * device is enabled for remote wakeup.  Hence the reset
3236	 * operation is carried out here, after the port has been
3237	 * resumed.
3238	 */
3239	if (udev->reset_resume) {
3240		/*
3241		 * If the device morphs or switches modes when it is reset,
3242		 * we don't want to perform a reset-resume.  We'll fail the
3243		 * resume, which will cause a logical disconnect, and then
3244		 * the device will be rediscovered.
3245		 */
3246 retry_reset_resume:
3247		if (udev->quirks & USB_QUIRK_RESET)
3248			status = -ENODEV;
3249		else
3250			status = usb_reset_and_verify_device(udev);
3251	}
3252
3253	/* 10.5.4.5 says be sure devices in the tree are still there.
3254	 * For now let's assume the device didn't go crazy on resume,
3255	 * and device drivers will know about any resume quirks.
3256	 */
3257	if (status == 0) {
3258		devstatus = 0;
3259		status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
3260
3261		/* If a normal resume failed, try doing a reset-resume */
3262		if (status && !udev->reset_resume && udev->persist_enabled) {
3263			dev_dbg(&udev->dev, "retry with reset-resume\n");
3264			udev->reset_resume = 1;
3265			goto retry_reset_resume;
3266		}
3267	}
3268
3269	if (status) {
3270		dev_dbg(&udev->dev, "gone after usb resume? status %d\n",
3271				status);
3272	/*
3273	 * There are a few quirky devices which violate the standard
3274	 * by claiming to have remote wakeup enabled after a reset,
3275	 * which crash if the feature is cleared, hence check for
3276	 * udev->reset_resume
3277	 */
3278	} else if (udev->actconfig && !udev->reset_resume) {
3279		if (udev->speed < USB_SPEED_SUPER) {
3280			if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP))
3281				status = usb_disable_remote_wakeup(udev);
3282		} else {
3283			status = usb_get_status(udev, USB_RECIP_INTERFACE, 0,
3284					&devstatus);
3285			if (!status && devstatus & (USB_INTRF_STAT_FUNC_RW_CAP
3286					| USB_INTRF_STAT_FUNC_RW))
3287				status = usb_disable_remote_wakeup(udev);
3288		}
3289
3290		if (status)
3291			dev_dbg(&udev->dev,
3292				"disable remote wakeup, status %d\n",
3293				status);
3294		status = 0;
3295	}
3296	return status;
3297}
3298
3299/*
3300 * There are some SS USB devices which take longer time for link training.
3301 * XHCI specs 4.19.4 says that when Link training is successful, port
3302 * sets CCS bit to 1. So if SW reads port status before successful link
3303 * training, then it will not find device to be present.
3304 * USB Analyzer log with such buggy devices show that in some cases
3305 * device switch on the RX termination after long delay of host enabling
3306 * the VBUS. In few other cases it has been seen that device fails to
3307 * negotiate link training in first attempt. It has been
3308 * reported till now that few devices take as long as 2000 ms to train
3309 * the link after host enabling its VBUS and termination. Following
3310 * routine implements a 2000 ms timeout for link training. If in a case
3311 * link trains before timeout, loop will exit earlier.
3312 *
3313 * There are also some 2.0 hard drive based devices and 3.0 thumb
3314 * drives that, when plugged into a 2.0 only port, take a long
3315 * time to set CCS after VBUS enable.
3316 *
3317 * FIXME: If a device was connected before suspend, but was removed
3318 * while system was asleep, then the loop in the following routine will
3319 * only exit at timeout.
3320 *
3321 * This routine should only be called when persist is enabled.
3322 */
3323static int wait_for_connected(struct usb_device *udev,
3324		struct usb_hub *hub, int *port1,
3325		u16 *portchange, u16 *portstatus)
3326{
3327	int status = 0, delay_ms = 0;
3328
3329	while (delay_ms < 2000) {
3330		if (status || *portstatus & USB_PORT_STAT_CONNECTION)
3331			break;
 
 
 
 
3332		msleep(20);
3333		delay_ms += 20;
3334		status = hub_port_status(hub, *port1, portstatus, portchange);
3335	}
3336	dev_dbg(&udev->dev, "Waited %dms for CONNECT\n", delay_ms);
3337	return status;
3338}
3339
3340/*
3341 * usb_port_resume - re-activate a suspended usb device's upstream port
3342 * @udev: device to re-activate, not a root hub
3343 * Context: must be able to sleep; device not locked; pm locks held
3344 *
3345 * This will re-activate the suspended device, increasing power usage
3346 * while letting drivers communicate again with its endpoints.
3347 * USB resume explicitly guarantees that the power session between
3348 * the host and the device is the same as it was when the device
3349 * suspended.
3350 *
3351 * If @udev->reset_resume is set then this routine won't check that the
3352 * port is still enabled.  Furthermore, finish_port_resume() above will
3353 * reset @udev.  The end result is that a broken power session can be
3354 * recovered and @udev will appear to persist across a loss of VBUS power.
3355 *
3356 * For example, if a host controller doesn't maintain VBUS suspend current
3357 * during a system sleep or is reset when the system wakes up, all the USB
3358 * power sessions below it will be broken.  This is especially troublesome
3359 * for mass-storage devices containing mounted filesystems, since the
3360 * device will appear to have disconnected and all the memory mappings
3361 * to it will be lost.  Using the USB_PERSIST facility, the device can be
3362 * made to appear as if it had not disconnected.
3363 *
3364 * This facility can be dangerous.  Although usb_reset_and_verify_device() makes
3365 * every effort to insure that the same device is present after the
3366 * reset as before, it cannot provide a 100% guarantee.  Furthermore it's
3367 * quite possible for a device to remain unaltered but its media to be
3368 * changed.  If the user replaces a flash memory card while the system is
3369 * asleep, he will have only himself to blame when the filesystem on the
3370 * new card is corrupted and the system crashes.
3371 *
3372 * Returns 0 on success, else negative errno.
3373 */
3374int usb_port_resume(struct usb_device *udev, pm_message_t msg)
3375{
3376	struct usb_hub	*hub = usb_hub_to_struct_hub(udev->parent);
3377	struct usb_port *port_dev = hub->ports[udev->portnum  - 1];
3378	int		port1 = udev->portnum;
3379	int		status;
3380	u16		portchange, portstatus;
3381
3382	if (!test_and_set_bit(port1, hub->child_usage_bits)) {
3383		status = pm_runtime_get_sync(&port_dev->dev);
3384		if (status < 0) {
3385			dev_dbg(&udev->dev, "can't resume usb port, status %d\n",
3386					status);
3387			return status;
3388		}
3389	}
3390
3391	usb_lock_port(port_dev);
3392
3393	/* Skip the initial Clear-Suspend step for a remote wakeup */
3394	status = hub_port_status(hub, port1, &portstatus, &portchange);
3395	if (status == 0 && !port_is_suspended(hub, portstatus))
 
 
3396		goto SuspendCleared;
 
3397
3398	/* see 7.1.7.7; affects power usage, but not budgeting */
3399	if (hub_is_superspeed(hub->hdev))
3400		status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U0);
3401	else
3402		status = usb_clear_port_feature(hub->hdev,
3403				port1, USB_PORT_FEAT_SUSPEND);
3404	if (status) {
3405		dev_dbg(&port_dev->dev, "can't resume, status %d\n", status);
3406	} else {
3407		/* drive resume for USB_RESUME_TIMEOUT msec */
3408		dev_dbg(&udev->dev, "usb %sresume\n",
3409				(PMSG_IS_AUTO(msg) ? "auto-" : ""));
3410		msleep(USB_RESUME_TIMEOUT);
3411
3412		/* Virtual root hubs can trigger on GET_PORT_STATUS to
3413		 * stop resume signaling.  Then finish the resume
3414		 * sequence.
3415		 */
3416		status = hub_port_status(hub, port1, &portstatus, &portchange);
3417
3418		/* TRSMRCY = 10 msec */
3419		msleep(10);
3420	}
3421
3422 SuspendCleared:
3423	if (status == 0) {
3424		udev->port_is_suspended = 0;
3425		if (hub_is_superspeed(hub->hdev)) {
3426			if (portchange & USB_PORT_STAT_C_LINK_STATE)
3427				usb_clear_port_feature(hub->hdev, port1,
3428					USB_PORT_FEAT_C_PORT_LINK_STATE);
3429		} else {
3430			if (portchange & USB_PORT_STAT_C_SUSPEND)
3431				usb_clear_port_feature(hub->hdev, port1,
3432						USB_PORT_FEAT_C_SUSPEND);
3433		}
 
 
 
3434	}
3435
3436	if (udev->persist_enabled)
3437		status = wait_for_connected(udev, hub, &port1, &portchange,
3438				&portstatus);
3439
3440	status = check_port_resume_type(udev,
3441			hub, port1, status, portchange, portstatus);
3442	if (status == 0)
3443		status = finish_port_resume(udev);
3444	if (status < 0) {
3445		dev_dbg(&udev->dev, "can't resume, status %d\n", status);
3446		hub_port_logical_disconnect(hub, port1);
3447	} else  {
3448		/* Try to enable USB2 hardware LPM */
3449		if (udev->usb2_hw_lpm_capable == 1)
3450			usb_set_usb2_hardware_lpm(udev, 1);
3451
3452		/* Try to enable USB3 LTM and LPM */
3453		usb_enable_ltm(udev);
3454		usb_unlocked_enable_lpm(udev);
3455	}
3456
3457	usb_unlock_port(port_dev);
3458
3459	return status;
3460}
3461
3462int usb_remote_wakeup(struct usb_device *udev)
3463{
3464	int	status = 0;
3465
3466	usb_lock_device(udev);
3467	if (udev->state == USB_STATE_SUSPENDED) {
3468		dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
3469		status = usb_autoresume_device(udev);
3470		if (status == 0) {
3471			/* Let the drivers do their thing, then... */
3472			usb_autosuspend_device(udev);
3473		}
3474	}
3475	usb_unlock_device(udev);
3476	return status;
3477}
3478
3479/* Returns 1 if there was a remote wakeup and a connect status change. */
3480static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
3481		u16 portstatus, u16 portchange)
3482		__must_hold(&port_dev->status_lock)
3483{
3484	struct usb_port *port_dev = hub->ports[port - 1];
3485	struct usb_device *hdev;
3486	struct usb_device *udev;
3487	int connect_change = 0;
 
3488	int ret;
3489
3490	hdev = hub->hdev;
3491	udev = port_dev->child;
3492	if (!hub_is_superspeed(hdev)) {
3493		if (!(portchange & USB_PORT_STAT_C_SUSPEND))
3494			return 0;
3495		usb_clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND);
3496	} else {
 
3497		if (!udev || udev->state != USB_STATE_SUSPENDED ||
3498				 (portstatus & USB_PORT_STAT_LINK_STATE) !=
3499				 USB_SS_PORT_LS_U0)
 
3500			return 0;
3501	}
3502
3503	if (udev) {
3504		/* TRSMRCY = 10 msec */
3505		msleep(10);
3506
3507		usb_unlock_port(port_dev);
3508		ret = usb_remote_wakeup(udev);
3509		usb_lock_port(port_dev);
3510		if (ret < 0)
3511			connect_change = 1;
3512	} else {
3513		ret = -ENODEV;
3514		hub_port_disable(hub, port, 1);
3515	}
3516	dev_dbg(&port_dev->dev, "resume, status %d\n", ret);
3517	return connect_change;
3518}
3519
3520static int check_ports_changed(struct usb_hub *hub)
3521{
3522	int port1;
3523
3524	for (port1 = 1; port1 <= hub->hdev->maxchild; ++port1) {
3525		u16 portstatus, portchange;
3526		int status;
3527
3528		status = hub_port_status(hub, port1, &portstatus, &portchange);
3529		if (!status && portchange)
3530			return 1;
3531	}
3532	return 0;
3533}
3534
3535static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
3536{
3537	struct usb_hub		*hub = usb_get_intfdata(intf);
3538	struct usb_device	*hdev = hub->hdev;
3539	unsigned		port1;
3540	int			status;
3541
3542	/*
3543	 * Warn if children aren't already suspended.
3544	 * Also, add up the number of wakeup-enabled descendants.
3545	 */
3546	hub->wakeup_enabled_descendants = 0;
3547	for (port1 = 1; port1 <= hdev->maxchild; port1++) {
3548		struct usb_port *port_dev = hub->ports[port1 - 1];
3549		struct usb_device *udev = port_dev->child;
3550
3551		if (udev && udev->can_submit) {
3552			dev_warn(&port_dev->dev, "device %s not suspended yet\n",
3553					dev_name(&udev->dev));
3554			if (PMSG_IS_AUTO(msg))
3555				return -EBUSY;
3556		}
3557		if (udev)
3558			hub->wakeup_enabled_descendants +=
3559					wakeup_enabled_descendants(udev);
3560	}
3561
3562	if (hdev->do_remote_wakeup && hub->quirk_check_port_auto_suspend) {
3563		/* check if there are changes pending on hub ports */
3564		if (check_ports_changed(hub)) {
3565			if (PMSG_IS_AUTO(msg))
3566				return -EBUSY;
3567			pm_wakeup_event(&hdev->dev, 2000);
3568		}
3569	}
3570
3571	if (hub_is_superspeed(hdev) && hdev->do_remote_wakeup) {
3572		/* Enable hub to send remote wakeup for all ports. */
3573		for (port1 = 1; port1 <= hdev->maxchild; port1++) {
3574			status = set_port_feature(hdev,
3575					port1 |
3576					USB_PORT_FEAT_REMOTE_WAKE_CONNECT |
3577					USB_PORT_FEAT_REMOTE_WAKE_DISCONNECT |
3578					USB_PORT_FEAT_REMOTE_WAKE_OVER_CURRENT,
3579					USB_PORT_FEAT_REMOTE_WAKE_MASK);
3580		}
3581	}
3582
3583	dev_dbg(&intf->dev, "%s\n", __func__);
3584
3585	/* stop hub_wq and related activity */
3586	hub_quiesce(hub, HUB_SUSPEND);
3587	return 0;
3588}
3589
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3590static int hub_resume(struct usb_interface *intf)
3591{
3592	struct usb_hub *hub = usb_get_intfdata(intf);
3593
3594	dev_dbg(&intf->dev, "%s\n", __func__);
3595	hub_activate(hub, HUB_RESUME);
 
 
 
 
 
 
 
 
3596	return 0;
3597}
3598
3599static int hub_reset_resume(struct usb_interface *intf)
3600{
3601	struct usb_hub *hub = usb_get_intfdata(intf);
3602
3603	dev_dbg(&intf->dev, "%s\n", __func__);
3604	hub_activate(hub, HUB_RESET_RESUME);
3605	return 0;
3606}
3607
3608/**
3609 * usb_root_hub_lost_power - called by HCD if the root hub lost Vbus power
3610 * @rhdev: struct usb_device for the root hub
3611 *
3612 * The USB host controller driver calls this function when its root hub
3613 * is resumed and Vbus power has been interrupted or the controller
3614 * has been reset.  The routine marks @rhdev as having lost power.
3615 * When the hub driver is resumed it will take notice and carry out
3616 * power-session recovery for all the "USB-PERSIST"-enabled child devices;
3617 * the others will be disconnected.
3618 */
3619void usb_root_hub_lost_power(struct usb_device *rhdev)
3620{
3621	dev_warn(&rhdev->dev, "root hub lost power or was reset\n");
3622	rhdev->reset_resume = 1;
3623}
3624EXPORT_SYMBOL_GPL(usb_root_hub_lost_power);
3625
3626static const char * const usb3_lpm_names[]  = {
3627	"U0",
3628	"U1",
3629	"U2",
3630	"U3",
3631};
3632
3633/*
3634 * Send a Set SEL control transfer to the device, prior to enabling
3635 * device-initiated U1 or U2.  This lets the device know the exit latencies from
3636 * the time the device initiates a U1 or U2 exit, to the time it will receive a
3637 * packet from the host.
3638 *
3639 * This function will fail if the SEL or PEL values for udev are greater than
3640 * the maximum allowed values for the link state to be enabled.
3641 */
3642static int usb_req_set_sel(struct usb_device *udev, enum usb3_link_state state)
3643{
3644	struct usb_set_sel_req *sel_values;
3645	unsigned long long u1_sel;
3646	unsigned long long u1_pel;
3647	unsigned long long u2_sel;
3648	unsigned long long u2_pel;
3649	int ret;
3650
3651	if (udev->state != USB_STATE_CONFIGURED)
3652		return 0;
3653
3654	/* Convert SEL and PEL stored in ns to us */
3655	u1_sel = DIV_ROUND_UP(udev->u1_params.sel, 1000);
3656	u1_pel = DIV_ROUND_UP(udev->u1_params.pel, 1000);
3657	u2_sel = DIV_ROUND_UP(udev->u2_params.sel, 1000);
3658	u2_pel = DIV_ROUND_UP(udev->u2_params.pel, 1000);
3659
3660	/*
3661	 * Make sure that the calculated SEL and PEL values for the link
3662	 * state we're enabling aren't bigger than the max SEL/PEL
3663	 * value that will fit in the SET SEL control transfer.
3664	 * Otherwise the device would get an incorrect idea of the exit
3665	 * latency for the link state, and could start a device-initiated
3666	 * U1/U2 when the exit latencies are too high.
3667	 */
3668	if ((state == USB3_LPM_U1 &&
3669				(u1_sel > USB3_LPM_MAX_U1_SEL_PEL ||
3670				 u1_pel > USB3_LPM_MAX_U1_SEL_PEL)) ||
3671			(state == USB3_LPM_U2 &&
3672			 (u2_sel > USB3_LPM_MAX_U2_SEL_PEL ||
3673			  u2_pel > USB3_LPM_MAX_U2_SEL_PEL))) {
3674		dev_dbg(&udev->dev, "Device-initiated %s disabled due to long SEL %llu us or PEL %llu us\n",
3675				usb3_lpm_names[state], u1_sel, u1_pel);
3676		return -EINVAL;
3677	}
3678
3679	/*
3680	 * If we're enabling device-initiated LPM for one link state,
3681	 * but the other link state has a too high SEL or PEL value,
3682	 * just set those values to the max in the Set SEL request.
3683	 */
3684	if (u1_sel > USB3_LPM_MAX_U1_SEL_PEL)
3685		u1_sel = USB3_LPM_MAX_U1_SEL_PEL;
3686
3687	if (u1_pel > USB3_LPM_MAX_U1_SEL_PEL)
3688		u1_pel = USB3_LPM_MAX_U1_SEL_PEL;
3689
3690	if (u2_sel > USB3_LPM_MAX_U2_SEL_PEL)
3691		u2_sel = USB3_LPM_MAX_U2_SEL_PEL;
3692
3693	if (u2_pel > USB3_LPM_MAX_U2_SEL_PEL)
3694		u2_pel = USB3_LPM_MAX_U2_SEL_PEL;
3695
3696	/*
3697	 * usb_enable_lpm() can be called as part of a failed device reset,
3698	 * which may be initiated by an error path of a mass storage driver.
3699	 * Therefore, use GFP_NOIO.
3700	 */
3701	sel_values = kmalloc(sizeof *(sel_values), GFP_NOIO);
3702	if (!sel_values)
3703		return -ENOMEM;
3704
3705	sel_values->u1_sel = u1_sel;
3706	sel_values->u1_pel = u1_pel;
3707	sel_values->u2_sel = cpu_to_le16(u2_sel);
3708	sel_values->u2_pel = cpu_to_le16(u2_pel);
3709
3710	ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3711			USB_REQ_SET_SEL,
3712			USB_RECIP_DEVICE,
3713			0, 0,
3714			sel_values, sizeof *(sel_values),
3715			USB_CTRL_SET_TIMEOUT);
3716	kfree(sel_values);
 
 
 
 
3717	return ret;
3718}
3719
3720/*
3721 * Enable or disable device-initiated U1 or U2 transitions.
3722 */
3723static int usb_set_device_initiated_lpm(struct usb_device *udev,
3724		enum usb3_link_state state, bool enable)
3725{
3726	int ret;
3727	int feature;
3728
3729	switch (state) {
3730	case USB3_LPM_U1:
3731		feature = USB_DEVICE_U1_ENABLE;
3732		break;
3733	case USB3_LPM_U2:
3734		feature = USB_DEVICE_U2_ENABLE;
3735		break;
3736	default:
3737		dev_warn(&udev->dev, "%s: Can't %s non-U1 or U2 state.\n",
3738				__func__, enable ? "enable" : "disable");
3739		return -EINVAL;
3740	}
3741
3742	if (udev->state != USB_STATE_CONFIGURED) {
3743		dev_dbg(&udev->dev, "%s: Can't %s %s state "
3744				"for unconfigured device.\n",
3745				__func__, enable ? "enable" : "disable",
3746				usb3_lpm_names[state]);
3747		return 0;
3748	}
3749
3750	if (enable) {
3751		/*
3752		 * Now send the control transfer to enable device-initiated LPM
3753		 * for either U1 or U2.
3754		 */
3755		ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3756				USB_REQ_SET_FEATURE,
3757				USB_RECIP_DEVICE,
3758				feature,
3759				0, NULL, 0,
3760				USB_CTRL_SET_TIMEOUT);
3761	} else {
3762		ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3763				USB_REQ_CLEAR_FEATURE,
3764				USB_RECIP_DEVICE,
3765				feature,
3766				0, NULL, 0,
3767				USB_CTRL_SET_TIMEOUT);
3768	}
3769	if (ret < 0) {
3770		dev_warn(&udev->dev, "%s of device-initiated %s failed.\n",
3771				enable ? "Enable" : "Disable",
3772				usb3_lpm_names[state]);
3773		return -EBUSY;
3774	}
3775	return 0;
3776}
3777
3778static int usb_set_lpm_timeout(struct usb_device *udev,
3779		enum usb3_link_state state, int timeout)
3780{
3781	int ret;
3782	int feature;
3783
3784	switch (state) {
3785	case USB3_LPM_U1:
3786		feature = USB_PORT_FEAT_U1_TIMEOUT;
3787		break;
3788	case USB3_LPM_U2:
3789		feature = USB_PORT_FEAT_U2_TIMEOUT;
3790		break;
3791	default:
3792		dev_warn(&udev->dev, "%s: Can't set timeout for non-U1 or U2 state.\n",
3793				__func__);
3794		return -EINVAL;
3795	}
3796
3797	if (state == USB3_LPM_U1 && timeout > USB3_LPM_U1_MAX_TIMEOUT &&
3798			timeout != USB3_LPM_DEVICE_INITIATED) {
3799		dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x, "
3800				"which is a reserved value.\n",
3801				usb3_lpm_names[state], timeout);
3802		return -EINVAL;
3803	}
3804
3805	ret = set_port_feature(udev->parent,
3806			USB_PORT_LPM_TIMEOUT(timeout) | udev->portnum,
3807			feature);
3808	if (ret < 0) {
3809		dev_warn(&udev->dev, "Failed to set %s timeout to 0x%x,"
3810				"error code %i\n", usb3_lpm_names[state],
3811				timeout, ret);
3812		return -EBUSY;
3813	}
3814	if (state == USB3_LPM_U1)
3815		udev->u1_params.timeout = timeout;
3816	else
3817		udev->u2_params.timeout = timeout;
3818	return 0;
3819}
3820
3821/*
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3822 * Enable the hub-initiated U1/U2 idle timeouts, and enable device-initiated
3823 * U1/U2 entry.
3824 *
3825 * We will attempt to enable U1 or U2, but there are no guarantees that the
3826 * control transfers to set the hub timeout or enable device-initiated U1/U2
3827 * will be successful.
3828 *
 
 
 
3829 * If we cannot set the parent hub U1/U2 timeout, we attempt to let the xHCI
3830 * driver know about it.  If that call fails, it should be harmless, and just
3831 * take up more slightly more bus bandwidth for unnecessary U1/U2 exit latency.
3832 */
3833static void usb_enable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
3834		enum usb3_link_state state)
3835{
3836	int timeout, ret;
3837	__u8 u1_mel = udev->bos->ss_cap->bU1devExitLat;
3838	__le16 u2_mel = udev->bos->ss_cap->bU2DevExitLat;
 
 
 
 
 
 
 
3839
3840	/* If the device says it doesn't have *any* exit latency to come out of
3841	 * U1 or U2, it's probably lying.  Assume it doesn't implement that link
3842	 * state.
3843	 */
3844	if ((state == USB3_LPM_U1 && u1_mel == 0) ||
3845			(state == USB3_LPM_U2 && u2_mel == 0))
3846		return;
3847
3848	/*
3849	 * First, let the device know about the exit latencies
3850	 * associated with the link state we're about to enable.
3851	 */
3852	ret = usb_req_set_sel(udev, state);
3853	if (ret < 0) {
3854		dev_warn(&udev->dev, "Set SEL for device-initiated %s failed.\n",
3855				usb3_lpm_names[state]);
3856		return;
3857	}
3858
3859	/* We allow the host controller to set the U1/U2 timeout internally
3860	 * first, so that it can change its schedule to account for the
3861	 * additional latency to send data to a device in a lower power
3862	 * link state.
3863	 */
3864	timeout = hcd->driver->enable_usb3_lpm_timeout(hcd, udev, state);
3865
3866	/* xHCI host controller doesn't want to enable this LPM state. */
3867	if (timeout == 0)
3868		return;
3869
3870	if (timeout < 0) {
3871		dev_warn(&udev->dev, "Could not enable %s link state, "
3872				"xHCI error %i.\n", usb3_lpm_names[state],
3873				timeout);
3874		return;
3875	}
3876
3877	if (usb_set_lpm_timeout(udev, state, timeout)) {
3878		/* If we can't set the parent hub U1/U2 timeout,
3879		 * device-initiated LPM won't be allowed either, so let the xHCI
3880		 * host know that this link state won't be enabled.
3881		 */
3882		hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state);
3883	} else {
3884		/* Only a configured device will accept the Set Feature
3885		 * U1/U2_ENABLE
3886		 */
3887		if (udev->actconfig)
3888			usb_set_device_initiated_lpm(udev, state, true);
3889
3890		/* As soon as usb_set_lpm_timeout(timeout) returns 0, the
3891		 * hub-initiated LPM is enabled. Thus, LPM is enabled no
3892		 * matter the result of usb_set_device_initiated_lpm().
3893		 * The only difference is whether device is able to initiate
3894		 * LPM.
3895		 */
3896		if (state == USB3_LPM_U1)
3897			udev->usb3_lpm_u1_enabled = 1;
3898		else if (state == USB3_LPM_U2)
3899			udev->usb3_lpm_u2_enabled = 1;
 
 
 
 
3900	}
3901}
3902
 
 
 
 
 
3903/*
3904 * Disable the hub-initiated U1/U2 idle timeouts, and disable device-initiated
3905 * U1/U2 entry.
3906 *
3907 * If this function returns -EBUSY, the parent hub will still allow U1/U2 entry.
3908 * If zero is returned, the parent will not allow the link to go into U1/U2.
3909 *
3910 * If zero is returned, device-initiated U1/U2 entry may still be enabled, but
3911 * it won't have an effect on the bus link state because the parent hub will
3912 * still disallow device-initiated U1/U2 entry.
3913 *
3914 * If zero is returned, the xHCI host controller may still think U1/U2 entry is
3915 * possible.  The result will be slightly more bus bandwidth will be taken up
3916 * (to account for U1/U2 exit latency), but it should be harmless.
3917 */
3918static int usb_disable_link_state(struct usb_hcd *hcd, struct usb_device *udev,
3919		enum usb3_link_state state)
3920{
3921	switch (state) {
3922	case USB3_LPM_U1:
3923	case USB3_LPM_U2:
3924		break;
3925	default:
3926		dev_warn(&udev->dev, "%s: Can't disable non-U1 or U2 state.\n",
3927				__func__);
3928		return -EINVAL;
3929	}
3930
3931	if (usb_set_lpm_timeout(udev, state, 0))
3932		return -EBUSY;
3933
3934	usb_set_device_initiated_lpm(udev, state, false);
3935
3936	if (hcd->driver->disable_usb3_lpm_timeout(hcd, udev, state))
3937		dev_warn(&udev->dev, "Could not disable xHCI %s timeout, "
3938				"bus schedule bandwidth may be impacted.\n",
3939				usb3_lpm_names[state]);
3940
3941	/* As soon as usb_set_lpm_timeout(0) return 0, hub initiated LPM
3942	 * is disabled. Hub will disallows link to enter U1/U2 as well,
3943	 * even device is initiating LPM. Hence LPM is disabled if hub LPM
3944	 * timeout set to 0, no matter device-initiated LPM is disabled or
3945	 * not.
3946	 */
3947	if (state == USB3_LPM_U1)
3948		udev->usb3_lpm_u1_enabled = 0;
3949	else if (state == USB3_LPM_U2)
3950		udev->usb3_lpm_u2_enabled = 0;
3951
3952	return 0;
3953}
3954
3955/*
3956 * Disable hub-initiated and device-initiated U1 and U2 entry.
3957 * Caller must own the bandwidth_mutex.
3958 *
3959 * This will call usb_enable_lpm() on failure, which will decrement
3960 * lpm_disable_count, and will re-enable LPM if lpm_disable_count reaches zero.
3961 */
3962int usb_disable_lpm(struct usb_device *udev)
3963{
3964	struct usb_hcd *hcd;
3965
3966	if (!udev || !udev->parent ||
3967			udev->speed < USB_SPEED_SUPER ||
3968			!udev->lpm_capable ||
3969			udev->state < USB_STATE_DEFAULT)
3970		return 0;
3971
3972	hcd = bus_to_hcd(udev->bus);
3973	if (!hcd || !hcd->driver->disable_usb3_lpm_timeout)
3974		return 0;
3975
3976	udev->lpm_disable_count++;
3977	if ((udev->u1_params.timeout == 0 && udev->u2_params.timeout == 0))
3978		return 0;
3979
3980	/* If LPM is enabled, attempt to disable it. */
3981	if (usb_disable_link_state(hcd, udev, USB3_LPM_U1))
3982		goto enable_lpm;
3983	if (usb_disable_link_state(hcd, udev, USB3_LPM_U2))
3984		goto enable_lpm;
3985
3986	return 0;
3987
3988enable_lpm:
3989	usb_enable_lpm(udev);
3990	return -EBUSY;
3991}
3992EXPORT_SYMBOL_GPL(usb_disable_lpm);
3993
3994/* Grab the bandwidth_mutex before calling usb_disable_lpm() */
3995int usb_unlocked_disable_lpm(struct usb_device *udev)
3996{
3997	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
3998	int ret;
3999
4000	if (!hcd)
4001		return -EINVAL;
4002
4003	mutex_lock(hcd->bandwidth_mutex);
4004	ret = usb_disable_lpm(udev);
4005	mutex_unlock(hcd->bandwidth_mutex);
4006
4007	return ret;
4008}
4009EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
4010
4011/*
4012 * Attempt to enable device-initiated and hub-initiated U1 and U2 entry.  The
4013 * xHCI host policy may prevent U1 or U2 from being enabled.
4014 *
4015 * Other callers may have disabled link PM, so U1 and U2 entry will be disabled
4016 * until the lpm_disable_count drops to zero.  Caller must own the
4017 * bandwidth_mutex.
4018 */
4019void usb_enable_lpm(struct usb_device *udev)
4020{
4021	struct usb_hcd *hcd;
4022	struct usb_hub *hub;
4023	struct usb_port *port_dev;
4024
4025	if (!udev || !udev->parent ||
4026			udev->speed < USB_SPEED_SUPER ||
4027			!udev->lpm_capable ||
4028			udev->state < USB_STATE_DEFAULT)
4029		return;
4030
4031	udev->lpm_disable_count--;
4032	hcd = bus_to_hcd(udev->bus);
4033	/* Double check that we can both enable and disable LPM.
4034	 * Device must be configured to accept set feature U1/U2 timeout.
4035	 */
4036	if (!hcd || !hcd->driver->enable_usb3_lpm_timeout ||
4037			!hcd->driver->disable_usb3_lpm_timeout)
4038		return;
4039
4040	if (udev->lpm_disable_count > 0)
4041		return;
4042
4043	hub = usb_hub_to_struct_hub(udev->parent);
4044	if (!hub)
4045		return;
4046
4047	port_dev = hub->ports[udev->portnum - 1];
4048
4049	if (port_dev->usb3_lpm_u1_permit)
4050		usb_enable_link_state(hcd, udev, USB3_LPM_U1);
4051
4052	if (port_dev->usb3_lpm_u2_permit)
4053		usb_enable_link_state(hcd, udev, USB3_LPM_U2);
4054}
4055EXPORT_SYMBOL_GPL(usb_enable_lpm);
4056
4057/* Grab the bandwidth_mutex before calling usb_enable_lpm() */
4058void usb_unlocked_enable_lpm(struct usb_device *udev)
4059{
4060	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
4061
4062	if (!hcd)
4063		return;
4064
4065	mutex_lock(hcd->bandwidth_mutex);
4066	usb_enable_lpm(udev);
4067	mutex_unlock(hcd->bandwidth_mutex);
4068}
4069EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
4070
4071/* usb3 devices use U3 for disabled, make sure remote wakeup is disabled */
4072static void hub_usb3_port_prepare_disable(struct usb_hub *hub,
4073					  struct usb_port *port_dev)
4074{
4075	struct usb_device *udev = port_dev->child;
4076	int ret;
4077
4078	if (udev && udev->port_is_suspended && udev->do_remote_wakeup) {
4079		ret = hub_set_port_link_state(hub, port_dev->portnum,
4080					      USB_SS_PORT_LS_U0);
4081		if (!ret) {
4082			msleep(USB_RESUME_TIMEOUT);
4083			ret = usb_disable_remote_wakeup(udev);
4084		}
4085		if (ret)
4086			dev_warn(&udev->dev,
4087				 "Port disable: can't disable remote wake\n");
4088		udev->do_remote_wakeup = 0;
4089	}
4090}
4091
4092#else	/* CONFIG_PM */
4093
4094#define hub_suspend		NULL
4095#define hub_resume		NULL
4096#define hub_reset_resume	NULL
4097
4098static inline void hub_usb3_port_prepare_disable(struct usb_hub *hub,
4099						 struct usb_port *port_dev) { }
4100
4101int usb_disable_lpm(struct usb_device *udev)
4102{
4103	return 0;
4104}
4105EXPORT_SYMBOL_GPL(usb_disable_lpm);
4106
4107void usb_enable_lpm(struct usb_device *udev) { }
4108EXPORT_SYMBOL_GPL(usb_enable_lpm);
4109
4110int usb_unlocked_disable_lpm(struct usb_device *udev)
4111{
4112	return 0;
4113}
4114EXPORT_SYMBOL_GPL(usb_unlocked_disable_lpm);
4115
4116void usb_unlocked_enable_lpm(struct usb_device *udev) { }
4117EXPORT_SYMBOL_GPL(usb_unlocked_enable_lpm);
4118
4119int usb_disable_ltm(struct usb_device *udev)
4120{
4121	return 0;
4122}
4123EXPORT_SYMBOL_GPL(usb_disable_ltm);
4124
4125void usb_enable_ltm(struct usb_device *udev) { }
4126EXPORT_SYMBOL_GPL(usb_enable_ltm);
4127
4128static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
4129		u16 portstatus, u16 portchange)
4130{
4131	return 0;
4132}
4133
 
 
 
 
 
4134#endif	/* CONFIG_PM */
4135
4136/*
4137 * USB-3 does not have a similar link state as USB-2 that will avoid negotiating
4138 * a connection with a plugged-in cable but will signal the host when the cable
4139 * is unplugged. Disable remote wake and set link state to U3 for USB-3 devices
4140 */
4141static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
4142{
4143	struct usb_port *port_dev = hub->ports[port1 - 1];
4144	struct usb_device *hdev = hub->hdev;
4145	int ret = 0;
4146
4147	if (!hub->error) {
4148		if (hub_is_superspeed(hub->hdev)) {
4149			hub_usb3_port_prepare_disable(hub, port_dev);
4150			ret = hub_set_port_link_state(hub, port_dev->portnum,
4151						      USB_SS_PORT_LS_U3);
4152		} else {
4153			ret = usb_clear_port_feature(hdev, port1,
4154					USB_PORT_FEAT_ENABLE);
4155		}
4156	}
4157	if (port_dev->child && set_state)
4158		usb_set_device_state(port_dev->child, USB_STATE_NOTATTACHED);
4159	if (ret && ret != -ENODEV)
4160		dev_err(&port_dev->dev, "cannot disable (err = %d)\n", ret);
4161	return ret;
4162}
4163
 
 
 
 
 
 
 
 
 
 
 
 
 
4164
4165/* USB 2.0 spec, 7.1.7.3 / fig 7-29:
4166 *
4167 * Between connect detection and reset signaling there must be a delay
4168 * of 100ms at least for debounce and power-settling.  The corresponding
4169 * timer shall restart whenever the downstream port detects a disconnect.
4170 *
4171 * Apparently there are some bluetooth and irda-dongles and a number of
4172 * low-speed devices for which this debounce period may last over a second.
4173 * Not covered by the spec - but easy to deal with.
4174 *
4175 * This implementation uses a 1500ms total debounce timeout; if the
4176 * connection isn't stable by then it returns -ETIMEDOUT.  It checks
4177 * every 25ms for transient disconnects.  When the port status has been
4178 * unchanged for 100ms it returns the port status.
4179 */
4180int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected)
4181{
4182	int ret;
4183	u16 portchange, portstatus;
4184	unsigned connection = 0xffff;
4185	int total_time, stable_time = 0;
4186	struct usb_port *port_dev = hub->ports[port1 - 1];
4187
4188	for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
4189		ret = hub_port_status(hub, port1, &portstatus, &portchange);
4190		if (ret < 0)
4191			return ret;
4192
4193		if (!(portchange & USB_PORT_STAT_C_CONNECTION) &&
4194		     (portstatus & USB_PORT_STAT_CONNECTION) == connection) {
4195			if (!must_be_connected ||
4196			     (connection == USB_PORT_STAT_CONNECTION))
4197				stable_time += HUB_DEBOUNCE_STEP;
4198			if (stable_time >= HUB_DEBOUNCE_STABLE)
4199				break;
4200		} else {
4201			stable_time = 0;
4202			connection = portstatus & USB_PORT_STAT_CONNECTION;
4203		}
4204
4205		if (portchange & USB_PORT_STAT_C_CONNECTION) {
4206			usb_clear_port_feature(hub->hdev, port1,
4207					USB_PORT_FEAT_C_CONNECTION);
4208		}
4209
4210		if (total_time >= HUB_DEBOUNCE_TIMEOUT)
4211			break;
4212		msleep(HUB_DEBOUNCE_STEP);
4213	}
4214
4215	dev_dbg(&port_dev->dev, "debounce total %dms stable %dms status 0x%x\n",
4216			total_time, stable_time, portstatus);
4217
4218	if (stable_time < HUB_DEBOUNCE_STABLE)
4219		return -ETIMEDOUT;
4220	return portstatus;
4221}
4222
4223void usb_ep0_reinit(struct usb_device *udev)
4224{
4225	usb_disable_endpoint(udev, 0 + USB_DIR_IN, true);
4226	usb_disable_endpoint(udev, 0 + USB_DIR_OUT, true);
4227	usb_enable_endpoint(udev, &udev->ep0, true);
4228}
4229EXPORT_SYMBOL_GPL(usb_ep0_reinit);
4230
4231#define usb_sndaddr0pipe()	(PIPE_CONTROL << 30)
4232#define usb_rcvaddr0pipe()	((PIPE_CONTROL << 30) | USB_DIR_IN)
4233
4234static int hub_set_address(struct usb_device *udev, int devnum)
4235{
4236	int retval;
 
4237	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 
 
 
 
4238
4239	/*
4240	 * The host controller will choose the device address,
4241	 * instead of the core having chosen it earlier
4242	 */
4243	if (!hcd->driver->address_device && devnum <= 1)
4244		return -EINVAL;
4245	if (udev->state == USB_STATE_ADDRESS)
4246		return 0;
4247	if (udev->state != USB_STATE_DEFAULT)
4248		return -EINVAL;
4249	if (hcd->driver->address_device)
4250		retval = hcd->driver->address_device(hcd, udev);
4251	else
4252		retval = usb_control_msg(udev, usb_sndaddr0pipe(),
4253				USB_REQ_SET_ADDRESS, 0, devnum, 0,
4254				NULL, 0, USB_CTRL_SET_TIMEOUT);
4255	if (retval == 0) {
4256		update_devnum(udev, devnum);
4257		/* Device now using proper address. */
4258		usb_set_device_state(udev, USB_STATE_ADDRESS);
4259		usb_ep0_reinit(udev);
4260	}
4261	return retval;
4262}
4263
4264/*
4265 * There are reports of USB 3.0 devices that say they support USB 2.0 Link PM
4266 * when they're plugged into a USB 2.0 port, but they don't work when LPM is
4267 * enabled.
4268 *
4269 * Only enable USB 2.0 Link PM if the port is internal (hardwired), or the
4270 * device says it supports the new USB 2.0 Link PM errata by setting the BESL
4271 * support bit in the BOS descriptor.
4272 */
4273static void hub_set_initial_usb2_lpm_policy(struct usb_device *udev)
4274{
4275	struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
4276	int connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN;
4277
4278	if (!udev->usb2_hw_lpm_capable || !udev->bos)
4279		return;
4280
4281	if (hub)
4282		connect_type = hub->ports[udev->portnum - 1]->connect_type;
4283
4284	if ((udev->bos->ext_cap->bmAttributes & cpu_to_le32(USB_BESL_SUPPORT)) ||
4285			connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
4286		udev->usb2_hw_lpm_allowed = 1;
4287		usb_set_usb2_hardware_lpm(udev, 1);
4288	}
4289}
4290
4291static int hub_enable_device(struct usb_device *udev)
4292{
4293	struct usb_hcd *hcd = bus_to_hcd(udev->bus);
4294
4295	if (!hcd->driver->enable_device)
4296		return 0;
4297	if (udev->state == USB_STATE_ADDRESS)
4298		return 0;
4299	if (udev->state != USB_STATE_DEFAULT)
4300		return -EINVAL;
4301
4302	return hcd->driver->enable_device(hcd, udev);
4303}
4304
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4305/* Reset device, (re)assign address, get device descriptor.
4306 * Device connection must be stable, no more debouncing needed.
4307 * Returns device in USB_STATE_ADDRESS, except on error.
4308 *
4309 * If this is called for an already-existing device (as part of
4310 * usb_reset_and_verify_device), the caller must own the device lock and
4311 * the port lock.  For a newly detected device that is not accessible
4312 * through any global pointers, it's not necessary to lock the device,
4313 * but it is still necessary to lock the port.
 
 
 
 
 
 
 
4314 */
4315static int
4316hub_port_init(struct usb_hub *hub, struct usb_device *udev, int port1,
4317		int retry_counter)
4318{
4319	struct usb_device	*hdev = hub->hdev;
4320	struct usb_hcd		*hcd = bus_to_hcd(hdev->bus);
 
4321	int			retries, operations, retval, i;
4322	unsigned		delay = HUB_SHORT_RESET_TIME;
4323	enum usb_device_speed	oldspeed = udev->speed;
4324	const char		*speed;
4325	int			devnum = udev->devnum;
 
 
 
 
 
 
 
 
 
4326
4327	/* root hub ports have a slightly longer reset period
4328	 * (from USB 2.0 spec, section 7.1.7.5)
4329	 */
4330	if (!hdev->parent) {
4331		delay = HUB_ROOT_RESET_TIME;
4332		if (port1 == hdev->bus->otg_port)
4333			hdev->bus->b_hnp_enable = 0;
4334	}
4335
4336	/* Some low speed devices have problems with the quick delay, so */
4337	/*  be a bit pessimistic with those devices. RHbug #23670 */
4338	if (oldspeed == USB_SPEED_LOW)
4339		delay = HUB_LONG_RESET_TIME;
4340
4341	mutex_lock(hcd->address0_mutex);
4342
4343	/* Reset the device; full speed may morph to high speed */
4344	/* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */
4345	retval = hub_port_reset(hub, port1, udev, delay, false);
4346	if (retval < 0)		/* error or disconnect */
4347		goto fail;
4348	/* success, speed is known */
4349
4350	retval = -ENODEV;
4351
4352	/* Don't allow speed changes at reset, except usb 3.0 to faster */
4353	if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed &&
4354	    !(oldspeed == USB_SPEED_SUPER && udev->speed > oldspeed)) {
4355		dev_dbg(&udev->dev, "device reset changed speed!\n");
4356		goto fail;
4357	}
4358	oldspeed = udev->speed;
4359
4360	/* USB 2.0 section 5.5.3 talks about ep0 maxpacket ...
4361	 * it's fixed size except for full speed devices.
4362	 * For Wireless USB devices, ep0 max packet is always 512 (tho
4363	 * reported as 0xff in the device descriptor). WUSB1.0[4.8.1].
4364	 */
4365	switch (udev->speed) {
4366	case USB_SPEED_SUPER_PLUS:
4367	case USB_SPEED_SUPER:
4368	case USB_SPEED_WIRELESS:	/* fixed at 512 */
4369		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
4370		break;
4371	case USB_SPEED_HIGH:		/* fixed at 64 */
4372		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
4373		break;
4374	case USB_SPEED_FULL:		/* 8, 16, 32, or 64 */
4375		/* to determine the ep0 maxpacket size, try to read
4376		 * the device descriptor to get bMaxPacketSize0 and
4377		 * then correct our initial guess.
4378		 */
4379		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
4380		break;
4381	case USB_SPEED_LOW:		/* fixed at 8 */
4382		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(8);
4383		break;
4384	default:
4385		goto fail;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4386	}
4387
4388	if (udev->speed == USB_SPEED_WIRELESS)
4389		speed = "variable speed Wireless";
 
 
 
 
 
 
 
 
 
4390	else
4391		speed = usb_speed_string(udev->speed);
4392
4393	if (udev->speed < USB_SPEED_SUPER)
4394		dev_info(&udev->dev,
4395				"%s %s USB device number %d using %s\n",
4396				(udev->config) ? "reset" : "new", speed,
4397				devnum, udev->bus->controller->driver->name);
4398
4399	/* Set up TT records, if needed  */
4400	if (hdev->tt) {
4401		udev->tt = hdev->tt;
4402		udev->ttport = hdev->ttport;
4403	} else if (udev->speed != USB_SPEED_HIGH
4404			&& hdev->speed == USB_SPEED_HIGH) {
4405		if (!hub->tt.hub) {
4406			dev_err(&udev->dev, "parent hub has no TT\n");
4407			retval = -EINVAL;
4408			goto fail;
 
 
 
 
4409		}
4410		udev->tt = &hub->tt;
4411		udev->ttport = port1;
4412	}
4413
4414	/* Why interleave GET_DESCRIPTOR and SET_ADDRESS this way?
4415	 * Because device hardware and firmware is sometimes buggy in
4416	 * this area, and this is how Linux has done it for ages.
4417	 * Change it cautiously.
4418	 *
4419	 * NOTE:  If use_new_scheme() is true we will start by issuing
4420	 * a 64-byte GET_DESCRIPTOR request.  This is what Windows does,
4421	 * so it may help with some non-standards-compliant devices.
4422	 * Otherwise we start with SET_ADDRESS and then try to read the
4423	 * first 8 bytes of the device descriptor to get the ep0 maxpacket
4424	 * value.
4425	 */
4426	for (retries = 0; retries < GET_DESCRIPTOR_TRIES; (++retries, msleep(100))) {
4427		bool did_new_scheme = false;
4428
4429		if (use_new_scheme(udev, retry_counter)) {
4430			struct usb_device_descriptor *buf;
4431			int r = 0;
 
 
4432
4433			did_new_scheme = true;
4434			retval = hub_enable_device(udev);
4435			if (retval < 0) {
4436				dev_err(&udev->dev,
4437					"hub failed to enable device, error %d\n",
4438					retval);
4439				goto fail;
4440			}
4441
4442#define GET_DESCRIPTOR_BUFSIZE	64
4443			buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);
4444			if (!buf) {
4445				retval = -ENOMEM;
4446				continue;
4447			}
4448
4449			/* Retry on all errors; some devices are flakey.
4450			 * 255 is for WUSB devices, we actually need to use
4451			 * 512 (WUSB1.0[4.8.1]).
4452			 */
4453			for (operations = 0; operations < 3; ++operations) {
4454				buf->bMaxPacketSize0 = 0;
4455				r = usb_control_msg(udev, usb_rcvaddr0pipe(),
4456					USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
4457					USB_DT_DEVICE << 8, 0,
4458					buf, GET_DESCRIPTOR_BUFSIZE,
4459					initial_descriptor_timeout);
4460				switch (buf->bMaxPacketSize0) {
4461				case 8: case 16: case 32: case 64: case 255:
4462					if (buf->bDescriptorType ==
4463							USB_DT_DEVICE) {
4464						r = 0;
4465						break;
4466					}
4467					/* FALL THROUGH */
4468				default:
4469					if (r == 0)
4470						r = -EPROTO;
4471					break;
4472				}
4473				/*
4474				 * Some devices time out if they are powered on
4475				 * when already connected. They need a second
4476				 * reset. But only on the first attempt,
4477				 * lest we get into a time out/reset loop
4478				 */
4479				if (r == 0  || (r == -ETIMEDOUT && retries == 0))
4480					break;
4481			}
4482			udev->descriptor.bMaxPacketSize0 =
4483					buf->bMaxPacketSize0;
4484			kfree(buf);
4485
4486			retval = hub_port_reset(hub, port1, udev, delay, false);
4487			if (retval < 0)		/* error or disconnect */
4488				goto fail;
4489			if (oldspeed != udev->speed) {
4490				dev_dbg(&udev->dev,
4491					"device reset changed speed!\n");
4492				retval = -ENODEV;
4493				goto fail;
4494			}
4495			if (r) {
4496				if (r != -ENODEV)
4497					dev_err(&udev->dev, "device descriptor read/64, error %d\n",
4498							r);
4499				retval = -EMSGSIZE;
4500				continue;
4501			}
4502#undef GET_DESCRIPTOR_BUFSIZE
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4503		}
4504
4505		/*
4506		 * If device is WUSB, we already assigned an
4507		 * unauthorized address in the Connect Ack sequence;
4508		 * authorization will assign the final address.
4509		 */
4510		if (udev->wusb == 0) {
4511			for (operations = 0; operations < SET_ADDRESS_TRIES; ++operations) {
4512				retval = hub_set_address(udev, devnum);
4513				if (retval >= 0)
4514					break;
4515				msleep(200);
4516			}
4517			if (retval < 0) {
4518				if (retval != -ENODEV)
4519					dev_err(&udev->dev, "device not accepting address %d, error %d\n",
4520							devnum, retval);
4521				goto fail;
4522			}
4523			if (udev->speed >= USB_SPEED_SUPER) {
4524				devnum = udev->devnum;
4525				dev_info(&udev->dev,
4526						"%s SuperSpeed%s USB device number %d using %s\n",
4527						(udev->config) ? "reset" : "new",
4528					 (udev->speed == USB_SPEED_SUPER_PLUS) ? "Plus" : "",
4529						devnum, udev->bus->controller->driver->name);
4530			}
4531
4532			/* cope with hardware quirkiness:
4533			 *  - let SET_ADDRESS settle, some device hardware wants it
4534			 *  - read ep0 maxpacket even for high and low speed,
4535			 */
4536			msleep(10);
4537			/* use_new_scheme() checks the speed which may have
4538			 * changed since the initial look so we cache the result
4539			 * in did_new_scheme
4540			 */
4541			if (did_new_scheme)
4542				break;
4543		}
4544
4545		retval = usb_get_device_descriptor(udev, 8);
4546		if (retval < 8) {
 
4547			if (retval != -ENODEV)
4548				dev_err(&udev->dev,
4549					"device descriptor read/8, error %d\n",
4550					retval);
4551			if (retval >= 0)
4552				retval = -EMSGSIZE;
4553		} else {
4554			retval = 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4555			break;
4556		}
4557	}
4558	if (retval)
4559		goto fail;
4560
4561	/*
4562	 * Some superspeed devices have finished the link training process
4563	 * and attached to a superspeed hub port, but the device descriptor
4564	 * got from those devices show they aren't superspeed devices. Warm
4565	 * reset the port attached by the devices can fix them.
4566	 */
4567	if ((udev->speed >= USB_SPEED_SUPER) &&
4568			(le16_to_cpu(udev->descriptor.bcdUSB) < 0x0300)) {
4569		dev_err(&udev->dev, "got a wrong device descriptor, "
4570				"warm reset device\n");
4571		hub_port_reset(hub, port1, udev,
4572				HUB_BH_RESET_TIME, true);
4573		retval = -EINVAL;
4574		goto fail;
4575	}
4576
4577	if (udev->descriptor.bMaxPacketSize0 == 0xff ||
4578			udev->speed >= USB_SPEED_SUPER)
4579		i = 512;
4580	else
4581		i = udev->descriptor.bMaxPacketSize0;
4582	if (usb_endpoint_maxp(&udev->ep0.desc) != i) {
4583		if (udev->speed == USB_SPEED_LOW ||
4584				!(i == 8 || i == 16 || i == 32 || i == 64)) {
4585			dev_err(&udev->dev, "Invalid ep0 maxpacket: %d\n", i);
4586			retval = -EMSGSIZE;
4587			goto fail;
4588		}
4589		if (udev->speed == USB_SPEED_FULL)
4590			dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
4591		else
4592			dev_warn(&udev->dev, "Using ep0 maxpacket: %d\n", i);
4593		udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
4594		usb_ep0_reinit(udev);
 
 
 
 
 
4595	}
4596
4597	retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
4598	if (retval < (signed)sizeof(udev->descriptor)) {
 
4599		if (retval != -ENODEV)
4600			dev_err(&udev->dev, "device descriptor read/all, error %d\n",
4601					retval);
4602		if (retval >= 0)
4603			retval = -ENOMSG;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4604		goto fail;
4605	}
4606
4607	usb_detect_quirks(udev);
4608
4609	if (udev->wusb == 0 && le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0201) {
4610		retval = usb_get_bos_descriptor(udev);
4611		if (!retval) {
4612			udev->lpm_capable = usb_device_supports_lpm(udev);
 
4613			usb_set_lpm_parameters(udev);
 
4614		}
4615	}
4616
4617	retval = 0;
4618	/* notify HCD that we have a device connected and addressed */
4619	if (hcd->driver->update_device)
4620		hcd->driver->update_device(hcd, udev);
4621	hub_set_initial_usb2_lpm_policy(udev);
4622fail:
4623	if (retval) {
4624		hub_port_disable(hub, port1, 0);
4625		update_devnum(udev, devnum);	/* for disconnect processing */
4626	}
4627	mutex_unlock(hcd->address0_mutex);
4628	return retval;
4629}
4630
4631static void
4632check_highspeed(struct usb_hub *hub, struct usb_device *udev, int port1)
4633{
4634	struct usb_qualifier_descriptor	*qual;
4635	int				status;
4636
4637	if (udev->quirks & USB_QUIRK_DEVICE_QUALIFIER)
4638		return;
4639
4640	qual = kmalloc(sizeof *qual, GFP_KERNEL);
4641	if (qual == NULL)
4642		return;
4643
4644	status = usb_get_descriptor(udev, USB_DT_DEVICE_QUALIFIER, 0,
4645			qual, sizeof *qual);
4646	if (status == sizeof *qual) {
4647		dev_info(&udev->dev, "not running at top speed; "
4648			"connect to a high speed hub\n");
4649		/* hub LEDs are probably harder to miss than syslog */
4650		if (hub->has_indicators) {
4651			hub->indicator[port1-1] = INDICATOR_GREEN_BLINK;
4652			queue_delayed_work(system_power_efficient_wq,
4653					&hub->leds, 0);
4654		}
4655	}
4656	kfree(qual);
4657}
4658
4659static unsigned
4660hub_power_remaining(struct usb_hub *hub)
4661{
4662	struct usb_device *hdev = hub->hdev;
4663	int remaining;
4664	int port1;
4665
4666	if (!hub->limited_power)
4667		return 0;
4668
4669	remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;
4670	for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
4671		struct usb_port *port_dev = hub->ports[port1 - 1];
4672		struct usb_device *udev = port_dev->child;
4673		unsigned unit_load;
4674		int delta;
4675
4676		if (!udev)
4677			continue;
4678		if (hub_is_superspeed(udev))
4679			unit_load = 150;
4680		else
4681			unit_load = 100;
4682
4683		/*
4684		 * Unconfigured devices may not use more than one unit load,
4685		 * or 8mA for OTG ports
4686		 */
4687		if (udev->actconfig)
4688			delta = usb_get_max_power(udev, udev->actconfig);
4689		else if (port1 != udev->bus->otg_port || hdev->parent)
4690			delta = unit_load;
4691		else
4692			delta = 8;
4693		if (delta > hub->mA_per_port)
4694			dev_warn(&port_dev->dev, "%dmA is over %umA budget!\n",
4695					delta, hub->mA_per_port);
4696		remaining -= delta;
4697	}
4698	if (remaining < 0) {
4699		dev_warn(hub->intfdev, "%dmA over power budget!\n",
4700			-remaining);
4701		remaining = 0;
4702	}
4703	return remaining;
4704}
4705
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4706static void hub_port_connect(struct usb_hub *hub, int port1, u16 portstatus,
4707		u16 portchange)
4708{
4709	int status, i;
 
4710	unsigned unit_load;
4711	struct usb_device *hdev = hub->hdev;
4712	struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
4713	struct usb_port *port_dev = hub->ports[port1 - 1];
4714	struct usb_device *udev = port_dev->child;
4715	static int unreliable_port = -1;
 
4716
4717	/* Disconnect any existing devices under this port */
4718	if (udev) {
4719		if (hcd->usb_phy && !hdev->parent)
4720			usb_phy_notify_disconnect(hcd->usb_phy, udev->speed);
4721		usb_disconnect(&port_dev->child);
4722	}
4723
4724	/* We can forget about a "removed" device when there's a physical
4725	 * disconnect or the connect status changes.
4726	 */
4727	if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
4728			(portchange & USB_PORT_STAT_C_CONNECTION))
4729		clear_bit(port1, hub->removed_bits);
4730
4731	if (portchange & (USB_PORT_STAT_C_CONNECTION |
4732				USB_PORT_STAT_C_ENABLE)) {
4733		status = hub_port_debounce_be_stable(hub, port1);
4734		if (status < 0) {
4735			if (status != -ENODEV &&
4736				port1 != unreliable_port &&
4737				printk_ratelimit())
4738				dev_err(&port_dev->dev, "connect-debounce failed\n");
4739			portstatus &= ~USB_PORT_STAT_CONNECTION;
4740			unreliable_port = port1;
4741		} else {
4742			portstatus = status;
4743		}
4744	}
4745
4746	/* Return now if debouncing failed or nothing is connected or
4747	 * the device was "removed".
4748	 */
4749	if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
4750			test_bit(port1, hub->removed_bits)) {
4751
4752		/*
4753		 * maybe switch power back on (e.g. root hub was reset)
4754		 * but only if the port isn't owned by someone else.
4755		 */
4756		if (hub_is_port_power_switchable(hub)
4757				&& !port_is_power_on(hub, portstatus)
4758				&& !port_dev->port_owner)
4759			set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
4760
4761		if (portstatus & USB_PORT_STAT_ENABLE)
4762			goto done;
4763		return;
4764	}
4765	if (hub_is_superspeed(hub->hdev))
4766		unit_load = 150;
4767	else
4768		unit_load = 100;
4769
4770	status = 0;
4771	for (i = 0; i < SET_CONFIG_TRIES; i++) {
4772
 
 
 
 
 
 
 
 
 
4773		/* reallocate for each attempt, since references
4774		 * to the previous one can escape in various ways
4775		 */
4776		udev = usb_alloc_dev(hdev, hdev->bus, port1);
4777		if (!udev) {
4778			dev_err(&port_dev->dev,
4779					"couldn't allocate usb_device\n");
 
 
4780			goto done;
4781		}
4782
4783		usb_set_device_state(udev, USB_STATE_POWERED);
4784		udev->bus_mA = hub->mA_per_port;
4785		udev->level = hdev->level + 1;
4786		udev->wusb = hub_is_wusb(hub);
4787
4788		/* Devices connected to SuperSpeed hubs are USB 3.0 or later */
4789		if (hub_is_superspeed(hub->hdev))
4790			udev->speed = USB_SPEED_SUPER;
4791		else
4792			udev->speed = USB_SPEED_UNKNOWN;
4793
4794		choose_devnum(udev);
4795		if (udev->devnum <= 0) {
4796			status = -ENOTCONN;	/* Don't retry */
4797			goto loop;
4798		}
4799
4800		/* reset (non-USB 3.0 devices) and get descriptor */
4801		usb_lock_port(port_dev);
4802		status = hub_port_init(hub, udev, port1, i);
4803		usb_unlock_port(port_dev);
4804		if (status < 0)
4805			goto loop;
4806
 
 
 
 
4807		if (udev->quirks & USB_QUIRK_DELAY_INIT)
4808			msleep(1000);
4809
4810		/* consecutive bus-powered hubs aren't reliable; they can
4811		 * violate the voltage drop budget.  if the new child has
4812		 * a "powered" LED, users should notice we didn't enable it
4813		 * (without reading syslog), even without per-port LEDs
4814		 * on the parent.
4815		 */
4816		if (udev->descriptor.bDeviceClass == USB_CLASS_HUB
4817				&& udev->bus_mA <= unit_load) {
4818			u16	devstat;
4819
4820			status = usb_get_status(udev, USB_RECIP_DEVICE, 0,
4821					&devstat);
4822			if (status) {
4823				dev_dbg(&udev->dev, "get status %d ?\n", status);
4824				goto loop_disable;
4825			}
4826			if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
4827				dev_err(&udev->dev,
4828					"can't connect bus-powered hub "
4829					"to this port\n");
4830				if (hub->has_indicators) {
4831					hub->indicator[port1-1] =
4832						INDICATOR_AMBER_BLINK;
4833					queue_delayed_work(
4834						system_power_efficient_wq,
4835						&hub->leds, 0);
4836				}
4837				status = -ENOTCONN;	/* Don't retry */
4838				goto loop_disable;
4839			}
4840		}
4841
4842		/* check for devices running slower than they could */
4843		if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200
4844				&& udev->speed == USB_SPEED_FULL
4845				&& highspeed_hubs != 0)
4846			check_highspeed(hub, udev, port1);
4847
4848		/* Store the parent's children[] pointer.  At this point
4849		 * udev becomes globally accessible, although presumably
4850		 * no one will look at it until hdev is unlocked.
4851		 */
4852		status = 0;
4853
4854		mutex_lock(&usb_port_peer_mutex);
4855
4856		/* We mustn't add new devices if the parent hub has
4857		 * been disconnected; we would race with the
4858		 * recursively_mark_NOTATTACHED() routine.
4859		 */
4860		spin_lock_irq(&device_state_lock);
4861		if (hdev->state == USB_STATE_NOTATTACHED)
4862			status = -ENOTCONN;
4863		else
4864			port_dev->child = udev;
4865		spin_unlock_irq(&device_state_lock);
4866		mutex_unlock(&usb_port_peer_mutex);
4867
4868		/* Run it through the hoops (find a driver, etc) */
4869		if (!status) {
4870			status = usb_new_device(udev);
4871			if (status) {
4872				mutex_lock(&usb_port_peer_mutex);
4873				spin_lock_irq(&device_state_lock);
4874				port_dev->child = NULL;
4875				spin_unlock_irq(&device_state_lock);
4876				mutex_unlock(&usb_port_peer_mutex);
4877			} else {
4878				if (hcd->usb_phy && !hdev->parent)
4879					usb_phy_notify_connect(hcd->usb_phy,
4880							udev->speed);
4881			}
4882		}
4883
4884		if (status)
4885			goto loop_disable;
4886
4887		status = hub_power_remaining(hub);
4888		if (status)
4889			dev_dbg(hub->intfdev, "%dmA power budget left\n", status);
4890
4891		return;
4892
4893loop_disable:
4894		hub_port_disable(hub, port1, 1);
4895loop:
4896		usb_ep0_reinit(udev);
4897		release_devnum(udev);
4898		hub_free_dev(udev);
 
 
 
 
4899		usb_put_dev(udev);
4900		if ((status == -ENOTCONN) || (status == -ENOTSUPP))
4901			break;
 
 
 
 
 
 
 
 
 
4902	}
4903	if (hub->hdev->parent ||
4904			!hcd->driver->port_handed_over ||
4905			!(hcd->driver->port_handed_over)(hcd, port1)) {
4906		if (status != -ENOTCONN && status != -ENODEV)
4907			dev_err(&port_dev->dev,
4908					"unable to enumerate USB device\n");
4909	}
4910
4911done:
4912	hub_port_disable(hub, port1, 1);
4913	if (hcd->driver->relinquish_port && !hub->hdev->parent)
4914		hcd->driver->relinquish_port(hcd, port1);
4915
 
4916}
4917
4918/* Handle physical or logical connection change events.
4919 * This routine is called when:
4920 *	a port connection-change occurs;
4921 *	a port enable-change occurs (often caused by EMI);
4922 *	usb_reset_and_verify_device() encounters changed descriptors (as from
4923 *		a firmware download)
4924 * caller already locked the hub
4925 */
4926static void hub_port_connect_change(struct usb_hub *hub, int port1,
4927					u16 portstatus, u16 portchange)
4928		__must_hold(&port_dev->status_lock)
4929{
4930	struct usb_port *port_dev = hub->ports[port1 - 1];
4931	struct usb_device *udev = port_dev->child;
 
4932	int status = -ENODEV;
4933
4934	dev_dbg(&port_dev->dev, "status %04x, change %04x, %s\n", portstatus,
4935			portchange, portspeed(hub, portstatus));
4936
4937	if (hub->has_indicators) {
4938		set_port_led(hub, port1, HUB_LED_AUTO);
4939		hub->indicator[port1-1] = INDICATOR_AUTO;
4940	}
4941
4942#ifdef	CONFIG_USB_OTG
4943	/* during HNP, don't repeat the debounce */
4944	if (hub->hdev->bus->is_b_host)
4945		portchange &= ~(USB_PORT_STAT_C_CONNECTION |
4946				USB_PORT_STAT_C_ENABLE);
4947#endif
4948
4949	/* Try to resuscitate an existing device */
4950	if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
4951			udev->state != USB_STATE_NOTATTACHED) {
4952		if (portstatus & USB_PORT_STAT_ENABLE) {
4953			status = 0;		/* Nothing to do */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4954#ifdef CONFIG_PM
4955		} else if (udev->state == USB_STATE_SUSPENDED &&
4956				udev->persist_enabled) {
4957			/* For a suspended device, treat this as a
4958			 * remote wakeup event.
4959			 */
4960			usb_unlock_port(port_dev);
4961			status = usb_remote_wakeup(udev);
4962			usb_lock_port(port_dev);
4963#endif
4964		} else {
4965			/* Don't resuscitate */;
4966		}
4967	}
4968	clear_bit(port1, hub->change_bits);
4969
4970	/* successfully revalidated the connection */
4971	if (status == 0)
4972		return;
4973
4974	usb_unlock_port(port_dev);
4975	hub_port_connect(hub, port1, portstatus, portchange);
4976	usb_lock_port(port_dev);
4977}
4978
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4979static void port_event(struct usb_hub *hub, int port1)
4980		__must_hold(&port_dev->status_lock)
4981{
4982	int connect_change;
4983	struct usb_port *port_dev = hub->ports[port1 - 1];
4984	struct usb_device *udev = port_dev->child;
4985	struct usb_device *hdev = hub->hdev;
4986	u16 portstatus, portchange;
 
4987
4988	connect_change = test_bit(port1, hub->change_bits);
4989	clear_bit(port1, hub->event_bits);
4990	clear_bit(port1, hub->wakeup_bits);
4991
4992	if (hub_port_status(hub, port1, &portstatus, &portchange) < 0)
4993		return;
4994
4995	if (portchange & USB_PORT_STAT_C_CONNECTION) {
4996		usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION);
4997		connect_change = 1;
4998	}
4999
5000	if (portchange & USB_PORT_STAT_C_ENABLE) {
5001		if (!connect_change)
5002			dev_dbg(&port_dev->dev, "enable change, status %08x\n",
5003					portstatus);
5004		usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);
5005
5006		/*
5007		 * EM interference sometimes causes badly shielded USB devices
5008		 * to be shutdown by the hub, this hack enables them again.
5009		 * Works at least with mouse driver.
5010		 */
5011		if (!(portstatus & USB_PORT_STAT_ENABLE)
5012		    && !connect_change && udev) {
5013			dev_err(&port_dev->dev, "disabled by hub (EMI?), re-enabling...\n");
5014			connect_change = 1;
5015		}
5016	}
5017
5018	if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
5019		u16 status = 0, unused;
 
 
5020
5021		dev_dbg(&port_dev->dev, "over-current change\n");
 
5022		usb_clear_port_feature(hdev, port1,
5023				USB_PORT_FEAT_C_OVER_CURRENT);
5024		msleep(100);	/* Cool down */
5025		hub_power_on(hub, true);
5026		hub_port_status(hub, port1, &status, &unused);
5027		if (status & USB_PORT_STAT_OVERCURRENT)
5028			dev_err(&port_dev->dev, "over-current condition\n");
5029	}
5030
5031	if (portchange & USB_PORT_STAT_C_RESET) {
5032		dev_dbg(&port_dev->dev, "reset change\n");
5033		usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_RESET);
5034	}
5035	if ((portchange & USB_PORT_STAT_C_BH_RESET)
5036	    && hub_is_superspeed(hdev)) {
5037		dev_dbg(&port_dev->dev, "warm reset change\n");
5038		usb_clear_port_feature(hdev, port1,
5039				USB_PORT_FEAT_C_BH_PORT_RESET);
5040	}
5041	if (portchange & USB_PORT_STAT_C_LINK_STATE) {
5042		dev_dbg(&port_dev->dev, "link state change\n");
5043		usb_clear_port_feature(hdev, port1,
5044				USB_PORT_FEAT_C_PORT_LINK_STATE);
5045	}
5046	if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
5047		dev_warn(&port_dev->dev, "config error\n");
5048		usb_clear_port_feature(hdev, port1,
5049				USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
5050	}
5051
5052	/* skip port actions that require the port to be powered on */
5053	if (!pm_runtime_active(&port_dev->dev))
5054		return;
5055
 
 
 
 
5056	if (hub_handle_remote_wakeup(hub, port1, portstatus, portchange))
5057		connect_change = 1;
5058
5059	/*
5060	 * Warm reset a USB3 protocol port if it's in
5061	 * SS.Inactive state.
 
 
5062	 */
5063	if (hub_port_warm_reset_required(hub, port1, portstatus)) {
5064		dev_dbg(&port_dev->dev, "do warm reset\n");
5065		if (!udev || !(portstatus & USB_PORT_STAT_CONNECTION)
 
 
 
 
 
 
5066				|| udev->state == USB_STATE_NOTATTACHED) {
 
5067			if (hub_port_reset(hub, port1, NULL,
5068					HUB_BH_RESET_TIME, true) < 0)
5069				hub_port_disable(hub, port1, 1);
5070		} else {
 
5071			usb_unlock_port(port_dev);
5072			usb_lock_device(udev);
5073			usb_reset_device(udev);
5074			usb_unlock_device(udev);
5075			usb_lock_port(port_dev);
5076			connect_change = 0;
5077		}
 
5078	}
5079
5080	if (connect_change)
5081		hub_port_connect_change(hub, port1, portstatus, portchange);
5082}
5083
5084static void hub_event(struct work_struct *work)
5085{
5086	struct usb_device *hdev;
5087	struct usb_interface *intf;
5088	struct usb_hub *hub;
5089	struct device *hub_dev;
5090	u16 hubstatus;
5091	u16 hubchange;
5092	int i, ret;
5093
5094	hub = container_of(work, struct usb_hub, events);
5095	hdev = hub->hdev;
5096	hub_dev = hub->intfdev;
5097	intf = to_usb_interface(hub_dev);
5098
 
 
5099	dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
5100			hdev->state, hdev->maxchild,
5101			/* NOTE: expects max 15 ports... */
5102			(u16) hub->change_bits[0],
5103			(u16) hub->event_bits[0]);
5104
5105	/* Lock the device, then check to see if we were
5106	 * disconnected while waiting for the lock to succeed. */
5107	usb_lock_device(hdev);
5108	if (unlikely(hub->disconnected))
5109		goto out_hdev_lock;
5110
5111	/* If the hub has died, clean up after it */
5112	if (hdev->state == USB_STATE_NOTATTACHED) {
5113		hub->error = -ENODEV;
5114		hub_quiesce(hub, HUB_DISCONNECT);
5115		goto out_hdev_lock;
5116	}
5117
5118	/* Autoresume */
5119	ret = usb_autopm_get_interface(intf);
5120	if (ret) {
5121		dev_dbg(hub_dev, "Can't autoresume: %d\n", ret);
5122		goto out_hdev_lock;
5123	}
5124
5125	/* If this is an inactive hub, do nothing */
5126	if (hub->quiescing)
5127		goto out_autopm;
5128
5129	if (hub->error) {
5130		dev_dbg(hub_dev, "resetting for error %d\n", hub->error);
5131
5132		ret = usb_reset_device(hdev);
5133		if (ret) {
5134			dev_dbg(hub_dev, "error resetting hub: %d\n", ret);
5135			goto out_autopm;
5136		}
5137
5138		hub->nerrors = 0;
5139		hub->error = 0;
5140	}
5141
5142	/* deal with port status changes */
5143	for (i = 1; i <= hdev->maxchild; i++) {
5144		struct usb_port *port_dev = hub->ports[i - 1];
5145
5146		if (test_bit(i, hub->event_bits)
5147				|| test_bit(i, hub->change_bits)
5148				|| test_bit(i, hub->wakeup_bits)) {
5149			/*
5150			 * The get_noresume and barrier ensure that if
5151			 * the port was in the process of resuming, we
5152			 * flush that work and keep the port active for
5153			 * the duration of the port_event().  However,
5154			 * if the port is runtime pm suspended
5155			 * (powered-off), we leave it in that state, run
5156			 * an abbreviated port_event(), and move on.
5157			 */
5158			pm_runtime_get_noresume(&port_dev->dev);
5159			pm_runtime_barrier(&port_dev->dev);
5160			usb_lock_port(port_dev);
5161			port_event(hub, i);
5162			usb_unlock_port(port_dev);
5163			pm_runtime_put_sync(&port_dev->dev);
5164		}
5165	}
5166
5167	/* deal with hub status changes */
5168	if (test_and_clear_bit(0, hub->event_bits) == 0)
5169		;	/* do nothing */
5170	else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
5171		dev_err(hub_dev, "get_hub_status failed\n");
5172	else {
5173		if (hubchange & HUB_CHANGE_LOCAL_POWER) {
5174			dev_dbg(hub_dev, "power change\n");
5175			clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
5176			if (hubstatus & HUB_STATUS_LOCAL_POWER)
5177				/* FIXME: Is this always true? */
5178				hub->limited_power = 1;
5179			else
5180				hub->limited_power = 0;
5181		}
5182		if (hubchange & HUB_CHANGE_OVERCURRENT) {
5183			u16 status = 0;
5184			u16 unused;
5185
5186			dev_dbg(hub_dev, "over-current change\n");
5187			clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
5188			msleep(500);	/* Cool down */
5189			hub_power_on(hub, true);
5190			hub_hub_status(hub, &status, &unused);
5191			if (status & HUB_STATUS_OVERCURRENT)
5192				dev_err(hub_dev, "over-current condition\n");
5193		}
5194	}
5195
5196out_autopm:
5197	/* Balance the usb_autopm_get_interface() above */
5198	usb_autopm_put_interface_no_suspend(intf);
5199out_hdev_lock:
5200	usb_unlock_device(hdev);
5201
5202	/* Balance the stuff in kick_hub_wq() and allow autosuspend */
5203	usb_autopm_put_interface(intf);
5204	kref_put(&hub->kref, hub_release);
 
 
5205}
5206
5207static const struct usb_device_id hub_id_table[] = {
5208    { .match_flags = USB_DEVICE_ID_MATCH_VENDOR
 
 
 
 
 
 
 
 
 
 
 
 
5209			| USB_DEVICE_ID_MATCH_INT_CLASS,
5210      .idVendor = USB_VENDOR_GENESYS_LOGIC,
5211      .bInterfaceClass = USB_CLASS_HUB,
5212      .driver_info = HUB_QUIRK_CHECK_PORT_AUTOSUSPEND},
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5213    { .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
5214      .bDeviceClass = USB_CLASS_HUB},
5215    { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
5216      .bInterfaceClass = USB_CLASS_HUB},
5217    { }						/* Terminating entry */
5218};
5219
5220MODULE_DEVICE_TABLE(usb, hub_id_table);
5221
5222static struct usb_driver hub_driver = {
5223	.name =		"hub",
5224	.probe =	hub_probe,
5225	.disconnect =	hub_disconnect,
5226	.suspend =	hub_suspend,
5227	.resume =	hub_resume,
5228	.reset_resume =	hub_reset_resume,
5229	.pre_reset =	hub_pre_reset,
5230	.post_reset =	hub_post_reset,
5231	.unlocked_ioctl = hub_ioctl,
5232	.id_table =	hub_id_table,
5233	.supports_autosuspend =	1,
5234};
5235
5236int usb_hub_init(void)
5237{
5238	if (usb_register(&hub_driver) < 0) {
5239		printk(KERN_ERR "%s: can't register hub driver\n",
5240			usbcore_name);
5241		return -1;
5242	}
5243
5244	/*
5245	 * The workqueue needs to be freezable to avoid interfering with
5246	 * USB-PERSIST port handover. Otherwise it might see that a full-speed
5247	 * device was gone before the EHCI controller had handed its port
5248	 * over to the companion full-speed controller.
5249	 */
5250	hub_wq = alloc_workqueue("usb_hub_wq", WQ_FREEZABLE, 0);
5251	if (hub_wq)
5252		return 0;
5253
5254	/* Fall through if kernel_thread failed */
5255	usb_deregister(&hub_driver);
5256	pr_err("%s: can't allocate workqueue for usb hub\n", usbcore_name);
5257
5258	return -1;
5259}
5260
5261void usb_hub_cleanup(void)
5262{
5263	destroy_workqueue(hub_wq);
5264
5265	/*
5266	 * Hub resources are freed for us by usb_deregister. It calls
5267	 * usb_driver_purge on every device which in turn calls that
5268	 * devices disconnect function if it is using this driver.
5269	 * The hub_disconnect function takes care of releasing the
5270	 * individual hub resources. -greg
5271	 */
5272	usb_deregister(&hub_driver);
5273} /* usb_hub_cleanup() */
5274
5275static int descriptors_changed(struct usb_device *udev,
5276		struct usb_device_descriptor *old_device_descriptor,
5277		struct usb_host_bos *old_bos)
5278{
5279	int		changed = 0;
5280	unsigned	index;
5281	unsigned	serial_len = 0;
5282	unsigned	len;
5283	unsigned	old_length;
5284	int		length;
5285	char		*buf;
5286
5287	if (memcmp(&udev->descriptor, old_device_descriptor,
5288			sizeof(*old_device_descriptor)) != 0)
5289		return 1;
5290
5291	if ((old_bos && !udev->bos) || (!old_bos && udev->bos))
5292		return 1;
5293	if (udev->bos) {
5294		len = le16_to_cpu(udev->bos->desc->wTotalLength);
5295		if (len != le16_to_cpu(old_bos->desc->wTotalLength))
5296			return 1;
5297		if (memcmp(udev->bos->desc, old_bos->desc, len))
5298			return 1;
5299	}
5300
5301	/* Since the idVendor, idProduct, and bcdDevice values in the
5302	 * device descriptor haven't changed, we will assume the
5303	 * Manufacturer and Product strings haven't changed either.
5304	 * But the SerialNumber string could be different (e.g., a
5305	 * different flash card of the same brand).
5306	 */
5307	if (udev->serial)
5308		serial_len = strlen(udev->serial) + 1;
5309
5310	len = serial_len;
5311	for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
5312		old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
5313		len = max(len, old_length);
5314	}
5315
5316	buf = kmalloc(len, GFP_NOIO);
5317	if (!buf)
5318		/* assume the worst */
5319		return 1;
5320
5321	for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
5322		old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
5323		length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf,
5324				old_length);
5325		if (length != old_length) {
5326			dev_dbg(&udev->dev, "config index %d, error %d\n",
5327					index, length);
5328			changed = 1;
5329			break;
5330		}
5331		if (memcmp(buf, udev->rawdescriptors[index], old_length)
5332				!= 0) {
5333			dev_dbg(&udev->dev, "config index %d changed (#%d)\n",
5334				index,
5335				((struct usb_config_descriptor *) buf)->
5336					bConfigurationValue);
5337			changed = 1;
5338			break;
5339		}
5340	}
5341
5342	if (!changed && serial_len) {
5343		length = usb_string(udev, udev->descriptor.iSerialNumber,
5344				buf, serial_len);
5345		if (length + 1 != serial_len) {
5346			dev_dbg(&udev->dev, "serial string error %d\n",
5347					length);
5348			changed = 1;
5349		} else if (memcmp(buf, udev->serial, length) != 0) {
5350			dev_dbg(&udev->dev, "serial string changed\n");
5351			changed = 1;
5352		}
5353	}
5354
5355	kfree(buf);
5356	return changed;
5357}
5358
5359/**
5360 * usb_reset_and_verify_device - perform a USB port reset to reinitialize a device
5361 * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
5362 *
5363 * WARNING - don't use this routine to reset a composite device
5364 * (one with multiple interfaces owned by separate drivers)!
5365 * Use usb_reset_device() instead.
5366 *
5367 * Do a port reset, reassign the device's address, and establish its
5368 * former operating configuration.  If the reset fails, or the device's
5369 * descriptors change from their values before the reset, or the original
5370 * configuration and altsettings cannot be restored, a flag will be set
5371 * telling hub_wq to pretend the device has been disconnected and then
5372 * re-connected.  All drivers will be unbound, and the device will be
5373 * re-enumerated and probed all over again.
5374 *
5375 * Return: 0 if the reset succeeded, -ENODEV if the device has been
5376 * flagged for logical disconnection, or some other negative error code
5377 * if the reset wasn't even attempted.
5378 *
5379 * Note:
5380 * The caller must own the device lock and the port lock, the latter is
5381 * taken by usb_reset_device().  For example, it's safe to use
5382 * usb_reset_device() from a driver probe() routine after downloading
5383 * new firmware.  For calls that might not occur during probe(), drivers
5384 * should lock the device using usb_lock_device_for_reset().
5385 *
5386 * Locking exception: This routine may also be called from within an
5387 * autoresume handler.  Such usage won't conflict with other tasks
5388 * holding the device lock because these tasks should always call
5389 * usb_autopm_resume_device(), thereby preventing any unwanted
5390 * autoresume.  The autoresume handler is expected to have already
5391 * acquired the port lock before calling this routine.
5392 */
5393static int usb_reset_and_verify_device(struct usb_device *udev)
5394{
5395	struct usb_device		*parent_hdev = udev->parent;
5396	struct usb_hub			*parent_hub;
5397	struct usb_hcd			*hcd = bus_to_hcd(udev->bus);
5398	struct usb_device_descriptor	descriptor = udev->descriptor;
5399	struct usb_host_bos		*bos;
5400	int				i, j, ret = 0;
5401	int				port1 = udev->portnum;
5402
5403	if (udev->state == USB_STATE_NOTATTACHED ||
5404			udev->state == USB_STATE_SUSPENDED) {
5405		dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
5406				udev->state);
5407		return -EINVAL;
5408	}
5409
5410	if (!parent_hdev)
5411		return -EISDIR;
5412
5413	parent_hub = usb_hub_to_struct_hub(parent_hdev);
5414
5415	/* Disable USB2 hardware LPM.
5416	 * It will be re-enabled by the enumeration process.
5417	 */
5418	if (udev->usb2_hw_lpm_enabled == 1)
5419		usb_set_usb2_hardware_lpm(udev, 0);
5420
5421	/* Disable LPM and LTM while we reset the device and reinstall the alt
5422	 * settings.  Device-initiated LPM settings, and system exit latency
5423	 * settings are cleared when the device is reset, so we have to set
5424	 * them up again.
5425	 */
5426	ret = usb_unlocked_disable_lpm(udev);
5427	if (ret) {
5428		dev_err(&udev->dev, "%s Failed to disable LPM\n.", __func__);
5429		goto re_enumerate_no_bos;
5430	}
5431	ret = usb_disable_ltm(udev);
5432	if (ret) {
5433		dev_err(&udev->dev, "%s Failed to disable LTM\n.",
5434				__func__);
5435		goto re_enumerate_no_bos;
5436	}
5437
5438	bos = udev->bos;
5439	udev->bos = NULL;
5440
5441	for (i = 0; i < SET_CONFIG_TRIES; ++i) {
 
 
 
 
 
 
5442
5443		/* ep0 maxpacket size may change; let the HCD know about it.
5444		 * Other endpoints will be handled by re-enumeration. */
5445		usb_ep0_reinit(udev);
5446		ret = hub_port_init(parent_hub, udev, port1, i);
5447		if (ret >= 0 || ret == -ENOTCONN || ret == -ENODEV)
5448			break;
5449	}
 
5450
5451	if (ret < 0)
5452		goto re_enumerate;
5453
5454	/* Device might have changed firmware (DFU or similar) */
5455	if (descriptors_changed(udev, &descriptor, bos)) {
5456		dev_info(&udev->dev, "device firmware changed\n");
5457		udev->descriptor = descriptor;	/* for disconnect() calls */
5458		goto re_enumerate;
5459	}
5460
5461	/* Restore the device's previous configuration */
5462	if (!udev->actconfig)
5463		goto done;
5464
5465	mutex_lock(hcd->bandwidth_mutex);
5466	ret = usb_hcd_alloc_bandwidth(udev, udev->actconfig, NULL, NULL);
5467	if (ret < 0) {
5468		dev_warn(&udev->dev,
5469				"Busted HC?  Not enough HCD resources for "
5470				"old configuration.\n");
5471		mutex_unlock(hcd->bandwidth_mutex);
5472		goto re_enumerate;
5473	}
5474	ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
5475			USB_REQ_SET_CONFIGURATION, 0,
5476			udev->actconfig->desc.bConfigurationValue, 0,
5477			NULL, 0, USB_CTRL_SET_TIMEOUT);
5478	if (ret < 0) {
5479		dev_err(&udev->dev,
5480			"can't restore configuration #%d (error=%d)\n",
5481			udev->actconfig->desc.bConfigurationValue, ret);
5482		mutex_unlock(hcd->bandwidth_mutex);
5483		goto re_enumerate;
5484	}
5485	mutex_unlock(hcd->bandwidth_mutex);
5486	usb_set_device_state(udev, USB_STATE_CONFIGURED);
5487
5488	/* Put interfaces back into the same altsettings as before.
5489	 * Don't bother to send the Set-Interface request for interfaces
5490	 * that were already in altsetting 0; besides being unnecessary,
5491	 * many devices can't handle it.  Instead just reset the host-side
5492	 * endpoint state.
5493	 */
5494	for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
5495		struct usb_host_config *config = udev->actconfig;
5496		struct usb_interface *intf = config->interface[i];
5497		struct usb_interface_descriptor *desc;
5498
5499		desc = &intf->cur_altsetting->desc;
5500		if (desc->bAlternateSetting == 0) {
5501			usb_disable_interface(udev, intf, true);
5502			usb_enable_interface(udev, intf, true);
5503			ret = 0;
5504		} else {
5505			/* Let the bandwidth allocation function know that this
5506			 * device has been reset, and it will have to use
5507			 * alternate setting 0 as the current alternate setting.
5508			 */
5509			intf->resetting_device = 1;
5510			ret = usb_set_interface(udev, desc->bInterfaceNumber,
5511					desc->bAlternateSetting);
5512			intf->resetting_device = 0;
5513		}
5514		if (ret < 0) {
5515			dev_err(&udev->dev, "failed to restore interface %d "
5516				"altsetting %d (error=%d)\n",
5517				desc->bInterfaceNumber,
5518				desc->bAlternateSetting,
5519				ret);
5520			goto re_enumerate;
5521		}
5522		/* Resetting also frees any allocated streams */
5523		for (j = 0; j < intf->cur_altsetting->desc.bNumEndpoints; j++)
5524			intf->cur_altsetting->endpoint[j].streams = 0;
5525	}
5526
5527done:
5528	/* Now that the alt settings are re-installed, enable LTM and LPM. */
5529	usb_set_usb2_hardware_lpm(udev, 1);
5530	usb_unlocked_enable_lpm(udev);
5531	usb_enable_ltm(udev);
5532	usb_release_bos_descriptor(udev);
5533	udev->bos = bos;
5534	return 0;
5535
5536re_enumerate:
5537	usb_release_bos_descriptor(udev);
5538	udev->bos = bos;
5539re_enumerate_no_bos:
5540	/* LPM state doesn't matter when we're about to destroy the device. */
5541	hub_port_logical_disconnect(parent_hub, port1);
5542	return -ENODEV;
5543}
5544
5545/**
5546 * usb_reset_device - warn interface drivers and perform a USB port reset
5547 * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
5548 *
5549 * Warns all drivers bound to registered interfaces (using their pre_reset
5550 * method), performs the port reset, and then lets the drivers know that
5551 * the reset is over (using their post_reset method).
5552 *
5553 * Return: The same as for usb_reset_and_verify_device().
 
 
 
 
 
5554 *
5555 * Note:
5556 * The caller must own the device lock.  For example, it's safe to use
5557 * this from a driver probe() routine after downloading new firmware.
5558 * For calls that might not occur during probe(), drivers should lock
5559 * the device using usb_lock_device_for_reset().
5560 *
5561 * If an interface is currently being probed or disconnected, we assume
5562 * its driver knows how to handle resets.  For all other interfaces,
5563 * if the driver doesn't have pre_reset and post_reset methods then
5564 * we attempt to unbind it and rebind afterward.
5565 */
5566int usb_reset_device(struct usb_device *udev)
5567{
5568	int ret;
5569	int i;
5570	unsigned int noio_flag;
5571	struct usb_port *port_dev;
5572	struct usb_host_config *config = udev->actconfig;
5573	struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
5574
5575	if (udev->state == USB_STATE_NOTATTACHED ||
5576			udev->state == USB_STATE_SUSPENDED) {
5577		dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
5578				udev->state);
5579		return -EINVAL;
5580	}
5581
5582	if (!udev->parent) {
5583		/* this requires hcd-specific logic; see ohci_restart() */
5584		dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
5585		return -EISDIR;
5586	}
5587
 
 
 
 
5588	port_dev = hub->ports[udev->portnum - 1];
5589
5590	/*
5591	 * Don't allocate memory with GFP_KERNEL in current
5592	 * context to avoid possible deadlock if usb mass
5593	 * storage interface or usbnet interface(iSCSI case)
5594	 * is included in current configuration. The easist
5595	 * approach is to do it for every device reset,
5596	 * because the device 'memalloc_noio' flag may have
5597	 * not been set before reseting the usb device.
5598	 */
5599	noio_flag = memalloc_noio_save();
5600
5601	/* Prevent autosuspend during the reset */
5602	usb_autoresume_device(udev);
5603
5604	if (config) {
5605		for (i = 0; i < config->desc.bNumInterfaces; ++i) {
5606			struct usb_interface *cintf = config->interface[i];
5607			struct usb_driver *drv;
5608			int unbind = 0;
5609
5610			if (cintf->dev.driver) {
5611				drv = to_usb_driver(cintf->dev.driver);
5612				if (drv->pre_reset && drv->post_reset)
5613					unbind = (drv->pre_reset)(cintf);
5614				else if (cintf->condition ==
5615						USB_INTERFACE_BOUND)
5616					unbind = 1;
5617				if (unbind)
5618					usb_forced_unbind_intf(cintf);
5619			}
5620		}
5621	}
5622
5623	usb_lock_port(port_dev);
5624	ret = usb_reset_and_verify_device(udev);
5625	usb_unlock_port(port_dev);
5626
5627	if (config) {
5628		for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
5629			struct usb_interface *cintf = config->interface[i];
5630			struct usb_driver *drv;
5631			int rebind = cintf->needs_binding;
5632
5633			if (!rebind && cintf->dev.driver) {
5634				drv = to_usb_driver(cintf->dev.driver);
5635				if (drv->post_reset)
5636					rebind = (drv->post_reset)(cintf);
5637				else if (cintf->condition ==
5638						USB_INTERFACE_BOUND)
5639					rebind = 1;
5640				if (rebind)
5641					cintf->needs_binding = 1;
5642			}
5643		}
5644		usb_unbind_and_rebind_marked_interfaces(udev);
 
 
 
5645	}
5646
5647	usb_autosuspend_device(udev);
5648	memalloc_noio_restore(noio_flag);
 
5649	return ret;
5650}
5651EXPORT_SYMBOL_GPL(usb_reset_device);
5652
5653
5654/**
5655 * usb_queue_reset_device - Reset a USB device from an atomic context
5656 * @iface: USB interface belonging to the device to reset
5657 *
5658 * This function can be used to reset a USB device from an atomic
5659 * context, where usb_reset_device() won't work (as it blocks).
5660 *
5661 * Doing a reset via this method is functionally equivalent to calling
5662 * usb_reset_device(), except for the fact that it is delayed to a
5663 * workqueue. This means that any drivers bound to other interfaces
5664 * might be unbound, as well as users from usbfs in user space.
5665 *
5666 * Corner cases:
5667 *
5668 * - Scheduling two resets at the same time from two different drivers
5669 *   attached to two different interfaces of the same device is
5670 *   possible; depending on how the driver attached to each interface
5671 *   handles ->pre_reset(), the second reset might happen or not.
5672 *
5673 * - If the reset is delayed so long that the interface is unbound from
5674 *   its driver, the reset will be skipped.
5675 *
5676 * - This function can be called during .probe().  It can also be called
5677 *   during .disconnect(), but doing so is pointless because the reset
5678 *   will not occur.  If you really want to reset the device during
5679 *   .disconnect(), call usb_reset_device() directly -- but watch out
5680 *   for nested unbinding issues!
5681 */
5682void usb_queue_reset_device(struct usb_interface *iface)
5683{
5684	if (schedule_work(&iface->reset_ws))
5685		usb_get_intf(iface);
5686}
5687EXPORT_SYMBOL_GPL(usb_queue_reset_device);
5688
5689/**
5690 * usb_hub_find_child - Get the pointer of child device
5691 * attached to the port which is specified by @port1.
5692 * @hdev: USB device belonging to the usb hub
5693 * @port1: port num to indicate which port the child device
5694 *	is attached to.
5695 *
5696 * USB drivers call this function to get hub's child device
5697 * pointer.
5698 *
5699 * Return: %NULL if input param is invalid and
5700 * child's usb_device pointer if non-NULL.
5701 */
5702struct usb_device *usb_hub_find_child(struct usb_device *hdev,
5703		int port1)
5704{
5705	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
5706
5707	if (port1 < 1 || port1 > hdev->maxchild)
5708		return NULL;
5709	return hub->ports[port1 - 1]->child;
5710}
5711EXPORT_SYMBOL_GPL(usb_hub_find_child);
5712
5713void usb_hub_adjust_deviceremovable(struct usb_device *hdev,
5714		struct usb_hub_descriptor *desc)
5715{
5716	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
5717	enum usb_port_connect_type connect_type;
5718	int i;
5719
5720	if (!hub)
5721		return;
5722
5723	if (!hub_is_superspeed(hdev)) {
5724		for (i = 1; i <= hdev->maxchild; i++) {
5725			struct usb_port *port_dev = hub->ports[i - 1];
5726
5727			connect_type = port_dev->connect_type;
5728			if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
5729				u8 mask = 1 << (i%8);
5730
5731				if (!(desc->u.hs.DeviceRemovable[i/8] & mask)) {
5732					dev_dbg(&port_dev->dev, "DeviceRemovable is changed to 1 according to platform information.\n");
5733					desc->u.hs.DeviceRemovable[i/8]	|= mask;
5734				}
5735			}
5736		}
5737	} else {
5738		u16 port_removable = le16_to_cpu(desc->u.ss.DeviceRemovable);
5739
5740		for (i = 1; i <= hdev->maxchild; i++) {
5741			struct usb_port *port_dev = hub->ports[i - 1];
5742
5743			connect_type = port_dev->connect_type;
5744			if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
5745				u16 mask = 1 << i;
5746
5747				if (!(port_removable & mask)) {
5748					dev_dbg(&port_dev->dev, "DeviceRemovable is changed to 1 according to platform information.\n");
5749					port_removable |= mask;
5750				}
5751			}
5752		}
5753
5754		desc->u.ss.DeviceRemovable = cpu_to_le16(port_removable);
5755	}
5756}
5757
5758#ifdef CONFIG_ACPI
5759/**
5760 * usb_get_hub_port_acpi_handle - Get the usb port's acpi handle
5761 * @hdev: USB device belonging to the usb hub
5762 * @port1: port num of the port
5763 *
5764 * Return: Port's acpi handle if successful, %NULL if params are
5765 * invalid.
5766 */
5767acpi_handle usb_get_hub_port_acpi_handle(struct usb_device *hdev,
5768	int port1)
5769{
5770	struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
5771
5772	if (!hub)
5773		return NULL;
5774
5775	return ACPI_HANDLE(&hub->ports[port1 - 1]->dev);
5776}
5777#endif