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

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

frv: convert to dma_map_ops 



Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Cc: David Howells <dhowells@redhat.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 5a1a67f1

arch/frv/Kconfig

+2 −0
Original line number Diff line number Diff line
@@ -15,6 +15,8 @@ config FRV 
	select OLD_SIGSUSPEND3

	select OLD_SIGACTION

	select HAVE_DEBUG_STACKOVERFLOW

	select ARCH_NO_COHERENT_DMA_MMAP

	select HAVE_DMA_ATTRS



config ZONE_DMA

	bool

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

+4 −128
Original line number Diff line number Diff line 
#ifndef _ASM_DMA_MAPPING_H

#define _ASM_DMA_MAPPING_H



#include <linux/device.h>

#include <linux/scatterlist.h>

#include <asm/cache.h>

#include <asm/cacheflush.h>

#include <asm/io.h>



/*

 * See Documentation/DMA-API.txt for the description of how the

 * following DMA API should work.

 */



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



extern unsigned long __nongprelbss dma_coherent_mem_start;

extern unsigned long __nongprelbss dma_coherent_mem_end;



void *dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle, gfp_t gfp);

void dma_free_coherent(struct device *dev, size_t size, void *vaddr, dma_addr_t dma_handle);



extern dma_addr_t dma_map_single(struct device *dev, void *ptr, size_t size,

				 enum dma_data_direction direction);



static inline

void dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,

		      enum dma_data_direction direction)

{

	BUG_ON(direction == DMA_NONE);

}



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

		      enum dma_data_direction direction);



static inline

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

	     enum dma_data_direction direction)

{

	BUG_ON(direction == DMA_NONE);

}



extern

dma_addr_t dma_map_page(struct device *dev, struct page *page, unsigned long offset,

			size_t size, enum dma_data_direction direction);



static inline

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

		    enum dma_data_direction direction)

{

	BUG_ON(direction == DMA_NONE);

}





static inline

void dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,

			     enum dma_data_direction direction)

{

}



static inline

void dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,

				enum dma_data_direction direction)

{

	flush_write_buffers();

}

extern struct dma_map_ops frv_dma_ops;



static inline

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)

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

{

}



static inline

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)

{

	flush_write_buffers();

}



static inline

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

			 enum dma_data_direction direction)

{

}



static inline

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

			    enum dma_data_direction direction)

{

	flush_write_buffers();

}



static inline

int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)

{

	return 0;

}



static inline

int dma_supported(struct device *dev, u64 mask)

{

        /*

         * we fall back to GFP_DMA when the mask isn't all 1s,

         * so we can't guarantee allocations that must be

         * within a tighter range than GFP_DMA..

         */

        if (mask < 0x00ffffff)

                return 0;



	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;

	return &frv_dma_ops;

}



static inline
@@ -132,19 +21,6 @@ void dma_cache_sync(struct device *dev, void *vaddr, size_t size, 
	flush_write_buffers();

}



/* Not supported for now */

static inline int dma_mmap_coherent(struct device *dev,

				    struct vm_area_struct *vma, void *cpu_addr,

				    dma_addr_t dma_addr, size_t size)

{

	return -EINVAL;

}



static inline int dma_get_sgtable(struct device *dev, struct sg_table *sgt,

				  void *cpu_addr, dma_addr_t dma_addr,

				  size_t size)

{

	return -EINVAL;

}

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



#endif  /* _ASM_DMA_MAPPING_H */

arch/frv/mb93090-mb00/pci-dma-nommu.c

