[mirror_ubuntu-artful-kernel.git] / lib / dma-noop.c

/*
 *	lib/dma-noop.c
 *
 * DMA operations that map to physical addresses without flushing memory.
 */
#include <linux/export.h>
#include <linux/mm.h>
#include <linux/dma-mapping.h>
#include <linux/scatterlist.h>
#include <linux/pfn.h>

static void *dma_noop_alloc(struct device *dev, size_t size,
			    dma_addr_t *dma_handle, gfp_t gfp,
			    unsigned long attrs)
{
	void *ret;

	ret = (void *)__get_free_pages(gfp, get_order(size));
	if (ret)
		*dma_handle = virt_to_phys(ret) - PFN_PHYS(dev->dma_pfn_offset);

	return ret;
}

static void dma_noop_free(struct device *dev, size_t size,
			  void *cpu_addr, dma_addr_t dma_addr,
			  unsigned long attrs)
{
	free_pages((unsigned long)cpu_addr, get_order(size));
}

static dma_addr_t dma_noop_map_page(struct device *dev, struct page *page,
				      unsigned long offset, size_t size,
				      enum dma_data_direction dir,
				      unsigned long attrs)
{
	return page_to_phys(page) + offset - PFN_PHYS(dev->dma_pfn_offset);
}

static int dma_noop_map_sg(struct device *dev, struct scatterlist *sgl, int nents,
			     enum dma_data_direction dir,
			     unsigned long attrs)
{
	int i;
	struct scatterlist *sg;

	for_each_sg(sgl, sg, nents, i) {
		dma_addr_t offset = PFN_PHYS(dev->dma_pfn_offset);
		void *va;

		BUG_ON(!sg_page(sg));
		va = sg_virt(sg);
		sg_dma_address(sg) = (dma_addr_t)virt_to_phys(va) - offset;
		sg_dma_len(sg) = sg->length;
	}

	return nents;
}

const struct dma_map_ops dma_noop_ops = {
	.alloc			= dma_noop_alloc,
	.free			= dma_noop_free,
	.map_page		= dma_noop_map_page,
	.map_sg			= dma_noop_map_sg,
};

EXPORT_SYMBOL(dma_noop_ops);
Commit	Line	Data
a8463d4b CB	1	/*
	2	* lib/dma-noop.c
	3	*
1eec9e2b	4	* DMA operations that map to physical addresses without flushing memory.
a8463d4b CB	5	*/
	6	#include <linux/export.h>
	7	#include <linux/mm.h>
	8	#include <linux/dma-mapping.h>
	9	#include <linux/scatterlist.h>
25f1e188	10	#include <linux/pfn.h>
a8463d4b CB	11
	12	static void dma_noop_alloc(struct device dev, size_t size,
	13	dma_addr_t *dma_handle, gfp_t gfp,
00085f1e	14	unsigned long attrs)
a8463d4b CB	15	{
	16	void *ret;
	17
	18	ret = (void *)__get_free_pages(gfp, get_order(size));
	19	if (ret)
25f1e188 VM	20	*dma_handle = virt_to_phys(ret) - PFN_PHYS(dev->dma_pfn_offset);
25f1e188 VM	21
a8463d4b CB	22	return ret;
	23	}
	24
	25	static void dma_noop_free(struct device *dev, size_t size,
	26	void *cpu_addr, dma_addr_t dma_addr,
00085f1e	27	unsigned long attrs)
a8463d4b CB	28	{
	29	free_pages((unsigned long)cpu_addr, get_order(size));
	30	}
	31
	32	static dma_addr_t dma_noop_map_page(struct device dev, struct page page,
	33	unsigned long offset, size_t size,
	34	enum dma_data_direction dir,
00085f1e	35	unsigned long attrs)
a8463d4b	36	{
25f1e188	37	return page_to_phys(page) + offset - PFN_PHYS(dev->dma_pfn_offset);
a8463d4b CB	38	}
	39
	40	static int dma_noop_map_sg(struct device dev, struct scatterlist sgl, int nents,
00085f1e KK	41	enum dma_data_direction dir,
00085f1e KK	42	unsigned long attrs)
a8463d4b CB	43	{
	44	int i;
	45	struct scatterlist *sg;
	46
	47	for_each_sg(sgl, sg, nents, i) {
25f1e188	48	dma_addr_t offset = PFN_PHYS(dev->dma_pfn_offset);
a8463d4b CB	49	void *va;
	50
	51	BUG_ON(!sg_page(sg));
	52	va = sg_virt(sg);
25f1e188	53	sg_dma_address(sg) = (dma_addr_t)virt_to_phys(va) - offset;
a8463d4b CB	54	sg_dma_len(sg) = sg->length;
	55	}
	56
	57	return nents;
	58	}
	59
5299709d	60	const struct dma_map_ops dma_noop_ops = {
a8463d4b CB	61	.alloc = dma_noop_alloc,
	62	.free = dma_noop_free,
	63	.map_page = dma_noop_map_page,
	64	.map_sg = dma_noop_map_sg,
a8463d4b CB	65	};
	66
	67	EXPORT_SYMBOL(dma_noop_ops);