/* * 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" : "" \		);/*-------------------------------------------------------------------------*//* hcd->hub_irq_enable() */static void ohci_rhsc_enable (struct usb_hcd *hcd){	struct ohci_hcd		*ohci = hcd_to_ohci (hcd);	spin_lock_irq(&ohci->lock);	if (!ohci->autostop)		del_timer(&hcd->rh_timer);	/* Prevent next poll */	ohci_writel(ohci, OHCI_INTR_RHSC, &ohci->regs->intrenable);	spin_unlock_irq(&ohci->lock);}#define OHCI_SCHED_ENABLES \	(OHCI_CTRL_CLE|OHCI_CTRL_BLE|OHCI_CTRL_PLE|OHCI_CTRL_IE)static void dl_done_list (struct ohci_hcd *);static void finish_unlinks (struct ohci_hcd *, u16);#ifdef	CONFIG_PMstatic int ohci_restart(struct ohci_hcd *ohci);static int ohci_rh_suspend (struct ohci_hcd *ohci, int autostop)__releases(ohci->lock)__acquires(ohci->lock){	int			status = 0;	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:		if (!ohci->autostop) {			ohci_dbg (ohci, "already suspended\n");			goto done;		}	}	ohci_dbg (ohci, "%s root hub\n",			autostop ? "auto-stop" : "suspend");	/* First stop any processing */	if (!autostop && (ohci->hc_control & OHCI_SCHED_ENABLES)) {		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");		ohci->autostop = 0;		spin_unlock_irq (&ohci->lock);		msleep (8);		spin_lock_irq (&ohci->lock);	}	dl_done_list (ohci);	finish_unlinks (ohci, ohci_frame_no(ohci));	/* maybe resume can wake root hub */	if (device_may_wakeup(&ohci_to_hcd(ohci)->self.root_hub->dev) ||			autostop)		ohci->hc_control |= OHCI_CTRL_RWE;	else {		ohci_writel (ohci, OHCI_INTR_RHSC, &ohci->regs->intrdisable);		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 */	if (!autostop) {		ohci->next_statechange = jiffies + msecs_to_jiffies (5);		ohci->autostop = 0;	}done:	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_rh_resume (struct ohci_hcd *ohci)__releases(ohci->lock)__acquires(ohci->lock){	struct usb_hcd		*hcd = ohci_to_hcd (ohci);	u32			temp, enables;	int			status = -EINPROGRESS;	int			autostopped = ohci->autostop;	ohci->autostop = 0;	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, "%s root hub\n",				autostopped ? "auto-start" : "resume");		break;	case OHCI_USB_RESUME:		/* HCFS changes sometime after INTR_RD */		ohci_dbg(ohci, "%swakeup root hub\n",				autostopped ? "auto-" : "");		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;	}	if (status == -EBUSY) {		if (!autostopped) {			spin_unlock_irq (&ohci->lock);			(void) ohci_init (ohci);			status = ohci_restart (ohci);			spin_lock_irq (&ohci->lock);		}		return status;	}	if (status != -EINPROGRESS)		return status;	if (autostopped)		goto skip_resume;	spin_unlock_irq (&ohci->lock);	/* 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");		spin_lock_irq(&ohci->lock);		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);	/* the following code is executed with ohci->lock held and	 * irqs disabled if and only if autostopped is true	 */skip_resume:	/* 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);	/* Then re-enable operations */	ohci_writel (ohci, OHCI_USB_OPER, &ohci->regs->control);	(void) ohci_readl (ohci, &ohci->regs->control);	if (!autostopped)		msleep (3);	temp = ohci->hc_control;	temp &= OHCI_CTRL_RWC;	temp |= OHCI_CONTROL_INIT | OHCI_USB_OPER;	ohci->hc_control = temp;	ohci_writel (ohci, temp, &ohci->regs->control);	(void) ohci_readl (ohci, &ohci->regs->control);	/* TRSMRCY */	if (!autostopped) {		msleep (10);		spin_lock_irq (&ohci->lock);	}	/* now ohci->lock is always held and irqs are always disabled */	/* keep it alive for more than ~5x suspend + resume costs */	ohci->next_statechange = jiffies + STATECHANGE_DELAY;	/* 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;}static int ohci_bus_suspend (struct usb_hcd *hcd){	struct ohci_hcd		*ohci = hcd_to_ohci (hcd);	int			rc;	spin_lock_irq (&ohci->lock);	if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))		rc = -ESHUTDOWN;	else		rc = ohci_rh_suspend (ohci, 0);	spin_unlock_irq (&ohci->lock);	return rc;}static int ohci_bus_resume (struct usb_hcd *hcd){	struct ohci_hcd		*ohci = hcd_to_ohci (hcd);	int			rc;	if (time_before (jiffies, ohci->next_statechange))		msleep(5);	spin_lock_irq (&ohci->lock);	if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)))		rc = -ESHUTDOWN;	else		rc = ohci_rh_resume (ohci);	spin_unlock_irq (&ohci->lock);	/* poll until we know a device is connected or we autostop */	if (rc == 0)		usb_hcd_poll_rh_status(hcd);	return rc;}/* Carry out polling-, autostop-, and autoresume-related state changes */static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,		int any_connected){	int	poll_rh = 1;	switch (ohci->hc_control & OHCI_CTRL_HCFS) {	case OHCI_USB_OPER:		/* keep on polling until we know a device is connected		 * and RHSC is enabled */		if (!ohci->autostop) {			if (any_connected ||					!device_may_wakeup(&ohci_to_hcd(ohci)						->self.root_hub->dev)) {				if (ohci_readl(ohci, &ohci->regs->intrenable) &						OHCI_INTR_RHSC)					poll_rh = 0;			} else {				ohci->autostop = 1;				ohci->next_statechange = jiffies + HZ;			}		/* if no devices have been attached for one second, autostop */		} else {			if (changed || any_connected) {				ohci->autostop = 0;				ohci->next_statechange = jiffies +						STATECHANGE_DELAY;			} else if (time_after_eq(jiffies,						ohci->next_statechange)					&& !ohci->ed_rm_list					&& !(ohci->hc_control &						OHCI_SCHED_ENABLES)) {				ohci_rh_suspend(ohci, 1);			}