Fix for bug 3322 - Non-portable case-sensitivity and path-delimiter fluff in e32test build
// 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\lffs\t_lfsdrv2.cpp
// Test the LFFS Flash media driver
//
//
#include <e32test.h>
#include <e32svr.h>
#include <e32hal.h>
#include <e32uid.h>
#include <hal.h>
#include "u32std.h"
#include "../misc/prbs.h"
_LIT(KTestName,"T_LFSDRV");
_LIT(KMediaDriverName,"MEDLFS");
_LIT(KDot,".");
_LIT(KSemiColon,";");
RTest test(KTestName);
TBusLocalDrive Drive;
TInt DriveNumber;
TLocalDriveCapsV7 DriveCaps; // Required for M18 devices
TBool ChangedFlag;
TUint32 EbSz;
TUint32 Size;
const TInt KBufferSize=4096;
const TInt KBigBufferSize=4096*4;
TUint8 Buffer[KBigBufferSize];
#ifdef _DEBUG
/***************************************************
* ControlIO command types - for debug builds, only
***************************************************/
enum TCtrlIoTypes
{
ECtrlIoRww=0,
ECtrlIoTimeout=1
};
// Used only for the ControlIO tests
#define TYAX_PARTITION_SIZE 0x00200000 // Partition size for TYAX is 1MB; 2 devices in parallel
#endif
/******************************************************************************
* Extra thread for background erase
******************************************************************************/
struct SEraseInfo
{
TInt iFirstBlock;
TInt iNumBlocks;
};
volatile TInt Block;
TInt EraseThreadFn(TAny* aPtr)
{
SEraseInfo& e=*(SEraseInfo*)aPtr;
TInt r=KErrNone;
for (Block=e.iFirstBlock; Block<e.iFirstBlock+e.iNumBlocks; ++Block)
{
TInt64 pos64 = MAKE_TINT64(0, Block*EbSz);
r=Drive.Format(pos64,EbSz);
if (r!=KErrNone)
return r;
}
return KErrNone;
}
SEraseInfo EraseInfo;
RThread EraseThread;
TRequestStatus EraseStatus;
const TInt KHeapSize=0x4000;
_LIT(KEraseThreadName,"Eraser");
TInt StartAsyncErase(TInt aFirstBlock, TInt aNumBlocks)
{
EraseInfo.iFirstBlock=aFirstBlock;
EraseInfo.iNumBlocks=aNumBlocks;
TInt r=EraseThread.Create(KEraseThreadName,EraseThreadFn,0x4000,KHeapSize,KHeapSize,&EraseInfo,EOwnerThread);
if (r!=KErrNone)
return r;
EraseThread.Logon(EraseStatus);
EraseThread.Resume();
return KErrNone;
}
TInt WaitForAsyncErase()
{
User::WaitForRequest(EraseStatus);
TInt exitType=EraseThread.ExitType();
TInt exitReason=EraseThread.ExitReason();
TBuf<16> exitCat=EraseThread.ExitCategory();
if((exitType!= EExitKill)||(exitReason!=KErrNone))
{
test.Printf(_L("Async erase error: %d, block %d\n"),EraseStatus.Int(),Block);
test.Printf(_L("Thread exit reason: %d,%d,%S\n"),exitType,exitReason,&exitCat);
test(0);
}
EraseThread.Close();
TUint32 pos=EraseInfo.iFirstBlock*EbSz;
TUint32 endpos=pos+EraseInfo.iNumBlocks*EbSz;
test.Printf(_L("\nAsync erase completed; verifying...\n"));
for (; pos<endpos; pos+=KBufferSize)
{
TInt64 pos64 = MAKE_TINT64(0, pos);
TPtr8 ptr(Buffer,0,KBufferSize);
Mem::FillZ(Buffer,KBufferSize);
TInt r=Drive.Read(pos64,KBufferSize,ptr);
test(r==KErrNone);
test(ptr.Length()==KBufferSize);
const TUint32* pB=(const TUint32*)Buffer;
const TUint32* pE=(const TUint32*)(Buffer+KBufferSize);
while (pB<pE && *pB==0xffffffff) ++pB;
if (pB<pE)
{
test.Printf(_L("ERROR: pos %08x data %08x\n"),((TUint32)pB)-((TUint32)Buffer)+pos,*pB);
test(0);
}
test.Printf(KDot);
}
test.Printf(_L("\n"));
return KErrNone;
}
/******************************************************************************
* Extra thread for background write, for use in the read-while-write tests
******************************************************************************/
TUint seed[2];
TInt WriteThreadFn(TAny* aPtr)
{
// re-use the struct created for the erase thread
SEraseInfo& e=*(SEraseInfo*)aPtr;
TInt r=KErrNone;
TPtrC8 wptr(Buffer,KBufferSize);
TUint32* pB=(TUint32*)Buffer;
TUint32* pE=(TUint32*)(Buffer+KBufferSize);
while (pB<pE)
*pB++=Random(seed);
for (Block=e.iFirstBlock; Block<e.iFirstBlock+e.iNumBlocks; ++Block)
{
TInt64 pos64 = MAKE_TINT64(0, Block*EbSz);
r=Drive.Write(pos64,wptr);
if (r!=KErrNone)
return r;
}
return KErrNone;
}
RThread WriteThread;
TRequestStatus WriteStatus;
_LIT(KWriteThreadName,"Writer");
TInt StartAsyncWrite(TInt aFirstBlock, TInt aNumBlocks)
{
// re-use the struct created for the erase thread
EraseInfo.iFirstBlock=aFirstBlock;
EraseInfo.iNumBlocks=aNumBlocks;
TInt r=WriteThread.Create(KWriteThreadName,WriteThreadFn,0x4000,KHeapSize,KHeapSize,&EraseInfo,EOwnerThread);
if (r!=KErrNone)
return r;
WriteThread.Logon(WriteStatus);
WriteThread.Resume();
return KErrNone;
}
TInt WaitForAsyncWrite()
{
User::WaitForRequest(WriteStatus);
TInt exitType=WriteThread.ExitType();
TInt exitReason=WriteThread.ExitReason();
TBuf<16> exitCat=WriteThread.ExitCategory();
if((exitType!= EExitKill)||(exitReason!=KErrNone))
{
test.Printf(_L("Async Write error: %d, block %d\n"),WriteStatus.Int(),Block);
test.Printf(_L("Thread exit reason: %d,%d,%S\n"),exitType,exitReason,&exitCat);
test(0);
}
WriteThread.Close();
// No verification performed
test.Printf(_L("\n"));
return KErrNone;
}
/******************************************************************************
* Control mode and Object mode test functions
******************************************************************************/
TInt DoControlModeWriteAndVerify(TUint32 aPattern, TUint32 aStartOffset)
{
// Writes 4K bytes of a given pattern to the "A" half of programming regions,
// starting at the specified offset, then reads the data back to verify it
TUint32* pB=(TUint32*)(Buffer);
TUint32* pE=(TUint32*)(Buffer + KBufferSize);
TInt r=KErrNone;
// Fill the entire buffer with an initial value
while (pB<pE)
*pB++= aPattern;
// In this mode, half the device is available for writing, the other half is reserved;
// the available half appears as the first DriveCaps.iControlModeSize bytes, the reserved
// half as the following DriveCaps.iControlModeSize, and this alternating continues.
// To perform this discrete-write test, therefore, the data held in Buffer that corresponds
// to the reserved area is overwritten with 0xFF; 'writing' this value to the reserved area
// has no detrimental effect.
TInt i;
TUint32 b;
pB=(TUint32*)Buffer;
for(i=0; i< KBufferSize; i+=(DriveCaps.iControlModeSize*2))
{
pB = (TUint32 *)((TUint32)pB + DriveCaps.iControlModeSize);
for (b=0; b < DriveCaps.iControlModeSize; b+=4)
{
*pB = 0xFFFFFFFF;
pB++;
}
}
// Write the data
for (i=0; i<KBufferSize; i+=(4*DriveCaps.iControlModeSize))
{
TInt64 pos64(i + aStartOffset);
TPtrC8 ptr(Buffer+i,(4*DriveCaps.iControlModeSize));
r=Drive.Write(pos64,ptr);
test(r==KErrNone);
}
// Check what has been written
Mem::FillZ(Buffer,KBigBufferSize);
TPtr8 buf(Buffer,0,KBufferSize);
r=Drive.Read(aStartOffset,KBufferSize,buf);
test(r==KErrNone);
pB=(TUint32*)Buffer;
for(i=0; i< KBufferSize; i+=(DriveCaps.iControlModeSize*2))
{
for (b=0; b< DriveCaps.iControlModeSize; b+=4)
{
if(*pB++ != aPattern)
{
test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,aPattern);
r=KErrCorrupt;
break;
}
}
for (b=0; b< DriveCaps.iControlModeSize; b+=4)
{
if(*pB++ != 0xFFFFFFFF)
{
test.Printf(_L("ERROR: addr %08x data %08x expected 0xFFFFFFFF\n"),pB,*pB);
r=KErrCorrupt;
break;
}
}
}
return r;
}
TInt DoObjectModeWriteAndVerify(TUint32 aOffset, TUint32 aSize)
{
// Writes 'aSize' bytes of a 'random' pattern to the specified offset
// then read back and verify
TInt r=KErrNone;
// Check that aSize is valid
if(aSize>DriveCaps.iObjectModeSize)
{
test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - aSize=%x is greater than max (%x)\n"),aSize,DriveCaps.iObjectModeSize);
return KErrArgument;
}
// write the data
TUint seed[2];
seed[0]=0xb17217f8;
seed[1]=0;
TInt64 pos64 = MAKE_TINT64(0, aOffset);
TPtrC8 ptr(Buffer,aSize);
TUint32* pB=(TUint32*)Buffer;
TUint32* pE=(TUint32*)(Buffer+aSize);
while (pB<pE)
*pB++=Random(seed);
r=Drive.Write(pos64,ptr);
if(r!=KErrNone)
{
return r;
}
// Read the data back
seed[0]=0xb17217f8;
seed[1]=0;
TPtr8 rptr(Buffer,0,aSize);
Mem::FillZ(Buffer,aSize);
r=Drive.Read(pos64,aSize,rptr);
if(r!=KErrNone)
{
test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);
return r;
}
test((TUint32)(rptr.Length())==aSize);
// Verify the content
pB=(TUint32*)Buffer;
pE=(TUint32*)(Buffer+aSize);
TUint32 ex=0;
while (pB<pE && (ex=Random(seed),*pB==ex)) ++pB;
if (pB<pE)
{
test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected %08x\n"),pB,*pB,ex);
r=KErrCorrupt;
}
return r;
}
TInt DoControlModeBoundaryWriteAndVerify()
{
//
TInt r=KErrNone;
//test.Printf(_L("Entering: DoControlModeBoundaryWriteAndVerify - Start Test\n"));
r=Drive.Format(0,DriveCaps.iEraseBlockSize);
test(r==KErrNone);
// Program into the last Control mode region in the programming region.
TInt64 pos64 = MAKE_TINT64(0, (DriveCaps.iObjectModeSize - (DriveCaps.iControlModeSize*2)));
TPtrC8 ptr(Buffer,DriveCaps.iControlModeSize);
TUint32* pB=(TUint32*)Buffer;
TUint32* pE=(TUint32*)(Buffer+DriveCaps.iControlModeSize);
while (pB<pE)
*pB++=0xb4b4a5a5;
r=Drive.Write(pos64,ptr);
if(r!=KErrNone)
{
test.Printf(_L("ERROR: DoControlModeBoundaryWriteAndVerify - Write 1\n"));
return r;
}
// Program into the next programming region starting at the first byte up to the size of the Control Mode Size.
pos64 = MAKE_TINT64(0, DriveCaps.iObjectModeSize);
r=Drive.Write(pos64,ptr);
if(r!=KErrNone)
{
test.Printf(_L("ERROR: DoControlModeBoundaryWriteAndVerify - Write 2\n"));
return r;
}
// Read the data back from the first program
pos64 = MAKE_TINT64(0, (DriveCaps.iObjectModeSize - (DriveCaps.iControlModeSize*2)));
TPtr8 rptr(Buffer,0,(TInt)DriveCaps.iControlModeSize);
Mem::FillZ(Buffer,DriveCaps.iControlModeSize);
r=Drive.Read(pos64,DriveCaps.iControlModeSize,rptr);
if(r!=KErrNone)
{
test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);
return r;
}
test((TUint32)(rptr.Length())==DriveCaps.iControlModeSize);
// Verify the content
pB=(TUint32*)Buffer;
pE=(TUint32*)(Buffer+DriveCaps.iControlModeSize);
TUint32 ex=0xb4b4a5a5;
while (pB<pE && (*pB==ex)) ++pB;
if (pB<pE)
{
test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected %08x\n"),pB,*pB,ex);
r=KErrCorrupt;
}
// Read the data back from the second program
pos64 = MAKE_TINT64(0, DriveCaps.iObjectModeSize);
TPtr8 rptr2(Buffer,0,((TInt)DriveCaps.iControlModeSize));
Mem::FillZ(Buffer,DriveCaps.iControlModeSize);
r=Drive.Read(pos64,DriveCaps.iControlModeSize,rptr2);
if(r!=KErrNone)
{
test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);
return r;
}
test((TUint32)(rptr2.Length())==DriveCaps.iControlModeSize);
// Verify the content
pB=(TUint32*)Buffer;
pE=(TUint32*)(Buffer+DriveCaps.iControlModeSize);
ex=0xb4b4a5a5;
while (pB<pE && (*pB==ex)) ++pB;
if (pB<pE)
{
test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected %08x\n"),pB,*pB,ex);
r=KErrCorrupt;
}
// Bit Twiddle the last bit of the last Control Mode Region
// Then bit twiddle the first bit of the first control Mode region.
// Program into the last Control mode region in the programming region.
pos64 = MAKE_TINT64(0, (DriveCaps.iObjectModeSize - DriveCaps.iControlModeSize - 4));
TPtrC8 ptr2(Buffer,4);
TUint32* pC=(TUint32*)Buffer;
*pC = 0xFFFFFFFE;
r=Drive.Write(pos64,ptr2);
if(r!=KErrNone)
{
test.Printf(_L("ERROR: DoControlModeBoundaryWriteAndVerify - Write 3\n"));
return r;
}
// Read the data back from the first program
pos64 = MAKE_TINT64(0, (DriveCaps.iObjectModeSize - DriveCaps.iControlModeSize - 4));
TPtr8 rptr3(Buffer,0,4);
Mem::FillZ(Buffer,4);
r=Drive.Read(pos64,4,rptr3);
if(r!=KErrNone)
{
test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);
return r;
}
test(rptr3.Length()==4);
// Verify the content
pB=(TUint32*)Buffer;
if (*pB != 0xb4b4a5a4)
{
test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected 0xb4b4a5a4\n"),pB,*pB);
r=KErrCorrupt;
}
// Program into the last Control mode region in the programming region.
pos64 = MAKE_TINT64(0, DriveCaps.iObjectModeSize);
TPtrC8 ptr3(Buffer,4);
pC=(TUint32*)Buffer;
*pC = 0x7FFFFFFF;
r=Drive.Write(pos64,ptr3);
if(r!=KErrNone)
{
test.Printf(_L("ERROR: DoControlModeBoundaryWriteAndVerify - Write 4\n"));
return r;
}
// Read the data back from the first program
pos64 = MAKE_TINT64(0, DriveCaps.iObjectModeSize);
TPtr8 rptr4(Buffer,0,4);
Mem::FillZ(Buffer,4);
r=Drive.Read(pos64,4,rptr4);
if(r!=KErrNone)
{
test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - Read returned %d\n"),r);
return r;
}
test(rptr4.Length()==4);
// Verify the content
pB=(TUint32*)Buffer;
if (*pB != 0x34b4a5a5)
{
test.Printf(_L("ERROR: DoObjectModeWriteAndVerify - addr %08x data %08x expected 0x34b4a5a5\n"),pB,*pB);
r=KErrCorrupt;
}
return r;
}
/******************************************************************************
* Main test program
******************************************************************************/
GLDEF_C TInt E32Main()
{
test.Title();
/******************************************************************************
* Initialisation
******************************************************************************/
TDriveInfoV1Buf diBuf;
UserHal::DriveInfo(diBuf);
TDriveInfoV1 &di=diBuf();
test.Start(_L("Test the LFFS media driver"));
test.Printf(_L("DRIVES PRESENT :%d\r\n"),di.iTotalSupportedDrives);
test.Printf(_L("C:(1ST) DRIVE NAME :%- 16S\r\n"),&di.iDriveName[0]);
test.Printf(_L("D:(2ND) DRIVE NAME :%- 16S\r\n"),&di.iDriveName[1]);
test.Printf(_L("E:(3RD) DRIVE NAME :%- 16S\r\n"),&di.iDriveName[2]);
test.Printf(_L("F:(4TH) DRIVE NAME :%- 16S\r\n"),&di.iDriveName[3]);
test.Printf(_L("G:(5TH) DRIVE NAME :%- 16S\r\n"),&di.iDriveName[4]);
test.Printf(_L("H:(6TH) DRIVE NAME :%- 16S\r\n"),&di.iDriveName[5]);
test.Printf(_L("I:(7TH) DRIVE NAME :%- 16S\r\n"),&di.iDriveName[6]);
test.Printf(_L("J:(8TH) DRIVE NAME :%- 16S\r\n"),&di.iDriveName[7]);
test.Printf(_L("K:(9TH) DRIVE NAME :%- 16S\r\n"),&di.iDriveName[8]);
test.Printf(_L("\r\nWarning - all data on LFFS drive will be lost.\r\n"));
test.Printf(_L("<<<Select drive to continue>>>\r\n"));
FOREVER
{
TChar c=(TUint)test.Getch();
c.UpperCase();
DriveNumber=((TUint)c)-'C';
if (DriveNumber>=0&&DriveNumber<='C'+ 8)
break;
}
test.Next(_L("Load media driver"));
TInt r=User::LoadPhysicalDevice(KMediaDriverName);
test(r==KErrNone || r==KErrAlreadyExists);
test.Next(_L("Connect to drive"));
r=Drive.Connect(DriveNumber,ChangedFlag);
test(r==KErrNone);
test.Next(_L("Get capabilities"));
DriveCaps.iControlModeSize=0; // If test invoked for a chip other than Sibley then this element will not be updated
DriveCaps.iObjectModeSize=0; // If test invoked for a chip other than Sibley then this element will not be updated
TPckg<TLocalDriveCapsV7> capsPckg(DriveCaps);
r=Drive.Caps(capsPckg);
test(r==KErrNone);
test.Printf(_L("Size : %08x\n"),I64LOW(DriveCaps.iSize));
test.Printf(_L("Type : %d\n"),DriveCaps.iType);
test.Printf(_L("Connection Bus : %d\n"),DriveCaps.iConnectionBusType);
test.Printf(_L("DriveAtt : %02x\n"),DriveCaps.iDriveAtt);
test.Printf(_L("MediaAtt : %02x\n"),DriveCaps.iMediaAtt);
test.Printf(_L("BaseAddress : %08x\n"),DriveCaps.iBaseAddress);
test.Printf(_L("FileSysID : %d\n"),DriveCaps.iFileSystemId);
test.Printf(_L("Hidden sectors : %d\n"),DriveCaps.iHiddenSectors);
test.Printf(_L("Erase block size: %d\n"),DriveCaps.iEraseBlockSize);
test.Printf(_L("Partition size: %d\n"),DriveCaps.iPartitionSize);
test.Printf(_L("Control Mode size: %d\n"),DriveCaps.iControlModeSize);
test.Printf(_L("Object Mode size: %d\n"),DriveCaps.iObjectModeSize);
test.Printf(_L("Press any key...\n\n"));
test.Getch();
test(DriveCaps.iDriveAtt==(KDriveAttLocal|KDriveAttInternal));
test((DriveCaps.iMediaAtt&KMediaAttFormattable)==(KMediaAttFormattable)); // Apply mask since other flags may be set
#if defined(_DEBUG) && defined(_WINS)
/******************************************************************************
* Simulate device timeout
******************************************************************************/
test.Next(_L("Timeout"));
EbSz=DriveCaps.iEraseBlockSize;
r=Drive.Format(0,EbSz);
test(r==KErrNone);
r=Drive.ControlIO(ECtrlIoTimeout, NULL, NULL);
if(r!=KErrNotSupported)
{
if(r==KErrNone)
{
// Test timeout behaviour for Write operation
TPtrC8 ptr(Buffer,1);
r=Drive.Write(0,ptr);
test(r==KErrNotReady);
// Test condition now cleared, ensure normal operation is OK
r=Drive.Write(0,ptr);
test(r==KErrNone);
// Test timeout behaviour for Format operation
r=Drive.ControlIO(ECtrlIoTimeout, NULL, NULL);
test(r==KErrNone);
r=Drive.Format(0,EbSz);
test(r==KErrNotReady);
// Cleanup
r=Drive.Format(0,EbSz);
test(r==KErrNone);
}
else
{
test.Printf(_L("Timeout ControlIO failed initialisation\n"));
test(0); // Cannot proceed with this test
}
}
else
{
test.Printf(_L("Timeout ControlIO not supported\n"));
}
test.Printf(_L("Press any key...\n"));
test.Getch();
#endif
/******************************************************************************
* Formatting
******************************************************************************/
test.Next(_L("Format"));
TUint32 pos;
EbSz=DriveCaps.iEraseBlockSize;
Size=I64LOW(DriveCaps.iSize);
// Reduce size so test doesn't take forever
if (Size>8*EbSz)
Size=8*EbSz;
for (pos=0; pos<Size; pos+=EbSz)
{
TInt64 pos64 = MAKE_TINT64(0, pos);
r=Drive.Format(pos64,EbSz);
test(r==KErrNone);
test.Printf(KDot);
}
test.Next(_L("\nVerify"));
for (pos=0; pos<Size; pos+=KBufferSize)
{
TInt64 pos64 = MAKE_TINT64(0, pos);
TPtr8 ptr(Buffer,0,KBufferSize);
Mem::FillZ(Buffer,KBigBufferSize);
r=Drive.Read(pos64,KBufferSize,ptr);
test(r==KErrNone);
test(ptr.Length()==KBufferSize);
const TUint32* pB=(const TUint32*)Buffer;
const TUint32* pE=(const TUint32*)(Buffer+KBufferSize);
while (pB<pE && *pB==0xffffffff) ++pB;
if (pB<pE)
{
test.Printf(_L("ERROR: addr %08x data %08x\n"),pB,*pB);
test(0);
}
test.Printf(KDot);
}
test.Printf(_L("\nPress any key...\n\n"));
test.Getch();
/******************************************************************************
* Large block writes
******************************************************************************/
test.Next(_L("Write"));
TUint seed[2];
seed[0]=0xb17217f8;
seed[1]=0;
for (pos=0; pos<Size; pos+=KBufferSize)
{
TInt64 pos64 = MAKE_TINT64(0, pos);
TPtrC8 ptr(Buffer,KBufferSize);
TUint32* pB=(TUint32*)Buffer;
TUint32* pE=(TUint32*)(Buffer+KBufferSize);
while (pB<pE)
*pB++=Random(seed);
r=Drive.Write(pos64,ptr);
test(r==KErrNone);
test.Printf(KDot);
}
test.Printf(_L("\n"));
test.Next(_L("Verify"));
seed[0]=0xb17217f8;
seed[1]=0;
for (pos=0; pos<Size; pos+=KBufferSize)
{
TInt64 pos64 = MAKE_TINT64(0, pos);
TPtr8 ptr(Buffer,0,KBufferSize);
Mem::FillZ(Buffer,KBigBufferSize);
r=Drive.Read(pos64,KBufferSize,ptr);
test(r==KErrNone);
test(ptr.Length()==KBufferSize);
const TUint32* pB=(const TUint32*)Buffer;
const TUint32* pE=(const TUint32*)(Buffer+KBufferSize);
TUint32 ex=0;
while (pB<pE && (ex=Random(seed),*pB==ex)) ++pB;
if (pB<pE)
{
test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,ex);
test(0);
}
test.Printf(KDot);
}
test.Printf(_L("\nPress any key...\n\n"));
test.Getch();
/******************************************************************************
* Single byte writes
******************************************************************************/
test.Next(_L("Format first block"));
r=Drive.Format(0,EbSz);
test(r==KErrNone);
test.Next(_L("Single byte writes"));
seed[0]=0x317b106f;
seed[1]=0;
TUint32* pB=(TUint32*)Buffer;
TUint32* pE=(TUint32*)(Buffer+KBufferSize);
while (pB<pE)
*pB++= Random(seed);
// For M18 devices, this test requires control mode operation.
// In this mode, half the device is available for writing, the other half is reserved;
// the available half appears as the first DriveCaps.iControlModeSize bytes, the reserved
// half as the following DriveCaps.iControlModeSize, and this alternating continues.
// To perform this discrete-write test, therefore, the data held in Buffer that corresponds
// to the reserved area is overwritten with 0xFF; 'writing' this value to the reserved area
// has no detrimental effect.
TInt i;
TUint32 b;
if (DriveCaps.iControlModeSize > 0)
{
pB=(TUint32*)Buffer;
for(i=0; i< KBufferSize; i+=(DriveCaps.iControlModeSize*2))
{
pB = (TUint32 *)((TUint32)pB + DriveCaps.iControlModeSize);
for (b=0; b < DriveCaps.iControlModeSize; b+=4)
{
*pB = 0xFFFFFFFF;
pB++;
}
}
}
#if 0
// Debug - print content of buffer
test.Printf(_L("Content of buffer after inserting 0xFFFFFFFFs follows\n"));
i=0;
TUint32* verifyPtr=(TUint32*)Buffer;
while(i<KBufferSize)
{
test.Printf(_L("%8x %8X %8X\n"),i+=8,*verifyPtr++,*verifyPtr++);
}
#endif
for (i=0; i<KBufferSize; ++i)
{
TInt64 pos64(i);
TPtrC8 ptr(Buffer+i,1);
r=Drive.Write(pos64,ptr);
test(r==KErrNone);
if (!(i%16))
test.Printf(KDot);
}
test.Printf(_L("\n"));
test.Next(_L("Verify"));
Mem::FillZ(Buffer,KBigBufferSize);
TPtr8 buf(Buffer,0,KBufferSize);
r=Drive.Read(0,KBufferSize,buf);
test(r==KErrNone);
seed[0]=0x317b106f;
seed[1]=0;
pB=(TUint32*)Buffer;
TUint32 ex=0;
if (DriveCaps.iControlModeSize > 0)
{
pB=(TUint32*)Buffer;
for(i=0; i< KBufferSize; i+=(DriveCaps.iControlModeSize*2))
{
for (b=0; b< DriveCaps.iControlModeSize; b+=4)
{
ex=Random(seed);
if(*pB++ != ex)
{
test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,ex);
break;
}
}
for (b=0; b< DriveCaps.iControlModeSize; b+=4)
{
ex=Random(seed);
if(*pB++ != 0xFFFFFFFF)
{
test.Printf(_L("ERROR: addr %08x data %08x expected 0xFF\n"),pB,*pB);
break;
}
}
if (!((i+1)%64))
test.Printf(KDot);
}
}
else
{
while (pB<pE && (ex=Random(seed),*pB==ex)) ++pB;
}
if (pB<pE)
{
test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,ex);
test(0);
}
test.Printf(_L("Single byte writes OK\n"));
test.Printf(_L("Press any key...\n\n"));
test.Getch();
/******************************************************************************
* Random length writes
******************************************************************************/
test.Next(_L("Random length writes"));
// Prepare the device (required if control mode is used for M18 devices)
// assume that a maximum of 2 blocks is required
r=Drive.Format(0,EbSz);
r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);
seed[0]=0xdeadbeef;
seed[1]=0;
pB=(TUint32*)Buffer;
pE=(TUint32*)(Buffer+KBigBufferSize);
while (pB<pE)
*pB++=Random(seed);
TInt remain=KBigBufferSize;
TInt objectModeOffset=0;
TUint32 writeCount=0;
seed[0]=0xdeadbeef;
seed[1]=0;
for(writeCount=0; remain && (writeCount<512); writeCount++)
{
TInt l=1+(Random(seed)&255); // random length between 1 and 256
if (l>remain)
l=remain;
TInt pos=0;
if(DriveCaps.iObjectModeSize == 0)
{
pos=KBigBufferSize-remain;
}
TPtrC8 ptr(Buffer+(KBigBufferSize-remain),l);
TInt64 pos64(pos+objectModeOffset); // Start writes in a new programming region if object mode supported
r=Drive.Write(pos64,ptr);
test(r==KErrNone);
objectModeOffset+=DriveCaps.iObjectModeSize;
remain-=l;
test.Printf(KDot);
}
test.Printf(_L("\n"));
test.Next(_L("Verify"));
Mem::FillZ(Buffer,KBigBufferSize);
new (&buf) TPtr8(Buffer,0,KBigBufferSize);
if(DriveCaps.iObjectModeSize==0)
{
r=Drive.Read(0,KBigBufferSize,buf);
test(r==KErrNone);
}
else
{
remain=KBigBufferSize;
objectModeOffset=0;
while(remain && writeCount)
{
TInt totalLength=0;
TInt l=1+(Random(seed)&255); // random length between 1 and 256
if (l>remain)
l=remain;
TPtr8 ptr(Buffer+(totalLength),l);
r=Drive.Read(objectModeOffset,l,ptr);
test(r==KErrNone);
totalLength +=l;
remain-=l;
writeCount--;
test.Printf(KDot);
}
}
seed[0]=0xdeadbeef;
seed[1]=0;
pB=(TUint32*)Buffer;
ex=0;
if(DriveCaps.iObjectModeSize==0)
{
while (pB<pE && (ex=Random(seed),*pB==ex)) ++pB;
if (pB<pE)
{
test.Printf(_L("ERROR: addr %08x data %08x expected %08x\n"),pB,*pB,ex);
// test.Getch();
test(0);
}
}
r=Drive.Format(0,EbSz);
r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);
test.Printf(_L("\nPress any key...\n\n"));
test.Getch();
/******************************************************************************
* Concurrent read/write/erase
******************************************************************************/
test.Printf(_L("Foreground R/W\n"));
r=StartAsyncErase(1,Size/EbSz-1);
test(r==KErrNone);
seed[0]=0xb17217f8;
seed[1]=0;
for (pos=KBufferSize+KBigBufferSize; pos<EbSz; pos+=KBufferSize)
{
TInt64 pos64 = MAKE_TINT64(0, pos);
TPtrC8 wptr(Buffer,KBufferSize);
TUint32* pB=(TUint32*)Buffer;
TUint32* pE=(TUint32*)(Buffer+KBufferSize);
while (pB<pE)
*pB++=Random(seed);
r=Drive.Write(pos64,wptr);
test(r==KErrNone);
test.Printf(KDot);
Mem::FillZ(Buffer+KBufferSize,KBufferSize);
TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);
r=Drive.Read(pos64,KBufferSize,rptr);
test(r==KErrNone);
test(rptr.Length()==KBufferSize);
//test(Mem::Compare(Buffer,KBufferSize,Buffer+KBufferSize,KBufferSize)==0);
r = Mem::Compare(Buffer,KBufferSize,Buffer+KBufferSize,KBufferSize);
#if 0
if (r!=KErrNone)
{
pB=(TUint32*)Buffer;
pE=(TUint32*)(Buffer+KBufferSize);
for(TInt i=0; i < (KBufferSize>>2); i++)
{
test.Printf(_L("%d Buffer Content %08x %08x Flash Content\n"),i, pB[i], pE[i]);
}
}
#endif
test (r==KErrNone);
test.Printf(KSemiColon);
}
r=WaitForAsyncErase();
test(r==KErrNone);
r=Drive.Format(0,EbSz);
r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);
test.Printf(_L("Press any key...\n\n"));
test.Getch();
// Perform the following tests for debug builds, only
#ifdef _DEBUG
/******************************************************************************
* Concurrent operations to exercise TYAX Read-While-Write capability
* First, show read while write denied when attempting to read from a partition
* that is being written to
* Second, show read while write proceeding when reading from a partition other
* than that which is being written to
******************************************************************************/
// Do not perform these tests unless read-while-write is supported
if(DriveCaps.iMediaAtt&KMediaAttReadWhileWrite)
{
test.Next(_L("Denied read while write"));
r=Drive.ControlIO(ECtrlIoRww, NULL, NULL);
if(r!=KErrNone)
{
test.Printf(_L("ControlIO not ready, returned %d\n"), r);
test(0); // Cannot proceed with this test
}
test.Printf(_L("Press any key...\n"));
test.Getch();
test.Printf(_L("Starting async write for the first RWE/RWW test"));
r=StartAsyncWrite(1,3); // Write to the first three blocks, only, to limit duration
test(r==KErrNone);
// Allow the write thread to be created and ready to run
// This will ensure that the driver will have received a write request before the second of the read
// requests, below. Following the issue of the ControlIO command, above, the driver will not instigate
// the write request until the next (second) read request is received. This is done so that the high priority
// driver thread recognises the existence of a read request (from a lower priority test / user thread)
// before it executes a sequence of writes to the FLASH device. This is necessary because, although
// each write takes a finite amount of time, the poll timer expires so quickly that the driver thread
// would not be blocked for a sufficiently long period to allow the read request to be processed. Adopting
// the contrived, and artificial, approach of using ControlIO to 'stage' the write allows the read-while-write
// capability of the device to be execrised.
User::After(1000);
test.Printf(_L("Starting concurrent loop for background write\n"));
{
// First read - this will be performed before the write thread is run, so does
// not exercise read while write.
TInt64 pos64 = MAKE_TINT64(0,0);
TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);
test.Printf(_L("Issuing Drive.Read 1\n"));
r=Drive.Read(pos64,KBufferSize,rptr);
test(r==KErrNone);
test.Printf(KSemiColon);
}
{
// Second read - to same partition (and block) as the active write
// This read should be deferred by the driver
TInt64 pos64 = MAKE_TINT64(0, 2*EbSz);
TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);
test.Printf(_L("Issuing Drive.Read 2\n"));
r=Drive.Read(pos64,KBufferSize,rptr); // Should collide with second write
test(r==KErrNone);
test.Printf(KSemiColon);
}
{
// Third read - due to the tight poll timer period, this will not be scheduled
// until the write request has completed - so does not exercise read while write.
TInt64 pos64 = MAKE_TINT64(0, DriveCaps.iPartitionSize);
TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);
test.Printf(_L("Issuing Drive.Read 3\n"));
r=Drive.Read(pos64,KBufferSize,rptr);
test(r==KErrNone);
test.Printf(KSemiColon);
}
r=WaitForAsyncWrite();
test(r==KErrNone);
///////////////////////////////////////////////////////////////////////////////
r=Drive.Format(0,EbSz);
r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);
r=Drive.Format((DriveCaps.iEraseBlockSize*2),EbSz);
r=Drive.Format((DriveCaps.iEraseBlockSize*3),EbSz);
test.Printf(_L("Press any key...\n"));
test.Getch();
test.Next(_L("Supported read while write"));
r=Drive.ControlIO(ECtrlIoRww, NULL, NULL);
if(r!=KErrNone)
{
test.Printf(_L("ControlIO not ready\n"));
return r;
}
test.Printf(_L("Press any key...\n"));
test.Getch();
test.Printf(_L("Starting async write for the second RWE/RWW test"));
r=StartAsyncWrite(1,3); // Write to the first three blocks, only, to limit duration
test(r==KErrNone);
// Allow the write thread to be created and ready to run
User::After(1000);
test.Printf(_L("Starting concurrent loop for background write\n"));
{
// First read - this will be performed before the write thread is run, so does
// not exercise read while write.
TInt64 pos64 = MAKE_TINT64(0, DriveCaps.iPartitionSize);
TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);
test.Printf(_L("Issuing Drive.Read 1\n"));
r=Drive.Read(pos64,KBufferSize,rptr);
test(r==KErrNone);
test.Printf(KSemiColon);
}
{
// Second read - to different partition than that targeted by the active write
// This read should check the overlap and proceed without being deferred
TInt64 pos64 = MAKE_TINT64(0, DriveCaps.iPartitionSize);
TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);
test.Printf(_L("Issuing Drive.Read 2\n"));
r=Drive.Read(pos64,KBufferSize,rptr); // Should collide with second write
test(r==KErrNone);
test.Printf(KSemiColon);
}
{
// Third read - due to the tight poll timer period, this will not be scheduled
// until the write request has completed - so does not exercise read while write.
TInt64 pos64 = MAKE_TINT64(0, DriveCaps.iPartitionSize);
TPtr8 rptr(Buffer+KBufferSize,0,KBufferSize);
test.Printf(_L("Issuing Drive.Read 3\n"));
r=Drive.Read(pos64,KBufferSize,rptr);
test(r==KErrNone);
test.Printf(KSemiColon);
}
test.Printf(_L("\nForeground Read OK\n"));
r=WaitForAsyncWrite();
test(r==KErrNone);
}
#endif
// Clean up
r=Drive.Format(0,EbSz);
r=Drive.Format(DriveCaps.iEraseBlockSize,EbSz);
r=Drive.Format((DriveCaps.iEraseBlockSize*2),EbSz);
r=Drive.Format((DriveCaps.iEraseBlockSize*3),EbSz);
/*****************************************************************************************************
Tests for M18 NOR Flash devices
These tests assume that object mode and control mode is supported
*****************************************************************************************************/
if((DriveCaps.iControlModeSize !=0) && (DriveCaps.iObjectModeSize != 0))
{
// Control mode writes
// Prove that control mode writes are supported
// This requires that data is formatted such that areas coinciding with the "B" Half of a
// programming region are set to all 0xFFs
// Write to programming region zero
test.Next(_L("\nControl mode writes"));
r=DoControlModeWriteAndVerify(0xa5a5a5a5, 0);
test(r==KErrNone);
// Now verify that data written in control mode can be further modified
// Do this by ANDing the read-back pattern with a mask that clears particular bits
// then write the resulting pattern back to the region
r=DoControlModeWriteAndVerify(0x84848484, 0);
test(r==KErrNone);
// Now verify that data written in control mode can be further modified to all 0x00s
// Do this by ANDing the read-back pattern with a mask that clears the remaining bits
// then write the resulting pattern back to the region
r=DoControlModeWriteAndVerify(0x00000000, 0);
test(r==KErrNone);
// Erase the block before attempting to re-use the programming region for object mode writing
test.Printf(_L("\nErase block 0 before object mode write"));
r=Drive.Format(0,EbSz);
test(r==KErrNone);
test.Next(_L("\n(Subsequent) Object mode writes"));
// Control mode writes
// Prove that object mode writes are allowd to an erased block that was previously
// used in control mode
// Use offset zero and length equal to one-quarter of the allowed object mode size (i.e. one-
// quarter of the lengh of the programming region) (The write test, above, wrote an entire region
// in object mode)
test.Printf(_L("\nObject mode write, object mode size=%d"),DriveCaps.iObjectModeSize);
r=DoObjectModeWriteAndVerify(0, (DriveCaps.iObjectModeSize>>2));
test(r==KErrNone);
// Prove that an attempt to append data to an object mode region fails
test.Printf(_L("\nAttempt append to object mode region"));
r=DoObjectModeWriteAndVerify((DriveCaps.iObjectModeSize>>2),(DriveCaps.iObjectModeSize>>2));
test(r==KErrGeneral);
// Erase the block after a failed write and before attempting to re-use for programming
test.Printf(_L("\nErase block 0 after failed object mode write"));
r=Drive.Format(0,EbSz);
test(r==KErrNone);
test.Next(_L("\n(Subsequent) Object mode writes following an error"));
// write to a new object mode region after a failed write and before attempting to erase the block
// Prove that erase block can be re-written to
test.Printf(_L("\nObject mode write following failed write and erase"));
r=DoObjectModeWriteAndVerify(0, (DriveCaps.iObjectModeSize>>2));
test(r==KErrNone);
// Cause a failed object mode write
r=DoObjectModeWriteAndVerify(0, (DriveCaps.iObjectModeSize>>2));
test(r==KErrGeneral);
// the status register has an error. Attempt to write in a new region and ensure that it succeeds
r=DoObjectModeWriteAndVerify(DriveCaps.iObjectModeSize, DriveCaps.iObjectModeSize);
test(r==KErrNone);
test.Next(_L("\n(Subsequent) Control mode writes following previous use in object mode"));
// Re-use a former object mode region for control mode writes
// Erase the block after a failed write and before attempting to re-use for programming
r=Drive.Format(0,EbSz);
test(r==KErrNone);
r=DoControlModeWriteAndVerify(0xa5a5a5a5, 0);
test(r==KErrNone);
// Verify that data written in control mode can be further modified
r=DoControlModeWriteAndVerify(0x84848484, 0);
test(r==KErrNone);
test.Next(_L("\n(Subsequent) Control mode writes following an error"));
// Test that a control mode write can succeed after a previous error
// Use a failed object mode write attempt to the "B" half of a control mode region
// to cause the error
r=DoObjectModeWriteAndVerify(DriveCaps.iControlModeSize,(DriveCaps.iObjectModeSize>>2));
test(r==KErrGeneral);
r=DoControlModeWriteAndVerify(0x00000000, 0);
test(r==KErrNone);
test.Next(_L("\nControl mode boundary write test"));
r=DoControlModeBoundaryWriteAndVerify();
test(r==KErrNone);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
test.Printf(_L("Press any key...\n"));
test.Getch();
test.End();
return KErrNone;
}