Quelle  k3-udma.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 *  Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com
 *  Author: Peter Ujfalusi <peter.ujfalusi@ti.com>
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/dmaengine.h>
#include <linux/dma-mapping.h>
#include <linux/dmapool.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/sys_soc.h>
#include <linux/of.h>
#include <linux/of_dma.h>
#include <linux/of_irq.h>
#include <linux/workqueue.h>
#include <linux/completion.h>
#include <linux/soc/ti/k3-ringacc.h>
#include <linux/soc/ti/ti_sci_protocol.h>
#include <linux/soc/ti/ti_sci_inta_msi.h>
#include <linux/dma/k3-event-router.h>
#include <linux/dma/ti-cppi5.h>

#include "../virt-dma.h"
#include "k3-udma.h"
#include "k3-psil-priv.h"

struct udma_static_tr {
 u8 elsize; /* RPSTR0 */
 u16 elcnt; /* RPSTR0 */
 u16 bstcnt; /* RPSTR1 */
};

#define K3_UDMA_MAX_RFLOWS  1024
#define K3_UDMA_DEFAULT_RING_SIZE 16

/* How SRC/DST tag should be updated by UDMA in the descriptor's Word 3 */
#define UDMA_RFLOW_SRCTAG_NONE  0
#define UDMA_RFLOW_SRCTAG_CFG_TAG 1
#define UDMA_RFLOW_SRCTAG_FLOW_ID 2
#define UDMA_RFLOW_SRCTAG_SRC_TAG 4

#define UDMA_RFLOW_DSTTAG_NONE  0
#define UDMA_RFLOW_DSTTAG_CFG_TAG 1
#define UDMA_RFLOW_DSTTAG_FLOW_ID 2
#define UDMA_RFLOW_DSTTAG_DST_TAG_LO 4
#define UDMA_RFLOW_DSTTAG_DST_TAG_HI 5

struct udma_chan;

enum k3_dma_type {
 DMA_TYPE_UDMA = 0,
 DMA_TYPE_BCDMA,
 DMA_TYPE_PKTDMA,
};

enum udma_mmr {
 MMR_GCFG = 0,
 MMR_BCHANRT,
 MMR_RCHANRT,
 MMR_TCHANRT,
 MMR_LAST,
};

static const char * const mmr_names[] = {
 [MMR_GCFG] = "gcfg",
 [MMR_BCHANRT] = "bchanrt",
 [MMR_RCHANRT] = "rchanrt",
 [MMR_TCHANRT] = "tchanrt",
};

struct udma_tchan {
 void __iomem *reg_rt;

 int id;
 struct k3_ring *t_ring; /* Transmit ring */
 struct k3_ring *tc_ring; /* Transmit Completion ring */
 int tflow_id; /* applicable only for PKTDMA */

};

#define udma_bchan udma_tchan

struct udma_rflow {
 int id;
 struct k3_ring *fd_ring; /* Free Descriptor ring */
 struct k3_ring *r_ring; /* Receive ring */
};

struct udma_rchan {
 void __iomem *reg_rt;

 int id;
};

struct udma_oes_offsets {
 /* K3 UDMA Output Event Offset */
 u32 udma_rchan;

 /* BCDMA Output Event Offsets */
 u32 bcdma_bchan_data;
 u32 bcdma_bchan_ring;
 u32 bcdma_tchan_data;
 u32 bcdma_tchan_ring;
 u32 bcdma_rchan_data;
 u32 bcdma_rchan_ring;

 /* PKTDMA Output Event Offsets */
 u32 pktdma_tchan_flow;
 u32 pktdma_rchan_flow;
};

#define UDMA_FLAG_PDMA_ACC32  BIT(0)
#define UDMA_FLAG_PDMA_BURST  BIT(1)
#define UDMA_FLAG_TDTYPE  BIT(2)
#define UDMA_FLAG_BURST_SIZE  BIT(3)
#define UDMA_FLAGS_J7_CLASS  (UDMA_FLAG_PDMA_ACC32 | \
      UDMA_FLAG_PDMA_BURST | \
      UDMA_FLAG_TDTYPE | \
      UDMA_FLAG_BURST_SIZE)

struct udma_match_data {
 enum k3_dma_type type;
 u32 psil_base;
 bool enable_memcpy_support;
 u32 flags;
 u32 statictr_z_mask;
 u8 burst_size[3];
 struct udma_soc_data *soc_data;
};

struct udma_soc_data {
 struct udma_oes_offsets oes;
 u32 bcdma_trigger_event_offset;
};

struct udma_hwdesc {
 size_t cppi5_desc_size;
 void *cppi5_desc_vaddr;
 dma_addr_t cppi5_desc_paddr;

 /* TR descriptor internal pointers */
 void *tr_req_base;
 struct cppi5_tr_resp_t *tr_resp_base;
};

struct udma_rx_flush {
 struct udma_hwdesc hwdescs[2];

 size_t buffer_size;
 void *buffer_vaddr;
 dma_addr_t buffer_paddr;
};

struct udma_tpl {
 u8 levels;
 u32 start_idx[3];
};

struct udma_dev {
 struct dma_device ddev;
 struct device *dev;
 void __iomem *mmrs[MMR_LAST];
 const struct udma_match_data *match_data;
 const struct udma_soc_data *soc_data;

 struct udma_tpl bchan_tpl;
 struct udma_tpl tchan_tpl;
 struct udma_tpl rchan_tpl;

 size_t desc_align; /* alignment to use for descriptors */

 struct udma_tisci_rm tisci_rm;

 struct k3_ringacc *ringacc;

 struct work_struct purge_work;
 struct list_head desc_to_purge;
 spinlock_t lock;

 struct udma_rx_flush rx_flush;

 int bchan_cnt;
 int tchan_cnt;
 int echan_cnt;
 int rchan_cnt;
 int rflow_cnt;
 int tflow_cnt;
 unsigned long *bchan_map;
 unsigned long *tchan_map;
 unsigned long *rchan_map;
 unsigned long *rflow_gp_map;
 unsigned long *rflow_gp_map_allocated;
 unsigned long *rflow_in_use;
 unsigned long *tflow_map;

 struct udma_bchan *bchans;
 struct udma_tchan *tchans;
 struct udma_rchan *rchans;
 struct udma_rflow *rflows;

 struct udma_chan *channels;
 u32 psil_base;
 u32 atype;
 u32 asel;
};

struct udma_desc {
 struct virt_dma_desc vd;

 bool terminated;

 enum dma_transfer_direction dir;

 struct udma_static_tr static_tr;
 u32 residue;

 unsigned int sglen;
 unsigned int desc_idx; /* Only used for cyclic in packet mode */
 unsigned int tr_idx;

 u32 metadata_size;
 void *metadata; /* pointer to provided metadata buffer (EPIP, PSdata) */

 unsigned int hwdesc_count;
 struct udma_hwdesc hwdesc[];
};

enum udma_chan_state {
 UDMA_CHAN_IS_IDLE = 0, /* not active, no teardown is in progress */
 UDMA_CHAN_IS_ACTIVE, /* Normal operation */
 UDMA_CHAN_IS_TERMINATING, /* channel is being terminated */
};

struct udma_tx_drain {
 struct delayed_work work;
 ktime_t tstamp;
 u32 residue;
};

struct udma_chan_config {
 bool pkt_mode; /* TR or packet */
 bool needs_epib; /* EPIB is needed for the communication or not */
 u32 psd_size; /* size of Protocol Specific Data */
 u32 metadata_size; /* (needs_epib ? 16:0) + psd_size */
 u32 hdesc_size; /* Size of a packet descriptor in packet mode */
 bool notdpkt; /* Suppress sending TDC packet */
 int remote_thread_id;
 u32 atype;
 u32 asel;
 u32 src_thread;
 u32 dst_thread;
 enum psil_endpoint_type ep_type;
 bool enable_acc32;
 bool enable_burst;
 enum udma_tp_level channel_tpl; /* Channel Throughput Level */

 u32 tr_trigger_type;
 unsigned long tx_flags;

 /* PKDMA mapped channel */
 int mapped_channel_id;
 /* PKTDMA default tflow or rflow for mapped channel */
 int default_flow_id;

 enum dma_transfer_direction dir;
};

struct udma_chan {
 struct virt_dma_chan vc;
 struct dma_slave_config cfg;
 struct udma_dev *ud;
 struct device *dma_dev;
 struct udma_desc *desc;
 struct udma_desc *terminated_desc;
 struct udma_static_tr static_tr;
 char *name;

 struct udma_bchan *bchan;
 struct udma_tchan *tchan;
 struct udma_rchan *rchan;
 struct udma_rflow *rflow;

 bool psil_paired;

 int irq_num_ring;
 int irq_num_udma;

 bool cyclic;
 bool paused;

 enum udma_chan_state state;
 struct completion teardown_completed;

 struct udma_tx_drain tx_drain;

 /* Channel configuration parameters */
 struct udma_chan_config config;
 /* Channel configuration parameters (backup) */
 struct udma_chan_config backup_config;

 /* dmapool for packet mode descriptors */
 bool use_dma_pool;
 struct dma_pool *hdesc_pool;

 u32 id;
};

static inline struct udma_dev *to_udma_dev(struct dma_device *d)
{
 return container_of(d, struct udma_dev, ddev);
}

static inline struct udma_chan *to_udma_chan(struct dma_chan *c)
{
 return container_of(c, struct udma_chan, vc.chan);
}

static inline struct udma_desc *to_udma_desc(struct dma_async_tx_descriptor *t)
{
 return container_of(t, struct udma_desc, vd.tx);
}

/* Generic register access functions */
static inline u32 udma_read(void __iomem *base, int reg)
{
 return readl(base + reg);
}

static inline void udma_write(void __iomem *base, int reg, u32 val)
{
 writel(val, base + reg);
}

static inline void udma_update_bits(void __iomem *base, int reg,
        u32 mask, u32 val)
{
 u32 tmp, orig;

 orig = readl(base + reg);
 tmp = orig & ~mask;
 tmp |= (val & mask);

 if (tmp != orig)
  writel(tmp, base + reg);
}

/* TCHANRT */
static inline u32 udma_tchanrt_read(struct udma_chan *uc, int reg)
{
 if (!uc->tchan)
  return 0;
 return udma_read(uc->tchan->reg_rt, reg);
}

static inline void udma_tchanrt_write(struct udma_chan *uc, int reg, u32 val)
{
 if (!uc->tchan)
  return;
 udma_write(uc->tchan->reg_rt, reg, val);
}

static inline void udma_tchanrt_update_bits(struct udma_chan *uc, int reg,
         u32 mask, u32 val)
{
 if (!uc->tchan)
  return;
 udma_update_bits(uc->tchan->reg_rt, reg, mask, val);
}

/* RCHANRT */
static inline u32 udma_rchanrt_read(struct udma_chan *uc, int reg)
{
 if (!uc->rchan)
  return 0;
 return udma_read(uc->rchan->reg_rt, reg);
}

static inline void udma_rchanrt_write(struct udma_chan *uc, int reg, u32 val)
{
 if (!uc->rchan)
  return;
 udma_write(uc->rchan->reg_rt, reg, val);
}

static inline void udma_rchanrt_update_bits(struct udma_chan *uc, int reg,
         u32 mask, u32 val)
{
 if (!uc->rchan)
  return;
 udma_update_bits(uc->rchan->reg_rt, reg, mask, val);
}

