// Copyright (c) 1998-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\kernel\power.cpp

// Generic power management

// 

//

#include <kernel/kpower.h>

#include <kernel/kern_priv.h>

#include "execs.h"

#include "msgqueue.h"

// #define _DEBUG_POWER

/******************************************************************************

 * Power Manager - a Power Model implementation

 ******************************************************************************/

#ifndef __X86__

DPowerController* TPowerController::ThePowerController = 0;

#endif

class DPowerManager : public DPowerModel

	{

public:

	// from DPowerModel

	void CpuIdle();

	void RegisterUserActivity(const TRawEvent& anEvent);

	TInt PowerHalFunction(TInt aFunction, TAny* a1, TAny* a2);

	void AbsoluteTimerExpired();

	void SystemTimeChanged(TInt anOldTime, TInt aNewTime);

	TSupplyStatus MachinePowerStatus();

public:

	static DPowerManager* New();

	TInt EnableWakeupEvents(TPowerState);

	void DisableWakeupEvents();

	void RequestWakeupEventNotification(TRequestStatus*);

	void CancelWakeupEventNotification();

	TInt PowerDown();

	void AppendHandler(DPowerHandler*);

	void RemoveHandler(DPowerHandler*);

	void WakeupEvent();

	DPowerController*	iPowerController;

	DBatteryMonitor*	iBatteryMonitor;

	DPowerHal*			iPowerHal;

	TInt				iTotalCurrent;

private:

	DPowerManager();

	// Acquire the feature lock

	// Called in CS

	void Lock()

		{

		Kern::MutexWait(*iFeatureLock);

		}

	// Release the feature lock

	// Called in CS

	void Unlock()

		{

		Kern::MutexSignal(*iFeatureLock);

		}

//

// Currently not used

//

// #ifdef _DEBUG

//	TBool IsLocked()

		// used in assertions only

//		{ return iFeatureLock->iCleanup.iThread == TheCurrentThread; }

// #endif

	void NotifyWakeupEvent(TInt aReason);

	DMutex*			iFeatureLock;

	DThread*		iClient;				// protected by the system lock

	TClientRequest*	iRequest;				// protected by the system lock

	DPowerHandler*	iHandlers;				// protected by the feature lock

	};

static DPowerManager* PowerManager;

class DummyPowerController : public DPowerController

	// Used when the plaform doesn't support power management

	{	 

public: // from DPowerController

	void CpuIdle() {} 

	void EnableWakeupEvents() { WakeupEvent(); }

	void DisableWakeupEvents() {}

	void AbsoluteTimerExpired() {}

	void PowerDown(TTimeK /* aWakeupTime */) { if (iTargetState == EPwOff) __PM_PANIC("Can't power off"); }

	};

TInt PowerModelInit()

	{

#ifdef _DEBUG_POWER

	TInt maskIndex = KPOWER / 32;

	TUint32 bitMask = 1 << (KPOWER % 32);

	TheSuperPage().iDebugMask[maskIndex] |= bitMask;

#endif

	__KTRACE_OPT2(KBOOT,KPOWER,Kern::Printf("PowerModelInit()"));

	DPowerManager* pm = DPowerManager::New();

	if (!pm)

		return KErrNoMemory;

	PowerManager = pm;

	return KErrNone;

	}

_LIT(KPowerMgrMutexName, "PwrMgrLock");

DPowerManager* DPowerManager::New()

	{

	DPowerManager* self = new DPowerManager();

	if (!self)

		return NULL;

	if (Kern::MutexCreate(self->iFeatureLock, KPowerMgrMutexName, KMutexOrdPowerMgr) != KErrNone)

		return NULL; // Do not cleanup since kernel will panic eventually

	self->iPowerController = new DummyPowerController();

	if (self->iPowerController == NULL)

		return NULL; // Do not cleanup since kernel will panic eventually

	TInt r = Kern::CreateClientRequest(self->iRequest);

	if (r != KErrNone)

		return NULL; // Do not cleanup since kernel will panic eventually

	return self;

	}

DPowerManager::DPowerManager() 

	{

	}

void DPowerManager::CpuIdle()

	{ // from DPowerModel

	__PM_ASSERT(iPowerController);

	iPowerController->CpuIdle();

	}

void DPowerManager::RegisterUserActivity(const TRawEvent&)

	{ // from DPowerModel

	}	

void DPowerManager::SystemTimeChanged(TInt aOldTime, TInt aNewTime)

	{ // from DPowerModel

	if (iBatteryMonitor)

		iBatteryMonitor->SystemTimeChanged(aOldTime, aNewTime);

	}

TSupplyStatus DPowerManager::MachinePowerStatus()

	{ // from DPowerModel

	TSupplyStatus s;

	if (iBatteryMonitor)

		s = iBatteryMonitor->MachinePowerStatus();

	else

		s = EGood;

	return s;

	}

