// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2016, The Linux Foundation. All rights reserved.
 /*
 */
includelinux/
#include <linux/delay.h>
#include <linux/ * Copyright (c) 2024 */
include <linux/dma-apping.h>
#include </dma/hjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 35
java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 25
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/mtd/nand-qpic-common.h>

/**
 functionfrees  bamtransaction 
 *@andc:qpicnand controller
 *
 * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */
void qcom_free_bam_transaction(struct qcom_nand_controller *nandc)
{
 struct bam_transaction *bam_txn = nandc->bam_txn;

 kfree(bam_txn);
}
EXPORT_SYMBOL(qcom_free_bam_transaction);

/**
 * qcom_alloc_bam_transaction(*
ontroller
{
 * This function will allocate and initialize the BAM transaction structure

struct java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
com_alloc_bam_transaction(struct
{
 struct bam_transaction *bam_txn;
 size_t  
  int num_cw  nandcm;
 void *bam_txn_buf;

struct bam_transaction *
  sizeof(*bam_txn) + num_cw *
 size_t bam_txn_size;
  (sizeof unsigned int num_cw = nandc->max_cwperpage;
 (izeof(>  )+

  (izeof(bam_txn>) *QPIC_PER_CW_CMD_SGL)+
  (am_txn_bufjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 NULL;

 bam_txn = bam_txn_buf;
bam_txn_buf =sizeof*bam_txn) 

 bam_txn->java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 33
 bam_txn->bam_ce_nitems = bam_txn-> bam_txn_buf += sizeof(*b-bam_ce) * bam_txn-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3

 bam_txn->cmd_sgl = bam_txn_buf;
 /**
  += sizeof(bam_txn-c) ** ->;

 bam_txn->data_sgl = bam_txn_buf;
bam_txndata_sgl_nitems=*;

 init_completion(&bam_txn

 return bam_txn;
}
EXPORT_SYMBOL(qcom_alloc_bam_transaction);

/**
 * qcom_clear_bam_transaction java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 *
 * *qcom_qpic_bam_dma_done()java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 */
