// 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_extended.cpp

// 

//

#include <drivers/resourcecontrol.h>

extern DPowerResourceController* PowerResourceController;

/**

@internalComponent

@prototype 9.5

Reserves the client level from pool to be used for updating resource client level in dependency resource.

@param aCount Number of client levels to reserve from pool

@return KErrNone On success 

@return KErrNoMemory Not enough memory to grow the pool

*/

TInt DPowerResourceController::ReserveClientLevelPoolCount(TUint16 aCount)

	{

	if(aCount < iResourceLevelPoolCount) 

		iResourceLevelPoolCount = (TUint16)(iResourceLevelPoolCount - aCount);

	else

		{

		TUint allocCount = (iStaticResDependencyCount / 2) + aCount;

		// coverity[alloc_fn]

		SPowerResourceClientLevel* pCL = new SPowerResourceClientLevel[allocCount];

		if(!pCL)

			return KErrNoMemory;

		for(TUint count = 0;count<(TUint)(allocCount);count++)

			LIST_PUSH(iResourceLevelPool, &pCL[count], iNextInList);

		iResourceLevelPoolCount= (TUint16)(iResourceLevelPoolCount + (iStaticResDependencyCount / 2));

#ifdef PRM_INSTRUMENTATION_MACRO

		TUint size = allocCount * sizeof(SPowerResourceClientLevel);

		PRM_MEMORY_USAGE_TRACE

#endif

		}

	return KErrNone;

	}

/**

@internalComponent

@prototype 9.5

Return a client level object from pool.

@param aLevelPtr Pointer to update the client level object.

@return None 

*/

void DPowerResourceController::RemoveClientLevelFromPool(SPowerResourceClientLevel *&aLevelPtr)

	{

	LIST_POP(iResourceLevelPool, aLevelPtr, iNextInList);

	return;

	}

/**

Update with number of dependent resources for the specified resource. 

*/

TInt DPowerResourceController::GetNumDependentsForResource(TUint aResourceId, TUint* aNumResources)

	{

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

	if(!(aResourceId & KIdMaskResourceWithDependencies))

		return KErrNotSupported;

	SNode* pN;

	if(aResourceId & KIdMaskDynamic)

		{

		DDynamicPowerResourceD* pDR = iDynamicResDependencyList[(TUint16)(aResourceId & ID_INDEX_BIT_MASK)];		

		if(!pDR)														

			return KErrNotFound;

		pN = pDR->iDependencyList;

		}

	else

		{

		if((aResourceId & ID_INDEX_BIT_MASK) > iStaticResDependencyCount)

			return KErrNotFound;

		DStaticPowerResourceD* pDR = iStaticResDependencyArray[(TUint16)(aResourceId & ID_INDEX_BIT_MASK) - 1];

		pN = pDR->iDependencyList;

		}

	*aNumResources = 0;

	for(;pN != NULL; pN = pN->iNext)

		(*aNumResources)++;

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

	return KErrNone;

	}

/**

Update the specified array with dependent resource Id's of the specified resource. 

*/

TInt DPowerResourceController::GetDependentsIdForResource(TUint aResourceId, TAny* aInfo, TUint* aNumDepResources)

	{

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

	if(!(aResourceId & KIdMaskResourceWithDependencies))

		return KErrNotSupported;

	if(!aInfo || !*aNumDepResources)

		{

		return KErrArgument;

		}

	TDes8 *pInfo = (TDes8*)aInfo;

	if((TUint)(pInfo->MaxLength() - pInfo->Length()) < (sizeof(SResourceDependencyInfo)*(*aNumDepResources)))

		return KErrArgument;

	SResourceDependencyInfo sResDepInfo;

	SNode* pN;

	if(aResourceId & KIdMaskDynamic)

		{

		DDynamicPowerResourceD* pDR = iDynamicResDependencyList[(TUint16)(aResourceId & ID_INDEX_BIT_MASK)];

		if(!pDR)

			return KErrNotFound;

		pN = pDR->iDependencyList;

		}

	else

		{

		if((aResourceId & ID_INDEX_BIT_MASK) > iStaticResDependencyCount)

			return KErrNotFound;

		DStaticPowerResourceD* pDR = iStaticResDependencyArray[(TUint16)(aResourceId & ID_INDEX_BIT_MASK) -1];

		pN = pDR->iDependencyList;

		}

	TUint count = 0;

	TUint resCount = 0;

	for(; pN != NULL; pN = pN->iNext)

		{

		resCount++;

		if(count == *aNumDepResources)

			continue;

		sResDepInfo.iResourceId = pN->iResource->iResourceId;

		sResDepInfo.iDependencyPriority = pN->iPriority;

		pInfo->Append(TPckgC<SResourceDependencyInfo>(sResDepInfo));

		}

	*aNumDepResources = resCount;

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

	return KErrNone;

	}

