[net-next-2.6.git] / arch / arm / mach-ep93xx / dma-m2p.c

/*
 * arch/arm/mach-ep93xx/dma-m2p.c
 * M2P DMA handling for Cirrus EP93xx chips.
 *
 * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
 * Copyright (C) 2006 Applied Data Systems
 *
 * Copyright (C) 2009 Ryan Mallon <ryan@bluewatersys.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 */

/*
 * On the EP93xx chip the following peripherals my be allocated to the 10
 * Memory to Internal Peripheral (M2P) channels (5 transmit + 5 receive).
 *
 *	I2S	contains 3 Tx and 3 Rx DMA Channels
 *	AAC	contains 3 Tx and 3 Rx DMA Channels
 *	UART1	contains 1 Tx and 1 Rx DMA Channels
 *	UART2	contains 1 Tx and 1 Rx DMA Channels
 *	UART3	contains 1 Tx and 1 Rx DMA Channels
 *	IrDA	contains 1 Tx and 1 Rx DMA Channels
 *
 * SSP and IDE use the Memory to Memory (M2M) channels and are not covered
 * with this implementation.
 */

#define pr_fmt(fmt) "ep93xx " KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/io.h>

#include <mach/dma.h>
#include <mach/hardware.h>

#define M2P_CONTROL			0x00
#define  M2P_CONTROL_STALL_IRQ_EN	(1 << 0)
#define  M2P_CONTROL_NFB_IRQ_EN		(1 << 1)
#define  M2P_CONTROL_ERROR_IRQ_EN	(1 << 3)
#define  M2P_CONTROL_ENABLE		(1 << 4)
#define M2P_INTERRUPT			0x04
#define  M2P_INTERRUPT_STALL		(1 << 0)
#define  M2P_INTERRUPT_NFB		(1 << 1)
#define  M2P_INTERRUPT_ERROR		(1 << 3)
#define M2P_PPALLOC			0x08
#define M2P_STATUS			0x0c
#define M2P_REMAIN			0x14
#define M2P_MAXCNT0			0x20
#define M2P_BASE0			0x24
#define M2P_MAXCNT1			0x30
#define M2P_BASE1			0x34

#define STATE_IDLE	0	/* Channel is inactive.  */
#define STATE_STALL	1	/* Channel is active, no buffers pending.  */
#define STATE_ON	2	/* Channel is active, one buffer pending.  */
#define STATE_NEXT	3	/* Channel is active, two buffers pending.  */

struct m2p_channel {
	char				*name;
	void __iomem			*base;
	int				irq;

	struct clk			*clk;
	spinlock_t			lock;

	void				*client;
	unsigned			next_slot:1;
	struct ep93xx_dma_buffer	*buffer_xfer;
	struct ep93xx_dma_buffer	*buffer_next;
	struct list_head		buffers_pending;
};

static struct m2p_channel m2p_rx[] = {
	{"m2p1", EP93XX_DMA_BASE + 0x0040, IRQ_EP93XX_DMAM2P1},
	{"m2p3", EP93XX_DMA_BASE + 0x00c0, IRQ_EP93XX_DMAM2P3},
	{"m2p5", EP93XX_DMA_BASE + 0x0200, IRQ_EP93XX_DMAM2P5},
	{"m2p7", EP93XX_DMA_BASE + 0x0280, IRQ_EP93XX_DMAM2P7},
	{"m2p9", EP93XX_DMA_BASE + 0x0300, IRQ_EP93XX_DMAM2P9},
	{NULL},
};

static struct m2p_channel m2p_tx[] = {
	{"m2p0", EP93XX_DMA_BASE + 0x0000, IRQ_EP93XX_DMAM2P0},
	{"m2p2", EP93XX_DMA_BASE + 0x0080, IRQ_EP93XX_DMAM2P2},
	{"m2p4", EP93XX_DMA_BASE + 0x0240, IRQ_EP93XX_DMAM2P4},
	{"m2p6", EP93XX_DMA_BASE + 0x02c0, IRQ_EP93XX_DMAM2P6},
	{"m2p8", EP93XX_DMA_BASE + 0x0340, IRQ_EP93XX_DMAM2P8},
	{NULL},
};

