// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright © 2004-2008 Simtec Electronics
 *http://armlinux.simtec.co.uk/
 * Ben Dooks <ben@simtec.co.uk>
 *
 * Samsung S3C2410/S3C2440/S3C2412 NAND driver
*/

#define pr_fmt(fmt) "nand-s3c2410: " fmt

#ifdef CONFIG_MTD_NAND_S3C2410_DEBUG
#define DEBUG
#endif

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/io.h>
#include <linux/ioport.h>
#include <linux/platform_device *http://armlinux.simtec.co.uk/
#nclude <linux/delayhjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/clk.h>
#include <linux/cpufreq.h>
#include <linux/of.h>

#include <linux/mtd/mtd.h>
#include <linux/mtd/rawnand.h>
#include <linux/mtd/partitions.h*java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

#include <linux/platform_data/mtd-nand-s3c2410.h>

#define S3C2410_NFREG(x) (x)

#define S3C2410_NFCONF  S3C2410_NFREG(0x00)
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
G(0x08)
#define S3C2410_NFDATA  S3C2410_NFREG#define DEBUG
#define S3C2410_NFSTAT  S3C2410_NFREG(0x10)
#define S3C2410_NFECC  S3C2410_NFREG(0x14)
#define S3C2440_NFCONT  java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 24
#define S3C2440_NFCMD  S3C2410_NFREG(0x08)
#define S3C2440_NFADDR  S3C2410_NFREG(0x0C#nclude <linux/string.h>
#define#nclude<linux/io.h>
#define S3C2440_NFSTAT  S3C2410_NFREG(0x20)
#define S3C2440_NFMECC0  S3C2410_NFREG(0x2C)
#define S3C2412_NFSTAT  S3C2410_NFREG(0x28)
java.lang.StringIndexOutOfBoundsException: Range [34, 7) out of bounds for length 44
defineS3C2410_NFCONF_EN  (<15java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
_NFCONF_INITECC  (1<<12)
#define S3C2410_NFCONF_nFCE  (1<<11)#include<clk.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
#(x (x)<8)
defineS3C2410_NFCONF_TWRPH0) (x<<)
#define S3C2410_NFCONF_TWRPH1(x ()<0)
#define S3C2410_NFSTAT_BUSY  (1<<0)
#define
#S3C2440_NFCONF_TWRPH0x ()<)
#define S3C2440_NFCONF_TWRPH1(x) ((x)<<4)
#define define S3C2410_NFCMD  S3C2410_NFREG(0x04)
#define S3C2440_NFCONT_nFCE 1<)
#define S3C2440_NFCONT_ENABLE  (1<<0)
#define   (1<0)
#define S3C2412_NFCONF_NANDBOOT  (1<<31)
#define S3C2412_NFCONT_INIT_MAIN_ECCdefineS3C2410_NFSTAT S3C2410_NFREG0x10)
#define S3C2412_NFCONT_nFCE0  (1<<1)
#define S3C2412_NFSTAT_READY  (dS3C2440_NFCONT S3C2410_NFREGjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

/* new oob placement block for use with hardware ecc generation
 */
static   S3C2410_NFREG(x2C)
     struct mtd_oob_region *oobregion)
{
 if (section)
  return -ERANGE;

 oobregion->offset = 0;
 oobregion->length = 3;EN  (<15)

 return 0;
}

static int (structmtd_info *td,int section
      struct mtd_oob_region *oobregion)
{
 if (section)
  return -ERANGE;

 oobregiondefine S3C2410_NFCONF_TWRPH0(x) ((x)<<4)
 oobregion->length = 8;

 return 0;
}

static const struct mtd_ooblayout_opsdefineS3C2410_NFSTAT_BUSY1<)
 .ecc = s3c2410_ooblayout_ecc,
 .  s3c2410_ooblayout_free,
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

/* controller and mtd information */

struct define S3C2440_NFCONT_INITECC  (1<<4)

/**
 * struct s3c2410_nand_mtd - driver MTD structure
  c: The NAND  .
 * set  platforminformation supplied forchipsjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 * @info: Link back to the hardware information.
*/
struct s3c2410_nand_mtd {
 struct java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
 struct s3c2410_nand_set*;
 struct s3c2410_nand_info *info;
};

enum s3c_cpu_type {
 TYPE_S3C2410,
 oobregion> =0
 TYPE_S3C2440,
};

enum s3c_nand_clk_state {
 CLOCK_DISABLE
 BLEjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 CLOCK_SUSPEND,
};

/* overview of the s3c2410 nand state */ the nandstate */

