// Copyright (c) 2007-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:

//

#include <kernel/kernel.h>

#include <drivers/resourceman.h>

#include "d_prmacctst.h"

#ifdef RESOURCE_MANAGER_SIMULATED_PSL

#include "../resourceman_psl/rescontrol_psl.h"

#endif // RESOURCE_MANAGER_SIMULATED_PSL

#define TEST_KERRNONE(x) { TInt  _r = (x); if (_r != KErrNone) \

	Kern::Printf("Test failed: %s line %d error %d", __FILE__, __LINE__, _r); }

#define TEST(x) { if (!(x)) Kern::Printf("Test failed: %s line %d", __FILE__, __LINE__); }

_LIT(KTestDfcQueBaseName, "PrmIfDfc");

const TInt KTestDfcQuePrority = KMaxDfcPriority - 1;

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

class DPrmIfDevice : public DLogicalDevice

	{

public:

	DPrmIfDevice();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

	};

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

class DPrmIfChannel : public DLogicalChannel

	{

public:

	DPrmIfChannel();

	~DPrmIfChannel();

protected:

	virtual void HandleMsg(TMessageBase* aMsg);

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

private:

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

	TInt DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny *a1, TAny *a2);

	void Shutdown();

public:

	static TUint KernelExtensionClientId;

private:

	DThread*		iUserThread;

	TUint			iClientId;

	HBuf*			iClientName;

	};

TUint DPrmIfChannel::KernelExtensionClientId = 0;

void TestCallbackFunction(TUint /* aClientId */,

						  TUint /* aResourceId */,

						  TInt  /* aLevel */,

						  TInt  /* aLevelOwnerId */,

						  TInt  /* aResult */,

						  TAny* aSem);

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

DPrmIfDevice::DPrmIfDevice()

	{

	}

TInt DPrmIfDevice::Install()

	{

	return SetName(&KPrmIfLddName);

	}

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

	{

	// Not used but required as DLogicalDevice::GetCaps is pure virtual

	}

TInt DPrmIfDevice::Create(DLogicalChannelBase*& aChannel)

	{

	aChannel = new DPrmIfChannel;

	return aChannel ? KErrNone : KErrNoMemory;

	}

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

DPrmIfChannel::DPrmIfChannel()

	{

	iUserThread = &Kern::CurrentThread();

	((DObject*) iUserThread)->Open();

	}

DPrmIfChannel::~DPrmIfChannel()

	{

	if(iDfcQ)

	  ((TDynamicDfcQue*)iDfcQ)->Destroy();

	// Close our reference on the client thread

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

	}

