// 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:

// e32test\pccd\t_mmcdrv.cpp

// Test the MultiMediaCard (MMC) media driver

// Spare Test case Numbers 0513-0519

// 

//

#include "../mmu/d_sharedchunk.h"

#include <e32test.h>

#include <e32svr.h>

#include <e32hal.h>

#include <e32uid.h>

#include <f32fsys.h>

#include <e32def.h>

#include <e32def_private.h>

const TInt KDiskSectorSize=512;

const TInt KDiskSectorShift=9;

const TUint KDiskSectorMask=0xFFFFFE00;

const TInt KSectBufSizeInSectors=8;

const TInt KSectBufSizeInBytes=(KSectBufSizeInSectors<<KDiskSectorShift);

const TInt KRdWrBufLen=(KSectBufSizeInBytes+KDiskSectorSize); // 4.5K - exceeds driver local buffer size

const TInt KShortFormatInSectors=1;

const TInt KShortFormatInBytes=(KShortFormatInSectors<<KDiskSectorShift);

const TInt KLongFormatInSectors=KSectBufSizeInSectors+1;	// 4.5K - exceeds driver local buffer size

const TInt KLongFormatInBytes=(KLongFormatInSectors<<KDiskSectorShift);

const TInt KVeryLongSectBufSizeInSectors=4096;												// ..2M

const TInt KVeryLongSectBufSizeInBytes=(KVeryLongSectBufSizeInSectors<<KDiskSectorShift);	//

const TInt KVeryLongRdWrBufLen=(KVeryLongSectBufSizeInBytes+KDiskSectorSize);				// 2M + 0.5K

const TInt KHeapSize=0x4000;

const TInt64 KDefaultRandSeed = MAKE_TINT64(0x501a501a, 0x501a501a);

#define TEST_DOOR_CLOSE 	0					// see comment in E32Main()

class TMMCDrive : public TBusLocalDrive

	{

public:

	enum TTestMode

		{

		ETestPartition,

		ETestWholeMedia,

		ETestSharedMemory,

		ETestSharedMemoryCache,

		ETestSharedMemoryFrag,

		ETestSharedMemoryFragCache,

		EMaxTestModes

		};

public:

	TMMCDrive();

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

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

	TInt SetTestMode(TTestMode aTestMode);

	TTestMode TestMode();

	void SetSize(TInt64 aDriveSize, TInt64 aMediaSize);

	TInt64 Size();

private:

	TTestMode iTestMode;

	TInt64 iDriveSize;

	TInt64 iMediaSize;

	};

// Serial numbers for 'special case' test cards (ie - those with known problems)

class TKnownCardTypes

	{

public:

	enum TCardType

		{

		EStandardCard = 0,

		EBuffalloMiniSD_32M_ERASE,

		EBuffalloMiniSD_64M_ERASE,

		EBuffalloMiniSD_128M_ERASE,

		EBuffalloMiniSD_256M_ERASE,

		EBuffalloMiniSD_512M_ERASE,

		EBuffalloMiniSD_512M,

		EIntegralHSSD_2G,

		ESanDiskMmcMobile_1GB

		};

	TKnownCardTypes(TCardType aCardType, const TText8* aSerialNumber) 

		: iCardType(aCardType), iSerialNumber(aSerialNumber) {};

	TCardType iCardType;

	const TText8* iSerialNumber;

	};