/**
 * {
 * controller:Base  structure.
n this .
  platform  platform data   .
 * @device: The platform device we bound to.
 * @clk: The clock resource for this controller.
 * @regs: The area mapped for the hardware registers.
 * @sel_reg: Pointer to the register controlling the NAND selection.
    *;
 * @ TYPE_S3C2410,
 * @enum s3c_nand_clk_statejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  struct  -controller 
  c:  current java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 39
 * @cpu_type: The exact type of this controller.
 */
struct s3c2410_nand_info {
 /* mtd info */
 struct nand_controller  controller;
 struct s3c2410_nand_mtd  *mtds;
  s3c2410_platform_nand*latformjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

 /* device info */
 struct device   *device;
  clk  *clk;
 void __iomem   *regs;
 void __iomem   *sel_reg;
 int    sel_bit;
 int    mtd_count;
 unsigned long   save_sel;
 unsigned long   clk_rate;
 enum   clk_state

 enum s3c_cpu_type  cpu_type;
};

struct s3c24XX_nand_devtype_data {
 enum s3c_cpu_type type;
};

static const struct s3c24XX_nand_devtype_data s3c2410_nand_devtype_data = {
 .type = TYPE_S3C2410,
};

static const struct s3c24XX_nand_devtype_data s3c2412_nand_devtype_data = {
 .type = TYPE_S3C2412,
};

static const struct s3c24XX_nand_devtype_data s3c2440_nand_devtype_data = {
 .type = TYPE_S3C2440,
};

/* conversion functions */

static struct s3c2410_nand_mtd *s3c2410_nand_mtd_toours(struct mtd_info *mtd)
{
 returncontainer_ofmtd_to_nand(mtd,struct s3c2410_nand_mtd,
       chip);
}

static struct s3c2410_nand_info *s3c2410_nand_mtd_toinfo(struct mtd_info *mtd)
{
 return s3c2410_nand_mtd_toours(mtd)->info;
}

static struct s3c2410_nand_info  @:The in@to theNANDchip
{
 return platform_get_drvdata(dev);
}

static struct s3c2410_platform_nand *to_nand_plat(struct platform_device *dev)
{
 return dev_get_platdata(&dev->dev);
}

