X86 & IA64: adapt for dma_map_ops changes

Adapt core x86 and IA64 architecture code for dma_map_ops changes: replace
alloc/free_coherent with generic alloc/free methods.

Signed-off-by: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
Acked-by: Kyungmin Park <kyungmin.park@samsung.com>
[removed swiotlb related changes and replaced it with wrappers,
 merged with IA64 patch to avoid inter-patch dependences in intel-iommu code]
Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>
Reviewed-by: Arnd Bergmann <arnd@arndb.de>
Acked-by: Tony Luck <tony.luck@intel.com>

7 files changed, 47 insertions, 29 deletions

diff --git a/arch/x86/include/asm/dma-mapping.h b/arch/x86/include/asm/dma-mapping.h
index ed3065fd6314..4b4331d71935 100644
--- a/arch/x86/include/asm/dma-mapping.h
+++ b/arch/x86/include/asm/dma-mapping.h
@@ -59,7 +59,8 @@ extern int dma_supported(struct device *hwdev, u64 mask);
 extern int dma_set_mask(struct device *dev, u64 mask);
 
 extern void *dma_generic_alloc_coherent(struct device *dev, size_t size,
-                                        dma_addr_t *dma_addr, gfp_t flag);
+                                        dma_addr_t *dma_addr, gfp_t flag,
+                                        struct dma_attrs *attrs);
 
 static inline bool dma_capable(struct device *dev, dma_addr_t addr, size_t size)
 {
@@ -111,9 +112,11 @@ static inline gfp_t dma_alloc_coherent_gfp_flags(struct device *dev, gfp_t gfp)
        return gfp;
 }
 
+#define dma_alloc_coherent(d,s,h,f)     dma_alloc_attrs(d,s,h,f,NULL)
+
 static inline void *
-dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
-                gfp_t gfp)
+dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
+                gfp_t gfp, struct dma_attrs *attrs)
 {
         struct dma_map_ops *ops = get_dma_ops(dev);
         void *memory;
@@ -129,18 +132,21 @@ dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
         if (!is_device_dma_capable(dev))
                 return NULL;
 
-        if (!ops->alloc_coherent)
+        if (!ops->alloc)
                 return NULL;
 
-        memory = ops->alloc_coherent(dev, size, dma_handle,
-                                     dma_alloc_coherent_gfp_flags(dev, gfp));
+        memory = ops->alloc(dev, size, dma_handle,
+                            dma_alloc_coherent_gfp_flags(dev, gfp), attrs);
         debug_dma_alloc_coherent(dev, size, *dma_handle, memory);
 
         return memory;
 }
 
-static inline void dma_free_coherent(struct device *dev, size_t size,
-                                     void *vaddr, dma_addr_t bus)
+#define dma_free_coherent(d,s,c,h) dma_free_attrs(d,s,c,h,NULL)
+
+static inline void dma_free_attrs(struct device *dev, size_t size,
+                                  void *vaddr, dma_addr_t bus,
+                                  struct dma_attrs *attrs)
 {
         struct dma_map_ops *ops = get_dma_ops(dev);
 
@@ -150,8 +156,8 @@ static inline void dma_free_coherent(struct device *dev, size_t size,
                 return;
 
         debug_dma_free_coherent(dev, size, vaddr, bus);
-        if (ops->free_coherent)
-                ops->free_coherent(dev, size, vaddr, bus);
+        if (ops->free)
+                ops->free(dev, size, vaddr, bus, attrs);
 }
 
 #endif
diff --git a/arch/x86/kernel/amd_gart_64.c b/arch/x86/kernel/amd_gart_64.c
index b1e7c7f7a0af..e66311200cbd 100644
--- a/arch/x86/kernel/amd_gart_64.c
+++ b/arch/x86/kernel/amd_gart_64.c
@@ -477,7 +477,7 @@ error:
 /* allocate and map a coherent mapping */
 static void *
 gart_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_addr,
-                    gfp_t flag)
+                    gfp_t flag, struct dma_attrs *attrs)
 {
         dma_addr_t paddr;
         unsigned long align_mask;
@@ -500,7 +500,8 @@ gart_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_addr,
                 }
                 __free_pages(page, get_order(size));
         } else
