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