Symaptic: os/kernelhwsrv/userlibandfileserver/fileserver/sfat32/inc/sl

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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // fileserver\sfat32\inc\sl_std.h

    15 //

    17 /**

    18  @file

    19  @internalTechnology

    20 */

    22 #ifndef SL_STD_H

    23 #define SL_STD_H

    26 //

    27 // #define _DEBUG_RELEASE

    28 //

    30 #include "common.h"

    31 #include <f32ver.h>

    32 #include <e32svr.h>

    33 #include <kernel/localise.h>

    35 #include "filesystem_fat.h"

    36 using namespace FileSystem_FAT;

    38 #include "common_constants.h"

    39 #include "sl_bpb.h"

    40 #include "fat_config.h"

    41 #include "fat_dir_entry.h"

    42 #include "bit_vector.h"

    46 #ifdef _DEBUG

    47 _LIT(KThisFsyName,"EFAT32.FSY"); ///< This FSY name

    48 #endif

    50 //-----------------------------------------------------------------------------

    51 //-- FAT32 specific declarations

    53 const TUint32 KFat32EntryMask = 0x0FFFFFFF;

    55 //-----------------------------------------------------------------------------

    57 class CFatMountCB;

    58 class CFatFileSystem;

    60 /**

    61 Represents the position of a directory entery in terms of a cluster and off set into it

    62 */

    63 class TEntryPos

    64 	{

    65 public:

    66 	TEntryPos() {}

    67 	TEntryPos(TInt aCluster,TUint aPos) : iCluster(aCluster), iPos(aPos) {}

    69     inline TUint32 Cluster() const;

    70     inline TUint32 Pos() const;

    71     inline TBool operator==(const TEntryPos& aRhs) const;

    73 public:

    74 	TInt iCluster;

    75 	TUint iPos;

    76 	};

    79 /**

    80     Interface class between the file system and the local drive media interface,

    81     handles incomplete writes to media with the ability to notify the user.

    82     This class can't be instantinated by user; only CFatMountCB can do this; see CFatMountCB::DriveInterface()

    84 */

    85 class TDriveInterface

    86     {

    87 public:

    88 	enum TAction {ERetry=1};

    90 public:

    92     //-- public interface to the local drive. Provides media driver's error handling (critical and non-critical user notifiers)

    93     //-- and thread-safety if required.

    94 	TInt ReadNonCritical(TInt64 aPos,TInt aLength,const TAny* aTrg,const RMessagePtr2 &aMessage,TInt anOffset) const;

    95 	TInt ReadNonCritical(TInt64 aPos,TInt aLength,TDes8& aTrg) const;

    96 	TInt ReadCritical(TInt64 aPos,TInt aLength,TDes8& aTrg) const;

    98     TInt WriteCritical(TInt64 aPos,const TDesC8& aSrc);

    99     TInt WriteNonCritical(TInt64 aPos,TInt aLength,const TAny* aSrc,const RMessagePtr2 &aMessage,TInt anOffset);

   101     TInt GetLastErrorInfo(TDes8& aErrorInfo) const;

   103     //-- lock the mutex guarding CProxyDrive interface in order to be sure that no other thread can access it.

   104     //-- The thread that calls this method may be suspended until another signals the mutex, i.e. leaves the critical section.

   105     inline void AcquireLock() const {iProxyDrive.EnterCriticalSection();}

   107     //-- release the mutex guarding CProxyDrive.

   108     inline void ReleaseLock() const {iProxyDrive.LeaveCriticalSection();}

   111 protected:

   112     TDriveInterface();

   113     TDriveInterface(const TDriveInterface&);

   114     TDriveInterface& operator=(const TDriveInterface&);

   116     TBool Init(CFatMountCB* aMount);

   117     void Close();

   119 	inline TBool NotifyUser() const;

   120 	TInt HandleRecoverableError(TInt aRes) const;

   121 	TInt HandleCriticalError(TInt aRes) const;

   122 	TInt UnlockAndReMount() const;

   123 	TBool IsDriveWriteProtected() const;

   124 	TBool IsRecoverableRemount() const;

   126 private:

   128 	/**

   129         An internal class that represents a thread-safe wrapper around raw interface to the CProxyDrive

   130         and restricts access to it.

   131     */

   132     class XProxyDriveWrapper

   133         {

   134      public:

   136         XProxyDriveWrapper();

   137        ~XProxyDriveWrapper();

   139         TBool Init(CProxyDrive* aProxyDrive);

   141         inline void EnterCriticalSection() const {iLock.Wait();}

   142         inline void LeaveCriticalSection() const {iLock.Signal();}

   144         //-- methods' wrappers that are used by TDriveInterface

   145         TInt Read(TInt64 aPos,TInt aLength,const TAny* aTrg,const RMessagePtr2 &aMessage,TInt anOffset) const;

   146         TInt Read(TInt64 aPos,TInt aLength,TDes8& aTrg) const;

   147         TInt Write(TInt64 aPos,TInt aLength,const TAny* aSrc,const RMessagePtr2 &aMessage,TInt anOffset);

   148         TInt Write(TInt64 aPos, const TDesC8& aSrc);

   149         TInt GetLastErrorInfo(TDes8& aErrorInfo) const;

   150         TInt Caps(TDes8& anInfo) const;

   152      private:

   153         CProxyDrive*    iLocalDrive; ///< raw interface to the media operations

   154         mutable RMutex  iLock;       ///< used for sorting out multithreaded access to the iLocalDrive

   155         };

   157     CFatMountCB*        iMount;      ///< Pointer to the owning file system mount

   158     XProxyDriveWrapper  iProxyDrive; ///< wrapper around raw interface to the media operations

   160     };

   163 /**

   164     Class providing FAT table interface and basic functionality.

   165 */

   166 class CFatTable : public CBase

   167 	{

   169 public:

   171     virtual ~CFatTable();

   173     static CFatTable* NewL(CFatMountCB& aOwner, const TLocalDriveCaps& aLocDrvCaps);

   175     /** FAT table mounting parameters */

   176     struct TMountParams

   177         {

   178         TMountParams() :iFreeClusters(0), iFirstFreeCluster(0), iFsInfoValid(0) {};

   180         TUint32 iFreeClusters;      ///< Free clusters count, obtained from FSInfo

   181         TUint32 iFirstFreeCluster;  ///< First free cluster,  obtained from FSInfo

   182         TUint32 iFsInfoValid : 1;   ///< ETrue if the information in iFreeClusters &  iFirstFreeCluster is valid

   183         };

   185     //-----------------------------------------------------------------

   186     //-- pure virtual interface

   187     virtual TUint32 ReadL(TUint32 aFatIndex) const = 0;

   188 	virtual void WriteL(TUint32 aFatIndex, TUint32 aValue) = 0;

   189 	virtual TInt64 DataPositionInBytes(TUint32 aCluster) const = 0;

   190     virtual void MountL(const TMountParams& aMountParam) = 0;

   191     //-----------------------------------------------------------------

   192     //-- just virtual interface

   194     virtual void Dismount(TBool /*aDiscardDirtyData*/) {}

   195 	virtual void FlushL() {};

   197     virtual void InvalidateCacheL() {};

   198     virtual void InvalidateCacheL(TInt64 /*aPos*/,TUint32 /*aLength*/) {};

   200 	virtual void FreeClusterListL(TUint32 aCluster);

   201 	virtual void ExtendClusterListL(TUint32 aNumber,TInt& aCluster);

   203     virtual TUint32 AllocateSingleClusterL(TUint32 aNearestCluster);

   204 	virtual TUint32 AllocateClusterListL(TUint32 aNumber,TUint32 aNearestCluster);

   206     virtual void RequestRawWriteAccess(TInt64 /*aPos*/, TUint32 /*aLen*/) const {};

   208     virtual TUint32 FreeClusterHint() const;

   209     virtual TUint32 NumberOfFreeClusters(TBool aSyncOperation=EFalse) const;

   210     virtual TBool RequestFreeClusters(TUint32 aClustersRequired) const;

   212     virtual void InitializeL();

   213     virtual TBool ConsistentState() const {return ETrue;} //-- dummy

   215     //-----------------------------------------------------------------

   216     //-- non-virtual interface

   217     TBool GetNextClusterL(TInt& aCluster) const;

   218     void WriteFatEntryEofL(TUint32 aFatIndex);

   220     void MarkAsBadClusterL(TUint32 aCluster);

   221     TInt CountContiguousClustersL(TUint32 aStartCluster,TInt& anEndCluster, TUint32 aMaxCount) const;

   223     inline TUint32 MaxEntries() const;

   225     TUint32 PosInBytes(TUint32 aFatIndex) const;

   228 protected:

   229 	CFatTable(CFatMountCB& aOwner);

   231     //-- outlawed

   232     CFatTable();

   233     CFatTable(const CFatTable&);

   234     CFatTable& operator=(const CFatTable&);

   236     virtual void SetFreeClusterHint(TUint32 aCluster);

   238     virtual void DecrementFreeClusterCount(TUint32 aCount);

   239 	virtual void IncrementFreeClusterCount(TUint32 aCount);

   241     virtual void SetFreeClusters(TUint32 aFreeClusters);

   242     virtual void CountFreeClustersL();

   243     virtual TUint32 FindClosestFreeClusterL(TUint32 aCluster);

   246     inline TInt     SectorSizeLog2() const;

   247     inline TUint32  FreeClusters() const;

   249     inline TBool IsEndOfClusterCh(TUint32 aCluster) const;

   252     inline TFatType FatType() const;

   253     inline TBool IsFat12() const;

   254     inline TBool IsFat16() const;

   255     inline TBool IsFat32() const;

   258     inline TBool ClusterNumberValid(TUint32 aClusterNo) const;

   260     typedef RArray<TUint> RClusterArray;

   261     void DoFreedClustersNotify(RClusterArray &aFreedClusters);

   264 protected:

   266     CFatMountCB* iOwner;            ///< Owning file system mount

   267     TUint        iMediaAtt;         ///< Cached copy of TLocalDriveCaps::iMediaAtt

   269 private:

   271     TUint32  iFreeClusters;     ///< Number of free cluster in the fat table

   272 	TUint32  iFreeClusterHint;  ///< this is just a hint to the free cluster number, not required to contain exact information.

   273 	TFatType iFatType;          ///< FAT type 12/16/32, cached from the iOwner

   274     TUint32  iFatEocCode;       ///< End Of Cluster Chain code, 0xff8 for FAT12, 0xfff8 for FAT16, and 0xffffff8 for FAT32

   275     TUint32  iMaxEntries;       ///< maximal number of FAT entries in the table. This value is taken from the CFatMount that calculates it

   277     };

   280 class MWTCacheInterface;

   283 //---------------------------------------------------------------------------------------------------------------------------------

   285 /**

   286 Base class abstraction of a raw media disk

   287 */

   290 class CRawDisk : public CBase

   291 	{

   292 public:

   294     static CRawDisk* NewL(CFatMountCB& aOwner, const TLocalDriveCaps& aLocDrvCaps);

   296     virtual void InitializeL();

   298     virtual TInt GetLastErrorInfo(TDes8& aErrorInfo) const;

   299 public:

   301     /**

   302 	Read data from the media via simple WT data cache if it is present. Some media types, like RAM do not have caches.

   303     This method is mostly used to read UIDs of executable modules and store them in the cache.

   305 	@param aPos		Media position in bytes

   306 	@param aLength	Length in bytes of read

   307 	@param aDes		Data from read

   308 	*/

   309 	virtual void ReadCachedL(TInt64 aPos,TInt aLength,TDes8& aDes) const = 0;

   311     /**

   312 	Write data to the media via simple WT data cache if it is present. Some media types, like RAM do not have caches.

   313 	@param aPos		Media position in bytes

   314 	@param aDes		Data to write

   315 	*/

   316 	virtual void WriteCachedL(TInt64 aPos,const TDesC8& aDes) = 0;

   318     virtual void InvalidateUidCache() {}

   319     virtual void InvalidateUidCachePage(TUint64 /*aPos*/) {}

   322 	/**

   323 	Disk read function

   325 	@param aPos		Media position in bytes

   326 	@param aLength	Length in bytes of read

   327 	@param aTrg		Pointer to the data descriptor, i.e. (const TAny*)(&TDes8)

   328 	@param aMessage	Refrence to server message from request

   329 	@param anOffset	Offset into read data to write

   330 	*/

   331 	virtual void ReadL(TInt64 aPos,TInt aLength,const TAny* aTrg,const RMessagePtr2 &aMessage,TInt anOffset) const = 0;

   333 	/**

   334 	Disk write function

   336 	@param aPos		Media position in bytes

   337 	@param aLength	Length in bytes of write

   338 	@param aTrg		Pointer to the data descriptor, i.e. (const TAny*)(&TDes8)

   339 	@param aMessage	Refrence to server message from request, contains data

   340 	@param anOffset	Offset into write data to use in write

   341 	*/

   342 	virtual void WriteL(TInt64 aPos,TInt aLength,const TAny* aSrc,const RMessagePtr2 &aMessage,TInt anOffset) = 0;

   345     virtual inline MWTCacheInterface* DirCacheInterface();

   350 protected:

   352     CRawDisk(CFatMountCB& aOwner);

   354     //-- outlawed

   355     CRawDisk();

   356     CRawDisk(const CRawDisk&);

   357     CRawDisk& operator=(const CRawDisk&);

   360 protected:

   362 	CFatMountCB* iFatMount; ///< Owning file system mount

   366 	};

   368 class CFatFileCB;

   369 class RBitVector;

   371 /**

   372     A helper class. Holds the FAT volume parameters, which in turn are obtained from the Boot Sector

   373 */

   374 class TFatVolParam

   375     {

   376 public:

   378     TFatVolParam();

   379     void Populate(const TFatBootSector& aBootSector);

   380     TBool operator==(const TFatVolParam& aRhs) const;

   382     //-- simple getters

   383     TUint32 ClusterSizeLog2() const     {return iClusterSizeLog2;    }

   384     TUint32 SectorSizeLog2() const      {return iSectorSizeLog2;     }

   385     TUint32 RootDirEnd() const          {return iRootDirEnd;         }

   386     TUint32 SectorsPerCluster() const   {return iSectorsPerCluster;  }

   387     TUint32 RootDirectorySector() const {return iRootDirectorySector;}

   388     TUint32 FirstFatSector() const      {return iFirstFatSector;     }

   389     TUint32 TotalSectors() const        {return iTotalSectors;       }

   390     TUint32 NumberOfFats() const        {return iNumberOfFats;       }

   391     TUint32 FatSizeInBytes() const      {return iFatSizeInBytes;     }

   392     TUint32 RootClusterNum() const      {return iRootClusterNum;     }

   393     TUint32 FSInfoSectorNum() const     {return iFSInfoSectorNum;    }

   394     TUint32 BkFSInfoSectorNum() const   {return iBkFSInfoSectorNum;  }

   396 protected:

   397     TUint32 iClusterSizeLog2;      ///< Log2 of fat file system cluster size

   398     TUint32 iSectorSizeLog2;       ///< Log2 of media sector size

   399     TUint32 iRootDirEnd;           ///< End position of the root directory for Fat12/16

   400     TUint32 iSectorsPerCluster;    ///< Sector per cluster ratio for mounted Fat file system volume

   401     TUint32 iRootDirectorySector;  ///< Start sector of the root directory for Fat12/16

   402     TUint32 iFirstFatSector;       ///< Start sector of the first Fat table in volume

   403     TUint32 iTotalSectors;         ///< Total sectors on media partition

   404     TUint32 iNumberOfFats;         ///< Number of Fats the volume has

   405     TUint32 iFatSizeInBytes;       ///< Size of a single Fat table in volume

   406     TUint32 iRootClusterNum;       ///< Cluster number for Root directory, for Fat32

   407     TUint32 iFSInfoSectorNum;      ///< FSInfo Sector number. If 0, this means that corresponding value isn't set in BPB

   408     TUint32 iBkFSInfoSectorNum;    ///< backup FSInfo Sector number

   409     };

   412 TBool IsLegalDosName(const TDesC&  aName, TBool anAllowWildCards, TBool aUseExtendedChars, TBool aInScanDrive, TBool aAllowLowerCase, TBool aIsForFileCreation);

   413 TBool IsLegalDOSNameChar(TChar aCharacter, TBool aUseExtendedChars);

   415 TUint32 CalculatePageOffsetInCluster(TUint32 aPos, TUint aPageSzLog2);

   417 class CLruCache;

   418 class TLeafDirData;

   419 class CLeafDirCache;

   422 /**

   423 Fat file system mount implmentation, provides all that is required of a plug in

   424 file system mount as well as Fat mount specific functionality

   425 */

   426 class CFatMountCB : public CLocDrvMountCB,

   427 					public MFileSystemSubType,

   428 					public MFileSystemClusterSize,

   429 					public CMountCB::MFileAccessor,

   430 					public CMountCB::MFileExtendedInterface

   431 	{

   432 public:

   433 	static CFatMountCB* NewL();

   434 	~CFatMountCB();

   435     void ConstructL();

   437 public:

   439 	//-- overrides from the abstract CMountCB

   440     void MountL(TBool aForceMount);

   441 	TInt ReMount();

   442 	void Dismounted();

   443 	void VolumeL(TVolumeInfo& aVolume) const;

   444 	void SetVolumeL(TDes& aName);

   445 	void MkDirL(const TDesC& aName);

   446 	void RmDirL(const TDesC& aName);

   447 	void DeleteL(const TDesC& aName);

   448 	void RenameL(const TDesC& anOldName,const TDesC& anNewName);

   449 	void ReplaceL(const TDesC& anOldName,const TDesC& anNewName);

   450 	void EntryL(const TDesC& aName,TEntry& anEntry) const;

   451 	void SetEntryL(const TDesC& aName,const TTime& aTime,TUint aMask,TUint aVal);

   452 	void FileOpenL(const TDesC& aName,TUint aMode,TFileOpen anOpen,CFileCB* aFile);

   453 	void DirOpenL(const TDesC& aName,CDirCB* aDir);

   454 	void RawReadL(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt anOffset,const RMessagePtr2& aMessage) const;

   455 	void RawWriteL(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt anOffset,const RMessagePtr2& aMessage);

   456 	void GetShortNameL(const TDesC& aLongName,TDes& aShortName);

   457 	void GetLongNameL(const TDesC& aShortName,TDes& aLongName);

   458 	void ReadSectionL(const TDesC& aName,TInt aPos,TAny* aTrg,TInt aLength,const RMessagePtr2& aMessage);

   459     TInt CheckDisk();

   460 	TInt ScanDrive();

   461 	TInt ControlIO(const RMessagePtr2& aMessage,TInt aCommand,TAny* aParam1,TAny* aParam2);

   462 	TInt Lock(TMediaPassword& aOld,TMediaPassword& aNew,TBool aStore);

   463 	TInt Unlock(TMediaPassword& aPassword,TBool aStore);

   464 	TInt ClearPassword(TMediaPassword& aPassword);

   465 	TInt ErasePassword();

   466 	TInt ForceRemountDrive(const TDesC8* aMountInfo,TInt aMountInfoMessageHandle,TUint aFlags);

   468     void FinaliseMountL();

   469     void FinaliseMountL(TInt aOperation, TAny* aParam1=NULL, TAny* aParam2=NULL);

   470     TInt MountControl(TInt aLevel, TInt aOption, TAny* aParam);

   471 	TTimeIntervalSeconds TimeOffset() const;

   473 protected:

   475     /** CFatMountCB states */

   476     enum  TFatMntState

   477         {

   478         ENotMounted = 0, ///< 0, initial state, not mounted     (mount state is inconsistent)

   479         EMounting,       ///< 1, Mounting started               (mount state is inconsistent)

   480         EInit_R,         ///< 2, Initialised and not written    (mount state is Consistent)

   481         EInit_W,         ///< 3, Initialised and written        (mount state is Consistent)

   482         EFinalised,      ///< 4, Finalised                      (mount state is Consistent)

   483         EDismounted,     ///< 5, Dismounted                     (mount state is inconsistent)

   484         EInit_Forced,    ///< 6, forcedly mounted, special case (mount state is inconsistent)

   485         };

   487     inline TFatMntState State() const;

   488     inline void SetState(TFatMntState aState);

   489     TInt OpenMountForWrite();

   490     TInt IsFinalised(TBool& aFinalised);

   492     /**

   493         A wrapper around TDriveInterface providing its instantination and destruction.

   494         You must not create objects of this class, use DriveInterface() instead.

   495     */

   496     class XDriveInterface: public TDriveInterface

   497         {

   498       public:

   499         XDriveInterface() : TDriveInterface() {}

   500         ~XDriveInterface() {Close();}

   501         TBool Init(CFatMountCB* aMount) {return TDriveInterface::Init(aMount);}

   502         };

   505 public:

   507 	enum TRenMode {EModeReplace,EModeRename};

   509     TBool ConsistentState() const;

   510     void CheckWritableL() const;

   511     void CheckStateConsistentL() const;

   513 	inline TBool ReadOnly(void) const;

   514     inline void  SetReadOnly(TBool aReadOnlyMode);

   515 	inline TInt StartCluster(const TFatDirEntry & anEntry) const;

   516 	inline CRawDisk& RawDisk() const;

   517 	inline CFatFileSystem& FatFileSystem() const;

   518 	inline CFatTable& FAT() const;

   519 	inline TInt ClusterSizeLog2() const;

   520 	inline TInt SectorSizeLog2() const;

   521 	inline TInt TotalSectors() const;

   522 	inline TInt SectorsPerCluster() const;

   523 	inline TInt ClusterBasePosition() const;

   524     inline TInt RootDirectorySector() const;

   525     inline TUint RootDirEnd() const;

   526     inline TUint32 RootClusterNum() const;

   528 	inline TFatType FatType() const;

   529     inline TBool Is16BitFat() const;

   530     inline TBool Is32BitFat() const;

   532 	inline TUint32 MaxClusterNumber() const;

   533 	inline TInt StartOfFatInBytes() const;

   534     inline TUint32 FirstFatSector() const;

   536 	inline TInt NumberOfFats() const;

   537 	inline TInt FatSizeInBytes() const;

   538 	inline TInt ClusterRelativePos(TInt aPos) const;

   539 	inline TUint StartOfRootDirInBytes() const;

   540 	inline TUint32 UsableClusters() const;

   541 	inline TBool IsBadCluster(TInt aCluster) const;

   542 	inline TBool IsRuggedFSys() const;

   543 	inline void SetRuggedFSys(TBool aVal);

   545 	inline TInt RootIndicator() const;

   547     inline TBool IsRootDir(const TEntryPos &aEntry) const;

   548 	inline CAsyncNotifier* Notifier() const;

   549 	inline TDriveInterface& DriveInterface() const;

   551     inline TBool IsEndOfClusterCh(TInt aCluster) const;

   552 	inline void SetEndOfClusterCh(TInt &aCluster) const;

   555     void ReadUidL(TInt aCluster,TEntry& anEntry) const;

   557     void ReadDirEntryL(const TEntryPos& aPos,TFatDirEntry& aDirEntry) const;

   558 	void WriteDirEntryL(const TEntryPos& aPos,const TFatDirEntry& aDirEntry);

   560     void DirReadL(const TEntryPos& aPos,TInt aLength,TDes8& aDes) const;

   561     void DirWriteL(const TEntryPos& aPos,const TDesC8& aDes);

   563 	void ReadFromClusterListL(TEntryPos& aPos,TInt aLength,const TAny* aTrg,const RMessagePtr2& aMessage,TInt anOffset) const;

   564 	void WriteToClusterListL(TEntryPos& aPos,TInt aLength,const TAny* aSrc,const RMessagePtr2& aMessage,TInt anOffset, TInt& aBadcluster, TInt &aGoodcluster);

   565 	void MoveToNextEntryL(TEntryPos& aPos) const;

   566 	void MoveToDosEntryL(TEntryPos& aPos,TFatDirEntry& anEntry) const;

   567 	void EnlargeL(TInt aSize);

   568 	void ReduceSizeL(TInt aPos,TInt aLength);

   569 	void DoDismount();

   570     TBool ProcessFSInfoSectors(CFatTable::TMountParams& aFatInitParams) const;

   573 	void DoRenameOrReplaceL(const TDesC& anOldName,const TDesC& aNewName,TRenMode aMode,TEntryPos& aNewPos);

   574 	void FindDosNameL(const TDesC& aName,TUint anAtt,TEntryPos& aDosEntryPos,TFatDirEntry& aDosEntry,TDes& aFileName,TInt anError) const;

   576 	void Dismount();

   578     void InitializeRootEntry(TFatDirEntry & anEntry) const;

   580     TInt64 MakeLinAddrL(const TEntryPos& aPos) const;

   582     inline const TFatConfig& FatConfig() const;

   583     TBool CheckVolumeTheSame();

   585     void InvalidateLeafDirCache();

   587     void BlockMapReadFromClusterListL(TEntryPos& aPos, TInt aLength, SBlockMapInfo& aInfo);

   588 	virtual TInt GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput);

   589 	virtual TInt GetFileUniqueId(const TDesC& aName, TInt64& aUniqueId);

   590 	virtual TInt Spare3(TInt aVal, TAny* aPtr1, TAny* aPtr2);

   591 	virtual TInt Spare2(TInt aVal, TAny* aPtr1, TAny* aPtr2);

   592 	virtual TInt Spare1(TInt aVal, TAny* aPtr1, TAny* aPtr2);

   594 public:

   596     // interface extension implementation

   597 	virtual TInt SubType(TDes& aName) const;

   598 	virtual TInt ClusterSize() const;

   599     virtual void ReadSection64L(const TDesC& aName, TInt64 aPos, TAny* aTrg, TInt aLength, const RMessagePtr2& aMessage);

   601 private:

   603     /** An ad hoc internal helper object for using in DoFindL() method and its derivatives */

   604     class TFindHelper

   605         {

   606         public:

   607             TFindHelper() {isInitialised = EFalse;}

   608             void  InitialiseL(const TDesC&  aTargetName);

   609             TBool MatchDosEntryName(const TUint8* apDosEntryName) const;

   610             TBool TrgtNameIsLegalDos() const {ASSERT (isInitialised) ;return isLegalDosName;}

   612         private:

   613             TFindHelper(const TFindHelper&);

   614             TFindHelper& operator=(const TFindHelper&);

   615         public:

   616             TPtrC       iTargetName;        ///< pointer to the aTargetName, used in DoRummageDirCacheL() as a parameter

   617         private:

   618             TBool       isInitialised  :1;  ///< ETrue if the object is initialised. It can be done only once.

   619             TBool       isLegalDosName :1;  ///< ETrue if iTargetName is a legal DOS name

   620             TShortName  iShortName;         ///< a short DOS name in XXXXXXXXYYY format generated from aTargetName

   621         };

   624     	/**

   625 	   	An ad hoc internal helper object for entry creations

   626 	    */

   627 	    class XFileCreationHelper

   628 	    {

   629 	    public:

   630 	    	XFileCreationHelper();

   631 	    	~XFileCreationHelper();

   632 	    	void Close();

   633 	    	void InitialiseL(const TDesC&  aTargetName);

   634 	        TInt GetValidatedShortName(TShortName& aShortName) const;

   635 	    	void CheckShortNameCandidates(const TUint8* apDosEntryName);

   637 	        // inline functions for sets and gets

   638 	        //  note all the get functions have been checked against initialisation status

   639 	    	inline TBool 	IsInitialised() const;

   640 	        inline TUint16	NumOfAddingEntries() const;

   641 	        inline TEntryPos EntryAddingPos()const;

   642 	        inline TBool 	IsNewEntryPosFound() const;

   643 	    	inline TBool 	IsTrgNameLegalDosName() const;

   645 	    	inline void	SetEntryAddingPos(const TEntryPos& aEntryPos);

   646 	    	inline void	SetIsNewEntryPosFound(TBool aFound);

   648 	    private:

   649 	    	XFileCreationHelper(const XFileCreationHelper&);

   650 	    	XFileCreationHelper& operator=(const TFindHelper&);

   652 	    private:

   653 	        TPtrC       iTargetName;		///< pointer to hold the long file name of the target file

   654 	        TUint16		iNumOfAddingEntries;///< calculated number of entries to add

   655 	        TEntryPos	iEntryAddingPos;	///< contains new entry position for adding if found any

   656 	        TBool		isNewEntryPosFound; ///< flags whether the position for new entries is found

   657 	        TBool       isInitialised	:1;	///< flags whether the object is initialised

   658 	        TBool       isTrgNameLegalDosName	:1;	///< flags whether the target file name is a valid Dos name

   659 	        /**

   660 	        an array that holds short name candidates, prepared on initialisation.

   661 	        */

   662 	        RArray<TShortName>  iShortNameCandidates;

   663 	    };

   667 	TBool DoRummageDirCacheL(TUint anAtt,TEntryPos& aStartEntryPos,TFatDirEntry& aStartEntry,TEntryPos& aDosEntryPos,TFatDirEntry& aDosEntry,TDes& aFileName, const TFindHelper& aAuxParam, XFileCreationHelper* aFileCreationHelper, const TLeafDirData& aLeafDir) const;

   668     TBool DoFindL(const TDesC& aName,TUint anAtt,TEntryPos& aStartEntryPos,TFatDirEntry& aStartEntry,TEntryPos& aDosEntryPos,TFatDirEntry& aDosEntry,TDes& aFileName,TInt anError, XFileCreationHelper* aFileCreationHelper, const TLeafDirData& aLeafDirData) const;

   669     void FindEntryStartL(const TDesC& aName,TUint anAtt,TFatDirEntry& anEntry,TEntryPos& aPos, XFileCreationHelper* aFileCreationHelper) const;

   671     void FindEntryStartL(const TDesC& aName,TUint anAtt,TFatDirEntry& anEntry,TEntryPos& aPos) const;

   673 	void CheckFatForLoopsL(const TFatDirEntry& anEntry) const;

   674 	void DoCheckFatForLoopsL(TInt aCluster,TInt& aPreviousCluster,TInt& aChangePreviousCluster,TInt& aCount) const;

   675     void InitializeL(const TLocalDriveCaps& aLocDrvCaps, TBool aIgnoreFSInfo=EFalse);

   676 	void DoReadFromClusterListL(TEntryPos& aPos,TInt aLength,const TAny* aTrg,const RMessagePtr2& aMessage,TInt anOffset) const;

   677 	void DoWriteToClusterListL(TEntryPos& aPos,TInt aLength,const TAny* aSrc,const RMessagePtr2& aMessage,TInt anOffset, TInt aLastcluster, TInt& aBadcluster, TInt& aGoodcluster);

   678 	TBool IsUniqueNameL(const TShortName& aName,TInt aDirCluster);

   679 	TBool FindShortNameL(const TShortName& aName,TEntryPos& anEntryPos);

   680 	void ReplaceClashingNameL(const TShortName& aNewName,const TEntryPos& anEntryPos);

   681     TBool GenerateShortNameL(TInt aDirCluster,const TDesC& aLongName,TShortName& aShortName, TBool aForceRandomize=EFalse);

   682     TInt FindLeafDirL(const TDesC& aName, TLeafDirData& aLeafDir) const;

   684 	TInt GetDirEntry(TEntryPos& aPos,TFatDirEntry& aDosEntry,TFatDirEntry& aStartEntry,TDes& aLongFileName) const;

   685     TBool DoGetDirEntryL(TEntryPos& aPos,TFatDirEntry& aDosEntry,TFatDirEntry& aStartEntry,TDes& aLongFileName) const;

   687 	void WriteDirEntryL(TEntryPos& aPos,const TFatDirEntry& aFatDirEntry,const TDesC& aLongFileName);

   688 	void EraseDirEntryL(TEntryPos aPos,const TFatDirEntry& anEntry);

   689 	void EraseDirEntryL(const TEntryPos& aPos);

   690 	void InitializeFirstDirClusterL(TInt aCluster,TInt aParentCluster);

   691 	void AddDirEntryL(TEntryPos& aPos,TInt aNameLength);

   692 	void ZeroDirClusterL(TInt aCluster);

   694     TInt DoWriteBootSector(TInt64 aMediaPos, const TFatBootSector& aBootSector) const;

   695 	TInt DoReadBootSector(TInt64 aMediaPos, TFatBootSector& aBootSector) const;

   696     TInt ReadBootSector(TFatBootSector& aBootSector, TBool aDoNotReadBkBootSec=EFalse);

   698     TInt WriteFSInfoSector(TInt64 aMediaPos, const TFSInfo& aFSInfo) const;

   699 	TInt ReadFSInfoSector(TInt64 aMediaPos, TFSInfo& aFSInfo) const;

   701     TBool IsDirectoryEmptyL(TInt aCluster);

   702 	void ExtendClusterListZeroedL(TInt aNumber,TInt& aCluster);

   703 	void WritePasswordData();

   705     void WriteVolumeLabelL(const TDesC8& aVolumeLabel) const;

   706     TInt ReadVolumeLabelFile(TDes8& aLabel);

   707 	void WriteVolumeLabelFileL(const TDesC8& aNewName);

   708 	void FindVolumeLabelFileL(TDes8& aLabel, TEntryPos& aDosEntryPos, TFatDirEntry& aDosEntry);

   709 	void GetVolumeLabelFromDiskL(const TFatBootSector& aBootSector);

   710 	void TrimVolumeLabel(TDes8& aLabel) const;

   712     TInt    DoRunScanDrive();

   713     TBool   VolumeCleanL();

   714     void    SetVolumeCleanL(TBool aClean);

   715     TBool   VolCleanFlagSupported() const;

   717     void    DoUpdateFSInfoSectorsL(TBool aInvalidateFSInfo);

   718     void    UnFinaliseMountL();

   719     void    DoReMountL();

   720     void    SetFatType(TFatType aFatType);

   723 private:

   726 	CFatMountCB();

   728 	TInt GetDosEntryFromNameL(const TDesC& aName, TEntryPos& aDosEntryPos, TFatDirEntry& aDosEntry);

   730     TInt MntCtl_DoCheckFileSystemMountable();

   733 private:

   735     TBool iReadOnly         : 1;///< if true, the drive is in read-only mode

   736     TBool iRamDrive         : 1;///< true if this is a RAM drive

   737     TBool iMainBootSecValid : 1;///< true if the main boot sector is valid, if false, a backup boot sector may be in use.

   739     TFatMntState iState;        ///< this mounnt internal state

   741     TFatType iFatType;          ///< FAT type, FAT12,16 or 32

   742     TUint32  iFatEocCode;       ///< End Of Cluster Chain code, 0xff8 for FAT12, 0xfff8 for FAT16, and 0xffffff8 for FAT32

   744     CLeafDirCache* iLeafDirCache;	///< A cache for most recently visited directories, only valid when limit is set bigger than 1

   745     HBufC* iLastLeafDir;        	///< The last visited directory, only valid when limit of iLeafDirCache is less than 1

   746     TInt iLastLeafDirCluster;   	///< Cluster number of the last visited cluster, only valid when limit of iLeafDirCache is less than 1

   748 	TFatVolParam iVolParam;         ///< FAT volume parameters, populated form the boot sector values.

   750 	TInt iFirstFreeByte;            ///< First free byte in media (start of the data area on the volume)

   751 	TUint32 iUsableClusters;        ///< Number of usable cluster on the volume

   753     CFatTable* iFatTable;           ///< Pointer to the volume Fat

   754 	CRawDisk*  iRawDisk;            ///< Pointer to the raw data interface class

   756     CAsyncNotifier* iNotifier;  ///< Async notifier for notifying user of Fat error conditions

   758     XDriveInterface iDriverInterface; ///< the object representing interface to the drive, provides read/write access and notifiers

   759     TInt            iChkDiscRecLevel; ///< Check disk recursion level counter. A temporary measure.

   760 	TFatConfig      iFatConfig;       ///< FAT parametrers from estart.txt

   762 	XFileCreationHelper iFileCreationHelper;

   765 #ifdef  _DEBUG

   766     private:

   767     //-- debug odds and ends

   768     inline TBool IsWriteFail()const;

   769 	inline void SetWriteFail(TBool aIsWriteFail);

   770 	inline TInt WriteFailCount()const;

   771 	inline void SetWriteFailCount(TInt aFailCount);

   772 	inline void DecWriteFailCount();

   773 	inline TInt WriteFailError()const;

   774 	inline void SetWriteFailError(TInt aErrorValue);

   777 	TBool   iIsWriteFail : 1; ///< Flag to indicate if write failed used for debugging

   778     TBool   iCBRecFlag   : 1; ///< in debug mode used for checking unwanted recursion

   780     TInt    iWriteFailCount;  ///< Write fail count for debug

   781 	TInt    iWriteFailError;  ///< Write fail error to use for debug

   783 #endif

   785 friend class CFatFormatCB;

   786 friend class CScanDrive;

   787 friend class TDriveInterface;

   788 	};

   793 /**

   794 Fat file system file subsession implmentation, provides all that is required of a plug in

   795 file system file as well as Fat specific functionality

   796 */

   797 class CFatFileCB : public CFileCB, public CFileCB::MBlockMapInterface, public CFileCB::MExtendedFileInterface

   798 	{

   799 public:

   800 	CFatFileCB();

   801 	~CFatFileCB();

   802 public:

   803 	void RenameL(const TDesC& aNewName);

   804 	void ReadL(TInt aPos,TInt& aLength,const TAny* aDes,const RMessagePtr2& aMessage);

   805 	void WriteL(TInt aPos,TInt& aLength,const TAny* aDes,const RMessagePtr2& aMessage);

   806 	void SetSizeL(TInt aSize);

   807 	void SetEntryL(const TTime& aTime,TUint aMask,TUint aVal);

   808 	void FlushDataL();

   809 	void FlushAllL();

   810 public:

   811 	void CheckPosL(TUint aPos);

   812 	void SetL(const TFatDirEntry& aFatDirEntry,TShare aShare,const TEntryPos& aPos);

   813 	void CreateSeekIndex();

   815     inline TBool IsSeekIndex() const;

   817 	// from MBlockMapInterface

   818 	TInt BlockMap(SBlockMapInfo& aInfo, TInt64& aStartPos, TInt64 aEndPos);

   820 	// from CFileCB

   821 	virtual TInt GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput);

   823 	// from CFileCB::MExtendedFileInterface

   824 	virtual void ReadL(TInt64 aPos,TInt& aLength,TDes8* aDes,const RMessagePtr2& aMessage, TInt aOffset);

   825 	virtual void WriteL(TInt64 aPos,TInt& aLength,const TDesC8* aDes,const RMessagePtr2& aMessage, TInt aOffset);

   826 	virtual void SetSizeL(TInt64 aSize);

   828 private:

   829 	inline CFatMountCB& FatMount() const;

   830     inline CFatTable& FAT();

   831 	inline TInt ClusterSizeLog2();

   832 	inline TInt ClusterRelativePos(TInt aPos);

   835     void FlushStartClusterL();

   836 	TInt SeekToPosition(TInt aNewCluster,TInt aClusterOffset);

   837 	void SetSeekIndexValueL(TInt aFileCluster,TInt aStoredCluster);

   838 	void ResizeIndex(TInt aNewMult,TUint aNewSize);

   839 	TInt CalcSeekIndexSize(TUint aSize);

   840 	TBool IsSeekBackwards(TUint aPos);

   841 	void ClearIndex(TUint aNewSize);

   842 	void DoSetSizeL(TUint aSize,TBool aIsSizeWrite);

   843 	void WriteFileSizeL(TUint aSize);

   845 private:

   847 	TUint32* iSeekIndex;    ///< Seek index into file

   848 	TInt iSeekIndexSize;    ///< size of seek index

   849 	TInt iStartCluster;     ///< Start cluster number of file

   850 	TEntryPos iCurrentPos;  ///< Current position in file data

   851 	TEntryPos iFileDirPos;  ///< File directory entry position

   852 	TBool iFileSizeModified;

   853 	};

   856 /**

   857 Fat file system directory subsession implmentation, provides all that is required of a plug in

   858 file system directory as well as Fat specific functionality

   859 */

   860 class CFatDirCB : public CDirCB

   861 	{

   862 public:

   863 	static CFatDirCB* NewL();

   864 	~CFatDirCB();

   865 public:

   866 	void ReadL(TEntry& anEntry);

   867 	void StoreLongEntryNameL(const TDesC& aName);

   868 public:

   869 	void SetDirL(const TFatDirEntry& anEntry,const TDesC& aMatchName);

   870 	inline CFatMountCB& FatMount();

   871 private:

   872 	CFatDirCB();

   873 private:

   874 	TFatDirEntry iEntry;       ///< Current directory entry in this directory

   875 	TEntryPos    iCurrentPos;  ///< Current position in directory

   876 	HBufC*       iMatch;       ///< Current name being searched in directory (Dos Name)

   877 	HBufC*       iLongNameBuf; ///< Long name storage

   878 	TBool        iMatchUid;    ///< Flag to indicate if UID matches

   879 	};

   881 /**

   882     Fat file system Format subsession implmentation, provides all that is required of a plug in

   883     file system format as well as Fat specific functionality

   884 */

   885 class CFatFormatCB : public CFormatCB

   886 	{

   887 public:

   888 	CFatFormatCB();

   889 	~CFatFormatCB();

   890 public:

   892     //-- overrides from CFormatCB

   893     void DoFormatStepL();

   895 private:

   896     //-- overrides from CFormatCB

   897     TInt GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput);

   899 private:

   901     TInt DoProcessTVolFormatParam(const TVolFormatParam_FAT* apVolFormatParam);

   903     void CreateBootSectorL();

   904 	void CreateFSInfoSectorL();

   905 	void CreateReservedBootSectorL();

   906 	void InitializeFormatDataL();

   907 	void DoZeroFillMediaL(TInt64 aStartPos, TInt64 aEndPos);

   909     TInt InitFormatDataForVariableSizeDisk(TInt aDiskSizeInSectors);

   910 	TInt InitFormatDataForFixedSizeDiskNormal(TInt aDiskSizeInSectors, const TLocalDriveCapsV6& aCaps);

   911 	TInt InitFormatDataForFixedSizeDiskCustom(const TLDFormatInfo& aFormatInfo);

   912     TInt InitFormatDataForFixedSizeDiskUser(TInt aDiskSizeInSectors);

   913 	void AdjustClusterSize(TInt aRecommendedSectorsPerCluster);

   914 	TInt AdjustFirstDataSectorAlignment(TInt aBlockSize);

   915 	TInt FirstDataSector() const;

   917 	TInt HandleCorrupt(TInt aError);

   918 	TInt BadSectorToCluster();

   919     void TranslateL();

   920     TInt DoTranslate(TPtr8& aBuf, RArray<TInt>& aArray);

   921     void RecordOldInfoL();

   922 	TInt MaxFat12Sectors() const;

   923 	TInt MaxFat16Sectors() const;

   924 	TUint32 MaxFat32Sectors() const;

   925 	inline TBool Is16BitFat() const;

   926 	inline TBool Is32BitFat() const;

   927 	inline CFatMountCB& FatMount();

   928 	inline CProxyDrive* LocalDrive();

   929     TFatType SuggestFatType() const;

   931 private:

   933     TBool   iVariableSize;      ///< Flag to indicat if we are dealing with a variable size volume

   934 	TInt    iBytesPerSector;    ///< Byte per sector of media

   935     TInt    iSectorSizeLog2;    ///< Sector size in log2

   936 	TInt    iNumberOfFats;      ///< Number of Fats the volume will contain

   937 	TInt    iReservedSectors;   ///< Number of reserved sectors in the volume

   938 	TInt    iRootDirEntries;    ///< Nummer of root directory entries the root dir will have, specific to Fat12/16 volumes

   939 	TInt    iSectorsPerCluster; ///< Sector per cluster ration the volume will be formatted with

   940 	TInt    iSectorsPerFat;     ///< Number of sectors the Fat uses

   941 	TInt    iMaxDiskSectors;    ///< number of sectors the volume has

   942 	TFormatInfo iFormatInfo;    ///< format information for a custom format

   943 	TBuf8<16>   iFileSystemName;///< Buffer to contain the volume name

   944 	TInt    iHiddenSectors;     ///< Number of hidden sectors in the volume

   945 	TInt    iNumberOfHeads;     ///< Number of heads the media device has, not used so far as only used on solid state media.

   946 	TInt    iSectorsPerTrack;   ///< Number of sectors the media device has, not used so far as only used on solid state media.

   947 	TUint32 iRootClusterNum;    ///< cluster number used for root directory, Fat32 specific

   948 	TUint32 iCountOfClusters;   ///< Count of clusters on the media

   949     RArray<TInt> iBadClusters;  ///< Array of bad cluster numbers

   950     RArray<TInt> iBadSectors;   ///< Array of bad sector numbers

   951     TBool   iDiskCorrupt;       ///< Disk is corrupt when format or not

   952     TInt    iOldFirstFreeSector;

   953     TInt    iOldSectorsPerCluster;

   954 	};

   956 /**

   957 Required file system class used by file server to create the file system objects

   958 */

   959 class CFatFileSystem : public CFileSystem

   960 	{

   961 public:

   962 	static CFatFileSystem* New();

   963 	~CFatFileSystem();

   964 public:

   965 	TInt Install();

   966 	CMountCB* NewMountL() const;

   967 	CFileCB* NewFileL() const;

   968 	CDirCB* NewDirL() const;

   969 	CFormatCB* NewFormatL() const;

   970 	TInt DefaultPath(TDes& aPath) const;

   971 	TBool IsExtensionSupported() const;

   972 	TBool GetUseLocalTime() const;

   973 	void SetUseLocalTime(TBool aFlag);

   974 	TInt GetInterface(TInt aInterfaceId, TAny*& aInterface,TAny* aInput);

   975 protected:

   976 	CFatFileSystem();

   977 	/**

   978 	If true, then local time will be used when writing timestamps to FS. When reading,

   979 	timestamps will be assumed local and converted back to UTC.

   980 	At present, this behaviour will also be conditional upon a particular drive being logically removable.

   981 	*/

   982 	TBool iUseLocalTimeIfRemovable;

   983 	};

   987 /**

   988 Locale utilities allows the file system to call into a specific locale for tasks

   989 such as Dos name to unicode conversions and testing the legality of characters for

   990 any given locale.

   991 */

   992 class LocaleUtils

   994 	{

   995 public:

   996 	static void ConvertFromUnicodeL(TDes8& aForeign, const TDesC16& aUnicode, TFatUtilityFunctions::TOverflowAction aOverflowAction=TFatUtilityFunctions::EOverflowActionTruncate);

   997 	static void ConvertToUnicodeL(TDes16& aUnicode, const TDesC8& aForeign, TFatUtilityFunctions::TOverflowAction aOverflowAction=TFatUtilityFunctions::EOverflowActionTruncate);

   998 	static TBool IsLegalShortNameCharacter(TUint aCharacter,TBool aUseExtendedChars=EFalse);

   999 	};

  1000 //

  1002 /**

  1003 Converts Dos time (from a directory entry) to TTime format

  1005 @param aDosTime Dos format time

  1006 @param aDosDate Dos format Date

  1007 @return TTime format of Dos time passed in

  1008 */

  1009 TTime DosTimeToTTime(TInt aDosTime,TInt aDosDate);

  1010 /**

  1011 Converts TTime format to Dos time format

  1013 @param aTime TTime to convert to Dos time

  1014 @return Dos time format

  1015 */

  1016 TInt DosTimeFromTTime(const TTime& aTime);

  1017 /**

  1018 Converts TTime format to Dos time format

  1020 @param aTime TTime to convert to Dos Date

  1021 @return Dos Date format

  1022 */

  1023 TInt DosDateFromTTime(const TTime& aTime);

  1024 /**

  1025 Converts Dos Directory entry format to 8.3 format

  1027 @param aDosName Directory entry format with space delimeter

  1028 @return 8.3 Dos filename format

  1029 */

  1030 TBuf8<12> DosNameToStdFormat(const TDesC8& aDosName);

  1031 /**

  1032 Converts 8.3 format to Dos Directory entry format

  1034 @param aStdFormatName 8.3 Dos filename format

  1035 @return Directory entry format with space delimeter

  1036 */

  1037 TBuf8<12> DosNameFromStdFormat(const TDesC8& aStdFormatName);

  1038 /**

  1039 Fault function calls user panic with a fault reason

  1041 @param Enumerated fault reason

  1042 */

  1043 void Fault(TFault aFault);

  1044 /**

  1045 calculates the number of VFat directory entries for a given file/directory name length

  1047 @param the length in characters of the name

  1048 @return the number of VFat entries required

  1049 */

  1050 TInt NumberOfVFatEntries(TInt aNameLength);

  1051 /**

  1052 Calculates the check sum for a standard directory entry

  1054 @param the Dos name for the directory entry

  1055 @return the checksum

  1056 */

  1057 TUint8 CalculateShortNameCheckSum(const TDesC8& aShortName);

  1059 TUint32 EocCodeByFatType(TFatType aFatType);

  1062 #include "sl_std.inl"

  1063 #include "sl_bpb.inl"

  1064 #include "fat_dir_entry.inl"

  1066 #endif //SL_STD_H

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--