/*

* Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:  

* ne1_tb\inc\ne1_tb_power.h

* NE1_TBVariant Power Management Header

* (see also assp.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)

*

*/

#ifndef __PM_STD_H__

#define __PM_STD_H__

#include <kernel/kpower.h>

#include "variant.h"

#include <e32btrace.h>

#ifdef __SMP__

#include <arm_gic.h>

#endif

#include <upd35001_timer.h>

#if defined (__SMP__) && !defined(__NO_IDLE_HANDLER_PIL__)

#include <smppower/idlehelper.h>

#include "smpidlehandler.h"

#endif

#define __PM_ASSERT_ALWAYS(aCond) \

	__ASSERT_ALWAYS( (aCond), \

		( \

			Kern::Printf("Assertion '" #aCond "' failed;\nFile: '" __FILE__ "' Line: %d\n", __LINE__), \

			Kern::Fault("Power Management", 1) \

		) )

#define __PM_ASSERT_DEBUG(aCond) \

	__ASSERT_DEBUG( (aCond), \

		( \

			Kern::Printf("Assertion '" #aCond "' failed;\nFile: '" __FILE__ "' Line: %d\n", __LINE__), \

			Kern::Fault("Power Management", 1) \

		) )

class TNE1_TBPowerController;

class DNE1_TBPowerController;

struct TRetireEngageCb

    {

    TRetireEngageCb(TDfcFn aFunction, TAny* aPtr, TInt aPriority)

        :iDfc(aFunction,aPtr,aPriority)

            {};

    TRetireEngageCb(TDfcFn aFunction, TAny* aPtr, TDfcQue* aDfcQ, TInt aPriority)

        :iDfc(aFunction,aPtr,aDfcQ,aPriority)

            {};

    TDfc iDfc;

    TInt iResult;

    TAny* iParam;

    };    

struct SRetireCall

    {

    SRetireCall(TInt aCpu,TRetireEngageCb& aCb);

#if defined(__SMP__) && !defined(__NO_IDLE_HANDLER_PIL__) && defined(SIMULATE_RETIREMENT)

    static void RetireCoreDfcFn(TAny*);

    void Call() { iTimer.OneShot(0);} // use a timer instead of Dfc as call can race with timer ISR

    NTimer iTimer;                    // by using a timer we are kinda sure we will run between ticks

    TInt iCpu;

    TRetireEngageCb& iCb;

    const TUint32 iAllCpusMask;

#endif

    };

struct SEngageCall

    {

    SEngageCall(TInt aCpu,TRetireEngageCb& aCb);

#if defined(__SMP__) && !defined(__NO_IDLE_HANDLER_PIL__) && defined(SIMULATE_RETIREMENT)

    static void EngageCoreDfcFn(TAny*);

    void Call() { iDfc.Enque();}

    TDfc iDfc;

    TInt iCpu;

    TRetireEngageCb& iCb;

#endif

    };

#if defined(__SMP__) && !defined(__NO_IDLE_HANDLER_PIL__)

class DNE1_TBPowerController;

NONSHARABLE_CLASS(DNE1_SMPIdleHandler) : public DSMPIdleHandler

    {

friend class SRetireCall;

friend class SEngageCall;

public:

    DNE1_SMPIdleHandler(DNE1_TBPowerController* aController);

    TInt Initialise();

    TBool DoEnterIdle(TInt aCpuMask, TInt aStage, volatile TAny* aU);

    TBool GetLowPowerMode(TInt aIdleTime, TInt &aLowPowerMode);

    TBool EnterLowPowerMode(TInt aMode, TInt aCpuMask, TBool aLastCpu);

private:

    void DoRetireCore(TInt aCpu, TLinAddr aReturnPoint);

#ifdef SIMULATE_RETIREMENT

    static void IdleSteal(TAny*);

#endif

private:

#ifdef SIMULATE_RETIREMENT

    static volatile TUint32 iRetiredCores;

    //    static volatile TUint32 iEngagingCores;

    TDfcQue** iIdleStealers;

    TDfc**    iIdleStealDfcs;

    TDfcQue*  iRetireEngageQue;

#endif

    DNE1_TBPowerController* iController;

    };

#endif

//

// TO DO: (mandatory)

//

// Definition of the DPowerController derived class

//

NONSHARABLE_CLASS(DNE1_TBPowerController) : public DPowerController

	{

friend class TNE1_TBPowerController;

public: // from DPowerController

	void CpuIdle();

	void EnableWakeupEvents();

	void AbsoluteTimerExpired();

	void DisableWakeupEvents();

	void PowerDown(TTimeK aWakeupTime);

    void IdleTickSuppresionEntry(TUint32 aWakeDelay, TInt aNextTimer);

    void IdleTickSuppresionRestore();

public:

	DNE1_TBPowerController();

private:

    static TInt ClearTimerInterrupt();      // return pending interrupt or 1023 if non pending

	void DoStandby(TBool aTimed, TUint32 aWakeupRTC);

public:

    static const TUint32 KCyclesPerTick;	// clock cycles per ms tick

    static const TInt KMaxSleepTicks;	// max number of ticks that can be slept

	static const TUint32 KWakeUpBeforeTick;	// The time (in cycles) that we required to before next tick is due to expire (i.e. after idle tick suppression)

	static const TUint32 KTooCloseToTick;	// In cycles abort idle tick suppresion if we very close current tick edge

	static const TUint32 KMinTimeToTick;	// In cyles, if time to next interrupt is less than this value in wakeup

											// ... we need to update tick in idle tick restore

	static const TInt KMinIdleTicks;		// Minimum amount of ticks we wish to enter power saving mode				

private:

#if defined(__SMP__) && !defined(__NO_IDLE_HANDLER_PIL__)

    DNE1_SMPIdleHandler iIdleHandler;

#endif

//     const TUint32 iNumCpus;

// Idle tick supression related variables

	TBool iWakeupEventsOn;

    TUint32 iNextInterrupt;

	TUint32 iOriginalTimerExpire;

    TUint iIdleCount;                     // in SMP increased every time we do ITS

                                            // in unicore, updated on every entry to CpuIdle

    };

//

// If you need to access to the Power Controller from Drivers/Extensions/Variant 

// or access to Resource Manager then define an accessor class as below

//

class TNE1_TBPowerController

	{

friend class SRetireCall;

friend class SEngageCall;

public:

	// to allow Variant/Drivers/Extensions access to Resource Manager

	// used by drivers/extensions to signal a wakeup event to Power Controller

	IMPORT_C static void WakeupEvent();

    IMPORT_C static void RetireCore(TInt aCpu, TRetireEngageCb& aCb);

    IMPORT_C static void EngageCore(TInt aCpu, TRetireEngageCb& aCb);

    IMPORT_C static TUint IdleCount();

	inline static void RegisterPowerController(DNE1_TBPowerController* aPowerController);

private:

	static DNE1_TBPowerController* iPowerController;

#if defined(__SMP__) && !defined(__NO_IDLE_HANDLER_PIL__)

    static DNE1_SMPIdleHandler* iIdleHandler;

#endif

    };

#include "ne1_tb_power.inl"

#endif