static int navss_psil_pair(struct udma_dev *ud, u32 src_thread, u32 dst_thread)
{
 struct udma_tisci_rm *tisci_rm = &ud->tisci_rm;

 dst_thread |= K3_PSIL_DST_THREAD_ID_OFFSET;
 return tisci_rm->tisci_psil_ops->pair(tisci_rm->tisci,
           tisci_rm->tisci_navss_dev_id,
           src_thread, dst_thread);
}

static int navss_psil_unpair(struct udma_dev *ud, u32 src_thread,
        u32 dst_thread)
{
 struct udma_tisci_rm *tisci_rm = &ud->tisci_rm;

 dst_thread |= K3_PSIL_DST_THREAD_ID_OFFSET;
 return tisci_rm->tisci_psil_ops->unpair(tisci_rm->tisci,
      tisci_rm->tisci_navss_dev_id,
      src_thread, dst_thread);
}

static void k3_configure_chan_coherency(struct dma_chan *chan, u32 asel)
{
 struct device *chan_dev = &chan->dev->device;

 if (asel == 0) {
  /* No special handling for the channel */
  chan->dev->chan_dma_dev = false;

  chan_dev->dma_coherent = false;
  chan_dev->dma_parms = NULL;
 } else if (asel == 14 || asel == 15) {
  chan->dev->chan_dma_dev = true;

  chan_dev->dma_coherent = true;
  dma_coerce_mask_and_coherent(chan_dev, DMA_BIT_MASK(48));
  chan_dev->dma_parms = chan_dev->parent->dma_parms;
 } else {
  dev_warn(chan->device->dev, "Invalid ASEL value: %u\n", asel);

  chan_dev->dma_coherent = false;
  chan_dev->dma_parms = NULL;
 }
}

static u8 udma_get_chan_tpl_index(struct udma_tpl *tpl_map, int chan_id)
{
 int i;

 for (i = 0; i < tpl_map->levels; i++) {
  if (chan_id >= tpl_map->start_idx[i])
   return i;
 }

 return 0;
}

static void udma_reset_uchan(struct udma_chan *uc)
{
 memset(&uc->config, 0, sizeof(uc->config));
 uc->config.remote_thread_id = -1;
 uc->config.mapped_channel_id = -1;
 uc->config.default_flow_id = -1;
 uc->state = UDMA_CHAN_IS_IDLE;
}

static void udma_dump_chan_stdata(struct udma_chan *uc)
{
 struct device *dev = uc->ud->dev;
 u32 offset;
 int i;

 if (uc->config.dir == DMA_MEM_TO_DEV || uc->config.dir == DMA_MEM_TO_MEM) {
  dev_dbg(dev, "TCHAN State data:\n");
  for (i = 0; i < 32; i++) {
   offset = UDMA_CHAN_RT_STDATA_REG + i * 4;
   dev_dbg(dev, "TRT_STDATA[%02d]: 0x%08x\n", i,
    udma_tchanrt_read(uc, offset));
  }
 }

 if (uc->config.dir == DMA_DEV_TO_MEM || uc->config.dir == DMA_MEM_TO_MEM) {
  dev_dbg(dev, "RCHAN State data:\n");
  for (i = 0; i < 32; i++) {
   offset = UDMA_CHAN_RT_STDATA_REG + i * 4;
   dev_dbg(dev, "RRT_STDATA[%02d]: 0x%08x\n", i,
    udma_rchanrt_read(uc, offset));
  }
 }
}

static inline dma_addr_t udma_curr_cppi5_desc_paddr(struct udma_desc *d,
          int idx)
{
 return d->hwdesc[idx].cppi5_desc_paddr;
}

static inline void *udma_curr_cppi5_desc_vaddr(struct udma_desc *d, int idx)
{
 return d->hwdesc[idx].cppi5_desc_vaddr;
}

static struct udma_desc *udma_udma_desc_from_paddr(struct udma_chan *uc,
         dma_addr_t paddr)
{
 struct udma_desc *d = uc->terminated_desc;

 if (d) {
  dma_addr_t desc_paddr = udma_curr_cppi5_desc_paddr(d,
           d->desc_idx);

  if (desc_paddr != paddr)
   d = NULL;
 }

 if (!d) {
  d = uc->desc;
  if (d) {
   dma_addr_t desc_paddr = udma_curr_cppi5_desc_paddr(d,
        d->desc_idx);

   if (desc_paddr != paddr)
    d = NULL;
  }
 }

 return d;
}

static void udma_free_hwdesc(struct udma_chan *uc, struct udma_desc *d)
{
 if (uc->use_dma_pool) {
  int i;

  for (i = 0; i < d->hwdesc_count; i++) {
   if (!d->hwdesc[i].cppi5_desc_vaddr)
    continue;

   dma_pool_free(uc->hdesc_pool,
          d->hwdesc[i].cppi5_desc_vaddr,
          d->hwdesc[i].cppi5_desc_paddr);

   d->hwdesc[i].cppi5_desc_vaddr = NULL;
  }
 } else if (d->hwdesc[0].cppi5_desc_vaddr) {
  dma_free_coherent(uc->dma_dev, d->hwdesc[0].cppi5_desc_size,
      d->hwdesc[0].cppi5_desc_vaddr,
      d->hwdesc[0].cppi5_desc_paddr);

  d->hwdesc[0].cppi5_desc_vaddr = NULL;
 }
}

static void udma_purge_desc_work(struct work_struct *work)
{
 struct udma_dev *ud = container_of(work, typeof(*ud), purge_work);
 struct virt_dma_desc *vd, *_vd;
 unsigned long flags;
 LIST_HEAD(head);

 spin_lock_irqsave(&ud->lock, flags);
 list_splice_tail_init(&ud->desc_to_purge, &head);
 spin_unlock_irqrestore(&ud->lock, flags);

 list_for_each_entry_safe(vd, _vd, &head, node) {
  struct udma_chan *uc = to_udma_chan(vd->tx.chan);
  struct udma_desc *d = to_udma_desc(&vd->tx);

  udma_free_hwdesc(uc, d);
  list_del(&vd->node);
  kfree(d);
 }

 /* If more to purge, schedule the work again */
 if (!list_empty(&ud->desc_to_purge))
  schedule_work(&ud->purge_work);
}

static void udma_desc_free(struct virt_dma_desc *vd)
{
 struct udma_dev *ud = to_udma_dev(vd->tx.chan->device);
 struct udma_chan *uc = to_udma_chan(vd->tx.chan);
 struct udma_desc *d = to_udma_desc(&vd->tx);
 unsigned long flags;

 if (uc->terminated_desc == d)
  uc->terminated_desc = NULL;

 if (uc->use_dma_pool) {
  udma_free_hwdesc(uc, d);
  kfree(d);
  return;
 }

 spin_lock_irqsave(&ud->lock, flags);
 list_add_tail(&vd->node, &ud->desc_to_purge);
 spin_unlock_irqrestore(&ud->lock, flags);

 schedule_work(&ud->purge_work);
}

static bool udma_is_chan_running(struct udma_chan *uc)
{
 u32 trt_ctl = 0;
 u32 rrt_ctl = 0;

 if (uc->tchan)
  trt_ctl = udma_tchanrt_read(uc, UDMA_CHAN_RT_CTL_REG);
 if (uc->rchan)
  rrt_ctl = udma_rchanrt_read(uc, UDMA_CHAN_RT_CTL_REG);

 if (trt_ctl & UDMA_CHAN_RT_CTL_EN || rrt_ctl & UDMA_CHAN_RT_CTL_EN)
  return true;

 return false;
}

static bool udma_is_chan_paused(struct udma_chan *uc)
{
 u32 val, pause_mask;

 switch (uc->config.dir) {
 case DMA_DEV_TO_MEM:
  val = udma_rchanrt_read(uc, UDMA_CHAN_RT_PEER_RT_EN_REG);
  pause_mask = UDMA_PEER_RT_EN_PAUSE;
  break;
 case DMA_MEM_TO_DEV:
  val = udma_tchanrt_read(uc, UDMA_CHAN_RT_PEER_RT_EN_REG);
  pause_mask = UDMA_PEER_RT_EN_PAUSE;
  break;
 case DMA_MEM_TO_MEM:
  val = udma_tchanrt_read(uc, UDMA_CHAN_RT_CTL_REG);
  pause_mask = UDMA_CHAN_RT_CTL_PAUSE;
  break;
 default:
  return false;
 }

 if (val & pause_mask)
  return true;

 return false;
}

static inline dma_addr_t udma_get_rx_flush_hwdesc_paddr(struct udma_chan *uc)
{
 return uc->ud->rx_flush.hwdescs[uc->config.pkt_mode].cppi5_desc_paddr;
}

static int udma_push_to_ring(struct udma_chan *uc, int idx)
{
 struct udma_desc *d = uc->desc;
 struct k3_ring *ring = NULL;
 dma_addr_t paddr;

 switch (uc->config.dir) {
 case DMA_DEV_TO_MEM:
  ring = uc->rflow->fd_ring;
  break;
 case DMA_MEM_TO_DEV:
 case DMA_MEM_TO_MEM:
  ring = uc->tchan->t_ring;
  break;
 default:
  return -EINVAL;
 }

 /* RX flush packet: idx == -1 is only passed in case of DEV_TO_MEM */
 if (idx == -1) {
  paddr = udma_get_rx_flush_hwdesc_paddr(uc);
 } else {
  paddr = udma_curr_cppi5_desc_paddr(d, idx);

  wmb(); /* Ensure that writes are not moved over this point */
 }

 return k3_ringacc_ring_push(ring, &paddr);
}

static bool udma_desc_is_rx_flush(struct udma_chan *uc, dma_addr_t addr)
{
 if (uc->config.dir != DMA_DEV_TO_MEM)
  return false;

 if (addr == udma_get_rx_flush_hwdesc_paddr(uc))
  return true;

 return false;
}

static int udma_pop_from_ring(struct udma_chan *uc, dma_addr_t *addr)
{
 struct k3_ring *ring = NULL;
 int ret;

 switch (uc->config.dir) {
 case DMA_DEV_TO_MEM:
  ring = uc->rflow->r_ring;
  break;
 case DMA_MEM_TO_DEV:
 case DMA_MEM_TO_MEM:
  ring = uc->tchan->tc_ring;
  break;
 default:
  return -ENOENT;
 }

 ret = k3_ringacc_ring_pop(ring, addr);
 if (ret)
  return ret;

 rmb(); /* Ensure that reads are not moved before this point */

 /* Teardown completion */
 if (cppi5_desc_is_tdcm(*addr))
  return 0;

 /* Check for flush descriptor */
 if (udma_desc_is_rx_flush(uc, *addr))
  return -ENOENT;

 return 0;
}

static void udma_reset_rings(struct udma_chan *uc)
{
 struct k3_ring *ring1 = NULL;
 struct k3_ring *ring2 = NULL;

 switch (uc->config.dir) {
 case DMA_DEV_TO_MEM:
  if (uc->rchan) {
   ring1 = uc->rflow->fd_ring;
   ring2 = uc->rflow->r_ring;
  }
  break;
 case DMA_MEM_TO_DEV:
 case DMA_MEM_TO_MEM:
  if (uc->tchan) {
   ring1 = uc->tchan->t_ring;
   ring2 = uc->tchan->tc_ring;
  }
  break;
 default:
  break;
 }

 if (ring1)
  k3_ringacc_ring_reset_dma(ring1,
       k3_ringacc_ring_get_occ(ring1));
 if (ring2)
  k3_ringacc_ring_reset(ring2);

 /* make sure we are not leaking memory by stalled descriptor */
 if (uc->terminated_desc) {
  udma_desc_free(&uc->terminated_desc->vd);
  uc->terminated_desc = NULL;
 }
}

