/* 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*/
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

    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 "License"); you may not use this file
         Version 11 (the"License";you may not this file
    the License at http://www.mozilla.org/MPL/

    Software distributed under the License is distributed on opy 
    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
      Layer (FTL) Specification."

e of  FTLformat forPCMCIAapplications bejava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    infringement =================================*
    include<linux/blktrans.>

======================================================================*/
i<mtd/.>
#include <linux/#include linux//mtd.hjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
#include <inux/mtd.h>
/*#define PSYCHO_DEBUG */

i <inuxkernel.h>
#<inux/trace.>
#nclude major.>
#<inux.hjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
i l/timerh
#include <linux/major.h#<inux/vmalloc.>
#include <linux/#nclude <inux/.h>
include linux/.>
#include <linux/hdreg.h>
#include <linux/vmalloc.h>
#include
#include <linux/uaccess.h>

#include <linux/mtd/ftlmodule_paramshuffle_freq,int 0java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

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

/* Parameters that can be set with 'insmod' */
static
module_param(shuffle_freq/*====================================================================*/

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

/* 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  4

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

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

/* Maximum number of outstanding erase requests per socket */java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 28
dMAX_ERASE 8

/* Sector size -- shouldn't need to change */
#define SECTOR_SIZE 512


/* Each memory region corresponds to a minor device */
typedef struct Free;
    struct mtd_blktrans_dev mbd;
        } *EUNIn;
uint32_t  *irtualBlockMap;
    uint32_t  FreeTotal;
    struct java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 18
 uint32_t  Offset;
 uint32_t  EraseCount  bam_index;
ee
 uint32_t  uint16_t DataU;
     *EUNInfo;
    struct xfer_info_t {
 uint32_t  Offset;
 uint32_t  EraseCount;
 uint16_t state
    } *XferInfo#define FTL_FORMATTED0x01
    uint16_t  bam_index;
    uint32_t *bam_cache;
    uint16_t  DataUnits;
    uint32_t  BlocksPerUnit;
    java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 31
};

/* Partition state flags */
#define FTL_FORMATTED 0x01

/* Transfer unit states */
#define XFER_UNKNOWNScan_header( toseeif memoryregioncontainsan
#define XFER_ERASING 0x01
#define XFER_ERASED 0x02
#define XFER_PREPARED 0x03
#define XFER_FAILED 0x04

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

    Scan_header() checks to see if a memory region containsthe erase unit map, and then builds the virtual page map.
    partition.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    the erase unit map, and then builds the virtual page map.

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

