// 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 the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32test\dma\t_dma.cpp

// Overview:

// Test the DMA channel functionality.

// API Information:

// RBusLogicalChannel, DLogicalChannelBase, DLogicalDevice

// Details:	

// - Load the DMA LDD, create a critical section, an active scheduler and

// a CPeriodic object.

// - Test one shot single buffer transfers: test simple transfer, request 

// reconfiguration and cancelling. Verify results are as expected.

// - Test one shot double buffer transfers: test simple transfer, request 

// reconfiguration and cancelling. Verify results are as expected.

// - Test streaming single buffer transfers: test simple transfer and

// cancelling. Test that framework behaves correctly if one or more DMA

// interrupts are missed. Verify results are as expected.

// - Test streaming double buffer transfers: test simple transfer and

// cancelling. Test that framework behaves correctly if one or more DMA

// interrupts are missed. Verify results are as expected.

// - Test streaming scatter/gather transfers: test simple transfer and

// cancelling. Test that framework behaves correctly if one or more DMA

// interrupts are missed. Verify results are as expected.

// Platforms/Drives/Compatibility:

// Hardware (Automatic).

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include "d_dma.h"

#include <e32debug.h>

#include <e32svr.h>

#include <e32def.h>

#include <e32def_private.h>

#include "u32std.h"

#ifdef __DMASIM__

RTest test(_L("T_DMASIM"));

#else

RTest test(_L("T_DMA"));

#endif

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

// Mini-framework for running tests either in a single thread or in

// several concurrent ones.

RTestDma::TInfo Info;

TBool JitEnabled;

RCriticalSection TheCriticalSection;						// protect following variables

TInt ThreadCount;											// decremented when tester thread dies

CPeriodic* Bipper;											// display dots during tests to detect lock-ups

// Test macro used inside tester threads

_LIT(KTestFailure, "XTEST");

static void TestPanic(TInt aLine, TUint32 a1, TUint32 a2, TUint32 a3)

	{

	RDebug::Printf("Line %d test failed a1=%08x a2=%08x a3=%08x", aLine, a1, a2, a3);

	RThread().Panic(KTestFailure, aLine);

	}

#define XTEST(e)				if (!(e)) TestPanic(__LINE__, 0, 0, 0)

#define XTEST1(e,a1)			if (!(e)) TestPanic(__LINE__, (a1), 0, 0)

#define XTEST2(e,a1,a2)			if (!(e)) TestPanic(__LINE__, (a1), (a2), 0)

#define XTEST3(e,a1,a2,a3)		if (!(e)) TestPanic(__LINE__, (a1), (a2), (a3))

/**

Specifies a DMA test

@note Have not inherited from CBase so that implicit copy ctors are used

*/

class CTest

	{

public:

	typedef void (*TTestFunction)(RTestDma aChannel, TInt aMaxFragment, TInt aFragmentSize);

	CTest(TTestFunction aFn, TInt aMaxIter)

		:iTestFn(aFn), iChannelId(0), iMaxIter(aMaxIter)

		{}

	virtual ~CTest()

		{}

	TInt RunTest();

	virtual TBool OpenChannel(TInt aDesCount, TInt aMaxFragmentSize=0);

	virtual void AnnounceTest(TDes& aDes)

		{aDes.AppendFormat(_L("Channel Id %d, iMaxIter %d"), iChannelId, iMaxIter);}

	virtual void ReportState(TDes& aDes)

		{aDes.AppendFormat(_L("Channel Id %d, iCurIter %d"), iChannelId, iCurIter);}

	void SetChannelId(TUint32 aChannelId)

		{iChannelId = aChannelId;}

	TInt MaxIter() const {return iMaxIter;}

	TInt CurIter() const {return iCurIter;}

	/**

	@return A copy of this test

	*/	

	virtual	CTest* Clone() const =0;

protected:

	TInt virtual DoRunTest() =0;

	const TTestFunction iTestFn;

	TUint32 iChannelId;

	const TInt iMaxIter;

	TInt iCurIter;

	RTestDma iChannel;

	};	

/**

Specifies a DMA test where the maximum fragmentation is

explicitly limited. This tests that requests are split

in to the number of fragments expected.

This test also requires that physically contiguous buffers

are used. For this reason the product of iMaxFragment and

iMaxFragmentSize should be kept small

*/

