[mirror_ubuntu-bionic-kernel.git] / include / asm-x86 / dma-mapping_64.h

#ifndef _X8664_DMA_MAPPING_H
#define _X8664_DMA_MAPPING_H 1

/*
 * IOMMU interface. See Documentation/DMA-mapping.txt and DMA-API.txt for
 * documentation.
 */

#include <linux/scatterlist.h>
#include <asm/io.h>
#include <asm/swiotlb.h>

struct dma_mapping_ops {
	int             (*mapping_error)(dma_addr_t dma_addr);
	void*           (*alloc_coherent)(struct device *dev, size_t size,
                                dma_addr_t *dma_handle, gfp_t gfp);
	void            (*free_coherent)(struct device *dev, size_t size,
                                void *vaddr, dma_addr_t dma_handle);
	dma_addr_t      (*map_single)(struct device *hwdev, void *ptr,
                                size_t size, int direction);
	/* like map_single, but doesn't check the device mask */
	dma_addr_t      (*map_simple)(struct device *hwdev, char *ptr,
                                size_t size, int direction);
	void            (*unmap_single)(struct device *dev, dma_addr_t addr,
		                size_t size, int direction);
	void            (*sync_single_for_cpu)(struct device *hwdev,
		                dma_addr_t dma_handle, size_t size,
				int direction);
	void            (*sync_single_for_device)(struct device *hwdev,
                                dma_addr_t dma_handle, size_t size,
				int direction);
	void            (*sync_single_range_for_cpu)(struct device *hwdev,
                                dma_addr_t dma_handle, unsigned long offset,
		                size_t size, int direction);
	void            (*sync_single_range_for_device)(struct device *hwdev,
				dma_addr_t dma_handle, unsigned long offset,
		                size_t size, int direction);
	void            (*sync_sg_for_cpu)(struct device *hwdev,
                                struct scatterlist *sg, int nelems,
				int direction);
	void            (*sync_sg_for_device)(struct device *hwdev,
				struct scatterlist *sg, int nelems,
				int direction);
	int             (*map_sg)(struct device *hwdev, struct scatterlist *sg,
		                int nents, int direction);
	void            (*unmap_sg)(struct device *hwdev,
				struct scatterlist *sg, int nents,
				int direction);
	int             (*dma_supported)(struct device *hwdev, u64 mask);
	int		is_phys;
};

extern dma_addr_t bad_dma_address;
extern const struct dma_mapping_ops* dma_ops;
extern int iommu_merge;

static inline int dma_mapping_error(dma_addr_t dma_addr)
{
	if (dma_ops->mapping_error)
		return dma_ops->mapping_error(dma_addr);

	return (dma_addr == bad_dma_address);
}

#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_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 void *dma_alloc_coherent(struct device *dev, size_t size,
				dma_addr_t *dma_handle, gfp_t gfp);
extern 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 *hwdev, void *ptr, size_t size,
	       int direction)
{
	BUG_ON(!valid_dma_direction(direction));
	return dma_ops->map_single(hwdev, ptr, size, direction);
}

static inline void
dma_unmap_single(struct device *dev, dma_addr_t addr,size_t size,
		 int direction)
{
	BUG_ON(!valid_dma_direction(direction));
	dma_ops->unmap_single(dev, addr, size, direction);
}

#define dma_map_page(dev,page,offset,size,dir) \
	dma_map_single((dev), page_address(page)+(offset), (size), (dir))

#define dma_unmap_page dma_unmap_single

static inline void
dma_sync_single_for_cpu(struct device *hwdev, dma_addr_t dma_handle,
			size_t size, int direction)
{
	BUG_ON(!valid_dma_direction(direction));
	if (dma_ops->sync_single_for_cpu)
		dma_ops->sync_single_for_cpu(hwdev, dma_handle, size,
					     direction);
	flush_write_buffers();
}

static inline void
dma_sync_single_for_device(struct device *hwdev, dma_addr_t dma_handle,
			   size_t size, int direction)
{
	BUG_ON(!valid_dma_direction(direction));
	if (dma_ops->sync_single_for_device)
		dma_ops->sync_single_for_device(hwdev, dma_handle, size,
						direction);
	flush_write_buffers();
}

