Subversion Repositories freemyipod

//

//

//    Copyright 2009 TheSeven

//

//

//    This file is part of the Linux4Nano toolkit.

//

//    TheSeven's iBugger is free software: you can redistribute it and/or

//    modify it under the terms of the GNU General Public License as

//    published by the Free Software Foundation, either version 2 of the

//    License, or (at your option) any later version.

//

//    TheSeven's iBugger is distributed in the hope that it will be useful,

//    but WITHOUT ANY WARRANTY; without even the implied warranty of

//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

//    See the GNU General Public License for more details.

//

//    You should have received a copy of the GNU General Public License along

//    with the Linux4Nano toolkit.  If not, see <http://www.gnu.org/licenses/>.

//

//

#include <toolkit.h>

#include <nand.h>

#include <ftl.h>

#include <beep.h>

//#define FTL_FORCEMOUNT

#ifdef FTL_FORCEMOUNT

#ifndef FTL_READONLY

#define FTL_READONLY

#endif

#endif

#ifdef FTL_READONLY

uint32_t ftl_write(uint32_t sector, uint32_t count, const void* buffer)

{

    (void)sector;

    (void)count;

    (void)buffer;

    return -1;

}

uint32_t ftl_sync(void)

{

    return 0;

}

#endif

/* Keeps the state of a scattered page block.

   This structure is used in memory only, not on flash,

   but it equals the one the OFW uses. */

struct ftl_log_type

{

    /* The ftl_cxt.nextblockusn at the time the block was allocated,

       needed in order to be able to remove the oldest ones first. */

    uint32_t usn;

    /* The vBlock number at which the scattered pages are stored */

    uint16_t scatteredvblock;

    /* the lBlock number for which those pages are */

    uint16_t logicalvblock;

    /* Pointer to ftl_offsets, contains the mapping which lPage is

       currently stored at which scattered vPage. */

    uint16_t* pageoffsets;

    /* Pages used in the vBlock, i.e. next page number to be written */

    uint16_t pagesused;

    /* Pages that are still up to date in this block, i.e. need to be

       moved when this vBlock is deallocated. */

    uint16_t pagescurrent;

    /* A flag whether all pages are still sequential in this block.

       Initialized to 1 on allocation, zeroed as soon as anything is

       written out of sequence, so that the block will need copying

       when committing to get the pages back into the right order.

       This is used to half the number of block erases needed when

       writing huge amounts of sequential data. */

    uint32_t issequential;

} __attribute__((packed));

/* Keeps the state of the FTL, both on flash and in memory */

struct ftl_cxt_type

{

    /* Update sequence number of the FTL context, decremented

       every time a new revision of FTL meta data is written. */

    uint32_t usn;

    /* Update sequence number for user data blocks. Incremented

       every time a portion of user pages is written, so that

       a consistency check can determine which copy of a user

       page is the most recent one. */

    uint32_t nextblockusn;

    /* Count of currently free pages in the block pool */

    uint16_t freecount;

    /* Index to the first free hyperblock in the blockpool ring buffer */

    uint16_t nextfreeidx;

    /* This is a counter that is used to better distribute block

       wear. It is incremented on every block erase, and if it

       gets too high (300 on writes, 20 on sync), the most and

       least worn hyperblock will be swapped (causing an additional

       block write) and the counter will be decreased by 20. */

    uint16_t swapcounter;

    /* Ring buffer of currently free hyperblocks. nextfreeidx is the

       index to freecount free ones, the other ones are currently

       allocated for scattered page hyperblocks. */

    uint16_t blockpool[0x14];

    /* Alignment to 32 bits */

    uint16_t field_36;

    /* vPages where the block map is stored */

    uint32_t ftl_map_pages[8];

    /* Probably additional map page number space for bigger chips */

    uint8_t field_58[0x28];

    /* vPages where the erase counters are stored */

    uint32_t ftl_erasectr_pages[8];

    /* Seems to be padding */

    uint8_t field_A0[0x70];

    /* Pointer to ftl_map used by Whimory, not used by us */

    uint32_t ftl_map_ptr;

    /* Pointer to ftl_erasectr used by Whimory, not used by us */

    uint32_t ftl_erasectr_ptr;

    /* Pointer to ftl_log used by Whimory, not used by us */

    uint32_t ftl_log_ptr;

    /* Flag used to indicate that some erase counter pages should be committed

       because they were changed more than 100 times since the last commit. */

    uint32_t erasedirty;

    /* Seems to be unused */

    uint16_t field_120;

