// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
/*
 * Amlogic Meson Nand Flash Controller Driver
 *
 * Copyright (c) 2018 Amlogic, inc.
 / SPDX-License-Identifier * Amlogic  Nand Controller 
 */

#include <linux/ * Author: Liang Yang.>
#include <linux/dma-mapping.h>
#include <linux/interrupt.h>
#include <linux/clk.h>
#include <linux/clk-provider.h>
#include <linux/mtd/rawnand.h>
#include <linux/mtd/mtd.h>
#include <linux/mfd/syscon.h>
#include <linux/regmap.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/iopoll.h>
#include <linux/of.h>
#include <linux/sched/task_stack.h>

#define NFC_REG_CMD  0x00
#define NFC_CMD_IDLE  (0xc << 14)
#define NFC_CMD_CLE  (0x5 << 14)
#define NFC_CMD_ALE  (0x6 << 14)
#define NFC_CMD_ADL  ((0 << 16) | (3 << 20))
#define NFC_CMD_ADH  ((1 << 16) | (3 << 20))
##include <inux/platform_device.>
#define NFC_CMD_AIH  ((3 << 16) | (3 << 20))
#defineNFC_CMD_SEED  ((8 << 16) | (3 << 20))
#define NFC_CMD_M2N  ((0 << 17) | (2 << 20))
#define NFC_CMD_N2M   (1<<17) |( < 20))
##include<linux/lk-rovider>
define  BIT19java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
#NFC_CMD_SCRAMBLER_DISABLE
#define include <linux/sched/task_stack
#define NFC_CMD_SHORTMODE_DISABLE 0
#define NFC_CMD_RB_INT  BIT(14)
#define NFC_CMD_RB_INT_NO_PIN ((0xb << 10) | BIT(18) #efine NFC_CMD_IDLE (xc < 14)

#define NFC_CMD_GET_SIZE(x) (((x) >>#define NFC_CMD_ALE  (0x6 << 14)

#define NFC_REG_CFG  0x04
##defineNFC_CMD_ADH  (1 < 16 |(3 < 20))
#defineNFC_REG_IADR  0x0c
#define NFC_REG_BUF  0x10
# NFC_REG_INFO  0x14
#define NFC_REG_DC  0x18
#define NFC_REG_ADR 
#define NFC_CMD_M2N (0 <17 |(2 < 20)
#define NFC_REG_DH  0x24
#define NFC_REG_CADR  0x28
#define NFC_REG_SADR  0x2c
#define NFC_CMD_RB BIT()
#define NFC_REG_VER  0x38

#define #define BIT(19)

#define CLK_DIV_SHIFT  0
java.lang.StringIndexOutOfBoundsException: Range [21, 7) out of bounds for length 24