static inline void
dma_sync_single_range_for_cpu(struct device *hwdev, dma_addr_t dma_handle,
			      unsigned long offset, size_t size, int direction)
{
	BUG_ON(!valid_dma_direction(direction));
	if (dma_ops->sync_single_range_for_cpu) {
		dma_ops->sync_single_range_for_cpu(hwdev, dma_handle, offset, size, direction);
	}

	flush_write_buffers();
}

static inline void
dma_sync_single_range_for_device(struct device *hwdev, dma_addr_t dma_handle,
				 unsigned long offset, size_t size, int direction)
{
	BUG_ON(!valid_dma_direction(direction));
	if (dma_ops->sync_single_range_for_device)
		dma_ops->sync_single_range_for_device(hwdev, dma_handle,
						      offset, size, direction);

	flush_write_buffers();
}

static inline void
dma_sync_sg_for_cpu(struct device *hwdev, struct scatterlist *sg,
		    int nelems, int direction)
{
	BUG_ON(!valid_dma_direction(direction));
	if (dma_ops->sync_sg_for_cpu)
		dma_ops->sync_sg_for_cpu(hwdev, sg, nelems, direction);
	flush_write_buffers();
}

static inline void
dma_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg,
		       int nelems, int direction)
{
	BUG_ON(!valid_dma_direction(direction));
	if (dma_ops->sync_sg_for_device) {
		dma_ops->sync_sg_for_device(hwdev, sg, nelems, direction);
	}

	flush_write_buffers();
}

static inline int
dma_map_sg(struct device *hwdev, struct scatterlist *sg, int nents, int direction)
{
	BUG_ON(!valid_dma_direction(direction));
	return dma_ops->map_sg(hwdev, sg, nents, direction);
}

static inline void
dma_unmap_sg(struct device *hwdev, struct scatterlist *sg, int nents,
	     int direction)
{
	BUG_ON(!valid_dma_direction(direction));
	dma_ops->unmap_sg(hwdev, sg, nents, direction);
}

extern int dma_supported(struct device *hwdev, u64 mask);

/* same for gart, swiotlb, and nommu */
static inline int dma_get_cache_alignment(void)
{
	return boot_cpu_data.x86_clflush_size;
}

#define dma_is_consistent(d, h) 1

extern int dma_set_mask(struct device *dev, u64 mask);

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

extern struct device fallback_dev;
extern int panic_on_overflow;

#endif /* _X8664_DMA_MAPPING_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef _X8664_DMA_MAPPING_H
	2	#define _X8664_DMA_MAPPING_H 1
	3
	4	/*
	5	* IOMMU interface. See Documentation/DMA-mapping.txt and DMA-API.txt for
	6	* documentation.
	7	*/
	8
46856afa	9	#include <linux/scatterlist.h>
1da177e4 LT	10	#include <asm/io.h>
	11	#include <asm/swiotlb.h>
	12
17a941d8 MBY	13	struct dma_mapping_ops {
	14	int (*mapping_error)(dma_addr_t dma_addr);
	15	void* (alloc_coherent)(struct device dev, size_t size,
	16	dma_addr_t *dma_handle, gfp_t gfp);
	17	void (free_coherent)(struct device dev, size_t size,
	18	void *vaddr, dma_addr_t dma_handle);
	19	dma_addr_t (map_single)(struct device hwdev, void *ptr,
	20	size_t size, int direction);
	21	/* like map_single, but doesn't check the device mask */
	22	dma_addr_t (map_simple)(struct device hwdev, char *ptr,
	23	size_t size, int direction);
	24	void (unmap_single)(struct device dev, dma_addr_t addr,
	25	size_t size, int direction);
	26	void (sync_single_for_cpu)(struct device hwdev,
	27	dma_addr_t dma_handle, size_t size,
	28	int direction);
	29	void (sync_single_for_device)(struct device hwdev,
	30	dma_addr_t dma_handle, size_t size,
	31	int direction);
	32	void (sync_single_range_for_cpu)(struct device hwdev,
	33	dma_addr_t dma_handle, unsigned long offset,
	34	size_t size, int direction);
	35	void (sync_single_range_for_device)(struct device hwdev,
	36	dma_addr_t dma_handle, unsigned long offset,
	37	size_t size, int direction);
	38	void (sync_sg_for_cpu)(struct device hwdev,
	39	struct scatterlist *sg, int nelems,
	40	int direction);
	41	void (sync_sg_for_device)(struct device hwdev,
	42	struct scatterlist *sg, int nelems,
	43	int direction);
	44	int (map_sg)(struct device hwdev, struct scatterlist *sg,
	45	int nents, int direction);
	46	void (unmap_sg)(struct device hwdev,
	47	struct scatterlist *sg, int nents,
	48	int direction);
	49	int (dma_supported)(struct device hwdev, u64 mask);
	50	int is_phys;
	51	};
