Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1757784AbaJaFbW (ORCPT ); Fri, 31 Oct 2014 01:31:22 -0400 Received: from arroyo.ext.ti.com ([192.94.94.40]:53795 "EHLO arroyo.ext.ti.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754102AbaJaFbU (ORCPT ); Fri, 31 Oct 2014 01:31:20 -0400 Message-ID: <54531E8A.3090702@ti.com> Date: Fri, 31 Oct 2014 11:00:50 +0530 From: Kishon Vijay Abraham I User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:31.0) Gecko/20100101 Thunderbird/31.0 MIME-Version: 1.0 To: , Peter Chen , Aaro Koskinen CC: Antoine Tenart , , , , , , , , Subject: Re: [PATCH v7 1/7] usb: move the OTG state from the USB PHY to the OTG structure References: <1414514141-31767-1-git-send-email-antoine.tenart@free-electrons.com> <1414514141-31767-2-git-send-email-antoine.tenart@free-electrons.com> <20141030163148.GF10130@saruman> <20141030163513.GI10130@saruman> <20141030174254.GA6764@kwain> <20141030174734.GA6652@saruman> <20141031003812.GA3692@peterchendt> <20141031004710.GA17652@saruman> In-Reply-To: <20141031004710.GA17652@saruman> Content-Type: text/plain; charset="windows-1252" Content-Transfer-Encoding: 7bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Friday 31 October 2014 06:17 AM, Felipe Balbi wrote: > Hi, > > On Fri, Oct 31, 2014 at 08:38:14AM +0800, Peter Chen wrote: >> On Thu, Oct 30, 2014 at 12:47:34PM -0500, Felipe Balbi wrote: >>> On Thu, Oct 30, 2014 at 06:42:54PM +0100, Antoine Tenart wrote: >>>> Hi Felipe, >>>> >>>> On Thu, Oct 30, 2014 at 11:35:13AM -0500, Felipe Balbi wrote: >>>>> On Thu, Oct 30, 2014 at 11:31:48AM -0500, Felipe Balbi wrote: >>>>>> On Tue, Oct 28, 2014 at 05:35:35PM +0100, Antoine Tenart wrote: >>>>>>> Before using the PHY framework instead of the USB PHY one, we need to >>>>>>> move the OTG state into another place, since it won't be available when >>>>>>> USB PHY isn't used. This patch moves the OTG state into the OTG >>>>>>> structure, and makes all the needed modifications in the drivers >>>>>>> using the OTG state. >>>>>>> >>>>>>> Signed-off-by: Antoine Tenart >>>>>>> Acked-by: Peter Chen >>>>>> >>>>>> Acked-by: Felipe Balbi >>>>> >>>>> Please rebase on my testing/next and I'll take the series. When >>>>> rebasing, then add Peter's Tested-by/Acked-by where they're missing. >>>> >>>> I just re-sent the series, rebased on your testing/next branch. >>> >>> Thanks, I put them on my testing/next and I'm running build tests. >>> >> >> I see them, I will rebase your testing/next tree for coming chipidea dev, thanks. > > I fixed a build breakage caused by $subject which I fixed, updated patch > below: (Aaro, can I get a tested-by by any chance ?) > > 8<------------------------------------------------------------------ > > commit 9057203a959384ef4d0324b2fa724c37169b05c9 > Author: Antoine Tenart > Date: Thu Oct 30 18:41:13 2014 +0100 > > usb: move the OTG state from the USB PHY to the OTG structure > > Before using the PHY framework instead of the USB PHY one, we need to > move the OTG state into another place, since it won't be available when > USB PHY isn't used. This patch moves the OTG state into the OTG > structure, and makes all the needed modifications in the drivers > using the OTG state. > > [ balbi@ti.com : fix build regression with phy-tahvo.c ] > > Signed-off-by: Antoine Tenart > Acked-by: Peter Chen > Signed-off-by: Felipe Balbi For drivers/phy Acked-by: Kishon Vijay Abraham I > > diff --git a/drivers/phy/phy-omap-usb2.c b/drivers/phy/phy-omap-usb2.c > index 8c84298..9f409359 100644 > --- a/drivers/phy/phy-omap-usb2.c > +++ b/drivers/phy/phy-omap-usb2.c > @@ -80,11 +80,9 @@ static int omap_usb_start_srp(struct usb_otg *otg) > > static int omap_usb_set_host(struct usb_otg *otg, struct usb_bus *host) > { > - struct usb_phy *phy = otg->phy; > - > otg->host = host; > if (!host) > - phy->state = OTG_STATE_UNDEFINED; > + otg->state = OTG_STATE_UNDEFINED; > > return 0; > } > @@ -92,11 +90,9 @@ static int omap_usb_set_host(struct usb_otg *otg, struct usb_bus *host) > static int omap_usb_set_peripheral(struct usb_otg *otg, > struct usb_gadget *gadget) > { > - struct usb_phy *phy = otg->phy; > - > otg->gadget = gadget; > if (!gadget) > - phy->state = OTG_STATE_UNDEFINED; > + otg->state = OTG_STATE_UNDEFINED; > > return 0; > } > diff --git a/drivers/usb/chipidea/debug.c b/drivers/usb/chipidea/debug.c > index 795d653..8878eea 100644 > --- a/drivers/usb/chipidea/debug.c > +++ b/drivers/usb/chipidea/debug.c > @@ -220,7 +220,7 @@ static int ci_otg_show(struct seq_file *s, void *unused) > > /* ------ State ----- */ > seq_printf(s, "OTG state: %s\n\n", > - usb_otg_state_string(ci->transceiver->state)); > + usb_otg_state_string(ci->transceiver->otg.state)); > > /* ------ State Machine Variables ----- */ > seq_printf(s, "a_bus_drop: %d\n", fsm->a_bus_drop); > diff --git a/drivers/usb/chipidea/otg_fsm.c b/drivers/usb/chipidea/otg_fsm.c > index caaabc5..8cb2508 100644 > --- a/drivers/usb/chipidea/otg_fsm.c > +++ b/drivers/usb/chipidea/otg_fsm.c > @@ -328,7 +328,7 @@ static void b_ssend_srp_tmout_func(void *ptr, unsigned long indicator) > set_tmout(ci, indicator); > > /* only vbus fall below B_sess_vld in b_idle state */ > - if (ci->transceiver->state == OTG_STATE_B_IDLE) > + if (ci->fsm.otg->state == OTG_STATE_B_IDLE) > ci_otg_queue_work(ci); > } > > @@ -582,11 +582,11 @@ int ci_otg_fsm_work(struct ci_hdrc *ci) > * when there is no gadget class driver > */ > if (ci->fsm.id && !(ci->driver) && > - ci->transceiver->state < OTG_STATE_A_IDLE) > + ci->fsm.otg->state < OTG_STATE_A_IDLE) > return 0; > > if (otg_statemachine(&ci->fsm)) { > - if (ci->transceiver->state == OTG_STATE_A_IDLE) { > + if (ci->fsm.otg->state == OTG_STATE_A_IDLE) { > /* > * Further state change for cases: > * a_idle to b_idle; or > @@ -600,7 +600,7 @@ int ci_otg_fsm_work(struct ci_hdrc *ci) > ci_otg_queue_work(ci); > if (ci->id_event) > ci->id_event = false; > - } else if (ci->transceiver->state == OTG_STATE_B_IDLE) { > + } else if (ci->fsm.otg->state == OTG_STATE_B_IDLE) { > if (ci->fsm.b_sess_vld) { > ci->fsm.power_up = 0; > /* > @@ -627,7 +627,7 @@ static void ci_otg_fsm_event(struct ci_hdrc *ci) > otg_bsess_vld = hw_read_otgsc(ci, OTGSC_BSV); > port_conn = hw_read(ci, OP_PORTSC, PORTSC_CCS); > > - switch (ci->transceiver->state) { > + switch (ci->fsm.otg->state) { > case OTG_STATE_A_WAIT_BCON: > if (port_conn) { > fsm->b_conn = 1; > @@ -794,7 +794,7 @@ int ci_hdrc_otg_fsm_init(struct ci_hdrc *ci) > ci->transceiver->otg = ci->fsm.otg; > ci->fsm.power_up = 1; > ci->fsm.id = hw_read_otgsc(ci, OTGSC_ID) ? 1 : 0; > - ci->transceiver->state = OTG_STATE_UNDEFINED; > + ci->fsm.otg->state = OTG_STATE_UNDEFINED; > ci->fsm.ops = &ci_otg_ops; > > mutex_init(&ci->fsm.lock); > diff --git a/drivers/usb/common/usb-otg-fsm.c b/drivers/usb/common/usb-otg-fsm.c > index 98e8340..c6b35b7 100644 > --- a/drivers/usb/common/usb-otg-fsm.c > +++ b/drivers/usb/common/usb-otg-fsm.c > @@ -124,10 +124,10 @@ static void otg_leave_state(struct otg_fsm *fsm, enum usb_otg_state old_state) > static int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state) > { > state_changed = 1; > - if (fsm->otg->phy->state == new_state) > + if (fsm->otg->state == new_state) > return 0; > VDBG("Set state: %s\n", usb_otg_state_string(new_state)); > - otg_leave_state(fsm, fsm->otg->phy->state); > + otg_leave_state(fsm, fsm->otg->state); > switch (new_state) { > case OTG_STATE_B_IDLE: > otg_drv_vbus(fsm, 0); > @@ -236,7 +236,7 @@ static int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state) > break; > } > > - fsm->otg->phy->state = new_state; > + fsm->otg->state = new_state; > return 0; > } > > @@ -247,7 +247,7 @@ int otg_statemachine(struct otg_fsm *fsm) > > mutex_lock(&fsm->lock); > > - state = fsm->otg->phy->state; > + state = fsm->otg->state; > state_changed = 0; > /* State machine state change judgement */ > > diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c > index 0231606d..cf89b4b1 100644 > --- a/drivers/usb/host/ohci-omap.c > +++ b/drivers/usb/host/ohci-omap.c > @@ -183,7 +183,7 @@ static void start_hnp(struct ohci_hcd *ohci) > otg_start_hnp(hcd->usb_phy->otg); > > local_irq_save(flags); > - hcd->usb_phy->state = OTG_STATE_A_SUSPEND; > + hcd->usb_phy->otg.state = OTG_STATE_A_SUSPEND; > writel (RH_PS_PSS, &ohci->regs->roothub.portstatus [port]); > l = omap_readl(OTG_CTRL); > l &= ~OTG_A_BUSREQ; > diff --git a/drivers/usb/musb/am35x.c b/drivers/usb/musb/am35x.c > index a2735df..d836a3e 100644 > --- a/drivers/usb/musb/am35x.c > +++ b/drivers/usb/musb/am35x.c > @@ -149,25 +149,25 @@ static void otg_timer(unsigned long _musb) > */ > devctl = musb_readb(mregs, MUSB_DEVCTL); > dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl, > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > > spin_lock_irqsave(&musb->lock, flags); > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_WAIT_BCON: > devctl &= ~MUSB_DEVCTL_SESSION; > musb_writeb(musb->mregs, MUSB_DEVCTL, devctl); > > devctl = musb_readb(musb->mregs, MUSB_DEVCTL); > if (devctl & MUSB_DEVCTL_BDEVICE) { > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > MUSB_DEV_MODE(musb); > } else { > - musb->xceiv->state = OTG_STATE_A_IDLE; > + musb->xceiv->otg->state = OTG_STATE_A_IDLE; > MUSB_HST_MODE(musb); > } > break; > case OTG_STATE_A_WAIT_VFALL: > - musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE; > musb_writel(musb->ctrl_base, CORE_INTR_SRC_SET_REG, > MUSB_INTR_VBUSERROR << AM35X_INTR_USB_SHIFT); > break; > @@ -176,7 +176,7 @@ static void otg_timer(unsigned long _musb) > if (devctl & MUSB_DEVCTL_BDEVICE) > mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); > else > - musb->xceiv->state = OTG_STATE_A_IDLE; > + musb->xceiv->otg->state = OTG_STATE_A_IDLE; > break; > default: > break; > @@ -193,9 +193,9 @@ static void am35x_musb_try_idle(struct musb *musb, unsigned long timeout) > > /* Never idle if active, or when VBUS timeout is not set as host */ > if (musb->is_active || (musb->a_wait_bcon == 0 && > - musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) { > + musb->xceiv->otg->state == OTG_STATE_A_WAIT_BCON)) { > dev_dbg(musb->controller, "%s active, deleting timer\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > del_timer(&otg_workaround); > last_timer = jiffies; > return; > @@ -208,7 +208,7 @@ static void am35x_musb_try_idle(struct musb *musb, unsigned long timeout) > last_timer = timeout; > > dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > jiffies_to_msecs(timeout - jiffies)); > mod_timer(&otg_workaround, timeout); > } > @@ -278,27 +278,27 @@ static irqreturn_t am35x_musb_interrupt(int irq, void *hci) > * devctl. > */ > musb->int_usb &= ~MUSB_INTR_VBUSERROR; > - musb->xceiv->state = OTG_STATE_A_WAIT_VFALL; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL; > mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); > WARNING("VBUS error workaround (delay coming)\n"); > } else if (drvvbus) { > MUSB_HST_MODE(musb); > otg->default_a = 1; > - musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE; > portstate(musb->port1_status |= USB_PORT_STAT_POWER); > del_timer(&otg_workaround); > } else { > musb->is_active = 0; > MUSB_DEV_MODE(musb); > otg->default_a = 0; > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > portstate(musb->port1_status &= ~USB_PORT_STAT_POWER); > } > > /* NOTE: this must complete power-on within 100 ms. */ > dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n", > drvvbus ? "on" : "off", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > err ? " ERROR" : "", > devctl); > ret = IRQ_HANDLED; > @@ -324,7 +324,7 @@ eoi: > } > > /* Poll for ID change */ > - if (musb->xceiv->state == OTG_STATE_B_IDLE) > + if (musb->xceiv->otg->state == OTG_STATE_B_IDLE) > mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); > > spin_unlock_irqrestore(&musb->lock, flags); > diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c > index 8554c6f..f23ce40b 100644 > --- a/drivers/usb/musb/blackfin.c > +++ b/drivers/usb/musb/blackfin.c > @@ -185,8 +185,8 @@ static irqreturn_t blackfin_interrupt(int irq, void *__hci) > } > > /* Start sampling ID pin, when plug is removed from MUSB */ > - if ((musb->xceiv->state == OTG_STATE_B_IDLE > - || musb->xceiv->state == OTG_STATE_A_WAIT_BCON) || > + if ((musb->xceiv->otg->state == OTG_STATE_B_IDLE > + || musb->xceiv->otg->state == OTG_STATE_A_WAIT_BCON) || > (musb->int_usb & MUSB_INTR_DISCONNECT && is_host_active(musb))) { > mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY); > musb->a_wait_bcon = TIMER_DELAY; > @@ -205,7 +205,7 @@ static void musb_conn_timer_handler(unsigned long _musb) > static u8 toggle; > > spin_lock_irqsave(&musb->lock, flags); > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_IDLE: > case OTG_STATE_A_WAIT_BCON: > /* Start a new session */ > @@ -219,7 +219,7 @@ static void musb_conn_timer_handler(unsigned long _musb) > > if (!(val & MUSB_DEVCTL_BDEVICE)) { > gpio_set_value(musb->config->gpio_vrsel, 1); > - musb->xceiv->state = OTG_STATE_A_WAIT_BCON; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_BCON; > } else { > gpio_set_value(musb->config->gpio_vrsel, 0); > /* Ignore VBUSERROR and SUSPEND IRQ */ > @@ -229,7 +229,7 @@ static void musb_conn_timer_handler(unsigned long _musb) > > val = MUSB_INTR_SUSPEND | MUSB_INTR_VBUSERROR; > musb_writeb(musb->mregs, MUSB_INTRUSB, val); > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > } > mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY); > break; > @@ -245,7 +245,7 @@ static void musb_conn_timer_handler(unsigned long _musb) > > if (!(val & MUSB_DEVCTL_BDEVICE)) { > gpio_set_value(musb->config->gpio_vrsel, 1); > - musb->xceiv->state = OTG_STATE_A_WAIT_BCON; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_BCON; > } else { > gpio_set_value(musb->config->gpio_vrsel, 0); > > @@ -280,13 +280,13 @@ static void musb_conn_timer_handler(unsigned long _musb) > break; > default: > dev_dbg(musb->controller, "%s state not handled\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > break; > } > spin_unlock_irqrestore(&musb->lock, flags); > > dev_dbg(musb->controller, "state is %s\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > } > > static void bfin_musb_enable(struct musb *musb) > @@ -307,7 +307,7 @@ static void bfin_musb_set_vbus(struct musb *musb, int is_on) > > dev_dbg(musb->controller, "VBUS %s, devctl %02x " > /* otg %3x conf %08x prcm %08x */ "\n", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > musb_readb(musb->mregs, MUSB_DEVCTL)); > } > > diff --git a/drivers/usb/musb/da8xx.c b/drivers/usb/musb/da8xx.c > index 058775e..527c7fe 100644 > --- a/drivers/usb/musb/da8xx.c > +++ b/drivers/usb/musb/da8xx.c > @@ -198,20 +198,20 @@ static void otg_timer(unsigned long _musb) > */ > devctl = musb_readb(mregs, MUSB_DEVCTL); > dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl, > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > > spin_lock_irqsave(&musb->lock, flags); > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_WAIT_BCON: > devctl &= ~MUSB_DEVCTL_SESSION; > musb_writeb(musb->mregs, MUSB_DEVCTL, devctl); > > devctl = musb_readb(musb->mregs, MUSB_DEVCTL); > if (devctl & MUSB_DEVCTL_BDEVICE) { > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > MUSB_DEV_MODE(musb); > } else { > - musb->xceiv->state = OTG_STATE_A_IDLE; > + musb->xceiv->otg->state = OTG_STATE_A_IDLE; > MUSB_HST_MODE(musb); > } > break; > @@ -226,7 +226,7 @@ static void otg_timer(unsigned long _musb) > mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); > break; > } > - musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE; > musb_writel(musb->ctrl_base, DA8XX_USB_INTR_SRC_SET_REG, > MUSB_INTR_VBUSERROR << DA8XX_INTR_USB_SHIFT); > break; > @@ -248,7 +248,7 @@ static void otg_timer(unsigned long _musb) > if (devctl & MUSB_DEVCTL_BDEVICE) > mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); > else > - musb->xceiv->state = OTG_STATE_A_IDLE; > + musb->xceiv->otg->state = OTG_STATE_A_IDLE; > break; > default: > break; > @@ -265,9 +265,9 @@ static void da8xx_musb_try_idle(struct musb *musb, unsigned long timeout) > > /* Never idle if active, or when VBUS timeout is not set as host */ > if (musb->is_active || (musb->a_wait_bcon == 0 && > - musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) { > + musb->xceiv->otg->state == OTG_STATE_A_WAIT_BCON)) { > dev_dbg(musb->controller, "%s active, deleting timer\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > del_timer(&otg_workaround); > last_timer = jiffies; > return; > @@ -280,7 +280,7 @@ static void da8xx_musb_try_idle(struct musb *musb, unsigned long timeout) > last_timer = timeout; > > dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > jiffies_to_msecs(timeout - jiffies)); > mod_timer(&otg_workaround, timeout); > } > @@ -341,26 +341,26 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci) > * devctl. > */ > musb->int_usb &= ~MUSB_INTR_VBUSERROR; > - musb->xceiv->state = OTG_STATE_A_WAIT_VFALL; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL; > mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); > WARNING("VBUS error workaround (delay coming)\n"); > } else if (drvvbus) { > MUSB_HST_MODE(musb); > otg->default_a = 1; > - musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE; > portstate(musb->port1_status |= USB_PORT_STAT_POWER); > del_timer(&otg_workaround); > } else { > musb->is_active = 0; > MUSB_DEV_MODE(musb); > otg->default_a = 0; > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > portstate(musb->port1_status &= ~USB_PORT_STAT_POWER); > } > > dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n", > drvvbus ? "on" : "off", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > err ? " ERROR" : "", > devctl); > ret = IRQ_HANDLED; > @@ -375,7 +375,7 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci) > musb_writel(reg_base, DA8XX_USB_END_OF_INTR_REG, 0); > > /* Poll for ID change */ > - if (musb->xceiv->state == OTG_STATE_B_IDLE) > + if (musb->xceiv->otg->state == OTG_STATE_B_IDLE) > mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); > > spin_unlock_irqrestore(&musb->lock, flags); > diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c > index 04de3ac..3c1d9b2 100644 > --- a/drivers/usb/musb/davinci.c > +++ b/drivers/usb/musb/davinci.c > @@ -214,10 +214,10 @@ static void otg_timer(unsigned long _musb) > */ > devctl = musb_readb(mregs, MUSB_DEVCTL); > dev_dbg(musb->controller, "poll devctl %02x (%s)\n", devctl, > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > > spin_lock_irqsave(&musb->lock, flags); > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_WAIT_VFALL: > /* Wait till VBUS falls below SessionEnd (~0.2V); the 1.3 RTL > * seems to mis-handle session "start" otherwise (or in our > @@ -228,7 +228,7 @@ static void otg_timer(unsigned long _musb) > mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); > break; > } > - musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE; > musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG, > MUSB_INTR_VBUSERROR << DAVINCI_USB_USBINT_SHIFT); > break; > @@ -251,7 +251,7 @@ static void otg_timer(unsigned long _musb) > if (devctl & MUSB_DEVCTL_BDEVICE) > mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); > else > - musb->xceiv->state = OTG_STATE_A_IDLE; > + musb->xceiv->otg->state = OTG_STATE_A_IDLE; > break; > default: > break; > @@ -325,20 +325,20 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci) > * to stop registering in devctl. > */ > musb->int_usb &= ~MUSB_INTR_VBUSERROR; > - musb->xceiv->state = OTG_STATE_A_WAIT_VFALL; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL; > mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); > WARNING("VBUS error workaround (delay coming)\n"); > } else if (drvvbus) { > MUSB_HST_MODE(musb); > otg->default_a = 1; > - musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE; > portstate(musb->port1_status |= USB_PORT_STAT_POWER); > del_timer(&otg_workaround); > } else { > musb->is_active = 0; > MUSB_DEV_MODE(musb); > otg->default_a = 0; > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > portstate(musb->port1_status &= ~USB_PORT_STAT_POWER); > } > > @@ -348,7 +348,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci) > davinci_musb_source_power(musb, drvvbus, 0); > dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n", > drvvbus ? "on" : "off", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > err ? " ERROR" : "", > devctl); > retval = IRQ_HANDLED; > @@ -361,7 +361,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci) > musb_writel(tibase, DAVINCI_USB_EOI_REG, 0); > > /* poll for ID change */ > - if (musb->xceiv->state == OTG_STATE_B_IDLE) > + if (musb->xceiv->otg->state == OTG_STATE_B_IDLE) > mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ); > > spin_unlock_irqrestore(&musb->lock, flags); > diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c > index e46e295..df9c5fa 100644 > --- a/drivers/usb/musb/musb_core.c > +++ b/drivers/usb/musb/musb_core.c > @@ -360,23 +360,23 @@ static void musb_otg_timer_func(unsigned long data) > unsigned long flags; > > spin_lock_irqsave(&musb->lock, flags); > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_B_WAIT_ACON: > dev_dbg(musb->controller, "HNP: b_wait_acon timeout; back to b_peripheral\n"); > musb_g_disconnect(musb); > - musb->xceiv->state = OTG_STATE_B_PERIPHERAL; > + musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL; > musb->is_active = 0; > break; > case OTG_STATE_A_SUSPEND: > case OTG_STATE_A_WAIT_BCON: > dev_dbg(musb->controller, "HNP: %s timeout\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > musb_platform_set_vbus(musb, 0); > - musb->xceiv->state = OTG_STATE_A_WAIT_VFALL; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL; > break; > default: > dev_dbg(musb->controller, "HNP: Unhandled mode %s\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > } > spin_unlock_irqrestore(&musb->lock, flags); > } > @@ -391,19 +391,19 @@ void musb_hnp_stop(struct musb *musb) > u8 reg; > > dev_dbg(musb->controller, "HNP: stop from %s\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_PERIPHERAL: > musb_g_disconnect(musb); > dev_dbg(musb->controller, "HNP: back to %s\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > break; > case OTG_STATE_B_HOST: > dev_dbg(musb->controller, "HNP: Disabling HR\n"); > if (hcd) > hcd->self.is_b_host = 0; > - musb->xceiv->state = OTG_STATE_B_PERIPHERAL; > + musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL; > MUSB_DEV_MODE(musb); > reg = musb_readb(mbase, MUSB_POWER); > reg |= MUSB_POWER_SUSPENDM; > @@ -412,7 +412,7 @@ void musb_hnp_stop(struct musb *musb) > break; > default: > dev_dbg(musb->controller, "HNP: Stopping in unknown state %s\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > } > > /* > @@ -449,13 +449,13 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, > */ > if (int_usb & MUSB_INTR_RESUME) { > handled = IRQ_HANDLED; > - dev_dbg(musb->controller, "RESUME (%s)\n", usb_otg_state_string(musb->xceiv->state)); > + dev_dbg(musb->controller, "RESUME (%s)\n", usb_otg_state_string(musb->xceiv->otg->state)); > > if (devctl & MUSB_DEVCTL_HM) { > void __iomem *mbase = musb->mregs; > u8 power; > > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_SUSPEND: > /* remote wakeup? later, GetPortStatus > * will stop RESUME signaling > @@ -482,25 +482,25 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, > &musb->finish_resume_work, > msecs_to_jiffies(20)); > > - musb->xceiv->state = OTG_STATE_A_HOST; > + musb->xceiv->otg->state = OTG_STATE_A_HOST; > musb->is_active = 1; > musb_host_resume_root_hub(musb); > break; > case OTG_STATE_B_WAIT_ACON: > - musb->xceiv->state = OTG_STATE_B_PERIPHERAL; > + musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL; > musb->is_active = 1; > MUSB_DEV_MODE(musb); > break; > default: > WARNING("bogus %s RESUME (%s)\n", > "host", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > } > } else { > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_SUSPEND: > /* possibly DISCONNECT is upcoming */ > - musb->xceiv->state = OTG_STATE_A_HOST; > + musb->xceiv->otg->state = OTG_STATE_A_HOST; > musb_host_resume_root_hub(musb); > break; > case OTG_STATE_B_WAIT_ACON: > @@ -523,7 +523,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, > default: > WARNING("bogus %s RESUME (%s)\n", > "peripheral", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > } > } > } > @@ -539,7 +539,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, > } > > dev_dbg(musb->controller, "SESSION_REQUEST (%s)\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > > /* IRQ arrives from ID pin sense or (later, if VBUS power > * is removed) SRP. responses are time critical: > @@ -550,7 +550,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, > */ > musb_writeb(mbase, MUSB_DEVCTL, MUSB_DEVCTL_SESSION); > musb->ep0_stage = MUSB_EP0_START; > - musb->xceiv->state = OTG_STATE_A_IDLE; > + musb->xceiv->otg->state = OTG_STATE_A_IDLE; > MUSB_HST_MODE(musb); > musb_platform_set_vbus(musb, 1); > > @@ -576,7 +576,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, > * REVISIT: do delays from lots of DEBUG_KERNEL checks > * make trouble here, keeping VBUS < 4.4V ? > */ > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_HOST: > /* recovery is dicey once we've gotten past the > * initial stages of enumeration, but if VBUS > @@ -605,7 +605,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, > > dev_printk(ignore ? KERN_DEBUG : KERN_ERR, musb->controller, > "VBUS_ERROR in %s (%02x, %s), retry #%d, port1 %08x\n", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > devctl, > ({ char *s; > switch (devctl & MUSB_DEVCTL_VBUS) { > @@ -630,10 +630,10 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, > > if (int_usb & MUSB_INTR_SUSPEND) { > dev_dbg(musb->controller, "SUSPEND (%s) devctl %02x\n", > - usb_otg_state_string(musb->xceiv->state), devctl); > + usb_otg_state_string(musb->xceiv->otg->state), devctl); > handled = IRQ_HANDLED; > > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_PERIPHERAL: > /* We also come here if the cable is removed, since > * this silicon doesn't report ID-no-longer-grounded. > @@ -657,7 +657,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, > musb_g_suspend(musb); > musb->is_active = musb->g.b_hnp_enable; > if (musb->is_active) { > - musb->xceiv->state = OTG_STATE_B_WAIT_ACON; > + musb->xceiv->otg->state = OTG_STATE_B_WAIT_ACON; > dev_dbg(musb->controller, "HNP: Setting timer for b_ase0_brst\n"); > mod_timer(&musb->otg_timer, jiffies > + msecs_to_jiffies( > @@ -670,7 +670,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, > + msecs_to_jiffies(musb->a_wait_bcon)); > break; > case OTG_STATE_A_HOST: > - musb->xceiv->state = OTG_STATE_A_SUSPEND; > + musb->xceiv->otg->state = OTG_STATE_A_SUSPEND; > musb->is_active = musb->hcd->self.b_hnp_enable; > break; > case OTG_STATE_B_HOST: > @@ -713,7 +713,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, > musb->port1_status |= USB_PORT_STAT_LOW_SPEED; > > /* indicate new connection to OTG machine */ > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_B_PERIPHERAL: > if (int_usb & MUSB_INTR_SUSPEND) { > dev_dbg(musb->controller, "HNP: SUSPEND+CONNECT, now b_host\n"); > @@ -725,7 +725,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb, > case OTG_STATE_B_WAIT_ACON: > dev_dbg(musb->controller, "HNP: CONNECT, now b_host\n"); > b_host: > - musb->xceiv->state = OTG_STATE_B_HOST; > + musb->xceiv->otg->state = OTG_STATE_B_HOST; > if (musb->hcd) > musb->hcd->self.is_b_host = 1; > del_timer(&musb->otg_timer); > @@ -733,7 +733,7 @@ b_host: > default: > if ((devctl & MUSB_DEVCTL_VBUS) > == (3 << MUSB_DEVCTL_VBUS_SHIFT)) { > - musb->xceiv->state = OTG_STATE_A_HOST; > + musb->xceiv->otg->state = OTG_STATE_A_HOST; > if (hcd) > hcd->self.is_b_host = 0; > } > @@ -743,16 +743,16 @@ b_host: > musb_host_poke_root_hub(musb); > > dev_dbg(musb->controller, "CONNECT (%s) devctl %02x\n", > - usb_otg_state_string(musb->xceiv->state), devctl); > + usb_otg_state_string(musb->xceiv->otg->state), devctl); > } > > if (int_usb & MUSB_INTR_DISCONNECT) { > dev_dbg(musb->controller, "DISCONNECT (%s) as %s, devctl %02x\n", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > MUSB_MODE(musb), devctl); > handled = IRQ_HANDLED; > > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_HOST: > case OTG_STATE_A_SUSPEND: > musb_host_resume_root_hub(musb); > @@ -770,7 +770,7 @@ b_host: > musb_root_disconnect(musb); > if (musb->hcd) > musb->hcd->self.is_b_host = 0; > - musb->xceiv->state = OTG_STATE_B_PERIPHERAL; > + musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL; > MUSB_DEV_MODE(musb); > musb_g_disconnect(musb); > break; > @@ -786,7 +786,7 @@ b_host: > break; > default: > WARNING("unhandled DISCONNECT transition (%s)\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > break; > } > } > @@ -812,15 +812,15 @@ b_host: > } > } else { > dev_dbg(musb->controller, "BUS RESET as %s\n", > - usb_otg_state_string(musb->xceiv->state)); > - switch (musb->xceiv->state) { > + usb_otg_state_string(musb->xceiv->otg->state)); > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_SUSPEND: > musb_g_reset(musb); > /* FALLTHROUGH */ > case OTG_STATE_A_WAIT_BCON: /* OPT TD.4.7-900ms */ > /* never use invalid T(a_wait_bcon) */ > dev_dbg(musb->controller, "HNP: in %s, %d msec timeout\n", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > TA_WAIT_BCON(musb)); > mod_timer(&musb->otg_timer, jiffies > + msecs_to_jiffies(TA_WAIT_BCON(musb))); > @@ -831,19 +831,19 @@ b_host: > break; > case OTG_STATE_B_WAIT_ACON: > dev_dbg(musb->controller, "HNP: RESET (%s), to b_peripheral\n", > - usb_otg_state_string(musb->xceiv->state)); > - musb->xceiv->state = OTG_STATE_B_PERIPHERAL; > + usb_otg_state_string(musb->xceiv->otg->state)); > + musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL; > musb_g_reset(musb); > break; > case OTG_STATE_B_IDLE: > - musb->xceiv->state = OTG_STATE_B_PERIPHERAL; > + musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL; > /* FALLTHROUGH */ > case OTG_STATE_B_PERIPHERAL: > musb_g_reset(musb); > break; > default: > dev_dbg(musb->controller, "Unhandled BUS RESET as %s\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > } > } > } > @@ -1630,7 +1630,7 @@ musb_mode_show(struct device *dev, struct device_attribute *attr, char *buf) > int ret = -EINVAL; > > spin_lock_irqsave(&musb->lock, flags); > - ret = sprintf(buf, "%s\n", usb_otg_state_string(musb->xceiv->state)); > + ret = sprintf(buf, "%s\n", usb_otg_state_string(musb->xceiv->otg->state)); > spin_unlock_irqrestore(&musb->lock, flags); > > return ret; > @@ -1675,7 +1675,7 @@ musb_vbus_store(struct device *dev, struct device_attribute *attr, > spin_lock_irqsave(&musb->lock, flags); > /* force T(a_wait_bcon) to be zero/unlimited *OR* valid */ > musb->a_wait_bcon = val ? max_t(int, val, OTG_TIME_A_WAIT_BCON) : 0 ; > - if (musb->xceiv->state == OTG_STATE_A_WAIT_BCON) > + if (musb->xceiv->otg->state == OTG_STATE_A_WAIT_BCON) > musb->is_active = 0; > musb_platform_try_idle(musb, jiffies + msecs_to_jiffies(val)); > spin_unlock_irqrestore(&musb->lock, flags); > @@ -1743,8 +1743,8 @@ static void musb_irq_work(struct work_struct *data) > { > struct musb *musb = container_of(data, struct musb, irq_work); > > - if (musb->xceiv->state != musb->xceiv_old_state) { > - musb->xceiv_old_state = musb->xceiv->state; > + if (musb->xceiv->otg->state != musb->xceiv_old_state) { > + musb->xceiv_old_state = musb->xceiv->otg->state; > sysfs_notify(&musb->controller->kobj, NULL, "mode"); > } > } > @@ -1983,10 +1983,10 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl) > > if (musb->xceiv->otg->default_a) { > MUSB_HST_MODE(musb); > - musb->xceiv->state = OTG_STATE_A_IDLE; > + musb->xceiv->otg->state = OTG_STATE_A_IDLE; > } else { > MUSB_DEV_MODE(musb); > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > } > > switch (musb->port_mode) { > diff --git a/drivers/usb/musb/musb_dsps.c b/drivers/usb/musb/musb_dsps.c > index 759ef1d..a44d9e3 100644 > --- a/drivers/usb/musb/musb_dsps.c > +++ b/drivers/usb/musb/musb_dsps.c > @@ -179,9 +179,9 @@ static void dsps_musb_try_idle(struct musb *musb, unsigned long timeout) > > /* Never idle if active, or when VBUS timeout is not set as host */ > if (musb->is_active || (musb->a_wait_bcon == 0 && > - musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) { > + musb->xceiv->otg->state == OTG_STATE_A_WAIT_BCON)) { > dev_dbg(musb->controller, "%s active, deleting timer\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > del_timer(&glue->timer); > glue->last_timer = jiffies; > return; > @@ -201,7 +201,7 @@ static void dsps_musb_try_idle(struct musb *musb, unsigned long timeout) > glue->last_timer = timeout; > > dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > jiffies_to_msecs(timeout - jiffies)); > mod_timer(&glue->timer, timeout); > } > @@ -265,10 +265,10 @@ static void otg_timer(unsigned long _musb) > */ > devctl = dsps_readb(mregs, MUSB_DEVCTL); > dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl, > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > > spin_lock_irqsave(&musb->lock, flags); > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_WAIT_BCON: > dsps_writeb(musb->mregs, MUSB_DEVCTL, 0); > skip_session = 1; > @@ -277,10 +277,10 @@ static void otg_timer(unsigned long _musb) > case OTG_STATE_A_IDLE: > case OTG_STATE_B_IDLE: > if (devctl & MUSB_DEVCTL_BDEVICE) { > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > MUSB_DEV_MODE(musb); > } else { > - musb->xceiv->state = OTG_STATE_A_IDLE; > + musb->xceiv->otg->state = OTG_STATE_A_IDLE; > MUSB_HST_MODE(musb); > } > if (!(devctl & MUSB_DEVCTL_SESSION) && !skip_session) > @@ -288,7 +288,7 @@ static void otg_timer(unsigned long _musb) > mod_timer(&glue->timer, jiffies + wrp->poll_seconds * HZ); > break; > case OTG_STATE_A_WAIT_VFALL: > - musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE; > dsps_writel(musb->ctrl_base, wrp->coreintr_set, > MUSB_INTR_VBUSERROR << wrp->usb_shift); > break; > @@ -373,26 +373,26 @@ static irqreturn_t dsps_interrupt(int irq, void *hci) > * devctl. > */ > musb->int_usb &= ~MUSB_INTR_VBUSERROR; > - musb->xceiv->state = OTG_STATE_A_WAIT_VFALL; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL; > mod_timer(&glue->timer, > jiffies + wrp->poll_seconds * HZ); > WARNING("VBUS error workaround (delay coming)\n"); > } else if (drvvbus) { > MUSB_HST_MODE(musb); > musb->xceiv->otg->default_a = 1; > - musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE; > del_timer(&glue->timer); > } else { > musb->is_active = 0; > MUSB_DEV_MODE(musb); > musb->xceiv->otg->default_a = 0; > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > } > > /* NOTE: this must complete power-on within 100 ms. */ > dev_dbg(musb->controller, "VBUS %s (%s)%s, devctl %02x\n", > drvvbus ? "on" : "off", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > err ? " ERROR" : "", > devctl); > ret = IRQ_HANDLED; > @@ -402,7 +402,7 @@ static irqreturn_t dsps_interrupt(int irq, void *hci) > ret |= musb_interrupt(musb); > > /* Poll for ID change in OTG port mode */ > - if (musb->xceiv->state == OTG_STATE_B_IDLE && > + if (musb->xceiv->otg->state == OTG_STATE_B_IDLE && > musb->port_mode == MUSB_PORT_MODE_DUAL_ROLE) > mod_timer(&glue->timer, jiffies + wrp->poll_seconds * HZ); > out: > diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c > index 4ab1896..56c31b7 100644 > --- a/drivers/usb/musb/musb_gadget.c > +++ b/drivers/usb/musb/musb_gadget.c > @@ -1546,7 +1546,7 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget) > > spin_lock_irqsave(&musb->lock, flags); > > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_B_PERIPHERAL: > /* NOTE: OTG state machine doesn't include B_SUSPENDED; > * that's part of the standard usb 1.1 state machine, and > @@ -1587,7 +1587,7 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget) > goto done; > default: > dev_dbg(musb->controller, "Unhandled wake: %s\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > goto done; > } > > @@ -1791,7 +1791,7 @@ int musb_gadget_setup(struct musb *musb) > > MUSB_DEV_MODE(musb); > musb->xceiv->otg->default_a = 0; > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > > /* this "gadget" abstracts/virtualizes the controller */ > musb->g.name = musb_driver_name; > @@ -1857,7 +1857,7 @@ static int musb_gadget_start(struct usb_gadget *g, > musb->is_active = 1; > > otg_set_peripheral(otg, &musb->g); > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > spin_unlock_irqrestore(&musb->lock, flags); > > musb_start(musb); > @@ -1941,7 +1941,7 @@ static int musb_gadget_stop(struct usb_gadget *g) > > (void) musb_gadget_vbus_draw(&musb->g, 0); > > - musb->xceiv->state = OTG_STATE_UNDEFINED; > + musb->xceiv->otg->state = OTG_STATE_UNDEFINED; > stop_activity(musb, NULL); > otg_set_peripheral(musb->xceiv->otg, NULL); > > @@ -1968,7 +1968,7 @@ static int musb_gadget_stop(struct usb_gadget *g) > void musb_g_resume(struct musb *musb) > { > musb->is_suspended = 0; > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_B_IDLE: > break; > case OTG_STATE_B_WAIT_ACON: > @@ -1982,7 +1982,7 @@ void musb_g_resume(struct musb *musb) > break; > default: > WARNING("unhandled RESUME transition (%s)\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > } > } > > @@ -1994,10 +1994,10 @@ void musb_g_suspend(struct musb *musb) > devctl = musb_readb(musb->mregs, MUSB_DEVCTL); > dev_dbg(musb->controller, "devctl %02x\n", devctl); > > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_B_IDLE: > if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS) > - musb->xceiv->state = OTG_STATE_B_PERIPHERAL; > + musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL; > break; > case OTG_STATE_B_PERIPHERAL: > musb->is_suspended = 1; > @@ -2012,7 +2012,7 @@ void musb_g_suspend(struct musb *musb) > * A_PERIPHERAL may need care too > */ > WARNING("unhandled SUSPEND transition (%s)\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > } > } > > @@ -2043,22 +2043,22 @@ void musb_g_disconnect(struct musb *musb) > spin_lock(&musb->lock); > } > > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > default: > dev_dbg(musb->controller, "Unhandled disconnect %s, setting a_idle\n", > - usb_otg_state_string(musb->xceiv->state)); > - musb->xceiv->state = OTG_STATE_A_IDLE; > + usb_otg_state_string(musb->xceiv->otg->state)); > + musb->xceiv->otg->state = OTG_STATE_A_IDLE; > MUSB_HST_MODE(musb); > break; > case OTG_STATE_A_PERIPHERAL: > - musb->xceiv->state = OTG_STATE_A_WAIT_BCON; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_BCON; > MUSB_HST_MODE(musb); > break; > case OTG_STATE_B_WAIT_ACON: > case OTG_STATE_B_HOST: > case OTG_STATE_B_PERIPHERAL: > case OTG_STATE_B_IDLE: > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > break; > case OTG_STATE_B_SRP_INIT: > break; > @@ -2118,13 +2118,13 @@ __acquires(musb->lock) > * In that case, do not rely on devctl for setting > * peripheral mode. > */ > - musb->xceiv->state = OTG_STATE_B_PERIPHERAL; > + musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL; > musb->g.is_a_peripheral = 0; > } else if (devctl & MUSB_DEVCTL_BDEVICE) { > - musb->xceiv->state = OTG_STATE_B_PERIPHERAL; > + musb->xceiv->otg->state = OTG_STATE_B_PERIPHERAL; > musb->g.is_a_peripheral = 0; > } else { > - musb->xceiv->state = OTG_STATE_A_PERIPHERAL; > + musb->xceiv->otg->state = OTG_STATE_A_PERIPHERAL; > musb->g.is_a_peripheral = 1; > } > > diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c > index 855793d..23d474d 100644 > --- a/drivers/usb/musb/musb_host.c > +++ b/drivers/usb/musb/musb_host.c > @@ -2463,7 +2463,7 @@ static int musb_bus_suspend(struct usb_hcd *hcd) > if (!is_host_active(musb)) > return 0; > > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_SUSPEND: > return 0; > case OTG_STATE_A_WAIT_VRISE: > @@ -2473,7 +2473,7 @@ static int musb_bus_suspend(struct usb_hcd *hcd) > */ > devctl = musb_readb(musb->mregs, MUSB_DEVCTL); > if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS) > - musb->xceiv->state = OTG_STATE_A_WAIT_BCON; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_BCON; > break; > default: > break; > @@ -2481,7 +2481,7 @@ static int musb_bus_suspend(struct usb_hcd *hcd) > > if (musb->is_active) { > WARNING("trying to suspend as %s while active\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > return -EBUSY; > } else > return 0; > @@ -2678,7 +2678,7 @@ int musb_host_setup(struct musb *musb, int power_budget) > > MUSB_HST_MODE(musb); > musb->xceiv->otg->default_a = 1; > - musb->xceiv->state = OTG_STATE_A_IDLE; > + musb->xceiv->otg->state = OTG_STATE_A_IDLE; > > otg_set_host(musb->xceiv->otg, &hcd->self); > hcd->self.otg_port = 1; > diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c > index e2d2d8c..a133bd8 100644 > --- a/drivers/usb/musb/musb_virthub.c > +++ b/drivers/usb/musb/musb_virthub.c > @@ -69,7 +69,7 @@ void musb_host_finish_resume(struct work_struct *work) > musb->port1_status |= USB_PORT_STAT_C_SUSPEND << 16; > usb_hcd_poll_rh_status(musb->hcd); > /* NOTE: it might really be A_WAIT_BCON ... */ > - musb->xceiv->state = OTG_STATE_A_HOST; > + musb->xceiv->otg->state = OTG_STATE_A_HOST; > > spin_unlock_irqrestore(&musb->lock, flags); > } > @@ -107,9 +107,9 @@ void musb_port_suspend(struct musb *musb, bool do_suspend) > dev_dbg(musb->controller, "Root port suspended, power %02x\n", power); > > musb->port1_status |= USB_PORT_STAT_SUSPEND; > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_HOST: > - musb->xceiv->state = OTG_STATE_A_SUSPEND; > + musb->xceiv->otg->state = OTG_STATE_A_SUSPEND; > musb->is_active = otg->host->b_hnp_enable; > if (musb->is_active) > mod_timer(&musb->otg_timer, jiffies > @@ -118,13 +118,13 @@ void musb_port_suspend(struct musb *musb, bool do_suspend) > musb_platform_try_idle(musb, 0); > break; > case OTG_STATE_B_HOST: > - musb->xceiv->state = OTG_STATE_B_WAIT_ACON; > + musb->xceiv->otg->state = OTG_STATE_B_WAIT_ACON; > musb->is_active = otg->host->b_hnp_enable; > musb_platform_try_idle(musb, 0); > break; > default: > dev_dbg(musb->controller, "bogus rh suspend? %s\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > } > } else if (power & MUSB_POWER_SUSPENDM) { > power &= ~MUSB_POWER_SUSPENDM; > @@ -145,7 +145,7 @@ void musb_port_reset(struct musb *musb, bool do_reset) > u8 power; > void __iomem *mbase = musb->mregs; > > - if (musb->xceiv->state == OTG_STATE_B_IDLE) { > + if (musb->xceiv->otg->state == OTG_STATE_B_IDLE) { > dev_dbg(musb->controller, "HNP: Returning from HNP; no hub reset from b_idle\n"); > musb->port1_status &= ~USB_PORT_STAT_RESET; > return; > @@ -224,24 +224,24 @@ void musb_root_disconnect(struct musb *musb) > usb_hcd_poll_rh_status(musb->hcd); > musb->is_active = 0; > > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_SUSPEND: > if (otg->host->b_hnp_enable) { > - musb->xceiv->state = OTG_STATE_A_PERIPHERAL; > + musb->xceiv->otg->state = OTG_STATE_A_PERIPHERAL; > musb->g.is_a_peripheral = 1; > break; > } > /* FALLTHROUGH */ > case OTG_STATE_A_HOST: > - musb->xceiv->state = OTG_STATE_A_WAIT_BCON; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_BCON; > musb->is_active = 0; > break; > case OTG_STATE_A_WAIT_VFALL: > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > break; > default: > dev_dbg(musb->controller, "host disconnect (%s)\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > } > } > > diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c > index 20fc2a5..763649e 100644 > --- a/drivers/usb/musb/omap2430.c > +++ b/drivers/usb/musb/omap2430.c > @@ -65,15 +65,15 @@ static void musb_do_idle(unsigned long _musb) > > spin_lock_irqsave(&musb->lock, flags); > > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_WAIT_BCON: > > devctl = musb_readb(musb->mregs, MUSB_DEVCTL); > if (devctl & MUSB_DEVCTL_BDEVICE) { > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > MUSB_DEV_MODE(musb); > } else { > - musb->xceiv->state = OTG_STATE_A_IDLE; > + musb->xceiv->otg->state = OTG_STATE_A_IDLE; > MUSB_HST_MODE(musb); > } > break; > @@ -90,15 +90,15 @@ static void musb_do_idle(unsigned long _musb) > musb->port1_status |= USB_PORT_STAT_C_SUSPEND << 16; > usb_hcd_poll_rh_status(musb->hcd); > /* NOTE: it might really be A_WAIT_BCON ... */ > - musb->xceiv->state = OTG_STATE_A_HOST; > + musb->xceiv->otg->state = OTG_STATE_A_HOST; > } > break; > case OTG_STATE_A_HOST: > devctl = musb_readb(musb->mregs, MUSB_DEVCTL); > if (devctl & MUSB_DEVCTL_BDEVICE) > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > else > - musb->xceiv->state = OTG_STATE_A_WAIT_BCON; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_BCON; > default: > break; > } > @@ -116,9 +116,9 @@ static void omap2430_musb_try_idle(struct musb *musb, unsigned long timeout) > > /* Never idle if active, or when VBUS timeout is not set as host */ > if (musb->is_active || ((musb->a_wait_bcon == 0) > - && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) { > + && (musb->xceiv->otg->state == OTG_STATE_A_WAIT_BCON))) { > dev_dbg(musb->controller, "%s active, deleting timer\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > del_timer(&musb_idle_timer); > last_timer = jiffies; > return; > @@ -135,7 +135,7 @@ static void omap2430_musb_try_idle(struct musb *musb, unsigned long timeout) > last_timer = timeout; > > dev_dbg(musb->controller, "%s inactive, for idle timer for %lu ms\n", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > (unsigned long)jiffies_to_msecs(timeout - jiffies)); > mod_timer(&musb_idle_timer, timeout); > } > @@ -153,7 +153,7 @@ static void omap2430_musb_set_vbus(struct musb *musb, int is_on) > devctl = musb_readb(musb->mregs, MUSB_DEVCTL); > > if (is_on) { > - if (musb->xceiv->state == OTG_STATE_A_IDLE) { > + if (musb->xceiv->otg->state == OTG_STATE_A_IDLE) { > int loops = 100; > /* start the session */ > devctl |= MUSB_DEVCTL_SESSION; > @@ -180,7 +180,7 @@ static void omap2430_musb_set_vbus(struct musb *musb, int is_on) > } else { > musb->is_active = 1; > otg->default_a = 1; > - musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE; > devctl |= MUSB_DEVCTL_SESSION; > MUSB_HST_MODE(musb); > } > @@ -192,7 +192,7 @@ static void omap2430_musb_set_vbus(struct musb *musb, int is_on) > */ > > otg->default_a = 0; > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > devctl &= ~MUSB_DEVCTL_SESSION; > > MUSB_DEV_MODE(musb); > @@ -201,7 +201,7 @@ static void omap2430_musb_set_vbus(struct musb *musb, int is_on) > > dev_dbg(musb->controller, "VBUS %s, devctl %02x " > /* otg %3x conf %08x prcm %08x */ "\n", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > musb_readb(musb->mregs, MUSB_DEVCTL)); > } > > @@ -266,7 +266,7 @@ static void omap_musb_set_mailbox(struct omap2430_glue *glue) > dev_dbg(dev, "ID GND\n"); > > otg->default_a = true; > - musb->xceiv->state = OTG_STATE_A_IDLE; > + musb->xceiv->otg->state = OTG_STATE_A_IDLE; > musb->xceiv->last_event = USB_EVENT_ID; > if (musb->gadget_driver) { > pm_runtime_get_sync(dev); > @@ -280,7 +280,7 @@ static void omap_musb_set_mailbox(struct omap2430_glue *glue) > dev_dbg(dev, "VBUS Connect\n"); > > otg->default_a = false; > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > musb->xceiv->last_event = USB_EVENT_VBUS; > if (musb->gadget_driver) > pm_runtime_get_sync(dev); > diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c > index 25f02df..69ca92d6 100644 > --- a/drivers/usb/musb/tusb6010.c > +++ b/drivers/usb/musb/tusb6010.c > @@ -415,13 +415,13 @@ static void musb_do_idle(unsigned long _musb) > > spin_lock_irqsave(&musb->lock, flags); > > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_WAIT_BCON: > if ((musb->a_wait_bcon != 0) > && (musb->idle_timeout == 0 > || time_after(jiffies, musb->idle_timeout))) { > dev_dbg(musb->controller, "Nothing connected %s, turning off VBUS\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > } > /* FALLTHROUGH */ > case OTG_STATE_A_IDLE: > @@ -474,9 +474,9 @@ static void tusb_musb_try_idle(struct musb *musb, unsigned long timeout) > > /* Never idle if active, or when VBUS timeout is not set as host */ > if (musb->is_active || ((musb->a_wait_bcon == 0) > - && (musb->xceiv->state == OTG_STATE_A_WAIT_BCON))) { > + && (musb->xceiv->otg->state == OTG_STATE_A_WAIT_BCON))) { > dev_dbg(musb->controller, "%s active, deleting timer\n", > - usb_otg_state_string(musb->xceiv->state)); > + usb_otg_state_string(musb->xceiv->otg->state)); > del_timer(&musb_idle_timer); > last_timer = jiffies; > return; > @@ -493,7 +493,7 @@ static void tusb_musb_try_idle(struct musb *musb, unsigned long timeout) > last_timer = timeout; > > dev_dbg(musb->controller, "%s inactive, for idle timer for %lu ms\n", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > (unsigned long)jiffies_to_msecs(timeout - jiffies)); > mod_timer(&musb_idle_timer, timeout); > } > @@ -524,7 +524,7 @@ static void tusb_musb_set_vbus(struct musb *musb, int is_on) > if (is_on) { > timer = OTG_TIMER_MS(OTG_TIME_A_WAIT_VRISE); > otg->default_a = 1; > - musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE; > devctl |= MUSB_DEVCTL_SESSION; > > conf |= TUSB_DEV_CONF_USB_HOST_MODE; > @@ -537,16 +537,16 @@ static void tusb_musb_set_vbus(struct musb *musb, int is_on) > /* If ID pin is grounded, we want to be a_idle */ > otg_stat = musb_readl(tbase, TUSB_DEV_OTG_STAT); > if (!(otg_stat & TUSB_DEV_OTG_STAT_ID_STATUS)) { > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_WAIT_VRISE: > case OTG_STATE_A_WAIT_BCON: > - musb->xceiv->state = OTG_STATE_A_WAIT_VFALL; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VFALL; > break; > case OTG_STATE_A_WAIT_VFALL: > - musb->xceiv->state = OTG_STATE_A_IDLE; > + musb->xceiv->otg->state = OTG_STATE_A_IDLE; > break; > default: > - musb->xceiv->state = OTG_STATE_A_IDLE; > + musb->xceiv->otg->state = OTG_STATE_A_IDLE; > } > musb->is_active = 0; > otg->default_a = 1; > @@ -554,7 +554,7 @@ static void tusb_musb_set_vbus(struct musb *musb, int is_on) > } else { > musb->is_active = 0; > otg->default_a = 0; > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > MUSB_DEV_MODE(musb); > } > > @@ -569,7 +569,7 @@ static void tusb_musb_set_vbus(struct musb *musb, int is_on) > musb_writeb(musb->mregs, MUSB_DEVCTL, devctl); > > dev_dbg(musb->controller, "VBUS %s, devctl %02x otg %3x conf %08x prcm %08x\n", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > musb_readb(musb->mregs, MUSB_DEVCTL), > musb_readl(tbase, TUSB_DEV_OTG_STAT), > conf, prcm); > @@ -668,23 +668,23 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase) > > if (otg_stat & TUSB_DEV_OTG_STAT_SESS_END) { > dev_dbg(musb->controller, "Forcing disconnect (no interrupt)\n"); > - if (musb->xceiv->state != OTG_STATE_B_IDLE) { > + if (musb->xceiv->otg->state != OTG_STATE_B_IDLE) { > /* INTR_DISCONNECT can hide... */ > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > musb->int_usb |= MUSB_INTR_DISCONNECT; > } > musb->is_active = 0; > } > dev_dbg(musb->controller, "vbus change, %s, otg %03x\n", > - usb_otg_state_string(musb->xceiv->state), otg_stat); > + usb_otg_state_string(musb->xceiv->otg->state), otg_stat); > idle_timeout = jiffies + (1 * HZ); > schedule_work(&musb->irq_work); > > } else /* A-dev state machine */ { > dev_dbg(musb->controller, "vbus change, %s, otg %03x\n", > - usb_otg_state_string(musb->xceiv->state), otg_stat); > + usb_otg_state_string(musb->xceiv->otg->state), otg_stat); > > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_IDLE: > dev_dbg(musb->controller, "Got SRP, turning on VBUS\n"); > musb_platform_set_vbus(musb, 1); > @@ -731,9 +731,9 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase) > u8 devctl; > > dev_dbg(musb->controller, "%s timer, %03x\n", > - usb_otg_state_string(musb->xceiv->state), otg_stat); > + usb_otg_state_string(musb->xceiv->otg->state), otg_stat); > > - switch (musb->xceiv->state) { > + switch (musb->xceiv->otg->state) { > case OTG_STATE_A_WAIT_VRISE: > /* VBUS has probably been valid for a while now, > * but may well have bounced out of range a bit > @@ -745,7 +745,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase) > dev_dbg(musb->controller, "devctl %02x\n", devctl); > break; > } > - musb->xceiv->state = OTG_STATE_A_WAIT_BCON; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_BCON; > musb->is_active = 0; > idle_timeout = jiffies > + msecs_to_jiffies(musb->a_wait_bcon); > diff --git a/drivers/usb/musb/ux500.c b/drivers/usb/musb/ux500.c > index d0180a7..1d631d5 100644 > --- a/drivers/usb/musb/ux500.c > +++ b/drivers/usb/musb/ux500.c > @@ -56,7 +56,7 @@ static void ux500_musb_set_vbus(struct musb *musb, int is_on) > devctl = musb_readb(musb->mregs, MUSB_DEVCTL); > > if (is_on) { > - if (musb->xceiv->state == OTG_STATE_A_IDLE) { > + if (musb->xceiv->otg->state == OTG_STATE_A_IDLE) { > /* start the session */ > devctl |= MUSB_DEVCTL_SESSION; > musb_writeb(musb->mregs, MUSB_DEVCTL, devctl); > @@ -76,7 +76,7 @@ static void ux500_musb_set_vbus(struct musb *musb, int is_on) > } else { > musb->is_active = 1; > musb->xceiv->otg->default_a = 1; > - musb->xceiv->state = OTG_STATE_A_WAIT_VRISE; > + musb->xceiv->otg->state = OTG_STATE_A_WAIT_VRISE; > devctl |= MUSB_DEVCTL_SESSION; > MUSB_HST_MODE(musb); > } > @@ -102,7 +102,7 @@ static void ux500_musb_set_vbus(struct musb *musb, int is_on) > mdelay(200); > > dev_dbg(musb->controller, "VBUS %s, devctl %02x\n", > - usb_otg_state_string(musb->xceiv->state), > + usb_otg_state_string(musb->xceiv->otg->state), > musb_readb(musb->mregs, MUSB_DEVCTL)); > } > > @@ -112,7 +112,7 @@ static int musb_otg_notifications(struct notifier_block *nb, > struct musb *musb = container_of(nb, struct musb, nb); > > dev_dbg(musb->controller, "musb_otg_notifications %ld %s\n", > - event, usb_otg_state_string(musb->xceiv->state)); > + event, usb_otg_state_string(musb->xceiv->otg->state)); > > switch (event) { > case UX500_MUSB_ID: > @@ -127,7 +127,7 @@ static int musb_otg_notifications(struct notifier_block *nb, > if (is_host_active(musb)) > ux500_musb_set_vbus(musb, 0); > else > - musb->xceiv->state = OTG_STATE_B_IDLE; > + musb->xceiv->otg->state = OTG_STATE_B_IDLE; > break; > default: > dev_dbg(musb->controller, "ID float\n"); > diff --git a/drivers/usb/phy/phy-ab8500-usb.c b/drivers/usb/phy/phy-ab8500-usb.c > index 11ab2c4..2d52501 100644 > --- a/drivers/usb/phy/phy-ab8500-usb.c > +++ b/drivers/usb/phy/phy-ab8500-usb.c > @@ -446,7 +446,7 @@ static int ab9540_usb_link_status_update(struct ab8500_usb *ab, > if (event != UX500_MUSB_RIDB) > event = UX500_MUSB_NONE; > /* Fallback to default B_IDLE as nothing is connected. */ > - ab->phy.state = OTG_STATE_B_IDLE; > + ab->phy.otg->state = OTG_STATE_B_IDLE; > break; > > case USB_LINK_ACA_RID_C_NM_9540: > @@ -584,7 +584,7 @@ static int ab8540_usb_link_status_update(struct ab8500_usb *ab, > * Fallback to default B_IDLE as nothing > * is connected > */ > - ab->phy.state = OTG_STATE_B_IDLE; > + ab->phy.otg->state = OTG_STATE_B_IDLE; > break; > > case USB_LINK_ACA_RID_C_NM_8540: > @@ -693,7 +693,7 @@ static int ab8505_usb_link_status_update(struct ab8500_usb *ab, > * Fallback to default B_IDLE as nothing > * is connected > */ > - ab->phy.state = OTG_STATE_B_IDLE; > + ab->phy.otg->state = OTG_STATE_B_IDLE; > break; > > case USB_LINK_ACA_RID_C_NM_8505: > @@ -776,7 +776,7 @@ static int ab8500_usb_link_status_update(struct ab8500_usb *ab, > if (event != UX500_MUSB_RIDB) > event = UX500_MUSB_NONE; > /* Fallback to default B_IDLE as nothing is connected */ > - ab->phy.state = OTG_STATE_B_IDLE; > + ab->phy.otg->state = OTG_STATE_B_IDLE; > break; > > case USB_LINK_ACA_RID_C_NM_8500: > @@ -1380,7 +1380,7 @@ static int ab8500_usb_probe(struct platform_device *pdev) > ab->phy.label = "ab8500"; > ab->phy.set_suspend = ab8500_usb_set_suspend; > ab->phy.set_power = ab8500_usb_set_power; > - ab->phy.state = OTG_STATE_UNDEFINED; > + ab->phy.otg->state = OTG_STATE_UNDEFINED; > > otg->phy = &ab->phy; > otg->set_host = ab8500_usb_set_host; > diff --git a/drivers/usb/phy/phy-fsl-usb.c b/drivers/usb/phy/phy-fsl-usb.c > index f1ea599..15d7a81 100644 > --- a/drivers/usb/phy/phy-fsl-usb.c > +++ b/drivers/usb/phy/phy-fsl-usb.c > @@ -623,7 +623,7 @@ static int fsl_otg_set_host(struct usb_otg *otg, struct usb_bus *host) > /* Mini-A cable connected */ > struct otg_fsm *fsm = &otg_dev->fsm; > > - otg->phy->state = OTG_STATE_UNDEFINED; > + otg.state = OTG_STATE_UNDEFINED; > fsm->protocol = PROTO_UNDEF; > } > } > @@ -681,7 +681,7 @@ static int fsl_otg_set_power(struct usb_phy *phy, unsigned mA) > { > if (!fsl_otg_dev) > return -ENODEV; > - if (phy->state == OTG_STATE_B_PERIPHERAL) > + if (phy->otg.state == OTG_STATE_B_PERIPHERAL) > pr_info("FSL OTG: Draw %d mA\n", mA); > > return 0; > @@ -714,7 +714,7 @@ static int fsl_otg_start_srp(struct usb_otg *otg) > { > struct fsl_otg *otg_dev; > > - if (!otg || otg->phy->state != OTG_STATE_B_IDLE) > + if (!otg || otg.state != OTG_STATE_B_IDLE) > return -ENODEV; > > otg_dev = container_of(otg->phy, struct fsl_otg, phy); > @@ -989,10 +989,10 @@ int usb_otg_start(struct platform_device *pdev) > * Also: record initial state of ID pin > */ > if (fsl_readl(&p_otg->dr_mem_map->otgsc) & OTGSC_STS_USB_ID) { > - p_otg->phy.state = OTG_STATE_UNDEFINED; > + p_otg->phy->otg.state = OTG_STATE_UNDEFINED; > p_otg->fsm.id = 1; > } else { > - p_otg->phy.state = OTG_STATE_A_IDLE; > + p_otg->phy->otg.state = OTG_STATE_A_IDLE; > p_otg->fsm.id = 0; > } > > diff --git a/drivers/usb/phy/phy-generic.c b/drivers/usb/phy/phy-generic.c > index 7594e50..280a345 100644 > --- a/drivers/usb/phy/phy-generic.c > +++ b/drivers/usb/phy/phy-generic.c > @@ -123,7 +123,7 @@ static int nop_set_peripheral(struct usb_otg *otg, struct usb_gadget *gadget) > } > > otg->gadget = gadget; > - otg->phy->state = OTG_STATE_B_IDLE; > + otg->state = OTG_STATE_B_IDLE; > return 0; > } > > @@ -225,9 +225,9 @@ int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_generic *nop, > nop->phy.dev = nop->dev; > nop->phy.label = "nop-xceiv"; > nop->phy.set_suspend = nop_set_suspend; > - nop->phy.state = OTG_STATE_UNDEFINED; > nop->phy.type = type; > > + nop->phy.otg->state = OTG_STATE_UNDEFINED; > nop->phy.otg->phy = &nop->phy; > nop->phy.otg->set_host = nop_set_host; > nop->phy.otg->set_peripheral = nop_set_peripheral; > diff --git a/drivers/usb/phy/phy-gpio-vbus-usb.c b/drivers/usb/phy/phy-gpio-vbus-usb.c > index f4b14bd..7a6be3e 100644 > --- a/drivers/usb/phy/phy-gpio-vbus-usb.c > +++ b/drivers/usb/phy/phy-gpio-vbus-usb.c > @@ -121,7 +121,7 @@ static void gpio_vbus_work(struct work_struct *work) > > if (vbus) { > status = USB_EVENT_VBUS; > - gpio_vbus->phy.state = OTG_STATE_B_PERIPHERAL; > + gpio_vbus->phy.otg->state = OTG_STATE_B_PERIPHERAL; > gpio_vbus->phy.last_event = status; > usb_gadget_vbus_connect(gpio_vbus->phy.otg->gadget); > > @@ -143,7 +143,7 @@ static void gpio_vbus_work(struct work_struct *work) > > usb_gadget_vbus_disconnect(gpio_vbus->phy.otg->gadget); > status = USB_EVENT_NONE; > - gpio_vbus->phy.state = OTG_STATE_B_IDLE; > + gpio_vbus->phy.otg->state = OTG_STATE_B_IDLE; > gpio_vbus->phy.last_event = status; > > atomic_notifier_call_chain(&gpio_vbus->phy.notifier, > @@ -196,7 +196,7 @@ static int gpio_vbus_set_peripheral(struct usb_otg *otg, > set_vbus_draw(gpio_vbus, 0); > > usb_gadget_vbus_disconnect(otg->gadget); > - otg->phy->state = OTG_STATE_UNDEFINED; > + otg->state = OTG_STATE_UNDEFINED; > > otg->gadget = NULL; > return 0; > @@ -218,7 +218,7 @@ static int gpio_vbus_set_power(struct usb_phy *phy, unsigned mA) > > gpio_vbus = container_of(phy, struct gpio_vbus_data, phy); > > - if (phy->state == OTG_STATE_B_PERIPHERAL) > + if (phy->otg->state == OTG_STATE_B_PERIPHERAL) > set_vbus_draw(gpio_vbus, mA); > return 0; > } > @@ -269,8 +269,8 @@ static int gpio_vbus_probe(struct platform_device *pdev) > gpio_vbus->phy.dev = gpio_vbus->dev; > gpio_vbus->phy.set_power = gpio_vbus_set_power; > gpio_vbus->phy.set_suspend = gpio_vbus_set_suspend; > - gpio_vbus->phy.state = OTG_STATE_UNDEFINED; > > + gpio_vbus->phy.otg->state = OTG_STATE_UNDEFINED; > gpio_vbus->phy.otg->phy = &gpio_vbus->phy; > gpio_vbus->phy.otg->set_peripheral = gpio_vbus_set_peripheral; > > diff --git a/drivers/usb/phy/phy-msm-usb.c b/drivers/usb/phy/phy-msm-usb.c > index 471e69d..18015b7 100644 > --- a/drivers/usb/phy/phy-msm-usb.c > +++ b/drivers/usb/phy/phy-msm-usb.c > @@ -721,11 +721,11 @@ static int msm_otg_set_host(struct usb_otg *otg, struct usb_bus *host) > } > > if (!host) { > - if (otg->phy->state == OTG_STATE_A_HOST) { > + if (otg->state == OTG_STATE_A_HOST) { > pm_runtime_get_sync(otg->phy->dev); > msm_otg_start_host(otg->phy, 0); > otg->host = NULL; > - otg->phy->state = OTG_STATE_UNDEFINED; > + otg->state = OTG_STATE_UNDEFINED; > schedule_work(&motg->sm_work); > } else { > otg->host = NULL; > @@ -794,11 +794,11 @@ static int msm_otg_set_peripheral(struct usb_otg *otg, > } > > if (!gadget) { > - if (otg->phy->state == OTG_STATE_B_PERIPHERAL) { > + if (otg->state == OTG_STATE_B_PERIPHERAL) { > pm_runtime_get_sync(otg->phy->dev); > msm_otg_start_peripheral(otg->phy, 0); > otg->gadget = NULL; > - otg->phy->state = OTG_STATE_UNDEFINED; > + otg->state = OTG_STATE_UNDEFINED; > schedule_work(&motg->sm_work); > } else { > otg->gadget = NULL; > @@ -1170,12 +1170,12 @@ static void msm_otg_sm_work(struct work_struct *w) > struct msm_otg *motg = container_of(w, struct msm_otg, sm_work); > struct usb_otg *otg = motg->phy.otg; > > - switch (otg->phy->state) { > + switch (otg->state) { > case OTG_STATE_UNDEFINED: > dev_dbg(otg->phy->dev, "OTG_STATE_UNDEFINED state\n"); > msm_otg_reset(otg->phy); > msm_otg_init_sm(motg); > - otg->phy->state = OTG_STATE_B_IDLE; > + otg->state = OTG_STATE_B_IDLE; > /* FALL THROUGH */ > case OTG_STATE_B_IDLE: > dev_dbg(otg->phy->dev, "OTG_STATE_B_IDLE state\n"); > @@ -1183,7 +1183,7 @@ static void msm_otg_sm_work(struct work_struct *w) > /* disable BSV bit */ > writel(readl(USB_OTGSC) & ~OTGSC_BSVIE, USB_OTGSC); > msm_otg_start_host(otg->phy, 1); > - otg->phy->state = OTG_STATE_A_HOST; > + otg->state = OTG_STATE_A_HOST; > } else if (test_bit(B_SESS_VLD, &motg->inputs)) { > switch (motg->chg_state) { > case USB_CHG_STATE_UNDEFINED: > @@ -1199,13 +1199,13 @@ static void msm_otg_sm_work(struct work_struct *w) > msm_otg_notify_charger(motg, > IDEV_CHG_MAX); > msm_otg_start_peripheral(otg->phy, 1); > - otg->phy->state > + otg->state > = OTG_STATE_B_PERIPHERAL; > break; > case USB_SDP_CHARGER: > msm_otg_notify_charger(motg, IUNIT); > msm_otg_start_peripheral(otg->phy, 1); > - otg->phy->state > + otg->state > = OTG_STATE_B_PERIPHERAL; > break; > default: > @@ -1230,7 +1230,7 @@ static void msm_otg_sm_work(struct work_struct *w) > motg->chg_type = USB_INVALID_CHARGER; > } > > - if (otg->phy->state == OTG_STATE_B_IDLE) > + if (otg->state == OTG_STATE_B_IDLE) > pm_runtime_put_sync(otg->phy->dev); > break; > case OTG_STATE_B_PERIPHERAL: > @@ -1241,7 +1241,7 @@ static void msm_otg_sm_work(struct work_struct *w) > msm_otg_start_peripheral(otg->phy, 0); > motg->chg_state = USB_CHG_STATE_UNDEFINED; > motg->chg_type = USB_INVALID_CHARGER; > - otg->phy->state = OTG_STATE_B_IDLE; > + otg->state = OTG_STATE_B_IDLE; > msm_otg_reset(otg->phy); > schedule_work(w); > } > @@ -1250,7 +1250,7 @@ static void msm_otg_sm_work(struct work_struct *w) > dev_dbg(otg->phy->dev, "OTG_STATE_A_HOST state\n"); > if (test_bit(ID, &motg->inputs)) { > msm_otg_start_host(otg->phy, 0); > - otg->phy->state = OTG_STATE_B_IDLE; > + otg->state = OTG_STATE_B_IDLE; > msm_otg_reset(otg->phy); > schedule_work(w); > } > @@ -1303,7 +1303,7 @@ static int msm_otg_mode_show(struct seq_file *s, void *unused) > struct msm_otg *motg = s->private; > struct usb_otg *otg = motg->phy.otg; > > - switch (otg->phy->state) { > + switch (otg->state) { > case OTG_STATE_A_HOST: > seq_puts(s, "host\n"); > break; > @@ -1353,7 +1353,7 @@ static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf, > > switch (req_mode) { > case USB_DR_MODE_UNKNOWN: > - switch (otg->phy->state) { > + switch (otg->state) { > case OTG_STATE_A_HOST: > case OTG_STATE_B_PERIPHERAL: > set_bit(ID, &motg->inputs); > @@ -1364,7 +1364,7 @@ static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf, > } > break; > case USB_DR_MODE_PERIPHERAL: > - switch (otg->phy->state) { > + switch (otg->state) { > case OTG_STATE_B_IDLE: > case OTG_STATE_A_HOST: > set_bit(ID, &motg->inputs); > @@ -1375,7 +1375,7 @@ static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf, > } > break; > case USB_DR_MODE_HOST: > - switch (otg->phy->state) { > + switch (otg->state) { > case OTG_STATE_B_IDLE: > case OTG_STATE_B_PERIPHERAL: > clear_bit(ID, &motg->inputs); > @@ -1769,7 +1769,7 @@ static int msm_otg_runtime_idle(struct device *dev) > * This 1 sec delay also prevents entering into LPM immediately > * after asynchronous interrupt. > */ > - if (otg->phy->state != OTG_STATE_UNDEFINED) > + if (otg->state != OTG_STATE_UNDEFINED) > pm_schedule_suspend(dev, 1000); > > return -EAGAIN; > diff --git a/drivers/usb/phy/phy-mv-usb.c b/drivers/usb/phy/phy-mv-usb.c > index c9517d8..ee87aa7 100644 > --- a/drivers/usb/phy/phy-mv-usb.c > +++ b/drivers/usb/phy/phy-mv-usb.c > @@ -339,68 +339,68 @@ static void mv_otg_update_state(struct mv_otg *mvotg) > { > struct mv_otg_ctrl *otg_ctrl = &mvotg->otg_ctrl; > struct usb_phy *phy = &mvotg->phy; > - int old_state = phy->state; > + int old_state = mvotg->phy.otg->state; > > switch (old_state) { > case OTG_STATE_UNDEFINED: > - phy->state = OTG_STATE_B_IDLE; > + mvotg->phy.otg->state = OTG_STATE_B_IDLE; > /* FALL THROUGH */ > case OTG_STATE_B_IDLE: > if (otg_ctrl->id == 0) > - phy->state = OTG_STATE_A_IDLE; > + mvotg->phy.otg->state = OTG_STATE_A_IDLE; > else if (otg_ctrl->b_sess_vld) > - phy->state = OTG_STATE_B_PERIPHERAL; > + mvotg->phy.otg->state = OTG_STATE_B_PERIPHERAL; > break; > case OTG_STATE_B_PERIPHERAL: > if (!otg_ctrl->b_sess_vld || otg_ctrl->id == 0) > - phy->state = OTG_STATE_B_IDLE; > + mvotg->phy.otg->state = OTG_STATE_B_IDLE; > break; > case OTG_STATE_A_IDLE: > if (otg_ctrl->id) > - phy->state = OTG_STATE_B_IDLE; > + mvotg->phy.otg->state = OTG_STATE_B_IDLE; > else if (!(otg_ctrl->a_bus_drop) && > (otg_ctrl->a_bus_req || otg_ctrl->a_srp_det)) > - phy->state = OTG_STATE_A_WAIT_VRISE; > + mvotg->phy.otg->state = OTG_STATE_A_WAIT_VRISE; > break; > case OTG_STATE_A_WAIT_VRISE: > if (otg_ctrl->a_vbus_vld) > - phy->state = OTG_STATE_A_WAIT_BCON; > + mvotg->phy.otg->state = OTG_STATE_A_WAIT_BCON; > break; > case OTG_STATE_A_WAIT_BCON: > if (otg_ctrl->id || otg_ctrl->a_bus_drop > || otg_ctrl->a_wait_bcon_timeout) { > mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER); > mvotg->otg_ctrl.a_wait_bcon_timeout = 0; > - phy->state = OTG_STATE_A_WAIT_VFALL; > + mvotg->phy.otg->state = OTG_STATE_A_WAIT_VFALL; > otg_ctrl->a_bus_req = 0; > } else if (!otg_ctrl->a_vbus_vld) { > mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER); > mvotg->otg_ctrl.a_wait_bcon_timeout = 0; > - phy->state = OTG_STATE_A_VBUS_ERR; > + mvotg->phy.otg->state = OTG_STATE_A_VBUS_ERR; > } else if (otg_ctrl->b_conn) { > mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER); > mvotg->otg_ctrl.a_wait_bcon_timeout = 0; > - phy->state = OTG_STATE_A_HOST; > + mvotg->phy.otg->state = OTG_STATE_A_HOST; > } > break; > case OTG_STATE_A_HOST: > if (otg_ctrl->id || !otg_ctrl->b_conn > || otg_ctrl->a_bus_drop) > - phy->state = OTG_STATE_A_WAIT_BCON; > + mvotg->phy.otg->state = OTG_STATE_A_WAIT_BCON; > else if (!otg_ctrl->a_vbus_vld) > - phy->state = OTG_STATE_A_VBUS_ERR; > + mvotg->phy.otg->state = OTG_STATE_A_VBUS_ERR; > break; > case OTG_STATE_A_WAIT_VFALL: > if (otg_ctrl->id > || (!otg_ctrl->b_conn && otg_ctrl->a_sess_vld) > || otg_ctrl->a_bus_req) > - phy->state = OTG_STATE_A_IDLE; > + mvotg->phy.otg->state = OTG_STATE_A_IDLE; > break; > case OTG_STATE_A_VBUS_ERR: > if (otg_ctrl->id || otg_ctrl->a_clr_err > || otg_ctrl->a_bus_drop) { > otg_ctrl->a_clr_err = 0; > - phy->state = OTG_STATE_A_WAIT_VFALL; > + mvotg->phy.otg->state = OTG_STATE_A_WAIT_VFALL; > } > break; > default: > @@ -420,8 +420,8 @@ static void mv_otg_work(struct work_struct *work) > run: > /* work queue is single thread, or we need spin_lock to protect */ > phy = &mvotg->phy; > - otg = phy->otg; > - old_state = phy->state; > + otg = mvotg->phy.otg; > + old_state = otg->state; > > if (!mvotg->active) > return; > @@ -429,12 +429,12 @@ run: > mv_otg_update_inputs(mvotg); > mv_otg_update_state(mvotg); > > - if (old_state != phy->state) { > + if (old_state != mvotg->phy.otg->state) { > dev_info(&mvotg->pdev->dev, "change from state %s to %s\n", > state_string[old_state], > - state_string[phy->state]); > + state_string[mvotg->phy.otg->state]); > > - switch (phy->state) { > + switch (mvotg->phy.otg->state) { > case OTG_STATE_B_IDLE: > otg->default_a = 0; > if (old_state == OTG_STATE_B_PERIPHERAL) > @@ -545,8 +545,8 @@ set_a_bus_req(struct device *dev, struct device_attribute *attr, > return -1; > > /* We will use this interface to change to A device */ > - if (mvotg->phy.state != OTG_STATE_B_IDLE > - && mvotg->phy.state != OTG_STATE_A_IDLE) > + if (mvotg->phy.otg->state != OTG_STATE_B_IDLE > + && mvotg->phy.otg->state != OTG_STATE_A_IDLE) > return -1; > > /* The clock may disabled and we need to set irq for ID detected */ > @@ -715,9 +715,9 @@ static int mv_otg_probe(struct platform_device *pdev) > mvotg->phy.dev = &pdev->dev; > mvotg->phy.otg = otg; > mvotg->phy.label = driver_name; > - mvotg->phy.state = OTG_STATE_UNDEFINED; > > otg->phy = &mvotg->phy; > + otg->state = OTG_STATE_UNDEFINED; > otg->set_host = mv_otg_set_host; > otg->set_peripheral = mv_otg_set_peripheral; > otg->set_vbus = mv_otg_set_vbus; > diff --git a/drivers/usb/phy/phy-tahvo.c b/drivers/usb/phy/phy-tahvo.c > index cc61ee4..04ece53 100644 > --- a/drivers/usb/phy/phy-tahvo.c > +++ b/drivers/usb/phy/phy-tahvo.c > @@ -81,33 +81,33 @@ static void check_vbus_state(struct tahvo_usb *tu) > > reg = retu_read(rdev, TAHVO_REG_IDSR); > if (reg & TAHVO_STAT_VBUS) { > - switch (tu->phy.state) { > + switch (tu->phy.otg->state) { > case OTG_STATE_B_IDLE: > /* Enable the gadget driver */ > if (tu->phy.otg->gadget) > usb_gadget_vbus_connect(tu->phy.otg->gadget); > - tu->phy.state = OTG_STATE_B_PERIPHERAL; > + tu->phy.otg->state = OTG_STATE_B_PERIPHERAL; > break; > case OTG_STATE_A_IDLE: > /* > * Session is now valid assuming the USB hub is driving > * Vbus. > */ > - tu->phy.state = OTG_STATE_A_HOST; > + tu->phy.otg->state = OTG_STATE_A_HOST; > break; > default: > break; > } > dev_info(&tu->pt_dev->dev, "USB cable connected\n"); > } else { > - switch (tu->phy.state) { > + switch (tu->phy.otg->state) { > case OTG_STATE_B_PERIPHERAL: > if (tu->phy.otg->gadget) > usb_gadget_vbus_disconnect(tu->phy.otg->gadget); > - tu->phy.state = OTG_STATE_B_IDLE; > + tu->phy.otg->state = OTG_STATE_B_IDLE; > break; > case OTG_STATE_A_HOST: > - tu->phy.state = OTG_STATE_A_IDLE; > + tu->phy.otg->state = OTG_STATE_A_IDLE; > break; > default: > break; > @@ -132,14 +132,14 @@ static void tahvo_usb_become_host(struct tahvo_usb *tu) > /* Power up the transceiver in USB host mode */ > retu_write(rdev, TAHVO_REG_USBR, USBR_REGOUT | USBR_NSUSPEND | > USBR_MASTER_SW2 | USBR_MASTER_SW1); > - tu->phy.state = OTG_STATE_A_IDLE; > + tu->phy.otg->state = OTG_STATE_A_IDLE; > > check_vbus_state(tu); > } > > static void tahvo_usb_stop_host(struct tahvo_usb *tu) > { > - tu->phy.state = OTG_STATE_A_IDLE; > + tu->phy.otg->state = OTG_STATE_A_IDLE; > } > > static void tahvo_usb_become_peripheral(struct tahvo_usb *tu) > @@ -151,7 +151,7 @@ static void tahvo_usb_become_peripheral(struct tahvo_usb *tu) > /* Power up transceiver and set it in USB peripheral mode */ > retu_write(rdev, TAHVO_REG_USBR, USBR_SLAVE_CONTROL | USBR_REGOUT | > USBR_NSUSPEND | USBR_SLAVE_SW); > - tu->phy.state = OTG_STATE_B_IDLE; > + tu->phy.otg->state = OTG_STATE_B_IDLE; > > check_vbus_state(tu); > } > @@ -160,7 +160,7 @@ static void tahvo_usb_stop_peripheral(struct tahvo_usb *tu) > { > if (tu->phy.otg->gadget) > usb_gadget_vbus_disconnect(tu->phy.otg->gadget); > - tu->phy.state = OTG_STATE_B_IDLE; > + tu->phy.otg->state = OTG_STATE_B_IDLE; > } > > static void tahvo_usb_power_off(struct tahvo_usb *tu) > @@ -173,7 +173,7 @@ static void tahvo_usb_power_off(struct tahvo_usb *tu) > > /* Power off transceiver */ > retu_write(rdev, TAHVO_REG_USBR, 0); > - tu->phy.state = OTG_STATE_UNDEFINED; > + tu->phy.otg->state = OTG_STATE_UNDEFINED; > } > > static int tahvo_usb_set_suspend(struct usb_phy *dev, int suspend) > @@ -379,7 +379,7 @@ static int tahvo_usb_probe(struct platform_device *pdev) > /* Create OTG interface */ > tahvo_usb_power_off(tu); > tu->phy.dev = &pdev->dev; > - tu->phy.state = OTG_STATE_UNDEFINED; > + tu->phy.otg->state = OTG_STATE_UNDEFINED; > tu->phy.label = DRIVER_NAME; > tu->phy.set_suspend = tahvo_usb_set_suspend; > > diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h > index 154332b..33d3480 100644 > --- a/include/linux/usb/otg.h > +++ b/include/linux/usb/otg.h > @@ -18,6 +18,8 @@ struct usb_otg { > struct usb_bus *host; > struct usb_gadget *gadget; > > + enum usb_otg_state state; > + > /* bind/unbind the host controller */ > int (*set_host)(struct usb_otg *otg, struct usb_bus *host); > > diff --git a/include/linux/usb/phy.h b/include/linux/usb/phy.h > index 353053a..ac7d791 100644 > --- a/include/linux/usb/phy.h > +++ b/include/linux/usb/phy.h > @@ -77,7 +77,6 @@ struct usb_phy { > unsigned int flags; > > enum usb_phy_type type; > - enum usb_otg_state state; > enum usb_phy_events last_event; > > struct usb_otg *otg; > > > -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/