[linux-2.6-block.git] / drivers / usb / host / ohci-hub.c

/*
 * OHCI HCD (Host Controller Driver) for USB.
 * 
 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
 * (C) Copyright 2000-2004 David Brownell <dbrownell@users.sourceforge.net>
 * 
 * This file is licenced under GPL
 */

/*-------------------------------------------------------------------------*/

/*
 * OHCI Root Hub ... the nonsharable stuff
 */

#define dbg_port(hc,label,num,value) \
	ohci_dbg (hc, \
		"%s roothub.portstatus [%d] " \
		"= 0x%08x%s%s%s%s%s%s%s%s%s%s%s%s\n", \
		label, num, temp, \
		(temp & RH_PS_PRSC) ? " PRSC" : "", \
		(temp & RH_PS_OCIC) ? " OCIC" : "", \
		(temp & RH_PS_PSSC) ? " PSSC" : "", \
		(temp & RH_PS_PESC) ? " PESC" : "", \
		(temp & RH_PS_CSC) ? " CSC" : "", \
 		\
		(temp & RH_PS_LSDA) ? " LSDA" : "", \
		(temp & RH_PS_PPS) ? " PPS" : "", \
		(temp & RH_PS_PRS) ? " PRS" : "", \
		(temp & RH_PS_POCI) ? " POCI" : "", \
		(temp & RH_PS_PSS) ? " PSS" : "", \
 		\
		(temp & RH_PS_PES) ? " PES" : "", \
		(temp & RH_PS_CCS) ? " CCS" : "" \
		);

/*-------------------------------------------------------------------------*/

#ifdef	CONFIG_PM

#define OHCI_SCHED_ENABLES \
	(OHCI_CTRL_CLE|OHCI_CTRL_BLE|OHCI_CTRL_PLE|OHCI_CTRL_IE)

static void dl_done_list (struct ohci_hcd *, struct pt_regs *);
static void finish_unlinks (struct ohci_hcd *, u16 , struct pt_regs *);
static int ohci_restart (struct ohci_hcd *ohci);

static int ohci_bus_suspend (struct usb_hcd *hcd)
{
	struct ohci_hcd		*ohci = hcd_to_ohci (hcd);
	int			status = 0;
	unsigned long		flags;

	spin_lock_irqsave (&ohci->lock, flags);

	if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))) {
		spin_unlock_irqrestore (&ohci->lock, flags);
		return -ESHUTDOWN;
	}

	ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);
	switch (ohci->hc_control & OHCI_CTRL_HCFS) {
	case OHCI_USB_RESUME:
		ohci_dbg (ohci, "resume/suspend?\n");
		ohci->hc_control &= ~OHCI_CTRL_HCFS;
		ohci->hc_control |= OHCI_USB_RESET;
		ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
		(void) ohci_readl (ohci, &ohci->regs->control);
		/* FALL THROUGH */
	case OHCI_USB_RESET:
		status = -EBUSY;
		ohci_dbg (ohci, "needs reinit!\n");
		goto done;
	case OHCI_USB_SUSPEND:
		ohci_dbg (ohci, "already suspended\n");
		goto done;
	}
	ohci_dbg (ohci, "suspend root hub\n");

	/* First stop any processing */
	if (ohci->hc_control & OHCI_SCHED_ENABLES) {
		int		limit;

		ohci->hc_control &= ~OHCI_SCHED_ENABLES;
		ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
		ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);
		ohci_writel (ohci, OHCI_INTR_SF, &ohci->regs->intrstatus);

		/* sched disables take effect on the next frame,
		 * then the last WDH could take 6+ msec
		 */
		ohci_dbg (ohci, "stopping schedules ...\n");
		limit = 2000;
		while (limit > 0) {
			udelay (250);
			limit =- 250;
			if (ohci_readl (ohci, &ohci->regs->intrstatus)
					& OHCI_INTR_SF)
				break;
		}
		dl_done_list (ohci, NULL);
		mdelay (7);
	}
	dl_done_list (ohci, NULL);
	finish_unlinks (ohci, ohci_frame_no(ohci), NULL);
	ohci_writel (ohci, ohci_readl (ohci, &ohci->regs->intrstatus),
			&ohci->regs->intrstatus);

	/* maybe resume can wake root hub */
	if (hcd->remote_wakeup)
		ohci->hc_control |= OHCI_CTRL_RWE;
	else
		ohci->hc_control &= ~OHCI_CTRL_RWE;

	/* Suspend hub ... this is the "global (to this bus) suspend" mode,
	 * which doesn't imply ports will first be individually suspended.
	 */
	ohci->hc_control &= ~OHCI_CTRL_HCFS;
	ohci->hc_control |= OHCI_USB_SUSPEND;
	ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
	(void) ohci_readl (ohci, &ohci->regs->control);

	/* no resumes until devices finish suspending */
	ohci->next_statechange = jiffies + msecs_to_jiffies (5);