TInt DPowerManager::PowerHalFunction(TInt aFunction, TAny* a1, TAny* a2)

	{ // from DPowerModel

	__KTRACE_OPT(KPOWER,Kern::Printf(">DPowerManager::PowerHalFunction() func=0x%x, a1=0x%x, a2=0x%x", aFunction, a1, a2));

	TInt r;

	if (iPowerHal)

		r = iPowerHal->PowerHalFunction(aFunction, a1, a2);

	else

		r = KErrNotSupported;

	__KTRACE_OPT(KPOWER,Kern::Printf("<DPowerManager::PowerHalFunction() return 0x%x", r));

	return r;

	}

void DPowerManager::AbsoluteTimerExpired()

	{ // from DPowerModel  

	if (iPowerController->iTargetState != EPwActive)

		iPowerController->AbsoluteTimerExpired();

	}

// Called in CS

void DPowerManager::AppendHandler(DPowerHandler* aPh)

	{ // called by drivers (power handler)

	__KTRACE_OPT(KPOWER,Kern::Printf("PowerManger::AppendHandler('%lS')", &aPh->iName));

	__ASSERT_CRITICAL;

	//Check to ensure that handler is not added multiple times and not part of any other list

	__PM_ASSERT(!(aPh->iPrev) && !(aPh->iNext));

	Lock();

	//Create circular doubly linked power handler list

	if(iHandlers == NULL)

		{ //Empty list, create first entry

		iHandlers = aPh;

		aPh->iNext = iHandlers;

		aPh->iPrev = iHandlers;

		}

	else

		{ //Append to end of the list.

		aPh->iNext = iHandlers->iNext;

		iHandlers->iNext->iPrev = aPh;

		aPh->iPrev = iHandlers;

		iHandlers->iNext = aPh;

		iHandlers = aPh;

		}

	Unlock();

	}	

// Called in CS

void DPowerManager::RemoveHandler(DPowerHandler* aPh)

	{ // called by drivers (power handler)

	__KTRACE_OPT(KPOWER,Kern::Printf("PowerManger::RemoveHandler('%lS')", &aPh->iName));

	__ASSERT_CRITICAL;

	Lock();

	__PM_ASSERT(aPh);

	if ((iHandlers == NULL) //If the list is empty

		|| (aPh->iNext == NULL || aPh->iPrev == NULL)) //or entry already removed then return immediately

		{

		aPh->iPrev = aPh->iNext = NULL;

		Unlock();

		return;

		}

	DPowerHandler *temp = aPh->iPrev;

	if(aPh == temp) //Only one node in the list.

		iHandlers = NULL;

	else

		{ //Remove the entry from list

		temp->iNext = aPh->iNext;

		temp = aPh->iNext;

		temp->iPrev = aPh->iPrev;

		if(aPh == iHandlers) //If the node is the last node in the list then make iHandler point to last one.

			iHandlers = aPh->iPrev;

		}

	//Make next and prev pointers to NULL

	aPh->iPrev = aPh->iNext = NULL;

	Unlock();

	}	

void DPowerManager::WakeupEvent()

	{ // called by power controller  

	__KTRACE_OPT(KPOWER,Kern::Printf("PowerManger::WakeupEvent()"));

	if (iPowerController->iTargetState != EPwActive)

		{

		NKern::ThreadEnterCS();

		NotifyWakeupEvent(KErrNone);

		NKern::ThreadLeaveCS();

		}

	}

TInt DPowerManager::EnableWakeupEvents(TPowerState aState)

	{ // called by ExecHandler

	__KTRACE_OPT(KPOWER,Kern::Printf("PowerManger::EnableWakeupEvents(0x%x)", aState));

	if ((aState < 0) || (EPwLimit <= aState)) 

		return KErrArgument;

	if (aState == EPwActive)

		return KErrArgument;

	Lock();

	if (iPowerController->iTargetState != EPwActive)

		iPowerController->DisableWakeupEvents();

	iPowerController->iTargetState = aState;

	iPowerController->EnableWakeupEvents();

	Unlock();

	return KErrNone;

	}	

void DPowerManager::DisableWakeupEvents()

	{ // called by ExecHandler

	__KTRACE_OPT(KPOWER,Kern::Printf("PowerManger::DisableWakeupEvents()"));

	Lock();

	if (iPowerController->iTargetState != EPwActive)

		{

		iPowerController->iTargetState = EPwActive;

		iPowerController->DisableWakeupEvents();

		}

	Unlock();

	}	

void DPowerManager::RequestWakeupEventNotification(TRequestStatus* aStatus)

	{ // called by ExecHandler

	__KTRACE_OPT(KPOWER,Kern::Printf("PowerManger::RequestWakeupEventNotification()"));

	Lock();		// we aquire this lock to avoid new requests while in PowerDown

	NKern::LockSystem();

	if (iClient || iRequest->SetStatus(aStatus) != KErrNone)

		Kern::RequestComplete(aStatus, KErrInUse);

	else

		{

		iClient = TheCurrentThread;

		iClient->Open();

		}

	NKern::UnlockSystem();

	Unlock();

	__KTRACE_OPT(KPOWER,Kern::Printf("<PowerManger::RequestWakeupEventNotification()"));

	}	