/**

Registers resource dependency. This could be between 2 dynamic resource or between

dynamic and static resource.

*/

TInt DPowerResourceController::RegisterResourceDependency(SPowerResourceClient* aClientPtr, SResourceDependencyInfo* aInfo1, 

														              SResourceDependencyInfo* aInfo2)

	{

	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DExtendedResourceController::RegisterResourceDependency"));

	__KTRACE_OPT(KRESMANAGER, Kern::Printf("ClientId = 0x%x, ResourceId1 = 0x%x, ResourceId2 = 0x%x", 

		                             aClientPtr->iClientId, aInfo1->iResourceId, aInfo2->iResourceId));

	if(iDfcQDependencyLock)

		{

		__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::RegisterResourceDependency::Resource In Use"));

		return KErrInUse;

		}

	TInt r = KErrNone;

	//One of the resource must be dynamic resource

	if(!(aInfo1->iResourceId & KIdMaskDynamic) && !(aInfo2->iResourceId & KIdMaskDynamic))

		return KErrNotSupported;

	//Both the resources should have dependency resource bit set in its id. 

	if(!(aInfo1->iResourceId & KIdMaskResourceWithDependencies) || !(aInfo2->iResourceId & KIdMaskResourceWithDependencies))

		return KErrNotSupported;

	DDynamicPowerResourceD* pR1 = NULL;

	DDynamicPowerResourceD* pR2 = NULL;

	SNode* pN1 = NULL;

	SNode* pN2 = NULL;

	//Retrieve resource1 from the corresponding list.

	if(aInfo1->iResourceId & KIdMaskDynamic)

		{

		pR1 = iDynamicResDependencyList[(TUint16)(aInfo1->iResourceId & ID_INDEX_BIT_MASK)];

		if(!pR1)

			return KErrNotFound;

		pN1 = pR1->iDependencyList;

		}

	else 

		{

		if((aInfo1->iResourceId & ID_INDEX_BIT_MASK) > iStaticResDependencyCount)

			return KErrNotFound;

		pR1 = (DDynamicPowerResourceD*)iStaticResDependencyArray[(TUint16)(aInfo1->iResourceId & ID_INDEX_BIT_MASK) - 1];

		pN1 = ((DStaticPowerResourceD*)pR1)->iDependencyList;

		}

	//Retrieve resource2 from the corresponding list.

	if(aInfo2->iResourceId & KIdMaskDynamic)

		{

		pR2 = iDynamicResDependencyList[(TUint16)(aInfo2->iResourceId & ID_INDEX_BIT_MASK)];

		if(!pR2)

			return KErrNotFound;

		pN2 = pR2->iDependencyList;

		}

	else

		{

		if((aInfo2->iResourceId & ID_INDEX_BIT_MASK) > iStaticResDependencyCount)

			return KErrNotFound;

		pR2 = (DDynamicPowerResourceD*)iStaticResDependencyArray[(TUint16)(aInfo2->iResourceId & ID_INDEX_BIT_MASK) - 1];

		pN2 = ((DStaticPowerResourceD*)pR2)->iDependencyList;

		}

	//Only long latency resource is allowed to have dependents.

	if(!pR1->LatencySet())

		pR1->iFlags |= KLongLatencySet;

	if(!pR2->LatencySet())

		pR2->iFlags |= KLongLatencySet;

	//Check for closed loop

	//NOTE: Panics, if any closed loop is encountered

	if(pN1)

		CheckForDependencyLoop((DStaticPowerResourceD*)pR1, pR1->iResourceId, pR2->iResourceId);

	if(pN2)

		CheckForDependencyLoop((DStaticPowerResourceD*)pR2, pR2->iResourceId, pR1->iResourceId);

	//Check whether the passed priority already exists.Code will return with KErrAlreadyExists, if it exists.

	CHECK_IF_PRIORITY_ALREADY_EXISTS(pN1, aInfo2->iDependencyPriority)

	CHECK_IF_PRIORITY_ALREADY_EXISTS(pN2, aInfo1->iDependencyPriority)

	UnLock();

	//Allocate nodes

	// coverity[alloc_fn]

	SNode* pSN1 = new (SNode);

	// coverity[alloc_fn]

	SNode* pSN2 = new (SNode);

	Lock();

	if(!pSN1 || !pSN2)

		return KErrNoMemory;

	//Add the link

	pSN1->iResource = (DStaticPowerResourceD*)pR1;

	pSN1->iPropagatedLevel = 0;

	pSN1->iPriority = aInfo1->iDependencyPriority;

	pSN1->iVisited = EFalse;

	pSN1->iNext = NULL;

	pSN2->iResource = (DStaticPowerResourceD*)pR2;

	pSN2->iPropagatedLevel = 0;

	pSN2->iPriority = aInfo2->iDependencyPriority;

	pSN2->iVisited = EFalse;

	pSN2->iNext = NULL;

	if(aInfo1->iResourceId & KIdMaskDynamic) //Dynamic resource

		// coverity[memory_leak]

		ADD_DEPENDENCY_NODE(pSN2, ((DDynamicPowerResourceD*)pR1)->iDependencyList)

	else

		((DStaticPowerResourceD*)pR1)->AddNode(pSN2);

	//Add the second node

	if(aInfo2->iResourceId & KIdMaskDynamic) //Dynamic resource

		// coverity[memory_leak]

		ADD_DEPENDENCY_NODE(pSN1, ((DDynamicPowerResourceD*)pR2)->iDependencyList)

	else

		((DStaticPowerResourceD*)pR2)->AddNode(pSN1);

	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DExtendedResourceController::RegisterResourceDependency"));

#ifdef PRM_INSTRUMENTATION_MACRO

	PRM_REGISTER_RESOURCE_DEPENDENCY_TRACE

#endif

	return r;

	}

