[linux-2.6-block.git] / include / asm-frv / dma-mapping.h

#ifndef _ASM_DMA_MAPPING_H
#define _ASM_DMA_MAPPING_H

#include <linux/device.h>
#include <asm/cache.h>
#include <asm/cacheflush.h>
#include <asm/scatterlist.h>
#include <asm/io.h>

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

/*
 * Map a single buffer of the indicated size for DMA in streaming mode.
 * The 32-bit bus address to use is returned.
 *
 * Once the device is given the dma address, the device owns this memory
 * until either pci_unmap_single or pci_dma_sync_single is performed.
 */
extern dma_addr_t dma_map_single(struct device *dev, void *ptr, size_t size,
				 enum dma_data_direction direction);

/*
 * Unmap a single streaming mode DMA translation.  The dma_addr and size
 * must match what was provided for in a previous pci_map_single call.  All
 * other usages are undefined.
 *
 * After this call, reads by the cpu to the buffer are guarenteed to see
 * whatever the device wrote there.
 */
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);
}

/*
 * Map a set of buffers described by scatterlist in streaming
 * mode for DMA.  This is the scather-gather version of the
 * above pci_map_single interface.  Here the scatter gather list
 * elements are each tagged with the appropriate dma address
 * and length.  They are obtained via sg_dma_{address,length}(SG).
 *
 * NOTE: An implementation may be able to use a smaller number of
 *       DMA address/length pairs than there are SG table elements.
 *       (for example via virtual mapping capabilities)
 *       The routine returns the number of addr/length pairs actually
 *       used, at most nents.
 *
 * Device ownership issues as mentioned above for pci_map_single are
 * the same here.
 */
extern int dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
		      enum dma_data_direction direction);

/*
 * Unmap a set of streaming mode DMA translations.
 * Again, cpu read rules concerning calls here are the same as for
 * pci_unmap_single() above.
 */
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();
}

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
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(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;
}

static inline
int dma_get_cache_alignment(void)
{
	return 1 << L1_CACHE_SHIFT;
}

#define dma_is_consistent(d, h)	(1)

static inline
void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
		    enum dma_data_direction direction)
{
	flush_write_buffers();
}

#endif  /* _ASM_DMA_MAPPING_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef _ASM_DMA_MAPPING_H
	2	#define _ASM_DMA_MAPPING_H
	3
	4	#include <linux/device.h>
	5	#include <asm/cache.h>
	6	#include <asm/cacheflush.h>
	7	#include <asm/scatterlist.h>
	8	#include <asm/io.h>
	9
	10	#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
	11	#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
	12
	13	extern unsigned long __nongprelbss dma_coherent_mem_start;
	14	extern unsigned long __nongprelbss dma_coherent_mem_end;
	15
