[PATCHv9 02/19] usb: otg: Rename usb_otg and usb_xceiv to usb_phy

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Renames OTG_STATE_* to USB_PHY_STATE_*,
usb_xceiv_event to usb_phy_event and
otg_state_string() to usb_phy_state_string().

Signed-off-by: Heikki Krogerus <heikki.krogerus@xxxxxxxxxxxxxxx>
---
 drivers/power/pda_power.c       |    2 +-
 drivers/usb/host/ohci-omap.c    |    2 +-
 drivers/usb/musb/am35x.c        |   33 ++++---
 drivers/usb/musb/blackfin.c     |   22 ++--
 drivers/usb/musb/da8xx.c        |   33 ++++---
 drivers/usb/musb/davinci.c      |   20 ++--
 drivers/usb/musb/musb_core.c    |  151 ++++++++++++++++--------------
 drivers/usb/musb/musb_gadget.c  |   50 +++++-----
 drivers/usb/musb/musb_host.c    |    8 +-
 drivers/usb/musb/musb_virthub.c |   28 +++---
 drivers/usb/musb/omap2430.c     |   30 +++---
 drivers/usb/musb/tusb6010.c     |   60 ++++++------
 drivers/usb/otg/ab8500-usb.c    |   10 +-
 drivers/usb/otg/fsl_otg.c       |   16 ++--
 drivers/usb/otg/fsl_otg.h       |    2 +-
 drivers/usb/otg/gpio_vbus.c     |   10 +-
 drivers/usb/otg/isp1301_omap.c  |  198 ++++++++++++++++++++-------------------
 drivers/usb/otg/msm_otg.c       |   62 ++++++------
 drivers/usb/otg/mv_otg.c        |   76 ++++++++--------
 drivers/usb/otg/nop-usb-xceiv.c |    4 +-
 drivers/usb/otg/otg.c           |   30 +++---
 drivers/usb/otg/otg_fsm.c       |  152 +++++++++++++++---------------
 drivers/usb/otg/twl4030-usb.c   |   10 +-
 drivers/usb/otg/twl6030-usb.c   |    8 +-
 include/linux/usb/msm_hsusb.h   |    2 +-
 include/linux/usb/otg.h         |   42 ++++----
 26 files changed, 539 insertions(+), 522 deletions(-)

diff --git a/drivers/power/pda_power.c b/drivers/power/pda_power.c
index 8f817e6..60433b7 100644
--- a/drivers/power/pda_power.c
+++ b/drivers/power/pda_power.c
@@ -222,7 +222,7 @@ static void polling_timer_func(unsigned long unused)
 #ifdef CONFIG_USB_OTG_UTILS
 static int otg_is_usb_online(void)
 {
-	return (transceiver->state == OTG_STATE_B_PERIPHERAL);
+	return (transceiver->state == USB_PHY_STATE_B_PERIPHERAL);
 }
 #endif
 
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index e4b8782..96073bd 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -174,7 +174,7 @@ static void start_hnp(struct ohci_hcd *ohci)
 	otg_start_hnp(ohci->transceiver);
 
 	local_irq_save(flags);
-	ohci->transceiver->state = OTG_STATE_A_SUSPEND;
+	ohci->transceiver->state = USB_PHY_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 e233d2b..66457de 100644
--- a/drivers/usb/musb/am35x.c
+++ b/drivers/usb/musb/am35x.c
@@ -149,29 +149,29 @@ static void otg_timer(unsigned long _musb)
 	 */
 	devctl = musb_readb(mregs, MUSB_DEVCTL);
 	dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl,
-		otg_state_string(musb->xceiv->state));
+		usb_phy_state_string(musb->xceiv->state));
 
 	spin_lock_irqsave(&musb->lock, flags);
 	switch (musb->xceiv->state) {
-	case OTG_STATE_A_WAIT_BCON:
+	case USB_PHY_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->state = USB_PHY_STATE_B_IDLE;
 			MUSB_DEV_MODE(musb);
 		} else {
-			musb->xceiv->state = OTG_STATE_A_IDLE;
+			musb->xceiv->state = USB_PHY_STATE_A_IDLE;
 			MUSB_HST_MODE(musb);
 		}
 		break;
-	case OTG_STATE_A_WAIT_VFALL:
-		musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
+	case USB_PHY_STATE_A_WAIT_VFALL:
+		musb->xceiv->state = USB_PHY_STATE_A_WAIT_VRISE;
 		musb_writel(musb->ctrl_base, CORE_INTR_SRC_SET_REG,
 			    MUSB_INTR_VBUSERROR << AM35X_INTR_USB_SHIFT);
 		break;
-	case OTG_STATE_B_IDLE:
+	case USB_PHY_STATE_B_IDLE:
 		if (!is_peripheral_enabled(musb))
 			break;
 
@@ -179,7 +179,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->state = USB_PHY_STATE_A_IDLE;
 		break;
 	default:
 		break;
@@ -199,9 +199,10 @@ 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->state ==
+						USB_PHY_STATE_A_WAIT_BCON)) {
 		dev_dbg(musb->controller, "%s active, deleting timer\n",
-			otg_state_string(musb->xceiv->state));
+			usb_phy_state_string(musb->xceiv->state));
 		del_timer(&otg_workaround);
 		last_timer = jiffies;
 		return;
@@ -214,7 +215,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",
-		otg_state_string(musb->xceiv->state),
+		usb_phy_state_string(musb->xceiv->state),
 		jiffies_to_msecs(timeout - jiffies));
 	mod_timer(&otg_workaround, timeout);
 }
@@ -284,27 +285,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->state = USB_PHY_STATE_A_WAIT_VFALL;
 			mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
 			WARNING("VBUS error workaround (delay coming)\n");
 		} else if (is_host_enabled(musb) && drvvbus) {
 			MUSB_HST_MODE(musb);
 			musb->xceiv->default_a = 1;
-			musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
+			musb->xceiv->state = USB_PHY_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);
 			musb->xceiv->default_a = 0;
-			musb->xceiv->state = OTG_STATE_B_IDLE;
+			musb->xceiv->state = USB_PHY_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",
-				otg_state_string(musb->xceiv->state),
+				usb_phy_state_string(musb->xceiv->state),
 				err ? " ERROR" : "",
 				devctl);
 		ret = IRQ_HANDLED;
@@ -324,7 +325,7 @@ eoi:
 	}
 
 	/* Poll for ID change */
-	if (is_otg_enabled(musb) && musb->xceiv->state == OTG_STATE_B_IDLE)
+	if (is_otg_enabled(musb) && musb->xceiv->state == USB_PHY_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 fc8e9ed..2f3e0b0 100644
--- a/drivers/usb/musb/blackfin.c
+++ b/drivers/usb/musb/blackfin.c
@@ -183,8 +183,8 @@ static irqreturn_t blackfin_interrupt(int irq, void *__hci)
 	}
 
 	/* Start sampling ID pin, when plug is removed from MUSB */
-	if ((is_otg_enabled(musb) && (musb->xceiv->state == OTG_STATE_B_IDLE
-		|| musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) ||
+	if ((is_otg_enabled(musb) && (musb->xceiv->state == USB_PHY_STATE_B_IDLE
+		|| musb->xceiv->state == USB_PHY_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;
@@ -204,8 +204,8 @@ static void musb_conn_timer_handler(unsigned long _musb)
 
 	spin_lock_irqsave(&musb->lock, flags);
 	switch (musb->xceiv->state) {
-	case OTG_STATE_A_IDLE:
-	case OTG_STATE_A_WAIT_BCON:
+	case USB_PHY_STATE_A_IDLE:
+	case USB_PHY_STATE_A_WAIT_BCON:
 		/* Start a new session */
 		val = musb_readw(musb->mregs, MUSB_DEVCTL);
 		val &= ~MUSB_DEVCTL_SESSION;
@@ -217,7 +217,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->state = USB_PHY_STATE_A_WAIT_BCON;
 		} else {
 			gpio_set_value(musb->config->gpio_vrsel, 0);
 			/* Ignore VBUSERROR and SUSPEND IRQ */
@@ -228,13 +228,13 @@ static void musb_conn_timer_handler(unsigned long _musb)
 			val = MUSB_INTR_SUSPEND | MUSB_INTR_VBUSERROR;
 			musb_writeb(musb->mregs, MUSB_INTRUSB, val);
 			if (is_otg_enabled(musb))
-				musb->xceiv->state = OTG_STATE_B_IDLE;
+				musb->xceiv->state = USB_PHY_STATE_B_IDLE;
 			else
 				musb_writeb(musb->mregs, MUSB_POWER, MUSB_POWER_HSENAB);
 		}
 		mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
 		break;
-	case OTG_STATE_B_IDLE:
+	case USB_PHY_STATE_B_IDLE:
 
 		if (!is_peripheral_enabled(musb))
 			break;
@@ -248,7 +248,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->state = USB_PHY_STATE_A_WAIT_BCON;
 		} else {
 			gpio_set_value(musb->config->gpio_vrsel, 0);
 
@@ -283,13 +283,13 @@ static void musb_conn_timer_handler(unsigned long _musb)
 		break;
 	default:
 		dev_dbg(musb->controller, "%s state not handled\n",
-			otg_state_string(musb->xceiv->state));
+			usb_phy_state_string(musb->xceiv->state));
 		break;
 	}
 	spin_unlock_irqrestore(&musb->lock, flags);
 
 	dev_dbg(musb->controller, "state is %s\n",
-		otg_state_string(musb->xceiv->state));
+		usb_phy_state_string(musb->xceiv->state));
 }
 
 static void bfin_musb_enable(struct musb *musb)
@@ -313,7 +313,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",
-		otg_state_string(musb->xceiv->state),
+		usb_phy_state_string(musb->xceiv->state),
 		musb_readb(musb->mregs, MUSB_DEVCTL));
 }
 
diff --git a/drivers/usb/musb/da8xx.c b/drivers/usb/musb/da8xx.c
index 2613bfd..058e730 100644
--- a/drivers/usb/musb/da8xx.c
+++ b/drivers/usb/musb/da8xx.c
@@ -197,24 +197,24 @@ static void otg_timer(unsigned long _musb)
 	 */
 	devctl = musb_readb(mregs, MUSB_DEVCTL);
 	dev_dbg(musb->controller, "Poll devctl %02x (%s)\n", devctl,
-		otg_state_string(musb->xceiv->state));
+		usb_phy_state_string(musb->xceiv->state));
 
 	spin_lock_irqsave(&musb->lock, flags);
 	switch (musb->xceiv->state) {
-	case OTG_STATE_A_WAIT_BCON:
+	case USB_PHY_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->state = USB_PHY_STATE_B_IDLE;
 			MUSB_DEV_MODE(musb);
 		} else {
-			musb->xceiv->state = OTG_STATE_A_IDLE;
+			musb->xceiv->state = USB_PHY_STATE_A_IDLE;
 			MUSB_HST_MODE(musb);
 		}
 		break;
-	case OTG_STATE_A_WAIT_VFALL:
+	case USB_PHY_STATE_A_WAIT_VFALL:
 		/*
 		 * Wait till VBUS falls below SessionEnd (~0.2 V); the 1.3
 		 * RTL seems to mis-handle session "start" otherwise (or in
@@ -225,11 +225,11 @@ 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->state = USB_PHY_STATE_A_WAIT_VRISE;
 		musb_writel(musb->ctrl_base, DA8XX_USB_INTR_SRC_SET_REG,
 			    MUSB_INTR_VBUSERROR << DA8XX_INTR_USB_SHIFT);
 		break;
-	case OTG_STATE_B_IDLE:
+	case USB_PHY_STATE_B_IDLE:
 		if (!is_peripheral_enabled(musb))
 			break;
 
@@ -250,7 +250,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->state = USB_PHY_STATE_A_IDLE;
 		break;
 	default:
 		break;
@@ -270,9 +270,10 @@ 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->state ==
+						USB_PHY_STATE_A_WAIT_BCON)) {
 		dev_dbg(musb->controller, "%s active, deleting timer\n",
-			otg_state_string(musb->xceiv->state));
+			usb_phy_state_string(musb->xceiv->state));
 		del_timer(&otg_workaround);
 		last_timer = jiffies;
 		return;
@@ -285,7 +286,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",
-		otg_state_string(musb->xceiv->state),
+		usb_phy_state_string(musb->xceiv->state),
 		jiffies_to_msecs(timeout - jiffies));
 	mod_timer(&otg_workaround, timeout);
 }
@@ -346,26 +347,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->state = USB_PHY_STATE_A_WAIT_VFALL;
 			mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
 			WARNING("VBUS error workaround (delay coming)\n");
 		} else if (is_host_enabled(musb) && drvvbus) {
 			MUSB_HST_MODE(musb);
 			musb->xceiv->default_a = 1;
-			musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
+			musb->xceiv->state = USB_PHY_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);
 			musb->xceiv->default_a = 0;
-			musb->xceiv->state = OTG_STATE_B_IDLE;
+			musb->xceiv->state = USB_PHY_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",
-				otg_state_string(musb->xceiv->state),
+				usb_phy_state_string(musb->xceiv->state),
 				err ? " ERROR" : "",
 				devctl);
 		ret = IRQ_HANDLED;
@@ -380,7 +381,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 (is_otg_enabled(musb) && musb->xceiv->state == OTG_STATE_B_IDLE)
+	if (is_otg_enabled(musb) && musb->xceiv->state == USB_PHY_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 f9a3f62..e80466b 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -216,11 +216,11 @@ static void otg_timer(unsigned long _musb)
 	 */
 	devctl = musb_readb(mregs, MUSB_DEVCTL);
 	dev_dbg(musb->controller, "poll devctl %02x (%s)\n", devctl,
-		otg_state_string(musb->xceiv->state));
+		usb_phy_state_string(musb->xceiv->state));
 
 	spin_lock_irqsave(&musb->lock, flags);
 	switch (musb->xceiv->state) {
-	case OTG_STATE_A_WAIT_VFALL:
+	case USB_PHY_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
 		 * case "recover"), in routine "VBUS was valid by the time
@@ -230,11 +230,11 @@ 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->state = USB_PHY_STATE_A_WAIT_VRISE;
 		musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG,
 			MUSB_INTR_VBUSERROR << DAVINCI_USB_USBINT_SHIFT);
 		break;
-	case OTG_STATE_B_IDLE:
+	case USB_PHY_STATE_B_IDLE:
 		if (!is_peripheral_enabled(musb))
 			break;
 
@@ -255,7 +255,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->state = USB_PHY_STATE_A_IDLE;
 		break;
 	default:
 		break;
@@ -329,20 +329,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->state = USB_PHY_STATE_A_WAIT_VFALL;
 			mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
 			WARNING("VBUS error workaround (delay coming)\n");
 		} else if (is_host_enabled(musb) && drvvbus) {
 			MUSB_HST_MODE(musb);
 			musb->xceiv->default_a = 1;
-			musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
+			musb->xceiv->state = USB_PHY_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);
 			musb->xceiv->default_a = 0;
-			musb->xceiv->state = OTG_STATE_B_IDLE;
+			musb->xceiv->state = USB_PHY_STATE_B_IDLE;
 			portstate(musb->port1_status &= ~USB_PORT_STAT_POWER);
 		}
 
@@ -352,7 +352,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",
-				otg_state_string(musb->xceiv->state),
+				usb_phy_state_string(musb->xceiv->state),
 				err ? " ERROR" : "",
 				devctl);
 		retval = IRQ_HANDLED;
@@ -366,7 +366,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
 
 	/* poll for ID change */
 	if (is_otg_enabled(musb)
-			&& musb->xceiv->state == OTG_STATE_B_IDLE)
+			&& musb->xceiv->state == USB_PHY_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 e264959..39177f1 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -338,22 +338,22 @@ void musb_otg_timer_func(unsigned long data)
 
 	spin_lock_irqsave(&musb->lock, flags);
 	switch (musb->xceiv->state) {
-	case OTG_STATE_B_WAIT_ACON:
+	case USB_PHY_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->state = USB_PHY_STATE_B_PERIPHERAL;
 		musb->is_active = 0;
 		break;
-	case OTG_STATE_A_SUSPEND:
-	case OTG_STATE_A_WAIT_BCON:
+	case USB_PHY_STATE_A_SUSPEND:
+	case USB_PHY_STATE_A_WAIT_BCON:
 		dev_dbg(musb->controller, "HNP: %s timeout\n",
-			otg_state_string(musb->xceiv->state));
+			usb_phy_state_string(musb->xceiv->state));
 		musb_platform_set_vbus(musb, 0);
-		musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
+		musb->xceiv->state = USB_PHY_STATE_A_WAIT_VFALL;
 		break;
 	default:
 		dev_dbg(musb->controller, "HNP: Unhandled mode %s\n",
-			otg_state_string(musb->xceiv->state));
+			usb_phy_state_string(musb->xceiv->state));
 	}
 	musb->ignore_disconnect = 0;
 	spin_unlock_irqrestore(&musb->lock, flags);
@@ -368,18 +368,19 @@ void musb_hnp_stop(struct musb *musb)
 	void __iomem	*mbase = musb->mregs;
 	u8	reg;
 
