// 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_mnt16.cpp

// CFatMountCB code, specific to the EFAT.FSY

// 

//

/**

 @file 

*/

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//!!

//!! WARNING!! DO NOT edit this file !! '\sfat' component is obsolete and is not being used. '\sfat32'replaces it

//!!

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

#include "sl_std.h"

#include "sl_cache.h"

#include "sl_leafdir_cache.h"

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

/**

    Write aligned members of TFatBootSector to media

    @param  aMediaPos   media position the data will be written to

    @param  aBootSector data to write

    @return Media write error code

*/

TInt CFatMountCB::DoWriteBootSector(TInt64 aMediaPos, const TFatBootSector& aBootSector) const

    {

    __PRINT2(_L("#- CFatMountCB::DoWriteBootSector() drv:%d, pos:0x%x"),Drive().DriveNumber(), (TUint32)aMediaPos);   

    ASSERT(aMediaPos>=0);

    TBuf8<KDefaultSectorSize> bootSecBuf(KDefaultSectorSize);

    bootSecBuf.FillZ();

    //-- externalize boot sector to the data buffer

    aBootSector.Externalize(bootSecBuf);

    //-- put a boot sector signature to the last 2 bytes

    bootSecBuf[KDefaultSectorSize-2] = 0x55;

    bootSecBuf[KDefaultSectorSize-1] = 0xaa;

    //-- write boot sector to the media

    TInt r=LocalDrive()->Write(aMediaPos, bootSecBuf);

    if (r!=KErrNone)

        {//-- write failure

        __PRINT2(_L("CFatMountCB::DoWriteBootSector() failed! drv:%d, code:%d"),Drive().DriveNumber(),r);

        }

    return r;

    }

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

/**

    Read non aligned boot data from media into TFatBootSector structure

    @param  aMediaPos   media position the data will be read from

    @param  aBootSector refrence to TFatBootSector populate

    @return Media read error code

*/

TInt CFatMountCB::DoReadBootSector(TInt64 aMediaPos, TFatBootSector& aBootSector) const 

    {

    __PRINT2(_L("#- CFatMountCB::DoReadBootSector() drv:%d, pos:0x%x"),Drive().DriveNumber(), (TUint32)aMediaPos);   

    ASSERT(aMediaPos>=0);

    TBuf8<KSizeOfFatBootSector> bootSecBuf(KSizeOfFatBootSector);

    //-- read boot sector from the media

    TInt r=LocalDrive()->Read(aMediaPos, KSizeOfFatBootSector, bootSecBuf);

    if (r != KErrNone)

        {

        __PRINT2(_L("CFatMountCB::DoReadBootSector() failed! drv:%d, code:%d"),Drive().DriveNumber(),r);

        //-- fiddling with the error code; taken from MountL()

        if (r==KErrNotSupported)

            return KErrNotReady;

    #if defined(_LOCKABLE_MEDIA)

        else if(r==KErrLocked)

            return KErrLocked;

    #endif

        else if (r!=KErrNoMemory && r!=KErrNotReady && r!=KErrCorrupt && r!=KErrUnknown)

                return KErrCorrupt; 

        return r;

        }

    ASSERT(r==KErrNone);

    //-- initialise TFatBootSector object

    aBootSector.Internalize(bootSecBuf);

    //-- Validate the partition size, and fix up if the out of bounds

    TLocalDriveCapsV2Buf localDriveCaps;

    r = LocalDrive()->Caps(localDriveCaps);

    ASSERT(r==KErrNone);

    if(!(localDriveCaps().iMediaAtt & KMediaAttVariableSize))

        {//-- this is not a RAM drive.

        const TUint32 maxSectors = I64LOW(localDriveCaps().iSize >> KDefSectorSzLog2);

        if(aBootSector.TotalSectors())

            aBootSector.SetTotalSectors(Min(aBootSector.TotalSectors(), maxSectors));

        else

            aBootSector.SetHugeSectors(Min(aBootSector.HugeSectors(), maxSectors));

        }

    return KErrNone;

    }

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

