// Copyright (c) 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\system\d_khal.cpp

// LDD for testing class Kern HAL APIs

// Kern::AddHalEntry(), Kern::RemoveHalEntry(), Kern::FindHalEntry()

// 

//

#include <kernel/kernel.h>

#include "d_khal.h"

#define KMaxDeviceNumber 8 // same as KMaxHalEntries

TUint 	gDeviceNumber=1;			// Device Number

TUint	gRegisteredDeviceNumber;	// Holds the device number which we managed to register for

TBool	gEntryForDevice0Registered; // indicator whether the device0 got registered

TBool	gEntryForDeviceXRegistered;	// States HAL Entry Successfully registered or not

TBool	gFirstCall=ETrue;			// for add function, this tells if this is first call or not

class DKHalLDDTestFactory : public DLogicalDevice

//

// Test LDD factory

//

	{

public:

	DKHalLDDTestFactory();

	virtual TInt Install(); 								//overriding pure virtual

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

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

	};

class DKHalLDDTestChannel : public DLogicalChannelBase

//

// Test logical channel

//

	{

public:

	virtual ~DKHalLDDTestChannel();

protected:

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

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

	};

LOCAL_C TInt halFunction0(TAny* /*aPtr*/, TInt aFunction, TAny* /*a1*/, TAny* /*a2*/)

	{

	TInt r=KErrNotSupported;

	switch(aFunction)

		{

		case RLddKHalTest::ETestHalFunc:

			Kern::Printf("HAL function0 called successfully !");

			r=KErrNone; // just return KErrNone

			break;

		default:

			break;

		}

	return r;

	}

LOCAL_C TInt halFunctionX(TAny* /*aPtr*/, TInt aFunction, TAny* /*a1*/, TAny* /*a2*/)

	{

	TInt r=KErrNotSupported;

	switch(aFunction)

		{

		case RLddKHalTest::ETestHalFunc:

			Kern::Printf("HAL functionX called successfully !");

			r=KErrNone; // just return KErrNone

			break;

		default:

			break;

		}

	return r;

	}

DECLARE_STANDARD_LDD()

	{

	return new DKHalLDDTestFactory;

	}

//

// Constructor

//

DKHalLDDTestFactory::DKHalLDDTestFactory()

	{

	}

TInt DKHalLDDTestFactory::Create(DLogicalChannelBase*& aChannel)

	{

//

// Create new channel

//  

	aChannel=new DKHalLDDTestChannel;

	return aChannel?KErrNone:KErrNoMemory;

	}

TInt DKHalLDDTestFactory::Install()

//

// Install the LDD - overriding pure virtual

	{

	return SetName(&KLddName);

	}

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

//

// Get capabilities - overriding pure virtual

//

	{

	}

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

//

// Create channel

//

	{

	return KErrNone;

	}

DKHalLDDTestChannel::~DKHalLDDTestChannel()

//

// Destructor

//

	{

	}

TInt DKHalLDDTestChannel::Request(TInt aReqNo, TAny* /*a1*/, TAny* /*a2*/)

	{

	TInt r=KErrNone;

	switch(aReqNo)

		{

		case RLddKHalTest::EAddHalEntryDevice0:

			{

			// try to register the halfunction for PlatformSpecific category, device 0

            NKern::ThreadEnterCS();

			r=Kern::AddHalEntry(EHalGroupPlatformSpecific2,halFunction0,this);

			NKern::ThreadLeaveCS();

			//this function gets called twice, second time must not changed these values

			if (gFirstCall)

				{

				if (r==KErrNone)

					{

					gEntryForDevice0Registered=ETrue;

					}

				else

					{

					gEntryForDevice0Registered=EFalse;

					}

				gFirstCall=EFalse;

				}

			break;

			}

		case RLddKHalTest::EAddHalEntryDeviceX:

			{

			// try to register the halfunction for PlatformSpecific category, device x

            NKern::ThreadEnterCS();

			do

				{

				r=Kern::AddHalEntry(EHalGroupPlatformSpecific2,halFunctionX,this,gDeviceNumber);

				}

            while((r==KErrInUse) && (++gDeviceNumber < KMaxDeviceNumber));

			NKern::ThreadLeaveCS();

			if((gDeviceNumber < KMaxDeviceNumber) && (r==KErrNone))

				{

				gEntryForDeviceXRegistered=ETrue;

				gRegisteredDeviceNumber=gDeviceNumber;

				}

			else

				{

				gEntryForDeviceXRegistered=EFalse;

				r=KErrInUse;

				}

			break;

			}

		case RLddKHalTest::EAddHalEntryForExistingFixed:

			{

			// try to add HAL entry for Kernel, should fail

            NKern::ThreadEnterCS();

			r=Kern::AddHalEntry(EHalGroupKernel,halFunction0,this);

			NKern::ThreadLeaveCS();

			break;

			}

		case RLddKHalTest::ERemoveHalEntryDevice0:

			{

			// try to remove the registered halfunction for device 0

			if(gEntryForDevice0Registered)

				r=Kern::RemoveHalEntry(EHalGroupPlatformSpecific2);

			break;

			}

		case RLddKHalTest::ERemoveHalEntryDeviceX:

			{

			// try to remove the registered halfunction for device x

			if(gEntryForDeviceXRegistered)

				r=Kern::RemoveHalEntry(EHalGroupPlatformSpecific2,gRegisteredDeviceNumber);

			break;

			}

		case RLddKHalTest::ERemoveHalEntryExistingFixed:

			{

			// try to remove EGroupHalKernel. This operation should return an error

			r=Kern::RemoveHalEntry(EHalGroupKernel);

			break;

			}

		case RLddKHalTest::EGetRegisteredDeviceNumber:

			{

			// return the device number which we managed to register

			if(gEntryForDeviceXRegistered)

				{

				r=gRegisteredDeviceNumber;

				}

			else

				{

				r=KErrNotFound;

				}

			break;

			}

		case RLddKHalTest::EFindHalEntryDevice0:

			{

			SHalEntry* pEntry=Kern::FindHalEntry(EHalGroupPlatformSpecific2);

			// returns valid pEntry if EAddHalEntryForDevice0 managed to register

			// an entry earlier

			if (pEntry && pEntry->iFunction!=NULL)

				{

				r=KErrNone;

				}

			else

				{

				r=KErrNotFound;

				}

			break;

			}

		case RLddKHalTest::EFindHalEntryDevice0Other:

			{

			SHalEntry* pEntry=Kern::FindHalEntry(EHalGroupKernel);

			//try to find an existing HAL group (kernel must exist)

			if (pEntry && pEntry->iFunction!=NULL)

				{

				r=KErrNone;

				}

			else

				{

				r=KErrNotFound;

				}

			break;

			}

		case RLddKHalTest::EFindHalEntryDeviceX:

			{

			SHalEntry* pEntry=Kern::FindHalEntry(EHalGroupPlatformSpecific2,gRegisteredDeviceNumber);

			// Should return valid pEntry if EAddHalEntryForDeviceX managed to register

			// one earlier

			if (pEntry && pEntry->iFunction!=NULL)

				{

				r=KErrNone;

				}

			else

				{

				r=KErrNotFound; 

				}

			break;

			}

		default:

			r=KErrNotSupported;

			break;

		} 

	return r;

	}