    /* vBlocks used to store the FTL context, map, and erase

       counter pages. This is also a ring buffer, and the oldest

       page gets swapped with the least used page from the block

       pool ring buffer when a new one is allocated. */

    uint16_t ftlctrlblocks[3];

    /* The last used vPage number from ftlctrlblocks */

    uint32_t ftlctrlpage;

    /* Set on context sync, reset on write, so obviously never

       zero in the context written to the flash */

    uint32_t clean_flag;

    /* Seems to be unused, but gets loaded from flash by Whimory. */

    uint8_t field_130[0x15C];

} __attribute__((packed));

/* Keeps the state of the bank's VFL, both on flash and in memory.

   There is one of these per bank. */

struct ftl_vfl_cxt_type

{

    /* Cross-bank update sequence number, incremented on every VFL

       context commit on any bank. */

    uint32_t usn;

    /* See ftl_cxt.ftlctrlblocks. This is stored to the VFL contexts

       in order to be able to find the most recent FTL context copy

       when mounting the FTL. The VFL context number this will be

       written to on an FTL context commit is chosen semi-randomly. */

    uint16_t ftlctrlblocks[3];

    /* Alignment to 32 bits */

    uint8_t field_A[2];

    /* Decrementing update counter for VFL context commits per bank */

    uint32_t updatecount;

    /* Number of the currently active VFL context block, it's an index

       into vflcxtblocks. */

    uint16_t activecxtblock;

    /* Number of the first free page in the active VFL context block */

    uint16_t nextcxtpage;

    /* Seems to be unused */

    uint8_t field_14[4];

    /* Incremented every time a block erase error leads to a remap,

       but doesn't seem to be read anywhere. */

    uint16_t field_18;

    /* Number of spare blocks used */

    uint16_t spareused;

    /* pBlock number of the first spare block */

    uint16_t firstspare;

    /* Total number of spare blocks */

    uint16_t sparecount;

    /* Block remap table. Contains the vBlock number the n-th spare

       block is used as a replacement for. 0 = unused, 0xFFFF = bad. */

    uint16_t remaptable[0x334];

    /* Bad block table. Each bit represents 8 blocks. 1 = OK, 0 = Bad.

       If the entry is zero, you should look at the remap table to see

       if the block is remapped, and if yes, where the replacement is. */

    uint8_t bbt[0x11A];

    /* pBlock numbers used to store the VFL context. This is a ring

       buffer. On a VFL context write, always 8 pages are written,

       and it passes if at least 4 of them can be read back. */

    uint16_t vflcxtblocks[4];

    /* Blocks scheduled for remapping are stored at the end of the

       remap table. This is the first index used for them. */

    uint16_t scheduledstart;

    /* Probably padding */

    uint8_t field_7AC[0x4C];

    /* First checksum (addition) */

    uint32_t checksum1;

    /* Second checksum (XOR), there is a bug in whimory regarding this. */

    uint32_t checksum2;

} __attribute__((packed));

/* Layout of the spare bytes of each page on the flash */

union ftl_spare_data_type

{

    /* The layout used for actual user data (types 0x40 and 0x41) */

    struct ftl_spare_data_user_type

    {

        /* The lPage, i.e. Sector, number */

        uint32_t lpn;

        /* The update sequence number of that page,

           copied from ftl_cxt.nextblockusn on write */

        uint32_t usn;

        /* Seems to be unused */

        uint8_t field_8;

        /* Type field, 0x40 (data page) or 0x41

           (last data page of hyperblock) */

        uint8_t type;

        /* ECC mark, usually 0xFF. If an error occurred while reading the

           page during a copying operation earlier, this will be 0x55. */

        uint8_t eccmark;

        /* Seems to be unused */

        uint8_t field_B;

        /* ECC data for the user data */

        uint8_t dataecc[0x28];

        /* ECC data for the first 0xC bytes above */

        uint8_t spareecc[0xC];

    } __attribute__((packed)) user;

    /* The layout used for meta data (other types) */

    struct ftl_spare_data_meta_type

    {

        /* ftl_cxt.usn for FTL stuff, ftl_vfl_cxt.updatecount for VFL stuff */

        uint32_t usn;

        /* Index of the thing inside the page,

           for example number / index of the map or erase counter page */

        uint16_t idx;

        /* Seems to be unused */

        uint8_t field_6;

        /* Seems to be unused */

        uint8_t field_7;

        /* Seems to be unused */

        uint8_t field_8;

