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