// Copyright (c) 2004-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:

 // e32\drivers\crashflashnor.cpp

 // 

 //

 #include <crashflashnor.h>

 void CrashFlashNor::StartTransaction()

 	{

 	}

 void CrashFlashNor::EndTransaction()

 	{

 #ifdef _CRASHLOG_COMPR

 	// Ensure any buffered data is output not all the data will be valid but 

 	// iWriteTotal should reflect this by only increasing by no of valid/buffered bytes

 	if (iWriteBufBytes)

 		{

 		DoWrite(iWriteBuf);

 		}

 #endif //_CRASHLOG_COMPR

 	}

 TUint CrashFlashNor::BytesWritten()

 	{

 	return iWriteTotal + iWriteBufBytes;

 	}

 void CrashFlashNor::SetReadPos(TUint aPos)

 	{

 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("Setting read position to %d", aPos));

 	if( (aPos%sizeof(TCFIWord)) == 0)

 		{

 		iReadPos = aPos;

 		iReadBufBytes = 0;

 		iReadBuf = 0;

 		}

 	else

 		{

 		__KTRACE_OPT(KDEBUGGER,Kern::Printf("Invalid read position requested, ignoring."));

 		}

 	}

 TInt CrashFlashNor::Initialise()

 	{

 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("CrashFlashNor::Initialise()"));

 	TInt ret = VariantInitialise();

 	if(ret)

 		{

 		__KTRACE_OPT(KDEBUGGER,Kern::Printf("CrashFlashNor::VariantInitialise() failed"));

 		return ret;

 		}

 	// start writing after the crash log header	

 #ifdef CDS_CRASH_LOGGER

 	iWritePos = 0;

 #else

 	iWritePos = KCrashLogHeaderSize;

 #endif //CDS_CRASH_LOGGER

 	SetReadPos(0);

 	iWriteTotal = 0;

 	return KErrNone;

 	}

 void CrashFlashNor::SetWritePos(TUint aPos)

 	{

 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("CrashFlashNor::SetWritePos"));

 	if( (aPos%sizeof(TCFIWord)) == 0)

 		{

 		__KTRACE_OPT(KDEBUGGER,Kern::Printf("Setting write position to %d", aPos));

 		iWritePos = aPos;

 		iWriteTotal = 0;

 		iWriteBufBytes = 0;

 		iWriteBuf = 0;

 		}

 	else

 		{

 		__KTRACE_OPT(KDEBUGGER,Kern::Printf("Invalid read position requested, ignoring."));

 		}

 	}

 void CrashFlashNor::Write(const TDesC8& aDes)

 	{	

 	if (iWritePos >= KMaxCrashLogSize)

 		{

 		__KTRACE_OPT(KDEBUGGER,Kern::Printf("Write: log limit already exceeded"));

 		return;

 		}

 	TInt size = aDes.Size();

 #ifndef _CRASHLOG_COMPR	

 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("Write: %S, size: %d",&aDes,size));

 #else	

 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("Write: writing %d bytes",size));

 #endif

 	const TUint8* ptr8 = aDes.Ptr();

 	TInt truncated = EFalse;

 #ifndef _CRASHLOG_COMPR	

 	// If this will take us too close to (or past) the end of the crash log, discard the current string

 	// and write the truncation notice instead

 	if (iWritePos+size > KMaxCrashLogSize-KCrashLogTruncated().Size())

 		{

 		__KTRACE_OPT(KDEBUGGER,Kern::Printf("Write: truncating log"));

 		size = KCrashLogTruncated().Size();

 		ptr8 = KCrashLogTruncated().Ptr();

 		truncated = ETrue;

 		}

 #else

 	// If this will take us past the end of the crash log, then truncate it

 	if (iWritePos+size > KMaxCrashLogSize)

 		{

 		// no. of bytes left in crash log sector

 		TUint tmp=KMaxCrashLogSize - iWritePos;

 		__KTRACE_OPT(KDEBUGGER,Kern::Printf("Write: truncating log, limiting output to %d bytes as iWritePos=%d",tmp,iWritePos));

 		size = tmp;

 		truncated = ETrue;

 		}

 #endif

 	const TUint8* end = ptr8 + size;

 	for(; ptr8<end; ptr8++)

 		{

 		switch(iWriteBufBytes)

 			{

 			case 0:

 				iWriteBuf |= (*ptr8);

 				break;

 #if defined(TCFI_2BYTE_WORD) || defined(TCFI_4BYTE_WORD)

 			case 1:

 				iWriteBuf |= (*ptr8)<<8;

 				break;

 #if defined(TCFI_4BYTE_WORD)

 			case 2:

 				iWriteBuf |= (*ptr8)<<16;

 				break;

 			case 3:

 				iWriteBuf |= (*ptr8)<<24;

 				break;

 #endif

 #endif

 			}

 		iWriteBufBytes++;

 		if(iWriteBufBytes == (sizeof(TCFIWord)))

 			{

 			DoWrite(iWriteBuf);

 			iWritePos+=sizeof(TCFIWord);

 			iWriteTotal+=sizeof(TCFIWord);

 			iWriteBuf = 0;

 			}

 		//equiv to iWriteBufBytes%=sizeof(TCFIWord) as long as TCFIWord is

 		//a power of 2

 		iWriteBufBytes&=sizeof(TCFIWord)-1;

 		}

 	// If the log was truncated, skip the write position ahead so we don't try to write any more

 	if (truncated)

 		{

 		iWritePos = KMaxCrashLogSize;

 		}

 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("Write: total %d, position %d", iWriteTotal, iWritePos));

 	}

 void CrashFlashNor::WriteSignature(const TDesC8& aDes)

 	{

 	if (iWriteBufBytes > 0)

 		{

 		DoWrite(iWriteBuf);

 		iWriteBufBytes=0;

 		iWriteBuf=0;

 		}

 	iWritePos = 0;

 	Write(aDes);

 	}

 void CrashFlashNor::Read(TDes8& aDes)

 	{

 	TUint8* ptr8 = const_cast<TUint8*>(aDes.Ptr());

 	const TUint8* end = ptr8 + aDes.Size();

 	for( ; ptr8<end; ptr8++)

 		{

 		switch(iReadBufBytes)

 			{

 			case 0:

 				iReadBuf = DoRead();

 				iReadPos+=sizeof(TCFIWord);

 				*ptr8 = (TUint8)(iReadBuf);

 				break;

 #if defined(TCFI_2BYTE_WORD) || defined(TCFI_4BYTE_WORD)

 			case 1:

 				*ptr8 = (TUint8)(iReadBuf>>8);

 				break;

 #if defined(TCFI_4BYTE_WORD)

 			case 2:

 				*ptr8 = (TUint8)(iReadBuf>>16);

 				break;

 			case 3:

 				*ptr8 = (TUint8)(iReadBuf>>24);

 				break;

 #endif

 #endif

 			}

 		iReadBufBytes++;

 		//equiv to iReadBufBytes%=sizeof(TCFIWord) as long as TCFIWord is

 		//a power of 2

 		iReadBufBytes&=sizeof(TCFIWord)-1;

 		}

 	}

 void CrashFlashNor::EraseLogArea()

 	{

 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("Erasing crash log area..."));

 	for(TUint erased = 0; erased < KMaxCrashLogSize; erased += iEraseBlockSize)

 		{		

 		DoEraseBlock(erased);

 		}

 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("Finished erasing area for crash log."));	

 	}

 void CrashFlashNor::EraseFlashBlock(TUint aBlock)

 	{

 	__KTRACE_OPT(KDEBUGGER,Kern::Printf("CrashFlashNor::Erasing crash flash block offset [0x%X]", aBlock));

 	if(aBlock%iEraseBlockSize != 0 || aBlock > KMaxCrashLogSize)

 		{

 		__KTRACE_OPT(KDEBUGGER,Kern::Printf("Invalid Block Address - Not deleting [0x%X]", aBlock));

 		return;

 		}

 	DoEraseBlock(aBlock);

 	}

 #ifdef _CRASHLOG_COMPR	

 TUint CrashFlashNor::GetOutputLimit()

 	{

 	return KMaxCrashLogSize-KCrashLogHeaderSize;

 	}

 TUint CrashFlashNor::GetLogOffset(void)

 	{

 	return 0;

 	}

 #endif