Merge branch 'iommu-linux-3.14.y' of git://git.ti.com/rpmsg/iommu into rproc-linux-3.14.y

Merge in the updated iommu feature branch into remoteproc tree to
pull in the suspend/resume support in the OMAP IOMMU driver. The
following are the main changes:
    - improvements in the OMAP iommu to perform the enabling &
      disabling of the IOMMU from within the runtime pm callbacks
    - two new API that needs to be invoked from the OMAP remoteproc
      driver to suspend/resume the IOMMU.
    - locked TLB save & restore logic
    - add needed pdata quirks to all supported IOMMUs

* 'iommu-linux-3.14.y' of git://git.ti.com/rpmsg/iommu:
  iommu/omap: add support for runtime auto suspend/resume
  iommu/omap: add logic to save/restore locked TLBs
  iommu/omap: introduce new API for suspend/resume
  iommu/omap: streamline enable/disable through runtime pm callbacks
  ARM: OMAP2+: add pdata-quirks for OMAP3 ISP IOMMU
  ARM: OMAP2+: Add iommu pdata-quirks for DRA7 DSP EDMA MMUs
  ARM: OMAP2+: plug in device_enable/idle ops for IOMMUs
  iommu/omap: add pdata ops for omap_device_enable/idle

Signed-off-by: Suman Anna <s-anna@ti.com>

6 files changed, 254 insertions, 23 deletions

diff --git a/arch/arm/mach-omap2/omap-iommu.c b/arch/arm/mach-omap2/omap-iommu.c
index f1fab5684a24..d6803a41034c 100644
--- a/arch/arm/mach-omap2/omap-iommu.c
+++ b/arch/arm/mach-omap2/omap-iommu.c
@@ -42,6 +42,8 @@ static int __init omap_iommu_dev_init(struct omap_hwmod *oh, void *unused)
                 pdata->assert_reset = omap_device_assert_hardreset;
                 pdata->deassert_reset = omap_device_deassert_hardreset;
         }
+        pdata->device_enable = omap_device_enable,
+        pdata->device_idle = omap_device_idle,
 
         pdev = omap_device_build("omap-iommu", i, oh, pdata, sizeof(*pdata));
 
