// 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);