diff -r 000000000000 -r bde4ae8d615e os/kernelhwsrv/kerneltest/e32test/resourceman/resourceman_psl/rescontrol_psl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/kernelhwsrv/kerneltest/e32test/resourceman/resourceman_psl/rescontrol_psl.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,952 @@ +// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of the License "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// e32test\resourceman\resourceman_psl\rescontrol_psl.cpp +// +// + +#include "rescontrol_psl.h" +TInt KSimulatedRCThreadPriority = 28; +#ifdef RESOURCE_MANAGER_SIMULATED_PSL +static DSimulatedPowerResourceController TheController; +#endif + +//Resource controller creation +#ifdef RESOURCE_MANAGER_SIMULATED_PSL +DECLARE_STANDARD_PDD() + { + TInt r = DPowerResourceController::InitController(); + if(r == KErrNone) + return new DResConPddFactory; + return NULL; + } +#endif + +/** ISR function invoked when the specified amount of time expires. This is used for event driven resources. */ +void DSimulatedPowerResourceController::TimerIsrFunc(TAny *ptr) + { + DSimulatedPowerResourceController *pC = (DSimulatedPowerResourceController *)ptr; + //Queues a Dfc to signal fast semaphore. + pC->iEventDfc.Add(); + } + +/** DFC function to signal the fast semaphore. For event driven resources, the PIL is blocked until specified time (just + to simulate hardware event). */ +void DSimulatedPowerResourceController::EventDfcFunc(TAny *ptr) + { + DSimulatedPowerResourceController *pC = (DSimulatedPowerResourceController *)ptr; + NKern::FSSignal((NFastSemaphore*)&pC->iEventFastSem); + } + +/** Constructor for simulated resource controller. */ +DSimulatedPowerResourceController::DSimulatedPowerResourceController():DPowerResourceController(),iStaticResourceCount(0), iEventDfc(EventDfcFunc, this) + { + Kern::Printf(">DSimulatedPowerResourceController"); + } + +/** Destructor for simulated resource controller. */ +DSimulatedPowerResourceController::~DSimulatedPowerResourceController() + { + Kern::Printf("DSimulatedPowerResourceController::~DSimulatedPowerResourceController()\n"); + ((TDynamicDfcQue*)iDfcQ)->Destroy(); + DStaticPowerResource *pR; + TUint c; + for(c = 0; c < iStaticResourceCount; c++) + { + pR = iResources[c]; + delete pR; + } + delete []iResources; +#ifdef PRM_ENABLE_EXTENDED_VERSION + DStaticPowerResourceD* pDR; + + delete []iNodeArray; //Delete dependency nodes + for(c = 0; c < iStaticResDependencyCount; c++) + { + pDR = iDependencyResources[c]; + delete pDR; + } + delete []iDependencyResources; +#endif + } + +#ifdef PRM_ENABLE_EXTENDED_VERSION +//Function to return the controller pointer to use in extended psl file +DSimulatedPowerResourceController* GetControllerPtr() + { + return &TheController; + } +#endif + +/** This function is called from PIL, during resource controller creation phase. + It creates a DFC queue and then invokes setDfcQ function to PIL to set the queue. + It calls InitPools function of PIL to create the specified sizes of clients, + client levels and requests pools. + */ +TInt DSimulatedPowerResourceController::DoInitController() + { + TInt r = KErrNone; + Kern::Printf(">DSimulatedPowerResourceController::DoInitController()"); + //Create a DFC queue + r = Kern::DynamicDfcQCreate((TDynamicDfcQue*&)iDfcQ, KSimulatedRCThreadPriority, KResmanName); + if(r != KErrNone) + { + Kern::Printf("DFC Queue creation failed"); + return r; + } + +#ifdef CPU_AFFINITY_ANY + NKern::ThreadSetCpuAffinity((NThread*)(iDfcQ->iThread), KCpuAffinityAny); +#endif + + //Call the resource controller to set the DFCQ + SetDfcQ(iDfcQ); + +#ifdef PRM_ENABLE_EXTENDED_VERSION + //Create a DFC Dependency Queue + r = Kern::DynamicDfcQCreate((TDynamicDfcQue*&)iDfcQDependency, KSimulatedRCThreadPriority, + KResmanName); + if(r != KErrNone) + { + Kern::Printf("DFC Dependency Queue creation failed"); + return r; + } + //Call the resource controller to set the DFCQDependency + SetDfcQDependency(iDfcQDependency); +#endif + //Init pools + r = InitPools(KERNEL_CLIENTS, USER_CLIENTS, CLIENT_LEVELS, REQUESTS); + return r; + } + +/** This function is used only for testing purpose to test the RegisterResorcesForIdle API + ideally will be used by Power controller to obtain the state of the resources will be interested + for idle power management. + */ +EXPORT_C TInt DSimulatedPowerResourceController::CaptureIdleResourcesInfo(TUint aControllerId, TUint aNumResources, TPtr* aPtr) + { + Kern::Printf("DSimulatedPowerResourceController::CaptureIdleResourcesInfo\n"); + TInt r = TheController.RegisterResourcesForIdle(aControllerId, aNumResources, aPtr); + return r; + } + +/** This function is used only for testing purpose. This is complete the initialization of resource controller. + This is used to test the Postbootlevel and registration of static resource API's. + */ +EXPORT_C TInt DSimulatedPowerResourceController::CompleteResourceControllerInitialisation() + { + Kern::Printf("DSimulatedPowerResourceController::CompleteResourceControllerInitialisation()\n"); + return(TheController.InitResources()); + } + +/** This function changes the state of the resource to appropriate value */ +TInt DSimulatedPowerResourceController::ChangeResource(TPowerRequest& req, TInt& aCurrentLevel, TInt aMaxLevel, TInt aMinLevel) + { + DStaticPowerResource* pR = req.Resource(); + if(pR->Sense() == DStaticPowerResource::ECustom) //Custom sense set it to specified level + { + req.Level() = aCurrentLevel; + } + else if(pR->Sense() == DStaticPowerResource::EPositive) + { + //Set it to value specified if valid, otherwise minimum or maximum based on the value. + if(req.Level() > aMaxLevel) + req.Level() = aMaxLevel; + else if(req.Level() < aMinLevel) + req.Level() = aMinLevel; + aCurrentLevel = req.Level(); + } + else + { + //Set it to value specified if valid, otherwise minimum or maximum based on the value. + if( req.Level() < aMaxLevel) + req.Level() = aMaxLevel; + else if(req.Level() > aMinLevel) + req.Level() = aMinLevel; + aCurrentLevel = req.Level(); + } + return KErrNone; + } + +/** This function processes all instantaneous resource types. Instantaneous resources should returned immediately, so + this function returns immediately after updating the value. */ +TInt DSimulatedPowerResourceController::ProcessInstantaneousResources(TPowerRequest& req, TInt& aCurrentLevel, TInt aMaxLevel, TInt aMinLevel, TInt aDefaultLevel) + { + if(req.ReqType() == TPowerRequest::EGet) + { + req.Level() = aCurrentLevel; + } + else if(req.ReqType() == TPowerRequest::EChange) + { + return ChangeResource(req, aCurrentLevel, aMaxLevel, aMinLevel); + } + else if(req.ReqType() == TPowerRequest::ESetDefaultLevel) + { + req.Level() = aDefaultLevel; + aCurrentLevel = aDefaultLevel; + } + else + return KErrNotSupported; + return KErrNone; + } + +/** Function used for polling resources. */ +TBool PollingFunction(TAny* ptr) + { + static TInt count = 0; + if(++count == (TInt)ptr) + { + count = 0; + return ETrue; + } + return EFalse; + } + +/** This function processes polled resources. It waits for specified time and then performs requested operation + if the specified operation is long latency operation. + */ +TInt DSimulatedPowerResourceController::ProcessPolledResources(TPowerRequest& req, TInt&aCurrentLevel, TInt aMaxLevel, TInt aMinLevel, TInt aDefaultLevel, TInt aBlockTime) + { + DStaticPowerResource* pR = req.Resource(); + if(req.ReqType() == TPowerRequest::EGet) + { + if(!pR->LatencyGet()) + return ProcessInstantaneousResources(req, aCurrentLevel, aMaxLevel, aMinLevel, aDefaultLevel); + Kern::PollingWait(PollingFunction, (TAny*)aBlockTime, 3, aBlockTime); + req.Level() = aCurrentLevel; + } + else if(req.ReqType() == TPowerRequest::EChange) + { + if(!pR->LatencySet()) + return ProcessInstantaneousResources(req, aCurrentLevel, aMaxLevel, aMinLevel, aDefaultLevel); + Kern::PollingWait(PollingFunction, (TAny*)aBlockTime, 3, aBlockTime); + return ChangeResource(req, aCurrentLevel, aMaxLevel, aMinLevel); + } + else if(req.ReqType() == TPowerRequest::ESetDefaultLevel) + { + if(!pR->LatencySet()) + return ProcessInstantaneousResources(req, aCurrentLevel, aMaxLevel, aMinLevel, aDefaultLevel); + Kern::PollingWait(PollingFunction, (TAny*)aBlockTime, 3, aBlockTime); + req.Level() = aDefaultLevel; + aCurrentLevel = aDefaultLevel; + } + else + return KErrNotSupported; + return KErrNone; + } + +/** This function processes event driven resources. It makes the calling function (PIL) to block on fast semaphore + and starts the timer.The PIL is blocked until the timer expires. + */ +TInt DSimulatedPowerResourceController::ProcessEventResources(TPowerRequest& req, TInt& aCurrentLevel, TInt aMaxLevel, TInt aMinLevel, TInt aDefaultLevel, TInt aBlockTime) + { + DStaticPowerResource* pR = req.Resource(); + if(((req.ReqType() == TPowerRequest::EGet) && (!pR->LatencyGet())) || ((req.ReqType() == TPowerRequest::EChange) && (!pR->LatencySet())) || ((req.ReqType() == TPowerRequest::ESetDefaultLevel) && (!pR->LatencySet()))) + return ProcessInstantaneousResources(req, aCurrentLevel, aMaxLevel, aMinLevel, aDefaultLevel); + iEventFastSem.iOwningThread = (NThreadBase*)NKern::CurrentThread(); + iEventFastSem.iCount = 0; + TInt timeout = NKern::TimerTicks(aBlockTime); + NTimer iEventTimer(TimerIsrFunc, this); + iEventTimer.OneShot(timeout); + NKern::FSWait(&iEventFastSem); + if(req.ReqType() == TPowerRequest::EGet) + req.Level() = aCurrentLevel; + else if(req.ReqType() == TPowerRequest::EChange) + return ChangeResource(req, aCurrentLevel, aMaxLevel, aMinLevel); + else if(req.ReqType() == TPowerRequest::ESetDefaultLevel) + { + req.Level() = aDefaultLevel; + aCurrentLevel = aDefaultLevel; + } + else + return KErrNotSupported; + return KErrNone; + } + +//This registers all static resource with resource controller. This function is called by PIL +TInt DSimulatedPowerResourceController::DoRegisterStaticResources(DStaticPowerResource**& aStaticResourceArray, TUint16& aStaticResourceCount) + { + Kern::Printf(">DSimulatedPowerResourceController::DoRegisterStaticResources"); + aStaticResourceArray = (DStaticPowerResource**)new(DStaticPowerResource*[MAX_RESOURCE_COUNT]); + if(!aStaticResourceArray) + return KErrNoMemory; + DStaticPowerResource* pR = NULL; + + //Create Binary Single Instantaneous Positive Resource + pR = new DBSIGISPResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Multilevel Single Instantaneous Positive Resource + pR = new DMLSIGISPResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Binary Single Instantaneous Negative Resource + pR = new DBSIGISNResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Multilevel Single Instantaneous Negative Resource + pR = new DMLSIGISNResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Binary Single Longlatency Positive Resource + pR = new DBSLGLSPResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Multilevel Single Longlatency Positive Resource + pR = new DMLSLGLSPResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Binary Single Longlatency Get & Instantaneous Set Negative Resource + pR = new DBSLGISNResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Multilevel Single Longlatency Get & Instantaneous Set Negative Resource + pR = new DMLSLGISNResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Binary Single Instantaneous Get & Longlatency Set Positive Resource + pR = new DBSIGLSPResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Multilevel Single Instantaneous Get & Longlatency Set Positive Resource + pR = new DMLSIGLSPResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Binary SHared Instantaneous Positive Resource + pR = new DBSHIGISPResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Multilevel SHared Instantaneous Positive Resource + pR = new DMLSHIGISPResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Binary SHared Instantaneous Negative Resource + pR = new DBSHIGISNResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Multilevel SHared Instantaneous Negative Resource + pR = new DMLSHIGISNResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Binary SHared Longlatency Positive Resource + pR = new DBSHLGLSPResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Multilevel SHared Longlatency Positive Resource + pR = new DMLSHLGLSPResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Binary SHared Longlatency Get & Instantaneous Set Negative Resource + pR = new DBSHLGISNResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Multilevel SHared Longlatency Get & Instantaneous Set Negative Resource + pR = new DMLSHLGISNResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create holes in resource array + aStaticResourceArray[iStaticResourceCount++] = NULL; + aStaticResourceArray[iStaticResourceCount++] = NULL; + //Create Binary SHared Instantaneous Get & Longlatency Set Positive Resource + pR = new DBSHIGLSPResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Multilevel SHared Instantaneous Get & Longlatency Set Positive Resource + pR = new DMLSHIGLSPResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + //Create Binary shared Longlatency get and set Custom Resource + pR = new DBSHLGLSCResource(); + if(!pR) + CLEAN_AND_RETURN(iStaticResourceCount, aStaticResourceArray, KErrNoMemory) + aStaticResourceArray[iStaticResourceCount++] = pR; + + iResources = aStaticResourceArray; + + aStaticResourceCount = iStaticResourceCount; + return KErrNone; + } + +//Constructors of all resources +_LIT(KDBSIGISPResource, "SymbianSimulResource"); +DBSIGISPResource::DBSIGISPResource() : DStaticPowerResource(KDBSIGISPResource, E_OFF), iMinLevel(0), iMaxLevel(1), iCurrentLevel(0) + { + iFlags = KBinary; + } + +_LIT(KDMLSIGISPResource, "DMLSIGISPResource"); +DMLSIGISPResource::DMLSIGISPResource() : DStaticPowerResource(KDMLSIGISPResource, 12), iMinLevel(10), iMaxLevel(75), iCurrentLevel(12) + { + iFlags = KMultiLevel; + } + +_LIT(KDBSIGISNResource, "DBSIGISNResource"); +DBSIGISNResource::DBSIGISNResource() : DStaticPowerResource(KDBSIGISNResource, E_ON), iMinLevel(E_ON), iMaxLevel(E_OFF), iCurrentLevel(E_ON) + { + iFlags = KBinary | KSenseNegative; + } + +_LIT(KDMLSIGISNResource, "DMLSIGISNResource"); +DMLSIGISNResource::DMLSIGISNResource() : DStaticPowerResource(KDMLSIGISNResource, 75), iMinLevel(75), iMaxLevel(10), iCurrentLevel(75) + { + iFlags = KMultiLevel | KSenseNegative; + } + +_LIT(KDBSLGLSPResource, "DBSLGLSPResource"); +// change this state to OFF +DBSLGLSPResource::DBSLGLSPResource() : DStaticPowerResource(KDBSLGLSPResource, E_ON), iMinLevel(E_OFF), iMaxLevel(E_ON), iCurrentLevel(E_ON), iPolled(ETrue) + { + iFlags = KLongLatencyGet | KLongLatencySet; + NKern::LockSystem(); + iBlockTime = 5; + NKern::UnlockSystem(); + } + +_LIT(KDMLSLGLSPResource, "DMLSLGLSPResource"); +DMLSLGLSPResource::DMLSLGLSPResource() : DStaticPowerResource(KDMLSLGLSPResource, 75), iMinLevel(10), iMaxLevel(75), iCurrentLevel(75), iPolled(EFalse) + { + iFlags = KMultiLevel | KLongLatencySet | KLongLatencyGet; + NKern::LockSystem(); + iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME; + NKern::UnlockSystem(); + } + +_LIT(KDBSLGISNResource, "DBSLGISNResource"); +DBSLGISNResource::DBSLGISNResource() : DStaticPowerResource(KDBSLGISNResource, E_ON), iMinLevel(E_ON), iMaxLevel(E_OFF), iCurrentLevel(E_ON), iPolled(ETrue) + { + iFlags = KLongLatencyGet | KSenseNegative; + NKern::LockSystem(); + iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME; + NKern::UnlockSystem(); + } + +_LIT(KDMLSLGISNResource, "DMLSLGISNResource"); +DMLSLGISNResource::DMLSLGISNResource() : DStaticPowerResource(KDMLSLGISNResource, 75), iMinLevel(75), iMaxLevel(10), iCurrentLevel(75), iPolled(EFalse) + { + iFlags = KMultiLevel | KLongLatencyGet | KSenseNegative; + NKern::LockSystem(); + iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME; + NKern::UnlockSystem(); + } + +_LIT(KDBSIGLSPResource, "DBSIGLSPResource"); +DBSIGLSPResource::DBSIGLSPResource() : DStaticPowerResource(KDBSIGLSPResource, E_ON), iMinLevel(E_OFF), iMaxLevel(E_ON), iCurrentLevel(E_ON), iPolled(ETrue) + { + iFlags = KBinary | KLongLatencySet; + NKern::LockSystem(); + iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME; + NKern::UnlockSystem(); + } + +_LIT(KDMLSIGLSPResource, "DMLSIGLSPResource"); +DMLSIGLSPResource::DMLSIGLSPResource() : DStaticPowerResource(KDMLSIGLSPResource, 75), iMinLevel(10), iMaxLevel(100), iCurrentLevel(75), iPolled(EFalse) + { + iFlags = KMultiLevel | KLongLatencySet; + NKern::LockSystem(); + iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME; + NKern::UnlockSystem(); + } + +_LIT(KDBSHIGISPResource, "DBSHIGISPResource"); +DBSHIGISPResource::DBSHIGISPResource() : DStaticPowerResource(KDBSHIGISPResource, E_OFF), iMinLevel(0), iMaxLevel(1), iCurrentLevel(0) + { + iFlags = KBinary | KShared; + } + +_LIT(KDMLSHIGISPResource, "DMLSHIGISPResource"); +DMLSHIGISPResource::DMLSHIGISPResource() : DStaticPowerResource(KDMLSHIGISPResource, 12), iMinLevel(10), iMaxLevel(75), iCurrentLevel(12) + { + iFlags = KMultiLevel | KShared; + } + +_LIT(KDBSHIGISNResource, "DBSHIGISNResource"); +DBSHIGISNResource::DBSHIGISNResource() : DStaticPowerResource(KDBSHIGISNResource, E_ON), iMinLevel(E_ON), iMaxLevel(E_OFF), iCurrentLevel(E_ON) + { + iFlags = KBinary | KShared | KSenseNegative; + } + +_LIT(KDMLSHIGISNResource, "DMLSHIGISNResource"); +DMLSHIGISNResource::DMLSHIGISNResource() : DStaticPowerResource(KDMLSHIGISNResource, 75), iMinLevel(75), iMaxLevel(10), iCurrentLevel(75) + { + iFlags = KMultiLevel | KShared | KSenseNegative; + } + +_LIT(KDBSHLGLSPResource, "DBSHLGLSPResource"); +DBSHLGLSPResource::DBSHLGLSPResource() : DStaticPowerResource(KDBSHLGLSPResource, E_ON), iMinLevel(E_OFF), iMaxLevel(E_ON), iCurrentLevel(E_ON), iPolled(ETrue) + { + iFlags = KBinary | KShared | KLongLatencySet | KLongLatencyGet; + NKern::LockSystem(); + iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME; + NKern::UnlockSystem(); + } + +_LIT(KDMLSHLGLSPResource, "DMLSHLGLSPResource"); +DMLSHLGLSPResource::DMLSHLGLSPResource() : DStaticPowerResource(KDMLSHLGLSPResource, 70), iMinLevel(5), iMaxLevel(70), iCurrentLevel(70), iPolled(EFalse) + { + iFlags = KMultiLevel | KShared | KLongLatencySet | KLongLatencyGet; + NKern::LockSystem(); + iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME; + NKern::UnlockSystem(); + } + +_LIT(KDBSHLGISNResource, "DBSHLGISNResource"); +DBSHLGISNResource::DBSHLGISNResource() : DStaticPowerResource(KDBSHLGISNResource, E_ON), iMinLevel(E_ON), iMaxLevel(E_OFF), iCurrentLevel(E_ON), iPolled(ETrue) + { + iFlags = KBinary | KShared | KLongLatencyGet | KSenseNegative; + NKern::LockSystem(); + iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME; + NKern::UnlockSystem(); + } + +_LIT(KDMLSHLGISNResource, "DMLSHLGISNResource"); +DMLSHLGISNResource::DMLSHLGISNResource() : DStaticPowerResource(KDMLSHLGISNResource, 75), iMinLevel(75), iMaxLevel(10), iCurrentLevel(75), iPolled(EFalse) + { + iFlags = KMultiLevel | KShared | KLongLatencySet | KSenseNegative; + NKern::LockSystem(); + iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME; + NKern::UnlockSystem(); + } + +_LIT(KDBSHIGLSPResource, "DBSHIGLSPResource"); +DBSHIGLSPResource::DBSHIGLSPResource() : DStaticPowerResource(KDBSHIGLSPResource, E_ON), iMinLevel(E_OFF), iMaxLevel(E_ON), iCurrentLevel(E_ON), iPolled(ETrue) + { + iFlags = KBinary | KShared | KLongLatencySet; + NKern::LockSystem(); + iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME; + NKern::UnlockSystem(); + } + +_LIT(KDMLSHIGLSPResource, "DMLSHIGLSPResource"); +DMLSHIGLSPResource::DMLSHIGLSPResource() : DStaticPowerResource(KDMLSHIGLSPResource, 75), iMinLevel(10), iMaxLevel(75), iCurrentLevel(75), iPolled(EFalse) + { + iFlags = KMultiLevel | KShared | KLongLatencySet; + NKern::LockSystem(); + iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME; + NKern::UnlockSystem(); + } + +_LIT(KDBSHLGLSCResource, "KDBSHLGLSCResource"); +DBSHLGLSCResource::DBSHLGLSCResource() : DStaticPowerResource(KDBSHLGLSCResource, E_ON), iMinLevel(E_OFF), iMaxLevel(E_ON), iCurrentLevel(E_ON), iPolled(EFalse) + { + iFlags = KMultiLevel | KShared | KLongLatencySet | KSenseCustom; + SetCustomFunction(CustomFunction); + NKern::LockSystem(); + iBlockTime = MIN_BLOCK_TIME + Kern::Random() % MAX_BLOCK_TIME; + NKern::UnlockSystem(); + } + +//DoRequest implementation of all functions +TInt DBSIGISPResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessInstantaneousResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel); + } + +TInt DMLSIGISPResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessInstantaneousResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel); + } + +TInt DBSIGISNResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessInstantaneousResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel); + } + +TInt DMLSIGISNResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessInstantaneousResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel); + } + +TInt DBSLGLSPResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessPolledResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel, iBlockTime); + } + +TInt DMLSLGLSPResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessEventResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel, iBlockTime); + } + +TInt DBSLGISNResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessPolledResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel, iBlockTime); + } + +TInt DMLSLGISNResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessPolledResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel, iBlockTime); + } + +TInt DBSIGLSPResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessEventResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel, iBlockTime); + } + +TInt DMLSIGLSPResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessEventResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel, iBlockTime); + } + +TInt DBSHIGISPResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessInstantaneousResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel); + } + +TInt DMLSHIGISPResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessInstantaneousResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel); + } + +TInt DBSHIGISNResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessInstantaneousResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel); + } + +TInt DMLSHIGISNResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessInstantaneousResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel); + } + +TInt DBSHLGLSPResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessPolledResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel, iBlockTime); + } + +TInt DMLSHLGLSPResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessEventResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel, iBlockTime); + } + +TInt DBSHLGISNResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessEventResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel, iBlockTime); + } + +TInt DMLSHLGISNResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessPolledResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel, iBlockTime); + } + +TInt DBSHIGLSPResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessPolledResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel, iBlockTime); + } + +TInt DMLSHIGLSPResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessEventResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel, iBlockTime); + } + +TInt DBSHLGLSCResource::DoRequest(TPowerRequest& req) + { + return TheController.ProcessEventResources(req, iCurrentLevel, iMaxLevel, iMinLevel, iDefaultLevel, iBlockTime); + } + +/** Custom function implemetation*/ +TBool DBSHLGLSCResource::CustomFunction(TInt &aClientId, const TDesC8& aClientName, + TUint /*aResourceId*/, + TCustomOperation aCustomOperation, TInt &aLevel, + TAny* aLevelList, TAny* /*aReserved*/) + { + static TInt ClientId = -1; + + Kern::Printf("CustomFunction Passed Clientname = %S\n", &aClientName); + + //Allow first client to change the resource state + if(aCustomOperation == EClientRequestLevel && ClientId == -1) + { + ClientId = aClientId; + return ETrue; + } + + //If client deregisters then ask to set the value to next client level if present, else to default level. + if(aCustomOperation == EClientRelinquishLevel) + { + TInt count = 0; + SPowerResourceClientLevel* pL = NULL; + SDblQue* pS = (SDblQue*)aLevelList; + for(SDblQueLink* pCL=pS->First();pCL!=&pS->iA;pCL=pCL->iNext) + { + count++; + pL=(SPowerResourceClientLevel*)pCL; + if((pL->iClientId != (TUint)aClientId)) + { + aClientId = pL->iClientId; + aLevel = pL->iLevel; + ClientId = aClientId; + return ETrue; + } + } + if((pL == NULL) || (count == 1)) + { + aClientId = -1; + aLevel = E_OFF; + ClientId = aClientId; + return ETrue; + } + } + + /*Allow if the current client is asking to state change to E_ON. + Also change is allowed if current client asks for E_OFF and no other + client is holding requirement for E_ON + */ + if(aClientId == ClientId) + { + if(aLevel == E_ON) + return ETrue; + SPowerResourceClientLevel* pL = NULL; + SDblQue* pS = (SDblQue*)aLevelList; + for(SDblQueLink* pCL=pS->First();pCL!=&pS->iA;pCL=pCL->iNext) + { + pL=(SPowerResourceClientLevel*)pCL; + if(pL->iLevel == E_ON) + { + aClientId = pL->iClientId; + ClientId = pL->iClientId; + aLevel = E_ON; + return EFalse; + } + } + return ETrue; + } + return EFalse; + } + +//Get info implementation of all resources. +TInt DBSIGISPResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DMLSIGISPResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DBSIGISNResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DMLSIGISNResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DBSLGLSPResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DMLSLGLSPResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DBSLGISNResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DMLSLGISNResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DBSIGLSPResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DMLSIGLSPResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DBSHIGISPResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DMLSHIGISPResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DBSHIGISNResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DMLSHIGISNResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DBSHLGLSPResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DMLSHLGLSPResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DBSHLGISNResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DMLSHLGISNResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DBSHIGLSPResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DMLSHIGLSPResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + } + +TInt DBSHLGLSCResource::GetInfo(TDes8* info) const + { + DStaticPowerResource::GetInfo((TDes8*)info); + TPowerResourceInfoV01 *buf1 = (TPowerResourceInfoV01*)info; + buf1->iMinLevel = iMinLevel; + buf1->iMaxLevel = iMaxLevel; + return KErrNone; + }