// 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\d_dma2.h

// User-side API for LDD used to test DMAv2 framework.

// 

//

#ifndef __D_DMA2_H__

#define __D_DMA2_H__

#include <e32cmn.h>

#include <drivers/dmadefs.h>

#define ARRAY_LENGTH(ARRAY) sizeof(ARRAY)/sizeof(ARRAY[0])

#ifdef __KERNEL_MODE__

	#include <nkern.h>

	#include <kernel.h>

	#define TEST_FAULT FAULT();

	#define PRINT(N) Kern::Printf("%s = 0x%08x (%d)", #N, (N), (N))

#else

	#include <e32std.h>

	#include <e32debug.h>

	#define PRINT(N) RDebug::Printf("%s = 0x%08x (%d)", #N, (N), (N))

#endif

#define TEST_ASSERT(C) if(!(C)) {TEST_FAULT;}

const TUint KPhysAddrInvalidUser=0xFFFFFFFFu; // KPhysAddrInvalid is not defined on the user side

#ifdef __KERNEL_MODE__

//if this fails then KPhysAddrInvalidUser must be updated to match

//KPhysAddrInvalid

__ASSERT_COMPILE(KPhysAddrInvalidUser == KPhysAddrInvalid);

#endif

_LIT(KTestDmaLddName, "TestDmaV2");

inline TVersion TestDmaLddVersion() { return TVersion(1, 0, 1); }

TInt Log2(TInt aNum);

/**

Indicates the number of each type of call back received

and their context

the final one

*/

const TInt KNumberOfCallbacks = 12;

class TCallbackRecord

	{

public:

	enum TCbContext

		{ EInvalid, EThread, EIsr };

	TCallbackRecord(

			TCbContext aContext = EThread,

			TInt aReq = 0,

			TInt aReqSrc = 0,

			TInt aReqDst = 0,

			TInt aDes = 0,

			TInt aDesSrc = 0,

			TInt aDesDst = 0,

			TInt aFrame = 0,

			TInt aFrameSrc = 0,

			TInt aFrameDst = 0,

			TInt aPause = 0,

			TInt aPauseSrc = 0,

			TInt aPauseDst = 0,

			TDmaResult aResult = EDmaResultOK

		);

	static TCallbackRecord Empty();

	void Reset();

	/**

	Allows 2 callback records to be compared

	*/

	TBool operator == (const TCallbackRecord aOther) const;

	void Print() const;

	/**

	Get the number of callbacks for callback aCbType

	*/

	TInt GetCount(TDmaCallbackType aCbType) const;

	void SetCount(TDmaCallbackType aCbType, TInt aCount);

	/**

	Set the result (expected or actual) from

	TDmaChannel::IsrRedoRequest

	 */

	inline TCallbackRecord& IsrRedoResult(TInt aResult) {iIsrRedoRequestResult = aResult; return *this;}

	/**

	Reports the context in which the callback occurred.

	*/

	inline TCbContext GetContext()

		{return iContext;}

	/**

	Updates data based on callback mask aCallbackMask

	@param aCallbackMask Bitmask of callback events @see TDmaCallbackType

	@oaram aResult The result reported by the current callback

	*/

	void ProcessCallback(TUint aCallbackMask, TDmaResult aResultaContext);

	static void SelfTest();

	// The below methods are setters, which may be chained together

	// ie. The Named Parameter Idiom

	// @see http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.18

	TCallbackRecord& Context(TCbContext aContext) {iContext = aContext; return *this;}

private:

	TInt BitToIndex(TDmaCallbackType aCbType) const;

	TCbContext CurrentContext() const;

	TInt iCallbackLog[KNumberOfCallbacks];

	TDmaResult iResult;

	TCbContext iContext;

	/** Result of the most recent redo request call */

	TInt iIsrRedoRequestResult;

	};

/**

Extends SDmacCaps to contain the DMA PIL

version being used

*/

struct TDmacTestCaps : public SDmacCaps

	{

	TDmacTestCaps();

	TDmacTestCaps(const SDmacCaps& aDmacCaps, TInt aVersion = 2);

	TInt iPILVersion;

	};

