[linux-2.6-block.git] / include / linux / swiotlb.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __LINUX_SWIOTLB_H
#define __LINUX_SWIOTLB_H

#include <linux/dma-direction.h>
#include <linux/init.h>
#include <linux/types.h>

struct device;
struct page;
struct scatterlist;

enum swiotlb_force {
	SWIOTLB_NORMAL,		/* Default - depending on HW DMA mask etc. */
	SWIOTLB_FORCE,		/* swiotlb=force */
	SWIOTLB_NO_FORCE,	/* swiotlb=noforce */
};

extern enum swiotlb_force swiotlb_force;

/*
 * Maximum allowable number of contiguous slabs to map,
 * must be a power of 2.  What is the appropriate value ?
 * The complexity of {map,unmap}_single is linearly dependent on this value.
 */
#define IO_TLB_SEGSIZE	128

/*
 * log of the size of each IO TLB slab.  The number of slabs is command line
 * controllable.
 */
#define IO_TLB_SHIFT 11

extern void swiotlb_init(int verbose);
int swiotlb_init_with_tbl(char *tlb, unsigned long nslabs, int verbose);
extern unsigned long swiotlb_nr_tbl(void);
unsigned long swiotlb_size_or_default(void);
extern int swiotlb_late_init_with_tbl(char *tlb, unsigned long nslabs);
extern void __init swiotlb_update_mem_attributes(void);

/*
 * Enumeration for sync targets
 */
enum dma_sync_target {
	SYNC_FOR_CPU = 0,
	SYNC_FOR_DEVICE = 1,
};

/* define the last possible byte of physical address space as a mapping error */
#define SWIOTLB_MAP_ERROR (~(phys_addr_t)0x0)

extern phys_addr_t swiotlb_tbl_map_single(struct device *hwdev,
					  dma_addr_t tbl_dma_addr,
					  phys_addr_t phys, size_t size,
					  enum dma_data_direction dir,
					  unsigned long attrs);

extern void swiotlb_tbl_unmap_single(struct device *hwdev,
				     phys_addr_t tlb_addr,
				     size_t size, enum dma_data_direction dir,
				     unsigned long attrs);

extern void swiotlb_tbl_sync_single(struct device *hwdev,
				    phys_addr_t tlb_addr,
				    size_t size, enum dma_data_direction dir,
				    enum dma_sync_target target);

/* Accessory functions. */

void *swiotlb_alloc(struct device *hwdev, size_t size, dma_addr_t *dma_handle,
		gfp_t flags, unsigned long attrs);
void swiotlb_free(struct device *dev, size_t size, void *vaddr,
		dma_addr_t dma_addr, unsigned long attrs);

extern dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
				   unsigned long offset, size_t size,
				   enum dma_data_direction dir,
				   unsigned long attrs);
extern void swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
			       size_t size, enum dma_data_direction dir,
			       unsigned long attrs);

extern int
swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems,
		     enum dma_data_direction dir,
		     unsigned long attrs);

extern void
swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
		       int nelems, enum dma_data_direction dir,
		       unsigned long attrs);

extern void
swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr,
			    size_t size, enum dma_data_direction dir);

extern void
swiotlb_sync_sg_for_cpu(struct device *hwdev, struct scatterlist *sg,
			int nelems, enum dma_data_direction dir);

extern void
swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr,
			       size_t size, enum dma_data_direction dir);

extern void
swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg,
			   int nelems, enum dma_data_direction dir);

extern int
swiotlb_dma_mapping_error(struct device *hwdev, dma_addr_t dma_addr);

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

#ifdef CONFIG_SWIOTLB
extern void __init swiotlb_exit(void);
unsigned int swiotlb_max_segment(void);
#else
static inline void swiotlb_exit(void) { }
static inline unsigned int swiotlb_max_segment(void) { return 0; }
#endif

extern void swiotlb_print_info(void);
extern int is_swiotlb_buffer(phys_addr_t paddr);
extern void swiotlb_set_max_segment(unsigned int);

extern const struct dma_map_ops swiotlb_dma_ops;

#endif /* __LINUX_SWIOTLB_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
1648993f JR	2	#ifndef __LINUX_SWIOTLB_H
	3	#define __LINUX_SWIOTLB_H
	4
38674442 TR	5	#include <linux/dma-direction.h>
38674442 TR	6	#include <linux/init.h>
1648993f JR	7	#include <linux/types.h>
	8
	9	struct device;
38674442	10	struct page;
1648993f JR	11	struct scatterlist;
1648993f JR	12
ae7871be GU	13	enum swiotlb_force {
	14	SWIOTLB_NORMAL, /* Default - depending on HW DMA mask etc. */
	15	SWIOTLB_FORCE, /* swiotlb=force */
fff5d992	16	SWIOTLB_NO_FORCE, /* swiotlb=noforce */
ae7871be GU	17	};
	18
	19	extern enum swiotlb_force swiotlb_force;
6959450e	20
0016fdee IC	21	/*
	22	* Maximum allowable number of contiguous slabs to map,
	23	* must be a power of 2. What is the appropriate value ?
	24	* The complexity of {map,unmap}_single is linearly dependent on this value.
	25	*/
	26	#define IO_TLB_SEGSIZE 128
	27
