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

equal deleted inserted replaced

-:4122176ea935
+:56f325a607ea
 	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)
 {
 /** 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
+#ifdef RESOURCE_MANAGER_SIMULATED_PSL
-	SPowerResourceClient* pC = NULL;
+	iCleanList.ResetAndDestroy();
-	pC = iClientList[(TUint16)(iPowerControllerId & ID_INDEX_BIT_MASK)];
+#endif
-	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;
 			{
 			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, \
+			__KTRACE_OPT(KRESMANAGER, Kern::Printf("Notification ClientId = 0x%x, ResourceId = %d, state = %d, Result = %d",
-				             Result = %d", pN->iCallback.iClientId, pN->iCallback.iResourceId, aState, aReturnCode));
+									pN->iCallback.iClientId, pN->iCallback.iResourceId, aState, aReturnCode));
 			PRM_POSTNOTIFICATION_SENT_TRACE
 			pN->iCallback.Enque();
 			continue;
 			}
 #endif
 			{
 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, \
+			__KTRACE_OPT(KRESMANAGER, Kern::Printf("Notifications ClientId = 0x%x, ResourceId = %d, State = %d, Result = %d",
-				              Result = %d", pN->iCallback.iClientId, pN->iCallback.iResourceId, aState, aReturnCode));
+										pN->iCallback.iClientId, pN->iCallback.iResourceId, aState, aReturnCode));
 			PRM_POSTNOTIFICATION_SENT_TRACE
 pN->iCallback.Enque();
 			}
 		pN->iPreviousLevel = aState; //Update the state
 		}
 		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",  \
+	__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
 			{
 			{
 			aRequest.ClientId() = -1;
 			aRequest.Level() = pR->iDefaultLevel;
 			}
 		}
-	aRequest.ReturnCode() = pR->DoRequest(aRequest);
+	if((aRequest.ReqType() == TPowerRequest::EGet) || (pR->iCachedLevel != aRequest.Level()))
+		aRequest.ReturnCode() = pR->DoRequest(aRequest);
 	CompleteRequest(aRequest);
 	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::HandleMsg"));
 	}
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 		if(aClientId & USER_SIDE_CLIENT_BIT_MASK)
 			pC = iUserSideClientList[TUint16(aClientId & ID_INDEX_BIT_MASK)];
 		else
 			pC = iClientList[TUint16(aClientId & ID_INDEX_BIT_MASK)];
 		}
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf("Request Type = %d, ClientId = 0x%x, ResourceId = %d",  \
+	__KTRACE_OPT(KRESMANAGER, Kern::Printf("Request Type = %d, ClientId = 0x%x, ResourceId = %d",
 		                             aRequest.ReqType(), aRequest.ClientId(), aRequest.ResourceId()));
 	if((aRequest.ResourceId() & KIdMaskResourceWithDependencies) && (aRequest.ReqType() != TPowerRequest::EGet))
 		{
 		Lock();
 		iDfcQDependencyLock = ETrue;
 void DPowerResourceController::MsgQFunc(TAny* aPtr)
 	{
 __KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::MsgQFunc"));
 DPowerResourceController* pRC=(DPowerResourceController*)aPtr;
 TPowerRequest* aReq=(TPowerRequest*)pRC->iMsgQ->iMessage;
+	DStaticPowerResource *pR = aReq->Resource();
 	if(aReq->ReqType() == TPowerRequest::EAllocReserve)
 		{
 		aReq->ReturnCode() = pRC->HandleReservationOfObjects(*aReq);
 		aReq->Complete(aReq->ReturnCode(),ETrue);
 		return;
 else if(aReq->ClientId() & USER_SIDE_CLIENT_BIT_MASK)
 		pC = pRC->iUserSideClientList[TUint16(aReq->ClientId() & ID_INDEX_BIT_MASK)];
 	else
 		pC = pRC->iClientList[TUint16(aReq->ClientId() & ID_INDEX_BIT_MASK)];
-	DStaticPowerResource *pR = aReq->Resource();
 TUint aResourceId = aReq->ResourceId();
 TInt r = aReq->ReturnCode();
 if(aReq->ReqType()==TPowerRequest::EGet)
 		{
 		TInt aState = aReq->Level();
 void DPowerResourceController::MsgQDependencyFunc(TAny* aPtr)
 	{
 __KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::MsgQDependencyFunc"));
 DPowerResourceController* pRC=(DPowerResourceController*)aPtr;
 TPowerRequest* aReq=(TPowerRequest*)pRC->iMsgQDependency->iMessage;
+	DStaticPowerResource *pR = aReq->Resource();
 	pRC->HandleDependencyMsg(*aReq);
 	if((aReq->ResourceId() & KIdMaskDynamic) && (aReq->ResourceCb()))
 		{
 		pRC->Lock();
 		((DDynamicPowerResource*)aReq->Resource())->UnLock();
 else if(aReq->ClientId() & USER_SIDE_CLIENT_BIT_MASK)
 		pC = pRC->iUserSideClientList[TUint16(aReq->ClientId() & ID_INDEX_BIT_MASK)];
 	else
 		pC = pRC->iClientList[TUint16(aReq->ClientId() & ID_INDEX_BIT_MASK)];
-	DStaticPowerResource *pR = aReq->Resource();
 TUint aResourceId = aReq->ResourceId();
 TInt r = aReq->ReturnCode();
 if(aReq->ReqType()==TPowerRequest::EGet)
 		{
 		TInt aState = aReq->Level();
 	//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();
 	if(!pC)
 		{
 		UnLock();
-		TUint16 growBy = iClientList.GrowBy();
 		// coverity[alloc_fn]
 		SPowerResourceClient *pCL = new SPowerResourceClient[growBy];
 		if(!pCL)
 			{
 			__KTRACE_OPT(KRESMANAGER, Kern::Printf("No memory to grow client pool"));
 			Panic(ENoMemToCreatePowerControllerClient);
 			}
-		if(iClientList.ReSize(growBy))
+#ifdef RESOURCE_MANAGER_SIMULATED_PSL
-			Panic(ENoMemToCreatePowerControllerClient);
+		iCleanList.Append(pCL);
+#endif
 		Lock();
 for(count = 0; count < growBy-1; count++)
 			LIST_PUSH(iClientPool, &pCL[count], iNextInList);
 		pC = &pCL[count];
 #ifdef PRM_INSTRUMENTATION_MACRO
 	TUint size = growBy *sizeof(SPowerResourceClient);
 	PRM_MEMORY_USAGE_TRACE
 #endif
 		}
 	pC->iName = (const TDesC8*)&KPowerController;
-iClientList.Add(pC, iPowerControllerId);
+	UnLock();
+	if(iClientList.Allocd()==iClientList.Count())
+		{
+		if(iClientList.ReSize(growBy))
+			{
+			Panic(ENoMemToCreatePowerControllerClient);
+			}
+		}
+	Lock();
+	iClientList.Add(pC, iPowerControllerId);
 	pC->iClientId = iPowerControllerId | CLIENT_POWER_CONTROLLER_BIT_MASK;
 	iPowerControllerId = pC->iClientId;
 iClientCount++;
 if(TPowerController::PowerController())
 TPowerController::PowerController()->RegisterResourceController(this, iPowerControllerId);
 This takes care of updating the resource level for each client.
 */
 TInt DPowerResourceController::CheckLevelAndAddClient(SPowerResourceClient* pC, TPowerRequest* aReq)
 	{
 //Client level addition in state change needs to be taken care.
-__KTRACE_OPT(KRESMANAGER, Kern::Printf("DPowerResourceController::CheckLevelAndAddClient, ClientId = 0x%x, \
+__KTRACE_OPT(KRESMANAGER, Kern::Printf("DPowerResourceController::CheckLevelAndAddClient, ClientId = 0x%x, ResourceId = %d, ReqType = %d",
-		                     ResourceId = %d, ReqType = %d", pC->iClientId, aReq->ResourceId(), aReq->ReqType()));
+													pC->iClientId, aReq->ResourceId(), aReq->ReqType()));
 	SPowerResourceClientLevel* pSCL=NULL; //Place to hold the current client
 	SPowerResourceClientLevel* pMCL=NULL; //Place to hold the prevailing client.
 	DStaticPowerResource* aResource = aReq->Resource();
 aReq->RequiresChange() = EFalse;
 		{
 		// If the client is new, get free client level from pool and populate with client information
 		// and add it to the client list and in resource list.
 if((pC->iReservedCl ==0) && !iClientLevelPoolCount)
 			{
-			__KTRACE_OPT(KRESMANAGER, Kern::Printf("Client level quota exhausted and its free pool empty, \
+			__KTRACE_OPT(KRESMANAGER, Kern::Printf("Client level quota exhausted and its free pool empty, iReservedCl = %d, iClientLevelPoolCount = %d",
-				        iReservedCl = %d, iClientLevelPoolCount = %d", pC->iReservedCl, iClientLevelPoolCount));
+													pC->iReservedCl, iClientLevelPoolCount));
 			return KErrUnderflow;
 			}
 LIST_POP(iClientLevelPool, pSCL, iNextInList);
 pSCL->iClientId=pC->iClientId;
 pSCL->iResourceId=aReq->ResourceId();
 	//If the level is in increasing order with respect to sense the change is allowed.
 if(((aResource->Sense() == DStaticPowerResource::ENegative) && aReq->Level()<CurrentLevel) ||
 		                 ((aResource->Sense() == DStaticPowerResource::EPositive) && aReq->Level()>CurrentLevel))
 		{
-		__KTRACE_OPT(KRESMANAGER, Kern::Printf("Resource is in increasing order with respect to sense and level is %d",\
+		__KTRACE_OPT(KRESMANAGER, Kern::Printf("Resource is in increasing order with respect to sense and level is %d",
 			                                                                                           aReq->Level()));
 aReq->RequiresChange()=ETrue;
 return KErrNone;
 		}
 if((TInt)pC->iClientId == aResource->iLevelOwnerId)
 @return KErrNoMemory if one the prealocations fails
 */
 TInt DPowerResourceController::InitPools(TUint16 aKClients, TUint16 aUClients, TUint16 aNClientLevels, TUint16 aNRequests)
 	{
 __KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::InitPools"));
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf("aKClients = %d, aUClients = %d, aNClientLevels = %d, aNRequests = %d", \
+	__KTRACE_OPT(KRESMANAGER, Kern::Printf("aKClients = %d, aUClients = %d, aNClientLevels = %d, aNRequests = %d",
 		                                                     aKClients, aUClients, aNClientLevels, aNRequests));
 __ASSERT_ALWAYS((iInitialised == EResConCreated) && !(iClientPool || iRequestPool || iClientLevelPool), Kern::Fault("Already initialized"
 		                                                     __FILE__, __LINE__));
 // Create client pool
 			iClientList.Delete();
 			iUserSideClientList.Delete();
 			return KErrNoMemory;
 			}
 		}
+#ifdef RESOURCE_MANAGER_SIMULATED_PSL
+	iCleanList.Append(pC);
+#endif
 	Lock();
 	TUint16 c;
 	for(c = 0; c < iStaticResDependencyCount; c++)
 		{
 		LIST_PUSH(iResourceLevelPool, &pRL[c], iNextInList);
 		}
 	iResourceLevelPoolCount = iStaticResDependencyCount;
 #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++)
 @pre Call in a thread context, but not from null thread or DFC thread1.
 @pre Can be used in a device driver
 */
 TInt DPowerResourceController::RegisterClient(TUint& aClientId, const TDesC8& aName, TOwnerType aType)
 	{
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::RegisterClient, Name = %S, \
+	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::RegisterClient, Name = %S, Type = %d", &aName, aType));
-		                                                                 Type = %d", &aName, aType));
 	DThread& thread = Kern::CurrentThread();
 	CHECK_CONTEXT(thread)
 	//If number of expected kernel side clients is set to 0 during initial configuration
 	//then dont allow to configure kernel side clients.
 	if(!iClientList.GrowBy())
 	TUint clientId;
 	if(aRequest.ReqType() == TPowerRequest::ERegisterKernelClient)
 		{
 		//Get Next client from FreePool
 		LIST_POP(iClientPool, pC, iNextInList);
+		TUint16 growBy = iClientList.GrowBy();
 		if(!pC)
 			{
 			//Free Pool is empty, so try to grow the pool.
-			TUint16 growBy = iClientList.GrowBy();
 			__KTRACE_OPT(KRESMANAGER, Kern::Printf("Client pool exhausted so growing client Pool by %d", growBy));
 			// coverity[alloc_fn]
-			SPowerResourceClient *pCL = new SPowerResourceClient[growBy];
+			SPowerResourceClient *pCL = (SPowerResourceClient*)Kern::Alloc(sizeof(SPowerResourceClient) * growBy);
 			if(!pCL)
 				{
 				__KTRACE_OPT(KRESMANAGER, Kern::Printf("No memory to grow client pool"));
 				return(KErrNoMemory);
 				}
-			//Resize the container for holding client list
+#ifdef RESOURCE_MANAGER_SIMULATED_PSL
-			if(!iClientList.ReSize(growBy))
+			iCleanList.Append(pCL);
-				{
+#endif
-				__KTRACE_OPT(KRESMANAGER, Kern::Printf("No memory for client container allocation"));
-				delete []pCL;
-				return(KErrNoMemory);
-				}
 			Lock();
 			TUint16 count;
 			for(count = 0; count < growBy-1; count++)
 				LIST_PUSH(iClientPool, &pCL[count], iNextInList);
 			UnLock();
 	PRM_MEMORY_USAGE_TRACE
 #endif
 			pC = &pCL[count];
 			}
 		pC->iClientId = 0;
+		if(iClientList.Allocd()==iClientList.Count())
+			{
+			//Resize the container for holding client list
+			if(iClientList.ReSize(growBy)!=KErrNone)
+				{
+				__KTRACE_OPT(KRESMANAGER, Kern::Printf("No memory for client container allocation"));
+				return(KErrNoMemory);
+				}
+			}
 		Lock();
 		iClientList.Add(pC, clientId);
 		++iClientCount;
 		UnLock();
 		}
 	else // Request is registration of user side client
 		{
 		//Get Next client from FreePool
 		LIST_POP(iClientPool, pC, iNextInList);
+		TUint16 growBy = iUserSideClientList.GrowBy();
 		if(!pC)
 			{
 			//Free Pool is empty, so try to grow the pool.
-			TUint16 growBy = iUserSideClientList.GrowBy();
+			SPowerResourceClient *pCL = (SPowerResourceClient*)Kern::Alloc(sizeof(SPowerResourceClient) * growBy);
-			SPowerResourceClient* pCL = new SPowerResourceClient[growBy];
 			if(!pCL)
 				{
 				return KErrNoMemory;
 				}
-			//Resize the container for holding client list
+#ifdef RESOURCE_MANAGER_SIMULATED_PSL
-			if(!iUserSideClientList.ReSize(growBy))
+			iCleanList.Append(pCL);
-				{
+#endif
-				__KTRACE_OPT(KRESMANAGER, Kern::Printf("No memory for container class allocation"));
-				delete []pCL;
-				return KErrNoMemory;
-				}
 			Lock();
 			TUint16 count;
 			for(count = 0; count < growBy - 1; count++)
 				LIST_PUSH(iClientPool, &pCL[count], iNextInList);
 			UnLock();
 			}
 		pC->iClientId = 0;
 		//User side clients are always thread relative as they execute in the context of proxy driver.
 		pC->iClientId = CLIENT_THREAD_RELATIVE_BIT_MASK; //Set 31st bit;
 		pC->iClientId|=USER_SIDE_CLIENT_BIT_MASK;
+		if(iUserSideClientList.Allocd()==iUserSideClientList.Count())
+			{
+			//Resize the container for holding client list
+			if(iUserSideClientList.ReSize(growBy)!=KErrNone)
+				{
+				__KTRACE_OPT(KRESMANAGER, Kern::Printf("No memory for container class allocation"));
+				return KErrNoMemory;
+				}
+			}
 		Lock();
 		iUserSideClientList.Add(pC, clientId);
 		++iUserSideClientCount;
 		UnLock();
 		}
 void DPowerResourceController::ResourceStateChangeOfClientLevels(SPowerResourceClient* pC)
 	{
 	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::ResourceStateChangeOfClientLevels"));
 TPowerRequest* pReq = (TPowerRequest*)&TPowerRequest::Get();
 DStaticPowerResource* pR = NULL;
-TInt r = KErrNone;
 SPowerResourceClientLevel* pCL = pC->iLevelList;
 SPowerResourceClientLevel* pCLL = NULL;
 	while(pCL != NULL)
 		{
-__KTRACE_OPT(KRESMANAGER, Kern::Printf("Client 0x%x has requirement on resource %d", pCL->iClientId, \
+__KTRACE_OPT(KRESMANAGER, Kern::Printf("Client 0x%x has requirement on resource %d", pCL->iClientId, pCL->iResourceId));
-			                                                                                 pCL->iResourceId));
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 		switch((pCL->iResourceId >>RESOURCE_BIT_IN_ID_CHECK) & 0x3)
 		{
 		case PRM_STATIC_RESOURCE:
 			pR = iStaticResourceArray[pCL->iResourceId - 1];
 		}
 #else
 		pR = iStaticResourceArray[pCL->iResourceId -1];
 #endif
 #ifdef PRM_ENABLE_EXTENDED_VERSION
-		if((((TInt)pCL->iClientId == pR->iLevelOwnerId) || (pR->Sense() == DStaticPowerResource::ECustom)) && (!(pCL->iResourceId & KIdMaskDynamic) ||
+		if(((pR->Sense() == DStaticPowerResource::ECustom) || ((TInt)pCL->iClientId == pR->iLevelOwnerId)) && (!(pCL->iResourceId & KIdMaskDynamic) ||
 			         ((pCL->iResourceId & KIdMaskDynamic) && (((DDynamicPowerResource*)pR)->LockCount() != 0))))
 #else
-			if(((TInt)pCL->iClientId == pR->iLevelOwnerId) || (pR->Sense() == DStaticPowerResource::ECustom))
+		if((pR->Sense() == DStaticPowerResource::ECustom) || ((TInt)pCL->iClientId == pR->iLevelOwnerId))
 #endif
 		    {
 pReq->ReqType() = TPowerRequest::ESetDefaultLevel;
 pReq->ResourceId() = pCL->iResourceId;
 pReq->ClientId() = pCL->iClientId;
 pReq->Resource() = pR;
 			pReq->Level() = pR->iCachedLevel;
 pReq->ResourceCb() = NULL;
 			pReq->ReturnCode() = KErrNone;
-r = KErrNone;
 #ifdef PRM_INSTRUMENTATION_MACRO
 			//Setting level to current level as correct level will be known only at the end,
 			TInt aNewState = pR->iCachedLevel;
 			TUint aResourceId = pReq->ResourceId();
 			PRM_CLIENT_CHANGE_STATE_START_TRACE
 #endif
+			TInt r = KErrNone;
 			if(pR->LatencySet())
 				{
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 				if(pCL->iResourceId & KIdMaskDynamic)
 					((DDynamicPowerResource*)pR)->Lock();
 				else
 					{
 					pReq->ClientId() = -1;
 					pReq->Level() = pR->iDefaultLevel;
 					}
 				if((!pR->Usage()) || (pR->Usage() && pReq->RequiresChange()))
 					{
 					// NOTE:Not checking error here as no action can be taken based on error.
-					UnLock();
+					if(pR->iCachedLevel != pReq->Level())
-					r = pR->DoRequest(*pReq);
+						{
-					Lock();
+						UnLock();
+						r = pR->DoRequest(*pReq);
+						Lock();
+						}
 					CompleteNotifications(pReq->ClientId(), pReq->Resource(), pReq->Level(),
 						                            pReq->ReturnCode(), pReq->ClientId(), EFalse);
+#ifdef PRM_INSTRUMENTATION_MACRO
 					PRM_CLIENT_CHANGE_STATE_END_TRACE
+#endif
 					pR->iLevelOwnerId = pReq->ClientId();
 					pR->iCachedLevel = pReq->Level();
 					if(pR->iIdleListEntry)
 						{
 						SIdleResourceInfo* pI = (SIdleResourceInfo*)pR->iIdleListEntry;
 						pI->iLevelOwnerId = pReq->ClientId();
 						pI->iCurrentLevel = pReq->Level();
 						}
 					}
 				}
 			}
 		/* Deque from resource */
 		pCLL = pCL;
 		pCL = pCL->iNextInList;
 		pCLL->Deque();
 @pre Call in a thread context but not from null thread or DFC thread1
 @pre Can be used in a device driver
 */
 TInt DPowerResourceController::GetClientName(TUint aClientId, TUint aTargetClientId, TDes8& aName)
 	{
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::GetClientName, CallingClientId = 0x%x, \
+	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::GetClientName, CallingClientId = 0x%x, TargetClientId = 0x%x", aClientId, aTargetClientId));
-		                                                       TargetClientId = 0x%x", aClientId, aTargetClientId));
 	DThread& thread = Kern::CurrentThread();
 	CHECK_CONTEXT(thread)
 	if((aName.MaxLength() - aName.Length()) < KMaxClientNameLength)
 		return KErrArgument;
 	SPowerResourceClient* pC = NULL;
 @pre Call in a thread context but not from null thread or DFC thread1
 @pre Can be used in a device driver
 */
 TInt DPowerResourceController::GetClientId(TUint aClientId, TDesC8& aClientName, TUint& aTargetClientId)
 	{
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::GetClientId CallingClientId = 0x%x, \
+	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::GetClientId CallingClientId = 0x%x, ClientName = %S", aClientId, &aClientName));
-		                                                           ClientName = %S", aClientId, &aClientName));
 	DThread& thread = Kern::CurrentThread();
 	CHECK_CONTEXT(thread)
 	if(aClientName.Length() > KMaxClientNameLength)
 		return KErrTooBig;
 	SPowerResourceClient* pC = NULL;
 	for(count = 0; count < iStaticResourceArrayEntries; count++)
 		{
 		if((iStaticResourceArray[count]) && (!(aResourceName.Compare(*(const TDesC8*)iStaticResourceArray[count]->iName))))
 			{
 			aResourceId = ++count;
-			__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetResourceId, ResourceId = 0x%x", \
+			__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetResourceId, ResourceId = 0x%x", aResourceId));
-				                                                                                    aResourceId));
 			UNLOCK_RETURN(KErrNone);
 			}
 		}
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 	//Search in dynamic resource with no dependencies array for specified resource name.
 	for(count = 0; count < iStaticResDependencyCount; count++)
 		{
 		if(!(aResourceName.Compare(*(const TDesC8*)iStaticResDependencyArray[count]->iName)))
 			{
 			aResourceId = iStaticResDependencyArray[count]->iResourceId;
-			__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetResourceId, ResourceId = 0x%x", \
+			__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetResourceId, ResourceId = 0x%x", aResourceId));
-				                                                                                    aResourceId));
 			UNLOCK_RETURN(KErrNone);
 			}
 		}
 	//Search in dynamic resource with dependencies (if exists) for specified resource name
 	DDynamicPowerResourceD* pDRD;
 		UNLOCK_RETURN(KErrNotFound);
 		}
 #else
 	if(!aResourceId)
 		{
-		__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetResourceInfo, return value = %d", \
+		__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetResourceInfo, return value = %d", KErrNotFound));
-			                                                                                          KErrNotFound));
 		UNLOCK_RETURN(KErrNotFound);
 		}
 	//Get resource from corresponding container
 	GET_RESOURCE_FROM_LIST(aResourceId, pR)
 #endif
 		aNumResource = iStaticResourceCount + iDynamicResourceCount + iStaticResDependencyCount +
 			                                                          iDynamicResDependencyCount;
 #else
 		aNumResource = iStaticResourceCount;
 #endif
