// Copyright (c) 1994-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:

// template\template_variant\specific\power.cpp

// Template Power Management

// (see also variant.cpp for a discussion on Sleep modes and xyin.cpp for example

// of usage of Resource Manager and Peripheral self power down and interaction

// with Power Controller for Wakeup Events)

// 

//

#include "template_power.h"

static TemplateResourceManager TheResourceManager;

DTemplatePowerController* TTemplatePowerController::iPowerController;

//-/-/-/-/-/-/-/-/-/ class DTemplatePowerController /-/-/-/-/-/-/-/-/-/

DTemplatePowerController::DTemplatePowerController()

	{

	Register();			// register Power Controller with Power Manager

	TTemplatePowerController::RegisterPowerController(this);

	}

void DTemplatePowerController::CpuIdle()

	{

	Arch::TheAsic()->Idle();

	}

void DTemplatePowerController::EnableWakeupEvents()

	{

	//

	// TO DO: (mandatory)

	//

	// Enable tracking of wake-up events directly in hardware. If the hardware is controlled by a Driver

	// or Extension, may need to disable interrupts and preemption around the code that accesses the hardware

	// and set up a flag which the Driver/Extension code need to read before modifying the state of that piece

	// of hardware. Note in that case the Driver/Extension may need to link to this Library.

	//

	//

	// EXAMPLE ONLY

	// In this example we simply assume that the driver will call the Power Controller every time a 

	// wakeup event occurr. It is up to the Power Controller to know if it is tracking them or not.

	// We also assume that if a wakeup event occurrs when the CPU is in Standby, this will automatically

	// bring it back from that state.

	iWakeupEventsOn = ETrue;	// start tracking wakeup events

	}

void DTemplatePowerController::DisableWakeupEvents()

	{

	//

	// TO DO: (mandatory)

	//

	// Disable tracking of wake-up events directly in hardware or if the hardware is controlled by a Driver or

	// Extension need to set up a flag which the Driver/Extension reads whenever the event occurs, in order to

	// find out if it needs to deliver notification to the Power Controller

	//

	iWakeupEventsOn = EFalse;	// stop tracking wakeup events

	}

void DTemplatePowerController::AbsoluteTimerExpired()

	{

	if (iTargetState == EPwStandby && iWakeupEventsOn)

		{

		iWakeupEventsOn = EFalse;		// one occurred, no longer track wakeup events

		WakeupEvent();

		}

	}

void DTemplatePowerController::PowerDown(TTimeK aWakeupST)	

	{

	if (iTargetState == EPwStandby)

		{

		//

		// TO DO: (mandatory)

		//

		// Converts between the Wakeup time in System Time units as passed in to this function and a Wakeup

		// time in RTC units. The following code is given as an example how to convert between System time units

		// RTC time units on a system with a 32 bit RTC timer and which is incremented on a second interval:

		//

		TUint32 wakeupRTC;

		if (aWakeupST)

			{

			TUint32 nowRTC = TTemplate::RtcData();

			TTimeK nowST = Kern::SystemTime();

			__KTRACE_OPT(KPOWER,Kern::Printf("system time: now = 0x%lx(us) wakeup = 0x%lx(us)", nowST, aWakeupST));

			if (aWakeupST < nowST)

				return;

			Int64 deltaSecs = (aWakeupST - nowST) / 1000000;

			if (deltaSecs <= 0)

				return;

			if (deltaSecs + (Int64)nowRTC > (Int64)(KMaxTInt - 2))

				wakeupRTC = (KMaxTInt - 2); // RTC can't wrap around during standby

			else

				wakeupRTC = nowRTC + deltaSecs;

			__KTRACE_OPT(KPOWER,Kern::Printf("RTC: now = %d(s) wakeup = %d(s)", nowRTC, wakeupRTC));

			}

		else

			wakeupRTC = 0;

		//

		// TO DO: (optional)

		//

		// It then uses the calculated value to program the RTC to wakeup the System at the Wakeup

		// time ans sets the CPU and remaining hardware to go to the correponding low power mode. When the 

		// state of the Core and Core Peripherals is not preserved in this mode the following is usually 

		// required:

		//	- save current Core state (current Mode, banked registers for each Mode and Stack Pointer for 

		//	  both current and User Modes

		//	- save MMU state: Control Register, TTB and Domain Access Control

		//	- Flush Dta Cache and drain Write Buffer

		//	- save Core Peripherals state: Interrupt Controller, Pin Function, Bus State and Clock settings

		// SDRAM should be put in self refresh mode. Peripheral devices involved in detection of Wakeup events

		// should be left powered.

		// The Tick timer should be disabled and the current count of this and other System timers shall be

		// saved.

		// On wakeing up the state should be restored from the save state as above. SDRAM shall be brought back

		// under CPU control, The Tick count shall be restored and timers re-enabled.

		// We assume that if a wakeup event occurrs when the CPU is in Standby, this will automatically

		// bring it back from that state. Therefore we stop tracking wakeup events as the Power Manager will

		// complete any pending notifications anyway. When the driver delivers its notification, we just ignore

		// it.

		iWakeupEventsOn = EFalse;		// tracking of wakeup events is now done in hardware

		}

	else

		{

		Kern::Restart(0x80000000);

		}

	}

