Commit 5ed390e5 authored by Christoph Hellwig's avatar Christoph Hellwig
Browse files

ARM/dma-mapping: mark various dma-mapping routines static in dma-mapping.c 



With the dmabounce removal these aren't used outside of dma-mapping.c,
so mark them static.  Move the dma_map_ops declarations down a bit
to avoid lots of forward declarations.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarArnd Bergmann <arnd@arndb.de>
Tested-by: default avatarMarc Zyngier <maz@kernel.org>
parent e3217540

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

+0 −75
Original line number Diff line number Diff line
@@ -20,80 +20,5 @@ static inline const struct dma_map_ops *get_arch_dma_ops(struct bus_type *bus) 
	return NULL;

}



/**

 * arm_dma_alloc - allocate consistent memory for DMA

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

 * @size: required memory size

 * @handle: bus-specific DMA address

 * @attrs: optinal attributes that specific mapping properties

 *

 * Allocate some memory for a device for performing DMA.  This function

 * allocates pages, and will return the CPU-viewed address, and sets @handle

 * to be the device-viewed address.

 */

extern void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,

			   gfp_t gfp, unsigned long attrs);



/**

 * arm_dma_free - free memory allocated by arm_dma_alloc

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

 * @size: size of memory originally requested in dma_alloc_coherent

 * @cpu_addr: CPU-view address returned from dma_alloc_coherent

 * @handle: device-view address returned from dma_alloc_coherent

 * @attrs: optinal attributes that specific mapping properties

 *

 * Free (and unmap) a DMA buffer previously allocated by

 * arm_dma_alloc().

 *

 * References to memory and mappings associated with cpu_addr/handle

 * during and after this call executing are illegal.

 */

extern void arm_dma_free(struct device *dev, size_t size, void *cpu_addr,

			 dma_addr_t handle, unsigned long 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

 * @vma: vm_area_struct describing requested user mapping

 * @cpu_addr: kernel CPU-view address returned from dma_alloc_coherent

 * @handle: device-view address returned from dma_alloc_coherent

 * @size: size of memory originally requested in dma_alloc_coherent

 * @attrs: optinal attributes that specific mapping properties

 *

 * Map a coherent DMA buffer previously allocated by dma_alloc_coherent

 * into user space.  The coherent DMA buffer must not be freed by the

 * driver until the user space mapping has been released.

 */

extern int arm_dma_mmap(struct device *dev, struct vm_area_struct *vma,

			void *cpu_addr, dma_addr_t dma_addr, size_t size,

			unsigned long attrs);



/*

 * For SA-1111, IXP425, and ADI systems  the dma-mapping functions are "magic"

 * and utilize bounce buffers as needed to work around limited DMA windows.

 *

 * On the SA-1111, a bug limits DMA to only certain regions of RAM.

 * On the IXP425, the PCI inbound window is 64MB (256MB total RAM)

 * On some ADI engineering systems, PCI inbound window is 32MB (12MB total RAM)

 *

 * The following are helper functions used by the dmabounce subystem

 *

 */



/*

 * The scatter list versions of the above methods.

 */

extern int arm_dma_map_sg(struct device *, struct scatterlist *, int,

		enum dma_data_direction, unsigned long attrs);

extern void arm_dma_unmap_sg(struct device *, struct scatterlist *, int,

		enum dma_data_direction, unsigned long attrs);

extern void arm_dma_sync_sg_for_cpu(struct device *, struct scatterlist *, int,

		enum dma_data_direction);

extern void arm_dma_sync_sg_for_device(struct device *, struct scatterlist *, int,

		enum dma_data_direction);

extern int arm_dma_get_sgtable(struct device *dev, struct sg_table *sgt,

		void *cpu_addr, dma_addr_t dma_addr, size_t size,

		unsigned long attrs);



#endif /* __KERNEL__ */

#endif

arch/arm/mm/dma-mapping.c

+46 −54
Original line number Diff line number Diff line
@@ -193,50 +193,6 @@ static int arm_dma_supported(struct device *dev, u64 mask) 
	return dma_to_pfn(dev, mask) >= max_dma_pfn;

}