-		__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetNumResourcesInUseByClient, \
+		__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetNumResourcesInUseByClient, numResources = %d", aNumResource));
-			                                                              numResources = %d", aNumResource));
 		UNLOCK_RETURN(KErrNone);
 		}
 	GET_TARGET_CLIENT();
 	SPowerResourceClientLevel* pCL = pC->iLevelList;
 	aNumResource = 0;
 	while(pCL)
 		{
 		aNumResource++;
 		pCL = pCL->iNextInList;
 		}
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetNumResourcesInUseByClient, \
+	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetNumResourcesInUseByClient, numResources = %d", aNumResource));
-		                                                              numResources = %d", aNumResource));
 	UNLOCK_RETURN(KErrNone);
 	}
 /**
 @publishedPartner
 		if(r != KErrNone)
 			UNLOCK_RETURN(r);
 		pInfo->Append(buf);
 		}
 	aNumResources = count;
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetInfoOnResourcesInUseByClient, \
+	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetInfoOnResourcesInUseByClient, AcutalNoOfResources = %d", aNumResources));
-		                                                     AcutalNoOfResources = %d", aNumResources));
 	UNLOCK_RETURN(KErrNone);
 	}
 /**
 @publishedPartner
 		UNLOCK_RETURN(KErrNotFound);
 #endif
 	aNumClients = 0;
 	for(SDblQueLink*pCL = pR->iClientList.First(); pCL != &pR->iClientList.iA; pCL=pCL->iNext)
 	   aNumClients++;
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetNumClientsUsingResource, \
+	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetNumClientsUsingResource, NumClients = %d", aNumClients));
-		                                                                NumClients = %d", aNumClients));
 	UNLOCK_RETURN(KErrNone);
 	}
 /**
 @publishedPartner
 		info.iClientId = pC->iClientId;
 		info.iClientName =  (TDesC8*)pC->iName;
 pInfo->Append(TPckgC<TPowerClientInfoV01>(info));
 		}
 	aNumClients = c;
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetInfoOnClientsUsingResource, \
+	__KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::GetInfoOnClientsUsingResource, NumClients = %d", aNumClients));
-		                                                                NumClients = %d", aNumClients));
 	UNLOCK_RETURN(KErrNone);
 	}
 /**
 @publishedPartner
 												                                TPowerResourceCb* aCb)
 	{
 	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::ChangeResourceState"));
 	__KTRACE_OPT(KRESMANAGER, Kern::Printf("ClientId = 0x%x, ResourceId = %d, NewState = %d", aClientId, \
 		                                                                          aResourceId, aNewState));
+	DThread& thread = Kern::CurrentThread();
 	CHECK_CONTEXT(thread)
 	if(iInitialised <= EResConCreated)
 		return KErrNotReady;
-	DThread& thread = Kern::CurrentThread();
 	if(!aResourceId)
 		return KErrNotFound;
 	SPowerResourceClient* pC = NULL;
 	TInt r = KErrNone;
 	Lock();
 		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);
 	PRM_CLIENT_CHANGE_STATE_START_TRACE
 	//If long latency resource requested synchronously from DFC thread 0 Panic
 const TDesC8* pDfc0 = &KDfcThread0Name;
 	if((pR->LatencySet() && !aCb) && !(pDfc0->Compare(*(TDesC8*)thread.iName)))
 */
 TInt DPowerResourceController::GetResourceState(TUint aClientId, TUint aResourceId, TBool aCached, TInt& aState,
 																						TInt& aLevelOwnerId)
 	{
 	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::GetResourceState(synchronous)"));
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf("ClientId = 0x%x, ResourceId = %d, Cached = %d", aClientId, aResourceId,\
+	__KTRACE_OPT(KRESMANAGER, Kern::Printf("ClientId = 0x%x, ResourceId = %d, Cached = %d", aClientId, aResourceId, aCached));
-																										aCached));
+	DThread& thread = Kern::CurrentThread();
 	CHECK_CONTEXT(thread)
 	if(iInitialised <= EResConCreated)
 		return KErrNotReady;
