|
|
/*
* $Log: V:/Flite/archives/TrueFFS5/Src/inftl.c_V $ * * Rev 1.40 Apr 15 2002 20:14:40 oris * Changed the use of SecondUnitStructure for INFTLTEST utility. * * Rev 1.39 Apr 15 2002 08:39:32 oris * Placed quick mount under if def of CHECK_MOUNT for INFTLTST. * * Rev 1.38 Apr 15 2002 07:37:20 oris * Improved power failure resistant: * - setUnavail macro was changed for improved code readability. * - MarkSectorAsChecking macro was changed to MarkSectorAsChecked * - Bug fix - getSectorFlags - in case invalid sector flags are found do not forget to reset TL buffer to ff's and mark it as remapped. * - Added support for VERIFY_ERASED_SECTOR compilation flag - make sure a sector is free before writing it - most of the code * is found in writeAndCheck routine. * - Added MAKE_SURE_IGNORE_HAS_BAD_EDC compilation flag - make sure that the sector is really marked * as ignored. If not mark the entire sector as 0. * - Initialize a addition 1k buffer for the TL - used for verify erase. * - Bug fix - verifySector routine had several bugs. * - Bug fix - foldUnit routine bad comparison in FL_OFF mode. * - Bug fix - foldBestChain routine missing update of sector count after folding failed and bad search for free unit. * - Bug fix - mountUnit routine had bad handling for corrupted unit header. * Added support for RAM based MTD power failure tests. * Remove cache allocation checks - They are not needed since the cache routine itself check for proper allocation. * Bug fix - prevent initialization of flash record in case flash is NULL. * Bug fix - defragment routine used to call allocateUnit instead of foldBestChain. * Bug fix - bad debug print when format routine none INFTL media. * Bug fix - missing several dismount in INFTL format. * Bug fix - format routine could not place protection onto binary partition containing only the bios driver. * Changed format debug massages. * * Rev 1.37 Feb 19 2002 21:00:22 oris * Fixed FL_READ_ONLY compilation problems. * Replaced TL_LEAVE_BINARY_AREA with FL_LEAVE_BINARY_AREA * Improved protection against power failures: * - formatUnit/getUnitTailer and setUnitTailer - Added argument to support temporary units (unit with erase mark on an invalid offset so that if not fixed before next mount they will be considered as free). * - foldUnit - Removed setUnavailable (not called only from foldBestChain) and added code to restore temporary unit into permanent ones(mark erase mark in proper place). * - foldBestChain - added folding not in place and several bug fixes. * - AllocatUnit - Change sequence to be more robust. * - checkFolding/applyWearLeveling - Bug fix - read newest unit in chain after allocate call it might change as part of the allocate process. * - deleteSector - check status of write operation. * - mountInftl - perforce space reclamation only if no free units. * * Rev 1.36 Jan 29 2002 20:09:28 oris * Removed warnings. * Buf fix - chainging protection attributes of a DiskOnChip with more then a single floor. * Bug fix - if an invalid sector flag is found in getSectorFlags routine and read operation failed, SECTOR_IGNORED should have been returned. * * Rev 1.35 Jan 28 2002 21:25:46 oris * Bug fix - discard mark write operation had bad casting causing the * mark to be written to much lower addresses. * Changed discard variable to static const. * allocateAndWriteSectors - improved going along chain algorithm to scan * chain only once. * * Rev 1.34 Jan 23 2002 23:33:20 oris * Removed CHECK_DISCARD compilation flag. * Bug fix - bad casting caused discard mark to be written to a different unit then was expected in formatUnit(). * Changed discardQuickMountInfo to mark quick mount area as discarded instead of erasing it. * Improved markAsIgnored routine. * Bug fix - Problems with insert and remove key routines. * Bug fix - write BBT for INFTL formatted DiskOnChip was not supported. * Changed DFORMAT_PRINT syntax * * Rev 1.33 Jan 21 2002 20:44:56 oris * Bug fix - Erase of quick mount information does not take block multiplication into account. * * Rev 1.32 Jan 20 2002 20:28:48 oris * Removed warnings * Changed putGetBuffer to handle FAR pointers (prototype and pointers arithmetic's). * Quick mount is now saved if either of the following occurs * - Last mount did not use quick mount information. * - A write operation was made in this mount * Bug in quickMount units size calculation (affected large DiskOnChips). * * Rev 1.31 Jan 20 2002 10:49:52 oris * Added initialization of Bnand record in mount and format. * Removed badFormat field from Bnand record. * Improoved last sector cache mechanism * Removed support for PPP=3 interleave-2 * Changed FL_MALLOC allocation calls to FL_FAR_MALLOC and changed RAM tables pointers to FAR1. * Split preMount routine into protection routine and other premount routins. * Added DOUBLE_MAX_UNIT_CHAIN instead of MAX_UNIT_CHAIN*2 * Added protection agains power failures. * - Added several modes of verify write : * - FL_UPS no protection * - FL_ON verify each and every write operation * - FL_OFF full protection with minmal performance penalty. * - Added verifyVolume API to scan the media for slower mount, but with not further performance penalty. * - default after mount is FL_OFF * - Added folding not in place. * - Added verification of last sector of the chains (in folding). * - Added discard mark before erasing. * - Changed sector flags and unit data retrival error correction logic. * - Limit foldBestChain folding tryies. * - Improoved mount logic for choosing between invalid chains. * Quick mount mechanism * - Forced quick mount as default * - Delete previous data only after first write operation. * - Remove previous quick mount info with an erase operation. * - Added remove previous quick mount info API (In preMount). * Imprroved error report mechanizm of brocken chains (should never happen): * - error on read return unused area of flash * - error on write report flGeneralFailure * - error on mount fix chains. If error on a chain that was already validated , report flGeneralFailure * Format routine * - Force quick mount (ignoring user flag) * - Bug fix - format with leave binary partition of a protected binary partition. * - Removed single floor support. * * Rev 1.30 Nov 21 2001 11:38:26 oris * Changed FL_MARK_DELETE to FL_ON. * Changed FL_WITH_VERIFY_WRITE and FL_WITHOUT_VERIFY_WRITE to FL_ON and FL_OFF. * * Rev 1.29 Nov 16 2001 00:22:22 oris * Reorganized - removed function declaration, moved debug routines to a * separated file. * Bug fix - VERIFY_WRITE logic - marking unit as unavailable was done on the * virtual unit and not the last physical unit plus the least sector count and * max chain length , where not reinitialized in foldBestChange. The result * might cause infinite loop in foldbestchain if foldUnit fails. * Bug fix - Support for DiskOnChip with last floors having less chips. * Improved progress callback routine to show current unit starting from 1 and not 0 and to indicate bad and unavailable blocks as well. * Bug fix - all routines that changed protection attributes might not use * Bug fix - formatting with LEAVE_BINARY_PARTITION when binary partition is * exactly the floor size (virtual size). and improved it for bootAreaLen not * 0 and not -1 (leave only part of the previous binary partition). * Quick mount feature - Made sure the mount operation changes quick_mount * validity even if QUICK_MOUNT_FEATURE is commented. * Support 2 unchangeable protected partitions (not only 1). * Added discard mark before erase and placed this option under ifdef (default off). * Changed isValidUnitFlags to check all fields (isValidParityResult) not just * PUN and VUN. * getUnitData - bug in the logic of using second unit data structure. * No need to reread the unit data if verify write is activated after setUnitData. * Added check in virtual2physical to make sure this the unit found is valid. * initINFTLbasic - Use dword variable to calculate blocks per unit (support 64k blocks). * Change block multiplication from MORE then 32K units (not equal) * Improved support for read only mode including mount - FL_READ_ONLY * Add runtime option of VERIFY_WRITE * Bug fix - Binary partition in the first floor used only 1001 units while in * other floors 1002 units. * * Rev 1.28 Oct 11 2001 23:54:58 oris * Bug fix - When changing protection attribute of a BDTL partition (change * key, change lock , change protection type) on a DiskOnChip with more then * a single floor, an error massage might be returned since changing * protection attributes uses the same buffer as the structure holding the * protection area to work on. * * Rev 1.27 Sep 24 2001 18:23:50 oris * Bug fix - missing break in foldBestChain - very rare case. * Removed warnings. * * Rev 1.26 Sep 16 2001 21:47:54 oris * Placed intergrity check of sector in the last unit of the virtual unit under * VERIFY_WRITE compilation flag. * Bug fix - missing big-endian conversion when using static memory allocation. * * Rev 1.25 Sep 15 2001 23:46:54 oris * Removed redundant isAvailable checks. * Make sure mount operation does not reconstruct BBT. * Bug fix - folding in wear leveling does not change NAC to 1. * Bug fix - Bad casting caused bad protection type to be returned under BIG_ENDIAN. * Changed change protection attributes routine applied on protected partition * from flWrongKey to flHWProtection. * Improved algorithm reliability with VERIFY_WRITE. Following are the changes in the algorithm: * 1) virtual2Physical - * a) added flag stating if the specific sector is not free in the last unit of the chain. * 2) foldUnit - * a) if can not copy sector to the last unit of the chain, mark unit as * unavailable and return error code. * b) If verify write is enabled check even sectors that re marked as used and * are found on the last unit of the chain. * 3) foldBestChain - * a) Ignore unavailable units * b) If folding failed start looking from the beginning (it will be marked as * unavailable by the foldunit routine). * c) when done make all unit available. * 4) Added checkFolding routine - after folding check if succeeded. If not * loop up to MAX_FOLDING_LOOP each time free a unit with foldbestchain, * append a unit to the problematic chain and try to fold it. * 5) allocateUnit - Now when there are less then 2 unit reclaim space. This is * to minimize the chance of folding within a fold operation. * 6) MountINFTL - Make sure there are at least 2 free units. * * Rev 1.24 Jul 29 2001 16:10:00 oris * eraseOrphanUnit bug was fixed ( we did not add vol.firstUnit to the unitNo). * * Rev 1.23 Jul 15 2001 20:45:12 oris * Improoved documentation. * Changed unitBaseAddress function to a macro. * Removed unneccesary if statments in applyWearLeveling(). * * Rev 1.22 Jul 13 2001 01:06:14 oris * Changed multiBufferCounter to signed allowing a better buffer management. * Changed consequtiveNumbers routine into a macro. * Reorganized the DEBUG chains routines. * Bug fix - H/W read protected partition did not report as such. * Changed swapUnits routine name to applyWearleveling. * Added basics for last sector return mechanism - * foldUnit receives an additional field. * read2Sectors returns edc error sector address and actually read sector address * Added several static prefixes for static routines. * Added edc check for media header read operation. * Bug fix - parturition size smaller then a unit was acceptable. * Added default protection for unused DPSes. * Bug fix - formatINFTL with leave binary partition flag when previous binary * partition was larger then a single floor. * Improved mount documentation. * Changed policy - do not erase unit with bad erase mark. * * Rev 1.21 Jun 17 2001 08:20:06 oris * Added NO_READ_BBT_CODE compilation flag to reduce code size. * Improoved Reliability: * 1) Try to return next sector in chain if the current one has EDC error * 2) Mount routine erases all blocks not marked with the erase mark. * * Affected routines: * 1) virtual2Physical can recive the physical address to start looking for and * not the last virtual unit of the chain. * 2) copySector ,foldUnit, mapSector, read2sectors- if EDC error accures * return try returning the next sector. * 3) foldUnit - if EDC error accures return try returning the next sector. * 4) writeMultiSecotr - improove ppp = 3 * 5) mountINFTL - erase all units not marked with the erase mark. * * Rev 1.21 Jun 17 2001 08:18:02 oris * Changed recusive include define to INFTL_H. * Added FL_BAD_ERASE_MARK definition for units without the erase mark on * mount operation. * * For the rest of the revisions see revision 1.24 in the PVCS. */
/***********************************************************************************//* M-Systems Confidential *//* Copyright (C) M-Systems Flash Disk Pioneers Ltd. 1995-2001 *//* All Rights Reserved *//***********************************************************************************//* NOTICE OF M-SYSTEMS OEM *//* SOFTWARE LICENSE AGREEMENT *//* *//* THE USE OF THIS SOFTWARE IS GOVERNED BY A SEPARATE LICENSE *//* AGREEMENT BETWEEN THE OEM AND M-SYSTEMS. REFER TO THAT AGREEMENT *//* FOR THE SPECIFIC TERMS AND CONDITIONS OF USE, *//* OR CONTACT M-SYSTEMS FOR LICENSE ASSISTANCE: *//* E-MAIL = [email protected] *//***********************************************************************************/
/*************************************************//* T r u e F F S 5.0 S o u r c e F i l e s *//* --------------------------------------------- *//*************************************************/
/*****************************************************************************
* File Header ** ----------- ** Name : inftl.c ** ** Description : Implementation of INFTL flash translation layer. ** ******************************************************************************/
/* Internal compilation flags */
/* #define CHAINS_DEBUG */ /* Prints unit chains after mount routine *//* #define CHECK_MOUNT */ /* Print serious tl debug warnings to */ /* tl_out global file handle *//* #define MAKE_SURE_IGNORE_HAS_BAD_EDC */ /* Make sure the ignore mark was */ /* written. If not fill sector */ /* with 0's. *//* List of included files */
#include "inftl.h"
/* Private variables */
static Bnand vols[VOLUMES];#ifndef FL_MALLOC
#ifdef NFTL_CACHE
static ucacheEntry socketUcache[SOCKETS][U_CACHE_SIZE];static byte socketScache[SOCKETS][S_CACHE_SIZE];#endif /* NFTL_CACHE */
static Sbyte socketHeap[SOCKETS][ANAND_HEAP_SIZE];static byte multiSectorBuf[SOCKETS][SECTOR_SIZE<<1];#else
static byte *multiSectorBuf[SOCKETS];static Sbyte multiSectorBufCounter[SOCKETS];#endif /* FL_MALLOC */
#ifdef NFTL_CACHE
/* translation table for Sector Flags cache */static byte scacheTable[4] = { SECTOR_DELETED, /* 0 */ SECTOR_IGNORE, /* 1 */ SECTOR_USED, /* 2 */ SECTOR_FREE }; /* 3 */#endif /* NFTL_CACHE */
/* Macros */#define roundToUnits(var) ((var > 0) ? ((ANANDUnitNo)((var - 1) >> vol.unitSizeBits) + 1) : 0)
#define NextGoodUnit(addr,bbt) for(;bbt[(addr >> vol.unitSizeBits) - vol.firstQuickMountUnit]!=ANAND_UNIT_FREE;addr+=1L<<vol.unitSizeBits)
#define countOf(unitNo) (vol.physicalUnits[unitNo] & UNIT_COUNT)
#define isAvailable(unitNo) ((vol.physicalUnits[unitNo] == ANAND_UNIT_FREE) || (countOf(unitNo) <= UNIT_MAX_COUNT))
#define setUnavail(unitNo) (vol.physicalUnits[unitNo] = UNIT_UNAVAIL)
#define setUnitCount(unitNo,unitCount) { vol.physicalUnits[unitNo] &= ~UNIT_COUNT; vol.physicalUnits[unitNo] |= (ANANDPhysUnit)unitCount; }
#define isLegalUnit(unitNo) ((unitNo < vol.noOfUnits) || (unitNo == ANAND_NO_UNIT))
#define isValidSectorFlag(sectorFlag) ((sectorFlag==SECTOR_FREE)||(sectorFlag==SECTOR_USED)||(sectorFlag==SECTOR_DELETED))
#define badParityResult(parityResult) (parityResult != ALL_PARITY_BITS_OK)
#define consecutiveNumbers(first,second) ((byte)(second+1)==first)
#define unitBaseAddress(vol,unitNo) ((CardAddress)((ANANDUnitNo)unitNo+(ANANDUnitNo)vol.firstUnit) << vol.unitSizeBits)
#define distanceOf(read, expected) (onesCount((byte)(read ^ expected)))
#define MarkSectorAsChecked(addr) (scannedBlocks[((addr)>>SECTOR_SIZE_BITS) & vol.sectorsPerUnitMask] = TRUE)
#define WasSectorChecked(addr) scannedBlocks[((addr)>>SECTOR_SIZE_BITS) & vol.sectorsPerUnitMask]
/* M-Systems INFTL debug routines */#ifndef CHECK_MOUNT
#define TL_DEBUG_PRINT(x,y,z)
#define SET_EXIT(x)
#define DID_MOUNT_FAIL 1
#endif /* CHECK_MOUNT */
#if (defined(CHECK_MOUNT) || defined (CHAINS_DEBUG))
#include "inftldbg.c"
#endif /* CHECK_MOUNT || CHAINS_DEBUG */
/*------------------------------------------------------*//* o n e s C o u n t *//* *//* counts number of bits that valued 1 in a given byte *//*------------------------------------------------------*/
static byte onesCount(byte flag){ byte counter;
for (counter = 0; flag; flag >>= 1) if (flag & 1) counter++;
return counter;}
/*----------------------------------------------------------------------*//* g e t U n i t T a i l e r *//* *//* Get the erase record of a unit. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Physical unit number *//* eraseMark : Receives the erase mark of the unit *//* eraseCount : Receives the erase count of the unit *//* offset : offset in unit *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//* *//*----------------------------------------------------------------------*/
static FLStatus getUnitTailer(Bnand vol, ANANDUnitNo unitNo, word *eraseMark, dword *eraseCount, dword offset){ UnitTailer unitTailer; FLStatus status;
status = vol.flash->read(vol.flash, unitBaseAddress(vol,unitNo) + offset, &unitTailer, sizeof(UnitTailer), EXTRA);
/* Mask out any 1 -> 0 bit faults by or'ing with spare data */ *eraseMark = (word)(LE2(unitTailer.eraseMark) | LE2(unitTailer.eraseMark1)); *eraseCount = LE4(unitTailer.eraseCount); return status;}
#ifndef FL_READ_ONLY
/*----------------------------------------------------------------------*//* s e t U n i t T a i l e r *//* *//* Set the erase record of a unit. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Physical unit number *//* eraseMark : Erase mark to set *//* eraseCount : Erase count to set *//* offset : offset in unit *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//* *//*----------------------------------------------------------------------*/
static FLStatus setUnitTailer(Bnand vol, ANANDUnitNo unitNo, word eraseMark, dword eraseCount, dword offset){ UnitTailer unitTailer;
toLE2(unitTailer.eraseMark,eraseMark); toLE2(unitTailer.eraseMark1,eraseMark); toLE4(unitTailer.eraseCount,eraseCount);
return vol.flash->write(vol.flash, unitBaseAddress(vol,unitNo) + offset, &unitTailer, sizeof(UnitTailer), EXTRA);}
/*----------------------------------------------------------------------*//* m a r k U n i t B a d *//* *//* Mark a unit as bad in the conversion table and the bad units table. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Physical number of bad unit *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus markUnitBad(Bnand vol, ANANDUnitNo unitNo){ word eraseMark; dword eraseCount; FLStatus status;
vol.physicalUnits[unitNo] = UNIT_BAD; if(vol.freeUnits) vol.freeUnits--;
status = getUnitTailer(&vol,unitNo,&eraseMark,&eraseCount,UNIT_TAILER_OFFSET); if (status == flOK) status = setUnitTailer(&vol,unitNo,FL_BAD_ERASE_MARK,eraseCount,UNIT_TAILER_OFFSET);
#ifdef NFTL_CACHE
if (vol.ucache != NULL) /* Mark unit cache as unavaialbel */ { vol.ucache[unitNo].virtualUnitNo = 0xDEAD; vol.ucache[unitNo].prevUnitNo = 0xDEAD; }#endif /* NFTL_CACHE */
return status;}
/*----------------------------------------------------------------------*//* f o r m a t U n i t *//* *//* Format one unit. Erase the unit, and mark the physical units table. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Physical unit to format *//* eraseMarkOffset : Offset to place erase mark *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus formatUnit(Bnand vol, ANANDUnitNo unitNo, dword eraseMarkOffset){ word eraseMark; dword eraseCount; FLStatus status;#ifndef RAM_MTD
static const#endif /* RAM_MTD */
byte discard = (byte)CLEAR_DISCARD;
status = getUnitTailer(&vol,unitNo,&eraseMark,&eraseCount,UNIT_TAILER_OFFSET); if(status != flOK) return status;
#ifdef NFTL_CACHE
/* Update ANANDUnitHeader cache to prevent re-filling from flash */ if (vol.ucache != NULL) { vol.ucache[unitNo].virtualUnitNo = ANAND_NO_UNIT; vol.ucache[unitNo].prevUnitNo = ANAND_NO_UNIT; vol.ucache[unitNo].ANAC = ANAND_UNIT_FREE; vol.ucache[unitNo].NAC = ANAND_UNIT_FREE; }
/*
* Purge the Sector Flags cache (set entries for all the unit's * sectors to SECTOR_FREE). */
if(vol.scache!=NULL) { tffsset(&(vol.scache[unitNo << (vol.unitSizeBits - SECTOR_SIZE_BITS-2)]), S_CACHE_4_SECTORS_FREE, 1 << (vol.unitSizeBits - SECTOR_SIZE_BITS - 2)); }#endif /* NFTL_CACHE */
/* Mark unit as unusable before erase */ vol.flash->write(vol.flash,(((dword)(vol.firstUnit + unitNo))<<vol.unitSizeBits)+DISCARD_UNIT_OFFSET,&discard,1,EXTRA);
/* Physicaly erase unit */ status = vol.flash->erase(vol.flash,(word)((word)(vol.firstUnit + unitNo) << vol.blockMultiplierBits),(word)(1 << vol.blockMultiplierBits));
vol.eraseSum++; eraseCount++; if (eraseCount == 0) /* was hex FF's */ eraseCount++;
if (status == flOK) status = setUnitTailer(&vol,unitNo,ERASE_MARK,eraseCount,eraseMarkOffset);
if (status != flOK) { markUnitBad(&vol,unitNo); /* make sure unit format is not valid */ return status; }
if (vol.physicalUnits[unitNo] != ANAND_UNIT_FREE) { vol.physicalUnits[unitNo] = ANAND_UNIT_FREE; vol.freeUnits++; }
return status;}
#endif /* FL_READ_ONLY */
/*----------------------------------------------------------------------*//* g e t U n i t D a t a *//* *//* Get virtual unit No. and replacement unit no. of a unit. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Physical unit number *//* virtualUnitNo : Returns the virtual unit no. *//* prevUnitNo : Returns the previous unit no. *//* ANAC : Returns the Accumulating Number Along Chain. *//* NAC : Returns the Number Along Chain value. *//* validFields : Returns a bit map of the valid fields. *//* *//* Returns: *//* flOK on success, flHWProtection on H/W read protection. *//*----------------------------------------------------------------------*/
static FLStatus getUnitData(Bnand vol, ANANDUnitNo unitNo, ANANDUnitNo *virtualUnitNo, ANANDUnitNo *prevUnitNo, byte *ANAC, byte *NAC, byte *validFields){ ANANDUnitHeader unitData; SecondANANDUnitHeader secondUnitData; FLStatus status; byte parityPerField=0; byte temp; byte returnedValidField = ALL_PARITY_BITS_OK; byte curValidFields[2]; int index;
#ifdef NFTL_CACHE
/* on cache miss read ANANDUnitHeader from flash and re-fill cache */ if ((vol.ucache != NULL)&&(vol.ucache[unitNo].virtualUnitNo != 0xDEAD) && (vol.ucache[unitNo].prevUnitNo != 0xDEAD)) { *virtualUnitNo = vol.ucache[unitNo].virtualUnitNo; *prevUnitNo = vol.ucache[unitNo].prevUnitNo; *ANAC = vol.ucache[unitNo].ANAC; *NAC = vol.ucache[unitNo].NAC; } else#endif /* NFTL_CACHE */
{ /* no ANANDUnitHeader cache MUST read first header */
*validFields = 0; /* Set all fields to be invalid */
/* Read first unit data */ status = vol.flash->read(vol.flash, unitBaseAddress(vol,unitNo) + UNIT_DATA_OFFSET, &unitData, sizeof(ANANDUnitHeader), EXTRA); if(status != flOK) return status;
*virtualUnitNo = LE2(unitData.virtualUnitNo); *prevUnitNo = LE2(unitData.prevUnitNo ); *ANAC = unitData.ANAC; *NAC = unitData.NAC;
for(index=0;index<2;index++) { /* If all data is 0xff assume a free unit */ if((*virtualUnitNo == ANAND_NO_UNIT )&& (*prevUnitNo == ANAND_NO_UNIT )&& (*ANAC == ANAND_UNIT_FREE)&& (*NAC == ANAND_UNIT_FREE)&& (unitData.discarded == ANAND_UNIT_FREE)) {#ifndef FL_READ_ONLY
if(index!=0) { /* If this is the second copy then the first was not */ /* erased, but since it was written first it makes no */ /* sence. Let us erase it just in case. */
status = formatUnit(&vol,unitNo,UNIT_TAILER_OFFSET); if(status != flOK) return status; }#endif /* FL_READ_ONLY */
break; }
/* Not a free unit check unit data validity (discard and partity) */ if ((onesCount((byte)(unitData.discarded^DISCARD))>1)) { /* Discarded mark is more then 1 bit distance from 0xAA */ /* Assume erase operation was interrupted and erase unit */
TL_DEBUG_PRINT(tl_out,"getUnitData : unit %d has an invalid discard mark\n",unitNo); TL_DEBUG_PRINT(tl_out," it might be helpful to know it was %d\n",unitData.discarded);
#ifndef FL_READ_ONLY
status = formatUnit(&vol,unitNo,UNIT_TAILER_OFFSET); if(status != flOK) return status;#endif /* FL_READ_ONLY */
*virtualUnitNo = ANAND_NO_UNIT; *prevUnitNo = ANAND_NO_UNIT; *ANAC = ANAND_UNIT_FREE; *NAC = ANAND_UNIT_FREE; break; }
/* Discarded OK now check parity field */ parityPerField = 0; temp=(byte)(((byte *)virtualUnitNo)[0]^((byte *)virtualUnitNo)[1]); if((onesCount(temp) & 1)==1) parityPerField|=VU_PARITY_BIT; temp=(byte)(((byte *)prevUnitNo)[0]^((byte *)prevUnitNo)[1]); if((onesCount(temp) & 1)==1) parityPerField|=PU_PARITY_BIT; if((onesCount(unitData.ANAC) & 1)==1) parityPerField|=ANAC_PARITY_BIT; if((onesCount(unitData.NAC) & 1)==1) parityPerField|=NAC_PARITY_BIT;
/* Store valid fields using bitmap */ curValidFields[index] = (byte)((~(parityPerField ^ unitData.parityPerField)) & ALL_PARITY_BITS_OK);
if(curValidFields[index] == ALL_PARITY_BITS_OK) { /* If either copies has valid fields (all of them) use it */ break; } else { if(index>0) { /* Use first header data if possible otherwise use second */ returnedValidField = (byte)(curValidFields[0] | curValidFields[1]); TL_DEBUG_PRINT(tl_out,"getUnitData : The returned valid field indicator is %d\n",returnedValidField); TL_DEBUG_PRINT(tl_out," While %d indicates a valid unit data\n",ALL_PARITY_BITS_OK); if(curValidFields[0] & VU_PARITY_BIT) *virtualUnitNo = LE2(unitData.virtualUnitNo);
if(curValidFields[0] & PU_PARITY_BIT) *prevUnitNo = LE2(unitData.prevUnitNo );
if(curValidFields[0] & ANAC_PARITY_BIT) *ANAC = unitData.ANAC;
if(curValidFields[0] & NAC_PARITY_BIT) *NAC = unitData.ANAC; break; } }
/* Read second unit header for next iteration */ status = vol.flash->read(vol.flash, unitBaseAddress(vol,unitNo) + SECOND_HEADER_OFFSET + UNIT_DATA_OFFSET, &secondUnitData, sizeof(SecondANANDUnitHeader), EXTRA); if(status != flOK) return status;
*virtualUnitNo = LE2(secondUnitData.virtualUnitNo); *prevUnitNo = LE2(secondUnitData.prevUnitNo ); *ANAC = secondUnitData.ANAC; *NAC = secondUnitData.NAC;
TL_DEBUG_PRINT(tl_out,"getUnitData : First unit header is not OK in unit %d \n",unitNo); TL_DEBUG_PRINT(tl_out,"getUnitData : Virtual Unit No = %d \n",LE2(unitData.virtualUnitNo)); TL_DEBUG_PRINT(tl_out,"getUnitData : Previous Unit No = %d \n",LE2(unitData.prevUnitNo)); TL_DEBUG_PRINT(tl_out,"getUnitData : ANAC = %d \n",unitData.ANAC); TL_DEBUG_PRINT(tl_out,"getUnitData : NAC = %d \n",unitData.NAC); TL_DEBUG_PRINT(tl_out,"getUnitData : ParityPerField = %d \n",unitData.parityPerField); TL_DEBUG_PRINT(tl_out,"getUnitData : Discarded = %d \n",unitData.discarded);
TL_DEBUG_PRINT(tl_out,"getUnitData : Second unit header of the same unit %d is:\n",unitNo); TL_DEBUG_PRINT(tl_out,"getUnitData : Virtual Unit No = %d \n",LE2(secondUnitData.virtualUnitNo)); TL_DEBUG_PRINT(tl_out,"getUnitData : Previous Unit No = %d \n",LE2(secondUnitData.prevUnitNo)); TL_DEBUG_PRINT(tl_out,"getUnitData : ANAC = %d \n",secondUnitData.ANAC); TL_DEBUG_PRINT(tl_out,"getUnitData : NAC = %d \n",secondUnitData.NAC); TL_DEBUG_PRINT(tl_out,"getUnitData : ParityPerField = %d \n",secondUnitData.parityPerField); }
#ifdef NFTL_CACHE
if ((vol.ucache != NULL) && /* Cache enabled */ (returnedValidField == ALL_PARITY_BITS_OK)) /* All fields valid */ { vol.ucache[unitNo].virtualUnitNo = *virtualUnitNo; vol.ucache[unitNo].prevUnitNo = *prevUnitNo; vol.ucache[unitNo].ANAC = *ANAC; vol.ucache[unitNo].NAC = *NAC; }#endif /* NFTL_CACHE */
} *validFields = returnedValidField; return flOK;
}
/*----------------------------------------------------------------------*//* g e t P r e v U n i t *//* *//* Get next unit in chain. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Physical unit number *//* virUnitNo : The expected virtual unit number *//* *//* Returns: *//* Physical unit number of the unit following unitNo in the chain. *//* If such unit do not exist, return ANAND_NO_UNIT. *//*----------------------------------------------------------------------*/
static ANANDUnitNo getPrevUnit(Bnand vol, ANANDUnitNo unitNo, ANANDUnitNo virUnitNo){ ANANDUnitNo virtualUnitNo, replacementUnitNo; byte ANAC,NAC; byte parityPerField;
/* If first in chain there can be not previous unit */ if ((vol.physicalUnits[unitNo] & FIRST_IN_CHAIN)) return ANAND_NO_UNIT;
getUnitData(&vol,unitNo,&virtualUnitNo,&replacementUnitNo,&ANAC,&NAC,&parityPerField);
/* check if unit is valid */ if((badParityResult(parityPerField)) || ( virUnitNo != virtualUnitNo )) { TL_DEBUG_PRINT(tl_out,"getPrevUnit : An invalid unit was detected on getPrevUnit - parity is %x/0xf ",parityPerField); TL_DEBUG_PRINT(tl_out,"given virtual unit no is %d ",virUnitNo); TL_DEBUG_PRINT(tl_out,"where %d was read\n",virtualUnitNo); SET_EXIT(INFTL_FAILED_MOUNT); return ANAND_BAD_CHAIN_UNIT; } return replacementUnitNo;}
#ifdef NFTL_CACHE
/*----------------------------------------------------------------------*//* g e t S e c t o r F l a g s F r o m C a c h e *//* *//* Get sector flags from Sector Cache. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* address : starting address of the sector *//* *//* Returns: *//* sector flags (SECTOR_USED, SECTOR_DELETED etc.) *//*----------------------------------------------------------------------*/
static byte getSectorFlagsFromCache(Bnand vol, CardAddress address){ return scacheTable[((vol.scache[(address - vol.firstUnitAddress) >> (SECTOR_SIZE_BITS+2)] >> (((word)address >> 8) & 0x7)) & 0x3)];}
/*----------------------------------------------------------------------*//* s e t S e c t o r F l a g s C a c h e *//* *//* Get sector flags from Sector Cache. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* address : starting address of the sector *//* sectorFlags : one of SECTOR_USED, SECTOR_DELETED etc. *//* *//*----------------------------------------------------------------------*/
static void setSectorFlagsCache(Bnand vol, CardAddress address, byte sectorFlags){ register byte tmp, val;
if (vol.scache == NULL) return;
tmp = vol.scache[(address - vol.firstUnitAddress) >> (SECTOR_SIZE_BITS+2)];
switch(sectorFlags) { case SECTOR_USED: val = S_CACHE_SECTOR_USED; break; case SECTOR_FREE: val = S_CACHE_SECTOR_FREE; break; case SECTOR_DELETED: val = S_CACHE_SECTOR_DELETED; break; default:/* SECTOR_IGNORE */val = S_CACHE_SECTOR_IGNORE; break; }
switch (((word)address >> 8) & 0x7) { case 0: tmp = (tmp & 0xfc) | (val ); break; /* update bits 0..1 */ case 2: tmp = (tmp & 0xf3) | (val << 2); break; /* bits 2..3 */ case 4: tmp = (tmp & 0xcf) | (val << 4); break; /* bits 4..5 */ case 6: tmp = (tmp & 0x3f) | (val << 6); break; /* bits 6..7 */ }
vol.scache[(address - vol.firstUnitAddress) >> (SECTOR_SIZE_BITS+2)] = tmp;}
#endif /* NFTL_CACHE */
/*----------------------------------------------------------------------*//* g e t S e c t o r F l a g s *//* *//* Get sector status. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorAddress : Physical address of the sector *//* *//* Returns: *//* Return the OR of the two bytes in the sector status area (the *//* bytes should contain the same data). *//*----------------------------------------------------------------------*/
static byte getSectorFlags(Bnand vol, CardAddress sectorAddress){ byte flags[2]; byte blockFlag = SECTOR_IGNORE; byte index,tmpSector; FLStatus status;
#ifdef NFTL_CACHE
if (vol.scache != NULL) { /* check for Sector Flags cache hit */
blockFlag = getSectorFlagsFromCache(&vol, sectorAddress); if (blockFlag != SECTOR_IGNORE) return blockFlag; }#endif /* NFTL_CACHE */
vol.flash->read(vol.flash, sectorAddress + SECTOR_DATA_OFFSET, flags, sizeof flags, EXTRA);
if((flags[0] == flags[1]) && (isValidSectorFlag(flags[0]))) { blockFlag = flags[0]; } else /* Sector flags that were read are not legal or not valid */ { TL_DEBUG_PRINT(tl_out,"getSectorFlags : Sector flags are not valid - physical addr %ld ",sectorAddress); TL_DEBUG_PRINT(tl_out,"first flag was %x ",flags[0]); TL_DEBUG_PRINT(tl_out,"while scond is %x\n",flags[1]); SET_EXIT(INFTL_FAILED_MOUNT);
/* Force remapping of internal catched sector */ vol.flash->socket->remapped = TRUE;
/* Check for ignored sector using the EDC */ status = vol.flash->read(vol.flash, sectorAddress, inftlBuffer, SECTOR_SIZE, EDC);#if (defined(VERIFY_WRITE) || defined (VERIFY_VOLUME) || defined(VERIFY_ERASED_SECTOR))
/* Now restore the ff's for the verifySectors routine */ tffsset(inftlBuffer,0xff,SECTOR_SIZE);#endif /* VERIFY_WRITE || VERIFY_VOLUME || VERIFY_ERASED_SECTOR */
if(status == flOK) { /* Check if distance is less then 2 bits failure since */ /* 2 bits failure can be either delete or used */ for (index=0 , tmpSector = (byte)SECTOR_USED ; index < 2 ; index++ , tmpSector = (byte)SECTOR_DELETED) { if (distanceOf(flags[0], tmpSector) + distanceOf(flags[1], tmpSector) <= 2) { blockFlag = tmpSector; break; } } if(index>=2) return SECTOR_IGNORE; } else { return SECTOR_IGNORE; } }
#ifdef NFTL_CACHE
/* update Sector Flags cache */ setSectorFlagsCache(&vol, sectorAddress, blockFlag);#endif /* NFTL_CACHE */
return blockFlag;}
#ifndef FL_READ_ONLY
/*----------------------------------------------------------------------*//* s e t U n i t D a t a *//* *//* Set virtual unit No. and replacement unit no. of a unit. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Physical unit number *//* virtualUnitNo : Virtual unit no. *//* prevUnitNo : Previous unit no. *//* ANAC : Accumulating Number Along Chain *//* NAC : Number Along Chain. *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//* *//*----------------------------------------------------------------------*/
static FLStatus setUnitData(Bnand vol, ANANDUnitNo unitNo, ANANDUnitNo virtualUnitNo, ANANDUnitNo prevUnitNo,byte ANAC,byte NAC){ ANANDUnitHeader unitData; SecondANANDUnitHeader secondUnitData; FLStatus status; ANANDUnitNo newVirtualUnitNo, newPrevUnitNo; byte newANAC,newNAC; byte temp; byte parityPerField = 0;
if( prevUnitNo == unitNo ) /* prevent chain loop */ return flGeneralFailure;
/* Calculate parity per field */ temp=(byte)(((byte *)&virtualUnitNo)[0]^((byte *)&virtualUnitNo)[1]); if((onesCount(temp) & 1)==1) parityPerField|=VU_PARITY_BIT;
temp=(byte)(((byte *)&prevUnitNo)[0]^((byte *)&prevUnitNo)[1]); if((onesCount(temp) & 1)==1) parityPerField|=PU_PARITY_BIT;
if((onesCount(ANAC) & 1)==1) parityPerField|=ANAC_PARITY_BIT;
if((onesCount(NAC) & 1)==1) parityPerField|=NAC_PARITY_BIT;
/* Store fields in proper unit header record */ toLE2(unitData.virtualUnitNo,virtualUnitNo); toLE2(secondUnitData.virtualUnitNo,virtualUnitNo); toLE2(unitData.prevUnitNo,prevUnitNo); toLE2(secondUnitData.prevUnitNo,prevUnitNo); unitData.ANAC=secondUnitData.ANAC=ANAC; unitData.NAC=secondUnitData.NAC=NAC; unitData.parityPerField=secondUnitData.parityPerField=parityPerField; unitData.discarded=DISCARD;
/* Write first unit header */ status = vol.flash->write(vol.flash, unitBaseAddress(vol,unitNo) + UNIT_DATA_OFFSET, &unitData, sizeof(ANANDUnitHeader), EXTRA); if(status == flOK) /* Write second unit header */ status = vol.flash->write(vol.flash, unitBaseAddress(vol,unitNo) + SECOND_HEADER_OFFSET+UNIT_DATA_OFFSET, &secondUnitData, sizeof(SecondANANDUnitHeader), EXTRA); if(status == flOK) {
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
if (vol.flash->socket->verifyWrite == FL_ON) goto fillCache;#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
#ifdef NFTL_CACHE
if (vol.ucache != NULL) /* Mark unit cache as none valid before read */ { vol.ucache[unitNo].virtualUnitNo = 0xDEAD; vol.ucache[unitNo].prevUnitNo = 0xDEAD; }#endif /* NFTL_CACHE */
status = getUnitData(&vol,unitNo,&newVirtualUnitNo, &newPrevUnitNo,&newANAC,&newNAC,&parityPerField); if (status == flOK) { if ((virtualUnitNo == newVirtualUnitNo) && (prevUnitNo == newPrevUnitNo ) && (!badParityResult(parityPerField) ) ) goto fillCache; } }
/* If we reached here we failed in writing unit header */ /* Erase unit and report write fault */
DEBUG_PRINT(("setUnitData : Failed setting unit data\r\n")); status = formatUnit(&vol,unitNo,UNIT_TAILER_OFFSET); if (status != flOK) { markUnitBad(&vol,unitNo); return status; } else { return flWriteFault; }
fillCache: /* Unit headers were placed OK, now update cache */#ifdef NFTL_CACHE
/* Update ANANDUnitHeader cache to prevent re-filling from flash */ if (vol.ucache != NULL) { vol.ucache[unitNo].virtualUnitNo = virtualUnitNo; vol.ucache[unitNo].prevUnitNo = prevUnitNo; vol.ucache[unitNo].ANAC = ANAC; vol.ucache[unitNo].NAC = NAC; }#endif /* NFTL_CACHE */
return flOK;}
/*----------------------------------------------------------------------*//* d i s c a r d Q u i c k M o u n t I n f o *//* *//* Mark quick mount information is none valid. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus discardQuickMountInfo(Bnand vol){#ifndef RAM_MTD
static const#endif /* RAM_MTD */
dword tmp = 0; /* Dis - validate quick mount data */ if(vol.firstMediaWrite == FALSE) { vol.firstMediaWrite = TRUE; return vol.flash->write(vol.flash, QUICK_MOUNT_VALID_SIGN_OFFSET + ((dword)vol.firstQuickMountUnit << vol.unitSizeBits), &tmp, sizeof(tmp), 0); } return flOK;}
/*----------------------------------------------------------------------*//* m a r k A s I g n o r e d *//* *//* Mark sector at given address as ignored. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* addr : Physical address of the sector *//* *//*----------------------------------------------------------------------*/
static void markAsIgnored(Bnand vol,CardAddress addr){#ifndef RAM_MTD
static const#endif /* RAM_MTD */
byte sectorFlags[2] = {SECTOR_IGNORE,SECTOR_IGNORE};
DEBUG_PRINT(("markAsIgnored : A sector is being marked as ignored\r\n"));
discardQuickMountInfo(&vol);
#ifdef NFTL_CACHE
setSectorFlagsCache(&vol, addr, SECTOR_IGNORE);#endif /* NFTL_CACHE */
vol.flash->write(vol.flash,addr+SECTOR_DATA_OFFSET,sectorFlags,sizeof(sectorFlags),EXTRA);
#ifdef MAKE_SURE_IGNORE_HAS_BAD_EDC
/* Force remapping of internal catched sector */ vol.flash->socket->remapped = TRUE;
/* Make sure EDC is wrong - a slite problem with PPP */ if(vol.flash->read(vol.flash,addr,inftlBuffer,sizeof(inftlBuffer),EDC)==flOK) { tffsset(inftlBuffer,0,sizeof(inftlBuffer)); vol.flash->write(vol.flash,addr,inftlBuffer,sizeof(inftlBuffer),0); }#if (defined(VERIFY_WRITE) || defined (VERIFY_VOLUME) || defined(VERIFY_ERASED_SECTOR))
/* Now restore the ff's for the verifySectors routine */ tffsset(inftlBuffer,0xff,sizeof(inftlBuffer));#endif /* VERIFY_WRITE || VERIFY_VOLUME || VERIFY_ERASED_SECTOR */
#endif /* MAKE_SURE_IGNORE_HAS_BAD_EDC */
}
#endif /* FL_READ_ONLY */
/*----------------------------------------------------------------------*//* v i r t u a l 2 P h y s i c a l *//* *//* Translate virtual sector number to physical address. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorNo : Virtual sector number *//* startAddress : Physical address to start from *//* lastOK : TRUE - the current sector in the last unit of *//* virtual unit chain is free (not marked as *//* deleted / ignored or used). *//* *//* Note: The first unit of the search is assumed to be valid. *//* *//* Returns: *//* physical address of sectorNo *//*----------------------------------------------------------------------*/
static CardAddress virtual2Physical(Bnand vol, SectorNo sectorNo, CardAddress startAddress,FLBoolean* lastOK){ word unitOffset = (word)((sectorNo & vol.sectorsPerUnitMask) << SECTOR_SIZE_BITS); ANANDUnitNo unitNo, virUnitNo; ANANDUnitNo chainBound = 0; CardAddress sectorAddress = ANAND_UNASSIGNED_ADDRESS; byte sectorFlags = SECTOR_FREE;
/* follow the chain */ virUnitNo = (ANANDUnitNo)(sectorNo >> vol.sectorsPerUnitBits); if (startAddress == ANAND_UNASSIGNED_ADDRESS) { /* Start from last unit in chain */ unitNo = vol.virtualUnits[virUnitNo]; } else { /* Start from the unit that follows the given unit */
TL_DEBUG_PRINT(tl_out,"virtual2Physical : Virtual to physical started from middle of chain on unit %d\n",virUnitNo); SET_EXIT(INFTL_FAILED_MOUNT); unitNo = getPrevUnit(&vol,(ANANDUnitNo)((startAddress >> vol.unitSizeBits) - vol.firstUnit),virUnitNo); if(unitNo == ANAND_BAD_CHAIN_UNIT) return ANAND_BAD_CHAIN_ADDRESS; }
for (;unitNo != ANAND_NO_UNIT;unitNo = getPrevUnit(&vol,unitNo,virUnitNo)) { if((unitNo == ANAND_BAD_CHAIN_UNIT ) || (chainBound >= DOUBLE_MAX_UNIT_CHAIN) ) return ANAND_BAD_CHAIN_ADDRESS;
sectorAddress = unitBaseAddress(vol,unitNo) + unitOffset; sectorFlags = getSectorFlags(&vol,sectorAddress);
/* Report if the last unit of the chain is used */ if ((unitNo == vol.virtualUnits[virUnitNo]) && (sectorFlags != SECTOR_FREE)) *lastOK = FALSE;
if((sectorFlags==SECTOR_FREE) || (sectorFlags==SECTOR_IGNORE)) { chainBound++; continue; } break; }
if((sectorFlags==SECTOR_IGNORE)||(sectorFlags==SECTOR_FREE)||(sectorFlags==SECTOR_DELETED)) /* Sector was never written*/ return ANAND_UNASSIGNED_ADDRESS; return sectorAddress;}
/*----------------------------------------------------------------------*//* i n i t I N F T L b a s i c *//* *//* Initializes essential volume data *//* *//* Note : This routine is called both by the mount and format initINFTL *//* and as a preparation for counting the number of partitions function. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* flash : Flash media mounted on this socket *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus initINFTLbasic(Bnand vol, FLFlash *flash){ dword noOfUnits; /* Keep this variable dword , for large DiskOnChips */
if (flash == NULL || !(flash->flags & INFTL_ENABLED)) { DEBUG_PRINT(("\nDebug: media is not fit for INFTL format.\r\n")); return flUnknownMedia; } if(flash->readBBT == NULL) { DEBUG_PRINT(("\nDEBUG : MTD read BBT routine was not initialized\r\n")); return flFeatureNotSupported; }
vol.flash = flash; vol.erasableBlockSizeBits = flash->erasableBlockSizeBits; vol.unitSizeBits = vol.erasableBlockSizeBits; noOfUnits = (dword)((vol.flash->noOfChips * vol.flash->chipSize) >> vol.unitSizeBits);
/* Bound number of units to find room in 64 Kbytes Segment */
if((noOfUnits > MAX_UNIT_NUM) && (vol.unitSizeBits < MAX_UNIT_SIZE_BITS)) { vol.unitSizeBits++; noOfUnits >>= 1; }
vol.blockMultiplierBits = vol.unitSizeBits - vol.erasableBlockSizeBits;
/* get pointer to buffer (we assume SINGLE_BUFFER is not defined) */ vol.buffer = flBufferOf(flSocketNoOf(vol.flash->socket));#ifdef VERIFY_ERASED_SECTOR
vol.verifyBuffer = (dword *)flReadBackBufferOf(flSocketNoOf(flash->socket));#endif /* VERIFY_ERASED_SECTOR */
flash->socket->remapped = TRUE;
return flOK;}
/*----------------------------------------------------------------------*//* i n i t N F T L *//* *//* Initializes essential volume data as a preparation for mount or *//* format. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* flash : Flash media mounted on this socket *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus initINFTL(Bnand vol, FLFlash *flash){ dword chipSize; /* Keep this variable dword , for large DiskOnChips */ FLStatus status;
if(flash!=NULL) { tffsset(&vol,0,sizeof(Bnand)); /* Clear Bnand volume */
#ifdef NT5PORT
vol.socketNo = (byte)(flSocketNoOf(flash->socket)); /* socket No */#else
vol.socketNo = flSocketNoOf(flash->socket); /* socket No */#endif /*NT5PORT*/
}
status = initINFTLbasic(&vol, flash); if(status != flOK) return status;
chipSize = (dword)(flash->chipSize * flash->noOfChips);
#ifndef FL_MALLOC
if (chipSize > (dword)MAX_VOLUME_MBYTES << 20) { DEBUG_PRINT(("\nDebug: TrueFFS is customized for smaller media capacities.\r\n")); return flGeneralFailure; } if (ASSUMED_NFTL_UNIT_SIZE > (1L<<vol.unitSizeBits)) { DEBUG_PRINT(("\nDebug: TrueFFS is customized for smaller unit sizes.\r\n")); return flGeneralFailure; }#endif /* FL_MALLOC */
vol.physicalUnits = NULL; vol.virtualUnits = NULL;
#ifdef NFTL_CACHE
vol.ucache = NULL; vol.scache = NULL;#endif /* NFTL_CACHE */
vol.mappedSectorNo = UNASSIGNED_SECTOR; vol.countsValid = 0; /* No units have a valid count yet */ vol.firstUnit = 0; vol.sectorsPerUnit = 1 << (vol.unitSizeBits - SECTOR_SIZE_BITS); vol.sectorsPerUnitBits = vol.unitSizeBits - SECTOR_SIZE_BITS; vol.sectorsPerUnitMask = vol.sectorsPerUnit - 1; vol.noOfUnits = (ANANDUnitNo)(chipSize >> vol.unitSizeBits); vol.firstMediaWrite = FALSE;#if (defined(VERIFY_WRITE) || defined(VERIFY_VOLUME) || defined(VERIFY_ERASED_SECTOR))
vol.verifiedSectorNo = 0; /* Largest sector verified so far */#endif /* VERIFY_WRITE || VERIFY_VOLUME || VERIFY_ERASED_SECTOR */
#ifdef CHECK_MOUNT
vol.debugState = 0;#endif /* CHECK_MOUNT */
return flOK;}
/*----------------------------------------------------------------------*//* i n i t T a b l e s *//* *//* Allocates and initializes the dynamic volume table, including the *//* unit tables and secondary virtual map. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* ramForUnits : Number of bytes allocated to previous volumes *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
#ifdef FL_MALLOC
static FLStatus initTables(Bnand vol){ /* Allocate the conversion tables */
vol.physicalUnits = (ANANDPhysUnit FAR1*) FL_FAR_MALLOC(vol.noOfUnits * sizeof(ANANDPhysUnit)); if (vol.noOfVirtualUnits > 0) vol.virtualUnits = (ANANDUnitNo FAR1*) FL_FAR_MALLOC(vol.noOfVirtualUnits * sizeof(ANANDUnitNo)); if ((vol.physicalUnits == NULL) || ((vol.virtualUnits == NULL) && (vol.noOfVirtualUnits > 0))) { DEBUG_PRINT(("\nDebug: failed allocating conversion tables for INFTL.\r\n")); return flNotEnoughMemory; }
/* Allocate the multi-sector buffer (one per socket) */ if (++(multiSectorBufCounter[vol.socketNo]) == 0) { multiSectorBuf[vol.socketNo] = (byte *)FL_MALLOC(SECTOR_SIZE<<1); if (multiSectorBuf[vol.socketNo] == NULL) { DEBUG_PRINT(("\nDebug: failed allocating multi-sector buffers for INFTL.\r\n")); return flNotEnoughMemory; } } return flOK;}#else
static FLStatus initTables(Bnand vol,dword ramForUnits){ Sbyte *heapPtr;
vol.heap = &socketHeap[flSocketNoOf(vol.flash->socket)][ramForUnits]; heapPtr = vol.heap; vol.physicalUnits = (ANANDPhysUnit FAR1*) heapPtr; heapPtr += vol.noOfUnits * sizeof(ANANDPhysUnit); vol.virtualUnits = (ANANDUnitNo FAR1*) heapPtr; heapPtr += vol.noOfVirtualUnits * sizeof(ANANDUnitNo);
if ((ANAND_HEAP_SIZE < heapPtr - vol.heap) || (ASSUMED_NFTL_UNIT_SIZE > 1L << vol.unitSizeBits)) { DEBUG_PRINT(("\nDebug: not enough memory for INFTL conversion tables.\r\n")); return flNotEnoughMemory; } return flOK;}#endif /* FL_MALLOC */
/*----------------------------------------------------------------------*//* f i r s t I n C h a i n *//* *//* Find first unit in chain. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Start the search from this unit *//* nextUnit : Returns the Second unit of the chain. *//* *//* Returns: *//* Physical unit number of the last unit in chain. *//*----------------------------------------------------------------------*/
static ANANDUnitNo firstInChain(Bnand vol, ANANDUnitNo unitNo,ANANDUnitNo* nextUnit){ ANANDUnitNo firstVirtualUnitNo, firstReplacementUnitNo,prevVirtualUnitNo; ANANDUnitNo nextUnitNo,prevReplacementUnitNo; ANANDUnitNo chainBound = 0; byte ANAC,NAC,parityPerField;
if(unitNo==ANAND_NO_UNIT) /* Sanity check */ { if(nextUnit!=NULL) *nextUnit=ANAND_NO_UNIT; return unitNo; }
/* If this unit is the first of its chain , no need to keep looking */ if( vol.physicalUnits[unitNo] & FIRST_IN_CHAIN ) { if(nextUnit!=NULL) *nextUnit=ANAND_NO_UNIT; return unitNo; } getUnitData(&vol,unitNo,&firstVirtualUnitNo,&firstReplacementUnitNo,&ANAC,&NAC,&parityPerField); /* check if unit is valid */ if(badParityResult(parityPerField)) { DEBUG_PRINT(("\nFirst In chain found bad unit header\r\n")); if(nextUnit!=NULL) *nextUnit=ANAND_NO_UNIT; return ANAND_BAD_CHAIN_UNIT; }
nextUnitNo=unitNo; unitNo=firstReplacementUnitNo; while( (unitNo < vol.noOfUnits) && /* Validate replacement unit no. */ (chainBound < DOUBLE_MAX_UNIT_CHAIN) ) { if(unitNo==ANAND_NO_UNIT) break; getUnitData(&vol,unitNo,&prevVirtualUnitNo,&prevReplacementUnitNo,&ANAC,&NAC,&parityPerField); /* check if unit is valid */ if(badParityResult(parityPerField)) { DEBUG_PRINT(("\nFirst In chain found bad unit header\r\n")); if(nextUnit!=NULL) *nextUnit=ANAND_NO_UNIT;
return ANAND_BAD_CHAIN_UNIT; }
if(( vol.physicalUnits[unitNo] & FIRST_IN_CHAIN )&&(firstVirtualUnitNo==prevVirtualUnitNo)) { if(nextUnit!=NULL) *nextUnit=nextUnitNo;
return unitNo; }
if( prevVirtualUnitNo != (firstVirtualUnitNo ) ) { /* This one does not belong to the chain */ if(nextUnit!=NULL) *nextUnit=ANAND_NO_UNIT;
return nextUnitNo; } nextUnitNo = unitNo; unitNo = prevReplacementUnitNo; chainBound++; }
return ANAND_BAD_CHAIN_UNIT;}
#ifndef FL_READ_ONLY
/*----------------------------------------------------------------------*//* w r i t e A n d C h e c k *//* *//* Physicaly write up to 2 sectors on given address and verify. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* address : Physical address of the sector to write to *//* fromAddress : Buffer of data to write *//* flags : Write flags (ECC, overwrite etc.) *//* howMany : Number of sectors to write. *//* *//* Returns: *//* Status : 0 on success, failed otherwise. *//*----------------------------------------------------------------------*/
static FLStatus writeAndCheck(Bnand vol, CardAddress address, void FAR1 *fromAddress, unsigned flags,word howMany){ FLStatus status; register int i;#ifdef VERIFY_ERASED_SECTOR
register int noOfDword; int j;#endif /* VERIFY_ERASED_SECTOR */
/* Toggle verify write flag */#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
switch (flVerifyWrite[vol.socketNo][vol.flash->socket->curPartition]) { case FL_OFF: if (vol.verifiedSectorNo>vol.curSectorWrite+howMany) break; case FL_ON:#ifdef VERIFY_WRITE
vol.flash->socket->verifyWrite = FL_ON;#endif /* VERIFY_WRITE */
#ifdef VERIFY_ERASED_SECTOR
/* Make sure all of the sectors are really free */ checkStatus(vol.flash->read(vol.flash,address,vol.verifyBuffer,SECTOR_SIZE*howMany,0)); noOfDword = SECTOR_SIZE/sizeof(dword); for(j=0;j<howMany;j++) /* Loop over sectors */ { for(i = 0;i<noOfDword;i++) /* Loop over sector data */ { if(vol.verifyBuffer[i]!=0xffffffffL) { markAsIgnored(&vol,address+j*SECTOR_SIZE); DEBUG_PRINT(("writeAndCheck : The sector was not erased and is ignored\r\n")); return flWriteFault; } } }#endif /* VERIFY_ERASED_SECTOR */
break; default: break; }#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
/* Write sector */ status = vol.flash->write(vol.flash,address,fromAddress,SECTOR_SIZE*howMany,(word)flags);
#ifdef VERIFY_WRITE
if(flVerifyWrite[vol.socketNo][vol.flash->socket->curPartition] != FL_ON) vol.flash->socket->verifyWrite = FL_OFF;#endif /* VERIFY_WRITE */
/* Make sure write succeded and update sector catche */ if (status == flWriteFault) { /* write failed, ignore this sector */ DEBUG_PRINT(("writeAndCheck : Write of a sector failed and was marked as ignored\r\n"));
for(i=0;i<howMany;i++) { markAsIgnored(&vol,address+i*SECTOR_SIZE); } }#ifdef NFTL_CACHE
else { for(i=0;i<howMany;i++) setSectorFlagsCache(&vol, address+i*SECTOR_SIZE, SECTOR_USED); }#endif /* NFTL_CACHE */
return status;}
/*----------------------------------------------------------------------*//* a s s i g n U n i t *//* *//* Assigns a virtual unit no. to a unit *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Physical unit number *//* virtualUnitNo : Virtual unit number to assign *//* ANAC : Accumulating Number Along Chain *//* NAC : Number Along Chain. *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus assignUnit(Bnand vol, ANANDUnitNo unitNo, ANANDUnitNo virtualUnitNo, byte ANAC, byte NAC){ FLStatus status;
/* Perpare sector count */ if((vol.countsValid > virtualUnitNo ) && /* Has sector count */ (vol.virtualUnits[virtualUnitNo] != ANAND_NO_UNIT)) /* Was used */ { vol.physicalUnits[unitNo] = countOf(vol.virtualUnits[virtualUnitNo]); } else { vol.physicalUnits[unitNo] = 0; }
/* Vadim for ASAP policy*/#ifdef ENVIRONMENT_VARS
if(NAC>=MAX_UNIT_CHAIN) NAC=MAX_UNIT_CHAIN-1;#endif /* ENVIRONMENT_VARS */
status = setUnitData(&vol,unitNo,virtualUnitNo,(ANANDUnitNo)vol.virtualUnits[virtualUnitNo],(byte)(ANAC+1),(byte)(NAC+1)); if (status != flOK) { markUnitBad(&vol,unitNo); } else { if(unitNo>vol.noOfUnits) return flGeneralFailure; vol.virtualUnits[virtualUnitNo]=unitNo; if(vol.freeUnits) vol.freeUnits--; } return status;}
/*----------------------------------------------------------------------*//* f o r m a t C h a i n *//* *//* Format all the units in a chain. Start from the last one and go *//* backwards until unitNo is reached. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Format the chain from this unit onwards *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus formatChain(Bnand vol, ANANDUnitNo unitNo){ /* Erase the chain from end to start */ ANANDUnitNo chainBound; ANANDUnitNo unitToErase; FLStatus status;
for (chainBound=0;; chainBound++) { /* Find last unit in chain */ unitToErase = firstInChain(&vol,unitNo,NULL);
if((unitToErase == ANAND_BAD_CHAIN_UNIT ) || (chainBound >= DOUBLE_MAX_UNIT_CHAIN) ) return flGeneralFailure;
status = formatUnit(&vol,unitToErase,UNIT_TAILER_OFFSET); if(status != flOK) return status;
if (unitToErase == unitNo) break; /* Erased everything */ }
return flOK;}
/*----------------------------------------------------------------------*//* c r e a t e U n i t C o u n t *//* *//* Count the number of sectors in a unit that hold valid data. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Physical unit number *//* *//*----------------------------------------------------------------------*/
static void createUnitCount(Bnand vol, ANANDUnitNo unitNo){ register int i; SectorNo sectorNo; ANANDUnitNo physicalUnitNo = vol.virtualUnits[unitNo]; CardAddress sectorAddress; FLBoolean lastOK; /* Dummy variable */
if (physicalUnitNo == ANAND_NO_UNIT) return;
/* Get a count of the valid sector in this unit */ setUnitCount(physicalUnitNo,0);
sectorNo = (SectorNo)unitNo << vol.sectorsPerUnitBits; for (i = 0; i < vol.sectorsPerUnit; i++, sectorNo++) { sectorAddress = virtual2Physical(&vol,sectorNo,ANAND_UNASSIGNED_ADDRESS,&lastOK); /* Do not check for brocken chain. If one exists we will have a */ /* large sector count , which will delay folding. */ if (sectorAddress != ANAND_UNASSIGNED_ADDRESS) vol.physicalUnits[physicalUnitNo]++; }}
#if (defined(VERIFY_WRITE) || defined(VERIFY_VOLUME) || defined(VERIFY_ERASED_SECTOR))
/*----------------------------------------------------------------------*//* v e r i f y S e c t o r s *//* *//* Verify sectors for power failures simptoms and fix if neccesary. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorCount : No of sectors to verify *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
FLStatus verifySectors(Bnand vol, dword sectorCount){ FLStatus status; word unitOffset; ANANDUnitNo virUnitNo; ANANDUnitNo unitNo; dword curRead; CardAddress sectorAddress; word j; byte chainBound,index; byte sectorFlags[2]; static FLBoolean scannedBlocks[MAX_SECTORS_PER_BLOCK]; byte FAR1* buffer;
if (vol.verifiedSectorNo >= vol.virtualSectors) return flOK;
/* Initialize variables */ buffer = flReadBackBufferOf(vol.socketNo);
if(buffer==NULL) { DEBUG_PRINT(("\nDebug : Can not verify sectors since no buffer was allocated\r\n")); return flOK; }
virUnitNo = (ANANDUnitNo)(vol.verifiedSectorNo >> vol.sectorsPerUnitBits); sectorCount = TFFSMIN(vol.virtualSectors - vol.verifiedSectorNo,sectorCount);
/* Force remapping of internal catched sector */ vol.flash->socket->remapped = TRUE; tffsset(inftlBuffer,0xff,sizeof(inftlBuffer)); /* Useds as FF'S buffer */
/* Run over required number of virtual sectors */ for (; sectorCount > 0 ; virUnitNo++ ,sectorCount -= curRead) { /* Calculate needed number of sector in this unit */ unitOffset = (word)((vol.verifiedSectorNo & vol.sectorsPerUnitMask) << SECTOR_SIZE_BITS); curRead = TFFSMIN(sectorCount,((1UL<<vol.unitSizeBits)-unitOffset)>>SECTOR_SIZE_BITS); unitNo = vol.virtualUnits[virUnitNo];
if(unitNo == ANAND_NO_UNIT) /* Unit is empty */ { vol.verifiedSectorNo += ((1<<vol.unitSizeBits)-unitOffset)>>SECTOR_SIZE_BITS; continue; }
/* Unit is not empty - initialize sector array */ if(unitOffset==0) tffsset(scannedBlocks,FALSE,sizeof(scannedBlocks));
for(chainBound=0;;chainBound++) { /* Go over the chain from newest unit to oldest */
if(chainBound!=0) /* Get next unit */ { unitNo = getPrevUnit(&vol,unitNo,virUnitNo); if((unitNo == ANAND_BAD_CHAIN_UNIT ) || (chainBound>=DOUBLE_MAX_UNIT_CHAIN) ) { DEBUG_PRINT(("\nverifySectors : Bad chain was found\r\n")); return flGeneralFailure; } if(unitNo == ANAND_NO_UNIT) break; }
/* Check required sectors of the unit - 2 sectors at a time */ sectorAddress = unitBaseAddress(vol,unitNo)+unitOffset; for (index=0;index<curRead;index+=2) { /* Read sector flags if needed
* * Note - getSectorFlags routine must not change the inftlBuffer */ if(WasSectorChecked(sectorAddress) == FALSE) sectorFlags[0] = getSectorFlags(&vol,sectorAddress); if(WasSectorChecked(sectorAddress+SECTOR_SIZE) == FALSE) sectorFlags[1] = getSectorFlags(&vol,sectorAddress+SECTOR_SIZE);
/* Try checking 2 sectors together */ if((sectorFlags[0]==sectorFlags[1] ) && (WasSectorChecked(sectorAddress+SECTOR_SIZE) == FALSE) && (WasSectorChecked(sectorAddress) == FALSE)) { /* Indenctical sector flags - sectors are checked together */ switch(sectorFlags[0]) { case SECTOR_FREE: status = vol.flash->read(vol.flash,sectorAddress,buffer,SECTOR_SIZE<<1,0); if(status != flOK) return status; if (tffscmp(inftlBuffer,buffer,sizeof(inftlBuffer))) { markAsIgnored(&vol,sectorAddress); createUnitCount(&vol,virUnitNo); } if (tffscmp(inftlBuffer,buffer+sizeof(inftlBuffer),sizeof(inftlBuffer))) { markAsIgnored(&vol,sectorAddress+SECTOR_SIZE); createUnitCount(&vol,virUnitNo); } break; case SECTOR_DELETED: case SECTOR_USED: status = vol.flash->read(vol.flash,sectorAddress,buffer,SECTOR_SIZE<<1,EDC); if(status == flDataError) { status = vol.flash->read(vol.flash,sectorAddress,buffer,SECTOR_SIZE,EDC); if(status != flOK) { markAsIgnored(&vol,sectorAddress); status = vol.flash->read(vol.flash,sectorAddress+SECTOR_SIZE,buffer,SECTOR_SIZE,EDC); if(status != flOK) { markAsIgnored(&vol,sectorAddress+SECTOR_SIZE); } else { MarkSectorAsChecked(sectorAddress+SECTOR_SIZE); } } else { MarkSectorAsChecked(sectorAddress); markAsIgnored(&vol,sectorAddress+SECTOR_SIZE); } createUnitCount(&vol,virUnitNo); break; } MarkSectorAsChecked(sectorAddress); default: /* SECTOR_IGNORE */ break; }/* Flag type case */ sectorAddress+=SECTOR_SIZE<<1; } /* Flags are indentical */ else /* Check each sectors individualy */ { for(j=0;j<2;j++,sectorAddress+=SECTOR_SIZE) { if(WasSectorChecked(sectorAddress) == TRUE) continue;
switch(sectorFlags[j]) { case SECTOR_FREE: status = vol.flash->read(vol.flash,sectorAddress,buffer,SECTOR_SIZE,0); if(status != flOK) return status; if (tffscmp(inftlBuffer,buffer,sizeof(inftlBuffer))) { markAsIgnored(&vol,sectorAddress); createUnitCount(&vol,virUnitNo); } break; case SECTOR_USED: case SECTOR_DELETED: status = vol.flash->read(vol.flash,sectorAddress,buffer,SECTOR_SIZE,EDC); if(status == flDataError) { markAsIgnored(&vol,sectorAddress); createUnitCount(&vol,virUnitNo); } MarkSectorAsChecked(sectorAddress); default: /* SECTOR_IGNORE || SECTOR_DELETED */ break; } /* Flag type */ } /* Try second sector */ } /* Flags are NOT indentical */ } /* Loop over all sector of unit or until required sectors */ } /* Loop over all units chains */ vol.verifiedSectorNo+=curRead; } /* Loop over all required sectors */ return flOK;}
/*----------------------------------------------------------------------*//* c h e c k V o l u m e *//* *//* Scanthe entire media for partialy written sectors. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus checkVolume(Bnand vol){ return verifySectors(&vol, 0xffffffffL); /* Force scan of entire media */}
#endif /* VERIFY_WRITE || VERIFY_VOLUME || VERIFY_ERASED_SECTOR */
/*----------------------------------------------------------------------*//* f o l d U n i t *//* *//* Copy all the sectors that hold valid data in the chain to the last *//* unit of the chain and erase the chain. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* virtualUnitNo : Virtual unit number of the first unit in *//* chain. *//* foldingFlag : One of the following flags: *//* FL_NORMAL_FOLDING - Returns fail status if can not fold *//* FL_FORCE_FOLDING - Force folding even if last sector is used *//* FL_NOT_IN_PLACE - Fold into a unit with no erase mark *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus foldUnit(Bnand vol, ANANDUnitNo virtualUnitNo, int foldingFlag){ ANANDUnitNo unitNo = vol.virtualUnits[virtualUnitNo]; ANANDUnitNo prevUnitNo; SectorNo virtualSectorNo; CardAddress targetSectorAddress; int newSectorCount = 0; int i; byte ANAC,NAC,parityPerField;#ifdef ENVIRONMENT_VARS
ANANDUnitNo nextUnitNo = ANAND_NO_UNIT; CardAddress firstUnitAddress = ANAND_UNASSIGNED_ADDRESS; ANANDUnitNo firstUnit = ANAND_NO_UNIT; FLBoolean foldFirstOnly = (flPolicy[vol.socketNo] [vol.flash->socket->curPartition] == FL_COMPLETE_ASAP) ? TRUE : FALSE;#endif /* ENVIRONMENT_VARS */
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
byte verifyWriteState = flVerifyWrite[vol.socketNo] [vol.flash->socket->curPartition];#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
FLBoolean lastOK; byte chainBound; FLStatus status; CardAddress sourceSectorAddress;
/* Sanity checks */ if(unitNo>=vol.noOfUnits) /* Empty or INVALID */ { return flGeneralFailure; }
/* Internal statistics */ vol.unitsFolded++; /* Force remapping of internal catched sector */ vol.flash->socket->remapped = TRUE; virtualSectorNo = (SectorNo)virtualUnitNo << vol.sectorsPerUnitBits; targetSectorAddress = unitBaseAddress(vol,unitNo);
/* When verify write option is set to FL_OFF a very lazy check of the */ /* media is done every time a folding operation is issued */#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
if(verifyWriteState == FL_OFF) { status = verifySectors(&vol,SECTORS_VERIFIED_PER_FOLDING); if(status != flOK) return status; vol.curSectorWrite = virtualSectorNo; /* Store virtual sector Number */ }#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
/* When policy is set to FL_COMPLETE_ASAP - folding is performed only on */ /* the oldest unit, so find oldest unit and store its location */#ifdef ENVIRONMENT_VARS
if(foldFirstOnly == TRUE) { firstUnit = firstInChain(&vol,unitNo,&nextUnitNo); if(firstUnit == ANAND_BAD_CHAIN_UNIT) /* Error going along chain */ { return flGeneralFailure; } firstUnitAddress = unitBaseAddress(vol,firstUnit); }#endif
/* If chain has no valid sectors simply erase it. */ if((vol.countsValid>virtualUnitNo) && /* Unit valid sectors were counted */ (countOf(unitNo)==0)) /* No valid sectors in unit chain */ {#ifdef ENVIRONMENT_VARS
if((foldFirstOnly == TRUE) && (nextUnitNo != ANAND_NO_UNIT)) { /* Erase only first unit of chain */ vol.physicalUnits[nextUnitNo] = FIRST_IN_CHAIN; return formatChain(&vol,firstUnit); } else#endif /* ENVIRONMENT_VARS */
{ /* Erase chain completely */ vol.virtualUnits[virtualUnitNo] = ANAND_NO_UNIT; return formatChain(&vol,unitNo); } }
/* Single unit with valid sectors can not be folded */ if((vol.physicalUnits[unitNo]&FIRST_IN_CHAIN)==FIRST_IN_CHAIN) return flGeneralFailure;
/***********************************/ /* Copy all sectors to target unit */ /***********************************/
for (i = 0; i < vol.sectorsPerUnit;#ifdef ENVIRONMENT_VARS
firstUnitAddress += SECTOR_SIZE,#endif /* ENVIRONMENT_VARS */
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
vol.curSectorWrite++, /* Update virtual sector Number */#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
i++, virtualSectorNo++,targetSectorAddress += SECTOR_SIZE) { lastOK = TRUE; /* Set last sector of chain as valid */ sourceSectorAddress = virtual2Physical(&vol,virtualSectorNo,ANAND_UNASSIGNED_ADDRESS,&lastOK);
/* Check if sector is on the target unit. If so on some configuration we */ /* Verify the content and on some , we just assume the data is fine. */ if(sourceSectorAddress == targetSectorAddress) {#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
switch(verifyWriteState) { case FL_ON: /* Always verify */ break; case FL_OFF: /* Verify only if area was not scanned yet */ if(virtualSectorNo >= vol.verifiedSectorNo) break; default: /* FL_UPS - Never verify */ newSectorCount++; continue; }#else
newSectorCount++; continue;#endif /* VERIFY WRITE */
}
/* Read sector - Loop down the chain as long as there is an EDC error */ /* or infinit loop chain (chain bound) */ for (chainBound=0 ; (sourceSectorAddress != ANAND_UNASSIGNED_ADDRESS) ; chainBound++) { if(sourceSectorAddress == ANAND_BAD_CHAIN_ADDRESS) /* Could not follow chain */ return flGeneralFailure;
status = vol.flash->read(vol.flash,sourceSectorAddress, inftlBuffer,SECTOR_SIZE,EDC); if (status != flOK) { if (status == flDataError) { DEBUG_PRINT(("foldUnit : EDC error on folding\r\n")); if (chainBound >= MAX_UNIT_CHAIN) return status; sourceSectorAddress = virtual2Physical(&vol,virtualSectorNo,sourceSectorAddress,&lastOK); continue; } else { return status; } } break; } /* chain bound EDC error loop */
if (sourceSectorAddress == ANAND_UNASSIGNED_ADDRESS) /* Sector not found */ continue;
newSectorCount++; if (sourceSectorAddress == targetSectorAddress) /* Sector already exists */ continue;
/* Try and copy the relevant sector */
#ifdef ENVIRONMENT_VARS
/* On FL_COMPLETE_ASAP copy sector only if it is on the first unit */ if((flPolicy[vol.socketNo][vol.flash->socket->curPartition]==FL_COMPLETE_ASAP) && (sourceSectorAddress!=firstUnitAddress)) continue;#endif /* ENVIRONMENT_VARS */
if ((lastOK == FALSE) && (foldingFlag == FL_NORMAL_FOLDING)) { /* Last sector of the chain is already used */ return flCanNotFold; } status = writeAndCheck(&vol,targetSectorAddress,inftlBuffer,EDC,1); vol.parasiteWrites++;
/* On EDC error assume previous sector is empty */
switch (status) { case flOK: /* Success */ break;
case flWriteFault: /* Faild in verify write */ if (foldingFlag == FL_NORMAL_FOLDING) { DEBUG_PRINT(("foldUnit : Failed to write a sector while folding but will not force folding\r\n")); return flCanNotFold; } break;
default : /* Protection error or any other */ return status; } } /* Sector copy loop */
/***************************************************************/ /* After all sectors have been copied , erase the unused units */ /***************************************************************/
if(foldingFlag == FL_NOT_IN_PLACE) /* Add erase mark to validate unit */ { word eraseMark; dword eraseCount;
checkStatus(getUnitTailer(&vol,unitNo,&eraseMark,&eraseCount,UNIT_TAILER_OFFSET_2)); checkStatus(setUnitTailer(&vol,unitNo,eraseMark,eraseCount,UNIT_TAILER_OFFSET)); }
if (newSectorCount > 0) /* Some sectors remaining*/ { /* Set target unit in physical unit table as first in chain */ status = getUnitData(&vol,unitNo,&virtualUnitNo, &prevUnitNo,&ANAC,&NAC,&parityPerField); if(status != flOK) return status; /* check if unit is valid */ if(badParityResult(parityPerField)) return flGeneralFailure;#ifdef ENVIRONMENT_VARS
/* Erase only oldest unit */ if(flPolicy[vol.socketNo][vol.flash->socket->curPartition]==FL_COMPLETE_ASAP) { vol.physicalUnits[nextUnitNo] |= FIRST_IN_CHAIN; return formatUnit(&vol, firstUnit,UNIT_TAILER_OFFSET); } else#endif
{ vol.physicalUnits[unitNo] |= FIRST_IN_CHAIN; unitNo=prevUnitNo; /* erase all units in chain but the last one */ } } else { /* Erase chain completely */ vol.virtualUnits[virtualUnitNo] = ANAND_NO_UNIT; }
/* Erase source units */ return formatChain(&vol,unitNo);}
/*----------------------------------------------------------------------*//* f o l d B e s t C h a i n *//* *//* Find the best chain to fold and fold it.A good chain to fold is a *//* long chain with a small number of sectors that hold valid data. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Receives the physical unit no. of the first *//* unit in the chain that was folded. *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus foldBestChain(Bnand vol, ANANDUnitNo *unitNo){ word leastCount, longestChain, unitCount; ANANDUnitNo u, firstUnitNo, newVirtualUnitNo, prevUnitNo; ANANDUnitNo virtualUnitNo; ANANDUnitNo frozenCandidate = ANAND_NO_UNIT; ANANDUnitNo lazyMountCounter = 0; ANANDUnitNo newestUnit; FLStatus status = flOK; byte NAC,ANAC,parityPerField; int foldingTries;
/* Will exit when no more units are available or up to 10 times */ for (*unitNo = ANAND_NO_UNIT,foldingTries = 0 ; foldingTries < MAX_FOLDING_LOOP ; foldingTries++) { /*********************************************/ /* Pick unit to fold using huristic function */ /*********************************************/
virtualUnitNo = ANAND_NO_UNIT; longestChain = 1; /* Minimal chain length to fold == 1 */ leastCount = vol.sectorsPerUnit+1;
for (u = 0; u < vol.noOfVirtualUnits; u++) { firstUnitNo = vol.virtualUnits[u]; if(firstUnitNo == ANAND_NO_UNIT) /* Free unit */ continue;
if( !(isAvailable(firstUnitNo)) ) { /* Do not attempt to fold frozen unit. */ /* They will become unfrozen by the end of this routine. */ frozenCandidate = u; /* Remember for forced folding */ DEBUG_PRINT(("FoldBestChains : Skiped unavailable unit\r\n")); continue; }
/* Lazy mount - Make sure unit has a valid sector count */ if (vol.countsValid <= u) { if(lazyMountCounter>=MAX_CREATE_UNIT_COUNT) { /* If lazy mount takes too long , try and shorten it. */ if(virtualUnitNo!=ANAND_NO_UNIT) break; } createUnitCount(&vol,u); lazyMountCounter++; vol.countsValid = u + 1; }
unitCount = countOf(firstUnitNo); /* No of valid sectors */
/* If empty unit, use it. */ if(unitCount==0) { leastCount = unitCount; /* Store minimal sector count */ virtualUnitNo = u; /* Store virtual unit number */ break; }
if ((leastCount < unitCount) || /* Already found a better unit */ (vol.physicalUnits[firstUnitNo] & FIRST_IN_CHAIN)) /* 1 unit in chain */ continue;
/* Sector count is smaller or equal now check chains length */ status = getUnitData(&vol,firstUnitNo,&newVirtualUnitNo, &prevUnitNo,&ANAC,&NAC,&parityPerField); if(status != flOK) return status; /* check if unit is valid */ if((badParityResult(parityPerField)) || (newVirtualUnitNo != u)) return flGeneralFailure;
if((leastCount == unitCount) && /* If sector count is equal */ (longestChain >= NAC) ) /* Use chain length */ continue;
/* If we reached here the current unit is the best so far */ longestChain = NAC; /* Store maximal chain length */ leastCount = unitCount; /* Store minimal sector count */ virtualUnitNo = u; /* Store virtual unit number */ } /* End of unit huristic loop */
/****************************************/ /* Try folding the unit that was picked */ /****************************************/
if (virtualUnitNo != ANAND_NO_UNIT) /* Found a chain (more then 1 unit) */ {
*unitNo = firstInChain(&vol,vol.virtualUnits[virtualUnitNo],NULL); if(*unitNo==ANAND_BAD_CHAIN_UNIT) return flGeneralFailure;
status = foldUnit(&vol,virtualUnitNo,FL_NORMAL_FOLDING); switch(status) { case flOK: /* Try to make sure that there are at least 2 free units */ if(pVol->freeUnits < 2) { DEBUG_PRINT(("foldBestChains : Folding success, but need more units.\r\n")); continue; } break; case flCanNotFold: DEBUG_PRINT(("foldBestChains : Failed folding, mark as unavailable and try folding another\r\n")); setUnavail(vol.virtualUnits[virtualUnitNo]); *unitNo = ANAND_NO_UNIT; continue; default: DEBUG_PRINT(("foldBestChains : ERROR - Failed folding, with status diffrent then flCanNotFold.\r\n")); return status; } } else /* All remaining chains have single unit */ {
if (frozenCandidate == ANAND_NO_UNIT) /* Simply no chain larger then 1 */ { if(*unitNo == ANAND_NO_UNIT) /* Not even 1 unit was folded */ { DEBUG_PRINT(("foldBestChains : Failed - not enough units on flash.\r\n")); return flNotEnoughMemory; } else /* Aleady freed one unit - simply tried to get */ { return flOK; } } } break; } /* End folding tries loop */
/**************************************************************/ /* Unfreeze all frozen units , and fold them using freed unit */ /**************************************************************/
if (frozenCandidate != ANAND_NO_UNIT) /* At least one unit was frozen */ { DEBUG_PRINT(("foldBestChains : Found a frozen unit.\r\n")); /* find free unit to be appended */ if(*unitNo==ANAND_NO_UNIT) /* No unit was folded */ { DEBUG_PRINT(("foldBestChains : No free unit was found so far, so search for one.\r\n"));
if(vol.freeUnits) /* There are free units */ { ANANDUnitNo originalUnit = vol.roverUnit; do { if (++vol.roverUnit >= vol.noOfUnits) vol.roverUnit = 0;
if (vol.physicalUnits[vol.roverUnit] == ANAND_UNIT_FREE) { /* found a free unit, if not erased, */ if (formatUnit(&vol,vol.roverUnit,UNIT_TAILER_OFFSET_2) != flOK) continue; /* this unit is bad, find another */
*unitNo = vol.roverUnit; DEBUG_PRINT(("foldBestChains : Found a free unit for folding not in place.\r\n")); break; } }while (vol.roverUnit != originalUnit); } if(*unitNo==ANAND_NO_UNIT) /* No unit was found */ { /* Force folding of the last frozen unit - Loose data */ DEBUG_PRINT(("foldBestChains : Will force folding on Frozen candidate\r\n")); *unitNo = firstInChain(&vol,vol.virtualUnits[frozenCandidate],NULL); if(*unitNo==ANAND_BAD_CHAIN_UNIT) return flGeneralFailure; createUnitCount(&vol,frozenCandidate); status = foldUnit(&vol,frozenCandidate,FL_FORCE_FOLDING); if(status!= flOK) return status; } }
for (u=0 ; u < vol.noOfVirtualUnits ; u++) /* Loop over units and unfreeze */ { if(vol.virtualUnits[u] == ANAND_NO_UNIT) continue; if(isAvailable(vol.virtualUnits[u])) continue; createUnitCount(&vol,u); DEBUG_PRINT(("foldBestChains : Now free all frozen units.\r\n")); /* If unit is unavailable append newly found unit to chain and fold */ checkStatus(getUnitData(&vol,vol.virtualUnits[u],&newVirtualUnitNo, &prevUnitNo,&ANAC,&NAC,&parityPerField)); /* check if unit is valid */ if((badParityResult(parityPerField)) || (newVirtualUnitNo != u)) return flGeneralFailure; /* Remember the appended unit */ newestUnit = *unitNo; /* Remember oldest unit to return as new allocated unit */ *unitNo = firstInChain(&vol,vol.virtualUnits[u],NULL); /* Erase the erase mark and move erase count to offset 6K */ checkStatus(formatUnit(&vol,newestUnit,UNIT_TAILER_OFFSET_2)); checkStatus(assignUnit(&vol,newestUnit,u,ANAC,NAC)); status = foldUnit(&vol,u,FL_NOT_IN_PLACE); if(status != flOK) return status; } } return flOK;}
/*----------------------------------------------------------------------*//* a l l o c a t e U n i t *//* *//* Find a free unit to allocate, erase it if necessary. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Receives the physical number of the allocated *//* unit *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus allocateUnit(Bnand vol, ANANDUnitNo *unitNo){ ANANDUnitNo originalUnit = vol.roverUnit; FLStatus status; dword eraseCount; word eraseMark;
if (vol.freeUnits < 2) { status = foldBestChain(&vol,unitNo); /* make free units by folding the best chain */ if(status != flNotEnoughMemory) return status;
DEBUG_PRINT(("Debug: Using last free unit of the media.\r\n")); }
do { if (++vol.roverUnit >= vol.noOfUnits) vol.roverUnit = 0;
if (vol.physicalUnits[vol.roverUnit] == ANAND_UNIT_FREE) { /* found a free unit, if not erased, */
status = getUnitTailer(&vol,vol.roverUnit,&eraseMark,&eraseCount,UNIT_TAILER_OFFSET); if(status != flOK) return status; if (eraseMark != ERASE_MARK) { if (formatUnit(&vol,vol.roverUnit,UNIT_TAILER_OFFSET) != flOK) continue; /* this unit is bad, find another */ } *unitNo = vol.roverUnit; return flOK; } } while (vol.roverUnit != originalUnit);
return foldBestChain(&vol,unitNo); /* make free units by folding the best chain */}
/*----------------------------------------------------------------------*//* c h e c k F o l d i n g *//* *//* Check and complete a failed folding operation. *//* *//* Parameters: *//* foldStatus : Pointer identifying drive *//* virtualUnitNo : Virtual unit number of the first unit in *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus checkFolding(Bnand vol,FLStatus foldStatus,ANANDUnitNo virtualUnitNo){ ANANDUnitNo newVirtualUnitNo, prevUnitNo , dummyUnitNo; byte ANAC,NAC,parityPerField;
if(foldStatus == flCanNotFold) { DEBUG_PRINT(("checkFolding : Perform folding not in place\r\n"));
/* Get a new unit for extending the virtual unit */ checkStatus(allocateUnit(&vol,&dummyUnitNo)); checkStatus(getUnitData(&vol,vol.virtualUnits[virtualUnitNo],&newVirtualUnitNo, &prevUnitNo,&ANAC,&NAC,&parityPerField)); if((newVirtualUnitNo!=virtualUnitNo)|| (badParityResult(parityPerField))) { return flGeneralFailure; }
#ifdef ENVIRONMENT_VARS
/* Prepare NAC */ if(NAC>=MAX_UNIT_CHAIN) NAC=MAX_UNIT_CHAIN-1;#endif /* ENVIRONMENT_VARS */
checkStatus(assignUnit(&vol,dummyUnitNo,virtualUnitNo,ANAC,NAC)); foldStatus = foldUnit(&vol,virtualUnitNo,FL_FORCE_FOLDING); } return foldStatus;}
/*----------------------------------------------------------------------*//* a p p l y W e a r l e v e l i n g *//* *//* Try to extend the current vurtial chain in order to force static *//* files wear leveling. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus applyWearleveling(Bnand vol){ ANANDUnitNo replacementUnitNo,newVirtualUnitNo; ANANDUnitNo startUnit,curUnit; FLStatus status; byte NAC,ANAC,parityPerField;
/* Increament wear leveling counter */ vol.wearLevel.currUnit++; if(vol.wearLevel.currUnit>=vol.noOfVirtualUnits) vol.wearLevel.currUnit=0;
/****************************************************/ /* Searching for a candidate virtual unit to extend */ /****************************************************/
startUnit = vol.wearLevel.currUnit; for(curUnit = startUnit ; vol.virtualUnits[curUnit] == ANAND_NO_UNIT;curUnit++) { if(curUnit>=vol.noOfVirtualUnits) curUnit = 0; if(startUnit == curUnit) break; }
if(startUnit == curUnit) /* the media is empty*/ { return flOK; }
vol.wearLevel.currUnit = curUnit; /* Store last leveld unit */
/***************************************************************************/ /* Now fold the virtual chain. (if a single unit chain add before folding) */ /***************************************************************************/
if(vol.physicalUnits[vol.virtualUnits[curUnit]] & FIRST_IN_CHAIN) /* chain is 1 unit long */ { /* This is a one unit chain, so we have to add a unit before folding */
status = allocateUnit(&vol,&replacementUnitNo); /* Find unit to append */ if(status != flOK) return status;
if(vol.virtualUnits[curUnit] == ANAND_NO_UNIT) { /* We did folding for the very same unit and now virtual unit is FREE */ vol.freeUnits--; return flOK; }
/* Get previous unit information (ANAC and NAC) */ status = getUnitData(&vol,vol.virtualUnits[curUnit],&newVirtualUnitNo, &replacementUnitNo, &ANAC,&NAC,&parityPerField); if(status != flOK) return status;
if(badParityResult(parityPerField)) /* check if unit is valid */ return flGeneralFailure;
if(newVirtualUnitNo != curUnit) /* Problem with RAM tables */ { return flGeneralFailure; }
status = assignUnit(&vol,replacementUnitNo,curUnit,ANAC,NAC); if(status != flOK) return status; } /* Perform folding and verify operation */ status = foldUnit(&vol,curUnit,FL_NORMAL_FOLDING); if (status != flOK) return checkFolding(&vol,status,curUnit); return flOK;}
#endif /* FL_READ_ONLY */
/*----------------------------------------------------------------------*//* m a p S e c t o r *//* *//* Maps and returns location of a given sector no. *//* NOTE: This function is used in place of a read-sector operation. *//* *//* A one-sector cache is maintained to save on map operations. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorNo : Sector no. to read *//* physAddress : Optional pointer to receive sector address *//* *//* Returns: *//* Pointer to physical sector location. NULL returned if sector *//* does not exist. *//*----------------------------------------------------------------------*/
static const void FAR0 *mapSector(Bnand vol, SectorNo sectorNo, CardAddress *physAddress){ FLStatus status; FLBoolean lastOK; /* Dummy variable */ byte chainBound;
if ((sectorNo != vol.mappedSectorNo) || (vol.flash->socket->remapped) || (vol.buffer->owner == &vol) ) { vol.flash->socket->remapped = TRUE; vol.mappedSector = NULL; vol.mappedSectorAddress = ANAND_UNASSIGNED_ADDRESS; if (sectorNo < vol.virtualSectors) /* While EDC error on sector read */ { for (chainBound=0 ; (chainBound < DOUBLE_MAX_UNIT_CHAIN) ; chainBound++) { vol.mappedSectorAddress = virtual2Physical(&vol,sectorNo,vol.mappedSectorAddress,&lastOK); switch(vol.mappedSectorAddress) { case ANAND_UNASSIGNED_ADDRESS: case ANAND_BAD_CHAIN_ADDRESS: vol.mappedSector = NULL; /* no such sector */ break;
default: vol.mappedSector = inftlBuffer; status = vol.flash->read(vol.flash,vol.mappedSectorAddress,inftlBuffer,SECTOR_SIZE,EDC); if (status == flOK) break; if (status != flDataError) return dataErrorToken; continue; } break; } if (chainBound >= DOUBLE_MAX_UNIT_CHAIN) return dataErrorToken;
/* Store sector for next mapping operation */ vol.mappedSectorNo = sectorNo; /* Sector number */ vol.buffer->owner = &vol; /* Partition */ vol.flash->socket->remapped = FALSE; /* Valid */ } }
if (physAddress) *physAddress = vol.mappedSectorAddress;
return vol.mappedSector;}
/*----------------------------------------------------------------------*//* r e a d 2 S e c t o r s *//* *//* read content of a set of consecutive sectors. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorNo : Sector no. to read *//* dest : pointer to buffer to read *//* sectorCount : # of sectors to read ( up to 2 ) *//* *//* Returns: *//* status of the read operaton *//*----------------------------------------------------------------------*/
static FLStatus read2Sectors(Bnand vol, SectorNo sectorNo, byte FAR1 *dest, SectorNo sectorCount)
{ CardAddress mappedSectorAddress[2]; FLStatus status = flOK; FLStatus retStatus = flOK; word i; byte chainBound; FLBoolean lastOK; /* Dummy variable */
if ((sectorNo+sectorCount-1) >= vol.virtualSectors) { return flSectorNotFound; /* Out of bounds */ } else { /* find physical location of the 2 sectors */ for(i=0;i<sectorCount;i++) { mappedSectorAddress[i] = virtual2Physical(&vol,sectorNo+i, ANAND_UNASSIGNED_ADDRESS,&lastOK); /* If chain is brocken report sector not found */ if(mappedSectorAddress[i] == ANAND_BAD_CHAIN_ADDRESS) mappedSectorAddress[i] = ANAND_UNASSIGNED_ADDRESS; }
/* When possible read the 2 sectors together */ if((sectorCount==2)&& ( mappedSectorAddress[1] > mappedSectorAddress[0] ) && ((mappedSectorAddress[1] - mappedSectorAddress[0])==SECTOR_SIZE) && ( mappedSectorAddress[0] != ANAND_UNASSIGNED_ADDRESS ) && ( mappedSectorAddress[1] != ANAND_UNASSIGNED_ADDRESS )) { if (vol.flash->read(vol.flash,mappedSectorAddress[0], dest,SECTOR_SIZE<<1,EDC) == flOK) { vol.sectorsRead+=2; return flOK; } }
/* Sectors are not together */ for (i=0;i<sectorCount;i++,dest = (byte FAR1 *)flAddLongToFarPointer(dest,SECTOR_SIZE)) { /* While EDC error on sector read - keep reading from older unit */ for (chainBound=0 ; (chainBound < DOUBLE_MAX_UNIT_CHAIN) ; chainBound++) { if (mappedSectorAddress[i] == ANAND_UNASSIGNED_ADDRESS) { tffsset(dest,0,SECTOR_SIZE); retStatus = flSectorNotFound; break; } else { status=vol.flash->read(vol.flash,mappedSectorAddress[i], dest,SECTOR_SIZE,EDC); vol.sectorsRead++; if (status == flOK) { break; } else if (status == flDataError) { mappedSectorAddress[i] = virtual2Physical(&vol,sectorNo+i,mappedSectorAddress[i],&lastOK); /* If chain is brocken report sector not found */ if(mappedSectorAddress[i]==ANAND_BAD_CHAIN_ADDRESS) mappedSectorAddress[i] = ANAND_UNASSIGNED_ADDRESS; } else { return status; } } } if (chainBound >= DOUBLE_MAX_UNIT_CHAIN) return status; } } return retStatus;}
/*----------------------------------------------------------------------*//* r e a d S e c t o r s *//* *//* Read content of a set of consecutive sectors. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorNo : Sector no. to read *//* dest : pointer to buffer to read *//* sectorCount : # of sectors to read *//* *//* Returns: *//* status of the read operaton *//* *//*----------------------------------------------------------------------*/
static FLStatus readSectors(Bnand vol, SectorNo sectorNo, void FAR1 *dest, SectorNo sectorCount){ byte FAR1* curDest; SectorNo lastSector = 0; FLStatus retStatus = flOK; FLStatus status; SectorNo i;
#ifdef SCATTER_GATHER
curDest = *(byte FAR1 **)dest;#else
curDest = (byte FAR1 *)dest;#endif /* SCATTER_GATHER */
if ((sectorNo+sectorCount) > vol.virtualSectors) { return flSectorNotFound; /* Out of bounds */ }
/****************************************************************/ /* Read first sector if it's only one or it has odd address */ /****************************************************************/ if(((sectorNo & 1)!=0)||(sectorCount==1)) { status=read2Sectors(&vol, sectorNo, curDest,1); if (status != flOK) { if (status == flSectorNotFound) { retStatus = flSectorNotFound; } else { return status; } } if(sectorCount==1) return status; sectorNo++; sectorCount--;#ifdef SCATTER_GATHER
dest = (byte FAR1 **)dest+1;#else
dest = flAddLongToFarPointer(dest,SECTOR_SIZE);#endif /* SCATTER_GATHER */
}
if(((sectorNo+sectorCount-1) & 1)==0) /* keep last sector if it has odd address*/ lastSector=sectorNo+sectorCount-1;
/*****************************************/ /* Read pairs of consequtive sectors */ /*****************************************/
#ifdef SCATTER_GATHER
curDest = multiSectorBuf[vol.socketNo];#else
curDest = (byte FAR1 *)dest;#endif /* SCATTER_GATHER */
for(i=0;i<((sectorCount>>1)<<1);i+=2) /* read pair of sectors*/ { status=read2Sectors(&vol,sectorNo+i, curDest,2); if (status != flOK) { if (status == flSectorNotFound) { retStatus = flSectorNotFound; } else { return status; } }#ifdef SCATTER_GATHER
/* copy from temporary buffer to user scattered buffers */ tffscpy(*(byte FAR1 **)dest,curDest,SECTOR_SIZE); tffscpy(*((byte FAR1 **)dest+1),&(curDest[SECTOR_SIZE]),SECTOR_SIZE); dest = (byte FAR1 **)dest+2;#else
curDest=(byte FAR1 *)flAddLongToFarPointer(curDest,(SECTOR_SIZE<<1));#endif /* SCATTER_GATHER */
}
/********************************/ /* Read last uneven sectors */ /********************************/
#ifdef SCATTER_GATHER
curDest = *(byte FAR1 **)dest;#endif /* SCATTER_GATHER */
if(lastSector!=0) /* read last sector */ { checkStatus(read2Sectors(&vol,lastSector, curDest,1)); } return retStatus;}
#ifndef FL_READ_ONLY
/*----------------------------------------------------------------------*//* a l l o c a t e A n d W r i t e S e c t o r s *//* *//* Write to sectorNo. if necessary, allocate a free sector first. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorNo : Virtual sector no. to write *//* fromAddress : Address of sector data. *//* howMany : Number of sectors to write. *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus allocateAndWriteSectors(Bnand vol, SectorNo sectorNo, void FAR1 *fromAddress,word howMany){ ANANDUnitNo newVirtualUnitNo, newPrevUnitNo; ANANDUnitNo virtualUnitNo = (ANANDUnitNo)(sectorNo >> vol.sectorsPerUnitBits); ANANDUnitNo lastUnitNo = vol.virtualUnits[virtualUnitNo]; ANANDUnitNo unitNo,prevUnitNo; FLStatus status; byte ANAC,NAC,parityPerField; word unitOffset = (word)((sectorNo & vol.sectorsPerUnitMask) << SECTOR_SIZE_BITS); word chainBound = 0; word foundSoFar = 0; word newSect = howMany; byte sectorFlags; FLBoolean firstUnitFound = FALSE; FLBoolean secondUnitFound = FALSE; FLBoolean noneFreeFound = FALSE; ANANDUnitNo commonPrevUnitNo = ANAND_NO_UNIT; ANANDUnitNo commonUnitNo = lastUnitNo;
/************************************/ /* Find a unit to write this sector */ /************************************/
unitNo = lastUnitNo; /* newest unit that either sectors is not FREE */ prevUnitNo = ANAND_NO_UNIT; /* oldest unit with place for required sectors */
while (unitNo != ANAND_NO_UNIT) { if(firstUnitFound == FALSE) { sectorFlags = getSectorFlags(&vol,unitBaseAddress(vol,unitNo) + unitOffset);
switch(sectorFlags) { case SECTOR_USED: newSect--; /* Sector exists - do not increament counter */ case SECTOR_DELETED: foundSoFar++; firstUnitFound = TRUE; case SECTOR_IGNORE: if(noneFreeFound == FALSE) /* Store none free space */ { commonPrevUnitNo = prevUnitNo; commonUnitNo = unitNo; noneFreeFound = TRUE; } default: break; } } if(howMany==2) { if(secondUnitFound == FALSE) { sectorFlags = getSectorFlags(&vol,unitBaseAddress(vol,unitNo) + unitOffset+512);
switch(sectorFlags) { case SECTOR_USED: newSect--; /* Sector exists - do not increament counter */ case SECTOR_DELETED: foundSoFar++; secondUnitFound = TRUE; case SECTOR_IGNORE: if(noneFreeFound == FALSE) /* Store none free space */ { commonPrevUnitNo = prevUnitNo; commonUnitNo = unitNo; noneFreeFound = TRUE; } default: break; } } }
if(foundSoFar == howMany) /* Both sectors have been found */ break;
/* Both sectors are FREE */ prevUnitNo = unitNo; unitNo = getPrevUnit(&vol,unitNo,virtualUnitNo); if(unitNo == ANAND_BAD_CHAIN_UNIT) return flGeneralFailure; chainBound++; if(chainBound >= DOUBLE_MAX_UNIT_CHAIN) return flGeneralFailure; } /* End of - go over chain while */ if(noneFreeFound == TRUE) { prevUnitNo = commonPrevUnitNo; /* Common free unit for both sectors */ unitNo = commonUnitNo; /* First unit with wither used sector */ }
if ((prevUnitNo == ANAND_NO_UNIT)) /* No place to write sectors */ { if(unitNo!=ANAND_NO_UNIT) /* Unit already exists */ { status = getUnitData(&vol,unitNo,&newVirtualUnitNo, &newPrevUnitNo,&ANAC,&NAC,&parityPerField); if (status != flOK) return status;
if(badParityResult(parityPerField)) /* check if unit is valid */ return flGeneralFailure;
/* Check if chain length is graeter then allowed, but remember */ /* that the first unit of the chain has invalid NAC. */ if ((NAC>=MAX_UNIT_CHAIN) && ((vol.physicalUnits[unitNo]&FIRST_IN_CHAIN)!=FIRST_IN_CHAIN)) { status = foldUnit(&vol,virtualUnitNo,FL_NORMAL_FOLDING); if (status != flOK) { status = checkFolding(&vol,status,virtualUnitNo); if (status != flOK) return status; } } } status = allocateUnit(&vol,&prevUnitNo); if (status != flOK) return status;
unitNo = vol.virtualUnits[virtualUnitNo];
if(unitNo==ANAND_NO_UNIT) /* Free virtual unit */ { /* New Virtual unit. reinitialize NAC,ANAC and sector count */ ANAC=NAC=0; /* Force FIRST_IN_CHAIN and sector count to 0. it must be done */ /* after assignUnit, so that assign unit will not change it. */ unitNo=ANAND_NO_UNIT; } else /* Read unit data to set ANAC , NAC and sector count */ { status = getUnitData(&vol,unitNo,&newVirtualUnitNo, &newPrevUnitNo, &ANAC,&NAC,&parityPerField); if (status != flOK) return status;
/* Check if unit is valid */ if((badParityResult(parityPerField)) || /* Bad unit data */ (newVirtualUnitNo!=virtualUnitNo)) /* Bad virtual unit no */ return flGeneralFailure;
if(vol.physicalUnits[unitNo]&FIRST_IN_CHAIN) NAC=1; }
status = assignUnit(&vol,prevUnitNo,virtualUnitNo,ANAC,NAC); if (status != flOK) return status;
if(unitNo==ANAND_NO_UNIT) /* First physical unit of chain */ { vol.physicalUnits[prevUnitNo]=FIRST_IN_CHAIN; } lastUnitNo = vol.virtualUnits[virtualUnitNo]; unitNo=prevUnitNo; } else { unitNo=prevUnitNo; }
/***********************************************/ /* Area has been allocated , now write sectors */ /***********************************************/
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
vol.curSectorWrite = sectorNo; /* Store virtual sector Number */#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
status = writeAndCheck(&vol,unitBaseAddress(vol,unitNo) + unitOffset,fromAddress,EDC,howMany); if (status != flOK) return status;
/* Take care of sector count */ if (vol.countsValid > virtualUnitNo) { lastUnitNo=vol.virtualUnits[virtualUnitNo];
if (countOf(lastUnitNo) + newSect <= UNIT_MAX_COUNT) { vol.physicalUnits[lastUnitNo]+=newSect; /* Increment block count */ } else /* Should never happen , but sector count is not correct */ { return flGeneralFailure; } } return flOK;}
/*----------------------------------------------------------------------*//* w r i t e 2 S e c t o r s *//* *//* Writes up to 2 consecutive sector. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorNo : Virtual sector no. to write *//* fromAddress : Data to write *//* sectorCount : No of sectors to write *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus write2Sectors(Bnand vol, SectorNo sectorNo, void FAR1 *fromAddress,word sectorCount){ FLStatus status; byte i;
if ((sectorNo+sectorCount-1) >= vol.virtualSectors) return flSectorNotFound;
/* Check if cached sector is still valid */ if ((sectorNo == vol.mappedSectorNo ) && (sectorNo+sectorCount == vol.mappedSectorNo + sectorCount - 1) ) vol.flash->socket->remapped = TRUE;
#ifdef ENVIRONMENT_VARS
if(flPolicy[vol.socketNo][vol.flash->socket->curPartition]==FL_DEFAULT_POLICY)#endif /* ENVIRONMENT_VARS */
if((vol.wearLevel.currUnit!=ANAND_NO_UNIT)) { vol.wearLevel.alarm++; if(vol.wearLevel.alarm>=WLnow) { vol.wearLevel.alarm = 0; status = applyWearleveling(&vol); if (status != flOK) return status; } } status = flWriteFault; vol.sectorsWritten += sectorCount;
/* Try writing the sector up to 4 times before reporting an error */ for (i = 0; (i < 4) && (status == flWriteFault); i++) status = allocateAndWriteSectors(&vol,sectorNo,fromAddress,sectorCount);
return status;}
/*----------------------------------------------------------------------*//* w r i t e S e c t o r *//* *//* Writes a sector. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorNo : Virtual sector no. to write *//* fromAddress : Data to write *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus writeSector(Bnand vol, SectorNo sectorNo, void FAR1 *fromAddress){ checkStatus(discardQuickMountInfo(&vol)); return write2Sectors( &vol, sectorNo, fromAddress, ((SectorNo)1) );}
#ifdef ENVIRONMENT_VARS
/*----------------------------------------------------------------------*//* w r i t e F u l l U n i t *//* *//* Write set of consecutive sectors that occupies a full unit. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorNo : Sector no. to write *//* fromAddress : Pointer to buffer to write *//* *//* Returns: *//* status of the write operaton *//* *//*----------------------------------------------------------------------*/
static FLStatus writeFullUnit(Bnand vol, SectorNo sectorNo, void FAR1 *fromAddress){ ANANDUnitNo virtualUnitNo = (ANANDUnitNo)(sectorNo >> vol.sectorsPerUnitBits); ANANDUnitNo lastUnitNo,newVirtualUnitNo; ANANDUnitNo unitNo,prevUnitNo; FLStatus status; byte ANAC,NAC,parityPerField;
if(virtualUnitNo==ANAND_NO_UNIT) /* Sanity check */ return flGeneralFailure;
status = allocateUnit(&vol,&unitNo); if(status != flOK) return status;
lastUnitNo = vol.virtualUnits[virtualUnitNo]; if(lastUnitNo == ANAND_NO_UNIT) { /* First time we write to this VU */ ANAC = NAC = 0; } else { status = getUnitData(&vol,lastUnitNo,&newVirtualUnitNo, &prevUnitNo,&ANAC,&NAC,&parityPerField); if(status != flOK) return status;
/* check if unit is valid */ if((badParityResult(parityPerField) ) || (virtualUnitNo != newVirtualUnitNo) ) { DEBUG_PRINT(("\nwriteFullUnit: Found a brocken chain\r\n")); return flGeneralFailure; } /* Update NAC */ if(vol.physicalUnits[lastUnitNo]&FIRST_IN_CHAIN) { NAC = 1; /* One unit chain , set proper NAC */ } else { if(NAC>=MAX_UNIT_CHAIN) { status = foldUnit(&vol,virtualUnitNo,FL_NORMAL_FOLDING); if (status != flOK) { status = checkFolding(&vol,status,virtualUnitNo); if(status != flOK) return status; } if(vol.virtualUnits[virtualUnitNo]==ANAND_NO_UNIT) { /* Unit had no used sectors and was erased */ lastUnitNo = ANAND_NO_UNIT; ANAC = NAC = 0; } else /* After folding must be 1 unit chain */ { NAC = 1; } } } } status = assignUnit(&vol,unitNo,virtualUnitNo,ANAC,NAC); if(status != flOK) return status;
setUnitCount(unitNo,vol.sectorsPerUnit);
if(lastUnitNo==ANAND_NO_UNIT) vol.physicalUnits[unitNo] |= FIRST_IN_CHAIN; vol.virtualUnits[virtualUnitNo] = unitNo;
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
/* Turn verify write off since this is a new unit */ vol.curSectorWrite = 0; /* Store virtual sector Number */#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
#ifdef SCATTER_GATHER
/* Write in pairs (NAC is used as a simple index) */ for (NAC=0;NAC<vol.sectorsPerUnit;NAC+=2) { tffscpy(multiSectorBuf[vol.socketNo], *((byte FAR1 **)fromAddress+NAC),SECTOR_SIZE); tffscpy(multiSectorBuf[vol.socketNo]+SECTOR_SIZE, *((byte FAR1 **)fromAddress+NAC+1),SECTOR_SIZE); status = writeAndCheck(&vol,unitBaseAddress(vol,unitNo)+ (NAC<<(SECTOR_SIZE_BITS+1)), multiSectorBuf[vol.socketNo],EDC,2); if(status != flOK) return status; } return status;#else
return writeAndCheck(&vol,unitBaseAddress(vol,unitNo),fromAddress, EDC,vol.sectorsPerUnit);#endif /* SCATTER_GATHER */
}
#endif /* ENVIRONMENT_VARS */
/*----------------------------------------------------------------------*//* w r i t e M u l t i S e c t o r *//* *//* Write set of consecutive sectors *//* *//* Note : Special care was taken for SCATTER_GATHER option. In this *//* user buffer is given as an array of 512 bytes buffers and not *//* as a single large (sectors*512 Bytes) array. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorNo : Sector no. to write *//* fromAddress : pointer to buffer to write *//* sectorCount : # of sectors to write *//* *//* Returns: *//* status of the write operaton *//* *//*----------------------------------------------------------------------*/
static FLStatus writeMultiSector(Bnand vol, SectorNo sectorNo, void FAR1 *fromAddress,SectorNo sectorCount){ byte FAR1* curAddr = (byte FAR1 *)fromAddress; SectorNo lastSector; SectorNo i; FLStatus status = flOK;
/* Check if sector is in virtual size boundries */ if (sectorNo + sectorCount > vol.virtualSectors) return flSectorNotFound;
checkStatus(discardQuickMountInfo(&vol));
/*****************************************************/ /* Start from an odd address or only a one sector */ /*****************************************************/
if(((sectorNo & 1)!=0)||(sectorCount==1)) { status=write2Sectors(&vol, sectorNo,#ifdef SCATTER_GATHER
*(char FAR1 **)#endif /* SCATTER_GATHER */
fromAddress,1);
if((sectorCount == 1 ) || /* finished (only 1 sector) */ (status != flOK) ) /* or operation failed */ return status;
sectorNo++; sectorCount--; /* Increament user buffer */#ifdef SCATTER_GATHER
fromAddress=(void FAR1 *)((char FAR1 **)fromAddress+1);#else
fromAddress=(byte FAR1 *)flAddLongToFarPointer(fromAddress,SECTOR_SIZE);#endif /* SCATTER_GATHER */
}
/************************************************/ /* Write all the sequantial pair of sectors. */ /************************************************/
if(((sectorNo+sectorCount-1) & 1)==0) { /* Keep last sector since it can not be written as a pair */ lastSector = sectorNo+sectorCount-1; } else { lastSector = 0; /* All sectors can be written in pairs */ }
sectorCount = (sectorCount>>1)<<1; /* round down to even no' of sectors */
for(i=0;i<sectorCount;i+=2) /* write pair of sectors*/ {#ifdef SCATTER_GATHER
curAddr = (void FAR1 *)((byte FAR1 **)fromAddress+i);#else
curAddr=(byte FAR1 *)flAddLongToFarPointer(fromAddress,SECTOR_SIZE*i);#endif /* SCATTER_GATHER */
#ifdef ENVIRONMENT_VARS
if((flPolicy[vol.socketNo][vol.flash->socket->curPartition]==FL_COMPLETE_ASAP) && /* sector is unit aligned */ (((sectorNo + i ) & vol.sectorsPerUnitMask) == 0) && /* enough sectors to fill a unit */ ( (sectorCount - i ) >= vol.sectorsPerUnit )) { status = writeFullUnit(&vol,sectorNo+i,curAddr); if(status != flOK) return status; i += vol.sectorsPerUnit-2; continue; }#endif /* ENVIRONMENT_VARS */
#ifdef SCATTER_GATHER
/* Copy scattered buffers to internal 1k buffer */ tffscpy(multiSectorBuf[vol.socketNo],*((char FAR1 **)curAddr),SECTOR_SIZE); tffscpy(multiSectorBuf[vol.socketNo]+SECTOR_SIZE,*((char FAR1 **)curAddr+1),SECTOR_SIZE); curAddr = multiSectorBuf[vol.socketNo];#endif /* SCATTER_GATHER */
status = write2Sectors(&vol,sectorNo+i, curAddr,2); if(status != flOK) return status; }
/*********************************************/ /* Write the last sector (not full page). */ /*********************************************/
if(lastSector!=0) /* write last sector */ {#ifdef SCATTER_GATHER
fromAddress = (void FAR1 *)((byte FAR1 **)fromAddress+i);#else
fromAddress = (void FAR1 *)flAddLongToFarPointer(fromAddress,SECTOR_SIZE*i);#endif /* SCATTER_GATHER */
status=write2Sectors(&vol, lastSector,#ifdef SCATTER_GATHER
*(char FAR1 **)#endif /* SCATTER_GATHER */
fromAddress,1); } return status;}
/*----------------------------------------------------------------------*//* d e l e t e S e c t o r *//* *//* Marks contiguous sectors as deleted. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorNo : First sector no. to delete *//* noOfSectors : No. of sectors to delete *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus deleteSector(Bnand vol, SectorNo sectorNo, SectorNo noOfSectors){ CardAddress sectorAddress; SectorNo iSector; ANANDUnitNo virtualUnitNo; ANANDUnitNo currUnitNo; byte sectorFlags[2] = {SECTOR_DELETED,SECTOR_DELETED}; FLBoolean lastOK; /* Dummy variable */
if (sectorNo + noOfSectors > vol.virtualSectors) return flSectorNotFound;
checkStatus(discardQuickMountInfo(&vol));
for (iSector = 0; iSector < noOfSectors; iSector++, sectorNo++, vol.sectorsDeleted++) { sectorAddress = virtual2Physical(&vol,sectorNo,ANAND_UNASSIGNED_ADDRESS,&lastOK); switch(sectorAddress) { case ANAND_UNASSIGNED_ADDRESS: continue;
case ANAND_BAD_CHAIN_ADDRESS: return flGeneralFailure;
default: virtualUnitNo = (ANANDUnitNo)(sectorNo >> vol.sectorsPerUnitBits);#ifdef NFTL_CACHE
setSectorFlagsCache(&vol, sectorAddress, SECTOR_DELETED);#ifdef ENVIRONMENT_VARS
if (((flMarkDeleteOnFlash == FL_ON) && (flPolicy[vol.socketNo][vol.flash->socket->curPartition] != FL_COMPLETE_ASAP)) || (vol.scache == NULL))#endif /* ENVIRONMENT_VARS */
#endif /* NFTL_CACHE */
{
#ifndef NT5PORT
checkStatus(vol.flash->write(vol.flash, sectorAddress + SECTOR_DATA_OFFSET, §orFlags, sizeof sectorFlags, EXTRA));#else /*NT5PORT*/
vol.flash->write(vol.flash, sectorAddress + SECTOR_DATA_OFFSET, sectorFlags, sizeof sectorFlags, EXTRA);#endif /*NT5PORT*/
} currUnitNo = vol.virtualUnits[virtualUnitNo];
if (vol.countsValid > virtualUnitNo) { if (countOf(currUnitNo) > 0) { vol.physicalUnits[currUnitNo]--; /* Decrement block count */ } else { DEBUG_PRINT(("delete sector : Unit does not apear to have any sectors\r\n")); return flGeneralFailure; } } } /* End sectorAddress switch */ } /* End delete sector loop */
return flOK;}
#ifdef DEFRAGMENT_VOLUME
/*----------------------------------------------------------------------*//* d e f r a g m e n t *//* *//* Performs unit allocations to arrange a minimum number of writable *//* sectors. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorsNeeded : Minimum required sectors *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus defragment(Bnand vol, long FAR2 *sectorsNeeded){ ANANDUnitNo dummyUnitNo; ANANDUnitNo firstFreeUnit = ANAND_NO_UNIT; FLBoolean firstRound = TRUE; FLStatus status = flOK;
checkStatus(discardQuickMountInfo(&vol));
if( (*sectorsNeeded) == -1 ) /* fold single best chain */ { status = foldBestChain(&vol,&dummyUnitNo); if( (status != flOK) && (vol.freeUnits == 0) ) return status; *sectorsNeeded = (long)vol.freeUnits << vol.sectorsPerUnitBits; return flOK; }
/* Perform folding until the required number of sectors is achived */
while (((long)vol.freeUnits << vol.sectorsPerUnitBits) < *sectorsNeeded) { status = foldBestChain(&vol,&dummyUnitNo); /* make more free units */ if(status != flOK) break; }
*sectorsNeeded = (long)vol.freeUnits << vol.sectorsPerUnitBits;
return status;}
#endif /* DEFRAGMENT */
#endif /* FL_READ_ONLY */
/*----------------------------------------------------------------------*//* t l S e t B u s y *//* *//* Notifies the start and end of a file-system operation. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* state : FL_ON (1) = operation entry *//* FL_OFF(0) = operation exit *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus tlSetBusy(Bnand vol, FLBoolean state){ return flOK;}
/*----------------------------------------------------------------------*//* s e c t o r s I n V o l u m e *//* *//* Gets the total number of sectors in the volume *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//* Returns: *//* Number of sectors in the volume *//*----------------------------------------------------------------------*/
static SectorNo sectorsInVolume(Bnand vol){ return vol.virtualSectors;}
/*----------------------------------------------------------------------*//* p u t G e t B u f f e r *//* *//* Write \ Read a buffer to the flash from a specific flash offset *//* while making sure only good units are used. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* length : Size of the buffer (always full pages) *//* bufferPtr : Data buffer *//* flashAddr : Physcial address on the flash *//* bbt : Buffer containing BBT of the quick mount area *//* readFlag : TRUE - read data , FLASE - write data *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//* bufferPtr : Increamented data buffer *//* flashAddr : Increamented physcial address on the flash *//*----------------------------------------------------------------------*/
#ifdef QUICK_MOUNT_FEATURE
static FLStatus putGetBuffer(Bnand vol, dword length, byte FAR1** bufferPtr, CardAddress* flashAddr, byte* bbt, FLBoolean readFlag){ FLStatus status; word writeNow = 0;
while (length > 0) { writeNow = (word)TFFSMIN(length,(((*flashAddr >> vol.unitSizeBits)+1) << vol.unitSizeBits) - *flashAddr); if (readFlag) { status = vol.flash->read(vol.flash,*flashAddr,*bufferPtr, (dword)writeNow,EDC); }#ifndef FL_READ_ONLY
else { status = vol.flash->write(vol.flash,*flashAddr,*bufferPtr, (dword)writeNow,EDC); }#endif /* FL_READ_ONLY */
if(status != flOK) return status;
length -= writeNow; *flashAddr += writeNow; *bufferPtr = BYTE_ADD_FAR(*bufferPtr,writeNow); NextGoodUnit(*flashAddr,bbt); } return flOK;}
/*----------------------------------------------------------------------*//* q u i c k M o u n t D a t a *//* *//* Saves or restores the quick mount data to and from the flash *//* *//* Note : the data is saved according to the mechines architecture. Big *//* Indien is not converted into little indien like the rest of *//* of INFTL flash data structure *//* *//* The following will be saved : *//* *//* 1) physical Units table *//* 2) virutal Units table *//* 3) TL strucutre (Not by this routien but by its caller *//* *//* Parameters: *//* vol : Pointer identifying drive *//* readFlag : TRUE for retrieve data FALSE for writing it *//* *//* Returns: *//* flOK on success other error codes for erase\read\write failures *//* start : Unit offset (from the first unit of the *//* volume to start writting quick mount data. *//* (remember migh be bad). *//*----------------------------------------------------------------------*/
static FLStatus quickMountData(Bnand vol, FLBoolean readFlag, byte* start){ dword length; dword remainder; word partialSize; CardAddress flashAddr; FLStatus status; byte FAR1* bufferPtr = vol.physicalUnits; byte bbt[MAX_QUICK_MOUNT_UNITS]; /* Minimal bad blocks table */
/* Read bad block tabel and find the first good block of the volume */
status = vol.flash->readBBT(vol.flash,vol.firstQuickMountUnit, MAX_QUICK_MOUNT_UNITS,vol.blockMultiplierBits,bbt,FALSE); if(status != flOK) return status;
for(*start = 0 ; (*start<MAX_QUICK_MOUNT_UNITS) && (bbt[*start] != BBT_GOOD_UNIT) ; (*start)++); if (*start == MAX_QUICK_MOUNT_UNITS) { DEBUG_PRINT(("\nDebug: Too many Bad blocks in quick mount area\r\n")); return flBadBBT; } /* Skip first page for Bnand record */ flashAddr = ((CardAddress)(vol.firstQuickMountUnit + (*start)) << vol.unitSizeBits) + vol.flash->pageSize;
/* Only the full pages of physical table */
length = vol.noOfUnits * sizeof(ANANDPhysUnit); /* Physicals length */ remainder = length & (SECTOR_SIZE-1)/*vol.flash->pageSize*/; /* Last partial page */ length -= remainder; /* Round to pages */
status = putGetBuffer(&vol, length, &bufferPtr, &flashAddr,bbt,readFlag); if(status != flOK) return status;
/* Partial page of the physical table + begining of virtual table */
length = vol.noOfVirtualUnits * sizeof(ANANDUnitNo); /* Virtuals */ partialSize = (word)TFFSMIN(length,(dword)SECTOR_SIZE-remainder);
if (remainder > 0) { if (readFlag) { status = vol.flash->read(vol.flash,flashAddr , inftlBuffer, sizeof(inftlBuffer),EDC); tffscpy(bufferPtr,inftlBuffer,(word)remainder); tffscpy(vol.virtualUnits,inftlBuffer+(word)remainder,partialSize); }#ifndef FL_READ_ONLY
else { tffscpy(inftlBuffer,bufferPtr, (word)remainder); tffscpy(inftlBuffer+(word)remainder,vol.virtualUnits,partialSize); status = vol.flash->write(vol.flash,flashAddr,inftlBuffer, sizeof(inftlBuffer),EDC); }#endif /* FL_READ_ONLY */
if(status != flOK) return status;
bufferPtr = partialSize + (byte FAR1*)vol.virtualUnits; flashAddr += SECTOR_SIZE/*vol.flash->pageSize*/; NextGoodUnit(flashAddr,bbt); /* if needed check for next good unit */ } else { bufferPtr = (byte FAR1*)vol.virtualUnits; }
/* Only the full pages of virtual table */
length -= partialSize; /* Remaining virtuals */ remainder = length % SECTOR_SIZE/*vol.flash->pageSize*/; /* Last partial page */ length -= remainder; /* Round to pages */
status = putGetBuffer(&vol,length,&bufferPtr,&flashAddr,bbt,readFlag); if(status != flOK) return status;
/* Partial page of the virtual table */
if (remainder>0) { if(readFlag) { status = vol.flash->read(vol.flash,flashAddr,inftlBuffer, sizeof(inftlBuffer),EDC); tffscpy(bufferPtr , inftlBuffer,(word)remainder); }#ifndef FL_READ_ONLY
else { tffscpy(inftlBuffer , bufferPtr , (word)remainder); status = vol.flash->write(vol.flash,flashAddr,inftlBuffer, sizeof(inftlBuffer),EDC); }#endif /* FL_READ_ONLY */
} return status;}
#endif /* QUICK_MOUNT_FEATURE */
/*----------------------------------------------------------------------*//* d i s m o u n t I N F T L *//* *//* Dismount INFTL volume *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//*----------------------------------------------------------------------*/
static void dismountINFTL(Bnand vol){ DEBUG_PRINT(("\nDebug: starting INFTL dismount.\r\n"));
#if (defined(QUICK_MOUNT_FEATURE) && !defined(FL_READ_ONLY))
if ((vol.flags & QUICK_MOUNT) && (vol.firstMediaWrite == TRUE)) { savedBnand* newVol = (savedBnand*)inftlBuffer; byte start; FLStatus status;
DEBUG_PRINT(("\nDebug: with save operation of quick mount data.\r\n"));
start = vol.firstUnit - vol.firstQuickMountUnit; status = vol.flash->erase(vol.flash,(word)(vol.firstQuickMountUnit << vol.blockMultiplierBits), (word)((1 << vol.blockMultiplierBits) * start)); if (status==flOK) { vol.flags &= ~QUICK_MOUNT; /* Prevent resaving the data */ status = quickMountData(&vol, FALSE,&start); if (status == flOK) { /* Place Bnand record */
tffsset(inftlBuffer,0,sizeof(inftlBuffer)); /* Clear inftlBuffer */
/*********************************************************/ /* Convert internal volume to little indian dword fields */ /*********************************************************/
toLE4(newVol->freeUnits , vol.freeUnits ); toLE4(newVol->roverUnit , vol.roverUnit ); toLE4(newVol->countsValid , vol.countsValid ); toLE4(newVol->sectorsRead , vol.sectorsRead ); toLE4(newVol->sectorsWritten , vol.sectorsWritten ); toLE4(newVol->sectorsDeleted , vol.sectorsDeleted ); toLE4(newVol->parasiteWrites , vol.parasiteWrites ); toLE4(newVol->unitsFolded , vol.unitsFolded ); toLE4(newVol->wearLevel_1 , vol.wearLevel.alarm ); toLE4(newVol->wearLevel_2 , vol.wearLevel.currUnit); toLE4(newVol->eraseSum , vol.eraseSum ); toLE4(newVol->validate , QUICK_MOUNT_VALID_SIGN);#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
toLE4(newVol->verifiedSectorNo , vol.verifiedSectorNo);#else
toLE4(newVol->verifiedSectorNo , 0);#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
status = vol.flash->write(vol.flash,((CardAddress)(vol.firstQuickMountUnit +start))<< vol.unitSizeBits,inftlBuffer, sizeof(inftlBuffer),EDC); } if (status != flOK) DEBUG_PRINT(("Debug: ERROR writing quick mount information.\r\n")); } else /* continue with dismount */ { DEBUG_PRINT(("Debug: Error erasing quick mount information.\r\n")); } }#endif /* QUICK_MOUNT_FEATURE && not FL_READ_ONLY */
#ifdef FL_MALLOC
/* Free multi sector buffers */ if (multiSectorBufCounter[vol.socketNo] == 0) { if (multiSectorBuf[vol.socketNo] != NULL) { FL_FREE(multiSectorBuf[vol.socketNo]); multiSectorBuf[vol.socketNo] = NULL; } } if (multiSectorBufCounter[vol.socketNo] >= 0) { multiSectorBufCounter[vol.socketNo]--; } /* Free convertion tables */ if( vol.physicalUnits != NULL ) {#if (defined (CHAINS_DEBUG) && !defined(CHECK_MOUNT))
FILE * out;
out = getFileHandle(&vol,0); if (out == NULL) { DEBUG_PRINT(("Debug: Can not open debug file.\r\n")); } else { checkVirtualChains(&vol,out); checkVolumeStatistics(&vol,out); }#endif /* CHAINS_DEBUG AND NOT CHECK_MOUNT*/
FL_FAR_FREE(vol.physicalUnits); } if( vol.virtualUnits != NULL ) FL_FAR_FREE(vol.virtualUnits); vol.physicalUnits = NULL; vol.virtualUnits = NULL; /* Free catche tables */#ifdef NFTL_CACHE
if( vol.ucache != NULL ) FL_FAR_FREE(vol.ucache); if( vol.scache != NULL ) FL_FAR_FREE(vol.scache); vol.ucache = NULL; vol.scache = NULL;#endif /* NFTL_CACHE */
#endif /* FL_MALLOC */
DEBUG_PRINT(("Debug: finished INFTL dismount.\r\n"));}
/*----------------------------------------------------------------------*//* r e t r i e v e H e a d e r *//* *//* Retrieve media header by oring the headers of each floor *//* *//* Note: The header of each floor is read to the first half of the *//* buffer and then ORed to the second half therefor constructing *//* the real header in the upper half. After all copies are read *//* the data is copied to the first half. *//* *//* Note: No endian format changes are made. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* originalUnits : Array to store original units locations *//* readFullBBT : Boolean flag. When true the entire BBT will be read *//* and media units locations will be returned through *//* the originalUnits argument array. When FALSE only *//* the size of HEADER_SEARCH_BOUNDRY of each floor *//* be read. *//* retrieveData : Boolean flag. When true the header will be read *//* *//* Returns: *//* flOK on success any other value on error *//* flBadFormat if header was not found *//*----------------------------------------------------------------------*/
FLStatus retrieveHeader (Bnand vol , ANANDUnitNo * originalUnits, FLBoolean readFullBBT , FLBoolean retrieveData){ ANANDUnitNo iUnit,index; ANANDUnitNo noOfUnitsPerFloor; byte headerSize; byte floorNo; FLStatus status=flOK; byte bbt[HEADER_SEARCH_BOUNDRY]; byte FAR1* BBT;
noOfUnitsPerFloor = (ANANDUnitNo)(vol.flash->chipSize >> vol.unitSizeBits) * ((vol.flash->noOfChips + (vol.flash->noOfChips % vol.flash->noOfFloors)) / vol.flash->noOfFloors);
headerSize = sizeof(BNANDBootRecord)+MAX_TL_PARTITIONS*sizeof(BNANDVolumeHeaderRecord); tffsset(originalUnits,0,sizeof(ANANDUnitNo) * MAX_NO_OF_FLOORS);
if (readFullBBT == TRUE) /* read entire BBT into vol records (format) */ { status = vol.flash->readBBT(vol.flash,0,vol.noOfUnits, vol.blockMultiplierBits, vol.physicalUnits,TRUE); if(status != flOK) return status; BBT = vol.physicalUnits; } else { BBT = bbt; }
/* Go over all of the media floors and find header location */
for (floorNo = 0 ; floorNo < vol.flash->noOfFloors ; floorNo++) { iUnit = (ANANDUnitNo)floorNo * noOfUnitsPerFloor; if (readFullBBT == FALSE) /* read small part of the floors BBT */ { status = vol.flash->readBBT(vol.flash,iUnit, HEADER_SEARCH_BOUNDRY,vol.blockMultiplierBits,BBT,FALSE); if(status != flOK) return status;
iUnit=0; }
/* find and save location of the first good block of the floor */
index = iUnit + HEADER_SEARCH_BOUNDRY; while ((iUnit<index)&&(BBT[iUnit]!=BBT_GOOD_UNIT)) { iUnit++; } if (iUnit==index) { DEBUG_PRINT(("Debug: ERROR too many bad blocks (can not find place for INFTL header.\r\n")); return flBadBBT; }
if (readFullBBT == FALSE) /* Restore iUnit pointer to the physical media */ { iUnit += (ANANDUnitNo)floorNo * noOfUnitsPerFloor; } originalUnits[floorNo] = iUnit; /* Save origial unit location */ }
if (retrieveData == FALSE) return flOK;
/* Need to read the previous header */
tffsset(inftlBuffer,0,SECTOR_SIZE); for (floorNo = 0 ; floorNo < vol.flash->noOfFloors ; floorNo++) { for (index=0;index<NO_OF_MEDIA_HEADERS;index++) /* both 2 copies */ { status = vol.flash->read(vol.flash,((CardAddress)originalUnits[floorNo] << vol.unitSizeBits) + index * HEADERS_SPACING, inftlBuffer + headerSize,headerSize,PARTIAL_EDC); if (status != flOK) { DEBUG_PRINT(("Debug: ERROR reading original unit header.\r\n")); } else { if (tffscmp(inftlBuffer + headerSize, "BNAND", sizeof("BNAND")) == 0) break; } } if (index>=NO_OF_MEDIA_HEADERS) { DEBUG_PRINT(("Debug: Media header was not found on all copies.\r\n")); return flBadFormat; }
/* merge with previous headers */ for (index = 0 ; headerSize > index ; index++) { inftlBuffer[index] |= inftlBuffer[index + headerSize]; } } /* loop of the floors */
return flOK;}
/*----------------------------------------------------------------------*//* I N F T L I n f o *//* *//* get INFTL information. *//* *//* Parameters: *//* vol : Pointer discribing volume. *//* tlInfo : Pointer to user record *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//* tlInfo : Record containing tl infromation. *//*----------------------------------------------------------------------*/
static FLStatus INFTLInfo(Bnand vol, TLInfo *tlInfo){ tlInfo->sectorsInVolume = vol.virtualSectors; tlInfo->bootAreaSize = (dword)vol.bootUnits << vol.unitSizeBits; tlInfo->eraseCycles = vol.eraseSum; tlInfo->tlUnitBits = vol.unitSizeBits; return flOK;}
#ifndef NO_READ_BBT_CODE
/*----------------------------------------------------------------------*//* r e a d B B T *//* *//* Returns a pointer to the BBT of the device. *//* Note: Bad unit are marked with a 4 bytes address of the unit. *//* Note: A unit can contain several blocks *//* *//* Parameters: *//* vol : Pointer identifying drive *//* buf : pointer to buffer to read into *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//* noOfBB : returns the number of bad unit of the media *//* meidaSize : returns the media size in bytes *//*----------------------------------------------------------------------*/
static FLStatus readBBT(Bnand vol, CardAddress FAR1 * buf, long FAR2 * mediaSize, unsigned FAR2 * noOfBB){ dword iUnit; dword noOfUnits = (ANANDUnitNo)(((dword)vol.flash->noOfChips * vol.flash->chipSize) >> vol.unitSizeBits); dword index,curRead; ANANDUnitNo maxBad = (ANANDUnitNo)(noOfUnits * ANAND_BAD_PERCENTAGE / 100); CardAddress FAR1 * ptr = buf; *noOfBB = 0;
if ( vol.flash->readBBT == NULL) { DEBUG_PRINT(("Debug: ERROR unerasable BBT not supported by MTD.\r\n")); return flGeneralFailure; } else { for (iUnit=vol.flash->firstUsableBlock;iUnit<noOfUnits;iUnit+=curRead) { curRead = TFFSMIN(SECTOR_SIZE,noOfUnits-iUnit); vol.flash->readBBT(vol.flash,iUnit,curRead,vol.blockMultiplierBits,multiSectorBuf[vol.socketNo],FALSE); for ( index = 0 ; (index < curRead) && (*noOfBB < maxBad); index++) if ((*(multiSectorBuf[vol.socketNo] + index) != BBT_GOOD_UNIT) && /* Not good unit */ (*(multiSectorBuf[vol.socketNo] + index) != BBT_UNAVAIL_UNIT)) /* Not used for a special purpose */ { *ptr = (iUnit+index) << vol.unitSizeBits; ptr = (CardAddress FAR1*)flAddLongToFarPointer((byte FAR1 *)ptr, sizeof(CardAddress)); (*noOfBB)++; } if ( *noOfBB == maxBad) { DEBUG_PRINT(("Debug: ERROR to many bad blocks.\r\n")); return flVolumeTooSmall; } } } *mediaSize = (long) noOfUnits << vol.unitSizeBits; return flOK;}
#endif /* NO_READ_BBT_CODE */
/*----------------------------------------------------------------------*//* c o n v e r t C h a i n *//* *//* Convert candidate chain to given value. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* newestUnitNo : newest unit in chain *//* oldestUnitNo : oldest unit in chain *//* virtualUnitNo : virtual unit no *//* chainsMark : new value *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus convertChain(Bnand vol, ANANDUnitNo newestUnitNo, ANANDUnitNo oldestUnitNo, ANANDUnitNo virtualUnitNo, byte chainsMark){ ANANDUnitNo chainBound = 0;
for(;newestUnitNo != oldestUnitNo ; chainBound++, newestUnitNo = getPrevUnit(&vol,newestUnitNo,virtualUnitNo)) { if((newestUnitNo == ANAND_BAD_CHAIN_UNIT ) || /* Brocken chain */ (chainBound >= DOUBLE_MAX_UNIT_CHAIN)) /* Infinit loop */ return flGeneralFailure;
vol.physicalUnits[newestUnitNo] = chainsMark; } vol.physicalUnits[oldestUnitNo] = chainsMark; return flOK;}
#ifndef FL_READ_ONLY
/*----------------------------------------------------------------------*//* e r a s e O r p h a n U n i t *//* *//* Erase one unit. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Unit to format *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus eraseOrphanUnit(Bnand vol, ANANDUnitNo unitNo){ word eraseMark; dword eraseCount; FLStatus status;
status = getUnitTailer(&vol,unitNo,&eraseMark,&eraseCount,UNIT_TAILER_OFFSET); if(status != flOK) return status;
if(unitNo+(ANANDUnitNo)vol.firstUnit<(ANANDUnitNo)vol.firstUnit) { return flGeneralFailure; }
status = vol.flash->erase(vol.flash, (word)(((dword)unitNo+(dword)vol.firstUnit) << (vol.unitSizeBits - vol.erasableBlockSizeBits)), (word)(1 << vol.blockMultiplierBits));
if (status != flOK) { markUnitBad(&vol,unitNo); /* make sure unit format is not valid */ return status; }
vol.eraseSum++; eraseCount++; if (eraseCount == 0) /* was hex FF's */ eraseCount++;
return setUnitTailer(&vol,unitNo,ERASE_MARK,eraseCount,UNIT_TAILER_OFFSET);}
#endif /* FL_READ_ONLY */
/*----------------------------------------------------------------------*//* c h e c k U n i t H e a d *//* *//* Compare 2 copies of unit header. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Physical unit number *//* *//* Returns: *//* flOK on success, flFormattingError on miscompare. *//*----------------------------------------------------------------------*/
static FLStatus checkUnitHead(Bnand vol, ANANDUnitNo unitNo){ ANANDUnitHeader unitData; SecondANANDUnitHeader secondUnitData;
/* Read first unit data */ checkStatus(vol.flash->read(vol.flash, unitBaseAddress(vol,unitNo) + UNIT_DATA_OFFSET, &unitData, sizeof(ANANDUnitHeader), EXTRA)); checkStatus(vol.flash->read(vol.flash, unitBaseAddress(vol,unitNo) + SECOND_HEADER_OFFSET + UNIT_DATA_OFFSET, &secondUnitData, sizeof(SecondANANDUnitHeader), EXTRA)); if((LE2(secondUnitData.virtualUnitNo) != LE2(unitData.virtualUnitNo)) || (LE2(secondUnitData.prevUnitNo ) != LE2(unitData.prevUnitNo )) || (secondUnitData.ANAC != secondUnitData.ANAC ) ) return flFormattingError;
return flOK;}
/*----------------------------------------------------------------------*//* g o A l o n g C h a i n *//* *//* Go along the INFTL chaine while marking the chain in the convertion *//* tables. This routine is called by the mount routine in order to *//* initialize the volumes convertion tables. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Physical unit to check. *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus goAlongChain(Bnand vol,ANANDUnitNo unitNo){ ANANDUnitNo origVirtualNo,virtualUnitNo,prevUnitNo; ANANDUnitNo lastCurrent,nextUnitNo,lastUnitNo; byte ANAC, NAC, prevANAC, parityPerField; FLStatus status; word eraseMark; dword eraseCount;
/* Check if already been here */ if((vol.physicalUnits[unitNo]==FL_VALID) || (vol.physicalUnits[unitNo]==FL_FIRST_VALID) || (vol.physicalUnits[unitNo]==FL_PRELIMINARY) || (vol.physicalUnits[unitNo]==FL_FIRST_PRELIMINARY)) return flOK;
/* Read unit tailor to check the erase mark */
status = getUnitTailer(&vol,unitNo,&eraseMark,&eraseCount,UNIT_TAILER_OFFSET); if(status != flOK) return status; vol.eraseSum+=eraseCount; if (eraseMark != ERASE_MARK) { /* Do not perform erase in the mount. The allocateUnit routine */ /* rechecks for the erase mark and it will erase this unit. */ vol.physicalUnits[unitNo] = ANAND_UNIT_FREE; return flOK; }
status = getUnitData(&vol,unitNo,&virtualUnitNo, &prevUnitNo, &ANAC,&NAC,&parityPerField); if(status != flOK) return status;
/* Check parity result of values returned by getUnitData */
if(badParityResult(parityPerField)) { vol.physicalUnits[unitNo]=FL_PRELIMINARY; return flOK; }
/* Check if the unit is free (all fields are FF) */
if((virtualUnitNo == ANAND_NO_UNIT ) && (prevUnitNo == ANAND_NO_UNIT ) && (ANAC == ANAND_UNIT_FREE) && (NAC == ANAND_UNIT_FREE)) return flOK; /* free unit */
/* Check virtual unit number that was returned */ if((virtualUnitNo == ANAND_NO_UNIT) || (vol.noOfVirtualUnits <= virtualUnitNo) ) { vol.physicalUnits[unitNo]=FL_PRELIMINARY; return flOK; }
/* Save location of currently known newest unit of our chain */ lastUnitNo = vol.virtualUnits[virtualUnitNo];
/* If older unit is none existing then there is only one unit in this */ /* chain so lets not complicate things. */
if(prevUnitNo >= vol.noOfUnits) { if(lastUnitNo == ANAND_NO_UNIT ) { /* First access to this unit therefore a one unit chain */
vol.virtualUnits[virtualUnitNo] = unitNo; vol.physicalUnits[unitNo] = FL_VALID | FIRST_IN_CHAIN; return flOK; } else { /* One unit chain that has 2 ends mark and deal later */ if(checkUnitHead(&vol,unitNo)!=flOK) /* Invalid header */ { vol.physicalUnits[unitNo] = FL_PRELIMINARY; return flOK; } else { if(checkUnitHead(&vol,lastUnitNo)!=flOK) { vol.physicalUnits[lastUnitNo] = FL_PRELIMINARY; vol.virtualUnits[virtualUnitNo] = unitNo; vol.physicalUnits[unitNo] = FL_VALID | FIRST_IN_CHAIN; /* Might want to check rest of chain - but not neccesary */ return flOK; } } vol.physicalUnits[unitNo] = FL_PRELIMINARY; DEBUG_PRINT(("Debug: We have reached a unit twice while mounting.\r\n")); return flOK; } }
/* We know that our unit points to a valid unit , now check if we */ /* already checked that older unit */
if((vol.physicalUnits[prevUnitNo] == FL_VALID)|| (vol.physicalUnits[prevUnitNo] == FL_FIRST_VALID)) { if(lastUnitNo == prevUnitNo) { /* Our older unit is the head of the current chain. All we need */ /* to do is append our newer unit and mark it as the new head */
vol.physicalUnits[unitNo] = FL_VALID; vol.virtualUnits[virtualUnitNo] = unitNo; /* Might be nice to check for ANAC consistency */ return flOK; } else /* The previous unit is not the newest unit of our chain */ { if(lastUnitNo == ANAND_NO_UNIT) { /* This is the first time we accessed this chain, but the */ /* unit indicated by the previous unit field is taken. We */ /* must assume that it no longer belongs to our chain. */
vol.virtualUnits[virtualUnitNo] = unitNo; vol.physicalUnits[unitNo] = FL_VALID | FIRST_IN_CHAIN; return flOK; } else /* Virtual chain already has a head - 2 ends of chain */ { /* If we reached this point we have a problem - its bad. */ /* We were never visited, so we are'nt a part of a known chain. */ /* Our previous unit is used and was visited so: */ /* a) It belong to our chain - so why is it not it's head */ /* b) It does not belong to our chain - so it will not lead */ /* us to the rest of our chain which was already found. */
if(checkUnitHead(&vol,unitNo)!=flOK) /* Invalid header */ { vol.physicalUnits[unitNo] = FL_PRELIMINARY; return flOK; } else { if(checkUnitHead(&vol,lastUnitNo)!=flOK) { vol.physicalUnits[lastUnitNo] = FL_PRELIMINARY; vol.virtualUnits[virtualUnitNo] = unitNo; vol.physicalUnits[unitNo] = FL_VALID | FIRST_IN_CHAIN; /* Might want to check rest of chain - but not neccesary */ return flOK; } } vol.physicalUnits[unitNo] = FL_PRELIMINARY; DEBUG_PRINT(("Debug: We have reached a unit twice while mounting.\r\n")); return flOK; } } }
/* If we reached this point , we have a valid older unit pointer */ /* and it points to a unit we did not mark as visited yet. We need */ /* to go along the chain and reconstruct it in the RAM tables. */
/* Save location of our unit and virtual unit number */ lastCurrent = unitNo; origVirtualNo = virtualUnitNo;
/* Mark unit as Orphane until we shall verify the 2 ends connect */ vol.physicalUnits[unitNo] = FL_PRELIMINARY;
/************************************************************/ /* Go over the chain starting the unit previous to our unit */ /************************************************************/
while(1) { nextUnitNo = unitNo; unitNo = prevUnitNo; prevANAC = ANAC; if(unitNo == ANAND_NO_UNIT) break;
/* If already been to this unit */ if((vol.physicalUnits[unitNo] == FL_VALID)|| (vol.physicalUnits[unitNo] == FL_FIRST_VALID)) { if(lastUnitNo == unitNo) { /* We have returned to the chains head , so the unit is valid */ /* Convert all the units we passed as valid and mark new head */ status = convertChain(&vol,lastCurrent,nextUnitNo, origVirtualNo,FL_VALID); vol.virtualUnits[origVirtualNo] = lastCurrent; return flOK; } /* We have reached a unit that was already checked, but was not */ /* registeredour as the chains head. We can safely assume it does */ /* not belong to our virtual unit */ break; }
/* Read unit header of our previous unit */
status = getUnitData(&vol,unitNo,&virtualUnitNo, &prevUnitNo, &ANAC,&NAC,&parityPerField); if(status != flOK) return status;
if(badParityResult(parityPerField)) /* Bad unit header */ { /* We can no longer follow the chain */ vol.physicalUnits[unitNo] = FL_PRELIMINARY; /* Delete later */ break; }
/* Check if unit belongs to our chain */
if((virtualUnitNo != origVirtualNo ) || /* Correct virtual unit no */ (!consecutiveNumbers(prevANAC,ANAC)) ) /* ANAC is consecutive */ { /* Note : none consecutive ANAC might still be connected to the end */ /* the chain , on the next time we will read it. */ break; }
/* We have verified that unit belongs to our chain */ /* Mark unit as Orphane until we shall verify the 2 ends connect */ vol.physicalUnits[unitNo]=FL_PRELIMINARY; }
/* Chain reached a unit pointing to an invalid unit. */ if(lastUnitNo == ANAND_NO_UNIT) { /* Chain did not have a head so mark it as a valid chain */ status = convertChain(&vol,lastCurrent,nextUnitNo, origVirtualNo,FL_VALID); vol.physicalUnits[nextUnitNo] = FL_VALID | FIRST_IN_CHAIN; vol.virtualUnits[origVirtualNo] = lastCurrent; } else { /* Chain had a head. Check if previous head is valid. */
if(checkUnitHead(&vol,lastUnitNo)!=flOK) /* Invalid header */ { /* The unit we found earlier was a result of power failure */ vol.physicalUnits[lastUnitNo] = FL_PRELIMINARY; vol.virtualUnits[virtualUnitNo] = lastCurrent; status = convertChain(&vol,lastCurrent,nextUnitNo, origVirtualNo,FL_VALID); vol.physicalUnits[nextUnitNo] = FL_VALID | FIRST_IN_CHAIN; return status; } DEBUG_PRINT(("Debug: We have reached a unit twice while mounting.\r\n")); status = convertChain(&vol,lastCurrent,nextUnitNo, origVirtualNo,FL_PRELIMINARY); }
return status;}
#ifdef QUICK_MOUNT_FEATURE
/*----------------------------------------------------------------------*//* c h e c k Q u i c k M o u n t I n f o *//* *//* Read the quick mount information and verfiy its itegrity. *//* *//* Note : If the data is valid it will be read to the vol record and *//* will mark the current data as invalid. *//* *//* Note : checksum will be added in future versions. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//* Returns: TRUE if data is valid otherwise FALSE. *//*----------------------------------------------------------------------*/
static FLBoolean checkQuickMountInfo(Bnand vol){ byte start; /* The first goot unit of the quick mount data */ FLStatus status; savedBnand *newVol;
DEBUG_PRINT(("Debug: trying to read quick mount information.\r\n"));
status = quickMountData(&vol, TRUE,&start); if (status==flOK) { status = vol.flash->read(vol.flash,(((CardAddress)(vol.firstQuickMountUnit +start))<< vol.unitSizeBits),inftlBuffer, sizeof(inftlBuffer),EDC); if (status == flOK) { /* Convert the dword fields to the internal volume */
newVol = (savedBnand *) inftlBuffer; if (LE4(newVol->validate) == QUICK_MOUNT_VALID_SIGN) { vol.freeUnits = (ANANDUnitNo)LE4(newVol->freeUnits ); vol.roverUnit = (ANANDUnitNo)LE4(newVol->roverUnit ); vol.countsValid = (ANANDUnitNo)LE4(newVol->countsValid ); vol.sectorsRead = LE4(newVol->sectorsRead ); vol.sectorsWritten = LE4(newVol->sectorsWritten); vol.sectorsDeleted = LE4(newVol->sectorsDeleted); vol.parasiteWrites = LE4(newVol->parasiteWrites); vol.unitsFolded = LE4(newVol->unitsFolded ); vol.wearLevel.alarm = (word)LE4(newVol->wearLevel_1 ); vol.wearLevel.currUnit = (ANANDUnitNo)LE4(newVol->wearLevel_2 ); vol.eraseSum = LE4(newVol->eraseSum );#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
vol.verifiedSectorNo = LE4(newVol->verifiedSectorNo);#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
DEBUG_PRINT(("Debug: quick mount information was successfuly restored.\r\n")); return TRUE; } } } DEBUG_PRINT(("Debug: Error getting quick mount information.\r\n")); return FALSE;}
#endif /* QUICK_MOUNT_FEATURE */
#ifdef NFTL_CACHE
/*----------------------------------------------------------------------*//* i n i t C a t c h *//* *//* Initialize and allocate the unit and sector catche. *//* *//* Note - need to add check for not enough static memory. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* ramForCache : Cache offset of previous volumes on device *//* *//* Returns: *//*----------------------------------------------------------------------*/
#ifndef FL_MALLOC
void initCatch(Bnand vol, dword ramForCache)#else
void initCatch(Bnand vol)#endif /* FL_MALLOC */
{ dword scacheSize = 0; /* Initialized to remove warrnings */ dword iUnit;
/* create and initialize ANANDUnitHeader cache */#ifdef ENVIRONMENT_VARS
if( flUseNFTLCache == 1 ) /* behave according to the value of env variable */#endif
{#ifdef FL_MALLOC
vol.ucache = (ucacheEntry FAR1*) FL_FAR_MALLOC(vol.noOfUnits * sizeof(ucacheEntry));#else
vol.ucache = &socketUcache[flSocketNoOf(vol.flash->socket)][ramForCache];#endif /* FL_MALLOC */
}#ifdef ENVIRONMENT_VARS
else { vol.ucache = NULL; }#endif /* ENVIRONMENT_VARS */
if (vol.ucache != NULL) { for (iUnit = 0; iUnit < vol.noOfUnits; iUnit++) { vol.ucache[iUnit].virtualUnitNo = 0xDEAD; vol.ucache[iUnit].prevUnitNo = 0xDEAD; } } else { DEBUG_PRINT(("Debug: INFTL runs without U-cache\r\n")); }
/* create and initialize SectorFlags cache */#ifdef ENVIRONMENT_VARS
if( flUseNFTLCache == 1 ) /* behave according to the value of env variable */#endif /* ENVIRONMENT_VARS */
{ scacheSize = (dword)vol.noOfUnits << (vol.unitSizeBits - SECTOR_SIZE_BITS - 2);#ifdef FL_MALLOC
if( (sizeof(unsigned) < sizeof(scacheSize)) && (scacheSize >= 0x10000L) ) /* Out of Segment Boundary */ { vol.scache = NULL; } else { vol.scache = (byte FAR1*) FL_FAR_MALLOC(scacheSize); }#else
vol.scache = &socketScache[flSocketNoOf(vol.flash->socket)][ramForCache << (vol.unitSizeBits - SECTOR_SIZE_BITS - 2)];#endif /* FL_MALLOC */
}#ifdef ENVIRONMENT_VARS
else { vol.scache = NULL; }#endif /* ENVIRONMENT_VARS */
if (vol.scache != NULL) { /*
* Whenever SECTOR_IGNORE is found in Sector Flags cache it is double * checked by reading actual sector flags from flash-> This is way * all the cache entries are initially set to SECTOR_IGNORE. */ byte val = (S_CACHE_SECTOR_IGNORE << 6) | (S_CACHE_SECTOR_IGNORE << 4) | (S_CACHE_SECTOR_IGNORE << 2) | S_CACHE_SECTOR_IGNORE; dword iC;
for(iC=0;( iC < scacheSize );iC++) vol.scache[iC] = val; } else { DEBUG_PRINT(("Debug: INFTL runs without S-cache\r\n")); }}#endif /* NFTL_CACHE */
/*----------------------------------------------------------------------*//* m o u n t I N F T L *//* *//* Mount the volume. Initialize data structures and conversion tables *//* *//* Parameters: *//* volNo : Volume serial no. *//* tl : Mounted translation layer on exit *//* flash : Flash media mounted on this socket *//* volForCallback : Pointer to FLFlash structure for power on *//* callback routine. *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/static FLStatus mountINFTL(unsigned volNo, TL *tl, FLFlash *flash, FLFlash **volForCallback){ Bnand vol = &vols[volNo]; ANANDUnitNo iUnit; ANANDUnitNo originalUnits[MAX_NO_OF_FLOORS]; BNANDBootRecord * mediaHeader; /* Disk header record */ BNANDVolumeHeaderRecord * volumeHeader; /* volume header record */ FLStatus status; byte index;#ifndef FL_MALLOC
dword ramForUnits=0;#ifdef NFTL_CACHE
dword ramForCache=0;#endif /* NFTL_CACHE */
#endif /* FL_MALLOC */
#ifdef EXTRA_LARGE
word moreUnitBits;#endif /* EXTRA_LARGE */
#ifdef CHAINS_DEBUG
FILE * out;#endif /* CHAINS_DEBUG */
DEBUG_PRINT(("Debug: starting INFTL mount.\r\n"));
/*************************/ /* Find the media header */ /*************************/
tffsset(&vol,0,sizeof(vol)); status = initINFTL(&vol,flash); if(status == flOK) status = retrieveHeader(&vol,originalUnits,FALSE,TRUE); if(status != flOK) return status;
mediaHeader = (BNANDBootRecord *)inftlBuffer; if (tl->partitionNo >= LE4(mediaHeader->noOfBDTLPartitions)) { DEBUG_PRINT(("Debug: wrong partition number.\r\n")); return flBadDriveHandle; } *volForCallback = vol.flash; vol.eraseSum = 0;
/* Get media information from unit header */
volumeHeader = (BNANDVolumeHeaderRecord *)(inftlBuffer + sizeof(BNANDBootRecord) + (word)((LE4(mediaHeader->noOfBinaryPartitions) * sizeof(BNANDVolumeHeaderRecord)))); vol.bootUnits = (ANANDUnitNo)LE4(volumeHeader->firstQuickMountUnit);
#ifndef FL_MALLOC
/* calculate the memory offset for static allocation */
for (index = tl->partitionNo;index>0;index--,volumeHeader++) { ramForUnits += LE4(volumeHeader->virtualUnits) * sizeof(ANANDUnitNo); /* virtual size */ iUnit = (word)(LE4(volumeHeader->lastUnit) - LE4(volumeHeader->firstUnit) + 1); ramForUnits += iUnit * sizeof(ANANDPhysUnit);#ifdef NFTL_CACHE
ramForCache += iUnit;#endif /* NFTL_CACHE */
}#else
volumeHeader += tl->partitionNo;#endif /* FL_MALLOC */
vol.noOfVirtualUnits = (ANANDUnitNo)LE4(volumeHeader->virtualUnits); vol.flags = (byte)LE4(mediaHeader->formatFlags); vol.firstQuickMountUnit = (ANANDUnitNo)LE4(volumeHeader->firstQuickMountUnit); vol.firstUnit =(ANANDUnitNo) LE4(volumeHeader->firstUnit);#ifdef NFTL_CACHE
vol.firstUnitAddress = (dword)vol.firstUnit << vol.unitSizeBits;#endif /* NFTL_CACHE */
vol.virtualSectors = (SectorNo)((LE4(volumeHeader->virtualUnits)<< vol.unitSizeBits) >> SECTOR_SIZE_BITS); vol.noOfUnits = (ANANDUnitNo)(LE4(volumeHeader->lastUnit) - LE4(volumeHeader->firstUnit) + 1);
/* Validy check */
if((ANANDUnitNo)(vol.noOfVirtualUnits > vol.noOfUnits)) { DEBUG_PRINT(("Reported no of virtual unit is larger then no of physical units\r\n")); return flBadFormat; }
#ifdef FL_MALLOC
status = initTables(&vol);#else
status = initTables(&vol,ramForUnits);#endif /* MALLOCK */
if(status != flOK) return status;
#ifdef NFTL_CACHE
#ifndef FL_MALLOC
initCatch(&vol, ramForCache);#else
initCatch(&vol);#endif /* FL_MALLOC */
#endif /* NFTL_CACHE */
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
/* Default for INFTL is FL_OFF */ flVerifyWrite[vol.socketNo][tl->partitionNo] = FL_OFF;#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
/******************************************/ /* Try mounting from the quick mount data */ /******************************************/
#ifdef QUICK_MOUNT_FEATURE
#if (!defined(RAM_MTD) && !defined(CHECK_MOUNT))
if (((LE4(mediaHeader->formatFlags) & QUICK_MOUNT) == 0) || ( checkQuickMountInfo(&vol) == FALSE ) )#endif /* not RAM_MTD && not CHECK_MOUNT */
#endif /* QUICK_MOUNT_FORMAT */
{ vol.firstMediaWrite = TRUE; /* Force writing quick mount information */
/***************************************/ /* Read BBT to internal representation */ /***************************************/
status = flash->readBBT(vol.flash,vol.firstUnit, vol.noOfUnits,vol.blockMultiplierBits, vol.physicalUnits,FALSE); if( status != flOK ) { DEBUG_PRINT(("Debug: Error reading BBT.\r\n")); dismountINFTL(&vol); /* Free tables must be done after call to initTables */ return status; } /* Translate bad unit table to internal representation */ for (iUnit = 0; iUnit < vol.noOfUnits; iUnit++) { if (vol.physicalUnits[iUnit] != BBT_GOOD_UNIT) { vol.physicalUnits[iUnit] = UNIT_BAD; } else { vol.physicalUnits[iUnit] = ANAND_UNIT_FREE; } } /* Translate original units to bad blocks */ for (index=0;index < vol.flash->noOfFloors;index++) { iUnit = originalUnits[index]-vol.firstUnit; if ((iUnit < vol.noOfUnits) && (originalUnits[index] > vol.firstUnit)) vol.physicalUnits[iUnit] = UNIT_BAD; }
/*************************/ /* Mount the unit chains */ /*************************/
/* Initialize virutal units table */
for (iUnit = 0; iUnit < vol.noOfVirtualUnits; iUnit++) vol.virtualUnits[iUnit] = ANAND_NO_UNIT;
#ifdef CHECK_MOUNT
status = checkMountINFTL(&vol); if (status != flOK) { TL_DEBUG_PRINT(tl_out,"Failed check Mount routine with status %d\n",status); SET_EXIT(INFTL_FAILED_MOUNT); }#endif /* CHECK_MOUNT */
for (iUnit = 0; iUnit < vol.noOfUnits; iUnit++) { if (vol.physicalUnits[iUnit] != UNIT_BAD) { status = goAlongChain(&vol,iUnit); if(status != flOK) { DEBUG_PRINT(("Debug: Error going along INFTL chains.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return status; } } }#ifdef CHAINS_DEBUG
out = getFileHandle(&vol,0); if (out == NULL) { if (DID_MOUNT_FAIL) DEBUG_PRINT(("Debug: Can not open debug file.\r\n")); } else { checkVirtualChains(&vol,out); }#endif /* CHAINS_DEBUG */
vol.freeUnits = 0; for (iUnit = 0; iUnit < vol.noOfUnits; iUnit++) { switch( vol.physicalUnits[iUnit] ) { case ANAND_UNIT_FREE: vol.freeUnits++; break;
case FL_FIRST_VALID: /* Mark as first in chain */ case FL_VALID: vol.physicalUnits[iUnit] &= FIRST_IN_CHAIN; break;
case FL_FIRST_PRELIMINARY: /* Vadim :erase this unit*/ case FL_PRELIMINARY: DEBUG_PRINT(("Orphan unit found\r\n")); TL_DEBUG_PRINT(tl_out,"Orphan units found , unit no %d\n",iUnit); SET_EXIT(INFTL_FAILED_MOUNT);#ifndef FL_READ_ONLY
if( eraseOrphanUnit(&vol,iUnit) == flOK) { vol.physicalUnits[iUnit] = ANAND_UNIT_FREE; vol.freeUnits++; } break;#else
#ifndef CHECK_MOUNT
dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return flWriteFault;#endif /* CHECK_MOUNT */
#endif /* FL_READ_ONLY */
default: /* nothing here */ break; } } /* Initialize allocation rover */ vol.roverUnit = 0;
/* Initialize statistics */ vol.sectorsRead = vol.sectorsWritten = vol.sectorsDeleted = 0; vol.parasiteWrites = vol.unitsFolded = 0;
vol.wearLevel.alarm = (word)(vol.eraseSum % WLnow); vol.wearLevel.currUnit = (ANANDUnitNo)(vol.eraseSum % vol.noOfVirtualUnits); } /* end quick mounted succesful if */
#ifdef CHAINS_DEBUG
if (out != NULL) { checkVolumeStatistics(&vol,out); }#endif /* CHAINS_DEBUG */
#ifdef CHECK_MOUNT
dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ if(vol.debugState & INFTL_FAILED_MOUNT) { TL_DEBUG_PRINT(tl_out,"Test failed\n\n"); fclose(tl_out); exit(EXIT_FAILURE); } else { TL_DEBUG_PRINT(tl_out,"Test success\n\n"); exit(EXIT_SUCCESS); }#endif /* CHECK_MOUNT */
#ifndef FL_READ_ONLY
/* Make sure there are at least 2 free units */ if(vol.freeUnits == 0) { status = foldBestChain(&vol,&iUnit); switch(status) { case flNotEnoughMemory: DEBUG_PRINT(("Debug: Not enough free units. Media is read only.\r\n")); case flOK: break; default: return status; } } tl->writeSector = writeSector; tl->deleteSector = deleteSector; tl->writeMultiSector = writeMultiSector;#ifdef DEFRAGMENT_VOLUME
tl->defragment = defragment;#endif /* DEFRAGMENT */
#if (defined(VERIFY_WRITE) || defined (VERIFY_VOLUME) || defined(VERIFY_ERASED_SECTOR))
tl->checkVolume = checkVolume;#endif /* VERIFY_WRITE || VERIFY_VOLUME || VERIFY_ERASED_SECTOR */
#else /* FL_READ_ONLY */
tl->writeSector = NULL; tl->deleteSector = NULL; tl->writeMultiSector = NULL;#ifdef DEFRAGMENT_VOLUME
tl->defragment = NULL;#endif /* DEFRAGMENT */
#if (defined(VERIFY_WRITE) || defined (VERIFY_VOLUME) || defined(VERIFY_ERASED_SECTOR))
tl->checkVolume = NULL;#endif /* VERIFY_WRITE || VERIFY_VOLUME || VERIFY_ERASED_SECTOR */
#endif /* FL_READ_ONLY */
tl->rec = &vol; tl->mapSector = mapSector; tl->sectorsInVolume = sectorsInVolume; tl->getTLInfo = INFTLInfo; tl->tlSetBusy = tlSetBusy; tl->dismount = dismountINFTL; tl->readSectors = readSectors;#ifndef NO_READ_BBT_CODE
tl->readBBT = readBBT;#endif
DEBUG_PRINT(("Debug: finished INFTL mount.\r\n")); return flOK;}
#ifdef HW_PROTECTION
/*----------------------------------------------------------------------*//* p r o t e c t i o n I N F T L *//* *//* Common entry point to all protection routines. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* volume : Pointer to partition record of the media header *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failure *//* *//*----------------------------------------------------------------------*/
static FLStatus protectionINFTL(Bnand vol,BNANDVolumeHeaderRecord* volume, IOreq FAR2* ioreq , FLFunctionNo callType){ FLFlash * flash = vol.flash; FLStatus status;#ifndef FL_READ_ONLY
CardAddress low; CardAddress high; byte floorNo;#endif /* FL_READ_ONLY */
byte tempFlags = 0; /* Initialized to remove warrnings */ byte area; word returnedFlags;
/* Save protection area since "volume" is overwritten by protectionSet */
area = (byte)LE4(volume->protectionArea); /* Protection area */ if ((LE4(volume->flags) & PROTECTABLE) == 0) return flNotProtected;
/* Routine that need to get the partition type before executing */ if ((callType != FL_PROTECTION_INSERT_KEY) && (callType != FL_PROTECTION_REMOVE_KEY)) { tempFlags = (byte)ioreq->irFlags; if (flash->protectionType == NULL) return flFeatureNotSupported;
status = flash->protectionType(flash,area,&returnedFlags); ioreq->irFlags = (unsigned)returnedFlags; if (status != flOK) return status;
/* Routines that need to change the protection attributes */
#ifndef FL_READ_ONLY
if (callType!=FL_PROTECTION_GET_TYPE) { if((returnedFlags & KEY_INSERTED) == 0) /* Make sure the key is inserted */ { DEBUG_PRINT(("Please insert key before trying to change protection attributes\r\n")); return flHWProtection; }
if ((flash->protectionBoundries == NULL ) || (flash->protectionSet == NULL ) || (flash->protectionKeyInsert == NULL )) { DEBUG_PRINT(("Protection routine are NULL\r\n")); return flFeatureNotSupported; }
if (!(LE4(volume->flags) & CHANGEABLE_PROTECTION)) return flUnchangeableProtection;
/* The DPS of unprotected partitions is protected by a default key */ flash->protectionKeyInsert(flash,area,(byte *)DEFAULT_KEY); }#endif /* FL_READ_ONLY */
} /* End of protection change routine */
/* Execute each of the posible protection routines */
switch (callType) { case FL_PROTECTION_GET_TYPE:
ioreq->irFlags |= PROTECTABLE; if (LE4(volume->flags) & CHANGEABLE_PROTECTION) { if ((ioreq->irFlags & CHANGEABLE_PROTECTION)==0) { DEBUG_PRINT(("Debug: INFTL reported CHANGEALE protection, but MTD does not allow it.\r\n")); return flBadFormat; } } else { ioreq->irFlags &= (~CHANGEABLE_PROTECTION); } break;
#ifndef FL_READ_ONLY
case FL_PROTECTION_SET_LOCK:
if (tempFlags & LOCK_ENABLED) { ioreq->irFlags |= LOCK_ENABLED; } else { ioreq->irFlags &=~LOCK_ENABLED; } for (floorNo = 0 ; floorNo < flash->noOfFloors ; floorNo++) { /* Find boundries */ status = flash->protectionBoundries(flash, area,&low,&high,floorNo); if(status == flOK) /* Set new protection values */ { status = flash->protectionSet(flash,area, (word)((high == 0) ? PROTECTABLE : ioreq->irFlags), low,high,NULL, (byte)((floorNo == flash->noOfFloors - 1) ? COMMIT_PROTECTION : DO_NOT_COMMIT_PROTECTION),floorNo); } if(status != flOK) return status; } break;
case FL_PROTECTION_CHANGE_KEY:
for (floorNo = 0 ; floorNo < flash->noOfFloors ; floorNo++) { /* Find boundries */ status = flash->protectionBoundries(flash,area, &low,&high,floorNo); if(status == flOK) /* Set new protection values */ { status = flash->protectionSet(flash,area, (word)((high == 0) ? PROTECTABLE : ioreq->irFlags), low,high,(byte FAR1*)ioreq->irData, (byte)((floorNo == flash->noOfFloors - 1) ? COMMIT_PROTECTION : DO_NOT_COMMIT_PROTECTION),floorNo); } if(status != flOK) return status; } break;
case FL_PROTECTION_CHANGE_TYPE:
/* Only read and or write protected types are available */ if (((tempFlags & (READ_PROTECTED | WRITE_PROTECTED | PROTECTABLE)) != tempFlags) || ((tempFlags & PROTECTABLE) == 0)) return flBadParameter;
for (floorNo = 0 ; floorNo < flash->noOfFloors ; floorNo++) { /* Find boundries */ status = flash->protectionBoundries(flash,area, &low,&high,floorNo); if(status == flOK) /* Set new protection values */ { status = flash->protectionSet(flash,area, (word)((high == 0) ? PROTECTABLE : tempFlags), low,high,NULL,(byte)((floorNo == flash->noOfFloors - 1) ? COMMIT_PROTECTION : DO_NOT_COMMIT_PROTECTION),floorNo); } if(status != flOK) return status; } break;
#endif /* FL_READ_ONLY */
case FL_PROTECTION_REMOVE_KEY:
if (flash->protectionKeyRemove == NULL) { DEBUG_PRINT(("Protection routine is NULL\r\n")); return flFeatureNotSupported; } return flash->protectionKeyRemove(flash,area);
case FL_PROTECTION_INSERT_KEY:
if (flash->protectionKeyInsert == NULL) { DEBUG_PRINT(("Protection routine is NULL\r\n")); return flFeatureNotSupported; } return flash->protectionKeyInsert(flash,area,(byte FAR1*)ioreq->irData); default: break; } /* protection routines */ return flOK;}
#endif /* HW_PROTECTION */
/*----------------------------------------------------------------------*//* p r e M o u n t I N F T L *//* *//* Common entry point to all tl routines that may be perfomed before *//* the volume is mounted (except for the format routine *//* *//* Parameters: *//* callType : Enum type of posible routines *//* ioreq : Input and output request packet *//* flash : Flash media mounted on this socket *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failure *//* *//*----------------------------------------------------------------------*/
static FLStatus preMountINFTL(FLFunctionNo callType, IOreq FAR2* ioreq ,FLFlash* flash, FLStatus* status){ BNANDVolumeHeaderRecord* volume; ANANDUnitNo originalUnits[MAX_NO_OF_FLOORS]; Bnand vol = vols + FL_GET_SOCKET_FROM_HANDLE(ioreq); byte partition = FL_GET_PARTITION_FROM_HANDLE(ioreq); FLStatus tmpStatus;
DEBUG_PRINT(("Debug: starting INFTL preMount operation.\r\n"));
/*************************/ /* Find the media header */ /*************************/
tmpStatus = initINFTLbasic(&vol,flash); if(tmpStatus == flOK) tmpStatus = retrieveHeader(&vol,originalUnits,FALSE,TRUE); if(tmpStatus != flOK) return tmpStatus;
*status = flOK;
if (callType == FL_COUNT_VOLUMES) /* get number of BDTL volumes routine */ { ioreq->irFlags = (byte)LE4(((BNANDBootRecord *)inftlBuffer)-> noOfBDTLPartitions); return flOK; }
/* Check media header for the specific partition */ volume = (BNANDVolumeHeaderRecord*)(inftlBuffer + sizeof(BNANDBootRecord));
if (partition > LE4(((BNANDBootRecord *)inftlBuffer)->noOfBDTLPartitions)) { *status = flBadDriveHandle; } else { volume += (LE4(((BNANDBootRecord *)inftlBuffer)->noOfBinaryPartitions)+ partition); }
switch (callType) {#if (defined(QUICK_MOUNT_FEATURE) && !defined(FL_READ_ONLY))
case FL_CLEAR_QUICK_MOUNT_INFO: if(*status != flBadDriveHandle) /* Valid partition number */ *status = flash->erase(flash, (word)(LE4(volume->firstQuickMountUnit) << vol.blockMultiplierBits), (word)((LE4(volume->firstUnit) - LE4(volume->firstQuickMountUnit)) << vol.blockMultiplierBits)); break;#endif /* QUICK_MOUNT_FEATURE AND NOT FL_READ_ONLY */
#ifdef HW_PROTECTION
case FL_PROTECTION_GET_TYPE: /* Protection routines */ case FL_PROTECTION_SET_LOCK: case FL_PROTECTION_CHANGE_KEY: case FL_PROTECTION_CHANGE_TYPE: case FL_PROTECTION_INSERT_KEY: case FL_PROTECTION_REMOVE_KEY: if(*status == flBadDriveHandle) /* Valid partition number */ break; *status = protectionINFTL(&vol,volume,ioreq,callType); break;#endif /* HW_PROTECTION */
default: /* not supported pre mount routine */ return flBadParameter; } /* end of callType switch */ return flOK; /* This TL took responsibility of this call */}
#if (defined(FORMAT_VOLUME) && !defined(FL_READ_ONLY))
/*----------------------------------------------------------------------*//* e r a s e U n i t *//* *//* Erase the unit while retaining the erase count. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Physical unit to format *//* *//* the progress is repored by the progressCallBack routine *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus eraseUnit(Bnand vol, ANANDUnitNo unitNo, FLProgressCallback progressCallback){ word eraseMark; dword eraseCount; FLStatus status;
if (progressCallback) { status = (*progressCallback)((word)(vol.flash->noOfChips * (vol.flash->chipSize >> vol.unitSizeBits)),(word)(unitNo+1)); if(status != flOK) { DFORMAT_PRINT(("Debug: ERROR failed reporting progress callback.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return status; } } status = getUnitTailer(&vol,unitNo,&eraseMark,&eraseCount,UNIT_TAILER_OFFSET); if(status == flOK) { status = vol.flash->erase(vol.flash,(word)(unitNo << vol.blockMultiplierBits), (word)(1 << vol.blockMultiplierBits)); } if (status == flOK) { eraseCount++; if (eraseCount == 0) /* was hex FF's */ eraseCount++; status = setUnitTailer(&vol,unitNo,ERASE_MARK,eraseCount,UNIT_TAILER_OFFSET); } if (status != flOK) { DEBUG_PRINT(("Debug: ERROR failed formating unit.\r\n")); markUnitBad(&vol,unitNo); /* make sure unit format is not valid */ dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ }
return status;}
/*----------------------------------------------------------------------*//* f o r m a t I N F T L *//* *//* Perform INFTL Format. *//* *//* Parameters: *//* volNo : Volume serial no. *//* fp : Address of FormatParams structure to use *//* flash : Flash media mounted on this socket *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/
static FLStatus formatINFTL(unsigned volNo, TLFormatParams *fp, FLFlash *flash){ Bnand vol = &vols[volNo]; /* TL record */ BDTLPartitionFormatParams FAR2* bdtl = fp->BDTLPartitionInfo; /* bdtl input */ BinaryPartitionFormatParams FAR2* binary = fp->binaryPartitionInfo; /* binary input */ BNANDBootRecord * mediaHeader; /* Disk header record */ BNANDVolumeHeaderRecord * volumeHeader; /* volume header record */ BNANDVolumeHeaderRecord * volumeHeader2; /* volume header record */ CardAddress iBlock; /* Block counter index */ ANANDUnitNo iUnit; /* unit index for loops */ ANANDUnitNo unitsNeededForVolume; /* good units needed for volume */ ANANDUnitNo floorGarantiedUnitsLeft; /* garantied units not yet distributed */ ANANDUnitNo binaryUnitsInFloor; /* number of binary unit in this floor */ ANANDUnitNo noOfUnitsPerFloor[MAX_NO_OF_FLOORS]; ANANDUnitNo floorGarantiedUnits[MAX_NO_OF_FLOORS]; /* garantied good units in floor */ ANANDUnitNo originalUnits[MAX_NO_OF_FLOORS]; /* unit no' of the original units */ ANANDUnitNo goodUnits[MAX_NO_OF_FLOORS]; /* no of good blocks in floor */ ANANDUnitNo skipedUnits; /* number of good units to leave as unfrmated */ ANANDUnitNo goodBlocks; FLStatus status; /* status of TrueFFS routines */ Sbyte volumeNo; /* current volume index */ Sbyte noOfVolumes = fp->noOfBDTLPartitions + fp->noOfBinaryPartitions; dword index; /* general loops index */ dword sizeOfLastBinary; byte * firstVolumePtr; byte headersBuffer[sizeof(inftlBuffer)]; byte floorNo; /* current floor index */ byte noOfFloors; byte temp; byte lastBinaryFloor;#ifdef HW_PROTECTION
ANANDUnitNo volumeStart; word protectionType = 0; /* Initialized to remove warrnings */ /* Highest floor to leave DPS untouched - per DPS */ byte binaryFloorOfDPS[MAX_PROTECTED_PARTITIONS]; byte changeableProtection = 0; byte unchangeableProtection = 0; byte protectionKey[PROTECTION_KEY_LENGTH];#endif /* HW_PROTECTION */
#ifdef WRITE_EXB_IMAGE
BinaryPartitionFormatParams exbBinaryPartition; byte exbSign[BINARY_SIGNATURE_LEN]; byte noOfBinary = fp->noOfBinaryPartitions;#endif /* WRITE_EXB_IMAGE */
#ifdef QUICK_MOUNT_FEATURE
Sword quickMount[MAX_VOLUMES_PER_DOC];
/* fp->flags |= TL_QUICK_MOUNT_FORMAT; */ for (volumeNo=0;volumeNo<MAX_VOLUMES_PER_DOC;volumeNo++) { quickMount[volumeNo]=0; }#endif /* QUICK_MOUNT_FEATURE */
/*-------------------------------------------------------
* Media header || Binary 0 + exb file || Binary 1,.. || *-------------------------------------------------------*/
/*-----------------------------------------------------
* quick mount + BDTL 0 || quick mount + BDTL 1, ... || *-----------------------------------------------------*/
DEBUG_PRINT(("Debug: starting INFTL format by verifying arguments.\r\n"));
tffsset(&vol,0,sizeof(vol));
/* Check that there is up to 4 volumes on the device provided one is a
* BDTL volume. If there is an exb file to be placed it would require * at least 1 binary volume */
if ((fp->noOfBDTLPartitions < 1) ||#ifdef WRITE_EXB_IMAGE
((fp->exbLen > 0) && (fp->noOfBDTLPartitions == MAX_VOLUMES_PER_DOC)) ||#endif /* WRITE_EXB_IMAGE */
(noOfVolumes > MAX_VOLUMES_PER_DOC)) { DFORMAT_PRINT(("ERROR - There can be up to 4 volumes while at least one is a BDTL.\r\n")); return flBadParameter; }
/*******************/ /* Initialization */ /*******************/
checkStatus(initINFTL(&vol,flash)); /* Initialize variables */ noOfFloors = flash->noOfFloors; vol.noOfVirtualUnits = 0;
#ifdef FL_MALLOC
status = initTables(&vol); /* Allocate tables */#else
status = initTables(&vol,0);#endif /* FL_MALLOC */
if(status != flOK) { DFORMAT_PRINT(("ERROR - Failed allocating memory for INFTL tables.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return status; } /* Calculate units per floor */ noOfUnitsPerFloor[0] = (ANANDUnitNo)(vol.flash->chipSize >> vol.unitSizeBits) * ((vol.flash->noOfChips + (vol.flash->noOfChips % vol.flash->noOfFloors)) / vol.flash->noOfFloors); floorGarantiedUnits[0] = (ANANDUnitNo)((dword)((dword)fp->percentUse * (dword)noOfUnitsPerFloor[0]) / 100 - 1); /* - header */ for (index=0;index+1<vol.flash->noOfFloors;index++) { noOfUnitsPerFloor[index] = noOfUnitsPerFloor[0]; floorGarantiedUnits[index] = floorGarantiedUnits[0]; } /* Last floor might have diffrent number of chips */ noOfUnitsPerFloor[index] = (ANANDUnitNo)(vol.noOfUnits - (index*noOfUnitsPerFloor[0])); floorGarantiedUnits[index] = (ANANDUnitNo)((dword)fp->percentUse * noOfUnitsPerFloor[index] / 100 - 1);
/********************************************************************/ /* Read BBT , find headers location and count number of good blocks */ /********************************************************************/
status = retrieveHeader (&vol ,originalUnits,TRUE, (fp->flags & FL_LEAVE_BINARY_AREA) ? TRUE : FALSE); tffscpy(headersBuffer,inftlBuffer,sizeof(headersBuffer)); mediaHeader = (BNANDBootRecord *)headersBuffer; firstVolumePtr= headersBuffer + sizeof(BNANDBootRecord);
/* If previous header was not found it is not possible to leave
* the previous binary partition. */
if(status == flBadFormat) { if(fp->flags & FL_LEAVE_BINARY_AREA) { DFORMAT_PRINT(("NOTE - Previous binary partition data could not be found.\r\n")); fp->flags &= ~FL_LEAVE_BINARY_AREA; } }
if(status == flBadBBT) { DFORMAT_PRINT(("ERROR - Unreadable Bad Blocks Table.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return status; }
if(vol.physicalUnits[0] == BBT_BAD_UNIT) { DFORMAT_PRINT(("ERROR - IPL block is bad.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return flBadIPLBlock; }
/* Loop over the floors of the media while counting the good units
* the good units are needed for the transfere unit calculation. * In addition change the MTD values of Bad unit ro INFTL */
for (floorNo = 0 , iUnit = 0 , index = 0 ; floorNo<noOfFloors ; floorNo++) { index += noOfUnitsPerFloor[floorNo]; goodBlocks = noOfUnitsPerFloor[floorNo]; for (;iUnit<index;iUnit++) { if (vol.physicalUnits[iUnit]!=BBT_GOOD_UNIT) { goodBlocks--; vol.physicalUnits[iUnit] = UNIT_BAD; } else { vol.physicalUnits[iUnit] = ANAND_UNIT_FREE; } } goodBlocks--; /* Do not count one unit for floor header */ if (goodBlocks < floorGarantiedUnits[floorNo]) { DFORMAT_PRINT(("ERROR - Too many bad block on flash->\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return flVolumeTooSmall; } /* Save amount of good blocks for later */ goodUnits[floorNo] = goodBlocks; }
/************************************/ /* Construct binary volumes headers */ /************************************/
volumeHeader = (BNANDVolumeHeaderRecord *) firstVolumePtr; goodBlocks = 0; /* good units already used (counting headers) */ skipedUnits = 0; /* good units to leave unformated (not counting headers) */#ifdef HW_PROTECTION
for(index = 0 ; index < MAX_PROTECTED_PARTITIONS ; index++) binaryFloorOfDPS[index] = MAX_NO_OF_FLOORS; /* Invalid floor no */#endif /* HW_PROTECTION */
if(fp->flags & FL_LEAVE_BINARY_AREA) /* Previous Boot area is kept */ { if(fp->bootImageLen == -1) /* kept entirely */ { for (index = 0;index < LE4(mediaHeader->noOfBinaryPartitions); index++,volumeHeader++) { /* not including headers */ skipedUnits += (ANANDUnitNo)LE4(volumeHeader->virtualUnits);#ifdef HW_PROTECTION
if (LE4(volumeHeader->flags) & PROTECTABLE) { if (LE4(volumeHeader->protectionArea) >= flash->totalProtectedAreas) { tffsset(headersBuffer,0,sizeof(headersBuffer)); DFORMAT_PRINT(("ERROR - Previous Binary partition had a bad protection area field.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return flBadFormat; } binaryFloorOfDPS[LE4(volumeHeader->protectionArea)] = skipedUnits / floorGarantiedUnits[0]; }#endif /* HW_PROTECTION */
} } else /* erase all previous binary partitions */ { tffsset(headersBuffer,0,sizeof(headersBuffer)); if(fp->bootImageLen != 0) DFORMAT_PRINT(("ERROR - Requested Binary partition size is diffrent then previous one.\r\n")); } /* clean the bdtl entries */ tffsset(volumeHeader, 0,(word)(sizeof(headersBuffer)-((byte *)volumeHeader-headersBuffer))); goodBlocks = skipedUnits; /* Update the number of partitions with the binary partitions */ fp->noOfBinaryPartitions = (byte)(volumeHeader - (BNANDVolumeHeaderRecord *) firstVolumePtr); noOfVolumes = fp->noOfBDTLPartitions + fp->noOfBinaryPartitions; if(noOfVolumes > MAX_VOLUMES_PER_DOC) { DFORMAT_PRINT(("ERROR - There can be up to 4 volumes while at least one is a BDTL.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return flBadParameter; } } else /* Apply binary area format parameters */ { tffsset(headersBuffer,0,sizeof(headersBuffer)); /* reset all binary area */ for (volumeNo=0;volumeNo<fp->noOfBinaryPartitions; volumeNo++,binary++,volumeHeader++) { binary->length = roundToUnits(binary->length); if (binary->length == 0) {#ifdef WRITE_EXB_IMAGE
if(((fp->exbLen == 0) && (volumeNo == 0)) || ( volumeNo != 0 ) )#endif /* WRITE_EXB_IMAGE */
{ DFORMAT_PRINT(("ERROR - BINARY partition length should not be 0.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return flBadParameter; } } toLE4(volumeHeader->virtualUnits,binary->length);#ifdef HW_PROTECTION
toLE4(volumeHeader->flags ,INFTL_BINARY | binary->protectionType);#else
toLE4(volumeHeader->flags ,INFTL_BINARY);#endif /* HW_PROTECTION */
goodBlocks += (ANANDUnitNo)LE4(volumeHeader->virtualUnits); /* In Units */ } binary = fp->binaryPartitionInfo;
/* Add EXB area */#ifdef WRITE_EXB_IMAGE
if (fp->exbLen>0) { fp->exbLen = roundToUnits(fp->exbLen); goodBlocks += (ANANDUnitNo)fp->exbLen; tffscpy(exbSign,SIGN_SPL,BINARY_SIGNATURE_NAME); tffsset(exbSign+BINARY_SIGNATURE_NAME,'F',BINARY_SIGNATURE_NAME); if (fp->noOfBinaryPartitions > 0) /* Add firmware blocks */ { toLE4(((BNANDVolumeHeaderRecord*)firstVolumePtr)->virtualUnits, LE4(((BNANDVolumeHeaderRecord*)firstVolumePtr)->virtualUnits) + fp->exbLen); } else /* Must create a binary partition just for firmware */ { fp->noOfBinaryPartitions = 1; toLE4(volumeHeader->virtualUnits,fp->exbLen );#ifdef HW_PROTECTION
if(noOfBinary) /* Do not use binary record unless it was allocated */ { toLE4(volumeHeader->flags ,INFTL_BINARY | binary->protectionType); exbBinaryPartition.protectionType = binary->protectionType; } else#endif /* HW_PROTECTION */
toLE4(volumeHeader->flags ,INFTL_BINARY); binary = &exbBinaryPartition; volumeHeader++; noOfVolumes++; } fp->exbLen <<= vol.blockMultiplierBits; }#endif /* WRITE_EXB_IMAGE */
toLE4(mediaHeader->noOfBinaryPartitions, fp->noOfBinaryPartitions); }
binaryUnitsInFloor = goodBlocks % floorGarantiedUnits[0]; lastBinaryFloor = goodBlocks / floorGarantiedUnits[0]; goodBlocks += noOfFloors;
/********************************/ /* Construct Main media header */ /********************************/
tffscpy(mediaHeader->bootRecordId,"BNAND", TL_SIGNATURE); tffscpy(&(mediaHeader->osakVersion),TrueFFSVersion,sizeof(TrueFFSVersion)); toLE4(mediaHeader->percentUsed , fp->percentUse ); toLE4(mediaHeader->blockMultiplierBits , vol.blockMultiplierBits); toLE4(mediaHeader->formatFlags , 0 ); toLE4(mediaHeader->noOfBDTLPartitions , fp->noOfBDTLPartitions );/* noOfBinaryPartitions was already determinded */
/**********************************/ /* Construct BDTL volumes headers */ /**********************************/
for (volumeNo=1;(byte)volumeNo<LE4(mediaHeader->noOfBDTLPartitions); bdtl++,volumeNo++,volumeHeader++) { if (bdtl->length < flash->erasableBlockSize) { DFORMAT_PRINT(("ERROR - INFTL partition length should not be least one unit long.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return flBadParameter; } toLE4(volumeHeader->virtualUnits , roundToUnits(bdtl->length)); toLE4(volumeHeader->spareUnits , bdtl->noOfSpareUnits ); toLE4(volumeHeader->flags , INFTL_BDTL ); goodBlocks += (ANANDUnitNo)LE4(volumeHeader->virtualUnits) + bdtl->noOfSpareUnits;#ifdef HW_PROTECTION
toLE4(volumeHeader->flags,LE4(volumeHeader->flags) | bdtl->protectionType);#endif /* HW_PROTECTION */
#ifdef QUICK_MOUNT_FEATURE
/* if (fp->flags & TL_QUICK_MOUNT_FORMAT) */ { dword quickMountBytes;
quickMountBytes = (ANANDUnitNo)(LE4(volumeHeader->virtualUnits) + LE4(volumeHeader->spareUnits)); quickMountBytes += ((quickMountBytes / noOfUnitsPerFloor[0] + 1) * noOfUnitsPerFloor[0] * (100L-fp->percentUse) / 100L); quickMountBytes *= RAM_FACTOR; quickMountBytes += flash->pageSize; quickMount[volumeNo-1] = roundToUnits(quickMountBytes); goodBlocks += quickMount[volumeNo-1]; }#endif /* QUICK_MOUNT_FEATURE */
}
/* The size of the last partition is defined by the media itself */
goodBlocks += fp->noOfSpareUnits; for(index=0,floorNo=0;floorNo<noOfFloors;floorNo++) { index+=floorGarantiedUnits[floorNo]; } toLE4(volumeHeader->flags , INFTL_BDTL | INFTL_LAST); toLE4(volumeHeader->spareUnits , fp->noOfSpareUnits ); toLE4(volumeHeader->lastUnit , vol.noOfUnits-1); toLE4(volumeHeader->virtualUnits , index + noOfFloors - goodBlocks);#ifdef QUICK_MOUNT_FEATURE
/* if (fp->flags & TL_QUICK_MOUNT_FORMAT) */ { dword quickMountBytes;
quickMountBytes = (ANANDUnitNo)(LE4(volumeHeader->virtualUnits) + LE4(volumeHeader->spareUnits)); quickMountBytes += ((quickMountBytes / noOfUnitsPerFloor[0] + 1) * noOfUnitsPerFloor[0] * (100L-fp->percentUse) / 100L); quickMountBytes *= RAM_FACTOR; quickMountBytes += flash->pageSize;
toLE4(mediaHeader->formatFlags , QUICK_MOUNT); quickMount[volumeNo-1] = roundToUnits(quickMountBytes); toLE4(volumeHeader->virtualUnits , LE4(volumeHeader->virtualUnits) - quickMount[volumeNo-1]); }#endif /* QUICK_MOUNT_FEATURE */
if ((LE4(volumeHeader->virtualUnits) < 1) || (LE4(volumeHeader->virtualUnits) > vol.noOfUnits)) { DFORMAT_PRINT(("ERROR - Partition lengths could not be placed on the media.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return flVolumeTooSmall; }
/*******************************************/ /* Allocate protection area to the volumes */ /*******************************************/
#ifdef HW_PROTECTION
toLE4(volumeHeader->flags,LE4(volumeHeader->flags) | /* Ignore other flags */ fp->protectionType);
for (volumeNo = noOfVolumes, volumeHeader = (BNANDVolumeHeaderRecord *)firstVolumePtr; volumeNo>0;volumeNo--,volumeHeader++) { if (LE4(volumeHeader->flags) & PROTECTABLE) { if (flash->protectionSet == NULL) { DFORMAT_PRINT(("ERROR - setting protection routines are not available.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return flFeatureNotSupported; } if (LE4(volumeHeader->flags) & CHANGEABLE_PROTECTION) /* last areas (n,n-1,n-2..)*/ { changeableProtection++; /* Number of protected partitions */ toLE4(volumeHeader->protectionArea , flash->totalProtectedAreas - changeableProtection); } else /* first areas (0,1,2,..) */ { toLE4(volumeHeader->protectionArea , unchangeableProtection); unchangeableProtection++; } } }
/* Make sure the device support enough protected areas */
if ((changeableProtection > flash->changeableProtectedAreas) || (unchangeableProtection + changeableProtection > flash->totalProtectedAreas)) { DFORMAT_PRINT(("ERROR - too many protected areas.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return flBadParameter; }
/* Clear previous protection areas and write protect them */
for (index=0;index<flash->totalProtectedAreas;index++) { /* Send default key to open all protected areas */ status = flash->protectionKeyInsert(flash,(byte)index,(byte FAR1 *)DEFAULT_KEY); }
/* Clear all floors execpt for those that have only binary partitions */ for (floorNo=skipedUnits/floorGarantiedUnits[0];floorNo<noOfFloors;floorNo++) { for (index=0;index<flash->totalProtectedAreas;index++) { if(binaryFloorOfDPS[index] == floorNo) break; /* Belongs to a binary partition that must be left */ status = flash->protectionSet(flash,(byte)index, WRITE_PROTECTED, /* Write protect */ (index+1) << flash->erasableBlockSizeBits, /* Low address */ (index+1) << flash->erasableBlockSizeBits, /* High address */ (byte *)DEFAULT_KEY,DO_NOT_COMMIT_PROTECTION,floorNo); if (status != flOK) { DFORMAT_PRINT(("ERROR - FAILED clearing previous protection areas.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return status; } } }#endif /* HW_PROTECTION */
/***********************************/ /* Actual format of the partitions */ /***********************************/
DEBUG_PRINT(("Debug: INFTL format arguments have been verified, starting format.\r\n"));
unitsNeededForVolume = 0; floorNo = skipedUnits / floorGarantiedUnits[0]; volumeNo = -1; /* bdtl volume number */ bdtl = fp->BDTLPartitionInfo; iUnit = originalUnits[floorNo]+1; /* write after the first header */ volumeHeader = (BNANDVolumeHeaderRecord *) firstVolumePtr; /* location of first partition header */ floorGarantiedUnitsLeft = floorGarantiedUnits[floorNo]; /* floors units left */
/* Skip the boot image area if the FL_LEAVE_BINARY_AREA was set */
if (skipedUnits > 0 ) { skipedUnits %= floorGarantiedUnits[0]; /* skipped units on the current floor */ floorGarantiedUnitsLeft -= skipedUnits; /* floors units left */ volumeHeader += (word)LE4(mediaHeader->noOfBinaryPartitions); sizeOfLastBinary = LE4((volumeHeader-1)->virtualUnits);
/* Clear previous BDTL entries and adjust binary partition */ for (index = 0 ; index < floorNo ; index++) { /* read previous floor header */ status = flash->read(flash,((CardAddress)originalUnits[index] << vol.unitSizeBits) + sizeof(BNANDBootRecord), firstVolumePtr, sizeof(BNANDVolumeHeaderRecord) * (fp->noOfBinaryPartitions) ,0);
if(status != flOK) { DFORMAT_PRINT(("ERROR - FAILED reading previous INFTL header.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return status; } toLE4((volumeHeader-1)->virtualUnits , sizeOfLastBinary); /* adjust virtual size */ if((index == (dword)(floorNo - 1)) && (skipedUnits == 0)) toLE4((volumeHeader-1)->lastUnit , ((index+1) * noOfUnitsPerFloor[0]) - 1); /* adjust last block */
/* Erase and write the new updated header */ status = eraseUnit(&vol,originalUnits[index],fp->progressCallback); if(status != flOK) { DFORMAT_PRINT(("ERROR - FAILED erasing previous INFTL header.\r\n")); return status; } for (temp = 0 ; temp < NO_OF_MEDIA_HEADERS ; temp++) { status = flash->write(flash,((CardAddress)originalUnits[index] << vol.unitSizeBits) + temp * HEADERS_SPACING, headersBuffer, sizeof(headersBuffer),EDC); if (status != flOK) { DFORMAT_PRINT(("ERROR - FAILED rewriting INFTL header.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return status; } } }
/* Skip to first BDTL block */ for (;skipedUnits > 0;skipedUnits--) { do { iUnit++; }while (vol.physicalUnits[iUnit] == UNIT_BAD); }
/* Save last binary unit for floors header */ if(iUnit != originalUnits[floorNo]+1) toLE4((volumeHeader-1)->lastUnit , iUnit - 1); /* adjust last block */ }
do /* loop over floors */ { goodBlocks = goodUnits[floorNo]; /* Good blocks of the floor */
/* Format as many volumes as posible in this floor */
while((floorGarantiedUnitsLeft > 0) && (noOfVolumes >= 0)) { if (unitsNeededForVolume == 0) /* Read header of next volume */ { noOfVolumes--; toLE4(volumeHeader->firstQuickMountUnit , iUnit); unitsNeededForVolume = (ANANDUnitNo)(LE4(volumeHeader->virtualUnits) + LE4(volumeHeader->spareUnits));#ifdef QUICK_MOUNT_FEATURE
if (LE4(volumeHeader->flags) & INFTL_BDTL) { volumeNo++; unitsNeededForVolume +=quickMount[volumeNo]; }#else
toLE4(volumeHeader->firstUnit , iUnit);#endif /* QUICK_MOUNT_FEATURE */
/* Copy protection key and type */
#ifdef HW_PROTECTION
if (LE4(volumeHeader->flags) & INFTL_BDTL) { if (LE4(volumeHeader->flags) & INFTL_LAST) { tffscpy(protectionKey,fp->protectionKey,PROTECTION_KEY_LENGTH); protectionType = fp->protectionType; } else { tffscpy(protectionKey,bdtl->protectionKey,PROTECTION_KEY_LENGTH); protectionType = bdtl->protectionType; } } else /* Binary */ { tffscpy(protectionKey,binary->protectionKey,PROTECTION_KEY_LENGTH); protectionType = binary->protectionType; }#endif /* HW_PROTECTION */
}
/* update format indexs. */
if (unitsNeededForVolume > floorGarantiedUnitsLeft) { /* Volume does not fits in floor */ index = floorGarantiedUnitsLeft; unitsNeededForVolume -= floorGarantiedUnitsLeft; floorGarantiedUnitsLeft = 0; } else { /* Entire volume fits in floor */ index = unitsNeededForVolume; floorGarantiedUnitsLeft -= unitsNeededForVolume; unitsNeededForVolume = 0; }
/*******************************************/ /* Format the volumes blocks of this floor */ /*******************************************/
#ifdef HW_PROTECTION
volumeStart = iUnit;#endif /* HW_PROTECTION */
if (LE4(volumeHeader->flags) & INFTL_BDTL) /* BDTL VOLUME FORMAT */ { /* Add transfer units */
if (floorNo == lastBinaryFloor) { index *= (goodBlocks - binaryUnitsInFloor); index /= (floorGarantiedUnits[floorNo] - binaryUnitsInFloor); } else { index *= goodBlocks; index /= floorGarantiedUnits[floorNo]; }
/* Format units */
while (index > 0) { if (vol.physicalUnits[iUnit] == ANAND_UNIT_FREE) {#ifdef QUICK_MOUNT_FEATURE
/* Set the real first unit after the quick mount data */
if (quickMount[volumeNo] >= 0) { if(quickMount[volumeNo] == 0) { toLE4(volumeHeader->firstUnit , iUnit); } (quickMount[volumeNo])--; }#endif /* QUICK_MOUNT_FEATURE */
index--; status = eraseUnit(&vol, iUnit,fp->progressCallback); if(status != flOK) return status; } else { if (fp->progressCallback) { (*fp->progressCallback)((word)(flash->noOfChips * (flash->chipSize >> vol.unitSizeBits)),(word)(iUnit+1)); } } iUnit++; } if (unitsNeededForVolume == 0) bdtl++; } if (LE4(volumeHeader->flags) & INFTL_BINARY) /* BINARY VOLUME FORMAT */ { toLE4(volumeHeader->firstUnit , LE4(volumeHeader->firstQuickMountUnit)); for (; (index > 0) ; iUnit++) { if (vol.physicalUnits[iUnit] == ANAND_UNIT_FREE) { index--; status = eraseUnit(&vol, iUnit,fp->progressCallback); if(status != flOK) return status;
for (iBlock=0;iBlock<(1UL<<vol.unitSizeBits);iBlock+=(1L<<vol.erasableBlockSizeBits)) {#ifdef WRITE_EXB_IMAGE
if (fp->exbLen > 0) { fp->exbLen--; status = flash->write(flash, 8 + iBlock + ((CardAddress)(iUnit) << vol.unitSizeBits), exbSign,BINARY_SIGNATURE_LEN,EXTRA); } else#endif /* WRITE_EXB_IMAGE */
{ status = flash->write(flash, binary->signOffset + iBlock + ((CardAddress)(iUnit) << vol.unitSizeBits), binary->sign,BINARY_SIGNATURE_NAME,EXTRA); } if (status != flOK) { DFORMAT_PRINT(("ERROR - FAILED formating binary unit.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return status; } } } else /* unit is bad */ { if (fp->progressCallback) { (*fp->progressCallback)((word)(flash->noOfChips * (flash->chipSize >> vol.unitSizeBits)),(word)(iUnit+1)); } } } if (unitsNeededForVolume == 0) binary++; }#ifdef HW_PROTECTION
/* Place protection attributes to the volume */
if (LE4(volumeHeader->flags) & PROTECTABLE) {
#ifndef NT5PORT
status = flash->protectionSet(flash,(byte)LE4(volumeHeader->protectionArea), protectionType, ((CardAddress)volumeStart % noOfUnitsPerFloor[floorNo]) << vol.unitSizeBits, ((CardAddress)((iUnit-1) % noOfUnitsPerFloor[floorNo])) << vol.unitSizeBits , (byte *)&protectionKey,DO_NOT_COMMIT_PROTECTION,floorNo);#else /*NT5PORT*/
status = flash->protectionSet(flash,(byte)LE4(volumeHeader->protectionArea), protectionType, ((CardAddress)volumeStart % noOfUnitsPerFloor[floorNo]) << vol.unitSizeBits, ((CardAddress)((iUnit-1) % noOfUnitsPerFloor[floorNo])) << vol.unitSizeBits , protectionKey,DO_NOT_COMMIT_PROTECTION,floorNo);#endif /*NT5PORT*/
if (status != flOK) { DFORMAT_PRINT(("ERROR - FAILED setting protection.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return status; } }#endif /* HW_PROTECTION */
if (unitsNeededForVolume == 0) { toLE4(volumeHeader->lastUnit , iUnit - 1); volumeHeader++; } } /* loop until no more units in this floor */
/* Convert any leftovers to BDTL units */
index = noOfUnitsPerFloor[floorNo] + floorNo*noOfUnitsPerFloor[0]; while (iUnit < index) { if (vol.physicalUnits[iUnit] == ANAND_UNIT_FREE) { status = eraseUnit(&vol, iUnit,fp->progressCallback); if(status != flOK) return status; } else { if (fp->progressCallback) { (*fp->progressCallback)((word)(flash->noOfChips * (flash->chipSize >> vol.unitSizeBits)),(word)(iUnit+1)); } } iUnit++; }
/* Update last unit of BDTL partition */ if ((unitsNeededForVolume == 0) && (LE4((volumeHeader-1)->flags) & INFTL_BDTL)) { toLE4((volumeHeader-1)->lastUnit , iUnit-1); }
/***************************/ /* Place the floors header */ /***************************/
iUnit = originalUnits[floorNo];
status = eraseUnit(&vol, iUnit,NULL); if(status != flOK) return status;
for (index = 0 ; index < NO_OF_MEDIA_HEADERS;index++) { status = flash->write(flash,((CardAddress)iUnit << vol.unitSizeBits) + index * HEADERS_SPACING,headersBuffer, sizeof(headersBuffer),EDC); if (status != flOK) { DFORMAT_PRINT(("ERROR - FAILED writing INFTL header.\r\n")); dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return status; } }
/**************************/ /* Prepare next iteration */ /**************************/
floorNo++; if (floorNo < noOfFloors) { iUnit=originalUnits[floorNo]+1; floorGarantiedUnitsLeft = floorGarantiedUnits[floorNo];
/* Erase physical unit locations to enable independet unit headers */
volumeHeader2 = (BNANDVolumeHeaderRecord *) firstVolumePtr; /* location of first partition header */ while (volumeHeader2<=volumeHeader) { toLE4(volumeHeader2->firstUnit , 0); toLE4(volumeHeader2->lastUnit , 0); toLE4(volumeHeader2->firstQuickMountUnit , 0); volumeHeader2++; } } else { break; } } while (1); /* loop over floors */
DEBUG_PRINT(("Debug: finished INFTL format.\r\n"));
dismountINFTL(&vol); /*Free tables must be done after call to initTables*/ return flOK;}
#endif /* FORMAT_VOLUME && not FL_READ_ONLY */
/*----------------------------------------------------------------------*//* f l R e g i s t e r I N F T L *//* *//* Register this translation layer *//* *//* Parameters: *//* None *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failure *//*----------------------------------------------------------------------*/
FLStatus flRegisterINFTL(void){#ifdef FL_MALLOC
int i;#endif /* FL_MALLOC */
if (noOfTLs >= TLS) return flTooManyComponents;
tlTable[noOfTLs].mountRoutine = mountINFTL; tlTable[noOfTLs].preMountRoutine = preMountINFTL;
#if (defined(FORMAT_VOLUME) && !defined(FL_READ_ONLY))
tlTable[noOfTLs].formatRoutine = formatINFTL;#else
tlTable[noOfTLs].formatRoutine = noFormat;#endif /* FORMAT_VOLUME && not FL_READ_ONLY */
noOfTLs++;
#ifdef FL_MALLOC
/* reset multi sector buffer */ for(i=0;( i < SOCKETS );i++) { multiSectorBufCounter[i] = -1; } /* reset convertion tables */ for(i=0;( i < VOLUMES );i++) { vols[i].physicalUnits = NULL; vols[i].virtualUnits = NULL;#ifdef NFTL_CACHE
/* reset catche tables */ vols[i].ucache = NULL; vols[i].scache = NULL;#endif /* NFTL_CACHE */
}#endif /* FL_MALLOC */
return flOK;}
|
