--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/shared/mstick/mstick.cpp Thu Oct 15 12:59:54 2009 +0100
@@ -0,0 +1,189 @@
+// 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;
+ }
+