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, value, \ 21 (value & RH_PS_PRSC) ? " PRSC" : "", \ 22 (value & RH_PS_OCIC) ? " OCIC" : "", \ 23 (value & RH_PS_PSSC) ? " PSSC" : "", \ 24 (value & RH_PS_PESC) ? " PESC" : "", \ 25 (value & RH_PS_CSC) ? " CSC" : "", \ 26 \ 27 (value & RH_PS_LSDA) ? " LSDA" : "", \ 28 (value & RH_PS_PPS) ? " PPS" : "", \ 29 (value & RH_PS_PRS) ? " PRS" : "", \ 30 (value & RH_PS_POCI) ? " POCI" : "", \ 31 (value & RH_PS_PSS) ? " PSS" : "", \ 32 \ 33 (value & RH_PS_PES) ? " PES" : "", \ 34 (value & 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 update_done_list(struct ohci_hcd *); 43 static void ohci_work(struct ohci_hcd *); 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 update_done_list(ohci); 91 ohci_work(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 313 if (rc == 0) 314 del_timer_sync(&ohci->io_watchdog); 315 return rc; 316 } 317 318 static int ohci_bus_resume (struct usb_hcd *hcd) 319 { 320 struct ohci_hcd *ohci = hcd_to_ohci (hcd); 321 int rc; 322 323 if (time_before (jiffies, ohci->next_statechange)) 324 msleep(5); 325 326 spin_lock_irq (&ohci->lock); 327 328 if (unlikely(!HCD_HW_ACCESSIBLE(hcd))) 329 rc = -ESHUTDOWN; 330 else 331 rc = ohci_rh_resume (ohci); 332 spin_unlock_irq (&ohci->lock); 333 334 /* poll until we know a device is connected or we autostop */ 335 if (rc == 0) 336 usb_hcd_poll_rh_status(hcd); 337 return rc; 338 } 339 340 /* Carry out polling-, autostop-, and autoresume-related state changes */ 341 static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed, 342 int any_connected, int rhsc_status) 343 { 344 int poll_rh = 1; 345 int rhsc_enable; 346 347 /* Some broken controllers never turn off RHSC in the interrupt 348 * status register. For their sake we won't re-enable RHSC 349 * interrupts if the interrupt bit is already active. 350 */ 351 rhsc_enable = ohci_readl(ohci, &ohci->regs->intrenable) & 352 OHCI_INTR_RHSC; 353 354 switch (ohci->hc_control & OHCI_CTRL_HCFS) { 355 case OHCI_USB_OPER: 356 /* If no status changes are pending, enable RHSC interrupts. */ 357 if (!rhsc_enable && !rhsc_status && !changed) { 358 rhsc_enable = OHCI_INTR_RHSC; 359 ohci_writel(ohci, rhsc_enable, &ohci->regs->intrenable); 360 } 361 362 /* Keep on polling until we know a device is connected 363 * and RHSC is enabled, or until we autostop. 364 */ 365 if (!ohci->autostop) { 366 if (any_connected || 367 !device_may_wakeup(&ohci_to_hcd(ohci) 368 ->self.root_hub->dev)) { 369 if (rhsc_enable) 370 poll_rh = 0; 371 } else { 372 ohci->autostop = 1; 373 ohci->next_statechange = jiffies + HZ; 374 } 375 376 /* if no devices have been attached for one second, autostop */ 377 } else { 378 if (changed || any_connected) { 379 ohci->autostop = 0; 380 ohci->next_statechange = jiffies + 381 STATECHANGE_DELAY; 382 } else if (time_after_eq(jiffies, 383 ohci->next_statechange) 384 && !ohci->ed_rm_list 385 && !(ohci->hc_control & 386 OHCI_SCHED_ENABLES)) { 387 ohci_rh_suspend(ohci, 1); 388 if (rhsc_enable) 389 poll_rh = 0; 390 } 391 } 392 break; 393 394 case OHCI_USB_SUSPEND: 395 case OHCI_USB_RESUME: 396 /* if there is a port change, autostart or ask to be resumed */ 397 if (changed) { 398 if (ohci->autostop) 399 ohci_rh_resume(ohci); 400 else 401 usb_hcd_resume_root_hub(ohci_to_hcd(ohci)); 402 403 /* If remote wakeup is disabled, stop polling */ 404 } else if (!ohci->autostop && 405 !ohci_to_hcd(ohci)->self.root_hub-> 406 do_remote_wakeup) { 407 poll_rh = 0; 408 409 } else { 410 /* If no status changes are pending, 411 * enable RHSC interrupts 412 */ 413 if (!rhsc_enable && !rhsc_status) { 414 rhsc_enable = OHCI_INTR_RHSC; 415 ohci_writel(ohci, rhsc_enable, 416 &ohci->regs->intrenable); 417 } 418 /* Keep polling until RHSC is enabled */ 419 if (rhsc_enable) 420 poll_rh = 0; 421 } 422 break; 423 } 424 return poll_rh; 425 } 426 427 #else /* CONFIG_PM */ 428 429 static inline int ohci_rh_resume(struct ohci_hcd *ohci) 430 { 431 return 0; 432 } 433 434 /* Carry out polling-related state changes. 435 * autostop isn't used when CONFIG_PM is turned off. 436 */ 437 static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed, 438 int any_connected, int rhsc_status) 439 { 440 /* If RHSC is enabled, don't poll */ 441 if (ohci_readl(ohci, &ohci->regs->intrenable) & OHCI_INTR_RHSC) 442 return 0; 443 444 /* If status changes are pending, continue polling. 445 * Conversely, if no status changes are pending but the RHSC 446 * status bit was set, then RHSC may be broken so continue polling. 447 */ 448 if (changed || rhsc_status) 449 return 1; 450 451 /* It's safe to re-enable RHSC interrupts */ 452 ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrenable); 453 return 0; 454 } 455 456 #endif /* CONFIG_PM */ 457 458 /*-------------------------------------------------------------------------*/ 459 460 /* build "status change" packet (one or two bytes) from HC registers */ 461 462 int ohci_hub_status_data(struct usb_hcd *hcd, char *buf) 463 { 464 struct ohci_hcd *ohci = hcd_to_ohci (hcd); 465 int i, changed = 0, length = 1; 466 int any_connected = 0; 467 int rhsc_status; 468 unsigned long flags; 469 470 spin_lock_irqsave (&ohci->lock, flags); 471 if (!HCD_HW_ACCESSIBLE(hcd)) 472 goto done; 473 474 /* undocumented erratum seen on at least rev D */ 475 if ((ohci->flags & OHCI_QUIRK_AMD756) 476 && (roothub_a (ohci) & RH_A_NDP) > MAX_ROOT_PORTS) { 477 ohci_warn (ohci, "bogus NDP, rereads as NDP=%d\n", 478 ohci_readl (ohci, &ohci->regs->roothub.a) & RH_A_NDP); 479 /* retry later; "should not happen" */ 480 goto done; 481 } 482 483 /* init status */ 484 if (roothub_status (ohci) & (RH_HS_LPSC | RH_HS_OCIC)) 485 buf [0] = changed = 1; 486 else 487 buf [0] = 0; 488 if (ohci->num_ports > 7) { 489 buf [1] = 0; 490 length++; 491 } 492 493 /* Clear the RHSC status flag before reading the port statuses */ 494 ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrstatus); 495 rhsc_status = ohci_readl(ohci, &ohci->regs->intrstatus) & 496 OHCI_INTR_RHSC; 497 498 /* look at each port */ 499 for (i = 0; i < ohci->num_ports; i++) { 500 u32 status = roothub_portstatus (ohci, i); 501 502 /* can't autostop if ports are connected */ 503 any_connected |= (status & RH_PS_CCS); 504 505 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC 506 | RH_PS_OCIC | RH_PS_PRSC)) { 507 changed = 1; 508 if (i < 7) 509 buf [0] |= 1 << (i + 1); 510 else 511 buf [1] |= 1 << (i - 7); 512 } 513 } 514 515 if (ohci_root_hub_state_changes(ohci, changed, 516 any_connected, rhsc_status)) 517 set_bit(HCD_FLAG_POLL_RH, &hcd->flags); 518 else 519 clear_bit(HCD_FLAG_POLL_RH, &hcd->flags); 520 521 522 done: 523 spin_unlock_irqrestore (&ohci->lock, flags); 524 525 return changed ? length : 0; 526 } 527 EXPORT_SYMBOL_GPL(ohci_hub_status_data); 528 529 /*-------------------------------------------------------------------------*/ 530 531 static void 532 ohci_hub_descriptor ( 533 struct ohci_hcd *ohci, 534 struct usb_hub_descriptor *desc 535 ) { 536 u32 rh = roothub_a (ohci); 537 u16 temp; 538 539 desc->bDescriptorType = USB_DT_HUB; 540 desc->bPwrOn2PwrGood = (rh & RH_A_POTPGT) >> 24; 541 desc->bHubContrCurrent = 0; 542 543 desc->bNbrPorts = ohci->num_ports; 544 temp = 1 + (ohci->num_ports / 8); 545 desc->bDescLength = 7 + 2 * temp; 546 547 temp = HUB_CHAR_COMMON_LPSM | HUB_CHAR_COMMON_OCPM; 548 if (rh & RH_A_NPS) /* no power switching? */ 549 temp |= HUB_CHAR_NO_LPSM; 550 if (rh & RH_A_PSM) /* per-port power switching? */ 551 temp |= HUB_CHAR_INDV_PORT_LPSM; 552 if (rh & RH_A_NOCP) /* no overcurrent reporting? */ 553 temp |= HUB_CHAR_NO_OCPM; 554 else if (rh & RH_A_OCPM) /* per-port overcurrent reporting? */ 555 temp |= HUB_CHAR_INDV_PORT_OCPM; 556 desc->wHubCharacteristics = cpu_to_le16(temp); 557 558 /* ports removable, and usb 1.0 legacy PortPwrCtrlMask */ 559 rh = roothub_b (ohci); 560 memset(desc->u.hs.DeviceRemovable, 0xff, 561 sizeof(desc->u.hs.DeviceRemovable)); 562 desc->u.hs.DeviceRemovable[0] = rh & RH_B_DR; 563 if (ohci->num_ports > 7) { 564 desc->u.hs.DeviceRemovable[1] = (rh & RH_B_DR) >> 8; 565 desc->u.hs.DeviceRemovable[2] = 0xff; 566 } else 567 desc->u.hs.DeviceRemovable[1] = 0xff; 568 } 569 570 /*-------------------------------------------------------------------------*/ 571 572 #ifdef CONFIG_USB_OTG 573 574 static int ohci_start_port_reset (struct usb_hcd *hcd, unsigned port) 575 { 576 struct ohci_hcd *ohci = hcd_to_ohci (hcd); 577 u32 status; 578 579 if (!port) 580 return -EINVAL; 581 port--; 582 583 /* start port reset before HNP protocol times out */ 584 status = ohci_readl(ohci, &ohci->regs->roothub.portstatus [port]); 585 if (!(status & RH_PS_CCS)) 586 return -ENODEV; 587 588 /* hub_wq will finish the reset later */ 589 ohci_writel(ohci, RH_PS_PRS, &ohci->regs->roothub.portstatus [port]); 590 return 0; 591 } 592 593 #else 594 595 #define ohci_start_port_reset NULL 596 597 #endif 598 599 /*-------------------------------------------------------------------------*/ 600 601 602 /* See usb 7.1.7.5: root hubs must issue at least 50 msec reset signaling, 603 * not necessarily continuous ... to guard against resume signaling. 604 */ 605 #define PORT_RESET_MSEC 50 606 607 /* this timer value might be vendor-specific ... */ 608 #define PORT_RESET_HW_MSEC 10 609 610 /* wrap-aware logic morphed from <linux/jiffies.h> */ 611 #define tick_before(t1,t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0) 612 613 /* called from some task, normally hub_wq */ 614 static inline int root_port_reset (struct ohci_hcd *ohci, unsigned port) 615 { 616 __hc32 __iomem *portstat = &ohci->regs->roothub.portstatus [port]; 617 u32 temp = 0; 618 u16 now = ohci_readl(ohci, &ohci->regs->fmnumber); 619 u16 reset_done = now + PORT_RESET_MSEC; 620 int limit_1 = DIV_ROUND_UP(PORT_RESET_MSEC, PORT_RESET_HW_MSEC); 621 622 /* build a "continuous enough" reset signal, with up to 623 * 3msec gap between pulses. scheduler HZ==100 must work; 624 * this might need to be deadline-scheduled. 625 */ 626 do { 627 int limit_2; 628 629 /* spin until any current reset finishes */ 630 limit_2 = PORT_RESET_HW_MSEC * 2; 631 while (--limit_2 >= 0) { 632 temp = ohci_readl (ohci, portstat); 633 /* handle e.g. CardBus eject */ 634 if (temp == ~(u32)0) 635 return -ESHUTDOWN; 636 if (!(temp & RH_PS_PRS)) 637 break; 638 udelay (500); 639 } 640 641 /* timeout (a hardware error) has been observed when 642 * EHCI sets CF while this driver is resetting a port; 643 * presumably other disconnect paths might do it too. 644 */ 645 if (limit_2 < 0) { 646 ohci_dbg(ohci, 647 "port[%d] reset timeout, stat %08x\n", 648 port, temp); 649 break; 650 } 651 652 if (!(temp & RH_PS_CCS)) 653 break; 654 if (temp & RH_PS_PRSC) 655 ohci_writel (ohci, RH_PS_PRSC, portstat); 656 657 /* start the next reset, sleep till it's probably done */ 658 ohci_writel (ohci, RH_PS_PRS, portstat); 659 msleep(PORT_RESET_HW_MSEC); 660 now = ohci_readl(ohci, &ohci->regs->fmnumber); 661 } while (tick_before(now, reset_done) && --limit_1 >= 0); 662 663 /* caller synchronizes using PRSC ... and handles PRS 664 * still being set when this returns. 665 */ 666 667 return 0; 668 } 669 670 int ohci_hub_control( 671 struct usb_hcd *hcd, 672 u16 typeReq, 673 u16 wValue, 674 u16 wIndex, 675 char *buf, 676 u16 wLength 677 ) { 678 struct ohci_hcd *ohci = hcd_to_ohci (hcd); 679 int ports = ohci->num_ports; 680 u32 temp; 681 int retval = 0; 682 683 if (unlikely(!HCD_HW_ACCESSIBLE(hcd))) 684 return -ESHUTDOWN; 685 686 switch (typeReq) { 687 case ClearHubFeature: 688 switch (wValue) { 689 case C_HUB_OVER_CURRENT: 690 ohci_writel (ohci, RH_HS_OCIC, 691 &ohci->regs->roothub.status); 692 case C_HUB_LOCAL_POWER: 693 break; 694 default: 695 goto error; 696 } 697 break; 698 case ClearPortFeature: 699 if (!wIndex || wIndex > ports) 700 goto error; 701 wIndex--; 702 703 switch (wValue) { 704 case USB_PORT_FEAT_ENABLE: 705 temp = RH_PS_CCS; 706 break; 707 case USB_PORT_FEAT_C_ENABLE: 708 temp = RH_PS_PESC; 709 break; 710 case USB_PORT_FEAT_SUSPEND: 711 temp = RH_PS_POCI; 712 break; 713 case USB_PORT_FEAT_C_SUSPEND: 714 temp = RH_PS_PSSC; 715 break; 716 case USB_PORT_FEAT_POWER: 717 temp = RH_PS_LSDA; 718 break; 719 case USB_PORT_FEAT_C_CONNECTION: 720 temp = RH_PS_CSC; 721 break; 722 case USB_PORT_FEAT_C_OVER_CURRENT: 723 temp = RH_PS_OCIC; 724 break; 725 case USB_PORT_FEAT_C_RESET: 726 temp = RH_PS_PRSC; 727 break; 728 default: 729 goto error; 730 } 731 ohci_writel (ohci, temp, 732 &ohci->regs->roothub.portstatus [wIndex]); 733 // ohci_readl (ohci, &ohci->regs->roothub.portstatus [wIndex]); 734 break; 735 case GetHubDescriptor: 736 ohci_hub_descriptor (ohci, (struct usb_hub_descriptor *) buf); 737 break; 738 case GetHubStatus: 739 temp = roothub_status (ohci) & ~(RH_HS_CRWE | RH_HS_DRWE); 740 put_unaligned_le32(temp, buf); 741 break; 742 case GetPortStatus: 743 if (!wIndex || wIndex > ports) 744 goto error; 745 wIndex--; 746 temp = roothub_portstatus (ohci, wIndex); 747 put_unaligned_le32(temp, buf); 748 749 if (*(u16*)(buf+2)) /* only if wPortChange is interesting */ 750 dbg_port(ohci, "GetStatus", wIndex, temp); 751 break; 752 case SetHubFeature: 753 switch (wValue) { 754 case C_HUB_OVER_CURRENT: 755 // FIXME: this can be cleared, yes? 756 case C_HUB_LOCAL_POWER: 757 break; 758 default: 759 goto error; 760 } 761 break; 762 case SetPortFeature: 763 if (!wIndex || wIndex > ports) 764 goto error; 765 wIndex--; 766 switch (wValue) { 767 case USB_PORT_FEAT_SUSPEND: 768 #ifdef CONFIG_USB_OTG 769 if (hcd->self.otg_port == (wIndex + 1) 770 && hcd->self.b_hnp_enable) 771 ohci->start_hnp(ohci); 772 else 773 #endif 774 ohci_writel (ohci, RH_PS_PSS, 775 &ohci->regs->roothub.portstatus [wIndex]); 776 break; 777 case USB_PORT_FEAT_POWER: 778 ohci_writel (ohci, RH_PS_PPS, 779 &ohci->regs->roothub.portstatus [wIndex]); 780 break; 781 case USB_PORT_FEAT_RESET: 782 retval = root_port_reset (ohci, wIndex); 783 break; 784 default: 785 goto error; 786 } 787 break; 788 789 default: 790 error: 791 /* "protocol stall" on error */ 792 retval = -EPIPE; 793 } 794 return retval; 795 } 796 EXPORT_SYMBOL_GPL(ohci_hub_control); 797