class CFragmentationTest : public CTest

	{

public:

	CFragmentationTest(TTestFunction aFn, TInt aMaxIter, TInt aMaxFragment, TInt aMaxFragmentSize)

		: CTest(aFn, aMaxIter), iMaxFragment(aMaxFragment), iMaxFragmentSize(aMaxFragmentSize), iCurFragment(0)

	{}

	TInt virtual DoRunTest();

	virtual void AnnounceTest(TDes& aDes)

		{

		aDes.AppendFormat(_L("CFragmentationTest: Frag count = [1..%d], Max Frag Size = 0x%08x bytes: "), iMaxFragment, iMaxFragmentSize);

		CTest::AnnounceTest(aDes);

		}

	virtual void ReportState(TDes& aDes)

		{

		aDes.AppendFormat(_L("CFragmentationTest: Current Fragment %d: "), iCurFragment);

		CTest::ReportState(aDes);

		}

	CTest* Clone() const

		{return new CFragmentationTest(*this);}

private:

	const TInt iMaxFragment;

	TInt iMaxFragmentSize;

	TInt iCurFragment;

	};

/**

Specifies a DMA test where the maximum fragment size is

not limited - and we do not care how many fragments are

used

- This checks that transfers work correctly with the DMAC's

default fragment size

*/

class CDefaultFragTest : public CTest

	{

public:

	CDefaultFragTest(TTestFunction aFn, TInt aMaxIter, TUint aTotalTransferSize)

		: CTest(aFn, aMaxIter), iTotalTransferSize(aTotalTransferSize)

		{}

	TInt virtual DoRunTest();

	virtual void AnnounceTest(TDes& aDes)

		{

		aDes.AppendFormat(_L("CDefaultFragTest: Transfer = 0x%08x bytes: "), iTotalTransferSize);

		CTest::AnnounceTest(aDes);

		}

	CTest* Clone() const

		{return new CDefaultFragTest(*this);}

	const TInt iTotalTransferSize;

	};

//

// Active object used to create a tester thread, log on to it and

// interpret its exit status.

//

class CTesterThread : public CActive

	{

public:

	CTesterThread(TInt aIdx, CTest* aTest);

	~CTesterThread()

		{

		delete iTest;

		}

private:

	static TInt ThreadFunction(TAny* aSelf);

	TInt StartThread();

	// from CActive

	virtual void DoCancel();

	virtual void RunL();

private:

	RThread iThread;

	CTest* iTest;

	};

/**

Run the test for iMaxIter iterations

*/

TInt CTest::RunTest()

	{

	TInt r = KErrNone;

	for (iCurIter=0; iCurIter<iMaxIter; ++iCurIter)

		{

		r =  DoRunTest();

		if(KErrNone != r)

			break;

		}

	return r;

	}

/**

Open iChannel

@pre iChannel is not open

@return

   - KErrNotSupported Channel does not exist on DMAC

   - KErrNone Success

   - KErrInUse

*/

TInt CTest::OpenChannel(TInt aDesCount, TInt aMaxFragmentSize)

		{

		ASSERT(!iChannel.Handle());

		const TInt r = iChannel.Open(iChannelId, aDesCount, aMaxFragmentSize);

		if (r == KErrNotSupported)

			return r;

		XTEST1(KErrNone == r || KErrInUse == r, r);

		if(KErrInUse == r)

			{

			// Channel is in use.

			RDebug::Printf("\nDMA Channel %d is in use",iChannelId);

			if(0 == iCurIter)

				{

				// Terminate thread by returning this error code KErrInUse.

				return r;

				}

			else

				{

#ifdef __WINS__

#pragma warning( disable : 4127 ) // warning C4127: conditional expression is constant

#endif // __WINS__

				XTEST1(EFalse, iCurIter);

#ifdef __WINS__

#pragma warning( default : 4127 ) // warning C4127: conditional expression is constant

#endif // __WINS__

				}

			}

		return r;

		}

// Spawn thread. Will auto-delete when thread exits.