//-/-/-/-/-/-/-/-/-/ class TTemplatePowerController /-/-/-/-/-/-/-/-/-/

EXPORT_C TemplateResourceManager* TTemplatePowerController::ResourceManager()

	{

	return &TheResourceManager;

	}

EXPORT_C void TTemplatePowerController::WakeupEvent()

	{

	if(!iPowerController)

		__PM_PANIC("Power Controller not present");

	else if(iPowerController->iWakeupEventsOn)

		{

		iPowerController->iWakeupEventsOn=EFalse;		// one occurred, no longer track wakeup events

		iPowerController->WakeupEvent();

		}

	}

//-/-/-/-/-/-/-/-/-/ class TemplateResourceManager /-/-/-/-/-/-/-/-/-/

void TemplateResourceManager::InitResources()

	{

	//

	// TO DO: (optional)

	//

	// Initialise any power resources required by the platform and not initialised in the Bootstrap

	//

	}

//-/-/-/-/-/-/-/-/-/ interface for shared resources /-/-/-/-/-/-/-/-/-/

void SharedBinaryResource1::Use()

	{

	NKern::Lock();		// lock Kernel as shared resource is likely to be modified from different threads

	if (iCount++ == 0)

		{

		//

		// TO DO: (optional)

		//

		// Modify hardware register bit or bits to switch the resource On. If the resource

		// can be accessed from an ISR need to disable/enable interrupts around it.

		//

		NKern::Unlock();

		//

		// TO DO: (optional)

		//

		// If the resource is asynchronous may need to sleep or block the thread until the change is complete

		//

		}

	else

		NKern::Unlock();

	}

void SharedBinaryResource1::Release()

	{

	NKern::Lock();

	__PM_ASSERT(iCount);

	if (--iCount == 0)

		{

		//

		// TO DO: (optional)

		//

		// Modify hardware register bit or bits to switch the resource Off. If the resource

		// can be accessed from an ISR need to disable/enable interrupts around it.

		//

		NKern::Unlock();

		//

		// TO DO: (optional)

		//

		// If the resource is asynchronous may need to sleep or block the thread until the change is complete

		//

		}

	else

		NKern::Unlock();

	}

TUint SharedBinaryResource1::GetCount()

	{

	return iCount;

	}

SharedMultilevelResource1::SharedMultilevelResource1()

	//

	// TO DO: (optional)

	//

	// May need to initialise current level and the Id of its owner if these have been initialised in the Bootstrap

	//

	// : iCurrentLevel(/* a level for this resource as initialised in the Bootstrap */),

	//	 iCurrentLevelOwnerId(/* the Id of the requester of this resource that requires the initial value */)

	{

	}

