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

// omap3530/beaglboard/src/variant.cpp

//

#include <kernel.h>

#include <beagle/variant.h>

#include <beagle/mconf.h>

#include <beagle/beagle_gpio.h>

#include <assp/omap3530_assp/omap3530_uart.h>

#include <assp/omap3530_assp/omap3530_gpio.h>

#include <assp/omap3530_shared/tps65950.h>

#define ENABLE_WFI

#define IDLE_TICK_SUPPRESSION

#ifdef IDLE_TICK_SUPPRESSION

#include <assp/omap3530_shared/omap3_mstick.h>

#endif

GLREF_C void ArmWaitForInterrupt();

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

const TUint KHtCustomRestartMax	  = 0xff;

const TUint KHtCustomRestartShift = 8;

const TUint KHtCustomRestartMask  = KHtCustomRestartMax << KHtCustomRestartShift; 

//TODO: unncomment when referenced

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

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

//const TUint KHtRestartStartupModesMask = KHtRestartStartupModesMax << KHtRestartStartupModesShift;

void BeagleVariantFault(TInt aLine)

	{

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

	}

#define V_FAULT()	BeagleVariantFault(__LINE__)

// Debug output

#define XON								17

#define XOFF							19

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

GLDEF_D Beagle TheVariant;

TUint32 Variant::iBaseAddress=0;

EXPORT_C Asic* VariantInitialise()

	{

	return &TheVariant;

	}

Beagle::Beagle()

	{

	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 Beagle::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 Beagle::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;

	}

TUint Beagle::SysClkFrequency() const

	{

	return 26000000;

	}

TUint Beagle::SysClk32kFrequency() const

	{

	return 32768;

	}

TUint Beagle::AltClkFrequency() const

	{

	// Doesn't appear to be connected on Beagle

	return 0;

	}

void Beagle::Init1()

	{

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

	Omap3530Assp::Init1();

	}

EXPORT_C TInt Variant::GetMsTickPeriod()

	{

	return TheVariant.MsTickPeriod();

	}

void Beagle::Init3()

	{

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

	Omap3530Assp::Init3();

	Variant::Init3();

	}

void Variant::Init3()

//

// Phase 3 initialisation

//

    {

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

	}

EXPORT_C TUint Variant::BaseLinAddress()

	{

	return((TUint)iBaseAddress);

	}

EXPORT_C void Variant::MarkDebugPortOff()

	{

	TheVariant.iDebugInitialised=EFalse;

	}

EXPORT_C void Variant::UartInit()

	{

	if (!TheVariant.iDebugInitialised)

		{

		const Omap3530Uart::TUartNumber portNumber( Omap3530Assp::DebugPortNumber() );

		if( portNumber >= 0 )

			{

			Omap3530Uart::TUart uart( portNumber );

			uart.Init();

			uart.DefineMode( Omap3530Uart::TUart::EUart );

			uart.SetBaud( Omap3530Uart::TUart::E115200 );

			uart.SetDataFormat( Omap3530Uart::TUart::E8Data, Omap3530Uart::TUart::E1Stop, Omap3530Uart::TUart::ENone );

			uart.Enable();

			TheVariant.iDebugInitialised=ETrue;

			}

		}

	}

void Beagle::DebugInit()

	{

	Variant::UartInit();

	}

void Beagle::DebugOutput(TUint aLetter)

//

// Output a character to the debug port

//

    {

	const Omap3530Uart::TUartNumber portNumber( Omap3530Assp::DebugPortNumber() );

	if( portNumber >= 0 )

		{

		if (!iDebugInitialised)

			{

			DebugInit();

			}

		Omap3530Uart::TUart uart( portNumber );

		// If the FIFO is full we need to wait..

		while( uart.TxFifoFull() );

		uart.Write( aLetter );

		}

    }

void Beagle::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 \beagle_variant\inc\beagle_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);

	// ...

#ifdef ENABLE_WFI

	TInt irq = NKern::DisableAllInterrupts();

# ifdef IDLE_TICK_SUPPRESSION

	TInt maxSleepTicks = NTimerQ::IdleTime();

	TInt suppressedTicks = Omap3::MsTick::SuppressIdleTicks( maxSleepTicks );

# endif

	ArmWaitForInterrupt();

# ifdef IDLE_TICK_SUPPRESSION

	if( suppressedTicks > 0 )

		{

		suppressedTicks = Omap3::MsTick::EndIdleTickSuppression( suppressedTicks );

		if( suppressedTicks > 0 )

			{

			NTimerQ::Advance( suppressedTicks );

			}

		}

# endif

	NKern::RestoreInterrupts( irq );

#endif // ifdef ENABLE_WFI

	}

TInt Beagle::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:

			{

			kumemput32(a1, &Kern::SuperPage().iDebugPort, 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;

			}

		default:

			r=KErrNotSupported;

			break;

		}

	return r;

	}

TPtr8 Beagle::MachineConfiguration()

	{

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

	}

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

	}

// USB Client controller

TBool Beagle::UsbClientConnectorDetectable()

	{

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

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

	return ETrue;

	}

TBool Beagle::UsbClientConnectorInserted()

 	{

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

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

	return ETrue;

	}

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

	{

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

	iUsbClientConnectorCallback = aCallback;