// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// f32\sfat32\fat_table32.cpp

// FAT32 File Allocation Table classes implementation

// 

//

/**

 @file

 @internalTechnology

*/

#include "sl_std.h"

#include "sl_fatcache32.h"

#include "fat_table32.h"

//---------------------------------------------------------------------------------------------------------------------------------------

/** 

    Implements automatic locking object.

    Calls TDriveInterface::AcquireLock() on construction and TDriveInterface::ReleaseLock() on destruction. 

    Can be constructed on the stack only.

*/

class XAutoLock

    {

     public:

       inline XAutoLock(CFatMountCB* apOwner) : iDrv(apOwner->DriveInterface()) {iDrv.AcquireLock();}

       inline XAutoLock(TDriveInterface& aDrv) : iDrv(aDrv) {iDrv.AcquireLock();}

       inline ~XAutoLock() {iDrv.ReleaseLock();}

     private:

        void* operator new(TUint); //-- disable creating objects on heap.

        void* operator new(TUint, void*);

     private:

        TDriveInterface &iDrv; ///< reference to the drive interface

    };

//---------------------------------------------------------------------------------------------------------------------------------------

//#######################################################################################################################################

//#     CFatTable class implementation 

//#######################################################################################################################################

/**

    FAT object factory method.

    Constructs either CAtaFatTable or CRamFatTable depending on the media type parameter

    @param aOwner Pointer to the owning mount

    @param aLocDrvCaps local drive attributes

    @leave KErrNoMemory

    @return Pointer to the Fat table

*/

CFatTable* CFatTable::NewL(CFatMountCB& aOwner, const TLocalDriveCaps& aLocDrvCaps)

	{

    CFatTable* pFatTable=NULL;

    switch(aLocDrvCaps.iType)

        {

        case EMediaRam:

		    {//-- this is RAM media, try to create CRamFatTable instance.

            const TFatType fatType = aOwner.FatType();

            if(fatType != EFat16 && fatType != EFat32)

                {//-- CRamFatTable doesn't support FAT12, FAT16 & FAT32 only.

                __PRINT1(_L("CFatTable::NewL() CRamFatTable doesn't support this FAT type:%d"), fatType);

                ASSERT(0);

                return NULL;

                }

            pFatTable = CRamFatTable::NewL(aOwner);

            }

        break;

        default:

            //-- other media

            pFatTable = CAtaFatTable::NewL(aOwner);

        break;

        };

	return pFatTable;

	}

CFatTable::CFatTable(CFatMountCB& aOwner)

{

    iOwner = &aOwner;

    ASSERT(iOwner);

}

CFatTable::~CFatTable()

{

    //-- destroy cache ignoring dirty data in cache

    //-- the destructor isn't an appropriate place to flush the data.

    Dismount(ETrue); 

}

//-----------------------------------------------------------------------------

/**

    Initialise the object, get data from the owning CFatMountCB

*/

void CFatTable::InitializeL()

    {

    ASSERT(iOwner);

    //-- get FAT type from the owner

    iFatType = iOwner->FatType();

    ASSERT(IsFat12() || IsFat16() || IsFat32());

    //-- set the EOC code

    iFatEocCode = EocCodeByFatType(iFatType);

    iFreeClusterHint = KFatFirstSearchCluster;

    //-- cache the media attributes

    TLocalDriveCapsV2 caps;

    TPckg<TLocalDriveCapsV2> capsPckg(caps);

    User::LeaveIfError(iOwner->LocalDrive()->Caps(capsPckg));

    iMediaAtt = caps.iMediaAtt;

    //-- obtain maximal number of entries in the table

    iMaxEntries = iOwner->UsableClusters()+KFatFirstSearchCluster; //-- FAT[0] & FAT[1] are not in use

    __PRINT3(_L("CFatTable::InitializeL(), drv:%d, iMediaAtt = %08X, max Entries:%d"), iOwner->DriveNumber(), iMediaAtt, iMaxEntries);

    }

//-----------------------------------------------------------------------------

/** 

    Decrements the free cluster count.

    Note that can be quite expensive operation (especially for overrides with synchronisation), if it is called for every 

    cluster of a large file. Use more than one cluster granularity.

    @param  aCount a number of clusters 

*/

void CFatTable::DecrementFreeClusterCount(TUint32 aCount)

    {

    __ASSERT_DEBUG(iFreeClusters >= aCount, Fault(EFatCorrupt));

    iFreeClusters -= aCount;

    }