void SharedMultilevelResource1::IncreaseToLevel(TUint aLevel, TInt aRequester)

	{

	//

	// Drivers should use this API if they wish to request a level higher than the previous level they required 

	// Drivers should keep track of the level they require and be disciplined

	//

	NKern::Lock();

	__PM_ASSERT(aLevel<Levels[aRequester]);

	Levels[aRequester]=aLevel;

	if(aLevel > iCurrentLevel)			// need to increase the level

		{

		// if(aLevel <= MAXLEVEL)

		//	aLevel = MAXLEVEL;

		iCurrentLevel = aLevel;

		iCurrentLevelOwnerId = aRequester;

		//

		// TO DO: (optional)

		//

		// Modify hardware register bits to set the level of the resource to aLevel

		NKern::Unlock();

		//

		// TO DO: (optional)

		//

		// If the resource is asynchronous may need to sleep or block the thread until the change is complete

		//

		}

	else

		NKern::Unlock();

	}

void SharedMultilevelResource1::ReduceToLevel(TUint aLevel, TInt aRequester)

	{

	//

	// Drivers should use this API if they wish to request a level higher than the previous level they required 

	//

	NKern::Lock();

	__PM_ASSERT(aLevel>Levels[aRequester]);

	Levels[aRequester]=aLevel;

	if(aLevel < iCurrentLevel && aRequester == iCurrentLevelOwnerId)	// the holder of the current level as lowered its request

		{

		FindMaxLevel(&iCurrentLevel, &iCurrentLevelOwnerId);			// find max level required and the ID of its holder

		//

		// TO DO: (optional)

		//

		// Modify hardware register bits to set the level of the resource to iCurrentLevel

		NKern::Unlock();

		//

		// TO DO: (optional)

		//

		// If the resource is asynchronous may need to sleep or block the thread until the change is complete

		//

		}

	else

		NKern::Unlock();

	}

TUint SharedMultilevelResource1::GetResourceLevel()

	{

	return iCurrentLevel;

	}

void SharedMultilevelResource1::FindMaxLevel(TUint* aLevel, TInt* aId)

	{

	//

	// TO DO: (optional)

	//

	// Place your clever array search algorithm here...

	// return max level and id of owner

	}

TInt BinaryPowerInit();		// the Symbian example Battery Monitor and Power HAL handling

GLDEF_C TInt KernelModuleEntry(TInt aReason)

	{

	if(aReason==KModuleEntryReasonVariantInit0)

		{

		//

		// TO DO: (optional)

		//

		// Start the Resource Manager earlier so that Variant and other extension could make use of Power Resources

		//

		__KTRACE_OPT(KPOWER, Kern::Printf("Starting Template Resource controller"));

		new(&TheResourceManager)TemplateResourceManager;

		TheResourceManager.InitResources();

		return KErrNone;

		}

	else if(aReason==KModuleEntryReasonExtensionInit0)

		{

		__KTRACE_OPT(KPOWER, Kern::Printf("Starting Template power controller"));

		//

		// TO DO: (optional)

		//

		// Start the Kernel-side Battery Monitor and hook a Power HAL handling function.

		// Symbian provides example code for both of the above in \e32\include\driver\binpower.h

		// You may want to write your own versions.

		// The call below starts the example Battery Monitor and hooks the example Power HAL handling function

		// At the end we return an error to make sure that the entry point is not called again with

		// KModuleEntryReasonExtensionInit1 (which would call the constructor of TheResourceManager again)

		//

		TInt r = BinaryPowerInit();

		if (r!= KErrNone)

			__PM_PANIC("Can't initialise Binary Power model");

		DTemplatePowerController* c = new DTemplatePowerController();

		if(c)

			return KErrGeneral;

		else

			__PM_PANIC("Can't create Power Controller");

		}

	else if(aReason==KModuleEntryReasonExtensionInit1)

		{

		// does not get called...

		}

	return KErrArgument;

	}