www.pudn.com > WinGOS.rar > WinHAL.cpp

#include "..\gpmp.h" 
#include "WinHal.h" 
#include "SimDisplay.h" 
#include "SimDisplay.h" 
 
#include  
#include  
#include  
 
#undef Sleep 
#undef SwitchToThread 
 
#define GlobalHeapSize (2<<20) 
 
#define PAGE_READWRITE         0x04      
#define MEM_COMMIT           0x1000      
#define MEM_RELEASE          0x8000      
#define PRI_SWITCH 15 //1-15 
#define PRI_NORMAL 0 //0 
 
#define TH(pThread) HANDLE(*PDWORD(pThread->m_pStack)) 
 
static BOOL m_bIdle=FALSE; 
static HANDLE m_evtSwitch; 
 
CHAL* g_pHAL; 
CDesktop* g_pDesktop=NULL; 
HANDLE m_hMouseMsg; 
 
//Win32API函数 
extern "C"{ 
 
VOID __stdcall Sleep(DWORD dwMilliseconds); 
DWORD __stdcall SuspendThread(HANDLE hThread); 
DWORD __stdcall ResumeThread(HANDLE hThread); 
BOOL __stdcall SetThreadPriority(HANDLE hThread,int nPriority); 
BOOL __stdcall SwitchToThread(void); 
PVOID __stdcall VirtualAlloc(PVOID lpAddress,SIZE_T dwSize,DWORD flAllocationType,DWORD flProtect); 
BOOL __stdcall VirtualFree(PVOID lpAddress,SIZE_T dwSize,DWORD dwFreeType); 
DWORD __stdcall WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds); 
HANDLE __stdcall CreateEventA(PVOID lpEventAttributes,BOOL bManualReset,BOOL bInitialState,LPCTSTR lpName); 
BOOL __stdcall SetEvent(HANDLE hEvent); 
BOOL __stdcall ResetEvent(HANDLE hEvent); 
BOOL __stdcall CloseHandle(HANDLE hObject); 
BOOL __stdcall TerminateThread(HANDLE hThread,DWORD dwExitCode); 
void __stdcall ExitThread(DWORD dwExitCode); 
HANDLE __stdcall CreateThread(PVOID lpThreadAttributes,SIZE_T dwStackSize,PVOID lpStartAddress,PVOID lpParameter,DWORD dwCreationFlags,PDWORD lpThreadId); 
 
}//extern "C" 
#ifdef _DEBUG 
#undef TRACE 
void TRACE(LPCTSTR pszFormat,...) 
{ 
	TCHAR szTrace[1024]; 
	va_list args; 
 
	va_start(args,pszFormat); 
	vsprintf(szTrace,pszFormat,args); 
	_CrtDbgReport(0, NULL, 0, NULL, szTrace); 
	va_end(args); 
} 
#endif 
 
//#define TRACE(x) 
 
extern "C" LRESULT HalMain(UINT message, WPARAM wParam, LPARAM lParam) 
{ 
	/* 
	CKernel kernel; 
	CHAL hal; 
	g_pKernel=&kernel; 
	g_pHAL=&hal; 
 
	初始化关键的中断或设备寄存器; 
	初始化全局堆栈 
	初始化驱动 
	g_pKernel->Run(); 
	... 
	*/ 
	switch(message) 
	{ 
	case halCreate:{ 
		HANDLE hThread=::CreateThread(NULL,0,CHAL::RunGOS,0,CreateSuspend,NULL); 
		TRACE("创建GOS内核线程0x%08x\r\n",hThread); 
		m_evtSwitch=hThread; 
		::ResumeThread(hThread); 
		}break; 
	case halMouseEvent: 
		switch(wParam) 
		{ 
		case 0x200: message=WM_MOUSEMOVE;break; 
		case 0x201: message=WM_LBUTTONDOWN;break; 
		case 0x202: message=WM_LBUTTONUP;break; 
		} 
		g_pDesktop->PulseMessageEvent(m_hMouseMsg,message,lParam); 
		break; 
	case halSetWallpaper:{ 
		g_pDesktop->SetWallpaper(PBITMAPFILEHEADER(wParam)); 
		}break; 
	} 
	return 0; 
} 
 
