// 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:

// e32\drivers\resourceman\resourcecontrol.cpp

// 

//

#include <drivers/resourcecontrol.h>

#include <drivers/resourcecontrol_trace.h>

#ifdef DEBUG_VERSION

#define GET_CRITICAL_SECTION_COUNT				\

	DThread& thread = Kern::CurrentThread();	\

	TInt CsCount = thread.iNThread.iCsCount;

#define LOCK_AND_CRITICAL_SECTION_COUNT_CHECK						\

	if(thread.iNThread.iCsCount != CsCount)							\

		Kern::Fault("PowerResourceController CScount", __LINE__);	\

	if(PowerResourceController->iResourceMutex->iHoldCount != 0)	\

		Kern::Fault("PowerResourceController HoldCount", __LINE__);

#else

#define GET_CRITICAL_SECTION_COUNT

#define LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

#endif

/** Allow interface class to call this. */

DPowerResourceController* PowerResourceController = NULL;

/** Resource Controller factory class implementation */

#ifdef RESOURCE_MANAGER_SIMULATED_PSL

#ifndef PRM_ENABLE_EXTENDED_VERSION

_LIT(KPddName,"resourcecontroller.pdd");

#else

_LIT(KPddName, "resourcecontrollerextended.pdd");

#endif

#else

#ifndef PRM_ENABLE_EXTENDED_VERSION

_LIT(KPddName, "resman.pdd");

#else

_LIT(KPddName, "resmanextended.pdd");

#endif

#endif

/** Factory class constructor */

DResConPddFactory::DResConPddFactory()

	{

    //Set Version number

    iVersion = DResConPddFactory::VersionRequired();

	}

TInt DResConPddFactory::Install()

    {

    // Set a Name for Resource Controller Factory class object.

    return(SetName(&KPddName));

    }

/**  Called by the kernel's device driver framework to create a Physical Channel. */

TInt DResConPddFactory::Create(DBase*& aChannel, TInt /*aUint*/, const TDesC8* /*anInfo*/, const TVersion& /*aVer*/)

    {

    //Create new interface for each channel.

	DUserSideProxyInterface *pI = new (DUserSideProxyInterface);

	if(!pI)

		return KErrNoMemory;

	pI->iController = PowerResourceController; //Store the resource controller. 

	aChannel = (DBase*)pI;

    return KErrNone;

    }

/**  Called by the kernel's device driver framework to check if this PDD is suitable for use with a Logical Channel.*/

TInt DResConPddFactory::Validate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)

    {

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

		return(KErrNotSupported);

    return KErrNone;

    }

/** Return the driver capabilities */

void DResConPddFactory::GetCaps(TDes8& aDes) const

    {

	// Create a capabilities object

	TCaps caps;

	caps.iVersion = iVersion;

	// Zero the buffer

	TInt maxLen = aDes.MaxLength();

	aDes.FillZ(maxLen);

	// Copy cpabilities

	TInt size=sizeof(caps);

	if(size>maxLen)

	   size=maxLen;

	aDes.Copy((TUint8*)&caps,size);

    }

/** Entry point for a standard physical device driver (PDD) that is also an extension */

#ifndef RESOURCE_MANAGER_SIMULATED_PSL

DECLARE_EXTENSION_PDD()

    {

    return new DResConPddFactory;

    }

#endif

/** Interface class implementation */