/**

Registers dynamic resource. 

*/

TInt DPowerResourceController::RegisterDynamicResource(SPowerResourceClient* aClientPtr, DDynamicPowerResource* aPDRes, 

													                 TUint* aDynamicResourceId)

	{

	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DExtendedResourceController::RegisterDynamicResource"));

	TInt r = KErrNone;

	//Check for dynamic resource

	if(!(aPDRes->iResourceId & KIdMaskDynamic))

		return KErrNotSupported;

	//check for count

	else if(aPDRes->LockCount() != 0) 

		return KErrAlreadyExists;

	TPowerRequest* req = (TPowerRequest*)&TPowerRequest::Get();

	req->ReqType() = TPowerRequest::ERegisterDynamicResource;

	req->Resource() = (DStaticPowerResource*)aPDRes;

	UnLock();

	req->SendReceive(iMsgQ);

	Lock();

	if(req->ReturnCode() == KErrNone)

		{

		*aDynamicResourceId = req->ResourceId();

		aPDRes-> iOwnerId = aClientPtr->iClientId;

		aPDRes->Lock();

		//Increment dynamic resource count in client

		aClientPtr->iDynamicResCount++;

		}

	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DExtendedResourceController::RegisterDynamicResource, resource ID = 0x%x", 

		                                                                                  *aDynamicResourceId));

#ifdef PRM_INSTRUMENTATION_MACRO

	PRM_REGISTER_DYNAMIC_RESOURCE_TRACE

#endif

	return r;

	}

/**

Deregisters dynamic resource.

*/

