// Copyright (c) 2003-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\mmu\d_sharedio.cpp

// LDD for testing SharedIoBuffers

// 

//

#include <kernel/kern_priv.h>

#include "d_sharedio.h"

//

// LDD factory

//

class DSharedIoTestFactory : public DLogicalDevice

	{

public:

	DSharedIoTestFactory();

	~DSharedIoTestFactory();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

public:

	DSharedIoBuffer* iGlobalBuffer;

	};

//

// Logical Channel

//

class DSharedIoTest : public DLogicalChannelBase

	{

public:

	virtual ~DSharedIoTest();

protected:

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

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

public:

	DSharedIoBuffer* iIoBuffer;

	DSharedIoBuffer* iGlobalBuffer;

	DSharedIoTestFactory* iFactory;

#ifndef __WINS__

	TPhysAddr iPhysAddress;

#endif

	};

//

// LDD factory

//

DSharedIoTestFactory::DSharedIoTestFactory()

	{

	iGlobalBuffer=NULL;

	}

DSharedIoTestFactory::~DSharedIoTestFactory()

	{

	delete iGlobalBuffer;

	}

TInt DSharedIoTestFactory::Create(DLogicalChannelBase*& aChannel)

	{

	__KTRACE_OPT(KMMU,Kern::Printf(">DSharedIoTestFactory::Create iGlobalBuffer=%x",iGlobalBuffer));

	if(!iGlobalBuffer)

		{

#ifdef __WINS__

		TUint aAttribs=0;

#else

		TUint aAttribs=EMapAttrSupRw | EMapAttrFullyBlocking;

#endif

		TInt r=DSharedIoBuffer::New(iGlobalBuffer,KSizeGlobalBuffer,aAttribs);

		if(r!=KErrNone)

			return r;

		}

	aChannel=new DSharedIoTest;

	if(!aChannel)

		return KErrNoMemory;

	((DSharedIoTest*)aChannel)->iGlobalBuffer=iGlobalBuffer;

	((DSharedIoTest*)aChannel)->iFactory=this;

	__KTRACE_OPT(KMMU,Kern::Printf("<DSharedIoTestFactory::Create iGlobalBuffer=%x",iGlobalBuffer));

	return KErrNone;

	}

TInt DSharedIoTestFactory::Install()

	{

	return SetName(&KSharedIoTestLddName);

	}

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

	{

	//aDes.FillZ(aDes.MaxLength());

	}

DECLARE_STANDARD_LDD()

	{

	return new DSharedIoTestFactory;

	}

//

// Logical Channel

//

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

	{

	return KErrNone;

	}

DSharedIoTest::~DSharedIoTest()

	{

	delete iIoBuffer;

	}

TInt checkBuffer(TAny* buffer, TUint32 aSize, TUint32 key)

	{

	TInt r=KErrNone;

	TUint8* m=(TUint8*)buffer;

	for(TUint32 size=0;size<aSize;size++,key+=5,m++)

		{

		if(*m!=(TUint8)(key%256))

			{

			r=KErrCorrupt;

			break;

			}

		}

	return r;

	}

TInt fillBuffer(TAny* buffer, TUint32 aSize, TUint32 key)

	{

	TUint8* m=(TUint8*)buffer;

	for(TUint32 size=0;size<aSize;size++,key+=5,m++)

		{

		*m=(TUint8)(key%256);

		}

	return KErrNone;

	}

static void AppendNumToBuf(TDes8& aDes, const TDesC& aNum, TInt width, char fill)

{

	TInt l = aNum.Length();

	for (; l < width; ++l)

		aDes.Append(TChar(fill));

	aDes.Append(aNum);

}

static void DumpMemory(TUint8* aStart, TInt aSize)

