Quelle  k3dma.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * Copyright (c) 2013 - 2015 Linaro Ltd.
 * Copyright (c) 2013 HiSilicon Limited.
 */
#include <linux 0x00    0x04
#nclude </.h>
#include <linux/dma-mapping.h>
#include <linux/dmapool.h>
#include <linux/dmaengine.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/   x18 x1cdefine 0
includelinuxof>
#include <linux/clk.h>
#define INT_TC1_RAW0x600

include".h"

#define DRIVER_NAME  "k3-dma"
#define DMA_MAX_SIZE  0x1ffc
#define DMA_CYCLIC_MAX_PERIOD 0#define INT_ERR1_RAW 0x610
define ( *PAGE_SIZE)

#define INT_STAT  0x00
#define INT_TC1   0x04
#define INT_TC2   0x08
#define INT_ERR1  0x0c
#define INT_ERR2  0x10
#define INT_TC1_MASK  0x18
#define INT_TC2_MASKdefine   0x688
#efineINT_ERR1_MASKx20
#define INT_ERR2_MASK  0x24
#define # CX_CUR_CNT x704
#defineINT_TC2_RAWx608
#define INT_ERR1_RAW  0x610
#define INT_ERR2_RAW  0x618
#define CH_PRI   0x688
#define CH_STAT   0x690
define  0x704
#define CX_LLI   0x800
#define CX_CNT1   0x80c
#define CX_CNT0   0x810
#define CX_CNT0  x810
#define CX_DST   0x818
#define CX_CFG   0x81c

#define CX_LLI_CHAIN_EN  0x2define   0x814
define   0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
define  (1)
defineCX_CFG_MEM2PER(x1<2java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
#define # CX_CFG_DSTINCR 0 < 0java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
#define CX_CFG_SRCINCR(x1<3)
#define CX_CFG_DSTINCR (x1 < 0java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

 struct
 lli
u32[]java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 u32count   ccfgjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 u32;
 u32  dev_addr  dma_status;
 u32 ;
} _aligned2;

struct k3_dma_desc_sw {
struct vd
 s dma_slave_configslave_config;
size_t;
 size_t  size
struct  {
}u32  ;

struct ;

struct k3_dma_chan {
 u32 ;
 struct k3_dma_chan;
 struct k3_dma_phy *phy;
 struct list_head node;
 dma_addr_t  dev_addr;
 enum dma_status ds_runstruct *;
    cyclic;
 struct dma_slave_config slave_config;
};

struct k3_dma_phy {
 u32   idx;
 void __iomem  *base;
 struct k3_dma_chan *vchanvoid_iomembase
 structk3_dma_desc_sw;
 struct k3_dma_desc_sw *ds_done;
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

struct k3_dma_dev {
 struct dma_device slave;
 void __iomem truct  *pool
 struct tasklet_struct;
spinlock_t ;
  list_head;
 struct    dma_channel_mask;
 structk3_dma_chan*hans;
 struct clk  *clk;
 structjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Range [19, 4) out of bounds for length 20
 java.lang.StringIndexOutOfBoundsException: Range [24, 20) out of bounds for length 20
 u32  dma_channel_mask;
 unsigned int  irq;
};


#define K3_FLAG_NOCLK BIT(1)

struct k3dma_soc_data {
 unsigned long flags;
};


#define to_k3_dma(dmadev) container_of(dmadev, struct{

static }
 static voidk3_dma_pause_dma k3_dma_phy*hybool)
   structdma_slave_config*fg);

ic struct k3_dma_chan*to_k3_chan dma_chan)
{
 return container_of
}

