projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
brcmfmac: remove use of unconditional access of struct wireless_dev::netdev
[deliverable/linux.git] / drivers / usb / host / ohci-hub.c
CommitLineData
1da177e4
LT		 1/*
2 * OHCI HCD (Host Controller Driver) for USB.
dd9048af 3 *
1da177e4
LT		 4 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
5 * (C) Copyright 2000-2004 David Brownell <dbrownell@users.sourceforge.net>
dd9048af 6 *
1da177e4
LT		 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" : "", \
dd9048af 26 \
1da177e4
LT		 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" : "", \
dd9048af 32 \
1da177e4
LT		 33 (temp & RH_PS_PES) ? " PES" : "", \
34 (temp & RH_PS_CCS) ? " CCS" : "" \
35 );
36
37/*-------------------------------------------------------------------------*/
38
1da177e4
LT		 39#define OHCI_SCHED_ENABLES \
40 (OHCI_CTRL_CLE|OHCI_CTRL_BLE|OHCI_CTRL_PLE|OHCI_CTRL_IE)
41
7d12e780
DH		 42static void dl_done_list (struct ohci_hcd *);
43static void finish_unlinks (struct ohci_hcd *, u16);
1da177e4 44
b1878440 45#ifdef CONFIG_PM
8d1a243b
AS		 46static int ohci_rh_suspend (struct ohci_hcd *ohci, int autostop)
47__releases(ohci->lock)
48__acquires(ohci->lock)
1da177e4 49{
1da177e4 50 int status = 0;
8de98402 51
1da177e4
LT		 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:
8d1a243b
AS		 66 if (!ohci->autostop) {
67 ohci_dbg (ohci, "already suspended\n");
68 goto done;
69 }
1da177e4 70 }
8d1a243b
AS		 71 ohci_dbg (ohci, "%s root hub\n",
72 autostop ? "auto-stop" : "suspend");
1da177e4
LT		 73
74 /* First stop any processing */
8d1a243b 75 if (!autostop && (ohci->hc_control & OHCI_SCHED_ENABLES)) {
1da177e4
LT		 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");
8d1a243b
AS		 85 ohci->autostop = 0;
86 spin_unlock_irq (&ohci->lock);
87 msleep (8);
88 spin_lock_irq (&ohci->lock);
1da177e4 89 }
7d12e780
DH		 90 dl_done_list (ohci);
91 finish_unlinks (ohci, ohci_frame_no(ohci));
1da177e4
LT		 92
93 /* maybe resume can wake root hub */
58a97ffe 94 if (ohci_to_hcd(ohci)->self.root_hub->do_remote_wakeup || autostop) {
1da177e4 95 ohci->hc_control |= OHCI_CTRL_RWE;
58a97ffe 96 } else {
5f47493c
AS		 97 ohci_writel(ohci, OHCI_INTR_RHSC | OHCI_INTR_RD,
98 &ohci->regs->intrdisable);
1da177e4 99 ohci->hc_control &= ~OHCI_CTRL_RWE;
1f7e1a3b 100 }
1da177e4 101
f197b2c5
DB		 102 /* Suspend hub ... this is the "global (to this bus) suspend" mode,
103 * which doesn't imply ports will first be individually suspended.
104 */
1da177e4
LT		 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 */
8d1a243b
AS		 111 if (!autostop) {
112 ohci->next_statechange = jiffies + msecs_to_jiffies (5);
113 ohci->autostop = 0;
b7463c71 114 ohci->rh_state = OHCI_RH_SUSPENDED;
8d1a243b 115 }
d413984a 116
1da177e4 117done:
1da177e4
LT		 118 return status;
119}
120
121static 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 */
8d1a243b
AS		 130static int ohci_rh_resume (struct ohci_hcd *ohci)
131__releases(ohci->lock)
132__acquires(ohci->lock)
1da177e4 133{
8d1a243b 134 struct usb_hcd *hcd = ohci_to_hcd (ohci);
1da177e4
LT		 135 u32 temp, enables;
136 int status = -EINPROGRESS;
8d1a243b 137 int autostopped = ohci->autostop;
8de98402 138
8d1a243b 139 ohci->autostop = 0;
1da177e4
LT		 140 ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);
141
142 if (ohci->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) {
f197b2c5 143 /* this can happen after resuming a swsusp snapshot */
b7463c71 144 if (ohci->rh_state != OHCI_RH_RUNNING) {
1da177e4
LT		 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);
8d1a243b
AS		 159 ohci_dbg (ohci, "%s root hub\n",
160 autostopped ? "auto-start" : "resume");
1da177e4
LT		 161 break;
162 case OHCI_USB_RESUME:
163 /* HCFS changes sometime after INTR_RD */
1b7be3c0 164 ohci_dbg(ohci, "%swakeup root hub\n",
583ceada 165 autostopped ? "auto-" : "");
1da177e4
LT		 166 break;
167 case OHCI_USB_OPER:
f197b2c5
DB		 168 /* this can happen after resuming a swsusp snapshot */
169 ohci_dbg (ohci, "snapshot resume? reinit\n");
170 status = -EBUSY;
1da177e4
LT		 171 break;
172 default: /* RESET, we lost power */
f197b2c5 173 ohci_dbg (ohci, "lost power\n");
1da177e4
LT		 174 status = -EBUSY;
175 }
1da177e4 176 if (status == -EBUSY) {
8d1a243b 177 if (!autostopped) {
8d1a243b
AS		 178 spin_unlock_irq (&ohci->lock);
179 (void) ohci_init (ohci);
180 status = ohci_restart (ohci);
d576bb9f
MH		 181
182 usb_root_hub_lost_power(hcd->self.root_hub);
183
8d1a243b
AS		 184 spin_lock_irq (&ohci->lock);
185 }
186 return status;
1da177e4
LT		 187 }
188 if (status != -EINPROGRESS)
189 return status;
8d1a243b
AS		 190 if (autostopped)
191 goto skip_resume;
192 spin_unlock_irq (&ohci->lock);
1da177e4 193
1da177e4 194 /* Some controllers (lucent erratum) need extra-long delays */
f197b2c5 195 msleep (20 /* usb 11.5.1.10 */ + 12 /* 32 msec counter */ + 1);
1da177e4
LT		 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");
565402ba 201 spin_lock_irq(&ohci->lock);
1da177e4
LT		 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
8d1a243b
AS		 216 /* the following code is executed with ohci->lock held and
217 * irqs disabled if and only if autostopped is true
218 */
219
220skip_resume:
1da177e4
LT		 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);
1da177e4
LT		 225
226 /* Then re-enable operations */
227 ohci_writel (ohci, OHCI_USB_OPER, &ohci->regs->control);
228 (void) ohci_readl (ohci, &ohci->regs->control);
8d1a243b
AS		 229 if (!autostopped)
230 msleep (3);
1da177e4 231
6a9062f3
DB		 232 temp = ohci->hc_control;
233 temp &= OHCI_CTRL_RWC;
234 temp |= OHCI_CONTROL_INIT | OHCI_USB_OPER;
1da177e4
LT		 235 ohci->hc_control = temp;
236 ohci_writel (ohci, temp, &ohci->regs->control);
237 (void) ohci_readl (ohci, &ohci->regs->control);
238
239 /* TRSMRCY */
8d1a243b
AS		 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 */
1da177e4 245
d413984a
DB		 246 /* keep it alive for more than ~5x suspend + resume costs */
247 ohci->next_statechange = jiffies + STATECHANGE_DELAY;
1da177e4
LT		 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
b7463c71 278 ohci->rh_state = OHCI_RH_RUNNING;
1da177e4
LT		 279 return 0;
280}
281
8d1a243b
AS		 282static 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
541c7d43 289 if (unlikely(!HCD_HW_ACCESSIBLE(hcd)))
8d1a243b
AS		 290 rc = -ESHUTDOWN;
291 else
292 rc = ohci_rh_suspend (ohci, 0);
293 spin_unlock_irq (&ohci->lock);
294 return rc;
295}
296
297static 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
541c7d43 307 if (unlikely(!HCD_HW_ACCESSIBLE(hcd)))
8d1a243b
AS		 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
1f9fc882
AS		 319/* Carry out polling-, autostop-, and autoresume-related state changes */
320static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
71b7497c 321 int any_connected, int rhsc_status)
1f9fc882
AS		 322{
323 int poll_rh = 1;
71b7497c 324 int rhsc_enable;
1f9fc882 325
ee0b9be8 326 /* Some broken controllers never turn off RHSC in the interrupt
4a511bc3
AS		 327 * status register. For their sake we won't re-enable RHSC
328 * interrupts if the interrupt bit is already active.
329 */
4a511bc3
AS		 330 rhsc_enable = ohci_readl(ohci, &ohci->regs->intrenable) &
331 OHCI_INTR_RHSC;
1f9fc882 332
4a511bc3 333 switch (ohci->hc_control & OHCI_CTRL_HCFS) {
1f9fc882 334 case OHCI_USB_OPER:
4a511bc3
AS		 335 /* If no status changes are pending, enable RHSC interrupts. */
336 if (!rhsc_enable && !rhsc_status && !changed) {
337 rhsc_enable = OHCI_INTR_RHSC;
338 ohci_writel(ohci, rhsc_enable, &ohci->regs->intrenable);
b5fb454f
AS		 339 }
340
341 /* Keep on polling until we know a device is connected
342 * and RHSC is enabled, or until we autostop.
343 */
1f9fc882
AS		 344 if (!ohci->autostop) {
345 if (any_connected ||
346 !device_may_wakeup(&ohci_to_hcd(ohci)
347 ->self.root_hub->dev)) {
4a511bc3 348 if (rhsc_enable)
1f9fc882
AS		 349 poll_rh = 0;
350 } else {
351 ohci->autostop = 1;
352 ohci->next_statechange = jiffies + HZ;
353 }
354
355 /* if no devices have been attached for one second, autostop */
356 } else {
357 if (changed || any_connected) {
358 ohci->autostop = 0;
359 ohci->next_statechange = jiffies +
360 STATECHANGE_DELAY;
4a511bc3 361 } else if (time_after_eq(jiffies,
1f9fc882
AS		 362 ohci->next_statechange)
363 && !ohci->ed_rm_list
364 && !(ohci->hc_control &
365 OHCI_SCHED_ENABLES)) {
366 ohci_rh_suspend(ohci, 1);
4a511bc3
AS		 367 if (rhsc_enable)
368 poll_rh = 0;
1f9fc882
AS		 369 }
370 }
371 break;
372
1f9fc882
AS		 373 case OHCI_USB_SUSPEND:
374 case OHCI_USB_RESUME:
4a511bc3 375 /* if there is a port change, autostart or ask to be resumed */
1f9fc882
AS		 376 if (changed) {
377 if (ohci->autostop)
378 ohci_rh_resume(ohci);
379 else
380 usb_hcd_resume_root_hub(ohci_to_hcd(ohci));
71b7497c
AS		 381
382 /* If remote wakeup is disabled, stop polling */
383 } else if (!ohci->autostop &&
384 !ohci_to_hcd(ohci)->self.root_hub->
385 do_remote_wakeup) {
386 poll_rh = 0;
387
1f9fc882 388 } else {
71b7497c
AS		 389 /* If no status changes are pending,
390 * enable RHSC interrupts
391 */
392 if (!rhsc_enable && !rhsc_status) {
4a511bc3
AS		 393 rhsc_enable = OHCI_INTR_RHSC;
394 ohci_writel(ohci, rhsc_enable,
b5fb454f 395 &ohci->regs->intrenable);
4a511bc3 396 }
71b7497c 397 /* Keep polling until RHSC is enabled */
4a511bc3
AS		 398 if (rhsc_enable)
399 poll_rh = 0;
1f9fc882
AS		 400 }
401 break;
402 }
403 return poll_rh;
404}
405
406#else /* CONFIG_PM */
407
408static inline int ohci_rh_resume(struct ohci_hcd *ohci)
409{
410 return 0;
411}
412
413/* Carry out polling-related state changes.
414 * autostop isn't used when CONFIG_PM is turned off.
415 */
416static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
71b7497c 417 int any_connected, int rhsc_status)
1f9fc882 418{
b5fb454f 419 /* If RHSC is enabled, don't poll */
09ca8adb 420 if (ohci_readl(ohci, &ohci->regs->intrenable) & OHCI_INTR_RHSC)
b5fb454f
AS		 421 return 0;
422
71b7497c
AS		 423 /* If status changes are pending, continue polling.
424 * Conversely, if no status changes are pending but the RHSC
425 * status bit was set, then RHSC may be broken so continue polling.
426 */
427 if (changed || rhsc_status)
428 return 1;
429
430 /* It's safe to re-enable RHSC interrupts */
431 ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrenable);
432 return 0;
1f9fc882
AS		 433}
434
8ad7fe16 435#endif /* CONFIG_PM */
1da177e4
LT		 436
437/*-------------------------------------------------------------------------*/
438
439/* build "status change" packet (one or two bytes) from HC registers */
440
441static int
442ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
443{
444 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
fdd13b36 445 int i, changed = 0, length = 1;
052ac01a 446 int any_connected = 0;
71b7497c 447 int rhsc_status;
1da177e4
LT		 448 unsigned long flags;
449
450 spin_lock_irqsave (&ohci->lock, flags);
541c7d43 451 if (!HCD_HW_ACCESSIBLE(hcd))
6fd75b19 452 goto done;
1da177e4 453
fdd13b36
DB		 454 /* undocumented erratum seen on at least rev D */
455 if ((ohci->flags & OHCI_QUIRK_AMD756)
456 && (roothub_a (ohci) & RH_A_NDP) > MAX_ROOT_PORTS) {
457 ohci_warn (ohci, "bogus NDP, rereads as NDP=%d\n",
1da177e4
LT		 458 ohci_readl (ohci, &ohci->regs->roothub.a) & RH_A_NDP);
459 /* retry later; "should not happen" */
460 goto done;
461 }
462
463 /* init status */
464 if (roothub_status (ohci) & (RH_HS_LPSC | RH_HS_OCIC))
465 buf [0] = changed = 1;
466 else
467 buf [0] = 0;
fdd13b36 468 if (ohci->num_ports > 7) {
1da177e4
LT		 469 buf [1] = 0;
470 length++;
471 }
472
71b7497c
AS		 473 /* Clear the RHSC status flag before reading the port statuses */
474 ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrstatus);
475 rhsc_status = ohci_readl(ohci, &ohci->regs->intrstatus) &
476 OHCI_INTR_RHSC;
477
1da177e4 478 /* look at each port */
fdd13b36 479 for (i = 0; i < ohci->num_ports; i++) {
1da177e4
LT		 480 u32 status = roothub_portstatus (ohci, i);
481
8d1a243b
AS		 482 /* can't autostop if ports are connected */
483 any_connected |= (status & RH_PS_CCS);
484
1da177e4
LT		 485 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
486 | RH_PS_OCIC | RH_PS_PRSC)) {
487 changed = 1;
488 if (i < 7)
489 buf [0] |= 1 << (i + 1);
490 else
491 buf [1] |= 1 << (i - 7);
1da177e4 492 }
d413984a 493 }
1da177e4 494
541c7d43
AS		 495 if (ohci_root_hub_state_changes(ohci, changed,
496 any_connected, rhsc_status))
497 set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
498 else
499 clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
500
d413984a 501
1da177e4
LT		 502done:
503 spin_unlock_irqrestore (&ohci->lock, flags);
504
1da177e4
LT		 505 return changed ? length : 0;
506}
507
508/*-------------------------------------------------------------------------*/
509
510static void
511ohci_hub_descriptor (
512 struct ohci_hcd *ohci,
513 struct usb_hub_descriptor *desc
514) {
515 u32 rh = roothub_a (ohci);
1da177e4
LT		 516 u16 temp;
517
518 desc->bDescriptorType = 0x29;
519 desc->bPwrOn2PwrGood = (rh & RH_A_POTPGT) >> 24;
520 desc->bHubContrCurrent = 0;
521
fdd13b36
DB		 522 desc->bNbrPorts = ohci->num_ports;
523 temp = 1 + (ohci->num_ports / 8);
1da177e4
LT		 524 desc->bDescLength = 7 + 2 * temp;
525
526 temp = 0;
527 if (rh & RH_A_NPS) /* no power switching? */
528 temp |= 0x0002;
dd9048af 529 if (rh & RH_A_PSM) /* per-port power switching? */
1da177e4
LT		 530 temp |= 0x0001;
531 if (rh & RH_A_NOCP) /* no overcurrent reporting? */
532 temp |= 0x0010;
533 else if (rh & RH_A_OCPM) /* per-port overcurrent reporting? */
534 temp |= 0x0008;
535 desc->wHubCharacteristics = (__force __u16)cpu_to_hc16(ohci, temp);
536
da13051c 537 /* ports removable, and usb 1.0 legacy PortPwrCtrlMask */
1da177e4 538 rh = roothub_b (ohci);
dbe79bbe
JY		 539 memset(desc->u.hs.DeviceRemovable, 0xff,
540 sizeof(desc->u.hs.DeviceRemovable));
541 desc->u.hs.DeviceRemovable[0] = rh & RH_B_DR;
fdd13b36 542 if (ohci->num_ports > 7) {
dbe79bbe
JY		 543 desc->u.hs.DeviceRemovable[1] = (rh & RH_B_DR) >> 8;
544 desc->u.hs.DeviceRemovable[2] = 0xff;
1da177e4 545 } else
dbe79bbe 546 desc->u.hs.DeviceRemovable[1] = 0xff;
1da177e4
LT		 547}
548
549/*-------------------------------------------------------------------------*/
550
551#ifdef CONFIG_USB_OTG
552
553static int ohci_start_port_reset (struct usb_hcd *hcd, unsigned port)
554{
555 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
556 u32 status;
557
558 if (!port)
559 return -EINVAL;
560 port--;
561
562 /* start port reset before HNP protocol times out */
563 status = ohci_readl(ohci, &ohci->regs->roothub.portstatus [port]);
564 if (!(status & RH_PS_CCS))
565 return -ENODEV;
566
567 /* khubd will finish the reset later */
568 ohci_writel(ohci, RH_PS_PRS, &ohci->regs->roothub.portstatus [port]);
569 return 0;
570}
571
1da177e4
LT		 572#else
573
574#define ohci_start_port_reset NULL
575
576#endif
577
578/*-------------------------------------------------------------------------*/
579
580
581/* See usb 7.1.7.5: root hubs must issue at least 50 msec reset signaling,
582 * not necessarily continuous ... to guard against resume signaling.
583 * The short timeout is safe for non-root hubs, and is backward-compatible
584 * with earlier Linux hosts.
585 */
586#ifdef CONFIG_USB_SUSPEND
587#define PORT_RESET_MSEC 50
588#else
589#define PORT_RESET_MSEC 10
590#endif
591
592/* this timer value might be vendor-specific ... */
593#define PORT_RESET_HW_MSEC 10
594
595/* wrap-aware logic morphed from <linux/jiffies.h> */
596#define tick_before(t1,t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0)
597
598/* called from some task, normally khubd */
23d10a9e 599static inline int root_port_reset (struct ohci_hcd *ohci, unsigned port)
1da177e4
LT		 600{
601 __hc32 __iomem *portstat = &ohci->regs->roothub.portstatus [port];
1b7b61c5 602 u32 temp = 0;
1da177e4
LT		 603 u16 now = ohci_readl(ohci, &ohci->regs->fmnumber);
604 u16 reset_done = now + PORT_RESET_MSEC;
e01e7fe3 605 int limit_1 = DIV_ROUND_UP(PORT_RESET_MSEC, PORT_RESET_HW_MSEC);
1da177e4
LT		 606
607 /* build a "continuous enough" reset signal, with up to
608 * 3msec gap between pulses. scheduler HZ==100 must work;
609 * this might need to be deadline-scheduled.
610 */
611 do {
e01e7fe3
DB		 612 int limit_2;
613
1da177e4 614 /* spin until any current reset finishes */
e01e7fe3
DB		 615 limit_2 = PORT_RESET_HW_MSEC * 2;
616 while (--limit_2 >= 0) {
1da177e4 617 temp = ohci_readl (ohci, portstat);
23d10a9e
TO		 618 /* handle e.g. CardBus eject */
619 if (temp == ~(u32)0)
620 return -ESHUTDOWN;
1da177e4
LT		 621 if (!(temp & RH_PS_PRS))
622 break;
623 udelay (500);
dd9048af 624 }
1da177e4 625
e01e7fe3
DB		 626 /* timeout (a hardware error) has been observed when
627 * EHCI sets CF while this driver is resetting a port;
628 * presumably other disconnect paths might do it too.
629 */
630 if (limit_2 < 0) {
631 ohci_dbg(ohci,
632 "port[%d] reset timeout, stat %08x\n",
633 port, temp);
634 break;
635 }
636
1da177e4
LT		 637 if (!(temp & RH_PS_CCS))
638 break;
639 if (temp & RH_PS_PRSC)
640 ohci_writel (ohci, RH_PS_PRSC, portstat);
641
642 /* start the next reset, sleep till it's probably done */
643 ohci_writel (ohci, RH_PS_PRS, portstat);
644 msleep(PORT_RESET_HW_MSEC);
645 now = ohci_readl(ohci, &ohci->regs->fmnumber);
e01e7fe3
DB		 646 } while (tick_before(now, reset_done) && --limit_1 >= 0);
647
648 /* caller synchronizes using PRSC ... and handles PRS
649 * still being set when this returns.
650 */
23d10a9e
TO		 651
652 return 0;
1da177e4
LT		 653}
654
655static int ohci_hub_control (
656 struct usb_hcd *hcd,
657 u16 typeReq,
658 u16 wValue,
659 u16 wIndex,
660 char *buf,
661 u16 wLength
662) {
663 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
fcf7d214 664 int ports = ohci->num_ports;
1da177e4
LT		 665 u32 temp;
666 int retval = 0;
667
541c7d43 668 if (unlikely(!HCD_HW_ACCESSIBLE(hcd)))
8de98402
BH		 669 return -ESHUTDOWN;
670
1da177e4
LT		 671 switch (typeReq) {
672 case ClearHubFeature:
673 switch (wValue) {
674 case C_HUB_OVER_CURRENT:
675 ohci_writel (ohci, RH_HS_OCIC,
676 &ohci->regs->roothub.status);
677 case C_HUB_LOCAL_POWER:
678 break;
679 default:
680 goto error;
681 }
682 break;
683 case ClearPortFeature:
684 if (!wIndex || wIndex > ports)
685 goto error;
686 wIndex--;
687
688 switch (wValue) {
689 case USB_PORT_FEAT_ENABLE:
690 temp = RH_PS_CCS;
691 break;
692 case USB_PORT_FEAT_C_ENABLE:
693 temp = RH_PS_PESC;
694 break;
695 case USB_PORT_FEAT_SUSPEND:
696 temp = RH_PS_POCI;
1da177e4
LT		 697 break;
698 case USB_PORT_FEAT_C_SUSPEND:
699 temp = RH_PS_PSSC;
700 break;
701 case USB_PORT_FEAT_POWER:
702 temp = RH_PS_LSDA;
703 break;
704 case USB_PORT_FEAT_C_CONNECTION:
705 temp = RH_PS_CSC;
706 break;
707 case USB_PORT_FEAT_C_OVER_CURRENT:
708 temp = RH_PS_OCIC;
709 break;
710 case USB_PORT_FEAT_C_RESET:
711 temp = RH_PS_PRSC;
712 break;
713 default:
714 goto error;
715 }
716 ohci_writel (ohci, temp,
717 &ohci->regs->roothub.portstatus [wIndex]);
718 // ohci_readl (ohci, &ohci->regs->roothub.portstatus [wIndex]);
719 break;
720 case GetHubDescriptor:
721 ohci_hub_descriptor (ohci, (struct usb_hub_descriptor *) buf);
722 break;
723 case GetHubStatus:
724 temp = roothub_status (ohci) & ~(RH_HS_CRWE | RH_HS_DRWE);
a5abdeaf 725 put_unaligned_le32(temp, buf);
1da177e4
LT		 726 break;
727 case GetPortStatus:
728 if (!wIndex || wIndex > ports)
729 goto error;
730 wIndex--;
731 temp = roothub_portstatus (ohci, wIndex);
a5abdeaf 732 put_unaligned_le32(temp, buf);
1da177e4
LT		 733
734#ifndef OHCI_VERBOSE_DEBUG
735 if (*(u16*)(buf+2)) /* only if wPortChange is interesting */
736#endif
737 dbg_port (ohci, "GetStatus", wIndex, temp);
738 break;
739 case SetHubFeature:
740 switch (wValue) {
741 case C_HUB_OVER_CURRENT:
742 // FIXME: this can be cleared, yes?
743 case C_HUB_LOCAL_POWER:
744 break;
745 default:
746 goto error;
747 }
748 break;
749 case SetPortFeature:
750 if (!wIndex || wIndex > ports)
751 goto error;
752 wIndex--;
753 switch (wValue) {
754 case USB_PORT_FEAT_SUSPEND:
755#ifdef CONFIG_USB_OTG
756 if (hcd->self.otg_port == (wIndex + 1)
757 && hcd->self.b_hnp_enable)
e8b24450 758 ohci->start_hnp(ohci);
1da177e4
LT		 759 else
760#endif
761 ohci_writel (ohci, RH_PS_PSS,
762 &ohci->regs->roothub.portstatus [wIndex]);
763 break;
764 case USB_PORT_FEAT_POWER:
765 ohci_writel (ohci, RH_PS_PPS,
766 &ohci->regs->roothub.portstatus [wIndex]);
767 break;
768 case USB_PORT_FEAT_RESET:
23d10a9e 769 retval = root_port_reset (ohci, wIndex);
1da177e4
LT		 770 break;
771 default:
772 goto error;
773 }
774 break;
775
776 default:
777error:
778 /* "protocol stall" on error */
779 retval = -EPIPE;
780 }
781 return retval;
782}
783
Linux kernel - Deliverables
This page took 1.224397 seconds and 5 git commands to generate.