TInt DPowerResourceController::DeregisterDynamicResource(SPowerResourceClient* aClientPtr, TUint aResourceId, 

														 TInt* aPDefLevel)

	{

	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DExtendedResourceController::DeregisterDynamicResource"));

	__KTRACE_OPT(KRESMANAGER, Kern::Printf("aClientId = 0x%x, aDynamicResourceId = 0x%x, Default Level = %d", 

		                               aClientPtr->iClientId, aResourceId, aPDefLevel ? *aPDefLevel : 0));

	TInt r = KErrNone;

	DDynamicPowerResource* pDR = NULL;

	//Check for dynamic resource bit

	if(!(aResourceId & KIdMaskDynamic))

		return KErrNotSupported;

	//Get the resource from appropriate container

	if(aResourceId & KIdMaskResourceWithDependencies)

		{

		pDR = iDynamicResDependencyList[(TUint16)(aResourceId & ID_INDEX_BIT_MASK)];		

		if(!pDR)														

			return KErrNotFound;

		}

	else

		{

		pDR = iDynamicResourceList[(TUint16)(aResourceId & ID_INDEX_BIT_MASK)];		

		if(!pDR)														

			return KErrNotFound;

		}

	//Client which registered the dynamic resource is only allowed to deregister. 

	if(aClientPtr->iClientId != pDR->iOwnerId)

		{

		__KTRACE_OPT(KRESMANAGER, Kern::Printf("Client attempting to deregister a dynamic resource which is not the owner!"));

		return KErrAccessDenied;

		}

	// Don't allow to deregister if the some other operation is in progress or if the resource is shared and

	// another client holds requirement on this resource

	if((pDR->LockCount() > RESOURCE_NOT_IN_OPERATION) || pDR->InUse())

		{

		return KErrInUse;

		}

	TPowerRequest* req = (TPowerRequest*)&TPowerRequest::Get();

	req->ResourceCb() = NULL;

	req->ReturnCode() = KErrNone;

	req->RequiresChange() = EFalse;

	pDR->UnLock(); //Marked as deleted so that no other operation will be taking place.

	req->ReqType() = TPowerRequest::ESetDefaultLevel;

	//Handle dynamic resource with dependencies

	if(aResourceId & KIdMaskResourceWithDependencies)

		{

		for(SNode* pNode = ((DDynamicPowerResourceD*)pDR)->iDependencyList; pNode != NULL; pNode = pNode->iNext)

			{

			if((TUint)pNode->iResource->iLevelOwnerId == aResourceId)

				{

				req->ResourceId() = pNode->iResource->iResourceId;

				req->ClientId() = aResourceId;

				req->Level() = pNode->iResource->iCachedLevel;

				req->Resource() = pNode->iResource; 

				((DDynamicPowerResourceD*)(pNode->iResource))->Lock();

				UnLock();

				req->SendReceive(iMsgQDependency);

				Lock();

				}

			//Remove entry from resource dependency list

			for(SNode* pSN = pNode->iResource->iDependencyList; pSN != NULL; pSN = pSN->iNext)

				{

				if(pSN->iResource->iResourceId == aResourceId)

					{

					LIST_REMOVE(pNode->iResource->iDependencyList, pSN, iNext, SNode);

					UnLock();

					delete pSN;

					Lock();

					break;

					}

				}

			//Remove from dependent resource "resource client level" list

			for(SPowerResourceClientLevel* pL = ((DDynamicPowerResourceD*)(pNode->iResource))->iResourceClientList; 

			                                                                pL != NULL; pL = pL->iNextInList)

				{

				if(pL->iClientId == aResourceId)

					{

					LIST_REMOVE(((DDynamicPowerResourceD*)(pNode->iResource))->iResourceClientList, pL, iNextInList, 

						                                                                SPowerResourceClientLevel);

					//Move to free pool

					LIST_PUSH(iResourceLevelPool, pL, iNextInList);

					iResourceLevelPoolCount++;

					}

				}

			((DDynamicPowerResource*)(pNode->iResource))->UnLock();

			}

		//Move the resource to default level

		req->ClientId() = -1;

		req->ResourceId() = aResourceId;

		req->Resource() = pDR;

		if(aPDefLevel)

			req->Level() = *aPDefLevel; //Set the resource to the passed level

		else

			req->Level() = pDR->iDefaultLevel; //Set the resource level to default level

		UnLock();

		req->SendReceive(iMsgQDependency);

		}

	else

		{

		UnLock();

		req->ResourceId() = aResourceId;

		req->ClientId() = KDynamicResourceDeRegistering;

		req->Resource() = pDR;

		req->ResourceCb() = NULL;

		if(aPDefLevel)

			req->Level() = *aPDefLevel; //Set the resource to the passed level

		else

			req->Level() = pDR->iDefaultLevel; //Set the resource level to default level

		if(pDR->LatencySet())

			{

			r = req->SendReceive(iMsgQ);

			}

		else

			{

			//Call custom function for custom sense resource

			if(pDR->Sense() == DStaticPowerResource::ECustom)

				{

				if(!pDR->iCustomFunction)

					Panic(ECustomFunctionNotSet);

				pDR->iCustomFunction(req->ClientId(), *(aClientPtr->iName), aResourceId,

				                     EDynamicResourceDeregister, req->Level(),

				                     (TAny*)&pDR->iClientList, NULL);

				}

			//Not checking for error condition as the resource needs to be moved to default state

			if(aPDefLevel)

				{

				//If the resource change to requested level fails trying to change it to default level.

				req->ReqType() = TPowerRequest::EChange;

				r = pDR->DoRequest(*req);

				if(r != KErrNone)

					{

					req->ReqType() = TPowerRequest::ESetDefaultLevel;

					req->Level() = pDR->iDefaultLevel;

					pDR->DoRequest(*req);

					}

				}

			else

				pDR->DoRequest(*req);

			//Send notifications. Passing -2 in clientId to indicate that this dynamic resource is deregistering

			CompleteNotifications(KDynamicResourceDeRegistering, pDR, req->Level(),KErrNone, req->ClientId());

			}

		}

	Lock();

	//Remove client level

	SPowerResourceClientLevel *pCL;

	SPowerResourceClient *pC;

	for(SDblQueLink* pRC = pDR->iClientList.First(); pRC != &pDR->iClientList.iA; pRC = pRC->iNext)

		{

		pCL = (SPowerResourceClientLevel*)pRC;

		if(pCL->iClientId & USER_SIDE_CLIENT_BIT_MASK)

			pC = iUserSideClientList[(TUint16)(pCL->iClientId & ID_INDEX_BIT_MASK)];								

		else																										

			pC = iClientList[(TUint16)(pCL->iClientId & ID_INDEX_BIT_MASK)];										

		LIST_REMOVE(pC->iLevelList, pCL, iNextInList, SPowerResourceClientLevel);

		LIST_PUSH(iClientLevelPool, pCL, iNextInList);

		if(pC->iUnderFlowClCount > 0)

			{

			pC->iUnderFlowClCount--;

			iClientLevelPoolCount++;

			}

		else

			pC->iReservedCl++;

		}

	//Decrement dynamic resource count in client

	aClientPtr->iDynamicResCount--;

	if(aResourceId & KIdMaskResourceWithDependencies)

		{

		iDynamicResDependencyList.Remove((DDynamicPowerResourceD*)pDR, (TUint16)(pDR->iResourceId & ID_INDEX_BIT_MASK));

		iDynamicResDependencyCount--;

		}

	else

		{

		iDynamicResourceList.Remove(pDR, (TUint16)(pDR->iResourceId & ID_INDEX_BIT_MASK));

		iDynamicResourceCount--;

		}

	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DExtendedResourceController::DeregisterDynamicResource"));

#ifdef PRM_INSTRUMENTATION_MACRO

	TInt level = req->Level();

	PRM_DEREGISTER_DYNAMIC_RESOURCE_TRACE

#endif

	return r;

	}

