// Copyright (c) 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:
// omap3530/shared/mstick/mstick.cpp
//

#include <nk_priv.h>
#include <assp/omap3530_assp/omap3530_timer.h>
#include <assp/omap3530_assp/omap3530_prcm.h>
#include <assp/omap3530_assp/omap3530_irqmap.h>
#include <assp/omap3530_assp/omap3530_hardware_base.h>

using namespace TexasInstruments::Omap3530 ;
using namespace TexasInstruments::Omap3530::GPTimer ;

const TUint32 KMaxIdleTicks = 0xFFFFFF;
const TUint KMinSuppressTickCount = 2;
static const Omap3530HwBase::TRegValue	KTickInterruptMask = TISR::T_OVF_IT_FLAG::KOn;


namespace Omap3
{
namespace MsTick
{

void MsTickIsr(TAny* aPtr )
	{
	// Clear interrupts
	TGpTimer1::iTISR.Write( KTickInterruptMask );
	TGpTimer1::iTOCR.Write( 0 );
	reinterpret_cast< NTimerQ* >( aPtr )->Tick();
	}


EXPORT_C TInt Start()
	{
	 __KTRACE_OPT(KBOOT,Kern::Printf("+Omap3:MsTick:Start"));

	 //	Enable GPT1 and set it to run from the 32kHz sysclk
	Prcm::SetGptClockSource( Prcm::EGpt1, Prcm::EGptClock32k );
	Prcm::SetClockState( Prcm::EClkGpt1_F, Prcm::EClkOn );
	Prcm::SetClockState( Prcm::EClkGpt1_I, Prcm::EClkAuto );

	__NK_ASSERT_DEBUG(TGpTimer1::iTISTAT.Read() == 0x1);

//	Prcm::AddToWakeupGroup( Prcm::EClkGpt1_I, Prcm::EWakeGroupMpu );

	//Set GPT1 to highest priority
	Interrupt::SetPriority(EOmap3530_IRQ37_GPT1_IRQ,KOmap3530MaxIntPriority);

	 // Bind to GPTimer 1 interrupt
	TInt r = Interrupt::Bind( TGpTimer1::Irq(), MsTickIsr, NTimerQ::TimerAddress() );

	if( KErrNone == r )
		{
		TGpTimer1::Reset();
		while ( !TGpTimer1::ResetComplete()) {}

		const TRegValue startOcp = ( TIOCP_CFG::T_AUTOIDLE::KOff
								   | TIOCP_CFG::T_SOFTRESET::KOff
								   | TIOCP_CFG::T_ENAWAKEUP::KOn
								   | TIOCP_CFG::T_IDLEMODE::KSmartIdle
								   | TIOCP_CFG::T_EMUFREE::KOff
								   | TIOCP_CFG::T_CLOCKACTIVITY::KMaintainFuncClock);
		TGpTimer1::iTIOCP_CFG.Write(startOcp) ;
		TGpTimer1::iTIOCP_CFG.Modify(TIOCP_CFG::T_SOFTRESET::KOn, KClear32);
		TGpTimer1::iTIOCP_CFG.Write(startOcp);
		
		// Enable timer to generate wakeups
		TGpTimer1::iTWER.Write(TWER::T_MAT_WUP_ENA::KOff | TWER::T_OVF_WUP_ENA::KOn | TWER::T_TCAR_WUP_ENA::KOff);

		TGpTimer1::ConfigureFor1Ms();

		TGpTimer1::iTIER.Write(TIER::T_MAT_IT_ENA::KOff | TIER::T_OVF_IT_ENA::KOn | TIER::T_TCAR_IT_ENA::KOff);
		TGpTimer1::iTISR.Write(TISR::T_MAT_IT_FLAG::KOn | TISR::T_OVF_IT_FLAG::KOn | TISR::T_TCAR_IT_FLAG::KOff);

		TGpTimer1::iTTGR.Write(1);

		TGpTimer1::iTOWR.Write( 0 );

		while (TGpTimer1::WriteOutstanding()) {}

		// Start the timer in auto-reload mode
		TGpTimer1::iTCLR.Modify(KClear32, (TCLR::T_ST::KOn | TCLR::T_AR::KOn | TCLR::T_IDLEMODE::KOverflow));

		// Ensure Timer Control Reg write is completed
		while(TGpTimer1::WriteOutstanding());

		Interrupt::Enable(TGpTimer1::Irq());
		}

	__KTRACE_OPT(KBOOT,Kern::Printf("-Omap3:MsTick:Start:%d", r ));
	return r;
	}

EXPORT_C TInt SuppressIdleTicks( TInt aMaxSleepTicks )
	{
	TUint32 targetSleepTicks = (aMaxSleepTicks >= KMaxIdleTicks) ? KMaxIdleTicks : aMaxSleepTicks; 

	if( targetSleepTicks >= KMinSuppressTickCount )
		{
		while(TGpTimer1::WriteOutstanding());

		// Mask out the next <targetSleepTicks> number of overflow events
		// Don't clear TOCR - we want to include any pending expiries that happened
		// while we were setting up into the sleep count
		TGpTimer1::iTOWR.Write( targetSleepTicks );

		// Clear any pending interrupt so we don't wake up immediately
		TGpTimer1::iTISR.Write( KTickInterruptMask );
		while(TGpTimer1::WriteOutstanding());
		}
	else
		{
		targetSleepTicks = 0;
		}

	return targetSleepTicks;
	}

EXPORT_C TInt EndIdleTickSuppression( TInt aMaxSleepTicks )
	{
	TUint actualSleepTicks = 0;

	if( aMaxSleepTicks >= KMinSuppressTickCount )
		{
		// Get counter values immediately. TCRR must be read first so we can check for
		// overflow while we are executing this code
		TUint32 tcrr = TGpTimer1::iTCRR.Read();
		TUint32 tisr = TGpTimer1::iTISR.Read() bitand KTickInterruptMask;
		TUint32 tocr = TGpTimer1::iTOCR.Read();

		TUint32 targetSleepTicks = (aMaxSleepTicks >= KMaxIdleTicks) ? KMaxIdleTicks : aMaxSleepTicks; 

		// Initial assumption is number of ticks missed == overflow count
		actualSleepTicks = tocr;

		if( tisr  )
			{
			// If maximum time has expired TOCR will be reset to zero
			// we want to handle the pending tick interrupt immediately
			// in the normal tick ISR so don't include it in the count of
			// ticks slept
			actualSleepTicks = targetSleepTicks - 1;
			}

		// Set timer back to normal mode
		// Dont' clear interrupts - we want any pending timer interrupt handled in the tick ISR
		TGpTimer1::iTOWR.Write( 0 );
		TGpTimer1::iTOCR.Write( 0 );
		while(TGpTimer1::WriteOutstanding());

		// Check whether another tick has expired while we were doing this
		if( TGpTimer1::iTCRR.Read() < tcrr )
			{
			// it's overflowed since we first checked
			if( tisr )
				{
				// if there was already a pending interrupt to be handled by the tick ISR
				// we need to include this new expiry in the sleep count
				++actualSleepTicks;
				}
			// else if there wasn't already a pending interrupt, this overflow will have generated
			// one which will be handled by the tick ISR
			}
		}
		
	return actualSleepTicks;
	}

}	// namespace MsTick
}	// namespace Omap3


DECLARE_STANDARD_EXTENSION()
	{
	return KErrNone;
	}