emu48-mirror/sources/Emu48/ENGINE.C

/*
 *   engine.c
 *
 *   This file is part of Emu48
 *
 *   Copyright (C) 1995 Sebastien Carlier
 *
 */
#include "pch.h"
#include "Emu48.h"
#include "Opcodes.h"
#include "io.h"
#include "debugger.h"

#define SAMPLE    16384						// speed adjust sample frequency

BOOL     bInterrupt = FALSE;
UINT     nState = 1;
UINT     nNextState = 0;
BOOL     bRealSpeed = FALSE;
BOOL     bKeySlow = FALSE;					// slow down for key emulation
CHIPSET  Chipset;

char     szSerialWire[16];					// evicename for wire port
char     szSerialIr[16];					// devicename for IR port

DWORD    dwSXCycles = 82;					// SX cpu cycles in interval
DWORD    dwGXCycles = 123;					// GX cpu cycles in interval

static BOOL  bCommInit = FALSE;				// COM port not open
static BOOL  bCpuSlow = FALSE;				// enable/disable real speed

static DWORD dwEDbgT2 = 0;					// debugger timer2 emulation
static DWORD dwEDbgCycles = 0;				// debugger cycle counter

static DWORD dwOldCyc;						// cpu cycles at last event
static DWORD dwSpeedRef;					// timer value at last event
static DWORD dwTickRef;						// sample timer ticks

#include "Ops.h"

// save last instruction in circular instruction buffer
static __inline VOID SaveInstrAddr(DWORD dwAddr)
{
	if (pdwInstrArray)						// circular buffer allocated
	{
		pdwInstrArray[wInstrWp] = dwAddr;
		wInstrWp = (wInstrWp + 1) % wInstrSize;
		if (wInstrWp == wInstrRp)
			wInstrRp = (wInstrRp + 1) % wInstrSize;
	}
	return;
}