static void udma_decrement_byte_counters(struct udma_chan *uc, u32 val)
{
 if (uc->desc->dir == DMA_DEV_TO_MEM) {
  udma_rchanrt_write(uc, UDMA_CHAN_RT_BCNT_REG, val);
  udma_rchanrt_write(uc, UDMA_CHAN_RT_SBCNT_REG, val);
  if (uc->config.ep_type != PSIL_EP_NATIVE)
   udma_rchanrt_write(uc, UDMA_CHAN_RT_PEER_BCNT_REG, val);
 } else {
  udma_tchanrt_write(uc, UDMA_CHAN_RT_BCNT_REG, val);
  udma_tchanrt_write(uc, UDMA_CHAN_RT_SBCNT_REG, val);
  if (!uc->bchan && uc->config.ep_type != PSIL_EP_NATIVE)
   udma_tchanrt_write(uc, UDMA_CHAN_RT_PEER_BCNT_REG, val);
 }
}

static void udma_reset_counters(struct udma_chan *uc)
{
 u32 val;

 if (uc->tchan) {
  val = udma_tchanrt_read(uc, UDMA_CHAN_RT_BCNT_REG);
  udma_tchanrt_write(uc, UDMA_CHAN_RT_BCNT_REG, val);

  val = udma_tchanrt_read(uc, UDMA_CHAN_RT_SBCNT_REG);
  udma_tchanrt_write(uc, UDMA_CHAN_RT_SBCNT_REG, val);

  val = udma_tchanrt_read(uc, UDMA_CHAN_RT_PCNT_REG);
  udma_tchanrt_write(uc, UDMA_CHAN_RT_PCNT_REG, val);

  if (!uc->bchan) {
   val = udma_tchanrt_read(uc, UDMA_CHAN_RT_PEER_BCNT_REG);
   udma_tchanrt_write(uc, UDMA_CHAN_RT_PEER_BCNT_REG, val);
  }
 }

 if (uc->rchan) {
  val = udma_rchanrt_read(uc, UDMA_CHAN_RT_BCNT_REG);
  udma_rchanrt_write(uc, UDMA_CHAN_RT_BCNT_REG, val);

  val = udma_rchanrt_read(uc, UDMA_CHAN_RT_SBCNT_REG);
  udma_rchanrt_write(uc, UDMA_CHAN_RT_SBCNT_REG, val);

  val = udma_rchanrt_read(uc, UDMA_CHAN_RT_PCNT_REG);
  udma_rchanrt_write(uc, UDMA_CHAN_RT_PCNT_REG, val);

  val = udma_rchanrt_read(uc, UDMA_CHAN_RT_PEER_BCNT_REG);
  udma_rchanrt_write(uc, UDMA_CHAN_RT_PEER_BCNT_REG, val);
 }
}

static int udma_reset_chan(struct udma_chan *uc, bool hard)
{
 switch (uc->config.dir) {
 case DMA_DEV_TO_MEM:
  udma_rchanrt_write(uc, UDMA_CHAN_RT_PEER_RT_EN_REG, 0);
  udma_rchanrt_write(uc, UDMA_CHAN_RT_CTL_REG, 0);
  break;
 case DMA_MEM_TO_DEV:
  udma_tchanrt_write(uc, UDMA_CHAN_RT_CTL_REG, 0);
  udma_tchanrt_write(uc, UDMA_CHAN_RT_PEER_RT_EN_REG, 0);
  break;
 case DMA_MEM_TO_MEM:
  udma_rchanrt_write(uc, UDMA_CHAN_RT_CTL_REG, 0);
  udma_tchanrt_write(uc, UDMA_CHAN_RT_CTL_REG, 0);
  break;
 default:
  return -EINVAL;
 }

 /* Reset all counters */
 udma_reset_counters(uc);

 /* Hard reset: re-initialize the channel to reset */
 if (hard) {
  struct udma_chan_config ucc_backup;
  int ret;

  memcpy(&ucc_backup, &uc->config, sizeof(uc->config));
  uc->ud->ddev.device_free_chan_resources(&uc->vc.chan);

  /* restore the channel configuration */
  memcpy(&uc->config, &ucc_backup, sizeof(uc->config));
  ret = uc->ud->ddev.device_alloc_chan_resources(&uc->vc.chan);
  if (ret)
   return ret;

  /*
 * Setting forced teardown after forced reset helps recovering
 * the rchan.
 */
  if (uc->config.dir == DMA_DEV_TO_MEM)
   udma_rchanrt_write(uc, UDMA_CHAN_RT_CTL_REG,
        UDMA_CHAN_RT_CTL_EN |
        UDMA_CHAN_RT_CTL_TDOWN |
        UDMA_CHAN_RT_CTL_FTDOWN);
 }
 uc->state = UDMA_CHAN_IS_IDLE;

 return 0;
}

static void udma_start_desc(struct udma_chan *uc)
{
 struct udma_chan_config *ucc = &uc->config;

 if (uc->ud->match_data->type == DMA_TYPE_UDMA && ucc->pkt_mode &&
     (uc->cyclic || ucc->dir == DMA_DEV_TO_MEM)) {
  int i;

  /*
 * UDMA only: Push all descriptors to ring for packet mode
 * cyclic or RX
 * PKTDMA supports pre-linked descriptor and cyclic is not
 * supported
 */
  for (i = 0; i < uc->desc->sglen; i++)
   udma_push_to_ring(uc, i);
 } else {
  udma_push_to_ring(uc, 0);
 }
}

static bool udma_chan_needs_reconfiguration(struct udma_chan *uc)
{
 /* Only PDMAs have staticTR */
 if (uc->config.ep_type == PSIL_EP_NATIVE)
  return false;

 /* Check if the staticTR configuration has changed for TX */
 if (memcmp(&uc->static_tr, &uc->desc->static_tr, sizeof(uc->static_tr)))
  return true;

 return false;
}

static int udma_start(struct udma_chan *uc)
{
 struct virt_dma_desc *vd = vchan_next_desc(&uc->vc);

 if (!vd) {
  uc->desc = NULL;
  return -ENOENT;
 }

 list_del(&vd->node);

 uc->desc = to_udma_desc(&vd->tx);

 /* Channel is already running and does not need reconfiguration */
 if (udma_is_chan_running(uc) && !udma_chan_needs_reconfiguration(uc)) {
  udma_start_desc(uc);
  goto out;
 }

 /* Make sure that we clear the teardown bit, if it is set */
 udma_reset_chan(uc, false);

 /* Push descriptors before we start the channel */
 udma_start_desc(uc);

 switch (uc->desc->dir) {
 case DMA_DEV_TO_MEM:
  /* Config remote TR */
  if (uc->config.ep_type == PSIL_EP_PDMA_XY) {
   u32 val = PDMA_STATIC_TR_Y(uc->desc->static_tr.elcnt) |
      PDMA_STATIC_TR_X(uc->desc->static_tr.elsize);
   const struct udma_match_data *match_data =
       uc->ud->match_data;

   if (uc->config.enable_acc32)
    val |= PDMA_STATIC_TR_XY_ACC32;
   if (uc->config.enable_burst)
    val |= PDMA_STATIC_TR_XY_BURST;

   udma_rchanrt_write(uc,
        UDMA_CHAN_RT_PEER_STATIC_TR_XY_REG,
        val);

   udma_rchanrt_write(uc,
    UDMA_CHAN_RT_PEER_STATIC_TR_Z_REG,
    PDMA_STATIC_TR_Z(uc->desc->static_tr.bstcnt,
       match_data->statictr_z_mask));

   /* save the current staticTR configuration */
   memcpy(&uc->static_tr, &uc->desc->static_tr,
          sizeof(uc->static_tr));
  }

  udma_rchanrt_write(uc, UDMA_CHAN_RT_CTL_REG,
       UDMA_CHAN_RT_CTL_EN);

  /* Enable remote */
  udma_rchanrt_write(uc, UDMA_CHAN_RT_PEER_RT_EN_REG,
       UDMA_PEER_RT_EN_ENABLE);

  break;
 case DMA_MEM_TO_DEV:
  /* Config remote TR */
  if (uc->config.ep_type == PSIL_EP_PDMA_XY) {
   u32 val = PDMA_STATIC_TR_Y(uc->desc->static_tr.elcnt) |
      PDMA_STATIC_TR_X(uc->desc->static_tr.elsize);

   if (uc->config.enable_acc32)
    val |= PDMA_STATIC_TR_XY_ACC32;
   if (uc->config.enable_burst)
    val |= PDMA_STATIC_TR_XY_BURST;

   udma_tchanrt_write(uc,
        UDMA_CHAN_RT_PEER_STATIC_TR_XY_REG,
        val);

   /* save the current staticTR configuration */
   memcpy(&uc->static_tr, &uc->desc->static_tr,
          sizeof(uc->static_tr));
  }

  /* Enable remote */
  udma_tchanrt_write(uc, UDMA_CHAN_RT_PEER_RT_EN_REG,
       UDMA_PEER_RT_EN_ENABLE);

  udma_tchanrt_write(uc, UDMA_CHAN_RT_CTL_REG,
       UDMA_CHAN_RT_CTL_EN);

  break;
 case DMA_MEM_TO_MEM:
  udma_rchanrt_write(uc, UDMA_CHAN_RT_CTL_REG,
       UDMA_CHAN_RT_CTL_EN);
  udma_tchanrt_write(uc, UDMA_CHAN_RT_CTL_REG,
       UDMA_CHAN_RT_CTL_EN);

  break;
 default:
  return -EINVAL;
 }

 uc->state = UDMA_CHAN_IS_ACTIVE;
out:

 return 0;
}

static int udma_stop(struct udma_chan *uc)
{
 enum udma_chan_state old_state = uc->state;

 uc->state = UDMA_CHAN_IS_TERMINATING;
 reinit_completion(&uc->teardown_completed);

 switch (uc->config.dir) {
 case DMA_DEV_TO_MEM:
  if (!uc->cyclic && !uc->desc)
   udma_push_to_ring(uc, -1);

  udma_rchanrt_write(uc, UDMA_CHAN_RT_PEER_RT_EN_REG,
       UDMA_PEER_RT_EN_ENABLE |
       UDMA_PEER_RT_EN_TEARDOWN);
  break;
 case DMA_MEM_TO_DEV:
  udma_tchanrt_write(uc, UDMA_CHAN_RT_PEER_RT_EN_REG,
       UDMA_PEER_RT_EN_ENABLE |
       UDMA_PEER_RT_EN_FLUSH);
  udma_tchanrt_write(uc, UDMA_CHAN_RT_CTL_REG,
       UDMA_CHAN_RT_CTL_EN |
       UDMA_CHAN_RT_CTL_TDOWN);
  break;
 case DMA_MEM_TO_MEM:
  udma_tchanrt_write(uc, UDMA_CHAN_RT_CTL_REG,
       UDMA_CHAN_RT_CTL_EN |
       UDMA_CHAN_RT_CTL_TDOWN);
  break;
 default:
  uc->state = old_state;
  complete_all(&uc->teardown_completed);
  return -EINVAL;
 }

 return 0;
}

