#define NDEBUG
#include "emulator.h"
-#include "bios.h"
+#include "callback.h"
+
+#include "clock.h"
+#include "bios/rom.h"
+#include "hardware/cmos.h"
+#include "hardware/pic.h"
+#include "hardware/ps2.h"
+#include "hardware/speaker.h"
+#include "hardware/timer.h"
+#include "hardware/vga.h"
+
#include "bop.h"
-#include "dos.h"
-#include "speaker.h"
-#include "vga.h"
-#include "pic.h"
-#include "ps2.h"
-#include "timer.h"
-#include "cmos.h"
+#include "vddsup.h"
+#include "io.h"
+
+#include <isvbop.h>
/* PRIVATE VARIABLES **********************************************************/
FAST486_STATE EmulatorContext;
+BOOLEAN CpuSimulate = FALSE;
+
+/* No more than 'MaxCpuCallLevel' recursive CPU calls are allowed */
+const static INT MaxCpuCallLevel = 32;
+static INT CpuCallLevel = 0;
+
+LPVOID BaseAddress = NULL;
+BOOLEAN VdmRunning = TRUE;
-static BOOLEAN A20Line = FALSE;
+static BOOLEAN A20Line = FALSE;
+static BYTE Port61hState = 0x00;
+
+static HANDLE InputThread = NULL;
+
+LPCWSTR ExceptionName[] =
+{
+ L"Division By Zero",
+ L"Debug",
+ L"Unexpected Error",
+ L"Breakpoint",
+ L"Integer Overflow",
+ L"Bound Range Exceeded",
+ L"Invalid Opcode",
+ L"FPU Not Available"
+};
+
+/* BOP Identifiers */
+#define BOP_DEBUGGER 0x56 // Break into the debugger from a 16-bit app
/* PRIVATE FUNCTIONS **********************************************************/
-static VOID WINAPI EmulatorReadMemory(PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
+VOID WINAPI EmulatorReadMemory(PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
{
UNREFERENCED_PARAMETER(State);
+ // BIG HACK!!!! To make BIOS images working correctly,
+ // until Aleksander rewrites memory management!!
+ if (Address >= 0xFFFFFFF0) Address -= 0xFFF00000;
+
/* 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;
- /* 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 */
+ /*
+ * Check if we are going to read the VGA memory and
+ * copy it into the virtual address space if needed.
+ */
if (((Address + Size) >= VgaGetVideoBaseAddress())
&& (Address < VgaGetVideoLimitAddress()))
{
DWORD VgaAddress = max(Address, VgaGetVideoBaseAddress());
- LPBYTE VgaBuffer = (LPBYTE)((ULONG_PTR)Buffer + VgaAddress - Address);
+ DWORD ActualSize = min(Address + Size - 1, VgaGetVideoLimitAddress())
+ - VgaAddress + 1;
+ LPBYTE DestBuffer = (LPBYTE)REAL_TO_PHYS(VgaAddress);
/* Read from the VGA memory */
- VgaReadMemory(VgaAddress, VgaBuffer, Size);
+ VgaReadMemory(VgaAddress, DestBuffer, ActualSize);
}
+
+ /* Read the data from the virtual address space and store it in the buffer */
+ RtlCopyMemory(Buffer, REAL_TO_PHYS(Address), Size);
}
-static VOID WINAPI EmulatorWriteMemory(PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
+VOID WINAPI EmulatorWriteMemory(PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
{
UNREFERENCED_PARAMETER(State);
+ // BIG HACK!!!! To make BIOS images working correctly,
+ // until Aleksander rewrites memory management!!
+ if (Address >= 0xFFFFFFF0) Address -= 0xFFF00000;
+
/* If the A20 line is disabled, mask bit 20 */
if (!A20Line) Address &= ~(1 << 20);
if ((Address + Size) >= ROM_AREA_START && (Address < ROM_AREA_END)) return;
/* Read the data from the buffer and store it in the virtual address space */
- RtlCopyMemory((LPVOID)((ULONG_PTR)BaseAddress + Address), Buffer, Size);
+ RtlCopyMemory(REAL_TO_PHYS(Address), Buffer, Size);
- /* Check if we modified the console video memory */
+ /*
+ * Check if we modified the VGA memory.
+ */
if (((Address + Size) >= VgaGetVideoBaseAddress())
&& (Address < VgaGetVideoLimitAddress()))
{
DWORD VgaAddress = max(Address, VgaGetVideoBaseAddress());
- LPBYTE VgaBuffer = (LPBYTE)((ULONG_PTR)Buffer + VgaAddress - Address);
+ DWORD ActualSize = min(Address + Size - 1, VgaGetVideoLimitAddress())
+ - VgaAddress + 1;
+ LPBYTE SrcBuffer = (LPBYTE)REAL_TO_PHYS(VgaAddress);
/* Write to the VGA memory */
- VgaWriteMemory(VgaAddress, VgaBuffer, Size);
+ VgaWriteMemory(VgaAddress, SrcBuffer, ActualSize);
}
}
-static VOID WINAPI EmulatorReadIo(PFAST486_STATE State, ULONG Port, PVOID Buffer, ULONG Size, UCHAR Width)
+UCHAR WINAPI EmulatorIntAcknowledge(PFAST486_STATE State)
{
- INT i, j;
- LPBYTE Address = (LPBYTE)Buffer;
-
UNREFERENCED_PARAMETER(State);
- for (i = 0; i < Size; i++) for (j = 0; j < Width; j++)
- {
- ULONG CurrentPort = Port + j;
-
- switch (CurrentPort)
- {
- case PIC_MASTER_CMD:
- case PIC_SLAVE_CMD:
- {
- *(Address++) = PicReadCommand(CurrentPort);
- break;
- }
-
- case PIC_MASTER_DATA:
- case PIC_SLAVE_DATA:
- {
- *(Address++) = PicReadData(CurrentPort);
- break;
- }
-
- case PIT_DATA_PORT(0):
- case PIT_DATA_PORT(1):
- case PIT_DATA_PORT(2):
- {
- *(Address++) = PitReadData(CurrentPort - PIT_DATA_PORT(0));
- break;
- }
-
- case PS2_CONTROL_PORT:
- {
- *(Address++) = KeyboardReadStatus();
- break;
- }
-
- case PS2_DATA_PORT:
- {
- *(Address++) = KeyboardReadData();
- break;
- }
-
- case CMOS_DATA_PORT:
- {
- *(Address++) = CmosReadData();
- break;
- }
-
- case SPEAKER_CONTROL_PORT:
- {
- *(Address++) = SpeakerReadStatus();
- 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:
- {
- *(Address++) = VgaReadPort(CurrentPort);
- break;
- }
-
- default:
- {
- DPRINT1("Read from unknown port: 0x%X\n", CurrentPort);
- }
- }
- }
+ /* Get the interrupt number from the PIC */
+ return PicGetInterrupt();
}
-static VOID WINAPI EmulatorWriteIo(PFAST486_STATE State, ULONG Port, PVOID Buffer, ULONG Size, UCHAR Width)
+VOID EmulatorException(BYTE ExceptionNumber, LPWORD Stack)
{
- INT i, j;
- LPBYTE Address = (LPBYTE)Buffer;
+ WORD CodeSegment, InstructionPointer;
+ PBYTE Opcode;
+
+ ASSERT(ExceptionNumber < 8);
+
+ /* Get the CS:IP */
+ InstructionPointer = Stack[STACK_IP];
+ CodeSegment = Stack[STACK_CS];
+ Opcode = (PBYTE)SEG_OFF_TO_PTR(CodeSegment, InstructionPointer);
+
+ /* Display a message to the user */
+ DisplayMessage(L"Exception: %s occured at %04X:%04X\n"
+ L"Opcode: %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X",
+ ExceptionName[ExceptionNumber],
+ CodeSegment,
+ InstructionPointer,
+ Opcode[0],
+ Opcode[1],
+ Opcode[2],
+ Opcode[3],
+ Opcode[4],
+ Opcode[5],
+ Opcode[6],
+ Opcode[7],
+ Opcode[8],
+ Opcode[9]);
+
+ /* Stop the VDM */
+ VdmRunning = FALSE;
+ return;
+}
- UNREFERENCED_PARAMETER(State);
+// FIXME: This function assumes 16-bit mode!!!
+VOID EmulatorExecute(WORD Segment, WORD Offset)
+{
+ /* Tell Fast486 to move the instruction pointer */
+ Fast486ExecuteAt(&EmulatorContext, Segment, Offset);
+}
- for (i = 0; i < Size; i++) for (j = 0; j < Width; j++)
- {
- ULONG CurrentPort = Port + j;
-
- switch (CurrentPort)
- {
- case PIT_COMMAND_PORT:
- {
- PitWriteCommand(*(Address++));
- break;
- }
-
- case PIT_DATA_PORT(0):
- case PIT_DATA_PORT(1):
- case PIT_DATA_PORT(2):
- {
- PitWriteData(CurrentPort - PIT_DATA_PORT(0), *(Address++));
- break;
- }
-
- case PIC_MASTER_CMD:
- case PIC_SLAVE_CMD:
- {
- PicWriteCommand(CurrentPort, *(Address++));
- break;
- }
-
- case PIC_MASTER_DATA:
- case PIC_SLAVE_DATA:
- {
- PicWriteData(CurrentPort, *(Address++));
- break;
- }
-
- case PS2_CONTROL_PORT:
- {
- KeyboardWriteCommand(*(Address++));
- break;
- }
-
- case PS2_DATA_PORT:
- {
- KeyboardWriteData(*(Address++));
- break;
- }
-
- case CMOS_ADDRESS_PORT:
- {
- CmosWriteAddress(*(Address++));
- break;
- }
-
- case CMOS_DATA_PORT:
- {
- CmosWriteData(*(Address++));
- break;
- }
-
- case SPEAKER_CONTROL_PORT:
- {
- SpeakerWriteCommand(*(Address++));
- 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(CurrentPort, *(Address++));
- break;
- }
-
- default:
- {
- DPRINT1("Write to unknown port: 0x%X\n", CurrentPort);
- }
- }
- }
+VOID EmulatorStep(VOID)
+{
+ /* Dump the state for debugging purposes */
+ // Fast486DumpState(&EmulatorContext);
+
+ /* Execute the next instruction */
+ Fast486StepInto(&EmulatorContext);
}
-static VOID WINAPI EmulatorBiosOperation(PFAST486_STATE State, UCHAR BopCode)
+VOID EmulatorSimulate(VOID)
{
- WORD StackSegment, StackPointer;
- LPWORD Stack;
+ if (CpuCallLevel > MaxCpuCallLevel)
+ {
+ DisplayMessage(L"Too many CPU levels of recursion (%d, expected maximum %d)",
+ CpuCallLevel, MaxCpuCallLevel);
- /* Get the SS:SP */
- StackSegment = State->SegmentRegs[FAST486_REG_SS].Selector;
- StackPointer = State->GeneralRegs[FAST486_REG_ESP].LowWord;
+ /* Stop the VDM */
+ VdmRunning = FALSE;
+ return;
+ }
+ CpuCallLevel++;
- /* Get the stack */
- Stack = (LPWORD)SEG_OFF_TO_PTR(StackSegment, StackPointer);
+ CpuSimulate = TRUE;
+ while (VdmRunning && CpuSimulate) ClockUpdate();
- if (BopProc[BopCode] != NULL)
- BopProc[BopCode](Stack);
- else
- DPRINT1("Invalid BOP code %u\n", BopCode);
+ CpuCallLevel--;
+ if (CpuCallLevel < 0) CpuCallLevel = 0;
+
+ /* This takes into account for reentrance */
+ CpuSimulate = TRUE;
}
-static UCHAR WINAPI EmulatorIntAcknowledge(PFAST486_STATE State)
+VOID EmulatorUnsimulate(VOID)
{
- UNREFERENCED_PARAMETER(State);
-
- /* Get the interrupt number from the PIC */
- return PicGetInterrupt();
+ /* Stop simulation */
+ CpuSimulate = FALSE;
}
-/* PUBLIC FUNCTIONS ***********************************************************/
-
-BOOLEAN EmulatorInitialize(VOID)
+VOID EmulatorInterrupt(BYTE Number)
{
- /* Allocate memory for the 16-bit address space */
- BaseAddress = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, MAX_ADDRESS);
- if (BaseAddress == NULL) return FALSE;
-
- /* Initialize the CPU */
- Fast486Initialize(&EmulatorContext,
- EmulatorReadMemory,
- EmulatorWriteMemory,
- EmulatorReadIo,
- EmulatorWriteIo,
- NULL,
- EmulatorBiosOperation,
- EmulatorIntAcknowledge);
+ /* Call the Fast486 API */
+ Fast486Interrupt(&EmulatorContext, Number);
+}
- /* Enable interrupts */
- EmulatorSetFlag(EMULATOR_FLAG_IF);
+VOID EmulatorInterruptSignal(VOID)
+{
+ /* Call the Fast486 API */
+ Fast486InterruptSignal(&EmulatorContext);
+}
- return TRUE;
+VOID EmulatorSetA20(BOOLEAN Enabled)
+{
+ A20Line = Enabled;
}
-VOID EmulatorCleanup(VOID)
+VOID WINAPI EmulatorDebugBreakBop(LPWORD Stack)
{
- /* Free the memory allocated for the 16-bit address space */
- if (BaseAddress != NULL) HeapFree(GetProcessHeap(), 0, BaseAddress);
+ DPRINT1("NTVDM: BOP_DEBUGGER\n");
+ DebugBreak();
}
-VOID EmulatorSetStack(WORD Segment, DWORD Offset)
+VOID WINAPI EmulatorUnsimulateBop(LPWORD Stack)
{
- Fast486SetStack(&EmulatorContext, Segment, Offset);
+ EmulatorUnsimulate();
}
-// FIXME: This function assumes 16-bit mode!!!
-VOID EmulatorExecute(WORD Segment, WORD Offset)
+static BYTE WINAPI Port61hRead(ULONG Port)
{
- /* Tell Fast486 to move the instruction pointer */
- Fast486ExecuteAt(&EmulatorContext, Segment, Offset);
+ return Port61hState;
}
-VOID EmulatorInterrupt(BYTE Number)
+static VOID WINAPI Port61hWrite(ULONG Port, BYTE Data)
{
- /* Call the Fast486 API */
- Fast486Interrupt(&EmulatorContext, Number);
+ // BOOLEAN SpeakerChange = FALSE;
+ BYTE OldPort61hState = Port61hState;
+
+ /* Only the four lowest bytes can be written */
+ Port61hState = (Port61hState & 0xF0) | (Data & 0x0F);
+
+ if ((OldPort61hState ^ Port61hState) & 0x01)
+ {
+ DPRINT("PIT 2 Gate %s\n", Port61hState & 0x01 ? "on" : "off");
+ // SpeakerChange = TRUE;
+ }
+
+ PitSetGate(2, !!(Port61hState & 0x01));
+
+ if ((OldPort61hState ^ Port61hState) & 0x02)
+ {
+ /* There were some change for the speaker... */
+ DPRINT("Speaker %s\n", Port61hState & 0x02 ? "on" : "off");
+ // SpeakerChange = TRUE;
+ }
+ // if (SpeakerChange) SpeakerChange();
+ SpeakerChange();
}
-VOID EmulatorInterruptSignal(VOID)
+static VOID WINAPI PitChan0Out(LPVOID Param, BOOLEAN State)
{
- /* Call the Fast486 API */
- Fast486InterruptSignal(&EmulatorContext);
+ if (State)
+ {
+ DPRINT("PicInterruptRequest\n");
+ PicInterruptRequest(0); // Raise IRQ 0
+ }
+ // else < Lower IRQ 0 >
}
-ULONG EmulatorGetRegister(ULONG Register)
+static VOID WINAPI PitChan1Out(LPVOID Param, BOOLEAN State)
{
- if (Register < EMULATOR_REG_ES)
+#if 0
+ if (State)
{
- return EmulatorContext.GeneralRegs[Register].Long;
+ /* Set bit 4 of Port 61h */
+ Port61hState |= 1 << 4;
}
else
{
- return EmulatorContext.SegmentRegs[Register - EMULATOR_REG_ES].Selector;
+ /* Clear bit 4 of Port 61h */
+ Port61hState &= ~(1 << 4);
}
+#else
+ Port61hState = (Port61hState & 0xEF) | (State << 4);
+#endif
}
-VOID EmulatorSetRegister(ULONG Register, ULONG Value)
+static VOID WINAPI PitChan2Out(LPVOID Param, BOOLEAN State)
{
- if (Register < EMULATOR_REG_ES)
+ // BYTE OldPort61hState = Port61hState;
+
+#if 0
+ if (State)
{
- EmulatorContext.GeneralRegs[Register].Long = Value;
+ /* Set bit 5 of Port 61h */
+ Port61hState |= 1 << 5;
}
else
{
- Fast486SetSegment(&EmulatorContext, Register - EMULATOR_REG_ES, (USHORT)Value);
+ /* Clear bit 5 of Port 61h */
+ Port61hState &= ~(1 << 5);
}
+#else
+ Port61hState = (Port61hState & 0xDF) | (State << 5);
+#endif
+ DPRINT("Speaker PIT out\n");
+ // if ((OldPort61hState ^ Port61hState) & 0x20)
+ // SpeakerChange();
}
-ULONG EmulatorGetProgramCounter(VOID)
+/* PUBLIC FUNCTIONS ***********************************************************/
+
+DWORD WINAPI PumpConsoleInput(LPVOID Parameter);
+
+BOOLEAN EmulatorInitialize(HANDLE ConsoleInput, HANDLE ConsoleOutput)
{
- return EmulatorContext.InstPtr.Long;
+ /* Allocate memory for the 16-bit address space */
+ BaseAddress = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, MAX_ADDRESS);
+ if (BaseAddress == NULL)
+ {
+ wprintf(L"FATAL: Failed to allocate VDM memory.\n");
+ return FALSE;
+ }
+
+ /* Initialize I/O ports */
+ /* Initialize RAM */
+
+ /* Initialize the internal clock */
+ if (!ClockInitialize())
+ {
+ wprintf(L"FATAL: Failed to initialize the clock\n");
+ return FALSE;
+ }
+
+ /* Initialize the CPU */
+ Fast486Initialize(&EmulatorContext,
+ EmulatorReadMemory,
+ EmulatorWriteMemory,
+ EmulatorReadIo,
+ EmulatorWriteIo,
+ NULL,
+ EmulatorBiosOperation,
+ EmulatorIntAcknowledge,
+ NULL /* TODO: Use a TLB */);
+
+ /* Initialize DMA */
+
+ /* Initialize the PIC, the PIT, the CMOS and the PC Speaker */
+ PicInitialize();
+ PitInitialize();
+ CmosInitialize();
+ SpeakerInitialize();
+
+ /* Set output functions */
+ PitSetOutFunction(0, NULL, PitChan0Out);
+ PitSetOutFunction(1, NULL, PitChan1Out);
+ PitSetOutFunction(2, NULL, PitChan2Out);
+
+ /* Register the I/O Ports */
+ RegisterIoPort(CONTROL_SYSTEM_PORT61H, Port61hRead, Port61hWrite);
+
+ /* Initialize the PS2 port */
+ PS2Initialize(ConsoleInput);
+
+ /* Set the console input mode */
+ // FIXME: Activate ENABLE_WINDOW_INPUT when we will want to perform actions
+ // upon console window events (screen buffer resize, ...).
+ SetConsoleMode(ConsoleInput, ENABLE_PROCESSED_INPUT /* | ENABLE_WINDOW_INPUT */);
+
+ /* Start the input thread */
+ InputThread = CreateThread(NULL, 0, &PumpConsoleInput, ConsoleInput, 0, NULL);
+ // if (InputThread == NULL) return FALSE;
+
+ /* Initialize the VGA */
+ // if (!VgaInitialize(ConsoleOutput)) return FALSE;
+ VgaInitialize(ConsoleOutput);
+
+ /* Initialize the software callback system and register the emulator BOPs */
+ InitializeCallbacks();
+ RegisterBop(BOP_DEBUGGER , EmulatorDebugBreakBop);
+ RegisterBop(BOP_UNSIMULATE, EmulatorUnsimulateBop);
+
+ /* Initialize VDD support */
+ VDDSupInitialize();
+
+ return TRUE;
+}
+
+VOID EmulatorCleanup(VOID)
+{
+ VgaCleanup();
+
+ /* Close the input thread handle */
+ if (InputThread != NULL) CloseHandle(InputThread);
+ InputThread = NULL;
+
+ PS2Cleanup();
+
+ SpeakerCleanup();
+ CmosCleanup();
+ // PitCleanup();
+ // PicCleanup();
+
+ // Fast486Cleanup();
+
+ /* Free the memory allocated for the 16-bit address space */
+ if (BaseAddress != NULL) HeapFree(GetProcessHeap(), 0, BaseAddress);
}
-BOOLEAN EmulatorGetFlag(ULONG Flag)
+
+
+VOID
+WINAPI
+VDDSimulate16(VOID)
{
- return (EmulatorContext.Flags.Long & Flag) ? TRUE : FALSE;
+ EmulatorSimulate();
}
-VOID EmulatorSetFlag(ULONG Flag)
+VOID
+WINAPI
+VDDTerminateVDM(VOID)
{
- EmulatorContext.Flags.Long |= Flag;
+ /* Stop the VDM */
+ VdmRunning = FALSE;
}
-VOID EmulatorClearFlag(ULONG Flag)
+PBYTE
+WINAPI
+Sim32pGetVDMPointer(IN ULONG Address,
+ IN BOOLEAN ProtectedMode)
{
- EmulatorContext.Flags.Long &= ~Flag;
+ // FIXME
+ UNREFERENCED_PARAMETER(ProtectedMode);
+
+ /*
+ * HIWORD(Address) == Segment (if ProtectedMode == FALSE)
+ * or Selector (if ProtectedMode == TRUE )
+ * LOWORD(Address) == Offset
+ */
+ return (PBYTE)FAR_POINTER(Address);
}
-VOID EmulatorStep(VOID)
+PBYTE
+WINAPI
+MGetVdmPointer(IN ULONG Address,
+ IN ULONG Size,
+ IN BOOLEAN ProtectedMode)
{
- /* Dump the state for debugging purposes */
- // Fast486DumpState(&EmulatorContext);
+ UNREFERENCED_PARAMETER(Size);
+ return Sim32pGetVDMPointer(Address, ProtectedMode);
+}
- /* Execute the next instruction */
- Fast486StepInto(&EmulatorContext);
+PVOID
+WINAPI
+VdmMapFlat(IN USHORT Segment,
+ IN ULONG Offset,
+ IN VDM_MODE Mode)
+{
+ // FIXME
+ UNREFERENCED_PARAMETER(Mode);
+
+ return SEG_OFF_TO_PTR(Segment, Offset);
}
-VOID EmulatorSetA20(BOOLEAN Enabled)
+BOOL
+WINAPI
+VdmFlushCache(IN USHORT Segment,
+ IN ULONG Offset,
+ IN ULONG Size,
+ IN VDM_MODE Mode)
{
- A20Line = Enabled;
+ // FIXME
+ UNIMPLEMENTED;
+ return TRUE;
+}
+
+BOOL
+WINAPI
+VdmUnmapFlat(IN USHORT Segment,
+ IN ULONG Offset,
+ IN PVOID Buffer,
+ IN VDM_MODE Mode)
+{
+ // FIXME
+ UNIMPLEMENTED;
+ return TRUE;
}
/* EOF */
projects / reactos.git / blobdiff