static __inline VOID Debugger(VOID)			// debugger part
{
	LARGE_INTEGER lDummyInt;				// sample timer ticks
	BOOL  bStopEmulation;
	BOOL  bRplBreak = FALSE;				// flag for RPL breakpoint

	LPBYTE I = FASTPTR(Chipset.pc);			// get opcode stream

	SaveInstrAddr(Chipset.pc);				// save pc in last instruction buffer

	// check for code breakpoints
	bStopEmulation = CheckBreakpoint(Chipset.pc, 1, BP_EXEC);

	// check for memory breakpoints, opcode #14x or #15x
	if (I[0] == 0x1 && (I[1] == 0x4 || I[1] == 0x5))
	{
		DWORD dwData  = (I[2] & 0x1) ? Chipset.d1 : Chipset.d0;
		UINT  nType   = (I[2] & 0x2) ? BP_READ : BP_WRITE;

		DWORD dwRange;
		if (I[1] == 0x4)					// B,A
		{
			dwRange = (I[2] & 0x8) ? 2 : 5;
		}
		else								// P,WP,XS,X,S,M,W or number of nibbles
		{
			if (I[2] & 0x8)					// number of nibbles
			{
				dwRange = I[3]+1;
			}
			else							// P,WP,XS,X,S,M,W
			{
				dwData += F_s[I[3]];
				dwRange = F_l[I[3]];
			}
		}
		#if defined DEBUG_DEBUGGER
		{
			char buffer[256];
			wsprintf(buffer,"Memory breakpoint %.5lx, %u\n",dwData,dwRange);
			OutputDebugString(buffer);
		}
		#endif
		bStopEmulation |= CheckBreakpoint(dwData, dwRange, nType);
	}

	// NOP3, opcode #420 (GOC)
	if (bDbgNOP3 && I[0] == 0x4 && I[1] == 0x2 && I[2] == 0x0)
		bStopEmulation = TRUE;

	// RPL breakpoints, PC=(A), opcode #808C or PC=(C), opcode #808E
	if (bDbgRPL && I[0] == 0x8 && I[1] == 0x0 && I[2] == 0x8 && (I[3] == 0xC || I[3] == 0xE ))
	{
		BYTE byRplPtr[5];

		// A=DAT0 A, D0=D0+ 5, PC=(A)
		// C=DAT0 A, D0=D0+ 5, PC=(C)
		Npeek(byRplPtr,Chipset.d0-5,5);
		if (memcmp(byRplPtr,(I[3] == 0xC) ? Chipset.A : Chipset.C,5) == 0)
		{
			bRplBreak = TRUE;
			bStopEmulation = TRUE;
		}
	}

	// step over interrupt execution
	if (bDbgSkipInt && !bStopEmulation && !Chipset.inte)
		return;

	// check for step into
	bStopEmulation |= (nDbgState == DBG_STEPINTO);

	// check for step over
	bStopEmulation |= (nDbgState == DBG_STEPOVER) && dwDbgRstkp == Chipset.rstkp;

	// check for step out, something was popped from hardware stack
	if (nDbgState == DBG_STEPOUT && dwDbgRstkp == Chipset.rstkp)
	{
		_ASSERT(bStopEmulation == FALSE);
		if ((bStopEmulation = (Chipset.pc == dwDbgRstk)) == FALSE)
		{
			// it was C=RSTK, check for next object popped from hardware stack
			dwDbgRstkp = (Chipset.rstkp-1)&7;
			dwDbgRstk  = Chipset.rstk[dwDbgRstkp];
		}
	}

	if (bStopEmulation)						// stop condition
	{
		StopTimers();						// hold timer values when emulator is stopped
		if (Chipset.IORam[TIMER2_CTRL]&RUN)	// check if timer running
		{
			if (dwEDbgT2 == Chipset.t2)
			{
				// cpu cycles for one timer2 tick elapsed
				if ((DWORD) (Chipset.cycles & 0xFFFFFFFF) - dwEDbgCycles 
					>= (SAMPLE / 8192) * (DWORD) T2CYCLES)
				{
					--Chipset.t2;
					// adjust cycles reference
					dwEDbgCycles += (SAMPLE / 8192) * T2CYCLES;
				}
			}
			else							// new timer2 value
			{
				// new cycle reference
				dwEDbgCycles = (DWORD) (Chipset.cycles & 0xFFFFFFFF);
			}

			// check rising edge of Bit 8 of timer2
			if ((dwEDbgT2 & 0x100) == 0 && (Chipset.t2 & 0x100) != 0)
				Chipset.t1 = (Chipset.t1 - 1) & 0xF;
		}
		dwEDbgT2 = Chipset.t2;				// timer2 check reference value

		// OutputDebugString("Emulator stopped...\n");
		NotifyDebugger(bRplBreak); 
		WaitForSingleObject(hEventDebug,INFINITE);
		// OutputDebugString("Emulator running...\n");

		StartTimers();						// continue timers

		Chipset.Shutdn = FALSE;
		Chipset.bShutdnWake = FALSE;

		// init slow down part
		dwOldCyc = (DWORD) (Chipset.cycles & 0xFFFFFFFF);
		QueryPerformanceCounter(&lDummyInt);
		dwSpeedRef = lDummyInt.LowPart;
	}
}

static __inline VOID CheckDisp(BOOL bSync)
{
	if (disp == 0) return;					// no display update need

	// update display when drawing top line or display is off
	if (bSync && GetLineCounter() != 0x3F && (Chipset.IORam[0x00]&8))
		return;

	_ASSERT((disp & DISP_POINTER) == 0);	// display pointer already updated
	if (disp & DISP_MAIN)  UpdateMainDisplay();
	if (disp & DISP_MENUE) UpdateMenuDisplay();
	_ASSERT((disp & DISP_ANNUN) == 0);		// annunciators already updated
	disp = 0;								// display updated
	return;
}