-                return dma_generic_alloc_coherent(dev, size, dma_addr, flag);
+                return dma_generic_alloc_coherent(dev, size, dma_addr, flag,
+                                                  attrs);
 
         return NULL;
 }
@@ -508,7 +509,7 @@ gart_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_addr,
 /* free a coherent mapping */
 static void
 gart_free_coherent(struct device *dev, size_t size, void *vaddr,
-                   dma_addr_t dma_addr)
+                   dma_addr_t dma_addr, struct dma_attrs *attrs)
 {
         gart_unmap_page(dev, dma_addr, size, DMA_BIDIRECTIONAL, NULL);
         free_pages((unsigned long)vaddr, get_order(size));
@@ -700,8 +701,8 @@ static struct dma_map_ops gart_dma_ops = {
         .unmap_sg                       = gart_unmap_sg,
         .map_page                       = gart_map_page,
         .unmap_page                     = gart_unmap_page,
-        .alloc_coherent                 = gart_alloc_coherent,
-        .free_coherent                  = gart_free_coherent,
+        .alloc                          = gart_alloc_coherent,
+        .free                           = gart_free_coherent,
         .mapping_error                  = gart_mapping_error,
 };
 
diff --git a/arch/x86/kernel/pci-calgary_64.c b/arch/x86/kernel/pci-calgary_64.c
index 726494b58345..07b587c5a2d2 100644
--- a/arch/x86/kernel/pci-calgary_64.c
+++ b/arch/x86/kernel/pci-calgary_64.c
@@ -431,7 +431,7 @@ static void calgary_unmap_page(struct device *dev, dma_addr_t dma_addr,
 }
 
 static void* calgary_alloc_coherent(struct device *dev, size_t size,
-        dma_addr_t *dma_handle, gfp_t flag)
+        dma_addr_t *dma_handle, gfp_t flag, struct dma_attrs *attrs)
 {
         void *ret = NULL;
         dma_addr_t mapping;
@@ -464,7 +464,8 @@ error:
 }
 
 static void calgary_free_coherent(struct device *dev, size_t size,
-                                  void *vaddr, dma_addr_t dma_handle)
+                                  void *vaddr, dma_addr_t dma_handle,
+                                  struct dma_attrs *attrs)
 {
         unsigned int npages;
         struct iommu_table *tbl = find_iommu_table(dev);
@@ -477,8 +478,8 @@ static void calgary_free_coherent(struct device *dev, size_t size,
 }
 
 static struct dma_map_ops calgary_dma_ops = {
-        .alloc_coherent = calgary_alloc_coherent,
-        .free_coherent = calgary_free_coherent,
+        .alloc = calgary_alloc_coherent,
+        .free = calgary_free_coherent,
         .map_sg = calgary_map_sg,
         .unmap_sg = calgary_unmap_sg,
         .map_page = calgary_map_page,
diff --git a/arch/x86/kernel/pci-dma.c b/arch/x86/kernel/pci-dma.c
index 1c4d769e21ea..75e1cc19e630 100644
--- a/arch/x86/kernel/pci-dma.c
+++ b/arch/x86/kernel/pci-dma.c
@@ -96,7 +96,8 @@ void __init pci_iommu_alloc(void)
         }
 }
 void *dma_generic_alloc_coherent(struct device *dev, size_t size,
-                                 dma_addr_t *dma_addr, gfp_t flag)
+                                 dma_addr_t *dma_addr, gfp_t flag,
+                                 struct dma_attrs *attrs)
 {
         unsigned long dma_mask;
         struct page *page;
diff --git a/arch/x86/kernel/pci-nommu.c b/arch/x86/kernel/pci-nommu.c
index 3af4af810c07..f96050685b46 100644
--- a/arch/x86/kernel/pci-nommu.c
+++ b/arch/x86/kernel/pci-nommu.c
@@ -75,7 +75,7 @@ static int nommu_map_sg(struct device *hwdev, struct scatterlist *sg,
 }
 
 static void nommu_free_coherent(struct device *dev, size_t size, void *vaddr,
-                                dma_addr_t dma_addr)
+                                dma_addr_t dma_addr, struct dma_attrs *attrs)
 {
         free_pages((unsigned long)vaddr, get_order(size));
 }
