Commit 6894258e authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Linus Torvalds
Browse files

dma-mapping: consolidate dma_{alloc,free}_{attrs,coherent} 



Since 2009 we have a nice asm-generic header implementing lots of DMA API
functions for architectures using struct dma_map_ops, but unfortunately
it's still missing a lot of APIs that all architectures still have to
duplicate.

This series consolidates the remaining functions, although we still need
arch opt outs for two of them as a few architectures have very
non-standard implementations.

This patch (of 5):

The coherent DMA allocator works the same over all architectures supporting
dma_map operations.

This patch consolidates them and converges the minor differences:

 - the debug_dma helpers are now called from all architectures, including
   those that were previously missing them
 - dma_alloc_from_coherent and dma_release_from_coherent are now always
   called from the generic alloc/free routines instead of the ops
   dma-mapping-common.h always includes dma-coherent.h to get the defintions
   for them, or the stubs if the architecture doesn't support this feature
 - checks for ->alloc / ->free presence are removed.  There is only one
   magic instead of dma_map_ops without them (mic_dma_ops) and that one
   is x86 only anyway.

Besides that only x86 needs special treatment to replace a default devices
if none is passed and tweak the gfp_flags.  An optional arch hook is provided
for that.

[linux@roeck-us.net: fix build]
[jcmvbkbc@gmail.com: fix xtensa]
Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Russell King <linux@arm.linux.org.uk>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Yoshinori Sato <ysato@users.sourceforge.jp>
Cc: Michal Simek <monstr@monstr.eu>
Cc: Jonas Bonn <jonas@southpole.se>
Cc: Chris Metcalf <cmetcalf@ezchip.com>
Cc: Guan Xuetao <gxt@mprc.pku.edu.cn>
Cc: Ralf Baechle <ralf@linux-mips.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Andy Shevchenko <andy.shevchenko@gmail.com>
Signed-off-by: default avatarGuenter Roeck <linux@roeck-us.net>
Signed-off-by: default avatarMax Filippov <jcmvbkbc@gmail.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent fb6dd5fa

arch/alpha/include/asm/dma-mapping.h

+0 −18
Original line number Diff line number Diff line
@@ -12,24 +12,6 @@ static inline struct dma_map_ops *get_dma_ops(struct device *dev) 


#include <asm-generic/dma-mapping-common.h>



#define dma_alloc_coherent(d,s,h,f)	dma_alloc_attrs(d,s,h,f,NULL)



static inline void *dma_alloc_attrs(struct device *dev, size_t size,

				    dma_addr_t *dma_handle, gfp_t gfp,

				    struct dma_attrs *attrs)

{

	return get_dma_ops(dev)->alloc(dev, size, dma_handle, gfp, attrs);

}



#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 dma_handle,

				  struct dma_attrs *attrs)

{

	get_dma_ops(dev)->free(dev, size, vaddr, dma_handle, attrs);

}



static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)

{

	return get_dma_ops(dev)->mapping_error(dev, dma_addr);

arch/arm/include/asm/dma-mapping.h

+0 −29
Original line number Diff line number Diff line
@@ -8,7 +8,6 @@ 
#include <linux/dma-attrs.h>

#include <linux/dma-debug.h>



#include <asm-generic/dma-coherent.h>

#include <asm/memory.h>



#include <xen/xen.h>
@@ -209,21 +208,6 @@ extern int arm_dma_set_mask(struct device *dev, u64 dma_mask); 
extern void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,

			   gfp_t gfp, struct dma_attrs *attrs);



#define dma_alloc_coherent(d, s, h, f) dma_alloc_attrs(d, s, h, f, NULL)



static inline void *dma_alloc_attrs(struct device *dev, size_t size,

				       dma_addr_t *dma_handle, gfp_t flag,

				       struct dma_attrs *attrs)

{

	struct dma_map_ops *ops = get_dma_ops(dev);

	void *cpu_addr;

	BUG_ON(!ops);



	cpu_addr = ops->alloc(dev, size, dma_handle, flag, attrs);

	debug_dma_alloc_coherent(dev, size, *dma_handle, cpu_addr);

	return cpu_addr;

}



