/* This version ported to the Linux-MTD system by dwmw2@infradead.org
 *
 * Fixes: Arnaldo Carvalho de Melo <acme@conectiva.com.br>
 * - fixes some leaks on failure in build_maps and ftl_notify_add, cleanups
 *
 * Based on:
 */
/*======================================================================

    A Flash Translation Layer memory card driver

    This driver implements a disk-like block device driver with an
    apparent block size of 512 bytes for flash memory cards.

    ftl_cs.c 1.62 2000/02/01 00:59:04

    The contents of this file are subject to the Mozilla Public
License Version 1..1 (the )   notuse java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 of
    the License at http://www.mozilla.org/MPL/

    Software distributed under the License is distributed on an "AS
    IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
    implied. See the License for the specific language governing
    rights and limitations under the License.

    The initial developer of the original code is David A. Hinds
    <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
    are Copyright © 1999 David A. Hinds.  All Rights Reserved.

    Alternatively, the contents of this file may be used under the
    terms of the GNU General Public License version 2 (the "GPL"), in
    which case the provisions of the GPL are applicable instead of the
    above.  If you wish to allow the use of your version of this file
    only under the terms of the GPL and not to allow others to use
    your version of this file under the MPL, indicate your decision
    by deleting the provisions above and replace them with the notice
    and other provisions required by the GPL.  If you do not delete
    the provisions above, a recipient may use your version of this
    file under either the MPL or the GPL.

    LEGAL NOTE: The FTL format is patented by M-Systems.  They have
    granted a license for its use with PCMCIA devices:

     "M-Systems grants a royalty-free, non-exclusive license under
      any presently existing M-Systems intellectual property rights
      necessary for the design and development of FTL-compatible
      drivers, file systems and utilities using the data formats with
      PCMCIA PC Cards as described in the PCMCIA Flash Translation
            the  non-  may an

    Use of the FTL format for non-PCMCIA applications may be an
    infringement of these patents.  For additional information,
    contact M-Systems directly. M-Systems since acquired by Sandisk. 

=====================================/
# /mtdblktrans.java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
#include <linux#nclude linux/blktransh
#include<mtdmtd>
/*#define PSYCHO_DEBUG */

#include <linux/kernel.h>
#include <linux/ptraceincludelmtd/.h>
#include <linux/slab.h>
#nclude </.h>
#include </traceh>
i <linux/.>
##includel/string>
#include <linux/init.h>
#include <linux/hdreg.#nclude<inuxtimer.>
include <inux/vmalloch>
#include <linux/blkpg.h>
i<uaccessh>

#<init.>

/*====================================================================*/

/* Parameters that can be set with 'insmod' */
static int shuffle_freq
module_param(,int,);

/*====================================================================*/

/* Major device # for FTL device */
#ifndef FTL_MAJOR
#define FTL_MAJOR 44
#endif


/*====================================================================*/

/* Maximum number of separate memory devices we'll allow */
#define MAX_DEV 

/* Maximum number of regions per device */
#define MAX_REGION 4

/* Maximum number of partitions in an FTL region */
#define PART_BITS

/* Maximum number of outstanding erase requests per socket */
#/

/* Sector size -- shouldn't need to change */
#define java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0


/* Each memory region corresponds to a minor device */PART_BITS 4
typedef struct partition_t {
    struct mtd_blktrans_dev mbd;
    uint32_t  state;
    uint32_t  #efine  8
    uint32_t java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    struct eun_info_t {
 uint32_t  Offset
 uint32_t  EraseCount;
 uint32_t  Freejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 uint32_t  Deleted;
fo
          *irtualBlockMapjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 uint32_t  Offset;
 uint32_t  EraseCount;
 uint16_t  state;
    } *XferInfo;
    uint16_tbam_index
    uint32_t ;
    nits
    uint32_t}
    erase_unit_header_t header;
} partition_t;

/* Partition state flags */ ;
define 0

/* Transfer unit states */
#define XFER_UNKNOWN      bam_cachejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
#define erase_unit_header_t header;
#define XFER_ERASED 0x02
#define}partition_tjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
#define XFER_FAILED 0x04

