Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1758782AbaGOLcn (ORCPT ); Tue, 15 Jul 2014 07:32:43 -0400 Received: from mail-by2lp0244.outbound.protection.outlook.com ([207.46.163.244]:32536 "EHLO na01-by2-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1758493AbaGOLcj (ORCPT ); Tue, 15 Jul 2014 07:32:39 -0400 Date: Tue, 15 Jul 2014 19:27:38 +0800 From: Peter Chen To: Antoine =?iso-8859-1?Q?T=E9nart?= CC: , , , , , , , , , Subject: Re: [PATCH 1/4] usb: move the OTG state from the USB PHY to the OTG structure Message-ID: <20140715112735.GA6657@shlinux1.ap.freescale.net> References: <1404901036-27682-1-git-send-email-antoine.tenart@free-electrons.com> <1404901036-27682-2-git-send-email-antoine.tenart@free-electrons.com> MIME-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <1404901036-27682-2-git-send-email-antoine.tenart@free-electrons.com> User-Agent: Mutt/1.5.20 (2009-06-14) X-EOPAttributedMessage: 0 X-Forefront-Antispam-Report: CIP:192.88.158.2;CTRY:US;IPV:CAL;IPV:NLI;EFV:NLI;SFV:NSPM;SFS:(6009001)(24454002)(199002)(189002)(51704005)(54356999)(21056001)(69596002)(85306003)(102836001)(20776003)(86362001)(77982001)(105606002)(33656002)(19580395003)(92726001)(92566001)(83072002)(84676001)(68736004)(50986999)(46102001)(80022001)(44976005)(19580405001)(47776003)(64706001)(83506001)(83322001)(110136001)(26826002)(76176999)(575784001)(81542001)(107046002)(81342001)(4396001)(106466001)(76482001)(87936001)(81156004)(23756003)(104016003)(79102001)(31966008)(50466002)(95666004)(85852003)(74502001)(97736001)(74662001)(6806004)(99396002)(217873001)(559001)(579004)(569005);DIR:OUT;SFP:;SCL:1;SRVR:BLUPR03MB566;H:az84smr01.freescale.net;FPR:;MLV:ovrnspm;PTR:InfoDomainNonexistent;MX:1;LANG:en; X-Microsoft-Antispam: BCL:0;PCL:0;RULEID: X-Forefront-PRVS: 027367F73D Authentication-Results: spf=fail (sender IP is 192.88.158.2) smtp.mailfrom=Peter.Chen@freescale.com; X-OriginatorOrg: freescale.com Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Wed, Jul 09, 2014 at 12:17:13PM +0200, Antoine T?nart 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. > Really good job, with this patch, we can split otg from usb_phy easier next time. Acked-by: Peter Chen > Signed-off-by: Antoine T?nart > --- > drivers/phy/phy-omap-usb2.c | 8 +--- > drivers/usb/chipidea/debug.c | 3 +- > drivers/usb/chipidea/otg_fsm.c | 12 ++--- > drivers/usb/common/usb-otg-fsm.c | 8 ++-- > drivers/usb/host/ohci-omap.c | 2 +- > drivers/usb/musb/am35x.c | 28 +++++------ > drivers/usb/musb/blackfin.c | 18 +++---- > drivers/usb/musb/da8xx.c | 28 +++++------ > drivers/usb/musb/davinci.c | 18 +++---- > drivers/usb/musb/musb_core.c | 94 ++++++++++++++++++------------------- > drivers/usb/musb/musb_dsps.c | 26 +++++----- > drivers/usb/musb/musb_gadget.c | 36 +++++++------- > drivers/usb/musb/musb_host.c | 8 ++-- > drivers/usb/musb/musb_virthub.c | 22 ++++----- > drivers/usb/musb/omap2430.c | 30 ++++++------ > drivers/usb/musb/tusb6010.c | 40 ++++++++-------- > drivers/usb/musb/ux500.c | 10 ++-- > drivers/usb/phy/phy-ab8500-usb.c | 10 ++-- > drivers/usb/phy/phy-fsl-usb.c | 10 ++-- > drivers/usb/phy/phy-generic.c | 4 +- > drivers/usb/phy/phy-gpio-vbus-usb.c | 10 ++-- > drivers/usb/phy/phy-msm-usb.c | 34 +++++++------- > drivers/usb/phy/phy-mv-usb.c | 46 +++++++++--------- > include/linux/usb/otg.h | 2 + > include/linux/usb/phy.h | 1 - > 25 files changed, 252 insertions(+), 256 deletions(-) > > diff --git a/drivers/phy/phy-omap-usb2.c b/drivers/phy/phy-omap-usb2.c > index 7007c11fe07d..1f444f91ed7d 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 7cccab6ff308..9a9702773e43 100644 > --- a/drivers/usb/chipidea/debug.c > +++ b/drivers/usb/chipidea/debug.c > @@ -219,8 +219,7 @@ int ci_otg_show(struct seq_file *s, void *unused) > fsm = &ci->fsm; > > /* ------ 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 caaabc58021e..8cb2508a6b71 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 98e8340a5bb1..c6b35b77dab7 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 c923cafcaca7..61967405b56d 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->phy->otg); > > local_irq_save(flags); > - hcd->phy->state = OTG_STATE_A_SUSPEND; > + hcd->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 0a34dd859555..aef4a46399ce 100644 > --- a/drivers/usb/musb/am35x.c > +++ b/drivers/usb/musb/am35x.c > @@ -148,25 +148,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; > @@ -175,7 +175,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; > @@ -192,9 +192,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; > @@ -207,7 +207,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); > } > @@ -277,27 +277,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; > @@ -323,7 +323,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 d40d5f0b5528..a241a14e255f 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 058775e647ad..527c7fe60ece 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 de8492b06e46..c9b3fdb1bb8b 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 eff3c5cf84f4..b8296ff103a1 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)); > } > } > } > @@ -1631,7 +1631,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; > @@ -1676,7 +1676,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); > @@ -1744,8 +1744,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"); > } > } > @@ -1982,10 +1982,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 09529f94e72d..8e98d8eee3cf 100644 > --- a/drivers/usb/musb/musb_dsps.c > +++ b/drivers/usb/musb/musb_dsps.c > @@ -170,9 +170,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; > @@ -192,7 +192,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); > } > @@ -256,10 +256,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; > @@ -268,10 +268,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) > @@ -279,7 +279,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; > @@ -364,26 +364,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; > @@ -393,7 +393,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 d4aa779339f1..b811a5e9ce4f 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; > } > > @@ -1792,7 +1792,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; > @@ -1860,7 +1860,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); > @@ -1945,7 +1945,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, driver); > otg_set_peripheral(musb->xceiv->otg, NULL); > > @@ -1975,7 +1975,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: > @@ -1989,7 +1989,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)); > } > } > > @@ -2001,10 +2001,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; > @@ -2019,7 +2019,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)); > } > } > > @@ -2050,22 +2050,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; > @@ -2125,13 +2125,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 eb06291a40c8..3ccb4d83bcfa 100644 > --- a/drivers/usb/musb/musb_host.c > +++ b/drivers/usb/musb/musb_host.c > @@ -2462,7 +2462,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: > @@ -2472,7 +2472,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; > @@ -2480,7 +2480,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; > @@ -2677,7 +2677,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 e2d2d8c9891b..a133bd8c5dc7 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 d369bf1f3936..d1b08349f056 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; > @@ -179,7 +179,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); > } > @@ -191,7 +191,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); > @@ -200,7 +200,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)); > } > > @@ -265,7 +265,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); > @@ -279,7 +279,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 159ef4be1ef2..df4513e151a5 100644 > --- a/drivers/usb/musb/tusb6010.c > +++ b/drivers/usb/musb/tusb6010.c > @@ -414,13 +414,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: > @@ -473,9 +473,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; > @@ -492,7 +492,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); > } > @@ -523,7 +523,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; > @@ -536,16 +536,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; > @@ -553,7 +553,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); > } > > @@ -568,7 +568,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); > @@ -667,23 +667,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); > @@ -730,9 +730,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 > @@ -744,7 +744,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 f202e5088461..71231bcbd178 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 11ab2c45e462..2d5250143ce1 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 2b0f968d9325..a22f88fb8176 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 7594e5069ae5..280a3458ff6b 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 69462e09d014..a4e88a28199a 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 c929370cdaa6..4394397b1370 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); > @@ -1772,7 +1772,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 7d80c54f0ac6..d6b3c473f068 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 */ > @@ -717,9 +717,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/include/linux/usb/otg.h b/include/linux/usb/otg.h > index 154332b7c8c0..33d3480c9cda 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 353053a33f21..ac7d7913694f 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; > -- > 1.9.1 > -- Best Regards, Peter Chen -- 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/