0016fdee IC	28	/*
	29	* log of the size of each IO TLB slab. The number of slabs is command line
	30	* controllable.
	31	*/
	32	#define IO_TLB_SHIFT 11
	33
ad32e8cb	34	extern void swiotlb_init(int verbose);
ac2cbab2	35	int swiotlb_init_with_tbl(char *tlb, unsigned long nslabs, int verbose);
f21ffe9f	36	extern unsigned long swiotlb_nr_tbl(void);
c729de8f	37	unsigned long swiotlb_size_or_default(void);
74838b75	38	extern int swiotlb_late_init_with_tbl(char *tlb, unsigned long nslabs);
c7753208	39	extern void __init swiotlb_update_mem_attributes(void);
1648993f	40
d7ef1533 KRW	41	/*
	42	* Enumeration for sync targets
	43	*/
	44	enum dma_sync_target {
	45	SYNC_FOR_CPU = 0,
	46	SYNC_FOR_DEVICE = 1,
	47	};
e05ed4d1 AD	48
	49	/* define the last possible byte of physical address space as a mapping error */
	50	#define SWIOTLB_MAP_ERROR (~(phys_addr_t)0x0)
	51
	52	extern phys_addr_t swiotlb_tbl_map_single(struct device *hwdev,
	53	dma_addr_t tbl_dma_addr,
	54	phys_addr_t phys, size_t size,
0443fa00 AD	55	enum dma_data_direction dir,
0443fa00 AD	56	unsigned long attrs);
d7ef1533	57
61ca08c3 AD	58	extern void swiotlb_tbl_unmap_single(struct device *hwdev,
61ca08c3 AD	59	phys_addr_t tlb_addr,
0443fa00 AD	60	size_t size, enum dma_data_direction dir,
0443fa00 AD	61	unsigned long attrs);
d7ef1533	62
fbfda893 AD	63	extern void swiotlb_tbl_sync_single(struct device *hwdev,
fbfda893 AD	64	phys_addr_t tlb_addr,
d7ef1533 KRW	65	size_t size, enum dma_data_direction dir,
	66	enum dma_sync_target target);
	67
	68	/* Accessory functions. */
251533eb CH	69
	70	void swiotlb_alloc(struct device hwdev, size_t size, dma_addr_t *dma_handle,
	71	gfp_t flags, unsigned long attrs);
	72	void swiotlb_free(struct device dev, size_t size, void vaddr,
	73	dma_addr_t dma_addr, unsigned long attrs);
	74
f98eee8e FT	75	extern dma_addr_t swiotlb_map_page(struct device dev, struct page page,
	76	unsigned long offset, size_t size,
	77	enum dma_data_direction dir,
00085f1e	78	unsigned long attrs);
f98eee8e FT	79	extern void swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
f98eee8e FT	80	size_t size, enum dma_data_direction dir,
00085f1e	81	unsigned long attrs);
1648993f	82
1648993f JR	83	extern int
1648993f JR	84	swiotlb_map_sg_attrs(struct device hwdev, struct scatterlist sgl, int nelems,
00085f1e KK	85	enum dma_data_direction dir,
00085f1e KK	86	unsigned long attrs);
1648993f JR	87
	88	extern void
	89	swiotlb_unmap_sg_attrs(struct device hwdev, struct scatterlist sgl,
160c1d8e	90	int nelems, enum dma_data_direction dir,
00085f1e	91	unsigned long attrs);
1648993f JR	92
	93	extern void
	94	swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr,
160c1d8e	95	size_t size, enum dma_data_direction dir);
1648993f JR	96
	97	extern void
	98	swiotlb_sync_sg_for_cpu(struct device hwdev, struct scatterlist sg,
160c1d8e	99	int nelems, enum dma_data_direction dir);
1648993f JR	100
	101	extern void
	102	swiotlb_sync_single_for_device(struct device *hwdev, dma_addr_t dev_addr,
160c1d8e	103	size_t size, enum dma_data_direction dir);
1648993f JR	104
	105	extern void
	106	swiotlb_sync_sg_for_device(struct device hwdev, struct scatterlist sg,
160c1d8e	107	int nelems, enum dma_data_direction dir);
1648993f	108
1648993f JR	109	extern int
	110	swiotlb_dma_mapping_error(struct device *hwdev, dma_addr_t dma_addr);
	111
	112	extern int
	113	swiotlb_dma_supported(struct device *hwdev, u64 mask);
	114
5740afdb	115	#ifdef CONFIG_SWIOTLB
7f2c8bbd	116	extern void __init swiotlb_exit(void);
7453c549	117	unsigned int swiotlb_max_segment(void);
5740afdb	118	#else
7f2c8bbd	119	static inline void swiotlb_exit(void) { }
7453c549	120	static inline unsigned int swiotlb_max_segment(void) { return 0; }
5740afdb FT	121	#endif
5740afdb FT	122
ad32e8cb	123	extern void swiotlb_print_info(void);
9c5a3621	124	extern int is_swiotlb_buffer(phys_addr_t paddr);
7453c549	125	extern void swiotlb_set_max_segment(unsigned int);
9c5a3621	126
251533eb CH	127	extern const struct dma_map_ops swiotlb_dma_ops;
251533eb CH	128
1648993f	129	#endif /* __LINUX_SWIOTLB_H */