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

// 

//

#include "variant.h"

#include "mconf.h"

#include <videodriver.h>

#include <drivers/xyin.h>

#include "template_power.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 TemplateVariantFault(TInt aLine)

	{

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

	}

#define V_FAULT()	TemplateVariantFault(__LINE__)

// Debug output

#define XON								17

#define XOFF							19

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

GLDEF_D Template TheVariant;

TUint32 Variant::iBaseAddress=0;

TUint32 Template::HandlerData[3];

SInterruptHandler Template::Handlers[ENumXInts];

extern void XIntDispatch(TAny*);

EXPORT_C Asic* VariantInitialise()

	{

	return &TheVariant;

	}

Template::Template()

	{

	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 Template::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 Template::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 Template::Init1()

	{

	__KTRACE_OPT(KBOOT,Kern::Printf("Template::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);

	//

	TemplateAssp::Init1();

	}

void Template::Init3()

	{

	__KTRACE_OPT(KBOOT,Kern::Printf("Template::Init3()"));

	TemplateAssp::Init3();

	Variant::Init3();

	//

	// TO DO: (optional)

	//

	// Initialise other accessor classes, if required

	//

	InitInterrupts();

	}

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);

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

	iBaseAddress=pC->LinearAddress();

	}

EXPORT_C TUint Variant::BaseLinAddress()

	{

	return((TUint)iBaseAddress);

	}

EXPORT_C void Variant::MarkDebugPortOff()

	{

	TheVariant.iDebugInitialised=EFalse;

	}

EXPORT_C void Variant::UartInit()

	{

	NKern::Lock();

	if (!TheVariant.iDebugInitialised)

		{

		//

		// TO DO: (mandatory)

		//

		// Reset and initialise the UART used to output debug strings

		//

		TheVariant.iDebugInitialised=ETrue;

		}

	NKern::Unlock();

	}

void Template::DebugInit()

	{

	//

	// TO DO: (mandatory)

	//

	// Initialise the UART used for outputting Debug Strings (no Interrupts), as in the following EXAMPLE ONLY:

	//

	Variant::UartInit();

	TTemplate::BootWaitMilliSeconds(10);	// wait loop to ensure that the port is fully initialised and output buffer empty

	}

void Template::DebugOutput(TUint aLetter)

//

// Output a character to the debug port

//

    {

	if (!iDebugInitialised)

		{

		DebugInit();

		}

		//

		// TO DO: (mandatory)

		//

		// Write the character aLetter to the UART output register and wait until sent (do NOT use interrupts!)

		//

    }

void Template::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 \template_variant\inc\template_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

	// TemplateResourceManager* aManager = TTemplatePowerController::ResourceManager();

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

	// ...

	// Find out the state of some particular resources

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

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

	// ...

	}

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

	{

	TInt r=KErrNone;

	switch(aFunction)

		{

		case EVariantHalVariantInfo:

			{

			TVariantInfoV01Buf infoBuf;

			TVariantInfoV01& info=infoBuf();

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

			//

			// TO DO: (mandatory)

			//

			// Fill in the TVariantInfoV01 info structure

			//	info.iMachineUniqueId=;

			//	info.iLedCapabilities=;

			//	info.iProcessorClockInKHz=;

			//	info.iSpeedFactor=;

			//

			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 1:

				case 2:

				case 3:

					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 = TTemplate::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 EVariantHalProfilingDefaultInterruptBase:

			{

			//

            // TO DO: (optional)

            //

            //Set the default interrupt number for the sampling profiler.   

            //TInt interruptNumber = KIntCpuProfilingDefaultInterruptBase;

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

			break;

			}

		default:

			r=KErrNotSupported;

			break;

		}

	return r;

	}

TPtr8 Template::MachineConfiguration()

	{

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

	}

TInt Template::VideoRamSize()

	{

	//

	// TO DO: (mandatory)

	//

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

	//

	return 0x28000;

	}

EXPORT_C void Variant::PowerReset()

	{

	//

	// TO DO: (optional)

	//

	// Reset all power supplies

	//

	}

EXPORT_C TUint Variant::Switches()

	{

	//

	// TO DO: (optional)

	//

	// Read the state of on-board switches

	//

	return 0;		// EXAMPLE ONLY

	}

/******************************************************************************

 * Interrupt handling/dispatch

 ******************************************************************************/

TInt Template::InterruptBind(TInt anId, TIsr anIsr, TAny* aPtr)

	{

	TUint id=anId&0x7fffffff;	// mask off second-level interrupt mask

	if (id>=ENumXInts)

		return KErrArgument;

	TInt r=KErrNone;

	SInterruptHandler& h=Handlers[id];

	TInt irq=NKern::DisableAllInterrupts();

	if (h.iIsr!=Spurious)

		r=KErrInUse;

	else

		{

		h.iIsr=anIsr;

		h.iPtr=aPtr;

		}

	NKern::RestoreInterrupts(irq);

	return r;

	}

TInt Template::InterruptUnbind(TInt anId)

	{

	TUint id=anId&0x7fffffff;	// mask off second-level interrupt mask

	if (id>=ENumXInts)

		return KErrArgument;

	InterruptDisable(anId);

	InterruptClear(anId);

	TInt r=KErrNone;

	SInterruptHandler& h=Handlers[id];

	TInt irq=NKern::DisableAllInterrupts();

	if (h.iIsr!=Spurious)

		{

		h.iIsr=Spurious;

		h.iPtr=(TAny*)id;

		}

	NKern::RestoreInterrupts(irq);

	return r;

	}

TInt Template::InterruptEnable(TInt anId)

	{

	TUint id=anId&0x7fffffff;	// mask off second-level interrupt mask

	if (id>=ENumXInts)

		return KErrArgument;

	TInt r=KErrNone;

	SInterruptHandler& h=Handlers[id];

	TInt irq=NKern::DisableAllInterrupts();

	if (h.iIsr==Spurious)

		r=KErrNotReady;

	else

		{

		//

		// TO DO: (mandatory)

		//

		// Enable the hardware interrupt in the source, e.g.

		// Variant::EnableInt(anId);

		//

		}

	NKern::RestoreInterrupts(irq);

	return r;

	}

TInt Template::InterruptDisable(TInt anId)

	{

	TUint id=anId&0x7fffffff;	// mask off second-level interrupt mask

	if (id>=ENumXInts)

		return KErrArgument;

	//

	// TO DO: (mandatory)

	//

	// Disable the hardware interrupt in the source, e.g.

	// Variant::DisableInt(anId);

	//

	return KErrNone;

	}

TInt Template::InterruptClear(TInt anId)

	{

	TUint id=anId&0x7fffffff;

	if (id>=ENumXInts)

		return KErrArgument;

	//

	// TO DO: (mandatory)

	//

	// Clear the hardware interrupt in the source, e.g.

	// Variant::ClearInt(anId);

	//

	return KErrNone;

	}

void Template::InitInterrupts()

	{

	// Set up the variant interrupt dispatcher

	// all interrupts initially unbound

	TInt i;

	for (i=0; i<(TInt)ENumXInts; i++)

		{

		Handlers[i].iPtr=(TAny*)i;

		Handlers[i].iIsr=Spurious;

		}

	// Set up data for 2nd level interrupt dispatcher

	HandlerData[0]=Variant::BaseLinAddress();	// Linear Base address of 2nd level Int Controller

	HandlerData[1]=(TUint32)&Handlers[0];		// Pointer to handler array

	HandlerData[2]=0;							// 

	//

	// TO DO: (mandatory)

	//

	// set up ASSP expansion interrupt to generate interrupts whenever a 2nd level interrupt occurrs

	// 

	// bind Template ASSP expansion interrupt input to our interrupt dispatcher

	TInt r=Interrupt::Bind(KIntIdExpansion, XIntDispatch, HandlerData);

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

	Interrupt::Enable(KIntIdExpansion);				// enable expansion interrupt

	}

void Template::Spurious(TAny* aId)

	{

	TUint32 id=((TUint32)aId)|0x80000000u;

	Kern::Fault("SpuriousInt",id);

	}

// USB Client controller

TBool Template::UsbClientConnectorDetectable()

	{

	__KTRACE_OPT(KHARDWARE, Kern::Printf("Template::UsbClientConnectorDetectable"));

	// TO DO: The return value should reflect the actual situation.

	return ETrue;

	}

TBool Template::UsbClientConnectorInserted()

 	{

	__KTRACE_OPT(KHARDWARE, Kern::Printf("Template::UsbClientConnectorInserted"));

	// TO DO: Query cable status here. The return value should reflect the actual current state.

	return ETrue;

	}

TInt Template::RegisterUsbClientConnectorCallback(TInt (*aCallback)(TAny*), TAny* aPtr)

	{

	__KTRACE_OPT(KHARDWARE, Kern::Printf("Template::RegisterUsbClientConnectorCallback"));

	iUsbClientConnectorCallback = aCallback;

	iUsbClientConnectorCallbackArg = aPtr;

	// TO DO: Register and enable the interrupt(s) for detecting USB cable insertion/removal here.

	// (Register UsbClientConnectorIsr.)

	// TO DO: The return value should reflect the actual situation.

	return KErrNone;

	}

void Template::UnregisterUsbClientConnectorCallback()

	{

	__KTRACE_OPT(KHARDWARE, Kern::Printf("Template::UnregisterUsbClientConnectorCallback"));

	// TO DO: Disable and unbind the interrupt(s) for detecting USB cable insertion/removal here.

	iUsbClientConnectorCallback = NULL;

	iUsbClientConnectorCallbackArg = NULL;

	}

TBool Template::UsbSoftwareConnectable()

	{

	__KTRACE_OPT(KHARDWARE, Kern::Printf("Template::UsbSoftwareConnectable"));

	// TO DO: The return value should reflect the actual situation.

	return ETrue;

	}

TInt Template::UsbConnect()

	{

	__KTRACE_OPT(KHARDWARE, Kern::Printf("Template::UsbConnect"));

	// TO DO: Do here whatever is necessary for the UDC to appear on the bus (and thus to the host).

	return KErrNone;

	}

TInt Template::UsbDisconnect()

	{

	__KTRACE_OPT(KHARDWARE, Kern::Printf("Template::UsbDisconnect"));

	// TO DO: Do here whatever is necessary for the UDC to appear disconnected from the bus (and thus from the

	// host).

	return KErrNone;

	}

void Template::UsbClientConnectorIsr(TAny *aPtr)

//

// Services the USB cable interrupt.

//

	{

	__KTRACE_OPT(KHARDWARE, Kern::Printf("Template::UsbClientConnectorIsr()"));

	Template* tm = static_cast<Template*>(aPtr);

	// TO DO: Service interrupt here: determmine cause, clear condition flag (if applicable), etc.

	if (tm->UsbClientConnectorInserted())

		{

		__KTRACE_OPT(KHARDWARE, Kern::Printf(" > USB cable now inserted."));

		}

	else

		{

		__KTRACE_OPT(KHARDWARE, Kern::Printf(" > USB cable now removed."));

		}

	// Important: Inform the USB stack.

	if (tm->iUsbClientConnectorCallback)

		{

		(*tm->iUsbClientConnectorCallback)(tm->iUsbClientConnectorCallbackArg);

		}

	}

//---eof