// 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:

// Test driver for DMA V2 framework

//

//

#include <kernel/kern_priv.h>

#include <drivers/dma.h>

#include "d_dma2.h"

_LIT(KClientPanicCat, "D_DMA2");

_LIT(KDFCThreadName,"D_DMA_DFC_THREAD");

_LIT(KIsrCbDfcThreadName,"D_DMA_IsrCb_thread");

const TInt KDFCThreadPriority=26;

class TStopwatch

	{

public:

	TStopwatch()

		:iStart(0), iStop(0)

		{}

	void Start()

		{iStart = NKern::FastCounter();}

	void Stop()

		{

		iStop = NKern::FastCounter();

		__KTRACE_OPT(KDMA, Kern::Printf(">TStopwatch::Stop FastCounter ticks: iStart=0x%lx iStop=0x%lx", iStart, iStop));

		}

	TUint64 ReadMicroSecs() const

		{

#ifndef __SMP__

		TUint64 diff = 0;

		if(iStart > iStop)

			{

			diff = (KMaxTUint64 - iStart) + iStop;

			}

		else

			{

			diff = iStop - iStart;

			}

		return FastCountToMicroSecs(diff);

#else

		//On SMP it is possible for the value returned from

		//NKern::FastCounter to depend on the current CPU (ie.

		//NaviEngine)

		//

		//One solution would be to tie DFC's and ISR's to the same

		//core as the client, but this would reduce the usefulness of

		//SMP testing.

		return 0;

#endif

		}

private:

	TUint64 FastCountToMicroSecs(TUint64 aCount) const

		{

		const TUint64 countsPerS = NKern::FastCounterFrequency();

		TUint64 timeuS = (aCount*1000000)/countsPerS;

		__KTRACE_OPT(KDMA, Kern::Printf(">TStopwatch::FastCountToMicroSecs FastCounter ticks: aCount=0x%lx countsPerS=0x%lx time=0x%lx", aCount, countsPerS, timeuS));

		return timeuS;

		}

	TUint64 iStart;

	TUint64 iStop;

	};

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

class DClientDmaRequest;

/**

Driver channel. Only accessible by a single client thread

*/

class DDmaTestSession : public DLogicalChannelBase

	{

public:

	DDmaTestSession();

	virtual ~DDmaTestSession();

protected:

	// from DLogicalChannelBase

	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);

	virtual TInt RequestUserHandle(DThread* aThread, TOwnerType aType);