/**

    Read and validate the boot sector.

    @param      aBootSector reference to the boot sector object to be read.

    @param      aDoNotReadBkBootSec if true, there won't be an attempt to read backup sector (N/A for FAT12/16)

    @return     standard error code.

*/

TInt CFatMountCB::ReadBootSector(TFatBootSector& aBootSector, TBool /*aDoNotReadBkBootSec=EFalse*/)

    {

    //-- read main boot sector from the sector 0

    TInt nRes = DoReadBootSector(KBootSectorNum << KDefSectorSzLog2, aBootSector); 

    if(nRes == KErrNone)

        {

        if(aBootSector.IsValid())

            {//-- main boot sector is valid, everything is OK

            return KErrNone;

            }

        else

            {

            __PRINT(_L("Boot Sector is invalid! dump:\n"));

            aBootSector.PrintDebugInfo();

            return KErrCorrupt;

            }

        }

    //-- can't read boot sector

    return nRes;

    }

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

/**

Write a new volume label to BPB in media

@param aVolumeLabel Descriptor containing the new volume label

@leave 

*/

void CFatMountCB::WriteVolumeLabelL(const TDesC8& aVolumeLabel) const

    {

    if(aVolumeLabel.Length() > KVolumeLabelSize)

        User::Leave(KErrArgument);

    User::LeaveIfError(LocalDrive()->Write(KFat16VolumeLabelPos,aVolumeLabel)); 

    }

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

const TUint16 KFat16CleanShutDownMask   = 0x08000;    ///< Mask used to indicate test clean/dirty bit for Fat16

/**

Set or reset "VolumeClean" (ClnShutBitmask) flag.

@param  aClean if ETrue, marks the volume as clean, otherwise as dirty.

@leave  if write error occured.        

*/

void CFatMountCB::SetVolumeCleanL(TBool aClean) 

    {

    //-- The volume can't be set clean if there are objects opened on it. This precondition must be checked before calling this function

    if(aClean && LockStatus()!=0)

        {

        __PRINT1(_L("#- CFatMountCB::SetVolumeCleanL drive:%d isn't free!"),DriveNumber());

        ASSERT(0);

        User::Leave(KErrInUse);

        return;

        }

    if(FatType() == EFat12)

        {//-- Fat12 doesn't support this feature; do nothing other than notify the underlying drive

         //   (ignoring any error for now as there's nothing we can do with it)

        (void)LocalDrive()->Finalise(aClean);

        return;

        }

    //-- further read and write will be directly from the CProxyDrive, bypassing FAT cache. 

    //-- this is because CFatTable doesn't allow access to FAT[1]

    if(Is16BitFat())

        {//-- Fat16

        __PRINT2(_L("#- CFatMountCB::SetVolumeCleanL, drive:%d, param:%d, FAT16, efat.fsy"),DriveNumber(), aClean);

        if(FatConfig().FAT16_UseCleanShutDownBit())

            {

            TFat16Entry fatEntry;

            const TInt  KFatEntrySize=sizeof(fatEntry); //-- FAT entry size in bytes

            TPtr8       ptrFatEntry((TUint8*)&fatEntry,KFatEntrySize);

            User::LeaveIfError(LocalDrive()->Read(StartOfFatInBytes()+KFatEntrySize, KFatEntrySize, ptrFatEntry)); //read FAT16[1] entry

            const TFat16Entry tmp = fatEntry;

            if(aClean)

                fatEntry |= KFat16CleanShutDownMask;  //-- set ClnShutBit flag

            else

                fatEntry &= ~KFat16CleanShutDownMask; //-- reset ClnShutBit flag

            if(tmp != fatEntry)

                {//-- write FAT[1] entry to all available FATs

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

                    {

                    const TInt64 pos = StartOfFatInBytes()+KFatEntrySize+(FatSizeInBytes()*i);

                    User::LeaveIfError(LocalDrive()->Write(pos, ptrFatEntry)); //write FAT16[1] entry

                    }

                }

             //-- Notify the underlying media that the mount is consistent

             //   (ignoring any error for now as there's nothing we can do with it)

            (void)LocalDrive()->Finalise(aClean);

            __PRINT2(_L("#- CFatMountCB::SetVolumeCleanL() entry:  %x->%x"), tmp, fatEntry);    

            }

        else //if(FatConfig().FAT16_UseCleanShutDownBit())

            {

            __PRINT(_L("#- changing FAT16[1] is disabled in config!"));    

            }

        }// if(Is16BitFat())

    else

        {//-- must never get here

        ASSERT(0);

        }

    }

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

