[deliverable/linux.git] / arch / c6x / kernel / dma.c

/*
 *  Copyright (C) 2011 Texas Instruments Incorporated
 *  Author: Mark Salter <msalter@redhat.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 */
#include <linux/module.h>
#include <linux/dma-mapping.h>
#include <linux/mm.h>
#include <linux/mm_types.h>
#include <linux/scatterlist.h>

#include <asm/cacheflush.h>

static void c6x_dma_sync(dma_addr_t handle, size_t size,
			 enum dma_data_direction dir)
{
	unsigned long paddr = handle;

	BUG_ON(!valid_dma_direction(dir));

	switch (dir) {
	case DMA_FROM_DEVICE:
		L2_cache_block_invalidate(paddr, paddr + size);
		break;
	case DMA_TO_DEVICE:
		L2_cache_block_writeback(paddr, paddr + size);
		break;
	case DMA_BIDIRECTIONAL:
		L2_cache_block_writeback_invalidate(paddr, paddr + size);
		break;
	default:
		break;
	}
}

static dma_addr_t c6x_dma_map_page(struct device *dev, struct page *page,
		unsigned long offset, size_t size, enum dma_data_direction dir,
		struct dma_attrs *attrs)
{
	dma_addr_t handle = virt_to_phys(page_address(page) + offset);

	c6x_dma_sync(handle, size, dir);
	return handle;
}

static void c6x_dma_unmap_page(struct device *dev, dma_addr_t handle,
		size_t size, enum dma_data_direction dir, struct dma_attrs *attrs)
{
	c6x_dma_sync(handle, size, dir);
}

static int c6x_dma_map_sg(struct device *dev, struct scatterlist *sglist,
		int nents, enum dma_data_direction dir, struct dma_attrs *attrs)
{
	struct scatterlist *sg;
	int i;

	for_each_sg(sglist, sg, nents, i) {
		sg->dma_address = sg_phys(sg);
		c6x_dma_sync(sg->dma_address, sg->length, dir);
	}

	return nents;
}

static void c6x_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
		  int nents, enum dma_data_direction dir,
		  struct dma_attrs *attrs)
{
	struct scatterlist *sg;
	int i;

	for_each_sg(sglist, sg, nents, i)
		c6x_dma_sync(sg_dma_address(sg), sg->length, dir);

}

static void c6x_dma_sync_single_for_cpu(struct device *dev, dma_addr_t handle,
		size_t size, enum dma_data_direction dir)
{
	c6x_dma_sync(handle, size, dir);

}

static void c6x_dma_sync_single_for_device(struct device *dev,
		dma_addr_t handle, size_t size, enum dma_data_direction dir)
{
	c6x_dma_sync(handle, size, dir);

}

static void c6x_dma_sync_sg_for_cpu(struct device *dev,
		struct scatterlist *sglist, int nents,
		enum dma_data_direction dir)
{
	struct scatterlist *sg;
	int i;

	for_each_sg(sglist, sg, nents, i)
		c6x_dma_sync_single_for_cpu(dev, sg_dma_address(sg),
					sg->length, dir);

}

static void c6x_dma_sync_sg_for_device(struct device *dev,
		struct scatterlist *sglist, int nents,
		enum dma_data_direction dir)
{
	struct scatterlist *sg;
	int i;

	for_each_sg(sglist, sg, nents, i)
		c6x_dma_sync_single_for_device(dev, sg_dma_address(sg),
					   sg->length, dir);

}

struct dma_map_ops c6x_dma_ops = {
	.alloc			= c6x_dma_alloc,
	.free			= c6x_dma_free,
	.map_page		= c6x_dma_map_page,
	.unmap_page		= c6x_dma_unmap_page,
	.map_sg			= c6x_dma_map_sg,
	.unmap_sg		= c6x_dma_unmap_sg,
	.sync_single_for_device	= c6x_dma_sync_single_for_device,
	.sync_single_for_cpu	= c6x_dma_sync_single_for_cpu,
	.sync_sg_for_device	= c6x_dma_sync_sg_for_device,
	.sync_sg_for_cpu	= c6x_dma_sync_sg_for_cpu,
};
EXPORT_SYMBOL(c6x_dma_ops);

/* Number of entries preallocated for DMA-API debugging */
#define PREALLOC_DMA_DEBUG_ENTRIES (1 << 16)