LOCAL_D TKnownCardTypes KnownCardTypes[] = 	

	{

	//** The Following Buffalo Cards all have a known Mis-Implementation

	// When requesting Erase the area to be erase is specified in terms of a start (CMD32) and stop (CMD33) blocks

	// Specification states that CMD33 refers to the end block in terms of the first byte of that block

	// the Buffallo implementation requires that the last byte of the block is specified.

	TKnownCardTypes(TKnownCardTypes::EBuffalloMiniSD_32M_ERASE,  _S8("936300c70e150d003630333046445004")),

	TKnownCardTypes(TKnownCardTypes::EBuffalloMiniSD_64M_ERASE,  _S8("d96600456d120a003732343046445004")),

	TKnownCardTypes(TKnownCardTypes::EBuffalloMiniSD_128M_ERASE, _S8("f964000d13150c003630333046445004")),

	TKnownCardTypes(TKnownCardTypes::EBuffalloMiniSD_256M_ERASE, _S8("4d66004c68120a003732343046445004")),

	TKnownCardTypes(TKnownCardTypes::EBuffalloMiniSD_512M_ERASE, _S8("db6500824e0010013236333243454228")),

	TKnownCardTypes(TKnownCardTypes::EBuffalloMiniSD_32M_ERASE,  _S8("df6400e60d150d003630333046445004")),

	TKnownCardTypes(TKnownCardTypes::EBuffalloMiniSD_64M_ERASE,  _S8("296600386d120a003732343046445004")),

	TKnownCardTypes(TKnownCardTypes::EBuffalloMiniSD_128M_ERASE, _S8("b16400f512150c003630333046445004")),

	TKnownCardTypes(TKnownCardTypes::EBuffalloMiniSD_256M_ERASE, _S8("435600cc390000000000004453474b13")),

	TKnownCardTypes(TKnownCardTypes::EBuffalloMiniSD_512M_ERASE, _S8("ed6300de700000000000004453474b13")),

	//***********************************************************************************************//

	TKnownCardTypes(TKnownCardTypes::EBuffalloMiniSD_512M, _S8("0d56004e2d0000000000004453474b13")),

	TKnownCardTypes(TKnownCardTypes::EIntegralHSSD_2G,     _S8("37570058073099114732304453000027")),

	TKnownCardTypes(TKnownCardTypes::ESanDiskMmcMobile_1GB,_S8("956a1c00001810303030303030000015"))

	};

LOCAL_D RTest test(_L("T_MMCDRV"));

LOCAL_D RTest nTest(_L("This thread doesn't disconnect"));

LOCAL_D TBool ChangeFlag;

LOCAL_D TBool SecThreadChangeFlag;

LOCAL_D TPtr8 wrBuf(NULL, KVeryLongRdWrBufLen);

LOCAL_D TPtr8 rdBuf(NULL, KVeryLongRdWrBufLen);

LOCAL_D HBufC8* wrBufH = NULL;

LOCAL_D HBufC8* rdBufH = NULL;

LOCAL_D TInt DriveNumber = -1; // Local Drive number

LOCAL_D TInt RFsDNum = -1;	// File Server Drive number

LOCAL_D TMMCDrive TheMmcDrive;

LOCAL_D TLocalDriveCapsV5Buf DriveCaps;

LOCAL_D TKnownCardTypes::TCardType CardType;

LOCAL_D TBool IsReadOnly;

LOCAL_D RSharedChunkLdd Ldd;

LOCAL_D RChunk TheChunk;

LOCAL_D TInt PageSize;

const TUint ChunkSize    = 0x201000;	//2MB+4096bytes > than largest transfer

const TInt	 KSingSectorNo=1;

const TInt64 KTwoGigbytes = 0x80000000;

TBool mediaChangeSupported=EFalse; // ???

TBool ManualMode=EFalse;

// Wrappers for the test asserts

GLREF_C void TestIfError( TInt aValue, TInt aLine, const TText* aFile );

GLREF_C void TestIfErrorMsg( TInt aValue, TInt aLine, const TText* aFile, const TDesC& aMessageOnError );

GLREF_C void TestEqual( TInt aValue, TInt aExpected, TInt aLine, const TText* aFile );

GLREF_C void TestEqualMsg( TInt aValue, TInt aExpected, TInt aLine, const TText* aFile, const TDesC& aMessageOnError );

GLREF_C void TestEitherEqual( TInt aValue, TInt aExpected1, TInt aExpected2, TInt aLine, const TText* aFile );

GLREF_C void TestRange( TInt aValue, TInt aMin, TInt Max, TInt aLine, const TText* aFile );

#define TEST_FOR_ERROR2( r, l, f )	TestIfError( r, l, _S(f) )

