6c52959b00af55d4d2487decc43ee74e97287868
[linux-2.6.git] / drivers / dma / amba-pl08x.c
1 /*
2  * Copyright (c) 2006 ARM Ltd.
3  * Copyright (c) 2010 ST-Ericsson SA
4  *
5  * Author: Peter Pearse <peter.pearse@arm.com>
6  * Author: Linus Walleij <linus.walleij@stericsson.com>
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License as published by the Free
10  * Software Foundation; either version 2 of the License, or (at your option)
11  * any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  *
18  * You should have received a copy of the GNU General Public License along with
19  * this program; if not, write to the Free Software Foundation, Inc., 59
20  * Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The full GNU General Public License is in this distribution in the file
23  * called COPYING.
24  *
25  * Documentation: ARM DDI 0196G == PL080
26  * Documentation: ARM DDI 0218E == PL081
27  *
28  * PL080 & PL081 both have 16 sets of DMA signals that can be routed to any
29  * channel.
30  *
31  * The PL080 has 8 channels available for simultaneous use, and the PL081
32  * has only two channels. So on these DMA controllers the number of channels
33  * and the number of incoming DMA signals are two totally different things.
34  * It is usually not possible to theoretically handle all physical signals,
35  * so a multiplexing scheme with possible denial of use is necessary.
36  *
37  * The PL080 has a dual bus master, PL081 has a single master.
38  *
39  * Memory to peripheral transfer may be visualized as
40  *      Get data from memory to DMAC
41  *      Until no data left
42  *              On burst request from peripheral
43  *                      Destination burst from DMAC to peripheral
44  *                      Clear burst request
45  *      Raise terminal count interrupt
46  *
47  * For peripherals with a FIFO:
48  * Source      burst size == half the depth of the peripheral FIFO
49  * Destination burst size == the depth of the peripheral FIFO
50  *
51  * (Bursts are irrelevant for mem to mem transfers - there are no burst
52  * signals, the DMA controller will simply facilitate its AHB master.)
53  *
54  * ASSUMES default (little) endianness for DMA transfers
55  *
56  * The PL08x has two flow control settings:
57  *  - DMAC flow control: the transfer size defines the number of transfers
58  *    which occur for the current LLI entry, and the DMAC raises TC at the
59  *    end of every LLI entry.  Observed behaviour shows the DMAC listening
60  *    to both the BREQ and SREQ signals (contrary to documented),
61  *    transferring data if either is active.  The LBREQ and LSREQ signals
62  *    are ignored.
63  *
64  *  - Peripheral flow control: the transfer size is ignored (and should be
65  *    zero).  The data is transferred from the current LLI entry, until
66  *    after the final transfer signalled by LBREQ or LSREQ.  The DMAC
67  *    will then move to the next LLI entry.
68  *
69  * Only the former works sanely with scatter lists, so we only implement
70  * the DMAC flow control method.  However, peripherals which use the LBREQ
71  * and LSREQ signals (eg, MMCI) are unable to use this mode, which through
72  * these hardware restrictions prevents them from using scatter DMA.
73  *
74  * Global TODO:
75  * - Break out common code from arch/arm/mach-s3c64xx and share
76  */
77 #include <linux/amba/bus.h>
78 #include <linux/amba/pl08x.h>
79 #include <linux/debugfs.h>
80 #include <linux/delay.h>
81 #include <linux/device.h>
82 #include <linux/dmaengine.h>
83 #include <linux/dmapool.h>
84 #include <linux/init.h>
85 #include <linux/interrupt.h>
86 #include <linux/module.h>
87 #include <linux/seq_file.h>
88 #include <linux/slab.h>
89 #include <asm/hardware/pl080.h>
90
91 #define DRIVER_NAME     "pl08xdmac"
92
93 /**
94  * struct vendor_data - vendor-specific config parameters for PL08x derivatives
95  * @channels: the number of channels available in this variant
96  * @dualmaster: whether this version supports dual AHB masters or not.
97  */
98 struct vendor_data {
99         u8 channels;
100         bool dualmaster;
101 };
102
103 /*
104  * PL08X private data structures
105  * An LLI struct - see PL08x TRM.  Note that next uses bit[0] as a bus bit,
106  * start & end do not - their bus bit info is in cctl.  Also note that these
107  * are fixed 32-bit quantities.
108  */
109 struct pl08x_lli {
110         u32 src;
111         u32 dst;
112         u32 lli;
113         u32 cctl;
114 };
115
116 /**
117  * struct pl08x_driver_data - the local state holder for the PL08x
118  * @slave: slave engine for this instance
119  * @memcpy: memcpy engine for this instance
120  * @base: virtual memory base (remapped) for the PL08x
121  * @adev: the corresponding AMBA (PrimeCell) bus entry
122  * @vd: vendor data for this PL08x variant
123  * @pd: platform data passed in from the platform/machine
124  * @phy_chans: array of data for the physical channels
125  * @pool: a pool for the LLI descriptors
126  * @pool_ctr: counter of LLIs in the pool
127  * @lli_buses: bitmask to or in to LLI pointer selecting AHB port for LLI
128  * fetches
129  * @mem_buses: set to indicate memory transfers on AHB2.
130  * @lock: a spinlock for this struct
131  */
132 struct pl08x_driver_data {
133         struct dma_device slave;
134         struct dma_device memcpy;
135         void __iomem *base;
136         struct amba_device *adev;
137         const struct vendor_data *vd;
138         struct pl08x_platform_data *pd;
139         struct pl08x_phy_chan *phy_chans;
140         struct dma_pool *pool;
141         int pool_ctr;
142         u8 lli_buses;
143         u8 mem_buses;
144         spinlock_t lock;
145 };
146
147 /*
148  * PL08X specific defines
149  */
150
151 /*
152  * Memory boundaries: the manual for PL08x says that the controller
153  * cannot read past a 1KiB boundary, so these defines are used to
154  * create transfer LLIs that do not cross such boundaries.
155  */
156 #define PL08X_BOUNDARY_SHIFT            (10)    /* 1KB 0x400 */
157 #define PL08X_BOUNDARY_SIZE             (1 << PL08X_BOUNDARY_SHIFT)
158
159 /* Size (bytes) of each LLI buffer allocated for one transfer */
160 # define PL08X_LLI_TSFR_SIZE    0x2000
161
162 /* Maximum times we call dma_pool_alloc on this pool without freeing */
163 #define MAX_NUM_TSFR_LLIS       (PL08X_LLI_TSFR_SIZE/sizeof(struct pl08x_lli))
164 #define PL08X_ALIGN             8
165
166 static inline struct pl08x_dma_chan *to_pl08x_chan(struct dma_chan *chan)
167 {
168         return container_of(chan, struct pl08x_dma_chan, chan);
169 }
170
171 static inline struct pl08x_txd *to_pl08x_txd(struct dma_async_tx_descriptor *tx)
172 {
173         return container_of(tx, struct pl08x_txd, tx);
174 }
175
176 /*
177  * Physical channel handling
178  */
179
180 /* Whether a certain channel is busy or not */
181 static int pl08x_phy_channel_busy(struct pl08x_phy_chan *ch)
182 {
183         unsigned int val;
184
185         val = readl(ch->base + PL080_CH_CONFIG);
186         return val & PL080_CONFIG_ACTIVE;
187 }
188
189 /*
190  * Set the initial DMA register values i.e. those for the first LLI
191  * The next LLI pointer and the configuration interrupt bit have
192  * been set when the LLIs were constructed.  Poke them into the hardware
193  * and start the transfer.
194  */
195 static void pl08x_start_txd(struct pl08x_dma_chan *plchan,
196         struct pl08x_txd *txd)
197 {
198         struct pl08x_driver_data *pl08x = plchan->host;
199         struct pl08x_phy_chan *phychan = plchan->phychan;
200         struct pl08x_lli *lli = &txd->llis_va[0];
201         u32 val;
202
203         plchan->at = txd;
204
205         /* Wait for channel inactive */
206         while (pl08x_phy_channel_busy(phychan))
207                 cpu_relax();
208
209         dev_vdbg(&pl08x->adev->dev,
210                 "WRITE channel %d: csrc=0x%08x, cdst=0x%08x, "
211                 "clli=0x%08x, cctl=0x%08x, ccfg=0x%08x\n",
212                 phychan->id, lli->src, lli->dst, lli->lli, lli->cctl,
213                 txd->ccfg);
214
215         writel(lli->src, phychan->base + PL080_CH_SRC_ADDR);
216         writel(lli->dst, phychan->base + PL080_CH_DST_ADDR);
217         writel(lli->lli, phychan->base + PL080_CH_LLI);
218         writel(lli->cctl, phychan->base + PL080_CH_CONTROL);
219         writel(txd->ccfg, phychan->base + PL080_CH_CONFIG);
220
221         /* Enable the DMA channel */
222         /* Do not access config register until channel shows as disabled */
223         while (readl(pl08x->base + PL080_EN_CHAN) & (1 << phychan->id))
224                 cpu_relax();
225
226         /* Do not access config register until channel shows as inactive */
227         val = readl(phychan->base + PL080_CH_CONFIG);
228         while ((val & PL080_CONFIG_ACTIVE) || (val & PL080_CONFIG_ENABLE))
229                 val = readl(phychan->base + PL080_CH_CONFIG);
230
231         writel(val | PL080_CONFIG_ENABLE, phychan->base + PL080_CH_CONFIG);
232 }
233
234 /*
235  * Pause the channel by setting the HALT bit.
236  *
237  * For M->P transfers, pause the DMAC first and then stop the peripheral -
238  * the FIFO can only drain if the peripheral is still requesting data.
239  * (note: this can still timeout if the DMAC FIFO never drains of data.)
240  *
241  * For P->M transfers, disable the peripheral first to stop it filling
242  * the DMAC FIFO, and then pause the DMAC.
243  */
244 static void pl08x_pause_phy_chan(struct pl08x_phy_chan *ch)
245 {
246         u32 val;
247         int timeout;
248
249         /* Set the HALT bit and wait for the FIFO to drain */
250         val = readl(ch->base + PL080_CH_CONFIG);
251         val |= PL080_CONFIG_HALT;
252         writel(val, ch->base + PL080_CH_CONFIG);
253
254         /* Wait for channel inactive */
255         for (timeout = 1000; timeout; timeout--) {
256                 if (!pl08x_phy_channel_busy(ch))
257                         break;
258                 udelay(1);
259         }
260         if (pl08x_phy_channel_busy(ch))
261                 pr_err("pl08x: channel%u timeout waiting for pause\n", ch->id);
262 }
263
264 static void pl08x_resume_phy_chan(struct pl08x_phy_chan *ch)
265 {
266         u32 val;
267
268         /* Clear the HALT bit */
269         val = readl(ch->base + PL080_CH_CONFIG);
270         val &= ~PL080_CONFIG_HALT;
271         writel(val, ch->base + PL080_CH_CONFIG);
272 }
273
274 /*
275  * pl08x_terminate_phy_chan() stops the channel, clears the FIFO and
276  * clears any pending interrupt status.  This should not be used for
277  * an on-going transfer, but as a method of shutting down a channel
278  * (eg, when it's no longer used) or terminating a transfer.
279  */
280 static void pl08x_terminate_phy_chan(struct pl08x_driver_data *pl08x,
281         struct pl08x_phy_chan *ch)
282 {
283         u32 val = readl(ch->base + PL080_CH_CONFIG);
284
285         val &= ~(PL080_CONFIG_ENABLE | PL080_CONFIG_ERR_IRQ_MASK |
286                  PL080_CONFIG_TC_IRQ_MASK);
287
288         writel(val, ch->base + PL080_CH_CONFIG);
289
290         writel(1 << ch->id, pl08x->base + PL080_ERR_CLEAR);
291         writel(1 << ch->id, pl08x->base + PL080_TC_CLEAR);
292 }
293
294 static inline u32 get_bytes_in_cctl(u32 cctl)
295 {
296         /* The source width defines the number of bytes */
297         u32 bytes = cctl & PL080_CONTROL_TRANSFER_SIZE_MASK;
298
299         switch (cctl >> PL080_CONTROL_SWIDTH_SHIFT) {
300         case PL080_WIDTH_8BIT:
301                 break;
302         case PL080_WIDTH_16BIT:
303                 bytes *= 2;
304                 break;
305         case PL080_WIDTH_32BIT:
306                 bytes *= 4;
307                 break;
308         }
309         return bytes;
310 }
311
312 /* The channel should be paused when calling this */
313 static u32 pl08x_getbytes_chan(struct pl08x_dma_chan *plchan)
314 {
315         struct pl08x_phy_chan *ch;
316         struct pl08x_txd *txd;
317         unsigned long flags;
318         size_t bytes = 0;
319
320         spin_lock_irqsave(&plchan->lock, flags);
321         ch = plchan->phychan;
322         txd = plchan->at;
323
324         /*
325          * Follow the LLIs to get the number of remaining
326          * bytes in the currently active transaction.
327          */
328         if (ch && txd) {
329                 u32 clli = readl(ch->base + PL080_CH_LLI) & ~PL080_LLI_LM_AHB2;
330
331                 /* First get the remaining bytes in the active transfer */
332                 bytes = get_bytes_in_cctl(readl(ch->base + PL080_CH_CONTROL));
333
334                 if (clli) {
335                         struct pl08x_lli *llis_va = txd->llis_va;
336                         dma_addr_t llis_bus = txd->llis_bus;
337                         int index;
338
339                         BUG_ON(clli < llis_bus || clli >= llis_bus +
340                                 sizeof(struct pl08x_lli) * MAX_NUM_TSFR_LLIS);
341
342                         /*
343                          * Locate the next LLI - as this is an array,
344                          * it's simple maths to find.
345                          */
346                         index = (clli - llis_bus) / sizeof(struct pl08x_lli);
347
348                         for (; index < MAX_NUM_TSFR_LLIS; index++) {
349                                 bytes += get_bytes_in_cctl(llis_va[index].cctl);
350
351                                 /*
352                                  * A LLI pointer of 0 terminates the LLI list
353                                  */
354                                 if (!llis_va[index].lli)
355                                         break;
356                         }
357                 }
358         }
359
360         /* Sum up all queued transactions */
361         if (!list_empty(&plchan->pend_list)) {
362                 struct pl08x_txd *txdi;
363                 list_for_each_entry(txdi, &plchan->pend_list, node) {
364                         bytes += txdi->len;
365                 }
366         }
367
368         spin_unlock_irqrestore(&plchan->lock, flags);
369
370         return bytes;
371 }
372
373 /*
374  * Allocate a physical channel for a virtual channel
375  *
376  * Try to locate a physical channel to be used for this transfer. If all
377  * are taken return NULL and the requester will have to cope by using
378  * some fallback PIO mode or retrying later.
379  */
380 static struct pl08x_phy_chan *
381 pl08x_get_phy_channel(struct pl08x_driver_data *pl08x,
382                       struct pl08x_dma_chan *virt_chan)
383 {
384         struct pl08x_phy_chan *ch = NULL;
385         unsigned long flags;
386         int i;
387
388         for (i = 0; i < pl08x->vd->channels; i++) {
389                 ch = &pl08x->phy_chans[i];
390
391                 spin_lock_irqsave(&ch->lock, flags);
392
393                 if (!ch->serving) {
394                         ch->serving = virt_chan;
395                         ch->signal = -1;
396                         spin_unlock_irqrestore(&ch->lock, flags);
397                         break;
398                 }
399
400                 spin_unlock_irqrestore(&ch->lock, flags);
401         }
402
403         if (i == pl08x->vd->channels) {
404                 /* No physical channel available, cope with it */
405                 return NULL;
406         }
407
408         return ch;
409 }
410
411 static inline void pl08x_put_phy_channel(struct pl08x_driver_data *pl08x,
412                                          struct pl08x_phy_chan *ch)
413 {
414         unsigned long flags;
415
416         spin_lock_irqsave(&ch->lock, flags);
417
418         /* Stop the channel and clear its interrupts */
419         pl08x_terminate_phy_chan(pl08x, ch);
420
421         /* Mark it as free */
422         ch->serving = NULL;
423         spin_unlock_irqrestore(&ch->lock, flags);
424 }
425
426 /*
427  * LLI handling
428  */
429
430 static inline unsigned int pl08x_get_bytes_for_cctl(unsigned int coded)
431 {
432         switch (coded) {
433         case PL080_WIDTH_8BIT:
434                 return 1;
435         case PL080_WIDTH_16BIT:
436                 return 2;
437         case PL080_WIDTH_32BIT:
438                 return 4;
439         default:
440                 break;
441         }
442         BUG();
443         return 0;
444 }
445
446 static inline u32 pl08x_cctl_bits(u32 cctl, u8 srcwidth, u8 dstwidth,
447                                   size_t tsize)
448 {
449         u32 retbits = cctl;
450
451         /* Remove all src, dst and transfer size bits */
452         retbits &= ~PL080_CONTROL_DWIDTH_MASK;
453         retbits &= ~PL080_CONTROL_SWIDTH_MASK;
454         retbits &= ~PL080_CONTROL_TRANSFER_SIZE_MASK;
455
456         /* Then set the bits according to the parameters */
457         switch (srcwidth) {
458         case 1:
459                 retbits |= PL080_WIDTH_8BIT << PL080_CONTROL_SWIDTH_SHIFT;
460                 break;
461         case 2:
462                 retbits |= PL080_WIDTH_16BIT << PL080_CONTROL_SWIDTH_SHIFT;
463                 break;
464         case 4:
465                 retbits |= PL080_WIDTH_32BIT << PL080_CONTROL_SWIDTH_SHIFT;
466                 break;
467         default:
468                 BUG();
469                 break;
470         }
471
472         switch (dstwidth) {
473         case 1:
474                 retbits |= PL080_WIDTH_8BIT << PL080_CONTROL_DWIDTH_SHIFT;
475                 break;
476         case 2:
477                 retbits |= PL080_WIDTH_16BIT << PL080_CONTROL_DWIDTH_SHIFT;
478                 break;
479         case 4:
480                 retbits |= PL080_WIDTH_32BIT << PL080_CONTROL_DWIDTH_SHIFT;
481                 break;
482         default:
483                 BUG();
484                 break;
485         }
486
487         retbits |= tsize << PL080_CONTROL_TRANSFER_SIZE_SHIFT;
488         return retbits;
489 }
490
491 struct pl08x_lli_build_data {
492         struct pl08x_txd *txd;
493         struct pl08x_bus_data srcbus;
494         struct pl08x_bus_data dstbus;
495         size_t remainder;
496         u32 lli_bus;
497 };
498
499 /*
500  * Autoselect a master bus to use for the transfer. Slave will be the chosen as
501  * victim in case src & dest are not similarly aligned. i.e. If after aligning
502  * masters address with width requirements of transfer (by sending few byte by
503  * byte data), slave is still not aligned, then its width will be reduced to
504  * BYTE.
505  * - prefers the destination bus if both available
506  * - if fixed address on one bus the other will be chosen
507  */
508 static void pl08x_choose_master_bus(struct pl08x_lli_build_data *bd,
509         struct pl08x_bus_data **mbus, struct pl08x_bus_data **sbus, u32 cctl)
510 {
511         if (!(cctl & PL080_CONTROL_DST_INCR)) {
512                 *mbus = &bd->srcbus;
513                 *sbus = &bd->dstbus;
514         } else if (!(cctl & PL080_CONTROL_SRC_INCR)) {
515                 *mbus = &bd->dstbus;
516                 *sbus = &bd->srcbus;
517         } else {
518                 if (bd->dstbus.buswidth == 4) {
519                         *mbus = &bd->dstbus;
520                         *sbus = &bd->srcbus;
521                 } else if (bd->srcbus.buswidth == 4) {
522                         *mbus = &bd->srcbus;
523                         *sbus = &bd->dstbus;
524                 } else if (bd->dstbus.buswidth == 2) {
525                         *mbus = &bd->dstbus;
526                         *sbus = &bd->srcbus;
527                 } else if (bd->srcbus.buswidth == 2) {
528                         *mbus = &bd->srcbus;
529                         *sbus = &bd->dstbus;
530                 } else {
531                         /* bd->srcbus.buswidth == 1 */
532                         *mbus = &bd->dstbus;
533                         *sbus = &bd->srcbus;
534                 }
535         }
536 }
537
538 /*
539  * Fills in one LLI for a certain transfer descriptor and advance the counter
540  */
541 static void pl08x_fill_lli_for_desc(struct pl08x_lli_build_data *bd,
542         int num_llis, int len, u32 cctl)
543 {
544         struct pl08x_lli *llis_va = bd->txd->llis_va;
545         dma_addr_t llis_bus = bd->txd->llis_bus;
546
547         BUG_ON(num_llis >= MAX_NUM_TSFR_LLIS);
548
549         llis_va[num_llis].cctl = cctl;
550         llis_va[num_llis].src = bd->srcbus.addr;
551         llis_va[num_llis].dst = bd->dstbus.addr;
552         llis_va[num_llis].lli = llis_bus + (num_llis + 1) *
553                 sizeof(struct pl08x_lli);
554         llis_va[num_llis].lli |= bd->lli_bus;
555
556         if (cctl & PL080_CONTROL_SRC_INCR)
557                 bd->srcbus.addr += len;
558         if (cctl & PL080_CONTROL_DST_INCR)
559                 bd->dstbus.addr += len;
560
561         BUG_ON(bd->remainder < len);
562
563         bd->remainder -= len;
564 }
565
566 /*
567  * Return number of bytes to fill to boundary, or len.
568  * This calculation works for any value of addr.
569  */
570 static inline size_t pl08x_pre_boundary(u32 addr, size_t len)
571 {
572         size_t boundary_len = PL08X_BOUNDARY_SIZE -
573                         (addr & (PL08X_BOUNDARY_SIZE - 1));
574
575         return min(boundary_len, len);
576 }
577
578 /*
579  * This fills in the table of LLIs for the transfer descriptor
580  * Note that we assume we never have to change the burst sizes
581  * Return 0 for error
582  */
583 static int pl08x_fill_llis_for_desc(struct pl08x_driver_data *pl08x,
584                               struct pl08x_txd *txd)
585 {
586         struct pl08x_bus_data *mbus, *sbus;
587         struct pl08x_lli_build_data bd;
588         int num_llis = 0;
589         u32 cctl;
590         size_t max_bytes_per_lli, total_bytes = 0;
591         struct pl08x_lli *llis_va;
592
593         txd->llis_va = dma_pool_alloc(pl08x->pool, GFP_NOWAIT, &txd->llis_bus);
594         if (!txd->llis_va) {
595                 dev_err(&pl08x->adev->dev, "%s no memory for llis\n", __func__);
596                 return 0;
597         }
598
599         pl08x->pool_ctr++;
600
601         /* Get the default CCTL */
602         cctl = txd->cctl;
603
604         bd.txd = txd;
605         bd.srcbus.addr = txd->src_addr;
606         bd.dstbus.addr = txd->dst_addr;
607         bd.lli_bus = (pl08x->lli_buses & PL08X_AHB2) ? PL080_LLI_LM_AHB2 : 0;
608
609         /* Find maximum width of the source bus */
610         bd.srcbus.maxwidth =
611                 pl08x_get_bytes_for_cctl((cctl & PL080_CONTROL_SWIDTH_MASK) >>
612                                        PL080_CONTROL_SWIDTH_SHIFT);
613
614         /* Find maximum width of the destination bus */
615         bd.dstbus.maxwidth =
616                 pl08x_get_bytes_for_cctl((cctl & PL080_CONTROL_DWIDTH_MASK) >>
617                                        PL080_CONTROL_DWIDTH_SHIFT);
618
619         /* Set up the bus widths to the maximum */
620         bd.srcbus.buswidth = bd.srcbus.maxwidth;
621         bd.dstbus.buswidth = bd.dstbus.maxwidth;
622
623         /*
624          * Bytes transferred == tsize * MIN(buswidths), not max(buswidths)
625          */
626         max_bytes_per_lli = min(bd.srcbus.buswidth, bd.dstbus.buswidth) *
627                 PL080_CONTROL_TRANSFER_SIZE_MASK;
628
629         /* We need to count this down to zero */
630         bd.remainder = txd->len;
631
632         pl08x_choose_master_bus(&bd, &mbus, &sbus, cctl);
633
634         dev_vdbg(&pl08x->adev->dev, "src=0x%08x%s/%u dst=0x%08x%s/%u len=%zu llimax=%zu\n",
635                  bd.srcbus.addr, cctl & PL080_CONTROL_SRC_INCR ? "+" : "",
636                  bd.srcbus.buswidth,
637                  bd.dstbus.addr, cctl & PL080_CONTROL_DST_INCR ? "+" : "",
638                  bd.dstbus.buswidth,
639                  bd.remainder, max_bytes_per_lli);
640         dev_vdbg(&pl08x->adev->dev, "mbus=%s sbus=%s\n",
641                  mbus == &bd.srcbus ? "src" : "dst",
642                  sbus == &bd.srcbus ? "src" : "dst");
643
644         if (txd->len < mbus->buswidth) {
645                 /* Less than a bus width available - send as single bytes */
646                 while (bd.remainder) {
647                         dev_vdbg(&pl08x->adev->dev,
648                                  "%s single byte LLIs for a transfer of "
649                                  "less than a bus width (remain 0x%08x)\n",
650                                  __func__, bd.remainder);
651                         cctl = pl08x_cctl_bits(cctl, 1, 1, 1);
652                         pl08x_fill_lli_for_desc(&bd, num_llis++, 1, cctl);
653                         total_bytes++;
654                 }
655         } else {
656                 /* Make one byte LLIs until master bus is aligned */
657                 while ((mbus->addr) % (mbus->buswidth)) {
658                         dev_vdbg(&pl08x->adev->dev,
659                                 "%s adjustment lli for less than bus width "
660                                  "(remain 0x%08x)\n",
661                                  __func__, bd.remainder);
662                         cctl = pl08x_cctl_bits(cctl, 1, 1, 1);
663                         pl08x_fill_lli_for_desc(&bd, num_llis++, 1, cctl);
664                         total_bytes++;
665                 }
666
667                 /*
668                  * Master now aligned
669                  * - if slave is not then we must set its width down
670                  */
671                 if (sbus->addr % sbus->buswidth) {
672                         dev_dbg(&pl08x->adev->dev,
673                                 "%s set down bus width to one byte\n",
674                                  __func__);
675
676                         sbus->buswidth = 1;
677                 }
678
679                 /*
680                  * Make largest possible LLIs until less than one bus
681                  * width left
682                  */
683                 while (bd.remainder > (mbus->buswidth - 1)) {
684                         size_t lli_len, target_len, tsize, odd_bytes;
685
686                         /*
687                          * If enough left try to send max possible,
688                          * otherwise try to send the remainder
689                          */
690                         target_len = min(bd.remainder, max_bytes_per_lli);
691
692                         /*
693                          * Set bus lengths for incrementing buses to the
694                          * number of bytes which fill to next memory boundary,
695                          * limiting on the target length calculated above.
696                          */
697                         if (cctl & PL080_CONTROL_SRC_INCR)
698                                 bd.srcbus.fill_bytes =
699                                         pl08x_pre_boundary(bd.srcbus.addr,
700                                                 target_len);
701                         else
702                                 bd.srcbus.fill_bytes = target_len;
703
704                         if (cctl & PL080_CONTROL_DST_INCR)
705                                 bd.dstbus.fill_bytes =
706                                         pl08x_pre_boundary(bd.dstbus.addr,
707                                                 target_len);
708                         else
709                                 bd.dstbus.fill_bytes = target_len;
710
711                         /* Find the nearest */
712                         lli_len = min(bd.srcbus.fill_bytes,
713                                       bd.dstbus.fill_bytes);
714
715                         BUG_ON(lli_len > bd.remainder);
716
717                         if (lli_len <= 0) {
718                                 dev_err(&pl08x->adev->dev,
719                                         "%s lli_len is %zu, <= 0\n",
720                                                 __func__, lli_len);
721                                 return 0;
722                         }
723
724                         if (lli_len == target_len) {
725                                 /*
726                                  * Can send what we wanted.
727                                  * Maintain alignment
728                                  */
729                                 lli_len = (lli_len/mbus->buswidth) *
730                                                         mbus->buswidth;
731                                 odd_bytes = 0;
732                         } else {
733                                 /*
734                                  * So now we know how many bytes to transfer
735                                  * to get to the nearest boundary.  The next
736                                  * LLI will past the boundary.  However, we
737                                  * may be working to a boundary on the slave
738                                  * bus.  We need to ensure the master stays
739                                  * aligned, and that we are working in
740                                  * multiples of the bus widths.
741                                  */
742                                 odd_bytes = lli_len % mbus->buswidth;
743                                 lli_len -= odd_bytes;
744
745                         }
746
747                         if (lli_len) {
748                                 /*
749                                  * Check against minimum bus alignment:
750                                  * Calculate actual transfer size in relation
751                                  * to bus width an get a maximum remainder of
752                                  * the smallest bus width - 1
753                                  */
754                                 /* FIXME: use round_down()? */
755                                 tsize = lli_len / min(mbus->buswidth,
756                                                       sbus->buswidth);
757                                 lli_len = tsize * min(mbus->buswidth,
758                                                       sbus->buswidth);
759
760                                 if (target_len != lli_len) {
761                                         dev_vdbg(&pl08x->adev->dev,
762                                         "%s can't send what we want. Desired 0x%08zx, lli of 0x%08zx bytes in txd of 0x%08zx\n",
763                                         __func__, target_len, lli_len, txd->len);
764                                 }
765
766                                 cctl = pl08x_cctl_bits(cctl,
767                                                        bd.srcbus.buswidth,
768                                                        bd.dstbus.buswidth,
769                                                        tsize);
770
771                                 dev_vdbg(&pl08x->adev->dev,
772                                         "%s fill lli with single lli chunk of size 0x%08zx (remainder 0x%08zx)\n",
773                                         __func__, lli_len, bd.remainder);
774                                 pl08x_fill_lli_for_desc(&bd, num_llis++,
775                                         lli_len, cctl);
776                                 total_bytes += lli_len;
777                         }
778
779                         if (odd_bytes) {
780                                 /*
781                                  * Creep past the boundary, maintaining
782                                  * master alignment
783                                  */
784                                 int j;
785                                 for (j = 0; (j < mbus->buswidth)
786                                                 && (bd.remainder); j++) {
787                                         cctl = pl08x_cctl_bits(cctl, 1, 1, 1);
788                                         dev_vdbg(&pl08x->adev->dev,
789                                                 "%s align with boundary, single byte (remain 0x%08zx)\n",
790                                                 __func__, bd.remainder);
791                                         pl08x_fill_lli_for_desc(&bd,
792                                                 num_llis++, 1, cctl);
793                                         total_bytes++;
794                                 }
795                         }
796                 }
797
798                 /*
799                  * Send any odd bytes
800                  */
801                 while (bd.remainder) {
802                         cctl = pl08x_cctl_bits(cctl, 1, 1, 1);
803                         dev_vdbg(&pl08x->adev->dev,
804                                 "%s align with boundary, single odd byte (remain %zu)\n",
805                                 __func__, bd.remainder);
806                         pl08x_fill_lli_for_desc(&bd, num_llis++, 1, cctl);
807                         total_bytes++;
808                 }
809         }
810         if (total_bytes != txd->len) {
811                 dev_err(&pl08x->adev->dev,
812                         "%s size of encoded lli:s don't match total txd, transferred 0x%08zx from size 0x%08zx\n",
813                         __func__, total_bytes, txd->len);
814                 return 0;
815         }
816
817         if (num_llis >= MAX_NUM_TSFR_LLIS) {
818                 dev_err(&pl08x->adev->dev,
819                         "%s need to increase MAX_NUM_TSFR_LLIS from 0x%08x\n",
820                         __func__, (u32) MAX_NUM_TSFR_LLIS);
821                 return 0;
822         }
823
824         llis_va = txd->llis_va;
825         /* The final LLI terminates the LLI. */
826         llis_va[num_llis - 1].lli = 0;
827         /* The final LLI element shall also fire an interrupt. */
828         llis_va[num_llis - 1].cctl |= PL080_CONTROL_TC_IRQ_EN;
829
830 #ifdef VERBOSE_DEBUG
831         {
832                 int i;
833
834                 dev_vdbg(&pl08x->adev->dev,
835                          "%-3s %-9s  %-10s %-10s %-10s %s\n",
836                          "lli", "", "csrc", "cdst", "clli", "cctl");
837                 for (i = 0; i < num_llis; i++) {
838                         dev_vdbg(&pl08x->adev->dev,
839                                  "%3d @%p: 0x%08x 0x%08x 0x%08x 0x%08x\n",
840                                  i, &llis_va[i], llis_va[i].src,
841                                  llis_va[i].dst, llis_va[i].lli, llis_va[i].cctl
842                                 );
843                 }
844         }
845 #endif
846
847         return num_llis;
848 }
849
850 /* You should call this with the struct pl08x lock held */
851 static void pl08x_free_txd(struct pl08x_driver_data *pl08x,
852                            struct pl08x_txd *txd)
853 {
854         /* Free the LLI */
855         dma_pool_free(pl08x->pool, txd->llis_va, txd->llis_bus);
856
857         pl08x->pool_ctr--;
858
859         kfree(txd);
860 }
861
862 static void pl08x_free_txd_list(struct pl08x_driver_data *pl08x,
863                                 struct pl08x_dma_chan *plchan)
864 {
865         struct pl08x_txd *txdi = NULL;
866         struct pl08x_txd *next;
867
868         if (!list_empty(&plchan->pend_list)) {
869                 list_for_each_entry_safe(txdi,
870                                          next, &plchan->pend_list, node) {
871                         list_del(&txdi->node);
872                         pl08x_free_txd(pl08x, txdi);
873                 }
874         }
875 }
876
877 /*
878  * The DMA ENGINE API
879  */
880 static int pl08x_alloc_chan_resources(struct dma_chan *chan)
881 {
882         return 0;
883 }
884
885 static void pl08x_free_chan_resources(struct dma_chan *chan)
886 {
887 }
888
889 /*
890  * This should be called with the channel plchan->lock held
891  */
892 static int prep_phy_channel(struct pl08x_dma_chan *plchan,
893                             struct pl08x_txd *txd)
894 {
895         struct pl08x_driver_data *pl08x = plchan->host;
896         struct pl08x_phy_chan *ch;
897         int ret;
898
899         /* Check if we already have a channel */
900         if (plchan->phychan)
901                 return 0;
902
903         ch = pl08x_get_phy_channel(pl08x, plchan);
904         if (!ch) {
905                 /* No physical channel available, cope with it */
906                 dev_dbg(&pl08x->adev->dev, "no physical channel available for xfer on %s\n", plchan->name);
907                 return -EBUSY;
908         }
909
910         /*
911          * OK we have a physical channel: for memcpy() this is all we
912          * need, but for slaves the physical signals may be muxed!
913          * Can the platform allow us to use this channel?
914          */
915         if (plchan->slave && ch->signal < 0 && pl08x->pd->get_signal) {
916                 ret = pl08x->pd->get_signal(plchan);
917                 if (ret < 0) {
918                         dev_dbg(&pl08x->adev->dev,
919                                 "unable to use physical channel %d for transfer on %s due to platform restrictions\n",
920                                 ch->id, plchan->name);
921                         /* Release physical channel & return */
922                         pl08x_put_phy_channel(pl08x, ch);
923                         return -EBUSY;
924                 }
925                 ch->signal = ret;
926
927                 /* Assign the flow control signal to this channel */
928                 if (txd->direction == DMA_TO_DEVICE)
929                         txd->ccfg |= ch->signal << PL080_CONFIG_DST_SEL_SHIFT;
930                 else if (txd->direction == DMA_FROM_DEVICE)
931                         txd->ccfg |= ch->signal << PL080_CONFIG_SRC_SEL_SHIFT;
932         }
933
934         dev_dbg(&pl08x->adev->dev, "allocated physical channel %d and signal %d for xfer on %s\n",
935                  ch->id,
936                  ch->signal,
937                  plchan->name);
938
939         plchan->phychan_hold++;
940         plchan->phychan = ch;
941
942         return 0;
943 }
944
945 static void release_phy_channel(struct pl08x_dma_chan *plchan)
946 {
947         struct pl08x_driver_data *pl08x = plchan->host;
948
949         if ((plchan->phychan->signal >= 0) && pl08x->pd->put_signal) {
950                 pl08x->pd->put_signal(plchan);
951                 plchan->phychan->signal = -1;
952         }
953         pl08x_put_phy_channel(pl08x, plchan->phychan);
954         plchan->phychan = NULL;
955 }
956
957 static dma_cookie_t pl08x_tx_submit(struct dma_async_tx_descriptor *tx)
958 {
959         struct pl08x_dma_chan *plchan = to_pl08x_chan(tx->chan);
960         struct pl08x_txd *txd = to_pl08x_txd(tx);
961         unsigned long flags;
962
963         spin_lock_irqsave(&plchan->lock, flags);
964
965         plchan->chan.cookie += 1;
966         if (plchan->chan.cookie < 0)
967                 plchan->chan.cookie = 1;
968         tx->cookie = plchan->chan.cookie;
969
970         /* Put this onto the pending list */
971         list_add_tail(&txd->node, &plchan->pend_list);
972
973         /*
974          * If there was no physical channel available for this memcpy,
975          * stack the request up and indicate that the channel is waiting
976          * for a free physical channel.
977          */
978         if (!plchan->slave && !plchan->phychan) {
979                 /* Do this memcpy whenever there is a channel ready */
980                 plchan->state = PL08X_CHAN_WAITING;
981                 plchan->waiting = txd;
982         } else {
983                 plchan->phychan_hold--;
984         }
985
986         spin_unlock_irqrestore(&plchan->lock, flags);
987
988         return tx->cookie;
989 }
990
991 static struct dma_async_tx_descriptor *pl08x_prep_dma_interrupt(
992                 struct dma_chan *chan, unsigned long flags)
993 {
994         struct dma_async_tx_descriptor *retval = NULL;
995
996         return retval;
997 }
998
999 /*
1000  * Code accessing dma_async_is_complete() in a tight loop may give problems.
1001  * If slaves are relying on interrupts to signal completion this function
1002  * must not be called with interrupts disabled.
1003  */
1004 static enum dma_status pl08x_dma_tx_status(struct dma_chan *chan,
1005                 dma_cookie_t cookie, struct dma_tx_state *txstate)
1006 {
1007         struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
1008         dma_cookie_t last_used;
1009         dma_cookie_t last_complete;
1010         enum dma_status ret;
1011         u32 bytesleft = 0;
1012
1013         last_used = plchan->chan.cookie;
1014         last_complete = plchan->lc;
1015
1016         ret = dma_async_is_complete(cookie, last_complete, last_used);
1017         if (ret == DMA_SUCCESS) {
1018                 dma_set_tx_state(txstate, last_complete, last_used, 0);
1019                 return ret;
1020         }
1021
1022         /*
1023          * This cookie not complete yet
1024          */
1025         last_used = plchan->chan.cookie;
1026         last_complete = plchan->lc;
1027
1028         /* Get number of bytes left in the active transactions and queue */
1029         bytesleft = pl08x_getbytes_chan(plchan);
1030
1031         dma_set_tx_state(txstate, last_complete, last_used,
1032                          bytesleft);
1033
1034         if (plchan->state == PL08X_CHAN_PAUSED)
1035                 return DMA_PAUSED;
1036
1037         /* Whether waiting or running, we're in progress */
1038         return DMA_IN_PROGRESS;
1039 }
1040
1041 /* PrimeCell DMA extension */
1042 struct burst_table {
1043         u32 burstwords;
1044         u32 reg;
1045 };
1046
1047 static const struct burst_table burst_sizes[] = {
1048         {
1049                 .burstwords = 256,
1050                 .reg = PL080_BSIZE_256,
1051         },
1052         {
1053                 .burstwords = 128,
1054                 .reg = PL080_BSIZE_128,
1055         },
1056         {
1057                 .burstwords = 64,
1058                 .reg = PL080_BSIZE_64,
1059         },
1060         {
1061                 .burstwords = 32,
1062                 .reg = PL080_BSIZE_32,
1063         },
1064         {
1065                 .burstwords = 16,
1066                 .reg = PL080_BSIZE_16,
1067         },
1068         {
1069                 .burstwords = 8,
1070                 .reg = PL080_BSIZE_8,
1071         },
1072         {
1073                 .burstwords = 4,
1074                 .reg = PL080_BSIZE_4,
1075         },
1076         {
1077                 .burstwords = 0,
1078                 .reg = PL080_BSIZE_1,
1079         },
1080 };
1081
1082 /*
1083  * Given the source and destination available bus masks, select which
1084  * will be routed to each port.  We try to have source and destination
1085  * on separate ports, but always respect the allowable settings.
1086  */
1087 static u32 pl08x_select_bus(u8 src, u8 dst)
1088 {
1089         u32 cctl = 0;
1090
1091         if (!(dst & PL08X_AHB1) || ((dst & PL08X_AHB2) && (src & PL08X_AHB1)))
1092                 cctl |= PL080_CONTROL_DST_AHB2;
1093         if (!(src & PL08X_AHB1) || ((src & PL08X_AHB2) && !(dst & PL08X_AHB2)))
1094                 cctl |= PL080_CONTROL_SRC_AHB2;
1095
1096         return cctl;
1097 }
1098
1099 static u32 pl08x_cctl(u32 cctl)
1100 {
1101         cctl &= ~(PL080_CONTROL_SRC_AHB2 | PL080_CONTROL_DST_AHB2 |
1102                   PL080_CONTROL_SRC_INCR | PL080_CONTROL_DST_INCR |
1103                   PL080_CONTROL_PROT_MASK);
1104
1105         /* Access the cell in privileged mode, non-bufferable, non-cacheable */
1106         return cctl | PL080_CONTROL_PROT_SYS;
1107 }
1108
1109 static u32 pl08x_width(enum dma_slave_buswidth width)
1110 {
1111         switch (width) {
1112         case DMA_SLAVE_BUSWIDTH_1_BYTE:
1113                 return PL080_WIDTH_8BIT;
1114         case DMA_SLAVE_BUSWIDTH_2_BYTES:
1115                 return PL080_WIDTH_16BIT;
1116         case DMA_SLAVE_BUSWIDTH_4_BYTES:
1117                 return PL080_WIDTH_32BIT;
1118         default:
1119                 return ~0;
1120         }
1121 }
1122
1123 static u32 pl08x_burst(u32 maxburst)
1124 {
1125         int i;
1126
1127         for (i = 0; i < ARRAY_SIZE(burst_sizes); i++)
1128                 if (burst_sizes[i].burstwords <= maxburst)
1129                         break;
1130
1131         return burst_sizes[i].reg;
1132 }
1133
1134 static int dma_set_runtime_config(struct dma_chan *chan,
1135                                   struct dma_slave_config *config)
1136 {
1137         struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
1138         struct pl08x_driver_data *pl08x = plchan->host;
1139         enum dma_slave_buswidth addr_width;
1140         u32 width, burst, maxburst;
1141         u32 cctl = 0;
1142
1143         if (!plchan->slave)
1144                 return -EINVAL;
1145
1146         /* Transfer direction */
1147         plchan->runtime_direction = config->direction;
1148         if (config->direction == DMA_TO_DEVICE) {
1149                 addr_width = config->dst_addr_width;
1150                 maxburst = config->dst_maxburst;
1151         } else if (config->direction == DMA_FROM_DEVICE) {
1152                 addr_width = config->src_addr_width;
1153                 maxburst = config->src_maxburst;
1154         } else {
1155                 dev_err(&pl08x->adev->dev,
1156                         "bad runtime_config: alien transfer direction\n");
1157                 return -EINVAL;
1158         }
1159
1160         width = pl08x_width(addr_width);
1161         if (width == ~0) {
1162                 dev_err(&pl08x->adev->dev,
1163                         "bad runtime_config: alien address width\n");
1164                 return -EINVAL;
1165         }
1166
1167         cctl |= width << PL080_CONTROL_SWIDTH_SHIFT;
1168         cctl |= width << PL080_CONTROL_DWIDTH_SHIFT;
1169
1170         /*
1171          * If this channel will only request single transfers, set this
1172          * down to ONE element.  Also select one element if no maxburst
1173          * is specified.
1174          */
1175         if (plchan->cd->single)
1176                 maxburst = 1;
1177
1178         burst = pl08x_burst(maxburst);
1179         cctl |= burst << PL080_CONTROL_SB_SIZE_SHIFT;
1180         cctl |= burst << PL080_CONTROL_DB_SIZE_SHIFT;
1181
1182         if (plchan->runtime_direction == DMA_FROM_DEVICE) {
1183                 plchan->src_addr = config->src_addr;
1184                 plchan->src_cctl = pl08x_cctl(cctl) | PL080_CONTROL_DST_INCR |
1185                         pl08x_select_bus(plchan->cd->periph_buses,
1186                                          pl08x->mem_buses);
1187         } else {
1188                 plchan->dst_addr = config->dst_addr;
1189                 plchan->dst_cctl = pl08x_cctl(cctl) | PL080_CONTROL_SRC_INCR |
1190                         pl08x_select_bus(pl08x->mem_buses,
1191                                          plchan->cd->periph_buses);
1192         }
1193
1194         dev_dbg(&pl08x->adev->dev,
1195                 "configured channel %s (%s) for %s, data width %d, "
1196                 "maxburst %d words, LE, CCTL=0x%08x\n",
1197                 dma_chan_name(chan), plchan->name,
1198                 (config->direction == DMA_FROM_DEVICE) ? "RX" : "TX",
1199                 addr_width,
1200                 maxburst,
1201                 cctl);
1202
1203         return 0;
1204 }
1205
1206 /*
1207  * Slave transactions callback to the slave device to allow
1208  * synchronization of slave DMA signals with the DMAC enable
1209  */
1210 static void pl08x_issue_pending(struct dma_chan *chan)
1211 {
1212         struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
1213         unsigned long flags;
1214
1215         spin_lock_irqsave(&plchan->lock, flags);
1216         /* Something is already active, or we're waiting for a channel... */
1217         if (plchan->at || plchan->state == PL08X_CHAN_WAITING) {
1218                 spin_unlock_irqrestore(&plchan->lock, flags);
1219                 return;
1220         }
1221
1222         /* Take the first element in the queue and execute it */
1223         if (!list_empty(&plchan->pend_list)) {
1224                 struct pl08x_txd *next;
1225
1226                 next = list_first_entry(&plchan->pend_list,
1227                                         struct pl08x_txd,
1228                                         node);
1229                 list_del(&next->node);
1230                 plchan->state = PL08X_CHAN_RUNNING;
1231
1232                 pl08x_start_txd(plchan, next);
1233         }
1234
1235         spin_unlock_irqrestore(&plchan->lock, flags);
1236 }
1237
1238 static int pl08x_prep_channel_resources(struct pl08x_dma_chan *plchan,
1239                                         struct pl08x_txd *txd)
1240 {
1241         struct pl08x_driver_data *pl08x = plchan->host;
1242         unsigned long flags;
1243         int num_llis, ret;
1244
1245         num_llis = pl08x_fill_llis_for_desc(pl08x, txd);
1246         if (!num_llis) {
1247                 kfree(txd);
1248                 return -EINVAL;
1249         }
1250
1251         spin_lock_irqsave(&plchan->lock, flags);
1252
1253         /*
1254          * See if we already have a physical channel allocated,
1255          * else this is the time to try to get one.
1256          */
1257         ret = prep_phy_channel(plchan, txd);
1258         if (ret) {
1259                 /*
1260                  * No physical channel was available.
1261                  *
1262                  * memcpy transfers can be sorted out at submission time.
1263                  *
1264                  * Slave transfers may have been denied due to platform
1265                  * channel muxing restrictions.  Since there is no guarantee
1266                  * that this will ever be resolved, and the signal must be
1267                  * acquired AFTER acquiring the physical channel, we will let
1268                  * them be NACK:ed with -EBUSY here. The drivers can retry
1269                  * the prep() call if they are eager on doing this using DMA.
1270                  */
1271                 if (plchan->slave) {
1272                         pl08x_free_txd_list(pl08x, plchan);
1273                         pl08x_free_txd(pl08x, txd);
1274                         spin_unlock_irqrestore(&plchan->lock, flags);
1275                         return -EBUSY;
1276                 }
1277         } else
1278                 /*
1279                  * Else we're all set, paused and ready to roll, status
1280                  * will switch to PL08X_CHAN_RUNNING when we call
1281                  * issue_pending(). If there is something running on the
1282                  * channel already we don't change its state.
1283                  */
1284                 if (plchan->state == PL08X_CHAN_IDLE)
1285                         plchan->state = PL08X_CHAN_PAUSED;
1286
1287         spin_unlock_irqrestore(&plchan->lock, flags);
1288
1289         return 0;
1290 }
1291
1292 static struct pl08x_txd *pl08x_get_txd(struct pl08x_dma_chan *plchan,
1293         unsigned long flags)
1294 {
1295         struct pl08x_txd *txd = kzalloc(sizeof(*txd), GFP_NOWAIT);
1296
1297         if (txd) {
1298                 dma_async_tx_descriptor_init(&txd->tx, &plchan->chan);
1299                 txd->tx.flags = flags;
1300                 txd->tx.tx_submit = pl08x_tx_submit;
1301                 INIT_LIST_HEAD(&txd->node);
1302
1303                 /* Always enable error and terminal interrupts */
1304                 txd->ccfg = PL080_CONFIG_ERR_IRQ_MASK |
1305                             PL080_CONFIG_TC_IRQ_MASK;
1306         }
1307         return txd;
1308 }
1309
1310 /*
1311  * Initialize a descriptor to be used by memcpy submit
1312  */
1313 static struct dma_async_tx_descriptor *pl08x_prep_dma_memcpy(
1314                 struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
1315                 size_t len, unsigned long flags)
1316 {
1317         struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
1318         struct pl08x_driver_data *pl08x = plchan->host;
1319         struct pl08x_txd *txd;
1320         int ret;
1321
1322         txd = pl08x_get_txd(plchan, flags);
1323         if (!txd) {
1324                 dev_err(&pl08x->adev->dev,
1325                         "%s no memory for descriptor\n", __func__);
1326                 return NULL;
1327         }
1328
1329         txd->direction = DMA_NONE;
1330         txd->src_addr = src;
1331         txd->dst_addr = dest;
1332         txd->len = len;
1333
1334         /* Set platform data for m2m */
1335         txd->ccfg |= PL080_FLOW_MEM2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT;
1336         txd->cctl = pl08x->pd->memcpy_channel.cctl &
1337                         ~(PL080_CONTROL_DST_AHB2 | PL080_CONTROL_SRC_AHB2);
1338
1339         /* Both to be incremented or the code will break */
1340         txd->cctl |= PL080_CONTROL_SRC_INCR | PL080_CONTROL_DST_INCR;
1341
1342         if (pl08x->vd->dualmaster)
1343                 txd->cctl |= pl08x_select_bus(pl08x->mem_buses,
1344                                               pl08x->mem_buses);
1345
1346         ret = pl08x_prep_channel_resources(plchan, txd);
1347         if (ret)
1348                 return NULL;
1349
1350         return &txd->tx;
1351 }
1352
1353 static struct dma_async_tx_descriptor *pl08x_prep_slave_sg(
1354                 struct dma_chan *chan, struct scatterlist *sgl,
1355                 unsigned int sg_len, enum dma_data_direction direction,
1356                 unsigned long flags)
1357 {
1358         struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
1359         struct pl08x_driver_data *pl08x = plchan->host;
1360         struct pl08x_txd *txd;
1361         int ret;
1362
1363         /*
1364          * Current implementation ASSUMES only one sg
1365          */
1366         if (sg_len != 1) {
1367                 dev_err(&pl08x->adev->dev, "%s prepared too long sglist\n",
1368                         __func__);
1369                 BUG();
1370         }
1371
1372         dev_dbg(&pl08x->adev->dev, "%s prepare transaction of %d bytes from %s\n",
1373                 __func__, sgl->length, plchan->name);
1374
1375         txd = pl08x_get_txd(plchan, flags);
1376         if (!txd) {
1377                 dev_err(&pl08x->adev->dev, "%s no txd\n", __func__);
1378                 return NULL;
1379         }
1380
1381         if (direction != plchan->runtime_direction)
1382                 dev_err(&pl08x->adev->dev, "%s DMA setup does not match "
1383                         "the direction configured for the PrimeCell\n",
1384                         __func__);
1385
1386         /*
1387          * Set up addresses, the PrimeCell configured address
1388          * will take precedence since this may configure the
1389          * channel target address dynamically at runtime.
1390          */
1391         txd->direction = direction;
1392         txd->len = sgl->length;
1393
1394         if (direction == DMA_TO_DEVICE) {
1395                 txd->ccfg |= PL080_FLOW_MEM2PER << PL080_CONFIG_FLOW_CONTROL_SHIFT;
1396                 txd->cctl = plchan->dst_cctl;
1397                 txd->src_addr = sgl->dma_address;
1398                 txd->dst_addr = plchan->dst_addr;
1399         } else if (direction == DMA_FROM_DEVICE) {
1400                 txd->ccfg |= PL080_FLOW_PER2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT;
1401                 txd->cctl = plchan->src_cctl;
1402                 txd->src_addr = plchan->src_addr;
1403                 txd->dst_addr = sgl->dma_address;
1404         } else {
1405                 dev_err(&pl08x->adev->dev,
1406                         "%s direction unsupported\n", __func__);
1407                 return NULL;
1408         }
1409
1410         ret = pl08x_prep_channel_resources(plchan, txd);
1411         if (ret)
1412                 return NULL;
1413
1414         return &txd->tx;
1415 }
1416
1417 static int pl08x_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
1418                          unsigned long arg)
1419 {
1420         struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
1421         struct pl08x_driver_data *pl08x = plchan->host;
1422         unsigned long flags;
1423         int ret = 0;
1424
1425         /* Controls applicable to inactive channels */
1426         if (cmd == DMA_SLAVE_CONFIG) {
1427                 return dma_set_runtime_config(chan,
1428                                               (struct dma_slave_config *)arg);
1429         }
1430
1431         /*
1432          * Anything succeeds on channels with no physical allocation and
1433          * no queued transfers.
1434          */
1435         spin_lock_irqsave(&plchan->lock, flags);
1436         if (!plchan->phychan && !plchan->at) {
1437                 spin_unlock_irqrestore(&plchan->lock, flags);
1438                 return 0;
1439         }
1440
1441         switch (cmd) {
1442         case DMA_TERMINATE_ALL:
1443                 plchan->state = PL08X_CHAN_IDLE;
1444
1445                 if (plchan->phychan) {
1446                         pl08x_terminate_phy_chan(pl08x, plchan->phychan);
1447
1448                         /*
1449                          * Mark physical channel as free and free any slave
1450                          * signal
1451                          */
1452                         release_phy_channel(plchan);
1453                 }
1454                 /* Dequeue jobs and free LLIs */
1455                 if (plchan->at) {
1456                         pl08x_free_txd(pl08x, plchan->at);
1457                         plchan->at = NULL;
1458                 }
1459                 /* Dequeue jobs not yet fired as well */
1460                 pl08x_free_txd_list(pl08x, plchan);
1461                 break;
1462         case DMA_PAUSE:
1463                 pl08x_pause_phy_chan(plchan->phychan);
1464                 plchan->state = PL08X_CHAN_PAUSED;
1465                 break;
1466         case DMA_RESUME:
1467                 pl08x_resume_phy_chan(plchan->phychan);
1468                 plchan->state = PL08X_CHAN_RUNNING;
1469                 break;
1470         default:
1471                 /* Unknown command */
1472                 ret = -ENXIO;
1473                 break;
1474         }
1475
1476         spin_unlock_irqrestore(&plchan->lock, flags);
1477
1478         return ret;
1479 }
1480
1481 bool pl08x_filter_id(struct dma_chan *chan, void *chan_id)
1482 {
1483         struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
1484         char *name = chan_id;
1485
1486         /* Check that the channel is not taken! */
1487         if (!strcmp(plchan->name, name))
1488                 return true;
1489
1490         return false;
1491 }
1492
1493 /*
1494  * Just check that the device is there and active
1495  * TODO: turn this bit on/off depending on the number of physical channels
1496  * actually used, if it is zero... well shut it off. That will save some
1497  * power. Cut the clock at the same time.
1498  */
1499 static void pl08x_ensure_on(struct pl08x_driver_data *pl08x)
1500 {
1501         u32 val;
1502
1503         val = readl(pl08x->base + PL080_CONFIG);
1504         val &= ~(PL080_CONFIG_M2_BE | PL080_CONFIG_M1_BE | PL080_CONFIG_ENABLE);
1505         /* We implicitly clear bit 1 and that means little-endian mode */
1506         val |= PL080_CONFIG_ENABLE;
1507         writel(val, pl08x->base + PL080_CONFIG);
1508 }
1509
1510 static void pl08x_unmap_buffers(struct pl08x_txd *txd)
1511 {
1512         struct device *dev = txd->tx.chan->device->dev;
1513
1514         if (!(txd->tx.flags & DMA_COMPL_SKIP_SRC_UNMAP)) {
1515                 if (txd->tx.flags & DMA_COMPL_SRC_UNMAP_SINGLE)
1516                         dma_unmap_single(dev, txd->src_addr, txd->len,
1517                                 DMA_TO_DEVICE);
1518                 else
1519                         dma_unmap_page(dev, txd->src_addr, txd->len,
1520                                 DMA_TO_DEVICE);
1521         }
1522         if (!(txd->tx.flags & DMA_COMPL_SKIP_DEST_UNMAP)) {
1523                 if (txd->tx.flags & DMA_COMPL_DEST_UNMAP_SINGLE)
1524                         dma_unmap_single(dev, txd->dst_addr, txd->len,
1525                                 DMA_FROM_DEVICE);
1526                 else
1527                         dma_unmap_page(dev, txd->dst_addr, txd->len,
1528                                 DMA_FROM_DEVICE);
1529         }
1530 }
1531
1532 static void pl08x_tasklet(unsigned long data)
1533 {
1534         struct pl08x_dma_chan *plchan = (struct pl08x_dma_chan *) data;
1535         struct pl08x_driver_data *pl08x = plchan->host;
1536         struct pl08x_txd *txd;
1537         unsigned long flags;
1538
1539         spin_lock_irqsave(&plchan->lock, flags);
1540
1541         txd = plchan->at;
1542         plchan->at = NULL;
1543
1544         if (txd) {
1545                 /* Update last completed */
1546                 plchan->lc = txd->tx.cookie;
1547         }
1548
1549         /* If a new descriptor is queued, set it up plchan->at is NULL here */
1550         if (!list_empty(&plchan->pend_list)) {
1551                 struct pl08x_txd *next;
1552
1553                 next = list_first_entry(&plchan->pend_list,
1554                                         struct pl08x_txd,
1555                                         node);
1556                 list_del(&next->node);
1557
1558                 pl08x_start_txd(plchan, next);
1559         } else if (plchan->phychan_hold) {
1560                 /*
1561                  * This channel is still in use - we have a new txd being
1562                  * prepared and will soon be queued.  Don't give up the
1563                  * physical channel.
1564                  */
1565         } else {
1566                 struct pl08x_dma_chan *waiting = NULL;
1567
1568                 /*
1569                  * No more jobs, so free up the physical channel
1570                  * Free any allocated signal on slave transfers too
1571                  */
1572                 release_phy_channel(plchan);
1573                 plchan->state = PL08X_CHAN_IDLE;
1574
1575                 /*
1576                  * And NOW before anyone else can grab that free:d up
1577                  * physical channel, see if there is some memcpy pending
1578                  * that seriously needs to start because of being stacked
1579                  * up while we were choking the physical channels with data.
1580                  */
1581                 list_for_each_entry(waiting, &pl08x->memcpy.channels,
1582                                     chan.device_node) {
1583                         if (waiting->state == PL08X_CHAN_WAITING &&
1584                                 waiting->waiting != NULL) {
1585                                 int ret;
1586
1587                                 /* This should REALLY not fail now */
1588                                 ret = prep_phy_channel(waiting,
1589                                                        waiting->waiting);
1590                                 BUG_ON(ret);
1591                                 waiting->phychan_hold--;
1592                                 waiting->state = PL08X_CHAN_RUNNING;
1593                                 waiting->waiting = NULL;
1594                                 pl08x_issue_pending(&waiting->chan);
1595                                 break;
1596                         }
1597                 }
1598         }
1599
1600         spin_unlock_irqrestore(&plchan->lock, flags);
1601
1602         if (txd) {
1603                 dma_async_tx_callback callback = txd->tx.callback;
1604                 void *callback_param = txd->tx.callback_param;
1605
1606                 /* Don't try to unmap buffers on slave channels */
1607                 if (!plchan->slave)
1608                         pl08x_unmap_buffers(txd);
1609
1610                 /* Free the descriptor */
1611                 spin_lock_irqsave(&plchan->lock, flags);
1612                 pl08x_free_txd(pl08x, txd);
1613                 spin_unlock_irqrestore(&plchan->lock, flags);
1614
1615                 /* Callback to signal completion */
1616                 if (callback)
1617                         callback(callback_param);
1618         }
1619 }
1620
1621 static irqreturn_t pl08x_irq(int irq, void *dev)
1622 {
1623         struct pl08x_driver_data *pl08x = dev;
1624         u32 mask = 0;
1625         u32 val;
1626         int i;
1627
1628         val = readl(pl08x->base + PL080_ERR_STATUS);
1629         if (val) {
1630                 /* An error interrupt (on one or more channels) */
1631                 dev_err(&pl08x->adev->dev,
1632                         "%s error interrupt, register value 0x%08x\n",
1633                                 __func__, val);
1634                 /*
1635                  * Simply clear ALL PL08X error interrupts,
1636                  * regardless of channel and cause
1637                  * FIXME: should be 0x00000003 on PL081 really.
1638                  */
1639                 writel(0x000000FF, pl08x->base + PL080_ERR_CLEAR);
1640         }
1641         val = readl(pl08x->base + PL080_INT_STATUS);
1642         for (i = 0; i < pl08x->vd->channels; i++) {
1643                 if ((1 << i) & val) {
1644                         /* Locate physical channel */
1645                         struct pl08x_phy_chan *phychan = &pl08x->phy_chans[i];
1646                         struct pl08x_dma_chan *plchan = phychan->serving;
1647
1648                         /* Schedule tasklet on this channel */
1649                         tasklet_schedule(&plchan->tasklet);
1650
1651                         mask |= (1 << i);
1652                 }
1653         }
1654         /* Clear only the terminal interrupts on channels we processed */
1655         writel(mask, pl08x->base + PL080_TC_CLEAR);
1656
1657         return mask ? IRQ_HANDLED : IRQ_NONE;
1658 }
1659
1660 static void pl08x_dma_slave_init(struct pl08x_dma_chan *chan)
1661 {
1662         u32 cctl = pl08x_cctl(chan->cd->cctl);
1663
1664         chan->slave = true;
1665         chan->name = chan->cd->bus_id;
1666         chan->src_addr = chan->cd->addr;
1667         chan->dst_addr = chan->cd->addr;
1668         chan->src_cctl = cctl | PL080_CONTROL_DST_INCR |
1669                 pl08x_select_bus(chan->cd->periph_buses, chan->host->mem_buses);
1670         chan->dst_cctl = cctl | PL080_CONTROL_SRC_INCR |
1671                 pl08x_select_bus(chan->host->mem_buses, chan->cd->periph_buses);
1672 }
1673
1674 /*
1675  * Initialise the DMAC memcpy/slave channels.
1676  * Make a local wrapper to hold required data
1677  */
1678 static int pl08x_dma_init_virtual_channels(struct pl08x_driver_data *pl08x,
1679                 struct dma_device *dmadev, unsigned int channels, bool slave)
1680 {
1681         struct pl08x_dma_chan *chan;
1682         int i;
1683
1684         INIT_LIST_HEAD(&dmadev->channels);
1685
1686         /*
1687          * Register as many many memcpy as we have physical channels,
1688          * we won't always be able to use all but the code will have
1689          * to cope with that situation.
1690          */
1691         for (i = 0; i < channels; i++) {
1692                 chan = kzalloc(sizeof(*chan), GFP_KERNEL);
1693                 if (!chan) {
1694                         dev_err(&pl08x->adev->dev,
1695                                 "%s no memory for channel\n", __func__);
1696                         return -ENOMEM;
1697                 }
1698
1699                 chan->host = pl08x;
1700                 chan->state = PL08X_CHAN_IDLE;
1701
1702                 if (slave) {
1703                         chan->cd = &pl08x->pd->slave_channels[i];
1704                         pl08x_dma_slave_init(chan);
1705                 } else {
1706                         chan->cd = &pl08x->pd->memcpy_channel;
1707                         chan->name = kasprintf(GFP_KERNEL, "memcpy%d", i);
1708                         if (!chan->name) {
1709                                 kfree(chan);
1710                                 return -ENOMEM;
1711                         }
1712                 }
1713                 if (chan->cd->circular_buffer) {
1714                         dev_err(&pl08x->adev->dev,
1715                                 "channel %s: circular buffers not supported\n",
1716                                 chan->name);
1717                         kfree(chan);
1718                         continue;
1719                 }
1720                 dev_info(&pl08x->adev->dev,
1721                          "initialize virtual channel \"%s\"\n",
1722                          chan->name);
1723
1724                 chan->chan.device = dmadev;
1725                 chan->chan.cookie = 0;
1726                 chan->lc = 0;
1727
1728                 spin_lock_init(&chan->lock);
1729                 INIT_LIST_HEAD(&chan->pend_list);
1730                 tasklet_init(&chan->tasklet, pl08x_tasklet,
1731                              (unsigned long) chan);
1732
1733                 list_add_tail(&chan->chan.device_node, &dmadev->channels);
1734         }
1735         dev_info(&pl08x->adev->dev, "initialized %d virtual %s channels\n",
1736                  i, slave ? "slave" : "memcpy");
1737         return i;
1738 }
1739
1740 static void pl08x_free_virtual_channels(struct dma_device *dmadev)
1741 {
1742         struct pl08x_dma_chan *chan = NULL;
1743         struct pl08x_dma_chan *next;
1744
1745         list_for_each_entry_safe(chan,
1746                                  next, &dmadev->channels, chan.device_node) {
1747                 list_del(&chan->chan.device_node);
1748                 kfree(chan);
1749         }
1750 }
1751
1752 #ifdef CONFIG_DEBUG_FS
1753 static const char *pl08x_state_str(enum pl08x_dma_chan_state state)
1754 {
1755         switch (state) {
1756         case PL08X_CHAN_IDLE:
1757                 return "idle";
1758         case PL08X_CHAN_RUNNING:
1759                 return "running";
1760         case PL08X_CHAN_PAUSED:
1761                 return "paused";
1762         case PL08X_CHAN_WAITING:
1763                 return "waiting";
1764         default:
1765                 break;
1766         }
1767         return "UNKNOWN STATE";
1768 }
1769
1770 static int pl08x_debugfs_show(struct seq_file *s, void *data)
1771 {
1772         struct pl08x_driver_data *pl08x = s->private;
1773         struct pl08x_dma_chan *chan;
1774         struct pl08x_phy_chan *ch;
1775         unsigned long flags;
1776         int i;
1777
1778         seq_printf(s, "PL08x physical channels:\n");
1779         seq_printf(s, "CHANNEL:\tUSER:\n");
1780         seq_printf(s, "--------\t-----\n");
1781         for (i = 0; i < pl08x->vd->channels; i++) {
1782                 struct pl08x_dma_chan *virt_chan;
1783
1784                 ch = &pl08x->phy_chans[i];
1785
1786                 spin_lock_irqsave(&ch->lock, flags);
1787                 virt_chan = ch->serving;
1788
1789                 seq_printf(s, "%d\t\t%s\n",
1790                            ch->id, virt_chan ? virt_chan->name : "(none)");
1791
1792                 spin_unlock_irqrestore(&ch->lock, flags);
1793         }
1794
1795         seq_printf(s, "\nPL08x virtual memcpy channels:\n");
1796         seq_printf(s, "CHANNEL:\tSTATE:\n");
1797         seq_printf(s, "--------\t------\n");
1798         list_for_each_entry(chan, &pl08x->memcpy.channels, chan.device_node) {
1799                 seq_printf(s, "%s\t\t%s\n", chan->name,
1800                            pl08x_state_str(chan->state));
1801         }
1802
1803         seq_printf(s, "\nPL08x virtual slave channels:\n");
1804         seq_printf(s, "CHANNEL:\tSTATE:\n");
1805         seq_printf(s, "--------\t------\n");
1806         list_for_each_entry(chan, &pl08x->slave.channels, chan.device_node) {
1807                 seq_printf(s, "%s\t\t%s\n", chan->name,
1808                            pl08x_state_str(chan->state));
1809         }
1810
1811         return 0;
1812 }
1813
1814 static int pl08x_debugfs_open(struct inode *inode, struct file *file)
1815 {
1816         return single_open(file, pl08x_debugfs_show, inode->i_private);
1817 }
1818
1819 static const struct file_operations pl08x_debugfs_operations = {
1820         .open           = pl08x_debugfs_open,
1821         .read           = seq_read,
1822         .llseek         = seq_lseek,
1823         .release        = single_release,
1824 };
1825
1826 static void init_pl08x_debugfs(struct pl08x_driver_data *pl08x)
1827 {
1828         /* Expose a simple debugfs interface to view all clocks */
1829         (void) debugfs_create_file(dev_name(&pl08x->adev->dev),
1830                         S_IFREG | S_IRUGO, NULL, pl08x,
1831                         &pl08x_debugfs_operations);
1832 }
1833
1834 #else
1835 static inline void init_pl08x_debugfs(struct pl08x_driver_data *pl08x)
1836 {
1837 }
1838 #endif
1839
1840 static int pl08x_probe(struct amba_device *adev, const struct amba_id *id)
1841 {
1842         struct pl08x_driver_data *pl08x;
1843         const struct vendor_data *vd = id->data;
1844         int ret = 0;
1845         int i;
1846
1847         ret = amba_request_regions(adev, NULL);
1848         if (ret)
1849                 return ret;
1850
1851         /* Create the driver state holder */
1852         pl08x = kzalloc(sizeof(*pl08x), GFP_KERNEL);
1853         if (!pl08x) {
1854                 ret = -ENOMEM;
1855                 goto out_no_pl08x;
1856         }
1857
1858         /* Initialize memcpy engine */
1859         dma_cap_set(DMA_MEMCPY, pl08x->memcpy.cap_mask);
1860         pl08x->memcpy.dev = &adev->dev;
1861         pl08x->memcpy.device_alloc_chan_resources = pl08x_alloc_chan_resources;
1862         pl08x->memcpy.device_free_chan_resources = pl08x_free_chan_resources;
1863         pl08x->memcpy.device_prep_dma_memcpy = pl08x_prep_dma_memcpy;
1864         pl08x->memcpy.device_prep_dma_interrupt = pl08x_prep_dma_interrupt;
1865         pl08x->memcpy.device_tx_status = pl08x_dma_tx_status;
1866         pl08x->memcpy.device_issue_pending = pl08x_issue_pending;
1867         pl08x->memcpy.device_control = pl08x_control;
1868
1869         /* Initialize slave engine */
1870         dma_cap_set(DMA_SLAVE, pl08x->slave.cap_mask);
1871         pl08x->slave.dev = &adev->dev;
1872         pl08x->slave.device_alloc_chan_resources = pl08x_alloc_chan_resources;
1873         pl08x->slave.device_free_chan_resources = pl08x_free_chan_resources;
1874         pl08x->slave.device_prep_dma_interrupt = pl08x_prep_dma_interrupt;
1875         pl08x->slave.device_tx_status = pl08x_dma_tx_status;
1876         pl08x->slave.device_issue_pending = pl08x_issue_pending;
1877         pl08x->slave.device_prep_slave_sg = pl08x_prep_slave_sg;
1878         pl08x->slave.device_control = pl08x_control;
1879
1880         /* Get the platform data */
1881         pl08x->pd = dev_get_platdata(&adev->dev);
1882         if (!pl08x->pd) {
1883                 dev_err(&adev->dev, "no platform data supplied\n");
1884                 goto out_no_platdata;
1885         }
1886
1887         /* Assign useful pointers to the driver state */
1888         pl08x->adev = adev;
1889         pl08x->vd = vd;
1890
1891         /* By default, AHB1 only.  If dualmaster, from platform */
1892         pl08x->lli_buses = PL08X_AHB1;
1893         pl08x->mem_buses = PL08X_AHB1;
1894         if (pl08x->vd->dualmaster) {
1895                 pl08x->lli_buses = pl08x->pd->lli_buses;
1896                 pl08x->mem_buses = pl08x->pd->mem_buses;
1897         }
1898
1899         /* A DMA memory pool for LLIs, align on 1-byte boundary */
1900         pl08x->pool = dma_pool_create(DRIVER_NAME, &pl08x->adev->dev,
1901                         PL08X_LLI_TSFR_SIZE, PL08X_ALIGN, 0);
1902         if (!pl08x->pool) {
1903                 ret = -ENOMEM;
1904                 goto out_no_lli_pool;
1905         }
1906
1907         spin_lock_init(&pl08x->lock);
1908
1909         pl08x->base = ioremap(adev->res.start, resource_size(&adev->res));
1910         if (!pl08x->base) {
1911                 ret = -ENOMEM;
1912                 goto out_no_ioremap;
1913         }
1914
1915         /* Turn on the PL08x */
1916         pl08x_ensure_on(pl08x);
1917
1918         /* Attach the interrupt handler */
1919         writel(0x000000FF, pl08x->base + PL080_ERR_CLEAR);
1920         writel(0x000000FF, pl08x->base + PL080_TC_CLEAR);
1921
1922         ret = request_irq(adev->irq[0], pl08x_irq, IRQF_DISABLED,
1923                           DRIVER_NAME, pl08x);
1924         if (ret) {
1925                 dev_err(&adev->dev, "%s failed to request interrupt %d\n",
1926                         __func__, adev->irq[0]);
1927                 goto out_no_irq;
1928         }
1929
1930         /* Initialize physical channels */
1931         pl08x->phy_chans = kmalloc((vd->channels * sizeof(*pl08x->phy_chans)),
1932                         GFP_KERNEL);
1933         if (!pl08x->phy_chans) {
1934                 dev_err(&adev->dev, "%s failed to allocate "
1935                         "physical channel holders\n",
1936                         __func__);
1937                 goto out_no_phychans;
1938         }
1939
1940         for (i = 0; i < vd->channels; i++) {
1941                 struct pl08x_phy_chan *ch = &pl08x->phy_chans[i];
1942
1943                 ch->id = i;
1944                 ch->base = pl08x->base + PL080_Cx_BASE(i);
1945                 spin_lock_init(&ch->lock);
1946                 ch->serving = NULL;
1947                 ch->signal = -1;
1948                 dev_info(&adev->dev,
1949                          "physical channel %d is %s\n", i,
1950                          pl08x_phy_channel_busy(ch) ? "BUSY" : "FREE");
1951         }
1952
1953         /* Register as many memcpy channels as there are physical channels */
1954         ret = pl08x_dma_init_virtual_channels(pl08x, &pl08x->memcpy,
1955                                               pl08x->vd->channels, false);
1956         if (ret <= 0) {
1957                 dev_warn(&pl08x->adev->dev,
1958                          "%s failed to enumerate memcpy channels - %d\n",
1959                          __func__, ret);
1960                 goto out_no_memcpy;
1961         }
1962         pl08x->memcpy.chancnt = ret;
1963
1964         /* Register slave channels */
1965         ret = pl08x_dma_init_virtual_channels(pl08x, &pl08x->slave,
1966                         pl08x->pd->num_slave_channels, true);
1967         if (ret <= 0) {
1968                 dev_warn(&pl08x->adev->dev,
1969                         "%s failed to enumerate slave channels - %d\n",
1970                                 __func__, ret);
1971                 goto out_no_slave;
1972         }
1973         pl08x->slave.chancnt = ret;
1974
1975         ret = dma_async_device_register(&pl08x->memcpy);
1976         if (ret) {
1977                 dev_warn(&pl08x->adev->dev,
1978                         "%s failed to register memcpy as an async device - %d\n",
1979                         __func__, ret);
1980                 goto out_no_memcpy_reg;
1981         }
1982
1983         ret = dma_async_device_register(&pl08x->slave);
1984         if (ret) {
1985                 dev_warn(&pl08x->adev->dev,
1986                         "%s failed to register slave as an async device - %d\n",
1987                         __func__, ret);
1988                 goto out_no_slave_reg;
1989         }
1990
1991         amba_set_drvdata(adev, pl08x);
1992         init_pl08x_debugfs(pl08x);
1993         dev_info(&pl08x->adev->dev, "DMA: PL%03x rev%u at 0x%08llx irq %d\n",
1994                  amba_part(adev), amba_rev(adev),
1995                  (unsigned long long)adev->res.start, adev->irq[0]);
1996         return 0;
1997
1998 out_no_slave_reg:
1999         dma_async_device_unregister(&pl08x->memcpy);
2000 out_no_memcpy_reg:
2001         pl08x_free_virtual_channels(&pl08x->slave);
2002 out_no_slave:
2003         pl08x_free_virtual_channels(&pl08x->memcpy);
2004 out_no_memcpy:
2005         kfree(pl08x->phy_chans);
2006 out_no_phychans:
2007         free_irq(adev->irq[0], pl08x);
2008 out_no_irq:
2009         iounmap(pl08x->base);
2010 out_no_ioremap:
2011         dma_pool_destroy(pl08x->pool);
2012 out_no_lli_pool:
2013 out_no_platdata:
2014         kfree(pl08x);
2015 out_no_pl08x:
2016         amba_release_regions(adev);
2017         return ret;
2018 }
2019
2020 /* PL080 has 8 channels and the PL080 have just 2 */
2021 static struct vendor_data vendor_pl080 = {
2022         .channels = 8,
2023         .dualmaster = true,
2024 };
2025
2026 static struct vendor_data vendor_pl081 = {
2027         .channels = 2,
2028         .dualmaster = false,
2029 };
2030
2031 static struct amba_id pl08x_ids[] = {
2032         /* PL080 */
2033         {
2034                 .id     = 0x00041080,
2035                 .mask   = 0x000fffff,
2036                 .data   = &vendor_pl080,
2037         },
2038         /* PL081 */
2039         {
2040                 .id     = 0x00041081,
2041                 .mask   = 0x000fffff,
2042                 .data   = &vendor_pl081,
2043         },
2044         /* Nomadik 8815 PL080 variant */
2045         {
2046                 .id     = 0x00280880,
2047                 .mask   = 0x00ffffff,
2048                 .data   = &vendor_pl080,
2049         },
2050         { 0, 0 },
2051 };
2052
2053 static struct amba_driver pl08x_amba_driver = {
2054         .drv.name       = DRIVER_NAME,
2055         .id_table       = pl08x_ids,
2056         .probe          = pl08x_probe,
2057 };
2058
2059 static int __init pl08x_init(void)
2060 {
2061         int retval;
2062         retval = amba_driver_register(&pl08x_amba_driver);
2063         if (retval)
2064                 printk(KERN_WARNING DRIVER_NAME
2065                        "failed to register as an AMBA device (%d)\n",
2066                        retval);
2067         return retval;
2068 }
2069 subsys_initcall(pl08x_init);