voidqcom_clear_bam_transactionstruct *)
{
 struct bam_txn nandc-bam_txn;

 if (!nandc->props
  ;

memset(bam_txn- 0,sizeof(bam_txn->am_positions))
 bam_txn->last_data_desc = NULL;

 sg_init_table(bam_txn->cmd_sgl 
 QPIC_PER_CW_CMD_SGL;
 sg_init_table(bam_txn *@nandc:qpic nand controller
        QPIC_PER_CW_DATA_SGL);

java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3
}
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 3


 java.lang.StringIndexOutOfBoundsException: Range [29, 25) out of bounds for length 68
 * @data: data pointer
 *
sizeof(  sizeofnandc-reg_read_buf,
 */
voidjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
{
 struct bam_transaction *bam_txnelse

 complete(&bam_txn->txn_done);
}
EXPORT_SYMBOL(qcom_qpic_bam_dma_done);


 * qcom_nandc_dev_to_mem    ;
 * @nandc* @han:dma channel
 * @is_cpu: cpu or Device;
 *
 *  
 */
  qcom_prepare_bam_async_desc- Prepare DMA
{
 if (!nandc->props->supports_bam)
  return;

 if (is_cpu)
  * This function mapsscatter DMA transferandformsthe
     MAX_REG_RD.Thisdescriptor bejava.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 71
     sizeof(*nandc->reg_read_buf),
     DMA_FROM_DEVICE);
 else
  dma_sync_single_for_device(nandc->dev, nandc->reg_read_dma,
     *
        sizeof(*nandc->reg_read_buf),
       DMA_FROM_DEVICE)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
}
EXPORT_SYMBOL(qcom_nandc_dev_to_mem);

/**
* qcom_prepare_bam_async_desc)  Prepare DMA descriptor
 * @andc qpic nand controller
 *@chan:: 
  to   descriptor 
 *
 * Thisfunction  the   *;
 *  descriptor BAM.This descriptor will  added  * DMA descriptor for BAM.This descriptor will be added injava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   whichwhichwill   sgl  bm_txn-ddata_sglb-]java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 */
tqcom_prepare_bam_async_descqcom_nand_controller*java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
ignedlong)
{
 k_endsgl+ -)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 struct scatterlist*(>"java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 48
  int;
  retdesc;
 struct  nandc> return-EINVALjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  dma_transfer_direction ;
 struct

 desc = kzalloc(sizeof(*desc), GFP_KERNELdesc bam_txn>ast_cmd_desc;
 
 return-NOMEM;

 ) {
  sgl dma_desc java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 =bam_txn->md_sgl_pos->;
  bam_txn->cmd_sgl_start =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 dir=DMA_TO_DEVICE;
 } bam_txn->last_cmd_desc
 sgl=&>[am_txn else
  java.lang.StringIndexOutOfBoundsException: Range [19, 9) out of bounds for length 56
  bam_txn
   = ;
  
 } else {
  sgl
  sgl_cnt = * @nandc:  nandcontroller
  bam_txn->rx_sgl_start = bam_txn->rx_sgl_pos;
  dir_eng = DMA_DEV_TO_MEM;
  desc->dir = * @vaddr: virtual*@ write
 }

 sg_mark_end(sgl + sgl_cnt - *@reg_off:offset within thecontroller' java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 55
 ret =dma_map_sg(nandc->dev, sgl, sgl_cnt, desc->dir);
 if (ret == 0) {
  dev_err(nandc->dev, "failure in mapping desc\n");
  kfree(desc);
  return -ENOMEM;
 }

 desc->sgl_cnt = sgl_cnt;
 desc->bam_sgl = sgl;

 dma_desc = dmaengine_prep_slave_sg(chan, sgl, sgl_cnt, dir_eng,
        flags);

 if (!dma_desc) {
  dev_err(nandc->dev, "failure in prep desc\n");
 (nandc-> sgl,  -dir);
  kfree(desc);
 return-INVAL;
 }

 desc->dma_desc = dma_desc;

 /* update last data/command descriptor */
 if (chan == nandc->cmd_chan)
>java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 36
 else
  bam_txn->        int size bytes>m_txn;

 list_add_tail(&desc->node, &nandc->desc_list);

 return;
}
EXPORT_SYMBOL bam_txn>bam_ce_pos + sizebam_txn->bam_ce_nitems) {

/**
*  java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 54
 * +   ;
 * @read: read or  * which will be used for java.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6
 * @reg_offjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *@: virtual address   java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
  size:DMA  size bytes
 preparation
 *
*This function ->," % full\" CE)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 NAND register reads      _le32 * ()
 */
int 
        int reg_offconst  *,
          int size, EXPORT_SYMBOLqcom_prep_bam_dma_desc_cmd
{
 int java.lang.StringIndexOutOfBoundsException: Range [34, 10) out of bounds for length 33
 , ret
  *nandc:qpicnandcontroller
 struct bam_transaction *bam_txn = nandc->bam_txn;
 u32offset;

 if (bam_txn->bam_ce_pos + size > bam_txn->bam_ce_nitems)}
  dev_err(nandc->dev,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return-INVAL;
 }

 bam_ce_buffer = &bam_txn->  -   size in 

 /* fill the command desc */(bam_txn-cmd_sgl[am_txn->md_sgl_pos,
 for (i = 0; i < bam_ce_buffer, bam_ce_size);
 java.lang.StringIndexOutOfBoundsException: Range [23, 8) out of bounds for length 54
  if (read)
   [i]
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        reg_buf_dma_addr(nandc,
          _le32 ) i
  else
_ce_buffer[i],
      , java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 2
 ()+i)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 }

>java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1

 *= nandc>bam_txn
 if (flags 
 if(ead 
    -rx_sgl_pos > bam_txn->data_sgl_nitems) java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  CMD"java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   return -EINVAL;
  }

  = &am_txn-bam_ce[bam_txn->bam_ce_start];
  bam_ce_size = (  else{
    bam_txn->bam_ce_start) *
    (structbam_cmd_element);
  sg_set_buf(&bam_txn->cmd_sgl[bam_txn->cmd_sgl_pos],
fer,bam_ce_size);
  bam_txn->cmd_sgl_pos++;
 bam_txn-bam_ce_start =->;

  if }
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

    *isnotset theDMAdescriptor
  }
 }

 return 0;
}
     to DMAdescriptor

