// Copyright (c) 2007-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\resourceman\d_rescontrol_cli.cpp

// 

//

#include <kernel/kern_priv.h>

#include <drivers/resource_extend.h>

#include <drivers/resourceman.h>

#include "d_rescontrolcli.h"

#ifdef PRM_ENABLE_EXTENDED_VERSION

#include "dynamicresource.h"

#endif

#include "./resourceman_psl/rescontrol_psl.h"

#ifndef PRM_ENABLE_EXTENDED_VERSION

_LIT(KTestPowerRCName, "D_RESCONTROLCLI.LDD");

#else

_LIT(KTestPowerRCName, "D_EXTENDEDRESCONTROLCLI.LDD");

#endif

const TInt KTestResManLddThreadPriority  = 0x5;

_LIT(KTestResManLddThread, "TestResManLddThread");

#ifdef PRM_ENABLE_EXTENDED_VERSION

#define EXPECTED_POST_NOTI_COUNT 6 //Expected number of notifications as a result of post boot level setting. 

#else

#define EXPECTED_POST_NOTI_COUNT 5

#endif

#define MAX_DYNAMIC_RES_NUM 5

/** 

Structure for holding resource information

*/

struct SClientInfo

	{

	HBuf8* pName;

	TUint iClientId;

	};

/**

The logical device (factory class) for the resource manager client side test.

*/

