/*

* 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\specific\variant.cpp

*

*/

#include "variant.h"

#include "mconf.h"

#include <videodriver.h>

#include <xyin.h>

#include "ne1_tb_power.h"

#include <naviengine_lcd.h>

#include <d32ethernet.h>

//These constants define Custom Restart Reasons in SuperPage::iHwStartupReason

const TUint KHtCustomRestartMax	  = 0xff;

const TUint KHtCustomRestartShift = 8;

const TUint KHtCustomRestartMask  = KHtCustomRestartMax << KHtCustomRestartShift; 

const TUint KHtRestartStartupModesMax = 0xf; // Variable, platform dependant 

//const TUint KHtRestartStartupModesShift = 16; // Variable, platform dependant 

//const TUint KHtRestartStartupModesMask = KHtRestartStartupModesMax << KHtRestartStartupModesShift;

void NE1_TBVariantFault(TInt aLine)

	{

	Kern::Fault("NE1_TBVariant",aLine);

	}

#define V_FAULT()	NE1_TBVariantFault(__LINE__)

// Debug output

#define XON								17

#define XOFF							19

#define DEBUG_XON_XOFF					0		// Non-zero if we want XON-XOFF handshaking

GLDEF_D NE1_TBVariant TheVariant;

TUint32 Variant::iBaseAddress=0;

TUint32 NE1_TBVariant::HandlerData[3];

SInterruptHandler NE1_TBVariant::Handlers[ENumXInts];

extern void XIntDispatch(TAny*);

#ifdef __SMP__

extern void PowerUpCpu(TInt aCpu, SPerCpuUncached* aU);

extern void PowerDownCpu(TInt aCpu, SPerCpuUncached* aU);

extern "C" {

SVariantInterfaceBlock VIB;

SVariantInterfaceBlock* InitVIB()

	{

	SVariantInterfaceBlock* v = &VIB;

	v->iVer = 0;

	v->iSize = sizeof(VIB);

	v->iMaxCpuClock = UI64LIT(400000000);	// 400MHz

	v->iMaxTimerClock = 200000000u;			// 200MHz = CPU CLK / 2

	v->iScuAddr = KHwBaseSCU;

	v->iGicDistAddr = KHwBaseGlobalIntDist;

	v->iGicCpuIfcAddr = KHwBaseIntIf;

	v->iLocalTimerAddr = KHwBaseSCU + 0x600u;

	v->iCpuPowerUpFn = &PowerUpCpu;

	v->iCpuPowerDownFn = &PowerDownCpu;

	return v;

	}

}

#endif

extern "C" EXPORT_C TAny* VariantInitialise(TInt a)

	{

	switch(a)

		{

		case 0:	return &TheVariant;

#ifdef __SMP__

		case 1: return InitVIB();

#endif

		default: return 0;

		}

	}

NE1_TBVariant::NE1_TBVariant()

	{

#ifdef __SMP__

	__VARIANT_SUPPORTS_NANOKERNEL_INTERFACE_BLOCK__();

#endif

	iDebugInitialised=EFalse;

	}

//

// TO DO: (optional)

//

// Specify the RAM zone configuration.

//

// The lowest addressed zone must have the highest preference as the bootstrap 

// will always allocate from the lowest address up.  Once the kernel has initialised

// then the zone preferences will decide from which RAM zone memory is allocated.

//

// 	const TUint KVariantRamZoneCount = ?;

//	static const SRamZone KRamZoneConfig[KVariantRamZoneCount+1] = 

//				 			iBase      iSize   		iID	iPref	iFlags

//				{

//				__SRAM_ZONE(0x????????, 0x???????, 	?,	?, 		?), 

//				...

//				__SRAM_ZONE(0x????????, 0x???????, 	?, 	?, 		?),

//				__SRAM_ZONE_END, // end of zone list

//				};

//

TInt NE1_TBVariant::RamZoneCallback(TRamZoneOp aOp, TAny* aId, const TAny* aMasks)

	{

	//

	// TO DO: (optional)

	//

	// Handle RAM zone operations requested by the kernel.

	//

	return TheVariant.DoRamZoneCallback(aOp, (TUint)aId, (const TUint*)aMasks);

	}

