// 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\sl_fatcache.cpp

// FAT12 and FAT16 cache implementation

// 

//

/**

 @file

*/

#include "sl_std.h"

#include "sl_fatcache.h"

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

//  CFatCacheBase implementation

//  Base class for all types of FAT cache

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

CFatCacheBase::~CFatCacheBase()

    {

    Close(ETrue); //-- deallocate cache's memory discarding any dirty data

    }

CFatCacheBase::CFatCacheBase()

    {

    iCurrentFatNo = KInvalidFatNo;

    SetDirty(EFalse);

    }

/**

    FAT cache initialisation.

    @param  aOwner pointer to the owning FAT mount

*/

void CFatCacheBase::InitialiseL(CFatMountCB* aOwner)

    {

    ASSERT(aOwner);

    Close(ETrue); //-- deallocate cache's memory discarding any dirty data

    //-- populate parameters from the owning mount

    iFatType = aOwner->FatType();

    __ASSERT_ALWAYS((iFatType == EFat12 || iFatType == EFat16 || iFatType == EFat32), User::Leave(KErrCorrupt));  

    ipDrive = &aOwner->DriveInterface();

    iFatStartPos = aOwner->FirstFatSector() << aOwner->SectorSizeLog2(); 

    iFatSize = aOwner->FatSizeInBytes();

    iNumFATs = (TUint16)aOwner->NumberOfFats();

    iFatSecSzLog2   = (TUint16)aOwner->SectorSizeLog2(); 

    iFatClustSzLog2 = (TUint16)aOwner->ClusterSizeLog2();

    __ASSERT_ALWAYS(iNumFATs >=1, User::Leave(KErrCorrupt));

    __PRINT3(_L("#-CFatCacheBase::InitialiseL() FatStart:%u, FatSz:%d, drv:%d"),iFatStartPos, iFatSize, aOwner->DriveNumber());

    }

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

/**

    This method shall be called to check if we are allowed to invalidate dirty cache, i.e. discard non-flushed data.

    The behaviour is hardcoded (see KAllowInvalidateDirtyCache constant)

    @return ETrue if invalidating dirty cache is allowed. Otherwise panics the current thread

*/

TBool CFatCacheBase::CheckInvalidatingDirtyCache() const

    {

    //-- If not EFalse, invalidating dirty cache (pages) is allowed. This shall be OK, because

    //-- invalidating the cache is required only after direct media writes to the FAT by RawWrite, which can corrupt it anyway. 

    TBool KAllowInvalidateDirtyCache = ETrue;

    if(!IsDirty())

        return KAllowInvalidateDirtyCache;        

    __PRINT(_L("#-CFatCacheBase::Invalidating dirty cache !"));

    if(!KAllowInvalidateDirtyCache)

        {

        __ASSERT_ALWAYS(0, Fault(EFatCache_DiscardingDirtyData));

        }

    return KAllowInvalidateDirtyCache;        

    }

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

/**

    Read portion of raw data from 1st FAT copy.

    @param  aPos   media position in the _FIRST_ FAT to start reading with

    @param  aLen   number of bytes to read

    @param  aData  data descriptor

    @return standard error code.

*/

TInt CFatCacheBase::ReadFatData(TUint32 aPos, TUint32 aLen, TDes8& aData) const

    {

    //__PRINT2(_L("#-CFatCacheNew::ReadFatData() pos:%u, Len:%d"), aPos, aLen);

    //-- this method can pick up data corresponding to invalid FAT entries, like FAT[0], FAT[1] and

    //-- the last portion beyond FAT because of read granularity. This isn't a problem, because the data there

    //-- won't be written on disk.

    ASSERT(aPos >= FatStartPos()); 

    return ipDrive->ReadNonCritical(aPos, aLen, aData);

    }

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

/** 

    Writes data to the FAT table, which number is set in iCurrentFatNo member variable. 

    @param  aPos   data media position in the _FIRST_ FAT copy

    @param  aData  data descriptor

    @return standard error code.

*/

