Merge tag 'usb-3.20-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb

Pull USB patches from Greg KH:
 "Here's the big pull request for the USB driver tree for 3.20-rc1.

  Nothing major happening here, just lots of gadget driver updates, new
  device ids, and a bunch of cleanups.

  All of these have been in linux-next for a while with no reported
  issues"

* tag 'usb-3.20-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: (299 commits)
  usb: musb: fix device hotplug behind hub
  usb: dwc2: Fix a bug in reading the endpoint directions from reg.
  staging: emxx_udc: fix the build error
  usb: Retry port status check on resume to work around RH bugs
  Revert "usb: Reset USB-3 devices on USB-3 link bounce"
  uhci-hub: use HUB_CHAR_*
  usb: kconfig: replace PPC_OF with PPC
  ehci-pci: disable for Intel MID platforms (update)
  usb: gadget: Kconfig: use bool instead of boolean
  usb: musb: blackfin: remove incorrect __exit_p()
  USB: fix use-after-free bug in usb_hcd_unlink_urb()
  ehci-pci: disable for Intel MID platforms
  usb: host: pci_quirks: joing string literals
  USB: add flag for HCDs that can't receive wakeup requests (isp1760-hcd)
  USB: usbfs: allow URBs to be reaped after disconnection
  cdc-acm: kill unnecessary messages
  cdc-acm: add sanity checks
  usb: phy: phy-generic: Fix USB PHY gpio reset
  usb: dwc2: fix USB core dependencies
  usb: renesas_usbhs: fix NULL pointer dereference in dma_release_channel()
  ...

7 files changed, 369 insertions, 94 deletions

diff --git a/drivers/phy/Kconfig b/drivers/phy/Kconfig
index 26a7623e551e..2962de205ba7 100644
--- a/drivers/phy/Kconfig
+++ b/drivers/phy/Kconfig
@@ -239,6 +239,13 @@ config PHY_QCOM_IPQ806X_SATA
         depends on OF
         select GENERIC_PHY
 
+config PHY_ROCKCHIP_USB
+        tristate "Rockchip USB2 PHY Driver"
+        depends on ARCH_ROCKCHIP && OF
+        select GENERIC_PHY
+        help
+          Enable this to support the Rockchip USB 2.0 PHY.
+
 config PHY_ST_SPEAR1310_MIPHY
         tristate "ST SPEAR1310-MIPHY driver"
         select GENERIC_PHY
diff --git a/drivers/phy/Makefile b/drivers/phy/Makefile
index cfbb72064516..f080e1bb2a74 100644
--- a/drivers/phy/Makefile
+++ b/drivers/phy/Makefile
@@ -28,6 +28,7 @@ phy-exynos-usb2-$(CONFIG_PHY_EXYNOS5250_USB2)	+= phy-exynos5250-usb2.o
 phy-exynos-usb2-$(CONFIG_PHY_S5PV210_USB2)      += phy-s5pv210-usb2.o
 obj-$(CONFIG_PHY_EXYNOS5_USBDRD)        += phy-exynos5-usbdrd.o
 obj-$(CONFIG_PHY_QCOM_APQ8064_SATA)     += phy-qcom-apq8064-sata.o
+obj-$(CONFIG_PHY_ROCKCHIP_USB) += phy-rockchip-usb.o
 obj-$(CONFIG_PHY_QCOM_IPQ806X_SATA)     += phy-qcom-ipq806x-sata.o
 obj-$(CONFIG_PHY_ST_SPEAR1310_MIPHY)    += phy-spear1310-miphy.o
 obj-$(CONFIG_PHY_ST_SPEAR1340_MIPHY)    += phy-spear1340-miphy.o
