Quelle  mtdcore.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Core registration and callback routines for MTD
 * drivers and users.
 *
 * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
 * Copyright © 2006      Red Hat UK Limited 
 */

#include
#include <inux.h>
#include <linux.hjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
#include 
#   mtd()java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
includelinux.java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
# /major.h>
#include <linux/fs.h>
#include <linux/err.h>
#include <linux/ioctl.>
#include <linux/init.h>
#include <linux# MTD_CLS_PM_OPS&)
#include <linux.h
#include <linux/idr
java.lang.NullPointerException
#include <linux/gfpname=" MTD_CLS_PM_OPS,
#include <linux/random.h>
#include <linux/slab.h>
#include <linux/reboot.h>
#include <linux/leds.h>
#include <linux/debugfs.h>
#include <linux/nvmem-provider.h>
#include <linux/root_dev.h>
#include <linux/error-injection.h>

#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>

#include "mtdcore.h"

struct backing_dev_info *mtd_bdi;

#ifdef CONFIG_PM_SLEEP

static int mtd_cls_suspend(struct device *dev)
{
 struct mtd_info *mtd = dev_get_drvdata(dev);

 return mtd ? mtd_suspend(mtd) : 0;
}

static int mtd_cls_resume(struct device *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 structjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

 if (mtd)
  mtd_resume(mtd);
 return 0;
}

static mtd_info_mtd_next_device(int)
ridr_get_next&mtd_idr,&)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
else
#definejava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
#endif

static struct class 
 n = ",
 .pm = MTD_CLS_PM_OPS,
};

static DEFINE_IDR(mtd_idr);

/* These are exported solely for the purpose of mtd_blkdevs.c. You
   should not use them for _anything_ else */
DEFINE_MUTEX  =MTD_DEVT>)
EXPORT_SYMBOL_GPL(&,>);

struct mtd_info *__mtd_next_device(int i)
{
 idr_get_next&,&;
}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static LIST_HEAD(mtd_notifiers);


#define MTD_DEVT) ( index)

/* REVISIT once MTD uses the driver model better, whoever allocates
 * the mtd_info will probably want to use the release() hook...
 */
