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