// Copyright (c) 1997-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\misc\d_ipccpy.cpp

// LDD for testing IPC copy functions

// 

//

#include "platform.h"

#include <kernel/kern_priv.h>

#include "d_ipccpy.h"

const TInt KMajorVersionNumber=0;

const TInt KMinorVersionNumber=1;

const TInt KBuildVersionNumber=1;

const TInt KBigBufferSize = 65536;

_LIT(KDIpcCpyPanicCategory,"DIpcCpy");

class DIpcCpyFactory : public DLogicalDevice

//

// IPC copy LDD factory

//

	{

public:

	DIpcCpyFactory();

	~DIpcCpyFactory();

	virtual TInt Install();						//overriding pure virtual

	virtual void GetCaps(TDes8& aDes) const;	//overriding pure virtual

	virtual TInt Create(DLogicalChannelBase*& aChannel);	//overriding pure virtual

private:

	TDynamicDfcQue* iDfcQ;

	};

class DIpcCpy : public DLogicalChannel

//

// Millisecond timer LDD channel

//

	{

public:

	DIpcCpy(TDfcQue* aDfcQ);

	virtual ~DIpcCpy();

protected:

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

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

	virtual void HandleMsg(TMessageBase* aMsg);

public:

	void TimerExpired();

	TInt CreateHardwareChunks(TPtr8& aUserDes);

	// Panic reasons

	enum TPanic

		{

		ERequestAlreadyPending = 1

		};

public:

	DThread* iThread;

	TClientRequest* iAsyncRequest;

	TAny* iDest;

	TInt iSeqNum;

	NTimer iTimer;

	TDfc iDfc;

	TUint8 iBuffer[260];

	TUint8* iBigBuffer;

#ifdef __EPOC32__

	DPlatChunkHw* iHwChunks[RIpcCpy::ENumHwChunkTypes];

#endif

	TLinAddr iHwChunkLinAddrs[RIpcCpy::ENumHwChunkTypes];

	};

DECLARE_STANDARD_LDD()

	{

    return new DIpcCpyFactory;

    }

DIpcCpyFactory::DIpcCpyFactory()

//

// Constructor

//

    {

    iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

    //iParseMask=0;//No units, no info, no PDD

    //iUnitsMask=0;//Only one thing

    }

DIpcCpyFactory::~DIpcCpyFactory()

//

// Destructor

//

	{

	if (iDfcQ)

		iDfcQ->Destroy();

	}

TInt DIpcCpyFactory::Create(DLogicalChannelBase*& aChannel)

//

// Create a new DIpcCpy on this logical device

//

    {

	aChannel=new DIpcCpy(iDfcQ);

    return aChannel?KErrNone:KErrNoMemory;

    }

const TInt KIpcCpyThreadPriority = 27;

_LIT(KIpcCpyThread,"IpcCpyThread");

TInt DIpcCpyFactory::Install()

//

// Install the LDD - overriding pure virtual

//

    {

	// Allocate a kernel thread to run the DFC 

	TInt r = Kern::DynamicDfcQCreate(iDfcQ, KIpcCpyThreadPriority, KIpcCpyThread);

#ifdef CPU_AFFINITY_ANY

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

#endif

	if (r != KErrNone)

		return r; 	

    return SetName(&KIpcCpyLddName);

    }

void DIpcCpyFactory::GetCaps(TDes8& aDes) const

//

// Get capabilities - overriding pure virtual

//

    {

    TCapsIpcCpyV01 b;

    b.iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

    Kern::InfoCopy(aDes,(TUint8*)&b,sizeof(b));

    }

void timerExpired(TAny* aPtr)

	{

	DIpcCpy* p=(DIpcCpy*)aPtr;

	p->iDfc.Add();

	}

void dfcFn(TAny* aPtr)

	{

	DIpcCpy* p=(DIpcCpy*)aPtr;

	p->TimerExpired();

	}

DIpcCpy::DIpcCpy(TDfcQue* aDfcQ)

//

// Constructor

//

	:	iTimer(timerExpired,this),

		iDfc(dfcFn,this,aDfcQ,1)

    {

	iThread=&Kern::CurrentThread();

	iThread->Open();

//	iSeqNum=0;

//	iDest=NULL;

	SetDfcQ(aDfcQ);

    }

DIpcCpy::~DIpcCpy()

	{

	if (iAsyncRequest)

		{

		Kern::QueueRequestComplete(iThread, iAsyncRequest, KErrCancel);	// does nothing if request not pending

		Kern::DestroyClientRequest(iAsyncRequest);

		}

	Kern::Free(iBigBuffer);

	Kern::SafeClose((DObject*&)iThread, NULL);

#ifdef __EPOC32__

	for(TInt i=0; i<RIpcCpy::ENumHwChunkTypes; i++)

		Kern::SafeClose((DObject*&)iHwChunks[i], NULL);

#endif

	}

TInt DIpcCpy::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)

//

// Create channel

//

    {

    if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))

    	return KErrNotSupported;

	TInt r = Kern::CreateClientRequest(iAsyncRequest);

	if (r!=KErrNone)

		return r;

	iBigBuffer = (TUint8*)Kern::Alloc(KBigBufferSize);

	if (!iBigBuffer)

		return KErrNoMemory;

	iMsgQ.Receive();

	return KErrNone;

	}

