// 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 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 (%d) a2=%08x (%d) a3=%08x (%d)", aLine, a1, a1, a2, a2, a3, 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;

	};

/**

Test that it is possible to close a channel from a callback

*/

class CCloseInCb : public CTest

	{

public:

	CCloseInCb()

		: CTest(NULL, 1), iTransferSize(4 * KKilo)

		{}

	TInt virtual DoRunTest();

	virtual void AnnounceTest(TDes& aDes)

		{

		aDes.AppendFormat(_L("CCloseInCb"));

		CTest::AnnounceTest(aDes);

		}

	CTest* Clone() const

		{return new CCloseInCb(*this);}

private:

	const TInt iTransferSize;

	};

/**

Perform multiple transfers with different fragment counts and with smaller

and smaller fragment size

This checks that the PSL's ISR(s) are properly written, and do not miss interrupts

or notify the PIL spuriously.

*/

class CFragSizeRange : public CTest

	{

public:

	CFragSizeRange(TInt aMaxIter, TInt aFragCount, TInt aInitialFragmentSize, TInt aInnerIteraions)

		: CTest(NULL, aMaxIter), iMaxFragCount(aFragCount), iFragCount(1), iInitialFragmentSize(aInitialFragmentSize),

		iInnerIterations(aInnerIteraions)

		{}

	TInt virtual DoRunTest();

	virtual void AnnounceTest(TDes& aDes)

		{

		aDes.AppendFormat(_L("CFragSizeRange: Fragments %d, intital frag size %d, inner iters %d "), iFragCount, iInitialFragmentSize, iInnerIterations);

		CTest::AnnounceTest(aDes);

		}

	CTest* Clone() const

		{return new CFragSizeRange(*this);}

private:

	/**

	Run the transfer

	*/

	TInt Transfer(TInt aFragSize);

	TInt iMaxFragCount;

	TInt iFragCount;

	const TInt iInitialFragmentSize;

	const TInt iInnerIterations;

	RTimer iTimer;

	};

//

// 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, 0x2000, 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;

	}

TInt CCloseInCb::DoRunTest()

	{

	TInt r = KErrNone;

	RTest test(_L("CCloseInCb test"));

	r = OpenChannel(1);

	test_KErrNone(r);

	const TInt KRequest = 0;

	const TInt KSrcBuf = 0;

	const TInt KDestBuf = 1;

	const TInt size = Min(iTransferSize, Info.iMaxTransferSize);

	r = iChannel.AllocBuffer(KSrcBuf, size);

	test_KErrNone(r);

	iChannel.FillBuffer(KSrcBuf, 'A');

	r = iChannel.AllocBuffer(KDestBuf, size);

	test_KErrNone(r);

	iChannel.FillBuffer(KDestBuf, '\0');

	TRequestStatus rs = KRequestPending;

	r = iChannel.Fragment(KRequest, KSrcBuf, KDestBuf, size, &rs);

	test_KErrNone(r);

	// "X" will cause channel to be closed during callback

	r = iChannel.Execute(_L8("QX0"));

	test_KErrNone(r);

	User::WaitForRequest(rs);

	test_KErrNone(rs.Int());

	test(iChannel.CheckBuffer(KDestBuf, 'A'));

	iChannel.FreeAllBuffers();

	test.Close();

	return KErrNone;

	}

TInt CFragSizeRange::DoRunTest()

	{

	const TInt initialFragmentSize = Min(iInitialFragmentSize, Info.iMaxTransferSize);

	TInt r = KErrNone;

	RTest test(_L("CFragSizeRange test"));

	r = iTimer.CreateLocal();

	test_KErrNone(r);

	TInt fragSize = initialFragmentSize;

	TInt step = 0;

	do

		{

		fragSize -= step;

		// Make sure size is aligned

		fragSize = fragSize & ~Info.iMemAlignMask;

		if(fragSize == 0)

			break;

		r = OpenChannel(iMaxFragCount, fragSize);

		test_KErrNone(r);

		for(iFragCount=1; iFragCount <= iMaxFragCount; iFragCount++)

			{

			test.Printf(_L("Chan %d Fragment size %d bytes, %d fragments, %d iters\n"), iChannelId, fragSize, iFragCount, iInnerIterations);

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

				{

				r = Transfer(fragSize);

				test_KErrNone(r);

				}

			}

		iChannel.Close();

		// Reduce frag size by a quarter each iteration

		step = (fragSize/4);

		} while (step > 0);

	iTimer.Close();

	test.Close();

	return r;

	}

TInt CFragSizeRange::Transfer(TInt aFragmentSize)

	{

	const TInt KRequest = 0;

	const TInt KSrcBuf = 0;

	const TInt KDestBuf = 1;

	const TInt size = aFragmentSize * iFragCount;

	TInt r = iChannel.AllocBuffer(KSrcBuf, size);

	test_KErrNone(r);