TInt TInterface::RegisterClient(TUint& aClientId, const TDesC8& aName, TOwnerType aType)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::RegisterClient"));

	r = PowerResourceController->RegisterClient(aClientId, aName, aType);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::DeRegisterClient(TUint aClientId)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::DeRegisterClient"));

	r = PowerResourceController->DeRegisterClient(aClientId);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::GetClientName(TUint aClientId, TUint aTargetClientId, TDes8& aName)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::GetClientName"));

	r = PowerResourceController->GetClientName(aClientId, aTargetClientId, aName);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::GetClientId(TUint aClientId, TDesC8& aClientName, TUint& aTargetClientId)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::GetClientId"));

	r = PowerResourceController->GetClientId(aClientId, aClientName, aTargetClientId);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::GetResourceId(TUint aClientId, TDesC8& aResourceName, TUint& aResourceId)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::GetResourceId"));

	r = PowerResourceController->GetResourceId(aClientId, aResourceName, aResourceId);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::GetResourceInfo(TUint aClientId, TUint aResourceId, TAny* aInfo)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::GetResourceInfo"));

	r = PowerResourceController->GetResourceInfo(aClientId, aResourceId, aInfo);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::GetNumResourcesInUseByClient(TUint aClientId, TUint aTargetClientId, TUint& aNumResource)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::GetNumResourcesInUseByClient"));

	r = PowerResourceController->GetNumResourcesInUseByClient(aClientId, aTargetClientId, aNumResource);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::GetInfoOnResourcesInUseByClient(TUint aClientId, TUint aTargetClientId, TUint& aNumResources, TAny* aInfo)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::GetInfoOnResourcesInUseByClient"));

	r = PowerResourceController->GetInfoOnResourcesInUseByClient(aClientId, aTargetClientId, aNumResources, aInfo);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::GetNumClientsUsingResource(TUint aClientId, TUint aResourceId, TUint& aNumClients)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::GetNumClientsUsingResource"));

	r = PowerResourceController->GetNumClientsUsingResource(aClientId, aResourceId, aNumClients);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::GetInfoOnClientsUsingResource(TUint aClientId, TUint aResourceId, TUint& aNumClients, TAny* aInfo)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::GetInfoOnClientsUsingResource"));

	r = PowerResourceController->GetInfoOnClientsUsingResource(aClientId, aResourceId, aNumClients, aInfo);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::ChangeResourceState(TUint aClientId, TUint aResourceId, TInt aNewState, TPowerResourceCb* aCb)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::ChangeResourceState"));

	r = PowerResourceController->ChangeResourceState(aClientId, aResourceId, aNewState, aCb);

	if(!aCb) //Not checking incase of asynchronous function as mutex might be held in RC thread, when this is checked.

		{

		LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

		}

	return r;

    }

TInt TInterface::GetResourceState(TUint aClientId, TUint aResourceId, TBool aCached, TInt& aState, TInt& aLevelOwnerId)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::GetResourceState"));

    r = PowerResourceController->GetResourceState(aClientId, aResourceId, aCached, aState, aLevelOwnerId);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::GetResourceState(TUint aClientId, TUint aResourceId, TBool aCached, TPowerResourceCb& aCb)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::GetResourceState"));

    r = PowerResourceController->GetResourceState(aClientId, aResourceId, aCached, aCb);

	if(!&aCb) //Not checking incase of asynchronous function as mutex might be held in RC thread, when this is checked.

		{

		LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

		}

	return r;

    }

TInt TInterface::CancelAsyncRequestCallBack(TUint aClientId, TUint aResourceId, TPowerResourceCb& aCb)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::CancelAsyncRequestCallback"));

    r = PowerResourceController->CancelAsyncRequestCallBack(aClientId, aResourceId, aCb);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::RequestNotification(TUint aClientId, TUint aResourceId, DPowerResourceNotification& aN)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::RequestNotification"));

    r = PowerResourceController->RequestNotification(aClientId, aResourceId, aN);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::RequestNotification(TUint aClientId, TUint aResourceId, DPowerResourceNotification& aN, TInt aThreshold, 

									                                                               TBool aDirection)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::RequestNotification"));

    r = PowerResourceController->RequestNotification(aClientId, aResourceId, aN, aThreshold, aDirection);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::CancelNotification(TUint aClientId, TUint aResourceId, DPowerResourceNotification& aN)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::CancelNotification"));

    r = PowerResourceController->CancelNotification(aClientId, aResourceId, aN);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::DeRegisterClientLevelFromResource(TUint aClientId, TUint aResourceId)

	{

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::DeRegisterClientLevelFromResource"));

    r = PowerResourceController->DeRegisterClientLevelFromResource(aClientId, aResourceId);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

TInt TInterface::AllocReserve(TUint aClientId, TUint8 aNumCl, TUint8 aNumRm)

    {

	GET_CRITICAL_SECTION_COUNT

	TInt r;

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::AllocReserve"));

    r = PowerResourceController->AllocReserve(aClientId, aNumCl, aNumRm);

	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK

	return r;

    }

/** This function is used by export functions of Resource contoller defined in seperate file */

DPowerResourceController* TInterface::GetPowerResourceController(void)

    {

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::GetPowerResourceController"));

    return PowerResourceController;

    }

TInt TInterface::ControlIO(TUint aClientId, TUint aFunction, TAny* aParam1, TAny* aParam2, TAny* aParam3)

    {

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::ControlIO"));

    return PowerResourceController->GetInterface(aClientId, aFunction, aParam1, aParam2, aParam3);

    }

/** Resouce controller panic */

void DPowerResourceController::Panic(TUint8 aPanic)

	{

	Kern::Fault("Power Resource Controller", aPanic);

	}

/** Constructor for power controller. Creates message queue and generates ID for power controller to use. */

DPowerResourceController::DPowerResourceController()

	{

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("DPowerResourceController::DPowerResouceController()"));

	//Constructor is expected to invoke multiple times (during creation, variant init 0 and extension init 1)

	if(PowerResourceController) 

		return;

    PowerResourceController = this;

	iClientList.Initialise(0);

	iUserSideClientList.Initialise(0);

	iInitialised = EResConCreated;

#ifdef PRM_ENABLE_EXTENDED_VERSION

	iDynamicResourceList.Initialise(0);

	iDynamicResDependencyList.Initialise(0);

#endif

	}

