x86/dma: Remove dma_alloc_coherent_mask()

These days all devices (including the ISA fallback device) have a coherent
DMA mask set, so remove the workaround.

Tested-by: Tom Lendacky <thomas.lendacky@amd.com>
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Cc: David Woodhouse <dwmw2@infradead.org>
Cc: Joerg Roedel <joro@8bytes.org>
Cc: Jon Mason <jdmason@kudzu.us>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Muli Ben-Yehuda <mulix@mulix.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: iommu@lists.linux-foundation.org
Link: http://lkml.kernel.org/r/20180319103826.12853-3-hch@lst.de
Signed-off-by: Ingo Molnar <mingo@kernel.org>

diff --git a/arch/x86/include/asm/dma-mapping.h b/arch/x86/include/asm/dma-mapping.h
index 6277c83c0eb18e51023a561703cd7856dfd7dba6..545bf3721bc0ffbbcc0921107c2003639e752a26 100644 (file)
--- a/arch/x86/include/asm/dma-mapping.h
+++ b/arch/x86/include/asm/dma-mapping.h
@@ -44,26 +44,12 @@ extern void dma_generic_free_coherent(struct device *dev, size_t size,
                                      void *vaddr, dma_addr_t dma_addr,
                                      unsigned long attrs);
 
-static inline unsigned long dma_alloc_coherent_mask(struct device *dev,
-                                                   gfp_t gfp)
-{
-       unsigned long dma_mask = 0;
-
-       dma_mask = dev->coherent_dma_mask;
-       if (!dma_mask)
-               dma_mask = (gfp & GFP_DMA) ? DMA_BIT_MASK(24) : DMA_BIT_MASK(32);
-
-       return dma_mask;
-}
-
 static inline gfp_t dma_alloc_coherent_gfp_flags(struct device *dev, gfp_t gfp)
 {
-       unsigned long dma_mask = dma_alloc_coherent_mask(dev, gfp);
-
-       if (dma_mask <= DMA_BIT_MASK(24))
+       if (dev->coherent_dma_mask <= DMA_BIT_MASK(24))
                gfp |= GFP_DMA;
 #ifdef CONFIG_X86_64
-       if (dma_mask <= DMA_BIT_MASK(32) && !(gfp & GFP_DMA))
+       if (dev->coherent_dma_mask <= DMA_BIT_MASK(32) && !(gfp & GFP_DMA))
                gfp |= GFP_DMA32;
 #endif
        return gfp;

diff --git a/arch/x86/kernel/pci-dma.c b/arch/x86/kernel/pci-dma.c
index df7ab02f959f69e46d662bee7f34d5d803c852f1..b59820872ec73a4e278ac09316ed79fac5c22428 100644 (file)
--- a/arch/x86/kernel/pci-dma.c
+++ b/arch/x86/kernel/pci-dma.c
@@ -80,13 +80,10 @@ void *dma_generic_alloc_coherent(struct device *dev, size_t size,
                                 dma_addr_t *dma_addr, gfp_t flag,
                                 unsigned long attrs)
 {
-       unsigned long dma_mask;
        struct page *page;
        unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
        dma_addr_t addr;
 
-       dma_mask = dma_alloc_coherent_mask(dev, flag);
-
 again:
        page = NULL;
        /* CMA can be used only in the context which permits sleeping */
@@ -95,7 +92,7 @@ again:
                                                 flag);
                if (page) {
                        addr = phys_to_dma(dev, page_to_phys(page));
-                       if (addr + size > dma_mask) {
+                       if (addr + size > dev->coherent_dma_mask) {
                                dma_release_from_contiguous(dev, page, count);
                                page = NULL;
                        }
@@ -108,10 +105,11 @@ again:
                return NULL;
 
        addr = phys_to_dma(dev, page_to_phys(page));
-       if (addr + size > dma_mask) {
+       if (addr + size > dev->coherent_dma_mask) {
                __free_pages(page, get_order(size));
 
-               if (dma_mask < DMA_BIT_MASK(32) && !(flag & GFP_DMA)) {
+               if (dev->coherent_dma_mask < DMA_BIT_MASK(32) &&
+                   !(flag & GFP_DMA)) {
                        flag = (flag & ~GFP_DMA32) | GFP_DMA;
                        goto again;
                }

diff --git a/arch/x86/mm/mem_encrypt.c b/arch/x86/mm/mem_encrypt.c
index 3a1b5fe4c2ca225f268894e925c29719e2af9716..f6cd84beb61044bcc84cb9164baa6c7004e211d8 100644 (file)
--- a/arch/x86/mm/mem_encrypt.c
+++ b/arch/x86/mm/mem_encrypt.c
@@ -198,12 +198,10 @@ void __init sme_early_init(void)
 static void *sev_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
                       gfp_t gfp, unsigned long attrs)
 {
-       unsigned long dma_mask;
        unsigned int order;
        struct page *page;
        void *vaddr = NULL;
 
-       dma_mask = dma_alloc_coherent_mask(dev, gfp);
        order = get_order(size);
 
        /*
@@ -221,7 +219,7 @@ static void *sev_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
                 * mask with it already cleared.
                 */
                addr = __sme_clr(phys_to_dma(dev, page_to_phys(page)));
-               if ((addr + size) > dma_mask) {
+               if ((addr + size) > dev->coherent_dma_mask) {
                        __free_pages(page, get_order(size));
                } else {
                        vaddr = page_address(page);

diff --git a/drivers/xen/swiotlb-xen.c b/drivers/xen/swiotlb-xen.c
index 5bb72d3f8337c742b4bdb068d84cddf2b4156a7e..e1c60899fdbc8de0b530078bb310f28bea33dd2c 100644 (file)
--- a/drivers/xen/swiotlb-xen.c
+++ b/drivers/xen/swiotlb-xen.c
@@ -53,20 +53,6 @@
  * API.
  */
 
-#ifndef CONFIG_X86
-static unsigned long dma_alloc_coherent_mask(struct device *dev,
-                                           gfp_t gfp)
-{
-       unsigned long dma_mask = 0;
-
-       dma_mask = dev->coherent_dma_mask;
-       if (!dma_mask)
-               dma_mask = (gfp & GFP_DMA) ? DMA_BIT_MASK(24) : DMA_BIT_MASK(32);
-
-       return dma_mask;
-}
-#endif
-
 #define XEN_SWIOTLB_ERROR_CODE (~(dma_addr_t)0x0)
 
 static char *xen_io_tlb_start, *xen_io_tlb_end;
@@ -328,7 +314,7 @@ xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                return ret;
 
        if (hwdev && hwdev->coherent_dma_mask)
-               dma_mask = dma_alloc_coherent_mask(hwdev, flags);
+               dma_mask = hwdev->coherent_dma_mask;
 
        /* At this point dma_handle is the physical address, next we are
         * going to set it to the machine address.