Rev 128 | Blame | Last modification | View Log | RSS feed
////// Copyright 2010 TheSeven////// This file is part of emBIOS.//// emBIOS 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.//// emBIOS 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 emBIOS. If not, see <http://www.gnu.org/licenses/>.////#include "global.h"#include "nand.h"#include "ftl.h"#include "util.h"#include "thread.h"#include "panic.h"#include "debug.h"#include "console.h"#include "progressbar.h"#include "lcdconsole.h"#define FTL_COPYBUF_SIZE 4#define FTL_WRITESPARE_SIZE 32//#define FTL_FORCEMOUNT#ifdef FTL_FORCEMOUNT#ifndef FTL_READONLY#define FTL_READONLY#endif#endif#ifdef FTL_READONLYuint32_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 iscurrently 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 bemoved 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 iswritten out of sequence, so that the block will need copyingwhen committing to get the pages back into the right order.This is used to half the number of block erases needed whenwriting 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, decrementedevery time a new revision of FTL meta data is written. */uint32_t usn;/* Update sequence number for user data blocks. Incrementedevery time a portion of user pages is written, so thata consistency check can determine which copy of a userpage 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 blockwear. It is incremented on every block erase, and if itgets too high (300 on writes, 20 on sync), the most andleast worn hyperblock will be swapped (causing an additionalblock write) and the counter will be decreased by 20. */uint16_t swapcounter;/* Ring buffer of currently free hyperblocks. nextfreeidx is theindex to freecount free ones, the other ones are currentlyallocated 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 committedbecause 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 erasecounter pages. This is also a ring buffer, and the oldestpage gets swapped with the least used page from the blockpool 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 neverzero 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 VFLcontext commit on any bank. */uint32_t usn;/* See ftl_cxt.ftlctrlblocks. This is stored to the VFL contextsin order to be able to find the most recent FTL context copywhen mounting the FTL. The VFL context number this will bewritten 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 indexinto 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 spareblock 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 seeif 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 ringbuffer. 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 theremap 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 block) */uint8_t type;/* ECC mark, usually 0xFF. If an error occurred while reading thepage 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 page0x44: Block map page0x46: Erase counter page0x47: "FTL is currently mounted", i.e. unclean shutdown, mark0x80: VFL context page */uint8_t type;/* ECC mark, usually 0xFF. If an error occurred while reading thepage 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 */const struct nand_device_info_type* ftl_nand_type;/* Number of banks we detected a chip on */uint32_t ftl_banks;/* Block map, used vor pBlock to vBlock mapping */static uint16_t ftl_map[0x2000] CACHEALIGN_ATTR;/* VFL context for each bank */static struct ftl_vfl_cxt_type ftl_vfl_cxt[4];/* FTL context */static struct ftl_cxt_type ftl_cxt CACHEALIGN_ATTR;/* Temporary data buffers for internal use by the FTL */static uint8_t ftl_buffer[0x800] CACHEALIGN_ATTR;/* Temporary spare byte buffer for internal use by the FTL */static union ftl_spare_data_type ftl_sparebuffer[FTL_WRITESPARE_SIZE] CACHEALIGN_ATTR;#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] CACHEALIGN_ATTR;/* 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 affectedpage 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 overwrittenduring the copying operation in order to e.g. commit a CXT. */static uint8_t ftl_copybuffer[FTL_COPYBUF_SIZE][0x800] CACHEALIGN_ATTR;static union ftl_spare_data_type ftl_copyspare[FTL_COPYBUF_SIZE] CACHEALIGN_ATTR;/* Needed to store the old scattered page offsets in order to be able to rollback if something fails while compacting a scattered page block. */static uint16_t ftl_offsets_backup[0x200] CACHEALIGN_ATTR;/* Buffers needed for FTL recovery */static uint32_t blk_usn[0x2000] INITBSS_ATTR;static uint8_t blk_type[0x2000] INITBSS_ATTR;static uint32_t erasectr_usn[8] INITBSS_ATTR;static uint32_t pageusn[0x200] INITBSS_ATTR;static uint8_t pagedata[0x200][0x800] INITBSS_ATTR CACHEALIGN_ATTR;/* State information needed for FTL recovery */static uint32_t meta_usn INITBSS_ATTR;static uint32_t user_usn INITBSS_ATTR;static uint32_t allocmode INITBSS_ATTR;static uint32_t firstfree INITBSS_ATTR;#endifstatic struct mutex ftl_mtx;bool ftl_initialized;/* 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) INITCODE_ATTR;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 / 10);uint32_t block, page, pagenum;for (block = ftl_nand_type->blocks - 1; block >= lowestBlock; block--){page = ftl_nand_type->pagesperblock - 8;for (; page < ftl_nand_type->pagesperblock; page++){pagenum = block * ftl_nand_type->pagesperblock + page;if ((nand_read_page(bank, pagenum, ftl_buffer,&ftl_sparebuffer[0], 1, 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) INITCODE_ATTR;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) INITCODE_ATTR;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 & ~(ftl_nand_type->pagesperblock - 1);if ((nand_read_page(bank, page, ftl_buffer,(uint32_t*)0, 1, 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)(ftl_nand_type->pagesperblock - 8))break;if ((nand_read_page(bank, pagebase + page2, ftl_buffer,(void*)0, 1, 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 contextof 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;DEBUGF("FTL: Bad VFL CXT checksum on bank %d!", bank);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[0], 0xFF, 0x40);ftl_sparebuffer[0].meta.usn = ftl_vfl_cxt[bank].updatecount;ftl_sparebuffer[0].meta.field_8 = 0;ftl_sparebuffer[0].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 * ftl_nand_type->pagesperblock;page += ftl_vfl_cxt[bank].nextcxtpage - i;nand_write_page(bank, page, &ftl_vfl_cxt[bank], &ftl_sparebuffer[0], 1);}uint32_t good = 0;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 * ftl_nand_type->pagesperblock;page += ftl_vfl_cxt[bank].nextcxtpage - i;if ((nand_read_page(bank, page, ftl_buffer,&ftl_sparebuffer[0], 1, 0) & 0x11F) != 0)continue;if (memcmp(ftl_buffer, &ftl_vfl_cxt[bank], 0x7AC) != 0)continue;if (ftl_sparebuffer[0].meta.usn != ftl_vfl_cxt[bank].updatecount)continue;if (ftl_sparebuffer[0].meta.field_8 == 0&& ftl_sparebuffer[0].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){DEBUGF("FTL: VFL: Committing context on bank %d", bank);if (ftl_vfl_cxt[bank].nextcxtpage + 8 <= ftl_nand_type->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]* ftl_nand_type->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;}panicf(PANIC_FATAL, "VFL: Failed to commit VFL CXT!");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) INITCODE_ATTR;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) INITCODE_ATTR;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 vBlockin 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) INITCODE_ATTR;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 * ftl_nand_type->pagesperblock+ startpage + i;if ((nand_read_page(bank, page, databuffer,sparebuffer, 1, 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){DEBUGF("FTL: VFL: Following remapped block: %d => %d",block, ftl_vfl_cxt[bank].firstspare + spareindex);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;panicf(PANIC_FATAL, "FTL: Scheduling bank %u block %u for remap!",(unsigned)bank, (unsigned)block);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 combinationfrom 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 remapif 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;panicf(PANIC_FATAL, "FTL: Remapping bank %u block %u!",(unsigned)bank, (unsigned)block);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 * ftl_nand_type->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_TRACEDEBUGF("FTL: VFL: Reading page %d", vpage);#endifuint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;uint32_t syshyperblocks = ftl_nand_type->blocks- ftl_nand_type->userblocks - 0x17;uint32_t abspage = vpage + ppb * syshyperblocks;if (abspage >= ftl_nand_type->blocks * ppb || abspage < ppb){DEBUGF("FTL: Trying to read out-of-bounds vPage %u", (unsigned)vpage);return 4;}uint32_t bank = abspage % ftl_banks;uint32_t block = abspage / (ftl_nand_type->pagesperblock * ftl_banks);uint32_t page = (abspage / ftl_banks) % ftl_nand_type->pagesperblock;uint32_t physblock = ftl_vfl_get_physical_block(bank, block);uint32_t physpage = physblock * ftl_nand_type->pagesperblock + page;uint32_t ret = nand_read_page(bank, physpage, buffer,sparebuffer, 1, checkempty);if ((ret & 0x11D) != 0 && (ret & 2) == 0){nand_reset(bank);ret = nand_read_page(bank, physpage, buffer,sparebuffer, 1, checkempty);#ifdef FTL_READONLY(void)remaponfail;#elseif (remaponfail == 1 &&(ret & 0x11D) != 0 && (ret & 2) == 0){DEBUGF("FTL: VFL: Scheduling vBlock %d for remapping!", block);ftl_vfl_schedule_block_for_remap(bank, block);}#endifreturn ret;}return ret;}/* Multi-bank version of ftl_vfl_read, will read ftl_banks pages in parallel */static uint32_t ftl_vfl_read_fast(uint32_t vpage, void* buffer, void* sparebuffer,uint32_t checkempty, uint32_t remaponfail){#ifdef VFL_TRACEDEBUGF("FTL: VFL: Fast reading page %d on all banks", vpage);#endifuint32_t i, rc = 0;uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;uint32_t syshyperblocks = ftl_nand_type->blocks- ftl_nand_type->userblocks - 0x17;uint32_t abspage = vpage + ppb * syshyperblocks;if (abspage + ftl_banks - 1 >= ftl_nand_type->blocks * ppb || abspage < ppb){DEBUGF("FTL: Trying to read out-of-bounds vPage %u", (unsigned)vpage);return 4;}uint32_t bank = abspage % ftl_banks;uint32_t block = abspage / (ftl_nand_type->pagesperblock * ftl_banks);uint32_t page = (abspage / ftl_banks) % ftl_nand_type->pagesperblock;uint32_t remapped = 0;for (i = 0; i < ftl_banks; i++)if (ftl_vfl_get_physical_block(i, block) != block)remapped = 1;if (bank || remapped){for (i = 0; i < ftl_banks; i++){void* databuf = (void*)0;void* sparebuf = (void*)0;if (buffer) databuf = (void*)((uint32_t)buffer + 0x800 * i);if (sparebuffer) sparebuf = (void*)((uint32_t)sparebuffer + 0x40 * i);uint32_t ret = ftl_vfl_read(vpage + i, databuf, sparebuf, checkempty, remaponfail);if (ret & 1) rc |= 1 << (i << 2);if (ret & 2) rc |= 2 << (i << 2);if (ret & 0x10) rc |= 4 << (i << 2);if (ret & 0x100) rc |= 8 << (i << 2);}return rc;}uint32_t physpage = block * ftl_nand_type->pagesperblock + page;rc = nand_read_page_fast(physpage, buffer, sparebuffer, 1, checkempty);if (!(rc & 0xdddd)) return rc;for (i = 0; i < ftl_banks; i++){if ((rc >> (i << 2)) & 0x2) continue;if ((rc >> (i << 2)) & 0xd){rc &= ~(0xf << (i << 2));nand_reset(i);uint32_t ret = nand_read_page(i, physpage,(void*)((uint32_t)buffer + 0x800 * i),(void*)((uint32_t)sparebuffer + 0x40 * i),1, checkempty);#ifdef FTL_READONLY(void)remaponfail;#elseif (remaponfail == 1 && (ret & 0x11D) != 0 && (ret & 2) == 0)ftl_vfl_schedule_block_for_remap(i, block);#endifif (ret & 1) rc |= 1 << (i << 2);if (ret & 2) rc |= 2 << (i << 2);if (ret & 0x10) rc |= 4 << (i << 2);if (ret & 0x100) rc |= 8 << (i << 2);}}return rc;}#ifndef FTL_READONLY/* Writes the specified vPage, dealing with all kinds of trouble */static uint32_t ftl_vfl_write(uint32_t vpage, uint32_t count,void* buffer, void* sparebuffer){uint32_t i, j;#ifdef VFL_TRACEDEBUGF("FTL: VFL: Writing page %d", vpage);#endifuint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;uint32_t syshyperblocks = ftl_nand_type->blocks- ftl_nand_type->userblocks - 0x17;uint32_t abspage = vpage + ppb * syshyperblocks;if (abspage + count > ftl_nand_type->blocks * ppb || abspage < ppb){DEBUGF("FTL: Trying to write out-of-bounds vPage %u",(unsigned)vpage);return 4;}uint32_t bank[5];uint32_t block[5];uint32_t physpage[5];for (i = 0; i < count; i++, abspage++){for (j = ftl_banks; j > 0; j--){bank[j] = bank[j - 1];block[j] = block[j - 1];physpage[j] = physpage[j - 1];}bank[0] = abspage % ftl_banks;block[0] = abspage / (ftl_nand_type->pagesperblock * ftl_banks);uint32_t page = (abspage / ftl_banks) % ftl_nand_type->pagesperblock;uint32_t physblock = ftl_vfl_get_physical_block(bank[0], block[0]);physpage[0] = physblock * ftl_nand_type->pagesperblock + page;if (i >= ftl_banks)if (nand_write_page_collect(bank[ftl_banks]))if (nand_read_page(bank[ftl_banks], physpage[ftl_banks],ftl_buffer, &ftl_sparebuffer[0], 1, 1) & 0x11F){panicf(PANIC_FATAL, "FTL: write error (2) on vPage %u, bank %u, pPage %u",(unsigned)(vpage + i - ftl_banks),(unsigned)bank[ftl_banks],(unsigned)physpage[ftl_banks]);ftl_vfl_log_trouble(bank[ftl_banks], block[ftl_banks]);}if (nand_write_page_start(bank[0], physpage[0],(void*)((uint32_t)buffer + 0x800 * i),(void*)((uint32_t)sparebuffer + 0x40 * i), 1))if (nand_read_page(bank[0], physpage[0], ftl_buffer,&ftl_sparebuffer[0], 1, 1) & 0x11F){panicf(PANIC_FATAL, "FTL: write error (1) on vPage %u, bank %u, pPage %u",(unsigned)(vpage + i), (unsigned)bank[0], (unsigned)physpage[0]);ftl_vfl_log_trouble(bank[0], block[0]);}}for (i = count < ftl_banks ? count : ftl_banks; i > 0; i--)if (nand_write_page_collect(bank[i - 1]))if (nand_read_page(bank[i - 1], physpage[i - 1],ftl_buffer, &ftl_sparebuffer[0], 1, 1) & 0x11F){panicf(PANIC_FATAL, "FTL: write error (2) on vPage %u, bank %u, pPage %u",(unsigned)(vpage + count - i),(unsigned)bank[i - 1], (unsigned)physpage[i - 1]);ftl_vfl_log_trouble(bank[i - 1], block[i - 1]);}return 0;}#endif/* Mounts the VFL on all banks */static uint32_t ftl_vfl_open(void) INITCODE_ATTR;static uint32_t ftl_vfl_open(){uint32_t i, j, k;uint32_t minusn, vflcxtidx, last;struct ftl_vfl_cxt_type* cxt;uint16_t vflcxtblock[4];#ifndef FTL_READONLYftl_vfl_usn = 0;#else/* Temporary BBT buffer if we're readonly,as we won't need it again after mounting */uint8_t bbt[0x410];#endifuint32_t syshyperblocks = ftl_nand_type->blocks- ftl_nand_type->userblocks - 0x18;for (i = 0; i < ftl_banks; i++)#ifndef FTL_READONLYif (ftl_load_bbt(i, ftl_bbt[i]) == 0)#elseif (ftl_load_bbt(i, bbt) == 0)#endif{for (j = 1; j <= syshyperblocks; j++)#ifndef FTL_READONLYif (ftl_is_good_block(ftl_bbt[i], j) != 0)#elseif (ftl_is_good_block(bbt, j) != 0)#endifif (ftl_vfl_read_page(i, j, 0, ftl_buffer,&ftl_sparebuffer[0]) == 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]) == 0)if (ftl_sparebuffer[0].meta.usn > 0&& ftl_sparebuffer[0].meta.usn <= minusn){minusn = ftl_sparebuffer[0].meta.usn;vflcxtidx = k;}if (vflcxtidx == 4){DEBUGF("FTL: No VFL CXT block found on bank %u!",(unsigned)i);return 1;}last = 0;uint32_t max = ftl_nand_type->pagesperblock;for (k = 8; k < max; k += 8){if (ftl_vfl_read_page(i, vflcxtblock[vflcxtidx],k, ftl_buffer,&ftl_sparebuffer[0]) != 0)break;last = k;}if (ftl_vfl_read_page(i, vflcxtblock[vflcxtidx],last, ftl_buffer,&ftl_sparebuffer[0]) != 0)panicf(PANIC_FATAL, "FTL: Re-reading VFL CXT block ""on bank %u failed!?", (unsigned)i);//return 1;memcpy(&ftl_vfl_cxt[i], ftl_buffer, 0x800);if (ftl_vfl_verify_checksum(i) != 0) return 1;#ifndef FTL_READONLYif (ftl_vfl_usn < ftl_vfl_cxt[i].usn)ftl_vfl_usn = ftl_vfl_cxt[i].usn;#endifbreak;}}else{DEBUGF("FTL: Couldn't load bank %u lowlevel BBT!", (unsigned)i);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) INITCODE_ATTR;static uint32_t ftl_open(){uint32_t i;uint32_t ret;uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;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++){ret = ftl_vfl_read(ppb * cxt->ftlctrlblocks[i],ftl_buffer, &ftl_sparebuffer[0], 1, 0);if ((ret &= 0x11F) != 0) continue;if (ftl_sparebuffer[0].meta.type - 0x43 > 4) continue;if (ftlcxtblock != 0xffffffff && ftl_sparebuffer[0].meta.usn >= minusn)continue;minusn = ftl_sparebuffer[0].meta.usn;ftlcxtblock = cxt->ftlctrlblocks[i];}if (ftlcxtblock == 0xffffffff){DEBUGF("FTL: Couldn't find readable FTL CXT block!");return 1;}DEBUGF("FTL: Found FTL context block: vBlock %d", ftlcxtblock);uint32_t ftlcxtfound = 0;for (i = ftl_nand_type->pagesperblock * ftl_banks - 1; i > 0; i--){ret = ftl_vfl_read(ppb * ftlcxtblock + i,ftl_buffer, &ftl_sparebuffer[0], 1, 0);if ((ret & 0x11F) != 0) continue;else if (ftl_sparebuffer[0].meta.type == 0x43){memcpy(&ftl_cxt, ftl_buffer, 0x28C);ftlcxtfound = 1;break;}else{/* This will trip if there was an unclean unmount before. */DEBUGF("FTL: Unclean shutdown before!");#ifdef FTL_FORCEMOUNTDEBUGF("FTL: Forcing mount nevertheless...");#elsebreak;#endif}}if (ftlcxtfound == 0){DEBUGF("FTL: Couldn't find FTL CXT page!");return 1;}DEBUGF("FTL: Successfully read FTL context block");uint32_t pagestoread = ftl_nand_type->userblocks >> 10;if ((ftl_nand_type->userblocks & 0x1FF) != 0) pagestoread++;for (i = 0; i < pagestoread; i++){if ((ftl_vfl_read(ftl_cxt.ftl_map_pages[i],ftl_buffer, &ftl_sparebuffer[0], 1, 1) & 0x11F) != 0){DEBUGF("FTL: Failed to read block map page %u", (unsigned)i);return 1;}uint32_t toread = 2048;if (toread > (ftl_nand_type->userblocks << 1) - (i << 11))toread = (ftl_nand_type->userblocks << 1) - (i << 11);memcpy(&ftl_map[i << 10], ftl_buffer, toread);}#ifndef FTL_READONLYpagestoread = (ftl_nand_type->userblocks + 23) >> 10;if (((ftl_nand_type->userblocks + 23) & 0x1FF) != 0) pagestoread++;for (i = 0; i < pagestoread; i++){if ((ftl_vfl_read(ftl_cxt.ftl_erasectr_pages[i],ftl_buffer, &ftl_sparebuffer[0], 1, 1) & 0x11F) != 0){DEBUGF("FTL: Failed to read erase counter page %u", (unsigned)i);return 1;}uint32_t toread = 2048;if (toread > ((ftl_nand_type->userblocks + 23) << 1) - (i << 11))toread = ((ftl_nand_type->userblocks + 23) << 1) - (i << 11);memcpy(&ftl_erasectr[i << 10], ftl_buffer, toread);}for (i = 0; i < 0x11; i++){ftl_log[i].scatteredvblock = 0xFFFF;ftl_log[i].logicalvblock = 0xFFFF;ftl_log[i].pageoffsets = ftl_offsets[i];}memset(ftl_troublelog, 0xFF, 20);memset(ftl_erasectr_dirt, 0, 8);#endif#ifdef FTL_DEBUGuint32_t j, k;for (i = 0; i < ftl_banks; i++){uint32_t badblocks = 0;#ifndef FTL_READONLYfor (j = 0; j < ftl_nand_type->blocks >> 3; j++){uint8_t bbtentry = ftl_bbt[i][j];for (k = 0; k < 8; k++) if ((bbtentry & (1 << k)) == 0) badblocks++;}DEBUGF("FTL: BBT for bank %d: %d bad blocks", i, badblocks);badblocks = 0;#endiffor (j = 0; j < ftl_vfl_cxt[i].sparecount; j++)if (ftl_vfl_cxt[i].remaptable[j] == 0xFFFF) badblocks++;DEBUGF("FTL: VFL: Bank %d: %d of %d spare blocks are bad",i, badblocks, ftl_vfl_cxt[i].sparecount);DEBUGF("FTL: VFL: Bank %d: %d blocks remapped",i, ftl_vfl_cxt[i].spareused);DEBUGF("FTL: VFL: Bank %d: %d blocks scheduled for remapping",i, 0x334 - ftl_vfl_cxt[i].scheduledstart);}#ifndef FTL_READONLYuint32_t min = 0xFFFFFFFF, max = 0, total = 0;for (i = 0; i < ftl_nand_type->userblocks + 23; i++){if (ftl_erasectr[i] > max) max = ftl_erasectr[i];if (ftl_erasectr[i] < min) min = ftl_erasectr[i];total += ftl_erasectr[i];}DEBUGF("FTL: Erase counters: Minimum: %d, maximum %d, average: %d, total: %d",min, max, total / (ftl_nand_type->userblocks + 23), total);#endif#endifreturn 0;}#ifndef FTL_READONLY/* Returns a pointer to the ftl_log entry for the specified vBlock,or null, if there is none */static struct ftl_log_type* ftl_get_log_entry(uint32_t block){uint32_t i;for (i = 0; i < 0x11; i++){if (ftl_log[i].scatteredvblock == 0xFFFF) continue;if (ftl_log[i].logicalvblock == block) return &ftl_log[i];}return (struct ftl_log_type*)0;}#endif/* Exposed function: Read highlevel sectors */uint32_t ftl_read(uint32_t sector, uint32_t count, void* buffer){uint32_t i, j;uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;uint32_t error = 0;if (!ftl_initialized) return 1;#ifdef FTL_TRACEDEBUGF("FTL: Reading %d sectors starting at %d", count, sector);#endifif ((uint32_t)buffer & (CACHEALIGN_SIZE - 1))panicf(PANIC_KILLTHREAD,"ftl_read: Misaligned data buffer at %08X (sector %lu, count %lu)",(unsigned int)buffer, sector, count);if (sector + count > ftl_nand_type->userblocks * ppb){DEBUGF("FTL: Sector %d is out of range!", sector + count - 1);return 1;}if (count == 0) return 0;mutex_lock(&ftl_mtx, TIMEOUT_BLOCK);for (i = 0; i < count; i++){uint32_t block = (sector + i) / ppb;uint32_t page = (sector + i) % ppb;uint32_t abspage = ftl_map[block] * ppb + page;#ifndef FTL_READONLYstruct ftl_log_type* logentry = ftl_get_log_entry(block);if (logentry != (struct ftl_log_type*)0){#ifdef FTL_TRACEDEBUGF("FTL: Block %d has a log entry", block);#endifif (logentry->scatteredvblock != 0xFFFF&& logentry->pageoffsets[page] != 0xFFFF){#ifdef FTL_TRACEDEBUGF("FTL: Found page %d at block %d, page %d", page,(*logentry).scatteredvblock, (*logentry).pageoffsets[page]);#endifabspage = logentry->scatteredvblock * ppb+ logentry->pageoffsets[page];}}#endif#ifndef FTL_READONLYif (count >= i + ftl_banks && !(page & (ftl_banks - 1))&& logentry == (struct ftl_log_type*)0)#elseif (count >= i + ftl_banks && !(page & (ftl_banks - 1)))#endif{uint32_t ret = ftl_vfl_read_fast(abspage, &((uint8_t*)buffer)[i << 11],&ftl_sparebuffer[0], 1, 1);for (j = 0; j < ftl_banks; j++)if (ret & (2 << (j << 2)))memset(&((uint8_t*)buffer)[(i + j) << 11], 0, 0x800);else if ((ret & (0xd << (j << 2))) || ftl_sparebuffer[j].user.eccmark != 0xFF){DEBUGF("FTL: Error while reading sector %d!", (sector + i));error = 1;memset(&((uint8_t*)buffer)[(i + j) << 11], 0, 0x800);}i += ftl_banks - 1;}else{uint32_t ret = ftl_vfl_read(abspage, &((uint8_t*)buffer)[i << 11],&ftl_sparebuffer[0], 1, 1);if (ret & 2) memset(&((uint8_t*)buffer)[i << 11], 0, 0x800);else if ((ret & 0x11D) != 0 || ftl_sparebuffer[0].user.eccmark != 0xFF){DEBUGF("FTL: Error while reading sector %d!", (sector + i));error = 1;memset(&((uint8_t*)buffer)[i << 11], 0, 0x800);}}}mutex_unlock(&ftl_mtx);return error;}#ifndef FTL_READONLY/* Performs a vBlock erase, dealing with hardware,remapping and all kinds of trouble */static uint32_t ftl_erase_block_internal(uint32_t block){uint32_t i, j;block = block + ftl_nand_type->blocks- ftl_nand_type->userblocks - 0x17;if (block == 0 || block >= ftl_nand_type->blocks) return 1;for (i = 0; i < ftl_banks; i++){if (ftl_vfl_check_remap_scheduled(i, block) == 1){ftl_vfl_remap_block(i, block);ftl_vfl_mark_remap_done(i, block);}ftl_vfl_log_success(i, block);uint32_t pblock = ftl_vfl_get_physical_block(i, block);uint32_t rc;for (j = 0; j < 3; j++){rc = nand_block_erase(i, pblock * ftl_nand_type->pagesperblock);if (rc == 0) break;}if (rc != 0){panicf(PANIC_FATAL, "FTL: Block erase failed on bank %u block %u",(unsigned)i, (unsigned)block);if (pblock != block){uint32_t spareindex = pblock - ftl_vfl_cxt[i].firstspare;ftl_vfl_cxt[i].remaptable[spareindex] = 0xFFFF;}ftl_vfl_cxt[i].field_18++;if (ftl_vfl_remap_block(i, block) == 0) return 1;if (ftl_vfl_commit_cxt(i) != 0) return 1;memset(&ftl_sparebuffer, 0, 0x40);nand_write_page(i, pblock, &ftl_vfl_cxt[0], &ftl_sparebuffer, 1);}}return 0;}#endif#ifndef FTL_READONLY/* Highlevel vBlock erase, that increments the erase counter for the block */static uint32_t ftl_erase_block(uint32_t block){ftl_erasectr[block]++;if (ftl_erasectr_dirt[block >> 10] == 100) ftl_cxt.erasedirty = 1;else ftl_erasectr_dirt[block >> 10]++;return ftl_erase_block_internal(block);}#endif#ifndef FTL_READONLY/* Allocates a block from the pool,returning its vBlock number, or 0xFFFFFFFF on error */static uint32_t ftl_allocate_pool_block(void){uint32_t i;uint32_t erasectr = 0xFFFFFFFF, bestidx = 0xFFFFFFFF, block;for (i = 0; i < ftl_cxt.freecount; i++){uint32_t idx = ftl_cxt.nextfreeidx + i;if (idx >= 0x14) idx -= 0x14;if (!ftl_cxt.blockpool[idx]) continue;if (ftl_erasectr[ftl_cxt.blockpool[idx]] < erasectr){erasectr = ftl_erasectr[ftl_cxt.blockpool[idx]];bestidx = idx;}}if (bestidx == 0xFFFFFFFF) panicf(PANIC_FATAL, "FTL: Out of pool blocks!");block = ftl_cxt.blockpool[bestidx];if (bestidx != ftl_cxt.nextfreeidx){ftl_cxt.blockpool[bestidx] = ftl_cxt.blockpool[ftl_cxt.nextfreeidx];ftl_cxt.blockpool[ftl_cxt.nextfreeidx] = block;}if (block > (uint32_t)ftl_nand_type->userblocks + 0x17)panicf(PANIC_FATAL, "FTL: Bad block number in pool: %u", (unsigned)block);if (ftl_erase_block(block) != 0) return 0xFFFFFFFF;if (++ftl_cxt.nextfreeidx == 0x14) ftl_cxt.nextfreeidx = 0;ftl_cxt.freecount--;return block;}#endif#ifndef FTL_READONLY/* Releases a vBlock back into the pool */static void ftl_release_pool_block(uint32_t block){if (block >= (uint32_t)ftl_nand_type->userblocks + 0x17)panicf(PANIC_FATAL, "FTL: Tried to release block %u", (unsigned)block);uint32_t idx = ftl_cxt.nextfreeidx + ftl_cxt.freecount++;if (idx >= 0x14) idx -= 0x14;ftl_cxt.blockpool[idx] = block;}#endif#ifndef FTL_READONLY/* Commits the location of the FTL context blocksto a semi-randomly chosen VFL context */static uint32_t ftl_store_ctrl_block_list(void){uint32_t i;for (i = 0; i < ftl_banks; i++)memcpy(ftl_vfl_cxt[i].ftlctrlblocks, ftl_cxt.ftlctrlblocks, 6);return ftl_vfl_commit_cxt(ftl_vfl_usn % ftl_banks);}#endif#ifndef FTL_READONLY/* Saves the n-th erase counter page to the flash,because it is too dirty or needs to be moved. */static uint32_t ftl_save_erasectr_page(uint32_t index){memset(&ftl_sparebuffer[0], 0xFF, 0x40);ftl_sparebuffer[0].meta.usn = ftl_cxt.usn;ftl_sparebuffer[0].meta.idx = index;ftl_sparebuffer[0].meta.type = 0x46;if (ftl_vfl_write(ftl_cxt.ftlctrlpage, 1, &ftl_erasectr[index << 10],&ftl_sparebuffer[0]) != 0)return 1;if ((ftl_vfl_read(ftl_cxt.ftlctrlpage, ftl_buffer,&ftl_sparebuffer[0], 1, 1) & 0x11F) != 0)return 1;if (memcmp(ftl_buffer, &ftl_erasectr[index << 10], 0x800) != 0) return 1;if (ftl_sparebuffer[0].meta.type != 0x46) return 1;if (ftl_sparebuffer[0].meta.idx != index) return 1;if (ftl_sparebuffer[0].meta.usn != ftl_cxt.usn) return 1;ftl_cxt.ftl_erasectr_pages[index] = ftl_cxt.ftlctrlpage;ftl_erasectr_dirt[index] = 0;return 0;}#endif#ifndef FTL_READONLY/* Increments ftl_cxt.ftlctrlpage to the next available FTL context page,allocating a new context block if neccessary. */static uint32_t ftl_next_ctrl_pool_page(void){uint32_t i;uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;if (++ftl_cxt.ftlctrlpage % ppb != 0) return 0;for (i = 0; i < 3; i++)if ((ftl_cxt.ftlctrlblocks[i] + 1) * ppb == ftl_cxt.ftlctrlpage)break;i = (i + 1) % 3;uint32_t oldblock = ftl_cxt.ftlctrlblocks[i];uint32_t newblock = ftl_allocate_pool_block();if (newblock == 0xFFFFFFFF) return 1;ftl_cxt.ftlctrlblocks[i] = newblock;ftl_cxt.ftlctrlpage = newblock * ppb;DEBUGF("Starting new FTL control block at %d", ftl_cxt.ftlctrlpage);uint32_t pagestoread = (ftl_nand_type->userblocks + 23) >> 10;if (((ftl_nand_type->userblocks + 23) & 0x1FF) != 0) pagestoread++;for (i = 0; i < pagestoread; i++)if (oldblock * ppb <= ftl_cxt.ftl_erasectr_pages[i]&& (oldblock + 1) * ppb > ftl_cxt.ftl_erasectr_pages[i]){ftl_cxt.usn--;if (ftl_save_erasectr_page(i) != 0){ftl_cxt.ftlctrlblocks[i] = oldblock;ftl_cxt.ftlctrlpage = oldblock * (ppb + 1) - 1;ftl_release_pool_block(newblock);return 1;}ftl_cxt.ftlctrlpage++;}ftl_release_pool_block(oldblock);return ftl_store_ctrl_block_list();}#endif#ifndef FTL_READONLY/* Copies a vPage from one location to another */static uint32_t ftl_copy_page(uint32_t source, uint32_t destination,uint32_t lpn, uint32_t type){uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;uint32_t rc = ftl_vfl_read(source, ftl_copybuffer[0],&ftl_copyspare[0], 1, 1) & 0x11F;memset(&ftl_copyspare[0], 0xFF, 0x40);ftl_copyspare[0].user.lpn = lpn;ftl_copyspare[0].user.usn = ++ftl_cxt.nextblockusn;ftl_copyspare[0].user.type = 0x40;if ((rc & 2) != 0) memset(ftl_copybuffer[0], 0, 0x800);else if (rc != 0) ftl_copyspare[0].user.eccmark = 0x55;if (type == 1 && destination % ppb == ppb - 1)ftl_copyspare[0].user.type = 0x41;return ftl_vfl_write(destination, 1, ftl_copybuffer[0], &ftl_copyspare[0]);}#endif#ifndef FTL_READONLY/* Copies a pBlock to a vBlock */static uint32_t ftl_copy_block(uint32_t source, uint32_t destination){uint32_t i, j;uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;uint32_t error = 0;ftl_cxt.nextblockusn++;for (i = 0; i < ppb; i += FTL_COPYBUF_SIZE){uint32_t rc = ftl_read(source * ppb + i,FTL_COPYBUF_SIZE, ftl_copybuffer[0]);memset(&ftl_copyspare[0], 0xFF, 0x40 * FTL_COPYBUF_SIZE);for (j = 0; j < FTL_COPYBUF_SIZE; j++){ftl_copyspare[j].user.lpn = source * ppb + i + j;ftl_copyspare[j].user.usn = ftl_cxt.nextblockusn;ftl_copyspare[j].user.type = 0x40;if (rc){if (ftl_read(source * ppb + i + j, 1, ftl_copybuffer[j]))ftl_copyspare[j].user.eccmark = 0x55;}if (i + j == ppb - 1) ftl_copyspare[j].user.type = 0x41;}if (ftl_vfl_write(destination * ppb + i, FTL_COPYBUF_SIZE,ftl_copybuffer[0], &ftl_copyspare[0])){error = 1;break;}}if (error != 0){ftl_erase_block(destination);return 1;}return 0;}#endif#ifndef FTL_READONLY/* Clears ftl_log.issequential, if something violating that is written. */static void ftl_check_still_sequential(struct ftl_log_type* entry, uint32_t page){if (entry->pagesused != entry->pagescurrent|| entry->pageoffsets[page] != page)entry->issequential = 0;}#endif#ifndef FTL_READONLY/* Copies all pages that are currently used from the scattered page block inuse by the supplied ftl_log entry to a newly-allocated one, and releasesthe old one.In other words: It kicks the pages containing old garbage out of it to makespace again. This is usually done when a scattered page block is beingremoved because it is full, but less than half of the pages in there arestill in use and rest is just filled with old crap. */static uint32_t ftl_compact_scattered(struct ftl_log_type* entry){uint32_t i, j;uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;uint32_t error;struct ftl_log_type backup;if (entry->pagescurrent == 0){ftl_release_pool_block(entry->scatteredvblock);entry->scatteredvblock = 0xFFFF;return 0;}backup = *entry;memcpy(ftl_offsets_backup, entry->pageoffsets, 0x400);for (i = 0; i < 4; i++){uint32_t block = ftl_allocate_pool_block();if (block == 0xFFFFFFFF) return 1;entry->pagesused = 0;entry->pagescurrent = 0;entry->issequential = 1;entry->scatteredvblock = block;error = 0;for (j = 0; j < ppb; j++)if (entry->pageoffsets[j] != 0xFFFF){uint32_t lpn = entry->logicalvblock * ppb + j;uint32_t newpage = block * ppb + entry->pagesused;uint32_t oldpage = backup.scatteredvblock * ppb+ entry->pageoffsets[j];if (ftl_copy_page(oldpage, newpage, lpn,entry->issequential) != 0){error = 1;break;}entry->pageoffsets[j] = entry->pagesused++;entry->pagescurrent++;ftl_check_still_sequential(entry, j);}if (backup.pagescurrent != entry->pagescurrent) error = 1;if (error == 0){ftl_release_pool_block(backup.scatteredvblock);break;}*entry = backup;memcpy(entry->pageoffsets, ftl_offsets_backup, 0x400);}return error;}#endif#ifndef FTL_READONLY/* Commits an ftl_log entry to proper blocks, no matter what's in there. */static uint32_t ftl_commit_scattered(struct ftl_log_type* entry){uint32_t i;uint32_t error;uint32_t block;for (i = 0; i < 4; i++){block = ftl_allocate_pool_block();if (block == 0xFFFFFFFF) return 1;error = ftl_copy_block(entry->logicalvblock, block);if (error == 0) break;ftl_release_pool_block(block);}if (error != 0) return 1;ftl_release_pool_block(entry->scatteredvblock);entry->scatteredvblock = 0xFFFF;ftl_release_pool_block(ftl_map[entry->logicalvblock]);ftl_map[entry->logicalvblock] = block;return 0;}#endif#ifndef FTL_READONLY/* Fills the rest of a scattered page block that was actually writtensequentially until now, in order to be able to save a block erase bycommitting it without needing to copy it again.If this fails for whichever reason, it will be committed the usual way. */static uint32_t ftl_commit_sequential(struct ftl_log_type* entry){uint32_t i;uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;if (entry->issequential != 1|| entry->pagescurrent != entry->pagesused)return 1;for (; entry->pagesused < ppb; ){uint32_t lpn = entry->logicalvblock * ppb + entry->pagesused;uint32_t newpage = entry->scatteredvblock * ppb+ entry->pagesused;uint32_t count = FTL_COPYBUF_SIZE < ppb - entry->pagesused? FTL_COPYBUF_SIZE : ppb - entry->pagesused;for (i = 0; i < count; i++)if (entry->pageoffsets[entry->pagesused + i] != 0xFFFF)return ftl_commit_scattered(entry);uint32_t rc = ftl_read(lpn, count, ftl_copybuffer[0]);memset(&ftl_copyspare[0], 0xFF, 0x40 * FTL_COPYBUF_SIZE);for (i = 0; i < count; i++){ftl_copyspare[i].user.lpn = lpn + i;ftl_copyspare[i].user.usn = ++ftl_cxt.nextblockusn;ftl_copyspare[i].user.type = 0x40;if (rc) ftl_copyspare[i].user.eccmark = 0x55;if (entry->pagesused + i == ppb - 1)ftl_copyspare[i].user.type = 0x41;}if (ftl_vfl_write(newpage, count, ftl_copybuffer[0], &ftl_copyspare[0]))return ftl_commit_scattered(entry);entry->pagesused += count;}ftl_release_pool_block(ftl_map[entry->logicalvblock]);ftl_map[entry->logicalvblock] = entry->scatteredvblock;entry->scatteredvblock = 0xFFFF;return 0;}#endif#ifndef FTL_READONLY/* If a log entry is supplied, its scattered page block will be removed inwhatever way seems most appropriate. Else, the oldest scattered page blockwill be freed by committing it. */static uint32_t ftl_remove_scattered_block(struct ftl_log_type* entry){uint32_t i;uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;uint32_t age = 0xFFFFFFFF, used = 0;if (entry == (struct ftl_log_type*)0){for (i = 0; i < 0x11; i++){if (ftl_log[i].scatteredvblock == 0xFFFF) continue;if (ftl_log[i].pagesused == 0 || ftl_log[i].pagescurrent == 0)return 1;if (ftl_log[i].usn < age|| (ftl_log[i].usn == age && ftl_log[i].pagescurrent > used)){age = ftl_log[i].usn;used = ftl_log[i].pagescurrent;entry = &ftl_log[i];}}if (entry == (struct ftl_log_type*)0) return 1;}else if (entry->pagescurrent < ppb / 2){ftl_cxt.swapcounter++;return ftl_compact_scattered(entry);}ftl_cxt.swapcounter++;if (entry->issequential == 1) return ftl_commit_sequential(entry);else return ftl_commit_scattered(entry);}#endif#ifndef FTL_READONLY/* Initialize a log entry to the values for an empty scattered page block */static void ftl_init_log_entry(struct ftl_log_type* entry){entry->issequential = 1;entry->pagescurrent = 0;entry->pagesused = 0;memset(entry->pageoffsets, 0xFF, 0x400);}#endif#ifndef FTL_READONLY/* Allocates a log entry for the specified vBlock,first making space, if neccessary. */static struct ftl_log_type* ftl_allocate_log_entry(uint32_t block){uint32_t i;struct ftl_log_type* entry = ftl_get_log_entry(block);entry->usn = ftl_cxt.nextblockusn - 1;if (entry != (struct ftl_log_type*)0) return entry;for (i = 0; i < 0x11; i++){if (ftl_log[i].scatteredvblock == 0xFFFF) continue;if (ftl_log[i].pagesused == 0){entry = &ftl_log[i];break;}}if (entry == (struct ftl_log_type*)0){if (ftl_cxt.freecount < 3) panicf(PANIC_FATAL, "FTL: Detected a pool block leak!");else if (ftl_cxt.freecount == 3)if (ftl_remove_scattered_block((struct ftl_log_type*)0) != 0)return (struct ftl_log_type*)0;entry = ftl_log;while (entry->scatteredvblock != 0xFFFF) entry = &entry[1];entry->scatteredvblock = ftl_allocate_pool_block();if (entry->scatteredvblock == 0xFFFF)return (struct ftl_log_type*)0;}ftl_init_log_entry(entry);entry->logicalvblock = block;entry->usn = ftl_cxt.nextblockusn - 1;return entry;}#endif#ifndef FTL_READONLY/* Commits the FTL block map, erase counters, and context to flash */static uint32_t ftl_commit_cxt(void){uint32_t i;uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;uint32_t mappages = (ftl_nand_type->userblocks + 0x3ff) >> 10;uint32_t ctrpages = (ftl_nand_type->userblocks + 23 + 0x3ff) >> 10;uint32_t endpage = ftl_cxt.ftlctrlpage + mappages + ctrpages + 1;DEBUGF("FTL: Committing context");if (endpage >= (ftl_cxt.ftlctrlpage / ppb + 1) * ppb)ftl_cxt.ftlctrlpage |= ppb - 1;for (i = 0; i < ctrpages; i++){if (ftl_next_ctrl_pool_page() != 0) return 1;if (ftl_save_erasectr_page(i) != 0) return 1;}for (i = 0; i < mappages; i++){if (ftl_next_ctrl_pool_page() != 0) return 1;memset(&ftl_sparebuffer[0], 0xFF, 0x40);ftl_sparebuffer[0].meta.usn = ftl_cxt.usn;ftl_sparebuffer[0].meta.idx = i;ftl_sparebuffer[0].meta.type = 0x44;if (ftl_vfl_write(ftl_cxt.ftlctrlpage, 1, &ftl_map[i << 10],&ftl_sparebuffer[0]) != 0)return 1;ftl_cxt.ftl_map_pages[i] = ftl_cxt.ftlctrlpage;}if (ftl_next_ctrl_pool_page() != 0) return 1;ftl_cxt.clean_flag = 1;memset(&ftl_sparebuffer[0], 0xFF, 0x40);ftl_sparebuffer[0].meta.usn = ftl_cxt.usn;ftl_sparebuffer[0].meta.type = 0x43;if (ftl_vfl_write(ftl_cxt.ftlctrlpage, 1, &ftl_cxt, &ftl_sparebuffer[0]) != 0)return 1;DEBUGF("FTL: Wrote context to page %d", ftl_cxt.ftlctrlpage);return 0;}#endif#ifndef FTL_READONLY/* Swaps the most and least worn block on the flash,to better distribute wear. It will refuse to do anythingif the wear spread is lower than 5 erases. */static uint32_t ftl_swap_blocks(void){uint32_t i;uint32_t min = 0xFFFFFFFF, max = 0, maxidx = 0x14;uint32_t minidx = 0, minvb = 0, maxvb = 0;for (i = 0; i < ftl_cxt.freecount; i++){uint32_t idx = ftl_cxt.nextfreeidx + i;if (idx >= 0x14) idx -= 0x14;if (ftl_erasectr[ftl_cxt.blockpool[idx]] > max){maxidx = idx;maxvb = ftl_cxt.blockpool[idx];max = ftl_erasectr[maxidx];}}if (maxidx == 0x14) return 0;for (i = 0; i < ftl_nand_type->userblocks; i++){if (ftl_erasectr[ftl_map[i]] > max) max = ftl_erasectr[ftl_map[i]];if (ftl_get_log_entry(i) != (struct ftl_log_type*)0) continue;if (ftl_erasectr[ftl_map[i]] < min){minidx = i;minvb = ftl_map[i];min = ftl_erasectr[minidx];}}if (max - min < 5) return 0;if (minvb == maxvb) return 0;if (ftl_erase_block(maxvb) != 0) return 1;if (ftl_copy_block(minidx, maxvb) != 0) return 1;ftl_cxt.blockpool[maxidx] = minvb;ftl_map[minidx] = maxvb;return 0;}#endif#ifndef FTL_READONLY/* Exposed function: Write highlevel sectors */uint32_t ftl_write(uint32_t sector, uint32_t count, const void* buffer){uint32_t i, j, k;uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;if (!ftl_initialized) return 1;#ifdef FTL_TRACEDEBUGF("FTL: Writing %d sectors starting at %d", count, sector);#endifif ((uint32_t)buffer & (CACHEALIGN_SIZE - 1))panicf(PANIC_KILLTHREAD,"ftl_write: Misaligned data buffer at %08X (sector %lu, count %lu)",(unsigned int)buffer, sector, count);if (sector + count > ftl_nand_type->userblocks * ppb){DEBUGF("FTL: Sector %d is out of range!", sector + count - 1);return 1;}if (count == 0) return 0;mutex_lock(&ftl_mtx, TIMEOUT_BLOCK);if (ftl_cxt.clean_flag == 1){for (i = 0; i < 3; i++){DEBUGF("FTL: Marking dirty, try %d", i);if (ftl_next_ctrl_pool_page() != 0){mutex_unlock(&ftl_mtx);return 1;}memset(ftl_buffer, 0xFF, 0x800);memset(&ftl_sparebuffer[0], 0xFF, 0x40);ftl_sparebuffer[0].meta.usn = ftl_cxt.usn;ftl_sparebuffer[0].meta.type = 0x47;if (ftl_vfl_write(ftl_cxt.ftlctrlpage, 1, ftl_buffer,&ftl_sparebuffer[0]) == 0)break;}if (i == 3){mutex_unlock(&ftl_mtx);return 1;}DEBUGF("FTL: Wrote dirty mark to %d", ftl_cxt.ftlctrlpage);ftl_cxt.clean_flag = 0;}for (i = 0; i < count; ){uint32_t block = (sector + i) / ppb;uint32_t page = (sector + i) % ppb;struct ftl_log_type* logentry = ftl_allocate_log_entry(block);if (logentry == (struct ftl_log_type*)0){mutex_unlock(&ftl_mtx);return 1;}if (page == 0 && count - i >= ppb){#ifdef FTL_TRACEDEBUGF("FTL: Going to write a full hyperblock in one shot");#endifuint32_t vblock = logentry->scatteredvblock;logentry->scatteredvblock = 0xFFFF;if (logentry->pagesused != 0){#ifdef FTL_TRACEDEBUGF("FTL: Scattered block had some pages already used, committing");#endifftl_release_pool_block(vblock);vblock = ftl_allocate_pool_block();if (vblock == 0xFFFFFFFF){mutex_unlock(&ftl_mtx);return 1;}}ftl_cxt.nextblockusn++;for (j = 0; j < ppb; j += FTL_WRITESPARE_SIZE){memset(&ftl_sparebuffer[0], 0xFF, 0x40 * FTL_WRITESPARE_SIZE);for (k = 0; k < FTL_WRITESPARE_SIZE; k++){ftl_sparebuffer[k].user.lpn = sector + i + j + k;ftl_sparebuffer[k].user.usn = ftl_cxt.nextblockusn;ftl_sparebuffer[k].user.type = 0x40;if (j == ppb - 1) ftl_sparebuffer[k].user.type = 0x41;}uint32_t rc = ftl_vfl_write(vblock * ppb + j, FTL_WRITESPARE_SIZE,&((uint8_t*)buffer)[(i + j) << 11],&ftl_sparebuffer[0]);if (rc)for (k = 0; k < ftl_banks; k++)if (rc & (1 << k)){while (ftl_vfl_write(vblock * ppb + j + k, 1,&((uint8_t*)buffer)[(i + j + k) << 11],&ftl_sparebuffer[k]));}}ftl_release_pool_block(ftl_map[block]);ftl_map[block] = vblock;i += ppb;}else{if (logentry->pagesused == ppb){#ifdef FTL_TRACEDEBUGF("FTL: Scattered block is full, committing");#endifftl_remove_scattered_block(logentry);logentry = ftl_allocate_log_entry(block);if (logentry == (struct ftl_log_type*)0){mutex_unlock(&ftl_mtx);return 1;}}uint32_t cnt = FTL_WRITESPARE_SIZE;if (cnt > count - i) cnt = count - i;if (cnt > ppb - logentry->pagesused) cnt = ppb - logentry->pagesused;if (cnt > ppb - page) cnt = ppb - page;memset(&ftl_sparebuffer[0], 0xFF, 0x40 * cnt);for (j = 0; j < cnt; j++){ftl_sparebuffer[j].user.lpn = sector + i + j;ftl_sparebuffer[j].user.usn = ++ftl_cxt.nextblockusn;ftl_sparebuffer[j].user.type = 0x40;if (logentry->pagesused + j == ppb - 1 && logentry->issequential)ftl_sparebuffer[j].user.type = 0x41;}uint32_t abspage = logentry->scatteredvblock * ppb+ logentry->pagesused;logentry->pagesused += cnt;if (ftl_vfl_write(abspage, cnt, &((uint8_t*)buffer)[i << 11],&ftl_sparebuffer[0]) == 0){for (j = 0; j < cnt; j++){if (logentry->pageoffsets[page + j] == 0xFFFF)logentry->pagescurrent++;logentry->pageoffsets[page + j] = logentry->pagesused - cnt + j;if (logentry->pagesused - cnt + j + 1 != logentry->pagescurrent|| logentry->pageoffsets[page + j] != page + j)logentry->issequential = 0;}i += cnt;}else panicf(PANIC_FATAL, "FTL: Write error: %u %u %u!",(unsigned)sector, (unsigned)count, (unsigned)i);}if (logentry->pagesused == ppb) ftl_remove_scattered_block(logentry);}if (ftl_cxt.swapcounter >= 300){ftl_cxt.swapcounter -= 20;for (i = 0; i < 4; i++) if (ftl_swap_blocks() == 0) break;}if (ftl_cxt.erasedirty == 1){ftl_cxt.erasedirty = 0;for (i = 0; i < 8; i++)if (ftl_erasectr_dirt[i] >= 100){ftl_next_ctrl_pool_page();ftl_save_erasectr_page(i);}}mutex_unlock(&ftl_mtx);return 0;}#endif#ifndef FTL_READONLY/* Exposed function: Performes a sync / unmount,i.e. commits all scattered page blocks,distributes wear, and commits the FTL context. */uint32_t ftl_sync(void){uint32_t i;uint32_t rc = 0;uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;if (!ftl_initialized) return 1;if (ftl_cxt.clean_flag == 1) return 0;mutex_lock(&ftl_mtx, TIMEOUT_BLOCK);#ifdef FTL_TRACEDEBUGF("FTL: Syncing");#endifif (ftl_cxt.swapcounter >= 20)for (i = 0; i < 4; i++)if (ftl_swap_blocks() == 0){ftl_cxt.swapcounter -= 20;break;}for (i = 0; i < 0x11; i++){if (ftl_log[i].scatteredvblock == 0xFFFF) continue;ftl_cxt.nextblockusn++;if (ftl_log[i].issequential == 1)rc |= ftl_commit_sequential(&ftl_log[i]);else rc |= ftl_commit_scattered(&ftl_log[i]);}if (rc != 0){mutex_unlock(&ftl_mtx);return 1;}for (i = 0; i < 5; i++)if (ftl_commit_cxt() == 0){mutex_unlock(&ftl_mtx);return 0;}else ftl_cxt.ftlctrlpage |= ppb - 1;mutex_unlock(&ftl_mtx);return 1;}#endif/* Block allocator for FTL recovery */static uint32_t ftl_alloc_block() INITCODE_ATTR;static uint32_t ftl_alloc_block(){while (1){for (; firstfree < ftl_nand_type->userblocks + 0x17; firstfree++)if (!blk_type[firstfree]) break;else if (allocmode && blk_type[firstfree] != 1){if (ftl_erase_block(firstfree)){cprintf(CONSOLE_BOOT, "Couldn't erase vBlock %d (pool alloc)!\n", firstfree);return 1;}break;}if (firstfree < ftl_nand_type->userblocks + 0x17){blk_type[firstfree] = 1;return firstfree++;}if (!allocmode){allocmode = 1;firstfree = 0;}else{cputs(CONSOLE_BOOT, "Out of empty blocks!\n");return 1;}}}static uint32_t ftl_repair(void) INITCODE_ATTR;static uint32_t ftl_repair(){uint32_t i, j, k;#ifdef HAVE_LCDstruct progressbar_state progressbar;#endifcputs(CONSOLE_BOOT, "Scanning flash...\n");#ifdef HAVE_LCDlcdconsole_progressbar(&progressbar, 0, ftl_nand_type->userblocks + 0x17);#endifuint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;memset(&ftl_cxt, 0x00, 0x800);memset(ftl_map, 0xff, 0x4000);memset(blk_usn, 0x00, 0x8000);memset(blk_type, 0x00, 0x2000);memset(ftl_erasectr, 0x00, 0x4000);memset(erasectr_usn, 0xff, 32);user_usn = 0;meta_usn = 0xffffffff;for (i = 0; i < ftl_nand_type->userblocks + 0x17; i++){uint32_t ret = ftl_vfl_read((i + 1) * ppb - 1, 0, &ftl_sparebuffer[0], 1, 0);if ((ret & 0x11F) == 0 && ftl_sparebuffer[0].meta.type == 0x41){uint32_t lbn = ftl_sparebuffer[0].user.lpn / ppb;if (ftl_sparebuffer[0].user.usn > user_usn)user_usn = ftl_sparebuffer[0].user.usn;if (ftl_sparebuffer[0].user.usn > blk_usn[lbn]){if (ftl_map[lbn] != 0xffff)blk_type[ftl_map[lbn]] = 5;blk_usn[lbn] = ftl_sparebuffer[0].user.usn;ftl_map[lbn] = i;blk_type[i] = 1;}else blk_type[i] = 5;}elsefor (j = 0; j < ppb; j++){ret = ftl_vfl_read(i * ppb + j, 0, &ftl_sparebuffer[0], 1, 0);if (ret & 2) break;if (ret & 0x11F){blk_type[i] = 4;continue;}if (ftl_sparebuffer[0].meta.type == 0x40){blk_type[i] = 2;break;}else if (ftl_sparebuffer[0].meta.type - 0x43 <= 4){blk_type[i] = 3;if (ftl_sparebuffer[0].meta.type == 0x46){uint32_t idx = ftl_sparebuffer[0].meta.idx;if (ftl_sparebuffer[0].meta.usn < meta_usn)meta_usn = ftl_sparebuffer[0].meta.usn;if (ftl_sparebuffer[0].meta.usn < erasectr_usn[idx]){erasectr_usn[idx] = ftl_sparebuffer[0].meta.usn;ret = ftl_vfl_read(i * ppb + j, &ftl_erasectr[idx << 10],&ftl_sparebuffer[0], 1, 0);if (ret & 0x11f) memset(&ftl_erasectr[idx << 10], 0, 0x800);}}}else{cprintf(CONSOLE_BOOT, "Invalid block type %02X while reading vPage %d\n",ftl_sparebuffer[0].meta.type, i * ppb + j);return 1;}}#ifdef HAVE_LCDprogressbar_setpos(&progressbar, i + 1, false);#endif}uint32_t sum = 0;uint32_t count = 0;for (i = 0; i < 0x2000; i++)if (ftl_erasectr[i]){sum += ftl_erasectr[i];count++;}uint32_t average = sum / count;for (i = 0; i < 0x2000; i++)if (!ftl_erasectr[i])ftl_erasectr[i] = average;cputs(CONSOLE_BOOT, "Committing scattered pages...\n");count = 0;for (i = 0; i < ftl_nand_type->userblocks + 0x17; i++)if (blk_type[i] == 2) count++;uint32_t block;uint32_t dirty;if (count){#ifdef HAVE_LCDlcdconsole_progressbar(&progressbar, 0, count * ppb * 2);#endifcount = 0;for (i = 0; i < ftl_nand_type->userblocks + 0x17; i++)if (blk_type[i] == 2){block = 0xffff;for (j = 0; j < ppb; j++){#ifdef HAVE_LCDprogressbar_setpos(&progressbar, count * ppb * 2 + j, false);#endifuint32_t ret = ftl_vfl_read(i * ppb + j, ftl_buffer,&ftl_sparebuffer[0], 1, 0);if (ret & 0x11F) continue;if (ftl_sparebuffer[0].user.type != 0x40){cprintf(CONSOLE_BOOT, "Invalid block type %02X while reading ""vPage %d (scattered page)!\n",ftl_sparebuffer[0].meta.type, i * ppb + j);return 1;}if (block == 0xffff){block = ftl_sparebuffer[0].user.lpn / ppb;memset(pageusn, 0x00, 0x800);memset(pagedata, 0x00, 0x100000);if (ftl_map[block] != 0xffff)for (k = 0; k < ppb; k++){uint32_t ret = ftl_vfl_read(ftl_map[block] * ppb + k, pagedata[k],&ftl_copyspare[0], 1, 0);if (ret & 0x11F) continue;if (ftl_copyspare[0].user.type != 0x40&& ftl_copyspare[0].user.type != 0x41){cprintf(CONSOLE_BOOT, "Invalid block type %02X while reading ""vPage %d (scattered page orig)!\n",ftl_sparebuffer[0].meta.type,ftl_map[block] * ppb + k);return 1;}if (block != ftl_copyspare[0].user.lpn / ppb){cprintf(CONSOLE_BOOT, "Foreign page in scattered page orig ""block (vPage %d, LPN %d)!\n",ftl_map[block] * ppb + k,ftl_sparebuffer[0].user.usn);return 1;}pageusn[k] = ftl_copyspare[0].user.usn;}dirty = 0;}if (block != ftl_sparebuffer[0].user.lpn / ppb){cprintf(CONSOLE_BOOT, "Foreign page in scattered page block ""block (vPage %d, LPN %d)!\n",i * ppb + j, ftl_sparebuffer[0].user.lpn);return 1;}uint32_t idx = ftl_sparebuffer[0].user.lpn % ppb;if (ftl_sparebuffer[0].user.usn > user_usn)user_usn = ftl_sparebuffer[0].user.usn;if (ftl_sparebuffer[0].user.usn > pageusn[idx]){pageusn[idx] = ftl_sparebuffer[0].user.usn;memcpy(pagedata[idx], ftl_buffer, 0x800);dirty = 1;}}if (dirty){if (ftl_erase_block(i)){cprintf(CONSOLE_BOOT, "Couldn't erase vBlock %d ""(scattered page commit)!\n", i);return 1;}for (j = 0; j < ppb; j++){#ifdef HAVE_LCDprogressbar_setpos(&progressbar, count * ppb * 2 + ppb + j, false);#endifmemset(&ftl_sparebuffer[0], 0xFF, 0x40);ftl_sparebuffer[0].user.lpn = block * ppb + j;ftl_sparebuffer[0].user.usn = pageusn[j];ftl_sparebuffer[0].user.type = 0x40;if (j == ppb - 1) ftl_sparebuffer[0].user.type = 0x41;if (ftl_vfl_write(i * ppb + j, 1, pagedata[j], &ftl_sparebuffer[0])){cprintf(CONSOLE_BOOT, "Couldn't write vPage %d ""(scattered page commit)!\n", i * ppb + j);return 1;}}if (ftl_map[block] != 0xffff) blk_type[ftl_map[block]] = 5;blk_type[i] = 1;ftl_map[block] = i;}else blk_type[i] = 5;#ifdef HAVE_LCDprogressbar_setpos(&progressbar, ++count * ppb * 2, false);#endif}}cputs(CONSOLE_BOOT, "Fixing block map...\n");allocmode = 0;firstfree = 0;for (i = 0; i < 3; i++) ftl_cxt.ftlctrlblocks[i] = ftl_alloc_block();for (i = 0; i < 20; i++) ftl_cxt.blockpool[i] = ftl_alloc_block();for (i = 0; i < ftl_nand_type->userblocks; i++)if (ftl_map[i] == 0xffff)ftl_map[i] = ftl_alloc_block();ftl_cxt.usn = meta_usn - 1;ftl_cxt.nextblockusn = user_usn + 1;ftl_cxt.freecount = 20;ftl_cxt.clean_flag = 1;cputs(CONSOLE_BOOT, "Committing FTL context...\n");uint32_t blockmappages = ftl_nand_type->userblocks >> 10;if ((ftl_nand_type->userblocks & 0x1FF) != 0) blockmappages++;uint32_t erasectrpages = (ftl_nand_type->userblocks + 23) >> 10;if (((ftl_nand_type->userblocks + 23) & 0x1FF) != 0) erasectrpages++;uint32_t page = ftl_cxt.ftlctrlblocks[0] * ppb;for (i = 0; i < erasectrpages; i++){memset(&ftl_sparebuffer, 0xFF, 0x40);ftl_sparebuffer[0].meta.usn = ftl_cxt.usn;ftl_sparebuffer[0].meta.idx = i;ftl_sparebuffer[0].meta.type = 0x46;if (ftl_vfl_write(page, 1, &ftl_erasectr[i << 10], &ftl_sparebuffer[0])){cprintf(CONSOLE_BOOT, "Couldn't write vPage %d (save erase counters)!\n", page);return 1;}ftl_cxt.ftl_erasectr_pages[i] = page++;}for (i = 0; i < blockmappages; i++){memset(&ftl_sparebuffer[0], 0xFF, 0x40);ftl_sparebuffer[0].meta.usn = ftl_cxt.usn;ftl_sparebuffer[0].meta.idx = i;ftl_sparebuffer[0].meta.type = 0x44;if (ftl_vfl_write(page, 1, &ftl_map[i << 10], &ftl_sparebuffer[0])){cprintf(CONSOLE_BOOT, "Couldn't write vPage %d (save block map)!\n", page);return 1;}ftl_cxt.ftl_map_pages[i] = page++;}ftl_cxt.ftlctrlpage = page;memset(&ftl_sparebuffer[0], 0xFF, 0x40);ftl_sparebuffer[0].meta.usn = ftl_cxt.usn;ftl_sparebuffer[0].meta.type = 0x43;if (ftl_vfl_write(page, 1, &ftl_cxt, &ftl_sparebuffer[0])){cprintf(CONSOLE_BOOT, "Couldn't write vPage %d (save FTL context)!\n", page);return 1;}ftl_store_ctrl_block_list();return 0;}/* Initializes and mounts the FTL.As long as nothing was written, you won't need to unmount it.Before shutting down after writing something, call ftl_sync(),which will return immediately if everything was already clean. */uint32_t ftl_init(void){mutex_init(&ftl_mtx);uint32_t i;uint32_t result = 0;uint32_t foundsignature, founddevinfo, blockwiped, repaired, skip;int rc;if ((rc = nand_device_init()) != 0) //return 1;panicf(PANIC_FATAL, "FTL: Lowlevel NAND driver init failed: %d", rc);ftl_banks = 0;for (i = 0; i < 4; i++)if (nand_get_device_type(i) != 0) ftl_banks = i + 1;ftl_nand_type = nand_get_device_type(0);foundsignature = 0;blockwiped = 1;for (i = 0; i < ftl_nand_type->pagesperblock; i++){result = nand_read_page(0, i, ftl_buffer, (uint32_t*)0, 1, 1);if ((result & 0x11F) == 0){blockwiped = 0;if (((uint32_t*)ftl_buffer)[0] != 0x41303034) continue;foundsignature = 1;break;}else if ((result & 2) != 2) blockwiped = 0;}founddevinfo = ftl_has_devinfo();repaired = 0;skip = 0;if (founddevinfo == 0){DEBUGF("FTL: No DEVICEINFO found!");return 1;}if (foundsignature != 0 && (result & 0x11F) != 0){DEBUGF("FTL: Problem with the signature!");return 1;}if (ftl_vfl_open() == 0){if (ftl_open() == 0){ftl_initialized = true;return 0;}cprintf(CONSOLE_BOOT, "The FTL seems to be damaged. Forcing check.\n");if (ftl_repair() != 0)cprintf(CONSOLE_BOOT, "FTL recovery failed. Use disk mode to recover.\n");else{cprintf(CONSOLE_BOOT, "FTL recovery finished. Trying to mount again...\n");if (ftl_open() == 0){cprintf(CONSOLE_BOOT, "Mount succeeded.\n");ftl_initialized = true;return 0;}cprintf(CONSOLE_BOOT, "Mounting FTL failed again, use disk mode to recover.\n");}}DEBUGF("FTL: Initialization failed!");return 1;}