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