// 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\d_dma.cpp

// 

//

#include "platform.h"

#include <kernel/kern_priv.h>

#include <drivers/dma.h>

#include "d_dma.h"

_LIT(KClientPanicCat, "D_DMA");

_LIT(KDFCThreadName,"D_DMA_DFC_THREAD");

const TInt KDFCThreadPriority=26;

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

//

// Class abstracting the way DMA buffers are created and destroyed to

// allow tests to run both on WINS and hardware.

//

class TBufferMgr

	{

public:

	TInt Alloc(TInt aIdx, TInt aSize);

	void FreeAll();

	TUint8* Addr(TInt aIdx) const;

	TPhysAddr PhysAddr(TInt aIdx) const;

	TInt Size(TInt aIdx) const;

	enum { KMaxBuf = 8 };

private:

#ifdef __WINS__

	struct {TUint8* iPtr; TInt iSize;} iBufs[KMaxBuf];

#else

	struct {DPlatChunkHw* iChunk; TInt iSize;} iBufs[KMaxBuf];

#endif

	};

#ifdef __WINS__

TUint8* TBufferMgr::Addr(TInt aIdx) const

	{

 	__ASSERT_DEBUG(0 <= aIdx && aIdx < KMaxBuf, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	__ASSERT_DEBUG(iBufs[aIdx].iPtr != NULL, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	return iBufs[aIdx].iPtr;

	}

TInt TBufferMgr::Size(TInt aIdx) const

	{

 	__ASSERT_DEBUG(0 <= aIdx && aIdx < KMaxBuf, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	__ASSERT_DEBUG(iBufs[aIdx].iPtr != NULL, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	return iBufs[aIdx].iSize;

	}

TInt TBufferMgr::Alloc(TInt aIdx, TInt aSize)

	{

 	__ASSERT_DEBUG(0 <= aIdx && aIdx < KMaxBuf, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	__ASSERT_DEBUG(iBufs[aIdx].iPtr == NULL, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	NKern::ThreadEnterCS();

	iBufs[aIdx].iPtr = new TUint8[aSize];

	NKern::ThreadLeaveCS();

	iBufs[aIdx].iSize = aSize;

	return iBufs[aIdx].iPtr ? KErrNone : KErrNoMemory;

	}

void TBufferMgr::FreeAll()

	{

	NKern::ThreadEnterCS();

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

		{

		delete iBufs[i].iPtr;

		iBufs[i].iPtr = NULL;

		}

	NKern::ThreadLeaveCS();

	}

#else

TUint8* TBufferMgr::Addr(TInt aIdx) const

	{

 	__ASSERT_DEBUG(0 <= aIdx && aIdx < KMaxBuf, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	__ASSERT_DEBUG(iBufs[aIdx].iChunk != NULL, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	return (TUint8*)iBufs[aIdx].iChunk->LinearAddress();

	}

TPhysAddr TBufferMgr::PhysAddr(TInt aIdx) const

	{

 	__ASSERT_DEBUG(0 <= aIdx && aIdx < KMaxBuf, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	__ASSERT_DEBUG(iBufs[aIdx].iChunk != NULL, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	return iBufs[aIdx].iChunk->PhysicalAddress();

	}

TInt TBufferMgr::Size(TInt aIdx) const

	{

 	__ASSERT_DEBUG(0 <= aIdx && aIdx < KMaxBuf, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	__ASSERT_DEBUG(iBufs[aIdx].iChunk != NULL, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	return iBufs[aIdx].iSize;

	}

TInt TBufferMgr::Alloc(TInt aIdx, TInt aSize)

	{

 	__ASSERT_DEBUG(0 <= aIdx && aIdx < KMaxBuf, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	__ASSERT_DEBUG(iBufs[aIdx].iChunk == NULL, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	NKern::ThreadEnterCS();

	TPhysAddr phys;

	TInt r = Epoc::AllocPhysicalRam(aSize, phys);

	if (r == KErrNone)

		{

		r = DPlatChunkHw::New(iBufs[aIdx].iChunk, phys, aSize, EMapAttrSupRw | EMapAttrFullyBlocking);

		if (r != KErrNone)

			Epoc::FreePhysicalRam(phys, aSize);

		iBufs[aIdx].iSize = aSize;

		__KTRACE_OPT(KDMA, Kern::Printf("TBufferMgr::Alloc buffer %d linAddr=0x%08x, physAddr=0x%08x, size=%d",

					aIdx, Addr(aIdx), PhysAddr(aIdx), Size(aIdx)));

		}

	NKern::ThreadLeaveCS();

	return r;

	}

void TBufferMgr::FreeAll()

	{

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

		{

		if (iBufs[i].iChunk)

			{

			TPhysAddr base = iBufs[i].iChunk->PhysicalAddress();

			TInt size = iBufs[i].iSize;

			__ASSERT_DEBUG(iBufs[i].iChunk->AccessCount() == 1,

						   Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

			NKern::ThreadEnterCS();

			iBufs[i].iChunk->Close(NULL);

			iBufs[i].iChunk = NULL;

			Epoc::FreePhysicalRam(base, size);

			NKern::ThreadLeaveCS();

			}

		}

	}

#endif

static TInt FragmentCount(DDmaRequest* aRequest)

	{

	TInt count = 0;

	for (SDmaDesHdr* pH = aRequest->iFirstHdr; pH != NULL; pH = pH->iNext)

		count++;

	return count;

	}

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

class DDmaTestChannel : public DLogicalChannelBase

	{

public:

	virtual ~DDmaTestChannel();

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 Execute(const TDesC8& aDes);

	static void Dfc(DDmaRequest::TResult aResult, TAny* aArg);

	TInt DoGetInfo(TAny* aInfo);

	void FreeDmaRequests();

	void FreeClientRequests();

private:

	TUint32 iCookie;

	TBufferMgr iBufMgr;

	TDmaChannel* iChannel;

	enum { KMaxRequests = 8 };

	DDmaRequest* iRequests[KMaxRequests];

	TClientRequest* iClientRequests[KMaxRequests];

	DDmaTestChannel* iMap[KMaxRequests];

	TBool iCloseInCb[KMaxRequests];

	TUint32 iMemMemPslInfo;

	DThread* iClient;

	TDynamicDfcQue* iDfcQ;

	};

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

	{

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

		return KErrAccessDenied;

	return KErrNone;

	}

TInt DDmaTestChannel::DoGetInfo(TAny* aInfo)

	{

	RTestDma::TInfo uinfo;

	const TDmaTestInfo& kinfo = DmaTestInfo();

	uinfo.iMaxTransferSize = kinfo.iMaxTransferSize;

	uinfo.iMemAlignMask = kinfo.iMemAlignMask;

	uinfo.iMaxSbChannels = kinfo.iMaxSbChannels;

	memcpy(&(uinfo.iSbChannels), kinfo.iSbChannels, 4 * kinfo.iMaxSbChannels);

	uinfo.iMaxDbChannels = kinfo.iMaxDbChannels;

	memcpy(&(uinfo.iDbChannels), kinfo.iDbChannels, 4 * kinfo.iMaxDbChannels);

	uinfo.iMaxSgChannels = kinfo.iMaxSgChannels;

	memcpy(&(uinfo.iSgChannels), kinfo.iSgChannels, 4 * kinfo.iMaxSgChannels);

	XTRAPD(r, XT_DEFAULT, kumemput(aInfo, &uinfo, sizeof(RTestDma::TInfo)));

	return r == KErrNone ? KErrDied : KErrGeneral;

	}

// called in thread critical section

TInt DDmaTestChannel::DoCreate(TInt /*aUnit*/, const TDesC8* aInfo, const TVersion& /*aVer*/)

	{

	TPckgBuf<RTestDma::TOpenInfo> infoBuf;

	TInt r=Kern::ThreadDesRead(&Kern::CurrentThread(), aInfo, infoBuf, 0, KChunkShiftBy0);

	if (r != KErrNone)

		return r;

	if (infoBuf().iWhat == RTestDma::TOpenInfo::EGetInfo)

		return DoGetInfo(infoBuf().U.iInfo);

	else

		{

		if (!iDfcQ)

 			{

 			r = Kern::DynamicDfcQCreate(iDfcQ, KDFCThreadPriority, KDFCThreadName);

			if (r != KErrNone)

 				return r;

#ifdef CPU_AFFINITY_ANY

			NKern::ThreadSetCpuAffinity((NThread*)(iDfcQ->iThread), KCpuAffinityAny);			

#endif

 			}	

		iMemMemPslInfo = DmaTestInfo().iMemMemPslInfo;

		iCookie = infoBuf().U.iOpen.iId;

		TDmaChannel::SCreateInfo info;

		info.iCookie = iCookie;

		info.iDfcQ = iDfcQ;

		info.iDfcPriority = 3;

		info.iDesCount = infoBuf().U.iOpen.iDesCount;

		r = TDmaChannel::Open(info, iChannel);

		if (r!= KErrNone)

			return r;

		iClient = &Kern::CurrentThread();

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

			{

			r = Kern::CreateClientRequest(iClientRequests[i]);

			if (r!=KErrNone)

				return r;

			iMap[i] = this;

			TInt max = infoBuf().U.iOpen.iMaxTransferSize;

			if (max)

				{

				// Exercise request with custom limit

				iRequests[i] = new DDmaRequest(*iChannel, Dfc, iMap+i, max);

				}

			else

				{

				// Exercise request with default limit

				iRequests[i] = new DDmaRequest(*iChannel, Dfc, iMap+i);

				}

			if (! iRequests[i])

				return KErrNoMemory;

			iCloseInCb[i] = EFalse;

			}

		return KErrNone;

		}

	}

DDmaTestChannel::~DDmaTestChannel()

	{

	if (iChannel)

		{

		iChannel->CancelAll();

		FreeDmaRequests();

		iChannel->Close();

		}

	FreeClientRequests();

	if (iDfcQ)

		{

		iDfcQ->Destroy();

		}

	iBufMgr.FreeAll();

	}

void DDmaTestChannel::FreeDmaRequests()

	{

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

		{

		delete iRequests[i];

		iRequests[i] = NULL;

		}

	}

void DDmaTestChannel::FreeClientRequests()

	{

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

		{

		Kern::DestroyClientRequest(iClientRequests[i]);

		}

	}

TInt DDmaTestChannel::Request(TInt aFunction, TAny* a1, TAny* a2)

	{

	switch (aFunction)

		{

	case RTestDma::EAllocBuffer:

		return iBufMgr.Alloc((TInt)a1, (TInt)a2);

	case RTestDma::EFreeAllBuffers:

		iBufMgr.FreeAll();

		return KErrNone;

	case RTestDma::EFillBuffer:

		{

		TInt i = (TInt)a1;

		TUint8 val = (TUint8)(TUint)a2;

		memset(iBufMgr.Addr(i), val, iBufMgr.Size(i));

		return KErrNone;

		}

	case RTestDma::ECheckBuffer:

		{

		TInt i = (TInt)a1;

		TUint8 val = (TUint8)(TUint)a2;

		TUint8* p = iBufMgr.Addr(i);

		TUint8* end = p + iBufMgr.Size(i);

		while (p < end)

			if (*p++ != val)

				{

#ifdef _DEBUG

				const TUint8 prevValue = *(p-1);

#endif

				__KTRACE_OPT(KDMA, Kern::Printf("Check DMA buffer number %d failed at offset: %d value: %d(%c)",

												i, p-iBufMgr.Addr(i)-1, prevValue, prevValue));

				return EFalse;

				}

		return ETrue;

		}

	case RTestDma::EFragment:

		{

		RTestDma::TFragmentInfo info;

		kumemget(&info, a1, sizeof info);

		__ASSERT_DEBUG(iBufMgr.Size(info.iSrcBufIdx) == iBufMgr.Size(info.iDestBufIdx),

					   Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

		__ASSERT_DEBUG(info.iSize <= iBufMgr.Size(info.iSrcBufIdx),

					   Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

		__ASSERT_DEBUG(0 <= info.iRequestIdx && info.iRequestIdx < KMaxRequests,

					   Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

#ifdef __DMASIM__

		// DMASIM doesn't use physical addresses

  		TUint32 src = (TUint32)iBufMgr.Addr(info.iSrcBufIdx);

  		TUint32 dest = (TUint32)iBufMgr.Addr(info.iDestBufIdx);

  		TUint KFlags = KDmaMemSrc | KDmaIncSrc | KDmaMemDest | KDmaIncDest;

#else

		TUint32 src = iBufMgr.PhysAddr(info.iSrcBufIdx);

		TUint32 dest = iBufMgr.PhysAddr(info.iDestBufIdx);

		TUint KFlags = KDmaMemSrc | KDmaIncSrc | KDmaPhysAddrSrc |

			KDmaMemDest | KDmaIncDest | KDmaPhysAddrDest | KDmaAltTransferLen;

#endif

		TInt r = iRequests[info.iRequestIdx]->Fragment(src, dest, info.iSize, KFlags, iMemMemPslInfo);

		if (r == KErrNone && info.iRs)

			r = iClientRequests[info.iRequestIdx]->SetStatus(info.iRs);

		return r;

		}

	case RTestDma::EExecute:

		return Execute(*(TDesC8*)a1);

	case RTestDma::EFailNext:

		return iChannel->FailNext((TInt)a1);

	case RTestDma::EFragmentCount:

		{

		TInt reqIdx = (TInt)a1;

		__ASSERT_DEBUG(0 <= reqIdx && reqIdx < KMaxRequests, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

		return FragmentCount(iRequests[reqIdx]);

		}

	case RTestDma::EMissInterrupts:

		return iChannel->MissNextInterrupts((TInt)a1);

	default:

		Kern::PanicCurrentThread(KClientPanicCat, __LINE__);

		return KErrNone; // work-around spurious warning

		}

	}

TInt DDmaTestChannel::Execute(const TDesC8& aDes)

	{

	TBuf8<64> cmd;

	Kern::KUDesGet(cmd, aDes);

	__KTRACE_OPT(KDMA, Kern::Printf("DDmaTestChannel::Execute cmd=%S", &cmd));

	const TText8* p = cmd.Ptr();

	const TText8* pEnd = p + cmd.Length();

	while (p<pEnd)

		{

		TText8 opcode = *p++;

		switch (opcode)

			{

		case 'Q':

			{

			__ASSERT_DEBUG(p < pEnd, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

			TInt nextChar = *p++;

			TInt channel = -1;

			if(nextChar == 'X')

				{

				// Channel should be closed in callback

				__ASSERT_DEBUG(p < pEnd, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

				channel = *p++ - '0';

				iCloseInCb[channel] = ETrue;

				}

			else

				{

				channel = nextChar - '0';

				}

			__ASSERT_DEBUG(0 <= channel && channel < KMaxRequests, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

			iRequests[channel]->Queue();

			break;

			}

		case 'C':

			{

			iChannel->CancelAll();

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

				{

				if(iClientRequests[i]->IsReady())

					iClientRequests[i]->Reset();

				}

			break;

			}

		default:

			Kern::PanicCurrentThread(KClientPanicCat, __LINE__);

			}

		}

	return KErrNone;

	}

void DDmaTestChannel::Dfc(DDmaRequest::TResult aResult, TAny* aArg)

	{

	DDmaTestChannel** ppC = (DDmaTestChannel**)aArg;

	DDmaTestChannel* pC = *ppC;

	TInt i = ppC - pC->iMap;

	TClientRequest* req = pC->iClientRequests[i];

	TInt r = (aResult==DDmaRequest::EOk) ? KErrNone : KErrGeneral;

	if(pC->iCloseInCb[i])

		{

		pC->iCloseInCb[i] = EFalse;

		__KTRACE_OPT(KDMA, Kern::Printf("Close channel in callback"));

		pC->FreeDmaRequests();

		pC->iChannel->Close();

		pC->iChannel = NULL;

		}

	if (req->IsReady())

		Kern::QueueRequestComplete(pC->iClient, req, r);

	}

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

class DDmaTestFactory : public DLogicalDevice

	{

public:

	DDmaTestFactory();

	// from DLogicalDevice

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

	};

DDmaTestFactory::DDmaTestFactory()

    {

    iVersion = TestDmaLddVersion();

    iParseMask = KDeviceAllowUnit;							// no info, no PDD

    // iUnitsMask = 0;										// Only one thing

    }

TInt DDmaTestFactory::Create(DLogicalChannelBase*& aChannel)

    {

	aChannel=new DDmaTestChannel;

	return aChannel ? KErrNone : KErrNoMemory;

    }

TInt DDmaTestFactory::Install()

    {

    return SetName(&KTestDmaLddName);

    }

void DDmaTestFactory::GetCaps(TDes8& /*aDes*/) const

    {

    }

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

DECLARE_STANDARD_LDD()

	{

    return new DDmaTestFactory;

	}