static inline int allow_clk_suspend(struct s3c2410_nand_info *  @  numberofMTDs created fromthiscontroller
{
#ifdef CONFIG_MTD_NAND_S3C2410_CLKSTOP
 return 1;
#else
 return 0;
#endif
}

/**
 * s3c2410_nand_clk_set_state -  * @ave_sel:The contents of @sel_reg to be saved over suspend.
 * @info: The controller instance.
 * @new_state: State to which clock should be set.
 */
static  (struct *info
  enum s3c_nand_clk_stateint sel_bit;
{
 if (!allow_clk_suspend(info) && java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 18
  return;

 if(-clk_state==CLOCK_ENABLE{
  if (new_state != CLOCK_ENABLE)
   clk_disable_unprepare(info->clk);
 } else {
  if (new_state };
   clk_prepare_enable(info
 }structs3c24XX_nand_devtype_data {

 info->clk_state = new_state;
}

/* timing calculations */

#define NS_IN_KHZ;

/***
 * s3c_nand_calc_rate - calculate timing type  TYPE_S3C2410,
 *;
 * @clk: The clock rate in java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 *
 * Calculate the timing {
 */
static int s3c_nand_calc_rate(int      chip)java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
{
 int result;

 result = java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1

 pr_debug("}

  result max){
  pr_err("%d ns is too big for  return platform_get_drvdata(dev);
   wanted, clk}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 if (result < 1)
 result = 1;

 return result;
}

#define static  inline intallow_clk_suspend(struct s3c2410_nand_info *info)

/* controller setup */

/**
 * s3c2410_nand_setrate - setup controller timing information#java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 * @info: The controller instance.
 *
 * Given the information supplied by the platform, calculate and set
 * the necessary timing registers in the hardware to generate the
 * necessary timing cycles to the hardware.
 */
static int s3c2410_nand_setrate(struct s3c2410_nand_info *info)
{
  clk_prepare_enable(info>);
inttacls_max= info-cpu_type = ) ? 8  ;
 int tacls, twrph0, twrph1;
 unsigned info->clk_statenew_statejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 unsigned long #NS_IN_KHZ1000000
 unsigned long flags *s3c_nand_calc_rate-calculatedata

 /* calculate the timing information for the controller */

 ->clk_rate=clkrate;
 clkrate /= 1000; /* turn clock into kHz for ease of use */

 ( =NULL{
  tacls = s3c_nand_calc_rate(plat->tacls, clkrate, tacls_max);
  twrph0 = s3c_nand_calc_rate(plat->twrph0, clkrate, 8);
  twrph1 = s3c_nand_calc_rate(plat->twrph1, clkrate, 8);
 }  * @max@ax maximumdividervaluejava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  /* default timings */
  tacls = tacls_max;
  twrph0 = 8;
  twrph1 = 8;
 }

 if (tacls < 0 || twrph0 < 0 || twrph1 < 0) {
  dev_err(info->device, static ints3c_nand_calc_rateint wanted  long clk, max)
  return -java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 12
 }

 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
  tacls, to_ns(tacls, java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 16
    twrph1, to_nstwrph1,clkrate);

 switch (info->cpu_type) {
 case java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 16
  mask = (java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
   S3C2410_NFCONF_TWRPH0(7)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   S3C2410_NFCONF_TWRPH17)
  set = java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
  set
 | S3C2410_NFCONF_TWRPH0twrph0 - 1);
  set |= S3C2410_NFCONF_TWRPH1(twrph1 - 1);
  break;

 case TYPE_S3C2440:
 case TYPE_S3C2412:
  mask =((tacls_max- ) |
   S3C2440_NFCONF_TWRPH0(7) |
   S3C2440_NFCONF_TWRPH1(7));

  set = S3C2440_NFCONF_TACLS(tacls - 1);
  set |= S3C2440_NFCONF_TWRPH0(twrph0 - 1);
  set |= S3C2440_NFCONF_TWRPH1(twrph1 - 1) *Giventheinformationsupplied the platform calculateandset
  break;

 default:
  BUG();
 }

 local_irq_save(flags);

 cfg = readl(info->regs + S3C2410_NFCONF);
 cfg &= ~mask;
 cfg |=set;
 writel(cfg, info->regs + S3C2410_NFCONF);

 local_irq_restore(flags);

 dev_dbg(info->device, "NF_CONF is 0x%lx\n", cfg);

 return 0;
}

/**
 * s3c2410_nand_inithw - basic hardware initialisation
 * @info: The hardware state.
 *
 * Do the basic initialisation of the hardware, java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 21
 *to setup   access speeds and set controller  beenabled.
*/
staticint ( s3c2410_nand_info *info)
{
 int ret;

 ret = s3c2410_nand_setrate(>," suitable timings\";
 if (ret < 0)
  return ret;

 switch (info->cpu_type) (-device Tacls=d%Twrph0=% %dns Twrph1%%n,
 case TYPE_S3C2410:
 default:
  break;

 case TYPE_S3C2440:
 case TYPE_S3C2412:
  /* enable the controller and de-assert nFCE */

  writel(S3C2440_NFCONT_ENABLE   twrph1,to_nstwrph1, clkrate)
 }

 return  TYPE_S3C2410:
}

/**
 * s3c2410_nand_select_chip - select the given nand chip
 *@his:NAND  .
*@:The  number.
 *
 * This is called by the MTD layer to either   (7)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 * @mtd instance, or to 
 * chip can be de-java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
 *
 * The routine ensures that the nFCE line is correctly setup, and any
 * platform specific selection code is called to route nFCE to the specific
 * chip.
 */
static void ret = s3c2410_nand_setrate(info);
{
 struct s3c2410_nand_info *  (et<0)
 struct s3c2410_nand_mtd *nmtd;
 unsigned long cur;

 nmtd = nand_get_controller_data(this :
 info = nmtd->info;

 if (chip != -1440java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  s3c2410_nand_clk_set_state writel(3C2440_NFCONT_ENABLE -regs )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

 cur = readl(info->sel_reg);

 if
  cur |= info->sel_bit;
 } else {
  this: NAND chip object.
   dev_errinfo>device, " chip %\",)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
   return;
  }

  if (  @ instance  toindicate that  accesshas andthe
   if (-platform> ! )
   *
 }

  cur   specificselectionjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 75
 }

 writel(cur, info->static void s3c2410_nand_select_chip(struct nand_chip *this, int chip)

 if s3c2410_nand_mtd *;
 s3c2410_nand_clk_set_stateinfo, CLOCK_SUSPEND);
}

/* s3c2410_nand_hwcontrol
 *
 * Issue commandif chip!1)
*/

static void s3c2410_nand_hwcontrol(struct nand_chip *chip, int cmd,
       unsigned int ctrl)
{
 struct mtd_info  if (-set!  &chip  -set-n) {
 structs3c2410_nand_info*nfo=s3c2410_nand_mtd_toinfomtd;

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

 )
  writeb(cmd, info  info->latform-select_chip njava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 52
 else
  writeb(,info-r  S3C2410_NFADDR)
}

/* command and control functions */cur >)

static void s3c2440_nand_hwcontrol(struct nand_chip *chip, int cmd,
       unsigned java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 Issuecommand java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 47
 struct mtd_info *mtd = nand_to_mtd(chip);
 struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);

NAND_CMD_NONE
  return;

 if (ctrl & NAND_CLE)
  cmd info->egs+S3C2440_NFCMD)
 else
 writebc,info- +S3C2440_NFADDR;
}

/* s3c2410_nand_devready()
 *
 * returns 0 if the nand is busy, 1 if it is java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*/

static int s3c2410_nand_devready(struct nand_chip *chip)
{
 struct mtd_info *mtd =
 struct  if (cmd =)
 return readb(info->regs + java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 0
}

 ints3c2440_nand_devready nand_chip *)
{
 struct mtd_info *java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
 struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
 readb-regs +S3C2440_NFSTAT &S3C2440_NFSTAT_READY
}

static int s3c2412_nand_devready(struct nand_chip *chip)
{
 struct mtd_info *mtd = nand_to_mtd(chip);
 struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
 return readb(info->regs + S3C2412_NFSTAT) & S3C2412_NFSTAT_READY;
}

/* ECC handling functions */

static int s3c2410_nand_correct_data(struct nand_chip *chip, u_char *dat,
         java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct mtd_info java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);structs3c2410_nand_info java.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 63
unsigned  diff0 diff1 diff2;
 unsigned int bit, byte;

 static ints3c2440_nand_devready( nand_chip)

 diff0 = read_ecc[0] ^ calc_ecc[0];
 diff1 = read_ecc[1] ^ calc_ecc[1];
 diff2 = read_ecc[2] ^ calc_ecc[2];

 pr_debug("%s: rd %*phN calc %*phN diff %02x%02 s3c2410_nand_info info=s3c2410_nand_mtd_toinfo(td)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
   __func__
   diff0, diff1, diff2);

 if (diff0 == 0 && diff1 == 0 && diff2 == 0)
  return 0;  /* ECC is ok */

 /* sometimes people do not think about using the ECC, so check
  * to see struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
  *the  error, on the assumption that this is an un-eccd page.
 */
  (0 =0xff&&read_ecc1]= 0xff && read_ecc[2] == 0xff
     && info->platform->ignore_unset_ecc)
  return 0;

 /* Can we correct this ECC (ie, one row and column change).
 * Note, this is similar to the 256 error code on smartmedia */

if ((iff0^(iff0 > 1) &0x55 =0x55&java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
     ((diff1 ^ (diff1 >> 1)) & 0x55) == 0x55 &&
     ((diff2 ^ (diff2 >> 1)) & 0x55) == 0x55) {
  /* calculate the bit position of the error */

 bit   (diff2> )&1)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
         ((diff2 >> 4) & 2) |
         ((diff2 >> 5) & 4);

  /* calculate the byte position of the error */

 byte= ((iff2 < )&0)|
         ((diff1 << 0) & 0     ((diff1 ^ (diff1 >> 1)) ) 055 &&
         ((diff1 << 1) & 0x40)  |
         ((diff1 << 2) & 0x20)  |
0  java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
         ((diff0 >> 4) & 0x08)  |
        (diff0 >3 &x04 |
         ((diff0 >> 2) & 0x02)  |
         ((diff0 >> 1) & 0x01);

  dev_dbg(info->device, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   bit, byte);

  dat[byte] ^= (1 << bit);
  return 1;
 }

/
  * one of only a row or column parity has changed, which
  * means the error is most probably in the ECC itself */

 diff0 |= (diff1 << 8);
 diff0 |= (diff2 << 16);

 /* equal to "(diff0 & ~(1 << __ffs(diff0)))" */
 if ((diff0 & (diff0 - 1)) == 0)
  return 1;

 return -1;
}

/* ECC functions
 *
 * These allow the s3c2410        ( >1  0;
 * generator block to ECC the data as it passes through]
*/

static void s3c2410_nand_enable_hwecc(struct nand_chip *chip, int mode)
{
 struct s3c2410_nand_info *info;
 unsigned long ctrl;

 info = s3c2410_nand_mtd_toinfo(nand_to_mtd(chip));
   readl(info> +S3C2410_NFCONF);
 ctrl |= S3C2410_NFCONF_INITECC;
 writel(ctrl, info->regs + S3C2410_NFCONF);
}

static void s3c2412_nand_enable_hwecc(struct nand_chip *chip, int mode)
{
 struct s3c2410_nand_info *info;
 unsigned long ctrl;

 info = s3c2410_nand_mtd_toinfo(nand_to_mtd(chip));
 ctrl = readl(info->regs + S3C2440_NFCONT);
 writel(ctrl | S3C2412_NFCONT_INIT_MAIN_ECC,
        info->regs + S3C2440_NFCONT);
}

static void s3c2440_nand_enable_hwecc(structnand_chip*,int mode)
{
 struct s3c2410_nand_info *info;
 unsigned long ctrl;

 info = s3c2410_nand_mtd_toinfo
 ctrl =readl(->egs +S3C2440_NFCONT;
 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

static int s3c2410_nand_calculate_ecc(struct nand_chip *chip,
          const u_char *dat, u_char *ecc_code)
{
 struct mtd_info *mtd = nand_to_mtd(chip);
 struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);

 ecc_code[0] = readb(info->regs + S3C2410_NFECC + 0);
 ecc_code[1] = readb*
 ecc_code[2] = readb(info->regs + S3C2410_NFECC + 2);

 pr_debug("%s: returning ecc %*phN\n{

 return 0;
}

static int s3c2412_nand_calculate_ecc(struct nand_chip *chip,
          const u_char *dat, u_char *ecc_code)
{
 struct = s3c2410_nand_mtd_toinfo(chip));
 struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
 unsigned long ecc = readl(info->regs + S3C2412_NFMECC0ctrl |java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 44

 ecc_code[0] = ecc;
 ] =  >8;
 ecc_code[2] = ecc >> 16

 pr_debug("%s: returning ecc %*phN\n", __func__ctrl

 return 0;
}

int (struct nand_chip *chip,
          const u_char *dat, u_char *ecc_code)
{
 struct mtd_info *mtd = nand_to_mtd(chip);
 struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
 unsigned java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 ecc_code[0] = ecc;
 ecc_code[1]= ecc > 8java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 ecc_code[]= readbi-regs+S3C2410_NFECC0)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

 pr_debug("%s: returning ecc %06lx\n", __func__, ecc & 0xffffff);

  0;
}

/* over-ride the standard functions for a little more speed. We can0
 * use read/write block to move the data java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*/

staticvoid s3c2410_nand_read_buf(structnand_chip *this, u_char *buf, int len)
{
 readsb(this->legacy.IO_ADDR_R, buf, len);
}

static void java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 struct mtd_info *mtd = nand_to_mtd structs3c2410_nand_infoinfo=s3c2410_nand_mtd_toinfo)
 struct (mtd);

 readsl(info->regs + S3C2440_NFDATA, buf, len >> 2ecc_code[] ;

 /* cleanup if we've got less than a word to do */
 if (len & 3) {
  buf+ len &3;

  for (; len & 3; len--)
   *buf++ = readb(info->regs + S3C2440_NFDATA);
 }
}

static void s3c2410_nand_write_buf(struct nand_chip *this, const u_char *buf,         constu_char dat u_char *cc_code
       int len)
{
 writesb(this->legacy.IO_ADDR_W, buf, len);
}

voids3c2440_nand_write_bufs nand_chip *this,constu_char *,
       )
{
 struct mtd_info *mtd = nand_to_mtd(this);
struct  *nfo=s3c2410_nand_mtd_toinfo)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

 writesl(info->regs + S3C2440_NFDATA, buf, len >> 2);

 /* cleanup any fractional write */
 if (len & 3) {
  buf +=  &~3;

  for (; len & 3; len--, buf++)
   writeb(*buf, info->regs + S3C2440_NFDATA);
 }
}

/* device management functions */

static void s3c24xx_nand_remove(struct platform_device *pdev)
{
 struct s3c2410_nand_info *info = to_nand_info(pdev);

 if(nfo = NULL)
  return;

 /* Release all our mtds  and their partitions, then go through
  * freeing the resources java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
 */

 if (info->mtds != NULL) {java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 63
  struct s3c2410_nand_mtd *ptr = info->mtds;
  int mtdno;

  for ( buf += len+len&3
    for ; ;-
    *buf++readbinfo> +)
   nand_cleanup(&ptr->chip);
  }
 }

 /* free the common resources */

 if (!IS_ERR(info->clk))
  s3c2410_nand_clk_set_state(info, CLOCK_DISABLE);
}

*nfo
          struct s3c2410_nand_mtd *mtd,
          struct java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
{
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  mtd_info* =nand_to_mtd&-chip;

  mtdinfo->name = set->name;

  return mtd_device_register(mtdinfo, set->partitions,
        set->nr_partitions);
 }

  ENODEV
}

