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