// Copyright (c) 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/hcr/d_hcrsim.cpp

//

#include "d_hcrsim.h"

#include <kernel/kernel.h>

#include <plat_priv.h>

#include "hcr_debug.h"

#include "hcr_uids.h"

#ifdef HCRTEST_USERSIDE_INTERFACE

#include "d_hcrsim_testdata.h"

#endif // HCRTEST_USERSIDE_INTERFACE

#define TEST(a)				CheckPoint(a, __LINE__)

#define TEST_KERRNONE(a)	CheckPointError(a, __LINE__)

#ifndef HCRTEST_USERSIDE_INTERFACE

TInt InitExtension();

extern TUint32 PslConfigurationFlags;

#endif // HCRTEST_USERSIDE_INTERFACE

#ifdef HCRTEST_CLIENT_THREAD

#define TEST_ENTERCS()			NKern::ThreadEnterCS()

#define TEST_LEAVECS()			NKern::ThreadLeaveCS()

#define TEST_MEMGET(s, d, l)	kumemget(d, s, l)

#define TEST_MEMPUT(d, s, l)	kumemput(d, s, l)

#define TEST_DESGET(s, d)		Kern::KUDesGet(d, *(TDes8*) s)

#define TEST_DESPUT(d, s)		Kern::KUDesPut(*(TDes8*) d, s)

#else

#define TEST_ENTERCS()

#define TEST_LEAVECS()

#define TEST_MEMGET(s, d, l)	Kern::ThreadRawRead(iClient, s, d, l)

#define TEST_MEMPUT(d, s, l)	Kern::ThreadRawWrite(iClient, d, s, l)

#define TEST_DESGET(s, d)		Kern::ThreadDesRead(iClient, s, d, 0)

#define TEST_DESPUT(d, s)		Kern::ThreadDesWrite(iClient, d, s, 0)

#endif // HCRTEST_CLIENT_THREAD

// Test results for the Kernel Extension initialisation routine

TInt TestKernExtensionTestLine = -1;

TInt TestKernExtensionTestError = -1;

const TUint KTestBenchmarkIterations = 10000;

const TUint KTestGetMultipleBenchmarkIterations = 100;

class DHcrSimTestDrvFactory : public DLogicalDevice

	{

public:

	DHcrSimTestDrvFactory();

	~DHcrSimTestDrvFactory();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

public:

#ifndef HCRTEST_CLIENT_THREAD

	TDynamicDfcQue* iDfcQ;

#endif

	};

#ifdef HCRTEST_CLIENT_THREAD

class DHcrSimTestDrvChannel : public DLogicalChannelBase

#else

class DHcrSimTestDrvChannel : public DLogicalChannel

#endif

	{

public:

	DHcrSimTestDrvChannel();

	~DHcrSimTestDrvChannel();

	// Inherited from DLogicalChannel

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

#ifdef HCRTEST_CLIENT_THREAD

	// Inherited from DLogicalChannelBase: process all DoControl in the user's context

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

#else

	TInt DoControl(TInt aReqNo, TAny* a1, TAny* a2);

	virtual void HandleMsg(TMessageBase* aMsg);

public:

	DThread* iClient;

#endif // HCRTEST_CLIENT_THREAD

	};

void CheckPoint(TInt aCondition, TInt aLine)

	{

	if (!aCondition)

		{

		Kern::Printf("Device driver test failed (line %d)", aLine);

		}

	}

void CheckPointError(TInt aErrorCode, TInt aLine)

	{

	if (aErrorCode != KErrNone)

		{

		Kern::Printf("Device driver error %d (line %d)", aErrorCode, aLine);

		}

	}