-	DThread& thread = Kern::CurrentThread();
 	SPowerResourceClient* pC = NULL;
 	TInt r = KErrNone;
 	Lock();
 	VALIDATE_CLIENT(thread);
 	if(!aResourceId)
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 	if(aResourceId & KIdMaskDynamic)
 		((DDynamicPowerResource*)pR)->UnLock();
 #endif
 	UnLock();
-__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::GetResourceState(synchronous), Level = %d",\
+__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::GetResourceState(synchronous), Level = %d", aState));
-																											aState));
 	if(pR->LatencyGet()) //For long latency resource btrace is done in controller thread.
 		return r;
 	PRM_RESOURCE_GET_STATE_END_TRACE
 	return r;
 	}
 @pre Can be used in a device driver
 */
 TInt DPowerResourceController::GetResourceState(TUint aClientId, TUint aResourceId, TBool aCached,  TPowerResourceCb& aCb)
 	{
 	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::GetResourceState(asynchronous)"));
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf("ClientId = 0x%x, ResourceId = %d, Cached = %d", aClientId, aResourceId, \
+	__KTRACE_OPT(KRESMANAGER, Kern::Printf("ClientId = 0x%x, ResourceId = %d, Cached = %d", aClientId, aResourceId, aCached));
-																											aCached));
+	DThread& thread = Kern::CurrentThread();
 	CHECK_CONTEXT(thread)
 	if(iInitialised <= EResConCreated)
 		return KErrNotReady;