/**

Determine whether "VolumeClean" (ClnShutBitmask) flag is set.

@return ETrue if the volume is marked as clean and EFalse otherwise.

@leave  if is called for FAT12 or if read error occured.

*/

TBool CFatMountCB::VolumeCleanL()

    {

    TFatDriveInterface& drive = DriveInterface();

    if(Is16BitFat())

        {//-- Fat16

        TFat16Entry fatEntry;

        const TInt  KFatEntrySize=sizeof(fatEntry); //-- FAT entry size in bytes

        TPtr8       ptrFatEntry((TUint8*)&fatEntry, KFatEntrySize);

        User::LeaveIfError(drive.ReadNonCritical(StartOfFatInBytes()+KFatEntrySize, KFatEntrySize, ptrFatEntry)); //read FAT16[1] entry

        return (fatEntry & KFat16CleanShutDownMask);

        }

    else

        {//-- Fat12 doesn't support this feature, shan't get here, actually

        ASSERT(0);

        User::Leave(KErrNotSupported);

        return ETrue; //-- to satisfy the compiler

        }

    }

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

/**

Mount a Fat volume. 

@param aForceMount Flag to indicate whether mount should be forced to succeed if an error occurs

@leave KErrNoMemory,KErrNotReady,KErrCorrupt,KErrUnknown.

*/

void CFatMountCB::MountL(TBool aForceMount)

    {

    const TInt driveNo = Drive().DriveNumber();

    __PRINT2(_L("CFatMountCB::MountL() drv:%d, forceMount=%d\n"),driveNo,aForceMount);

    ASSERT(State() == ENotMounted || State() == EDismounted);

    SetState(EMounting);

    SetReadOnly(EFalse);

    User::LeaveIfError(CreateDrive(Drive().DriveNumber()));

    //-- read FAT configuration parameters from estart.txt

    iFatConfig.ReadConfig(driveNo);

    //-- initialise interface to the low-level drive access

    if(!iDriverInterface.Init(this))

        User::LeaveIfError(KErrNoMemory);    

    //-- get drive capabilities

    TLocalDriveCapsV2Buf capsBuf;

    User::LeaveIfError(LocalDrive()->Caps(capsBuf));

    iSize=capsBuf().iSize;

    iRamDrive = EFalse;

    if(capsBuf().iMediaAtt & KMediaAttVariableSize)

    {//-- this is a RAM drive

        UserSvr::UnlockRamDrive();

        iRamDrive = ETrue;

    }

    if(aForceMount)

    {//-- the state is "forcedly mounted", special case. This is an inconsistent state.

        SetState(EInit_Forced);  

        return;

    }

    //-- read and validate boot sector (sector 0)

    TFatBootSector bootSector;

    User::LeaveIfError(ReadBootSector(bootSector, iRamDrive));

    //-- print out boot sector debug information

    bootSector.PrintDebugInfo();

    //-- determine FAT type by data from boot sector. This is done by counting number of clusters, not by BPB_RootEntCnt

    iFatType=bootSector.FatType();

    ASSERT(iFatType != EInvalid); //-- this shall be checked in ReadBootSector()

    //-- values from the boot sector are checked in TFatBootSector::IsValid()

    //-- store volume UID, it can be checked on Remount

    iUniqueID = bootSector.UniqueID();

    //-- populate volume parameters with the values from boot sector. They had been validated in TFatBootSector::IsValid()

    iVolParam.Populate(bootSector); 

    //-- initialize the volume

    InitializeL(capsBuf());

    ASSERT(State()==EInit_R);

    GetVolumeLabelFromDiskL(bootSector);

    __PRINT2(_L("CFatMountCB::MountL() Completed, drv: %d, state:%d"), DriveNumber(), State());

    }

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

