4 files changed, 115 insertions, 66 deletions

diff --git a/kernel/dma/Kconfig b/kernel/dma/Kconfig
index 9decbba255fc..73c5c2b8e824 100644
--- a/kernel/dma/Kconfig
+++ b/kernel/dma/Kconfig
@@ -20,6 +20,15 @@ config ARCH_HAS_DMA_COHERENCE_H
 config ARCH_HAS_DMA_SET_MASK
         bool
 
+#
+# Select this option if the architecture needs special handling for
+# DMA_ATTR_WRITE_COMBINE.  Normally the "uncached" mapping should be what
+# people thing of when saying write combine, so very few platforms should
+# need to enable this.
+#
+config ARCH_HAS_DMA_WRITE_COMBINE
+        bool
+
 config DMA_DECLARE_COHERENT
         bool
 
@@ -45,9 +54,6 @@ config ARCH_HAS_DMA_PREP_COHERENT
 config ARCH_HAS_DMA_COHERENT_TO_PFN
         bool
 
-config ARCH_HAS_DMA_MMAP_PGPROT
-        bool
-
 config ARCH_HAS_FORCE_DMA_UNENCRYPTED
         bool
 
diff --git a/kernel/dma/coherent.c b/kernel/dma/coherent.c
index 29fd6590dc1e..545e3869b0e3 100644
--- a/kernel/dma/coherent.c
+++ b/kernel/dma/coherent.c
@@ -122,18 +122,6 @@ int dma_declare_coherent_memory(struct device *dev, phys_addr_t phys_addr,
                 dma_release_coherent_memory(mem);
         return ret;
 }
-EXPORT_SYMBOL(dma_declare_coherent_memory);
-
-void dma_release_declared_memory(struct device *dev)
-{
-        struct dma_coherent_mem *mem = dev->dma_mem;
-
-        if (!mem)
-                return;
-        dma_release_coherent_memory(mem);
-        dev->dma_mem = NULL;
-}
-EXPORT_SYMBOL(dma_release_declared_memory);
 
 static void *__dma_alloc_from_coherent(struct dma_coherent_mem *mem,
                 ssize_t size, dma_addr_t *dma_handle)
@@ -288,7 +276,6 @@ int dma_mmap_from_dev_coherent(struct device *dev, struct vm_area_struct *vma,
 
         return __dma_mmap_from_coherent(mem, vma, vaddr, size, ret);
 }
-EXPORT_SYMBOL(dma_mmap_from_dev_coherent);
 
 int dma_mmap_from_global_coherent(struct vm_area_struct *vma, void *vaddr,
                                    size_t size, int *ret)
diff --git a/kernel/dma/mapping.c b/kernel/dma/mapping.c
index b0038ca3aa92..64a3d294f4b4 100644
--- a/kernel/dma/mapping.c
+++ b/kernel/dma/mapping.c
@@ -136,17 +136,29 @@ int dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,
         return ret;
 }
 
+/*
+ * The whole dma_get_sgtable() idea is fundamentally unsafe - it seems
+ * that the intention is to allow exporting memory allocated via the
+ * coherent DMA APIs through the dma_buf API, which only accepts a
+ * scattertable.  This presents a couple of problems:
+ * 1. Not all memory allocated via the coherent DMA APIs is backed by
+ *    a struct page
+ * 2. Passing coherent DMA memory into the streaming APIs is not allowed
+ *    as we will try to flush the memory through a different alias to that
+ *    actually being used (and the flushes are redundant.)
+ */
 int dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt,
                 void *cpu_addr, dma_addr_t dma_addr, size_t size,
                 unsigned long attrs)
 {
         const struct dma_map_ops *ops = get_dma_ops(dev);
 
-        if (!dma_is_direct(ops) && ops->get_sgtable)
-                return ops->get_sgtable(dev, sgt, cpu_addr, dma_addr, size,
-                                        attrs);
-        return dma_common_get_sgtable(dev, sgt, cpu_addr, dma_addr, size,
-                        attrs);
+        if (dma_is_direct(ops))
+                return dma_common_get_sgtable(dev, sgt, cpu_addr, dma_addr,
+                                size, attrs);
+        if (!ops->get_sgtable)
+                return -ENXIO;
+        return ops->get_sgtable(dev, sgt, cpu_addr, dma_addr, size, attrs);
 }
 EXPORT_SYMBOL(dma_get_sgtable_attrs);
 