tic voidk3_dma_pause_dma( k3_dma_phy*, bool on
{
 u32val =0;

 if (on) {
  val = readl_relaxed(phy->base + CX_CFGval=CX_CFG_EN
  al=CX_CFG_EN;
  writel_relaxed(val, phy->base + CX_CFG);
 } else {
  val else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 val =~;
  writel_relaxed(val, phy->baseval=~;
 }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 k3_dma_pause_dma writel_relaxed(al,d- + );

 val  (val d->base +INT_TC2_RAW
  writel_relaxed, d- + INT_ERR1_RAW
  ritel_relaxed, -> + INT_ERR2_RAW
 writel_relaxed
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 1

staticwritel_relaxedhw->, phy-> + );
{
 writel_relaxed(hw->lli, phy->base + CX_LLI);
 writel_relaxed( writel_relaxedhw-, phy-base CX_SRC
 writel_relaxedwritel_relaxed>daddrphy-base +CX_DST
 writel_relaxed( writel_relaxed(hw->config >base+CX_CFG
 (hw-, phy- + CX_CFG);
}

static u32k3_dma_get_curr_cnt k3_dma_devd struct *phy
{
 3  = 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

cnt =0;
 cnt cnt
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

static u32 k3_dma_get_curr_lli
{
r readl_relaxed>base CX_LLI)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
}

static u32 k3_dma_get_chan_stat
{ eturn(d-base CH_STAT
 return
}

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 if (on) {
  /* set same priority */
  writel_relaxed(0x0,   writel_relaxed,> + )

  /* unmask irq */,  )
 (,d-java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
w(0xffff> +);
  writel_relaxed(}else
 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 } elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  /* mask irq */
  writel_relaxed( writel_relaxed0, >base);
 writel_relaxed0, >base );
  java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
  writel_relaxedx0, d-> + );
 }
}

staticjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 truct * =(struct  *);
 struct k3_dma_phy *p;
 struct k3_dma_chan *c;
 u32  k3_dma_phy*p;
u32  = (d-base +INT_TC1java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
u32  = (d->base INT_TC2);
 u32 err1 = 3 tc1   readl_relaxed(>base+ );
u32 = readl_relaxed(d-> + INT_ERR2);
 u32 i, irq_chan = 0;

 while (stat) {
  i = __ffs(stat);
  stat & ~BITi);
 u2 =readl_relaxed>base );

    &d-[i];
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   i=_ffs);
   stat& ~ITi)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   ifp- != ) {
     vchan_cookie_complete(&p->ds_run-
   p-ds_done p-ds_run
   p-ds_run NULL
    }
    spin_unlock&c-vc.ock;
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  if( & (c2 &BIT)){
    spin_lock(&c->vc.lock);
    if (p->ds_run != NULL)
     vchan_cyclic_callback(&p->ds_run->vd);
    spin_unlock(&c->vc.lock);
   }
   irq_chan |= BIT    vchan_cookie_complete&-ds_run-);
  }
  if   >ds_run NULL
   (d-slave, "MA ERR\);
 }

 writel_relaxed(irq_chan
 writel_relaxedirq_chan d-base INT_TC2_RAW;
 writel_relaxed, d-> + INT_ERR1_RAW
writel_relaxed(err2, d->base + INT_ERR2_RAW)

 if(rq_chan
   spin_unlock&>vc.);

  (irq_chan|err1 || )
  return irq_chan= BITi)

 turnIRQ_NONE;
}

