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 #ifdef CONFIG_USB_PERSIST 32 33 static int ehci_hub_control( 34 struct usb_hcd *hcd, 35 u16 typeReq, 36 u16 wValue, 37 u16 wIndex, 38 char *buf, 39 u16 wLength 40 ); 41 42 /* After a power loss, ports that were owned by the companion must be 43 * reset so that the companion can still own them. 44 */ 45 static void ehci_handover_companion_ports(struct ehci_hcd *ehci) 46 { 47 u32 __iomem *reg; 48 u32 status; 49 int port; 50 __le32 buf; 51 struct usb_hcd *hcd = ehci_to_hcd(ehci); 52 53 if (!ehci->owned_ports) 54 return; 55 56 /* Give the connections some time to appear */ 57 msleep(20); 58 59 port = HCS_N_PORTS(ehci->hcs_params); 60 while (port--) { 61 if (test_bit(port, &ehci->owned_ports)) { 62 reg = &ehci->regs->port_status[port]; 63 status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS; 64 65 /* Port already owned by companion? */ 66 if (status & PORT_OWNER) 67 clear_bit(port, &ehci->owned_ports); 68 else if (test_bit(port, &ehci->companion_ports)) 69 ehci_writel(ehci, status & ~PORT_PE, reg); 70 else 71 ehci_hub_control(hcd, SetPortFeature, 72 USB_PORT_FEAT_RESET, port + 1, 73 NULL, 0); 74 } 75 } 76 77 if (!ehci->owned_ports) 78 return; 79 msleep(90); /* Wait for resets to complete */ 80 81 port = HCS_N_PORTS(ehci->hcs_params); 82 while (port--) { 83 if (test_bit(port, &ehci->owned_ports)) { 84 ehci_hub_control(hcd, GetPortStatus, 85 0, port + 1, 86 (char *) &buf, sizeof(buf)); 87 88 /* The companion should now own the port, 89 * but if something went wrong the port must not 90 * remain enabled. 91 */ 92 reg = &ehci->regs->port_status[port]; 93 status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS; 94 if (status & PORT_OWNER) 95 ehci_writel(ehci, status | PORT_CSC, reg); 96 else { 97 ehci_dbg(ehci, "failed handover port %d: %x\n", 98 port + 1, status); 99 ehci_writel(ehci, status & ~PORT_PE, reg); 100 } 101 } 102 } 103 104 ehci->owned_ports = 0; 105 } 106 107 #else /* CONFIG_USB_PERSIST */ 108 109 static inline void ehci_handover_companion_ports(struct ehci_hcd *ehci) 110 { } 111 112 #endif 113 114 #ifdef CONFIG_PM 115 116 static int ehci_bus_suspend (struct usb_hcd *hcd) 117 { 118 struct ehci_hcd *ehci = hcd_to_ehci (hcd); 119 int port; 120 int mask; 121 122 ehci_dbg(ehci, "suspend root hub\n"); 123 124 if (time_before (jiffies, ehci->next_statechange)) 125 msleep(5); 126 127 port = HCS_N_PORTS (ehci->hcs_params); 128 spin_lock_irq (&ehci->lock); 129 130 /* stop schedules, clean any completed work */ 131 if (HC_IS_RUNNING(hcd->state)) { 132 ehci_quiesce (ehci); 133 hcd->state = HC_STATE_QUIESCING; 134 } 135 ehci->command = ehci_readl(ehci, &ehci->regs->command); 136 if (ehci->reclaim) 137 ehci->reclaim_ready = 1; 138 ehci_work(ehci); 139 140 /* Unlike other USB host controller types, EHCI doesn't have 141 * any notion of "global" or bus-wide suspend. The driver has 142 * to manually suspend all the active unsuspended ports, and 143 * then manually resume them in the bus_resume() routine. 144 */ 145 ehci->bus_suspended = 0; 146 ehci->owned_ports = 0; 147 while (port--) { 148 u32 __iomem *reg = &ehci->regs->port_status [port]; 149 u32 t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS; 150 u32 t2 = t1; 151 152 /* keep track of which ports we suspend */ 153 if (t1 & PORT_OWNER) 154 set_bit(port, &ehci->owned_ports); 155 else if ((t1 & PORT_PE) && !(t1 & PORT_SUSPEND)) { 156 t2 |= PORT_SUSPEND; 157 set_bit(port, &ehci->bus_suspended); 158 } 159 160 /* enable remote wakeup on all ports */ 161 if (device_may_wakeup(&hcd->self.root_hub->dev)) 162 t2 |= PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E; 163 else 164 t2 &= ~(PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E); 165 166 if (t1 != t2) { 167 ehci_vdbg (ehci, "port %d, %08x -> %08x\n", 168 port + 1, t1, t2); 169 ehci_writel(ehci, t2, reg); 170 } 171 } 172 173 /* turn off now-idle HC */ 174 del_timer_sync (&ehci->watchdog); 175 ehci_halt (ehci); 176 hcd->state = HC_STATE_SUSPENDED; 177 178 /* allow remote wakeup */ 179 mask = INTR_MASK; 180 if (!device_may_wakeup(&hcd->self.root_hub->dev)) 181 mask &= ~STS_PCD; 182 ehci_writel(ehci, mask, &ehci->regs->intr_enable); 183 ehci_readl(ehci, &ehci->regs->intr_enable); 184 185 ehci->next_statechange = jiffies + msecs_to_jiffies(10); 186 spin_unlock_irq (&ehci->lock); 187 return 0; 188 } 189 190 191 /* caller has locked the root hub, and should reset/reinit on error */ 192 static int ehci_bus_resume (struct usb_hcd *hcd) 193 { 194 struct ehci_hcd *ehci = hcd_to_ehci (hcd); 195 u32 temp; 196 u32 power_okay; 197 int i; 198 199 if (time_before (jiffies, ehci->next_statechange)) 200 msleep(5); 201 spin_lock_irq (&ehci->lock); 202 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) { 203 spin_unlock_irq(&ehci->lock); 204 return -ESHUTDOWN; 205 } 206 207 /* Ideally and we've got a real resume here, and no port's power 208 * was lost. (For PCI, that means Vaux was maintained.) But we 209 * could instead be restoring a swsusp snapshot -- so that BIOS was 210 * the last user of the controller, not reset/pm hardware keeping 211 * state we gave to it. 212 */ 213 power_okay = ehci_readl(ehci, &ehci->regs->intr_enable); 214 ehci_dbg(ehci, "resume root hub%s\n", 215 power_okay ? "" : " after power loss"); 216 217 /* at least some APM implementations will try to deliver 218 * IRQs right away, so delay them until we're ready. 219 */ 220 ehci_writel(ehci, 0, &ehci->regs->intr_enable); 221 222 /* re-init operational registers */ 223 ehci_writel(ehci, 0, &ehci->regs->segment); 224 ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list); 225 ehci_writel(ehci, (u32) ehci->async->qh_dma, &ehci->regs->async_next); 226 227 /* restore CMD_RUN, framelist size, and irq threshold */ 228 ehci_writel(ehci, ehci->command, &ehci->regs->command); 229 230 /* Some controller/firmware combinations need a delay during which 231 * they set up the port statuses. See Bugzilla #8190. */ 232 mdelay(8); 233 234 /* manually resume the ports we suspended during bus_suspend() */ 235 i = HCS_N_PORTS (ehci->hcs_params); 236 while (i--) { 237 temp = ehci_readl(ehci, &ehci->regs->port_status [i]); 238 temp &= ~(PORT_RWC_BITS 239 | PORT_WKOC_E | PORT_WKDISC_E | PORT_WKCONN_E); 240 if (test_bit(i, &ehci->bus_suspended) && 241 (temp & PORT_SUSPEND)) { 242 ehci->reset_done [i] = jiffies + msecs_to_jiffies (20); 243 temp |= PORT_RESUME; 244 } 245 ehci_writel(ehci, temp, &ehci->regs->port_status [i]); 246 } 247 i = HCS_N_PORTS (ehci->hcs_params); 248 mdelay (20); 249 while (i--) { 250 temp = ehci_readl(ehci, &ehci->regs->port_status [i]); 251 if (test_bit(i, &ehci->bus_suspended) && 252 (temp & PORT_SUSPEND)) { 253 temp &= ~(PORT_RWC_BITS | PORT_RESUME); 254 ehci_writel(ehci, temp, &ehci->regs->port_status [i]); 255 ehci_vdbg (ehci, "resumed port %d\n", i + 1); 256 } 257 } 258 (void) ehci_readl(ehci, &ehci->regs->command); 259 260 /* maybe re-activate the schedule(s) */ 261 temp = 0; 262 if (ehci->async->qh_next.qh) 263 temp |= CMD_ASE; 264 if (ehci->periodic_sched) 265 temp |= CMD_PSE; 266 if (temp) { 267 ehci->command |= temp; 268 ehci_writel(ehci, ehci->command, &ehci->regs->command); 269 } 270 271 ehci->next_statechange = jiffies + msecs_to_jiffies(5); 272 hcd->state = HC_STATE_RUNNING; 273 274 /* Now we can safely re-enable irqs */ 275 ehci_writel(ehci, INTR_MASK, &ehci->regs->intr_enable); 276 277 spin_unlock_irq (&ehci->lock); 278 279 if (!power_okay) 280 ehci_handover_companion_ports(ehci); 281 return 0; 282 } 283 284 #else 285 286 #define ehci_bus_suspend NULL 287 #define ehci_bus_resume NULL 288 289 #endif /* CONFIG_PM */ 290 291 /*-------------------------------------------------------------------------*/ 292 293 /* Display the ports dedicated to the companion controller */ 294 static ssize_t show_companion(struct class_device *class_dev, char *buf) 295 { 296 struct ehci_hcd *ehci; 297 int nports, index, n; 298 int count = PAGE_SIZE; 299 char *ptr = buf; 300 301 ehci = hcd_to_ehci(bus_to_hcd(class_get_devdata(class_dev))); 302 nports = HCS_N_PORTS(ehci->hcs_params); 303 304 for (index = 0; index < nports; ++index) { 305 if (test_bit(index, &ehci->companion_ports)) { 306 n = scnprintf(ptr, count, "%d\n", index + 1); 307 ptr += n; 308 count -= n; 309 } 310 } 311 return ptr - buf; 312 } 313 314 /* 315 * Dedicate or undedicate a port to the companion controller. 316 * Syntax is "[-]portnum", where a leading '-' sign means 317 * return control of the port to the EHCI controller. 318 */ 319 static ssize_t store_companion(struct class_device *class_dev, 320 const char *buf, size_t count) 321 { 322 struct ehci_hcd *ehci; 323 int portnum, new_owner, try; 324 u32 __iomem *status_reg; 325 u32 port_status; 326 327 ehci = hcd_to_ehci(bus_to_hcd(class_get_devdata(class_dev))); 328 new_owner = PORT_OWNER; /* Owned by companion */ 329 if (sscanf(buf, "%d", &portnum) != 1) 330 return -EINVAL; 331 if (portnum < 0) { 332 portnum = - portnum; 333 new_owner = 0; /* Owned by EHCI */ 334 } 335 if (portnum <= 0 || portnum > HCS_N_PORTS(ehci->hcs_params)) 336 return -ENOENT; 337 status_reg = &ehci->regs->port_status[--portnum]; 338 if (new_owner) 339 set_bit(portnum, &ehci->companion_ports); 340 else 341 clear_bit(portnum, &ehci->companion_ports); 342 343 /* 344 * The controller won't set the OWNER bit if the port is 345 * enabled, so this loop will sometimes require at least two 346 * iterations: one to disable the port and one to set OWNER. 347 */ 348 349 for (try = 4; try > 0; --try) { 350 spin_lock_irq(&ehci->lock); 351 port_status = ehci_readl(ehci, status_reg); 352 if ((port_status & PORT_OWNER) == new_owner 353 || (port_status & (PORT_OWNER | PORT_CONNECT)) 354 == 0) 355 try = 0; 356 else { 357 port_status ^= PORT_OWNER; 358 port_status &= ~(PORT_PE | PORT_RWC_BITS); 359 ehci_writel(ehci, port_status, status_reg); 360 } 361 spin_unlock_irq(&ehci->lock); 362 if (try > 1) 363 msleep(5); 364 } 365 return count; 366 } 367 static CLASS_DEVICE_ATTR(companion, 0644, show_companion, store_companion); 368 369 static inline void create_companion_file(struct ehci_hcd *ehci) 370 { 371 int i; 372 373 /* with integrated TT there is no companion! */ 374 if (!ehci_is_TDI(ehci)) 375 i = class_device_create_file(ehci_to_hcd(ehci)->self.class_dev, 376 &class_device_attr_companion); 377 } 378 379 static inline void remove_companion_file(struct ehci_hcd *ehci) 380 { 381 /* with integrated TT there is no companion! */ 382 if (!ehci_is_TDI(ehci)) 383 class_device_remove_file(ehci_to_hcd(ehci)->self.class_dev, 384 &class_device_attr_companion); 385 } 386 387 388 /*-------------------------------------------------------------------------*/ 389 390 static int check_reset_complete ( 391 struct ehci_hcd *ehci, 392 int index, 393 u32 __iomem *status_reg, 394 int port_status 395 ) { 396 if (!(port_status & PORT_CONNECT)) { 397 ehci->reset_done [index] = 0; 398 return port_status; 399 } 400 401 /* if reset finished and it's still not enabled -- handoff */ 402 if (!(port_status & PORT_PE)) { 403 404 /* with integrated TT, there's nobody to hand it to! */ 405 if (ehci_is_TDI(ehci)) { 406 ehci_dbg (ehci, 407 "Failed to enable port %d on root hub TT\n", 408 index+1); 409 return port_status; 410 } 411 412 ehci_dbg (ehci, "port %d full speed --> companion\n", 413 index + 1); 414 415 // what happens if HCS_N_CC(params) == 0 ? 416 port_status |= PORT_OWNER; 417 port_status &= ~PORT_RWC_BITS; 418 ehci_writel(ehci, port_status, status_reg); 419 420 } else 421 ehci_dbg (ehci, "port %d high speed\n", index + 1); 422 423 return port_status; 424 } 425 426 /*-------------------------------------------------------------------------*/ 427 428 429 /* build "status change" packet (one or two bytes) from HC registers */ 430 431 static int 432 ehci_hub_status_data (struct usb_hcd *hcd, char *buf) 433 { 434 struct ehci_hcd *ehci = hcd_to_ehci (hcd); 435 u32 temp, status = 0; 436 u32 mask; 437 int ports, i, retval = 1; 438 unsigned long flags; 439 440 /* if !USB_SUSPEND, root hub timers won't get shut down ... */ 441 if (!HC_IS_RUNNING(hcd->state)) 442 return 0; 443 444 /* init status to no-changes */ 445 buf [0] = 0; 446 ports = HCS_N_PORTS (ehci->hcs_params); 447 if (ports > 7) { 448 buf [1] = 0; 449 retval++; 450 } 451 452 /* Some boards (mostly VIA?) report bogus overcurrent indications, 453 * causing massive log spam unless we completely ignore them. It 454 * may be relevant that VIA VT8235 controlers, where PORT_POWER is 455 * always set, seem to clear PORT_OCC and PORT_CSC when writing to 456 * PORT_POWER; that's surprising, but maybe within-spec. 457 */ 458 if (!ignore_oc) 459 mask = PORT_CSC | PORT_PEC | PORT_OCC; 460 else 461 mask = PORT_CSC | PORT_PEC; 462 // PORT_RESUME from hardware ~= PORT_STAT_C_SUSPEND 463 464 /* no hub change reports (bit 0) for now (power, ...) */ 465 466 /* port N changes (bit N)? */ 467 spin_lock_irqsave (&ehci->lock, flags); 468 for (i = 0; i < ports; i++) { 469 temp = ehci_readl(ehci, &ehci->regs->port_status [i]); 470 471 /* 472 * Return status information even for ports with OWNER set. 473 * Otherwise khubd wouldn't see the disconnect event when a 474 * high-speed device is switched over to the companion 475 * controller by the user. 476 */ 477 478 if (!(temp & PORT_CONNECT)) 479 ehci->reset_done [i] = 0; 480 if ((temp & mask) != 0 481 || ((temp & PORT_RESUME) != 0 482 && time_after_eq(jiffies, 483 ehci->reset_done[i]))) { 484 if (i < 7) 485 buf [0] |= 1 << (i + 1); 486 else 487 buf [1] |= 1 << (i - 7); 488 status = STS_PCD; 489 } 490 } 491 /* FIXME autosuspend idle root hubs */ 492 spin_unlock_irqrestore (&ehci->lock, flags); 493 return status ? retval : 0; 494 } 495 496 /*-------------------------------------------------------------------------*/ 497 498 static void 499 ehci_hub_descriptor ( 500 struct ehci_hcd *ehci, 501 struct usb_hub_descriptor *desc 502 ) { 503 int ports = HCS_N_PORTS (ehci->hcs_params); 504 u16 temp; 505 506 desc->bDescriptorType = 0x29; 507 desc->bPwrOn2PwrGood = 10; /* ehci 1.0, 2.3.9 says 20ms max */ 508 desc->bHubContrCurrent = 0; 509 510 desc->bNbrPorts = ports; 511 temp = 1 + (ports / 8); 512 desc->bDescLength = 7 + 2 * temp; 513 514 /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */ 515 memset (&desc->bitmap [0], 0, temp); 516 memset (&desc->bitmap [temp], 0xff, temp); 517 518 temp = 0x0008; /* per-port overcurrent reporting */ 519 if (HCS_PPC (ehci->hcs_params)) 520 temp |= 0x0001; /* per-port power control */ 521 else 522 temp |= 0x0002; /* no power switching */ 523 #if 0 524 // re-enable when we support USB_PORT_FEAT_INDICATOR below. 525 if (HCS_INDICATOR (ehci->hcs_params)) 526 temp |= 0x0080; /* per-port indicators (LEDs) */ 527 #endif 528 desc->wHubCharacteristics = (__force __u16)cpu_to_le16 (temp); 529 } 530 531 /*-------------------------------------------------------------------------*/ 532 533 #define PORT_WAKE_BITS (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E) 534 535 static int ehci_hub_control ( 536 struct usb_hcd *hcd, 537 u16 typeReq, 538 u16 wValue, 539 u16 wIndex, 540 char *buf, 541 u16 wLength 542 ) { 543 struct ehci_hcd *ehci = hcd_to_ehci (hcd); 544 int ports = HCS_N_PORTS (ehci->hcs_params); 545 u32 __iomem *status_reg = &ehci->regs->port_status[ 546 (wIndex & 0xff) - 1]; 547 u32 temp, status; 548 unsigned long flags; 549 int retval = 0; 550 unsigned selector; 551 552 /* 553 * FIXME: support SetPortFeatures USB_PORT_FEAT_INDICATOR. 554 * HCS_INDICATOR may say we can change LEDs to off/amber/green. 555 * (track current state ourselves) ... blink for diagnostics, 556 * power, "this is the one", etc. EHCI spec supports this. 557 */ 558 559 spin_lock_irqsave (&ehci->lock, flags); 560 switch (typeReq) { 561 case ClearHubFeature: 562 switch (wValue) { 563 case C_HUB_LOCAL_POWER: 564 case C_HUB_OVER_CURRENT: 565 /* no hub-wide feature/status flags */ 566 break; 567 default: 568 goto error; 569 } 570 break; 571 case ClearPortFeature: 572 if (!wIndex || wIndex > ports) 573 goto error; 574 wIndex--; 575 temp = ehci_readl(ehci, status_reg); 576 577 /* 578 * Even if OWNER is set, so the port is owned by the 579 * companion controller, khubd needs to be able to clear 580 * the port-change status bits (especially 581 * USB_PORT_FEAT_C_CONNECTION). 582 */ 583 584 switch (wValue) { 585 case USB_PORT_FEAT_ENABLE: 586 ehci_writel(ehci, temp & ~PORT_PE, status_reg); 587 break; 588 case USB_PORT_FEAT_C_ENABLE: 589 ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_PEC, 590 status_reg); 591 break; 592 case USB_PORT_FEAT_SUSPEND: 593 if (temp & PORT_RESET) 594 goto error; 595 if (ehci->no_selective_suspend) 596 break; 597 if (temp & PORT_SUSPEND) { 598 if ((temp & PORT_PE) == 0) 599 goto error; 600 /* resume signaling for 20 msec */ 601 temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS); 602 ehci_writel(ehci, temp | PORT_RESUME, 603 status_reg); 604 ehci->reset_done [wIndex] = jiffies 605 + msecs_to_jiffies (20); 606 } 607 break; 608 case USB_PORT_FEAT_C_SUSPEND: 609 /* we auto-clear this feature */ 610 break; 611 case USB_PORT_FEAT_POWER: 612 if (HCS_PPC (ehci->hcs_params)) 613 ehci_writel(ehci, 614 temp & ~(PORT_RWC_BITS | PORT_POWER), 615 status_reg); 616 break; 617 case USB_PORT_FEAT_C_CONNECTION: 618 ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_CSC, 619 status_reg); 620 break; 621 case USB_PORT_FEAT_C_OVER_CURRENT: 622 ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_OCC, 623 status_reg); 624 break; 625 case USB_PORT_FEAT_C_RESET: 626 /* GetPortStatus clears reset */ 627 break; 628 default: 629 goto error; 630 } 631 ehci_readl(ehci, &ehci->regs->command); /* unblock posted write */ 632 break; 633 case GetHubDescriptor: 634 ehci_hub_descriptor (ehci, (struct usb_hub_descriptor *) 635 buf); 636 break; 637 case GetHubStatus: 638 /* no hub-wide feature/status flags */ 639 memset (buf, 0, 4); 640 //cpu_to_le32s ((u32 *) buf); 641 break; 642 case GetPortStatus: 643 if (!wIndex || wIndex > ports) 644 goto error; 645 wIndex--; 646 status = 0; 647 temp = ehci_readl(ehci, status_reg); 648 649 // wPortChange bits 650 if (temp & PORT_CSC) 651 status |= 1 << USB_PORT_FEAT_C_CONNECTION; 652 if (temp & PORT_PEC) 653 status |= 1 << USB_PORT_FEAT_C_ENABLE; 654 655 if ((temp & PORT_OCC) && !ignore_oc){ 656 status |= 1 << USB_PORT_FEAT_C_OVER_CURRENT; 657 658 /* 659 * Hubs should disable port power on over-current. 660 * However, not all EHCI implementations do this 661 * automatically, even if they _do_ support per-port 662 * power switching; they're allowed to just limit the 663 * current. khubd will turn the power back on. 664 */ 665 if (HCS_PPC (ehci->hcs_params)){ 666 ehci_writel(ehci, 667 temp & ~(PORT_RWC_BITS | PORT_POWER), 668 status_reg); 669 } 670 } 671 672 /* whoever resumes must GetPortStatus to complete it!! */ 673 if (temp & PORT_RESUME) { 674 675 /* Remote Wakeup received? */ 676 if (!ehci->reset_done[wIndex]) { 677 /* resume signaling for 20 msec */ 678 ehci->reset_done[wIndex] = jiffies 679 + msecs_to_jiffies(20); 680 /* check the port again */ 681 mod_timer(&ehci_to_hcd(ehci)->rh_timer, 682 ehci->reset_done[wIndex]); 683 } 684 685 /* resume completed? */ 686 else if (time_after_eq(jiffies, 687 ehci->reset_done[wIndex])) { 688 status |= 1 << USB_PORT_FEAT_C_SUSPEND; 689 ehci->reset_done[wIndex] = 0; 690 691 /* stop resume signaling */ 692 temp = ehci_readl(ehci, status_reg); 693 ehci_writel(ehci, 694 temp & ~(PORT_RWC_BITS | PORT_RESUME), 695 status_reg); 696 retval = handshake(ehci, status_reg, 697 PORT_RESUME, 0, 2000 /* 2msec */); 698 if (retval != 0) { 699 ehci_err(ehci, 700 "port %d resume error %d\n", 701 wIndex + 1, retval); 702 goto error; 703 } 704 temp &= ~(PORT_SUSPEND|PORT_RESUME|(3<<10)); 705 } 706 } 707 708 /* whoever resets must GetPortStatus to complete it!! */ 709 if ((temp & PORT_RESET) 710 && time_after_eq(jiffies, 711 ehci->reset_done[wIndex])) { 712 status |= 1 << USB_PORT_FEAT_C_RESET; 713 ehci->reset_done [wIndex] = 0; 714 715 /* force reset to complete */ 716 ehci_writel(ehci, temp & ~(PORT_RWC_BITS | PORT_RESET), 717 status_reg); 718 /* REVISIT: some hardware needs 550+ usec to clear 719 * this bit; seems too long to spin routinely... 720 */ 721 retval = handshake(ehci, status_reg, 722 PORT_RESET, 0, 750); 723 if (retval != 0) { 724 ehci_err (ehci, "port %d reset error %d\n", 725 wIndex + 1, retval); 726 goto error; 727 } 728 729 /* see what we found out */ 730 temp = check_reset_complete (ehci, wIndex, status_reg, 731 ehci_readl(ehci, status_reg)); 732 } 733 734 /* transfer dedicated ports to the companion hc */ 735 if ((temp & PORT_CONNECT) && 736 test_bit(wIndex, &ehci->companion_ports)) { 737 temp &= ~PORT_RWC_BITS; 738 temp |= PORT_OWNER; 739 ehci_writel(ehci, temp, status_reg); 740 ehci_dbg(ehci, "port %d --> companion\n", wIndex + 1); 741 temp = ehci_readl(ehci, status_reg); 742 } 743 744 /* 745 * Even if OWNER is set, there's no harm letting khubd 746 * see the wPortStatus values (they should all be 0 except 747 * for PORT_POWER anyway). 748 */ 749 750 if (temp & PORT_CONNECT) { 751 status |= 1 << USB_PORT_FEAT_CONNECTION; 752 // status may be from integrated TT 753 status |= ehci_port_speed(ehci, temp); 754 } 755 if (temp & PORT_PE) 756 status |= 1 << USB_PORT_FEAT_ENABLE; 757 if (temp & (PORT_SUSPEND|PORT_RESUME)) 758 status |= 1 << USB_PORT_FEAT_SUSPEND; 759 if (temp & PORT_OC) 760 status |= 1 << USB_PORT_FEAT_OVER_CURRENT; 761 if (temp & PORT_RESET) 762 status |= 1 << USB_PORT_FEAT_RESET; 763 if (temp & PORT_POWER) 764 status |= 1 << USB_PORT_FEAT_POWER; 765 766 #ifndef EHCI_VERBOSE_DEBUG 767 if (status & ~0xffff) /* only if wPortChange is interesting */ 768 #endif 769 dbg_port (ehci, "GetStatus", wIndex + 1, temp); 770 put_unaligned(cpu_to_le32 (status), (__le32 *) buf); 771 break; 772 case SetHubFeature: 773 switch (wValue) { 774 case C_HUB_LOCAL_POWER: 775 case C_HUB_OVER_CURRENT: 776 /* no hub-wide feature/status flags */ 777 break; 778 default: 779 goto error; 780 } 781 break; 782 case SetPortFeature: 783 selector = wIndex >> 8; 784 wIndex &= 0xff; 785 if (!wIndex || wIndex > ports) 786 goto error; 787 wIndex--; 788 temp = ehci_readl(ehci, status_reg); 789 if (temp & PORT_OWNER) 790 break; 791 792 temp &= ~PORT_RWC_BITS; 793 switch (wValue) { 794 case USB_PORT_FEAT_SUSPEND: 795 if (ehci->no_selective_suspend) 796 break; 797 if ((temp & PORT_PE) == 0 798 || (temp & PORT_RESET) != 0) 799 goto error; 800 if (device_may_wakeup(&hcd->self.root_hub->dev)) 801 temp |= PORT_WAKE_BITS; 802 ehci_writel(ehci, temp | PORT_SUSPEND, status_reg); 803 break; 804 case USB_PORT_FEAT_POWER: 805 if (HCS_PPC (ehci->hcs_params)) 806 ehci_writel(ehci, temp | PORT_POWER, 807 status_reg); 808 break; 809 case USB_PORT_FEAT_RESET: 810 if (temp & PORT_RESUME) 811 goto error; 812 /* line status bits may report this as low speed, 813 * which can be fine if this root hub has a 814 * transaction translator built in. 815 */ 816 if ((temp & (PORT_PE|PORT_CONNECT)) == PORT_CONNECT 817 && !ehci_is_TDI(ehci) 818 && PORT_USB11 (temp)) { 819 ehci_dbg (ehci, 820 "port %d low speed --> companion\n", 821 wIndex + 1); 822 temp |= PORT_OWNER; 823 } else { 824 ehci_vdbg (ehci, "port %d reset\n", wIndex + 1); 825 temp |= PORT_RESET; 826 temp &= ~PORT_PE; 827 828 /* 829 * caller must wait, then call GetPortStatus 830 * usb 2.0 spec says 50 ms resets on root 831 */ 832 ehci->reset_done [wIndex] = jiffies 833 + msecs_to_jiffies (50); 834 } 835 ehci_writel(ehci, temp, status_reg); 836 break; 837 838 /* For downstream facing ports (these): one hub port is put 839 * into test mode according to USB2 11.24.2.13, then the hub 840 * must be reset (which for root hub now means rmmod+modprobe, 841 * or else system reboot). See EHCI 2.3.9 and 4.14 for info 842 * about the EHCI-specific stuff. 843 */ 844 case USB_PORT_FEAT_TEST: 845 if (!selector || selector > 5) 846 goto error; 847 ehci_quiesce(ehci); 848 ehci_halt(ehci); 849 temp |= selector << 16; 850 ehci_writel(ehci, temp, status_reg); 851 break; 852 853 default: 854 goto error; 855 } 856 ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */ 857 break; 858 859 default: 860 error: 861 /* "stall" on error */ 862 retval = -EPIPE; 863 } 864 spin_unlock_irqrestore (&ehci->lock, flags); 865 return retval; 866 } 867