@@ -161,9 +173,11 @@ pgprot_t dma_pgprot(struct device *dev, pgprot_t prot, unsigned long attrs)
             (IS_ENABLED(CONFIG_DMA_NONCOHERENT_CACHE_SYNC) &&
              (attrs & DMA_ATTR_NON_CONSISTENT)))
                 return prot;
-        if (IS_ENABLED(CONFIG_ARCH_HAS_DMA_MMAP_PGPROT))
-                return arch_dma_mmap_pgprot(dev, prot, attrs);
-        return pgprot_noncached(prot);
+#ifdef CONFIG_ARCH_HAS_DMA_WRITE_COMBINE
+        if (attrs & DMA_ATTR_WRITE_COMBINE)
+                return pgprot_writecombine(prot);
+#endif
+        return pgprot_dmacoherent(prot);
 }
 #endif /* CONFIG_MMU */
 
@@ -174,7 +188,7 @@ int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
                 void *cpu_addr, dma_addr_t dma_addr, size_t size,
                 unsigned long attrs)
 {
-#ifndef CONFIG_ARCH_NO_COHERENT_DMA_MMAP
+#ifdef CONFIG_MMU
         unsigned long user_count = vma_pages(vma);
         unsigned long count = PAGE_ALIGN(size) >> PAGE_SHIFT;
         unsigned long off = vma->vm_pgoff;
@@ -205,8 +219,29 @@ int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
                         user_count << PAGE_SHIFT, vma->vm_page_prot);
 #else
         return -ENXIO;
-#endif /* !CONFIG_ARCH_NO_COHERENT_DMA_MMAP */
+#endif /* CONFIG_MMU */
+}
+
+/**
+ * dma_can_mmap - check if a given device supports dma_mmap_*
+ * @dev: device to check
+ *
+ * Returns %true if @dev supports dma_mmap_coherent() and dma_mmap_attrs() to
+ * map DMA allocations to userspace.
+ */
+bool dma_can_mmap(struct device *dev)
+{
+        const struct dma_map_ops *ops = get_dma_ops(dev);
+
+        if (dma_is_direct(ops)) {
+                return IS_ENABLED(CONFIG_MMU) &&
+                       (dev_is_dma_coherent(dev) ||
+                        IS_ENABLED(CONFIG_ARCH_HAS_DMA_COHERENT_TO_PFN));
+        }
+
+        return ops->mmap != NULL;
 }
