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