7 files changed, 246 insertions, 192 deletions

diff --git a/kernel/dma/Kconfig b/kernel/dma/Kconfig
index 1b1d63b3634b..645c7a2ecde8 100644
--- a/kernel/dma/Kconfig
+++ b/kernel/dma/Kconfig
@@ -13,6 +13,9 @@ config NEED_DMA_MAP_STATE
 config ARCH_DMA_ADDR_T_64BIT
         def_bool 64BIT || PHYS_ADDR_T_64BIT
 
+config ARCH_HAS_DMA_COHERENCE_H
+        bool
+
 config HAVE_GENERIC_DMA_COHERENT
         bool
 
@@ -26,22 +29,19 @@ config ARCH_HAS_SYNC_DMA_FOR_CPU
 config ARCH_HAS_SYNC_DMA_FOR_CPU_ALL
         bool
 
-config DMA_DIRECT_OPS
+config ARCH_HAS_DMA_COHERENT_TO_PFN
         bool
-        depends on HAS_DMA
 
-config DMA_NONCOHERENT_OPS
+config ARCH_HAS_DMA_MMAP_PGPROT
         bool
-        depends on HAS_DMA
-        select DMA_DIRECT_OPS
 
-config DMA_NONCOHERENT_MMAP
+config DMA_DIRECT_OPS
         bool
-        depends on DMA_NONCOHERENT_OPS
+        depends on HAS_DMA
 
 config DMA_NONCOHERENT_CACHE_SYNC
         bool
-        depends on DMA_NONCOHERENT_OPS
+        depends on DMA_DIRECT_OPS
 
 config DMA_VIRT_OPS
         bool
diff --git a/kernel/dma/Makefile b/kernel/dma/Makefile
index 6de44e4eb454..7d581e4eea4a 100644
--- a/kernel/dma/Makefile
+++ b/kernel/dma/Makefile
@@ -4,7 +4,6 @@ obj-$(CONFIG_HAS_DMA)			+= mapping.o
 obj-$(CONFIG_DMA_CMA)                   += contiguous.o
 obj-$(CONFIG_HAVE_GENERIC_DMA_COHERENT) += coherent.o
 obj-$(CONFIG_DMA_DIRECT_OPS)            += direct.o
-obj-$(CONFIG_DMA_NONCOHERENT_OPS)       += noncoherent.o
 obj-$(CONFIG_DMA_VIRT_OPS)              += virt.o
 obj-$(CONFIG_DMA_API_DEBUG)             += debug.o
 obj-$(CONFIG_SWIOTLB)                   += swiotlb.o
diff --git a/kernel/dma/contiguous.c b/kernel/dma/contiguous.c
index 286d82329eb0..b2a87905846d 100644
--- a/kernel/dma/contiguous.c
+++ b/kernel/dma/contiguous.c
@@ -49,7 +49,11 @@ static phys_addr_t limit_cmdline;
 
 static int __init early_cma(char *p)
 {
-        pr_debug("%s(%s)\n", __func__, p);
+        if (!p) {
+                pr_err("Config string not provided\n");
+                return -EINVAL;
+        }
+
         size_cmdline = memparse(p, &p);
         if (*p != '@')
                 return 0;
diff --git a/kernel/dma/debug.c b/kernel/dma/debug.c
index c007d25bee09..231ca4628062 100644
--- a/kernel/dma/debug.c
+++ b/kernel/dma/debug.c
@@ -1312,6 +1312,22 @@ static void check_sg_segment(struct device *dev, struct scatterlist *sg)
 #endif
 }
 
