]> git.sur5r.net Git - u-boot/blob - drivers/dma/apbh_dma.c
Merge git://git.denx.de/u-boot-fsl-qoriq
[u-boot] / drivers / dma / apbh_dma.c
1 /*
2  * Freescale i.MX28 APBH DMA driver
3  *
4  * Copyright (C) 2011 Marek Vasut <marek.vasut@gmail.com>
5  * on behalf of DENX Software Engineering GmbH
6  *
7  * Based on code from LTIB:
8  * Copyright (C) 2010 Freescale Semiconductor, Inc. All Rights Reserved.
9  *
10  * SPDX-License-Identifier:     GPL-2.0+
11  */
12
13 #include <linux/list.h>
14
15 #include <common.h>
16 #include <malloc.h>
17 #include <linux/errno.h>
18 #include <asm/io.h>
19 #include <asm/arch/clock.h>
20 #include <asm/arch/imx-regs.h>
21 #include <asm/arch/sys_proto.h>
22 #include <asm/imx-common/dma.h>
23 #include <asm/imx-common/regs-apbh.h>
24
25 static struct mxs_dma_chan mxs_dma_channels[MXS_MAX_DMA_CHANNELS];
26
27 /*
28  * Test is the DMA channel is valid channel
29  */
30 int mxs_dma_validate_chan(int channel)
31 {
32         struct mxs_dma_chan *pchan;
33
34         if ((channel < 0) || (channel >= MXS_MAX_DMA_CHANNELS))
35                 return -EINVAL;
36
37         pchan = mxs_dma_channels + channel;
38         if (!(pchan->flags & MXS_DMA_FLAGS_ALLOCATED))
39                 return -EINVAL;
40
41         return 0;
42 }
43
44 /*
45  * Return the address of the command within a descriptor.
46  */
47 static unsigned int mxs_dma_cmd_address(struct mxs_dma_desc *desc)
48 {
49         return desc->address + offsetof(struct mxs_dma_desc, cmd);
50 }
51
52 /*
53  * Read a DMA channel's hardware semaphore.
54  *
55  * As used by the MXS platform's DMA software, the DMA channel's hardware
56  * semaphore reflects the number of DMA commands the hardware will process, but
57  * has not yet finished. This is a volatile value read directly from hardware,
58  * so it must be be viewed as immediately stale.
59  *
60  * If the channel is not marked busy, or has finished processing all its
61  * commands, this value should be zero.
62  *
63  * See mxs_dma_append() for details on how DMA command blocks must be configured
64  * to maintain the expected behavior of the semaphore's value.
65  */
66 static int mxs_dma_read_semaphore(int channel)
67 {
68         struct mxs_apbh_regs *apbh_regs =
69                 (struct mxs_apbh_regs *)MXS_APBH_BASE;
70         uint32_t tmp;
71         int ret;
72
73         ret = mxs_dma_validate_chan(channel);
74         if (ret)
75                 return ret;
76
77         tmp = readl(&apbh_regs->ch[channel].hw_apbh_ch_sema);
78
79         tmp &= APBH_CHn_SEMA_PHORE_MASK;
80         tmp >>= APBH_CHn_SEMA_PHORE_OFFSET;
81
82         return tmp;
83 }
84
85 #ifndef CONFIG_SYS_DCACHE_OFF
86 void mxs_dma_flush_desc(struct mxs_dma_desc *desc)
87 {
88         uint32_t addr;
89         uint32_t size;
90
91         addr = (uint32_t)desc;
92         size = roundup(sizeof(struct mxs_dma_desc), MXS_DMA_ALIGNMENT);
93
94         flush_dcache_range(addr, addr + size);
95 }
96 #else
97 inline void mxs_dma_flush_desc(struct mxs_dma_desc *desc) {}
98 #endif
99
100 /*
101  * Enable a DMA channel.
102  *
103  * If the given channel has any DMA descriptors on its active list, this
104  * function causes the DMA hardware to begin processing them.
105  *
106  * This function marks the DMA channel as "busy," whether or not there are any
107  * descriptors to process.
108  */
109 static int mxs_dma_enable(int channel)
110 {
111         struct mxs_apbh_regs *apbh_regs =
112                 (struct mxs_apbh_regs *)MXS_APBH_BASE;
113         unsigned int sem;
114         struct mxs_dma_chan *pchan;
115         struct mxs_dma_desc *pdesc;
116         int ret;
117
118         ret = mxs_dma_validate_chan(channel);
119         if (ret)
120                 return ret;
121
122         pchan = mxs_dma_channels + channel;
123
124         if (pchan->pending_num == 0) {
125                 pchan->flags |= MXS_DMA_FLAGS_BUSY;
126                 return 0;
127         }
128
129         pdesc = list_first_entry(&pchan->active, struct mxs_dma_desc, node);
130         if (pdesc == NULL)
131                 return -EFAULT;
132
133         if (pchan->flags & MXS_DMA_FLAGS_BUSY) {
134                 if (!(pdesc->cmd.data & MXS_DMA_DESC_CHAIN))
135                         return 0;
136
137                 sem = mxs_dma_read_semaphore(channel);
138                 if (sem == 0)
139                         return 0;
140
141                 if (sem == 1) {
142                         pdesc = list_entry(pdesc->node.next,
143                                            struct mxs_dma_desc, node);
144                         writel(mxs_dma_cmd_address(pdesc),
145                                 &apbh_regs->ch[channel].hw_apbh_ch_nxtcmdar);
146                 }
147                 writel(pchan->pending_num,
148                         &apbh_regs->ch[channel].hw_apbh_ch_sema);
149                 pchan->active_num += pchan->pending_num;
150                 pchan->pending_num = 0;
151         } else {
152                 pchan->active_num += pchan->pending_num;
153                 pchan->pending_num = 0;
154                 writel(mxs_dma_cmd_address(pdesc),
155                         &apbh_regs->ch[channel].hw_apbh_ch_nxtcmdar);
156                 writel(pchan->active_num,
157                         &apbh_regs->ch[channel].hw_apbh_ch_sema);
158                 writel(1 << (channel + APBH_CTRL0_CLKGATE_CHANNEL_OFFSET),
159                         &apbh_regs->hw_apbh_ctrl0_clr);
160         }
161
162         pchan->flags |= MXS_DMA_FLAGS_BUSY;
163         return 0;
164 }
165
166 /*
167  * Disable a DMA channel.
168  *
169  * This function shuts down a DMA channel and marks it as "not busy." Any
170  * descriptors on the active list are immediately moved to the head of the
171  * "done" list, whether or not they have actually been processed by the
172  * hardware. The "ready" flags of these descriptors are NOT cleared, so they
173  * still appear to be active.
174  *
175  * This function immediately shuts down a DMA channel's hardware, aborting any
176  * I/O that may be in progress, potentially leaving I/O hardware in an undefined
177  * state. It is unwise to call this function if there is ANY chance the hardware
178  * is still processing a command.
179  */
180 static int mxs_dma_disable(int channel)
181 {
182         struct mxs_dma_chan *pchan;
183         struct mxs_apbh_regs *apbh_regs =
184                 (struct mxs_apbh_regs *)MXS_APBH_BASE;
185         int ret;
186
187         ret = mxs_dma_validate_chan(channel);
188         if (ret)
189                 return ret;
190
191         pchan = mxs_dma_channels + channel;
192
193         if (!(pchan->flags & MXS_DMA_FLAGS_BUSY))
194                 return -EINVAL;
195
196         writel(1 << (channel + APBH_CTRL0_CLKGATE_CHANNEL_OFFSET),
197                 &apbh_regs->hw_apbh_ctrl0_set);
198
199         pchan->flags &= ~MXS_DMA_FLAGS_BUSY;
200         pchan->active_num = 0;
201         pchan->pending_num = 0;
202         list_splice_init(&pchan->active, &pchan->done);
203
204         return 0;
205 }
206
207 /*
208  * Resets the DMA channel hardware.
209  */
210 static int mxs_dma_reset(int channel)
211 {
212         struct mxs_apbh_regs *apbh_regs =
213                 (struct mxs_apbh_regs *)MXS_APBH_BASE;
214         int ret;
215 #if defined(CONFIG_MX23)
216         uint32_t setreg = (uint32_t)(&apbh_regs->hw_apbh_ctrl0_set);
217         uint32_t offset = APBH_CTRL0_RESET_CHANNEL_OFFSET;
218 #elif (defined(CONFIG_MX28) || defined(CONFIG_MX6) || defined(CONFIG_MX7))
219         uint32_t setreg = (uint32_t)(&apbh_regs->hw_apbh_channel_ctrl_set);
220         uint32_t offset = APBH_CHANNEL_CTRL_RESET_CHANNEL_OFFSET;
221 #endif
222
223         ret = mxs_dma_validate_chan(channel);
224         if (ret)
225                 return ret;
226
227         writel(1 << (channel + offset), setreg);
228
229         return 0;
230 }
231
232 /*
233  * Enable or disable DMA interrupt.
234  *
235  * This function enables the given DMA channel to interrupt the CPU.
236  */
237 static int mxs_dma_enable_irq(int channel, int enable)
238 {
239         struct mxs_apbh_regs *apbh_regs =
240                 (struct mxs_apbh_regs *)MXS_APBH_BASE;
241         int ret;
242
243         ret = mxs_dma_validate_chan(channel);
244         if (ret)
245                 return ret;
246
247         if (enable)
248                 writel(1 << (channel + APBH_CTRL1_CH_CMDCMPLT_IRQ_EN_OFFSET),
249                         &apbh_regs->hw_apbh_ctrl1_set);
250         else
251                 writel(1 << (channel + APBH_CTRL1_CH_CMDCMPLT_IRQ_EN_OFFSET),
252                         &apbh_regs->hw_apbh_ctrl1_clr);
253
254         return 0;
255 }
256
257 /*
258  * Clear DMA interrupt.
259  *
260  * The software that is using the DMA channel must register to receive its
261  * interrupts and, when they arrive, must call this function to clear them.
262  */
263 static int mxs_dma_ack_irq(int channel)
264 {
265         struct mxs_apbh_regs *apbh_regs =
266                 (struct mxs_apbh_regs *)MXS_APBH_BASE;
267         int ret;
268
269         ret = mxs_dma_validate_chan(channel);
270         if (ret)
271                 return ret;
272
273         writel(1 << channel, &apbh_regs->hw_apbh_ctrl1_clr);
274         writel(1 << channel, &apbh_regs->hw_apbh_ctrl2_clr);
275
276         return 0;
277 }
278
279 /*
280  * Request to reserve a DMA channel
281  */
282 static int mxs_dma_request(int channel)
283 {
284         struct mxs_dma_chan *pchan;
285
286         if ((channel < 0) || (channel >= MXS_MAX_DMA_CHANNELS))
287                 return -EINVAL;
288
289         pchan = mxs_dma_channels + channel;
290         if ((pchan->flags & MXS_DMA_FLAGS_VALID) != MXS_DMA_FLAGS_VALID)
291                 return -ENODEV;
292
293         if (pchan->flags & MXS_DMA_FLAGS_ALLOCATED)
294                 return -EBUSY;
295
296         pchan->flags |= MXS_DMA_FLAGS_ALLOCATED;
297         pchan->active_num = 0;
298         pchan->pending_num = 0;
299
300         INIT_LIST_HEAD(&pchan->active);
301         INIT_LIST_HEAD(&pchan->done);
302
303         return 0;
304 }
305
306 /*
307  * Release a DMA channel.
308  *
309  * This function releases a DMA channel from its current owner.
310  *
311  * The channel will NOT be released if it's marked "busy" (see
312  * mxs_dma_enable()).
313  */
314 int mxs_dma_release(int channel)
315 {
316         struct mxs_dma_chan *pchan;
317         int ret;
318
319         ret = mxs_dma_validate_chan(channel);
320         if (ret)
321                 return ret;
322
323         pchan = mxs_dma_channels + channel;
324
325         if (pchan->flags & MXS_DMA_FLAGS_BUSY)
326                 return -EBUSY;
327
328         pchan->dev = 0;
329         pchan->active_num = 0;
330         pchan->pending_num = 0;
331         pchan->flags &= ~MXS_DMA_FLAGS_ALLOCATED;
332
333         return 0;
334 }
335
336 /*
337  * Allocate DMA descriptor
338  */
339 struct mxs_dma_desc *mxs_dma_desc_alloc(void)
340 {
341         struct mxs_dma_desc *pdesc;
342         uint32_t size;
343
344         size = roundup(sizeof(struct mxs_dma_desc), MXS_DMA_ALIGNMENT);
345         pdesc = memalign(MXS_DMA_ALIGNMENT, size);
346
347         if (pdesc == NULL)
348                 return NULL;
349
350         memset(pdesc, 0, sizeof(*pdesc));
351         pdesc->address = (dma_addr_t)pdesc;
352
353         return pdesc;
354 };
355
356 /*
357  * Free DMA descriptor
358  */
359 void mxs_dma_desc_free(struct mxs_dma_desc *pdesc)
360 {
361         if (pdesc == NULL)
362                 return;
363
364         free(pdesc);
365 }
366
367 /*
368  * Add a DMA descriptor to a channel.
369  *
370  * If the descriptor list for this channel is not empty, this function sets the
371  * CHAIN bit and the NEXTCMD_ADDR fields in the last descriptor's DMA command so
372  * it will chain to the new descriptor's command.
373  *
374  * Then, this function marks the new descriptor as "ready," adds it to the end
375  * of the active descriptor list, and increments the count of pending
376  * descriptors.
377  *
378  * The MXS platform DMA software imposes some rules on DMA commands to maintain
379  * important invariants. These rules are NOT checked, but they must be carefully
380  * applied by software that uses MXS DMA channels.
381  *
382  * Invariant:
383  *     The DMA channel's hardware semaphore must reflect the number of DMA
384  *     commands the hardware will process, but has not yet finished.
385  *
386  * Explanation:
387  *     A DMA channel begins processing commands when its hardware semaphore is
388  *     written with a value greater than zero, and it stops processing commands
389  *     when the semaphore returns to zero.
390  *
391  *     When a channel finishes a DMA command, it will decrement its semaphore if
392  *     the DECREMENT_SEMAPHORE bit is set in that command's flags bits.
393  *
394  *     In principle, it's not necessary for the DECREMENT_SEMAPHORE to be set,
395  *     unless it suits the purposes of the software. For example, one could
396  *     construct a series of five DMA commands, with the DECREMENT_SEMAPHORE
397  *     bit set only in the last one. Then, setting the DMA channel's hardware
398  *     semaphore to one would cause the entire series of five commands to be
399  *     processed. However, this example would violate the invariant given above.
400  *
401  * Rule:
402  *    ALL DMA commands MUST have the DECREMENT_SEMAPHORE bit set so that the DMA
403  *    channel's hardware semaphore will be decremented EVERY time a command is
404  *    processed.
405  */
406 int mxs_dma_desc_append(int channel, struct mxs_dma_desc *pdesc)
407 {
408         struct mxs_dma_chan *pchan;
409         struct mxs_dma_desc *last;
410         int ret;
411
412         ret = mxs_dma_validate_chan(channel);
413         if (ret)
414                 return ret;
415
416         pchan = mxs_dma_channels + channel;
417
418         pdesc->cmd.next = mxs_dma_cmd_address(pdesc);
419         pdesc->flags |= MXS_DMA_DESC_FIRST | MXS_DMA_DESC_LAST;
420
421         if (!list_empty(&pchan->active)) {
422                 last = list_entry(pchan->active.prev, struct mxs_dma_desc,
423                                         node);
424
425                 pdesc->flags &= ~MXS_DMA_DESC_FIRST;
426                 last->flags &= ~MXS_DMA_DESC_LAST;
427
428                 last->cmd.next = mxs_dma_cmd_address(pdesc);
429                 last->cmd.data |= MXS_DMA_DESC_CHAIN;
430
431                 mxs_dma_flush_desc(last);
432         }
433         pdesc->flags |= MXS_DMA_DESC_READY;
434         if (pdesc->flags & MXS_DMA_DESC_FIRST)
435                 pchan->pending_num++;
436         list_add_tail(&pdesc->node, &pchan->active);
437
438         mxs_dma_flush_desc(pdesc);
439
440         return ret;
441 }
442
443 /*
444  * Clean up processed DMA descriptors.
445  *
446  * This function removes processed DMA descriptors from the "active" list. Pass
447  * in a non-NULL list head to get the descriptors moved to your list. Pass NULL
448  * to get the descriptors moved to the channel's "done" list. Descriptors on
449  * the "done" list can be retrieved with mxs_dma_get_finished().
450  *
451  * This function marks the DMA channel as "not busy" if no unprocessed
452  * descriptors remain on the "active" list.
453  */
454 static int mxs_dma_finish(int channel, struct list_head *head)
455 {
456         int sem;
457         struct mxs_dma_chan *pchan;
458         struct list_head *p, *q;
459         struct mxs_dma_desc *pdesc;
460         int ret;
461
462         ret = mxs_dma_validate_chan(channel);
463         if (ret)
464                 return ret;
465
466         pchan = mxs_dma_channels + channel;
467
468         sem = mxs_dma_read_semaphore(channel);
469         if (sem < 0)
470                 return sem;
471
472         if (sem == pchan->active_num)
473                 return 0;
474
475         list_for_each_safe(p, q, &pchan->active) {
476                 if ((pchan->active_num) <= sem)
477                         break;
478
479                 pdesc = list_entry(p, struct mxs_dma_desc, node);
480                 pdesc->flags &= ~MXS_DMA_DESC_READY;
481
482                 if (head)
483                         list_move_tail(p, head);
484                 else
485                         list_move_tail(p, &pchan->done);
486
487                 if (pdesc->flags & MXS_DMA_DESC_LAST)
488                         pchan->active_num--;
489         }
490
491         if (sem == 0)
492                 pchan->flags &= ~MXS_DMA_FLAGS_BUSY;
493
494         return 0;
495 }
496
497 /*
498  * Wait for DMA channel to complete
499  */
500 static int mxs_dma_wait_complete(uint32_t timeout, unsigned int chan)
501 {
502         struct mxs_apbh_regs *apbh_regs =
503                 (struct mxs_apbh_regs *)MXS_APBH_BASE;
504         int ret;
505
506         ret = mxs_dma_validate_chan(chan);
507         if (ret)
508                 return ret;
509
510         if (mxs_wait_mask_set(&apbh_regs->hw_apbh_ctrl1_reg,
511                                 1 << chan, timeout)) {
512                 ret = -ETIMEDOUT;
513                 mxs_dma_reset(chan);
514         }
515
516         return ret;
517 }
518
519 /*
520  * Execute the DMA channel
521  */
522 int mxs_dma_go(int chan)
523 {
524         uint32_t timeout = 10000000;
525         int ret;
526
527         LIST_HEAD(tmp_desc_list);
528
529         mxs_dma_enable_irq(chan, 1);
530         mxs_dma_enable(chan);
531
532         /* Wait for DMA to finish. */
533         ret = mxs_dma_wait_complete(timeout, chan);
534
535         /* Clear out the descriptors we just ran. */
536         mxs_dma_finish(chan, &tmp_desc_list);
537
538         /* Shut the DMA channel down. */
539         mxs_dma_ack_irq(chan);
540         mxs_dma_reset(chan);
541         mxs_dma_enable_irq(chan, 0);
542         mxs_dma_disable(chan);
543
544         return ret;
545 }
546
547 /*
548  * Execute a continuously running circular DMA descriptor.
549  * NOTE: This is not intended for general use, but rather
550  *       for the LCD driver in Smart-LCD mode. It allows
551  *       continuous triggering of the RUN bit there.
552  */
553 void mxs_dma_circ_start(int chan, struct mxs_dma_desc *pdesc)
554 {
555         struct mxs_apbh_regs *apbh_regs =
556                 (struct mxs_apbh_regs *)MXS_APBH_BASE;
557
558         mxs_dma_flush_desc(pdesc);
559
560         mxs_dma_enable_irq(chan, 1);
561
562         writel(mxs_dma_cmd_address(pdesc),
563                 &apbh_regs->ch[chan].hw_apbh_ch_nxtcmdar);
564         writel(1, &apbh_regs->ch[chan].hw_apbh_ch_sema);
565         writel(1 << (chan + APBH_CTRL0_CLKGATE_CHANNEL_OFFSET),
566                 &apbh_regs->hw_apbh_ctrl0_clr);
567 }
568
569 /*
570  * Initialize the DMA hardware
571  */
572 void mxs_dma_init(void)
573 {
574         struct mxs_apbh_regs *apbh_regs =
575                 (struct mxs_apbh_regs *)MXS_APBH_BASE;
576
577         mxs_reset_block(&apbh_regs->hw_apbh_ctrl0_reg);
578
579 #ifdef CONFIG_APBH_DMA_BURST8
580         writel(APBH_CTRL0_AHB_BURST8_EN,
581                 &apbh_regs->hw_apbh_ctrl0_set);
582 #else
583         writel(APBH_CTRL0_AHB_BURST8_EN,
584                 &apbh_regs->hw_apbh_ctrl0_clr);
585 #endif
586
587 #ifdef CONFIG_APBH_DMA_BURST
588         writel(APBH_CTRL0_APB_BURST_EN,
589                 &apbh_regs->hw_apbh_ctrl0_set);
590 #else
591         writel(APBH_CTRL0_APB_BURST_EN,
592                 &apbh_regs->hw_apbh_ctrl0_clr);
593 #endif
594 }
595
596 int mxs_dma_init_channel(int channel)
597 {
598         struct mxs_dma_chan *pchan;
599         int ret;
600
601         pchan = mxs_dma_channels + channel;
602         pchan->flags = MXS_DMA_FLAGS_VALID;
603
604         ret = mxs_dma_request(channel);
605
606         if (ret) {
607                 printf("MXS DMA: Can't acquire DMA channel %i\n",
608                         channel);
609                 return ret;
610         }
611
612         mxs_dma_reset(channel);
613         mxs_dma_ack_irq(channel);
614
615         return 0;
616 }