Skip to contentSkip to conversation

x86: enable DMA CMA with swiotlb

PATCH In review Akinobu Mita 5 participants 11 messages Nov 19, 2013 – Nov 23, 2013

Subsystems (4)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 x86: enable DMA CMA with swiotlb

The DMA Contiguous Memory Allocator support on x86 is disabled when swiotlb config option is enabled. So DMA CMA is always disabled on x86_64 because swiotlb is always enabled. This attempts to support for DMA CMA with enabling swiotlb config option.

The contiguous memory allocator on x86 is integrated in the function dma_generic_alloc_coherent() which is .alloc callback in nommu_dma_ops for dma_alloc_coherent().

x86_swiotlb_alloc_coherent() which is .alloc callback in swiotlb_dma_ops tries to allocate with dma_generic_alloc_coherent() firstly and then swiotlb_alloc_coherent() is called as a fallback.

The main part of supporting DMA CMA with swiotlb is that changing x86_swiotlb_free_coherent() which is .free callback in swiotlb_dma_ops for dma_free_coherent() so that it can distinguish memory allocated by dma_generic_alloc_coherent() from one allocated by swiotlb_alloc_coherent() and release it with dma_generic_free_coherent() which can handle contiguous memory. This change requires making is_swiotlb_buffer() global function.

This also needs to change .free callback in the dma_map_ops for amd_gart and sta2x11, because these dma_ops are also using dma_generic_alloc_coherent().

Cc Marek Szyprowski <[email protected]>
Cc Konrad Rzeszutek Wilk <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Ingo Molnar <[email protected]>
Cc "H. Peter Anvin" <[email protected]>
---
 arch/x86/Kconfig               | 2 +-
 arch/x86/include/asm/swiotlb.h | 7 +++++++
 arch/x86/kernel/amd_gart_64.c  | 2 +-
 arch/x86/kernel/pci-swiotlb.c  | 9 ++++++---
 arch/x86/pci/sta2x11-fixup.c   | 6 ++----
 include/linux/swiotlb.h        | 2 ++
 lib/swiotlb.c                  | 2 +-
 7 files changed, 20 insertions(+), 10 deletions(-)
arch/x86/Kconfig +1 -1
index e903c71..b15df8b 100644
@@ -39,7 +39,7 @@ config X86
 	select ARCH_WANT_OPTIONAL_GPIOLIB
 	select ARCH_WANT_FRAME_POINTERS
 	select HAVE_DMA_ATTRS
-	select HAVE_DMA_CONTIGUOUS if !SWIOTLB
+	select HAVE_DMA_CONTIGUOUS
 	select HAVE_KRETPROBES
 	select HAVE_OPTPROBES
 	select HAVE_KPROBES_ON_FTRACE
arch/x86/include/asm/swiotlb.h +7 -0
index 977f176..ab05d73 100644
@@ -29,4 +29,11 @@ static inline void pci_swiotlb_late_init(void)
 
 static inline void dma_mark_clean(void *addr, size_t size) {}
 
+extern void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
+					dma_addr_t *dma_handle, gfp_t flags,
+					struct dma_attrs *attrs);
+extern void x86_swiotlb_free_coherent(struct device *dev, size_t size,
+					void *vaddr, dma_addr_t dma_addr,
+					struct dma_attrs *attrs);
+
 #endif /* _ASM_X86_SWIOTLB_H */
arch/x86/kernel/amd_gart_64.c +1 -1
index b574b29..8e3842f 100644
@@ -512,7 +512,7 @@ gart_free_coherent(struct device *dev, size_t size, void *vaddr,
 		   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));
+	dma_generic_free_coherent(dev, size, vaddr, dma_addr, attrs);
 }
 
 static int gart_mapping_error(struct device *dev, dma_addr_t dma_addr)