/**

Initialize the FAT cache and disk access

@param  aLocDrvCaps local drive capabilities

@leave KErrNoMemory,KErrNotReady,KErrCorrupt,KErrUnknown.

*/

void CFatMountCB::InitializeL(const TLocalDriveCaps& aLocDrvCaps, TBool /*aIgnoreFSInfo=EFalse*/)

    {

    __PRINT1(_L("CFatMountCB::InitializeL() drv:%d"), DriveNumber());

    ASSERT(State() == EMounting); //-- we must get here only from MountL()

    //========== Find out number of clusters on the volume

    if(iRamDrive && SectorsPerCluster()!=1)

        {// Align iFirstFreeByte to cluster boundary if internal ram drive

        const TInt sectorsPerClusterLog2=ClusterSizeLog2()-SectorSizeLog2();

        const TInt rootDirEndSector=RootDirEnd()>>SectorSizeLog2();

        const TInt alignedSector=((rootDirEndSector+SectorsPerCluster()-1)>>sectorsPerClusterLog2)<<sectorsPerClusterLog2;

        iFirstFreeByte=alignedSector<<SectorSizeLog2();

        }

    else

        {

        iFirstFreeByte=RootDirEnd();

        }

        {//-- check if volume geometry looks valid

        const TInt usableSectors=TotalSectors()-(iFirstFreeByte>>SectorSizeLog2());

        iUsableClusters=usableSectors>>(ClusterSizeLog2()-SectorSizeLog2());

        const TUint32 KMinClusters = 32; //-- absolute minimum number of clusters on the volume

        const TUint32 KMaxClusters =(TotalSectors()-FirstFatSector()-NumberOfFats()*(FatSizeInBytes()>>SectorSizeLog2())) >> (ClusterSizeLog2()-SectorSizeLog2());

        if(usableSectors <=0 || iUsableClusters < KMinClusters || iUsableClusters > KMaxClusters)

            {

            __PRINT(_L("CFatMountCB::InitializeL() Wrong number of usable cluster/sectors on the volume!"));

            User::Leave(KErrCorrupt);

            }

        }

    //========== initialise RawDisk interface

    //-- CFatMountCB parameters might have changed, e.g. after formatting. Reconstruct directory cache with new parameters

    delete iRawDisk;

    iRawDisk=CRawDisk::NewL(*this, aLocDrvCaps);

    iRawDisk->InitializeL();

    //========== create FAT table object

    delete iFatTable;

    iFatTable=CFatTable::NewL(*this, aLocDrvCaps);

    //========== create and setup leaf direcotry cache if cache limit is set bigger than one 

    const TUint32 cacheLimit = iFatConfig.LeafDirCacheSize();

    if (cacheLimit > 1)

        {

        // destroy the old leaf dir cache to avoid memory leak.

        delete iLeafDirCache;

        iLeafDirCache = CLeafDirCache::NewL(cacheLimit);

        }

    else

        {

        iLeafDirCache = NULL;

        }

    //==========  find out free clusters number on the volume

    FAT().CountFreeClustersL();

    SetState(EInit_R);  //-- the state is "Initialized, but not writen"

    //-- make a callback, telling FileServer about free space discovered.

    const TInt64 freeSpace = ((TInt64)FAT().NumberOfFreeClusters()) << ClusterSizeLog2();

    SetDiskSpaceChange(freeSpace);

    __PRINT3(_L("#- CFatMountCB::InitializeL() done. drv:%d, Free clusters:%d, 1st Free cluster:%d"),DriveNumber(), FAT().NumberOfFreeClusters(), FAT().FreeClusterHint());

    }

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

/**

Checks for end of file for all Fat types

@param aCluster Cluster to check

@return Result of test

*/

TBool CFatMountCB::IsEndOfClusterCh(TInt aCluster) const

    {

    if(Is16BitFat())

        return(aCluster>=0xFFF8 && aCluster<=0xFFFF);

    else

        return(aCluster>=0xFF8 && aCluster<=0xFFF);

    }