-	dev_dbg(musb->controller, "HNP: stop from %s\n", otg_state_string(musb->xceiv->state));
+	dev_dbg(musb->controller, "HNP: stop from %s\n",
+			usb_phy_state_string(musb->xceiv->state));
 
 	switch (musb->xceiv->state) {
-	case OTG_STATE_A_PERIPHERAL:
+	case USB_PHY_STATE_A_PERIPHERAL:
 		musb_g_disconnect(musb);
 		dev_dbg(musb->controller, "HNP: back to %s\n",
-			otg_state_string(musb->xceiv->state));
+			usb_phy_state_string(musb->xceiv->state));
 		break;
-	case OTG_STATE_B_HOST:
+	case USB_PHY_STATE_B_HOST:
 		dev_dbg(musb->controller, "HNP: Disabling HR\n");
 		hcd->self.is_b_host = 0;
-		musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
+		musb->xceiv->state = USB_PHY_STATE_B_PERIPHERAL;
 		MUSB_DEV_MODE(musb);
 		reg = musb_readb(mbase, MUSB_POWER);
 		reg |= MUSB_POWER_SUSPENDM;
@@ -388,7 +389,7 @@ void musb_hnp_stop(struct musb *musb)
 		break;
 	default:
 		dev_dbg(musb->controller, "HNP: Stopping in unknown state %s\n",
-			otg_state_string(musb->xceiv->state));
+			usb_phy_state_string(musb->xceiv->state));
 	}
 
 	/*
@@ -425,13 +426,14 @@ 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", otg_state_string(musb->xceiv->state));
+		dev_dbg(musb->controller, "RESUME (%s)\n",
+				usb_phy_state_string(musb->xceiv->state));
 
 		if (devctl & MUSB_DEVCTL_HM) {
 			void __iomem *mbase = musb->mregs;
 
 			switch (musb->xceiv->state) {
-			case OTG_STATE_A_SUSPEND:
+			case USB_PHY_STATE_A_SUSPEND:
 				/* remote wakeup?  later, GetPortStatus
 				 * will stop RESUME signaling
 				 */
@@ -453,29 +455,30 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 				musb->rh_timer = jiffies
 						+ msecs_to_jiffies(20);
 
-				musb->xceiv->state = OTG_STATE_A_HOST;
+				musb->xceiv->state = USB_PHY_STATE_A_HOST;
 				musb->is_active = 1;
 				usb_hcd_resume_root_hub(musb_to_hcd(musb));
 				break;
-			case OTG_STATE_B_WAIT_ACON:
-				musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
+			case USB_PHY_STATE_B_WAIT_ACON:
+				musb->xceiv->state = USB_PHY_STATE_B_PERIPHERAL;
 				musb->is_active = 1;
 				MUSB_DEV_MODE(musb);
 				break;
 			default:
 				WARNING("bogus %s RESUME (%s)\n",
 					"host",
-					otg_state_string(musb->xceiv->state));
+					usb_phy_state_string(
+						musb->xceiv->state));
 			}
 		} else {
 			switch (musb->xceiv->state) {
-			case OTG_STATE_A_SUSPEND:
+			case USB_PHY_STATE_A_SUSPEND:
 				/* possibly DISCONNECT is upcoming */
-				musb->xceiv->state = OTG_STATE_A_HOST;
+				musb->xceiv->state = USB_PHY_STATE_A_HOST;
 				usb_hcd_resume_root_hub(musb_to_hcd(musb));
 				break;
-			case OTG_STATE_B_WAIT_ACON:
-			case OTG_STATE_B_PERIPHERAL:
+			case USB_PHY_STATE_B_WAIT_ACON:
+			case USB_PHY_STATE_B_PERIPHERAL:
 				/* disconnect while suspended?  we may
 				 * not get a disconnect irq...
 				 */
@@ -488,13 +491,14 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 				}
 				musb_g_resume(musb);
 				break;
-			case OTG_STATE_B_IDLE:
+			case USB_PHY_STATE_B_IDLE:
 				musb->int_usb &= ~MUSB_INTR_SUSPEND;
 				break;
 			default:
 				WARNING("bogus %s RESUME (%s)\n",
 					"peripheral",
-					otg_state_string(musb->xceiv->state));
+					usb_phy_state_string(
+						musb->xceiv->state));
 			}
 		}
 	}
@@ -510,7 +514,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 		}
 
 		dev_dbg(musb->controller, "SESSION_REQUEST (%s)\n",
-			otg_state_string(musb->xceiv->state));
+			usb_phy_state_string(musb->xceiv->state));
 
 		/* IRQ arrives from ID pin sense or (later, if VBUS power
 		 * is removed) SRP.  responses are time critical:
@@ -521,7 +525,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->state = USB_PHY_STATE_A_IDLE;
 		MUSB_HST_MODE(musb);
 		musb_platform_set_vbus(musb, 1);
 
@@ -548,15 +552,15 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 		 * make trouble here, keeping VBUS < 4.4V ?
 		 */
 		switch (musb->xceiv->state) {
-		case OTG_STATE_A_HOST:
+		case USB_PHY_STATE_A_HOST:
 			/* recovery is dicey once we've gotten past the
 			 * initial stages of enumeration, but if VBUS
 			 * stayed ok at the other end of the link, and
 			 * another reset is due (at least for high speed,
 			 * to redo the chirp etc), it might work OK...
 			 */
-		case OTG_STATE_A_WAIT_BCON:
-		case OTG_STATE_A_WAIT_VRISE:
+		case USB_PHY_STATE_A_WAIT_BCON:
+		case USB_PHY_STATE_A_WAIT_VRISE:
 			if (musb->vbuserr_retry) {
 				void __iomem *mbase = musb->mregs;
 
@@ -575,7 +579,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 		}
 
 		dev_dbg(musb->controller, "VBUS_ERROR in %s (%02x, %s), retry #%d, port1 %08x\n",
-				otg_state_string(musb->xceiv->state),
+				usb_phy_state_string(musb->xceiv->state),
 				devctl,
 				({ char *s;
 				switch (devctl & MUSB_DEVCTL_VBUS) {
@@ -600,11 +604,12 @@ 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 power %02x\n",
-			otg_state_string(musb->xceiv->state), devctl, power);
+			usb_phy_state_string(musb->xceiv->state), devctl,
+			power);
 		handled = IRQ_HANDLED;
 
 		switch (musb->xceiv->state) {
-		case OTG_STATE_A_PERIPHERAL:
+		case USB_PHY_STATE_A_PERIPHERAL:
 			/* We also come here if the cable is removed, since
 			 * this silicon doesn't report ID-no-longer-grounded.
 			 *
@@ -620,32 +625,32 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 						? : OTG_TIME_A_WAIT_BCON));
 
 			break;
-		case OTG_STATE_B_IDLE:
+		case USB_PHY_STATE_B_IDLE:
 			if (!musb->is_active)
 				break;
-		case OTG_STATE_B_PERIPHERAL:
+		case USB_PHY_STATE_B_PERIPHERAL:
 			musb_g_suspend(musb);
 			musb->is_active = is_otg_enabled(musb)
 					&& musb->xceiv->gadget->b_hnp_enable;
 			if (musb->is_active) {
-				musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
+				musb->xceiv->state = USB_PHY_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(
 							OTG_TIME_B_ASE0_BRST));
 			}
 			break;
-		case OTG_STATE_A_WAIT_BCON:
+		case USB_PHY_STATE_A_WAIT_BCON:
 			if (musb->a_wait_bcon != 0)
 				musb_platform_try_idle(musb, jiffies
 					+ msecs_to_jiffies(musb->a_wait_bcon));
 			break;
-		case OTG_STATE_A_HOST:
-			musb->xceiv->state = OTG_STATE_A_SUSPEND;
+		case USB_PHY_STATE_A_HOST:
+			musb->xceiv->state = USB_PHY_STATE_A_SUSPEND;
 			musb->is_active = is_otg_enabled(musb)
 					&& musb->xceiv->host->b_hnp_enable;
 			break;
-		case OTG_STATE_B_HOST:
+		case USB_PHY_STATE_B_HOST:
 			/* Transition to B_PERIPHERAL, see 6.8.2.6 p 44 */
 			dev_dbg(musb->controller, "REVISIT: SUSPEND as B_HOST\n");
 			break;
@@ -685,7 +690,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 
 		/* indicate new connection to OTG machine */
 		switch (musb->xceiv->state) {
-		case OTG_STATE_B_PERIPHERAL:
+		case USB_PHY_STATE_B_PERIPHERAL:
 			if (int_usb & MUSB_INTR_SUSPEND) {
 				dev_dbg(musb->controller, "HNP: SUSPEND+CONNECT, now b_host\n");
 				int_usb &= ~MUSB_INTR_SUSPEND;
@@ -693,10 +698,10 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 			} else
 				dev_dbg(musb->controller, "CONNECT as b_peripheral???\n");
 			break;
-		case OTG_STATE_B_WAIT_ACON:
+		case USB_PHY_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->state = USB_PHY_STATE_B_HOST;
 			hcd->self.is_b_host = 1;
 			musb->ignore_disconnect = 0;
 			del_timer(&musb->otg_timer);
@@ -704,7 +709,7 @@ b_host:
 		default:
 			if ((devctl & MUSB_DEVCTL_VBUS)
 					== (3 << MUSB_DEVCTL_VBUS_SHIFT)) {
-				musb->xceiv->state = OTG_STATE_A_HOST;
+				musb->xceiv->state = USB_PHY_STATE_A_HOST;
 				hcd->self.is_b_host = 0;
 			}
 			break;
@@ -718,25 +723,26 @@ b_host:
 			usb_hcd_resume_root_hub(hcd);
 
 		dev_dbg(musb->controller, "CONNECT (%s) devctl %02x\n",
-				otg_state_string(musb->xceiv->state), devctl);
+				usb_phy_state_string(musb->xceiv->state),
+				devctl);
 	}
 
 	if ((int_usb & MUSB_INTR_DISCONNECT) && !musb->ignore_disconnect) {
 		dev_dbg(musb->controller, "DISCONNECT (%s) as %s, devctl %02x\n",
-				otg_state_string(musb->xceiv->state),
+				usb_phy_state_string(musb->xceiv->state),
 				MUSB_MODE(musb), devctl);
 		handled = IRQ_HANDLED;
 
 		switch (musb->xceiv->state) {
-		case OTG_STATE_A_HOST:
-		case OTG_STATE_A_SUSPEND:
+		case USB_PHY_STATE_A_HOST:
+		case USB_PHY_STATE_A_SUSPEND:
 			usb_hcd_resume_root_hub(musb_to_hcd(musb));
 			musb_root_disconnect(musb);
 			if (musb->a_wait_bcon != 0 && is_otg_enabled(musb))
 				musb_platform_try_idle(musb, jiffies
 					+ msecs_to_jiffies(musb->a_wait_bcon));
 			break;
-		case OTG_STATE_B_HOST:
+		case USB_PHY_STATE_B_HOST:
 			/* REVISIT this behaves for "real disconnect"
 			 * cases; make sure the other transitions from
 			 * from B_HOST act right too.  The B_HOST code
@@ -744,23 +750,23 @@ b_host:
 			 */
 			musb_root_disconnect(musb);
 			musb_to_hcd(musb)->self.is_b_host = 0;
-			musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
+			musb->xceiv->state = USB_PHY_STATE_B_PERIPHERAL;
 			MUSB_DEV_MODE(musb);
 			musb_g_disconnect(musb);
 			break;
-		case OTG_STATE_A_PERIPHERAL:
+		case USB_PHY_STATE_A_PERIPHERAL:
 			musb_hnp_stop(musb);
 			musb_root_disconnect(musb);
 			/* FALLTHROUGH */
-		case OTG_STATE_B_WAIT_ACON:
+		case USB_PHY_STATE_B_WAIT_ACON:
 			/* FALLTHROUGH */
-		case OTG_STATE_B_PERIPHERAL:
-		case OTG_STATE_B_IDLE:
+		case USB_PHY_STATE_B_PERIPHERAL:
+		case USB_PHY_STATE_B_IDLE:
 			musb_g_disconnect(musb);
 			break;
 		default:
 			WARNING("unhandled DISCONNECT transition (%s)\n",
-				otg_state_string(musb->xceiv->state));
+				usb_phy_state_string(musb->xceiv->state));
 			break;
 		}
 	}
@@ -786,9 +792,9 @@ b_host:
 			}
 		} else if (is_peripheral_capable()) {
 			dev_dbg(musb->controller, "BUS RESET as %s\n",
-				otg_state_string(musb->xceiv->state));
+				usb_phy_state_string(musb->xceiv->state));
 			switch (musb->xceiv->state) {
-			case OTG_STATE_A_SUSPEND:
+			case USB_PHY_STATE_A_SUSPEND:
 				/* We need to ignore disconnect on suspend
 				 * otherwise tusb 2.0 won't reconnect after a
 				 * power cycle, which breaks otg compliance.
@@ -796,34 +802,37 @@ b_host:
 				musb->ignore_disconnect = 1;
 				musb_g_reset(musb);
 				/* FALLTHROUGH */
-			case OTG_STATE_A_WAIT_BCON:	/* OPT TD.4.7-900ms */
+			case USB_PHY_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",
-					otg_state_string(musb->xceiv->state),
+					usb_phy_state_string(
+						musb->xceiv->state),
 					TA_WAIT_BCON(musb));
 				mod_timer(&musb->otg_timer, jiffies
 					+ msecs_to_jiffies(TA_WAIT_BCON(musb)));
 				break;
-			case OTG_STATE_A_PERIPHERAL:
+			case USB_PHY_STATE_A_PERIPHERAL:
 				musb->ignore_disconnect = 0;
 				del_timer(&musb->otg_timer);
 				musb_g_reset(musb);
 				break;
-			case OTG_STATE_B_WAIT_ACON:
+			case USB_PHY_STATE_B_WAIT_ACON:
 				dev_dbg(musb->controller, "HNP: RESET (%s), to b_peripheral\n",
-					otg_state_string(musb->xceiv->state));
-				musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
+					usb_phy_state_string(
+						musb->xceiv->state));
+				musb->xceiv->state = USB_PHY_STATE_B_PERIPHERAL;
 				musb_g_reset(musb);
 				break;
-			case OTG_STATE_B_IDLE:
-				musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
+			case USB_PHY_STATE_B_IDLE:
+				musb->xceiv->state = USB_PHY_STATE_B_PERIPHERAL;
 				/* FALLTHROUGH */
-			case OTG_STATE_B_PERIPHERAL:
+			case USB_PHY_STATE_B_PERIPHERAL:
 				musb_g_reset(musb);
 				break;
 			default:
 				dev_dbg(musb->controller, "Unhandled BUS RESET as %s\n",
-					otg_state_string(musb->xceiv->state));
+					usb_phy_state_string(
+						musb->xceiv->state));
 			}
 		}
 	}
@@ -1649,7 +1658,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", otg_state_string(musb->xceiv->state));
+	ret = sprintf(buf, "%s\n", usb_phy_state_string(musb->xceiv->state));
 	spin_unlock_irqrestore(&musb->lock, flags);
 
 	return ret;
@@ -1694,7 +1703,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->state == USB_PHY_STATE_A_WAIT_BCON)
 		musb->is_active = 0;
 	musb_platform_try_idle(musb, jiffies + msecs_to_jiffies(val));
 	spin_unlock_irqrestore(&musb->lock, flags);
@@ -1985,7 +1994,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
 
 		MUSB_HST_MODE(musb);
 		musb->xceiv->default_a = 1;
-		musb->xceiv->state = OTG_STATE_A_IDLE;
+		musb->xceiv->state = USB_PHY_STATE_A_IDLE;
 
 		status = usb_add_hcd(musb_to_hcd(musb), -1, 0);
 
@@ -2000,7 +2009,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
 	} else /* peripheral is enabled */ {
 		MUSB_DEV_MODE(musb);
 		musb->xceiv->default_a = 0;
-		musb->xceiv->state = OTG_STATE_B_IDLE;
+		musb->xceiv->state = USB_PHY_STATE_B_IDLE;
 
 		status = musb_gadget_setup(musb);
 
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index ac3d2ee..09f6d20 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -1595,7 +1595,7 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget)
 	spin_lock_irqsave(&musb->lock, flags);
 
 	switch (musb->xceiv->state) {
-	case OTG_STATE_B_PERIPHERAL:
+	case USB_PHY_STATE_B_PERIPHERAL:
 		/* NOTE:  OTG state machine doesn't include B_SUSPENDED;
 		 * that's part of the standard usb 1.1 state machine, and
 		 * doesn't affect OTG transitions.
@@ -1603,7 +1603,7 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget)
 		if (musb->may_wakeup && musb->is_suspended)
 			break;
 		goto done;
-	case OTG_STATE_B_IDLE:
+	case USB_PHY_STATE_B_IDLE:
 		/* Start SRP ... OTG not required. */
 		devctl = musb_readb(mregs, MUSB_DEVCTL);
 		dev_dbg(musb->controller, "Sending SRP: devctl: %02x\n", devctl);
@@ -1635,7 +1635,7 @@ static int musb_gadget_wakeup(struct usb_gadget *gadget)
 		goto done;
 	default:
 		dev_dbg(musb->controller, "Unhandled wake: %s\n",
-			otg_state_string(musb->xceiv->state));
+			usb_phy_state_string(musb->xceiv->state));
 		goto done;
 	}
 
