// Copyright (c) 1998-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\sfat\sl_facache.h
// FAT cache base classes definition
// FAT12 and FAT16 cache classes definition
//
//
/**
@file
@internalTechnology
*/
#ifndef SL_FAT_CACHE_H
#define SL_FAT_CACHE_H
//-----------------------------------------------------------------------------
class CFatBitCache;
/**
An abstract base class for all types of FAT caches.
Provides user interface and some common for all types of FAT caches functionality.
*/
class CFatCacheBase : public CBase
{
public:
virtual ~CFatCacheBase();
//-- public interface
virtual void Close(TBool /*aDiscardDirtyData*/) {};
virtual void FlushL() = 0;
virtual TUint32 ReadEntryL(TUint32 aIndex) = 0;
virtual void WriteEntryL(TUint32 aIndex, TUint32 aEntry) = 0;
virtual TInt Invalidate() = 0;
virtual TInt InvalidateRegion(TUint32 aStartEntry, TUint32 aNumEntries) = 0;
TInt ReadFatData(TUint32 aPos, TUint32 aLen, TDes8& aData) const;
TInt WriteFatData(TUint32 aPos, const TDesC8& aData) const;
inline TUint32 FatStartPos() const;
inline TUint32 FatSize() const;
inline TFatType FatType() const;
public:
//-- auxilary interface to additional bit supercache (it may exist only in FAT32 cache implementation)
virtual CFatBitCache* BitCacheInterface();
protected:
CFatCacheBase();
virtual void InitialiseL(CFatMountCB* aOwner);
inline TBool IsDirty() const;
inline void SetDirty(TBool aDirty);
inline TUint NumFATs() const;
TBool CheckInvalidatingDirtyCache() const;
inline TUint FAT_SectorSzLog2() const;
inline TUint FAT_SectorSz() const;
inline TUint FAT_ClusterSzLog2() const;
inline TUint32 MaxFatEntries() const;
inline TBool FatIndexValid(TUint32 aIndex) const;
protected:
enum {KInvalidFatNo = 0xFF}; ///< used to invalidate current FAT no.
TUint iCurrentFatNo; ///< current FAT number WriteFatData will write to.
private:
//-- values cached from owning mount.
TUint32 iFatStartPos; ///< media position of FAT1 start
TUint32 iFatSize; ///< size of FAT in bytes
TUint32 iMaxFatEntries; ///< maximal number of FAT entries in FAT table, FAT[0] & FAT [1] included
TUint16 iNumFATs; ///< number of FATs on the volume
TUint16 iFatSecSzLog2; ///< Log2(FAT Sector size)
TUint16 iFatClustSzLog2;///< Log2(FAT cluster size)
TFatType iFatType; ///< FAT type
TDriveInterface* ipDrive;///< interface to the media driver
//---
TBool iDirty; ///< ETrue if the cache is dirty
};
//-----------------------------------------------------------------------------
/**
Fixed FAT12 cache. This is a contiguous cache that caches whole FAT12.
This cache is logically divided to sectors, maximal number of sectors in this cache is KMaxSectorsInCache (32).
Read granularity: whole cache; anyway it can't be larger than 6126 bytes.
Write granularity: cache sector size, which is always "FAT Sector Size" and non-configurable.
*/
class CFat12Cache : public CFatCacheBase
{
public:
static CFat12Cache* NewL(CFatMountCB* aOwner, TUint32 aFatSize);
//-- overrides from base class
virtual void Close(TBool aDiscardDirtyData);
virtual void FlushL();
virtual TUint32 ReadEntryL(TUint32 aIndex);
virtual void WriteEntryL(TUint32 aIndex, TUint32 aEntry);
virtual TInt Invalidate();
virtual TInt InvalidateRegion(TUint32 aStartEntry, TUint32 aNumEntries);
//------------------------------------
private:
void InitialiseL(CFatMountCB* aOwner, TUint32 aFatSize);
CFat12Cache();
CFat12Cache(const CFat12Cache&);
CFat12Cache& operator=(const CFat12Cache&);
inline TUint32 NumSectors() const;
void AssertCacheReallyClean() const;
private:
enum {KMaxSectorsInCache = 32}; ///< maximal number sectors in FAT12 cache
enum {KFat12EntryMask = 0x0FFF}; ///< FAT12 entry mask
TUint32 iSectorsInCache; ///< total number sectors in the cache, KMaxSectorsInCache max.
T32Bits iDirtySectors; ///< dirty sectors bitmap. '1' bit corresponds to the dirty sector;
RBuf8 iData; ///< Whole FAT12 cache data.
};
//-----------------------------------------------------------------------------
/**
Abstract base class for paged caches, i.e. those that consist of some number of cache pages.
In this case the most of the functionality is implemented in page classes and this is just a page container.
Each cache page in turn is logically divided to sectors. The sector is a logical unit of write granularity
See also CFatCachePageBase et al.
*/
class CFatPagedCacheBase : public CFatCacheBase
{
public:
inline TUint PageSizeLog2() const;
inline TUint PageSize() const;
inline TUint SectorSizeLog2() const;
inline TUint SectorsInPage() const;
protected:
CFatPagedCacheBase();
protected:
enum {KMaxSectorsInPage = 32}; ///< maximal number sectors in FAT cache page
TUint iPageSizeLog2; ///< Log2(page size)
TUint iSectorSizeLog2; ///< Log2(page sector size)
};
//-----------------------------------------------------------------------------
class CFat16FixedCachePage;
/**
FAT16 fixed paged cache. Used for FAT16 only and caches whole FAT16 (its max size is 131048 bytes).
Consists of the fixed array of cache pages; Pages are allocated on demand and never get evicted.
Each page is logically divided to page sectors. The number of pages depends on the FAT16 size.
Read granularity: One page, which size is 2^aRdGranularityLog2
Write granularity: cache's page sector; its size is 2^aWrGranularityLog2
*/
class CFat16FixedCache : public CFatPagedCacheBase
{
public:
static CFat16FixedCache* NewL(CFatMountCB* aOwner, TUint32 aFatSize, TUint32 aRdGranularityLog2, TUint32 aWrGranularityLog2);
//-- overrides from base class
virtual void Close(TBool aDiscardDirtyData);
virtual void FlushL();
virtual TUint32 ReadEntryL(TUint32 aIndex);
virtual void WriteEntryL(TUint32 aIndex, TUint32 aEntry);
virtual TInt Invalidate();
virtual TInt InvalidateRegion(TUint32 aStartEntry, TUint32 aNumEntries);
//------------------------------------
private:
void InitialiseL(CFatMountCB* aOwner, TUint32 aFatSize, TUint32 aRdGranularityLog2, TUint32 aWrGranularityLog2);
CFat16FixedCache();
CFat16FixedCache(const CFat16FixedCache&);
CFat16FixedCache& operator=(const CFat16FixedCache&);
inline TUint NumPages() const;
void AssertCacheReallyClean() const;
private:
RPointerArray<CFat16FixedCachePage> iPages; ///< array of pointer to the cahe pages; if the entry is NULL, it means that the page isn't allocated yet.
};
//-----------------------------------------------------------------------------
/**
An abstract base class for the cache page. Paged caches, i.e derived form CFatPagedCacheBase uses this functionality.
Provides an interface and common functionality for all types of cache pages.
The FAT cache page contains a number of FAT16 or FAT32 entries, their number is always the power of 2.
The page is logically divided into sectors, the maximal number of sectors in the page is KMaxSectorsInPage (32).
The page read granularity is whole page and the write granularity is the sector (see aRdGranularityLog2, aWrGranularityLog2 from the cache)
The caching is write-back, i.e WriteCachedEntryL() modifies data in the cache and marks corresponding page sector as dirty.
FlushL() shall be called to flust all dirty sectors in page to the media
*/
class CFatCachePageBase : public CBase
{
public:
~CFatCachePageBase();
//----------------
virtual TBool ReadCachedEntryL (TUint32 aFatIndex, TUint32& aResult) = 0;
virtual TBool WriteCachedEntryL(TUint32 aFatIndex, TUint32 aFatEntry) = 0;
virtual TUint32 ReadFromMediaL(TUint32 aFatIndex) = 0;
virtual void FlushL(TBool aKeepDirty);
//----------------
inline TBool IsEntryCached(TUint32 aFatIndex) const ;
void Invalidate(TBool aIgnoreDirtyData = EFalse);
inline TBool IsDirty() const;
inline TBool IsValid() const;
inline TUint32 StartFatIndex() const;
protected:
CFatCachePageBase(CFatPagedCacheBase& aCache);
/** possible states of the page */
enum TState
{
EInvalid, ///< the page's data are invalid
EClean, ///< the page is clean, data valid and the same as on the media
EDirty ///< the page is dirty, there are data eventually to be flushed to the media, iDirtySectors contains dirty sectors bitmap.
};
inline void SetState(TState aState);
inline TState State() const;
inline void SetClean();
inline TUint32 PageSize() const;
inline TUint32 NumSectors() const;
virtual void DoWriteSectorL(TUint32 aSector)=0;
inline TUint32 EntriesInPage() const;
protected:
TUint32 iStartIndexInFAT; ///< FAT index this page starts from
T32Bits iDirtySectors; ///< dirty sectors bitmap. '1' bit corresponds to the dirty sector;
CFatPagedCacheBase& iCache; ///< reference to the owher cache
RBuf8 iData; ///< page Data
private:
TState iState; ///< page state
TUint32 iFatEntriesInPage; ///< number of FAT entries in the page.
};
//---------------------------------------------------------------------------------------------------------------------------------
/**
FAT16 cache page. Used only by CFat16FixedCache.
*/
class CFat16FixedCachePage : public CFatCachePageBase
{
public:
~CFat16FixedCachePage() {}
static CFat16FixedCachePage* NewL(CFatPagedCacheBase& aCache);
//-- overrides
virtual TBool ReadCachedEntryL (TUint32 aFatIndex, TUint32& aResult);
virtual TBool WriteCachedEntryL(TUint32 aFatIndex, TUint32 aFatEntry);
virtual TUint32 ReadFromMediaL(TUint32 aFatIndex);
//----
private:
CFat16FixedCachePage(CFatPagedCacheBase& aCache);
//-- outlaws here
CFat16FixedCachePage();
CFat16FixedCachePage(const CFat16FixedCachePage&);
CFat16FixedCachePage& operator=(const CFat16FixedCachePage&);
virtual void DoWriteSectorL(TUint32 aSector);
inline TFat16Entry* GetEntryPtr(TUint32 aFatIndex) const;
private:
enum {KFat16EntryMask = 0xFFFF}; ///< FAT16 entry mask
};
//---------------------------------------------------------------------------------------------------------------------------------
#include "sl_fatcache.inl"
#endif //SL_FAT_CACHE_H