[mirror_ubuntu-bionic-kernel.git] / include / linux / pci-dma-compat.h

/* SPDX-License-Identifier: GPL-2.0 */
/* include this file if the platform implements the dma_ DMA Mapping API
 * and wants to provide the pci_ DMA Mapping API in terms of it */

#ifndef _ASM_GENERIC_PCI_DMA_COMPAT_H
#define _ASM_GENERIC_PCI_DMA_COMPAT_H

#include <linux/dma-mapping.h>

/* This defines the direction arg to the DMA mapping routines. */
#define PCI_DMA_BIDIRECTIONAL	0
#define PCI_DMA_TODEVICE	1
#define PCI_DMA_FROMDEVICE	2
#define PCI_DMA_NONE		3

static inline void *
pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
		     dma_addr_t *dma_handle)
{
	return dma_alloc_coherent(hwdev == NULL ? NULL : &hwdev->dev, size, dma_handle, GFP_ATOMIC);
}

static inline void *
pci_zalloc_consistent(struct pci_dev *hwdev, size_t size,
		      dma_addr_t *dma_handle)
{
	return dma_zalloc_coherent(hwdev == NULL ? NULL : &hwdev->dev,
				   size, dma_handle, GFP_ATOMIC);
}

static inline void
pci_free_consistent(struct pci_dev *hwdev, size_t size,
		    void *vaddr, dma_addr_t dma_handle)
{
	dma_free_coherent(hwdev == NULL ? NULL : &hwdev->dev, size, vaddr, dma_handle);
}

static inline dma_addr_t
pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction)
{
	return dma_map_single(hwdev == NULL ? NULL : &hwdev->dev, ptr, size, (enum dma_data_direction)direction);
}

static inline void
pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr,
		 size_t size, int direction)
{
	dma_unmap_single(hwdev == NULL ? NULL : &hwdev->dev, dma_addr, size, (enum dma_data_direction)direction);
}

static inline dma_addr_t
pci_map_page(struct pci_dev *hwdev, struct page *page,
	     unsigned long offset, size_t size, int direction)
{
	return dma_map_page(hwdev == NULL ? NULL : &hwdev->dev, page, offset, size, (enum dma_data_direction)direction);
}

static inline void
pci_unmap_page(struct pci_dev *hwdev, dma_addr_t dma_address,
	       size_t size, int direction)
{
	dma_unmap_page(hwdev == NULL ? NULL : &hwdev->dev, dma_address, size, (enum dma_data_direction)direction);
}

static inline int
pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg,
	   int nents, int direction)
{
	return dma_map_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nents, (enum dma_data_direction)direction);
}

static inline void
pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sg,
	     int nents, int direction)
{
	dma_unmap_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nents, (enum dma_data_direction)direction);
}

static inline void
pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle,
		    size_t size, int direction)
{
	dma_sync_single_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
}

static inline void
pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle,
		    size_t size, int direction)
{
	dma_sync_single_for_device(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
}

static inline void
pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg,
		int nelems, int direction)
{
	dma_sync_sg_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
}

static inline void
pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg,
		int nelems, int direction)
{
	dma_sync_sg_for_device(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
}

static inline int
pci_dma_mapping_error(struct pci_dev *pdev, dma_addr_t dma_addr)
{
	return dma_mapping_error(&pdev->dev, dma_addr);
}

#ifdef CONFIG_PCI
static inline int pci_set_dma_mask(struct pci_dev *dev, u64 mask)
{
	return dma_set_mask(&dev->dev, mask);
}

static inline int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
{
	return dma_set_coherent_mask(&dev->dev, mask);
}

static inline int pci_set_dma_max_seg_size(struct pci_dev *dev,
					   unsigned int size)
{
	return dma_set_max_seg_size(&dev->dev, size);
}

static inline int pci_set_dma_seg_boundary(struct pci_dev *dev,
					   unsigned long mask)
{
	return dma_set_seg_boundary(&dev->dev, mask);
}
#else
static inline int pci_set_dma_mask(struct pci_dev *dev, u64 mask)
{ return -EIO; }
static inline int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
{ return -EIO; }
static inline int pci_set_dma_max_seg_size(struct pci_dev *dev,
					   unsigned int size)
{ return -EIO; }
static inline int pci_set_dma_seg_boundary(struct pci_dev *dev,
					   unsigned long mask)
{ return -EIO; }
#endif

#endif
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
1da177e4 LT	2	/* include this file if the platform implements the dma_ DMA Mapping API
	3	* and wants to provide the pci_ DMA Mapping API in terms of it */
	4
	5	#ifndef _ASM_GENERIC_PCI_DMA_COMPAT_H
	6	#define _ASM_GENERIC_PCI_DMA_COMPAT_H
	7
	8	#include <linux/dma-mapping.h>
	9
fe537670 BH	10	/* This defines the direction arg to the DMA mapping routines. */
	11	#define PCI_DMA_BIDIRECTIONAL 0
	12	#define PCI_DMA_TODEVICE 1
	13	#define PCI_DMA_FROMDEVICE 2
	14	#define PCI_DMA_NONE 3
	15
1da177e4 LT	16	static inline void *
	17	pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
	18	dma_addr_t *dma_handle)
	19	{
	20	return dma_alloc_coherent(hwdev == NULL ? NULL : &hwdev->dev, size, dma_handle, GFP_ATOMIC);
	21	}
	22