static __inline VOID CheckSerial(VOID)
{
	if (ioc_acc)							// IOC changed
	{
		ioc_acc = FALSE;

		// COM port closed and serial on
		if (bCommInit == FALSE && (Chipset.IORam[IOC] & SON) != 0)
		{
			CommOpen(szSerialWire,szSerialIr); // open COM ports
			bCommInit = CommConnect() != PORT_CLOSE;
		}

		// COM port opend and serial off
		if (bCommInit == TRUE && (Chipset.IORam[IOC] & SON) == 0)
		{
			CommClose();					// close COM port
			bCommInit = FALSE;
		}

		// Interrupt on recv buffer full and receive buffer full
		if ((Chipset.IORam[IOC] & ERBF) && (Chipset.IORam[RCS] & RBF))
		{
			Chipset.Shutdn = FALSE;
			INTERRUPT;
		}
	}
}

static __inline VOID AdjustSpeed(VOID)		// adjust emulation speed
{
	if (bCpuSlow || bKeySlow)				// emulation slow down
	{
		DWORD dwCycles,dwTicks;

		// cycles elapsed for next check
		if ((dwCycles = (DWORD) (Chipset.cycles & 0xFFFFFFFF)-dwOldCyc) >= (DWORD) T2CYCLES)
		{
			LARGE_INTEGER lAct;
			do
			{
				BOOL bErr = QueryPerformanceCounter(&lAct);
				_ASSERT(bErr);				// no high-resolution performance counter
			}
			while((dwTicks = lAct.LowPart-dwSpeedRef) <= dwTickRef);

			// workaround for QueryPerformanceCounter() in Win2k, 
			// if last command sequence took over 50ms -> synchronize
			if(dwTicks > 819 * dwTickRef)	// time for last commands > 50ms (819 / 16384Hz)
			{
				// new synchronizing
				dwOldCyc = (DWORD) (Chipset.cycles & 0xFFFFFFFF);
				QueryPerformanceCounter(&lAct);	// get timer ticks
				dwSpeedRef = lAct.LowPart;	// save reference time
			}
			else
			{
				dwOldCyc += T2CYCLES;		// adjust cycles reference
				dwSpeedRef += dwTickRef;	// adjust reference time
			}
		}
	}
	return;
}

VOID AdjKeySpeed(VOID)						// slow down key repeat
{
	WORD i;
	BOOL bKey;

	if (bCpuSlow) return;					// no need to slow down

	bKey = FALSE;							// search for a pressed key
	for (i = 0;i < sizeof(Chipset.Keyboard_Row) / sizeof(Chipset.Keyboard_Row[0]) && !bKey;++i)
		bKey = (Chipset.Keyboard_Row[i] != 0);

	if (!bKeySlow && bKey)					// key pressed, init variables
	{
		LARGE_INTEGER lTime;				// sample timer ticks
		// save reference cycles
		dwOldCyc = (DWORD) (Chipset.cycles & 0xFFFFFFFF);
		QueryPerformanceCounter(&lTime);	// get timer ticks
		dwSpeedRef = lTime.LowPart;			// save reference time
	}
	bKeySlow = bKey;						// save new state
	return;
}

VOID SetSpeed(BOOL bAdjust)					// set emulation speed
{
	if (bAdjust)							// switch to real speed
	{
		LARGE_INTEGER lTime;				// sample timer ticks
		// save reference cycles
		dwOldCyc = (DWORD) (Chipset.cycles & 0xFFFFFFFF);
		QueryPerformanceCounter(&lTime);	// get timer ticks
		dwSpeedRef = lTime.LowPart;			// save reference time
	}
	bCpuSlow = bAdjust;						// save emulation speed
}

VOID UpdateKdnBit(VOID)						// update KDN bit
{
	if (Chipset.intk && (DWORD) (Chipset.cycles & 0xFFFFFFFFF) - Chipset.dwKdnCycles > (DWORD) T2CYCLES * 16)
		IOBit(0x19,8,Chipset.in != 0);
}