class TDmaChannel;

struct TAddrRange

	{

	TAddrRange(TUint aStart, TUint aLength);

	inline TUint End() const {return (iStart + iLength -1);}

	inline TUint Start() const {return iStart;}

	inline TBool Contains(TUint aValue) const {return Rng(iStart, aValue, End());}

	TBool Contains(TAddrRange aRange) const;

	TBool Overlaps(const TAddrRange& aRange) const;

	static void SelfTest();

private:

	TUint iStart;

	TUint iLength;

	};

struct TAddressParms

	{

	TAddressParms(TUint32 aSrcAddr=0, TUint32 aDstAddr=0, TUint aTransferCount=0)

		:iSrcAddr(aSrcAddr), iDstAddr(aDstAddr), iTransferCount(aTransferCount)

		{}

	TAddressParms(const TDmaTransferArgs& aArgs)

		:iSrcAddr(aArgs.iSrcConfig.iAddr),

		iDstAddr(aArgs.iDstConfig.iAddr),

		iTransferCount(aArgs.iTransferCount)

		{}

	/**

	*/

	void Substitute(const TDmaTransferArgs& aTransferArgs);

	/**

	addresses will be offsets from the dma test session's

	chunk base. They must be converted to absolute, *physical* addresses

	*/

	void Fixup(TLinAddr aChunkBase);

	/**

	Check that both the src and destination lie within the area

	defined by aStart and aSize

	*/

	TBool CheckRange(TLinAddr aStart, TUint aSize);

	TAddrRange SourceRange() const;

	TAddrRange DestRange() const;

	TBool Overlaps(const TAddrRange aRange) const;

	TBool Overlaps(const TAddressParms aParm) const;

	TBool operator==(const TAddressParms& aOther) const;

	static void SelfTest();

	TUint32 iSrcAddr;

	TUint32 iDstAddr;

	TUint iTransferCount;

	};

// These functions can be used for accessing TDmaTransferArgs in

// terms of TAddressParms. (TAddressParms would be a natural base

// class for TDmaTransferArgs but changing the production code

// is undesirable)

TAddressParms GetAddrParms(const TDmaTransferArgs&);

void SetAddrParms(TDmaTransferArgs&, const TAddressParms&);

/**

This struct holds the arguments which can be used with TDmaChannel::IsrRedoRequest

*/

struct TIsrRequeArgs : public TAddressParms

	{

	TIsrRequeArgs(TUint32 aSrcAddr=KPhysAddrInvalidUser, TUint32 aDstAddr=KPhysAddrInvalidUser,

			TUint aTransferCount=0, TUint32 aPslRequestInfo=0,

			TBool aIsrCb=ETrue)

		: TAddressParms(aSrcAddr, aDstAddr, aTransferCount), iPslRequestInfo(aPslRequestInfo), iIsrCb(aIsrCb)

		{}

	TInt Call(TDmaChannel& aChannel);

	TBool CheckRange(TLinAddr aStart, TUint aSize) const;

	TUint32 iPslRequestInfo;

	TBool iIsrCb;

	};

class CISrRequeTest;

/**

A collection of TIsrRequeArgs

*/

struct TIsrRequeArgsSet

	{

	TIsrRequeArgsSet(TIsrRequeArgs* aRequeueArgs=NULL, TInt aCount =0)

		:iCount(aCount), iIndex(0)

		{

		TEST_ASSERT(iCount <= MaxCount);

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

			{

			iRequeArgs[i] = aRequeueArgs[i];

			}

		}

	TBool IsEmpty() const

		{return iCount == 0;}

	TIsrRequeArgs GetArgs();

	void Substitute(const TDmaTransferArgs& aTransferArgs);

	void Fixup(TLinAddr aChunkBase);

	TBool CheckRange(TLinAddr aAddr, TUint aSize) const;

private:

	enum {MaxCount=6};

	TInt iCount;

	TInt iIndex;

	TIsrRequeArgs iRequeArgs[MaxCount];

	};

class DDmaTestSession;

