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