private:

	TInt DoGetInfo(TAny* aInfo);

	TInt OpenDmaChannel(TUint aPslCookie, TUint& aDriverCookie);

	TInt OpenDmaChannel(TUint& aDriverCookie, TDmaChannel::SCreateInfo& aInfo);

	TInt LinkDmaChannelByCookie(TUint aDriverCookie);	

	TInt UnlinkDmaChannelByCookie(TUint aDriverCookie);

	TInt CloseDmaChannelByCookie(TUint aDriverCookie);

	TInt PauseDmaChannelByCookie(TUint aDriverCookie);

	TInt ResumeDmaChannelByCookie(TUint aDriverCookie);

	TInt GetChannelCapsByCookie(TUint aDriverCookie, SDmacCaps& aChannelCaps);

	TInt GetChannelCapsByCookie(TUint aDriverCookie, TDmacTestCaps& aChannelCaps);

	TInt CancelAllByCookie(TUint aDriverCookie);

	TInt IsrRedoRequestByCookie(TUint aDriverCookie,TUint32 aSrcAddr,TUint32 aDstAddr,TInt aTransferCount,TUint32 aPslRequestInfo,TBool aIsrCb);

	TInt IsQueueEmptyByCookie(TUint aDriverCookie, TBool& aQueueEmpty);		

	TInt ChannelIsOpenedByCookie(TUint aDriverCookie, TBool& aChannelOpen);	

	TInt EnableDstElementCountingByCookie(TUint aDriverCookie);

	TInt EnableSrcElementCountingByCookie(TUint aDriverCookie);

	TInt DisableDstElementCountingByCookie(TUint aDriverCookie);

	TInt DisableSrcElementCountingByCookie(TUint aDriverCookie);

	TInt TotalNumDstElementsTransferredByCookie(TUint aDriverCookie);

	TInt TotalNumSrcElementsTransferredByCookie(TUint aDriverCookie);

	void CloseDmaChannelByIndex(TInt aIndex);

	void CancelAllByIndex(TInt aIndex);

	TInt LinkDmaChannelByIndex(TInt aIndex);

	TInt UnlinkDmaChannelByIndex(TInt aIndex);

	TInt PauseDmaChannelByIndex(TInt aIndex);

	TInt ResumeDmaChannelByIndex(TInt aIndex);		

	TInt IsrRedoRequestByIndex(TInt aIndex,TUint32 aSrcAddr,TUint32 aDstAddr,TInt aTransferCount,TUint32 aPslRequestInfo,TBool aIsrCb);

	void EnableDstElementCountingByIndex(TInt aIndex);

	void EnableSrcElementCountingByIndex(TInt aIndex);

	void DisableDstElementCountingByIndex(TInt aIndex);

	void DisableSrcElementCountingByIndex(TInt aIndex);

	TInt TotalNumDstElementsTransferredByIndex(TInt aIndex);

	TInt TotalNumSrcElementsTransferredByIndex(TInt aIndex);

	TInt CreateSharedChunk();

	TUint OpenSharedChunkHandle();

	/**

	Creates a new kernel-side DMA request object, associated with a previously

	opened channel

	@param aChannelCookie - A channel cookie as returned by OpenDmaChannel

	@param aRequestCookie - On success will be a cookie by which the dma request can be referred to

	@param aNewCallback - If true, then a new style DMA callback will be used

	*/

	TInt CreateDmaRequest(TUint aChannelCookie, TUint& aRequestCookie, TBool aNewCallback = EFalse, TInt aMaxFragmentSizeBytes=0);

	/**

	Destroys a previously created dma request object

	*/

	TInt DestroyDmaRequestByCookie(TUint aRequestCookie);

	void DestroyDmaRequestByIndex(TInt aIndex);

	TInt CookieToChannelIndex(TUint aDriverCookie) const;

	TInt CookieToRequestIndex(TUint aRequestCookie) const;

	void MakeAddressesAbsoulute(TDmaTransferArgs& aTransferArgs) const;

	TInt FragmentRequest(TUint aRequestCookie, const TDmaTransferArgs& aTransferArgs, TBool aLegacy=ETrue);

	TInt QueueRequest(TUint aRequestCookie, TRequestStatus* aStatus, TCallbackRecord* aRecord, TUint64* aDurationMicroSecs);

	DClientDmaRequest* RequestFromCookie(TUint aRequestCookie) const;

	TInt RequestFragmentCount(TUint aRequestCookie);

	TDmaV2TestInfo ConvertTestInfo(const TDmaTestInfo& aOldInfo) const;

private:

	DThread* iClient;

	TDynamicDfcQue* iDfcQ;

	TDynamicDfcQue* iIsrCallbackDfcQ; // Will be used by requests which complete with an ISR callback

	static const TInt KMaxChunkSize;

	TLinAddr iChunkBase;

	DChunk* iChunk;

	RPointerArray<TDmaChannel> iChannels;

	RPointerArray<DClientDmaRequest> iClientDmaReqs;

	};

/**

Allows a TClientRequest to be associated with a DDmaRequest

*/