@@ -1915,7 +1915,7 @@ static int musb_gadget_start(struct usb_gadget *g,
 	musb->is_active = 1;
 
 	otg_set_peripheral(musb->xceiv, &musb->g);
-	musb->xceiv->state = OTG_STATE_B_IDLE;
+	musb->xceiv->state = USB_PHY_STATE_B_IDLE;
 
 	/*
 	 * FIXME this ignores the softconnect flag.  Drivers are
@@ -2026,7 +2026,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->state = USB_PHY_STATE_UNDEFINED;
 	stop_activity(musb, driver);
 	otg_set_peripheral(musb->xceiv, NULL);
 
@@ -2060,10 +2060,10 @@ void musb_g_resume(struct musb *musb)
 {
 	musb->is_suspended = 0;
 	switch (musb->xceiv->state) {
-	case OTG_STATE_B_IDLE:
+	case USB_PHY_STATE_B_IDLE:
 		break;
-	case OTG_STATE_B_WAIT_ACON:
-	case OTG_STATE_B_PERIPHERAL:
+	case USB_PHY_STATE_B_WAIT_ACON:
+	case USB_PHY_STATE_B_PERIPHERAL:
 		musb->is_active = 1;
 		if (musb->gadget_driver && musb->gadget_driver->resume) {
 			spin_unlock(&musb->lock);
@@ -2073,7 +2073,7 @@ void musb_g_resume(struct musb *musb)
 		break;
 	default:
 		WARNING("unhandled RESUME transition (%s)\n",
-				otg_state_string(musb->xceiv->state));
+				usb_phy_state_string(musb->xceiv->state));
 	}
 }
 
@@ -2086,11 +2086,11 @@ void musb_g_suspend(struct musb *musb)
 	dev_dbg(musb->controller, "devctl %02x\n", devctl);
 
 	switch (musb->xceiv->state) {
-	case OTG_STATE_B_IDLE:
+	case USB_PHY_STATE_B_IDLE:
 		if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS)
-			musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
+			musb->xceiv->state = USB_PHY_STATE_B_PERIPHERAL;
 		break;
-	case OTG_STATE_B_PERIPHERAL:
+	case USB_PHY_STATE_B_PERIPHERAL:
 		musb->is_suspended = 1;
 		if (musb->gadget_driver && musb->gadget_driver->suspend) {
 			spin_unlock(&musb->lock);
@@ -2103,7 +2103,7 @@ void musb_g_suspend(struct musb *musb)
 		 * A_PERIPHERAL may need care too
 		 */
 		WARNING("unhandled SUSPEND transition (%s)\n",
-				otg_state_string(musb->xceiv->state));
+				usb_phy_state_string(musb->xceiv->state));
 	}
 }
 
@@ -2137,21 +2137,21 @@ void musb_g_disconnect(struct musb *musb)
 	switch (musb->xceiv->state) {
 	default:
 		dev_dbg(musb->controller, "Unhandled disconnect %s, setting a_idle\n",
-			otg_state_string(musb->xceiv->state));
-		musb->xceiv->state = OTG_STATE_A_IDLE;
+			usb_phy_state_string(musb->xceiv->state));
+		musb->xceiv->state = USB_PHY_STATE_A_IDLE;
 		MUSB_HST_MODE(musb);
 		break;
-	case OTG_STATE_A_PERIPHERAL:
-		musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
+	case USB_PHY_STATE_A_PERIPHERAL:
+		musb->xceiv->state = USB_PHY_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;
+	case USB_PHY_STATE_B_WAIT_ACON:
+	case USB_PHY_STATE_B_HOST:
+	case USB_PHY_STATE_B_PERIPHERAL:
+	case USB_PHY_STATE_B_IDLE:
+		musb->xceiv->state = USB_PHY_STATE_B_IDLE;
 		break;
-	case OTG_STATE_B_SRP_INIT:
+	case USB_PHY_STATE_B_SRP_INIT:
 		break;
 	}
 
@@ -2205,10 +2205,10 @@ __acquires(musb->lock)
 	 * or else after HNP, as A-Device
 	 */
 	if (devctl & MUSB_DEVCTL_BDEVICE) {
-		musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
+		musb->xceiv->state = USB_PHY_STATE_B_PERIPHERAL;
 		musb->g.is_a_peripheral = 0;
 	} else if (is_otg_enabled(musb)) {
-		musb->xceiv->state = OTG_STATE_A_PERIPHERAL;
+		musb->xceiv->state = USB_PHY_STATE_A_PERIPHERAL;
 		musb->g.is_a_peripheral = 1;
 	} else
 		WARN_ON(1);
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index 60ddba8..a6e8cc6 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -2270,16 +2270,16 @@ static int musb_bus_suspend(struct usb_hcd *hcd)
 		return 0;
 
 	switch (musb->xceiv->state) {
-	case OTG_STATE_A_SUSPEND:
+	case USB_PHY_STATE_A_SUSPEND:
 		return 0;
-	case OTG_STATE_A_WAIT_VRISE:
+	case USB_PHY_STATE_A_WAIT_VRISE:
 		/* ID could be grounded even if there's no device
 		 * on the other end of the cable.  NOTE that the
 		 * A_WAIT_VRISE timers are messy with MUSB...
 		 */
 		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->state = USB_PHY_STATE_A_WAIT_BCON;
 		break;
 	default:
 		break;
@@ -2287,7 +2287,7 @@ static int musb_bus_suspend(struct usb_hcd *hcd)
 
 	if (musb->is_active) {
 		WARNING("trying to suspend as %s while active\n",
-				otg_state_string(musb->xceiv->state));
+				usb_phy_state_string(musb->xceiv->state));
 		return -EBUSY;
 	} else
 		return 0;
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
index e9f80ad..b36e704 100644
--- a/drivers/usb/musb/musb_virthub.c
+++ b/drivers/usb/musb/musb_virthub.c
@@ -78,8 +78,8 @@ static void musb_port_suspend(struct musb *musb, bool do_suspend)
 
 		musb->port1_status |= USB_PORT_STAT_SUSPEND;
 		switch (musb->xceiv->state) {
-		case OTG_STATE_A_HOST:
-			musb->xceiv->state = OTG_STATE_A_SUSPEND;
+		case USB_PHY_STATE_A_HOST:
+			musb->xceiv->state = USB_PHY_STATE_A_SUSPEND;
 			musb->is_active = is_otg_enabled(musb)
 					&& musb->xceiv->host->b_hnp_enable;
 			if (musb->is_active)
@@ -88,15 +88,15 @@ static void musb_port_suspend(struct musb *musb, bool do_suspend)
 						OTG_TIME_A_AIDL_BDIS));
 			musb_platform_try_idle(musb, 0);
 			break;
-		case OTG_STATE_B_HOST:
-			musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
+		case USB_PHY_STATE_B_HOST:
+			musb->xceiv->state = USB_PHY_STATE_B_WAIT_ACON;
 			musb->is_active = is_otg_enabled(musb)
 					&& musb->xceiv->host->b_hnp_enable;
 			musb_platform_try_idle(musb, 0);
 			break;
 		default:
 			dev_dbg(musb->controller, "bogus rh suspend? %s\n",
-				otg_state_string(musb->xceiv->state));
+				usb_phy_state_string(musb->xceiv->state));
 		}
 	} else if (power & MUSB_POWER_SUSPENDM) {
 		power &= ~MUSB_POWER_SUSPENDM;
@@ -116,7 +116,7 @@ static 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->state == USB_PHY_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;
@@ -186,24 +186,24 @@ void musb_root_disconnect(struct musb *musb)
 	musb->is_active = 0;
 
 	switch (musb->xceiv->state) {
-	case OTG_STATE_A_SUSPEND:
+	case USB_PHY_STATE_A_SUSPEND:
 		if (is_otg_enabled(musb)
 				&& musb->xceiv->host->b_hnp_enable) {
-			musb->xceiv->state = OTG_STATE_A_PERIPHERAL;
+			musb->xceiv->state = USB_PHY_STATE_A_PERIPHERAL;
 			musb->g.is_a_peripheral = 1;
 			break;
 		}
 		/* FALLTHROUGH */
-	case OTG_STATE_A_HOST:
-		musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
+	case USB_PHY_STATE_A_HOST:
+		musb->xceiv->state = USB_PHY_STATE_A_WAIT_BCON;
 		musb->is_active = 0;
 		break;
-	case OTG_STATE_A_WAIT_VFALL:
-		musb->xceiv->state = OTG_STATE_B_IDLE;
+	case USB_PHY_STATE_A_WAIT_VFALL:
+		musb->xceiv->state = USB_PHY_STATE_B_IDLE;
 		break;
 	default:
 		dev_dbg(musb->controller, "host disconnect (%s)\n",
-			otg_state_string(musb->xceiv->state));
+			usb_phy_state_string(musb->xceiv->state));
 	}
 }
 
@@ -339,7 +339,7 @@ int musb_hub_control(
 			musb->port1_status |= USB_PORT_STAT_C_SUSPEND << 16;
 			usb_hcd_poll_rh_status(musb_to_hcd(musb));
 			/* NOTE: it might really be A_WAIT_BCON ... */
-			musb->xceiv->state = OTG_STATE_A_HOST;
+			musb->xceiv->state = USB_PHY_STATE_A_HOST;
 		}
 
 		put_unaligned(cpu_to_le32(musb->port1_status
diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c
index c27bbbf..92745ff 100644
--- a/drivers/usb/musb/omap2430.c
+++ b/drivers/usb/musb/omap2430.c
@@ -56,18 +56,18 @@ static void musb_do_idle(unsigned long _musb)
 	spin_lock_irqsave(&musb->lock, flags);
 
 	switch (musb->xceiv->state) {
-	case OTG_STATE_A_WAIT_BCON:
+	case USB_PHY_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->state = USB_PHY_STATE_B_IDLE;
 			MUSB_DEV_MODE(musb);
 		} else {
-			musb->xceiv->state = OTG_STATE_A_IDLE;
+			musb->xceiv->state = USB_PHY_STATE_A_IDLE;
 			MUSB_HST_MODE(musb);
 		}
 		break;
-	case OTG_STATE_A_SUSPEND:
+	case USB_PHY_STATE_A_SUSPEND:
 		/* finish RESUME signaling? */
 		if (musb->port1_status & MUSB_PORT_STAT_RESUME) {
 			power = musb_readb(musb->mregs, MUSB_POWER);
@@ -80,15 +80,15 @@ static void musb_do_idle(unsigned long _musb)
 			musb->port1_status |= USB_PORT_STAT_C_SUSPEND << 16;
 			usb_hcd_poll_rh_status(musb_to_hcd(musb));
 			/* NOTE: it might really be A_WAIT_BCON ... */
-			musb->xceiv->state = OTG_STATE_A_HOST;
+			musb->xceiv->state = USB_PHY_STATE_A_HOST;
 		}
 		break;
-	case OTG_STATE_A_HOST:
+	case USB_PHY_STATE_A_HOST:
 		devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 		if (devctl &  MUSB_DEVCTL_BDEVICE)
-			musb->xceiv->state = OTG_STATE_B_IDLE;
+			musb->xceiv->state = USB_PHY_STATE_B_IDLE;
 		else
-			musb->xceiv->state = OTG_STATE_A_WAIT_BCON;
+			musb->xceiv->state = USB_PHY_STATE_A_WAIT_BCON;
 	default:
 		break;
 	}
@@ -106,9 +106,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->state == USB_PHY_STATE_A_WAIT_BCON))) {
 		dev_dbg(musb->controller, "%s active, deleting timer\n",
-			otg_state_string(musb->xceiv->state));
+			usb_phy_state_string(musb->xceiv->state));
 		del_timer(&musb_idle_timer);
 		last_timer = jiffies;
 		return;
@@ -125,7 +125,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",
-		otg_state_string(musb->xceiv->state),
+		usb_phy_state_string(musb->xceiv->state),
 		(unsigned long)jiffies_to_msecs(timeout - jiffies));
 	mod_timer(&musb_idle_timer, timeout);
 }
@@ -143,7 +143,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->state == USB_PHY_STATE_A_IDLE) {
 			/* start the session */
 			devctl |= MUSB_DEVCTL_SESSION;
 			musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
@@ -168,7 +168,7 @@ static void omap2430_musb_set_vbus(struct musb *musb, int is_on)
 		} else {
 			musb->is_active = 1;
 			musb->xceiv->default_a = 1;
-			musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
+			musb->xceiv->state = USB_PHY_STATE_A_WAIT_VRISE;
 			devctl |= MUSB_DEVCTL_SESSION;
 			MUSB_HST_MODE(musb);
 		}
@@ -180,7 +180,7 @@ static void omap2430_musb_set_vbus(struct musb *musb, int is_on)
 		 */
 
 		musb->xceiv->default_a = 0;
-		musb->xceiv->state = OTG_STATE_B_IDLE;
+		musb->xceiv->state = USB_PHY_STATE_B_IDLE;
 		devctl &= ~MUSB_DEVCTL_SESSION;
 
 		MUSB_DEV_MODE(musb);
@@ -189,7 +189,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",
-		otg_state_string(musb->xceiv->state),
+		usb_phy_state_string(musb->xceiv->state),
 		musb_readb(musb->mregs, MUSB_DEVCTL));
 }
 
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index 5ce01bd..a370768 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -415,15 +415,15 @@ static void musb_do_idle(unsigned long _musb)
 	spin_lock_irqsave(&musb->lock, flags);
 
 	switch (musb->xceiv->state) {
-	case OTG_STATE_A_WAIT_BCON:
+	case USB_PHY_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",
-					otg_state_string(musb->xceiv->state));
+				usb_phy_state_string(musb->xceiv->state));
 		}
 		/* FALLTHROUGH */
-	case OTG_STATE_A_IDLE:
+	case USB_PHY_STATE_A_IDLE:
 		tusb_musb_set_vbus(musb, 0);
 	default:
 		break;
@@ -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->state == USB_PHY_STATE_A_WAIT_BCON))) {
 		dev_dbg(musb->controller, "%s active, deleting timer\n",
-			otg_state_string(musb->xceiv->state));
+			usb_phy_state_string(musb->xceiv->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",
-		otg_state_string(musb->xceiv->state),
+		usb_phy_state_string(musb->xceiv->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);
 		musb->xceiv->default_a = 1;
-		musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
+		musb->xceiv->state = USB_PHY_STATE_A_WAIT_VRISE;
 		devctl |= MUSB_DEVCTL_SESSION;
 
 		conf |= TUSB_DEV_CONF_USB_HOST_MODE;
@@ -537,15 +537,15 @@ static void tusb_musb_set_vbus(struct musb *musb, int is_on)
 		otg_stat = musb_readl(tbase, TUSB_DEV_OTG_STAT);
 		if (!(otg_stat & TUSB_DEV_OTG_STAT_ID_STATUS)) {
 			switch (musb->xceiv->state) {
-			case OTG_STATE_A_WAIT_VRISE:
-			case OTG_STATE_A_WAIT_BCON:
-				musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
+			case USB_PHY_STATE_A_WAIT_VRISE:
+			case USB_PHY_STATE_A_WAIT_BCON:
+				musb->xceiv->state = USB_PHY_STATE_A_WAIT_VFALL;
 				break;
-			case OTG_STATE_A_WAIT_VFALL:
-				musb->xceiv->state = OTG_STATE_A_IDLE;
+			case USB_PHY_STATE_A_WAIT_VFALL:
+				musb->xceiv->state = USB_PHY_STATE_A_IDLE;
 				break;
 			default:
-				musb->xceiv->state = OTG_STATE_A_IDLE;
+				musb->xceiv->state = USB_PHY_STATE_A_IDLE;
 			}
 			musb->is_active = 0;
 			musb->xceiv->default_a = 1;
@@ -553,7 +553,7 @@ static void tusb_musb_set_vbus(struct musb *musb, int is_on)
 		} else {
 			musb->is_active = 0;
 			musb->xceiv->default_a = 0;
-			musb->xceiv->state = OTG_STATE_B_IDLE;
+			musb->xceiv->state = USB_PHY_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",
-		otg_state_string(musb->xceiv->state),
+		usb_phy_state_string(musb->xceiv->state),
 		musb_readb(musb->mregs, MUSB_DEVCTL),
 		musb_readl(tbase, TUSB_DEV_OTG_STAT),
 		conf, prcm);
@@ -679,24 +679,28 @@ 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->state !=
+						USB_PHY_STATE_B_IDLE) {
 					/* INTR_DISCONNECT can hide... */
-					musb->xceiv->state = OTG_STATE_B_IDLE;
+					musb->xceiv->state =
+						USB_PHY_STATE_B_IDLE;
 					musb->int_usb |= MUSB_INTR_DISCONNECT;
 				}
 				musb->is_active = 0;
 			}
 			dev_dbg(musb->controller, "vbus change, %s, otg %03x\n",
-				otg_state_string(musb->xceiv->state), otg_stat);
+				usb_phy_state_string(musb->xceiv->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",
-				otg_state_string(musb->xceiv->state), otg_stat);
+				usb_phy_state_string(musb->xceiv->state),
+				otg_stat);
 
 			switch (musb->xceiv->state) {
-			case OTG_STATE_A_IDLE:
+			case USB_PHY_STATE_A_IDLE:
 				dev_dbg(musb->controller, "Got SRP, turning on VBUS\n");
 				musb_platform_set_vbus(musb, 1);
 
@@ -713,12 +717,12 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
 				idle_timeout = jiffies + (2 * HZ);
 
 				break;
-			case OTG_STATE_A_WAIT_VRISE:
+			case USB_PHY_STATE_A_WAIT_VRISE:
 				/* ignore; A-session-valid < VBUS_VALID/2,
 				 * we monitor this with the timer
 				 */
 				break;
-			case OTG_STATE_A_WAIT_VFALL:
+			case USB_PHY_STATE_A_WAIT_VFALL:
 				/* REVISIT this irq triggers during short
 				 * spikes caused by enumeration ...
 				 */
@@ -742,10 +746,10 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
 		u8	devctl;
 
 		dev_dbg(musb->controller, "%s timer, %03x\n",
-			otg_state_string(musb->xceiv->state), otg_stat);
+			usb_phy_state_string(musb->xceiv->state), otg_stat);
 
 		switch (musb->xceiv->state) {
-		case OTG_STATE_A_WAIT_VRISE:
+		case USB_PHY_STATE_A_WAIT_VRISE:
 			/* VBUS has probably been valid for a while now,
 			 * but may well have bounced out of range a bit
 			 */
@@ -756,7 +760,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->state = USB_PHY_STATE_A_WAIT_BCON;
 				musb->is_active = 0;
 				idle_timeout = jiffies
 					+ msecs_to_jiffies(musb->a_wait_bcon);
@@ -766,14 +770,14 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
 				tusb_musb_set_vbus(musb, 0);
 			}
 			break;