TInt CFatCacheBase::WriteFatData(TUint32 aPos, const TDesC8& aData) const

    {

    //__PRINT3(_L("#-CFatCacheBase::WriteFatData() pos:%u, Len:%d, FAT:%d"), aPos, aData.Length(), iCurrentFatNo);

#ifdef _DEBUG    

    //-- FAT[0] and FAT[1] entries are reserved and we must not write data there. It's up to the caller of this method to

    //-- calculate correct data position in FAT

    TInt reserved_Entries_Offset=0;

    switch(iFatType)

        {

        case EFat32: reserved_Entries_Offset = KFatFirstSearchCluster*sizeof(TFat32Entry); break;  //-- FAT32  

        case EFat16: reserved_Entries_Offset = KFatFirstSearchCluster*sizeof(TFat16Entry); break;  //-- FAT16  

        case EFat12: reserved_Entries_Offset = 3;   break;                                         //-- FAT12

        default: ASSERT(0); break;

        }

    ASSERT(aPos >= FatStartPos()+reserved_Entries_Offset);

    ASSERT((aPos+aData.Length()) <= FatStartPos()+FatSize());

    ASSERT(iCurrentFatNo < iNumFATs);

#endif    

    //-- goto the required FAT copy. iCurrentFatNo shall contain FAT number we are writing to.

    aPos+=iCurrentFatNo*FatSize(); 

    return ipDrive->WriteCritical(aPos, aData);

    }

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

/** 

    get a pointer to the CFatBitCache interface. 

    @return NULL because it is not present here 

*/

CFatBitCache* CFatCacheBase::BitCacheInterface() 

    {

    return NULL;

    }

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

//  CFatPagedCacheBase implementation

//  Base class for all paged FAT caches

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

CFatPagedCacheBase::CFatPagedCacheBase()

               :CFatCacheBase() 

    {

    }

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

//  CFatCachePageBase implementation

//  Base class for FAT cache pages (FAT16 fixed and FAT32 LRU)

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

CFatCachePageBase::CFatCachePageBase(CFatPagedCacheBase& aCache)

                  :iCache(aCache)

    {

    ASSERT(IsPowerOf2(aCache.PageSize()));

    iStartIndexInFAT = KMaxTUint;

    //-- calculate number of FAT entries in the page, it depends on FAT type

    switch(aCache.FatType())

        {

        case EFat32:

            iFatEntriesInPage = PageSize() >> KFat32EntrySzLog2;

        break;

        case EFat16:

            iFatEntriesInPage = PageSize() >> KFat16EntrySzLog2;

        break;

        default:

            ASSERT(0);

            Fault(EFatCache_BadFatType);

        break;

        };

    SetState(EInvalid); 

    }

CFatCachePageBase::~CFatCachePageBase()

    {

    iData.Close();

    }

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

/**

    Mark the page as "invalid". I.e containing inalid data.

    On the first read/write access to such page it will be re-read from the media

    @param aIgnoreDirtyData if ETrue, it is allowed to ignore the fact that the page contains dirty (not flushed) data.

*/

void CFatCachePageBase::Invalidate(TBool aIgnoreDirtyData /*= EFalse*/)

    {

    if(!aIgnoreDirtyData && IsDirty())

        {

        __PRINT1(_L("#-CFatCachePageBase::Invalidate() dirty page! FAT idx:%d"), iStartIndexInFAT);

        __ASSERT_ALWAYS(0, Fault(EFatCache_DiscardingDirtyData));

        }

    iDirtySectors.Clear(); //-- clear dirty sectors bitmap

    SetState(EInvalid);

    }

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

/**

    Flush all dirty page sectors to the media and mark the page as "clean" if required.

    If the page is "clean" i.e doesn't contain changed data, does nothing.

    @param  aKeepDirty  if ETrue, the "dirty" flag isn't reset after page flushing.

*/

void CFatCachePageBase::FlushL(TBool aKeepDirty)

    {

    if(!IsDirty())

        return;

    if(!IsValid())

        {

        __PRINT1(_L("#-CFatCachePageBase::FlushL() Invalid page! FAT idx:%d"), iStartIndexInFAT);

        ASSERT(0);

        User::Leave(KErrCorrupt);

        return;

        }

    //__PRINT1(_L("#-CFatCachePageBase::FlushL() FAT idx:%d"), iStartIndexInFAT);

    //-- write dirty FAT sectors  to the media one by one. 

    //-- merging adjacent dirty subsectors into larger clusters and writing them at once looks like a good idea, but

    //-- in reality it showed FAT performance degradation, at least on MMC/SD media.

    const TInt MaxSectors = iCache.SectorsInPage();

    for(TInt i=0; i<MaxSectors; ++i)

        {

        if(iDirtySectors[i])

            {

            DoWriteSectorL(i);

            }

        }

    //-- All data flushed; mark page as clean if it isn't required not to do.

    if(!aKeepDirty)

        SetClean(); 

    }

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

//  CFat16FixedCache implementation

//  Fixed cache (caches all FAT16) but organised as an array of pages

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

