11 files changed, 243 insertions, 45 deletions

diff --git a/arch/arm/include/asm/dma-mapping.h b/arch/arm/include/asm/dma-mapping.h
index e6e3446abdf6..b52101d37ec7 100644
--- a/arch/arm/include/asm/dma-mapping.h
+++ b/arch/arm/include/asm/dma-mapping.h
@@ -121,13 +121,12 @@ static inline unsigned long dma_max_pfn(struct device *dev)
 }
 #define dma_max_pfn(dev) dma_max_pfn(dev)
 
-static inline int set_arch_dma_coherent_ops(struct device *dev)
-{
-        dev->archdata.dma_coherent = true;
-        set_dma_ops(dev, &arm_coherent_dma_ops);
-        return 0;
-}
-#define set_arch_dma_coherent_ops(dev)  set_arch_dma_coherent_ops(dev)
+#define arch_setup_dma_ops arch_setup_dma_ops
+extern void arch_setup_dma_ops(struct device *dev, u64 dma_base, u64 size,
+                               struct iommu_ops *iommu, bool coherent);
+
+#define arch_teardown_dma_ops arch_teardown_dma_ops
+extern void arch_teardown_dma_ops(struct device *dev);
 
 /* do not use this function in a driver */
 static inline bool is_device_dma_coherent(struct device *dev)
diff --git a/arch/arm/kernel/setup.c b/arch/arm/kernel/setup.c
index 8361652b6dab..f9c863911038 100644
--- a/arch/arm/kernel/setup.c
+++ b/arch/arm/kernel/setup.c
@@ -18,6 +18,7 @@
 #include <linux/bootmem.h>
 #include <linux/seq_file.h>
 #include <linux/screen_info.h>
+#include <linux/of_iommu.h>
 #include <linux/of_platform.h>
 #include <linux/init.h>
 #include <linux/kexec.h>
@@ -806,6 +807,7 @@ static int __init customize_machine(void)
          * machine from the device tree, if no callback is provided,
          * otherwise we would always need an init_machine callback.
          */
+        of_iommu_init();
         if (machine_desc->init_machine)
                 machine_desc->init_machine();
 #ifdef CONFIG_OF
diff --git a/arch/arm/mm/dma-mapping.c b/arch/arm/mm/dma-mapping.c
index e8907117861e..7864797609b3 100644
--- a/arch/arm/mm/dma-mapping.c
+++ b/arch/arm/mm/dma-mapping.c
@@ -1947,9 +1947,8 @@ EXPORT_SYMBOL_GPL(arm_iommu_release_mapping);
  *      arm_iommu_create_mapping)
  *
  * Attaches specified io address space mapping to the provided device,
- * this replaces the dma operations (dma_map_ops pointer) with the
- * IOMMU aware version. More than one client might be attached to
- * the same io address space mapping.
+ * More than one client might be attached to the same io address space
+ * mapping.
  */
 int arm_iommu_attach_device(struct device *dev,
                             struct dma_iommu_mapping *mapping)
@@ -1962,7 +1961,6 @@ int arm_iommu_attach_device(struct device *dev,
 
         kref_get(&mapping->kref);
         dev->archdata.mapping = mapping;
-        set_dma_ops(dev, &iommu_ops);
 
         pr_debug("Attached IOMMU controller to %s device.\n", dev_name(dev));
         return 0;
@@ -1974,7 +1972,6 @@ EXPORT_SYMBOL_GPL(arm_iommu_attach_device);
  * @dev: valid struct device pointer
  *
  * Detaches the provided device from a previously attached map.
- * This voids the dma operations (dma_map_ops pointer)
  */
 void arm_iommu_detach_device(struct device *dev)
 {
@@ -1989,10 +1986,83 @@ void arm_iommu_detach_device(struct device *dev)
         iommu_detach_device(mapping->domain, dev);
         kref_put(&mapping->kref, release_iommu_mapping);
         dev->archdata.mapping = NULL;
-        set_dma_ops(dev, NULL);
 
         pr_debug("Detached IOMMU controller from %s device.\n", dev_name(dev));
 }
 EXPORT_SYMBOL_GPL(arm_iommu_detach_device);
 
-#endif
+static struct dma_map_ops *arm_get_iommu_dma_map_ops(bool coherent)
+{
+        return coherent ? &iommu_coherent_ops : &iommu_ops;
+}
+
+static bool arm_setup_iommu_dma_ops(struct device *dev, u64 dma_base, u64 size,
+                                    struct iommu_ops *iommu)
+{
+        struct dma_iommu_mapping *mapping;
+
+        if (!iommu)
+                return false;
+
+        mapping = arm_iommu_create_mapping(dev->bus, dma_base, size);
+        if (IS_ERR(mapping)) {
+                pr_warn("Failed to create %llu-byte IOMMU mapping for device %s\n",
+                                size, dev_name(dev));
+                return false;
+        }
+
+        if (arm_iommu_attach_device(dev, mapping)) {
+                pr_warn("Failed to attached device %s to IOMMU_mapping\n",
+                                dev_name(dev));
+                arm_iommu_release_mapping(mapping);
+                return false;
+        }
+
+        return true;
+}
+
+static void arm_teardown_iommu_dma_ops(struct device *dev)
+{
+        struct dma_iommu_mapping *mapping = dev->archdata.mapping;
+
+        arm_iommu_detach_device(dev);
+        arm_iommu_release_mapping(mapping);
+}
+
+#else
+
+static bool arm_setup_iommu_dma_ops(struct device *dev, u64 dma_base, u64 size,
+                                    struct iommu_ops *iommu)
+{
+        return false;
+}
+
+static void arm_teardown_iommu_dma_ops(struct device *dev) { }
+
+#define arm_get_iommu_dma_map_ops arm_get_dma_map_ops
+
+#endif  /* CONFIG_ARM_DMA_USE_IOMMU */
+
+static struct dma_map_ops *arm_get_dma_map_ops(bool coherent)
+{
+        return coherent ? &arm_coherent_dma_ops : &arm_dma_ops;
+}
+
+void arch_setup_dma_ops(struct device *dev, u64 dma_base, u64 size,
+                        struct iommu_ops *iommu, bool coherent)
+{
+        struct dma_map_ops *dma_ops;
+
+        dev->archdata.dma_coherent = coherent;
+        if (arm_setup_iommu_dma_ops(dev, dma_base, size, iommu))
+                dma_ops = arm_get_iommu_dma_map_ops(coherent);
+        else
+                dma_ops = arm_get_dma_map_ops(coherent);
+
+        set_dma_ops(dev, dma_ops);
+}
+
+void arch_teardown_dma_ops(struct device *dev)
+{
+        arm_teardown_iommu_dma_ops(dev);
+}
diff --git a/drivers/iommu/Kconfig b/drivers/iommu/Kconfig
index 2fbe3b1dc92d..325188eef1c1 100644
--- a/drivers/iommu/Kconfig
+++ b/drivers/iommu/Kconfig
@@ -15,7 +15,7 @@ if IOMMU_SUPPORT
 
 config OF_IOMMU
        def_bool y
-       depends on OF
+       depends on OF && IOMMU_API
 
 config FSL_PAMU
         bool "Freescale IOMMU support"