[PATCH v3 0/9] usb: some PM changes for cdns3 and xhci-plat

[PATCH v3 0/9] usb: some PM changes for cdns3 and xhci-plat

[Peter Chen]

Hi Felipe & Mathias,

In this series, it adds cdns3 runtime PM support as well as some
xhci-plat changes, and verified at NXP i.MX8QM and i.MX8QXP platforms.

Patch 1-3: add main runtime PM support for cdns3 core and imx glue layer
Patch 4-9: add platform data support and two quirks for xhci-plat.c.
- .suspend_quirk for platform special sequence between xhci_bus_suspend
and xhci_suspend.
- add XHCI_SKIP_PHY_INIT quirk for skip PHY management from HCD core.

Changes for v2:
Add Jun Li’s reviewed-by [Patch 1 and Patch 6]
Add Mathias’s acked-by [Patch 4-6]
Some wakeup logic improvement [Patch 2]
Add dedicated wakeup interrupt for core, and improve the commit log [Patch]
Fix build error found by kbuild test robot [Patch 3]
Using xhci_plat_priv quirk for skip PHY initialization [patch 7, patch 9]
Some other typo and tiny improvements

Changes for v1:
- Add the 1st patch. Without it, the build on the usb-next will fail.
- Change the subject for cover letter a little to reflect all contents.

Peter Chen (9):
  usb: cdns3: introduce cdns3_set_phy_power API
  usb: cdns3: add runtime PM support
  usb: cdns3: imx: add glue layer runtime pm implementation
  usb: host: xhci-plat: add platform data support
  usb: host: xhci-plat: add .suspend_quirk for struct xhci_plat_priv
  usb: host: xhci-plat: delete the unnecessary code
  usb: host: xhci-plat: add priv quirk for skip PHY initialization
  usb: cdns3: host: add .suspend_quirk for xhci-plat.c
  usb: cdns3: host: add xhci_plat_priv quirk XHCI_SKIP_PHY_INIT

 drivers/usb/cdns3/cdns3-imx.c   | 203 ++++++++++++++++++++++++++++++--
 drivers/usb/cdns3/core.c        | 199 ++++++++++++++++++++++++++-----
 drivers/usb/cdns3/core.h        |  16 +++
 drivers/usb/cdns3/drd.c         |   3 +
 drivers/usb/cdns3/gadget.c      |   4 +
 drivers/usb/cdns3/host-export.h |   6 +
 drivers/usb/cdns3/host.c        |  48 ++++++++
 drivers/usb/host/xhci-plat.c    |  36 +++++-
 drivers/usb/host/xhci-plat.h    |   1 +
 drivers/usb/host/xhci.h         |   1 +
 10 files changed, 469 insertions(+), 48 deletions(-)

-- 
2.17.1

[PATCH v3 1/9] usb: cdns3: introduce cdns3_set_phy_power API

[Peter Chen]

Since we have both USB2 and USB3 PHYs for cdns3 controller, it is
better we have a unity API to handle both USB2 and USB3's power, it
could simplify code for error handling and further power management
implementation.

Reviewed-by: Jun Li <jun.li@nxp.com>
Signed-off-by: Peter Chen <peter.chen@nxp.com>
---
 drivers/usb/cdns3/core.c | 44 ++++++++++++++++++++++++++--------------
 1 file changed, 29 insertions(+), 15 deletions(-)

diff --git a/drivers/usb/cdns3/core.c b/drivers/usb/cdns3/core.c
index 19bbb5b7e6b6..bfd09aa98c12 100644
--- a/drivers/usb/cdns3/core.c
+++ b/drivers/usb/cdns3/core.c
@@ -384,6 +384,28 @@ static int cdns3_role_set(struct usb_role_switch *sw, enum usb_role role)
 	return ret;
 }
 