TInt NE1_TBVariant::DoRamZoneCallback(TRamZoneOp aOp, TUint aId, const TUint* aMasks)

	{

	//

	// TO DO: (optional)

	//

	// Handle RAM zone operations requested by the kernel.

	//

	// Three types of operation need to be supported:

	//	ERamZoneOp_Init:		Update power state of the RAM zones after the

	//							kernel has initialised.

	//	ERamZoneOp_PowerUp:		A RAM zone changing from used to empty.

	//	ERamZoneOp_PowerDown:	A RAM zone changing from empty to used.

	//

	switch (aOp)

		{

		case ERamZoneOp_Init:	

			break;

		case ERamZoneOp_PowerUp:

			break;

		case ERamZoneOp_PowerDown:

			break;

		default:

			return KErrNotSupported;

		}

	return KErrNone;

	}

void NE1_TBVariant::Init1()

	{

	__KTRACE_OPT(KBOOT,Kern::Printf("NE1_TBVariant::Init1()"));

	//

	// TO DO: (mandatory)

	//

	// Configure Memory controller and Memrory Bus parameters (in addition to what was done in the Bootstrap)

	//

	__KTRACE_OPT(KBOOT,Kern::Printf("Memory Configuration done"));

	//

	// TO DO: (optional)

	//

	// Inform the kernel of the RAM zone configuration via Epoc::SetRamZoneConfig().

	// For devices that wish to reduce power consumption of the RAM IC(s) the callback functions

	// RamZoneCallback() and DoRamZoneCallback() will need to be implemented and passed 

	// to Epoc::SetRamZoneConfig() as the parameter aCallback.

	// The kernel will assume that all RAM ICs are fully intialised and ready for use from boot.

	//

	//

	// TO DO: (optional)

	//

	// Initialise other critical hardware functions such as I/O interfaces, etc, not done by Bootstrap

	//

	// if CPU is Sleep-capable, and requires some preparation to be put in that state (code provided in Bootstrap),

	// the address of the idle code is writen at this location by the Bootstrap

	// e.g.

	// iIdleFunction=*(TLinAddr*)((TUint8*)&Kern::SuperPage()+0x1000);

	//

	NaviEngineAssp::Init1();

	}

#ifdef __SMP__

void NE1_TBVariant::Init2AP()

	{

	__KTRACE_OPT(KBOOT,Kern::Printf("NE1_TBVariant::Init2AP()"));

	}

#endif

void NE1_TBVariant::Init3()

	{

	__KTRACE_OPT(KBOOT,Kern::Printf(">NE1_TBVariant::Init3()"));

	NaviEngineAssp::Init3();

	Variant::Init3();

	//

	// TO DO: (optional)

	//

	// Initialise other accessor classes, if required

	//

	InitInterrupts();

	__KTRACE_OPT(KBOOT,Kern::Printf("<NE1_TBVariant::Init3()"));

	}

void Variant::Init3()

//

// Phase 3 initialisation

//

    {

	__KTRACE_OPT(KHARDWARE, Kern::Printf(">Variant::Init3"));

	//

	// TO DO: (optional)

	//

	// Initialise any Variant class data members here, map in Variant and external hardware addresses

	//

	DPlatChunkHw* pC=NULL;

	TInt r=DPlatChunkHw::New(pC,KHwVariantPhysBase,0x2000,EMapAttrSupRw|EMapAttrFullyBlocking);

	__KTRACE_OPT(KHARDWARE, Kern::Printf("r=%d", r));

    __ASSERT_ALWAYS(r==KErrNone,V_FAULT());

	iBaseAddress=pC->LinearAddress();

	__KTRACE_OPT(KHARDWARE, Kern::Printf("iBaseAddress=%08x", iBaseAddress));

	__KTRACE_OPT(KHARDWARE, Kern::Printf("<Variant::Init3"));

	}

EXPORT_C TUint Variant::BaseLinAddress()

	{

	return((TUint)iBaseAddress);

	}

EXPORT_C void Variant::MarkDebugPortOff()

	{

	TheVariant.iDebugInitialised=EFalse;

	}

void NE1_TBVariant::Idle()

//

// The NULL thread idle loop

