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

// wins\specific\variant.cpp

// 

//

#include "variant.h"

#include "mconf.h"

#include <kernel/kern_priv.h>

#include <stdlib.h>

#include <property.h>

#include <emulator.h>

const TInt KDefaultRam = 63;				// 63MB default internal RAM

const TInt KUnlimitedRam = 0x400;			// 1GB ~= unlimited memory

const TInt KDefaultRamDrive = 0x400000;		// 4MB default RAM drive limit

_LIT(KLitWins,"Wins");

GLDEF_D Wins TheVariant;

GLDEF_D TActualMachineConfig TheConfig;

EXPORT_C Asic* VariantInitialise(TBool aRunExe)

	{

	return TheVariant.Init(aRunExe) == KErrNone ? &TheVariant : NULL;

	}

void AsicInitialise()

	{

	}

class DWinsPowerController : public DPowerController

	{

public: // from DPowerComtroller

	void CpuIdle();

	void EnableWakeupEvents();

	void AbsoluteTimerExpired();

	void DisableWakeupEvents();

	void PowerDown(TTimeK aWakeupTime);

public:

	static DWinsPowerController* New();

	void AssertWakeupSignal();

	void WakeupEvent();

private:

	HANDLE	iStandbySem;

	TUint	iStandby;

	TBool	iWakeupSignal;

	};

Wins::Wins()

	:iUi(0), iRealCpuSpeed(0), iCpuSpeed(0),

	iDebugOutput(INVALID_HANDLE_VALUE), iLogTimeStamp(ETrue),

	iPurgedImages(EFalse), iPowerController(0), iLogToDebugger(EFalse),

	iLogToFile(ETrue)

	{}