void HasRepositoryInSmr(TBool& aHasSmr, TBool& aHasSmrHcr)

	{

	aHasSmr = EFalse;

	aHasSmrHcr = EFalse;

	// Note: the SMR feature by which we obtain the address of the override

	// repository is only supported in the ARM bootstrap, not X86 or WINS so 

	// this test code needs conditional compilation.

#if !defined(__WINS__) && !defined(__X86__)

	const TSuperPage& superpage = Kern::SuperPage();

	TUint32* smrib = (TUint32*) superpage.iSmrData;

	SSmrBank* smrbank = (SSmrBank*) smrib;

	if((smrib != NULL) && (smrib != (TUint32*)KSuperPageAddressFieldUndefined))

		{

		aHasSmr = ETrue;

		while (smrbank->iBase)

			{

			if (smrbank->iPayloadUID == KHCRUID_SMRPayloadUID)

				{

				// We have a HCR repository - assuming it is the test one...

				aHasSmrHcr = ETrue;

				break;

				}

			++smrbank;

			}

		}

#endif // !__WINS__ && !__X86__

	}

#ifdef HCRTEST_USERSIDE_INTERFACE

#define KEXT_TESTKERRNONE(_r)						\

	{												\

	TInt _s = _r;									\

	if ((_s) && !TestKernExtensionTestLine)			\

		{											\

		TestKernExtensionTestError = (_r);			\

		TestKernExtensionTestLine = __LINE__;		\

		}											\

	}

#define KEXT_TEST(_r)								\

	{												\

	if (!(_r) && !TestKernExtensionTestLine)		\

		{											\

		TestKernExtensionTestError = 1;				\

		TestKernExtensionTestLine = __LINE__;		\

		}											\

	}

void KextInitTests()

	{

	TInt r;

	// Get last Setting in Reference Compiled Repository

	TUint32 value1;

	TSettingId setting1(0xFFFFFFFF, 0xFFFFFFFF);

	r = GetUInt(setting1, value1);

	KEXT_TESTKERRNONE(r);

	KEXT_TEST(value1==0x4C415354); // 'L', 'A', 'S', 'T'

	// Determine what test repositories the HCR has loaded

	// Make sure we have the file repository

	const TRomHeader& romheader = Epoc::RomHeader();

	KEXT_TEST(romheader.iHcrFileAddress != NULL); // Assuming this is the test repository (hcr.dat)

	// Find the nand repository

	TBool smr;

	TBool smrrep;

	SSettingC* repos = NULL;

	TInt nosettings = 0;

	HasRepositoryInSmr(smr, smrrep);

	if (smrrep)

		{

		repos = SettingsList6; // File+Nand

		nosettings = sizeof(SettingsList6) / sizeof(SSettingC);

		}

	else if (!smr)

		{

		repos = SettingsList7; // File Only

		nosettings = sizeof(SettingsList7) / sizeof(SSettingC);

		}

	else

		{

		// SMR partitions found but no HCR repository

		KEXT_TEST(0);

		return;

		}

	// Simple word setting Get

	for (SSettingC* setting = repos; setting < repos + nosettings; setting++)

		{

// Note: these macros are irrelevant here, it is just so the two test kernel

// extensions do something different

#ifdef HCRTEST_CLIENT_THREAD

		if (setting->iName.iType == ETypeInt32)

			{

			TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey);

			TInt32 val;

			r = GetInt(id, val);

			KEXT_TESTKERRNONE(r);

			KEXT_TEST(setting->iValue.iLit.iInt32 == val);

			}

#else // !HCRTEST_CLIENT_THREAD

		if (setting->iName.iType == ETypeUInt32)

			{

			TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey);

			TUint32 val;

			r = GetUInt(id, val);

			KEXT_TESTKERRNONE(r);

			KEXT_TEST(setting->iValue.iLit.iUInt32 == val);

			}

#endif // !HCRTEST_CLIENT_THREAD

		}

	// Large setting Get

	for (SSettingC* setting = repos; setting < repos + nosettings; setting++)

		{

// Note: these macros are irrelevant here, it is just so the two test kernel

// extensions do something different

#ifdef HCRTEST_CLIENT_THREAD

		if (setting->iName.iType == ETypeBinData)

			{

			TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey);

			TBuf8<KMaxSettingLength> val;

			TPtrC8 aval(setting->iValue.iPtr.iData, setting->iName.iLen);

			r = GetData(id, val);

			KEXT_TESTKERRNONE(r);

			KEXT_TEST(0 == val.Compare(aval));

			}