1da177e4	52
17a941d8	53	extern dma_addr_t bad_dma_address;
e6584504	54	extern const struct dma_mapping_ops* dma_ops;
17a941d8	55	extern int iommu_merge;
1da177e4	56
17a941d8 MBY	57	static inline int dma_mapping_error(dma_addr_t dma_addr)
	58	{
	59	if (dma_ops->mapping_error)
	60	return dma_ops->mapping_error(dma_addr);
1da177e4	61
17a941d8 MBY	62	return (dma_addr == bad_dma_address);
17a941d8 MBY	63	}
1da177e4	64
259886a7 JG	65	#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
	66	#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
	67
2fa8a050 JG	68	#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
	69	#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
	70
17a941d8 MBY	71	extern void dma_alloc_coherent(struct device dev, size_t size,
	72	dma_addr_t *dma_handle, gfp_t gfp);
	73	extern void dma_free_coherent(struct device dev, size_t size, void vaddr,
	74	dma_addr_t dma_handle);
1da177e4	75
17a941d8 MBY	76	static inline dma_addr_t
	77	dma_map_single(struct device hwdev, void ptr, size_t size,
	78	int direction)
1da177e4	79	{
a3c042a0	80	BUG_ON(!valid_dma_direction(direction));
17a941d8	81	return dma_ops->map_single(hwdev, ptr, size, direction);
1da177e4 LT	82	}
1da177e4 LT	83
17a941d8 MBY	84	static inline void
	85	dma_unmap_single(struct device *dev, dma_addr_t addr,size_t size,
	86	int direction)
1da177e4	87	{
a3c042a0	88	BUG_ON(!valid_dma_direction(direction));
17a941d8	89	dma_ops->unmap_single(dev, addr, size, direction);
1da177e4 LT	90	}
1da177e4 LT	91
1da177e4 LT	92	#define dma_map_page(dev,page,offset,size,dir) \
	93	dma_map_single((dev), page_address(page)+(offset), (size), (dir))
	94
17a941d8	95	#define dma_unmap_page dma_unmap_single
1da177e4	96
17a941d8 MBY	97	static inline void
	98	dma_sync_single_for_cpu(struct device *hwdev, dma_addr_t dma_handle,
	99	size_t size, int direction)
	100	{
a3c042a0	101	BUG_ON(!valid_dma_direction(direction));
17a941d8 MBY	102	if (dma_ops->sync_single_for_cpu)
	103	dma_ops->sync_single_for_cpu(hwdev, dma_handle, size,
	104	direction);
1da177e4 LT	105	flush_write_buffers();
	106	}
	107
17a941d8 MBY	108	static inline void
	109	dma_sync_single_for_device(struct device *hwdev, dma_addr_t dma_handle,
	110	size_t size, int direction)
1da177e4	111	{
a3c042a0	112	BUG_ON(!valid_dma_direction(direction));
17a941d8 MBY	113	if (dma_ops->sync_single_for_device)
	114	dma_ops->sync_single_for_device(hwdev, dma_handle, size,
	115	direction);
1da177e4 LT	116	flush_write_buffers();
	117	}
	118