TInt Wins::Init(TBool aRunExe)

	{

	TInt r = InitProperties(aRunExe);

	if (r == KErrNone)

		{

		iProperties.GetInt("LogTimeStamp",iLogTimeStamp);

		TInt logThreadId=ETrue;

		iProperties.GetInt("LogThreadId",logThreadId);

		TInt cpu=NThread::ECpuSingle;

		iProperties.GetInt("HostCPU",cpu);

		NThread::SetProperties(logThreadId,cpu);

		iProperties.GetInt("LogToDebugger",iLogToDebugger);

		iProperties.GetInt("LogToFile",iLogToFile);

		TInt mask;

		Kern::SuperPage().iDebugMask[0] = DebugMask();  // get int or text mask value

		// check to see if DebugMask0 was used instead of DebugMask

		if ( (iProperties.GetInt("DebugMask", mask) != KErrNone) &&

			 (iProperties.GetInt("DebugMask0", mask) == KErrNone) )

			Kern::SuperPage().iDebugMask[0] = ((iProperties.GetInt("DebugMask0", mask) == KErrNone) ? mask : 0);

		// only int entries are supported for DebugMasks 1-7

		Kern::SuperPage().iDebugMask[1] = ((iProperties.GetInt("DebugMask1", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iDebugMask[2] = ((iProperties.GetInt("DebugMask2", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iDebugMask[3] = ((iProperties.GetInt("DebugMask3", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iDebugMask[4] = ((iProperties.GetInt("DebugMask4", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iDebugMask[5] = ((iProperties.GetInt("DebugMask5", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iDebugMask[6] = ((iProperties.GetInt("DebugMask6", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iDebugMask[7] = ((iProperties.GetInt("DebugMask7", mask) == KErrNone) ? mask : 0);

		// initial values for fast trace...

		Kern::SuperPage().iInitialBTraceFilter[0] = ((iProperties.GetInt("BTrace0", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iInitialBTraceFilter[1] = ((iProperties.GetInt("BTrace1", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iInitialBTraceFilter[2] = ((iProperties.GetInt("BTrace2", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iInitialBTraceFilter[3] = ((iProperties.GetInt("BTrace3", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iInitialBTraceFilter[4] = ((iProperties.GetInt("BTrace4", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iInitialBTraceFilter[5] = ((iProperties.GetInt("BTrace5", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iInitialBTraceFilter[6] = ((iProperties.GetInt("BTrace6", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iInitialBTraceFilter[7] = ((iProperties.GetInt("BTrace7", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iInitialBTraceBuffer = ((iProperties.GetInt("BTraceBuffer", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().iInitialBTraceMode = ((iProperties.GetInt("BTraceMode", mask) == KErrNone) ? mask : 0);

		Kern::SuperPage().SetKernelConfigFlags(KernelConfigFlags());

		SCapabilitySet caps;

		DisabledCapabilities(caps);

		memcpy(&Kern::SuperPage().iDisabledCapabilities,&caps,sizeof(caps));

		}

	CalibrateCpuSpeed();

	return r;

	}

inline void Wins::InstallUi(DWinsUiBase& aUi)

	{iUi = &aUi;}

void Wins::Init1()

	{

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

	TInt tickperiod = WinsTimer::EDefaultPeriod;

	iProperties.GetInt("TimerResolution",tickperiod);

	iTimer.Init(tickperiod);

	TUint speed;

	if (iProperties.GetInt("CPUSpeed", (TInt&)speed) == KErrNone)

		SetCpuSpeed(speed);

	}

static TInt emulatorHal(TAny* aPtr, TInt aFunction, TAny* a1, TAny* a2)

	{

	return ((Wins*)aPtr)->EmulatorHal(aFunction, a1, a2);

	}

void Wins::Init3()

//

// Initialise timer tick and add emulator hal function

//

	{

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

	Kern::AddHalEntry(EHalGroupEmulator,&emulatorHal,this);

	iPowerController = DWinsPowerController::New();

	if (iPowerController == 0)

		__PM_PANIC("Can't create 'DWinsPowerController'");

	iTimer.Enable();

	}

void Wins::AddressInfo(SAddressInfo& aInfo)

	{

	TInt megabytes = KDefaultRam;

	iProperties.GetInt("MegabytesOfFreeMemory", megabytes);

	if (megabytes == 0)

		megabytes = KUnlimitedRam;

	aInfo.iTotalRamSize = megabytes << 20;

//

	TInt ramdisk = KDefaultRamDrive;

	iProperties.GetInt("RamDriveMaxSize", ramdisk);

	aInfo.iRamDriveMaxSize = ramdisk;

	}

void Wins::PurgeImages()

//

// Use the idle thread to clean up remnants of the emulator from the image path

//

	{

	char path[KMaxFileName+1];

	const char* imgPath=0;

	iProperties.GetString("EmulatorImagePath", imgPath);

	strcpy(path, imgPath);

	char* name = path +strlen(path);

	strcpy(name,"*");

	Emulator::Lock();

	WIN32_FIND_DATAA fdata;

	HANDLE finder = FindFirstFileA(path, &fdata);

	if (finder != INVALID_HANDLE_VALUE)

		{

		do

			{

			if ((fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)

				{

				strcpy(name, fdata.cFileName);

				DeleteFileA(path);

				}

			} while (FindNextFileA(finder, &fdata));

		FindClose(finder);

		}

	Emulator::Unlock();

	}

void Wins::Idle()

//

// Use the win32 NKern idle function

//

	{

	iTimer.SetIdleThread();

	if (!iPurgedImages)

		{

		PurgeImages();

		iPurgedImages = ETrue;

		}

	NThread::Idle();

	}

TInt Wins::MsTickPeriod()

//

// Provide the 'millisecond' timer tick period in microseconds

//

	{

	return 1000 * iTimer.Period();

	}

TInt Wins::SystemTimeInSecondsFrom2000(TInt& aTime)

	{

	aTime = iTimer.SystemTime();

	__KTRACE_OPT(KHARDWARE,Kern::Printf("RTC READ: %d",aTime));

	return KErrNone;

	}

TInt Wins::SetSystemTimeInSecondsFrom2000(TInt aTime)

// 

// Set the emulator time. We must not change the Win32 time so

// we just adjust the offset value to account for the difference

//

	{

	__KTRACE_OPT(KHARDWARE,Kern::Printf("Set RTC: %d",aTime));

	iTimer.SetSystemTime(aTime);

	return KErrNone;

	}

TInt Wins::VariantHal(TInt aFunction, TAny* a1, TAny* /*a2*/)

	{

	TInt r=KErrNone;

	switch(aFunction)

		{

		case EVariantHalVariantInfo:

			{

			TVariantInfoV01Buf infoBuf;

			TVariantInfoV01& info=infoBuf();

//			info.iRomVersion=TVersion(KRomMajorVersionNumber,KRomMinorVersionNumber,KRomBuildVersionNumber);

			info.iMachineUniqueId=0;

			info.iLedCapabilities=0x0;

			info.iProcessorClockInKHz=iCpuSpeed ? iCpuSpeed*1000 : 1;

			info.iSpeedFactor=0;

			if (iUi)

				iUi->Info(info);

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

			break;

			}

		case EVariantHalCustomRestartReason:

			{

			//This will take value from c:\data\epoc.ini.

			TInt x = Property::GetInt("CustomRestartReason");    

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

			}

			break;

		case EVariantHalCustomRestart:

			{

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

				return KErrPermissionDenied;

			//This will only shut down epoc as Custom Restart Reason is not supported on wins.

			Kern::Restart((TInt)a1);

			break;

			}

		default:

			r=KErrNotSupported;

			break;

		}

	return r;

	}

TPtr8 Wins::MachineConfiguration()

	{

	return TPckg<TActualMachineConfig>(TheConfig);

	}

void Wins::CalibrateCpuSpeed()

//

// calculate approx. CPU speed in MHz, 0 if we can't tell

//

	{

    TInt cycleCount =200*1000*20;   //take 20ms at 20MHz

    // This loop will double the cyclecount until the difference is non-zero.

    FOREVER

    	{

      	if (cycleCount > (KMaxTUint / 2))

    		{

    		break;

    		}

		SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);

		LARGE_INTEGER start;

		if (QueryPerformanceCounter(&start))

    		{

	   		__asm mov eax, cycleCount

 	noploop: 

 			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm dec eax

			__asm sub eax, 2

			__asm jnz noploop

			//

			LARGE_INTEGER end;

			QueryPerformanceCounter(&end);

			LARGE_INTEGER f;

			QueryPerformanceFrequency(&f);

			TInt64 diff = (end.QuadPart - start.QuadPart);

	    	if(diff!=0)

	    		{

				TInt64 hz = (TInt64(cycleCount) / 1000000) * (f.QuadPart / diff);

				iRealCpuSpeed = (TUint)(hz);

				break;

		     	}

  	  	    }

    	cycleCount *= 2;  // Double the count!!

 		}

   	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);

	}

TInt Wins::SetCpuSpeed(TUint aSpeed)

	{

	if (iRealCpuSpeed == 0)

		return KErrNotSupported;	// don't know the real CPUSpeed

	if (IsDebuggerPresent())

		return KErrGeneral;			// nobbling not avaliable when debugging

	if (aSpeed == 0)

		aSpeed = iRealCpuSpeed;		// reset to maximum

	else if (aSpeed > iRealCpuSpeed)

		aSpeed = iRealCpuSpeed;

	else if (aSpeed * 20u  < iRealCpuSpeed)

		aSpeed = (iRealCpuSpeed + 19u) / 20u;

	__KTRACE_OPT(KHARDWARE,Kern::Printf("Set CPUSpeed: %d",aSpeed));

	iCpuSpeed = aSpeed;

	// calculate CPU time to nobble in parts-per-million

	TUint nobble = ((iRealCpuSpeed - aSpeed) * 1000000u) / iRealCpuSpeed;

	iTimer.Nobble(nobble);

	return KErrNone;

	}

HANDLE Wins::DebugOutput()

//

// Return a handle to the trace file, creating the file if required.

//

// The log file name can be specified by a property or environment

// variable called 'EmulatorLog', otherwise it defaults to 

// 'epocwind.out' in the temporary directory.

//

	{

	HANDLE file = iDebugOutput;

	if (file == INVALID_HANDLE_VALUE)

		{

		CHAR debugfile[MAX_PATH];

		const char* logpath;

		if (iProperties.GetString("EmulatorLog",logpath)==KErrNone)

			strcpy(debugfile,logpath);

		else

			{

			DWORD len = GetEnvironmentVariableA("EmulatorLog", debugfile, MAX_PATH);

			debugfile[len]=0;

			if (len == 0)

				{

				len=GetTempPathA(MAX_PATH,debugfile);

				strcpy(debugfile+len,"epocwind.out");	// EPOC WINS DEBUG output file

				}

			}

		file=CreateFileA(debugfile, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, NULL, NULL);

		if (file!=INVALID_HANDLE_VALUE)

			{

			SetFilePointer(file, NULL, NULL, FILE_END);

			iDebugOutput = file;

			}

		}

	return file;

	}

const TInt MaxOutputMsg = 599;

void Wins::EarlyLogging(const char* aMessage1,const char* aMessage2)

	{

	char message[MaxOutputMsg+3];

	TInt len = min(strlen(aMessage1), MaxOutputMsg);

	memcpy(message,aMessage1,len);

	if(aMessage2)

		{

		TInt len2 = min((TInt)strlen(aMessage2), MaxOutputMsg-len);

		memcpy(message+len,aMessage2,len2);

		len+=len2;

		}

	message[len++] = '\r';

	message[len++] = '\n';

	message[len] = 0;

	if (iLogToFile)

		{

		DWORD bytes;

		WriteFile(DebugOutput(), message, len, &bytes, NULL);

		}

	if (iLogToDebugger)

		{

		OutputDebugStringA(message);

		}

	}

void Wins::DebugPrint(const TDesC8& aDes)

//

// Send the string to the debug output (Win32 debug trace) and trace file

//

	{

	char message[MaxOutputMsg+1];

	TInt len = aDes.Length();

	const char* ptr = (const char*)aDes.Ptr();

	if (iLogTimeStamp)

		{

		strcpy(message,"          ");

		_ultoa(NKern::TickCount() * iTimer.Period(), message + 10, 10);

		int n = strlen(message);

		len = min(len, MaxOutputMsg - n - 2);

		char* msg = message + n;

		msg[0] = msg[-1];

		msg[-1] = n < 10+2 ? '0' : msg[-2];

		msg[-2] = n < 10+3 ? '0' : msg[-3];

		msg[-3] = '.';

		if (n < 10+4)

			msg[-4] = '0';

		++msg;

		*msg++ = '\t';

		strncpy(msg, ptr, len);

		msg[len] = 0;

		ptr = msg - 11;

		len += 11;

		}

	else

		{

		len = min(len, MaxOutputMsg);

		strncpy(message, ptr, len);

		message[len] = 0;

		ptr = message;

		}

	TInt irq = NKern::DisableAllInterrupts();

	if (iLogToFile)

		{

		DWORD bytes;

		WriteFile(DebugOutput(), ptr, len, &bytes, NULL);

		}

	if (iLogToDebugger)

		{

		OutputDebugStringA(message);

		}

	NKern::RestoreInterrupts(irq);

	}

const char* const KErrorTitles[] =

	{

	"Symbian OS Fatal Error",

	"Symbian OS Application Error"

	};

const TText8* const KErrorMsg[] =