+void debug_dma_map_single(struct device *dev, const void *addr,
+                            unsigned long len)
+{
+        if (unlikely(dma_debug_disabled()))
+                return;
+
+        if (!virt_addr_valid(addr))
+                err_printk(dev, NULL, "DMA-API: device driver maps memory from invalid area [addr=%p] [len=%lu]\n",
+                           addr, len);
+
+        if (is_vmalloc_addr(addr))
+                err_printk(dev, NULL, "DMA-API: device driver maps memory from vmalloc area [addr=%p] [len=%lu]\n",
+                           addr, len);
+}
+EXPORT_SYMBOL(debug_dma_map_single);
+
 void debug_dma_map_page(struct device *dev, struct page *page, size_t offset,
                         size_t size, int direction, dma_addr_t dma_addr,
                         bool map_single)
diff --git a/kernel/dma/direct.c b/kernel/dma/direct.c
index de87b0282e74..87a6bc2a96c0 100644
--- a/kernel/dma/direct.c
+++ b/kernel/dma/direct.c
@@ -1,13 +1,16 @@
 // SPDX-License-Identifier: GPL-2.0
 /*
- * DMA operations that map physical memory directly without using an IOMMU or
- * flushing caches.
+ * Copyright (C) 2018 Christoph Hellwig.
+ *
+ * DMA operations that map physical memory directly without using an IOMMU.
  */
+#include <linux/bootmem.h> /* for max_pfn */
 #include <linux/export.h>
 #include <linux/mm.h>
 #include <linux/dma-direct.h>
 #include <linux/scatterlist.h>
 #include <linux/dma-contiguous.h>
+#include <linux/dma-noncoherent.h>
 #include <linux/pfn.h>
 #include <linux/set_memory.h>
 
@@ -41,40 +44,83 @@ check_addr(struct device *dev, dma_addr_t dma_addr, size_t size,
                         return false;
                 }
 
-                if (*dev->dma_mask >= DMA_BIT_MASK(32)) {
+                if (*dev->dma_mask >= DMA_BIT_MASK(32) || dev->bus_dma_mask) {
                         dev_err(dev,
-                                "%s: overflow %pad+%zu of device mask %llx\n",
-                                caller, &dma_addr, size, *dev->dma_mask);
+                                "%s: overflow %pad+%zu of device mask %llx bus mask %llx\n",
+                                caller, &dma_addr, size,
+                                *dev->dma_mask, dev->bus_dma_mask);
                 }
                 return false;
         }
         return true;
 }
 
+static inline dma_addr_t phys_to_dma_direct(struct device *dev,
+                phys_addr_t phys)
+{
+        if (force_dma_unencrypted())
+                return __phys_to_dma(dev, phys);
+        return phys_to_dma(dev, phys);
+}
+
+u64 dma_direct_get_required_mask(struct device *dev)
+{
+        u64 max_dma = phys_to_dma_direct(dev, (max_pfn - 1) << PAGE_SHIFT);
+
+        if (dev->bus_dma_mask && dev->bus_dma_mask < max_dma)
+                max_dma = dev->bus_dma_mask;
+
+        return (1ULL << (fls64(max_dma) - 1)) * 2 - 1;
+}
+
+static gfp_t __dma_direct_optimal_gfp_mask(struct device *dev, u64 dma_mask,
+                u64 *phys_mask)
+{
+        if (dev->bus_dma_mask && dev->bus_dma_mask < dma_mask)
+                dma_mask = dev->bus_dma_mask;
+
+        if (force_dma_unencrypted())
+                *phys_mask = __dma_to_phys(dev, dma_mask);
+        else
+                *phys_mask = dma_to_phys(dev, dma_mask);
+
+        /*
+         * Optimistically try the zone that the physical address mask falls
+         * into first.  If that returns memory that isn't actually addressable
+         * we will fallback to the next lower zone and try again.
+         *
+         * Note that GFP_DMA32 and GFP_DMA are no ops without the corresponding
+         * zones.
+         */
+        if (*phys_mask <= DMA_BIT_MASK(ARCH_ZONE_DMA_BITS))
+                return GFP_DMA;
+        if (*phys_mask <= DMA_BIT_MASK(32))
+                return GFP_DMA32;
+        return 0;
+}
+
 static bool dma_coherent_ok(struct device *dev, phys_addr_t phys, size_t size)
 {
-        dma_addr_t addr = force_dma_unencrypted() ?
-                __phys_to_dma(dev, phys) : phys_to_dma(dev, phys);
-        return addr + size - 1 <= dev->coherent_dma_mask;
+        return phys_to_dma_direct(dev, phys) + size - 1 <=
+                        min_not_zero(dev->coherent_dma_mask, dev->bus_dma_mask);
 }
 