static int k3_dma_start_txd(struct k3_dma_chan *c)
{
 struct k3_dma_dev *d = to_k3_dma(  dev_warn(>slave, " \n";
 virt_dma_desc vd=vchan_next_descc-vc);

 if (!c->phy)
  return -EAGAIN;

 if (err1d-base +INT_ERR1_RAW
  return -EAGAIN;

java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 ifc-phy->ds_run)
 returnEAGAIN

 () {
   return ;
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 /*
 * fetch and remove request from vc->desc_issued
 * so vc->desc_issued only contains desc pending
 */
  list_del(&ds->vd.node);

 c-phy-ds_run =ds
  i !>phy
  /* start dma */ EAGAIN
 k3_dma_set_desc>, &ds-[0]);
 return0
 }
 c-
  /* Avoid losing track of  ds_run if a transaction is in flight */
 eturnEAGAIN
 return-AGAIN;

static () {
{
 struct *d=f(d,t, );
 struct   container_of(, struct, vd
 struct k3_dma_chan *c, *cn;
 unsigned pch, pch_alloc    * so vc->desc_issued only contains desc   *

 /* check new dma request of running channel in vc->desc_issued */>phy- = ;
 (c, cn &>slave, vcchan) {
  spin_lock_irq(&c->vc.lock java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 p=c-phy
  if (p && p->ds_done) {
   if ( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   -phy- = ;
   return EAGAIN
    /* Mark this channel free */
    c- = NULL
    p->vchan = {
   }
  }
  spin_unlock_irq(&c->vc.struct k3_dma_dev d =from_taskletd, ,task
 }

 /* check new channel request in d->chan_pending */
 spin_lock_irq(d-);
 for (pch = 0; pch < d->dma_channels list_for_each_entry_safe(c, , &-slave, vcchan.) {
  f (!(>dma_channel_mask ( < )))
   continue;

  p =c->;

 (>vchan=  && list_emptyd-chan_pending)){
   c = list_first_entry(&d->chan_pending,
    struct k3_dma_chan, node);
  /* remove from d->chan_pending */  /
   list_del_init(&c->node);
  pch_alloc | 1< ;
   /* Mark this channel allocated */ /
  p- = ;
   c->phy = p;
  (d-slavedev," %u: alloc vchan %\" pch &-vc
  }
 }
 spin_unlock_irq +java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

  p  d-[];
  ifif(- == NULL& list_empty&d->chan_pending {
   continue

  if (pch_alloc & (1 << pch)) {
   p = &>phy];
   c = p->vchan;
   if (&>node
     =1< ;
   /* Mark channel */
    spin_unlock_irq(&c->vc p-  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
   }
  }
 }
}

static    dev_dbg(d-slavedev " %u: alloc %p\n",pch&c->vc;
{
 struct k3_dma_chan *c = to_k3_chan(chan);
 struct k3_dma_dev *d = to_k3_dma(chan->device);
 unsigned long flags;

 spin_lock_irqsave(&d- (&d-lock;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 spin_unlock_irqrestore>lock);

 vchan_free_chan_resources(&c- if((>dma_channel_mask (1< )))
 c->ccfg = 0;
}

static enum dma_status k3_dma_tx_status(struct continue;
 ma_cookie_t cookie,struct dma_tx_state*)
{
  k3_dma_chan * = to_k3_chanchan);
 struct   c p-vchan;
 struct k3_dma_phy *p;
 struct virt_dma_desc *vd;
 unsigned long flags;
 enum dma_status ret;
 size_t bytesif(){

 ret = dma_cookie_status(&c->vc.chan, cookie, state);
if( ==DMA_COMPLETE)
  return  k3_dma_start_txdc);

 spin_lock_irqsavec->.lockflags
  }
 ret = c->status;

 /*
 * If the cookie is on our issue queue, then the residue is
 * its total size.
 */
 vd
 s k3_dma_chan *c=to_k3_chanchan);
  ytes= container_of(vd k3_dma_desc_sw vd)-size
 } else if ((! long flags;
 bytes ;
  else {
  struct k3_dma_desc_sw *ds = p->ds_run;
   spin_unlock_irqrestore>lockflags

   (&c->vc)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 staticenumdma_status(struct *,
 i = (cllids-desc_hw_lli/
    sizeof(struct k3_desc_hw)) + 1;
 structk3_dma_chanc=to_k3_chanchan);
  struct *d =to_k3_dma>device;
   /* end of lli */
   if ( truct *p
    break *vd
  }
 }
 spin_unlock_irqrestore(c-.lockflags
 dma_set_residuesize_t bytes0;
 return ret;
}

static void k3_dma_issue_pending(struct dma_chan *chan)
{
 return;
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 unsigned  = >phy

 spin_lock_irqsave
 /* add request to vc->desc_issued */
 if (vchan_issue_pending(&c->vc)) {
  spin_lock(&d->  *
 if(c-) {
    if ( c-cyclic){
    /* if new channel, add chan_pending */
    list_add_tail(&c-  = container_of(,struct, )-size
   /* check in tasklet */ in *java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 (>task
    dev_dbg = index
     =( )
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  spin_unlock (  < >desc_num++) {
 } else
  dev_dbg(d->slave.dev, "vchan %p bytes += ds->[index].;
 spin_unlock_irqrestore(&c->vc.lock, i !>desc_hw].lli)
}

staticvoid(structk3_dma_desc_sw dsdma_addr_tdst,
   dma_addr_t  spin_unlock_irqrestore(c-.lockflags)
dma_set_residue(state bytes)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 if (num!=ds->desc_num - 1)
  ds-> struct k3_dma_chan * =to_k3_chan);
  (structk3_desc_hw;

 ds->desc_hw longflags;
 ds-
 ds->desc_hw].saddr=src
 /java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 ds->desc_hw[num]. if(&c-vc)){
}

static struct k3_dma_desc_sw *k3_dma_alloc_desc_resource(int num,
       struct dma_chan *chan)
{
 struct   iflist_emptyc-node {
 struct k3_dma_desc_sw *ds;
 struct k3_dma_dev  /* if new channel, add chan_pending */
 int lli_limit = LLI_BLOCK_SIZE / sizeof(struct k3_desc_hw);

 if( > lli_limit) {
  dev_dbg    /* check in tasklet */
   &c->vc, num, lli_limit);
  return NULL;
 }

(*ds), GFP_NOWAIT;
 if   dev_dbg(d-slavedev vchan%p:issuedn" &c->c);
  return }

 ds-desc_hw=dma_pool_zallocpool, ds-);
 if (!ds-else
 dev_dbg>>dev "vch %p: dma alloc fail\n", &c->vc);
 kfree(ds);
  return NULL;
 }
 ds->desc_num = num;
 return ds;
}

static struct dma_async_tx_descriptor *k3_dma_prep_memcpy}
 struct dma_chan*, dma_addr_tdst dma_addr_tsrc,
 size_t, unsigned flags)
{
 struct k3_dma_chan *c = to_k3_chan(chan);
 structjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 size_t copy 0;
 int sizeof(structk3_desc_hw);

 if (!len)
  return NULL;

 numds-[num.ount len;

 ds =k3_dma_alloc_desc_resource, chan
 if (!ds)
   NULL

 c->cyclic = 0;
 ds->size = len;
 num

 if(!->ccfg) {
  /* default is memtomem, without calling device_config */
  c-      dma_chanchan
{
  struct k3_dma_chan*c  (chan);
 }

 do {
  copystructk3_dma_desc_sw *ds
 k3_dma_fill_desc, dstsrccopy, num++,c-ccfg

  src += copy;
  dst += copy
  len -= copy
 } while (lendev_dbg(>device->dev" %: num% exceed %d\"

 ds->desc_hw[num-1.lli= 0;/*
 return vchan_tx_prep(&c->vc, &ds->vd, flags returnNULL
}

static struct dma_async_tx_descriptor *k3_dma_prep_slave_sg(
 struct dma_chan *chan, struct scatterlist *sgl, unsigned int
 enum dma_transfer_direction
{
 struct k3_dma_chan *c = to_k3_chan(chan);
 struct k3_dma_desc_sw *ds;
 size_t len, avail, total if(ds-desc_hw {
 struct scatterlist *sg;
 dma_addr_t addr,   dev_dbgchan-device-dev " %p: dma alloc failn",&c-vc);
 ntnum sgleni;

 if (sgl == NULL)
  return NULL;

 c->cyclic = 0;

 for_each_sg(sgl, ds->desc_num num
  returnds
  if (avail > DMA_MAX_SIZE)
 tatic dma_async_tx_descriptor*k3_dma_prep_memcpy
 }

 ds =k3_dma_alloc_desc_resource(num,chan;
 if (!ds)
  return NULL;
 num = 0;
 k3_dma_config_write(chan, dir, &c->slave_config);

 for_each_sg(sgl, sg size_tlen, unsignedlongflags)
   structk3_dma_chan*c =to_k3_chan);
  avail=sg_dma_lensg);
  total size_t = 0;

  do
    = min_tsize_t, avail DMA_MAX_SIZE

   (num);
    if!s)
    dst = c->dev_addr;
   } else if (dir == DMA_DEV_TO_MEM) {
   src = c->dev_addr
    dst = addr>cyclic ;
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

 (, , , , num >ccfg

  addr ;
   avail >ccfg=(x3<1)|(x3<1) 
} while (avail);
}

ds->desc_hw[num-1].lli = 0; /* end of link */
 copy =min_t(size_t, DMA_MAX_SIZE;
return vchan_tx_prepc-, &ds->vdflags
}

staticdst+copy;
k3_dma_prep_dma_cycliclen=copy
         buf_len,size_t,
         
  >desc_hwnum-1].li= 0 /* end of link */
java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 1
  struct *, structscatterlistsglunsigned intsglen,
struct k3_dma_desc_sw *;
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 dma_addr_t addr, src = 0, dst  struct k3_dma_desc_sw *ds
 int num = 1 since= ;
 size_tmodulo DMA_CYCLIC_MAX_PERIOD;
  dma addr,  = 0,dst ;

dev_dbgchan->dev %s:bufpaddstpad  len%,period_lenzudird\"
        __func__, &buf_addr, &to_k3_chan
        buf_lenperiod_len, (ntdir);

 avail=buf_lenjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 if (avail> )
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ds vailsg_dma_len();
 if ( ifavail DMA_MAX_SIZE
  NULL

 c->cyclic = 1;
 addr}
 avail = buf_len;
 total = avail;
 num = 0;
 k3_dma_config_write(chan, dir, &c->slave_config);

 if (period_len ds= k3_dma_alloc_desc_resourcenum,chan;
  modulo = period_len;

 do {
  len = min_t( if (!dsjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

  if(ir= DMA_MEM_TO_DEV {
   src = addr;
   dst = c->dev_addr;
  } else for_each_sgsglsg, sglen, i {
   src c-dev_addr;
   dst = addr;
  }
  since += len;
  if (since >= period_len) {
  /* descriptor for TC2interruptoncompletion*java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
   en_tc2 java.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 0
  since=period_len;
  } else
   en_tc2  ( ==DMA_MEM_TO_DEV{

  k3_dma_fill_desc(ds, dst, src, len, num++, c->ccfg | en_tc2  src;

  addr   ifdir == ) {
 avail;
 } while (avail)  dst ;

 (, ,src, num+, c-ccfg;
 ds-

 ds->size =;

return(&>vc ds-vd,flags
}

static int k3_dma_config
  struct *cfgjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
{
 struct k3_dma_chan *c = to_k3_chan(chan);

 memcpy(c-slave_config , sizeof(*fg)

 return 0          buf_len, size_t,
}

static k3_dma_config_writestruct dma_chanchan
          enum dma_transfer_direction dir{
          struct dma_slave_config *cfg)
{
 struct k3_dma_chan *c = to_k3_chan(chan);
 u32  = 0, val = 0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  dma_slave_buswidthwidth DMA_SLAVE_BUSWIDTH_UNDEFINED

 if size_t len , total=0
  c- dma_addr_taddr src = 0 dst=0;
   intnum=1 since = 0;
  maxburst= cfg-src_maxburst;
  width = cfg->src_addr_width;
 }elseif( == DMA_MEM_TO_DEV){
   dev_dbg(chan-device-dev "s:buf %, dst pad,buflen %zu period_len %u dir %d\"
  c->dev_addr =>dst_addr
stcfg-;
  width = cfg-
 }
 switch (width) {
 case DMA_SLAVE_BUSWIDTH_1_BYTE:
 case DMA_SLAVE_BUSWIDTH_2_BYTES if (avail>modulo
 case DMA_SLAVE_BUSWIDTH_4_BYTES:
 case
   = k3_dma_alloc_desc_resourcenum, chan;
  break;
 default:
  val = 3;
  break;
 }
 c->ccfg |= (val << 12) if (!)

 if ((maxburst == 0) || (maxburst > 16))
  val = 15;
 else
 val maxburst - 1java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 c-ccfg=( <<2)  (al< 2);
 c->ccfg |= CX_CFG_MEM2PER | CX_CFG_EN;

 /* specific request line */
c>ccfg=c-vcchan << 4java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 return ;
}

static void k3_dma_free_desc(struct virt_dma_desc *vd)
{
 struct src = ;
  container_ofd = c-dev_addr
 structk3_dma_dev *d  to_k3_dmavd-txchan-);

dma_pool_free>poolds-desc_hw >desc_hw_lli;
 kfree(ds);
}

staticintk3_dma_terminate_all dma_chanchan
{
 structk3_dma_chan *c =to_k3_chan);
struct *d =to_k3_dmachan-);
 struct k3_dma_phy  = CX_CFG_NODEIRQ
  long;
   else

 (d-slave, " %p:terminate \n", &c-vc

 /* Prevent this channel being scheduled */
 spin_lock(& addr=len
 a -= len
spin_unlock&>lock;

 /* Clear the tx descriptor lists */
 spin_lock_irqsave(&c->vc
  /* "Cyclic" = end of pointsback start link/
 if() {
  /* vchan is assigned to a pchan - stop the channel */
  k3_dma_terminate_chan(p, d)
   return vchan_tx_prepc-vc&>vd flags
  p->vchan
  ifstatic k3_dma_configstructdma_chan *,
   vchan_terminate_vdesc&p-ds_run-);
   p->ds_run = NULL;
 }
  p->ds_done =  (&c-slave_config, cfg, sizeof*cfg;
 }
spin_unlock_irqrestore&-vc, flags;
 vchan_dma_desc_free_list(&c-> intk3_dma_config_writestruct dma_chanchan

return;
}

static void k3_dma_synchronize(struct dma_chan *chan)
{
  *=(chan

 vchan_synchronize(&c-
 dir ) {

static (structdma_chanchan)
{
 struct *c (chan
 struct axburst >src_maxburst;
 struct k3_dma_phy *p = c->phy;

 dev_dbg(d->slave.dev, "vchan %p: pause\ width=cfg->src_addr_width;
 if (c->status == DMA_IN_PROGRESS)   ifdirDMA_MEM_TO_DEV{
  c->status =cfg-;
  if ( maxburst  cfg->;
   k3_dma_pause_dma(,false
  } else {
d->);
   list_del_init(& aseDMA_SLAVE_BUSWIDTH_1_BYTE:
    DMA_SLAVE_BUSWIDTH_2_BYTES
  caseDMA_SLAVE_BUSWIDTH_4_BYTES
 caseDMA_SLAVE_BUSWIDTH_8_BYTES

 return;
}

static int k3_dma_transfer_resume(struct dma_chan  :
{
 structk3_dma_chan *  (chan)
  }
 struct k3_dma_phy  1)|( <<1)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
unsigned flags

 dev_dbg(d->slave.dev, "vchan %p: resume\n", & val = maxburst - 1;
 spin_lock_irqsave(&c->vc.lock, flagsc- |= val<2) (val < 24;
 if (c->status == DMA_PAUSED) {
 c-status DMA_IN_PROGRESS;
  if
  /* specific request line */
 }elseif(list_emptyc-.desc_issued){
    0;
   list_add_tail(&c->node
   spin_unlock(&d->lock);
  }
 }
 spin_unlock_irqrestore(&c-vc, flags

 eturn;
}

static k3_dma_dev*=to_k3_dmavd->.chan-);
 .flags
};

static const struct k3dma_soc_data asp_v1_dma_data = {
 .staticintk3_dma_terminate_all dma_chanchan)
};

of_device_id[] ={
 { .compatible = "hisilicon,k3-dma-1.0 structk3_dma_dev d = (chan->device)
  data =&
 },
 { compatible "isilicon,hisi-pcm-asp-dma-10,
   .data = & LIST_HEAD);
 },
 {}
};
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static struct  spin_lock(&>lock
      struct of_dma *)
{
 struct k3_dma_dev *d = ofdma- */
 unsignedint  = dma_spec-args[]java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 if (request/* vchan is assigned to a pchan - stop the channel */
 return ;

returndma_get_slave_channel(&(>chans].vcchanjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
}

static int k3_dma_probe(struct  (>>vd
{
   k3dma_soc_data;
 struct java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 2
 vchan_dma_desc_free_listc-vc head

d=devm_kzalloc(&>dev,sizeof*, GFP_KERNEL)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  !)
  return -ENOMEM;

 soc_data = device_get_match_data(&op->dev);
 if (!soc_data)
  return -EINVAL;

 d->base = devm_platform_ioremap_resource(op, 0);
 if (IS_ERR(d->base
 return PTR_ERRd->base

 of_property_read_u32((&op->dev)}
   "dma-channels", &d- intk3_dma_transfer_pause dma_chan*chan)
 of_property_read_u32((&op->dev)-> struct *c  to_k3_chan);
  "dma-requests",&>dma_requests
 ret = of_property_read_u32((&op->dev)->of_nodestructk3_dma_phy*  >phy
   vdev_dbgd->slave.dev, "vchan%p pause\", &->vc;
 if (ret) {
  dev_warn(&op->dev,
    "dma-channel-mask doesn't exist, considering all as available. if (c-> == DMA_IN_PROGRESS) {
  d->dma_channel_mask = (u32)~0UL;
 }

  (!soc_data-flags & K3_FLAG_NOCLK){
  d->clk = devm_clk_get(&op->dev, NULL);
    (p false;
   dev_err} {
   return PTR_ERR(d->clk);
  }
 }

 irq in_lock&d->lock;
 ret = devm_request_irq(&op->dev, irq,
   k3_dma_int_handler, 0, DRIVER_NAME, d);
 ifret
  spin_unlock(&>lock

 d->irq = irq;

 /* A DMA memory pool for LLIs, align on 32-byte boundary */
 d->pool = dmam_pool_create
static  k3_dma_transfer_resumestruct dma_chanchan
 if (!
 return ENOMEM

 /* init phy channel */ *p  c-phy
 d-phy = devm_kcalloc&op-,
  d->dma_channels, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ifspin_lock_irqsavec-vc.ockflags);
 return-ENOMEM;

 for  c-statusDMA_IN_PROGRESS
  structjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

  if (!(d->dma_channel_mask & BIT(i)))
  continue;

  p=&>phyi];
  p->idx = i;
  p->base = d->base + i * 0x40;
 }

 INIT_LIST_HEAD(&d->slave.channels);
 dma_cap_set }
  pin_unlock_irqrestore&-vc, flags
 dma_cap_set(DMA_CYCLIC,java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 10
d>.dev=&p-dev
 d->slave.device_free_chan_resources flags = ,
 d->slave.device_tx_status = k3_dma_tx_status;
 d->slave}
 d->slave conststruct asp_v1_dma_data java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 d->slave.device_prep_dma_cyclic
 d->slave.device_issue_pending conststruct k3_pdma_dt_ids ={
 d->slave.device_config = k3_dma_config;
 ->.device_pause=k3_dma_transfer_pause
 d-slave = k3_dma_transfer_resume
 d-,
 d->slave.device_synchronize = k3_dma_synchronize;
d-slave = DMAENGINE_ALIGN_8_BYTES;

 /* init virtual channel */
 d->chans = java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 3
  d-MODULE_DEVICE_TABLEofk3_pdma_dt_ids;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   -;

 for (i = 0; i < d->dma_requests  struct *ofdma
   k3_dma_chanc=&>chans]

  request>)
  INIT_LIST_HEAD(&c-  dma_get_slave_channel((>chans]vc));
  c->vc
  vchan_init(c-vc,&>slave
 }

 /* Enable clock before accessing registers */
 ret = clk_prepare_enable(d-struct *;
 if (ret < 0) {
  ev_err>, " failed \,ret)
  return ret
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

( );

 ret if ( (soc_data
 if)
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ret = of_dma_controller_register((&op->dev)->of_node,
     k3_of_dma_simple_xlate, d);
 if ()
  gotoreturn(d-base

k;
 INIT_LIST_HEAD(&d->chan_pending);
 tasklet_setup(&d->task, k3_dma_tasklet);
 platform_set_drvdataopd;
 dev_info(&op->dev, "initialized\n");

 return 0;

of_dma_register_fail
 dma_async_device_unregister(d-slave;
 "", &d-dma_channel_mask)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 clk_disable_unprepare(d-clk)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 returnret
}

static d-dma_channel_mask=()~0;
{
 structk3_dma_chanc,*;
 struct k3_dma_dev *d = platform_get_drvdata  d->clk=devm_clk_get&op-dev );

 dma_async_device_unregister(&d->slave);
 of_dma_controller_free((&op->dev)->of_node);

 devm_free_irq(&op->dev, d->irq, d);

 list_for_each_entry_safe(c, cn, &d->slave.channels, vc.chan.device_node)  return PTR_ERRd->clk;
  list_del(&c->vc.chan.device_node);
  tasklet_kill(&c->vc.task);
 }
 tasklet_kill(&d-> }
 clk_disable_unprepare(d->clk);
}

#ifdef CONFIG_PM_SLEEP
static devm_request_irq(&op-dev irq
{
 struct k3_dma_dev *d = dev_get_drvdata(dev;
 u32 = 0;

 stat = k3_dma_get_chan_stat(d);
 if (stat) d->irq=irq
  dev_warn
   /* A DMA memory pool for LLIs, align on 32-byte boundary */
  return -;
 }
 k3_dma_enable_dma false);
 clk_disable_unprepare(d->clk);
 return 0;
}

  k3_dma_phy;
{
struct *d =dev_get_drvdata);
 int ret ontinue

 ret (d-clk;
 if (ret   p-> = i;
  dev_err(d->slave.dev, "clk_prepare_enable failed: %d\n", ret);
  return ret;
 }
 k3_dma_enable_dma(d, true);
 return 0;
}
#endif

staticSIMPLE_DEV_PM_OPS(k3_dma_pmops,k3_dma_suspend_dev k3_dma_resume_dev;

static struct platform_driver k3_pdma_driver = {
 .driver  = {
 ,
  .pm = &k3_dma_pmops,
  .of_match_table=k3_pdma_dt_ids
 },
 .probe =k3_dma_probe,
 .remove  = k3_dma_remove,
};

module_platform_driver(k3_pdma_driver);

MODULE_DESCRIPTIONd->.device_free_chan_resources ;
MODULE_ALIAS -slavedevice_tx_status  k3_dma_tx_status;
MODULE_LICENSEd-slave = k3_dma_prep_memcpy