static void feed_buf(struct m2p_channel *ch, struct ep93xx_dma_buffer *buf)
{
	if (ch->next_slot == 0) {
		writel(buf->size, ch->base + M2P_MAXCNT0);
		writel(buf->bus_addr, ch->base + M2P_BASE0);
	} else {
		writel(buf->size, ch->base + M2P_MAXCNT1);
		writel(buf->bus_addr, ch->base + M2P_BASE1);
	}
	ch->next_slot ^= 1;
}

static void choose_buffer_xfer(struct m2p_channel *ch)
{
	struct ep93xx_dma_buffer *buf;

	ch->buffer_xfer = NULL;
	if (!list_empty(&ch->buffers_pending)) {
		buf = list_entry(ch->buffers_pending.next,
				 struct ep93xx_dma_buffer, list);
		list_del(&buf->list);
		feed_buf(ch, buf);
		ch->buffer_xfer = buf;
	}
}

static void choose_buffer_next(struct m2p_channel *ch)
{
	struct ep93xx_dma_buffer *buf;

	ch->buffer_next = NULL;
	if (!list_empty(&ch->buffers_pending)) {
		buf = list_entry(ch->buffers_pending.next,
				 struct ep93xx_dma_buffer, list);
		list_del(&buf->list);
		feed_buf(ch, buf);
		ch->buffer_next = buf;
	}
}

static inline void m2p_set_control(struct m2p_channel *ch, u32 v)
{
	/*
	 * The control register must be read immediately after being written so
	 * that the internal state machine is correctly updated. See the ep93xx
	 * users' guide for details.
	 */
	writel(v, ch->base + M2P_CONTROL);
	readl(ch->base + M2P_CONTROL);
}

static inline int m2p_channel_state(struct m2p_channel *ch)
{
	return (readl(ch->base + M2P_STATUS) >> 4) & 0x3;
}

static irqreturn_t m2p_irq(int irq, void *dev_id)
{
	struct m2p_channel *ch = dev_id;
	struct ep93xx_dma_m2p_client *cl;
	u32 irq_status, v;
	int error = 0;

	cl = ch->client;

	spin_lock(&ch->lock);
	irq_status = readl(ch->base + M2P_INTERRUPT);

	if (irq_status & M2P_INTERRUPT_ERROR) {
		writel(M2P_INTERRUPT_ERROR, ch->base + M2P_INTERRUPT);
		error = 1;
	}

	if ((irq_status & (M2P_INTERRUPT_STALL | M2P_INTERRUPT_NFB)) == 0) {
		spin_unlock(&ch->lock);
		return IRQ_NONE;
	}

	switch (m2p_channel_state(ch)) {
	case STATE_IDLE:
		pr_crit("dma interrupt without a dma buffer\n");
		BUG();
		break;

	case STATE_STALL:
		cl->buffer_finished(cl->cookie, ch->buffer_xfer, 0, error);
		if (ch->buffer_next != NULL) {
			cl->buffer_finished(cl->cookie, ch->buffer_next,
					    0, error);
		}
		choose_buffer_xfer(ch);
		choose_buffer_next(ch);
		if (ch->buffer_xfer != NULL)
			cl->buffer_started(cl->cookie, ch->buffer_xfer);
		break;

	case STATE_ON:
		cl->buffer_finished(cl->cookie, ch->buffer_xfer, 0, error);
		ch->buffer_xfer = ch->buffer_next;
		choose_buffer_next(ch);
		cl->buffer_started(cl->cookie, ch->buffer_xfer);
		break;

	case STATE_NEXT:
		pr_crit("dma interrupt while next\n");
		BUG();
		break;
	}

	v = readl(ch->base + M2P_CONTROL) & ~(M2P_CONTROL_STALL_IRQ_EN |
					      M2P_CONTROL_NFB_IRQ_EN);
	if (ch->buffer_xfer != NULL)
		v |= M2P_CONTROL_STALL_IRQ_EN;
	if (ch->buffer_next != NULL)
		v |= M2P_CONTROL_NFB_IRQ_EN;
	m2p_set_control(ch, v);

	spin_unlock(&ch->lock);
	return IRQ_HANDLED;
}

static struct m2p_channel *find_free_channel(struct ep93xx_dma_m2p_client *cl)
{
	struct m2p_channel *ch;
	int i;

	if (cl->flags & EP93XX_DMA_M2P_RX)
		ch = m2p_rx;
	else
		ch = m2p_tx;

