FCL/sf/os/kernelhwsrv: comparison kernel/eka/kernel/power.cpp

equal deleted inserted replaced

-:957c583b417b
+:2bfb1feef9de
 #include <kernel/kpower.h>
 #include <kernel/kern_priv.h>
 #include "execs.h"
 #include "msgqueue.h"
-// #define _DEBUG_POWER
+#ifdef _DEBUG
+#include <nkern/nk_trace.h>
+//#define _DEBUG_POWER
+#endif
 /******************************************************************************
 * Power Manager - a Power Model implementation
 ******************************************************************************/
 #ifndef __X86__
 	DPowerController*	iPowerController;
 	DBatteryMonitor*	iBatteryMonitor;
 	DPowerHal*			iPowerHal;
-	TInt				iTotalCurrent;
+	TUint iPslShutdownTimeoutMs; // default = 0
 private:
+#ifndef _DEBUG_POWER
+	enum
+		{
+		ESHUTDOWN_TIMEOUT = 0xFFFFFFFF // -1
+		};
+	TInt iPendingShutdownCount;
+#endif
 	DPowerManager();
 	// Acquire the feature lock
 	// Called in CS
 		// used in assertions only
 //		{ return iFeatureLock->iCleanup.iThread == TheCurrentThread; }
 // #endif
 	void NotifyWakeupEvent(TInt aReason);
+	static void ShutDownTimeoutFn(TAny* aArg);
 	DMutex*			iFeatureLock;
 	DThread*		iClient;				// protected by the system lock
 	TClientRequest*	iRequest;				// protected by the system lock
 	DPowerHandler*	iHandlers;				// protected by the feature lock
 	if (r != KErrNone)
 		return NULL; // Do not cleanup since kernel will panic eventually
 	return self;
 	}
 DPowerManager::DPowerManager()
 	{
 	}
 void DPowerManager::CpuIdle()
 	{ // from DPowerModel
 	NKern::ThreadEnterCS();
 	NotifyWakeupEvent(KErrCancel);
 	NKern::ThreadLeaveCS();
 	}
-// Called in CS
+void DPowerManager::ShutDownTimeoutFn(TAny* aArg)
+	{
+	__KTRACE_OPT(KPOWER,Kern::Printf(">DPowerManager::ShutDownTimeoutFn"));
+	NFastSemaphore* sem = (NFastSemaphore*)aArg;
+#ifdef _DEBUG_POWER
+	NKern::FSSignal(sem);
+#else
+	TUint SignalCount = __e32_atomic_load_acq32(&(PowerManager->iPendingShutdownCount));
+	DPowerHandler* ph = PowerManager->iHandlers;
+	do
+		{
+		ph->iSem = NULL;
+		ph = ph->iPrev;
+		}while(ph != PowerManager->iHandlers);
+	__e32_atomic_store_rel32(&(PowerManager->iPendingShutdownCount), (TUint)ESHUTDOWN_TIMEOUT); // = -1
+	NKern::FSSignalN(sem,SignalCount);
+	__KTRACE_OPT(KPOWER,Kern::Printf("<DPowerManager::ShutDownTimeoutFn"));
+#endif
+	}
 TInt DPowerManager::PowerDown()
 	{ // called by ExecHandler
 	__KTRACE_OPT(KPOWER,Kern::Printf(">PowerManger::PowerDown(0x%x) Enter", iPowerController->iTargetState));
 	__ASSERT_CRITICAL;
 		Unlock();
 		return KErrNotReady;
 		}
 __PM_ASSERT(iHandlers);
-	NFastSemaphore sem(0);
+	NFastSemaphore shutdownSem(0);
+	NTimer ntimer;
+	TDfc dfc(ShutDownTimeoutFn, &shutdownSem);
+#ifndef _DEBUG_POWER
+	iPendingShutdownCount = 0;
+#endif
 	DPowerHandler* ph = iHandlers;
 	//Power down in reverse order of handle registration.
 	do
 		{
 #ifdef _DEBUG_POWER
 		__PM_ASSERT(!(ph->iStatus & DPowerHandler::EDone));
 #endif
-		ph->iSem = &sem;
+		ph->iSem = &shutdownSem;
 		ph->PowerDown(iPowerController->iTargetState);
-#ifdef _DEBUG_POWER
+#ifndef _DEBUG_POWER
-		__PM_ASSERT(!(ph->iStatus & DPowerHandler::EDone));
+		iPendingShutdownCount++;
-		NKern::FSWait(&sem);	// power down drivers one after another to simplify debug
+#else
-		__PM_ASSERT(!ph->iSem);
+		if(iPslShutdownTimeoutMs>0)
-		__PM_ASSERT(ph->iStatus & EDone);
+			{
-		ph->iStatus &= ~EDone;
+		    // Fire shut down timeout timer
-#endif
+			ntimer.OneShot(iPslShutdownTimeoutMs, dfc);
+			}
+		NKern::FSWait(&shutdownSem);	// power down drivers one after another to simplify debug
+		__e32_atomic_and_ord32(&(ph->iStatus), ~DPowerHandler::EDone);
+		// timeout condition
+		if(iPslShutdownTimeoutMs>0 && ph->iSem)
+			{
+			__e32_atomic_store_ord_ptr(&ph->iSem, 0);
+			}
+		ntimer.Cancel();
+#endif
 		ph = ph->iPrev;
 		}while(ph != iHandlers);
 #ifndef _DEBUG_POWER
