fsldma: reduce locking during descriptor cleanup
[linux-2.6.git] / drivers / dma / fsldma.c
1 /*
2  * Freescale MPC85xx, MPC83xx DMA Engine support
3  *
4  * Copyright (C) 2007-2010 Freescale Semiconductor, Inc. All rights reserved.
5  *
6  * Author:
7  *   Zhang Wei <wei.zhang@freescale.com>, Jul 2007
8  *   Ebony Zhu <ebony.zhu@freescale.com>, May 2007
9  *
10  * Description:
11  *   DMA engine driver for Freescale MPC8540 DMA controller, which is
12  *   also fit for MPC8560, MPC8555, MPC8548, MPC8641, and etc.
13  *   The support for MPC8349 DMA controller is also added.
14  *
15  * This driver instructs the DMA controller to issue the PCI Read Multiple
16  * command for PCI read operations, instead of using the default PCI Read Line
17  * command. Please be aware that this setting may result in read pre-fetching
18  * on some platforms.
19  *
20  * This is free software; you can redistribute it and/or modify
21  * it under the terms of the GNU General Public License as published by
22  * the Free Software Foundation; either version 2 of the License, or
23  * (at your option) any later version.
24  *
25  */
26
27 #include <linux/init.h>
28 #include <linux/module.h>
29 #include <linux/pci.h>
30 #include <linux/slab.h>
31 #include <linux/interrupt.h>
32 #include <linux/dmaengine.h>
33 #include <linux/delay.h>
34 #include <linux/dma-mapping.h>
35 #include <linux/dmapool.h>
36 #include <linux/of_platform.h>
37
38 #include "fsldma.h"
39
40 #define chan_dbg(chan, fmt, arg...)                                     \
41         dev_dbg(chan->dev, "%s: " fmt, chan->name, ##arg)
42 #define chan_err(chan, fmt, arg...)                                     \
43         dev_err(chan->dev, "%s: " fmt, chan->name, ##arg)
44
45 static const char msg_ld_oom[] = "No free memory for link descriptor";
46
47 /*
48  * Register Helpers
49  */
50
51 static void set_sr(struct fsldma_chan *chan, u32 val)
52 {
53         DMA_OUT(chan, &chan->regs->sr, val, 32);
54 }
55
56 static u32 get_sr(struct fsldma_chan *chan)
57 {
58         return DMA_IN(chan, &chan->regs->sr, 32);
59 }
60
61 static void set_cdar(struct fsldma_chan *chan, dma_addr_t addr)
62 {
63         DMA_OUT(chan, &chan->regs->cdar, addr | FSL_DMA_SNEN, 64);
64 }
65
66 static dma_addr_t get_cdar(struct fsldma_chan *chan)
67 {
68         return DMA_IN(chan, &chan->regs->cdar, 64) & ~FSL_DMA_SNEN;
69 }
70
71 static u32 get_bcr(struct fsldma_chan *chan)
72 {
73         return DMA_IN(chan, &chan->regs->bcr, 32);
74 }
75
76 /*
77  * Descriptor Helpers
78  */
79
80 static void set_desc_cnt(struct fsldma_chan *chan,
81                                 struct fsl_dma_ld_hw *hw, u32 count)
82 {
83         hw->count = CPU_TO_DMA(chan, count, 32);
84 }
85
86 static u32 get_desc_cnt(struct fsldma_chan *chan, struct fsl_desc_sw *desc)
87 {
88         return DMA_TO_CPU(chan, desc->hw.count, 32);
89 }
90
91 static void set_desc_src(struct fsldma_chan *chan,
92                          struct fsl_dma_ld_hw *hw, dma_addr_t src)
93 {
94         u64 snoop_bits;
95
96         snoop_bits = ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_85XX)
97                 ? ((u64)FSL_DMA_SATR_SREADTYPE_SNOOP_READ << 32) : 0;
98         hw->src_addr = CPU_TO_DMA(chan, snoop_bits | src, 64);
99 }
100
101 static dma_addr_t get_desc_src(struct fsldma_chan *chan,
102                                struct fsl_desc_sw *desc)
103 {
104         u64 snoop_bits;
105
106         snoop_bits = ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_85XX)
107                 ? ((u64)FSL_DMA_SATR_SREADTYPE_SNOOP_READ << 32) : 0;
108         return DMA_TO_CPU(chan, desc->hw.src_addr, 64) & ~snoop_bits;
109 }
110
111 static void set_desc_dst(struct fsldma_chan *chan,
112                          struct fsl_dma_ld_hw *hw, dma_addr_t dst)
113 {
114         u64 snoop_bits;
115
116         snoop_bits = ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_85XX)
117                 ? ((u64)FSL_DMA_DATR_DWRITETYPE_SNOOP_WRITE << 32) : 0;
118         hw->dst_addr = CPU_TO_DMA(chan, snoop_bits | dst, 64);
119 }
120
121 static dma_addr_t get_desc_dst(struct fsldma_chan *chan,
122                                struct fsl_desc_sw *desc)
123 {
124         u64 snoop_bits;
125
126         snoop_bits = ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_85XX)
127                 ? ((u64)FSL_DMA_DATR_DWRITETYPE_SNOOP_WRITE << 32) : 0;
128         return DMA_TO_CPU(chan, desc->hw.dst_addr, 64) & ~snoop_bits;
129 }
130
131 static void set_desc_next(struct fsldma_chan *chan,
132                           struct fsl_dma_ld_hw *hw, dma_addr_t next)
133 {
134         u64 snoop_bits;
135
136         snoop_bits = ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_83XX)
137                 ? FSL_DMA_SNEN : 0;
138         hw->next_ln_addr = CPU_TO_DMA(chan, snoop_bits | next, 64);
139 }
140
141 static void set_ld_eol(struct fsldma_chan *chan, struct fsl_desc_sw *desc)
142 {
143         u64 snoop_bits;
144
145         snoop_bits = ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_83XX)
146                 ? FSL_DMA_SNEN : 0;
147
148         desc->hw.next_ln_addr = CPU_TO_DMA(chan,
149                 DMA_TO_CPU(chan, desc->hw.next_ln_addr, 64) | FSL_DMA_EOL
150                         | snoop_bits, 64);
151 }
152
153 /*
154  * DMA Engine Hardware Control Helpers
155  */
156
157 static void dma_init(struct fsldma_chan *chan)
158 {
159         /* Reset the channel */
160         DMA_OUT(chan, &chan->regs->mr, 0, 32);
161
162         switch (chan->feature & FSL_DMA_IP_MASK) {
163         case FSL_DMA_IP_85XX:
164                 /* Set the channel to below modes:
165                  * EIE - Error interrupt enable
166                  * EOLNIE - End of links interrupt enable
167                  * BWC - Bandwidth sharing among channels
168                  */
169                 DMA_OUT(chan, &chan->regs->mr, FSL_DMA_MR_BWC
170                                 | FSL_DMA_MR_EIE | FSL_DMA_MR_EOLNIE, 32);
171                 break;
172         case FSL_DMA_IP_83XX:
173                 /* Set the channel to below modes:
174                  * EOTIE - End-of-transfer interrupt enable
175                  * PRC_RM - PCI read multiple
176                  */
177                 DMA_OUT(chan, &chan->regs->mr, FSL_DMA_MR_EOTIE
178                                 | FSL_DMA_MR_PRC_RM, 32);
179                 break;
180         }
181 }
182
183 static int dma_is_idle(struct fsldma_chan *chan)
184 {
185         u32 sr = get_sr(chan);
186         return (!(sr & FSL_DMA_SR_CB)) || (sr & FSL_DMA_SR_CH);
187 }
188
189 /*
190  * Start the DMA controller
191  *
192  * Preconditions:
193  * - the CDAR register must point to the start descriptor
194  * - the MRn[CS] bit must be cleared
195  */
196 static void dma_start(struct fsldma_chan *chan)
197 {
198         u32 mode;
199
200         mode = DMA_IN(chan, &chan->regs->mr, 32);
201
202         if (chan->feature & FSL_DMA_CHAN_PAUSE_EXT) {
203                 DMA_OUT(chan, &chan->regs->bcr, 0, 32);
204                 mode |= FSL_DMA_MR_EMP_EN;
205         } else {
206                 mode &= ~FSL_DMA_MR_EMP_EN;
207         }
208
209         if (chan->feature & FSL_DMA_CHAN_START_EXT) {
210                 mode |= FSL_DMA_MR_EMS_EN;
211         } else {
212                 mode &= ~FSL_DMA_MR_EMS_EN;
213                 mode |= FSL_DMA_MR_CS;
214         }
215
216         DMA_OUT(chan, &chan->regs->mr, mode, 32);
217 }
218
219 static void dma_halt(struct fsldma_chan *chan)
220 {
221         u32 mode;
222         int i;
223
224         mode = DMA_IN(chan, &chan->regs->mr, 32);
225         mode |= FSL_DMA_MR_CA;
226         DMA_OUT(chan, &chan->regs->mr, mode, 32);
227
228         mode &= ~(FSL_DMA_MR_CS | FSL_DMA_MR_EMS_EN | FSL_DMA_MR_CA);
229         DMA_OUT(chan, &chan->regs->mr, mode, 32);
230
231         for (i = 0; i < 100; i++) {
232                 if (dma_is_idle(chan))
233                         return;
234
235                 udelay(10);
236         }
237
238         if (!dma_is_idle(chan))
239                 chan_err(chan, "DMA halt timeout!\n");
240 }
241
242 /**
243  * fsl_chan_set_src_loop_size - Set source address hold transfer size
244  * @chan : Freescale DMA channel
245  * @size     : Address loop size, 0 for disable loop
246  *
247  * The set source address hold transfer size. The source
248  * address hold or loop transfer size is when the DMA transfer
249  * data from source address (SA), if the loop size is 4, the DMA will
250  * read data from SA, SA + 1, SA + 2, SA + 3, then loop back to SA,
251  * SA + 1 ... and so on.
252  */
253 static void fsl_chan_set_src_loop_size(struct fsldma_chan *chan, int size)
254 {
255         u32 mode;
256
257         mode = DMA_IN(chan, &chan->regs->mr, 32);
258
259         switch (size) {
260         case 0:
261                 mode &= ~FSL_DMA_MR_SAHE;
262                 break;
263         case 1:
264         case 2:
265         case 4:
266         case 8:
267                 mode |= FSL_DMA_MR_SAHE | (__ilog2(size) << 14);
268                 break;
269         }
270
271         DMA_OUT(chan, &chan->regs->mr, mode, 32);
272 }
273
274 /**
275  * fsl_chan_set_dst_loop_size - Set destination address hold transfer size
276  * @chan : Freescale DMA channel
277  * @size     : Address loop size, 0 for disable loop
278  *
279  * The set destination address hold transfer size. The destination
280  * address hold or loop transfer size is when the DMA transfer
281  * data to destination address (TA), if the loop size is 4, the DMA will
282  * write data to TA, TA + 1, TA + 2, TA + 3, then loop back to TA,
283  * TA + 1 ... and so on.
284  */
285 static void fsl_chan_set_dst_loop_size(struct fsldma_chan *chan, int size)
286 {
287         u32 mode;
288
289         mode = DMA_IN(chan, &chan->regs->mr, 32);
290
291         switch (size) {
292         case 0:
293                 mode &= ~FSL_DMA_MR_DAHE;
294                 break;
295         case 1:
296         case 2:
297         case 4:
298         case 8:
299                 mode |= FSL_DMA_MR_DAHE | (__ilog2(size) << 16);
300                 break;
301         }
302
303         DMA_OUT(chan, &chan->regs->mr, mode, 32);
304 }
305
306 /**
307  * fsl_chan_set_request_count - Set DMA Request Count for external control
308  * @chan : Freescale DMA channel
309  * @size     : Number of bytes to transfer in a single request
310  *
311  * The Freescale DMA channel can be controlled by the external signal DREQ#.
312  * The DMA request count is how many bytes are allowed to transfer before
313  * pausing the channel, after which a new assertion of DREQ# resumes channel
314  * operation.
315  *
316  * A size of 0 disables external pause control. The maximum size is 1024.
317  */
318 static void fsl_chan_set_request_count(struct fsldma_chan *chan, int size)
319 {
320         u32 mode;
321
322         BUG_ON(size > 1024);
323
324         mode = DMA_IN(chan, &chan->regs->mr, 32);
325         mode |= (__ilog2(size) << 24) & 0x0f000000;
326
327         DMA_OUT(chan, &chan->regs->mr, mode, 32);
328 }
329
330 /**
331  * fsl_chan_toggle_ext_pause - Toggle channel external pause status
332  * @chan : Freescale DMA channel
333  * @enable   : 0 is disabled, 1 is enabled.
334  *
335  * The Freescale DMA channel can be controlled by the external signal DREQ#.
336  * The DMA Request Count feature should be used in addition to this feature
337  * to set the number of bytes to transfer before pausing the channel.
338  */
339 static void fsl_chan_toggle_ext_pause(struct fsldma_chan *chan, int enable)
340 {
341         if (enable)
342                 chan->feature |= FSL_DMA_CHAN_PAUSE_EXT;
343         else
344                 chan->feature &= ~FSL_DMA_CHAN_PAUSE_EXT;
345 }
346
347 /**
348  * fsl_chan_toggle_ext_start - Toggle channel external start status
349  * @chan : Freescale DMA channel
350  * @enable   : 0 is disabled, 1 is enabled.
351  *
352  * If enable the external start, the channel can be started by an
353  * external DMA start pin. So the dma_start() does not start the
354  * transfer immediately. The DMA channel will wait for the
355  * control pin asserted.
356  */
357 static void fsl_chan_toggle_ext_start(struct fsldma_chan *chan, int enable)
358 {
359         if (enable)
360                 chan->feature |= FSL_DMA_CHAN_START_EXT;
361         else
362                 chan->feature &= ~FSL_DMA_CHAN_START_EXT;
363 }
364
365 static void append_ld_queue(struct fsldma_chan *chan, struct fsl_desc_sw *desc)
366 {
367         struct fsl_desc_sw *tail = to_fsl_desc(chan->ld_pending.prev);
368
369         if (list_empty(&chan->ld_pending))
370                 goto out_splice;
371
372         /*
373          * Add the hardware descriptor to the chain of hardware descriptors
374          * that already exists in memory.
375          *
376          * This will un-set the EOL bit of the existing transaction, and the
377          * last link in this transaction will become the EOL descriptor.
378          */
379         set_desc_next(chan, &tail->hw, desc->async_tx.phys);
380
381         /*
382          * Add the software descriptor and all children to the list
383          * of pending transactions
384          */
385 out_splice:
386         list_splice_tail_init(&desc->tx_list, &chan->ld_pending);
387 }
388
389 static dma_cookie_t fsl_dma_tx_submit(struct dma_async_tx_descriptor *tx)
390 {
391         struct fsldma_chan *chan = to_fsl_chan(tx->chan);
392         struct fsl_desc_sw *desc = tx_to_fsl_desc(tx);
393         struct fsl_desc_sw *child;
394         unsigned long flags;
395         dma_cookie_t cookie;
396
397         spin_lock_irqsave(&chan->desc_lock, flags);
398
399         /*
400          * assign cookies to all of the software descriptors
401          * that make up this transaction
402          */
403         cookie = chan->common.cookie;
404         list_for_each_entry(child, &desc->tx_list, node) {
405                 cookie++;
406                 if (cookie < DMA_MIN_COOKIE)
407                         cookie = DMA_MIN_COOKIE;
408
409                 child->async_tx.cookie = cookie;
410         }
411
412         chan->common.cookie = cookie;
413
414         /* put this transaction onto the tail of the pending queue */
415         append_ld_queue(chan, desc);
416
417         spin_unlock_irqrestore(&chan->desc_lock, flags);
418
419         return cookie;
420 }
421
422 /**
423  * fsl_dma_alloc_descriptor - Allocate descriptor from channel's DMA pool.
424  * @chan : Freescale DMA channel
425  *
426  * Return - The descriptor allocated. NULL for failed.
427  */
428 static struct fsl_desc_sw *fsl_dma_alloc_descriptor(struct fsldma_chan *chan)
429 {
430         struct fsl_desc_sw *desc;
431         dma_addr_t pdesc;
432
433         desc = dma_pool_alloc(chan->desc_pool, GFP_ATOMIC, &pdesc);
434         if (!desc) {
435                 chan_dbg(chan, "out of memory for link descriptor\n");
436                 return NULL;
437         }
438
439         memset(desc, 0, sizeof(*desc));
440         INIT_LIST_HEAD(&desc->tx_list);
441         dma_async_tx_descriptor_init(&desc->async_tx, &chan->common);
442         desc->async_tx.tx_submit = fsl_dma_tx_submit;
443         desc->async_tx.phys = pdesc;
444
445 #ifdef FSL_DMA_LD_DEBUG
446         chan_dbg(chan, "LD %p allocated\n", desc);
447 #endif
448
449         return desc;
450 }
451
452 /**
453  * fsl_dma_alloc_chan_resources - Allocate resources for DMA channel.
454  * @chan : Freescale DMA channel
455  *
456  * This function will create a dma pool for descriptor allocation.
457  *
458  * Return - The number of descriptors allocated.
459  */
460 static int fsl_dma_alloc_chan_resources(struct dma_chan *dchan)
461 {
462         struct fsldma_chan *chan = to_fsl_chan(dchan);
463
464         /* Has this channel already been allocated? */
465         if (chan->desc_pool)
466                 return 1;
467
468         /*
469          * We need the descriptor to be aligned to 32bytes
470          * for meeting FSL DMA specification requirement.
471          */
472         chan->desc_pool = dma_pool_create(chan->name, chan->dev,
473                                           sizeof(struct fsl_desc_sw),
474                                           __alignof__(struct fsl_desc_sw), 0);
475         if (!chan->desc_pool) {
476                 chan_err(chan, "unable to allocate descriptor pool\n");
477                 return -ENOMEM;
478         }
479
480         /* there is at least one descriptor free to be allocated */
481         return 1;
482 }
483
484 /**
485  * fsldma_free_desc_list - Free all descriptors in a queue
486  * @chan: Freescae DMA channel
487  * @list: the list to free
488  *
489  * LOCKING: must hold chan->desc_lock
490  */
491 static void fsldma_free_desc_list(struct fsldma_chan *chan,
492                                   struct list_head *list)
493 {
494         struct fsl_desc_sw *desc, *_desc;
495
496         list_for_each_entry_safe(desc, _desc, list, node) {
497                 list_del(&desc->node);
498 #ifdef FSL_DMA_LD_DEBUG
499                 chan_dbg(chan, "LD %p free\n", desc);
500 #endif
501                 dma_pool_free(chan->desc_pool, desc, desc->async_tx.phys);
502         }
503 }
504
505 static void fsldma_free_desc_list_reverse(struct fsldma_chan *chan,
506                                           struct list_head *list)
507 {
508         struct fsl_desc_sw *desc, *_desc;
509
510         list_for_each_entry_safe_reverse(desc, _desc, list, node) {
511                 list_del(&desc->node);
512 #ifdef FSL_DMA_LD_DEBUG
513                 chan_dbg(chan, "LD %p free\n", desc);
514 #endif
515                 dma_pool_free(chan->desc_pool, desc, desc->async_tx.phys);
516         }
517 }
518
519 /**
520  * fsl_dma_free_chan_resources - Free all resources of the channel.
521  * @chan : Freescale DMA channel
522  */
523 static void fsl_dma_free_chan_resources(struct dma_chan *dchan)
524 {
525         struct fsldma_chan *chan = to_fsl_chan(dchan);
526         unsigned long flags;
527
528         chan_dbg(chan, "free all channel resources\n");
529         spin_lock_irqsave(&chan->desc_lock, flags);
530         fsldma_free_desc_list(chan, &chan->ld_pending);
531         fsldma_free_desc_list(chan, &chan->ld_running);
532         spin_unlock_irqrestore(&chan->desc_lock, flags);
533
534         dma_pool_destroy(chan->desc_pool);
535         chan->desc_pool = NULL;
536 }
537
538 static struct dma_async_tx_descriptor *
539 fsl_dma_prep_interrupt(struct dma_chan *dchan, unsigned long flags)
540 {
541         struct fsldma_chan *chan;
542         struct fsl_desc_sw *new;
543
544         if (!dchan)
545                 return NULL;
546
547         chan = to_fsl_chan(dchan);
548
549         new = fsl_dma_alloc_descriptor(chan);
550         if (!new) {
551                 chan_err(chan, "%s\n", msg_ld_oom);
552                 return NULL;
553         }
554
555         new->async_tx.cookie = -EBUSY;
556         new->async_tx.flags = flags;
557
558         /* Insert the link descriptor to the LD ring */
559         list_add_tail(&new->node, &new->tx_list);
560
561         /* Set End-of-link to the last link descriptor of new list */
562         set_ld_eol(chan, new);
563
564         return &new->async_tx;
565 }
566
567 static struct dma_async_tx_descriptor *
568 fsl_dma_prep_memcpy(struct dma_chan *dchan,
569         dma_addr_t dma_dst, dma_addr_t dma_src,
570         size_t len, unsigned long flags)
571 {
572         struct fsldma_chan *chan;
573         struct fsl_desc_sw *first = NULL, *prev = NULL, *new;
574         size_t copy;
575
576         if (!dchan)
577                 return NULL;
578
579         if (!len)
580                 return NULL;
581
582         chan = to_fsl_chan(dchan);
583
584         do {
585
586                 /* Allocate the link descriptor from DMA pool */
587                 new = fsl_dma_alloc_descriptor(chan);
588                 if (!new) {
589                         chan_err(chan, "%s\n", msg_ld_oom);
590                         goto fail;
591                 }
592
593                 copy = min(len, (size_t)FSL_DMA_BCR_MAX_CNT);
594
595                 set_desc_cnt(chan, &new->hw, copy);
596                 set_desc_src(chan, &new->hw, dma_src);
597                 set_desc_dst(chan, &new->hw, dma_dst);
598
599                 if (!first)
600                         first = new;
601                 else
602                         set_desc_next(chan, &prev->hw, new->async_tx.phys);
603
604                 new->async_tx.cookie = 0;
605                 async_tx_ack(&new->async_tx);
606
607                 prev = new;
608                 len -= copy;
609                 dma_src += copy;
610                 dma_dst += copy;
611
612                 /* Insert the link descriptor to the LD ring */
613                 list_add_tail(&new->node, &first->tx_list);
614         } while (len);
615
616         new->async_tx.flags = flags; /* client is in control of this ack */
617         new->async_tx.cookie = -EBUSY;
618
619         /* Set End-of-link to the last link descriptor of new list */
620         set_ld_eol(chan, new);
621
622         return &first->async_tx;
623
624 fail:
625         if (!first)
626                 return NULL;
627
628         fsldma_free_desc_list_reverse(chan, &first->tx_list);
629         return NULL;
630 }
631
632 static struct dma_async_tx_descriptor *fsl_dma_prep_sg(struct dma_chan *dchan,
633         struct scatterlist *dst_sg, unsigned int dst_nents,
634         struct scatterlist *src_sg, unsigned int src_nents,
635         unsigned long flags)
636 {
637         struct fsl_desc_sw *first = NULL, *prev = NULL, *new = NULL;
638         struct fsldma_chan *chan = to_fsl_chan(dchan);
639         size_t dst_avail, src_avail;
640         dma_addr_t dst, src;
641         size_t len;
642
643         /* basic sanity checks */
644         if (dst_nents == 0 || src_nents == 0)
645                 return NULL;
646
647         if (dst_sg == NULL || src_sg == NULL)
648                 return NULL;
649
650         /*
651          * TODO: should we check that both scatterlists have the same
652          * TODO: number of bytes in total? Is that really an error?
653          */
654
655         /* get prepared for the loop */
656         dst_avail = sg_dma_len(dst_sg);
657         src_avail = sg_dma_len(src_sg);
658
659         /* run until we are out of scatterlist entries */
660         while (true) {
661
662                 /* create the largest transaction possible */
663                 len = min_t(size_t, src_avail, dst_avail);
664                 len = min_t(size_t, len, FSL_DMA_BCR_MAX_CNT);
665                 if (len == 0)
666                         goto fetch;
667
668                 dst = sg_dma_address(dst_sg) + sg_dma_len(dst_sg) - dst_avail;
669                 src = sg_dma_address(src_sg) + sg_dma_len(src_sg) - src_avail;
670
671                 /* allocate and populate the descriptor */
672                 new = fsl_dma_alloc_descriptor(chan);
673                 if (!new) {
674                         chan_err(chan, "%s\n", msg_ld_oom);
675                         goto fail;
676                 }
677
678                 set_desc_cnt(chan, &new->hw, len);
679                 set_desc_src(chan, &new->hw, src);
680                 set_desc_dst(chan, &new->hw, dst);
681
682                 if (!first)
683                         first = new;
684                 else
685                         set_desc_next(chan, &prev->hw, new->async_tx.phys);
686
687                 new->async_tx.cookie = 0;
688                 async_tx_ack(&new->async_tx);
689                 prev = new;
690
691                 /* Insert the link descriptor to the LD ring */
692                 list_add_tail(&new->node, &first->tx_list);
693
694                 /* update metadata */
695                 dst_avail -= len;
696                 src_avail -= len;
697
698 fetch:
699                 /* fetch the next dst scatterlist entry */
700                 if (dst_avail == 0) {
701
702                         /* no more entries: we're done */
703                         if (dst_nents == 0)
704                                 break;
705
706                         /* fetch the next entry: if there are no more: done */
707                         dst_sg = sg_next(dst_sg);
708                         if (dst_sg == NULL)
709                                 break;
710
711                         dst_nents--;
712                         dst_avail = sg_dma_len(dst_sg);
713                 }
714
715                 /* fetch the next src scatterlist entry */
716                 if (src_avail == 0) {
717
718                         /* no more entries: we're done */
719                         if (src_nents == 0)
720                                 break;
721
722                         /* fetch the next entry: if there are no more: done */
723                         src_sg = sg_next(src_sg);
724                         if (src_sg == NULL)
725                                 break;
726
727                         src_nents--;
728                         src_avail = sg_dma_len(src_sg);
729                 }
730         }
731
732         new->async_tx.flags = flags; /* client is in control of this ack */
733         new->async_tx.cookie = -EBUSY;
734
735         /* Set End-of-link to the last link descriptor of new list */
736         set_ld_eol(chan, new);
737
738         return &first->async_tx;
739
740 fail:
741         if (!first)
742                 return NULL;
743
744         fsldma_free_desc_list_reverse(chan, &first->tx_list);
745         return NULL;
746 }
747
748 /**
749  * fsl_dma_prep_slave_sg - prepare descriptors for a DMA_SLAVE transaction
750  * @chan: DMA channel
751  * @sgl: scatterlist to transfer to/from
752  * @sg_len: number of entries in @scatterlist
753  * @direction: DMA direction
754  * @flags: DMAEngine flags
755  *
756  * Prepare a set of descriptors for a DMA_SLAVE transaction. Following the
757  * DMA_SLAVE API, this gets the device-specific information from the
758  * chan->private variable.
759  */
760 static struct dma_async_tx_descriptor *fsl_dma_prep_slave_sg(
761         struct dma_chan *dchan, struct scatterlist *sgl, unsigned int sg_len,
762         enum dma_data_direction direction, unsigned long flags)
763 {
764         /*
765          * This operation is not supported on the Freescale DMA controller
766          *
767          * However, we need to provide the function pointer to allow the
768          * device_control() method to work.
769          */
770         return NULL;
771 }
772
773 static int fsl_dma_device_control(struct dma_chan *dchan,
774                                   enum dma_ctrl_cmd cmd, unsigned long arg)
775 {
776         struct dma_slave_config *config;
777         struct fsldma_chan *chan;
778         unsigned long flags;
779         int size;
780
781         if (!dchan)
782                 return -EINVAL;
783
784         chan = to_fsl_chan(dchan);
785
786         switch (cmd) {
787         case DMA_TERMINATE_ALL:
788                 spin_lock_irqsave(&chan->desc_lock, flags);
789
790                 /* Halt the DMA engine */
791                 dma_halt(chan);
792
793                 /* Remove and free all of the descriptors in the LD queue */
794                 fsldma_free_desc_list(chan, &chan->ld_pending);
795                 fsldma_free_desc_list(chan, &chan->ld_running);
796                 chan->idle = true;
797
798                 spin_unlock_irqrestore(&chan->desc_lock, flags);
799                 return 0;
800
801         case DMA_SLAVE_CONFIG:
802                 config = (struct dma_slave_config *)arg;
803
804                 /* make sure the channel supports setting burst size */
805                 if (!chan->set_request_count)
806                         return -ENXIO;
807
808                 /* we set the controller burst size depending on direction */
809                 if (config->direction == DMA_TO_DEVICE)
810                         size = config->dst_addr_width * config->dst_maxburst;
811                 else
812                         size = config->src_addr_width * config->src_maxburst;
813
814                 chan->set_request_count(chan, size);
815                 return 0;
816
817         case FSLDMA_EXTERNAL_START:
818
819                 /* make sure the channel supports external start */
820                 if (!chan->toggle_ext_start)
821                         return -ENXIO;
822
823                 chan->toggle_ext_start(chan, arg);
824                 return 0;
825
826         default:
827                 return -ENXIO;
828         }
829
830         return 0;
831 }
832
833 /**
834  * fsldma_cleanup_descriptor - cleanup and free a single link descriptor
835  * @chan: Freescale DMA channel
836  * @desc: descriptor to cleanup and free
837  *
838  * This function is used on a descriptor which has been executed by the DMA
839  * controller. It will run any callbacks, submit any dependencies, and then
840  * free the descriptor.
841  */
842 static void fsldma_cleanup_descriptor(struct fsldma_chan *chan,
843                                       struct fsl_desc_sw *desc)
844 {
845         struct dma_async_tx_descriptor *txd = &desc->async_tx;
846         struct device *dev = chan->common.device->dev;
847         dma_addr_t src = get_desc_src(chan, desc);
848         dma_addr_t dst = get_desc_dst(chan, desc);
849         u32 len = get_desc_cnt(chan, desc);
850
851         /* Run the link descriptor callback function */
852         if (txd->callback) {
853 #ifdef FSL_DMA_LD_DEBUG
854                 chan_dbg(chan, "LD %p callback\n", desc);
855 #endif
856                 txd->callback(txd->callback_param);
857         }
858
859         /* Run any dependencies */
860         dma_run_dependencies(txd);
861
862         /* Unmap the dst buffer, if requested */
863         if (!(txd->flags & DMA_COMPL_SKIP_DEST_UNMAP)) {
864                 if (txd->flags & DMA_COMPL_DEST_UNMAP_SINGLE)
865                         dma_unmap_single(dev, dst, len, DMA_FROM_DEVICE);
866                 else
867                         dma_unmap_page(dev, dst, len, DMA_FROM_DEVICE);
868         }
869
870         /* Unmap the src buffer, if requested */
871         if (!(txd->flags & DMA_COMPL_SKIP_SRC_UNMAP)) {
872                 if (txd->flags & DMA_COMPL_SRC_UNMAP_SINGLE)
873                         dma_unmap_single(dev, src, len, DMA_TO_DEVICE);
874                 else
875                         dma_unmap_page(dev, src, len, DMA_TO_DEVICE);
876         }
877
878 #ifdef FSL_DMA_LD_DEBUG
879         chan_dbg(chan, "LD %p free\n", desc);
880 #endif
881         dma_pool_free(chan->desc_pool, desc, txd->phys);
882 }
883
884 /**
885  * fsl_chan_xfer_ld_queue - transfer any pending transactions
886  * @chan : Freescale DMA channel
887  *
888  * HARDWARE STATE: idle
889  * LOCKING: must hold chan->desc_lock
890  */
891 static void fsl_chan_xfer_ld_queue(struct fsldma_chan *chan)
892 {
893         struct fsl_desc_sw *desc;
894
895         /*
896          * If the list of pending descriptors is empty, then we
897          * don't need to do any work at all
898          */
899         if (list_empty(&chan->ld_pending)) {
900                 chan_dbg(chan, "no pending LDs\n");
901                 return;
902         }
903
904         /*
905          * The DMA controller is not idle, which means that the interrupt
906          * handler will start any queued transactions when it runs after
907          * this transaction finishes
908          */
909         if (!chan->idle) {
910                 chan_dbg(chan, "DMA controller still busy\n");
911                 return;
912         }
913
914         /*
915          * If there are some link descriptors which have not been
916          * transferred, we need to start the controller
917          */
918
919         /*
920          * Move all elements from the queue of pending transactions
921          * onto the list of running transactions
922          */
923         chan_dbg(chan, "idle, starting controller\n");
924         desc = list_first_entry(&chan->ld_pending, struct fsl_desc_sw, node);
925         list_splice_tail_init(&chan->ld_pending, &chan->ld_running);
926
927         /*
928          * The 85xx DMA controller doesn't clear the channel start bit
929          * automatically at the end of a transfer. Therefore we must clear
930          * it in software before starting the transfer.
931          */
932         if ((chan->feature & FSL_DMA_IP_MASK) == FSL_DMA_IP_85XX) {
933                 u32 mode;
934
935                 mode = DMA_IN(chan, &chan->regs->mr, 32);
936                 mode &= ~FSL_DMA_MR_CS;
937                 DMA_OUT(chan, &chan->regs->mr, mode, 32);
938         }
939
940         /*
941          * Program the descriptor's address into the DMA controller,
942          * then start the DMA transaction
943          */
944         set_cdar(chan, desc->async_tx.phys);
945         get_cdar(chan);
946
947         dma_start(chan);
948         chan->idle = false;
949 }
950
951 /**
952  * fsl_dma_memcpy_issue_pending - Issue the DMA start command
953  * @chan : Freescale DMA channel
954  */
955 static void fsl_dma_memcpy_issue_pending(struct dma_chan *dchan)
956 {
957         struct fsldma_chan *chan = to_fsl_chan(dchan);
958         unsigned long flags;
959
960         spin_lock_irqsave(&chan->desc_lock, flags);
961         fsl_chan_xfer_ld_queue(chan);
962         spin_unlock_irqrestore(&chan->desc_lock, flags);
963 }
964
965 /**
966  * fsl_tx_status - Determine the DMA status
967  * @chan : Freescale DMA channel
968  */
969 static enum dma_status fsl_tx_status(struct dma_chan *dchan,
970                                         dma_cookie_t cookie,
971                                         struct dma_tx_state *txstate)
972 {
973         struct fsldma_chan *chan = to_fsl_chan(dchan);
974         dma_cookie_t last_complete;
975         dma_cookie_t last_used;
976         unsigned long flags;
977
978         spin_lock_irqsave(&chan->desc_lock, flags);
979
980         last_complete = chan->completed_cookie;
981         last_used = dchan->cookie;
982
983         spin_unlock_irqrestore(&chan->desc_lock, flags);
984
985         dma_set_tx_state(txstate, last_complete, last_used, 0);
986         return dma_async_is_complete(cookie, last_complete, last_used);
987 }
988
989 /*----------------------------------------------------------------------------*/
990 /* Interrupt Handling                                                         */
991 /*----------------------------------------------------------------------------*/
992
993 static irqreturn_t fsldma_chan_irq(int irq, void *data)
994 {
995         struct fsldma_chan *chan = data;
996         u32 stat;
997
998         /* save and clear the status register */
999         stat = get_sr(chan);
1000         set_sr(chan, stat);
1001         chan_dbg(chan, "irq: stat = 0x%x\n", stat);
1002
1003         /* check that this was really our device */
1004         stat &= ~(FSL_DMA_SR_CB | FSL_DMA_SR_CH);
1005         if (!stat)
1006                 return IRQ_NONE;
1007
1008         if (stat & FSL_DMA_SR_TE)
1009                 chan_err(chan, "Transfer Error!\n");
1010
1011         /*
1012          * Programming Error
1013          * The DMA_INTERRUPT async_tx is a NULL transfer, which will
1014          * triger a PE interrupt.
1015          */
1016         if (stat & FSL_DMA_SR_PE) {
1017                 chan_dbg(chan, "irq: Programming Error INT\n");
1018                 stat &= ~FSL_DMA_SR_PE;
1019                 if (get_bcr(chan) != 0)
1020                         chan_err(chan, "Programming Error!\n");
1021         }
1022
1023         /*
1024          * For MPC8349, EOCDI event need to update cookie
1025          * and start the next transfer if it exist.
1026          */
1027         if (stat & FSL_DMA_SR_EOCDI) {
1028                 chan_dbg(chan, "irq: End-of-Chain link INT\n");
1029                 stat &= ~FSL_DMA_SR_EOCDI;
1030         }
1031
1032         /*
1033          * If it current transfer is the end-of-transfer,
1034          * we should clear the Channel Start bit for
1035          * prepare next transfer.
1036          */
1037         if (stat & FSL_DMA_SR_EOLNI) {
1038                 chan_dbg(chan, "irq: End-of-link INT\n");
1039                 stat &= ~FSL_DMA_SR_EOLNI;
1040         }
1041
1042         /* check that the DMA controller is really idle */
1043         if (!dma_is_idle(chan))
1044                 chan_err(chan, "irq: controller not idle!\n");
1045
1046         /* check that we handled all of the bits */
1047         if (stat)
1048                 chan_err(chan, "irq: unhandled sr 0x%08x\n", stat);
1049
1050         /*
1051          * Schedule the tasklet to handle all cleanup of the current
1052          * transaction. It will start a new transaction if there is
1053          * one pending.
1054          */
1055         tasklet_schedule(&chan->tasklet);
1056         chan_dbg(chan, "irq: Exit\n");
1057         return IRQ_HANDLED;
1058 }
1059
1060 static void dma_do_tasklet(unsigned long data)
1061 {
1062         struct fsldma_chan *chan = (struct fsldma_chan *)data;
1063         struct fsl_desc_sw *desc, *_desc;
1064         LIST_HEAD(ld_cleanup);
1065         unsigned long flags;
1066
1067         chan_dbg(chan, "tasklet entry\n");
1068
1069         spin_lock_irqsave(&chan->desc_lock, flags);
1070
1071         /* update the cookie if we have some descriptors to cleanup */
1072         if (!list_empty(&chan->ld_running)) {
1073                 dma_cookie_t cookie;
1074
1075                 desc = to_fsl_desc(chan->ld_running.prev);
1076                 cookie = desc->async_tx.cookie;
1077
1078                 chan->completed_cookie = cookie;
1079                 chan_dbg(chan, "completed_cookie=%d\n", cookie);
1080         }
1081
1082         /*
1083          * move the descriptors to a temporary list so we can drop the lock
1084          * during the entire cleanup operation
1085          */
1086         list_splice_tail_init(&chan->ld_running, &ld_cleanup);
1087
1088         /* the hardware is now idle and ready for more */
1089         chan->idle = true;
1090
1091         /*
1092          * Start any pending transactions automatically
1093          *
1094          * In the ideal case, we keep the DMA controller busy while we go
1095          * ahead and free the descriptors below.
1096          */
1097         fsl_chan_xfer_ld_queue(chan);
1098         spin_unlock_irqrestore(&chan->desc_lock, flags);
1099
1100         /* Run the callback for each descriptor, in order */
1101         list_for_each_entry_safe(desc, _desc, &ld_cleanup, node) {
1102
1103                 /* Remove from the list of transactions */
1104                 list_del(&desc->node);
1105
1106                 /* Run all cleanup for this descriptor */
1107                 fsldma_cleanup_descriptor(chan, desc);
1108         }
1109
1110         chan_dbg(chan, "tasklet exit\n");
1111 }
1112
1113 static irqreturn_t fsldma_ctrl_irq(int irq, void *data)
1114 {
1115         struct fsldma_device *fdev = data;
1116         struct fsldma_chan *chan;
1117         unsigned int handled = 0;
1118         u32 gsr, mask;
1119         int i;
1120
1121         gsr = (fdev->feature & FSL_DMA_BIG_ENDIAN) ? in_be32(fdev->regs)
1122                                                    : in_le32(fdev->regs);
1123         mask = 0xff000000;
1124         dev_dbg(fdev->dev, "IRQ: gsr 0x%.8x\n", gsr);
1125
1126         for (i = 0; i < FSL_DMA_MAX_CHANS_PER_DEVICE; i++) {
1127                 chan = fdev->chan[i];
1128                 if (!chan)
1129                         continue;
1130
1131                 if (gsr & mask) {
1132                         dev_dbg(fdev->dev, "IRQ: chan %d\n", chan->id);
1133                         fsldma_chan_irq(irq, chan);
1134                         handled++;
1135                 }
1136
1137                 gsr &= ~mask;
1138                 mask >>= 8;
1139         }
1140
1141         return IRQ_RETVAL(handled);
1142 }
1143
1144 static void fsldma_free_irqs(struct fsldma_device *fdev)
1145 {
1146         struct fsldma_chan *chan;
1147         int i;
1148
1149         if (fdev->irq != NO_IRQ) {
1150                 dev_dbg(fdev->dev, "free per-controller IRQ\n");
1151                 free_irq(fdev->irq, fdev);
1152                 return;
1153         }
1154
1155         for (i = 0; i < FSL_DMA_MAX_CHANS_PER_DEVICE; i++) {
1156                 chan = fdev->chan[i];
1157                 if (chan && chan->irq != NO_IRQ) {
1158                         chan_dbg(chan, "free per-channel IRQ\n");
1159                         free_irq(chan->irq, chan);
1160                 }
1161         }
1162 }
1163
1164 static int fsldma_request_irqs(struct fsldma_device *fdev)
1165 {
1166         struct fsldma_chan *chan;
1167         int ret;
1168         int i;
1169
1170         /* if we have a per-controller IRQ, use that */
1171         if (fdev->irq != NO_IRQ) {
1172                 dev_dbg(fdev->dev, "request per-controller IRQ\n");
1173                 ret = request_irq(fdev->irq, fsldma_ctrl_irq, IRQF_SHARED,
1174                                   "fsldma-controller", fdev);
1175                 return ret;
1176         }
1177
1178         /* no per-controller IRQ, use the per-channel IRQs */
1179         for (i = 0; i < FSL_DMA_MAX_CHANS_PER_DEVICE; i++) {
1180                 chan = fdev->chan[i];
1181                 if (!chan)
1182                         continue;
1183
1184                 if (chan->irq == NO_IRQ) {
1185                         chan_err(chan, "interrupts property missing in device tree\n");
1186                         ret = -ENODEV;
1187                         goto out_unwind;
1188                 }
1189
1190                 chan_dbg(chan, "request per-channel IRQ\n");
1191                 ret = request_irq(chan->irq, fsldma_chan_irq, IRQF_SHARED,
1192                                   "fsldma-chan", chan);
1193                 if (ret) {
1194                         chan_err(chan, "unable to request per-channel IRQ\n");
1195                         goto out_unwind;
1196                 }
1197         }
1198
1199         return 0;
1200
1201 out_unwind:
1202         for (/* none */; i >= 0; i--) {
1203                 chan = fdev->chan[i];
1204                 if (!chan)
1205                         continue;
1206
1207                 if (chan->irq == NO_IRQ)
1208                         continue;
1209
1210                 free_irq(chan->irq, chan);
1211         }
1212
1213         return ret;
1214 }
1215
1216 /*----------------------------------------------------------------------------*/
1217 /* OpenFirmware Subsystem                                                     */
1218 /*----------------------------------------------------------------------------*/
1219
1220 static int __devinit fsl_dma_chan_probe(struct fsldma_device *fdev,
1221         struct device_node *node, u32 feature, const char *compatible)
1222 {
1223         struct fsldma_chan *chan;
1224         struct resource res;
1225         int err;
1226
1227         /* alloc channel */
1228         chan = kzalloc(sizeof(*chan), GFP_KERNEL);
1229         if (!chan) {
1230                 dev_err(fdev->dev, "no free memory for DMA channels!\n");
1231                 err = -ENOMEM;
1232                 goto out_return;
1233         }
1234
1235         /* ioremap registers for use */
1236         chan->regs = of_iomap(node, 0);
1237         if (!chan->regs) {
1238                 dev_err(fdev->dev, "unable to ioremap registers\n");
1239                 err = -ENOMEM;
1240                 goto out_free_chan;
1241         }
1242
1243         err = of_address_to_resource(node, 0, &res);
1244         if (err) {
1245                 dev_err(fdev->dev, "unable to find 'reg' property\n");
1246                 goto out_iounmap_regs;
1247         }
1248
1249         chan->feature = feature;
1250         if (!fdev->feature)
1251                 fdev->feature = chan->feature;
1252
1253         /*
1254          * If the DMA device's feature is different than the feature
1255          * of its channels, report the bug
1256          */
1257         WARN_ON(fdev->feature != chan->feature);
1258
1259         chan->dev = fdev->dev;
1260         chan->id = ((res.start - 0x100) & 0xfff) >> 7;
1261         if (chan->id >= FSL_DMA_MAX_CHANS_PER_DEVICE) {
1262                 dev_err(fdev->dev, "too many channels for device\n");
1263                 err = -EINVAL;
1264                 goto out_iounmap_regs;
1265         }
1266
1267         fdev->chan[chan->id] = chan;
1268         tasklet_init(&chan->tasklet, dma_do_tasklet, (unsigned long)chan);
1269         snprintf(chan->name, sizeof(chan->name), "chan%d", chan->id);
1270
1271         /* Initialize the channel */
1272         dma_init(chan);
1273
1274         /* Clear cdar registers */
1275         set_cdar(chan, 0);
1276
1277         switch (chan->feature & FSL_DMA_IP_MASK) {
1278         case FSL_DMA_IP_85XX:
1279                 chan->toggle_ext_pause = fsl_chan_toggle_ext_pause;
1280         case FSL_DMA_IP_83XX:
1281                 chan->toggle_ext_start = fsl_chan_toggle_ext_start;
1282                 chan->set_src_loop_size = fsl_chan_set_src_loop_size;
1283                 chan->set_dst_loop_size = fsl_chan_set_dst_loop_size;
1284                 chan->set_request_count = fsl_chan_set_request_count;
1285         }
1286
1287         spin_lock_init(&chan->desc_lock);
1288         INIT_LIST_HEAD(&chan->ld_pending);
1289         INIT_LIST_HEAD(&chan->ld_running);
1290         chan->idle = true;
1291
1292         chan->common.device = &fdev->common;
1293
1294         /* find the IRQ line, if it exists in the device tree */
1295         chan->irq = irq_of_parse_and_map(node, 0);
1296
1297         /* Add the channel to DMA device channel list */
1298         list_add_tail(&chan->common.device_node, &fdev->common.channels);
1299         fdev->common.chancnt++;
1300
1301         dev_info(fdev->dev, "#%d (%s), irq %d\n", chan->id, compatible,
1302                  chan->irq != NO_IRQ ? chan->irq : fdev->irq);
1303
1304         return 0;
1305
1306 out_iounmap_regs:
1307         iounmap(chan->regs);
1308 out_free_chan:
1309         kfree(chan);
1310 out_return:
1311         return err;
1312 }
1313
1314 static void fsl_dma_chan_remove(struct fsldma_chan *chan)
1315 {
1316         irq_dispose_mapping(chan->irq);
1317         list_del(&chan->common.device_node);
1318         iounmap(chan->regs);
1319         kfree(chan);
1320 }
1321
1322 static int __devinit fsldma_of_probe(struct platform_device *op,
1323                         const struct of_device_id *match)
1324 {
1325         struct fsldma_device *fdev;
1326         struct device_node *child;
1327         int err;
1328
1329         fdev = kzalloc(sizeof(*fdev), GFP_KERNEL);
1330         if (!fdev) {
1331                 dev_err(&op->dev, "No enough memory for 'priv'\n");
1332                 err = -ENOMEM;
1333                 goto out_return;
1334         }
1335
1336         fdev->dev = &op->dev;
1337         INIT_LIST_HEAD(&fdev->common.channels);
1338
1339         /* ioremap the registers for use */
1340         fdev->regs = of_iomap(op->dev.of_node, 0);
1341         if (!fdev->regs) {
1342                 dev_err(&op->dev, "unable to ioremap registers\n");
1343                 err = -ENOMEM;
1344                 goto out_free_fdev;
1345         }
1346
1347         /* map the channel IRQ if it exists, but don't hookup the handler yet */
1348         fdev->irq = irq_of_parse_and_map(op->dev.of_node, 0);
1349
1350         dma_cap_set(DMA_MEMCPY, fdev->common.cap_mask);
1351         dma_cap_set(DMA_INTERRUPT, fdev->common.cap_mask);
1352         dma_cap_set(DMA_SG, fdev->common.cap_mask);
1353         dma_cap_set(DMA_SLAVE, fdev->common.cap_mask);
1354         fdev->common.device_alloc_chan_resources = fsl_dma_alloc_chan_resources;
1355         fdev->common.device_free_chan_resources = fsl_dma_free_chan_resources;
1356         fdev->common.device_prep_dma_interrupt = fsl_dma_prep_interrupt;
1357         fdev->common.device_prep_dma_memcpy = fsl_dma_prep_memcpy;
1358         fdev->common.device_prep_dma_sg = fsl_dma_prep_sg;
1359         fdev->common.device_tx_status = fsl_tx_status;
1360         fdev->common.device_issue_pending = fsl_dma_memcpy_issue_pending;
1361         fdev->common.device_prep_slave_sg = fsl_dma_prep_slave_sg;
1362         fdev->common.device_control = fsl_dma_device_control;
1363         fdev->common.dev = &op->dev;
1364
1365         dma_set_mask(&(op->dev), DMA_BIT_MASK(36));
1366
1367         dev_set_drvdata(&op->dev, fdev);
1368
1369         /*
1370          * We cannot use of_platform_bus_probe() because there is no
1371          * of_platform_bus_remove(). Instead, we manually instantiate every DMA
1372          * channel object.
1373          */
1374         for_each_child_of_node(op->dev.of_node, child) {
1375                 if (of_device_is_compatible(child, "fsl,eloplus-dma-channel")) {
1376                         fsl_dma_chan_probe(fdev, child,
1377                                 FSL_DMA_IP_85XX | FSL_DMA_BIG_ENDIAN,
1378                                 "fsl,eloplus-dma-channel");
1379                 }
1380
1381                 if (of_device_is_compatible(child, "fsl,elo-dma-channel")) {
1382                         fsl_dma_chan_probe(fdev, child,
1383                                 FSL_DMA_IP_83XX | FSL_DMA_LITTLE_ENDIAN,
1384                                 "fsl,elo-dma-channel");
1385                 }
1386         }
1387
1388         /*
1389          * Hookup the IRQ handler(s)
1390          *
1391          * If we have a per-controller interrupt, we prefer that to the
1392          * per-channel interrupts to reduce the number of shared interrupt
1393          * handlers on the same IRQ line
1394          */
1395         err = fsldma_request_irqs(fdev);
1396         if (err) {
1397                 dev_err(fdev->dev, "unable to request IRQs\n");
1398                 goto out_free_fdev;
1399         }
1400
1401         dma_async_device_register(&fdev->common);
1402         return 0;
1403
1404 out_free_fdev:
1405         irq_dispose_mapping(fdev->irq);
1406         kfree(fdev);
1407 out_return:
1408         return err;
1409 }
1410
1411 static int fsldma_of_remove(struct platform_device *op)
1412 {
1413         struct fsldma_device *fdev;
1414         unsigned int i;
1415
1416         fdev = dev_get_drvdata(&op->dev);
1417         dma_async_device_unregister(&fdev->common);
1418
1419         fsldma_free_irqs(fdev);
1420
1421         for (i = 0; i < FSL_DMA_MAX_CHANS_PER_DEVICE; i++) {
1422                 if (fdev->chan[i])
1423                         fsl_dma_chan_remove(fdev->chan[i]);
1424         }
1425
1426         iounmap(fdev->regs);
1427         dev_set_drvdata(&op->dev, NULL);
1428         kfree(fdev);
1429
1430         return 0;
1431 }
1432
1433 static const struct of_device_id fsldma_of_ids[] = {
1434         { .compatible = "fsl,eloplus-dma", },
1435         { .compatible = "fsl,elo-dma", },
1436         {}
1437 };
1438
1439 static struct of_platform_driver fsldma_of_driver = {
1440         .driver = {
1441                 .name = "fsl-elo-dma",
1442                 .owner = THIS_MODULE,
1443                 .of_match_table = fsldma_of_ids,
1444         },
1445         .probe = fsldma_of_probe,
1446         .remove = fsldma_of_remove,
1447 };
1448
1449 /*----------------------------------------------------------------------------*/
1450 /* Module Init / Exit                                                         */
1451 /*----------------------------------------------------------------------------*/
1452
1453 static __init int fsldma_init(void)
1454 {
1455         int ret;
1456
1457         pr_info("Freescale Elo / Elo Plus DMA driver\n");
1458
1459         ret = of_register_platform_driver(&fsldma_of_driver);
1460         if (ret)
1461                 pr_err("fsldma: failed to register platform driver\n");
1462
1463         return ret;
1464 }
1465
1466 static void __exit fsldma_exit(void)
1467 {
1468         of_unregister_platform_driver(&fsldma_of_driver);
1469 }
1470
1471 subsys_initcall(fsldma_init);
1472 module_exit(fsldma_exit);
1473
1474 MODULE_DESCRIPTION("Freescale Elo / Elo Plus DMA driver");
1475 MODULE_LICENSE("GPL");