done:
	/* external suspend vs self autosuspend ... same effect */
	if (status == 0)
		usb_hcd_suspend_root_hub(hcd);
	spin_unlock_irqrestore (&ohci->lock, flags);
	return status;
}

static inline struct ed *find_head (struct ed *ed)
{
	/* for bulk and control lists */
	while (ed->ed_prev)
		ed = ed->ed_prev;
	return ed;
}

/* caller has locked the root hub */
static int ohci_bus_resume (struct usb_hcd *hcd)
{
	struct ohci_hcd		*ohci = hcd_to_ohci (hcd);
	u32			temp, enables;
	int			status = -EINPROGRESS;
	unsigned long		flags;

	if (time_before (jiffies, ohci->next_statechange))
		msleep(5);

	spin_lock_irqsave (&ohci->lock, flags);

	if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))) {
		spin_unlock_irqrestore (&ohci->lock, flags);
		return -ESHUTDOWN;
	}


	ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);

	if (ohci->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) {
		/* this can happen after resuming a swsusp snapshot */
		if (hcd->state == HC_STATE_RESUMING) {
			ohci_dbg (ohci, "BIOS/SMM active, control %03x\n",
					ohci->hc_control);
			status = -EBUSY;
		/* this happens when pmcore resumes HC then root */
		} else {
			ohci_dbg (ohci, "duplicate resume\n");
			status = 0;
		}
	} else switch (ohci->hc_control & OHCI_CTRL_HCFS) {
	case OHCI_USB_SUSPEND:
		ohci->hc_control &= ~(OHCI_CTRL_HCFS|OHCI_SCHED_ENABLES);
		ohci->hc_control |= OHCI_USB_RESUME;
		ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
		(void) ohci_readl (ohci, &ohci->regs->control);
		ohci_dbg (ohci, "resume root hub\n");
		break;
	case OHCI_USB_RESUME:
		/* HCFS changes sometime after INTR_RD */
		ohci_info (ohci, "wakeup\n");
		break;
	case OHCI_USB_OPER:
		/* this can happen after resuming a swsusp snapshot */
		ohci_dbg (ohci, "snapshot resume? reinit\n");
		status = -EBUSY;
		break;
	default:		/* RESET, we lost power */
		ohci_dbg (ohci, "lost power\n");
		status = -EBUSY;
	}
	spin_unlock_irqrestore (&ohci->lock, flags);
	if (status == -EBUSY) {
		(void) ohci_init (ohci);
		return ohci_restart (ohci);
	}
	if (status != -EINPROGRESS)
		return status;

	temp = ohci->num_ports;
	enables = 0;
	while (temp--) {
		u32 stat = ohci_readl (ohci,
				       &ohci->regs->roothub.portstatus [temp]);

		/* force global, not selective, resume */
		if (!(stat & RH_PS_PSS))
			continue;
		ohci_writel (ohci, RH_PS_POCI,
				&ohci->regs->roothub.portstatus [temp]);
	}

	/* Some controllers (lucent erratum) need extra-long delays */
	msleep (20 /* usb 11.5.1.10 */ + 12 /* 32 msec counter */ + 1);

	temp = ohci_readl (ohci, &ohci->regs->control);
	temp &= OHCI_CTRL_HCFS;
	if (temp != OHCI_USB_RESUME) {
		ohci_err (ohci, "controller won't resume\n");
		return -EBUSY;
	}

	/* disable old schedule state, reinit from scratch */
	ohci_writel (ohci, 0, &ohci->regs->ed_controlhead);
	ohci_writel (ohci, 0, &ohci->regs->ed_controlcurrent);
	ohci_writel (ohci, 0, &ohci->regs->ed_bulkhead);
	ohci_writel (ohci, 0, &ohci->regs->ed_bulkcurrent);
	ohci_writel (ohci, 0, &ohci->regs->ed_periodcurrent);
	ohci_writel (ohci, (u32) ohci->hcca_dma, &ohci->regs->hcca);

	/* Sometimes PCI D3 suspend trashes frame timings ... */
	periodic_reinit (ohci);

	/* interrupts might have been disabled */
	ohci_writel (ohci, OHCI_INTR_INIT, &ohci->regs->intrenable);
	if (ohci->ed_rm_list)
		ohci_writel (ohci, OHCI_INTR_SF, &ohci->regs->intrenable);
	ohci_writel (ohci, ohci_readl (ohci, &ohci->regs->intrstatus),
			&ohci->regs->intrstatus);

	/* Then re-enable operations */
	ohci_writel (ohci, OHCI_USB_OPER, &ohci->regs->control);
	(void) ohci_readl (ohci, &ohci->regs->control);
	msleep (3);

	temp = OHCI_CONTROL_INIT | OHCI_USB_OPER;
	if (hcd->can_wakeup)
		temp |= OHCI_CTRL_RWC;
	ohci->hc_control = temp;
	ohci_writel (ohci, temp, &ohci->regs->control);
	(void) ohci_readl (ohci, &ohci->regs->control);

	/* TRSMRCY */
	msleep (10);

	/* keep it alive for ~5x suspend + resume costs */
	ohci->next_statechange = jiffies + msecs_to_jiffies (250);

	/* maybe turn schedules back on */
	enables = 0;
	temp = 0;
	if (!ohci->ed_rm_list) {
		if (ohci->ed_controltail) {
			ohci_writel (ohci,
					find_head (ohci->ed_controltail)->dma,
					&ohci->regs->ed_controlhead);
			enables |= OHCI_CTRL_CLE;
			temp |= OHCI_CLF;
		}
		if (ohci->ed_bulktail) {
			ohci_writel (ohci, find_head (ohci->ed_bulktail)->dma,
				&ohci->regs->ed_bulkhead);
			enables |= OHCI_CTRL_BLE;
			temp |= OHCI_BLF;
		}
	}
	if (hcd->self.bandwidth_isoc_reqs || hcd->self.bandwidth_int_reqs)
		enables |= OHCI_CTRL_PLE|OHCI_CTRL_IE;
	if (enables) {
		ohci_dbg (ohci, "restarting schedules ... %08x\n", enables);
		ohci->hc_control |= enables;
		ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
		if (temp)
			ohci_writel (ohci, temp, &ohci->regs->cmdstatus);
		(void) ohci_readl (ohci, &ohci->regs->control);
	}

	return 0;
}