DWORD CHAL::RunGOS(PVOID pParam) 
{ 
	CKernel kernel; 
	CHAL hal; 
	CSimDisplay sd; 
	CPMPDesktop scr; 
 
	g_pKernel=&kernel; 
	g_pHAL=&hal; 
	g_pDesktop=&scr; 
 
	PDWORD pGlobalHeapStack=(PDWORD)::VirtualAlloc(0,GlobalHeapSize,MEM_COMMIT,PAGE_READWRITE); 
	*pGlobalHeapStack=GlobalHeapSize-4; 
	g_pKernel->CreateThread(pGlobalHeapStack+1); 
	*PDWORD(kernel.m_pStack)=DWORD(m_evtSwitch); 
	 
	m_evtSwitch=::CreateEventA(NULL,FALSE,FALSE,NULL); 
	HANDLE hThread=::CreateThread(NULL,0,SimSWI,0,CreateSuspend,NULL); 
	::SetThreadPriority(hThread,PRI_SWITCH); 
	::ResumeThread(hThread); 
 
	scr.Create(g_pKernel,&sd,NULL,NULL); 
	m_hMouseMsg=scr.SetMessageEvent(PriorityHighest); 
	RunThread(g_pKernel); 
 
	::CloseHandle(m_evtSwitch); 
	::VirtualFree(pGlobalHeapStack,0,MEM_RELEASE); 
	return 0; 
} 
 
DWORD CHAL::RunThread(PVOID pParam) 
{ 
	PTHREAD pThread=PTHREAD(pParam); 
	PDWORD pSP=PDWORD(pThread->m_pStack)-1; 
	pParam=PVOID(*pSP); 
	__asm 
	{ 
		mov eax,pSP; 
		mov pSP,esp; 
		mov esp,eax; 
	} 
	pParam=(PVOID)pThread->Run(pParam); 
	__asm 
	{ 
		mov esp,pSP; 
	} 
	return DWORD(pParam); 
} 
 
DWORD CHAL::SimSWI(PVOID pParam) 
{ 
	LONG nTime; 
	for(;;) 
	{ 
		if(m_bIdle) 
		{ 
			//TRACE("HAL挂起线程0x%08x(0x%04x)\r\n",GetCurrentThread(),TH(GetCurrentThread())); 
			SuspendThread(TH(GetCurrentThread())); 
		} 
		nTime=LONG(g_pKernel->GetSwitchTime()-GetTickCount()); 
		while(nTime>0) 
		{ 
			::WaitForSingleObject(m_evtSwitch,nTime); 
			nTime=g_pKernel->IsLockSwitch()?ThreadSwitchInterval:0; 
		} 
		if(m_bIdle) 
		{ 
			::ResumeThread(TH(GetCurrentThread())); 
		} 
		g_pKernel->SwitchThread(); 
	} 
	return 0; 
} 
 
void CHAL::CreateThread(CThread* pThread,PVOID pParam) 
{ 
	/* 
	sp=pThread->m_pStack; 
	将所有寄存器入栈 
	*/ 
	HANDLE hThread=::CreateThread(NULL,0,RunThread,pThread,CreateSuspend,NULL); 
	::SetThreadPriority(hThread,PRI_NORMAL); 
	*PDWORD(pThread->m_pStack)=DWORD(hThread); 
	*(PDWORD(pThread->m_pStack)-1)=DWORD(pParam); 
	TRACE("HAL创建线程0x%08x(0x%04x)\r\n",pThread,TH(pThread)); 
} 
 
void CHAL::ExitThread(CThread* pThread) 
{ 
	TRACE("HAL终止线程0x%08x(0x%04x)\r\n",pThread,TH(pThread)); 
	::TerminateThread(TH(pThread),pThread->GetLastError()); 
} 
 
BOOL CHAL::SwitchThread(void) 
{ 
	/* 
	激活软中断，以调用切换函数 
	*/ 
 
	::SetEvent(m_evtSwitch); 
#if PRI_SWITCH-PRI_NORMAL<3 
	::SwitchToThread(); 
#endif 
	return TRUE; 
} 
 
void CHAL::SwitchThread(CThread* pFromThread,CThread* pToThread) 
{ 
	/* 
	将所有寄存器入栈 
	pFromThread->m_pStack=sp; 
	sp=pToThread; 
	将所在寄存器出栈 
	*/ 
	//TRACE("HAL切换线程0x%08x(0x%04x) -> 0x%08x(0x%04x)\r\n",pFromThread,TH(pFromThread),pToThread,TH(pToThread)); 
	::SuspendThread(TH(pFromThread)); 
	::ResumeThread(TH(pToThread)); 
} 
 
void CHAL::OnSwitchThread(BOOL bIdle) 
{ 
	/*计算下个换醒时间，配置唤醒定时器 
	if(bIdle) 
	{ 
		调用系统休眠函数，系统休眠 
		... 
		调用系统唤醒函数 
	} 
	//最后，定时器引发软中断，将调用g_pKernel->SwitchThread() 
	*/ 
	m_bIdle=bIdle; 
} 
 
LRESULT CHAL::MsgProc(UINT message, WPARAM wParam, LPARAM lParam) 
{ 
	return CMsgObject::MsgProc(message,wParam,lParam); 
}