/** Destructor for power controller. Frees the memory allocated in kernel heap. */

DPowerResourceController::~DPowerResourceController()

	{

	__KTRACE_OPT(KRESMANAGER, Kern::Printf("DPowerResourceController::~DPowerResourceController()"));

	//Push Power controller ID back to Pool

	SPowerResourceClient* pC = NULL;

	pC = iClientList[(TUint16)(iPowerControllerId & ID_INDEX_BIT_MASK)];

	if(pC)

		{

		iClientCount--; //Decrement client count

		LIST_PUSH(iClientPool, pC, iNextInList);

		}

	iClientList.Delete();

	iUserSideClientList.Delete();

#ifdef PRM_ENABLE_EXTENDED_VERSION

	iDynamicResourceList.Delete();

	iDynamicResDependencyList.Delete();

#endif

	pC = iClientPool;

	while(iClientPool) //Find the starting position of array to delete

		{

		if(iClientPool < pC)

			pC = iClientPool;

		iClientPool = iClientPool->iNextInList;

		}

	//delete pC;

	delete []pC;

	SPowerResourceClientLevel *pCL = iClientLevelPool;

	while(iClientLevelPool) //Find the starting position of array to delete

		{

		if(iClientLevelPool < pCL)

			pCL = iClientLevelPool;

		iClientLevelPool = iClientLevelPool->iNextInList;

		}

	//delete pCL;

	delete []pCL;

	SPowerRequest *pReq = iRequestPool;

	while(iRequestPool) //Find the starting position of array to delete

		{

		if(iRequestPool < pReq)

			pReq = iRequestPool;

		iRequestPool = iRequestPool->iNext;

		}

	//delete pR

	delete []pReq;

#ifdef PRM_ENABLE_EXTENDED_VERSION

	pCL = iResourceLevelPool;

	while(iResourceLevelPool)

		{

		if(iResourceLevelPool < pCL)

			pCL = iResourceLevelPool;

		iResourceLevelPool = iResourceLevelPool->iNextInList;

		}

	//delete resource pool

	delete []pCL;

	//delete Message Queue dependency

	delete iMsgQDependency;

#endif

	//delete Message Queue

	delete iMsgQ;

	}

/** Send notificatins to clients registered for it for the specified resource. */