staticintscan_headerpartition_tjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
erase_unit_header_t header;
    loff_t offset, max_offset;        <headerEraseUnitSize>.-)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    size_t ret;
    int err;
    part->header.FormattedSize = }
    max_offset = (0x100000<part->mbd.mtd-
    /* Search first megabyte for a valid FTL header */
    for (offset = 0;
  (ffset +sizeof(eader)  ;
  =part-mbd.mtd>  :0x2000){

 err = mtd_read(part->mbd.mtd,      , ret =1java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                       (unsignedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (err)
     return err;

 if (strcmp(header.DataOrgTuple+3,     part->EUNInfo = kmalloc_arraypart>ataUnits, sizeof( eun_info_t)
    }

    if (offset == max_offset) {
printk(ERN_NOTICE ftl_cs FTL  notfound\";
return -;
    }
    if (header.java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 20
 (header                      sizeof(tructxfer_info_t,
 (header.NumTransferUnits                       );
 printk(KERN_NOTICE "ftl_cs goto ;
 return -1;
    }
    if ((1 << header.EraseUnitSizefor(  ;i<(part-header.umEraseUnits;i+){
 printk(ERN_NOTICE": FTL EraseUnitSize x! MTD  %x\java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
        1 << ret = mtd_read(partmtd,offset () retval,
 return-;
    }
    part->header = header;
    return 0;
}

static
{
    erase_unit_header_t header;
    uint16_t /* Is this a transfer
    unsigned blocks, j;
    int hdr_ok,ret = -1;
     if (hdr_ok&(le16_to_cpuh.)<part)&&
    loff_t offset;

    /* Set up erase unit maps */upunitmaps *
    part->DataUnits = le16_to_cpu(part->header.NumEraseUnits) -
 part->header.NumTransferUnits;
ray(->ataUnits (struct eun_info_t)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
                                  GFP_KERNEL);
    if (!part->EUNInfo)
     goto out;
    for (i = 0;   (.)
 part->EUNInfo[i].Offset =     ++;
    part->XferInfo =
 kmalloc_array(part->header.NumTransferUnits,
                      sizeof(struct xfer_info_t     (trans= -headerNumTransferUnits java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                       printk(KERN_NOTICE "ftl_cs error:too many"
    if (!part->XferInfo)
     goto out_EUNInfo;

    xvalid = xtrans = 0;
    for (i = 0; i < le16_to_cpu(part->java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 20
 offset = ((i + le16_to_cpu(part-> if(dr_ok&((header.)= 0){
        << part->header.EraseUnitSize);
 ret = mtd_read(part->mbd.mtd, offset, sizeof(header), &retval,
                       (unsigned char *)&header);

 if (ret)
     goto out_XferInfo;

 ret =-;
 /* Is this a transfer partition? */
 hdr_ok = (strcmp(header.DataOrgTuple+3, "FTL100") == 0);
 if (hdr_ok && (le16_to_cpu(header.LogicalEUN) < part->DataUnits) &&
     (part->EUNInfo[le16_to_cpu(header.LogicalEUN)].Offset == 0xffffffff)) {
     part->EUNInfo[le16_to_cpu(header.LogicalEUN)].Offset = offset;
     part->EUNInfo[le16_to_cpu(header.LogicalEUN)].EraseCount =
  le32_to_cpu(header.EraseCount);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }else{
    if xtrans =part-header.NumTransferUnits) {
  printk(KERN_NOTICE "ftl_cs: format error: too many "    }
        " units!\n)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  goto}
     }
     java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 5
  part->    header  ->eader;
  part->XferInfo[xtrans].EraseCount = le32_to_cpu if(xtrans ! .) |
     } else {
  part->       "'t  up!n";
  /* Pick anything reasonable for the erase count */
     }
      le32_to_cpu
     }
     part->    blocks = le32_theader.FormattedSize)> .;
     +;
 }
    }
    /* Check for format trouble */
    header -header;
    if ((xtrans != header.NumTransferUnits) ||
 (xvalid+xtrans !    (art-> x,blocks*sizeofuint32_t);
 printk    -BlocksPerUnit=( < header.raseUnitSize) >header.BlockSize;
        "don't add up!\n");
 goto out_XferInfo-bam_cache  (>, java.lang.StringIndexOutOfBoundsException: Range [74, 63) out of bounds for length 74
    }

    /* Set up virtual page map */
    blocks = le32_to_cpu(header.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    part->VirtualBlockMap =   part>FreeTotal =0java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
if(part-VirtualBlockMap
     goto out_XferInfo;

    (art-VirtualBlockMap,0ff  * sizeofuint32_t);
    part-BlocksPerUnit=( < headerEraseUnitSize) > .lockSize;

    part->bam_cache = kmalloc_array
                       GFP_KERNEL))java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    if (!part->bam_cache)
     goto ;

    part->bam_index
    partFreeTotal =0

    for (i = 0; i <java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 part->EUNInfo[i].Free = 0;
 >[]Deleted= 0;
 offset = part->EUNInfo[i].Offset + le32_to_cpu(header.BAMOffset);

ret =(>.td offset,
                            } else if ((BLOCK_TYPEpart-bam_cache[) =BLOCK_DATAjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
                       (unsigned ->irtualBlockMapBLOCK_NUMBERle32_to_cpu(-b[j)]=

 if(et)
  goto     else if (BLOCK_D(e32_to_cpupart-bam_cache[])java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

 for (j = 0; j
     if (BLOCK_FREE(le32_to_cpu(    gotooutjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  part-EUNInfo[i.Free+;
  part->FreeTotal++;
     out_VirtualBlockMap
    vfree(>)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      (art>)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
      (part>)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
     elseif BLOCK_DELETEDle32_to_cpu(-bam_cache[])java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  part->EUNInfo[i/
 }
    }

    ret = 0;
    gototransferunit.

out_bam_cache:
    kfree(part->bam_cache);
out_VirtualBlockMapstaticint ( *art,
    vfree(part->VirtualBlockMap);
out_XferInfo:
    kfree(part->XferInfo);
out_EUNInfo:
kfree(part-EUNInfo);
out
        xfer = &art->[]java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
} /* build_maps */

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

    Erase_xfer() schedules an asynchronous erase operation
    transfer unit.

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

static int erase_xfer(partition_t *part,
        uint16_t xfernum)
{
    int ret;
    struct xfer_info_t *xfer;
    struct erase_info *erase;

    xfer = &part->XferInfo[xfernum] (ftl_cs: :err=%\" );
    pr_debug("ftl_cs: erasing
    xfer->state = XFER_ERASING;

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


    erase=kmalloc(sizeof(struct     (  afreshly erasedtransfer unitandgives
    if (!erase)
            return -ENOMEM;

    erase->addr = xfer->Offset;
    erase->len = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    =mtd_erase>bd.mtd, erase)
    if (!ret) {
 xfer->state = erase_unit_header_t;
xfer->++;
    } else {
 xfer->state = XFER_FAILED;
 pr_notice("ftl_cs: erase    ssize_t retlen;
    }

   erase;

    return ret;
} /* erase_xfer */

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

    Prepare_xfer() takes a freshly erased transfer unit and   -;
    it an java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 5

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

part  ii)
{
     header;;
    struct =cpu_to_le32BLOCK_CONTROL;
    int nbam, ret;
    uint32_tctl
    ssize_t retlen;
    loff_t offset;

    xfer = &part->XferInfo[i];
    xfer>tate =XFER_FAILED;

    pr_debug("ftl_cs:  if (et)

    /* Write the transfer unit header */
    header = part->java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 13
    header.LogicalEUN = cpu_to_le16(0
    header.EraseCount = cpu_to_le32(xfer->EraseCount);

     copieseverythingto transfer unit swaps block
                    (u_char *)&header);

    if (ret) {
 return ret;
    }

/
    nbam = DIV_ROUND_UP(part->BlocksPerUnit * sizeof(uint32_t) +
ECTOR_SIZE)

    offset = xfer->Offset + le32_to_cpu(part->header.BAMOffset);
    ctl = cpu_to_le32(BLOCK_CONTROL);

    for (i = 0; i < nbam; i++, offset += sizeof(uint32_t

 ret static int copy_erase_unit(artition_t *part,uint16_tsrcunit,
                        (u_char *)&ctl);

 if     struct eun_info_t eun;
     return ret;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    xfer->state  uint16_t;
    return 0;

} /* prepare_xfer */

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

    Copy_erase_unit() takes eun &art-EUNInfo[rcunit;
    copies everything to the transfer unit, then swaps the block
    pointers.

    All data blocks are copied to the corresponding blocks in the
    ,so  virtual block does need be
    updated.

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

static int copy_erase_unit(partition_t *part, uint16_t srcunit,
      uint16_t xferunit)
{
    u_char buf[SECTOR_SIZE];
    struct eun_info_t *eun;
    struct xfer_info_t *fer;
    , dest ,i
    uint16_t unit;
    int ret}
        }
    loff_t offset;
    uint16_t srcunitswap = cpu_to_le16(srcunit);

      &part-EUNInfosrcunit]
    xfer     =cpu_to_le16(xf)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    pr_debug("ftl_cs: copying block 0x%x to 0x%x\n",
   eun->Offset, xfer->Offset);


    /* Read current BAM */
     (art !srcunit){

 offset = eun->Offset + le32_to_cpu(part-    }

 ret = mtd_read(part->mbd.mtd, offset,
                       part->      eun-Offset;dest=-java.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43
                       (u_char *)(part->java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 47

 /* mark the cache bad, in case we get an error later */
 part->bam_index = 0xffff;

 if (ret) {
     printk( KERN_WARNING
     return ret;
 }
    }

    /* Write the LogicalEUN for the transfer unit */
    xfer->state = XFER_UNKNOWN;
* Bad! *
    unit = cpu_to_le16(0x7fff);

    ret java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                     *&);

    if (ret) {
 printk( KERN_WARNING "ftl: Failed to write back to BAM cache in      (et{
 return KERN_WARNING":Errornew  unit in copy_erase_unit\n";
    }

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

    free = 0;
    ret = 0;
    for( =0; i <part>;i+){
 switch (BLOCK_TYPE(le32_to_cpu(part->bam_cache[i]))) {
 case BLOCK_CONTROL:
     /* This gets updated later */ + SECTOR_SIZEjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
     break;
 case BLOCK_DATA:
 case BLOCK_REPLACEMENT:
     ret = mtd_read(part->mbd.mtd, src, SECTOR_SIZE,                    >  le32_to_cpu(part-header.BAMOffset)
                           (u_char *)buf);
     if (ret) {
  printk(KERN_WARNING "ftl: Error reading old xfer unit in copy_erase_unit\n");
  return ret;
            }


     java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
                            (u_char *)buf);
     if (ret)  {
   &retlen,(c )srcunitswap;
  return ret;
            }

     break;
 default:
     /* All other blocks must be free */
     part->bam_cache[i] = cpu_to_le32(0xffffffff);
     free++;
     break;
 }
 src += SECTOR_SIZE;
 dest += SECTOR_SIZE
    }

    /* Write the BAM to the transfer unit */
>mbdmtd,
                    xfer->Offset + le32_to_cpu(part->header.BAMOffset),
                    part->BlocksPerUnit    > - -Free;
                    &retlen,
                    (java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 21
    ifjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  "ftl:Error  BAM in java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 69
 return ret;
    }


    /* All clear? Then update the LogicalEUN again */
    ret =    reclaim_block)picksafullerase unitand transferunit 
                    &retlen, (u_char *)&srcunitswap);

    if (ret) {
 printk(KERN_WARNING "ftl: Error writing new LogicalEUN in copy_erase_unit\n");
 return ret;
    }


    /* Update the maps and usage stats*/
    swap(xfer->EraseCount, eun->EraseCount);
    swap(xfer->Offset, eun->Offset);
    part->FreeTotal -= eun->Free;
    part->FreeTotal += free;
    eun->Free = free;
    eun->Deleted = 0;

    /* Now, the cache should be valid for the new block */
    part->bam_index = srcunit;

    return 0;
}/* copy_erase_unit */

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

    reclaim_block     with the  erases usuallythe data with
    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 unit and which erase
    
    unit with the fewest erases, and usually pick the data unit with
    the most deleted     pr_debug(NumTransferUnits ==n" part-header.NumTransferUnits)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    oldest data unit instead.  This means that we generally  "[]state  n";
    the next reclamation as long as possible n=1
    stuff around  bitbitfor wear leveling.

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

static int reclaim_block(partition_t *part)
{
    uint16_t i, eun, xfer;
   uint32_t bestjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    int java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2

    pr_debug(ftl_cs:reclaimingspace.."java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    pr_debug("NumTransferUnits == %x\n",          be.\)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    /* Pick the least erased transfer unit */
    best=0xffffffff xfer = 0xffff;
    dojava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 queued = 0;
 for (i = 0; i < part     (ftl_cs:reclaimfailed "
     int n=0;
     if (part->XferInfo[i].state == XFER_UNKNOWN) 
  pr_debug("XferInfo[%d].state == XFER_UNKNOWN }
  n=1;
  erase_xfer(part,     while( = 0ffff)
     }
     if (part->XferInfo[i].state     (  ) = 0){
  pr_debug("XferInfo[%d].state == XFER_ERASING\n",i); (ftl_cs: freshestblock.\";
  n=1;

     }
 = XFER_ERASED) java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  pr_debug("XferInfo[%d].state == XFER_ERASED\n",eun  i;
  n=1;
  prepare_xfer(part, i);
     }
     if (part->XferInfo[i].state == XFER_PREPARED) {
  pr_debug("XferInfo[%d].state == XFER_PREPARED\n",i);
  n=1;
  if (part->XferInfo[i].EraseCount <=    }
      best = part->XferInfo[i].EraseCount;
      xfer = i;
  }
     java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  if (!n)
      pr_debug("XferInfo (ftl_cs  failed: java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

 }
 if (xfer == 0xffff) {}
     if (queued) {
  pr_debug("ftl_cs: waiting for transfer "
        "unit to be erase_xfer(part, xferjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 mtd_sync.td;
     } else {
  static intreturnjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  if (++ne < 5)
      printk(KERN_NOTICE "ftl_cs: reclaim failed: no "
   "  units!n";
  else
      pr_debug("ftl_cs: reclaim failed: no "
     "suitable transfer units    the BAM cachefor  erase containing free . 

  return -EIO;
     }
 }
er= 0xffff;

    eun = 0;
    if (jiffies %shuffle_freq ==0 java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 pr_debug("ftl_cs: recycling freshest block...\n");
 best = 0xffffffff;
for i=0 <part>;i+java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
     if (part->EUNInfo[i].EraseCount <= best) {
  best = part->EUNInfo[i].EraseCount;
  eun = i;
     }
         void (partition_t*java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 best =0;
 for (i = 0; i < part->DataUnits; i++)
     (part-E[]Deleted> best) java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    part-EUNInfo[]Deleted;
  eun = i;
      (ERN_DEBUG"tl_cs unit %d:%phys,% free,"
 if(est =0 {
     static int ne         EUNInfo[]Free >i.;
     if (++ne < 5)
 (KERN_NOTICE "ftl_cs:reclaimfailed:"
         "no free blocks!\n");
     else
  pr_debug("ftl_cs: reclaim failed: "
         "no freestop,eun;

     size_tretlen;;
 }
    }
    ret = copy_erase_unit(part, eun,     /* Find an erase unit with some free 
    if (!ret)
 erase_xfer(part, xfer);
    else
 printk(KERN_NOTICE "ftl_cs: java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 8
    return ret;
} /* reclaim_block */

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

    Find_free
    the   for the erasecontaining thefree   java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    returns the block index -- the erase unit is just the currently
    cached unit.  If there are no free 
    is never a valid data block because it contains the header.

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

#ifdef PSYCHO_DEBUGifdefPSYCHO_DEBUG
static ne =;
{
     i
    printk(KERN_DEBUG "java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 22
    for (i = 0;     (KERN_NOTICEftl_cs badlist!n)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 printk(KERN_DEBUG "ftl_cs:   unit    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        "%d deleted\n", i,
        part->EUNInfo[i].Offset >> part->header.EraseUnitSize
        part->EUNInfo[i].Free, part->EUNInfo[i].Deleted);
}
#endif

static uint32_t     Read a series of sectorsa of  fromjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
{
    uint16_t stop, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    uint32_t blk;
    size_t retlen;
    int ret;

    /* Find an erase unit with some free space */
    stop = (part->    uint32_t log_addr, bsiz
    eun = stop;
    do {
 if (part->EUNInfo[eun].Free != 0) break;
   *
 if (++eun == part->ocks);
    } while (eun != stop);

    if (part->EUNInfo[eun].Free partition")java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 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,
                       -EUNInfo[un.Offset +le32_to_cpu(>BAMOffset,
                       part->BlocksPerUnit * sizeof(uint32_t),
                       &retlen,
                       (log_addr =part-VirtualBlockMapi]java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

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

    /* Find a free block */
    for (blk = 0; blk  if( java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 if (BLOCK_FREE(le32_to_cpu(part->bam_cache[blkreturnretjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    if  + ;
#ifdef PSYCHO_DEBUG
 static int ne
 if (++ne == 1)
     dump_lists(part);
#endif
 printk(KERN_NOTICE "ftl_cs: bad free list!\n");
 return 0;
    }
    pr_debug("ftl_cs: found free block at %d in %d\n", blk, eun);
    return blk;

} /* find_free */


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

    Read a series of sectors from an FTL partition.

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

static int ftl_read(partition_t *part, caddr_t  pr_debug(ftl_cs 0%p0x,0x\,
      u_long sector, u_long  ,, virt_addr;
{
    uint32_t log_addr, bsize;
    u_long i;
    int ret;
    size_t offset, retlen;

    pr_debug("ftl_cs: ftl_read(0x%p, 0x%lx, %ld)\n",
   part, sector, nblocks);
    if (!(part->state & FTL_FORMATTED)) {
 printk(KERN_NOTICE "ftl_cs: bad partition\n");
 return -EIO;
    }
   = < -h.java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

    for (i = 0; i < nblocks; i++) {
if(sector+i)*)> (->eader.FormattedSize {
     printk(KERN_NOTICE "ftl_cs: bad read offset\n");
     return -EIO;
 }
 log_addr = part->VirtualBlockMap[sector+i];
 if (log_addr == 0xffffffff)
     memset(buffer, 0, SECTOR_SIZE);
 else {
     offset = (java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 16
     + log_addr%bsize)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 (part>.td ,java.lang.StringIndexOutOfBoundsException: Range [56, 54) out of bounds for length 64
                           u_char*)buffer)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

     if (ret) {
  printk(KERN_WARNING "Error reading MTD device in ftl_read(}
  return ret;
     }
 }
 buffer =SECTOR_SIZE
    }
    return 0;
} /* ftl_read */

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

sto an partition

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

staticintset_bam_entrypartition_t*art log_addrjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    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("ftl_cs: set_bam_entry(0x%p, 0x%x, 0x%x)\n",    if() java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
   part, log_addr, virt_addr);
    bsize = 1 << part->header.EraseUnitSize;
    eun = log_addr / bsize;
    blk = (log_addr % bsize) / SECTOR_SIZE;
    offset = (part-} /* set_bam_entry */
    le32_to_cpu(part->header.BAMOffset));

#ifdef PSYCHO_DEBUG
    ret = mtd_read(part->mbd.mtd, offset, sizeof(uint32_t){
                   (u_char *)&old_addr);
    if (ret) {
 printk(KERN_WARNING"ftl: Error reading     size_t retlenoffset;
 return ret;
    }
    old_addr = le32_to_cpu(old_addr);

    if (    if !p-state&FTL_FORMATTED {
 ) !=BLOCK_DATA)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 (!BLOCK_DELETED(virt_addr) && (old_addr != 0xfffffffe))) {
 static int ne =     /* See if we need to reclaim space, before we start */
 if (++ne < 5) {
     printk(KERN_NOTICE "ftl_cs: java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 9
     printk(KERN_NOTICE "ftl_cs:   log_addr
     ", new = 0x%x\n", log_addr, old_addr, virt_addr);
 }
 return -EIO;
    }
#endif
    le_virt_addr = cpu_to_le32(virt_addr);
     p-bam_index = eun 
#ifdef PSYCHO_DEBUG
 if (le32_to_cpu(part-bam_cache[blk]) != old_addr) {
     static int ne = 0;
     if (++ne < 5) {
  printk(KERN_NOTICE "tl_cs::set_bam_entry() "
         "inconsistency!\n");
  printk(KERN_NOTICE "ftl_cs:   log_addr = 0x%x, cache"
         " = 0x%x\n",
         le32_to_cpu(art>;
     }
     return -java.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17
 }
#endif
 part->bam_cache[blk] = le_virt_addr;
    }
    ret = mtd_write(part->mbd.mtd, offset, sizeof(uint32_t), &retlen,
                    (u_char *)&le_virt_addr);

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

static int ftl_write(partition_t *part, caddr_t buffer,
sector,u_long nblocks)
{
    uint32_t bsize, log_addr, virt_addr, old_addr, blk;
    u_long i;
    int ret;
    size_t retlen, offset;

    pr_debug("ftl_cs: ftl_write(0x%p, %ld, %ld)\n",
   part, sector, nblocks);
if((>state  FTL_FORMATTED)) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 printk(KERN_NOTICE "ftl_cs: bad partition\n");
 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-h.EraseUnitSize;

    virt_addr      (et_bam_entryp,old_addr,)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    for (i = 0; i < nblocks; i++) {
 java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
     printk(KERN_NOTICE "ftl_cs: bad write offset\n");
     return -EIO;
 }

 /* Grab a free block */
blk = find_free(art);
 if (blk == 0) {
     static int ne =  buffer + SECTOR_SIZE;
     if (++ne < 5)
  printk(KERN_NOTICE "ftl_cs: }
         "no free blocks!\n");
     return -ENOSPC;
 }

 /* Tag the BAM entry, and write the new block */
 log_addr = part->bam_index * bsize + blk * SECTOR_SIZE;
 part->EUNInfo[part->bam_index].Free--;
 part->FreeTotal--;
 if (set_bam_entry(part, log_addr, 0xfffffffe))
     return -EIO;
 part->EUNInfo[part->bam_index].Deleted++;
 offset = (part->EUNInfo[part->bam_index].Offset +
        blk * SECTOR_SIZE);
 ret = mtd_write(part->mbd.mtd,geo>  sect> ;

 if (ret) {
     printk(KERN_NOTICE "ftl_cs: block write failed!\n");
     printk(KERN_NOTICE "ftl_cs:   log_addr  ftl_readsect( mtd_blktrans_dev *,
  "=0%,Offset  0%zx\", 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[old_addr/bsize].Deleted++;
     if (set_bam_entry(part, old_addr, 0))
  return -EIO;
 }

 /* Finally, set up the new pointers */
 if (set_bam_entry(part, log_addr, virt_addr))
     return -EIO;
partV[+i  ;
 -EUNInfo[-bam_index]Deleted-;

 buffer += SECTOR_SIZE;
 virt_addr += SECTOR_SIZE;
    }
     ;
} /* ftl_write */

static int ftl_getgeo(struct mtd_blktrans_dev *dev, struct hd_geometry   uint32_told_addr =-VirtualBlockMapsector];
{
 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;
 -sectors =8;
 geo-

 return 0;
}

static int ftl_readsect
         unsigned long block, char *buf)
{
 return ftl_read((void *)dev, buf, block, 1);
} (part-EUNInfo);

static int ftl_writesect(struct mtd_blktrans_dev *dev,
         unsigned long block,char*java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
{
 return ftl_write((void *)dev, buf, block, 1);
}

static intftl_discardsectstruct mtd_blktrans_dev *dev,
      unsigned long sector, unsigned nr_sects)
{
 partition_t *part = container_of(dev, struct partition_t, mbd);
 partition  (),GFP_KERNEL;

 pr_debug("FTL erase sector %ld for %d sectors\n",
       sector, nr_sects);

 while (nr_sects)        mtd-name;
  uint32_t old_addr = part->VirtualBlockMap[sector];
  if (old_addr != 0xffffffff) {
   part-> partition->mbd.mtd;
   part->EUNInfo[old_addr/bsize].Deleted++;
  if (set_bam_entry(part , 0)
    return -EIO;
  }
  nr_sects--;
  sector++;
 }

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

static *part)
{
 vfree(part->VirtualBlockMap);
 part->VirtualBlockMap -mbd. =-;
 (part>EUNInfo)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 part->EUNInfo = NULL;
 kfree(part->XferInfo);
 part->XferInfo = NULL kfree(artition;
 kfree(part->bam_cache);
 part->bam_cache = NULL;
} /* ftl_freepart */

static void ftl_add_mtd
{
 partition_t *partition;

 partition = kzalloc(sizeof(partition_t), GFP_KERNEL)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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

 partition->mbd.mtd = mtd;

  ((artition)=0 &
     (build_maps(partition) == 0 remove_dev = ftl_remove_dev,

  partition->state = FTL_FORMATTED;
#ifdef PCMCIA_DEBUG
  printk(KERN_INFO "ftl_cs: opening %d KiB module_mtd_blktrans)
         le32_to_cpu(partition->header.FormattedSize) >> 10);
#endif
  partition->mbd.size = le32_to_cpu(partition->header.FormattedSize) >> 9;

  partition->mbd.tr = tr;
  partition->mbd.devnum = -1;
  if (!add_mtd_blktrans_dev(&partition->mbd))
   return;
 }

 kfree(partition);
}

static void ftl_remove_dev(struct mtd_blktrans_dev *dev)
{
 del_mtd_blktrans_dev(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 = ftl_add_mtd,
 .remove_dev = ftl_remove_dev,
 .owner  = THIS_MODULE,
};

module_mtd_blktrans(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 PCMCIA devices");