#define TEST_FOR_ERROR_ERRMSG2( r, l, f, m )	TestIfErrorMsg( r, l, _S(f), m )

#define TEST_FOR_VALUE2( r, e, l, f )	TestEqual( r, e, l, _S(f) )

#define TEST_FOR_VALUE_ERRMSG2( r, e, l, f, m )	TestEqualMsg( r, e, l, _S(f), m )

#define TEST_FOR_EITHER_VALUE2( r, e1, e2, l, f )	TestEitherEqual( r, e1, e2, l, _S(f) )

#define TEST_FOR_RANGE2( r, min, max, l, f )	TestRange( r, min, max, l, _S(f) )

#define TEST_FOR_ERROR( r )	TEST_FOR_ERROR2( r, __LINE__, __FILE__ )

#define TEST_FOR_ERROR_ERRMSG( r, m )	TEST_FOR_ERRORMSG2( r, __LINE__, __FILE__, m )

#define TEST_FOR_VALUE( r, expected )	TEST_FOR_VALUE2( r, expected, __LINE__, __FILE__ )

#define TEST_FOR_VALUE_ERRMSG( r, expected, m )	TEST_FOR_VALUE_ERRMSG2( r, expected, __LINE__, __FILE__, m )

#define TEST_FOR_EITHER_VALUE( r, expected1, expected2 )	TEST_FOR_EITHER_VALUE2( r, expected1, expected2, __LINE__, __FILE__ )

#define TEST_FOR_RANGE( r, min, max )	TEST_FOR_RANGE2( r, min, max, __LINE__, __FILE__ )

GLDEF_C void TestIfError( TInt aValue, TInt aLine, const TText* aFile )

	{

	if( aValue < 0 )

		{

		_LIT( KErrorTestFailMsg, "ERROR %d\n\r" );

		test.Printf( KErrorTestFailMsg, aValue );

		test.operator()( EFalse, aLine, (const TText*)(aFile) );

		}

	}

GLDEF_C void TestIfErrorMsg( TInt aValue, TInt aLine, const TText* aFile, const TDesC& aMessageOnError )

	{

	if( aValue < 0 )

		{

		_LIT( KErrorTestFailMsg, "ERROR %d %S\n\r" );

		test.Printf( KErrorTestFailMsg, aValue, &aMessageOnError );

		test.operator()( EFalse, aLine, (const TText*)(aFile) );

		}

	}

GLDEF_C void TestEqual( TInt aValue, TInt aExpected, TInt aLine, const TText* aFile )

	{

	if( aExpected != aValue )

		{

		_LIT( KEqualTestFailMsg, "ERROR %d expected %d\n\r" );

		test.Printf( KEqualTestFailMsg, aValue, aExpected );

		test.operator()( EFalse, aLine, (const TText*)(aFile) );

		}

	}

GLDEF_C void TestEqualMsg( TInt aValue, TInt aExpected, TInt aLine, const TText* aFile, const TDesC& aMessageOnError )

	{

	if( aExpected != aValue )

		{

		_LIT( KEqualTestFailMsg, "ERROR %d expected %d %S\n\r" );

		test.Printf( KEqualTestFailMsg, aValue, aExpected, &aMessageOnError );

		test.operator()( EFalse, aLine, (const TText*)(aFile) );

		}

	}

GLDEF_C void TestEitherEqual( TInt aValue, TInt aExpected1, TInt aExpected2, TInt aLine, const TText* aFile )

	{

	if( (aExpected1 != aValue) && (aExpected2 != aValue) )

		{

		_LIT( KEqualTestFailMsg, "ERROR %d expected %d or %d\n\r" );

		test.Printf( KEqualTestFailMsg, aValue, aExpected1, aExpected2 );

		test.operator()( EFalse, aLine, (const TText*)(aFile) );

		}

	}