	for (i = 0; ch[i].base; i++) {
		struct ep93xx_dma_m2p_client *client;

		client = ch[i].client;
		if (client != NULL) {
			int port;

			port = cl->flags & EP93XX_DMA_M2P_PORT_MASK;
			if (port == (client->flags &
				     EP93XX_DMA_M2P_PORT_MASK)) {
				pr_warning("DMA channel already used by %s\n",
					   cl->name ? : "unknown client");
				return ERR_PTR(-EBUSY);
			}
		}
	}

	for (i = 0; ch[i].base; i++) {
		if (ch[i].client == NULL)
			return ch + i;
	}

	pr_warning("No free DMA channel for %s\n",
		   cl->name ? : "unknown client");
	return ERR_PTR(-ENODEV);
}

static void channel_enable(struct m2p_channel *ch)
{
	struct ep93xx_dma_m2p_client *cl = ch->client;
	u32 v;

	clk_enable(ch->clk);

	v = cl->flags & EP93XX_DMA_M2P_PORT_MASK;
	writel(v, ch->base + M2P_PPALLOC);

	v = cl->flags & EP93XX_DMA_M2P_ERROR_MASK;
	v |= M2P_CONTROL_ENABLE | M2P_CONTROL_ERROR_IRQ_EN;
	m2p_set_control(ch, v);
}

static void channel_disable(struct m2p_channel *ch)
{
	u32 v;

	v = readl(ch->base + M2P_CONTROL);
	v &= ~(M2P_CONTROL_STALL_IRQ_EN | M2P_CONTROL_NFB_IRQ_EN);
	m2p_set_control(ch, v);

	while (m2p_channel_state(ch) >= STATE_ON)
		cpu_relax();

	m2p_set_control(ch, 0x0);

	while (m2p_channel_state(ch) == STATE_STALL)
		cpu_relax();

	clk_disable(ch->clk);
}

int ep93xx_dma_m2p_client_register(struct ep93xx_dma_m2p_client *cl)
{
	struct m2p_channel *ch;
	int err;

	ch = find_free_channel(cl);
	if (IS_ERR(ch))
		return PTR_ERR(ch);

	err = request_irq(ch->irq, m2p_irq, 0, cl->name ? : "dma-m2p", ch);
	if (err)
		return err;

	ch->client = cl;
	ch->next_slot = 0;
	ch->buffer_xfer = NULL;
	ch->buffer_next = NULL;
	INIT_LIST_HEAD(&ch->buffers_pending);

	cl->channel = ch;

	channel_enable(ch);

	return 0;
}
EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_client_register);

void ep93xx_dma_m2p_client_unregister(struct ep93xx_dma_m2p_client *cl)
{
	struct m2p_channel *ch = cl->channel;

	channel_disable(ch);
	free_irq(ch->irq, ch);
	ch->client = NULL;
}
EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_client_unregister);

void ep93xx_dma_m2p_submit(struct ep93xx_dma_m2p_client *cl,
			   struct ep93xx_dma_buffer *buf)
{
	struct m2p_channel *ch = cl->channel;
	unsigned long flags;
	u32 v;

	spin_lock_irqsave(&ch->lock, flags);
	v = readl(ch->base + M2P_CONTROL);
	if (ch->buffer_xfer == NULL) {
		ch->buffer_xfer = buf;
		feed_buf(ch, buf);
		cl->buffer_started(cl->cookie, buf);

		v |= M2P_CONTROL_STALL_IRQ_EN;
		m2p_set_control(ch, v);

	} else if (ch->buffer_next == NULL) {
		ch->buffer_next = buf;
		feed_buf(ch, buf);

		v |= M2P_CONTROL_NFB_IRQ_EN;
		m2p_set_control(ch, v);
	} else {
		list_add_tail(&buf->list, &ch->buffers_pending);
	}
	spin_unlock_irqrestore(&ch->lock, flags);
}
EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_submit);

void ep93xx_dma_m2p_submit_recursive(struct ep93xx_dma_m2p_client *cl,
				     struct ep93xx_dma_buffer *buf)
{
	struct m2p_channel *ch = cl->channel;

	list_add_tail(&buf->list, &ch->buffers_pending);
}
EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_submit_recursive);

void ep93xx_dma_m2p_flush(struct ep93xx_dma_m2p_client *cl)
{
	struct m2p_channel *ch = cl->channel;

	channel_disable(ch);
	ch->next_slot = 0;
	ch->buffer_xfer = NULL;
	ch->buffer_next = NULL;
	INIT_LIST_HEAD(&ch->buffers_pending);
	channel_enable(ch);
}
EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_flush);