TInt DIpcCpy::CreateHardwareChunks(TPtr8& aUserDes)

	{

#ifndef __EPOC32__

	(void)aUserDes;

	return KErrNone;

#else

	NKern::ThreadEnterCS();

	TInt r;

	TUint32 size=Kern::RoundToPageSize(1);

#ifdef __X86__

	const TUint attrs[] = { EMapAttrSupRw, EMapAttrUserRw, EMapAttrReadUser }; // X86 does support EMapAttrUserRo, so use EMapAttrReadUser

#else

	const TUint attrs[] = { EMapAttrSupRw, EMapAttrUserRw, EMapAttrUserRo };

#endif

	for(TInt i=0; i<RIpcCpy::ENumHwChunkTypes; i++)

		{

		TPhysAddr phys;

		r = Epoc::AllocPhysicalRam(size,phys);

		if(r!=KErrNone)

			{

			NKern::ThreadLeaveCS();

			return r;

			}

		TChunkCreateInfo info;

		info.iType = TChunkCreateInfo::ESharedKernelMultiple;

		info.iMaxSize = size;

		info.iMapAttr = 0;

		info.iOwnsMemory = EFalse;

		DChunk* chunk;

		TLinAddr base;

		TUint32 attr;

		r = Kern::ChunkCreate(info,chunk,base,attr);

		if(r==KErrNone)

			{

			r=Kern::ChunkCommitPhysical(chunk, 0, size, phys);

			if(r==KErrNone)

				{

				memcpy((TAny*)base,&aUserDes,sizeof(TPtr8));

				}

			Kern::ChunkClose(chunk);

			if(r==KErrNone)

				r = DPlatChunkHw::New(iHwChunks[i], phys, size, attrs[i]);

			}

		if(r==KErrNone)

			{

			iHwChunkLinAddrs[i] = iHwChunks[i]->LinearAddress();

			}

		else if (r==KErrNotSupported) //ARMv6K && ARMv7 do not support EMapAttrUserRo

			{

			iHwChunkLinAddrs[i] = 0;

			r = KErrNone;			

			}

		else

			{

			Epoc::FreePhysicalRam(phys,size);

			NKern::ThreadLeaveCS();

			return r;

			}

		}

	NKern::ThreadLeaveCS();

	return r;

#endif

	}

TInt DIpcCpy::Request(TInt aFunc, TAny* a1, TAny* a2)

	{

	if (aFunc == RIpcCpy::EControlBigRead)

		{

		TUint size = (TUint)a2;

		if (size > (TUint)KBigBufferSize)

			return KErrOverflow;

		kumemput(a1, iBigBuffer, size);

		return KErrNone;

		}

	else if (aFunc == RIpcCpy::EControlBigWrite)

		{

		TUint size = (TUint)a2;

		if (size > (TUint)KBigBufferSize)

			return KErrOverflow;

		kumemget(iBigBuffer, a1, size);

		return KErrNone;

		}

	else if (aFunc == RIpcCpy::EControlHardwareChunks)

		{

		TPtr8 des(0,0,0);

		kumemget(&des,a2,sizeof(TPtr8));

		TInt r=CreateHardwareChunks(des);

		if(r==KErrNone)

			kumemput(a1, iHwChunkLinAddrs, sizeof(iHwChunkLinAddrs));

		return r;

		}

	return DLogicalChannel::Request(aFunc, a1, a2);

	}

void DIpcCpy::HandleMsg(TMessageBase* aMsg)

	{

	TInt r=KErrNone;

	TThreadMessage& m=*(TThreadMessage*)aMsg;

	TInt id=m.iValue;

	if (id==(TInt)ECloseMsg)

		{

		iTimer.Cancel();

		iDfc.Cancel();

		m.Complete(KErrNone,EFalse);

		iMsgQ.CompleteAll(KErrServerTerminated);

		return;

		}

	else if (id<0)

		{

		TRequestStatus* pS=(TRequestStatus*)m.Ptr0();

		if (iAsyncRequest->SetStatus(pS) != KErrNone)

			Kern::ThreadKill(iThread,EExitPanic,ERequestAlreadyPending,KDIpcCpyPanicCategory);

		if (id==~RIpcCpy::ERequestIpcCpy)

			{

			iDest=m.Ptr1();

			iTimer.OneShot(1);

			}

		else

			{

			r=KErrNotSupported;

			}

		if(r!=KErrNone)

			{

			Kern::QueueRequestComplete(iThread, iAsyncRequest, r);

			r = KErrNone;

			}

		}

	else

		{

		r=KErrNotSupported;

		}

	m.Complete(r,ETrue);

	}

void DIpcCpy::TimerExpired()

	{

	TInt src_offset=iSeqNum&3;

	TInt dest_offset=(iSeqNum>>2)&3;

	TInt length=(iSeqNum>>4)+1;

	TInt i;

	for (i=src_offset; i<length+src_offset; ++i)

		iBuffer[i]=(TUint8)(i+1);

	TPtrC8 ptr(iBuffer+src_offset, length);

	TInt r=Kern::ThreadDesWrite(iThread, iDest, ptr, dest_offset, KChunkShiftBy0, NULL);

	if (r==KErrNone)

		{

		r=iSeqNum;

		if (++iSeqNum==4096)

			iSeqNum=0;

		}

	Kern::QueueRequestComplete(iThread, iAsyncRequest, r);

	}