-	DThread& thread = Kern::CurrentThread();
 	SPowerResourceClient* pC = NULL;
 	TInt r = KErrNone;
 	Lock();
 	VALIDATE_CLIENT(thread);
 	if(!aResourceId)
 		UNLOCK_RETURN(KErrNotFound);
-	if(!&aCb) //Need to specify a callback for this asynchronous API
-		UNLOCK_RETURN(KErrArgument);
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 	DStaticPowerResource *pR = NULL;
 	GET_RESOURCE_FROM_LIST(aResourceId, pR)
 	if(aResourceId & KIdMaskDynamic)
 		{
 		UNLOCK_RETURN(KErrNotFound);
 	DStaticPowerResource *pR = iStaticResourceArray[aResourceId-1];
 	if(!pR)
 		UNLOCK_RETURN(KErrNotFound);
 #endif
-	if(&aCb)
+	aCb.iResult = KErrNone;
-		{
+	aCb.iResourceId = aResourceId;
-		aCb.iResult = KErrNone;
+	aCb.iClientId = aClientId;
-		aCb.iResourceId = aResourceId;
-		aCb.iClientId = aClientId;
-		}
 	PRM_RESOURCE_GET_STATE_START_TRACE
 	if(aCached) //Call the callback directly
 		{
 		UnLock();
 		aCb.iCallback(aClientId, aResourceId, pR->iCachedLevel, pR->iLevelOwnerId, KErrNone, aCb.iParam);
 		UnLock();
 		// Call the client callback function directly as it is already executing in the context of client thread.
 		aCb.iCallback(aClientId, aResourceId, req->Level(), pR->iLevelOwnerId, r, aCb.iParam);
 		aCb.iResult = KErrCompletion; //Mark the callback object to act properly during cancellation of this request.
 		}
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::GetResourceState(asynchronous), Level = %d", \
+	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::GetResourceState(asynchronous), Level = %d", req->Level()));
-																										req->Level()));
 	if(pR->LatencyGet())
 		return r;
 #ifdef PRM_INSTRUMENTATION_MACRO
 	TInt aState = req->Level();
 	PRM_RESOURCE_GET_STATE_END_TRACE
 #endif
 	if(aCb.iClientId != aClientId)
 		{
 __KTRACE_OPT(KRESMANAGER, Kern::Printf("aCb.iClientId = 0x%x, aClientId = 0x%x", aCb.iClientId, aClientId));
 r = KErrAccessDenied;
+#ifdef PRM_INSTRUMENTATION_MACRO
 PRM_RESOURCE_CANCEL_LONGLATENCY_OPERATION_TRACE
+#endif
 UNLOCK_RETURN(r);
 		}
 	if(aCb.iResult == KErrCompletion)
 		{
 r = KErrCompletion;
+#ifdef PRM_INSTRUMENTATION_MACRO
 PRM_RESOURCE_CANCEL_LONGLATENCY_OPERATION_TRACE
+#endif
 		UNLOCK_RETURN(r);
 		}
 	//Search in the controller message queue for this message
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 	if(aResourceId & KIdMaskResourceWithDependencies) //long latency resource with dependency and will be processed in dependency thread.
 				{
 				r = KErrCancel;
 				pRM->Deque();
 				pMsgQ->iState = TMessageBase::EFree; //Reset the state
 				MoveRequestToFreePool(pReq);
+#ifdef PRM_INSTRUMENTATION_MACRO
 				PRM_RESOURCE_CANCEL_LONGLATENCY_OPERATION_TRACE
+#endif
 				UNLOCK_RETURN(r);
 				}
 			}
 		}
 	else // long latency resource without dependency and will be processed in RC thread.
 				{
 				r = KErrCancel;
 				pRM->Deque();
 				pMsgQ->iState = TMessageBase::EFree; //Reset the state
 				MoveRequestToFreePool(pReq);
+#ifdef PRM_INSTRUMENTATION_MACRO
 				PRM_RESOURCE_CANCEL_LONGLATENCY_OPERATION_TRACE
+#endif
 				UNLOCK_RETURN(r);
 				}
 			}
 		}