static int init_channel(struct m2p_channel *ch)
{
	ch->clk = clk_get(NULL, ch->name);
	if (IS_ERR(ch->clk))
		return PTR_ERR(ch->clk);

	spin_lock_init(&ch->lock);
	ch->client = NULL;

	return 0;
}

static int __init ep93xx_dma_m2p_init(void)
{
	int i;
	int ret;

	for (i = 0; m2p_rx[i].base; i++) {
		ret = init_channel(m2p_rx + i);
		if (ret)
			return ret;
	}

	for (i = 0; m2p_tx[i].base; i++) {
		ret = init_channel(m2p_tx + i);
		if (ret)
			return ret;
	}

	pr_info("M2P DMA subsystem initialized\n");
	return 0;
}
arch_initcall(ep93xx_dma_m2p_init);
Commit	Line	Data
6d831c65 RM	1	/*
	2	* arch/arm/mach-ep93xx/dma-m2p.c
	3	* M2P DMA handling for Cirrus EP93xx chips.
	4	*
	5	* Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
	6	* Copyright (C) 2006 Applied Data Systems
	7	*
	8	* Copyright (C) 2009 Ryan Mallon <ryan@bluewatersys.com>
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or (at
	13	* your option) any later version.
	14	*/
	15
	16	/*
	17	* On the EP93xx chip the following peripherals my be allocated to the 10
	18	* Memory to Internal Peripheral (M2P) channels (5 transmit + 5 receive).
	19	*
	20	* I2S contains 3 Tx and 3 Rx DMA Channels
	21	* AAC contains 3 Tx and 3 Rx DMA Channels
	22	* UART1 contains 1 Tx and 1 Rx DMA Channels
	23	* UART2 contains 1 Tx and 1 Rx DMA Channels
	24	* UART3 contains 1 Tx and 1 Rx DMA Channels
	25	* IrDA contains 1 Tx and 1 Rx DMA Channels
	26	*
	27	* SSP and IDE use the Memory to Memory (M2M) channels and are not covered
	28	* with this implementation.
	29	*/
	30
f3f1882c HS	31	#define pr_fmt(fmt) "ep93xx " KBUILD_MODNAME ": " fmt
f3f1882c HS	32
6d831c65 RM	33	#include <linux/kernel.h>
	34	#include <linux/clk.h>
	35	#include <linux/err.h>
	36	#include <linux/interrupt.h>
	37	#include <linux/module.h>
