--- a/kerneltest/e32test/dmav2/t_dma2.cpp Tue Aug 31 16:34:26 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2851 +0,0 @@
-// Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).
-// All rights reserved.
-// This component and the accompanying materials are made available
-// under the terms of "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\dmav2\t_dma2.cpp
-
-#include "d_dma2.h"
-#include "u32std.h"
-#include "t_dma2.h"
-#include "cap_reqs.h"
-
-#define __E32TEST_EXTENSION__
-#include <e32test.h>
-#include <e32debug.h>
-#include <e32svr.h>
-#include <e32def_private.h>
-
-// DMA test framework command parameter options
-
-// SelfTest option
-_LIT(KArgSelfTest, "/SELFTEST");
-_LIT(KArgSelfTest2, "/S");
-
-//Verbose option
-_LIT(KArgVerboseOutput, "/VERBOSE");
-_LIT(KArgVerboseOutput2, "/V");
-
-//Simple transfer test option
-_LIT(KArgSimpleTest, "/simple");
-
-//Callback test option
-_LIT(KArgCallBackTest, "/callback");
-
-//Suspend test option
-_LIT(KArgSuspendTest, "/suspend");
-
-//Multipart transfer tests
-_LIT(KArgMultiPartTest, "/multi");
-
-//Isr and dfc test option
-_LIT(KArgIsrDfcTest, "/isrdfc");
-
-//Isr reque test option
-_LIT(KArgIsrequeTest, "/isreque");
-
-//Benchmark test option
-_LIT(KArgBenchmarkTest, "/bench");
-
-//Graphics test option
-_LIT(KArgGraphicTest, "/graphic");
-
-//DMA channel (opening and closing) test option
-_LIT(KArgChannelTest, "/channel");
-
-//Queue test option
-_LIT(KArgQueueTest, "/queue");
-
-//Fragment test option
-_LIT(KArgFragmentTest, "/fragment");
-
-//Request test option
-_LIT(KArgRequestTest, "/request");
-
-
-
-TBool gHelpRequested; // print usage
-TBool gVerboseOutput; // enable verbose output
-TBool gSelfTest; // run SelfTest
-TBool gSimpleTest; // run only Simple transfer test
-TBool gCallBack; // run only Callback test
-TBool gSuspend; // run only Pause and resume tests
-TBool gIsrReque; // run only IsrReque tests
-TBool gMultiPart; // run only Multipart tests
-TBool gIsrAndDfc; // run only IsrAndDfc tests
-TBool gBenchmark; // run only Benchmark tests
-TBool gGraphic; // run only Graphic tests
-TBool gFragment; // run only Fragment related tests
-TBool gChannel; // run only Channel(open/close)tests
-TBool gQueue; // run only Queue related tests
-TBool gRequest; // run only Request related tests
-
-/**
-This function prints out the PSL test Information
-*/
-void Print(const TDmaV2TestInfo& aInfo)
- {
- PRINT(aInfo.iMaxTransferSize);
- PRINT(aInfo.iMemAlignMask);
- PRINT(aInfo.iMemMemPslInfo);
- PRINT(aInfo.iMaxSbChannels);
- for(TInt i=0; i<aInfo.iMaxSbChannels; i++)
- {
- PRINT(aInfo.iSbChannels[i]);
- }
- PRINT(aInfo.iMaxDbChannels);
- for(TInt j=0; j<aInfo.iMaxDbChannels; j++)
- {
- PRINT(aInfo.iDbChannels[j]);
- }
- PRINT(aInfo.iMaxSgChannels);
- for(TInt k=0; k<aInfo.iMaxSgChannels; k++)
- {
- PRINT(aInfo.iSgChannels[k]);
- }
- }
-
-void CDmaTest::PrintTestInfo() const
- {
- TBuf<32> buf;
- buf.AppendFormat(_L("DMA channel %d"), iChannelCookie);
- RDebug::RawPrint(buf);
- }
-
-//////////////////////////////////////////////////////////////////////
-// CDmaTest
-//////////////////////////////////////////////////////////////////////
-
-void CDmaTest::OpenDmaSession()
- {
- // Only open a new session if one
- // was not already supplied
- if(iDmaSession.Handle() == KNullHandle)
- {
- TInt r = iDmaSession.Open();
- if(KErrNone != r)
- {
- RDebug::Printf("CDmaTest::OpenDmaSession = %d\n", r);
- }
- TEST_ASSERT(r == KErrNone);
- r = iDmaSession.OpenSharedChunk(iChunk);
- TEST_ASSERT(r == KErrNone);
- }
- }
-
-// Open another handle to the test driver
-void CDmaTest::OpenDmaSession(const RDmaSession& aSession)
- {
- iDmaSession = aSession;
- TInt r = iDmaSession.Duplicate(RThread(), EOwnerThread);
- TEST_ASSERT(r == KErrNone);
-
- // open another handle to the test driver chunk
- r = iDmaSession.OpenSharedChunk(iChunk);
- TEST_ASSERT(r == KErrNone);
- }
-
-void CDmaTest::CloseDmaSession()
- {
- iChunk.Close();
- iDmaSession.Close();
- }
-
-void CDmaTest::PreTransferSetup()
- {
- }
-
-TInt CDmaTest::DoPostTransferCheck()
- {
- return KErrNotSupported;
- }
-
-void CDmaTest::ChannelPause(TUint aChannelSessionCookie)
-{
- TInt r = iDmaSession.ChannelPause(aChannelSessionCookie);
- TEST_ASSERT(r == KErrNone);
-}
-
-void CDmaTest::ChannelResume(TUint aChannelSessionCookie)
-{
- TInt r = iDmaSession.ChannelResume(aChannelSessionCookie);
- TEST_ASSERT(r == KErrNone);
-}
-//////////////////////////////////////////////////////////////////////
-// CSingleTransferTest
-//////////////////////////////////////////////////////////////////////
-void CSingleTransferTest::RunTest()
- {
- OpenDmaSession();
- PreTransferSetup();
-
- OpenChannel();
- CreateDmaRequest();
- Fragment();
- Queue();
- FreeRequest();
- CloseChannel();
- PostTransferCheck();
-
- CloseDmaSession();
- }
-
-void CSingleTransferTest::OpenChannel()
- {
- iActual.iChannelOpenResult =
- iDmaSession.ChannelOpen(iChannelCookie, iChannelSessionCookie);
- }
-
-void CSingleTransferTest::CreateDmaRequest()
- {
- if(iUseNewRequest)
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("Calling New Request API\n");
- }
- iActual.iRequestResult.iCreate =
- iDmaSession.RequestCreate(iChannelSessionCookie, iRequestSessionCookie, iMaxFragmentSize);
- }
- else
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("Calling Old Request API\n");
- }
- iActual.iRequestResult.iCreate =
- iDmaSession.RequestCreateOld(iChannelSessionCookie, iRequestSessionCookie, iMaxFragmentSize);
- }
- }
-
-void CSingleTransferTest::Fragment()
- {
- if(iActual.iRequestResult.iCreate != KErrNone)
- return;
-
- if(iUseNewFragment)
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("Calling New Fragment API\n");
- }
- iActual.iRequestResult.iFragmentationResult =
- iDmaSession.FragmentRequest(iRequestSessionCookie, iTransferArgs);
- }
- else
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("Calling Old Fragment API\n");
- }
- iActual.iRequestResult.iFragmentationResult =
- iDmaSession.FragmentRequestOld(iRequestSessionCookie, iTransferArgs);
- }
-
- const TInt fragmentCount = iDmaSession.RequestFragmentCount(iRequestSessionCookie);
-
- // Record the fragment count if a non-zero value was expected,
- // or if it was an error value
- if(iExpected.iRequestResult.iFragmentCount != 0 || fragmentCount < 0)
- iActual.iRequestResult.iFragmentCount = fragmentCount;
- }
-
-void CSingleTransferTest::Queue()
- {
- if(iActual.iRequestResult.iFragmentationResult == KErrNone)
- {
- iActual.iRequestResult.iQueueResult = iDmaSession.QueueRequest(iRequestSessionCookie, &iActual.iCallbackRecord);
- }
- }
-
-void CSingleTransferTest::PostTransferCheck()
- {
- if(iPostTransferCheck)
- iActual.iPostTransferCheck = DoPostTransferCheck();
- }
-
-TInt CSingleTransferTest::DoPostTransferCheck()
- {
- return iPostTransferCheck->Check(*this);
- }
-
-void CSingleTransferTest::FreeRequest()
- {
- if(iActual.iRequestResult.iCreate == KErrNone)
- {
- TInt r = iDmaSession.RequestDestroy(iRequestSessionCookie);
- TEST_ASSERT(r == KErrNone);
- }
- }
-
-void CSingleTransferTest::CloseChannel()
- {
- if(iActual.iChannelOpenResult == KErrNone)
- {
- TInt r = iDmaSession.ChannelClose(iChannelSessionCookie);
- TEST_ASSERT(r == KErrNone);
- }
- }
-
-void CSingleTransferTest::PrintTestType() const
- {
- RDebug::RawPrint(_L("Single transfer"));
- }
-
-void CSingleTransferTest::PrintTestInfo() const
- {
- CDmaTest::PrintTestInfo();
-
- // State which API versions are being used
- if(iUseNewFragment)
- RDebug::RawPrint(_L(", Fragment v2,"));
- else
- RDebug::RawPrint(_L(", Fragment v1,"));
-
- if(iUseNewRequest)
- RDebug::RawPrint(_L(" DDmaRequest v2"));
- else
- RDebug::RawPrint(_L(" DDmaRequest v1"));
- }
-
-void CSingleTransferTest::PreTransferSetup()
- {
- if(iPreTransfer)
- iPreTransfer->Setup(*this); //initialize test
- }
-
-TBool CSingleTransferTest::Result()
- {
- const TBool result = iExpected == iActual;
- if(!result)
- {
- RDebug::Printf("TResultSets do not match");
- }
- if(!result || gVerboseOutput)
- {
- RDebug::Printf("\nExpected error codes:");
- iExpected.Print();
- RDebug::Printf("Expected callback record:");
- iExpected.iCallbackRecord.Print();
-
- RDebug::Printf("\nActual error codes:");
- iActual.Print();
- RDebug::Printf("Actual callback record:");
- iActual.iCallbackRecord.Print();
- }
- return result;
- }
-
-//////////////////////////////////////////////////////////////////////
-// CDmaTestDecorator
-//////////////////////////////////////////////////////////////////////
-
-CDmaTestDecorator::CDmaTestDecorator(CDmaTest* aDecoratedTest)
- : CDmaTest(_L("Decorated Test"), 1, NULL, NULL), iDecoratedTest(aDecoratedTest)
- {}
-
-CDmaTestDecorator::CDmaTestDecorator(const CDmaTestDecorator& aOther)
- : CDmaTest(aOther), iDecoratedTest( static_cast<CDmaTest*>( aOther.iDecoratedTest->Clone() ) )
- // Need cast because Clone does not have a covariant return type,
- // as not all compillers allow it
- {}
-
-//////////////////////////////////////////////////////////////////////
-// CMultiVersionTest
-//////////////////////////////////////////////////////////////////////
-
-CMultiVersionTest::CMultiVersionTest(CSingleTransferTest* aDmaTest)
- : CDmaTestDecorator(aDmaTest), iNewVersionTest(NULL)
- {
- }
-
-CMultiVersionTest::CMultiVersionTest(const CMultiVersionTest& aOther)
- : CDmaTestDecorator(aOther), iNewVersionTest( aOther.iNewVersionTest ? static_cast<CSingleTransferTest*>(aOther.iNewVersionTest->Clone()) : NULL)
- {
- }
-
-CMultiVersionTest::~CMultiVersionTest()
- {
- delete iDecoratedTest;
- delete iNewVersionTest;
- }
-
-void CMultiVersionTest::SetupL()
- {
- // Open a tempory dma session to find out the
- // capabilities of the dma channel.
- OpenDmaSession();
- Configure();
- CloseDmaSession();
- }
-
-void CMultiVersionTest::Announce() const
- {
- CTest::Announce();
-
- iDecoratedTest->Announce();
-
- if(iNewVersionTest)
- iNewVersionTest->Announce();
- }
-
-void CMultiVersionTest::PrintTestType() const
- {
- RDebug::RawPrint(_L("Multi version test wrapper"));
- }
-
-void CMultiVersionTest::PrintTestInfo() const
- {
- if(iNewVersionTest)
- {
- RDebug::RawPrint(_L("Running tests using Version 2 PIL"));
- }
- else
- {
- RDebug::RawPrint(_L("Running tests using Version 1 PIL"));
- }
- }
-
-void CMultiVersionTest::RunTest()
- {
- OpenDmaSession();
-
- // iDecoratedTest is the test, in the old configuration
- // iNewVersionTest is the same test, configured
- // to use the new APIs
- //
- // 2 objects are needed since they can each store
- // their own results
-
- iDecoratedTest->OpenDmaSession(iDmaSession);
- (*iDecoratedTest)();
-
- if(iNewVersionTest)
- {
- iNewVersionTest->OpenDmaSession(iDmaSession);
- (*iNewVersionTest)();
- }
-
- CloseDmaSession();
- }
-
-/**
-Maybe create another test object to run with new API
-
-Pass on the cookie for the channel they must test
-*/
-void CMultiVersionTest::Configure()
- {
- static_cast<CSingleTransferTest*>(iDecoratedTest)->UseNewDmaApi(EFalse);
- iDecoratedTest->SetChannelCookie(iChannelCookie);
-
- if(Version2PILAvailable())
- {
- iNewVersionTest = static_cast<CSingleTransferTest*>(iDecoratedTest->Clone());
- TEST_ASSERT(iNewVersionTest != NULL);
-
- iNewVersionTest->UseNewDmaApi(ETrue);
- iNewVersionTest->SetChannelCookie(iChannelCookie);
- }
- }
-
-/**
-Discover from DMA channel what PIL versions are available.
-In practice V1 APIs will always be available, V2 may be.
-*/
-TBool CMultiVersionTest::Version2PILAvailable()
- {
- TUint channelSessionCookie;
- TInt r = iDmaSession.ChannelOpen(iChannelCookie, channelSessionCookie);
- TEST_ASSERT(r == KErrNone);
-
- TDmacTestCaps channelCaps;
- r = iDmaSession.ChannelCaps(channelSessionCookie, channelCaps);
- TEST_ASSERT(r == KErrNone);
-
- r = iDmaSession.ChannelClose(channelSessionCookie);
- TEST_ASSERT(r == KErrNone);
-
- return channelCaps.iPILVersion >= 2;
- }
-
-TBool CMultiVersionTest::Result()
- {
- TBool v1Result = iDecoratedTest->Result();
- if(gVerboseOutput || !v1Result)
- RDebug::Printf("V1 API result: %s", v1Result ? "success" : "failure");
-
- TBool v2Result = iNewVersionTest ? iNewVersionTest->Result() : ETrue;
- if(gVerboseOutput || !v1Result)
- RDebug::Printf("V2 API result: %s", v2Result ? "success" : "failure");
- return v1Result && v2Result;
- }
-
-//////////////////////////////////////////////////////////////////////
-// CDmaBenchmark
-//////////////////////////////////////////////////////////////////////
-CDmaBenchmark::CDmaBenchmark(const TDesC& aName, TInt aIterations, const TResultSet& aExpectedResults, const TDmaTransferArgs& aTransferArgs, TUint aMaxFragmentSize)
- :CSingleTransferTest(aName, aIterations, aTransferArgs, aExpectedResults, aMaxFragmentSize, NULL, NULL)
- {
- UseNewDmaApi(EFalse);
- }
-
-CDmaBenchmark::CDmaBenchmark(const CDmaBenchmark& aOriginal)
- :CSingleTransferTest(aOriginal)
- {
- CopyL(aOriginal.iResultArray, iResultArray);
- }
-
-CDmaBenchmark::~CDmaBenchmark()
- {
- iResultArray.Close();
- }
-
-TUint64 CDmaBenchmark::MeanResult()
- {
- if(gVerboseOutput)
- RDebug::Printf("CDmaBenchmark::MeanResult\n");
-
- const TInt count = iResultArray.Count();
-
- TEST_ASSERT(count > 0);
- TEST_ASSERT(count == iIterations);
-
- TUint64 sum = 0;
-
- for(TInt i = 0; i < count; i++)
- {
- const TUint64 value = iResultArray[i];
- if(gVerboseOutput)
- RDebug::Printf("iResultArray[%d]: %lu", i, value);
-
- sum += value;
- }
-
- return sum / count;
- }
-
-TBool CDmaBenchmark::Result()
- {
- const TBool result = CSingleTransferTest::Result();
- if(result)
- {
- RDebug::Printf(" Mean time: %lu us", MeanResult());
- }
-
- return result;
- }
-
-//////////////////////////////////////////////////////////////////////
-// CDmaBmFragmentation
-//////////////////////////////////////////////////////////////////////
-CDmaBmFragmentation::CDmaBmFragmentation(const TDesC& aName, TInt aIterations, const TDmaTransferArgs& aTransferArgs, TUint aMaxFragmentSize)
- :CDmaBenchmark(aName, aIterations, ExpectedResults, aTransferArgs, aMaxFragmentSize)
- {}
-
-const TResultSet CDmaBmFragmentation::ExpectedResults(KErrNone,
- TRequestResults(KErrNone, 0, KErrNone, KErrUnknown),
- KErrUnknown,
- TCallbackRecord::Empty()
- );
-
-void CDmaBmFragmentation::Fragment()
- {
- TUint64 time;
- iActual.iRequestResult.iFragmentationResult =
- iDmaSession.FragmentRequestOld(iRequestSessionCookie, iTransferArgs, &time);
- iResultArray.Append(time);
- }
-
-void CDmaBmFragmentation::PrintTestType() const
- {
- RDebug::RawPrint(_L("Fragmentation Benchmark"));
- }
-
-void CDmaBmFragmentation::RunTest()
- {
- OpenDmaSession();
-
- OpenChannel();
- CreateDmaRequest();
- Fragment();
- FreeRequest();
- CloseChannel();
- CloseDmaSession();
- }
-
-//////////////////////////////////////////////////////////////////////
-// CPauseResumeTest
-//
-// -Time how long a given transfer takes
-// -Pause the channel
-// -repeat the transfer (queued asynchronously)
-// -wait for some time (say, 3 times the time measured)
-// -read the value of the TRequestStatus object, to check it is still pending
-// -resume the channel
-// -Wait on the request
-// -Confirm that the request completed
-//////////////////////////////////////////////////////////////////////
-CPauseResumeTest::~CPauseResumeTest()
- {
- }
-
-void CPauseResumeTest::RunTest()
- {
- OpenDmaSession();
-
- //Open a single DMA channel for a transfer
- OpenChannel();
-
- RDebug::Printf("Resume unpaused idle channel");
- TInt r = iDmaSession.ChannelResume(iChannelSessionCookie);
- TEST_ASSERT(KErrCompletion == r);
-
- RDebug::Printf("Pause idle channel");
- r = iDmaSession.ChannelPause(iChannelSessionCookie);
- TEST_ASSERT(KErrNone == r);
-
- RDebug::Printf("Pause paused idle Channel");
- r = iDmaSession.ChannelPause(iChannelSessionCookie);
- TEST_ASSERT(KErrCompletion == r);
-
- RDebug::Printf("Resume paused idle channel");
- r = iDmaSession.ChannelResume(iChannelSessionCookie);
- TEST_ASSERT(KErrNone == r);
-
- //Setup a DMA request and Fragment the request.
- CreateDmaRequest();
- Fragment();
-
- //Queue the DMA request and time how long a transfer takes
- TUint64 queueTime;
- DoCalibrationTransfer(queueTime);
-
- RDebug::Printf("Calibration transfer completed in %Lu us",queueTime);
- TUint32 waitQueueReqTime = I64LOW(queueTime*3); //3 times the time measured in DoCalibrationTransfer
- TEST_ASSERT(I64HIGH(queueTime*3) == 0); // If transfer takes over an hour, something has gone wrong anyway
-
- // Initialise buffers, after calibration transfer
- PreTransferSetup();
-
- RDebug::Printf("Resume unpaused channel");
- r = iDmaSession.ChannelResume(iChannelSessionCookie);
- TEST_ASSERT(KErrCompletion == r);
-
- //Pause DMA Transfer
- RDebug::Printf("Pausing DMA Channel");
- r = iDmaSession.ChannelPause(iChannelSessionCookie);
- TEST_ASSERT(KErrNone == r);
-
- RDebug::Printf("Pause paused Channel");
- r = iDmaSession.ChannelPause(iChannelSessionCookie);
- TEST_ASSERT(KErrCompletion == r);
-
- //Repeat the transfer (queued asynchronously)
- TRequestStatus queueRequestStatus;
- iActual.iRequestResult.iQueueResult = QueueAsyncRequest(queueRequestStatus,queueTime);
- RDebug::Printf("Queue a DMA Request and wait for %u us ", waitQueueReqTime);
-
- User::After(waitQueueReqTime);
- RDebug::Printf("Finished waiting");
- TEST_ASSERT(queueRequestStatus.Int() == KRequestPending);
-
- TBool queueEmpty = ETrue;
- r = iDmaSession.ChannelIsQueueEmpty(iChannelSessionCookie,queueEmpty);
- TEST_ASSERT(r == KErrNone);
- TEST_ASSERT(!queueEmpty);
-
- //Resume DMA channel
- RDebug::Printf("Resuming paused DMA Channel");
- r = iDmaSession.ChannelResume(iChannelSessionCookie);
- TEST_ASSERT(KErrNone == r);
-
- //Wait for transfer to complete
- User::WaitForRequest(queueRequestStatus);
- if (queueRequestStatus.Int() == KErrNone)
- {
- RDebug::Printf("DMA QueueAsyncRequest completed");
- }
-
- FreeRequest();
- CloseChannel();
-
- PostTransferCheck();
- CloseDmaSession();
- }
-
-/**
-Time how long transfer takes, with no pausing
-*/
-void CPauseResumeTest::DoCalibrationTransfer(TUint64 &atime)
- {
- //Queue the DMA request.
- TCallbackRecord pCallbackRecord;
- TInt r = iDmaSession.QueueRequest(iRequestSessionCookie,&pCallbackRecord,&atime);
- TEST_ASSERT(r == KErrNone);
- }
-
-TInt CPauseResumeTest::QueueAsyncRequest(TRequestStatus &aRequestState, TUint64 &atime)
- {
- return iDmaSession.QueueRequest(iRequestSessionCookie,aRequestState, &iActual.iCallbackRecord, &atime);
- }
-
-void CPauseResumeTest::PrintTestType() const
- {
- RDebug::RawPrint(_L("Pause and Resume API Test"));
- }
-
-//////////////////////////////////////////////////////////////////////
-// CPauseResumeNegTest
-//
-// -Open DMA Channel
-// -Pause and Resume DMA channel
-// -Check that KErrNotSupported is returned
-// -Close DMA Channel
-//////////////////////////////////////////////////////////////////////
-CPauseResumeNegTest::~CPauseResumeNegTest()
- {
- }
-
-void CPauseResumeNegTest::RunTest()
- {
- OpenDmaSession();
-
- //Open a single DMA channel for a transfer
- OpenChannel();
-
- RDebug::Printf("Resume unpaused idle channel");
- TInt r = iDmaSession.ChannelResume(iChannelSessionCookie);
- TEST_ASSERT(KErrNotSupported == r);
-
- RDebug::Printf("Pause idle channel");
- r = iDmaSession.ChannelPause(iChannelSessionCookie);
- TEST_ASSERT(KErrNotSupported == r);
-
- RDebug::Printf("Pause paused idle Channel");
- r = iDmaSession.ChannelPause(iChannelSessionCookie);
- TEST_ASSERT(KErrNotSupported == r);
-
- RDebug::Printf("Resume paused idle channel");
- r = iDmaSession.ChannelResume(iChannelSessionCookie);
- TEST_ASSERT(KErrNotSupported == r);
-
- CloseChannel();
- CloseDmaSession();
- }
-
-void CPauseResumeNegTest::PrintTestType() const
- {
- RDebug::RawPrint(_L("Pause and Resume API Test - Negative Test"));
- }
-
-//////////////////////////////////////////////////////////////////////
-// CLinkChannelTest
-//
-// -Open DMA Channel
-// -Link and Unlink DMA channel
-// -Check that KErrNotSupported is returned
-// -Close DMA Channel
-//
-//////////////////////////////////////////////////////////////////////
-CLinkChannelTest::~CLinkChannelTest()
- {
- }
-
-void CLinkChannelTest::RunTest()
- {
- OpenDmaSession();
-
- //Open a single DMA channel for a transfer
- OpenChannel();
-
- RDebug::Printf("Linking DMA channels");
- TInt r = iDmaSession.ChannelLinking(iChannelSessionCookie);
- TEST_ASSERT(KErrNotSupported == r);
-
- RDebug::Printf("Unlinking DMA channels");
- r = iDmaSession.ChannelUnLinking(iChannelSessionCookie);
- TEST_ASSERT(KErrNotSupported == r);
-
- CloseChannel();
- CloseDmaSession();
- }
-
-void CLinkChannelTest::PrintTestType() const
- {
- RDebug::RawPrint(_L("Channel Linking API Test - Negative Test"));
- }
-
-//////////////////////////////////////////////////////////////////////
-// CElementCountingTest
-//
-// -Open DMA Channel
-// -Create Request
-// -Fragment and Make calls to Element Counting APIs
-// -Check that TotalNumDstElementsTransferred() and TotalNumSrcElementsTransferred()
-// return non zero values
-// -Check that KErrNone(from test driver) returned for other API calls
-// -Queue Request
-// -Close DMA Channel
-//////////////////////////////////////////////////////////////////////
-CElementCountingTest::~CElementCountingTest()
- {
- }
-
-void CElementCountingTest::RunTest()
- {
- OpenDmaSession();
- PreTransferSetup();
-
- //Open a single DMA channel for a transfer
- OpenChannel();
-
- //Setup a DMA request and Fragment the request.
- RDebug::Printf("Create and Fragment DMA Request");
- CreateDmaRequest();
- Fragment();
-
- //Enable src/dst counting
- RDebug::Printf("Enable DstElementCounting");
- TInt r = iDmaSession.RequestEnableDstElementCounting(iRequestSessionCookie);
- TEST_ASSERT(KErrNone == r);
-
- RDebug::Printf("Enable SrcElementCounting");
- r = iDmaSession.RequestEnableSrcElementCounting(iRequestSessionCookie);
- TEST_ASSERT(KErrNone == r);
-
- //Queue request
- RDebug::Printf("Queue DMA Request");
- Queue();
-
- //Disable src/dst counting
- RDebug::Printf("Disable DstElementCounting");
- r = iDmaSession.RequestDisableDstElementCounting(iRequestSessionCookie);
- TEST_ASSERT(KErrNone == r);
-
- RDebug::Printf("Disable SrcElementCounting");
- r = iDmaSession.RequestDisableSrcElementCounting(iRequestSessionCookie);
- TEST_ASSERT(KErrNone == r);
-
- //check total src/dst elements transferred
- RDebug::Printf("Get Total Number of DstElementsTransferred");
- r = iDmaSession.RequestTotalNumDstElementsTransferred(iRequestSessionCookie);
- TEST_ASSERT(r >= 0);
-
- RDebug::Printf("Get Total Number of SrcElementsTransferred");
- r = iDmaSession.RequestTotalNumSrcElementsTransferred(iRequestSessionCookie);
- TEST_ASSERT(r >= 0);
-
- FreeRequest();
- CloseChannel();
-
- PostTransferCheck();
- CloseDmaSession();
- }
-
-void CElementCountingTest::PrintTestType() const
- {
- RDebug::RawPrint(_L("Element Counting Tests"));
- }
-
-//////////////////////////////////////////////////////////////////////
-// COpenCloseTest
-//////////////////////////////////////////////////////////////////////
-COpenCloseTest::~COpenCloseTest()
- {
- }
-
-TBool COpenCloseTest::DoRunClose()
- {
- // For storing cookie during neagtive test i,e open channel twice
- TUint testChannelSessionCookie = 0;
-
- // Open a single DMA channel
- TInt r = iDmaSession.ChannelOpen(iChannelCookie, iChannelSessionCookie);
- if (r == KErrNone)//Check that DMA channel opened with no errors
- {
- RDebug::Printf("DMA channel opened");
- }
- else
- {
- RDebug::Printf("Open DMA channel failed");
- return EFalse;
- }
-
- // Open DMA channel again and check that opening DMA channel again fails
- r = iDmaSession.ChannelOpen(iChannelCookie, testChannelSessionCookie);
- if (r == KErrInUse)
- {
- RDebug::Printf("Opening DMA channel again fails as expected");
- }
- else
- {
- RDebug::Printf("Open DMA channel again failed");
- return EFalse;
- }
-
- // Close the DMA channel and check that DMA channel closes with no errors
- r =iDmaSession.ChannelClose(iChannelSessionCookie);
- if (r == KErrNone)
- {
- RDebug::Printf("DMA channel closes with no errors");
- }
- else
- {
- RDebug::Printf("Close the DMA channel failed");
- return EFalse;
- }
-
- // Verify that the DMA channel was actually closed by opening DMA channel
- r = iDmaSession.ChannelOpen(iChannelCookie, iChannelSessionCookie);
- if (r == KErrNone)
- {
- RDebug::Printf("DMA channel opened after a previous close operation");
- return ETrue;
- }
- else
- {
- RDebug::Printf("Open DMA channel to verify that the DMA channel closed failed");
- return EFalse;
- }
- }
-
-TBool COpenCloseTest::DoRunOpen()
- {
- // Open a single DMA channel
- TInt r = iDmaSession.ChannelOpen(iChannelCookie, iChannelSessionCookie);
- if (r == KErrNone)//Check that DMA channel opened with no errors
- {
- RDebug::Printf("DoRunOpen:DMA channel opened");
- }
- else
- {
- RDebug::Printf("DoRunOpenDMA channel failed to open");
- return EFalse;
- }
-
- // Verify that channel is really open by closing DMA channel
- // and checking that DMA channel closes with no errors
- r = iDmaSession.ChannelClose(iChannelSessionCookie);
- if (r == KErrNone)
- {
- RDebug::Printf("DoRunOpen:DMA channel closes with no errors");
- return ETrue;
- }
- else
- {
- RDebug::Printf("DoRunOpen:DMA channel failed to close");
- return EFalse;
- }
- }
-
-TBool COpenCloseTest::DoRunOpenExposed()
- {
- SCreateInfoTest TOpenInfo;
- TOpenInfo.iCookie =iChannelCookie;
- TOpenInfo.iDfcPriority = 3;
-
- const TInt desCount[3] = {0,1,128};
- const TBool dynChannel[3] = {EFalse,EFalse,ETrue};
- const TInt expectedResults[3] = {KErrArgument,KErrNone,KErrInUse};
- TInt actualResults[3] = {1, 1, 1};
-
- for (TInt i =0; i<3; i++)
- {
- TOpenInfo.iDesCount = desCount[i];
- TOpenInfo.iDynChannel = dynChannel[i];
-
- // Open a single DMA channel
- RDebug::Printf("DoRunOpenExposed:Trying to open DMA channel using iDesCount(%d) and iDynChannel(%d) ", TOpenInfo.iDesCount,TOpenInfo.iDynChannel);
- actualResults[i] = iDmaSession.ChannelOpen(iChannelSessionCookie, TOpenInfo);
- if (actualResults[i] == KErrNone)// Verify that channel is really open by closing DMA channel
- {
- TInt err = iDmaSession.ChannelClose(iChannelSessionCookie);
- TEST_ASSERT(err == KErrNone)//Check that DMA channel closed with no errors
- }
- }
-
- // This case should fail if idesCount = 0.
- // PIL has been changed to return KErrArgument instead of using an assertion check
- if (expectedResults[0] == actualResults[0])
- {
- RDebug::Printf("DoRunOpenExposed:DMA channel failed to open as expected as for iDesCount = 0 ");
- }
- else
- {
- RDebug::Printf("DoRunOpenExposed:Error code returned (%d), expected KErrArgument as iDesCount= 0) ", actualResults[0]);
- return EFalse;
- }
-
- // For this case( idesCount = 1), DMA channel should open with no issues
- if (expectedResults[1] == actualResults[1])
- {
- RDebug::Printf("DoRunOpenExposed:DMA channel closes with no errors as expected for iDesCount = 1 ");
- }
- else
- {
- RDebug::Printf("DoRunOpenExposed:Failed to open DMA channel with error code (%d)", actualResults[1]);
- return EFalse;
- }
-
- // For this case(dynaChannel=ETrue), DMA channel now returns KErrInUse. dynaChannel is not supported in the PSL.
- // PSL now returns a NULL pointer when dynaChannel is requested. The PIL interprets a NULL
- // pointer being returned from opening a DMA channel as a channel in use. Hence, KErrInUse is returned.
- if (expectedResults[2] == actualResults[2])
- {
- RDebug::Printf("DoRunOpenExposed:DMA channel failed to open as expected as dynamic channel is not supported");
- }
- else
- {
- RDebug::Printf("DoRunOpenExposed:Error code returned (%d), expected KErrInUse as as dynamic channel is not supported", actualResults[2]);
- return EFalse;
- }
-
- return ETrue;
- }
-
-void COpenCloseTest::RunTest()
- {
- OpenDmaSession();
-
- if (iRunOpen)
- { // Run Open() API test
- iOpenCloseResult = DoRunOpenExposed();
- if(iOpenCloseResult)
- iOpenCloseResult = DoRunOpen();
- }
- else
- {
- // Run Close() API test
- iOpenCloseResult = DoRunClose();
- }
-
- CloseDmaSession();
- }
-
-void COpenCloseTest::PrintTestType() const
- {
- RDebug::RawPrint(_L("Close/Open API Test"));
-
- }
-
-TBool COpenCloseTest::Result()
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("Results for Close/Open API Test");
- }
-
- if(!iOpenCloseResult)
- {
- RDebug::Printf("Open/Close test sequence failed");
- }
-
- return iOpenCloseResult;
- }
-//////////////////////////////////////////////////////////////////////
-// CDmaBmTransfer
-//////////////////////////////////////////////////////////////////////
-CDmaBmTransfer::CDmaBmTransfer(const TDesC& aName, TInt aIterations, const TDmaTransferArgs& aTransferArgs, TUint aMaxFragmentSize)
- :CDmaBenchmark(aName, aIterations,
- TResultSet(KErrNone, TRequestResults(), KErrUnknown, TCallbackRecord(TCallbackRecord::EThread,1)),
- aTransferArgs, aMaxFragmentSize)
- {}
-
-void CDmaBmTransfer::PrintTestType() const
- {
- RDebug::RawPrint(_L("Transfer Benchmark"));
- }
-
-void CDmaBmTransfer::RunTest()
- {
- OpenDmaSession();
-
- OpenChannel();
- CreateDmaRequest();
- Fragment();
- Queue();
- FreeRequest();
- CloseChannel();
-
- CloseDmaSession();
- }
-
-void CDmaBmTransfer::Queue()
- {
- if(iActual.iRequestResult.iFragmentationResult == KErrNone)
- {
- TUint64 time;
- iActual.iRequestResult.iQueueResult = iDmaSession.QueueRequest(iRequestSessionCookie, &iActual.iCallbackRecord, &time);
- iResultArray.Append(time);
- }
- }
-
-/*
-1. Open a DMA channel for a transfer.
-2. Queue multiple request on the DMA channel.
-3. Call CancelAll () on the DMA channel.
-4. Verify that all transfers have been cancelled.
-5. Open a DMA channel for a transfer. This channel should support pause and resume.
-6. Call Pause () on the channel.
-7. Queue multiple request on the DMA channel.
-8. Call CancelAll () on the channel.
-9. Verify that all transfers have been cancelled.
-
- Note: This check does not add results to TResultSet like some
- other tests as its operation is different. The test checks for
- the the cancelllation of all transfers queued on a channel by
- calling iDmaSession.ChannelIsQueueEmpty();
-*/
-
-//////////////////////////////////////////////////////////////////////
-// CCancelAllTest
-//////////////////////////////////////////////////////////////////////
-
-
-CCancelAllTest::CCancelAllTest(const TDesC& aName, TInt aIterations,
- const TDmaTransferArgs* aTransferArgs, const TResultSet* aResultSets,
- TInt aCount)
- :CMultiTransferTest(aName, aIterations, aTransferArgs, aResultSets, aCount)
- {}
-
-void CCancelAllTest::RunTest()
- {
- OpenDmaSession();
- PreTransferSetup();
-
- // Open a DMA channel for a transfer.This channel should support pause and resume.
- OpenChannel();
-
- //Call Pause () on the channel
- RDebug::Printf("Pausing DMA Channel");
- ChannelPause(iChannelSessionCookie);
-
- // Queue multiple request on the DMA channel.
- CreateDmaRequests();
- Fragment();
-
- QueueRequestsAsync();
-
- // Call CancelAll () on the DMA channel and Verify that all transfers have been cancelled.
- TInt r = CancelAllRequests();
- TEST_ASSERT(r == KErrNone);
-
- //Call Resume () on the channel.
- RDebug::Printf("Cancel should clear Pause state: resuming channel should fail");
- ChannelResume(iChannelSessionCookie);
- //TEST_ASSERT(r == KErrCompletion);
-
- r = DoPostTransferCheck();
- TEST_ASSERT(r == KErrNone);
- //Destroy request
- for(TInt i=0; i<2; i++)
- {
- r = iDmaSession.RequestDestroy(iRequestCookies[i]);
- TEST_ASSERT(r == KErrNone);
- }
-
- //Close DMA channel
- CloseChannel();
-
- CloseDmaSession();
- }
-
-TInt CCancelAllTest::CancelAllRequests()
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("CCancelAllTest::CancelAllRequests()");
- }
- TInt r = KErrGeneral;
- r = iDmaSession.ChannelCancelAll(iChannelSessionCookie);
- if (r != KErrNone)
- return r;
-
- TBool queueEmpty;
- r = iDmaSession.ChannelIsQueueEmpty(iChannelSessionCookie,queueEmpty);
- if (r != KErrNone)
- return r;
-
- if(!queueEmpty)
- return KErrGeneral;
-
- if(gVerboseOutput)
- {
- RDebug::Printf("Both current and pending requests cancelled");
- }
- return KErrNone;
- }
-
-void CCancelAllTest::PrintTestType() const
- {
- RDebug::RawPrint(_L("CCancelAllTest"));
- }
-
-void CCancelAllTest::QueueRequestsAsync()
- {
- if(iPauseWhileQueuing)
- {
- TInt r = iDmaSession.ChannelPause(iChannelSessionCookie);
- TEST_ASSERT(r == KErrNone);
- }
-
- // Queue all the DMA requests asynchronously
- TEST_ASSERT(iActualResults.Count() == iTransferArgsCount);
- for(TInt i=0; i<iTransferArgsCount; i++)
- {
- TResultSet& resultSet = iActualResults[i];
- if(resultSet.iRequestResult.iFragmentationResult != KErrNone)
- continue;
-
- TInt r = iDmaSession.QueueRequest(iRequestCookies[i], iDummyRequestStatus, &resultSet.iCallbackRecord, NULL);
- resultSet.iRequestResult.iQueueResult = r;
- }
-
- if(iPauseWhileQueuing)
- {
- TInt r = iDmaSession.ChannelResume(iChannelSessionCookie);
- TEST_ASSERT(r == KErrNone);
- }
- }
-
-//////////////////////////////////////////////////////////////////////
-// CIsQueueEmptyTest
-//////////////////////////////////////////////////////////////////////
-CIsQueueEmptyTest::CIsQueueEmptyTest(const TDesC& aName, TInt aIterations, const TDmaTransferArgs* aTransferArgs,
- const TResultSet* aResultSets, TInt aCount)
- :CMultiTransferTest(aName, aIterations, aTransferArgs, aResultSets, aCount)
- {}
-
-CIsQueueEmptyTest::CIsQueueEmptyTest(const CIsQueueEmptyTest& aOther)
- :CMultiTransferTest(aOther)
- {}
-
-CIsQueueEmptyTest::~CIsQueueEmptyTest()
- {
- }
-
-void CIsQueueEmptyTest::RunTest()
- {
- OpenDmaSession();
- PreTransferSetup();
-
- OpenChannel();
-
- CreateDmaRequests();
- Fragment();
- QueueRequests();
-
- TInt r = DoPostTransferCheck();
- TEST_ASSERT(r == KErrNone);
-
- CloseDmaSession();
- }
-
-void CIsQueueEmptyTest::DoIsQueueEmpty()
- {
- TBool queueEmpty;
- TInt r = iDmaSession.ChannelIsQueueEmpty(iChannelSessionCookie,queueEmpty);
- TEST_ASSERT(r == KErrNone);
-
- if(queueEmpty)
- {
- RDebug::Printf("Verified that calling IsQueueEmpty() returns ETrue before calling Queue()");
- }
- else
- {
- RDebug::Printf("IsQueueEmpty() fails to return ETrue before calling Queue()");
- TEST_ASSERT(queueEmpty);
- }
- }
-
-void CIsQueueEmptyTest::DoQueueNotEmpty()
- {
- TBool queueEmpty;
- TInt r = iDmaSession.ChannelIsQueueEmpty(iChannelSessionCookie,queueEmpty);
- TEST_ASSERT(r == KErrNone);
-
- if (!queueEmpty)
- {
- RDebug::Printf("Verified that calling IsQueueEmpty() returns EFalse after calling Queue()");
- }
- else
- {
- RDebug::Printf("IsQueueEmpty() fails to return EFalse after calling Queue()");
- TEST_ASSERT(!queueEmpty);
- }
- }
-
-void CIsQueueEmptyTest::PrintTestType() const
- {
- RDebug::RawPrint(_L("IsQueue Empty Test using Multi Transfer"));
- }
-
-void CIsQueueEmptyTest::QueueRequests()
- {
- // Queue all the DMA requests asynchronously
- TInt i;
- RArray<TRequestStatus> requestStates;
-
- ChannelPause(iChannelSessionCookie);
- DoIsQueueEmpty();
-
- TEST_ASSERT(iActualResults.Count() == iTransferArgsCount);
- for(i=0; i<iTransferArgsCount; i++)
- {
- TResultSet& resultSet = iActualResults[i];
- if(resultSet.iRequestResult.iFragmentationResult != KErrNone)
- continue;
-
- TInt r = requestStates.Append(TRequestStatus());
- TEST_ASSERT(r == KErrNone);
-
- r = iDmaSession.QueueRequest(iRequestCookies[i], requestStates[i], &resultSet.iCallbackRecord, NULL);
- resultSet.iRequestResult.iQueueResult = r;
-
- DoQueueNotEmpty();
- }
-
- ChannelResume(iChannelSessionCookie);
-
- // wait for all transfers to complete
- const TInt count = requestStates.Count();
-
- for(i=0; i<count; i++)
- {
- User::WaitForRequest(requestStates[i]);
- }
-
- requestStates.Close();
- }
-
-//////////////////////////////////////////////////////////////////////
-// CMultiTransferTest
-//////////////////////////////////////////////////////////////////////
-CMultiTransferTest::CMultiTransferTest(const TDesC& aName, TInt aIterations, const TDmaTransferArgs* aTransferArgs,
- const TResultSet* aResultSets, TInt aCount)
- : CDmaTest(aName, aIterations, NULL, NULL), iTransferArgs(aTransferArgs), iTransferArgsCount(aCount), iNewDmaApi(ETrue),
- iChannelSessionCookie(0), iExpectedArray(aResultSets), iPauseWhileQueuing(EFalse)
- {}
-
-CMultiTransferTest::CMultiTransferTest(const CMultiTransferTest& aOther)
- : CDmaTest(aOther), iTransferArgs(aOther.iTransferArgs), iTransferArgsCount(aOther.iTransferArgsCount),
- iNewDmaApi(aOther.iNewDmaApi),
- iExpectedArray(aOther.iExpectedArray), iPauseWhileQueuing(aOther.iPauseWhileQueuing)
- {
- CopyL(aOther.iRequestCookies, iRequestCookies);
- }
-
-CMultiTransferTest::~CMultiTransferTest()
- {
- iRequestCookies.Close();
- iActualResults.Close();
- }
-
-TBool CMultiTransferTest::Result()
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("Results for %d transfers:", iTransferArgsCount);
- }
-
- TBool result = EFalse;
- for(TInt i=0; i<iTransferArgsCount; i++)
- {
- result = Result(i);
- if(!result)
- break;
- }
- return result;
- }
-
-TBool CMultiTransferTest::Result(TInt aTransfer)
- {
- const TResultSet& expected = iExpectedArray[aTransfer];
- const TResultSet& actual = iActualResults[aTransfer];
- const TBool result = expected == actual;
- if(!result || gVerboseOutput)
- {
- RDebug::Printf("Compairing results for transfer %d", aTransfer);
- }
-
- if(!result)
- {
- RDebug::Printf("TResultSets do not match");
- }
- if(!result || gVerboseOutput)
- {
- RDebug::Printf("\nExpected error codes:");
- expected.Print();
- RDebug::Printf("Expected callback record:");
- expected.iCallbackRecord.Print();
-
- RDebug::Printf("\nActual error codes:");
- actual.Print();
- RDebug::Printf("Actual callback record:");
- actual.iCallbackRecord.Print();
- }
- return result;
- }
-void CMultiTransferTest::RunTest()
- {
- OpenDmaSession();
-
- PreTransferSetup();
- OpenChannel();
-
- CreateDmaRequests();
- Fragment();
-
- QueueRequests();
-
- TInt r = DoPostTransferCheck();
- TEST_ASSERT(r == KErrNone);
-
- CloseDmaSession();
- }
-
-void CMultiTransferTest::PrintTestType() const
- {
- RDebug::RawPrint(_L("Multi Transfer"));
- }
-
-const TDmaTransferArgs& CMultiTransferTest::TransferArgs(TInt aIndex) const
- {
- TEST_ASSERT(Rng(0, aIndex, iTransferArgsCount-1));
-
- return iTransferArgs[aIndex];
- }
-
-void CMultiTransferTest::SetPostTransferResult(TInt aIndex, TInt aErrorCode)
- {
- TEST_ASSERT(Rng(0, aIndex, iTransferArgsCount-1));
-
- iActualResults[aIndex].iPostTransferCheck = aErrorCode;
- }
-
-void CMultiTransferTest::OpenChannel()
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("CMultiTransferTest::OpenChannel()");
- }
- TInt r = iDmaSession.ChannelOpen(iChannelCookie, iChannelSessionCookie);
-
- TEST_ASSERT(iActualResults.Count() == iTransferArgsCount);
- for(TInt i=0; i<iTransferArgsCount; i++)
- {
- // In a multi transfer test a series of requests are created and queued.
- // They all use the same channel, is opened here at the beginning of the test
- //
- // Each transfer has a TResultSet which holds a result for the channel opening,
- // which we store here. Although in this case it is redundant,
- // in future it might be that different transfers open
- // different channels.
- iActualResults[i].iChannelOpenResult = r;
- }
- }
-
-TInt CMultiTransferTest::CloseChannel()
- {
- return iDmaSession.ChannelClose(iChannelSessionCookie);
- }
-
-void CMultiTransferTest::CreateDmaRequests()
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("CMultiTransferTest::CreateDmaRequests() %d", iTransferArgsCount);
- }
- TEST_ASSERT(iActualResults.Count() == iTransferArgsCount);
- //create a DMA request for each transfer arg struct
- for(TInt i=0; i<iTransferArgsCount; i++)
- {
- if(iActualResults[i].iChannelOpenResult != KErrNone)
- continue;
-
- TUint cookie = 0;
- TInt r = KErrGeneral;
-
- if(iNewDmaApi)
- {
- r = iDmaSession.RequestCreate(iChannelSessionCookie, cookie);
- }
- else
- {
- r = iDmaSession.RequestCreateOld(iChannelSessionCookie, cookie);
- }
- iActualResults[i].iRequestResult.iCreate = r;
-
- if(r == KErrNone)
- {
- r = iRequestCookies.Append(cookie);
- TEST_ASSERT(r == KErrNone);
- }
- }
- }
-
-void CMultiTransferTest::Fragment()
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("CMultiTransferTest::Fragment() %d", iTransferArgsCount);
- }
- TEST_ASSERT(iActualResults.Count() == iTransferArgsCount);
- // Fragment each dma request
- for(TInt i=0; i<iTransferArgsCount; i++)
- {
- TRequestResults& result = iActualResults[i].iRequestResult;
- if(result.iCreate != KErrNone)
- continue;
-
- TInt r = KErrGeneral;
- if(iNewDmaApi)
- r = iDmaSession.FragmentRequest(iRequestCookies[i], iTransferArgs[i]);
- else
- r = iDmaSession.FragmentRequestOld(iRequestCookies[i], iTransferArgs[i]);
-
- result.iFragmentationResult = r;
- }
- }
-
-void CMultiTransferTest::QueueRequests()
- {
- if(iPauseWhileQueuing)
- {
- TInt r = iDmaSession.ChannelPause(iChannelSessionCookie);
- TEST_ASSERT(r == KErrNone);
- }
-
- // Queue all the DMA requests asynchronously
- TInt i;
- RArray<TRequestStatus> requestStates;
-
- TEST_ASSERT(iActualResults.Count() == iTransferArgsCount);
- for(i=0; i<iTransferArgsCount; i++)
- {
- TResultSet& resultSet = iActualResults[i];
- if(resultSet.iRequestResult.iFragmentationResult != KErrNone)
- continue;
-
- TInt r = requestStates.Append(TRequestStatus());
- TEST_ASSERT(r == KErrNone);
-
- r = iDmaSession.QueueRequest(iRequestCookies[i], requestStates[i], &resultSet.iCallbackRecord, NULL);
- resultSet.iRequestResult.iQueueResult = r;
- }
-
- if(iPauseWhileQueuing)
- {
- TInt r = iDmaSession.ChannelResume(iChannelSessionCookie);
- TEST_ASSERT(r == KErrNone);
- }
-
- // wait for all transfers to complete
- const TInt count = requestStates.Count();
-
- for(i=0; i<count; i++)
- {
- User::WaitForRequest(requestStates[i]);
- }
-
- requestStates.Close();
- }
-
-void CMultiTransferTest::PreTransferSetup()
- {
- // TODO this is the wrong place to do this!
- for(TInt i=0; i<iTransferArgsCount; i++)
- {
- //pre-fill actual results with error values
- TInt r = iActualResults.Append(TResultSet(EFalse));
- TEST_ASSERT(r == KErrNone);
- }
- if(iPreTransfer)
- iPreTransfer->Setup(*this); //initialize test
- }
-
-TInt CMultiTransferTest::DoPostTransferCheck()
- {
- if(iPostTransferCheck)
- return iPostTransferCheck->Check(*this);
- else
- return KErrNone;
- }
-//////////////////////////////////////////////////////////////////////
-// CIsrRequeTest
-//////////////////////////////////////////////////////////////////////
-CIsrRequeTest::CIsrRequeTest(const TDesC& aName, TInt aIterations, const TDmaTransferArgs& aArgs,
- TIsrRequeArgs* aRequeueArgs, TInt aCount,
- const TResultSet& aExpected,const MPreTransfer* aPreTfer,const MPostTransferCheck* aPostTferChk, TUint aMaxFragmentSize)
- :CSingleTransferTest(aName, aIterations, aArgs, aExpected, aMaxFragmentSize, aPostTferChk, aPreTfer), iRequeArgSet(aRequeueArgs, aCount)
- {}
-
-void CIsrRequeTest::Queue()
- {
- if(iActual.iRequestResult.iFragmentationResult == KErrNone)
- {
- iActual.iRequestResult.iQueueResult = iDmaSession.QueueRequestWithRequeue(iRequestSessionCookie, iRequeArgSet.iRequeArgs, iRequeArgSet.iCount, &iActual.iCallbackRecord);
- }
- }
-
-void CIsrRequeTest::PrintTestType() const
- {
- RDebug::RawPrint(_L("ISR Requeue"));
- }
-
-void CIsrRequeTest::PreTransferSetup()
- {
- if(iPreTransfer)
- iPreTransfer->Setup(*this); //initialize test
- }
-
-TInt CIsrRequeTest::DoPostTransferCheck()
- {
- return iPostTransferCheck->Check(*this);
- }
-
-//////////////////////////////////////////////////////////////////////
-// TResultSet
-//////////////////////////////////////////////////////////////////////
-void TResultSet::Print() const
- {
- PRINT(iChannelOpenResult);
- PRINT(iRequestResult.iCreate);
- PRINT(iRequestResult.iFragmentCount);
- PRINT(iRequestResult.iFragmentationResult);
- PRINT(iRequestResult.iQueueResult);
- PRINT(iPostTransferCheck);
- }
-
-TBool TResultSet::operator == (const TResultSet& aOther) const
- {
- return (memcompare((TUint8*)this, sizeof(*this), (TUint8*)&aOther, sizeof(aOther)) == 0);
- }
-
-//////////////////////////////////////////////////////////////////////
-// MPostTransferCheck classes
-//////////////////////////////////////////////////////////////////////
-TInt TCompareSrcDst::Check(const CSingleTransferTest& aTest) const
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("Comparing CSingleTransferTest buffers");
- }
- return Check(aTest.TransferArgs(), aTest.Chunk().Base());
- }
-
-// Note: this check will not deal correctly with transfers were subsequent
-// requeues overlap previous sources or destinations
-// or where the source of transfer depends on a previous transfer.
-// This is because it simply compares the source and destination
-// pairwise for each transfer
-//
-// If TPreTransferIncrBytes is used for the pre-test then the transfers
-// will be checked however.
-TInt TCompareSrcDst::Check(const CIsrRequeTest& aTest) const
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("Comparing CIsrRequeTest buffers");
- }
- TUint8* chunkBase = aTest.Chunk().Base();
- const TDmaTransferArgs& transferArgs = aTest.TransferArgs();
- // check first transfer
- TInt r = Check(transferArgs, chunkBase);
-
- if(r != KErrNone)
- return r;
-
- // check re-queued transfers
- const TIsrRequeArgsSet& requeueArgs = aTest.GetRequeueArgs();
- return Check(requeueArgs, chunkBase, transferArgs);
- }
-
-TInt TCompareSrcDst::Check(const TDmaTransferArgs& aTransferArgs, TUint8* aChunkBase) const
- {
- const TUint32 srcOffset = aTransferArgs.iSrcConfig.iAddr;
- const TUint32 dstOffset = aTransferArgs.iDstConfig.iAddr;
- const TInt size = aTransferArgs.iTransferCount;
-
- const TUint8* src = srcOffset + aChunkBase;
- const TUint8* dst = dstOffset + aChunkBase;
-
- if(gVerboseOutput)
- {
- RDebug::Printf("Comparing TDmaTransferArgs buffers src=0x%08x dst=0x%08x size=0x%08x",
- src, dst, size);
- }
-
- return memcompare(src, size, dst, size);
- }
-
-TInt TCompareSrcDst::Check(const TIsrRequeArgsSet& aRequeueArgSet, TUint8* aChunkBase, const TDmaTransferArgs& aTferArgs) const
- {
- TIsrRequeArgsSet argSet(aRequeueArgSet); //copy since Fixup will mutate object
-
- argSet.Substitute(aTferArgs); // replace any default (0) values with the values in aTferArgs
-
- argSet.Fixup((TLinAddr)aChunkBase); //convert address offsets to virtual user mode addresses
-
- TInt r = KErrCorrupt;
- while(!argSet.IsEmpty())
- {
- r = Check(argSet.GetArgs());
- if(r != KErrNone)
- break;
- }
- return r;
- }
-
-TInt TCompareSrcDst::Check(const TIsrRequeArgs& aRequeueArgs) const
- {
- const TUint8* src = (TUint8*)aRequeueArgs.iSrcAddr;
- const TUint8* dst = (TUint8*)aRequeueArgs.iDstAddr;
- const TInt size = aRequeueArgs.iTransferCount;
-
- if(gVerboseOutput)
- {
- RDebug::Printf("Comparing TIsrRequeArgs: src=0x%08x dst=0x%08x size=0x%08x",
- src, dst, size);
- }
-
- return memcompare(src, size, dst, size);
- }
-
-// Note: this check will not deal correctly with transfers were subsequent
-// requeues overlap previous sources or destinations
-// or where the source of trasnfer depends on a previous trasnfer.
-// This is because it simply compares the source and destination
-// pairwise for each transfer
-//
-// If TCompareSrcDst is used for the pre-test then the transfers
-// will be checked however.
-TInt TCompareSrcDst::Check(CMultiTransferTest& aTest) const
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("Comparing CMultiTransferTest buffers");
- }
-
- const TInt transferCount = aTest.TransferCount();
- TUint8* const chunkBase = aTest.Chunk().Base();
-
- // check buffers for each transfer
- for(TInt i=0; i<transferCount; i++)
- {
- TInt r = Check(aTest.TransferArgs(i), chunkBase);
- aTest.SetPostTransferResult(i, r);
- }
- // CMultiTransferTest is handled differently to the others.
- // Whereas CSingleTransferTest logs just the return value
- // of the check, here, we write back a result for each transfer
- // so the return value from this function is not important
- return KErrNone;
- }
-
-TInt TCompare2D::Check(const CSingleTransferTest& aTest) const
- {
- const TDmaTransferArgs& args = aTest.TransferArgs();
- TUint8* const chunkBase = aTest.Chunk().Base();
-
- TInt ret = KErrNone;
-
- TTransferIter src_iter(args.iSrcConfig, chunkBase);
- TTransferIter dst_iter(args.iDstConfig, chunkBase);
- TTransferIter end;
- for (; (src_iter != end) && (dst_iter !=end); ++src_iter, ++dst_iter)
- {
- if(*src_iter != *dst_iter)
- {
- ret = KErrCorrupt;
- break;
- }
- }
- return ret;
- }
-
-TInt TCompare2D::Check(const CIsrRequeTest&) const
- {
- return KErrNotSupported;
- }
-
-TInt TCompare2D::Check(CMultiTransferTest&) const
- {
- return KErrNotSupported;
- }
-
-
-TInt TCheckNoTransfer::Check(const CSingleTransferTest&) const
- {
- return KErrNotSupported;
- }
-
-TInt TCheckNoTransfer::Check(const CIsrRequeTest&) const
- {
- return KErrNotSupported;
- }
-
-TInt TCheckNoTransfer::Check(CMultiTransferTest& aTest) const
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("TCheckNoTransfer Comparing CMultiTransferTest buffers");
- }
-
- const TInt transferCount = aTest.TransferCount();
- TUint8* const chunkBase = aTest.Chunk().Base();
-
- // check buffers for each transfer
- for(TInt i=0; i<transferCount; i++)
- {
- TInt r = KErrCorrupt;
- if(IsZeroed(aTest.TransferArgs(i), chunkBase))
- {
- r = KErrNone;
- }
-
- aTest.SetPostTransferResult(i, r);
- }
- // CMultiTransferTest is handled differently to the others.
- // Whereas CSingleTransferTest logs just the return value
- // of the check, here, we write back a result for each transfer
- // so the return value from this function is not important
- return KErrNone;
- }
-
-TBool TCheckNoTransfer::IsZeroed(const TDmaTransferArgs& aTransferArgs, TUint8* aChunkBase) const
- {
- TAddressParms parms = GetAddrParms(aTransferArgs);
- parms.Fixup(reinterpret_cast<TLinAddr>(aChunkBase));
- const TAddrRange destination = parms.DestRange();
-
- return destination.IsFilled(0);
- }
-//////////////////////////////////////////////////////////////////////
-// MPreTransfer classes
-//////////////////////////////////////////////////////////////////////
-void TPreTransferIncrBytes::Setup(const CSingleTransferTest& aTest) const
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("TPreTransferIncrBytes(CSingleTransferTest)");
- }
- TAddressParms params = GetAddrParms(aTest.TransferArgs());
-
- TUint8* const chunkBase = aTest.Chunk().Base();
- params.Fixup((TLinAddr)chunkBase);
-
-
- Setup(params);
- }
-
-void TPreTransferIncrBytes::Setup(const TAddressParms& aParams) const
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("TPreTransferIncrBytes: setup memory buffers: src=0x%08x dst=0x%08x size=0x%08x",
- aParams.iSrcAddr, aParams.iDstAddr, aParams.iTransferCount);
- }
- TUint8* const src = (TUint8*) aParams.iSrcAddr;
- const TInt size = aParams.iTransferCount;
-
- for(TInt i=0; i<size; i++)
- {src[i] = (TUint8)i;} //each src byte holds its own offset (mod 256)
-
- TUint8* const dst = (TUint8*) aParams.iDstAddr;
- memclr(dst, size); //clear destination
- }
-
-void TPreTransferIncrBytes::Setup(const CIsrRequeTest& aTest) const
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("TPreTransferIncrBytes(CIsrRequeTest)");
- }
- if(!CheckBuffers(aTest))
- {
- RDebug::Printf("Successive transfer destinations may not overlap previous src or dst buffers");
- RDebug::Printf("unless the whole transfer is an exact repeat of a previous one");
- TEST_FAULT;
- }
-
- Setup(static_cast<CSingleTransferTest>(aTest)); // prepare the CSingleTransferTest parts
-
- TIsrRequeArgsSet requeSet(aTest.GetRequeueArgs());
-
- requeSet.Substitute(aTest.TransferArgs());
-
- const TLinAddr chunkBase = (TLinAddr) aTest.Chunk().Base();
- requeSet.Fixup(chunkBase);
-
- while(!requeSet.IsEmpty())
- {
- TIsrRequeArgs args = requeSet.GetArgs();
- Setup(args); // perform the setup operation for each TIsrRequeArgs
- }
- }
-
-void TPreTransferIncrBytes::Setup(const CMultiTransferTest& aTest) const
- {
- if(gVerboseOutput)
- {
- RDebug::Printf("TPreTransferIncrBytes(CMultiTransferTest)");
- }
-
- if(!CheckBuffers(aTest))
- {
- RDebug::Printf("Successive transfer destinations may not overlap previous src or dst buffers");
- TEST_FAULT;
- }
-
- TUint8* const chunkBase = aTest.Chunk().Base();
- const TInt transferCount = aTest.TransferCount();
-
- // initialise buffers for each transfer
- for(TInt i=0; i<transferCount; i++)
- {
- TAddressParms params = GetAddrParms(aTest.TransferArgs(i));
-
- params.Fixup((TLinAddr)chunkBase);
-
- Setup(params);
- }
- }
-
-TBool TPreTransferIncrBytes::CheckBuffers(const CIsrRequeTest& aTest) const
- {
- RArray<const TAddressParms> array;
- array.AppendL(TAddressParms(aTest.TransferArgs()));
-
- TIsrRequeArgsSet requeSet(aTest.GetRequeueArgs());
- requeSet.Substitute(aTest.TransferArgs());
-
- const TLinAddr chunkBase = (TLinAddr) aTest.Chunk().Base();
- requeSet.Fixup(chunkBase);
- while(!requeSet.IsEmpty())
- {
- const TIsrRequeArgs requeArgs = requeSet.GetArgs();
- array.AppendL(requeArgs);
- }
-
- const TBool result = CheckBuffers(array);
-
- array.Close();
- return result;
- }
-
-/**
-A CMultiTransferTest will wait for all transfers to complete
-before comapairing source and destination buffers. For this to be successful
-each transfer must be independent ie. no destination or source may be
-overwritten by another transfer and source buffers may not depend on an
-earlier transfer
-*/
-TBool TPreTransferIncrBytes::CheckBuffers(const CMultiTransferTest& aTest) const
- {
- TUint8* const chunkBase = aTest.Chunk().Base();
- const TInt transferCount = aTest.TransferCount();
-
- // assemble an array of TAddressParams from aTest, that
- // can then be passed to CheckBuffers(RArray<TAddressParms>)
- RArray<const TAddressParms> array;
-
- for(TInt i=0; i<transferCount; i++)
- {
- TAddressParms params = GetAddrParms(aTest.TransferArgs(i));
- params.Fixup((TLinAddr)chunkBase);
-
- array.AppendL(params);
- }
-
- // 2nd arg EFalse as there is no need to permit exact repeats
- const TBool r = CheckBuffers(array, EFalse);
-
- array.Close();
- return r;
- }
-
-/**
-Check that the destination of each TAddressParms does not overlap with
-any previous source or destination or that if it does the whole transfer
-matches.
-This is so that successive transfers do not overwrite the destinations or
-sources of preceeding ones.
-
-If aAllowExactRepeat is true then exactly matching transfers are allowed
-to test the case where a repeat transfer is required - though it can't
-then be determined just from looking at the buffers that the repeat was
-successful
-*/
-TBool TPreTransferIncrBytes::CheckBuffers(const RArray<const TAddressParms>& aTransferParams, TBool aAllowExactRepeat) const
- {
-
- const TInt count = aTransferParams.Count();
-
- if(gVerboseOutput)
- {
- RDebug::Printf("CheckBuffers, %d transfers", count);
- }
-
- TBuf<128> buf;
- for(TInt i=1; i<count; i++)
- {
- const TAddressParms& current = aTransferParams[i];
-
- if(gVerboseOutput)
- {
- buf.Zero();
- current.AppendString(buf);
- RDebug::Print(_L("Check current: %S, against:"), &buf);
- }
-
- for(TInt j=0; j<i; j++)
- {
- const TAddressParms& previous = aTransferParams[j];
- if(gVerboseOutput)
- {
- buf.Zero();
- previous.AppendString(buf);
- RDebug::Print(_L("Previous: %S"), &buf);
- }
-
- const TBool curDstOverlapsPrevTfer = previous.Overlaps(current.DestRange());
- const TBool curSrcDependsOnPrevDest = current.SourceRange().Overlaps(previous.DestRange());
- const TBool permitExactRepeat = aAllowExactRepeat && (current == previous);
-
- const TBool ok = !(curDstOverlapsPrevTfer || curSrcDependsOnPrevDest) || permitExactRepeat;
- if(!ok)
- return EFalse;
- }
- }
- return ETrue;
- }
-//////////////////////////////////////////////////////////////////////
-// TTransferIter class
-//////////////////////////////////////////////////////////////////////
-void TTransferIter::operator++ ()
- {
- iPtr++; //the standard post increment
- if(iElem < (iCfg->iElementsPerFrame-1))
- {
- iPtr += iCfg->iElementSkip;
- iElem++;
- iBytes++;
- }
- else
- {
- TEST_ASSERT(iElem == iCfg->iElementsPerFrame-1);
- if(iFrame < iCfg->iFramesPerTransfer-1)
- {
- iPtr += iCfg->iFrameSkip;
- iFrame++;
- iBytes++;
- iElem = 0;
- }
- else
- {
- //we have reached the end
- TEST_ASSERT(iFrame == iCfg->iFramesPerTransfer-1);
- iPtr = NULL;
- }
- }
-
- Invariant();
- }
-
-void TTransferIter::Invariant() const
- {
- const TInt elemSize = iCfg->iElementSize;
- RTest test(_L("TTransferIter invariant"));
- const TUint bytesTransfered = (
- elemSize * (iFrame * iCfg->iElementsPerFrame + iElem)
- + ((TUint)iPtr % (elemSize))
- );
- test_Equal(iBytes, bytesTransfered);
- test.Close();
- }
-
-///////////////////////////////////////////////////////////
-// TTestCase
-///////////////////////////////////////////////////////////
-TTestCase::TTestCase(CDmaTest* aTest,
- TBool aConcurrent,
- const TDmaCapability aCap1,
- const TDmaCapability aCap2,
- const TDmaCapability aCap3,
- const TDmaCapability aCap4,
- const TDmaCapability aCap5
- )
-:
- iTest(aTest), iConcurrentTest(aConcurrent)
- {
- iChannelCaps[0] = aCap1;
- iChannelCaps[1] = aCap2;
- iChannelCaps[2] = aCap3;
- iChannelCaps[3] = aCap4;
- iChannelCaps[4] = aCap5;
- }
-
-TResult TTestCase::TestCaseValid(const SDmacCaps& aChannelCaps) const
- {
- const TDmaCapability* cap = &iChannelCaps[0];
-
- TResult ret = ERun;
- //We assume that the array is empty at the first ENone found
- //any caps after this wil be ignored
- while(cap->iCapsReq != ENone)
- {
- TResult t = cap->CompareToDmaCaps(aChannelCaps);
- if(t > ret) //this relies on the enum ordering
- ret = t;
- cap++;
- }
- return ret;
- }
-
-TResult TTestCase::TestCaseValid(const TDmacTestCaps& aChannelCaps) const
- {
- const TDmaCapability* cap = &iChannelCaps[0];
-
- TResult ret = ERun;
- //We assume that the array is empty at the first ENone found
- //any caps after this wil be ignored
- while(cap->iCapsReq != ENone)
- {
- TResult t = cap->CompareToDmaCaps(aChannelCaps);
- if(t > ret) //this relies on the enum ordering
- ret = t;
- cap++;
- }
- return ret;
- }
-/**
-Will report whether a value held in aChannelCaps satisfies a
-requirement specfied by this object
-*/
-TBool TDmaCapability::RequirementSatisfied(const SDmacCaps& aChannelCaps) const
- {
- switch(iCapsReq)
- {
- case ENone:
- return ETrue;
- case EChannelPriorities:
- TEST_FAULT;
- case EChannelPauseAndResume:
- return aChannelCaps.iChannelPauseAndResume == (TBool)iValue;
- case EAddrAlignedToElementSize:
- TEST_FAULT;
- case E1DAddressing:
- return aChannelCaps.i1DIndexAddressing == (TBool)iValue;
- case E2DAddressing:
- return aChannelCaps.i2DIndexAddressing == (TBool)iValue;
- case ESynchronizationTypes:
- case EBurstTransactions:
- case EDescriptorInterrupt:
- case EFrameInterrupt:
- case ELinkedListPausedInterrupt:
- case EEndiannessConversion:
- case EGraphicsOps:
- case ERepeatingTransfers:
- case EChannelLinking:
- return aChannelCaps.iChannelLinking == (TBool)iValue;
- case EHwDescriptors:
- return aChannelCaps.iHwDescriptors == (TBool)iValue;
- case ESrcDstAsymmetry:
- case EAsymHwDescriptors:
- TEST_FAULT;
- case EBalancedAsymSegments:
- return aChannelCaps.iBalancedAsymSegments == (TBool)iValue;
- case EAsymCompletionInterrupt:
- return aChannelCaps.iAsymCompletionInterrupt == (TBool)iValue;
- case EAsymDescriptorInterrupt:
- return aChannelCaps.iAsymDescriptorInterrupt == (TBool)iValue;
- case EAsymFrameInterrupt:
- return aChannelCaps.iAsymFrameInterrupt == (TBool)iValue;
- default:
- TEST_FAULT;
- }
-
- return EFalse;
- }
-
-/**
-Will report whether a value held in aChannelCaps satisfies a
-requirement specfied by this object
-*/
-TBool TDmaCapability::RequirementSatisfied(const TDmacTestCaps& aChannelCaps) const
- {
- switch(iCapsReq)
- {
- case EPilVersion:
- return TestValue(aChannelCaps.iPILVersion);
- default:
- return RequirementSatisfied(static_cast<SDmacCaps>(aChannelCaps));
- }
- }
-
-TResult TDmaCapability::CompareToDmaCaps(const SDmacCaps& aChannelCaps) const
- {
- const TBool reqSatisfied = RequirementSatisfied(aChannelCaps);
- if(reqSatisfied)
- {
- return ERun;
- }
- else
- {
- return iFail ? EFail : ESkip;
- }
- }
-
-TResult TDmaCapability::CompareToDmaCaps(const TDmacTestCaps& aChannelCaps) const
- {
- const TBool reqSatisfied = RequirementSatisfied(aChannelCaps);
- if(reqSatisfied)
- {
- return ERun;
- }
- else
- {
- return iFail ? EFail : ESkip;
- }
- }
-/**
-Test that aValue satisfies the comparrison (iCapsReqType) with the
-reference value held in iValue
-*/
-TBool TDmaCapability::TestValue(TUint aValue) const
- {
- switch(iCapsReqType)
- {
- case EEqual:
- return aValue == iValue;
- case EGTE:
- return aValue >= iValue;
- case ELTE:
- return aValue <= iValue;
- case EBitsSet:
- case EBitsClear:
- default:
- TEST_FAULT;
- }
- return EFalse;
- }
-
-static RTest test(_L("DMAv2 test"));
-
-//////////////////////////////////////////////////////////////////////
-// TTestRunner
-//////////////////////////////////////////////////////////////////////
-TTestRunner::TTestRunner()
- {
- // Open RDmaSession handle
- TInt r = iDmaSession.Open();
- TEST_ASSERT(r == KErrNone);
-
- // Get PSI Test info
- r = iDmaSession.GetTestInfo(iPslTestInfo);
- TEST_ASSERT(r == KErrNone);
-
- //Retrieve PSL cookies
- GetPslCookie();
-
- //Generate the DMA channel records
- GenerateChannelRecord();
- }
-
-TTestRunner::~TTestRunner()
- {
- RTest::CloseHandleAndWaitForDestruction(iDmaSession);
- iTestCases.Close(); //TestRunner does not own test cases
- iChannelRecords.Close();
- iPslCookies.Close();
- }
-
-void TTestRunner::AddTestCases(RPointerArray<TTestCase>& aTTestCases)
- {
- const TInt count = aTTestCases.Count();
- for(TInt i=0; i < count; i++)
- {
- iTestCases.AppendL(aTTestCases[i]);
- }
- }
-
-void TTestRunner::RunTests()
- {
- //Print PslTestInfo
- if(gVerboseOutput)
- {
- Print(iPslTestInfo);
- }
-
- //iterate through the test case array
- const TInt testCaseCount = iTestCases.Count();
- for(TInt i=0; i < testCaseCount; i++)
- {
- const TTestCase& testCase = *iTestCases[i];
-
- //Here, we must create a test thread for each channel
- RPointerArray<CTest> concurrentTests;
-
- const TInt chanRecCount = iChannelRecords.Count();
- for(TInt j=0; j < chanRecCount; j++)
- {
- const TChannelRecord& record = iChannelRecords[j];
- const TDmacTestCaps& caps = record.iChannelCaps;
-
- const TResult t = testCase.TestCaseValid(caps);
-
- switch(t)
- {
- case ERun:
- {
- CDmaTest* dmaTest = static_cast<CDmaTest*>(testCase.iTest->Clone());
- TEST_ASSERT(dmaTest != NULL);
-
- dmaTest->SetChannelCookie(record.iCookie);
- dmaTest->SetupL();
- if(testCase.iConcurrentTest)
- {
- //Add test to array to be run concurrently
- TInt r = concurrentTests.Append(dmaTest);
- TEST_ASSERT(r == KErrNone);
- }
- else
- {
- dmaTest->Announce();
- //Run test in this thread
- (*dmaTest)();
- TBool result = dmaTest->Result();
- TEST_ASSERT(result);
-
- delete dmaTest;
- }
-
- break;
- }
- case ESkip:
- if(gVerboseOutput)
- {
- RDebug::Printf("Skipping test-case %S, PSL channel %d", &testCase.iTest->Name(), record.iCookie);
- }
- break;
- case EFail:
- if(gVerboseOutput)
- {
- RDebug::Printf("Failling test-case %S, PSL channel %d", &testCase.iTest->Name(), record.iCookie);
- }
- TEST_FAULT;
- default:
- TEST_FAULT;
- }
- //Depending on the value of iConcurrentTest the test runner will either block until the thread has completed or
- //alternatively run the current test case on the next channel:
-
- //if the test case has been run on all channels it will then wait for all threads to complete.
- }
-
- // Run the tests which should happen concurrently
- const TInt count = concurrentTests.Count();
- if(count>0)
- {
- RDebug::Printf("== Begin concurrent test run ==");
-
- TInt i; // VC++
- for(i=0; i<count; i++)
- {
- concurrentTests[i]->Announce();
- }
-
- MultipleTestRun(concurrentTests);
- for(i=0; i<count; i++)
- {
- TBool result = static_cast<CDmaTest*>(concurrentTests[i])->Result();
- TEST_ASSERT(result);
- }
- RDebug::Printf("== End concurrent test run ==");
- }
-
- concurrentTests.ResetAndDestroy();
- }
- }
-
-void TTestRunner::GetPslCookie()
- {
- //Get Sb Channel cookies
- for(TInt sb_channelcount=0; sb_channelcount<iPslTestInfo.iMaxSbChannels; sb_channelcount++)
- {
- iPslCookies.AppendL(iPslTestInfo.iSbChannels[sb_channelcount]);
- }
-
- //Get Db Channel cookies
- for(TInt db_channelcount=0; db_channelcount<iPslTestInfo.iMaxDbChannels; db_channelcount++)
- {
- iPslCookies.AppendL(iPslTestInfo.iDbChannels[db_channelcount]);
- }
-
- //Get Sg Channel cookies
- for(TInt sg_channelcount=0; sg_channelcount<iPslTestInfo.iMaxSgChannels; sg_channelcount++)
- {
- iPslCookies.AppendL(iPslTestInfo.iSgChannels[sg_channelcount]);
- }
- }
-
-void TTestRunner::GenerateChannelRecord()
- {
- //for each PSL cookie
- for(TInt count=0; count<iPslCookies.Count(); count++)
- {
- //Get channel cookie
- const TUint pslCookie = iPslCookies[count];
- TUint sessionCookie;
- TInt r = iDmaSession.ChannelOpen(pslCookie, sessionCookie);
- TEST_ASSERT(r == KErrNone);
- if(gVerboseOutput)
- {
- RDebug::Printf("Channel PSL Cookie[%d] :0x%08x",count,pslCookie);
- }
-
- TChannelRecord dmaChannelRecord;
- dmaChannelRecord.iCookie = pslCookie;
-
- //Get Channel Caps
- r = iDmaSession.ChannelCaps(sessionCookie, dmaChannelRecord.iChannelCaps);
- TEST_ASSERT(r == KErrNone);
-
- r = iDmaSession.ChannelClose(sessionCookie);
- TEST_ASSERT(r == KErrNone);
-
- //Append array
- iChannelRecords.AppendL(dmaChannelRecord);
- }
- }
-//////////////////////////////////////////////////////////////////////
-// Global test functions and E32Main
-//////////////////////////////////////////////////////////////////////
-
-/**
-Displayed if used supplied no parameters, garbage, or a ? in the parameters
-*/
-void PrintUsage()
- {
- test.Printf(_L("*** DMA TEST FRAMEWORK ***\n"));
- test.Printf(_L("Usage : t_dma2.exe [/option]\n"));
- test.Printf(_L(" /V or /VERBOSE = Control test output\n"));
- test.Printf(_L(" /S or /SELFTEST = Run DMA self tests\n"));
- test.Printf(_L(" /simple = Run only simple transfer tests\n"));
- test.Printf(_L(" /callback = Run only callback tests\n"));
- test.Printf(_L(" /multi = Run only multipart transfer tests\n"));
- test.Printf(_L(" /isrdfc = Run only isr and dfc tests\n"));
- test.Printf(_L(" /isreque = Run only isr reque tests\n"));
- test.Printf(_L(" /bench = Run only benchmark tests\n"));
- test.Printf(_L(" /suspend = Run only pause and resume tests\n"));
- test.Printf(_L(" /graphic = Run only graphic tests\n"));
- test.Printf(_L(" /channel = Run only DMA channel (opening and closing) tests\n"));
- test.Printf(_L(" /queue = Run only queue tests\n"));
- test.Printf(_L(" /fragment = Run only fragmentation related tests\n"));
- test.Printf(_L(" /request = Run only requests tests related tests\n"));
- test.Printf(_L("\n"));
- }
-
-void ProcessCommandLineL()
-{
- test.Printf(_L("Process command line arguments\n"));
-
- TInt cmdLineLength(User::CommandLineLength());
- HBufC* cmdLine = HBufC::NewMaxLC(cmdLineLength);
- TPtr cmdLinePtr = cmdLine->Des();
- User::CommandLine(cmdLinePtr);
- TBool tokenParsed(EFalse);
-
- TLex args(*cmdLine);
- args.SkipSpace(); // args are separated by spaces
-
- // first arg is the exe name, skip it
- TPtrC cmdToken = args.NextToken();
- HBufC* tc = HBufC::NewLC(KParameterTextLenMax);
- *tc = cmdToken;
- while (tc->Length())
- {
- tokenParsed = EFalse;
-
- // '/?' help wanted flag '?' or /? parameter
- if ((0== tc->FindF(_L("?"))) || (0==tc->FindF(_L("/?"))))
- {
- gHelpRequested = ETrue;
- tokenParsed = ETrue;
- }
-
- // '/SELFTEST'
- if ((0== tc->FindF(KArgSelfTest)) || (0==tc->FindF(KArgSelfTest2)))
- {
- // Run self test
- test.Printf(_L("Command Line Options:Selftest option specified.\n"));
- gSelfTest = ETrue;
- tokenParsed = ETrue;
- }
-
- // '/VERBOSE' option
- if ((0== tc->FindF(KArgVerboseOutput)) || (0==tc->FindF(KArgVerboseOutput2)))
- {
- test.Printf(_L("Command Line Options:Verbose option specified.\n"));
- gVerboseOutput = ETrue;
- tokenParsed = ETrue;
- }
-
- // '/suspend' option
- if ((0== tc->FindF(KArgSuspendTest)))
- {
- gSuspend = ETrue;
- tokenParsed = ETrue;
- }
-
- // '/simple' option
- if ((0== tc->FindF(KArgSimpleTest)))
- {
- gSimpleTest = ETrue;
- tokenParsed = ETrue;
- }
-
- // '/multi' option
- if ((0== tc->FindF(KArgMultiPartTest)))
- {
- gMultiPart = ETrue;
- tokenParsed = ETrue;
- }
-
- // '/callback' option
- if ((0== tc->FindF(KArgCallBackTest)))
- {
- gCallBack = ETrue;
- tokenParsed = ETrue;
- }
-
- // '/IsrAndDfc' option
- if ((0== tc->FindF(KArgIsrDfcTest)))
- {
- gIsrAndDfc = ETrue;
- tokenParsed = ETrue;
- }
-
- // '/IsrReque' option
- if ((0== tc->FindF(KArgIsrequeTest)))
- {
- gIsrReque = ETrue;
- tokenParsed = ETrue;
- }
-
- // '/Benchmark' option
- if ((0== tc->FindF(KArgBenchmarkTest)))
- {
- gBenchmark = ETrue;
- tokenParsed = ETrue;
- }
-
- // '/Queue' option
- if ((0== tc->FindF(KArgQueueTest)))
- {
- gQueue = ETrue;
- tokenParsed = ETrue;
- }
-
- // '/Fragment' option
- if ((0== tc->FindF(KArgFragmentTest)))
- {
- gFragment = ETrue;
- tokenParsed = ETrue;
- }
-
- // '/Channel' option
- if ((0== tc->FindF(KArgChannelTest)))
- {
- gChannel = ETrue;
- tokenParsed = ETrue;
- }
-
- // '/Graphic' option
- if ((0== tc->FindF(KArgGraphicTest)))
- {
- gGraphic = ETrue;
- tokenParsed = ETrue;
- }
-
- // '/Request' option
- if ((0== tc->FindF(KArgRequestTest)))
- {
- gRequest = ETrue;
- tokenParsed = ETrue;
- }
-
- if (!tokenParsed)
- {
- // warn about unparsed parameter
- test.Printf(_L("Warning: '%lS'??? not parsed\n"), tc);
- gHelpRequested = ETrue;
- }
-
- // next parameter
- *tc = args.NextToken();
- }
- CleanupStack::PopAndDestroy(tc);
- CleanupStack::PopAndDestroy(cmdLine);
-}
-
-void RunDMATests()
- {
- test.Start(_L("Creating test runner\n"));
- TTestRunner testRunner;
-
- test.Next(_L("Add global test cases to test runner\n"));
-
- if (gSimpleTest) //Add only simple tranfer test cases
- {
- testRunner.AddTestCases(TestArraySimple);
- }
- else if (gCallBack) //Add only callback test cases
- {
- testRunner.AddTestCases(TestArrayCallback);
- }
- else if (gIsrReque) //Add only ISR Reque test cases
- {
- testRunner.AddTestCases(TestArrayIsrReque);
- }
- else if (gMultiPart) //Add only Multipart test cases
- {
- testRunner.AddTestCases(TestArrayMultiPart);
- }
- else if (gIsrAndDfc) //Add only IsrAndDfc test cases
- {
- testRunner.AddTestCases(TestArrayIsrAndDfc);
- }
- else if (gBenchmark) //Add only Benchmark test cases
- {
- testRunner.AddTestCases(TestArrayBenchmark);
- }
- else if (gGraphic) //Add only 2D test cases
- {
- testRunner.AddTestCases(TestArray2DTest);
- }
- else if (gFragment) //Add only Fragment test cases
- {
- testRunner.AddTestCases(TestArrayFragment);
- }
- else if (gChannel) //Add only Channel test cases
- {
- testRunner.AddTestCases(TestArrayChannel);
- }
- else if (gSuspend) //Add only Suspend test cases
- {
- testRunner.AddTestCases(TestArraySuspend);
- }
- else if (gQueue) //Add only queue test cases
- {
- testRunner.AddTestCases(TestArrayQueue);
- }
- else if (gRequest) //Add only request test cases
- {
- testRunner.AddTestCases(TestArrayRequest);
- }
- else
- {
- testRunner.AddTestCases(TestArray);//Add all test cases
- }
-
- test.Next(_L("call TTestRunner::RunTests()\n"));
- testRunner.RunTests();
-
- test.End();
- }
-
-
-struct TSimTest
- {
- TUint iPslId;
- TBool iFragment;
- };
-
-const TSimTest KSimTests[] =
- {
- {0, EFalse},
- {1, EFalse},
- {2, ETrue},
- {3, ETrue},
- };
-
-const TInt KSimTestsCount = ARRAY_LENGTH(KSimTests);
-
-void RunSimDMATests()
- {
- test.Start(_L("Run simulated DMAC tests\n"));
-
- test.Next(_L("Open session"));
- RDmaSession session;
- TInt r = session.OpenSim();
- test_KErrNone(r);
-
- for(TInt i=0; i<KSimTestsCount; i++)
- {
- TUint pslId = KSimTests[i].iPslId;
- TBool doFrag = KSimTests[i].iFragment;
-
- test.Start(_L("Open channel"));
- TUint channelCookie=0;
- r = session.ChannelOpen(pslId, channelCookie);
- test.Printf(_L("Open channel %d, cookie recived = 0x%08x\n"), pslId, channelCookie);
- test_KErrNone(r);
-
- test.Next(_L("Create Dma request"));
-
- TUint reqCookie=0;
- r = session.RequestCreate(channelCookie, reqCookie);
- test.Printf(_L("cookie recived = 0x%08x\n"), reqCookie );
- test_KErrNone(r);
-
- if(doFrag)
- {
- test.Next(_L("Fragment request"));
- const TInt size = 128 * KKilo;
- TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr);
- r = session.FragmentRequest(reqCookie, transferArgs);
- test_KErrNone(r);
- }
-
- test.Next(_L("Destroy Dma request"));
- r = session.RequestDestroy(reqCookie);
- test_KErrNone(r);
-
- test.Next(_L("Channel close"));
- r = session.ChannelClose(channelCookie);
- test_KErrNone(r);
- test.End();
- }
-
- test.Next(_L("Close session"));
- RTest::CloseHandleAndWaitForDestruction(session);
-
- test.End();
- }
-
-TInt E32Main()
- {
- __UHEAP_MARK;
- test.Title();
-
- gHelpRequested = EFalse;
- TInt r;
-
- // Create the new trap-cleanup mechanism
- CTrapCleanup* cleanup = CTrapCleanup::New();
-
- if (cleanup == NULL)
- {
- return KErrNoMemory;
- }
-
- // Process the command line parameters for batch/etc
- TRAPD(err, ProcessCommandLineL());
- if (err != KErrNone)
- {
- User::Panic(_L("DMA test run memory failure"), KErrNoMemory);
- }
-
- if (gHelpRequested)
- {
- PrintUsage();
- User::Leave(-2); // nothing to do!
- }
- test.Start(_L("Loading test LDD"));
- //load either the new test ldd, d_dma2.ldd,
- //or d_dma2_compat.ldd - an ldd linked against
- //the old DMA framework
- _LIT(KDma, "D_DMA2.LDD");
- r = User::LoadLogicalDevice(KDma);
- const TBool dma2Loaded = ((r == KErrNone) || (r == KErrAlreadyExists));
-
- _LIT(KDma2Compat, "D_DMA2_COMPAT.LDD");
- r = User::LoadLogicalDevice(KDma2Compat);
- const TBool dma2CompatLoaded = ((r == KErrNone) || (r == KErrAlreadyExists));
-
- if (!(dma2Loaded || dma2CompatLoaded))
- {
- test.Printf(_L("Hardware DMA test driver not found - will run tests on simulated DMAC only\n"));
- }
- else if (dma2Loaded && !dma2CompatLoaded)
- {
- test.Printf(_L("Loaded %S\n"), &KDma);
- }
- else if (!dma2Loaded && dma2CompatLoaded)
- {
- test.Printf(_L("Loaded %S\n"), &KDma2Compat);
- }
- else
- {
- test.Printf(_L("The ROM contains %S and %S - only one should be present\n"), &KDma, &KDma2Compat);
- TEST_FAULT;
- }
-
- const TBool dmaHwPresent = (dma2Loaded || dma2CompatLoaded);
-
- _LIT(KDma2Sim, "D_DMA2_SIM.LDD");
-
- r = User::LoadLogicalDevice(KDma2Sim);
- const TBool dma2SimLoaded = ((r == KErrNone) || (r == KErrAlreadyExists));
- if (dma2SimLoaded)
- {
- test.Printf(_L("Loaded %S\n"), &KDma2Sim);
- }
- else
- {
- test.Printf(_L("Failed to load %S, r=%d\n"), &KDma2Sim, r);
- test(EFalse);
- }
-
- // Turn off evil lazy dll unloading
- RLoader l;
- test(l.Connect()==KErrNone);
- test(l.CancelLazyDllUnload()==KErrNone);
- RTest::CloseHandleAndWaitForDestruction(l);
-
- __KHEAP_MARK;
-
- if (gSelfTest) //Run self tests if specified on command line
- {
- SelfTests();
- }
-
- RunSimDMATests();
- if (dmaHwPresent)
- {
- RunDMATests();
- }
-
- // Wait for the supervisor thread to run and perform asynchronous
- // cleanup, so that kernel heap space will be freed
- r = UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, (TAny*)5000, 0);
- test_KErrNone(r);
- __KHEAP_MARKEND;
-
- if(dmaHwPresent)
- {
- r = User::FreeLogicalDevice(KTestDmaLddNameHw);
- test_KErrNone(r);
- }
- r = User::FreeLogicalDevice(KTestDmaLddNameSim);
- test_KErrNone(r);
-
- test.End();
- test.Close();
-
- delete cleanup;
-
- __UHEAP_MARKEND;
- return 0;
- }