// 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_assp\assp.cpp
// 
//

#include <template_assp_priv.h>

TemplateAssp* TemplateAssp::Variant=NULL;
TPhysAddr TemplateAssp::VideoRamPhys;

DECLARE_STANDARD_ASSP()

EXPORT_C TemplateAssp::TemplateAssp()
	{
	TemplateAssp::Variant=this;
	}

extern void MsTimerTick(TAny* aPtr);

EXPORT_C TMachineStartupType TemplateAssp::StartupReason()
	{
	__KTRACE_OPT(KBOOT,Kern::Printf("TemplateAssp::StartupReason"));
#ifdef _DEBUG															// REMOVE THIS
	TUint s = Kern::SuperPage().iHwStartupReason;
	__KTRACE_OPT(KBOOT,Kern::Printf("CPU page value %08x", s));
#endif																	// REMOVE THIS
	//
	// TO DO: (mandatory)
	//
	// Map the startup reason read from the Super Page to one of TMachineStartupType enumerated values
	// and return this
	//
	return EStartupCold;   // EXAMPLE ONLY
	}

EXPORT_C void TemplateAssp::Init1()
	{
	__KTRACE_OPT(KBOOT,Kern::Printf("TemplateAssp::Init1()"));
	//
	// TO DO: (optional)
	//
	TemplateInterrupt::Init1();			// initialise the ASSP interrupt controller

	//
	// TO DO: (optional)
	//
	// Initialises any hardware blocks which require early initialisation, e.g. enable and power the LCD, set up
	// RTC clocks, disable DMA controllers. etc.
	//
	}

EXPORT_C void TemplateAssp::Init3()
	{
	__KTRACE_OPT(KBOOT,Kern::Printf("TemplateAssp::Init3()"));

	TTemplate::Init3();

	NTimerQ& m=*(NTimerQ*)NTimerQ::TimerAddress();
	iTimerQ=&m;
	//
	// TO DO: (mandatory)
	//
	// If Hardware Timer used for System Ticks cannot give exactly the period required store the initial rounding value
	// here which is updated every time a match occurrs. Note this leads to "wobbly" timers whose exact period change
	// but averages exactly the required value
	// e.g.
	// m.iRounding=-5;
	//
	
	TInt r=Interrupt::Bind(KIntIdOstMatchMsTimer,MsTimerTick,&m);	// bind the System Tick interrupt
	if (r!=KErrNone)
		Kern::Fault("BindMsTick",r);

	// 
	// TO DO: (mandatory)
	//
	// Clear any pending OST interrupts and enable any OST match registers.
	// If possible may reset the OST here (to start counting from a full period). Set the harwdare to produce an 
	// interrupt on full count
	//

	r=Interrupt::Enable(KIntIdOstMatchMsTimer);	// enable the System Tick interrupt
	if (r!=KErrNone)
		Kern::Fault("EnbMsTick",r);

	// 
	// TO DO: (optional)
	//
	// Allocate physical RAM for video buffer, as per example below. However with some hardware, the Video Buffer
	// may not reside in main System memory, it may be dedicated memory.
	//
	// EXAMPLE ONLY
	TInt vSize=VideoRamSize();
	r=Epoc::AllocPhysicalRam(2*vSize,TemplateAssp::VideoRamPhys);
	if (r!=KErrNone)
		Kern::Fault("AllocVRam",r);
	}

EXPORT_C TInt TemplateAssp::MsTickPeriod()
	{
	// 
	// TO DO: (mandatory)
	//
	// Return the OST tick period (System Tick) in microseconds ( 10E-06 s ).
	//
	return 1000;   // EXAMPLE ONLY
	}

EXPORT_C TInt TemplateAssp::SystemTimeInSecondsFrom2000(TInt& aTime)
	{
	aTime=(TInt)TTemplate::RtcData();
	__KTRACE_OPT(KHARDWARE,Kern::Printf("RTC READ: %d",aTime));
	return KErrNone;
	}

EXPORT_C TInt TemplateAssp::SetSystemTimeInSecondsFrom2000(TInt aTime)
	{
	//
	// TO DO: (optional)
	//
	// Check if the RTC is running and is stable
	//
	__KTRACE_OPT(KHARDWARE,Kern::Printf("Set RTC: %d",aTime));
	TTemplate::SetRtcData(aTime);
	__KTRACE_OPT(KHARDWARE,Kern::Printf("RTC: %d",TTemplate::RtcData()));
	return KErrNone;
	}

EXPORT_C TUint32 TemplateAssp::NanoWaitCalibration()
	{
	// 
	// TO DO: (mandatory)
	//
	// Return the minimum time in nano-seconds that it takes to execute the following code:
	//	 nanowait_loop:
	//	 		  subs r0, r0, r1
	//	 		  bhi nanowait_loop
	//
	// If accurate timings are required by the Base Port, then it should provide it's own implementation 
	// of NanoWait which uses a hardware counter. (See Kern::SetNanoWaitHandler)
	//
	
	return 0;   // EXAMPLE ONLY
	}