+EXPORT_SYMBOL_GPL(dma_can_mmap);
 
 /**
  * dma_mmap_attrs - map a coherent DMA allocation into user space
@@ -227,31 +262,15 @@ int dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
 {
         const struct dma_map_ops *ops = get_dma_ops(dev);
 
-        if (!dma_is_direct(ops) && ops->mmap)
-                return ops->mmap(dev, vma, cpu_addr, dma_addr, size, attrs);
-        return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size, attrs);
+        if (dma_is_direct(ops))
+                return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size,
+                                attrs);
+        if (!ops->mmap)
+                return -ENXIO;
+        return ops->mmap(dev, vma, cpu_addr, dma_addr, size, attrs);
 }
 EXPORT_SYMBOL(dma_mmap_attrs);
 
-static u64 dma_default_get_required_mask(struct device *dev)
-{
-        u32 low_totalram = ((max_pfn - 1) << PAGE_SHIFT);
-        u32 high_totalram = ((max_pfn - 1) >> (32 - PAGE_SHIFT));
-        u64 mask;
-
-        if (!high_totalram) {
-                /* convert to mask just covering totalram */
-                low_totalram = (1 << (fls(low_totalram) - 1));
-                low_totalram += low_totalram - 1;
-                mask = low_totalram;
-        } else {
-                high_totalram = (1 << (fls(high_totalram) - 1));
-                high_totalram += high_totalram - 1;
-                mask = (((u64)high_totalram) << 32) + 0xffffffff;
-        }
-        return mask;
-}
-
 u64 dma_get_required_mask(struct device *dev)
 {
         const struct dma_map_ops *ops = get_dma_ops(dev);
@@ -260,7 +279,16 @@ u64 dma_get_required_mask(struct device *dev)
                 return dma_direct_get_required_mask(dev);
         if (ops->get_required_mask)
                 return ops->get_required_mask(dev);
-        return dma_default_get_required_mask(dev);
+
+        /*
+         * We require every DMA ops implementation to at least support a 32-bit
+         * DMA mask (and use bounce buffering if that isn't supported in
+         * hardware).  As the direct mapping code has its own routine to
+         * actually report an optimal mask we default to 32-bit here as that
+         * is the right thing for most IOMMUs, and at least not actively
+         * harmful in general.
+         */
+        return DMA_BIT_MASK(32);
 }
 EXPORT_SYMBOL_GPL(dma_get_required_mask);
 
@@ -405,3 +433,14 @@ size_t dma_max_mapping_size(struct device *dev)
         return size;
 }
 EXPORT_SYMBOL_GPL(dma_max_mapping_size);