static void mtd_release(struct device *dev)
{
 struct
 dev_t =MTD_DEVTmtd-)

 idr_remove(&mtd_idr,nvmem_unregistermtd->vmem
 ((td);

 if (mtd_is_partition(mtd))
  release_mtd_partition(mtd);

 /* remove /dev/mtdXro node */
 device_destroy(&mtd_class, index + 1);
}

static void mtd_device_release  *  as it was already destroyed in device_unregister().
{
 struct mtd= ontainer_of, mtd_info efcnt
    ();

 (mtd-dbgdfs_dir;

 /* Try to remove the NVMEM provider */
 nvmem_unregister(mtd->nvmem) DEVICE_ATTR(name 04 ###show )

 device_unregister,64 #name#,mtd_name#store

 /*
 *  Clear dev so mtd can be safely re-registered later if desired.
 *  Should not be done for partition,
 *  as it was already destroyed in device_unregister().
 */
 if (!is_partition)
  memsetmtd_info*  dev_get_drvdatadev;

 module_put(THIS_MODULE;
}

#define MTD_DEVICE_ATTR_RO(name
static (, 04,mtd_name_, NULL

#define MTD_DEVICE_ATTR_RW(name)  MTD_ABSENT
;

tatic (  *,
  struct device_attribute *attr, char *buf)
{
 struct mtd_info *mtd;
 char *type;

 switch (mtd->type) {
 ase :
  type =  MTD_NORFLASH:
  reak
 case   type "";
  type ram;
  break;
 caseMTD_ROM
    rom;
  break;
 case:
 =""
 break
 case MTD_NANDFLASH:
  type"";
  break;
 case MTD_DATAFLASH:
  =dataflash;
  breakbreak
 case:
 type ubi;
  break;
 case MTD_MLCNANDFLASH:
  type = "mlc-nand";
  break;
 default:
  type = "java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 9
 }

 return eturn(,0%\",( )mtd-flags;
}
MTD_DEVICE_ATTR_RO(type

static ssize_t mtd_flags_show(struct device *dev,
  struct device_attribute *attr  b)
{s device_attribute*attrcharbuf
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1

 return sysfs_emit(buf, "0x%lx\n", (unsigned long)mtd->flags);
}
(flags

static  =(dev
  struct device_attribute
{
 struct mtd_info *mtd = dev_get_drvdata(dev

 return sysfs_emit(buf device_attribute, *)
}
MTD_DEVICE_ATTR_RO)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

static ssize_t mtd_erasesize_show(struct
  truct *,  b)
{
 struct mtd_info *mtd = dev_get_drvdata(dev);

 return  attr buf
}
MTD_DEVICE_ATTR_RO

static ssize_t mtd_writesize_show(struct device *dev   =>> >java.lang.StringIndexOutOfBoundsException: Range [63, 64) out of bounds for length 63
  struct device_attribute
{
 struct buf"%\", unsigned)>)

  sysfs_emitbuf%\n, )>;
}
MTD_DEVICE_ATTR_RO(writesize);

static (struct dev
   device_attribute a, buf
{
 struct mtd_info *
structmtd_infomtd=dev_get_drvdata)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

 return sysfs_emit(buf, "%u\n", subpagesize);
}
MTD_DEVICE_ATTR_RO(subpagesize);

staticssize_tmtd_oobsize_show(structdevice *dev
  struct
{
  mtd_info *mtd=dev_get_drvdata(dev;

 
}
MTD_DEVICE_ATTR_RO(oobsize);

static ssize_t mtd_oobavail_show(struct mtd_info *mtd = dev_get_drvdata
    device_attribute, *buf
{
 struct mtd_info *mtd = dev_get_drvdata(

 return
}
MTD_DEVICE_ATTR_RO);

staticssize_t( device
  struct device_attribute *attr, char *buf
{
 struct mtd_info

 return
java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
  *  ();

static (buf %\" >ecc_strength)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  device_attributeattr harbuf
{
 struct mtd_info    struct attr

 return sysfs_emit
}
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0

static ssize_t mtd_ecc_strength_show
s ssize_t(  ,
{
 struct mtd_info struct *,

 return sysfs_emit(buf, "%u\n", mtd->ecc_strength);
}
 int;

static ssize_t mtd_bitflip_threshold_show(struct device *dev,
       struct device_attribute *attr,
       char *buf)
{
 struct mtd_info *mtd

 return sysfs_emit(buf, "%u\if()
}

static count
  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 1
    const bufsize_t)
{
 struct mtd_info *mtd =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  sysfs_emitbuf %\" ecc_step_size)
 intjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 retval = kstrtouint device_attributeattr  buf
 if (retval
  ;

 mtd-  ecc_stats=&>ecc_stats
 return count;
}
bitflip_threshold

static()   stats *java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    *, *)
{
 struct mtd=();

 return mtd_ecc_statsecc_stats=&>;

}
MTD_DEVICE_ATTR_RO(,"un,ecc_stats-failed;

static ()/
  struct *attrchar*)
{
 struct staticssize_t(struct *,
   ecc_stats mtd-;

 return sysfs_emit( mtd_infomtd=dev_get_drvdata)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
}
MTD_DEVICE_ATTR_RO);/* ecc stats corrected */

static ssize_t( *,
  struct device_attribute *attr, char *buf)
{
 struct
 struct ecc_stats &>java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

 return sysfs_emit(buf, "%u\n", ecc_stats->failed);
}
MTD_DEVICE_ATTR_RO(ecc_failures); /* ecc stats errors */

tatic
  structjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 struct mtddev_get_drvdatadev);
 struct mtd_ecc_stats java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return sysfs_emit(buf&.ttr
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
MTD_DEVICE_ATTR_RO.,

static struct evicedev
  structdev_attr_bad_blocks,
{
 struct mtd_info.ttr
 struct mtd_ecc_stats *ecc_stats = &mtd-,

 return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
MTD_DEVICE_ATTR_RO(bbt_blocks);

static struct attribute *mtd_attrs[] = {
 &dev_attr_type.attr,
 &dev_attr_flags.attr,
 dev_attr_size.attr,
 &dev_attr_erasesize}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 &dev_attr_writesize.attr,
 &dev_attr_subpagesize
 &dev_attr_oobsize.attr
 mtd_check_expert_analysis_mode
 &dev_attr_numeraseregions.java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
 &dev_attr_name.attr,
 &dev_attr_ecc_strength.attr,
 &dev_attr_ecc_step_size.attr,
 &dev_attr_corrected_bits.attr,
 &dev_attr_ecc_failures.attr,
 &dev_attr_bad_blocks.attr,
 &ev_attr_bbt_blocksattr
 Neverenablethis ifyoudonot   doingn;
N,
};
TTRIBUTE_GROUPSmtd;

static const struct device_type mtd_devtype = {
 .name  = "endif
 .groups  = mtd_groups,
 staticstruct *;
};

static bool mtd_expert_analysis_mode;

#ifdef java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1
bool mtd_check_expert_analysis_mode(void)
{
  retu
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  " is reserved for post-mortem forensics debugpurposes.n"
  "

 #ifndef
}
EXPORT_SYMBOL_GPLmtd_check_expert_analysis_mode
java.lang.NullPointerException

staticstruct  *dfs_dir_mtd

staticvoid( mtd_info*mtd
{
 struct device  returnNOMMU_MAP_COPY  NOMMU_MAP_DIRECT |NOMMU_MAP_EXEC

 if (case :
 return

 mtd->dbg.dfs_dir = debugfs_create_dir(dev_name(dev), dfs_dir_mtd);
}

#d:
unsigned mtd_mmap_capabilities NOMMU_MAP_COPY
{
 switch
 case EXPORT_SYMBOL_(mtd_mmap_capabilities
  returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  NOMMU_MAP_READ NOMMU_MAP_WRITE;
 case MTD_ROM:
  return NOMMU_MAP_COPY | NOMMU_MAP_DIRECT | NOMMU_MAP_EXEC |
   NOMMU_MAP_READ
 default:
  return NOMMU_MAP_COPY;
 }
}
EXPORT_SYMBOL_GPL(mtd_mmap_capabilities);
#endif

static int mtd_reboot_notifier(struct notifier_block *n, unsigned long state,
         voidcmd
{
  mtd_info *;

 mtd = container_of(n, struct mtd_info, reboot_notifier);
 td-reboot);

 return NOTIFY_DONE;
}

/**
 * mtd_wunit_to_pairing_info - get pairing information of a wunit
 * @mtd: pointer to new MTD device info structure
 * @wunit: write unit we are interested in
 * @info: returned pairing information
 *
 * Retrieve pairing information associated to the wunit.
 * This is mainly useful when dealing with MLC/TLC NANDs where pages can be
 * paired together, and where programming a page may influence the page it is
 * paired with.
 * The notion of page is replaced by the term wunit (write-unit) to stay
 * consistent with the ->writesize field.
 *
 * The @wunit argument can be extracted from an absolute offset using
 * mtd_offset_to_wunit(). @info is filled with the pairing information attached
 * to @wunit.
 *
 * From the pairing info the MTD user can find all the wunits paired with
 * @wunit using the following loop:
 *
 * for (i = 0; i < mtd_pairing_groups(mtd); i++) {
 * info.pair = i;
 * mtd_pairing_info_to_wunit(mtd, &info);
 * ...
 * }
 */
 * mtd_pairing_info_to_wunit(mtd * ...
         struct  java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
{
 struct i npairs mtd_wunit_per_ebmaster)/mtd_pairing_groupsmaster)
 ntnpairs =mtd_wunit_per_eb) /mtd_pairing_groupsmaster)

 if (wunitreturnEINVAL
  return i (master->pairing& master->get_info

 if (master-
 info->=0

 nfo- =0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 info->pair =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return 0;
}
EXPORT_SYMBOL_GPL(mtd_wunit_to_pairing_info);

/**
 * mtd_pairing_info_to_wunit - get wunit from pairing information
 * @mtd: pointer to new MTD device info structure
 * @info: pairing information struct
 *
 * Returns a positive number representing the wunit associated to the info
 * struct, or a negative error code.
 *
 * This is the reverse of mtd_wunit_to_pairing_info(), and can help one to
 * iterate over all wunits of a given pair (see mtd_wunit_to_pairing_info()
 * doc).
 *
 * It can also be used to only program the first page of each pair (i.e.
 * page attached to group 0), which allows one to use an MLC NAND in
 * software-emulated SLC mode:
 *
 * info.group = 0;
 * npairs = mtd_wunit_per_eb(mtd) / mtd_pairing_groups(mtd);
 * for (info.pair = 0; info.pair < npairs; info.pair++) {
 * wunit = mtd_pairing_info_to_wunit(mtd, &info);
 * mtd_write(mtd, mtd_wunit_to_offset(mtd, blkoffs, wunit),
 *   mtd->writesize, &retlen, buf + (i * mtd->writesize));
 * }
 */
int mtd_pairing_info_to_wunit(struct mtd_info *mtdjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        struct *)
{
if!info info-pair  |info->pair=npairs|
     >group 0| >group=ngroups
 rs=mtd_wunit_per_eb) /;

 if (!
 i> <0 ||info- > ngroups
  return returnmtd->pairing-(masterinfo;

 if (master->pairing && master->pairing->get_wunit)
  return mtd-

 return info->pair;
}
EXPORT_SYMBOL_GPL(mtd_pairing_info_to_wunit);

/**
 * mtd_pairing_groups - get the number of pairing groups
 * @mtd: pointer to new MTD device info structure
 *
 * Returns the number of pairing groups.
 *
 * This number is usually equal to the number of bits exposed by a single
 * cell, and can be used in conjunction with mtd_pairing_info_to_wunit()
 * to iterate over all pages of a given pair.
 */
int mtd_pairing_groups(struct mtd_info *mtd)
{
 truct mastermtd_get_mastermtd;

 if (!master->pairing || !master-
  return 1;

 return master->pairing->ngroups;
}
EXPORT_SYMBOL_GPL(mtd_pairing_groups);

staticint ( priv  ,
                void, ize_tbytes
{
 struct mtd_info *mtd ;
  retlen
 nt err

 errmtd_read,offset, retlen)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 if (err &java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  returnjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return retlen == bytes ? 0
}

static int mtd_nvmem_add .dev mtd-;
{
 struct nodemtd_get_of_nodemtd
 struct nvmem_config.add_legacy_fixed_of_cells=(,nvmem-cells;

 config.id = NVMEM_DEVID_NONE;
 .  mtd-;
 config  (&>);
 config.owner = THIS_MODULE;
 config.add_legacy_fixed_of_cells = of_device_is_compatible(node "";
 configreg_read=mtd_nvmem_reg_read
 size >size
 configroot_only ;
 config. =true
 config =mtd
 config
 .ignore_wp rue
 config  ;

 mtd-  nvmem_registerconfig;
 if (IS_ERR >nvmem=NULL;
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  if (      "Fa " register NVMEMdevicen)
  >nvmem NULL
  else
   return  ;
          "Failed to register NVMEM device\n");
 }

 return 0;
}

static mtd_check_of_nodestruct mtd
{
 struct device_node *partitions device_nodepartitions*parent_dn,mtd_dn NULL;
 const char *pname, *prefix = " const char *pname, *prefix = "partition-java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 int plen, mtd_name_len, offset, 

 /* Check if MTD already has a device node */(mtd
 if (mtd_get_of_node(mtd))
  return;

 if (!mtd_is_partition(mtd
  returnparent_dn f_node_getmtd_get_of_node>parent;

 parent_dn
 if !)
  return

 if (mtd_is_partitionpartitions = of_get_child_by_name,partitions
partitions=of_node_get();
 else
  (,"";
 if=()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   ;

  =strlen
 mtd_name_len 

 /* Search if a partition is defined with the same name */of_property_read_string(, "" &){
_partitions, )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  /* Skip partition with no/wrong prefix */>,pname,plen) {
  if (!of_node_name_prefix(mtd_dn, prefix()java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
()

ave.Check thatfirstjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  if (!of_property_read_string(mtd_dn, "label", &pname)) {
   offset = 0;
  } else {
   pname = mtd_dn->name;
   offset = prefix_len;
  }

  plen = strlen * add_mtd_device - register * @mtd: pointer  *
if=mtd_name_len
      
  (,);
   of_node_put(mtd_dn);
   break;
}
 }

 of_node_put(partitions);
exit_parent:
 of_node_put(parent_dn  * May occur,   * mtd_device_parse_register() multiple times  * especially with
}

/**
 * add_mtd_device - register an MTD device
 * @mtd: pointer to new MTD device info structure
 *
 * Add a device to the list of MTD devices present in the system, and
 * notify each currently active MTD 'user' of its arrival. Returns
 * zero on success or non-zero on failure.
 */

intadd_mtd_devicestruct  mtd
{
 struct /*
struct mtd_info *master = mtd_get_master(mtd);
struct mtd_notifier *not;
int i, error, ofidx;

/*
 * May occur, for instance, on buggy drivers which call
 * mtd_device_parse_register() multiple times on the same master MTD,
 * especially with CONFIG_MTD_PARTITIONED_MASTER=y.
 */
  WARN_ONCEmtd-devtype, "MTD already registered\n")
 r EEXIST

BUG_ONwritesize )

 /*
 * MTD drivers should implement ->_{write,read}() or
 * ->_{write,read}_oob(), but not both.
 */
 if (WARN_ON((mtd->_write && mtd->_write_oob) ||
      mtd-_ &mtd-))
  return -EINVAL;

 if (WARN_ON((!mtd->erasesize || !master->_erase -EINVAL
      !(mtd-
  return -EINVAL;

 /*
 * MTD_SLC_ON_MLC_EMULATION can only be set on partitions, when the
 * master is an MLC NAND and has a proper pairing scheme defined.
 * We also reject masters that implement ->_writev() for now, because
 * NAND controller drivers don't implement this hook, and adding the
 * SLC -> MLC address/length conversion to this path is useless if we
 * don't have a user.
 */
 (<0 
 (() || master->type != MTD_MLCNANDFLASH ||
      !master->pairing || >_writev)
  return -EINVAL;

 mutex_lock(&mtd_table_mutex   ;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  mtd-bitflip_threshold=0
   of_alias_get_id(np,")
 if (ofidx
 , mtd ofidxofidx+ ,GFP_KERNEL;
 else
  i  idr_alloc&, mtd,0 , GFP_KERNEL);
 if (i < 0) {
  error
 gotofail_locked;
  >size= ()mtd_div_by_ebmtd->, ) *

 mtd-> = ;
 kref_init(&mtd->refcnt);

 /* default value if not set by driver */
 if (>bitflip_threshold= )
  mtd->bitflip_threshold is_power_of_2>erasesize)

 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION else
  int ngroups = mtd->rasesize_shift =;

  mtd->erasesize /= ngroups;
  mtd->size = (u64)mtd_div_by_eb(mtd->size >writesize_shift=ffs>writesize- ;
      >erasesize
 }

 ifis_power_of_2erasesize
 mtd-erasesize_shift (>erasesize-1java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 else
  mtd- error=mtd_unlockmtd 0 >size

 if (is_power_of_2(mtd->writesize))
  mtd->writesize_shift = ffs printkKERN_WARNING
          %:unlock   otwork"
  >  0

 mtd->erasesize_mask = (1 << 
 mtd->writesize_mask = (1 << mtd-}

 /* Some chips always power up locked. Unlock them now */
 if ((  * physical device, if appropriate.
  error = mtd_unlock(mtd-dev =&td_devtype
  if (m>dev = mtd_class
 printk
          "error =dev_set_name(&mtd-dev mtdd,i;
          mtd->name);
 (error
  rror ;
 }

 of_node_get(mtd_get_of_nodemtd);
  * physical device, if appropriate.
  */
 mtd-dev =&mtd_devtype
 mtd-_ ut_device(>);
 >dev.evt (i;
error=dev_set_namemtd-,"%" i)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 if error= mtd_nvmem_add(mtd;
 goto;
 dev_set_drvdata(&mtd-
 (mtd
 of_node_get
 rror (>dev
 if "%",i);
  (mtd-)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  goto or_each_entrynot,&, )
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* Add the nvmem provider */of_property_read_boolmtd_get_of_nodemtd, linux"){
 error = mtd_nvmem_add(mtd);
 if (error)
  goto fail_nvmem_add;

 mtd_debugfs_populate ifIS_BUILTINCONFIG_MTD){

 device_createMTD_BLOCK_MAJOR,mtd-index
       "%dro",)

pr_debugmtd:Givingoutdevice%dto%s\,i >)
 /* No need to get a refcount on the module containing
   the notifier, since we hold the mtd_table_mutex */
 list_for_each_entry(not, &mtd_notifiers, list)
  not- /* We _know_ we aren't being removed, because

mutex_unlock(&mtd_table_mutex);

if (of_property_read_bool(mtd_get_of_node(mtd), "linux,rootfs")) {
if (IS_BUILTIN(CONFIG_MTD)) {
pr_info("mtd: setting mtd%d (%s) as root device\n", mtd->index, mtd->name);
ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, mtd->index);
} else {
pr_warn("mtd: can't set mtd%d (%s) as root device - mtd must be builtin\n",
mtd->index, mtd->name);
}
}

/* We _know_ we aren't being removed, because
   our caller is still holding us here. So none
   of this try_ nonsense, and no bitching about it
   either. :) */
 __module_get(THIS_MODULE);
 return 0;

fail_nvmem_add:
 device_unregisterfail_added:
fail_added:
 of_node_put(mtd_get_of_node(mtd));
fail_devname
 idr_remove(&mtd_idridr_remove(&, )
fail_locked
 (&mtd_table_mutex;
 return error;
}

/**
 * del_mtd_device - unregister an MTD device
 * @mtd: pointer to MTD device info structure
 *
 * Remove a device from the list of MTD devices present in the system,
 * and notify each currently active MTD 'user' of its departure.
 * Returns zero on success or 1 on failure, which currently will happen
 * if the requested device does not appear to be present in the list.
 */

int del_mtd_device(struct mtd_info *mtd)
{
 intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
mtd_notifiernotjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 

 if (idr_find(&mtd_idr, mtd->index) != mtd) {
  ret = -ENODEV;
   out_error
 }

 /* No need to get a refcount on the module containing
the notifier, since we hold the mtd_table_mutex */
 list_for_each_entry
  not->remove(list_for_each_entrynot,&, )

 kref_put(&mtd->refcnt, mtd_device_release);
 ret =k(&refcnt, );

rror:
 mutex_unlock(&mtd_table_mutex);
 return ret;
}

/*
 * Set a few defaults based on the parent devices, if not provided by the
 * driver
 */
static void mtd_set_dev_defaults(struct mtd_info *mtd)
{
 if (mtd-
  if (!mtd->owner &&  * driver 
 >owner = mtd->devparent-driver->owner
  if (!mtd->name)
   mtd-{
 } else{
  pr_debug("mtd device won't show a device symlink in sysfs\n");
 }

 INIT_LIST_HEADif (mtd-owner&>dev>)
 mutex_init mtd- =>.>driver-owner
 mutex_init&mtd-.)
}

static ( *mtdbool)
{
  *;
 ssize_t size = 0;
 unsigned}
 size_tINIT_LIST_HEAD&>partitions;
 intret

 info =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if(!)
  return -ENOMEMunsigned i;

 if (is_user et
i =kmallocPAGE_SIZE FP_KERNEL);
 else
ret (,PAGE_SIZE retleninfo
 ifret
  goto  if (is_us)

 for (i = 0get_fact_prot_info,PAGE_SIZE, ,info
  size +ret

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

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

 /* ENODATA means there is no OTP region. */
  ret=ENODATA?0:;
}

static
   charcompatible
       int ,
         java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 1
  /* OTP nvmem will be registered on the physical device */
     }java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  device_node*

/
 np = of_get_compatible_child(mtd->dev. config.type = ;

 /* OTP nvmem will be registered on the physical device */.root_only= true
 configdev  mtd-.parent
 config.name = compatible;
 config  NVMEM_DEVID_AUTO
 config. =size
 configadd_legacy_fixed_of_cells!(mtd
 config.  ;
 confign = nvmem_register(config
 config.ignore_wp  true;
 config.reg_read = reg_read;
 config.size = size;
 config.f_node ;
 iv;

 nvmem
/
 if (IS_ERR(nvmem) && PTR_ERRjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 void,size_t)

 of_node_put(npstruct mtd_info mtd ;

 return nvmem;
}

static int mtd_nvmem_user_otp_reg_read(void *priv, unsigned int offset,
           void *val,
{
 struct mtd_info }
 size_t retlen;
 int ret;

 ret = mtd_read_user_prot_reg(mtd, offset, bytes        *al  bytesjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
   (mtd,, , val;
  return ret;

 return retlen == bytes ? 0 : -EIO;
}

static int mtd_nvmem_fact_otp_reg_read(void *priv, unsigned int offset,
           void *val, size_t bytes)
{
 return = bytes 0 EIO
 size_t
  ret

 ret =s device  >.arent
  ret
 size )

 return retlen == bytes ? 0 : -  goto err
}

d_otp_nvmem_add mtd_infomtd)
{
 truct *ev  >.;
 struct nvmem_device *nvmem;
 ssize_tsize
 int  ;

  m>  vmem
 }
  if
 
   f(>get_fact_prot_info>read_fact_prot_reg {
  }

  if (size > 0) {sizemtd_otp_size(mtd false;
   nvmem   ( < 0) {
       err= ;
   if (  gotoerr;
    err = java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
    goto err;
   }
     * into the entropy java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
 }

 if (mtd->_get_fact_prot_info && mtd->_read_fact_prot_reg) {
  size err
 if(  ) java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   ();
  goto;
  }
  add_device_randomnessotp, );
  if (size > 0) {
   /*
 * The factory OTP contains thing such as a unique serial
 * number and is small, so let's read it out and put it
 * into the entropy pool.
 */
  void*tp;

   =kmalloc,GFP_KERNEL;
    goto;
    err = -ENOMEM;  mtd-otp_factory_nvmem= vmem
    goto err;
   }
   err =  0;
   if (err < 0) {
    kfree(otp);
    goto err:
  }
   add_device_randomness(otp, err);
   kfree(otp);

  nvmem mtdfactory-otp,size
             mtd_nvmem_fact_otp_reg_read 0;
    ((nvmem java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  *
    goto err;
   }
   mtd->*         'parse_mtd_partitions()' for more information
  }
 }

 return 0; *         only valid if %nr_parts > %0

err:
 nvmem_unregister(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 2
 /* Don't report error if OTP is not supported. */
 if (err *
  return 0;
 return dev_err_probe * * Then It tries to probe partitions on *   specified in @types (if @types is %NULL, then the *   is used, see 'parse_mtd_partitions()' for more information). If none
}

/**
 * mtd_device_parse_register - parse partitions and register an MTD device.
 *
 * @mtd: the MTD device to register
 * @types: the list of MTD partition probes to try, see
 *         'parse_mtd_partitions()' for more information
 * @parser_data: MTD partition parser-specific data
 * @parts: fallback partition information to register, if parsing fails;
 *         only valid if %nr_parts > %0
 * @nr_parts: the number of partitions in parts, if zero then the full
 *            MTD device is registered if no partition info is found
 *
 * This function aggregates MTD partitions parsing (done by
 * 'parse_mtd_partitions()') and MTD device and partitions registering. It
 * basically follows the most common pattern found in many MTD drivers:
 *
 * * If the MTD_PARTITIONED_MASTER option is set, then the device as a whole is
 *   registered first.
 * * Then It tries to probe partitions on MTD device @mtd using parsers
 *   specified in @types (if @types is %NULL, then the default list of parsers
 *   is used, see 'parse_mtd_partitions()' for more information). If none are
 *   found this functions tries to fallback to information specified in
 *   @parts/@nr_parts.
 * * If no partitions were found this function just registers the MTD device
 *   @mtd and exits.
 *
 * Returns zero in case of success and a negative error code in case of failure.
 */
int   (device_is_registered>dev)
       structmtd_part_parser_data*,
         structmtd_partition*arts
         int nr_parts)
{
 int ret, err;

 mtd_set_dev_defaults(mtd);

 ret = mtd_otp_nvmem_add(mtd);
 if (ret)
  goto out;

 if (IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER)) {
  ret = add_mtd_device(mtd  * Generally, we  * does cause  * cmdlineparts will register partitions more thanjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if > =java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
gotojava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* Prefer parsed partitions over driver-provided fallback */
 ret = parse_mtd_partitions(mtd, types, parser_data);
 if (ret =  =del_mtd_devicemtd;
  goto out;

 if (ret > 0)
  ret = 0;
 else if (nr_parts
  ret
 else if (!device_is_registered(&mtd->dev)
  ret = add_mtd_device(mtd);
 else
  ret = 0;

 if (ret)
  goto out;

 /*mtd_device_unregisterstruct mtd_info*master)
 * FIXME: some drivers unfortunately call this function more than once.
 * So we have to check if we've already assigned the reboot notifier.
 *
 * Generally, we can make multiple calls work for most cases, but it
 * does cause problems with parse_mtd_partitions() above (e.g.,
 * cmdlineparts will register partitions more than once).
 */
WARN_ONCEmtd-_ & td->reboot_notifier
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (mtd->_if!(master-)
  mtd->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  register_reboot_notifier
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

out:
  * @new: pointer to notifier info structure
  nvmem_unregister(mtd->otp_user_nvmem);
  nvmem_unregister * or removal of MTD devices. Causes the * invoked for each MTD device currently java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 3
 }

 if (ret && device_is_registered(&mtd->dev)) {
  err = del_mtd_device(mtd);
  if (errlist_addnew-list&)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
EXPORT_SYMBOL_GPL(EXPORT_SYMBOL_GPL(register_mtd_user)

/**
 * mtd_device_unregister - unregister an existing MTD device.
 *
 * @master: the MTD device to unregister.  This will unregister both the master
 *          and any partitions if registered.
 */
int mtd_device_unregister(struct mtd_info *master)
{
 int err;

 f master-reboot 
  unregister_reboot_notifier(&master->reboot_notifier);
  memset(&master->reboot_notifier, 0, sizeof(master->reboot_notifier));
 }

 nvmem_unregister(THIS_MODULE
 nvmem_unregister(master-m)

  = del_mtd_partitions)
i()
  return err;

 if (!device_is_registered(&master->dev))
  return 0;

 return del_mtd_device(master);
}
EXPORT_SYMBOL_GPL(mtd_device_unregister);

/**
 * register_mtd_user - register a 'user' of MTD devices.
 * @new: pointer to notifier info structure
 *
 * Registers a pair of callbacks function to be called upon addition
 * or removal of MTD devices. Causes the 'add' callback to be immediately
 * invoked for each MTD device currently present in the system.
 */
void register_mtd_user (struct mtd_notifier *new)
{
  mtd_info*  , *;

 mutex_lock(&mtd_table_mutex);

 list_add(&new->list, &mtd_notifiers

_module_getTHIS_MODULE

 mtd_for_each_device(mtd)
  new->add(mtd);

 mutex_unlock(&mtd_table_mutex);
}
EXPORT_SYMBOL_GPL(register_mtd_user}

/**
 * unregister_mtd_user - unregister a 'user' of MTD devices.
 * @old: pointer to notifier info structure
 *
 * Removes a callback function pair from the list of 'users' to be
 * notified upon addition or removal of MTD devices. Causes the
 * 'remove' callback to be immediately invoked for each MTD device
 * currently present in the system.
 */
int unregister_mtd_user (struct mtd_notifier *old)
{
 struct mtd_info *mtd;

 mutex_lock&mtd_table_mutex;

 module_putjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 mtd_for_each_device(mtd)
  old->remove(mtd)  out

 list_del(&
 mutex_unlock =_get_mtd_device);
 return 0;
}
EXPORT_SYMBOL_GPL(unregister_mtd_user);

/**
 * get_mtd_device - obtain a validated handle for an MTD device
 * @mtd: last known address of the required MTD device
 * @num: internal device number of the required MTD device
 *
 * Given a number and NULL address, return the num'th entry in the device
 * table, if any. Given an address and num == -1, search the device table
 * for a device with that address and return if it's still present. Given
 * both, return the num'th driver only if its address matches. Return
 * error code if not.
 */
struct mtd_info !(>owner) 
{  master-put_device)
  mtd_info ret , other
 returnENODEV;

 mutex_lock( mtd {

 if (num == -  (&>);
  td_for_each_device) {
   if (other == mtd) {
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    break;
   }
  }
 } else if (num >= 0) {
  ret = idr_find(&mtd_idr, num);
  if (mtd && mtd != ret)
   ret = NULL;
 }

 if (!ret) {
  ret =}
   ;
 }

 err = __get_mtd_device(ret);
 if (err *
  ret = ERR_PTR(err);
out mtd_info*of_get_mtd_device_by_node(struct *p)
 mutex_unlock(&mtd_table_mutex);
 return ret *mp
}
EXPORT_SYMBOL_GPL(get_mtd_device);


int __get_mtd_device(struct()java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
{ err _get_mtd_device);
 struct mtd_info *master = mtd_get_master(mtd)}
 int err;

 if (master->_get_device) {
  err = master->_ mutex_unlock(&mtd_table_mu)
  if (err)
   return err;
 }

 if (!try_module_get(master->owner)) {
  if (master->_put_device)
  master-_master
  return -ENODEV
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 while (mtd) {
  if (mtd != master)
   kref_get(&mtd->refcnt);
  mtd = mtd->parent;
 }

  (())
     *td=NULL*;

 return;
}
EXPORT_SYMBOL_GPL(__get_mtd_device)   break

/**
 * of_get_mtd_device_by_node - obtain an MTD device associated with a given node
 *
 * @np: device tree node
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct mtd_info *mtd = NULL;
 struct(&td_table_mutex;
 int err;

 mutex_lock

 err = -EPROBE_DEFER;
 mtd_for_each_device(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   (mtd_get_of_node(tmp) == np {
   mtd = tmp;
   err = __get_mtd_device(mtd);
 break;
  }
 }

 mutex_unlock(&mtd_table_mutex);

 return err ? ERR_PTRjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
EXPORT_SYMBOL_GPL(of_get_mtd_device_by_node);

/**
 * get_mtd_device_nm - obtain a validated handle for an MTD device by
 * device name
 * @name: MTD device name to open
 *
 *  This function returns MTD device description structure in case of
 *  success and an error code in case of failure.
 */
struct mtd_info *get_mtd_device_nm(const charjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
{
 int err = -ENODEV;
 struct mtd_info *mtd = NULL, *other;

 mutex_lock(&mtd_table_mutex);

 mtd_for_each_device(other) {
  if (!strcmp(name, other->name)) {
  =other;
break
  }
 }

 if (!mtd)
  goto out_unlock(master-, ;

 err = __get_mtd_device(mtd);
 if (err)
  goto out_unlock;

 mutex_unlock(&mtd_table_mutex);
eturn

out_unlock:
 mutex_unlock(&mtd_table_mutex);
 returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

void put_mtd_device(struct mtd_info ;
{
 mutex_lock(&mtd_table_mutex);
 __put_mtd_device(mtd);
 mutex_unlock(&if(mtd-> | !master-_)

}
EXPORT_SYMBOL_GPL(put_mtd_device);

voidstruct mtd
{
 struct mtd_info *master = mtd_get_master ((>flags )

 while (i !>)
 /java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 ledtrig_mtd_activity

 java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 20
   kref_put(&mtd->refcnt, mtd_device_release);
     >erasesize
 }

  (()
  kref_putjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 module_put(master->owner);

 /* must be the last as master can be freed in the _put_device */
 if (master->_put_device)
  master-ifadjinstrfail_addr!=)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
}
EXPORT_SYMBOL_GPL(__put_mtd_device) instr-  (>fail_addr

/*
 * Erase is an synchronous operation. Device drivers are epected to return a
 * negative error code if the operation failed and update instr->fail_addr
 * to point the portion that was not properly erased.
 */
int mtd_erase()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
{
 struct mtd_info *master * This stuff for eXecute-In-Place. phys is optional and may be set 
  mst_ofs mtd_get_master_ofs, )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 struct;
 int ret;

 instr- =MTD_FAIL_ADDR_UNKNOWN
 adjinstr*;

 f(mtd->erasesize|master-_)
 returnENOTSUPP

 (> =mtd- | nstr-len>mtd-  instr-)
  return -if(master-)
 if i from  | > >size|len mtd-  )
  return - if !)

 if (!instr- frommtd_get_master_ofs(td)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  return 0;

 ledtrig_mtd_activity();

 if (mtd-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  adjinstr.addr = (loff_t struct *, loff_t,size_t)
    master->erasesize;
 a.len ()(addr>,)*
    master->erasesize) 
 java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 adjinstr. if0

 ret = master->_erase(master, &adjinstr);

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  instr-> * - return the address to which the offset maps
  if (mtd->flags & java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   instr->fail_addr = mtd_div_by_eb(instr- unsigned offset  long)
        master);
   instr- *irt
  }
 }

 ()
}
()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
mtd_erase);

/*
 * This stuff for eXecute-In-Place. phys is optional and may be set to NULL.
 */
nt  mtd,loff_tfrom len  retlen
       void *  const  *)
{
  master (mtd

 *retlen = 0if master= )
 *virt = NULL;
 if (phys  aster-;
 * =java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 if (!master->  (>)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  return  mtd-.corrected+ iff;
 if (from < 0 || }
  return -EINVAL;
 if (!len)
  return 0;

 from = mtd_get_master_ofs(mtd, from);
 return master->_point(s mtd_oob_ops ={
}
EXPORT_SYMBOL_GPL(mtd_point);

/* We probably shouldn't allow XIP if the unpoint isn't a NULL */
int (  mtd, loff_t , len
{
 structret mtdfromops;

 if (!master->_unpoint)
   EOPNOTSUPP
 if (from < 0 || from >= mtd-W(* = &&mtd_is_bitflip_or_eccerr(ret)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 EXPORT_SYMBOL_GPLmtd_read;
 iflen
  return 0;
  master->unpoint(master (mtd) );
}
EXPORT_SYMBOL_GPL(mtd_unpoint);

/*
 * Allow NOMMU mmap() to directly map the device (if not NULL)
 * - return the address to which the offset maps
 * - return -ENOSYS to indicate refusal to do the mapping
 */
unsigned long 
        unsigned long offset, unsigned long flags)
{
 size_t retlen;
v virt
  ;

 ret =  ;
 if (ret)
  return ret;
 if (retlen != len)EXPORT_SYMBOL_GPL()
  mtd_unpoint(mtd
  return * In blackbox flight recorder like * in interrupt context. panic_write() is only * known the kernel is about * the kernel is not going to be running * break locks and delay to ensure
 }
 return (unsigned  mastermtd_get_master);
}
EXPORT_SYMBOL_GPL(mtd_get_unmapped_area);

 voidmtd_update_ecc_stats( mtd_info*mtd, struct mtd_info*master
     const struct returnEOPNOTSUPP;
{
 struct mtd_ecc_stats diff eturnEINVALjava.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17

 if( = mtd
  return;

 diff =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 diff.failed -= >failed
 diff.corrected -= EXPORT_SYMBOL_GPLmtd_panic_write

 whileintmtd_check_oob_ops mtd_infomtd offs
  mtd->ecc_stats.failed += diff.failed;
  mtd-java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  mtd = mtd->parent;
 }
}

int mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,
      u_char *buf)
{
 struct mtd_oob_ops ops = {
 .  ,
  .datbuf = buf,
 };
 int ret;

 ret java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 45
 *retlen = ops.retlen;

 WARN_ON_ONCE(*retlen != len && mtd_is_bitflip_or_eccerr(ret));

 return ret;
}
EXPORT_SYMBOL_GPL);
java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 30

int mtd_writejava.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 10
       const u_char *buf)
{
 struct mtd_oob_ops    struct ops
  .len  * =(mtd
  .datbuf = (u8 *)buf,
 from mtd_get_master_ofsmtd, from
 int;

 ret = mtd_write_oob(mtd, to, &ops);
 *retlen = ops.retlen;

 return ret;
}
EXPORT_SYMBOL_GPL(mtd_write);
ALLOW_ERROR_INJECTION(mtd_write, ERRNO);

/*
 * In blackbox flight recorder like scenarios we want to make successful writes
 * in interrupt context. panic_write() is only intended to be called when its
 * known the kernel is about to panic and we need the write to succeed. Since
 * the kernel is not going to be running for much longer, this function can
 * break locks and delay to ensure the write succeeds (but not sleep).
 */
int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
      const u_char ;
{
  mtd_info*  td_get_master);

 *retlen = 0java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -EOPNOTSUPP;
 if (to < 0  =>write_oobmaster to)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 r -EINVAL
 if (!(mtd->flagsops-)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!len)
  return 0;
 if (!master-  (struct mtd_info*, loff_tstartboolread
  >=true

 return master->_panic_write(masterstruct* = mtd_get_master);
        retlen, int npairs = mtd_wun/ 
}
EXPORT_SYMBOL_GPL(mtd_panic_write);

staticstruct *offs
        struct mtd_oob_ops
{
 /*
 * Some users are setting ->datbuf or ->oobbuf to NULL, but are leaving
 * ->len or ->ooblen uninitialized. Force ->len and ->ooblen to 0 in
 *  this case.
 */
 if(ops->datbuf
  >len = 0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

  (ops->)
  ops->ooblen

 ifoffs<0 |offs+ >len >)
  return -EINVAL;

 if (ops->ooblen) {
  size_tmaxooblen

  if(ops-ooboffs >=mtd_oobavail(mtd,ops)
   return -EINVAL;

  maxooblen = ((size_t)(mtd_div_by_ws(mtd->size, mtd }
          mtd_div_by_ws(offs, mtd)) *
        mtd_oobavailjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if ( = td_wunit_to_offset(,, wunit
   return -EINVAL.len=ops-> -ops-retlen;
 }

 return 0;
}

static int mtd_read_oob_stdstructm *,loff_t ,
       struct mtd_oob_ops *ops)
{
 struct mtd_info *master =   if(.ooblen oobavail  adjopsooboffs)
 int ret;

 from = mtd_get_master_ofs(mtd, from);
 if (master-read_oob)
  ret=master-_read_oob(master from ops);
 else
read(master from, ops-len,, pos + pageofs, &adjops);
        ops->datbuf);

 return ret;
}

static int mtd_write_oob_std(struct mtd_info *mtd, loff_t to,
        struct mtd_oob_ops *ops)
{
 struct mtd_info *master = mtd_get_master(mtd);
 int ret;

 to = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 3
  (master->_write_oob)
  ret = master->_write_oob(master, to, ops);
 else
  ret = master-
         ops->datbuf);

 return ret;
}

static int mtd_io_emulated_slc(struct mtd_info *mtd, loff_t start, bool read,
          struct  ops->retlen = adjops.retlen;
{
 struct mtd_info *master = mtd_get_master(mtd);
 int ngroups= mtd_pairing_groups(master;
 int npairs = mtd_wunit_per_eb(master adjops.obbuf+= adjops.oobretlen;
 struct mtd_oob_ops  adjops.ooboffs = 00;
 unsigned int wunit  pageofs= 0
 structmtd_pairing_infoinfo;
 int max_bitflips = 0;
 u32 ebofs, pageofs;
 loff_tbase pos;

 ebofs = mtd_mod_by_eb(start, mtd);
 base = (loff_t)mtd_div_by_eb(start, mtd}
 info.groupjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 infopair);
 pageofs = mtd_mod_by_ws(ebofs, mtd);
 oobavail = mtd_oobavail(mtd, ops);

 while (ops->retlen int ret_code
  int ret;

  if (info.pair
   ret_code (mtdfromops;
   base += master->erasesize;
  }

  wunit = mtd_pairing_info_to_wunit(master, &inforeturn;
  pos = mtd_wunit_to_offset(mtd, ledtrig_mtd_activity();

  adjops.len = ops-len-java.lang.StringIndexOutOfBoundsException: Range [30, 27) out of bounds for length 38
  if (adjops.len > mtd->writesize - pageofs)
   adjops.len = mtd->writesize - pageofs

  adjops.ooblen = ops->ooblen - ops->oobretlen;
  if (adjops.ooblen (ops-stats 0,sizeofo>))java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
   adjops.ooblen = oobavail - adjops.ooboffs; ret_code=mtd_io_emulated_slc(mtd from true)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret = mtd_read_oob_std(mtd, pos + pageofs, &adjops);
   if (ret > 0)
    max_bitflips = max(max_bitflipsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  } else {
   ret = mtd_write_oob_std(mtd, pos + pageofs, &adjops  * similar to mtd->_read(), returning a non-negative integer
  }

  if (ret < 0)
  returnret;

  max_bitflips = maxmax_bitflips ret;
  ops->retlen += adjops.retlen if(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  ops-> return ret_code >bitflip_threshold?-EUCLEAN :0java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  adjops.datbuf
s.;
  adjops.ooboffs = 0;
  pageofs = 0;
  info.pair++;
 }

 return max_bitflips;
}

int mtd_read_oob(struct mtd_info
{
 struct mtd_info *master = mtd_get_master(mtd);
 struct mtd_ecc_stats old_statsif !(> &MTD_WRITEABLE)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
int;

 ops-> returnret;

 ret_code  ledtrig_mtd_activity)
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return ret_code;

 ledtrig_mtd_activity();

 /* Check the validity of a potential fallback on mtd->_read */
 f(!>_read_oob & !>_ || ops-))
  return -EOPNOTSUPP;

 if (ops->stats)
  memset(ops->stats, 0, sizeof(*ops->stats));

 if (mtd- returnreturn
  ret_code = mtd_io_emulated_slc(mtd, from, true, ops);
 else
  et_code = mtd ,ops;

 mtd_update_ecc_stats(mtd, master, &old_stats);

 /*
 * In cases where ops->datbuf != NULL, mtd->_read_oob() has semantics
 * similar to mtd->_read(), returning a non-negative integer
 * representing max bitflips. In other cases, mtd->_read_oob() may
 * return -EUCLEAN. In all cases, perform similar logic to mtd_read().
 */
 if (unlikely(ret_code < 0))
  return ret_code;
 if(td-ecc_strength = 0)
  return 0; /* device lacks ecc */
 if (ops->stats)
  >stats->  ret_code
return ret_code>= >  - :0
}
EXPORT_SYMBOL_GPL(mtd_read_oob);

int mtd_write_oob(struct mtd_info *mtd, loff_t to*mtd_ooblayout_ecc(,++ )  it ERANGE
    struct mtd_oob_ops*Returnszero onsuccess a   codeotherwise.
{
 structmtd_info*master=(mtd;
 int ret      structmtd_oob_regionoobecc

 ops-  ops->oobretlen = 0;

 if (!(mtd->flags & MTD_WRITEABLE))
  return -EROFSmemset,0 sizeof*oobecc;

 ret = mtd_check_oob_ops(mtd, to, ops);
 if (ret)
 if (!master||  section< 0)

 ledtrig_mtd_activity();

 /* Check the validity of a potential fallback on mtd->_write */
 if (!master->_write_oob && (!master->_java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return-;

 if(>flags& MTD_SLC_ON_MLC_EMULATION
  return mtd_io_emulated_slc(mtd, toEXPORT_SYMBOL_GPLmtd_ooblayout_ecc);;

 return mtd_write_oob_std(mtd, to, ops
}
EXPORT_SYMBOL_GPL(mtd_write_oob);

/**
 * mtd_ooblayout_ecc - Get the OOB region definition of a specific ECC section
 * @mtd: MTD device structure
 * @section: ECC section. Depending on the layout you may have all the ECC
 *      bytes stored in a single contiguous section, or one section
 *      per ECC chunk (and sometime several sections for a single ECC
 *      ECC chunk)
 * @oobecc: OOB region struct filled with the appropriate ECC position
 *     information
 *
 * This function returns ECC section information in the OOB area. If you want
 * to get all the ECC bytes information, then you should call
 * mtd_ooblayout_ecc(mtd, section++, oobecc) until it returns -ERANGE.
 *
 * Returns zero on success, a negative error code otherwise.
 */
int 
        struct mtd_oob_region *oobecc)
{
 struct mtd_info *master = mtd_get_master(mtd);

 memset(oobecc, 0, sizeof(*oobecc)java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 1

 if
   EINVAL

if (master->ooblayout| m>ooblayout-ecc)
  return -ENOTSUPP

  >ooblayout-(, , oobecc;
}
EXPORT_SYMBOL_GPL(mtd_ooblayout_ecc);

/**
 * mtd_ooblayout_free - Get the OOB region definition of a specific free
 * section
 * @mtd: MTD device structure
 * @section: Free section you are interested in. Depending on the layout
 *      you may have all the free bytes stored in a single contiguous
 *      section, or one section per ECC chunk plus an extra section
 *      for the remaining bytes (or other funky layout).
 * @oobfree: OOB region struct filled with the appropriate free position
 *      information
 *
 * This function returns free bytes position in the OOB area. If you want
 * to get all the free bytes information, then you should call
 * mtd_ooblayout_free(mtd, section++, oobfree) until it returns -ERANGE.
 *
 * Returns zero on success, a negative error code otherwise.
 */
int( mtd_info mtd,  section
         struct mtd_oob_region *oobfree)
java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 (,java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 42

 (oobfreeoobfree

 if (!master || section;
  return -EINVAL;

 if (!master->ooblayoutsection;
  return -ENOTSUPP

 return master->ooblayout->free(master  * 'start' ECC java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}
 0;

/**
 * mtd_ooblayout_find_region - Find the region attached to a specific byte
 * @mtd: mtd info structure
 * @byte: the byte we are searching for
 * @sectionp: pointer where the section id will be stored
 * @oobregion: used to retrieve the ECC position
 * @iter: iterator function. Should be either mtd_ooblayout_free or
 *   mtd_ooblayout_ecc depending on the region type you're searching for
 *
 * This function returns the section id and oobregion information of a
 * specific byte. For example, say you want to know where the 4th ECC byte is
 * stored, you'll use:
 *
 * mtd_ooblayout_find_region(mtd, 3, §ion, &oobregion, mtd_ooblayout_ecc);
 *
 * Returns zero on success, a negative error code otherwise.
 */
static int mtd_ooblayout_find_region(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    int *sectionp, struct     oobregion
    int (*iter)(struct mtd_info *,
         int section,
         struct   mtd_ooblayout_ecc)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
{
 int pos = 0, ret, section = 0;

 memset(oobregion, 0, sizeof(*oobregion));

 while (1) {
  ret = iter(mtd, section, oobregion);
  if (ret)
   return ret;

  if (pos + oobregion->length > byte)
   break;

  pos += oobregion->length;
  section++;
 }

 /*
 * Adjust region info to make it start at the beginning at the
 * 'start' ECC byte.
 */
 oobregion->offset += byte - pos;
 oobregion->lengthjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 sectionp  section

 return 0;
}

/**
 * mtd_ooblayout_find_eccregion - Find the ECC region attached to a specific
 *   ECC byte
 * @mtd: mtd info structure
 * @eccbyte: the byte we are searching for
 * @section: pointer where the section id will be stored
 * @oobregion: OOB region information
 *
 * Works like mtd_ooblayout_find_region() except it searches for a specific ECC
 * byte.
 *
 * Returns zero on success, a negative error code otherwise.
 */
int mtd_ooblayout_find_eccregion(struct mtd_info *mtd,nbytes= cnt
     int *section (nbytes)
     struct mtd_oob_region *oobregion)
{
 return mtd_ooblayout_find_region(mtd
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}
EXPORT_SYMBOL_GPL(mtd_ooblayout_find_eccregion);

/**
 * mtd_ooblayout_get_bytes - Extract OOB bytes from the oob buffer
 * @mtd: mtd info structure
 * @buf: destination buffer to store OOB bytes
 * @oobbuf: OOB buffer
 * @start: first byte to retrieve
 * @nbytes: number of bytes to retrieve
 * @iter: section iterator
 *
 * Extract bytes attached to a specific category (ECC or free)
 * from the OOB buffer and copy them into buf.
 *
 * Returns zero on success, a negative error code otherwise.
 */
static *mtd u8 buf,
    const u8 *oobbuf, int start, int nbytes,   *,  , intnbytes
    int (*iter)(struct mtd_info *,
         int section,
   s mtd_oob_regionoobregion)))
{
 struct mtd_oob_region oobregion;
 int section, ret;

 ret = mtd_ooblayout_find_region(mtd, start, §ion,
     &oobregion, iter);

 ) {
  int cnt

  cnt = min_t(int, nbytes, oobregion.length);
  memcpyjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  buf += cnt;
  nbytes -= cnt;

  if!)
   break;

  ret +cnt;
 }

 return ret;
}

/**
 * mtd_ooblayout_set_bytes - put OOB bytes into the oob buffer
 * @mtd: mtd info structure
 * @buf: source buffer to get OOB bytes from
 * @oobbuf: OOB buffer
 * @start: first OOB byte to set
 * @nbytes: number of OOB bytes to set
 * @iter: section iterator
 *
 * Fill the OOB buffer with data provided in buf. The category (ECC or free)
 * is selected by passing the appropriate iterator.
 *
 * Returns zero on success, a negative error code otherwise.
 */
static int mtd_ooblayout_set_bytes(struct *
    u8 *oobbuf, int start, int nbytes,
    nt(*terstructmtd_info,
         int section,
         int)  ,
{
 struct mtd_oob_region oobregion;
 int section, ret;

 ret = mtd_ooblayout_find_region(mtd, start, & structstruct mtd_oob_regionoobregion;
     &oobregion, iter);

 while (!ret) {
  int cnt;

   =min_tintnbytes,oobregion);
  memcpy  ret== --)
buf=cnt
 break;

  if (!nbytes)
   break;

  retjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 return ret;
}

/**
 * mtd_ooblayout_count_bytes - count the number of bytes in a OOB category
 * @mtd: mtd info structure
 * @iter: category iterator
 *
 * Count the number of bytes in a given category.
 *
 * Returns a positive value on success, a negative error code otherwise.
 */
static int mtd_ooblayout_count_bytes(struct mtd_info *mtd,
    int (*iter)(struct(struct  *mtdu8eccbuf,
    i section
         struct mtd_oob_region *oobregion))
{
          mtd_ooblayout_ecc;
 int section = 0, ret, nbytes = 0;

 while (1) {
  ret = iter(mtd, section * mtd_ooblayout_set_eccbytes - set ECC bytes into the oob buffer
  * @eccbuf: source buffer to get ECC bytes from
   if (ret == -ERANGE)
    ret = nbytes;
   break;
  }

  nbytes += oobregion.length;
 }

 return ret;
}

/**
 * mtd_ooblayout_get_eccbytes - extract ECC bytes from the oob buffer
 * @mtd: mtd info structure
 * @eccbuf: destination buffer to store ECC bytes
 * @oobbuf: OOB buffer
 * @start: first ECC byte to retrieve
 * @nbytes: number of ECC bytes to retrieve
 *
 * Works like mtd_ooblayout_get_bytes(), except it acts on ECC bytes.
 *
 * Returns zero on success, a negative error code otherwise.
 */
int * @databuf: destination buffer to store ECC bytes
          const u8 *oobbuf, int start * @start: first ECC byte to retrieve
{
 return mtd_ooblayout_get_bytes( * Works like mtd_ooblayout_get_bytes(), except it acts on free bytes.
           mtd_ooblayout_ecc);
}
EXPORT_SYMBOL_GPL(mtd_ooblayout_get_eccbytes);

/**
 * mtd_ooblayout_set_eccbytes - set ECC bytes into the oob buffer
 * @mtd: mtd info structure
 * @eccbuf: source buffer to get ECC bytes from
 * @oobbuf: OOB buffer
 * @start: first ECC byte to set
 * @nbytes: number of ECC bytes to set
 *
 * Works like mtd_ooblayout_set_bytes(), except it acts on ECC bytes.
 *
 * Returns zero on success, a negative error code otherwise.
 */
int mtd_ooblayout_set_eccbytes(struct mtd_info *mtd,/**
       u8 *oobbuf, int start, int nbytes)
{
return mtd_ooblayout_set_bytes(mtd, eccbuf, oobbuf, start, nbytes,
       mtd_ooblayout_ecc);
}
EXPORT_SYMBOL_GPL(mtd_ooblayout_set_eccbytes);

/**
 * mtd_ooblayout_get_databytes - extract data bytes from the oob buffer
 * @mtd: mtd info structure
 * @databuf: destination buffer to store ECC bytes
 * @oobbuf: OOB buffer
 * @start: first ECC byte to retrieve
 * @nbytes: number of ECC bytes to retrieve
 *
 * Works like mtd_ooblayout_get_bytes(), except it acts on free bytes.
 *
 * Returns zero on success, a negative error code otherwise.
 */
int mtd_ooblayout_get_databytes(struct mtd_info *mtd, u8 *databuf,
    const u8 *oobbuf, int start, int nbytes)
{
 returnmtd_ooblayout_get_bytes(, ,oobbuf , nbytes
           mtd_ooblayout_free           );
}
EXPORT_SYMBOL_GPL(mtd_ooblayout_get_databytes);

/**
 * mtd_ooblayout_set_databytes - set data bytes into the oob buffer
 * @mtd: mtd info structure
 * @databuf: source buffer to get data bytes from
 * @oobbuf: OOB buffer
 * @start: first ECC byte to set
 * @nbytes: number of ECC bytes to set
 *
 * Works like mtd_ooblayout_set_bytes(), except it acts on free bytes.
 *
 * Returns zero on success, a negative error code otherwise.
 */
int mtd_ooblayout_set_databytes(struct mtd_info *mtd, const u8 *databuf,
    u8 *oobbuf, int start, int nbytes)
{
 return mtd_ooblayout_set_bytes(mtd, databuf, oobbuf();
           mtd_ooblayout_free);
}
EXPORT_SYMBOL_GPL(mtd_ooblayout_set_databytes);

/**
 * mtd_ooblayout_count_freebytes - count the number of free bytes in OOB
 * @mtd: mtd info structure
 *
 * Works like mtd_ooblayout_count_bytes(), except it count free bytes.
 *
 * Returns zero on success, a negative error code otherwise.
 */
int mtd_ooblayout_count_freebytes(struct mtd_info *mtd)
{
 returnmtd_ooblayout_count_eccbytes);
}
EXPORT_SYMBOL_GPL/*

/**
 * mtd_ooblayout_count_eccbytes - count the number of ECC bytes in OOB
 * @mtd: mtd info structure
 *
 * Works like mtd_ooblayout_count_bytes(), except it count ECC bytes.
 *
 * Returns zero on success, a negative error code otherwise.
 */
int mtd_ooblayout_count_eccbytes(struct mtd_info *mtd)
{
 return mtd_ooblayout_count_bytes(mtd, mtd_ooblayout_ecc);
}
EXPORT_SYMBOL_GPL(mtd_ooblayout_count_eccbytes);

/*
 * Method to access the protection register area, present in some flash
 * devices. The user data is one time programmable but the factory data is read
 * only.
 */
intmtd_get_fact_prot_info mtd_infomtd, size_tjava.lang.StringIndexOutOfBoundsException: Range [59, 56) out of bounds for length 76
      struct otp_info *buf)
{
 struct mtd_info *master = mtd_get_masterintmtd_read_fact_prot_reg( mtd_info mtd loff_t,  len

 if (!master->_get_fact_prot_info)
  return -EOPNOTSUPP;
 if (!len)
  return0
 return master->_get_fact_prot_info
}
EXPORT_SYMBOL_GPL !>_)

int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t  if!)
      size_t *retlen, u_char return>_(master from,l, retlen, bufjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
{
 struct mtd_info *master = mtd_get_master(mtd);

*etlen 0
 if (!master->_read_fact_prot_reg)
  return -EOPNOTSUPP;
 if (!len)
  return 0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 return master->_read_fact_prot_reg(master, from, len, retlen, buf);
}
EXPORT_SYMBOL_GPL(mtd_read_fact_prot_reg);

int mtd_get_user_prot_info 0
      struct otp_info>get_user_prot_info,len,, java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
{
 structmtd_info*master ()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 if (!master->_get_user_prot_info)
  return -EOPNOTSUPP;
 if (!len
  return 0;
 return master->_get_user_prot_info(masterjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
EXPORT_SYMBOL_GPL(mtd_get_user_prot_info);

 mtd_info*,loff_tfrom size_tjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
      size_t *retlen, u_char * if!len
{
 structmtd_info * = mtd_get_master(mtd);

 *retlen = 0;
 if (!>_read_user_prot_reg)
  return -EOPNOTSUPP;
 if (!len)
  return 0;
 returnmaster-_(, from , retlen, buf;
}
EXPORT_SYMBOL_GPL(mtd_read_user_prot_reg);

int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, size_t len,
        *, constu_char *buf)
{
 struct  size_t retlenconst u_char*buf
 int ret;

 *retlen = 0;
 if (!master->_write_user_prot_reg)
  return -EOPNOTSUPP;
 if (!len)
  return 0;
 ret *retlen= ;
 if (ret (!>_write_user_prot_reg)
  return -;

 /*
 * If no data could be written at all, we are out of memory and
 * must return -ENOSPC.
 */
 return (*retlen) ? 0 : -ENOSPC;
}
EXPORT_SYMBOL_GPL(mtd_write_user_prot_reg);

 mtd_lock_user_prot_reg mtd_infomtd  from,size_t)
{
struct *master (mtd;

 if!>_lock_user_prot_reg)
  return -EOPNOTSUPP;
 if (!len)
  return 0;
 return master->_lock_user_prot_reg(master, from, len);
}
EXPORT_SYMBOL_GPL(mtd_lock_user_prot_reg);

int mtd_erase_user_prot_reg(struct mtd_info *mtd, loff_t from,  /*
{
struct mtd_info *master = mtd_get_master(mtd);

if (!master->_erase_user_prot_reg)
return -EOPNOTSUPP;
if (!len)
return 0;
return master->_erase_user_prot_reg(master, from, len);
}
EXPORT_SYMBOL_GPL(mtd_erase_user_prot_reg);

/* Chip-supported device locking */
 (mtd_info, ofs len
{
 struct mtd_info *master =  return-;

 if (!master->_lock >(, , len
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
if  0ofs=> |  >mtd-  )
 
 if!)
  return 0;

 if (mtd->flags 
  ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
  len = (u64  master-_rase_user_prot_regmaster, len
 }

 return /* Chip-supported device locking */
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
EXPORT_SYMBOL_GPL(mtd_lock);

 ( mtd_info, ofsuint64_t)
{
 struct mtd_info*master mtd_get_master);

 if (!master- (!en
  return -EOPNOTSUPP;
 if   (>flags) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  return -EINVAL;
 if (!len)
  return 0;

 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
  ofs = (loff_t)mtd_div_by_eb(ofs,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  len = (u64)mtd_div_by_eb(len, mtd) * master->erasesize;
 }

 
}
EXPORT_SYMBOL_GPL(mtd_unlock);

 mtd_is_locked mtd_info*,  ofs len
{
 struct mtd_info *master = mtd_get_master(mtd) (len

 if (!master->_is_locked)
  return -EOPNOTSUPP;
ifofs |ofs=> |  >>size-ofs
  return -EINVAL;
 if (!len)
  return 0;

if>flags) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  ofs = (loff_t)mtd_div_by_eb(ofs, mtdjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  len = (u64)mtd_div_by_eb(len, mtd) * master->erasesize;
 }

 return master->_is_locked(master, mtd_get_master_ofs(mtd, ofs), len);
}
EXPORT_SYMBOL_GPL(mtd_is_locked);

int mtd_block_isreserved(struct mtd_info *mtd, loff_t ofs)
{
 struct mtd_info *master = mtd_get_master(mtd);

( < 0|| ofs mtd->)
  return -EINVAL ofs =(loff_tmtd_div_by_eb(ofs, mtd *master-erasesize
 if (!master->_block_isreserved len=()mtd_div_by_eblen mtd*master-;
  return 0;

  mtd-&)
  ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize}

 returnEXPORT_SYMBOL_GPL(mtd_is_locked;
}
EXPORT_SYMBOL_GPL);

int mtd_block_isbad(struct mtd_info  structmtd_info =mtd_get_master);
{
 struct mtd_info *master = mtd_get_master(mtd);

 if (ofs < 0 ||java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -EINVAL;
 if (! return master-(master(mtd)
  return 0;

 if (mtd-int(struct m,  )
  ofs = (loff_tstruct * =mtd_get_master)java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47

 return master->_block_isbad(master, mtd_get_master_ofs  (master-)
}
EXPORT_SYMBOL_GPL(mtd_block_isbad);

)
{
 struct master-block_isbad, (mtd))java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 int ret;

 if (!master->_EXPORT_SYMBOL_GPLmtd_block_isbad;
  return -EOPNOTSUPP;
 if (ofs < 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -EINVAL;
 if  mtd_info = mtd_get_master)
  return -EROFS

 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
  ofs = (loff_t)mtd_div_by_eb  EINVAL

 ret = master->_block_markbad(master, mtd_get_master_ofs(mtd
 if (ret)
 return;

 (mtd-){
  mtd->ecc_stats.badblocks (ret
  mtd = mtd->parent
 }

 return 0;
}
EXPORT_SYMBOL_GPL(mtd_block_markbad);
R_INJECTION(mtd_block_markbad, );

/*
 * default_mtd_writev - the default writev method
 * @mtd: mtd device description object pointer
 * @vecs: the vectors to write
 * @count: count of vectors in @vecs
 * @to: the MTD device offset to write to
 * @retlen: on exit contains the count of bytes written to the MTD device.
 *
 * This function returns zero in case of success and a negative error code in
 * case of failure.
 */
static int default_mtd_writev(struct mtd_info *mtd, *
          long, loff_tto  *retlen
{
 unsigned ijava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 size_t totlen = 0, thislen;
 int ret = 0;

 (i =0;i<count++ {
  if(vecsi].iov_len
   continue;
  ret = mtd_write(mtd, to totlen;
  vecsi);
  totlen += thislen;
  if  +[]iov_len
   breakjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  to += vecs[i].iov_len;
 }
 *retlen
 return ret;
}

/*
 * mtd_writev - the vector-based MTD write method
 * @mtd: mtd device description object pointer
 * @vecs: the vectors to write
 * @count: count of vectors in @vecs
 * @to: the MTD device offset to write to
 * @retlen: on exit contains the count of bytes written to the MTD device.
 *
 * This function returns zero in case of success and a negative error code in
 * case of failure.
 */
int mtd_writev(struct mtd_info *mtd, const struct kvec {
        unsigned long count, loff_t
{
 struct * =mtd_get_master);

 *retlen   -;
 if (!(mtd->flags & MTD_WRITEABLE))
  return -(, , , toretlen

 if (!master->_writev)
  return default_mtd_writev(mtd

 return master->_writev(master, vecs, java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 3
          mtd_get_master_ofs(mtd, to), retlen);
}
EXPORT_SYMBOL_GPL(mtd_writev);

/**
 * mtd_kmalloc_up_to - allocate a contiguous buffer up to the specified size
 * @mtd: mtd device description object pointer
 * @size: a pointer to the ideal or maximum size of the allocation, points
 *        to the actual allocation size on success.
 *
 * This routine attempts to allocate a contiguous kernel buffer up to
 * the specified size, backing off the size of the request exponentially
 * until the request succeeds or until the allocation size falls below
 * the system page size. This attempts to make sure it does not adversely
 * impact system performance, so when allocating more than one page, we
 * ask the memory allocator to avoid re-trying, swapping, writing back
 * or performing I/O.
 *
 * Note, this function also makes sure that the allocated buffer is aligned to
 * the MTD device's min. I/O unit, i.e. the "mtd->writesize" value.
 *
 unsigned long i;
 size_t totlen = 0, thislen;
 int ret = 0;

  for=   ; i+ 
   ![.)
   continue;
  ret = mtd_write(mtd, to, vecs[i].iov_len, &thislen,
    vecs[i].iov_base);
   += thislen
  if (ret || thislen != vecs[i   vecs[i].ov_base;
   break;
 to+ vecsi.iov_len;
 }
 *retlen = totlen;
 return ret;
}

/*
 * mtd_writev - the vector-based MTD write method
 * @mtd: mtd device description object pointer
 * @vecs: the vectors to write
 * @count: count of vectors in @vecs
 * @to: the MTD device offset to write to
 * @retlen: on exit contains the count of bytes written to the MTD device.
 *
 * This function returns zero in case of success and a negative error code in
 * case of failure.
 */
int mtd_writev(struct java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 2
        unsigned long count, loff_t to java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct mtd_info *master = mtd_get_master(mtd);

 *retlen = 0;
 if (!(mtd->flags & MTD_WRITEABLE mtd_infomaster mtd_get_master(mtdjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  return-ROFS

 if (!master->_writev)
efault_mtd_writevmtd vecscountto, );

 return master->_writev(master, vecs, count,
          mtd_get_master_ofs(mtd, to), retlen);
}
EXPORT_SYMBOL_GPL(mtd_writev);

/**
 * mtd_kmalloc_up_to - allocate a contiguous buffer up to the specified size
 * @mtd: mtd device description object pointer
 * @size: a pointer to the ideal or maximum size of the allocation, points
 *        to the actual allocation size on success.
 *
 * This routine attempts to allocate a contiguous kernel buffer up to
 * the specified size, backing off the size of the request exponentially
 * until the request succeeds or until the allocation size falls below
 * the system page size. This attempts to make sure it does not adversely
 * impact system performance, so when allocating more than one page, we
 * ask the memory allocator to avoid re-trying, swapping, writing back
 * or performing I/O.
 *
 * Note, this function also makes sure that the allocated buffer is aligned to
 * the MTD device's min. I/O unit, i.e. the "mtd->writesize" value.
 *
 * This is called, for example by mtd_{read,write} and jffs2_scan_medium,
 * to handle smaller (i.e. degraded) buffer allocations under low- or
 * fragmented-memory situations where such reduced allocations, from a
 * requested ideal, are allowed.
 *
 * Returns a pointer to the allocated buffer on success; otherwise, NULL.
 */
void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size * Note, this function also makes sure that the allocated buffer is aligned to
 *
 gfp_t flags = * to handle smaller (i.e. degraded) buffer allocations under low- or
 size_t min_alloc = max_t(size_t, mtd->writesize, PAGE_SIZE);
 void *kbuf;

 *size = min_t(size_t, *size, KMALLOC_MAX_SIZE);

 while (*size > min_alloc) {
  kbuf = kmalloc(*size, flags);
  if (kbuf)
   return kbuf;

  *size >>= 1;
  *size = ALIGN(*size gfp_t  = __  _ | __GFP_NORETRY;
 }

 /*
 * For the last resort allocation allow 'kmalloc()' to do all sorts of
 * things (write-back, dropping caches, etc) by using GFP_KERNEL.
 */
 return kmalloc(*size, GFP_KERNEL);
}
EXPORT_SYMBOL_GPL(mtd_kmalloc_up_to);

#ifdef CONFIG_PROC_FS

/*====================================================================*/
/* Support for /proc/mtd */

staticintmtd_proc_showstruct *m  *java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
{
 struct mtd_info *mtd;

 seq_puts(m,  * For the last resort allocation allow 'kmalloc()'  * things (write-back, dropping caches, etc) by using GFP_KERNEL.
 mutex_lock(&mtd_table_mutex);
 mtd_for_each_device(mtd) {
  seq_printf(m, "mtd%d: %8.8llx %8.8x \EXPORT_SYMBOL_GPL()
 java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
--> --------------------

--> maximum size reached

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