// Copyright (c) 2002-2009 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\dma\t_dma.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");	     

TBool gHelpRequested;   // print usage 

TBool gVerboseOutput;   // enable verbose output 

TBool gSelfTest;        // run SelfTest 

/**

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()

	{

	TInt r = iDmaSession.Open();

	TEST_ASSERT(r == KErrNone);

	r = iDmaSession.OpenSharedChunk(iChunk);

	TEST_ASSERT(r == KErrNone);

	}

void CDmaTest::CloseDmaSession()

	{

	iChunk.Close();

	iDmaSession.Close();

	}

//////////////////////////////////////////////////////////////////////

// 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.RequestCreateNew(iChannelSessionCookie, iRequestSessionCookie, iMaxFragmentSize);

		}

	else

		{

		if(gVerboseOutput)

			{

			RDebug::Printf("Calling Old Request API\n");

			}

		iActual.iRequestResult.iCreate =

			iDmaSession.RequestCreate(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::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;

	}

//////////////////////////////////////////////////////////////////////

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

	{

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

		}

	//TODO this will be handled by the ctor later

	iResultArray.Close();

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

	}

//////////////////////////////////////////////////////////////////////

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

		}

	}

//////////////////////////////////////////////////////////////////////

// CMultiTransferTest

//////////////////////////////////////////////////////////////////////

//TODO

// Add pre and post transfer for 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)

	//const cast is required because their isn't a ctor taking const

	//array values

	//TODO iRequestCookies(const_cast<TUint*>(&aOther.iRequestCookies[0]), aOther.iRequestCookies.Count())

	{

	}

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++)

		{

		// Since all transfers will use the same channel,

		// they all get the same result

		// Arguably, iChannelOpenResult doesn't

		// belong TResultSet

		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;