-		case OTG_STATE_A_WAIT_BCON:
+		case USB_PHY_STATE_A_WAIT_BCON:
 			if (musb->a_wait_bcon != 0)
 				idle_timeout = jiffies
 					+ msecs_to_jiffies(musb->a_wait_bcon);
 			break;
-		case OTG_STATE_A_SUSPEND:
+		case USB_PHY_STATE_A_SUSPEND:
 			break;
-		case OTG_STATE_B_WAIT_ACON:
+		case USB_PHY_STATE_B_WAIT_ACON:
 			break;
 		default:
 			break;
diff --git a/drivers/usb/otg/ab8500-usb.c b/drivers/usb/otg/ab8500-usb.c
index 99a56af..366c3af 100644
--- a/drivers/usb/otg/ab8500-usb.c
+++ b/drivers/usb/otg/ab8500-usb.c
@@ -153,7 +153,7 @@ static int ab8500_usb_link_status_update(struct ab8500_usb *ab)
 	u8 reg;
 	enum ab8500_usb_link_status lsts;
 	void *v = NULL;
-	enum usb_xceiv_events event;
+	enum usb_phy_events event;
 
 	abx500_get_register_interruptible(ab->dev,
 			AB8500_USB,
@@ -169,7 +169,7 @@ static int ab8500_usb_link_status_update(struct ab8500_usb *ab)
 		/* TODO: Disable regulators. */
 		ab8500_usb_host_phy_dis(ab);
 		ab8500_usb_peri_phy_dis(ab);
-		ab->otg.state = OTG_STATE_B_IDLE;
+		ab->otg.state = USB_PHY_STATE_B_IDLE;
 		ab->otg.default_a = false;
 		ab->vbus_draw = 0;
 		event = USB_EVENT_NONE;
@@ -195,7 +195,7 @@ static int ab8500_usb_link_status_update(struct ab8500_usb *ab)
 			ab8500_usb_host_phy_en(ab);
 			v = ab->otg.host;
 		}
-		ab->otg.state = OTG_STATE_A_IDLE;
+		ab->otg.state = USB_PHY_STATE_A_IDLE;
 		ab->otg.default_a = true;
 		event = USB_EVENT_ID;
 		break;
@@ -317,7 +317,7 @@ static int ab8500_usb_set_peripheral(struct usb_phy *otg,
 		schedule_work(&ab->phy_dis_work);
 	} else {
 		ab->otg.gadget = gadget;
-		ab->otg.state = OTG_STATE_B_IDLE;
+		ab->otg.state = USB_PHY_STATE_B_IDLE;
 
 		/* Phy will not be enabled if cable is already
 		 * plugged-in. Schedule to enable phy.
@@ -492,7 +492,7 @@ static int __devinit ab8500_usb_probe(struct platform_device *pdev)
 	ab->rev			= rev;
 	ab->otg.dev		= ab->dev;
 	ab->otg.label		= "ab8500";
-	ab->otg.state		= OTG_STATE_UNDEFINED;
+	ab->otg.state		= USB_PHY_STATE_UNDEFINED;
 	ab->otg.set_host	= ab8500_usb_set_host;
 	ab->otg.set_peripheral	= ab8500_usb_set_peripheral;
 	ab->otg.set_suspend	= ab8500_usb_set_suspend;
diff --git a/drivers/usb/otg/fsl_otg.c b/drivers/usb/otg/fsl_otg.c
index 2f0678d..76125f7 100644
--- a/drivers/usb/otg/fsl_otg.c
+++ b/drivers/usb/otg/fsl_otg.c
@@ -275,7 +275,7 @@ void b_srp_end(unsigned long foo)
 	fsl_otg_dischrg_vbus(0);
 	srp_wait_done = 1;
 
-	if ((fsl_otg_dev->otg.state == OTG_STATE_B_SRP_INIT) &&
+	if ((fsl_otg_dev->otg.state == USB_PHY_STATE_B_SRP_INIT) &&
 	    fsl_otg_dev->fsm.b_sess_vld)
 		fsl_otg_dev->fsm.b_srp_done = 1;
 }
@@ -574,7 +574,7 @@ static int fsl_otg_set_host(struct usb_phy *otg_p, struct usb_bus *host)
 			/* Mini-A cable connected */
 			struct otg_fsm *fsm = &otg_dev->fsm;
 
-			otg_p->state = OTG_STATE_UNDEFINED;
+			otg_p->state = USB_PHY_STATE_UNDEFINED;
 			fsm->protocol = PROTO_UNDEF;
 		}
 	}
@@ -629,7 +629,7 @@ static int fsl_otg_set_power(struct usb_phy *otg_p, unsigned mA)
 {
 	if (!fsl_otg_dev)
 		return -ENODEV;
-	if (otg_p->state == OTG_STATE_B_PERIPHERAL)
+	if (otg_p->state == USB_PHY_STATE_B_PERIPHERAL)
 		pr_info("FSL OTG: Draw %d mA\n", mA);
 
 	return 0;
@@ -663,7 +663,7 @@ static int fsl_otg_start_srp(struct usb_phy *otg_p)
 	struct fsl_otg *otg_dev = container_of(otg_p, struct fsl_otg, otg);
 
 	if (!otg_p || otg_dev != fsl_otg_dev
-	    || otg_p->state != OTG_STATE_B_IDLE)
+	    || otg_p->state != USB_PHY_STATE_B_IDLE)
 		return -ENODEV;
 
 	otg_dev->fsm.b_bus_req = 1;
@@ -826,7 +826,7 @@ int usb_otg_start(struct platform_device *pdev)
 	fsm = &p_otg->fsm;
 
 	/* Initialize the state machine structure with default values */
-	SET_OTG_STATE(otg_trans, OTG_STATE_UNDEFINED);
+	SET_OTG_STATE(otg_trans, USB_PHY_STATE_UNDEFINED);
 	fsm->transceiver = &p_otg->otg;
 
 	/* We don't require predefined MEM/IRQ resource index */
@@ -919,10 +919,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->otg.state = OTG_STATE_UNDEFINED;
+		p_otg->otg.state = USB_PHY_STATE_UNDEFINED;
 		p_otg->fsm.id = 1;
 	} else {
-		p_otg->otg.state = OTG_STATE_A_IDLE;
+		p_otg->otg.state = USB_PHY_STATE_A_IDLE;
 		p_otg->fsm.id = 0;
 	}
 
@@ -978,7 +978,7 @@ static int show_fsl_usb2_otg_state(struct device *dev,
 	/* State */
 	t = scnprintf(next, size,
 		      "OTG state: %s\n\n",
-		      otg_state_string(fsl_otg_dev->otg.state));
+		      usb_phy_state_string(fsl_otg_dev->otg.state));
 	size -= t;
 	next += t;
 
diff --git a/drivers/usb/otg/fsl_otg.h b/drivers/usb/otg/fsl_otg.h
index caec254..33f3997 100644
--- a/drivers/usb/otg/fsl_otg.h
+++ b/drivers/usb/otg/fsl_otg.h
@@ -250,7 +250,7 @@
 /* Wait for B-Connect */
 #define TA_WAIT_BCON	(10000)  /* a_wait_bcon > 1 sec, section: 6.6.5.2
 				  * This is only used to get out of
-				  * OTG_STATE_A_WAIT_BCON state if there was
+				  * USB_PHY_STATE_A_WAIT_BCON state if there was
 				  * no connection for these many milliseconds
 				  */
 
diff --git a/drivers/usb/otg/gpio_vbus.c b/drivers/usb/otg/gpio_vbus.c
index 4e1b138..00171c3 100644
--- a/drivers/usb/otg/gpio_vbus.c
+++ b/drivers/usb/otg/gpio_vbus.c
@@ -108,7 +108,7 @@ static void gpio_vbus_work(struct work_struct *work)
 	 */
 	gpio = pdata->gpio_pullup;
 	if (is_vbus_powered(pdata)) {
-		gpio_vbus->otg.state = OTG_STATE_B_PERIPHERAL;
+		gpio_vbus->otg.state = USB_PHY_STATE_B_PERIPHERAL;
 		usb_gadget_vbus_connect(gpio_vbus->otg.gadget);
 
 		/* drawing a "unit load" is *always* OK, except for OTG */
@@ -125,7 +125,7 @@ static void gpio_vbus_work(struct work_struct *work)
 		set_vbus_draw(gpio_vbus, 0);
 
 		usb_gadget_vbus_disconnect(gpio_vbus->otg.gadget);
-		gpio_vbus->otg.state = OTG_STATE_B_IDLE;
+		gpio_vbus->otg.state = USB_PHY_STATE_B_IDLE;
 	}
 }
 
@@ -174,7 +174,7 @@ static int gpio_vbus_set_peripheral(struct usb_phy *otg,
 		set_vbus_draw(gpio_vbus, 0);
 
 		usb_gadget_vbus_disconnect(otg->gadget);
-		otg->state = OTG_STATE_UNDEFINED;
+		otg->state = USB_PHY_STATE_UNDEFINED;
 
 		otg->gadget = NULL;
 		return 0;
@@ -195,7 +195,7 @@ static int gpio_vbus_set_power(struct usb_phy *otg, unsigned mA)
 
 	gpio_vbus = container_of(otg, struct gpio_vbus_data, otg);
 
-	if (otg->state == OTG_STATE_B_PERIPHERAL)
+	if (otg->state == USB_PHY_STATE_B_PERIPHERAL)
 		set_vbus_draw(gpio_vbus, mA);
 	return 0;
 }
@@ -236,7 +236,7 @@ static int __init gpio_vbus_probe(struct platform_device *pdev)
 	platform_set_drvdata(pdev, gpio_vbus);
 	gpio_vbus->dev = &pdev->dev;
 	gpio_vbus->otg.label = "gpio-vbus";
-	gpio_vbus->otg.state = OTG_STATE_UNDEFINED;
+	gpio_vbus->otg.state = USB_PHY_STATE_UNDEFINED;
 	gpio_vbus->otg.set_peripheral = gpio_vbus_set_peripheral;
 	gpio_vbus->otg.set_power = gpio_vbus_set_power;
 	gpio_vbus->otg.set_suspend = gpio_vbus_set_suspend;
diff --git a/drivers/usb/otg/isp1301_omap.c b/drivers/usb/otg/isp1301_omap.c
index 1bc2794..c9a9441 100644
--- a/drivers/usb/otg/isp1301_omap.c
+++ b/drivers/usb/otg/isp1301_omap.c
@@ -236,7 +236,7 @@ isp1301_clear_bits(struct isp1301 *isp, u8 reg, u8 bits)
 
 static inline const char *state_name(struct isp1301 *isp)
 {
-	return otg_state_string(isp->otg.state);
+	return usb_phy_state_string(isp->otg.state);
 }
 
 /*-------------------------------------------------------------------------*/
@@ -251,7 +251,7 @@ static inline const char *state_name(struct isp1301 *isp)
 
 static void power_down(struct isp1301 *isp)
 {
-	isp->otg.state = OTG_STATE_UNDEFINED;
+	isp->otg.state = USB_PHY_STATE_UNDEFINED;
 
 	// isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2, MC2_GLOBAL_PWR_DN);
 	isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_SUSPEND);
@@ -341,7 +341,7 @@ static void a_idle(struct isp1301 *isp, const char *tag)
 {
 	u32 l;
 
-	if (isp->otg.state == OTG_STATE_A_IDLE)
+	if (isp->otg.state == USB_PHY_STATE_A_IDLE)
 		return;
 
 	isp->otg.default_a = 1;
@@ -353,7 +353,7 @@ static void a_idle(struct isp1301 *isp, const char *tag)
 		isp->otg.gadget->is_a_peripheral = 1;
 		gadget_suspend(isp);
 	}
-	isp->otg.state = OTG_STATE_A_IDLE;
+	isp->otg.state = USB_PHY_STATE_A_IDLE;
 	l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
 	omap_writel(l, OTG_CTRL);
 	isp->last_otg_ctrl = l;
@@ -365,7 +365,7 @@ static void b_idle(struct isp1301 *isp, const char *tag)
 {
 	u32 l;
 
-	if (isp->otg.state == OTG_STATE_B_IDLE)
+	if (isp->otg.state == USB_PHY_STATE_B_IDLE)
 		return;
 
 	isp->otg.default_a = 0;
@@ -377,7 +377,7 @@ static void b_idle(struct isp1301 *isp, const char *tag)
 		isp->otg.gadget->is_a_peripheral = 0;
 		gadget_suspend(isp);
 	}
-	isp->otg.state = OTG_STATE_B_IDLE;
+	isp->otg.state = USB_PHY_STATE_B_IDLE;
 	l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
 	omap_writel(l, OTG_CTRL);
 	isp->last_otg_ctrl = l;
@@ -415,7 +415,7 @@ dump_regs(struct isp1301 *isp, const char *label)
 
 static void check_state(struct isp1301 *isp, const char *tag)
 {
-	enum usb_otg_state	state = OTG_STATE_UNDEFINED;
+	enum usb_phy_state	state = USB_PHY_STATE_UNDEFINED;
 	u8			fsm = omap_readw(OTG_TEST) & 0x0ff;
 	unsigned		extra = 0;
 
@@ -423,16 +423,16 @@ static void check_state(struct isp1301 *isp, const char *tag)
 
 	/* default-b */
 	case 0x0:
-		state = OTG_STATE_B_IDLE;
+		state = USB_PHY_STATE_B_IDLE;
 		break;
 	case 0x3:
 	case 0x7:
 		extra = 1;
 	case 0x1:
-		state = OTG_STATE_B_PERIPHERAL;
+		state = USB_PHY_STATE_B_PERIPHERAL;
 		break;
 	case 0x11:
-		state = OTG_STATE_B_SRP_INIT;
+		state = USB_PHY_STATE_B_SRP_INIT;
 		break;
 
 	/* extra dual-role default-b states */
@@ -441,39 +441,39 @@ static void check_state(struct isp1301 *isp, const char *tag)
 	case 0x16:
 		extra = 1;
 	case 0x17:
-		state = OTG_STATE_B_WAIT_ACON;
+		state = USB_PHY_STATE_B_WAIT_ACON;
 		break;
 	case 0x34:
-		state = OTG_STATE_B_HOST;
+		state = USB_PHY_STATE_B_HOST;
 		break;
 
 	/* default-a */
 	case 0x36:
-		state = OTG_STATE_A_IDLE;
+		state = USB_PHY_STATE_A_IDLE;
 		break;
 	case 0x3c:
-		state = OTG_STATE_A_WAIT_VFALL;
+		state = USB_PHY_STATE_A_WAIT_VFALL;
 		break;
 	case 0x7d:
-		state = OTG_STATE_A_VBUS_ERR;
+		state = USB_PHY_STATE_A_VBUS_ERR;
 		break;
 	case 0x9e:
 	case 0x9f:
 		extra = 1;
 	case 0x89:
-		state = OTG_STATE_A_PERIPHERAL;
+		state = USB_PHY_STATE_A_PERIPHERAL;
 		break;
 	case 0xb7:
-		state = OTG_STATE_A_WAIT_VRISE;
+		state = USB_PHY_STATE_A_WAIT_VRISE;
 		break;
 	case 0xb8:
-		state = OTG_STATE_A_WAIT_BCON;
+		state = USB_PHY_STATE_A_WAIT_BCON;
 		break;
 	case 0xb9:
-		state = OTG_STATE_A_HOST;
+		state = USB_PHY_STATE_A_HOST;
 		break;
 	case 0xba:
-		state = OTG_STATE_A_SUSPEND;
+		state = USB_PHY_STATE_A_SUSPEND;
 		break;
 	default:
 		break;
@@ -481,7 +481,7 @@ static void check_state(struct isp1301 *isp, const char *tag)
 	if (isp->otg.state == state && !extra)
 		return;
 	pr_debug("otg: %s FSM %s/%02x, %s, %06x\n", tag,
-		otg_state_string(state), fsm, state_name(isp),
+		usb_phy_state_string(state), fsm, state_name(isp),
 		omap_readl(OTG_CTRL));
 }
 