@@ -96,8 +96,8 @@ static void nommu_sync_sg_for_device(struct device *dev,
 }
 
 struct dma_map_ops nommu_dma_ops = {
-        .alloc_coherent         = dma_generic_alloc_coherent,
-        .free_coherent          = nommu_free_coherent,
+        .alloc                  = dma_generic_alloc_coherent,
+        .free                   = nommu_free_coherent,
         .map_sg                 = nommu_map_sg,
         .map_page               = nommu_map_page,
         .sync_single_for_device = nommu_sync_single_for_device,
diff --git a/arch/x86/kernel/pci-swiotlb.c b/arch/x86/kernel/pci-swiotlb.c
index 8f972cbddef0..6c483ba98b9c 100644
--- a/arch/x86/kernel/pci-swiotlb.c
+++ b/arch/x86/kernel/pci-swiotlb.c
@@ -15,21 +15,30 @@
 int swiotlb __read_mostly;
 
 static void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
-                                        dma_addr_t *dma_handle, gfp_t flags)
+                                        dma_addr_t *dma_handle, gfp_t flags,
+                                        struct dma_attrs *attrs)
 {
         void *vaddr;
 
-        vaddr = dma_generic_alloc_coherent(hwdev, size, dma_handle, flags);
+        vaddr = dma_generic_alloc_coherent(hwdev, size, dma_handle, flags,
+                                           attrs);
         if (vaddr)
                 return vaddr;
 
         return swiotlb_alloc_coherent(hwdev, size, dma_handle, flags);
 }
 
+static void x86_swiotlb_free_coherent(struct device *dev, size_t size,
+                                      void *vaddr, dma_addr_t dma_addr,
+                                      struct dma_attrs *attrs)
+{
+        swiotlb_free_coherent(dev, size, vaddr, dma_addr);
+}
+
 static struct dma_map_ops swiotlb_dma_ops = {
         .mapping_error = swiotlb_dma_mapping_error,
-        .alloc_coherent = x86_swiotlb_alloc_coherent,
-        .free_coherent = swiotlb_free_coherent,
+        .alloc = x86_swiotlb_alloc_coherent,
+        .free = x86_swiotlb_free_coherent,
         .sync_single_for_cpu = swiotlb_sync_single_for_cpu,
         .sync_single_for_device = swiotlb_sync_single_for_device,
         .sync_sg_for_cpu = swiotlb_sync_sg_for_cpu,
diff --git a/arch/x86/xen/pci-swiotlb-xen.c b/arch/x86/xen/pci-swiotlb-xen.c
index b480d4207a4c..967633ad98c4 100644
--- a/arch/x86/xen/pci-swiotlb-xen.c
+++ b/arch/x86/xen/pci-swiotlb-xen.c
@@ -12,8 +12,8 @@ int xen_swiotlb __read_mostly;
 
 static struct dma_map_ops xen_swiotlb_dma_ops = {
         .mapping_error = xen_swiotlb_dma_mapping_error,
-        .alloc_coherent = xen_swiotlb_alloc_coherent,
-        .free_coherent = xen_swiotlb_free_coherent,
+        .alloc = xen_swiotlb_alloc_coherent,
+        .free = xen_swiotlb_free_coherent,
         .sync_single_for_cpu = xen_swiotlb_sync_single_for_cpu,
         .sync_single_for_device = xen_swiotlb_sync_single_for_device,
         .sync_sg_for_cpu = xen_swiotlb_sync_sg_for_cpu,