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