1 // Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 #include <e32def.h>

    18 #include <e32cmn.h>

    19 #include <f32file.h>

    20 #include <e32test.h>

    21 #include <e32math.h>

    22 

    23 #include "tmslog.h"

    24 #include "cblockdevicetester.h"

    25 

    26 extern RTest test;

    27 extern RFs fsSession;

    28 

    29 

    30 const TInt KTestCaseDataOffset = 9;

    31 _LIT8(KTxtTestCaseOutPreamble,  "5555AAAA");

    32 _LIT8(KTxtTestCaseInPreamble,   "AAAA5555");

    33 _LIT8(KTxtTestCase,         "T");

    34 _LIT8(KTxtTestEnable,       "E");

    35 _LIT8(KTxtTestSenseError,   "S");

    36 _LIT8(KTxtTestConfig,       "C");

    37 

    38 

    39 void TLocalBuffer::Init()

    40     {

    41     __MSFNSLOG

    42     TInt64 rndSeed = 123456789;

    43 

    44     //-- initialize buffer with random rubbish

    45     iBuffer.SetMax();

    46     for (TInt i = 0; i < KSize; ++i)

    47         {

    48         iBuffer[i] = static_cast<TUint8>(Math::Rand(rndSeed));

    49         }

    50 

    51     test.Printf(_L("Test area size is %x blocks\n"), KSizeInBlocks);

    52     }

    53 

    54 

    55 void TLocalBuffer::Update(TInt aPos, TUint aLen)

    56     {

    57     // complement data

    58     for (TInt i = 0; i < aLen; i++, aPos++)

    59         {

    60         iBuffer[aPos] = ~iBuffer[aPos];

    61         }

    62     }

    63 

    64 

    65 RTargetMedia::RTargetMedia(TInt aDriveNumber)

    66 :   iDriveNumber(aDriveNumber)

    67     {

    68     __MSFNSLOG

    69     }

    70 

    71 

    72 void RTargetMedia::OpenL()

    73     {

    74     __MSFNSLOG

    75     User::LeaveIfError(iRawDisk.Open(fsSession, iDriveNumber));

    76     }

    77 

    78 

    79 void RTargetMedia::Close()

    80     {

    81     __MSFNSLOG

    82     iRawDisk.Close();

    83     }

    84 

    85 

    86 TInt RTargetMedia::MediaRawWrite(TPos aPos, const TDesC8& aData)

    87     {

    88     __MSFNSLOG

    89     return iRawDisk.Write(aPos, (TDesC8&)aData);

    90     }

    91 

    92 

    93 TInt RTargetMedia::MediaRawRead(TPos aPos, TUint32 aLen, TDes8& aData)

    94     {

    95     __MSFNSLOG

    96     aData.SetMax();

    97     TPtr8 ptr = aData.LeftTPtr(aLen);

    98     TInt err = iRawDisk.Read(aPos, ptr);

    99     aData.SetLength(aLen);

   100     return err;

   101     }

   102 

   103 

   104 RTargetDrive::RTargetDrive(TInt aDriveNumber)

   105 :   RTargetMedia(aDriveNumber)

   106     {

   107     }

   108 

   109 TInt RTargetDrive::OpenTestAreaL(const TDesC8& aData)

   110     {

   111     __MSFNSLOG

   112     RTargetMedia::OpenL();

   113     iStartLba = 0x20;

   114 

   115     iSource.Set(aData);

   116     test.Printf(_L("Test area located @ LBA=%x\n"), iStartLba);

   117 

   118     return MediaRawWrite(StartPos(), iSource);

   119     }

   120 

   121 

   122 TInt RTargetDrive::Update(TInt aPos, TUint aLen)

   123     {

   124     __MSFNSLOG

   125     TPtrC8 ptr = iSource.Mid(aPos, aLen);

   126     TPos targetPos = TargetPos(aPos);

   127     return MediaRawWrite(targetPos, ptr);

   128     }

   129 

   130 

   131 TInt RTargetDrive::Verify()

   132     {

   133     __MSFNLOG

   134     TInt res = MediaRawRead(StartPos(), iSource.Length(), iTmpBuffer);

   135     if (res)

   136         return res;

   137 

   138     res = iTmpBuffer.Compare(iSource);

   139     return res == 0 ? KErrNone : KErrCorrupt;

   140     }

   141 

   142 TInt RTargetDrive::Verify(TInt aPos, TUint aLen)

   143     {

   144     __MSFNSLOG

   145     TPos pos = TargetPos(aPos);

   146     TInt res = MediaRawRead(pos, aLen, iTmpBuffer);

   147     if (res)

   148         return res;

   149 

   150     iTmpBuffer.SetLength(aLen);

   151     TPtrC8 ptr = iSource.Mid(aPos, aLen);

   152 

   153     res = iTmpBuffer.Compare(ptr);

   154     return res == 0 ? KErrNone : KErrCorrupt;

   155     }

   156 

   157 

   158 TInt RTargetDrive::VerifyBlock(TLba aLba, TLba aBlocks)

   159     {

   160     __MSFNSLOG

   161     return Verify(TLbaUtils::Pos(aLba), TLbaUtils::Length(aBlocks));

   162     }

   163 

   164 

   165 _LIT(KTxtControlFile, "ControlFile.txt");

   166 static const TChar KFillChar = 'x';

   167 

   168 TTargetTestArea::TTargetTestArea(RTargetMedia& aMedia)

   169 :   iTargetMedia(aMedia)

   170     {

   171     __MSFNLOG

   172     }

   173 

   174 void TTargetTestArea::CreateControlFile()

   175     {

   176     __MSFNLOG

   177     iStartLba = -1;

   178     static const TInt KBlockSize = 0x200;

   179     static const TInt KFileSize = KBlockSize * 8;

   180 

   181     RFile file;

   182 

   183     TBuf8<KFileSize> testData;

   184     testData.Fill(KFillChar, KFileSize);

   185 

   186     // write control file

   187     TInt err = file.Replace(fsSession, KTxtControlFile, EFileStream);

   188     test(err == KErrNone);

   189 

   190     err = file.Write(testData);

   191     test(err == KErrNone);

   192 

   193     file.Close();

   194     }

   195 

   196 

   197 void TTargetTestArea::RemoveControlFile()

   198     {

   199     __MSFNLOG

   200     TInt err = fsSession.Delete(KTxtControlFile);

   201     test(err == KErrNone);

   202     }

   203 

   204 

   205 void TTargetTestArea::FindBlockStartL()

   206     {

   207     __MSFNLOG

   208     iTargetMedia.OpenL();

   209     // search for first block

   210     TBuf8<KBlockSize> readBlock;

   211     TBuf8<KBlockSize> refBlock;

   212     refBlock.Fill(KFillChar, KBlockSize);

   213 

   214     TInt err = KErrNone;

   215     TInt lba;

   216     for (lba = 0; ;lba++)

   217         {

   218         err = iTargetMedia.MediaRawRead(lba*KBlockSize, KBlockSize, readBlock);

   219 

   220         if (err != KErrNone)

   221             {

   222             lba = -1;

   223             break;

   224             }

   225 

   226         if (readBlock == refBlock)

   227             {

   228             break;

   229             }

   230         }

   231 

   232     iStartLba = lba;

   233     iTargetMedia.Close();

   234     test.Printf(_L("Block found at 0x%x"), lba);

   235     }

   236 

   237 

   238 TInt TTargetTestArea::WriteBlockL(TBuf8<KBlockSize>& aBlock)

   239     {

   240     __MSFNLOG

   241     iTargetMedia.OpenL();

   242     TInt err = iTargetMedia.MediaRawWrite(iStartLba * KBlockSize, aBlock);

   243     iTargetMedia.Close();

   244     return err;

   245     }

   246 

   247 

   248 TInt TTargetTestArea::ReadBlockL(TBuf8<KBlockSize>& aBlock)

   249     {

   250     __MSFNLOG

   251     iTargetMedia.OpenL();

   252     TInt err = iTargetMedia.MediaRawRead(iStartLba * KBlockSize, KBlockSize, aBlock);

   253     iTargetMedia.Close();

   254     return err;

   255     }

   256 

   257 

   258 RBlockTargetMedia::RBlockTargetMedia(TInt aDriveNumber)

   259 :   RTargetMedia(aDriveNumber)

   260     {

   261     __MSFNSLOG

   262     }

   263 

   264 

   265 void RBlockTargetMedia::OpenL()

   266     {

   267     __MSFNSLOG

   268     RTargetMedia::OpenL();

   269 

   270     TInt64 rndSeed = 123456789;

   271 

   272     //-- initialize buffer with random rubbish

   273     iBlockData.SetMax();

   274     for (TInt i = 0; i < iBlockData.Length(); ++i)

   275         {

   276         iBlockData[i] = static_cast<TUint8>(Math::Rand(rndSeed));

   277         }

   278     }

   279 

   280 

   281 TInt RBlockTargetMedia::WriteBlock(TLba aLba)

   282     {

   283     __MSFNSLOG

   284     TPos pos = TLbaUtils::Pos(aLba);

   285     return iRawDisk.Write(pos, (TDesC8&)iBlockData);

   286     }

   287 

   288 

   289 TInt RBlockTargetMedia::ReadBlock(TLba aLba)

   290     {

   291     __MSFNSLOG

   292     TBuf8<KBlockSize> blockData;

   293     TPos pos = TLbaUtils::Pos(aLba);

   294     blockData.SetMax();

   295     TInt err = iRawDisk.Read(pos, blockData);

   296     return err;

   297     }

   298 

   299 

   300 CBlockDeviceTester* CBlockDeviceTester::NewL(TInt aDriveNumber)

   301     {

   302     __MSFNSLOG

   303 	CBlockDeviceTester* r = new (ELeave) CBlockDeviceTester(aDriveNumber);

   304 	CleanupStack::PushL(r);

   305 

   306 	r->ConstructL();

   307 	CleanupStack::Pop();

   308 	return r;

   309     }

   310 

   311 

   312 void CBlockDeviceTester::ConstructL()

   313     {

   314     __MSFNLOG

   315     TVolumeInfo volumeInfo;

   316 

   317     User::LeaveIfError(fsSession.Volume(volumeInfo, iDriveNumber));

   318     test.Printf(_L("Drive=%d Size = %lx\n"), iDriveNumber, volumeInfo.iSize);

   319     iDriveSizeInBlocks = volumeInfo.iSize / KBlockSize;

   320     iLocalBuffer.Init();

   321     iTargetDrive.OpenTestAreaL(iLocalBuffer.Buffer());

   322     }

   323 

   324 

   325 CBlockDeviceTester::CBlockDeviceTester(TInt aDriveNumber)

   326 :   iDriveNumber(aDriveNumber),

   327     iTargetDrive(aDriveNumber)

   328     {

   329     __MSFNLOG

   330     }

   331 

   332 

   333 CBlockDeviceTester::~CBlockDeviceTester()

   334     {

   335     __MSFNLOG

   336     iTargetDrive.Close();

   337     }

   338 

   339 

   340 void CBlockDeviceTester::OpenDriveL()

   341     {

   342     iTargetDrive.OpenL();

   343     }

   344 

   345 void CBlockDeviceTester::CloseDrive()

   346     {

   347     iTargetDrive.Close();

   348     }

   349 

   350 

   351 

   352 TInt CBlockDeviceTester::VerifyDrive()

   353     {

   354     __MSFNLOG

   355     return iTargetDrive.Verify();

   356     }

   357 

   358 

   359 TInt CBlockDeviceTester::Update(TPos aPos, TUint aLen)

   360     {

   361     __MSFNLOG

   362     iLocalBuffer.Update(aPos, aLen);

   363     return iTargetDrive.Update(aPos, aLen);

   364     }

   365 

   366 

   367 TInt CBlockDeviceTester::UpdateBlock(TLba aLba, TLba aBlocks)

   368     {

   369     __MSFNLOG

   370     return Update(TLbaUtils::Pos(aLba), TLbaUtils::Length(aBlocks));

   371     }

   372 

   373 

   374 TInt CBlockDeviceTester::Verify(TPos aPos, TUint aLen)

   375     {

   376     __MSFNLOG

   377     return iTargetDrive.Verify(aPos, aLen);

   378     }

   379 

   380 TInt CBlockDeviceTester::VerifyBlock(TLba aLba, TLba aBlocks)

   381     {

   382     __MSFNLOG

   383     return iTargetDrive.VerifyBlock(aLba, aBlocks);

   384     }

   385 

   386 /**

   387  * CBotTester

   388  */

   389 CBotTester* CBotTester::NewL(TInt aDriveNumber)

   390     {

   391     __MSFNSLOG

   392 	CBotTester* r = new (ELeave) CBotTester(aDriveNumber);

   393 	CleanupStack::PushL(r);

   394 

   395 	r->ConstructL();

   396 	CleanupStack::Pop();

   397 	return r;

   398     }

   399 

   400 

   401 void CBotTester::ConstructL()

   402     {

   403     __MSFNLOG

   404 

   405     CBlockDeviceTester::ConstructL();

   406 

   407     iCmdBuffer.Append(KTxtTestCaseOutPreamble);

   408     iCmdBuffer.Append(KTxtTestCase);

   409     iCmdBuffer.AppendFill('t', iCmdBuffer.MaxLength() - iCmdBuffer.Length());

   410 

   411     iOutEnableBuffer.Append(KTxtTestCaseOutPreamble);

   412     iOutEnableBuffer.Append(KTxtTestEnable);

   413     iOutEnableBuffer.AppendFill('o', iOutEnableBuffer.MaxLength() - iOutEnableBuffer.Length());

   414 

   415     iInEnableBuffer.Append(KTxtTestCaseInPreamble);

   416     iInEnableBuffer.Append(KTxtTestEnable);

   417     iInEnableBuffer.AppendFill('i', iInEnableBuffer.MaxLength() - iInEnableBuffer.Length());

   418     }

   419 

   420 

   421 CBotTester::CBotTester(TInt aDriveNumber)

   422 :   CBlockDeviceTester(aDriveNumber)

   423     {

   424     __MSFNLOG

   425     }

   426 

   427 

   428 CBotTester::~CBotTester()

   429     {

   430     __MSFNLOG

   431     iTargetDrive.Close();

   432     }

   433 

   434 

   435 TInt CBotTester::SetTest(TTestCase aTestCase)

   436     {

   437     __MSFNLOG

   438     iCmdBuffer[KTestCaseDataOffset] = static_cast<TUint8>(aTestCase);

   439 

   440     TPos pos = KSetTestPos;

   441     return iTargetDrive.MediaRawWrite(pos, iCmdBuffer);

   442     }

   443 

   444 

   445 TInt CBotTester::WriteEnableFile()

   446     {

   447     __MSFNLOG

   448     TPos pos = KWriteEnableFilePos;

   449     return iTargetDrive.MediaRawWrite(pos, iOutEnableBuffer);

   450     }

   451 

   452 

   453 TInt CBotTester::InitReadEnableFile()

   454     {

   455     __MSFNLOG

   456     TPos pos = KReadEnableFilePos;

   457     return iTargetDrive.MediaRawWrite(pos, iInEnableBuffer);

   458     }

   459 

   460 

   461 TInt CBotTester::ReadEnableFile()

   462     {

   463     __MSFNLOG

   464     TBuf8<KInEnableBufferSize> readBuf(KInEnableBufferSize);

   465     TPos pos = KReadEnableFilePos;

   466     return iTargetDrive.MediaRawRead(pos, readBuf.Size(), readBuf);

   467     }

   468 

   469 

   470 /**

   471  * CSbcErrTester

   472  */

   473 CSbcErrTester* CSbcErrTester::NewL(TInt aDriveNumber)

   474     {

   475     __MSFNSLOG

   476 	CSbcErrTester* r = new (ELeave) CSbcErrTester(aDriveNumber);

   477 	CleanupStack::PushL(r);

   478 

   479 	r->ConstructL();

   480 	CleanupStack::Pop();

   481 	return r;

   482     }

   483 

   484 

   485 void CSbcErrTester::ConstructL()

   486     {

   487     __MSFNLOG

   488 

   489     CBlockDeviceTester::ConstructL();

   490 

   491     iCmdBuffer.Append(KTxtTestCaseOutPreamble);

   492     iCmdBuffer.Append(KTxtTestCase);

   493     iCmdBuffer.AppendFill('t', iCmdBuffer.MaxLength() - iCmdBuffer.Length());

   494 

   495     iEnableBuffer.Append(KTxtTestCaseOutPreamble);

   496     iEnableBuffer.Append(KTxtTestEnable);

   497     iEnableBuffer.AppendFill('e', iEnableBuffer.MaxLength() - iEnableBuffer.Length());

   498 

   499     iSenseErrorBuffer.Append(KTxtTestCaseOutPreamble);

   500     iSenseErrorBuffer.Append(KTxtTestSenseError);

   501     iSenseErrorBuffer.AppendFill('s', iSenseErrorBuffer.MaxLength() - iSenseErrorBuffer.Length());

   502     }

   503 

   504 

   505 CSbcErrTester::CSbcErrTester(TInt aDriveNumber)

   506 :   CBlockDeviceTester(aDriveNumber)

   507     {

   508     __MSFNLOG

   509     }

   510 

   511 

   512 CSbcErrTester::~CSbcErrTester()

   513     {

   514     __MSFNLOG

   515     iTargetDrive.Close();

   516     }

   517 

   518 

   519 TInt CSbcErrTester::WriteTestFile()

   520     {

   521     __MSFNLOG

   522     TPos pos = KWriteTestFilePos;

   523     return iTargetDrive.MediaRawWrite(pos, iEnableBuffer);

   524     }

   525 

   526 

   527 TInt CSbcErrTester::ReadTestFile()

   528     {

   529     __MSFNLOG

   530     TBuf8<KEnableBufferSize> readBuf(KEnableBufferSize);

   531     TPos pos = KReadTestFilePos;

   532     TInt err = iTargetDrive.MediaRawRead(pos, readBuf.Size(), readBuf);

   533     return err;

   534     }

   535 

   536 

   537 TInt CSbcErrTester::WriteSenseErrorFile(TTestSenseError aTestSenseError)

   538     {

   539     __MSFNLOG

   540     iSenseErrorBuffer[KTestCaseDataOffset] = static_cast<TUint8>(aTestSenseError);

   541     TPos pos = KSenseErrorFile;

   542     return iTargetDrive.MediaRawWrite(pos, iSenseErrorBuffer);

   543     }

   544 

   545 

   546 CWrPrTester* CWrPrTester::NewL(TInt aDriveNumber)

   547     {

   548     __MSFNSLOG

   549 	CWrPrTester* r = new (ELeave) CWrPrTester(aDriveNumber);

   550 	CleanupStack::PushL(r);

   551 	r->ConstructL();

   552 	CleanupStack::Pop();

   553 	return r;

   554     }

   555 

   556 

   557 void CWrPrTester::ConstructL()

   558     {

   559     __MSFNLOG

   560     iCmdBuffer.Append(KTxtTestCaseOutPreamble);

   561     iCmdBuffer.Append(KTxtTestConfig);

   562     iCmdBuffer.AppendFill('c', iCmdBuffer.MaxLength() - iCmdBuffer.Length());

   563 

   564     iInCmdBuffer.Append(KTxtTestCaseInPreamble);

   565     iInCmdBuffer.Append(KTxtTestConfig);

   566     iInCmdBuffer.AppendFill('c', iInCmdBuffer.MaxLength() - iInCmdBuffer.Length());

   567 

   568     iTargetTestArea.CreateControlFile();

   569     iTargetTestArea.FindBlockStartL();

   570     }

   571 

   572 

   573 CWrPrTester::CWrPrTester(TInt aDriveNumber)

   574 :   iTargetMedia(aDriveNumber),

   575     iTargetTestArea(iTargetMedia)

   576     {

   577     __MSFNLOG

   578     }

   579 

   580 

   581 CWrPrTester::~CWrPrTester()

   582     {

   583     __MSFNLOG

   584     iTargetTestArea.RemoveControlFile();

   585     }

   586 

   587 

   588 void CWrPrTester::SetWriteProtectL()

   589     {

   590     __MSFNLOG

   591     // first write WrPr CLR Control block to media to enable setting to be

   592     // cleared

   593     iInCmdBuffer[KTestCaseDataOffset] = ETestConfigMediaWpClr;

   594     TInt err = iTargetTestArea.WriteBlockL(iInCmdBuffer);

   595     User::LeaveIfError(err);

   596 

   597     // Now write WrPr Set Control block to test client

   598     iCmdBuffer[KTestCaseDataOffset] = ETestConfigMediaWpSet;

   599     iTargetMedia.OpenL();

   600     err = iTargetMedia.MediaRawWrite(KCmdPos, iCmdBuffer);

   601     User::LeaveIfError(err);

   602     iTargetMedia.Close();

   603     }

   604 

   605 

   606 void CWrPrTester::ClrWriteProtectL()

   607     {

   608     __MSFNLOG

   609     test.Printf(_L("Clearing WRITE PROTECT"));

   610     TInt err = KErrNone;

   611     // Write protect so read the control file from the drive

   612     TBuf8<KCmdBufferSize> buffer;

   613     buffer.SetLength(KCmdBufferSize);

   614     iTargetTestArea.ReadBlockL(buffer);

   615 

   616     if (buffer != iInCmdBuffer)

   617         {

   618         err = KErrCorrupt;

   619         }

   620     User::LeaveIfError(err);

   621     }

   622 

   623 

   624 TInt CWrPrTester::SetRemovableL()

   625     {

   626     __MSFNLOG

   627     iCmdBuffer[KTestCaseDataOffset] = ETestConfigMediaRmbSet;

   628     iTargetMedia.OpenL();

   629     TInt err = iTargetMedia.MediaRawWrite(KCmdPos, iCmdBuffer);

   630     iTargetMedia.Close();

   631     return err;

   632     }

   633 

   634 TInt CWrPrTester::ClrRemovableL()

   635     {

   636     __MSFNLOG

   637     iCmdBuffer[KTestCaseDataOffset] = ETestConfigMediaRmbClr;

   638     iTargetMedia.OpenL();

   639     TInt err = iTargetMedia.MediaRawWrite(KCmdPos, iCmdBuffer);

   640     iTargetMedia.Close();

   641     return err;

   642     }

   643 

   644 

   645 TInt CWrPrTester::WriteReadTestL()

   646     {

   647     __MSFNLOG

   648     TInt err = KErrNone;

   649     TBuf8<KCmdBufferSize> wrBuffer;

   650 

   651     wrBuffer.SetMax();

   652     for (TInt i = 0; i < KCmdBufferSize; i++)

   653         {

   654         wrBuffer[i] = i;

   655         }

   656 

   657     err = iTargetTestArea.WriteBlockL(wrBuffer);

   658     if (err == KErrNone)

   659         {

   660         TBuf8<KCmdBufferSize> rdBuffer;

   661         rdBuffer.SetMax();

   662         err = iTargetTestArea.ReadBlockL(rdBuffer);

   663         User::LeaveIfError(err);

   664 

   665         if (wrBuffer != rdBuffer)

   666             {

   667             err = KErrCorrupt;

   668             }

   669         }

   670 

   671     if (err)

   672         {

   673         test.Printf(_L("WriteRead test returned %d\n"), err);

   674         }

   675     return err;

   676     }

   677 

   678 

   679