17a941d8 MBY	119	static inline void
	120	dma_sync_single_range_for_cpu(struct device *hwdev, dma_addr_t dma_handle,
	121	unsigned long offset, size_t size, int direction)
8d15d19e	122	{
a3c042a0	123	BUG_ON(!valid_dma_direction(direction));
17a941d8 MBY	124	if (dma_ops->sync_single_range_for_cpu) {
	125	dma_ops->sync_single_range_for_cpu(hwdev, dma_handle, offset, size, direction);
	126	}
8d15d19e JL	127
	128	flush_write_buffers();
	129	}
	130
17a941d8 MBY	131	static inline void
	132	dma_sync_single_range_for_device(struct device *hwdev, dma_addr_t dma_handle,
	133	unsigned long offset, size_t size, int direction)
8d15d19e	134	{
a3c042a0	135	BUG_ON(!valid_dma_direction(direction));
17a941d8 MBY	136	if (dma_ops->sync_single_range_for_device)
	137	dma_ops->sync_single_range_for_device(hwdev, dma_handle,
	138	offset, size, direction);
8d15d19e JL	139
	140	flush_write_buffers();
	141	}
27183ebd	142
17a941d8 MBY	143	static inline void
	144	dma_sync_sg_for_cpu(struct device hwdev, struct scatterlist sg,
	145	int nelems, int direction)
1da177e4	146	{
a3c042a0	147	BUG_ON(!valid_dma_direction(direction));
17a941d8 MBY	148	if (dma_ops->sync_sg_for_cpu)
17a941d8 MBY	149	dma_ops->sync_sg_for_cpu(hwdev, sg, nelems, direction);
1da177e4 LT	150	flush_write_buffers();
	151	}
	152
17a941d8 MBY	153	static inline void
	154	dma_sync_sg_for_device(struct device hwdev, struct scatterlist sg,
	155	int nelems, int direction)
1da177e4	156	{
a3c042a0	157	BUG_ON(!valid_dma_direction(direction));
17a941d8 MBY	158	if (dma_ops->sync_sg_for_device) {
	159	dma_ops->sync_sg_for_device(hwdev, sg, nelems, direction);
	160	}
1da177e4 LT	161
	162	flush_write_buffers();
	163	}
	164
17a941d8 MBY	165	static inline int
	166	dma_map_sg(struct device hwdev, struct scatterlist sg, int nents, int direction)
	167	{
a3c042a0	168	BUG_ON(!valid_dma_direction(direction));
17a941d8 MBY	169	return dma_ops->map_sg(hwdev, sg, nents, direction);
17a941d8 MBY	170	}
1da177e4	171
17a941d8 MBY	172	static inline void
	173	dma_unmap_sg(struct device hwdev, struct scatterlist sg, int nents,
	174	int direction)
	175	{
a3c042a0	176	BUG_ON(!valid_dma_direction(direction));
17a941d8 MBY	177	dma_ops->unmap_sg(hwdev, sg, nents, direction);
17a941d8 MBY	178	}
1da177e4 LT	179
1da177e4 LT	180	extern int dma_supported(struct device *hwdev, u64 mask);
1da177e4	181
17a941d8 MBY	182	/* same for gart, swiotlb, and nommu */
17a941d8 MBY	183	static inline int dma_get_cache_alignment(void)
1da177e4	184	{
17a941d8	185	return boot_cpu_data.x86_clflush_size;
1da177e4 LT	186	}
1da177e4 LT	187
f67637ee	188	#define dma_is_consistent(d, h) 1
17a941d8 MBY	189
	190	extern int dma_set_mask(struct device *dev, u64 mask);
	191
	192	static inline void
d3fa72e4 RB	193	dma_cache_sync(struct device dev, void vaddr, size_t size,
d3fa72e4 RB	194	enum dma_data_direction dir)
1da177e4 LT	195	{
	196	flush_write_buffers();
	197	}
	198
17a941d8 MBY	199	extern struct device fallback_dev;
	200	extern int panic_on_overflow;
	201
	202	#endif /* _X8664_DMA_MAPPING_H */