drivers/dma/xilinx/xilinx_dma.c

   1 /*
   2  * DMA driver for Xilinx Video DMA Engine
   3  *
   4  * Copyright (C) 2010-2014 Xilinx, Inc. All rights reserved.
   5  *
   6  * Based on the Freescale DMA driver.
   7  *
   8  * Description:
   9  * The AXI Video Direct Memory Access (AXI VDMA) core is a soft Xilinx IP
  10  * core that provides high-bandwidth direct memory access between memory
  11  * and AXI4-Stream type video target peripherals. The core provides efficient
  12  * two dimensional DMA operations with independent asynchronous read (S2MM)
  13  * and write (MM2S) channel operation. It can be configured to have either
  14  * one channel or two channels. If configured as two channels, one is to
  15  * transmit to the video device (MM2S) and another is to receive from the
  16  * video device (S2MM). Initialization, status, interrupt and management
  17  * registers are accessed through an AXI4-Lite slave interface.
  18  *
  19  * The AXI Direct Memory Access (AXI DMA) core is a soft Xilinx IP core that
  20  * provides high-bandwidth one dimensional direct memory access between memory
  21  * and AXI4-Stream target peripherals. It supports one receive and one
  22  * transmit channel, both of them optional at synthesis time.
  23  *
  24  * The AXI CDMA, is a soft IP, which provides high-bandwidth Direct Memory
  25  * Access (DMA) between a memory-mapped source address and a memory-mapped
  26  * destination address.
  27  *
  28  * This program is free software: you can redistribute it and/or modify
  29  * it under the terms of the GNU General Public License as published by
  30  * the Free Software Foundation, either version 2 of the License, or
  31  * (at your option) any later version.
  32  */
  33
  34 #include <linux/bitops.h>
  35 #include <linux/dmapool.h>
  36 #include <linux/dma/xilinx_dma.h>
  37 #include <linux/init.h>
  38 #include <linux/interrupt.h>
  39 #include <linux/io.h>
  40 #include <linux/iopoll.h>
  41 #include <linux/module.h>
  42 #include <linux/of_address.h>
  43 #include <linux/of_dma.h>
  44 #include <linux/of_platform.h>
  45 #include <linux/of_irq.h>
  46 #include <linux/slab.h>
  47 #include <linux/clk.h>
  48 #include <linux/io-64-nonatomic-lo-hi.h>
  49
  50 #include "../dmaengine.h"
  51
  52 /* Register/Descriptor Offsets */
  53 #define XILINX_DMA_MM2S_CTRL_OFFSET             0x0000
  54 #define XILINX_DMA_S2MM_CTRL_OFFSET             0x0030
  55 #define XILINX_VDMA_MM2S_DESC_OFFSET            0x0050
  56 #define XILINX_VDMA_S2MM_DESC_OFFSET            0x00a0
  57
  58 /* Control Registers */
  59 #define XILINX_DMA_REG_DMACR                    0x0000
  60 #define XILINX_DMA_DMACR_DELAY_MAX              0xff
  61 #define XILINX_DMA_DMACR_DELAY_SHIFT            24
  62 #define XILINX_DMA_DMACR_FRAME_COUNT_MAX        0xff
  63 #define XILINX_DMA_DMACR_FRAME_COUNT_SHIFT      16
  64 #define XILINX_DMA_DMACR_ERR_IRQ                BIT(14)
  65 #define XILINX_DMA_DMACR_DLY_CNT_IRQ            BIT(13)
  66 #define XILINX_DMA_DMACR_FRM_CNT_IRQ            BIT(12)
  67 #define XILINX_DMA_DMACR_MASTER_SHIFT           8
  68 #define XILINX_DMA_DMACR_FSYNCSRC_SHIFT 5
  69 #define XILINX_DMA_DMACR_FRAMECNT_EN            BIT(4)
  70 #define XILINX_DMA_DMACR_GENLOCK_EN             BIT(3)
  71 #define XILINX_DMA_DMACR_RESET                  BIT(2)
  72 #define XILINX_DMA_DMACR_CIRC_EN                BIT(1)
  73 #define XILINX_DMA_DMACR_RUNSTOP                BIT(0)
  74 #define XILINX_DMA_DMACR_FSYNCSRC_MASK          GENMASK(6, 5)
  75
  76 #define XILINX_DMA_REG_DMASR                    0x0004
  77 #define XILINX_DMA_DMASR_EOL_LATE_ERR           BIT(15)
  78 #define XILINX_DMA_DMASR_ERR_IRQ                BIT(14)
  79 #define XILINX_DMA_DMASR_DLY_CNT_IRQ            BIT(13)
  80 #define XILINX_DMA_DMASR_FRM_CNT_IRQ            BIT(12)
  81 #define XILINX_DMA_DMASR_SOF_LATE_ERR           BIT(11)
  82 #define XILINX_DMA_DMASR_SG_DEC_ERR             BIT(10)
  83 #define XILINX_DMA_DMASR_SG_SLV_ERR             BIT(9)
  84 #define XILINX_DMA_DMASR_EOF_EARLY_ERR          BIT(8)
  85 #define XILINX_DMA_DMASR_SOF_EARLY_ERR          BIT(7)
  86 #define XILINX_DMA_DMASR_DMA_DEC_ERR            BIT(6)
  87 #define XILINX_DMA_DMASR_DMA_SLAVE_ERR          BIT(5)
  88 #define XILINX_DMA_DMASR_DMA_INT_ERR            BIT(4)
  89 #define XILINX_DMA_DMASR_IDLE                   BIT(1)
  90 #define XILINX_DMA_DMASR_HALTED         BIT(0)
  91 #define XILINX_DMA_DMASR_DELAY_MASK             GENMASK(31, 24)
  92 #define XILINX_DMA_DMASR_FRAME_COUNT_MASK       GENMASK(23, 16)
  93
  94 #define XILINX_DMA_REG_CURDESC                  0x0008
  95 #define XILINX_DMA_REG_TAILDESC         0x0010
  96 #define XILINX_DMA_REG_REG_INDEX                0x0014
  97 #define XILINX_DMA_REG_FRMSTORE         0x0018
  98 #define XILINX_DMA_REG_THRESHOLD                0x001c
  99 #define XILINX_DMA_REG_FRMPTR_STS               0x0024
 100 #define XILINX_DMA_REG_PARK_PTR         0x0028
 101 #define XILINX_DMA_PARK_PTR_WR_REF_SHIFT        8
 102 #define XILINX_DMA_PARK_PTR_RD_REF_SHIFT        0
 103 #define XILINX_DMA_REG_VDMA_VERSION             0x002c
 104
 105 /* Register Direct Mode Registers */
 106 #define XILINX_DMA_REG_VSIZE                    0x0000
 107 #define XILINX_DMA_REG_HSIZE                    0x0004
 108
 109 #define XILINX_DMA_REG_FRMDLY_STRIDE            0x0008
 110 #define XILINX_DMA_FRMDLY_STRIDE_FRMDLY_SHIFT   24
 111 #define XILINX_DMA_FRMDLY_STRIDE_STRIDE_SHIFT   0
 112
 113 #define XILINX_VDMA_REG_START_ADDRESS(n)        (0x000c + 4 * (n))
 114 #define XILINX_VDMA_REG_START_ADDRESS_64(n)     (0x000c + 8 * (n))
 115
 116 /* HW specific definitions */
 117 #define XILINX_DMA_MAX_CHANS_PER_DEVICE 0x20
 118
 119 #define XILINX_DMA_DMAXR_ALL_IRQ_MASK   \
 120                 (XILINX_DMA_DMASR_FRM_CNT_IRQ | \
 121                  XILINX_DMA_DMASR_DLY_CNT_IRQ | \
 122                  XILINX_DMA_DMASR_ERR_IRQ)
 123
 124 #define XILINX_DMA_DMASR_ALL_ERR_MASK   \
 125                 (XILINX_DMA_DMASR_EOL_LATE_ERR | \
 126                  XILINX_DMA_DMASR_SOF_LATE_ERR | \
 127                  XILINX_DMA_DMASR_SG_DEC_ERR | \
 128                  XILINX_DMA_DMASR_SG_SLV_ERR | \
 129                  XILINX_DMA_DMASR_EOF_EARLY_ERR | \
 130                  XILINX_DMA_DMASR_SOF_EARLY_ERR | \
 131                  XILINX_DMA_DMASR_DMA_DEC_ERR | \
 132                  XILINX_DMA_DMASR_DMA_SLAVE_ERR | \
 133                  XILINX_DMA_DMASR_DMA_INT_ERR)
 134
 135 /*
 136  * Recoverable errors are DMA Internal error, SOF Early, EOF Early
 137  * and SOF Late. They are only recoverable when C_FLUSH_ON_FSYNC
 138  * is enabled in the h/w system.
 139  */
 140 #define XILINX_DMA_DMASR_ERR_RECOVER_MASK       \
 141                 (XILINX_DMA_DMASR_SOF_LATE_ERR | \
 142                  XILINX_DMA_DMASR_EOF_EARLY_ERR | \
 143                  XILINX_DMA_DMASR_SOF_EARLY_ERR | \
 144                  XILINX_DMA_DMASR_DMA_INT_ERR)
 145
 146 /* Axi VDMA Flush on Fsync bits */
 147 #define XILINX_DMA_FLUSH_S2MM           3
 148 #define XILINX_DMA_FLUSH_MM2S           2
 149 #define XILINX_DMA_FLUSH_BOTH           1
 150
 151 /* Delay loop counter to prevent hardware failure */
 152 #define XILINX_DMA_LOOP_COUNT           1000000
 153
 154 /* AXI DMA Specific Registers/Offsets */
 155 #define XILINX_DMA_REG_SRCDSTADDR       0x18
 156 #define XILINX_DMA_REG_BTT              0x28
 157
 158 /* AXI DMA Specific Masks/Bit fields */
 159 #define XILINX_DMA_MAX_TRANS_LEN        GENMASK(22, 0)
 160 #define XILINX_DMA_CR_COALESCE_MAX      GENMASK(23, 16)
 161 #define XILINX_DMA_CR_CYCLIC_BD_EN_MASK BIT(4)
 162 #define XILINX_DMA_CR_COALESCE_SHIFT    16
 163 #define XILINX_DMA_BD_SOP               BIT(27)
 164 #define XILINX_DMA_BD_EOP               BIT(26)
 165 #define XILINX_DMA_COALESCE_MAX         255
 166 #define XILINX_DMA_NUM_APP_WORDS        5
 167
 168 /* Multi-Channel DMA Descriptor offsets*/
 169 #define XILINX_DMA_MCRX_CDESC(x)        (0x40 + (x-1) * 0x20)
 170 #define XILINX_DMA_MCRX_TDESC(x)        (0x48 + (x-1) * 0x20)
 171
 172 /* Multi-Channel DMA Masks/Shifts */
 173 #define XILINX_DMA_BD_HSIZE_MASK        GENMASK(15, 0)
 174 #define XILINX_DMA_BD_STRIDE_MASK       GENMASK(15, 0)
 175 #define XILINX_DMA_BD_VSIZE_MASK        GENMASK(31, 19)
 176 #define XILINX_DMA_BD_TDEST_MASK        GENMASK(4, 0)
 177 #define XILINX_DMA_BD_STRIDE_SHIFT      0
 178 #define XILINX_DMA_BD_VSIZE_SHIFT       19
 179
 180 /* AXI CDMA Specific Registers/Offsets */
 181 #define XILINX_CDMA_REG_SRCADDR         0x18
 182 #define XILINX_CDMA_REG_DSTADDR         0x20
 183
 184 /* AXI CDMA Specific Masks */
 185 #define XILINX_CDMA_CR_SGMODE          BIT(3)
 186
 187 /**
 188  * struct xilinx_vdma_desc_hw - Hardware Descriptor
 189  * @next_desc: Next Descriptor Pointer @0x00
 190  * @pad1: Reserved @0x04
 191  * @buf_addr: Buffer address @0x08
 192  * @buf_addr_msb: MSB of Buffer address @0x0C
 193  * @vsize: Vertical Size @0x10
 194  * @hsize: Horizontal Size @0x14
 195  * @stride: Number of bytes between the first
 196  *          pixels of each horizontal line @0x18
 197  */
 198 struct xilinx_vdma_desc_hw {
 199         u32 next_desc;
 200         u32 pad1;
 201         u32 buf_addr;
 202         u32 buf_addr_msb;
 203         u32 vsize;
 204         u32 hsize;
 205         u32 stride;
 206 } __aligned(64);
 207
 208 /**
 209  * struct xilinx_axidma_desc_hw - Hardware Descriptor for AXI DMA
 210  * @next_desc: Next Descriptor Pointer @0x00
 211  * @next_desc_msb: MSB of Next Descriptor Pointer @0x04
 212  * @buf_addr: Buffer address @0x08
 213  * @buf_addr_msb: MSB of Buffer address @0x0C
 214  * @pad1: Reserved @0x10
 215  * @pad2: Reserved @0x14
 216  * @control: Control field @0x18
 217  * @status: Status field @0x1C
 218  * @app: APP Fields @0x20 - 0x30
 219  */
 220 struct xilinx_axidma_desc_hw {
 221         u32 next_desc;
 222         u32 next_desc_msb;
 223         u32 buf_addr;
 224         u32 buf_addr_msb;
 225         u32 mcdma_control;
 226         u32 vsize_stride;
 227         u32 control;
 228         u32 status;
 229         u32 app[XILINX_DMA_NUM_APP_WORDS];
 230 } __aligned(64);
 231
 232 /**
 233  * struct xilinx_cdma_desc_hw - Hardware Descriptor
 234  * @next_desc: Next Descriptor Pointer @0x00
 235  * @next_descmsb: Next Descriptor Pointer MSB @0x04
 236  * @src_addr: Source address @0x08
 237  * @src_addrmsb: Source address MSB @0x0C
 238  * @dest_addr: Destination address @0x10
 239  * @dest_addrmsb: Destination address MSB @0x14
 240  * @control: Control field @0x18
 241  * @status: Status field @0x1C
 242  */
 243 struct xilinx_cdma_desc_hw {
 244         u32 next_desc;
 245         u32 next_desc_msb;
 246         u32 src_addr;
 247         u32 src_addr_msb;
 248         u32 dest_addr;
 249         u32 dest_addr_msb;
 250         u32 control;
 251         u32 status;
 252 } __aligned(64);
 253
 254 /**
 255  * struct xilinx_vdma_tx_segment - Descriptor segment
 256  * @hw: Hardware descriptor
 257  * @node: Node in the descriptor segments list
 258  * @phys: Physical address of segment
 259  */
 260 struct xilinx_vdma_tx_segment {
 261         struct xilinx_vdma_desc_hw hw;
 262         struct list_head node;
 263         dma_addr_t phys;
 264 } __aligned(64);
 265
 266 /**
 267  * struct xilinx_axidma_tx_segment - Descriptor segment
 268  * @hw: Hardware descriptor
 269  * @node: Node in the descriptor segments list
 270  * @phys: Physical address of segment
 271  */
 272 struct xilinx_axidma_tx_segment {
 273         struct xilinx_axidma_desc_hw hw;
 274         struct list_head node;
 275         dma_addr_t phys;
 276 } __aligned(64);
 277
 278 /**
 279  * struct xilinx_cdma_tx_segment - Descriptor segment
 280  * @hw: Hardware descriptor
 281  * @node: Node in the descriptor segments list
 282  * @phys: Physical address of segment
 283  */
 284 struct xilinx_cdma_tx_segment {
 285         struct xilinx_cdma_desc_hw hw;
 286         struct list_head node;
 287         dma_addr_t phys;
 288 } __aligned(64);
 289
 290 /**
 291  * struct xilinx_dma_tx_descriptor - Per Transaction structure
 292  * @async_tx: Async transaction descriptor
 293  * @segments: TX segments list
 294  * @node: Node in the channel descriptors list
 295  * @cyclic: Check for cyclic transfers.
 296  */
 297 struct xilinx_dma_tx_descriptor {
 298         struct dma_async_tx_descriptor async_tx;
 299         struct list_head segments;
 300         struct list_head node;
 301         bool cyclic;
 302 };
 303
 304 /**
 305  * struct xilinx_dma_chan - Driver specific DMA channel structure
 306  * @xdev: Driver specific device structure
 307  * @ctrl_offset: Control registers offset
 308  * @desc_offset: TX descriptor registers offset
 309  * @lock: Descriptor operation lock
 310  * @pending_list: Descriptors waiting
 311  * @active_list: Descriptors ready to submit
 312  * @done_list: Complete descriptors
 313  * @common: DMA common channel
 314  * @desc_pool: Descriptors pool
 315  * @dev: The dma device
 316  * @irq: Channel IRQ
 317  * @id: Channel ID
 318  * @direction: Transfer direction
 319  * @num_frms: Number of frames
 320  * @has_sg: Support scatter transfers
 321  * @cyclic: Check for cyclic transfers.
 322  * @genlock: Support genlock mode
 323  * @err: Channel has errors
 324  * @tasklet: Cleanup work after irq
 325  * @config: Device configuration info
 326  * @flush_on_fsync: Flush on Frame sync
 327  * @desc_pendingcount: Descriptor pending count
 328  * @ext_addr: Indicates 64 bit addressing is supported by dma channel
 329  * @desc_submitcount: Descriptor h/w submitted count
 330  * @residue: Residue for AXI DMA
 331  * @seg_v: Statically allocated segments base
 332  * @cyclic_seg_v: Statically allocated segment base for cyclic transfers
 333  * @start_transfer: Differentiate b/w DMA IP's transfer
 334  * @stop_transfer: Differentiate b/w DMA IP's quiesce
 335  */
 336 struct xilinx_dma_chan {
 337         struct xilinx_dma_device *xdev;
 338         u32 ctrl_offset;
 339         u32 desc_offset;
 340         spinlock_t lock;
 341         struct list_head pending_list;
 342         struct list_head active_list;
 343         struct list_head done_list;
 344         struct dma_chan common;
 345         struct dma_pool *desc_pool;
 346         struct device *dev;
 347         int irq;
 348         int id;
 349         enum dma_transfer_direction direction;
 350         int num_frms;
 351         bool has_sg;
 352         bool cyclic;
 353         bool genlock;
 354         bool err;
 355         struct tasklet_struct tasklet;
 356         struct xilinx_vdma_config config;
 357         bool flush_on_fsync;
 358         u32 desc_pendingcount;
 359         bool ext_addr;
 360         u32 desc_submitcount;
 361         u32 residue;
 362         struct xilinx_axidma_tx_segment *seg_v;
 363         struct xilinx_axidma_tx_segment *cyclic_seg_v;
 364         void (*start_transfer)(struct xilinx_dma_chan *chan);
 365         int (*stop_transfer)(struct xilinx_dma_chan *chan);
 366         u16 tdest;
 367 };
 368
 369 struct xilinx_dma_config {
 370         enum xdma_ip_type dmatype;
 371         int (*clk_init)(struct platform_device *pdev, struct clk **axi_clk,
 372                         struct clk **tx_clk, struct clk **txs_clk,
 373                         struct clk **rx_clk, struct clk **rxs_clk);
 374 };
 375
 376 /**
 377  * struct xilinx_dma_device - DMA device structure
 378  * @regs: I/O mapped base address
 379  * @dev: Device Structure
 380  * @common: DMA device structure
 381  * @chan: Driver specific DMA channel
 382  * @has_sg: Specifies whether Scatter-Gather is present or not
 383  * @mcdma: Specifies whether Multi-Channel is present or not
 384  * @flush_on_fsync: Flush on frame sync
 385  * @ext_addr: Indicates 64 bit addressing is supported by dma device
 386  * @pdev: Platform device structure pointer
 387  * @dma_config: DMA config structure
 388  * @axi_clk: DMA Axi4-lite interace clock
 389  * @tx_clk: DMA mm2s clock
 390  * @txs_clk: DMA mm2s stream clock
 391  * @rx_clk: DMA s2mm clock
 392  * @rxs_clk: DMA s2mm stream clock
 393  * @nr_channels: Number of channels DMA device supports
 394  * @chan_id: DMA channel identifier
 395  */
 396 struct xilinx_dma_device {
 397         void __iomem *regs;
 398         struct device *dev;
 399         struct dma_device common;
 400         struct xilinx_dma_chan *chan[XILINX_DMA_MAX_CHANS_PER_DEVICE];
 401         bool has_sg;
 402         bool mcdma;
 403         u32 flush_on_fsync;
 404         bool ext_addr;
 405         struct platform_device  *pdev;
 406         const struct xilinx_dma_config *dma_config;
 407         struct clk *axi_clk;
 408         struct clk *tx_clk;
 409         struct clk *txs_clk;
 410         struct clk *rx_clk;
 411         struct clk *rxs_clk;
 412         u32 nr_channels;
 413         u32 chan_id;
 414 };
 415
 416 /* Macros */
 417 #define to_xilinx_chan(chan) \
 418         container_of(chan, struct xilinx_dma_chan, common)
 419 #define to_dma_tx_descriptor(tx) \
 420         container_of(tx, struct xilinx_dma_tx_descriptor, async_tx)
 421 #define xilinx_dma_poll_timeout(chan, reg, val, cond, delay_us, timeout_us) \
 422         readl_poll_timeout(chan->xdev->regs + chan->ctrl_offset + reg, val, \
 423                            cond, delay_us, timeout_us)
 424
 425 /* IO accessors */
 426 static inline u32 dma_read(struct xilinx_dma_chan *chan, u32 reg)
 427 {
 428         return ioread32(chan->xdev->regs + reg);
 429 }
 430
 431 static inline void dma_write(struct xilinx_dma_chan *chan, u32 reg, u32 value)
 432 {
 433         iowrite32(value, chan->xdev->regs + reg);
 434 }
 435
 436 static inline void vdma_desc_write(struct xilinx_dma_chan *chan, u32 reg,
 437                                    u32 value)
 438 {
 439         dma_write(chan, chan->desc_offset + reg, value);
 440 }
 441
 442 static inline u32 dma_ctrl_read(struct xilinx_dma_chan *chan, u32 reg)
 443 {
 444         return dma_read(chan, chan->ctrl_offset + reg);
 445 }
 446
 447 static inline void dma_ctrl_write(struct xilinx_dma_chan *chan, u32 reg,
 448                                    u32 value)
 449 {
 450         dma_write(chan, chan->ctrl_offset + reg, value);
 451 }
 452
 453 static inline void dma_ctrl_clr(struct xilinx_dma_chan *chan, u32 reg,
 454                                  u32 clr)
 455 {
 456         dma_ctrl_write(chan, reg, dma_ctrl_read(chan, reg) & ~clr);
 457 }
 458
 459 static inline void dma_ctrl_set(struct xilinx_dma_chan *chan, u32 reg,
 460                                  u32 set)
 461 {
 462         dma_ctrl_write(chan, reg, dma_ctrl_read(chan, reg) | set);
 463 }
 464
 465 /**
 466  * vdma_desc_write_64 - 64-bit descriptor write
 467  * @chan: Driver specific VDMA channel
 468  * @reg: Register to write
 469  * @value_lsb: lower address of the descriptor.
 470  * @value_msb: upper address of the descriptor.
 471  *
 472  * Since vdma driver is trying to write to a register offset which is not a
 473  * multiple of 64 bits(ex : 0x5c), we are writing as two separate 32 bits
 474  * instead of a single 64 bit register write.
 475  */
 476 static inline void vdma_desc_write_64(struct xilinx_dma_chan *chan, u32 reg,
 477                                       u32 value_lsb, u32 value_msb)
 478 {
 479         /* Write the lsb 32 bits*/
 480         writel(value_lsb, chan->xdev->regs + chan->desc_offset + reg);
 481
 482         /* Write the msb 32 bits */
 483         writel(value_msb, chan->xdev->regs + chan->desc_offset + reg + 4);
 484 }
 485
 486 static inline void dma_writeq(struct xilinx_dma_chan *chan, u32 reg, u64 value)
 487 {
 488         lo_hi_writeq(value, chan->xdev->regs + chan->ctrl_offset + reg);
 489 }
 490
 491 static inline void xilinx_write(struct xilinx_dma_chan *chan, u32 reg,
 492                                 dma_addr_t addr)
 493 {
 494         if (chan->ext_addr)
 495                 dma_writeq(chan, reg, addr);
 496         else
 497                 dma_ctrl_write(chan, reg, addr);
 498 }
 499
 500 static inline void xilinx_axidma_buf(struct xilinx_dma_chan *chan,
 501                                      struct xilinx_axidma_desc_hw *hw,
 502                                      dma_addr_t buf_addr, size_t sg_used,
 503                                      size_t period_len)
 504 {
 505         if (chan->ext_addr) {
 506                 hw->buf_addr = lower_32_bits(buf_addr + sg_used + period_len);
 507                 hw->buf_addr_msb = upper_32_bits(buf_addr + sg_used +
 508                                                  period_len);
 509         } else {
 510                 hw->buf_addr = buf_addr + sg_used + period_len;
 511         }
 512 }
 513
 514 /* -----------------------------------------------------------------------------
 515  * Descriptors and segments alloc and free
 516  */
 517
 518 /**
 519  * xilinx_vdma_alloc_tx_segment - Allocate transaction segment
 520  * @chan: Driver specific DMA channel
 521  *
 522  * Return: The allocated segment on success and NULL on failure.
 523  */
 524 static struct xilinx_vdma_tx_segment *
 525 xilinx_vdma_alloc_tx_segment(struct xilinx_dma_chan *chan)
 526 {
 527         struct xilinx_vdma_tx_segment *segment;
 528         dma_addr_t phys;
 529
 530         segment = dma_pool_zalloc(chan->desc_pool, GFP_ATOMIC, &phys);
 531         if (!segment)
 532                 return NULL;
 533
 534         segment->phys = phys;
 535
 536         return segment;
 537 }
 538
 539 /**
 540  * xilinx_cdma_alloc_tx_segment - Allocate transaction segment
 541  * @chan: Driver specific DMA channel
 542  *
 543  * Return: The allocated segment on success and NULL on failure.
 544  */
 545 static struct xilinx_cdma_tx_segment *
 546 xilinx_cdma_alloc_tx_segment(struct xilinx_dma_chan *chan)
 547 {
 548         struct xilinx_cdma_tx_segment *segment;
 549         dma_addr_t phys;
 550
 551         segment = dma_pool_zalloc(chan->desc_pool, GFP_ATOMIC, &phys);
 552         if (!segment)
 553                 return NULL;
 554
 555         segment->phys = phys;
 556
 557         return segment;
 558 }
 559
 560 /**
 561  * xilinx_axidma_alloc_tx_segment - Allocate transaction segment
 562  * @chan: Driver specific DMA channel
 563  *
 564  * Return: The allocated segment on success and NULL on failure.
 565  */
 566 static struct xilinx_axidma_tx_segment *
 567 xilinx_axidma_alloc_tx_segment(struct xilinx_dma_chan *chan)
 568 {
 569         struct xilinx_axidma_tx_segment *segment;
 570         dma_addr_t phys;
 571
 572         segment = dma_pool_zalloc(chan->desc_pool, GFP_ATOMIC, &phys);
 573         if (!segment)
 574                 return NULL;
 575
 576         segment->phys = phys;
 577
 578         return segment;
 579 }
 580
 581 /**
 582  * xilinx_dma_free_tx_segment - Free transaction segment
 583  * @chan: Driver specific DMA channel
 584  * @segment: DMA transaction segment
 585  */
 586 static void xilinx_dma_free_tx_segment(struct xilinx_dma_chan *chan,
 587                                 struct xilinx_axidma_tx_segment *segment)
 588 {
 589         dma_pool_free(chan->desc_pool, segment, segment->phys);
 590 }
 591
 592 /**
 593  * xilinx_cdma_free_tx_segment - Free transaction segment
 594  * @chan: Driver specific DMA channel
 595  * @segment: DMA transaction segment
 596  */
 597 static void xilinx_cdma_free_tx_segment(struct xilinx_dma_chan *chan,
 598                                 struct xilinx_cdma_tx_segment *segment)
 599 {
 600         dma_pool_free(chan->desc_pool, segment, segment->phys);
 601 }
 602
 603 /**
 604  * xilinx_vdma_free_tx_segment - Free transaction segment
 605  * @chan: Driver specific DMA channel
 606  * @segment: DMA transaction segment
 607  */
 608 static void xilinx_vdma_free_tx_segment(struct xilinx_dma_chan *chan,
 609                                         struct xilinx_vdma_tx_segment *segment)
 610 {
 611         dma_pool_free(chan->desc_pool, segment, segment->phys);
 612 }
 613
 614 /**
 615  * xilinx_dma_tx_descriptor - Allocate transaction descriptor
 616  * @chan: Driver specific DMA channel
 617  *
 618  * Return: The allocated descriptor on success and NULL on failure.
 619  */
 620 static struct xilinx_dma_tx_descriptor *
 621 xilinx_dma_alloc_tx_descriptor(struct xilinx_dma_chan *chan)
 622 {
 623         struct xilinx_dma_tx_descriptor *desc;
 624
 625         desc = kzalloc(sizeof(*desc), GFP_KERNEL);
 626         if (!desc)
 627                 return NULL;
 628
 629         INIT_LIST_HEAD(&desc->segments);
 630
 631         return desc;
 632 }
 633
 634 /**
 635  * xilinx_dma_free_tx_descriptor - Free transaction descriptor
 636  * @chan: Driver specific DMA channel
 637  * @desc: DMA transaction descriptor
 638  */
 639 static void
 640 xilinx_dma_free_tx_descriptor(struct xilinx_dma_chan *chan,
 641                                struct xilinx_dma_tx_descriptor *desc)
 642 {
 643         struct xilinx_vdma_tx_segment *segment, *next;
 644         struct xilinx_cdma_tx_segment *cdma_segment, *cdma_next;
 645         struct xilinx_axidma_tx_segment *axidma_segment, *axidma_next;
 646
 647         if (!desc)
 648                 return;
 649
 650         if (chan->xdev->dma_config->dmatype == XDMA_TYPE_VDMA) {
 651                 list_for_each_entry_safe(segment, next, &desc->segments, node) {
 652                         list_del(&segment->node);
 653                         xilinx_vdma_free_tx_segment(chan, segment);
 654                 }
 655         } else if (chan->xdev->dma_config->dmatype == XDMA_TYPE_CDMA) {
 656                 list_for_each_entry_safe(cdma_segment, cdma_next,
 657                                          &desc->segments, node) {
 658                         list_del(&cdma_segment->node);
 659                         xilinx_cdma_free_tx_segment(chan, cdma_segment);
 660                 }
 661         } else {
 662                 list_for_each_entry_safe(axidma_segment, axidma_next,
 663                                          &desc->segments, node) {
 664                         list_del(&axidma_segment->node);
 665                         xilinx_dma_free_tx_segment(chan, axidma_segment);
 666                 }
 667         }
 668
 669         kfree(desc);
 670 }
 671
 672 /* Required functions */
 673
 674 /**
 675  * xilinx_dma_free_desc_list - Free descriptors list
 676  * @chan: Driver specific DMA channel
 677  * @list: List to parse and delete the descriptor
 678  */
 679 static void xilinx_dma_free_desc_list(struct xilinx_dma_chan *chan,
 680                                         struct list_head *list)
 681 {
 682         struct xilinx_dma_tx_descriptor *desc, *next;
 683
 684         list_for_each_entry_safe(desc, next, list, node) {
 685                 list_del(&desc->node);
 686                 xilinx_dma_free_tx_descriptor(chan, desc);
 687         }
 688 }
 689
 690 /**
 691  * xilinx_dma_free_descriptors - Free channel descriptors
 692  * @chan: Driver specific DMA channel
 693  */
 694 static void xilinx_dma_free_descriptors(struct xilinx_dma_chan *chan)
 695 {
 696         unsigned long flags;
 697
 698         spin_lock_irqsave(&chan->lock, flags);
 699
 700         xilinx_dma_free_desc_list(chan, &chan->pending_list);
 701         xilinx_dma_free_desc_list(chan, &chan->done_list);
 702         xilinx_dma_free_desc_list(chan, &chan->active_list);
 703
 704         spin_unlock_irqrestore(&chan->lock, flags);
 705 }
 706
 707 /**
 708  * xilinx_dma_free_chan_resources - Free channel resources
 709  * @dchan: DMA channel
 710  */
 711 static void xilinx_dma_free_chan_resources(struct dma_chan *dchan)
 712 {
 713         struct xilinx_dma_chan *chan = to_xilinx_chan(dchan);
 714
 715         dev_dbg(chan->dev, "Free all channel resources.\n");
 716
 717         xilinx_dma_free_descriptors(chan);
 718         if (chan->xdev->dma_config->dmatype == XDMA_TYPE_AXIDMA) {
 719                 xilinx_dma_free_tx_segment(chan, chan->cyclic_seg_v);
 720                 xilinx_dma_free_tx_segment(chan, chan->seg_v);
 721         }
 722         dma_pool_destroy(chan->desc_pool);
 723         chan->desc_pool = NULL;
 724 }
 725
 726 /**
 727  * xilinx_dma_chan_handle_cyclic - Cyclic dma callback
 728  * @chan: Driver specific dma channel
 729  * @desc: dma transaction descriptor
 730  * @flags: flags for spin lock
 731  */
 732 static void xilinx_dma_chan_handle_cyclic(struct xilinx_dma_chan *chan,
 733                                           struct xilinx_dma_tx_descriptor *desc,
 734                                           unsigned long *flags)
 735 {
 736         dma_async_tx_callback callback;
 737         void *callback_param;
 738
 739         callback = desc->async_tx.callback;
 740         callback_param = desc->async_tx.callback_param;
 741         if (callback) {
 742                 spin_unlock_irqrestore(&chan->lock, *flags);
 743                 callback(callback_param);
 744                 spin_lock_irqsave(&chan->lock, *flags);
 745         }
 746 }
 747
 748 /**
 749  * xilinx_dma_chan_desc_cleanup - Clean channel descriptors
 750  * @chan: Driver specific DMA channel
 751  */
 752 static void xilinx_dma_chan_desc_cleanup(struct xilinx_dma_chan *chan)
 753 {
 754         struct xilinx_dma_tx_descriptor *desc, *next;
 755         unsigned long flags;
 756
 757         spin_lock_irqsave(&chan->lock, flags);
 758
 759         list_for_each_entry_safe(desc, next, &chan->done_list, node) {
 760                 struct dmaengine_desc_callback cb;
 761
 762                 if (desc->cyclic) {
 763                         xilinx_dma_chan_handle_cyclic(chan, desc, &flags);
 764                         break;
 765                 }
 766
 767                 /* Remove from the list of running transactions */
 768                 list_del(&desc->node);
 769
 770                 /* Run the link descriptor callback function */
 771                 dmaengine_desc_get_callback(&desc->async_tx, &cb);
 772                 if (dmaengine_desc_callback_valid(&cb)) {
 773                         spin_unlock_irqrestore(&chan->lock, flags);
 774                         dmaengine_desc_callback_invoke(&cb, NULL);
 775                         spin_lock_irqsave(&chan->lock, flags);
 776                 }
 777
 778                 /* Run any dependencies, then free the descriptor */
 779                 dma_run_dependencies(&desc->async_tx);
 780                 xilinx_dma_free_tx_descriptor(chan, desc);
 781         }
 782
 783         spin_unlock_irqrestore(&chan->lock, flags);
 784 }
 785
 786 /**
 787  * xilinx_dma_do_tasklet - Schedule completion tasklet
 788  * @data: Pointer to the Xilinx DMA channel structure
 789  */
 790 static void xilinx_dma_do_tasklet(unsigned long data)
 791 {
 792         struct xilinx_dma_chan *chan = (struct xilinx_dma_chan *)data;
 793
 794         xilinx_dma_chan_desc_cleanup(chan);
 795 }
 796
 797 /**
 798  * xilinx_dma_alloc_chan_resources - Allocate channel resources
 799  * @dchan: DMA channel
 800  *
 801  * Return: '0' on success and failure value on error
 802  */
 803 static int xilinx_dma_alloc_chan_resources(struct dma_chan *dchan)
 804 {
 805         struct xilinx_dma_chan *chan = to_xilinx_chan(dchan);
 806
 807         /* Has this channel already been allocated? */
 808         if (chan->desc_pool)
 809                 return 0;
 810
 811         /*
 812          * We need the descriptor to be aligned to 64bytes
 813          * for meeting Xilinx VDMA specification requirement.
 814          */
 815         if (chan->xdev->dma_config->dmatype == XDMA_TYPE_AXIDMA) {
 816                 chan->desc_pool = dma_pool_create("xilinx_dma_desc_pool",
 817                                    chan->dev,
 818                                    sizeof(struct xilinx_axidma_tx_segment),
 819                                    __alignof__(struct xilinx_axidma_tx_segment),
 820                                    0);
 821         } else if (chan->xdev->dma_config->dmatype == XDMA_TYPE_CDMA) {
 822                 chan->desc_pool = dma_pool_create("xilinx_cdma_desc_pool",
 823                                    chan->dev,
 824                                    sizeof(struct xilinx_cdma_tx_segment),
 825                                    __alignof__(struct xilinx_cdma_tx_segment),
 826                                    0);
 827         } else {
 828                 chan->desc_pool = dma_pool_create("xilinx_vdma_desc_pool",
 829                                      chan->dev,
 830                                      sizeof(struct xilinx_vdma_tx_segment),
 831                                      __alignof__(struct xilinx_vdma_tx_segment),
 832                                      0);
 833         }
 834
 835         if (!chan->desc_pool) {
 836                 dev_err(chan->dev,
 837                         "unable to allocate channel %d descriptor pool\n",
 838                         chan->id);
 839                 return -ENOMEM;
 840         }
 841
 842         if (chan->xdev->dma_config->dmatype == XDMA_TYPE_AXIDMA) {
 843                 /*
 844                  * For AXI DMA case after submitting a pending_list, keep
 845                  * an extra segment allocated so that the "next descriptor"
 846                  * pointer on the tail descriptor always points to a
 847                  * valid descriptor, even when paused after reaching taildesc.
 848                  * This way, it is possible to issue additional
 849                  * transfers without halting and restarting the channel.
 850                  */
 851                 chan->seg_v = xilinx_axidma_alloc_tx_segment(chan);
 852
 853                 /*
 854                  * For cyclic DMA mode we need to program the tail Descriptor
 855                  * register with a value which is not a part of the BD chain
 856                  * so allocating a desc segment during channel allocation for
 857                  * programming tail descriptor.
 858                  */
 859                 chan->cyclic_seg_v = xilinx_axidma_alloc_tx_segment(chan);
 860         }
 861
 862         dma_cookie_init(dchan);
 863
 864         if (chan->xdev->dma_config->dmatype == XDMA_TYPE_AXIDMA) {
 865                 /* For AXI DMA resetting once channel will reset the
 866                  * other channel as well so enable the interrupts here.
 867                  */
 868                 dma_ctrl_set(chan, XILINX_DMA_REG_DMACR,
 869                               XILINX_DMA_DMAXR_ALL_IRQ_MASK);
 870         }
 871
 872         if ((chan->xdev->dma_config->dmatype == XDMA_TYPE_CDMA) && chan->has_sg)
 873                 dma_ctrl_set(chan, XILINX_DMA_REG_DMACR,
 874                              XILINX_CDMA_CR_SGMODE);
 875
 876         return 0;
 877 }
 878
 879 /**
 880  * xilinx_dma_tx_status - Get DMA transaction status
 881  * @dchan: DMA channel
 882  * @cookie: Transaction identifier
 883  * @txstate: Transaction state
 884  *
 885  * Return: DMA transaction status
 886  */
 887 static enum dma_status xilinx_dma_tx_status(struct dma_chan *dchan,
 888                                         dma_cookie_t cookie,
 889                                         struct dma_tx_state *txstate)
 890 {
 891         struct xilinx_dma_chan *chan = to_xilinx_chan(dchan);
 892         struct xilinx_dma_tx_descriptor *desc;
 893         struct xilinx_axidma_tx_segment *segment;
 894         struct xilinx_axidma_desc_hw *hw;
 895         enum dma_status ret;
 896         unsigned long flags;
 897         u32 residue = 0;
 898
 899         ret = dma_cookie_status(dchan, cookie, txstate);
 900         if (ret == DMA_COMPLETE || !txstate)
 901                 return ret;
 902
 903         if (chan->xdev->dma_config->dmatype == XDMA_TYPE_AXIDMA) {
 904                 spin_lock_irqsave(&chan->lock, flags);
 905
 906                 desc = list_last_entry(&chan->active_list,
 907                                        struct xilinx_dma_tx_descriptor, node);
 908                 if (chan->has_sg) {
 909                         list_for_each_entry(segment, &desc->segments, node) {
 910                                 hw = &segment->hw;
 911                                 residue += (hw->control - hw->status) &
 912                                            XILINX_DMA_MAX_TRANS_LEN;
 913                         }
 914                 }
 915                 spin_unlock_irqrestore(&chan->lock, flags);
 916
 917                 chan->residue = residue;
 918                 dma_set_residue(txstate, chan->residue);
 919         }
 920
 921         return ret;
 922 }
 923
 924 /**
 925  * xilinx_dma_is_running - Check if DMA channel is running
 926  * @chan: Driver specific DMA channel
 927  *
 928  * Return: '1' if running, '0' if not.
 929  */
 930 static bool xilinx_dma_is_running(struct xilinx_dma_chan *chan)
 931 {
 932         return !(dma_ctrl_read(chan, XILINX_DMA_REG_DMASR) &
 933                  XILINX_DMA_DMASR_HALTED) &&
 934                 (dma_ctrl_read(chan, XILINX_DMA_REG_DMACR) &
 935                  XILINX_DMA_DMACR_RUNSTOP);
 936 }
 937
 938 /**
 939  * xilinx_dma_is_idle - Check if DMA channel is idle
 940  * @chan: Driver specific DMA channel
 941  *
 942  * Return: '1' if idle, '0' if not.
 943  */
 944 static bool xilinx_dma_is_idle(struct xilinx_dma_chan *chan)
 945 {
 946         return dma_ctrl_read(chan, XILINX_DMA_REG_DMASR) &
 947                 XILINX_DMA_DMASR_IDLE;
 948 }
 949
 950 /**
 951  * xilinx_dma_stop_transfer - Halt DMA channel
 952  * @chan: Driver specific DMA channel
 953  */
 954 static int xilinx_dma_stop_transfer(struct xilinx_dma_chan *chan)
 955 {
 956         u32 val;
 957
 958         dma_ctrl_clr(chan, XILINX_DMA_REG_DMACR, XILINX_DMA_DMACR_RUNSTOP);
 959
 960         /* Wait for the hardware to halt */
 961         return xilinx_dma_poll_timeout(chan, XILINX_DMA_REG_DMASR, val,
 962                                        val & XILINX_DMA_DMASR_HALTED, 0,
 963                                        XILINX_DMA_LOOP_COUNT);
 964 }
 965
 966 /**
 967  * xilinx_cdma_stop_transfer - Wait for the current transfer to complete
 968  * @chan: Driver specific DMA channel
 969  */
 970 static int xilinx_cdma_stop_transfer(struct xilinx_dma_chan *chan)
 971 {
 972         u32 val;
 973
 974         return xilinx_dma_poll_timeout(chan, XILINX_DMA_REG_DMASR, val,
 975                                        val & XILINX_DMA_DMASR_IDLE, 0,
 976                                        XILINX_DMA_LOOP_COUNT);
 977 }
 978
 979 /**
 980  * xilinx_dma_start - Start DMA channel
 981  * @chan: Driver specific DMA channel
 982  */
 983 static void xilinx_dma_start(struct xilinx_dma_chan *chan)
 984 {
 985         int err;
 986         u32 val;
 987
 988         dma_ctrl_set(chan, XILINX_DMA_REG_DMACR, XILINX_DMA_DMACR_RUNSTOP);
 989
 990         /* Wait for the hardware to start */
 991         err = xilinx_dma_poll_timeout(chan, XILINX_DMA_REG_DMASR, val,
 992                                       !(val & XILINX_DMA_DMASR_HALTED), 0,
 993                                       XILINX_DMA_LOOP_COUNT);
 994
 995         if (err) {
 996                 dev_err(chan->dev, "Cannot start channel %p: %x\n",
 997                         chan, dma_ctrl_read(chan, XILINX_DMA_REG_DMASR));
 998
 999                 chan->err = true;
1000         }
1001 }
1002
1003 /**
1004  * xilinx_vdma_start_transfer - Starts VDMA transfer
1005  * @chan: Driver specific channel struct pointer
1006  */
1007 static void xilinx_vdma_start_transfer(struct xilinx_dma_chan *chan)
1008 {
1009         struct xilinx_vdma_config *config = &chan->config;
1010         struct xilinx_dma_tx_descriptor *desc, *tail_desc;
1011         u32 reg;
1012         struct xilinx_vdma_tx_segment *tail_segment;
1013
1014         /* This function was invoked with lock held */
1015         if (chan->err)
1016                 return;
1017
1018         if (list_empty(&chan->pending_list))
1019                 return;
1020
1021         desc = list_first_entry(&chan->pending_list,
1022                                 struct xilinx_dma_tx_descriptor, node);
1023         tail_desc = list_last_entry(&chan->pending_list,
1024                                     struct xilinx_dma_tx_descriptor, node);
1025
1026         tail_segment = list_last_entry(&tail_desc->segments,
1027                                        struct xilinx_vdma_tx_segment, node);
1028
1029         /* If it is SG mode and hardware is busy, cannot submit */
1030         if (chan->has_sg && xilinx_dma_is_running(chan) &&
1031             !xilinx_dma_is_idle(chan)) {
1032                 dev_dbg(chan->dev, "DMA controller still busy\n");
1033                 return;
1034         }
1035
1036         /*
1037          * If hardware is idle, then all descriptors on the running lists are
1038          * done, start new transfers
1039          */
1040         if (chan->has_sg)
1041                 dma_ctrl_write(chan, XILINX_DMA_REG_CURDESC,
1042                                 desc->async_tx.phys);
1043
1044         /* Configure the hardware using info in the config structure */
1045         reg = dma_ctrl_read(chan, XILINX_DMA_REG_DMACR);
1046
1047         if (config->frm_cnt_en)
1048                 reg |= XILINX_DMA_DMACR_FRAMECNT_EN;
1049         else
1050                 reg &= ~XILINX_DMA_DMACR_FRAMECNT_EN;
1051
1052         /* Configure channel to allow number frame buffers */
1053         dma_ctrl_write(chan, XILINX_DMA_REG_FRMSTORE,
1054                         chan->desc_pendingcount);
1055
1056         /*
1057          * With SG, start with circular mode, so that BDs can be fetched.
1058          * In direct register mode, if not parking, enable circular mode
1059          */
1060         if (chan->has_sg || !config->park)
1061                 reg |= XILINX_DMA_DMACR_CIRC_EN;
1062
1063         if (config->park)
1064                 reg &= ~XILINX_DMA_DMACR_CIRC_EN;
1065
1066         dma_ctrl_write(chan, XILINX_DMA_REG_DMACR, reg);
1067
1068         if (config->park && (config->park_frm >= 0) &&
1069                         (config->park_frm < chan->num_frms)) {
1070                 if (chan->direction == DMA_MEM_TO_DEV)
1071                         dma_write(chan, XILINX_DMA_REG_PARK_PTR,
1072                                 config->park_frm <<
1073                                         XILINX_DMA_PARK_PTR_RD_REF_SHIFT);
1074                 else
1075                         dma_write(chan, XILINX_DMA_REG_PARK_PTR,
1076                                 config->park_frm <<
1077                                         XILINX_DMA_PARK_PTR_WR_REF_SHIFT);
1078         }
1079
1080         /* Start the hardware */
1081         xilinx_dma_start(chan);
1082
1083         if (chan->err)
1084                 return;
1085
1086         /* Start the transfer */
1087         if (chan->has_sg) {
1088                 dma_ctrl_write(chan, XILINX_DMA_REG_TAILDESC,
1089                                 tail_segment->phys);
1090         } else {
1091                 struct xilinx_vdma_tx_segment *segment, *last = NULL;
1092                 int i = 0;
1093
1094                 if (chan->desc_submitcount < chan->num_frms)
1095                         i = chan->desc_submitcount;
1096
1097                 list_for_each_entry(segment, &desc->segments, node) {
1098                         if (chan->ext_addr)
1099                                 vdma_desc_write_64(chan,
1100                                         XILINX_VDMA_REG_START_ADDRESS_64(i++),
1101                                         segment->hw.buf_addr,
1102                                         segment->hw.buf_addr_msb);
1103                         else
1104                                 vdma_desc_write(chan,
1105                                         XILINX_VDMA_REG_START_ADDRESS(i++),
1106                                         segment->hw.buf_addr);
1107
1108                         last = segment;
1109                 }
1110
1111                 if (!last)
1112                         return;
1113
1114                 /* HW expects these parameters to be same for one transaction */
1115                 vdma_desc_write(chan, XILINX_DMA_REG_HSIZE, last->hw.hsize);
1116                 vdma_desc_write(chan, XILINX_DMA_REG_FRMDLY_STRIDE,
1117                                 last->hw.stride);
1118                 vdma_desc_write(chan, XILINX_DMA_REG_VSIZE, last->hw.vsize);
1119         }
1120
1121         if (!chan->has_sg) {
1122                 list_del(&desc->node);
1123                 list_add_tail(&desc->node, &chan->active_list);
1124                 chan->desc_submitcount++;
1125                 chan->desc_pendingcount--;
1126                 if (chan->desc_submitcount == chan->num_frms)
1127                         chan->desc_submitcount = 0;
1128         } else {
1129                 list_splice_tail_init(&chan->pending_list, &chan->active_list);
1130                 chan->desc_pendingcount = 0;
1131         }
1132 }
1133
1134 /**
1135  * xilinx_cdma_start_transfer - Starts cdma transfer
1136  * @chan: Driver specific channel struct pointer
1137  */
1138 static void xilinx_cdma_start_transfer(struct xilinx_dma_chan *chan)
1139 {
1140         struct xilinx_dma_tx_descriptor *head_desc, *tail_desc;
1141         struct xilinx_cdma_tx_segment *tail_segment;
1142         u32 ctrl_reg = dma_read(chan, XILINX_DMA_REG_DMACR);
1143
1144         if (chan->err)
1145                 return;
1146
1147         if (list_empty(&chan->pending_list))
1148                 return;
1149
1150         head_desc = list_first_entry(&chan->pending_list,
1151                                      struct xilinx_dma_tx_descriptor, node);
1152         tail_desc = list_last_entry(&chan->pending_list,
1153                                     struct xilinx_dma_tx_descriptor, node);
1154         tail_segment = list_last_entry(&tail_desc->segments,
1155                                        struct xilinx_cdma_tx_segment, node);
1156
1157         if (chan->desc_pendingcount <= XILINX_DMA_COALESCE_MAX) {
1158                 ctrl_reg &= ~XILINX_DMA_CR_COALESCE_MAX;
1159                 ctrl_reg |= chan->desc_pendingcount <<
1160                                 XILINX_DMA_CR_COALESCE_SHIFT;
1161                 dma_ctrl_write(chan, XILINX_DMA_REG_DMACR, ctrl_reg);
1162         }
1163
1164         if (chan->has_sg) {
1165                 xilinx_write(chan, XILINX_DMA_REG_CURDESC,
1166                              head_desc->async_tx.phys);
1167
1168                 /* Update tail ptr register which will start the transfer */
1169                 xilinx_write(chan, XILINX_DMA_REG_TAILDESC,
1170                              tail_segment->phys);
1171         } else {
1172                 /* In simple mode */
1173                 struct xilinx_cdma_tx_segment *segment;
1174                 struct xilinx_cdma_desc_hw *hw;
1175
1176                 segment = list_first_entry(&head_desc->segments,
1177                                            struct xilinx_cdma_tx_segment,
1178                                            node);
1179
1180                 hw = &segment->hw;
1181
1182                 xilinx_write(chan, XILINX_CDMA_REG_SRCADDR, hw->src_addr);
1183                 xilinx_write(chan, XILINX_CDMA_REG_DSTADDR, hw->dest_addr);
1184
1185                 /* Start the transfer */
1186                 dma_ctrl_write(chan, XILINX_DMA_REG_BTT,
1187                                 hw->control & XILINX_DMA_MAX_TRANS_LEN);
1188         }
1189
1190         list_splice_tail_init(&chan->pending_list, &chan->active_list);
1191         chan->desc_pendingcount = 0;
1192 }
1193
1194 /**
1195  * xilinx_dma_start_transfer - Starts DMA transfer
1196  * @chan: Driver specific channel struct pointer
1197  */
1198 static void xilinx_dma_start_transfer(struct xilinx_dma_chan *chan)
1199 {
1200         struct xilinx_dma_tx_descriptor *head_desc, *tail_desc;
1201         struct xilinx_axidma_tx_segment *tail_segment, *old_head, *new_head;
1202         u32 reg;
1203
1204         if (chan->err)
1205                 return;
1206
1207         if (list_empty(&chan->pending_list))
1208                 return;
1209
1210         /* If it is SG mode and hardware is busy, cannot submit */
1211         if (chan->has_sg && xilinx_dma_is_running(chan) &&
1212             !xilinx_dma_is_idle(chan)) {
1213                 dev_dbg(chan->dev, "DMA controller still busy\n");
1214                 return;
1215         }
1216
1217         head_desc = list_first_entry(&chan->pending_list,
1218                                      struct xilinx_dma_tx_descriptor, node);
1219         tail_desc = list_last_entry(&chan->pending_list,
1220                                     struct xilinx_dma_tx_descriptor, node);
1221         tail_segment = list_last_entry(&tail_desc->segments,
1222                                        struct xilinx_axidma_tx_segment, node);
1223
1224         if (chan->has_sg && !chan->xdev->mcdma) {
1225                 old_head = list_first_entry(&head_desc->segments,
1226                                         struct xilinx_axidma_tx_segment, node);
1227                 new_head = chan->seg_v;
1228                 /* Copy Buffer Descriptor fields. */
1229                 new_head->hw = old_head->hw;
1230
1231                 /* Swap and save new reserve */
1232                 list_replace_init(&old_head->node, &new_head->node);
1233                 chan->seg_v = old_head;
1234
1235                 tail_segment->hw.next_desc = chan->seg_v->phys;
1236                 head_desc->async_tx.phys = new_head->phys;
1237         }
1238
1239         reg = dma_ctrl_read(chan, XILINX_DMA_REG_DMACR);
1240
1241         if (chan->desc_pendingcount <= XILINX_DMA_COALESCE_MAX) {
1242                 reg &= ~XILINX_DMA_CR_COALESCE_MAX;
1243                 reg |= chan->desc_pendingcount <<
1244                                   XILINX_DMA_CR_COALESCE_SHIFT;
1245                 dma_ctrl_write(chan, XILINX_DMA_REG_DMACR, reg);
1246         }
1247
1248         if (chan->has_sg && !chan->xdev->mcdma)
1249                 xilinx_write(chan, XILINX_DMA_REG_CURDESC,
1250                              head_desc->async_tx.phys);
1251
1252         if (chan->has_sg && chan->xdev->mcdma) {
1253                 if (chan->direction == DMA_MEM_TO_DEV) {
1254                         dma_ctrl_write(chan, XILINX_DMA_REG_CURDESC,
1255                                        head_desc->async_tx.phys);
1256                 } else {
1257                         if (!chan->tdest) {
1258                                 dma_ctrl_write(chan, XILINX_DMA_REG_CURDESC,
1259                                        head_desc->async_tx.phys);
1260                         } else {
1261                                 dma_ctrl_write(chan,
1262                                         XILINX_DMA_MCRX_CDESC(chan->tdest),
1263                                        head_desc->async_tx.phys);
1264                         }
1265                 }
1266         }
1267
1268         xilinx_dma_start(chan);
1269
1270         if (chan->err)
1271                 return;
1272
1273         /* Start the transfer */
1274         if (chan->has_sg && !chan->xdev->mcdma) {
1275                 if (chan->cyclic)
1276                         xilinx_write(chan, XILINX_DMA_REG_TAILDESC,
1277                                      chan->cyclic_seg_v->phys);
1278                 else
1279                         xilinx_write(chan, XILINX_DMA_REG_TAILDESC,
1280                                      tail_segment->phys);
1281         } else if (chan->has_sg && chan->xdev->mcdma) {
1282                 if (chan->direction == DMA_MEM_TO_DEV) {
1283                         dma_ctrl_write(chan, XILINX_DMA_REG_TAILDESC,
1284                                tail_segment->phys);
1285                 } else {
1286                         if (!chan->tdest) {
1287                                 dma_ctrl_write(chan, XILINX_DMA_REG_TAILDESC,
1288                                                tail_segment->phys);
1289                         } else {
1290                                 dma_ctrl_write(chan,
1291                                         XILINX_DMA_MCRX_TDESC(chan->tdest),
1292                                         tail_segment->phys);
1293                         }
1294                 }
1295         } else {
1296                 struct xilinx_axidma_tx_segment *segment;
1297                 struct xilinx_axidma_desc_hw *hw;
1298
1299                 segment = list_first_entry(&head_desc->segments,
1300                                            struct xilinx_axidma_tx_segment,
1301                                            node);
1302                 hw = &segment->hw;
1303
1304                 xilinx_write(chan, XILINX_DMA_REG_SRCDSTADDR, hw->buf_addr);
1305
1306                 /* Start the transfer */
1307                 dma_ctrl_write(chan, XILINX_DMA_REG_BTT,
1308                                hw->control & XILINX_DMA_MAX_TRANS_LEN);
1309         }
1310
1311         list_splice_tail_init(&chan->pending_list, &chan->active_list);
1312         chan->desc_pendingcount = 0;
1313 }
1314
1315 /**
1316  * xilinx_dma_issue_pending - Issue pending transactions
1317  * @dchan: DMA channel
1318  */
1319 static void xilinx_dma_issue_pending(struct dma_chan *dchan)
1320 {
1321         struct xilinx_dma_chan *chan = to_xilinx_chan(dchan);
1322         unsigned long flags;
1323
1324         spin_lock_irqsave(&chan->lock, flags);
1325         chan->start_transfer(chan);
1326         spin_unlock_irqrestore(&chan->lock, flags);
1327 }
1328
1329 /**
1330  * xilinx_dma_complete_descriptor - Mark the active descriptor as complete
1331  * @chan : xilinx DMA channel
1332  *
1333  * CONTEXT: hardirq
1334  */
1335 static void xilinx_dma_complete_descriptor(struct xilinx_dma_chan *chan)
1336 {
1337         struct xilinx_dma_tx_descriptor *desc, *next;
1338
1339         /* This function was invoked with lock held */
1340         if (list_empty(&chan->active_list))
1341                 return;
1342
1343         list_for_each_entry_safe(desc, next, &chan->active_list, node) {
1344                 list_del(&desc->node);
1345                 if (!desc->cyclic)
1346                         dma_cookie_complete(&desc->async_tx);
1347                 list_add_tail(&desc->node, &chan->done_list);
1348         }
1349 }
1350
1351 /**
1352  * xilinx_dma_reset - Reset DMA channel
1353  * @chan: Driver specific DMA channel
1354  *
1355  * Return: '0' on success and failure value on error
1356  */
1357 static int xilinx_dma_reset(struct xilinx_dma_chan *chan)
1358 {
1359         int err;
1360         u32 tmp;
1361
1362         dma_ctrl_set(chan, XILINX_DMA_REG_DMACR, XILINX_DMA_DMACR_RESET);
1363
1364         /* Wait for the hardware to finish reset */
1365         err = xilinx_dma_poll_timeout(chan, XILINX_DMA_REG_DMACR, tmp,
1366                                       !(tmp & XILINX_DMA_DMACR_RESET), 0,
1367                                       XILINX_DMA_LOOP_COUNT);
1368
1369         if (err) {
1370                 dev_err(chan->dev, "reset timeout, cr %x, sr %x\n",
1371                         dma_ctrl_read(chan, XILINX_DMA_REG_DMACR),
1372                         dma_ctrl_read(chan, XILINX_DMA_REG_DMASR));
1373                 return -ETIMEDOUT;
1374         }
1375
1376         chan->err = false;
1377
1378         return err;
1379 }
1380
1381 /**
1382  * xilinx_dma_chan_reset - Reset DMA channel and enable interrupts
1383  * @chan: Driver specific DMA channel
1384  *
1385  * Return: '0' on success and failure value on error
1386  */
1387 static int xilinx_dma_chan_reset(struct xilinx_dma_chan *chan)
1388 {
1389         int err;
1390
1391         /* Reset VDMA */
1392         err = xilinx_dma_reset(chan);
1393         if (err)
1394                 return err;
1395
1396         /* Enable interrupts */
1397         dma_ctrl_set(chan, XILINX_DMA_REG_DMACR,
1398                       XILINX_DMA_DMAXR_ALL_IRQ_MASK);
1399
1400         return 0;
1401 }
1402
1403 /**
1404  * xilinx_dma_irq_handler - DMA Interrupt handler
1405  * @irq: IRQ number
1406  * @data: Pointer to the Xilinx DMA channel structure
1407  *
1408  * Return: IRQ_HANDLED/IRQ_NONE
1409  */
1410 static irqreturn_t xilinx_dma_irq_handler(int irq, void *data)
1411 {
1412         struct xilinx_dma_chan *chan = data;
1413         u32 status;
1414
1415         /* Read the status and ack the interrupts. */
1416         status = dma_ctrl_read(chan, XILINX_DMA_REG_DMASR);
1417         if (!(status & XILINX_DMA_DMAXR_ALL_IRQ_MASK))
1418                 return IRQ_NONE;
1419
1420         dma_ctrl_write(chan, XILINX_DMA_REG_DMASR,
1421                         status & XILINX_DMA_DMAXR_ALL_IRQ_MASK);
1422
1423         if (status & XILINX_DMA_DMASR_ERR_IRQ) {
1424                 /*
1425                  * An error occurred. If C_FLUSH_ON_FSYNC is enabled and the
1426                  * error is recoverable, ignore it. Otherwise flag the error.
1427                  *
1428                  * Only recoverable errors can be cleared in the DMASR register,
1429                  * make sure not to write to other error bits to 1.
1430                  */
1431                 u32 errors = status & XILINX_DMA_DMASR_ALL_ERR_MASK;
1432
1433                 dma_ctrl_write(chan, XILINX_DMA_REG_DMASR,
1434                                 errors & XILINX_DMA_DMASR_ERR_RECOVER_MASK);
1435
1436                 if (!chan->flush_on_fsync ||
1437                     (errors & ~XILINX_DMA_DMASR_ERR_RECOVER_MASK)) {
1438                         dev_err(chan->dev,
1439                                 "Channel %p has errors %x, cdr %x tdr %x\n",
1440                                 chan, errors,
1441                                 dma_ctrl_read(chan, XILINX_DMA_REG_CURDESC),
1442                                 dma_ctrl_read(chan, XILINX_DMA_REG_TAILDESC));
1443                         chan->err = true;
1444                 }
1445         }
1446
1447         if (status & XILINX_DMA_DMASR_DLY_CNT_IRQ) {
1448                 /*
1449                  * Device takes too long to do the transfer when user requires
1450                  * responsiveness.
1451                  */
1452                 dev_dbg(chan->dev, "Inter-packet latency too long\n");
1453         }
1454
1455         if (status & XILINX_DMA_DMASR_FRM_CNT_IRQ) {
1456                 spin_lock(&chan->lock);
1457                 xilinx_dma_complete_descriptor(chan);
1458                 chan->start_transfer(chan);
1459                 spin_unlock(&chan->lock);
1460         }
1461
1462         tasklet_schedule(&chan->tasklet);
1463         return IRQ_HANDLED;
1464 }
1465
1466 /**
1467  * append_desc_queue - Queuing descriptor
1468  * @chan: Driver specific dma channel
1469  * @desc: dma transaction descriptor
1470  */
1471 static void append_desc_queue(struct xilinx_dma_chan *chan,
1472                               struct xilinx_dma_tx_descriptor *desc)
1473 {
1474         struct xilinx_vdma_tx_segment *tail_segment;
1475         struct xilinx_dma_tx_descriptor *tail_desc;
1476         struct xilinx_axidma_tx_segment *axidma_tail_segment;
1477         struct xilinx_cdma_tx_segment *cdma_tail_segment;
1478
1479         if (list_empty(&chan->pending_list))
1480                 goto append;
1481
1482         /*
1483          * Add the hardware descriptor to the chain of hardware descriptors
1484          * that already exists in memory.
1485          */
1486         tail_desc = list_last_entry(&chan->pending_list,
1487                                     struct xilinx_dma_tx_descriptor, node);
1488         if (chan->xdev->dma_config->dmatype == XDMA_TYPE_VDMA) {
1489                 tail_segment = list_last_entry(&tail_desc->segments,
1490                                                struct xilinx_vdma_tx_segment,
1491                                                node);
1492                 tail_segment->hw.next_desc = (u32)desc->async_tx.phys;
1493         } else if (chan->xdev->dma_config->dmatype == XDMA_TYPE_CDMA) {
1494                 cdma_tail_segment = list_last_entry(&tail_desc->segments,
1495                                                 struct xilinx_cdma_tx_segment,
1496                                                 node);
1497                 cdma_tail_segment->hw.next_desc = (u32)desc->async_tx.phys;
1498         } else {
1499                 axidma_tail_segment = list_last_entry(&tail_desc->segments,
1500                                                struct xilinx_axidma_tx_segment,
1501                                                node);
1502                 axidma_tail_segment->hw.next_desc = (u32)desc->async_tx.phys;
1503         }
1504
1505         /*
1506          * Add the software descriptor and all children to the list
1507          * of pending transactions
1508          */
1509 append:
1510         list_add_tail(&desc->node, &chan->pending_list);
1511         chan->desc_pendingcount++;
1512
1513         if (chan->has_sg && (chan->xdev->dma_config->dmatype == XDMA_TYPE_VDMA)
1514             && unlikely(chan->desc_pendingcount > chan->num_frms)) {
1515                 dev_dbg(chan->dev, "desc pendingcount is too high\n");
1516                 chan->desc_pendingcount = chan->num_frms;
1517         }
1518 }
1519
1520 /**
1521  * xilinx_dma_tx_submit - Submit DMA transaction
1522  * @tx: Async transaction descriptor
1523  *
1524  * Return: cookie value on success and failure value on error
1525  */
1526 static dma_cookie_t xilinx_dma_tx_submit(struct dma_async_tx_descriptor *tx)
1527 {
1528         struct xilinx_dma_tx_descriptor *desc = to_dma_tx_descriptor(tx);
1529         struct xilinx_dma_chan *chan = to_xilinx_chan(tx->chan);
1530         dma_cookie_t cookie;
1531         unsigned long flags;
1532         int err;
1533
1534         if (chan->cyclic) {
1535                 xilinx_dma_free_tx_descriptor(chan, desc);
1536                 return -EBUSY;
1537         }
1538
1539         if (chan->err) {
1540                 /*
1541                  * If reset fails, need to hard reset the system.
1542                  * Channel is no longer functional
1543                  */
1544                 err = xilinx_dma_chan_reset(chan);
1545                 if (err < 0)
1546                         return err;
1547         }
1548
1549         spin_lock_irqsave(&chan->lock, flags);
1550
1551         cookie = dma_cookie_assign(tx);
1552
1553         /* Put this transaction onto the tail of the pending queue */
1554         append_desc_queue(chan, desc);
1555
1556         if (desc->cyclic)
1557                 chan->cyclic = true;
1558
1559         spin_unlock_irqrestore(&chan->lock, flags);
1560
1561         return cookie;
1562 }
1563
1564 /**
1565  * xilinx_vdma_dma_prep_interleaved - prepare a descriptor for a
1566  *      DMA_SLAVE transaction
1567  * @dchan: DMA channel
1568  * @xt: Interleaved template pointer
1569  * @flags: transfer ack flags
1570  *
1571  * Return: Async transaction descriptor on success and NULL on failure
1572  */
1573 static struct dma_async_tx_descriptor *
1574 xilinx_vdma_dma_prep_interleaved(struct dma_chan *dchan,
1575                                  struct dma_interleaved_template *xt,
1576                                  unsigned long flags)
1577 {
1578         struct xilinx_dma_chan *chan = to_xilinx_chan(dchan);
1579         struct xilinx_dma_tx_descriptor *desc;
1580         struct xilinx_vdma_tx_segment *segment, *prev = NULL;
1581         struct xilinx_vdma_desc_hw *hw;
1582
1583         if (!is_slave_direction(xt->dir))
1584                 return NULL;
1585
1586         if (!xt->numf || !xt->sgl[0].size)
1587                 return NULL;
1588
1589         if (xt->frame_size != 1)
1590                 return NULL;
1591
1592         /* Allocate a transaction descriptor. */
1593         desc = xilinx_dma_alloc_tx_descriptor(chan);
1594         if (!desc)
1595                 return NULL;
1596
1597         dma_async_tx_descriptor_init(&desc->async_tx, &chan->common);
1598         desc->async_tx.tx_submit = xilinx_dma_tx_submit;
1599         async_tx_ack(&desc->async_tx);
1600
1601         /* Allocate the link descriptor from DMA pool */
1602         segment = xilinx_vdma_alloc_tx_segment(chan);
1603         if (!segment)
1604                 goto error;
1605
1606         /* Fill in the hardware descriptor */
1607         hw = &segment->hw;
1608         hw->vsize = xt->numf;
1609         hw->hsize = xt->sgl[0].size;
1610         hw->stride = (xt->sgl[0].icg + xt->sgl[0].size) <<
1611                         XILINX_DMA_FRMDLY_STRIDE_STRIDE_SHIFT;
1612         hw->stride |= chan->config.frm_dly <<
1613                         XILINX_DMA_FRMDLY_STRIDE_FRMDLY_SHIFT;
1614
1615         if (xt->dir != DMA_MEM_TO_DEV) {
1616                 if (chan->ext_addr) {
1617                         hw->buf_addr = lower_32_bits(xt->dst_start);
1618                         hw->buf_addr_msb = upper_32_bits(xt->dst_start);
1619                 } else {
1620                         hw->buf_addr = xt->dst_start;
1621                 }
1622         } else {
1623                 if (chan->ext_addr) {
1624                         hw->buf_addr = lower_32_bits(xt->src_start);
1625                         hw->buf_addr_msb = upper_32_bits(xt->src_start);
1626                 } else {
1627                         hw->buf_addr = xt->src_start;
1628                 }
1629         }
1630
1631         /* Insert the segment into the descriptor segments list. */
1632         list_add_tail(&segment->node, &desc->segments);
1633
1634         prev = segment;
1635
1636         /* Link the last hardware descriptor with the first. */
1637         segment = list_first_entry(&desc->segments,
1638                                    struct xilinx_vdma_tx_segment, node);
1639         desc->async_tx.phys = segment->phys;
1640
1641         return &desc->async_tx;
1642
1643 error:
1644         xilinx_dma_free_tx_descriptor(chan, desc);
1645         return NULL;
1646 }
1647
1648 /**
1649  * xilinx_cdma_prep_memcpy - prepare descriptors for a memcpy transaction
1650  * @dchan: DMA channel
1651  * @dma_dst: destination address
1652  * @dma_src: source address
1653  * @len: transfer length
1654  * @flags: transfer ack flags
1655  *
1656  * Return: Async transaction descriptor on success and NULL on failure
1657  */
1658 static struct dma_async_tx_descriptor *
1659 xilinx_cdma_prep_memcpy(struct dma_chan *dchan, dma_addr_t dma_dst,
1660                         dma_addr_t dma_src, size_t len, unsigned long flags)
1661 {
1662         struct xilinx_dma_chan *chan = to_xilinx_chan(dchan);
1663         struct xilinx_dma_tx_descriptor *desc;
1664         struct xilinx_cdma_tx_segment *segment, *prev;
1665         struct xilinx_cdma_desc_hw *hw;
1666
1667         if (!len || len > XILINX_DMA_MAX_TRANS_LEN)
1668                 return NULL;
1669
1670         desc = xilinx_dma_alloc_tx_descriptor(chan);
1671         if (!desc)
1672                 return NULL;
1673
1674         dma_async_tx_descriptor_init(&desc->async_tx, &chan->common);
1675         desc->async_tx.tx_submit = xilinx_dma_tx_submit;
1676
1677         /* Allocate the link descriptor from DMA pool */
1678         segment = xilinx_cdma_alloc_tx_segment(chan);
1679         if (!segment)
1680                 goto error;
1681
1682         hw = &segment->hw;
1683         hw->control = len;
1684         hw->src_addr = dma_src;
1685         hw->dest_addr = dma_dst;
1686         if (chan->ext_addr) {
1687                 hw->src_addr_msb = upper_32_bits(dma_src);
1688                 hw->dest_addr_msb = upper_32_bits(dma_dst);
1689         }
1690
1691         /* Fill the previous next descriptor with current */
1692         prev = list_last_entry(&desc->segments,
1693                                struct xilinx_cdma_tx_segment, node);
1694         prev->hw.next_desc = segment->phys;
1695
1696         /* Insert the segment into the descriptor segments list. */
1697         list_add_tail(&segment->node, &desc->segments);
1698
1699         prev = segment;
1700
1701         /* Link the last hardware descriptor with the first. */
1702         segment = list_first_entry(&desc->segments,
1703                                 struct xilinx_cdma_tx_segment, node);
1704         desc->async_tx.phys = segment->phys;
1705         prev->hw.next_desc = segment->phys;
1706
1707         return &desc->async_tx;
1708
1709 error:
1710         xilinx_dma_free_tx_descriptor(chan, desc);
1711         return NULL;
1712 }
1713
1714 /**
1715  * xilinx_dma_prep_slave_sg - prepare descriptors for a DMA_SLAVE transaction
1716  * @dchan: DMA channel
1717  * @sgl: scatterlist to transfer to/from
1718  * @sg_len: number of entries in @scatterlist
1719  * @direction: DMA direction
1720  * @flags: transfer ack flags
1721  * @context: APP words of the descriptor
1722  *
1723  * Return: Async transaction descriptor on success and NULL on failure
1724  */
1725 static struct dma_async_tx_descriptor *xilinx_dma_prep_slave_sg(
1726         struct dma_chan *dchan, struct scatterlist *sgl, unsigned int sg_len,
1727         enum dma_transfer_direction direction, unsigned long flags,
1728         void *context)
1729 {
1730         struct xilinx_dma_chan *chan = to_xilinx_chan(dchan);
1731         struct xilinx_dma_tx_descriptor *desc;
1732         struct xilinx_axidma_tx_segment *segment = NULL, *prev = NULL;
1733         u32 *app_w = (u32 *)context;
1734         struct scatterlist *sg;
1735         size_t copy;
1736         size_t sg_used;
1737         unsigned int i;
1738
1739         if (!is_slave_direction(direction))
1740                 return NULL;
1741
1742         /* Allocate a transaction descriptor. */
1743         desc = xilinx_dma_alloc_tx_descriptor(chan);
1744         if (!desc)
1745                 return NULL;
1746
1747         dma_async_tx_descriptor_init(&desc->async_tx, &chan->common);
1748         desc->async_tx.tx_submit = xilinx_dma_tx_submit;
1749
1750         /* Build transactions using information in the scatter gather list */
1751         for_each_sg(sgl, sg, sg_len, i) {
1752                 sg_used = 0;
1753
1754                 /* Loop until the entire scatterlist entry is used */
1755                 while (sg_used < sg_dma_len(sg)) {
1756                         struct xilinx_axidma_desc_hw *hw;
1757
1758                         /* Get a free segment */
1759                         segment = xilinx_axidma_alloc_tx_segment(chan);
1760                         if (!segment)
1761                                 goto error;
1762
1763                         /*
1764                          * Calculate the maximum number of bytes to transfer,
1765                          * making sure it is less than the hw limit
1766                          */
1767                         copy = min_t(size_t, sg_dma_len(sg) - sg_used,
1768                                      XILINX_DMA_MAX_TRANS_LEN);
1769                         hw = &segment->hw;
1770
1771                         /* Fill in the descriptor */
1772                         xilinx_axidma_buf(chan, hw, sg_dma_address(sg),
1773                                           sg_used, 0);
1774
1775                         hw->control = copy;
1776
1777                         if (chan->direction == DMA_MEM_TO_DEV) {
1778                                 if (app_w)
1779                                         memcpy(hw->app, app_w, sizeof(u32) *
1780                                                XILINX_DMA_NUM_APP_WORDS);
1781                         }
1782
1783                         if (prev)
1784                                 prev->hw.next_desc = segment->phys;
1785
1786                         prev = segment;
1787                         sg_used += copy;
1788
1789                         /*
1790                          * Insert the segment into the descriptor segments
1791                          * list.
1792                          */
1793                         list_add_tail(&segment->node, &desc->segments);
1794                 }
1795         }
1796
1797         segment = list_first_entry(&desc->segments,
1798                                    struct xilinx_axidma_tx_segment, node);
1799         desc->async_tx.phys = segment->phys;
1800         prev->hw.next_desc = segment->phys;
1801
1802         /* For the last DMA_MEM_TO_DEV transfer, set EOP */
1803         if (chan->direction == DMA_MEM_TO_DEV) {
1804                 segment->hw.control |= XILINX_DMA_BD_SOP;
1805                 segment = list_last_entry(&desc->segments,
1806                                           struct xilinx_axidma_tx_segment,
1807                                           node);
1808                 segment->hw.control |= XILINX_DMA_BD_EOP;
1809         }
1810
1811         return &desc->async_tx;
1812
1813 error:
1814         xilinx_dma_free_tx_descriptor(chan, desc);
1815         return NULL;
1816 }
1817
1818 /**
1819  * xilinx_dma_prep_dma_cyclic - prepare descriptors for a DMA_SLAVE transaction
1820  * @chan: DMA channel
1821  * @sgl: scatterlist to transfer to/from
1822  * @sg_len: number of entries in @scatterlist
1823  * @direction: DMA direction
1824  * @flags: transfer ack flags
1825  */
1826 static struct dma_async_tx_descriptor *xilinx_dma_prep_dma_cyclic(
1827         struct dma_chan *dchan, dma_addr_t buf_addr, size_t buf_len,
1828         size_t period_len, enum dma_transfer_direction direction,
1829         unsigned long flags)
1830 {
1831         struct xilinx_dma_chan *chan = to_xilinx_chan(dchan);
1832         struct xilinx_dma_tx_descriptor *desc;
1833         struct xilinx_axidma_tx_segment *segment, *head_segment, *prev = NULL;
1834         size_t copy, sg_used;
1835         unsigned int num_periods;
1836         int i;
1837         u32 reg;
1838
1839         if (!period_len)
1840                 return NULL;
1841
1842         num_periods = buf_len / period_len;
1843
1844         if (!num_periods)
1845                 return NULL;
1846
1847         if (!is_slave_direction(direction))
1848                 return NULL;
1849
1850         /* Allocate a transaction descriptor. */
1851         desc = xilinx_dma_alloc_tx_descriptor(chan);
1852         if (!desc)
1853                 return NULL;
1854
1855         chan->direction = direction;
1856         dma_async_tx_descriptor_init(&desc->async_tx, &chan->common);
1857         desc->async_tx.tx_submit = xilinx_dma_tx_submit;
1858
1859         for (i = 0; i < num_periods; ++i) {
1860                 sg_used = 0;
1861
1862                 while (sg_used < period_len) {
1863                         struct xilinx_axidma_desc_hw *hw;
1864
1865                         /* Get a free segment */
1866                         segment = xilinx_axidma_alloc_tx_segment(chan);
1867                         if (!segment)
1868                                 goto error;
1869
1870                         /*
1871                          * Calculate the maximum number of bytes to transfer,
1872                          * making sure it is less than the hw limit
1873                          */
1874                         copy = min_t(size_t, period_len - sg_used,
1875                                      XILINX_DMA_MAX_TRANS_LEN);
1876                         hw = &segment->hw;
1877                         xilinx_axidma_buf(chan, hw, buf_addr, sg_used,
1878                                           period_len * i);
1879                         hw->control = copy;
1880
1881                         if (prev)
1882                                 prev->hw.next_desc = segment->phys;
1883
1884                         prev = segment;
1885                         sg_used += copy;
1886
1887                         /*
1888                          * Insert the segment into the descriptor segments
1889                          * list.
1890                          */
1891                         list_add_tail(&segment->node, &desc->segments);
1892                 }
1893         }
1894
1895         head_segment = list_first_entry(&desc->segments,
1896                                    struct xilinx_axidma_tx_segment, node);
1897         desc->async_tx.phys = head_segment->phys;
1898
1899         desc->cyclic = true;
1900         reg = dma_ctrl_read(chan, XILINX_DMA_REG_DMACR);
1901         reg |= XILINX_DMA_CR_CYCLIC_BD_EN_MASK;
1902         dma_ctrl_write(chan, XILINX_DMA_REG_DMACR, reg);
1903
1904         segment = list_last_entry(&desc->segments,
1905                                   struct xilinx_axidma_tx_segment,
1906                                   node);
1907         segment->hw.next_desc = (u32) head_segment->phys;
1908
1909         /* For the last DMA_MEM_TO_DEV transfer, set EOP */
1910         if (direction == DMA_MEM_TO_DEV) {
1911                 head_segment->hw.control |= XILINX_DMA_BD_SOP;
1912                 segment->hw.control |= XILINX_DMA_BD_EOP;
1913         }
1914
1915         return &desc->async_tx;
1916
1917 error:
1918         xilinx_dma_free_tx_descriptor(chan, desc);
1919         return NULL;
1920 }
1921
1922 /**
1923  * xilinx_dma_prep_interleaved - prepare a descriptor for a
1924  *      DMA_SLAVE transaction
1925  * @dchan: DMA channel
1926  * @xt: Interleaved template pointer
1927  * @flags: transfer ack flags
1928  *
1929  * Return: Async transaction descriptor on success and NULL on failure
1930  */
1931 static struct dma_async_tx_descriptor *
1932 xilinx_dma_prep_interleaved(struct dma_chan *dchan,
1933                                  struct dma_interleaved_template *xt,
1934                                  unsigned long flags)
1935 {
1936         struct xilinx_dma_chan *chan = to_xilinx_chan(dchan);
1937         struct xilinx_dma_tx_descriptor *desc;
1938         struct xilinx_axidma_tx_segment *segment;
1939         struct xilinx_axidma_desc_hw *hw;
1940
1941         if (!is_slave_direction(xt->dir))
1942                 return NULL;
1943
1944         if (!xt->numf || !xt->sgl[0].size)
1945                 return NULL;
1946
1947         if (xt->frame_size != 1)
1948                 return NULL;
1949
1950         /* Allocate a transaction descriptor. */
1951         desc = xilinx_dma_alloc_tx_descriptor(chan);
1952         if (!desc)
1953                 return NULL;
1954
1955         chan->direction = xt->dir;
1956         dma_async_tx_descriptor_init(&desc->async_tx, &chan->common);
1957         desc->async_tx.tx_submit = xilinx_dma_tx_submit;
1958
1959         /* Get a free segment */
1960         segment = xilinx_axidma_alloc_tx_segment(chan);
1961         if (!segment)
1962                 goto error;
1963
1964         hw = &segment->hw;
1965
1966         /* Fill in the descriptor */
1967         if (xt->dir != DMA_MEM_TO_DEV)
1968                 hw->buf_addr = xt->dst_start;
1969         else
1970                 hw->buf_addr = xt->src_start;
1971
1972         hw->mcdma_control = chan->tdest & XILINX_DMA_BD_TDEST_MASK;
1973         hw->vsize_stride = (xt->numf << XILINX_DMA_BD_VSIZE_SHIFT) &
1974                             XILINX_DMA_BD_VSIZE_MASK;
1975         hw->vsize_stride |= (xt->sgl[0].icg + xt->sgl[0].size) &
1976                             XILINX_DMA_BD_STRIDE_MASK;
1977         hw->control = xt->sgl[0].size & XILINX_DMA_BD_HSIZE_MASK;
1978
1979         /*
1980          * Insert the segment into the descriptor segments
1981          * list.
1982          */
1983         list_add_tail(&segment->node, &desc->segments);
1984
1985
1986         segment = list_first_entry(&desc->segments,
1987                                    struct xilinx_axidma_tx_segment, node);
1988         desc->async_tx.phys = segment->phys;
1989
1990         /* For the last DMA_MEM_TO_DEV transfer, set EOP */
1991         if (xt->dir == DMA_MEM_TO_DEV) {
1992                 segment->hw.control |= XILINX_DMA_BD_SOP;
1993                 segment = list_last_entry(&desc->segments,
1994                                           struct xilinx_axidma_tx_segment,
1995                                           node);
1996                 segment->hw.control |= XILINX_DMA_BD_EOP;
1997         }
1998
1999         return &desc->async_tx;
2000
2001 error:
2002         xilinx_dma_free_tx_descriptor(chan, desc);
2003         return NULL;
2004 }
2005
2006 /**
2007  * xilinx_dma_terminate_all - Halt the channel and free descriptors
2008  * @chan: Driver specific DMA Channel pointer
2009  */
2010 static int xilinx_dma_terminate_all(struct dma_chan *dchan)
2011 {
2012         struct xilinx_dma_chan *chan = to_xilinx_chan(dchan);
2013         u32 reg;
2014         int err;
2015
2016         if (chan->cyclic)
2017                 xilinx_dma_chan_reset(chan);
2018
2019         err = chan->stop_transfer(chan);
2020         if (err) {
2021                 dev_err(chan->dev, "Cannot stop channel %p: %x\n",
2022                         chan, dma_ctrl_read(chan, XILINX_DMA_REG_DMASR));
2023                 chan->err = true;
2024         }
2025
2026         /* Remove and free all of the descriptors in the lists */
2027         xilinx_dma_free_descriptors(chan);
2028
2029         if (chan->cyclic) {
2030                 reg = dma_ctrl_read(chan, XILINX_DMA_REG_DMACR);
2031                 reg &= ~XILINX_DMA_CR_CYCLIC_BD_EN_MASK;
2032                 dma_ctrl_write(chan, XILINX_DMA_REG_DMACR, reg);
2033                 chan->cyclic = false;
2034         }
2035
2036         return 0;
2037 }
2038
2039 /**
2040  * xilinx_dma_channel_set_config - Configure VDMA channel
2041  * Run-time configuration for Axi VDMA, supports:
2042  * . halt the channel
2043  * . configure interrupt coalescing and inter-packet delay threshold
2044  * . start/stop parking
2045  * . enable genlock
2046  *
2047  * @dchan: DMA channel
2048  * @cfg: VDMA device configuration pointer
2049  *
2050  * Return: '0' on success and failure value on error
2051  */
2052 int xilinx_vdma_channel_set_config(struct dma_chan *dchan,
2053                                         struct xilinx_vdma_config *cfg)
2054 {
2055         struct xilinx_dma_chan *chan = to_xilinx_chan(dchan);
2056         u32 dmacr;
2057
2058         if (cfg->reset)
2059                 return xilinx_dma_chan_reset(chan);
2060
2061         dmacr = dma_ctrl_read(chan, XILINX_DMA_REG_DMACR);
2062
2063         chan->config.frm_dly = cfg->frm_dly;
2064         chan->config.park = cfg->park;
2065
2066         /* genlock settings */
2067         chan->config.gen_lock = cfg->gen_lock;
2068         chan->config.master = cfg->master;
2069
2070         if (cfg->gen_lock && chan->genlock) {
2071                 dmacr |= XILINX_DMA_DMACR_GENLOCK_EN;
2072                 dmacr |= cfg->master << XILINX_DMA_DMACR_MASTER_SHIFT;
2073         }
2074
2075         chan->config.frm_cnt_en = cfg->frm_cnt_en;
2076         if (cfg->park)
2077                 chan->config.park_frm = cfg->park_frm;
2078         else
2079                 chan->config.park_frm = -1;
2080
2081         chan->config.coalesc = cfg->coalesc;
2082         chan->config.delay = cfg->delay;
2083
2084         if (cfg->coalesc <= XILINX_DMA_DMACR_FRAME_COUNT_MAX) {
2085                 dmacr |= cfg->coalesc << XILINX_DMA_DMACR_FRAME_COUNT_SHIFT;
2086                 chan->config.coalesc = cfg->coalesc;
2087         }
2088
2089         if (cfg->delay <= XILINX_DMA_DMACR_DELAY_MAX) {
2090                 dmacr |= cfg->delay << XILINX_DMA_DMACR_DELAY_SHIFT;
2091                 chan->config.delay = cfg->delay;
2092         }
2093
2094         /* FSync Source selection */
2095         dmacr &= ~XILINX_DMA_DMACR_FSYNCSRC_MASK;
2096         dmacr |= cfg->ext_fsync << XILINX_DMA_DMACR_FSYNCSRC_SHIFT;
2097
2098         dma_ctrl_write(chan, XILINX_DMA_REG_DMACR, dmacr);
2099
2100         return 0;
2101 }
2102 EXPORT_SYMBOL(xilinx_vdma_channel_set_config);
2103
2104 /* -----------------------------------------------------------------------------
2105  * Probe and remove
2106  */
2107
2108 /**
2109  * xilinx_dma_chan_remove - Per Channel remove function
2110  * @chan: Driver specific DMA channel
2111  */
2112 static void xilinx_dma_chan_remove(struct xilinx_dma_chan *chan)
2113 {
2114         /* Disable all interrupts */
2115         dma_ctrl_clr(chan, XILINX_DMA_REG_DMACR,
2116                       XILINX_DMA_DMAXR_ALL_IRQ_MASK);
2117
2118         if (chan->irq > 0)
2119                 free_irq(chan->irq, chan);
2120
2121         tasklet_kill(&chan->tasklet);
2122
2123         list_del(&chan->common.device_node);
2124 }
2125
2126 static int axidma_clk_init(struct platform_device *pdev, struct clk **axi_clk,
2127                             struct clk **tx_clk, struct clk **rx_clk,
2128                             struct clk **sg_clk, struct clk **tmp_clk)
2129 {
2130         int err;
2131
2132         *tmp_clk = NULL;
2133
2134         *axi_clk = devm_clk_get(&pdev->dev, "s_axi_lite_aclk");
2135         if (IS_ERR(*axi_clk)) {
2136                 err = PTR_ERR(*axi_clk);
2137                 dev_err(&pdev->dev, "failed to get axi_aclk (%u)\n", err);
2138                 return err;
2139         }
2140
2141         *tx_clk = devm_clk_get(&pdev->dev, "m_axi_mm2s_aclk");
2142         if (IS_ERR(*tx_clk))
2143                 *tx_clk = NULL;
2144
2145         *rx_clk = devm_clk_get(&pdev->dev, "m_axi_s2mm_aclk");
2146         if (IS_ERR(*rx_clk))
2147                 *rx_clk = NULL;
2148
2149         *sg_clk = devm_clk_get(&pdev->dev, "m_axi_sg_aclk");
2150         if (IS_ERR(*sg_clk))
2151                 *sg_clk = NULL;
2152
2153         err = clk_prepare_enable(*axi_clk);
2154         if (err) {
2155                 dev_err(&pdev->dev, "failed to enable axi_clk (%u)\n", err);
2156                 return err;
2157         }
2158
2159         err = clk_prepare_enable(*tx_clk);
2160         if (err) {
2161                 dev_err(&pdev->dev, "failed to enable tx_clk (%u)\n", err);
2162                 goto err_disable_axiclk;
2163         }
2164
2165         err = clk_prepare_enable(*rx_clk);
2166         if (err) {
2167                 dev_err(&pdev->dev, "failed to enable rx_clk (%u)\n", err);
2168                 goto err_disable_txclk;
2169         }
2170
2171         err = clk_prepare_enable(*sg_clk);
2172         if (err) {
2173                 dev_err(&pdev->dev, "failed to enable sg_clk (%u)\n", err);
2174                 goto err_disable_rxclk;
2175         }
2176
2177         return 0;
2178
2179 err_disable_rxclk:
2180         clk_disable_unprepare(*rx_clk);
2181 err_disable_txclk:
2182         clk_disable_unprepare(*tx_clk);
2183 err_disable_axiclk:
2184         clk_disable_unprepare(*axi_clk);
2185
2186         return err;
2187 }
2188
2189 static int axicdma_clk_init(struct platform_device *pdev, struct clk **axi_clk,
2190                             struct clk **dev_clk, struct clk **tmp_clk,
2191                             struct clk **tmp1_clk, struct clk **tmp2_clk)
2192 {
2193         int err;
2194
2195         *tmp_clk = NULL;
2196         *tmp1_clk = NULL;
2197         *tmp2_clk = NULL;
2198
2199         *axi_clk = devm_clk_get(&pdev->dev, "s_axi_lite_aclk");
2200         if (IS_ERR(*axi_clk)) {
2201                 err = PTR_ERR(*axi_clk);
2202                 dev_err(&pdev->dev, "failed to get axi_clk (%u)\n", err);
2203                 return err;
2204         }
2205
2206         *dev_clk = devm_clk_get(&pdev->dev, "m_axi_aclk");
2207         if (IS_ERR(*dev_clk)) {
2208                 err = PTR_ERR(*dev_clk);
2209                 dev_err(&pdev->dev, "failed to get dev_clk (%u)\n", err);
2210                 return err;
2211         }
2212
2213         err = clk_prepare_enable(*axi_clk);
2214         if (err) {
2215                 dev_err(&pdev->dev, "failed to enable axi_clk (%u)\n", err);
2216                 return err;
2217         }
2218
2219         err = clk_prepare_enable(*dev_clk);
2220         if (err) {
2221                 dev_err(&pdev->dev, "failed to enable dev_clk (%u)\n", err);
2222                 goto err_disable_axiclk;
2223         }
2224
2225         return 0;
2226
2227 err_disable_axiclk:
2228         clk_disable_unprepare(*axi_clk);
2229
2230         return err;
2231 }
2232
2233 static int axivdma_clk_init(struct platform_device *pdev, struct clk **axi_clk,
2234                             struct clk **tx_clk, struct clk **txs_clk,
2235                             struct clk **rx_clk, struct clk **rxs_clk)
2236 {
2237         int err;
2238
2239         *axi_clk = devm_clk_get(&pdev->dev, "s_axi_lite_aclk");
2240         if (IS_ERR(*axi_clk)) {
2241                 err = PTR_ERR(*axi_clk);
2242                 dev_err(&pdev->dev, "failed to get axi_aclk (%u)\n", err);
2243                 return err;
2244         }
2245
2246         *tx_clk = devm_clk_get(&pdev->dev, "m_axi_mm2s_aclk");
2247         if (IS_ERR(*tx_clk))
2248                 *tx_clk = NULL;
2249
2250         *txs_clk = devm_clk_get(&pdev->dev, "m_axis_mm2s_aclk");
2251         if (IS_ERR(*txs_clk))
2252                 *txs_clk = NULL;
2253
2254         *rx_clk = devm_clk_get(&pdev->dev, "m_axi_s2mm_aclk");
2255         if (IS_ERR(*rx_clk))
2256                 *rx_clk = NULL;
2257
2258         *rxs_clk = devm_clk_get(&pdev->dev, "s_axis_s2mm_aclk");
2259         if (IS_ERR(*rxs_clk))
2260                 *rxs_clk = NULL;
2261
2262         err = clk_prepare_enable(*axi_clk);
2263         if (err) {
2264                 dev_err(&pdev->dev, "failed to enable axi_clk (%u)\n", err);
2265                 return err;
2266         }
2267
2268         err = clk_prepare_enable(*tx_clk);
2269         if (err) {
2270                 dev_err(&pdev->dev, "failed to enable tx_clk (%u)\n", err);
2271                 goto err_disable_axiclk;
2272         }
2273
2274         err = clk_prepare_enable(*txs_clk);
2275         if (err) {
2276                 dev_err(&pdev->dev, "failed to enable txs_clk (%u)\n", err);
2277                 goto err_disable_txclk;
2278         }
2279
2280         err = clk_prepare_enable(*rx_clk);
2281         if (err) {
2282                 dev_err(&pdev->dev, "failed to enable rx_clk (%u)\n", err);
2283                 goto err_disable_txsclk;
2284         }
2285
2286         err = clk_prepare_enable(*rxs_clk);
2287         if (err) {
2288                 dev_err(&pdev->dev, "failed to enable rxs_clk (%u)\n", err);
2289                 goto err_disable_rxclk;
2290         }
2291
2292         return 0;
2293
2294 err_disable_rxclk:
2295         clk_disable_unprepare(*rx_clk);
2296 err_disable_txsclk:
2297         clk_disable_unprepare(*txs_clk);
2298 err_disable_txclk:
2299         clk_disable_unprepare(*tx_clk);
2300 err_disable_axiclk:
2301         clk_disable_unprepare(*axi_clk);
2302
2303         return err;
2304 }
2305
2306 static void xdma_disable_allclks(struct xilinx_dma_device *xdev)
2307 {
2308         clk_disable_unprepare(xdev->rxs_clk);
2309         clk_disable_unprepare(xdev->rx_clk);
2310         clk_disable_unprepare(xdev->txs_clk);
2311         clk_disable_unprepare(xdev->tx_clk);
2312         clk_disable_unprepare(xdev->axi_clk);
2313 }
2314
2315 /**
2316  * xilinx_dma_chan_probe - Per Channel Probing
2317  * It get channel features from the device tree entry and
2318  * initialize special channel handling routines
2319  *
2320  * @xdev: Driver specific device structure
2321  * @node: Device node
2322  *
2323  * Return: '0' on success and failure value on error
2324  */
2325 static int xilinx_dma_chan_probe(struct xilinx_dma_device *xdev,
2326                                   struct device_node *node, int chan_id)
2327 {
2328         struct xilinx_dma_chan *chan;
2329         bool has_dre = false;
2330         u32 value, width;
2331         int err;
2332
2333         /* Allocate and initialize the channel structure */
2334         chan = devm_kzalloc(xdev->dev, sizeof(*chan), GFP_KERNEL);
2335         if (!chan)
2336                 return -ENOMEM;
2337
2338         chan->dev = xdev->dev;
2339         chan->xdev = xdev;
2340         chan->has_sg = xdev->has_sg;
2341         chan->desc_pendingcount = 0x0;
2342         chan->ext_addr = xdev->ext_addr;
2343
2344         spin_lock_init(&chan->lock);
2345         INIT_LIST_HEAD(&chan->pending_list);
2346         INIT_LIST_HEAD(&chan->done_list);
2347         INIT_LIST_HEAD(&chan->active_list);
2348
2349         /* Retrieve the channel properties from the device tree */
2350         has_dre = of_property_read_bool(node, "xlnx,include-dre");
2351
2352         chan->genlock = of_property_read_bool(node, "xlnx,genlock-mode");
2353
2354         err = of_property_read_u32(node, "xlnx,datawidth", &value);
2355         if (err) {
2356                 dev_err(xdev->dev, "missing xlnx,datawidth property\n");
2357                 return err;
2358         }
2359         width = value >> 3; /* Convert bits to bytes */
2360
2361         /* If data width is greater than 8 bytes, DRE is not in hw */
2362         if (width > 8)
2363                 has_dre = false;
2364
2365         if (!has_dre)
2366                 xdev->common.copy_align = fls(width - 1);
2367
2368         if (of_device_is_compatible(node, "xlnx,axi-vdma-mm2s-channel") ||
2369             of_device_is_compatible(node, "xlnx,axi-dma-mm2s-channel") ||
2370             of_device_is_compatible(node, "xlnx,axi-cdma-channel")) {
2371                 chan->direction = DMA_MEM_TO_DEV;
2372                 chan->id = chan_id;
2373                 chan->tdest = chan_id;
2374
2375                 chan->ctrl_offset = XILINX_DMA_MM2S_CTRL_OFFSET;
2376                 if (xdev->dma_config->dmatype == XDMA_TYPE_VDMA) {
2377                         chan->desc_offset = XILINX_VDMA_MM2S_DESC_OFFSET;
2378
2379                         if (xdev->flush_on_fsync == XILINX_DMA_FLUSH_BOTH ||
2380                             xdev->flush_on_fsync == XILINX_DMA_FLUSH_MM2S)
2381                                 chan->flush_on_fsync = true;
2382                 }
2383         } else if (of_device_is_compatible(node,
2384                                            "xlnx,axi-vdma-s2mm-channel") ||
2385                    of_device_is_compatible(node,
2386                                            "xlnx,axi-dma-s2mm-channel")) {
2387                 chan->direction = DMA_DEV_TO_MEM;
2388                 chan->id = chan_id;
2389                 chan->tdest = chan_id - xdev->nr_channels;
2390
2391                 chan->ctrl_offset = XILINX_DMA_S2MM_CTRL_OFFSET;
2392                 if (xdev->dma_config->dmatype == XDMA_TYPE_VDMA) {
2393                         chan->desc_offset = XILINX_VDMA_S2MM_DESC_OFFSET;
2394
2395                         if (xdev->flush_on_fsync == XILINX_DMA_FLUSH_BOTH ||
2396                             xdev->flush_on_fsync == XILINX_DMA_FLUSH_S2MM)
2397                                 chan->flush_on_fsync = true;
2398                 }
2399         } else {
2400                 dev_err(xdev->dev, "Invalid channel compatible node\n");
2401                 return -EINVAL;
2402         }
2403
2404         /* Request the interrupt */
2405         chan->irq = irq_of_parse_and_map(node, 0);
2406         err = request_irq(chan->irq, xilinx_dma_irq_handler, IRQF_SHARED,
2407                           "xilinx-dma-controller", chan);
2408         if (err) {
2409                 dev_err(xdev->dev, "unable to request IRQ %d\n", chan->irq);
2410                 return err;
2411         }
2412
2413         if (xdev->dma_config->dmatype == XDMA_TYPE_AXIDMA) {
2414                 chan->start_transfer = xilinx_dma_start_transfer;
2415                 chan->stop_transfer = xilinx_dma_stop_transfer;
2416         } else if (xdev->dma_config->dmatype == XDMA_TYPE_CDMA) {
2417                 chan->start_transfer = xilinx_cdma_start_transfer;
2418                 chan->stop_transfer = xilinx_cdma_stop_transfer;
2419         } else {
2420                 chan->start_transfer = xilinx_vdma_start_transfer;
2421                 chan->stop_transfer = xilinx_dma_stop_transfer;
2422         }
2423
2424         /* Initialize the tasklet */
2425         tasklet_init(&chan->tasklet, xilinx_dma_do_tasklet,
2426                         (unsigned long)chan);
2427
2428         /*
2429          * Initialize the DMA channel and add it to the DMA engine channels
2430          * list.
2431          */
2432         chan->common.device = &xdev->common;
2433
2434         list_add_tail(&chan->common.device_node, &xdev->common.channels);
2435         xdev->chan[chan->id] = chan;
2436
2437         /* Reset the channel */
2438         err = xilinx_dma_chan_reset(chan);
2439         if (err < 0) {
2440                 dev_err(xdev->dev, "Reset channel failed\n");
2441                 return err;
2442         }
2443
2444         return 0;
2445 }
2446
2447 /**
2448  * xilinx_dma_child_probe - Per child node probe
2449  * It get number of dma-channels per child node from
2450  * device-tree and initializes all the channels.
2451  *
2452  * @xdev: Driver specific device structure
2453  * @node: Device node
2454  *
2455  * Return: 0 always.
2456  */
2457 static int xilinx_dma_child_probe(struct xilinx_dma_device *xdev,
2458                                     struct device_node *node) {
2459         int ret, i, nr_channels = 1;
2460
2461         ret = of_property_read_u32(node, "dma-channels", &nr_channels);
2462         if ((ret < 0) && xdev->mcdma)
2463                 dev_warn(xdev->dev, "missing dma-channels property\n");
2464
2465         for (i = 0; i < nr_channels; i++)
2466                 xilinx_dma_chan_probe(xdev, node, xdev->chan_id++);
2467
2468         xdev->nr_channels += nr_channels;
2469
2470         return 0;
2471 }
2472
2473 /**
2474  * of_dma_xilinx_xlate - Translation function
2475  * @dma_spec: Pointer to DMA specifier as found in the device tree
2476  * @ofdma: Pointer to DMA controller data
2477  *
2478  * Return: DMA channel pointer on success and NULL on error
2479  */
2480 static struct dma_chan *of_dma_xilinx_xlate(struct of_phandle_args *dma_spec,
2481                                                 struct of_dma *ofdma)
2482 {
2483         struct xilinx_dma_device *xdev = ofdma->of_dma_data;
2484         int chan_id = dma_spec->args[0];
2485
2486         if (chan_id >= xdev->nr_channels || !xdev->chan[chan_id])
2487                 return NULL;
2488
2489         return dma_get_slave_channel(&xdev->chan[chan_id]->common);
2490 }
2491
2492 static const struct xilinx_dma_config axidma_config = {
2493         .dmatype = XDMA_TYPE_AXIDMA,
2494         .clk_init = axidma_clk_init,
2495 };
2496
2497 static const struct xilinx_dma_config axicdma_config = {
2498         .dmatype = XDMA_TYPE_CDMA,
2499         .clk_init = axicdma_clk_init,
2500 };
2501
2502 static const struct xilinx_dma_config axivdma_config = {
2503         .dmatype = XDMA_TYPE_VDMA,
2504         .clk_init = axivdma_clk_init,
2505 };
2506
2507 static const struct of_device_id xilinx_dma_of_ids[] = {
2508         { .compatible = "xlnx,axi-dma-1.00.a", .data = &axidma_config },
2509         { .compatible = "xlnx,axi-cdma-1.00.a", .data = &axicdma_config },
2510         { .compatible = "xlnx,axi-vdma-1.00.a", .data = &axivdma_config },
2511         {}
2512 };
2513 MODULE_DEVICE_TABLE(of, xilinx_dma_of_ids);
2514
2515 /**
2516  * xilinx_dma_probe - Driver probe function
2517  * @pdev: Pointer to the platform_device structure
2518  *
2519  * Return: '0' on success and failure value on error
2520  */
2521 static int xilinx_dma_probe(struct platform_device *pdev)
2522 {
2523         int (*clk_init)(struct platform_device *, struct clk **, struct clk **,
2524                         struct clk **, struct clk **, struct clk **)
2525                                         = axivdma_clk_init;
2526         struct device_node *node = pdev->dev.of_node;
2527         struct xilinx_dma_device *xdev;
2528         struct device_node *child, *np = pdev->dev.of_node;
2529         struct resource *io;
2530         u32 num_frames, addr_width;
2531         int i, err;
2532
2533         /* Allocate and initialize the DMA engine structure */
2534         xdev = devm_kzalloc(&pdev->dev, sizeof(*xdev), GFP_KERNEL);
2535         if (!xdev)
2536                 return -ENOMEM;
2537
2538         xdev->dev = &pdev->dev;
2539         if (np) {
2540                 const struct of_device_id *match;
2541
2542                 match = of_match_node(xilinx_dma_of_ids, np);
2543                 if (match && match->data) {
2544                         xdev->dma_config = match->data;
2545                         clk_init = xdev->dma_config->clk_init;
2546                 }
2547         }
2548
2549         err = clk_init(pdev, &xdev->axi_clk, &xdev->tx_clk, &xdev->txs_clk,
2550                        &xdev->rx_clk, &xdev->rxs_clk);
2551         if (err)
2552                 return err;
2553
2554         /* Request and map I/O memory */
2555         io = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2556         xdev->regs = devm_ioremap_resource(&pdev->dev, io);
2557         if (IS_ERR(xdev->regs))
2558                 return PTR_ERR(xdev->regs);
2559
2560         /* Retrieve the DMA engine properties from the device tree */
2561         xdev->has_sg = of_property_read_bool(node, "xlnx,include-sg");
2562         if (xdev->dma_config->dmatype == XDMA_TYPE_AXIDMA)
2563                 xdev->mcdma = of_property_read_bool(node, "xlnx,mcdma");
2564
2565         if (xdev->dma_config->dmatype == XDMA_TYPE_VDMA) {
2566                 err = of_property_read_u32(node, "xlnx,num-fstores",
2567                                            &num_frames);
2568                 if (err < 0) {
2569                         dev_err(xdev->dev,
2570                                 "missing xlnx,num-fstores property\n");
2571                         return err;
2572                 }
2573
2574                 err = of_property_read_u32(node, "xlnx,flush-fsync",
2575                                            &xdev->flush_on_fsync);
2576                 if (err < 0)
2577                         dev_warn(xdev->dev,
2578                                  "missing xlnx,flush-fsync property\n");
2579         }
2580
2581         err = of_property_read_u32(node, "xlnx,addrwidth", &addr_width);
2582         if (err < 0)
2583                 dev_warn(xdev->dev, "missing xlnx,addrwidth property\n");
2584
2585         if (addr_width > 32)
2586                 xdev->ext_addr = true;
2587         else
2588                 xdev->ext_addr = false;
2589
2590         /* Set the dma mask bits */
2591         dma_set_mask(xdev->dev, DMA_BIT_MASK(addr_width));
2592
2593         /* Initialize the DMA engine */
2594         xdev->common.dev = &pdev->dev;
2595
2596         INIT_LIST_HEAD(&xdev->common.channels);
2597         if (!(xdev->dma_config->dmatype == XDMA_TYPE_CDMA)) {
2598                 dma_cap_set(DMA_SLAVE, xdev->common.cap_mask);
2599                 dma_cap_set(DMA_PRIVATE, xdev->common.cap_mask);
2600         }
2601
2602         xdev->common.device_alloc_chan_resources =
2603                                 xilinx_dma_alloc_chan_resources;
2604         xdev->common.device_free_chan_resources =
2605                                 xilinx_dma_free_chan_resources;
2606         xdev->common.device_terminate_all = xilinx_dma_terminate_all;
2607         xdev->common.device_tx_status = xilinx_dma_tx_status;
2608         xdev->common.device_issue_pending = xilinx_dma_issue_pending;
2609         if (xdev->dma_config->dmatype == XDMA_TYPE_AXIDMA) {
2610                 dma_cap_set(DMA_CYCLIC, xdev->common.cap_mask);
2611                 xdev->common.device_prep_slave_sg = xilinx_dma_prep_slave_sg;
2612                 xdev->common.device_prep_dma_cyclic =
2613                                           xilinx_dma_prep_dma_cyclic;
2614                 xdev->common.device_prep_interleaved_dma =
2615                                         xilinx_dma_prep_interleaved;
2616                 /* Residue calculation is supported by only AXI DMA */
2617                 xdev->common.residue_granularity =
2618                                           DMA_RESIDUE_GRANULARITY_SEGMENT;
2619         } else if (xdev->dma_config->dmatype == XDMA_TYPE_CDMA) {
2620                 dma_cap_set(DMA_MEMCPY, xdev->common.cap_mask);
2621                 xdev->common.device_prep_dma_memcpy = xilinx_cdma_prep_memcpy;
2622         } else {
2623                 xdev->common.device_prep_interleaved_dma =
2624                                 xilinx_vdma_dma_prep_interleaved;
2625         }
2626
2627         platform_set_drvdata(pdev, xdev);
2628
2629         /* Initialize the channels */
2630         for_each_child_of_node(node, child) {
2631                 err = xilinx_dma_child_probe(xdev, child);
2632                 if (err < 0)
2633                         goto disable_clks;
2634         }
2635
2636         if (xdev->dma_config->dmatype == XDMA_TYPE_VDMA) {
2637                 for (i = 0; i < xdev->nr_channels; i++)
2638                         if (xdev->chan[i])
2639                                 xdev->chan[i]->num_frms = num_frames;
2640         }
2641
2642         /* Register the DMA engine with the core */
2643         dma_async_device_register(&xdev->common);
2644
2645         err = of_dma_controller_register(node, of_dma_xilinx_xlate,
2646                                          xdev);
2647         if (err < 0) {
2648                 dev_err(&pdev->dev, "Unable to register DMA to DT\n");
2649                 dma_async_device_unregister(&xdev->common);
2650                 goto error;
2651         }
2652
2653         dev_info(&pdev->dev, "Xilinx AXI VDMA Engine Driver Probed!!\n");
2654
2655         return 0;
2656
2657 disable_clks:
2658         xdma_disable_allclks(xdev);
2659 error:
2660         for (i = 0; i < xdev->nr_channels; i++)
2661                 if (xdev->chan[i])
2662                         xilinx_dma_chan_remove(xdev->chan[i]);
2663
2664         return err;
2665 }
2666
2667 /**
2668  * xilinx_dma_remove - Driver remove function
2669  * @pdev: Pointer to the platform_device structure
2670  *
2671  * Return: Always '0'
2672  */
2673 static int xilinx_dma_remove(struct platform_device *pdev)
2674 {
2675         struct xilinx_dma_device *xdev = platform_get_drvdata(pdev);
2676         int i;
2677
2678         of_dma_controller_free(pdev->dev.of_node);
2679
2680         dma_async_device_unregister(&xdev->common);
2681
2682         for (i = 0; i < xdev->nr_channels; i++)
2683                 if (xdev->chan[i])
2684                         xilinx_dma_chan_remove(xdev->chan[i]);
2685
2686         xdma_disable_allclks(xdev);
2687
2688         return 0;
2689 }
2690
2691 static struct platform_driver xilinx_vdma_driver = {
2692         .driver = {
2693                 .name = "xilinx-vdma",
2694                 .of_match_table = xilinx_dma_of_ids,
2695         },
2696         .probe = xilinx_dma_probe,
2697         .remove = xilinx_dma_remove,
2698 };
2699
2700 module_platform_driver(xilinx_vdma_driver);
2701
2702 MODULE_AUTHOR("Xilinx, Inc.");
2703 MODULE_DESCRIPTION("Xilinx VDMA driver");
2704 MODULE_LICENSE("GPL v2");