1/*
2 * OHCI HCD (Host Controller Driver) for USB.
3 *
4 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
5 * (C) Copyright 2000-2004 David Brownell <dbrownell@users.sourceforge.net>
6 *
7 * This file is licenced under GPL
8 */
9
10/*-------------------------------------------------------------------------*/
11
12/*
13 * OHCI Root Hub ... the nonsharable stuff
14 */
15
16#define dbg_port(hc,label,num,value) \
17	ohci_dbg (hc, \
18		"%s roothub.portstatus [%d] " \
19		"= 0x%08x%s%s%s%s%s%s%s%s%s%s%s%s\n", \
20		label, num, 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" : "", \
26		\
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" : "", \
32		\
33		(temp & RH_PS_PES) ? " PES" : "", \
34		(temp & RH_PS_CCS) ? " CCS" : "" \
35		);
36
37/*-------------------------------------------------------------------------*/
38
39/* hcd->hub_irq_enable() */
40static void ohci_rhsc_enable (struct usb_hcd *hcd)
41{
42	struct ohci_hcd		*ohci = hcd_to_ohci (hcd);
43
44	spin_lock_irq(&ohci->lock);
45	if (!ohci->autostop)
46		del_timer(&hcd->rh_timer);	/* Prevent next poll */
47	ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrenable);
48	spin_unlock_irq(&ohci->lock);
49}
50
51#define OHCI_SCHED_ENABLES \
52	(OHCI_CTRL_CLE|OHCI_CTRL_BLE|OHCI_CTRL_PLE|OHCI_CTRL_IE)
53
54static void dl_done_list (struct ohci_hcd *);
55static void finish_unlinks (struct ohci_hcd *, u16);
56
57#ifdef	CONFIG_PM
58static int ohci_restart(struct ohci_hcd *ohci);
59
60static int ohci_rh_suspend (struct ohci_hcd *ohci, int autostop)
61__releases(ohci->lock)
62__acquires(ohci->lock)
63{
64	int			status = 0;
65
66	ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);
67	switch (ohci->hc_control & OHCI_CTRL_HCFS) {
68	case OHCI_USB_RESUME:
69		ohci_dbg (ohci, "resume/suspend?\n");
70		ohci->hc_control &= ~OHCI_CTRL_HCFS;
71		ohci->hc_control |= OHCI_USB_RESET;
72		ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
73		(void) ohci_readl (ohci, &ohci->regs->control);
74		/* FALL THROUGH */
75	case OHCI_USB_RESET:
76		status = -EBUSY;
77		ohci_dbg (ohci, "needs reinit!\n");
78		goto done;
79	case OHCI_USB_SUSPEND:
80		if (!ohci->autostop) {
81			ohci_dbg (ohci, "already suspended\n");
82			goto done;
83		}
84	}
85	ohci_dbg (ohci, "%s root hub\n",
86			autostop ? "auto-stop" : "suspend");
87
88	/* First stop any processing */
89	if (!autostop && (ohci->hc_control & OHCI_SCHED_ENABLES)) {
90		ohci->hc_control &= ~OHCI_SCHED_ENABLES;
91		ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
92		ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);
93		ohci_writel (ohci, OHCI_INTR_SF, &ohci->regs->intrstatus);
94
95		/* sched disables take effect on the next frame,
96		 * then the last WDH could take 6+ msec
97		 */
98		ohci_dbg (ohci, "stopping schedules ...\n");
99		ohci->autostop = 0;
100		spin_unlock_irq (&ohci->lock);
101		msleep (8);
102		spin_lock_irq (&ohci->lock);
103	}
104	dl_done_list (ohci);
105	finish_unlinks (ohci, ohci_frame_no(ohci));
106
107	/* maybe resume can wake root hub */
108	if (device_may_wakeup(&ohci_to_hcd(ohci)->self.root_hub->dev) ||
109			autostop)
110		ohci->hc_control |= OHCI_CTRL_RWE;
111	else {
112		ohci_writel (ohci, OHCI_INTR_RHSC, &ohci->regs->intrdisable);
113		ohci->hc_control &= ~OHCI_CTRL_RWE;
114	}
115
116	/* Suspend hub ... this is the "global (to this bus) suspend" mode,
117	 * which doesn't imply ports will first be individually suspended.
118	 */
119	ohci->hc_control &= ~OHCI_CTRL_HCFS;
120	ohci->hc_control |= OHCI_USB_SUSPEND;
121	ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
122	(void) ohci_readl (ohci, &ohci->regs->control);
123
124	/* no resumes until devices finish suspending */
125	if (!autostop) {
126		ohci->next_statechange = jiffies + msecs_to_jiffies (5);
127		ohci->autostop = 0;
128	}
129
130done:
131	return status;
132}
133
134static inline struct ed *find_head (struct ed *ed)
135{
136	/* for bulk and control lists */
137	while (ed->ed_prev)
138		ed = ed->ed_prev;
139	return ed;
140}
141
142/* caller has locked the root hub */
143static int ohci_rh_resume (struct ohci_hcd *ohci)
144__releases(ohci->lock)
145__acquires(ohci->lock)
146{
147	struct usb_hcd		*hcd = ohci_to_hcd (ohci);
148	u32			temp, enables;
149	int			status = -EINPROGRESS;
150	int			autostopped = ohci->autostop;
151
152	ohci->autostop = 0;
153	ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);
154
155	if (ohci->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) {
156		/* this can happen after resuming a swsusp snapshot */
157		if (hcd->state == HC_STATE_RESUMING) {
158			ohci_dbg (ohci, "BIOS/SMM active, control %03x\n",
159					ohci->hc_control);
160			status = -EBUSY;
161		/* this happens when pmcore resumes HC then root */
162		} else {
163			ohci_dbg (ohci, "duplicate resume\n");
164			status = 0;
165		}
166	} else switch (ohci->hc_control & OHCI_CTRL_HCFS) {
167	case OHCI_USB_SUSPEND:
168		ohci->hc_control &= ~(OHCI_CTRL_HCFS|OHCI_SCHED_ENABLES);
169		ohci->hc_control |= OHCI_USB_RESUME;
170		ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
171		(void) ohci_readl (ohci, &ohci->regs->control);
172		ohci_dbg (ohci, "%s root hub\n",
173				autostopped ? "auto-start" : "resume");
174		break;
175	case OHCI_USB_RESUME:
176		/* HCFS changes sometime after INTR_RD */
177		ohci_dbg(ohci, "%swakeup root hub\n",
178				autostopped ? "auto-" : "");
179		break;
180	case OHCI_USB_OPER:
181		/* this can happen after resuming a swsusp snapshot */
182		ohci_dbg (ohci, "snapshot resume? reinit\n");
183		status = -EBUSY;
184		break;
185	default:		/* RESET, we lost power */
186		ohci_dbg (ohci, "lost power\n");
187		status = -EBUSY;
188	}
189	if (status == -EBUSY) {
190		if (!autostopped) {
191			spin_unlock_irq (&ohci->lock);
192			(void) ohci_init (ohci);
193			status = ohci_restart (ohci);
194			spin_lock_irq (&ohci->lock);
195		}
196		return status;
197	}
198	if (status != -EINPROGRESS)
199		return status;
200	if (autostopped)
201		goto skip_resume;
202	spin_unlock_irq (&ohci->lock);
203
204	/* Some controllers (lucent erratum) need extra-long delays */
205	msleep (20 /* usb 11.5.1.10 */ + 12 /* 32 msec counter */ + 1);
206
207	temp = ohci_readl (ohci, &ohci->regs->control);
208	temp &= OHCI_CTRL_HCFS;
209	if (temp != OHCI_USB_RESUME) {
210		ohci_err (ohci, "controller won't resume\n");
211		spin_lock_irq(&ohci->lock);
212		return -EBUSY;
213	}
214
215	/* disable old schedule state, reinit from scratch */
216	ohci_writel (ohci, 0, &ohci->regs->ed_controlhead);
217	ohci_writel (ohci, 0, &ohci->regs->ed_controlcurrent);
218	ohci_writel (ohci, 0, &ohci->regs->ed_bulkhead);
219	ohci_writel (ohci, 0, &ohci->regs->ed_bulkcurrent);
220	ohci_writel (ohci, 0, &ohci->regs->ed_periodcurrent);
221	ohci_writel (ohci, (u32) ohci->hcca_dma, &ohci->regs->hcca);
222
223	/* Sometimes PCI D3 suspend trashes frame timings ... */
224	periodic_reinit (ohci);
225
226	/* the following code is executed with ohci->lock held and
227	 * irqs disabled if and only if autostopped is true
228	 */
229
230skip_resume:
231	/* interrupts might have been disabled */
232	ohci_writel (ohci, OHCI_INTR_INIT, &ohci->regs->intrenable);
233	if (ohci->ed_rm_list)
234		ohci_writel (ohci, OHCI_INTR_SF, &ohci->regs->intrenable);
235
236	/* Then re-enable operations */
237	ohci_writel (ohci, OHCI_USB_OPER, &ohci->regs->control);
238	(void) ohci_readl (ohci, &ohci->regs->control);
239	if (!autostopped)
240		msleep (3);
241
242	temp = ohci->hc_control;
243	temp &= OHCI_CTRL_RWC;
244	temp |= OHCI_CONTROL_INIT | OHCI_USB_OPER;
245	ohci->hc_control = temp;
246	ohci_writel (ohci, temp, &ohci->regs->control);
247	(void) ohci_readl (ohci, &ohci->regs->control);
248
249	/* TRSMRCY */
250	if (!autostopped) {
251		msleep (10);
252		spin_lock_irq (&ohci->lock);
253	}
254	/* now ohci->lock is always held and irqs are always disabled */
255
256	/* keep it alive for more than ~5x suspend + resume costs */
257	ohci->next_statechange = jiffies + STATECHANGE_DELAY;
258
259	/* maybe turn schedules back on */
260	enables = 0;
261	temp = 0;
262	if (!ohci->ed_rm_list) {
263		if (ohci->ed_controltail) {
264			ohci_writel (ohci,
265					find_head (ohci->ed_controltail)->dma,
266					&ohci->regs->ed_controlhead);
267			enables |= OHCI_CTRL_CLE;
268			temp |= OHCI_CLF;
269		}
270		if (ohci->ed_bulktail) {
271			ohci_writel (ohci, find_head (ohci->ed_bulktail)->dma,
272				&ohci->regs->ed_bulkhead);
273			enables |= OHCI_CTRL_BLE;
274			temp |= OHCI_BLF;
275		}
276	}
277	if (hcd->self.bandwidth_isoc_reqs || hcd->self.bandwidth_int_reqs)
278		enables |= OHCI_CTRL_PLE|OHCI_CTRL_IE;
279	if (enables) {
280		ohci_dbg (ohci, "restarting schedules ... %08x\n", enables);
281		ohci->hc_control |= enables;
282		ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
283		if (temp)
284			ohci_writel (ohci, temp, &ohci->regs->cmdstatus);
285		(void) ohci_readl (ohci, &ohci->regs->control);
286	}
287
288	return 0;
289}
290
291static int ohci_bus_suspend (struct usb_hcd *hcd)
292{
293	struct ohci_hcd		*ohci = hcd_to_ohci (hcd);
294	int			rc;
295
296	spin_lock_irq (&ohci->lock);
297
298	if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
299		rc = -ESHUTDOWN;
300	else
301		rc = ohci_rh_suspend (ohci, 0);
302	spin_unlock_irq (&ohci->lock);
303	return rc;
304}
305
306static int ohci_bus_resume (struct usb_hcd *hcd)
307{
308	struct ohci_hcd		*ohci = hcd_to_ohci (hcd);
309	int			rc;
310
311	if (time_before (jiffies, ohci->next_statechange))
312		msleep(5);
313
314	spin_lock_irq (&ohci->lock);
315
316	if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
317		rc = -ESHUTDOWN;
318	else
319		rc = ohci_rh_resume (ohci);
320	spin_unlock_irq (&ohci->lock);
321
322	/* poll until we know a device is connected or we autostop */
323	if (rc == 0)
324		usb_hcd_poll_rh_status(hcd);
325	return rc;
326}
327
328/* Carry out polling-, autostop-, and autoresume-related state changes */
329static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
330		int any_connected)
331{
332	int	poll_rh = 1;
333
334	switch (ohci->hc_control & OHCI_CTRL_HCFS) {
335
336	case OHCI_USB_OPER:
337		/* keep on polling until we know a device is connected
338		 * and RHSC is enabled */
339		if (!ohci->autostop) {
340			if (any_connected ||
341					!device_may_wakeup(&ohci_to_hcd(ohci)
342						->self.root_hub->dev)) {
343				if (ohci_readl(ohci, &ohci->regs->intrenable) &
344						OHCI_INTR_RHSC)
345					poll_rh = 0;
346			} else {
347				ohci->autostop = 1;
348				ohci->next_statechange = jiffies + HZ;
349			}
350
351		/* if no devices have been attached for one second, autostop */
352		} else {
353			if (changed || any_connected) {
354				ohci->autostop = 0;
355				ohci->next_statechange = jiffies +
356						STATECHANGE_DELAY;
357			} else if (time_after_eq(jiffies,
358						ohci->next_statechange)
359					&& !ohci->ed_rm_list
360					&& !(ohci->hc_control &
361						OHCI_SCHED_ENABLES)) {
362				ohci_rh_suspend(ohci, 1);
363			}
364		}
365		break;
366
367	/* if there is a port change, autostart or ask to be resumed */
368	case OHCI_USB_SUSPEND:
369	case OHCI_USB_RESUME:
370		if (changed) {
371			if (ohci->autostop)
372				ohci_rh_resume(ohci);
373			else
374				usb_hcd_resume_root_hub(ohci_to_hcd(ohci));
375		} else {
376			/* everything is idle, no need for polling */
377			poll_rh = 0;
378		}
379		break;
380	}
381	return poll_rh;
382}
383
384#else	/* CONFIG_PM */
385
386static inline int ohci_rh_resume(struct ohci_hcd *ohci)
387{
388	return 0;
389}
390
391/* Carry out polling-related state changes.
392 * autostop isn't used when CONFIG_PM is turned off.
393 */
394static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
395		int any_connected)
396{
397	int	poll_rh = 1;
398
399	/* keep on polling until RHSC is enabled */
400	if (ohci_readl(ohci, &ohci->regs->intrenable) & OHCI_INTR_RHSC)
401		poll_rh = 0;
402	return poll_rh;
403}
404
405#endif	/* CONFIG_PM */
406
407/*-------------------------------------------------------------------------*/
408
409/* build "status change" packet (one or two bytes) from HC registers */
410
411static int
412ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
413{
414	struct ohci_hcd	*ohci = hcd_to_ohci (hcd);
415	int		i, changed = 0, length = 1;
416	int		any_connected = 0;
417	unsigned long	flags;
418
419	spin_lock_irqsave (&ohci->lock, flags);
420	if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))
421		goto done;
422
423	/* undocumented erratum seen on at least rev D */
424	if ((ohci->flags & OHCI_QUIRK_AMD756)
425			&& (roothub_a (ohci) & RH_A_NDP) > MAX_ROOT_PORTS) {
426		ohci_warn (ohci, "bogus NDP, rereads as NDP=%d\n",
427			  ohci_readl (ohci, &ohci->regs->roothub.a) & RH_A_NDP);
428		/* retry later; "should not happen" */
429		goto done;
430	}
431
432	/* init status */
433	if (roothub_status (ohci) & (RH_HS_LPSC | RH_HS_OCIC))
434		buf [0] = changed = 1;
435	else
436		buf [0] = 0;
437	if (ohci->num_ports > 7) {
438		buf [1] = 0;
439		length++;
440	}
441
442	/* look at each port */
443	for (i = 0; i < ohci->num_ports; i++) {
444		u32	status = roothub_portstatus (ohci, i);
445
446		/* can't autostop if ports are connected */
447		any_connected |= (status & RH_PS_CCS);
448
449		if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
450				| RH_PS_OCIC | RH_PS_PRSC)) {
451			changed = 1;
452			if (i < 7)
453			    buf [0] |= 1 << (i + 1);
454			else
455			    buf [1] |= 1 << (i - 7);
456		}
457	}
458
459	hcd->poll_rh = ohci_root_hub_state_changes(ohci, changed,
460			any_connected);
461
462done:
463	spin_unlock_irqrestore (&ohci->lock, flags);
464
465	return changed ? length : 0;
466}
467
468/*-------------------------------------------------------------------------*/
469
470static void
471ohci_hub_descriptor (
472	struct ohci_hcd			*ohci,
473	struct usb_hub_descriptor	*desc
474) {
475	u32		rh = roothub_a (ohci);
476	u16		temp;
477
478	desc->bDescriptorType = 0x29;
479	desc->bPwrOn2PwrGood = (rh & RH_A_POTPGT) >> 24;
480	desc->bHubContrCurrent = 0;
481
482	desc->bNbrPorts = ohci->num_ports;
483	temp = 1 + (ohci->num_ports / 8);
484	desc->bDescLength = 7 + 2 * temp;
485
486	temp = 0;
487	if (rh & RH_A_NPS)		/* no power switching? */
488	    temp |= 0x0002;
489	if (rh & RH_A_PSM)		/* per-port power switching? */
490	    temp |= 0x0001;
491	if (rh & RH_A_NOCP)		/* no overcurrent reporting? */
492	    temp |= 0x0010;
493	else if (rh & RH_A_OCPM)	/* per-port overcurrent reporting? */
494	    temp |= 0x0008;
495	desc->wHubCharacteristics = (__force __u16)cpu_to_hc16(ohci, temp);
496
497	/* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
498	rh = roothub_b (ohci);
499	memset(desc->bitmap, 0xff, sizeof(desc->bitmap));
500	desc->bitmap [0] = rh & RH_B_DR;
501	if (ohci->num_ports > 7) {
502		desc->bitmap [1] = (rh & RH_B_DR) >> 8;
503		desc->bitmap [2] = 0xff;
504	} else
505		desc->bitmap [1] = 0xff;
506}
507
508/*-------------------------------------------------------------------------*/
509
510#ifdef	CONFIG_USB_OTG
511
512static int ohci_start_port_reset (struct usb_hcd *hcd, unsigned port)
513{
514	struct ohci_hcd	*ohci = hcd_to_ohci (hcd);
515	u32			status;
516
517	if (!port)
518		return -EINVAL;
519	port--;
520
521	/* start port reset before HNP protocol times out */
522	status = ohci_readl(ohci, &ohci->regs->roothub.portstatus [port]);
523	if (!(status & RH_PS_CCS))
524		return -ENODEV;
525
526	/* khubd will finish the reset later */
527	ohci_writel(ohci, RH_PS_PRS, &ohci->regs->roothub.portstatus [port]);
528	return 0;
529}
530
531static void start_hnp(struct ohci_hcd *ohci);
532
533#else
534
535#define	ohci_start_port_reset		NULL
536
537#endif
538
539/*-------------------------------------------------------------------------*/
540
541
542/* See usb 7.1.7.5:  root hubs must issue at least 50 msec reset signaling,
543 * not necessarily continuous ... to guard against resume signaling.
544 * The short timeout is safe for non-root hubs, and is backward-compatible
545 * with earlier Linux hosts.
546 */
547#ifdef	CONFIG_USB_SUSPEND
548#define	PORT_RESET_MSEC		50
549#else
550#define	PORT_RESET_MSEC		10
551#endif
552
553/* this timer value might be vendor-specific ... */
554#define	PORT_RESET_HW_MSEC	10
555
556/* wrap-aware logic morphed from <linux/jiffies.h> */
557#define tick_before(t1,t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0)
558
559/* called from some task, normally khubd */
560static inline int root_port_reset (struct ohci_hcd *ohci, unsigned port)
561{
562	__hc32 __iomem *portstat = &ohci->regs->roothub.portstatus [port];
563	u32	temp;
564	u16	now = ohci_readl(ohci, &ohci->regs->fmnumber);
565	u16	reset_done = now + PORT_RESET_MSEC;
566
567	/* build a "continuous enough" reset signal, with up to
568	 * 3msec gap between pulses.  scheduler HZ==100 must work;
569	 * this might need to be deadline-scheduled.
570	 */
571	do {
572		/* spin until any current reset finishes */
573		for (;;) {
574			temp = ohci_readl (ohci, portstat);
575			/* handle e.g. CardBus eject */
576			if (temp == ~(u32)0)
577				return -ESHUTDOWN;
578			if (!(temp & RH_PS_PRS))
579				break;
580			udelay (500);
581		}
582
583		if (!(temp & RH_PS_CCS))
584			break;
585		if (temp & RH_PS_PRSC)
586			ohci_writel (ohci, RH_PS_PRSC, portstat);
587
588		/* start the next reset, sleep till it's probably done */
589		ohci_writel (ohci, RH_PS_PRS, portstat);
590		msleep(PORT_RESET_HW_MSEC);
591		now = ohci_readl(ohci, &ohci->regs->fmnumber);
592	} while (tick_before(now, reset_done));
593	/* caller synchronizes using PRSC */
594
595	return 0;
596}
597
598static int ohci_hub_control (
599	struct usb_hcd	*hcd,
600	u16		typeReq,
601	u16		wValue,
602	u16		wIndex,
603	char		*buf,
604	u16		wLength
605) {
606	struct ohci_hcd	*ohci = hcd_to_ohci (hcd);
607	int		ports = hcd_to_bus (hcd)->root_hub->maxchild;
608	u32		temp;
609	int		retval = 0;
610
611	if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
612		return -ESHUTDOWN;
613
614	switch (typeReq) {
615	case ClearHubFeature:
616		switch (wValue) {
617		case C_HUB_OVER_CURRENT:
618			ohci_writel (ohci, RH_HS_OCIC,
619					&ohci->regs->roothub.status);
620		case C_HUB_LOCAL_POWER:
621			break;
622		default:
623			goto error;
624		}
625		break;
626	case ClearPortFeature:
627		if (!wIndex || wIndex > ports)
628			goto error;
629		wIndex--;
630
631		switch (wValue) {
632		case USB_PORT_FEAT_ENABLE:
633			temp = RH_PS_CCS;
634			break;
635		case USB_PORT_FEAT_C_ENABLE:
636			temp = RH_PS_PESC;
637			break;
638		case USB_PORT_FEAT_SUSPEND:
639			temp = RH_PS_POCI;
640			break;
641		case USB_PORT_FEAT_C_SUSPEND:
642			temp = RH_PS_PSSC;
643			break;
644		case USB_PORT_FEAT_POWER:
645			temp = RH_PS_LSDA;
646			break;
647		case USB_PORT_FEAT_C_CONNECTION:
648			temp = RH_PS_CSC;
649			break;
650		case USB_PORT_FEAT_C_OVER_CURRENT:
651			temp = RH_PS_OCIC;
652			break;
653		case USB_PORT_FEAT_C_RESET:
654			temp = RH_PS_PRSC;
655			break;
656		default:
657			goto error;
658		}
659		ohci_writel (ohci, temp,
660				&ohci->regs->roothub.portstatus [wIndex]);
661		// ohci_readl (ohci, &ohci->regs->roothub.portstatus [wIndex]);
662		break;
663	case GetHubDescriptor:
664		ohci_hub_descriptor (ohci, (struct usb_hub_descriptor *) buf);
665		break;
666	case GetHubStatus:
667		temp = roothub_status (ohci) & ~(RH_HS_CRWE | RH_HS_DRWE);
668		put_unaligned(cpu_to_le32 (temp), (__le32 *) buf);
669		break;
670	case GetPortStatus:
671		if (!wIndex || wIndex > ports)
672			goto error;
673		wIndex--;
674		temp = roothub_portstatus (ohci, wIndex);
675		put_unaligned(cpu_to_le32 (temp), (__le32 *) buf);
676
677#ifndef	OHCI_VERBOSE_DEBUG
678	if (*(u16*)(buf+2))	/* only if wPortChange is interesting */
679#endif
680		dbg_port (ohci, "GetStatus", wIndex, temp);
681		break;
682	case SetHubFeature:
683		switch (wValue) {
684		case C_HUB_OVER_CURRENT:
685		case C_HUB_LOCAL_POWER:
686			break;
687		default:
688			goto error;
689		}
690		break;
691	case SetPortFeature:
692		if (!wIndex || wIndex > ports)
693			goto error;
694		wIndex--;
695		switch (wValue) {
696		case USB_PORT_FEAT_SUSPEND:
697#ifdef	CONFIG_USB_OTG
698			if (hcd->self.otg_port == (wIndex + 1)
699					&& hcd->self.b_hnp_enable)
700				start_hnp(ohci);
701			else
702#endif
703			ohci_writel (ohci, RH_PS_PSS,
704				&ohci->regs->roothub.portstatus [wIndex]);
705			break;
706		case USB_PORT_FEAT_POWER:
707			ohci_writel (ohci, RH_PS_PPS,
708				&ohci->regs->roothub.portstatus [wIndex]);
709			break;
710		case USB_PORT_FEAT_RESET:
711			retval = root_port_reset (ohci, wIndex);
712			break;
713		default:
714			goto error;
715		}
716		break;
717
718	default:
719error:
720		/* "protocol stall" on error */
721		retval = -EPIPE;
722	}
723	return retval;
724}
725