// Copyright (c) 1998-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:

// e32\include\nkern\win32\nk_plat.h

// 

// WARNING: This file contains some APIs which are internal and are subject

//          to change without notice. Such APIs should therefore not be used

//          outside the Kernel and Hardware Services package.

//

/**

 @file

 @internalComponent

*/

#ifndef __NK_WIN32_H__

#define __NK_WIN32_H__

//SL: Avoid warnings

#ifdef _CRTIMP

#undef _CRTIMP

#endif

#define _CRTIMP			// we want to use the win32 static runtime library

#define WIN32_LEAN_AND_MEAN

//SL: Avoid warnings

#ifdef _WIN32_WINNT

#undef _WIN32_WINNT

#endif

#define _WIN32_WINNT 0x0400

#include <windows.h>

typedef void (*TExcHandler)(TAny*,TAny*);

struct TWin32ExcInfo

	{

	enum {EExcInKernel = 0x1};

public:

	TExcHandler iHandler;

	TAny* iParam[2];

	TUint iFlags;

	// ExcType, iExcId, iFaultAddress, iEax, iEcx, iEdx, iEbx, iEsp, iEbp, iEsi, iEdi,

	// iSs, iDs, iEs, iFs, iGs, iEflags, iEip, iCs

	TUint32	iExcType;	// filled in by EPOC

	TUint32 iExcCode;

	TUint32 iExcDataAddress;

	TUint32 iEax;

	TUint32 iEcx;

	TUint32 iEdx;

	TUint32 iEbx;

	TUint32 iEsp;

	TUint32 iEsi;

	TUint32 iEdi;

	TUint32 iSs;

	TUint32 iDs;

	TUint32 iEs;

	TUint32 iFs;

	TUint32 iGs;

	TUint32 iEflags;

	TUint32 iCs;

	TUint32 iEbp;

	TUint32 iEip;

	};

enum TEmulThreadType

	{

	EThreadEvent,	// an 'interrupt' thread, interacts with Win32 events

	EThreadNKern	// a nKern thread, identified by a NThread control block

	};

class NThread : public NThreadBase

	{

public:

	typedef void (*TDivert)();

	enum TWakeup {ERelease,EResume,EResumeLocked,EIdle,EEscaped,EResumeDiverted};

	enum TSelectCpu {ECpuAll=-1,ECpuSingle=-2};

public:

	TInt Create(SNThreadCreateInfo& aInfo, TBool aInitial);

	void Stillborn();

	void DoForceExit();

//

	IMPORT_C static void Idle();

	IMPORT_C static void SetProperties(TBool aTrace, TInt aCpu);

	TBool WakeUp();

	TBool IsSafeToPreempt();

	void Divert(TDivert aDivert);

	void ApplyDiversion();

private:

	static DWORD WINAPI StartThread(LPVOID aParam);

//

	static void ExitSync();

	static void ExitAsync();

//

	static void Exception();

	static LONG WINAPI ExceptionFilter(EXCEPTION_POINTERS* aExc);

public:

	static void Diverted();

	// Has to be accessible to code user-side via emulator.lib

	static DWORD ExceptionHandler(EXCEPTION_RECORD* aException, CONTEXT* aContext);

public:

	HANDLE iWinThread;

	DWORD iWinThreadId;

	HANDLE iScheduleLock;	// event used for scheduling interlock

	TBool iDiverted;		// flag to indicate that the thread is being diverted

	TDivert iDivert;		// function to invoke after reschedule, may be null

	TAny* iDivertReturn;    // return address from diversion

	TInt iInKernel;			// flag to indicate if the thread is running 'in' the kernel

	TWakeup iWakeup;		// indicates how to wake up the thread

	TLinAddr iUserStackBase;

	};

IMPORT_C HANDLE CreateWin32Thread(TEmulThreadType aType, LPTHREAD_START_ROUTINE aThreadFunc, LPVOID aPtr, TBool aRun);

IMPORT_C void StartOfInterrupt();

IMPORT_C void EndOfInterrupt();

void SchedulerInit(NThread& aInit);

void SchedulerRegister(NThread& aSelf);

NThread* SchedulerThread();

NThread& CheckedCurrentThread();

void SchedulerLock();

void SchedulerUnlock();

void SchedulerEscape();

void SchedulerReenter();

void Win32FindNonPreemptibleFunctions();

inline void EnterKernel(TBool aCheck=TRUE)

	{

	if (++CheckedCurrentThread().iInKernel==1 && aCheck)

		{

		NThread& t = CheckedCurrentThread();

		__NK_ASSERT_ALWAYS(t.iCsCount==0);

		__NK_ASSERT_ALWAYS(t.iHeldFastMutex==0);

		__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked==0);

		}

	}

void LeaveKernel();

IMPORT_C TInt __fastcall Dispatch(TInt aFunction, TInt* aArgs);

typedef TInt (__cdecl *TExecHandler)(TInt,TInt,TInt,TInt);

typedef void (__cdecl *TPreprocessHandler)(TInt*,TUint32);

// Emulator nKern scheduling data

class Win32Interrupt

	{

public:

	void Init();

	TInt Mask();

	void Restore(TInt aLevel);

	void Begin();

	void End();

	inline TBool InInterrupt() const

		{return iInterrupted!=0;}	

	void ForceReschedule();

	inline TBool InterruptsStatus(TBool aRequest) const

	{return aRequest?(iLevel==0):(iLevel!=0);}

private:

	static void Reschedule(TAny*);

private:

	TInt iLock;

	HANDLE iQ;

	DWORD iOwner;

	TInt iLevel;

	TBool iRescheduleOnExit;

	NThread* iInterrupted;

	NThread iScheduler;

	};

extern TBool Win32AtomicSOAW;	// flag to indicate availability of SignalObjectAndWait() API

extern TBool Win32TraceThreadId;

extern TInt Win32SingleCpu;

extern Win32Interrupt Interrupt;

// Emulator nKern exception data

extern TAny* Win32ExcAddress;

extern TAny* Win32ExcDataAddress;

extern TUint Win32ExcCode;

void FastCounterInit();

#endif