9 files changed, 74 insertions, 94 deletions

diff --git a/arch/arm/plat-omap/include/plat/iommu.h b/arch/arm/plat-omap/include/plat/iommu.h
index fa11ee26aca9..88be3e628b33 100644
--- a/arch/arm/plat-omap/include/plat/iommu.h
+++ b/arch/arm/plat-omap/include/plat/iommu.h
@@ -189,8 +189,8 @@ extern int omap_iommu_set_isr(const char *name,
                                     void *priv),
                          void *isr_priv);
 
-extern void omap_iommu_save_ctx(struct omap_iommu *obj);
-extern void omap_iommu_restore_ctx(struct omap_iommu *obj);
+extern void omap_iommu_save_ctx(struct device *dev);
+extern void omap_iommu_restore_ctx(struct device *dev);
 
 extern int omap_install_iommu_arch(const struct iommu_functions *ops);
 extern void omap_uninstall_iommu_arch(const struct iommu_functions *ops);
@@ -202,6 +202,5 @@ extern ssize_t
 omap_iommu_dump_ctx(struct omap_iommu *obj, char *buf, ssize_t len);
 extern size_t
 omap_dump_tlb_entries(struct omap_iommu *obj, char *buf, ssize_t len);
-struct device *omap_find_iommu_device(const char *name);
 
 #endif /* __MACH_IOMMU_H */