-void *dma_direct_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
-                gfp_t gfp, unsigned long attrs)
+void *dma_direct_alloc_pages(struct device *dev, size_t size,
+                dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 {
         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
         int page_order = get_order(size);
         struct page *page = NULL;
+        u64 phys_mask;
         void *ret;
 
+        if (attrs & DMA_ATTR_NO_WARN)
+                gfp |= __GFP_NOWARN;
+
         /* we always manually zero the memory once we are done: */
         gfp &= ~__GFP_ZERO;
-
-        /* GFP_DMA32 and GFP_DMA are no ops without the corresponding zones: */
-        if (dev->coherent_dma_mask <= DMA_BIT_MASK(ARCH_ZONE_DMA_BITS))
-                gfp |= GFP_DMA;
-        if (dev->coherent_dma_mask <= DMA_BIT_MASK(32) && !(gfp & GFP_DMA))
-                gfp |= GFP_DMA32;
-
+        gfp |= __dma_direct_optimal_gfp_mask(dev, dev->coherent_dma_mask,
+                        &phys_mask);
 again:
         /* CMA can be used only in the context which permits sleeping */
         if (gfpflags_allow_blocking(gfp)) {
@@ -93,15 +139,14 @@ again:
                 page = NULL;
 
                 if (IS_ENABLED(CONFIG_ZONE_DMA32) &&
-                    dev->coherent_dma_mask < DMA_BIT_MASK(64) &&
+                    phys_mask < DMA_BIT_MASK(64) &&
                     !(gfp & (GFP_DMA32 | GFP_DMA))) {
                         gfp |= GFP_DMA32;
                         goto again;
                 }
 
                 if (IS_ENABLED(CONFIG_ZONE_DMA) &&
-                    dev->coherent_dma_mask < DMA_BIT_MASK(32) &&
-                    !(gfp & GFP_DMA)) {
+                    phys_mask < DMA_BIT_MASK(32) && !(gfp & GFP_DMA)) {
                         gfp = (gfp & ~GFP_DMA32) | GFP_DMA;
                         goto again;
                 }
@@ -124,7 +169,7 @@ again:
  * NOTE: this function must never look at the dma_addr argument, because we want
  * to be able to use it as a helper for iommu implementations as well.
  */
-void dma_direct_free(struct device *dev, size_t size, void *cpu_addr,
+void dma_direct_free_pages(struct device *dev, size_t size, void *cpu_addr,
                 dma_addr_t dma_addr, unsigned long attrs)
 {
         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
@@ -136,14 +181,96 @@ void dma_direct_free(struct device *dev, size_t size, void *cpu_addr,
                 free_pages((unsigned long)cpu_addr, page_order);
 }
 
+void *dma_direct_alloc(struct device *dev, size_t size,
+                dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
+{
+        if (!dev_is_dma_coherent(dev))
+                return arch_dma_alloc(dev, size, dma_handle, gfp, attrs);
+        return dma_direct_alloc_pages(dev, size, dma_handle, gfp, attrs);
+}
+
+void dma_direct_free(struct device *dev, size_t size,
+                void *cpu_addr, dma_addr_t dma_addr, unsigned long attrs)
+{
+        if (!dev_is_dma_coherent(dev))
+                arch_dma_free(dev, size, cpu_addr, dma_addr, attrs);
+        else
+                dma_direct_free_pages(dev, size, cpu_addr, dma_addr, attrs);
+}
+
+static void dma_direct_sync_single_for_device(struct device *dev,
+                dma_addr_t addr, size_t size, enum dma_data_direction dir)
+{
+        if (dev_is_dma_coherent(dev))
+                return;
+        arch_sync_dma_for_device(dev, dma_to_phys(dev, addr), size, dir);
+}
+
+static void dma_direct_sync_sg_for_device(struct device *dev,
+                struct scatterlist *sgl, int nents, enum dma_data_direction dir)
+{
+        struct scatterlist *sg;
+        int i;
+
+        if (dev_is_dma_coherent(dev))
+                return;
+
+        for_each_sg(sgl, sg, nents, i)
+                arch_sync_dma_for_device(dev, sg_phys(sg), sg->length, dir);
+}
+
+#if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
+    defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL)
+static void dma_direct_sync_single_for_cpu(struct device *dev,
+                dma_addr_t addr, size_t size, enum dma_data_direction dir)
+{
+        if (dev_is_dma_coherent(dev))
+                return;
+        arch_sync_dma_for_cpu(dev, dma_to_phys(dev, addr), size, dir);
+        arch_sync_dma_for_cpu_all(dev);
+}
+
+static void dma_direct_sync_sg_for_cpu(struct device *dev,
+                struct scatterlist *sgl, int nents, enum dma_data_direction dir)
+{
+        struct scatterlist *sg;
+        int i;
+
+        if (dev_is_dma_coherent(dev))
+                return;
+
+        for_each_sg(sgl, sg, nents, i)
+                arch_sync_dma_for_cpu(dev, sg_phys(sg), sg->length, dir);
+        arch_sync_dma_for_cpu_all(dev);
+}
+
+static void dma_direct_unmap_page(struct device *dev, dma_addr_t addr,
+                size_t size, enum dma_data_direction dir, unsigned long attrs)
+{
+        if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
+                dma_direct_sync_single_for_cpu(dev, addr, size, dir);
+}
+
+static void dma_direct_unmap_sg(struct device *dev, struct scatterlist *sgl,
+                int nents, enum dma_data_direction dir, unsigned long attrs)
+{
+        if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
+                dma_direct_sync_sg_for_cpu(dev, sgl, nents, dir);
+}
+#endif
+
 dma_addr_t dma_direct_map_page(struct device *dev, struct page *page,
                 unsigned long offset, size_t size, enum dma_data_direction dir,
                 unsigned long attrs)
 {
-        dma_addr_t dma_addr = phys_to_dma(dev, page_to_phys(page)) + offset;
+        phys_addr_t phys = page_to_phys(page) + offset;
+        dma_addr_t dma_addr = phys_to_dma(dev, phys);
 
         if (!check_addr(dev, dma_addr, size, __func__))
                 return DIRECT_MAPPING_ERROR;
+
+        if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
+                dma_direct_sync_single_for_device(dev, dma_addr, size, dir);
         return dma_addr;
 }
 
@@ -162,31 +289,29 @@ int dma_direct_map_sg(struct device *dev, struct scatterlist *sgl, int nents,
                 sg_dma_len(sg) = sg->length;
         }
 
+        if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
+                dma_direct_sync_sg_for_device(dev, sgl, nents, dir);
         return nents;
 }
 
+/*
+ * Because 32-bit DMA masks are so common we expect every architecture to be
+ * able to satisfy them - either by not supporting more physical memory, or by
+ * providing a ZONE_DMA32.  If neither is the case, the architecture needs to
+ * use an IOMMU instead of the direct mapping.
+ */
 int dma_direct_supported(struct device *dev, u64 mask)
 {
-#ifdef CONFIG_ZONE_DMA
-        if (mask < phys_to_dma(dev, DMA_BIT_MASK(ARCH_ZONE_DMA_BITS)))
-                return 0;
-#else
-        /*
-         * Because 32-bit DMA masks are so common we expect every architecture
-         * to be able to satisfy them - either by not supporting more physical
-         * memory, or by providing a ZONE_DMA32.  If neither is the case, the
-         * architecture needs to use an IOMMU instead of the direct mapping.
-         */
-        if (mask < phys_to_dma(dev, DMA_BIT_MASK(32)))
-                return 0;
-#endif
-        /*
-         * Upstream PCI/PCIe bridges or SoC interconnects may not carry
-         * as many DMA address bits as the device itself supports.
-         */
-        if (dev->bus_dma_mask && mask > dev->bus_dma_mask)
-                return 0;
-        return 1;
+        u64 min_mask;
+
+        if (IS_ENABLED(CONFIG_ZONE_DMA))
+                min_mask = DMA_BIT_MASK(ARCH_ZONE_DMA_BITS);
+        else
+                min_mask = DMA_BIT_MASK(32);
+
+        min_mask = min_t(u64, min_mask, (max_pfn - 1) << PAGE_SHIFT);
+
+        return mask >= phys_to_dma(dev, min_mask);
 }
 
 int dma_direct_mapping_error(struct device *dev, dma_addr_t dma_addr)
@@ -199,7 +324,20 @@ const struct dma_map_ops dma_direct_ops = {
         .free                   = dma_direct_free,
         .map_page               = dma_direct_map_page,
         .map_sg                 = dma_direct_map_sg,
+#if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE)
+        .sync_single_for_device = dma_direct_sync_single_for_device,
+        .sync_sg_for_device     = dma_direct_sync_sg_for_device,
+#endif
+#if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
+    defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL)
+        .sync_single_for_cpu    = dma_direct_sync_single_for_cpu,
+        .sync_sg_for_cpu        = dma_direct_sync_sg_for_cpu,
+        .unmap_page             = dma_direct_unmap_page,
+        .unmap_sg               = dma_direct_unmap_sg,
+#endif
+        .get_required_mask      = dma_direct_get_required_mask,
         .dma_supported          = dma_direct_supported,
         .mapping_error          = dma_direct_mapping_error,
+        .cache_sync             = arch_dma_cache_sync,
 };
 EXPORT_SYMBOL(dma_direct_ops);
diff --git a/kernel/dma/mapping.c b/kernel/dma/mapping.c
index d2a92ddaac4d..58dec7a92b7b 100644
--- a/kernel/dma/mapping.c
+++ b/kernel/dma/mapping.c
@@ -7,7 +7,7 @@
  */
 
 #include <linux/acpi.h>
-#include <linux/dma-mapping.h>
+#include <linux/dma-noncoherent.h>
 #include <linux/export.h>
 #include <linux/gfp.h>
 #include <linux/of_device.h>
@@ -202,17 +202,26 @@ EXPORT_SYMBOL(dmam_release_declared_memory);
  * Create scatter-list for the already allocated DMA buffer.
  */
 int dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,
-                 void *cpu_addr, dma_addr_t handle, size_t size)
+                 void *cpu_addr, dma_addr_t dma_addr, size_t size,
+                 unsigned long attrs)
 {
-        struct page *page = virt_to_page(cpu_addr);
+        struct page *page;
         int ret;
 
-        ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
-        if (unlikely(ret))
-                return ret;
+        if (!dev_is_dma_coherent(dev)) {
+                if (!IS_ENABLED(CONFIG_ARCH_HAS_DMA_COHERENT_TO_PFN))
+                        return -ENXIO;
 
-        sg_set_page(sgt->sgl, page, PAGE_ALIGN(size), 0);
-        return 0;
+                page = pfn_to_page(arch_dma_coherent_to_pfn(dev, cpu_addr,
+                                dma_addr));
+        } else {
+                page = virt_to_page(cpu_addr);
+        }
+
+        ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
+        if (!ret)
+                sg_set_page(sgt->sgl, page, PAGE_ALIGN(size), 0);
+        return ret;
 }
 EXPORT_SYMBOL(dma_common_get_sgtable);
 
@@ -220,27 +229,37 @@ EXPORT_SYMBOL(dma_common_get_sgtable);
  * Create userspace mapping for the DMA-coherent memory.
  */
 int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
-                    void *cpu_addr, dma_addr_t dma_addr, size_t size)
+                void *cpu_addr, dma_addr_t dma_addr, size_t size,
+                unsigned long attrs)
 {
-        int ret = -ENXIO;
 #ifndef CONFIG_ARCH_NO_COHERENT_DMA_MMAP
         unsigned long user_count = vma_pages(vma);
         unsigned long count = PAGE_ALIGN(size) >> PAGE_SHIFT;
         unsigned long off = vma->vm_pgoff;
+        unsigned long pfn;
+        int ret = -ENXIO;
 
-        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+        vma->vm_page_prot = arch_dma_mmap_pgprot(dev, vma->vm_page_prot, attrs);
 
         if (dma_mmap_from_dev_coherent(dev, vma, cpu_addr, size, &ret))
                 return ret;
 
-        if (off < count && user_count <= (count - off))
-                ret = remap_pfn_range(vma, vma->vm_start,
-                                      page_to_pfn(virt_to_page(cpu_addr)) + off,
-                                      user_count << PAGE_SHIFT,
-                                      vma->vm_page_prot);
-#endif  /* !CONFIG_ARCH_NO_COHERENT_DMA_MMAP */
+        if (off >= count || user_count > count - off)
+                return -ENXIO;
 
-        return ret;
+        if (!dev_is_dma_coherent(dev)) {
+                if (!IS_ENABLED(CONFIG_ARCH_HAS_DMA_COHERENT_TO_PFN))
+                        return -ENXIO;
+                pfn = arch_dma_coherent_to_pfn(dev, cpu_addr, dma_addr);
+        } else {
+                pfn = page_to_pfn(virt_to_page(cpu_addr));
+        }
+
+        return remap_pfn_range(vma, vma->vm_start, pfn + vma->vm_pgoff,
+                        user_count << PAGE_SHIFT, vma->vm_page_prot);
+#else
+        return -ENXIO;
+#endif /* !CONFIG_ARCH_NO_COHERENT_DMA_MMAP */
 }
 EXPORT_SYMBOL(dma_common_mmap);
 