CTesterThread::CTesterThread(TInt aIdx, CTest* aTest)

	: CActive(EPriorityStandard), iTest(aTest)

	{

	CActiveScheduler::Add(this);

	TBuf<16> name;

	name = _L("TESTER-");

	name.AppendNum(aIdx);

	test(iThread.Create(name, ThreadFunction, 0x1000, NULL, this) == KErrNone);

	iThread.SetPriority(EPriorityLess);

	iThread.Logon(iStatus);

	SetActive();

	iThread.Resume();

	}

TInt CTesterThread::ThreadFunction(TAny* aSelf)

	{

	CTesterThread* self = (CTesterThread*)aSelf;

	return self->StartThread();

	}

TInt CTesterThread::StartThread()

	{

	return iTest->RunTest();

	}

TInt CFragmentationTest::DoRunTest()

	{

	// In case iMaxFragmentSize was larger than suppported (we need to know what fragment

	// size will actually be used)

	iMaxFragmentSize = Min(iMaxFragmentSize, Info.iMaxTransferSize);

	// Open channel with enough descriptors for 3 open DMA

	// requests (see TestStreaming).

	TInt r = OpenChannel(3* iMaxFragment, iMaxFragmentSize);

	if(r != KErrNone)

		return r;

	//we are controlling fragment size, so we know how

	//many to expect

	for (iCurFragment=1; iCurFragment<=iMaxFragment; iCurFragment*=2)

		{

		const TInt size = iCurFragment * ( iMaxFragmentSize & ~Info.iMemAlignMask);

		iTestFn(iChannel, iCurFragment, size);

		}

	iChannel.Close();

	return KErrNone;

	}

TInt CDefaultFragTest::DoRunTest()

	{

	// +1 so we don't underestimate maxFragount for inexact division

	const TUint maxFragCount = (iTotalTransferSize / Info.iMaxTransferSize) +1;

	// Open channel with enough descriptors for 3 open DMA

	// requests (see TestStreaming).

	const TUint descriptorCount = 3 * maxFragCount;

	TInt r = OpenChannel(descriptorCount);

	if(r != KErrNone)

		return r;

	iTestFn(iChannel, 0, iTotalTransferSize);

	iChannel.Close();

	return KErrNone;

	}

// Called when thread completed.

void CTesterThread::RunL()

	{

	TExitType et = iThread.ExitType();

	TInt er = iThread.ExitReason();

	TExitCategoryName ec = iThread.ExitCategory();

	TName name = iThread.Name();

	CLOSE_AND_WAIT(iThread);

	switch (et)

		{

	case EExitKill:

		// nothing to do

		break;

	case EExitPanic:

			{

			User::SetJustInTime(JitEnabled);

			TBuf<128> buffer;

			iTest->ReportState(buffer);

			test.Printf(_L("Tester Thread Panic: %S: Test: %S\n"),

						&name, &buffer);

			if (ec.Match(KTestFailure) == 0)

				test.Panic(_L("Test failure line %d"), er);

			else

				test.Panic(_L("Unexpected panic: %S-%d"), &ec, er);

			break;

			}

	default:

		test.Panic(_L("Invalid thread exit type"));

		}

	TheCriticalSection.Wait();

	if (--ThreadCount == 0)

		{

		Bipper->Cancel();

		test.Console()->Printf(_L("\n"));

		CActiveScheduler::Stop();

		}

	TheCriticalSection.Signal();

	// We commit suicide as the alternative (being deleted by

	// RunTest()) implies keeping a list of all instances in

	// RunTest().

	delete this;

	}

void CTesterThread::DoCancel()

	{

	test.Panic(_L("CTesterThread::DoCancel called"));

	}

static TInt Bip(TAny*)

	{

	test.Console()->Printf(_L("."));

	return 0;

	}

// Execute provided test object in one or more tester threads.