void DPrmIfChannel::HandleMsg(TMessageBase *aMsg)

	{

	TThreadMessage& m = *(TThreadMessage*) aMsg;

	TInt id = m.iValue;

	if (id == (TInt) ECloseMsg)

		{

		m.Complete(KErrNone, EFalse);

		return;

		}

	else if (id == KMaxTInt)

		{

		// DoCancel

		m.Complete(KErrNone, ETrue);

		return;

		}

	else if (id < 0)

		{

		// DoRequest

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

		TInt r = DoRequest(~id, pS, m.Ptr1(), m.Ptr2());

		if (r != KErrNone)

			{

			Kern::RequestComplete(iUserThread, pS, r);

			}

		m.Complete(KErrNone, ETrue);

		}

	else

		{

		// DoControl

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

		if(r != KErrCompletion)

			{

			m.Complete(r, ETrue);

			}

		}

	}

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

	{

	TDynamicDfcQue* dfcQ;

	TInt r = Kern::DynamicDfcQCreate(dfcQ, KTestDfcQuePrority, KTestDfcQueBaseName);

	TEST_KERRNONE(r);

	if (r != KErrNone)

		{

		return r;

		}

	dfcQ->SetRealtimeState(ERealtimeStateOff);

	iDfcQ = dfcQ;

	SetDfcQ(iDfcQ);

	iMsgQ.Receive();

	return KErrNone;

	}

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

	{

	TInt r = KErrNotSupported;

	switch (aReqNo)

		{

		case RPrmIf::EControlOpenClient:

			{

			if (iClientId)

				{

				return KErrAlreadyExists;

				}

			TBuf8<80> clientName;

			r = PowerResourceManager::GetClientName((TUint) a1, (TUint) a1, clientName);

			TEST_KERRNONE(r);

			if (r == KErrNone)

				iClientId = (TUint) a1;

			break;

			}

		case RPrmIf::EControlGetKernelExtClientId:

			{

			r = Kern::ThreadRawWrite(iUserThread, a1, &KernelExtensionClientId, sizeof(TUint));

			TEST_KERRNONE(r);

			break;

			}

		case RPrmIf::EControlRegisterClient:

			{

			if (iClientId)

				{

				return KErrAlreadyExists;

				}

			iClientName = HBuf::New(KNameMaxLength);

			r = Kern::ThreadDesRead(iUserThread, a1, *iClientName, 0);

			TEST_KERRNONE(r);

			if (r)

				{

				return r;

				}

			r = PowerResourceManager::RegisterClient(iClientId, *iClientName);

			TEST_KERRNONE(r);

			break;

			}

		case RPrmIf::EControlDeRegisterClient:

			{

			if (!iClientId)

				{

				return KErrNotReady;

				}

			r = PowerResourceManager::DeRegisterClient(iClientId);

			if (r == KErrNone)

				{

				if (iClientId == KernelExtensionClientId)

					{

					// Set it to 0 so it cannot be re-opened

					KernelExtensionClientId = 0;

					}

				delete iClientName;

				iClientId = 0;

				}

			break;

			}

		case RPrmIf::EControlGetInfoOnResourcesInUseByClient:

			{

			if (!iClientId)

				{

				return KErrNotReady;

				}

			TUint nores;

			r = PowerResourceManager::GetNumResourcesInUseByClient(iClientId, (TUint) a1, nores);

			TEST_KERRNONE(r);

			if (r)

				{

				return r;

				}

			if (nores > 0)

				{

				HBuf* resinfo;

				resinfo = HBuf::New(nores * sizeof(TResInfo));

				TEST(resinfo != NULL);

				if (resinfo == NULL)

					{

					return KErrNoMemory;

					}

				r = PowerResourceManager::GetInfoOnResourcesInUseByClient(iClientId, (TUint) a1, nores, (TAny*) resinfo);

				TEST_KERRNONE(r);

				if (r)

					{

					delete resinfo;

					return r;

					}

				r = Kern::ThreadDesWrite(iUserThread, a2, *resinfo, 0);

				TEST_KERRNONE(r);

				delete resinfo;

				}

			break;

			}

		case RPrmIf::EControlChangeResourceState:

			{

			if (!iClientId)

				{

				return KErrNotReady;

				}

			r = PowerResourceManager::ChangeResourceState(iClientId, (TUint) a1, (TInt) a2);

			break;

			}

		case RPrmIf::EControlGetResourceState:

			{

			if (!iClientId)

				{

				return KErrNotReady;

				}

			TInt state;

			TInt levelowner;

			r = PowerResourceManager::GetResourceState(iClientId, (TUint) a1, EFalse, state, levelowner);

			TEST_KERRNONE(r);

			if (r)

				{

				return r;

				}

			r = Kern::ThreadRawWrite(iUserThread, a2, (TAny*) &state, sizeof(TInt));

			TEST_KERRNONE(r);

			break;

			}

		case RPrmIf::EControlGetResourceStateCached:

			{

			if (!iClientId)

				{

				return KErrNotReady;

				}

			TInt state;

			TInt levelowner;

			r = PowerResourceManager::GetResourceState(iClientId, (TUint) a1, ETrue, state, levelowner);

			TEST_KERRNONE(r);

			if (r)

				{

				return r;

				}

			r = Kern::ThreadRawWrite(iUserThread, a2, (TAny*) &state, sizeof(TInt));

			TEST_KERRNONE(r);

			break;

			}

		case RPrmIf::EControlGetLevelOwner:

			{

			if (!iClientId)

				{

				return KErrNotReady;

				}

			TInt state;

			TInt levelowner;

			r = PowerResourceManager::GetResourceState(iClientId, (TUint) a1, EFalse, state, levelowner);

			TEST_KERRNONE(r);

			if (r)

				{

				return r;

				}

			r = Kern::ThreadRawWrite(iUserThread, a2, (TAny*) &levelowner, sizeof(TInt));

			TEST_KERRNONE(r);

			break;

			}

		case RPrmIf::EControlGetTotalNumberOfResources:

			{

			if (!iClientId)

				{

				return KErrNotReady;

				}

			TUint nores;

			r = PowerResourceManager::GetNumResourcesInUseByClient(iClientId, 0, nores);

			TEST_KERRNONE(r);

			if (r)

				{

				return r;

				}

			r = Kern::ThreadRawWrite(iUserThread, a1, (TAny*) &nores, sizeof(TUint));

			TEST_KERRNONE(r);

			break;

			}

#ifdef PRM_ENABLE_EXTENDED_VERSION

		case RPrmIf::EControlGetResourceDependencies:

			{

			if (!iClientId)

				{

				return KErrNotReady;

				}

			// Get the resource information from the PRM

			TUint numres;

			r = PowerResourceManager::GetNumDependentsForResource(iClientId, (TUint) a1, numres);

			TEST_KERRNONE(r);

			if (r)

				{

				return r;

				}

			// Create a descriptor with the list of dependencies

			HBuf* depdes;

			depdes = HBuf::New(sizeof(SResourceDependencyInfo) * numres);

			TEST(depdes != NULL);

			if (depdes == NULL)

				{

				return KErrNoMemory;

				}

			TUint numres2 = numres;

			r = PowerResourceManager::GetDependentsIdForResource(iClientId, (TUint) a1, (TAny*) depdes, numres2);

			TEST_KERRNONE(r);

			TEST(numres == numres2);

			// Copy the descriptor contents to the user-side descriptor

			r = Kern::ThreadDesWrite(iUserThread, a2, *depdes, 0);

			TEST_KERRNONE(r);

			delete depdes;

			break;

			}

#endif // PRM_ENABLE_EXTENDED_VERSION

		}

	return r;

	}