#endif	/* CONFIG_PM */

/*-------------------------------------------------------------------------*/

/* build "status change" packet (one or two bytes) from HC registers */

static int
ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
{
	struct ohci_hcd	*ohci = hcd_to_ohci (hcd);
	int		i, changed = 0, length = 1;
	int		can_suspend = hcd->can_wakeup;
	unsigned long	flags;

	spin_lock_irqsave (&ohci->lock, flags);

	/* handle autosuspended root:  finish resuming before
	 * letting khubd or root hub timer see state changes.
	 */
	if (unlikely((ohci->hc_control & OHCI_CTRL_HCFS) != OHCI_USB_OPER
		     || !HC_IS_RUNNING(hcd->state))) {
		can_suspend = 0;
		goto done;
	}

	/* undocumented erratum seen on at least rev D */
	if ((ohci->flags & OHCI_QUIRK_AMD756)
			&& (roothub_a (ohci) & RH_A_NDP) > MAX_ROOT_PORTS) {
		ohci_warn (ohci, "bogus NDP, rereads as NDP=%d\n",
			  ohci_readl (ohci, &ohci->regs->roothub.a) & RH_A_NDP);
		/* retry later; "should not happen" */
		goto done;
	}

	/* init status */
	if (roothub_status (ohci) & (RH_HS_LPSC | RH_HS_OCIC))
		buf [0] = changed = 1;
	else
		buf [0] = 0;
	if (ohci->num_ports > 7) {
		buf [1] = 0;
		length++;
	}

	/* look at each port */
	for (i = 0; i < ohci->num_ports; i++) {
		u32	status = roothub_portstatus (ohci, i);

		if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
				| RH_PS_OCIC | RH_PS_PRSC)) {
			changed = 1;
			if (i < 7)
			    buf [0] |= 1 << (i + 1);
			else
			    buf [1] |= 1 << (i - 7);
			continue;
		}

		/* can suspend if no ports are enabled; or if all all
		 * enabled ports are suspended AND remote wakeup is on.
		 */
		if (!(status & RH_PS_CCS))
			continue;
		if ((status & RH_PS_PSS) && hcd->remote_wakeup)
			continue;
		can_suspend = 0;
	}
done:
	spin_unlock_irqrestore (&ohci->lock, flags);