       /* Type field:

            0x43: FTL context page

            0x44: Block map page

            0x46: Erase counter page

            0x47: "FTL is currently mounted", i.e. unclean shutdown, mark

            0x80: VFL context page */

        uint8_t type;

        /* ECC mark, usually 0xFF. If an error occurred while reading the

           page during a copying operation earlier, this will be 0x55. */

        uint8_t eccmark;

        /* Seems to be unused */

        uint8_t field_B;

        /* ECC data for the user data */

        uint8_t dataecc[0x28];

        /* ECC data for the first 0xC bytes above */

        uint8_t spareecc[0xC];

    } __attribute__((packed)) meta;

};

/* Keeps track of troublesome blocks, only in memory, lost on unmount. */

struct ftl_trouble_type

{

    /* vBlock number of the block giving trouble */

    uint16_t block;

    /* Bank of the block giving trouble */

    uint8_t bank;

    /* Error counter, incremented by 3 on error, decremented by 1 on erase,

       remaping will be done when it reaches 6. */

    uint8_t errors;

} __attribute__((packed));

/* Pointer to an info structure regarding the flash type used */

static const struct nand_device_info_type* ftl_nand_type;

/* Number of banks we detected a chip on */

static uint32_t ftl_banks;

/* Number of banks we detected a chip on (power of two) */

static uint32_t ftl_banks_exponent;

/* Block map, used vor pBlock to vBlock mapping */

static uint16_t ftl_map[0x2000] __attribute__((aligned(16)));

/* VFL context for each bank */

static struct ftl_vfl_cxt_type ftl_vfl_cxt[4];

/* FTL context */

static struct ftl_cxt_type ftl_cxt __attribute__((aligned(16)));

/* Temporary data buffers for internal use by the FTL */

static uint8_t ftl_buffer[0x800] __attribute__((aligned(16)));

/* Temporary spare byte buffer for internal use by the FTL */

static union ftl_spare_data_type ftl_sparebuffer __attribute__((aligned(16)));

#ifndef FTL_READONLY

/* Lowlevel BBT for each bank */

static uint8_t ftl_bbt[4][0x410];

/* Erase counters for the vBlocks */

static uint16_t ftl_erasectr[0x2000] __attribute__((aligned(16)));

/* Used by ftl_log */

static uint16_t ftl_offsets[0x11][0x200];

/* Structs keeping record of scattered page blocks */

static struct ftl_log_type ftl_log[0x11];

/* Global cross-bank update sequence number of the VFL context */

static uint32_t ftl_vfl_usn;

/* Keeps track (temporarily) of troublesome blocks */

static struct ftl_trouble_type ftl_troublelog[5];

/* Counts erase counter page changes, after 100 of them the affected

   page will be committed to the flash. */

static uint8_t ftl_erasectr_dirt[8];

/* Buffer needed for copying pages around while moving or committing blocks.

   This can't be shared with ftl_buffer, because this one could be overwritten

   during the copying operation in order to e.g. commit a CXT. */

static uint8_t ftl_copybuffer[0x800] __attribute__((aligned(16)));

/* Needed to store the old scattered page offsets in order to be able to roll

   back if something fails while compacting a scattered page block. */

static uint16_t ftl_offsets_backup[0x200] __attribute__((aligned(16)));

#endif

/* Pages per hyperblock (ftl_nand_type->pagesperblock) */

static uint32_t pagesperblock;

/* Pages per hyperblock (ftl_nand_type->pagesperblock * ftl_banks) */

static uint32_t ppb;

/* Pages per hyperblock (power of two) */

static uint32_t ppb_exponent;

/* Reserved hyperblocks (ftl_nand_type->blocks

                       - ftl_nand_type->userblocks - 0x17) */

static uint32_t syshyperblocks;

/* Finds a device info page for the specified bank and returns its number.

   Used to check if one is present, and to read the lowlevel BBT. */

static uint32_t ftl_find_devinfo(uint32_t bank)

{

    /* Scan the last 10% of the flash for device info pages */

    uint32_t lowestBlock = (*ftl_nand_type).blocks

                         - ((*ftl_nand_type).blocks / 8);

    uint32_t block, page, pagenum;

    for (block = (*ftl_nand_type).blocks - 1; block >= lowestBlock; block--)

    {

        page = pagesperblock - 8;

        for (; page < pagesperblock; page++)

        {

            pagenum = block * pagesperblock + page;

            if ((nand_read_page(bank, pagenum, ftl_buffer,

                                &ftl_sparebuffer, 0) & 0x11F) != 0)

                continue;

            if (memcmp(ftl_buffer, "DEVICEINFOSIGN\0", 0x10) == 0)

                return pagenum;

        }

    }

    return 0;

}