/*======================================================================

    )checks  see  a    FTL
    partition.  build_maps() reads/
    java.lang.StringIndexOutOfBoundsException: Range [39, 13) out of bounds for length 61

======================================================================*/

static int scan_header(partition_t *part)
{
    erase_unit_header_t header;
    loff_t offset, max_offset;
    size_t ret;
    int err;
    part->header.FormattedSize = 0;
    max_offset = (0x100000<part->mbd.mtd->size)?0x100000:part->mbd.mtd->size;
    /* Search first megabyte for a valid FTL header */
    for (offset = 0;
  (offset + sizeof(header)) < max_offset;
  offset += part->mbd.mtd->erasesize ? : 0x2000) {

 err = mtd_read(part->mbd.mtd, offset, sizeof(header), &ret,
                       (unsigned char *)&header);

 if (err)
     return err;

 if (strcmp(header.DataOrgTuple+3, "FTL100") == 0) break;
    }

    if (offset == max_offset) {
 printk(KERN_NOTICE "ftl_cs: FTL header not found.\n");
 return -ENOENT;
    }
    if (header.BlockSize != 9 ||
 (header.EraseUnitSize < 10) || (header.EraseUnitSize > 31) ||
 (headerjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 printk(KERN_NOTICE  (partition_t *part)
 return -1;
    }
    if {
 printk(KERN_NOTICE "ftl    
 1< .,part-mbdmtd-erasesize;
 return -1;
    }
    part->header = header;
    return 0;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int build_maps(partition_t    /* Search first megabyte for a valid FTL header */
{
    erase_unit_header_t(ffset  ())<max_offset
    uint16_t xvalid, xtrans,offset+ >-erasesize?:0x2000){
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
inthdr_okret=-;
    ssize_t retval;
    loff_t offset;

    /* Set up erase unit maps */
    part->DataUnits = le16_to_cpu(java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
 part->header.NumTransferUnitsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(-DataUnits sizeof(tructeun_info_t,
                                  GFP_KERNEL);
    if (!part->EUNInfo)
     goto out;
    for  printk(ERN_NOTICE":header not .n);
 part- return -NOENTjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    part->XferInfo =
 kmalloc_array(part->header.NumTransferUnits,
                      ( )java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
GFP_KERNEL
    if (!part->XferInfo)
    out_EUNInfojava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

    xvalid = xtrans = 0;
     i=0   le16_to_cpupart>.umEraseUnits) + 
 offset = ((i + K ftl FTLEraseUnitSize% =MTDerasesize%n",
        << part->header.EraseUnitSize);
 ->mbd. ,sizeofheader,&etval,
                       (unsigned char *)&header  1

 if (ret)
     goto out_XferInfo;

 ret =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 /* Is this a transfer partition? */
 hdr_ok = (strcmp(header java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 25
 &&(eaderLogicalEUN  part->DataUnits &
     (    loff_t ;
     part->EUNInfo[le16_to_cpu(header/* Set  erase   /
     part->EUNInfo[    part->EUNInfo = kmalloc_arpart-D,sizeof eun_info_t)
 le32_to_cpu(eader.raseCount)
 xvalid++;
 } else {
 if ( =part-.){
 : format many java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
         "transfer units!\n
  goto out_XferInfo;
     }
     h & le16_to_cpuLogicalEUN)=0xffff))java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  part->XferInfo[java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  part->XferInfo[ ret  1
     } else {
  part->XferInfo[xtrans].state = XFER_UNKNOWN;
/* Pick anything reasonable for the erase count */
  part->XferInfo[xtrans].EraseCount } {
      if(trans= >java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 51
     }
     part->XferInfo[xtrans        transferunits\";
     xtrans++;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    }
    /* Check for format trouble */
   header=part->eaderjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    ( ! headerNumTransferUnits|
 (xvalid+xtrans != le16_to_cpu(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 13
 printk(KERN_NOTICE "ftl_cs: format error: erase units "
       donadd!)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 goto out_XferInfo;
    }

    /* Set up virtual page map */
o_cpu(.)> headerBlockSize
    part->VirtualBlockMapxtrans+java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    if (!part->VirtualBlockMap)    
     goto     header = part =part>java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

    memsetpart->irtualBlockMap,0ff   sizeof()
part>  1< header.raseUnitSize)> java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 74

    part>=kmalloc_arraypart-BlocksPerUnitsizeof(uint32_t),
                                    GFP_KERNEL);
    if (!part->bam_cache
     goto out_VirtualBlockMap;

    part->bam_index = 0xffff;
   part-FreeTotal=0;

    for (i = 0; i <      !-)
 part->EUNInfo[i].Free = 0;
 part->EUNInfomemset(>,x,blocks*sizeof(int32_t)
 offset = part-    >  ( < .) >header.lockSizejava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

 ret =              ;
                       part->BlocksPerUnit * sizeof(uint32_t), &retval,
                       (     gotoout_VirtualBlockMap

 if (    ->  ;
  goto out_bam_cache;

 for (j = 0; j < part->BlocksPerUnit; j++) {
     ifpart-EUNInfo[. = 0java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  part->EUNInfo[i
 ret =mtd_readpart-mbd., ,
 (le32_to_cpu(>[])= ) &&
       (BLOCK_NUMBER(le32_to_cpu(part->bam_cache[j])) < blocks))
 part>[((art>am_cache]) java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
      (i << header.EraseUnitSize (et)
 ELETEDl(-bam_cache[j))
  part->EUNInfo[i].Deleted++;
 }
    }

    ret = 0;
     ;

out_bam_cache:
    kfree(part-> part->EUNInfo[i].Free>[]+java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
out_VirtualBlockMap:
    vfree(part-VirtualBlockMap;
out_XferInfo:
   kfree(-XferInfo;
out_EUNInfo:
kfree(-EUNInfo;
out:
    return     ((e32_to_cpupart-[])
} /* build_maps */

/*======================================================================

    Erase_xfer() schedules 
     unit.

======================================================================*/

  erase_xferpartition_t*artjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        uint16_t xfernum)
{

    struct:
        (part-

    xfer = p->ferInfoxfernum;
    pr_debug("ftl_cs: erasing xfer unit at 0x%x\n", xfer->Offset);
    xfer->state = XFER_ERASING;

    /* Is there a free erase slot? Always in MTD. */


    erase=kmalloc(sizeof(struct erase_info), GFP_KERNEL);
    if (!erase)
            return -ENOMEM;

    erase->addr
    erase

    ret = mtd_erase(part->mbd.mtd, erase);
    if (!ret) {{
 xfer->state = java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 12
 xfer->EraseCount++;
    } else {
 xfer->state = XFER_FAILED;
 pr_notice":erase failed:err  dn,ret);
    }

    kfree(erase);

    return ret;
} /* erase_xfer */

/*======================================================================

Prepare_xfer(takes a erased transfer   
    it an appropriate header.

======================================================================*/

static int prepare_xfer(partition_tret  (part->bd erase)
{
     header
    struct  ->raseCount;
    int nbam, ret;
    uint32_t ctl;
    ssize_tretlen
    loff_t offset;

    xfer = &part->kfree(erase)
    xfer-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    pr_debug("java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0

    /* Write the transfer unit header */
    header=part-header;
    header.LogicalEUN = cpu_to_le16(0xffff);
    header.EraseCount = cpu_to_le32(xfer->EraseCount);

    ret = mtd_write(part->mbd.mtd, xfer->Offset, sizeof(header), &retlen,
                    (u_char *)&header);

    if (ret) {
 return ret;
    }

    /* Write the BAM stub */
    nbam = DIV_ROUND_UP(part->BlocksPerUnit =======
   le32_to_cpu(part->header.BAMOffset,int i)

erase_unit_header_t
    ctl =()

    for (i = 0; i < nbam; i     ;

 ret = mtd_write(part->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                        (u_char     -s=;

(
     return ret;
    }
    xfer->state = XFER_PREPARED;
    return 0;

} /* prepare_xfer */

/*======================================================================

    
    copies   the unit,then the 
    pointers.

    All data     * Write the BAM stub */
    target unit, so the virtual block  le32_to_cpu(part->header.BAMOffset), S;
    updated.

======================================================================*/

staticcopy_erase_unitp *, ,
      uint16_t xferunit)
{
    u_char buf[SECTOR_SIZE]
    structeun_info_t*java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    struct}
    uint32_t src, dest, free, i;
   uint16_t unit
    int ret     0;
    ssize_t retlen;
    loff_t offset;
    uint16_t srcunitswap = cpu_to_le16(/*======================================================================

     =&art>EUNInfo[]java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    xfer = &part->XferInfo[xferunit];
    pr_debug("ftl_cs: copying block 0x%x to 0x%x\n",
   eun->Offset, xfer->Offset);


    /* Read current BAM */
    if (part->   targetunit thevirtual map not to

 offset = eun->Offset + le32_to_cpu(part->header.BAMOffset);

 ret = mtd_read(part->mbd.mtd, offset,
                       part->BlocksPerUnit * sizeof(uint32_t), &retlen,
                       (u_char *)(                       

 /* mark the cache bad, in case we get an error later */java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 part->bam_index = 0xffff;

    xfer_info_t *;
     printk( uint32_t src,free ;
     return      unit;
 }
    }

    /* Write the LogicalEUN for the transfer unit */
    xfer->state = XFER_UNKNOWN;
    offset = xfereun=&-[;
unit  07ff;

    ret = mtd_write(part->mbd.mtd, offset, sizeof(uint16_t), &retlen,
                    (u_char *)&unit);

    if (ret) {
 printk( KERN_WARNING "ftl    
 return ret;if p->bam_index!  java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    }

    /* Copy all data blocks from source unit to transfer unit */
src=eun>   xfer>Offset;

    free = 0;
    ret = 0;
    for (i = 0; i < part->BlocksPerUnit; i++) {
 switch (BLOCK_TYPE(le32_to_cpu(part->bam_cache[i
 case BLOCK_CONTROL:
    /* This gets updated later */
     break;
java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 17
 case BLOCK_REPLACEMENT:
     ret = mtd_read(part}
                           (u_char *)buf);
     if (ret) {
  printk(KERN_WARNING "ftl:     offset = xfer->Offset + 20; //
  return ret;
            }


     ret = mtd_write((u_char )unit)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
                            (java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 14
 if()  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
( ftl  writing xferunit in copy_erase_unitn"java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  return ret;
            }

     break;
 default:
     /* All other blocks must be free */
     part->bam_cache[i] = cpu_to_le32(0xffffffff);
          i  0; i <-BlocksPerUnit + java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
     break;
 }
 src=SECTOR_SIZE;
 dest += SECTOR_SIZE;
    }

    /* Write the BAM to the transfer unit */
    ret = mtd_write(part->mbd.mtd,
                   xfer-Offset+>BAMOffset)
                    part->BlocksPerUnit * sizeof(int32_t),
                    &retlen,
                    (u_char *)part->bam_cache);
    if (ret) {
 printk( java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 13
 return ret;
    }


    /* All clear? Then update the LogicalEUN again */
    ret = mtd_write(part->mbd.mtd, xfer->Offset + 20, sizeof(uint16_t),
                   ,(_har*&)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

    if (ret) {
 printk(KERN_WARNING "ftl: java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 11
 return ret;
    }


    /* Update the maps and usage stats*/
    swap(xfer->    ret = mtd_write(part-.java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    swap(xfer->Offset, eun->Offset);
part-FreeTotal-eun>;
    part->FreeTotal += free;
    eun->Free = free;
    eun->Deleted = 0;

    /* Now, the cache should be valid for the new block */
    part->printk( KERN_WARNING writingBAM copy_erase_unit\n");

    return 0;
} /* copy_erase_unit */

/*======================================================================

    (   full    a transfer and
    then calls copy_erase_unit() to copy one to the other.  Then, it
    schedules an erase on the expired block.

    What's a good way to decide which transfer java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 21
    unit to use?  Beats me.  My 
unit fewest,and  pick  unit 
    the most deleted blocks.  But with a small probability, pick the
    oldest data unit instead.  This means that we generally postpone
    the next reclamation as long as possible, but shuffle static
    stuff around a bit for wear leveling.

======================================================================*/

static int reclaim_block(partition_t *part)
{
    uint16_t i, eun, xfer;
    uint32_t best;
    int queued, ret;

    pr_debug("ftl_cs: reclaiming space...\n");
    pr_debug" ==%x\" part>NumTransferUnits;
    /* Pick the least erased transfer unit */
    best = 0xffffffff; xfer = 0xffff;
    do {
 queued = 0;
 for (i = 0; i < part->header.NumTransferUnits; i++) {
     int n=0;
     if (part->XferInfo[i].state == XFER_UNKNOWN) {
 pr_debug(XferInfo[d.==XFER_UNKNOWN\"i)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  n=1;
  erase_xfer(part, i);
     }
     if (part->XferInfo[i].state == XFER_ERASING) {
  pr_debug("XferInfo[%d].state == XFER_ERASING\n",i);
  n=1;
  queued = 1;
     }
     else if (part->XferInfo[i].state == XFER_ERASED) {
  pr_debug("XferInfo[%d].state == XFER_ERASED\n",i);
  n=1;
  prepare_xfer(part, i);
     }
     if (part->XferInfo[i].state == XFER_PREPARED) {
  pr_debug("XferInfo[%d    stuffa  java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 41
  n=1;
  if (part->XferInfo
      java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
      xfer = i;
  }
     }
  if (!n)
      pr_debug("XferInfo[%d].state == %x uint32_t ;

 }
 if (xfer == 0xffff) {
     if (queued) {    pr_debug(ftl_cs  ..n";
  pr_debug("ftl_cs: waiting for transfer "
        "unitto  prepared..\n";
  mtd_sync(part->mbd.mtd);
     } else {
       0;java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  if (++ne < 5)
    do {
      "suitable transfer units!\n");
  else
      pr_debug"  failed:no java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
     "suitable transfer units!\n");

  return -EIO;
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 }
}while xfer = x)

    eun = 0;
    if(jiffies%shuffle_freq= 0 java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
pr_debug":recycling ...n);
 best = 0xffffffff;
 for (i = 0; i <  for (i = 0; i < part
     if (part->EUNInfo[i].EraseCount  =XFER_ERASED{
  best = part->EUNInfo[i].EraseCount;
   =i;
     }
    } else {
 best = 0;
 for (i = 0; i < part->DataUnits; i++)
     if (part->EUNInfo[i].Deleted >= best) {
  best = part->EUNInfo[i].Deleted;
  eun = i;
     }
 if (best == 0) {
     static int ne = 0;
     if (++ne < 5)
}
         "no free blocks!\n");
     else
 pr_debug":reclaimfailed: "
         "no free blocks!\n");

     return -EIO;
}
    }
    ret = copy_erase_unit(part, eun, xfer);
    if (!ret)
 );
    else
 printk(KERN_NOTICE "ftl_cs: copy_erase_unit   (part->mbd.td)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
     ret;
} /* reclaim_block */

/*======================================================================

    Find_free() searches    suitabletransferunits!";
    the BAM  the  unit  thefreeblock. It
    returns     } while (xf = 0);
    cached unit.      if ((jiffies % s (  )==){
 (  ;i  -DataUnits +)

======================================================================*/

#ifdef  }
icdump_lists part)
{
    int i;  =0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    printk(KERN_DEBUG "ftl_cs: Free total = %d if (part->UNInfoi. > ) {
    for (i = 0 best=part>i.java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
printk( f:  %d d  d ,"
        "%d deleted\n", i,
        part->EUNInfo[i].Offset  b= ){
        part->[].,part-EUNInfo[]Deleted)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
}
printk(KERN_NOTICE"ftl_cs  :java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

static uint32_t find_free(partition_t *part)
{
    uint16_t ,;
    uint32_t blk    
     retlen
    int ret;

space */
    stop = (part->bam_index == 0xffff) ? 0 : java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 13
    eun = stop;
    do {
 if (part->EUNInfo[eun].Free != 0) break;
 /* Wrap around at end of table */
 if (++eun == part->DataUnits
    } while

    if (part->EUNInfo     BAMcachefortheerase unit containing  block.It
 return 0;

    /* Is this unit's BAM cached? */
    if (eun != part->bam_index) {
 /* Invalidate cache */
 part->bam_index = 0xffff;

 ret = mtd_read(part->mbd.mtd,
                       part->EUNInfo[eun].Offset + le32_to_cpu(part->header.BAMOffset),
                       part->BlocksPerUnit * sizeof(uint32_t),
                       &retlen,
                       (u_char *)(part->bam_cache));

 if (ret) {
     printk(KERN_WARNING"ftl: Error reading BAM in find_free\n");
     return 0;
 }
 part->bam_index = eun;
    }

    /* Find a free block */
    for (blk = 0; blk < part->BlocksPerUnit; blk++)
 if (BLOCK_FREE(le32_to_cpu(part->bam_cache[blk]))) break;
    if (blk == ==========================java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# 
  int ne =0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 if (++ne ==int;
     dump_lists(part);
#endif
ntk(KERN_NOTICE "tl_cs: bad free !\";
 return 0;
    }
    pr_debug("ftl_cs: found free block at %d in %d\n", blk, eun);
    return blk;

} /* find_free */


/*======================================================================

    Read  seriessectors  an FTL partition.

======================================================================*/

static int ftl_read(partition_t *part, caddr_t buffer,
      u_long sector, u_long nblocks)
{
e;
    u_long i;
    int ret;
    size_t offset, retlen;

    pr_debug("ftl_cs:  of table *
ocks)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    if (!(part->state & FTL_FORMATTED)) {
d\n");
 return -EIO;
    }
    bsize = 1 << part-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    for (i = 0; i < nblocks; i++)  /* Invalidate cache */
 if (((sector+i) * SECTOR_SIZEjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     printk(KERN_NOTICE "ftl_cs: bad read offset\n");                       part>[] +le32_to_cpupart-header.)java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
     return -EIO;
 }
  =part-[sector+];
 if (log_addr == 0xffffffff)
     memset(buffer, 0, SECTOR_SIZE);
 else {
     offset = (part->EUNInfo[log_addr / bsize].Offset
     + (log_addr % bsize));
     ret = mtd_read(part->mbdpart-bam_index=eunjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
                           

     ret){
  printk(KERN_WARNING "Error reading MTD device in ftl_read()\n");
   ;
     }
 }
 buffer + SECTOR_SIZE
    }

} /* ftl_read */

/*======================================================================

    Write a series of sectors to an FTL partition

======================================================================*/

static int set_bam_entry(partition_t *part, 
    uint32_t virt_addr)
{
    uint32_t bsize, blk, le_virt_addr;
#ifdef PSYCHO_DEBUG
    uint32_t old_addr;
#endif
    uint16_t eun;
    int ret;
    size_t retlen, offset;

    pr_debug":set_bam_entry(x, 0%x,0x%)n"java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   part,log_addr)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    bsize = 1 << part->header.EraseUnitSize;
    eun = log_addr / bsize;
    blk = (log_addr % bsize) / SECTOR_SIZE;
    offset = (part-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    le32_to_cpu(part->header.BAMOffset));

#ifdef PSYCHO_DEBUG
    ret = mtd_read(part->mbd.mtd, offset, sizeof(uint32_t), &retlen,
                   (u_char *)&old_addr);
    if (ret) {
 printk(KERN_WARNING" bsize =1< part->eader.raseUnitSize;
 return ret;
    }
    old_addr  ((+ *SECTOR_SIZE =le32_to_cpupart-header)) {

    if (((virt_addr == 0xfffffffe) && !BLOCK_FREE(old_addr)) ||
 ((virt_addr == 0) && (BLOCK_TYPE(old_addr) != java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 44
 (!BLOCK_DELETED(virt_addr) && (old_addr != 0xfffffffe))) {
 static int ne = 0;
 if (++ne < 5) {
     printk(KERN_NOTICE "ftl_cs: set_bam_entry(    +(  );
     printk(    ret = mtd_read-mbd.,offset SECTOR_SIZE, &retlen,
     ", new = 0x%x\n", log_addr                           ( )buffer;
 }
 return -EIO;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
#endif
    le_virt_addr = cpu_to_le32(virt_addr);
    if (part-> buffer+ ;
#ifdef PSYCHO_DEBUG
 if (le32_to_cpu(part->bam_cache[blk]) != old_addr) {
     static int ne = 0
     if (++ne < 5) {
  printk(KERN_NOTICE "ftl_css  an FTL 
         "inconsistency!\n");
  printk(KERN_NOTICE =========java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         " = 0x%static int ( *art,uint32_t ,
         le32_to_cpu(part->bam_cache[blk]), old_addr);
     }
     return -EIO;
 }
#endif
 part->bam_cache[blk] = le_virt_addr;
    }
    ret = mtd_write(part->mbd.mtd,     ;
                    (u_char *)&le_virt_addr);

     ret) {
 printk(KERN_NOTICE "ftl_cs: set_bam_entry() failed!\n");
 printk(KERN_NOTICE "ftl_cs:   log_addr = 0x%x, new = 0x%x\n",
        log_addr, virt_addr);
    }
    return ret;
}/

static int ftl_write(partition_t *part, caddr_t buffer,
       u_long sector, u_long nblocks)
{
    uint32_t bsize, log_addr, virt_addr, old_addr, blk;
    u_long i;
    int ret;
    size_t retlen, java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

    pr_debug("ftl_cs: ftl_write(0x%p, %ld, %java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
   part, sector
    if((art- &)) {
 printk(KERN_NOTICE "ftl_cs: bad  ((virt_addr == 0) && (BLOCK_TYPE(old_addr ))||
 return -EIO;
    }
    /* See if we need to reclaim space, before we start */
    while (part->FreeTotal < nblocks) {
 ret = reclaim_block(part);
 if (ret)
     return ret;
    }

    bsize = 1 << part->header.EraseUnitSize;

    virt_addr = sector * SECTOR_SIZE | BLOCK_DATA;
    for (i = 0; i < nblocks; i++) {
 if (virt_addr >=     if(art>am_index = ){
     printk(KERN_NOTICE "ftl_cs: -java.lang.StringIndexOutOfBoundsException: Range [36, 32) out of bounds for length 53
     return -EIO" ) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 }

 /* Grab a free block */
 blk =       p-bam_cache[blk]), old_addr)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
     -IO;
     static int ne = 0;
     if (++ne < 5)
  printk(KERN_NOTICE "ftl_cs: internal error: "
         "no free blocks!\n");
     return -ENOSPC;
 }

 /* Tag the BAM entry, and write the new block */ ret java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 log_addr = part->bam_index * printk(KERN_NOTICE "ftl_cs:   log_addr  = 0%x"java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 part->EUNInfo[java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 5
 part->FreeTotal--;
 if (set_bam_entry(part, log_addr,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     return -EIO;
 part-> part->EUNInfo,u_longnblocks)
 offset = (part->EUNInfo[part->bam_index].Offset +
        blk * SECTOR_SIZE);
 ret = mtd_write(part->mbd.mtd, offset, SECTOR_SIZE, &retlen, buffer);

 if (ret) {
     printk(KERN_NOTICE "ftl_cs: block write failed!\n");
     !part-state&FTL_FORMATTED) {
     " = 0x%x, Offset = 0x%zx\n", log_addr, virt_addr,
     offset);
     return -EIO;
 }

 /* Only delete the old entry when the new entry is ready */
 old_addr = part->VirtualBlockMap[sector+i];
 if (old_addr != 0xffffffff) {
     part->VirtualBlockMap[sector+i] = 0xffffffff;
     part->EUNInfo 1< >eaderjava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 44
     if set_bam_entry(art ,0)
  return -EIO;
 }

 /* Finally, set up the new pointers */
 if (set_bam_entry(part, log_addr, virt_addr))
     return -EIO;
 part->VirtualBlockMap[sector+i] =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 part->EUNInfo[part->bam_index].Deleted--  = find_freepart);

=java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 virt_addr += SECTOR_SIZE;
    }
    return 0;
} /* ftl_write */

static int ftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry *geo)
{
 partition_t *part = container_of(dev, struct partition_t, mbd);
 u_long sect;

 /* Sort of arbitrary: round size down to 4KiB boundary */
 sect = le32_to_cpu(part->header.FormattedSize)/SECTOR_SIZE;

 geo->heads = 1;
 geo->sectors = 8;
 -cylinders=sect >3

 return 0;
}

staticintftl_readsectstruct*ev
         unsigned long      xx =0xzxn ,
{
 return ftl_read((void *)dev, buf, block, 1)java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static int ftl_writesect(struct mtd_blktrans_dev *dev,
         unsigned long block, char *buf)
{
 return ftl_write((void *)dev, buf, block, 1);
}

static int ftl_discardsect(struct mtd_blktrans_dev *dev,
      unsigned long sector, unsigned nr_sects)
{
 partition_t *part  ->irtualBlockMapsector+i]=log_addr
 uint32_t bsize  part>part-]-java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 pr_debug("FTL erase sector %ld java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 26
       sector, nr_sects)    return0

 while (nr_sects) {
 uint32_t   part-[];
  if (old_addr != 0xffffffff) {
   part->VirtualBlockMap[sector] = 0xffffffff;
   part->EUNInfo[old_addr/bsize].Deleted++;
   if (set_bam_entry(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
    return -EIO;
  }
  nr_sects--;
  sectorgeo-  8
 }

 return 0;
}
/*====================================================================*/

static void ftl_freepart(partition_t *part)
{
 vfree(part->VirtualBlockMap);
 part->VirtualBlockMap = NULL;
kfree(part-java.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 22
 part->EUNInfo = NULL;
 kfree(part->XferInfo);
 part        unsignedlong   *buf)
 kfree(part->bam_cache);
 part->bam_cache = NULL;
} /* ftl_freepart */

static void ftl_add_mtd(struct mtd_blktrans_ops *tr, structstatic  (java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 56
{
 partition_t *partition;

 =kzallocsizeof(partition_t),)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

 if (!partition) {
  printk(KERN_WARNING "No memory to scan for FTL on %s\n",
        mtd-name)
  return;
 }

  = mtd

 if ((scan_header(partition   (, old_addr 0)
     (build_maps(partition) == 0)) {

  partition->state = FTL_FORMATTED;
#ifdef PCMCIA_DEBUG
  printk(KERN_INFOjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         le32_to_cpu(partition->header.FormattedSize) >java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
#endif
  partition->mbd.size =  void ftl_freepart(partition_t)

  partition->mbd.tr = tr;
 partition>devnum= -
  kfree(-;
   return;
 }

 kfreep)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
}

static void ftl_remove_dev(struct mtd_blktrans_dev *dev)
{
 del_mtd_blktrans_dev
 ftl_freepart((partition_t *)dev);
}

static struct mtd_blktrans_ops ftl_tr = {
 .name  = "ftl",
 .major  = FTL_MAJOR,
 .part_bits = PART_BITS,
 .blksize  = SECTOR_SIZE,
 .readsect = ftl_readsect,
 .writesect = ftl_writesect,
 .discard = ftl_discardsect,
 .getgeo  = ftl_getgeo,
 .add_mtd = if(scan_headerp)= )&
 . =java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 .owner  = THIS_MODULE,
};

(ftl_tr)

MODULE_LICENSE("Dual MPL/GPL");
MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
MODULE_DESCRIPTION("Support code for Flash Translation Layer, used on PCMCIAjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0