/** 

    Increments the free cluster count.

    Note that can be quite expensive operation (especially for overrides with synchronisation), if it is called for every 

    cluster of a large file. Use more than one cluster granularity.

    @param  aCount a number of clusters 

*/

void CFatTable::IncrementFreeClusterCount(TUint32 aCount)

    {

	const TUint32 newVal = iFreeClusters+aCount;

    __ASSERT_DEBUG(newVal<=MaxEntries(), Fault(EFatCorrupt));

    iFreeClusters = newVal;

    }

/** @return number of free clusters in the FAT */

TUint32 CFatTable::NumberOfFreeClusters(TBool /*aSyncOperation=EFalse*/) const

    {

    return FreeClusters();

    }

void CFatTable::SetFreeClusters(TUint32 aFreeClusters)

    {   

    iFreeClusters=aFreeClusters;

    }

/**

    Get the hint about the last known free cluster number.

    Note that can be quite expensive operation (especially for overrides with synchronisation), if it is called for every 

    cluster of a large file.

    @return cluster number supposedly close to the free one.

*/

TUint32 CFatTable::FreeClusterHint() const 

    {

    ASSERT(ClusterNumberValid(iFreeClusterHint));

    return iFreeClusterHint;

    } 

/**

    Set a free cluster hint. The next search fro the free cluster can start from this value.

    aCluster doesn't have to be a precise number of free FAT entry; it just needs to be as close as possible to the 

    free entries chain.

    Note that can be quite expensive operation (especially for overrides with synchronisation), if it is called for every 

    cluster of a large file.

    @param aCluster cluster number hint.

*/

void CFatTable::SetFreeClusterHint(TUint32 aCluster) 

    {

    ASSERT(ClusterNumberValid(aCluster));

    iFreeClusterHint=aCluster;

    } 

//-----------------------------------------------------------------------------

/**

    Find out the number of free clusters on the volume.

    Reads whole FAT and counts free clusters.

*/

void CFatTable::CountFreeClustersL()

    {

    __PRINT1(_L("#- CFatTable::CountFreeClustersL(), drv:%d"), iOwner->DriveNumber());

    const TUint32 KUsableClusters = iOwner->UsableClusters();

    (void)KUsableClusters;

    TUint32 freeClusters = 0;

    TUint32 firstFreeCluster = 0;

    TTime   timeStart;

    TTime   timeEnd;

    timeStart.UniversalTime(); //-- take start time

    //-- walk through whole FAT table looking for free clusters

	for(TUint i=KFatFirstSearchCluster; i<MaxEntries(); ++i)

    {

	    if(ReadL(i) == KSpareCluster)

            {//-- found a free cluster

		    ++freeClusters;

            if(!firstFreeCluster)

                firstFreeCluster = i;

            }

	    }

    timeEnd.UniversalTime(); //-- take end time

    const TInt msScanTime = (TInt)( (timeEnd.MicroSecondsFrom(timeStart)).Int64() / K1mSec);

    __PRINT1(_L("#- CFatTable::CountFreeClustersL() finished. Taken:%d ms"), msScanTime);

    (void)msScanTime;

    if(!firstFreeCluster) //-- haven't found free clusters on the volume

        firstFreeCluster = KFatFirstSearchCluster;

    ASSERT(freeClusters <= KUsableClusters);

    SetFreeClusters(freeClusters);

    SetFreeClusterHint(firstFreeCluster);

    }

//-----------------------------------------------------------------------------

/**

Count the number of contiguous cluster from a start cluster

@param aStartCluster cluster to start counting from

@param anEndCluster contains the end cluster number upon return

@param aMaxCount Maximum cluster required

@leave System wide error values

@return Number of contiguous clusters from aStartCluster.

*/

TInt CFatTable::CountContiguousClustersL(TUint32 aStartCluster,TInt& anEndCluster,TUint32 aMaxCount) const

	{

	__PRINT2(_L("CFatTable::CountContiguousClustersL() start:%d, max:%d"),aStartCluster, aMaxCount);

	TUint32 clusterListLen=1;

	TInt endCluster=aStartCluster;

	TInt64 endClusterPos=DataPositionInBytes(endCluster);

	while (clusterListLen<aMaxCount)

		{

		TInt oldCluster=endCluster;

		TInt64 oldClusterPos=endClusterPos;

		if (GetNextClusterL(endCluster)==EFalse || (endClusterPos=DataPositionInBytes(endCluster))!=(oldClusterPos+(1<<iOwner->ClusterSizeLog2())))

			{

			endCluster=oldCluster;

			break;

			}

		clusterListLen++;

		}

	anEndCluster=endCluster;

	return(clusterListLen);

	}	

