1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * Copyright (C) 2001-2004 by David Brownell 4 */ 5 6/* this file is part of ehci-hcd.c */ 7 8/*-------------------------------------------------------------------------*/ 9 10/* 11 * EHCI Root Hub ... the nonsharable stuff 12 * 13 * Registers don't need cpu_to_le32, that happens transparently 14 */ 15 16/*-------------------------------------------------------------------------*/ 17 18#define PORT_WAKE_BITS (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E) 19 20#ifdef CONFIG_PM 21 22static void unlink_empty_async_suspended(struct ehci_hcd *ehci); 23 24static int persist_enabled_on_companion(struct usb_device *udev, void *unused) 25{ 26 return !udev->maxchild && udev->persist_enabled && 27 udev->bus->root_hub->speed < USB_SPEED_HIGH; 28} 29 30/* After a power loss, ports that were owned by the companion must be 31 * reset so that the companion can still own them. 32 */ 33static void ehci_handover_companion_ports(struct ehci_hcd *ehci) 34{ 35 u32 __iomem *reg; 36 u32 status; 37 int port; 38 __le32 buf; 39 struct usb_hcd *hcd = ehci_to_hcd(ehci); 40 41 if (!ehci->owned_ports) 42 return; 43 44 /* 45 * USB 1.1 devices are mostly HIDs, which don't need to persist across 46 * suspends. If we ensure that none of our companion's devices have 47 * persist_enabled (by looking through all USB 1.1 buses in the system), 48 * we can skip this and avoid slowing resume down. Devices without 49 * persist will just get reenumerated shortly after resume anyway. 50 */ 51 if (!usb_for_each_dev(NULL, persist_enabled_on_companion)) 52 return; 53 54 /* Make sure the ports are powered */ 55 port = HCS_N_PORTS(ehci->hcs_params); 56 while (port--) { 57 if (test_bit(port, &ehci->owned_ports)) { 58 reg = &ehci->regs->port_status[port]; 59 status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS; 60 if (!(status & PORT_POWER)) 61 ehci_port_power(ehci, port, true); 62 } 63 } 64 65 /* Give the connections some time to appear */ 66 msleep(20); 67 68 spin_lock_irq(&ehci->lock); 69 port = HCS_N_PORTS(ehci->hcs_params); 70 while (port--) { 71 if (test_bit(port, &ehci->owned_ports)) { 72 reg = &ehci->regs->port_status[port]; 73 status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS; 74 75 /* Port already owned by companion? */ 76 if (status & PORT_OWNER) 77 clear_bit(port, &ehci->owned_ports); 78 else if (test_bit(port, &ehci->companion_ports)) 79 ehci_writel(ehci, status & ~PORT_PE, reg); 80 else { 81 spin_unlock_irq(&ehci->lock); 82 ehci_hub_control(hcd, SetPortFeature, 83 USB_PORT_FEAT_RESET, port + 1, 84 NULL, 0); 85 spin_lock_irq(&ehci->lock); 86 } 87 } 88 } 89 spin_unlock_irq(&ehci->lock); 90 91 if (!ehci->owned_ports) 92 return; 93 msleep(90); /* Wait for resets to complete */ 94 95 spin_lock_irq(&ehci->lock); 96 port = HCS_N_PORTS(ehci->hcs_params); 97 while (port--) { 98 if (test_bit(port, &ehci->owned_ports)) { 99 spin_unlock_irq(&ehci->lock); 100 ehci_hub_control(hcd, GetPortStatus, 101 0, port + 1, 102 (char *) &buf, sizeof(buf)); 103 spin_lock_irq(&ehci->lock); 104 105 /* The companion should now own the port, 106 * but if something went wrong the port must not 107 * remain enabled. 108 */ 109 reg = &ehci->regs->port_status[port]; 110 status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS; 111 if (status & PORT_OWNER) 112 ehci_writel(ehci, status | PORT_CSC, reg); 113 else { 114 ehci_dbg(ehci, "failed handover port %d: %x\n", 115 port + 1, status); 116 ehci_writel(ehci, status & ~PORT_PE, reg); 117 } 118 } 119 } 120 121 ehci->owned_ports = 0; 122 spin_unlock_irq(&ehci->lock); 123} 124 125static int ehci_port_change(struct ehci_hcd *ehci) 126{ 127 int i = HCS_N_PORTS(ehci->hcs_params); 128 129 /* First check if the controller indicates a change event */ 130 131 if (ehci_readl(ehci, &ehci->regs->status) & STS_PCD) 132 return 1; 133 134 /* 135 * Not all controllers appear to update this while going from D3 to D0, 136 * so check the individual port status registers as well 137 */ 138 139 while (i--) 140 if (ehci_readl(ehci, &ehci->regs->port_status[i]) & PORT_CSC) 141 return 1; 142 143 return 0; 144} 145 146void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci, 147 bool suspending, bool do_wakeup) 148{ 149 int port; 150 u32 temp; 151 152 /* If remote wakeup is enabled for the root hub but disabled 153 * for the controller, we must adjust all the port wakeup flags 154 * when the controller is suspended or resumed. In all other 155 * cases they don't need to be changed. 156 */ 157 if (!ehci_to_hcd(ehci)->self.root_hub->do_remote_wakeup || do_wakeup) 158 return; 159 160 spin_lock_irq(&ehci->lock); 161 162 /* clear phy low-power mode before changing wakeup flags */ 163 if (ehci->has_tdi_phy_lpm) { 164 port = HCS_N_PORTS(ehci->hcs_params); 165 while (port--) { 166 u32 __iomem *hostpc_reg = &ehci->regs->hostpc[port]; 167 168 temp = ehci_readl(ehci, hostpc_reg); 169 ehci_writel(ehci, temp & ~HOSTPC_PHCD, hostpc_reg); 170 } 171 spin_unlock_irq(&ehci->lock); 172 msleep(5); 173 spin_lock_irq(&ehci->lock); 174 } 175 176 port = HCS_N_PORTS(ehci->hcs_params); 177 while (port--) { 178 u32 __iomem *reg = &ehci->regs->port_status[port]; 179 u32 t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS; 180 u32 t2 = t1 & ~PORT_WAKE_BITS; 181 182 /* If we are suspending the controller, clear the flags. 183 * If we are resuming the controller, set the wakeup flags. 184 */ 185 if (!suspending) { 186 if (t1 & PORT_CONNECT) 187 t2 |= PORT_WKOC_E | PORT_WKDISC_E; 188 else 189 t2 |= PORT_WKOC_E | PORT_WKCONN_E; 190 } 191 ehci_writel(ehci, t2, reg); 192 } 193 194 /* enter phy low-power mode again */ 195 if (ehci->has_tdi_phy_lpm) { 196 port = HCS_N_PORTS(ehci->hcs_params); 197 while (port--) { 198 u32 __iomem *hostpc_reg = &ehci->regs->hostpc[port]; 199 200 temp = ehci_readl(ehci, hostpc_reg); 201 ehci_writel(ehci, temp | HOSTPC_PHCD, hostpc_reg); 202 } 203 } 204 205 /* Does the root hub have a port wakeup pending? */ 206 if (!suspending && ehci_port_change(ehci)) 207 usb_hcd_resume_root_hub(ehci_to_hcd(ehci)); 208 209 spin_unlock_irq(&ehci->lock); 210} 211EXPORT_SYMBOL_GPL(ehci_adjust_port_wakeup_flags); 212 213static int ehci_bus_suspend (struct usb_hcd *hcd) 214{ 215 struct ehci_hcd *ehci = hcd_to_ehci (hcd); 216 int port; 217 int mask; 218 int changed; 219 bool fs_idle_delay; 220 221 ehci_dbg(ehci, "suspend root hub\n"); 222 223 if (time_before (jiffies, ehci->next_statechange)) 224 msleep(5); 225 226 /* stop the schedules */ 227 ehci_quiesce(ehci); 228 229 spin_lock_irq (&ehci->lock); 230 if (ehci->rh_state < EHCI_RH_RUNNING) 231 goto done; 232 233 /* Once the controller is stopped, port resumes that are already 234 * in progress won't complete. Hence if remote wakeup is enabled 235 * for the root hub and any ports are in the middle of a resume or 236 * remote wakeup, we must fail the suspend. 237 */ 238 if (hcd->self.root_hub->do_remote_wakeup) { 239 if (ehci->resuming_ports) { 240 spin_unlock_irq(&ehci->lock); 241 ehci_dbg(ehci, "suspend failed because a port is resuming\n"); 242 return -EBUSY; 243 } 244 } 245 246 /* Unlike other USB host controller types, EHCI doesn't have 247 * any notion of "global" or bus-wide suspend. The driver has 248 * to manually suspend all the active unsuspended ports, and 249 * then manually resume them in the bus_resume() routine. 250 */ 251 ehci->bus_suspended = 0; 252 ehci->owned_ports = 0; 253 changed = 0; 254 fs_idle_delay = false; 255 port = HCS_N_PORTS(ehci->hcs_params); 256 while (port--) { 257 u32 __iomem *reg = &ehci->regs->port_status [port]; 258 u32 t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS; 259 u32 t2 = t1 & ~PORT_WAKE_BITS; 260 261 /* keep track of which ports we suspend */ 262 if (t1 & PORT_OWNER) 263 set_bit(port, &ehci->owned_ports); 264 else if ((t1 & PORT_PE) && !(t1 & PORT_SUSPEND)) { 265 t2 |= PORT_SUSPEND; 266 set_bit(port, &ehci->bus_suspended); 267 } 268 269 /* enable remote wakeup on all ports, if told to do so */ 270 if (hcd->self.root_hub->do_remote_wakeup) { 271 /* only enable appropriate wake bits, otherwise the 272 * hardware can not go phy low power mode. If a race 273 * condition happens here(connection change during bits 274 * set), the port change detection will finally fix it. 275 */ 276 if (t1 & PORT_CONNECT) 277 t2 |= PORT_WKOC_E | PORT_WKDISC_E; 278 else 279 t2 |= PORT_WKOC_E | PORT_WKCONN_E; 280 } 281 282 if (t1 != t2) { 283 /* 284 * On some controllers, Wake-On-Disconnect will 285 * generate false wakeup signals until the bus 286 * switches over to full-speed idle. For their 287 * sake, add a delay if we need one. 288 */ 289 if ((t2 & PORT_WKDISC_E) && 290 ehci_port_speed(ehci, t2) == 291 USB_PORT_STAT_HIGH_SPEED) 292 fs_idle_delay = true; 293 ehci_writel(ehci, t2, reg); 294 changed = 1; 295 } 296 } 297 spin_unlock_irq(&ehci->lock); 298 299 if (changed && ehci_has_fsl_susp_errata(ehci)) 300 /* 301 * Wait for at least 10 millisecondes to ensure the controller 302 * enter the suspend status before initiating a port resume 303 * using the Force Port Resume bit (Not-EHCI compatible). 304 */ 305 usleep_range(10000, 20000); 306 307 if ((changed && ehci->has_tdi_phy_lpm) || fs_idle_delay) { 308 /* 309 * Wait for HCD to enter low-power mode or for the bus 310 * to switch to full-speed idle. 311 */ 312 usleep_range(5000, 5500); 313 } 314 315 if (changed && ehci->has_tdi_phy_lpm) { 316 spin_lock_irq(&ehci->lock); 317 port = HCS_N_PORTS(ehci->hcs_params); 318 while (port--) { 319 u32 __iomem *hostpc_reg = &ehci->regs->hostpc[port]; 320 u32 t3; 321 322 t3 = ehci_readl(ehci, hostpc_reg); 323 ehci_writel(ehci, t3 | HOSTPC_PHCD, hostpc_reg); 324 t3 = ehci_readl(ehci, hostpc_reg); 325 ehci_dbg(ehci, "Port %d phy low-power mode %s\n", 326 port, (t3 & HOSTPC_PHCD) ? 327 "succeeded" : "failed"); 328 } 329 spin_unlock_irq(&ehci->lock); 330 } 331 332 /* Apparently some devices need a >= 1-uframe delay here */ 333 if (ehci->bus_suspended) 334 udelay(150); 335 336 /* turn off now-idle HC */ 337 ehci_halt (ehci); 338 339 spin_lock_irq(&ehci->lock); 340 if (ehci->enabled_hrtimer_events & BIT(EHCI_HRTIMER_POLL_DEAD)) 341 ehci_handle_controller_death(ehci); 342 if (ehci->rh_state != EHCI_RH_RUNNING) 343 goto done; 344 ehci->rh_state = EHCI_RH_SUSPENDED; 345 346 unlink_empty_async_suspended(ehci); 347 348 /* Some Synopsys controllers mistakenly leave IAA turned on */ 349 ehci_writel(ehci, STS_IAA, &ehci->regs->status); 350 351 /* Any IAA cycle that started before the suspend is now invalid */ 352 end_iaa_cycle(ehci); 353 ehci_handle_start_intr_unlinks(ehci); 354 ehci_handle_intr_unlinks(ehci); 355 end_free_itds(ehci); 356 357 /* allow remote wakeup */ 358 mask = INTR_MASK; 359 if (!hcd->self.root_hub->do_remote_wakeup) 360 mask &= ~STS_PCD; 361 ehci_writel(ehci, mask, &ehci->regs->intr_enable); 362 ehci_readl(ehci, &ehci->regs->intr_enable); 363 364 done: 365 ehci->next_statechange = jiffies + msecs_to_jiffies(10); 366 ehci->enabled_hrtimer_events = 0; 367 ehci->next_hrtimer_event = EHCI_HRTIMER_NO_EVENT; 368 spin_unlock_irq (&ehci->lock); 369 370 hrtimer_cancel(&ehci->hrtimer); 371 return 0; 372} 373 374 375/* caller has locked the root hub, and should reset/reinit on error */ 376static int ehci_bus_resume (struct usb_hcd *hcd) 377{ 378 struct ehci_hcd *ehci = hcd_to_ehci (hcd); 379 u32 temp; 380 u32 power_okay; 381 int i; 382 unsigned long resume_needed = 0; 383 384 if (time_before (jiffies, ehci->next_statechange)) 385 msleep(5); 386 spin_lock_irq (&ehci->lock); 387 if (!HCD_HW_ACCESSIBLE(hcd) || ehci->shutdown) 388 goto shutdown; 389 390 if (unlikely(ehci->debug)) { 391 if (!dbgp_reset_prep(hcd)) 392 ehci->debug = NULL; 393 else 394 dbgp_external_startup(hcd); 395 } 396 397 /* Ideally and we've got a real resume here, and no port's power 398 * was lost. (For PCI, that means Vaux was maintained.) But we 399 * could instead be restoring a swsusp snapshot -- so that BIOS was 400 * the last user of the controller, not reset/pm hardware keeping 401 * state we gave to it. 402 */ 403 power_okay = ehci_readl(ehci, &ehci->regs->intr_enable); 404 ehci_dbg(ehci, "resume root hub%s\n", 405 power_okay ? "" : " after power loss"); 406 407 /* at least some APM implementations will try to deliver 408 * IRQs right away, so delay them until we're ready. 409 */ 410 ehci_writel(ehci, 0, &ehci->regs->intr_enable); 411 412 /* re-init operational registers */ 413 ehci_writel(ehci, 0, &ehci->regs->segment); 414 ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list); 415 ehci_writel(ehci, (u32) ehci->async->qh_dma, &ehci->regs->async_next); 416 417 /* restore CMD_RUN, framelist size, and irq threshold */ 418 ehci->command |= CMD_RUN; 419 ehci_writel(ehci, ehci->command, &ehci->regs->command); 420 ehci->rh_state = EHCI_RH_RUNNING; 421 422 /* 423 * According to Bugzilla #8190, the port status for some controllers 424 * will be wrong without a delay. At their wrong status, the port 425 * is enabled, but not suspended neither resumed. 426 */ 427 i = HCS_N_PORTS(ehci->hcs_params); 428 while (i--) { 429 temp = ehci_readl(ehci, &ehci->regs->port_status[i]); 430 if ((temp & PORT_PE) && 431 !(temp & (PORT_SUSPEND | PORT_RESUME))) { 432 ehci_dbg(ehci, "Port status(0x%x) is wrong\n", temp); 433 spin_unlock_irq(&ehci->lock); 434 msleep(8); 435 spin_lock_irq(&ehci->lock); 436 break; 437 } 438 } 439 440 if (ehci->shutdown) 441 goto shutdown; 442 443 /* clear phy low-power mode before resume */ 444 if (ehci->bus_suspended && ehci->has_tdi_phy_lpm) { 445 i = HCS_N_PORTS(ehci->hcs_params); 446 while (i--) { 447 if (test_bit(i, &ehci->bus_suspended)) { 448 u32 __iomem *hostpc_reg = 449 &ehci->regs->hostpc[i]; 450 451 temp = ehci_readl(ehci, hostpc_reg); 452 ehci_writel(ehci, temp & ~HOSTPC_PHCD, 453 hostpc_reg); 454 } 455 } 456 spin_unlock_irq(&ehci->lock); 457 msleep(5); 458 spin_lock_irq(&ehci->lock); 459 if (ehci->shutdown) 460 goto shutdown; 461 } 462 463 /* manually resume the ports we suspended during bus_suspend() */ 464 i = HCS_N_PORTS (ehci->hcs_params); 465 while (i--) { 466 temp = ehci_readl(ehci, &ehci->regs->port_status [i]); 467 temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS); 468 if (test_bit(i, &ehci->bus_suspended) && 469 (temp & PORT_SUSPEND)) { 470 temp |= PORT_RESUME; 471 set_bit(i, &resume_needed); 472 } 473 ehci_writel(ehci, temp, &ehci->regs->port_status [i]); 474 } 475 476 /* 477 * msleep for USB_RESUME_TIMEOUT ms only if code is trying to resume 478 * port 479 */ 480 if (resume_needed) { 481 spin_unlock_irq(&ehci->lock); 482 msleep(USB_RESUME_TIMEOUT); 483 spin_lock_irq(&ehci->lock); 484 if (ehci->shutdown) 485 goto shutdown; 486 } 487 488 i = HCS_N_PORTS (ehci->hcs_params); 489 while (i--) { 490 temp = ehci_readl(ehci, &ehci->regs->port_status [i]); 491 if (test_bit(i, &resume_needed)) { 492 temp &= ~(PORT_RWC_BITS | PORT_SUSPEND | PORT_RESUME); 493 ehci_writel(ehci, temp, &ehci->regs->port_status [i]); 494 } 495 } 496 497 ehci->next_statechange = jiffies + msecs_to_jiffies(5); 498 spin_unlock_irq(&ehci->lock); 499 500 ehci_handover_companion_ports(ehci); 501 502 /* Now we can safely re-enable irqs */ 503 spin_lock_irq(&ehci->lock); 504 if (ehci->shutdown) 505 goto shutdown; 506 ehci_writel(ehci, INTR_MASK, &ehci->regs->intr_enable); 507 (void) ehci_readl(ehci, &ehci->regs->intr_enable); 508 spin_unlock_irq(&ehci->lock); 509 510 return 0; 511 512 shutdown: 513 spin_unlock_irq(&ehci->lock); 514 return -ESHUTDOWN; 515} 516 517static unsigned long ehci_get_resuming_ports(struct usb_hcd *hcd) 518{ 519 struct ehci_hcd *ehci = hcd_to_ehci(hcd); 520 521 return ehci->resuming_ports; 522} 523 524#else 525 526#define ehci_bus_suspend NULL 527#define ehci_bus_resume NULL 528#define ehci_get_resuming_ports NULL 529 530#endif /* CONFIG_PM */ 531 532/*-------------------------------------------------------------------------*/ 533 534/* 535 * Sets the owner of a port 536 */ 537static void set_owner(struct ehci_hcd *ehci, int portnum, int new_owner) 538{ 539 u32 __iomem *status_reg; 540 u32 port_status; 541 int try; 542 543 status_reg = &ehci->regs->port_status[portnum]; 544 545 /* 546 * The controller won't set the OWNER bit if the port is 547 * enabled, so this loop will sometimes require at least two 548 * iterations: one to disable the port and one to set OWNER. 549 */ 550 for (try = 4; try > 0; --try) { 551 spin_lock_irq(&ehci->lock); 552 port_status = ehci_readl(ehci, status_reg); 553 if ((port_status & PORT_OWNER) == new_owner 554 || (port_status & (PORT_OWNER | PORT_CONNECT)) 555 == 0) 556 try = 0; 557 else { 558 port_status ^= PORT_OWNER; 559 port_status &= ~(PORT_PE | PORT_RWC_BITS); 560 ehci_writel(ehci, port_status, status_reg); 561 } 562 spin_unlock_irq(&ehci->lock); 563 if (try > 1) 564 msleep(5); 565 } 566} 567 568/*-------------------------------------------------------------------------*/ 569 570static int check_reset_complete ( 571 struct ehci_hcd *ehci, 572 int index, 573 u32 __iomem *status_reg, 574 int port_status 575) { 576 if (!(port_status & PORT_CONNECT)) 577 return port_status; 578 579 /* if reset finished and it's still not enabled -- handoff */ 580 if (!(port_status & PORT_PE)) { 581 582 /* with integrated TT, there's nobody to hand it to! */ 583 if (ehci_is_TDI(ehci)) { 584 ehci_dbg (ehci, 585 "Failed to enable port %d on root hub TT\n", 586 index+1); 587 return port_status; 588 } 589 590 ehci_dbg (ehci, "port %d full speed --> companion\n", 591 index + 1); 592 593 // what happens if HCS_N_CC(params) == 0 ? 594 port_status |= PORT_OWNER; 595 port_status &= ~PORT_RWC_BITS; 596 ehci_writel(ehci, port_status, status_reg); 597 598 /* ensure 440EPX ohci controller state is operational */ 599 if (ehci->has_amcc_usb23) 600 set_ohci_hcfs(ehci, 1); 601 } else { 602 ehci_dbg(ehci, "port %d reset complete, port enabled\n", 603 index + 1); 604 /* ensure 440EPx ohci controller state is suspended */ 605 if (ehci->has_amcc_usb23) 606 set_ohci_hcfs(ehci, 0); 607 } 608 609 return port_status; 610} 611 612/*-------------------------------------------------------------------------*/ 613 614 615/* build "status change" packet (one or two bytes) from HC registers */ 616 617static int 618ehci_hub_status_data (struct usb_hcd *hcd, char *buf) 619{ 620 struct ehci_hcd *ehci = hcd_to_ehci (hcd); 621 u32 temp, status; 622 u32 mask; 623 int ports, i, retval = 1; 624 unsigned long flags; 625 u32 ppcd = ~0; 626 627 /* init status to no-changes */ 628 buf [0] = 0; 629 ports = HCS_N_PORTS (ehci->hcs_params); 630 if (ports > 7) { 631 buf [1] = 0; 632 retval++; 633 } 634 635 /* Inform the core about resumes-in-progress by returning 636 * a non-zero value even if there are no status changes. 637 */ 638 status = ehci->resuming_ports; 639 640 /* Some boards (mostly VIA?) report bogus overcurrent indications, 641 * causing massive log spam unless we completely ignore them. It 642 * may be relevant that VIA VT8235 controllers, where PORT_POWER is 643 * always set, seem to clear PORT_OCC and PORT_CSC when writing to 644 * PORT_POWER; that's surprising, but maybe within-spec. 645 */ 646 if (!ignore_oc && !ehci->spurious_oc) 647 mask = PORT_CSC | PORT_PEC | PORT_OCC; 648 else 649 mask = PORT_CSC | PORT_PEC; 650 // PORT_RESUME from hardware ~= PORT_STAT_C_SUSPEND 651 652 /* no hub change reports (bit 0) for now (power, ...) */ 653 654 /* port N changes (bit N)? */ 655 spin_lock_irqsave (&ehci->lock, flags); 656 657 /* get per-port change detect bits */ 658 if (ehci->has_ppcd) 659 ppcd = ehci_readl(ehci, &ehci->regs->status) >> 16; 660 661 for (i = 0; i < ports; i++) { 662 /* leverage per-port change bits feature */ 663 if (ppcd & (1 << i)) 664 temp = ehci_readl(ehci, &ehci->regs->port_status[i]); 665 else 666 temp = 0; 667 668 /* 669 * Return status information even for ports with OWNER set. 670 * Otherwise hub_wq wouldn't see the disconnect event when a 671 * high-speed device is switched over to the companion 672 * controller by the user. 673 */ 674 675 if ((temp & mask) != 0 || test_bit(i, &ehci->port_c_suspend) 676 || (ehci->reset_done[i] && time_after_eq( 677 jiffies, ehci->reset_done[i])) 678 || ehci_has_ci_pec_bug(ehci, temp)) { 679 if (i < 7) 680 buf [0] |= 1 << (i + 1); 681 else 682 buf [1] |= 1 << (i - 7); 683 status = STS_PCD; 684 } 685 } 686 687 /* If a resume is in progress, make sure it can finish */ 688 if (ehci->resuming_ports) 689 mod_timer(&hcd->rh_timer, jiffies + msecs_to_jiffies(25)); 690 691 spin_unlock_irqrestore (&ehci->lock, flags); 692 return status ? retval : 0; 693} 694 695/*-------------------------------------------------------------------------*/ 696 697static void 698ehci_hub_descriptor ( 699 struct ehci_hcd *ehci, 700 struct usb_hub_descriptor *desc 701) { 702 int ports = HCS_N_PORTS (ehci->hcs_params); 703 u16 temp; 704 705 desc->bDescriptorType = USB_DT_HUB; 706 desc->bPwrOn2PwrGood = 10; /* ehci 1.0, 2.3.9 says 20ms max */ 707 desc->bHubContrCurrent = 0; 708 709 desc->bNbrPorts = ports; 710 temp = 1 + (ports / 8); 711 desc->bDescLength = 7 + 2 * temp; 712 713 /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */ 714 memset(&desc->u.hs.DeviceRemovable[0], 0, temp); 715 memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp); 716 717 temp = HUB_CHAR_INDV_PORT_OCPM; /* per-port overcurrent reporting */ 718 if (HCS_PPC (ehci->hcs_params)) 719 temp |= HUB_CHAR_INDV_PORT_LPSM; /* per-port power control */ 720 else 721 temp |= HUB_CHAR_NO_LPSM; /* no power switching */ 722#if 0 723// re-enable when we support USB_PORT_FEAT_INDICATOR below. 724 if (HCS_INDICATOR (ehci->hcs_params)) 725 temp |= HUB_CHAR_PORTIND; /* per-port indicators (LEDs) */ 726#endif 727 desc->wHubCharacteristics = cpu_to_le16(temp); 728} 729 730/*-------------------------------------------------------------------------*/ 731 732int ehci_hub_control( 733 struct usb_hcd *hcd, 734 u16 typeReq, 735 u16 wValue, 736 u16 wIndex, 737 char *buf, 738 u16 wLength 739) { 740 struct ehci_hcd *ehci = hcd_to_ehci (hcd); 741 int ports = HCS_N_PORTS (ehci->hcs_params); 742 u32 __iomem *status_reg, *hostpc_reg; 743 u32 temp, temp1, status; 744 unsigned long flags; 745 int retval = 0; 746 unsigned selector; 747 748 /* 749 * Avoid out-of-bounds values while calculating the port index 750 * from wIndex. The compiler doesn't like pointers to invalid 751 * addresses, even if they are never used. 752 */ 753 temp = (wIndex - 1) & 0xff; 754 if (temp >= HCS_N_PORTS_MAX) 755 temp = 0; 756 status_reg = &ehci->regs->port_status[temp]; 757 hostpc_reg = &ehci->regs->hostpc[temp]; 758 759 /* 760 * FIXME: support SetPortFeatures USB_PORT_FEAT_INDICATOR. 761 * HCS_INDICATOR may say we can change LEDs to off/amber/green. 762 * (track current state ourselves) ... blink for diagnostics, 763 * power, "this is the one", etc. EHCI spec supports this. 764 */ 765 766 spin_lock_irqsave (&ehci->lock, flags); 767 switch (typeReq) { 768 case ClearHubFeature: 769 switch (wValue) { 770 case C_HUB_LOCAL_POWER: 771 case C_HUB_OVER_CURRENT: 772 /* no hub-wide feature/status flags */ 773 break; 774 default: 775 goto error; 776 } 777 break; 778 case ClearPortFeature: 779 if (!wIndex || wIndex > ports) 780 goto error; 781 wIndex--; 782 temp = ehci_readl(ehci, status_reg); 783 temp &= ~PORT_RWC_BITS; 784 785 /* 786 * Even if OWNER is set, so the port is owned by the 787 * companion controller, hub_wq needs to be able to clear 788 * the port-change status bits (especially 789 * USB_PORT_STAT_C_CONNECTION). 790 */ 791 792 switch (wValue) { 793 case USB_PORT_FEAT_ENABLE: 794 ehci_writel(ehci, temp & ~PORT_PE, status_reg); 795 break; 796 case USB_PORT_FEAT_C_ENABLE: 797 ehci_writel(ehci, temp | PORT_PEC, status_reg); 798 break; 799 case USB_PORT_FEAT_SUSPEND: 800 if (temp & PORT_RESET) 801 goto error; 802 if (ehci->no_selective_suspend) 803 break; 804#ifdef CONFIG_USB_OTG 805 if ((hcd->self.otg_port == (wIndex + 1)) 806 && hcd->self.b_hnp_enable) { 807 otg_start_hnp(hcd->usb_phy->otg); 808 break; 809 } 810#endif 811 if (!(temp & PORT_SUSPEND)) 812 break; 813 if ((temp & PORT_PE) == 0) 814 goto error; 815 816 /* clear phy low-power mode before resume */ 817 if (ehci->has_tdi_phy_lpm) { 818 temp1 = ehci_readl(ehci, hostpc_reg); 819 ehci_writel(ehci, temp1 & ~HOSTPC_PHCD, 820 hostpc_reg); 821 spin_unlock_irqrestore(&ehci->lock, flags); 822 msleep(5);/* wait to leave low-power mode */ 823 spin_lock_irqsave(&ehci->lock, flags); 824 } 825 /* resume signaling for 20 msec */ 826 temp &= ~PORT_WAKE_BITS; 827 ehci_writel(ehci, temp | PORT_RESUME, status_reg); 828 ehci->reset_done[wIndex] = jiffies 829 + msecs_to_jiffies(USB_RESUME_TIMEOUT); 830 set_bit(wIndex, &ehci->resuming_ports); 831 usb_hcd_start_port_resume(&hcd->self, wIndex); 832 break; 833 case USB_PORT_FEAT_C_SUSPEND: 834 clear_bit(wIndex, &ehci->port_c_suspend); 835 break; 836 case USB_PORT_FEAT_POWER: 837 if (HCS_PPC(ehci->hcs_params)) { 838 spin_unlock_irqrestore(&ehci->lock, flags); 839 ehci_port_power(ehci, wIndex, false); 840 spin_lock_irqsave(&ehci->lock, flags); 841 } 842 break; 843 case USB_PORT_FEAT_C_CONNECTION: 844 ehci_writel(ehci, temp | PORT_CSC, status_reg); 845 break; 846 case USB_PORT_FEAT_C_OVER_CURRENT: 847 ehci_writel(ehci, temp | PORT_OCC, status_reg); 848 break; 849 case USB_PORT_FEAT_C_RESET: 850 /* GetPortStatus clears reset */ 851 break; 852 default: 853 goto error; 854 } 855 ehci_readl(ehci, &ehci->regs->command); /* unblock posted write */ 856 break; 857 case GetHubDescriptor: 858 ehci_hub_descriptor (ehci, (struct usb_hub_descriptor *) 859 buf); 860 break; 861 case GetHubStatus: 862 /* no hub-wide feature/status flags */ 863 memset (buf, 0, 4); 864 //cpu_to_le32s ((u32 *) buf); 865 break; 866 case GetPortStatus: 867 if (!wIndex || wIndex > ports) 868 goto error; 869 wIndex--; 870 status = 0; 871 temp = ehci_readl(ehci, status_reg); 872 873 // wPortChange bits 874 if (temp & PORT_CSC) 875 status |= USB_PORT_STAT_C_CONNECTION << 16; 876 if (temp & PORT_PEC) 877 status |= USB_PORT_STAT_C_ENABLE << 16; 878 879 if (ehci_has_ci_pec_bug(ehci, temp)) { 880 status |= USB_PORT_STAT_C_ENABLE << 16; 881 ehci_info(ehci, 882 "PE is cleared by HW port:%d PORTSC:%08x\n", 883 wIndex + 1, temp); 884 } 885 886 if ((temp & PORT_OCC) && (!ignore_oc && !ehci->spurious_oc)){ 887 status |= USB_PORT_STAT_C_OVERCURRENT << 16; 888 889 /* 890 * Hubs should disable port power on over-current. 891 * However, not all EHCI implementations do this 892 * automatically, even if they _do_ support per-port 893 * power switching; they're allowed to just limit the 894 * current. hub_wq will turn the power back on. 895 */ 896 if (((temp & PORT_OC) || (ehci->need_oc_pp_cycle)) 897 && HCS_PPC(ehci->hcs_params)) { 898 spin_unlock_irqrestore(&ehci->lock, flags); 899 ehci_port_power(ehci, wIndex, false); 900 spin_lock_irqsave(&ehci->lock, flags); 901 temp = ehci_readl(ehci, status_reg); 902 } 903 } 904 905 /* no reset or resume pending */ 906 if (!ehci->reset_done[wIndex]) { 907 908 /* Remote Wakeup received? */ 909 if (temp & PORT_RESUME) { 910 /* resume signaling for 20 msec */ 911 ehci->reset_done[wIndex] = jiffies 912 + msecs_to_jiffies(20); 913 usb_hcd_start_port_resume(&hcd->self, wIndex); 914 set_bit(wIndex, &ehci->resuming_ports); 915 /* check the port again */ 916 mod_timer(&ehci_to_hcd(ehci)->rh_timer, 917 ehci->reset_done[wIndex]); 918 } 919 920 /* reset or resume not yet complete */ 921 } else if (!time_after_eq(jiffies, ehci->reset_done[wIndex])) { 922 ; /* wait until it is complete */ 923 924 /* resume completed */ 925 } else if (test_bit(wIndex, &ehci->resuming_ports)) { 926 clear_bit(wIndex, &ehci->suspended_ports); 927 set_bit(wIndex, &ehci->port_c_suspend); 928 ehci->reset_done[wIndex] = 0; 929 usb_hcd_end_port_resume(&hcd->self, wIndex); 930 931 /* stop resume signaling */ 932 temp &= ~(PORT_RWC_BITS | PORT_SUSPEND | PORT_RESUME); 933 ehci_writel(ehci, temp, status_reg); 934 clear_bit(wIndex, &ehci->resuming_ports); 935 retval = ehci_handshake(ehci, status_reg, 936 PORT_RESUME, 0, 2000 /* 2msec */); 937 if (retval != 0) { 938 ehci_err(ehci, "port %d resume error %d\n", 939 wIndex + 1, retval); 940 goto error; 941 } 942 temp = ehci_readl(ehci, status_reg); 943 944 /* whoever resets must GetPortStatus to complete it!! */ 945 } else { 946 status |= USB_PORT_STAT_C_RESET << 16; 947 ehci->reset_done [wIndex] = 0; 948 949 /* force reset to complete */ 950 ehci_writel(ehci, temp & ~(PORT_RWC_BITS | PORT_RESET), 951 status_reg); 952 /* REVISIT: some hardware needs 550+ usec to clear 953 * this bit; seems too long to spin routinely... 954 */ 955 retval = ehci_handshake(ehci, status_reg, 956 PORT_RESET, 0, 1000); 957 if (retval != 0) { 958 ehci_err (ehci, "port %d reset error %d\n", 959 wIndex + 1, retval); 960 goto error; 961 } 962 963 /* see what we found out */ 964 temp = check_reset_complete (ehci, wIndex, status_reg, 965 ehci_readl(ehci, status_reg)); 966 } 967 968 /* transfer dedicated ports to the companion hc */ 969 if ((temp & PORT_CONNECT) && 970 test_bit(wIndex, &ehci->companion_ports)) { 971 temp &= ~PORT_RWC_BITS; 972 temp |= PORT_OWNER; 973 ehci_writel(ehci, temp, status_reg); 974 ehci_dbg(ehci, "port %d --> companion\n", wIndex + 1); 975 temp = ehci_readl(ehci, status_reg); 976 } 977 978 /* 979 * Even if OWNER is set, there's no harm letting hub_wq 980 * see the wPortStatus values (they should all be 0 except 981 * for PORT_POWER anyway). 982 */ 983 984 if (temp & PORT_CONNECT) { 985 status |= USB_PORT_STAT_CONNECTION; 986 // status may be from integrated TT 987 if (ehci->has_hostpc) { 988 temp1 = ehci_readl(ehci, hostpc_reg); 989 status |= ehci_port_speed(ehci, temp1); 990 } else 991 status |= ehci_port_speed(ehci, temp); 992 } 993 if (temp & PORT_PE) 994 status |= USB_PORT_STAT_ENABLE; 995 996 /* maybe the port was unsuspended without our knowledge */ 997 if (temp & (PORT_SUSPEND|PORT_RESUME)) { 998 status |= USB_PORT_STAT_SUSPEND; 999 } else if (test_bit(wIndex, &ehci->suspended_ports)) { 1000 clear_bit(wIndex, &ehci->suspended_ports); 1001 clear_bit(wIndex, &ehci->resuming_ports); 1002 ehci->reset_done[wIndex] = 0; 1003 if (temp & PORT_PE) 1004 set_bit(wIndex, &ehci->port_c_suspend); 1005 usb_hcd_end_port_resume(&hcd->self, wIndex); 1006 } 1007 1008 if (temp & PORT_OC) 1009 status |= USB_PORT_STAT_OVERCURRENT; 1010 if (temp & PORT_RESET) 1011 status |= USB_PORT_STAT_RESET; 1012 if (temp & PORT_POWER) 1013 status |= USB_PORT_STAT_POWER; 1014 if (test_bit(wIndex, &ehci->port_c_suspend)) 1015 status |= USB_PORT_STAT_C_SUSPEND << 16; 1016 1017 if (status & ~0xffff) /* only if wPortChange is interesting */ 1018 dbg_port(ehci, "GetStatus", wIndex + 1, temp); 1019 put_unaligned_le32(status, buf); 1020 break; 1021 case SetHubFeature: 1022 switch (wValue) { 1023 case C_HUB_LOCAL_POWER: 1024 case C_HUB_OVER_CURRENT: 1025 /* no hub-wide feature/status flags */ 1026 break; 1027 default: 1028 goto error; 1029 } 1030 break; 1031 case SetPortFeature: 1032 selector = wIndex >> 8; 1033 wIndex &= 0xff; 1034 if (unlikely(ehci->debug)) { 1035 /* If the debug port is active any port 1036 * feature requests should get denied */ 1037 if (wIndex == HCS_DEBUG_PORT(ehci->hcs_params) && 1038 (readl(&ehci->debug->control) & DBGP_ENABLED)) { 1039 retval = -ENODEV; 1040 goto error_exit; 1041 } 1042 } 1043 if (!wIndex || wIndex > ports) 1044 goto error; 1045 wIndex--; 1046 temp = ehci_readl(ehci, status_reg); 1047 if (temp & PORT_OWNER) 1048 break; 1049 1050 temp &= ~PORT_RWC_BITS; 1051 switch (wValue) { 1052 case USB_PORT_FEAT_SUSPEND: 1053 if (ehci->no_selective_suspend) 1054 break; 1055 if ((temp & PORT_PE) == 0 1056 || (temp & PORT_RESET) != 0) 1057 goto error; 1058 1059 /* After above check the port must be connected. 1060 * Set appropriate bit thus could put phy into low power 1061 * mode if we have tdi_phy_lpm feature 1062 */ 1063 temp &= ~PORT_WKCONN_E; 1064 temp |= PORT_WKDISC_E | PORT_WKOC_E; 1065 ehci_writel(ehci, temp | PORT_SUSPEND, status_reg); 1066 if (ehci->has_tdi_phy_lpm) { 1067 spin_unlock_irqrestore(&ehci->lock, flags); 1068 msleep(5);/* 5ms for HCD enter low pwr mode */ 1069 spin_lock_irqsave(&ehci->lock, flags); 1070 temp1 = ehci_readl(ehci, hostpc_reg); 1071 ehci_writel(ehci, temp1 | HOSTPC_PHCD, 1072 hostpc_reg); 1073 temp1 = ehci_readl(ehci, hostpc_reg); 1074 ehci_dbg(ehci, "Port%d phy low pwr mode %s\n", 1075 wIndex, (temp1 & HOSTPC_PHCD) ? 1076 "succeeded" : "failed"); 1077 } 1078 if (ehci_has_fsl_susp_errata(ehci)) { 1079 /* 10ms for HCD enter suspend */ 1080 spin_unlock_irqrestore(&ehci->lock, flags); 1081 usleep_range(10000, 20000); 1082 spin_lock_irqsave(&ehci->lock, flags); 1083 } 1084 set_bit(wIndex, &ehci->suspended_ports); 1085 break; 1086 case USB_PORT_FEAT_POWER: 1087 if (HCS_PPC(ehci->hcs_params)) { 1088 spin_unlock_irqrestore(&ehci->lock, flags); 1089 ehci_port_power(ehci, wIndex, true); 1090 spin_lock_irqsave(&ehci->lock, flags); 1091 } 1092 break; 1093 case USB_PORT_FEAT_RESET: 1094 if (temp & (PORT_SUSPEND|PORT_RESUME)) 1095 goto error; 1096 /* line status bits may report this as low speed, 1097 * which can be fine if this root hub has a 1098 * transaction translator built in. 1099 */ 1100 if ((temp & (PORT_PE|PORT_CONNECT)) == PORT_CONNECT 1101 && !ehci_is_TDI(ehci) 1102 && PORT_USB11 (temp)) { 1103 ehci_dbg (ehci, 1104 "port %d low speed --> companion\n", 1105 wIndex + 1); 1106 temp |= PORT_OWNER; 1107 } else { 1108 temp |= PORT_RESET; 1109 temp &= ~PORT_PE; 1110 1111 /* 1112 * caller must wait, then call GetPortStatus 1113 * usb 2.0 spec says 50 ms resets on root 1114 */ 1115 ehci->reset_done [wIndex] = jiffies 1116 + msecs_to_jiffies (50); 1117 1118 /* 1119 * Force full-speed connect for FSL high-speed 1120 * erratum; disable HS Chirp by setting PFSC bit 1121 */ 1122 if (ehci_has_fsl_hs_errata(ehci)) 1123 temp |= (1 << PORTSC_FSL_PFSC); 1124 } 1125 ehci_writel(ehci, temp, status_reg); 1126 break; 1127 1128 /* For downstream facing ports (these): one hub port is put 1129 * into test mode according to USB2 11.24.2.13, then the hub 1130 * must be reset (which for root hub now means rmmod+modprobe, 1131 * or else system reboot). See EHCI 2.3.9 and 4.14 for info 1132 * about the EHCI-specific stuff. 1133 */ 1134 case USB_PORT_FEAT_TEST: 1135#ifdef CONFIG_USB_HCD_TEST_MODE 1136 if (selector == EHSET_TEST_SINGLE_STEP_SET_FEATURE) { 1137 spin_unlock_irqrestore(&ehci->lock, flags); 1138 retval = ehset_single_step_set_feature(hcd, 1139 wIndex + 1); 1140 spin_lock_irqsave(&ehci->lock, flags); 1141 break; 1142 } 1143#endif 1144 if (!selector || selector > 5) 1145 goto error; 1146 spin_unlock_irqrestore(&ehci->lock, flags); 1147 ehci_quiesce(ehci); 1148 spin_lock_irqsave(&ehci->lock, flags); 1149 1150 /* Put all enabled ports into suspend */ 1151 while (ports--) { 1152 u32 __iomem *sreg = 1153 &ehci->regs->port_status[ports]; 1154 1155 temp = ehci_readl(ehci, sreg) & ~PORT_RWC_BITS; 1156 if (temp & PORT_PE) 1157 ehci_writel(ehci, temp | PORT_SUSPEND, 1158 sreg); 1159 } 1160 1161 spin_unlock_irqrestore(&ehci->lock, flags); 1162 ehci_halt(ehci); 1163 spin_lock_irqsave(&ehci->lock, flags); 1164 1165 temp = ehci_readl(ehci, status_reg); 1166 temp |= selector << 16; 1167 ehci_writel(ehci, temp, status_reg); 1168 break; 1169 1170 default: 1171 goto error; 1172 } 1173 ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */ 1174 break; 1175 1176 default: 1177error: 1178 /* "stall" on error */ 1179 retval = -EPIPE; 1180 } 1181error_exit: 1182 spin_unlock_irqrestore (&ehci->lock, flags); 1183 return retval; 1184} 1185EXPORT_SYMBOL_GPL(ehci_hub_control); 1186 1187static void ehci_relinquish_port(struct usb_hcd *hcd, int portnum) 1188{ 1189 struct ehci_hcd *ehci = hcd_to_ehci(hcd); 1190 1191 if (ehci_is_TDI(ehci)) 1192 return; 1193 set_owner(ehci, --portnum, PORT_OWNER); 1194} 1195 1196static int ehci_port_handed_over(struct usb_hcd *hcd, int portnum) 1197{ 1198 struct ehci_hcd *ehci = hcd_to_ehci(hcd); 1199 u32 __iomem *reg; 1200 1201 if (ehci_is_TDI(ehci)) 1202 return 0; 1203 reg = &ehci->regs->port_status[portnum - 1]; 1204 return ehci_readl(ehci, reg) & PORT_OWNER; 1205} 1206 1207static int ehci_port_power(struct ehci_hcd *ehci, int portnum, bool enable) 1208{ 1209 struct usb_hcd *hcd = ehci_to_hcd(ehci); 1210 u32 __iomem *status_reg = &ehci->regs->port_status[portnum]; 1211 u32 temp = ehci_readl(ehci, status_reg) & ~PORT_RWC_BITS; 1212 1213 if (enable) 1214 ehci_writel(ehci, temp | PORT_POWER, status_reg); 1215 else 1216 ehci_writel(ehci, temp & ~PORT_POWER, status_reg); 1217 1218 if (hcd->driver->port_power) 1219 hcd->driver->port_power(hcd, portnum, enable); 1220 1221 return 0; 1222} 1223