arch/x86/kernel/pci-swiotlb.c +6 -3
index 6c483ba..77dd0ad 100644
@@ -14,7 +14,7 @@
 #include <asm/iommu_table.h>
 int swiotlb __read_mostly;
 
-static void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
+void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
 					dma_addr_t *dma_handle, gfp_t flags,
 					struct dma_attrs *attrs)
 {
@@ -28,11 +28,14 @@ static void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
 	return swiotlb_alloc_coherent(hwdev, size, dma_handle, flags);
 }
 
-static void x86_swiotlb_free_coherent(struct device *dev, size_t size,
+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);
+	if (is_swiotlb_buffer(dma_to_phys(dev, dma_addr)))
+		swiotlb_free_coherent(dev, size, vaddr, dma_addr);
+	else
+		dma_generic_free_coherent(dev, size, vaddr, dma_addr, attrs);
 }
 
 static struct dma_map_ops swiotlb_dma_ops = {
arch/x86/pci/sta2x11-fixup.c +2 -4
index 9d8a509..5ceda85 100644
@@ -173,9 +173,7 @@ static void *sta2x11_swiotlb_alloc_coherent(struct device *dev,
 {
 	void *vaddr;
 
-	vaddr = dma_generic_alloc_coherent(dev, size, dma_handle, flags, attrs);
-	if (!vaddr)
-		vaddr = swiotlb_alloc_coherent(dev, size, dma_handle, flags);
+	vaddr = x86_swiotlb_alloc_coherent(dev, size, dma_handle, flags, attrs);
 	*dma_handle = p2a(*dma_handle, to_pci_dev(dev));
 	return vaddr;
 }
@@ -183,7 +181,7 @@ static void *sta2x11_swiotlb_alloc_coherent(struct device *dev,
 /* We have our own dma_ops: the same as swiotlb but from alloc (above) */
 static struct dma_map_ops sta2x11_dma_ops = {
 	.alloc = sta2x11_swiotlb_alloc_coherent,
-	.free = swiotlb_free_coherent,
+	.free = x86_swiotlb_free_coherent,
 	.map_page = swiotlb_map_page,
 	.unmap_page = swiotlb_unmap_page,
 	.map_sg = swiotlb_map_sg_attrs,
include/linux/swiotlb.h +2 -0
index a5ffd32..e7a018e 100644
@@ -116,4 +116,6 @@ static inline void swiotlb_free(void) { }
 #endif
 
 extern void swiotlb_print_info(void);
+extern int is_swiotlb_buffer(phys_addr_t paddr);
+
 #endif /* __LINUX_SWIOTLB_H */
lib/swiotlb.c +1 -1
index fe978e0..6e4a798 100644
@@ -369,7 +369,7 @@ void __init swiotlb_free(void)
 	io_tlb_nslabs = 0;
 }
 
-static int is_swiotlb_buffer(phys_addr_t paddr)
+int is_swiotlb_buffer(phys_addr_t paddr)
 {
 	return paddr >= io_tlb_start && paddr < io_tlb_end;
 }
Signature · 1 line
1.8.3.2
#1 lore raw
Quoted 31 lines · Akinobu Mita

The DMA Contiguous Memory Allocator support on x86 is disabled when swiotlb config option is enabled. So DMA CMA is always disabled on x86_64 because swiotlb is always enabled. This attempts to support for DMA CMA with enabling swiotlb config option.

The contiguous memory allocator on x86 is integrated in the function dma_generic_alloc_coherent() which is .alloc callback in nommu_dma_ops for dma_alloc_coherent().

x86_swiotlb_alloc_coherent() which is .alloc callback in swiotlb_dma_ops tries to allocate with dma_generic_alloc_coherent() firstly and then swiotlb_alloc_coherent() is called as a fallback.

The main part of supporting DMA CMA with swiotlb is that changing x86_swiotlb_free_coherent() which is .free callback in swiotlb_dma_ops for dma_free_coherent() so that it can distinguish memory allocated by dma_generic_alloc_coherent() from one allocated by swiotlb_alloc_coherent() and release it with dma_generic_free_coherent() which can handle contiguous memory. This change requires making is_swiotlb_buffer() global function.

This also needs to change .free callback in the dma_map_ops for amd_gart and sta2x11, because these dma_ops are also using dma_generic_alloc_coherent().

Cc Marek Szyprowski <[email protected]>
Cc Konrad Rzeszutek Wilk <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Ingo Molnar <[email protected]>
Cc "H. Peter Anvin" <[email protected]>
Quoted 8 lines
---
 arch/x86/Kconfig               | 2 +-
 arch/x86/include/asm/swiotlb.h | 7 +++++++
 arch/x86/kernel/amd_gart_64.c  | 2 +-
 arch/x86/kernel/pci-swiotlb.c  | 9 ++++++---
 arch/x86/pci/sta2x11-fixup.c   | 6 ++----
 include/linux/swiotlb.h        | 2 ++
 lib/swiotlb.c                  | 2 +-

Looks OK, but before this goes anywhere I need to run regression tests on IA64 and the other users of SWIOTLB.

Quoted 125 lines
 7 files changed, 20 insertions(+), 10 deletions(-)
arch/x86/Kconfig +1 -1
index e903c71..b15df8b 100644
@@ -39,7 +39,7 @@ config X86
 	select ARCH_WANT_OPTIONAL_GPIOLIB
 	select ARCH_WANT_FRAME_POINTERS
 	select HAVE_DMA_ATTRS
-	select HAVE_DMA_CONTIGUOUS if !SWIOTLB
+	select HAVE_DMA_CONTIGUOUS
 	select HAVE_KRETPROBES
 	select HAVE_OPTPROBES
 	select HAVE_KPROBES_ON_FTRACE
arch/x86/include/asm/swiotlb.h +7 -0
index 977f176..ab05d73 100644
@@ -29,4 +29,11 @@ static inline void pci_swiotlb_late_init(void)
 
 static inline void dma_mark_clean(void *addr, size_t size) {}
 
+extern void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
+					dma_addr_t *dma_handle, gfp_t flags,
+					struct dma_attrs *attrs);
+extern void x86_swiotlb_free_coherent(struct device *dev, size_t size,
+					void *vaddr, dma_addr_t dma_addr,
+					struct dma_attrs *attrs);
+
 #endif /* _ASM_X86_SWIOTLB_H */
arch/x86/kernel/amd_gart_64.c +1 -1
index b574b29..8e3842f 100644
@@ -512,7 +512,7 @@ gart_free_coherent(struct device *dev, size_t size, void *vaddr,
 		   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));
+	dma_generic_free_coherent(dev, size, vaddr, dma_addr, attrs);
 }
 
 static int gart_mapping_error(struct device *dev, dma_addr_t dma_addr)