class DClientDmaRequest : public DDmaRequest

	{

public:

	static DClientDmaRequest* Construct(DThread* aClient, TDfcQue* const aDfcQ, TDmaChannel& aChannel, TBool aNewStyle=EFalse, TInt aMaxTransferSize=0);

	~DClientDmaRequest();

	TInt Queue(TRequestStatus* aRequestStatus, TCallbackRecord* aRecord, TUint64* aDurationMicroSecs);

	void AddRequeArgs(const TIsrRequeArgsSet& aRequeArgSet);

	TUint64 GetDuration()

		{return iStopwatch.ReadMicroSecs();}

	/**

	Store a copy of the TDmaTransferArgs which was used for fragmentation

	for argument checking

	*/

	void SetAddressParms(const TDmaTransferArgs& aAddressParms)

		{iFragmentedTransfer = aAddressParms;}

	/**

	Retrieve stored TDmaTransferArgs

	*/

	const TDmaTransferArgs& GetAddressParms() const

		{return iFragmentedTransfer;}

protected:

	TInt Create();

	/** Construct with old style callback */

	DClientDmaRequest(DThread* aClient, TDfcQue* const aDfcQ, TDmaChannel& aChannel, TInt aMaxTransferSize);

	/** Construct with new style callback */

	DClientDmaRequest(DThread* aClient, TDfcQue* const aDfcQ, TDmaChannel& aChannel, TBool aNewStyle, TInt aMaxTransferSize);

private:

	static void CallbackOldStyle(TResult aResult, TAny* aRequest);

	static void Callback(TUint, TDmaResult, TAny*, SDmaDesHdr*);

	static void CompleteCallback(TAny* aRequest);

	void DoCallback(TUint, TDmaResult);

	TBool RedoRequest();

	//!< Used to return a TCallbackRecord and transfer time

	TClientDataRequest2<TCallbackRecord, TUint64>* iClientDataRequest;

	DThread* const iClient;

	TDfcQue* const iDfcQ; //!< Use the DDmaTestSession's dfc queue

	TDfc iDfc;

	TStopwatch iStopwatch;

	TIsrRequeArgsSet iIsrRequeArgSet;

	/**

	This will be updated each time fragment is called.

	It is required so that, at queue time, if ISR re-queue

	arguments are added, they can be checked for sanity

	*/

	TDmaTransferArgs iFragmentedTransfer;

	};

DClientDmaRequest* DClientDmaRequest::Construct(DThread* aClient, TDfcQue* const aDfcQ, TDmaChannel& aChannel, TBool aNewStyle, TInt aMaxTransferSize)

	{

	DClientDmaRequest* dmaRequest = NULL;

	if(aNewStyle)

		{

#ifdef DMA_APIV2

		dmaRequest = new DClientDmaRequest(aClient, aDfcQ, aChannel, aNewStyle, aMaxTransferSize);

#else

		TEST_FAULT; // if a new style dma request was requested it should have been caught earlier

#endif

		}

	else

		{

		dmaRequest = new DClientDmaRequest(aClient, aDfcQ, aChannel, aMaxTransferSize);

		}

	if(dmaRequest == NULL)

		{

		return dmaRequest;

		}

	const TInt r = dmaRequest->Create();

	if(r != KErrNone)

		{

		delete dmaRequest;

		dmaRequest = NULL;

		}

	return dmaRequest;

	}

DClientDmaRequest::DClientDmaRequest(DThread* aClient, TDfcQue* const aDfcQ, TDmaChannel& aChannel, TInt aMaxFragmentSize)

	:DDmaRequest(aChannel, &CallbackOldStyle, this, aMaxFragmentSize),

	iClientDataRequest(NULL),

	iClient(aClient),

	iDfcQ(aDfcQ),

	iDfc(CompleteCallback,NULL, iDfcQ, KMaxDfcPriority)

	{

	}

#ifdef DMA_APIV2

DClientDmaRequest::DClientDmaRequest(DThread* aClient, TDfcQue* const aDfcQ, TDmaChannel& aChannel, TBool /*aNewStyle*/, TInt aMaxFragmentSize)

	:DDmaRequest(aChannel, &Callback, this, aMaxFragmentSize),

	iClientDataRequest(NULL),

	iClient(aClient),

	iDfcQ(aDfcQ),

	iDfc(CompleteCallback,NULL, iDfcQ, KMaxDfcPriority)

	{

	}

#endif

TInt DClientDmaRequest::Create()

	{

	return Kern::CreateClientDataRequest2(iClientDataRequest);

	}

