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

/* linux/arch/arm/plat-samsung/s3c-dma-ops.c
 *
 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
 *		http://www.samsung.com
 *
 * Samsung S3C-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/slab.h>
#include <linux/types.h>
#include <linux/export.h>

#include <mach/dma.h>

struct cb_data {
	void (*fp) (void *);
	void *fp_param;
	unsigned ch;
	struct list_head node;
};

static LIST_HEAD(dma_list);

static void s3c_dma_cb(struct s3c2410_dma_chan *channel, void *param,
		       int size, enum s3c2410_dma_buffresult res)
{
	struct cb_data *data = param;

	data->fp(data->fp_param);
}

static unsigned s3c_dma_request(enum dma_ch dma_ch,
				struct samsung_dma_req *param,
				struct device *dev, char *ch_name)
{
	struct cb_data *data;

	if (s3c2410_dma_request(dma_ch, param->client, NULL) < 0) {
		s3c2410_dma_free(dma_ch, param->client);
		return 0;
	}

	if (param->cap == DMA_CYCLIC)
		s3c2410_dma_setflags(dma_ch, S3C2410_DMAF_CIRCULAR);

	data = kzalloc(sizeof(struct cb_data), GFP_KERNEL);
	data->ch = dma_ch;
	list_add_tail(&data->node, &dma_list);

	return (unsigned)dma_ch;
}

static int s3c_dma_release(unsigned ch, void *param)
{
	struct cb_data *data;

	list_for_each_entry(data, &dma_list, node)
		if (data->ch == ch)
			break;
	list_del(&data->node);

	s3c2410_dma_free(ch, param);
	kfree(data);

	return 0;
}

static int s3c_dma_config(unsigned ch, struct samsung_dma_config *param)
{
	s3c2410_dma_devconfig(ch, param->direction, param->fifo);
	s3c2410_dma_config(ch, param->width);

	return 0;
}

static int s3c_dma_prepare(unsigned ch, struct samsung_dma_prep *param)
{
	struct cb_data *data;
	int len = (param->cap == DMA_CYCLIC) ? param->period : param->len;

	list_for_each_entry(data, &dma_list, node)
		if (data->ch == ch)
			break;

	if (!data->fp) {
		s3c2410_dma_set_buffdone_fn(ch, s3c_dma_cb);
		data->fp = param->fp;
		data->fp_param = param->fp_param;
	}

	s3c2410_dma_enqueue(ch, (void *)data, param->buf, len);

	return 0;
}

static inline int s3c_dma_trigger(unsigned ch)
{
	return s3c2410_dma_ctrl(ch, S3C2410_DMAOP_START);
}

static inline int s3c_dma_started(unsigned ch)
{
	return s3c2410_dma_ctrl(ch, S3C2410_DMAOP_STARTED);
}

static inline int s3c_dma_flush(unsigned ch)
{
	return s3c2410_dma_ctrl(ch, S3C2410_DMAOP_FLUSH);
}

static inline int s3c_dma_stop(unsigned ch)
{
	return s3c2410_dma_ctrl(ch, S3C2410_DMAOP_STOP);
}

static struct samsung_dma_ops s3c_dma_ops = {
	.request	= s3c_dma_request,
	.release	= s3c_dma_release,
	.config		= s3c_dma_config,
	.prepare	= s3c_dma_prepare,
	.trigger	= s3c_dma_trigger,
	.started	= s3c_dma_started,
	.flush		= s3c_dma_flush,
	.stop		= s3c_dma_stop,
};

void *s3c_dma_get_ops(void)
{
	return &s3c_dma_ops;
}
EXPORT_SYMBOL(s3c_dma_get_ops);
Commit	Line	Data
c4e16625 BK	1	/* linux/arch/arm/plat-samsung/s3c-dma-ops.c
	2	*
	3	* Copyright (c) 2011 Samsung Electronics Co., Ltd.
	4	* http://www.samsung.com
	5	*
	6	* Samsung S3C-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/slab.h>
	16	#include <linux/types.h>
0c073e35	17	#include <linux/export.h>
c4e16625 BK	18
	19	#include <mach/dma.h>
	20
	21	struct cb_data {
	22	void (fp) (void );
	23	void *fp_param;
	24	unsigned ch;
	25	struct list_head node;
	26	};
	27
	28	static LIST_HEAD(dma_list);
	29
	30	static void s3c_dma_cb(struct s3c2410_dma_chan channel, void param,
	31	int size, enum s3c2410_dma_buffresult res)
	32	{
	33	struct cb_data *data = param;
	34
	35	data->fp(data->fp_param);
	36	}
	37
	38	static unsigned s3c_dma_request(enum dma_ch dma_ch,
e7ba5f1d PV	39	struct samsung_dma_req *param,
e7ba5f1d PV	40	struct device dev, char ch_name)
c4e16625 BK	41	{
	42	struct cb_data *data;
	43
fbb20e81 BK	44	if (s3c2410_dma_request(dma_ch, param->client, NULL) < 0) {
fbb20e81 BK	45	s3c2410_dma_free(dma_ch, param->client);
c4e16625 BK	46	return 0;
	47	}
	48
fbb20e81 BK	49	if (param->cap == DMA_CYCLIC)
	50	s3c2410_dma_setflags(dma_ch, S3C2410_DMAF_CIRCULAR);
	51
c4e16625 BK	52	data = kzalloc(sizeof(struct cb_data), GFP_KERNEL);
	53	data->ch = dma_ch;
	54	list_add_tail(&data->node, &dma_list);
	55
c4e16625 BK	56	return (unsigned)dma_ch;
	57	}
	58
fbb20e81	59	static int s3c_dma_release(unsigned ch, void *param)
c4e16625 BK	60	{
	61	struct cb_data *data;
	62
	63	list_for_each_entry(data, &dma_list, node)
	64	if (data->ch == ch)
	65	break;
	66	list_del(&data->node);
	67
fbb20e81	68	s3c2410_dma_free(ch, param);
c4e16625 BK	69	kfree(data);
	70
	71	return 0;
	72	}
	73
fbb20e81 BK	74	static int s3c_dma_config(unsigned ch, struct samsung_dma_config *param)
	75	{
	76	s3c2410_dma_devconfig(ch, param->direction, param->fifo);
	77	s3c2410_dma_config(ch, param->width);
	78
	79	return 0;
	80	}
	81
	82	static int s3c_dma_prepare(unsigned ch, struct samsung_dma_prep *param)
c4e16625 BK	83	{
c4e16625 BK	84	struct cb_data *data;
fbb20e81	85	int len = (param->cap == DMA_CYCLIC) ? param->period : param->len;
c4e16625 BK	86
	87	list_for_each_entry(data, &dma_list, node)
	88	if (data->ch == ch)
	89	break;
	90
	91	if (!data->fp) {
	92	s3c2410_dma_set_buffdone_fn(ch, s3c_dma_cb);
fbb20e81 BK	93	data->fp = param->fp;
fbb20e81 BK	94	data->fp_param = param->fp_param;
c4e16625 BK	95	}
c4e16625 BK	96
fbb20e81	97	s3c2410_dma_enqueue(ch, (void *)data, param->buf, len);
c4e16625 BK	98
	99	return 0;
	100	}
	101
	102	static inline int s3c_dma_trigger(unsigned ch)
	103	{
	104	return s3c2410_dma_ctrl(ch, S3C2410_DMAOP_START);
	105	}
	106
	107	static inline int s3c_dma_started(unsigned ch)
	108	{
	109	return s3c2410_dma_ctrl(ch, S3C2410_DMAOP_STARTED);
	110	}
	111
	112	static inline int s3c_dma_flush(unsigned ch)
	113	{
	114	return s3c2410_dma_ctrl(ch, S3C2410_DMAOP_FLUSH);
	115	}
	116
	117	static inline int s3c_dma_stop(unsigned ch)
	118	{
	119	return s3c2410_dma_ctrl(ch, S3C2410_DMAOP_STOP);
	120	}
	121
	122	static struct samsung_dma_ops s3c_dma_ops = {
	123	.request = s3c_dma_request,
	124	.release = s3c_dma_release,
fbb20e81	125	.config = s3c_dma_config,
c4e16625 BK	126	.prepare = s3c_dma_prepare,
	127	.trigger = s3c_dma_trigger,
	128	.started = s3c_dma_started,
	129	.flush = s3c_dma_flush,
	130	.stop = s3c_dma_stop,
	131	};
	132
	133	void *s3c_dma_get_ops(void)
	134	{
	135	return &s3c_dma_ops;
	136	}
	137	EXPORT_SYMBOL(s3c_dma_get_ops);