1 files changed, 115 insertions, 3 deletions

diff --git a/drivers/usb/musb/musb_dsps.c b/drivers/usb/musb/musb_dsps.c
index 1901f6fe5807..7a109eae9b9a 100644
--- a/drivers/usb/musb/musb_dsps.c
+++ b/drivers/usb/musb/musb_dsps.c
@@ -29,7 +29,6 @@
  * da8xx.c would be merged to this file after testing.
  */
 
-#include <linux/init.h>
 #include <linux/io.h>
 #include <linux/err.h>
 #include <linux/platform_device.h>
@@ -83,6 +82,8 @@ struct dsps_musb_wrapper {
         u16     coreintr_status;
         u16     phy_utmi;
         u16     mode;
+        u16     tx_mode;
+        u16     rx_mode;
 
         /* bit positions for control */
         unsigned        reset:5;
@@ -106,10 +107,24 @@ struct dsps_musb_wrapper {
 
         /* bit positions for mode */
         unsigned        iddig:5;
+        unsigned        iddig_mux:5;
         /* miscellaneous stuff */
         u8              poll_seconds;
 };
 
+/*
+ * register shadow for suspend
+ */
+struct dsps_context {
+        u32 control;
+        u32 epintr;
+        u32 coreintr;
+        u32 phy_utmi;
+        u32 mode;
+        u32 tx_mode;
+        u32 rx_mode;
+};
+
 /**
  * DSPS glue structure.
  */
@@ -119,6 +134,8 @@ struct dsps_glue {
         const struct dsps_musb_wrapper *wrp; /* wrapper register offsets */
         struct timer_list timer;        /* otg_workaround timer */
         unsigned long last_timer;    /* last timer data for each instance */
+
+        struct dsps_context context;
 };
 
 static void dsps_musb_try_idle(struct musb *musb, unsigned long timeout)
@@ -341,8 +358,9 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
         if (musb->int_tx || musb->int_rx || musb->int_usb)
                 ret |= musb_interrupt(musb);
 
-        /* Poll for ID change */
-        if (musb->xceiv->state == OTG_STATE_B_IDLE)
+        /* Poll for ID change in OTG port mode */
+        if (musb->xceiv->state == OTG_STATE_B_IDLE &&
+                        musb->port_mode == MUSB_PORT_MODE_DUAL_ROLE)
                 mod_timer(&glue->timer, jiffies + wrp->poll_seconds * HZ);
 out:
         spin_unlock_irqrestore(&musb->lock, flags);
@@ -406,6 +424,54 @@ static int dsps_musb_exit(struct musb *musb)
         return 0;
 }
 