#else // !HCRTEST_CLIENT_THREAD

		if (setting->iName.iType == ETypeText8)

			{

			TSettingId id(setting->iName.iId.iCat, setting->iName.iId.iKey);

			TBuf8<KMaxSettingLength> val;

			TPtrC8 aval(setting->iValue.iPtr.iString8, setting->iName.iLen);

			r = GetString(id, val);

			KEXT_TESTKERRNONE(r);

			KEXT_TEST(0 == val.Compare(aval));

			}

#endif // !HCRTEST_CLIENT_THREAD

		}

	// Some other API calls

	TUint i;

	for (i = 0; i < sizeof(KTestCategories) / sizeof(TCategoryUid); i++)

		{

		r = FindNumSettingsInCategory(KTestCategories[i]);

		KEXT_TEST(r >= 0);

		}

	}

DECLARE_EXTENSION_WITH_PRIORITY(KExtensionMaximumPriority)

	{

	// Set these to 0 so we know we've been here

	TestKernExtensionTestLine = 0;

	TestKernExtensionTestError = 0;

	KextInitTests();

	return KErrNone;

	}

#endif // HCRTEST_USERSIDE_INTERFACE

DECLARE_EXTENSION_LDD()

	{

	return new DHcrSimTestDrvFactory;

	}

DHcrSimTestDrvFactory::DHcrSimTestDrvFactory()

	{

	iParseMask = 0;

	iUnitsMask = 0;

	iVersion = TVersion(1,0,KE32BuildVersionNumber);

	}

DHcrSimTestDrvFactory::~DHcrSimTestDrvFactory()

	{

#ifndef HCRTEST_CLIENT_THREAD

	if (iDfcQ)

		iDfcQ->Destroy();

#endif

	}

#ifndef HCRTEST_CLIENT_THREAD

const TInt KHcrSimTestThreadPriority = 1;

_LIT(KHcrSimTestThread,"HcrSimTestThread");

#endif

TInt DHcrSimTestDrvFactory::Install()

	{

	TInt r;

#ifndef HCRTEST_CLIENT_THREAD

	r = Kern::DynamicDfcQCreate(iDfcQ, KHcrSimTestThreadPriority, KHcrSimTestThread);

	if (r != KErrNone)

		return r;

#ifdef HCRTEST_USERSIDE_INTERFACE

	r = SetName(&KTestHcrRealOwn);

#else

	r = SetName(&KTestHcrSimOwn);

#endif // HCRTEST_USERSIDE_INTERFACE

#else

#ifdef HCRTEST_USERSIDE_INTERFACE

	r = SetName(&KTestHcrRealClient);

#else

	r = SetName(&KTestHcrSimClient);

#endif // HCRTEST_USERSIDE_INTERFACE

#endif // HCRTEST_CLIENT_THREAD

	return r;

	}

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

	{

	// Get capabilities - overriding pure virtual

	}

TInt DHcrSimTestDrvFactory::Create(DLogicalChannelBase*& aChannel)

	{

	aChannel=new DHcrSimTestDrvChannel;

	return aChannel?KErrNone:KErrNoMemory;

	}

// ----------------------------------------------------------------------------

DHcrSimTestDrvChannel::DHcrSimTestDrvChannel()

	{

#ifndef HCRTEST_CLIENT_THREAD

	iClient=&Kern::CurrentThread();

	iClient->Open();

#endif

	}

DHcrSimTestDrvChannel::~DHcrSimTestDrvChannel()

	{

#ifndef HCRTEST_CLIENT_THREAD

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

#endif

	}

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

	{

#ifndef HCRTEST_CLIENT_THREAD

	SetDfcQ(((DHcrSimTestDrvFactory*)iDevice)->iDfcQ);

	iMsgQ.Receive();

#endif

	return KErrNone;

	}

#ifndef HCRTEST_CLIENT_THREAD

void DHcrSimTestDrvChannel::HandleMsg(TMessageBase* aMsg)

	{

	TInt r=KErrNone;

	TThreadMessage& m=*(TThreadMessage*)aMsg;

	TInt id=m.iValue;

	if (id==(TInt)ECloseMsg)

		{

		m.Complete(KErrNone,EFalse);

		return;

		}

	else

		{

		r=DoControl(id,m.Ptr0(),m.Ptr1());

		}

	m.Complete(r,ETrue);

	}