static void udma_cyclic_packet_elapsed(struct udma_chan *uc)
{
 struct udma_desc *d = uc->desc;
 struct cppi5_host_desc_t *h_desc;

 h_desc = d->hwdesc[d->desc_idx].cppi5_desc_vaddr;
 cppi5_hdesc_reset_to_original(h_desc);
 udma_push_to_ring(uc, d->desc_idx);
 d->desc_idx = (d->desc_idx + 1) % d->sglen;
}

static inline void udma_fetch_epib(struct udma_chan *uc, struct udma_desc *d)
{
 struct cppi5_host_desc_t *h_desc = d->hwdesc[0].cppi5_desc_vaddr;

 memcpy(d->metadata, h_desc->epib, d->metadata_size);
}

static bool udma_is_desc_really_done(struct udma_chan *uc, struct udma_desc *d)
{
 u32 peer_bcnt, bcnt;

 /*
 * Only TX towards PDMA is affected.
 * If DMA_PREP_INTERRUPT is not set by consumer then skip the transfer
 * completion calculation, consumer must ensure that there is no stale
 * data in DMA fabric in this case.
 */
 if (uc->config.ep_type == PSIL_EP_NATIVE ||
     uc->config.dir != DMA_MEM_TO_DEV || !(uc->config.tx_flags & DMA_PREP_INTERRUPT))
  return true;

 peer_bcnt = udma_tchanrt_read(uc, UDMA_CHAN_RT_PEER_BCNT_REG);
 bcnt = udma_tchanrt_read(uc, UDMA_CHAN_RT_BCNT_REG);

 /* Transfer is incomplete, store current residue and time stamp */
 if (peer_bcnt < bcnt) {
  uc->tx_drain.residue = bcnt - peer_bcnt;
  uc->tx_drain.tstamp = ktime_get();
  return false;
 }

 return true;
}

static void udma_check_tx_completion(struct work_struct *work)
{
 struct udma_chan *uc = container_of(work, typeof(*uc),
         tx_drain.work.work);
 bool desc_done = true;
 u32 residue_diff;
 ktime_t time_diff;
 unsigned long delay;
 unsigned long flags;

 while (1) {
  spin_lock_irqsave(&uc->vc.lock, flags);

  if (uc->desc) {
   /* Get previous residue and time stamp */
   residue_diff = uc->tx_drain.residue;
   time_diff = uc->tx_drain.tstamp;
   /*
 * Get current residue and time stamp or see if
 * transfer is complete
 */
   desc_done = udma_is_desc_really_done(uc, uc->desc);
  }

  if (!desc_done) {
   /*
 * Find the time delta and residue delta w.r.t
 * previous poll
 */
   time_diff = ktime_sub(uc->tx_drain.tstamp,
           time_diff) + 1;
   residue_diff -= uc->tx_drain.residue;
   if (residue_diff) {
    /*
 * Try to guess when we should check
 * next time by calculating rate at
 * which data is being drained at the
 * peer device
 */
    delay = (time_diff / residue_diff) *
     uc->tx_drain.residue;
   } else {
    /* No progress, check again in 1 second  */
    schedule_delayed_work(&uc->tx_drain.work, HZ);
    break;
   }

   spin_unlock_irqrestore(&uc->vc.lock, flags);

   usleep_range(ktime_to_us(delay),
         ktime_to_us(delay) + 10);
   continue;
  }

  if (uc->desc) {
   struct udma_desc *d = uc->desc;

   udma_decrement_byte_counters(uc, d->residue);
   udma_start(uc);
   vchan_cookie_complete(&d->vd);
   break;
  }

  break;
 }

 spin_unlock_irqrestore(&uc->vc.lock, flags);
}

static irqreturn_t udma_ring_irq_handler(int irq, void *data)
{
 struct udma_chan *uc = data;
 struct udma_desc *d;
 dma_addr_t paddr = 0;

 if (udma_pop_from_ring(uc, &paddr) || !paddr)
  return IRQ_HANDLED;

 spin_lock(&uc->vc.lock);

 /* Teardown completion message */
 if (cppi5_desc_is_tdcm(paddr)) {
  complete_all(&uc->teardown_completed);

  if (uc->terminated_desc) {
   udma_desc_free(&uc->terminated_desc->vd);
   uc->terminated_desc = NULL;
  }

  if (!uc->desc)
   udma_start(uc);

  goto out;
 }

 d = udma_udma_desc_from_paddr(uc, paddr);

 if (d) {
  dma_addr_t desc_paddr = udma_curr_cppi5_desc_paddr(d,
           d->desc_idx);
  if (desc_paddr != paddr) {
   dev_err(uc->ud->dev, "not matching descriptors!\n");
   goto out;
  }

  if (d == uc->desc) {
   /* active descriptor */
   if (uc->cyclic) {
    udma_cyclic_packet_elapsed(uc);
    vchan_cyclic_callback(&d->vd);
   } else {
    if (udma_is_desc_really_done(uc, d)) {
     udma_decrement_byte_counters(uc, d->residue);
     udma_start(uc);
     vchan_cookie_complete(&d->vd);
    } else {
     schedule_delayed_work(&uc->tx_drain.work,
             0);
    }
   }
  } else {
   /*
 * terminated descriptor, mark the descriptor as
 * completed to update the channel's cookie marker
 */
   dma_cookie_complete(&d->vd.tx);
  }
 }
out:
 spin_unlock(&uc->vc.lock);

 return IRQ_HANDLED;
}

static irqreturn_t udma_udma_irq_handler(int irq, void *data)
{
 struct udma_chan *uc = data;
 struct udma_desc *d;

 spin_lock(&uc->vc.lock);
 d = uc->desc;
 if (d) {
  d->tr_idx = (d->tr_idx + 1) % d->sglen;

  if (uc->cyclic) {
   vchan_cyclic_callback(&d->vd);
  } else {
   /* TODO: figure out the real amount of data */
   udma_decrement_byte_counters(uc, d->residue);
   udma_start(uc);
   vchan_cookie_complete(&d->vd);
  }
 }

 spin_unlock(&uc->vc.lock);

 return IRQ_HANDLED;
}

/**
 * __udma_alloc_gp_rflow_range - alloc range of GP RX flows
 * @ud: UDMA device
 * @from: Start the search from this flow id number
 * @cnt: Number of consecutive flow ids to allocate
 *
 * Allocate range of RX flow ids for future use, those flows can be requested
 * only using explicit flow id number. if @from is set to -1 it will try to find
 * first free range. if @from is positive value it will force allocation only
 * of the specified range of flows.
 *
 * Returns -ENOMEM if can't find free range.
 * -EEXIST if requested range is busy.
 * -EINVAL if wrong input values passed.
 * Returns flow id on success.
 */
static int __udma_alloc_gp_rflow_range(struct udma_dev *ud, int from, int cnt)
{
 int start, tmp_from;
 DECLARE_BITMAP(tmp, K3_UDMA_MAX_RFLOWS);

 tmp_from = from;
 if (tmp_from < 0)
  tmp_from = ud->rchan_cnt;
 /* default flows can't be allocated and accessible only by id */
 if (tmp_from < ud->rchan_cnt)
  return -EINVAL;

 if (tmp_from + cnt > ud->rflow_cnt)
  return -EINVAL;

 bitmap_or(tmp, ud->rflow_gp_map, ud->rflow_gp_map_allocated,
    ud->rflow_cnt);

 start = bitmap_find_next_zero_area(tmp,
        ud->rflow_cnt,
        tmp_from, cnt, 0);
 if (start >= ud->rflow_cnt)
  return -ENOMEM;

 if (from >= 0 && start != from)
  return -EEXIST;

 bitmap_set(ud->rflow_gp_map_allocated, start, cnt);
 return start;
}

static int __udma_free_gp_rflow_range(struct udma_dev *ud, int from, int cnt)
{
 if (from < ud->rchan_cnt)
  return -EINVAL;
 if (from + cnt > ud->rflow_cnt)
  return -EINVAL;

 bitmap_clear(ud->rflow_gp_map_allocated, from, cnt);
 return 0;
}

static struct udma_rflow *__udma_get_rflow(struct udma_dev *ud, int id)
{
 /*
 * Attempt to request rflow by ID can be made for any rflow
 * if not in use with assumption that caller knows what's doing.
 * TI-SCI FW will perform additional permission check ant way, it's
 * safe
 */

 if (id < 0 || id >= ud->rflow_cnt)
  return ERR_PTR(-ENOENT);

 if (test_bit(id, ud->rflow_in_use))
  return ERR_PTR(-ENOENT);

 if (ud->rflow_gp_map) {
  /* GP rflow has to be allocated first */
  if (!test_bit(id, ud->rflow_gp_map) &&
      !test_bit(id, ud->rflow_gp_map_allocated))
   return ERR_PTR(-EINVAL);
 }

 dev_dbg(ud->dev, "get rflow%d\n", id);
 set_bit(id, ud->rflow_in_use);
 return &ud->rflows[id];
}

static void __udma_put_rflow(struct udma_dev *ud, struct udma_rflow *rflow)
{
 if (!test_bit(rflow->id, ud->rflow_in_use)) {
  dev_err(ud->dev, "attempt to put unused rflow%d\n", rflow->id);
  return;
 }

 dev_dbg(ud->dev, "put rflow%d\n", rflow->id);
 clear_bit(rflow->id, ud->rflow_in_use);
}