GLDEF_C void TestRange( TInt aValue, TInt aMin, TInt aMax, TInt aLine, const TText* aFile )

	{

	if( (aValue < aMin) || (aValue > aMax) )

		{

		_LIT( KRangeTestFailMsg, "ERROR 0x%x expected 0x%x..0x%x\n\r" );

		test.Printf( KRangeTestFailMsg, aValue, aMin, aMax );

		test.operator()( EFalse, aLine, (const TText*)(aFile) );

		}

	}

////

TMMCDrive::TMMCDrive()

  : iTestMode(ETestPartition),

    iDriveSize(0),

    iMediaSize(0)

	{

	}

TInt TMMCDrive::Read(TInt64 aPos,TInt aLength,TDes8& aTrg)

	{

	if(iTestMode == ETestWholeMedia)

		{

		return TBusLocalDrive::Read(aPos, aLength, &aTrg, KLocalMessageHandle, 0, RLocalDrive::ELocDrvWholeMedia);

		}

	else if(iTestMode != ETestPartition && aLength <= (TInt)ChunkSize)

		{

		TPtr8 wholeBufPtr(TheChunk.Base(),aLength);

		TInt r = TBusLocalDrive::Read(aPos, aLength, wholeBufPtr);

		aTrg.Copy(wholeBufPtr);

		return r;

		}

	return TBusLocalDrive::Read(aPos, aLength, aTrg);

	}

TInt TMMCDrive::Write(TInt64 aPos,const TDesC8& aSrc)

	{

	if(iTestMode == ETestWholeMedia)

		{

		return TBusLocalDrive::Write(aPos, aSrc.Length(), &aSrc, KLocalMessageHandle, 0, RLocalDrive::ELocDrvWholeMedia);

		}

	else if(iTestMode != ETestPartition && aSrc.Length() <= (TInt)ChunkSize)

		{		

		TPtr8 wholeBufPtr(TheChunk.Base(),aSrc.Length());

		wholeBufPtr.Copy(aSrc);

		TInt r = TBusLocalDrive::Write(aPos, wholeBufPtr);

		return r;

		}

	return TBusLocalDrive::Write(aPos, aSrc);

	}

TInt TMMCDrive::SetTestMode(TTestMode aTestMode)

	{

	switch (aTestMode) 

		{

		case ETestWholeMedia   : 		test.Printf(_L("\nTesting Whole Media\n")); break;

		case ETestPartition    : 		test.Printf(_L("\nTesting Partition\n")); break;

		case ETestSharedMemory : 		test.Printf(_L("\nTesting Shared Memory\n")); break;

		case ETestSharedMemoryCache : 	test.Printf(_L("\nTesting Shared Memory (Caching)\n")); break;

		case ETestSharedMemoryFrag : 	test.Printf(_L("\nTesting Shared Memory (Fragmented)\n")); break;

		default :           			test.Printf(_L("\nTesting Shared Memory (Fragmented/Caching)\n")); break;

		}

	if(aTestMode == ETestWholeMedia && iMediaSize == 0)

		{

		test.Printf(_L("...not supported"));

		return KErrNotSupported;

		}

	iTestMode = aTestMode;

	return KErrNone;

	}

TMMCDrive::TTestMode TMMCDrive::TestMode()

	{

	return iTestMode;

	}

void TMMCDrive::SetSize(TInt64 aDriveSize, TInt64 aMediaSize)

	{

	iDriveSize = aDriveSize;

	iMediaSize = aMediaSize;

	}

TInt64 TMMCDrive::Size()

	{

	switch (iTestMode)

		{

		case ETestWholeMedia : return iMediaSize;

		default 			 : return iDriveSize;

		}

	}

//////

