/*
* Copyright (c) 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:
* NTT Docomo, Inc : BUG 1296
*
* Description: implementation of class Syborg
*
*/

#include <syborg_priv.h>
#include <hal_data.h>

#ifdef __EMI_SUPPORT__
#include <emi.h>
#endif

//#define ASSP_DEBUG

#ifdef ASSP_DEBUG
#define __DEBUG_PRINT(format...)    Kern::Printf(format)
#else
#define __DEBUG_PRINT(format...)    __KTRACE_OPT(KBOOT,Kern::Printf(format))
#endif

Syborg* Syborg::Variant=NULL;
// !@!
#if 0
TPhysAddr Syborg::VideoRamPhys;
TPhysAddr Syborg::VideoRamPhysSecure;		// Secure display memory
#endif

GLDEF_D Syborg TheVariant;

// Wait for interrupt idle routine
extern TInt SyborgWFIIdle();

DECLARE_STANDARD_ASSP()

EXPORT_C Asic* VariantInitialise()
{
	return &TheVariant;
}

void Syborg::Idle()
{
	// Use the basic Wait For Interrupt call to idle
	TInt irq = NKern::DisableAllInterrupts();
#ifdef __EMI_SUPPORT__
	EMI::EnterIdle();
#endif
	SyborgWFIIdle();
#ifdef __EMI_SUPPORT__
	EMI::LeaveIdle();
#endif
	NKern::RestoreInterrupts(irq);
}

TUint32 Syborg::NanoWaitCalibration()
{
	return 17;	// 2 cycles approx 17ns at 125MHz
}

TInt Syborg::VariantHal(TInt aFunction, TAny* a1, TAny* a2)
{
	__KTRACE_OPT(KHARDWARE,Kern::Printf("Syborg::VariantHal(%d, %0x, %0x)",aFunction,a1,a2));

	switch(aFunction)
    {
		case EVariantHalVariantInfo:
		{
			TVariantInfoV01Buf infoBuf;
			TVariantInfoV01& info = infoBuf();
			TUint clock=0;
			info.iRomVersion = Epoc::RomHeader().iVersion;
    		info.iMachineUniqueId = (TInt64(HALData::EMachineUid_OmapH4)<<32);
   			info.iLedCapabilities = (8<<16) + KLedMaskGreen1;
			info.iProcessorClockInKHz = clock;
			info.iSpeedFactor = clock/25;
			Kern::InfoCopy(*(TDes8*)a1,infoBuf);
			break;
	    }
		case EVariantHalDebugPortSet:
	    {
			TUint32 thePort = (TUint32)a1;
			switch(thePort) // Accept UART(0-3)
		    {
				case 0:
				case 1:
			    case 2:
                case 3:
                {
                    TSyborg::MarkDebugPortOff();           // mark port is not initialised
					Kern::SuperPage().iDebugPort = thePort; // update the super page
                    Syborg::DebugInit();                   // init debug port        
                    break;
                }
				case (TUint32)KNullDebugPort:               // debug output supressed
                {
                    TSyborg::MarkDebugPortOff();           // mark port is not initialised
					Kern::SuperPage().iDebugPort = thePort; // update the super page
					break;
                }
				default:
					return KErrNotSupported;
		    }
			break;
	    }
		case EVariantHalDebugPortGet:
	    {
			TUint32 thePort = Kern::SuperPage().iDebugPort;
			kumemput32(a1, &thePort, sizeof(TUint32));
			break;
	    }
		case EVariantHalSwitches:
	    {
		  TUint32 x = 0; //Register32(KHwBaseSystemReg+KHoRoSystemSw);
			kumemput32(a1, &x, sizeof(x));
			break;
	    }
		case EVariantHalLedMaskSet:
	    {
		  //SetRegister32(KHwBaseSystemReg+KHoRwSystemLed, (TUint32)a1 & 0xFF);
			break;
	    }
		case EVariantHalLedMaskGet:
	    {
		  TUint32 x = 0; //Register32(KHwBaseSystemReg+KHoRwSystemLed);
			kumemput32(a1, &x, sizeof(x));
			break;
	    }
		case EVariantHalCustomRestartReason:
	    {
			// Restart reason is stored in super page
		  TInt x = (Kern::SuperPage().iHwStartupReason); // & KmRestartCustomReasons) >> KsRestartCustomReasons;
			kumemput32(a1, &x, sizeof(TInt));
			break;
	    }
		case EVariantHalCustomRestart:
	    {
            __KERNEL_CAPABILITY_CHECK(
                if(!Kern::CurrentThreadHasCapability(ECapabilityPowerMgmt,
			       __PLATSEC_DIAGNOSTIC_STRING("Checked by Hal function EVariantHalCustomRestart")))
				    return KErrPermissionDenied;
            )
			  Kern::Restart(0);
			break;
	    }
		default:
    	{
			return KErrNotSupported;
	    }
    }
	return KErrNone;
}

