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