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