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