DClientDmaRequest::~DClientDmaRequest()

	{

	__KTRACE_OPT(KDMA, Kern::Printf(">DClientDmaRequest::~DClientDmaRequest")); 

	if(iClientDataRequest)

		{

		Kern::DestroyClientRequest(iClientDataRequest);

		}

	}

/**

Queue the DClientDmaRequest.

@param aRequestStatus Pointer to the client's request status

@param aRecord Pointer to the user's TCallbackRecord, may be null

@return

   -KErrInUse The client request is in use

   -KErrNone success

*/

TInt DClientDmaRequest::Queue(TRequestStatus* aRequestStatus, TCallbackRecord* aRecord, TUint64* aDurationMicroSecs)

	{

	__NK_ASSERT_ALWAYS(aRecord);

	__NK_ASSERT_ALWAYS(aDurationMicroSecs);

	//erase results from last transfer

	iClientDataRequest->Data1().Reset();

	iClientDataRequest->SetDestPtr1(aRecord);

	iClientDataRequest->SetDestPtr2(aDurationMicroSecs);

	TInt r = iClientDataRequest->SetStatus(aRequestStatus);

	if(r != KErrNone)

		{

		return r;

		}

	iStopwatch.Start();

#ifdef DMA_APIV2

	r = DDmaRequest::Queue();

#else

	// old version of queue did not return an error code

	DDmaRequest::Queue();

	r = KErrNone;

#endif

	return r;

	}

void DClientDmaRequest::AddRequeArgs(const TIsrRequeArgsSet& aRequeArgSet)

	{

	iIsrRequeArgSet = aRequeArgSet;

	}

/**

If a transfer complete callback in ISR context s received this will be

called to redo the request with the first entry in the array

@return ETrue If the redo was successful - indicates that another callback is comming

*/

TBool DClientDmaRequest::RedoRequest()

	{

	TIsrRequeArgs args = iIsrRequeArgSet.GetArgs();

	const TInt r = args.Call(iChannel);

	TCallbackRecord& record = iClientDataRequest->Data1();

	record.IsrRedoResult(r);

	return (r == KErrNone);

	}

/**

Calls TDmaChannel::IsrRedoRequest on aChannel

with this object's parameters

*/

TInt TIsrRequeArgs::Call(TDmaChannel& aChannel)

	{

#ifdef DMA_APIV2

	return aChannel.IsrRedoRequest(iSrcAddr, iDstAddr, iTransferCount, iPslRequestInfo, iIsrCb);

#else

	TEST_FAULT;

	return KErrNotSupported;

#endif

	}

/** Translate an old style dma callback to a new-style one

*/

void DClientDmaRequest::CallbackOldStyle(TResult aResult, TAny* aArg)

	{

	__KTRACE_OPT(KDMA, Kern::Printf(">DClientDmaRequest::CallBackOldStyle: TResult result=%d", aResult));

	TEST_ASSERT(aResult != EBadResult);

	//translate result code

	const TDmaResult result = (aResult == EOk) ? EDmaResultOK : EDmaResultError;

	//call the new-style callback

	Callback(EDmaCallbackRequestCompletion, result, aArg, NULL);

	}

/**

The new style callback called by the DMA framework

may be called in either thread or ISR context

*/

