Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5a1a67f1 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Linus Torvalds
Browse files

nios2: convert to dma_map_ops 



Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Cc: Ley Foon Tan <lftan@altera.com>
Cc: Christian Borntraeger <borntraeger@de.ibm.com>
Cc: Joerg Roedel <jroedel@suse.de>
Cc: Sebastian Ott <sebott@linux.vnet.ibm.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent e20dd889

arch/nios2/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ config NIOS2 
	select SOC_BUS

	select SPARSE_IRQ

	select USB_ARCH_HAS_HCD if USB_SUPPORT

	select HAVE_DMA_ATTRS



config GENERIC_CSUM

	def_bool y

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

+6 −117
Original line number Diff line number Diff line
@@ -10,112 +10,11 @@ 
#ifndef _ASM_NIOS2_DMA_MAPPING_H

#define _ASM_NIOS2_DMA_MAPPING_H



#include <linux/scatterlist.h>

#include <linux/cache.h>

#include <asm/cacheflush.h>

extern struct dma_map_ops nios2_dma_ops;



static inline void __dma_sync_for_device(void *vaddr, size_t size,

			      enum dma_data_direction direction)

static inline struct dma_map_ops *get_dma_ops(struct device *dev)

{

	switch (direction) {

	case DMA_FROM_DEVICE:

		invalidate_dcache_range((unsigned long)vaddr,

			(unsigned long)(vaddr + size));

		break;

	case DMA_TO_DEVICE:

		/*

		 * We just need to flush the caches here , but Nios2 flush

		 * instruction will do both writeback and invalidate.

		 */

	case DMA_BIDIRECTIONAL: /* flush and invalidate */

		flush_dcache_range((unsigned long)vaddr,

			(unsigned long)(vaddr + size));

		break;

	default:

		BUG();

	}

}



static inline void __dma_sync_for_cpu(void *vaddr, size_t size,

			      enum dma_data_direction direction)

{

	switch (direction) {

	case DMA_BIDIRECTIONAL:

	case DMA_FROM_DEVICE:

		invalidate_dcache_range((unsigned long)vaddr,

			(unsigned long)(vaddr + size));

		break;

	case DMA_TO_DEVICE:

		break;

	default:

		BUG();

	}

}



#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)



void *dma_alloc_coherent(struct device *dev, size_t size,

			   dma_addr_t *dma_handle, gfp_t flag);



void dma_free_coherent(struct device *dev, size_t size,

			 void *vaddr, dma_addr_t dma_handle);



static inline dma_addr_t dma_map_single(struct device *dev, void *ptr,

					size_t size,

					enum dma_data_direction direction)

{

	BUG_ON(!valid_dma_direction(direction));

	__dma_sync_for_device(ptr, size, direction);

	return virt_to_phys(ptr);

}



static inline void dma_unmap_single(struct device *dev, dma_addr_t dma_addr,

				size_t size, enum dma_data_direction direction)

{

}



extern int dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,

	enum dma_data_direction direction);

extern dma_addr_t dma_map_page(struct device *dev, struct page *page,

	unsigned long offset, size_t size, enum dma_data_direction direction);

extern void dma_unmap_page(struct device *dev, dma_addr_t dma_address,

	size_t size, enum dma_data_direction direction);

extern void dma_unmap_sg(struct device *dev, struct scatterlist *sg,

	int nhwentries, enum dma_data_direction direction);

extern void dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle,

	size_t size, enum dma_data_direction direction);

extern void dma_sync_single_for_device(struct device *dev,

	dma_addr_t dma_handle, size_t size, enum dma_data_direction direction);

extern void dma_sync_single_range_for_cpu(struct device *dev,

	dma_addr_t dma_handle, unsigned long offset, size_t size,

	enum dma_data_direction direction);

extern void dma_sync_single_range_for_device(struct device *dev,

	dma_addr_t dma_handle, unsigned long offset, size_t size,

	enum dma_data_direction direction);

extern void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,

	int nelems, enum dma_data_direction direction);

extern void dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,

	int nelems, enum dma_data_direction direction);



static inline int dma_supported(struct device *dev, u64 mask)

{

	return 1;

}