#ifdef CONFIG_PM
	/* save power by suspending idle root hubs;
	 * INTR_RD wakes us when there's work
	 */
	if (can_suspend
			&& !changed
			&& !ohci->ed_rm_list
			&& ((OHCI_CTRL_HCFS | OHCI_SCHED_ENABLES)
					& ohci->hc_control)
				== OHCI_USB_OPER
			&& time_after (jiffies, ohci->next_statechange)
			&& usb_trylock_device (hcd->self.root_hub)
			) {
		ohci_vdbg (ohci, "autosuspend\n");
		(void) ohci_bus_suspend (hcd);
		usb_unlock_device (hcd->self.root_hub);
	}
#endif

	return changed ? length : 0;
}

/*-------------------------------------------------------------------------*/

static void
ohci_hub_descriptor (
	struct ohci_hcd			*ohci,
	struct usb_hub_descriptor	*desc
) {
	u32		rh = roothub_a (ohci);
	u16		temp;

	desc->bDescriptorType = 0x29;
	desc->bPwrOn2PwrGood = (rh & RH_A_POTPGT) >> 24;
	desc->bHubContrCurrent = 0;

	desc->bNbrPorts = ohci->num_ports;
	temp = 1 + (ohci->num_ports / 8);
	desc->bDescLength = 7 + 2 * temp;

	temp = 0;
	if (rh & RH_A_NPS)		/* no power switching? */
	    temp |= 0x0002;
	if (rh & RH_A_PSM) 		/* per-port power switching? */
	    temp |= 0x0001;
	if (rh & RH_A_NOCP)		/* no overcurrent reporting? */
	    temp |= 0x0010;
	else if (rh & RH_A_OCPM)	/* per-port overcurrent reporting? */
	    temp |= 0x0008;
	desc->wHubCharacteristics = (__force __u16)cpu_to_hc16(ohci, temp);

	/* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
	rh = roothub_b (ohci);
	memset(desc->bitmap, 0xff, sizeof(desc->bitmap));
	desc->bitmap [0] = rh & RH_B_DR;
	if (ohci->num_ports > 7) {
		desc->bitmap [1] = (rh & RH_B_DR) >> 8;
		desc->bitmap [2] = 0xff;
	} else
		desc->bitmap [1] = 0xff;
}

/*-------------------------------------------------------------------------*/

#ifdef	CONFIG_USB_OTG

static int ohci_start_port_reset (struct usb_hcd *hcd, unsigned port)
{
	struct ohci_hcd	*ohci = hcd_to_ohci (hcd);
	u32			status;

	if (!port)
		return -EINVAL;
	port--;

	/* start port reset before HNP protocol times out */
	status = ohci_readl(ohci, &ohci->regs->roothub.portstatus [port]);
	if (!(status & RH_PS_CCS))
		return -ENODEV;

	/* khubd will finish the reset later */
	ohci_writel(ohci, RH_PS_PRS, &ohci->regs->roothub.portstatus [port]);
	return 0;
}

static void start_hnp(struct ohci_hcd *ohci);

#else

#define	ohci_start_port_reset		NULL

#endif

/*-------------------------------------------------------------------------*/


/* See usb 7.1.7.5:  root hubs must issue at least 50 msec reset signaling,
 * not necessarily continuous ... to guard against resume signaling.
 * The short timeout is safe for non-root hubs, and is backward-compatible
 * with earlier Linux hosts.
 */
#ifdef	CONFIG_USB_SUSPEND
#define	PORT_RESET_MSEC		50
#else
#define	PORT_RESET_MSEC		10
#endif

/* this timer value might be vendor-specific ... */
#define	PORT_RESET_HW_MSEC	10

/* wrap-aware logic morphed from <linux/jiffies.h> */
#define tick_before(t1,t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0)

/* called from some task, normally khubd */
static inline void root_port_reset (struct ohci_hcd *ohci, unsigned port)
{
	__hc32 __iomem *portstat = &ohci->regs->roothub.portstatus [port];
	u32	temp;
	u16	now = ohci_readl(ohci, &ohci->regs->fmnumber);
	u16	reset_done = now + PORT_RESET_MSEC;

	/* build a "continuous enough" reset signal, with up to
	 * 3msec gap between pulses.  scheduler HZ==100 must work;
	 * this might need to be deadline-scheduled.
	 */
	do {
		/* spin until any current reset finishes */
		for (;;) {
			temp = ohci_readl (ohci, portstat);
			if (!(temp & RH_PS_PRS))
				break;
			udelay (500);
		} 

		if (!(temp & RH_PS_CCS))
			break;
		if (temp & RH_PS_PRSC)
			ohci_writel (ohci, RH_PS_PRSC, portstat);

		/* start the next reset, sleep till it's probably done */
		ohci_writel (ohci, RH_PS_PRS, portstat);
		msleep(PORT_RESET_HW_MSEC);
		now = ohci_readl(ohci, &ohci->regs->fmnumber);
	} while (tick_before(now, reset_done));
	/* caller synchronizes using PRSC */
}

static int ohci_hub_control (
	struct usb_hcd	*hcd,
	u16		typeReq,
	u16		wValue,
	u16		wIndex,
	char		*buf,
	u16		wLength
) {
	struct ohci_hcd	*ohci = hcd_to_ohci (hcd);
	int		ports = hcd_to_bus (hcd)->root_hub->maxchild;
	u32		temp;
	int		retval = 0;

	if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))
		return -ESHUTDOWN;

	switch (typeReq) {
	case ClearHubFeature:
		switch (wValue) {
		case C_HUB_OVER_CURRENT:
			ohci_writel (ohci, RH_HS_OCIC,
					&ohci->regs->roothub.status);
		case C_HUB_LOCAL_POWER:
			break;
		default:
			goto error;
		}
		break;
	case ClearPortFeature:
		if (!wIndex || wIndex > ports)
			goto error;
		wIndex--;

		switch (wValue) {
		case USB_PORT_FEAT_ENABLE:
			temp = RH_PS_CCS;
			break;
		case USB_PORT_FEAT_C_ENABLE:
			temp = RH_PS_PESC;
			break;
		case USB_PORT_FEAT_SUSPEND:
			temp = RH_PS_POCI;
			if ((ohci->hc_control & OHCI_CTRL_HCFS)
					!= OHCI_USB_OPER)
				usb_hcd_resume_root_hub(hcd);
			break;
		case USB_PORT_FEAT_C_SUSPEND:
			temp = RH_PS_PSSC;
			break;
		case USB_PORT_FEAT_POWER:
			temp = RH_PS_LSDA;
			break;
		case USB_PORT_FEAT_C_CONNECTION:
			temp = RH_PS_CSC;
			break;
		case USB_PORT_FEAT_C_OVER_CURRENT:
			temp = RH_PS_OCIC;
			break;
		case USB_PORT_FEAT_C_RESET:
			temp = RH_PS_PRSC;
			break;
		default:
			goto error;
		}
		ohci_writel (ohci, temp,
				&ohci->regs->roothub.portstatus [wIndex]);
		// ohci_readl (ohci, &ohci->regs->roothub.portstatus [wIndex]);
		break;
	case GetHubDescriptor:
		ohci_hub_descriptor (ohci, (struct usb_hub_descriptor *) buf);
		break;
	case GetHubStatus:
		temp = roothub_status (ohci) & ~(RH_HS_CRWE | RH_HS_DRWE);
		*(__le32 *) buf = cpu_to_le32 (temp);
		break;
	case GetPortStatus:
		if (!wIndex || wIndex > ports)
			goto error;
		wIndex--;
		temp = roothub_portstatus (ohci, wIndex);
		*(__le32 *) buf = cpu_to_le32 (temp);

#ifndef	OHCI_VERBOSE_DEBUG
	if (*(u16*)(buf+2))	/* only if wPortChange is interesting */
#endif
		dbg_port (ohci, "GetStatus", wIndex, temp);
		break;
	case SetHubFeature:
		switch (wValue) {
		case C_HUB_OVER_CURRENT:
			// FIXME:  this can be cleared, yes?
		case C_HUB_LOCAL_POWER:
			break;
		default:
			goto error;
		}
		break;
	case SetPortFeature:
		if (!wIndex || wIndex > ports)
			goto error;
		wIndex--;
		switch (wValue) {
		case USB_PORT_FEAT_SUSPEND:
#ifdef	CONFIG_USB_OTG
			if (hcd->self.otg_port == (wIndex + 1)
					&& hcd->self.b_hnp_enable)
				start_hnp(ohci);
			else
#endif
			ohci_writel (ohci, RH_PS_PSS,
				&ohci->regs->roothub.portstatus [wIndex]);
			break;
		case USB_PORT_FEAT_POWER:
			ohci_writel (ohci, RH_PS_PPS,
				&ohci->regs->roothub.portstatus [wIndex]);
			break;
		case USB_PORT_FEAT_RESET:
			root_port_reset (ohci, wIndex);
			break;
		default:
			goto error;
		}
		break;

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