+static int cdns3_set_phy_power(struct cdns3 *cdns, bool on)
+{
+	int ret = 0;
+
+	if (on) {
+		ret = phy_power_on(cdns->usb2_phy);
+		if (ret)
+			return ret;
+
+		ret = phy_power_on(cdns->usb3_phy);
+		if (ret) {
+			phy_power_off(cdns->usb2_phy);
+			return ret;
+		}
+	} else {
+		phy_power_off(cdns->usb3_phy);
+		phy_power_off(cdns->usb2_phy);
+	}
+
+	return 0;
+}
+
 /**
  * cdns3_probe - probe for cdns3 core device
  * @pdev: Pointer to cdns3 core platform device
@@ -477,14 +499,10 @@ static int cdns3_probe(struct platform_device *pdev)
 	if (ret)
 		goto err1;
 
-	ret = phy_power_on(cdns->usb2_phy);
+	ret = cdns3_set_phy_power(cdns, true);
 	if (ret)
 		goto err2;
 
-	ret = phy_power_on(cdns->usb3_phy);
-	if (ret)
-		goto err3;
-
 	sw_desc.set = cdns3_role_set;
 	sw_desc.get = cdns3_role_get;
 	sw_desc.allow_userspace_control = true;
@@ -496,16 +514,16 @@ static int cdns3_probe(struct platform_device *pdev)
 	if (IS_ERR(cdns->role_sw)) {
 		ret = PTR_ERR(cdns->role_sw);
 		dev_warn(dev, "Unable to register Role Switch\n");
-		goto err4;
+		goto err3;
 	}
 
 	ret = cdns3_drd_init(cdns);
 	if (ret)
-		goto err5;
+		goto err4;
 
 	ret = cdns3_core_init_role(cdns);
 	if (ret)
-		goto err5;
+		goto err4;
 
 	device_set_wakeup_capable(dev, true);
 	pm_runtime_set_active(dev);
@@ -522,14 +540,11 @@ static int cdns3_probe(struct platform_device *pdev)
 	dev_dbg(dev, "Cadence USB3 core: probe succeed\n");
 
 	return 0;
-err5:
+err4:
 	cdns3_drd_exit(cdns);
 	usb_role_switch_unregister(cdns->role_sw);
-err4:
-	phy_power_off(cdns->usb3_phy);
-
 err3:
-	phy_power_off(cdns->usb2_phy);
+	cdns3_set_phy_power(cdns, false);
 err2:
 	phy_exit(cdns->usb3_phy);
 err1:
@@ -553,8 +568,7 @@ static int cdns3_remove(struct platform_device *pdev)
 	pm_runtime_put_noidle(&pdev->dev);
 	cdns3_exit_roles(cdns);
 	usb_role_switch_unregister(cdns->role_sw);
-	phy_power_off(cdns->usb2_phy);
-	phy_power_off(cdns->usb3_phy);
+	cdns3_set_phy_power(cdns, false);
 	phy_exit(cdns->usb2_phy);
 	phy_exit(cdns->usb3_phy);
 	return 0;
-- 
2.17.1

[PATCH v3 2/9] usb: cdns3: add runtime PM support

[Peter Chen]

Introduce runtime PM and wakeup interrupt handler for cdns3,
the runtime PM is default off since other cdns3 may not
implement glue layer support for runtime PM.

One typical wakeup event use case is xHCI runtime suspend will clear
USBCMD.RS bit, after that the xHCI will not trigger any interrupts,
so its parent (cdns core device) needs to resume xHCI device when
any (wakeup) events occurs at host port.

When the controller is in low power mode, the lpm flag will be set.
The interrupt triggered later than lpm flag is set considers as
wakeup interrupt and handled at cdns_wakeup_irq. Once the wakeup
occurs, it first disables interrupt to avoid later interrupt
occurrence since the controller is in low power mode at that
time, and access registers may be invalid at that time. At wakeup
handler, it will call pm_request_resume to wakeup xHCI device, and
at runtime resume handler, it will enable interrupt again.

The API platform_suspend is introduced for glue layer to implement
platform specific PM sequence.

Signed-off-by: Peter Chen <peter.chen@nxp.com>
---
 drivers/usb/cdns3/core.c   | 155 +++++++++++++++++++++++++++++++++----
 drivers/usb/cdns3/core.h   |  16 ++++
 drivers/usb/cdns3/drd.c    |   3 +
 drivers/usb/cdns3/gadget.c |   4 +
 drivers/usb/cdns3/host.c   |   7 ++
 5 files changed, 168 insertions(+), 17 deletions(-)

diff --git a/drivers/usb/cdns3/core.c b/drivers/usb/cdns3/core.c
index bfd09aa98c12..97fb082ed3b4 100644
--- a/drivers/usb/cdns3/core.c
+++ b/drivers/usb/cdns3/core.c
@@ -406,6 +406,30 @@ static int cdns3_set_phy_power(struct cdns3 *cdns, bool on)
 	return 0;
 }
 
+/**
+ * cdns3_wakeup_irq - interrupt handler for wakeup events
+ *
+ * @irq: irq number for cdns3 core device
+ * @data: structure of cdns3
+ *
+ * Returns IRQ_HANDLED or IRQ_NONE
+ */
+static irqreturn_t cdns3_wakeup_irq(int irq, void *data)
+{
+	struct cdns3 *cdns = data;
+
+	if (cdns->in_lpm) {
+		disable_irq_nosync(irq);
+		cdns->wakeup_int = true;
+		if ((cdns->role == USB_ROLE_HOST) && cdns->host_dev)
+			pm_request_resume(&cdns->host_dev->dev);
+
+		return IRQ_HANDLED;
+	}
+
+	return IRQ_NONE;
+}
+
 /**
  * cdns3_probe - probe for cdns3 core device
  * @pdev: Pointer to cdns3 core platform device
@@ -432,6 +456,7 @@ static int cdns3_probe(struct platform_device *pdev)
 		return -ENOMEM;
 
 	cdns->dev = dev;
+	cdns->pdata = dev_get_platdata(dev);
 
 	platform_set_drvdata(pdev, cdns);
 
@@ -481,6 +506,15 @@ static int cdns3_probe(struct platform_device *pdev)
 
 	cdns->otg_res = *res;
 
+	cdns->wakeup_irq = platform_get_irq_byname(pdev, "wakeup");
+	if (cdns->wakeup_irq == -EPROBE_DEFER)
+		return cdns->wakeup_irq;
+
+	if (cdns->wakeup_irq < 0) {
+		dev_dbg(dev, "couldn't get wakeup irq\n");
+		cdns->wakeup_irq = 0x0;
+	}
+
 	mutex_init(&cdns->mutex);
 
 	cdns->usb2_phy = devm_phy_optional_get(dev, "cdns3,usb2-phy");
@@ -517,6 +551,19 @@ static int cdns3_probe(struct platform_device *pdev)
 		goto err3;
 	}
 
+	if (cdns->wakeup_irq) {
+		ret = devm_request_threaded_irq(cdns->dev, cdns->wakeup_irq,
+						cdns3_wakeup_irq,
+						NULL,
+						IRQF_SHARED,
+						dev_name(cdns->dev), cdns);
+
+		if (ret) {
+			dev_err(cdns->dev, "couldn't register wakeup irq handler\n");
+			goto err3;
+		}
+	}
+
 	ret = cdns3_drd_init(cdns);
 	if (ret)
 		goto err4;
@@ -525,9 +572,11 @@ static int cdns3_probe(struct platform_device *pdev)
 	if (ret)
 		goto err4;
 
+	spin_lock_init(&cdns->lock);
 	device_set_wakeup_capable(dev, true);
 	pm_runtime_set_active(dev);
 	pm_runtime_enable(dev);
+	pm_runtime_forbid(dev);
 
 	/*
 	 * The controller needs less time between bus and controller suspend,
@@ -574,52 +623,124 @@ static int cdns3_remove(struct platform_device *pdev)
 	return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
+#ifdef CONFIG_PM
 
-static int cdns3_suspend(struct device *dev)
+static int cdns3_set_platform_suspend(struct device *dev,
+		bool suspend, bool wakeup)
+{
+	struct cdns3 *cdns = dev_get_drvdata(dev);
+	int ret = 0;
+	unsigned long flags;
+
+	spin_lock_irqsave(&cdns->lock, flags);
+	if (cdns->pdata && cdns->pdata->platform_suspend)
+		ret = cdns->pdata->platform_suspend(dev, suspend, wakeup);
+
+	spin_unlock_irqrestore(&cdns->lock, flags);
+
+	return ret;
+}
+
+static int cdns3_controller_suspend(struct device *dev, pm_message_t msg)
 {
 	struct cdns3 *cdns = dev_get_drvdata(dev);
+	bool wakeup;
 	unsigned long flags;
 
-	if (cdns->role == USB_ROLE_HOST)
+	if (cdns->in_lpm)
 		return 0;
 
-	if (pm_runtime_status_suspended(dev))
-		pm_runtime_resume(dev);
+	if (PMSG_IS_AUTO(msg))
+		wakeup = true;
+	else
+		wakeup = device_may_wakeup(dev);
 
-	if (cdns->roles[cdns->role]->suspend) {
-		spin_lock_irqsave(&cdns->gadget_dev->lock, flags);
-		cdns->roles[cdns->role]->suspend(cdns, false);
-		spin_unlock_irqrestore(&cdns->gadget_dev->lock, flags);
-	}
+	cdns3_set_platform_suspend(cdns->dev, true, wakeup);
+	cdns3_set_phy_power(cdns, false);
+	spin_lock_irqsave(&cdns->lock, flags);
+	cdns->in_lpm = true;
+	spin_unlock_irqrestore(&cdns->lock, flags);
 
 	return 0;
 }
 
-static int cdns3_resume(struct device *dev)
+static int cdns3_controller_resume(struct device *dev, pm_message_t msg)
 {
 	struct cdns3 *cdns = dev_get_drvdata(dev);
+	int ret;
 	unsigned long flags;
 
-	if (cdns->role == USB_ROLE_HOST)
+	if (!cdns->in_lpm)
 		return 0;
 
-	if (cdns->roles[cdns->role]->resume) {
-		spin_lock_irqsave(&cdns->gadget_dev->lock, flags);
+	ret = cdns3_set_phy_power(cdns, true);
+	if (ret)
+		return ret;
+
+	cdns3_set_platform_suspend(cdns->dev, false, false);
+
+	spin_lock_irqsave(&cdns->lock, flags);
+	if (cdns->roles[cdns->role]->resume && !PMSG_IS_AUTO(msg))
 		cdns->roles[cdns->role]->resume(cdns, false);
-		spin_unlock_irqrestore(&cdns->gadget_dev->lock, flags);
+
+	cdns->in_lpm = false;
+	spin_unlock_irqrestore(&cdns->lock, flags);
+	if (cdns->wakeup_int) {
+		cdns->wakeup_int = false;
+		enable_irq(cdns->otg_irq);
 	}
 
+	return ret;
+}
+
+static int cdns3_runtime_suspend(struct device *dev)
+{
+	return cdns3_controller_suspend(dev, PMSG_AUTO_SUSPEND);
+}
+
+static int cdns3_runtime_resume(struct device *dev)
+{
+	return cdns3_controller_resume(dev, PMSG_AUTO_RESUME);
+}
+#ifdef CONFIG_PM_SLEEP
+
+static int cdns3_suspend(struct device *dev)
+{
+	struct cdns3 *cdns = dev_get_drvdata(dev);
+	unsigned long flags;
+
+	if (pm_runtime_status_suspended(dev))
+		pm_runtime_resume(dev);
+
+	if (cdns->roles[cdns->role]->suspend) {
+		spin_lock_irqsave(&cdns->lock, flags);
+		cdns->roles[cdns->role]->suspend(cdns, false);
+		spin_unlock_irqrestore(&cdns->lock, flags);
+	}
+
+	return cdns3_controller_suspend(dev, PMSG_SUSPEND);
+}
+
+static int cdns3_resume(struct device *dev)
+{
+	int ret;
+
+	ret = cdns3_controller_resume(dev, PMSG_RESUME);
+	if (ret)
+		return ret;
+
 	pm_runtime_disable(dev);
 	pm_runtime_set_active(dev);
 	pm_runtime_enable(dev);
 
-	return 0;
+	return ret;
 }
-#endif
+#endif /* CONFIG_PM_SLEEP */
+#endif /* CONFIG_PM */
 
 static const struct dev_pm_ops cdns3_pm_ops = {
 	SET_SYSTEM_SLEEP_PM_OPS(cdns3_suspend, cdns3_resume)
+	SET_RUNTIME_PM_OPS(cdns3_runtime_suspend, cdns3_runtime_resume, NULL)
 };
 
 #ifdef CONFIG_OF
diff --git a/drivers/usb/cdns3/core.h b/drivers/usb/cdns3/core.h
index 1ad1f1fe61e9..fdbcf557a61f 100644
--- a/drivers/usb/cdns3/core.h
+++ b/drivers/usb/cdns3/core.h
@@ -38,6 +38,12 @@ struct cdns3_role_driver {
 };
 
 #define CDNS3_XHCI_RESOURCES_NUM	2