void DPowerManager::NotifyWakeupEvent(TInt aReason)

	{ // private

	NKern::LockSystem();

	DThread* client = iClient;

	if (!client)

		{

		NKern::UnlockSystem();

		return;

		}

	iClient = NULL;

	Kern::QueueRequestComplete(client, iRequest, aReason);

	NKern::UnlockSystem();

	client->Close(NULL);

	}

void DPowerManager::CancelWakeupEventNotification()

	{ // called by ExecHandler

	__KTRACE_OPT(KPOWER,Kern::Printf("PowerManger::CancelWakeupEventNotification()"));

	NKern::ThreadEnterCS();

	NotifyWakeupEvent(KErrCancel);

	NKern::ThreadLeaveCS();

	}

// Called in CS

TInt DPowerManager::PowerDown()

	{ // called by ExecHandler 

	__KTRACE_OPT(KPOWER,Kern::Printf(">PowerManger::PowerDown(0x%x) Enter", iPowerController->iTargetState));

	__ASSERT_CRITICAL;

	Lock();

	if (iPowerController->iTargetState == EPwActive)

		{

		Unlock();

		return KErrNotReady;

		}

    __PM_ASSERT(iHandlers);

	NFastSemaphore sem(0);

	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->PowerDown(iPowerController->iTargetState);

#ifdef _DEBUG_POWER

		__PM_ASSERT(!(ph->iStatus & DPowerHandler::EDone));

		NKern::FSWait(&sem);	// power down drivers one after another to simplify debug

		__PM_ASSERT(!ph->iSem);

		__PM_ASSERT(ph->iStatus & EDone);

		ph->iStatus &= ~EDone;

#endif

		ph = ph->iPrev;

		}while(ph != iHandlers);

#ifndef _DEBUG_POWER

	ph = iHandlers;

	do

		{

		NKern::FSWait(&sem);

		ph = ph->iPrev;

		}while(ph != iHandlers);

#endif

	TTickQ::Wait();

	iPowerController->PowerDown(K::SecondQ->WakeupTime());

	__PM_ASSERT(iPowerController->iTargetState != EPwOff);

	iPowerController->iTargetState = EPwActive;

	K::SecondQ->WakeUp();

	TTickQ::Signal();

	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->PowerUp();

#ifdef _DEBUG_POWER

		__PM_ASSERT(!(ph->iStatus & DPowerHandler::EDone));

		NKern::FSWait(&sem);	// power down drivers one after another to simplify debug

		__PM_ASSERT(!ph->iSem);

		__PM_ASSERT(ph->iStatus & EDone);

		ph->iStatus &= ~EDone;

#endif

		ph = ph->iNext;

		}while(ph != iHandlers->iNext);

#ifndef _DEBUG_POWER

	ph = iHandlers->iNext;

	do

		{

		NKern::FSWait(&sem);

		ph = ph->iNext;

		}while(ph != iHandlers->iNext);

#endif

	// complete wakeup notification request if any

	NotifyWakeupEvent(KErrNone); 

	Unlock();

	__KTRACE_OPT(KPOWER,Kern::Printf("<PowerManger::PowerDown() Leave"));

	return KErrNone;

	}	

/******************************************************************************

 * Power Handlers

 ******************************************************************************/

/**

Constructor.

@param aName The power handler's debug-purpose symbolic name.

@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 DPowerHandler::DPowerHandler(const TDesC& aName) : iName(aName)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"DPowerHandler::DPowerHandler");

	}

/**

Destructor.

@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 DPowerHandler::~DPowerHandler()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"DPowerHandler::~DPowerHandler");

	SetCurrentConsumption(0);

	}

/**

Registers the power handler with the power manager.

After registration, the power manager notifies the device driver about

power state transitions by calling PowerDown() & PowerUp() in this power

handler's interface.

Note that the implementation of Add() acquires an internal lock (a DMutex),

which is also held when the power manager calls PowerDown() and PowerUp(). 

This means that the device driver cannot hold a lock over Add() calls if

the same lock is acquired by PowerDown() and PowerUp() implementations.

You can find an example of synchronization between outgoing Add()

and incoming PowerDown() & PowerUp() in e32/drivers/ecomm/d_comm.cpp.

@see DPowerHandler::Remove()

@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 DPowerHandler::Add()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"DPowerHandler::Add");

	PowerManager->AppendHandler(this);

	}

/**

De-registers the power handler.

After the call to this function completes, the power manager stops notifying

the device driver about kernel power state transitions.

Note that the implementation of Remove() acquires an internal lock (a DMutex),

which is also held when the power manager calls PowerDown() and PowerUp(). 

This means that the device driver cannot hold a lock over Remove() calls if

the same lock is acquired by PowerDown() and PowerUp() implementations.

You can find an example of synchronization between outgoing Remove()

and incoming PowerDown() & PowerUp() in e32/drivers/ecomm/d_comm.cpp.

@see DPowerHandler::Add()

@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 DPowerHandler::Remove()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"DPowerHandler::Remove");

	PowerManager->RemoveHandler(this);

	}

void DPowerHandler::Done()

	{ // private

#ifdef _DEBUG_POWER

	__PM_ASSERT(!(iStatus & EDone));