TInt DPrmIfChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny *a1, TAny *a2)

	{

	TInt r = KErrNotSupported;

	switch (aReqNo)

		{

		case RPrmIf::ERequestChangeResourceStateAndGetState:

			{

			if (!iClientId)

				{

				return KErrNotReady;

				}

			TTestResourceStateBuf args;

			r = Kern::ThreadDesRead(iUserThread, a1, args, 0);

			TEST_KERRNONE(r);

			if (r)

				{

				return r;

				}

			NFastSemaphore sem;

			NKern::FSSetOwner(&sem, (NThreadBase*) NKern::CurrentThread());

			TPowerResourceCb cbfn(&TestCallbackFunction, (TAny*) &sem, /*iDfcQ*/ Kern::DfcQue0(), KMaxDfcPriority - 2);

			// Change the state of the resource (asynchronous call)

			r = PowerResourceManager::ChangeResourceState(iClientId, args().iResourceId, args().iNewState, &cbfn);

			TEST_KERRNONE(r);

			if (r)

				{

				return r;

				}

			// Retrieve the intermediate state of the resource

			TInt state;

			TInt levelowner;

			r = PowerResourceManager::GetResourceState(iClientId, args().iResourceId, EFalse, state, levelowner);

			TEST_KERRNONE(r);

			if (r)

				{

				return r;

				}

			r = Kern::ThreadRawWrite(iUserThread, a2, (TAny*) &state, sizeof(TInt));

			TEST_KERRNONE(r);

			if (r)

				{

				return r;

				}

			// Wait for the callback function

			NKern::FSWait(&sem);

			Kern::RequestComplete(iUserThread, aStatus, r);

			break;

			}

		}

	return r;

	}

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

//

// Callback function for Latency Tests

//

void TestCallbackFunction(TUint /* aClientId */,

						  TUint /* aResourceId */,

						  TInt  /* aLevel */,

						  TInt  /* aLevelOwnerId */,

						  TInt  /* aResult */,

						  TAny* aSem)

	{

	if (!aSem)

		{

		return;

		}

	NKern::FSSignal((NFastSemaphore*) aSem);

	}

//

// This function is called during kernel initialisation. It registers a client

// on the PRM in order to take ownership of the Single-User resources before

// anyone else does.

//

static void InitExtension(TAny*)

	{

	TInt r;	

	// Get the overall number of resources

	TUint nores;

	r = PowerResourceManager::GetNumResourcesInUseByClient(DPrmIfChannel::KernelExtensionClientId, 0, nores);

	TEST_KERRNONE(r);

	if (r)

		{

		return;

		}

	// Get hold of all of the resources by setting their state to the default level

	TInt i;

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

		{

		TPowerResourceInfoBuf01 res;

		res.Zero();

		r = PowerResourceManager::GetResourceInfo(DPrmIfChannel::KernelExtensionClientId, i + 1, (TAny*) &res);

		TEST_KERRNONE(r);

		if (r)

			{

			return;

			}

		r = PowerResourceManager::ChangeResourceState(DPrmIfChannel::KernelExtensionClientId, i + 1, res().iDefaultLevel);

		TEST_KERRNONE(r);

		if (r)

			{

			return;

			}

		}

	TUint resinuse;

	r = PowerResourceManager::GetNumResourcesInUseByClient(DPrmIfChannel::KernelExtensionClientId, DPrmIfChannel::KernelExtensionClientId, resinuse);

	TEST_KERRNONE(r);

	TEST(resinuse == nores);

	}

static TDfc InitExtensionDfc(&InitExtension, NULL, Kern::SvMsgQue(), KMaxDfcPriority - 2); // Priority lower than the Resource Controller (KMaxDfcPriority - 1)

#ifndef RESOURCE_MANAGER_SIMULATED_PSL

_LIT8(KTestKExtClientName, "KEXTC");

DECLARE_STANDARD_EXTENSION()

	{

	// Register the initial PRM client (kernel will crash if this fails)

	TUint clientid;

	TInt r = PowerResourceManager::RegisterClient(clientid, KTestKExtClientName);

	TEST_KERRNONE(r);

	if (r)

		{

		return r;

		}

	DPrmIfChannel::KernelExtensionClientId = clientid;

	// Queue the DFC call to take control of all the resources

	InitExtensionDfc.Enque();

	return KErrNone;

	}

DECLARE_EXTENSION_LDD()

	{

	return new DPrmIfDevice;

	}