//-----------------------------------------------------------------------------

/**

    Extend a file or directory cluster chain, leaves if there are no free clusters (the disk is full).

    @param aNumber  amount of clusters to allocate

    @param aCluster FAT entry index to start with.

    @leave KErrDiskFull + system wide error codes

*/

void CFatTable::ExtendClusterListL(TUint32 aNumber,TInt& aCluster)

	{

	__PRINT2(_L("CFatTable::ExtendClusterListL() num:%d, clust:%d"), aNumber, aCluster);

	__ASSERT_DEBUG(aNumber>0,Fault(EFatBadParameter));

	while(aNumber && GetNextClusterL(aCluster))

		aNumber--;

    if(!aNumber)

        return;

    if(!RequestFreeClusters(aNumber))

		{

		__PRINT(_L("CFatTable::ExtendClusterListL - leaving KErrDirFull"));

		User::Leave(KErrDiskFull);

		}

    TUint32 freeCluster = 0;

    //-- note: this can be impoved by trying to fing as long chain of free clusters as possible in FindClosestFreeClusterL()

    for(TUint i=0; i<aNumber; ++i)

        {

        freeCluster = FindClosestFreeClusterL(aCluster);

        WriteFatEntryEofL(freeCluster); //	Must write EOF for FindClosestFreeCluster to work again

        WriteL(aCluster,freeCluster);

        aCluster=freeCluster;

        }

    //-- decrement number of available clusters

    DecrementFreeClusterCount(aNumber);

    //-- update free cluster hint, it isn't required to be a precise value, just a hint where to start the from from

    SetFreeClusterHint(aCluster); 

    }

//-----------------------------------------------------------------------------

/**

    Allocate and mark as EOF a single cluster as close as possible to aNearestCluster

    @param aNearestCluster Cluster the new cluster should be nearest to

    @leave System wide error codes

    @return The cluster number allocated

*/

TUint32 CFatTable::AllocateSingleClusterL(TUint32 aNearestCluster)

	{

	__PRINT1(_L("CFatTable::AllocateSingleCluster() nearest:%d"), aNearestCluster);

    const TInt freeCluster=FindClosestFreeClusterL(aNearestCluster);

	WriteFatEntryEofL(freeCluster);

	DecrementFreeClusterCount(1);

    //-- update free cluster hint, it isn't required to be a precise value, just a hint where to start the from from.

    SetFreeClusterHint(freeCluster); 

	return(freeCluster);

	}	

//-----------------------------------------------------------------------------

/**

    Allocate and link a cluster chain, leaves if there are not enough free clusters.

    Chain starts as close as possible to aNearestCluster, last cluster will be marked as EOF.

    @param aNumber Number of clusters to allocate

    @param aNearestCluster Cluster the new chain should be nearest to

    @leave System wide error codes

    @return The first cluster number allocated

*/

TUint32 CFatTable::AllocateClusterListL(TUint32 aNumber, TUint32 aNearestCluster)

	{

    __PRINT2(_L("CFatTable::AllocateClusterList() N:%d,NearestCL:%d"),aNumber,aNearestCluster);

	__ASSERT_DEBUG(aNumber>0, Fault(EFatBadParameter));

	if(!RequestFreeClusters(aNumber))

    	{

		__PRINT(_L("CFatTable::AllocateClusterListL - leaving KErrDirFull"));

		User::Leave(KErrDiskFull);

		}

	TInt firstCluster = aNearestCluster = AllocateSingleClusterL(aNearestCluster);

	if (aNumber>1)

		ExtendClusterListL(aNumber-1, (TInt&)aNearestCluster);

    return(firstCluster);

	}	

//-----------------------------------------------------------------------------

/**

    Notify the media drive about media areas that shall be treated as "deleted" if this feature is supported.

    @param aFreedClusters array with FAT numbers of clusters that shall be marked as "deleted"

*/

void CFatTable::DoFreedClustersNotify(RClusterArray &aFreedClusters)