diff --git a/arch/arm/mach-omap2/pdata-quirks.c b/arch/arm/mach-omap2/pdata-quirks.c
index bce029f1bdcd..9bb61bec9251 100644
--- a/arch/arm/mach-omap2/pdata-quirks.c
+++ b/arch/arm/mach-omap2/pdata-quirks.c
@@ -89,6 +89,13 @@ static struct iommu_platform_data omap3_iommu_pdata = {
         .reset_name = "mmu",
         .assert_reset = omap_device_assert_hardreset,
         .deassert_reset = omap_device_deassert_hardreset,
+        .device_enable = omap_device_enable,
+        .device_idle = omap_device_idle,
+};
+
+static struct iommu_platform_data omap3_iommu_isp_pdata = {
+        .device_enable = omap_device_enable,
+        .device_idle = omap_device_idle,
 };
 
 static int omap3_sbc_t3730_twl_callback(struct device *dev,
@@ -221,6 +228,8 @@ static struct iommu_platform_data omap4_iommu_pdata = {
         .reset_name = "mmu_cache",
         .assert_reset = omap_device_assert_hardreset,
         .deassert_reset = omap_device_deassert_hardreset,
+        .device_enable = omap_device_enable,
+        .device_idle = omap_device_idle,
 };
 
 static struct omap_rproc_pdata omap4_ipu_pdata = {
@@ -240,6 +249,11 @@ static struct omap_rproc_pdata omap4_dsp_pdata = {
 #endif
 
 #ifdef CONFIG_SOC_DRA7XX
+static struct iommu_platform_data dra7_dsp_mmu_edma_pdata = {
+        .device_enable = omap_device_enable,
+        .device_idle = omap_device_idle,
+};
+
 static struct omap_rproc_pdata dra7_dsp1_pdata = {
         .device_enable = omap_rproc_device_enable,
         .device_shutdown = omap_rproc_device_shutdown,
@@ -317,6 +331,8 @@ struct of_dev_auxdata omap_auxdata_lookup[] __initdata = {
         OF_DEV_AUXDATA("ti,omap3-padconf", 0x48002a00, "48002a00.pinmux", &pcs_pdata),
         OF_DEV_AUXDATA("ti,omap2-iommu", 0x5d000000, "5d000000.mmu",
                        &omap3_iommu_pdata),
+        OF_DEV_AUXDATA("ti,omap2-iommu", 0x480bd400, "480bd400.mmu",
+                       &omap3_iommu_isp_pdata),
         /* Only on am3517 */
         OF_DEV_AUXDATA("ti,davinci_mdio", 0x5c030000, "davinci_mdio.0", NULL),
         OF_DEV_AUXDATA("ti,am3517-emac", 0x5c000000, "davinci_emac.0",
@@ -353,8 +369,12 @@ struct of_dev_auxdata omap_auxdata_lookup[] __initdata = {
         OF_DEV_AUXDATA("ti,dra7-padconf", 0x4a003400, "4a003400.pinmux", &pcs_pdata),
         OF_DEV_AUXDATA("ti,dra7-iommu", 0x40d01000, "40d01000.mmu",
                        &omap4_iommu_pdata),
+        OF_DEV_AUXDATA("ti,dra7-iommu", 0x40d02000, "40d02000.mmu",
+                       &dra7_dsp_mmu_edma_pdata),
         OF_DEV_AUXDATA("ti,dra7-iommu", 0x41501000, "41501000.mmu",
                        &omap4_iommu_pdata),
+        OF_DEV_AUXDATA("ti,dra7-iommu", 0x41502000, "41502000.mmu",
+                       &dra7_dsp_mmu_edma_pdata),
         OF_DEV_AUXDATA("ti,dra7-iommu", 0x55082000, "55082000.mmu",
                        &omap4_iommu_pdata),
         OF_DEV_AUXDATA("ti,dra7-iommu", 0x58882000, "58882000.mmu",
diff --git a/drivers/iommu/omap-iommu.c b/drivers/iommu/omap-iommu.c
index 693f23c46a64..17b7890616b2 100644
--- a/drivers/iommu/omap-iommu.c
+++ b/drivers/iommu/omap-iommu.c
@@ -129,6 +129,11 @@ EXPORT_SYMBOL_GPL(omap_uninstall_iommu_arch);
 /**
  * omap_iommu_save_ctx - Save registers for pm off-mode support
  * @dev:        client device
+ *
+ * This should be treated as an deprecated API. It is preserved only
+ * to maintain existing functionality for OMAP3 ISP driver, newer
+ * SoCs will leverage the newer omap_iommu_domain_suspend() API and
+ * associated runtime_suspend callback.
  **/
 void omap_iommu_save_ctx(struct device *dev)
 {
@@ -146,6 +151,11 @@ EXPORT_SYMBOL_GPL(omap_iommu_save_ctx);
 /**
  * omap_iommu_restore_ctx - Restore registers for pm off-mode support
  * @dev:        client device
+ *
+ * This should be treated as an deprecated API. It is preserved only
+ * to maintain existing functionality for OMAP3 ISP driver, newer
+ * SoCs will leverage the newer omap_iommu_domain_resume() API and
+ * associated runtime_resume callback.
  **/
 void omap_iommu_restore_ctx(struct device *dev)
 {
@@ -162,39 +172,24 @@ EXPORT_SYMBOL_GPL(omap_iommu_restore_ctx);
 
 static int iommu_enable(struct omap_iommu *obj)
 {
-        int err;
-        struct platform_device *pdev = to_platform_device(obj->dev);
-        struct iommu_platform_data *pdata = pdev->dev.platform_data;
+        int ret;
 
         if (!arch_iommu)
                 return -ENODEV;
 
-        if (pdata && pdata->deassert_reset) {
-                err = pdata->deassert_reset(pdev, pdata->reset_name);
-                if (err) {
-                        dev_err(obj->dev, "deassert_reset failed: %d\n", err);
-                        return err;
-                }
-        }
-
-        pm_runtime_get_sync(obj->dev);
-
-        err = arch_iommu->enable(obj);
+        ret = pm_runtime_get_sync(obj->dev);
+        if (ret < 0)
+                pm_runtime_put_noidle(obj->dev);
 
-        return err;
+        return ret < 0 ? ret : 0;
 }
 
 static void iommu_disable(struct omap_iommu *obj)
 {
-        struct platform_device *pdev = to_platform_device(obj->dev);
-        struct iommu_platform_data *pdata = pdev->dev.platform_data;
-
-        arch_iommu->disable(obj);
+        if (!arch_iommu)
+                return;
 
         pm_runtime_put_sync(obj->dev);
-
-        if (pdata && pdata->assert_reset)
-                pdata->assert_reset(pdev, pdata->reset_name);
 }
 
 /*
@@ -913,14 +908,200 @@ static void omap_iommu_detach(struct omap_iommu *obj)
 
         spin_lock(&obj->iommu_lock);
 
-        iommu_disable(obj);
         obj->iopgd = NULL;
+        iommu_disable(obj);
 
         spin_unlock(&obj->iommu_lock);
 
         dev_dbg(obj->dev, "%s: %s\n", __func__, obj->name);
 }
 
+/**
+ * omap_iommu_domain_suspend - suspend the iommu device
+ * @domain: iommu domain attached to the target iommu device
+ * @auto_suspend: flag to indicate system suspend or runtime suspend
+ *
+ * This API allows the client devices of IOMMU devices to suspend
+ * the IOMMUs they control, after they are idled and suspended all
+ * activity.
+ **/
+int omap_iommu_domain_suspend(struct iommu_domain *domain, bool auto_suspend)
+{
+        struct omap_iommu_domain *omap_domain = domain->priv;
+        struct omap_iommu_device *iommu;
+        struct omap_iommu *oiommu;
+        int i;
+
+        if (!omap_domain->attached)
+                return 0;
+
+        iommu = omap_domain->iommus;
+        iommu += (omap_domain->num_iommus - 1);
+        for (i = 0; i < omap_domain->num_iommus; i++, iommu--) {
+                oiommu = iommu->iommu_dev;
+                if (auto_suspend) {
+                        pm_runtime_put_sync(oiommu->dev);
+                } else {
+                        pm_runtime_put_noidle(oiommu->dev);
+                        pm_generic_runtime_suspend(oiommu->dev);
+                        pm_runtime_disable(oiommu->dev);
+                        pm_runtime_set_suspended(oiommu->dev);
+                }
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(omap_iommu_domain_suspend);
+
+/**
+ * omap_iommu_domain_resume - resume the iommu device
+ * @domain: iommu domain attached to the target iommu device
+ * @auto_suspend: flag to indicate system suspend or runtime suspend
+ *
+ * This API allows the client devices of IOMMU devices to resume
+ * the IOMMUs they control, before they can resume operations.
+ **/
+int omap_iommu_domain_resume(struct iommu_domain *domain, bool auto_suspend)
+{
+        struct omap_iommu_domain *omap_domain = domain->priv;
+        struct omap_iommu_device *iommu;
+        struct omap_iommu *oiommu;
+        int i;
+
+        if (!omap_domain->attached)
+                return 0;
+
+        iommu = omap_domain->iommus;
+        for (i = 0; i < omap_domain->num_iommus; i++, iommu++) {
+                oiommu = iommu->iommu_dev;
+                if (auto_suspend) {
+                        pm_runtime_get_sync(oiommu->dev);
+                } else {
+                        pm_runtime_set_active(oiommu->dev);
+                        pm_runtime_enable(oiommu->dev);
+                        pm_runtime_get_noresume(oiommu->dev);
+                        pm_generic_runtime_resume(oiommu->dev);
+                }
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(omap_iommu_domain_resume);
+
+static void omap_iommu_save_tlb_entries(struct omap_iommu *obj)
+{
+        struct iotlb_lock lock;
+        struct cr_regs cr;
+        struct cr_regs *tmp;
+        int i;
+
+        /* check if there are any locked tlbs to save */
+        iotlb_lock_get(obj, &lock);
+        obj->num_cr_ctx = lock.base;
+        if (!obj->num_cr_ctx)
+                return;
+
+        tmp = obj->cr_ctx;
+        for_each_iotlb_cr(obj, obj->num_cr_ctx, i, cr)
+                *tmp++ = cr;
+}
+
+static void omap_iommu_restore_tlb_entries(struct omap_iommu *obj)
+{
+        struct iotlb_lock l;
+        struct cr_regs *tmp;
+        int i;
+
+        /* no locked tlbs to restore */
+        if (!obj->num_cr_ctx)
+                return;
+
+        l.base = 0;
+        tmp = obj->cr_ctx;
+        for (i = 0; i < obj->num_cr_ctx; i++, tmp++) {
+                l.vict = i;
+                iotlb_lock_set(obj, &l);
+                iotlb_load_cr(obj, tmp);
+        }
+        l.base = obj->num_cr_ctx;
+        l.vict = i;
+        iotlb_lock_set(obj, &l);
+}
+
+/**
+ * omap_iommu_runtime_suspend - disable an iommu device
+ * @dev:        iommu device
+ *
+ * This function performs all that is necessary to disable an
+ * IOMMU device, either during final detachment from a client
+ * device, or during system/runtime suspend of the device. This
+ * includes programming all the appropriate IOMMU registers, and
+ * managing the associated omap_hwmod's state and the device's
+ * reset line. This function also saves the context of any
+ * locked TLBs if suspending.
+ **/
+static int omap_iommu_runtime_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct iommu_platform_data *pdata = dev_get_platdata(dev);
+        struct omap_iommu *obj = to_iommu(dev);
+
+        /* save the TLBs only during suspend, and not for power down */
+        if (obj->domain && obj->iopgd)
+                omap_iommu_save_tlb_entries(obj);
+
+        if (arch_iommu->disable)
+                arch_iommu->disable(obj);
+
+        if (pdata && pdata->device_idle)
+                pdata->device_idle(pdev);
+
+        if (pdata && pdata->assert_reset)
+                pdata->assert_reset(pdev, pdata->reset_name);
+
+        return 0;
+}
+
+/**
+ * omap_iommu_runtime_resume - enable an iommu device
+ * @dev:        iommu device
+ *
+ * This function performs all that is necessary to enable an
+ * IOMMU device, either during initial attachment to a client
+ * device, or during system/runtime resume of the device. This
+ * includes programming all the appropriate IOMMU registers, and
+ * managing the associated omap_hwmod's state and the device's
+ * reset line. The function also restores any locked TLBs if
+ * resuming after a suspend.
+ **/
+static int omap_iommu_runtime_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct iommu_platform_data *pdata = dev_get_platdata(dev);
+        struct omap_iommu *obj = to_iommu(dev);
+        int ret = 0;
+
+        if (pdata && pdata->deassert_reset) {
+                ret = pdata->deassert_reset(pdev, pdata->reset_name);
+                if (ret) {
+                        dev_err(dev, "deassert_reset failed: %d\n", ret);
+                        return ret;
+                }
+        }
+
+        if (pdata && pdata->device_enable)
+                pdata->device_enable(pdev);
+
+        /* restore the TLBs only during resume, and not for power up */
+        if (obj->domain)
+                omap_iommu_restore_tlb_entries(obj);
+
+        if (arch_iommu->enable)
+                ret = arch_iommu->enable(obj);
+
+        return ret;
+}
+
 static int omap_iommu_dra7_get_dsp_system_cfg(struct platform_device *pdev,
                                               struct omap_iommu *obj,
                                               resource_size_t start)
@@ -977,6 +1158,15 @@ static int omap_iommu_probe(struct platform_device *pdev)
         if (!obj)
                 return -ENOMEM;
 
+        /*
+         * self-manage the ordering dependencies between omap_device_enable/idle
+         * and omap_device_assert/deassert_hardreset API
+         */
+        if (pdev->dev.pm_domain) {
+                dev_dbg(&pdev->dev, "device pm_domain is being reset\n");
+                pdev->dev.pm_domain = NULL;
+        }
+
         if (of) {
                 obj->name = dev_name(&pdev->dev);
                 obj->nr_tlb_entries = 32;
@@ -1006,6 +1196,11 @@ static int omap_iommu_probe(struct platform_device *pdev)
 
         obj->dev = &pdev->dev;
         obj->ctx = (void *)obj + sizeof(*obj);
+        obj->cr_ctx = devm_kzalloc(&pdev->dev,
+                                   sizeof(*obj->cr_ctx) * obj->nr_tlb_entries,
+                                   GFP_KERNEL);
+        if (!obj->cr_ctx)
+                return -ENOMEM;
 
         spin_lock_init(&obj->iommu_lock);
         mutex_init(&obj->mmap_lock);
@@ -1050,6 +1245,11 @@ static int omap_iommu_remove(struct platform_device *pdev)
         return 0;
 }
 
+static const struct dev_pm_ops omap_iommu_pm_ops = {
+        SET_RUNTIME_PM_OPS(omap_iommu_runtime_suspend,
+                           omap_iommu_runtime_resume, NULL)
+};
+
 static struct of_device_id omap_iommu_of_match[] = {
         { .compatible = "ti,omap2-iommu" },
         { .compatible = "ti,omap4-iommu" },
@@ -1063,6 +1263,7 @@ static struct platform_driver omap_iommu_driver = {
         .remove = omap_iommu_remove,
         .driver = {
                 .name   = "omap-iommu",
+                .pm     = &omap_iommu_pm_ops,
                 .of_match_table = of_match_ptr(omap_iommu_of_match),
         },
 };
diff --git a/drivers/iommu/omap-iommu.h b/drivers/iommu/omap-iommu.h
index c1c0d824c79b..4278aa36b770 100644
--- a/drivers/iommu/omap-iommu.h
+++ b/drivers/iommu/omap-iommu.h
@@ -55,6 +55,9 @@ struct omap_iommu {
         u32 da_start;
         u32 da_end;
 
+        struct cr_regs *cr_ctx;
+        u32 num_cr_ctx;
+
         int has_bus_err_back;
         u32 id;
 };
diff --git a/include/linux/omap-iommu.h b/include/linux/omap-iommu.h
index cac78de09c07..7a3a9c88f163 100644
--- a/include/linux/omap-iommu.h
+++ b/include/linux/omap-iommu.h
@@ -49,4 +49,7 @@ extern void *omap_da_to_va(struct device *dev, u32 da);
 extern void omap_iommu_save_ctx(struct device *dev);
 extern void omap_iommu_restore_ctx(struct device *dev);
 
+int omap_iommu_domain_suspend(struct iommu_domain *domain, bool auto_suspend);
+int omap_iommu_domain_resume(struct iommu_domain *domain, bool auto_suspend);
+
 #endif
diff --git a/include/linux/platform_data/iommu-omap.h b/include/linux/platform_data/iommu-omap.h
index 5b429c43a297..8aec9172822c 100644
--- a/include/linux/platform_data/iommu-omap.h
+++ b/include/linux/platform_data/iommu-omap.h
@@ -51,4 +51,6 @@ struct iommu_platform_data {
 
         int (*assert_reset)(struct platform_device *pdev, const char *name);
         int (*deassert_reset)(struct platform_device *pdev, const char *name);
+        int (*device_enable)(struct platform_device *pdev);
+        int (*device_idle)(struct platform_device *pdev);
 };