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

#include "sl_std.h"
#include "sl_scandrv.h"

const TInt KMaxBufferSize=8192;


TBool CCheckFatTable::IsEof16Bit(TInt aCluster) const
{
    return(aCluster>=0xFFF8 && aCluster<=0xFFFF);
}

TBool CCheckFatTable::IsEof12Bit(TInt aCluster) const
{
    return(aCluster>=0xFF8 && aCluster<=0xFFF);
}

TInt CCheckFatTable::MaxFatIndex() const
    {   
	__ASSERT_DEBUG((TUint)iMaxFatIndex>=KFatFirstSearchCluster, Fault(ECheckFatIndexZero));
	return(iMaxFatIndex);
	}


CCheckFatTable* CCheckFatTable::NewL(CFatMountCB* aOwner)
//
// Create a CCheckFatTable
//
	{
	CCheckFatTable* fatTable;
	fatTable=new(ELeave) CCheckFatTable(aOwner);
	return(fatTable);
	}


CCheckFatTable::CCheckFatTable(CFatMountCB* aOwner)
//
// Constructor
//
	{
	iOwner=aOwner;
	}

CCheckFatTable::~CCheckFatTable()
//
// Destructor
//
	{
	User::Free(iCheckFat);
	}


void CCheckFatTable::InitializeL()
//
// Initialize the check fat table
//
	{
	__PRINT(_L("CCheckFatTable::InitializeL"));

	TInt fatSize=iOwner->FatSizeInBytes();

	if(iCheckFat==NULL)
		iCheckFat=(TUint8*)User::AllocL(fatSize);
	else
		iCheckFat=(TUint8*)User::ReAllocL(iCheckFat,fatSize);
	Mem::FillZ(iCheckFat,fatSize);
	iMaxFatIndex=iOwner->UsableClusters()+1;
	if(iOwner->Is16BitFat())
		{
		__ASSERT_ALWAYS(iMaxFatIndex>0 && iMaxFatIndex<EOF_16Bit && !IsEof16Bit(iMaxFatIndex),User::Leave(KErrCorrupt));
		}
	else
		{
		__ASSERT_ALWAYS(iMaxFatIndex>0 && iMaxFatIndex<EOF_12Bit && !IsEof12Bit(iMaxFatIndex),User::Leave(KErrCorrupt));
		}
	WriteMediaDescriptor();
	
	__PRINT2(_L("fatSize=%d,iCheckFat=0x%x"),fatSize,iCheckFat);
	}


/**
@return ETrue if found errors in FAT 
*/
TBool CCheckFatTable::FlushL()
//
// Flush iCheckFat to the media, comparing each sector to corresponding 
// sector in all fats (cf.CFixedCache::FlushL)
//	
	{
	TBool bErrFound = EFalse;
    
    __PRINT(_L("CCheckFatTable::FlushL()"));
	HBufC8* hBuf=HBufC8::New(KMaxBufferSize);
	if (hBuf==NULL)
		hBuf=HBufC8::NewL(KMaxBufferSize/4);
	CleanupStack::PushL(hBuf);

	TUint8* ptr=(TUint8*)hBuf->Ptr();
	TInt maxSize=hBuf->Des().MaxSize();

	TPtr8 fatBuffer(ptr,maxSize);
	TInt fatSize=iOwner->FatSizeInBytes();
	TInt remainder=fatSize;
	TInt offset=iOwner->StartOfFatInBytes();
	TUint8* dataPtr=iCheckFat;
    TFatDriveInterface& drive = iOwner->DriveInterface();
	TInt fatNumber=iOwner->NumberOfFats();
	
	while(remainder)
		{
		TInt s=Min(fatBuffer.MaxSize(),remainder);
		TInt fatCount=fatNumber;
		TInt fatPos=0;
		while(fatCount)
			{
			TInt fatOffset=offset+fatPos;
			User::LeaveIfError(drive.ReadCritical(fatOffset,s,fatBuffer));
			TInt rem2=s;
			TInt offset2=fatOffset;
			TUint8* dataPtr2=dataPtr;
			TInt bufOffset=0;
			while(rem2)
				{
				TInt s2=Min(rem2,512);
				TInt r=Mem::Compare(dataPtr2,s2,fatBuffer.Ptr()+bufOffset,s2);
				if (r!=0)
					{
					bErrFound = ETrue;
                    TPtrC8 dataBuf(dataPtr2,s2);
					User::LeaveIfError(drive.WriteCritical(offset2,dataBuf));
					}
				rem2-=s2;
				offset2+=s2;
				dataPtr2+=s2;
				bufOffset+=s2;
				}
			--fatCount;
			fatPos+=fatSize;
			}
		offset+=s;
		dataPtr+=s;
		remainder-=s;
		}

	CleanupStack::PopAndDestroy();

    return bErrFound;
	}

