1 /* 2 * OHCI HCD (Host Controller Driver) for USB. 3 * 4 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at> 5 * (C) Copyright 2000-2004 David Brownell <dbrownell@users.sourceforge.net> 6 * 7 * This file is licenced under GPL 8 */ 9 10 /*-------------------------------------------------------------------------*/ 11 12 /* 13 * OHCI Root Hub ... the nonsharable stuff 14 */ 15 16 #define dbg_port(hc,label,num,value) \ 17 ohci_dbg (hc, \ 18 "%s roothub.portstatus [%d] " \ 19 "= 0x%08x%s%s%s%s%s%s%s%s%s%s%s%s\n", \ 20 label, num, temp, \ 21 (temp & RH_PS_PRSC) ? " PRSC" : "", \ 22 (temp & RH_PS_OCIC) ? " OCIC" : "", \ 23 (temp & RH_PS_PSSC) ? " PSSC" : "", \ 24 (temp & RH_PS_PESC) ? " PESC" : "", \ 25 (temp & RH_PS_CSC) ? " CSC" : "", \ 26 \ 27 (temp & RH_PS_LSDA) ? " LSDA" : "", \ 28 (temp & RH_PS_PPS) ? " PPS" : "", \ 29 (temp & RH_PS_PRS) ? " PRS" : "", \ 30 (temp & RH_PS_POCI) ? " POCI" : "", \ 31 (temp & RH_PS_PSS) ? " PSS" : "", \ 32 \ 33 (temp & RH_PS_PES) ? " PES" : "", \ 34 (temp & RH_PS_CCS) ? " CCS" : "" \ 35 ); 36 37 /*-------------------------------------------------------------------------*/ 38 39 /* hcd->hub_irq_enable() */ 40 static void ohci_rhsc_enable (struct usb_hcd *hcd) 41 { 42 struct ohci_hcd *ohci = hcd_to_ohci (hcd); 43 44 spin_lock_irq(&ohci->lock); 45 if (!ohci->autostop) 46 del_timer(&hcd->rh_timer); /* Prevent next poll */ 47 ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrenable); 48 spin_unlock_irq(&ohci->lock); 49 } 50 51 #define OHCI_SCHED_ENABLES \ 52 (OHCI_CTRL_CLE|OHCI_CTRL_BLE|OHCI_CTRL_PLE|OHCI_CTRL_IE) 53 54 static void dl_done_list (struct ohci_hcd *); 55 static void finish_unlinks (struct ohci_hcd *, u16); 56 57 #ifdef CONFIG_PM 58 static int ohci_restart(struct ohci_hcd *ohci); 59 60 static int ohci_rh_suspend (struct ohci_hcd *ohci, int autostop) 61 __releases(ohci->lock) 62 __acquires(ohci->lock) 63 { 64 int status = 0; 65 66 ohci->hc_control = ohci_readl (ohci, &ohci->regs->control); 67 switch (ohci->hc_control & OHCI_CTRL_HCFS) { 68 case OHCI_USB_RESUME: 69 ohci_dbg (ohci, "resume/suspend?\n"); 70 ohci->hc_control &= ~OHCI_CTRL_HCFS; 71 ohci->hc_control |= OHCI_USB_RESET; 72 ohci_writel (ohci, ohci->hc_control, &ohci->regs->control); 73 (void) ohci_readl (ohci, &ohci->regs->control); 74 /* FALL THROUGH */ 75 case OHCI_USB_RESET: 76 status = -EBUSY; 77 ohci_dbg (ohci, "needs reinit!\n"); 78 goto done; 79 case OHCI_USB_SUSPEND: 80 if (!ohci->autostop) { 81 ohci_dbg (ohci, "already suspended\n"); 82 goto done; 83 } 84 } 85 ohci_dbg (ohci, "%s root hub\n", 86 autostop ? "auto-stop" : "suspend"); 87 88 /* First stop any processing */ 89 if (!autostop && (ohci->hc_control & OHCI_SCHED_ENABLES)) { 90 ohci->hc_control &= ~OHCI_SCHED_ENABLES; 91 ohci_writel (ohci, ohci->hc_control, &ohci->regs->control); 92 ohci->hc_control = ohci_readl (ohci, &ohci->regs->control); 93 ohci_writel (ohci, OHCI_INTR_SF, &ohci->regs->intrstatus); 94 95 /* sched disables take effect on the next frame, 96 * then the last WDH could take 6+ msec 97 */ 98 ohci_dbg (ohci, "stopping schedules ...\n"); 99 ohci->autostop = 0; 100 spin_unlock_irq (&ohci->lock); 101 msleep (8); 102 spin_lock_irq (&ohci->lock); 103 } 104 dl_done_list (ohci); 105 finish_unlinks (ohci, ohci_frame_no(ohci)); 106 107 /* maybe resume can wake root hub */ 108 if (device_may_wakeup(&ohci_to_hcd(ohci)->self.root_hub->dev) || 109 autostop) 110 ohci->hc_control |= OHCI_CTRL_RWE; 111 else { 112 ohci_writel (ohci, OHCI_INTR_RHSC, &ohci->regs->intrdisable); 113 ohci->hc_control &= ~OHCI_CTRL_RWE; 114 } 115 116 /* Suspend hub ... this is the "global (to this bus) suspend" mode, 117 * which doesn't imply ports will first be individually suspended. 118 */ 119 ohci->hc_control &= ~OHCI_CTRL_HCFS; 120 ohci->hc_control |= OHCI_USB_SUSPEND; 121 ohci_writel (ohci, ohci->hc_control, &ohci->regs->control); 122 (void) ohci_readl (ohci, &ohci->regs->control); 123 124 /* no resumes until devices finish suspending */ 125 if (!autostop) { 126 ohci->next_statechange = jiffies + msecs_to_jiffies (5); 127 ohci->autostop = 0; 128 } 129 130 done: 131 return status; 132 } 133 134 static inline struct ed *find_head (struct ed *ed) 135 { 136 /* for bulk and control lists */ 137 while (ed->ed_prev) 138 ed = ed->ed_prev; 139 return ed; 140 } 141 142 /* caller has locked the root hub */ 143 static int ohci_rh_resume (struct ohci_hcd *ohci) 144 __releases(ohci->lock) 145 __acquires(ohci->lock) 146 { 147 struct usb_hcd *hcd = ohci_to_hcd (ohci); 148 u32 temp, enables; 149 int status = -EINPROGRESS; 150 int autostopped = ohci->autostop; 151 152 ohci->autostop = 0; 153 ohci->hc_control = ohci_readl (ohci, &ohci->regs->control); 154 155 if (ohci->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) { 156 /* this can happen after resuming a swsusp snapshot */ 157 if (hcd->state == HC_STATE_RESUMING) { 158 ohci_dbg (ohci, "BIOS/SMM active, control %03x\n", 159 ohci->hc_control); 160 status = -EBUSY; 161 /* this happens when pmcore resumes HC then root */ 162 } else { 163 ohci_dbg (ohci, "duplicate resume\n"); 164 status = 0; 165 } 166 } else switch (ohci->hc_control & OHCI_CTRL_HCFS) { 167 case OHCI_USB_SUSPEND: 168 ohci->hc_control &= ~(OHCI_CTRL_HCFS|OHCI_SCHED_ENABLES); 169 ohci->hc_control |= OHCI_USB_RESUME; 170 ohci_writel (ohci, ohci->hc_control, &ohci->regs->control); 171 (void) ohci_readl (ohci, &ohci->regs->control); 172 ohci_dbg (ohci, "%s root hub\n", 173 autostopped ? "auto-start" : "resume"); 174 break; 175 case OHCI_USB_RESUME: 176 /* HCFS changes sometime after INTR_RD */ 177 ohci_dbg(ohci, "%swakeup root hub\n", 178 autostopped ? "auto-" : ""); 179 break; 180 case OHCI_USB_OPER: 181 /* this can happen after resuming a swsusp snapshot */ 182 ohci_dbg (ohci, "snapshot resume? reinit\n"); 183 status = -EBUSY; 184 break; 185 default: /* RESET, we lost power */ 186 ohci_dbg (ohci, "lost power\n"); 187 status = -EBUSY; 188 } 189 if (status == -EBUSY) { 190 if (!autostopped) { 191 spin_unlock_irq (&ohci->lock); 192 (void) ohci_init (ohci); 193 status = ohci_restart (ohci); 194 spin_lock_irq (&ohci->lock); 195 } 196 return status; 197 } 198 if (status != -EINPROGRESS) 199 return status; 200 if (autostopped) 201 goto skip_resume; 202 spin_unlock_irq (&ohci->lock); 203 204 /* Some controllers (lucent erratum) need extra-long delays */ 205 msleep (20 /* usb 11.5.1.10 */ + 12 /* 32 msec counter */ + 1); 206 207 temp = ohci_readl (ohci, &ohci->regs->control); 208 temp &= OHCI_CTRL_HCFS; 209 if (temp != OHCI_USB_RESUME) { 210 ohci_err (ohci, "controller won't resume\n"); 211 spin_lock_irq(&ohci->lock); 212 return -EBUSY; 213 } 214 215 /* disable old schedule state, reinit from scratch */ 216 ohci_writel (ohci, 0, &ohci->regs->ed_controlhead); 217 ohci_writel (ohci, 0, &ohci->regs->ed_controlcurrent); 218 ohci_writel (ohci, 0, &ohci->regs->ed_bulkhead); 219 ohci_writel (ohci, 0, &ohci->regs->ed_bulkcurrent); 220 ohci_writel (ohci, 0, &ohci->regs->ed_periodcurrent); 221 ohci_writel (ohci, (u32) ohci->hcca_dma, &ohci->regs->hcca); 222 223 /* Sometimes PCI D3 suspend trashes frame timings ... */ 224 periodic_reinit (ohci); 225 226 /* the following code is executed with ohci->lock held and 227 * irqs disabled if and only if autostopped is true 228 */ 229 230 skip_resume: 231 /* interrupts might have been disabled */ 232 ohci_writel (ohci, OHCI_INTR_INIT, &ohci->regs->intrenable); 233 if (ohci->ed_rm_list) 234 ohci_writel (ohci, OHCI_INTR_SF, &ohci->regs->intrenable); 235 236 /* Then re-enable operations */ 237 ohci_writel (ohci, OHCI_USB_OPER, &ohci->regs->control); 238 (void) ohci_readl (ohci, &ohci->regs->control); 239 if (!autostopped) 240 msleep (3); 241 242 temp = ohci->hc_control; 243 temp &= OHCI_CTRL_RWC; 244 temp |= OHCI_CONTROL_INIT | OHCI_USB_OPER; 245 ohci->hc_control = temp; 246 ohci_writel (ohci, temp, &ohci->regs->control); 247 (void) ohci_readl (ohci, &ohci->regs->control); 248 249 /* TRSMRCY */ 250 if (!autostopped) { 251 msleep (10); 252 spin_lock_irq (&ohci->lock); 253 } 254 /* now ohci->lock is always held and irqs are always disabled */ 255 256 /* keep it alive for more than ~5x suspend + resume costs */ 257 ohci->next_statechange = jiffies + STATECHANGE_DELAY; 258 259 /* maybe turn schedules back on */ 260 enables = 0; 261 temp = 0; 262 if (!ohci->ed_rm_list) { 263 if (ohci->ed_controltail) { 264 ohci_writel (ohci, 265 find_head (ohci->ed_controltail)->dma, 266 &ohci->regs->ed_controlhead); 267 enables |= OHCI_CTRL_CLE; 268 temp |= OHCI_CLF; 269 } 270 if (ohci->ed_bulktail) { 271 ohci_writel (ohci, find_head (ohci->ed_bulktail)->dma, 272 &ohci->regs->ed_bulkhead); 273 enables |= OHCI_CTRL_BLE; 274 temp |= OHCI_BLF; 275 } 276 } 277 if (hcd->self.bandwidth_isoc_reqs || hcd->self.bandwidth_int_reqs) 278 enables |= OHCI_CTRL_PLE|OHCI_CTRL_IE; 279 if (enables) { 280 ohci_dbg (ohci, "restarting schedules ... %08x\n", enables); 281 ohci->hc_control |= enables; 282 ohci_writel (ohci, ohci->hc_control, &ohci->regs->control); 283 if (temp) 284 ohci_writel (ohci, temp, &ohci->regs->cmdstatus); 285 (void) ohci_readl (ohci, &ohci->regs->control); 286 } 287 288 return 0; 289 } 290 291 static int ohci_bus_suspend (struct usb_hcd *hcd) 292 { 293 struct ohci_hcd *ohci = hcd_to_ohci (hcd); 294 int rc; 295 296 spin_lock_irq (&ohci->lock); 297 298 if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))) 299 rc = -ESHUTDOWN; 300 else 301 rc = ohci_rh_suspend (ohci, 0); 302 spin_unlock_irq (&ohci->lock); 303 return rc; 304 } 305 306 static int ohci_bus_resume (struct usb_hcd *hcd) 307 { 308 struct ohci_hcd *ohci = hcd_to_ohci (hcd); 309 int rc; 310 311 if (time_before (jiffies, ohci->next_statechange)) 312 msleep(5); 313 314 spin_lock_irq (&ohci->lock); 315 316 if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))) 317 rc = -ESHUTDOWN; 318 else 319 rc = ohci_rh_resume (ohci); 320 spin_unlock_irq (&ohci->lock); 321 322 /* poll until we know a device is connected or we autostop */ 323 if (rc == 0) 324 usb_hcd_poll_rh_status(hcd); 325 return rc; 326 } 327 328 /* Carry out polling-, autostop-, and autoresume-related state changes */ 329 static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed, 330 int any_connected) 331 { 332 int poll_rh = 1; 333 334 switch (ohci->hc_control & OHCI_CTRL_HCFS) { 335 336 case OHCI_USB_OPER: 337 /* keep on polling until we know a device is connected 338 * and RHSC is enabled */ 339 if (!ohci->autostop) { 340 if (any_connected || 341 !device_may_wakeup(&ohci_to_hcd(ohci) 342 ->self.root_hub->dev)) { 343 if (ohci_readl(ohci, &ohci->regs->intrenable) & 344 OHCI_INTR_RHSC) 345 poll_rh = 0; 346 } else { 347 ohci->autostop = 1; 348 ohci->next_statechange = jiffies + HZ; 349 } 350 351 /* if no devices have been attached for one second, autostop */ 352 } else { 353 if (changed || any_connected) { 354 ohci->autostop = 0; 355 ohci->next_statechange = jiffies + 356 STATECHANGE_DELAY; 357 } else if (time_after_eq(jiffies, 358 ohci->next_statechange) 359 && !ohci->ed_rm_list 360 && !(ohci->hc_control & 361 OHCI_SCHED_ENABLES)) { 362 ohci_rh_suspend(ohci, 1); 363 } 364 } 365 break; 366 367 /* if there is a port change, autostart or ask to be resumed */ 368 case OHCI_USB_SUSPEND: 369 case OHCI_USB_RESUME: 370 if (changed) { 371 if (ohci->autostop) 372 ohci_rh_resume(ohci); 373 else 374 usb_hcd_resume_root_hub(ohci_to_hcd(ohci)); 375 } else { 376 /* everything is idle, no need for polling */ 377 poll_rh = 0; 378 } 379 break; 380 } 381 return poll_rh; 382 } 383 384 #else /* CONFIG_PM */ 385 386 static inline int ohci_rh_resume(struct ohci_hcd *ohci) 387 { 388 return 0; 389 } 390 391 /* Carry out polling-related state changes. 392 * autostop isn't used when CONFIG_PM is turned off. 393 */ 394 static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed, 395 int any_connected) 396 { 397 int poll_rh = 1; 398 399 /* keep on polling until RHSC is enabled */ 400 if (ohci_readl(ohci, &ohci->regs->intrenable) & OHCI_INTR_RHSC) 401 poll_rh = 0; 402 return poll_rh; 403 } 404 405 #endif /* CONFIG_PM */ 406 407 /*-------------------------------------------------------------------------*/ 408 409 /* build "status change" packet (one or two bytes) from HC registers */ 410 411 static int 412 ohci_hub_status_data (struct usb_hcd *hcd, char *buf) 413 { 414 struct ohci_hcd *ohci = hcd_to_ohci (hcd); 415 int i, changed = 0, length = 1; 416 int any_connected = 0; 417 unsigned long flags; 418 419 spin_lock_irqsave (&ohci->lock, flags); 420 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) 421 goto done; 422 423 /* undocumented erratum seen on at least rev D */ 424 if ((ohci->flags & OHCI_QUIRK_AMD756) 425 && (roothub_a (ohci) & RH_A_NDP) > MAX_ROOT_PORTS) { 426 ohci_warn (ohci, "bogus NDP, rereads as NDP=%d\n", 427 ohci_readl (ohci, &ohci->regs->roothub.a) & RH_A_NDP); 428 /* retry later; "should not happen" */ 429 goto done; 430 } 431 432 /* init status */ 433 if (roothub_status (ohci) & (RH_HS_LPSC | RH_HS_OCIC)) 434 buf [0] = changed = 1; 435 else 436 buf [0] = 0; 437 if (ohci->num_ports > 7) { 438 buf [1] = 0; 439 length++; 440 } 441 442 /* look at each port */ 443 for (i = 0; i < ohci->num_ports; i++) { 444 u32 status = roothub_portstatus (ohci, i); 445 446 /* can't autostop if ports are connected */ 447 any_connected |= (status & RH_PS_CCS); 448 449 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC 450 | RH_PS_OCIC | RH_PS_PRSC)) { 451 changed = 1; 452 if (i < 7) 453 buf [0] |= 1 << (i + 1); 454 else 455 buf [1] |= 1 << (i - 7); 456 } 457 } 458 459 hcd->poll_rh = ohci_root_hub_state_changes(ohci, changed, 460 any_connected); 461 462 done: 463 spin_unlock_irqrestore (&ohci->lock, flags); 464 465 return changed ? length : 0; 466 } 467 468 /*-------------------------------------------------------------------------*/ 469 470 static void 471 ohci_hub_descriptor ( 472 struct ohci_hcd *ohci, 473 struct usb_hub_descriptor *desc 474 ) { 475 u32 rh = roothub_a (ohci); 476 u16 temp; 477 478 desc->bDescriptorType = 0x29; 479 desc->bPwrOn2PwrGood = (rh & RH_A_POTPGT) >> 24; 480 desc->bHubContrCurrent = 0; 481 482 desc->bNbrPorts = ohci->num_ports; 483 temp = 1 + (ohci->num_ports / 8); 484 desc->bDescLength = 7 + 2 * temp; 485 486 temp = 0; 487 if (rh & RH_A_NPS) /* no power switching? */ 488 temp |= 0x0002; 489 if (rh & RH_A_PSM) /* per-port power switching? */ 490 temp |= 0x0001; 491 if (rh & RH_A_NOCP) /* no overcurrent reporting? */ 492 temp |= 0x0010; 493 else if (rh & RH_A_OCPM) /* per-port overcurrent reporting? */ 494 temp |= 0x0008; 495 desc->wHubCharacteristics = (__force __u16)cpu_to_hc16(ohci, temp); 496 497 /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */ 498 rh = roothub_b (ohci); 499 memset(desc->bitmap, 0xff, sizeof(desc->bitmap)); 500 desc->bitmap [0] = rh & RH_B_DR; 501 if (ohci->num_ports > 7) { 502 desc->bitmap [1] = (rh & RH_B_DR) >> 8; 503 desc->bitmap [2] = 0xff; 504 } else 505 desc->bitmap [1] = 0xff; 506 } 507 508 /*-------------------------------------------------------------------------*/ 509 510 #ifdef CONFIG_USB_OTG 511 512 static int ohci_start_port_reset (struct usb_hcd *hcd, unsigned port) 513 { 514 struct ohci_hcd *ohci = hcd_to_ohci (hcd); 515 u32 status; 516 517 if (!port) 518 return -EINVAL; 519 port--; 520 521 /* start port reset before HNP protocol times out */ 522 status = ohci_readl(ohci, &ohci->regs->roothub.portstatus [port]); 523 if (!(status & RH_PS_CCS)) 524 return -ENODEV; 525 526 /* khubd will finish the reset later */ 527 ohci_writel(ohci, RH_PS_PRS, &ohci->regs->roothub.portstatus [port]); 528 return 0; 529 } 530 531 static void start_hnp(struct ohci_hcd *ohci); 532 533 #else 534 535 #define ohci_start_port_reset NULL 536 537 #endif 538 539 /*-------------------------------------------------------------------------*/ 540 541 542 /* See usb 7.1.7.5: root hubs must issue at least 50 msec reset signaling, 543 * not necessarily continuous ... to guard against resume signaling. 544 * The short timeout is safe for non-root hubs, and is backward-compatible 545 * with earlier Linux hosts. 546 */ 547 #ifdef CONFIG_USB_SUSPEND 548 #define PORT_RESET_MSEC 50 549 #else 550 #define PORT_RESET_MSEC 10 551 #endif 552 553 /* this timer value might be vendor-specific ... */ 554 #define PORT_RESET_HW_MSEC 10 555 556 /* wrap-aware logic morphed from <linux/jiffies.h> */ 557 #define tick_before(t1,t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0) 558 559 /* called from some task, normally khubd */ 560 static inline int root_port_reset (struct ohci_hcd *ohci, unsigned port) 561 { 562 __hc32 __iomem *portstat = &ohci->regs->roothub.portstatus [port]; 563 u32 temp; 564 u16 now = ohci_readl(ohci, &ohci->regs->fmnumber); 565 u16 reset_done = now + PORT_RESET_MSEC; 566 567 /* build a "continuous enough" reset signal, with up to 568 * 3msec gap between pulses. scheduler HZ==100 must work; 569 * this might need to be deadline-scheduled. 570 */ 571 do { 572 /* spin until any current reset finishes */ 573 for (;;) { 574 temp = ohci_readl (ohci, portstat); 575 /* handle e.g. CardBus eject */ 576 if (temp == ~(u32)0) 577 return -ESHUTDOWN; 578 if (!(temp & RH_PS_PRS)) 579 break; 580 udelay (500); 581 } 582 583 if (!(temp & RH_PS_CCS)) 584 break; 585 if (temp & RH_PS_PRSC) 586 ohci_writel (ohci, RH_PS_PRSC, portstat); 587 588 /* start the next reset, sleep till it's probably done */ 589 ohci_writel (ohci, RH_PS_PRS, portstat); 590 msleep(PORT_RESET_HW_MSEC); 591 now = ohci_readl(ohci, &ohci->regs->fmnumber); 592 } while (tick_before(now, reset_done)); 593 /* caller synchronizes using PRSC */ 594 595 return 0; 596 } 597 598 static int ohci_hub_control ( 599 struct usb_hcd *hcd, 600 u16 typeReq, 601 u16 wValue, 602 u16 wIndex, 603 char *buf, 604 u16 wLength 605 ) { 606 struct ohci_hcd *ohci = hcd_to_ohci (hcd); 607 int ports = hcd_to_bus (hcd)->root_hub->maxchild; 608 u32 temp; 609 int retval = 0; 610 611 if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))) 612 return -ESHUTDOWN; 613 614 switch (typeReq) { 615 case ClearHubFeature: 616 switch (wValue) { 617 case C_HUB_OVER_CURRENT: 618 ohci_writel (ohci, RH_HS_OCIC, 619 &ohci->regs->roothub.status); 620 case C_HUB_LOCAL_POWER: 621 break; 622 default: 623 goto error; 624 } 625 break; 626 case ClearPortFeature: 627 if (!wIndex || wIndex > ports) 628 goto error; 629 wIndex--; 630 631 switch (wValue) { 632 case USB_PORT_FEAT_ENABLE: 633 temp = RH_PS_CCS; 634 break; 635 case USB_PORT_FEAT_C_ENABLE: 636 temp = RH_PS_PESC; 637 break; 638 case USB_PORT_FEAT_SUSPEND: 639 temp = RH_PS_POCI; 640 break; 641 case USB_PORT_FEAT_C_SUSPEND: 642 temp = RH_PS_PSSC; 643 break; 644 case USB_PORT_FEAT_POWER: 645 temp = RH_PS_LSDA; 646 break; 647 case USB_PORT_FEAT_C_CONNECTION: 648 temp = RH_PS_CSC; 649 break; 650 case USB_PORT_FEAT_C_OVER_CURRENT: 651 temp = RH_PS_OCIC; 652 break; 653 case USB_PORT_FEAT_C_RESET: 654 temp = RH_PS_PRSC; 655 break; 656 default: 657 goto error; 658 } 659 ohci_writel (ohci, temp, 660 &ohci->regs->roothub.portstatus [wIndex]); 661 // ohci_readl (ohci, &ohci->regs->roothub.portstatus [wIndex]); 662 break; 663 case GetHubDescriptor: 664 ohci_hub_descriptor (ohci, (struct usb_hub_descriptor *) buf); 665 break; 666 case GetHubStatus: 667 temp = roothub_status (ohci) & ~(RH_HS_CRWE | RH_HS_DRWE); 668 put_unaligned(cpu_to_le32 (temp), (__le32 *) buf); 669 break; 670 case GetPortStatus: 671 if (!wIndex || wIndex > ports) 672 goto error; 673 wIndex--; 674 temp = roothub_portstatus (ohci, wIndex); 675 put_unaligned(cpu_to_le32 (temp), (__le32 *) buf); 676 677 #ifndef OHCI_VERBOSE_DEBUG 678 if (*(u16*)(buf+2)) /* only if wPortChange is interesting */ 679 #endif 680 dbg_port (ohci, "GetStatus", wIndex, temp); 681 break; 682 case SetHubFeature: 683 switch (wValue) { 684 case C_HUB_OVER_CURRENT: 685 // FIXME: this can be cleared, yes? 686 case C_HUB_LOCAL_POWER: 687 break; 688 default: 689 goto error; 690 } 691 break; 692 case SetPortFeature: 693 if (!wIndex || wIndex > ports) 694 goto error; 695 wIndex--; 696 switch (wValue) { 697 case USB_PORT_FEAT_SUSPEND: 698 #ifdef CONFIG_USB_OTG 699 if (hcd->self.otg_port == (wIndex + 1) 700 && hcd->self.b_hnp_enable) 701 start_hnp(ohci); 702 else 703 #endif 704 ohci_writel (ohci, RH_PS_PSS, 705 &ohci->regs->roothub.portstatus [wIndex]); 706 break; 707 case USB_PORT_FEAT_POWER: 708 ohci_writel (ohci, RH_PS_PPS, 709 &ohci->regs->roothub.portstatus [wIndex]); 710 break; 711 case USB_PORT_FEAT_RESET: 712 retval = root_port_reset (ohci, wIndex); 713 break; 714 default: 715 goto error; 716 } 717 break; 718 719 default: 720 error: 721 /* "protocol stall" on error */ 722 retval = -EPIPE; 723 } 724 return retval; 725 } 726 727