static int __init dma_init(void)
{
	dma_debug_init(PREALLOC_DMA_DEBUG_ENTRIES);

	return 0;
}
fs_initcall(dma_init);
Commit	Line	Data
	1	/*
	2	* Copyright (C) 2011 Texas Instruments Incorporated
	3	* Author: Mark Salter <msalter@redhat.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 as
	7	* published by the Free Software Foundation.
	8	*/
	9	#include <linux/module.h>
	10	#include <linux/dma-mapping.h>
	11	#include <linux/mm.h>
	12	#include <linux/mm_types.h>
	13	#include <linux/scatterlist.h>
	14
	15	#include <asm/cacheflush.h>
	16
	17	static void c6x_dma_sync(dma_addr_t handle, size_t size,
	18	enum dma_data_direction dir)
	19	{
	20	unsigned long paddr = handle;
	21
	22	BUG_ON(!valid_dma_direction(dir));
	23
	24	switch (dir) {
	25	case DMA_FROM_DEVICE:
	26	L2_cache_block_invalidate(paddr, paddr + size);
	27	break;
	28	case DMA_TO_DEVICE:
	29	L2_cache_block_writeback(paddr, paddr + size);
	30	break;
	31	case DMA_BIDIRECTIONAL:
	32	L2_cache_block_writeback_invalidate(paddr, paddr + size);
	33	break;
	34	default:
	35	break;
	36	}
	37	}
	38
	39	static dma_addr_t c6x_dma_map_page(struct device dev, struct page page,
	40	unsigned long offset, size_t size, enum dma_data_direction dir,
	41	struct dma_attrs *attrs)
	42	{
	43	dma_addr_t handle = virt_to_phys(page_address(page) + offset);
	44
	45	c6x_dma_sync(handle, size, dir);
	46	return handle;
	47	}
	48
	49	static void c6x_dma_unmap_page(struct device *dev, dma_addr_t handle,
	50	size_t size, enum dma_data_direction dir, struct dma_attrs *attrs)
	51	{
	52	c6x_dma_sync(handle, size, dir);
	53	}
	54
	55	static int c6x_dma_map_sg(struct device dev, struct scatterlist sglist,
	56	int nents, enum dma_data_direction dir, struct dma_attrs *attrs)
	57	{
	58	struct scatterlist *sg;
	59	int i;
	60
	61	for_each_sg(sglist, sg, nents, i) {
	62	sg->dma_address = sg_phys(sg);
	63	c6x_dma_sync(sg->dma_address, sg->length, dir);
	64	}
	65
	66	return nents;
	67	}
	68
	69	static void c6x_dma_unmap_sg(struct device dev, struct scatterlist sglist,
	70	int nents, enum dma_data_direction dir,
	71	struct dma_attrs *attrs)
	72	{
	73	struct scatterlist *sg;
	74	int i;
	75
	76	for_each_sg(sglist, sg, nents, i)
	77	c6x_dma_sync(sg_dma_address(sg), sg->length, dir);
	78
	79	}
	80
	81	static void c6x_dma_sync_single_for_cpu(struct device *dev, dma_addr_t handle,
	82	size_t size, enum dma_data_direction dir)
	83	{
	84	c6x_dma_sync(handle, size, dir);
	85
	86	}
	87
	88	static void c6x_dma_sync_single_for_device(struct device *dev,
	89	dma_addr_t handle, size_t size, enum dma_data_direction dir)
	90	{
	91	c6x_dma_sync(handle, size, dir);
	92
	93	}
	94
	95	static void c6x_dma_sync_sg_for_cpu(struct device *dev,
	96	struct scatterlist *sglist, int nents,
	97	enum dma_data_direction dir)
	98	{
	99	struct scatterlist *sg;
	100	int i;
	101
	102	for_each_sg(sglist, sg, nents, i)
	103	c6x_dma_sync_single_for_cpu(dev, sg_dma_address(sg),
	104	sg->length, dir);
	105
	106	}
	107
	108	static void c6x_dma_sync_sg_for_device(struct device *dev,
	109	struct scatterlist *sglist, int nents,
	110	enum dma_data_direction dir)
	111	{
	112	struct scatterlist *sg;
	113	int i;
	114
	115	for_each_sg(sglist, sg, nents, i)
	116	c6x_dma_sync_single_for_device(dev, sg_dma_address(sg),
	117	sg->length, dir);
	118
	119	}
	120
	121	struct dma_map_ops c6x_dma_ops = {
	122	.alloc = c6x_dma_alloc,
	123	.free = c6x_dma_free,
	124	.map_page = c6x_dma_map_page,
	125	.unmap_page = c6x_dma_unmap_page,
	126	.map_sg = c6x_dma_map_sg,
	127	.unmap_sg = c6x_dma_unmap_sg,
	128	.sync_single_for_device = c6x_dma_sync_single_for_device,
	129	.sync_single_for_cpu = c6x_dma_sync_single_for_cpu,
	130	.sync_sg_for_device = c6x_dma_sync_sg_for_device,
	131	.sync_sg_for_cpu = c6x_dma_sync_sg_for_cpu,
	132	};
	133	EXPORT_SYMBOL(c6x_dma_ops);
	134
	135	/* Number of entries preallocated for DMA-API debugging */
	136	#define PREALLOC_DMA_DEBUG_ENTRIES (1 << 16)
	137
	138	static int __init dma_init(void)
	139	{
	140	dma_debug_init(PREALLOC_DMA_DEBUG_ENTRIES);
	141
	142	return 0;
	143	}
	144	fs_initcall(dma_init);