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