i2c: tegra: remove support for I2C_M_REV_DIR_ADDR
[linux-2.6.git] / drivers / dma / pl330.c
1 /* linux/drivers/dma/pl330.c
2  *
3  * Copyright (C) 2010 Samsung Electronics Co. Ltd.
4  *      Jaswinder Singh <jassi.brar@samsung.com>
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 #include <linux/io.h>
13 #include <linux/init.h>
14 #include <linux/slab.h>
15 #include <linux/module.h>
16 #include <linux/dmaengine.h>
17 #include <linux/interrupt.h>
18 #include <linux/amba/bus.h>
19 #include <linux/amba/pl330.h>
20
21 #include "dmaengine.h"
22
23 #define NR_DEFAULT_DESC 16
24
25 enum desc_status {
26         /* In the DMAC pool */
27         FREE,
28         /*
29          * Allocted to some channel during prep_xxx
30          * Also may be sitting on the work_list.
31          */
32         PREP,
33         /*
34          * Sitting on the work_list and already submitted
35          * to the PL330 core. Not more than two descriptors
36          * of a channel can be BUSY at any time.
37          */
38         BUSY,
39         /*
40          * Sitting on the channel work_list but xfer done
41          * by PL330 core
42          */
43         DONE,
44 };
45
46 struct dma_pl330_chan {
47         /* Schedule desc completion */
48         struct tasklet_struct task;
49
50         /* DMA-Engine Channel */
51         struct dma_chan chan;
52
53         /* List of to be xfered descriptors */
54         struct list_head work_list;
55
56         /* Pointer to the DMAC that manages this channel,
57          * NULL if the channel is available to be acquired.
58          * As the parent, this DMAC also provides descriptors
59          * to the channel.
60          */
61         struct dma_pl330_dmac *dmac;
62
63         /* To protect channel manipulation */
64         spinlock_t lock;
65
66         /* Token of a hardware channel thread of PL330 DMAC
67          * NULL if the channel is available to be acquired.
68          */
69         void *pl330_chid;
70 };
71
72 struct dma_pl330_dmac {
73         struct pl330_info pif;
74
75         /* DMA-Engine Device */
76         struct dma_device ddma;
77
78         /* Pool of descriptors available for the DMAC's channels */
79         struct list_head desc_pool;
80         /* To protect desc_pool manipulation */
81         spinlock_t pool_lock;
82
83         /* Peripheral channels connected to this DMAC */
84         struct dma_pl330_chan *peripherals; /* keep at end */
85 };
86
87 struct dma_pl330_desc {
88         /* To attach to a queue as child */
89         struct list_head node;
90
91         /* Descriptor for the DMA Engine API */
92         struct dma_async_tx_descriptor txd;
93
94         /* Xfer for PL330 core */
95         struct pl330_xfer px;
96
97         struct pl330_reqcfg rqcfg;
98         struct pl330_req req;
99
100         enum desc_status status;
101
102         /* The channel which currently holds this desc */
103         struct dma_pl330_chan *pchan;
104 };
105
106 static inline struct dma_pl330_chan *
107 to_pchan(struct dma_chan *ch)
108 {
109         if (!ch)
110                 return NULL;
111
112         return container_of(ch, struct dma_pl330_chan, chan);
113 }
114
115 static inline struct dma_pl330_desc *
116 to_desc(struct dma_async_tx_descriptor *tx)
117 {
118         return container_of(tx, struct dma_pl330_desc, txd);
119 }
120
121 static inline void free_desc_list(struct list_head *list)
122 {
123         struct dma_pl330_dmac *pdmac;
124         struct dma_pl330_desc *desc;
125         struct dma_pl330_chan *pch;
126         unsigned long flags;
127
128         if (list_empty(list))
129                 return;
130
131         /* Finish off the work list */
132         list_for_each_entry(desc, list, node) {
133                 dma_async_tx_callback callback;
134                 void *param;
135
136                 /* All desc in a list belong to same channel */
137                 pch = desc->pchan;
138                 callback = desc->txd.callback;
139                 param = desc->txd.callback_param;
140
141                 if (callback)
142                         callback(param);
143
144                 desc->pchan = NULL;
145         }
146
147         pdmac = pch->dmac;
148
149         spin_lock_irqsave(&pdmac->pool_lock, flags);
150         list_splice_tail_init(list, &pdmac->desc_pool);
151         spin_unlock_irqrestore(&pdmac->pool_lock, flags);
152 }
153
154 static inline void fill_queue(struct dma_pl330_chan *pch)
155 {
156         struct dma_pl330_desc *desc;
157         int ret;
158
159         list_for_each_entry(desc, &pch->work_list, node) {
160
161                 /* If already submitted */
162                 if (desc->status == BUSY)
163                         break;
164
165                 ret = pl330_submit_req(pch->pl330_chid,
166                                                 &desc->req);
167                 if (!ret) {
168                         desc->status = BUSY;
169                         break;
170                 } else if (ret == -EAGAIN) {
171                         /* QFull or DMAC Dying */
172                         break;
173                 } else {
174                         /* Unacceptable request */
175                         desc->status = DONE;
176                         dev_err(pch->dmac->pif.dev, "%s:%d Bad Desc(%d)\n",
177                                         __func__, __LINE__, desc->txd.cookie);
178                         tasklet_schedule(&pch->task);
179                 }
180         }
181 }
182
183 static void pl330_tasklet(unsigned long data)
184 {
185         struct dma_pl330_chan *pch = (struct dma_pl330_chan *)data;
186         struct dma_pl330_desc *desc, *_dt;
187         unsigned long flags;
188         LIST_HEAD(list);
189
190         spin_lock_irqsave(&pch->lock, flags);
191
192         /* Pick up ripe tomatoes */
193         list_for_each_entry_safe(desc, _dt, &pch->work_list, node)
194                 if (desc->status == DONE) {
195                         dma_cookie_complete(&desc->txd);
196                         list_move_tail(&desc->node, &list);
197                 }
198
199         /* Try to submit a req imm. next to the last completed cookie */
200         fill_queue(pch);
201
202         /* Make sure the PL330 Channel thread is active */
203         pl330_chan_ctrl(pch->pl330_chid, PL330_OP_START);
204
205         spin_unlock_irqrestore(&pch->lock, flags);
206
207         free_desc_list(&list);
208 }
209
210 static void dma_pl330_rqcb(void *token, enum pl330_op_err err)
211 {
212         struct dma_pl330_desc *desc = token;
213         struct dma_pl330_chan *pch = desc->pchan;
214         unsigned long flags;
215
216         /* If desc aborted */
217         if (!pch)
218                 return;
219
220         spin_lock_irqsave(&pch->lock, flags);
221
222         desc->status = DONE;
223
224         spin_unlock_irqrestore(&pch->lock, flags);
225
226         tasklet_schedule(&pch->task);
227 }
228
229 static int pl330_alloc_chan_resources(struct dma_chan *chan)
230 {
231         struct dma_pl330_chan *pch = to_pchan(chan);
232         struct dma_pl330_dmac *pdmac = pch->dmac;
233         unsigned long flags;
234
235         spin_lock_irqsave(&pch->lock, flags);
236
237         dma_cookie_init(chan);
238         pch->cyclic = false;
239
240         pch->pl330_chid = pl330_request_channel(&pdmac->pif);
241         if (!pch->pl330_chid) {
242                 spin_unlock_irqrestore(&pch->lock, flags);
243                 return 0;
244         }
245
246         tasklet_init(&pch->task, pl330_tasklet, (unsigned long) pch);
247
248         spin_unlock_irqrestore(&pch->lock, flags);
249
250         return 1;
251 }
252
253 static int pl330_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd, unsigned long arg)
254 {
255         struct dma_pl330_chan *pch = to_pchan(chan);
256         struct dma_pl330_desc *desc;
257         unsigned long flags;
258
259         /* Only supports DMA_TERMINATE_ALL */
260         if (cmd != DMA_TERMINATE_ALL)
261                 return -ENXIO;
262
263         spin_lock_irqsave(&pch->lock, flags);
264
265         /* FLUSH the PL330 Channel thread */
266         pl330_chan_ctrl(pch->pl330_chid, PL330_OP_FLUSH);
267
268         /* Mark all desc done */
269         list_for_each_entry(desc, &pch->work_list, node)
270                 desc->status = DONE;
271
272         spin_unlock_irqrestore(&pch->lock, flags);
273
274         pl330_tasklet((unsigned long) pch);
275
276         return 0;
277 }
278
279 static void pl330_free_chan_resources(struct dma_chan *chan)
280 {
281         struct dma_pl330_chan *pch = to_pchan(chan);
282         unsigned long flags;
283
284         spin_lock_irqsave(&pch->lock, flags);
285
286         tasklet_kill(&pch->task);
287
288         pl330_release_channel(pch->pl330_chid);
289         pch->pl330_chid = NULL;
290
291         spin_unlock_irqrestore(&pch->lock, flags);
292 }
293
294 static enum dma_status
295 pl330_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
296                  struct dma_tx_state *txstate)
297 {
298         return dma_cookie_status(chan, cookie, txstate);
299 }
300
301 static void pl330_issue_pending(struct dma_chan *chan)
302 {
303         pl330_tasklet((unsigned long) to_pchan(chan));
304 }
305
306 /*
307  * We returned the last one of the circular list of descriptor(s)
308  * from prep_xxx, so the argument to submit corresponds to the last
309  * descriptor of the list.
310  */
311 static dma_cookie_t pl330_tx_submit(struct dma_async_tx_descriptor *tx)
312 {
313         struct dma_pl330_desc *desc, *last = to_desc(tx);
314         struct dma_pl330_chan *pch = to_pchan(tx->chan);
315         dma_cookie_t cookie;
316         unsigned long flags;
317
318         spin_lock_irqsave(&pch->lock, flags);
319
320         /* Assign cookies to all nodes */
321         while (!list_empty(&last->node)) {
322                 desc = list_entry(last->node.next, struct dma_pl330_desc, node);
323
324                 dma_cookie_assign(&desc->txd);
325
326                 list_move_tail(&desc->node, &pch->work_list);
327         }
328
329         cookie = dma_cookie_assign(&last->txd);
330         list_add_tail(&last->node, &pch->work_list);
331         spin_unlock_irqrestore(&pch->lock, flags);
332
333         return cookie;
334 }
335
336 static inline void _init_desc(struct dma_pl330_desc *desc)
337 {
338         desc->pchan = NULL;
339         desc->req.x = &desc->px;
340         desc->req.token = desc;
341         desc->rqcfg.swap = SWAP_NO;
342         desc->rqcfg.privileged = 0;
343         desc->rqcfg.insnaccess = 0;
344         desc->rqcfg.scctl = SCCTRL0;
345         desc->rqcfg.dcctl = DCCTRL0;
346         desc->req.cfg = &desc->rqcfg;
347         desc->req.xfer_cb = dma_pl330_rqcb;
348         desc->txd.tx_submit = pl330_tx_submit;
349
350         INIT_LIST_HEAD(&desc->node);
351 }
352
353 /* Returns the number of descriptors added to the DMAC pool */
354 int add_desc(struct dma_pl330_dmac *pdmac, gfp_t flg, int count)
355 {
356         struct dma_pl330_desc *desc;
357         unsigned long flags;
358         int i;
359
360         if (!pdmac)
361                 return 0;
362
363         desc = kmalloc(count * sizeof(*desc), flg);
364         if (!desc)
365                 return 0;
366
367         spin_lock_irqsave(&pdmac->pool_lock, flags);
368
369         for (i = 0; i < count; i++) {
370                 _init_desc(&desc[i]);
371                 list_add_tail(&desc[i].node, &pdmac->desc_pool);
372         }
373
374         spin_unlock_irqrestore(&pdmac->pool_lock, flags);
375
376         return count;
377 }
378
379 static struct dma_pl330_desc *
380 pluck_desc(struct dma_pl330_dmac *pdmac)
381 {
382         struct dma_pl330_desc *desc = NULL;
383         unsigned long flags;
384
385         if (!pdmac)
386                 return NULL;
387
388         spin_lock_irqsave(&pdmac->pool_lock, flags);
389
390         if (!list_empty(&pdmac->desc_pool)) {
391                 desc = list_entry(pdmac->desc_pool.next,
392                                 struct dma_pl330_desc, node);
393
394                 list_del_init(&desc->node);
395
396                 desc->status = PREP;
397                 desc->txd.callback = NULL;
398         }
399
400         spin_unlock_irqrestore(&pdmac->pool_lock, flags);
401
402         return desc;
403 }
404
405 static struct dma_pl330_desc *pl330_get_desc(struct dma_pl330_chan *pch)
406 {
407         struct dma_pl330_dmac *pdmac = pch->dmac;
408         struct dma_pl330_peri *peri = pch->chan.private;
409         struct dma_pl330_desc *desc;
410
411         /* Pluck one desc from the pool of DMAC */
412         desc = pluck_desc(pdmac);
413
414         /* If the DMAC pool is empty, alloc new */
415         if (!desc) {
416                 if (!add_desc(pdmac, GFP_ATOMIC, 1))
417                         return NULL;
418
419                 /* Try again */
420                 desc = pluck_desc(pdmac);
421                 if (!desc) {
422                         dev_err(pch->dmac->pif.dev,
423                                 "%s:%d ALERT!\n", __func__, __LINE__);
424                         return NULL;
425                 }
426         }
427
428         /* Initialize the descriptor */
429         desc->pchan = pch;
430         desc->txd.cookie = 0;
431         async_tx_ack(&desc->txd);
432
433         if (peri) {
434                 desc->req.rqtype = peri->rqtype;
435                 desc->req.peri = peri->peri_id;
436         } else {
437                 desc->req.rqtype = MEMTOMEM;
438                 desc->req.peri = 0;
439         }
440
441         dma_async_tx_descriptor_init(&desc->txd, &pch->chan);
442
443         return desc;
444 }
445
446 static inline void fill_px(struct pl330_xfer *px,
447                 dma_addr_t dst, dma_addr_t src, size_t len)
448 {
449         px->next = NULL;
450         px->bytes = len;
451         px->dst_addr = dst;
452         px->src_addr = src;
453 }
454
455 static struct dma_pl330_desc *
456 __pl330_prep_dma_memcpy(struct dma_pl330_chan *pch, dma_addr_t dst,
457                 dma_addr_t src, size_t len)
458 {
459         struct dma_pl330_desc *desc = pl330_get_desc(pch);
460
461         if (!desc) {
462                 dev_err(pch->dmac->pif.dev, "%s:%d Unable to fetch desc\n",
463                         __func__, __LINE__);
464                 return NULL;
465         }
466
467         /*
468          * Ideally we should lookout for reqs bigger than
469          * those that can be programmed with 256 bytes of
470          * MC buffer, but considering a req size is seldom
471          * going to be word-unaligned and more than 200MB,
472          * we take it easy.
473          * Also, should the limit is reached we'd rather
474          * have the platform increase MC buffer size than
475          * complicating this API driver.
476          */
477         fill_px(&desc->px, dst, src, len);
478
479         return desc;
480 }
481
482 /* Call after fixing burst size */
483 static inline int get_burst_len(struct dma_pl330_desc *desc, size_t len)
484 {
485         struct dma_pl330_chan *pch = desc->pchan;
486         struct pl330_info *pi = &pch->dmac->pif;
487         int burst_len;
488
489         burst_len = pi->pcfg.data_bus_width / 8;
490         burst_len *= pi->pcfg.data_buf_dep;
491         burst_len >>= desc->rqcfg.brst_size;
492
493         /* src/dst_burst_len can't be more than 16 */
494         if (burst_len > 16)
495                 burst_len = 16;
496
497         while (burst_len > 1) {
498                 if (!(len % (burst_len << desc->rqcfg.brst_size)))
499                         break;
500                 burst_len--;
501         }
502
503         return burst_len;
504 }
505
506 static struct dma_async_tx_descriptor *pl330_prep_dma_cyclic(
507                 struct dma_chan *chan, dma_addr_t dma_addr, size_t len,
508                 size_t period_len, enum dma_transfer_direction direction,
509                 void *context)
510 {
511         struct dma_pl330_desc *desc;
512         struct dma_pl330_chan *pch = to_pchan(chan);
513         dma_addr_t dst;
514         dma_addr_t src;
515
516         desc = pl330_get_desc(pch);
517         if (!desc) {
518                 dev_err(pch->dmac->pif.dev, "%s:%d Unable to fetch desc\n",
519                         __func__, __LINE__);
520                 return NULL;
521         }
522
523         switch (direction) {
524         case DMA_MEM_TO_DEV:
525                 desc->rqcfg.src_inc = 1;
526                 desc->rqcfg.dst_inc = 0;
527                 desc->req.rqtype = MEMTODEV;
528                 src = dma_addr;
529                 dst = pch->fifo_addr;
530                 break;
531         case DMA_DEV_TO_MEM:
532                 desc->rqcfg.src_inc = 0;
533                 desc->rqcfg.dst_inc = 1;
534                 desc->req.rqtype = DEVTOMEM;
535                 src = pch->fifo_addr;
536                 dst = dma_addr;
537                 break;
538         default:
539                 dev_err(pch->dmac->pif.dev, "%s:%d Invalid dma direction\n",
540                 __func__, __LINE__);
541                 return NULL;
542         }
543
544         desc->rqcfg.brst_size = pch->burst_sz;
545         desc->rqcfg.brst_len = 1;
546
547         pch->cyclic = true;
548
549         fill_px(&desc->px, dst, src, period_len);
550
551         return &desc->txd;
552 }
553
554 static struct dma_async_tx_descriptor *
555 pl330_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dst,
556                 dma_addr_t src, size_t len, unsigned long flags)
557 {
558         struct dma_pl330_desc *desc;
559         struct dma_pl330_chan *pch = to_pchan(chan);
560         struct dma_pl330_peri *peri = chan->private;
561         struct pl330_info *pi;
562         int burst;
563
564         if (unlikely(!pch || !len))
565                 return NULL;
566
567         if (peri && peri->rqtype != MEMTOMEM)
568                 return NULL;
569
570         pi = &pch->dmac->pif;
571
572         desc = __pl330_prep_dma_memcpy(pch, dst, src, len);
573         if (!desc)
574                 return NULL;
575
576         desc->rqcfg.src_inc = 1;
577         desc->rqcfg.dst_inc = 1;
578
579         /* Select max possible burst size */
580         burst = pi->pcfg.data_bus_width / 8;
581
582         while (burst > 1) {
583                 if (!(len % burst))
584                         break;
585                 burst /= 2;
586         }
587
588         desc->rqcfg.brst_size = 0;
589         while (burst != (1 << desc->rqcfg.brst_size))
590                 desc->rqcfg.brst_size++;
591
592         desc->rqcfg.brst_len = get_burst_len(desc, len);
593
594         desc->txd.flags = flags;
595
596         return &desc->txd;
597 }
598
599 static struct dma_async_tx_descriptor *
600 pl330_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
601                 unsigned int sg_len, enum dma_transfer_direction direction,
602                 unsigned long flg, void *context)
603 {
604         struct dma_pl330_desc *first, *desc = NULL;
605         struct dma_pl330_chan *pch = to_pchan(chan);
606         struct dma_pl330_peri *peri = chan->private;
607         struct scatterlist *sg;
608         unsigned long flags;
609         int i, burst_size;
610         dma_addr_t addr;
611
612         if (unlikely(!pch || !sgl || !sg_len || !peri))
613                 return NULL;
614
615         /* Make sure the direction is consistent */
616         if ((direction == DMA_TO_DEVICE &&
617                                 peri->rqtype != MEMTODEV) ||
618                         (direction == DMA_FROM_DEVICE &&
619                                 peri->rqtype != DEVTOMEM)) {
620                 dev_err(pch->dmac->pif.dev, "%s:%d Invalid Direction\n",
621                                 __func__, __LINE__);
622                 return NULL;
623         }
624
625         addr = peri->fifo_addr;
626         burst_size = peri->burst_sz;
627
628         first = NULL;
629
630         for_each_sg(sgl, sg, sg_len, i) {
631
632                 desc = pl330_get_desc(pch);
633                 if (!desc) {
634                         struct dma_pl330_dmac *pdmac = pch->dmac;
635
636                         dev_err(pch->dmac->pif.dev,
637                                 "%s:%d Unable to fetch desc\n",
638                                 __func__, __LINE__);
639                         if (!first)
640                                 return NULL;
641
642                         spin_lock_irqsave(&pdmac->pool_lock, flags);
643
644                         while (!list_empty(&first->node)) {
645                                 desc = list_entry(first->node.next,
646                                                 struct dma_pl330_desc, node);
647                                 list_move_tail(&desc->node, &pdmac->desc_pool);
648                         }
649
650                         list_move_tail(&first->node, &pdmac->desc_pool);
651
652                         spin_unlock_irqrestore(&pdmac->pool_lock, flags);
653
654                         return NULL;
655                 }
656
657                 if (!first)
658                         first = desc;
659                 else
660                         list_add_tail(&desc->node, &first->node);
661
662                 if (direction == DMA_TO_DEVICE) {
663                         desc->rqcfg.src_inc = 1;
664                         desc->rqcfg.dst_inc = 0;
665                         fill_px(&desc->px,
666                                 addr, sg_dma_address(sg), sg_dma_len(sg));
667                 } else {
668                         desc->rqcfg.src_inc = 0;
669                         desc->rqcfg.dst_inc = 1;
670                         fill_px(&desc->px,
671                                 sg_dma_address(sg), addr, sg_dma_len(sg));
672                 }
673
674                 desc->rqcfg.brst_size = burst_size;
675                 desc->rqcfg.brst_len = 1;
676         }
677
678         /* Return the last desc in the chain */
679         desc->txd.flags = flg;
680         return &desc->txd;
681 }
682
683 static irqreturn_t pl330_irq_handler(int irq, void *data)
684 {
685         if (pl330_update(data))
686                 return IRQ_HANDLED;
687         else
688                 return IRQ_NONE;
689 }
690
691 static int __devinit
692 pl330_probe(struct amba_device *adev, const struct amba_id *id)
693 {
694         struct dma_pl330_platdata *pdat;
695         struct dma_pl330_dmac *pdmac;
696         struct dma_pl330_chan *pch;
697         struct pl330_info *pi;
698         struct dma_device *pd;
699         struct resource *res;
700         int i, ret, irq;
701         int num_chan;
702
703         pdat = adev->dev.platform_data;
704
705         /* Allocate a new DMAC and its Channels */
706         pdmac = kzalloc(sizeof(*pdmac), GFP_KERNEL);
707         if (!pdmac) {
708                 dev_err(&adev->dev, "unable to allocate mem\n");
709                 return -ENOMEM;
710         }
711
712         pi = &pdmac->pif;
713         pi->dev = &adev->dev;
714         pi->pl330_data = NULL;
715         pi->mcbufsz = pdat ? pdat->mcbuf_sz : 0;
716
717         res = &adev->res;
718         request_mem_region(res->start, resource_size(res), "dma-pl330");
719
720         pi->base = ioremap(res->start, resource_size(res));
721         if (!pi->base) {
722                 ret = -ENXIO;
723                 goto probe_err1;
724         }
725
726         irq = adev->irq[0];
727         ret = request_irq(irq, pl330_irq_handler, 0,
728                         dev_name(&adev->dev), pi);
729         if (ret)
730                 goto probe_err2;
731
732         ret = pl330_add(pi);
733         if (ret)
734                 goto probe_err3;
735
736         INIT_LIST_HEAD(&pdmac->desc_pool);
737         spin_lock_init(&pdmac->pool_lock);
738
739         /* Create a descriptor pool of default size */
740         if (!add_desc(pdmac, GFP_KERNEL, NR_DEFAULT_DESC))
741                 dev_warn(&adev->dev, "unable to allocate desc\n");
742
743         pd = &pdmac->ddma;
744         INIT_LIST_HEAD(&pd->channels);
745
746         /* Initialize channel parameters */
747         num_chan = max(pdat ? pdat->nr_valid_peri : 0, (u8)pi->pcfg.num_chan);
748         pdmac->peripherals = kzalloc(num_chan * sizeof(*pch), GFP_KERNEL);
749
750         for (i = 0; i < num_chan; i++) {
751                 pch = &pdmac->peripherals[i];
752                 if (pdat) {
753                         struct dma_pl330_peri *peri = &pdat->peri[i];
754
755                         switch (peri->rqtype) {
756                         case MEMTOMEM:
757                                 dma_cap_set(DMA_MEMCPY, pd->cap_mask);
758                                 break;
759                         case MEMTODEV:
760                         case DEVTOMEM:
761                                 dma_cap_set(DMA_SLAVE, pd->cap_mask);
762                                 break;
763                         default:
764                                 dev_err(&adev->dev, "DEVTODEV Not Supported\n");
765                                 continue;
766                         }
767                         pch->chan.private = peri;
768                 } else {
769                         dma_cap_set(DMA_MEMCPY, pd->cap_mask);
770                         pch->chan.private = NULL;
771                 }
772
773                 INIT_LIST_HEAD(&pch->work_list);
774                 spin_lock_init(&pch->lock);
775                 pch->pl330_chid = NULL;
776                 pch->chan.device = pd;
777                 pch->chan.chan_id = i;
778                 pch->dmac = pdmac;
779
780                 /* Add the channel to the DMAC list */
781                 pd->chancnt++;
782                 list_add_tail(&pch->chan.device_node, &pd->channels);
783         }
784
785         pd->dev = &adev->dev;
786
787         pd->device_alloc_chan_resources = pl330_alloc_chan_resources;
788         pd->device_free_chan_resources = pl330_free_chan_resources;
789         pd->device_prep_dma_memcpy = pl330_prep_dma_memcpy;
790         pd->device_tx_status = pl330_tx_status;
791         pd->device_prep_slave_sg = pl330_prep_slave_sg;
792         pd->device_control = pl330_control;
793         pd->device_issue_pending = pl330_issue_pending;
794
795         ret = dma_async_device_register(pd);
796         if (ret) {
797                 dev_err(&adev->dev, "unable to register DMAC\n");
798                 goto probe_err4;
799         }
800
801         amba_set_drvdata(adev, pdmac);
802
803         dev_info(&adev->dev,
804                 "Loaded driver for PL330 DMAC-%d\n", adev->periphid);
805         dev_info(&adev->dev,
806                 "\tDBUFF-%ux%ubytes Num_Chans-%u Num_Peri-%u Num_Events-%u\n",
807                 pi->pcfg.data_buf_dep,
808                 pi->pcfg.data_bus_width / 8, pi->pcfg.num_chan,
809                 pi->pcfg.num_peri, pi->pcfg.num_events);
810
811         return 0;
812
813 probe_err4:
814         pl330_del(pi);
815 probe_err3:
816         free_irq(irq, pi);
817 probe_err2:
818         iounmap(pi->base);
819 probe_err1:
820         release_mem_region(res->start, resource_size(res));
821         kfree(pdmac);
822
823         return ret;
824 }
825
826 static int __devexit pl330_remove(struct amba_device *adev)
827 {
828         struct dma_pl330_dmac *pdmac = amba_get_drvdata(adev);
829         struct dma_pl330_chan *pch, *_p;
830         struct pl330_info *pi;
831         struct resource *res;
832         int irq;
833
834         if (!pdmac)
835                 return 0;
836
837         amba_set_drvdata(adev, NULL);
838
839         /* Idle the DMAC */
840         list_for_each_entry_safe(pch, _p, &pdmac->ddma.channels,
841                         chan.device_node) {
842
843                 /* Remove the channel */
844                 list_del(&pch->chan.device_node);
845
846                 /* Flush the channel */
847                 pl330_control(&pch->chan, DMA_TERMINATE_ALL, 0);
848                 pl330_free_chan_resources(&pch->chan);
849         }
850
851         pi = &pdmac->pif;
852
853         pl330_del(pi);
854
855         irq = adev->irq[0];
856         free_irq(irq, pi);
857
858         iounmap(pi->base);
859
860         res = &adev->res;
861         release_mem_region(res->start, resource_size(res));
862
863         kfree(pdmac);
864
865         return 0;
866 }
867
868 static struct amba_id pl330_ids[] = {
869         {
870                 .id     = 0x00041330,
871                 .mask   = 0x000fffff,
872         },
873         { 0, 0 },
874 };
875
876 static struct amba_driver pl330_driver = {
877         .drv = {
878                 .owner = THIS_MODULE,
879                 .name = "dma-pl330",
880         },
881         .id_table = pl330_ids,
882         .probe = pl330_probe,
883         .remove = pl330_remove,
884 };
885
886 static int __init pl330_init(void)
887 {
888         return amba_driver_register(&pl330_driver);
889 }
890 module_init(pl330_init);
891
892 static void __exit pl330_exit(void)
893 {
894         amba_driver_unregister(&pl330_driver);
895         return;
896 }
897 module_exit(pl330_exit);
898
899 MODULE_AUTHOR("Jaswinder Singh <jassi.brar@samsung.com>");
900 MODULE_DESCRIPTION("API Driver for PL330 DMAC");
901 MODULE_LICENSE("GPL");