diff --git a/drivers/phy/phy-armada375-usb2.c b/drivers/phy/phy-armada375-usb2.c
index ac7d99d01cb3..7c99ca256f05 100644
--- a/drivers/phy/phy-armada375-usb2.c
+++ b/drivers/phy/phy-armada375-usb2.c
@@ -118,8 +118,8 @@ static int armada375_usb_phy_probe(struct platform_device *pdev)
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         usb_cluster_base = devm_ioremap_resource(&pdev->dev, res);
-        if (!usb_cluster_base)
-                return -ENOMEM;
+        if (IS_ERR(usb_cluster_base))
+                return PTR_ERR(usb_cluster_base);
 
         phy = devm_phy_create(dev, NULL, &armada375_usb_phy_ops);
         if (IS_ERR(phy)) {
diff --git a/drivers/phy/phy-exynos-mipi-video.c b/drivers/phy/phy-exynos-mipi-video.c
index 943e0f88a120..f017b2f2a54e 100644
--- a/drivers/phy/phy-exynos-mipi-video.c
+++ b/drivers/phy/phy-exynos-mipi-video.c
@@ -12,19 +12,18 @@
 #include <linux/err.h>
 #include <linux/io.h>
 #include <linux/kernel.h>
+#include <linux/mfd/syscon/exynos4-pmu.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/phy/phy.h>
 #include <linux/platform_device.h>
+#include <linux/regmap.h>
 #include <linux/spinlock.h>
+#include <linux/mfd/syscon.h>
 
-/* MIPI_PHYn_CONTROL register offset: n = 0..1 */
+/* MIPI_PHYn_CONTROL reg. offset (for base address from ioremap): n = 0..1 */
 #define EXYNOS_MIPI_PHY_CONTROL(n)      ((n) * 4)
-#define EXYNOS_MIPI_PHY_ENABLE          (1 << 0)
-#define EXYNOS_MIPI_PHY_SRESETN         (1 << 1)
-#define EXYNOS_MIPI_PHY_MRESETN         (1 << 2)
-#define EXYNOS_MIPI_PHY_RESET_MASK      (3 << 1)
 
 enum exynos_mipi_phy_id {
         EXYNOS_MIPI_PHY_ID_CSIS0,
@@ -38,43 +37,62 @@ enum exynos_mipi_phy_id {
         ((id) == EXYNOS_MIPI_PHY_ID_DSIM0 || (id) == EXYNOS_MIPI_PHY_ID_DSIM1)
 
 struct exynos_mipi_video_phy {
-        spinlock_t slock;
         struct video_phy_desc {
                 struct phy *phy;
                 unsigned int index;
         } phys[EXYNOS_MIPI_PHYS_NUM];
+        spinlock_t slock;
         void __iomem *regs;
+        struct mutex mutex;
+        struct regmap *regmap;
 };
 
 static int __set_phy_state(struct exynos_mipi_video_phy *state,
                         enum exynos_mipi_phy_id id, unsigned int on)
 {
+        const unsigned int offset = EXYNOS4_MIPI_PHY_CONTROL(id / 2);
         void __iomem *addr;
-        u32 reg, reset;
-
-        addr = state->regs + EXYNOS_MIPI_PHY_CONTROL(id / 2);
+        u32 val, reset;
 
         if (is_mipi_dsim_phy_id(id))
-                reset = EXYNOS_MIPI_PHY_MRESETN;
-        else
-                reset = EXYNOS_MIPI_PHY_SRESETN;
-
-        spin_lock(&state->slock);
-        reg = readl(addr);
-        if (on)
-                reg |= reset;
+                reset = EXYNOS4_MIPI_PHY_MRESETN;
         else
-                reg &= ~reset;
-        writel(reg, addr);
-
-        /* Clear ENABLE bit only if MRESETN, SRESETN bits are not set. */
-        if (on)
-                reg |= EXYNOS_MIPI_PHY_ENABLE;
-        else if (!(reg & EXYNOS_MIPI_PHY_RESET_MASK))
-                reg &= ~EXYNOS_MIPI_PHY_ENABLE;
+                reset = EXYNOS4_MIPI_PHY_SRESETN;
+
+        if (state->regmap) {
+                mutex_lock(&state->mutex);
+                regmap_read(state->regmap, offset, &val);
+                if (on)
+                        val |= reset;
+                else
+                        val &= ~reset;
+                regmap_write(state->regmap, offset, val);
+                if (on)
+                        val |= EXYNOS4_MIPI_PHY_ENABLE;
+                else if (!(val & EXYNOS4_MIPI_PHY_RESET_MASK))
+                        val &= ~EXYNOS4_MIPI_PHY_ENABLE;
+                regmap_write(state->regmap, offset, val);
+                mutex_unlock(&state->mutex);
+        } else {
+                addr = state->regs + EXYNOS_MIPI_PHY_CONTROL(id / 2);
+
+                spin_lock(&state->slock);
+                val = readl(addr);
+                if (on)
+                        val |= reset;
+                else
+                        val &= ~reset;
+                writel(val, addr);
+                /* Clear ENABLE bit only if MRESETN, SRESETN bits are not set */
+                if (on)
+                        val |= EXYNOS4_MIPI_PHY_ENABLE;
+                else if (!(val & EXYNOS4_MIPI_PHY_RESET_MASK))
+                        val &= ~EXYNOS4_MIPI_PHY_ENABLE;
+
+                writel(val, addr);
+                spin_unlock(&state->slock);
+        }
 
-        writel(reg, addr);
-        spin_unlock(&state->slock);
         return 0;
 }
 
@@ -118,7 +136,6 @@ static int exynos_mipi_video_phy_probe(struct platform_device *pdev)
 {
         struct exynos_mipi_video_phy *state;
         struct device *dev = &pdev->dev;
-        struct resource *res;
         struct phy_provider *phy_provider;
         unsigned int i;
 
@@ -126,14 +143,22 @@ static int exynos_mipi_video_phy_probe(struct platform_device *pdev)
         if (!state)
                 return -ENOMEM;
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        state->regmap = syscon_regmap_lookup_by_phandle(dev->of_node, "syscon");
+        if (IS_ERR(state->regmap)) {
+                struct resource *res;
 
-        state->regs = devm_ioremap_resource(dev, res);
-        if (IS_ERR(state->regs))
-                return PTR_ERR(state->regs);
+                dev_info(dev, "regmap lookup failed: %ld\n",
+                         PTR_ERR(state->regmap));
+
+                res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+                state->regs = devm_ioremap_resource(dev, res);
+                if (IS_ERR(state->regs))
+                        return PTR_ERR(state->regs);
+        }
 
         dev_set_drvdata(dev, state);
         spin_lock_init(&state->slock);
+        mutex_init(&state->mutex);
 
         for (i = 0; i < EXYNOS_MIPI_PHYS_NUM; i++) {
                 struct phy *phy = devm_phy_create(dev, NULL,
diff --git a/drivers/phy/phy-miphy28lp.c b/drivers/phy/phy-miphy28lp.c
index 27fa62ce6136..9b2848e6115d 100644
--- a/drivers/phy/phy-miphy28lp.c
+++ b/drivers/phy/phy-miphy28lp.c
@@ -194,6 +194,14 @@
 #define MIPHY_SATA_BANK_NB      3
 #define MIPHY_PCIE_BANK_NB      2
 
+enum {
+        SYSCFG_CTRL,
+        SYSCFG_STATUS,
+        SYSCFG_PCI,
+        SYSCFG_SATA,
+        SYSCFG_REG_MAX,
+};
+
 struct miphy28lp_phy {
         struct phy *phy;
         struct miphy28lp_dev *phydev;
@@ -211,10 +219,7 @@ struct miphy28lp_phy {
         u32 sata_gen;
 
         /* Sysconfig registers offsets needed to configure the device */
-        u32 syscfg_miphy_ctrl;
-        u32 syscfg_miphy_status;
-        u32 syscfg_pci;
-        u32 syscfg_sata;
+        u32 syscfg_reg[SYSCFG_REG_MAX];
         u8 type;
 };
 
@@ -834,12 +839,12 @@ static int miphy_osc_is_ready(struct miphy28lp_phy *miphy_phy)
         if (!miphy_phy->osc_rdy)
                 return 0;
 
-        if (!miphy_phy->syscfg_miphy_status)
+        if (!miphy_phy->syscfg_reg[SYSCFG_STATUS])
                 return -EINVAL;
 
         do {
-                regmap_read(miphy_dev->regmap, miphy_phy->syscfg_miphy_status,
-                            &val);
+                regmap_read(miphy_dev->regmap,
+                                miphy_phy->syscfg_reg[SYSCFG_STATUS], &val);
 
                 if ((val & MIPHY_OSC_RDY) != MIPHY_OSC_RDY)
                         cpu_relax();
@@ -888,7 +893,7 @@ static int miphy28lp_setup(struct miphy28lp_phy *miphy_phy, u32 miphy_val)
         int err;
         struct miphy28lp_dev *miphy_dev = miphy_phy->phydev;
 
-        if (!miphy_phy->syscfg_miphy_ctrl)
+        if (!miphy_phy->syscfg_reg[SYSCFG_CTRL])
                 return -EINVAL;
 
         err = reset_control_assert(miphy_phy->miphy_rst);
@@ -900,7 +905,8 @@ static int miphy28lp_setup(struct miphy28lp_phy *miphy_phy, u32 miphy_val)
         if (miphy_phy->osc_force_ext)
                 miphy_val |= MIPHY_OSC_FORCE_EXT;
 
-        regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_miphy_ctrl,
+        regmap_update_bits(miphy_dev->regmap,
+                           miphy_phy->syscfg_reg[SYSCFG_CTRL],
                            MIPHY_CTRL_MASK, miphy_val);
 
         err = reset_control_deassert(miphy_phy->miphy_rst);
@@ -917,8 +923,9 @@ static int miphy28lp_init_sata(struct miphy28lp_phy *miphy_phy)
         struct miphy28lp_dev *miphy_dev = miphy_phy->phydev;
         int err, sata_conf = SATA_CTRL_SELECT_SATA;
 
-        if ((!miphy_phy->syscfg_sata) || (!miphy_phy->syscfg_pci)
-                || (!miphy_phy->base))
+        if ((!miphy_phy->syscfg_reg[SYSCFG_SATA]) ||
+                        (!miphy_phy->syscfg_reg[SYSCFG_PCI]) ||
+                        (!miphy_phy->base))
                 return -EINVAL;
 
         dev_info(miphy_dev->dev, "sata-up mode, addr 0x%p\n", miphy_phy->base);
@@ -926,10 +933,11 @@ static int miphy28lp_init_sata(struct miphy28lp_phy *miphy_phy)
         /* Configure the glue-logic */
         sata_conf |= ((miphy_phy->sata_gen - SATA_GEN1) << SATA_SPDMODE);
 
-        regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_sata,
+        regmap_update_bits(miphy_dev->regmap,
+                           miphy_phy->syscfg_reg[SYSCFG_SATA],
                            SATA_CTRL_MASK, sata_conf);
 
-        regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_pci,
+        regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_reg[SYSCFG_PCI],
                            PCIE_CTRL_MASK, SATA_CTRL_SELECT_PCIE);
 
         /* MiPHY path and clocking init */
@@ -951,17 +959,19 @@ static int miphy28lp_init_pcie(struct miphy28lp_phy *miphy_phy)
         struct miphy28lp_dev *miphy_dev = miphy_phy->phydev;
         int err;
 
-        if ((!miphy_phy->syscfg_sata) || (!miphy_phy->syscfg_pci)
+        if ((!miphy_phy->syscfg_reg[SYSCFG_SATA]) ||
+                        (!miphy_phy->syscfg_reg[SYSCFG_PCI])
                 || (!miphy_phy->base) || (!miphy_phy->pipebase))
                 return -EINVAL;
 
         dev_info(miphy_dev->dev, "pcie-up mode, addr 0x%p\n", miphy_phy->base);
 
         /* Configure the glue-logic */
-        regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_sata,
+        regmap_update_bits(miphy_dev->regmap,
+                           miphy_phy->syscfg_reg[SYSCFG_SATA],
                            SATA_CTRL_MASK, SATA_CTRL_SELECT_PCIE);
 
-        regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_pci,
+        regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_reg[SYSCFG_PCI],
                            PCIE_CTRL_MASK, SYSCFG_PCIE_PCIE_VAL);
 
         /* MiPHY path and clocking init */
@@ -1156,7 +1166,8 @@ static int miphy28lp_probe_resets(struct device_node *node,
 static int miphy28lp_of_probe(struct device_node *np,
                               struct miphy28lp_phy *miphy_phy)
 {
-        struct resource res;
+        int i;
+        u32 ctrlreg;
 
         miphy_phy->osc_force_ext =
                 of_property_read_bool(np, "st,osc-force-ext");
@@ -1175,18 +1186,10 @@ static int miphy28lp_of_probe(struct device_node *np,
         if (!miphy_phy->sata_gen)
                 miphy_phy->sata_gen = SATA_GEN1;
 
-        if (!miphy28lp_get_resource_byname(np, "miphy-ctrl-glue", &res))
-                miphy_phy->syscfg_miphy_ctrl = res.start;
-
-        if (!miphy28lp_get_resource_byname(np, "miphy-status-glue", &res))
-                miphy_phy->syscfg_miphy_status = res.start;
-
-        if (!miphy28lp_get_resource_byname(np, "pcie-glue", &res))
-                miphy_phy->syscfg_pci = res.start;
-
-        if (!miphy28lp_get_resource_byname(np, "sata-glue", &res))
-                miphy_phy->syscfg_sata = res.start;
-
+        for (i = 0; i < SYSCFG_REG_MAX; i++) {
+                if (!of_property_read_u32_index(np, "st,syscfg", i, &ctrlreg))
+                        miphy_phy->syscfg_reg[i] = ctrlreg;
+        }
 
         return 0;
 }
diff --git a/drivers/phy/phy-rockchip-usb.c b/drivers/phy/phy-rockchip-usb.c
new file mode 100644
index 000000000000..22011c3b6a4b
--- /dev/null
+++ b/drivers/phy/phy-rockchip-usb.c
@@ -0,0 +1,158 @@
+/*
+ * Rockchip usb PHY driver
+ *
+ * Copyright (C) 2014 Yunzhi Li <lyz@rock-chips.com>
+ * Copyright (C) 2014 ROCKCHIP, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/phy/phy.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+#include <linux/reset.h>
+#include <linux/regmap.h>
+#include <linux/mfd/syscon.h>
+
+/*
+ * The higher 16-bit of this register is used for write protection
+ * only if BIT(13 + 16) set to 1 the BIT(13) can be written.
+ */
+#define SIDDQ_WRITE_ENA BIT(29)
+#define SIDDQ_ON                BIT(13)
+#define SIDDQ_OFF               (0 << 13)
+
+struct rockchip_usb_phy {
+        unsigned int    reg_offset;
+        struct regmap   *reg_base;
+        struct clk      *clk;
+        struct phy      *phy;
+};
+
+static int rockchip_usb_phy_power(struct rockchip_usb_phy *phy,
+                                           bool siddq)
+{
+        return regmap_write(phy->reg_base, phy->reg_offset,
+                            SIDDQ_WRITE_ENA | (siddq ? SIDDQ_ON : SIDDQ_OFF));
+}
+
+static int rockchip_usb_phy_power_off(struct phy *_phy)
+{
+        struct rockchip_usb_phy *phy = phy_get_drvdata(_phy);
+        int ret = 0;
+
+        /* Power down usb phy analog blocks by set siddq 1 */
+        ret = rockchip_usb_phy_power(phy, 1);
+        if (ret)
+                return ret;
+
+        clk_disable_unprepare(phy->clk);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int rockchip_usb_phy_power_on(struct phy *_phy)
+{
+        struct rockchip_usb_phy *phy = phy_get_drvdata(_phy);
+        int ret = 0;
+
+        ret = clk_prepare_enable(phy->clk);
+        if (ret)
+                return ret;
+
+        /* Power up usb phy analog blocks by set siddq 0 */
+        ret = rockchip_usb_phy_power(phy, 0);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static struct phy_ops ops = {
+        .power_on       = rockchip_usb_phy_power_on,
+        .power_off      = rockchip_usb_phy_power_off,
+        .owner          = THIS_MODULE,
+};
+
+static int rockchip_usb_phy_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct rockchip_usb_phy *rk_phy;
+        struct phy_provider *phy_provider;
+        struct device_node *child;
+        struct regmap *grf;
+        unsigned int reg_offset;
+
+        grf = syscon_regmap_lookup_by_phandle(dev->of_node, "rockchip,grf");
+        if (IS_ERR(grf)) {
+                dev_err(&pdev->dev, "Missing rockchip,grf property\n");
+                return PTR_ERR(grf);
+        }
+
+        for_each_available_child_of_node(dev->of_node, child) {
+                rk_phy = devm_kzalloc(dev, sizeof(*rk_phy), GFP_KERNEL);
+                if (!rk_phy)
+                        return -ENOMEM;
+
+                if (of_property_read_u32(child, "reg", &reg_offset)) {
+                        dev_err(dev, "missing reg property in node %s\n",
+                                child->name);
+                        return -EINVAL;
+                }
+
+                rk_phy->reg_offset = reg_offset;
+                rk_phy->reg_base = grf;
+
+                rk_phy->clk = of_clk_get_by_name(child, "phyclk");
+                if (IS_ERR(rk_phy->clk))
+                        rk_phy->clk = NULL;
+
+                rk_phy->phy = devm_phy_create(dev, child, &ops);
+                if (IS_ERR(rk_phy->phy)) {
+                        dev_err(dev, "failed to create PHY\n");
+                        return PTR_ERR(rk_phy->phy);
+                }
+                phy_set_drvdata(rk_phy->phy, rk_phy);
+        }
+
+        phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate);
+        return PTR_ERR_OR_ZERO(phy_provider);
+}
+
+static const struct of_device_id rockchip_usb_phy_dt_ids[] = {
+        { .compatible = "rockchip,rk3288-usb-phy" },
+        {}
+};
+
+MODULE_DEVICE_TABLE(of, rockchip_usb_phy_dt_ids);
+
+static struct platform_driver rockchip_usb_driver = {
+        .probe          = rockchip_usb_phy_probe,
+        .driver         = {
+                .name   = "rockchip-usb-phy",
+                .owner  = THIS_MODULE,
+                .of_match_table = rockchip_usb_phy_dt_ids,
+        },
+};
+
+module_platform_driver(rockchip_usb_driver);
+
+MODULE_AUTHOR("Yunzhi Li <lyz@rock-chips.com>");
+MODULE_DESCRIPTION("Rockchip USB 2.0 PHY driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/phy/phy-ti-pipe3.c b/drivers/phy/phy-ti-pipe3.c
index 465de2c800f2..95c88f929f27 100644
--- a/drivers/phy/phy-ti-pipe3.c
+++ b/drivers/phy/phy-ti-pipe3.c
@@ -28,6 +28,7 @@
 #include <linux/delay.h>
 #include <linux/phy/omap_control_phy.h>
 #include <linux/of_platform.h>
+#include <linux/spinlock.h>
 
 #define PLL_STATUS              0x00000004
 #define PLL_GO                  0x00000008
@@ -82,6 +83,10 @@ struct ti_pipe3 {
         struct clk              *refclk;
         struct clk              *div_clk;
         struct pipe3_dpll_map   *dpll_map;
+        bool                    enabled;
+        spinlock_t              lock;   /* serialize clock enable/disable */
+        /* the below flag is needed specifically for SATA */
+        bool                    refclk_enabled;
 };
 
 static struct pipe3_dpll_map dpll_map_usb[] = {
@@ -307,6 +312,7 @@ static int ti_pipe3_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         phy->dev                = &pdev->dev;
+        spin_lock_init(&phy->lock);
 
         if (!of_device_is_compatible(node, "ti,phy-pipe3-pcie")) {
                 match = of_match_device(of_match_ptr(ti_pipe3_id_table),
@@ -333,21 +339,24 @@ static int ti_pipe3_probe(struct platform_device *pdev)
                 }
         }
 
+        phy->refclk = devm_clk_get(phy->dev, "refclk");
+        if (IS_ERR(phy->refclk)) {
+                dev_err(&pdev->dev, "unable to get refclk\n");
+                /* older DTBs have missing refclk in SATA PHY
+                 * so don't bail out in case of SATA PHY.
+                 */
+                if (!of_device_is_compatible(node, "ti,phy-pipe3-sata"))
+                        return PTR_ERR(phy->refclk);
+        }
+
         if (!of_device_is_compatible(node, "ti,phy-pipe3-sata")) {
                 phy->wkupclk = devm_clk_get(phy->dev, "wkupclk");
                 if (IS_ERR(phy->wkupclk)) {
                         dev_err(&pdev->dev, "unable to get wkupclk\n");
                         return PTR_ERR(phy->wkupclk);
                 }
-
-                phy->refclk = devm_clk_get(phy->dev, "refclk");
-                if (IS_ERR(phy->refclk)) {
-                        dev_err(&pdev->dev, "unable to get refclk\n");
-                        return PTR_ERR(phy->refclk);
-                }
         } else {
                 phy->wkupclk = ERR_PTR(-ENODEV);
-                phy->refclk = ERR_PTR(-ENODEV);
         }
 
         if (of_device_is_compatible(node, "ti,phy-pipe3-pcie")) {
@@ -426,33 +435,42 @@ static int ti_pipe3_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM
-
-static int ti_pipe3_runtime_suspend(struct device *dev)
+static int ti_pipe3_enable_refclk(struct ti_pipe3 *phy)
 {
-        struct ti_pipe3 *phy = dev_get_drvdata(dev);
+        if (!IS_ERR(phy->refclk) && !phy->refclk_enabled) {
+                int ret;
 
-        if (!IS_ERR(phy->wkupclk))
-                clk_disable_unprepare(phy->wkupclk);
+                ret = clk_prepare_enable(phy->refclk);
+                if (ret) {
+                        dev_err(phy->dev, "Failed to enable refclk %d\n", ret);
+                        return ret;
+                }
+                phy->refclk_enabled = true;
+        }
+
+        return 0;
+}
+
+static void ti_pipe3_disable_refclk(struct ti_pipe3 *phy)
+{
         if (!IS_ERR(phy->refclk))
                 clk_disable_unprepare(phy->refclk);
-        if (!IS_ERR(phy->div_clk))
-                clk_disable_unprepare(phy->div_clk);
 
-        return 0;
+        phy->refclk_enabled = false;
 }
 
-static int ti_pipe3_runtime_resume(struct device *dev)
+static int ti_pipe3_enable_clocks(struct ti_pipe3 *phy)
 {
-        u32 ret = 0;
-        struct ti_pipe3 *phy = dev_get_drvdata(dev);
+        int ret = 0;
+        unsigned long flags;
 
-        if (!IS_ERR(phy->refclk)) {
-                ret = clk_prepare_enable(phy->refclk);
-                if (ret) {
-                        dev_err(phy->dev, "Failed to enable refclk %d\n", ret);
-                        goto err1;
-                }
-        }
+        spin_lock_irqsave(&phy->lock, flags);
+        if (phy->enabled)
+                goto err1;
+
+        ret = ti_pipe3_enable_refclk(phy);
+        if (ret)
+                goto err1;
 
         if (!IS_ERR(phy->wkupclk)) {
                 ret = clk_prepare_enable(phy->wkupclk);
@@ -469,6 +487,9 @@ static int ti_pipe3_runtime_resume(struct device *dev)
                         goto err3;
                 }
         }
+
+        phy->enabled = true;
+        spin_unlock_irqrestore(&phy->lock, flags);
         return 0;
 
 err3:
@@ -479,20 +500,80 @@ err2:
         if (!IS_ERR(phy->refclk))
                 clk_disable_unprepare(phy->refclk);
 
+        ti_pipe3_disable_refclk(phy);
 err1:
+        spin_unlock_irqrestore(&phy->lock, flags);
         return ret;
 }
 
+static void ti_pipe3_disable_clocks(struct ti_pipe3 *phy)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&phy->lock, flags);
+        if (!phy->enabled) {
+                spin_unlock_irqrestore(&phy->lock, flags);
+                return;
+        }
+
+        if (!IS_ERR(phy->wkupclk))
+                clk_disable_unprepare(phy->wkupclk);
+        /* Don't disable refclk for SATA PHY due to Errata i783 */
+        if (!of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-sata"))
+                ti_pipe3_disable_refclk(phy);
+        if (!IS_ERR(phy->div_clk))
+                clk_disable_unprepare(phy->div_clk);
+        phy->enabled = false;
+        spin_unlock_irqrestore(&phy->lock, flags);
+}
+
+static int ti_pipe3_runtime_suspend(struct device *dev)
+{
+        struct ti_pipe3 *phy = dev_get_drvdata(dev);
+
+        ti_pipe3_disable_clocks(phy);
+        return 0;
+}
+
+static int ti_pipe3_runtime_resume(struct device *dev)
+{
+        struct ti_pipe3 *phy = dev_get_drvdata(dev);
+        int ret = 0;
+
+        ret = ti_pipe3_enable_clocks(phy);
+        return ret;
+}
+
+static int ti_pipe3_suspend(struct device *dev)
+{
+        struct ti_pipe3 *phy = dev_get_drvdata(dev);
+
+        ti_pipe3_disable_clocks(phy);
+        return 0;
+}
+
+static int ti_pipe3_resume(struct device *dev)
+{
+        struct ti_pipe3 *phy = dev_get_drvdata(dev);
+        int ret;
+
+        ret = ti_pipe3_enable_clocks(phy);
+        if (ret)
+                return ret;
+
+        pm_runtime_disable(dev);
+        pm_runtime_set_active(dev);
+        pm_runtime_enable(dev);
+        return 0;
+}
+#endif
+
 static const struct dev_pm_ops ti_pipe3_pm_ops = {
         SET_RUNTIME_PM_OPS(ti_pipe3_runtime_suspend,
                            ti_pipe3_runtime_resume, NULL)
+        SET_SYSTEM_SLEEP_PM_OPS(ti_pipe3_suspend, ti_pipe3_resume)
 };
 
-#define DEV_PM_OPS     (&ti_pipe3_pm_ops)
-#else
-#define DEV_PM_OPS     NULL
-#endif
-
 #ifdef CONFIG_OF
 static const struct of_device_id ti_pipe3_id_table[] = {
         {
@@ -520,7 +601,7 @@ static struct platform_driver ti_pipe3_driver = {
         .remove         = ti_pipe3_remove,
         .driver         = {
                 .name   = "ti-pipe3",
-                .pm     = DEV_PM_OPS,
+                .pm     = &ti_pipe3_pm_ops,
                 .of_match_table = of_match_ptr(ti_pipe3_id_table),
         },
 };