CFat16FixedCache::CFat16FixedCache()

                 :CFatPagedCacheBase(),iPages(1) //-- array granularity is 1

    {

    }

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

/**

    FAT16 fixed cache factory function.

    @param  aOwner              pointer to the owning FAT mount

    @param  aFatSize            size of the FAT table in bytes

    @param  aRdGranularityLog2  Log2(read granularity)

    @param  aWrGranularityLog2  Log2(write granularity)

    @return pointer to the constructed object.

*/

CFat16FixedCache* CFat16FixedCache::NewL(CFatMountCB* aOwner, TUint32 aFatSize, TUint32 aRdGranularityLog2, TUint32 aWrGranularityLog2)

    {

    __PRINT(_L("#-CFat16FixedCache::NewL()"));

    CFat16FixedCache* pSelf = NULL;

    pSelf = new (ELeave) CFat16FixedCache;

    CleanupStack::PushL(pSelf);

    pSelf->InitialiseL(aOwner, aFatSize, aRdGranularityLog2, aWrGranularityLog2);

    CleanupStack::Pop();

    return pSelf;

    }

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

/**

    FAT16 fixed cache initialisation.

    @param  aOwner              pointer to the owning FAT mount

    @param  aFatSize            size of the FAT table in bytes

    @param  aRdGranularityLog2  Log2(read granularity)

    @param  aWrGranularityLog2  Log2(write granularity)

*/

void CFat16FixedCache::InitialiseL(CFatMountCB* aOwner, TUint32 aFatSize, TUint32 aRdGranularityLog2, TUint32 aWrGranularityLog2)

    {

    const TUint32 ReadGranularity = Pow2(aRdGranularityLog2);

    const TUint32 WriteGranularity = Pow2(aWrGranularityLog2);

    __PRINT3(_L("#-CFat16FixedCache::InitialiseL FatSz:%u, RdGr:%d, WrGr:%d"),aFatSize, ReadGranularity, WriteGranularity);

    (void)ReadGranularity;

    (void)WriteGranularity;

    TBool bParamsValid = (aRdGranularityLog2 >= aWrGranularityLog2) && (aWrGranularityLog2 >= KDefSectorSzLog2);

    __ASSERT_ALWAYS(bParamsValid, Fault(EFatCache_BadGranularity));

    CFatPagedCacheBase::InitialiseL(aOwner);

    ASSERT(FatType() == EFat16);

    //-- See FAT specs, and round up the limit to the FAT sector boundary

    const TUint32 KMaxFat16Size = ((65524*sizeof(TFat16Entry)+FAT_SectorSz()-1) >> FAT_SectorSzLog2()) << FAT_SectorSzLog2(); 

    const TUint32 KMinFat16Size = 4086*sizeof(TFat16Entry);  //-- See FAT specs

    bParamsValid = aFatSize >= KMinFat16Size && aFatSize <= KMaxFat16Size;

	__ASSERT_ALWAYS(bParamsValid, User::Leave(KErrCorrupt));

    //-- cache page size is (2^aRdGranularityLog2) bytes and consists of 2^(aRdGranularityLog2-aWrGranularity) sectors.

    iPageSizeLog2 = aRdGranularityLog2;

    iSectorSizeLog2 = aWrGranularityLog2; //-- Log2(number of sectors in cache page)

    __ASSERT_ALWAYS(SectorsInPage() < KMaxSectorsInPage, Fault(EFatCache_BadGranularity));

    const TUint numPages = (aFatSize+(PageSize()-1)) >> iPageSizeLog2;

    __PRINT1(_L("#-CFat16FixedCache Num Pages:%d"), numPages);

    //-- prepare pointer array for pages. NULL entry in the array means that the page at this index isn't allocated.

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

        iPages.AppendL(NULL);

    }

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

/**

    Close the cache and deallocate its memory.

    @param  aDiscardDirtyData if ETrue, will ignore dirty data. If EFalse, will panic on atempt to close dirty cache.  

*/

void CFat16FixedCache::Close(TBool aDiscardDirtyData)

    {

    __PRINT1(_L("#-CFat16FixedCache::Close(%d)"), aDiscardDirtyData);

    TInt cnt = iPages.Count();

    while(cnt--)

        {//-- delete pages

        CFat16FixedCachePage *pPage = iPages[cnt];

        if(pPage && (pPage->IsDirty()))

            {//-- trying to destroy the cache that has dirty pages

            __PRINT1(_L("#-CFat16FixedCache::Close() The page is dirty! Start idx:%d"), pPage->StartFatIndex());

            if(!aDiscardDirtyData)

                {

                __ASSERT_ALWAYS(0, Fault(EFatCache_DiscardingDirtyData));

                }

            //-- ignore this fact if requested.

            }

        delete pPage;

        }

    iPages.Close();

    SetDirty(EFalse);

    }

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