@@ -502,22 +502,22 @@ static void update_otg1(struct isp1301 *isp, u8 int_src)
 
 	if (int_src & INTR_SESS_VLD)
 		otg_ctrl |= OTG_ASESSVLD;
-	else if (isp->otg.state == OTG_STATE_A_WAIT_VFALL) {
+	else if (isp->otg.state == USB_PHY_STATE_A_WAIT_VFALL) {
 		a_idle(isp, "vfall");
 		otg_ctrl &= ~OTG_CTRL_BITS;
 	}
 	if (int_src & INTR_VBUS_VLD)
 		otg_ctrl |= OTG_VBUSVLD;
 	if (int_src & INTR_ID_GND) {		/* default-A */
-		if (isp->otg.state == OTG_STATE_B_IDLE
-				|| isp->otg.state == OTG_STATE_UNDEFINED) {
+		if (isp->otg.state == USB_PHY_STATE_B_IDLE
+				|| isp->otg.state == USB_PHY_STATE_UNDEFINED) {
 			a_idle(isp, "init");
 			return;
 		}
 	} else {				/* default-B */
 		otg_ctrl |= OTG_ID;
-		if (isp->otg.state == OTG_STATE_A_IDLE
-				|| isp->otg.state == OTG_STATE_UNDEFINED) {
+		if (isp->otg.state == USB_PHY_STATE_A_IDLE
+				|| isp->otg.state == USB_PHY_STATE_UNDEFINED) {
 			b_idle(isp, "init");
 			return;
 		}
@@ -552,13 +552,13 @@ static void otg_update_isp(struct isp1301 *isp)
 	otg_ctrl = otg_ctrl & OTG_XCEIV_INPUTS;
 
 	switch (isp->otg.state) {
-	case OTG_STATE_B_IDLE:
-	case OTG_STATE_B_PERIPHERAL:
-	case OTG_STATE_B_SRP_INIT:
+	case USB_PHY_STATE_B_IDLE:
+	case USB_PHY_STATE_B_PERIPHERAL:
+	case USB_PHY_STATE_B_SRP_INIT:
 		if (!(otg_ctrl & OTG_PULLUP)) {
 			// if (otg_ctrl & OTG_B_HNPEN) {
 			if (isp->otg.gadget->b_hnp_enable) {
-				isp->otg.state = OTG_STATE_B_WAIT_ACON;
+				isp->otg.state = USB_PHY_STATE_B_WAIT_ACON;
 				pr_debug("  --> b_wait_acon\n");
 			}
 			goto pulldown;
@@ -567,12 +567,12 @@ pullup:
 		set |= OTG1_DP_PULLUP;
 		clr |= OTG1_DP_PULLDOWN;
 		break;
-	case OTG_STATE_A_SUSPEND:
-	case OTG_STATE_A_PERIPHERAL:
+	case USB_PHY_STATE_A_SUSPEND:
+	case USB_PHY_STATE_A_PERIPHERAL:
 		if (otg_ctrl & OTG_PULLUP)
 			goto pullup;
 		/* FALLTHROUGH */
-	// case OTG_STATE_B_WAIT_ACON:
+	/* case USB_PHY_STATE_B_WAIT_ACON: */
 	default:
 pulldown:
 		set |= OTG1_DP_PULLDOWN;
@@ -589,7 +589,7 @@ pulldown:
 		otg_ctrl &= ~OTG_DRV_VBUS;
 
 	switch (isp->otg.state) {
-	case OTG_STATE_A_SUSPEND:
+	case USB_PHY_STATE_A_SUSPEND:
 		if (otg_ctrl & OTG_DRV_VBUS) {
 			set |= OTG1_VBUS_DRV;
 			break;
@@ -598,17 +598,17 @@ pulldown:
 		notresponding(isp);
 
 		/* FALLTHROUGH */
-	case OTG_STATE_A_VBUS_ERR:
-		isp->otg.state = OTG_STATE_A_WAIT_VFALL;
+	case USB_PHY_STATE_A_VBUS_ERR:
+		isp->otg.state = USB_PHY_STATE_A_WAIT_VFALL;
 		pr_debug("  --> a_wait_vfall\n");
 		/* FALLTHROUGH */
-	case OTG_STATE_A_WAIT_VFALL:
+	case USB_PHY_STATE_A_WAIT_VFALL:
 		/* FIXME usbcore thinks port power is still on ... */
 		clr |= OTG1_VBUS_DRV;
 		break;
-	case OTG_STATE_A_IDLE:
+	case USB_PHY_STATE_A_IDLE:
 		if (otg_ctrl & OTG_DRV_VBUS) {
-			isp->otg.state = OTG_STATE_A_WAIT_VRISE;
+			isp->otg.state = USB_PHY_STATE_A_WAIT_VRISE;
 			pr_debug("  --> a_wait_vrise\n");
 		}
 		/* FALLTHROUGH */
@@ -629,16 +629,16 @@ pulldown:
 		u32 l;
 
 		switch (isp->otg.state) {
-		case OTG_STATE_B_IDLE:
+		case USB_PHY_STATE_B_IDLE:
 			if (clr & OTG1_DP_PULLUP)
 				break;
-			isp->otg.state = OTG_STATE_B_PERIPHERAL;
+			isp->otg.state = USB_PHY_STATE_B_PERIPHERAL;
 			pr_debug("  --> b_peripheral\n");
 			break;
-		case OTG_STATE_A_SUSPEND:
+		case USB_PHY_STATE_A_SUSPEND:
 			if (clr & OTG1_DP_PULLUP)
 				break;
-			isp->otg.state = OTG_STATE_A_PERIPHERAL;
+			isp->otg.state = USB_PHY_STATE_A_PERIPHERAL;
 			pr_debug("  --> a_peripheral\n");
 			break;
 		default:
@@ -675,7 +675,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
 		 * remote wakeup (SRP, normal) using their own timer
 		 * to give "check cable and A-device" messages.
 		 */
-		if (isp->otg.state == OTG_STATE_B_SRP_INIT)
+		if (isp->otg.state == USB_PHY_STATE_B_SRP_INIT)
 			b_idle(isp, "srp_timeout");
 
 		omap_writew(B_SRP_TMROUT, OTG_IRQ_SRC);
@@ -693,7 +693,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
 		omap_writel(otg_ctrl, OTG_CTRL);
 
 		/* subset of b_peripheral()... */
-		isp->otg.state = OTG_STATE_B_PERIPHERAL;
+		isp->otg.state = USB_PHY_STATE_B_PERIPHERAL;
 		pr_debug("  --> b_peripheral\n");
 
 		omap_writew(B_HNP_FAIL, OTG_IRQ_SRC);
@@ -706,7 +706,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
 
 		isp1301_defer_work(isp, WORK_UPDATE_OTG);
 		switch (isp->otg.state) {
-		case OTG_STATE_A_IDLE:
+		case USB_PHY_STATE_A_IDLE:
 			if (!isp->otg.host)
 				break;
 			isp1301_defer_work(isp, WORK_HOST_RESUME);
@@ -736,7 +736,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
 		otg_ctrl |= OTG_BUSDROP;
 		otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
 		omap_writel(otg_ctrl, OTG_CTRL);
-		isp->otg.state = OTG_STATE_A_WAIT_VFALL;
+		isp->otg.state = USB_PHY_STATE_A_WAIT_VFALL;
 
 		omap_writew(A_REQ_TMROUT, OTG_IRQ_SRC);
 		ret = IRQ_HANDLED;
@@ -750,7 +750,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
 		otg_ctrl |= OTG_BUSDROP;
 		otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
 		omap_writel(otg_ctrl, OTG_CTRL);
-		isp->otg.state = OTG_STATE_A_VBUS_ERR;
+		isp->otg.state = USB_PHY_STATE_A_VBUS_ERR;
 
 		omap_writew(A_VBUS_ERR, OTG_IRQ_SRC);
 		ret = IRQ_HANDLED;
@@ -772,7 +772,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
 		/* role is peripheral */
 		if (otg_ctrl & OTG_DRIVER_SEL) {
 			switch (isp->otg.state) {
-			case OTG_STATE_A_IDLE:
+			case USB_PHY_STATE_A_IDLE:
 				b_idle(isp, __func__);
 				break;
 			default:
@@ -789,17 +789,18 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
 
 			if (isp->otg.host) {
 				switch (isp->otg.state) {
-				case OTG_STATE_B_WAIT_ACON:
-					isp->otg.state = OTG_STATE_B_HOST;
+				case USB_PHY_STATE_B_WAIT_ACON:
+					isp->otg.state = USB_PHY_STATE_B_HOST;
 					pr_debug("  --> b_host\n");
 					kick = 1;
 					break;
-				case OTG_STATE_A_WAIT_BCON:
-					isp->otg.state = OTG_STATE_A_HOST;
+				case USB_PHY_STATE_A_WAIT_BCON:
+					isp->otg.state = USB_PHY_STATE_A_HOST;
 					pr_debug("  --> a_host\n");
 					break;
-				case OTG_STATE_A_PERIPHERAL:
-					isp->otg.state = OTG_STATE_A_WAIT_BCON;
+				case USB_PHY_STATE_A_PERIPHERAL:
+					isp->otg.state =
+						USB_PHY_STATE_A_WAIT_BCON;
 					pr_debug("  --> a_wait_bcon\n");
 					break;
 				default:
@@ -940,7 +941,7 @@ static void b_peripheral(struct isp1301 *isp)
 	/* UDC driver just set OTG_BSESSVLD */
 	isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_DP_PULLUP);
 	isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_DP_PULLDOWN);
-	isp->otg.state = OTG_STATE_B_PERIPHERAL;
+	isp->otg.state = USB_PHY_STATE_B_PERIPHERAL;
 	pr_debug("  --> b_peripheral\n");
 	dump_regs(isp, "2periph");
 #endif
@@ -949,7 +950,7 @@ static void b_peripheral(struct isp1301 *isp)
 static void isp_update_otg(struct isp1301 *isp, u8 stat)
 {
 	u8			isp_stat, isp_bstat;
-	enum usb_otg_state	state = isp->otg.state;
+	enum usb_phy_state	state = isp->otg.state;
 
 	if (stat & INTR_BDIS_ACON)
 		pr_debug("OTG:  BDIS_ACON, %s\n", state_name(isp));
@@ -959,44 +960,45 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
 	if (isp_stat & INTR_ID_GND) {
 		if (isp->otg.default_a) {
 			switch (state) {
-			case OTG_STATE_B_IDLE:
+			case USB_PHY_STATE_B_IDLE:
 				a_idle(isp, "idle");
 				/* FALLTHROUGH */
-			case OTG_STATE_A_IDLE:
+			case USB_PHY_STATE_A_IDLE:
 				enable_vbus_source(isp);
 				/* FALLTHROUGH */
-			case OTG_STATE_A_WAIT_VRISE:
-				/* we skip over OTG_STATE_A_WAIT_BCON, since
+			case USB_PHY_STATE_A_WAIT_VRISE:
+				/* we skip over USB_PHY_STATE_A_WAIT_BCON, since
 				 * the HC will transition to A_HOST (or
 				 * A_SUSPEND!) without our noticing except
 				 * when HNP is used.
 				 */
 				if (isp_stat & INTR_VBUS_VLD)
-					isp->otg.state = OTG_STATE_A_HOST;
+					isp->otg.state = USB_PHY_STATE_A_HOST;
 				break;
-			case OTG_STATE_A_WAIT_VFALL:
+			case USB_PHY_STATE_A_WAIT_VFALL:
 				if (!(isp_stat & INTR_SESS_VLD))
 					a_idle(isp, "vfell");
 				break;
 			default:
 				if (!(isp_stat & INTR_VBUS_VLD))
-					isp->otg.state = OTG_STATE_A_VBUS_ERR;
+					isp->otg.state =
+						USB_PHY_STATE_A_VBUS_ERR;
 				break;
 			}
 			isp_bstat = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
 		} else {
 			switch (state) {
-			case OTG_STATE_B_PERIPHERAL:
-			case OTG_STATE_B_HOST:
-			case OTG_STATE_B_WAIT_ACON:
+			case USB_PHY_STATE_B_PERIPHERAL:
+			case USB_PHY_STATE_B_HOST:
+			case USB_PHY_STATE_B_WAIT_ACON:
 				usb_gadget_vbus_disconnect(isp->otg.gadget);
 				break;
 			default:
 				break;
 			}
-			if (state != OTG_STATE_A_IDLE)
+			if (state != USB_PHY_STATE_A_IDLE)
 				a_idle(isp, "id");
-			if (isp->otg.host && state == OTG_STATE_A_IDLE)
+			if (isp->otg.host && state == USB_PHY_STATE_A_IDLE)
 				isp1301_defer_work(isp, WORK_HOST_RESUME);
 			isp_bstat = 0;
 		}
@@ -1009,34 +1011,34 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
 		if (isp->otg.default_a) {
 			switch (state) {
 			default:
-				isp->otg.state = OTG_STATE_A_WAIT_VFALL;
+				isp->otg.state = USB_PHY_STATE_A_WAIT_VFALL;
 				break;
-			case OTG_STATE_A_WAIT_VFALL:
-				state = OTG_STATE_A_IDLE;
+			case USB_PHY_STATE_A_WAIT_VFALL:
+				state = USB_PHY_STATE_A_IDLE;
 				/* khubd may take a while to notice and
 				 * handle this disconnect, so don't go
 				 * to B_IDLE quite yet.
 				 */
 				break;
-			case OTG_STATE_A_IDLE:
+			case USB_PHY_STATE_A_IDLE:
 				host_suspend(isp);
 				isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1,
 						MC1_BDIS_ACON_EN);
-				isp->otg.state = OTG_STATE_B_IDLE;
+				isp->otg.state = USB_PHY_STATE_B_IDLE;
 				l = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
 				l &= ~OTG_CTRL_BITS;
 				omap_writel(l, OTG_CTRL);
 				break;
-			case OTG_STATE_B_IDLE:
+			case USB_PHY_STATE_B_IDLE:
 				break;
 			}
 		}
 		isp_bstat = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
 
 		switch (isp->otg.state) {
-		case OTG_STATE_B_PERIPHERAL:
-		case OTG_STATE_B_WAIT_ACON:
-		case OTG_STATE_B_HOST:
+		case USB_PHY_STATE_B_PERIPHERAL:
+		case USB_PHY_STATE_B_WAIT_ACON:
+		case USB_PHY_STATE_B_HOST:
 			if (likely(isp_bstat & OTG_B_SESS_VLD))
 				break;
 			enable_vbus_draw(isp, 0);
@@ -1049,12 +1051,12 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
 			dump_regs(isp, __func__);
 #endif
 			/* FALLTHROUGH */
-		case OTG_STATE_B_SRP_INIT:
+		case USB_PHY_STATE_B_SRP_INIT:
 			b_idle(isp, __func__);
 			l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
 			omap_writel(l, OTG_CTRL);
 			/* FALLTHROUGH */
-		case OTG_STATE_B_IDLE:
+		case USB_PHY_STATE_B_IDLE:
 			if (isp->otg.gadget && (isp_bstat & OTG_B_SESS_VLD)) {
 #ifdef	CONFIG_USB_OTG
 				update_otg1(isp, isp_stat);
@@ -1064,7 +1066,7 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
 			} else if (!(isp_stat & (INTR_VBUS_VLD|INTR_SESS_VLD)))
 				isp_bstat |= OTG_B_SESS_END;
 			break;
-		case OTG_STATE_A_WAIT_VFALL:
+		case USB_PHY_STATE_A_WAIT_VFALL:
 			break;
 		default:
 			pr_debug("otg: unsupported b-device %s\n",
@@ -1075,7 +1077,7 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
 
 	if (state != isp->otg.state)
 		pr_debug("  isp, %s -> %s\n",
-				otg_state_string(state), state_name(isp));
+				usb_phy_state_string(state), state_name(isp));
 
 #ifdef	CONFIG_USB_OTG
 	/* update the OTG controller state to match the isp1301; may
@@ -1132,9 +1134,9 @@ isp1301_work(struct work_struct *work)
 			 * skip A_WAIT_BCON; same.
 			 */
 			switch (isp->otg.state) {
-			case OTG_STATE_A_WAIT_BCON:
-			case OTG_STATE_A_WAIT_VRISE:
-				isp->otg.state = OTG_STATE_A_HOST;
+			case USB_PHY_STATE_A_WAIT_BCON:
+			case USB_PHY_STATE_A_WAIT_VRISE:
+				isp->otg.state = USB_PHY_STATE_A_HOST;
 				pr_debug("  --> a_host\n");
 				otg_ctrl = omap_readl(OTG_CTRL);
 				otg_ctrl |= OTG_A_BUSREQ;
@@ -1142,13 +1144,13 @@ isp1301_work(struct work_struct *work)
 						& OTG_CTRL_MASK;
 				omap_writel(otg_ctrl, OTG_CTRL);
 				break;
-			case OTG_STATE_B_WAIT_ACON:
-				isp->otg.state = OTG_STATE_B_HOST;
+			case USB_PHY_STATE_B_WAIT_ACON:
+				isp->otg.state = USB_PHY_STATE_B_HOST;
 				pr_debug("  --> b_host (acon)\n");
 				break;
-			case OTG_STATE_B_HOST:
-			case OTG_STATE_B_IDLE:
-			case OTG_STATE_A_IDLE:
+			case USB_PHY_STATE_B_HOST:
+			case USB_PHY_STATE_B_IDLE:
+			case USB_PHY_STATE_A_IDLE:
 				break;
 			default:
 				pr_debug("  host resume in %s\n",
@@ -1368,7 +1370,7 @@ isp1301_set_peripheral(struct usb_phy *otg, struct usb_gadget *gadget)
 	omap_writel(l, OTG_CTRL);
 
 	power_up(isp);
-	isp->otg.state = OTG_STATE_B_IDLE;
+	isp->otg.state = USB_PHY_STATE_B_IDLE;
 
 	if (machine_is_omap_h2() || machine_is_omap_h3())
 		isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
@@ -1403,7 +1405,7 @@ isp1301_set_power(struct usb_phy *dev, unsigned mA)
 {
 	if (!the_transceiver)
 		return -ENODEV;
-	if (dev->state == OTG_STATE_B_PERIPHERAL)
+	if (dev->state == USB_PHY_STATE_B_PERIPHERAL)
 		enable_vbus_draw(the_transceiver, mA);
 	return 0;
 }
@@ -1415,7 +1417,7 @@ isp1301_start_srp(struct usb_phy *dev)
 	u32		otg_ctrl;
 
 	if (!dev || isp != the_transceiver
-			|| isp->otg.state != OTG_STATE_B_IDLE)
+			|| isp->otg.state != USB_PHY_STATE_B_IDLE)
 		return -ENODEV;
 
 	otg_ctrl = omap_readl(OTG_CTRL);
@@ -1425,7 +1427,7 @@ isp1301_start_srp(struct usb_phy *dev)
 	otg_ctrl |= OTG_B_BUSREQ;
 	otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK;
 	omap_writel(otg_ctrl, OTG_CTRL);
-	isp->otg.state = OTG_STATE_B_SRP_INIT;
+	isp->otg.state = USB_PHY_STATE_B_SRP_INIT;
 
 	pr_debug("otg: SRP, %s ... %06x\n", state_name(isp),
 			omap_readl(OTG_CTRL));
@@ -1455,11 +1457,11 @@ isp1301_start_hnp(struct usb_phy *dev)
 	 * So do this part as early as possible...
 	 */
 	switch (isp->otg.state) {
-	case OTG_STATE_B_HOST:
-		isp->otg.state = OTG_STATE_B_PERIPHERAL;
+	case USB_PHY_STATE_B_HOST:
+		isp->otg.state = USB_PHY_STATE_B_PERIPHERAL;
 		/* caller will suspend next */
 		break;
-	case OTG_STATE_A_HOST:
+	case USB_PHY_STATE_A_HOST:
 #if 0
 		/* autoconnect mode avoids irq latency bugs */
 		isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1,
@@ -1472,7 +1474,7 @@ isp1301_start_hnp(struct usb_phy *dev)
 		omap_writel(l, OTG_CTRL);
 
 		break;
-	case OTG_STATE_A_PERIPHERAL:
+	case USB_PHY_STATE_A_PERIPHERAL:
 		/* initiated by B-Host suspend */
 		break;
 	default:
diff --git a/drivers/usb/otg/msm_otg.c b/drivers/usb/otg/msm_otg.c
index cba4737..c468db6 100644
--- a/drivers/usb/otg/msm_otg.c
+++ b/drivers/usb/otg/msm_otg.c
@@ -666,7 +666,7 @@ static void msm_otg_start_host(struct usb_phy *otg, int on)
 		 * HUB before kicking the host.
 		 */
 		if (pdata->setup_gpio)
-			pdata->setup_gpio(OTG_STATE_A_HOST);
+			pdata->setup_gpio(USB_PHY_STATE_A_HOST);
 #ifdef CONFIG_USB
 		usb_add_hcd(hcd, hcd->irq, IRQF_SHARED);
 #endif
@@ -677,7 +677,7 @@ static void msm_otg_start_host(struct usb_phy *otg, int on)
 		usb_remove_hcd(hcd);
 #endif
 		if (pdata->setup_gpio)
-			pdata->setup_gpio(OTG_STATE_UNDEFINED);
+			pdata->setup_gpio(USB_PHY_STATE_UNDEFINED);
 		if (pdata->vbus_power)
 			pdata->vbus_power(0);
 	}
@@ -698,11 +698,11 @@ static int msm_otg_set_host(struct usb_phy *otg, struct usb_bus *host)
 	}
 
 	if (!host) {
-		if (otg->state == OTG_STATE_A_HOST) {
+		if (otg->state == USB_PHY_STATE_A_HOST) {
 			pm_runtime_get_sync(otg->dev);
 			msm_otg_start_host(otg, 0);
 			otg->host = NULL;
-			otg->state = OTG_STATE_UNDEFINED;
+			otg->state = USB_PHY_STATE_UNDEFINED;
 			schedule_work(&motg->sm_work);
 		} else {
 			otg->host = NULL;
@@ -745,13 +745,13 @@ static void msm_otg_start_peripheral(struct usb_phy *otg, int on)
 		 * HUB before kicking the gadget.
 		 */
 		if (pdata->setup_gpio)
-			pdata->setup_gpio(OTG_STATE_B_PERIPHERAL);
+			pdata->setup_gpio(USB_PHY_STATE_B_PERIPHERAL);
 		usb_gadget_vbus_connect(otg->gadget);
 	} else {
 		dev_dbg(otg->dev, "gadget off\n");
 		usb_gadget_vbus_disconnect(otg->gadget);
 		if (pdata->setup_gpio)
-			pdata->setup_gpio(OTG_STATE_UNDEFINED);
+			pdata->setup_gpio(USB_PHY_STATE_UNDEFINED);
 	}
 
 }
@@ -771,11 +771,11 @@ static int msm_otg_set_peripheral(struct usb_phy *otg,
 	}
 
 	if (!gadget) {
-		if (otg->state == OTG_STATE_B_PERIPHERAL) {
+		if (otg->state == USB_PHY_STATE_B_PERIPHERAL) {
 			pm_runtime_get_sync(otg->dev);
 			msm_otg_start_peripheral(otg, 0);
 			otg->gadget = NULL;
-			otg->state = OTG_STATE_UNDEFINED;
+			otg->state = USB_PHY_STATE_UNDEFINED;
 			schedule_work(&motg->sm_work);
 		} else {
 			otg->gadget = NULL;
@@ -1155,19 +1155,19 @@ static void msm_otg_sm_work(struct work_struct *w)
 	struct usb_phy *otg = &motg->otg;
 
 	switch (otg->state) {
-	case OTG_STATE_UNDEFINED:
-		dev_dbg(otg->dev, "OTG_STATE_UNDEFINED state\n");
+	case USB_PHY_STATE_UNDEFINED:
+		dev_dbg(otg->dev, "USB_PHY_STATE_UNDEFINED state\n");
 		msm_otg_reset(otg);
 		msm_otg_init_sm(motg);
-		otg->state = OTG_STATE_B_IDLE;
+		otg->state = USB_PHY_STATE_B_IDLE;
 		/* FALL THROUGH */
-	case OTG_STATE_B_IDLE:
-		dev_dbg(otg->dev, "OTG_STATE_B_IDLE state\n");
+	case USB_PHY_STATE_B_IDLE:
+		dev_dbg(otg->dev, "USB_PHY_STATE_B_IDLE state\n");
 		if (!test_bit(ID, &motg->inputs) && otg->host) {
 			/* disable BSV bit */
 			writel(readl(USB_OTGSC) & ~OTGSC_BSVIE, USB_OTGSC);
 			msm_otg_start_host(otg, 1);
-			otg->state = OTG_STATE_A_HOST;
+			otg->state = USB_PHY_STATE_A_HOST;
 		} else if (test_bit(B_SESS_VLD, &motg->inputs)) {
 			switch (motg->chg_state) {
 			case USB_CHG_STATE_UNDEFINED:
@@ -1183,12 +1183,12 @@ static void msm_otg_sm_work(struct work_struct *w)
 					msm_otg_notify_charger(motg,
 							IDEV_CHG_MAX);
 					msm_otg_start_peripheral(otg, 1);
-					otg->state = OTG_STATE_B_PERIPHERAL;
+					otg->state = USB_PHY_STATE_B_PERIPHERAL;
 					break;
 				case USB_SDP_CHARGER:
 					msm_otg_notify_charger(motg, IUNIT);
 					msm_otg_start_peripheral(otg, 1);
-					otg->state = OTG_STATE_B_PERIPHERAL;
+					otg->state = USB_PHY_STATE_B_PERIPHERAL;
 					break;
 				default:
 					break;
@@ -1213,24 +1213,24 @@ static void msm_otg_sm_work(struct work_struct *w)
 		}
 		pm_runtime_put_sync(otg->dev);
 		break;
-	case OTG_STATE_B_PERIPHERAL:
-		dev_dbg(otg->dev, "OTG_STATE_B_PERIPHERAL state\n");
+	case USB_PHY_STATE_B_PERIPHERAL:
+		dev_dbg(otg->dev, "USB_PHY_STATE_B_PERIPHERAL state\n");
 		if (!test_bit(B_SESS_VLD, &motg->inputs) ||
 				!test_bit(ID, &motg->inputs)) {
 			msm_otg_notify_charger(motg, 0);
 			msm_otg_start_peripheral(otg, 0);
 			motg->chg_state = USB_CHG_STATE_UNDEFINED;
 			motg->chg_type = USB_INVALID_CHARGER;
-			otg->state = OTG_STATE_B_IDLE;
+			otg->state = USB_PHY_STATE_B_IDLE;
 			msm_otg_reset(otg);
 			schedule_work(w);
 		}
 		break;
-	case OTG_STATE_A_HOST:
-		dev_dbg(otg->dev, "OTG_STATE_A_HOST state\n");
+	case USB_PHY_STATE_A_HOST:
+		dev_dbg(otg->dev, "USB_PHY_STATE_A_HOST state\n");
 		if (test_bit(ID, &motg->inputs)) {
 			msm_otg_start_host(otg, 0);
-			otg->state = OTG_STATE_B_IDLE;
+			otg->state = USB_PHY_STATE_B_IDLE;
 			msm_otg_reset(otg);
 			schedule_work(w);
 		}
@@ -1284,10 +1284,10 @@ static int msm_otg_mode_show(struct seq_file *s, void *unused)
 	struct usb_phy *otg = &motg->otg;
 
 	switch (otg->state) {
-	case OTG_STATE_A_HOST:
+	case USB_PHY_STATE_A_HOST:
 		seq_printf(s, "host\n");
 		break;
-	case OTG_STATE_B_PERIPHERAL:
+	case USB_PHY_STATE_B_PERIPHERAL:
 		seq_printf(s, "peripheral\n");
 		break;
 	default:
@@ -1334,8 +1334,8 @@ static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf,
 	switch (req_mode) {
 	case USB_NONE:
 		switch (otg->state) {
-		case OTG_STATE_A_HOST:
-		case OTG_STATE_B_PERIPHERAL:
+		case USB_PHY_STATE_A_HOST:
+		case USB_PHY_STATE_B_PERIPHERAL:
 			set_bit(ID, &motg->inputs);
 			clear_bit(B_SESS_VLD, &motg->inputs);
 			break;
@@ -1345,8 +1345,8 @@ static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf,
 		break;
 	case USB_PERIPHERAL:
 		switch (otg->state) {
-		case OTG_STATE_B_IDLE:
-		case OTG_STATE_A_HOST:
+		case USB_PHY_STATE_B_IDLE:
+		case USB_PHY_STATE_A_HOST:
 			set_bit(ID, &motg->inputs);
 			set_bit(B_SESS_VLD, &motg->inputs);
 			break;
@@ -1356,8 +1356,8 @@ static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf,
 		break;
 	case USB_HOST:
 		switch (otg->state) {
-		case OTG_STATE_B_IDLE:
-		case OTG_STATE_B_PERIPHERAL:
+		case USB_PHY_STATE_B_IDLE:
+		case USB_PHY_STATE_B_PERIPHERAL:
 			clear_bit(ID, &motg->inputs);
 			break;
 		default:
@@ -1670,7 +1670,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->state != OTG_STATE_UNDEFINED)
+	if (otg->state != USB_PHY_STATE_UNDEFINED)
 		pm_schedule_suspend(dev, 1000);
 
 	return -EAGAIN;
diff --git a/drivers/usb/otg/mv_otg.c b/drivers/usb/otg/mv_otg.c
index 1d2f7cb..81d9303 100644
--- a/drivers/usb/otg/mv_otg.c
+++ b/drivers/usb/otg/mv_otg.c
@@ -345,65 +345,65 @@ static void mv_otg_update_state(struct mv_otg *mvotg)
 	int old_state = otg->state;
 
 	switch (old_state) {
-	case OTG_STATE_UNDEFINED:
-		otg->state = OTG_STATE_B_IDLE;
+	case USB_PHY_STATE_UNDEFINED:
+		otg->state = USB_PHY_STATE_B_IDLE;
 		/* FALL THROUGH */
-	case OTG_STATE_B_IDLE:
+	case USB_PHY_STATE_B_IDLE:
 		if (otg_ctrl->id == 0)
-			otg->state = OTG_STATE_A_IDLE;
+			otg->state = USB_PHY_STATE_A_IDLE;
 		else if (otg_ctrl->b_sess_vld)
-			otg->state = OTG_STATE_B_PERIPHERAL;
+			otg->state = USB_PHY_STATE_B_PERIPHERAL;
 		break;
-	case OTG_STATE_B_PERIPHERAL:
+	case USB_PHY_STATE_B_PERIPHERAL:
 		if (!otg_ctrl->b_sess_vld || otg_ctrl->id == 0)
-			otg->state = OTG_STATE_B_IDLE;
+			otg->state = USB_PHY_STATE_B_IDLE;
 		break;
-	case OTG_STATE_A_IDLE:
+	case USB_PHY_STATE_A_IDLE:
 		if (otg_ctrl->id)
-			otg->state = OTG_STATE_B_IDLE;
+			otg->state = USB_PHY_STATE_B_IDLE;
 		else if (!(otg_ctrl->a_bus_drop) &&
 			 (otg_ctrl->a_bus_req || otg_ctrl->a_srp_det))
-			otg->state = OTG_STATE_A_WAIT_VRISE;
+			otg->state = USB_PHY_STATE_A_WAIT_VRISE;
 		break;
-	case OTG_STATE_A_WAIT_VRISE:
+	case USB_PHY_STATE_A_WAIT_VRISE:
 		if (otg_ctrl->a_vbus_vld)
-			otg->state = OTG_STATE_A_WAIT_BCON;
+			otg->state = USB_PHY_STATE_A_WAIT_BCON;
 		break;
-	case OTG_STATE_A_WAIT_BCON:
+	case USB_PHY_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;
-			otg->state = OTG_STATE_A_WAIT_VFALL;
+			otg->state = USB_PHY_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;
-			otg->state = OTG_STATE_A_VBUS_ERR;
+			otg->state = USB_PHY_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;
-			otg->state = OTG_STATE_A_HOST;
+			otg->state = USB_PHY_STATE_A_HOST;
 		}
 		break;
-	case OTG_STATE_A_HOST:
+	case USB_PHY_STATE_A_HOST:
 		if (otg_ctrl->id || !otg_ctrl->b_conn
 		    || otg_ctrl->a_bus_drop)
-			otg->state = OTG_STATE_A_WAIT_BCON;
+			otg->state = USB_PHY_STATE_A_WAIT_BCON;
 		else if (!otg_ctrl->a_vbus_vld)
-			otg->state = OTG_STATE_A_VBUS_ERR;
+			otg->state = USB_PHY_STATE_A_VBUS_ERR;
 		break;
-	case OTG_STATE_A_WAIT_VFALL:
+	case USB_PHY_STATE_A_WAIT_VFALL:
 		if (otg_ctrl->id
 		    || (!otg_ctrl->b_conn && otg_ctrl->a_sess_vld)
 		    || otg_ctrl->a_bus_req)
-			otg->state = OTG_STATE_A_IDLE;
+			otg->state = USB_PHY_STATE_A_IDLE;
 		break;
-	case OTG_STATE_A_VBUS_ERR:
+	case USB_PHY_STATE_A_VBUS_ERR:
 		if (otg_ctrl->id || otg_ctrl->a_clr_err
 		    || otg_ctrl->a_bus_drop) {
 			otg_ctrl->a_clr_err = 0;
-			otg->state = OTG_STATE_A_WAIT_VFALL;
+			otg->state = USB_PHY_STATE_A_WAIT_VFALL;
 		}
 		break;
 	default:
@@ -436,29 +436,29 @@ run:
 			 state_string[otg->state]);
 
 		switch (otg->state) {
-		case OTG_STATE_B_IDLE:
+		case USB_PHY_STATE_B_IDLE:
 			mvotg->otg.default_a = 0;
-			if (old_state == OTG_STATE_B_PERIPHERAL)
+			if (old_state == USB_PHY_STATE_B_PERIPHERAL)
 				mv_otg_start_periphrals(mvotg, 0);
 			mv_otg_reset(mvotg);
 			mv_otg_disable(mvotg);
 			break;
-		case OTG_STATE_B_PERIPHERAL:
+		case USB_PHY_STATE_B_PERIPHERAL:
 			mv_otg_enable(mvotg);
 			mv_otg_start_periphrals(mvotg, 1);
 			break;
-		case OTG_STATE_A_IDLE:
+		case USB_PHY_STATE_A_IDLE:
 			mvotg->otg.default_a = 1;
 			mv_otg_enable(mvotg);
-			if (old_state == OTG_STATE_A_WAIT_VFALL)
+			if (old_state == USB_PHY_STATE_A_WAIT_VFALL)
 				mv_otg_start_host(mvotg, 0);
 			mv_otg_reset(mvotg);
 			break;
-		case OTG_STATE_A_WAIT_VRISE:
+		case USB_PHY_STATE_A_WAIT_VRISE:
 			mv_otg_set_vbus(&mvotg->otg, 1);
 			break;
-		case OTG_STATE_A_WAIT_BCON:
-			if (old_state != OTG_STATE_A_HOST)
+		case USB_PHY_STATE_A_WAIT_BCON:
+			if (old_state != USB_PHY_STATE_A_HOST)
 				mv_otg_start_host(mvotg, 1);
 			mv_otg_set_timer(mvotg, A_WAIT_BCON_TIMER,
 					 T_A_WAIT_BCON,
@@ -469,9 +469,9 @@ run:
 			 */
 			mvotg->otg_ctrl.b_conn = 1;
 			break;
-		case OTG_STATE_A_HOST:
+		case USB_PHY_STATE_A_HOST:
 			break;
-		case OTG_STATE_A_WAIT_VFALL:
+		case USB_PHY_STATE_A_WAIT_VFALL:
 			/*
 			 * Now, we has exited A_HOST. So set b_conn = 0
 			 * here. In fact, it need host driver to notify us.
@@ -479,7 +479,7 @@ run:
 			mvotg->otg_ctrl.b_conn = 0;
 			mv_otg_set_vbus(&mvotg->otg, 0);
 			break;
-		case OTG_STATE_A_VBUS_ERR:
+		case USB_PHY_STATE_A_VBUS_ERR:
 			break;
 		default:
 			break;
@@ -546,8 +546,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->otg.state != OTG_STATE_B_IDLE
-	    && mvotg->otg.state != OTG_STATE_A_IDLE)
+	if (mvotg->otg.state != USB_PHY_STATE_B_IDLE
+	    && mvotg->otg.state != USB_PHY_STATE_A_IDLE)
 		return -1;
 
 	/* The clock may disabled and we need to set irq for ID detected */
@@ -744,7 +744,7 @@ static int mv_otg_probe(struct platform_device *pdev)
 	mvotg->otg.set_host = mv_otg_set_host;
 	mvotg->otg.set_peripheral = mv_otg_set_peripheral;
 	mvotg->otg.set_vbus = mv_otg_set_vbus;
-	mvotg->otg.state = OTG_STATE_UNDEFINED;
+	mvotg->otg.state = USB_PHY_STATE_UNDEFINED;
 
 	for (i = 0; i < OTG_TIMER_NUM; i++)
 		init_timer(&mvotg->otg_ctrl.timer[i]);
@@ -896,7 +896,7 @@ static int mv_otg_suspend(struct platform_device *pdev, pm_message_t state)
 {
 	struct mv_otg *mvotg = platform_get_drvdata(pdev);
 
-	if (mvotg->otg.state != OTG_STATE_B_IDLE) {
+	if (mvotg->otg.state != USB_PHY_STATE_B_IDLE) {
 		dev_info(&pdev->dev,
 			 "OTG state is not B_IDLE, it is %d!\n",
 			 mvotg->otg.state);
diff --git a/drivers/usb/otg/nop-usb-xceiv.c b/drivers/usb/otg/nop-usb-xceiv.c
index 2ab0279..6a0c102 100644
--- a/drivers/usb/otg/nop-usb-xceiv.c
+++ b/drivers/usb/otg/nop-usb-xceiv.c
@@ -84,7 +84,7 @@ static int nop_set_peripheral(struct usb_phy *x,
 	}
 
 	nop->otg.gadget = gadget;
-	nop->otg.state = OTG_STATE_B_IDLE;
+	nop->otg.state = USB_PHY_STATE_B_IDLE;
 	return 0;
 }
 
@@ -118,7 +118,7 @@ static int __devinit nop_usb_xceiv_probe(struct platform_device *pdev)
 	nop->dev		= &pdev->dev;
 	nop->otg.dev		= nop->dev;
 	nop->otg.label		= "nop-xceiv";
-	nop->otg.state		= OTG_STATE_UNDEFINED;
+	nop->otg.state		= USB_PHY_STATE_UNDEFINED;
 	nop->otg.set_host	= nop_set_host;
 	nop->otg.set_peripheral	= nop_set_peripheral;
 	nop->otg.set_suspend	= nop_set_suspend;
diff --git a/drivers/usb/otg/otg.c b/drivers/usb/otg/otg.c
index 56c0f17..a202e63 100644
--- a/drivers/usb/otg/otg.c
+++ b/drivers/usb/otg/otg.c
@@ -66,37 +66,37 @@ int otg_set_transceiver(struct usb_phy *x)
 }
 EXPORT_SYMBOL(otg_set_transceiver);
 
-const char *otg_state_string(enum usb_otg_state state)
+const char *usb_phy_state_string(enum usb_phy_state state)
 {
 	switch (state) {
-	case OTG_STATE_A_IDLE:
+	case USB_PHY_STATE_A_IDLE:
 		return "a_idle";
-	case OTG_STATE_A_WAIT_VRISE:
+	case USB_PHY_STATE_A_WAIT_VRISE:
 		return "a_wait_vrise";
-	case OTG_STATE_A_WAIT_BCON:
+	case USB_PHY_STATE_A_WAIT_BCON:
 		return "a_wait_bcon";
-	case OTG_STATE_A_HOST:
+	case USB_PHY_STATE_A_HOST:
 		return "a_host";
-	case OTG_STATE_A_SUSPEND:
+	case USB_PHY_STATE_A_SUSPEND:
 		return "a_suspend";
-	case OTG_STATE_A_PERIPHERAL:
+	case USB_PHY_STATE_A_PERIPHERAL:
 		return "a_peripheral";
-	case OTG_STATE_A_WAIT_VFALL:
+	case USB_PHY_STATE_A_WAIT_VFALL:
 		return "a_wait_vfall";
-	case OTG_STATE_A_VBUS_ERR:
+	case USB_PHY_STATE_A_VBUS_ERR:
 		return "a_vbus_err";
-	case OTG_STATE_B_IDLE:
+	case USB_PHY_STATE_B_IDLE:
 		return "b_idle";
-	case OTG_STATE_B_SRP_INIT:
+	case USB_PHY_STATE_B_SRP_INIT:
 		return "b_srp_init";
-	case OTG_STATE_B_PERIPHERAL:
+	case USB_PHY_STATE_B_PERIPHERAL:
 		return "b_peripheral";
-	case OTG_STATE_B_WAIT_ACON:
+	case USB_PHY_STATE_B_WAIT_ACON:
 		return "b_wait_acon";
-	case OTG_STATE_B_HOST:
+	case USB_PHY_STATE_B_HOST:
 		return "b_host";
 	default:
 		return "UNDEFINED";
 	}
 }
-EXPORT_SYMBOL(otg_state_string);
+EXPORT_SYMBOL(usb_phy_state_string);
diff --git a/drivers/usb/otg/otg_fsm.c b/drivers/usb/otg/otg_fsm.c
index 0911738..b2feb07 100644
--- a/drivers/usb/otg/otg_fsm.c
+++ b/drivers/usb/otg/otg_fsm.c
@@ -65,48 +65,48 @@ static int otg_set_protocol(struct otg_fsm *fsm, int protocol)
 static int state_changed;
 
 /* Called when leaving a state.  Do state clean up jobs here */
-void otg_leave_state(struct otg_fsm *fsm, enum usb_otg_state old_state)
+void otg_leave_state(struct otg_fsm *fsm, enum usb_phy_state old_state)
 {
 	switch (old_state) {
-	case OTG_STATE_B_IDLE:
+	case USB_PHY_STATE_B_IDLE:
 		otg_del_timer(fsm, b_se0_srp_tmr);
 		fsm->b_se0_srp = 0;
 		break;
-	case OTG_STATE_B_SRP_INIT:
+	case USB_PHY_STATE_B_SRP_INIT:
 		fsm->b_srp_done = 0;
 		break;
-	case OTG_STATE_B_PERIPHERAL:
+	case USB_PHY_STATE_B_PERIPHERAL:
 		break;
-	case OTG_STATE_B_WAIT_ACON:
+	case USB_PHY_STATE_B_WAIT_ACON:
 		otg_del_timer(fsm, b_ase0_brst_tmr);
 		fsm->b_ase0_brst_tmout = 0;
 		break;
-	case OTG_STATE_B_HOST:
+	case USB_PHY_STATE_B_HOST:
 		break;
-	case OTG_STATE_A_IDLE:
+	case USB_PHY_STATE_A_IDLE:
 		break;
-	case OTG_STATE_A_WAIT_VRISE:
+	case USB_PHY_STATE_A_WAIT_VRISE:
 		otg_del_timer(fsm, a_wait_vrise_tmr);
 		fsm->a_wait_vrise_tmout = 0;
 		break;
-	case OTG_STATE_A_WAIT_BCON:
+	case USB_PHY_STATE_A_WAIT_BCON:
 		otg_del_timer(fsm, a_wait_bcon_tmr);
 		fsm->a_wait_bcon_tmout = 0;
 		break;
-	case OTG_STATE_A_HOST:
+	case USB_PHY_STATE_A_HOST:
 		otg_del_timer(fsm, a_wait_enum_tmr);
 		break;
-	case OTG_STATE_A_SUSPEND:
+	case USB_PHY_STATE_A_SUSPEND:
 		otg_del_timer(fsm, a_aidl_bdis_tmr);
 		fsm->a_aidl_bdis_tmout = 0;
 		fsm->a_suspend_req = 0;
 		break;
-	case OTG_STATE_A_PERIPHERAL:
+	case USB_PHY_STATE_A_PERIPHERAL:
 		break;
-	case OTG_STATE_A_WAIT_VFALL:
+	case USB_PHY_STATE_A_WAIT_VFALL:
 		otg_del_timer(fsm, a_wait_vrise_tmr);
 		break;
-	case OTG_STATE_A_VBUS_ERR:
+	case USB_PHY_STATE_A_VBUS_ERR:
 		break;
 	default:
 		break;
@@ -114,15 +114,15 @@ void otg_leave_state(struct otg_fsm *fsm, enum usb_otg_state old_state)
 }
 
 /* Called when entering a state */
-int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
+int otg_set_state(struct otg_fsm *fsm, enum usb_phy_state new_state)
 {
 	state_changed = 1;
 	if (fsm->transceiver->state == new_state)
 		return 0;
-	VDBG("Set state: %s\n", otg_state_string(new_state));
+	VDBG("Set state: %s\n", usb_phy_state_string(new_state));
 	otg_leave_state(fsm, fsm->transceiver->state);
 	switch (new_state) {
-	case OTG_STATE_B_IDLE:
+	case USB_PHY_STATE_B_IDLE:
 		otg_drv_vbus(fsm, 0);
 		otg_chrg_vbus(fsm, 0);
 		otg_loc_conn(fsm, 0);
@@ -130,19 +130,19 @@ int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
 		otg_set_protocol(fsm, PROTO_UNDEF);
 		otg_add_timer(fsm, b_se0_srp_tmr);
 		break;
-	case OTG_STATE_B_SRP_INIT:
+	case USB_PHY_STATE_B_SRP_INIT:
 		otg_start_pulse(fsm);
 		otg_loc_sof(fsm, 0);
 		otg_set_protocol(fsm, PROTO_UNDEF);
 		otg_add_timer(fsm, b_srp_fail_tmr);
 		break;
-	case OTG_STATE_B_PERIPHERAL:
+	case USB_PHY_STATE_B_PERIPHERAL:
 		otg_chrg_vbus(fsm, 0);
 		otg_loc_conn(fsm, 1);
 		otg_loc_sof(fsm, 0);
 		otg_set_protocol(fsm, PROTO_GADGET);
 		break;
-	case OTG_STATE_B_WAIT_ACON:
+	case USB_PHY_STATE_B_WAIT_ACON:
 		otg_chrg_vbus(fsm, 0);
 		otg_loc_conn(fsm, 0);
 		otg_loc_sof(fsm, 0);
@@ -150,7 +150,7 @@ int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
 		otg_add_timer(fsm, b_ase0_brst_tmr);
 		fsm->a_bus_suspend = 0;
 		break;
-	case OTG_STATE_B_HOST:
+	case USB_PHY_STATE_B_HOST:
 		otg_chrg_vbus(fsm, 0);
 		otg_loc_conn(fsm, 0);
 		otg_loc_sof(fsm, 1);
@@ -158,28 +158,28 @@ int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
 		usb_bus_start_enum(fsm->transceiver->host,
 				fsm->transceiver->host->otg_port);
 		break;
-	case OTG_STATE_A_IDLE:
+	case USB_PHY_STATE_A_IDLE:
 		otg_drv_vbus(fsm, 0);
 		otg_chrg_vbus(fsm, 0);
 		otg_loc_conn(fsm, 0);
 		otg_loc_sof(fsm, 0);
 		otg_set_protocol(fsm, PROTO_HOST);
 		break;
-	case OTG_STATE_A_WAIT_VRISE:
+	case USB_PHY_STATE_A_WAIT_VRISE:
 		otg_drv_vbus(fsm, 1);
 		otg_loc_conn(fsm, 0);
 		otg_loc_sof(fsm, 0);
 		otg_set_protocol(fsm, PROTO_HOST);
 		otg_add_timer(fsm, a_wait_vrise_tmr);
 		break;
-	case OTG_STATE_A_WAIT_BCON:
+	case USB_PHY_STATE_A_WAIT_BCON:
 		otg_drv_vbus(fsm, 1);
 		otg_loc_conn(fsm, 0);
 		otg_loc_sof(fsm, 0);
 		otg_set_protocol(fsm, PROTO_HOST);
 		otg_add_timer(fsm, a_wait_bcon_tmr);
 		break;
-	case OTG_STATE_A_HOST:
+	case USB_PHY_STATE_A_HOST:
 		otg_drv_vbus(fsm, 1);
 		otg_loc_conn(fsm, 0);
 		otg_loc_sof(fsm, 1);
@@ -191,7 +191,7 @@ int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
 		if (!fsm->a_bus_req || fsm->a_suspend_req)
 			otg_add_timer(fsm, a_wait_enum_tmr);
 		break;
-	case OTG_STATE_A_SUSPEND:
+	case USB_PHY_STATE_A_SUSPEND:
 		otg_drv_vbus(fsm, 1);
 		otg_loc_conn(fsm, 0);
 		otg_loc_sof(fsm, 0);
@@ -199,19 +199,19 @@ int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
 		otg_add_timer(fsm, a_aidl_bdis_tmr);
 
 		break;
-	case OTG_STATE_A_PERIPHERAL:
+	case USB_PHY_STATE_A_PERIPHERAL:
 		otg_loc_conn(fsm, 1);
 		otg_loc_sof(fsm, 0);
 		otg_set_protocol(fsm, PROTO_GADGET);
 		otg_drv_vbus(fsm, 1);
 		break;
-	case OTG_STATE_A_WAIT_VFALL:
+	case USB_PHY_STATE_A_WAIT_VFALL:
 		otg_drv_vbus(fsm, 0);
 		otg_loc_conn(fsm, 0);
 		otg_loc_sof(fsm, 0);
 		otg_set_protocol(fsm, PROTO_HOST);
 		break;
-	case OTG_STATE_A_VBUS_ERR:
+	case USB_PHY_STATE_A_VBUS_ERR:
 		otg_drv_vbus(fsm, 0);
 		otg_loc_conn(fsm, 0);
 		otg_loc_sof(fsm, 0);
@@ -228,7 +228,7 @@ int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
 /* State change judgement */
 int otg_statemachine(struct otg_fsm *fsm)
 {
-	enum usb_otg_state state;
+	enum usb_phy_state state;
 	unsigned long flags;
 
 	spin_lock_irqsave(&fsm->lock, flags);
@@ -238,105 +238,105 @@ int otg_statemachine(struct otg_fsm *fsm)
 	/* State machine state change judgement */
 
 	switch (state) {
-	case OTG_STATE_UNDEFINED:
+	case USB_PHY_STATE_UNDEFINED:
 		VDBG("fsm->id = %d\n", fsm->id);
 		if (fsm->id)
-			otg_set_state(fsm, OTG_STATE_B_IDLE);
+			otg_set_state(fsm, USB_PHY_STATE_B_IDLE);
 		else
-			otg_set_state(fsm, OTG_STATE_A_IDLE);
+			otg_set_state(fsm, USB_PHY_STATE_A_IDLE);
 		break;
-	case OTG_STATE_B_IDLE:
+	case USB_PHY_STATE_B_IDLE:
 		if (!fsm->id)
-			otg_set_state(fsm, OTG_STATE_A_IDLE);
+			otg_set_state(fsm, USB_PHY_STATE_A_IDLE);
 		else if (fsm->b_sess_vld && fsm->transceiver->gadget)
-			otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
+			otg_set_state(fsm, USB_PHY_STATE_B_PERIPHERAL);
 		else if (fsm->b_bus_req && fsm->b_sess_end && fsm->b_se0_srp)
-			otg_set_state(fsm, OTG_STATE_B_SRP_INIT);
+			otg_set_state(fsm, USB_PHY_STATE_B_SRP_INIT);
 		break;
-	case OTG_STATE_B_SRP_INIT:
+	case USB_PHY_STATE_B_SRP_INIT:
 		if (!fsm->id || fsm->b_srp_done)
-			otg_set_state(fsm, OTG_STATE_B_IDLE);
+			otg_set_state(fsm, USB_PHY_STATE_B_IDLE);
 		break;
-	case OTG_STATE_B_PERIPHERAL:
+	case USB_PHY_STATE_B_PERIPHERAL:
 		if (!fsm->id || !fsm->b_sess_vld)
-			otg_set_state(fsm, OTG_STATE_B_IDLE);
+			otg_set_state(fsm, USB_PHY_STATE_B_IDLE);
 		else if (fsm->b_bus_req && fsm->transceiver->
 				gadget->b_hnp_enable && fsm->a_bus_suspend)
-			otg_set_state(fsm, OTG_STATE_B_WAIT_ACON);
+			otg_set_state(fsm, USB_PHY_STATE_B_WAIT_ACON);
 		break;
-	case OTG_STATE_B_WAIT_ACON:
+	case USB_PHY_STATE_B_WAIT_ACON:
 		if (fsm->a_conn)
-			otg_set_state(fsm, OTG_STATE_B_HOST);
+			otg_set_state(fsm, USB_PHY_STATE_B_HOST);
 		else if (!fsm->id || !fsm->b_sess_vld)
-			otg_set_state(fsm, OTG_STATE_B_IDLE);
+			otg_set_state(fsm, USB_PHY_STATE_B_IDLE);
 		else if (fsm->a_bus_resume || fsm->b_ase0_brst_tmout) {
 			fsm->b_ase0_brst_tmout = 0;
-			otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
+			otg_set_state(fsm, USB_PHY_STATE_B_PERIPHERAL);
 		}
 		break;
-	case OTG_STATE_B_HOST:
+	case USB_PHY_STATE_B_HOST:
 		if (!fsm->id || !fsm->b_sess_vld)
-			otg_set_state(fsm, OTG_STATE_B_IDLE);
+			otg_set_state(fsm, USB_PHY_STATE_B_IDLE);
 		else if (!fsm->b_bus_req || !fsm->a_conn)
-			otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
+			otg_set_state(fsm, USB_PHY_STATE_B_PERIPHERAL);
 		break;
-	case OTG_STATE_A_IDLE:
+	case USB_PHY_STATE_A_IDLE:
 		if (fsm->id)
-			otg_set_state(fsm, OTG_STATE_B_IDLE);
+			otg_set_state(fsm, USB_PHY_STATE_B_IDLE);
 		else if (!fsm->a_bus_drop && (fsm->a_bus_req || fsm->a_srp_det))
-			otg_set_state(fsm, OTG_STATE_A_WAIT_VRISE);
+			otg_set_state(fsm, USB_PHY_STATE_A_WAIT_VRISE);
 		break;
-	case OTG_STATE_A_WAIT_VRISE:
+	case USB_PHY_STATE_A_WAIT_VRISE:
 		if (fsm->id || fsm->a_bus_drop || fsm->a_vbus_vld ||
 				fsm->a_wait_vrise_tmout) {
-			otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
+			otg_set_state(fsm, USB_PHY_STATE_A_WAIT_BCON);
 		}
 		break;
-	case OTG_STATE_A_WAIT_BCON:
+	case USB_PHY_STATE_A_WAIT_BCON:
 		if (!fsm->a_vbus_vld)
-			otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
+			otg_set_state(fsm, USB_PHY_STATE_A_VBUS_ERR);
 		else if (fsm->b_conn)
-			otg_set_state(fsm, OTG_STATE_A_HOST);
+			otg_set_state(fsm, USB_PHY_STATE_A_HOST);
 		else if (fsm->id | fsm->a_bus_drop | fsm->a_wait_bcon_tmout)
-			otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
+			otg_set_state(fsm, USB_PHY_STATE_A_WAIT_VFALL);
 		break;
-	case OTG_STATE_A_HOST:
+	case USB_PHY_STATE_A_HOST:
 		if ((!fsm->a_bus_req || fsm->a_suspend_req) &&
 				fsm->transceiver->host->b_hnp_enable)
-			otg_set_state(fsm, OTG_STATE_A_SUSPEND);
+			otg_set_state(fsm, USB_PHY_STATE_A_SUSPEND);
 		else if (fsm->id || !fsm->b_conn || fsm->a_bus_drop)
-			otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
+			otg_set_state(fsm, USB_PHY_STATE_A_WAIT_BCON);
 		else if (!fsm->a_vbus_vld)
-			otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
+			otg_set_state(fsm, USB_PHY_STATE_A_VBUS_ERR);
 		break;
-	case OTG_STATE_A_SUSPEND:
+	case USB_PHY_STATE_A_SUSPEND:
 		if (!fsm->b_conn && fsm->transceiver->host->b_hnp_enable)
-			otg_set_state(fsm, OTG_STATE_A_PERIPHERAL);
+			otg_set_state(fsm, USB_PHY_STATE_A_PERIPHERAL);
 		else if (!fsm->b_conn && !fsm->transceiver->host->b_hnp_enable)
-			otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
+			otg_set_state(fsm, USB_PHY_STATE_A_WAIT_BCON);
 		else if (fsm->a_bus_req || fsm->b_bus_resume)
-			otg_set_state(fsm, OTG_STATE_A_HOST);
+			otg_set_state(fsm, USB_PHY_STATE_A_HOST);
 		else if (fsm->id || fsm->a_bus_drop || fsm->a_aidl_bdis_tmout)
-			otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
+			otg_set_state(fsm, USB_PHY_STATE_A_WAIT_VFALL);
 		else if (!fsm->a_vbus_vld)
-			otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
+			otg_set_state(fsm, USB_PHY_STATE_A_VBUS_ERR);
 		break;
-	case OTG_STATE_A_PERIPHERAL:
+	case USB_PHY_STATE_A_PERIPHERAL:
 		if (fsm->id || fsm->a_bus_drop)
-			otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
+			otg_set_state(fsm, USB_PHY_STATE_A_WAIT_VFALL);
 		else if (fsm->b_bus_suspend)
-			otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
+			otg_set_state(fsm, USB_PHY_STATE_A_WAIT_BCON);
 		else if (!fsm->a_vbus_vld)
-			otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
+			otg_set_state(fsm, USB_PHY_STATE_A_VBUS_ERR);
 		break;
-	case OTG_STATE_A_WAIT_VFALL:
+	case USB_PHY_STATE_A_WAIT_VFALL:
 		if (fsm->id || fsm->a_bus_req || (!fsm->a_sess_vld &&
 					!fsm->b_conn))
-			otg_set_state(fsm, OTG_STATE_A_IDLE);
+			otg_set_state(fsm, USB_PHY_STATE_A_IDLE);
 		break;
-	case OTG_STATE_A_VBUS_ERR:
+	case USB_PHY_STATE_A_VBUS_ERR:
 		if (fsm->id || fsm->a_bus_drop || fsm->a_clr_err)
-			otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
+			otg_set_state(fsm, USB_PHY_STATE_A_WAIT_VFALL);
 		break;
 	default:
 		break;
diff --git a/drivers/usb/otg/twl4030-usb.c b/drivers/usb/otg/twl4030-usb.c
index beeecc2..9eed1f3 100644
--- a/drivers/usb/otg/twl4030-usb.c
+++ b/drivers/usb/otg/twl4030-usb.c
@@ -246,7 +246,7 @@ twl4030_usb_clear_bits(struct twl4030_usb *twl, u8 reg, u8 bits)
 
 /*-------------------------------------------------------------------------*/
 
-static enum usb_xceiv_events twl4030_usb_linkstat(struct twl4030_usb *twl)
+static enum usb_phy_events twl4030_usb_linkstat(struct twl4030_usb *twl)
 {
 	int	status;
 	int	linkstat = USB_EVENT_NONE;
@@ -291,10 +291,10 @@ static enum usb_xceiv_events twl4030_usb_linkstat(struct twl4030_usb *twl)
 	twl->linkstat = linkstat;
 	if (linkstat == USB_EVENT_ID) {
 		twl->otg.default_a = true;
-		twl->otg.state = OTG_STATE_A_IDLE;
+		twl->otg.state = USB_PHY_STATE_A_IDLE;
 	} else {
 		twl->otg.default_a = false;
-		twl->otg.state = OTG_STATE_B_IDLE;
+		twl->otg.state = USB_PHY_STATE_B_IDLE;
 	}
 	spin_unlock_irq(&twl->lock);
 
@@ -571,7 +571,7 @@ static int twl4030_set_peripheral(struct usb_phy *x,
 	twl = xceiv_to_twl(x);
 	twl->otg.gadget = gadget;
 	if (!gadget)
-		twl->otg.state = OTG_STATE_UNDEFINED;
+		twl->otg.state = USB_PHY_STATE_UNDEFINED;
 
 	return 0;
 }
@@ -586,7 +586,7 @@ static int twl4030_set_host(struct usb_phy *x, struct usb_bus *host)
 	twl = xceiv_to_twl(x);
 	twl->otg.host = host;
 	if (!host)
-		twl->otg.state = OTG_STATE_UNDEFINED;
+		twl->otg.state = USB_PHY_STATE_UNDEFINED;
 
 	return 0;
 }
diff --git a/drivers/usb/otg/twl6030-usb.c b/drivers/usb/otg/twl6030-usb.c
index 56c4d3d..2f5c299 100644
--- a/drivers/usb/otg/twl6030-usb.c
+++ b/drivers/usb/otg/twl6030-usb.c
@@ -269,7 +269,7 @@ static irqreturn_t twl6030_usb_irq(int irq, void *_twl)
 			twl->asleep = 1;
 			status = USB_EVENT_VBUS;
 			twl->otg.default_a = false;
-			twl->otg.state = OTG_STATE_B_IDLE;
+			twl->otg.state = USB_PHY_STATE_B_IDLE;
 			twl->linkstat = status;
 			twl->otg.last_event = status;
 			atomic_notifier_call_chain(&twl->otg.notifier,
@@ -308,7 +308,7 @@ static irqreturn_t twl6030_usbotg_irq(int irq, void *_twl)
 								0x10);
 		status = USB_EVENT_ID;
 		twl->otg.default_a = true;
-		twl->otg.state = OTG_STATE_A_IDLE;
+		twl->otg.state = USB_PHY_STATE_A_IDLE;
 		twl->linkstat = status;
 		twl->otg.last_event = status;
 		atomic_notifier_call_chain(&twl->otg.notifier, status,
@@ -335,7 +335,7 @@ static int twl6030_set_peripheral(struct usb_phy *x,
 	twl = xceiv_to_twl(x);
 	twl->otg.gadget = gadget;
 	if (!gadget)
-		twl->otg.state = OTG_STATE_UNDEFINED;
+		twl->otg.state = USB_PHY_STATE_UNDEFINED;
 
 	return 0;
 }
@@ -396,7 +396,7 @@ static int twl6030_set_host(struct usb_phy *x, struct usb_bus *host)
 	twl = xceiv_to_twl(x);
 	twl->otg.host = host;
 	if (!host)
-		twl->otg.state = OTG_STATE_UNDEFINED;
+		twl->otg.state = USB_PHY_STATE_UNDEFINED;
 	return 0;
 }
 
diff --git a/include/linux/usb/msm_hsusb.h b/include/linux/usb/msm_hsusb.h
index 2d3547a..e25ee7a 100644
--- a/include/linux/usb/msm_hsusb.h
+++ b/include/linux/usb/msm_hsusb.h
@@ -133,7 +133,7 @@ struct msm_otg_platform_data {
 	enum otg_control_type otg_control;
 	enum usb_mode_type default_mode;
 	enum msm_usb_phy_type phy_type;
-	void (*setup_gpio)(enum usb_otg_state state);
+	void (*setup_gpio)(enum usb_phy_state state);
 	char *pclk_src_name;
 };
 
diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h
index e0bc557..926e04c 100644
--- a/include/linux/usb/otg.h
+++ b/include/linux/usb/otg.h
@@ -12,30 +12,30 @@
 #include <linux/notifier.h>
 
 /* OTG defines lots of enumeration states before device reset */
-enum usb_otg_state {
-	OTG_STATE_UNDEFINED = 0,
+enum usb_phy_state {
+	USB_PHY_STATE_UNDEFINED = 0,
 
 	/* single-role peripheral, and dual-role default-b */
-	OTG_STATE_B_IDLE,
-	OTG_STATE_B_SRP_INIT,
-	OTG_STATE_B_PERIPHERAL,
+	USB_PHY_STATE_B_IDLE,
+	USB_PHY_STATE_B_SRP_INIT,
+	USB_PHY_STATE_B_PERIPHERAL,
 
 	/* extra dual-role default-b states */
-	OTG_STATE_B_WAIT_ACON,
-	OTG_STATE_B_HOST,
+	USB_PHY_STATE_B_WAIT_ACON,
+	USB_PHY_STATE_B_HOST,
 
 	/* dual-role default-a */
-	OTG_STATE_A_IDLE,
-	OTG_STATE_A_WAIT_VRISE,
-	OTG_STATE_A_WAIT_BCON,
-	OTG_STATE_A_HOST,
-	OTG_STATE_A_SUSPEND,
-	OTG_STATE_A_PERIPHERAL,
-	OTG_STATE_A_WAIT_VFALL,
-	OTG_STATE_A_VBUS_ERR,
+	USB_PHY_STATE_A_IDLE,
+	USB_PHY_STATE_A_WAIT_VRISE,
+	USB_PHY_STATE_A_WAIT_BCON,
+	USB_PHY_STATE_A_HOST,
+	USB_PHY_STATE_A_SUSPEND,
+	USB_PHY_STATE_A_PERIPHERAL,
+	USB_PHY_STATE_A_WAIT_VFALL,
+	USB_PHY_STATE_A_VBUS_ERR,
 };
 
-enum usb_xceiv_events {
+enum usb_phy_events {
 	USB_EVENT_NONE,         /* no events or cable disconnected */
 	USB_EVENT_VBUS,         /* vbus valid event */
 	USB_EVENT_ID,           /* id was grounded */
@@ -65,8 +65,8 @@ struct usb_phy {
 	unsigned int		 flags;
 
 	u8			default_a;
-	enum usb_otg_state	state;
-	enum usb_xceiv_events	last_event;
+	enum usb_phy_state	state;
+	enum usb_phy_events	last_event;
 
 	struct usb_bus		*host;
 	struct usb_gadget	*gadget;
@@ -74,7 +74,7 @@ struct usb_phy {
 	struct otg_io_access_ops	*io_ops;
 	void __iomem			*io_priv;
 
-	/* for notification of usb_xceiv_events */
+	/* for notification of usb_phy_events */
 	struct atomic_notifier_head	notifier;
 
 	/* to pass extra port status to the root hub */
@@ -168,7 +168,7 @@ otg_shutdown(struct usb_phy *x)
 #ifdef CONFIG_USB_OTG_UTILS
 extern struct usb_phy *otg_get_transceiver(void);
 extern void otg_put_transceiver(struct usb_phy *);
-extern const char *otg_state_string(enum usb_otg_state state);
+extern const char *usb_phy_state_string(enum usb_phy_state state);
 #else
 static inline struct usb_phy *otg_get_transceiver(void)
 {
@@ -179,7 +179,7 @@ static inline void otg_put_transceiver(struct usb_phy *x)
 {
 }
 
-static inline const char *otg_state_string(enum usb_otg_state state)
+static inline const char *usb_phy_state_string(enum usb_phy_state state)
 {
 	return NULL;
 }
-- 
1.7.5.4

--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html


[Index of Archives]     [Linux Media]     [Linux Input]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]     [Old Linux USB Devel Archive]

  Powered by Linux