GLDEF_C void DumpBuffer( const TDesC8& aBuffer )

	/**

	 * Dump the content of aBuffer in hex

	 */

	{

	static const TText hextab[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 

										'A', 'B', 'C', 'D', 'E', 'F' };

	const TInt KBytesPerLine = 32;

	const TInt KCharsPerLine = KBytesPerLine * 2;

	TInt remaining = aBuffer.Length();

	TUint8* pSrc = const_cast<TUint8*>(aBuffer.Ptr());

	TBuf<KCharsPerLine> line;

	line.SetLength( KCharsPerLine );	// don't need to print trailing space

	TInt bytesPerLine = KBytesPerLine;

	TInt lineOffs = 0;

	while( remaining )

		{

		if( remaining < KBytesPerLine )

			{

			bytesPerLine = remaining;

			line.SetLength( (bytesPerLine*2) );

			}

		TUint16* pDest = const_cast<TUint16*>(line.Ptr());

		remaining -= bytesPerLine;

		for( TInt i = bytesPerLine; i > 0; --i )

			{

			TUint8 c = *pSrc++;

			*pDest++ = hextab[c >> 4];

			*pDest++ = hextab[c & 0xF];

			}

		_LIT( KFmt, "%06x: %S\n\r" );

		test.Printf( KFmt, lineOffs, &line );

		lineOffs += bytesPerLine;

		}

	}

GLDEF_C TBool CompareBuffers( const TDesC8& aBuf1, const TDesC8& aBuf2 )

	{

	TInt count = 32;

	if (aBuf1.Length() < count) 

		count = aBuf1.Length();

	for (TInt i = 0; i < (aBuf1.Length()-count); i+= count)

		{

		if( aBuf1.Mid(i,count).Compare(aBuf2.Mid(i,count)) != 0)

			{

			// now need to find where mismatch ends

			TInt j =i;

			for (; j <= (aBuf1.Length()-count); j+= count)

				{

				if( aBuf1.Mid(j,count).Compare(aBuf2.Mid(j,count)) == 0) break;

				}

			test.Printf(_L("buf1 len: %d, buf2 len: %d\n"),aBuf1.Length(),aBuf2.Length());

			test.Printf( _L("Buffer mismatch @%d to %d (%d Bytes)\n\r"),i,j, (j-i) );

			test.Printf( _L("buffer 1 ------------------\n\r") );

			DumpBuffer( aBuf1.Mid(i,(j-i)) );

			test.Printf( _L("buffer 2 ------------------\n\r") );

			DumpBuffer( aBuf2.Mid(i,(j-i)) );

			test.Printf(_L("buf1 len: %d, buf2 len: %d\n"),aBuf1.Length(),aBuf2.Length());

			test.Printf( _L("Buffer mismatch @%d to %d (%d Bytes)\n\r"),i,j, (j-i) );

			return EFalse;

			}

		}

	return ETrue;

	}

void singleSectorRdWrTest(TInt aSectorOffset,TInt aLen)

//

// Perform a write / read test on a single sector (KSingSectorNo). Verify that the

// write / read back is successful and that the rest of the sector is unchanged.

//

	{

	TBuf8<KDiskSectorSize> saveBuf;

	test.Start(_L("Single sector write/read test"));

	test(aSectorOffset+aLen<=KDiskSectorSize);

	// Now save state of sector before we write to it

	TInt secStart=(KSingSectorNo<<KDiskSectorShift);

	test(TheMmcDrive.Read(secStart,KDiskSectorSize,saveBuf)==KErrNone);

	// Write zero's to another sector altogether (to ensure drivers 

	// local buffer hasn't already got test pattern we expect).

	wrBuf.Fill(0,KDiskSectorSize);

	test(TheMmcDrive.Write((KSingSectorNo+4)<<KDiskSectorShift,wrBuf)==KErrNone);

	// Write / read back sector in question

	wrBuf.SetLength(aLen);

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

		wrBuf[i]=(TUint8)(0xFF-i);

	test(TheMmcDrive.Write((secStart+aSectorOffset),wrBuf)==KErrNone);

	rdBuf.Fill(0,aLen);

	test(TheMmcDrive.Read((secStart+aSectorOffset),aLen,rdBuf)==KErrNone);

	test(CompareBuffers(rdBuf, wrBuf));

	//test(rdBuf.Compare(wrBuf)==0);

	// Now check the rest of the sector is unchanged

	rdBuf.Fill(0,KDiskSectorSize);

	test(TheMmcDrive.Read(secStart,KDiskSectorSize,rdBuf)==KErrNone);

	saveBuf.Replace(aSectorOffset,aLen,wrBuf);

	test(CompareBuffers(rdBuf, saveBuf));

	test.End();

	}