diff --git a/arch/arm/plat-omap/include/plat/iovmm.h b/arch/arm/plat-omap/include/plat/iovmm.h
index 6af1a91c0f36..498e57cda6cd 100644
--- a/arch/arm/plat-omap/include/plat/iovmm.h
+++ b/arch/arm/plat-omap/include/plat/iovmm.h
@@ -72,18 +72,18 @@ struct iovm_struct {
 #define IOVMF_DA_FIXED          (1 << (4 + IOVMF_SW_SHIFT))
 
 
-extern struct iovm_struct *omap_find_iovm_area(struct omap_iommu *obj, u32 da);
+extern struct iovm_struct *omap_find_iovm_area(struct device *dev, u32 da);
 extern u32
-omap_iommu_vmap(struct iommu_domain *domain, struct omap_iommu *obj, u32 da,
+omap_iommu_vmap(struct iommu_domain *domain, struct device *dev, u32 da,
                         const struct sg_table *sgt, u32 flags);
 extern struct sg_table *omap_iommu_vunmap(struct iommu_domain *domain,
-                                struct omap_iommu *obj, u32 da);
+                                struct device *dev, u32 da);
 extern u32
-omap_iommu_vmalloc(struct iommu_domain *domain, struct omap_iommu *obj,
+omap_iommu_vmalloc(struct iommu_domain *domain, struct device *dev,
                                 u32 da, size_t bytes, u32 flags);
 extern void
-omap_iommu_vfree(struct iommu_domain *domain, struct omap_iommu *obj,
+omap_iommu_vfree(struct iommu_domain *domain, struct device *dev,
                                 const u32 da);
-extern void *omap_da_to_va(struct omap_iommu *obj, u32 da);
+extern void *omap_da_to_va(struct device *dev, u32 da);
 
 #endif /* __IOMMU_MMAP_H */
diff --git a/drivers/iommu/omap-iommu.c b/drivers/iommu/omap-iommu.c
index 8f32b2bf7587..b7f863d72c08 100644
--- a/drivers/iommu/omap-iommu.c
+++ b/drivers/iommu/omap-iommu.c
@@ -86,20 +86,24 @@ EXPORT_SYMBOL_GPL(omap_uninstall_iommu_arch);
 
 /**
  * omap_iommu_save_ctx - Save registers for pm off-mode support
- * @obj:        target iommu
+ * @dev:        client device
  **/
-void omap_iommu_save_ctx(struct omap_iommu *obj)
+void omap_iommu_save_ctx(struct device *dev)
 {
+        struct omap_iommu *obj = dev_to_omap_iommu(dev);
+
         arch_iommu->save_ctx(obj);
 }
 EXPORT_SYMBOL_GPL(omap_iommu_save_ctx);
 
 /**
  * omap_iommu_restore_ctx - Restore registers for pm off-mode support
- * @obj:        target iommu
+ * @dev:        client device
  **/
-void omap_iommu_restore_ctx(struct omap_iommu *obj)
+void omap_iommu_restore_ctx(struct device *dev)
 {
+        struct omap_iommu *obj = dev_to_omap_iommu(dev);
+
         arch_iommu->restore_ctx(obj);
 }
 EXPORT_SYMBOL_GPL(omap_iommu_restore_ctx);
@@ -820,35 +824,23 @@ static int device_match_by_alias(struct device *dev, void *data)
 }
 
 /**
- * omap_find_iommu_device() - find an omap iommu device by name
- * @name:       name of the iommu device
- *
- * The generic iommu API requires the caller to provide the device
- * he wishes to attach to a certain iommu domain.
- *
- * Drivers generally should not bother with this as it should just
- * be taken care of by the DMA-API using dev_archdata.
- *
- * This function is provided as an interim solution until the latter
- * materializes, and omap3isp is fully migrated to the DMA-API.
- */
-struct device *omap_find_iommu_device(const char *name)
-{
-        return driver_find_device(&omap_iommu_driver.driver, NULL,
-                                (void *)name,
-                                device_match_by_alias);
-}
-EXPORT_SYMBOL_GPL(omap_find_iommu_device);
-
-/**
  * omap_iommu_attach() - attach iommu device to an iommu domain
- * @dev:        target omap iommu device
+ * @name:       name of target omap iommu device
  * @iopgd:      page table
  **/
-static struct omap_iommu *omap_iommu_attach(struct device *dev, u32 *iopgd)
+static struct omap_iommu *omap_iommu_attach(const char *name, u32 *iopgd)
 {
         int err = -ENOMEM;
-        struct omap_iommu *obj = to_iommu(dev);
+        struct device *dev;
+        struct omap_iommu *obj;
+
+        dev = driver_find_device(&omap_iommu_driver.driver, NULL,
+                                (void *)name,
+                                device_match_by_alias);
+        if (!dev)
+                return NULL;
+
+        obj = to_iommu(dev);
 
         spin_lock(&obj->iommu_lock);
 
@@ -1069,6 +1061,7 @@ omap_iommu_attach_dev(struct iommu_domain *domain, struct device *dev)
 {
         struct omap_iommu_domain *omap_domain = domain->priv;
         struct omap_iommu *oiommu;
+        struct omap_iommu_arch_data *arch_data = dev->archdata.iommu;
         int ret = 0;
 
         spin_lock(&omap_domain->lock);
@@ -1081,14 +1074,14 @@ omap_iommu_attach_dev(struct iommu_domain *domain, struct device *dev)
         }
 
         /* get a handle to and enable the omap iommu */
-        oiommu = omap_iommu_attach(dev, omap_domain->pgtable);
+        oiommu = omap_iommu_attach(arch_data->name, omap_domain->pgtable);
         if (IS_ERR(oiommu)) {
                 ret = PTR_ERR(oiommu);
                 dev_err(dev, "can't get omap iommu: %d\n", ret);
                 goto out;
         }
 
-        omap_domain->iommu_dev = oiommu;
+        omap_domain->iommu_dev = arch_data->iommu_dev = oiommu;
         oiommu->domain = domain;
 
 out:
@@ -1100,7 +1093,8 @@ static void omap_iommu_detach_dev(struct iommu_domain *domain,
                                  struct device *dev)
 {
         struct omap_iommu_domain *omap_domain = domain->priv;
-        struct omap_iommu *oiommu = to_iommu(dev);
+        struct omap_iommu_arch_data *arch_data = dev->archdata.iommu;
+        struct omap_iommu *oiommu = dev_to_omap_iommu(dev);
 
         spin_lock(&omap_domain->lock);
 
@@ -1114,7 +1108,7 @@ static void omap_iommu_detach_dev(struct iommu_domain *domain,
 
         omap_iommu_detach(oiommu);
 
-        omap_domain->iommu_dev = NULL;
+        omap_domain->iommu_dev = arch_data->iommu_dev = NULL;
 
 out:
         spin_unlock(&omap_domain->lock);
diff --git a/drivers/iommu/omap-iovmm.c b/drivers/iommu/omap-iovmm.c
index 46be456fcc00..23655945e30c 100644
--- a/drivers/iommu/omap-iovmm.c
+++ b/drivers/iommu/omap-iovmm.c
@@ -231,12 +231,14 @@ static struct iovm_struct *__find_iovm_area(struct omap_iommu *obj,
 
 /**
  * omap_find_iovm_area  -  find iovma which includes @da
+ * @dev:        client device
  * @da:         iommu device virtual address
  *
  * Find the existing iovma starting at @da
  */
-struct iovm_struct *omap_find_iovm_area(struct omap_iommu *obj, u32 da)
+struct iovm_struct *omap_find_iovm_area(struct device *dev, u32 da)
 {
+        struct omap_iommu *obj = dev_to_omap_iommu(dev);
         struct iovm_struct *area;
 
         mutex_lock(&obj->mmap_lock);
@@ -343,14 +345,15 @@ static void free_iovm_area(struct omap_iommu *obj, struct iovm_struct *area)
 
 /**
  * omap_da_to_va - convert (d) to (v)
- * @obj:        objective iommu
+ * @dev:        client device
  * @da:         iommu device virtual address
  * @va:         mpu virtual address
  *
  * Returns mpu virtual addr which corresponds to a given device virtual addr
  */
-void *omap_da_to_va(struct omap_iommu *obj, u32 da)
+void *omap_da_to_va(struct device *dev, u32 da)
 {
+        struct omap_iommu *obj = dev_to_omap_iommu(dev);
         void *va = NULL;
         struct iovm_struct *area;
 
@@ -582,16 +585,18 @@ __iommu_vmap(struct iommu_domain *domain, struct omap_iommu *obj,
 
 /**
  * omap_iommu_vmap  -  (d)-(p)-(v) address mapper
- * @obj:        objective iommu
+ * @domain:     iommu domain
+ * @dev:        client device
  * @sgt:        address of scatter gather table
  * @flags:      iovma and page property
  *
  * Creates 1-n-1 mapping with given @sgt and returns @da.
  * All @sgt element must be io page size aligned.
  */
-u32 omap_iommu_vmap(struct iommu_domain *domain, struct omap_iommu *obj, u32 da,
+u32 omap_iommu_vmap(struct iommu_domain *domain, struct device *dev, u32 da,
                 const struct sg_table *sgt, u32 flags)
 {
+        struct omap_iommu *obj = dev_to_omap_iommu(dev);
         size_t bytes;
         void *va = NULL;
 
@@ -622,15 +627,17 @@ EXPORT_SYMBOL_GPL(omap_iommu_vmap);
 
 /**
  * omap_iommu_vunmap  -  release virtual mapping obtained by 'omap_iommu_vmap()'
- * @obj:        objective iommu
+ * @domain:     iommu domain
+ * @dev:        client device
  * @da:         iommu device virtual address
  *
  * Free the iommu virtually contiguous memory area starting at
  * @da, which was returned by 'omap_iommu_vmap()'.
  */
 struct sg_table *
-omap_iommu_vunmap(struct iommu_domain *domain, struct omap_iommu *obj, u32 da)
+omap_iommu_vunmap(struct iommu_domain *domain, struct device *dev, u32 da)
 {
+        struct omap_iommu *obj = dev_to_omap_iommu(dev);
         struct sg_table *sgt;
         /*
          * 'sgt' is allocated before 'omap_iommu_vmalloc()' is called.
@@ -647,7 +654,7 @@ EXPORT_SYMBOL_GPL(omap_iommu_vunmap);
 
 /**
  * omap_iommu_vmalloc  -  (d)-(p)-(v) address allocator and mapper
- * @obj:        objective iommu
+ * @dev:        client device
  * @da:         contiguous iommu virtual memory
  * @bytes:      allocation size
  * @flags:      iovma and page property
@@ -656,9 +663,10 @@ EXPORT_SYMBOL_GPL(omap_iommu_vunmap);
  * @da again, which might be adjusted if 'IOVMF_DA_FIXED' is not set.
  */
 u32
-omap_iommu_vmalloc(struct iommu_domain *domain, struct omap_iommu *obj, u32 da,
+omap_iommu_vmalloc(struct iommu_domain *domain, struct device *dev, u32 da,
                                                 size_t bytes, u32 flags)
 {
+        struct omap_iommu *obj = dev_to_omap_iommu(dev);
         void *va;
         struct sg_table *sgt;
 
@@ -698,15 +706,16 @@ EXPORT_SYMBOL_GPL(omap_iommu_vmalloc);
 
 /**
  * omap_iommu_vfree  -  release memory allocated by 'omap_iommu_vmalloc()'
- * @obj:        objective iommu
+ * @dev:        client device
  * @da:         iommu device virtual address
  *
  * Frees the iommu virtually continuous memory area starting at
  * @da, as obtained from 'omap_iommu_vmalloc()'.
  */
-void omap_iommu_vfree(struct iommu_domain *domain, struct omap_iommu *obj,
+void omap_iommu_vfree(struct iommu_domain *domain, struct device *dev,
                                                                 const u32 da)
 {
+        struct omap_iommu *obj = dev_to_omap_iommu(dev);
         struct sg_table *sgt;
 
         sgt = unmap_vm_area(domain, obj, da, vfree,
diff --git a/drivers/media/video/omap3isp/isp.c b/drivers/media/video/omap3isp/isp.c
index b818cacf420f..d4c48ef227fb 100644
--- a/drivers/media/video/omap3isp/isp.c
+++ b/drivers/media/video/omap3isp/isp.c
@@ -80,13 +80,6 @@
 #include "isph3a.h"
 #include "isphist.h"
 
-/*
- * this is provided as an interim solution until omap3isp doesn't need
- * any omap-specific iommu API
- */
-#define to_iommu(dev)                                                   \
-        (struct omap_iommu *)platform_get_drvdata(to_platform_device(dev))
-
 static unsigned int autoidle;
 module_param(autoidle, int, 0444);
 MODULE_PARM_DESC(autoidle, "Enable OMAP3ISP AUTOIDLE support");
@@ -1114,8 +1107,7 @@ isp_restore_context(struct isp_device *isp, struct isp_reg *reg_list)
 static void isp_save_ctx(struct isp_device *isp)
 {
         isp_save_context(isp, isp_reg_list);
-        if (isp->iommu)
-                omap_iommu_save_ctx(isp->iommu);
+        omap_iommu_save_ctx(isp->dev);
 }
 
 /*
@@ -1128,8 +1120,7 @@ static void isp_save_ctx(struct isp_device *isp)
 static void isp_restore_ctx(struct isp_device *isp)
 {
         isp_restore_context(isp, isp_reg_list);
-        if (isp->iommu)
-                omap_iommu_restore_ctx(isp->iommu);
+        omap_iommu_restore_ctx(isp->dev);
         omap3isp_ccdc_restore_context(isp);
         omap3isp_preview_restore_context(isp);
 }
@@ -1983,7 +1974,7 @@ static int isp_remove(struct platform_device *pdev)
         isp_cleanup_modules(isp);
 
         omap3isp_get(isp);
-        iommu_detach_device(isp->domain, isp->iommu_dev);
+        iommu_detach_device(isp->domain, &pdev->dev);
         iommu_domain_free(isp->domain);
         omap3isp_put(isp);
 
@@ -2131,17 +2122,6 @@ static int isp_probe(struct platform_device *pdev)
                 }
         }
 
-        /* IOMMU */
-        isp->iommu_dev = omap_find_iommu_device("isp");
-        if (!isp->iommu_dev) {
-                dev_err(isp->dev, "omap_find_iommu_device failed\n");
-                ret = -ENODEV;
-                goto error_isp;
-        }
-
-        /* to be removed once iommu migration is complete */
-        isp->iommu = to_iommu(isp->iommu_dev);
-
         isp->domain = iommu_domain_alloc(pdev->dev.bus);
         if (!isp->domain) {
                 dev_err(isp->dev, "can't alloc iommu domain\n");
@@ -2149,7 +2129,7 @@ static int isp_probe(struct platform_device *pdev)
                 goto error_isp;
         }
 
-        ret = iommu_attach_device(isp->domain, isp->iommu_dev);
+        ret = iommu_attach_device(isp->domain, &pdev->dev);
         if (ret) {
                 dev_err(&pdev->dev, "can't attach iommu device: %d\n", ret);
                 goto free_domain;
@@ -2188,7 +2168,7 @@ error_modules:
 error_irq:
         free_irq(isp->irq_num, isp);
 detach_dev:
-        iommu_detach_device(isp->domain, isp->iommu_dev);
+        iommu_detach_device(isp->domain, &pdev->dev);
 free_domain:
         iommu_domain_free(isp->domain);
 error_isp:
diff --git a/drivers/media/video/omap3isp/isp.h b/drivers/media/video/omap3isp/isp.h
index 705946ef4d60..d96603eb0d17 100644
--- a/drivers/media/video/omap3isp/isp.h
+++ b/drivers/media/video/omap3isp/isp.h
@@ -212,9 +212,7 @@ struct isp_device {
         unsigned int sbl_resources;
         unsigned int subclk_resources;
 
-        struct omap_iommu *iommu;
         struct iommu_domain *domain;
-        struct device *iommu_dev;
 
         struct isp_platform_callback platform_cb;
 };
diff --git a/drivers/media/video/omap3isp/ispccdc.c b/drivers/media/video/omap3isp/ispccdc.c
index b0b0fa5a3572..8748e0855c61 100644
--- a/drivers/media/video/omap3isp/ispccdc.c
+++ b/drivers/media/video/omap3isp/ispccdc.c
@@ -366,7 +366,7 @@ static void ccdc_lsc_free_request(struct isp_ccdc_device *ccdc,
                 dma_unmap_sg(isp->dev, req->iovm->sgt->sgl,
                              req->iovm->sgt->nents, DMA_TO_DEVICE);
         if (req->table)
-                omap_iommu_vfree(isp->domain, isp->iommu, req->table);
+                omap_iommu_vfree(isp->domain, isp->dev, req->table);
         kfree(req);
 }
 
@@ -438,7 +438,7 @@ static int ccdc_lsc_config(struct isp_ccdc_device *ccdc,
 
                 req->enable = 1;
 
-                req->table = omap_iommu_vmalloc(isp->domain, isp->iommu, 0,
+                req->table = omap_iommu_vmalloc(isp->domain, isp->dev, 0,
                                         req->config.size, IOMMU_FLAG);
                 if (IS_ERR_VALUE(req->table)) {
                         req->table = 0;
@@ -446,7 +446,7 @@ static int ccdc_lsc_config(struct isp_ccdc_device *ccdc,
                         goto done;
                 }
 
-                req->iovm = omap_find_iovm_area(isp->iommu, req->table);
+                req->iovm = omap_find_iovm_area(isp->dev, req->table);
                 if (req->iovm == NULL) {
                         ret = -ENOMEM;
                         goto done;
@@ -462,7 +462,7 @@ static int ccdc_lsc_config(struct isp_ccdc_device *ccdc,
                 dma_sync_sg_for_cpu(isp->dev, req->iovm->sgt->sgl,
                                     req->iovm->sgt->nents, DMA_TO_DEVICE);
 
-                table = omap_da_to_va(isp->iommu, req->table);
+                table = omap_da_to_va(isp->dev, req->table);
                 if (copy_from_user(table, config->lsc, req->config.size)) {
                         ret = -EFAULT;
                         goto done;
@@ -734,15 +734,15 @@ static int ccdc_config(struct isp_ccdc_device *ccdc,
                          * already done by omap_iommu_vmalloc().
                          */
                         size = ccdc->fpc.fpnum * 4;
-                        table_new = omap_iommu_vmalloc(isp->domain, isp->iommu,
+                        table_new = omap_iommu_vmalloc(isp->domain, isp->dev,
                                                         0, size, IOMMU_FLAG);
                         if (IS_ERR_VALUE(table_new))
                                 return -ENOMEM;
 
-                        if (copy_from_user(omap_da_to_va(isp->iommu, table_new),
+                        if (copy_from_user(omap_da_to_va(isp->dev, table_new),
                                            (__force void __user *)
                                            ccdc->fpc.fpcaddr, size)) {
-                                omap_iommu_vfree(isp->domain, isp->iommu,
+                                omap_iommu_vfree(isp->domain, isp->dev,
                                                                 table_new);
                                 return -EFAULT;
                         }
@@ -753,7 +753,7 @@ static int ccdc_config(struct isp_ccdc_device *ccdc,
 
                 ccdc_configure_fpc(ccdc);
                 if (table_old != 0)
-                        omap_iommu_vfree(isp->domain, isp->iommu, table_old);
+                        omap_iommu_vfree(isp->domain, isp->dev, table_old);
         }
 
         return ccdc_lsc_config(ccdc, ccdc_struct);
@@ -2309,7 +2309,7 @@ void omap3isp_ccdc_cleanup(struct isp_device *isp)
         ccdc_lsc_free_queue(ccdc, &ccdc->lsc.free_queue);
 
         if (ccdc->fpc.fpcaddr != 0)
-                omap_iommu_vfree(isp->domain, isp->iommu, ccdc->fpc.fpcaddr);
+                omap_iommu_vfree(isp->domain, isp->dev, ccdc->fpc.fpcaddr);
 
         mutex_destroy(&ccdc->ioctl_lock);
 }
diff --git a/drivers/media/video/omap3isp/ispstat.c b/drivers/media/video/omap3isp/ispstat.c
index 68d539456c55..9f41aa3d00a5 100644
--- a/drivers/media/video/omap3isp/ispstat.c
+++ b/drivers/media/video/omap3isp/ispstat.c
@@ -366,7 +366,7 @@ static void isp_stat_bufs_free(struct ispstat *stat)
                                 dma_unmap_sg(isp->dev, buf->iovm->sgt->sgl,
                                              buf->iovm->sgt->nents,
                                              DMA_FROM_DEVICE);
-                        omap_iommu_vfree(isp->domain, isp->iommu,
+                        omap_iommu_vfree(isp->domain, isp->dev,
                                                         buf->iommu_addr);
                 } else {
                         if (!buf->virt_addr)
@@ -400,7 +400,7 @@ static int isp_stat_bufs_alloc_iommu(struct ispstat *stat, unsigned int size)
                 struct iovm_struct *iovm;
 
                 WARN_ON(buf->dma_addr);
-                buf->iommu_addr = omap_iommu_vmalloc(isp->domain, isp->iommu, 0,
+                buf->iommu_addr = omap_iommu_vmalloc(isp->domain, isp->dev, 0,
                                                         size, IOMMU_FLAG);
                 if (IS_ERR((void *)buf->iommu_addr)) {
                         dev_err(stat->isp->dev,
@@ -410,7 +410,7 @@ static int isp_stat_bufs_alloc_iommu(struct ispstat *stat, unsigned int size)
                         return -ENOMEM;
                 }
 
-                iovm = omap_find_iovm_area(isp->iommu, buf->iommu_addr);
+                iovm = omap_find_iovm_area(isp->dev, buf->iommu_addr);
                 if (!iovm ||
                     !dma_map_sg(isp->dev, iovm->sgt->sgl, iovm->sgt->nents,
                                 DMA_FROM_DEVICE)) {
@@ -419,7 +419,7 @@ static int isp_stat_bufs_alloc_iommu(struct ispstat *stat, unsigned int size)
                 }
                 buf->iovm = iovm;
 
-                buf->virt_addr = omap_da_to_va(stat->isp->iommu,
+                buf->virt_addr = omap_da_to_va(stat->isp->dev,
                                           (u32)buf->iommu_addr);
                 buf->empty = 1;
                 dev_dbg(stat->isp->dev, "%s: buffer[%d] allocated."
diff --git a/drivers/media/video/omap3isp/ispvideo.c b/drivers/media/video/omap3isp/ispvideo.c
index d1000723c5ae..9974cfc09090 100644
--- a/drivers/media/video/omap3isp/ispvideo.c
+++ b/drivers/media/video/omap3isp/ispvideo.c
@@ -452,7 +452,7 @@ ispmmu_vmap(struct isp_device *isp, const struct scatterlist *sglist, int sglen)
         sgt->nents = sglen;
         sgt->orig_nents = sglen;
 
-        da = omap_iommu_vmap(isp->domain, isp->iommu, 0, sgt, IOMMU_FLAG);
+        da = omap_iommu_vmap(isp->domain, isp->dev, 0, sgt, IOMMU_FLAG);
         if (IS_ERR_VALUE(da))
                 kfree(sgt);
 
@@ -468,7 +468,7 @@ static void ispmmu_vunmap(struct isp_device *isp, dma_addr_t da)
 {
         struct sg_table *sgt;
 
-        sgt = omap_iommu_vunmap(isp->domain, isp->iommu, (u32)da);
+        sgt = omap_iommu_vunmap(isp->domain, isp->dev, (u32)da);
         kfree(sgt);
 }