{

	TBuf8<80> line;

	TBuf8<24> val;

	TChar space(' ');

	TInt i = (TInt)aStart & 0xF;	// first byte in this line to dump

	TInt n = 16;					// end byte in this line

	while (aSize > 0)

		{

		if (i + aSize < 16)

			n = i + aSize;

		val.Num((TUint32)aStart & ~0xF, EHex);

		AppendNumToBuf(line, val, 8, '0');

		line.Append(space);

		line.Append(space);

		TInt j;

		for (j = 0; j < i; ++j)

			{

			line.Append(space);

			line.Append(space);

			line.Append(space);

			if (j == 7) line.Append(space);

			}

		for (; j < n; ++j)

			{

			val.Num(aStart[j-i], EHex);

			line.Append(space);

			AppendNumToBuf(line, val, 2, '0');

			if (j == 7) line.Append(space);

			}

		for (; j < 16; ++j)

			{

			line.Append(space);

			line.Append(space);

			line.Append(space);

			if (j == 7) line.Append(space);

			}

		line.Append(space);

		line.Append(space);

		for (j = 0; j < i; ++j)

			line.Append(space);

		for (; j < n; ++j)

			{

			char c = aStart[j-i];

			if (c < ' ' || c > 126) c = '.';

			line.Append(TChar(c));

			}

		Kern::Printf("%S", &line);

		line.SetLength(0);

		aStart += (n - i);

		aSize -= (n - i);

		i = 0;

		}

}

TBool CheckMemCleared(TLinAddr aAddress, TInt aSize)