static inline int dma_set_mask(struct device *dev, u64 mask)

{

	if (!dev->dma_mask || !dma_supported(dev, mask))

		return -EIO;



	*dev->dma_mask = mask;



	return 0;

}



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

{

	return 0;

	return &nios2_dma_ops;

}



/*
@@ -127,14 +26,4 @@ static inline void dma_cache_sync(struct device *dev, void *vaddr, size_t size, 
{

}



/* drivers/base/dma-mapping.c */

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

		void *cpu_addr, dma_addr_t dma_addr, size_t size);

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

		void *cpu_addr, dma_addr_t dma_addr,

		size_t size);



#define dma_mmap_coherent(d, v, c, h, s) dma_common_mmap(d, v, c, h, s)

#define dma_get_sgtable(d, t, v, h, s) dma_common_get_sgtable(d, t, v, h, s)



#endif /* _ASM_NIOS2_DMA_MAPPING_H */

arch/nios2/mm/dma-mapping.c

+80 −69
Original line number Diff line number Diff line
@@ -20,9 +20,46 @@ 
#include <linux/cache.h>

#include <asm/cacheflush.h>



static inline void __dma_sync_for_device(void *vaddr, size_t size,

			      enum dma_data_direction direction)

{

	switch (direction) {

	case DMA_FROM_DEVICE:

		invalidate_dcache_range((unsigned long)vaddr,

			(unsigned long)(vaddr + size));

		break;

	case DMA_TO_DEVICE:

		/*

		 * We just need to flush the caches here , but Nios2 flush

		 * instruction will do both writeback and invalidate.

		 */

	case DMA_BIDIRECTIONAL: /* flush and invalidate */

		flush_dcache_range((unsigned long)vaddr,

			(unsigned long)(vaddr + size));

		break;

	default:

		BUG();

	}

}



static inline void __dma_sync_for_cpu(void *vaddr, size_t size,

			      enum dma_data_direction direction)

{

	switch (direction) {

	case DMA_BIDIRECTIONAL:

	case DMA_FROM_DEVICE:

		invalidate_dcache_range((unsigned long)vaddr,

			(unsigned long)(vaddr + size));

		break;

	case DMA_TO_DEVICE:

		break;

	default:

		BUG();

	}

}



void *dma_alloc_coherent(struct device *dev, size_t size,

			    dma_addr_t *dma_handle, gfp_t gfp)

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

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

{

	void *ret;
@@ -45,24 +82,21 @@ void *dma_alloc_coherent(struct device *dev, size_t size, 


	return ret;

}

EXPORT_SYMBOL(dma_alloc_coherent);



void dma_free_coherent(struct device *dev, size_t size, void *vaddr,

			dma_addr_t dma_handle)

static void nios2_dma_free(struct device *dev, size_t size, void *vaddr,

		dma_addr_t dma_handle, struct dma_attrs *attrs)

{

	unsigned long addr = (unsigned long) CAC_ADDR((unsigned long) vaddr);



	free_pages(addr, get_order(size));

}

EXPORT_SYMBOL(dma_free_coherent);



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

		enum dma_data_direction direction)

static int nios2_dma_map_sg(struct device *dev, struct scatterlist *sg,

		int nents, enum dma_data_direction direction,

		struct dma_attrs *attrs)

{

	int i;



	BUG_ON(!valid_dma_direction(direction));



	for_each_sg(sg, sg, nents, i) {

		void *addr;
@@ -75,40 +109,32 @@ int dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, 


	return nents;

}

EXPORT_SYMBOL(dma_map_sg);



dma_addr_t dma_map_page(struct device *dev, struct page *page,

static dma_addr_t nios2_dma_map_page(struct device *dev, struct page *page,

			unsigned long offset, size_t size,

			enum dma_data_direction direction)

			enum dma_data_direction direction,

			struct dma_attrs *attrs)

{

	void *addr;

	void *addr = page_address(page) + offset;



	BUG_ON(!valid_dma_direction(direction));



	addr = page_address(page) + offset;

	__dma_sync_for_device(addr, size, direction);



	return page_to_phys(page) + offset;

}

EXPORT_SYMBOL(dma_map_page);



void dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,