{

    ASSERT(iMediaAtt & KMediaAttDeleteNotify);

    const TUint clusterCount = aFreedClusters.Count();

    if(!clusterCount)

        return;

    FlushL(); //-- Commit the FAT changes to disk first to be safe

    const TUint bytesPerCluster = 1 << iOwner->ClusterSizeLog2();

    TInt64  byteAddress = 0;	

	TUint   deleteLen = 0;	// zero indicates no clusters accumulated yet

	for (TUint i=0; i<clusterCount; ++i)

	{

        const TUint currCluster = aFreedClusters[i];

        if (deleteLen == 0)

		    byteAddress = DataPositionInBytes(currCluster); //-- start of the media range

        deleteLen += bytesPerCluster;

        //-- if this is the last entry in the array or the net cluster number is not consecutive, notify the driver

		if ((i+1) == clusterCount || aFreedClusters[i+1] != (currCluster+1))

        {

            //__PRINT3(_L("DeleteNotify(%08X:%08X, %u), first cluster %u last cluster #%u"), I64HIGH(byteAddress), I64LOW(byteAddress), deleteLen);

			//__PRINT2(_L("   first cluster %u last cluster #%u"), I64LOW((byteAddress - iOwner->ClusterBasePosition()) >> iOwner->ClusterSizeLog2()) + 2, cluster);

            const TInt r = iOwner->LocalDrive()->DeleteNotify(byteAddress, deleteLen);

			if(r != KErrNone)

                {//-- if DeleteNotify() failed, it means that something terribly wrong happened to the NAND media; 

                 //-- in normal circumstances it can not happen. One of the reasons: totally worn out media.

                const TBool platSecEnabled = PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement);

                __PRINT3(_L("CFatTable::DoFreedClustersNotify() DeleteNotify failure! drv:%d err:%d, PlatSec:%d"),iOwner->DriveNumber(), r, platSecEnabled);

                if(platSecEnabled)

                    {

                    //-- if PlatSec is enabled, we can't afford jeopardize the security; without DeleteNotify()

                    //-- it's possible to pick up data from deleted files, so, panic the file server.

                    Fault(EFatBadLocalDrive);

                    }

                else

                    {

                    //-- if PlatSec is disabled, it's OK to ignore the NAND fault in release mode.

                    __ASSERT_DEBUG(0, Fault(EFatBadLocalDrive));

                    }        

                }

            deleteLen = 0;

        }

    }

    //-- empty the array.

    aFreedClusters.Reset();

}

//-----------------------------------------------------------------------------

/**

    Mark a chain of clusters as free in the FAT. 

    @param aCluster Start cluster of cluster chain to free

    @leave System wide error codes

*/

void CFatTable::FreeClusterListL(TUint32 aCluster)

	{

	__PRINT1(_L("CFatTable::FreeClusterListL startCluster=%d"),aCluster);

	if (aCluster == KSpareCluster)

		return; 

	//-- here we can store array of freed cluster numbers in order to 

    //-- notify media drive about the media addresses marked as "invalid"

    RClusterArray deletedClusters;      

	CleanupClosePushL(deletedClusters);

    //-- if ETrue, we need to notify media driver about invalidated media addressses

    const TBool bFreeClustersNotify = iMediaAtt & KMediaAttDeleteNotify;

    //-- this is a maximal number of FAT entries in the deletedClusters array.

    //-- as soon as we collect this number of entries in the array, FAT cache will be flushed

    //-- and driver notified. The array will be emptied. Used to avoid huge array when deleting

    //--  large files on NAND media 

    const TUint KSubListLen = 4096;

    ASSERT(IsPowerOf2(KSubListLen));

    TUint32 lastKnownFreeCluster = FreeClusterHint();

    TUint32 cntFreedClusters = 0;

    TUint32 currCluster = aCluster;

    TInt    nextCluster = aCluster;

    for(;;)

    {

        const TBool bEOF = !GetNextClusterL(nextCluster);    

        WriteL(currCluster, KSpareCluster);

        lastKnownFreeCluster = Min(currCluster, lastKnownFreeCluster);

		// Keep a record of the deleted clusters so that we can subsequently notify the media driver. This is only safe 

		// to do once the FAT changes have been written to disk.

        if(bFreeClustersNotify)

            deletedClusters.Append(currCluster);

        ++cntFreedClusters;

        currCluster = nextCluster;

		if (bEOF || aCluster == KSpareCluster)

			break;

        if(bFreeClustersNotify && cntFreedClusters && (cntFreedClusters & (KSubListLen-1))==0)

        {//-- reached a limit of the entries in the array. Flush FAT cache, notify the driver and empty the array.

            IncrementFreeClusterCount(cntFreedClusters);

            cntFreedClusters = 0;

            SetFreeClusterHint(lastKnownFreeCluster);

            DoFreedClustersNotify(deletedClusters);

        }

    }

    //-- increase the number of free clusters and notify the driver if required.

    IncrementFreeClusterCount(cntFreedClusters);

    SetFreeClusterHint(lastKnownFreeCluster);

    if(bFreeClustersNotify)

        DoFreedClustersNotify(deletedClusters);

	CleanupStack::PopAndDestroy(&deletedClusters);

	}