a5da7d3c	16	void dma_alloc_coherent(struct device dev, size_t size, dma_addr_t *dma_handle, gfp_t gfp);
1da177e4 LT	17	void dma_free_coherent(struct device dev, size_t size, void vaddr, dma_addr_t dma_handle);
1da177e4 LT	18
1da177e4 LT	19	/*
	20	* Map a single buffer of the indicated size for DMA in streaming mode.
	21	* The 32-bit bus address to use is returned.
	22	*
	23	* Once the device is given the dma address, the device owns this memory
	24	* until either pci_unmap_single or pci_dma_sync_single is performed.
	25	*/
	26	extern dma_addr_t dma_map_single(struct device dev, void ptr, size_t size,
	27	enum dma_data_direction direction);
	28
	29	/*
	30	* Unmap a single streaming mode DMA translation. The dma_addr and size
	31	* must match what was provided for in a previous pci_map_single call. All
	32	* other usages are undefined.
	33	*
	34	* After this call, reads by the cpu to the buffer are guarenteed to see
	35	* whatever the device wrote there.
	36	*/
	37	static inline
	38	void dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
	39	enum dma_data_direction direction)
	40	{
	41	BUG_ON(direction == DMA_NONE);
	42	}
	43
	44	/*
	45	* Map a set of buffers described by scatterlist in streaming
	46	* mode for DMA. This is the scather-gather version of the
	47	* above pci_map_single interface. Here the scatter gather list
	48	* elements are each tagged with the appropriate dma address
	49	* and length. They are obtained via sg_dma_{address,length}(SG).
	50	*
	51	* NOTE: An implementation may be able to use a smaller number of
	52	* DMA address/length pairs than there are SG table elements.
	53	* (for example via virtual mapping capabilities)
	54	* The routine returns the number of addr/length pairs actually
	55	* used, at most nents.
	56	*
	57	* Device ownership issues as mentioned above for pci_map_single are
	58	* the same here.
	59	*/
	60	extern int dma_map_sg(struct device dev, struct scatterlist sg, int nents,
	61	enum dma_data_direction direction);
	62
	63	/*
	64	* Unmap a set of streaming mode DMA translations.
	65	* Again, cpu read rules concerning calls here are the same as for
	66	* pci_unmap_single() above.
	67	*/
	68	static inline
	69	void dma_unmap_sg(struct device dev, struct scatterlist sg, int nhwentries,
	70	enum dma_data_direction direction)
	71	{
	72	BUG_ON(direction == DMA_NONE);
	73	}
	74
	75	extern
	76	dma_addr_t dma_map_page(struct device dev, struct page page, unsigned long offset,
	77	size_t size, enum dma_data_direction direction);
	78
	79	static inline
	80	void dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
	81	enum dma_data_direction direction)
	82	{
83	BUG_ON(direction == DMA_NONE);
84	}
85
86
87	static inline
88	void dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
89	enum dma_data_direction direction)
90	{
91	}
92
93	static inline
94	void dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
95	enum dma_data_direction direction)
96	{
97	flush_write_buffers();
98	}
99
100	static inline
101	void dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
102	unsigned long offset, size_t size,
103	enum dma_data_direction direction)
104	{
105	}
106
107	static inline
108	void dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
109	unsigned long offset, size_t size,
110	enum dma_data_direction direction)
111	{
112	flush_write_buffers();
113	}
114
115	static inline
116	void dma_sync_sg_for_cpu(struct device dev, struct scatterlist sg, int nelems,
117	enum dma_data_direction direction)
118	{
119	}
120
121	static inline
122	void dma_sync_sg_for_device(struct device dev, struct scatterlist sg, int nelems,
123	enum dma_data_direction direction)
124	{
125	flush_write_buffers();
126	}
127
128	static inline
129	int dma_mapping_error(dma_addr_t dma_addr)
130	{
131	return 0;
132	}
133
134	static inline
135	int dma_supported(struct device *dev, u64 mask)
136	{
137	/*
138	* we fall back to GFP_DMA when the mask isn't all 1s,
139	* so we can't guarantee allocations that must be
140	* within a tighter range than GFP_DMA..
141	*/
142	if (mask < 0x00ffffff)
143	return 0;
144
145	return 1;
146	}
147
148	static inline
149	int dma_set_mask(struct device *dev, u64 mask)
150	{
151	if (!dev->dma_mask \|\| !dma_supported(dev, mask))
152	return -EIO;
153
154	*dev->dma_mask = mask;
155
156	return 0;
157	}
158
159	static inline
160	int dma_get_cache_alignment(void)
161	{
162	return 1 << L1_CACHE_SHIFT;
163	}
164
f67637ee	165	#define dma_is_consistent(d, h) (1)
1da177e4 LT	166
1da177e4 LT	167	static inline
d3fa72e4	168	void dma_cache_sync(struct device dev, void vaddr, size_t size,
1da177e4 LT	169	enum dma_data_direction direction)
	170	{
	171	flush_write_buffers();
	172	}
	173
	174	#endif /* _ASM_DMA_MAPPING_H */