		    enum dma_data_direction direction)

static void nios2_dma_unmap_page(struct device *dev, dma_addr_t dma_address,

		size_t size, enum dma_data_direction direction,

		struct dma_attrs *attrs)

{

	BUG_ON(!valid_dma_direction(direction));



	__dma_sync_for_cpu(phys_to_virt(dma_address), size, direction);

}

EXPORT_SYMBOL(dma_unmap_page);



void dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,

		  enum dma_data_direction direction)

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

		int nhwentries, enum dma_data_direction direction,

		struct dma_attrs *attrs)

{

	void *addr;

	int i;



	BUG_ON(!valid_dma_direction(direction));



	if (direction == DMA_TO_DEVICE)

		return;
@@ -118,69 +144,54 @@ void dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries, 
			__dma_sync_for_cpu(addr, sg->length, direction);

	}

}

EXPORT_SYMBOL(dma_unmap_sg);



void dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle,

			     size_t size, enum dma_data_direction direction)

{

	BUG_ON(!valid_dma_direction(direction));



	__dma_sync_for_cpu(phys_to_virt(dma_handle), size, direction);

}

EXPORT_SYMBOL(dma_sync_single_for_cpu);



void dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle,

				size_t size, enum dma_data_direction direction)

{

	BUG_ON(!valid_dma_direction(direction));



	__dma_sync_for_device(phys_to_virt(dma_handle), size, direction);

}

EXPORT_SYMBOL(dma_sync_single_for_device);



void dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,

					unsigned long offset, size_t size,

static void nios2_dma_sync_single_for_cpu(struct device *dev,

		dma_addr_t dma_handle, size_t size,

		enum dma_data_direction direction)

{

	BUG_ON(!valid_dma_direction(direction));



	__dma_sync_for_cpu(phys_to_virt(dma_handle), size, direction);

}

EXPORT_SYMBOL(dma_sync_single_range_for_cpu);



void dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,

					unsigned long offset, size_t size,

static void nios2_dma_sync_single_for_device(struct device *dev,

		dma_addr_t dma_handle, size_t size,

		enum dma_data_direction direction)

{

	BUG_ON(!valid_dma_direction(direction));



	__dma_sync_for_device(phys_to_virt(dma_handle), size, direction);

}

EXPORT_SYMBOL(dma_sync_single_range_for_device);



void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,

static void nios2_dma_sync_sg_for_cpu(struct device *dev,

		struct scatterlist *sg, int nelems,

		enum dma_data_direction direction)

{

	int i;



	BUG_ON(!valid_dma_direction(direction));



	/* Make sure that gcc doesn't leave the empty loop body.  */

	for_each_sg(sg, sg, nelems, i)

		__dma_sync_for_cpu(sg_virt(sg), sg->length, direction);

}

EXPORT_SYMBOL(dma_sync_sg_for_cpu);



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

				int nelems, enum dma_data_direction direction)

static void nios2_dma_sync_sg_for_device(struct device *dev,

		struct scatterlist *sg, int nelems,

		enum dma_data_direction direction)

{

	int i;



	BUG_ON(!valid_dma_direction(direction));



	/* Make sure that gcc doesn't leave the empty loop body.  */

	for_each_sg(sg, sg, nelems, i)

		__dma_sync_for_device(sg_virt(sg), sg->length, direction);



}

EXPORT_SYMBOL(dma_sync_sg_for_device);
 


struct dma_map_ops nios2_dma_ops = {

	.alloc			= nios2_dma_alloc,

	.free			= nios2_dma_free,

	.map_page		= nios2_dma_map_page,

	.unmap_page		= nios2_dma_unmap_page,

	.map_sg			= nios2_dma_map_sg,

	.unmap_sg		= nios2_dma_unmap_sg,

	.sync_single_for_device	= nios2_dma_sync_single_for_device,

	.sync_single_for_cpu	= nios2_dma_sync_single_for_cpu,

	.sync_sg_for_cpu	= nios2_dma_sync_sg_for_cpu,

	.sync_sg_for_device	= nios2_dma_sync_sg_for_device,

};

EXPORT_SYMBOL(nios2_dma_ops);