BOOL WaitForSleepState(VOID)				// wait for cpu SHUTDN then sleep state
{
	DWORD dwRefTime = timeGetTime();		

	// wait for the SHUTDN command with 1.5 sec timeout
	while (timeGetTime() - dwRefTime < 1500L && !Chipset.Shutdn)
		Sleep(0);

	if (Chipset.Shutdn)						// not timeout, cpu is down
		SwitchToState(3);					// go to sleep state

	return 3 != nNextState;					// state not changed, emulator was busy
}

UINT SwitchToState(UINT nNewState)
{
	UINT  nOldState = nState;

	if (nState == nNewState) return nOldState;
	switch (nState)
	{
	case 0: // Run
		if (hDlgDebug)						// debugger running
		{
			DestroyWindow(hDlgDebug);		// then close debugger to renter emulation
			hDlgDebug = NULL;
		}
		switch (nNewState)
		{
		case 1: // -> Invalid
			nNextState = 1;
			if (Chipset.Shutdn)
				SetEvent(hEventShutdn);
			else
				bInterrupt = TRUE;
			while (nState!=nNextState) Sleep(0);
			UpdateWindowStatus();
			break;
		case 2: // -> Return
			nNextState = 1;
			if (Chipset.Shutdn)
				SetEvent(hEventShutdn);
			else
				bInterrupt = TRUE;
			while (nState!=nNextState) Sleep(0);
			nNextState = 2;
			SetEvent(hEventShutdn);
			while (nState!=nNextState) Sleep(0);
			UpdateWindowStatus();
			break;
		case 3: // -> Sleep
			nNextState = 3;
			if (Chipset.Shutdn)
				SetEvent(hEventShutdn);
			else
				bInterrupt = TRUE;
			while (nState!=nNextState) Sleep(0);
			break;
		}
		break;
	case 1: // Invalid
		switch (nNewState)
		{
		case 0: // -> Run
			nNextState = 0;
			// don't enter opcode loop on interrupt request
			bInterrupt = Chipset.Shutdn || Chipset.SoftInt;
			SetEvent(hEventShutdn);
			while (nState!=nNextState) Sleep(0);
			UpdateWindowStatus();
			break;
		case 2: // -> Return
			nNextState = 2;
			SetEvent(hEventShutdn);
			while (nState!=nNextState) Sleep(0);
			break;
		case 3: // -> Sleep
			nNextState = 3;
			SetEvent(hEventShutdn);
			while (nState!=nNextState) Sleep(0);
			UpdateWindowStatus();
			break;
		}
		break;
	case 3: // Sleep
		switch (nNewState)
		{
		case 0: // -> Run
			nNextState = 0;
			if (Chipset.Shutdn) bInterrupt=TRUE;
			SetEvent(hEventShutdn);
			break;
		case 1: // -> Invalid
			nNextState = 1;
			SetEvent(hEventShutdn);
			while (nState!=nNextState) Sleep(0);
			UpdateWindowStatus();
			break;
		case 2: // -> Return
			nNextState = 1;
			SetEvent(hEventShutdn);
			while (nState!=nNextState) Sleep(0);
			nNextState = 2;
			SetEvent(hEventShutdn);
			while (nState!=nNextState) Sleep(0);
			UpdateWindowStatus();
			break;
		}
		break;
	}
	return nOldState;
}

