[deliverable/linux.git] / arch / arm / plat-samsung / dma-ops.c

/* linux/arch/arm/plat-samsung/dma-ops.c
 *
 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
 *		http://www.samsung.com
 *
 * Samsung DMA Operations
 *
 * 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/kernel.h>
#include <linux/errno.h>
#include <linux/amba/pl330.h>
#include <linux/scatterlist.h>

#include <mach/dma.h>

static inline bool pl330_filter(struct dma_chan *chan, void *param)
{
	struct dma_pl330_peri *peri = chan->private;
	return peri->peri_id == (unsigned)param;
}

static unsigned samsung_dmadev_request(enum dma_ch dma_ch,
				struct samsung_dma_info *info)
{
	struct dma_chan *chan;
	dma_cap_mask_t mask;
	struct dma_slave_config slave_config;

	dma_cap_zero(mask);
	dma_cap_set(info->cap, mask);

	chan = dma_request_channel(mask, pl330_filter, (void *)dma_ch);

	if (info->direction == DMA_FROM_DEVICE) {
		memset(&slave_config, 0, sizeof(struct dma_slave_config));
		slave_config.direction = info->direction;
		slave_config.src_addr = info->fifo;
		slave_config.src_addr_width = info->width;
		slave_config.src_maxburst = 1;
		dmaengine_slave_config(chan, &slave_config);
	} else if (info->direction == DMA_TO_DEVICE) {
		memset(&slave_config, 0, sizeof(struct dma_slave_config));
		slave_config.direction = info->direction;
		slave_config.dst_addr = info->fifo;
		slave_config.dst_addr_width = info->width;
		slave_config.dst_maxburst = 1;
		dmaengine_slave_config(chan, &slave_config);
	}

	return (unsigned)chan;
}

static int samsung_dmadev_release(unsigned ch,
			struct s3c2410_dma_client *client)
{
	dma_release_channel((struct dma_chan *)ch);

	return 0;
}

static int samsung_dmadev_prepare(unsigned ch,
			struct samsung_dma_prep_info *info)
{
	struct scatterlist sg;
	struct dma_chan *chan = (struct dma_chan *)ch;
	struct dma_async_tx_descriptor *desc;

	switch (info->cap) {
	case DMA_SLAVE:
		sg_init_table(&sg, 1);
		sg_dma_len(&sg) = info->len;
		sg_set_page(&sg, pfn_to_page(PFN_DOWN(info->buf)),
			    info->len, offset_in_page(info->buf));
		sg_dma_address(&sg) = info->buf;

		desc = chan->device->device_prep_slave_sg(chan,
			&sg, 1, info->direction, DMA_PREP_INTERRUPT);
		break;
	case DMA_CYCLIC:
		desc = chan->device->device_prep_dma_cyclic(chan,
			info->buf, info->len, info->period, info->direction);
		break;
	default:
		dev_err(&chan->dev->device, "unsupported format\n");
		return -EFAULT;
	}

	if (!desc) {
		dev_err(&chan->dev->device, "cannot prepare cyclic dma\n");
		return -EFAULT;
	}

	desc->callback = info->fp;
	desc->callback_param = info->fp_param;

	dmaengine_submit((struct dma_async_tx_descriptor *)desc);

	return 0;
}

static inline int samsung_dmadev_trigger(unsigned ch)
{
	dma_async_issue_pending((struct dma_chan *)ch);

	return 0;
}

static inline int samsung_dmadev_flush(unsigned ch)
{
	return dmaengine_terminate_all((struct dma_chan *)ch);
}

struct samsung_dma_ops dmadev_ops = {
	.request	= samsung_dmadev_request,
	.release	= samsung_dmadev_release,
	.prepare	= samsung_dmadev_prepare,
	.trigger	= samsung_dmadev_trigger,
	.started	= NULL,
	.flush		= samsung_dmadev_flush,
	.stop		= samsung_dmadev_flush,
};

void *samsung_dmadev_get_ops(void)
{
	return &dmadev_ops;
}
EXPORT_SYMBOL(samsung_dmadev_get_ops);
Commit	Line	Data
c4e16625 BK	1	/* linux/arch/arm/plat-samsung/dma-ops.c
	2	*
	3	* Copyright (c) 2011 Samsung Electronics Co., Ltd.
	4	* http://www.samsung.com
	5	*
	6	* Samsung DMA Operations
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*/
	12
	13	#include <linux/kernel.h>
	14	#include <linux/errno.h>
	15	#include <linux/amba/pl330.h>
	16	#include <linux/scatterlist.h>
	17
	18	#include <mach/dma.h>
	19
	20	static inline bool pl330_filter(struct dma_chan chan, void param)
	21	{
	22	struct dma_pl330_peri *peri = chan->private;
	23	return peri->peri_id == (unsigned)param;
	24	}
	25
	26	static unsigned samsung_dmadev_request(enum dma_ch dma_ch,
	27	struct samsung_dma_info *info)
	28	{
	29	struct dma_chan *chan;
	30	dma_cap_mask_t mask;
	31	struct dma_slave_config slave_config;
	32
	33	dma_cap_zero(mask);
	34	dma_cap_set(info->cap, mask);
	35
	36	chan = dma_request_channel(mask, pl330_filter, (void *)dma_ch);
	37
	38	if (info->direction == DMA_FROM_DEVICE) {
	39	memset(&slave_config, 0, sizeof(struct dma_slave_config));
	40	slave_config.direction = info->direction;
	41	slave_config.src_addr = info->fifo;
	42	slave_config.src_addr_width = info->width;
	43	slave_config.src_maxburst = 1;
	44	dmaengine_slave_config(chan, &slave_config);
	45	} else if (info->direction == DMA_TO_DEVICE) {
	46	memset(&slave_config, 0, sizeof(struct dma_slave_config));
	47	slave_config.direction = info->direction;
	48	slave_config.dst_addr = info->fifo;
	49	slave_config.dst_addr_width = info->width;
	50	slave_config.dst_maxburst = 1;
	51	dmaengine_slave_config(chan, &slave_config);
	52	}
	53
	54	return (unsigned)chan;
	55	}
	56
	57	static int samsung_dmadev_release(unsigned ch,
	58	struct s3c2410_dma_client *client)
	59	{
	60	dma_release_channel((struct dma_chan *)ch);
	61
	62	return 0;
	63	}
	64