arch/x86/kernel/pci-swiotlb.c +6 -3
index 6c483ba..77dd0ad 100644
@@ -14,7 +14,7 @@
 #include <asm/iommu_table.h>
 int swiotlb __read_mostly;
 
-static void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
+void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
 					dma_addr_t *dma_handle, gfp_t flags,
 					struct dma_attrs *attrs)
 {
@@ -28,11 +28,14 @@ static void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
 	return swiotlb_alloc_coherent(hwdev, size, dma_handle, flags);
 }
 
-static void x86_swiotlb_free_coherent(struct device *dev, size_t size,
+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);
+	if (is_swiotlb_buffer(dma_to_phys(dev, dma_addr)))
+		swiotlb_free_coherent(dev, size, vaddr, dma_addr);
+	else
+		dma_generic_free_coherent(dev, size, vaddr, dma_addr, attrs);
 }
 
 static struct dma_map_ops swiotlb_dma_ops = {
arch/x86/pci/sta2x11-fixup.c +2 -4
index 9d8a509..5ceda85 100644
@@ -173,9 +173,7 @@ static void *sta2x11_swiotlb_alloc_coherent(struct device *dev,
 {
 	void *vaddr;
 
-	vaddr = dma_generic_alloc_coherent(dev, size, dma_handle, flags, attrs);
-	if (!vaddr)
-		vaddr = swiotlb_alloc_coherent(dev, size, dma_handle, flags);
+	vaddr = x86_swiotlb_alloc_coherent(dev, size, dma_handle, flags, attrs);
 	*dma_handle = p2a(*dma_handle, to_pci_dev(dev));
 	return vaddr;
 }
@@ -183,7 +181,7 @@ static void *sta2x11_swiotlb_alloc_coherent(struct device *dev,
 /* We have our own dma_ops: the same as swiotlb but from alloc (above) */
 static struct dma_map_ops sta2x11_dma_ops = {
 	.alloc = sta2x11_swiotlb_alloc_coherent,
-	.free = swiotlb_free_coherent,
+	.free = x86_swiotlb_free_coherent,
 	.map_page = swiotlb_map_page,
 	.unmap_page = swiotlb_unmap_page,
 	.map_sg = swiotlb_map_sg_attrs,
include/linux/swiotlb.h +2 -0
index a5ffd32..e7a018e 100644
@@ -116,4 +116,6 @@ static inline void swiotlb_free(void) { }
 #endif
 
 extern void swiotlb_print_info(void);
+extern int is_swiotlb_buffer(phys_addr_t paddr);
+
 #endif /* __LINUX_SWIOTLB_H */
lib/swiotlb.c +1 -1
index fe978e0..6e4a798 100644
@@ -369,7 +369,7 @@ void __init swiotlb_free(void)
 	io_tlb_nslabs = 0;
 }
 
-static int is_swiotlb_buffer(phys_addr_t paddr)
+int is_swiotlb_buffer(phys_addr_t paddr)
 {
 	return paddr >= io_tlb_start && paddr < io_tlb_end;
 }
Signature · 1 line
1.8.3.2
#2 lore raw

2013/11/20 Konrad Rzeszutek Wilk <[email protected]>:

Quoted 41 lines · Akinobu Mita
Quoted 31 lines

The DMA Contiguous Memory Allocator support on x86 is disabled when swiotlb config option is enabled. So DMA CMA is always disabled on x86_64 because swiotlb is always enabled. This attempts to support for DMA CMA with enabling swiotlb config option.

The contiguous memory allocator on x86 is integrated in the function dma_generic_alloc_coherent() which is .alloc callback in nommu_dma_ops for dma_alloc_coherent().

x86_swiotlb_alloc_coherent() which is .alloc callback in swiotlb_dma_ops tries to allocate with dma_generic_alloc_coherent() firstly and then swiotlb_alloc_coherent() is called as a fallback.

The main part of supporting DMA CMA with swiotlb is that changing x86_swiotlb_free_coherent() which is .free callback in swiotlb_dma_ops for dma_free_coherent() so that it can distinguish memory allocated by dma_generic_alloc_coherent() from one allocated by swiotlb_alloc_coherent() and release it with dma_generic_free_coherent() which can handle contiguous memory. This change requires making is_swiotlb_buffer() global function.

This also needs to change .free callback in the dma_map_ops for amd_gart and sta2x11, because these dma_ops are also using dma_generic_alloc_coherent().

Cc Marek Szyprowski <[email protected]>
Cc Konrad Rzeszutek Wilk <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Ingo Molnar <[email protected]>
Cc "H. Peter Anvin" <[email protected]>
Quoted 8 lines
---
 arch/x86/Kconfig               | 2 +-
 arch/x86/include/asm/swiotlb.h | 7 +++++++
 arch/x86/kernel/amd_gart_64.c  | 2 +-
 arch/x86/kernel/pci-swiotlb.c  | 9 ++++++---
 arch/x86/pci/sta2x11-fixup.c   | 6 ++----
 include/linux/swiotlb.h        | 2 ++
 lib/swiotlb.c                  | 2 +-
Quoted 2 lines

Looks OK, but before this goes anywhere I need to run regression tests on IA64 and the other users of SWIOTLB.

Thanks a lot for your review.

#3 lore raw
In reply to Akinobu Mita
Quoted 4 lines · Akinobu Mita

The DMA Contiguous Memory Allocator support on x86 is disabled when swiotlb config option is enabled. So DMA CMA is always disabled on x86_64 because swiotlb is always enabled. This attempts to support for DMA CMA with enabling swiotlb config option.

What is the use case?

-hpa

#4 lore raw

2013/11/21 H. Peter Anvin <[email protected]>:

Quoted 7 lines · Akinobu Mita
Quoted 4 lines

The DMA Contiguous Memory Allocator support on x86 is disabled when swiotlb config option is enabled. So DMA CMA is always disabled on x86_64 because swiotlb is always enabled. This attempts to support for DMA CMA with enabling swiotlb config option.

What is the use case?

I want to use DMA CMA for the feature that requires a single huge chunk (about 64MB) of host memory. Please refer 3 of 24 in:
http://www.jedec.org/sites/default/files/T_Fujisawa_MF_2013.pdf

#5 lore raw
Quoted 3 lines · Akinobu Mita

I want to use DMA CMA for the feature that requires a single huge chunk (about 64MB) of host memory.

That is tautological. "I want to use the Contiguous Memory Allocator to allocate contiguous memory."

Quoted 2 lines

Please refer 3 of 24 in:
http://www.jedec.org/sites/default/files/T_Fujisawa_MF_2013.pdf

But yes, it makes sense that a device using host memory would not be able to leverage swiotlb, because the software simply has no clue what the DMA transactions are. In that sense it is fundamentally different from a real IOTLB.

-hpa

#6 lore raw

2013/11/22 H. Peter Anvin <[email protected]>:

Quoted 8 lines · Akinobu Mita
Quoted 3 lines

I want to use DMA CMA for the feature that requires a single huge chunk (about 64MB) of host memory.

That is tautological. "I want to use the Contiguous Memory Allocator to allocate contiguous memory."

Quoted 7 lines
Quoted 2 lines

Please refer 3 of 24 in:
http://www.jedec.org/sites/default/files/T_Fujisawa_MF_2013.pdf

But yes, it makes sense that a device using host memory would not be able to leverage swiotlb, because the software simply has no clue what the DMA transactions are. In that sense it is fundamentally different from a real IOTLB.

I'm currently working for integrating DMA CMA with intel-iommu which I can test. Regardless of which dma ops is actually used, I would like to allocate large contiguous memory with dma_alloc_coherent() and tell the base address to the device.

We can use mem= or crashkernel= to reserve host memory, but it is complicated and unables to work with real IOMMU.

#7 lore raw
Quoted 9 lines · Akinobu Mita

I'm currently working for integrating DMA CMA with intel-iommu which I can test. Regardless of which dma ops is actually used, I would like to allocate large contiguous memory with dma_alloc_coherent() and tell the base address to the device.

We can use mem= or crashkernel= to reserve host memory, but it is complicated and unables to work with real IOMMU.

If you have a real iotlb, why would you need contiguous memory?

-hpa

#8 lore raw
Quoted 2 lines · H. Peter Anvin

If you have a real iotlb, why would you need contiguous memory?

iotlb is often slow.

Another use case is allocating 1GB pages at runtime.

-Andi

Signature · 1 line
[email protected] -- Speaking for myself only
#9 lore raw
In reply to H. Peter Anvin

2013/11/23 H. Peter Anvin <[email protected]>:

Quoted 7 lines · Akinobu Mita
Quoted 6 lines

I'm currently working for integrating DMA CMA with intel-iommu which I can test. Regardless of which dma ops is actually used, I would like to allocate large contiguous memory with dma_alloc_coherent() and tell the base address to the device.

Quoted 5 lines
Quoted 3 lines

We can use mem= or crashkernel= to reserve host memory, but it is complicated and unables to work with real IOMMU.

If you have a real iotlb, why would you need contiguous memory?

Because allocating large memory by dma_alloc_coherent() with intel-iommu fails. intel_alloc_coherent() allocates memory by alloc_pages() and then maps it by __intel_map_single().

What I'm trying change wit inte-iommu is adding the same scheme done by dma_generic_alloc_coherent(), i.e. trying to allocate memory by dma_alloc_from_contiguous() and alloc_pages() is used as a fallback.

maintainer Acked-by on v1 1/1
#10 lore raw
In reply to Akinobu Mita

Hello,

Quoted 24 lines · Akinobu Mita

The DMA Contiguous Memory Allocator support on x86 is disabled when swiotlb config option is enabled. So DMA CMA is always disabled on x86_64 because swiotlb is always enabled. This attempts to support for DMA CMA with enabling swiotlb config option.

The contiguous memory allocator on x86 is integrated in the function dma_generic_alloc_coherent() which is .alloc callback in nommu_dma_ops for dma_alloc_coherent().

x86_swiotlb_alloc_coherent() which is .alloc callback in swiotlb_dma_ops tries to allocate with dma_generic_alloc_coherent() firstly and then swiotlb_alloc_coherent() is called as a fallback.

The main part of supporting DMA CMA with swiotlb is that changing x86_swiotlb_free_coherent() which is .free callback in swiotlb_dma_ops for dma_free_coherent() so that it can distinguish memory allocated by dma_generic_alloc_coherent() from one allocated by swiotlb_alloc_coherent() and release it with dma_generic_free_coherent() which can handle contiguous memory. This change requires making is_swiotlb_buffer() global function.

This also needs to change .free callback in the dma_map_ops for amd_gart and sta2x11, because these dma_ops are also using dma_generic_alloc_coherent().

Quoted 7 lines
Cc Marek Szyprowski <[email protected]>
Cc Konrad Rzeszutek Wilk <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Ingo Molnar <[email protected]>
Cc "H. Peter Anvin" <[email protected]>
Quoted 122 lines
---
  arch/x86/Kconfig               | 2 +-
  arch/x86/include/asm/swiotlb.h | 7 +++++++
  arch/x86/kernel/amd_gart_64.c  | 2 +-
  arch/x86/kernel/pci-swiotlb.c  | 9 ++++++---
  arch/x86/pci/sta2x11-fixup.c   | 6 ++----
  include/linux/swiotlb.h        | 2 ++
  lib/swiotlb.c                  | 2 +-
  7 files changed, 20 insertions(+), 10 deletions(-)
arch/x86/Kconfig +1 -1
index e903c71..b15df8b 100644
@@ -39,7 +39,7 @@ config X86
  	select ARCH_WANT_OPTIONAL_GPIOLIB
  	select ARCH_WANT_FRAME_POINTERS
  	select HAVE_DMA_ATTRS
-	select HAVE_DMA_CONTIGUOUS if !SWIOTLB
+	select HAVE_DMA_CONTIGUOUS
  	select HAVE_KRETPROBES
  	select HAVE_OPTPROBES
  	select HAVE_KPROBES_ON_FTRACE
arch/x86/include/asm/swiotlb.h +7 -0
index 977f176..ab05d73 100644
@@ -29,4 +29,11 @@ static inline void pci_swiotlb_late_init(void)
 
  static inline void dma_mark_clean(void *addr, size_t size) {}
 
+extern void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
+					dma_addr_t *dma_handle, gfp_t flags,
+					struct dma_attrs *attrs);
+extern void x86_swiotlb_free_coherent(struct device *dev, size_t size,
+					void *vaddr, dma_addr_t dma_addr,
+					struct dma_attrs *attrs);
+
  #endif /* _ASM_X86_SWIOTLB_H */
arch/x86/kernel/amd_gart_64.c +1 -1
index b574b29..8e3842f 100644
@@ -512,7 +512,7 @@ gart_free_coherent(struct device *dev, size_t size, void *vaddr,
  		   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));
+	dma_generic_free_coherent(dev, size, vaddr, dma_addr, attrs);
  }
 
  static int gart_mapping_error(struct device *dev, dma_addr_t dma_addr)
