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