//-----------------------------------------------------------------------------

/**

    Find a free cluster nearest to aCluster, Always checks to the right of aCluster first 

    but checks in both directions in the Fat.

    @param aCluster Cluster to find nearest free cluster to.

    @leave KErrDiskFull + system wide error codes

    @return cluster number found

*/

TUint32 CFatTable::FindClosestFreeClusterL(TUint32 aCluster)

	{

    __PRINT2(_L("CFatTable::FindClosestFreeClusterL() drv:%d cl:%d"),iOwner->DriveNumber(),aCluster);

    if(!ClusterNumberValid(aCluster))

        {

        ASSERT(0);

        User::Leave(KErrCorrupt);

        }

    if(!RequestFreeClusters(1))

	    {//-- there is no at least 1 free cluster available

    	__PRINT(_L("CFatTable::FindClosestFreeClusterL() leaving KErrDiskFull #1"));

        User::Leave(KErrDiskFull);

        }

    //-- 1. look if the given index contains a free entry 

    if(ReadL(aCluster) != KSpareCluster)

        {//-- no, it doesn't...

        //-- 2. look in both directions starting from the aCluster, looking in the right direction first

        const TUint32 maxEntries = MaxEntries();

        const TUint32 MinIdx = KFatFirstSearchCluster;

        const TUint32 MaxIdx = maxEntries-1;

        TBool canGoRight = ETrue;

        TBool canGoLeft = ETrue;

        TUint32 rightIdx = aCluster;

        TUint32 leftIdx  = aCluster;

        for(TUint i=0; i<maxEntries; ++i)

            {

            if(canGoRight)

                {

                if(rightIdx < MaxIdx)

                    ++rightIdx;

                else

                    canGoRight = EFalse;

                }

            if(canGoLeft)

                {

                if(leftIdx > MinIdx)

                    --leftIdx;

                else        

                    canGoLeft = EFalse;

                }

            if(!canGoRight && !canGoLeft)

	            {

    	        __PRINT(_L("CFatTable::FindClosestFreeClusterL() leaving KErrDiskFull #2"));

                User::Leave(KErrDiskFull);

                }

            if(canGoRight && ReadL(rightIdx) == KSpareCluster)

			    {

			    aCluster = rightIdx;

			    break;

			    }

		    if (canGoLeft && ReadL(leftIdx) == KSpareCluster)

			    {

			    aCluster = leftIdx;

			    break;

			    }

            }//for(..)

        }//if(ReadL(aCluster) != KSpareCluster)

    //-- note: do not update free cluster hint here by calling SetFreeClusterHint(). This is going to be 

    //-- expensive especially if overridden methods with synchronisation are called. Instead, set the number of 

    //-- the last known free cluster in the caller of this internal method.

    //__PRINT1(_L("CFatTable::FindClosestFreeClusterL found:%d"),aCluster);

    return aCluster;

	}

//-----------------------------------------------------------------------------

/**

    Converts a cluster number to byte offset in the FAT

    @param aFatIndex Cluster number

    @return Number of bytes from the beginning of the FAT

*/

TUint32 CFatTable::PosInBytes(TUint32 aFatIndex) const

	{

    switch(FatType())

        {

        case EFat12:

            return (((aFatIndex>>1)<<1) + (aFatIndex>>1)); //-- 1.5 bytes per FAT entry

        case EFat16:

            return aFatIndex<<1; //-- 2 bytes per FAT entry

        case EFat32:

            return aFatIndex<<2; //-- 4 bytes per FAT entry

        default:

            ASSERT(0);

            return 0;//-- get rid of warning

        };

	}

