drivers/dma/tegra186-gpc-dma.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * DMA driver for NVIDIA Tegra GPC DMA controller.
   4  *
   5  * Copyright (c) 2014-2022, NVIDIA CORPORATION.  All rights reserved.
   6  */
   7
   8 #include <linux/bitfield.h>
   9 #include <linux/dmaengine.h>
  10 #include <linux/dma-mapping.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/iommu.h>
  13 #include <linux/iopoll.h>
  14 #include <linux/minmax.h>
  15 #include <linux/module.h>
  16 #include <linux/of_device.h>
  17 #include <linux/of_dma.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/reset.h>
  20 #include <linux/slab.h>
  21 #include <dt-bindings/memory/tegra186-mc.h>
  22 #include "virt-dma.h"
  23
  24 /* CSR register */
  25 #define TEGRA_GPCDMA_CHAN_CSR                   0x00
  26 #define TEGRA_GPCDMA_CSR_ENB                    BIT(31)
  27 #define TEGRA_GPCDMA_CSR_IE_EOC                 BIT(30)
  28 #define TEGRA_GPCDMA_CSR_ONCE                   BIT(27)
  29
  30 #define TEGRA_GPCDMA_CSR_FC_MODE                GENMASK(25, 24)
  31 #define TEGRA_GPCDMA_CSR_FC_MODE_NO_MMIO        \
  32                 FIELD_PREP(TEGRA_GPCDMA_CSR_FC_MODE, 0)
  33 #define TEGRA_GPCDMA_CSR_FC_MODE_ONE_MMIO       \
  34                 FIELD_PREP(TEGRA_GPCDMA_CSR_FC_MODE, 1)
  35 #define TEGRA_GPCDMA_CSR_FC_MODE_TWO_MMIO       \
  36                 FIELD_PREP(TEGRA_GPCDMA_CSR_FC_MODE, 2)
  37 #define TEGRA_GPCDMA_CSR_FC_MODE_FOUR_MMIO      \
  38                 FIELD_PREP(TEGRA_GPCDMA_CSR_FC_MODE, 3)
  39
  40 #define TEGRA_GPCDMA_CSR_DMA                    GENMASK(23, 21)
  41 #define TEGRA_GPCDMA_CSR_DMA_IO2MEM_NO_FC       \
  42                 FIELD_PREP(TEGRA_GPCDMA_CSR_DMA, 0)
  43 #define TEGRA_GPCDMA_CSR_DMA_IO2MEM_FC          \
  44                 FIELD_PREP(TEGRA_GPCDMA_CSR_DMA, 1)
  45 #define TEGRA_GPCDMA_CSR_DMA_MEM2IO_NO_FC       \
  46                 FIELD_PREP(TEGRA_GPCDMA_CSR_DMA, 2)
  47 #define TEGRA_GPCDMA_CSR_DMA_MEM2IO_FC          \
  48                 FIELD_PREP(TEGRA_GPCDMA_CSR_DMA, 3)
  49 #define TEGRA_GPCDMA_CSR_DMA_MEM2MEM            \
  50                 FIELD_PREP(TEGRA_GPCDMA_CSR_DMA, 4)
  51 #define TEGRA_GPCDMA_CSR_DMA_FIXED_PAT          \
  52                 FIELD_PREP(TEGRA_GPCDMA_CSR_DMA, 6)
  53
  54 #define TEGRA_GPCDMA_CSR_REQ_SEL_MASK           GENMASK(20, 16)
  55 #define TEGRA_GPCDMA_CSR_REQ_SEL_UNUSED         \
  56                                         FIELD_PREP(TEGRA_GPCDMA_CSR_REQ_SEL_MASK, 4)
  57 #define TEGRA_GPCDMA_CSR_IRQ_MASK               BIT(15)
  58 #define TEGRA_GPCDMA_CSR_WEIGHT                 GENMASK(13, 10)
  59
  60 /* STATUS register */
  61 #define TEGRA_GPCDMA_CHAN_STATUS                0x004
  62 #define TEGRA_GPCDMA_STATUS_BUSY                BIT(31)
  63 #define TEGRA_GPCDMA_STATUS_ISE_EOC             BIT(30)
  64 #define TEGRA_GPCDMA_STATUS_PING_PONG           BIT(28)
  65 #define TEGRA_GPCDMA_STATUS_DMA_ACTIVITY        BIT(27)
  66 #define TEGRA_GPCDMA_STATUS_CHANNEL_PAUSE       BIT(26)
  67 #define TEGRA_GPCDMA_STATUS_CHANNEL_RX          BIT(25)
  68 #define TEGRA_GPCDMA_STATUS_CHANNEL_TX          BIT(24)
  69 #define TEGRA_GPCDMA_STATUS_IRQ_INTR_STA        BIT(23)
  70 #define TEGRA_GPCDMA_STATUS_IRQ_STA             BIT(21)
  71 #define TEGRA_GPCDMA_STATUS_IRQ_TRIG_STA        BIT(20)
  72
  73 #define TEGRA_GPCDMA_CHAN_CSRE                  0x008
  74 #define TEGRA_GPCDMA_CHAN_CSRE_PAUSE            BIT(31)
  75
  76 /* Source address */
  77 #define TEGRA_GPCDMA_CHAN_SRC_PTR               0x00C
  78
  79 /* Destination address */
  80 #define TEGRA_GPCDMA_CHAN_DST_PTR               0x010
  81
  82 /* High address pointer */
  83 #define TEGRA_GPCDMA_CHAN_HIGH_ADDR_PTR         0x014
  84 #define TEGRA_GPCDMA_HIGH_ADDR_SRC_PTR          GENMASK(7, 0)
  85 #define TEGRA_GPCDMA_HIGH_ADDR_DST_PTR          GENMASK(23, 16)
  86
  87 /* MC sequence register */
  88 #define TEGRA_GPCDMA_CHAN_MCSEQ                 0x18
  89 #define TEGRA_GPCDMA_MCSEQ_DATA_SWAP            BIT(31)
  90 #define TEGRA_GPCDMA_MCSEQ_REQ_COUNT            GENMASK(30, 25)
  91 #define TEGRA_GPCDMA_MCSEQ_BURST                GENMASK(24, 23)
  92 #define TEGRA_GPCDMA_MCSEQ_BURST_2              \
  93                 FIELD_PREP(TEGRA_GPCDMA_MCSEQ_BURST, 0)
  94 #define TEGRA_GPCDMA_MCSEQ_BURST_16             \
  95                 FIELD_PREP(TEGRA_GPCDMA_MCSEQ_BURST, 3)
  96 #define TEGRA_GPCDMA_MCSEQ_WRAP1                GENMASK(22, 20)
  97 #define TEGRA_GPCDMA_MCSEQ_WRAP0                GENMASK(19, 17)
  98 #define TEGRA_GPCDMA_MCSEQ_WRAP_NONE            0
  99
 100 #define TEGRA_GPCDMA_MCSEQ_STREAM_ID1_MASK      GENMASK(13, 7)
 101 #define TEGRA_GPCDMA_MCSEQ_STREAM_ID0_MASK      GENMASK(6, 0)
 102
 103 /* MMIO sequence register */
 104 #define TEGRA_GPCDMA_CHAN_MMIOSEQ                       0x01c
 105 #define TEGRA_GPCDMA_MMIOSEQ_DBL_BUF            BIT(31)
 106 #define TEGRA_GPCDMA_MMIOSEQ_BUS_WIDTH          GENMASK(30, 28)
 107 #define TEGRA_GPCDMA_MMIOSEQ_BUS_WIDTH_8        \
 108                 FIELD_PREP(TEGRA_GPCDMA_MMIOSEQ_BUS_WIDTH, 0)
 109 #define TEGRA_GPCDMA_MMIOSEQ_BUS_WIDTH_16       \
 110                 FIELD_PREP(TEGRA_GPCDMA_MMIOSEQ_BUS_WIDTH, 1)
 111 #define TEGRA_GPCDMA_MMIOSEQ_BUS_WIDTH_32       \
 112                 FIELD_PREP(TEGRA_GPCDMA_MMIOSEQ_BUS_WIDTH, 2)
 113 #define TEGRA_GPCDMA_MMIOSEQ_DATA_SWAP          BIT(27)
 114 #define TEGRA_GPCDMA_MMIOSEQ_BURST_SHIFT        23
 115 #define TEGRA_GPCDMA_MMIOSEQ_BURST_MIN          2U
 116 #define TEGRA_GPCDMA_MMIOSEQ_BURST_MAX          32U
 117 #define TEGRA_GPCDMA_MMIOSEQ_BURST(bs)  \
 118                 (GENMASK((fls(bs) - 2), 0) << TEGRA_GPCDMA_MMIOSEQ_BURST_SHIFT)
 119 #define TEGRA_GPCDMA_MMIOSEQ_MASTER_ID          GENMASK(22, 19)
 120 #define TEGRA_GPCDMA_MMIOSEQ_WRAP_WORD          GENMASK(18, 16)
 121 #define TEGRA_GPCDMA_MMIOSEQ_MMIO_PROT          GENMASK(8, 7)
 122
 123 /* Channel WCOUNT */
 124 #define TEGRA_GPCDMA_CHAN_WCOUNT                0x20
 125
 126 /* Transfer count */
 127 #define TEGRA_GPCDMA_CHAN_XFER_COUNT            0x24
 128
 129 /* DMA byte count status */
 130 #define TEGRA_GPCDMA_CHAN_DMA_BYTE_STATUS       0x28
 131
 132 /* Error Status Register */
 133 #define TEGRA_GPCDMA_CHAN_ERR_STATUS            0x30
 134 #define TEGRA_GPCDMA_CHAN_ERR_TYPE_SHIFT        8
 135 #define TEGRA_GPCDMA_CHAN_ERR_TYPE_MASK 0xF
 136 #define TEGRA_GPCDMA_CHAN_ERR_TYPE(err) (                       \
 137                 ((err) >> TEGRA_GPCDMA_CHAN_ERR_TYPE_SHIFT) &   \
 138                 TEGRA_GPCDMA_CHAN_ERR_TYPE_MASK)
 139 #define TEGRA_DMA_BM_FIFO_FULL_ERR              0xF
 140 #define TEGRA_DMA_PERIPH_FIFO_FULL_ERR          0xE
 141 #define TEGRA_DMA_PERIPH_ID_ERR                 0xD
 142 #define TEGRA_DMA_STREAM_ID_ERR                 0xC
 143 #define TEGRA_DMA_MC_SLAVE_ERR                  0xB
 144 #define TEGRA_DMA_MMIO_SLAVE_ERR                0xA
 145
 146 /* Fixed Pattern */
 147 #define TEGRA_GPCDMA_CHAN_FIXED_PATTERN         0x34
 148
 149 #define TEGRA_GPCDMA_CHAN_TZ                    0x38
 150 #define TEGRA_GPCDMA_CHAN_TZ_MMIO_PROT_1        BIT(0)
 151 #define TEGRA_GPCDMA_CHAN_TZ_MC_PROT_1          BIT(1)
 152
 153 #define TEGRA_GPCDMA_CHAN_SPARE                 0x3c
 154 #define TEGRA_GPCDMA_CHAN_SPARE_EN_LEGACY_FC    BIT(16)
 155
 156 /*
 157  * If any burst is in flight and DMA paused then this is the time to complete
 158  * on-flight burst and update DMA status register.
 159  */
 160 #define TEGRA_GPCDMA_BURST_COMPLETE_TIME        10
 161 #define TEGRA_GPCDMA_BURST_COMPLETION_TIMEOUT   5000 /* 5 msec */
 162
 163 /* Channel base address offset from GPCDMA base address */
 164 #define TEGRA_GPCDMA_CHANNEL_BASE_ADD_OFFSET    0x20000
 165
 166 struct tegra_dma;
 167 struct tegra_dma_channel;
 168
 169 /*
 170  * tegra_dma_chip_data Tegra chip specific DMA data
 171  * @nr_channels: Number of channels available in the controller.
 172  * @channel_reg_size: Channel register size.
 173  * @max_dma_count: Maximum DMA transfer count supported by DMA controller.
 174  * @hw_support_pause: DMA HW engine support pause of the channel.
 175  */
 176 struct tegra_dma_chip_data {
 177         bool hw_support_pause;
 178         unsigned int nr_channels;
 179         unsigned int channel_reg_size;
 180         unsigned int max_dma_count;
 181         int (*terminate)(struct tegra_dma_channel *tdc);
 182 };
 183
 184 /* DMA channel registers */
 185 struct tegra_dma_channel_regs {
 186         u32 csr;
 187         u32 src_ptr;
 188         u32 dst_ptr;
 189         u32 high_addr_ptr;
 190         u32 mc_seq;
 191         u32 mmio_seq;
 192         u32 wcount;
 193         u32 fixed_pattern;
 194 };
 195
 196 /*
 197  * tegra_dma_sg_req: DMA request details to configure hardware. This
 198  * contains the details for one transfer to configure DMA hw.
 199  * The client's request for data transfer can be broken into multiple
 200  * sub-transfer as per requester details and hw support. This sub transfer
 201  * get added as an array in Tegra DMA desc which manages the transfer details.
 202  */
 203 struct tegra_dma_sg_req {
 204         unsigned int len;
 205         struct tegra_dma_channel_regs ch_regs;
 206 };
 207
 208 /*
 209  * tegra_dma_desc: Tegra DMA descriptors which uses virt_dma_desc to
 210  * manage client request and keep track of transfer status, callbacks
 211  * and request counts etc.
 212  */
 213 struct tegra_dma_desc {
 214         bool cyclic;
 215         unsigned int bytes_req;
 216         unsigned int bytes_xfer;
 217         unsigned int sg_idx;
 218         unsigned int sg_count;
 219         struct virt_dma_desc vd;
 220         struct tegra_dma_channel *tdc;
 221         struct tegra_dma_sg_req sg_req[];
 222 };
 223
 224 /*
 225  * tegra_dma_channel: Channel specific information
 226  */
 227 struct tegra_dma_channel {
 228         bool config_init;
 229         char name[30];
 230         enum dma_transfer_direction sid_dir;
 231         int id;
 232         int irq;
 233         int slave_id;
 234         struct tegra_dma *tdma;
 235         struct virt_dma_chan vc;
 236         struct tegra_dma_desc *dma_desc;
 237         struct dma_slave_config dma_sconfig;
 238         unsigned int stream_id;
 239         unsigned long chan_base_offset;
 240 };
 241
 242 /*
 243  * tegra_dma: Tegra DMA specific information
 244  */
 245 struct tegra_dma {
 246         const struct tegra_dma_chip_data *chip_data;
 247         unsigned long sid_m2d_reserved;
 248         unsigned long sid_d2m_reserved;
 249         void __iomem *base_addr;
 250         struct device *dev;
 251         struct dma_device dma_dev;
 252         struct reset_control *rst;
 253         struct tegra_dma_channel channels[];
 254 };
 255
 256 static inline void tdc_write(struct tegra_dma_channel *tdc,
 257                              u32 reg, u32 val)
 258 {
 259         writel_relaxed(val, tdc->tdma->base_addr + tdc->chan_base_offset + reg);
 260 }
 261
 262 static inline u32 tdc_read(struct tegra_dma_channel *tdc, u32 reg)
 263 {
 264         return readl_relaxed(tdc->tdma->base_addr + tdc->chan_base_offset + reg);
 265 }
 266
 267 static inline struct tegra_dma_channel *to_tegra_dma_chan(struct dma_chan *dc)
 268 {
 269         return container_of(dc, struct tegra_dma_channel, vc.chan);
 270 }
 271
 272 static inline struct tegra_dma_desc *vd_to_tegra_dma_desc(struct virt_dma_desc *vd)
 273 {
 274         return container_of(vd, struct tegra_dma_desc, vd);
 275 }
 276
 277 static inline struct device *tdc2dev(struct tegra_dma_channel *tdc)
 278 {
 279         return tdc->vc.chan.device->dev;
 280 }
 281
 282 static void tegra_dma_dump_chan_regs(struct tegra_dma_channel *tdc)
 283 {
 284         dev_dbg(tdc2dev(tdc), "DMA Channel %d name %s register dump:\n",
 285                 tdc->id, tdc->name);
 286         dev_dbg(tdc2dev(tdc), "CSR %x STA %x CSRE %x SRC %x DST %x\n",
 287                 tdc_read(tdc, TEGRA_GPCDMA_CHAN_CSR),
 288                 tdc_read(tdc, TEGRA_GPCDMA_CHAN_STATUS),
 289                 tdc_read(tdc, TEGRA_GPCDMA_CHAN_CSRE),
 290                 tdc_read(tdc, TEGRA_GPCDMA_CHAN_SRC_PTR),
 291                 tdc_read(tdc, TEGRA_GPCDMA_CHAN_DST_PTR)
 292         );
 293         dev_dbg(tdc2dev(tdc), "MCSEQ %x IOSEQ %x WCNT %x XFER %x BSTA %x\n",
 294                 tdc_read(tdc, TEGRA_GPCDMA_CHAN_MCSEQ),
 295                 tdc_read(tdc, TEGRA_GPCDMA_CHAN_MMIOSEQ),
 296                 tdc_read(tdc, TEGRA_GPCDMA_CHAN_WCOUNT),
 297                 tdc_read(tdc, TEGRA_GPCDMA_CHAN_XFER_COUNT),
 298                 tdc_read(tdc, TEGRA_GPCDMA_CHAN_DMA_BYTE_STATUS)
 299         );
 300         dev_dbg(tdc2dev(tdc), "DMA ERR_STA %x\n",
 301                 tdc_read(tdc, TEGRA_GPCDMA_CHAN_ERR_STATUS));
 302 }
 303
 304 static int tegra_dma_sid_reserve(struct tegra_dma_channel *tdc,
 305                                  enum dma_transfer_direction direction)
 306 {
 307         struct tegra_dma *tdma = tdc->tdma;
 308         int sid = tdc->slave_id;
 309
 310         if (!is_slave_direction(direction))
 311                 return 0;
 312
 313         switch (direction) {
 314         case DMA_MEM_TO_DEV:
 315                 if (test_and_set_bit(sid, &tdma->sid_m2d_reserved)) {
 316                         dev_err(tdma->dev, "slave id already in use\n");
 317                         return -EINVAL;
 318                 }
 319                 break;
 320         case DMA_DEV_TO_MEM:
 321                 if (test_and_set_bit(sid, &tdma->sid_d2m_reserved)) {
 322                         dev_err(tdma->dev, "slave id already in use\n");
 323                         return -EINVAL;
 324                 }
 325                 break;
 326         default:
 327                 break;
 328         }
 329
 330         tdc->sid_dir = direction;
 331
 332         return 0;
 333 }
 334
 335 static void tegra_dma_sid_free(struct tegra_dma_channel *tdc)
 336 {
 337         struct tegra_dma *tdma = tdc->tdma;
 338         int sid = tdc->slave_id;
 339
 340         switch (tdc->sid_dir) {
 341         case DMA_MEM_TO_DEV:
 342                 clear_bit(sid,  &tdma->sid_m2d_reserved);
 343                 break;
 344         case DMA_DEV_TO_MEM:
 345                 clear_bit(sid,  &tdma->sid_d2m_reserved);
 346                 break;
 347         default:
 348                 break;
 349         }
 350
 351         tdc->sid_dir = DMA_TRANS_NONE;
 352 }
 353
 354 static void tegra_dma_desc_free(struct virt_dma_desc *vd)
 355 {
 356         kfree(container_of(vd, struct tegra_dma_desc, vd));
 357 }
 358
 359 static int tegra_dma_slave_config(struct dma_chan *dc,
 360                                   struct dma_slave_config *sconfig)
 361 {
 362         struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
 363
 364         memcpy(&tdc->dma_sconfig, sconfig, sizeof(*sconfig));
 365         tdc->config_init = true;
 366
 367         return 0;
 368 }
 369
 370 static int tegra_dma_pause(struct tegra_dma_channel *tdc)
 371 {
 372         int ret;
 373         u32 val;
 374
 375         val = tdc_read(tdc, TEGRA_GPCDMA_CHAN_CSRE);
 376         val |= TEGRA_GPCDMA_CHAN_CSRE_PAUSE;
 377         tdc_write(tdc, TEGRA_GPCDMA_CHAN_CSRE, val);
 378
 379         /* Wait until busy bit is de-asserted */
 380         ret = readl_relaxed_poll_timeout_atomic(tdc->tdma->base_addr +
 381                         tdc->chan_base_offset + TEGRA_GPCDMA_CHAN_STATUS,
 382                         val,
 383                         !(val & TEGRA_GPCDMA_STATUS_BUSY),
 384                         TEGRA_GPCDMA_BURST_COMPLETE_TIME,
 385                         TEGRA_GPCDMA_BURST_COMPLETION_TIMEOUT);
 386
 387         if (ret) {
 388                 dev_err(tdc2dev(tdc), "DMA pause timed out\n");
 389                 tegra_dma_dump_chan_regs(tdc);
 390         }
 391
 392         return ret;
 393 }
 394
 395 static int tegra_dma_device_pause(struct dma_chan *dc)
 396 {
 397         struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
 398         unsigned long flags;
 399         int ret;
 400
 401         if (!tdc->tdma->chip_data->hw_support_pause)
 402                 return -ENOSYS;
 403
 404         spin_lock_irqsave(&tdc->vc.lock, flags);
 405         ret = tegra_dma_pause(tdc);
 406         spin_unlock_irqrestore(&tdc->vc.lock, flags);
 407
 408         return ret;
 409 }
 410
 411 static void tegra_dma_resume(struct tegra_dma_channel *tdc)
 412 {
 413         u32 val;
 414
 415         val = tdc_read(tdc, TEGRA_GPCDMA_CHAN_CSRE);
 416         val &= ~TEGRA_GPCDMA_CHAN_CSRE_PAUSE;
 417         tdc_write(tdc, TEGRA_GPCDMA_CHAN_CSRE, val);
 418 }
 419
 420 static int tegra_dma_device_resume(struct dma_chan *dc)
 421 {
 422         struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
 423         unsigned long flags;
 424
 425         if (!tdc->tdma->chip_data->hw_support_pause)
 426                 return -ENOSYS;
 427
 428         spin_lock_irqsave(&tdc->vc.lock, flags);
 429         tegra_dma_resume(tdc);
 430         spin_unlock_irqrestore(&tdc->vc.lock, flags);
 431
 432         return 0;
 433 }
 434
 435 static inline int tegra_dma_pause_noerr(struct tegra_dma_channel *tdc)
 436 {
 437         /* Return 0 irrespective of PAUSE status.
 438          * This is useful to recover channels that can exit out of flush
 439          * state when the channel is disabled.
 440          */
 441
 442         tegra_dma_pause(tdc);
 443         return 0;
 444 }
 445
 446 static void tegra_dma_disable(struct tegra_dma_channel *tdc)
 447 {
 448         u32 csr, status;
 449
 450         csr = tdc_read(tdc, TEGRA_GPCDMA_CHAN_CSR);
 451
 452         /* Disable interrupts */
 453         csr &= ~TEGRA_GPCDMA_CSR_IE_EOC;
 454
 455         /* Disable DMA */
 456         csr &= ~TEGRA_GPCDMA_CSR_ENB;
 457         tdc_write(tdc, TEGRA_GPCDMA_CHAN_CSR, csr);
 458
 459         /* Clear interrupt status if it is there */
 460         status = tdc_read(tdc, TEGRA_GPCDMA_CHAN_STATUS);
 461         if (status & TEGRA_GPCDMA_STATUS_ISE_EOC) {
 462                 dev_dbg(tdc2dev(tdc), "%s():clearing interrupt\n", __func__);
 463                 tdc_write(tdc, TEGRA_GPCDMA_CHAN_STATUS, status);
 464         }
 465 }
 466
 467 static void tegra_dma_configure_next_sg(struct tegra_dma_channel *tdc)
 468 {
 469         struct tegra_dma_desc *dma_desc = tdc->dma_desc;
 470         struct tegra_dma_channel_regs *ch_regs;
 471         int ret;
 472         u32 val;
 473
 474         dma_desc->sg_idx++;
 475
 476         /* Reset the sg index for cyclic transfers */
 477         if (dma_desc->sg_idx == dma_desc->sg_count)
 478                 dma_desc->sg_idx = 0;
 479
 480         /* Configure next transfer immediately after DMA is busy */
 481         ret = readl_relaxed_poll_timeout_atomic(tdc->tdma->base_addr +
 482                         tdc->chan_base_offset + TEGRA_GPCDMA_CHAN_STATUS,
 483                         val,
 484                         (val & TEGRA_GPCDMA_STATUS_BUSY), 0,
 485                         TEGRA_GPCDMA_BURST_COMPLETION_TIMEOUT);
 486         if (ret)
 487                 return;
 488
 489         ch_regs = &dma_desc->sg_req[dma_desc->sg_idx].ch_regs;
 490
 491         tdc_write(tdc, TEGRA_GPCDMA_CHAN_WCOUNT, ch_regs->wcount);
 492         tdc_write(tdc, TEGRA_GPCDMA_CHAN_SRC_PTR, ch_regs->src_ptr);
 493         tdc_write(tdc, TEGRA_GPCDMA_CHAN_DST_PTR, ch_regs->dst_ptr);
 494         tdc_write(tdc, TEGRA_GPCDMA_CHAN_HIGH_ADDR_PTR, ch_regs->high_addr_ptr);
 495
 496         /* Start DMA */
 497         tdc_write(tdc, TEGRA_GPCDMA_CHAN_CSR,
 498                   ch_regs->csr | TEGRA_GPCDMA_CSR_ENB);
 499 }
 500
 501 static void tegra_dma_start(struct tegra_dma_channel *tdc)
 502 {
 503         struct tegra_dma_desc *dma_desc = tdc->dma_desc;
 504         struct tegra_dma_channel_regs *ch_regs;
 505         struct virt_dma_desc *vdesc;
 506
 507         if (!dma_desc) {
 508                 vdesc = vchan_next_desc(&tdc->vc);
 509                 if (!vdesc)
 510                         return;
 511
 512                 dma_desc = vd_to_tegra_dma_desc(vdesc);
 513                 list_del(&vdesc->node);
 514                 dma_desc->tdc = tdc;
 515                 tdc->dma_desc = dma_desc;
 516
 517                 tegra_dma_resume(tdc);
 518         }
 519
 520         ch_regs = &dma_desc->sg_req[dma_desc->sg_idx].ch_regs;
 521
 522         tdc_write(tdc, TEGRA_GPCDMA_CHAN_WCOUNT, ch_regs->wcount);
 523         tdc_write(tdc, TEGRA_GPCDMA_CHAN_CSR, 0);
 524         tdc_write(tdc, TEGRA_GPCDMA_CHAN_SRC_PTR, ch_regs->src_ptr);
 525         tdc_write(tdc, TEGRA_GPCDMA_CHAN_DST_PTR, ch_regs->dst_ptr);
 526         tdc_write(tdc, TEGRA_GPCDMA_CHAN_HIGH_ADDR_PTR, ch_regs->high_addr_ptr);
 527         tdc_write(tdc, TEGRA_GPCDMA_CHAN_FIXED_PATTERN, ch_regs->fixed_pattern);
 528         tdc_write(tdc, TEGRA_GPCDMA_CHAN_MMIOSEQ, ch_regs->mmio_seq);
 529         tdc_write(tdc, TEGRA_GPCDMA_CHAN_MCSEQ, ch_regs->mc_seq);
 530         tdc_write(tdc, TEGRA_GPCDMA_CHAN_CSR, ch_regs->csr);
 531
 532         /* Start DMA */
 533         tdc_write(tdc, TEGRA_GPCDMA_CHAN_CSR,
 534                   ch_regs->csr | TEGRA_GPCDMA_CSR_ENB);
 535 }
 536
 537 static void tegra_dma_xfer_complete(struct tegra_dma_channel *tdc)
 538 {
 539         vchan_cookie_complete(&tdc->dma_desc->vd);
 540
 541         tegra_dma_sid_free(tdc);
 542         tdc->dma_desc = NULL;
 543 }
 544
 545 static void tegra_dma_chan_decode_error(struct tegra_dma_channel *tdc,
 546                                         unsigned int err_status)
 547 {
 548         switch (TEGRA_GPCDMA_CHAN_ERR_TYPE(err_status)) {
 549         case TEGRA_DMA_BM_FIFO_FULL_ERR:
 550                 dev_err(tdc->tdma->dev,
 551                         "GPCDMA CH%d bm fifo full\n", tdc->id);
 552                 break;
 553
 554         case TEGRA_DMA_PERIPH_FIFO_FULL_ERR:
 555                 dev_err(tdc->tdma->dev,
 556                         "GPCDMA CH%d peripheral fifo full\n", tdc->id);
 557                 break;
 558
 559         case TEGRA_DMA_PERIPH_ID_ERR:
 560                 dev_err(tdc->tdma->dev,
 561                         "GPCDMA CH%d illegal peripheral id\n", tdc->id);
 562                 break;
 563
 564         case TEGRA_DMA_STREAM_ID_ERR:
 565                 dev_err(tdc->tdma->dev,
 566                         "GPCDMA CH%d illegal stream id\n", tdc->id);
 567                 break;
 568
 569         case TEGRA_DMA_MC_SLAVE_ERR:
 570                 dev_err(tdc->tdma->dev,
 571                         "GPCDMA CH%d mc slave error\n", tdc->id);
 572                 break;
 573
 574         case TEGRA_DMA_MMIO_SLAVE_ERR:
 575                 dev_err(tdc->tdma->dev,
 576                         "GPCDMA CH%d mmio slave error\n", tdc->id);
 577                 break;
 578
 579         default:
 580                 dev_err(tdc->tdma->dev,
 581                         "GPCDMA CH%d security violation %x\n", tdc->id,
 582                         err_status);
 583         }
 584 }
 585
 586 static irqreturn_t tegra_dma_isr(int irq, void *dev_id)
 587 {
 588         struct tegra_dma_channel *tdc = dev_id;
 589         struct tegra_dma_desc *dma_desc = tdc->dma_desc;
 590         struct tegra_dma_sg_req *sg_req;
 591         u32 status;
 592
 593         /* Check channel error status register */
 594         status = tdc_read(tdc, TEGRA_GPCDMA_CHAN_ERR_STATUS);
 595         if (status) {
 596                 tegra_dma_chan_decode_error(tdc, status);
 597                 tegra_dma_dump_chan_regs(tdc);
 598                 tdc_write(tdc, TEGRA_GPCDMA_CHAN_ERR_STATUS, 0xFFFFFFFF);
 599         }
 600
 601         spin_lock(&tdc->vc.lock);
 602         status = tdc_read(tdc, TEGRA_GPCDMA_CHAN_STATUS);
 603         if (!(status & TEGRA_GPCDMA_STATUS_ISE_EOC))
 604                 goto irq_done;
 605
 606         tdc_write(tdc, TEGRA_GPCDMA_CHAN_STATUS,
 607                   TEGRA_GPCDMA_STATUS_ISE_EOC);
 608
 609         if (!dma_desc)
 610                 goto irq_done;
 611
 612         sg_req = dma_desc->sg_req;
 613         dma_desc->bytes_xfer += sg_req[dma_desc->sg_idx].len;
 614
 615         if (dma_desc->cyclic) {
 616                 vchan_cyclic_callback(&dma_desc->vd);
 617                 tegra_dma_configure_next_sg(tdc);
 618         } else {
 619                 dma_desc->sg_idx++;
 620                 if (dma_desc->sg_idx == dma_desc->sg_count)
 621                         tegra_dma_xfer_complete(tdc);
 622                 else
 623                         tegra_dma_start(tdc);
 624         }
 625
 626 irq_done:
 627         spin_unlock(&tdc->vc.lock);
 628         return IRQ_HANDLED;
 629 }
 630
 631 static void tegra_dma_issue_pending(struct dma_chan *dc)
 632 {
 633         struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
 634         unsigned long flags;
 635
 636         if (tdc->dma_desc)
 637                 return;
 638
 639         spin_lock_irqsave(&tdc->vc.lock, flags);
 640         if (vchan_issue_pending(&tdc->vc))
 641                 tegra_dma_start(tdc);
 642
 643         /*
 644          * For cyclic DMA transfers, program the second
 645          * transfer parameters as soon as the first DMA
 646          * transfer is started inorder for the DMA
 647          * controller to trigger the second transfer
 648          * with the correct parameters.
 649          */
 650         if (tdc->dma_desc && tdc->dma_desc->cyclic)
 651                 tegra_dma_configure_next_sg(tdc);
 652
 653         spin_unlock_irqrestore(&tdc->vc.lock, flags);
 654 }
 655
 656 static int tegra_dma_stop_client(struct tegra_dma_channel *tdc)
 657 {
 658         int ret;
 659         u32 status, csr;
 660
 661         /*
 662          * Change the client associated with the DMA channel
 663          * to stop DMA engine from starting any more bursts for
 664          * the given client and wait for in flight bursts to complete
 665          */
 666         csr = tdc_read(tdc, TEGRA_GPCDMA_CHAN_CSR);
 667         csr &= ~(TEGRA_GPCDMA_CSR_REQ_SEL_MASK);
 668         csr |= TEGRA_GPCDMA_CSR_REQ_SEL_UNUSED;
 669         tdc_write(tdc, TEGRA_GPCDMA_CHAN_CSR, csr);
 670
 671         /* Wait for in flight data transfer to finish */
 672         udelay(TEGRA_GPCDMA_BURST_COMPLETE_TIME);
 673
 674         /* If TX/RX path is still active wait till it becomes
 675          * inactive
 676          */
 677
 678         ret = readl_relaxed_poll_timeout_atomic(tdc->tdma->base_addr +
 679                                 tdc->chan_base_offset +
 680                                 TEGRA_GPCDMA_CHAN_STATUS,
 681                                 status,
 682                                 !(status & (TEGRA_GPCDMA_STATUS_CHANNEL_TX |
 683                                 TEGRA_GPCDMA_STATUS_CHANNEL_RX)),
 684                                 5,
 685                                 TEGRA_GPCDMA_BURST_COMPLETION_TIMEOUT);
 686         if (ret) {
 687                 dev_err(tdc2dev(tdc), "Timeout waiting for DMA burst completion!\n");
 688                 tegra_dma_dump_chan_regs(tdc);
 689         }
 690
 691         return ret;
 692 }
 693
 694 static int tegra_dma_terminate_all(struct dma_chan *dc)
 695 {
 696         struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
 697         unsigned long flags;
 698         LIST_HEAD(head);
 699         int err;
 700
 701         spin_lock_irqsave(&tdc->vc.lock, flags);
 702
 703         if (tdc->dma_desc) {
 704                 err = tdc->tdma->chip_data->terminate(tdc);
 705                 if (err) {
 706                         spin_unlock_irqrestore(&tdc->vc.lock, flags);
 707                         return err;
 708                 }
 709
 710                 vchan_terminate_vdesc(&tdc->dma_desc->vd);
 711                 tegra_dma_disable(tdc);
 712                 tdc->dma_desc = NULL;
 713         }
 714
 715         tegra_dma_sid_free(tdc);
 716         vchan_get_all_descriptors(&tdc->vc, &head);
 717         spin_unlock_irqrestore(&tdc->vc.lock, flags);
 718
 719         vchan_dma_desc_free_list(&tdc->vc, &head);
 720
 721         return 0;
 722 }
 723
 724 static int tegra_dma_get_residual(struct tegra_dma_channel *tdc)
 725 {
 726         struct tegra_dma_desc *dma_desc = tdc->dma_desc;
 727         struct tegra_dma_sg_req *sg_req = dma_desc->sg_req;
 728         unsigned int bytes_xfer, residual;
 729         u32 wcount = 0, status;
 730
 731         wcount = tdc_read(tdc, TEGRA_GPCDMA_CHAN_XFER_COUNT);
 732
 733         /*
 734          * Set wcount = 0 if EOC bit is set. The transfer would have
 735          * already completed and the CHAN_XFER_COUNT could have updated
 736          * for the next transfer, specifically in case of cyclic transfers.
 737          */
 738         status = tdc_read(tdc, TEGRA_GPCDMA_CHAN_STATUS);
 739         if (status & TEGRA_GPCDMA_STATUS_ISE_EOC)
 740                 wcount = 0;
 741
 742         bytes_xfer = dma_desc->bytes_xfer +
 743                      sg_req[dma_desc->sg_idx].len - (wcount * 4);
 744
 745         residual = dma_desc->bytes_req - (bytes_xfer % dma_desc->bytes_req);
 746
 747         return residual;
 748 }
 749
 750 static enum dma_status tegra_dma_tx_status(struct dma_chan *dc,
 751                                            dma_cookie_t cookie,
 752                                            struct dma_tx_state *txstate)
 753 {
 754         struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
 755         struct tegra_dma_desc *dma_desc;
 756         struct virt_dma_desc *vd;
 757         unsigned int residual;
 758         unsigned long flags;
 759         enum dma_status ret;
 760
 761         ret = dma_cookie_status(dc, cookie, txstate);
 762         if (ret == DMA_COMPLETE)
 763                 return ret;
 764
 765         spin_lock_irqsave(&tdc->vc.lock, flags);
 766         vd = vchan_find_desc(&tdc->vc, cookie);
 767         if (vd) {
 768                 dma_desc = vd_to_tegra_dma_desc(vd);
 769                 residual = dma_desc->bytes_req;
 770                 dma_set_residue(txstate, residual);
 771         } else if (tdc->dma_desc && tdc->dma_desc->vd.tx.cookie == cookie) {
 772                 residual =  tegra_dma_get_residual(tdc);
 773                 dma_set_residue(txstate, residual);
 774         } else {
 775                 dev_err(tdc2dev(tdc), "cookie %d is not found\n", cookie);
 776         }
 777         spin_unlock_irqrestore(&tdc->vc.lock, flags);
 778
 779         return ret;
 780 }
 781
 782 static inline int get_bus_width(struct tegra_dma_channel *tdc,
 783                                 enum dma_slave_buswidth slave_bw)
 784 {
 785         switch (slave_bw) {
 786         case DMA_SLAVE_BUSWIDTH_1_BYTE:
 787                 return TEGRA_GPCDMA_MMIOSEQ_BUS_WIDTH_8;
 788         case DMA_SLAVE_BUSWIDTH_2_BYTES:
 789                 return TEGRA_GPCDMA_MMIOSEQ_BUS_WIDTH_16;
 790         case DMA_SLAVE_BUSWIDTH_4_BYTES:
 791                 return TEGRA_GPCDMA_MMIOSEQ_BUS_WIDTH_32;
 792         default:
 793                 dev_err(tdc2dev(tdc), "given slave bus width is not supported\n");
 794                 return -EINVAL;
 795         }
 796 }
 797
 798 static unsigned int get_burst_size(struct tegra_dma_channel *tdc,
 799                                    u32 burst_size, enum dma_slave_buswidth slave_bw,
 800                                    int len)
 801 {
 802         unsigned int burst_mmio_width, burst_byte;
 803
 804         /*
 805          * burst_size from client is in terms of the bus_width.
 806          * convert that into words.
 807          * If burst_size is not specified from client, then use
 808          * len to calculate the optimum burst size
 809          */
 810         burst_byte = burst_size ? burst_size * slave_bw : len;
 811         burst_mmio_width = burst_byte / 4;
 812
 813         if (burst_mmio_width < TEGRA_GPCDMA_MMIOSEQ_BURST_MIN)
 814                 return 0;
 815
 816         burst_mmio_width = min(burst_mmio_width, TEGRA_GPCDMA_MMIOSEQ_BURST_MAX);
 817
 818         return TEGRA_GPCDMA_MMIOSEQ_BURST(burst_mmio_width);
 819 }
 820
 821 static int get_transfer_param(struct tegra_dma_channel *tdc,
 822                               enum dma_transfer_direction direction,
 823                               u32 *apb_addr,
 824                               u32 *mmio_seq,
 825                               u32 *csr,
 826                               unsigned int *burst_size,
 827                               enum dma_slave_buswidth *slave_bw)
 828 {
 829         switch (direction) {
 830         case DMA_MEM_TO_DEV:
 831                 *apb_addr = tdc->dma_sconfig.dst_addr;
 832                 *mmio_seq = get_bus_width(tdc, tdc->dma_sconfig.dst_addr_width);
 833                 *burst_size = tdc->dma_sconfig.dst_maxburst;
 834                 *slave_bw = tdc->dma_sconfig.dst_addr_width;
 835                 *csr = TEGRA_GPCDMA_CSR_DMA_MEM2IO_FC;
 836                 return 0;
 837         case DMA_DEV_TO_MEM:
 838                 *apb_addr = tdc->dma_sconfig.src_addr;
 839                 *mmio_seq = get_bus_width(tdc, tdc->dma_sconfig.src_addr_width);
 840                 *burst_size = tdc->dma_sconfig.src_maxburst;
 841                 *slave_bw = tdc->dma_sconfig.src_addr_width;
 842                 *csr = TEGRA_GPCDMA_CSR_DMA_IO2MEM_FC;
 843                 return 0;
 844         default:
 845                 dev_err(tdc2dev(tdc), "DMA direction is not supported\n");
 846         }
 847
 848         return -EINVAL;
 849 }
 850
 851 static struct dma_async_tx_descriptor *
 852 tegra_dma_prep_dma_memset(struct dma_chan *dc, dma_addr_t dest, int value,
 853                           size_t len, unsigned long flags)
 854 {
 855         struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
 856         unsigned int max_dma_count = tdc->tdma->chip_data->max_dma_count;
 857         struct tegra_dma_sg_req *sg_req;
 858         struct tegra_dma_desc *dma_desc;
 859         u32 csr, mc_seq;
 860
 861         if ((len & 3) || (dest & 3) || len > max_dma_count) {
 862                 dev_err(tdc2dev(tdc),
 863                         "DMA length/memory address is not supported\n");
 864                 return NULL;
 865         }
 866
 867         /* Set DMA mode to fixed pattern */
 868         csr = TEGRA_GPCDMA_CSR_DMA_FIXED_PAT;
 869         /* Enable once or continuous mode */
 870         csr |= TEGRA_GPCDMA_CSR_ONCE;
 871         /* Enable IRQ mask */
 872         csr |= TEGRA_GPCDMA_CSR_IRQ_MASK;
 873         /* Enable the DMA interrupt */
 874         if (flags & DMA_PREP_INTERRUPT)
 875                 csr |= TEGRA_GPCDMA_CSR_IE_EOC;
 876         /* Configure default priority weight for the channel */
 877         csr |= FIELD_PREP(TEGRA_GPCDMA_CSR_WEIGHT, 1);
 878
 879         mc_seq =  tdc_read(tdc, TEGRA_GPCDMA_CHAN_MCSEQ);
 880         /* retain stream-id and clean rest */
 881         mc_seq &= TEGRA_GPCDMA_MCSEQ_STREAM_ID0_MASK;
 882
 883         /* Set the address wrapping */
 884         mc_seq |= FIELD_PREP(TEGRA_GPCDMA_MCSEQ_WRAP0,
 885                                                 TEGRA_GPCDMA_MCSEQ_WRAP_NONE);
 886         mc_seq |= FIELD_PREP(TEGRA_GPCDMA_MCSEQ_WRAP1,
 887                                                 TEGRA_GPCDMA_MCSEQ_WRAP_NONE);
 888
 889         /* Program outstanding MC requests */
 890         mc_seq |= FIELD_PREP(TEGRA_GPCDMA_MCSEQ_REQ_COUNT, 1);
 891         /* Set burst size */
 892         mc_seq |= TEGRA_GPCDMA_MCSEQ_BURST_16;
 893
 894         dma_desc = kzalloc(struct_size(dma_desc, sg_req, 1), GFP_NOWAIT);
 895         if (!dma_desc)
 896                 return NULL;
 897
 898         dma_desc->bytes_req = len;
 899         dma_desc->sg_count = 1;
 900         sg_req = dma_desc->sg_req;
 901
 902         sg_req[0].ch_regs.src_ptr = 0;
 903         sg_req[0].ch_regs.dst_ptr = dest;
 904         sg_req[0].ch_regs.high_addr_ptr =
 905                         FIELD_PREP(TEGRA_GPCDMA_HIGH_ADDR_DST_PTR, (dest >> 32));
 906         sg_req[0].ch_regs.fixed_pattern = value;
 907         /* Word count reg takes value as (N +1) words */
 908         sg_req[0].ch_regs.wcount = ((len - 4) >> 2);
 909         sg_req[0].ch_regs.csr = csr;
 910         sg_req[0].ch_regs.mmio_seq = 0;
 911         sg_req[0].ch_regs.mc_seq = mc_seq;
 912         sg_req[0].len = len;
 913
 914         dma_desc->cyclic = false;
 915         return vchan_tx_prep(&tdc->vc, &dma_desc->vd, flags);
 916 }
 917
 918 static struct dma_async_tx_descriptor *
 919 tegra_dma_prep_dma_memcpy(struct dma_chan *dc, dma_addr_t dest,
 920                           dma_addr_t src, size_t len, unsigned long flags)
 921 {
 922         struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
 923         struct tegra_dma_sg_req *sg_req;
 924         struct tegra_dma_desc *dma_desc;
 925         unsigned int max_dma_count;
 926         u32 csr, mc_seq;
 927
 928         max_dma_count = tdc->tdma->chip_data->max_dma_count;
 929         if ((len & 3) || (src & 3) || (dest & 3) || len > max_dma_count) {
 930                 dev_err(tdc2dev(tdc),
 931                         "DMA length/memory address is not supported\n");
 932                 return NULL;
 933         }
 934
 935         /* Set DMA mode to memory to memory transfer */
 936         csr = TEGRA_GPCDMA_CSR_DMA_MEM2MEM;
 937         /* Enable once or continuous mode */
 938         csr |= TEGRA_GPCDMA_CSR_ONCE;
 939         /* Enable IRQ mask */
 940         csr |= TEGRA_GPCDMA_CSR_IRQ_MASK;
 941         /* Enable the DMA interrupt */
 942         if (flags & DMA_PREP_INTERRUPT)
 943                 csr |= TEGRA_GPCDMA_CSR_IE_EOC;
 944         /* Configure default priority weight for the channel */
 945         csr |= FIELD_PREP(TEGRA_GPCDMA_CSR_WEIGHT, 1);
 946
 947         mc_seq =  tdc_read(tdc, TEGRA_GPCDMA_CHAN_MCSEQ);
 948         /* retain stream-id and clean rest */
 949         mc_seq &= (TEGRA_GPCDMA_MCSEQ_STREAM_ID0_MASK) |
 950                   (TEGRA_GPCDMA_MCSEQ_STREAM_ID1_MASK);
 951
 952         /* Set the address wrapping */
 953         mc_seq |= FIELD_PREP(TEGRA_GPCDMA_MCSEQ_WRAP0,
 954                              TEGRA_GPCDMA_MCSEQ_WRAP_NONE);
 955         mc_seq |= FIELD_PREP(TEGRA_GPCDMA_MCSEQ_WRAP1,
 956                              TEGRA_GPCDMA_MCSEQ_WRAP_NONE);
 957
 958         /* Program outstanding MC requests */
 959         mc_seq |= FIELD_PREP(TEGRA_GPCDMA_MCSEQ_REQ_COUNT, 1);
 960         /* Set burst size */
 961         mc_seq |= TEGRA_GPCDMA_MCSEQ_BURST_16;
 962
 963         dma_desc = kzalloc(struct_size(dma_desc, sg_req, 1), GFP_NOWAIT);
 964         if (!dma_desc)
 965                 return NULL;
 966
 967         dma_desc->bytes_req = len;
 968         dma_desc->sg_count = 1;
 969         sg_req = dma_desc->sg_req;
 970
 971         sg_req[0].ch_regs.src_ptr = src;
 972         sg_req[0].ch_regs.dst_ptr = dest;
 973         sg_req[0].ch_regs.high_addr_ptr =
 974                 FIELD_PREP(TEGRA_GPCDMA_HIGH_ADDR_SRC_PTR, (src >> 32));
 975         sg_req[0].ch_regs.high_addr_ptr |=
 976                 FIELD_PREP(TEGRA_GPCDMA_HIGH_ADDR_DST_PTR, (dest >> 32));
 977         /* Word count reg takes value as (N +1) words */
 978         sg_req[0].ch_regs.wcount = ((len - 4) >> 2);
 979         sg_req[0].ch_regs.csr = csr;
 980         sg_req[0].ch_regs.mmio_seq = 0;
 981         sg_req[0].ch_regs.mc_seq = mc_seq;
 982         sg_req[0].len = len;
 983
 984         dma_desc->cyclic = false;
 985         return vchan_tx_prep(&tdc->vc, &dma_desc->vd, flags);
 986 }
 987
 988 static struct dma_async_tx_descriptor *
 989 tegra_dma_prep_slave_sg(struct dma_chan *dc, struct scatterlist *sgl,
 990                         unsigned int sg_len, enum dma_transfer_direction direction,
 991                         unsigned long flags, void *context)
 992 {
 993         struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
 994         unsigned int max_dma_count = tdc->tdma->chip_data->max_dma_count;
 995         enum dma_slave_buswidth slave_bw = DMA_SLAVE_BUSWIDTH_UNDEFINED;
 996         u32 csr, mc_seq, apb_ptr = 0, mmio_seq = 0;
 997         struct tegra_dma_sg_req *sg_req;
 998         struct tegra_dma_desc *dma_desc;
 999         struct scatterlist *sg;
1000         u32 burst_size;
1001         unsigned int i;
1002         int ret;
1003
1004         if (!tdc->config_init) {
1005                 dev_err(tdc2dev(tdc), "DMA channel is not configured\n");
1006                 return NULL;
1007         }
1008         if (sg_len < 1) {
1009                 dev_err(tdc2dev(tdc), "Invalid segment length %d\n", sg_len);
1010                 return NULL;
1011         }
1012
1013         ret = tegra_dma_sid_reserve(tdc, direction);
1014         if (ret)
1015                 return NULL;
1016
1017         ret = get_transfer_param(tdc, direction, &apb_ptr, &mmio_seq, &csr,
1018                                  &burst_size, &slave_bw);
1019         if (ret < 0)
1020                 return NULL;
1021
1022         /* Enable once or continuous mode */
1023         csr |= TEGRA_GPCDMA_CSR_ONCE;
1024         /* Program the slave id in requestor select */
1025         csr |= FIELD_PREP(TEGRA_GPCDMA_CSR_REQ_SEL_MASK, tdc->slave_id);
1026         /* Enable IRQ mask */
1027         csr |= TEGRA_GPCDMA_CSR_IRQ_MASK;
1028         /* Configure default priority weight for the channel*/
1029         csr |= FIELD_PREP(TEGRA_GPCDMA_CSR_WEIGHT, 1);
1030
1031         /* Enable the DMA interrupt */
1032         if (flags & DMA_PREP_INTERRUPT)
1033                 csr |= TEGRA_GPCDMA_CSR_IE_EOC;
1034
1035         mc_seq =  tdc_read(tdc, TEGRA_GPCDMA_CHAN_MCSEQ);
1036         /* retain stream-id and clean rest */
1037         mc_seq &= TEGRA_GPCDMA_MCSEQ_STREAM_ID0_MASK;
1038
1039         /* Set the address wrapping on both MC and MMIO side */
1040
1041         mc_seq |= FIELD_PREP(TEGRA_GPCDMA_MCSEQ_WRAP0,
1042                              TEGRA_GPCDMA_MCSEQ_WRAP_NONE);
1043         mc_seq |= FIELD_PREP(TEGRA_GPCDMA_MCSEQ_WRAP1,
1044                              TEGRA_GPCDMA_MCSEQ_WRAP_NONE);
1045         mmio_seq |= FIELD_PREP(TEGRA_GPCDMA_MMIOSEQ_WRAP_WORD, 1);
1046
1047         /* Program 2 MC outstanding requests by default. */
1048         mc_seq |= FIELD_PREP(TEGRA_GPCDMA_MCSEQ_REQ_COUNT, 1);
1049
1050         /* Setting MC burst size depending on MMIO burst size */
1051         if (burst_size == 64)
1052                 mc_seq |= TEGRA_GPCDMA_MCSEQ_BURST_16;
1053         else
1054                 mc_seq |= TEGRA_GPCDMA_MCSEQ_BURST_2;
1055
1056         dma_desc = kzalloc(struct_size(dma_desc, sg_req, sg_len), GFP_NOWAIT);
1057         if (!dma_desc)
1058                 return NULL;
1059
1060         dma_desc->sg_count = sg_len;
1061         sg_req = dma_desc->sg_req;
1062
1063         /* Make transfer requests */
1064         for_each_sg(sgl, sg, sg_len, i) {
1065                 u32 len;
1066                 dma_addr_t mem;
1067
1068                 mem = sg_dma_address(sg);
1069                 len = sg_dma_len(sg);
1070
1071                 if ((len & 3) || (mem & 3) || len > max_dma_count) {
1072                         dev_err(tdc2dev(tdc),
1073                                 "DMA length/memory address is not supported\n");
1074                         kfree(dma_desc);
1075                         return NULL;
1076                 }
1077
1078                 mmio_seq |= get_burst_size(tdc, burst_size, slave_bw, len);
1079                 dma_desc->bytes_req += len;
1080
1081                 if (direction == DMA_MEM_TO_DEV) {
1082                         sg_req[i].ch_regs.src_ptr = mem;
1083                         sg_req[i].ch_regs.dst_ptr = apb_ptr;
1084                         sg_req[i].ch_regs.high_addr_ptr =
1085                                 FIELD_PREP(TEGRA_GPCDMA_HIGH_ADDR_SRC_PTR, (mem >> 32));
1086                 } else if (direction == DMA_DEV_TO_MEM) {
1087                         sg_req[i].ch_regs.src_ptr = apb_ptr;
1088                         sg_req[i].ch_regs.dst_ptr = mem;
1089                         sg_req[i].ch_regs.high_addr_ptr =
1090                                 FIELD_PREP(TEGRA_GPCDMA_HIGH_ADDR_DST_PTR, (mem >> 32));
1091                 }
1092
1093                 /*
1094                  * Word count register takes input in words. Writing a value
1095                  * of N into word count register means a req of (N+1) words.
1096                  */
1097                 sg_req[i].ch_regs.wcount = ((len - 4) >> 2);
1098                 sg_req[i].ch_regs.csr = csr;
1099                 sg_req[i].ch_regs.mmio_seq = mmio_seq;
1100                 sg_req[i].ch_regs.mc_seq = mc_seq;
1101                 sg_req[i].len = len;
1102         }
1103
1104         dma_desc->cyclic = false;
1105         return vchan_tx_prep(&tdc->vc, &dma_desc->vd, flags);
1106 }
1107
1108 static struct dma_async_tx_descriptor *
1109 tegra_dma_prep_dma_cyclic(struct dma_chan *dc, dma_addr_t buf_addr, size_t buf_len,
1110                           size_t period_len, enum dma_transfer_direction direction,
1111                           unsigned long flags)
1112 {
1113         enum dma_slave_buswidth slave_bw = DMA_SLAVE_BUSWIDTH_UNDEFINED;
1114         u32 csr, mc_seq, apb_ptr = 0, mmio_seq = 0, burst_size;
1115         unsigned int max_dma_count, len, period_count, i;
1116         struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
1117         struct tegra_dma_desc *dma_desc;
1118         struct tegra_dma_sg_req *sg_req;
1119         dma_addr_t mem = buf_addr;
1120         int ret;
1121
1122         if (!buf_len || !period_len) {
1123                 dev_err(tdc2dev(tdc), "Invalid buffer/period len\n");
1124                 return NULL;
1125         }
1126
1127         if (!tdc->config_init) {
1128                 dev_err(tdc2dev(tdc), "DMA slave is not configured\n");
1129                 return NULL;
1130         }
1131
1132         ret = tegra_dma_sid_reserve(tdc, direction);
1133         if (ret)
1134                 return NULL;
1135
1136         /*
1137          * We only support cycle transfer when buf_len is multiple of
1138          * period_len.
1139          */
1140         if (buf_len % period_len) {
1141                 dev_err(tdc2dev(tdc), "buf_len is not multiple of period_len\n");
1142                 return NULL;
1143         }
1144
1145         len = period_len;
1146         max_dma_count = tdc->tdma->chip_data->max_dma_count;
1147         if ((len & 3) || (buf_addr & 3) || len > max_dma_count) {
1148                 dev_err(tdc2dev(tdc), "Req len/mem address is not correct\n");
1149                 return NULL;
1150         }
1151
1152         ret = get_transfer_param(tdc, direction, &apb_ptr, &mmio_seq, &csr,
1153                                  &burst_size, &slave_bw);
1154         if (ret < 0)
1155                 return NULL;
1156
1157         /* Enable once or continuous mode */
1158         csr &= ~TEGRA_GPCDMA_CSR_ONCE;
1159         /* Program the slave id in requestor select */
1160         csr |= FIELD_PREP(TEGRA_GPCDMA_CSR_REQ_SEL_MASK, tdc->slave_id);
1161         /* Enable IRQ mask */
1162         csr |= TEGRA_GPCDMA_CSR_IRQ_MASK;
1163         /* Configure default priority weight for the channel*/
1164         csr |= FIELD_PREP(TEGRA_GPCDMA_CSR_WEIGHT, 1);
1165
1166         /* Enable the DMA interrupt */
1167         if (flags & DMA_PREP_INTERRUPT)
1168                 csr |= TEGRA_GPCDMA_CSR_IE_EOC;
1169
1170         mmio_seq |= FIELD_PREP(TEGRA_GPCDMA_MMIOSEQ_WRAP_WORD, 1);
1171
1172         mc_seq =  tdc_read(tdc, TEGRA_GPCDMA_CHAN_MCSEQ);
1173         /* retain stream-id and clean rest */
1174         mc_seq &= TEGRA_GPCDMA_MCSEQ_STREAM_ID0_MASK;
1175
1176         /* Set the address wrapping on both MC and MMIO side */
1177         mc_seq |= FIELD_PREP(TEGRA_GPCDMA_MCSEQ_WRAP0,
1178                              TEGRA_GPCDMA_MCSEQ_WRAP_NONE);
1179         mc_seq |= FIELD_PREP(TEGRA_GPCDMA_MCSEQ_WRAP1,
1180                              TEGRA_GPCDMA_MCSEQ_WRAP_NONE);
1181
1182         /* Program 2 MC outstanding requests by default. */
1183         mc_seq |= FIELD_PREP(TEGRA_GPCDMA_MCSEQ_REQ_COUNT, 1);
1184         /* Setting MC burst size depending on MMIO burst size */
1185         if (burst_size == 64)
1186                 mc_seq |= TEGRA_GPCDMA_MCSEQ_BURST_16;
1187         else
1188                 mc_seq |= TEGRA_GPCDMA_MCSEQ_BURST_2;
1189
1190         period_count = buf_len / period_len;
1191         dma_desc = kzalloc(struct_size(dma_desc, sg_req, period_count),
1192                            GFP_NOWAIT);
1193         if (!dma_desc)
1194                 return NULL;
1195
1196         dma_desc->bytes_req = buf_len;
1197         dma_desc->sg_count = period_count;
1198         sg_req = dma_desc->sg_req;
1199
1200         /* Split transfer equal to period size */
1201         for (i = 0; i < period_count; i++) {
1202                 mmio_seq |= get_burst_size(tdc, burst_size, slave_bw, len);
1203                 if (direction == DMA_MEM_TO_DEV) {
1204                         sg_req[i].ch_regs.src_ptr = mem;
1205                         sg_req[i].ch_regs.dst_ptr = apb_ptr;
1206                         sg_req[i].ch_regs.high_addr_ptr =
1207                                 FIELD_PREP(TEGRA_GPCDMA_HIGH_ADDR_SRC_PTR, (mem >> 32));
1208                 } else if (direction == DMA_DEV_TO_MEM) {
1209                         sg_req[i].ch_regs.src_ptr = apb_ptr;
1210                         sg_req[i].ch_regs.dst_ptr = mem;
1211                         sg_req[i].ch_regs.high_addr_ptr =
1212                                 FIELD_PREP(TEGRA_GPCDMA_HIGH_ADDR_DST_PTR, (mem >> 32));
1213                 }
1214                 /*
1215                  * Word count register takes input in words. Writing a value
1216                  * of N into word count register means a req of (N+1) words.
1217                  */
1218                 sg_req[i].ch_regs.wcount = ((len - 4) >> 2);
1219                 sg_req[i].ch_regs.csr = csr;
1220                 sg_req[i].ch_regs.mmio_seq = mmio_seq;
1221                 sg_req[i].ch_regs.mc_seq = mc_seq;
1222                 sg_req[i].len = len;
1223
1224                 mem += len;
1225         }
1226
1227         dma_desc->cyclic = true;
1228
1229         return vchan_tx_prep(&tdc->vc, &dma_desc->vd, flags);
1230 }
1231
1232 static int tegra_dma_alloc_chan_resources(struct dma_chan *dc)
1233 {
1234         struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
1235         int ret;
1236
1237         ret = request_irq(tdc->irq, tegra_dma_isr, 0, tdc->name, tdc);
1238         if (ret) {
1239                 dev_err(tdc2dev(tdc), "request_irq failed for %s\n", tdc->name);
1240                 return ret;
1241         }
1242
1243         dma_cookie_init(&tdc->vc.chan);
1244         tdc->config_init = false;
1245         return 0;
1246 }
1247
1248 static void tegra_dma_chan_synchronize(struct dma_chan *dc)
1249 {
1250         struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
1251
1252         synchronize_irq(tdc->irq);
1253         vchan_synchronize(&tdc->vc);
1254 }
1255
1256 static void tegra_dma_free_chan_resources(struct dma_chan *dc)
1257 {
1258         struct tegra_dma_channel *tdc = to_tegra_dma_chan(dc);
1259
1260         dev_dbg(tdc2dev(tdc), "Freeing channel %d\n", tdc->id);
1261
1262         tegra_dma_terminate_all(dc);
1263         synchronize_irq(tdc->irq);
1264
1265         tasklet_kill(&tdc->vc.task);
1266         tdc->config_init = false;
1267         tdc->slave_id = -1;
1268         tdc->sid_dir = DMA_TRANS_NONE;
1269         free_irq(tdc->irq, tdc);
1270
1271         vchan_free_chan_resources(&tdc->vc);
1272 }
1273
1274 static struct dma_chan *tegra_dma_of_xlate(struct of_phandle_args *dma_spec,
1275                                            struct of_dma *ofdma)
1276 {
1277         struct tegra_dma *tdma = ofdma->of_dma_data;
1278         struct tegra_dma_channel *tdc;
1279         struct dma_chan *chan;
1280
1281         chan = dma_get_any_slave_channel(&tdma->dma_dev);
1282         if (!chan)
1283                 return NULL;
1284
1285         tdc = to_tegra_dma_chan(chan);
1286         tdc->slave_id = dma_spec->args[0];
1287
1288         return chan;
1289 }
1290
1291 static const struct tegra_dma_chip_data tegra186_dma_chip_data = {
1292         .nr_channels = 31,
1293         .channel_reg_size = SZ_64K,
1294         .max_dma_count = SZ_1G,
1295         .hw_support_pause = false,
1296         .terminate = tegra_dma_stop_client,
1297 };
1298
1299 static const struct tegra_dma_chip_data tegra194_dma_chip_data = {
1300         .nr_channels = 31,
1301         .channel_reg_size = SZ_64K,
1302         .max_dma_count = SZ_1G,
1303         .hw_support_pause = true,
1304         .terminate = tegra_dma_pause,
1305 };
1306
1307 static const struct tegra_dma_chip_data tegra234_dma_chip_data = {
1308         .nr_channels = 31,
1309         .channel_reg_size = SZ_64K,
1310         .max_dma_count = SZ_1G,
1311         .hw_support_pause = true,
1312         .terminate = tegra_dma_pause_noerr,
1313 };
1314
1315 static const struct of_device_id tegra_dma_of_match[] = {
1316         {
1317                 .compatible = "nvidia,tegra186-gpcdma",
1318                 .data = &tegra186_dma_chip_data,
1319         }, {
1320                 .compatible = "nvidia,tegra194-gpcdma",
1321                 .data = &tegra194_dma_chip_data,
1322         }, {
1323                 .compatible = "nvidia,tegra234-gpcdma",
1324                 .data = &tegra234_dma_chip_data,
1325         }, {
1326         },
1327 };
1328 MODULE_DEVICE_TABLE(of, tegra_dma_of_match);
1329
1330 static int tegra_dma_program_sid(struct tegra_dma_channel *tdc, int stream_id)
1331 {
1332         unsigned int reg_val =  tdc_read(tdc, TEGRA_GPCDMA_CHAN_MCSEQ);
1333
1334         reg_val &= ~(TEGRA_GPCDMA_MCSEQ_STREAM_ID0_MASK);
1335         reg_val &= ~(TEGRA_GPCDMA_MCSEQ_STREAM_ID1_MASK);
1336
1337         reg_val |= FIELD_PREP(TEGRA_GPCDMA_MCSEQ_STREAM_ID0_MASK, stream_id);
1338         reg_val |= FIELD_PREP(TEGRA_GPCDMA_MCSEQ_STREAM_ID1_MASK, stream_id);
1339
1340         tdc_write(tdc, TEGRA_GPCDMA_CHAN_MCSEQ, reg_val);
1341         return 0;
1342 }
1343
1344 static int tegra_dma_probe(struct platform_device *pdev)
1345 {
1346         const struct tegra_dma_chip_data *cdata = NULL;
1347         struct iommu_fwspec *iommu_spec;
1348         unsigned int stream_id, i;
1349         struct tegra_dma *tdma;
1350         int ret;
1351
1352         cdata = of_device_get_match_data(&pdev->dev);
1353
1354         tdma = devm_kzalloc(&pdev->dev,
1355                             struct_size(tdma, channels, cdata->nr_channels),
1356                             GFP_KERNEL);
1357         if (!tdma)
1358                 return -ENOMEM;
1359
1360         tdma->dev = &pdev->dev;
1361         tdma->chip_data = cdata;
1362         platform_set_drvdata(pdev, tdma);
1363
1364         tdma->base_addr = devm_platform_ioremap_resource(pdev, 0);
1365         if (IS_ERR(tdma->base_addr))
1366                 return PTR_ERR(tdma->base_addr);
1367
1368         tdma->rst = devm_reset_control_get_exclusive(&pdev->dev, "gpcdma");
1369         if (IS_ERR(tdma->rst)) {
1370                 return dev_err_probe(&pdev->dev, PTR_ERR(tdma->rst),
1371                               "Missing controller reset\n");
1372         }
1373         reset_control_reset(tdma->rst);
1374
1375         tdma->dma_dev.dev = &pdev->dev;
1376
1377         iommu_spec = dev_iommu_fwspec_get(&pdev->dev);
1378         if (!iommu_spec) {
1379                 dev_err(&pdev->dev, "Missing iommu stream-id\n");
1380                 return -EINVAL;
1381         }
1382         stream_id = iommu_spec->ids[0] & 0xffff;
1383
1384         INIT_LIST_HEAD(&tdma->dma_dev.channels);
1385         for (i = 0; i < cdata->nr_channels; i++) {
1386                 struct tegra_dma_channel *tdc = &tdma->channels[i];
1387
1388                 tdc->irq = platform_get_irq(pdev, i);
1389                 if (tdc->irq < 0)
1390                         return tdc->irq;
1391
1392                 tdc->chan_base_offset = TEGRA_GPCDMA_CHANNEL_BASE_ADD_OFFSET +
1393                                         i * cdata->channel_reg_size;
1394                 snprintf(tdc->name, sizeof(tdc->name), "gpcdma.%d", i);
1395                 tdc->tdma = tdma;
1396                 tdc->id = i;
1397                 tdc->slave_id = -1;
1398
1399                 vchan_init(&tdc->vc, &tdma->dma_dev);
1400                 tdc->vc.desc_free = tegra_dma_desc_free;
1401
1402                 /* program stream-id for this channel */
1403                 tegra_dma_program_sid(tdc, stream_id);
1404                 tdc->stream_id = stream_id;
1405         }
1406
1407         dma_cap_set(DMA_SLAVE, tdma->dma_dev.cap_mask);
1408         dma_cap_set(DMA_PRIVATE, tdma->dma_dev.cap_mask);
1409         dma_cap_set(DMA_MEMCPY, tdma->dma_dev.cap_mask);
1410         dma_cap_set(DMA_MEMSET, tdma->dma_dev.cap_mask);
1411         dma_cap_set(DMA_CYCLIC, tdma->dma_dev.cap_mask);
1412
1413         /*
1414          * Only word aligned transfers are supported. Set the copy
1415          * alignment shift.
1416          */
1417         tdma->dma_dev.copy_align = 2;
1418         tdma->dma_dev.fill_align = 2;
1419         tdma->dma_dev.device_alloc_chan_resources =
1420                                         tegra_dma_alloc_chan_resources;
1421         tdma->dma_dev.device_free_chan_resources =
1422                                         tegra_dma_free_chan_resources;
1423         tdma->dma_dev.device_prep_slave_sg = tegra_dma_prep_slave_sg;
1424         tdma->dma_dev.device_prep_dma_memcpy = tegra_dma_prep_dma_memcpy;
1425         tdma->dma_dev.device_prep_dma_memset = tegra_dma_prep_dma_memset;
1426         tdma->dma_dev.device_prep_dma_cyclic = tegra_dma_prep_dma_cyclic;
1427         tdma->dma_dev.device_config = tegra_dma_slave_config;
1428         tdma->dma_dev.device_terminate_all = tegra_dma_terminate_all;
1429         tdma->dma_dev.device_tx_status = tegra_dma_tx_status;
1430         tdma->dma_dev.device_issue_pending = tegra_dma_issue_pending;
1431         tdma->dma_dev.device_pause = tegra_dma_device_pause;
1432         tdma->dma_dev.device_resume = tegra_dma_device_resume;
1433         tdma->dma_dev.device_synchronize = tegra_dma_chan_synchronize;
1434         tdma->dma_dev.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST;
1435
1436         ret = dma_async_device_register(&tdma->dma_dev);
1437         if (ret < 0) {
1438                 dev_err_probe(&pdev->dev, ret,
1439                               "GPC DMA driver registration failed\n");
1440                 return ret;
1441         }
1442
1443         ret = of_dma_controller_register(pdev->dev.of_node,
1444                                          tegra_dma_of_xlate, tdma);
1445         if (ret < 0) {
1446                 dev_err_probe(&pdev->dev, ret,
1447                               "GPC DMA OF registration failed\n");
1448
1449                 dma_async_device_unregister(&tdma->dma_dev);
1450                 return ret;
1451         }
1452
1453         dev_info(&pdev->dev, "GPC DMA driver register %d channels\n",
1454                  cdata->nr_channels);
1455
1456         return 0;
1457 }
1458
1459 static int tegra_dma_remove(struct platform_device *pdev)
1460 {
1461         struct tegra_dma *tdma = platform_get_drvdata(pdev);
1462
1463         of_dma_controller_free(pdev->dev.of_node);
1464         dma_async_device_unregister(&tdma->dma_dev);
1465
1466         return 0;
1467 }
1468
1469 static int __maybe_unused tegra_dma_pm_suspend(struct device *dev)
1470 {
1471         struct tegra_dma *tdma = dev_get_drvdata(dev);
1472         unsigned int i;
1473
1474         for (i = 0; i < tdma->chip_data->nr_channels; i++) {
1475                 struct tegra_dma_channel *tdc = &tdma->channels[i];
1476
1477                 if (tdc->dma_desc) {
1478                         dev_err(tdma->dev, "channel %u busy\n", i);
1479                         return -EBUSY;
1480                 }
1481         }
1482
1483         return 0;
1484 }
1485
1486 static int __maybe_unused tegra_dma_pm_resume(struct device *dev)
1487 {
1488         struct tegra_dma *tdma = dev_get_drvdata(dev);
1489         unsigned int i;
1490
1491         reset_control_reset(tdma->rst);
1492
1493         for (i = 0; i < tdma->chip_data->nr_channels; i++) {
1494                 struct tegra_dma_channel *tdc = &tdma->channels[i];
1495
1496                 tegra_dma_program_sid(tdc, tdc->stream_id);
1497         }
1498
1499         return 0;
1500 }
1501
1502 static const struct dev_pm_ops tegra_dma_dev_pm_ops = {
1503         SET_SYSTEM_SLEEP_PM_OPS(tegra_dma_pm_suspend, tegra_dma_pm_resume)
1504 };
1505
1506 static struct platform_driver tegra_dma_driver = {
1507         .driver = {
1508                 .name   = "tegra-gpcdma",
1509                 .pm     = &tegra_dma_dev_pm_ops,
1510                 .of_match_table = tegra_dma_of_match,
1511         },
1512         .probe          = tegra_dma_probe,
1513         .remove         = tegra_dma_remove,
1514 };
1515
1516 module_platform_driver(tegra_dma_driver);
1517
1518 MODULE_DESCRIPTION("NVIDIA Tegra GPC DMA Controller driver");
1519 MODULE_AUTHOR("Pavan Kunapuli <pkunapuli@nvidia.com>");
1520 MODULE_AUTHOR("Rajesh Gumasta <rgumasta@nvidia.com>");
1521 MODULE_LICENSE("GPL");