#define UDMA_RESERVE_RESOURCE(res)     \
static struct udma_##res *__udma_reserve_##res(struct udma_dev *ud, \
            enum udma_tp_level tpl, \
            int id)   \
{         \
 if (id >= 0) {       \
  if (test_bit(id, ud->res##_map)) {   \
   dev_err(ud->dev, "res##%d is in use\n", id); \
   return ERR_PTR(-ENOENT);   \
  }       \
 } else {       \
  int start;      \
         \
  if (tpl >= ud->res##_tpl.levels)   \
   tpl = ud->res##_tpl.levels - 1;   \
         \
  start = ud->res##_tpl.start_idx[tpl];   \
         \
  id = find_next_zero_bit(ud->res##_map, ud->res##_cnt, \
     start);    \
  if (id == ud->res##_cnt) {    \
   return ERR_PTR(-ENOENT);   \
  }       \
 }        \
         \
 set_bit(id, ud->res##_map);     \
 return &ud->res##s[id];      \
}

UDMA_RESERVE_RESOURCE(bchan);
UDMA_RESERVE_RESOURCE(tchan);
UDMA_RESERVE_RESOURCE(rchan);

static int bcdma_get_bchan(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;
 enum udma_tp_level tpl;
 int ret;

 if (uc->bchan) {
  dev_dbg(ud->dev, "chan%d: already have bchan%d allocated\n",
   uc->id, uc->bchan->id);
  return 0;
 }

 /*
 * Use normal channels for peripherals, and highest TPL channel for
 * mem2mem
 */
 if (uc->config.tr_trigger_type)
  tpl = 0;
 else
  tpl = ud->bchan_tpl.levels - 1;

 uc->bchan = __udma_reserve_bchan(ud, tpl, -1);
 if (IS_ERR(uc->bchan)) {
  ret = PTR_ERR(uc->bchan);
  uc->bchan = NULL;
  return ret;
 }

 uc->tchan = uc->bchan;

 return 0;
}

static int udma_get_tchan(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;
 int ret;

 if (uc->tchan) {
  dev_dbg(ud->dev, "chan%d: already have tchan%d allocated\n",
   uc->id, uc->tchan->id);
  return 0;
 }

 /*
 * mapped_channel_id is -1 for UDMA, BCDMA and PKTDMA unmapped channels.
 * For PKTDMA mapped channels it is configured to a channel which must
 * be used to service the peripheral.
 */
 uc->tchan = __udma_reserve_tchan(ud, uc->config.channel_tpl,
      uc->config.mapped_channel_id);
 if (IS_ERR(uc->tchan)) {
  ret = PTR_ERR(uc->tchan);
  uc->tchan = NULL;
  return ret;
 }

 if (ud->tflow_cnt) {
  int tflow_id;

  /* Only PKTDMA have support for tx flows */
  if (uc->config.default_flow_id >= 0)
   tflow_id = uc->config.default_flow_id;
  else
   tflow_id = uc->tchan->id;

  if (test_bit(tflow_id, ud->tflow_map)) {
   dev_err(ud->dev, "tflow%d is in use\n", tflow_id);
   clear_bit(uc->tchan->id, ud->tchan_map);
   uc->tchan = NULL;
   return -ENOENT;
  }

  uc->tchan->tflow_id = tflow_id;
  set_bit(tflow_id, ud->tflow_map);
 } else {
  uc->tchan->tflow_id = -1;
 }

 return 0;
}

static int udma_get_rchan(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;
 int ret;

 if (uc->rchan) {
  dev_dbg(ud->dev, "chan%d: already have rchan%d allocated\n",
   uc->id, uc->rchan->id);
  return 0;
 }

 /*
 * mapped_channel_id is -1 for UDMA, BCDMA and PKTDMA unmapped channels.
 * For PKTDMA mapped channels it is configured to a channel which must
 * be used to service the peripheral.
 */
 uc->rchan = __udma_reserve_rchan(ud, uc->config.channel_tpl,
      uc->config.mapped_channel_id);
 if (IS_ERR(uc->rchan)) {
  ret = PTR_ERR(uc->rchan);
  uc->rchan = NULL;
  return ret;
 }

 return 0;
}

static int udma_get_chan_pair(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;
 int chan_id, end;

 if ((uc->tchan && uc->rchan) && uc->tchan->id == uc->rchan->id) {
  dev_info(ud->dev, "chan%d: already have %d pair allocated\n",
    uc->id, uc->tchan->id);
  return 0;
 }

 if (uc->tchan) {
  dev_err(ud->dev, "chan%d: already have tchan%d allocated\n",
   uc->id, uc->tchan->id);
  return -EBUSY;
 } else if (uc->rchan) {
  dev_err(ud->dev, "chan%d: already have rchan%d allocated\n",
   uc->id, uc->rchan->id);
  return -EBUSY;
 }

 /* Can be optimized, but let's have it like this for now */
 end = min(ud->tchan_cnt, ud->rchan_cnt);
 /*
 * Try to use the highest TPL channel pair for MEM_TO_MEM channels
 * Note: in UDMAP the channel TPL is symmetric between tchan and rchan
 */
 chan_id = ud->tchan_tpl.start_idx[ud->tchan_tpl.levels - 1];
 for (; chan_id < end; chan_id++) {
  if (!test_bit(chan_id, ud->tchan_map) &&
      !test_bit(chan_id, ud->rchan_map))
   break;
 }

 if (chan_id == end)
  return -ENOENT;

 set_bit(chan_id, ud->tchan_map);
 set_bit(chan_id, ud->rchan_map);
 uc->tchan = &ud->tchans[chan_id];
 uc->rchan = &ud->rchans[chan_id];

 /* UDMA does not use tx flows */
 uc->tchan->tflow_id = -1;

 return 0;
}

static int udma_get_rflow(struct udma_chan *uc, int flow_id)
{
 struct udma_dev *ud = uc->ud;
 int ret;

 if (!uc->rchan) {
  dev_err(ud->dev, "chan%d: does not have rchan??\n", uc->id);
  return -EINVAL;
 }

 if (uc->rflow) {
  dev_dbg(ud->dev, "chan%d: already have rflow%d allocated\n",
   uc->id, uc->rflow->id);
  return 0;
 }

 uc->rflow = __udma_get_rflow(ud, flow_id);
 if (IS_ERR(uc->rflow)) {
  ret = PTR_ERR(uc->rflow);
  uc->rflow = NULL;
  return ret;
 }

 return 0;
}

static void bcdma_put_bchan(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;

 if (uc->bchan) {
  dev_dbg(ud->dev, "chan%d: put bchan%d\n", uc->id,
   uc->bchan->id);
  clear_bit(uc->bchan->id, ud->bchan_map);
  uc->bchan = NULL;
  uc->tchan = NULL;
 }
}

static void udma_put_rchan(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;

 if (uc->rchan) {
  dev_dbg(ud->dev, "chan%d: put rchan%d\n", uc->id,
   uc->rchan->id);
  clear_bit(uc->rchan->id, ud->rchan_map);
  uc->rchan = NULL;
 }
}

static void udma_put_tchan(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;

 if (uc->tchan) {
  dev_dbg(ud->dev, "chan%d: put tchan%d\n", uc->id,
   uc->tchan->id);
  clear_bit(uc->tchan->id, ud->tchan_map);

  if (uc->tchan->tflow_id >= 0)
   clear_bit(uc->tchan->tflow_id, ud->tflow_map);

  uc->tchan = NULL;
 }
}

static void udma_put_rflow(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;

 if (uc->rflow) {
  dev_dbg(ud->dev, "chan%d: put rflow%d\n", uc->id,
   uc->rflow->id);
  __udma_put_rflow(ud, uc->rflow);
  uc->rflow = NULL;
 }
}

static void bcdma_free_bchan_resources(struct udma_chan *uc)
{
 if (!uc->bchan)
  return;

 k3_ringacc_ring_free(uc->bchan->tc_ring);
 k3_ringacc_ring_free(uc->bchan->t_ring);
 uc->bchan->tc_ring = NULL;
 uc->bchan->t_ring = NULL;
 k3_configure_chan_coherency(&uc->vc.chan, 0);

 bcdma_put_bchan(uc);
}

static int bcdma_alloc_bchan_resources(struct udma_chan *uc)
{
 struct k3_ring_cfg ring_cfg;
 struct udma_dev *ud = uc->ud;
 int ret;

 ret = bcdma_get_bchan(uc);
 if (ret)
  return ret;

 ret = k3_ringacc_request_rings_pair(ud->ringacc, uc->bchan->id, -1,
         &uc->bchan->t_ring,
         &uc->bchan->tc_ring);
 if (ret) {
  ret = -EBUSY;
  goto err_ring;
 }

 memset(&ring_cfg, 0, sizeof(ring_cfg));
 ring_cfg.size = K3_UDMA_DEFAULT_RING_SIZE;
 ring_cfg.elm_size = K3_RINGACC_RING_ELSIZE_8;
 ring_cfg.mode = K3_RINGACC_RING_MODE_RING;

 k3_configure_chan_coherency(&uc->vc.chan, ud->asel);
 ring_cfg.asel = ud->asel;
 ring_cfg.dma_dev = dmaengine_get_dma_device(&uc->vc.chan);

 ret = k3_ringacc_ring_cfg(uc->bchan->t_ring, &ring_cfg);
 if (ret)
  goto err_ringcfg;

 return 0;

err_ringcfg:
 k3_ringacc_ring_free(uc->bchan->tc_ring);
 uc->bchan->tc_ring = NULL;
 k3_ringacc_ring_free(uc->bchan->t_ring);
 uc->bchan->t_ring = NULL;
 k3_configure_chan_coherency(&uc->vc.chan, 0);
err_ring:
 bcdma_put_bchan(uc);

 return ret;
}

static void udma_free_tx_resources(struct udma_chan *uc)
{
 if (!uc->tchan)
  return;

 k3_ringacc_ring_free(uc->tchan->t_ring);
 k3_ringacc_ring_free(uc->tchan->tc_ring);
 uc->tchan->t_ring = NULL;
 uc->tchan->tc_ring = NULL;

 udma_put_tchan(uc);
}

static int udma_alloc_tx_resources(struct udma_chan *uc)
{
 struct k3_ring_cfg ring_cfg;
 struct udma_dev *ud = uc->ud;
 struct udma_tchan *tchan;
 int ring_idx, ret;

 ret = udma_get_tchan(uc);
 if (ret)
  return ret;

 tchan = uc->tchan;
 if (tchan->tflow_id >= 0)
  ring_idx = tchan->tflow_id;
 else
  ring_idx = ud->bchan_cnt + tchan->id;

 ret = k3_ringacc_request_rings_pair(ud->ringacc, ring_idx, -1,
         &tchan->t_ring,
         &tchan->tc_ring);
 if (ret) {
  ret = -EBUSY;
  goto err_ring;
 }

 memset(&ring_cfg, 0, sizeof(ring_cfg));
 ring_cfg.size = K3_UDMA_DEFAULT_RING_SIZE;
 ring_cfg.elm_size = K3_RINGACC_RING_ELSIZE_8;
 if (ud->match_data->type == DMA_TYPE_UDMA) {
  ring_cfg.mode = K3_RINGACC_RING_MODE_MESSAGE;
 } else {
  ring_cfg.mode = K3_RINGACC_RING_MODE_RING;

  k3_configure_chan_coherency(&uc->vc.chan, uc->config.asel);
  ring_cfg.asel = uc->config.asel;
  ring_cfg.dma_dev = dmaengine_get_dma_device(&uc->vc.chan);
 }

 ret = k3_ringacc_ring_cfg(tchan->t_ring, &ring_cfg);
 ret |= k3_ringacc_ring_cfg(tchan->tc_ring, &ring_cfg);

 if (ret)
  goto err_ringcfg;

 return 0;

err_ringcfg:
 k3_ringacc_ring_free(uc->tchan->tc_ring);
 uc->tchan->tc_ring = NULL;
 k3_ringacc_ring_free(uc->tchan->t_ring);
 uc->tchan->t_ring = NULL;
err_ring:
 udma_put_tchan(uc);

 return ret;
}

static void udma_free_rx_resources(struct udma_chan *uc)
{
 if (!uc->rchan)
  return;

 if (uc->rflow) {
  struct udma_rflow *rflow = uc->rflow;

  k3_ringacc_ring_free(rflow->fd_ring);
  k3_ringacc_ring_free(rflow->r_ring);
  rflow->fd_ring = NULL;
  rflow->r_ring = NULL;

  udma_put_rflow(uc);
 }

 udma_put_rchan(uc);
}

static int udma_alloc_rx_resources(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;
 struct k3_ring_cfg ring_cfg;
 struct udma_rflow *rflow;
 int fd_ring_id;
 int ret;

 ret = udma_get_rchan(uc);
 if (ret)
  return ret;

 /* For MEM_TO_MEM we don't need rflow or rings */
 if (uc->config.dir == DMA_MEM_TO_MEM)
  return 0;

 if (uc->config.default_flow_id >= 0)
  ret = udma_get_rflow(uc, uc->config.default_flow_id);
 else
  ret = udma_get_rflow(uc, uc->rchan->id);

 if (ret) {
  ret = -EBUSY;
  goto err_rflow;
 }

 rflow = uc->rflow;
 if (ud->tflow_cnt)
  fd_ring_id = ud->tflow_cnt + rflow->id;
 else
  fd_ring_id = ud->bchan_cnt + ud->tchan_cnt + ud->echan_cnt +
        uc->rchan->id;

 ret = k3_ringacc_request_rings_pair(ud->ringacc, fd_ring_id, -1,
         &rflow->fd_ring, &rflow->r_ring);
 if (ret) {
  ret = -EBUSY;
  goto err_ring;
 }

 memset(&ring_cfg, 0, sizeof(ring_cfg));

 ring_cfg.elm_size = K3_RINGACC_RING_ELSIZE_8;
 if (ud->match_data->type == DMA_TYPE_UDMA) {
  if (uc->config.pkt_mode)
   ring_cfg.size = SG_MAX_SEGMENTS;
  else
   ring_cfg.size = K3_UDMA_DEFAULT_RING_SIZE;

  ring_cfg.mode = K3_RINGACC_RING_MODE_MESSAGE;
 } else {
  ring_cfg.size = K3_UDMA_DEFAULT_RING_SIZE;
  ring_cfg.mode = K3_RINGACC_RING_MODE_RING;

  k3_configure_chan_coherency(&uc->vc.chan, uc->config.asel);
  ring_cfg.asel = uc->config.asel;
  ring_cfg.dma_dev = dmaengine_get_dma_device(&uc->vc.chan);
 }

 ret = k3_ringacc_ring_cfg(rflow->fd_ring, &ring_cfg);

 ring_cfg.size = K3_UDMA_DEFAULT_RING_SIZE;
 ret |= k3_ringacc_ring_cfg(rflow->r_ring, &ring_cfg);

 if (ret)
  goto err_ringcfg;

 return 0;

err_ringcfg:
 k3_ringacc_ring_free(rflow->r_ring);
 rflow->r_ring = NULL;
 k3_ringacc_ring_free(rflow->fd_ring);
 rflow->fd_ring = NULL;
err_ring:
 udma_put_rflow(uc);
err_rflow:
 udma_put_rchan(uc);

 return ret;
}

#define TISCI_BCDMA_BCHAN_VALID_PARAMS (   \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_PAUSE_ON_ERR_VALID | \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_EXTENDED_CH_TYPE_VALID)

#define TISCI_BCDMA_TCHAN_VALID_PARAMS (   \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_PAUSE_ON_ERR_VALID | \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_TX_SUPR_TDPKT_VALID)

#define TISCI_BCDMA_RCHAN_VALID_PARAMS (   \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_PAUSE_ON_ERR_VALID)

#define TISCI_UDMA_TCHAN_VALID_PARAMS (    \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_PAUSE_ON_ERR_VALID | \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_TX_FILT_EINFO_VALID | \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_TX_FILT_PSWORDS_VALID | \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_CHAN_TYPE_VALID |  \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_TX_SUPR_TDPKT_VALID | \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_FETCH_SIZE_VALID |  \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_CQ_QNUM_VALID |  \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_ATYPE_VALID)

#define TISCI_UDMA_RCHAN_VALID_PARAMS (    \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_PAUSE_ON_ERR_VALID | \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_FETCH_SIZE_VALID |  \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_CQ_QNUM_VALID |  \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_CHAN_TYPE_VALID |  \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_RX_IGNORE_SHORT_VALID | \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_RX_IGNORE_LONG_VALID | \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_RX_FLOWID_START_VALID | \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_RX_FLOWID_CNT_VALID | \
 TI_SCI_MSG_VALUE_RM_UDMAP_CH_ATYPE_VALID)

static int udma_tisci_m2m_channel_config(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;
 struct udma_tisci_rm *tisci_rm = &ud->tisci_rm;
 const struct ti_sci_rm_udmap_ops *tisci_ops = tisci_rm->tisci_udmap_ops;
 struct udma_tchan *tchan = uc->tchan;
 struct udma_rchan *rchan = uc->rchan;
 u8 burst_size = 0;
 int ret;
 u8 tpl;

 /* Non synchronized - mem to mem type of transfer */
 int tc_ring = k3_ringacc_get_ring_id(tchan->tc_ring);
 struct ti_sci_msg_rm_udmap_tx_ch_cfg req_tx = { 0 };
 struct ti_sci_msg_rm_udmap_rx_ch_cfg req_rx = { 0 };

 if (ud->match_data->flags & UDMA_FLAG_BURST_SIZE) {
  tpl = udma_get_chan_tpl_index(&ud->tchan_tpl, tchan->id);

  burst_size = ud->match_data->burst_size[tpl];
 }

 req_tx.valid_params = TISCI_UDMA_TCHAN_VALID_PARAMS;
 req_tx.nav_id = tisci_rm->tisci_dev_id;
 req_tx.index = tchan->id;
 req_tx.tx_chan_type = TI_SCI_RM_UDMAP_CHAN_TYPE_3RDP_BCOPY_PBRR;
 req_tx.tx_fetch_size = sizeof(struct cppi5_desc_hdr_t) >> 2;
 req_tx.txcq_qnum = tc_ring;
 req_tx.tx_atype = ud->atype;
 if (burst_size) {
  req_tx.valid_params |= TI_SCI_MSG_VALUE_RM_UDMAP_CH_BURST_SIZE_VALID;
  req_tx.tx_burst_size = burst_size;
 }

 ret = tisci_ops->tx_ch_cfg(tisci_rm->tisci, &req_tx);
 if (ret) {
  dev_err(ud->dev, "tchan%d cfg failed %d\n", tchan->id, ret);
  return ret;
 }

 req_rx.valid_params = TISCI_UDMA_RCHAN_VALID_PARAMS;
 req_rx.nav_id = tisci_rm->tisci_dev_id;
 req_rx.index = rchan->id;
 req_rx.rx_fetch_size = sizeof(struct cppi5_desc_hdr_t) >> 2;
 req_rx.rxcq_qnum = tc_ring;
 req_rx.rx_chan_type = TI_SCI_RM_UDMAP_CHAN_TYPE_3RDP_BCOPY_PBRR;
 req_rx.rx_atype = ud->atype;
 if (burst_size) {
  req_rx.valid_params |= TI_SCI_MSG_VALUE_RM_UDMAP_CH_BURST_SIZE_VALID;
  req_rx.rx_burst_size = burst_size;
 }

 ret = tisci_ops->rx_ch_cfg(tisci_rm->tisci, &req_rx);
 if (ret)
  dev_err(ud->dev, "rchan%d alloc failed %d\n", rchan->id, ret);

 return ret;
}

static int bcdma_tisci_m2m_channel_config(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;
 struct udma_tisci_rm *tisci_rm = &ud->tisci_rm;
 const struct ti_sci_rm_udmap_ops *tisci_ops = tisci_rm->tisci_udmap_ops;
 struct ti_sci_msg_rm_udmap_tx_ch_cfg req_tx = { 0 };
 struct udma_bchan *bchan = uc->bchan;
 u8 burst_size = 0;
 int ret;
 u8 tpl;

 if (ud->match_data->flags & UDMA_FLAG_BURST_SIZE) {
  tpl = udma_get_chan_tpl_index(&ud->bchan_tpl, bchan->id);

  burst_size = ud->match_data->burst_size[tpl];
 }

 req_tx.valid_params = TISCI_BCDMA_BCHAN_VALID_PARAMS;
 req_tx.nav_id = tisci_rm->tisci_dev_id;
 req_tx.extended_ch_type = TI_SCI_RM_BCDMA_EXTENDED_CH_TYPE_BCHAN;
 req_tx.index = bchan->id;
 if (burst_size) {
  req_tx.valid_params |= TI_SCI_MSG_VALUE_RM_UDMAP_CH_BURST_SIZE_VALID;
  req_tx.tx_burst_size = burst_size;
 }

 ret = tisci_ops->tx_ch_cfg(tisci_rm->tisci, &req_tx);
 if (ret)
  dev_err(ud->dev, "bchan%d cfg failed %d\n", bchan->id, ret);

 return ret;
}

static int udma_tisci_tx_channel_config(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;
 struct udma_tisci_rm *tisci_rm = &ud->tisci_rm;
 const struct ti_sci_rm_udmap_ops *tisci_ops = tisci_rm->tisci_udmap_ops;
 struct udma_tchan *tchan = uc->tchan;
 int tc_ring = k3_ringacc_get_ring_id(tchan->tc_ring);
 struct ti_sci_msg_rm_udmap_tx_ch_cfg req_tx = { 0 };
 u32 mode, fetch_size;
 int ret;

 if (uc->config.pkt_mode) {
  mode = TI_SCI_RM_UDMAP_CHAN_TYPE_PKT_PBRR;
  fetch_size = cppi5_hdesc_calc_size(uc->config.needs_epib,
         uc->config.psd_size, 0);
 } else {
  mode = TI_SCI_RM_UDMAP_CHAN_TYPE_3RDP_PBRR;
  fetch_size = sizeof(struct cppi5_desc_hdr_t);
 }

 req_tx.valid_params = TISCI_UDMA_TCHAN_VALID_PARAMS;
 req_tx.nav_id = tisci_rm->tisci_dev_id;
 req_tx.index = tchan->id;
 req_tx.tx_chan_type = mode;
 req_tx.tx_supr_tdpkt = uc->config.notdpkt;
 req_tx.tx_fetch_size = fetch_size >> 2;
 req_tx.txcq_qnum = tc_ring;
 req_tx.tx_atype = uc->config.atype;
 if (uc->config.ep_type == PSIL_EP_PDMA_XY &&
     ud->match_data->flags & UDMA_FLAG_TDTYPE) {
  /* wait for peer to complete the teardown for PDMAs */
  req_tx.valid_params |=
    TI_SCI_MSG_VALUE_RM_UDMAP_CH_TX_TDTYPE_VALID;
  req_tx.tx_tdtype = 1;
 }

 ret = tisci_ops->tx_ch_cfg(tisci_rm->tisci, &req_tx);
 if (ret)
  dev_err(ud->dev, "tchan%d cfg failed %d\n", tchan->id, ret);

 return ret;
}

static int bcdma_tisci_tx_channel_config(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;
 struct udma_tisci_rm *tisci_rm = &ud->tisci_rm;
 const struct ti_sci_rm_udmap_ops *tisci_ops = tisci_rm->tisci_udmap_ops;
 struct udma_tchan *tchan = uc->tchan;
 struct ti_sci_msg_rm_udmap_tx_ch_cfg req_tx = { 0 };
 int ret;

 req_tx.valid_params = TISCI_BCDMA_TCHAN_VALID_PARAMS;
 req_tx.nav_id = tisci_rm->tisci_dev_id;
 req_tx.index = tchan->id;
 req_tx.tx_supr_tdpkt = uc->config.notdpkt;
 if (ud->match_data->flags & UDMA_FLAG_TDTYPE) {
  /* wait for peer to complete the teardown for PDMAs */
  req_tx.valid_params |=
    TI_SCI_MSG_VALUE_RM_UDMAP_CH_TX_TDTYPE_VALID;
  req_tx.tx_tdtype = 1;
 }

 ret = tisci_ops->tx_ch_cfg(tisci_rm->tisci, &req_tx);
 if (ret)
  dev_err(ud->dev, "tchan%d cfg failed %d\n", tchan->id, ret);

 return ret;
}

#define pktdma_tisci_tx_channel_config bcdma_tisci_tx_channel_config

static int udma_tisci_rx_channel_config(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;
 struct udma_tisci_rm *tisci_rm = &ud->tisci_rm;
 const struct ti_sci_rm_udmap_ops *tisci_ops = tisci_rm->tisci_udmap_ops;
 struct udma_rchan *rchan = uc->rchan;
 int fd_ring = k3_ringacc_get_ring_id(uc->rflow->fd_ring);
 int rx_ring = k3_ringacc_get_ring_id(uc->rflow->r_ring);
 struct ti_sci_msg_rm_udmap_rx_ch_cfg req_rx = { 0 };
 struct ti_sci_msg_rm_udmap_flow_cfg flow_req = { 0 };
 u32 mode, fetch_size;
 int ret;

 if (uc->config.pkt_mode) {
  mode = TI_SCI_RM_UDMAP_CHAN_TYPE_PKT_PBRR;
  fetch_size = cppi5_hdesc_calc_size(uc->config.needs_epib,
         uc->config.psd_size, 0);
 } else {
  mode = TI_SCI_RM_UDMAP_CHAN_TYPE_3RDP_PBRR;
  fetch_size = sizeof(struct cppi5_desc_hdr_t);
 }

 req_rx.valid_params = TISCI_UDMA_RCHAN_VALID_PARAMS;
 req_rx.nav_id = tisci_rm->tisci_dev_id;
 req_rx.index = rchan->id;
 req_rx.rx_fetch_size =  fetch_size >> 2;
 req_rx.rxcq_qnum = rx_ring;
 req_rx.rx_chan_type = mode;
 req_rx.rx_atype = uc->config.atype;

 ret = tisci_ops->rx_ch_cfg(tisci_rm->tisci, &req_rx);
 if (ret) {
  dev_err(ud->dev, "rchan%d cfg failed %d\n", rchan->id, ret);
  return ret;
 }

 flow_req.valid_params =
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_EINFO_PRESENT_VALID |
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_PSINFO_PRESENT_VALID |
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_ERROR_HANDLING_VALID |
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_DESC_TYPE_VALID |
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_DEST_QNUM_VALID |
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_SRC_TAG_HI_SEL_VALID |
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_SRC_TAG_LO_SEL_VALID |
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_DEST_TAG_HI_SEL_VALID |
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_DEST_TAG_LO_SEL_VALID |
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_FDQ0_SZ0_QNUM_VALID |
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_FDQ1_QNUM_VALID |
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_FDQ2_QNUM_VALID |
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_FDQ3_QNUM_VALID;

 flow_req.nav_id = tisci_rm->tisci_dev_id;
 flow_req.flow_index = rchan->id;

 if (uc->config.needs_epib)
  flow_req.rx_einfo_present = 1;
 else
  flow_req.rx_einfo_present = 0;
 if (uc->config.psd_size)
  flow_req.rx_psinfo_present = 1;
 else
  flow_req.rx_psinfo_present = 0;
 flow_req.rx_error_handling = 1;
 flow_req.rx_dest_qnum = rx_ring;
 flow_req.rx_src_tag_hi_sel = UDMA_RFLOW_SRCTAG_NONE;
 flow_req.rx_src_tag_lo_sel = UDMA_RFLOW_SRCTAG_SRC_TAG;
 flow_req.rx_dest_tag_hi_sel = UDMA_RFLOW_DSTTAG_DST_TAG_HI;
 flow_req.rx_dest_tag_lo_sel = UDMA_RFLOW_DSTTAG_DST_TAG_LO;
 flow_req.rx_fdq0_sz0_qnum = fd_ring;
 flow_req.rx_fdq1_qnum = fd_ring;
 flow_req.rx_fdq2_qnum = fd_ring;
 flow_req.rx_fdq3_qnum = fd_ring;

 ret = tisci_ops->rx_flow_cfg(tisci_rm->tisci, &flow_req);

 if (ret)
  dev_err(ud->dev, "flow%d config failed: %d\n", rchan->id, ret);

 return 0;
}

static int bcdma_tisci_rx_channel_config(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;
 struct udma_tisci_rm *tisci_rm = &ud->tisci_rm;
 const struct ti_sci_rm_udmap_ops *tisci_ops = tisci_rm->tisci_udmap_ops;
 struct udma_rchan *rchan = uc->rchan;
 struct ti_sci_msg_rm_udmap_rx_ch_cfg req_rx = { 0 };
 int ret;

 req_rx.valid_params = TISCI_BCDMA_RCHAN_VALID_PARAMS;
 req_rx.nav_id = tisci_rm->tisci_dev_id;
 req_rx.index = rchan->id;

 ret = tisci_ops->rx_ch_cfg(tisci_rm->tisci, &req_rx);
 if (ret)
  dev_err(ud->dev, "rchan%d cfg failed %d\n", rchan->id, ret);

 return ret;
}

static int pktdma_tisci_rx_channel_config(struct udma_chan *uc)
{
 struct udma_dev *ud = uc->ud;
 struct udma_tisci_rm *tisci_rm = &ud->tisci_rm;
 const struct ti_sci_rm_udmap_ops *tisci_ops = tisci_rm->tisci_udmap_ops;
 struct ti_sci_msg_rm_udmap_rx_ch_cfg req_rx = { 0 };
 struct ti_sci_msg_rm_udmap_flow_cfg flow_req = { 0 };
 int ret;

 req_rx.valid_params = TISCI_BCDMA_RCHAN_VALID_PARAMS;
 req_rx.nav_id = tisci_rm->tisci_dev_id;
 req_rx.index = uc->rchan->id;

 ret = tisci_ops->rx_ch_cfg(tisci_rm->tisci, &req_rx);
 if (ret) {
  dev_err(ud->dev, "rchan%d cfg failed %d\n", uc->rchan->id, ret);
  return ret;
 }

 flow_req.valid_params =
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_EINFO_PRESENT_VALID |
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_PSINFO_PRESENT_VALID |
  TI_SCI_MSG_VALUE_RM_UDMAP_FLOW_ERROR_HANDLING_VALID;

 flow_req.nav_id = tisci_rm->tisci_dev_id;
 flow_req.flow_index = uc->rflow->id;

 if (uc->config.needs_epib)
  flow_req.rx_einfo_present = 1;
 else
  flow_req.rx_einfo_present = 0;
 if (uc->config.psd_size)
  flow_req.rx_psinfo_present = 1;
 else
  flow_req.rx_psinfo_present = 0;
 flow_req.rx_error_handling = 1;

 ret = tisci_ops->rx_flow_cfg(tisci_rm->tisci, &flow_req);

 if (ret)
  dev_err(ud->dev, "flow%d config failed: %d\n", uc->rflow->id,
   ret);

 return ret;
}

static int udma_alloc_chan_resources(struct dma_chan *chan)
{
 struct udma_chan *uc = to_udma_chan(chan);
 struct udma_dev *ud = to_udma_dev(chan->device);
 const struct udma_soc_data *soc_data = ud->soc_data;
 struct k3_ring *irq_ring;
 u32 irq_udma_idx;
 int ret;

 uc->dma_dev = ud->dev;

 if (uc->config.pkt_mode || uc->config.dir == DMA_MEM_TO_MEM) {
  uc->use_dma_pool = true;
  /* in case of MEM_TO_MEM we have maximum of two TRs */
  if (uc->config.dir == DMA_MEM_TO_MEM) {
   uc->config.hdesc_size = cppi5_trdesc_calc_size(
     sizeof(struct cppi5_tr_type15_t), 2);
   uc->config.pkt_mode = false;
  }
 }

 if (uc->use_dma_pool) {
  uc->hdesc_pool = dma_pool_create(uc->name, ud->ddev.dev,
       uc->config.hdesc_size,
       ud->desc_align,
       0);
  if (!uc->hdesc_pool) {
   dev_err(ud->ddev.dev,
    "Descriptor pool allocation failed\n");
   uc->use_dma_pool = false;
   ret = -ENOMEM;
   goto err_cleanup;
  }
 }

 /*
 * Make sure that the completion is in a known state:
 * No teardown, the channel is idle
 */
 reinit_completion(&uc->teardown_completed);
 complete_all(&uc->teardown_completed);
 uc->state = UDMA_CHAN_IS_IDLE;

 switch (uc->config.dir) {
 case DMA_MEM_TO_MEM:
  /* Non synchronized - mem to mem type of transfer */
  dev_dbg(uc->ud->dev, "%s: chan%d as MEM-to-MEM\n", __func__,
   uc->id);

  ret = udma_get_chan_pair(uc);
  if (ret)
   goto err_cleanup;

  ret = udma_alloc_tx_resources(uc);
  if (ret) {
   udma_put_rchan(uc);
   goto err_cleanup;
  }

  ret = udma_alloc_rx_resources(uc);
  if (ret) {
   udma_free_tx_resources(uc);
   goto err_cleanup;
  }

  uc->config.src_thread = ud->psil_base + uc->tchan->id;
  uc->config.dst_thread = (ud->psil_base + uc->rchan->id) |
     K3_PSIL_DST_THREAD_ID_OFFSET;

  irq_ring = uc->tchan->tc_ring;
  irq_udma_idx = uc->tchan->id;

  ret = udma_tisci_m2m_channel_config(uc);
  break;
 case DMA_MEM_TO_DEV:
  /* Slave transfer synchronized - mem to dev (TX) trasnfer */
  dev_dbg(uc->ud->dev, "%s: chan%d as MEM-to-DEV\n", __func__,
   uc->id);

  ret = udma_alloc_tx_resources(uc);
  if (ret)
   goto err_cleanup;

  uc->config.src_thread = ud->psil_base + uc->tchan->id;
  uc->config.dst_thread = uc->config.remote_thread_id;
  uc->config.dst_thread |= K3_PSIL_DST_THREAD_ID_OFFSET;

  irq_ring = uc->tchan->tc_ring;
  irq_udma_idx = uc->tchan->id;

  ret = udma_tisci_tx_channel_config(uc);
  break;
 case DMA_DEV_TO_MEM:
  /* Slave transfer synchronized - dev to mem (RX) trasnfer */
  dev_dbg(uc->ud->dev, "%s: chan%d as DEV-to-MEM\n", __func__,
   uc->id);

  ret = udma_alloc_rx_resources(uc);
  if (ret)
   goto err_cleanup;

  uc->config.src_thread = uc->config.remote_thread_id;
  uc->config.dst_thread = (ud->psil_base + uc->rchan->id) |
     K3_PSIL_DST_THREAD_ID_OFFSET;

  irq_ring = uc->rflow->r_ring;
  irq_udma_idx = soc_data->oes.udma_rchan + uc->rchan->id;

  ret = udma_tisci_rx_channel_config(uc);
  break;
 default:
  /* Can not happen */
  dev_err(uc->ud->dev, "%s: chan%d invalid direction (%u)\n",
   __func__, uc->id, uc->config.dir);
  ret = -EINVAL;
  goto err_cleanup;

 }

 /* check if the channel configuration was successful */
 if (ret)
  goto err_res_free;

 if (udma_is_chan_running(uc)) {
  dev_warn(ud->dev, "chan%d: is running!\n", uc->id);
  udma_reset_chan(uc, false);
  if (udma_is_chan_running(uc)) {
   dev_err(ud->dev, "chan%d: won't stop!\n", uc->id);
   ret = -EBUSY;
   goto err_res_free;
  }
 }

 /* PSI-L pairing */
 ret = navss_psil_pair(ud, uc->config.src_thread, uc->config.dst_thread);
 if (ret) {
  dev_err(ud->dev, "PSI-L pairing failed: 0x%04x -> 0x%04x\n",
   uc->config.src_thread, uc->config.dst_thread);
  goto err_res_free;
 }

 uc->psil_paired = true;

 uc->irq_num_ring = k3_ringacc_get_ring_irq_num(irq_ring);
 if (uc->irq_num_ring <= 0) {
  dev_err(ud->dev, "Failed to get ring irq (index: %u)\n",
   k3_ringacc_get_ring_id(irq_ring));
  ret = -EINVAL;
  goto err_psi_free;
 }

 ret = request_irq(uc->irq_num_ring, udma_ring_irq_handler,
     IRQF_TRIGGER_HIGH, uc->name, uc);
 if (ret) {
  dev_err(ud->dev, "chan%d: ring irq request failed\n", uc->id);
  goto err_irq_free;
 }

 /* Event from UDMA (TR events) only needed for slave TR mode channels */
 if (is_slave_direction(uc->config.dir) && !uc->config.pkt_mode) {
  uc->irq_num_udma = msi_get_virq(ud->dev, irq_udma_idx);
  if (uc->irq_num_udma <= 0) {
   dev_err(ud->dev, "Failed to get udma irq (index: %u)\n",
    irq_udma_idx);
   free_irq(uc->irq_num_ring, uc);
   ret = -EINVAL;
   goto err_irq_free;
  }

  ret = request_irq(uc->irq_num_udma, udma_udma_irq_handler, 0,
      uc->name, uc);
  if (ret) {
   dev_err(ud->dev, "chan%d: UDMA irq request failed\n",
    uc->id);
   free_irq(uc->irq_num_ring, uc);
   goto err_irq_free;
  }
 } else {
  uc->irq_num_udma = 0;
 }

 udma_reset_rings(uc);

 return 0;

err_irq_free:
 uc->irq_num_ring = 0;
 uc->irq_num_udma = 0;
err_psi_free:
 navss_psil_unpair(ud, uc->config.src_thread, uc->config.dst_thread);
 uc->psil_paired = false;
err_res_free:
 udma_free_tx_resources(uc);
 udma_free_rx_resources(uc);
err_cleanup:
 udma_reset_uchan(uc);

 if (uc->use_dma_pool) {
  dma_pool_destroy(uc->hdesc_pool);
  uc->use_dma_pool = false;
 }

 return ret;
}

static int bcdma_alloc_chan_resources(struct dma_chan *chan)
{
 struct udma_chan *uc = to_udma_chan(chan);
 struct udma_dev *ud = to_udma_dev(chan->device);
 const struct udma_oes_offsets *oes = &ud->soc_data->oes;
 u32 irq_udma_idx, irq_ring_idx;
 int ret;

 /* Only TR mode is supported */
 uc->config.pkt_mode = false;

 /*
 * Make sure that the completion is in a known state:
 * No teardown, the channel is idle
 */
 reinit_completion(&uc->teardown_completed);
 complete_all(&uc->teardown_completed);
 uc->state = UDMA_CHAN_IS_IDLE;

 switch (uc->config.dir) {
 case DMA_MEM_TO_MEM:
  /* Non synchronized - mem to mem type of transfer */
  dev_dbg(uc->ud->dev, "%s: chan%d as MEM-to-MEM\n", __func__,
   uc->id);

  ret = bcdma_alloc_bchan_resources(uc);
  if (ret)
   return ret;

  irq_ring_idx = uc->bchan->id + oes->bcdma_bchan_ring;
  irq_udma_idx = uc->bchan->id + oes->bcdma_bchan_data;

  ret = bcdma_tisci_m2m_channel_config(uc);
  break;
 case DMA_MEM_TO_DEV:
  /* Slave transfer synchronized - mem to dev (TX) trasnfer */
  dev_dbg(uc->ud->dev, "%s: chan%d as MEM-to-DEV\n", __func__,
   uc->id);

  ret = udma_alloc_tx_resources(uc);
  if (ret) {
   uc->config.remote_thread_id = -1;
   return ret;
  }

  uc->config.src_thread = ud->psil_base + uc->tchan->id;
  uc->config.dst_thread = uc->config.remote_thread_id;
  uc->config.dst_thread |= K3_PSIL_DST_THREAD_ID_OFFSET;

  irq_ring_idx = uc->tchan->id + oes->bcdma_tchan_ring;
  irq_udma_idx = uc->tchan->id + oes->bcdma_tchan_data;

  ret = bcdma_tisci_tx_channel_config(uc);
  break;
 case DMA_DEV_TO_MEM:
  /* Slave transfer synchronized - dev to mem (RX) trasnfer */
  dev_dbg(uc->ud->dev, "%s: chan%d as DEV-to-MEM\n", __func__,
   uc->id);

  ret = udma_alloc_rx_resources(uc);
  if (ret) {
   uc->config.remote_thread_id = -1;
   return ret;
  }

  uc->config.src_thread = uc->config.remote_thread_id;
  uc->config.dst_thread = (ud->psil_base + uc->rchan->id) |
     K3_PSIL_DST_THREAD_ID_OFFSET;

  irq_ring_idx = uc->rchan->id + oes->bcdma_rchan_ring;
  irq_udma_idx = uc->rchan->id + oes->bcdma_rchan_data;

  ret = bcdma_tisci_rx_channel_config(uc);
  break;
 default:
  /* Can not happen */
  dev_err(uc->ud->dev, "%s: chan%d invalid direction (%u)\n",
   __func__, uc->id, uc->config.dir);
  return -EINVAL;
 }

 /* check if the channel configuration was successful */
 if (ret)
  goto err_res_free;

 if (udma_is_chan_running(uc)) {
  dev_warn(ud->dev, "chan%d: is running!\n", uc->id);
  udma_reset_chan(uc, false);
  if (udma_is_chan_running(uc)) {
   dev_err(ud->dev, "chan%d: won't stop!\n", uc->id);
   ret = -EBUSY;
   goto err_res_free;
  }
 }

 uc->dma_dev = dmaengine_get_dma_device(chan);
 if (uc->config.dir == DMA_MEM_TO_MEM  && !uc->config.tr_trigger_type) {
  uc->config.hdesc_size = cppi5_trdesc_calc_size(
     sizeof(struct cppi5_tr_type15_t), 2);

  uc->hdesc_pool = dma_pool_create(uc->name, ud->ddev.dev,
       uc->config.hdesc_size,
       ud->desc_align,
       0);
  if (!uc->hdesc_pool) {
   dev_err(ud->ddev.dev,
    "Descriptor pool allocation failed\n");
   uc->use_dma_pool = false;
   ret = -ENOMEM;
   goto err_res_free;
  }

  uc->use_dma_pool = true;
 } else if (uc->config.dir != DMA_MEM_TO_MEM) {
  /* PSI-L pairing */
  ret = navss_psil_pair(ud, uc->config.src_thread,
          uc->config.dst_thread);
  if (ret) {
   dev_err(ud->dev,
    "PSI-L pairing failed: 0x%04x -> 0x%04x\n",
    uc->config.src_thread, uc->config.dst_thread);
   goto err_res_free;
  }

  uc->psil_paired = true;
 }

 uc->irq_num_ring = msi_get_virq(ud->dev, irq_ring_idx);
 if (uc->irq_num_ring <= 0) {
  dev_err(ud->dev, "Failed to get ring irq (index: %u)\n",
   irq_ring_idx);
  ret = -EINVAL;
  goto err_psi_free;
 }

 ret = request_irq(uc->irq_num_ring, udma_ring_irq_handler,
     IRQF_TRIGGER_HIGH, uc->name, uc);
 if (ret) {
  dev_err(ud->dev, "chan%d: ring irq request failed\n", uc->id);
  goto err_irq_free;
 }

 /* Event from BCDMA (TR events) only needed for slave channels */
 if (is_slave_direction(uc->config.dir)) {
  uc->irq_num_udma = msi_get_virq(ud->dev, irq_udma_idx);
  if (uc->irq_num_udma <= 0) {
   dev_err(ud->dev, "Failed to get bcdma irq (index: %u)\n",
    irq_udma_idx);
   free_irq(uc->irq_num_ring, uc);
   ret = -EINVAL;
   goto err_irq_free;
  }

  ret = request_irq(uc->irq_num_udma, udma_udma_irq_handler, 0,
      uc->name, uc);
  if (ret) {
   dev_err(ud->dev, "chan%d: BCDMA irq request failed\n",
    uc->id);
   free_irq(uc->irq_num_ring, uc);
   goto err_irq_free;
  }
 } else {
  uc->irq_num_udma = 0;
 }

 udma_reset_rings(uc);

 INIT_DELAYED_WORK_ONSTACK(&uc->tx_drain.work,
      udma_check_tx_completion);
 return 0;

err_irq_free:
 uc->irq_num_ring = 0;
 uc->irq_num_udma = 0;
err_psi_free:
 if (uc->psil_paired)
  navss_psil_unpair(ud, uc->config.src_thread,
      uc->config.dst_thread);
 uc->psil_paired = false;
err_res_free:
 bcdma_free_bchan_resources(uc);
 udma_free_tx_resources(uc);
 udma_free_rx_resources(uc);

 udma_reset_uchan(uc);

 if (uc->use_dma_pool) {
  dma_pool_destroy(uc->hdesc_pool);
  uc->use_dma_pool = false;
 }

 return ret;
}

static int bcdma_router_config(struct dma_chan *chan)
{
 struct k3_event_route_data *router_data = chan->route_data;
 struct udma_chan *uc = to_udma_chan(chan);
 u32 trigger_event;

 if (!uc->bchan)
  return -EINVAL;

 if (uc->config.tr_trigger_type != 1 && uc->config.tr_trigger_type != 2)
  return -EINVAL;

 trigger_event = uc->ud->soc_data->bcdma_trigger_event_offset;
 trigger_event += (uc->bchan->id * 2) + uc->config.tr_trigger_type - 1;

 return router_data->set_event(router_data->priv, trigger_event);
}

static int pktdma_alloc_chan_resources(struct dma_chan *chan)
{
 struct udma_chan *uc = to_udma_chan(chan);
 struct udma_dev *ud = to_udma_dev(chan->device);
 const struct udma_oes_offsets *oes = &ud->soc_data->oes;
 u32 irq_ring_idx;
 int ret;

 /*
 * Make sure that the completion is in a known state:
 * No teardown, the channel is idle
 */
 reinit_completion(&uc->teardown_completed);
 complete_all(&uc->teardown_completed);
 uc->state = UDMA_CHAN_IS_IDLE;

 switch (uc->config.dir) {
 case DMA_MEM_TO_DEV:
  /* Slave transfer synchronized - mem to dev (TX) trasnfer */
  dev_dbg(uc->ud->dev, "%s: chan%d as MEM-to-DEV\n", __func__,
   uc->id);

  ret = udma_alloc_tx_resources(uc);
  if (ret) {
   uc->config.remote_thread_id = -1;
   return ret;
  }

  uc->config.src_thread = ud->psil_base + uc->tchan->id;
  uc->config.dst_thread = uc->config.remote_thread_id;
--> --------------------

--> maximum size reached

--> --------------------