2 * OHCI HCD (Host Controller Driver) for USB.
4 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
5 * (C) Copyright 2000-2004 David Brownell <dbrownell@users.sourceforge.net>
7 * This file is licenced under GPL
10 /*-------------------------------------------------------------------------*/
13 * OHCI Root Hub ... the nonsharable stuff
16 #define dbg_port(hc,label,num,value) \
18 "%s roothub.portstatus [%d] " \
19 "= 0x%08x%s%s%s%s%s%s%s%s%s%s%s%s\n", \
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" : "", \
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" : "", \
33 (temp & RH_PS_PES) ? " PES" : "", \
34 (temp & RH_PS_CCS) ? " CCS" : "" \
37 /*-------------------------------------------------------------------------*/
39 #define OHCI_SCHED_ENABLES \
40 (OHCI_CTRL_CLE|OHCI_CTRL_BLE|OHCI_CTRL_PLE|OHCI_CTRL_IE)
42 static void dl_done_list (struct ohci_hcd
*);
43 static void finish_unlinks (struct ohci_hcd
*, u16
);
46 static int ohci_rh_suspend (struct ohci_hcd
*ohci
, int autostop
)
47 __releases(ohci
->lock
)
48 __acquires(ohci
->lock
)
52 ohci
->hc_control
= ohci_readl (ohci
, &ohci
->regs
->control
);
53 switch (ohci
->hc_control
& OHCI_CTRL_HCFS
) {
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
);
63 ohci_dbg (ohci
, "needs reinit!\n");
65 case OHCI_USB_SUSPEND
:
66 if (!ohci
->autostop
) {
67 ohci_dbg (ohci
, "already suspended\n");
71 ohci_dbg (ohci
, "%s root hub\n",
72 autostop
? "auto-stop" : "suspend");
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
);
81 /* sched disables take effect on the next frame,
82 * then the last WDH could take 6+ msec
84 ohci_dbg (ohci
, "stopping schedules ...\n");
86 spin_unlock_irq (&ohci
->lock
);
88 spin_lock_irq (&ohci
->lock
);
91 finish_unlinks (ohci
, ohci_frame_no(ohci
));
93 /* maybe resume can wake root hub */
94 if (ohci_to_hcd(ohci
)->self
.root_hub
->do_remote_wakeup
|| autostop
) {
95 ohci
->hc_control
|= OHCI_CTRL_RWE
;
97 ohci_writel(ohci
, OHCI_INTR_RHSC
| OHCI_INTR_RD
,
98 &ohci
->regs
->intrdisable
);
99 ohci
->hc_control
&= ~OHCI_CTRL_RWE
;
102 /* Suspend hub ... this is the "global (to this bus) suspend" mode,
103 * which doesn't imply ports will first be individually suspended.
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
);
110 /* no resumes until devices finish suspending */
112 ohci
->next_statechange
= jiffies
+ msecs_to_jiffies (5);
120 static inline struct ed
*find_head (struct ed
*ed
)
122 /* for bulk and control lists */
128 /* caller has locked the root hub */
129 static int ohci_rh_resume (struct ohci_hcd
*ohci
)
130 __releases(ohci
->lock
)
131 __acquires(ohci
->lock
)
133 struct usb_hcd
*hcd
= ohci_to_hcd (ohci
);
135 int status
= -EINPROGRESS
;
136 int autostopped
= ohci
->autostop
;
139 ohci
->hc_control
= ohci_readl (ohci
, &ohci
->regs
->control
);
141 if (ohci
->hc_control
& (OHCI_CTRL_IR
| OHCI_SCHED_ENABLES
)) {
142 /* this can happen after resuming a swsusp snapshot */
143 if (hcd
->state
== HC_STATE_RESUMING
) {
144 ohci_dbg (ohci
, "BIOS/SMM active, control %03x\n",
147 /* this happens when pmcore resumes HC then root */
149 ohci_dbg (ohci
, "duplicate resume\n");
152 } else switch (ohci
->hc_control
& OHCI_CTRL_HCFS
) {
153 case OHCI_USB_SUSPEND
:
154 ohci
->hc_control
&= ~(OHCI_CTRL_HCFS
|OHCI_SCHED_ENABLES
);
155 ohci
->hc_control
|= OHCI_USB_RESUME
;
156 ohci_writel (ohci
, ohci
->hc_control
, &ohci
->regs
->control
);
157 (void) ohci_readl (ohci
, &ohci
->regs
->control
);
158 ohci_dbg (ohci
, "%s root hub\n",
159 autostopped
? "auto-start" : "resume");
161 case OHCI_USB_RESUME
:
162 /* HCFS changes sometime after INTR_RD */
163 ohci_dbg(ohci
, "%swakeup root hub\n",
164 autostopped
? "auto-" : "");
167 /* this can happen after resuming a swsusp snapshot */
168 ohci_dbg (ohci
, "snapshot resume? reinit\n");
171 default: /* RESET, we lost power */
172 ohci_dbg (ohci
, "lost power\n");
175 if (status
== -EBUSY
) {
177 spin_unlock_irq (&ohci
->lock
);
178 (void) ohci_init (ohci
);
179 status
= ohci_restart (ohci
);
181 usb_root_hub_lost_power(hcd
->self
.root_hub
);
183 spin_lock_irq (&ohci
->lock
);
187 if (status
!= -EINPROGRESS
)
191 spin_unlock_irq (&ohci
->lock
);
193 /* Some controllers (lucent erratum) need extra-long delays */
194 msleep (20 /* usb 11.5.1.10 */ + 12 /* 32 msec counter */ + 1);
196 temp
= ohci_readl (ohci
, &ohci
->regs
->control
);
197 temp
&= OHCI_CTRL_HCFS
;
198 if (temp
!= OHCI_USB_RESUME
) {
199 ohci_err (ohci
, "controller won't resume\n");
200 spin_lock_irq(&ohci
->lock
);
204 /* disable old schedule state, reinit from scratch */
205 ohci_writel (ohci
, 0, &ohci
->regs
->ed_controlhead
);
206 ohci_writel (ohci
, 0, &ohci
->regs
->ed_controlcurrent
);
207 ohci_writel (ohci
, 0, &ohci
->regs
->ed_bulkhead
);
208 ohci_writel (ohci
, 0, &ohci
->regs
->ed_bulkcurrent
);
209 ohci_writel (ohci
, 0, &ohci
->regs
->ed_periodcurrent
);
210 ohci_writel (ohci
, (u32
) ohci
->hcca_dma
, &ohci
->regs
->hcca
);
212 /* Sometimes PCI D3 suspend trashes frame timings ... */
213 periodic_reinit (ohci
);
215 /* the following code is executed with ohci->lock held and
216 * irqs disabled if and only if autostopped is true
220 /* interrupts might have been disabled */
221 ohci_writel (ohci
, OHCI_INTR_INIT
, &ohci
->regs
->intrenable
);
222 if (ohci
->ed_rm_list
)
223 ohci_writel (ohci
, OHCI_INTR_SF
, &ohci
->regs
->intrenable
);
225 /* Then re-enable operations */
226 ohci_writel (ohci
, OHCI_USB_OPER
, &ohci
->regs
->control
);
227 (void) ohci_readl (ohci
, &ohci
->regs
->control
);
231 temp
= ohci
->hc_control
;
232 temp
&= OHCI_CTRL_RWC
;
233 temp
|= OHCI_CONTROL_INIT
| OHCI_USB_OPER
;
234 ohci
->hc_control
= temp
;
235 ohci_writel (ohci
, temp
, &ohci
->regs
->control
);
236 (void) ohci_readl (ohci
, &ohci
->regs
->control
);
241 spin_lock_irq (&ohci
->lock
);
243 /* now ohci->lock is always held and irqs are always disabled */
245 /* keep it alive for more than ~5x suspend + resume costs */
246 ohci
->next_statechange
= jiffies
+ STATECHANGE_DELAY
;
248 /* maybe turn schedules back on */
251 if (!ohci
->ed_rm_list
) {
252 if (ohci
->ed_controltail
) {
254 find_head (ohci
->ed_controltail
)->dma
,
255 &ohci
->regs
->ed_controlhead
);
256 enables
|= OHCI_CTRL_CLE
;
259 if (ohci
->ed_bulktail
) {
260 ohci_writel (ohci
, find_head (ohci
->ed_bulktail
)->dma
,
261 &ohci
->regs
->ed_bulkhead
);
262 enables
|= OHCI_CTRL_BLE
;
266 if (hcd
->self
.bandwidth_isoc_reqs
|| hcd
->self
.bandwidth_int_reqs
)
267 enables
|= OHCI_CTRL_PLE
|OHCI_CTRL_IE
;
269 ohci_dbg (ohci
, "restarting schedules ... %08x\n", enables
);
270 ohci
->hc_control
|= enables
;
271 ohci_writel (ohci
, ohci
->hc_control
, &ohci
->regs
->control
);
273 ohci_writel (ohci
, temp
, &ohci
->regs
->cmdstatus
);
274 (void) ohci_readl (ohci
, &ohci
->regs
->control
);
280 static int ohci_bus_suspend (struct usb_hcd
*hcd
)
282 struct ohci_hcd
*ohci
= hcd_to_ohci (hcd
);
285 spin_lock_irq (&ohci
->lock
);
287 if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE
, &hcd
->flags
)))
290 rc
= ohci_rh_suspend (ohci
, 0);
291 spin_unlock_irq (&ohci
->lock
);
295 static int ohci_bus_resume (struct usb_hcd
*hcd
)
297 struct ohci_hcd
*ohci
= hcd_to_ohci (hcd
);
300 if (time_before (jiffies
, ohci
->next_statechange
))
303 spin_lock_irq (&ohci
->lock
);
305 if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE
, &hcd
->flags
)))
308 rc
= ohci_rh_resume (ohci
);
309 spin_unlock_irq (&ohci
->lock
);
311 /* poll until we know a device is connected or we autostop */
313 usb_hcd_poll_rh_status(hcd
);
317 /* Carry out the final steps of resuming the controller device */
318 static void ohci_finish_controller_resume(struct usb_hcd
*hcd
)
320 struct ohci_hcd
*ohci
= hcd_to_ohci(hcd
);
322 bool need_reinit
= false;
324 /* See if the controller is already running or has been reset */
325 ohci
->hc_control
= ohci_readl(ohci
, &ohci
->regs
->control
);
326 if (ohci
->hc_control
& (OHCI_CTRL_IR
| OHCI_SCHED_ENABLES
)) {
329 switch (ohci
->hc_control
& OHCI_CTRL_HCFS
) {
336 /* If needed, reinitialize and suspend the root hub */
338 spin_lock_irq(&ohci
->lock
);
339 hcd
->state
= HC_STATE_RESUMING
;
340 ohci_rh_resume(ohci
);
341 hcd
->state
= HC_STATE_QUIESCING
;
342 ohci_rh_suspend(ohci
, 0);
343 hcd
->state
= HC_STATE_SUSPENDED
;
344 spin_unlock_irq(&ohci
->lock
);
347 /* Normally just turn on port power and enable interrupts */
349 ohci_dbg(ohci
, "powerup ports\n");
350 for (port
= 0; port
< ohci
->num_ports
; port
++)
351 ohci_writel(ohci
, RH_PS_PPS
,
352 &ohci
->regs
->roothub
.portstatus
[port
]);
354 ohci_writel(ohci
, OHCI_INTR_MIE
, &ohci
->regs
->intrenable
);
355 ohci_readl(ohci
, &ohci
->regs
->intrenable
);
360 /* Carry out polling-, autostop-, and autoresume-related state changes */
361 static int ohci_root_hub_state_changes(struct ohci_hcd
*ohci
, int changed
,
365 int rhsc_status
, rhsc_enable
;
367 /* Some broken controllers never turn off RHCS in the interrupt
368 * status register. For their sake we won't re-enable RHSC
369 * interrupts if the interrupt bit is already active.
371 rhsc_status
= ohci_readl(ohci
, &ohci
->regs
->intrstatus
) &
373 rhsc_enable
= ohci_readl(ohci
, &ohci
->regs
->intrenable
) &
376 switch (ohci
->hc_control
& OHCI_CTRL_HCFS
) {
378 /* If no status changes are pending, enable RHSC interrupts. */
379 if (!rhsc_enable
&& !rhsc_status
&& !changed
) {
380 rhsc_enable
= OHCI_INTR_RHSC
;
381 ohci_writel(ohci
, rhsc_enable
, &ohci
->regs
->intrenable
);
384 /* Keep on polling until we know a device is connected
385 * and RHSC is enabled, or until we autostop.
387 if (!ohci
->autostop
) {
389 !device_may_wakeup(&ohci_to_hcd(ohci
)
390 ->self
.root_hub
->dev
)) {
395 ohci
->next_statechange
= jiffies
+ HZ
;
398 /* if no devices have been attached for one second, autostop */
400 if (changed
|| any_connected
) {
402 ohci
->next_statechange
= jiffies
+
404 } else if (time_after_eq(jiffies
,
405 ohci
->next_statechange
)
407 && !(ohci
->hc_control
&
408 OHCI_SCHED_ENABLES
)) {
409 ohci_rh_suspend(ohci
, 1);
416 case OHCI_USB_SUSPEND
:
417 case OHCI_USB_RESUME
:
418 /* if there is a port change, autostart or ask to be resumed */
421 ohci_rh_resume(ohci
);
423 usb_hcd_resume_root_hub(ohci_to_hcd(ohci
));
425 if (!rhsc_enable
&& !rhsc_status
&& (ohci
->autostop
||
426 ohci_to_hcd(ohci
)->self
.root_hub
->
428 rhsc_enable
= OHCI_INTR_RHSC
;
429 ohci_writel(ohci
, rhsc_enable
,
430 &ohci
->regs
->intrenable
);
440 #else /* CONFIG_PM */
442 static inline int ohci_rh_resume(struct ohci_hcd
*ohci
)
447 /* Carry out polling-related state changes.
448 * autostop isn't used when CONFIG_PM is turned off.
450 static int ohci_root_hub_state_changes(struct ohci_hcd
*ohci
, int changed
,
455 /* If RHSC is enabled, don't poll */
456 if (ohci_readl(ohci
, &ohci
->regs
->intrenable
) & OHCI_INTR_RHSC
)
459 /* If no status changes are pending, enable RHSC interrupts */
460 rhsc_status
= ohci_readl(ohci
, &ohci
->regs
->intrstatus
) &
462 if (!changed
&& !rhsc_status
) {
463 ohci_writel(ohci
, OHCI_INTR_RHSC
, &ohci
->regs
->intrenable
);
469 #endif /* CONFIG_PM */
471 /*-------------------------------------------------------------------------*/
473 /* build "status change" packet (one or two bytes) from HC registers */
476 ohci_hub_status_data (struct usb_hcd
*hcd
, char *buf
)
478 struct ohci_hcd
*ohci
= hcd_to_ohci (hcd
);
479 int i
, changed
= 0, length
= 1;
480 int any_connected
= 0;
483 spin_lock_irqsave (&ohci
->lock
, flags
);
484 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE
, &hcd
->flags
))
487 /* undocumented erratum seen on at least rev D */
488 if ((ohci
->flags
& OHCI_QUIRK_AMD756
)
489 && (roothub_a (ohci
) & RH_A_NDP
) > MAX_ROOT_PORTS
) {
490 ohci_warn (ohci
, "bogus NDP, rereads as NDP=%d\n",
491 ohci_readl (ohci
, &ohci
->regs
->roothub
.a
) & RH_A_NDP
);
492 /* retry later; "should not happen" */
497 if (roothub_status (ohci
) & (RH_HS_LPSC
| RH_HS_OCIC
))
498 buf
[0] = changed
= 1;
501 if (ohci
->num_ports
> 7) {
506 /* look at each port */
507 for (i
= 0; i
< ohci
->num_ports
; i
++) {
508 u32 status
= roothub_portstatus (ohci
, i
);
510 /* can't autostop if ports are connected */
511 any_connected
|= (status
& RH_PS_CCS
);
513 if (status
& (RH_PS_CSC
| RH_PS_PESC
| RH_PS_PSSC
514 | RH_PS_OCIC
| RH_PS_PRSC
)) {
517 buf
[0] |= 1 << (i
+ 1);
519 buf
[1] |= 1 << (i
- 7);
523 hcd
->poll_rh
= ohci_root_hub_state_changes(ohci
, changed
,
527 spin_unlock_irqrestore (&ohci
->lock
, flags
);
529 return changed
? length
: 0;
532 /*-------------------------------------------------------------------------*/
535 ohci_hub_descriptor (
536 struct ohci_hcd
*ohci
,
537 struct usb_hub_descriptor
*desc
539 u32 rh
= roothub_a (ohci
);
542 desc
->bDescriptorType
= 0x29;
543 desc
->bPwrOn2PwrGood
= (rh
& RH_A_POTPGT
) >> 24;
544 desc
->bHubContrCurrent
= 0;
546 desc
->bNbrPorts
= ohci
->num_ports
;
547 temp
= 1 + (ohci
->num_ports
/ 8);
548 desc
->bDescLength
= 7 + 2 * temp
;
551 if (rh
& RH_A_NPS
) /* no power switching? */
553 if (rh
& RH_A_PSM
) /* per-port power switching? */
555 if (rh
& RH_A_NOCP
) /* no overcurrent reporting? */
557 else if (rh
& RH_A_OCPM
) /* per-port overcurrent reporting? */
559 desc
->wHubCharacteristics
= (__force __u16
)cpu_to_hc16(ohci
, temp
);
561 /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */
562 rh
= roothub_b (ohci
);
563 memset(desc
->bitmap
, 0xff, sizeof(desc
->bitmap
));
564 desc
->bitmap
[0] = rh
& RH_B_DR
;
565 if (ohci
->num_ports
> 7) {
566 desc
->bitmap
[1] = (rh
& RH_B_DR
) >> 8;
567 desc
->bitmap
[2] = 0xff;
569 desc
->bitmap
[1] = 0xff;
572 /*-------------------------------------------------------------------------*/
574 #ifdef CONFIG_USB_OTG
576 static int ohci_start_port_reset (struct usb_hcd
*hcd
, unsigned port
)
578 struct ohci_hcd
*ohci
= hcd_to_ohci (hcd
);
585 /* start port reset before HNP protocol times out */
586 status
= ohci_readl(ohci
, &ohci
->regs
->roothub
.portstatus
[port
]);
587 if (!(status
& RH_PS_CCS
))
590 /* khubd will finish the reset later */
591 ohci_writel(ohci
, RH_PS_PRS
, &ohci
->regs
->roothub
.portstatus
[port
]);
597 #define ohci_start_port_reset NULL
601 /*-------------------------------------------------------------------------*/
604 /* See usb 7.1.7.5: root hubs must issue at least 50 msec reset signaling,
605 * not necessarily continuous ... to guard against resume signaling.
606 * The short timeout is safe for non-root hubs, and is backward-compatible
607 * with earlier Linux hosts.
609 #ifdef CONFIG_USB_SUSPEND
610 #define PORT_RESET_MSEC 50
612 #define PORT_RESET_MSEC 10
615 /* this timer value might be vendor-specific ... */
616 #define PORT_RESET_HW_MSEC 10
618 /* wrap-aware logic morphed from <linux/jiffies.h> */
619 #define tick_before(t1,t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0)
621 /* called from some task, normally khubd */
622 static inline int root_port_reset (struct ohci_hcd
*ohci
, unsigned port
)
624 __hc32 __iomem
*portstat
= &ohci
->regs
->roothub
.portstatus
[port
];
626 u16 now
= ohci_readl(ohci
, &ohci
->regs
->fmnumber
);
627 u16 reset_done
= now
+ PORT_RESET_MSEC
;
628 int limit_1
= DIV_ROUND_UP(PORT_RESET_MSEC
, PORT_RESET_HW_MSEC
);
630 /* build a "continuous enough" reset signal, with up to
631 * 3msec gap between pulses. scheduler HZ==100 must work;
632 * this might need to be deadline-scheduled.
637 /* spin until any current reset finishes */
638 limit_2
= PORT_RESET_HW_MSEC
* 2;
639 while (--limit_2
>= 0) {
640 temp
= ohci_readl (ohci
, portstat
);
641 /* handle e.g. CardBus eject */
644 if (!(temp
& RH_PS_PRS
))
649 /* timeout (a hardware error) has been observed when
650 * EHCI sets CF while this driver is resetting a port;
651 * presumably other disconnect paths might do it too.
655 "port[%d] reset timeout, stat %08x\n",
660 if (!(temp
& RH_PS_CCS
))
662 if (temp
& RH_PS_PRSC
)
663 ohci_writel (ohci
, RH_PS_PRSC
, portstat
);
665 /* start the next reset, sleep till it's probably done */
666 ohci_writel (ohci
, RH_PS_PRS
, portstat
);
667 msleep(PORT_RESET_HW_MSEC
);
668 now
= ohci_readl(ohci
, &ohci
->regs
->fmnumber
);
669 } while (tick_before(now
, reset_done
) && --limit_1
>= 0);
671 /* caller synchronizes using PRSC ... and handles PRS
672 * still being set when this returns.
678 static int ohci_hub_control (
686 struct ohci_hcd
*ohci
= hcd_to_ohci (hcd
);
687 int ports
= hcd_to_bus (hcd
)->root_hub
->maxchild
;
691 if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE
, &hcd
->flags
)))
695 case ClearHubFeature
:
697 case C_HUB_OVER_CURRENT
:
698 ohci_writel (ohci
, RH_HS_OCIC
,
699 &ohci
->regs
->roothub
.status
);
700 case C_HUB_LOCAL_POWER
:
706 case ClearPortFeature
:
707 if (!wIndex
|| wIndex
> ports
)
712 case USB_PORT_FEAT_ENABLE
:
715 case USB_PORT_FEAT_C_ENABLE
:
718 case USB_PORT_FEAT_SUSPEND
:
721 case USB_PORT_FEAT_C_SUSPEND
:
724 case USB_PORT_FEAT_POWER
:
727 case USB_PORT_FEAT_C_CONNECTION
:
730 case USB_PORT_FEAT_C_OVER_CURRENT
:
733 case USB_PORT_FEAT_C_RESET
:
739 ohci_writel (ohci
, temp
,
740 &ohci
->regs
->roothub
.portstatus
[wIndex
]);
741 // ohci_readl (ohci, &ohci->regs->roothub.portstatus [wIndex]);
743 case GetHubDescriptor
:
744 ohci_hub_descriptor (ohci
, (struct usb_hub_descriptor
*) buf
);
747 temp
= roothub_status (ohci
) & ~(RH_HS_CRWE
| RH_HS_DRWE
);
748 put_unaligned_le32(temp
, buf
);
751 if (!wIndex
|| wIndex
> ports
)
754 temp
= roothub_portstatus (ohci
, wIndex
);
755 put_unaligned_le32(temp
, buf
);
757 #ifndef OHCI_VERBOSE_DEBUG
758 if (*(u16
*)(buf
+2)) /* only if wPortChange is interesting */
760 dbg_port (ohci
, "GetStatus", wIndex
, temp
);
764 case C_HUB_OVER_CURRENT
:
765 // FIXME: this can be cleared, yes?
766 case C_HUB_LOCAL_POWER
:
773 if (!wIndex
|| wIndex
> ports
)
777 case USB_PORT_FEAT_SUSPEND
:
778 #ifdef CONFIG_USB_OTG
779 if (hcd
->self
.otg_port
== (wIndex
+ 1)
780 && hcd
->self
.b_hnp_enable
)
781 ohci
->start_hnp(ohci
);
784 ohci_writel (ohci
, RH_PS_PSS
,
785 &ohci
->regs
->roothub
.portstatus
[wIndex
]);
787 case USB_PORT_FEAT_POWER
:
788 ohci_writel (ohci
, RH_PS_PPS
,
789 &ohci
->regs
->roothub
.portstatus
[wIndex
]);
791 case USB_PORT_FEAT_RESET
:
792 retval
= root_port_reset (ohci
, wIndex
);
801 /* "protocol stall" on error */