+	if(iPslShutdownTimeoutMs>0)
+		{
+		// Fire shut down timeout timer
+		ntimer.OneShot(iPslShutdownTimeoutMs, dfc);
+		}
 	ph = iHandlers;
 	do
 		{
-		NKern::FSWait(&sem);
+		NKern::FSWait(&shutdownSem);
+		if(__e32_atomic_load_acq32(&iPendingShutdownCount)==ESHUTDOWN_TIMEOUT)
+			{
+			iPendingShutdownCount = 0;
+			NKern::Lock();
+			shutdownSem.Reset(); // iPendingShutdownCount could be altered while ShutDownTimeoutFn is running
+		       			     // reset it to make sure shutdownSem is completely clean.
+			NKern::Unlock();
+			break;
+			}
+		__e32_atomic_add_ord32(&iPendingShutdownCount, (TUint)(~0x0)); // iPendingShutDownCount--;
 		ph = ph->iPrev;
 		}while(ph != iHandlers);
+	ntimer.Cancel();
 #endif
 	TTickQ::Wait();
 	iPowerController->PowerDown(K::SecondQ->WakeupTime());
 	iPowerController->iTargetState = EPwActive;
 	K::SecondQ->WakeUp();
 	TTickQ::Signal();
+	NFastSemaphore powerupSem(0);
 	ph = iHandlers->iNext;
 	//Power up in same order of handle registration.
 	do
 		{
 #ifdef _DEBUG_POWER
 		__PM_ASSERT(!(ph->iStatus & DPowerHandler::EDone));
 #endif
-		ph->iSem = &sem;
+		ph->iSem = &powerupSem;
 		ph->PowerUp();
 #ifdef _DEBUG_POWER
-		__PM_ASSERT(!(ph->iStatus & DPowerHandler::EDone));
+		NKern::FSWait(&powerupSem);	// power down drivers one after another to simplify debug
-		NKern::FSWait(&sem);	// power down drivers one after another to simplify debug
 		__PM_ASSERT(!ph->iSem);
-		__PM_ASSERT(ph->iStatus & EDone);
+		__PM_ASSERT(ph->iStatus & DPowerHandler::EDone);
-		ph->iStatus &= ~EDone;
+		ph->iStatus &= ~DPowerHandler::EDone;
 #endif
 		ph = ph->iNext;
 		}while(ph != iHandlers->iNext);
 #ifndef _DEBUG_POWER
 	ph = iHandlers->iNext;
 	do
 		{
-		NKern::FSWait(&sem);
+		NKern::FSWait(&powerupSem);
 		ph = ph->iNext;
 		}while(ph != iHandlers->iNext);
 #endif
 	// complete wakeup notification request if any
 	__KTRACE_OPT(KPOWER,Kern::Printf("<PowerManger::PowerDown() Leave"));
 	return KErrNone;
 	}
 /******************************************************************************
 * Power Handlers
 ******************************************************************************/
 	}
 /**	@deprecated, no replacement	*/
-EXPORT_C void DPowerHandler::DeltaCurrentConsumption(TInt aDelta)
+EXPORT_C void DPowerHandler::DeltaCurrentConsumption(TInt /* aDelta */)
 	{
-	__e32_atomic_add_ord32(&iCurrent, aDelta);
-	__PM_ASSERT(iCurrent >= 0);
-	__e32_atomic_add_ord32(&PowerManager->iTotalCurrent, aDelta);
-	__PM_ASSERT(PowerManager->iTotalCurrent >= 0);
 	}
 /**	@deprecated, no replacement	*/
-EXPORT_C void DPowerHandler::SetCurrentConsumption(TInt aCurrent)
+EXPORT_C void DPowerHandler::SetCurrentConsumption(TInt /* aCurrent */)
 	{
-	__PM_ASSERT(aCurrent >= 0);
-	TInt old = (TInt)__e32_atomic_swp_ord32(&iCurrent, aCurrent);
-	TInt delta = aCurrent - old;
-	__e32_atomic_add_ord32(&PowerManager->iTotalCurrent, delta);
-	__PM_ASSERT(PowerManager->iTotalCurrent >= 0);
 	}
 /******************************************************************************
 * Power Controller
 ******************************************************************************/
 	PowerManager->iPowerController = this;
 #ifndef __X86__
 	TPowerController::ThePowerController = this;
 #endif
 	K::PowerModel = PowerManager;
+	}
+/**
+Registers this power controller object with the power manager.
+The power manager can only use the power controller after registration.
+@param aShutdownTimeoutMs The kernel shut down time out value in msec.
+@pre Calling thread must be in a critical section.
+@pre No fast mutex can be held.
+@pre Call in a thread context.
+@pre Kernel must be unlocked
+@pre interrupts enabled
+*/
+EXPORT_C void DPowerController::Register(TUint aShutdownTimeoutMs)
+	{
+	PowerManager->iPslShutdownTimeoutMs = aShutdownTimeoutMs;
+	Register();
 	}
 #ifndef __X86__
 /**
 Registers resource controller with power controller

changeset 280	2bfb1feef9de
parent 244	a77889bee936
child 286	48e57fb1237e