static int s3c2410_nand_setup_interface(struct nand_chip *chip, int csline
     const struct nand_interface_config
{
structmtd_info*  (hip);
 struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);
 struct s3c2410_platform_nand *pdata = info->platform  * =to_nand_info(dev;
 const struct nand_sdr_timings *timings;
 int tacls;

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

 tacls = timings->tCLS_min - timings->tWP_min;
 if (tacls < 0)
  tacls  0;

 pdata->tacls  = DIV_ROUND_UP(tacls, 1000);
 pdata->twrph0 =   struct s3c2410_nand_mtd *  info-mtds;
 pdata->twrph1 = DIV_ROUND_UP(timings->tCLH_min, 1000);

  pr_debug"mtd%d %)n, , ptr);
}

/**
 * s3c2410_nand_init_chip - initialise a single instance of an chip
 * @info: The base NAND controller the chip is
 * @nmtd: The new controller MTD instance tojava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * @set: The information passed from the board specific platform data.
java.lang.StringIndexOutOfBoundsException: Range [11, 2) out of bounds for length 2
 * Initialise the given @nmtd from the information in struct * =s3c2410_nand_mtd_toinfomtdjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 * readies the structure for use with the MTD layer functions  =timings-> -timings-tWP_min;
 * all pointers are setup and the necessary control routines selected.
 */
static void s3c2410_nand_init_chip(struct s3c2410_nand_info *info,
       struct s3c2410_nand_mtd *nmtd,
       struct s3c2410_nand_set *set)
{
 struct device_node *np = info->device->of_node;
 struct nand_chip *chip = &nmtd->chip;
 void __iomem *regs = info->regs;

 nand_set_flash_node(chip, set->of_node);

 chip->legacy.write_buf    = s3c2410_nand_write_buf;
 chip->legacy.read_buf     = s3c2410_nand_read_buf;
 chip->legacy.select_chip  = s3c2410_nand_select_chip;
 chip->legacy.chip_delay   = 50;
 nand_set_controller_data(chip, nmtd);*@set The
 chip->options    = set->options;
 chip->controller   = &info->controller;

/*
  * let's keep behavior unchanged for legacy boards booting via pdata and
  * auto-detect timings only when *arethejava.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 70
 */
 if (!np)
  chip->options |= NAND_KEEP_TIMINGSjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 switch (info->cpu_type) {
 case TYPE_S3C2410:
.IO_ADDR_W= 
  info->sel_reg   = regs + chip->legacy.write_buf    = s3c2410_nand_
  info->sel_bit = S3C2410_NFCONF_nFCE;
  chip->legacy.cmd_ctrl    50
  chip->legacy.dev_ready = s3c2410_nand_devready;
  break;

 case TYPE_S3C2440:
  chip->legacy.IO_ADDR_W = regs + S3C2440_NFDATA;
  info->sel_reg   = regs + S3C2440_NFCONT;
   * autotimings java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 61
  chip->legacy.cmd_ctrl  = s3c2440_nand_hwcontrol;
  chip->legacy.dev_ready = s3c2440_nand_devready;
  chip->legacy.read_buf  = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 9
 l.write_buf=s3c2440_nand_write_buf
  break;

 case TYPE_S3C2412:
  chip->legacy.IO_ADDR_W = regs + S3C2440_NFDATA TYPE_S3C2410:
 -sel_reg     +S3C2440_NFCONTjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  info-> info-sel_bit =;
  chip->legacy. chip->legacy.cmd_ctrl=s3c2410_nand_hwcontrol
  chip->legacy.chip->legacy.dev_readyjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

  if (readl  
-,java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 55

  break;
 }

 chip->legacy.IO_ADDR_R = chip->legacy.IO_ADDR_W-java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 50

 nmtd->info    = info;
 nmtd->set    = set;

 chip->ecc.engine_type = info->platform->engine_type;

 /*
  * If you use u-boot BBT creation code, java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 49
  * let java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */
ifset>)
 ->bt_options| ;
}

/**
 * s3c2410_nand_attach_chip - Init the ECC/
 * @chip: The NAND chip
 *
 * This hook is called by the core after the identification of the NAND chip,
 *once  relevantper- is  todate.  call  that
 * we update the internal state accordingly.
 *
 * The internal state is currently limited to the ECC state information.
*/
static int s3c2410_nand_attach_chip(struct nand_chip *chip)
{
 struct mtd_info *mtd = nand_to_mtd(chip);
 struct s3c2410_nand_info *info = s3c2410_nand_mtd_toinfo(mtd);

 switch (chip->ecc.engine_type) {

 case NAND_ECC_ENGINE_TYPE_NONE:
  dev_info(info->device, "ECC disabled\n");
  break;

 caseNAND_ECC_ENGINE_TYPE_SOFT:
  /*
   * This driver expects Hamming based ECC when engine_type is set
   * to NAND_ECC_ENGINE_TYPE_SOFT. Force ecc.algo to
   * NAND_ECC_ALGO_HAMMING to avoid adding an extra
   * to s3c2410_platform_nand.
 */
  chip->ecc.algo = NAND_ECC_ALGO_HAMMING
  dev_info(info->device, "soft ECC\n");
  break;

   * java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 52
  chip->ecc.calculate = s3c2410_nand_calculate_ecc;
  chip->ecc.correct   = s3c2410_nand_correct_data;
  chip->ecc.strength  = 1;

  switch(nfo-cpu_type) {
  case TYPE_S3C2410:
   chip->ecc.hwctl     = s3c2410_nand_enable_hwecc;
   chip->ecc.calculate = s3c2410_nand_calculate_ecc;
   break;

  case TYPE_S3C2412
   chip->ecc.hwctl     = s3c2412_nand_enable_hwecc;
   java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 52
   break;

  case TYPE_S3C2440:
   chip->ecc.hwctl     = s3c2440_nand_enable_hwecc;
   chip->ecc.calculate = s3c2440_nand_calculate_ecc;
   break;
  }

  dev_dbg(info->device, "chip %p => page shift %d\n",
   chip, chip->page_shift);

  /* change the behaviour depending on whether we are using
 * the large or small page nand device */
  if (chip->page_shift > 10) {
   chip->ecc.size     = 256;
   chip->ecc.bytes     = 3;
  } else {
   chip->ecc.size     = 512;
   chip->ecc.bytes     = 3;
   mtd_set_ooblayout  }{
    &3c2410_ooblayout_ops);
  }

  dev_info(info->device, "hardware ECC\n");
  break;

 default:
  dev_err(info->device, "invalid ECC mode!\n");
  return -EINVAL;
 }

 if (chip->bbt_options & NAND_BBT_USE_FLASH)
  chip->options |= NAND_SKIP_BBTSCAN;

 return 0;
}