/**

@publishedPartner

@prototype 9.6

Default implementation, PSL re-implements this if features supported.

*/

TInt DPowerResourceController::DoRegisterStaticResourcesDependency(DStaticPowerResourceD**& aStaticResourceDArray, 

																    TUint16& aStaticResourceDCount)

	{

	__KTRACE_OPT(KRESMANAGER, Kern::Printf("DExtendedResourceController::DoRegisterStaticResourcesDependency default implementation"));

	aStaticResourceDArray = NULL;

	aStaticResourceDCount = 0;

	return KErrNone;

	}

/**

This function checks for any closed loop dependency, if so panics.

*/

void DPowerResourceController::CheckForDependencyLoop(DStaticPowerResourceD* pR, TUint aParentResId, TUint aTargetResId)

	{

	SNode *pN;

	if(pR->iResourceId & KIdMaskDynamic)

		pN = ((DDynamicPowerResourceD*)pR)->iDependencyList;

	else

		pN = pR->iDependencyList;

	for(; pN != NULL; pN = pN->iNext)

		{

		if(pN->iResource->iResourceId == aParentResId)

			continue;

		if(pN->iVisited || (pN->iResource->iResourceId == aTargetResId))

			{

			__KTRACE_OPT(KRESMANAGER, Kern::Printf("Loop encountered\n"));

			DPowerResourceController::Panic(DPowerResourceController::EClosedLoopDependencies);