class DTestResManLddFactory : public DLogicalDevice

	{

public:

	DTestResManLddFactory();

	~DTestResManLddFactory();

	virtual TInt Install();

	virtual void GetCaps(TDes8 &aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

	static void PostBootNotificationFunc(TUint aClientId, TUint aResId, TInt aLevel, TInt aLevelOwnerId, TInt aResult, TAny* aParam);

	void SetPostBootLevelAndRequestNotification(TUint aClientId, TUint aResId, TInt aPostBootLevel);

	TDynamicDfcQue* iDfcQ;

	DStaticPowerResource *iStaticRes;

	DStaticPowerResource *iStaticResArray[3];

	static SClientInfo iClient; //Need to be static to access them in PostBootNotificationFunc (callback function).

	static TUint iPostBootNotiCount;

	};

/** Logical channel class for Resource manager test LDD */

class DTestResManLdd : public DLogicalChannel

	{

public:

	DTestResManLdd();

	virtual ~DTestResManLdd();

	// Inherited from DLogicalChannel

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

	virtual void HandleMsg(TMessageBase* aMsg);

private:

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

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

	TInt DoCancel(TUint aMask);

	static void CallbackFunc(TUint aClientId, TUint aResId, TInt aLevel, TInt aLevelOwnerId, TInt aResult, TAny* aParam);

	static void CondNotificationFunc(TUint aClientId, TUint aResId, TInt aLevel, TInt aLevelOwnerId, TInt aResult, TAny* aParam);

	static void UnCondNotificationFunc(TUint aClientId, TUint aResId, TInt aLevel, TInt aLevelOwnerId, TInt aResult, TAny* aParam);

private:

   	DThread* iClientThreadPtr;

   	TPowerResourceCb iAsyncResourceCallback; //Callback object for handling long latency resources.

	//Structure for storing the notification information

	struct SNotificationList

		{

		TUint iClientId;

		TUint iResourceId;

		TUint iCount;

		DPowerResourceNotification *iNoti;

		SNotificationList *iNext;

		};

	SNotificationList *iCondList; //List for maintaining conditional notification

	SNotificationList *iUnCondList; //List for maintaining unconditional notification

	TRequestStatus *iStatus; //Store the status and complete on callback function.

	TBool iCallbackCancel; 

	TInt iClientId; //ID of the client that requested long latency operation, to compare in callback and notifications.

	TUint iResourceId; //Id of the resource of long latency operation, to compare in callback and notifications.

	//Below 2 variables are used only for asynchronous get resource state operation

	TInt *iStatePtr; //Pointer to hold the address of state variable, where state is updated in callback function.

	TInt *iLevelOwnerIdPtr; //Pointer to hold the address of level owner Id variable, where owner Id is updated in callback function.

	HBuf *pBuf; //Buffer for testing caching of resource information for Idle power management 

	SClientInfo clientInfo[MAX_CLIENTS];

#ifdef PRM_ENABLE_EXTENDED_VERSION

	TUint iTestParallelResourceId; //Variable to hold the long latency resource id, this is used only in test parallel execution of DFC's

	static void TestParallelExecutionCallback(TUint aClientId, TUint aResId, TInt aLevel, TInt aLevelOwnerId, TInt aResult, TAny* aParam);

	TBool iCallbackReceived;

	TBool iValidateCallbackReceived;

	TPowerResourceCb iAsyncTestParallelCallback; //Callback object for handling long latency resources change state while deregistering non-dependency resource.

	RArray <DDynamicPowerResource*> iDynamicArray; //Array to hold dynamic resources. This includes dynamic dependent resource

#endif

	};

//class definition for multilevel single instantaneous positive resource

class DLaterRegisterStaticResource : public DStaticPowerResource

	{

public:

	DLaterRegisterStaticResource();

	TInt DoRequest(TPowerRequest &req);

	TInt GetInfo(TDes8* aInfo) const;

private:

	TInt iMinLevel;

	TInt iMaxLevel;

	TInt iCurrentLevel;

	};

//Constructors of the resource

_LIT(KLaterRegisterStaticResource, "LaterRegisterStaticResource");

DLaterRegisterStaticResource::DLaterRegisterStaticResource() : DStaticPowerResource(KLaterRegisterStaticResource, E_OFF), iMinLevel(0), iMaxLevel(1), iCurrentLevel(0)

	{

	iFlags = KBinary;

	}

TInt DLaterRegisterStaticResource::DoRequest(TPowerRequest& req)

	{

	Kern::Printf("DLaterRegisterStaticResource::DoRequest\n");

	if(req.ReqType() == TPowerRequest::EGet)

		{

		req.Level() = iCurrentLevel;

		}

	else if(req.ReqType() == TPowerRequest::EChange)

		{

		iCurrentLevel = req.Level();

		}

	else if(req.ReqType() == TPowerRequest::ESetDefaultLevel)

		{

		req.Level() = iDefaultLevel;

		iCurrentLevel = iDefaultLevel;

		}

	else

		return KErrNotSupported;

	return KErrNone;

	}

TInt DLaterRegisterStaticResource::GetInfo(TDes8* info) const

	{

	DStaticPowerResource::GetInfo((TDes8*)info);

	TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info;

	buf1->iDefaultLevel = iDefaultLevel;

	buf1->iMinLevel = iMinLevel;

	buf1->iMaxLevel = iMaxLevel;

	return KErrNone;

	}

//class definition for multilevel single instantaneous positive resource

class DLaterRegisterStaticResource1 : public DStaticPowerResource

	{

public:

	DLaterRegisterStaticResource1();

	TInt DoRequest(TPowerRequest &req);

	TInt GetInfo(TDes8* aInfo) const;

private:

	TInt iMinLevel;

	TInt iMaxLevel;

	TInt iCurrentLevel;

	};

//Constructors of the resource

_LIT(KLaterRegisterStaticResource1, "LaterRegisterStaticResource1");

DLaterRegisterStaticResource1::DLaterRegisterStaticResource1() : DStaticPowerResource(KLaterRegisterStaticResource1, E_OFF), iMinLevel(0), iMaxLevel(1), iCurrentLevel(0)

	{

	iFlags = KBinary;

	}

TInt DLaterRegisterStaticResource1::DoRequest(TPowerRequest& req)

	{

	Kern::Printf("DLaterRegisterStaticResource1::DoRequest\n");

	if(req.ReqType() == TPowerRequest::EGet)

		{

		req.Level() = iCurrentLevel;

		}

	else if(req.ReqType() == TPowerRequest::EChange)

		{

		iCurrentLevel = req.Level();

		}

	else if(req.ReqType() == TPowerRequest::ESetDefaultLevel)

		{

		req.Level() = iDefaultLevel;

		iCurrentLevel = iDefaultLevel;

		}

	else

		return KErrNotSupported;

	return KErrNone;

	}

TInt DLaterRegisterStaticResource1::GetInfo(TDes8* info) const

	{

	DStaticPowerResource::GetInfo((TDes8*)info);

	TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info;

	buf1->iDefaultLevel = iDefaultLevel;

	buf1->iMinLevel = iMinLevel;

	buf1->iMaxLevel = iMaxLevel;

	return KErrNone;

	}

//class definition for multilevel single instantaneous positive resource

class DLaterRegisterStaticResource2 : public DStaticPowerResource

	{

public:

	DLaterRegisterStaticResource2();

	TInt DoRequest(TPowerRequest &req);

	TInt GetInfo(TDes8* aInfo) const;

private:

	TInt iMinLevel;

	TInt iMaxLevel;

	TInt iCurrentLevel;

	};

//Constructors of the resource

_LIT(KLaterRegisterStaticResource2, "LaterRegisterStaticResource2");

DLaterRegisterStaticResource2::DLaterRegisterStaticResource2() : DStaticPowerResource(KLaterRegisterStaticResource2, E_OFF), iMinLevel(0), iMaxLevel(1), iCurrentLevel(0)

	{

	iFlags = KBinary;

	}

TInt DLaterRegisterStaticResource2::DoRequest(TPowerRequest& req)

	{

	Kern::Printf("DLaterRegisterStaticResource2::DoRequest\n");

	if(req.ReqType() == TPowerRequest::EGet)

		{

		req.Level() = iCurrentLevel;

		}

	else if(req.ReqType() == TPowerRequest::EChange)

		{

		iCurrentLevel = req.Level();

		}

	else if(req.ReqType() == TPowerRequest::ESetDefaultLevel)

		{

		req.Level() = iDefaultLevel;

		iCurrentLevel = iDefaultLevel;

		}

	else

		return KErrNotSupported;

	return KErrNone;

	}

TInt DLaterRegisterStaticResource2::GetInfo(TDes8* info) const

	{

	DStaticPowerResource::GetInfo((TDes8*)info);

	TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info;

	buf1->iDefaultLevel = iDefaultLevel;

	buf1->iMinLevel = iMinLevel;

	buf1->iMaxLevel = iMaxLevel;

	return KErrNone;

	}

TUint DTestResManLddFactory::iPostBootNotiCount = 0;

SClientInfo DTestResManLddFactory::iClient = {NULL, 0};

DTestResManLddFactory::DTestResManLddFactory()

	{

	iParseMask=0; // Allow info and pdd, but not units

	iUnitsMask=0;

	// Set version number for this device

	iVersion=RTestResMan::VersionRequired();

	}

DTestResManLddFactory::~DTestResManLddFactory()

	{

	if(iDfcQ)

	  iDfcQ->Destroy();

	if(iStaticRes)

		delete iStaticRes;

	if(iStaticResArray[0])

		delete iStaticResArray[0];

	if(iStaticResArray[2])

		delete iStaticResArray[2];

	}

/** Entry point for this driver */

DECLARE_STANDARD_LDD()

	{

	DTestResManLddFactory* p = new DTestResManLddFactory;

	if(!p)

		return NULL;

	TInt r = Kern::DynamicDfcQCreate(p->iDfcQ, KTestResManLddThreadPriority, KTestResManLddThread);

	if(r != KErrNone)

		{

		Kern::Printf("Memory not allocated");

		p->AsyncDelete();

		return NULL;

		}

#ifdef CPU_AFFINITY_ANY

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

#endif

	//Register client with Resource Controller

	TBuf8<32> ClientName(_L8("Client"));

	p->iClient.pName = HBuf::New((const TDesC&)ClientName);

	if(!p->iClient.pName)

		{

		p->iDfcQ->Destroy();

		p->AsyncDelete();

		return NULL;

		}

	//Allocating memory earlier so that during failure conditions can cleanup easily

	p->iStaticRes = new DLaterRegisterStaticResource();

	if(!p->iStaticRes)

		{

		delete p->iClient.pName;

		p->iDfcQ->Destroy();

		p->AsyncDelete();

		return NULL;

		}

	p->iStaticResArray[0] = new DLaterRegisterStaticResource1();

	if(!p->iStaticResArray[0])

		{

		delete p->iStaticRes;

		delete p->iClient.pName;

		p->iDfcQ->Destroy();

		p->AsyncDelete();

		return NULL;

		}	

	p->iStaticResArray[2] = new DLaterRegisterStaticResource2();

	if(!p->iStaticResArray[2])

		{

		delete p->iStaticRes;

		delete p->iStaticResArray[0];

		delete p->iClient.pName;

		p->iDfcQ->Destroy();

		p->AsyncDelete();

		return NULL;

		}

	r = PowerResourceManager::RegisterClient(DTestResManLddFactory::iClient.iClientId, (const TDesC&)*DTestResManLddFactory::iClient.pName);

	if(r != KErrNone)

		{

		Kern::Printf("RegisterClient Failed\n");

		Kern::Fault("PRM REGISTER CLIENT FAILED", __LINE__);

		}

	//Set postbootlevel for these resources.

	p->SetPostBootLevelAndRequestNotification(DTestResManLddFactory::iClient.iClientId, 1, 0);

	p->SetPostBootLevelAndRequestNotification(DTestResManLddFactory::iClient.iClientId, 6, 12);

	p->SetPostBootLevelAndRequestNotification(DTestResManLddFactory::iClient.iClientId, 7, 1);

	p->SetPostBootLevelAndRequestNotification(DTestResManLddFactory::iClient.iClientId, 12, 10);

	p->SetPostBootLevelAndRequestNotification(DTestResManLddFactory::iClient.iClientId, 15, 0);

#ifdef PRM_ENABLE_EXTENDED_VERSION

	p->SetPostBootLevelAndRequestNotification(DTestResManLddFactory::iClient.iClientId, 65537, -50);

#endif

	//Test the later registration of static resources.

	r = DPowerResourceController::RegisterStaticResource(DTestResManLddFactory::iClient.iClientId, p->iStaticRes);

	if(r != KErrNone)

		Kern::Fault("PRM REGISTER STATIC RESOURCE FAILED", __LINE__);

	DStaticPowerResource **resPtr = &p->iStaticResArray[0];

	r = DPowerResourceController::RegisterArrayOfStaticResources(DTestResManLddFactory::iClient.iClientId, resPtr, 3);

	if(r != KErrNone)

		Kern::Fault("PRM REGISTER STATIC RESOURCE FAILED", __LINE__);

	r = DSimulatedPowerResourceController::CompleteResourceControllerInitialisation();

	if(r != KErrNone)

		Kern::Fault("PRM INIT FAILED", __LINE__);

	return p;

	}

void DTestResManLddFactory::SetPostBootLevelAndRequestNotification(TUint aClientId, TUint aResId, TInt aPostBootLevel)

	{

	DPowerResourceController::PostBootLevel(aResId, aPostBootLevel);

	DPowerResourceNotification* iNoti = new DPowerResourceNotification(PostBootNotificationFunc, (TAny*)NULL, Kern::DfcQue0(), 3);

	if(!iNoti)

		{

		Kern::Fault("PRM NOTI FAILED", __LINE__);

		}

	//Passing the address of the object so that it could be deleted in callback function

	new (iNoti) DPowerResourceNotification(PostBootNotificationFunc, iNoti, Kern::DfcQue0(), 3);

	TInt r = PowerResourceManager::RequestNotification(aClientId, aResId, *iNoti);

	if(r != KErrNone)

		Kern::Fault("PRM REQ NOTI FAILED", __LINE__);

	}

/** Second stage constuctor */

TInt DTestResManLddFactory::Install()

	{

   	return(SetName(&KTestPowerRCName));

	}

/** Device capabilities */

void DTestResManLddFactory::GetCaps(TDes8& aDes)const

	{

	// Create a capabilities object

	RTestResMan::TCaps caps;

	caps.iVersion = iVersion;

	// Write it back to user memory

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

	}

/** Create logical channel, only open of one channel is allowed */

TInt DTestResManLddFactory::Create(DLogicalChannelBase*& aChannel)

	{

   	if (iOpenChannels != 0) //A Channel is already open

		return KErrInUse;

	aChannel = new DTestResManLdd;

	if(!aChannel)

		return KErrNoMemory;

	return KErrNone;

	}

/** Constructor */

DTestResManLdd::DTestResManLdd(): iAsyncResourceCallback(CallbackFunc, this, 3)

#ifdef PRM_ENABLE_EXTENDED_VERSION

				, iAsyncTestParallelCallback(TestParallelExecutionCallback, this, 3)

#endif

	{

	iCondList = NULL;

	iUnCondList = NULL;

	iCallbackCancel = EFalse;

	iClientId = 0;

	iResourceId = 0;

	iStatePtr = NULL;

	iLevelOwnerIdPtr = NULL;

	for(TUint c = 0; c < MAX_CLIENTS; c++)

		{

		clientInfo[c].iClientId = 0;

		clientInfo[c].pName = NULL;

		}

	iClientThreadPtr=&Kern::CurrentThread();

	// Increase the DThread's ref count so that it does not close without us

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

	}

/** Destructor */

DTestResManLdd::~DTestResManLdd()

	{

	if(pBuf) //Buffer created for storing idle resource information

		delete pBuf;

#ifdef PRM_ENABLE_EXTENDED_VERSION

	for(TInt c = 0; c < iDynamicArray.Count(); c++)

		{

		delete iDynamicArray[c]; //Delete the dynamic array. This includes dynamic dependent resource.

		}

	iDynamicArray.Close();

#endif

	// Close our reference on the client thread

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

	}

/** Second stage constructor. */

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

	{

   	// Check version

	if (!Kern::QueryVersionSupported(RTestResMan::VersionRequired(),aVer))

		return KErrNotSupported;

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

	iAsyncResourceCallback.SetDfcQ(iDfcQ);

#ifdef PRM_ENABLE_EXTENDED_VERSION

	iAsyncTestParallelCallback.SetDfcQ(iDfcQ);

#endif

 	iMsgQ.Receive();

	return KErrNone;

	}

/** Process a message for this logical channel */

void DTestResManLdd::HandleMsg(TMessageBase* aMsg)

	{

	TThreadMessage& m=*(TThreadMessage*)aMsg;

	TInt id=m.iValue;

	if (id==(TInt)ECloseMsg)

		{

		// Channel close.

		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(iClientThreadPtr,pS,r);

		m.Complete(KErrNone,ETrue);

		}

	else

		{

		// DoControl

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

		m.Complete(r,ETrue);

		}

	}

/** 

	Function used for polling the PostBoot Notification status. 

*/

TBool PollingPostBootStatus(TAny* aLddFactory)

	{

	if(aLddFactory)

		if(((DTestResManLddFactory *)aLddFactory)->iPostBootNotiCount == EXPECTED_POST_NOTI_COUNT)

			return ETrue;

	return EFalse;

	}

/**

  Process synchronous 'control' requests

*/

TInt DTestResManLdd::DoControl(TInt aFunction, TAny* a1, TAny* a2)

	{

	TInt r = KErrNone;

	TParameterListInfo ptr = {0, 0, 0, 0, 0};