void RunTest(TUint32 aChannelIds[], TInt aMaxThread, CTest* aTest)			 

	{

	test_NotNull(aTest);

	if (aMaxThread == 0)

		{

		delete aTest;

		test.Printf(_L("transfer mode not supported - skipped\n"));

		return;

		}

	test.Printf(_L("Using %d thread(s)\n"), aMaxThread);

	// We don't want JIT debugging here because the tester threads may panic

	JitEnabled = User::JustInTime();

	User::SetJustInTime(EFalse);

	// must be set before spawning threads to avoid premature active scheduler stop

	ThreadCount = aMaxThread;

	TBuf<128> buffer;

	for (TInt i=0; i<aMaxThread; ++i)

		{

		//each CTesterThread needs its own CTest object

		CTest* dmaTest = aTest->Clone();

		test_NotNull(dmaTest);

		dmaTest->SetChannelId(aChannelIds[i]);

		buffer.Zero();

		dmaTest->AnnounceTest(buffer);

		test.Printf(_L("Thread %d: %S\n"), i, &buffer);

		test(new CTesterThread(i, dmaTest) != NULL);

		dmaTest = NULL; //ownership transferred to CTesterThread

		}

	//the orginal isn't needed

	delete aTest;

	aTest = NULL;

	const TTimeIntervalMicroSeconds32 KPeriod = 1000000;	// 1s

	Bipper->Start(KPeriod, KPeriod, Bip);

	CActiveScheduler::Start();

	User::SetJustInTime(JitEnabled);

	}

inline void RunSbTest(TInt aMaxThread, CTest* aTest)

	{

	RunTest(Info.iSbChannels, Min(aMaxThread,Info.iMaxSbChannels), aTest);

	}

inline void RunDbTest(TInt aMaxThread, CTest* aTest)

	{

	RunTest(Info.iDbChannels, Min(aMaxThread,Info.iMaxDbChannels), aTest);

	}

inline void RunSgTest(TInt aMaxThread, CTest* aTest)

	{

	RunTest(Info.iSgChannels, Min(aMaxThread,Info.iMaxSgChannels), aTest);

	}

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

static void GetChannelInfo()

	{

	RTestDma channel;

	test(channel.GetInfo(Info) == KErrNone);

	test(Info.iMaxSbChannels>0 || Info.iMaxDbChannels>0 || Info.iMaxSgChannels>0);

	}

static void TestOneShot(RTestDma aChannel, TInt aFragmentCount, TInt aSize)

	{

	const TInt KRequest = 0;

	const TInt KSrcBuf = 0;

	const TInt KDestBuf1 = 1;

	const TInt KDestBuf2 = 2;

	TInt r = aChannel.AllocBuffer(KSrcBuf, aSize);

	XTEST2(r == KErrNone, r, aSize);

	aChannel.FillBuffer(KSrcBuf, 'A');

	r = aChannel.AllocBuffer(KDestBuf1, aSize);

	XTEST2(r == KErrNone, r, aSize);

	aChannel.FillBuffer(KDestBuf1, '\0');

	r = aChannel.AllocBuffer(KDestBuf2, aSize);

	XTEST2(r == KErrNone, r, aSize);

	aChannel.FillBuffer(KDestBuf2, '\0');

	// Test simple transfer

	TRequestStatus rs;

	r = aChannel.Fragment(KRequest, KSrcBuf, KDestBuf1, aSize, &rs);

	XTEST2(r == KErrNone, r, aSize);

	test(aChannel.FragmentCheck(KRequest, aFragmentCount));

	r = aChannel.Execute(_L8("Q0"));

	XTEST1(r == KErrNone, r);

	User::WaitForRequest(rs);

	XTEST1(rs == KErrNone, rs.Int());

	XTEST(aChannel.CheckBuffer(KDestBuf1, 'A'));

	// Test request reconfiguration.

	aChannel.FillBuffer(KDestBuf1, '\0');

	r = aChannel.Fragment(KRequest, KSrcBuf, KDestBuf2, aSize, &rs);

	XTEST2(r == KErrNone, r, aSize);

	test(aChannel.FragmentCheck(KRequest, aFragmentCount));

	r = aChannel.Execute(_L8("Q0"));

	XTEST1(r == KErrNone, r);

	User::WaitForRequest(rs);

	XTEST1(rs == KErrNone, rs.Int());

	XTEST(aChannel.CheckBuffer(KDestBuf1, '\0'));			// previous dest unchanged?

	XTEST(aChannel.CheckBuffer(KDestBuf2, 'A'));

	// Test cancelling

	aChannel.FillBuffer(KDestBuf1, '\0');

	r = aChannel.Fragment(KRequest, KSrcBuf, KDestBuf1, aSize);

	XTEST2(r == KErrNone, r, aSize);

	test(aChannel.FragmentCheck(KRequest, aFragmentCount));