#endif // HCRTEST_CLIENT_THREAD

#ifdef HCRTEST_CLIENT_THREAD

TInt DHcrSimTestDrvChannel::Request(TInt aReqNo, TAny* a1, TAny* a2)

#else

TInt DHcrSimTestDrvChannel::DoControl(TInt aReqNo, TAny* a1, TAny* a2)

#endif

	{

	TInt r=KErrNotSupported;

	switch (aReqNo)

		{

		case RHcrSimTestChannel::EHcrGetLinAddr:

			{

			TSettingId setting;

			TLinAddr value;

			TEST_MEMGET(a1, &setting, sizeof(TSettingId));

			r = GetLinAddr(setting, value);

			TEST_MEMPUT(a2, &value, sizeof(value));

			break;

			}

		case RHcrSimTestChannel::EHcrFindNumSettingsInCategory:

			{

			r = FindNumSettingsInCategory((TCategoryUid) a1);

			break;

			}

		case RHcrSimTestChannel::EHcrFindSettingsCategory:

			{

			// Get list of pointers

			TAny* args[6];

			TEST_MEMGET(a1, args, sizeof(args));

			TInt aMaxNum = (TInt) args[1];

			TElementId* ids = NULL;

			TSettingType* types = NULL;

			TUint16* lens = NULL;

			if(args[3])

			    {

			    TEST_ENTERCS();

			    ids = (TElementId*) Kern::Alloc(_ABS(aMaxNum) * sizeof(TElementId));

			    TEST_LEAVECS();

			    }

			if (args[4]) // aTypes

			    {

			    TEST_ENTERCS();

			    types = (TSettingType*) Kern::Alloc(_ABS(aMaxNum) * sizeof(TSettingType));

			    TEST_LEAVECS();

			    }

			if (types == NULL && args[4])

			    {

			    r = KErrNoMemory;

			    }

			else

			    {

			    if (args[5]) // aLens

			        {

			        TEST_ENTERCS();

			        lens = (TUint16*) Kern::Alloc(_ABS(aMaxNum) * sizeof(TUint16));

			        TEST_LEAVECS();

			        }

			    if (lens == NULL && args[5])

			        {

			        r = KErrNoMemory;

			        }

			    else

			        {

			        // Actual API call

			        r = FindSettings((TCategoryUid) args[0],

			                aMaxNum, ids, types, lens);

			        // Send values back to client

			        if (r >= 0)

			            {

			            if(args[3])

			                {

			                TEST_MEMPUT(args[3], ids, _ABS(aMaxNum) * sizeof(TElementId));

			                if (args[4])

			                    {

			                    TEST_MEMPUT(args[4], types, _ABS(aMaxNum) * sizeof(TSettingType));

			                    }

			                if (args[5])

			                    {

			                    TEST_MEMPUT(args[5], lens, _ABS(aMaxNum) * sizeof(TUint16));

			                    }

			                }

			            }

			        if (args[5])

			            {

			            TEST_ENTERCS();

			            Kern::Free(lens);

			            TEST_LEAVECS();

			            }

			        }

			    if (args[4])

			        {

			        TEST_ENTERCS();

			        Kern::Free(types);

			        TEST_LEAVECS();

			        }

			    }

			if(args[3])

			    {

			    TEST_ENTERCS();

			    Kern::Free(ids);

			    TEST_LEAVECS();

			    }

			break;

			}

		case RHcrSimTestChannel::EHcrFindSettingsPattern:

			{

			// Get list of pointers

			TAny* args[8];

			TEST_MEMGET(a1, args, sizeof(args));

			TInt aMaxNum = (TInt) args[1];

			// Allocate temporary memory

			TElementId* ids = NULL;

			TSettingType* types = NULL;

			TUint16* lens = NULL;

			if(args[5])

			    {

			    TEST_ENTERCS();

			    ids = (TElementId*) Kern::Alloc(_ABS(aMaxNum) * sizeof(TElementId));

			    if(!ids)

			        return KErrNoMemory;

			    TEST_LEAVECS();    

			    }