// 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[] =

 	{

 	_S8("An error has been detected in the Symbian OS emulator."),

 	_S8("A call to User::Panic() has occured, indicating\n"

 		"a programming fault in the running application.\n"

 		"Please refer to the documentation for more details.")

 	};

 _LIT8(KProgram, "\n\nProgram\t");

 _LIT8(KError, "\nError\t");

 _LIT8(KIDFC, "an IDFC");

 _LIT8(KEscaped, "an escaped thread");

 _LIT8(KInterrupt, "an interrupt thread");

 _LIT8(KNThread, "an NThread");

 _LIT8(KColon, " : ");

 _LIT8(KDebugQuery, "\n\nDo you wish to Debug the error?\0");

 TBool Wins::ErrorDialog(TError aType, const TDesC8& aPanic, TInt aVal)

 	{

 	// Must be called with interrupts enabled to allow thread running windows message loop to run

 	TBuf8<512> message(KErrorMsg[aType]);

 	message.Append(KProgram);

 	TInt context = NKern::CurrentContext();

 	switch(context)

 		{

 		case NKern::EIDFC:

 			message.Append(KIDFC);

 			break;

 		case NKern::EEscaped:

 			message.Append(KEscaped);

 			break;

 		case NKern::EInterrupt:

 			message.Append(KInterrupt);

 			break;

 		case NKern::EThread:

 			DThread *thread = Kern::NThreadToDThread(NKern::CurrentThread());

 			if (thread)

 				thread->TraceAppendFullName(message, ETrue);

 			else

 				message.Append(KNThread);

 			break;

 		}

 	message.Append(KError);

 	message.Append(aPanic);

 	message.Append(KColon);

 	message.AppendNum(aVal);

 #ifdef _DEBUG

 	message.Append(KDebugQuery);

 	UINT type = MB_YESNO | MB_DEFBUTTON2;

 #else

 	UINT type = MB_OK;

 #endif

 	type |= MB_SETFOREGROUND  | MB_ICONERROR;

 	message.Append('\0');

 	TInt r = MessageBoxA(iUi ? iUi->HWnd() : NULL, (LPCSTR)message.Ptr(), KErrorTitles[aType], type);

 	return r == IDYES;

 	}

 // UI installation

 EXPORT_C DWinsUiBase::DWinsUiBase()

 	{

 	TheVariant.InstallUi(*this);

 	}

 TInt BinaryPowerInit();

 DWinsPowerController* DWinsPowerController::New()

 	{

 	DWinsPowerController* self = new DWinsPowerController();

 	if (!self)

 		return NULL;

 	self->iStandbySem = CreateSemaphore(NULL, 0, 1, NULL);

 	if (self->iStandbySem == NULL)

 		return NULL;

 	TInt r = BinaryPowerInit();

 	if (r != KErrNone)

 		return NULL;

 	self->Register();

 	return self; 

 	}

 void DWinsPowerController::CpuIdle()

 	{

 	Arch::TheAsic()->Idle();

 	}

 void DWinsPowerController::EnableWakeupEvents()

 	{

 	iWakeupSignal = EFalse;

 	}

 void DWinsPowerController::DisableWakeupEvents()

 	{

 	}

 void DWinsPowerController::AbsoluteTimerExpired()

 	{

 	if (iTargetState == EPwStandby)

 		DWinsPowerController::WakeupEvent();	

 	}

 void DWinsPowerController::WakeupEvent()

 	{

 	if (iTargetState == EPwStandby)

 		{

 		iWakeupSignal = ETrue;

 		DPowerController::WakeupEvent();

 		}

 	}

 // called in Epoc thread

 void DWinsPowerController::PowerDown(TTimeK aWakeupTime)

 	{

 	if (iTargetState == EPwStandby)

 		{

 		UINT timeoutMs;

 		if (aWakeupTime == 0)

 			timeoutMs = INFINITE;

 		else 

 			{

 			TTimeK now = Kern::SystemTime();

 			if (now > aWakeupTime)

 				timeoutMs = 0;

 			else

 				timeoutMs = (UINT)((aWakeupTime - now) / 1000);

 			}

 		TInt l = NKern::DisableAllInterrupts();

 		if (!iWakeupSignal && timeoutMs)

 			{

 			iStandby = ETrue;

 			TheVariant.iTimer.Standby();

 			NKern::RestoreInterrupts(l);

 			DWORD r = WaitForSingleObject(iStandbySem, timeoutMs);

 			if (r == WAIT_TIMEOUT)

 				{

 				l = NKern::DisableAllInterrupts();

 				if (!iStandby)

 					WaitForSingleObject(iStandbySem, INFINITE);

 				else

 					iStandby = EFalse;

 				NKern::RestoreInterrupts(l);

 				}

 			TheVariant.iTimer.Wakeup();

 			}

 		else

 			NKern::RestoreInterrupts(l);

 		}

 	else

 		Kern::Restart(0x80000000);

 	}

 // called in the interrupt context

 void DWinsPowerController::AssertWakeupSignal()

 	{

 	iWakeupSignal = ETrue;

 	if (iStandby)

 		{

 		iStandby = EFalse;

 		ReleaseSemaphore(iStandbySem, 1, NULL);

 		}

 	}

 EXPORT_C void Wins::AssertWakeupSignal()

 	{

 	iPowerController->AssertWakeupSignal();

 	}

 EXPORT_C void Wins::WakeupEvent()

 	{

 	iPowerController->DWinsPowerController::WakeupEvent();

 	}

 // MMC emulation support

 TBool Wins::MediaDoorOpen;

 TInt Wins::CurrentPBusDevice;

 TAny* Wins::MediaChangeCallbackParam;

 TMediaChangeCallBack Wins::MediaChangeCallBackPtr;

 EXPORT_C TBool* Wins::MediaDoorOpenPtr()

 //

 // For media change simulation

 //

 	{

 	return(&MediaDoorOpen);

 	}

 EXPORT_C TInt* Wins::CurrentPBusDevicePtr()

 //

 // For media change simulation

 //

 	{

 	return(&CurrentPBusDevice);

 	}

 EXPORT_C void Wins::SetMediaChangeCallBackPtr(TMediaChangeCallBack aPtr, TAny* aMediaChangeCallbackParam)

 //

 // For media change simulation

 //

 	{

 	MediaChangeCallbackParam=aMediaChangeCallbackParam;

 	MediaChangeCallBackPtr=aPtr;

 	}

 EXPORT_C void Wins::MediaChangeCallBack()

 //

 // Perform the simulated media change callback

 //

 	{

 	if(MediaChangeCallBackPtr)

 		(*MediaChangeCallBackPtr)(MediaChangeCallbackParam);

 	}