arch/x86/kernel/pci-swiotlb.c +6 -3
index 6c483ba..77dd0ad 100644
@@ -14,7 +14,7 @@
  #include <asm/iommu_table.h>
  int swiotlb __read_mostly;
 
-static void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
+void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
  					dma_addr_t *dma_handle, gfp_t flags,
  					struct dma_attrs *attrs)
  {
@@ -28,11 +28,14 @@ static void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
  	return swiotlb_alloc_coherent(hwdev, size, dma_handle, flags);
  }
 
-static void x86_swiotlb_free_coherent(struct device *dev, size_t size,
+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);
+	if (is_swiotlb_buffer(dma_to_phys(dev, dma_addr)))
+		swiotlb_free_coherent(dev, size, vaddr, dma_addr);
+	else
+		dma_generic_free_coherent(dev, size, vaddr, dma_addr, attrs);
  }
 
  static struct dma_map_ops swiotlb_dma_ops = {
arch/x86/pci/sta2x11-fixup.c +2 -4
index 9d8a509..5ceda85 100644
@@ -173,9 +173,7 @@ static void *sta2x11_swiotlb_alloc_coherent(struct device *dev,
  {
  	void *vaddr;
 
-	vaddr = dma_generic_alloc_coherent(dev, size, dma_handle, flags, attrs);
-	if (!vaddr)
-		vaddr = swiotlb_alloc_coherent(dev, size, dma_handle, flags);
+	vaddr = x86_swiotlb_alloc_coherent(dev, size, dma_handle, flags, attrs);
  	*dma_handle = p2a(*dma_handle, to_pci_dev(dev));
  	return vaddr;
  }
@@ -183,7 +181,7 @@ static void *sta2x11_swiotlb_alloc_coherent(struct device *dev,
  /* We have our own dma_ops: the same as swiotlb but from alloc (above) */
  static struct dma_map_ops sta2x11_dma_ops = {
  	.alloc = sta2x11_swiotlb_alloc_coherent,
-	.free = swiotlb_free_coherent,
+	.free = x86_swiotlb_free_coherent,
  	.map_page = swiotlb_map_page,
  	.unmap_page = swiotlb_unmap_page,
  	.map_sg = swiotlb_map_sg_attrs,
include/linux/swiotlb.h +2 -0
index a5ffd32..e7a018e 100644
@@ -116,4 +116,6 @@ static inline void swiotlb_free(void) { }
  #endif
 
  extern void swiotlb_print_info(void);
+extern int is_swiotlb_buffer(phys_addr_t paddr);
+
  #endif /* __LINUX_SWIOTLB_H */
lib/swiotlb.c +0 -0
index fe978e0..6e4a798 100644

lib/swiotlb.c void __init swiotlb_free(void) · line 375

Quoted 8 lines
lib/swiotlb.c +1 -1
@@ -369,7 +369,7 @@ void __init swiotlb_free(void)
  	io_tlb_nslabs = 0;
  }
 
-static int is_swiotlb_buffer(phys_addr_t paddr)
+int is_swiotlb_buffer(phys_addr_t paddr)
  {
  	return paddr >= io_tlb_start && paddr < io_tlb_end;
  }

Best regards

Signature · 2 lines
Marek Szyprowski
Samsung R&D Institute Poland