//

	{

	// Idle the CPU, suppressing the system tick if possible

	//

	// TO DO: (optional)

	//

	// Idle Tick supression: 

	// 1- obtain the number of idle Ticks before the next NTimer expiration (NTimerQ::IdleTime())

	// 2- if the number of Ticks is large enough (criteria to be defined) reset the Hardware Timer

	//    to only interrupt again when the corresponding time has expired.

	//   2.1- the calculation of the new value to program the Hardware Timer with should take in 

	//		  consideration the rounding value (NTimerQ::iRounding)

	//  3- call the low level Sleep function (e'g. Bootstrap: address in iIdleFunction)

	//  4- on coming back from Idle need to read the Hardware Timer and determine if woken up due to 

	//     timer expiration (system time for new match<=current system time<system time for new match-tick period)

	//     or some other Interrupt.

	//	 4.1- if timer expiration, adjust System Time by adding the number of Ticks suppressed to NTimerQ::iMsCount

	//   4.2- if other interrupt, calculate the number of Ticks skipped until woken up and adjust the System Time as

	//		  above

	//

	// Support for different Sleep Modes:

	// Often the Sleep mode a platform can go to depends on how many resources such as clocks/voltages can be 

	// turned Off or lowered to a suitable level. If different Sleep modes are supported this code may need 

	// to be able to find out what power resources are On or Off or used to what level. This could be achieved by

	// enquiring the Resource Manager (see \ne1_tb\inc\ne1_tb_power.h).

	// Then a decision could be made to what Sleep level we go to.

	//

	// Example calls:

	// Obtain the number of Idle Ticks before the next NTimer expiration

	// TInt aTicksLeft = NTimerQ::IdleTime();

	// ... 

	// Find out the deepest Sleep mode available for current resource usage and sleeping time

	// NE1_TBResourceManager* aManager = TNE1_TBPowerController::ResourceManager();

	// NE1_TBResourceManager::TSleepModes aMode = aManager -> MapSleepMode(aTicksLeft*MsTickPeriod());

	// ...

	// Find out the state of some particular resources

	// TBool aResourceState = aManager -> GetResourceState(NE1_TBResourceManager::AsynchBinResourceUsedByZOnly);

	// TUint aResourceLevel = aManager -> GetResourceLevel(NE1_TBResourceManager::SynchMlResourceUsedByXOnly);

	// ...

	extern void __cpu_idle();

	__cpu_idle();

	}