/* Checks if all banks have proper device info pages */

static uint32_t ftl_has_devinfo(void)

{

    uint32_t i;

    for (i = 0; i < ftl_banks; i++) if (ftl_find_devinfo(i) == 0) return 0;

    return 1;

}

/* Loads the lowlevel BBT for a bank to the specified buffer.

   This is based on some cryptic disassembly and not fully understood yet. */

static uint32_t ftl_load_bbt(uint32_t bank, uint8_t* bbt)

{

    uint32_t i, j;

    uint32_t pagebase, page = ftl_find_devinfo(bank), page2;

    uint32_t unk1, unk2, unk3;

    if (page == 0) return 1;

    pagebase = page & ~(pagesperblock - 1);

    if ((nand_read_page(bank, page, ftl_buffer,

                        &ftl_sparebuffer, 0) & 0x11F) != 0) return 1;

    if (memcmp(&ftl_buffer[0x18], "BBT", 4) != 0) return 1;

    unk1 = ((uint16_t*)ftl_buffer)[0x10];

    unk2 = ((uint16_t*)ftl_buffer)[0x11];

    unk3 = ((uint16_t*)ftl_buffer)[((uint32_t*)ftl_buffer)[4] * 6 + 10]

         + ((uint16_t*)ftl_buffer)[((uint32_t*)ftl_buffer)[4] * 6 + 11];

    for (i = 0; i < unk1; i++)

    {

        for (j = 0; ; j++)

        {

            page2 = unk2 + i + unk3 * j;

            if (page2 >= (uint32_t)(pagesperblock - 8))

                break;

            if ((nand_read_page(bank, pagebase + page2, ftl_buffer,

                                &ftl_sparebuffer, 0) & 0x11F) == 0)

            {

                memcpy(bbt, ftl_buffer, 0x410);

                return 0;

            }

        }

    }

    return 1;

}

/* Calculates the checksums for the VFL context page of the specified bank */

static void ftl_vfl_calculate_checksum(uint32_t bank,

                                uint32_t* checksum1, uint32_t* checksum2)

{

    uint32_t i;

    *checksum1 = 0xAABBCCDD;

    *checksum2 = 0xAABBCCDD;

    for (i = 0; i < 0x1FE; i++)

    {

        *checksum1 += ((uint32_t*)(&ftl_vfl_cxt[bank]))[i];

        *checksum2 ^= ((uint32_t*)(&ftl_vfl_cxt[bank]))[i];

    }

}

/* Checks if the checksums of the VFL context

   of the specified bank are correct */

static uint32_t ftl_vfl_verify_checksum(uint32_t bank)

{

    uint32_t checksum1, checksum2;

    ftl_vfl_calculate_checksum(bank, &checksum1, &checksum2);

    if (checksum1 == ftl_vfl_cxt[bank].checksum1) return 0;

    /* The following line is pretty obviously a bug in Whimory,

       but we do it the same way for compatibility. */

    if (checksum2 != ftl_vfl_cxt[bank].checksum2) return 0;

#ifdef VFL_DEBUG

    debug_printf("VFL: Bad VFL CXT checksum!\n");

#endif

    return 1;

}

#ifndef FTL_READONLY

/* Updates the checksums of the VFL context of the specified bank */

static void ftl_vfl_update_checksum(uint32_t bank)

{

    ftl_vfl_calculate_checksum(bank, &ftl_vfl_cxt[bank].checksum1,

                               &ftl_vfl_cxt[bank].checksum2);

}

#endif

#ifndef FTL_READONLY

/* Writes 8 copies of the VFL context of the specified bank to flash,

   and succeeds if at least 4 can be read back properly. */

static uint32_t ftl_vfl_store_cxt(uint32_t bank)

