drivers/dma/mpc512x_dma.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) Freescale Semicondutor, Inc. 2007, 2008.
   4  * Copyright (C) Semihalf 2009
   5  * Copyright (C) Ilya Yanok, Emcraft Systems 2010
   6  * Copyright (C) Alexander Popov, Promcontroller 2014
   7  * Copyright (C) Mario Six, Guntermann & Drunck GmbH, 2016
   8  *
   9  * Written by Piotr Ziecik <kosmo@semihalf.com>. Hardware description
  10  * (defines, structures and comments) was taken from MPC5121 DMA driver
  11  * written by Hongjun Chen <hong-jun.chen@freescale.com>.
  12  *
  13  * Approved as OSADL project by a majority of OSADL members and funded
  14  * by OSADL membership fees in 2009;  for details see www.osadl.org.
  15  */
  16
  17 /*
  18  * MPC512x and MPC8308 DMA driver. It supports memory to memory data transfers
  19  * (tested using dmatest module) and data transfers between memory and
  20  * peripheral I/O memory by means of slave scatter/gather with these
  21  * limitations:
  22  *  - chunked transfers (described by s/g lists with more than one item) are
  23  *     refused as long as proper support for scatter/gather is missing
  24  *  - transfers on MPC8308 always start from software as this SoC does not have
  25  *     external request lines for peripheral flow control
  26  *  - memory <-> I/O memory transfer chunks of sizes of 1, 2, 4, 16 (for
  27  *     MPC512x), and 32 bytes are supported, and, consequently, source
  28  *     addresses and destination addresses must be aligned accordingly;
  29  *     furthermore, for MPC512x SoCs, the transfer size must be aligned on
  30  *     (chunk size * maxburst)
  31  */
  32
  33 #include <linux/module.h>
  34 #include <linux/dmaengine.h>
  35 #include <linux/dma-mapping.h>
  36 #include <linux/interrupt.h>
  37 #include <linux/io.h>
  38 #include <linux/slab.h>
  39 #include <linux/of.h>
  40 #include <linux/of_address.h>
  41 #include <linux/of_irq.h>
  42 #include <linux/of_dma.h>
  43 #include <linux/platform_device.h>
  44
  45 #include <linux/random.h>
  46
  47 #include "dmaengine.h"
  48
  49 /* Number of DMA Transfer descriptors allocated per channel */
  50 #define MPC_DMA_DESCRIPTORS     64
  51
  52 /* Macro definitions */
  53 #define MPC_DMA_TCD_OFFSET      0x1000
  54
  55 /*
  56  * Maximum channel counts for individual hardware variants
  57  * and the maximum channel count over all supported controllers,
  58  * used for data structure size
  59  */
  60 #define MPC8308_DMACHAN_MAX     16
  61 #define MPC512x_DMACHAN_MAX     64
  62 #define MPC_DMA_CHANNELS        64
  63
  64 /* Arbitration mode of group and channel */
  65 #define MPC_DMA_DMACR_EDCG      (1 << 31)
  66 #define MPC_DMA_DMACR_ERGA      (1 << 3)
  67 #define MPC_DMA_DMACR_ERCA      (1 << 2)
  68
  69 /* Error codes */
  70 #define MPC_DMA_DMAES_VLD       (1 << 31)
  71 #define MPC_DMA_DMAES_GPE       (1 << 15)
  72 #define MPC_DMA_DMAES_CPE       (1 << 14)
  73 #define MPC_DMA_DMAES_ERRCHN(err) \
  74                                 (((err) >> 8) & 0x3f)
  75 #define MPC_DMA_DMAES_SAE       (1 << 7)
  76 #define MPC_DMA_DMAES_SOE       (1 << 6)
  77 #define MPC_DMA_DMAES_DAE       (1 << 5)
  78 #define MPC_DMA_DMAES_DOE       (1 << 4)
  79 #define MPC_DMA_DMAES_NCE       (1 << 3)
  80 #define MPC_DMA_DMAES_SGE       (1 << 2)
  81 #define MPC_DMA_DMAES_SBE       (1 << 1)
  82 #define MPC_DMA_DMAES_DBE       (1 << 0)
  83
  84 #define MPC_DMA_DMAGPOR_SNOOP_ENABLE    (1 << 6)
  85
  86 #define MPC_DMA_TSIZE_1         0x00
  87 #define MPC_DMA_TSIZE_2         0x01
  88 #define MPC_DMA_TSIZE_4         0x02
  89 #define MPC_DMA_TSIZE_16        0x04
  90 #define MPC_DMA_TSIZE_32        0x05
  91
  92 /* MPC5121 DMA engine registers */
  93 struct __attribute__ ((__packed__)) mpc_dma_regs {
  94         /* 0x00 */
  95         u32 dmacr;              /* DMA control register */
  96         u32 dmaes;              /* DMA error status */
  97         /* 0x08 */
  98         u32 dmaerqh;            /* DMA enable request high(channels 63~32) */
  99         u32 dmaerql;            /* DMA enable request low(channels 31~0) */
 100         u32 dmaeeih;            /* DMA enable error interrupt high(ch63~32) */
 101         u32 dmaeeil;            /* DMA enable error interrupt low(ch31~0) */
 102         /* 0x18 */
 103         u8 dmaserq;             /* DMA set enable request */
 104         u8 dmacerq;             /* DMA clear enable request */
 105         u8 dmaseei;             /* DMA set enable error interrupt */
 106         u8 dmaceei;             /* DMA clear enable error interrupt */
 107         /* 0x1c */
 108         u8 dmacint;             /* DMA clear interrupt request */
 109         u8 dmacerr;             /* DMA clear error */
 110         u8 dmassrt;             /* DMA set start bit */
 111         u8 dmacdne;             /* DMA clear DONE status bit */
 112         /* 0x20 */
 113         u32 dmainth;            /* DMA interrupt request high(ch63~32) */
 114         u32 dmaintl;            /* DMA interrupt request low(ch31~0) */
 115         u32 dmaerrh;            /* DMA error high(ch63~32) */
 116         u32 dmaerrl;            /* DMA error low(ch31~0) */
 117         /* 0x30 */
 118         u32 dmahrsh;            /* DMA hw request status high(ch63~32) */
 119         u32 dmahrsl;            /* DMA hardware request status low(ch31~0) */
 120         union {
 121                 u32 dmaihsa;    /* DMA interrupt high select AXE(ch63~32) */
 122                 u32 dmagpor;    /* (General purpose register on MPC8308) */
 123         };
 124         u32 dmailsa;            /* DMA interrupt low select AXE(ch31~0) */
 125         /* 0x40 ~ 0xff */
 126         u32 reserve0[48];       /* Reserved */
 127         /* 0x100 */
 128         u8 dchpri[MPC_DMA_CHANNELS];
 129         /* DMA channels(0~63) priority */
 130 };
 131
 132 struct __attribute__ ((__packed__)) mpc_dma_tcd {
 133         /* 0x00 */
 134         u32 saddr;              /* Source address */
 135
 136         u32 smod:5;             /* Source address modulo */
 137         u32 ssize:3;            /* Source data transfer size */
 138         u32 dmod:5;             /* Destination address modulo */
 139         u32 dsize:3;            /* Destination data transfer size */
 140         u32 soff:16;            /* Signed source address offset */
 141
 142         /* 0x08 */
 143         u32 nbytes;             /* Inner "minor" byte count */
 144         u32 slast;              /* Last source address adjustment */
 145         u32 daddr;              /* Destination address */
 146
 147         /* 0x14 */
 148         u32 citer_elink:1;      /* Enable channel-to-channel linking on
 149                                  * minor loop complete
 150                                  */
 151         u32 citer_linkch:6;     /* Link channel for minor loop complete */
 152         u32 citer:9;            /* Current "major" iteration count */
 153         u32 doff:16;            /* Signed destination address offset */
 154
 155         /* 0x18 */
 156         u32 dlast_sga;          /* Last Destination address adjustment/scatter
 157                                  * gather address
 158                                  */
 159
 160         /* 0x1c */
 161         u32 biter_elink:1;      /* Enable channel-to-channel linking on major
 162                                  * loop complete
 163                                  */
 164         u32 biter_linkch:6;
 165         u32 biter:9;            /* Beginning "major" iteration count */
 166         u32 bwc:2;              /* Bandwidth control */
 167         u32 major_linkch:6;     /* Link channel number */
 168         u32 done:1;             /* Channel done */
 169         u32 active:1;           /* Channel active */
 170         u32 major_elink:1;      /* Enable channel-to-channel linking on major
 171                                  * loop complete
 172                                  */
 173         u32 e_sg:1;             /* Enable scatter/gather processing */
 174         u32 d_req:1;            /* Disable request */
 175         u32 int_half:1;         /* Enable an interrupt when major counter is
 176                                  * half complete
 177                                  */
 178         u32 int_maj:1;          /* Enable an interrupt when major iteration
 179                                  * count completes
 180                                  */
 181         u32 start:1;            /* Channel start */
 182 };
 183
 184 struct mpc_dma_desc {
 185         struct dma_async_tx_descriptor  desc;
 186         struct mpc_dma_tcd              *tcd;
 187         dma_addr_t                      tcd_paddr;
 188         int                             error;
 189         struct list_head                node;
 190         int                             will_access_peripheral;
 191 };
 192
 193 struct mpc_dma_chan {
 194         struct dma_chan                 chan;
 195         struct list_head                free;
 196         struct list_head                prepared;
 197         struct list_head                queued;
 198         struct list_head                active;
 199         struct list_head                completed;
 200         struct mpc_dma_tcd              *tcd;
 201         dma_addr_t                      tcd_paddr;
 202
 203         /* Settings for access to peripheral FIFO */
 204         dma_addr_t                      src_per_paddr;
 205         u32                             src_tcd_nunits;
 206         u8                              swidth;
 207         dma_addr_t                      dst_per_paddr;
 208         u32                             dst_tcd_nunits;
 209         u8                              dwidth;
 210
 211         /* Lock for this structure */
 212         spinlock_t                      lock;
 213 };
 214
 215 struct mpc_dma {
 216         struct dma_device               dma;
 217         struct tasklet_struct           tasklet;
 218         struct mpc_dma_chan             channels[MPC_DMA_CHANNELS];
 219         struct mpc_dma_regs __iomem     *regs;
 220         struct mpc_dma_tcd __iomem      *tcd;
 221         int                             irq;
 222         int                             irq2;
 223         uint                            error_status;
 224         int                             is_mpc8308;
 225
 226         /* Lock for error_status field in this structure */
 227         spinlock_t                      error_status_lock;
 228 };
 229
 230 #define DRV_NAME        "mpc512x_dma"
 231
 232 /* Convert struct dma_chan to struct mpc_dma_chan */
 233 static inline struct mpc_dma_chan *dma_chan_to_mpc_dma_chan(struct dma_chan *c)
 234 {
 235         return container_of(c, struct mpc_dma_chan, chan);
 236 }
 237
 238 /* Convert struct dma_chan to struct mpc_dma */
 239 static inline struct mpc_dma *dma_chan_to_mpc_dma(struct dma_chan *c)
 240 {
 241         struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(c);
 242
 243         return container_of(mchan, struct mpc_dma, channels[c->chan_id]);
 244 }
 245
 246 /*
 247  * Execute all queued DMA descriptors.
 248  *
 249  * Following requirements must be met while calling mpc_dma_execute():
 250  *      a) mchan->lock is acquired,
 251  *      b) mchan->active list is empty,
 252  *      c) mchan->queued list contains at least one entry.
 253  */
 254 static void mpc_dma_execute(struct mpc_dma_chan *mchan)
 255 {
 256         struct mpc_dma *mdma = dma_chan_to_mpc_dma(&mchan->chan);
 257         struct mpc_dma_desc *first = NULL;
 258         struct mpc_dma_desc *prev = NULL;
 259         struct mpc_dma_desc *mdesc;
 260         int cid = mchan->chan.chan_id;
 261
 262         while (!list_empty(&mchan->queued)) {
 263                 mdesc = list_first_entry(&mchan->queued,
 264                                                 struct mpc_dma_desc, node);
 265                 /*
 266                  * Grab either several mem-to-mem transfer descriptors
 267                  * or one peripheral transfer descriptor,
 268                  * don't mix mem-to-mem and peripheral transfer descriptors
 269                  * within the same 'active' list.
 270                  */
 271                 if (mdesc->will_access_peripheral) {
 272                         if (list_empty(&mchan->active))
 273                                 list_move_tail(&mdesc->node, &mchan->active);
 274                         break;
 275                 } else {
 276                         list_move_tail(&mdesc->node, &mchan->active);
 277                 }
 278         }
 279
 280         /* Chain descriptors into one transaction */
 281         list_for_each_entry(mdesc, &mchan->active, node) {
 282                 if (!first)
 283                         first = mdesc;
 284
 285                 if (!prev) {
 286                         prev = mdesc;
 287                         continue;
 288                 }
 289
 290                 prev->tcd->dlast_sga = mdesc->tcd_paddr;
 291                 prev->tcd->e_sg = 1;
 292                 mdesc->tcd->start = 1;
 293
 294                 prev = mdesc;
 295         }
 296
 297         prev->tcd->int_maj = 1;
 298
 299         /* Send first descriptor in chain into hardware */
 300         memcpy_toio(&mdma->tcd[cid], first->tcd, sizeof(struct mpc_dma_tcd));
 301
 302         if (first != prev)
 303                 mdma->tcd[cid].e_sg = 1;
 304
 305         if (mdma->is_mpc8308) {
 306                 /* MPC8308, no request lines, software initiated start */
 307                 out_8(&mdma->regs->dmassrt, cid);
 308         } else if (first->will_access_peripheral) {
 309                 /* Peripherals involved, start by external request signal */
 310                 out_8(&mdma->regs->dmaserq, cid);
 311         } else {
 312                 /* Memory to memory transfer, software initiated start */
 313                 out_8(&mdma->regs->dmassrt, cid);
 314         }
 315 }
 316
 317 /* Handle interrupt on one half of DMA controller (32 channels) */
 318 static void mpc_dma_irq_process(struct mpc_dma *mdma, u32 is, u32 es, int off)
 319 {
 320         struct mpc_dma_chan *mchan;
 321         struct mpc_dma_desc *mdesc;
 322         u32 status = is | es;
 323         int ch;
 324
 325         while ((ch = fls(status) - 1) >= 0) {
 326                 status &= ~(1 << ch);
 327                 mchan = &mdma->channels[ch + off];
 328
 329                 spin_lock(&mchan->lock);
 330
 331                 out_8(&mdma->regs->dmacint, ch + off);
 332                 out_8(&mdma->regs->dmacerr, ch + off);
 333
 334                 /* Check error status */
 335                 if (es & (1 << ch))
 336                         list_for_each_entry(mdesc, &mchan->active, node)
 337                                 mdesc->error = -EIO;
 338
 339                 /* Execute queued descriptors */
 340                 list_splice_tail_init(&mchan->active, &mchan->completed);
 341                 if (!list_empty(&mchan->queued))
 342                         mpc_dma_execute(mchan);
 343
 344                 spin_unlock(&mchan->lock);
 345         }
 346 }
 347
 348 /* Interrupt handler */
 349 static irqreturn_t mpc_dma_irq(int irq, void *data)
 350 {
 351         struct mpc_dma *mdma = data;
 352         uint es;
 353
 354         /* Save error status register */
 355         es = in_be32(&mdma->regs->dmaes);
 356         spin_lock(&mdma->error_status_lock);
 357         if ((es & MPC_DMA_DMAES_VLD) && mdma->error_status == 0)
 358                 mdma->error_status = es;
 359         spin_unlock(&mdma->error_status_lock);
 360
 361         /* Handle interrupt on each channel */
 362         if (mdma->dma.chancnt > 32) {
 363                 mpc_dma_irq_process(mdma, in_be32(&mdma->regs->dmainth),
 364                                         in_be32(&mdma->regs->dmaerrh), 32);
 365         }
 366         mpc_dma_irq_process(mdma, in_be32(&mdma->regs->dmaintl),
 367                                         in_be32(&mdma->regs->dmaerrl), 0);
 368
 369         /* Schedule tasklet */
 370         tasklet_schedule(&mdma->tasklet);
 371
 372         return IRQ_HANDLED;
 373 }
 374
 375 /* process completed descriptors */
 376 static void mpc_dma_process_completed(struct mpc_dma *mdma)
 377 {
 378         dma_cookie_t last_cookie = 0;
 379         struct mpc_dma_chan *mchan;
 380         struct mpc_dma_desc *mdesc;
 381         struct dma_async_tx_descriptor *desc;
 382         unsigned long flags;
 383         LIST_HEAD(list);
 384         int i;
 385
 386         for (i = 0; i < mdma->dma.chancnt; i++) {
 387                 mchan = &mdma->channels[i];
 388
 389                 /* Get all completed descriptors */
 390                 spin_lock_irqsave(&mchan->lock, flags);
 391                 if (!list_empty(&mchan->completed))
 392                         list_splice_tail_init(&mchan->completed, &list);
 393                 spin_unlock_irqrestore(&mchan->lock, flags);
 394
 395                 if (list_empty(&list))
 396                         continue;
 397
 398                 /* Execute callbacks and run dependencies */
 399                 list_for_each_entry(mdesc, &list, node) {
 400                         desc = &mdesc->desc;
 401
 402                         dmaengine_desc_get_callback_invoke(desc, NULL);
 403
 404                         last_cookie = desc->cookie;
 405                         dma_run_dependencies(desc);
 406                 }
 407
 408                 /* Free descriptors */
 409                 spin_lock_irqsave(&mchan->lock, flags);
 410                 list_splice_tail_init(&list, &mchan->free);
 411                 mchan->chan.completed_cookie = last_cookie;
 412                 spin_unlock_irqrestore(&mchan->lock, flags);
 413         }
 414 }
 415
 416 /* DMA Tasklet */
 417 static void mpc_dma_tasklet(struct tasklet_struct *t)
 418 {
 419         struct mpc_dma *mdma = from_tasklet(mdma, t, tasklet);
 420         unsigned long flags;
 421         uint es;
 422
 423         spin_lock_irqsave(&mdma->error_status_lock, flags);
 424         es = mdma->error_status;
 425         mdma->error_status = 0;
 426         spin_unlock_irqrestore(&mdma->error_status_lock, flags);
 427
 428         /* Print nice error report */
 429         if (es) {
 430                 dev_err(mdma->dma.dev,
 431                         "Hardware reported following error(s) on channel %u:\n",
 432                                                       MPC_DMA_DMAES_ERRCHN(es));
 433
 434                 if (es & MPC_DMA_DMAES_GPE)
 435                         dev_err(mdma->dma.dev, "- Group Priority Error\n");
 436                 if (es & MPC_DMA_DMAES_CPE)
 437                         dev_err(mdma->dma.dev, "- Channel Priority Error\n");
 438                 if (es & MPC_DMA_DMAES_SAE)
 439                         dev_err(mdma->dma.dev, "- Source Address Error\n");
 440                 if (es & MPC_DMA_DMAES_SOE)
 441                         dev_err(mdma->dma.dev, "- Source Offset Configuration Error\n");
 442                 if (es & MPC_DMA_DMAES_DAE)
 443                         dev_err(mdma->dma.dev, "- Destination Address Error\n");
 444                 if (es & MPC_DMA_DMAES_DOE)
 445                         dev_err(mdma->dma.dev, "- Destination Offset Configuration Error\n");
 446                 if (es & MPC_DMA_DMAES_NCE)
 447                         dev_err(mdma->dma.dev, "- NBytes/Citter Configuration Error\n");
 448                 if (es & MPC_DMA_DMAES_SGE)
 449                         dev_err(mdma->dma.dev, "- Scatter/Gather Configuration Error\n");
 450                 if (es & MPC_DMA_DMAES_SBE)
 451                         dev_err(mdma->dma.dev, "- Source Bus Error\n");
 452                 if (es & MPC_DMA_DMAES_DBE)
 453                         dev_err(mdma->dma.dev, "- Destination Bus Error\n");
 454         }
 455
 456         mpc_dma_process_completed(mdma);
 457 }
 458
 459 /* Submit descriptor to hardware */
 460 static dma_cookie_t mpc_dma_tx_submit(struct dma_async_tx_descriptor *txd)
 461 {
 462         struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(txd->chan);
 463         struct mpc_dma_desc *mdesc;
 464         unsigned long flags;
 465         dma_cookie_t cookie;
 466
 467         mdesc = container_of(txd, struct mpc_dma_desc, desc);
 468
 469         spin_lock_irqsave(&mchan->lock, flags);
 470
 471         /* Move descriptor to queue */
 472         list_move_tail(&mdesc->node, &mchan->queued);
 473
 474         /* If channel is idle, execute all queued descriptors */
 475         if (list_empty(&mchan->active))
 476                 mpc_dma_execute(mchan);
 477
 478         /* Update cookie */
 479         cookie = dma_cookie_assign(txd);
 480         spin_unlock_irqrestore(&mchan->lock, flags);
 481
 482         return cookie;
 483 }
 484
 485 /* Alloc channel resources */
 486 static int mpc_dma_alloc_chan_resources(struct dma_chan *chan)
 487 {
 488         struct mpc_dma *mdma = dma_chan_to_mpc_dma(chan);
 489         struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan);
 490         struct mpc_dma_desc *mdesc;
 491         struct mpc_dma_tcd *tcd;
 492         dma_addr_t tcd_paddr;
 493         unsigned long flags;
 494         LIST_HEAD(descs);
 495         int i;
 496
 497         /* Alloc DMA memory for Transfer Control Descriptors */
 498         tcd = dma_alloc_coherent(mdma->dma.dev,
 499                         MPC_DMA_DESCRIPTORS * sizeof(struct mpc_dma_tcd),
 500                                                         &tcd_paddr, GFP_KERNEL);
 501         if (!tcd)
 502                 return -ENOMEM;
 503
 504         /* Alloc descriptors for this channel */
 505         for (i = 0; i < MPC_DMA_DESCRIPTORS; i++) {
 506                 mdesc = kzalloc(sizeof(struct mpc_dma_desc), GFP_KERNEL);
 507                 if (!mdesc) {
 508                         dev_notice(mdma->dma.dev,
 509                                 "Memory allocation error. Allocated only %u descriptors\n", i);
 510                         break;
 511                 }
 512
 513                 dma_async_tx_descriptor_init(&mdesc->desc, chan);
 514                 mdesc->desc.flags = DMA_CTRL_ACK;
 515                 mdesc->desc.tx_submit = mpc_dma_tx_submit;
 516
 517                 mdesc->tcd = &tcd[i];
 518                 mdesc->tcd_paddr = tcd_paddr + (i * sizeof(struct mpc_dma_tcd));
 519
 520                 list_add_tail(&mdesc->node, &descs);
 521         }
 522
 523         /* Return error only if no descriptors were allocated */
 524         if (i == 0) {
 525                 dma_free_coherent(mdma->dma.dev,
 526                         MPC_DMA_DESCRIPTORS * sizeof(struct mpc_dma_tcd),
 527                                                                 tcd, tcd_paddr);
 528                 return -ENOMEM;
 529         }
 530
 531         spin_lock_irqsave(&mchan->lock, flags);
 532         mchan->tcd = tcd;
 533         mchan->tcd_paddr = tcd_paddr;
 534         list_splice_tail_init(&descs, &mchan->free);
 535         spin_unlock_irqrestore(&mchan->lock, flags);
 536
 537         /* Enable Error Interrupt */
 538         out_8(&mdma->regs->dmaseei, chan->chan_id);
 539
 540         return 0;
 541 }
 542
 543 /* Free channel resources */
 544 static void mpc_dma_free_chan_resources(struct dma_chan *chan)
 545 {
 546         struct mpc_dma *mdma = dma_chan_to_mpc_dma(chan);
 547         struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan);
 548         struct mpc_dma_desc *mdesc, *tmp;
 549         struct mpc_dma_tcd *tcd;
 550         dma_addr_t tcd_paddr;
 551         unsigned long flags;
 552         LIST_HEAD(descs);
 553
 554         spin_lock_irqsave(&mchan->lock, flags);
 555
 556         /* Channel must be idle */
 557         BUG_ON(!list_empty(&mchan->prepared));
 558         BUG_ON(!list_empty(&mchan->queued));
 559         BUG_ON(!list_empty(&mchan->active));
 560         BUG_ON(!list_empty(&mchan->completed));
 561
 562         /* Move data */
 563         list_splice_tail_init(&mchan->free, &descs);
 564         tcd = mchan->tcd;
 565         tcd_paddr = mchan->tcd_paddr;
 566
 567         spin_unlock_irqrestore(&mchan->lock, flags);
 568
 569         /* Free DMA memory used by descriptors */
 570         dma_free_coherent(mdma->dma.dev,
 571                         MPC_DMA_DESCRIPTORS * sizeof(struct mpc_dma_tcd),
 572                                                                 tcd, tcd_paddr);
 573
 574         /* Free descriptors */
 575         list_for_each_entry_safe(mdesc, tmp, &descs, node)
 576                 kfree(mdesc);
 577
 578         /* Disable Error Interrupt */
 579         out_8(&mdma->regs->dmaceei, chan->chan_id);
 580 }
 581
 582 /* Send all pending descriptor to hardware */
 583 static void mpc_dma_issue_pending(struct dma_chan *chan)
 584 {
 585         /*
 586          * We are posting descriptors to the hardware as soon as
 587          * they are ready, so this function does nothing.
 588          */
 589 }
 590
 591 /* Check request completion status */
 592 static enum dma_status
 593 mpc_dma_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
 594                struct dma_tx_state *txstate)
 595 {
 596         return dma_cookie_status(chan, cookie, txstate);
 597 }
 598
 599 /* Prepare descriptor for memory to memory copy */
 600 static struct dma_async_tx_descriptor *
 601 mpc_dma_prep_memcpy(struct dma_chan *chan, dma_addr_t dst, dma_addr_t src,
 602                                         size_t len, unsigned long flags)
 603 {
 604         struct mpc_dma *mdma = dma_chan_to_mpc_dma(chan);
 605         struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan);
 606         struct mpc_dma_desc *mdesc = NULL;
 607         struct mpc_dma_tcd *tcd;
 608         unsigned long iflags;
 609
 610         /* Get free descriptor */
 611         spin_lock_irqsave(&mchan->lock, iflags);
 612         if (!list_empty(&mchan->free)) {
 613                 mdesc = list_first_entry(&mchan->free, struct mpc_dma_desc,
 614                                                                         node);
 615                 list_del(&mdesc->node);
 616         }
 617         spin_unlock_irqrestore(&mchan->lock, iflags);
 618
 619         if (!mdesc) {
 620                 /* try to free completed descriptors */
 621                 mpc_dma_process_completed(mdma);
 622                 return NULL;
 623         }
 624
 625         mdesc->error = 0;
 626         mdesc->will_access_peripheral = 0;
 627         tcd = mdesc->tcd;
 628
 629         /* Prepare Transfer Control Descriptor for this transaction */
 630         memset(tcd, 0, sizeof(struct mpc_dma_tcd));
 631
 632         if (IS_ALIGNED(src | dst | len, 32)) {
 633                 tcd->ssize = MPC_DMA_TSIZE_32;
 634                 tcd->dsize = MPC_DMA_TSIZE_32;
 635                 tcd->soff = 32;
 636                 tcd->doff = 32;
 637         } else if (!mdma->is_mpc8308 && IS_ALIGNED(src | dst | len, 16)) {
 638                 /* MPC8308 doesn't support 16 byte transfers */
 639                 tcd->ssize = MPC_DMA_TSIZE_16;
 640                 tcd->dsize = MPC_DMA_TSIZE_16;
 641                 tcd->soff = 16;
 642                 tcd->doff = 16;
 643         } else if (IS_ALIGNED(src | dst | len, 4)) {
 644                 tcd->ssize = MPC_DMA_TSIZE_4;
 645                 tcd->dsize = MPC_DMA_TSIZE_4;
 646                 tcd->soff = 4;
 647                 tcd->doff = 4;
 648         } else if (IS_ALIGNED(src | dst | len, 2)) {
 649                 tcd->ssize = MPC_DMA_TSIZE_2;
 650                 tcd->dsize = MPC_DMA_TSIZE_2;
 651                 tcd->soff = 2;
 652                 tcd->doff = 2;
 653         } else {
 654                 tcd->ssize = MPC_DMA_TSIZE_1;
 655                 tcd->dsize = MPC_DMA_TSIZE_1;
 656                 tcd->soff = 1;
 657                 tcd->doff = 1;
 658         }
 659
 660         tcd->saddr = src;
 661         tcd->daddr = dst;
 662         tcd->nbytes = len;
 663         tcd->biter = 1;
 664         tcd->citer = 1;
 665
 666         /* Place descriptor in prepared list */
 667         spin_lock_irqsave(&mchan->lock, iflags);
 668         list_add_tail(&mdesc->node, &mchan->prepared);
 669         spin_unlock_irqrestore(&mchan->lock, iflags);
 670
 671         return &mdesc->desc;
 672 }
 673
 674 inline u8 buswidth_to_dmatsize(u8 buswidth)
 675 {
 676         u8 res;
 677
 678         for (res = 0; buswidth > 1; buswidth /= 2)
 679                 res++;
 680         return res;
 681 }
 682
 683 static struct dma_async_tx_descriptor *
 684 mpc_dma_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
 685                 unsigned int sg_len, enum dma_transfer_direction direction,
 686                 unsigned long flags, void *context)
 687 {
 688         struct mpc_dma *mdma = dma_chan_to_mpc_dma(chan);
 689         struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan);
 690         struct mpc_dma_desc *mdesc = NULL;
 691         dma_addr_t per_paddr;
 692         u32 tcd_nunits;
 693         struct mpc_dma_tcd *tcd;
 694         unsigned long iflags;
 695         struct scatterlist *sg;
 696         size_t len;
 697         int iter, i;
 698
 699         /* Currently there is no proper support for scatter/gather */
 700         if (sg_len != 1)
 701                 return NULL;
 702
 703         if (!is_slave_direction(direction))
 704                 return NULL;
 705
 706         for_each_sg(sgl, sg, sg_len, i) {
 707                 spin_lock_irqsave(&mchan->lock, iflags);
 708
 709                 mdesc = list_first_entry(&mchan->free,
 710                                                 struct mpc_dma_desc, node);
 711                 if (!mdesc) {
 712                         spin_unlock_irqrestore(&mchan->lock, iflags);
 713                         /* Try to free completed descriptors */
 714                         mpc_dma_process_completed(mdma);
 715                         return NULL;
 716                 }
 717
 718                 list_del(&mdesc->node);
 719
 720                 if (direction == DMA_DEV_TO_MEM) {
 721                         per_paddr = mchan->src_per_paddr;
 722                         tcd_nunits = mchan->src_tcd_nunits;
 723                 } else {
 724                         per_paddr = mchan->dst_per_paddr;
 725                         tcd_nunits = mchan->dst_tcd_nunits;
 726                 }
 727
 728                 spin_unlock_irqrestore(&mchan->lock, iflags);
 729
 730                 if (per_paddr == 0 || tcd_nunits == 0)
 731                         goto err_prep;
 732
 733                 mdesc->error = 0;
 734                 mdesc->will_access_peripheral = 1;
 735
 736                 /* Prepare Transfer Control Descriptor for this transaction */
 737                 tcd = mdesc->tcd;
 738
 739                 memset(tcd, 0, sizeof(struct mpc_dma_tcd));
 740
 741                 if (direction == DMA_DEV_TO_MEM) {
 742                         tcd->saddr = per_paddr;
 743                         tcd->daddr = sg_dma_address(sg);
 744
 745                         if (!IS_ALIGNED(sg_dma_address(sg), mchan->dwidth))
 746                                 goto err_prep;
 747
 748                         tcd->soff = 0;
 749                         tcd->doff = mchan->dwidth;
 750                 } else {
 751                         tcd->saddr = sg_dma_address(sg);
 752                         tcd->daddr = per_paddr;
 753
 754                         if (!IS_ALIGNED(sg_dma_address(sg), mchan->swidth))
 755                                 goto err_prep;
 756
 757                         tcd->soff = mchan->swidth;
 758                         tcd->doff = 0;
 759                 }
 760
 761                 tcd->ssize = buswidth_to_dmatsize(mchan->swidth);
 762                 tcd->dsize = buswidth_to_dmatsize(mchan->dwidth);
 763
 764                 if (mdma->is_mpc8308) {
 765                         tcd->nbytes = sg_dma_len(sg);
 766                         if (!IS_ALIGNED(tcd->nbytes, mchan->swidth))
 767                                 goto err_prep;
 768
 769                         /* No major loops for MPC8303 */
 770                         tcd->biter = 1;
 771                         tcd->citer = 1;
 772                 } else {
 773                         len = sg_dma_len(sg);
 774                         tcd->nbytes = tcd_nunits * tcd->ssize;
 775                         if (!IS_ALIGNED(len, tcd->nbytes))
 776                                 goto err_prep;
 777
 778                         iter = len / tcd->nbytes;
 779                         if (iter >= 1 << 15) {
 780                                 /* len is too big */
 781                                 goto err_prep;
 782                         }
 783                         /* citer_linkch contains the high bits of iter */
 784                         tcd->biter = iter & 0x1ff;
 785                         tcd->biter_linkch = iter >> 9;
 786                         tcd->citer = tcd->biter;
 787                         tcd->citer_linkch = tcd->biter_linkch;
 788                 }
 789
 790                 tcd->e_sg = 0;
 791                 tcd->d_req = 1;
 792
 793                 /* Place descriptor in prepared list */
 794                 spin_lock_irqsave(&mchan->lock, iflags);
 795                 list_add_tail(&mdesc->node, &mchan->prepared);
 796                 spin_unlock_irqrestore(&mchan->lock, iflags);
 797         }
 798
 799         return &mdesc->desc;
 800
 801 err_prep:
 802         /* Put the descriptor back */
 803         spin_lock_irqsave(&mchan->lock, iflags);
 804         list_add_tail(&mdesc->node, &mchan->free);
 805         spin_unlock_irqrestore(&mchan->lock, iflags);
 806
 807         return NULL;
 808 }
 809
 810 inline bool is_buswidth_valid(u8 buswidth, bool is_mpc8308)
 811 {
 812         switch (buswidth) {
 813         case 16:
 814                 if (is_mpc8308)
 815                         return false;
 816                 break;
 817         case 1:
 818         case 2:
 819         case 4:
 820         case 32:
 821                 break;
 822         default:
 823                 return false;
 824         }
 825
 826         return true;
 827 }
 828
 829 static int mpc_dma_device_config(struct dma_chan *chan,
 830                                  struct dma_slave_config *cfg)
 831 {
 832         struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan);
 833         struct mpc_dma *mdma = dma_chan_to_mpc_dma(&mchan->chan);
 834         unsigned long flags;
 835
 836         /*
 837          * Software constraints:
 838          *  - only transfers between a peripheral device and memory are
 839          *     supported
 840          *  - transfer chunk sizes of 1, 2, 4, 16 (for MPC512x), and 32 bytes
 841          *     are supported, and, consequently, source addresses and
 842          *     destination addresses; must be aligned accordingly; furthermore,
 843          *     for MPC512x SoCs, the transfer size must be aligned on (chunk
 844          *     size * maxburst)
 845          *  - during the transfer, the RAM address is incremented by the size
 846          *     of transfer chunk
 847          *  - the peripheral port's address is constant during the transfer.
 848          */
 849
 850         if (!IS_ALIGNED(cfg->src_addr, cfg->src_addr_width) ||
 851             !IS_ALIGNED(cfg->dst_addr, cfg->dst_addr_width)) {
 852                 return -EINVAL;
 853         }
 854
 855         if (!is_buswidth_valid(cfg->src_addr_width, mdma->is_mpc8308) ||
 856             !is_buswidth_valid(cfg->dst_addr_width, mdma->is_mpc8308))
 857                 return -EINVAL;
 858
 859         spin_lock_irqsave(&mchan->lock, flags);
 860
 861         mchan->src_per_paddr = cfg->src_addr;
 862         mchan->src_tcd_nunits = cfg->src_maxburst;
 863         mchan->swidth = cfg->src_addr_width;
 864         mchan->dst_per_paddr = cfg->dst_addr;
 865         mchan->dst_tcd_nunits = cfg->dst_maxburst;
 866         mchan->dwidth = cfg->dst_addr_width;
 867
 868         /* Apply defaults */
 869         if (mchan->src_tcd_nunits == 0)
 870                 mchan->src_tcd_nunits = 1;
 871         if (mchan->dst_tcd_nunits == 0)
 872                 mchan->dst_tcd_nunits = 1;
 873
 874         spin_unlock_irqrestore(&mchan->lock, flags);
 875
 876         return 0;
 877 }
 878
 879 static int mpc_dma_device_terminate_all(struct dma_chan *chan)
 880 {
 881         struct mpc_dma_chan *mchan = dma_chan_to_mpc_dma_chan(chan);
 882         struct mpc_dma *mdma = dma_chan_to_mpc_dma(chan);
 883         unsigned long flags;
 884
 885         /* Disable channel requests */
 886         spin_lock_irqsave(&mchan->lock, flags);
 887
 888         out_8(&mdma->regs->dmacerq, chan->chan_id);
 889         list_splice_tail_init(&mchan->prepared, &mchan->free);
 890         list_splice_tail_init(&mchan->queued, &mchan->free);
 891         list_splice_tail_init(&mchan->active, &mchan->free);
 892
 893         spin_unlock_irqrestore(&mchan->lock, flags);
 894
 895         return 0;
 896 }
 897
 898 static int mpc_dma_probe(struct platform_device *op)
 899 {
 900         struct device_node *dn = op->dev.of_node;
 901         struct device *dev = &op->dev;
 902         struct dma_device *dma;
 903         struct mpc_dma *mdma;
 904         struct mpc_dma_chan *mchan;
 905         struct resource res;
 906         ulong regs_start, regs_size;
 907         int retval, i;
 908         u8 chancnt;
 909
 910         mdma = devm_kzalloc(dev, sizeof(struct mpc_dma), GFP_KERNEL);
 911         if (!mdma) {
 912                 retval = -ENOMEM;
 913                 goto err;
 914         }
 915
 916         mdma->irq = irq_of_parse_and_map(dn, 0);
 917         if (!mdma->irq) {
 918                 dev_err(dev, "Error mapping IRQ!\n");
 919                 retval = -EINVAL;
 920                 goto err;
 921         }
 922
 923         if (of_device_is_compatible(dn, "fsl,mpc8308-dma")) {
 924                 mdma->is_mpc8308 = 1;
 925                 mdma->irq2 = irq_of_parse_and_map(dn, 1);
 926                 if (!mdma->irq2) {
 927                         dev_err(dev, "Error mapping IRQ!\n");
 928                         retval = -EINVAL;
 929                         goto err_dispose1;
 930                 }
 931         }
 932
 933         retval = of_address_to_resource(dn, 0, &res);
 934         if (retval) {
 935                 dev_err(dev, "Error parsing memory region!\n");
 936                 goto err_dispose2;
 937         }
 938
 939         regs_start = res.start;
 940         regs_size = resource_size(&res);
 941
 942         if (!devm_request_mem_region(dev, regs_start, regs_size, DRV_NAME)) {
 943                 dev_err(dev, "Error requesting memory region!\n");
 944                 retval = -EBUSY;
 945                 goto err_dispose2;
 946         }
 947
 948         mdma->regs = devm_ioremap(dev, regs_start, regs_size);
 949         if (!mdma->regs) {
 950                 dev_err(dev, "Error mapping memory region!\n");
 951                 retval = -ENOMEM;
 952                 goto err_dispose2;
 953         }
 954
 955         mdma->tcd = (struct mpc_dma_tcd *)((u8 *)(mdma->regs)
 956                                                         + MPC_DMA_TCD_OFFSET);
 957
 958         retval = request_irq(mdma->irq, &mpc_dma_irq, 0, DRV_NAME, mdma);
 959         if (retval) {
 960                 dev_err(dev, "Error requesting IRQ!\n");
 961                 retval = -EINVAL;
 962                 goto err_dispose2;
 963         }
 964
 965         if (mdma->is_mpc8308) {
 966                 retval = request_irq(mdma->irq2, &mpc_dma_irq, 0,
 967                                                         DRV_NAME, mdma);
 968                 if (retval) {
 969                         dev_err(dev, "Error requesting IRQ2!\n");
 970                         retval = -EINVAL;
 971                         goto err_free1;
 972                 }
 973         }
 974
 975         spin_lock_init(&mdma->error_status_lock);
 976
 977         dma = &mdma->dma;
 978         dma->dev = dev;
 979         dma->device_alloc_chan_resources = mpc_dma_alloc_chan_resources;
 980         dma->device_free_chan_resources = mpc_dma_free_chan_resources;
 981         dma->device_issue_pending = mpc_dma_issue_pending;
 982         dma->device_tx_status = mpc_dma_tx_status;
 983         dma->device_prep_dma_memcpy = mpc_dma_prep_memcpy;
 984         dma->device_prep_slave_sg = mpc_dma_prep_slave_sg;
 985         dma->device_config = mpc_dma_device_config;
 986         dma->device_terminate_all = mpc_dma_device_terminate_all;
 987
 988         INIT_LIST_HEAD(&dma->channels);
 989         dma_cap_set(DMA_MEMCPY, dma->cap_mask);
 990         dma_cap_set(DMA_SLAVE, dma->cap_mask);
 991
 992         if (mdma->is_mpc8308)
 993                 chancnt = MPC8308_DMACHAN_MAX;
 994         else
 995                 chancnt = MPC512x_DMACHAN_MAX;
 996
 997         for (i = 0; i < chancnt; i++) {
 998                 mchan = &mdma->channels[i];
 999
1000                 mchan->chan.device = dma;
1001                 dma_cookie_init(&mchan->chan);
1002
1003                 INIT_LIST_HEAD(&mchan->free);
1004                 INIT_LIST_HEAD(&mchan->prepared);
1005                 INIT_LIST_HEAD(&mchan->queued);
1006                 INIT_LIST_HEAD(&mchan->active);
1007                 INIT_LIST_HEAD(&mchan->completed);
1008
1009                 spin_lock_init(&mchan->lock);
1010                 list_add_tail(&mchan->chan.device_node, &dma->channels);
1011         }
1012
1013         tasklet_setup(&mdma->tasklet, mpc_dma_tasklet);
1014
1015         /*
1016          * Configure DMA Engine:
1017          * - Dynamic clock,
1018          * - Round-robin group arbitration,
1019          * - Round-robin channel arbitration.
1020          */
1021         if (mdma->is_mpc8308) {
1022                 /* MPC8308 has 16 channels and lacks some registers */
1023                 out_be32(&mdma->regs->dmacr, MPC_DMA_DMACR_ERCA);
1024
1025                 /* enable snooping */
1026                 out_be32(&mdma->regs->dmagpor, MPC_DMA_DMAGPOR_SNOOP_ENABLE);
1027                 /* Disable error interrupts */
1028                 out_be32(&mdma->regs->dmaeeil, 0);
1029
1030                 /* Clear interrupts status */
1031                 out_be32(&mdma->regs->dmaintl, 0xFFFF);
1032                 out_be32(&mdma->regs->dmaerrl, 0xFFFF);
1033         } else {
1034                 out_be32(&mdma->regs->dmacr, MPC_DMA_DMACR_EDCG |
1035                                                 MPC_DMA_DMACR_ERGA |
1036                                                 MPC_DMA_DMACR_ERCA);
1037
1038                 /* Disable hardware DMA requests */
1039                 out_be32(&mdma->regs->dmaerqh, 0);
1040                 out_be32(&mdma->regs->dmaerql, 0);
1041
1042                 /* Disable error interrupts */
1043                 out_be32(&mdma->regs->dmaeeih, 0);
1044                 out_be32(&mdma->regs->dmaeeil, 0);
1045
1046                 /* Clear interrupts status */
1047                 out_be32(&mdma->regs->dmainth, 0xFFFFFFFF);
1048                 out_be32(&mdma->regs->dmaintl, 0xFFFFFFFF);
1049                 out_be32(&mdma->regs->dmaerrh, 0xFFFFFFFF);
1050                 out_be32(&mdma->regs->dmaerrl, 0xFFFFFFFF);
1051
1052                 /* Route interrupts to IPIC */
1053                 out_be32(&mdma->regs->dmaihsa, 0);
1054                 out_be32(&mdma->regs->dmailsa, 0);
1055         }
1056
1057         /* Register DMA engine */
1058         dev_set_drvdata(dev, mdma);
1059         retval = dma_async_device_register(dma);
1060         if (retval)
1061                 goto err_free2;
1062
1063         /* Register with OF helpers for DMA lookups (nonfatal) */
1064         if (dev->of_node) {
1065                 retval = of_dma_controller_register(dev->of_node,
1066                                                 of_dma_xlate_by_chan_id, mdma);
1067                 if (retval)
1068                         dev_warn(dev, "Could not register for OF lookup\n");
1069         }
1070
1071         return 0;
1072
1073 err_free2:
1074         if (mdma->is_mpc8308)
1075                 free_irq(mdma->irq2, mdma);
1076 err_free1:
1077         free_irq(mdma->irq, mdma);
1078 err_dispose2:
1079         if (mdma->is_mpc8308)
1080                 irq_dispose_mapping(mdma->irq2);
1081 err_dispose1:
1082         irq_dispose_mapping(mdma->irq);
1083 err:
1084         return retval;
1085 }
1086
1087 static int mpc_dma_remove(struct platform_device *op)
1088 {
1089         struct device *dev = &op->dev;
1090         struct mpc_dma *mdma = dev_get_drvdata(dev);
1091
1092         if (dev->of_node)
1093                 of_dma_controller_free(dev->of_node);
1094         dma_async_device_unregister(&mdma->dma);
1095         if (mdma->is_mpc8308) {
1096                 free_irq(mdma->irq2, mdma);
1097                 irq_dispose_mapping(mdma->irq2);
1098         }
1099         free_irq(mdma->irq, mdma);
1100         irq_dispose_mapping(mdma->irq);
1101         tasklet_kill(&mdma->tasklet);
1102
1103         return 0;
1104 }
1105
1106 static const struct of_device_id mpc_dma_match[] = {
1107         { .compatible = "fsl,mpc5121-dma", },
1108         { .compatible = "fsl,mpc8308-dma", },
1109         {},
1110 };
1111 MODULE_DEVICE_TABLE(of, mpc_dma_match);
1112
1113 static struct platform_driver mpc_dma_driver = {
1114         .probe          = mpc_dma_probe,
1115         .remove         = mpc_dma_remove,
1116         .driver = {
1117                 .name = DRV_NAME,
1118                 .of_match_table = mpc_dma_match,
1119         },
1120 };
1121
1122 module_platform_driver(mpc_dma_driver);
1123
1124 MODULE_LICENSE("GPL");
1125 MODULE_AUTHOR("Piotr Ziecik <kosmo@semihalf.com>");