@@ -327,19 +346,3 @@ void dma_common_free_remap(void *cpu_addr, size_t size, unsigned long vm_flags)
         vunmap(cpu_addr);
 }
 #endif
-
-/*
- * enables DMA API use for a device
- */
-int dma_configure(struct device *dev)
-{
-        if (dev->bus->dma_configure)
-                return dev->bus->dma_configure(dev);
-        return 0;
-}
-
-void dma_deconfigure(struct device *dev)
-{
-        of_dma_deconfigure(dev);
-        acpi_dma_deconfigure(dev);
-}
diff --git a/kernel/dma/noncoherent.c b/kernel/dma/noncoherent.c
deleted file mode 100644
index 031fe235d958..000000000000
--- a/kernel/dma/noncoherent.c
+++ /dev/null
@@ -1,106 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2018 Christoph Hellwig.
- *
- * DMA operations that map physical memory directly without providing cache
- * coherence.
- */
-#include <linux/export.h>
-#include <linux/mm.h>
-#include <linux/dma-direct.h>
-#include <linux/dma-noncoherent.h>
-#include <linux/scatterlist.h>
-
-static void dma_noncoherent_sync_single_for_device(struct device *dev,
-                dma_addr_t addr, size_t size, enum dma_data_direction dir)
-{
-        arch_sync_dma_for_device(dev, dma_to_phys(dev, addr), size, dir);
-}
-
-static void dma_noncoherent_sync_sg_for_device(struct device *dev,
-                struct scatterlist *sgl, int nents, enum dma_data_direction dir)
-{
-        struct scatterlist *sg;
-        int i;
-
-        for_each_sg(sgl, sg, nents, i)
-                arch_sync_dma_for_device(dev, sg_phys(sg), sg->length, dir);
-}
-
-static dma_addr_t dma_noncoherent_map_page(struct device *dev, struct page *page,
-                unsigned long offset, size_t size, enum dma_data_direction dir,
-                unsigned long attrs)
-{
-        dma_addr_t addr;
-
-        addr = dma_direct_map_page(dev, page, offset, size, dir, attrs);
-        if (!dma_mapping_error(dev, addr) && !(attrs & DMA_ATTR_SKIP_CPU_SYNC))
-                arch_sync_dma_for_device(dev, page_to_phys(page) + offset,
-                                size, dir);
-        return addr;
-}
-
-static int dma_noncoherent_map_sg(struct device *dev, struct scatterlist *sgl,
-                int nents, enum dma_data_direction dir, unsigned long attrs)
-{
-        nents = dma_direct_map_sg(dev, sgl, nents, dir, attrs);
-        if (nents > 0 && !(attrs & DMA_ATTR_SKIP_CPU_SYNC))
-                dma_noncoherent_sync_sg_for_device(dev, sgl, nents, dir);
-        return nents;
-}
-
-#if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
-    defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL)
-static void dma_noncoherent_sync_single_for_cpu(struct device *dev,
-                dma_addr_t addr, size_t size, enum dma_data_direction dir)
-{
-        arch_sync_dma_for_cpu(dev, dma_to_phys(dev, addr), size, dir);
-        arch_sync_dma_for_cpu_all(dev);
-}
-
-static void dma_noncoherent_sync_sg_for_cpu(struct device *dev,
-                struct scatterlist *sgl, int nents, enum dma_data_direction dir)
-{
-        struct scatterlist *sg;
-        int i;
-
-        for_each_sg(sgl, sg, nents, i)
-                arch_sync_dma_for_cpu(dev, sg_phys(sg), sg->length, dir);
-        arch_sync_dma_for_cpu_all(dev);
-}
-
-static void dma_noncoherent_unmap_page(struct device *dev, dma_addr_t addr,
-                size_t size, enum dma_data_direction dir, unsigned long attrs)
-{
-        if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
-                dma_noncoherent_sync_single_for_cpu(dev, addr, size, dir);
-}
-
-static void dma_noncoherent_unmap_sg(struct device *dev, struct scatterlist *sgl,
-                int nents, enum dma_data_direction dir, unsigned long attrs)
-{
-        if (!(attrs & DMA_ATTR_SKIP_CPU_SYNC))
-                dma_noncoherent_sync_sg_for_cpu(dev, sgl, nents, dir);
-}
-#endif
-
-const struct dma_map_ops dma_noncoherent_ops = {
-        .alloc                  = arch_dma_alloc,
-        .free                   = arch_dma_free,
-        .mmap                   = arch_dma_mmap,
-        .sync_single_for_device = dma_noncoherent_sync_single_for_device,
-        .sync_sg_for_device     = dma_noncoherent_sync_sg_for_device,
-        .map_page               = dma_noncoherent_map_page,
-        .map_sg                 = dma_noncoherent_map_sg,
-#if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
-    defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL)
-        .sync_single_for_cpu    = dma_noncoherent_sync_single_for_cpu,
-        .sync_sg_for_cpu        = dma_noncoherent_sync_sg_for_cpu,
-        .unmap_page             = dma_noncoherent_unmap_page,
-        .unmap_sg               = dma_noncoherent_unmap_sg,
-#endif
-        .dma_supported          = dma_direct_supported,
-        .mapping_error          = dma_direct_mapping_error,
-        .cache_sync             = arch_dma_cache_sync,
-};
-EXPORT_SYMBOL(dma_noncoherent_ops);