/**

    Read FAT entry from the cache. 

    @param  aIndex FAT entry index to read

    @return FAT entry value at the index "aIndex" 

*/

TUint32 CFat16FixedCache::ReadEntryL(TUint32 aIndex)

    {

    //__PRINT1(_L("#-CFat16FixedCache::ReadEntryL() FAT idx:%d"), aIndex);

    //-- calculate page index in the array. Theoretically, aIndex can't be wrong because it is checked by the caller;

    //-- but in some strange situations (malformed volume ?) aIndex might get bigger than number of usable clusters.

    const TUint pgIdx = aIndex >> (PageSizeLog2()-KFat16EntrySzLog2);

    if(pgIdx >= (TUint)iPages.Count())

        {

        __PRINT1(_L("#-CFat16FixedCache::ReadEntryL() FAT idx:%d #1"), aIndex);

        ASSERT(0);

        User::Leave(KErrCorrupt);

        }

    CFat16FixedCachePage *pPage = iPages[pgIdx];

    TUint32 entry = KMaxTUint;

    if(!pPage)

        {//-- page at this position isn't allocated yet

        pPage = CFat16FixedCachePage::NewL(*this);

        iPages[pgIdx] = pPage;

        //-- read the page from media

        entry = pPage->ReadFromMediaL(aIndex);

        }

    else

        {//-- get cached entry from the page

        TBool bRes = pPage->ReadCachedEntryL(aIndex, entry);

        ASSERT(bRes);

        (void)bRes;

        }

    return entry;

    }

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

/**

    Write FAT entry to the cache. 

    Appropriate FAT cache sector will be marked as "dirty" and will be eventually flushed to the media.

    @param  aIndex FAT entry index

    @param  aEntry FAT entry value

*/

void CFat16FixedCache::WriteEntryL(TUint32 aIndex, TUint32 aEntry)

    {

    //__PRINT2(_L("#-CFat16FixedCache::WriteEntryL() FAT idx:%d, val:%d"), aIndex, aEntry);

    SetDirty(ETrue);

    //-- calculate page index in the array. Theoretically, aIndex can't be wrong because it is checked by the caller;

    //-- but in some strange situations (malformed volume ?) aIndex might get bigger than number of usable clusters.

    const TUint pgIdx = aIndex >> (PageSizeLog2()-KFat16EntrySzLog2);

    if(pgIdx >= (TUint)iPages.Count())

        {

        __PRINT2(_L("#-CFat16FixedCache::WriteEntryL() FAT idx:%d, val:%d #1"), aIndex, aEntry);

        ASSERT(0);

        User::Leave(KErrCorrupt);

        }

    CFat16FixedCachePage *pPage = iPages[pgIdx];

    if(!pPage)

        {//-- page at this position isn't allocated yet

        pPage = CFat16FixedCachePage::NewL(*this);

        iPages[pgIdx] = pPage;

        //-- read the page from media

        pPage->ReadFromMediaL(aIndex);

        }

    //-- overwrite entry in cache

    TBool bRes = pPage->WriteCachedEntryL(aIndex, aEntry);

    ASSERT(bRes);

    (void)bRes;

    }

/**

    A debug method that asserts that the cache is really clean

*/

void CFat16FixedCache::AssertCacheReallyClean() const

    {

#ifdef _DEBUG 

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

        {

            CFat16FixedCachePage* pPage = iPages[i];

            if(pPage && pPage->IsDirty())

                {

                __PRINT(_L("#-CFat16FixedCache::AssertCacheReallyClean()"));

                ASSERT(0);

                }

        }

#endif   

    }

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

/**

    Flushes all dirty data to the media.

*/

void CFat16FixedCache::FlushL()

    {

    if(!IsDirty())

        {

        AssertCacheReallyClean();

        return;

        }

    //-- flush dirty data to all copies of FAT

    for(iCurrentFatNo=0; iCurrentFatNo < NumFATs(); ++iCurrentFatNo)

        {

        const TInt nPages = NumPages();

        for(TInt i=0; i<nPages; ++i)

            {

            const TBool keepDirty = iCurrentFatNo < (NumFATs() - 1);

            CFat16FixedCachePage* pPage = iPages[i];

            if(pPage)

                pPage->FlushL(keepDirty);

            }

        }