//-----------------------------------------------------------------------------

/**

    Checks if we have at least aClustersRequired clusters free in the FAT.

    This is, actually a dummy implementation.

    @param  aClustersRequired number of free clusters required

    @return ETrue if there is at least aClustersRequired free clusters available, EFalse otherwise.

*/

TBool CFatTable::RequestFreeClusters(TUint32 aClustersRequired) const

    {

    //__PRINT1(_L("#- CFatTable::RequestFreeClusters(%d)"),aClustersRequired);

    ASSERT(aClustersRequired >0);

    return (NumberOfFreeClusters() >= aClustersRequired);

    }

//-----------------------------------------------------------------------------

/**

    @return ETrue if the cluster number aClusterNo is valid, i.e. belongs to the FAT table

*/

TBool CFatTable::ClusterNumberValid(TUint32 aClusterNo) const 

    {

    return (aClusterNo >= KFatFirstSearchCluster) && (aClusterNo < iMaxEntries); 

    }

//#######################################################################################################################################

//#     CAtaFatTable class implementation 

//#######################################################################################################################################

/**

    Constructor

*/

CAtaFatTable::CAtaFatTable(CFatMountCB& aOwner)

             :CFatTable(aOwner), iDriveInteface(aOwner.DriveInterface())

    {

        iState = ENotInitialised;

    }

CAtaFatTable::~CAtaFatTable()

    {

    DestroyHelperThread();

    }

/** factory method */

CAtaFatTable* CAtaFatTable::NewL(CFatMountCB& aOwner)

{

    __PRINT1(_L("CAtaFatTable::NewL() drv:%d"),aOwner.DriveNumber());

    CAtaFatTable* pSelf = new (ELeave) CAtaFatTable(aOwner);

    CleanupStack::PushL(pSelf);

    pSelf->InitializeL();

    CleanupStack::Pop();

    return pSelf;

}

//---------------------------------------------------------------------------------------------------------------------------------------

/**

    CAtaFatTable's FAT cache factory method.

    Creates fixed cache for FAT12/FAT16 or LRU cache for FAT32

*/

void CAtaFatTable::CreateCacheL()

{

    ASSERT(iOwner);

    const TUint32 fatSize=iOwner->FatSizeInBytes();

    __PRINT3(_L("CAtaFatTable::CreateCacheL drv:%d, FAT:%d, FAT Size:%d"), iOwner->DriveNumber(), FatType(), fatSize);

    //-- according to FAT specs:

    //-- FAT12 max size is 4084 entries or 6126 bytes                                               => create fixed cache for whole FAT

    //-- FAT16 min size is 4085 entries or 8170 bytes, max size is 65525 entries or 131048 bytes    => create fixed cache for whole FAT

    //-- FAT32 min size is 65526 entries or 262104 bytes                                            => create LRU paged cache of max size: KFat32LRUCacheSize

    ASSERT(!iCache);

    //-- this is used for chaches granularity sanity check 

    const TUint32 KMinGranularityLog2 = KDefSectorSzLog2;  //-- 512 bytes is a minimal allowed granularity

    const TUint32 KMaxGranularityLog2 = 18; //-- 256K is a maximal allowed granularity

    switch(FatType())

    {

        //-- create fixed FAT12 cache

        case EFat12: 

            iCache = CFat12Cache::NewL(iOwner, fatSize); 

        break;

        //-- create fixed FAT16 cache

        case EFat16: 

            {

            TUint32 fat16_ReadGranularity_Log2; //-- FAT16 cache read granularity Log2

            TUint32 fat16_WriteGranularity_Log2;//-- FAT16 cache write granularity Log2

            iOwner->FatConfig().Fat16FixedCacheParams(fat16_ReadGranularity_Log2, fat16_WriteGranularity_Log2);

            //-- check if granularity values look sensible

            const TBool bParamsValid = fat16_ReadGranularity_Log2  >= KMinGranularityLog2 && fat16_ReadGranularity_Log2  <= KMaxGranularityLog2 &&

                                       fat16_WriteGranularity_Log2 >= KMinGranularityLog2 && fat16_WriteGranularity_Log2 <= KMaxGranularityLog2;

             __ASSERT_ALWAYS(bParamsValid, Fault(EFatCache_BadGranularity)); 

            iCache = CFat16FixedCache::NewL(iOwner, fatSize, fat16_ReadGranularity_Log2, fat16_WriteGranularity_Log2); 

            }

        break;

        //-- create FAT32 LRU paged cache

        case EFat32: 

            {

            TUint32 fat32_LRUCache_MaxMemSize;  //-- Maximum memory for the LRU FAT32 cache

            TUint32 fat32_ReadGranularity_Log2; //-- FAT32 cache read granularity Log2

            TUint32 fat32_WriteGranularity_Log2;//-- FAT32 cache write granularity Log2

            iOwner->FatConfig().Fat32LruCacheParams(fat32_ReadGranularity_Log2, fat32_WriteGranularity_Log2, fat32_LRUCache_MaxMemSize);

            //-- check if granularity  and required cache size values look sensible

            const TBool bParamsValid = fat32_ReadGranularity_Log2  >= KMinGranularityLog2 && fat32_ReadGranularity_Log2  <= KMaxGranularityLog2 &&

                                       fat32_WriteGranularity_Log2 >= KMinGranularityLog2 && fat32_WriteGranularity_Log2 <= KMaxGranularityLog2 &&

                                       fat32_LRUCache_MaxMemSize >= 8*K1KiloByte && fat32_LRUCache_MaxMemSize < 4*K1MegaByte;

            __ASSERT_ALWAYS(bParamsValid, Fault(EFatCache_BadGranularity)); 

            iCache = CFat32LruCache::NewL(iOwner, fat32_LRUCache_MaxMemSize, fat32_ReadGranularity_Log2, fat32_WriteGranularity_Log2);

            }

        break;

        default:

        ASSERT(0);

        User::Leave(KErrCorrupt);

        break;

    };

    ASSERT(iCache);

}