UINT WorkerThread(LPVOID pParam)
{
	LARGE_INTEGER lDummyInt;				// sample timer ticks
	QueryPerformanceFrequency(&lDummyInt);	// init timer ticks
	lDummyInt.QuadPart /= SAMPLE;			// calculate sample ticks
	dwTickRef = lDummyInt.LowPart;			// sample timer ticks
	_ASSERT(dwTickRef);						// tick resolution error

loop:
	while (nNextState == 1)					// go into invalid state
	{
		CommClose();						// close COM port
		bCommInit = FALSE;					// COM port not open
		nState = 1;							// in invalid state
		WaitForSingleObject(hEventShutdn,INFINITE);
		if (nNextState == 2)				// go into return state
		{
			nState = 2;						// in return state
			return 0;						// kill thread
		}
		ioc_acc = TRUE;						// test if UART on
	}
	while (nNextState == 0)
	{
		if (nState!=0)
		{
			nState = 0;
			// clear port2 status bits
			Chipset.cards_status &= ~(PORT2_PRESENT | PORT2_WRITE);
			if (pbyPort2 || Chipset.Port2)	// card plugged in port2
			{
				Chipset.cards_status |= PORT2_PRESENT;

				if (bPort2Writeable)		// is card writeable
					Chipset.cards_status |= PORT2_WRITE;
			}
			// card detection off and timer running
			if ((Chipset.IORam[CARDCTL] & ECDT) == 0 && (Chipset.IORam[TIMER2_CTRL] & RUN) != 0)
			{
				BOOL bNINT2 = Chipset.IORam[SRQ1] == 0 && (Chipset.IORam[SRQ2] & LSRQ) == 0;
				BOOL bNINT  = (Chipset.IORam[CARDCTL] & SMP) == 0;

				// state of CDT2
				bNINT2 = bNINT2 && (Chipset.cards_status & (P2W|P2C)) != P2C;
				// state of CDT1
				bNINT  = bNINT  && (Chipset.cards_status & (P1W|P1C)) != P1C;

				IOBit(SRQ2,NINT2,bNINT2);
				IOBit(SRQ2,NINT,bNINT);
			}
			RomSwitch(Chipset.Bank_FF);		// select HP49G ROM bank and update memory mapping
			UpdateDisplayPointers();
			UpdateMainDisplay();
			UpdateMenuDisplay();
			UpdateAnnunciators();
			// init speed reference
			dwOldCyc = (DWORD) (Chipset.cycles & 0xFFFFFFFF);
			QueryPerformanceCounter(&lDummyInt);
			dwSpeedRef = lDummyInt.LowPart;
			SetHP48Time();					// update HP48 time & date
			StartTimers();
		}
		PCHANGED;
		while (!bInterrupt)
		{
			if (bDbgEnable)	Debugger();		// debugger active

			EvalOpcode(FASTPTR(Chipset.pc)); // execute opcode

			CheckDisp(!Chipset.Shutdn);		// check for display update
			CheckSerial();					// serial support
			AdjustSpeed();					// adjust emulation speed
		}
		bInterrupt = FALSE;					// be sure to reenter opcode loop

		// enter SHUTDN handler only in RUN mode
		if (Chipset.Shutdn && !(nDbgState == DBG_STEPINTO || nDbgState == DBG_STEPOVER))
		{
			if (!Chipset.SoftInt)			// ignore SHUTDN on interrupt request
				WaitForSingleObject(hEventShutdn,INFINITE);
			else
				Chipset.bShutdnWake = TRUE;	// waked by interrupt

			if (Chipset.bShutdnWake)		// waked up by timer, keyboard or serial
			{
				Chipset.bShutdnWake = FALSE;
				Chipset.Shutdn = FALSE;
				// init speed reference
				dwOldCyc = (DWORD) (Chipset.cycles & 0xFFFFFFFF);
				QueryPerformanceCounter(&lDummyInt);
				dwSpeedRef = lDummyInt.LowPart;
			}
		}
		if (Chipset.SoftInt)
		{
			Chipset.SoftInt = FALSE;
			if (Chipset.inte)
			{
				Chipset.inte = FALSE;
				rstkpush(Chipset.pc);
				Chipset.pc = 0xf;
			}
		}
	}
	_ASSERT(nNextState != 0);

	StopTimers();

	while (nNextState == 3)					// go into sleep state
	{
		nState = 3;							// in sleep state
		WaitForSingleObject(hEventShutdn,INFINITE);
	}
	goto loop;
	UNREFERENCED_PARAMETER(pParam);
}