void DPowerResourceController::CompleteNotifications(TInt aClientId, DStaticPowerResource* aResource, TInt aState, 

													      TInt aReturnCode, TInt aLevelOwnerId, TBool aLock)

	{

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::CompleteNotifications"));

    if(aLock)

		Lock();

    DPowerResourceNotification*pN=NULL;

    for(SDblQueLink* pNL=aResource->iNotificationList.First();pNL!=&aResource->iNotificationList.iA; pNL=pNL->iNext)

		{

        pN = _LOFF(pNL, DPowerResourceNotification, iNotificationLink);

#ifdef PRM_ENABLE_EXTENDED_VERSION

		//If dyanmic resource is deregistering, send notification to all clients requested for it

		if((pN->iCallback.iResourceId & KIdMaskDynamic) && (aClientId == KDynamicResourceDeRegistering))

			{

			pN->iCallback.iResult = aReturnCode;

			pN->iCallback.iLevel = aState;

			pN->iCallback.iClientId = aClientId;

			pN->iCallback.iLevelOwnerId = aLevelOwnerId;

			__KTRACE_OPT(KRESMANAGER, Kern::Printf("Notification ClientId = 0x%x, ResourceId = %d, state = %d, \

				             Result = %d", pN->iCallback.iClientId, pN->iCallback.iResourceId, aState, aReturnCode));

			PRM_POSTNOTIFICATION_SENT_TRACE

			pN->iCallback.Enque();

			continue;

			}	

#endif

		if((pN->iType==DPowerResourceNotification::EUnconditional) || 

				(pN->iDirection && ((pN->iPreviousLevel < pN->iThreshold) && (aState >= pN->iThreshold))) ||

				(!pN->iDirection && ((pN->iPreviousLevel > pN->iThreshold) && (aState <= pN->iThreshold))))

			{

            pN->iCallback.iResult=aReturnCode;

            pN->iCallback.iLevel=aState;

            pN->iCallback.iClientId = aClientId;

			pN->iCallback.iLevelOwnerId = aLevelOwnerId;

			__KTRACE_OPT(KRESMANAGER, Kern::Printf("Notifications ClientId = 0x%x, ResourceId = %d, State = %d, \

				              Result = %d", pN->iCallback.iClientId, pN->iCallback.iResourceId, aState, aReturnCode));

			PRM_POSTNOTIFICATION_SENT_TRACE

            pN->iCallback.Enque();

			}

		pN->iPreviousLevel = aState; //Update the state

		}

	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::CompleteNotifications"));

	if(aLock)

		UnLock();

	return;

	}

/** Complete the asynchronous request. */

void DPowerResourceController::CompleteRequest(TPowerRequest& aRequest)

	{

    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::CompleteRequest"));

 	// Complete notification for state change operation

    DStaticPowerResource* pR=aRequest.Resource();

	//If request in EChange or ESetDefaultValue and no error and if shared resources and if change is done then 

	//issue notification.

	if(((aRequest.ReqType() == TPowerRequest::EChange) || (aRequest.ReqType() == TPowerRequest::ESetDefaultLevel)) 

		         && (aRequest.ReturnCode() == KErrNone) && ((!pR->Usage()) || (pR->Usage() && aRequest.RequiresChange())))

		{	

    	CompleteNotifications(aRequest.ClientId(), aRequest.Resource(), aRequest.Level(), 

		                                                     aRequest.ReturnCode(), aRequest.ClientId());

		}

	//Do not update the level if the resource is shared and change is not required or any error.

    if(aRequest.ReturnCode()==KErrNone && ((aRequest.ReqType() ==TPowerRequest::EGet) || 

		       (((aRequest.ReqType()==TPowerRequest::EChange) || (aRequest.ReqType()==TPowerRequest::ESetDefaultLevel)) 

			   && ((!pR->Usage()) || (pR->Usage() && aRequest.RequiresChange())))))

        {

        Lock();

		// Cache the latest value

        pR->iCachedLevel=aRequest.Level();

		//Need to update client ID only during state change.

		if(aRequest.ReqType() != TPowerRequest::EGet)

			pR->iLevelOwnerId=aRequest.ClientId();

		// Cache Idle list entry for this reosurce if requested.

        if(pR->iIdleListEntry)

            {

            SIdleResourceInfo* pI=pR->iIdleListEntry;

            if(aRequest.ReqType() != TPowerRequest::EGet)

				pI->iLevelOwnerId= aRequest.ClientId();

            pI->iCurrentLevel=aRequest.Level();

            }

         UnLock();

        }

	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::CompleteRequest"));

	}

/** Handle/process the asynchronous request sent to resource controller.

   The request can be one of the following

   1) State change of long latency reosurce

   2) Get the state of long latency resource

   3) Set the default value of long latency resource */

void DPowerResourceController::HandleMsg(TPowerRequest& aRequest)

	{

	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::HandleMsg"));

    DStaticPowerResource* pR=aRequest.Resource();

	//Get client using client ID

	TUint aClientId = aRequest.ClientId();

	SPowerResourceClient* pC = NULL;

#ifdef PRM_ENABLE_EXTENDED_VERSION

	if((TInt)aClientId != KDynamicResourceDeRegistering)

		{

		if(aClientId & USER_SIDE_CLIENT_BIT_MASK)

			pC = iUserSideClientList[TUint16(aClientId & ID_INDEX_BIT_MASK)];

		else

			pC = iClientList[TUint16(aClientId & ID_INDEX_BIT_MASK)];

		}

#else

		if(aClientId & USER_SIDE_CLIENT_BIT_MASK)

			pC = iUserSideClientList[TUint16(aClientId & ID_INDEX_BIT_MASK)];

		else

			pC = iClientList[TUint16(aClientId & ID_INDEX_BIT_MASK)];

#endif		

	__KTRACE_OPT(KRESMANAGER, Kern::Printf("Request Type = %d, ClientId = 0x%x, ResourceId = %d",  \

		                             aRequest.ReqType(), aRequest.ClientId(), aRequest.ResourceId()));

    if(aRequest.ReqType()==TPowerRequest::EChange)

		{

        if(pR->Usage()) //Handling shared resource

			{

			Lock(); //To avoid race condition between deregister resource level.

			aRequest.ReturnCode() = CheckLevelAndAddClient(pC, &aRequest);

			UnLock();

			if((aRequest.ReturnCode()!= KErrNone) || (!aRequest.RequiresChange()))

				{