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