{

    uint32_t i;

    ftl_vfl_cxt[bank].updatecount--;

    ftl_vfl_cxt[bank].usn = ++ftl_vfl_usn;

    ftl_vfl_cxt[bank].nextcxtpage += 8;

    ftl_vfl_update_checksum(bank);

    memset(&ftl_sparebuffer, 0xFF, 0x40);

    ftl_sparebuffer.meta.usn = ftl_vfl_cxt[bank].updatecount;

    ftl_sparebuffer.meta.field_8 = 0;

    ftl_sparebuffer.meta.type = 0x80;

    for (i = 1; i <= 8; i++)

    {

        uint32_t index = ftl_vfl_cxt[bank].activecxtblock;

        uint32_t block = ftl_vfl_cxt[bank].vflcxtblocks[index];

        uint32_t page = block * pagesperblock;

        page += ftl_vfl_cxt[bank].nextcxtpage - i;

        nand_write_page(bank, page, &ftl_vfl_cxt[bank], &ftl_sparebuffer, 1);

    }

    uint32_t good = 0;

    for (i = 0; i < 8; i++)

    {

        uint32_t index = ftl_vfl_cxt[bank].activecxtblock;

        uint32_t block = ftl_vfl_cxt[bank].vflcxtblocks[index];

        uint32_t page = block * pagesperblock;

        page += ftl_vfl_cxt[bank].nextcxtpage - i;

        if ((nand_read_page(bank, page, ftl_buffer,

                            &ftl_sparebuffer, 0) & 0x11F) != 0)

            continue;

        if (memcmp(ftl_buffer, &ftl_vfl_cxt[bank], 0x7AC) != 0)

            continue;

        if (ftl_sparebuffer.meta.usn != ftl_vfl_cxt[bank].updatecount)

            continue;

        if (ftl_sparebuffer.meta.field_8 == 0

         && ftl_sparebuffer.meta.type == 0x80) good++;

    }

    return good > 3 ? 0 : 1;

}

#endif

#ifndef FTL_READONLY

/* Commits the VFL context of the specified bank to flash,

   retries until it works or all available pages have been tried */

static uint32_t ftl_vfl_commit_cxt(uint32_t bank)

{

#ifdef VFL_DEBUG

    debug_printf("FTL: VFL: Committing context on bank %d\n", bank);

#endif

    if (ftl_vfl_cxt[bank].nextcxtpage + 8 <= pagesperblock)

        if (ftl_vfl_store_cxt(bank) == 0) return 0;

    uint32_t current = ftl_vfl_cxt[bank].activecxtblock;

    uint32_t i = current, j;

    while (1)

    {

        i = (i + 1) & 3;

        if (i == current) break;

        if (ftl_vfl_cxt[bank].vflcxtblocks[i] == 0xFFFF) continue;

        for (j = 0; j < 4; j++)

            if (nand_block_erase(bank, ftl_vfl_cxt[bank].vflcxtblocks[i]

                                     * pagesperblock) == 0)

                break;

        if (j == 4) continue;

        ftl_vfl_cxt[bank].activecxtblock = i;

        ftl_vfl_cxt[bank].nextcxtpage = 0;

        if (ftl_vfl_store_cxt(bank) == 0) return 0;

    }

#ifdef VFL_DEBUG

    debug_printf("VFL: Failed to commit VFL CXT!\n");

#endif

    return 1;

}

#endif

/* Returns a pointer to the most recently updated VFL context,

   used to find out the current FTL context vBlock numbers

   (planetbeing's "maxthing") */

static struct ftl_vfl_cxt_type* ftl_vfl_get_newest_cxt(void)

{

    uint32_t i, maxusn;

    struct ftl_vfl_cxt_type* cxt = (struct ftl_vfl_cxt_type*)0;

    maxusn = 0;

    for (i = 0; i < ftl_banks; i++)

        if (ftl_vfl_cxt[i].usn >= maxusn)

        {

            cxt = &ftl_vfl_cxt[i];

            maxusn = ftl_vfl_cxt[i].usn;

        }

    return cxt;

}

/* Checks if the specified pBlock is marked bad in the supplied lowlevel BBT.

   Only used while mounting the VFL. */

static uint32_t ftl_is_good_block(uint8_t* bbt, uint32_t block)

{

    if ((bbt[block >> 3] & (1 << (block & 7))) == 0) return 0;

    else return 1;

}

/* Checks if the specified vBlock could be remapped */

static uint32_t ftl_vfl_is_good_block(uint32_t bank, uint32_t block)

{

    uint8_t bbtentry = ftl_vfl_cxt[bank].bbt[block >> 6];

    if ((bbtentry & (1 << ((7 - (block >> 3)) & 7))) == 0) return 0;

    else return 1;

}

#ifndef FTL_READONLY

/* Sets or unsets the bad bit of the specified vBlock

   in the specified bank's VFL context */

static void ftl_vfl_set_good_block(uint32_t bank, uint32_t block, uint32_t isgood)

{

    uint8_t bit = (1 << ((7 - (block >> 3)) & 7));

    if (isgood == 1) ftl_vfl_cxt[bank].bbt[block >> 6] |= bit;

    else ftl_vfl_cxt[bank].bbt[block >> 6] &= ~bit;

}