TInt NE1_TBVariant::VariantHal(TInt aFunction, TAny* a1, TAny* a2)

	{

	TInt r=KErrNone;

	switch(aFunction)

		{

		case EVariantHalCurrentNumberOfScreens:

			{

			TInt numScreens = 1; // Number of screens is fixed to 1 on the NaviEngine

			kumemput(a1,&numScreens,sizeof(numScreens));

			break;

			}

		case EVariantHalVariantInfo:

			{

			TVariantInfoV01Buf infoBuf;

			TVariantInfoV01& info=infoBuf();

			info.iRomVersion=Epoc::RomHeader().iVersion;

			info.iMachineUniqueId.iData[0] = 0x4956414E;

			info.iMachineUniqueId.iData[1] = 0x474E4520;

			info.iLedCapabilities = 0;

			info.iProcessorClockInKHz = 400000;

			// ratio of 'speed' to 'speed' of a Psion Series 5 ...

			// ... no I'm not joking!

			info.iSpeedFactor = 20;

			Kern::InfoCopy(*(TDes8*)a1,infoBuf);

			break;

			}

		case EVariantHalDebugPortSet:

			{

			//

			// TO DO: (mandatory)

			//

			// Write the iDebugPort field of the SuperPage, as in the following EXAMPLE ONLY:

			//

			TUint32 thePort = (TUint32)a1;

			switch(thePort)

				{

				case 0:			// port 0 at 115200bps

				case 0x100:		// port 0 at 230400bps

				case 1:			// port 1 at 115200bps

				case 0x101:		// port 1 at 230400bps

				case 2:			// port 2 at 115200bps

				case 3:			// ??same as 0??

					TheVariant.iDebugInitialised=EFalse;

				case (TUint32)KNullDebugPort:

					Kern::SuperPage().iDebugPort = thePort;

					break;

				default:

					r=KErrNotSupported;

				}

			break;

			}

		case EVariantHalDebugPortGet:

			{

			//

			// TO DO: (mandatory)

			//

			// Obtain the Linear address of the Uart used for outputting Debug strings as in the following EXAMPLE ONLY:

			//

			TUint32 thePort = TNaviEngine::DebugPortAddr();

			kumemput32(a1, &thePort, sizeof(TUint32));

			break;

			}

		case EVariantHalSwitches:

			{

			//

			// TO DO: (optional)

			//

			// Read the state of any switches, as in the following EXAMPLE ONLY:

			//

			TUint32 x = Variant::Switches();

			kumemput32(a1, &x, sizeof(x));

			break;

			}

		case EVariantHalLedMaskSet:

			{

			//

			// TO DO: (optional)

			//

			// Set the state of any on-board LEDs, e.g:

			// TUint32 aLedMask=(TUint32)a1;

			// Variant::ModifyLedState(~aLedMask,aLedMask);

			//

			break;

			}

		case EVariantHalLedMaskGet:

			{

			//

			// TO DO: (optional)

			//

			// Read the state of any on-board LEDs, e.g:

			// TUint32 x = Variant::LedState();

			// kumemput32(a1, &x, sizeof(x));

			//

			break;

			}

		case EVariantHalCustomRestartReason:

			{

			//Restart reason is stored in super page

			TInt x = (Kern::SuperPage().iHwStartupReason & KHtCustomRestartMask) >> KHtCustomRestartShift ;

			kumemput32(a1, &x, sizeof(TInt));

			break;

			}

		case EVariantHalCustomRestart:

			{

			if(!Kern::CurrentThreadHasCapability(ECapabilityPowerMgmt,__PLATSEC_DIAGNOSTIC_STRING("Checked by Hal function EVariantHalCustomRestart")))

				return KErrPermissionDenied;

			if ((TUint)a1 > KHtCustomRestartMax)

				return KErrArgument;

			Kern::Restart((TInt)a1 << KHtCustomRestartShift);

			}

			break;

		case EVariantHalCaseState:

			{

			//

			// TO DO: (optional)

			//

			// Read the state of the case, e.g:

			// TUint32 x = Variant::CaseState();

			// kumemput32(a1, &x, sizeof(x));

			//

			break;

			}

		case EVariantHalPersistStartupMode:

			{

			if (!Kern::CurrentThreadHasCapability(ECapabilityWriteDeviceData,__PLATSEC_DIAGNOSTIC_STRING("Checked by Hal function EDisplayHalSetBacklightOn")))

				return KErrPermissionDenied;

			if ((TUint)a1 > KHtRestartStartupModesMax ) // Restart startup mode max value

				return KErrArgument;

			//

			// TO DO: (optional)

			//

			// Store the restart reason locally,

			// which will eventually be picked up by

			// the power controller, e.g:

			// iCustomRestartReason = (TUint)a1;

			break;

			}

		case EVariantHalGetPersistedStartupMode:

			{

			//

			// TO DO: (optional)

			//

			// Read the restart startup mode, e.g:

			// TInt startup = (Kern::SuperPage().iHwStartupReason & KHtRestartStartupModesMask) >> KHtRestartStartupModesShift;

			// kumemput32(a1, &startup, sizeof(TInt));

			break; 			

			}

		case EVariantHalGetMaximumCustomRestartReasons:

			{

			//

			// TO DO: (optional)

			//

			// Read the maximum custom restart reason, e.g:

			// kumemput32(a1, &KHtCustomRestartMax, sizeof(TUint));

			break;

			}

		case EVariantHalGetMaximumRestartStartupModes:

			{

			//

			// TO DO: (optional)

			//

			// Read the maximum restart startup mode, e.g:

			// kumemput32(a1, &KHtRestartStartupModesMax, sizeof(TUint));

			break;

			}

		case EVariantHalSerialNumber:

			{

			TInt serialNumber = NE1_TBVariant::GetSerialNumber();

			kumemput(a1,&serialNumber,sizeof(serialNumber));

			break;

			}

		case EVariantHalProfilingDefaultInterruptBase:

			{

			TInt interruptNumber = KIntCpuProfilingDefaultInterruptBase;

			kumemput(a1,&interruptNumber,sizeof(interruptNumber));

			break;

			}

		default:

			r=KErrNotSupported;

			break;

		}

	return r;

	}

TPtr8 NE1_TBVariant::MachineConfiguration()

	{

	return TPtr8((TUint8*)&Kern::MachineConfig(),sizeof(TActualMachineConfig),sizeof(TActualMachineConfig));

	}

TInt NE1_TBVariant::VideoRamSize()

	{

	//

	// Return the size of the area of RAM used to store the Video Buffer, as in the following EXAMPLE ONLY:

	return FRAME_BUFFER_SIZE(32, 800, 480);//32 bits per pixel

	}

EXPORT_C void Variant::PowerReset()

	{

	//

	// TO DO: (optional)

	//

	// Reset all power supplies

	//

	}

EXPORT_C TUint Variant::Switches()

	{

	//

	// TO DO: (optional)