+
+unsigned long dma_get_merge_boundary(struct device *dev)
+{
+        const struct dma_map_ops *ops = get_dma_ops(dev);
+
+        if (!ops || !ops->get_merge_boundary)
+                return 0;       /* can't merge */
+
+        return ops->get_merge_boundary(dev);
+}
+EXPORT_SYMBOL_GPL(dma_get_merge_boundary);
diff --git a/kernel/dma/remap.c b/kernel/dma/remap.c
index ffe78f0b2fe4..ca4e5d44b571 100644
--- a/kernel/dma/remap.c
+++ b/kernel/dma/remap.c
@@ -11,13 +11,21 @@
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 
+struct page **dma_common_find_pages(void *cpu_addr)
+{
+        struct vm_struct *area = find_vm_area(cpu_addr);
+
+        if (!area || area->flags != VM_DMA_COHERENT)
+                return NULL;
+        return area->pages;
+}
+
 static struct vm_struct *__dma_common_pages_remap(struct page **pages,
-                        size_t size, unsigned long vm_flags, pgprot_t prot,
-                        const void *caller)
+                        size_t size, pgprot_t prot, const void *caller)
 {
         struct vm_struct *area;
 
-        area = get_vm_area_caller(size, vm_flags, caller);
+        area = get_vm_area_caller(size, VM_DMA_COHERENT, caller);
         if (!area)
                 return NULL;
 
@@ -34,12 +42,11 @@ static struct vm_struct *__dma_common_pages_remap(struct page **pages,
  * Cannot be used in non-sleeping contexts
  */
 void *dma_common_pages_remap(struct page **pages, size_t size,
-                        unsigned long vm_flags, pgprot_t prot,
-                        const void *caller)
+                         pgprot_t prot, const void *caller)
 {
         struct vm_struct *area;
 
-        area = __dma_common_pages_remap(pages, size, vm_flags, prot, caller);
+        area = __dma_common_pages_remap(pages, size, prot, caller);
         if (!area)
                 return NULL;
 
@@ -53,7 +60,6 @@ void *dma_common_pages_remap(struct page **pages, size_t size,
  * Cannot be used in non-sleeping contexts
  */
 void *dma_common_contiguous_remap(struct page *page, size_t size,
-                        unsigned long vm_flags,
                         pgprot_t prot, const void *caller)
 {
         int i;
@@ -67,7 +73,7 @@ void *dma_common_contiguous_remap(struct page *page, size_t size,
         for (i = 0; i < (size >> PAGE_SHIFT); i++)
                 pages[i] = nth_page(page, i);
 
-        area = __dma_common_pages_remap(pages, size, vm_flags, prot, caller);
+        area = __dma_common_pages_remap(pages, size, prot, caller);
 
         kfree(pages);
 
@@ -79,11 +85,11 @@ void *dma_common_contiguous_remap(struct page *page, size_t size,
 /*
  * Unmaps a range previously mapped by dma_common_*_remap
  */
-void dma_common_free_remap(void *cpu_addr, size_t size, unsigned long vm_flags)
+void dma_common_free_remap(void *cpu_addr, size_t size)
 {
-        struct vm_struct *area = find_vm_area(cpu_addr);
+        struct page **pages = dma_common_find_pages(cpu_addr);
 
-        if (!area || (area->flags & vm_flags) != vm_flags) {
+        if (!pages) {
                 WARN(1, "trying to free invalid coherent area: %p\n", cpu_addr);
                 return;
         }
@@ -105,7 +111,16 @@ static int __init early_coherent_pool(char *p)
 }
 early_param("coherent_pool", early_coherent_pool);
 
-int __init dma_atomic_pool_init(gfp_t gfp, pgprot_t prot)
+static gfp_t dma_atomic_pool_gfp(void)
+{
+        if (IS_ENABLED(CONFIG_ZONE_DMA))
+                return GFP_DMA;
+        if (IS_ENABLED(CONFIG_ZONE_DMA32))
+                return GFP_DMA32;
+        return GFP_KERNEL;
+}
+
+static int __init dma_atomic_pool_init(void)
 {
         unsigned int pool_size_order = get_order(atomic_pool_size);
         unsigned long nr_pages = atomic_pool_size >> PAGE_SHIFT;
@@ -117,7 +132,7 @@ int __init dma_atomic_pool_init(gfp_t gfp, pgprot_t prot)
                 page = dma_alloc_from_contiguous(NULL, nr_pages,
                                                  pool_size_order, false);
         else
-                page = alloc_pages(gfp, pool_size_order);
+                page = alloc_pages(dma_atomic_pool_gfp(), pool_size_order);
         if (!page)
                 goto out;
 
@@ -127,8 +142,9 @@ int __init dma_atomic_pool_init(gfp_t gfp, pgprot_t prot)
         if (!atomic_pool)
                 goto free_page;
 
-        addr = dma_common_contiguous_remap(page, atomic_pool_size, VM_USERMAP,
-                                           prot, __builtin_return_address(0));
+        addr = dma_common_contiguous_remap(page, atomic_pool_size,
+                                           pgprot_dmacoherent(PAGE_KERNEL),
+                                           __builtin_return_address(0));
         if (!addr)
                 goto destroy_genpool;
 
@@ -143,7 +159,7 @@ int __init dma_atomic_pool_init(gfp_t gfp, pgprot_t prot)
         return 0;
 
 remove_mapping:
-        dma_common_free_remap(addr, atomic_pool_size, VM_USERMAP);
+        dma_common_free_remap(addr, atomic_pool_size);
 destroy_genpool:
         gen_pool_destroy(atomic_pool);
         atomic_pool = NULL;
@@ -155,6 +171,7 @@ out:
                 atomic_pool_size / 1024);
         return -ENOMEM;
 }
+postcore_initcall(dma_atomic_pool_init);
 
 bool dma_in_atomic_pool(void *start, size_t size)
 {
@@ -217,7 +234,7 @@ void *arch_dma_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
         arch_dma_prep_coherent(page, size);
 
         /* create a coherent mapping */
-        ret = dma_common_contiguous_remap(page, size, VM_USERMAP,
+        ret = dma_common_contiguous_remap(page, size,
                         dma_pgprot(dev, PAGE_KERNEL, attrs),
                         __builtin_return_address(0));
         if (!ret) {