drivers/dma/bcm2835-dma.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * BCM2835 DMA engine support
   4  *
   5  * Author:      Florian Meier <florian.meier@koalo.de>
   6  *              Copyright 2013
   7  *
   8  * Based on
   9  *      OMAP DMAengine support by Russell King
  10  *
  11  *      BCM2708 DMA Driver
  12  *      Copyright (C) 2010 Broadcom
  13  *
  14  *      Raspberry Pi PCM I2S ALSA Driver
  15  *      Copyright (c) by Phil Poole 2013
  16  *
  17  *      MARVELL MMP Peripheral DMA Driver
  18  *      Copyright 2012 Marvell International Ltd.
  19  */
  20 #include <linux/dmaengine.h>
  21 #include <linux/dma-mapping.h>
  22 #include <linux/dmapool.h>
  23 #include <linux/err.h>
  24 #include <linux/init.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/list.h>
  27 #include <linux/module.h>
  28 #include <linux/platform_data/dma-bcm2708.h>
  29 #include <linux/platform_device.h>
  30 #include <linux/slab.h>
  31 #include <linux/io.h>
  32 #include <linux/spinlock.h>
  33 #include <linux/of.h>
  34 #include <linux/of_dma.h>
  35
  36 #include "virt-dma.h"
  37
  38 #define BCM2835_DMA_MAX_DMA_CHAN_SUPPORTED 14
  39 #define BCM2835_DMA_CHAN_NAME_SIZE 8
  40 #define BCM2835_DMA_BULK_MASK  BIT(0)
  41 #define BCM2711_DMA_MEMCPY_CHAN 14
  42
  43 struct bcm2835_dma_cfg_data {
  44         u64     dma_mask;
  45         u32     chan_40bit_mask;
  46 };
  47
  48 /**
  49  * struct bcm2835_dmadev - BCM2835 DMA controller
  50  * @ddev: DMA device
  51  * @base: base address of register map
  52  * @zero_page: bus address of zero page (to detect transactions copying from
  53  *      zero page and avoid accessing memory if so)
  54  */
  55 struct bcm2835_dmadev {
  56         struct dma_device ddev;
  57         void __iomem *base;
  58         dma_addr_t zero_page;
  59         const struct bcm2835_dma_cfg_data *cfg_data;
  60 };
  61
  62 struct bcm2835_dma_cb {
  63         uint32_t info;
  64         uint32_t src;
  65         uint32_t dst;
  66         uint32_t length;
  67         uint32_t stride;
  68         uint32_t next;
  69         uint32_t pad[2];
  70 };
  71
  72 struct bcm2711_dma40_scb {
  73         uint32_t ti;
  74         uint32_t src;
  75         uint32_t srci;
  76         uint32_t dst;
  77         uint32_t dsti;
  78         uint32_t len;
  79         uint32_t next_cb;
  80         uint32_t rsvd;
  81 };
  82
  83 struct bcm2835_cb_entry {
  84         struct bcm2835_dma_cb *cb;
  85         dma_addr_t paddr;
  86 };
  87
  88 struct bcm2835_chan {
  89         struct virt_dma_chan vc;
  90
  91         struct dma_slave_config cfg;
  92         unsigned int dreq;
  93
  94         int ch;
  95         struct bcm2835_desc *desc;
  96         struct dma_pool *cb_pool;
  97
  98         void __iomem *chan_base;
  99         int irq_number;
 100         unsigned int irq_flags;
 101
 102         bool is_lite_channel;
 103         bool is_40bit_channel;
 104 };
 105
 106 struct bcm2835_desc {
 107         struct bcm2835_chan *c;
 108         struct virt_dma_desc vd;
 109         enum dma_transfer_direction dir;
 110
 111         unsigned int frames;
 112         size_t size;
 113
 114         bool cyclic;
 115
 116         struct bcm2835_cb_entry cb_list[];
 117 };
 118
 119 #define BCM2835_DMA_CS          0x00
 120 #define BCM2835_DMA_ADDR        0x04
 121 #define BCM2835_DMA_TI          0x08
 122 #define BCM2835_DMA_SOURCE_AD   0x0c
 123 #define BCM2835_DMA_DEST_AD     0x10
 124 #define BCM2835_DMA_LEN         0x14
 125 #define BCM2835_DMA_STRIDE      0x18
 126 #define BCM2835_DMA_NEXTCB      0x1c
 127 #define BCM2835_DMA_DEBUG       0x20
 128
 129 /* DMA CS Control and Status bits */
 130 #define BCM2835_DMA_ACTIVE      BIT(0)  /* activate the DMA */
 131 #define BCM2835_DMA_END         BIT(1)  /* current CB has ended */
 132 #define BCM2835_DMA_INT         BIT(2)  /* interrupt status */
 133 #define BCM2835_DMA_DREQ        BIT(3)  /* DREQ state */
 134 #define BCM2835_DMA_ISPAUSED    BIT(4)  /* Pause requested or not active */
 135 #define BCM2835_DMA_ISHELD      BIT(5)  /* Is held by DREQ flow control */
 136 #define BCM2835_DMA_WAITING_FOR_WRITES BIT(6) /* waiting for last
 137                                                * AXI-write to ack
 138                                                */
 139 #define BCM2835_DMA_ERR         BIT(8)
 140 #define BCM2835_DMA_PRIORITY(x) ((x & 15) << 16) /* AXI priority */
 141 #define BCM2835_DMA_PANIC_PRIORITY(x) ((x & 15) << 20) /* panic priority */
 142 /* current value of TI.BCM2835_DMA_WAIT_RESP */
 143 #define BCM2835_DMA_WAIT_FOR_WRITES BIT(28)
 144 #define BCM2835_DMA_DIS_DEBUG   BIT(29) /* disable debug pause signal */
 145 #define BCM2835_DMA_ABORT       BIT(30) /* Stop current CB, go to next, WO */
 146 #define BCM2835_DMA_RESET       BIT(31) /* WO, self clearing */
 147
 148 /* Transfer information bits - also bcm2835_cb.info field */
 149 #define BCM2835_DMA_INT_EN      BIT(0)
 150 #define BCM2835_DMA_TDMODE      BIT(1) /* 2D-Mode */
 151 #define BCM2835_DMA_WAIT_RESP   BIT(3) /* wait for AXI-write to be acked */
 152 #define BCM2835_DMA_D_INC       BIT(4)
 153 #define BCM2835_DMA_D_WIDTH     BIT(5) /* 128bit writes if set */
 154 #define BCM2835_DMA_D_DREQ      BIT(6) /* enable DREQ for destination */
 155 #define BCM2835_DMA_D_IGNORE    BIT(7) /* ignore destination writes */
 156 #define BCM2835_DMA_S_INC       BIT(8)
 157 #define BCM2835_DMA_S_WIDTH     BIT(9) /* 128bit writes if set */
 158 #define BCM2835_DMA_S_DREQ      BIT(10) /* enable SREQ for source */
 159 #define BCM2835_DMA_S_IGNORE    BIT(11) /* ignore source reads - read 0 */
 160 #define BCM2835_DMA_BURST_LENGTH(x) ((x & 15) << 12)
 161 #define BCM2835_DMA_CS_FLAGS(x) (x & (BCM2835_DMA_PRIORITY(15) | \
 162                                       BCM2835_DMA_PANIC_PRIORITY(15) | \
 163                                       BCM2835_DMA_WAIT_FOR_WRITES | \
 164                                       BCM2835_DMA_DIS_DEBUG))
 165 #define BCM2835_DMA_PER_MAP(x)  ((x & 31) << 16) /* REQ source */
 166 #define BCM2835_DMA_WAIT(x)     ((x & 31) << 21) /* add DMA-wait cycles */
 167 #define BCM2835_DMA_NO_WIDE_BURSTS BIT(26) /* no 2 beat write bursts */
 168
 169 /* A fake bit to request that the driver doesn't set the WAIT_RESP bit. */
 170 #define BCM2835_DMA_NO_WAIT_RESP BIT(27)
 171 #define WAIT_RESP(x) ((x & BCM2835_DMA_NO_WAIT_RESP) ? \
 172                       0 : BCM2835_DMA_WAIT_RESP)
 173
 174 /* A fake bit to request that the driver requires wide reads */
 175 #define BCM2835_DMA_WIDE_SOURCE BIT(24)
 176 #define WIDE_SOURCE(x) ((x & BCM2835_DMA_WIDE_SOURCE) ? \
 177                       BCM2835_DMA_S_WIDTH : 0)
 178
 179 /* A fake bit to request that the driver requires wide writes */
 180 #define BCM2835_DMA_WIDE_DEST BIT(25)
 181 #define WIDE_DEST(x) ((x & BCM2835_DMA_WIDE_DEST) ? \
 182                       BCM2835_DMA_D_WIDTH : 0)
 183
 184
 185 /* debug register bits */
 186 #define BCM2835_DMA_DEBUG_LAST_NOT_SET_ERR      BIT(0)
 187 #define BCM2835_DMA_DEBUG_FIFO_ERR              BIT(1)
 188 #define BCM2835_DMA_DEBUG_READ_ERR              BIT(2)
 189 #define BCM2835_DMA_DEBUG_OUTSTANDING_WRITES_SHIFT 4
 190 #define BCM2835_DMA_DEBUG_OUTSTANDING_WRITES_BITS 4
 191 #define BCM2835_DMA_DEBUG_ID_SHIFT              16
 192 #define BCM2835_DMA_DEBUG_ID_BITS               9
 193 #define BCM2835_DMA_DEBUG_STATE_SHIFT           16
 194 #define BCM2835_DMA_DEBUG_STATE_BITS            9
 195 #define BCM2835_DMA_DEBUG_VERSION_SHIFT         25
 196 #define BCM2835_DMA_DEBUG_VERSION_BITS          3
 197 #define BCM2835_DMA_DEBUG_LITE                  BIT(28)
 198
 199 /* shared registers for all dma channels */
 200 #define BCM2835_DMA_INT_STATUS         0xfe0
 201 #define BCM2835_DMA_ENABLE             0xff0
 202
 203 #define BCM2835_DMA_DATA_TYPE_S8        1
 204 #define BCM2835_DMA_DATA_TYPE_S16       2
 205 #define BCM2835_DMA_DATA_TYPE_S32       4
 206 #define BCM2835_DMA_DATA_TYPE_S128      16
 207
 208 /* Valid only for channels 0 - 14, 15 has its own base address */
 209 #define BCM2835_DMA_CHAN_SIZE   0x100
 210 #define BCM2835_DMA_CHAN(n)     ((n) * BCM2835_DMA_CHAN_SIZE) /* Base address */
 211 #define BCM2835_DMA_CHANIO(base, n) ((base) + BCM2835_DMA_CHAN(n))
 212
 213 /* the max dma length for different channels */
 214 #define MAX_DMA_LEN SZ_1G
 215 #define MAX_LITE_DMA_LEN (SZ_64K - 4)
 216
 217 /* 40-bit DMA support */
 218 #define BCM2711_DMA40_CS        0x00
 219 #define BCM2711_DMA40_CB        0x04
 220 #define BCM2711_DMA40_DEBUG     0x0c
 221 #define BCM2711_DMA40_TI        0x10
 222 #define BCM2711_DMA40_SRC       0x14
 223 #define BCM2711_DMA40_SRCI      0x18
 224 #define BCM2711_DMA40_DEST      0x1c
 225 #define BCM2711_DMA40_DESTI     0x20
 226 #define BCM2711_DMA40_LEN       0x24
 227 #define BCM2711_DMA40_NEXT_CB   0x28
 228 #define BCM2711_DMA40_DEBUG2    0x2c
 229
 230 #define BCM2711_DMA40_ACTIVE            BIT(0)
 231 #define BCM2711_DMA40_END               BIT(1)
 232 #define BCM2711_DMA40_INT               BIT(2)
 233 #define BCM2711_DMA40_DREQ              BIT(3)  /* DREQ state */
 234 #define BCM2711_DMA40_RD_PAUSED         BIT(4)  /* Reading is paused */
 235 #define BCM2711_DMA40_WR_PAUSED         BIT(5)  /* Writing is paused */
 236 #define BCM2711_DMA40_DREQ_PAUSED       BIT(6)  /* Is paused by DREQ flow control */
 237 #define BCM2711_DMA40_WAITING_FOR_WRITES BIT(7)  /* Waiting for last write */
 238 #define BCM2711_DMA40_ERR               BIT(10)
 239 #define BCM2711_DMA40_QOS(x)            (((x) & 0x1f) << 16)
 240 #define BCM2711_DMA40_PANIC_QOS(x)      (((x) & 0x1f) << 20)
 241 #define BCM2711_DMA40_WAIT_FOR_WRITES   BIT(28)
 242 #define BCM2711_DMA40_DISDEBUG          BIT(29)
 243 #define BCM2711_DMA40_ABORT             BIT(30)
 244 #define BCM2711_DMA40_HALT              BIT(31)
 245 #define BCM2711_DMA40_CS_FLAGS(x) (x & (BCM2711_DMA40_QOS(15) | \
 246                                         BCM2711_DMA40_PANIC_QOS(15) | \
 247                                         BCM2711_DMA40_WAIT_FOR_WRITES | \
 248                                         BCM2711_DMA40_DISDEBUG))
 249
 250 /* Transfer information bits */
 251 #define BCM2711_DMA40_INTEN             BIT(0)
 252 #define BCM2711_DMA40_TDMODE            BIT(1) /* 2D-Mode */
 253 #define BCM2711_DMA40_WAIT_RESP         BIT(2) /* wait for AXI write to be acked */
 254 #define BCM2711_DMA40_WAIT_RD_RESP      BIT(3) /* wait for AXI read to complete */
 255 #define BCM2711_DMA40_PER_MAP(x)        ((x & 31) << 9) /* REQ source */
 256 #define BCM2711_DMA40_S_DREQ            BIT(14) /* enable SREQ for source */
 257 #define BCM2711_DMA40_D_DREQ            BIT(15) /* enable DREQ for destination */
 258 #define BCM2711_DMA40_S_WAIT(x)         ((x & 0xff) << 16) /* add DMA read-wait cycles */
 259 #define BCM2711_DMA40_D_WAIT(x)         ((x & 0xff) << 24) /* add DMA write-wait cycles */
 260
 261 /* debug register bits */
 262 #define BCM2711_DMA40_DEBUG_WRITE_ERR           BIT(0)
 263 #define BCM2711_DMA40_DEBUG_FIFO_ERR            BIT(1)
 264 #define BCM2711_DMA40_DEBUG_READ_ERR            BIT(2)
 265 #define BCM2711_DMA40_DEBUG_READ_CB_ERR         BIT(3)
 266 #define BCM2711_DMA40_DEBUG_IN_ON_ERR           BIT(8)
 267 #define BCM2711_DMA40_DEBUG_ABORT_ON_ERR        BIT(9)
 268 #define BCM2711_DMA40_DEBUG_HALT_ON_ERR         BIT(10)
 269 #define BCM2711_DMA40_DEBUG_DISABLE_CLK_GATE    BIT(11)
 270 #define BCM2711_DMA40_DEBUG_RSTATE_SHIFT        14
 271 #define BCM2711_DMA40_DEBUG_RSTATE_BITS         4
 272 #define BCM2711_DMA40_DEBUG_WSTATE_SHIFT        18
 273 #define BCM2711_DMA40_DEBUG_WSTATE_BITS         4
 274 #define BCM2711_DMA40_DEBUG_RESET               BIT(23)
 275 #define BCM2711_DMA40_DEBUG_ID_SHIFT            24
 276 #define BCM2711_DMA40_DEBUG_ID_BITS             4
 277 #define BCM2711_DMA40_DEBUG_VERSION_SHIFT       28
 278 #define BCM2711_DMA40_DEBUG_VERSION_BITS        4
 279
 280 /* Valid only for channels 0 - 3 (11 - 14) */
 281 #define BCM2711_DMA40_CHAN(n)   (((n) + 11) << 8) /* Base address */
 282 #define BCM2711_DMA40_CHANIO(base, n) ((base) + BCM2711_DMA_CHAN(n))
 283
 284 /* the max dma length for different channels */
 285 #define MAX_DMA40_LEN SZ_1G
 286
 287 #define BCM2711_DMA40_BURST_LEN(x)      ((min(x,16) - 1) << 8)
 288 #define BCM2711_DMA40_INC               BIT(12)
 289 #define BCM2711_DMA40_SIZE_32           (0 << 13)
 290 #define BCM2711_DMA40_SIZE_64           (1 << 13)
 291 #define BCM2711_DMA40_SIZE_128          (2 << 13)
 292 #define BCM2711_DMA40_SIZE_256          (3 << 13)
 293 #define BCM2711_DMA40_IGNORE            BIT(15)
 294 #define BCM2711_DMA40_STRIDE(x)         ((x) << 16) /* For 2D mode */
 295
 296 #define BCM2711_DMA40_MEMCPY_FLAGS \
 297         (BCM2711_DMA40_QOS(0) | \
 298          BCM2711_DMA40_PANIC_QOS(0) | \
 299          BCM2711_DMA40_WAIT_FOR_WRITES | \
 300          BCM2711_DMA40_DISDEBUG)
 301
 302 #define BCM2711_DMA40_MEMCPY_XFER_INFO \
 303         (BCM2711_DMA40_SIZE_128 | \
 304          BCM2711_DMA40_INC | \
 305          BCM2711_DMA40_BURST_LEN(16))
 306
 307 struct bcm2835_dmadev *memcpy_parent;
 308 static void __iomem *memcpy_chan;
 309 static struct bcm2711_dma40_scb *memcpy_scb;
 310 static dma_addr_t memcpy_scb_dma;
 311 DEFINE_SPINLOCK(memcpy_lock);
 312
 313 static const struct bcm2835_dma_cfg_data bcm2835_dma_cfg = {
 314         .chan_40bit_mask = 0,
 315         .dma_mask = DMA_BIT_MASK(32),
 316 };
 317
 318 static const struct bcm2835_dma_cfg_data bcm2711_dma_cfg = {
 319         .chan_40bit_mask = BIT(11) | BIT(12) | BIT(13) | BIT(14),
 320         .dma_mask = DMA_BIT_MASK(36),
 321 };
 322
 323 static inline size_t bcm2835_dma_max_frame_length(struct bcm2835_chan *c)
 324 {
 325         /* lite and normal channels have different max frame length */
 326         return c->is_lite_channel ? MAX_LITE_DMA_LEN : MAX_DMA_LEN;
 327 }
 328
 329 /* how many frames of max_len size do we need to transfer len bytes */
 330 static inline size_t bcm2835_dma_frames_for_length(size_t len,
 331                                                    size_t max_len)
 332 {
 333         return DIV_ROUND_UP(len, max_len);
 334 }
 335
 336 static inline struct bcm2835_dmadev *to_bcm2835_dma_dev(struct dma_device *d)
 337 {
 338         return container_of(d, struct bcm2835_dmadev, ddev);
 339 }
 340
 341 static inline struct bcm2835_chan *to_bcm2835_dma_chan(struct dma_chan *c)
 342 {
 343         return container_of(c, struct bcm2835_chan, vc.chan);
 344 }
 345
 346 static inline struct bcm2835_desc *to_bcm2835_dma_desc(
 347                 struct dma_async_tx_descriptor *t)
 348 {
 349         return container_of(t, struct bcm2835_desc, vd.tx);
 350 }
 351
 352 static inline uint32_t to_bcm2711_ti(uint32_t info)
 353 {
 354         return ((info & BCM2835_DMA_INT_EN) ? BCM2711_DMA40_INTEN : 0) |
 355                 ((info & BCM2835_DMA_WAIT_RESP) ? BCM2711_DMA40_WAIT_RESP : 0) |
 356                 ((info & BCM2835_DMA_S_DREQ) ?
 357                  (BCM2711_DMA40_S_DREQ | BCM2711_DMA40_WAIT_RD_RESP) : 0) |
 358                 ((info & BCM2835_DMA_D_DREQ) ? BCM2711_DMA40_D_DREQ : 0) |
 359                 BCM2711_DMA40_PER_MAP((info >> 16) & 0x1f);
 360 }
 361
 362 static inline uint32_t to_bcm2711_srci(uint32_t info)
 363 {
 364         return ((info & BCM2835_DMA_S_INC) ? BCM2711_DMA40_INC : 0);
 365 }
 366
 367 static inline uint32_t to_bcm2711_dsti(uint32_t info)
 368 {
 369         return ((info & BCM2835_DMA_D_INC) ? BCM2711_DMA40_INC : 0);
 370 }
 371
 372 static inline uint32_t to_bcm2711_cbaddr(dma_addr_t addr)
 373 {
 374         BUG_ON(addr & 0x1f);
 375         return (addr >> 5);
 376 }
 377
 378 static void bcm2835_dma_free_cb_chain(struct bcm2835_desc *desc)
 379 {
 380         size_t i;
 381
 382         for (i = 0; i < desc->frames; i++)
 383                 dma_pool_free(desc->c->cb_pool, desc->cb_list[i].cb,
 384                               desc->cb_list[i].paddr);
 385
 386         kfree(desc);
 387 }
 388
 389 static void bcm2835_dma_desc_free(struct virt_dma_desc *vd)
 390 {
 391         bcm2835_dma_free_cb_chain(
 392                 container_of(vd, struct bcm2835_desc, vd));
 393 }
 394
 395 static void bcm2835_dma_create_cb_set_length(
 396         struct bcm2835_chan *c,
 397         struct bcm2835_dma_cb *control_block,
 398         size_t len,
 399         size_t period_len,
 400         size_t *total_len,
 401         u32 finalextrainfo)
 402 {
 403         size_t max_len = bcm2835_dma_max_frame_length(c);
 404         uint32_t cb_len;
 405
 406         /* set the length taking lite-channel limitations into account */
 407         cb_len = min_t(u32, len, max_len);
 408
 409         if (period_len) {
 410                 /*
 411                  * period_len means: that we need to generate
 412                  * transfers that are terminating at every
 413                  * multiple of period_len - this is typically
 414                  * used to set the interrupt flag in info
 415                  * which is required during cyclic transfers
 416                  */
 417
 418                 /* have we filled in period_length yet? */
 419                 if (*total_len + cb_len < period_len) {
 420                         /* update number of bytes in this period so far */
 421                         *total_len += cb_len;
 422                 } else {
 423                         /* calculate the length that remains to reach period_len */
 424                         cb_len = period_len - *total_len;
 425
 426                         /* reset total_length for next period */
 427                         *total_len = 0;
 428                 }
 429         }
 430
 431         if (c->is_40bit_channel) {
 432                 struct bcm2711_dma40_scb *scb =
 433                         (struct bcm2711_dma40_scb *)control_block;
 434
 435                 scb->len = cb_len;
 436                 /* add extrainfo bits to ti */
 437                 scb->ti |= to_bcm2711_ti(finalextrainfo);
 438         } else {
 439                 control_block->length = cb_len;
 440                 /* add extrainfo bits to info */
 441                 control_block->info |= finalextrainfo;
 442         }
 443 }
 444
 445 static inline size_t bcm2835_dma_count_frames_for_sg(
 446         struct bcm2835_chan *c,
 447         struct scatterlist *sgl,
 448         unsigned int sg_len)
 449 {
 450         size_t frames = 0;
 451         struct scatterlist *sgent;
 452         unsigned int i;
 453         size_t plength = bcm2835_dma_max_frame_length(c);
 454
 455         for_each_sg(sgl, sgent, sg_len, i)
 456                 frames += bcm2835_dma_frames_for_length(
 457                         sg_dma_len(sgent), plength);
 458
 459         return frames;
 460 }
 461
 462 /**
 463  * bcm2835_dma_create_cb_chain - create a control block and fills data in
 464  *
 465  * @c:              the @bcm2835_chan for which we run this
 466  * @direction:      the direction in which we transfer
 467  * @cyclic:         it is a cyclic transfer
 468  * @info:           the default info bits to apply per controlblock
 469  * @frames:         number of controlblocks to allocate
 470  * @src:            the src address to assign (if the S_INC bit is set
 471  *                  in @info, then it gets incremented)
 472  * @dst:            the dst address to assign (if the D_INC bit is set
 473  *                  in @info, then it gets incremented)
 474  * @buf_len:        the full buffer length (may also be 0)
 475  * @period_len:     the period length when to apply @finalextrainfo
 476  *                  in addition to the last transfer
 477  *                  this will also break some control-blocks early
 478  * @finalextrainfo: additional bits in last controlblock
 479  *                  (or when period_len is reached in case of cyclic)
 480  * @gfp:            the GFP flag to use for allocation
 481  */
 482 static struct bcm2835_desc *bcm2835_dma_create_cb_chain(
 483         struct bcm2835_chan *c, enum dma_transfer_direction direction,
 484         bool cyclic, u32 info, u32 finalextrainfo, size_t frames,
 485         dma_addr_t src, dma_addr_t dst, size_t buf_len,
 486         size_t period_len, gfp_t gfp)
 487 {
 488         size_t len = buf_len, total_len;
 489         size_t frame;
 490         struct bcm2835_desc *d;
 491         struct bcm2835_cb_entry *cb_entry;
 492         struct bcm2835_dma_cb *control_block;
 493
 494         if (!frames)
 495                 return NULL;
 496
 497         /* allocate and setup the descriptor. */
 498         d = kzalloc(struct_size(d, cb_list, frames), gfp);
 499         if (!d)
 500                 return NULL;
 501
 502         d->c = c;
 503         d->dir = direction;
 504         d->cyclic = cyclic;
 505
 506         /*
 507          * Iterate over all frames, create a control block
 508          * for each frame and link them together.
 509          */
 510         for (frame = 0, total_len = 0; frame < frames; d->frames++, frame++) {
 511                 cb_entry = &d->cb_list[frame];
 512                 cb_entry->cb = dma_pool_alloc(c->cb_pool, gfp,
 513                                               &cb_entry->paddr);
 514                 if (!cb_entry->cb)
 515                         goto error_cb;
 516
 517                 /* fill in the control block */
 518                 control_block = cb_entry->cb;
 519                 if (c->is_40bit_channel) {
 520                         struct bcm2711_dma40_scb *scb =
 521                                 (struct bcm2711_dma40_scb *)control_block;
 522                         scb->ti = to_bcm2711_ti(info);
 523                         scb->src = lower_32_bits(src);
 524                         scb->srci= upper_32_bits(src) | to_bcm2711_srci(info);
 525                         scb->dst = lower_32_bits(dst);
 526                         scb->dsti = upper_32_bits(dst) | to_bcm2711_dsti(info);
 527                         scb->next_cb = 0;
 528                 } else {
 529                         control_block->info = info;
 530                         control_block->src = src;
 531                         control_block->dst = dst;
 532                         control_block->stride = 0;
 533                         control_block->next = 0;
 534                 }
 535
 536                 /* set up length in control_block if requested */
 537                 if (buf_len) {
 538                         /* calculate length honoring period_length */
 539                         bcm2835_dma_create_cb_set_length(
 540                                 c, control_block,
 541                                 len, period_len, &total_len,
 542                                 cyclic ? finalextrainfo : 0);
 543
 544                         /* calculate new remaining length */
 545                         len -= control_block->length;
 546                 }
 547
 548                 /* link this the last controlblock */
 549                 if (frame && c->is_40bit_channel)
 550                         ((struct bcm2711_dma40_scb *)
 551                          d->cb_list[frame - 1].cb)->next_cb =
 552                                 to_bcm2711_cbaddr(cb_entry->paddr);
 553                 if (frame && !c->is_40bit_channel)
 554                         d->cb_list[frame - 1].cb->next = cb_entry->paddr;
 555
 556                 /* update src and dst and length */
 557                 if (src && (info & BCM2835_DMA_S_INC))
 558                         src += control_block->length;
 559                 if (dst && (info & BCM2835_DMA_D_INC))
 560                         dst += control_block->length;
 561
 562                 /* Length of total transfer */
 563                 if (c->is_40bit_channel)
 564                         d->size += ((struct bcm2711_dma40_scb *)control_block)->len;
 565                 else
 566                         d->size += control_block->length;
 567         }
 568
 569         /* the last frame requires extra flags */
 570         if (c->is_40bit_channel) {
 571                 struct bcm2711_dma40_scb *scb =
 572                         (struct bcm2711_dma40_scb *)d->cb_list[d->frames-1].cb;
 573
 574                 scb->ti |= to_bcm2711_ti(finalextrainfo);
 575         } else {
 576                 d->cb_list[d->frames - 1].cb->info |= finalextrainfo;
 577         }
 578
 579         /* detect a size missmatch */
 580         if (buf_len && (d->size != buf_len))
 581                 goto error_cb;
 582
 583         return d;
 584 error_cb:
 585         bcm2835_dma_free_cb_chain(d);
 586
 587         return NULL;
 588 }
 589
 590 static void bcm2835_dma_fill_cb_chain_with_sg(
 591         struct bcm2835_chan *c,
 592         enum dma_transfer_direction direction,
 593         struct bcm2835_cb_entry *cb,
 594         struct scatterlist *sgl,
 595         unsigned int sg_len)
 596 {
 597         size_t len, max_len;
 598         unsigned int i;
 599         dma_addr_t addr;
 600         struct scatterlist *sgent;
 601
 602         max_len = bcm2835_dma_max_frame_length(c);
 603         for_each_sg(sgl, sgent, sg_len, i) {
 604                 if (c->is_40bit_channel) {
 605                         struct bcm2711_dma40_scb *scb;
 606
 607                         for (addr = sg_dma_address(sgent),
 608                                      len = sg_dma_len(sgent);
 609                                      len > 0;
 610                              addr += scb->len, len -= scb->len, cb++) {
 611                                 scb = (struct bcm2711_dma40_scb *)cb->cb;
 612                                 if (direction == DMA_DEV_TO_MEM) {
 613                                         scb->dst = lower_32_bits(addr);
 614                                         scb->dsti = upper_32_bits(addr) | BCM2711_DMA40_INC;
 615                                 } else {
 616                                         scb->src = lower_32_bits(addr);
 617                                         scb->srci = upper_32_bits(addr) | BCM2711_DMA40_INC;
 618                                 }
 619                                 scb->len = min(len, max_len);
 620                         }
 621                 } else {
 622                         for (addr = sg_dma_address(sgent),
 623                                      len = sg_dma_len(sgent);
 624                              len > 0;
 625                              addr += cb->cb->length, len -= cb->cb->length,
 626                              cb++) {
 627                                 if (direction == DMA_DEV_TO_MEM)
 628                                         cb->cb->dst = addr;
 629                                 else
 630                                         cb->cb->src = addr;
 631                                 cb->cb->length = min(len, max_len);
 632                         }
 633                 }
 634         }
 635 }
 636
 637 static void bcm2835_dma_abort(struct bcm2835_chan *c)
 638 {
 639         void __iomem *chan_base = c->chan_base;
 640         long int timeout = 10000;
 641         u32 wait_mask = BCM2835_DMA_WAITING_FOR_WRITES;
 642
 643         if (c->is_40bit_channel)
 644                 wait_mask = BCM2711_DMA40_WAITING_FOR_WRITES;
 645
 646         /*
 647          * A zero control block address means the channel is idle.
 648          * (The ACTIVE flag in the CS register is not a reliable indicator.)
 649          */
 650         if (!readl(chan_base + BCM2835_DMA_ADDR))
 651                 return;
 652
 653         /* Write 0 to the active bit - Pause the DMA */
 654         writel(0, chan_base + BCM2835_DMA_CS);
 655
 656         /* Wait for any current AXI transfer to complete */
 657         while ((readl(chan_base + BCM2835_DMA_CS) & wait_mask) && --timeout)
 658                 cpu_relax();
 659
 660         /* Peripheral might be stuck and fail to signal AXI write responses */
 661         if (!timeout)
 662                 dev_err(c->vc.chan.device->dev,
 663                         "failed to complete outstanding writes\n");
 664
 665         writel(BCM2835_DMA_RESET, chan_base + BCM2835_DMA_CS);
 666 }
 667
 668 static void bcm2835_dma_start_desc(struct bcm2835_chan *c)
 669 {
 670         struct virt_dma_desc *vd = vchan_next_desc(&c->vc);
 671         struct bcm2835_desc *d;
 672
 673         if (!vd) {
 674                 c->desc = NULL;
 675                 return;
 676         }
 677
 678         list_del(&vd->node);
 679
 680         c->desc = d = to_bcm2835_dma_desc(&vd->tx);
 681
 682         if (c->is_40bit_channel) {
 683                 writel(to_bcm2711_cbaddr(d->cb_list[0].paddr),
 684                        c->chan_base + BCM2711_DMA40_CB);
 685                 writel(BCM2711_DMA40_ACTIVE | BCM2711_DMA40_CS_FLAGS(c->dreq),
 686                        c->chan_base + BCM2711_DMA40_CS);
 687         } else {
 688                 writel(d->cb_list[0].paddr, c->chan_base + BCM2835_DMA_ADDR);
 689                 writel(BCM2835_DMA_ACTIVE | BCM2835_DMA_CS_FLAGS(c->dreq),
 690                        c->chan_base + BCM2835_DMA_CS);
 691         }
 692 }
 693
 694 static irqreturn_t bcm2835_dma_callback(int irq, void *data)
 695 {
 696         struct bcm2835_chan *c = data;
 697         struct bcm2835_desc *d;
 698         unsigned long flags;
 699
 700         /* check the shared interrupt */
 701         if (c->irq_flags & IRQF_SHARED) {
 702                 /* check if the interrupt is enabled */
 703                 flags = readl(c->chan_base + BCM2835_DMA_CS);
 704                 /* if not set then we are not the reason for the irq */
 705                 if (!(flags & BCM2835_DMA_INT))
 706                         return IRQ_NONE;
 707         }
 708
 709         spin_lock_irqsave(&c->vc.lock, flags);
 710
 711         /*
 712          * Clear the INT flag to receive further interrupts. Keep the channel
 713          * active in case the descriptor is cyclic or in case the client has
 714          * already terminated the descriptor and issued a new one. (May happen
 715          * if this IRQ handler is threaded.) If the channel is finished, it
 716          * will remain idle despite the ACTIVE flag being set.
 717          */
 718         writel(BCM2835_DMA_INT | BCM2835_DMA_ACTIVE | BCM2835_DMA_CS_FLAGS(c->dreq),
 719                c->chan_base + BCM2835_DMA_CS);
 720
 721         d = c->desc;
 722
 723         if (d) {
 724                 if (d->cyclic) {
 725                         /* call the cyclic callback */
 726                         vchan_cyclic_callback(&d->vd);
 727                 } else if (!readl(c->chan_base + BCM2835_DMA_ADDR)) {
 728                         vchan_cookie_complete(&c->desc->vd);
 729                         bcm2835_dma_start_desc(c);
 730                 }
 731         }
 732
 733         spin_unlock_irqrestore(&c->vc.lock, flags);
 734
 735         return IRQ_HANDLED;
 736 }
 737
 738 static int bcm2835_dma_alloc_chan_resources(struct dma_chan *chan)
 739 {
 740         struct bcm2835_chan *c = to_bcm2835_dma_chan(chan);
 741         struct device *dev = c->vc.chan.device->dev;
 742
 743         dev_dbg(dev, "Allocating DMA channel %d\n", c->ch);
 744
 745         /*
 746          * Control blocks are 256 bit in length and must start at a 256 bit
 747          * (32 byte) aligned address (BCM2835 ARM Peripherals, sec. 4.2.1.1).
 748          */
 749         c->cb_pool = dma_pool_create(dev_name(dev), dev,
 750                                      sizeof(struct bcm2835_dma_cb), 32, 0);
 751         if (!c->cb_pool) {
 752                 dev_err(dev, "unable to allocate descriptor pool\n");
 753                 return -ENOMEM;
 754         }
 755
 756         return request_irq(c->irq_number, bcm2835_dma_callback,
 757                            c->irq_flags, "DMA IRQ", c);
 758 }
 759
 760 static void bcm2835_dma_free_chan_resources(struct dma_chan *chan)
 761 {
 762         struct bcm2835_chan *c = to_bcm2835_dma_chan(chan);
 763
 764         vchan_free_chan_resources(&c->vc);
 765         free_irq(c->irq_number, c);
 766         dma_pool_destroy(c->cb_pool);
 767
 768         dev_dbg(c->vc.chan.device->dev, "Freeing DMA channel %u\n", c->ch);
 769 }
 770
 771 static size_t bcm2835_dma_desc_size(struct bcm2835_desc *d)
 772 {
 773         return d->size;
 774 }
 775
 776 static size_t bcm2835_dma_desc_size_pos(struct bcm2835_desc *d, dma_addr_t addr)
 777 {
 778         unsigned int i;
 779         size_t size;
 780
 781         for (size = i = 0; i < d->frames; i++) {
 782                 struct bcm2835_dma_cb *control_block = d->cb_list[i].cb;
 783                 size_t this_size = control_block->length;
 784                 dma_addr_t dma;
 785
 786                 if (d->dir == DMA_DEV_TO_MEM)
 787                         dma = control_block->dst;
 788                 else
 789                         dma = control_block->src;
 790
 791                 if (size)
 792                         size += this_size;
 793                 else if (addr >= dma && addr < dma + this_size)
 794                         size += dma + this_size - addr;
 795         }
 796
 797         return size;
 798 }
 799
 800 static enum dma_status bcm2835_dma_tx_status(struct dma_chan *chan,
 801         dma_cookie_t cookie, struct dma_tx_state *txstate)
 802 {
 803         struct bcm2835_chan *c = to_bcm2835_dma_chan(chan);
 804         struct virt_dma_desc *vd;
 805         enum dma_status ret;
 806         unsigned long flags;
 807
 808         ret = dma_cookie_status(chan, cookie, txstate);
 809         if (ret == DMA_COMPLETE || !txstate)
 810                 return ret;
 811
 812         spin_lock_irqsave(&c->vc.lock, flags);
 813         vd = vchan_find_desc(&c->vc, cookie);
 814         if (vd) {
 815                 txstate->residue =
 816                         bcm2835_dma_desc_size(to_bcm2835_dma_desc(&vd->tx));
 817         } else if (c->desc && c->desc->vd.tx.cookie == cookie) {
 818                 struct bcm2835_desc *d = c->desc;
 819                 dma_addr_t pos;
 820
 821                 if (d->dir == DMA_MEM_TO_DEV && c->is_40bit_channel)
 822                         pos = readl(c->chan_base + BCM2711_DMA40_SRC) +
 823                                 ((readl(c->chan_base + BCM2711_DMA40_SRCI) &
 824                                   0xff) << 8);
 825                 else if (d->dir == DMA_MEM_TO_DEV && !c->is_40bit_channel)
 826                         pos = readl(c->chan_base + BCM2835_DMA_SOURCE_AD);
 827                 else if (d->dir == DMA_DEV_TO_MEM && c->is_40bit_channel)
 828                         pos = readl(c->chan_base + BCM2711_DMA40_DEST) +
 829                                 ((readl(c->chan_base + BCM2711_DMA40_DESTI) &
 830                                   0xff) << 8);
 831                 else if (d->dir == DMA_DEV_TO_MEM && !c->is_40bit_channel)
 832                         pos = readl(c->chan_base + BCM2835_DMA_DEST_AD);
 833                 else
 834                         pos = 0;
 835
 836                 txstate->residue = bcm2835_dma_desc_size_pos(d, pos);
 837         } else {
 838                 txstate->residue = 0;
 839         }
 840
 841         spin_unlock_irqrestore(&c->vc.lock, flags);
 842
 843         return ret;
 844 }
 845
 846 static void bcm2835_dma_issue_pending(struct dma_chan *chan)
 847 {
 848         struct bcm2835_chan *c = to_bcm2835_dma_chan(chan);
 849         unsigned long flags;
 850
 851         spin_lock_irqsave(&c->vc.lock, flags);
 852         if (vchan_issue_pending(&c->vc) && !c->desc)
 853                 bcm2835_dma_start_desc(c);
 854
 855         spin_unlock_irqrestore(&c->vc.lock, flags);
 856 }
 857
 858 static struct dma_async_tx_descriptor *bcm2835_dma_prep_dma_memcpy(
 859         struct dma_chan *chan, dma_addr_t dst, dma_addr_t src,
 860         size_t len, unsigned long flags)
 861 {
 862         struct bcm2835_chan *c = to_bcm2835_dma_chan(chan);
 863         struct bcm2835_desc *d;
 864         u32 info = BCM2835_DMA_D_INC | BCM2835_DMA_S_INC |
 865                    WIDE_SOURCE(c->dreq) | WIDE_DEST(c->dreq);
 866         u32 extra = BCM2835_DMA_INT_EN | WAIT_RESP(c->dreq);
 867         size_t max_len = bcm2835_dma_max_frame_length(c);
 868         size_t frames;
 869
 870         /* if src, dst or len is not given return with an error */
 871         if (!src || !dst || !len)
 872                 return NULL;
 873
 874         /* calculate number of frames */
 875         frames = bcm2835_dma_frames_for_length(len, max_len);
 876
 877         /* allocate the CB chain - this also fills in the pointers */
 878         d = bcm2835_dma_create_cb_chain(c, DMA_MEM_TO_MEM, false,
 879                                         info, extra, frames,
 880                                         src, dst, len, 0, GFP_KERNEL);
 881         if (!d)
 882                 return NULL;
 883
 884         return vchan_tx_prep(&c->vc, &d->vd, flags);
 885 }
 886
 887 static struct dma_async_tx_descriptor *bcm2835_dma_prep_slave_sg(
 888         struct dma_chan *chan,
 889         struct scatterlist *sgl, unsigned int sg_len,
 890         enum dma_transfer_direction direction,
 891         unsigned long flags, void *context)
 892 {
 893         struct bcm2835_chan *c = to_bcm2835_dma_chan(chan);
 894         struct bcm2835_desc *d;
 895         dma_addr_t src = 0, dst = 0;
 896         u32 info = WAIT_RESP(c->dreq) |
 897                    WIDE_SOURCE(c->dreq) | WIDE_DEST(c->dreq);
 898         u32 extra = BCM2835_DMA_INT_EN;
 899         size_t frames;
 900
 901         if (!is_slave_direction(direction)) {
 902                 dev_err(chan->device->dev,
 903                         "%s: bad direction?\n", __func__);
 904                 return NULL;
 905         }
 906
 907         if (c->dreq != 0)
 908                 info |= BCM2835_DMA_PER_MAP(c->dreq);
 909
 910         if (direction == DMA_DEV_TO_MEM) {
 911                 if (c->cfg.src_addr_width != DMA_SLAVE_BUSWIDTH_4_BYTES)
 912                         return NULL;
 913                 src = c->cfg.src_addr;
 914                 /*
 915                  * One would think it ought to be possible to get the physical
 916                  * to dma address mapping information from the dma-ranges DT
 917                  * property, but I've not found a way yet that doesn't involve
 918                  * open-coding the whole thing.
 919                  */
 920                 if (c->is_40bit_channel)
 921                     src |= 0x400000000ull;
 922                 info |= BCM2835_DMA_S_DREQ | BCM2835_DMA_D_INC;
 923         } else {
 924                 if (c->cfg.dst_addr_width != DMA_SLAVE_BUSWIDTH_4_BYTES)
 925                         return NULL;
 926                 dst = c->cfg.dst_addr;
 927                 if (c->is_40bit_channel)
 928                     dst |= 0x400000000ull;
 929                 info |= BCM2835_DMA_D_DREQ | BCM2835_DMA_S_INC;
 930         }
 931
 932         /* count frames in sg list */
 933         frames = bcm2835_dma_count_frames_for_sg(c, sgl, sg_len);
 934
 935         /* allocate the CB chain */
 936         d = bcm2835_dma_create_cb_chain(c, direction, false,
 937                                         info, extra,
 938                                         frames, src, dst, 0, 0,
 939                                         GFP_NOWAIT);
 940         if (!d)
 941                 return NULL;
 942
 943         /* fill in frames with scatterlist pointers */
 944         bcm2835_dma_fill_cb_chain_with_sg(c, direction, d->cb_list,
 945                                           sgl, sg_len);
 946
 947         return vchan_tx_prep(&c->vc, &d->vd, flags);
 948 }
 949
 950 static struct dma_async_tx_descriptor *bcm2835_dma_prep_dma_cyclic(
 951         struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,
 952         size_t period_len, enum dma_transfer_direction direction,
 953         unsigned long flags)
 954 {
 955         struct bcm2835_dmadev *od = to_bcm2835_dma_dev(chan->device);
 956         struct bcm2835_chan *c = to_bcm2835_dma_chan(chan);
 957         struct bcm2835_desc *d;
 958         dma_addr_t src, dst;
 959         u32 info = WAIT_RESP(c->dreq) | WIDE_SOURCE(c->dreq) | WIDE_DEST(c->dreq);
 960         u32 extra = 0;
 961         size_t max_len = bcm2835_dma_max_frame_length(c);
 962         size_t frames;
 963
 964         /* Grab configuration */
 965         if (!is_slave_direction(direction)) {
 966                 dev_err(chan->device->dev, "%s: bad direction?\n", __func__);
 967                 return NULL;
 968         }
 969
 970         if (!buf_len) {
 971                 dev_err(chan->device->dev,
 972                         "%s: bad buffer length (= 0)\n", __func__);
 973                 return NULL;
 974         }
 975
 976         if (flags & DMA_PREP_INTERRUPT)
 977                 extra |= BCM2835_DMA_INT_EN;
 978         else
 979                 period_len = buf_len;
 980
 981         /*
 982          * warn if buf_len is not a multiple of period_len - this may leed
 983          * to unexpected latencies for interrupts and thus audiable clicks
 984          */
 985         if (buf_len % period_len)
 986                 dev_warn_once(chan->device->dev,
 987                               "%s: buffer_length (%zd) is not a multiple of period_len (%zd)\n",
 988                               __func__, buf_len, period_len);
 989
 990         /* Setup DREQ channel */
 991         if (c->dreq != 0)
 992                 info |= BCM2835_DMA_PER_MAP(c->dreq);
 993
 994         if (direction == DMA_DEV_TO_MEM) {
 995                 if (c->cfg.src_addr_width != DMA_SLAVE_BUSWIDTH_4_BYTES)
 996                         return NULL;
 997                 src = c->cfg.src_addr;
 998                 if (c->is_40bit_channel)
 999                     src |= 0x400000000ull;
1000                 dst = buf_addr;
1001                 info |= BCM2835_DMA_S_DREQ | BCM2835_DMA_D_INC;
1002         } else {
1003                 if (c->cfg.dst_addr_width != DMA_SLAVE_BUSWIDTH_4_BYTES)
1004                         return NULL;
1005                 dst = c->cfg.dst_addr;
1006                 if (c->is_40bit_channel)
1007                     dst |= 0x400000000ull;
1008                 src = buf_addr;
1009                 info |= BCM2835_DMA_D_DREQ | BCM2835_DMA_S_INC;
1010
1011                 /* non-lite channels can write zeroes w/o accessing memory */
1012                 if (buf_addr == od->zero_page && !c->is_lite_channel)
1013                         info |= BCM2835_DMA_S_IGNORE;
1014         }
1015
1016         /* calculate number of frames */
1017         frames = /* number of periods */
1018                  DIV_ROUND_UP(buf_len, period_len) *
1019                  /* number of frames per period */
1020                  bcm2835_dma_frames_for_length(period_len, max_len);
1021
1022         /*
1023          * allocate the CB chain
1024          * note that we need to use GFP_NOWAIT, as the ALSA i2s dmaengine
1025          * implementation calls prep_dma_cyclic with interrupts disabled.
1026          */
1027         d = bcm2835_dma_create_cb_chain(c, direction, true,
1028                                         info, extra,
1029                                         frames, src, dst, buf_len,
1030                                         period_len, GFP_NOWAIT);
1031         if (!d)
1032                 return NULL;
1033
1034         /* wrap around into a loop */
1035         if (c->is_40bit_channel)
1036                 ((struct bcm2711_dma40_scb *)
1037                  d->cb_list[frames - 1].cb)->next_cb =
1038                         to_bcm2711_cbaddr(d->cb_list[0].paddr);
1039         else
1040                 d->cb_list[d->frames - 1].cb->next = d->cb_list[0].paddr;
1041
1042         return vchan_tx_prep(&c->vc, &d->vd, flags);
1043 }
1044
1045 static int bcm2835_dma_slave_config(struct dma_chan *chan,
1046                                     struct dma_slave_config *cfg)
1047 {
1048         struct bcm2835_chan *c = to_bcm2835_dma_chan(chan);
1049
1050         c->cfg = *cfg;
1051
1052         return 0;
1053 }
1054
1055 static int bcm2835_dma_terminate_all(struct dma_chan *chan)
1056 {
1057         struct bcm2835_chan *c = to_bcm2835_dma_chan(chan);
1058         unsigned long flags;
1059         LIST_HEAD(head);
1060
1061         spin_lock_irqsave(&c->vc.lock, flags);
1062
1063         /* stop DMA activity */
1064         if (c->desc) {
1065                 vchan_terminate_vdesc(&c->desc->vd);
1066                 c->desc = NULL;
1067                 bcm2835_dma_abort(c);
1068         }
1069
1070         vchan_get_all_descriptors(&c->vc, &head);
1071         spin_unlock_irqrestore(&c->vc.lock, flags);
1072         vchan_dma_desc_free_list(&c->vc, &head);
1073
1074         return 0;
1075 }
1076
1077 static void bcm2835_dma_synchronize(struct dma_chan *chan)
1078 {
1079         struct bcm2835_chan *c = to_bcm2835_dma_chan(chan);
1080
1081         vchan_synchronize(&c->vc);
1082 }
1083
1084 static int bcm2835_dma_chan_init(struct bcm2835_dmadev *d, int chan_id,
1085                                  int irq, unsigned int irq_flags)
1086 {
1087         struct bcm2835_chan *c;
1088
1089         c = devm_kzalloc(d->ddev.dev, sizeof(*c), GFP_KERNEL);
1090         if (!c)
1091                 return -ENOMEM;
1092
1093         c->vc.desc_free = bcm2835_dma_desc_free;
1094         vchan_init(&c->vc, &d->ddev);
1095
1096         c->chan_base = BCM2835_DMA_CHANIO(d->base, chan_id);
1097         c->ch = chan_id;
1098         c->irq_number = irq;
1099         c->irq_flags = irq_flags;
1100
1101         /* check for 40bit and lite channels */
1102         if (d->cfg_data->chan_40bit_mask & BIT(chan_id))
1103                 c->is_40bit_channel = true;
1104         else if (readl(c->chan_base + BCM2835_DMA_DEBUG) &
1105                  BCM2835_DMA_DEBUG_LITE)
1106                 c->is_lite_channel = true;
1107
1108         return 0;
1109 }
1110
1111 static void bcm2835_dma_free(struct bcm2835_dmadev *od)
1112 {
1113         struct bcm2835_chan *c, *next;
1114
1115         list_for_each_entry_safe(c, next, &od->ddev.channels,
1116                                  vc.chan.device_node) {
1117                 list_del(&c->vc.chan.device_node);
1118                 tasklet_kill(&c->vc.task);
1119         }
1120
1121         dma_unmap_page_attrs(od->ddev.dev, od->zero_page, PAGE_SIZE,
1122                              DMA_TO_DEVICE, DMA_ATTR_SKIP_CPU_SYNC);
1123 }
1124
1125 int bcm2711_dma40_memcpy_init(void)
1126 {
1127         if (!memcpy_parent)
1128                 return -EPROBE_DEFER;
1129
1130         if (!memcpy_chan)
1131                 return -EINVAL;
1132
1133         if (!memcpy_scb)
1134                 return -ENOMEM;
1135
1136         return 0;
1137 }
1138 EXPORT_SYMBOL(bcm2711_dma40_memcpy_init);
1139
1140 void bcm2711_dma40_memcpy(dma_addr_t dst, dma_addr_t src, size_t size)
1141 {
1142         struct bcm2711_dma40_scb *scb = memcpy_scb;
1143         unsigned long flags;
1144
1145         if (!scb) {
1146                 pr_err("bcm2711_dma40_memcpy not initialised!\n");
1147                 return;
1148         }
1149
1150         spin_lock_irqsave(&memcpy_lock, flags);
1151
1152         scb->ti = 0;
1153         scb->src = lower_32_bits(src);
1154         scb->srci = upper_32_bits(src) | BCM2711_DMA40_MEMCPY_XFER_INFO;
1155         scb->dst = lower_32_bits(dst);
1156         scb->dsti = upper_32_bits(dst) | BCM2711_DMA40_MEMCPY_XFER_INFO;
1157         scb->len = size;
1158         scb->next_cb = 0;
1159
1160         writel((u32)(memcpy_scb_dma >> 5), memcpy_chan + BCM2711_DMA40_CB);
1161         writel(BCM2711_DMA40_MEMCPY_FLAGS + BCM2711_DMA40_ACTIVE,
1162                memcpy_chan + BCM2711_DMA40_CS);
1163
1164         /* Poll for completion */
1165         while (!(readl(memcpy_chan + BCM2711_DMA40_CS) & BCM2711_DMA40_END))
1166                 cpu_relax();
1167
1168         writel(BCM2711_DMA40_END, memcpy_chan + BCM2711_DMA40_CS);
1169
1170         spin_unlock_irqrestore(&memcpy_lock, flags);
1171 }
1172 EXPORT_SYMBOL(bcm2711_dma40_memcpy);
1173
1174 static const struct of_device_id bcm2835_dma_of_match[] = {
1175         { .compatible = "brcm,bcm2835-dma", .data = &bcm2835_dma_cfg },
1176         { .compatible = "brcm,bcm2711-dma", .data = &bcm2711_dma_cfg },
1177         {},
1178 };
1179 MODULE_DEVICE_TABLE(of, bcm2835_dma_of_match);
1180
1181 static struct dma_chan *bcm2835_dma_xlate(struct of_phandle_args *spec,
1182                                            struct of_dma *ofdma)
1183 {
1184         struct bcm2835_dmadev *d = ofdma->of_dma_data;
1185         struct dma_chan *chan;
1186
1187         chan = dma_get_any_slave_channel(&d->ddev);
1188         if (!chan)
1189                 return NULL;
1190
1191         /* Set DREQ from param */
1192         to_bcm2835_dma_chan(chan)->dreq = spec->args[0];
1193
1194         return chan;
1195 }
1196
1197 static int bcm2835_dma_probe(struct platform_device *pdev)
1198 {
1199         const struct bcm2835_dma_cfg_data *cfg_data;
1200         const struct of_device_id *of_id;
1201         struct bcm2835_dmadev *od;
1202         struct resource *res;
1203         void __iomem *base;
1204         int rc;
1205         int i, j;
1206         int irq[BCM2835_DMA_MAX_DMA_CHAN_SUPPORTED + 1];
1207         int irq_flags;
1208         uint32_t chans_available;
1209         char chan_name[BCM2835_DMA_CHAN_NAME_SIZE];
1210         int chan_count, chan_start, chan_end;
1211
1212         of_id = of_match_node(bcm2835_dma_of_match, pdev->dev.of_node);
1213         if (!of_id) {
1214                 dev_err(&pdev->dev, "Failed to match compatible string\n");
1215                 return -EINVAL;
1216         }
1217
1218         cfg_data = of_id->data;
1219
1220         if (!pdev->dev.dma_mask)
1221                 pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
1222
1223         rc = dma_set_mask_and_coherent(&pdev->dev, cfg_data->dma_mask);
1224         if (rc) {
1225                 dev_err(&pdev->dev, "Unable to set DMA mask\n");
1226                 return rc;
1227         }
1228
1229         od = devm_kzalloc(&pdev->dev, sizeof(*od), GFP_KERNEL);
1230         if (!od)
1231                 return -ENOMEM;
1232
1233         dma_set_max_seg_size(&pdev->dev, 0x3FFFFFFF);
1234
1235         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1236         base = devm_ioremap_resource(&pdev->dev, res);
1237         if (IS_ERR(base))
1238                 return PTR_ERR(base);
1239
1240         /* The set of channels can be split across multiple instances. */
1241         chan_start = ((u32)(uintptr_t)base / BCM2835_DMA_CHAN_SIZE) & 0xf;
1242         base -= BCM2835_DMA_CHAN(chan_start);
1243         chan_count = resource_size(res) / BCM2835_DMA_CHAN_SIZE;
1244         chan_end = min(chan_start + chan_count,
1245                          BCM2835_DMA_MAX_DMA_CHAN_SUPPORTED + 1);
1246
1247         od->base = base;
1248
1249         dma_cap_set(DMA_SLAVE, od->ddev.cap_mask);
1250         dma_cap_set(DMA_PRIVATE, od->ddev.cap_mask);
1251         dma_cap_set(DMA_CYCLIC, od->ddev.cap_mask);
1252         dma_cap_set(DMA_MEMCPY, od->ddev.cap_mask);
1253         od->ddev.device_alloc_chan_resources = bcm2835_dma_alloc_chan_resources;
1254         od->ddev.device_free_chan_resources = bcm2835_dma_free_chan_resources;
1255         od->ddev.device_tx_status = bcm2835_dma_tx_status;
1256         od->ddev.device_issue_pending = bcm2835_dma_issue_pending;
1257         od->ddev.device_prep_dma_cyclic = bcm2835_dma_prep_dma_cyclic;
1258         od->ddev.device_prep_slave_sg = bcm2835_dma_prep_slave_sg;
1259         od->ddev.device_prep_dma_memcpy = bcm2835_dma_prep_dma_memcpy;
1260         od->ddev.device_config = bcm2835_dma_slave_config;
1261         od->ddev.device_terminate_all = bcm2835_dma_terminate_all;
1262         od->ddev.device_synchronize = bcm2835_dma_synchronize;
1263         od->ddev.src_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);
1264         od->ddev.dst_addr_widths = BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);
1265         od->ddev.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV) |
1266                               BIT(DMA_MEM_TO_MEM);
1267         od->ddev.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
1268         od->ddev.descriptor_reuse = true;
1269         od->ddev.dev = &pdev->dev;
1270         INIT_LIST_HEAD(&od->ddev.channels);
1271
1272         platform_set_drvdata(pdev, od);
1273
1274         od->zero_page = dma_map_page_attrs(od->ddev.dev, ZERO_PAGE(0), 0,
1275                                            PAGE_SIZE, DMA_TO_DEVICE,
1276                                            DMA_ATTR_SKIP_CPU_SYNC);
1277         if (dma_mapping_error(od->ddev.dev, od->zero_page)) {
1278                 dev_err(&pdev->dev, "Failed to map zero page\n");
1279                 return -ENOMEM;
1280         }
1281
1282         of_id = of_match_node(bcm2835_dma_of_match, pdev->dev.of_node);
1283         if (!of_id) {
1284                 dev_err(&pdev->dev, "Failed to match compatible string\n");
1285                 return -EINVAL;
1286         }
1287
1288         od->cfg_data = cfg_data;
1289
1290         /* Request DMA channel mask from device tree */
1291         if (of_property_read_u32(pdev->dev.of_node,
1292                         "brcm,dma-channel-mask",
1293                         &chans_available)) {
1294                 dev_err(&pdev->dev, "Failed to get channel mask\n");
1295                 rc = -EINVAL;
1296                 goto err_no_dma;
1297         }
1298
1299 #ifdef CONFIG_DMA_BCM2708
1300         /* One channel is reserved for the legacy API */
1301         if (chans_available & BCM2835_DMA_BULK_MASK) {
1302                 rc = bcm_dmaman_probe(pdev, base,
1303                                       chans_available & BCM2835_DMA_BULK_MASK);
1304                 if (rc)
1305                         dev_err(&pdev->dev,
1306                                 "Failed to initialize the legacy API\n");
1307
1308                 chans_available &= ~BCM2835_DMA_BULK_MASK;
1309         }
1310 #endif
1311
1312         /* And possibly one for the 40-bit DMA memcpy API */
1313         if (chans_available & od->cfg_data->chan_40bit_mask &
1314             BIT(BCM2711_DMA_MEMCPY_CHAN)) {
1315                 memcpy_parent = od;
1316                 memcpy_chan = BCM2835_DMA_CHANIO(base, BCM2711_DMA_MEMCPY_CHAN);
1317                 memcpy_scb = dma_alloc_coherent(memcpy_parent->ddev.dev,
1318                                                 sizeof(*memcpy_scb),
1319                                                 &memcpy_scb_dma, GFP_KERNEL);
1320                 if (!memcpy_scb)
1321                         dev_warn(&pdev->dev,
1322                                  "Failed to allocated memcpy scb\n");
1323
1324                 chans_available &= ~BIT(BCM2711_DMA_MEMCPY_CHAN);
1325         }
1326
1327         /* get irqs for each channel that we support */
1328         for (i = chan_start; i < chan_end; i++) {
1329                 /* skip masked out channels */
1330                 if (!(chans_available & (1 << i))) {
1331                         irq[i] = -1;
1332                         continue;
1333                 }
1334
1335                 /* get the named irq */
1336                 snprintf(chan_name, sizeof(chan_name), "dma%i", i);
1337                 irq[i] = platform_get_irq_byname(pdev, chan_name);
1338                 if (irq[i] >= 0)
1339                         continue;
1340
1341                 /* legacy device tree case handling */
1342                 dev_warn_once(&pdev->dev,
1343                               "missing interrupt-names property in device tree - legacy interpretation is used\n");
1344                 /*
1345                  * in case of channel >= 11
1346                  * use the 11th interrupt and that is shared
1347                  */
1348                 irq[i] = platform_get_irq(pdev, i < 11 ? i : 11);
1349         }
1350
1351         chan_count = 0;
1352
1353         /* get irqs for each channel */
1354         for (i = chan_start; i < chan_end; i++) {
1355                 /* skip channels without irq */
1356                 if (irq[i] < 0)
1357                         continue;
1358
1359                 /* check if there are other channels that also use this irq */
1360                 /* FIXME: This will fail if interrupts are shared across
1361                    instances */
1362                 irq_flags = 0;
1363                 for (j = 0; j <= BCM2835_DMA_MAX_DMA_CHAN_SUPPORTED; j++)
1364                         if ((i != j) && (irq[j] == irq[i])) {
1365                                 irq_flags = IRQF_SHARED;
1366                                 break;
1367                         }
1368
1369                 /* initialize the channel */
1370                 rc = bcm2835_dma_chan_init(od, i, irq[i], irq_flags);
1371                 if (rc)
1372                         goto err_no_dma;
1373                 chan_count++;
1374         }
1375
1376         dev_dbg(&pdev->dev, "Initialized %i DMA channels\n", chan_count);
1377
1378         /* Device-tree DMA controller registration */
1379         rc = of_dma_controller_register(pdev->dev.of_node,
1380                         bcm2835_dma_xlate, od);
1381         if (rc) {
1382                 dev_err(&pdev->dev, "Failed to register DMA controller\n");
1383                 goto err_no_dma;
1384         }
1385
1386         rc = dma_async_device_register(&od->ddev);
1387         if (rc) {
1388                 dev_err(&pdev->dev,
1389                         "Failed to register slave DMA engine device: %d\n", rc);
1390                 goto err_no_dma;
1391         }
1392
1393         dev_dbg(&pdev->dev, "Load BCM2835 DMA engine driver\n");
1394
1395         return 0;
1396
1397 err_no_dma:
1398         bcm2835_dma_free(od);
1399         return rc;
1400 }
1401
1402 static int bcm2835_dma_remove(struct platform_device *pdev)
1403 {
1404         struct bcm2835_dmadev *od = platform_get_drvdata(pdev);
1405
1406         bcm_dmaman_remove(pdev);
1407         dma_async_device_unregister(&od->ddev);
1408         if (memcpy_parent == od) {
1409                 dma_free_coherent(&pdev->dev, sizeof(*memcpy_scb), memcpy_scb,
1410                                   memcpy_scb_dma);
1411                 memcpy_parent = NULL;
1412                 memcpy_scb = NULL;
1413                 memcpy_chan = NULL;
1414         }
1415         bcm2835_dma_free(od);
1416
1417         return 0;
1418 }
1419
1420 static struct platform_driver bcm2835_dma_driver = {
1421         .probe  = bcm2835_dma_probe,
1422         .remove = bcm2835_dma_remove,
1423         .driver = {
1424                 .name = "bcm2835-dma",
1425                 .of_match_table = of_match_ptr(bcm2835_dma_of_match),
1426         },
1427 };
1428
1429 static int bcm2835_dma_init(void)
1430 {
1431         return platform_driver_register(&bcm2835_dma_driver);
1432 }
1433
1434 static void bcm2835_dma_exit(void)
1435 {
1436         platform_driver_unregister(&bcm2835_dma_driver);
1437 }
1438
1439 /*
1440  * Load after serial driver (arch_initcall) so we see the messages if it fails,
1441  * but before drivers (module_init) that need a DMA channel.
1442  */
1443 subsys_initcall(bcm2835_dma_init);
1444 module_exit(bcm2835_dma_exit);
1445
1446 MODULE_ALIAS("platform:bcm2835-dma");
1447 MODULE_DESCRIPTION("BCM2835 DMA engine driver");
1448 MODULE_AUTHOR("Florian Meier <florian.meier@koalo.de>");
1449 MODULE_LICENSE("GPL");