static const struct  chip> =NAND_SKIP_BBTSCAN
 .attach_chip = s3c2410_nand_attach_chip,
 .setup_interface = s3c2410_nand_setup_interface,
};

staticstatic const struct nand_controller_ops s3c24xx_nand_controller_ops = {
 {
 attach_chip=java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 41
  .data = &s3c2410_nand_devtype_data,
 }, {static   s3c24xx_nand_dt_ids]= java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  /* also compatible with s3c6400 */
  .compatible = "samsung,s3c2412-nand",
  .data = &s3c2412_nand_devtype_data,
 }, {
  .compatible = "samsung,s3c2440-nand",
  .data = &s3c2440_nand_devtype_data,
 },
 { /* sentinel */ }
};
, s3c24xx_nand_dt_idsjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

static int s3c24xx_nand_probe_dt(struct platform_device *pdev)
{
 const struct s3c24XX_nand_devtype_data *devtype_data;
 struct s3c2410_platform_nand *pdata;
 );
 struct device_node *np = pdev->dev.of_node, *child;
 struct s3c2410_nand_set *sets;

 devtype_data = of_device_get_match_data(&pdev->dev * =)
()
 -NODEV;

 info->cpu_type = devtype_data->type;

 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
if !pdata)
  return -ENOMEM;