void CCheckFatTable::WriteMediaDescriptor()
//
// Write media descriptor to first byte and 0xFF to
// remaining bytes of first two entries
//
	{
	__PRINT(_L("CCheckFatTable::WriteMediaDescriptor"));
	iCheckFat[0]=KBootSectorMediaDescriptor;
	iCheckFat[1]=0xFF;
	iCheckFat[2]=0xFF;
	if (iOwner->Is16BitFat())
		iCheckFat[3]=0xFF;
	}

TInt CCheckFatTable::PosInBytes(TInt aFatIndex) const
//
// Return number of bytes into the fat
//
	{
	TInt fatPosInBytes;
	if (iOwner->Is16BitFat())
		fatPosInBytes=aFatIndex<<1;
	else
		// this is used since 8-bit access will be used for reading/writing
		fatPosInBytes=(aFatIndex*3>>1);
	return(fatPosInBytes);
	}


TInt CCheckFatTable::PosInIndex(TInt aBytePos) const
//
// Return index given byte position in fat
//
	{
	if(iOwner->Is16BitFat())
		return(aBytePos>>1);
	else
		return((aBytePos<<1)/3);
	}


TInt CCheckFatTable::ReadL(TInt aFatIndex) const
//
// Read a value from the check fat
//
	{
	__ASSERT_ALWAYS((TUint32)aFatIndex >=KFatFirstSearchCluster && aFatIndex<=MaxFatIndex(),User::Leave(KErrCorrupt));
	TUint clusterVal;
	if(iOwner->Is16BitFat())
		clusterVal=*(TUint16*)(iCheckFat+PosInBytes(aFatIndex));
	else
		{
		TUint8* pCluster=iCheckFat+PosInBytes(aFatIndex);
		clusterVal=pCluster[0]|(pCluster[1]<<8);
		TBool oddCluster=(aFatIndex)&1;
		if(oddCluster)
			clusterVal>>=4;
		clusterVal&=0xFFF;
		}
	return(clusterVal);
	}


void CCheckFatTable::WriteL(TInt aFatIndex,TInt aValue)
//
// Write a value to the check fat
//
	{
	if(iOwner->Is16BitFat())
		__ASSERT_ALWAYS((TUint32)aFatIndex>=KFatFirstSearchCluster && aFatIndex<=MaxFatIndex() && aValue>=0 && aValue<=0xFFFF,User::Leave(KErrCorrupt));
	else
		__ASSERT_ALWAYS((TUint32)aFatIndex>=KFatFirstSearchCluster && aFatIndex<=MaxFatIndex() && aValue>=0 && aValue<=0xFFF,User::Leave(KErrCorrupt));
	TUint8* p=(TUint8*)(iCheckFat+PosInBytes(aFatIndex));
	if (iOwner->Is16BitFat())
		{ 
		*(TUint16*)p=(TUint16)aValue;
		return;
		}
	TUint8 mask=0x0F;
	TBool odd=(aFatIndex)&1;
	TUint8 fatVal;
	if(odd)
		{
		mask<<=4;
		aValue<<=4;
		fatVal=p[0];
		fatVal&=~mask;
		fatVal|=(TUint8)(aValue&0xFF);
		p[0]=fatVal;
		p[1]=(TUint8)(aValue>>8);
		}
	else
		{
		p[0]=(TUint8)(aValue&0xFF);
		fatVal=p[1];
		fatVal&=~mask;
		fatVal|=(TUint8)(aValue>>8);
		p[1]=fatVal;
		}
	return;
	}
	

TBool CCheckFatTable::GetNextClusterL(TInt& aCluster) const
//
// Get the next cluster in the chain from the check fat.
//
    {
	__PRINT(_L("CCheckFatTable::GetNextClusterL"));
	TBool ret;
	TInt nextCluster=ReadL(aCluster);
	if (iOwner->Is16BitFat())
		ret=!IsEof16Bit(nextCluster);
	else
		ret=!IsEof12Bit(nextCluster);
	if (ret)
		aCluster=nextCluster;
	return(ret);
	}

void CCheckFatTable::WriteFatEntryEofFL(TInt aCluster)
//
// Write EOF to aCluster
//
	{
	__PRINT(_L("CCheckFatTable::WriteFatEntryEofF"));
	if (iOwner->Is16BitFat())
		WriteL(aCluster,EOF_16Bit);
	else
		WriteL(aCluster,EOF_12Bit);
	}