// 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

 	}