65	static int samsung_dmadev_prepare(unsigned ch,
66	struct samsung_dma_prep_info *info)
67	{
68	struct scatterlist sg;
69	struct dma_chan chan = (struct dma_chan )ch;
70	struct dma_async_tx_descriptor *desc;
71
72	switch (info->cap) {
73	case DMA_SLAVE:
74	sg_init_table(&sg, 1);
75	sg_dma_len(&sg) = info->len;
76	sg_set_page(&sg, pfn_to_page(PFN_DOWN(info->buf)),
77	info->len, offset_in_page(info->buf));
78	sg_dma_address(&sg) = info->buf;
79
80	desc = chan->device->device_prep_slave_sg(chan,
81	&sg, 1, info->direction, DMA_PREP_INTERRUPT);
82	break;
83	case DMA_CYCLIC:
84	desc = chan->device->device_prep_dma_cyclic(chan,
85	info->buf, info->len, info->period, info->direction);
86	break;
87	default:
88	dev_err(&chan->dev->device, "unsupported format\n");
89	return -EFAULT;
90	}
91
92	if (!desc) {
93	dev_err(&chan->dev->device, "cannot prepare cyclic dma\n");
94	return -EFAULT;
95	}
96
97	desc->callback = info->fp;
98	desc->callback_param = info->fp_param;
99
100	dmaengine_submit((struct dma_async_tx_descriptor *)desc);
101
102	return 0;
103	}
104
105	static inline int samsung_dmadev_trigger(unsigned ch)
106	{
107	dma_async_issue_pending((struct dma_chan *)ch);
108
109	return 0;
110	}
111
112	static inline int samsung_dmadev_flush(unsigned ch)
113	{
114	return dmaengine_terminate_all((struct dma_chan *)ch);
115	}
116
117	struct samsung_dma_ops dmadev_ops = {
118	.request = samsung_dmadev_request,
119	.release = samsung_dmadev_release,
120	.prepare = samsung_dmadev_prepare,
121	.trigger = samsung_dmadev_trigger,
122	.started = NULL,
123	.flush = samsung_dmadev_flush,
124	.stop = samsung_dmadev_flush,
125	};
126
127	void *samsung_dmadev_get_ops(void)
128	{
129	return &dmadev_ops;
130	}
131	EXPORT_SYMBOL(samsung_dmadev_get_ops);