whiterose

linux unikernel
Log | Files | Refs | README | LICENSE | git clone https://git.ne02ptzero.me/git/whiterose

hub.c (176217B)


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