//---------------------------------------------------------------------------------------------------------------------------------------

/**

    Destroys a helper thread object.

    If the thread is running, stops it first. than deletes the ipHelperThread and sets it to NULL

*/

void CAtaFatTable::DestroyHelperThread()

{

    if(!ipHelperThread)

        return;

    __PRINT1(_L("CAtaFatTable::DestroyHelperThread(), drv:%d"), iOwner->DriveNumber());

    ipHelperThread->ForceStop();

    delete ipHelperThread;

    ipHelperThread = NULL;

}

//---------------------------------------------------------------------------------------------------------------------------------------

/**

    Flush the FAT cache on disk

    @leave System wide error codes

*/

void CAtaFatTable::FlushL()

	{

    __PRINT1(_L("CAtaFatTable::FlushL(), drv:%d"), iOwner->DriveNumber());

    //-- the data can't be written if the mount is inconsistent

    iOwner->CheckStateConsistentL();

    if (iCache)

		iCache->FlushL();

	}

//---------------------------------------------------------------------------------------------------------------------------------------

/**

    Dismount the cache. Stops any activity, deallocates caches etc.

    @param aDiscardDirtyData if ETrue, non-flushed data in the cache will be discarded.

*/

void CAtaFatTable::Dismount(TBool aDiscardDirtyData)

	{

    __PRINT3(_L("#=-= CAtaFatTable::Dismount(%d), drv:%d, state:%d"), aDiscardDirtyData, iOwner->DriveNumber(), State());

    //-- if there is a helper thread, stop it and delete its object

    DestroyHelperThread();

    //-- if there is the cache, close it (it may lead to deallocating its memory)

	if(iCache)

		{

        //-- cache's Close() can check if the cache is clean. 

        //-- ignore dirty data in cache if the mount is not in consistent state (it's impossible to flush cache data)

        //-- or if we are asked to do so.

        const TBool bIgnoreDirtyData = aDiscardDirtyData || !iOwner->ConsistentState();

        iCache->Close(bIgnoreDirtyData);

        delete iCache;

		iCache=NULL;

		}

     SetState(EDismounted);

	}

//---------------------------------------------------------------------------------------------------------------------------------------

/**

    Invalidate whole FAT cache.

    Depending of cache type this may just mark cache invalid with reading on demand or re-read whole cache from the media

*/

void CAtaFatTable::InvalidateCacheL()

