MCL/sf/os/kernelhwsrv: comparison kernel/eka/drivers/resourceman/resourcecontrol.cpp

equal deleted inserted replaced

-:a179b74831c9
+:c1f20ce4abcf
-// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+// 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".
 //
 // Contributors:
 //
 // Description:
 // e32\drivers\resourceman\resourcecontrol.cpp
 //
 //
 #include <drivers/resourcecontrol.h>
 #include <drivers/resourcecontrol_trace.h>
 #ifdef DEBUG_VERSION
 {
 __KTRACE_OPT(KRESMANAGER, Kern::Printf(">TInterface::ControlIO"));
 return PowerResourceController->GetInterface(aClientId, aFunction, aParam1, aParam2, aParam3);
 }
-/** Resouce controller panic */
+/** Resource 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. */
+extern RPointerArray <DStaticPowerResource> *StaticResourceArrayPtr;
+#ifdef PRM_ENABLE_EXTENDED_VERSION
+extern RPointerArray <DStaticPowerResourceD> *StaticResourceDependencyArrayPtr;
+#endif
 DPowerResourceController::DPowerResourceController()
 	{
-__KTRACE_OPT(KRESMANAGER, Kern::Printf("DPowerResourceController::DPowerResouceController()"));
+	__KTRACE_OPT(KRESMANAGER, Kern::Printf("DPowerResourceController::DPowerResouceController()"));
-	//Constructor is expected to invoke multiple times (during creation, variant init 0 and extension init 1)
+	// Constructor is expected to invoke multiple times, i.e.:
-	if(PowerResourceController)
+	// during creation: variant init 0(KModuleEntryReasonVariantInit0) and later extension init 1 (KModuleEntryReasonExtensionInit1)
+	if(PowerResourceController)
+		{
+		// If InitController() was called in the Init3() static resource arrays were populated already and invocation of this
+		// constructor has zeroed the dynamic pointer arrays (calling their default constructors). In such case we need to
+		// restore these arrays from their temporary shadow copies (i.e. copies of RPointerArray objects, not their content)
+		// (See comments in RegisterStaticResources())
+		if(StaticResourceArrayPtr)
+			{
+			// by making a (binary) copy of RPointerArray object (compiler's auto-generated code)
+			// we are taking the ownership of content (pointers stored/owned by that array) of this temporary array
+			iStaticResourceArray = *StaticResourceArrayPtr;
+			}
+#ifdef PRM_ENABLE_EXTENDED_VERSION
+		// the same applies to static resources with dependencies for extended version.
+		// Temporary object are de-allocated in InitResources()
+		if(StaticResourceDependencyArrayPtr)
+			{
+			iStaticResDependencyArray = *StaticResourceDependencyArrayPtr;
+			}
+#endif
 		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()"));
-#ifdef RESOURCE_MANAGER_SIMULATED_PSL
-	iCleanList.ResetAndDestroy();
-#endif
-	iClientList.Delete();
-	iUserSideClientList.Delete();
-#ifdef PRM_ENABLE_EXTENDED_VERSION
-	iDynamicResourceList.Delete();
-	iDynamicResDependencyList.Delete();
-#endif
-	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)
 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.iMutex = iResourceMutex;
+			pN->iCallback.iPendingRequestCount++;
 			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",
 #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.iResult=aReturnCode;
-pN->iCallback.iLevel=aState;
+			pN->iCallback.iMutex = iResourceMutex;
-pN->iCallback.iClientId = aClientId;
+pN->iCallback.iPendingRequestCount++;
+			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->iCallback.Enque();
 			}
 		pN->iPreviousLevel = aState; //Update the state
 		}
 	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::CompleteNotifications"));
 	if(aLock)
 		{
 		TInt aNewState = aReq->Level();
 		PRM_CLIENT_CHANGE_STATE_END_TRACE
 		}
 #endif
