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