a0b98ec8	38	#include <linux/io.h>
6d831c65 RM	39
	40	#include <mach/dma.h>
	41	#include <mach/hardware.h>
	42
	43	#define M2P_CONTROL 0x00
	44	#define M2P_CONTROL_STALL_IRQ_EN (1 << 0)
	45	#define M2P_CONTROL_NFB_IRQ_EN (1 << 1)
	46	#define M2P_CONTROL_ERROR_IRQ_EN (1 << 3)
	47	#define M2P_CONTROL_ENABLE (1 << 4)
	48	#define M2P_INTERRUPT 0x04
	49	#define M2P_INTERRUPT_STALL (1 << 0)
	50	#define M2P_INTERRUPT_NFB (1 << 1)
	51	#define M2P_INTERRUPT_ERROR (1 << 3)
	52	#define M2P_PPALLOC 0x08
	53	#define M2P_STATUS 0x0c
	54	#define M2P_REMAIN 0x14
	55	#define M2P_MAXCNT0 0x20
	56	#define M2P_BASE0 0x24
	57	#define M2P_MAXCNT1 0x30
	58	#define M2P_BASE1 0x34
	59
	60	#define STATE_IDLE 0 /* Channel is inactive. */
	61	#define STATE_STALL 1 /* Channel is active, no buffers pending. */
	62	#define STATE_ON 2 /* Channel is active, one buffer pending. */
	63	#define STATE_NEXT 3 /* Channel is active, two buffers pending. */
	64
	65	struct m2p_channel {
	66	char *name;
	67	void __iomem *base;
	68	int irq;
	69
	70	struct clk *clk;
	71	spinlock_t lock;
	72
	73	void *client;
	74	unsigned next_slot:1;
	75	struct ep93xx_dma_buffer *buffer_xfer;
	76	struct ep93xx_dma_buffer *buffer_next;
	77	struct list_head buffers_pending;
	78	};
	79
	80	static struct m2p_channel m2p_rx[] = {
	81	{"m2p1", EP93XX_DMA_BASE + 0x0040, IRQ_EP93XX_DMAM2P1},
	82	{"m2p3", EP93XX_DMA_BASE + 0x00c0, IRQ_EP93XX_DMAM2P3},
	83	{"m2p5", EP93XX_DMA_BASE + 0x0200, IRQ_EP93XX_DMAM2P5},
	84	{"m2p7", EP93XX_DMA_BASE + 0x0280, IRQ_EP93XX_DMAM2P7},
	85	{"m2p9", EP93XX_DMA_BASE + 0x0300, IRQ_EP93XX_DMAM2P9},
	86	{NULL},
	87	};
	88
	89	static struct m2p_channel m2p_tx[] = {
	90	{"m2p0", EP93XX_DMA_BASE + 0x0000, IRQ_EP93XX_DMAM2P0},
	91	{"m2p2", EP93XX_DMA_BASE + 0x0080, IRQ_EP93XX_DMAM2P2},
	92	{"m2p4", EP93XX_DMA_BASE + 0x0240, IRQ_EP93XX_DMAM2P4},
	93	{"m2p6", EP93XX_DMA_BASE + 0x02c0, IRQ_EP93XX_DMAM2P6},
	94	{"m2p8", EP93XX_DMA_BASE + 0x0340, IRQ_EP93XX_DMAM2P8},
	95	{NULL},
	96	};
	97
	98	static void feed_buf(struct m2p_channel ch, struct ep93xx_dma_buffer buf)
	99	{
	100	if (ch->next_slot == 0) {
	101	writel(buf->size, ch->base + M2P_MAXCNT0);
	102	writel(buf->bus_addr, ch->base + M2P_BASE0);
103	} else {
104	writel(buf->size, ch->base + M2P_MAXCNT1);
105	writel(buf->bus_addr, ch->base + M2P_BASE1);
106	}
107	ch->next_slot ^= 1;
108	}
109
110	static void choose_buffer_xfer(struct m2p_channel *ch)
111	{
112	struct ep93xx_dma_buffer *buf;
113
114	ch->buffer_xfer = NULL;
115	if (!list_empty(&ch->buffers_pending)) {
116	buf = list_entry(ch->buffers_pending.next,
117	struct ep93xx_dma_buffer, list);
118	list_del(&buf->list);
119	feed_buf(ch, buf);
120	ch->buffer_xfer = buf;
121	}
122	}
123
124	static void choose_buffer_next(struct m2p_channel *ch)
125	{
126	struct ep93xx_dma_buffer *buf;
127
128	ch->buffer_next = NULL;
129	if (!list_empty(&ch->buffers_pending)) {
130	buf = list_entry(ch->buffers_pending.next,
131	struct ep93xx_dma_buffer, list);
132	list_del(&buf->list);
133	feed_buf(ch, buf);
134	ch->buffer_next = buf;
135	}
136	}
137
138	static inline void m2p_set_control(struct m2p_channel *ch, u32 v)
139	{
140	/*
141	* The control register must be read immediately after being written so
142	* that the internal state machine is correctly updated. See the ep93xx
143	* users' guide for details.
144	*/
145	writel(v, ch->base + M2P_CONTROL);
146	readl(ch->base + M2P_CONTROL);
147	}
148
149	static inline int m2p_channel_state(struct m2p_channel *ch)
150	{
151	return (readl(ch->base + M2P_STATUS) >> 4) & 0x3;
152	}
153
154	static irqreturn_t m2p_irq(int irq, void *dev_id)
155	{
156	struct m2p_channel *ch = dev_id;
157	struct ep93xx_dma_m2p_client *cl;
158	u32 irq_status, v;
159	int error = 0;
160
161	cl = ch->client;
162
163	spin_lock(&ch->lock);
164	irq_status = readl(ch->base + M2P_INTERRUPT);
165
166	if (irq_status & M2P_INTERRUPT_ERROR) {
167	writel(M2P_INTERRUPT_ERROR, ch->base + M2P_INTERRUPT);
168	error = 1;
169	}
170
171	if ((irq_status & (M2P_INTERRUPT_STALL \| M2P_INTERRUPT_NFB)) == 0) {
172	spin_unlock(&ch->lock);
173	return IRQ_NONE;
174	}
175
176	switch (m2p_channel_state(ch)) {
177	case STATE_IDLE:
f3f1882c	178	pr_crit("dma interrupt without a dma buffer\n");
6d831c65 RM	179	BUG();
	180	break;
	181
	182	case STATE_STALL:
	183	cl->buffer_finished(cl->cookie, ch->buffer_xfer, 0, error);
	184	if (ch->buffer_next != NULL) {
	185	cl->buffer_finished(cl->cookie, ch->buffer_next,
	186	0, error);
	187	}
	188	choose_buffer_xfer(ch);
	189	choose_buffer_next(ch);
	190	if (ch->buffer_xfer != NULL)
	191	cl->buffer_started(cl->cookie, ch->buffer_xfer);
	192	break;
	193
	194	case STATE_ON:
	195	cl->buffer_finished(cl->cookie, ch->buffer_xfer, 0, error);
	196	ch->buffer_xfer = ch->buffer_next;
	197	choose_buffer_next(ch);
	198	cl->buffer_started(cl->cookie, ch->buffer_xfer);
	199	break;
	200
	201	case STATE_NEXT:
f3f1882c	202	pr_crit("dma interrupt while next\n");
6d831c65 RM	203	BUG();
	204	break;
	205	}
	206
	207	v = readl(ch->base + M2P_CONTROL) & ~(M2P_CONTROL_STALL_IRQ_EN \|
	208	M2P_CONTROL_NFB_IRQ_EN);
	209	if (ch->buffer_xfer != NULL)
	210	v \|= M2P_CONTROL_STALL_IRQ_EN;
	211	if (ch->buffer_next != NULL)
	212	v \|= M2P_CONTROL_NFB_IRQ_EN;
	213	m2p_set_control(ch, v);
	214
	215	spin_unlock(&ch->lock);
	216	return IRQ_HANDLED;
	217	}
	218
	219	static struct m2p_channel find_free_channel(struct ep93xx_dma_m2p_client cl)
	220	{
	221	struct m2p_channel *ch;
	222	int i;
	223
	224	if (cl->flags & EP93XX_DMA_M2P_RX)
	225	ch = m2p_rx;
	226	else
	227	ch = m2p_tx;
	228
	229	for (i = 0; ch[i].base; i++) {
	230	struct ep93xx_dma_m2p_client *client;
	231
	232	client = ch[i].client;
	233	if (client != NULL) {
	234	int port;
	235
	236	port = cl->flags & EP93XX_DMA_M2P_PORT_MASK;
	237	if (port == (client->flags &
	238	EP93XX_DMA_M2P_PORT_MASK)) {
	239	pr_warning("DMA channel already used by %s\n",
	240	cl->name ? : "unknown client");
	241	return ERR_PTR(-EBUSY);
	242	}
	243	}
	244	}
	245
	246	for (i = 0; ch[i].base; i++) {
	247	if (ch[i].client == NULL)
	248	return ch + i;
	249	}
	250
	251	pr_warning("No free DMA channel for %s\n",
	252	cl->name ? : "unknown client");
	253	return ERR_PTR(-ENODEV);
	254	}
	255
	256	static void channel_enable(struct m2p_channel *ch)
	257	{
	258	struct ep93xx_dma_m2p_client *cl = ch->client;
	259	u32 v;
	260
	261	clk_enable(ch->clk);
	262
	263	v = cl->flags & EP93XX_DMA_M2P_PORT_MASK;
	264	writel(v, ch->base + M2P_PPALLOC);
	265
	266	v = cl->flags & EP93XX_DMA_M2P_ERROR_MASK;
267	v \|= M2P_CONTROL_ENABLE \| M2P_CONTROL_ERROR_IRQ_EN;
268	m2p_set_control(ch, v);
269	}
270
271	static void channel_disable(struct m2p_channel *ch)
272	{
273	u32 v;
274
275	v = readl(ch->base + M2P_CONTROL);
276	v &= ~(M2P_CONTROL_STALL_IRQ_EN \| M2P_CONTROL_NFB_IRQ_EN);
277	m2p_set_control(ch, v);
278
10d48b39	279	while (m2p_channel_state(ch) >= STATE_ON)
6d831c65 RM	280	cpu_relax();
	281
	282	m2p_set_control(ch, 0x0);
	283
	284	while (m2p_channel_state(ch) == STATE_STALL)
	285	cpu_relax();
	286
	287	clk_disable(ch->clk);
	288	}
	289
	290	int ep93xx_dma_m2p_client_register(struct ep93xx_dma_m2p_client *cl)
	291	{
	292	struct m2p_channel *ch;
	293	int err;
	294
	295	ch = find_free_channel(cl);
	296	if (IS_ERR(ch))
	297	return PTR_ERR(ch);
	298
	299	err = request_irq(ch->irq, m2p_irq, 0, cl->name ? : "dma-m2p", ch);
	300	if (err)
	301	return err;
	302
	303	ch->client = cl;
	304	ch->next_slot = 0;
	305	ch->buffer_xfer = NULL;
	306	ch->buffer_next = NULL;
	307	INIT_LIST_HEAD(&ch->buffers_pending);
	308
	309	cl->channel = ch;
	310
	311	channel_enable(ch);
	312
	313	return 0;
	314	}
	315	EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_client_register);
	316
	317	void ep93xx_dma_m2p_client_unregister(struct ep93xx_dma_m2p_client *cl)
	318	{
	319	struct m2p_channel *ch = cl->channel;
	320
	321	channel_disable(ch);
	322	free_irq(ch->irq, ch);
	323	ch->client = NULL;
	324	}
	325	EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_client_unregister);
	326
	327	void ep93xx_dma_m2p_submit(struct ep93xx_dma_m2p_client *cl,
	328	struct ep93xx_dma_buffer *buf)
	329	{
	330	struct m2p_channel *ch = cl->channel;
	331	unsigned long flags;
	332	u32 v;
	333
	334	spin_lock_irqsave(&ch->lock, flags);
	335	v = readl(ch->base + M2P_CONTROL);
	336	if (ch->buffer_xfer == NULL) {
	337	ch->buffer_xfer = buf;
	338	feed_buf(ch, buf);
	339	cl->buffer_started(cl->cookie, buf);
	340
	341	v \|= M2P_CONTROL_STALL_IRQ_EN;
	342	m2p_set_control(ch, v);
	343
344	} else if (ch->buffer_next == NULL) {
345	ch->buffer_next = buf;
346	feed_buf(ch, buf);
347
348	v \|= M2P_CONTROL_NFB_IRQ_EN;
349	m2p_set_control(ch, v);
350	} else {
351	list_add_tail(&buf->list, &ch->buffers_pending);
352	}
353	spin_unlock_irqrestore(&ch->lock, flags);
354	}
355	EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_submit);
356
357	void ep93xx_dma_m2p_submit_recursive(struct ep93xx_dma_m2p_client *cl,
358	struct ep93xx_dma_buffer *buf)
359	{
360	struct m2p_channel *ch = cl->channel;
361
362	list_add_tail(&buf->list, &ch->buffers_pending);
363	}
364	EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_submit_recursive);
365
366	void ep93xx_dma_m2p_flush(struct ep93xx_dma_m2p_client *cl)
367	{
368	struct m2p_channel *ch = cl->channel;
369
370	channel_disable(ch);
371	ch->next_slot = 0;
372	ch->buffer_xfer = NULL;
373	ch->buffer_next = NULL;
374	INIT_LIST_HEAD(&ch->buffers_pending);
375	channel_enable(ch);
376	}
377	EXPORT_SYMBOL_GPL(ep93xx_dma_m2p_flush);
378
379	static int init_channel(struct m2p_channel *ch)
380	{
381	ch->clk = clk_get(NULL, ch->name);
382	if (IS_ERR(ch->clk))
383	return PTR_ERR(ch->clk);
384
385	spin_lock_init(&ch->lock);
386	ch->client = NULL;
387
388	return 0;
389	}
390
391	static int __init ep93xx_dma_m2p_init(void)
392	{
393	int i;
394	int ret;
395
396	for (i = 0; m2p_rx[i].base; i++) {
397	ret = init_channel(m2p_rx + i);
398	if (ret)
399	return ret;
400	}
401
402	for (i = 0; m2p_tx[i].base; i++) {
403	ret = init_channel(m2p_tx + i);
404	if (ret)
405	return ret;
406	}
407
408	pr_info("M2P DMA subsystem initialized\n");
409	return 0;
410	}
411	arch_initcall(ep93xx_dma_m2p_init);