{

	TUint8* aPtr = (TUint8*)aAddress;

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

		{

		if(aPtr[i] != 0x03)

			{

			Kern::Printf("CheckMemCleared(0x%x, %d) failed at i = 0x%x", aAddress, aSize, i);

			// Start on current line & ~0xF, run for 16 lines x 16 bytes

			TUint8 *p = (TUint8*)((aAddress + i) & ~0x0F);

			TInt n = 256;

			if (p < aPtr) p = aPtr;

			if (p - aPtr > aSize - n)	// if (p + n > aPtr + aSize) rearranged (to avoid overflow)

				n = aPtr + aSize - p;

			DumpMemory(p, n);

			return EFalse;

			}

		}

	return ETrue;

}

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

	{

	TInt r=KErrNone;

	switch (aFunction)

		{

		case RTestLdd::ECreateBuffer:

			{

			TUint32 size = (TUint32)a1;

			r = KErrNoMemory;

#ifdef __WINS__

			TUint aAttribs1=0;

			TUint aAttribs2=0;

			TUint aAttribs3=0;

#else

			TUint aAttribs1=EMapAttrSupRw | EMapAttrBufferedNC;

			TUint aAttribs2=EMapAttrSupRw | EMapAttrFullyBlocking;

			TUint aAttribs3=EMapAttrSupRw | EMapAttrCachedMax;

#endif

			NKern::ThreadEnterCS();

			r=DSharedIoBuffer::New(iIoBuffer,size,aAttribs1);

			if(r!=KErrNone)

				{

				Kern::Printf("Error creating buffer r=%d\n",r);

				NKern::ThreadLeaveCS();

				return r;

				}

			//Check the buffer is properly initialized (the previous content 

			//deleted by inserting all 0x03s)

			if (!CheckMemCleared(iIoBuffer->iAddress, iIoBuffer->iSize))

				{

				Kern::Printf("Error memory zeroing test for shared io buffers");

				NKern::ThreadLeaveCS();

				return KErrCorrupt;

				}

			//just test that we can construct a second shared buffer

			DSharedIoBuffer* ptr;

			r=DSharedIoBuffer::New(ptr,size,aAttribs2);

			if(r!=KErrNone)

				{

				Kern::Printf("Error creating the 2nd buffer r=%d\n",r);

				delete iIoBuffer;

				iIoBuffer=NULL;

				NKern::ThreadLeaveCS();

				return r;

				}

			delete ptr; //creation successfull, simply delete the object

			// and the third one, this time fully cached.

			r=DSharedIoBuffer::New(ptr,size,aAttribs3);

			if(r!=KErrNone)

				{

				Kern::Printf("Error creating the 3rd buffer r=%d\n",r);

				delete iIoBuffer;

				iIoBuffer=NULL;

				NKern::ThreadLeaveCS();

				return r;

				}

			delete ptr; //creation successfull, simply delete the object

			NKern::ThreadLeaveCS();

			if(iIoBuffer->iSize!=size)   // test

				{

				Kern::Printf("Error checking size iIoBuffer->iSize=%d size=%d\n",iIoBuffer->iSize,size);

				return KErrGeneral;

				}

			memset((void*)iIoBuffer->iAddress,0,size);

			}

			return r;

		case RTestLdd::EMapInGlobalBuffer:

			{

			if(!iGlobalBuffer)

				return KErrGeneral;

			TUint id;

			kumemget32(&id,a1,sizeof(TUint));

			NKern::ThreadEnterCS();

			Kern::Containers()[EProcess]->Wait();

			DProcess* process=Kern::ProcessFromId(id);

			if(process)

				process->Open();

			Kern::Containers()[EProcess]->Signal();

			if(process)

				{

				r=iGlobalBuffer->UserMap(process);

				process->Close(0);

				}

			else

				r = KErrGeneral;

			NKern::ThreadLeaveCS();

			if(r!=KErrNone)

				return r;

			if(iGlobalBuffer->UserToKernel(iGlobalBuffer->iUserAddress,iGlobalBuffer->iSize)!=iGlobalBuffer->iAddress)

				return KErrGeneral;

			if(iGlobalBuffer->UserToKernel(iGlobalBuffer->iUserAddress,iGlobalBuffer->iSize+1)!=NULL)

				return KErrGeneral;

			if(iGlobalBuffer->KernelToUser(iGlobalBuffer->iAddress)!=iGlobalBuffer->iUserAddress)

				return KErrGeneral;

			kumemput32(a1,&iGlobalBuffer->iUserAddress,sizeof(TAny*));

			kumemput32(a2,&iGlobalBuffer->iSize,sizeof(TInt));

			return KErrNone;

			}

		case RTestLdd::EMapOutGlobalBuffer:

			{

			if(!iGlobalBuffer)

				return KErrGeneral;

			r=iGlobalBuffer->UserUnmap();

			if(r==KErrNone)

				if(iGlobalBuffer->iUserProcess)

					r = KErrGeneral;

			return r;

			}

		case RTestLdd::EDestroyGlobalBuffer:

			{

			NKern::ThreadEnterCS();

			delete iGlobalBuffer;

			iGlobalBuffer = NULL;

			iFactory->iGlobalBuffer=NULL;

			NKern::ThreadLeaveCS();

			return KErrNone;

			}

		case RTestLdd::ECreateBufferPhysAddr:

			{

#ifdef __WINS__

			return KErrNotSupported;

#else

			TUint32 size=Kern::RoundToPageSize(1);

			NKern::ThreadEnterCS();

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

			Kern::Printf("phys addr = %X!\n",iPhysAddress);

			if(r!=KErrNone)

				{

				NKern::ThreadLeaveCS();

				return r;

				}

			r = KErrNoMemory;

			//test that we can construct a fully cached sharedio

			DSharedIoBuffer* ptr;

			r=DSharedIoBuffer::New(ptr,iPhysAddress,size,EMapAttrSupRw|EMapAttrCachedMax);

			if(r!=KErrNone)

				{

				Kern::Printf("Error creating the physical cached buffer r=%d\n",r);

				Epoc::FreePhysicalRam(iPhysAddress,size);

				iPhysAddress=0;

				NKern::ThreadLeaveCS();

				return r;

				}

			delete ptr; //creation successfull, simply delete the object

			r=DSharedIoBuffer::New(iIoBuffer,iPhysAddress,size,EMapAttrSupRw|EMapAttrFullyBlocking);

			if(r!=KErrNone)

				{

				Epoc::FreePhysicalRam(iPhysAddress,size);

				iPhysAddress=0;

				NKern::ThreadLeaveCS();

				return r;

				}

			if(iIoBuffer->iSize!=size)   // test

				{

				delete iIoBuffer;

				iIoBuffer=NULL;

				Epoc::FreePhysicalRam(iPhysAddress,size);

				iPhysAddress=0;

				NKern::ThreadLeaveCS();

				return KErrGeneral;

				}

			fillBuffer((TAny*)iIoBuffer->iAddress,size,180);

			DPlatChunkHw* hwChunk;

			r=DPlatChunkHw::New(hwChunk, iPhysAddress, size, EMapAttrSupRw|EMapAttrFullyBlocking);

			if(r!=KErrNone)

				{

				delete iIoBuffer;

				iIoBuffer=NULL;

				Epoc::FreePhysicalRam(iPhysAddress,size);

				iPhysAddress=0;

				NKern::ThreadLeaveCS();

				return r;

				}

			r=checkBuffer((TAny*)hwChunk->LinearAddress(),size,180);

			if(r!=KErrNone)

				{

				delete iIoBuffer;

				iIoBuffer=NULL;

				hwChunk->Close(NULL);

				Epoc::FreePhysicalRam(iPhysAddress,size);

				iPhysAddress=0;

				NKern::ThreadLeaveCS();

				return r;

				}

			hwChunk->Close(NULL);

			NKern::ThreadLeaveCS();

			return r;

#endif

			}

		case RTestLdd::EDestroyBufferPhysAddr:

			{

#ifdef __WINS__

			return KErrNotSupported;

#else

			TUint32 size=Kern::RoundToPageSize(1);

			NKern::ThreadEnterCS();

			delete iIoBuffer;

			iIoBuffer = NULL;

			r=Epoc::FreePhysicalRam(iPhysAddress,size);

			iPhysAddress=0;

			NKern::ThreadLeaveCS();

			return r;

#endif

			}

		case RTestLdd::EMapInBuffer:

			{

			r=iIoBuffer->UserMap(&Kern::CurrentProcess());

			if(r!=KErrNone)

				return r;

			TAny** p = (TAny**)iIoBuffer->iAddress;

			TAny* ua = (TAny*)iIoBuffer->iUserAddress;

			TAny** end = (TAny**)((TInt)p+iIoBuffer->iSize);

			while(p<end)

				{

				*p++ = ua;

				ua = (TAny*)((TInt)ua+sizeof(TAny*));

				}

			if(iIoBuffer->UserToKernel(iIoBuffer->iUserAddress,iIoBuffer->iSize)!=iIoBuffer->iAddress)

				return KErrGeneral;

			if(iIoBuffer->UserToKernel(iIoBuffer->iUserAddress,iIoBuffer->iSize+1)!=NULL)

				return KErrGeneral;

			if(iIoBuffer->KernelToUser(iIoBuffer->iAddress)!=iIoBuffer->iUserAddress)

				return KErrGeneral;

			kumemput32(a1,&iIoBuffer->iUserAddress,sizeof(TAny*));

			kumemput32(a2,&iIoBuffer->iSize,sizeof(TInt));

			return r;

			}

		case RTestLdd::EMapOutBuffer:

			{

			r=iIoBuffer->UserUnmap();

			if(r==KErrNone)

				if(iIoBuffer->iUserProcess)

					r = KErrGeneral;

			return r;

			}

		case RTestLdd::EDestroyBuffer:

			NKern::ThreadEnterCS();

			delete iIoBuffer;

			iIoBuffer = NULL;

			NKern::ThreadLeaveCS();

			return KErrNone;

		case RTestLdd::ECheckBuffer:

			if(!iIoBuffer->iAddress || !iIoBuffer->iUserAddress || !iIoBuffer->iUserProcess)

				return KErrGeneral;

			return checkBuffer((TAny*)iIoBuffer->iAddress,iIoBuffer->iSize,(TUint32)a1);