#endif

/* Tries to read a VFL context from the specified bank, pBlock and page */

static uint32_t ftl_vfl_read_page(uint32_t bank, uint32_t block,

                           uint32_t startpage, void* databuffer,

                           union ftl_spare_data_type* sparebuffer)

{

    uint32_t i;

    for (i = 0; i < 8; i++)

    {

        uint32_t page = block * pagesperblock + startpage + i;

        if ((nand_read_page(bank, page, databuffer,

                            sparebuffer, 1) & 0x11F) == 0)

            if ((*sparebuffer).meta.field_8 == 0

             && (*sparebuffer).meta.type == 0x80)

                return 0;

    }

    return 1;

}

/* Translates a bank and vBlock to a pBlock, following remaps */

static uint32_t ftl_vfl_get_physical_block(uint32_t bank, uint32_t block)

{

    if (ftl_vfl_is_good_block(bank, block) == 1) return block;

    uint32_t spareindex;

    uint32_t spareused = ftl_vfl_cxt[bank].spareused;

    for (spareindex = 0; spareindex < spareused; spareindex++)

        if (ftl_vfl_cxt[bank].remaptable[spareindex] == block)

#ifdef VFL_TRACE

            debug_printf("FTL: VFL: Following remapped block: %d => %d\n",

                         block, ftl_vfl_cxt[bank].firstspare + spareindex);

#endif

            return ftl_vfl_cxt[bank].firstspare + spareindex;

    return block;

}

#ifndef FTL_READONLY

/* Checks if remapping is scheduled for the specified bank and vBlock */

static uint32_t ftl_vfl_check_remap_scheduled(uint32_t bank, uint32_t block)

{

    uint32_t i;

    for (i = 0x333; i > 0 && i > ftl_vfl_cxt[bank].scheduledstart; i--)

        if (ftl_vfl_cxt[bank].remaptable[i] == block) return 1;

    return 0;

}

#endif

#ifndef FTL_READONLY

/* Schedules remapping for the specified bank and vBlock */

static void ftl_vfl_schedule_block_for_remap(uint32_t bank, uint32_t block)

{

    if (ftl_vfl_check_remap_scheduled(bank, block) == 1) return;

#ifdef VFL_DEBUG

    debug_printf("VFL: Scheduling bank %u block %u for remap!\n",

                 (unsigned)bank, (unsigned)block);

#endif

    if (ftl_vfl_cxt[bank].scheduledstart == ftl_vfl_cxt[bank].spareused)

        return;

    ftl_vfl_cxt[bank].remaptable[--ftl_vfl_cxt[bank].scheduledstart] = block;

    ftl_vfl_commit_cxt(bank);

}

#endif

#ifndef FTL_READONLY

/* Removes the specified bank and vBlock combination

   from the remap scheduled list */

static void ftl_vfl_mark_remap_done(uint32_t bank, uint32_t block)

{

    uint32_t i;

    uint32_t start = ftl_vfl_cxt[bank].scheduledstart;

    uint32_t lastscheduled = ftl_vfl_cxt[bank].remaptable[start];

    for (i = 0x333; i > 0 && i > start; i--)

        if (ftl_vfl_cxt[bank].remaptable[i] == block)

        {

            if (i != start && i != 0x333)

                ftl_vfl_cxt[bank].remaptable[i] = lastscheduled;

            ftl_vfl_cxt[bank].scheduledstart++;

            return;

        }

}

#endif

#ifndef FTL_READONLY

/* Logs that there is trouble for the specified vBlock on the specified bank.

   The vBlock will be scheduled for remap

   if there is too much trouble with it. */

static void ftl_vfl_log_trouble(uint32_t bank, uint32_t vblock)

{

    uint32_t i;

    for (i = 0; i < 5; i++)

        if (ftl_troublelog[i].block == vblock

         && ftl_troublelog[i].bank == bank)

        {

            ftl_troublelog[i].errors += 3;

            if (ftl_troublelog[i].errors > 5)

            {

                ftl_vfl_schedule_block_for_remap(bank, vblock);

                ftl_troublelog[i].block = 0xFFFF;

            }

            return;

        }

    for (i = 0; i < 5; i++)

        if (ftl_troublelog[i].block == 0xFFFF)

        {

            ftl_troublelog[i].block = vblock;

            ftl_troublelog[i].bank = bank;

            ftl_troublelog[i].errors = 3;

            return;

        }

}

