--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/drivers/resourceman/rescontrol_export.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,338 @@
+// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// e32\drivers\resourceman\rescontrol_export.cpp
+//
+//
+
+#include <drivers/resourcecontrol.h>
+
+#ifdef DEBUG_VERSION
+#define GET_CRITICAL_SECTION_COUNT(thread) \
+ TInt CsCount = thread.iNThread.iCsCount;
+
+#define LOCK_AND_CRITICAL_SECTION_COUNT_CHECK(thread) \
+ if(thread.iNThread.iCsCount != CsCount) \
+ Kern::Fault("PowerResourceController", __LINE__); \
+ if(pRC->iResourceMutex->iHoldCount != 0) \
+ Kern::Fault("PowerResourceController", __LINE__);
+#else
+#define GET_CRITICAL_SECTION_COUNT(thread)
+#define LOCK_AND_CRITICAL_SECTION_COUNT_CHECK(thread)
+#endif
+
+/**
+ @publishedPartner
+ @prototype 9.5
+ Kernel extension or variants can call this API to set the post bool value without registering
+ as client with the resource controller. This can be used by the resource controller PSL to set the
+ specified static resources to appropriate value before resource controller is fully initialized.
+ @param aResId ID of the resource whose level should be set after initialisation
+ @param aLevel Resource level to set
+ @return KErrNone, if operation is success
+ KErrNotFound, if resource ID could not be found in the static resource array.
+ KErrNotSupported, if this API is called after resource controller is fully initialized
+ */
+EXPORT_C TInt DPowerResourceController::PostBootLevel(TUint aResId, TInt aLevel)
+ {
+#ifdef DEBUG_VERSION
+ DThread& thread = Kern::CurrentThread();
+ GET_CRITICAL_SECTION_COUNT(thread)
+#endif
+ __KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::PostBootLevel, aResId = 0x%x, aLevel = %d",
+ aResId, aLevel));
+ DPowerResourceController* pRC = TInterface::GetPowerResourceController();
+ if(!pRC)
+ return KErrNotFound;
+ pRC->Lock();
+ CHECK_CONTEXT(thread)
+ //Accept the postboot level only if issued before controller is fully initialised.
+ if(pRC->iInitialised == EResConStartupCompleted)
+ {
+ pRC->UnLock();
+ LOCK_AND_CRITICAL_SECTION_COUNT_CHECK(thread)
+ return KErrNotSupported;
+ }
+#ifndef PRM_ENABLE_EXTENDED_VERSION
+ // coverity[deref_ptr]
+ // aResId is checked to be more than the array entries before dereferencing pRC->iStaticResourceArray
+ if((!aResId) || (aResId > pRC->iStaticResourceArrayEntries) || (!pRC->iStaticResourceArray[aResId-1]))
+ {
+ pRC->UnLock();
+ LOCK_AND_CRITICAL_SECTION_COUNT_CHECK(thread)
+ return KErrNotFound;
+ }
+#else
+ if(!aResId || ((aResId & KIdMaskResourceWithDependencies) && ((aResId & ID_INDEX_BIT_MASK) > pRC->iStaticResDependencyCount))
+ || (!(aResId & KIdMaskResourceWithDependencies) && ((aResId > pRC->iStaticResourceArrayEntries)
+ || (!pRC->iStaticResourceArray[aResId-1]))))
+ {
+ pRC->UnLock();
+ LOCK_AND_CRITICAL_SECTION_COUNT_CHECK(thread)
+ return KErrNotFound;
+ }
+ if(aResId & KIdMaskResourceWithDependencies)
+ {
+ aResId &= ID_INDEX_BIT_MASK;
+ DStaticPowerResource* pR = pRC->iStaticResDependencyArray[--aResId];
+ pR->iPostBootLevel=aLevel;
+ pR->iFlags |= SET_VALID_POST_BOOT_LEVEL;
+ }
+ else
+#endif
+ if(pRC->iStaticResourceArray)
+ {
+ DStaticPowerResource* pR=pRC->iStaticResourceArray[--aResId];
+ pR->iPostBootLevel=aLevel;
+ pR->iFlags |= SET_VALID_POST_BOOT_LEVEL; // To indicate valid post boot level is set.
+ }
+ pRC->UnLock();
+ LOCK_AND_CRITICAL_SECTION_COUNT_CHECK(thread)
+ return KErrNone;
+ }
+
+/**
+ @publishedPartner
+ @prototype 9.5
+ Kernel extensions or variants can call this API to register the static resources before resource controller
+ is fully initialised.
+ @Param aClientId ID of the client that is requesting resource registration
+ @Param aStaticResourceArray Static resources to register with RC.
+ @Param aResCount Number of static resources to register with RC. This equals the size of the passed array.
+ @return KErrNone, if operation is success
+ KErrAccessDenied if clientId could not be found in the current list of registered clients or if this
+ client was registered as thread relative and was not called from the same thread.
+ KErrNotSupported if called after resource controller is fully initialised or if called from user side proxy
+ or if the resource is dynamic or dependency resource.
+ KErrNoMemory if there is insufficient memory.
+ KErrArgument if passed array is null or passed number of resources count is 0.
+ */
+EXPORT_C TInt DPowerResourceController::RegisterArrayOfStaticResources(TUint aClientId, DStaticPowerResource**& aStaticResourceArray, TUint aResCount)
+ {
+ DThread& thread = Kern::CurrentThread();
+ __KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::RegisterStaticResource"));
+ DPowerResourceController* pRC = TInterface::GetPowerResourceController();
+ if(!pRC)
+ return KErrNotFound;
+
+ if(!aStaticResourceArray || (aResCount == 0))
+ return KErrArgument;
+ CHECK_CONTEXT(thread)
+ //Accept the registration of static resource only if issued before controller is fully initialised.
+ if(pRC->iInitialised == EResConStartupCompleted)
+ {
+ return KErrNotSupported;
+ }
+ //User side clients and resource with dependency are not supported.
+ if(aClientId & USER_SIDE_CLIENT_BIT_MASK)
+ {
+ return KErrNotSupported;
+ }
+#ifdef PRM_ENABLE_EXTENDED_VERSION
+ if(aResCount == 1)
+ {
+ if((((DStaticPowerResource*)aStaticResourceArray)->iResourceId & KIdMaskResourceWithDependencies) ||
+ (((DStaticPowerResource*)aStaticResourceArray)->iResourceId & KIdMaskDynamic))
+ {
+ return KErrNotSupported;
+ }
+ }
+ else
+ {
+ for(TUint rescount = 0; rescount < aResCount; rescount++)
+ {
+ if(aStaticResourceArray[rescount] && ((aStaticResourceArray[rescount]->iResourceId & KIdMaskResourceWithDependencies) ||
+ (aStaticResourceArray[rescount]->iResourceId & KIdMaskDynamic)))
+ {
+ return KErrNotSupported;
+ }
+ }
+ }
+#endif
+ SPowerResourceClient* pC = pRC->iClientList[(TUint16)(aClientId & ID_INDEX_BIT_MASK)];
+ if(!pC)
+ {
+ __KTRACE_OPT(KRESMANAGER, Kern::Printf("Client ID not Found"));
+ return KErrAccessDenied;
+ }
+ if(pC->iClientId != aClientId)
+ {
+ __KTRACE_OPT(KRESMANAGER, Kern::Printf("Client ID instance count does not match"));
+ return KErrAccessDenied;
+ }
+ if(pC->iClientId & CLIENT_THREAD_RELATIVE_BIT_MASK)
+ {
+ if(pC->iThreadId != thread.iId)
+ {
+ __KTRACE_OPT(KRESMANAGER, Kern::Printf("Client not called from thread context(Thread Relative)"));
+ return KErrAccessDenied;
+ }
+ }
+
+ TInt r = Kern::SafeReAlloc((TAny*&)pRC->iStaticResourceArray, pRC->iStaticResourceArrayEntries*sizeof(DStaticPowerResource*),
+ (pRC->iStaticResourceArrayEntries + aResCount)*sizeof(DStaticPowerResource*));
+ if(r != KErrNone)
+ {
+ return r;
+ }
+ if(aResCount == 1)
+ {
+ pRC->iStaticResourceArray[pRC->iStaticResourceArrayEntries++] = (DStaticPowerResource*)aStaticResourceArray;
+ if((DStaticPowerResource*)aStaticResourceArray)
+ pRC->iStaticResourceCount++;
+ }
+ else
+ {
+ for(TUint count = 0; count < aResCount; count++)
+ {
+ pRC->iStaticResourceArray[pRC->iStaticResourceArrayEntries++] = aStaticResourceArray[count];
+ if(aStaticResourceArray[count])
+ pRC->iStaticResourceCount++;
+ }
+ }
+ return KErrNone;
+ }
+
+/**
+ @publishedPartner
+ @prototype 9.5
+ Kernel extensions or variants can call this API to register the static resources before resource controller
+ is fully initialized.
+ @Param aClientId ID of the client that is requesting resource registration
+ @Param pR Static resource to register with RC.
+ @return KErrNone, if operation is success
+ KErrAccessDenied if clientId could not be found in the current list of registered clients or if this
+ client was registered as thread relative and was not called from the same thread.
+ KErrNotSupported if called after resource controller is fully initialized or if called from user side proxy
+ or if the resource is dynamic or dependency resource
+ KErrNoMemory if there is insufficient memory.
+ KErrArgument if passed array is null
+ */
+EXPORT_C TInt DPowerResourceController::RegisterStaticResource(TUint aClientId, DStaticPowerResource* pR)
+ {
+ return RegisterArrayOfStaticResources(aClientId, (DStaticPowerResource**&)pR, 1);
+ }
+
+/**
+ @publishedPartner
+ @prototype 9.5
+ This function initialises the controller.
+ @return KErrNone, if operation is success or one of the system wide errors.
+ */
+EXPORT_C TInt DPowerResourceController::InitController()
+ {
+ __KTRACE_OPT(KRESMANAGER, Kern::Printf(">DPowerResourceController::InitController()"));
+ DPowerResourceController* pRC = TInterface::GetPowerResourceController();
+ if(!pRC)
+ return KErrNotFound;
+ if(pRC->iInitialised >= EResConInitialised)
+ {
+ __KTRACE_OPT(KRESMANAGER, Kern::Printf("InitController already initialised %d\n", pRC->iInitialised));
+ return KErrNone;
+ }
+ _LIT(KResMutexName, "RESCTRL");
+ TInt r=KErrNone;
+ //Create the message queue
+ pRC->iMsgQ = new TMessageQue(DPowerResourceController::MsgQFunc, pRC, NULL, 2);
+ if(!pRC->iMsgQ)
+ return KErrNoMemory;
+#ifdef PRM_ENABLE_EXTENDED_VERSION
+ //Create the message queue for dependency resource processing.
+ pRC->iMsgQDependency = new TMessageQue(DPowerResourceController::MsgQDependencyFunc, pRC, NULL, 1);
+ if(!pRC->iMsgQDependency)
+ return KErrNoMemory;
+#endif
+ // Call PSL to create all static resources and populate the iStaticResourceArray with pointers to resources and
+ // update static resource count
+ r=pRC->DoRegisterStaticResources(pRC->iStaticResourceArray, pRC->iStaticResourceArrayEntries);
+ if(r!=KErrNone)
+ return r;
+ //Get the actual number of static resource registered count
+ for(TInt resCnt = 0; resCnt < pRC->iStaticResourceArrayEntries; resCnt++)
+ {
+ if(pRC->iStaticResourceArray[resCnt])
+ pRC->iStaticResourceCount++;
+ }
+ __KTRACE_OPT(KRESMANAGER, Kern::Printf("Actual number of static resource registered = %d\n", pRC->iStaticResourceCount));
+#ifdef PRM_INSTRUMENTATION_MACRO
+ // Btrace output of resource information of each resource.
+ DStaticPowerResource* pR = NULL;
+ TPowerResourceInfoBuf01 resInfo;
+ TPowerResourceInfoV01 *pResInfo;
+ for(TInt resCount = 0; resCount < pRC->iStaticResourceArrayEntries; resCount++)
+ {
+ pR = pRC->iStaticResourceArray[resCount];
+ if(!pR)
+ continue;
+ pR->GetInfo((TDes8*)resInfo.Ptr());
+ pResInfo = (TPowerResourceInfoV01*)resInfo.Ptr();
+ PRM_REGISTER_RESOURCE_TRACE
+ }
+#endif
+
+#ifdef PRM_ENABLE_EXTENDED_VERSION
+ //Call PSL to register static resources with dependency if any exists
+ r = pRC->DoRegisterStaticResourcesDependency(pRC->iStaticResDependencyArray, pRC->iStaticResDependencyCount);
+ if(r != KErrNone)
+ return r;
+ if(pRC->iStaticResDependencyCount)
+ {
+ DStaticPowerResourceD* pRD = NULL;
+ TUint count;
+ //Assign resource index in resource id
+ for(count = 0; count < pRC->iStaticResDependencyCount; count++)
+ {
+ pRD = pRC->iStaticResDependencyArray[count];
+ if(!pRD)
+ Panic(DPowerResourceController::ERegisteringDependentStaticResourceWithHoles);
+ pRD->iResourceId |= ((count + 1) & ID_INDEX_BIT_MASK);
+ }
+ //Check for dependency closed loops
+ for(count = 0; count < pRC->iStaticResDependencyCount; count++)
+ {
+ pRD = pRC->iStaticResDependencyArray[count];
+ if(!(pRD->iResourceId & KIdMaskStaticWithDependencies))
+ Panic(DPowerResourceController::ERegisteringNonDependentStaticResource);
+ //Upgrade latency state change from instantaneous to long latency
+ if(!pRD->LatencySet())
+ pRD->iFlags |= KLongLatencySet;
+ pRC->CheckForDependencyLoop(pRD, pRD->iResourceId, pRD->iResourceId);
+ }
+#ifdef PRM_INSTRUMENTATION_MACRO
+ for(count = 0; count < pRC->iStaticResDependencyCount; count++)
+ {
+ pR = pRC->iStaticResDependencyArray[count];
+ pR->GetInfo((TDes8*)resInfo.Ptr());
+ pResInfo = (TPowerResourceInfoV01*)resInfo.Ptr();
+ PRM_REGISTER_STATIC_RESOURCE_WITH_DEPENDENCY_TRACE
+ }
+#endif
+ }
+#endif // PRM_ENABLE_EXTENDED_VERSION
+ // Create mutex object
+ r=Kern::MutexCreate(pRC->iResourceMutex, KResMutexName, KMutexOrdResourceManager);
+ if(r==KErrNone) // Call PSL to create DFC queue and creation of pools with the help API's provided by generic layer.
+ r=pRC->DoInitController();
+ __KTRACE_OPT(KRESMANAGER, Kern::Printf("<DPowerResourceController::InitController()"));
+ if(r == KErrNone)
+ {
+ pRC->iInitialised = EResConInitialised;
+ if(pRC->iDfcQ)
+ pRC->iMsgQ->Receive();
+#ifdef PRM_ENABLE_EXTENDED_VERSION
+ if(pRC->iDfcQDependency)
+ pRC->iMsgQDependency->Receive();
+#endif
+ }
+ return r;
+ }