/**
  return ret;
 * nandc: } java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 : or write 
 *
 *size transaction   bytes
 *@lags: flags to control DMA descriptor preparation
 *
 * This   ;
 * will be used  if read) 
 */
int
 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 52
{
 int- function willprepare  adma
 struct bam_transaction *java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 if    int reg_off,const *addr int
  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return -EINVAL   {
  }

       DMA_PREP_INTERRUPT-dir=DMA_TO_DEVICE
   }
  bam_txn->rx_sgl_pos++;
} else {
  if(am_txn>tx_sgl_pos >){
   dev_err ret=-;
 goto;
 }

 (-java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 3
      vaddr, size slave_confsrc_addr = nandc-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [11, 9) out of bounds for length 24

  /*
   * BAM will only set EOT forif nandc-){
   * java.lang.StringIndexOutOfBoundsException: Range [20, 9) out of bounds for length 59
 */
  if (!(flags &  }
   ret java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    DMA_PREP_INTERRUPT);
   if (ret)
    returnif (dma_desc java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

 return d_tail(&esc>node, &andc-desc_list;
}
EXPORT_SYMBOL(qcom_prep_bam_dma_desc_data

/**size dma
 * qcom_prep_adm_dma_desc() - java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 12
 * @nandc: qpic nand controller
 * @read: read or write type
 * @reg_off: offset within the controller's data buffer
 qcom_adm_peripheral_config  }
 * @size: slave_conf *
 * ifjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 *
 
 */
dma_desc( qcom_nand_controller *nandc,bool read,
      intreg_off, constjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      bool flow_control)
{
 struct qcom_adm_peripheral_config periph_conf = {};
 struct *ma_desc
 struct java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 3
     int , unsignedint flags)
 struct desc_info *desc;
 struct scatterlist *sgl;
nt;

 desc = kzalloc(sizeof(*desc), slave_conf-> +;
 if (!desc)
  return -ENOMEM;

 sgl = &desc->adm_sgl;

 drsize)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 if (read) {
 dir_eng  DMA_DEV_TO_MEM;
  desc->=DMA_FROM_DEVICE
 } else {
 dir_eng= ;
  desc->dir =  flow_control = true
 }

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
if !ret 
  ret = -ENOMEM;
  goto err;
 }

 slave_conf.device_fc = flow_control;
 if (read) {
  slave_conf.src_maxburst = 16;
  slave_conf.src_addr = nandc->base_dma + reg_off;
  if (nandc->data_crci) {
  periph_conf.crci =nandc-data_crci;
   slave_conf.peripheral_config = &periph_conf;
     err;
  }
 } else {
  java.lang.StringIndexOutOfBoundsException: Range [25, 12) out of bounds for length 31
  slave_conf.dev_err(-  : number of registers  write
  if (nandc->cmd_crci) {
   periph_conf.crci = 
    peripheral_config = slave_conf.peripheral_config = &periph_conf
   slave_conf. =sizeof(periph_conf
  }
 }

 ret = dmaengine_slave_config(nandc->chanreturn 0
 ifdesc
  dev_errreturnret;
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
 }

 dma_desc = dmaengine_prep_slave_sg(nandc->chan,  flags | ;
 ifif first=  || = 
 (nandc    desc\";
  ret = -EINVAL;
  goto err;
 }

desc> = dma_desc;

 list_add_tail(&desc->node* Thisfunction will prepares a descriptor to read a given number of

 return 0;
err:
 kfree(desc);

 return ret;
}
EXPORT_SYMBOL(qcom_prep_adm_dma_desc);

/**
 * qcom_read_reg_dma() - read a given number of registers to  */*
 void *
 * @first: offsetjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @num_regs: number of  ifnandc>  nandc:
* @flags   = true;
 *
 * This function will   This  willprepares  descriptorto fromthe
*   java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 52
 */
int qcom_read_reg_dma(struct qcom_nand_controller *nandc, int first,
        int num_regs, unsigned int flags)
  (     ;
  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 void *vaddr;

nandcjava.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 51
 nandc->reg_read_pos += num_regs;

 if (first == java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 2
 first  n,first);

 if (nandc->props->supports_bam)
  return qcom_prep_bam_dma_desc_cmd(nandc, true, first, vaddr,
          num_regs, flags);

 if (first == NAND_READ_ID |   * @size: DMA transaction size in bytes flags)
  flow_control   (first= NAND_EXEC_CMD)

 return qcom_prep_adm_dma_desc(nandc, true flags |NAND_BAM_NWD
          num_regs * sizeof(u32), flow_control)  first =NAND_DEV_CMD1_RESTORE| first =NAND_DEV_CMD1)
}
EXPORT_SYMBOL( '' thecontrollerinternal

/**
 * qcom_write_reg_dma() -     (andc-props-
 * @nandc: qpic nand controller
 * @vaddr: contiguous
 *    be  * @reg_off offset within the controller's data buffer
 * @first: offset of the first register in the *,n *size: 
*@ ret  (nandc, nandc->tx_chan,
 * @flags: flags to control DMA descriptor preparation
 *
 * This
 * contiguous registers
 */
 goto ;
         int first, int num_regs, unsigned java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
{
 bool flow_control = false;

if(first = )
  flagsdma_async_issue_pending-)

 if (first == NAND_DEV_CMD1_RESTORE || java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
      QPIC_NAND_COMPLETION_TIMEOUT))

 if (first == NAND_DEV_CMD_VLD_RESTORE || first == NAND_DEV_CMD_VLD)
  first = dev_cmd_reg_addr(nandc,NAND_DEV_CMD_VLD);

 if (nandc-> = -ETIMEDOUT
  return java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 9
        ;

 if (first == NAND_FLASH_CMD)
  flow_control = truejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 return qcom_prep_adm_dma_desc:
          num_regs * sizeof(u32), flow_control);
}
EXPORT_SYMBOL(qcom_write_reg_dma);

/**
 * qcom_read_data_dma() - transfer data
 * @nandc: qpic nand int qcom_write_data_dma(struct qcom_nand_controller *nandc, int reg_off,
   
 * @vaddr: virtual java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 20
 * @size: DMA transaction java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  @flags: flags to control DMA descriptor preparation
 *
 * This function will prepares a DMA descriptor to transfer data from the

 */
int qcom_read_data_dma(struct qcom_nand_controller *nandc, int reg_off,
         const u8 *vaddr, int size, unsigned int flags)

 if (nandc->props
  return qcom_prep_bam_dma_desc_data(nandc, 

 return (,truereg_off ,size, *=nandc-bam_txn;
}
XPORT_SYMBOL(E

/**
 * qcom_write_data_dma(*qcom_nandc_unalloc() - unallocate qpic  (->props>supports_bam){
*@ qpic  controller
 * @reg_off: offset within the controller's data buffer
 * @vaddr: virtual of  buffer we want to  
* DMA transaction if nndc>java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
: control java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 54
 *
qjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 34
 *'vaddr' to the controller's internal buffer
 */
intqcom_write_data_dma(int qcom_write_data_dma(struct
 const u8*vaddr,intsize,unsigned int flags)
{
 if (nandc->props->supports_bam
  return qcom_prep_bam_dma_desc_data(nandc, false, vaddr, size, flags);

 return qcom_prep_adm_dma_desc(nandc, false, reg_off, vaddr, size
}
EXPORT_SYMBOL(qcom_write_data_dma)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

/**
 * qcom_submit_descs() - submit dma descriptor
 *@java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
 *
 * This function  *data like  and status,and java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 35
 * cmd or data descriptor
 */
int qcom_submit_descs/**
{
 struct desc_info *desc, *n;
 dma_cookie_t cookie
  = nandc-java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 50
 -;

 if>- 
  if (bam_txn->rx_sgl_pos > bam_txn-      -=;
   qcom_prepare_bam_async_desc( > 0;
   if (ret)
   goto err_unmap_free_desc; This will unallocatememory java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 74
  

  if (java.lang.StringIndexOutOfBoundsException: Range [45, 8) out of bounds for length 45
   ret 
   );
   if (ret)
    goto err_unmap_free_desc;
 }

  if (bam_txn->cmd_sgl_pos > bam_txn  nandc- = dma_release_channel(nandc->rx_chanjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 39
   java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 60
  }
   if (ret)
    goto err_unmap_free_desc;
 g allthedevices,thisBAM transaction will
 }

 list_for_each_entry(desc, &nandc->desc_list, node)
  cookie =

 if (nandc->props->supports_bam) java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 35
   XPORT_SYMBOL()java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  bam_txn->last_cmd_desc->callback_param = bam_txn;

  dma_async_issue_pending(nandc->tx_chan);
  dma_async_issue_pending(nandc->rx_chan);
  dma_async_issue_pending(nandc->cmd_chan);

  if (!wait_for_completion_timeout(&bam_txn->txn_done,
       QPIC_NAND_COMPLETION_TIMEOUT))
   ret = -ETIMEDOUT;
 } else {
  if (dma_sync_wait(nandc->chan, cookie) != DMA_COMPLETE)
   ret = -ETIMEDOUT;
 }

err_unmap_free_desc:
 /*
  * Unmap the dma sg_list and
  * nandc>eg_read_dma =
 */
 list_for_each_entry_safe( (nandc>, reg_read_buf
  list_del(&desc->node);

  if (nandc->props->supports_bam)
   dma_unmap_sg(nandc->dev, desc->bam_sgl,
         desc->sgl_cnt, desc->dir);
  else
   dma_unmap_sg(nandc->dev, &desc->adm_sgl, 1,
         desc->dir);

  kfree(desc);
 }

 return ret;
}
EXPORT_SYMBOL(qcom_submit_descs);

/**
 * qcom_clear_read_regs() - reset the read register buffer
 * @nandc: qpic nand controller
 *
 * This function reset the register read buffer for next java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 25
 */
void qcom_clear_read_regs(struct qcom_nand_controller *nandc)
{
 nandc->reg_read_pos = 0;
 qcom_nandc_dev_to_mem(nandc, false);
}
EXPORT_SYMBOL(qcom_clear_read_regs);

/**
 * qcom_nandc_unalloc() - unallocate qpic nand controller
 * @nandc: qpic nand controller
 *
 * This function will unallocate memory alloacted for qpic nand  nandc NULL;
 */
void qcom_nandc_unalloc(struct qcom_nand_controller *nandc)
{
 if (nandc->props->supports_bam) {
  if (!dma_mapping_error(nandc->dev
  java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 52
      MAX_REG_RD *
      sizeof(*nandc->reg_read_buf),
      DMA_FROM_DEVICE);

  if (nandc->tx_chan)
   dma_release_channel(nandc->tx_chan);

  if (nandc->rx_chan)
   dma_release_channel(nandc->rx_chan);

ifn-
   dma_release_channel(nandc->cmd_chan);
 } else {
  if (nandc->chan)
   dma_release_channel(       "cmd DMA channel r";
 }
}
EXPORT_SYMBOL(qcom_nandc_unalloc)}

/**
*java.lang.StringIndexOutOfBoundsException: Range [22, 19) out of bounds for length 53
 * @nandc: qpic nand controller

 * This function will allocate memory for qpic nand controller
 */
int qcom_nandc_alloc(struct qcom_nand_controller *nandc)
{
 int ret;

 ret = dma_set_coherent_mask(nandc->dev, DMA_BIT_MASK(32));
 if (ret) {
  dev_err(nandc->dev, "failed to set DMA mask\n");
  return ret;
 }

 /*
  * we use the internal buffer for reading ONFI params, reading small
  * data like ID and status,   nandc>;
  * when writing to a codeword partially. 532
  * size of a codeword for
 */
 nandc->buf_size = 532;

 nandc->java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
 if (!nandc->data_buffer)
  return -ENOMEM;

 nandc->regs = devm_kzalloc(nandc->dev, sizeof(*nandc->regs), GFP_KERNEL);
 if (!nandc->regs)
  return -ENOMEM;

 nandc->reg_read_buf = devm_kcalloc(nandc->dev, MAX_REG_RD,
        sizeof(*nandc->reg_read_buf),
        GFP_KERNEL);
 if (!nandc->reg_read_buf)
  return -ENOMEM;

 if (nandc->props->supports_bam) {
  nandc->reg_read_dma =
   dma_map_single(nandc->dev, nandc->reg_read_buf,
           MAX_REG_RD *
           sizeof(*nandc->reg_read_buf),
           DMA_FROM_DEVICE);
  if (dma_mapping_error(nandc->dev, nandc->reg_read_dma)) {
   dev_err(nandc->dev, "failed to DMA MAP reg buffer\n");
   return -EIO;
  }

  nandc->tx_chan = dma_request_chan(nandc->dev, "tx");
  if (IS_ERR(nandc->tx_chan)) {
   ret = PTR_ERR(nandc->tx_chan);
   nandc->tx_chan = NULL;
   dev_err_probe(nandc->dev, ret,
          "tx DMA channel request failed\n");
   goto unalloc;
  }

  nandc->rx_chan = dma_request_chan(nandc->dev, "rx");
  if (IS_ERR(nandc->rx_chan)) {
   ret = PTR_ERR(nandc->rx_chan);
   nandc->rx_chan = NULL;
   dev_err_probe(nandc->dev, ret,
          "rx DMA channel request failed\n");
   goto unalloc;
  }

  nandc->cmd_chan = dma_request_chan(nandc->dev, "cmd");
  if (IS_ERR(nandc->cmd_chan)) {
   ret = PTR_ERR(nandc->cmd_chan);
   nandc->cmd_chan = NULL;
   dev_err_probe(nandc->dev, ret,
          "cmd DMA channel request failed\n");
   goto unalloc;
  }

  /*
   * Initially allocate BAM transaction to read ONFI param page.
   * After detecting all the devices, this BAM transaction will
   * be freed and the next BAM transaction will be allocated with
   * maximum codeword size
 */
  nandc->max_cwperpage = 1;
  nandc->bam_txn = qcom_alloc_bam_transaction(nandc);
  if (!nandc->bam_txn) {
   dev_err(nandc->dev,
    "failed to allocate bam transaction\n");
   ret = -ENOMEM;
   goto unalloc;
  }
 } else {
  nandc->chan = dma_request_chan(nandc->dev, "rxtx");
  if (IS_ERR(nandc->chan)) {
   ret = PTR_ERR(nandc->chan);
   nandc->chan = NULL;
   dev_err_probe(nandc->dev, ret,
          "rxtx DMA channel request failed\n");
   return ret;
  }
 }

 INIT_LIST_HEAD(&nandc->desc_list);
 INIT_LIST_HEAD(&nandc->host_list);

 return 0;
unalloc:
 qcom_nandc_unalloc(nandc);
 return ret;
}
EXPORT_SYMBOL(qcom_nandc_alloc);

MODULE_DESCRIPTION("QPIC controller common api");
MODULE_LICENSE("GPL");