ENGR00216081-1:Add USB host and gadget PM support

Handle usb suspend/resume, currently the BSP doesn't
support usb plug/unplug wakeup.

Signed-off-by: Jingchang Lu <b35083@freescale.com>

9 files changed, 437 insertions, 64 deletions

diff --git a/arch/arm/mach-mvf/board-twr-vf700.c b/arch/arm/mach-mvf/board-twr-vf700.c
index d9d0ff6161dd..a267df7a303f 100644
--- a/arch/arm/mach-mvf/board-twr-vf700.c
+++ b/arch/arm/mach-mvf/board-twr-vf700.c
@@ -435,12 +435,12 @@ static void __init mvf_twr_init_usb(void)
 {
 	imx_otg_base = MVF_IO_ADDRESS(MVF_USBC0_BASE_ADDR);
 	/*mvf_set_otghost_vbus_func(mvf_twr_usbotg_vbus);*/
-#ifdef CONFIG_USB_GADGET_ARC
-	mvf_usb_dr_init();
-#endif
 #ifdef CONFIG_USB_EHCI_ARC
 	mvf_usb_dr2_init();
 #endif
+#ifdef CONFIG_USB_GADGET_ARC
+	mvf_usb_dr_init();
+#endif
 }
 
 /*!
diff --git a/arch/arm/mach-mvf/devices-mvf.h b/arch/arm/mach-mvf/devices-mvf.h
index 61792fb34530..b8bea993bdee 100644
--- a/arch/arm/mach-mvf/devices-mvf.h
+++ b/arch/arm/mach-mvf/devices-mvf.h
@@ -69,9 +69,11 @@ extern const struct imx_fsl_usb2_otg_data mvf_fsl_usb2_otg_data __initconst;
 	imx_add_fsl_usb2_otg(&mvf_fsl_usb2_otg_data, pdata)
 
 extern
-const struct imx_fsl_usb2_wakeup_data mvf_fsl_otg_wakeup_data __initconst;
-#define mvf_add_fsl_usb2_otg_wakeup(pdata)	\
-	imx_add_fsl_usb2_wakeup(&mvf_fsl_otg_wakeup_data, pdata)
+const struct imx_fsl_usb2_wakeup_data mvf_fsl_otg_wakeup_data[] __initconst;
+#define mvf_add_fsl_usb2_ehci_otg_wakeup(pdata)	\
+	imx_add_fsl_usb2_wakeup(&mvf_fsl_otg_wakeup_data[1], pdata)
+#define mvf_add_fsl_usb2_udc_wakeup(pdata) \
+	imx_add_fsl_usb2_wakeup(&mvf_fsl_otg_wakeup_data[0], pdata)
 
 extern
 const struct imx_fsl_usb2_wakeup_data mvf_fsl_hs_wakeup_data[] __initconst;
diff --git a/arch/arm/mach-mvf/usb_dr.c b/arch/arm/mach-mvf/usb_dr.c
index 2467acc1bf28..bbd29f3b45a9 100644
--- a/arch/arm/mach-mvf/usb_dr.c
+++ b/arch/arm/mach-mvf/usb_dr.c
@@ -35,6 +35,7 @@ static int usbotg_init_ext(struct platform_device *pdev);
 static void usbotg_uninit_ext(struct platform_device *pdev);
 static void usbotg_clock_gate(bool on);
 static void _dr_discharge_line(bool enable);
+static void usbotg_wakeup_event_clear(void);
 
 /* The usb_phy0_clk do not have enable/disable function at clock.c
  * and PLL output for usb0's phy should be always enabled.
@@ -62,6 +63,13 @@ static struct fsl_usb2_platform_data dr_utmi_config = {
 	.dr_discharge_line = _dr_discharge_line,
 };
 
+/* Platform data for wakeup operation */
+static struct fsl_usb2_wakeup_platform_data dr_wakeup_config = {
+	.name = "Gadget wakeup",
+	.usb_clock_for_pm  = usbotg_clock_gate,
+	.usb_wakeup_exhandle = usbotg_wakeup_event_clear,
+};
+
 static void usbotg_internal_phy_clock_gate(bool on)
 {
 	u32 reg;
@@ -183,25 +191,213 @@ static void _dr_discharge_line(bool enable)
 /* Below two macros are used at otg mode to indicate usb mode*/
 #define ENABLED_BY_HOST   (0x1 << 0)
 #define ENABLED_BY_DEVICE (0x1 << 1)
+static u32 low_power_enable_src; /* only useful at otg mode */
+static void enter_phy_lowpower_suspend(struct fsl_usb2_platform_data *pdata,
+					bool enable)
+{
+	void __iomem *phy_reg = MVF_IO_ADDRESS(MVF_USBPHY0_BASE_ADDR);
+	u32 tmp;
+	pr_debug("DR: %s begins, enable is %d\n", __func__, enable);
+
+	if (enable) {
+		UOG_PORTSC1 |= PORTSC_PHCD;
+		tmp = (BM_USBPHY_PWD_TXPWDFS
+			| BM_USBPHY_PWD_TXPWDIBIAS
+			| BM_USBPHY_PWD_TXPWDV2I
+			| BM_USBPHY_PWD_RXPWDENV
+			| BM_USBPHY_PWD_RXPWD1PT1
+			| BM_USBPHY_PWD_RXPWDDIFF
+			| BM_USBPHY_PWD_RXPWDRX);
+		__raw_writel(tmp, phy_reg + HW_USBPHY_PWD_SET);
+		usbotg_internal_phy_clock_gate(false);
+
+	} else {
+		if (UOG_PORTSC1 & PORTSC_PHCD) {
+			UOG_PORTSC1 &= ~PORTSC_PHCD;
+			mdelay(1);
+		}
+		usbotg_internal_phy_clock_gate(true);
+		tmp = (BM_USBPHY_PWD_TXPWDFS
+			| BM_USBPHY_PWD_TXPWDIBIAS
+			| BM_USBPHY_PWD_TXPWDV2I
+			| BM_USBPHY_PWD_RXPWDENV
+			| BM_USBPHY_PWD_RXPWD1PT1
+			| BM_USBPHY_PWD_RXPWDDIFF
+			| BM_USBPHY_PWD_RXPWDRX);
+		__raw_writel(tmp, phy_reg + HW_USBPHY_PWD_CLR);
+
+	}
+	pr_debug("DR: %s ends, enable is %d\n", __func__, enable);
+}
+
+static void __phy_lowpower_suspend(struct fsl_usb2_platform_data *pdata,
+					bool enable, int source)
+{
+	if (enable) {
+		low_power_enable_src |= source;
+		enter_phy_lowpower_suspend(pdata, enable);
+	} else {
+		enter_phy_lowpower_suspend(pdata, enable);
+		low_power_enable_src &= ~source;
+	}
+}
+
+static void otg_wake_up_enable(struct fsl_usb2_platform_data *pdata,
+				bool enable)
+{
+	void __iomem *phy_reg = MVF_IO_ADDRESS(MVF_USBPHY0_BASE_ADDR);
+
+	pr_debug("%s, enable is %d\n", __func__, enable);
+	if (enable) {
+		__raw_writel(BM_USBPHY_CTRL_ENIDCHG_WKUP
+				| BM_USBPHY_CTRL_ENVBUSCHG_WKUP
+				| BM_USBPHY_CTRL_ENDPDMCHG_WKUP
+				| BM_USBPHY_CTRL_ENAUTOSET_USBCLKS
+				| BM_USBPHY_CTRL_ENAUTOCLR_PHY_PWD
+				| BM_USBPHY_CTRL_ENAUTOCLR_CLKGATE
+				| BM_USBPHY_CTRL_ENAUTOCLR_USBCLKGATE
+				| BM_USBPHY_CTRL_ENAUTO_PWRON_PLL,
+				phy_reg + HW_USBPHY_CTRL_SET);
+		USBC0_CTRL |= UCTRL_OWIE;
+	} else {
+		USBC0_CTRL &= ~UCTRL_OWIE;
+		/* The interrupt must be disabled for at least 3 clock
+		 * cycles of the standby clock(32k Hz) , that is 0.094 ms*/
+		udelay(100);
+	}
+}
+
+static void __wakeup_irq_enable(struct fsl_usb2_platform_data *pdata,
+				bool on, int source)
+{
+	/* otg host and device share the OWIE bit, only when host and device
+	 * all enable the wakeup irq, we can enable the OWIE bit
+	 */
+	 if (on) {
+		otg_wake_up_enable(pdata, on);
+	} else {
+		otg_wake_up_enable(pdata, on);
+		/* The interrupt must be disabled for at least 3 clock
+		 * cycles of the standby clock(32k Hz) , that is 0.094 ms*/
+		udelay(100);
+	}
+}
+
+/* The wakeup operation for DR port, it will clear the wakeup irq status
+ * and re-enable the wakeup
+ */
+static void usbotg_wakeup_event_clear(void)
+{
+	int wakeup_req = USBC0_CTRL & UCTRL_OWIR;
+
+	if (wakeup_req != 0) {
+		pr_debug("Unknown wakeup.(OTGSC 0x%x)\n", UOG_OTGSC);
+		/* Disable OWIE to clear OWIR, wait 3 clock
+		 * cycles of standly clock(32KHz)
+		 */
+		USBC0_CTRL &= ~UCTRL_OWIE;
+		udelay(100);
+		USBC0_CTRL |= UCTRL_OWIE;
+	}
+}
 
+/* End of Common operation for DR port */
 #ifdef CONFIG_USB_EHCI_ARC_OTG
 #endif /* CONFIG_USB_EHCI_ARC_OTG */
 
 
 #ifdef CONFIG_USB_GADGET_ARC
+/* Beginning of device related operation for DR port */
+static void _device_phy_lowpower_suspend(struct fsl_usb2_platform_data *pdata,
+					bool enable)
+{
+	__phy_lowpower_suspend(pdata, enable, ENABLED_BY_DEVICE);
+}
+
+static void _device_wakeup_enable(struct fsl_usb2_platform_data *pdata,
+				bool enable)
+{
+	__wakeup_irq_enable(pdata, enable, ENABLED_BY_DEVICE);
+	if (enable) {
+		pr_debug("device wakeup enable\n");
+		device_wakeup_enable(&pdata->pdev->dev);
+	} else {
+		pr_debug("device wakeup disable\n");
+		device_wakeup_disable(&pdata->pdev->dev);
+	}
+}
+
+static enum usb_wakeup_event
+_is_device_wakeup(struct fsl_usb2_platform_data *pdata)
+{
+	int wakeup_req = USBC0_CTRL & UCTRL_OWIR;
+
+	/* if ID=1, it is a device wakeup event */
+	if (wakeup_req && (UOG_OTGSC & OTGSC_STS_USB_ID) &&
+			(UOG_USBSTS & USBSTS_URI)) {
+		printk(KERN_INFO "otg udc wakeup, host sends reset signal\n");
+		return WAKEUP_EVENT_DPDM;
+	}
+	if (wakeup_req && (UOG_OTGSC & OTGSC_STS_USB_ID) &&  \
+		((UOG_USBSTS & USBSTS_PCI) ||
+		 (UOG_PORTSC1 & PORTSC_PORT_FORCE_RESUME))) {
+		/*
+		 * When the line state from J to K, the Port Change Detect bit
+		 * in the USBSTS register is also set to '1'.
+		 */
+		printk(KERN_INFO "otg udc wakeup, host sends resume signal\n");
+		return WAKEUP_EVENT_DPDM;
+	}
+	if (wakeup_req && (UOG_OTGSC & OTGSC_STS_USB_ID) &&
+			(UOG_OTGSC & OTGSC_STS_A_VBUS_VALID) &&
+			(UOG_OTGSC & OTGSC_IS_B_SESSION_VALID)) {
+		printk(KERN_INFO "otg udc vbus rising wakeup\n");
+		return WAKEUP_EVENT_VBUS;
+	}
+	if (wakeup_req && (UOG_OTGSC & OTGSC_STS_USB_ID) &&
+			!(UOG_OTGSC & OTGSC_STS_A_VBUS_VALID)) {
+		printk(KERN_INFO "otg udc vbus falling wakeup\n");
+		return WAKEUP_EVENT_VBUS;
+	}
+
+	return WAKEUP_EVENT_DPDM;
+}
+
+static void device_wakeup_handler(struct fsl_usb2_platform_data *pdata)
+{
+	_device_phy_lowpower_suspend(pdata, false);
+	_device_wakeup_enable(pdata, false);
+}
+/* end of device related operation for DR port */
 #endif /* CONFIG_USB_GADGET_ARC */
 
 void __init mvf_usb_dr_init(void)
 {
-	struct platform_device *pdev;
+	struct platform_device *pdev, *pdev_wakeup;
 	u32 reg;
 #ifdef CONFIG_USB_GADGET_ARC
 	dr_utmi_config.operating_mode = DR_UDC_MODE;
+	dr_utmi_config.wake_up_enable = _device_wakeup_enable;
 	dr_utmi_config.platform_suspend = NULL;
 	dr_utmi_config.platform_resume  = NULL;
+	dr_utmi_config.phy_lowpower_suspend = _device_phy_lowpower_suspend;
+	dr_utmi_config.is_wakeup_event = _is_device_wakeup;
+	dr_utmi_config.wakeup_pdata = &dr_wakeup_config;
+	dr_utmi_config.wakeup_handler = device_wakeup_handler;
 
 	pdev = mvf_add_fsl_usb2_udc(&dr_utmi_config);
 
+	dr_wakeup_config.usb_pdata[2] = pdev->dev.platform_data;
+
+	/* register wakeup device */
+	pdev_wakeup = mvf_add_fsl_usb2_udc_wakeup(&dr_wakeup_config);
+	if (pdev != NULL)
+		((struct fsl_usb2_platform_data *)
+			(pdev->dev.platform_data))->wakeup_pdata =
+				(struct fsl_usb2_wakeup_platform_data *)
+					(pdev_wakeup->dev.platform_data);
+
+	device_set_wakeup_capable(&pdev->dev, true);
 	__raw_writel(((0x01 << 30) | 0x2), ANADIG_USB1_MISC);
 
 	__raw_writel(0x00000894, USBPHY1_CTRL);
diff --git a/arch/arm/mach-mvf/usb_dr2.c b/arch/arm/mach-mvf/usb_dr2.c
index d26cfde125e0..67e3fcdbc921 100644
--- a/arch/arm/mach-mvf/usb_dr2.c
+++ b/arch/arm/mach-mvf/usb_dr2.c
@@ -20,6 +20,7 @@
 #include <linux/types.h>
 #include <linux/clk.h>
 #include <linux/platform_device.h>
+#include <linux/pm_wakeup.h>
 #include <linux/fsl_devices.h>
 #include <linux/delay.h>
 #include <linux/io.h>
@@ -35,6 +36,7 @@ static int usbotg2_init_ext(struct platform_device *pdev);
 static void usbotg2_uninit_ext(struct platform_device *pdev);
 static void usbotg_clock_gate(bool on);
 static void _dr_discharge_line(bool enable);
+static void usbotg_wakeup_event_clear(void);
 
 static struct clk *usb_phy1_clk;
 static u8 otg2_used;
@@ -58,6 +60,13 @@ static struct fsl_usb2_platform_data dr_utmi_config = {
 	.dr_discharge_line = _dr_discharge_line,
 };
 
+/* Platform data for wakeup operation */
+static struct fsl_usb2_wakeup_platform_data dr_wakeup_config = {
+	.name = "Host wakeup",
+	.usb_clock_for_pm  = usbotg_clock_gate,
+	.usb_wakeup_exhandle = usbotg_wakeup_event_clear,
+};
+
 static void usbotg_internal_phy_clock_gate(bool on)
 {
 	void __iomem *phy_reg = MVF_IO_ADDRESS(MVF_USBPHY1_BASE_ADDR);
@@ -181,6 +190,113 @@ static void _dr_discharge_line(bool enable)
 /* Below two macros are used at otg mode to indicate usb mode*/
 #define ENABLED_BY_HOST   (0x1 << 0)
 #define ENABLED_BY_DEVICE (0x1 << 1)
+static void enter_phy_lowpower_suspend(struct fsl_usb2_platform_data *pdata,
+					bool enable)
+{
+	void __iomem *phy_reg = MVF_IO_ADDRESS(MVF_USBPHY1_BASE_ADDR);
+	u32 tmp;
+	pr_debug("DR: %s begins, enable is %d\n", __func__, enable);
+
+	if (enable) {
+		UOG2_PORTSC1 |= PORTSC_PHCD;
+		tmp = (BM_USBPHY_PWD_TXPWDFS
+			| BM_USBPHY_PWD_TXPWDIBIAS
+			| BM_USBPHY_PWD_TXPWDV2I
+			| BM_USBPHY_PWD_RXPWDENV
+			| BM_USBPHY_PWD_RXPWD1PT1
+			| BM_USBPHY_PWD_RXPWDDIFF
+			| BM_USBPHY_PWD_RXPWDRX);
+		__raw_writel(tmp, phy_reg + HW_USBPHY_PWD_SET);
+		usbotg_internal_phy_clock_gate(false);
+
+	} else {
+		if (UOG2_PORTSC1 & PORTSC_PHCD) {
+			UOG2_PORTSC1 &= ~PORTSC_PHCD;
+			mdelay(1);
+		}
+		usbotg_internal_phy_clock_gate(true);
+		tmp = (BM_USBPHY_PWD_TXPWDFS
+			| BM_USBPHY_PWD_TXPWDIBIAS
+			| BM_USBPHY_PWD_TXPWDV2I
+			| BM_USBPHY_PWD_RXPWDENV
+			| BM_USBPHY_PWD_RXPWD1PT1
+			| BM_USBPHY_PWD_RXPWDDIFF
+			| BM_USBPHY_PWD_RXPWDRX);
+		__raw_writel(tmp, phy_reg + HW_USBPHY_PWD_CLR);
+
+	}
+	pr_debug("DR: %s ends, enable is %d\n", __func__, enable);
+}
+
+static void __phy_lowpower_suspend(struct fsl_usb2_platform_data *pdata,
+					bool enable, int source)
+{
+	if (enable)
+		enter_phy_lowpower_suspend(pdata, enable);
+	else {
+		pr_debug("phy lowpower disable\n");
+		enter_phy_lowpower_suspend(pdata, enable);
+	}
+}
+
+static void otg_wake_up_enable(struct fsl_usb2_platform_data *pdata,
+				bool enable)
+{
+	void __iomem *phy_reg = MVF_IO_ADDRESS(MVF_USBPHY1_BASE_ADDR);
+
+	pr_debug("%s, enable is %d\n", __func__, enable);
+	if (enable) {
+		__raw_writel(BM_USBPHY_CTRL_ENIDCHG_WKUP
+				| BM_USBPHY_CTRL_ENVBUSCHG_WKUP
+				| BM_USBPHY_CTRL_ENDPDMCHG_WKUP
+				| BM_USBPHY_CTRL_ENAUTOSET_USBCLKS
+				| BM_USBPHY_CTRL_ENAUTOCLR_PHY_PWD
+				| BM_USBPHY_CTRL_ENAUTOCLR_CLKGATE
+				| BM_USBPHY_CTRL_ENAUTOCLR_USBCLKGATE
+				| BM_USBPHY_CTRL_ENAUTO_PWRON_PLL,
+				phy_reg + HW_USBPHY_CTRL_SET);
+		USBC1_CTRL |= UCTRL_OWIE;
+	} else {
+		USBC1_CTRL &= ~UCTRL_OWIE;
+		/* The interrupt must be disabled for at least 3 clock
+		 * cycles of the standby clock(32k Hz) , that is 0.094 ms*/
+		udelay(100);
+	}
+}
+
+static void __wakeup_irq_enable(struct fsl_usb2_platform_data *pdata,
+				bool on, int source)
+{
+	pr_debug("USB Host %s,on=%d\n", __func__, on);
+	mdelay(3);
+	if (on) {
+		otg_wake_up_enable(pdata, on);
+	} else {
+		otg_wake_up_enable(pdata, on);
+		/* The interrupt must be disabled for at least 3 clock
+		 * cycles of the standby clock(32k Hz) , that is 0.094 ms*/
+		udelay(100);
+	}
+}
+
+/* The wakeup operation for DR port, it will clear the wakeup irq status
+ * and re-enable the wakeup
+ */
+static void usbotg_wakeup_event_clear(void)
+{
+	int wakeup_req = USBC1_CTRL & UCTRL_OWIR;
+
+	if (wakeup_req != 0) {
+		pr_debug("Unknown wakeup.(OTGSC 0x%x)\n", UOG_OTGSC);
+		/* Disable OWIE to clear OWIR, wait 3 clock
+		 * cycles of standly clock(32KHz)
+		 */
+		USBC1_CTRL &= ~UCTRL_OWIE;
+		udelay(100);
+		USBC1_CTRL |= UCTRL_OWIE;
+	}
+}
+
 /* End of Common operation for DR port */
 
 #ifdef CONFIG_USB_EHCI_ARC_OTG
@@ -215,22 +331,85 @@ static void _host_platform_resume(struct fsl_usb2_platform_data *pdata)
 	__raw_writel(tmp, phy_reg + HW_USBPHY_PWD_CLR);
 }
 
+static void _host_phy_lowpower_suspend(struct fsl_usb2_platform_data *pdata,
+					bool enable)
+{
+	__phy_lowpower_suspend(pdata, enable, ENABLED_BY_HOST);
+}
+
+static void _host_wakeup_enable(struct fsl_usb2_platform_data *pdata,
+				bool enable)
+{
+	__wakeup_irq_enable(pdata, enable, ENABLED_BY_HOST);
+
+	if (enable)
+		device_wakeup_enable(&pdata->pdev->dev);
+	else
+		device_wakeup_disable(&pdata->pdev->dev);
+}
+
+static enum usb_wakeup_event
+_is_host_wakeup(struct fsl_usb2_platform_data *pdata)
+{
+	u32 wakeup_req = USBC1_CTRL & UCTRL_OWIR;
+	u32 otgsc = UOG2_OTGSC;
+
+	if (wakeup_req) {
+		pr_debug("the otgsc is 0x%x, usbsts is 0x%x,"
+			" portsc is 0x%x, wakeup_irq is 0x%x\n",
+			UOG2_OTGSC, UOG2_USBSTS, UOG2_PORTSC1, wakeup_req);
+	}
+	/* if ID change sts, it is a host wakeup event */
+	if (wakeup_req && (otgsc & OTGSC_IS_USB_ID)) {
+		pr_debug("otg host ID wakeup\n");
+		/* if host ID wakeup, we must clear the b session change sts */
+		otgsc &= (~OTGSC_IS_USB_ID);
+		return WAKEUP_EVENT_ID;
+	}
+	if (wakeup_req  && (!(otgsc & OTGSC_STS_USB_ID))) {
+		pr_debug("otg host Remote wakeup\n");
+		return WAKEUP_EVENT_DPDM;
+	}
+	return WAKEUP_EVENT_INVALID;
+}
+
+static void host_wakeup_handler(struct fsl_usb2_platform_data *pdata)
+{
+	_host_phy_lowpower_suspend(pdata, false);
+	_host_wakeup_enable(pdata, false);
+}
+
 /* End of host related operation for DR port */
 #endif /* CONFIG_USB_EHCI_ARC_OTG */
 
 
 void __init mvf_usb_dr2_init(void)
 {
-	struct platform_device *pdev;
+	struct platform_device *pdev, *pdev_wakeup;
 	u32 reg;
 
 #ifdef CONFIG_USB_EHCI_ARC_OTG
 	dr_utmi_config.operating_mode = DR_HOST_MODE;
+	dr_utmi_config.wake_up_enable = _host_wakeup_enable;
 	dr_utmi_config.platform_suspend = _host_platform_suspend;
 	dr_utmi_config.platform_resume  = _host_platform_resume;
+	dr_utmi_config.phy_lowpower_suspend = _host_phy_lowpower_suspend;
+	dr_utmi_config.is_wakeup_event = _is_host_wakeup;
+	dr_utmi_config.wakeup_pdata = &dr_wakeup_config;
+	dr_utmi_config.wakeup_handler = host_wakeup_handler;
 
 	pdev = mvf_add_fsl_ehci_otg(&dr_utmi_config);
 
+	dr_wakeup_config.usb_pdata[1] = pdev->dev.platform_data;
+
+	/* register wakeup device */
+	pdev_wakeup = mvf_add_fsl_usb2_ehci_otg_wakeup(&dr_wakeup_config);
+	if (pdev != NULL)
+		((struct fsl_usb2_platform_data *)
+			(pdev->dev.platform_data))->wakeup_pdata =
+				(struct fsl_usb2_wakeup_platform_data *)
+					(pdev_wakeup->dev.platform_data);
+
 	__raw_writel(0x0220C802, USBPHY2_CTRL);
 	udelay(20);
 
diff --git a/arch/arm/plat-mxc/devices/platform-fsl-usb2-wakeup.c b/arch/arm/plat-mxc/devices/platform-fsl-usb2-wakeup.c
index 523c5d4599e1..957c96a7996e 100644
--- a/arch/arm/plat-mxc/devices/platform-fsl-usb2-wakeup.c
+++ b/arch/arm/plat-mxc/devices/platform-fsl-usb2-wakeup.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Copyright (C) 2011-2012 Freescale Semiconductor, Inc.
  *
  * Copyright (C) 2010 Pengutronix
  * Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>
@@ -26,6 +26,21 @@ const struct imx_fsl_usb2_wakeup_data imx6q_fsl_hs_wakeup_data[] __initconst = {
 	imx_fsl_usb2_wakeup_data_entry_single(MX6Q, 3, HS3),
 };
 #endif /* ifdef CONFIG_SOC_IMX6Q */
+#ifdef CONFIG_SOC_MVFA5
+const struct imx_fsl_usb2_wakeup_data mvf_fsl_otg_wakeup_data[] __initconst = {
+	{
+		.id = 0,
+		.irq_phy = MVF_INT_USBOTG0,
+		.irq_core = MVF_INT_USBOTG0,
+	},
+	{
+		.id = 1,
+		.irq_phy = MVF_INT_USB2,
+		.irq_core = MVF_INT_USB2,
+	}
+};
+
+#endif
 
 struct platform_device *__init imx_add_fsl_usb2_wakeup(
 		const struct imx_fsl_usb2_wakeup_data *data,
diff --git a/arch/arm/plat-mxc/usb_common.c b/arch/arm/plat-mxc/usb_common.c
index 0aa3d590d1d2..96cede81d319 100755
--- a/arch/arm/plat-mxc/usb_common.c
+++ b/arch/arm/plat-mxc/usb_common.c
@@ -1049,6 +1049,9 @@ EXPORT_SYMBOL(usb_debounce_id_vbus);
 
 int usb_event_is_otg_wakeup(struct fsl_usb2_platform_data *pdata)
 {
+#ifdef CONFIG_ARCH_MVF
+	return false;
+#endif
 	return (USBCTRL & UCTRL_OWIR) ? true : false;
 }
 EXPORT_SYMBOL(usb_event_is_otg_wakeup);
diff --git a/arch/arm/plat-mxc/usb_wakeup.c b/arch/arm/plat-mxc/usb_wakeup.c
index 4704eae91a51..7187eff67426 100755
--- a/arch/arm/plat-mxc/usb_wakeup.c
+++ b/arch/arm/plat-mxc/usb_wakeup.c
@@ -36,7 +36,8 @@ struct wakeup_ctrl {
 	struct task_struct *thread;
 	struct completion  event;
 };
-static struct wakeup_ctrl *g_ctrl;
+static struct wakeup_ctrl *g_ctrl[2];
+static unsigned int g_ctrls;
 
 extern int usb_event_is_otg_wakeup(struct fsl_usb2_platform_data *pdata);
 extern void usb_debounce_id_vbus(void);
@@ -166,7 +167,7 @@ static int wakeup_dev_probe(struct platform_device *pdev)
 	int status;
 	unsigned long interrupt_flag;
 
-	printk(KERN_INFO "IMX usb wakeup probe\n");
+	printk(KERN_INFO "IMX usb wakeup probe. id=%d\n", pdev->id);
 
 	if (!pdev || !pdev->dev.platform_data)
 		return -ENODEV;
@@ -192,11 +193,12 @@ static int wakeup_dev_probe(struct platform_device *pdev)
 	if (status)
 		goto error1;
 
-	ctrl->thread = kthread_run(wakeup_event_thread, (void *)ctrl, "usb_wakeup thread");
+	ctrl->thread = kthread_run(wakeup_event_thread, (void *)ctrl,
+					"usb_wakeup:%d", pdev->id);
 	status = IS_ERR(ctrl->thread) ? -1 : 0;
 	if (status)
 		goto error2;
-	g_ctrl = ctrl;
+	g_ctrl[g_ctrls++] = ctrl;
 
 	printk(KERN_DEBUG "the wakeup pdata is 0x%p\n", pdata);
 	return 0;
@@ -209,12 +211,17 @@ error1:
 
 static int  wakeup_dev_exit(struct platform_device *pdev)
 {
-	if (g_ctrl->thread) {
-		complete(&g_ctrl->event);
-		kthread_stop(g_ctrl->thread);
+	int i;
+	for (i = 0; i < g_ctrls; i++) {
+		if (g_ctrl[i]->thread) {
+			complete(&g_ctrl[i]->event);
+			kthread_stop(g_ctrl[i]->thread);
+		}
+		free_irq(g_ctrl[i]->wakeup_irq, (void *)g_ctrl[i]);
+		kfree(g_ctrl[i]);
+		g_ctrl[i] = NULL;
+		g_ctrls = 0;
 	}
-	free_irq(g_ctrl->wakeup_irq, (void *)g_ctrl);
-	kfree(g_ctrl);
 	return 0;
 }
 static struct platform_driver wakeup_d = {
diff --git a/drivers/usb/gadget/arcotg_udc.c b/drivers/usb/gadget/arcotg_udc.c
index 5a1aab94b405..c7c99cd9f3cb 100755
--- a/drivers/usb/gadget/arcotg_udc.c
+++ b/drivers/usb/gadget/arcotg_udc.c
@@ -3356,9 +3356,15 @@ static int fsl_udc_suspend(struct platform_device *pdev, pm_message_t state)
 			(udc_controller->usb_state > USB_STATE_POWERED) &&
 			(udc_controller->usb_state < USB_STATE_SUSPENDED)) {
 		return -EBUSY;/* keep the clk on */
-	} else
+	} else {
+		if (udc_controller->pdata->wake_up_enable)
+			udc_controller->pdata->wake_up_enable(
+						udc_controller->pdata, true);
 		ret = udc_suspend(udc_controller);
-	dr_clk_gate(false);
+	}
+
+	if (udc_controller->stopped)
+		dr_clk_gate(false);
 
 	printk(KERN_DEBUG "USB Gadget suspend ends\n");
 	return ret;
@@ -3408,6 +3414,8 @@ static int fsl_udc_resume(struct platform_device *pdev)
 	/* prevent the quirk interrupts from resuming */
 	disable_irq_nosync(udc_controller->irq);
 
+	if (pdata->wake_up_enable)
+		pdata->wake_up_enable(pdata, false);
 	/*
 	 * If the controller was stopped at suspend time, then
 	 * don't resume it now.
diff --git a/drivers/usb/host/ehci-arc.c b/drivers/usb/host/ehci-arc.c
index 81ab1cffe374..0f5335d6381e 100755
--- a/drivers/usb/host/ehci-arc.c
+++ b/drivers/usb/host/ehci-arc.c
@@ -670,28 +670,7 @@ static int ehci_fsl_drv_suspend(struct platform_device *pdev,
 	struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
 
 	printk(KERN_DEBUG "USB Host suspend begins\n");
-#ifdef CONFIG_ARCH_MVF
-	if (pdata->suspended) {
-		pr_debug("%s: already suspended, leaving early\n", __func__);
-		pdata->already_suspended = 1;
-		return 0;
-	}
-
-	pr_debug("%s: suspending...\n", __func__);
-
-	hcd->state = HC_STATE_SUSPENDED;
-	pdev->dev.power.power_state = PMSG_SUSPEND;
-
-	/* ignore non-host interrupts */
-	clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-
-	/* stop the controller */
-	tmp = ehci_readl(ehci, &ehci->regs->command);
-	tmp &= ~CMD_RUN;
-	ehci_writel(ehci, tmp, &ehci->regs->command);
 
-	pdata->suspended = 1;
-#else
 	/* Only handles OTG mode switch event, system suspend event will be done in bus suspend */
 	if (pdata->pmflags == 0) {
 		printk(KERN_DEBUG "%s, pm event\n", __func__);
@@ -706,7 +685,7 @@ static int ehci_fsl_drv_suspend(struct platform_device *pdev,
 		printk(KERN_DEBUG "host suspend ends\n");
 		return 0;
 	}
-
+#ifndef CONFIG_ARCH_MVF
 	/* only the otg host can go here */
 	/* wait for all usb device on the hcd dettached */
 	usb_lock_device(roothub);
@@ -740,7 +719,7 @@ static int ehci_fsl_drv_suspend(struct platform_device *pdev,
 		fsl_usb_clk_gate(hcd->self.controller->platform_data, true);
 		set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
 	}
-#endif
+
 	port_status = ehci_readl(ehci, &ehci->regs->port_status[0]);
 	/* save EHCI registers */
 	pdata->pm_command = ehci_readl(ehci, &ehci->regs->command);
@@ -772,6 +751,7 @@ static int ehci_fsl_drv_suspend(struct platform_device *pdev,
 	}
 	pdata->pmflags = 0;
 	printk(KERN_DEBUG "host suspend ends\n");
+#endif
 	return 0;
 }
 
@@ -786,27 +766,13 @@ static int ehci_fsl_drv_resume(struct platform_device *pdev)
 	struct fsl_usb2_wakeup_platform_data *wake_up_pdata = pdata->wakeup_pdata;
 	/* Only handles OTG mode switch event */
 	printk(KERN_DEBUG "ehci fsl drv resume begins: %s\n", pdata->name);
-#ifdef CONFIG_ARCH_MVF
-	if (pdata->already_suspended) {
-		pr_debug("already suspended, leaving early\n");
-		pdata->already_suspended = 0;
-		return 0;
-	}
 
-	if (!pdata->suspended) {
-		pr_debug("not suspended, leaving early\n");
-		return 0;
-	}
-
-	pdata->suspended = 0;
-
-	pr_debug("%s resuming...\n", __func__);
-#else
 	if (pdata->pmflags == 0) {
 		printk(KERN_DEBUG "%s,pm event, wait for wakeup irq if needed\n", __func__);
 		wait_event_interruptible(wake_up_pdata->wq, !wake_up_pdata->usb_wakeup_is_pending);
 		return 0;
 	}
+#ifndef CONFIG_ARCH_MVF
 	if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
 		set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
 		fsl_usb_clk_gate(hcd->self.controller->platform_data, true);
@@ -815,7 +781,7 @@ static int ehci_fsl_drv_resume(struct platform_device *pdev)
 		fsl_usb_lowpower_mode(pdata, false);
 		spin_unlock_irqrestore(&ehci->lock, flags);
 	}
-#endif
+
 	spin_lock_irqsave(&ehci->lock, flags);
 	/* set host mode */
 	fsl_platform_set_host_mode(hcd);
@@ -837,19 +803,16 @@ static int ehci_fsl_drv_resume(struct platform_device *pdev)
 	ehci_writel(ehci, tmp, &ehci->regs->command);
 	spin_unlock_irqrestore(&ehci->lock, flags);
 
-#ifdef CONFIG_ARCH_MVF
-	usb_hcd_resume_root_hub(hcd);
-#else
 	if ((hcd->state & HC_STATE_SUSPENDED)) {
 		printk(KERN_DEBUG "will resume roothub and its children\n");
 		usb_lock_device(roothub);
 		usb_resume(&roothub->dev, PMSG_USER_RESUME);
 		usb_unlock_device(roothub);
 	}
-#endif
+
 	pdata->pmflags = 0;
 	printk(KERN_DEBUG "ehci fsl drv resume ends: %s\n", pdata->name);
-
+#endif
 	return 0;
 }
 #endif