Merge tag 'dma-mapping-4.20' of git://git.infradead.org/users/hch/dma-mapping

Pull dma mapping updates from Christoph Hellwig:
 "First batch of dma-mapping changes for 4.20.

  There will be a second PR as some big changes were only applied just
  before the end of the merge window, and I want to give them a few more
  days in linux-next.

  Summary:

   - mostly more consolidation of the direct mapping code, including
     converting over hexagon, and merging the coherent and non-coherent
     code into a single dma_map_ops instance (me)

   - cleanups for the dma_configure/dma_unconfigure callchains (me)

   - better handling of dma_masks in odd setups (me, Alexander Duyck)

   - better debugging of passing vmalloc address to the DMA API (Stephen
     Boyd)

   - CMA command line parsing fix (He Zhe)"

* tag 'dma-mapping-4.20' of git://git.infradead.org/users/hch/dma-mapping: (27 commits)
  dma-direct: respect DMA_ATTR_NO_WARN
  dma-mapping: translate __GFP_NOFAIL to DMA_ATTR_NO_WARN
  dma-direct: document the zone selection logic
  dma-debug: Check for drivers mapping invalid addresses in dma_map_single()
  dma-direct: fix return value of dma_direct_supported
  dma-mapping: move dma_default_get_required_mask under ifdef
  dma-direct: always allow dma mask <= physiscal memory size
  dma-direct: implement complete bus_dma_mask handling
  dma-direct: refine dma_direct_alloc zone selection
  dma-direct: add an explicit dma_direct_get_required_mask
  dma-mapping: make the get_required_mask method available unconditionally
  unicore32: remove swiotlb support
  Revert "dma-mapping: clear dev->dma_ops in arch_teardown_dma_ops"
  dma-mapping: support non-coherent devices in dma_common_get_sgtable
  dma-mapping: consolidate the dma mmap implementations
  dma-mapping: merge direct and noncoherent ops
  dma-mapping: move the dma_coherent flag to struct device
  MIPS: don't select DMA_MAYBE_COHERENT from DMA_PERDEV_COHERENT
  dma-mapping: add the missing ARCH_HAS_SYNC_DMA_FOR_CPU_ALL declaration
  dma-mapping: fix panic caused by passing empty cma command line argument
  ...

1 files changed, 37 insertions, 34 deletions

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);
-}