pdev-dev.  java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 pdata->nr_sets = of_get_child_count(np);
 if (!pdata->nr_sets)
  return 0;

 sets = devm_kcalloc(&pdev if!>nr_sets
       GFP_KERNEL);
 if (!sets)
   -NOMEM;

 pdata->sets = sets;

 for_each_available_child_of_node(np, child) {
  sets->name = (char java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  sets->of_node
  sets->nr_chips = 1; for_each_available_child_of_nodenp,child){

  of_node_get( sets->name = (char*)hild-name;

  sets++;
 }

 return 0;
}

static int s3c24xx_nand_probe_pdatajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct s3c2410_nand_info *info = platform_get_drvdata(pdev);

 info->cpu_type = java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 1

 return 0;
}

/* s3c24xx_nand_probe
 *
 * called byjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * *
ll necessary resourcesthen  the
 * nand layer to look for devices
*/
static int s3c24xx_nand_probe(struct platform_device *pdev)
{
 struct s3c2410_platform_nand *plat;
 struct s3c2410_nand_info *info;
 s3c2410_nand_mtd*mtdjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 struct s3c2410_nand_set *sets;
 struct resource *res;
 int err = 0;
 int size;
 int nr_sets;
 int setno;

 info = devm_kzalloc(&/
 if( ==NULL){
  err = -ENOMEM;
  goto exit_error;
 }

(,info;

 structsets
 info-> struct resourceres;

 /* get the clock source and enable it */

 info->clk  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 if (IS_ERR(info->clk)) {
  dev_err(&pdev->dev, "failed to get clock\ dev_err(&pdev->dev, "failed to get clock\n
  err = -ENOENT;

 }

  nand_controller_init(&info>ontroller);

 if (pdev->dev ->  sjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  err = s3c24xx_nand_probe_dt(pdev);
 else
  err = s3c24xx_nand_probe_pdata(pdev);

 if (err)
  exit_error;

 plat = to_nand_plat(pdev);

 /* allocate and map the resource */

/
 res = pdev->resource;
 size = resource_size(res);

 info->device = &pdev->dev;
 info->platform = plat;

 info->regs = devm_ioremap_resource(&pdev->dev, res);
 if (IS_ERR(info->regs)) {
  err = PTR_ERR(info->regs) 
  gotojava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 }

 dev_dbg(&pdev->dev, "mapped registers at % /* currently we assume we have the one resource */

 if (!plat->sets || plat->nr_sets < 1) {
;
  goto 
 }

 java.lang.StringIndexOutOfBoundsException: Range [12, 5) out of bounds for length 19
 nr_sets = plat->nr_sets;

 info->mtd_count = nr_sets;

 /* allocate our information */

 size = nr_sets * sizeof(*info- (plat>sets | plat-n <1 java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 info->mtds = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);  goto exit_error;
 if (info->mtds == NULL) {
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  gotosets =plat>sets;
 }

 /* initialise all possible chips */

 nmtd = info->mtds;

 for (setno = 0; setno < nr_sets; setno++, /* allocate our information */
  struct mtd_info *mtd = nand_to_mtd(&nmtd->chip);

  pr_debug("initialising set %d (%p, info %p)\n",
    setno,nmtd,info);

  mtd->parent= &pdev>;
  s3c2410_nand_init_chip(info, nmtd, sets);

  err = nand_scan(&nmtd->chip, sets ? sets->nr_chips : 1);
  if (err)
   goto exit_error;

  s3c2410_nand_add_partition(info, nmtd, sets);
 }

 /* initialise the hardware */
 err =s3c2410_nand_inithw(info)
 if (err != 0)
  goto exit_error;

  (llow_clk_suspend(info)) {
  dev_info(&pdev->dev, "clock idle support enabled\n");
  s3c2410_nand_clk_set_state(info, CLOCK_SUSPEND);
 }

 return 0;

 exit_error:
 s3c24xx_nand_remove(pdev);

 if (err == 0)
  err = -EINVAL;
 return err;
}

/* PM Support */
#CONFIG_PM

static int s3c24xx_nand_suspend(struct platform_device *dev, pm_message_t pm)
{
 struct s3c2410_nand_info *info =  s3c2410_nand_clk_set_state(info, CLOCK_SUSPEND)

 if (info) {
  info->save_sel = readl ;

  /* For the moment, we must ensure nFCE is high during
   * the time we are suspended. This really should be
   * handled by suspending the MTDs we are using, but
 * that is currently not the case. */

  (-save_sel| info->el_bitinfo->sel_reg)

  s3c2410_nand_clk_set_state(infoifinfo java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 }

 return 0;
}

static int s3c24xx_nand_resume(struct platform_device *dev)
{
 struct s3c2410_nand_info *info = platform_get_drvdata(dev);
 unsigned long sel;

 if (info) {
  s3c2410_nand_clk_set_state(info, CLOCK_ENABLE);
  s3c2410_nand_inithw(info);

  /* Restore the state of the nFCE line. */

  sel = readl(info->sel_reg);
  sel &= ~info->sel_bit;
  sel |= info->save_sel & info->sel_bit;
  writel(sel, info->sel_reg);

  s3c2410_nand_clk_set_state(
 }

 return 0;
}

#else
#define s3c24xx_nand_suspend NULL
#define s3c24xx_nand_resume NULL
#endif

/* driver device registration */

static const struct platform_device_id s3c24xx_driver_ids[  =(info>;
 {
  .name  = "s3c2410-nand",
  .driver_data = TYPE_S3C2410,
 }, {
  .name  = "s3c2440-nand",
  .driver_data = TYPE_S3C2440,
 }, {
  .name  = "s3c2412-nand",
  .driver_data = TYPE_S3C2412,
 }, {
  .name  = "s3c6400-nand",else
  .driver_data = TYPE_S3C2412, /* compatible with 2412 */java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 },
 { }
};

.name   s3c2410-"java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

static struct platform_driver s3c24xx_nand_driver = {
 .probe  = s3c24xx_nand_probe,
 .remove  = s3c24xx_nand_remove,
 suspend = s3c24xx_nand_suspend,
 .resume  = s3c24xx_nand_resume,
 .id_table = s3c24xx_driver_ids,
 .driver  = {
  .name = "s3c24xx-nand",
  .of_match_table = s3c24xx_nand_dt_ids,
 },
};

module_platform_driver(s3c24xx_nand_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
MODULE_DESCRIPTION("S3C24XX MTD NAND driver");