const TInt KMultSectorNo=2; 

void MultipleSectorRdWrTestMB(TInt aFirstSectorOffset, TInt aLen, TBool aWrMB, TBool aRdMB)

//

// Perform a write / read test over multiple sectors (starting within sector KMultSectorNo).

// Verify that the write / read back is successful and that the remainder of the first and

// last sectors are not affected.

//

	{

	TBuf8<KDiskSectorSize> saveBuf1;

	TBuf8<KDiskSectorSize> saveBuf2;

	test.Printf(_L("   MBW[%d] : MBR[%d]\n\r"), aWrMB, aRdMB);

	test(aFirstSectorOffset<KDiskSectorSize&&aLen<=KVeryLongRdWrBufLen);

	// If not starting on sector boundary then save 1st sector to check rest of 1st sector is unchanged

	TInt startSecPos=(KMultSectorNo<<KDiskSectorShift);

	if (aFirstSectorOffset!=0)

		test(TheMmcDrive.Read(startSecPos,KDiskSectorSize,saveBuf1)==KErrNone);

	// If not ending on sector boundary then save last sector to check rest of last sector is unchanged

	TInt endOffset=(aFirstSectorOffset+aLen)&(~KDiskSectorMask);

	TInt endSecPos=((startSecPos+aFirstSectorOffset+aLen)&KDiskSectorMask);

	if (endOffset)

		{

		test(TheMmcDrive.Read(endSecPos,KDiskSectorSize,saveBuf2)==KErrNone);

		}

	// Write zero's to another sector altogether (to ensure drivers 

	// local buffer hasn't already got test pattern we expect).

	wrBuf.Fill(0,KSectBufSizeInBytes);

	test(TheMmcDrive.Write((endSecPos+(2*KDiskSectorSize)),wrBuf)==KErrNone);

	TInt i;

	wrBuf.SetLength(aLen);

	for (i=0;i<aLen;i++)

		{

		wrBuf[i]=(TUint8)(0xFF-i);

		}

	if(aWrMB)

		{

		test(TheMmcDrive.Write((startSecPos+aFirstSectorOffset),wrBuf)==KErrNone);

		}

	else

		{

		for (i=0;i<aLen;i+=512)

			{

			TInt thisLen = (aLen-i) < 512 ? (aLen-i) : 512;

			TPtrC8 sectorWr(wrBuf.Mid(i, thisLen).Ptr(), thisLen);

			test(TheMmcDrive.Write((startSecPos+aFirstSectorOffset+i), sectorWr)==KErrNone);

			}

		}

	rdBuf.Fill(0,aLen);

	rdBuf.SetLength(aLen);

	if(aRdMB)

		{

		test(TheMmcDrive.Read((startSecPos+aFirstSectorOffset),aLen,rdBuf) == KErrNone);

		}

	else

		{

		for (i=0;i<aLen;i+=512)

			{

			TInt thisLen = (aLen-i) < 512 ? (aLen-i) : 512;

			TPtr8 sectorRd(((TUint8*)(rdBuf.Ptr()))+i, thisLen, thisLen);

			test(TheMmcDrive.Read((startSecPos+aFirstSectorOffset+i), thisLen, sectorRd) == KErrNone);

			}

		}

	test(CompareBuffers(rdBuf, wrBuf));

	// Check rest of first sector involved is unchanged (if offset specified)

	if (aFirstSectorOffset!=0)

		{

		rdBuf.Fill(0,KDiskSectorSize);

		test(TheMmcDrive.Read(startSecPos,KDiskSectorSize,rdBuf)==KErrNone);

		wrBuf.SetLength(KDiskSectorSize-aFirstSectorOffset);

		saveBuf1.Replace(aFirstSectorOffset,(KDiskSectorSize-aFirstSectorOffset),wrBuf);

		test(rdBuf.Compare(saveBuf1)==0);