+#ifdef PRM_INSTRUMENTATION_MACRO
 PRM_RESOURCE_CANCEL_LONGLATENCY_OPERATION_TRACE
+#endif
 	UNLOCK_RETURN(r);
 	}
 /**
 @publishedPartner
 state information it is interested in for accessing from null thread. This
 list needs to be accessed from the Idle thread using direct access. */
 TInt DPowerResourceController::RegisterResourcesForIdle(TInt aPowerControllerId, TUint aNumResources, TPtr* aBuf)
 	{
 	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::RegisterResourceForIdle"));
-	__KTRACE_OPT(KRESMANAGER, Kern::Printf("PowerControllerId = 0x%x, NumResources = %d", aPowerControllerId, \
+	__KTRACE_OPT(KRESMANAGER, Kern::Printf("PowerControllerId = 0x%x, NumResources = %d", aPowerControllerId, aNumResources));
-																							aNumResources));
 #ifdef DEBUG_VERSION //Surrounding with macro to avoid warnings.
 	DThread& t = Kern::CurrentThread();
 	CHECK_CONTEXT(t)
 #endif
 	if(!aBuf)
 		return KErrInUse;
 	if((TUint)(aBuf->MaxLength() - aBuf->Length()) < (sizeof(SIdleResourceInfo) * aNumResources))
 		return KErrArgument;
 	GET_CRITICAL_SECTION_COUNT
 	Lock();
-	SIdleResourceInfo* pS=(SIdleResourceInfo*)aBuf;
+	SIdleResourceInfo* pS=(SIdleResourceInfo*)aBuf->Ptr();
 	DStaticPowerResource* pR=NULL;
-	TUint count=0, id=0;
+	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]))
 			{
 			UnLock();
 			LOCK_AND_CRITICAL_SECTION_COUNT_CHECK
 			return KErrNotSupported;
 			}
 		if((!pS->iResourceId) || ((pS->iResourceId & KIdMaskResourceWithDependencies) &&
-			     (pS->iResourceId > iStaticResDependencyCount)) || (pS->iResourceId > iStaticResourceArrayEntries)
+			     (pS->iResourceId > iStaticResDependencyCount)) || (!(pS->iResourceId & KIdMaskResourceWithDependencies) &&
-				                                 || (!iStaticResourceArray[pS->iResourceId-1]))
+					((pS->iResourceId > iStaticResourceArrayEntries) || (!iStaticResourceArray[pS->iResourceId-1]))))
 			{
 			UnLock();
 			LOCK_AND_CRITICAL_SECTION_COUNT_CHECK
 			return KErrNotFound;
 			}
 #endif
 		pS++;
 		}