#endif

#ifndef FTL_READONLY

/* Logs a successful erase for the specified vBlock on the specified bank */

static void ftl_vfl_log_success(uint32_t bank, uint32_t vblock)

{

    uint32_t i;

    for (i = 0; i < 5; i++)

        if (ftl_troublelog[i].block == vblock

         && ftl_troublelog[i].bank == bank)

        {

            if (--ftl_troublelog[i].errors == 0)

                ftl_troublelog[i].block = 0xFFFF;

            return;

        }

}

#endif

#ifndef FTL_READONLY

/* Tries to remap the specified vBlock on the specified bank,

   not caring about data in there.

   If it worked, it will return the new pBlock number,

   if not (no more spare blocks available), it will return zero. */

static uint32_t ftl_vfl_remap_block(uint32_t bank, uint32_t block)

{

    uint32_t i;

    uint32_t newblock = 0, newidx;

#ifdef VFL_DEBUG

    debug_printf("VFL: Remapping bank %u block %u!\n",

                 (unsigned)bank, (unsigned)block);

#endif

    if (bank >= ftl_banks || block >= (*ftl_nand_type).blocks) return 0;

    for (i = 0; i < ftl_vfl_cxt[bank].sparecount; i++)

        if (ftl_vfl_cxt[bank].remaptable[i] == 0)

        {

            newblock = ftl_vfl_cxt[bank].firstspare + i;

            newidx = i;

            break;

        }

    if (newblock == 0) return 0;

    for (i = 0; i < 9; i++)

        if (nand_block_erase(bank, newblock * pagesperblock) == 0)

            break;

    for (i = 0; i < newidx; i++)

        if (ftl_vfl_cxt[bank].remaptable[i] == block)

            ftl_vfl_cxt[bank].remaptable[i] = 0xFFFF;

    ftl_vfl_cxt[bank].remaptable[newidx] = block;

    ftl_vfl_cxt[bank].spareused++;

    ftl_vfl_set_good_block(bank, block, 0);

    return newblock;

}

#endif

// Reads the specified vPage, dealing with all kinds of trouble

static uint32_t ftl_vfl_read(uint32_t vpage, void* buffer, void* sparebuffer,

                      uint32_t checkempty, uint32_t remaponfail)

{

#ifdef VFL_TRACE

    debug_printf("FTL: VFL: Reading page %d\n", vpage);

#endif

    uint32_t abspage = vpage + ppb * syshyperblocks;

    if (abspage >= (*ftl_nand_type).blocks * ppb || abspage < ppb)

    {

#ifdef VFL_DEBUG

        debug_printf("FTL: VFL: vPage %d is out of range!\n", vpage);

#endif

        return 4;

    }

    uint32_t bank = abspage & (ftl_banks - 1);

    uint32_t block = abspage >> ppb_exponent;

    uint32_t page = (abspage >> ftl_banks_exponent) & ((1 << ftl_nand_type->blocksizeexponent) - 1);

    uint32_t physblock = ftl_vfl_get_physical_block(bank, block);

    uint32_t physpage = physblock * pagesperblock + page;

    return nand_read_page(bank, physpage, buffer, sparebuffer, checkempty);

}

#ifndef FTL_READONLY

/* Writes the specified vPage, dealing with all kinds of trouble */

static uint32_t ftl_vfl_write(uint32_t vpage, void* buffer, void* sparebuffer)

{

#ifdef VFL_TRACE

    debug_printf("FTL: VFL: Writing page %d\n", vpage);

#endif

    uint32_t abspage = vpage + ppb * syshyperblocks;

    if (abspage >= (*ftl_nand_type).blocks * ppb || abspage < ppb)

    {

#ifdef VFL_DEBUG

        debug_printf("FTL: VFL: vPage %d is out of range!\n", vpage);

#endif

        return 4;

    }

    uint32_t bank = abspage & (ftl_banks - 1);

    uint32_t block = abspage >> ppb_exponent;

    uint32_t page = (abspage >> ftl_banks_exponent) & ((1 << ftl_nand_type->blocksizeexponent) - 1);

    uint32_t physblock = ftl_vfl_get_physical_block(bank, block);

    uint32_t physpage = physblock * pagesperblock + page;

    if (nand_write_page(bank, physpage, buffer, sparebuffer, 1) == 0)

        return 0;

#ifdef VFL_TRACE

    debug_printf("FTL: VFL: Trouble writing bank %d page %d, trying readback\n", bank, physpage);

#endif

    if ((nand_read_page(bank, physpage, ftl_buffer,

                        &ftl_sparebuffer, 1) & 0x11F) == 0)

        return 0;

#ifdef VFL_TRACE

    debug_printf("FTL: VFL: Readback failed, logging problem\n");

#endif

    ftl_vfl_log_trouble(bank, block);

    return 1;

}

