[NTVDM]
[reactos.git] / subsystems / ntvdm / emulator.c
1 /*
2 * COPYRIGHT: GPL - See COPYING in the top level directory
3 * PROJECT: ReactOS Virtual DOS Machine
4 * FILE: emulator.c
5 * PURPOSE: Minimal x86 machine emulator for the VDM
6 * PROGRAMMERS: Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #define NDEBUG
12
13 #include "emulator.h"
14 #include "bios.h"
15 #include "dos.h"
16 #include "pic.h"
17 #include "ps2.h"
18 #include "timer.h"
19
20 /* PRIVATE VARIABLES **********************************************************/
21
22 #ifndef NEW_EMULATOR
23 softx86_ctx EmulatorContext;
24 softx87_ctx FpuEmulatorContext;
25 #else
26 EMULATOR_CONTEXT EmulatorContext;
27 #endif
28
29 static BOOLEAN A20Line = FALSE;
30
31 /* PRIVATE FUNCTIONS **********************************************************/
32
33 #ifndef NEW_EMULATOR
34
35 static VOID EmulatorReadMemory(PVOID Context, UINT Address, LPBYTE Buffer, INT Size)
36 {
37 /* If the A20 line is disabled, mask bit 20 */
38 if (!A20Line) Address &= ~(1 << 20);
39
40 /* Make sure the requested address is valid */
41 if ((Address + Size) >= MAX_ADDRESS) return;
42
43 /* Are we reading some of the console video memory? */
44 if (((Address + Size) >= BiosGetVideoMemoryStart())
45 && (Address < CONSOLE_VIDEO_MEM_END))
46 {
47 /* Call the VDM BIOS to update the video memory */
48 BiosUpdateVideoMemory(max(Address, BiosGetVideoMemoryStart()),
49 min(Address + Size, CONSOLE_VIDEO_MEM_END));
50 }
51
52 /* Read the data from the virtual address space and store it in the buffer */
53 RtlCopyMemory(Buffer, (LPVOID)((ULONG_PTR)BaseAddress + Address), Size);
54 }
55
56 static VOID EmulatorWriteMemory(PVOID Context, UINT Address, LPBYTE Buffer, INT Size)
57 {
58 /* If the A20 line is disabled, mask bit 20 */
59 if (!A20Line) Address &= ~(1 << 20);
60
61 /* Make sure the requested address is valid */
62 if ((Address + Size) >= MAX_ADDRESS) return;
63
64 /* Make sure we don't write to the ROM area */
65 if ((Address + Size) >= ROM_AREA_START && (Address < ROM_AREA_END)) return;
66
67 /* Read the data from the buffer and store it in the virtual address space */
68 RtlCopyMemory((LPVOID)((ULONG_PTR)BaseAddress + Address), Buffer, Size);
69
70 /* Check if we modified the console video memory */
71 if (((Address + Size) >= BiosGetVideoMemoryStart())
72 && (Address < CONSOLE_VIDEO_MEM_END))
73 {
74 /* Call the VDM BIOS to update the screen */
75 BiosUpdateConsole(max(Address, BiosGetVideoMemoryStart()),
76 min(Address + Size, CONSOLE_VIDEO_MEM_END));
77 }
78 }
79
80 static VOID EmulatorReadIo(PVOID Context, UINT Address, LPBYTE Buffer, INT Size)
81 {
82 switch (Address)
83 {
84 case PIC_MASTER_CMD:
85 case PIC_SLAVE_CMD:
86 {
87 *Buffer = PicReadCommand(Address);
88 break;
89 }
90
91 case PIC_MASTER_DATA:
92 case PIC_SLAVE_DATA:
93 {
94 *Buffer = PicReadData(Address);
95 break;
96 }
97
98 case PIT_DATA_PORT(0):
99 case PIT_DATA_PORT(1):
100 case PIT_DATA_PORT(2):
101 {
102 *Buffer = PitReadData(Address - PIT_DATA_PORT(0));
103 break;
104 }
105
106 case PS2_CONTROL_PORT:
107 {
108 *Buffer = KeyboardReadStatus();
109 break;
110 }
111
112 case PS2_DATA_PORT:
113 {
114 *Buffer = KeyboardReadData();
115 break;
116 }
117 }
118 }
119
120 static VOID EmulatorWriteIo(PVOID Context, UINT Address, LPBYTE Buffer, INT Size)
121 {
122 BYTE Byte = *Buffer;
123
124 switch (Address)
125 {
126 case PIT_COMMAND_PORT:
127 {
128 PitWriteCommand(Byte);
129 break;
130 }
131
132 case PIT_DATA_PORT(0):
133 case PIT_DATA_PORT(1):
134 case PIT_DATA_PORT(2):
135 {
136 PitWriteData(Address - PIT_DATA_PORT(0), Byte);
137 break;
138 }
139
140 case PIC_MASTER_CMD:
141 case PIC_SLAVE_CMD:
142 {
143 PicWriteCommand(Address, Byte);
144 break;
145 }
146
147 case PIC_MASTER_DATA:
148 case PIC_SLAVE_DATA:
149 {
150 PicWriteData(Address, Byte);
151 break;
152 }
153
154 case PS2_CONTROL_PORT:
155 {
156 KeyboardWriteCommand(Byte);
157 break;
158 }
159
160 case PS2_DATA_PORT:
161 {
162 KeyboardWriteData(Byte);
163 break;
164 }
165 }
166 }
167
168 static VOID EmulatorBop(WORD Code)
169 {
170 WORD StackSegment, StackPointer, CodeSegment, InstructionPointer;
171 BYTE IntNum;
172 LPWORD Stack;
173
174 /* Get the SS:SP */
175 #ifndef NEW_EMULATOR
176 StackSegment = EmulatorContext.state->segment_reg[SX86_SREG_SS].val;
177 StackPointer = EmulatorContext.state->general_reg[SX86_REG_SP].val;
178 #else
179 StackSegment = EmulatorContext.Registers[EMULATOR_REG_SS].LowWord;
180 StackPointer = EmulatorContext.Registers[EMULATOR_REG_SP].LowWord;
181 #endif
182
183 /* Get the stack */
184 Stack = (LPWORD)((ULONG_PTR)BaseAddress + TO_LINEAR(StackSegment, StackPointer));
185
186 if (Code == EMULATOR_INT_BOP)
187 {
188 /* Get the interrupt number */
189 IntNum = LOBYTE(Stack[0]);
190
191 /* Get the CS:IP */
192 InstructionPointer = Stack[1];
193 CodeSegment = Stack[2];
194
195 /* Check if this was an exception */
196 if (IntNum < 8)
197 {
198 /* Display a message to the user */
199 DisplayMessage(L"Exception: %s occured at %04X:%04X",
200 ExceptionName[IntNum],
201 CodeSegment,
202 InstructionPointer);
203
204 /* Stop the VDM */
205 VdmRunning = FALSE;
206 return;
207 }
208
209 /* Check if this was an PIC IRQ */
210 if (IntNum >= BIOS_PIC_MASTER_INT && IntNum < BIOS_PIC_MASTER_INT + 8)
211 {
212 /* It was an IRQ from the master PIC */
213 BiosHandleIrq(IntNum - BIOS_PIC_MASTER_INT);
214 return;
215 }
216 else if (IntNum >= BIOS_PIC_SLAVE_INT && IntNum < BIOS_PIC_SLAVE_INT + 8)
217 {
218 /* It was an IRQ from the slave PIC */
219 BiosHandleIrq(IntNum - BIOS_PIC_SLAVE_INT + 8);
220 return;
221 }
222
223 switch (IntNum)
224 {
225 case BIOS_VIDEO_INTERRUPT:
226 {
227 /* This is the video BIOS interrupt, call the BIOS */
228 BiosVideoService();
229 break;
230 }
231 case BIOS_EQUIPMENT_INTERRUPT:
232 {
233 /* This is the BIOS "get equipment" command, call the BIOS */
234 BiosEquipmentService();
235 break;
236 }
237 case BIOS_KBD_INTERRUPT:
238 {
239 /* This is the keyboard BIOS interrupt, call the BIOS */
240 BiosKeyboardService();
241 break;
242 }
243 case BIOS_TIME_INTERRUPT:
244 {
245 /* This is the time BIOS interrupt, call the BIOS */
246 BiosTimeService();
247 break;
248 }
249 case BIOS_SYS_TIMER_INTERRUPT:
250 {
251 /* BIOS timer update */
252 BiosSystemTimerInterrupt();
253 break;
254 }
255 case 0x20:
256 {
257 DosInt20h(CodeSegment);
258 break;
259 }
260 case 0x21:
261 {
262 DosInt21h(CodeSegment);
263 break;
264 }
265 case 0x23:
266 {
267 DosBreakInterrupt();
268 break;
269 }
270 default:
271 {
272 DPRINT1("Unhandled interrupt: 0x%02X\n", IntNum);
273 break;
274 }
275 }
276
277 /* Update the flags on the stack */
278 #ifndef NEW_EMULATOR
279 Stack[3] = EmulatorContext.state->reg_flags.val;
280 #else
281 Stack[3] = EmulatorContext.Flags.LowWord;
282 #endif
283 }
284 }
285
286 static VOID EmulatorSoftwareInt(PVOID Context, BYTE Number)
287 {
288 /* Do nothing */
289 }
290
291 static VOID EmulatorHardwareInt(PVOID Context, BYTE Number)
292 {
293 /* Do nothing */
294 }
295
296 static VOID EmulatorHardwareIntAck(PVOID Context, BYTE Number)
297 {
298 /* Do nothing */
299 }
300
301 #endif
302
303 /* PUBLIC FUNCTIONS ***********************************************************/
304
305 BOOLEAN EmulatorInitialize()
306 {
307 /* Allocate memory for the 16-bit address space */
308 BaseAddress = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, MAX_ADDRESS);
309 if (BaseAddress == NULL) return FALSE;
310
311 #ifndef NEW_EMULATOR
312 /* Initialize the softx86 CPU emulator */
313 if (!softx86_init(&EmulatorContext, SX86_CPULEVEL_80286))
314 {
315 HeapFree(GetProcessHeap(), 0, BaseAddress);
316 return FALSE;
317 }
318
319 /* Initialize the softx87 FPU emulator*/
320 if(!softx87_init(&FpuEmulatorContext, SX87_FPULEVEL_8087))
321 {
322 softx86_free(&EmulatorContext);
323 HeapFree(GetProcessHeap(), 0, BaseAddress);
324 return FALSE;
325 }
326
327 /* Set memory read/write callbacks */
328 EmulatorContext.callbacks->on_read_memory = EmulatorReadMemory;
329 EmulatorContext.callbacks->on_write_memory = EmulatorWriteMemory;
330
331 /* Set MMIO read/write callbacks */
332 EmulatorContext.callbacks->on_read_io = EmulatorReadIo;
333 EmulatorContext.callbacks->on_write_io = EmulatorWriteIo;
334
335 /* Set interrupt callbacks */
336 EmulatorContext.callbacks->on_sw_int = EmulatorSoftwareInt;
337 EmulatorContext.callbacks->on_hw_int = EmulatorHardwareInt;
338 EmulatorContext.callbacks->on_hw_int_ack = EmulatorHardwareIntAck;
339
340 /* Connect the emulated FPU to the emulated CPU */
341 softx87_connect_to_CPU(&EmulatorContext, &FpuEmulatorContext);
342 #else
343 // TODO: NOT IMPLEMENTED
344 #endif
345
346 /* Enable interrupts */
347 EmulatorSetFlag(EMULATOR_FLAG_IF);
348
349 return TRUE;
350 }
351
352 VOID EmulatorSetStack(WORD Segment, WORD Offset)
353 {
354 #ifndef NEW_EMULATOR
355 /* Call the softx86 API */
356 softx86_set_stack_ptr(&EmulatorContext, Segment, Offset);
357 #else
358 // TODO: NOT IMPLEMENTED
359 #endif
360 }
361
362 VOID EmulatorExecute(WORD Segment, WORD Offset)
363 {
364 #ifndef NEW_EMULATOR
365 /* Call the softx86 API */
366 softx86_set_instruction_ptr(&EmulatorContext, Segment, Offset);
367 #else
368 // TODO: NOT IMPLEMENTED
369 #endif
370 }
371
372 VOID EmulatorInterrupt(BYTE Number)
373 {
374 LPDWORD IntVecTable = (LPDWORD)((ULONG_PTR)BaseAddress);
375 UINT Segment, Offset;
376
377 /* Get the segment and offset */
378 Segment = HIWORD(IntVecTable[Number]);
379 Offset = LOWORD(IntVecTable[Number]);
380
381 #ifndef NEW_EMULATOR
382 /* Call the softx86 API */
383 softx86_make_simple_interrupt_call(&EmulatorContext, &Segment, &Offset);
384 #else
385 UNREFERENCED_PARAMETER(Segment);
386 UNREFERENCED_PARAMETER(Offset);
387 // TODO: NOT IMPLEMENTED
388 #endif
389 }
390
391 VOID EmulatorExternalInterrupt(BYTE Number)
392 {
393 #ifndef NEW_EMULATOR
394 /* Call the softx86 API */
395 softx86_ext_hw_signal(&EmulatorContext, Number);
396 #endif
397 }
398
399 ULONG EmulatorGetRegister(ULONG Register)
400 {
401 #ifndef NEW_EMULATOR
402 if (Register < EMULATOR_REG_ES)
403 {
404 return EmulatorContext.state->general_reg[Register].val;
405 }
406 else
407 {
408 return EmulatorContext.state->segment_reg[Register - EMULATOR_REG_ES].val;
409 }
410 #else
411 return EmulatorContext.Registers[Register].Long;
412 #endif
413 }
414
415 VOID EmulatorSetRegister(ULONG Register, ULONG Value)
416 {
417 #ifndef NEW_EMULATOR
418 if (Register < EMULATOR_REG_CS)
419 {
420 EmulatorContext.state->general_reg[Register].val = Value;
421 }
422 else
423 {
424 EmulatorContext.state->segment_reg[Register - EMULATOR_REG_ES].val = Value;
425 }
426 #else
427 // TODO: NOT IMPLEMENTED
428 #endif
429 }
430
431 BOOLEAN EmulatorGetFlag(ULONG Flag)
432 {
433 #ifndef NEW_EMULATOR
434 return (EmulatorContext.state->reg_flags.val & Flag) ? TRUE : FALSE;
435 #else
436 return (EmulatorContext.Flags.Long & Flag) ? TRUE : FALSE;
437 #endif
438 }
439
440 VOID EmulatorSetFlag(ULONG Flag)
441 {
442 #ifndef NEW_EMULATOR
443 EmulatorContext.state->reg_flags.val |= Flag;
444 #else
445 EmulatorContext.Flags.Long |= Flag;
446 #endif
447 }
448
449 VOID EmulatorClearFlag(ULONG Flag)
450 {
451 #ifndef NEW_EMULATOR
452 EmulatorContext.state->reg_flags.val &= ~Flag;
453 #else
454 EmulatorContext.Flags.Long &= ~Flag;
455 #endif
456 }
457
458 VOID EmulatorStep(VOID)
459 {
460 LPWORD Instruction;
461
462 #ifndef NEW_EMULATOR
463 /* Print the current position - useful for debugging */
464 DPRINT("Executing at CS:IP = %04X:%04X\n",
465 EmulatorGetRegister(EMULATOR_REG_CS),
466 EmulatorContext.state->reg_ip);
467
468 Instruction = (LPWORD)((ULONG_PTR)BaseAddress
469 + TO_LINEAR(EmulatorGetRegister(EMULATOR_REG_CS),
470 EmulatorContext.state->reg_ip));
471
472 /* Check for the BIOS operation (BOP) sequence */
473 if (Instruction[0] == EMULATOR_BOP)
474 {
475 /* Skip the opcodes */
476 EmulatorContext.state->reg_ip += 4;
477
478 /* Call the BOP handler */
479 EmulatorBop(Instruction[1]);
480 }
481
482 /* Call the softx86 API */
483 if (!softx86_step(&EmulatorContext))
484 {
485 /* Invalid opcode */
486 EmulatorInterrupt(EMULATOR_EXCEPTION_INVALID_OPCODE);
487 }
488 #else
489 // TODO: NOT IMPLEMENTED
490 #endif
491 }
492
493 VOID EmulatorCleanup(VOID)
494 {
495 /* Free the memory allocated for the 16-bit address space */
496 if (BaseAddress != NULL) HeapFree(GetProcessHeap(), 0, BaseAddress);
497
498 #ifndef NEW_EMULATOR
499 /* Free the softx86 CPU and FPU emulator */
500 softx86_free(&EmulatorContext);
501 softx87_free(&FpuEmulatorContext);
502 #endif
503 }
504
505 VOID EmulatorSetA20(BOOLEAN Enabled)
506 {
507 A20Line = Enabled;
508 }
509
510 /* EOF */