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