/* INCLUDES *******************************************************************/
+#define NDEBUG
+
#include "emulator.h"
#include "bios.h"
#include "dos.h"
+#include "vga.h"
#include "pic.h"
#include "ps2.h"
#include "timer.h"
softx86_ctx EmulatorContext;
softx87_ctx FpuEmulatorContext;
#else
-EMULATOR_CONTEXT EmulatorContext;
+SOFT386_STATE EmulatorContext;
#endif
static BOOLEAN A20Line = FALSE;
/* PRIVATE FUNCTIONS **********************************************************/
-#ifndef NEW_EMULATOR
-
-static VOID EmulatorReadMemory(PVOID Context, UINT Address, LPBYTE Buffer, INT Size)
+static VOID NTVDMCALL EmulatorReadMemory(PVOID Context, UINT Address, LPBYTE Buffer, INT Size)
{
+ UNREFERENCED_PARAMETER(Context);
+
/* If the A20 line is disabled, mask bit 20 */
if (!A20Line) Address &= ~(1 << 20);
/* Make sure the requested address is valid */
if ((Address + Size) >= MAX_ADDRESS) return;
- /* Are we reading some of the console video memory? */
- if (((Address + Size) >= BiosGetVideoMemoryStart())
- && (Address < CONSOLE_VIDEO_MEM_END))
- {
- /* Call the VDM BIOS to update the video memory */
- BiosUpdateVideoMemory(max(Address, BiosGetVideoMemoryStart()),
- min(Address + Size, CONSOLE_VIDEO_MEM_END));
- }
-
/* Read the data from the virtual address space and store it in the buffer */
RtlCopyMemory(Buffer, (LPVOID)((ULONG_PTR)BaseAddress + Address), Size);
+
+ /* Check if we modified the console video memory */
+ if (((Address + Size) >= VgaGetVideoBaseAddress())
+ && (Address < VgaGetVideoLimitAddress()))
+ {
+ DWORD VgaAddress = max(Address, VgaGetVideoBaseAddress());
+ LPBYTE VgaBuffer = &Buffer[VgaAddress - Address];
+
+ /* Read from the VGA memory */
+ VgaReadMemory(VgaAddress, VgaBuffer, Size);
+ }
}
-static VOID EmulatorWriteMemory(PVOID Context, UINT Address, LPBYTE Buffer, INT Size)
+static VOID NTVDMCALL EmulatorWriteMemory(PVOID Context, UINT Address, LPBYTE Buffer, INT Size)
{
+ UNREFERENCED_PARAMETER(Context);
+
/* If the A20 line is disabled, mask bit 20 */
if (!A20Line) Address &= ~(1 << 20);
RtlCopyMemory((LPVOID)((ULONG_PTR)BaseAddress + Address), Buffer, Size);
/* Check if we modified the console video memory */
- if (((Address + Size) >= BiosGetVideoMemoryStart())
- && (Address < CONSOLE_VIDEO_MEM_END))
+ if (((Address + Size) >= VgaGetVideoBaseAddress())
+ && (Address < VgaGetVideoLimitAddress()))
{
- /* Call the VDM BIOS to update the screen */
- BiosUpdateConsole(max(Address, BiosGetVideoMemoryStart()),
- min(Address + Size, CONSOLE_VIDEO_MEM_END));
+ DWORD VgaAddress = max(Address, VgaGetVideoBaseAddress());
+ LPBYTE VgaBuffer = &Buffer[VgaAddress - Address];
+
+ /* Write to the VGA memory */
+ VgaWriteMemory(VgaAddress, VgaBuffer, Size);
}
}
-static VOID EmulatorReadIo(PVOID Context, UINT Address, LPBYTE Buffer, INT Size)
+static VOID NTVDMCALL EmulatorReadIo(PVOID Context, UINT Address, LPBYTE Buffer, INT Size)
{
+ UNREFERENCED_PARAMETER(Context);
+ UNREFERENCED_PARAMETER(Size);
+
switch (Address)
{
case PIC_MASTER_CMD:
*Buffer = KeyboardReadData();
break;
}
+
+ case VGA_AC_WRITE:
+ case VGA_AC_READ:
+ case VGA_SEQ_INDEX:
+ case VGA_SEQ_DATA:
+ case VGA_DAC_READ_INDEX:
+ case VGA_DAC_WRITE_INDEX:
+ case VGA_DAC_DATA:
+ case VGA_MISC_READ:
+ case VGA_MISC_WRITE:
+ case VGA_CRTC_INDEX:
+ case VGA_CRTC_DATA:
+ case VGA_GC_INDEX:
+ case VGA_GC_DATA:
+ case VGA_STAT_MONO:
+ case VGA_STAT_COLOR:
+ {
+ *Buffer = VgaReadPort(Address);
+ break;
+ }
+
+ default:
+ {
+ DPRINT1("Read from unknown port: 0x%X\n", Address);
+ }
}
}
-static VOID EmulatorWriteIo(PVOID Context, UINT Address, LPBYTE Buffer, INT Size)
+static VOID NTVDMCALL EmulatorWriteIo(PVOID Context, UINT Address, LPBYTE Buffer, INT Size)
{
BYTE Byte = *Buffer;
+ UNREFERENCED_PARAMETER(Context);
+ UNREFERENCED_PARAMETER(Size);
+
switch (Address)
{
case PIT_COMMAND_PORT:
KeyboardWriteData(Byte);
break;
}
+
+ case VGA_AC_WRITE:
+ case VGA_AC_READ:
+ case VGA_SEQ_INDEX:
+ case VGA_SEQ_DATA:
+ case VGA_DAC_READ_INDEX:
+ case VGA_DAC_WRITE_INDEX:
+ case VGA_DAC_DATA:
+ case VGA_MISC_READ:
+ case VGA_MISC_WRITE:
+ case VGA_CRTC_INDEX:
+ case VGA_CRTC_DATA:
+ case VGA_GC_INDEX:
+ case VGA_GC_DATA:
+ case VGA_STAT_MONO:
+ case VGA_STAT_COLOR:
+ {
+ VgaWritePort(Address, Byte);
+ break;
+ }
+
+ default:
+ {
+ DPRINT1("Write to unknown port: 0x%X\n", Address);
+ }
}
}
-static VOID EmulatorSoftwareInt(PVOID Context, BYTE Number)
+static VOID EmulatorBop(WORD Code)
{
WORD StackSegment, StackPointer, CodeSegment, InstructionPointer;
BYTE IntNum;
+ LPWORD Stack;
- /* Check if this is the special interrupt */
- if (Number == SPECIAL_INT_NUM)
- {
- /* Get the SS:SP */
+ /* Get the SS:SP */
#ifndef NEW_EMULATOR
- StackSegment = EmulatorContext.state->segment_reg[SX86_SREG_SS].val;
- StackPointer = EmulatorContext.state->general_reg[SX86_REG_SP].val;
+ StackSegment = EmulatorContext.state->segment_reg[SX86_SREG_SS].val;
+ StackPointer = EmulatorContext.state->general_reg[SX86_REG_SP].val;
#else
- StackSegment = EmulatorContext.Registers[EMULATOR_REG_SS].LowWord;
- StackPointer = EmulatorContext.Registers[EMULATOR_REG_SP].LowWord;
+ StackSegment = EmulatorContext.SegmentRegs[SOFT386_REG_SS].Selector;
+ StackPointer = EmulatorContext.GeneralRegs[SOFT386_REG_ESP].LowWord;
#endif
- /* Get the interrupt number */
- IntNum = *(LPBYTE)((ULONG_PTR)BaseAddress + TO_LINEAR(StackSegment, StackPointer));
+ /* Get the stack */
+ Stack = (LPWORD)((ULONG_PTR)BaseAddress + TO_LINEAR(StackSegment, StackPointer));
- /* Move the stack pointer forward one word to skip the interrupt number */
- StackPointer += sizeof(WORD);
+ if (Code == EMULATOR_INT_BOP)
+ {
+ /* Get the interrupt number */
+ IntNum = LOBYTE(Stack[STACK_INT_NUM]);
/* Get the CS:IP */
- InstructionPointer = *(LPWORD)((ULONG_PTR)BaseAddress
- + TO_LINEAR(StackSegment, StackPointer));
- CodeSegment = *(LPWORD)((ULONG_PTR)BaseAddress
- + TO_LINEAR(StackSegment, StackPointer + sizeof(WORD)));
+ InstructionPointer = Stack[STACK_IP];
+ CodeSegment = Stack[STACK_CS];
/* Check if this was an exception */
if (IntNum < 8)
if (IntNum >= BIOS_PIC_MASTER_INT && IntNum < BIOS_PIC_MASTER_INT + 8)
{
/* It was an IRQ from the master PIC */
- BiosHandleIrq(IntNum - BIOS_PIC_MASTER_INT);
+ BiosHandleIrq(IntNum - BIOS_PIC_MASTER_INT, Stack);
return;
}
else if (IntNum >= BIOS_PIC_SLAVE_INT && IntNum < BIOS_PIC_SLAVE_INT + 8)
{
/* It was an IRQ from the slave PIC */
- BiosHandleIrq(IntNum - BIOS_PIC_SLAVE_INT + 8);
+ BiosHandleIrq(IntNum - BIOS_PIC_SLAVE_INT + 8, Stack);
return;
}
case BIOS_VIDEO_INTERRUPT:
{
/* This is the video BIOS interrupt, call the BIOS */
- BiosVideoService();
+ BiosVideoService(Stack);
break;
}
case BIOS_EQUIPMENT_INTERRUPT:
{
/* This is the BIOS "get equipment" command, call the BIOS */
- BiosEquipmentService();
+ BiosEquipmentService(Stack);
break;
}
case BIOS_KBD_INTERRUPT:
{
/* This is the keyboard BIOS interrupt, call the BIOS */
- BiosKeyboardService();
+ BiosKeyboardService(Stack);
break;
}
case BIOS_TIME_INTERRUPT:
{
/* This is the time BIOS interrupt, call the BIOS */
- BiosTimeService();
+ BiosTimeService(Stack);
break;
}
case BIOS_SYS_TIMER_INTERRUPT:
{
/* BIOS timer update */
- BiosSystemTimerInterrupt();
+ BiosSystemTimerInterrupt(Stack);
break;
}
case 0x20:
{
- DosInt20h(CodeSegment);
+ DosInt20h(Stack);
break;
}
case 0x21:
{
- DosInt21h(CodeSegment);
+ DosInt21h(Stack);
break;
}
case 0x23:
{
- DosBreakInterrupt();
+ DosBreakInterrupt(Stack);
break;
}
default:
}
}
+#ifdef NEW_EMULATOR
+static VOID WINAPI EmulatorBiosOperation(PSOFT386_STATE State, WORD Code)
+{
+ /*
+ * HACK: To maintain softx86 compatbility, just call the old EmulatorBop here.
+ * Later on, when softx86 is no longer needed, the code from EmulatorBop should
+ * be moved here and should use the "State" variable.
+ */
+ EmulatorBop(Code);
+}
+
+#endif
+
+#ifndef NEW_EMULATOR
+
+static VOID EmulatorSoftwareInt(PVOID Context, BYTE Number)
+{
+ UNREFERENCED_PARAMETER(Context);
+ UNREFERENCED_PARAMETER(Number);
+
+ /* Do nothing */
+}
+
static VOID EmulatorHardwareInt(PVOID Context, BYTE Number)
{
+ UNREFERENCED_PARAMETER(Context);
+ UNREFERENCED_PARAMETER(Number);
+
/* Do nothing */
}
static VOID EmulatorHardwareIntAck(PVOID Context, BYTE Number)
{
+ UNREFERENCED_PARAMETER(Context);
+ UNREFERENCED_PARAMETER(Number);
+
/* Do nothing */
}
/* Connect the emulated FPU to the emulated CPU */
softx87_connect_to_CPU(&EmulatorContext, &FpuEmulatorContext);
#else
- // TODO: NOT IMPLEMENTED
+ /* Set the callbacks */
+ EmulatorContext.MemReadCallback = (SOFT386_MEM_READ_PROC)EmulatorReadMemory;
+ EmulatorContext.MemWriteCallback = (SOFT386_MEM_WRITE_PROC)EmulatorWriteMemory;
+ EmulatorContext.IoReadCallback = (SOFT386_IO_READ_PROC)EmulatorReadIo;
+ EmulatorContext.IoWriteCallback = (SOFT386_IO_WRITE_PROC)EmulatorWriteIo;
+ EmulatorContext.BopCallback = (SOFT386_BOP_PROC)EmulatorBiosOperation;
+
+ /* Reset the CPU */
+ Soft386Reset(&EmulatorContext);
#endif
/* Enable interrupts */
return TRUE;
}
-VOID EmulatorSetStack(WORD Segment, WORD Offset)
+VOID EmulatorSetStack(WORD Segment, DWORD Offset)
{
#ifndef NEW_EMULATOR
/* Call the softx86 API */
softx86_set_stack_ptr(&EmulatorContext, Segment, Offset);
#else
- // TODO: NOT IMPLEMENTED
+ Soft386SetStack(&EmulatorContext, Segment, Offset);
#endif
}
+// FIXME: This function assumes 16-bit mode!!!
VOID EmulatorExecute(WORD Segment, WORD Offset)
{
#ifndef NEW_EMULATOR
/* Call the softx86 API */
softx86_set_instruction_ptr(&EmulatorContext, Segment, Offset);
#else
- // TODO: NOT IMPLEMENTED
+ /* Tell Soft386 to move the instruction pointer */
+ Soft386ExecuteAt(&EmulatorContext, Segment, Offset);
#endif
}
return EmulatorContext.state->segment_reg[Register - EMULATOR_REG_ES].val;
}
#else
- return EmulatorContext.Registers[Register].Long;
+ if (Register < EMULATOR_REG_ES)
+ {
+ return EmulatorContext.GeneralRegs[Register].Long;
+ }
+ else
+ {
+ return EmulatorContext.SegmentRegs[Register - EMULATOR_REG_ES].Selector;
+ }
+#endif
+}
+
+ULONG EmulatorGetProgramCounter(VOID)
+{
+#ifndef NEW_EMULATOR
+ return EmulatorContext.state->reg_ip;
+#else
+ return EmulatorContext.InstPtr.Long;
#endif
}
}
else
{
- EmulatorContext.state->segment_reg[Register - EMULATOR_REG_ES].val = Value;
+ EmulatorContext.state->segment_reg[Register - EMULATOR_REG_ES].val = (WORD)Value;
}
#else
// TODO: NOT IMPLEMENTED
#endif
}
-VOID EmulatorStep()
+VOID EmulatorStep(VOID)
{
#ifndef NEW_EMULATOR
+ LPWORD Instruction;
+
/* Print the current position - useful for debugging */
DPRINT("Executing at CS:IP = %04X:%04X\n",
EmulatorGetRegister(EMULATOR_REG_CS),
EmulatorContext.state->reg_ip);
+ Instruction = (LPWORD)((ULONG_PTR)BaseAddress
+ + TO_LINEAR(EmulatorGetRegister(EMULATOR_REG_CS),
+ EmulatorContext.state->reg_ip));
+
+ /* Check for the BIOS operation (BOP) sequence */
+ if (Instruction[0] == EMULATOR_BOP)
+ {
+ /* Skip the opcodes */
+ EmulatorContext.state->reg_ip += 4;
+
+ // HACK: Refresh the display because the called function may wait.
+ VgaRefreshDisplay();
+
+ /* Call the BOP handler */
+ EmulatorBop(Instruction[1]);
+ }
+
/* Call the softx86 API */
if (!softx86_step(&EmulatorContext))
{
EmulatorInterrupt(EMULATOR_EXCEPTION_INVALID_OPCODE);
}
#else
- // TODO: NOT IMPLEMENTED
+ /* Dump the state for debugging purposes */
+ Soft386DumpState(&EmulatorContext);
+
+ /* Execute the next instruction */
+ Soft386StepInto(&EmulatorContext);
#endif
}
-VOID EmulatorCleanup()
+VOID EmulatorCleanup(VOID)
{
- /* Free the memory allocated for the 16-bit address space */
- if (BaseAddress != NULL) HeapFree(GetProcessHeap(), 0, BaseAddress);
-
#ifndef NEW_EMULATOR
/* Free the softx86 CPU and FPU emulator */
- softx86_free(&EmulatorContext);
softx87_free(&FpuEmulatorContext);
+ softx86_free(&EmulatorContext);
#endif
+
+ /* Free the memory allocated for the 16-bit address space */
+ if (BaseAddress != NULL) HeapFree(GetProcessHeap(), 0, BaseAddress);
}
VOID EmulatorSetA20(BOOLEAN Enabled)