class RDmaSession : public RBusLogicalChannel

	{

	friend class DDmaTestSession;

public:

#ifndef __KERNEL_MODE__

	TInt ChannelIsQueueEmpty(TUint aDriverCookie,TBool& aQueueEmpty)

		{

		return DoControl(EIsQueueEmpty, reinterpret_cast<TAny*>(aDriverCookie),	&aQueueEmpty);		

		}

	TInt ChannelIsOpened(TUint aDriverCookie,TBool &aChannelOpen)

		{

		return DoControl(EIsOpened, reinterpret_cast<TAny*>(aDriverCookie), &aChannelOpen);		

		}

	TInt ChannelCancelAll(TUint aDriverCookie)

		{	

		return DoControl(ECancelAllChannel, reinterpret_cast<TAny*>(aDriverCookie));

		}

	TInt ChannelOpen(TUint aPslCookie,  TUint& aDriverCookie)

		{

		return DoControl(EOpenChannel, reinterpret_cast<TAny*>(aPslCookie), &aDriverCookie);

		}

	TInt ChannelClose(TUint aDriverCookie)

		{	

		return DoControl(ECloseChannel, reinterpret_cast<TAny*>(aDriverCookie));

		}

	TInt ChannelPause(TUint aDriverCookie)

		{	

		return DoControl(EPauseChannel, reinterpret_cast<TAny*>(aDriverCookie));

		}

	TInt ChannelResume(TUint aDriverCookie)

		{	

		return DoControl(EResumeChannel, reinterpret_cast<TAny*>(aDriverCookie));

		}

	TInt ChannelCaps(TUint aDriverCookie, SDmacCaps& aChannelCaps)

		{

		TDmacTestCaps caps;

		TInt r = ChannelCaps(aDriverCookie, caps);

		aChannelCaps = caps;

		return r;

		}

	TInt ChannelCaps(TUint aDriverCookie, TDmacTestCaps& aChannelCaps)

		{

		TPckg<TDmacTestCaps> package(aChannelCaps);

		return DoControl(EChannelCaps, reinterpret_cast<TAny*>(aDriverCookie), &package);

		}

	TInt Open()

		return DoCreate(KTestDmaLddName,TestDmaLddVersion(), 0, NULL, NULL, EOwnerThread);

		}

		{	

		return DoRequestCreate(aChannelCookie, EFalse, aMaxTransferSize, aRequestCookie);

		}

		{

		return DoRequestCreate(aChannelCookie, ETrue, aMaxTransferSize, aRequestCookie);

		}

	TInt RequestDestroy(TUint aRequestCookie)

		{	

		return DoControl(ERequestClose, reinterpret_cast<TAny*>(aRequestCookie));

		}

	TInt RequestFragmentCount(TUint aRequestCookie)

		{	

		return DoControl(EFragmentCount, reinterpret_cast<TAny*>(aRequestCookie));

		}

	/**

	Will fragment a DMA request using the legacy API

	*/

	TInt FragmentRequestOld(TUint aRequestCookie, const TDmaTransferArgs& aTransferArgs, TUint64* aDurationMicroSecs=NULL)

		{

		const TFragmentArgs args(aRequestCookie, aTransferArgs, aDurationMicroSecs);

		TPckgC<TFragmentArgs> package(args);

		return DoControl(EFragmentLegacy, &package);

		}

	/**

	Will fragment a DMA request using the new API

	*/

	TInt FragmentRequest(TUint aRequestCookie, const TDmaTransferArgs& aTransferArgs, TUint64* aDurationMicroSecs=NULL)

		{

		const TFragmentArgs args(aRequestCookie, aTransferArgs, aDurationMicroSecs);

		TPckgC<TFragmentArgs> package(args);

		return DoControl(EFragment, &package);

		}

	TInt QueueRequest(TUint aRequestCookie, TRequestStatus& aStatus, TCallbackRecord* aRecord = NULL, TUint64* aDurationMicroSecs=NULL)

		{

		//These dummy values can accept the writeback from the driver

		//if the client does not want them.

		//(TClientDataRequest can not be programmed with a NULL to

		//indicate that an argument is unwanted)

		TCallbackRecord dummyRec;

		TUint64 dummyTime=0;