void DClientDmaRequest::Callback(TUint aCallbackType, TDmaResult aResult, TAny* aArg, SDmaDesHdr* /*aHdr*/)

	{

	const TInt context = NKern::CurrentContext();

	__KTRACE_OPT(KDMA, Kern::Printf(">DClientDmaRequest::CallBack: TDmaResult result = %d, NKern::TContext context = %d", aResult, context));

	DClientDmaRequest& self = *reinterpret_cast<DClientDmaRequest*>(aArg);

	self.DoCallback(aCallbackType, aResult);

	// decide if callback is complete

	const TBool transferComplete = aCallbackType & EDmaCallbackRequestCompletion;

	if(!transferComplete)

		{

		return;

		}

	// If there are reque args then redo this request

	// another callback would then be expected.

	// Requests can only be re-queued in ISR context, but we

	// do not check that here as it is up to the client to get

	// it right - also, we want to test that the PIL catches this

	// error

	if(!self.iIsrRequeArgSet.IsEmpty())

		{

		// If redo call was succesful, return and wait for next call back

		if(self.RedoRequest())

			return;

		}

	switch(context)

		{

	case NKern::EThread:

		{

		CompleteCallback(aArg);

		break;

		}

	case NKern::EInterrupt:

		{

		self.iDfc.iPtr = aArg;

		self.iDfc.Add();

		break;

		}

	//Fall-through: If context is IDFC or the EEscaped marker occur

	//it is an error

	case NKern::EIDFC:

	case NKern::EEscaped:

	default:

		TEST_FAULT;

		}

	}

/**

Log results of callback. May be called in either thread or ISR context

*/

void DClientDmaRequest::DoCallback(TUint aCallbackType, TDmaResult aResult)

	{

	iStopwatch.Stop(); //sucessive calls will simply over write the stop time

	// This will always be done whether the client requested a

	// callback record or not

	TCallbackRecord& record = iClientDataRequest->Data1();

	record.ProcessCallback(aCallbackType, aResult);

	}

/**

This function may either be called directly or queued as a DFC

*/

void DClientDmaRequest::CompleteCallback(TAny* aArg)

	{

	__KTRACE_OPT(KDMA, Kern::Printf(">DClientDmaRequest::CompleteCallBack thread %O", &Kern::CurrentThread()));

	__ASSERT_NOT_ISR;

	DClientDmaRequest& self = *reinterpret_cast<DClientDmaRequest*>(aArg);

	self.iClientDataRequest->Data2() = self.iStopwatch.ReadMicroSecs();

	//Assert that we called SetRequestStatus on this object before

	//queueing

	__NK_ASSERT_DEBUG(self.iClientDataRequest->IsReady());

	// This is an inelegant, temporary, solution to the following problem:

	//

	// If a dma request completes with an ISR callback the test

	// framework will queue this function as a DFC which

	// will then signal the user-side client. As a consequence of

	// this the user side client may then decide to destroy this

	// request. However, untill the DMA framework's DFC has run

	// and called OnDeque() on this request, it is still considered as

	// queued. Since it is possible that this DFC could run

	// before the DMA fw's DFC, this request could get destroyed while

	// it is stil queued, triggering a PIL assertion.

	//

	// The real fix is likely be for the PIL to call the callback

	// twice, but with different arguments, once to annonunce the

	// ISR and again to announce the dequeue.

	//

	// Here we poll and wait for this request to be dequeued. Note,

	// this DFC is currently run on a separate DFC queue, otherwise

	// it could get deadlocked. An alternative to polling would be

	// to use DCondVar, but that would require PIL modification

	if(NKern::CurrentThread() == self.iDfcQ->iThread)

		{

		// Only need to poll if we aren't on the channel's DFC queue

		for(;;)

			{

			// once the request has been unqueued it

			// can only be queued again by the client

			const TBool queued = __e32_atomic_load_acq32(&self.iQueued);

			if(!queued)

				break;

			__KTRACE_OPT(KDMA, Kern::Printf("Waiting for requeuest to be dequeued"));

			NKern::Sleep(10);

			}

		}

	else

		{

		// If we are on the channel's DFCQ we should be dequeued

		// already

		__NK_ASSERT_DEBUG(!__e32_atomic_load_acq32(&self.iQueued));

		}

	// We can always complete with KErrNone, the actual DMA result is

	// logged in the TCallbackRecord

	Kern::QueueRequestComplete(self.iClient, self.iClientDataRequest, KErrNone);

	}

const TInt DDmaTestSession::KMaxChunkSize = 8 * KMega;

TInt DDmaTestSession::RequestUserHandle(DThread* aThread, TOwnerType aType)

	{

	if (aType!=EOwnerThread || aThread!=iClient)

		return KErrAccessDenied;

	return KErrNone;

	}