-	//Check whether callback is cancelled and if not queue the DFC.
+	//Check whether callback is canceled and if not queue the DFC.
 TPowerResourceCb* pCb = aReq->ResourceCb();
 if(pCb)
 		{
+pCb->iMutex = pRC->iResourceMutex;
+pCb->iPendingRequestCount++;
 pCb->iResult=aReq->ReturnCode();
 pCb->iLevel=aReq->Level();
 pCb->iResourceId=aReq->ResourceId();
 pCb->iClientId=aReq->ClientId();
 		pCb->iLevelOwnerId = pR->iLevelOwnerId;
 		{
 		pC = &tRes;
 		pC->iClientId = aReq->ClientId();
 		DDynamicPowerResourceD* pDRes;
 		if(aReq->ClientId() & KIdMaskDynamic)
-			pDRes = pRC->iDynamicResDependencyList[(TUint16)(aReq->ClientId() & ID_INDEX_BIT_MASK)];
+			pDRes = pRC->iDynamicResDependencyList[(aReq->ClientId() & ID_INDEX_BIT_MASK)];
 		else
 			pDRes = (DDynamicPowerResourceD*)pRC->iStaticResDependencyArray[(aReq->ClientId() & ID_INDEX_BIT_MASK) - 1];
-		pC->iName = pDRes->iName;
+		if (pDRes != NULL)
+		    {
+pC->iName = pDRes->iName;
+		    }
+		else
+		    {
+pC->iName = &KNullDesC;
+		    }
 		}
 	else if((aReq->ClientId() == -1) || (aReq->ClientId() == KDynamicResourceDeRegistering))
 		{
 pC = &tRes;
 pC->iClientId = (TUint)-1;
 		{
 		TInt aNewState = aReq->Level();
 		PRM_CLIENT_CHANGE_STATE_END_TRACE
 		}
 #endif
-	//Check whether callback is cancelled and if not queue the DFC.
+	//Check whether callback is canceled and if not queue the DFC.
 TPowerResourceCb* pCb = aReq->ResourceCb();
 if(pCb)
 		{
+pCb->iMutex = pRC->iResourceMutex;
+pCb->iPendingRequestCount++;
 pCb->iResult=aReq->ReturnCode();
 pCb->iLevel=aReq->Level();
 pCb->iResourceId=aReq->ResourceId();
 pCb->iClientId=aReq->ClientId();
 		pCb->iLevelOwnerId = pR->iLevelOwnerId;
 Finally mark resource controller as fully initialised (ready to accept state change and get request)
 and start the message queue if exists. */
 TInt DPowerResourceController::InitResources()
 	{
 __KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::InitResources()"));
-	TUint16 count;
+	TInt count;
 	//Create a Kernel client object for Power Controller
 	Lock();
 	SPowerResourceClient * pC = NULL;
 	// By now client pool should be created
 	LIST_POP(iClientPool, pC, iNextInList);
-	TUint16 growBy = iClientList.GrowBy();
+	TInt growBy = iClientList.GrowBy();
 	if(!pC)
 		{
 		UnLock();
 		// coverity[alloc_fn]
 		SPowerResourceClient *pCL = new SPowerResourceClient[growBy];
 	iClientList.Add(pC, iPowerControllerId);
 	pC->iClientId = iPowerControllerId | CLIENT_POWER_CONTROLLER_BIT_MASK;
 	iPowerControllerId = pC->iClientId;
 iClientCount++;
 if(TPowerController::PowerController())
-TPowerController::PowerController()->RegisterResourceController(this, iPowerControllerId);
+		{
+		if(TPowerController::PowerController()->RegisterResourceController(this, iPowerControllerId))
+			{
+#ifndef RESOURCE_MANAGER_SIMULATED_PSL
+			Panic(EControllerAlreadyExists);	//	Panic with this error for any error returned by RegisterResourceController
+#endif
+			}
+		}
 	iInitialised =EResConStartupCompleted;
 	UnLock();
 	//Check the resource for postboot level and send notifications to clients registered for it.
 	DStaticPowerResource *pR = NULL;
 	TInt r;
 	TPowerRequest req = TPowerRequest::Get();
 	//For Static resource with no dependencies
-for(count = 0; count< iStaticResourceArrayEntries; count++)
+for(count = 0; count < iStaticResourceArray.Count(); count++)
 		{
 		pR = iStaticResourceArray[count];
 		if(pR && (pR->iFlags & SET_VALID_POST_BOOT_LEVEL))
 			{
 //Form the request message
 				}
 			}
 		}
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 	//For Static resource with dependencies
-	for(count = 0; count < iStaticResDependencyCount; count++)
+	for(count = 0; count < iStaticResDependencyArray.Count(); count++)
 		{
 		pR = iStaticResDependencyArray[count];
 		if(pR->iFlags & SET_VALID_POST_BOOT_LEVEL)
 			{
 			req.ReqType() = TPowerRequest::EChange;
 			req.ResourceCb() = NULL;
 			req.RequiresChange() = ETrue;
 			//Form the request message
 			((DStaticPowerResourceD*)pR)->HandleChangePropagation(req, EChangeStart, req.ClientId(), KNoClient);
 			}
+		}
+#endif
+	// delete the temporary copy of static resource array used during initialization.
+	if(StaticResourceArrayPtr)
+		{
+		delete StaticResourceArrayPtr;
+		StaticResourceArrayPtr = NULL;
+		}
+#ifdef PRM_ENABLE_EXTENDED_VERSION
+	// the same applies to dependency resources array for extended version.
+	if(StaticResourceDependencyArrayPtr)
+		{
+		delete StaticResourceDependencyArrayPtr;
+		StaticResourceDependencyArrayPtr = NULL;
 		}
 #endif
 	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::InitResources()"));
 return KErrNone;
 	}
 iClientList.Delete();
 		return KErrNoMemory;
 		}
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 	SPowerResourceClientLevel* pRL = NULL;
-	if(iStaticResDependencyCount)
+	if(iStaticResDependencyArray.Count())
 		{
-		pRL = new SPowerResourceClientLevel[iStaticResDependencyCount];
+		pRL = new SPowerResourceClientLevel[iStaticResDependencyArray.Count()];
 		if(!pRL)
 			{
 			__KTRACE_OPT(KRESMANAGER, Kern::Printf("Resource level Pool Allocation Failed"));
 			delete []pC;
 			delete []pCL;
 		}
 #ifdef RESOURCE_MANAGER_SIMULATED_PSL
 	iCleanList.Append(pC);
 #endif
 	Lock();
-	TUint16 c;
+	TInt c;
-	for(c = 0; c < iStaticResDependencyCount; c++)
+	for(c = 0; c < iStaticResDependencyArray.Count(); c++)
 		{
 		LIST_PUSH(iResourceLevelPool, &pRL[c], iNextInList);
 		}
-	iResourceLevelPoolCount = iStaticResDependencyCount;
+	iResourceLevelPoolCount = (TUint16)iStaticResDependencyArray.Count();
 #else
 #ifdef RESOURCE_MANAGER_SIMULATED_PSL
 iCleanList.Append(pC);
 #endif
 Lock();
 TUint16 c;
 #endif
 // Create Client pool list
-for(c = 0; c< (aKClients + aUClients); c++)
+for(c = 0; c < TUint16(aKClients + aUClients); c++)
 		{
 LIST_PUSH(iClientPool, &pC[c], iNextInList);
 		}
 // Create client level pool list
 for(c = 0; c < aNClientLevels; c++)
 	req->ReqType() = TPowerRequest::ERegisterKernelClient;
 	UnLock();
 	req->SendReceive(iMsgQ);
 	if(req->ReturnCode() == KErrNone)
 		{
-		pC = iClientList[(TUint16)(req->ClientId() & ID_INDEX_BIT_MASK)];
+		pC = iClientList[(req->ClientId() & ID_INDEX_BIT_MASK)];
 		if(aType == EOwnerThread)
 			{
 			pC->iClientId |= CLIENT_THREAD_RELATIVE_BIT_MASK; //Set 31st bit;
 			//Store the current thread Id;
 			pC->iThreadId = thread.iId;
 			}
 		pC->iName = &aName;
 		aClientId = pC->iClientId;
-		}
+	    PRM_CLIENT_REGISTER_TRACE
-PRM_CLIENT_REGISTER_TRACE
+	    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::RegisterClient, clientId = 0x%x", aClientId));
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::RegisterClient, clientId = 0x%x", aClientId));
+		}
 	return(req->ReturnCode());
 	}
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 TInt DPowerResourceController::HandleResourceRegistration(TPowerRequest& aReq)
 	if(aRequest.ReqType() == TPowerRequest::ERegisterKernelClient)
 		{
 		//Get Next client from FreePool
 		LIST_POP(iClientPool, pC, iNextInList);
-		TUint16 growBy = iClientList.GrowBy();
+		TInt growBy = iClientList.GrowBy();
 		if(!pC)
 			{
 			//Free Pool is empty, so try to grow the pool.
 			__KTRACE_OPT(KRESMANAGER, Kern::Printf("Client pool exhausted so growing client Pool by %d", growBy));
 			// coverity[alloc_fn]
 		}
 	else // Request is registration of user side client
 		{
 		//Get Next client from FreePool
 		LIST_POP(iClientPool, pC, iNextInList);
-		TUint16 growBy = iUserSideClientList.GrowBy();
+		TInt growBy = iUserSideClientList.GrowBy();
 		if(!pC)
 			{
 			//Free Pool is empty, so try to grow the pool.
 			SPowerResourceClient *pCL = (SPowerResourceClient*)Kern::Alloc(sizeof(SPowerResourceClient) * growBy);
 			if(!pCL)
 				}
 #ifdef RESOURCE_MANAGER_SIMULATED_PSL
 			iCleanList.Append(pCL);
 #endif
 			Lock();
-			TUint16 count;
+			TInt count;
 			for(count = 0; count < growBy - 1; count++)
 				LIST_PUSH(iClientPool, &pCL[count], iNextInList);
 			UnLock();
 #ifdef PRM_INSTRUMENTATION_MACRO
 		TUint size = growBy * sizeof(SPowerResourceClient);
 SPowerResourceClientLevel* pCLL = NULL;
 	while(pCL != NULL)
 		{
 __KTRACE_OPT(KRESMANAGER, Kern::Printf("Client 0x%x has requirement on resource %d", pCL->iClientId, pCL->iResourceId));
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 		switch((pCL->iResourceId >>RESOURCE_BIT_IN_ID_CHECK) & 0x3)
-		{
+			{
-		case PRM_STATIC_RESOURCE:
+			case PRM_STATIC_RESOURCE:
 			pR = iStaticResourceArray[pCL->iResourceId - 1];
-			break;
+				break;
-		case PRM_DYNAMIC_RESOURCE:
+			case PRM_DYNAMIC_RESOURCE:
-			pR = (iDynamicResourceList[(TUint16)(pCL->iResourceId & ID_INDEX_BIT_MASK)]);
+			pR = (iDynamicResourceList[(pCL->iResourceId & ID_INDEX_BIT_MASK)]);
-			break;
+				break;
-		case PRM_STATIC_DEPENDENCY_RESOURCE:
+			case PRM_STATIC_DEPENDENCY_RESOURCE:
-			pR = (iStaticResDependencyArray[(TUint16)(pCL->iResourceId & ID_INDEX_BIT_MASK) - 1]);
+			pR = (iStaticResDependencyArray[(pCL->iResourceId & ID_INDEX_BIT_MASK) - 1]);
-			break;
+				break;
-		case PRM_DYNAMIC_DEPENDENCY_RESOURCE:
+			case PRM_DYNAMIC_DEPENDENCY_RESOURCE:
-			pR = (iDynamicResDependencyList[(TUint16)(pCL->iResourceId & ID_INDEX_BIT_MASK)]);
+			pR = (iDynamicResDependencyList[(pCL->iResourceId & ID_INDEX_BIT_MASK)]);
-			break;
+				break;
-		}
+			}
 #else
-		pR = iStaticResourceArray[pCL->iResourceId -1];
+		pR = iStaticResourceArray[pCL->iResourceId - 1];
 #endif
 #ifdef PRM_ENABLE_EXTENDED_VERSION
-		if(((pR->Sense() == DStaticPowerResource::ECustom) || ((TInt)pCL->iClientId == pR->iLevelOwnerId)) && (!(pCL->iResourceId & KIdMaskDynamic) ||
+		if(pR  &&  (((pR->Sense() == DStaticPowerResource::ECustom) || ((TInt)pCL->iClientId == pR->iLevelOwnerId)) && (!(pCL->iResourceId & KIdMaskDynamic) ||
-			         ((pCL->iResourceId & KIdMaskDynamic) && (((DDynamicPowerResource*)pR)->LockCount() != 0))))
+			         ((pCL->iResourceId & KIdMaskDynamic) && (((DDynamicPowerResource*)pR)->LockCount() != 0)))))
 #else
-		if((pR->Sense() == DStaticPowerResource::ECustom) || ((TInt)pCL->iClientId == pR->iLevelOwnerId))
+		if(pR  &&  ((pR->Sense() == DStaticPowerResource::ECustom) || ((TInt)pCL->iClientId == pR->iLevelOwnerId)))
 #endif
 		    {
 pReq->ReqType() = TPowerRequest::ESetDefaultLevel;
 pReq->ResourceId() = pCL->iResourceId;
 pReq->ClientId() = pCL->iClientId;
 	CHECK_CONTEXT(thread)
 	if((aClientId & USER_SIDE_CLIENT_BIT_MASK) || (aClientId == iPowerControllerId))
 		return KErrArgument;
 	//Get the index from client ID
 	Lock();
-	SPowerResourceClient* pC = iClientList[(TUint16)(aClientId & ID_INDEX_BIT_MASK)];
+	SPowerResourceClient* pC = iClientList[(aClientId & ID_INDEX_BIT_MASK)];
 if(!pC)
 	    {
 __KTRACE_OPT(KRESMANAGER, Kern::Printf("Client ID not Found"));
 UNLOCK_RETURN(KErrNotFound);
 		}
 	ResourceStateChangeOfClientLevels(pC);
 	// Add reserved request to pool
 	iRequestPoolCount = (TUint16)(iRequestPoolCount + (TUint16)pC->iReservedRm);
 	PRM_CLIENT_DEREGISTER_TRACE
 	//Increment the free pool count for client level and request level.
-	iClientList.Remove(pC, (TUint16)(pC->iClientId & ID_INDEX_BIT_MASK));
+	iClientList.Remove(pC, (pC->iClientId & ID_INDEX_BIT_MASK));
 	pC->iName = NULL;
 	iClientCount--; //Decrement client count
 	LIST_PUSH(iClientPool, pC, iNextInList);
 	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::DeRegisterClient"));
 	UNLOCK_RETURN(KErrNone);
 	SPowerResourceClient* pC;
 	if(aResourceName.Length() > KMaxResourceNameLength)
 		return KErrTooBig;
 	Lock();
 	VALIDATE_CLIENT(thread);
-	TUint count = 0;
+	TInt count = 0;
 	//Search in static resource with no dependencies array for specified resource name.
-	for(count = 0; count < iStaticResourceArrayEntries; count++)
+	for(count = 0; count < iStaticResourceArray.Count(); count++)
 		{
 		if((iStaticResourceArray[count]) && (!(aResourceName.Compare(*(const TDesC8*)iStaticResourceArray[count]->iName))))
 			{
 			aResourceId = ++count;
 			__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetResourceId, ResourceId = 0x%x", aResourceId));
 		aResourceId = pDR->iResourceId;
 		__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetResourceId, ResourceId = 0x%x", aResourceId));
 		UNLOCK_RETURN(KErrNone);
 		}
 	//Search in static resource with dependencies (if exists) for specified resource name
-	for(count = 0; count < iStaticResDependencyCount; count++)
+	for(count = 0; count < iStaticResDependencyArray.Count(); count++)
 		{
 		if(!(aResourceName.Compare(*(const TDesC8*)iStaticResDependencyArray[count]->iName)))
 			{
 			aResourceId = iStaticResDependencyArray[count]->iResourceId;
 			__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetResourceId, ResourceId = 0x%x", aResourceId));
 	//Validate buffer size
 	if((TUint)(buf->MaxLength() - buf->Length()) < sizeof(TPowerResourceInfoV01))
 	   UNLOCK_RETURN(KErrArgument);
 #ifndef PRM_ENABLE_EXTENDED_VERSION
-	if((!aResourceId) || (aResourceId > iStaticResourceArrayEntries))
+	if((!aResourceId) || (aResourceId > (TUint)iStaticResourceArray.Count()))
 		UNLOCK_RETURN(KErrNotFound);
 	//Get resource from static resource array. 0(1) operation.
 	pR = iStaticResourceArray[aResourceId-1];
 	if(!pR)
 		{
 	VALIDATE_CLIENT(thread);
 	//Special case, return number of resources registered resource controller.
 	if(!aTargetClientId)
 		{
 #ifdef PRM_ENABLE_EXTENDED_VERSION
-		aNumResource = iStaticResourceCount + iDynamicResourceCount + iStaticResDependencyCount +
+		aNumResource = iStaticResourceCount + iDynamicResourceCount + iStaticResDependencyArray.Count() +
 			                                                          iDynamicResDependencyCount;
 #else
 		aNumResource = iStaticResourceCount;
 #endif
 		__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetNumResourcesInUseByClient, numResources = %d", aNumResource));
 TDes8 *pInfo = (TDes8*)anInfo;
 if((TUint)(pInfo->MaxLength() - pInfo->Length()) < (sizeof(TPowerResourceInfoV01) * aNumResources))
 UNLOCK_RETURN(KErrArgument);
 TPowerResourceInfoBuf01 buf;
-	TUint16 count = 0;
+	TInt count = 0;
 	TInt r = KErrNone;
 	//Special case, if aTargetClientId is 0 fill with all the resource
 	if(!aTargetClientId)
 		{
-		TUint numResources = aNumResources;
+		TInt numResources = aNumResources;
 #ifndef PRM_ENABLE_EXTENDED_VERSION
 		aNumResources = iStaticResourceCount;
 #else
-		aNumResources = iStaticResourceCount + iDynamicResourceCount + iStaticResDependencyCount +
+		aNumResources = iStaticResourceCount + iDynamicResourceCount + iStaticResDependencyArray.Count() +
 			                                                           iDynamicResDependencyCount;
 #endif
 		UnLock();
-		while(count < iStaticResourceArrayEntries)
+		while(count < iStaticResourceArray.Count())
 			{
-			if(numResources <=0)
+			if(numResources == 0)
 				return KErrNone;
 			pR = iStaticResourceArray[count++];
 			if(!pR)
 				continue;
 r = pR->GetInfo((TDes8*)buf.Ptr());
 			pInfo->Append(buf);
 			numResources--;
 			}
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 		count = 0;
-		while(count < iStaticResDependencyCount)
+		while(count < iStaticResDependencyArray.Count())
 			{
 			if(count >= numResources)
 				return KErrNone;
 			pR = iStaticResDependencyArray[count++];
 			r = pR->GetInfo((TDes8*)buf.Ptr());
 			((TPowerResourceInfoV01*)buf.Ptr())->iResourceId = ((DStaticPowerResourceD*)pR)->iResourceId;
 			if(r != KErrNone)
 				return r;
 			pInfo->Append(buf);
 			}
-		numResources -= iStaticResDependencyCount;
+		numResources -= iStaticResDependencyArray.Count();
 		if((!numResources) || (!iDynamicResourceCount && !iDynamicResDependencyCount))
 			return r;
 		Lock();
-		TUint resCount = 0;
+		TInt resCount = 0;
 		for(count = 0; count < iDynamicResourceList.Allocd(); count++)
 			{
 			pR = iDynamicResourceList[count];
 			if(!pR)
 				continue;
 			pInfo->Append(buf);
 			resCount++;
 			}
 		numResources -= resCount;
 		resCount = 0;
-		for(count = 0; count < iDynamicResDependencyList.Allocd(); count++)
+		for(count = 0; count < (TInt)iDynamicResDependencyList.Allocd(); count++)
 			{
 			pR = iDynamicResDependencyList[count];
 			if(!pR)
 				continue;
 			if((resCount >= iDynamicResDependencyCount) || (resCount >= numResources))
 		}
 	GET_TARGET_CLIENT();
 	SPowerResourceClientLevel* pCL = pC->iLevelList;
 	for (count= 0; pCL; count++, pCL = pCL->iNextInList)
 		{
-		if(count >= aNumResources)
+		if(count >= (TInt)aNumResources)
 			continue;
 #ifndef PRM_ENABLE_EXTENDED_VERSION
 		pR = iStaticResourceArray[pCL->iResourceId-1];
 #else
 		GET_RESOURCE_FROM_LIST(pCL->iResourceId, pR);
 		}
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 	DStaticPowerResource* pR = NULL;
 	GET_RESOURCE_FROM_LIST(aResourceId, pR)
 #else
-	if(aResourceId > iStaticResourceArrayEntries)
+	if(aResourceId > (TUint)iStaticResourceArray.Count())
 		UNLOCK_RETURN(KErrNotFound);
 	DStaticPowerResource* pR = iStaticResourceArray[aResourceId-1];
 	if(!pR)
 		UNLOCK_RETURN(KErrNotFound);
 #endif
 		}
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 	DStaticPowerResource* pR = NULL;
 	GET_RESOURCE_FROM_LIST(aResourceId, pR)
 #else
-	if(aResourceId > iStaticResourceArrayEntries)
+	if(aResourceId > (TUint)iStaticResourceArray.Count())
 		UNLOCK_RETURN(KErrNotFound);
 	DStaticPowerResource* pR = iStaticResourceArray[aResourceId-1];
 	if(!pR)
 		UNLOCK_RETURN(KErrNotFound);
 #endif
 		{
 		if(c >= aNumClients)
 			continue;
 		pCL = (SPowerResourceClientLevel*)pRC;
 		if(pCL->iClientId & USER_SIDE_CLIENT_BIT_MASK)
-			pC = iUserSideClientList[(TUint16)(pCL->iClientId & ID_INDEX_BIT_MASK)];
+			pC = iUserSideClientList[(pCL->iClientId & ID_INDEX_BIT_MASK)];
 		else
-			pC = iClientList[(TUint16)(pCL->iClientId & ID_INDEX_BIT_MASK)];
+			pC = iClientList[(pCL->iClientId & ID_INDEX_BIT_MASK)];
 		info.iClientId = pC->iClientId;
 		info.iClientName =  (TDesC8*)pC->iName;
 pInfo->Append(TPckgC<TPowerClientInfoV01>(info));
 		}
 	aNumClients = c;
 Request changing the state of a resource
 NOTE: If a resource callback is specified for instantaneous resource, then callback
 will be called after resource change and will be executed in the context of the
 client thread.
-If a resource callback is specified for long latency reosurces, then it will be
+If a resource callback is specified for long latency resources, then it will be
 executed asynchronously.When the request is accepted the API returns immediately
 	  and the calling thread is unblocked: the callback (called in the client's context)
 	  will be invoked when the resource change finally takes place.
 If aCb is not specified (NULL by default) the API executes synchronously and will
 only return when the resource change has taken place for long latency resource.
 binary resource, an integer level for a multilevel resource or some
 platform specific token for a multi-property resource.
 @param aCb         For Long latency resource
 A pointer to a resource callback object which encapsulates a
 callback function to be called whenever the resource state change
-happens (if left NULL the API will execute synchrounously).
+happens (if left NULL the API will execute synchronously).
 For Instantaneous resource
 A pointer to a resource callback object which encapsulates a callback
 function to be called after resource change. This executes in the
 context of the client thread.
 	VALIDATE_CLIENT(thread);
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 	DStaticPowerResource *pR = NULL;
 	GET_RESOURCE_FROM_LIST(aResourceId, pR)
 #else
-	if(aResourceId > iStaticResourceArrayEntries)
+	if(aResourceId > (TUint)iStaticResourceArray.Count())
 		UNLOCK_RETURN(KErrNotFound);
 	DStaticPowerResource* pR = iStaticResourceArray[aResourceId-1];
 	if(!pR)
 		UNLOCK_RETURN(KErrNotFound);
 #endif
 	//Return if the resource is already in that state and client is also the same.
 	if((aNewState == pR->iCachedLevel) && ((TInt)aClientId == pR->iLevelOwnerId))
-		UNLOCK_RETURN(KErrNone);
+		{
+		if(aCb)
+			{
+			//Invoke callback function
+TUint ClientId = aClientId;
+TUint ResourceId = aResourceId;
+TInt Level = aNewState;
+TInt LevelOwnerId = pR->iLevelOwnerId;
+TInt Result = KErrNone;
+TAny* Param = aCb->iParam;
+aCb->iPendingRequestCount++;
+UnLock();
+// Call the client specified callback function
+aCb->iCallback(ClientId, ResourceId, Level, LevelOwnerId, Result, Param);
+Lock();
+aCb->iPendingRequestCount--;
+if(aCb->iPendingRequestCount == 0)
+{
+aCb->iResult = KErrCompletion;
+}
+			}
+UNLOCK_RETURN(KErrNone);
+		}
 	PRM_CLIENT_CHANGE_STATE_START_TRACE
 	//If long latency resource requested synchronously from DFC thread 0 Panic
 const TDesC8* pDfc0 = &KDfcThread0Name;
 	TPowerRequest* req;
 	SPowerRequest* pS=NULL;
 	if(pR->LatencySet() && aCb)
 		{
-		// Get request object from free pool, as it is long latency reosurce as client
+		// Get request object from free pool, as it is long latency resource as client
-		// will be unblocked once message is sent to controller, so cant use thread message.
+		// will be unblocked once message is sent to controller, so can't use thread message.
 		if(pC->iReservedRm ==0 && !iRequestPoolCount)
 			{
 r = KErrUnderflow;
 PRM_CLIENT_CHANGE_STATE_END_TRACE
 			UNLOCK_RETURN(r);
 				return KErrNone;
 				}
 			else
 #endif
 				{
-				req->Send(iMsgQ); // Send the request to Resource Controler thread.
+				req->Send(iMsgQ); // Send the request to Resource Controller thread.
 				return KErrNone;
 				}
 			}
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 		if(aResourceId & KIdMaskResourceWithDependencies) //Dependency resource
 			req->Level() = pR->iCachedLevel;
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 		    if(aResourceId & KIdMaskDynamic)
 				((DDynamicPowerResource*)pR)->UnLock();
 #endif
-			UnLock();
 			if(aCb)
 				{
-				//Invoke callback function
+//Invoke callback function
-				aCb->iCallback(req->ClientId(), aResourceId, req->Level(), pR->iLevelOwnerId, r, aCb->iParam);
+TUint ClientId = req->ClientId();
-				//Mark the callback object to act properly during cancellation of this request.
+TUint ResourceId = aResourceId;
-				aCb->iResult = KErrCompletion;
+TInt Level = req->Level();
-				}
+TInt LevelOwnerId = pR->iLevelOwnerId;
+TInt Result = r;
+TAny* Param = aCb->iParam;
+aCb->iPendingRequestCount++;
+UnLock();
+// Call the client specified callback function
+aCb->iCallback(ClientId, ResourceId, Level, LevelOwnerId, Result, Param);
+Lock();
+aCb->iPendingRequestCount--;
+if(aCb->iPendingRequestCount == 0)
+{
+aCb->iResult = KErrCompletion;
+}
+}
 			PRM_CLIENT_CHANGE_STATE_END_TRACE
-			return(r);
+			UNLOCK_RETURN(r);
 			}
 		}
 	else if(pR->iLevelOwnerId == -1)
 		{
 		/* Add client Level */
 		}
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 	if(aResourceId & KIdMaskDynamic)
 		((DDynamicPowerResource*)pR)->UnLock();
 #endif
-	UnLock();
 	if(aCb)
 		{
-		//Invoke callback function
+//Invoke callback function
-		aCb->iCallback(req->ClientId(), aResourceId, req->Level(), pR->iLevelOwnerId, r, aCb->iParam);
+TUint ClientId = req->ClientId();
-		aCb->iResult = KErrCompletion; //Mark the callback object to act properly during cancellation of this request.
+TUint ResourceId = aResourceId;
+TInt Level = req->Level();
+TInt LevelOwnerId = pR->iLevelOwnerId;
+TInt Result = r;
+TAny* Param = aCb->iParam;
+aCb->iPendingRequestCount++;
+UnLock();
+// Call the client specified callback function
+aCb->iCallback(ClientId, ResourceId, Level, LevelOwnerId, Result, Param);
+Lock();
+aCb->iPendingRequestCount--;
+if(aCb->iPendingRequestCount == 0)
+{
+aCb->iResult = KErrCompletion;
+}
 		}
 	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::ChangeResourceState, Level = %d", req->Level()));
 PRM_CLIENT_CHANGE_STATE_END_TRACE
-return r;
+UNLOCK_RETURN(r);
 	}
 /**
 @publishedPartner
 @prototype 9.5
 @param aCached     If ETrue, cached value will be updated in aState.
 If EFalse, aState will be updated after the resource
 state is read from resource.
 @param aState      Returns the resource state if operation was successful. This
 could be a binary value for a binary resource, an integer level
-for a multilevel resource or some platform specific tolen for a
+for a multilevel resource or some platform specific token for a
 multi-property resource.
 @param aLevelOwnerId Returns the Id of the client that is currently holding the resource.
 					 -1	is returned when no client is holding the resource.
 @return KErrNone   if operation was successful
 		{
 		if(((DDynamicPowerResource*)pR)->LockCount() == 0)
 			UNLOCK_RETURN(KErrNotFound);
 		}
 #else
-	if(aResourceId > iStaticResourceArrayEntries)
+	if(aResourceId > (TUint)iStaticResourceArray.Count())
 		UNLOCK_RETURN(KErrNotFound);
 	DStaticPowerResource *pR = iStaticResourceArray[aResourceId-1];
 	if(!pR)
 		UNLOCK_RETURN(KErrNotFound);
 #endif
 /**
 @publishedPartner
 @prototype 9.5
-Request the state of the resource asynchrounously for long latency resource and
+Request the state of the resource asynchronously for long latency resource and
 synchronously for instantaneous resource
 @param aClientId  ID of the client which is requesting the resource state.
 @param aResourceId ID of the resource whose state is being requested.
 @param aCached If ETrue, cached value will be updated in aState
 		//Dynamic resource in process of deregistration
 		if(((DDynamicPowerResource*)pR)->LockCount() == 0)
 			UNLOCK_RETURN(KErrNotFound);
 		}
 #else
-	if(aResourceId > iStaticResourceArrayEntries)
+	if(aResourceId > (TUint)iStaticResourceArray.Count())
 		UNLOCK_RETURN(KErrNotFound);
 	DStaticPowerResource *pR = iStaticResourceArray[aResourceId-1];
 	if(!pR)
 		UNLOCK_RETURN(KErrNotFound);
 #endif
 	aCb.iClientId = aClientId;
 	PRM_RESOURCE_GET_STATE_START_TRACE
 	if(aCached) //Call the callback directly
 		{
-		UnLock();
+//Invoke callback function
-		aCb.iCallback(aClientId, aResourceId, pR->iCachedLevel, pR->iLevelOwnerId, KErrNone, aCb.iParam);
+TUint ClientId = aClientId;
-		aCb.iResult = KErrCompletion; //Mark the callback object to act properly during cancellation of this request.
+TUint ResourceId = aResourceId;
+TInt Level = pR->iCachedLevel;
+TInt LevelOwnerId = pR->iLevelOwnerId;
+TInt Result = KErrNone;
+TAny* Param = aCb.iParam;
+aCb.iPendingRequestCount++;
+UnLock();
+// Call the client specified callback function
+aCb.iCallback(ClientId, ResourceId, Level, LevelOwnerId, Result, Param);
+Lock();
+aCb.iPendingRequestCount--;
+if(aCb.iPendingRequestCount == 0)
+{
+aCb.iResult = KErrCompletion; //Mark the callback object to act properly during cancellation of this request.
+}
 #ifdef PRM_INSTRUMENTATION_MACRO
 		TInt aState = pR->iCachedLevel;
 PRM_RESOURCE_GET_STATE_END_TRACE
 #endif
-		return(KErrNone);
+		UNLOCK_RETURN(KErrNone);
 		}
 	TPowerRequest* req=NULL;
 	if(pR->LatencyGet())
 		{
 		//Check the client quota of requests
 			}
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 		if(aResourceId & KIdMaskDynamic)
 			((DDynamicPowerResource*)pR)->UnLock();
 #endif
-		UnLock();
-		// Call the client callback function directly as it is already executing in the context of client thread.
+//Invoke callback function
-		aCb.iCallback(aClientId, aResourceId, req->Level(), pR->iLevelOwnerId, r, aCb.iParam);
+TUint ClientId = aClientId;
-		aCb.iResult = KErrCompletion; //Mark the callback object to act properly during cancellation of this request.
+TUint ResourceId = aResourceId;
+TInt Level = req->Level();
+TInt LevelOwnerId = pR->iLevelOwnerId;
+TInt Result = r;
+TAny* Param = aCb.iParam;
+aCb.iPendingRequestCount++;
+UnLock();
+// Call the client specified callback function
+aCb.iCallback(ClientId, ResourceId, Level, LevelOwnerId, Result, Param);
+Lock();
+aCb.iPendingRequestCount--;
+if(aCb.iPendingRequestCount == 0)
+{
+aCb.iResult = KErrCompletion; //Mark the callback object to act properly during cancellation of this request.
+}
+UnLock();
 		}
 	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::GetResourceState(asynchronous), Level = %d", req->Level()));
 	if(pR->LatencyGet())
 		return r;
 #ifdef PRM_INSTRUMENTATION_MACRO
 @prototype 9.5
 Cancel an asynchronous request(or its callback).
 @param aClientId       ID of the client which is requesting the cancellation of the request.
-@param aResourceId     ID for the resource which the request that is being cancelled operates
+@param aResourceId     ID for the resource which the request that is being canceled operates
 upon.
 @param aCb             A reference to the resource callback object specified with the request
-that is being cancelled.
+that is being canceled.
-@return KErrCancel if the request was cancelled.
+@return KErrCancel if the request was canceled.
 KErrNotFound if this resource ID could not be found in the current list of controllable
 resources.
 KErrCompletion if request is no longer pending.
 KErrAccessDenied if the client ID could not be found in the current list of registered
 		clients or if the client was registered to be thread relative and this API is not called
 		from the same thread or if client is not the same that requested the resource state change.
-		KErrInUse if the request cannot be cancelled as processing of the request already started
+		KErrInUse if the request cannot be canceled as processing of the request already started
 		and will run to completion.
 @pre Interrupts must be enabled
 @pre Kernel must be unlocked
 @pre No fast mutex can be held
 						 thread relative and this API is not called from the same thread.
 		KErrInUse if the passed notification object is used already.
 NOTE: This API should return immediately; however the notification will
 only happen when a resource change occurs.Notification request is idempotent,
 if the same notification has already been requested for this resource ID,
-the API returns with no further action.Notifications remain queued until they are cancelled.
+the API returns with no further action.Notifications remain queued until they are canceled.
 @pre Interrupts must be enabled
 @pre Kernel must be unlocked
 @pre No fast mutex can be held
 @pre Call in a thread context but not from null thread or DFC thread1
 		}
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 	DStaticPowerResource *pR = NULL;
 	GET_RESOURCE_FROM_LIST(aResourceId, pR)
 #else
-	if(aResourceId > iStaticResourceArrayEntries)
+	if(aResourceId > (TUint)iStaticResourceArray.Count())
 		{
 r = KErrNotFound;
 		PRM_POSTNOTIFICATION_REGISTER_TRACE
 		UNLOCK_RETURN(r);
 		}
 @return KErrNone if the operation of requesting a notification was successful.
 KErrNotFound if this resource ID could not be found in the current list
-of controllable reosurces.
+of controllable resources.
 KErrAccessDenied if the client ID could not be found in the list of
 registered clients or if the client was registered to be thread
 						 relative and this API is not called from the same thread.
 		KErrInUse if the passed notification object is used already.
 		KErrArgument if the specified threshold is out of range.
 NOTE: This API should return immediately; however the notification will only
 happen when a resource change occurs. Notification request is idempotent,
 if the same notification has already been requested for this resource ID,
-the API returns with no further action. Notification remain queued until they are cancelled.
+the API returns with no further action. Notification remain queued until they are canceled.
 @pre Interrupts must be enabled
 @pre Kernel must be unlocked
 @pre No fast mutex can be held
 @pre Call in a thread context but not from null thread or DFC thread1
 		}
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 	DStaticPowerResource *pR = NULL;
 	GET_RESOURCE_FROM_LIST(aResourceId, pR)
 #else
-	if(aResourceId > iStaticResourceArrayEntries)
+	if(aResourceId > (TUint)iStaticResourceArray.Count())
 		{
 r = KErrNotFound;
 PRM_POSTNOTIFICATION_REGISTER_TRACE
 		UNLOCK_RETURN(r);
 		}
 Cancel and remove from queue a previously issued request for notification on a
 resource state change.
 @param aClientId ID of the client which is requesting to cancel the notification
 @param aResourceId for the resource whose pending notification of state changes
-is being cancelled.
+is being canceled.
 @param aN          A reference to the notification object that was associated with
-the notification request that is being cancelled. This will be
+the notification request that is being canceled. This will be
-used to identify the notification that is being cancelled.
+used to identify the notification that is being canceled.
-@return KErrCancel if the notification request was successfully cancelled.
+@return KErrCancel if the notification request was successfully canceled.
 KErrNotFound if the specified notification object is
 					 not found in the current list of notification objects for the
 					 specified resource.
 KErrAccessDenied if the client requesting the cancellation is not the same
 which registered the notification or if the resource id does not match or
 	Lock();
 	TInt clientPoolCount = iClientLevelPoolCount;
 	TInt requestPoolCount = iRequestPoolCount;
 	SPowerResourceClient* pC;
 	if(aRequest.ClientId() & USER_SIDE_CLIENT_BIT_MASK)
-		pC = iUserSideClientList[(TUint16)(aRequest.ClientId() & ID_INDEX_BIT_MASK)];
+		pC = iUserSideClientList[(aRequest.ClientId() & ID_INDEX_BIT_MASK)];
 	else
-		pC = iClientList[(TUint16)(aRequest.ClientId() & ID_INDEX_BIT_MASK)];
+		pC = iClientList[(aRequest.ClientId() & ID_INDEX_BIT_MASK)];
 	UnLock();
 	if(clientPoolCount < aRequest.ClientLevelCount())
 		{
 		//Grow the client level pool
 	req->ReqType() = TPowerRequest::ERegisterUsersideClient;
 	UnLock();
 	req->SendReceive(iMsgQ);
 	if(req->ReturnCode() == KErrNone)
 		{
-		pC = iUserSideClientList[(TUint16)(req->ClientId() & ID_INDEX_BIT_MASK)];
+		pC = iUserSideClientList[(req->ClientId() & ID_INDEX_BIT_MASK)];
 		pC->iName=&aName;
 		//Store the current thread Id;
 		pC->iThreadId = t.iId;
 		aClientId = pC->iClientId;
-		}
+	    __KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::RegisterProxyClient, clientId = 0x%x", aClientId));
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::RegisterProxyClient, clientId = 0x%x", aClientId));
+	    PRM_CLIENT_REGISTER_TRACE
-PRM_CLIENT_REGISTER_TRACE
+		}
 	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK
 	return KErrNone;
 	}
 /*  Deregister the specified user side client from resource controller.
 	CHECK_CONTEXT(t)
 	//Get the index from client ID
 	if(!(aClientId & USER_SIDE_CLIENT_BIT_MASK))
 		return KErrArgument;
 	Lock();
-	SPowerResourceClient* pC = iUserSideClientList[(TUint16)(aClientId & ID_INDEX_BIT_MASK)];
+	SPowerResourceClient* pC = iUserSideClientList[(aClientId & ID_INDEX_BIT_MASK)];
 	if(!pC)
 		{
 		UnLock();
 		LOCK_AND_CRITICAL_SECTION_COUNT_CHECK
 		return KErrNotFound;
 	ResourceStateChangeOfClientLevels(pC);
 	//Add reserved request to pool
 	iRequestPoolCount = (TUint16)(iRequestPoolCount + pC->iReservedRm);
 	PRM_CLIENT_DEREGISTER_TRACE
 	//Increment the free pool count for client level and request level.
-	iUserSideClientList.Remove(pC, (TUint16)(pC->iClientId & ID_INDEX_BIT_MASK));
+	iUserSideClientList.Remove(pC, (pC->iClientId & ID_INDEX_BIT_MASK));
 	pC->iName = NULL;
 	iUserSideClientCount--; //Decrement client count
 	LIST_PUSH(iClientPool, pC, iNextInList);
 	UnLock();
 	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK
 	TUint count=0;
 	TUint id=0;
 	for(count=0;count<aNumResources;count++) //Check for valid resource ID.
 		{
 #ifndef PRM_ENABLE_EXTENDED_VERSION
-		if((!pS->iResourceId) || (pS->iResourceId > iStaticResourceArrayEntries) || (!iStaticResourceArray[pS->iResourceId-1]))
+		if((!pS->iResourceId) || (pS->iResourceId > (TUint)iStaticResourceArray.Count()) || (!iStaticResourceArray[pS->iResourceId-1]))
 			{
 			UnLock();
 			LOCK_AND_CRITICAL_SECTION_COUNT_CHECK
 			return KErrNotFound;
 			}
 			UnLock();
 			LOCK_AND_CRITICAL_SECTION_COUNT_CHECK
 			return KErrNotSupported;
 			}
 		if((!pS->iResourceId) || ((pS->iResourceId & KIdMaskResourceWithDependencies) &&
-			     (pS->iResourceId > iStaticResDependencyCount)) || (!(pS->iResourceId & KIdMaskResourceWithDependencies) &&
+			     (pS->iResourceId > (TUint)iStaticResDependencyArray.Count())) || (!(pS->iResourceId & KIdMaskResourceWithDependencies) &&
-					((pS->iResourceId > iStaticResourceArrayEntries) || (!iStaticResourceArray[pS->iResourceId-1]))))
+					((pS->iResourceId > (TUint)iStaticResourceArray.Count()) || (!iStaticResourceArray[pS->iResourceId-1]))))
 			{
 			UnLock();
 			LOCK_AND_CRITICAL_SECTION_COUNT_CHECK
 			return KErrNotFound;
 			}
 		pS->iCurrentLevel = pR->iCachedLevel;
 		pR->iIdleListEntry=pS;
 		pS++;
 		}
 	iListForIdle=(SIdleResourceInfo*)aBuf->Ptr();
-	pS = (SIdleResourceInfo*)aBuf->Ptr();
 	UnLock();
 	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK
 	return KErrNone;
 	}
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 	GET_RESOURCE_FROM_LIST(aResourceId, pR)
 	if(aResourceId & KIdMaskDynamic)
 		((DDynamicPowerResource*)pR)->Lock();
 #else
-	if(aResourceId > iStaticResourceArrayEntries)
+	if(aResourceId > (TUint)iStaticResourceArray.Count())
 		{
 		UNLOCK_RETURN(KErrNotFound);
 		}
 	pR = iStaticResourceArray[aResourceId - 1];
 	if(!pR)

branch	RCL_3
changeset 43	c1f20ce4abcf
parent 4	56f325a607ea
child 44	3e88ff8f41d5