#endif

/* Mounts the VFL on all banks */

static uint32_t ftl_vfl_open(void)

{

    uint32_t i, j, k;

    uint32_t minusn, vflcxtidx, last;

    struct ftl_vfl_cxt_type* cxt;

    uint16_t vflcxtblock[4];

#ifndef FTL_READONLY

    ftl_vfl_usn = 0;

#else

    /* Temporary BBT buffer if we're readonly,

       as we won't need it again after mounting */

    uint8_t bbt[0x410];

#endif

    for (i = 0; i < ftl_banks; i++)

#ifndef FTL_READONLY

        if (ftl_load_bbt(i, ftl_bbt[i]) == 0)

#else

        if (ftl_load_bbt(i, bbt) == 0)

#endif

        {

            for (j = 1; j <= syshyperblocks; j++)

#ifndef FTL_READONLY

                if (ftl_is_good_block(ftl_bbt[i], j) != 0)

#else

                if (ftl_is_good_block(bbt, j) != 0)

#endif

                    if (ftl_vfl_read_page(i, j, 0, ftl_buffer,

                                          &ftl_sparebuffer) == 0)

                    {

                        struct ftl_vfl_cxt_type* cxt;

                        cxt = (struct ftl_vfl_cxt_type*)ftl_buffer;

                        memcpy(vflcxtblock, &(*cxt).vflcxtblocks, 8);

                        minusn = 0xFFFFFFFF;

                        vflcxtidx = 4;

                        for (k = 0; k < 4; k++)

                            if (vflcxtblock[k] != 0xFFFF)

                                if (ftl_vfl_read_page(i, vflcxtblock[k], 0,

                                                      ftl_buffer,

                                                      &ftl_sparebuffer) == 0)

                                    if (ftl_sparebuffer.meta.usn > 0

                                     && ftl_sparebuffer.meta.usn <= minusn)

                                    {

                                        minusn = ftl_sparebuffer.meta.usn;

                                        vflcxtidx = k;

                                    }

                        if (vflcxtidx == 4)

                        {

#ifdef VFL_DEBUG

                            debug_printf("VFL: No CXT block found on bank %u!\n",

                                         (unsigned)i);

#endif

                            return 1;

                        }

                        last = 0;

                        uint32_t max = pagesperblock;

                        for (k = 8; k < max; k += 8)

                        {

                            if (ftl_vfl_read_page(i, vflcxtblock[vflcxtidx],

                                                  k, ftl_buffer,

                                                  &ftl_sparebuffer) != 0)

                                break;

                            last = k;

                        }

                        if (ftl_vfl_read_page(i, vflcxtblock[vflcxtidx],

                                              last, ftl_buffer,

                                              &ftl_sparebuffer) != 0)

                        {

#ifdef VFL_DEBUG

                            debug_printf("VFL: Re-reading VFL CXT block "

                                         "on bank %u failed!?\n", (unsigned)i);

#endif

                            return 1;

                        }

                        memcpy(&ftl_vfl_cxt[i], ftl_buffer, 0x800);

                        if (ftl_vfl_verify_checksum(i) != 0) return 1;

#ifndef FTL_READONLY

                        if (ftl_vfl_usn < ftl_vfl_cxt[i].usn)

                            ftl_vfl_usn = ftl_vfl_cxt[i].usn;

#endif

                        break;

                    }

        }

        else

        {

#ifdef FTL_DEBUG

            debug_printf("FTL: Couldn't load bank %u lowlevel BBT!\n", (unsigned)i);

#endif

            return 1;

        }

    cxt = ftl_vfl_get_newest_cxt();

    for (i = 0; i < ftl_banks; i++)

        memcpy(ftl_vfl_cxt[i].ftlctrlblocks, (*cxt).ftlctrlblocks, 6);

    return 0;

}

/* Mounts the actual FTL */

static uint32_t ftl_open(void)

{

    uint32_t i;

    uint32_t ret;

    struct ftl_vfl_cxt_type* cxt = ftl_vfl_get_newest_cxt();

    uint32_t ftlcxtblock = 0xffffffff;

    uint32_t minusn = 0xffffffff;

    for (i = 0; i < 3; i++)