const struct dma_map_ops arm_dma_ops = {

	.alloc			= arm_dma_alloc,

	.free			= arm_dma_free,

	.alloc_pages		= dma_direct_alloc_pages,

	.free_pages		= dma_direct_free_pages,

	.mmap			= arm_dma_mmap,

	.get_sgtable		= arm_dma_get_sgtable,

	.map_page		= arm_dma_map_page,

	.unmap_page		= arm_dma_unmap_page,

	.map_sg			= arm_dma_map_sg,

	.unmap_sg		= arm_dma_unmap_sg,

	.map_resource		= dma_direct_map_resource,

	.sync_single_for_cpu	= arm_dma_sync_single_for_cpu,

	.sync_single_for_device	= arm_dma_sync_single_for_device,

	.sync_sg_for_cpu	= arm_dma_sync_sg_for_cpu,

	.sync_sg_for_device	= arm_dma_sync_sg_for_device,

	.dma_supported		= arm_dma_supported,

	.get_required_mask	= dma_direct_get_required_mask,

};

EXPORT_SYMBOL(arm_dma_ops);



static void *arm_coherent_dma_alloc(struct device *dev, size_t size,

	dma_addr_t *handle, gfp_t gfp, unsigned long attrs);

static void arm_coherent_dma_free(struct device *dev, size_t size, void *cpu_addr,

				  dma_addr_t handle, unsigned long attrs);

static int arm_coherent_dma_mmap(struct device *dev, struct vm_area_struct *vma,

		 void *cpu_addr, dma_addr_t dma_addr, size_t size,

		 unsigned long attrs);



const struct dma_map_ops arm_coherent_dma_ops = {

	.alloc			= arm_coherent_dma_alloc,

	.free			= arm_coherent_dma_free,

	.alloc_pages		= dma_direct_alloc_pages,

	.free_pages		= dma_direct_free_pages,

	.mmap			= arm_coherent_dma_mmap,

	.get_sgtable		= arm_dma_get_sgtable,

	.map_page		= arm_coherent_dma_map_page,

	.map_sg			= arm_dma_map_sg,

	.map_resource		= dma_direct_map_resource,

	.dma_supported		= arm_dma_supported,

	.get_required_mask	= dma_direct_get_required_mask,

};

EXPORT_SYMBOL(arm_coherent_dma_ops);



static void __dma_clear_buffer(struct page *page, size_t size, int coherent_flag)

{

	/*
@@ -742,7 +698,7 @@ static void *__dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, 
 * Allocate DMA-coherent memory space and return both the kernel remapped

 * virtual and bus address for that space.

 */

void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,

static void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,

		    gfp_t gfp, unsigned long attrs)

