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