{

    __PRINT1(_L("CAtaFatTable::InvalidateCache(), drv:%d"), iOwner->DriveNumber());

    //-- if we have a cache, invalidate it entirely

    if(iCache)

        {

        User::LeaveIfError(iCache->Invalidate());

        }

    //-- invalidating whole FAT cache means that something very serious happened.

    //-- if we have a helper thread running, abort it.

    if(ipHelperThread)

        ipHelperThread->ForceStop();

}

//---------------------------------------------------------------------------------------------------------------------------------------

/**

    Invalidate specified region of the FAT cache

    Depending of cache type this may just mark part of the cache invalid with reading on demand later

    or re-read whole cache from the media.

    @param aPos absolute media position where the region being invalidated starts.

    @param aLength length in bytes of region to invalidate / refresh

*/

void CAtaFatTable::InvalidateCacheL(TInt64 aPos, TUint32 aLength)

	{

    __PRINT3(_L("CAtaFatTable::InvalidateCacheL() drv:%d, pos:%LU, len:%u,"), iOwner->DriveNumber(), aPos, aLength);

    if(I64HIGH(aPos) || !aLength || I64HIGH(aPos+aLength))

        return; //-- FAT tables can't span over 4G 

    const TUint32 mediaPos32 = I64LOW(aPos);

    //-- we do not use other copies of FAT, so trach changes only in FAT1

    const TUint32 fat1StartPos = iOwner->StartOfFatInBytes();

    const TUint32 fat1EndPos   = fat1StartPos + iOwner->FatSizeInBytes();

    TUint32 invRegionPosStart = 0; //-- media pos where the invalidated region starts

    TUint32 invRegionLen = 0;      //-- size of the invalidated region, bytes

    //-- calculate the FAT1 region being invalidated

    if(mediaPos32 < fat1StartPos)

        {

        if((mediaPos32 + aLength) <= fat1StartPos)

            return;

        invRegionPosStart = fat1StartPos;

        invRegionLen = aLength - (fat1StartPos-mediaPos32);

        }

    else //if(mediaPos32 < fat1StartPos)

        {//-- mediaPos32 >= fat1StartPos)

        if(mediaPos32 >= fat1EndPos)

            return;

        invRegionPosStart = mediaPos32;

        if((mediaPos32 + aLength) <= fat1EndPos)

            {

            invRegionLen = aLength;

            }

        else 

            {

            invRegionLen = mediaPos32+aLength-fat1EndPos;

            }

        }

    //-- convert the media pos of the region into FAT entries basis, depending on the FAT type

    ASSERT(invRegionPosStart >= fat1StartPos && invRegionLen <= (TUint)iOwner->FatSizeInBytes());

    TUint32 startFatEntry=0;

    TUint32 numEntries = 0;

    switch(FatType())

        {

        case EFat12:

        //-- invalidate whole cache; it is not worth making calculations for such small memory region.

        User::LeaveIfError(iCache->Invalidate());

        return;

        case EFat16:

        startFatEntry = (invRegionPosStart-fat1StartPos) >> KFat16EntrySzLog2;

        numEntries = (invRegionLen + (sizeof(TFat16Entry)-1)) >> KFat16EntrySzLog2;

        break;

        case EFat32:

        startFatEntry = (invRegionPosStart-fat1StartPos) >> KFat32EntrySzLog2;

        numEntries = (invRegionLen + (sizeof(TFat32Entry)-1)) >> KFat32EntrySzLog2;

        break;

        default:

        ASSERT(0);

        return;

        };

    if(startFatEntry < KFatFirstSearchCluster)

        {//-- FAT[0] and FAT[1] can't be legally accessed, they are reserved entries. We need to adjust region being refreshed.

        if(numEntries <= KFatFirstSearchCluster)

            return; //-- nothing to refresh

        startFatEntry += KFatFirstSearchCluster;

        numEntries -= KFatFirstSearchCluster;

        }

    User::LeaveIfError(iCache->InvalidateRegion(startFatEntry, numEntries));

	}

//-----------------------------------------------------------------------------

/**

    Initialize the object, create FAT cache if required

    @leave KErrNoMemory

*/

void CAtaFatTable::InitializeL()

	{

    __PRINT2(_L("CAtaFatTable::InitializeL() drv:%d, state%d"), iOwner->DriveNumber(), State());

    CFatTable::InitializeL();

    ASSERT(!iCache);

    ASSERT(State() == ENotInitialised);

    //-- create the FAT cache.

    CreateCacheL();

    SetState(EInitialised);