+static int dsps_musb_set_mode(struct musb *musb, u8 mode)
+{
+        struct device *dev = musb->controller;
+        struct dsps_glue *glue = dev_get_drvdata(dev->parent);
+        const struct dsps_musb_wrapper *wrp = glue->wrp;
+        void __iomem *ctrl_base = musb->ctrl_base;
+        void __iomem *base = musb->mregs;
+        u32 reg;
+
+        reg = dsps_readl(base, wrp->mode);
+
+        switch (mode) {
+        case MUSB_HOST:
+                reg &= ~(1 << wrp->iddig);
+
+                /*
+                 * if we're setting mode to host-only or device-only, we're
+                 * going to ignore whatever the PHY sends us and just force
+                 * ID pin status by SW
+                 */
+                reg |= (1 << wrp->iddig_mux);
+
+                dsps_writel(base, wrp->mode, reg);
+                dsps_writel(ctrl_base, wrp->phy_utmi, 0x02);
+                break;
+        case MUSB_PERIPHERAL:
+                reg |= (1 << wrp->iddig);
+
+                /*
+                 * if we're setting mode to host-only or device-only, we're
+                 * going to ignore whatever the PHY sends us and just force
+                 * ID pin status by SW
+                 */
+                reg |= (1 << wrp->iddig_mux);
+
+                dsps_writel(base, wrp->mode, reg);
+                break;
+        case MUSB_OTG:
+                dsps_writel(base, wrp->phy_utmi, 0x02);
+                break;
+        default:
+                dev_err(glue->dev, "unsupported mode %d\n", mode);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 static struct musb_platform_ops dsps_ops = {
         .init           = dsps_musb_init,
         .exit           = dsps_musb_exit,
@@ -414,6 +480,7 @@ static struct musb_platform_ops dsps_ops = {
         .disable        = dsps_musb_disable,
 
         .try_idle       = dsps_musb_try_idle,
+        .set_mode       = dsps_musb_set_mode,
 };
 
 static u64 musb_dmamask = DMA_BIT_MASK(32);
@@ -507,6 +574,7 @@ static int dsps_create_musb_pdev(struct dsps_glue *glue,
 
         config->num_eps = get_int_prop(dn, "mentor,num-eps");
         config->ram_bits = get_int_prop(dn, "mentor,ram-bits");
+        config->host_port_deassert_reset_at_resume = 1;
         pdata.mode = get_musb_port_mode(dev);
         /* DT keeps this entry in mA, musb expects it as per USB spec */
         pdata.power = get_int_prop(dn, "mentor,power") / 2;
@@ -605,9 +673,12 @@ static const struct dsps_musb_wrapper am33xx_driver_data = {
         .coreintr_status        = 0x34,
         .phy_utmi               = 0xe0,
         .mode                   = 0xe8,
+        .tx_mode                = 0x70,
+        .rx_mode                = 0x74,
         .reset                  = 0,
         .otg_disable            = 21,
         .iddig                  = 8,
+        .iddig_mux              = 7,
         .usb_shift              = 0,
         .usb_mask               = 0x1ff,
         .usb_bitmap             = (0x1ff << 0),
@@ -628,11 +699,52 @@ static const struct of_device_id musb_dsps_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, musb_dsps_of_match);
 
+#ifdef CONFIG_PM
+static int dsps_suspend(struct device *dev)
+{
+        struct dsps_glue *glue = dev_get_drvdata(dev);
+        const struct dsps_musb_wrapper *wrp = glue->wrp;
+        struct musb *musb = platform_get_drvdata(glue->musb);
+        void __iomem *mbase = musb->ctrl_base;
+
+        glue->context.control = dsps_readl(mbase, wrp->control);
+        glue->context.epintr = dsps_readl(mbase, wrp->epintr_set);
+        glue->context.coreintr = dsps_readl(mbase, wrp->coreintr_set);
+        glue->context.phy_utmi = dsps_readl(mbase, wrp->phy_utmi);
+        glue->context.mode = dsps_readl(mbase, wrp->mode);
+        glue->context.tx_mode = dsps_readl(mbase, wrp->tx_mode);
+        glue->context.rx_mode = dsps_readl(mbase, wrp->rx_mode);
+
+        return 0;
+}
+
+static int dsps_resume(struct device *dev)
+{
+        struct dsps_glue *glue = dev_get_drvdata(dev);
+        const struct dsps_musb_wrapper *wrp = glue->wrp;
+        struct musb *musb = platform_get_drvdata(glue->musb);
+        void __iomem *mbase = musb->ctrl_base;
+
+        dsps_writel(mbase, wrp->control, glue->context.control);
+        dsps_writel(mbase, wrp->epintr_set, glue->context.epintr);
+        dsps_writel(mbase, wrp->coreintr_set, glue->context.coreintr);
+        dsps_writel(mbase, wrp->phy_utmi, glue->context.phy_utmi);
+        dsps_writel(mbase, wrp->mode, glue->context.mode);
+        dsps_writel(mbase, wrp->tx_mode, glue->context.tx_mode);
+        dsps_writel(mbase, wrp->rx_mode, glue->context.rx_mode);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(dsps_pm_ops, dsps_suspend, dsps_resume);
+
 static struct platform_driver dsps_usbss_driver = {
         .probe          = dsps_probe,
         .remove         = dsps_remove,
         .driver         = {
                 .name   = "musb-dsps",
+                .pm     = &dsps_pm_ops,
                 .of_match_table = musb_dsps_of_match,
         },
 };