1/* 2 * ADM5120 HCD (Host Controller Driver) for USB 3 * 4 * Copyright (C) 2007-2008 Gabor Juhos <juhosg@openwrt.org> 5 * 6 * This file was derived from fragments of the OHCI driver. 7 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at> 8 * (C) Copyright 2000-2004 David Brownell <dbrownell@users.sourceforge.net> 9 * 10 * This program is free software; you can redistribute it and/or modify it 11 * under the terms of the GNU General Public License version 2 as published 12 * by the Free Software Foundation. 13 * 14 */ 15 16#define OHCI_SCHED_ENABLES \ 17 (OHCI_CTRL_CLE|OHCI_CTRL_BLE|OHCI_CTRL_PLE|OHCI_CTRL_IE) 18 19#ifdef CONFIG_PM 20static int admhc_restart(struct admhcd *ahcd); 21 22static int admhc_rh_suspend(struct admhcd *ahcd, int autostop) 23__releases(ahcd->lock) 24__acquires(ahcd->lock) 25{ 26 int status = 0; 27 28 ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control); 29 switch (ahcd->hc_control & OHCI_CTRL_HCFS) { 30 case OHCI_USB_RESUME: 31 admhc_dbg(ahcd, "resume/suspend?\n"); 32 ahcd->hc_control &= ~OHCI_CTRL_HCFS; 33 ahcd->hc_control |= OHCI_USB_RESET; 34 admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control); 35 (void) admhc_readl(ahcd, &ahcd->regs->control); 36 /* FALL THROUGH */ 37 case OHCI_USB_RESET: 38 status = -EBUSY; 39 admhc_dbg(ahcd, "needs reinit!\n"); 40 goto done; 41 case OHCI_USB_SUSPEND: 42 if (!ahcd->autostop) { 43 admhc_dbg(ahcd, "already suspended\n"); 44 goto done; 45 } 46 } 47 admhc_dbg(ahcd, "%s root hub\n", 48 autostop ? "auto-stop" : "suspend"); 49 50 /* First stop any processing */ 51 if (!autostop && (ahcd->hc_control & OHCI_SCHED_ENABLES)) { 52 ahcd->hc_control &= ~OHCI_SCHED_ENABLES; 53 admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control); 54 ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control); 55 admhc_writel(ahcd, OHCI_INTR_SF, &ahcd->regs->intrstatus); 56 57 /* sched disables take effect on the next frame, 58 * then the last WDH could take 6+ msec 59 */ 60 admhc_dbg(ahcd, "stopping schedules ...\n"); 61 ahcd->autostop = 0; 62 spin_unlock_irq (&ahcd->lock); 63 msleep (8); 64 spin_lock_irq(&ahcd->lock); 65 } 66 dl_done_list (ahcd); 67 finish_unlinks (ahcd, admhc_frame_no(ahcd)); 68 69 /* maybe resume can wake root hub */ 70 if (device_may_wakeup(&admhcd_to_hcd(ahcd)->self.root_hub->dev) || 71 autostop) 72 ahcd->hc_control |= OHCI_CTRL_RWE; 73 else { 74 admhc_writel(ahcd, OHCI_INTR_RHSC, &ahcd->regs->intrdisable); 75 ahcd->hc_control &= ~OHCI_CTRL_RWE; 76 } 77 78 /* Suspend hub ... this is the "global (to this bus) suspend" mode, 79 * which doesn't imply ports will first be individually suspended. 80 */ 81 ahcd->hc_control &= ~OHCI_CTRL_HCFS; 82 ahcd->hc_control |= OHCI_USB_SUSPEND; 83 admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control); 84 (void) admhc_readl(ahcd, &ahcd->regs->control); 85 86 /* no resumes until devices finish suspending */ 87 if (!autostop) { 88 ahcd->next_statechange = jiffies + msecs_to_jiffies (5); 89 ahcd->autostop = 0; 90 } 91 92done: 93 return status; 94} 95 96static inline struct ed *find_head(struct ed *ed) 97{ 98 /* for bulk and control lists */ 99 while (ed->ed_prev) 100 ed = ed->ed_prev; 101 return ed; 102} 103 104/* caller has locked the root hub */ 105static int admhc_rh_resume(struct admhcd *ahcd) 106__releases(ahcd->lock) 107__acquires(ahcd->lock) 108{ 109 struct usb_hcd *hcd = admhcd_to_hcd (ahcd); 110 u32 temp, enables; 111 int status = -EINPROGRESS; 112 int autostopped = ahcd->autostop; 113 114 ahcd->autostop = 0; 115 ahcd->hc_control = admhc_readl(ahcd, &ahcd->regs->control); 116 117 if (ahcd->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) { 118 /* this can happen after resuming a swsusp snapshot */ 119 if (hcd->state == HC_STATE_RESUMING) { 120 admhc_dbg(ahcd, "BIOS/SMM active, control %03x\n", 121 ahcd->hc_control); 122 status = -EBUSY; 123 /* this happens when pmcore resumes HC then root */ 124 } else { 125 admhc_dbg(ahcd, "duplicate resume\n"); 126 status = 0; 127 } 128 } else switch (ahcd->hc_control & OHCI_CTRL_HCFS) { 129 case OHCI_USB_SUSPEND: 130 ahcd->hc_control &= ~(OHCI_CTRL_HCFS|OHCI_SCHED_ENABLES); 131 ahcd->hc_control |= OHCI_USB_RESUME; 132 admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control); 133 (void) admhc_readl(ahcd, &ahcd->regs->control); 134 admhc_dbg(ahcd, "%s root hub\n", 135 autostopped ? "auto-start" : "resume"); 136 break; 137 case OHCI_USB_RESUME: 138 /* HCFS changes sometime after INTR_RD */ 139 admhc_dbg(ahcd, "%swakeup root hub\n", 140 autostopped ? "auto-" : ""); 141 break; 142 case OHCI_USB_OPER: 143 /* this can happen after resuming a swsusp snapshot */ 144 admhc_dbg(ahcd, "snapshot resume? reinit\n"); 145 status = -EBUSY; 146 break; 147 default: /* RESET, we lost power */ 148 admhc_dbg(ahcd, "lost power\n"); 149 status = -EBUSY; 150 } 151 if (status == -EBUSY) { 152 if (!autostopped) { 153 spin_unlock_irq (&ahcd->lock); 154 (void) ahcd_init (ahcd); 155 status = admhc_restart (ahcd); 156 spin_lock_irq(&ahcd->lock); 157 } 158 return status; 159 } 160 if (status != -EINPROGRESS) 161 return status; 162 if (autostopped) 163 goto skip_resume; 164 spin_unlock_irq (&ahcd->lock); 165 166 /* Some controllers (lucent erratum) need extra-long delays */ 167 msleep (20 /* usb 11.5.1.10 */ + 12 /* 32 msec counter */ + 1); 168 169 temp = admhc_readl(ahcd, &ahcd->regs->control); 170 temp &= OHCI_CTRL_HCFS; 171 if (temp != OHCI_USB_RESUME) { 172 admhc_err (ahcd, "controller won't resume\n"); 173 spin_lock_irq(&ahcd->lock); 174 return -EBUSY; 175 } 176 177 /* disable old schedule state, reinit from scratch */ 178 admhc_writel(ahcd, 0, &ahcd->regs->ed_controlhead); 179 admhc_writel(ahcd, 0, &ahcd->regs->ed_controlcurrent); 180 admhc_writel(ahcd, 0, &ahcd->regs->ed_bulkhead); 181 admhc_writel(ahcd, 0, &ahcd->regs->ed_bulkcurrent); 182 admhc_writel(ahcd, 0, &ahcd->regs->ed_periodcurrent); 183 admhc_writel(ahcd, (u32) ahcd->hcca_dma, &ahcd->ahcd->regs->hcca); 184 185 /* Sometimes PCI D3 suspend trashes frame timings ... */ 186 periodic_reinit(ahcd); 187 188 /* the following code is executed with ahcd->lock held and 189 * irqs disabled if and only if autostopped is true 190 */ 191 192skip_resume: 193 /* interrupts might have been disabled */ 194 admhc_writel(ahcd, OHCI_INTR_INIT, &ahcd->regs->int_enable); 195 if (ahcd->ed_rm_list) 196 admhc_writel(ahcd, OHCI_INTR_SF, &ahcd->regs->int_enable); 197 198 /* Then re-enable operations */ 199 admhc_writel(ahcd, OHCI_USB_OPER, &ahcd->regs->control); 200 (void) admhc_readl(ahcd, &ahcd->regs->control); 201 if (!autostopped) 202 msleep (3); 203 204 temp = ahcd->hc_control; 205 temp &= OHCI_CTRL_RWC; 206 temp |= OHCI_CONTROL_INIT | OHCI_USB_OPER; 207 ahcd->hc_control = temp; 208 admhc_writel(ahcd, temp, &ahcd->regs->control); 209 (void) admhc_readl(ahcd, &ahcd->regs->control); 210 211 /* TRSMRCY */ 212 if (!autostopped) { 213 msleep (10); 214 spin_lock_irq(&ahcd->lock); 215 } 216 /* now ahcd->lock is always held and irqs are always disabled */ 217 218 /* keep it alive for more than ~5x suspend + resume costs */ 219 ahcd->next_statechange = jiffies + STATECHANGE_DELAY; 220 221 /* maybe turn schedules back on */ 222 enables = 0; 223 temp = 0; 224 if (!ahcd->ed_rm_list) { 225 if (ahcd->ed_controltail) { 226 admhc_writel(ahcd, 227 find_head (ahcd->ed_controltail)->dma, 228 &ahcd->regs->ed_controlhead); 229 enables |= OHCI_CTRL_CLE; 230 temp |= OHCI_CLF; 231 } 232 if (ahcd->ed_bulktail) { 233 admhc_writel(ahcd, find_head (ahcd->ed_bulktail)->dma, 234 &ahcd->regs->ed_bulkhead); 235 enables |= OHCI_CTRL_BLE; 236 temp |= OHCI_BLF; 237 } 238 } 239 if (hcd->self.bandwidth_isoc_reqs || hcd->self.bandwidth_int_reqs) 240 enables |= OHCI_CTRL_PLE|OHCI_CTRL_IE; 241 if (enables) { 242 admhc_dbg(ahcd, "restarting schedules ... %08x\n", enables); 243 ahcd->hc_control |= enables; 244 admhc_writel(ahcd, ahcd->hc_control, &ahcd->ahcd->regs->control); 245 if (temp) 246 admhc_writel(ahcd, temp, &ahcd->regs->cmdstatus); 247 (void) admhc_readl(ahcd, &ahcd->regs->control); 248 } 249 250 return 0; 251} 252 253static int admhc_bus_suspend(struct usb_hcd *hcd) 254{ 255 struct admhcd *ahcd = hcd_to_admhcd(hcd); 256 int rc; 257 258 spin_lock_irq(&ahcd->lock); 259 260 if (unlikely(!HCD_HW_ACCESSIBLE(hcd))) 261 rc = -ESHUTDOWN; 262 else 263 rc = admhc_rh_suspend(ahcd, 0); 264 spin_unlock_irq(&ahcd->lock); 265 return rc; 266} 267 268static int admhc_bus_resume(struct usb_hcd *hcd) 269{ 270 struct admhcd *ahcd = hcd_to_admhcd(hcd); 271 int rc; 272 273 if (time_before(jiffies, ahcd->next_statechange)) 274 msleep(5); 275 276 spin_lock_irq(&ahcd->lock); 277 278 if (unlikely(!HCD_HW_ACCESSIBLE(hcd))) 279 rc = -ESHUTDOWN; 280 else 281 rc = admhc_rh_resume(ahcd); 282 spin_unlock_irq(&ahcd->lock); 283 284 /* poll until we know a device is connected or we autostop */ 285 if (rc == 0) 286 usb_hcd_poll_rh_status(hcd); 287 return rc; 288} 289 290/* Carry out polling-, autostop-, and autoresume-related state changes */ 291static int admhc_root_hub_state_changes(struct admhcd *ahcd, int changed, 292 int any_connected) 293{ 294 int poll_rh = 1; 295 296 switch (ahcd->hc_control & OHCI_CTRL_HCFS) { 297 298 case OHCI_USB_OPER: 299 /* keep on polling until we know a device is connected 300 * and RHSC is enabled */ 301 if (!ahcd->autostop) { 302 if (any_connected || 303 !device_may_wakeup(&admhcd_to_hcd(ahcd) 304 ->self.root_hub->dev)) { 305 if (admhc_readl(ahcd, &ahcd->regs->int_enable) & 306 OHCI_INTR_RHSC) 307 poll_rh = 0; 308 } else { 309 ahcd->autostop = 1; 310 ahcd->next_statechange = jiffies + HZ; 311 } 312 313 /* if no devices have been attached for one second, autostop */ 314 } else { 315 if (changed || any_connected) { 316 ahcd->autostop = 0; 317 ahcd->next_statechange = jiffies + 318 STATECHANGE_DELAY; 319 } else if (time_after_eq(jiffies, 320 ahcd->next_statechange) 321 && !ahcd->ed_rm_list 322 && !(ahcd->hc_control & 323 OHCI_SCHED_ENABLES)) { 324 ahcd_rh_suspend(ahcd, 1); 325 } 326 } 327 break; 328 329 /* if there is a port change, autostart or ask to be resumed */ 330 case OHCI_USB_SUSPEND: 331 case OHCI_USB_RESUME: 332 if (changed) { 333 if (ahcd->autostop) 334 admhc_rh_resume(ahcd); 335 else 336 usb_hcd_resume_root_hub(admhcd_to_hcd(ahcd)); 337 } else { 338 /* everything is idle, no need for polling */ 339 poll_rh = 0; 340 } 341 break; 342 } 343 return poll_rh; 344} 345 346/*-------------------------------------------------------------------------*/ 347 348/* must not be called from interrupt context */ 349static int admhc_restart(struct admhcd *ahcd) 350{ 351 int temp; 352 int i; 353 struct urb_priv *priv; 354 355 /* mark any devices gone, so they do nothing till khubd disconnects. 356 * recycle any "live" eds/tds (and urbs) right away. 357 * later, khubd disconnect processing will recycle the other state, 358 * (either as disconnect/reconnect, or maybe someday as a reset). 359 */ 360 spin_lock_irq(&ahcd->lock); 361 admhc_disable(ahcd); 362 usb_root_hub_lost_power(admhcd_to_hcd(ahcd)->self.root_hub); 363 if (!list_empty(&ahcd->pending)) 364 admhc_dbg(ahcd, "abort schedule...\n"); 365 list_for_each_entry(priv, &ahcd->pending, pending) { 366 struct urb *urb = priv->td[0]->urb; 367 struct ed *ed = priv->ed; 368 369 switch (ed->state) { 370 case ED_OPER: 371 ed->state = ED_UNLINK; 372 ed->hwINFO |= cpu_to_hc32(ahcd, ED_DEQUEUE); 373 ed_deschedule (ahcd, ed); 374 375 ed->ed_next = ahcd->ed_rm_list; 376 ed->ed_prev = NULL; 377 ahcd->ed_rm_list = ed; 378 /* FALLTHROUGH */ 379 case ED_UNLINK: 380 break; 381 default: 382 admhc_dbg(ahcd, "bogus ed %p state %d\n", 383 ed, ed->state); 384 } 385 386 if (!urb->unlinked) 387 urb->unlinked = -ESHUTDOWN; 388 } 389 finish_unlinks(ahcd, 0); 390 spin_unlock_irq(&ahcd->lock); 391 392 /* paranoia, in case that didn't work: */ 393 394 /* empty the interrupt branches */ 395 for (i = 0; i < NUM_INTS; i++) ahcd->load[i] = 0; 396 for (i = 0; i < NUM_INTS; i++) ahcd->hcca->int_table[i] = 0; 397 398 /* no EDs to remove */ 399 ahcd->ed_rm_list = NULL; 400 401 /* empty control and bulk lists */ 402 ahcd->ed_controltail = NULL; 403 ahcd->ed_bulktail = NULL; 404 405 if ((temp = admhc_run(ahcd)) < 0) { 406 admhc_err(ahcd, "can't restart, %d\n", temp); 407 return temp; 408 } else { 409 /* here we "know" root ports should always stay powered, 410 * and that if we try to turn them back on the root hub 411 * will respond to CSC processing. 412 */ 413 i = ahcd->num_ports; 414 while (i--) 415 admhc_writel(ahcd, RH_PS_PSS, 416 &ahcd->regs->portstatus[i]); 417 admhc_dbg(ahcd, "restart complete\n"); 418 } 419 return 0; 420} 421 422#else /* CONFIG_PM */ 423 424static inline int admhc_rh_resume(struct admhcd *ahcd) 425{ 426 return 0; 427} 428 429/* Carry out polling-related state changes. 430 * autostop isn't used when CONFIG_PM is turned off. 431 */ 432static int admhc_root_hub_state_changes(struct admhcd *ahcd, int changed, 433 int any_connected) 434{ 435 /* If INSM is enabled, don't poll */ 436 if (admhc_readl(ahcd, &ahcd->regs->int_enable) & ADMHC_INTR_INSM) 437 return 0; 438 439 /* If no status changes are pending, enable status-change interrupts */ 440 if (!changed) { 441 admhc_intr_enable(ahcd, ADMHC_INTR_INSM); 442 return 0; 443 } 444 445 return 1; 446} 447 448#endif /* CONFIG_PM */ 449 450