/**

Set a cluster to the end of cluster chain marker

@param aCluster cluster to set to end of chain marker

*/

void CFatMountCB::SetEndOfClusterCh(TInt &aCluster) const

    {

    if(Is16BitFat())

        aCluster=0xFFF8;

    else

        aCluster=0xFF8;

    }

/**

Initialize data to represent the root directory

@param anEntry Entry to initialise

*/

void CFatMountCB::InitializeRootEntry(TFatDirEntry & anEntry) const

    {

    anEntry.SetName(_L8("ROOT"));

    anEntry.SetAttributes(KEntryAttDir);

    anEntry.SetStartCluster(0);     

    }

/**

Implementation of CMountCB::FileSystemSubType(). Retrieves the sub type of Fat file system

and returns the name as a descriptor.

@param aName Name of the sub type of Fat file system

@return KErrNone if successful; KErrArgument if aName is not long enough; KErrNotReady if

        the mount is not ready.

@see CMountCB::FileSystemSubType()

*/

TInt CFatMountCB::SubType(TDes& aName) const

    {

    if(aName.MaxLength() < 5)

        return KErrArgument;

    switch (iFatType)

        {

        case EFat12:

            {

            aName = KFSSubType_FAT12;

            return KErrNone;

            }

        case EFat16:

            {

            aName = KFSSubType_FAT16;

            return KErrNone;

            }

        default:

        // case EInvalidFatType

            return KErrNotReady;

        }

    }

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

/**

    CFatMountCB control method.

    @param  aLevel  specifies the operation to perfrom on the mount

    @param  aOption specific option for the given operation

    @param  aParam  pointer to generic parameter, its meaning depends on aLevel and aOption

    @return standard error code.

*/

TInt CFatMountCB::MountControl(TInt aLevel, TInt aOption, TAny* aParam)

    {

    TInt nRes = KErrNotSupported; 

    if(aLevel == ECheckFsMountable)

        {

        return MntCtl_DoCheckFileSystemMountable();

        }

    //-- mount state query: check if is in finalised state 

    if(aLevel == EMountStateQuery && aOption == ESQ_IsMountFinalised)

        {

        TBool bFinalised;

        nRes = IsFinalised(bFinalised);

        if(nRes == KErrNone)

            {

            *((TBool*)aParam) = bFinalised;

            }

        return nRes;

        }

    //-- File System - specific queries 

    if(aLevel == EMountFsParamQuery && aOption == ESQ_GetMaxSupportedFileSize)

        {//-- this is a query to provide the max. supported file size; aParam is a pointer to TUint64 to return the value

        *(TUint64*)aParam = KMaxSupportedFatFileSize;    

        return KErrNone;

        }

    return nRes;

    }

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

/**

Reports whether the specified interface is supported - if it is,

the supplied interface object is modified to it

@param aInterfaceId     The interface of interest

@param aInterface       The interface object

@return                 KErrNone if the interface is supported, otherwise KErrNotFound 

@see CMountCB::GetInterface()

*/

TInt CFatMountCB::GetInterface(TInt aInterfaceId, TAny*& aInterface,TAny* aInput)

    {

    switch(aInterfaceId)

        {

        case (CMountCB::EFileAccessor):

            ((CMountCB::MFileAccessor*&) aInterface) = this;

            return KErrNone;

        case (CMountCB::EGetFileSystemSubType):

            aInterface = (MFileSystemSubType*) (this);

            return KErrNone;

        case (CMountCB::EGetClusterSize):

            aInterface = (MFileSystemClusterSize*) (this);

            return KErrNone;

        case CMountCB::ELocalBufferSupport:

            // RAM drives doesn't support local buffers (this results in file caching being disabled)

            if (iRamDrive) 

                return KErrNotSupported;

            else

                return LocalDrive()->LocalBufferSupport();

        case EGetProxyDrive:

            ((CProxyDrive*&)aInterface) = LocalDrive();

            return KErrNone;

        default:

            return(CMountCB::GetInterface(aInterfaceId, aInterface, aInput));

        }

    }