82bf0baa JP	23	static inline void *
	24	pci_zalloc_consistent(struct pci_dev *hwdev, size_t size,
	25	dma_addr_t *dma_handle)
	26	{
	27	return dma_zalloc_coherent(hwdev == NULL ? NULL : &hwdev->dev,
	28	size, dma_handle, GFP_ATOMIC);
	29	}
	30
1da177e4 LT	31	static inline void
	32	pci_free_consistent(struct pci_dev *hwdev, size_t size,
	33	void *vaddr, dma_addr_t dma_handle)
	34	{
	35	dma_free_coherent(hwdev == NULL ? NULL : &hwdev->dev, size, vaddr, dma_handle);
	36	}
	37
	38	static inline dma_addr_t
	39	pci_map_single(struct pci_dev hwdev, void ptr, size_t size, int direction)
	40	{
	41	return dma_map_single(hwdev == NULL ? NULL : &hwdev->dev, ptr, size, (enum dma_data_direction)direction);
	42	}
	43
	44	static inline void
	45	pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr,
	46	size_t size, int direction)
	47	{
	48	dma_unmap_single(hwdev == NULL ? NULL : &hwdev->dev, dma_addr, size, (enum dma_data_direction)direction);
	49	}
	50
	51	static inline dma_addr_t
	52	pci_map_page(struct pci_dev hwdev, struct page page,
	53	unsigned long offset, size_t size, int direction)
	54	{
	55	return dma_map_page(hwdev == NULL ? NULL : &hwdev->dev, page, offset, size, (enum dma_data_direction)direction);
	56	}
	57
	58	static inline void
	59	pci_unmap_page(struct pci_dev *hwdev, dma_addr_t dma_address,
	60	size_t size, int direction)
	61	{
	62	dma_unmap_page(hwdev == NULL ? NULL : &hwdev->dev, dma_address, size, (enum dma_data_direction)direction);
	63	}
	64
	65	static inline int
	66	pci_map_sg(struct pci_dev hwdev, struct scatterlist sg,
	67	int nents, int direction)
	68	{
	69	return dma_map_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nents, (enum dma_data_direction)direction);
	70	}
	71
	72	static inline void
	73	pci_unmap_sg(struct pci_dev hwdev, struct scatterlist sg,
	74	int nents, int direction)
	75	{
	76	dma_unmap_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nents, (enum dma_data_direction)direction);
	77	}
	78
	79	static inline void
	80	pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle,
	81	size_t size, int direction)
	82	{
	83	dma_sync_single_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
	84	}
	85
	86	static inline void
	87	pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle,
	88	size_t size, int direction)
	89	{
	90	dma_sync_single_for_device(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
	91	}
	92
	93	static inline void
	94	pci_dma_sync_sg_for_cpu(struct pci_dev hwdev, struct scatterlist sg,
95	int nelems, int direction)
96	{
97	dma_sync_sg_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
98	}
99
100	static inline void
101	pci_dma_sync_sg_for_device(struct pci_dev hwdev, struct scatterlist sg,
102	int nelems, int direction)
103	{
104	dma_sync_sg_for_device(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
105	}
106
107	static inline int
8d8bb39b	108	pci_dma_mapping_error(struct pci_dev *pdev, dma_addr_t dma_addr)
1da177e4	109	{
8d8bb39b	110	return dma_mapping_error(&pdev->dev, dma_addr);
1da177e4 LT	111	}
1da177e4 LT	112
5f3cd1e0 FT	113	#ifdef CONFIG_PCI
	114	static inline int pci_set_dma_mask(struct pci_dev *dev, u64 mask)
	115	{
	116	return dma_set_mask(&dev->dev, mask);
	117	}
	118
	119	static inline int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
	120	{
	121	return dma_set_coherent_mask(&dev->dev, mask);
	122	}
fe537670 BH	123
	124	static inline int pci_set_dma_max_seg_size(struct pci_dev *dev,
	125	unsigned int size)
	126	{
	127	return dma_set_max_seg_size(&dev->dev, size);
	128	}
	129
	130	static inline int pci_set_dma_seg_boundary(struct pci_dev *dev,
	131	unsigned long mask)
	132	{
	133	return dma_set_seg_boundary(&dev->dev, mask);
	134	}
	135	#else
	136	static inline int pci_set_dma_mask(struct pci_dev *dev, u64 mask)
	137	{ return -EIO; }
	138	static inline int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
	139	{ return -EIO; }
	140	static inline int pci_set_dma_max_seg_size(struct pci_dev *dev,
	141	unsigned int size)
	142	{ return -EIO; }
	143	static inline int pci_set_dma_seg_boundary(struct pci_dev *dev,
	144	unsigned long mask)
	145	{ return -EIO; }
5f3cd1e0 FT	146	#endif
5f3cd1e0 FT	147
1da177e4	148	#endif