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