/**

 * arm_dma_free - free memory allocated by arm_dma_alloc

 * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
@@ -241,19 +225,6 @@ static inline void *dma_alloc_attrs(struct device *dev, size_t size, 
extern void arm_dma_free(struct device *dev, size_t size, void *cpu_addr,

			 dma_addr_t handle, struct dma_attrs *attrs);



#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 *cpu_addr, dma_addr_t dma_handle,

				     struct dma_attrs *attrs)

{

	struct dma_map_ops *ops = get_dma_ops(dev);

	BUG_ON(!ops);



	debug_dma_free_coherent(dev, size, cpu_addr, dma_handle);

	ops->free(dev, size, cpu_addr, dma_handle, attrs);

}



/**

 * arm_dma_mmap - map a coherent DMA allocation into user space

 * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices

arch/arm/mm/dma-mapping.c

+0 −12
Original line number Diff line number Diff line
@@ -676,10 +676,6 @@ void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, 
		    gfp_t gfp, struct dma_attrs *attrs)

{

	pgprot_t prot = __get_dma_pgprot(attrs, PAGE_KERNEL);

	void *memory;



	if (dma_alloc_from_coherent(dev, size, handle, &memory))

		return memory;



	return __dma_alloc(dev, size, handle, gfp, prot, false,

			   attrs, __builtin_return_address(0));
@@ -688,11 +684,6 @@ void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, 
static void *arm_coherent_dma_alloc(struct device *dev, size_t size,

	dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs)

{

	void *memory;



	if (dma_alloc_from_coherent(dev, size, handle, &memory))

		return memory;



	return __dma_alloc(dev, size, handle, gfp, PAGE_KERNEL, true,

			   attrs, __builtin_return_address(0));

}
@@ -752,9 +743,6 @@ static void __arm_dma_free(struct device *dev, size_t size, void *cpu_addr, 
	struct page *page = pfn_to_page(dma_to_pfn(dev, handle));

	bool want_vaddr = !dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, attrs);



	if (dma_release_from_coherent(dev, get_order(size), cpu_addr))

		return;



	size = PAGE_ALIGN(size);



	if (nommu()) {

arch/arm64/include/asm/dma-mapping.h

+0 −33
Original line number Diff line number Diff line
@@ -22,8 +22,6 @@ 
#include <linux/types.h>

#include <linux/vmalloc.h>



#include <asm-generic/dma-coherent.h>



#include <xen/xen.h>

#include <asm/xen/hypervisor.h>
@@ -120,37 +118,6 @@ static inline void dma_mark_clean(void *addr, size_t size) 
{

}



#define dma_alloc_coherent(d, s, h, f)	dma_alloc_attrs(d, s, h, f, NULL)

#define dma_free_coherent(d, s, h, f)	dma_free_attrs(d, s, h, f, NULL)



static inline void *dma_alloc_attrs(struct device *dev, size_t size,

				    dma_addr_t *dma_handle, gfp_t flags,

				    struct dma_attrs *attrs)

{

	struct dma_map_ops *ops = get_dma_ops(dev);

	void *vaddr;



	if (dma_alloc_from_coherent(dev, size, dma_handle, &vaddr))

		return vaddr;



	vaddr = ops->alloc(dev, size, dma_handle, flags, attrs);

	debug_dma_alloc_coherent(dev, size, *dma_handle, vaddr);

	return vaddr;

}



static inline void dma_free_attrs(struct device *dev, size_t size,

				  void *vaddr, dma_addr_t dev_addr,

				  struct dma_attrs *attrs)

{

	struct dma_map_ops *ops = get_dma_ops(dev);



	if (dma_release_from_coherent(dev, get_order(size), vaddr))

		return;



	debug_dma_free_coherent(dev, size, vaddr, dev_addr);

	ops->free(dev, size, vaddr, dev_addr, attrs);

}



/*

 * There is no dma_cache_sync() implementation, so just return NULL here.

 */

arch/h8300/include/asm/dma-mapping.h

+0 −26
Original line number Diff line number Diff line 
#ifndef _H8300_DMA_MAPPING_H

#define _H8300_DMA_MAPPING_H



#include <asm-generic/dma-coherent.h>



extern struct dma_map_ops h8300_dma_map_ops;



static inline struct dma_map_ops *get_dma_ops(struct device *dev)
@@ -25,30 +23,6 @@ static inline int dma_set_mask(struct device *dev, u64 mask) 
#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)

#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)



#define dma_alloc_coherent(d, s, h, f) dma_alloc_attrs(d, s, h, f, NULL)



static inline void *dma_alloc_attrs(struct device *dev, size_t size,

				    dma_addr_t *dma_handle, gfp_t flag,

				    struct dma_attrs *attrs)

{

	struct dma_map_ops *ops = get_dma_ops(dev);

	void *memory;



	memory = ops->alloc(dev, size, dma_handle, flag, attrs);

	return memory;

}



#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 *cpu_addr, dma_addr_t dma_handle,

				  struct dma_attrs *attrs)

{

	struct dma_map_ops *ops = get_dma_ops(dev);



	ops->free(dev, size, cpu_addr, dma_handle, attrs);

}



static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)

{

	return 0;

CRA Git | Maintained and supported by SUSTech CRA and CCSE