-	pS = (SIdleResourceInfo*)aBuf;
+	pS = (SIdleResourceInfo*)aBuf->Ptr();
 	for(count=0;count<aNumResources;count++)
 		{
 		id=pS->iResourceId;
 #ifdef PRM_ENABLE_EXTENDED_VERSION
 		if(id & KIdMaskResourceWithDependencies) //Dependency resource
 			pR = iStaticResDependencyArray[(id & ID_INDEX_BIT_MASK)-1];
 		else
 #endif
 		pR=iStaticResourceArray[id-1];
+		pS->iLevelOwnerId = pR->iLevelOwnerId;
+		pS->iCurrentLevel = pR->iCachedLevel;
 		pR->iIdleListEntry=pS;
 		pS++;
 		}
-	iListForIdle=(SIdleResourceInfo*)aBuf;
+	iListForIdle=(SIdleResourceInfo*)aBuf->Ptr();
+	pS = (SIdleResourceInfo*)aBuf->Ptr();
 	UnLock();
 	LOCK_AND_CRITICAL_SECTION_COUNT_CHECK
 	return KErrNone;
 	}
 */
 TInt DPowerResourceController::GetInterface(TUint aClientId, TUint aInterfaceId, TAny* aParam1, TAny* aParam2,
 											                                             TAny* aParam3)
 	{
 	__KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::GetInterface"));
+	DThread& thread = Kern::CurrentThread();
 	CHECK_CONTEXT(thread)
 	if((iInitialised != EResConStartupCompleted) && (aInterfaceId != KResManControlIoGetVersion))
 		return KErrNotSupported;
 	TInt r = KErrNone;
-	DThread& thread = Kern::CurrentThread();
 	Lock();
 	SPowerResourceClient* pC = NULL;
 	VALIDATE_CLIENT(thread);
 #ifndef PRM_ENABLE_EXTENDED_VERSION
 	if(aInterfaceId == KResManControlIoGetVersion)

changeset 4	56f325a607ea
parent 0	a41df078684a
child 43	c1f20ce4abcf