+47 −25
Original line number Diff line number Diff line
@@ -34,7 +34,8 @@ struct dma_alloc_record { 
static DEFINE_SPINLOCK(dma_alloc_lock);

static LIST_HEAD(dma_alloc_list);



void *dma_alloc_coherent(struct device *hwdev, size_t size, dma_addr_t *dma_handle, gfp_t gfp)

static void *frv_dma_alloc(struct device *hwdev, size_t size, dma_addr_t *dma_handle,

		gfp_t gfp, struct dma_attrs *attrs)

{

	struct dma_alloc_record *new;

	struct list_head *this = &dma_alloc_list;
@@ -84,9 +85,8 @@ void *dma_alloc_coherent(struct device *hwdev, size_t size, dma_addr_t *dma_hand 
	return NULL;

}



EXPORT_SYMBOL(dma_alloc_coherent);



void dma_free_coherent(struct device *hwdev, size_t size, void *vaddr, dma_addr_t dma_handle)

static void frv_dma_free(struct device *hwdev, size_t size, void *vaddr,

		dma_addr_t dma_handle, struct dma_attrs *attrs)

{

	struct dma_alloc_record *rec;

	unsigned long flags;
@@ -105,22 +105,9 @@ void dma_free_coherent(struct device *hwdev, size_t size, void *vaddr, dma_addr_ 
	BUG();

}



EXPORT_SYMBOL(dma_free_coherent);



dma_addr_t dma_map_single(struct device *dev, void *ptr, size_t size,

			  enum dma_data_direction direction)

{

	BUG_ON(direction == DMA_NONE);



	frv_cache_wback_inv((unsigned long) ptr, (unsigned long) ptr + size);



	return virt_to_bus(ptr);

}



EXPORT_SYMBOL(dma_map_single);



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

	       enum dma_data_direction direction)

static int frv_dma_map_sg(struct device *dev, struct scatterlist *sglist,

		int nents, enum dma_data_direction direction,

		struct dma_attrs *attrs)

{

	int i;

	struct scatterlist *sg;
@@ -135,14 +122,49 @@ int dma_map_sg(struct device *dev, struct scatterlist *sglist, int nents, 
	return nents;

}



EXPORT_SYMBOL(dma_map_sg);



dma_addr_t dma_map_page(struct device *dev, struct page *page, unsigned long offset,

			size_t size, enum dma_data_direction direction)

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

		unsigned long offset, size_t size,

		enum dma_data_direction direction, struct dma_attrs *attrs)

{

	BUG_ON(direction == DMA_NONE);

	flush_dcache_page(page);

	return (dma_addr_t) page_to_phys(page) + offset;

}



EXPORT_SYMBOL(dma_map_page);
 
static void frv_dma_sync_single_for_device(struct device *dev,

		dma_addr_t dma_handle, size_t size,

		enum dma_data_direction direction)

{

	flush_write_buffers();

}



static void frv_dma_sync_sg_for_device(struct device *dev,

		struct scatterlist *sg, int nelems,

		enum dma_data_direction direction)

{

	flush_write_buffers();

}





static int frv_dma_supported(struct device *dev, u64 mask)

{

        /*

         * we fall back to GFP_DMA when the mask isn't all 1s,

         * so we can't guarantee allocations that must be

         * within a tighter range than GFP_DMA..

         */

        if (mask < 0x00ffffff)

                return 0;

	return 1;

}



struct dma_map_ops frv_dma_ops = {

	.alloc			= frv_dma_alloc,

	.free			= frv_dma_free,

	.map_page		= frv_dma_map_page,

	.map_sg			= frv_dma_map_sg,

	.sync_single_for_device	= frv_dma_sync_single_for_device,

	.sync_sg_for_device	= frv_dma_sync_sg_for_device,

	.dma_supported		= frv_dma_supported,

};

EXPORT_SYMBOL(frv_dma_ops);

arch/frv/mb93090-mb00/pci-dma.c

+48 −26
Original line number Diff line number Diff line
@@ -18,7 +18,9 @@ 
#include <linux/scatterlist.h>

#include <asm/io.h>



void *dma_alloc_coherent(struct device *hwdev, size_t size, dma_addr_t *dma_handle, gfp_t gfp)

static void *frv_dma_alloc(struct device *hwdev, size_t size,

		dma_addr_t *dma_handle, gfp_t gfp,

		struct dma_attrs *attrs)

{

	void *ret;
@@ -29,29 +31,15 @@ void *dma_alloc_coherent(struct device *hwdev, size_t size, dma_addr_t *dma_hand 
	return ret;

}



EXPORT_SYMBOL(dma_alloc_coherent);



void dma_free_coherent(struct device *hwdev, size_t size, void *vaddr, dma_addr_t dma_handle)

static void frv_dma_free(struct device *hwdev, size_t size, void *vaddr,

		dma_addr_t dma_handle, struct dma_attrs *attrs)

{

	consistent_free(vaddr);

}



EXPORT_SYMBOL(dma_free_coherent);



dma_addr_t dma_map_single(struct device *dev, void *ptr, size_t size,

			  enum dma_data_direction direction)

{

	BUG_ON(direction == DMA_NONE);



	frv_cache_wback_inv((unsigned long) ptr, (unsigned long) ptr + size);



	return virt_to_bus(ptr);

}



EXPORT_SYMBOL(dma_map_single);



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

	       enum dma_data_direction direction)

static int frv_dma_map_sg(struct device *dev, struct scatterlist *sglist,

		int nents, enum dma_data_direction direction,

		struct dma_attrs *attrs)

{

	unsigned long dampr2;

	void *vaddr;
@@ -79,14 +67,48 @@ int dma_map_sg(struct device *dev, struct scatterlist *sglist, int nents, 
	return nents;

}



EXPORT_SYMBOL(dma_map_sg);



dma_addr_t dma_map_page(struct device *dev, struct page *page, unsigned long offset,

			size_t size, enum dma_data_direction direction)

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

		unsigned long offset, size_t size,

		enum dma_data_direction direction, struct dma_attrs *attrs)

{

	BUG_ON(direction == DMA_NONE);

	flush_dcache_page(page);

	return (dma_addr_t) page_to_phys(page) + offset;

}



EXPORT_SYMBOL(dma_map_page);
 
static void frv_dma_sync_single_for_device(struct device *dev,

		dma_addr_t dma_handle, size_t size,

		enum dma_data_direction direction)

{

	flush_write_buffers();

}



static void frv_dma_sync_sg_for_device(struct device *dev,

		struct scatterlist *sg, int nelems,

		enum dma_data_direction direction)

{

	flush_write_buffers();

}





static int frv_dma_supported(struct device *dev, u64 mask)

{

        /*

         * we fall back to GFP_DMA when the mask isn't all 1s,

         * so we can't guarantee allocations that must be

         * within a tighter range than GFP_DMA..

         */

        if (mask < 0x00ffffff)

                return 0;

	return 1;

}



struct dma_map_ops frv_dma_ops = {

	.alloc			= frv_dma_alloc,

	.free			= frv_dma_free,

	.map_page		= frv_dma_map_page,

	.map_sg			= frv_dma_map_sg,

	.sync_single_for_device	= frv_dma_sync_single_for_device,

	.sync_sg_for_device	= frv_dma_sync_sg_for_device,

	.dma_supported		= frv_dma_supported,

};

EXPORT_SYMBOL(frv_dma_ops);