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) 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 if (i < 7) 679 buf [0] |= 1 << (i + 1); 680 else 681 buf [1] |= 1 << (i - 7); 682 status = STS_PCD; 683 } 684 } 685 686 /* If a resume is in progress, make sure it can finish */ 687 if (ehci->resuming_ports) 688 mod_timer(&hcd->rh_timer, jiffies + msecs_to_jiffies(25)); 689 690 spin_unlock_irqrestore (&ehci->lock, flags); 691 return status ? retval : 0; 692} 693 694/*-------------------------------------------------------------------------*/ 695 696static void 697ehci_hub_descriptor ( 698 struct ehci_hcd *ehci, 699 struct usb_hub_descriptor *desc 700) { 701 int ports = HCS_N_PORTS (ehci->hcs_params); 702 u16 temp; 703 704 desc->bDescriptorType = USB_DT_HUB; 705 desc->bPwrOn2PwrGood = 10; /* ehci 1.0, 2.3.9 says 20ms max */ 706 desc->bHubContrCurrent = 0; 707 708 desc->bNbrPorts = ports; 709 temp = 1 + (ports / 8); 710 desc->bDescLength = 7 + 2 * temp; 711 712 /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */ 713 memset(&desc->u.hs.DeviceRemovable[0], 0, temp); 714 memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp); 715 716 temp = HUB_CHAR_INDV_PORT_OCPM; /* per-port overcurrent reporting */ 717 if (HCS_PPC (ehci->hcs_params)) 718 temp |= HUB_CHAR_INDV_PORT_LPSM; /* per-port power control */ 719 else 720 temp |= HUB_CHAR_NO_LPSM; /* no power switching */ 721#if 0 722// re-enable when we support USB_PORT_FEAT_INDICATOR below. 723 if (HCS_INDICATOR (ehci->hcs_params)) 724 temp |= HUB_CHAR_PORTIND; /* per-port indicators (LEDs) */ 725#endif 726 desc->wHubCharacteristics = cpu_to_le16(temp); 727} 728 729/*-------------------------------------------------------------------------*/ 730#ifdef CONFIG_USB_HCD_TEST_MODE 731 732#define EHSET_TEST_SINGLE_STEP_SET_FEATURE 0x06 733 734static void usb_ehset_completion(struct urb *urb) 735{ 736 struct completion *done = urb->context; 737 738 complete(done); 739} 740static int submit_single_step_set_feature( 741 struct usb_hcd *hcd, 742 struct urb *urb, 743 int is_setup 744); 745 746/* 747 * Allocate and initialize a control URB. This request will be used by the 748 * EHSET SINGLE_STEP_SET_FEATURE test in which the DATA and STATUS stages 749 * of the GetDescriptor request are sent 15 seconds after the SETUP stage. 750 * Return NULL if failed. 751 */ 752static struct urb *request_single_step_set_feature_urb( 753 struct usb_device *udev, 754 void *dr, 755 void *buf, 756 struct completion *done 757) { 758 struct urb *urb; 759 struct usb_hcd *hcd = bus_to_hcd(udev->bus); 760 struct usb_host_endpoint *ep; 761 762 urb = usb_alloc_urb(0, GFP_KERNEL); 763 if (!urb) 764 return NULL; 765 766 urb->pipe = usb_rcvctrlpipe(udev, 0); 767 ep = (usb_pipein(urb->pipe) ? udev->ep_in : udev->ep_out) 768 [usb_pipeendpoint(urb->pipe)]; 769 if (!ep) { 770 usb_free_urb(urb); 771 return NULL; 772 } 773 774 urb->ep = ep; 775 urb->dev = udev; 776 urb->setup_packet = (void *)dr; 777 urb->transfer_buffer = buf; 778 urb->transfer_buffer_length = USB_DT_DEVICE_SIZE; 779 urb->complete = usb_ehset_completion; 780 urb->status = -EINPROGRESS; 781 urb->actual_length = 0; 782 urb->transfer_flags = URB_DIR_IN; 783 usb_get_urb(urb); 784 atomic_inc(&urb->use_count); 785 atomic_inc(&urb->dev->urbnum); 786 urb->setup_dma = dma_map_single( 787 hcd->self.sysdev, 788 urb->setup_packet, 789 sizeof(struct usb_ctrlrequest), 790 DMA_TO_DEVICE); 791 urb->transfer_dma = dma_map_single( 792 hcd->self.sysdev, 793 urb->transfer_buffer, 794 urb->transfer_buffer_length, 795 DMA_FROM_DEVICE); 796 urb->context = done; 797 return urb; 798} 799 800static int ehset_single_step_set_feature(struct usb_hcd *hcd, int port) 801{ 802 int retval = -ENOMEM; 803 struct usb_ctrlrequest *dr; 804 struct urb *urb; 805 struct usb_device *udev; 806 struct ehci_hcd *ehci = hcd_to_ehci(hcd); 807 struct usb_device_descriptor *buf; 808 DECLARE_COMPLETION_ONSTACK(done); 809 810 /* Obtain udev of the rhub's child port */ 811 udev = usb_hub_find_child(hcd->self.root_hub, port); 812 if (!udev) { 813 ehci_err(ehci, "No device attached to the RootHub\n"); 814 return -ENODEV; 815 } 816 buf = kmalloc(USB_DT_DEVICE_SIZE, GFP_KERNEL); 817 if (!buf) 818 return -ENOMEM; 819 820 dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL); 821 if (!dr) { 822 kfree(buf); 823 return -ENOMEM; 824 } 825 826 /* Fill Setup packet for GetDescriptor */ 827 dr->bRequestType = USB_DIR_IN; 828 dr->bRequest = USB_REQ_GET_DESCRIPTOR; 829 dr->wValue = cpu_to_le16(USB_DT_DEVICE << 8); 830 dr->wIndex = 0; 831 dr->wLength = cpu_to_le16(USB_DT_DEVICE_SIZE); 832 urb = request_single_step_set_feature_urb(udev, dr, buf, &done); 833 if (!urb) 834 goto cleanup; 835 836 /* Submit just the SETUP stage */ 837 retval = submit_single_step_set_feature(hcd, urb, 1); 838 if (retval) 839 goto out1; 840 if (!wait_for_completion_timeout(&done, msecs_to_jiffies(2000))) { 841 usb_kill_urb(urb); 842 retval = -ETIMEDOUT; 843 ehci_err(ehci, "%s SETUP stage timed out on ep0\n", __func__); 844 goto out1; 845 } 846 msleep(15 * 1000); 847 848 /* Complete remaining DATA and STATUS stages using the same URB */ 849 urb->status = -EINPROGRESS; 850 usb_get_urb(urb); 851 atomic_inc(&urb->use_count); 852 atomic_inc(&urb->dev->urbnum); 853 retval = submit_single_step_set_feature(hcd, urb, 0); 854 if (!retval && !wait_for_completion_timeout(&done, 855 msecs_to_jiffies(2000))) { 856 usb_kill_urb(urb); 857 retval = -ETIMEDOUT; 858 ehci_err(ehci, "%s IN stage timed out on ep0\n", __func__); 859 } 860out1: 861 usb_free_urb(urb); 862cleanup: 863 kfree(dr); 864 kfree(buf); 865 return retval; 866} 867#endif /* CONFIG_USB_HCD_TEST_MODE */ 868/*-------------------------------------------------------------------------*/ 869 870int ehci_hub_control( 871 struct usb_hcd *hcd, 872 u16 typeReq, 873 u16 wValue, 874 u16 wIndex, 875 char *buf, 876 u16 wLength 877) { 878 struct ehci_hcd *ehci = hcd_to_ehci (hcd); 879 int ports = HCS_N_PORTS (ehci->hcs_params); 880 u32 __iomem *status_reg, *hostpc_reg; 881 u32 temp, temp1, status; 882 unsigned long flags; 883 int retval = 0; 884 unsigned selector; 885 886 /* 887 * Avoid underflow while calculating (wIndex & 0xff) - 1. 888 * The compiler might deduce that wIndex can never be 0 and then 889 * optimize away the tests for !wIndex below. 890 */ 891 temp = wIndex & 0xff; 892 temp -= (temp > 0); 893 status_reg = &ehci->regs->port_status[temp]; 894 hostpc_reg = &ehci->regs->hostpc[temp]; 895 896 /* 897 * FIXME: support SetPortFeatures USB_PORT_FEAT_INDICATOR. 898 * HCS_INDICATOR may say we can change LEDs to off/amber/green. 899 * (track current state ourselves) ... blink for diagnostics, 900 * power, "this is the one", etc. EHCI spec supports this. 901 */ 902 903 spin_lock_irqsave (&ehci->lock, flags); 904 switch (typeReq) { 905 case ClearHubFeature: 906 switch (wValue) { 907 case C_HUB_LOCAL_POWER: 908 case C_HUB_OVER_CURRENT: 909 /* no hub-wide feature/status flags */ 910 break; 911 default: 912 goto error; 913 } 914 break; 915 case ClearPortFeature: 916 if (!wIndex || wIndex > ports) 917 goto error; 918 wIndex--; 919 temp = ehci_readl(ehci, status_reg); 920 temp &= ~PORT_RWC_BITS; 921 922 /* 923 * Even if OWNER is set, so the port is owned by the 924 * companion controller, hub_wq needs to be able to clear 925 * the port-change status bits (especially 926 * USB_PORT_STAT_C_CONNECTION). 927 */ 928 929 switch (wValue) { 930 case USB_PORT_FEAT_ENABLE: 931 ehci_writel(ehci, temp & ~PORT_PE, status_reg); 932 break; 933 case USB_PORT_FEAT_C_ENABLE: 934 ehci_writel(ehci, temp | PORT_PEC, status_reg); 935 break; 936 case USB_PORT_FEAT_SUSPEND: 937 if (temp & PORT_RESET) 938 goto error; 939 if (ehci->no_selective_suspend) 940 break; 941#ifdef CONFIG_USB_OTG 942 if ((hcd->self.otg_port == (wIndex + 1)) 943 && hcd->self.b_hnp_enable) { 944 otg_start_hnp(hcd->usb_phy->otg); 945 break; 946 } 947#endif 948 if (!(temp & PORT_SUSPEND)) 949 break; 950 if ((temp & PORT_PE) == 0) 951 goto error; 952 953 /* clear phy low-power mode before resume */ 954 if (ehci->has_tdi_phy_lpm) { 955 temp1 = ehci_readl(ehci, hostpc_reg); 956 ehci_writel(ehci, temp1 & ~HOSTPC_PHCD, 957 hostpc_reg); 958 spin_unlock_irqrestore(&ehci->lock, flags); 959 msleep(5);/* wait to leave low-power mode */ 960 spin_lock_irqsave(&ehci->lock, flags); 961 } 962 /* resume signaling for 20 msec */ 963 temp &= ~PORT_WAKE_BITS; 964 ehci_writel(ehci, temp | PORT_RESUME, status_reg); 965 ehci->reset_done[wIndex] = jiffies 966 + msecs_to_jiffies(USB_RESUME_TIMEOUT); 967 set_bit(wIndex, &ehci->resuming_ports); 968 usb_hcd_start_port_resume(&hcd->self, wIndex); 969 break; 970 case USB_PORT_FEAT_C_SUSPEND: 971 clear_bit(wIndex, &ehci->port_c_suspend); 972 break; 973 case USB_PORT_FEAT_POWER: 974 if (HCS_PPC(ehci->hcs_params)) { 975 spin_unlock_irqrestore(&ehci->lock, flags); 976 ehci_port_power(ehci, wIndex, false); 977 spin_lock_irqsave(&ehci->lock, flags); 978 } 979 break; 980 case USB_PORT_FEAT_C_CONNECTION: 981 ehci_writel(ehci, temp | PORT_CSC, status_reg); 982 break; 983 case USB_PORT_FEAT_C_OVER_CURRENT: 984 ehci_writel(ehci, temp | PORT_OCC, status_reg); 985 break; 986 case USB_PORT_FEAT_C_RESET: 987 /* GetPortStatus clears reset */ 988 break; 989 default: 990 goto error; 991 } 992 ehci_readl(ehci, &ehci->regs->command); /* unblock posted write */ 993 break; 994 case GetHubDescriptor: 995 ehci_hub_descriptor (ehci, (struct usb_hub_descriptor *) 996 buf); 997 break; 998 case GetHubStatus: 999 /* no hub-wide feature/status flags */ 1000 memset (buf, 0, 4); 1001 //cpu_to_le32s ((u32 *) buf); 1002 break; 1003 case GetPortStatus: 1004 if (!wIndex || wIndex > ports) 1005 goto error; 1006 wIndex--; 1007 status = 0; 1008 temp = ehci_readl(ehci, status_reg); 1009 1010 // wPortChange bits 1011 if (temp & PORT_CSC) 1012 status |= USB_PORT_STAT_C_CONNECTION << 16; 1013 if (temp & PORT_PEC) 1014 status |= USB_PORT_STAT_C_ENABLE << 16; 1015 1016 if ((temp & PORT_OCC) && !ignore_oc){ 1017 status |= USB_PORT_STAT_C_OVERCURRENT << 16; 1018 1019 /* 1020 * Hubs should disable port power on over-current. 1021 * However, not all EHCI implementations do this 1022 * automatically, even if they _do_ support per-port 1023 * power switching; they're allowed to just limit the 1024 * current. hub_wq will turn the power back on. 1025 */ 1026 if (((temp & PORT_OC) || (ehci->need_oc_pp_cycle)) 1027 && HCS_PPC(ehci->hcs_params)) { 1028 spin_unlock_irqrestore(&ehci->lock, flags); 1029 ehci_port_power(ehci, wIndex, false); 1030 spin_lock_irqsave(&ehci->lock, flags); 1031 temp = ehci_readl(ehci, status_reg); 1032 } 1033 } 1034 1035 /* no reset or resume pending */ 1036 if (!ehci->reset_done[wIndex]) { 1037 1038 /* Remote Wakeup received? */ 1039 if (temp & PORT_RESUME) { 1040 /* resume signaling for 20 msec */ 1041 ehci->reset_done[wIndex] = jiffies 1042 + msecs_to_jiffies(20); 1043 usb_hcd_start_port_resume(&hcd->self, wIndex); 1044 set_bit(wIndex, &ehci->resuming_ports); 1045 /* check the port again */ 1046 mod_timer(&ehci_to_hcd(ehci)->rh_timer, 1047 ehci->reset_done[wIndex]); 1048 } 1049 1050 /* reset or resume not yet complete */ 1051 } else if (!time_after_eq(jiffies, ehci->reset_done[wIndex])) { 1052 ; /* wait until it is complete */ 1053 1054 /* resume completed */ 1055 } else if (test_bit(wIndex, &ehci->resuming_ports)) { 1056 clear_bit(wIndex, &ehci->suspended_ports); 1057 set_bit(wIndex, &ehci->port_c_suspend); 1058 ehci->reset_done[wIndex] = 0; 1059 usb_hcd_end_port_resume(&hcd->self, wIndex); 1060 1061 /* stop resume signaling */ 1062 temp &= ~(PORT_RWC_BITS | PORT_SUSPEND | PORT_RESUME); 1063 ehci_writel(ehci, temp, status_reg); 1064 clear_bit(wIndex, &ehci->resuming_ports); 1065 retval = ehci_handshake(ehci, status_reg, 1066 PORT_RESUME, 0, 2000 /* 2msec */); 1067 if (retval != 0) { 1068 ehci_err(ehci, "port %d resume error %d\n", 1069 wIndex + 1, retval); 1070 goto error; 1071 } 1072 temp = ehci_readl(ehci, status_reg); 1073 1074 /* whoever resets must GetPortStatus to complete it!! */ 1075 } else { 1076 status |= USB_PORT_STAT_C_RESET << 16; 1077 ehci->reset_done [wIndex] = 0; 1078 1079 /* force reset to complete */ 1080 ehci_writel(ehci, temp & ~(PORT_RWC_BITS | PORT_RESET), 1081 status_reg); 1082 /* REVISIT: some hardware needs 550+ usec to clear 1083 * this bit; seems too long to spin routinely... 1084 */ 1085 retval = ehci_handshake(ehci, status_reg, 1086 PORT_RESET, 0, 1000); 1087 if (retval != 0) { 1088 ehci_err (ehci, "port %d reset error %d\n", 1089 wIndex + 1, retval); 1090 goto error; 1091 } 1092 1093 /* see what we found out */ 1094 temp = check_reset_complete (ehci, wIndex, status_reg, 1095 ehci_readl(ehci, status_reg)); 1096 } 1097 1098 /* transfer dedicated ports to the companion hc */ 1099 if ((temp & PORT_CONNECT) && 1100 test_bit(wIndex, &ehci->companion_ports)) { 1101 temp &= ~PORT_RWC_BITS; 1102 temp |= PORT_OWNER; 1103 ehci_writel(ehci, temp, status_reg); 1104 ehci_dbg(ehci, "port %d --> companion\n", wIndex + 1); 1105 temp = ehci_readl(ehci, status_reg); 1106 } 1107 1108 /* 1109 * Even if OWNER is set, there's no harm letting hub_wq 1110 * see the wPortStatus values (they should all be 0 except 1111 * for PORT_POWER anyway). 1112 */ 1113 1114 if (temp & PORT_CONNECT) { 1115 status |= USB_PORT_STAT_CONNECTION; 1116 // status may be from integrated TT 1117 if (ehci->has_hostpc) { 1118 temp1 = ehci_readl(ehci, hostpc_reg); 1119 status |= ehci_port_speed(ehci, temp1); 1120 } else 1121 status |= ehci_port_speed(ehci, temp); 1122 } 1123 if (temp & PORT_PE) 1124 status |= USB_PORT_STAT_ENABLE; 1125 1126 /* maybe the port was unsuspended without our knowledge */ 1127 if (temp & (PORT_SUSPEND|PORT_RESUME)) { 1128 status |= USB_PORT_STAT_SUSPEND; 1129 } else if (test_bit(wIndex, &ehci->suspended_ports)) { 1130 clear_bit(wIndex, &ehci->suspended_ports); 1131 clear_bit(wIndex, &ehci->resuming_ports); 1132 ehci->reset_done[wIndex] = 0; 1133 if (temp & PORT_PE) 1134 set_bit(wIndex, &ehci->port_c_suspend); 1135 usb_hcd_end_port_resume(&hcd->self, wIndex); 1136 } 1137 1138 if (temp & PORT_OC) 1139 status |= USB_PORT_STAT_OVERCURRENT; 1140 if (temp & PORT_RESET) 1141 status |= USB_PORT_STAT_RESET; 1142 if (temp & PORT_POWER) 1143 status |= USB_PORT_STAT_POWER; 1144 if (test_bit(wIndex, &ehci->port_c_suspend)) 1145 status |= USB_PORT_STAT_C_SUSPEND << 16; 1146 1147 if (status & ~0xffff) /* only if wPortChange is interesting */ 1148 dbg_port(ehci, "GetStatus", wIndex + 1, temp); 1149 put_unaligned_le32(status, buf); 1150 break; 1151 case SetHubFeature: 1152 switch (wValue) { 1153 case C_HUB_LOCAL_POWER: 1154 case C_HUB_OVER_CURRENT: 1155 /* no hub-wide feature/status flags */ 1156 break; 1157 default: 1158 goto error; 1159 } 1160 break; 1161 case SetPortFeature: 1162 selector = wIndex >> 8; 1163 wIndex &= 0xff; 1164 if (unlikely(ehci->debug)) { 1165 /* If the debug port is active any port 1166 * feature requests should get denied */ 1167 if (wIndex == HCS_DEBUG_PORT(ehci->hcs_params) && 1168 (readl(&ehci->debug->control) & DBGP_ENABLED)) { 1169 retval = -ENODEV; 1170 goto error_exit; 1171 } 1172 } 1173 if (!wIndex || wIndex > ports) 1174 goto error; 1175 wIndex--; 1176 temp = ehci_readl(ehci, status_reg); 1177 if (temp & PORT_OWNER) 1178 break; 1179 1180 temp &= ~PORT_RWC_BITS; 1181 switch (wValue) { 1182 case USB_PORT_FEAT_SUSPEND: 1183 if (ehci->no_selective_suspend) 1184 break; 1185 if ((temp & PORT_PE) == 0 1186 || (temp & PORT_RESET) != 0) 1187 goto error; 1188 1189 /* After above check the port must be connected. 1190 * Set appropriate bit thus could put phy into low power 1191 * mode if we have tdi_phy_lpm feature 1192 */ 1193 temp &= ~PORT_WKCONN_E; 1194 temp |= PORT_WKDISC_E | PORT_WKOC_E; 1195 ehci_writel(ehci, temp | PORT_SUSPEND, status_reg); 1196 if (ehci->has_tdi_phy_lpm) { 1197 spin_unlock_irqrestore(&ehci->lock, flags); 1198 msleep(5);/* 5ms for HCD enter low pwr mode */ 1199 spin_lock_irqsave(&ehci->lock, flags); 1200 temp1 = ehci_readl(ehci, hostpc_reg); 1201 ehci_writel(ehci, temp1 | HOSTPC_PHCD, 1202 hostpc_reg); 1203 temp1 = ehci_readl(ehci, hostpc_reg); 1204 ehci_dbg(ehci, "Port%d phy low pwr mode %s\n", 1205 wIndex, (temp1 & HOSTPC_PHCD) ? 1206 "succeeded" : "failed"); 1207 } 1208 if (ehci_has_fsl_susp_errata(ehci)) { 1209 /* 10ms for HCD enter suspend */ 1210 spin_unlock_irqrestore(&ehci->lock, flags); 1211 usleep_range(10000, 20000); 1212 spin_lock_irqsave(&ehci->lock, flags); 1213 } 1214 set_bit(wIndex, &ehci->suspended_ports); 1215 break; 1216 case USB_PORT_FEAT_POWER: 1217 if (HCS_PPC(ehci->hcs_params)) { 1218 spin_unlock_irqrestore(&ehci->lock, flags); 1219 ehci_port_power(ehci, wIndex, true); 1220 spin_lock_irqsave(&ehci->lock, flags); 1221 } 1222 break; 1223 case USB_PORT_FEAT_RESET: 1224 if (temp & (PORT_SUSPEND|PORT_RESUME)) 1225 goto error; 1226 /* line status bits may report this as low speed, 1227 * which can be fine if this root hub has a 1228 * transaction translator built in. 1229 */ 1230 if ((temp & (PORT_PE|PORT_CONNECT)) == PORT_CONNECT 1231 && !ehci_is_TDI(ehci) 1232 && PORT_USB11 (temp)) { 1233 ehci_dbg (ehci, 1234 "port %d low speed --> companion\n", 1235 wIndex + 1); 1236 temp |= PORT_OWNER; 1237 } else { 1238 temp |= PORT_RESET; 1239 temp &= ~PORT_PE; 1240 1241 /* 1242 * caller must wait, then call GetPortStatus 1243 * usb 2.0 spec says 50 ms resets on root 1244 */ 1245 ehci->reset_done [wIndex] = jiffies 1246 + msecs_to_jiffies (50); 1247 1248 /* 1249 * Force full-speed connect for FSL high-speed 1250 * erratum; disable HS Chirp by setting PFSC bit 1251 */ 1252 if (ehci_has_fsl_hs_errata(ehci)) 1253 temp |= (1 << PORTSC_FSL_PFSC); 1254 } 1255 ehci_writel(ehci, temp, status_reg); 1256 break; 1257 1258 /* For downstream facing ports (these): one hub port is put 1259 * into test mode according to USB2 11.24.2.13, then the hub 1260 * must be reset (which for root hub now means rmmod+modprobe, 1261 * or else system reboot). See EHCI 2.3.9 and 4.14 for info 1262 * about the EHCI-specific stuff. 1263 */ 1264 case USB_PORT_FEAT_TEST: 1265#ifdef CONFIG_USB_HCD_TEST_MODE 1266 if (selector == EHSET_TEST_SINGLE_STEP_SET_FEATURE) { 1267 spin_unlock_irqrestore(&ehci->lock, flags); 1268 retval = ehset_single_step_set_feature(hcd, 1269 wIndex + 1); 1270 spin_lock_irqsave(&ehci->lock, flags); 1271 break; 1272 } 1273#endif 1274 if (!selector || selector > 5) 1275 goto error; 1276 spin_unlock_irqrestore(&ehci->lock, flags); 1277 ehci_quiesce(ehci); 1278 spin_lock_irqsave(&ehci->lock, flags); 1279 1280 /* Put all enabled ports into suspend */ 1281 while (ports--) { 1282 u32 __iomem *sreg = 1283 &ehci->regs->port_status[ports]; 1284 1285 temp = ehci_readl(ehci, sreg) & ~PORT_RWC_BITS; 1286 if (temp & PORT_PE) 1287 ehci_writel(ehci, temp | PORT_SUSPEND, 1288 sreg); 1289 } 1290 1291 spin_unlock_irqrestore(&ehci->lock, flags); 1292 ehci_halt(ehci); 1293 spin_lock_irqsave(&ehci->lock, flags); 1294 1295 temp = ehci_readl(ehci, status_reg); 1296 temp |= selector << 16; 1297 ehci_writel(ehci, temp, status_reg); 1298 break; 1299 1300 default: 1301 goto error; 1302 } 1303 ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */ 1304 break; 1305 1306 default: 1307error: 1308 /* "stall" on error */ 1309 retval = -EPIPE; 1310 } 1311error_exit: 1312 spin_unlock_irqrestore (&ehci->lock, flags); 1313 return retval; 1314} 1315EXPORT_SYMBOL_GPL(ehci_hub_control); 1316 1317static void ehci_relinquish_port(struct usb_hcd *hcd, int portnum) 1318{ 1319 struct ehci_hcd *ehci = hcd_to_ehci(hcd); 1320 1321 if (ehci_is_TDI(ehci)) 1322 return; 1323 set_owner(ehci, --portnum, PORT_OWNER); 1324} 1325 1326static int ehci_port_handed_over(struct usb_hcd *hcd, int portnum) 1327{ 1328 struct ehci_hcd *ehci = hcd_to_ehci(hcd); 1329 u32 __iomem *reg; 1330 1331 if (ehci_is_TDI(ehci)) 1332 return 0; 1333 reg = &ehci->regs->port_status[portnum - 1]; 1334 return ehci_readl(ehci, reg) & PORT_OWNER; 1335} 1336 1337static int ehci_port_power(struct ehci_hcd *ehci, int portnum, bool enable) 1338{ 1339 struct usb_hcd *hcd = ehci_to_hcd(ehci); 1340 u32 __iomem *status_reg = &ehci->regs->port_status[portnum]; 1341 u32 temp = ehci_readl(ehci, status_reg) & ~PORT_RWC_BITS; 1342 1343 if (enable) 1344 ehci_writel(ehci, temp | PORT_POWER, status_reg); 1345 else 1346 ehci_writel(ehci, temp & ~PORT_POWER, status_reg); 1347 1348 if (hcd->driver->port_power) 1349 hcd->driver->port_power(hcd, portnum, enable); 1350 1351 return 0; 1352} 1353