// Copyright (c) 1998-2010 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"

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

 * 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;

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;

	}

	{

	}

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('%S')", &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('%S')", &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();

	}

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

	DPowerHandler* ph = iHandlers;

	//Power down in reverse order of handle registration.

	do

		{

#ifdef _DEBUG_POWER

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

#endif

		ph->PowerDown(iPowerController->iTargetState);

		ph = ph->iPrev;

		}while(ph != iHandlers);

#ifndef _DEBUG_POWER

	ph = iHandlers;

	do

		{

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

#ifdef _DEBUG_POWER

		__PM_ASSERT(!ph->iSem);

#endif

		ph = ph->iNext;

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

#ifndef _DEBUG_POWER

	ph = iHandlers->iNext;

	do

		{

		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");

	}