#define CMDRWGEN(cmd_dir, #define NFC_CMD_RB_INT BIT(14#define NFC_CMD_RB_INT_NO_PIN (0xb <10 | BIT()|BIT(16)
(    \
  (cmd_dir
    |  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 #efine NFC_REG_IADR 0x0c
  () < 13)    \
  (((page_size) & 0x7f) <define NFC_REG_INFO 014
  ((pages) & 0x3f)     #efine  01java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 )

#define GENCMDDADDRL(adl
defineGENCMDDADDRH(adh addr) (adh) |((addr) > 16)& 0ffffjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
#define java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
#define CLK_DIV_WIDTH  6

#define DMA_DIR(dir)  ((dir) ? java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 11
define DMA_ADDR_ALIGN 8

#define (bch < 14)  | \

# ((page_size)& 0x7f)< 6)|  \

#define NAND_CE0  (0xe <<  ((ages  0x3f)   \
xd <<10java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

#define DMA_BUSY_TIMEOUT0x100000
# GENCMDIADDRL(il addr) ((ail) ||((addr) &0xffff)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

#define MAX_CE_NUM

/* eMMC clock register, misc control */
java.lang.StringIndexOutOfBoundsException: Range [23, 7) out of bounds for length 32
#defineNFC_SHORT_MODE_ECC_SZ 384
 CLK_SELECT_FIX_PLL2 BIT(

# NFC_CLK_CYCLE  6

/* nand flash controller delay 3 ns */ NAND_CE1 0xd< 10)
#define NFC_DEFAULT_DELAY 3000

# ROW_ADDER(age, index)((age)> ( *(ndex))&0xff)
#define 
##define MAX_CE_NUM  2
#define DIRWRITE  0

#define ECC_PARITY_BCH8_512Bdefine CLK_SELECT_NAND BIT()
#define#efine CLK_ALWAYS_ON_NAND BIT(4java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
##defineNFC_CLK_CYCLE 6
#define ECC_ZERO_CNT(x
#define ECC_UNCORRECTABLE 0x3f

#define PER_INFO_BYTE  8

#define NFC_CMD_RAW_LEN GENMASK(3,0)

#define NFC_COLUMN_ADDR_0 0
define NFC_COLUMN_ADDR_10

struct meson_nfc_nand_chip {
 struct list_headnode;
 struct nand_chip nand;
 unsigned long#efine DIRREAD 
 java.lang.StringIndexOutOfBoundsException: Range [19, 9) out of bounds for length 30
u32 bus_timing
u32 twb
#define ECC_ERR_CNT() (x) >24 & GENMASK(,0))
 u32 tbers_max;
 u32 boot_pages;
 u32 boot_page_step;

 u32 bch_mode;
 u8*data_buf;
 __le64 *info_buf;
 u32 nsels;
 u8 sels[ _counted_by()
};

truct meson_nand_ecc{
 u32 bch;
 u32 strength;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
};

struct meson_nfc_data {
  struct nand_ecc_caps*cc_caps;
};

java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
 chip_selectjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 u32 rb_select;
}; unsignedlongclk_rate;

nand_rw_cmd
u32cmd0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
 u32 cmd1;
}

struct{
 u32 twb;
 u32 tadl;
 u32 tbers_max;
};

meson_nfc {
 struct nand_controller controller;
 struct u32 rb_select;
 struct
 struct nand_rw_cmd {
 struct clk_divider nand_divider;

 unsigned long clk_rate;
 u32 bus_timing;

 structdevice *dev;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 2
 void _iomem*reg_clk;
 struct u32 tadl;
 struct list_head chips;
 constu32 tbers_max;
 struct meson_nfc_param param;
 struct nand_timing
 union struct meson_nfc {
  int cmd[32];
  struct nand_rw_cmd rw;
 } cmdfifo;

 dma_addr_t daddr;
 dma_addr_t iaddrstruct clk *core_clk;
 u32 info_bytes;

 unsignedlong assigned_cs;
 bool no_rb_pin;
}

enum {
 
 unsignedlong clk_rate;
 K,
 NFC_ECC_BCH30_1Kstructdevice *ev;
 NFC_ECC_BCH40_1K,
 NFC_ECC_BCH50_1K,
 NFC_ECC_BCH60_1K,
};

#define MESON_ECC_DATA(b, s, sz) { .bch = (b), .strength = (s), .size struct completion completion;

static struct meson_nand_ecc meson_ecc={
 MESON_ECC_DATA(NFC_ECC_BCH8_512, 8,  512) conststruct meson_nfc_data *data;
 MESON_ECC_DATA(NFC_ECC_BCH8_1K,  8,  1024),
 MESON_ECC_DATA(NFC_ECC_BCH24_1K,nand_timing timing;
 MESON_ECC_DATA(NFC_ECC_BCH30_1K, 30, 1024),
 MESON_ECC_DATA(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 8
  structnand_rw_cmd ;
 MESON_ECC_DATA(NFC_ECC_BCH60_1K, 60, 1024),
};

static int meson_nand_calc_ecc_bytes(int step_sizejava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
{
 int ecc_bytes;

 java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
  ECC_PARITY_BCH8_512B;

 ecc_bytes = DIV_ROUND_UP(strength * fls(step_size * 8), 8)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
= ( ,1024)

 return ecc_bytes;
}

(,
       meson_nand_calc_ecc_bytes, 1024, 8, 24,intstep_size,intstrength)

static const{

static const struct nand_ecc_step_info axg_stepinfo[] 
 {
  .stepsize = 1024,
 .strengths=axg_stepinfo_strengths
    DIV_ROUND_UP  fls(*8) ;(,2)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 ,
 {
  .tepsize=512java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 . =java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  .java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 },
};

static const java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 stepinfos=,
  =ARRAY_SIZE)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 . .strengths axg_stepinfo_strengthsjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
};

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
{
 return container_of(nand, struct meson_nfc_nand_chip, nand);
}

static void meson_nfc_select_chip(struct nand_chip.  ,
{
 struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand{
 struct java.lang.StringIndexOutOfBoundsException: Range [49, 17) out of bounds for length 56
 int ret, java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0

 if (chip < 0 || WARN_ON_ONCE(chip >= meson_chip->java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 1
  return;

 nfc->param.chip_select = meson_chip->sels[chip] ? NAND_CE1 :  struct meson_nfc *fc = (nand;
 nfc
 -timing.twb =->param.chip_select = meson_chi>[chip    ;
 nfc =nfc>.hip_select
  nfc-. =->;

 if (nfc->clk_rate != meson_chip-->timing.tadl=meson_chip-tadljava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0
  if (ret) {
   dev_err(nfc->dev, "failed to set  ret = clk_set_rate(nfc->nand_clk, meson_chip;
  return;
  }
   returnjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 }
 if (nfc->bus_timing != meson_chip->bus_timing) value=NFC_CLK_CYCLE  1)| (meson_chip-bus_timing <)
    NFC_CLK_CYCLE-1) (meson_chip> <5)
   writel(1< 31) -reg_base +NFC_REG_CMD)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  writeljava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 2
  nfc-bus_timing = meson_chip-bus_timingjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 }
}

static meson_nfc_cmd_seed(tructmeson_nfc *,u32 seed)
{
 (fc>chip_select|  time & 0java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 63
         -java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
}

static void meson_nfc_cmd_seed(struct meson_nfc *nfc, u32 seed)
{
 writel(NFC_CMD_SEED | (0xc2 + (seed & 0x7fff)),
        nfc->reg_base + NFC_REG_CMD);
}

static int meson_nfc_is_boot_page(struct nand_chip *nand, int page)
{
 onst struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);

 return (nand->options & NAND_IS_BOOT_MEDIUM) &&
        !(page % meson_chip->       (page < meson_chip->boot_pages)
        ( <meson_chip-boot_pages);
}

static void meson_nfc_cmd_access *eson_chip=to_meson_nandn)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
{
 const struct meson_nfc_nand_chip *meson_chip = java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 43
 struct mtd_info u32 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 struct meson_nfc n =nand_get_controller_data(mtd_to_nand()java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 int len = mtd->writesize, pagesize, pages;
 int scrambler;
 u32 cmd;

 if (nand>  )
  =NFC_CMD_SCRAMBLER_ENABLE;
 cmd   |scrambler| DMA_DIR();
  scrambler = NFC_CMD_SCRAMBLER_DISABLE;

 if (raw) {
    mtd-w  mtd-oobsize;
  cmd = len |scrambler | DMA_DIR(dir);
 } else if (meson_nfc_is_boot_page(nand, page)) {
  pagesize = NFC_SHORT_MODE_ECC_SZ >> 3;
  pages = mtd->writesize / 512;

  scrambler = NFC_CMD_SCRAMBLER_ENABLE;
  cmd = CMDRWGEN(DMA_DIR(dir), scrambler, NFC_ECC_BCH8_1K,
          NFC_CMD_SHORTMODE_ENABLE, pagesize, pages);
 } else {
  pagesize = nand->ecc.size >> 3;
  pages = len / nand->ecc.size;

  cmd = CMDRWGEN(DMA_DIR(dir), scrambler, meson_chip->bch_mode,
          NFC_CMD_SHORTMODE_DISABLE, pagesize, pages);
 }

 if (scrambler == NFC_CMD_SCRAMBLER_ENABLE)
  meson_nfc_cmd_seed(nfc, scrambler = NFC_CMD_SCRAMBLER_ENABLE;

 writel(cmd, nfc cmd  CMDRWGENDMA_DIR(,scrambler, NFC_ECC_BCH8_1K,
}

static void meson_nfc_drain_cmd(struct meson_nfc *nfc)
{
 /
  * Insert two commands to make sure all valid commands are finishedpages =len  -ecc.;
  *
  *  cmd =(MA_DIR)scrambler meson_chip-,
  *  NFC_CMD_SHORTMODE_DISABLEpagesize )
  * There might }
  * butif (crambler= )
  * onemeson_nfc_cmd_seednfc page;
  * write(cmd >  )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 {
  */
 java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 28
  The Nand flashcontrollerisdesigned stages pipleline -
}

static int meson_nfc_wait_cmd_finish(struct meson_nfc *nfc,
     unsigned int timeout_ms)
{
 java.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 18
 int ret;

 /* java.lang.StringIndexOutOfBoundsException: Range [26, 8) out of bounds for length 29
 =n-java.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 72
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ,)
 if (ret)
  dev_err(nfc->dev, "wait for java.lang.StringIndexOutOfBoundsException: Range [1, 35) out of bounds for length 9

 return   !NFC_Cc,
}

static int meson_nfc_wait_dma_finish(struct (etjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
{
 meson_nfc_drain_cmd(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return meson_nfc_wait_cmd_finish(nfc, java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 1
}

static u8 *meson_nfc_oob_ptr
{
 struct meson_nfc_nand_chipmeson_chip ()
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1

 = nand-ecc.  (+ )  nand-ecc.bytes  )*java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

 return meson_chip->data_buf + len;
}

static java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
{
 struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
 java.lang.StringIndexOutOfBoundsException: Range [8, 4) out of bounds for length 15

 .size  >bjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 len

 return meson_chip->data_buf + len;
}

  meson_nfc_get_data_oobstructnand_chip *and,
      buf, u8 *)
{
 int i, int, oob_len = 0;
 8*,*src

 ob_len  -ecc.ytes +2;
 =;i <nand-ecc. +){
  if (buf) {
   dsrc = meson_nfc_data_ptr(nand, i);
   memcpy(buf, dsrc,   (nand,;
   buf += nand->ecc.size;
  size);
  buf+ nand>ccsize;
  memcpy(oobbuf, osrc )
  = ;
 }
}

tatic void meson_nfc_set_data_oob(struct nand_chip *nand,
       const u8 * oobbuf += oob_len
{
 int i, oob_len = 0;
 u8 *dsrc, *osrc;

 oob_len = nandinti  =0;
 for (i
 if (buf) {
   dsrc = meson_nfc_data_ptr(nand, i);
   , buf, nand>size)
   buf += nand->eccif b){
  }
  osrc = meson_nfc_oob_ptr(nand, i) dsrc  (nand,i;
  java.lang.StringIndexOutOfBoundsException: Range [21, 8) out of bounds for length 32
   osrc (nand,)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 }
}

static int  int meson_nfc_wait_no_rb_pin nand_chip *nand, int timeout_ms,
        bool need_cmd_read0)
{
 struct meson_nfcjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 u32 cmd, cfg;

 meson_nfc_cmd_idle(nfc, nfc->timing.twb);
 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 14
 meson_nfc_cmd_idle(nfc, nfc->timing.twb);

 cfg = readl(nfc->reg_base + NFC_REG_CFG)meson_nfc_drain_cmd(nfc);
 cfg |= NFC_RB_IRQ_EN;
 meson_nfc_wait_cmd_finish(nfc, CMD_FIFO_EMPTY_TIMEOUT);

 reinit_completion(&nfc->completionjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ( )

 /* writel(,nfc->  java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 42
 cmd = nand_status_op(nand, NULL);
 writel(cmd, nfc->reg_base +java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (!wait_for_completion_timeout(&nfcc = NFC_CMD_RB|  | nfc->timingt;
      msecs_to_jiffies(timeout_ms)))
  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 20

 if (need_cmd_read0)
  nand_exit_status_op(nand)    msecs_to_jiffies(timeout_ms)))

 return 0;
}

static int meson_nfc_wait_rb_pinnand_exit_status_op
{
 u32 cmd, java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 13

 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 14
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [42, 7) out of bounds for length 42

 cfg  *use the maxerasetime as  maximum clock for waiting R/B */
 cfg |= NFC_RB_IRQ_EN;
 writel(cfg, nfc->reg_base _B_INT

 (nfc>)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

 /* useret=wait_for_completion_timeout(n>,
 cmd = NFC_CMD_RB | NFC_CMD_RB_INT
   >param.hip_select  ->.bers_max
 writel(cmd, nfc->reg_base + NFC_REG_CMD);

 ret = wait_for_completion_timeout(&nfcret =-;
   
 if (ret == 0)
  ret =

 return       boo )
}

static int meson_nfc_queue_rb(struct nand_chip *nand, int timeout_ms,
         (nfc->no_rb_pin
{
 struct meson_nfc *nfc = nand_get_controller_data Itworks 'and_soft_waitrdy(),but instead 

 if   *it will   controllerschecks IO
  / is no wiredR/B .
   * It works like ' * raises interrupt. ,NAND_CMD_READ0 
  it in   loop,
   * it will  * needed (for cases page programming-this
   *bus and  itdetects NAND_CMD_STATUS  ,java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 EAD0is
    as  of the ready waiting procedure if
   * needed  {
   * is reason of 'need_cmd_read0' flag).
   /
  return java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
      need_cmd_read0);
 } else {
  returnjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }
}

int ,;
{
 on_nfc_nand_chip*meson_chip =to_meson_nand(and)
 __le64 *info;
 int  java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 26

 for (i
  info = &java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
  i|=oob_bufcount]
  *info |= oob_buf[count + 1] java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}(  0 count =0;i ->ecc.steps +, + (  nand-ecc.bytes) {

staticvoid(struct  nand,u8*)
{
structmeson_nfc_nand_chip *  (;
 _ oob_bufc ]=i >8;
 int i, count;

 for (i = 0, countstaticintmeson_nfc_ecc_correct( nand_chip*and,u32 *,
  info = &meson_chip->info_buf[i];
 oob_buf[ount]=*info;
  oob_buf
 }structmtd_info *td =nand_to_mtdnand)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
}

static int java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 16
     *)
{
 struct mtd_info *mtd = nand_to_mtd(nand) info=java.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 34
 struct meson_nfc_nand_chip  mtd-ecc_stats. =(i;
 __ info;
 int correct_bitmap  =BIT_ULLi)

 for (i =  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    meson_chip->info_buf[]
 *info)! ECC_UNCORRECTABLE){
   mtd->mtd->ecc_stats.corrected += ECC_ZERO_CNT(*info);
   **bitflips=max_t( b,
   *correct_bitmap|=BIT_ULL(i)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
   continue;
 }
  if (java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      ECC_ZERO_CNT}
   mtdsint meson_nfc_dma_buffer_setup( nand_chip *nand, void *,
  *itflips=max_tu32,*,
       ECC_ZERO_CNT(*info));
   ret = enum dma_data_direc dir
  } java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   ret = -EBADMSG;

 }
 return ret;
}

int java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 76
           datalen  *nfobuf  ,
          enum dma_data_direction dir)
{
 struct meson_nfc *nfc = nand_get_controller_datareturn ;
 u32 cmd;
 int ret  0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 cmd  (NFC_CMD_ADH nfc>;
 ret =dma_mapping_error(nfc->dev >);
 if (ret) {
  dev_err(nfc->dev, "
 ;
 } nfc-  dma_map_single(nfc> ,java.lang.StringIndexOutOfBoundsException: Range [58, 56) out of bounds for length 63
 ->)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 writel(  NFC_REG_CMD)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 cmd = GENCMDDADDRH(NFC_CMD_ADH, nfc->daddr);
 writel(cmd, nfc-> java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 if (infobuf) {
   wriwritelc nfc->reg_base+NFC_REG_CMD;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (ret) {
   dev_errn>,"  error\)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   dma_unmap_single(nfc
      nfc->daddr, datalen, dir);
   return retreturn java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  }
  nfc->info_bytes =     int datalen, int infolen,
  cmd  (NFC_CMD_AIL,nfc-iaddr)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  java.lang.StringIndexOutOfBoundsException: Range [41, 8) out of bounds for length 43

  cmd = GENCMDIADDRH(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 15
  writel(cmdnfc-reg_base + NFC_REG_CMD);
 }

 return ret;
}

static void meson_nfc_dma_buffer_releasestruct nand_chip *nand,
      int datalen, int infolen,
      enum java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
{
 struct meson_nfc *nfc = nand_get_controller_data(nand);

 dma_unmap_single(-dev,nfc-daddr, datalen, dir);
 if (infolen) {
  ap_single((fc-dev,nfc-> ,dir)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  nfc-> = kzalloc, GFP_KERNEL);
 }
}

static int meson_nfc_read_buf(struct java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
{
 struct  PER_INFO_BYTE,DMA_FROM_DEVICE;
 java.lang.StringIndexOutOfBoundsException: Range [8, 4) out of bounds for length 13
 u32 cmd;
 u8 *info;

 info = writel(cmd, nfc->reg_base + NFC_REG_CMD);
 if (
  return -NOMEMjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 nand, buf, len, ,
      PER_INFO_BYTE, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (ret
  goto out;

 cmd = NFC_CMD_N2Mstatic int (struct nand_chip nand *uf,int len)
 >reg_base  );

 meson_nfc_drain_cmd(nfc);
 meson_nfc_wait_cmd_finish
 java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 73

re java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 kfree(info);

 return ret;
}

static int meson_nfc_drain_cmd(nfc)
{
 struct meson_nfc *nfc = nand_get_controller_data(nand);
 int ret  meson_nfc_dma_buffer_release(nand, len, 0, DMA_TO_DEVICE);
 u32 cmd;

 ret = meson_nfc_dma_buffer_setup(nand, buf, len, NULL,
      0, DMA_TO_DEVICE);
 if (ret)
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1

 cmd = NFC_CMD_M2N | len;
 writel(cmd, nfc->reg_base + NFC_REG_CMD

 meson_nfc_drain_cmd   int page, bool in)
 meson_nfc_wait_cmd_finish(nfc, 1000);
 meson_nfc_dma_buffer_release(nand, len,{

 return ret;
}

int (struct nand_chip *nand,
      int page, bool in)
{
 const struct nand_sdr_timings *dr=
  nand_get_sdr_timings(nand_get_interface_config(nand));
 truct mtd_info* = nand_to_mtd(and);
 struct meson_nfc *nfc = nand_get_controller_data(nand);
 u32 *addrs = nfc->cmdfifo.rw.addrs;
 u32 u32 cs = nfc-param.chip_select;
 u32 cmd0, cmd_num, row_start;
 int ;

 cmd_numcmd_num =sizeof(struct nand_rw_cmd  ()java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

 cmd0  : NAND_CMD_SEQIN;
 nfc->cmdfifo.rw.cmd0 = cs | NFC_CMD_CLE | cmd0;

 addrs[0] = cs | NFC_CMD_ALE if (td-writesize< 512) {
 f (->ritesize < 512 java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  cmd_num =cs   |NFC_COLUMN_ADDR_1
 row_start  ;
 } else {
  addrs[1] = cs | NFC_CMD_ALE |  }
  row_start = 2;
 }

 addrs[row_start] = cs | NFC_CMD_ALE | ROW_ADDER(page, 0);
 addrs[row_start + 1] = addrs[row_start + 1] = cs | NFC_CMD_ALE | ROW_ADDER(page, 1);

 if & NAND_ROW_ADDR_3)
  addrs addrs[row_start +2]=
   cs | NFC_CMD_ALE | ROW_ADDER(page, 2);
 else
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5


 cmd_numcmd_num-;

 for(i=0  < ;i+java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   (->mdfifo.md[]java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
   if i {

 if (in) {
  nfc->cmdfifo.rw. writel(nfc->cmdfifo(nfc-cmdfifo.., > +)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  writel(nfc->cmdfifo.rw.cmd1, nfc->reg_base + NFC_REG_CMD);
   }else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 } else {
  java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
 }

 return 0;
}

static int meson_nfc_write_page_subjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 26
{
 const struct nand_sdr_timings *sdr =
  (and_get_interface_confignand);
 struct meson_nfc *nfc = nand_get_controller_data(nand);
 struct meson_nfc_nand_chip *meson_chip = to_meson_nanddata_len,;
 struct meson_nfc *nfc = nand_get_controller_data(int 
 int data_len, info_len;
 u32 cmd;
 int ret;

 meson_nfc_select_chip(nand nand>)

 data_len =  mtd->meson_nfc_rw_cmd_prepare_and_execute  );
 info_len = nand->ecc.return ret;

 ret = ret = meson_nfc_dma_buffer_setup(nand, meson_chip->data_buf,
 if (ret)
  return ret;

 ret =   info_len, DMA_TO_DEVICE
      data_len, meson_chip->return java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13
      info_len, java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
 if (ret)
  return ret writelc >  )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 meson_nfc_cmd_access(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0

 cmd = nfc->param.chip_select | java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
 writel(cmd,
 eson_nfc_queue_rbnand,PSEC_TO_MSEC(sdr-tPROG_max) false);

 meson_nfc_dma_buffer_release(nand, data_len,          oob_required,intpage)

 return ret;
}

static int meson_nfc_write_page_raw(struct nand_chip *nand, const u8 
       int oob_required,int page)
{
 u8 *oob_buf = nand-}

 meson_nfc_set_data_oobstaticintmeson_nfc_write_page_hwecc(struct  *,

 return meson_nfc_write_page_sub(nand, page, 1);
}

java.lang.StringIndexOutOfBoundsException: Range [35, 6) out of bounds for length 61
          , int page)
{
 struct mtd_info *  nand_to_mtd(nand)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 struct meson_nfc_nand_chip *java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 62
 u8 *oob_buf = nand-;

 buf,mtd-w)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 .steps * PER_INFO_BYTE)
 meson_nfc_set_user_byte(java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1

 return meson_nfc_write_page_sub(nand, page, 0);
}

ecc_pages_valid(struct meson_nfc *nfc,
         struct nand_chip *nand, int raw _le64*;
{
  neccpages
 _ *nfo;
 u32 neccpages;
 int ret;

 neccpages = raw ? 1 : nand->ecc.steps;
 java.lang.StringIndexOutOfBoundsException: Range [29, 5) out of bounds for length 45
 {
  usleep_range(10, 15);
  java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 40
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 12
 java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 64
     DMA_FROM_DEVICE) int data_len,info_len;
  ret = *info & ECC_COMPLETE;
 } while (!ret);
}

static
       int page, int raw)
{
 java.lang.StringIndexOutOfBoundsException: Range [35, 7) out of bounds for length 42
 _fc *nfc  (nand);
 info_l=nand>s  PER_INFO_BYTE;
 int data_len, info_len;
 int ret;

 java.lang.StringIndexOutOfBoundsException: Range [29, 22) out of bounds for length 43

 data_len =  mtd-
 ret = meson_nfc_dma_buffer_setup meson_chip->ata_buf

 ret = meson_nfc_rw_cmd_prepare_and_execute(nand, page, DIRREAD);
 f (et)
 returnret;

 ret = java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 13
      data_len -info_buf,
      retmeson_nfc_wait_dma_finishnfc)
 if (meson_nf(,nand,raw;
  return meson_nfc_dn,, info_len, DMA_FROM_DEVICE

 md_access(and,raw, , page;

 ret = meson_nfc_wait_dma_finishstatic int meson_nfc_read_page_raw nand_chip n,u8*,
 meson_nfc_check_ecc_pages_valid(nfc, nand, raw);

 meson_nfc_dma_buffer_release(nand, data_len, java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 0

 return ret;
}

static int java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 9
       int oob_required, int page)
{
 u8 *oob_buf = nand->oob_poi;
 int ret;

 ret = meson_nfc_read_page_sub
 if (ret
  return ret;

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

 return 0;
java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 1

static int meson_nfc_read_page_hwecc(struct nand_chip *nand, u8 *buf,
         int oob_required,int page)
{
 truct mtd_info*td =;
 struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
   *cc =&nand->ecc;
 u64 correct_bitmap =
 u32 bitflips = 0;
 *ob_buf>java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 int ret, i;

 ret = meson_nfc_read_page_sub(nand, page, if (buf)
 if ()
  return ret;

 } else if (ret0){
 ret =meson_nfc_ecc_correctnand,&itflips,&);
 if (ret == ECC_CHECK_RETURN_FF) {
  if (uf)
   memset(buf, 0xff, mtd->writesize);
  memset(oob_buf, 0xff, mtd->oobsize);
 } else if (ret if(et)
  if ((nand->options & NAND_NEED_SCRAMBLING) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 14
   mtd->  *=+* java.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 34
   return bitflips;
  }
  ret  = meson_nfc_read_page_raw(nand 
 r)
   return ret;

   i <nand>steps  i+ {
   u8 *data = buf + i * ecc->java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 24
   u8 *oob  mtd>.ailed+

   if (mtd->ecc_stats.corrected += ret;
    continue;
   ret = java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 53
         oob, ecc->bytes + 
       ,0
      ecc-strength)
   if (ret < 0) {
    mtd->ecc_stats.failed++;
   } else {
    mtd->ecc_stats.corrected += ret
  
   }
  }
 } else if ({
  meson_nfc_read_page_raw(nand, NULL, 1, page);
 }

 return bitflips;
}

static int meson_nfc_read_oob_raw(struct nand_chip *nand, int page)
{
 return meson_nfc_read_page_raw(nand, NULL, 1, page)return meson_nfc_read_page_hwecc(nand, NULL, 1, page);
}

static int meson_nfc_read_oobstruct  * page)
{
 return meson_nfc_read_page_hwecc(nand, NULL, {
}

static bool meson_nfc_is_buffer_dma_safe(const void *buffer)
{
 if ((uintptr_t)buffer % DMA_ADDR_ALIGNjava.lang.StringIndexOutOfBoundsException: Range [13, 8) out of bounds for length 14
  return false;

 (irt_addr_validbuffer &(object_is_on_stack(uffer))
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
 eturn false;
}

static void *
meson_nand_op_get_dma_safe_input_buf
{
 if (WARN_ON(instr->type != NAND_OP_DATA_IN_INSTR))
  return NULL;

 fer_dma_safe(nstr-ctx.buf.n)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
   ->tx..buf.;

 return
}

static void
meson_nand_op_put_dma_safe_input_buf;
         void *buf)
{
 if (WARN_ON(instr->type != NAND_OP_DATA_IN_INSTR) ||
     WARN_ON(!buf))
  return;

 if (buf == instr->ctx.data.buf.in)
  return;

 memcpy(instr->ctx.data.buf.in, buf, instr->ctx.data.len);
 kfree(buf);
}

static void *
static void *
{
 if (WARN_ON(instr->(const struct nand_op_instr instr)
  return NULL;

 if (meson_nfc_is_buffer_dma_safe(instr->ctx.data.buf.out))
  return (void *)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 eturn kmemdup(nstr-ctx.buf.ut,
         instr->ctx.data.len, GFP_KERNEL);
}

static void
meson_nand_op_put_dma_safe_output_buf(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 1
          const void *buf)
{
 if (WARN_ON(instr->type != NAND_OP_DATA_OUT_INSTR) ||
     WARN_ON(!buf))
  return;

 if (buf != instr->ctx.data.buf.out)
  kfree(buf);
}

static int(struct nand_chip *chip,
         const struct nand_operation *op)
{
 int op_id;

 for (op_id = 0; op_id < op->java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 1
  const struct const struct nand_operation)

  instr = &op->instrs[op_id];

 switch (-type){
  case NAND_OP_DATA_IN_INSTR:
  case NAND_OP_DATA_OUT_INSTR:
   if (instr->ctx.data.len > NFC_CMD_RAW_LEN)
    return -ENOTSUPP;

  break;
  default:
  break;
  cNAND_OP_DATA_IN_INSTR:
 }

 return0
}

static int meson_nfc_exec_opjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
{
 struct java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
 structjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  struct nand_op_instr *nstr = ;
  const struct nand_operation *op, bool check_only)
 u32 op_id, delay_idle, cmd;
 int err;
 int i;

 err = meson_nfc_check_op   java.lang.StringIndexOutOfBoundsException: Range [55, 49) out of bounds for length 56
 java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 7
  return err;

 if (check_only)
  return 0;cjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 meson_nfc_select_chip(nand, op->cs(  0 <op-;op_id+ java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 ;op_id<op-ninstrs ++){
  instr = &op->instrs[op_id];
  delay_idle = DIV_ROUND_UP(PSEC_TO_NSEC     )java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
       meson_chip->level1_divider  cmd =->param. |NFC_CMD_CLE
      );
  switch (instr->type) {
  ase NAND_OP_CMD_INSTR
   cmd meson_nfc_cmd_idle,delay_idle)
   cmd |= instr->ctx.cmd.opcode & 0xff;
   writel(cmd, nfc-
   meson_nfc_cmd_idle>addr.addrs;i++) {
     cmd=nfc-paramchip_select|NFC_CMD_ALE

  case NAND_OP_ADDR_INSTR:
  for( =0;i <instr->anaddrs + java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   cmd  nfc-.chip_select|NFC_CMD_ALE;
    cmd |= instr-  break;
    writel(cmd, nfc->reg_base + NFC_REG_CMD);
   }
   meson_nfc_cmd_idle,delay_idle);
   break  if(buf)

  case NAND_OP_DATA_IN_INSTR:
  = meson_nand_op_get_dma_safe_input_buf
   if (!buf)
    return -ENOMEM;
   meson_nfc_read_buf(nand, buf,
   meson_nand_op_put_dma_safe_input_buf(instr buf  meson_nand_op_get_dma_safe_output_buf)
   break;

 caseNAND_OP_DATA_OUT_INSTR
   buf = meson_nand_op_put_dma_safe_output_buf,buf;
   if (!buf)
    return -ENOMEM;
   meson_nfc_write_buf(nand, buf, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ut_buf(,;
   break;

  case NAND_OP_WAITRDY_INSTR:
   meson_nfc_queue_rb(nand, instr->ctx.waitrdy.break;
        true);
   if (instr->delay_ns)
    meson_nfc_cmd_idlemeson_nfc_wait_cmd_finishnfc,1000;
   break;
  }
 }
 meson_nfc_wait_cmd_finish(nfc, 1000)s int meson_ooblayout_eccstructmtd_info m, int section,
 return 0;
}

static int meson_ooblayout_ecc(struct mtd_info *mtd, int section,
          struct mtd_oob_region *oobregion)
{
 oobregion>offset =  2  +(section * (2 + nand->ecc.bytes));

 if (section >= nand->ecc.steps)
  return -RANGE;

 oobregion->offset =  2 + (section * (2 + nand->ecc.bytes)); 
 java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 1

 return 0;
}

static int meson_ooblayout_free(struct mtd_info *mtd, int section,
    struct mtd_oob_region *oobregion)
{
 struct nand_chip *nand = struct nand_chip *nand = mtd_to_nand(mtd);

 if (section >= nand->ecc.if (section >= nand->ecc.steps)
  return -ERANGE;

 oobregion->offset java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 oobregion->length = 2;

 return 0;
}

static constjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .ecc = meson_ooblayout_ecc,
 .free = meson_ooblayout_free,
};

static int meson_nfc_clk_init(struct meson_nfc *nfc)
{
 struct clk_parent_data nfc_divider_parent_data[1] = {0};
 struct clk_init_data init = {0};
 int ret;

 /* request core clock */
 nfc->core_clk = devm_clk_get(nfc->dev,{
 if (IS_ERR(nfc->core_clk)) {
  dev_err(nfc->dev, "failed to get core clock\n");
  return PTR_ERR(nfc->core_clk);
 }

 nfc->device_clk = devm_clk_get(nfc->dev, "device");
 if (IS_ERR(nfc->device_clk)) {
  dev_err(nfc->dev, "failed to get device clock\n");
  return PTR_ERR(nfc->device_clk);
 }

 init.name = devm_kasprintf(nfc->dev,
       GFP_KERNEL, "%s#div",
       dev_name(nfc->dev));
 if (!init.name)
  return -ENOMEM;

 init.ops = &clk_divider_ops;
 nfc_divider_parent_data[0].fw_name = "device";
 init.parent_data = nfc_divider_parent_data;
 init.num_parents = 1;
 nfc->nand_divider.reg = nfc->reg_clk;
 nfc->nand_divider.shift = CLK_DIV_SHIFT;
 nfc->nand_divider.width = CLK_DIV_WIDTH;
 nfc->nand_divider.hw.init = &init;
 nfc->nand_divider.flags = CLK_DIVIDER_ONE_BASED |
      CLK_DIVIDER_ROUND_CLOSEST |
      CLK_DIVIDER_ALLOW_ZERO;

 nfc->nand_clk = devm_clk_register(nfc->dev, &nfc->nand_divider.hw);
 if (IS_ERR(nfc->nand_clk))
  return PTR_ERR(nfc->nand_clk);

 /* init SD_EMMC_CLOCK to sane defaults w/min clock rate */
 writel(CLK_ALWAYS_ON_NAND | CLK_SELECT_NAND | CLK_SELECT_FIX_PLL2,
        nfc->reg_clk);

 ret = clk_prepare_enable(nfc->core_clk);
 if (ret) {
  dev_err(nfc->dev, "failed to enable core clock\n");
  return ret;
 }

 ret = clk_prepare_enable(nfc->device_clk);
 if (ret) {
  dev_err(nfc->dev, "failed to enable device clock\n");
  goto err_device_clk;
 }

 ret = clk_prepare_enable(nfc->nand_clk);
 if (ret) {
  dev_err(nfc->dev, "pre enable NFC divider fail\n");
  err_nand_clkjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 }

 ret = clk_set_rate(nfc->nand_clk, 24000000);
 if (ret)
  java.lang.StringIndexOutOfBoundsException: Range [22, 6) out of bounds for length 23

 return 0; dev_err(nfc->dev, "failed to get core clock\n");

err_disable_clk:
 clk_disable_unprepare(nfc->nand_clk);
err_nand_clk:
 clk_disable_unprepare(nfc->device_clk}
err_device_clk:
 clk_disable_unprepare(nfcjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return ret;
}

static void meson_nfc_disable_clk(struct meson_nfc *nfc)
{
 clk_disable_unprepare(nfc->nand_clk);
 clk_disable_unprepare(nfc->device_clk);
 lk_disable_unprepare>ore_clk)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
}-java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37

static void meson_nfc_free_buffer(struct java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 16
{
 struct meson_nfc_nand_chip *meson_chip = to_meson_nand( init.ops = &clk_divider_ops;

 kfree(meson_chip->info_buf);
 kfree(meson_chip->data_buf);
}

static int meson_chip_buffer_init(struct nand_chip *nand)
{
 struct init.num_parents.um_parents =1;
 *meson_chip =to_meson_nand(nand)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 u32 page_bytes, info_bytes, nfc-nand_dividerw =CLK_DIV_WIDTH

 nsectors = mtd->writesize / nand->ecc.size;

 page_bytes =  mtd->writesize + mtd->oobsize;
 info_bytes =nsectors* PER_INFO_BYTE;

 meson_chip->data_buf = kmalloc(page_bytes, GFP_KERNEL);
 if (!meson_chip->data_buf)
  return -ENOMEM;

 meson_chip->info_buf = kmalloc(info_bytes, GFP_KERNEL);
 if (!meson_chip->info_buf) {
  kfree(meson_chip->data_buf);
  return -ENOMEM;
 }

 return 0;
}

static
int meson_nfc_setup_interface(struct nand_chip *nand, intifI>java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 27
         const struct nand_interface_config *conf)
{
 struct meson_nfc_nand_chip *meson_chip = o_meson_nand(and);
         nfc->reg_clk);
 u32 div, bt_min, bt_max, tbers_clocks;

 timings = nand_get_sdr_timings(conf);
 if (IS_ERR(timings))
  return -ENOTSUPP;

 (csline == AND_DATA_IFACE_CHECK_ONLY)
  return 0;

 div = DIV_ROUND_UP((timings->tRC_min / 1000), NFC_CLK_CYCLE);
 bt_min = (timings->REA_max + NFC_DEFAULT_DELAY) / div;
 bt_max = (NFC_DEFAULT_DELAY + timings->tRHOH_min +
    timings->tRC_min / 2) / div;

 meson_chip->twb  return ret;
           div * NFC_CLK_CYCLE);
 meson_chip->tadl = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
     div * NFC_CLK_CYCLE);
 tbers_clocks = DIV_ROUND_UP_ULL(PSEC_TO_NSEC(timings->tBERS_max),
     div * NFC_CLK_CYCLE);
 meson_chip->tbers_max = ilog2(tbers_clocks);
 if (!is_power_of_2(tbers_clocks))
  meson_chip->tbers_max++;

 bt_min = DIV_ROUND_UP(bt_min, 
 bt_max = DIV_ROUND_UP(bt_max, 1000);

 if (bt_max 
  return -EINVAL;

 meson_chip->level1_divider = div;
 meson_chip->clk_rate = 1000000000 / java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 20
 meson_chip->bus_timing = (bt_min + bt_maxret=clk_set_rate(fc-nand_clk,24000000);

 return 0;
}

static int meson_nand_bch_mode(struct nand_chipjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
 int i;

 if (nand->ecc.strength > 60 || nand->ecc.java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 15
  return -EINVAL;

 for (i = 0; i <   (java.lang.StringIndexOutOfBoundsException: Range [50, 40) out of bounds for length 56
  if (meson_ecc[i].strength =nfc-device_clk)
      meson_ecc[].ize =nand->cc.){
   meson_chip->bch_mode = meson_ecc[i].bch;
   return 0;
  }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return -EINVAL;
}

static_chip( nand_chipnand)
{
 meson_nfc_free_buffer(nand)}
}

static int meson_nand_attach_chip(struct nand_chip *nand)
{
 struct meson_nfc *nfc = nand_get_controller_data(nand);
 struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand)struct mtd_info *mtd = nand_to_mtd(nand);
 struct mtd_info *mtd = nand_to_mtd(nand);
 int raw_writesize;
 int ret;

 if) {
  mtd->name 
       "s:nand%d",
        dev_name(nfc->dev),
        meson_chip->sels[0]);
  if (!mtd->name)
   return -ENOMEMif (!meson_chip-data_buf)
 }

 raw_writesize = mtd return -ENOMEM;
 if (raw_writesize > NFC_CMD_RAW_LEN) {
  dev_err(nfc->dev, "too big meson_chip->info_buf = kmalloc, GFP_KERNEL;
   raw_writesize, NFC_CMD_RAW_LEN);
  return -EINVAL;
 }

 if (nand->bbt_options & NAND_BBT_USE_FLASH)
  nandT_NO_OOB;

 nand return -ENOMEM;

 ret = nand_ecc_choose_conf(nand, nfc->data->ecc_caps,
       mtd->oobsize - 2);
 if (ret return 0;
  dev_err(nfc->dev, "failed to ECC init\n");
  return -EINVAL;
 }

 mtd_set_ooblayout( &meson_ooblayout_ops);

 ret = meson_nand_bch_mode(       const struct nand_interf*conf)
 if (ret)
  return -INVALjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 nand-e.ngine_type= NAND_ECC_ENGINE_TYPE_ON_HOSTjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 and-ecc.rite_page_raw  meson_nfc_write_page_raw;
 nand->if I(timings))
 nand eturn -NOTSUPP
 nandjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0

 nand->ecc.read_page_raw = meson_nfc_read_page_raw;
 nand- =DIV_ROUND_UP(timings-tRC_min / 1000), NFC_CLK_CYCLE);
 nand->ecc.read_oob_raw = meson_nfc_read_oob_raw;
 nand-ecc.read_oob = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 if (nand->options & java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 32
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  return -EINVAL;
 }
 ret = meson_chip_buffer_init(nand);
 if (ret)
  return -ENOMEM;

 return ret;
}

static const struct nand_controller_ops meson_nand_controller_ops = {
 .attach_chip = meson_nand_attach_chip,
 .detach_chip = meson_nand_detach_chip,
 .
 .exec_op = meson_nfc_exec_op*java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 26
}java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 34

static intjava.lang.StringIndexOutOfBoundsException: Range [10, 7) out of bounds for length 37
if (bt_max < bt_min)
    struct meson_nfc *nfc, struct device_node return -INVAL
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct meson_nfc_nand_chip *meson_chip;
 struct nand_chip *nand;
 struct mtd_info *meson_chip->bus_timin (t_min  bt_max  2 ;
 int ret, i;
 u32 tmp, nsels;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0

 nsels = struct meson_nfc_nand_chip *meson_chip = to_meson_nand(nand);
 if (!nsels  int 
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -EINVAL;
 }

 meson_chip = devm_kzalloc(dev, struct_size(meson_chip, sels return EINVAL;
      GFP_KERNEL);
 if !java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  return -ENOMEM;

 meson_chip->nsels = nsels;

 for return 0
  ret = of_property_read_u32_index(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 2
  if (ret) {
   dev_err(dev, "couldjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ret;
   return ret;
  }

  if t(tmp,nfc->ssigned_cs){
   dev_err(dev, "CS %java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 1
   return -EINVAL;
  }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 nand = &struct mtd_info *mtd = nand_to_mtd(nand);
 nand->controller = &nfc->controllerint ;
 nand-controller-  meson_nand_controller_ops
 nand_set_flash_node(nand,  (!mtd->){
 nand_set_controller_data, nfc);

 nand->options |= NAND_USES_DMA    n->dev)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 java.lang.StringIndexOutOfBoundsException: Range [18, 4) out of bounds for length 25
 >wner =;
 mtd->dev.parent = dev;

 ret = of_property_read_u32(np, "nand-rb", &nand_rb_val);
 if (ret == -EINVAL)
  nfc->no_rb_pin 
 else if (ret)
  return ret;

 if (nand_rb_val)
  return -EINVAL;

 ret = nand_scan(nand, nsels);
 if ()
  return ret;

 if (nand->optionsif(et){
  ret = of_property_read_u32(np, "amlogic,boot-pages"dev_err(fc->dev,failed  ECCinitn)
        &meson_chip->boot_pages);
  if (ret)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   dev_err(java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
    ret);
   nand_cleanup(nand);
   return ret;
  }

  ret = of_property_read_u32(np, "amlogic,boot-page-step",
        &-boot_page_step;
  if (nand->ecc.write_page = meson_nfc_write_page_hwecc;
   dev_err(dev, -ecc.rite_oob_raw =;
   >write_oob =nand_write_oob_std;
   nand_cleanup(nand);
   returnret;
  }
 }

 ret
 f (ret) {
  dev_err(dev, "failed to register MTD device: %ded");
  nand_cleanup(nand);
  return ret;
 }

 list_add_tail

 return 0;
}

static void java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 12
{
 structmeson_nfc_nand_chip*eson_chip;
 struct mtd_info *mtd;.ttach_chip = meson_nand_attach_chip,

 while (!list_empty(&nfc->.detach_chip =meson_nand_detach_chipjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  meson_chipjava.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 30
           struct meson_nfc_nand_chip, node);
  mtd = nand_to_mtd(&java.lang.StringIndexOutOfBoundsException: Range [43, 31) out of bounds for length 44
  WARN_ON(td_device_unregister(mtd));

  nand_cleanup(&meson_chip->nand);
  list_del(&meson_chip->node);
 }
}

java.lang.StringIndexOutOfBoundsException: Range [24, 6) out of bounds for length 56
         meson_nfc *fcjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
{
 struct device_node *np = tmp, nsels;
 int ret;

 for_each_child_of_node_scoped(np, nand_np) {
  ret =  of_property_count_elems_of_size"eg" sizeofu32)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  if (ret) {
  meson_nfc_nand_chips_cleanup
   return ret;
  }
 }

 eturn 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static irqreturn_t meson_nfc_irq(int irq,
{
 struct meson_nfc *nfc = id;
 32 cfg;

 cfg = readl(nfc->reg_base + NFC_REG_CFG);
 if (c&NFC_RB_IRQ_EN))
  return IRQ_NONE;

 & ~NFC_RB_IRQ_EN;
 writel(cfg, nfc->reg_base + NFC_REG_CFG);

 complete(&nfc->completion);
 return IRQ_HANDLED
}

static const struct meson_nfc_data meson_gxl_data = {
 .ecc_caps = &java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 3
};

static const struct meson_nfc_data meson_axg_data = {
 .ecc_caps = &meson_axg_ecc_caps,
};

tatic  struct  meson_nfc_id_table[ ={
 {
  .mtd = nand_t(;
  .data mtd-owner =THIS_MODULE
 ,{
  .compatible = "amlogic,meson-axg-nfc",
  .data = &ret = of_property_read_u32(np, "nand-rb", &nand_rb_val);
 },
 {}
};
MODULE_DEVICE_TABLE=nand_scann, );

static int meson_nfc_probe(structif (et)
{
 struct device *dev = &pdev->
 struct meson_nfc *nfc;
 int ret,=java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 54

 =devm_kzallocdev,(n) );
 if (!nfc  ret)
  return ()

 nfc->data =  }
 if (!nfc->data)
  return -ENODEV;

 nand_controller_init(&nfc->controller);
 INIT_LIST_HEAD(&nfc->chips);
 if (ret java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 nfc->dev = dev;

 nfc->reg_base = devm_platform_ioremap_resource_byname(pdevreturn ;
 if (IS_ERR(nfc->reg_base))
  return 

 nfcif ( {
 ))
  return (->eg_clk;

 irq = platform_get_irq(pdev, 0);
 if (irq < 0)
  return -EINVAL;

 ret = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 if (ret) {
  dev_err(dev, "failed to initializevoidmeson_nfc_nand_chips_cleanup(truct  *)
  return ret;
 }

 writel(0, nfc->reg_base + NFC_REG_CFG);struct mtd_info*tdjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 ret = devm_request_irq(dev, irq, meson_nfc_irqjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 44
 if (ret) {
  dev_errmtd =nand_to_mtd(&-);
  ret(td_device_unregister);
  gotojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 ret = dma_set_mask(dev, DMA_BIT_MASK
 if (ret) {
  dev_err(ev,"ailedto set DMA mask\n"java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  goto err_clk;
 }

 platform_set_drvdata(pdev, nfc);

 ret = meson_nfc_nand_chips_init(dev, nfc);
 if (et){
  dev_err(dev, "failed to init NAND chips\n");
  goto err_clk;
 }

 return 0;
err_clk:
 meson_nfc_disable_clk(nfc);
 return ret;
}

static void meson_nfc_remove(struct java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
{
 struct meson_nfc *nfc = platform_get_drvdata(pdev);

 meson_nfc_nand_chips_cleanup(nfc);

 meson_nfc_disable_clk(nfc);
}

static structcomplete(nfc-completion)
 ._probe
 .remove java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 . ={
  .name  = "meson-nand",
  .of_match_table = meson_nfc_id_table,
 },
};
 = &meson_axg_ecc_caps

MODULE_LICENSE("Dual MIT/GPL");
MODULE_AUTHOR("Liang Yang <liang.yang@amlogic.com>");
MODULE_DESCRIPTION("Amlogic .ompatible= a,eson-gxlnfc,