TPtr8 Syborg::MachineConfiguration()
{
	return TPtr8((TUint8*)&Kern::MachineConfig(),40,40);
}

EXPORT_C Syborg::Syborg()
{
	iDebugPortBase = TSyborg::DebugPortAddr(); // initialised in bootstrap
}

EXPORT_C TMachineStartupType Syborg::StartupReason()
{
	TUint s = Kern::SuperPage().iHwStartupReason;
	__DEBUG_PRINT("Syborg::StartupReason CPU page value 0x%08X", s);
	return EStartupColdReset;
}

EXPORT_C void Syborg::Init1()
{
	__DEBUG_PRINT("Syborg::Init1()");

	// Enable the CLCD in the System registers
	SyborgInterrupt::Init1();
}

EXPORT_C void Syborg::Init3()
{
	NTimerQ& m = *(NTimerQ*)NTimerQ::TimerAddress();
	m.iRounding = -5;
		
	TInt r = Interrupt::Bind(EIntTimer1,SyborgInterrupt::MsTimerTick,&m);
	if (r != KErrNone)
	{
		Kern::Fault("BindMsTick",r);
	}

	TSyborg::Init3();
	TSyborg::ClearTimerInt(KHwBaseCounterTimer);

	r = Interrupt::Enable(EIntTimer1);
	if (r != KErrNone)
	{
		Kern::Fault("EnbMsTick",r);
	}

	TSyborg::SetTimerLoad(KHwBaseCounterTimer, K1000HzTickMatchLoad);
	//	TSyborg::SetTimerLoad(KHwBaseCounterTimer, 1000000);
	TSyborg::SetTimerMode(KHwBaseCounterTimer, TSyborg::ETimerModePeriodic);	
	TSyborg::EnableTimerInterrupt(KHwBaseCounterTimer);
	TSyborg::EnableTimer(KHwBaseCounterTimer, TSyborg::EEnable);
	
	SyborgInterrupt::Init3();

	// !@!
#if 0
	// Allocate physical RAM for video
	TInt vSize = TSyborg::VideoRamSize();

	r = Epoc::AllocPhysicalRam(vSize,Syborg::VideoRamPhys);
	if (r != KErrNone)
	{
		Kern::Fault("AllocVideoRam",r);
	}

	// Allocate physical RAM for secure display
	r = Epoc::AllocPhysicalRam(vSize,Syborg::VideoRamPhysSecure);
	if (r != KErrNone)
	{
		Kern::Fault("AllocVideoRam 2",r);
	}
#endif
	__DEBUG_PRINT("Finished Syborg::Init3()");
}

EXPORT_C void Syborg::DebugInit()
{
	iDebugPortBase = TSyborg::DebugPortAddr();

    if(iDebugPortBase != (TUint32)KNullDebugPort)   // supress debug output
    {
	  TUint8 res = ReadReg(iDebugPortBase, 0);
    }
}

//
// Output a character to the debug port
//
EXPORT_C void Syborg::DebugOutput(TUint aLetter)
{
	if(!iDebugPortBase)
    {
		DebugInit();
	}

    if(iDebugPortBase != (TUint32)KNullDebugPort)   // supress debug output
    {
	  WriteReg(iDebugPortBase,1,aLetter);
    }
}

EXPORT_C TInt Syborg::MsTickPeriod()
{
	return KMsTickPeriod;
}

EXPORT_C TInt Syborg::SystemTimeInSecondsFrom2000(TInt& aTime)
{
	__KTRACE_OPT(KHARDWARE,Kern::Printf("RTC READ: %d",aTime));
	return KErrNone;
}

EXPORT_C TInt Syborg::SetSystemTimeInSecondsFrom2000(TInt aTime)
{
	__KTRACE_OPT(KHARDWARE,Kern::Printf("Set RTC: %d",aTime));					// do this here to allow the value to be loaded...
	return KErrNone;
}