{

	pgprot_t prot = __get_dma_pgprot(attrs, PAGE_KERNEL);
@@ -791,7 +747,7 @@ static int arm_coherent_dma_mmap(struct device *dev, struct vm_area_struct *vma, 
	return __arm_dma_mmap(dev, vma, cpu_addr, dma_addr, size, attrs);

}



int arm_dma_mmap(struct device *dev, struct vm_area_struct *vma,

static int arm_dma_mmap(struct device *dev, struct vm_area_struct *vma,

		 void *cpu_addr, dma_addr_t dma_addr, size_t size,

		 unsigned long attrs)

{
@@ -824,7 +780,7 @@ static void __arm_dma_free(struct device *dev, size_t size, void *cpu_addr, 
	kfree(buf);

}



void arm_dma_free(struct device *dev, size_t size, void *cpu_addr,

static void arm_dma_free(struct device *dev, size_t size, void *cpu_addr,

		  dma_addr_t handle, unsigned long attrs)

{

	__arm_dma_free(dev, size, cpu_addr, handle, attrs, false);
@@ -836,7 +792,7 @@ static void arm_coherent_dma_free(struct device *dev, size_t size, void *cpu_add 
	__arm_dma_free(dev, size, cpu_addr, handle, attrs, true);

}



int arm_dma_get_sgtable(struct device *dev, struct sg_table *sgt,

static int arm_dma_get_sgtable(struct device *dev, struct sg_table *sgt,

		 void *cpu_addr, dma_addr_t handle, size_t size,

		 unsigned long attrs)

{
@@ -977,7 +933,7 @@ static void __dma_page_dev_to_cpu(struct page *page, unsigned long off, 
 * Device ownership issues as mentioned for dma_map_single are the same

 * here.

 */

int arm_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,

static int arm_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,

		enum dma_data_direction dir, unsigned long attrs)

{

	const struct dma_map_ops *ops = get_dma_ops(dev);
@@ -1013,8 +969,8 @@ int arm_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, 
 * Unmap a set of streaming mode DMA translations.  Again, CPU access

 * rules concerning calls here are the same as for dma_unmap_single().

 */

void arm_dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,

		enum dma_data_direction dir, unsigned long attrs)

static void arm_dma_unmap_sg(struct device *dev, struct scatterlist *sg,

		int nents, enum dma_data_direction dir, unsigned long attrs)

{

	const struct dma_map_ops *ops = get_dma_ops(dev);

	struct scatterlist *s;
@@ -1032,7 +988,7 @@ void arm_dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, 
 * @nents: number of buffers to map (returned from dma_map_sg)

 * @dir: DMA transfer direction (same as was passed to dma_map_sg)

 */

void arm_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,

static void arm_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,

			int nents, enum dma_data_direction dir)

{

	const struct dma_map_ops *ops = get_dma_ops(dev);
@@ -1051,8 +1007,8 @@ void arm_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, 
 * @nents: number of buffers to map (returned from dma_map_sg)

 * @dir: DMA transfer direction (same as was passed to dma_map_sg)

 */

void arm_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,

			int nents, enum dma_data_direction dir)

static void arm_dma_sync_sg_for_device(struct device *dev,

		struct scatterlist *sg, int nents, enum dma_data_direction dir)

{

	const struct dma_map_ops *ops = get_dma_ops(dev);

	struct scatterlist *s;
@@ -1063,6 +1019,42 @@ void arm_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, 
					    dir);

}



const struct dma_map_ops arm_dma_ops = {

	.alloc			= arm_dma_alloc,

	.free			= arm_dma_free,

	.alloc_pages		= dma_direct_alloc_pages,

	.free_pages		= dma_direct_free_pages,

	.mmap			= arm_dma_mmap,

	.get_sgtable		= arm_dma_get_sgtable,

	.map_page		= arm_dma_map_page,

	.unmap_page		= arm_dma_unmap_page,

	.map_sg			= arm_dma_map_sg,

	.unmap_sg		= arm_dma_unmap_sg,

	.map_resource		= dma_direct_map_resource,

	.sync_single_for_cpu	= arm_dma_sync_single_for_cpu,

	.sync_single_for_device	= arm_dma_sync_single_for_device,

	.sync_sg_for_cpu	= arm_dma_sync_sg_for_cpu,

	.sync_sg_for_device	= arm_dma_sync_sg_for_device,

	.dma_supported		= arm_dma_supported,

	.get_required_mask	= dma_direct_get_required_mask,

};

EXPORT_SYMBOL(arm_dma_ops);



const struct dma_map_ops arm_coherent_dma_ops = {

	.alloc			= arm_coherent_dma_alloc,

	.free			= arm_coherent_dma_free,

	.alloc_pages		= dma_direct_alloc_pages,

	.free_pages		= dma_direct_free_pages,

	.mmap			= arm_coherent_dma_mmap,

	.get_sgtable		= arm_dma_get_sgtable,

	.map_page		= arm_coherent_dma_map_page,

	.map_sg			= arm_dma_map_sg,

	.map_resource		= dma_direct_map_resource,

	.dma_supported		= arm_dma_supported,

	.get_required_mask	= dma_direct_get_required_mask,

};

EXPORT_SYMBOL(arm_coherent_dma_ops);



static const struct dma_map_ops *arm_get_dma_map_ops(bool coherent)

{

	/*