+
+struct cdns3_platform_data {
+	int (*platform_suspend)(struct device *dev,
+			bool suspend, bool wakeup);
+};
+
 /**
  * struct cdns3 - Representation of Cadence USB3 DRD controller.
  * @dev: pointer to Cadence device struct
@@ -50,6 +56,7 @@ struct cdns3_role_driver {
  * @otg_regs: pointer to base of otg registers
  * @otg_irq: irq number for otg controller
  * @dev_irq: irq number for device controller
+ * @dev_irq: irq number for wakeup event
  * @roles: array of supported roles for this controller
  * @role: current role
  * @host_dev: the child host device pointer for cdns3 core
@@ -62,6 +69,10 @@ struct cdns3_role_driver {
  *           This field based on firmware setting, kernel configuration
  *           and hardware configuration.
  * @role_sw: pointer to role switch object.
+ * @in_lpm: indicate the controller is in low power mode
+ * @wakeup_int: wakeup interrupt occurs
+ * @pdata: platform data from glue layer
+ * @lock: spinlock structure
  */
 struct cdns3 {
 	struct device			*dev;
@@ -79,6 +90,7 @@ struct cdns3 {
 
 	int				otg_irq;
 	int				dev_irq;
+	int				wakeup_irq;
 	struct cdns3_role_driver	*roles[USB_ROLE_DEVICE + 1];
 	enum usb_role			role;
 	struct platform_device		*host_dev;
@@ -89,6 +101,10 @@ struct cdns3 {
 	struct mutex			mutex;
 	enum usb_dr_mode		dr_mode;
 	struct usb_role_switch		*role_sw;
+	bool				in_lpm;
+	bool				wakeup_int;
+	struct cdns3_platform_data	*pdata;
+	spinlock_t			lock;
 };
 
 int cdns3_hw_role_switch(struct cdns3 *cdns);
diff --git a/drivers/usb/cdns3/drd.c b/drivers/usb/cdns3/drd.c
index 58089841ed52..ac90a484e63c 100644
--- a/drivers/usb/cdns3/drd.c
+++ b/drivers/usb/cdns3/drd.c
@@ -281,6 +281,9 @@ static irqreturn_t cdns3_drd_irq(int irq, void *data)
 	if (cdns->dr_mode != USB_DR_MODE_OTG)
 		return ret;
 
+	if (cdns->in_lpm)
+		return ret;
+
 	reg = readl(&cdns->otg_regs->ivect);
 
 	if (!reg)
diff --git a/drivers/usb/cdns3/gadget.c b/drivers/usb/cdns3/gadget.c
index 7babba9dd916..eac01b1a4958 100644
--- a/drivers/usb/cdns3/gadget.c
+++ b/drivers/usb/cdns3/gadget.c
@@ -1765,9 +1765,13 @@ static void cdns3_check_usb_interrupt_proceed(struct cdns3_device *priv_dev,
 static irqreturn_t cdns3_device_irq_handler(int irq, void *data)
 {
 	struct cdns3_device *priv_dev = data;
+	struct cdns3 *cdns = dev_get_drvdata(priv_dev->dev);
 	irqreturn_t ret = IRQ_NONE;
 	u32 reg;
 
+	if (cdns->in_lpm)
+		return ret;
+
 	/* check USB device interrupt */
 	reg = readl(&priv_dev->regs->usb_ists);
 	if (reg) {
diff --git a/drivers/usb/cdns3/host.c b/drivers/usb/cdns3/host.c
index ad788bf3fe4f..b579ef15f4e0 100644
--- a/drivers/usb/cdns3/host.c
+++ b/drivers/usb/cdns3/host.c
@@ -13,11 +13,13 @@
 #include "core.h"
 #include "drd.h"
 #include "host-export.h"
+#include <linux/usb/hcd.h>
 
 static int __cdns3_host_init(struct cdns3 *cdns)
 {
 	struct platform_device *xhci;
 	int ret;
+	struct usb_hcd *hcd;
 
 	cdns3_drd_switch_host(cdns, 1);
 
@@ -43,6 +45,11 @@ static int __cdns3_host_init(struct cdns3 *cdns)
 		goto err1;
 	}
 
+	/* Glue needs to access xHCI region register for Power management */
+	hcd = platform_get_drvdata(xhci);
+	if (hcd)
+		cdns->xhci_regs = hcd->regs;
+
 	return 0;
 err1:
 	platform_device_put(xhci);
-- 
2.17.1

[PATCH v3 3/9] usb: cdns3: imx: add glue layer runtime pm implementation

[Peter Chen]

Add imx glue layer runtime pm implementation, and the runtime
pm is default off.

Signed-off-by: Peter Chen <peter.chen@nxp.com>
---
 drivers/usb/cdns3/cdns3-imx.c | 203 ++++++++++++++++++++++++++++++++--
 1 file changed, 192 insertions(+), 11 deletions(-)

diff --git a/drivers/usb/cdns3/cdns3-imx.c b/drivers/usb/cdns3/cdns3-imx.c
index aba988e71958..3a7e9bf7a294 100644
--- a/drivers/usb/cdns3/cdns3-imx.c
+++ b/drivers/usb/cdns3/cdns3-imx.c
@@ -15,6 +15,8 @@
 #include <linux/io.h>
 #include <linux/of_platform.h>
 #include <linux/iopoll.h>
+#include <linux/pm_runtime.h>
+#include "core.h"
 
 #define USB3_CORE_CTRL1    0x00
 #define USB3_CORE_CTRL2    0x04
@@ -32,7 +34,7 @@
 /* Register bits definition */
 
 /* USB3_CORE_CTRL1 */
-#define SW_RESET_MASK	(0x3f << 26)
+#define SW_RESET_MASK	GENMASK(31, 26)
 #define PWR_SW_RESET	BIT(31)
 #define APB_SW_RESET	BIT(30)
 #define AXI_SW_RESET	BIT(29)
@@ -44,17 +46,17 @@
 #define OC_DISABLE	BIT(9)
 #define MDCTRL_CLK_SEL	BIT(7)
 #define MODE_STRAP_MASK	(0x7)
-#define DEV_MODE	(1 << 2)
-#define HOST_MODE	(1 << 1)
-#define OTG_MODE	(1 << 0)
+#define DEV_MODE	BIT(2)
+#define HOST_MODE	BIT(1)
+#define OTG_MODE	BIT(0)
 
 /* USB3_INT_REG */
 #define CLK_125_REQ	BIT(29)
 #define LPM_CLK_REQ	BIT(28)
 #define DEVU3_WAEKUP_EN	BIT(14)
 #define OTG_WAKEUP_EN	BIT(12)
-#define DEV_INT_EN (3 << 8) /* DEV INT b9:8 */
-#define HOST_INT1_EN (1 << 0) /* HOST INT b7:0 */
+#define DEV_INT_EN	GENMASK(9, 8) /* DEV INT b9:8 */
+#define HOST_INT1_EN	BIT(0) /* HOST INT b7:0 */
 
 /* USB3_CORE_STATUS */
 #define MDCTRL_CLK_STATUS	BIT(15)
@@ -62,15 +64,34 @@
 #define HOST_POWER_ON_READY	BIT(12)
 
 /* USB3_SSPHY_STATUS */
-#define CLK_VALID_MASK		(0x3f << 26)
-#define CLK_VALID_COMPARE_BITS	(0xf << 28)
-#define PHY_REFCLK_REQ		(1 << 0)
+#define CLK_VALID_MASK		GENMASK(31, 26)
+#define CLK_VALID_COMPARE_BITS	GENMASK(31, 28)
+#define PHY_REFCLK_REQ		BIT(0)
+
+/* OTG registers definition */
+#define OTGSTS		0x4
+/* OTGSTS */
+#define OTG_NRDY	BIT(11)
+
+/* xHCI registers definition  */
+#define XECP_PM_PMCSR		0x8018
+#define XECP_AUX_CTRL_REG1	0x8120
+
+/* Register bits definition */
+/* XECP_AUX_CTRL_REG1 */
+#define CFG_RXDET_P3_EN		BIT(15)
+
+/* XECP_PM_PMCSR */
+#define PS_MASK			GENMASK(1, 0)
+#define PS_D0			0
+#define PS_D1			1
 
 struct cdns_imx {
 	struct device *dev;
 	void __iomem *noncore;
 	struct clk_bulk_data *clks;
 	int num_clks;
+	struct platform_device *cdns3_pdev;
 };
 
 static inline u32 cdns_imx_readl(struct cdns_imx *data, u32 offset)
@@ -126,6 +147,20 @@ static int cdns_imx_noncore_init(struct cdns_imx *data)
 	return ret;
 }
 
+static int cdns_imx_platform_suspend(struct device *dev,
+	bool suspend, bool wakeup);
+static struct cdns3_platform_data cdns_imx_pdata = {
+	.platform_suspend = cdns_imx_platform_suspend,
+};
+
+static struct of_dev_auxdata cdns_imx_auxdata[] = {
+	{
+	.compatible = "cdns,usb3",
+	.platform_data = &cdns_imx_pdata,
+	},
+	{},
+};
+
 static int cdns_imx_probe(struct platform_device *pdev)
 {
 	struct device *dev = &pdev->dev;
@@ -162,14 +197,18 @@ static int cdns_imx_probe(struct platform_device *pdev)
 	if (ret)
 		goto err;
 
-	ret = of_platform_populate(node, NULL, NULL, dev);
+	ret = of_platform_populate(node, NULL, cdns_imx_auxdata, dev);
 	if (ret) {
 		dev_err(dev, "failed to create children: %d\n", ret);
 		goto err;
 	}
 
-	return ret;
+	device_set_wakeup_capable(dev, true);
+	pm_runtime_set_active(dev);
+	pm_runtime_enable(dev);
+	pm_runtime_forbid(dev);
 
+	return ret;
 err:
 	clk_bulk_disable_unprepare(data->num_clks, data->clks);
 	return ret;
@@ -194,6 +233,147 @@ static int cdns_imx_remove(struct platform_device *pdev)
 	return 0;
 }
 
+#ifdef CONFIG_PM
+static void cdns3_set_wakeup(struct cdns_imx *data, bool enable)
+{
+	u32 value;
+
+	value = cdns_imx_readl(data, USB3_INT_REG);
+	if (enable)
+		value |= OTG_WAKEUP_EN | DEVU3_WAEKUP_EN;
+	else
+		value &= ~(OTG_WAKEUP_EN | DEVU3_WAEKUP_EN);
+
+	cdns_imx_writel(data, USB3_INT_REG, value);
+}
+
+static int cdns_imx_platform_suspend(struct device *dev,
+		bool suspend, bool wakeup)
+{
+	struct cdns3 *cdns = dev_get_drvdata(dev);
+	struct device *parent = dev->parent;
+	struct cdns_imx *data = dev_get_drvdata(parent);
+	void __iomem *otg_regs = cdns->otg_regs;
+	void __iomem *xhci_regs = cdns->xhci_regs;
+	u32 value;
+	int ret = 0;
+
+	if (cdns->role != USB_ROLE_HOST)
+		return 0;
+
+	if (suspend) {
+		/* SW request low power when all usb ports allow to it ??? */
+		value = readl(xhci_regs + XECP_PM_PMCSR);
+		value &= ~PS_MASK;
+		value |= PS_D1;
+		writel(value, xhci_regs + XECP_PM_PMCSR);
+
+		/* mdctrl_clk_sel */
+		value = cdns_imx_readl(data, USB3_CORE_CTRL1);
+		value |= MDCTRL_CLK_SEL;
+		cdns_imx_writel(data, USB3_CORE_CTRL1, value);
+
+		/* wait for mdctrl_clk_status */
+		value = cdns_imx_readl(data, USB3_CORE_STATUS);
+		ret = readl_poll_timeout_atomic(data->noncore + USB3_CORE_STATUS, value,
+			(value & MDCTRL_CLK_STATUS) == MDCTRL_CLK_STATUS,
+			10, 100000);
+		if (ret)
+			dev_warn(parent, "wait mdctrl_clk_status timeout\n");
+
+		/* wait lpm_clk_req to be 0 */
+		value = cdns_imx_readl(data, USB3_INT_REG);
+		ret = readl_poll_timeout_atomic(data->noncore + USB3_INT_REG, value,
+			(value & LPM_CLK_REQ) != LPM_CLK_REQ,
+			10, 100000);
+		if (ret)
+			dev_warn(parent, "wait lpm_clk_req timeout\n");
+
+		/* wait phy_refclk_req to be 0 */
+		value = cdns_imx_readl(data, USB3_SSPHY_STATUS);
+		ret = readl_poll_timeout_atomic(data->noncore + USB3_SSPHY_STATUS, value,
+			(value & PHY_REFCLK_REQ) != PHY_REFCLK_REQ,
+			10, 100000);
+		if (ret)
+			dev_warn(parent, "wait phy_refclk_req timeout\n");
+
+		cdns3_set_wakeup(data, wakeup);
+	} else {
+		/* wait CLK_125_REQ to be 1 */
+		value = cdns_imx_readl(data, USB3_INT_REG);
+		ret = readl_poll_timeout_atomic(data->noncore + USB3_INT_REG, value,
+			(value & CLK_125_REQ) != CLK_125_REQ,
+			10, 100000);
+		if (ret)
+			dev_warn(parent, "wait CLK_125_REQ timeout\n");
+
+		cdns3_set_wakeup(data, false);
+
+		/* SW request D0 */
+		value = readl(xhci_regs + XECP_PM_PMCSR);
+		value &= ~PS_MASK;
+		value |= PS_D0;
+		writel(value, xhci_regs + XECP_PM_PMCSR);
+
+		/* clr CFG_RXDET_P3_EN */
+		value = readl(xhci_regs + XECP_AUX_CTRL_REG1);
+		value &= ~CFG_RXDET_P3_EN;
+		writel(value, xhci_regs + XECP_AUX_CTRL_REG1);
+
+		/* clear mdctrl_clk_sel */
+		value = cdns_imx_readl(data, USB3_CORE_CTRL1);
+		value &= ~MDCTRL_CLK_SEL;
+		cdns_imx_writel(data, USB3_CORE_CTRL1, value);
+
+		/* wait for mdctrl_clk_status is cleared */
+		value = cdns_imx_readl(data, USB3_CORE_STATUS);
+		ret = readl_poll_timeout_atomic(data->noncore + USB3_CORE_STATUS, value,
+			(value & MDCTRL_CLK_STATUS) != MDCTRL_CLK_STATUS,
+			10, 100000);
+		if (ret)
+			dev_warn(parent, "wait mdctrl_clk_status cleared timeout\n");
+
+		/* Wait until OTG_NRDY is 0 */
+		value = readl(otg_regs + OTGSTS);
+		ret = readl_poll_timeout_atomic(otg_regs + OTGSTS, value,
+			(value & OTG_NRDY) != OTG_NRDY,
+			10, 100000);
+		if (ret)
+			dev_warn(parent, "wait OTG ready timeout\n");
+	}
+
+	return ret;
+
+}
+
+static int cdns_imx_resume(struct device *dev)
+{
+	struct cdns_imx *data = dev_get_drvdata(dev);
+
+	return clk_bulk_prepare_enable(data->num_clks, data->clks);
+}
+
+static int cdns_imx_suspend(struct device *dev)
+{
+	struct cdns_imx *data = dev_get_drvdata(dev);
+
+	clk_bulk_disable_unprepare(data->num_clks, data->clks);
+
+	return 0;
+}
+#else
+static int cdns_imx_platform_suspend(struct device *dev,
+	bool suspend, bool wakeup)
+{
+	return 0;
+}
+
+#endif /* CONFIG_PM */
+
+static const struct dev_pm_ops cdns_imx_pm_ops = {
+	SET_RUNTIME_PM_OPS(cdns_imx_suspend, cdns_imx_resume, NULL)
+};
+
 static const struct of_device_id cdns_imx_of_match[] = {
 	{ .compatible = "fsl,imx8qm-usb3", },
 	{},
@@ -206,6 +386,7 @@ static struct platform_driver cdns_imx_driver = {
 	.driver		= {
 		.name	= "cdns3-imx",
 		.of_match_table	= cdns_imx_of_match,
+		.pm	= &cdns_imx_pm_ops,
 	},
 };
 module_platform_driver(cdns_imx_driver);
-- 
2.17.1

[PATCH v3 4/9] usb: host: xhci-plat: add platform data support

[Peter Chen]

Some xhci hosts (eg dwc3 and cdns3) do not use OF to create
platform device, they create xhci-plat platform device runtime.
And these platforms may also have quirks, and the quirks could
be supplied by their parent device through platform data.

Acked-by: Mathias Nyman <mathias.nyman@linux.intel.com>
Signed-off-by: Peter Chen <peter.chen@nxp.com>
---
 drivers/usb/host/xhci-plat.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index 0b4cdc5af130..e00efd84ea1a 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -255,7 +255,11 @@ static int xhci_plat_probe(struct platform_device *pdev)
 	if (ret)
 		goto disable_reg_clk;
 
-	priv_match = of_device_get_match_data(&pdev->dev);
+	if (pdev->dev.of_node)
+		priv_match = of_device_get_match_data(&pdev->dev);
+	else
+		priv_match = dev_get_platdata(&pdev->dev);
+
 	if (priv_match) {
 		struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
 
-- 
2.17.1

[PATCH v3 5/9] usb: host: xhci-plat: add .suspend_quirk for struct xhci_plat_priv

[Peter Chen]

Some platforms (eg cdns3) may have special sequences between
xhci_bus_suspend and xhci_suspend, add .suspend_quick for it.

Acked-by: Mathias Nyman <mathias.nyman@linux.intel.com>
Signed-off-by: Peter Chen <peter.chen@nxp.com>
---
 drivers/usb/host/xhci-plat.c | 19 +++++++++++++++++++
 drivers/usb/host/xhci-plat.h |  1 +
 2 files changed, 20 insertions(+)

diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index e00efd84ea1a..ca02e7f36238 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -54,6 +54,16 @@ static int xhci_priv_init_quirk(struct usb_hcd *hcd)
 	return priv->init_quirk(hcd);
 }
 
+static int xhci_priv_suspend_quirk(struct usb_hcd *hcd)
+{
+	struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
+
+	if (!priv->suspend_quirk)
+		return 0;
+
+	return priv->suspend_quirk(hcd);
+}
+
 static int xhci_priv_resume_quirk(struct usb_hcd *hcd)
 {
 	struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
@@ -396,7 +406,11 @@ static int __maybe_unused xhci_plat_suspend(struct device *dev)
 {
 	struct usb_hcd	*hcd = dev_get_drvdata(dev);
 	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
+	int ret;
 
+	ret = xhci_priv_suspend_quirk(hcd);
+	if (ret)
+		return ret;
 	/*
 	 * xhci_suspend() needs `do_wakeup` to know whether host is allowed
 	 * to do wakeup during suspend. Since xhci_plat_suspend is currently
@@ -425,6 +439,11 @@ static int __maybe_unused xhci_plat_runtime_suspend(struct device *dev)
 {
 	struct usb_hcd  *hcd = dev_get_drvdata(dev);
 	struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+	int ret;
+
+	ret = xhci_priv_suspend_quirk(hcd);
+	if (ret)
+		return ret;
 
 	return xhci_suspend(xhci, true);
 }
diff --git a/drivers/usb/host/xhci-plat.h b/drivers/usb/host/xhci-plat.h
index 5681723fc9cd..9338a4f946d0 100644
--- a/drivers/usb/host/xhci-plat.h
+++ b/drivers/usb/host/xhci-plat.h
@@ -15,6 +15,7 @@ struct xhci_plat_priv {
 	unsigned long long quirks;
 	void (*plat_start)(struct usb_hcd *);
 	int (*init_quirk)(struct usb_hcd *);
+	int (*suspend_quirk)(struct usb_hcd *);
 	int (*resume_quirk)(struct usb_hcd *);
 };
 
-- 
2.17.1

[PATCH v3 6/9] usb: host: xhci-plat: delete the unnecessary code

[Peter Chen]

The if {} condition is duplicated with outer if {} condition.

Reviewed-by: Jun Li <jun.li@nxp.com>
Acked-by: Mathias Nyman <mathias.nyman@linux.intel.com>
Signed-off-by: Peter Chen <peter.chen@nxp.com>
---
 drivers/usb/host/xhci-plat.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index ca02e7f36238..a45c7ec33ed6 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -274,8 +274,7 @@ static int xhci_plat_probe(struct platform_device *pdev)
 		struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
 
 		/* Just copy data for now */
-		if (priv_match)
-			*priv = *priv_match;
+		*priv = *priv_match;
 	}
 
 	device_wakeup_enable(hcd->self.controller);
-- 
2.17.1

[PATCH v3 7/9] usb: host: xhci-plat: add priv quirk for skip PHY initialization

[Peter Chen]

Some DRD controllers (eg, dwc3 & cdns3) have PHY management at
their own driver to cover both device and host mode, so add one
priv quirk for such users to skip PHY management from HCD core.

Signed-off-by: Peter Chen <peter.chen@nxp.com>
---
 drivers/usb/host/xhci-plat.c | 8 ++++++--
 drivers/usb/host/xhci.h      | 1 +
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index a45c7ec33ed6..6b8a193bd012 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -173,6 +173,8 @@ static int xhci_plat_probe(struct platform_device *pdev)
 	struct usb_hcd		*hcd;
 	int			ret;
 	int			irq;
+	struct xhci_plat_priv	*priv = NULL;
+
 
 	if (usb_disabled())
 		return -ENODEV;
@@ -271,8 +273,7 @@ static int xhci_plat_probe(struct platform_device *pdev)
 		priv_match = dev_get_platdata(&pdev->dev);
 
 	if (priv_match) {
-		struct xhci_plat_priv *priv = hcd_to_xhci_priv(hcd);
-
+		priv = hcd_to_xhci_priv(hcd);
 		/* Just copy data for now */
 		*priv = *priv_match;
 	}
@@ -324,6 +325,9 @@ static int xhci_plat_probe(struct platform_device *pdev)
 
 	hcd->tpl_support = of_usb_host_tpl_support(sysdev->of_node);
 	xhci->shared_hcd->tpl_support = hcd->tpl_support;
+	if (priv && (priv->quirks & XHCI_SKIP_PHY_INIT))
+		hcd->skip_phy_initialization = 1;
+
 	ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
 	if (ret)
 		goto disable_usb_phy;
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 54a08bd31e46..b19169fd8a85 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -1873,6 +1873,7 @@ struct xhci_hcd {
 #define XHCI_RESET_PLL_ON_DISCONNECT	BIT_ULL(34)
 #define XHCI_SNPS_BROKEN_SUSPEND    BIT_ULL(35)
 #define XHCI_CDNS_HOST		BIT_ULL(36)
+#define XHCI_SKIP_PHY_INIT		BIT_ULL(37)
 
 	unsigned int		num_active_eps;
 	unsigned int		limit_active_eps;
-- 
2.17.1

[PATCH v3 8/9] usb: cdns3: host: add .suspend_quirk for xhci-plat.c

[Peter Chen]

cdns3 has some special PM sequence between xhci_bus_suspend and
xhci_suspend, add quirk to implement it.

Signed-off-by: Peter Chen <peter.chen@nxp.com>
---
 drivers/usb/cdns3/host-export.h |  6 +++++
 drivers/usb/cdns3/host.c        | 40 +++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+)

diff --git a/drivers/usb/cdns3/host-export.h b/drivers/usb/cdns3/host-export.h
index ae11810f8826..26041718a086 100644
--- a/drivers/usb/cdns3/host-export.h
+++ b/drivers/usb/cdns3/host-export.h
@@ -9,9 +9,11 @@
 #ifndef __LINUX_CDNS3_HOST_EXPORT
 #define __LINUX_CDNS3_HOST_EXPORT
 
+struct usb_hcd;
 #ifdef CONFIG_USB_CDNS3_HOST
 
 int cdns3_host_init(struct cdns3 *cdns);
+int xhci_cdns3_suspend_quirk(struct usb_hcd *hcd);
 
 #else
 
@@ -21,6 +23,10 @@ static inline int cdns3_host_init(struct cdns3 *cdns)
 }
 
 static inline void cdns3_host_exit(struct cdns3 *cdns) { }
+static inline int xhci_cdns3_suspend_quirk(struct usb_hcd *hcd)
+{
+	return 0;
+}
 
 #endif /* CONFIG_USB_CDNS3_HOST */
 
diff --git a/drivers/usb/cdns3/host.c b/drivers/usb/cdns3/host.c
index b579ef15f4e0..030d6421abd3 100644
--- a/drivers/usb/cdns3/host.c
+++ b/drivers/usb/cdns3/host.c
@@ -14,6 +14,18 @@
 #include "drd.h"
 #include "host-export.h"
 #include <linux/usb/hcd.h>
+#include "../host/xhci.h"
+#include "../host/xhci-plat.h"
+
+#define XECP_PORT_CAP_REG	0x8000
+#define XECP_AUX_CTRL_REG1	0x8120
+
+#define CFG_RXDET_P3_EN		(1 << 15)
+#define LPM_2_STB_SWITCH_EN	(1 << 25)
+
+static const struct xhci_plat_priv xhci_plat_cdns3_xhci = {
+	.suspend_quirk = xhci_cdns3_suspend_quirk,
+};
 
 static int __cdns3_host_init(struct cdns3 *cdns)
 {
@@ -39,6 +51,11 @@ static int __cdns3_host_init(struct cdns3 *cdns)
 		goto err1;
 	}
 
+	ret = platform_device_add_data(xhci, &xhci_plat_cdns3_xhci,
+			sizeof(struct xhci_plat_priv));
+	if (ret)
+		goto err1;
+
 	ret = platform_device_add(xhci);
 	if (ret) {
 		dev_err(cdns->dev, "failed to register xHCI device\n");
@@ -56,6 +73,29 @@ static int __cdns3_host_init(struct cdns3 *cdns)
 	return ret;
 }
 
+int xhci_cdns3_suspend_quirk(struct usb_hcd *hcd)
+{
+	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
+	u32 value;
+
+	/* set usbcmd.EU3S */
+	value = readl(&xhci->op_regs->command);
+	value |= CMD_PM_INDEX;
+	writel(value, &xhci->op_regs->command);
+
+	if (hcd->regs) {
+		value = readl(hcd->regs + XECP_AUX_CTRL_REG1);
+		value |= CFG_RXDET_P3_EN;
+		writel(value, hcd->regs + XECP_AUX_CTRL_REG1);
+
+		value = readl(hcd->regs + XECP_PORT_CAP_REG);
+		value |= LPM_2_STB_SWITCH_EN;
+		writel(value, hcd->regs + XECP_PORT_CAP_REG);
+	}
+
+	return 0;
+}
+
 static void cdns3_host_exit(struct cdns3 *cdns)
 {
 	platform_device_unregister(cdns->host_dev);
-- 
2.17.1

[PATCH v3 9/9] usb: cdns3: host: add xhci_plat_priv quirk XHCI_SKIP_PHY_INIT

[Peter Chen]

cdns3 manages PHY by own DRD driver, so skip the management by
HCD core.

Signed-off-by: Peter Chen <peter.chen@nxp.com>
---
 drivers/usb/cdns3/host.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/drivers/usb/cdns3/host.c b/drivers/usb/cdns3/host.c
index 030d6421abd3..1dfbe23fa089 100644
--- a/drivers/usb/cdns3/host.c
+++ b/drivers/usb/cdns3/host.c
@@ -24,6 +24,7 @@
 #define LPM_2_STB_SWITCH_EN	(1 << 25)
 
 static const struct xhci_plat_priv xhci_plat_cdns3_xhci = {
+	.quirks = XHCI_SKIP_PHY_INIT,
 	.suspend_quirk = xhci_cdns3_suspend_quirk,
 };
 
-- 
2.17.1

RE: [PATCH v3 2/9] usb: cdns3: add runtime PM support

[Jun Li]

> -----Original Message-----
> From: Peter Chen <peter.chen@nxp.com>
> Sent: Monday, June 8, 2020 3:11 PM
> To: balbi@kernel.org; mathias.nyman@intel.com
> Cc: linux-usb@vger.kernel.org; dl-linux-imx <linux-imx@nxp.com>;
> pawell@cadence.com; rogerq@ti.com; gregkh@linuxfoundation.org; Jun Li
> <jun.li@nxp.com>; Peter Chen <peter.chen@nxp.com>
> Subject: [PATCH v3 2/9] usb: cdns3: add runtime PM support
> 
> Introduce runtime PM and wakeup interrupt handler for cdns3, the runtime PM is default
> off since other cdns3 may not implement glue layer support for runtime PM.
> 
> One typical wakeup event use case is xHCI runtime suspend will clear USBCMD.RS bit,
> after that the xHCI will not trigger any interrupts, so its parent (cdns core device)
> needs to resume xHCI device when any (wakeup) events occurs at host port.
> 
> When the controller is in low power mode, the lpm flag will be set.
> The interrupt triggered later than lpm flag is set considers as wakeup interrupt
> and handled at cdns_wakeup_irq. Once the wakeup occurs, it first disables interrupt
> to avoid later interrupt occurrence since the controller is in low power mode at
> that time, and access registers may be invalid at that time. At wakeup handler,
> it will call pm_request_resume to wakeup xHCI device, and at runtime resume handler,
> it will enable interrupt again.
> 
> The API platform_suspend is introduced for glue layer to implement platform specific
> PM sequence.
> 
> Signed-off-by: Peter Chen <peter.chen@nxp.com>
> ---
>  drivers/usb/cdns3/core.c   | 155 +++++++++++++++++++++++++++++++++----
>  drivers/usb/cdns3/core.h   |  16 ++++
>  drivers/usb/cdns3/drd.c    |   3 +
>  drivers/usb/cdns3/gadget.c |   4 +
>  drivers/usb/cdns3/host.c   |   7 ++
>  5 files changed, 168 insertions(+), 17 deletions(-)
> 
> diff --git a/drivers/usb/cdns3/core.c b/drivers/usb/cdns3/core.c index
> bfd09aa98c12..97fb082ed3b4 100644
> --- a/drivers/usb/cdns3/core.c
> +++ b/drivers/usb/cdns3/core.c
> @@ -406,6 +406,30 @@ static int cdns3_set_phy_power(struct cdns3 *cdns, bool on)
>  	return 0;
>  }
> 
> +/**
> + * cdns3_wakeup_irq - interrupt handler for wakeup events
> + *
> + * @irq: irq number for cdns3 core device
> + * @data: structure of cdns3
> + *
> + * Returns IRQ_HANDLED or IRQ_NONE
> + */
> +static irqreturn_t cdns3_wakeup_irq(int irq, void *data) {
> +	struct cdns3 *cdns = data;
> +
> +	if (cdns->in_lpm) {
> +		disable_irq_nosync(irq);
> +		cdns->wakeup_int = true;
> +		if ((cdns->role == USB_ROLE_HOST) && cdns->host_dev)
> +			pm_request_resume(&cdns->host_dev->dev);
> +
> +		return IRQ_HANDLED;
> +	}
> +
> +	return IRQ_NONE;
> +}
> +
>  /**
>   * cdns3_probe - probe for cdns3 core device
>   * @pdev: Pointer to cdns3 core platform device @@ -432,6 +456,7 @@ static int
> cdns3_probe(struct platform_device *pdev)
>  		return -ENOMEM;
> 
>  	cdns->dev = dev;
> +	cdns->pdata = dev_get_platdata(dev);
> 
>  	platform_set_drvdata(pdev, cdns);
> 
> @@ -481,6 +506,15 @@ static int cdns3_probe(struct platform_device *pdev)
> 
>  	cdns->otg_res = *res;
> 
> +	cdns->wakeup_irq = platform_get_irq_byname(pdev, "wakeup");

platform_get_irq_byname_optional

> +	if (cdns->wakeup_irq == -EPROBE_DEFER)
> +		return cdns->wakeup_irq;
> +
> +	if (cdns->wakeup_irq < 0) {
> +		dev_dbg(dev, "couldn't get wakeup irq\n");
> +		cdns->wakeup_irq = 0x0;
> +	}
> +
>  	mutex_init(&cdns->mutex);
> 
>  	cdns->usb2_phy = devm_phy_optional_get(dev, "cdns3,usb2-phy"); @@ -517,6
> +551,19 @@ static int cdns3_probe(struct platform_device *pdev)
>  		goto err3;
>  	}
> 
> +	if (cdns->wakeup_irq) {
> +		ret = devm_request_threaded_irq(cdns->dev, cdns->wakeup_irq,
> +						cdns3_wakeup_irq,
> +						NULL,
> +						IRQF_SHARED,
> +						dev_name(cdns->dev), cdns);
> +
> +		if (ret) {
> +			dev_err(cdns->dev, "couldn't register wakeup irq handler\n");
> +			goto err3;
> +		}
> +	}
> +
>  	ret = cdns3_drd_init(cdns);
>  	if (ret)
>  		goto err4;
> @@ -525,9 +572,11 @@ static int cdns3_probe(struct platform_device *pdev)
>  	if (ret)
>  		goto err4;
> 
> +	spin_lock_init(&cdns->lock);
>  	device_set_wakeup_capable(dev, true);
>  	pm_runtime_set_active(dev);
>  	pm_runtime_enable(dev);
> +	pm_runtime_forbid(dev);
> 
>  	/*
>  	 * The controller needs less time between bus and controller suspend, @@ -574,52
> +623,124 @@ static int cdns3_remove(struct platform_device *pdev)
>  	return 0;
>  }
> 
> -#ifdef CONFIG_PM_SLEEP
> +#ifdef CONFIG_PM
> 
> -static int cdns3_suspend(struct device *dev)
> +static int cdns3_set_platform_suspend(struct device *dev,
> +		bool suspend, bool wakeup)
> +{
> +	struct cdns3 *cdns = dev_get_drvdata(dev);
> +	int ret = 0;
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&cdns->lock, flags);

This really need a big spinlock for all platforms specific
suspend operations? I see you have a 100us polling in your
platform_suspend implementation, and also the spinlock
seems can be inside your implementation to protect really
needed part.

> +	if (cdns->pdata && cdns->pdata->platform_suspend)
> +		ret = cdns->pdata->platform_suspend(dev, suspend, wakeup);
> +
> +	spin_unlock_irqrestore(&cdns->lock, flags);
> +
> +	return ret;
> +}
> +
> +static int cdns3_controller_suspend(struct device *dev, pm_message_t
> +msg)
>  {
>  	struct cdns3 *cdns = dev_get_drvdata(dev);
> +	bool wakeup;
>  	unsigned long flags;
> 
> -	if (cdns->role == USB_ROLE_HOST)
> +	if (cdns->in_lpm)
>  		return 0;
> 
> -	if (pm_runtime_status_suspended(dev))
> -		pm_runtime_resume(dev);
> +	if (PMSG_IS_AUTO(msg))
> +		wakeup = true;
> +	else
> +		wakeup = device_may_wakeup(dev);
> 
> -	if (cdns->roles[cdns->role]->suspend) {
> -		spin_lock_irqsave(&cdns->gadget_dev->lock, flags);
> -		cdns->roles[cdns->role]->suspend(cdns, false);
> -		spin_unlock_irqrestore(&cdns->gadget_dev->lock, flags);
> -	}
> +	cdns3_set_platform_suspend(cdns->dev, true, wakeup);
> +	cdns3_set_phy_power(cdns, false);
> +	spin_lock_irqsave(&cdns->lock, flags);
> +	cdns->in_lpm = true;
> +	spin_unlock_irqrestore(&cdns->lock, flags);
> 
>  	return 0;
>  }
> 
> -static int cdns3_resume(struct device *dev)
> +static int cdns3_controller_resume(struct device *dev, pm_message_t
> +msg)
>  {
>  	struct cdns3 *cdns = dev_get_drvdata(dev);
> +	int ret;
>  	unsigned long flags;
> 
> -	if (cdns->role == USB_ROLE_HOST)
> +	if (!cdns->in_lpm)
>  		return 0;
> 
> -	if (cdns->roles[cdns->role]->resume) {
> -		spin_lock_irqsave(&cdns->gadget_dev->lock, flags);
> +	ret = cdns3_set_phy_power(cdns, true);
> +	if (ret)
> +		return ret;
> +
> +	cdns3_set_platform_suspend(cdns->dev, false, false);
> +
> +	spin_lock_irqsave(&cdns->lock, flags);
> +	if (cdns->roles[cdns->role]->resume && !PMSG_IS_AUTO(msg))
>  		cdns->roles[cdns->role]->resume(cdns, false);
> -		spin_unlock_irqrestore(&cdns->gadget_dev->lock, flags);
> +
> +	cdns->in_lpm = false;
> +	spin_unlock_irqrestore(&cdns->lock, flags);
> +	if (cdns->wakeup_int) {
> +		cdns->wakeup_int = false;
> +		enable_irq(cdns->otg_irq);

enable_irq(cdns->wakeup_irq)

>  	}
> 
> +	return ret;
> +}
> +
> +static int cdns3_runtime_suspend(struct device *dev) {
> +	return cdns3_controller_suspend(dev, PMSG_AUTO_SUSPEND); }
> +
> +static int cdns3_runtime_resume(struct device *dev) {
> +	return cdns3_controller_resume(dev, PMSG_AUTO_RESUME); } #ifdef
> +CONFIG_PM_SLEEP
> +
> +static int cdns3_suspend(struct device *dev) {
> +	struct cdns3 *cdns = dev_get_drvdata(dev);
> +	unsigned long flags;
> +
> +	if (pm_runtime_status_suspended(dev))
> +		pm_runtime_resume(dev);
> +
> +	if (cdns->roles[cdns->role]->suspend) {
> +		spin_lock_irqsave(&cdns->lock, flags);
> +		cdns->roles[cdns->role]->suspend(cdns, false);
> +		spin_unlock_irqrestore(&cdns->lock, flags);
> +	}
> +
> +	return cdns3_controller_suspend(dev, PMSG_SUSPEND); }
> +
> +static int cdns3_resume(struct device *dev) {
> +	int ret;
> +
> +	ret = cdns3_controller_resume(dev, PMSG_RESUME);
> +	if (ret)
> +		return ret;
> +
>  	pm_runtime_disable(dev);
>  	pm_runtime_set_active(dev);
>  	pm_runtime_enable(dev);
> 
> -	return 0;
> +	return ret;
>  }
> -#endif
> +#endif /* CONFIG_PM_SLEEP */
> +#endif /* CONFIG_PM */
> 
>  static const struct dev_pm_ops cdns3_pm_ops = {
>  	SET_SYSTEM_SLEEP_PM_OPS(cdns3_suspend, cdns3_resume)
> +	SET_RUNTIME_PM_OPS(cdns3_runtime_suspend, cdns3_runtime_resume, NULL)
>  };
> 
>  #ifdef CONFIG_OF
> diff --git a/drivers/usb/cdns3/core.h b/drivers/usb/cdns3/core.h index
> 1ad1f1fe61e9..fdbcf557a61f 100644
> --- a/drivers/usb/cdns3/core.h
> +++ b/drivers/usb/cdns3/core.h
> @@ -38,6 +38,12 @@ struct cdns3_role_driver {  };
> 
>  #define CDNS3_XHCI_RESOURCES_NUM	2
> +
> +struct cdns3_platform_data {
> +	int (*platform_suspend)(struct device *dev,
> +			bool suspend, bool wakeup);
> +};
> +
>  /**
>   * struct cdns3 - Representation of Cadence USB3 DRD controller.
>   * @dev: pointer to Cadence device struct @@ -50,6 +56,7 @@ struct cdns3_role_driver
> {
>   * @otg_regs: pointer to base of otg registers
>   * @otg_irq: irq number for otg controller
>   * @dev_irq: irq number for device controller
> + * @dev_irq: irq number for wakeup event

@wakeup_irq

>   * @roles: array of supported roles for this controller
>   * @role: current role
>   * @host_dev: the child host device pointer for cdns3 core @@ -62,6 +69,10 @@ struct
> cdns3_role_driver {
>   *           This field based on firmware setting, kernel configuration
>   *           and hardware configuration.
>   * @role_sw: pointer to role switch object.
> + * @in_lpm: indicate the controller is in low power mode
> + * @wakeup_int: wakeup interrupt occurs
> + * @pdata: platform data from glue layer
> + * @lock: spinlock structure
>   */
>  struct cdns3 {
>  	struct device			*dev;
> @@ -79,6 +90,7 @@ struct cdns3 {
> 
>  	int				otg_irq;
>  	int				dev_irq;
> +	int				wakeup_irq;
>  	struct cdns3_role_driver	*roles[USB_ROLE_DEVICE + 1];
>  	enum usb_role			role;
>  	struct platform_device		*host_dev;
> @@ -89,6 +101,10 @@ struct cdns3 {
>  	struct mutex			mutex;
>  	enum usb_dr_mode		dr_mode;
>  	struct usb_role_switch		*role_sw;
> +	bool				in_lpm;
> +	bool				wakeup_int;

Too close to wakeup_irq, maybe wakeup_pending?

Li Jun
> +	struct cdns3_platform_data	*pdata;
> +	spinlock_t			lock;
>  };
> 
>  int cdns3_hw_role_switch(struct cdns3 *cdns); diff --git
> a/drivers/usb/cdns3/drd.c b/drivers/usb/cdns3/drd.c index
> 58089841ed52..ac90a484e63c 100644
> --- a/drivers/usb/cdns3/drd.c
> +++ b/drivers/usb/cdns3/drd.c
> @@ -281,6 +281,9 @@ static irqreturn_t cdns3_drd_irq(int irq, void *data)
>  	if (cdns->dr_mode != USB_DR_MODE_OTG)
>  		return ret;
> 
> +	if (cdns->in_lpm)
> +		return ret;
> +
>  	reg = readl(&cdns->otg_regs->ivect);
> 
>  	if (!reg)
> diff --git a/drivers/usb/cdns3/gadget.c b/drivers/usb/cdns3/gadget.c index
> 7babba9dd916..eac01b1a4958 100644
> --- a/drivers/usb/cdns3/gadget.c
> +++ b/drivers/usb/cdns3/gadget.c
> @@ -1765,9 +1765,13 @@ static void cdns3_check_usb_interrupt_proceed(struct
> cdns3_device *priv_dev,  static irqreturn_t cdns3_device_irq_handler(int irq, void
> *data)  {
>  	struct cdns3_device *priv_dev = data;
> +	struct cdns3 *cdns = dev_get_drvdata(priv_dev->dev);
>  	irqreturn_t ret = IRQ_NONE;
>  	u32 reg;
> 
> +	if (cdns->in_lpm)
> +		return ret;
> +
>  	/* check USB device interrupt */
>  	reg = readl(&priv_dev->regs->usb_ists);
>  	if (reg) {
> diff --git a/drivers/usb/cdns3/host.c b/drivers/usb/cdns3/host.c index
> ad788bf3fe4f..b579ef15f4e0 100644
> --- a/drivers/usb/cdns3/host.c
> +++ b/drivers/usb/cdns3/host.c
> @@ -13,11 +13,13 @@
>  #include "core.h"
>  #include "drd.h"
>  #include "host-export.h"
> +#include <linux/usb/hcd.h>
> 
>  static int __cdns3_host_init(struct cdns3 *cdns)  {
>  	struct platform_device *xhci;
>  	int ret;
> +	struct usb_hcd *hcd;
> 
>  	cdns3_drd_switch_host(cdns, 1);
> 
> @@ -43,6 +45,11 @@ static int __cdns3_host_init(struct cdns3 *cdns)
>  		goto err1;
>  	}
> 
> +	/* Glue needs to access xHCI region register for Power management */
> +	hcd = platform_get_drvdata(xhci);
> +	if (hcd)
> +		cdns->xhci_regs = hcd->regs;
> +
>  	return 0;
>  err1:
>  	platform_device_put(xhci);
> --
> 2.17.1

Re: [PATCH v3 2/9] usb: cdns3: add runtime PM support

[Peter Chen]

On 20-06-10 06:10:15, Jun Li wrote:
> >  /**
> >   * cdns3_probe - probe for cdns3 core device
> >   * @pdev: Pointer to cdns3 core platform device @@ -432,6 +456,7 @@ static int
> > cdns3_probe(struct platform_device *pdev)
> >  		return -ENOMEM;
> > 
> >  	cdns->dev = dev;
> > +	cdns->pdata = dev_get_platdata(dev);
> > 
> >  	platform_set_drvdata(pdev, cdns);
> > 
> > @@ -481,6 +506,15 @@ static int cdns3_probe(struct platform_device *pdev)
> > 
> >  	cdns->otg_res = *res;
> > 
> > +	cdns->wakeup_irq = platform_get_irq_byname(pdev, "wakeup");
> 
> platform_get_irq_byname_optional

Ok
> 
> > +	if (cdns->wakeup_irq == -EPROBE_DEFER)
> > +		return cdns->wakeup_irq;
> > +
> > +	if (cdns->wakeup_irq < 0) {
> > +		dev_dbg(dev, "couldn't get wakeup irq\n");
> > +		cdns->wakeup_irq = 0x0;
> > +	}
> > +
> >  	mutex_init(&cdns->mutex);
> > 
> >  	cdns->usb2_phy = devm_phy_optional_get(dev, "cdns3,usb2-phy"); @@ -517,6
> > +551,19 @@ static int cdns3_probe(struct platform_device *pdev)
> >  		goto err3;
> >  	}
> > 
> > +	if (cdns->wakeup_irq) {
> > +		ret = devm_request_threaded_irq(cdns->dev, cdns->wakeup_irq,
> > +						cdns3_wakeup_irq,
> > +						NULL,
> > +						IRQF_SHARED,
> > +						dev_name(cdns->dev), cdns);
> > +
> > +		if (ret) {
> > +			dev_err(cdns->dev, "couldn't register wakeup irq handler\n");
> > +			goto err3;
> > +		}
> > +	}
> > +
> >  	ret = cdns3_drd_init(cdns);
> >  	if (ret)
> >  		goto err4;
> > @@ -525,9 +572,11 @@ static int cdns3_probe(struct platform_device *pdev)
> >  	if (ret)
> >  		goto err4;
> > 
> > +	spin_lock_init(&cdns->lock);
> >  	device_set_wakeup_capable(dev, true);
> >  	pm_runtime_set_active(dev);
> >  	pm_runtime_enable(dev);
> > +	pm_runtime_forbid(dev);
> > 
> >  	/*
> >  	 * The controller needs less time between bus and controller suspend, @@ -574,52
> > +623,124 @@ static int cdns3_remove(struct platform_device *pdev)
> >  	return 0;
> >  }
> > 
> > -#ifdef CONFIG_PM_SLEEP
> > +#ifdef CONFIG_PM
> > 
> > -static int cdns3_suspend(struct device *dev)
> > +static int cdns3_set_platform_suspend(struct device *dev,
> > +		bool suspend, bool wakeup)
> > +{
> > +	struct cdns3 *cdns = dev_get_drvdata(dev);
> > +	int ret = 0;
> > +	unsigned long flags;
> > +
> > +	spin_lock_irqsave(&cdns->lock, flags);
> 
> This really need a big spinlock for all platforms specific
> suspend operations? I see you have a 100us polling in your
> platform_suspend implementation, and also the spinlock
> seems can be inside your implementation to protect really
> needed part.

It will remove this spinlock, some other platforms may could
sleep at its glue layer.

> 
> > +	if (cdns->pdata && cdns->pdata->platform_suspend)
> > +		ret = cdns->pdata->platform_suspend(dev, suspend, wakeup);
> > +
> > +	spin_unlock_irqrestore(&cdns->lock, flags);
> > +
> > +	return ret;
> > +}
> > +
> > +static int cdns3_controller_suspend(struct device *dev, pm_message_t
> > +msg)
> >  {
> >  	struct cdns3 *cdns = dev_get_drvdata(dev);
> > +	bool wakeup;
> >  	unsigned long flags;
> > 
> > -	if (cdns->role == USB_ROLE_HOST)
> > +	if (cdns->in_lpm)
> >  		return 0;
> > 
> > -	if (pm_runtime_status_suspended(dev))
> > -		pm_runtime_resume(dev);
> > +	if (PMSG_IS_AUTO(msg))
> > +		wakeup = true;
> > +	else
> > +		wakeup = device_may_wakeup(dev);
> > 
> > -	if (cdns->roles[cdns->role]->suspend) {
> > -		spin_lock_irqsave(&cdns->gadget_dev->lock, flags);
> > -		cdns->roles[cdns->role]->suspend(cdns, false);
> > -		spin_unlock_irqrestore(&cdns->gadget_dev->lock, flags);
> > -	}
> > +	cdns3_set_platform_suspend(cdns->dev, true, wakeup);
> > +	cdns3_set_phy_power(cdns, false);
> > +	spin_lock_irqsave(&cdns->lock, flags);
> > +	cdns->in_lpm = true;
> > +	spin_unlock_irqrestore(&cdns->lock, flags);
> > 
> >  	return 0;
> >  }
> > 
> > -static int cdns3_resume(struct device *dev)
> > +static int cdns3_controller_resume(struct device *dev, pm_message_t
> > +msg)
> >  {
> >  	struct cdns3 *cdns = dev_get_drvdata(dev);
> > +	int ret;
> >  	unsigned long flags;
> > 
> > -	if (cdns->role == USB_ROLE_HOST)
> > +	if (!cdns->in_lpm)
> >  		return 0;
> > 
> > -	if (cdns->roles[cdns->role]->resume) {
> > -		spin_lock_irqsave(&cdns->gadget_dev->lock, flags);
> > +	ret = cdns3_set_phy_power(cdns, true);
> > +	if (ret)
> > +		return ret;
> > +
> > +	cdns3_set_platform_suspend(cdns->dev, false, false);
> > +
> > +	spin_lock_irqsave(&cdns->lock, flags);
> > +	if (cdns->roles[cdns->role]->resume && !PMSG_IS_AUTO(msg))
> >  		cdns->roles[cdns->role]->resume(cdns, false);
> > -		spin_unlock_irqrestore(&cdns->gadget_dev->lock, flags);
> > +
> > +	cdns->in_lpm = false;
> > +	spin_unlock_irqrestore(&cdns->lock, flags);
> > +	if (cdns->wakeup_int) {
> > +		cdns->wakeup_int = false;
> > +		enable_irq(cdns->otg_irq);
> 
> enable_irq(cdns->wakeup_irq)

OK

> 
> >  	}
> > 
> > +	return ret;
> > +}
> > +
> > +static int cdns3_runtime_suspend(struct device *dev) {
> > +	return cdns3_controller_suspend(dev, PMSG_AUTO_SUSPEND); }
> > +
> > +static int cdns3_runtime_resume(struct device *dev) {
> > +	return cdns3_controller_resume(dev, PMSG_AUTO_RESUME); } #ifdef
> > +CONFIG_PM_SLEEP
> > +
> > +static int cdns3_suspend(struct device *dev) {
> > +	struct cdns3 *cdns = dev_get_drvdata(dev);
> > +	unsigned long flags;
> > +
> > +	if (pm_runtime_status_suspended(dev))
> > +		pm_runtime_resume(dev);
> > +
> > +	if (cdns->roles[cdns->role]->suspend) {
> > +		spin_lock_irqsave(&cdns->lock, flags);
> > +		cdns->roles[cdns->role]->suspend(cdns, false);
> > +		spin_unlock_irqrestore(&cdns->lock, flags);
> > +	}
> > +
> > +	return cdns3_controller_suspend(dev, PMSG_SUSPEND); }
> > +
> > +static int cdns3_resume(struct device *dev) {
> > +	int ret;
> > +
> > +	ret = cdns3_controller_resume(dev, PMSG_RESUME);
> > +	if (ret)
> > +		return ret;
> > +
> >  	pm_runtime_disable(dev);
> >  	pm_runtime_set_active(dev);
> >  	pm_runtime_enable(dev);
> > 
> > -	return 0;
> > +	return ret;
> >  }
> > -#endif
> > +#endif /* CONFIG_PM_SLEEP */
> > +#endif /* CONFIG_PM */
> > 
> >  static const struct dev_pm_ops cdns3_pm_ops = {
> >  	SET_SYSTEM_SLEEP_PM_OPS(cdns3_suspend, cdns3_resume)
> > +	SET_RUNTIME_PM_OPS(cdns3_runtime_suspend, cdns3_runtime_resume, NULL)
> >  };
> > 
> >  #ifdef CONFIG_OF
> > diff --git a/drivers/usb/cdns3/core.h b/drivers/usb/cdns3/core.h index
> > 1ad1f1fe61e9..fdbcf557a61f 100644
> > --- a/drivers/usb/cdns3/core.h
> > +++ b/drivers/usb/cdns3/core.h
> > @@ -38,6 +38,12 @@ struct cdns3_role_driver {  };
> > 
> >  #define CDNS3_XHCI_RESOURCES_NUM	2
> > +
> > +struct cdns3_platform_data {
> > +	int (*platform_suspend)(struct device *dev,
> > +			bool suspend, bool wakeup);
> > +};
> > +
> >  /**
> >   * struct cdns3 - Representation of Cadence USB3 DRD controller.
> >   * @dev: pointer to Cadence device struct @@ -50,6 +56,7 @@ struct cdns3_role_driver
> > {
> >   * @otg_regs: pointer to base of otg registers
> >   * @otg_irq: irq number for otg controller
> >   * @dev_irq: irq number for device controller
> > + * @dev_irq: irq number for wakeup event
> 
> @wakeup_irq

Ok

> 
> >   * @roles: array of supported roles for this controller
> >   * @role: current role
> >   * @host_dev: the child host device pointer for cdns3 core @@ -62,6 +69,10 @@ struct
> > cdns3_role_driver {
> >   *           This field based on firmware setting, kernel configuration
> >   *           and hardware configuration.
> >   * @role_sw: pointer to role switch object.
> > + * @in_lpm: indicate the controller is in low power mode
> > + * @wakeup_int: wakeup interrupt occurs
> > + * @pdata: platform data from glue layer
> > + * @lock: spinlock structure
> >   */
> >  struct cdns3 {
> >  	struct device			*dev;
> > @@ -79,6 +90,7 @@ struct cdns3 {
> > 
> >  	int				otg_irq;
> >  	int				dev_irq;
> > +	int				wakeup_irq;
> >  	struct cdns3_role_driver	*roles[USB_ROLE_DEVICE + 1];
> >  	enum usb_role			role;
> >  	struct platform_device		*host_dev;
> > @@ -89,6 +101,10 @@ struct cdns3 {
> >  	struct mutex			mutex;
> >  	enum usb_dr_mode		dr_mode;
> >  	struct usb_role_switch		*role_sw;
> > +	bool				in_lpm;
> > +	bool				wakeup_int;
> 
> Too close to wakeup_irq, maybe wakeup_pending?

OK

Peter
> 
> Li Jun
> > +	struct cdns3_platform_data	*pdata;
> > +	spinlock_t			lock;
> >  };
> > 
> >  int cdns3_hw_role_switch(struct cdns3 *cdns); diff --git
> > a/drivers/usb/cdns3/drd.c b/drivers/usb/cdns3/drd.c index
> > 58089841ed52..ac90a484e63c 100644
> > --- a/drivers/usb/cdns3/drd.c
> > +++ b/drivers/usb/cdns3/drd.c
> > @@ -281,6 +281,9 @@ static irqreturn_t cdns3_drd_irq(int irq, void *data)
> >  	if (cdns->dr_mode != USB_DR_MODE_OTG)
> >  		return ret;
> > 
> > +	if (cdns->in_lpm)
> > +		return ret;
> > +
> >  	reg = readl(&cdns->otg_regs->ivect);
> > 
> >  	if (!reg)
> > diff --git a/drivers/usb/cdns3/gadget.c b/drivers/usb/cdns3/gadget.c index
> > 7babba9dd916..eac01b1a4958 100644
> > --- a/drivers/usb/cdns3/gadget.c
> > +++ b/drivers/usb/cdns3/gadget.c
> > @@ -1765,9 +1765,13 @@ static void cdns3_check_usb_interrupt_proceed(struct
> > cdns3_device *priv_dev,  static irqreturn_t cdns3_device_irq_handler(int irq, void
> > *data)  {
> >  	struct cdns3_device *priv_dev = data;
> > +	struct cdns3 *cdns = dev_get_drvdata(priv_dev->dev);
> >  	irqreturn_t ret = IRQ_NONE;
> >  	u32 reg;
> > 
> > +	if (cdns->in_lpm)
> > +		return ret;
> > +
> >  	/* check USB device interrupt */
> >  	reg = readl(&priv_dev->regs->usb_ists);
> >  	if (reg) {
> > diff --git a/drivers/usb/cdns3/host.c b/drivers/usb/cdns3/host.c index
> > ad788bf3fe4f..b579ef15f4e0 100644
> > --- a/drivers/usb/cdns3/host.c
> > +++ b/drivers/usb/cdns3/host.c
> > @@ -13,11 +13,13 @@
> >  #include "core.h"
> >  #include "drd.h"
> >  #include "host-export.h"
> > +#include <linux/usb/hcd.h>
> > 
> >  static int __cdns3_host_init(struct cdns3 *cdns)  {
> >  	struct platform_device *xhci;
> >  	int ret;
> > +	struct usb_hcd *hcd;
> > 
> >  	cdns3_drd_switch_host(cdns, 1);
> > 
> > @@ -43,6 +45,11 @@ static int __cdns3_host_init(struct cdns3 *cdns)
> >  		goto err1;
> >  	}
> > 
> > +	/* Glue needs to access xHCI region register for Power management */
> > +	hcd = platform_get_drvdata(xhci);
> > +	if (hcd)
> > +		cdns->xhci_regs = hcd->regs;
> > +
> >  	return 0;
> >  err1:
> >  	platform_device_put(xhci);
> > --
> > 2.17.1
> 

-- 

Thanks,
Peter Chen

Re: [PATCH v3 0/9] usb: some PM changes for cdns3 and xhci-plat

[Peter Chen]

On Mon, Jun 8, 2020 at 3:12 PM Peter Chen <peter.chen@nxp.com> wrote:
>

Hi Felipe, Pawel, and Roger,

Would you please have any comments for this series?

Peter

> Hi Felipe & Mathias,
>
> In this series, it adds cdns3 runtime PM support as well as some
> xhci-plat changes, and verified at NXP i.MX8QM and i.MX8QXP platforms.
>
> Patch 1-3: add main runtime PM support for cdns3 core and imx glue layer
> Patch 4-9: add platform data support and two quirks for xhci-plat.c.
> - .suspend_quirk for platform special sequence between xhci_bus_suspend
> and xhci_suspend.
> - add XHCI_SKIP_PHY_INIT quirk for skip PHY management from HCD core.
>
> Changes for v2:
> Add Jun Li’s reviewed-by [Patch 1 and Patch 6]
> Add Mathias’s acked-by [Patch 4-6]
> Some wakeup logic improvement [Patch 2]
> Add dedicated wakeup interrupt for core, and improve the commit log [Patch]
> Fix build error found by kbuild test robot [Patch 3]
> Using xhci_plat_priv quirk for skip PHY initialization [patch 7, patch 9]
> Some other typo and tiny improvements
>
> Changes for v1:
> - Add the 1st patch. Without it, the build on the usb-next will fail.
> - Change the subject for cover letter a little to reflect all contents.
>
> Peter Chen (9):
>   usb: cdns3: introduce cdns3_set_phy_power API
>   usb: cdns3: add runtime PM support
>   usb: cdns3: imx: add glue layer runtime pm implementation
>   usb: host: xhci-plat: add platform data support
>   usb: host: xhci-plat: add .suspend_quirk for struct xhci_plat_priv
>   usb: host: xhci-plat: delete the unnecessary code
>   usb: host: xhci-plat: add priv quirk for skip PHY initialization
>   usb: cdns3: host: add .suspend_quirk for xhci-plat.c
>   usb: cdns3: host: add xhci_plat_priv quirk XHCI_SKIP_PHY_INIT
>
>  drivers/usb/cdns3/cdns3-imx.c   | 203 ++++++++++++++++++++++++++++++--
>  drivers/usb/cdns3/core.c        | 199 ++++++++++++++++++++++++++-----
>  drivers/usb/cdns3/core.h        |  16 +++
>  drivers/usb/cdns3/drd.c         |   3 +
>  drivers/usb/cdns3/gadget.c      |   4 +
>  drivers/usb/cdns3/host-export.h |   6 +
>  drivers/usb/cdns3/host.c        |  48 ++++++++
>  drivers/usb/host/xhci-plat.c    |  36 +++++-
>  drivers/usb/host/xhci-plat.h    |   1 +
>  drivers/usb/host/xhci.h         |   1 +
>  10 files changed, 469 insertions(+), 48 deletions(-)
>
> --
> 2.17.1
>