Merge branch 'mfd/wm8994' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie...
[linux-2.6.git] / drivers / dma / at_hdmac.c
1 /*
2  * Driver for the Atmel AHB DMA Controller (aka HDMA or DMAC on AT91 systems)
3  *
4  * Copyright (C) 2008 Atmel Corporation
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  *
12  * This supports the Atmel AHB DMA Controller,
13  *
14  * The driver has currently been tested with the Atmel AT91SAM9RL
15  * and AT91SAM9G45 series.
16  */
17
18 #include <linux/clk.h>
19 #include <linux/dmaengine.h>
20 #include <linux/dma-mapping.h>
21 #include <linux/dmapool.h>
22 #include <linux/interrupt.h>
23 #include <linux/module.h>
24 #include <linux/platform_device.h>
25 #include <linux/slab.h>
26
27 #include "at_hdmac_regs.h"
28
29 /*
30  * Glossary
31  * --------
32  *
33  * at_hdmac             : Name of the ATmel AHB DMA Controller
34  * at_dma_ / atdma      : ATmel DMA controller entity related
35  * atc_ / atchan        : ATmel DMA Channel entity related
36  */
37
38 #define ATC_DEFAULT_CFG         (ATC_FIFOCFG_HALFFIFO)
39 #define ATC_DEFAULT_CTRLA       (0)
40 #define ATC_DEFAULT_CTRLB       (ATC_SIF(AT_DMA_MEM_IF) \
41                                 |ATC_DIF(AT_DMA_MEM_IF))
42
43 /*
44  * Initial number of descriptors to allocate for each channel. This could
45  * be increased during dma usage.
46  */
47 static unsigned int init_nr_desc_per_channel = 64;
48 module_param(init_nr_desc_per_channel, uint, 0644);
49 MODULE_PARM_DESC(init_nr_desc_per_channel,
50                  "initial descriptors per channel (default: 64)");
51
52
53 /* prototypes */
54 static dma_cookie_t atc_tx_submit(struct dma_async_tx_descriptor *tx);
55
56
57 /*----------------------------------------------------------------------*/
58
59 static struct at_desc *atc_first_active(struct at_dma_chan *atchan)
60 {
61         return list_first_entry(&atchan->active_list,
62                                 struct at_desc, desc_node);
63 }
64
65 static struct at_desc *atc_first_queued(struct at_dma_chan *atchan)
66 {
67         return list_first_entry(&atchan->queue,
68                                 struct at_desc, desc_node);
69 }
70
71 /**
72  * atc_alloc_descriptor - allocate and return an initialized descriptor
73  * @chan: the channel to allocate descriptors for
74  * @gfp_flags: GFP allocation flags
75  *
76  * Note: The ack-bit is positioned in the descriptor flag at creation time
77  *       to make initial allocation more convenient. This bit will be cleared
78  *       and control will be given to client at usage time (during
79  *       preparation functions).
80  */
81 static struct at_desc *atc_alloc_descriptor(struct dma_chan *chan,
82                                             gfp_t gfp_flags)
83 {
84         struct at_desc  *desc = NULL;
85         struct at_dma   *atdma = to_at_dma(chan->device);
86         dma_addr_t phys;
87
88         desc = dma_pool_alloc(atdma->dma_desc_pool, gfp_flags, &phys);
89         if (desc) {
90                 memset(desc, 0, sizeof(struct at_desc));
91                 INIT_LIST_HEAD(&desc->tx_list);
92                 dma_async_tx_descriptor_init(&desc->txd, chan);
93                 /* txd.flags will be overwritten in prep functions */
94                 desc->txd.flags = DMA_CTRL_ACK;
95                 desc->txd.tx_submit = atc_tx_submit;
96                 desc->txd.phys = phys;
97         }
98
99         return desc;
100 }
101
102 /**
103  * atc_desc_get - get an unused descriptor from free_list
104  * @atchan: channel we want a new descriptor for
105  */
106 static struct at_desc *atc_desc_get(struct at_dma_chan *atchan)
107 {
108         struct at_desc *desc, *_desc;
109         struct at_desc *ret = NULL;
110         unsigned long flags;
111         unsigned int i = 0;
112         LIST_HEAD(tmp_list);
113
114         spin_lock_irqsave(&atchan->lock, flags);
115         list_for_each_entry_safe(desc, _desc, &atchan->free_list, desc_node) {
116                 i++;
117                 if (async_tx_test_ack(&desc->txd)) {
118                         list_del(&desc->desc_node);
119                         ret = desc;
120                         break;
121                 }
122                 dev_dbg(chan2dev(&atchan->chan_common),
123                                 "desc %p not ACKed\n", desc);
124         }
125         spin_unlock_irqrestore(&atchan->lock, flags);
126         dev_vdbg(chan2dev(&atchan->chan_common),
127                 "scanned %u descriptors on freelist\n", i);
128
129         /* no more descriptor available in initial pool: create one more */
130         if (!ret) {
131                 ret = atc_alloc_descriptor(&atchan->chan_common, GFP_ATOMIC);
132                 if (ret) {
133                         spin_lock_irqsave(&atchan->lock, flags);
134                         atchan->descs_allocated++;
135                         spin_unlock_irqrestore(&atchan->lock, flags);
136                 } else {
137                         dev_err(chan2dev(&atchan->chan_common),
138                                         "not enough descriptors available\n");
139                 }
140         }
141
142         return ret;
143 }
144
145 /**
146  * atc_desc_put - move a descriptor, including any children, to the free list
147  * @atchan: channel we work on
148  * @desc: descriptor, at the head of a chain, to move to free list
149  */
150 static void atc_desc_put(struct at_dma_chan *atchan, struct at_desc *desc)
151 {
152         if (desc) {
153                 struct at_desc *child;
154                 unsigned long flags;
155
156                 spin_lock_irqsave(&atchan->lock, flags);
157                 list_for_each_entry(child, &desc->tx_list, desc_node)
158                         dev_vdbg(chan2dev(&atchan->chan_common),
159                                         "moving child desc %p to freelist\n",
160                                         child);
161                 list_splice_init(&desc->tx_list, &atchan->free_list);
162                 dev_vdbg(chan2dev(&atchan->chan_common),
163                          "moving desc %p to freelist\n", desc);
164                 list_add(&desc->desc_node, &atchan->free_list);
165                 spin_unlock_irqrestore(&atchan->lock, flags);
166         }
167 }
168
169 /**
170  * atc_desc_chain - build chain adding a descripor
171  * @first: address of first descripor of the chain
172  * @prev: address of previous descripor of the chain
173  * @desc: descriptor to queue
174  *
175  * Called from prep_* functions
176  */
177 static void atc_desc_chain(struct at_desc **first, struct at_desc **prev,
178                            struct at_desc *desc)
179 {
180         if (!(*first)) {
181                 *first = desc;
182         } else {
183                 /* inform the HW lli about chaining */
184                 (*prev)->lli.dscr = desc->txd.phys;
185                 /* insert the link descriptor to the LD ring */
186                 list_add_tail(&desc->desc_node,
187                                 &(*first)->tx_list);
188         }
189         *prev = desc;
190 }
191
192 /**
193  * atc_assign_cookie - compute and assign new cookie
194  * @atchan: channel we work on
195  * @desc: descriptor to assign cookie for
196  *
197  * Called with atchan->lock held and bh disabled
198  */
199 static dma_cookie_t
200 atc_assign_cookie(struct at_dma_chan *atchan, struct at_desc *desc)
201 {
202         dma_cookie_t cookie = atchan->chan_common.cookie;
203
204         if (++cookie < 0)
205                 cookie = 1;
206
207         atchan->chan_common.cookie = cookie;
208         desc->txd.cookie = cookie;
209
210         return cookie;
211 }
212
213 /**
214  * atc_dostart - starts the DMA engine for real
215  * @atchan: the channel we want to start
216  * @first: first descriptor in the list we want to begin with
217  *
218  * Called with atchan->lock held and bh disabled
219  */
220 static void atc_dostart(struct at_dma_chan *atchan, struct at_desc *first)
221 {
222         struct at_dma   *atdma = to_at_dma(atchan->chan_common.device);
223
224         /* ASSERT:  channel is idle */
225         if (atc_chan_is_enabled(atchan)) {
226                 dev_err(chan2dev(&atchan->chan_common),
227                         "BUG: Attempted to start non-idle channel\n");
228                 dev_err(chan2dev(&atchan->chan_common),
229                         "  channel: s0x%x d0x%x ctrl0x%x:0x%x l0x%x\n",
230                         channel_readl(atchan, SADDR),
231                         channel_readl(atchan, DADDR),
232                         channel_readl(atchan, CTRLA),
233                         channel_readl(atchan, CTRLB),
234                         channel_readl(atchan, DSCR));
235
236                 /* The tasklet will hopefully advance the queue... */
237                 return;
238         }
239
240         vdbg_dump_regs(atchan);
241
242         /* clear any pending interrupt */
243         while (dma_readl(atdma, EBCISR))
244                 cpu_relax();
245
246         channel_writel(atchan, SADDR, 0);
247         channel_writel(atchan, DADDR, 0);
248         channel_writel(atchan, CTRLA, 0);
249         channel_writel(atchan, CTRLB, 0);
250         channel_writel(atchan, DSCR, first->txd.phys);
251         dma_writel(atdma, CHER, atchan->mask);
252
253         vdbg_dump_regs(atchan);
254 }
255
256 /**
257  * atc_chain_complete - finish work for one transaction chain
258  * @atchan: channel we work on
259  * @desc: descriptor at the head of the chain we want do complete
260  *
261  * Called with atchan->lock held and bh disabled */
262 static void
263 atc_chain_complete(struct at_dma_chan *atchan, struct at_desc *desc)
264 {
265         struct dma_async_tx_descriptor  *txd = &desc->txd;
266
267         dev_vdbg(chan2dev(&atchan->chan_common),
268                 "descriptor %u complete\n", txd->cookie);
269
270         atchan->completed_cookie = txd->cookie;
271
272         /* move children to free_list */
273         list_splice_init(&desc->tx_list, &atchan->free_list);
274         /* move myself to free_list */
275         list_move(&desc->desc_node, &atchan->free_list);
276
277         /* unmap dma addresses (not on slave channels) */
278         if (!atchan->chan_common.private) {
279                 struct device *parent = chan2parent(&atchan->chan_common);
280                 if (!(txd->flags & DMA_COMPL_SKIP_DEST_UNMAP)) {
281                         if (txd->flags & DMA_COMPL_DEST_UNMAP_SINGLE)
282                                 dma_unmap_single(parent,
283                                                 desc->lli.daddr,
284                                                 desc->len, DMA_FROM_DEVICE);
285                         else
286                                 dma_unmap_page(parent,
287                                                 desc->lli.daddr,
288                                                 desc->len, DMA_FROM_DEVICE);
289                 }
290                 if (!(txd->flags & DMA_COMPL_SKIP_SRC_UNMAP)) {
291                         if (txd->flags & DMA_COMPL_SRC_UNMAP_SINGLE)
292                                 dma_unmap_single(parent,
293                                                 desc->lli.saddr,
294                                                 desc->len, DMA_TO_DEVICE);
295                         else
296                                 dma_unmap_page(parent,
297                                                 desc->lli.saddr,
298                                                 desc->len, DMA_TO_DEVICE);
299                 }
300         }
301
302         /* for cyclic transfers,
303          * no need to replay callback function while stopping */
304         if (!atc_chan_is_cyclic(atchan)) {
305                 dma_async_tx_callback   callback = txd->callback;
306                 void                    *param = txd->callback_param;
307
308                 /*
309                  * The API requires that no submissions are done from a
310                  * callback, so we don't need to drop the lock here
311                  */
312                 if (callback)
313                         callback(param);
314         }
315
316         dma_run_dependencies(txd);
317 }
318
319 /**
320  * atc_complete_all - finish work for all transactions
321  * @atchan: channel to complete transactions for
322  *
323  * Eventually submit queued descriptors if any
324  *
325  * Assume channel is idle while calling this function
326  * Called with atchan->lock held and bh disabled
327  */
328 static void atc_complete_all(struct at_dma_chan *atchan)
329 {
330         struct at_desc *desc, *_desc;
331         LIST_HEAD(list);
332
333         dev_vdbg(chan2dev(&atchan->chan_common), "complete all\n");
334
335         BUG_ON(atc_chan_is_enabled(atchan));
336
337         /*
338          * Submit queued descriptors ASAP, i.e. before we go through
339          * the completed ones.
340          */
341         if (!list_empty(&atchan->queue))
342                 atc_dostart(atchan, atc_first_queued(atchan));
343         /* empty active_list now it is completed */
344         list_splice_init(&atchan->active_list, &list);
345         /* empty queue list by moving descriptors (if any) to active_list */
346         list_splice_init(&atchan->queue, &atchan->active_list);
347
348         list_for_each_entry_safe(desc, _desc, &list, desc_node)
349                 atc_chain_complete(atchan, desc);
350 }
351
352 /**
353  * atc_cleanup_descriptors - cleanup up finished descriptors in active_list
354  * @atchan: channel to be cleaned up
355  *
356  * Called with atchan->lock held and bh disabled
357  */
358 static void atc_cleanup_descriptors(struct at_dma_chan *atchan)
359 {
360         struct at_desc  *desc, *_desc;
361         struct at_desc  *child;
362
363         dev_vdbg(chan2dev(&atchan->chan_common), "cleanup descriptors\n");
364
365         list_for_each_entry_safe(desc, _desc, &atchan->active_list, desc_node) {
366                 if (!(desc->lli.ctrla & ATC_DONE))
367                         /* This one is currently in progress */
368                         return;
369
370                 list_for_each_entry(child, &desc->tx_list, desc_node)
371                         if (!(child->lli.ctrla & ATC_DONE))
372                                 /* Currently in progress */
373                                 return;
374
375                 /*
376                  * No descriptors so far seem to be in progress, i.e.
377                  * this chain must be done.
378                  */
379                 atc_chain_complete(atchan, desc);
380         }
381 }
382
383 /**
384  * atc_advance_work - at the end of a transaction, move forward
385  * @atchan: channel where the transaction ended
386  *
387  * Called with atchan->lock held and bh disabled
388  */
389 static void atc_advance_work(struct at_dma_chan *atchan)
390 {
391         dev_vdbg(chan2dev(&atchan->chan_common), "advance_work\n");
392
393         if (list_empty(&atchan->active_list) ||
394             list_is_singular(&atchan->active_list)) {
395                 atc_complete_all(atchan);
396         } else {
397                 atc_chain_complete(atchan, atc_first_active(atchan));
398                 /* advance work */
399                 atc_dostart(atchan, atc_first_active(atchan));
400         }
401 }
402
403
404 /**
405  * atc_handle_error - handle errors reported by DMA controller
406  * @atchan: channel where error occurs
407  *
408  * Called with atchan->lock held and bh disabled
409  */
410 static void atc_handle_error(struct at_dma_chan *atchan)
411 {
412         struct at_desc *bad_desc;
413         struct at_desc *child;
414
415         /*
416          * The descriptor currently at the head of the active list is
417          * broked. Since we don't have any way to report errors, we'll
418          * just have to scream loudly and try to carry on.
419          */
420         bad_desc = atc_first_active(atchan);
421         list_del_init(&bad_desc->desc_node);
422
423         /* As we are stopped, take advantage to push queued descriptors
424          * in active_list */
425         list_splice_init(&atchan->queue, atchan->active_list.prev);
426
427         /* Try to restart the controller */
428         if (!list_empty(&atchan->active_list))
429                 atc_dostart(atchan, atc_first_active(atchan));
430
431         /*
432          * KERN_CRITICAL may seem harsh, but since this only happens
433          * when someone submits a bad physical address in a
434          * descriptor, we should consider ourselves lucky that the
435          * controller flagged an error instead of scribbling over
436          * random memory locations.
437          */
438         dev_crit(chan2dev(&atchan->chan_common),
439                         "Bad descriptor submitted for DMA!\n");
440         dev_crit(chan2dev(&atchan->chan_common),
441                         "  cookie: %d\n", bad_desc->txd.cookie);
442         atc_dump_lli(atchan, &bad_desc->lli);
443         list_for_each_entry(child, &bad_desc->tx_list, desc_node)
444                 atc_dump_lli(atchan, &child->lli);
445
446         /* Pretend the descriptor completed successfully */
447         atc_chain_complete(atchan, bad_desc);
448 }
449
450 /**
451  * atc_handle_cyclic - at the end of a period, run callback function
452  * @atchan: channel used for cyclic operations
453  *
454  * Called with atchan->lock held and bh disabled
455  */
456 static void atc_handle_cyclic(struct at_dma_chan *atchan)
457 {
458         struct at_desc                  *first = atc_first_active(atchan);
459         struct dma_async_tx_descriptor  *txd = &first->txd;
460         dma_async_tx_callback           callback = txd->callback;
461         void                            *param = txd->callback_param;
462
463         dev_vdbg(chan2dev(&atchan->chan_common),
464                         "new cyclic period llp 0x%08x\n",
465                         channel_readl(atchan, DSCR));
466
467         if (callback)
468                 callback(param);
469 }
470
471 /*--  IRQ & Tasklet  ---------------------------------------------------*/
472
473 static void atc_tasklet(unsigned long data)
474 {
475         struct at_dma_chan *atchan = (struct at_dma_chan *)data;
476         unsigned long flags;
477
478         spin_lock_irqsave(&atchan->lock, flags);
479         if (test_and_clear_bit(ATC_IS_ERROR, &atchan->status))
480                 atc_handle_error(atchan);
481         else if (atc_chan_is_cyclic(atchan))
482                 atc_handle_cyclic(atchan);
483         else
484                 atc_advance_work(atchan);
485
486         spin_unlock_irqrestore(&atchan->lock, flags);
487 }
488
489 static irqreturn_t at_dma_interrupt(int irq, void *dev_id)
490 {
491         struct at_dma           *atdma = (struct at_dma *)dev_id;
492         struct at_dma_chan      *atchan;
493         int                     i;
494         u32                     status, pending, imr;
495         int                     ret = IRQ_NONE;
496
497         do {
498                 imr = dma_readl(atdma, EBCIMR);
499                 status = dma_readl(atdma, EBCISR);
500                 pending = status & imr;
501
502                 if (!pending)
503                         break;
504
505                 dev_vdbg(atdma->dma_common.dev,
506                         "interrupt: status = 0x%08x, 0x%08x, 0x%08x\n",
507                          status, imr, pending);
508
509                 for (i = 0; i < atdma->dma_common.chancnt; i++) {
510                         atchan = &atdma->chan[i];
511                         if (pending & (AT_DMA_BTC(i) | AT_DMA_ERR(i))) {
512                                 if (pending & AT_DMA_ERR(i)) {
513                                         /* Disable channel on AHB error */
514                                         dma_writel(atdma, CHDR,
515                                                 AT_DMA_RES(i) | atchan->mask);
516                                         /* Give information to tasklet */
517                                         set_bit(ATC_IS_ERROR, &atchan->status);
518                                 }
519                                 tasklet_schedule(&atchan->tasklet);
520                                 ret = IRQ_HANDLED;
521                         }
522                 }
523
524         } while (pending);
525
526         return ret;
527 }
528
529
530 /*--  DMA Engine API  --------------------------------------------------*/
531
532 /**
533  * atc_tx_submit - set the prepared descriptor(s) to be executed by the engine
534  * @desc: descriptor at the head of the transaction chain
535  *
536  * Queue chain if DMA engine is working already
537  *
538  * Cookie increment and adding to active_list or queue must be atomic
539  */
540 static dma_cookie_t atc_tx_submit(struct dma_async_tx_descriptor *tx)
541 {
542         struct at_desc          *desc = txd_to_at_desc(tx);
543         struct at_dma_chan      *atchan = to_at_dma_chan(tx->chan);
544         dma_cookie_t            cookie;
545         unsigned long           flags;
546
547         spin_lock_irqsave(&atchan->lock, flags);
548         cookie = atc_assign_cookie(atchan, desc);
549
550         if (list_empty(&atchan->active_list)) {
551                 dev_vdbg(chan2dev(tx->chan), "tx_submit: started %u\n",
552                                 desc->txd.cookie);
553                 atc_dostart(atchan, desc);
554                 list_add_tail(&desc->desc_node, &atchan->active_list);
555         } else {
556                 dev_vdbg(chan2dev(tx->chan), "tx_submit: queued %u\n",
557                                 desc->txd.cookie);
558                 list_add_tail(&desc->desc_node, &atchan->queue);
559         }
560
561         spin_unlock_irqrestore(&atchan->lock, flags);
562
563         return cookie;
564 }
565
566 /**
567  * atc_prep_dma_memcpy - prepare a memcpy operation
568  * @chan: the channel to prepare operation on
569  * @dest: operation virtual destination address
570  * @src: operation virtual source address
571  * @len: operation length
572  * @flags: tx descriptor status flags
573  */
574 static struct dma_async_tx_descriptor *
575 atc_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
576                 size_t len, unsigned long flags)
577 {
578         struct at_dma_chan      *atchan = to_at_dma_chan(chan);
579         struct at_desc          *desc = NULL;
580         struct at_desc          *first = NULL;
581         struct at_desc          *prev = NULL;
582         size_t                  xfer_count;
583         size_t                  offset;
584         unsigned int            src_width;
585         unsigned int            dst_width;
586         u32                     ctrla;
587         u32                     ctrlb;
588
589         dev_vdbg(chan2dev(chan), "prep_dma_memcpy: d0x%x s0x%x l0x%zx f0x%lx\n",
590                         dest, src, len, flags);
591
592         if (unlikely(!len)) {
593                 dev_dbg(chan2dev(chan), "prep_dma_memcpy: length is zero!\n");
594                 return NULL;
595         }
596
597         ctrla =   ATC_DEFAULT_CTRLA;
598         ctrlb =   ATC_DEFAULT_CTRLB | ATC_IEN
599                 | ATC_SRC_ADDR_MODE_INCR
600                 | ATC_DST_ADDR_MODE_INCR
601                 | ATC_FC_MEM2MEM;
602
603         /*
604          * We can be a lot more clever here, but this should take care
605          * of the most common optimization.
606          */
607         if (!((src | dest  | len) & 3)) {
608                 ctrla |= ATC_SRC_WIDTH_WORD | ATC_DST_WIDTH_WORD;
609                 src_width = dst_width = 2;
610         } else if (!((src | dest | len) & 1)) {
611                 ctrla |= ATC_SRC_WIDTH_HALFWORD | ATC_DST_WIDTH_HALFWORD;
612                 src_width = dst_width = 1;
613         } else {
614                 ctrla |= ATC_SRC_WIDTH_BYTE | ATC_DST_WIDTH_BYTE;
615                 src_width = dst_width = 0;
616         }
617
618         for (offset = 0; offset < len; offset += xfer_count << src_width) {
619                 xfer_count = min_t(size_t, (len - offset) >> src_width,
620                                 ATC_BTSIZE_MAX);
621
622                 desc = atc_desc_get(atchan);
623                 if (!desc)
624                         goto err_desc_get;
625
626                 desc->lli.saddr = src + offset;
627                 desc->lli.daddr = dest + offset;
628                 desc->lli.ctrla = ctrla | xfer_count;
629                 desc->lli.ctrlb = ctrlb;
630
631                 desc->txd.cookie = 0;
632
633                 atc_desc_chain(&first, &prev, desc);
634         }
635
636         /* First descriptor of the chain embedds additional information */
637         first->txd.cookie = -EBUSY;
638         first->len = len;
639
640         /* set end-of-link to the last link descriptor of list*/
641         set_desc_eol(desc);
642
643         first->txd.flags = flags; /* client is in control of this ack */
644
645         return &first->txd;
646
647 err_desc_get:
648         atc_desc_put(atchan, first);
649         return NULL;
650 }
651
652
653 /**
654  * atc_prep_slave_sg - prepare descriptors for a DMA_SLAVE transaction
655  * @chan: DMA channel
656  * @sgl: scatterlist to transfer to/from
657  * @sg_len: number of entries in @scatterlist
658  * @direction: DMA direction
659  * @flags: tx descriptor status flags
660  */
661 static struct dma_async_tx_descriptor *
662 atc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
663                 unsigned int sg_len, enum dma_data_direction direction,
664                 unsigned long flags)
665 {
666         struct at_dma_chan      *atchan = to_at_dma_chan(chan);
667         struct at_dma_slave     *atslave = chan->private;
668         struct at_desc          *first = NULL;
669         struct at_desc          *prev = NULL;
670         u32                     ctrla;
671         u32                     ctrlb;
672         dma_addr_t              reg;
673         unsigned int            reg_width;
674         unsigned int            mem_width;
675         unsigned int            i;
676         struct scatterlist      *sg;
677         size_t                  total_len = 0;
678
679         dev_vdbg(chan2dev(chan), "prep_slave_sg (%d): %s f0x%lx\n",
680                         sg_len,
681                         direction == DMA_TO_DEVICE ? "TO DEVICE" : "FROM DEVICE",
682                         flags);
683
684         if (unlikely(!atslave || !sg_len)) {
685                 dev_dbg(chan2dev(chan), "prep_dma_memcpy: length is zero!\n");
686                 return NULL;
687         }
688
689         reg_width = atslave->reg_width;
690
691         ctrla = ATC_DEFAULT_CTRLA | atslave->ctrla;
692         ctrlb = ATC_IEN;
693
694         switch (direction) {
695         case DMA_TO_DEVICE:
696                 ctrla |=  ATC_DST_WIDTH(reg_width);
697                 ctrlb |=  ATC_DST_ADDR_MODE_FIXED
698                         | ATC_SRC_ADDR_MODE_INCR
699                         | ATC_FC_MEM2PER
700                         | ATC_SIF(AT_DMA_MEM_IF) | ATC_DIF(AT_DMA_PER_IF);
701                 reg = atslave->tx_reg;
702                 for_each_sg(sgl, sg, sg_len, i) {
703                         struct at_desc  *desc;
704                         u32             len;
705                         u32             mem;
706
707                         desc = atc_desc_get(atchan);
708                         if (!desc)
709                                 goto err_desc_get;
710
711                         mem = sg_dma_address(sg);
712                         len = sg_dma_len(sg);
713                         mem_width = 2;
714                         if (unlikely(mem & 3 || len & 3))
715                                 mem_width = 0;
716
717                         desc->lli.saddr = mem;
718                         desc->lli.daddr = reg;
719                         desc->lli.ctrla = ctrla
720                                         | ATC_SRC_WIDTH(mem_width)
721                                         | len >> mem_width;
722                         desc->lli.ctrlb = ctrlb;
723
724                         atc_desc_chain(&first, &prev, desc);
725                         total_len += len;
726                 }
727                 break;
728         case DMA_FROM_DEVICE:
729                 ctrla |=  ATC_SRC_WIDTH(reg_width);
730                 ctrlb |=  ATC_DST_ADDR_MODE_INCR
731                         | ATC_SRC_ADDR_MODE_FIXED
732                         | ATC_FC_PER2MEM
733                         | ATC_SIF(AT_DMA_PER_IF) | ATC_DIF(AT_DMA_MEM_IF);
734
735                 reg = atslave->rx_reg;
736                 for_each_sg(sgl, sg, sg_len, i) {
737                         struct at_desc  *desc;
738                         u32             len;
739                         u32             mem;
740
741                         desc = atc_desc_get(atchan);
742                         if (!desc)
743                                 goto err_desc_get;
744
745                         mem = sg_dma_address(sg);
746                         len = sg_dma_len(sg);
747                         mem_width = 2;
748                         if (unlikely(mem & 3 || len & 3))
749                                 mem_width = 0;
750
751                         desc->lli.saddr = reg;
752                         desc->lli.daddr = mem;
753                         desc->lli.ctrla = ctrla
754                                         | ATC_DST_WIDTH(mem_width)
755                                         | len >> reg_width;
756                         desc->lli.ctrlb = ctrlb;
757
758                         atc_desc_chain(&first, &prev, desc);
759                         total_len += len;
760                 }
761                 break;
762         default:
763                 return NULL;
764         }
765
766         /* set end-of-link to the last link descriptor of list*/
767         set_desc_eol(prev);
768
769         /* First descriptor of the chain embedds additional information */
770         first->txd.cookie = -EBUSY;
771         first->len = total_len;
772
773         /* first link descriptor of list is responsible of flags */
774         first->txd.flags = flags; /* client is in control of this ack */
775
776         return &first->txd;
777
778 err_desc_get:
779         dev_err(chan2dev(chan), "not enough descriptors available\n");
780         atc_desc_put(atchan, first);
781         return NULL;
782 }
783
784 /**
785  * atc_dma_cyclic_check_values
786  * Check for too big/unaligned periods and unaligned DMA buffer
787  */
788 static int
789 atc_dma_cyclic_check_values(unsigned int reg_width, dma_addr_t buf_addr,
790                 size_t period_len, enum dma_data_direction direction)
791 {
792         if (period_len > (ATC_BTSIZE_MAX << reg_width))
793                 goto err_out;
794         if (unlikely(period_len & ((1 << reg_width) - 1)))
795                 goto err_out;
796         if (unlikely(buf_addr & ((1 << reg_width) - 1)))
797                 goto err_out;
798         if (unlikely(!(direction & (DMA_TO_DEVICE | DMA_FROM_DEVICE))))
799                 goto err_out;
800
801         return 0;
802
803 err_out:
804         return -EINVAL;
805 }
806
807 /**
808  * atc_dma_cyclic_fill_desc - Fill one period decriptor
809  */
810 static int
811 atc_dma_cyclic_fill_desc(struct at_dma_slave *atslave, struct at_desc *desc,
812                 unsigned int period_index, dma_addr_t buf_addr,
813                 size_t period_len, enum dma_data_direction direction)
814 {
815         u32             ctrla;
816         unsigned int    reg_width = atslave->reg_width;
817
818         /* prepare common CRTLA value */
819         ctrla =   ATC_DEFAULT_CTRLA | atslave->ctrla
820                 | ATC_DST_WIDTH(reg_width)
821                 | ATC_SRC_WIDTH(reg_width)
822                 | period_len >> reg_width;
823
824         switch (direction) {
825         case DMA_TO_DEVICE:
826                 desc->lli.saddr = buf_addr + (period_len * period_index);
827                 desc->lli.daddr = atslave->tx_reg;
828                 desc->lli.ctrla = ctrla;
829                 desc->lli.ctrlb = ATC_DST_ADDR_MODE_FIXED
830                                 | ATC_SRC_ADDR_MODE_INCR
831                                 | ATC_FC_MEM2PER
832                                 | ATC_SIF(AT_DMA_MEM_IF)
833                                 | ATC_DIF(AT_DMA_PER_IF);
834                 break;
835
836         case DMA_FROM_DEVICE:
837                 desc->lli.saddr = atslave->rx_reg;
838                 desc->lli.daddr = buf_addr + (period_len * period_index);
839                 desc->lli.ctrla = ctrla;
840                 desc->lli.ctrlb = ATC_DST_ADDR_MODE_INCR
841                                 | ATC_SRC_ADDR_MODE_FIXED
842                                 | ATC_FC_PER2MEM
843                                 | ATC_SIF(AT_DMA_PER_IF)
844                                 | ATC_DIF(AT_DMA_MEM_IF);
845                 break;
846
847         default:
848                 return -EINVAL;
849         }
850
851         return 0;
852 }
853
854 /**
855  * atc_prep_dma_cyclic - prepare the cyclic DMA transfer
856  * @chan: the DMA channel to prepare
857  * @buf_addr: physical DMA address where the buffer starts
858  * @buf_len: total number of bytes for the entire buffer
859  * @period_len: number of bytes for each period
860  * @direction: transfer direction, to or from device
861  */
862 static struct dma_async_tx_descriptor *
863 atc_prep_dma_cyclic(struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,
864                 size_t period_len, enum dma_data_direction direction)
865 {
866         struct at_dma_chan      *atchan = to_at_dma_chan(chan);
867         struct at_dma_slave     *atslave = chan->private;
868         struct at_desc          *first = NULL;
869         struct at_desc          *prev = NULL;
870         unsigned long           was_cyclic;
871         unsigned int            periods = buf_len / period_len;
872         unsigned int            i;
873
874         dev_vdbg(chan2dev(chan), "prep_dma_cyclic: %s buf@0x%08x - %d (%d/%d)\n",
875                         direction == DMA_TO_DEVICE ? "TO DEVICE" : "FROM DEVICE",
876                         buf_addr,
877                         periods, buf_len, period_len);
878
879         if (unlikely(!atslave || !buf_len || !period_len)) {
880                 dev_dbg(chan2dev(chan), "prep_dma_cyclic: length is zero!\n");
881                 return NULL;
882         }
883
884         was_cyclic = test_and_set_bit(ATC_IS_CYCLIC, &atchan->status);
885         if (was_cyclic) {
886                 dev_dbg(chan2dev(chan), "prep_dma_cyclic: channel in use!\n");
887                 return NULL;
888         }
889
890         /* Check for too big/unaligned periods and unaligned DMA buffer */
891         if (atc_dma_cyclic_check_values(atslave->reg_width, buf_addr,
892                                         period_len, direction))
893                 goto err_out;
894
895         /* build cyclic linked list */
896         for (i = 0; i < periods; i++) {
897                 struct at_desc  *desc;
898
899                 desc = atc_desc_get(atchan);
900                 if (!desc)
901                         goto err_desc_get;
902
903                 if (atc_dma_cyclic_fill_desc(atslave, desc, i, buf_addr,
904                                                 period_len, direction))
905                         goto err_desc_get;
906
907                 atc_desc_chain(&first, &prev, desc);
908         }
909
910         /* lets make a cyclic list */
911         prev->lli.dscr = first->txd.phys;
912
913         /* First descriptor of the chain embedds additional information */
914         first->txd.cookie = -EBUSY;
915         first->len = buf_len;
916
917         return &first->txd;
918
919 err_desc_get:
920         dev_err(chan2dev(chan), "not enough descriptors available\n");
921         atc_desc_put(atchan, first);
922 err_out:
923         clear_bit(ATC_IS_CYCLIC, &atchan->status);
924         return NULL;
925 }
926
927
928 static int atc_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
929                        unsigned long arg)
930 {
931         struct at_dma_chan      *atchan = to_at_dma_chan(chan);
932         struct at_dma           *atdma = to_at_dma(chan->device);
933         int                     chan_id = atchan->chan_common.chan_id;
934         unsigned long           flags;
935
936         LIST_HEAD(list);
937
938         dev_vdbg(chan2dev(chan), "atc_control (%d)\n", cmd);
939
940         if (cmd == DMA_PAUSE) {
941                 spin_lock_irqsave(&atchan->lock, flags);
942
943                 dma_writel(atdma, CHER, AT_DMA_SUSP(chan_id));
944                 set_bit(ATC_IS_PAUSED, &atchan->status);
945
946                 spin_unlock_irqrestore(&atchan->lock, flags);
947         } else if (cmd == DMA_RESUME) {
948                 if (!atc_chan_is_paused(atchan))
949                         return 0;
950
951                 spin_lock_irqsave(&atchan->lock, flags);
952
953                 dma_writel(atdma, CHDR, AT_DMA_RES(chan_id));
954                 clear_bit(ATC_IS_PAUSED, &atchan->status);
955
956                 spin_unlock_irqrestore(&atchan->lock, flags);
957         } else if (cmd == DMA_TERMINATE_ALL) {
958                 struct at_desc  *desc, *_desc;
959                 /*
960                  * This is only called when something went wrong elsewhere, so
961                  * we don't really care about the data. Just disable the
962                  * channel. We still have to poll the channel enable bit due
963                  * to AHB/HSB limitations.
964                  */
965                 spin_lock_irqsave(&atchan->lock, flags);
966
967                 /* disabling channel: must also remove suspend state */
968                 dma_writel(atdma, CHDR, AT_DMA_RES(chan_id) | atchan->mask);
969
970                 /* confirm that this channel is disabled */
971                 while (dma_readl(atdma, CHSR) & atchan->mask)
972                         cpu_relax();
973
974                 /* active_list entries will end up before queued entries */
975                 list_splice_init(&atchan->queue, &list);
976                 list_splice_init(&atchan->active_list, &list);
977
978                 /* Flush all pending and queued descriptors */
979                 list_for_each_entry_safe(desc, _desc, &list, desc_node)
980                         atc_chain_complete(atchan, desc);
981
982                 clear_bit(ATC_IS_PAUSED, &atchan->status);
983                 /* if channel dedicated to cyclic operations, free it */
984                 clear_bit(ATC_IS_CYCLIC, &atchan->status);
985
986                 spin_unlock_irqrestore(&atchan->lock, flags);
987         } else {
988                 return -ENXIO;
989         }
990
991         return 0;
992 }
993
994 /**
995  * atc_tx_status - poll for transaction completion
996  * @chan: DMA channel
997  * @cookie: transaction identifier to check status of
998  * @txstate: if not %NULL updated with transaction state
999  *
1000  * If @txstate is passed in, upon return it reflect the driver
1001  * internal state and can be used with dma_async_is_complete() to check
1002  * the status of multiple cookies without re-checking hardware state.
1003  */
1004 static enum dma_status
1005 atc_tx_status(struct dma_chan *chan,
1006                 dma_cookie_t cookie,
1007                 struct dma_tx_state *txstate)
1008 {
1009         struct at_dma_chan      *atchan = to_at_dma_chan(chan);
1010         dma_cookie_t            last_used;
1011         dma_cookie_t            last_complete;
1012         unsigned long           flags;
1013         enum dma_status         ret;
1014
1015         spin_lock_irqsave(&atchan->lock, flags);
1016
1017         last_complete = atchan->completed_cookie;
1018         last_used = chan->cookie;
1019
1020         ret = dma_async_is_complete(cookie, last_complete, last_used);
1021         if (ret != DMA_SUCCESS) {
1022                 atc_cleanup_descriptors(atchan);
1023
1024                 last_complete = atchan->completed_cookie;
1025                 last_used = chan->cookie;
1026
1027                 ret = dma_async_is_complete(cookie, last_complete, last_used);
1028         }
1029
1030         spin_unlock_irqrestore(&atchan->lock, flags);
1031
1032         if (ret != DMA_SUCCESS)
1033                 dma_set_tx_state(txstate, last_complete, last_used,
1034                         atc_first_active(atchan)->len);
1035         else
1036                 dma_set_tx_state(txstate, last_complete, last_used, 0);
1037
1038         if (atc_chan_is_paused(atchan))
1039                 ret = DMA_PAUSED;
1040
1041         dev_vdbg(chan2dev(chan), "tx_status %d: cookie = %d (d%d, u%d)\n",
1042                  ret, cookie, last_complete ? last_complete : 0,
1043                  last_used ? last_used : 0);
1044
1045         return ret;
1046 }
1047
1048 /**
1049  * atc_issue_pending - try to finish work
1050  * @chan: target DMA channel
1051  */
1052 static void atc_issue_pending(struct dma_chan *chan)
1053 {
1054         struct at_dma_chan      *atchan = to_at_dma_chan(chan);
1055         unsigned long           flags;
1056
1057         dev_vdbg(chan2dev(chan), "issue_pending\n");
1058
1059         /* Not needed for cyclic transfers */
1060         if (atc_chan_is_cyclic(atchan))
1061                 return;
1062
1063         spin_lock_irqsave(&atchan->lock, flags);
1064         if (!atc_chan_is_enabled(atchan)) {
1065                 atc_advance_work(atchan);
1066         }
1067         spin_unlock_irqrestore(&atchan->lock, flags);
1068 }
1069
1070 /**
1071  * atc_alloc_chan_resources - allocate resources for DMA channel
1072  * @chan: allocate descriptor resources for this channel
1073  * @client: current client requesting the channel be ready for requests
1074  *
1075  * return - the number of allocated descriptors
1076  */
1077 static int atc_alloc_chan_resources(struct dma_chan *chan)
1078 {
1079         struct at_dma_chan      *atchan = to_at_dma_chan(chan);
1080         struct at_dma           *atdma = to_at_dma(chan->device);
1081         struct at_desc          *desc;
1082         struct at_dma_slave     *atslave;
1083         unsigned long           flags;
1084         int                     i;
1085         u32                     cfg;
1086         LIST_HEAD(tmp_list);
1087
1088         dev_vdbg(chan2dev(chan), "alloc_chan_resources\n");
1089
1090         /* ASSERT:  channel is idle */
1091         if (atc_chan_is_enabled(atchan)) {
1092                 dev_dbg(chan2dev(chan), "DMA channel not idle ?\n");
1093                 return -EIO;
1094         }
1095
1096         cfg = ATC_DEFAULT_CFG;
1097
1098         atslave = chan->private;
1099         if (atslave) {
1100                 /*
1101                  * We need controller-specific data to set up slave
1102                  * transfers.
1103                  */
1104                 BUG_ON(!atslave->dma_dev || atslave->dma_dev != atdma->dma_common.dev);
1105
1106                 /* if cfg configuration specified take it instad of default */
1107                 if (atslave->cfg)
1108                         cfg = atslave->cfg;
1109         }
1110
1111         /* have we already been set up?
1112          * reconfigure channel but no need to reallocate descriptors */
1113         if (!list_empty(&atchan->free_list))
1114                 return atchan->descs_allocated;
1115
1116         /* Allocate initial pool of descriptors */
1117         for (i = 0; i < init_nr_desc_per_channel; i++) {
1118                 desc = atc_alloc_descriptor(chan, GFP_KERNEL);
1119                 if (!desc) {
1120                         dev_err(atdma->dma_common.dev,
1121                                 "Only %d initial descriptors\n", i);
1122                         break;
1123                 }
1124                 list_add_tail(&desc->desc_node, &tmp_list);
1125         }
1126
1127         spin_lock_irqsave(&atchan->lock, flags);
1128         atchan->descs_allocated = i;
1129         list_splice(&tmp_list, &atchan->free_list);
1130         atchan->completed_cookie = chan->cookie = 1;
1131         spin_unlock_irqrestore(&atchan->lock, flags);
1132
1133         /* channel parameters */
1134         channel_writel(atchan, CFG, cfg);
1135
1136         dev_dbg(chan2dev(chan),
1137                 "alloc_chan_resources: allocated %d descriptors\n",
1138                 atchan->descs_allocated);
1139
1140         return atchan->descs_allocated;
1141 }
1142
1143 /**
1144  * atc_free_chan_resources - free all channel resources
1145  * @chan: DMA channel
1146  */
1147 static void atc_free_chan_resources(struct dma_chan *chan)
1148 {
1149         struct at_dma_chan      *atchan = to_at_dma_chan(chan);
1150         struct at_dma           *atdma = to_at_dma(chan->device);
1151         struct at_desc          *desc, *_desc;
1152         LIST_HEAD(list);
1153
1154         dev_dbg(chan2dev(chan), "free_chan_resources: (descs allocated=%u)\n",
1155                 atchan->descs_allocated);
1156
1157         /* ASSERT:  channel is idle */
1158         BUG_ON(!list_empty(&atchan->active_list));
1159         BUG_ON(!list_empty(&atchan->queue));
1160         BUG_ON(atc_chan_is_enabled(atchan));
1161
1162         list_for_each_entry_safe(desc, _desc, &atchan->free_list, desc_node) {
1163                 dev_vdbg(chan2dev(chan), "  freeing descriptor %p\n", desc);
1164                 list_del(&desc->desc_node);
1165                 /* free link descriptor */
1166                 dma_pool_free(atdma->dma_desc_pool, desc, desc->txd.phys);
1167         }
1168         list_splice_init(&atchan->free_list, &list);
1169         atchan->descs_allocated = 0;
1170         atchan->status = 0;
1171
1172         dev_vdbg(chan2dev(chan), "free_chan_resources: done\n");
1173 }
1174
1175
1176 /*--  Module Management  -----------------------------------------------*/
1177
1178 /**
1179  * at_dma_off - disable DMA controller
1180  * @atdma: the Atmel HDAMC device
1181  */
1182 static void at_dma_off(struct at_dma *atdma)
1183 {
1184         dma_writel(atdma, EN, 0);
1185
1186         /* disable all interrupts */
1187         dma_writel(atdma, EBCIDR, -1L);
1188
1189         /* confirm that all channels are disabled */
1190         while (dma_readl(atdma, CHSR) & atdma->all_chan_mask)
1191                 cpu_relax();
1192 }
1193
1194 static int __init at_dma_probe(struct platform_device *pdev)
1195 {
1196         struct at_dma_platform_data *pdata;
1197         struct resource         *io;
1198         struct at_dma           *atdma;
1199         size_t                  size;
1200         int                     irq;
1201         int                     err;
1202         int                     i;
1203
1204         /* get DMA Controller parameters from platform */
1205         pdata = pdev->dev.platform_data;
1206         if (!pdata || pdata->nr_channels > AT_DMA_MAX_NR_CHANNELS)
1207                 return -EINVAL;
1208
1209         io = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1210         if (!io)
1211                 return -EINVAL;
1212
1213         irq = platform_get_irq(pdev, 0);
1214         if (irq < 0)
1215                 return irq;
1216
1217         size = sizeof(struct at_dma);
1218         size += pdata->nr_channels * sizeof(struct at_dma_chan);
1219         atdma = kzalloc(size, GFP_KERNEL);
1220         if (!atdma)
1221                 return -ENOMEM;
1222
1223         /* discover transaction capabilites from the platform data */
1224         atdma->dma_common.cap_mask = pdata->cap_mask;
1225         atdma->all_chan_mask = (1 << pdata->nr_channels) - 1;
1226
1227         size = resource_size(io);
1228         if (!request_mem_region(io->start, size, pdev->dev.driver->name)) {
1229                 err = -EBUSY;
1230                 goto err_kfree;
1231         }
1232
1233         atdma->regs = ioremap(io->start, size);
1234         if (!atdma->regs) {
1235                 err = -ENOMEM;
1236                 goto err_release_r;
1237         }
1238
1239         atdma->clk = clk_get(&pdev->dev, "dma_clk");
1240         if (IS_ERR(atdma->clk)) {
1241                 err = PTR_ERR(atdma->clk);
1242                 goto err_clk;
1243         }
1244         clk_enable(atdma->clk);
1245
1246         /* force dma off, just in case */
1247         at_dma_off(atdma);
1248
1249         err = request_irq(irq, at_dma_interrupt, 0, "at_hdmac", atdma);
1250         if (err)
1251                 goto err_irq;
1252
1253         platform_set_drvdata(pdev, atdma);
1254
1255         /* create a pool of consistent memory blocks for hardware descriptors */
1256         atdma->dma_desc_pool = dma_pool_create("at_hdmac_desc_pool",
1257                         &pdev->dev, sizeof(struct at_desc),
1258                         4 /* word alignment */, 0);
1259         if (!atdma->dma_desc_pool) {
1260                 dev_err(&pdev->dev, "No memory for descriptors dma pool\n");
1261                 err = -ENOMEM;
1262                 goto err_pool_create;
1263         }
1264
1265         /* clear any pending interrupt */
1266         while (dma_readl(atdma, EBCISR))
1267                 cpu_relax();
1268
1269         /* initialize channels related values */
1270         INIT_LIST_HEAD(&atdma->dma_common.channels);
1271         for (i = 0; i < pdata->nr_channels; i++) {
1272                 struct at_dma_chan      *atchan = &atdma->chan[i];
1273
1274                 atchan->chan_common.device = &atdma->dma_common;
1275                 atchan->chan_common.cookie = atchan->completed_cookie = 1;
1276                 list_add_tail(&atchan->chan_common.device_node,
1277                                 &atdma->dma_common.channels);
1278
1279                 atchan->ch_regs = atdma->regs + ch_regs(i);
1280                 spin_lock_init(&atchan->lock);
1281                 atchan->mask = 1 << i;
1282
1283                 INIT_LIST_HEAD(&atchan->active_list);
1284                 INIT_LIST_HEAD(&atchan->queue);
1285                 INIT_LIST_HEAD(&atchan->free_list);
1286
1287                 tasklet_init(&atchan->tasklet, atc_tasklet,
1288                                 (unsigned long)atchan);
1289                 atc_enable_irq(atchan);
1290         }
1291
1292         /* set base routines */
1293         atdma->dma_common.device_alloc_chan_resources = atc_alloc_chan_resources;
1294         atdma->dma_common.device_free_chan_resources = atc_free_chan_resources;
1295         atdma->dma_common.device_tx_status = atc_tx_status;
1296         atdma->dma_common.device_issue_pending = atc_issue_pending;
1297         atdma->dma_common.dev = &pdev->dev;
1298
1299         /* set prep routines based on capability */
1300         if (dma_has_cap(DMA_MEMCPY, atdma->dma_common.cap_mask))
1301                 atdma->dma_common.device_prep_dma_memcpy = atc_prep_dma_memcpy;
1302
1303         if (dma_has_cap(DMA_SLAVE, atdma->dma_common.cap_mask)) {
1304                 atdma->dma_common.device_prep_slave_sg = atc_prep_slave_sg;
1305                 /* controller can do slave DMA: can trigger cyclic transfers */
1306                 dma_cap_set(DMA_CYCLIC, atdma->dma_common.cap_mask);
1307                 atdma->dma_common.device_prep_dma_cyclic = atc_prep_dma_cyclic;
1308                 atdma->dma_common.device_control = atc_control;
1309         }
1310
1311         dma_writel(atdma, EN, AT_DMA_ENABLE);
1312
1313         dev_info(&pdev->dev, "Atmel AHB DMA Controller ( %s%s), %d channels\n",
1314           dma_has_cap(DMA_MEMCPY, atdma->dma_common.cap_mask) ? "cpy " : "",
1315           dma_has_cap(DMA_SLAVE, atdma->dma_common.cap_mask)  ? "slave " : "",
1316           pdata->nr_channels);
1317
1318         dma_async_device_register(&atdma->dma_common);
1319
1320         return 0;
1321
1322 err_pool_create:
1323         platform_set_drvdata(pdev, NULL);
1324         free_irq(platform_get_irq(pdev, 0), atdma);
1325 err_irq:
1326         clk_disable(atdma->clk);
1327         clk_put(atdma->clk);
1328 err_clk:
1329         iounmap(atdma->regs);
1330         atdma->regs = NULL;
1331 err_release_r:
1332         release_mem_region(io->start, size);
1333 err_kfree:
1334         kfree(atdma);
1335         return err;
1336 }
1337
1338 static int __exit at_dma_remove(struct platform_device *pdev)
1339 {
1340         struct at_dma           *atdma = platform_get_drvdata(pdev);
1341         struct dma_chan         *chan, *_chan;
1342         struct resource         *io;
1343
1344         at_dma_off(atdma);
1345         dma_async_device_unregister(&atdma->dma_common);
1346
1347         dma_pool_destroy(atdma->dma_desc_pool);
1348         platform_set_drvdata(pdev, NULL);
1349         free_irq(platform_get_irq(pdev, 0), atdma);
1350
1351         list_for_each_entry_safe(chan, _chan, &atdma->dma_common.channels,
1352                         device_node) {
1353                 struct at_dma_chan      *atchan = to_at_dma_chan(chan);
1354
1355                 /* Disable interrupts */
1356                 atc_disable_irq(atchan);
1357                 tasklet_disable(&atchan->tasklet);
1358
1359                 tasklet_kill(&atchan->tasklet);
1360                 list_del(&chan->device_node);
1361         }
1362
1363         clk_disable(atdma->clk);
1364         clk_put(atdma->clk);
1365
1366         iounmap(atdma->regs);
1367         atdma->regs = NULL;
1368
1369         io = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1370         release_mem_region(io->start, resource_size(io));
1371
1372         kfree(atdma);
1373
1374         return 0;
1375 }
1376
1377 static void at_dma_shutdown(struct platform_device *pdev)
1378 {
1379         struct at_dma   *atdma = platform_get_drvdata(pdev);
1380
1381         at_dma_off(platform_get_drvdata(pdev));
1382         clk_disable(atdma->clk);
1383 }
1384
1385 static int at_dma_prepare(struct device *dev)
1386 {
1387         struct platform_device *pdev = to_platform_device(dev);
1388         struct at_dma *atdma = platform_get_drvdata(pdev);
1389         struct dma_chan *chan, *_chan;
1390
1391         list_for_each_entry_safe(chan, _chan, &atdma->dma_common.channels,
1392                         device_node) {
1393                 struct at_dma_chan *atchan = to_at_dma_chan(chan);
1394                 /* wait for transaction completion (except in cyclic case) */
1395                 if (atc_chan_is_enabled(atchan) && !atc_chan_is_cyclic(atchan))
1396                         return -EAGAIN;
1397         }
1398         return 0;
1399 }
1400
1401 static void atc_suspend_cyclic(struct at_dma_chan *atchan)
1402 {
1403         struct dma_chan *chan = &atchan->chan_common;
1404
1405         /* Channel should be paused by user
1406          * do it anyway even if it is not done already */
1407         if (!atc_chan_is_paused(atchan)) {
1408                 dev_warn(chan2dev(chan),
1409                 "cyclic channel not paused, should be done by channel user\n");
1410                 atc_control(chan, DMA_PAUSE, 0);
1411         }
1412
1413         /* now preserve additional data for cyclic operations */
1414         /* next descriptor address in the cyclic list */
1415         atchan->save_dscr = channel_readl(atchan, DSCR);
1416
1417         vdbg_dump_regs(atchan);
1418 }
1419
1420 static int at_dma_suspend_noirq(struct device *dev)
1421 {
1422         struct platform_device *pdev = to_platform_device(dev);
1423         struct at_dma *atdma = platform_get_drvdata(pdev);
1424         struct dma_chan *chan, *_chan;
1425
1426         /* preserve data */
1427         list_for_each_entry_safe(chan, _chan, &atdma->dma_common.channels,
1428                         device_node) {
1429                 struct at_dma_chan *atchan = to_at_dma_chan(chan);
1430
1431                 if (atc_chan_is_cyclic(atchan))
1432                         atc_suspend_cyclic(atchan);
1433                 atchan->save_cfg = channel_readl(atchan, CFG);
1434         }
1435         atdma->save_imr = dma_readl(atdma, EBCIMR);
1436
1437         /* disable DMA controller */
1438         at_dma_off(atdma);
1439         clk_disable(atdma->clk);
1440         return 0;
1441 }
1442
1443 static void atc_resume_cyclic(struct at_dma_chan *atchan)
1444 {
1445         struct at_dma   *atdma = to_at_dma(atchan->chan_common.device);
1446
1447         /* restore channel status for cyclic descriptors list:
1448          * next descriptor in the cyclic list at the time of suspend */
1449         channel_writel(atchan, SADDR, 0);
1450         channel_writel(atchan, DADDR, 0);
1451         channel_writel(atchan, CTRLA, 0);
1452         channel_writel(atchan, CTRLB, 0);
1453         channel_writel(atchan, DSCR, atchan->save_dscr);
1454         dma_writel(atdma, CHER, atchan->mask);
1455
1456         /* channel pause status should be removed by channel user
1457          * We cannot take the initiative to do it here */
1458
1459         vdbg_dump_regs(atchan);
1460 }
1461
1462 static int at_dma_resume_noirq(struct device *dev)
1463 {
1464         struct platform_device *pdev = to_platform_device(dev);
1465         struct at_dma *atdma = platform_get_drvdata(pdev);
1466         struct dma_chan *chan, *_chan;
1467
1468         /* bring back DMA controller */
1469         clk_enable(atdma->clk);
1470         dma_writel(atdma, EN, AT_DMA_ENABLE);
1471
1472         /* clear any pending interrupt */
1473         while (dma_readl(atdma, EBCISR))
1474                 cpu_relax();
1475
1476         /* restore saved data */
1477         dma_writel(atdma, EBCIER, atdma->save_imr);
1478         list_for_each_entry_safe(chan, _chan, &atdma->dma_common.channels,
1479                         device_node) {
1480                 struct at_dma_chan *atchan = to_at_dma_chan(chan);
1481
1482                 channel_writel(atchan, CFG, atchan->save_cfg);
1483                 if (atc_chan_is_cyclic(atchan))
1484                         atc_resume_cyclic(atchan);
1485         }
1486         return 0;
1487 }
1488
1489 static const struct dev_pm_ops at_dma_dev_pm_ops = {
1490         .prepare = at_dma_prepare,
1491         .suspend_noirq = at_dma_suspend_noirq,
1492         .resume_noirq = at_dma_resume_noirq,
1493 };
1494
1495 static struct platform_driver at_dma_driver = {
1496         .remove         = __exit_p(at_dma_remove),
1497         .shutdown       = at_dma_shutdown,
1498         .driver = {
1499                 .name   = "at_hdmac",
1500                 .pm     = &at_dma_dev_pm_ops,
1501         },
1502 };
1503
1504 static int __init at_dma_init(void)
1505 {
1506         return platform_driver_probe(&at_dma_driver, at_dma_probe);
1507 }
1508 subsys_initcall(at_dma_init);
1509
1510 static void __exit at_dma_exit(void)
1511 {
1512         platform_driver_unregister(&at_dma_driver);
1513 }
1514 module_exit(at_dma_exit);
1515
1516 MODULE_DESCRIPTION("Atmel AHB DMA Controller driver");
1517 MODULE_AUTHOR("Nicolas Ferre <nicolas.ferre@atmel.com>");
1518 MODULE_LICENSE("GPL");
1519 MODULE_ALIAS("platform:at_hdmac");