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