![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to interrupt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / SLOF / clients / net-snk / app / biosemu|
Return to interrupt.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / SLOF / clients / net-snk / app / biosemu |
1.1 root 1: /******************************************************************************
2: * Copyright (c) 2004, 2008 IBM Corporation
3: * All rights reserved.
4: * This program and the accompanying materials
5: * are made available under the terms of the BSD License
6: * which accompanies this distribution, and is available at
7: * http://www.opensource.org/licenses/bsd-license.php
8: *
9: * Contributors:
10: * IBM Corporation - initial implementation
11: *****************************************************************************/
12:
13: #include <stdio.h>
14:
15: #include <rtas.h>
16:
17: #include "biosemu.h"
18: #include "mem.h"
19: #include "device.h"
20: #include "debug.h"
21:
22: #include <x86emu/x86emu.h>
23: #include <x86emu/prim_ops.h>
24:
25:
26:
27: //setup to run the code at the address, that the Interrupt Vector points to...
28: void
29: setupInt(int intNum)
30: {
31: DEBUG_PRINTF_INTR("%s(%x): executing interrupt handler @%08x\n",
32: __FUNCTION__, intNum, my_rdl(intNum * 4));
33: // push current R_FLG... will be popped by IRET
34: push_word((u16) M.x86.R_FLG);
35: CLEAR_FLAG(F_IF);
36: CLEAR_FLAG(F_TF);
37: // push current CS:IP to the stack, will be popped by IRET
38: push_word(M.x86.R_CS);
39: push_word(M.x86.R_IP);
40: // set CS:IP to the interrupt handler address... so the next executed instruction will
41: // be the interrupt handler
42: M.x86.R_CS = my_rdw(intNum * 4 + 2);
43: M.x86.R_IP = my_rdw(intNum * 4);
44: }
45:
46: // handle int10 (VGA BIOS Interrupt)
47: void
48: handleInt10()
49: {
50: // the data for INT10 is stored in BDA (0000:0400h) offset 49h-66h
51: // function number in AH
52: //DEBUG_PRINTF_CS_IP("%s:\n", __FUNCTION__);
53: //x86emu_dump_xregs();
54: //if ((M.x86.R_IP == 0x32c2) && (M.x86.R_SI == 0x1ce2)){
55: //X86EMU_trace_on();
56: //M.x86.debug &= ~DEBUG_DECODE_NOPRINT_F;
57: //}
58: switch (M.x86.R_AH) {
59: case 0x00:
60: // set video mode
61: // BDA offset 49h is current video mode
62: my_wrb(0x449, M.x86.R_AL);
63: if (M.x86.R_AL > 7)
64: M.x86.R_AL = 0x20;
65: else if (M.x86.R_AL == 6)
66: M.x86.R_AL = 0x3f;
67: else
68: M.x86.R_AL = 0x30;
69: break;
70: case 0x01:
71: // set cursor shape
72: // ignore
73: break;
74: case 0x02:
75: // set cursor position
76: // BH: pagenumber, DX: cursor_pos (DH:row, DL:col)
77: // BDA offset 50h-60h are 8 cursor position words for
78: // eight possible video pages
79: my_wrw(0x450 + (M.x86.R_BH * 2), M.x86.R_DX);
80: break;
81: case 0x03:
82: //get cursor position
83: // BH: pagenumber
84: // BDA offset 50h-60h are 8 cursor position words for
85: // eight possible video pages
86: M.x86.R_AX = 0;
87: M.x86.R_CH = 0; // start scan line ???
88: M.x86.R_CL = 0; // end scan line ???
89: M.x86.R_DX = my_rdw(0x450 + (M.x86.R_BH * 2));
90: break;
91: case 0x05:
92: // set active page
93: // BDA offset 62h is current page number
94: my_wrb(0x462, M.x86.R_AL);
95: break;
96: case 0x06:
97: //scroll up windows
98: break;
99: case 0x07:
100: //scroll down windows
101: break;
102: case 0x08:
103: //read character and attribute at position
104: M.x86.R_AH = 0x07; // white-on-black
105: M.x86.R_AL = 0x20; // a space...
106: break;
107: case 0x09:
108: // write character and attribute
109: //AL: char, BH: page number, BL: attribute, CX: number of times to write
110: //BDA offset 62h is current page number
111: CHECK_DBG(DEBUG_PRINT_INT10) {
112: uint32_t i = 0;
113: if (M.x86.R_BH == my_rdb(0x462)) {
114: for (i = 0; i < M.x86.R_CX; i++)
115: printf("%c", M.x86.R_AL);
116: }
117: }
118: break;
119: case 0x0a:
120: // write character
121: //AL: char, BH: page number, BL: attribute, CX: number of times to write
122: //BDA offset 62h is current page number
123: CHECK_DBG(DEBUG_PRINT_INT10) {
124: uint32_t i = 0;
125: if (M.x86.R_BH == my_rdb(0x462)) {
126: for (i = 0; i < M.x86.R_CX; i++)
127: printf("%c", M.x86.R_AL);
128: }
129: }
130: break;
131: case 0x0e:
132: // teletype output: write character and advance cursor...
133: //AL: char, BH: page number, BL: attribute
134: //BDA offset 62h is current page number
135: CHECK_DBG(DEBUG_PRINT_INT10) {
136: // we ignore the pagenumber on this call...
137: //if (M.x86.R_BH == my_rdb(0x462))
138: {
139: printf("%c", M.x86.R_AL);
140: // for debugging, to read all lines
141: //if (M.x86.R_AL == 0xd) // carriage return
142: // printf("\n");
143: }
144: }
145: break;
146: case 0x0f:
147: // get video mode
148: // BDA offset 49h is current video mode
149: // BDA offset 62h is current page number
150: // BDA offset 4ah is columns on screen
151: M.x86.R_AH = 80; //number of character columns... we hardcode it to 80
152: M.x86.R_AL = my_rdb(0x449);
153: M.x86.R_BH = my_rdb(0x462);
154: break;
155: default:
156: printf("%s(): unknown function (%x) for int10 handler.\n",
157: __FUNCTION__, M.x86.R_AH);
158: DEBUG_PRINTF_INTR("AX=%04x BX=%04x CX=%04x DX=%04x\n",
159: M.x86.R_AX, M.x86.R_BX, M.x86.R_CX,
160: M.x86.R_DX);
161: HALT_SYS();
162: break;
163: }
164: }
165:
166: // this table translates ASCII chars into their XT scan codes:
167: static uint8_t keycode_table[256] = {
168: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0 - 7
169: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 8 - 15
170: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 16 - 23
171: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 24 - 31
172: 0x39, 0x02, 0x28, 0x04, 0x05, 0x06, 0x08, 0x28, // 32 - 39
173: 0x0a, 0x0b, 0x09, 0x2b, 0x33, 0x0d, 0x34, 0x35, // 40 - 47
174: 0x0b, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // 48 - 55
175: 0x09, 0x0a, 0x27, 0x27, 0x33, 0x2b, 0x34, 0x35, // 56 - 63
176: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 64 - 71
177: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 72 - 79
178: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 80 - 87
179: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 88 - 95
180: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 96 - 103
181: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 104 - 111
182: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 112 - 119
183: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 120 - 127
184: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ...
185: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
186: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
187: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
188: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
189: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
190: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
191: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
192: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
193: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
194: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
195: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
196: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
197: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
198: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
199: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
200: }
201:
202: ;
203:
204: void
205: translate_keycode(uint64_t * keycode)
206: {
207: uint8_t scan_code = 0;
208: uint8_t char_code = 0;
209: if (*keycode < 256) {
210: scan_code = keycode_table[*keycode];
211: char_code = (uint8_t) * keycode & 0xff;
212: } else {
213: switch (*keycode) {
214: case 0x1b50:
215: // F1
216: scan_code = 0x3b;
217: char_code = 0x0;
218: break;
219: default:
220: printf("%s(): unknown multibyte keycode: %llx\n",
221: __FUNCTION__, *keycode);
222: break;
223: }
224: }
225: //assemble scan/char code in keycode
226: *keycode = (uint64_t) ((((uint16_t) scan_code) << 8) | char_code);
227: }
228:
229: // handle int16 (Keyboard BIOS Interrupt)
230: void
231: handleInt16()
232: {
233: // keyboard buffer is in BIOS Memory Area:
234: // offset 0x1a (WORD) pointer to next char in keybuffer
235: // offset 0x1c (WORD) pointer to next insert slot in keybuffer
236: // offset 0x1e-0x3e: 16 WORD Ring Buffer
237: // since we currently always read the char from the FW buffer,
238: // we misuse the ring buffer, we use it as pointer to a uint64_t that stores
239: // multi-byte keys (e.g. special keys in VT100 terminal)
240: // and as long as a key is available (not 0) we dont read further keys
241: uint64_t *keycode = (uint64_t *) (M.mem_base + 0x41e);
242: int8_t c;
243: // function number in AH
244: DEBUG_PRINTF_INTR("%s(): Keyboard Interrupt: function: %x.\n",
245: __FUNCTION__, M.x86.R_AH);
246: DEBUG_PRINTF_INTR("AX=%04x BX=%04x CX=%04x DX=%04x\n", M.x86.R_AX,
247: M.x86.R_BX, M.x86.R_CX, M.x86.R_DX);
248: switch (M.x86.R_AH) {
249: case 0x00:
250: // get keystroke
251: if (*keycode) {
252: M.x86.R_AX = (uint16_t) * keycode;
253: // clear keycode
254: *keycode = 0;
255: } else {
256: M.x86.R_AH = 0x61; // scancode for space key
257: M.x86.R_AL = 0x20; // a space
258: }
259: break;
260: case 0x01:
261: // check keystroke
262: // ZF set = no keystroke
263: // read first byte of key code
264: if (*keycode) {
265: // already read, but not yet taken
266: CLEAR_FLAG(F_ZF);
267: M.x86.R_AX = (uint16_t) * keycode;
268: } else {
269: c = getchar();
270: if (c == -1) {
271: // no key available
272: SET_FLAG(F_ZF);
273: } else {
274: *keycode = c;
275:
276: // since after an ESC it may take a while to receive the next char,
277: // we send something that is not shown on the screen, and then try to get
278: // the next char
279: // TODO: only after ESC?? what about other multibyte keys
280: printf("tt%c%c", 0x08, 0x08); // 0x08 == Backspace
281:
282: while ((c = getchar()) != -1) {
283: *keycode = (*keycode << 8) | c;
284: DEBUG_PRINTF(" key read: %0llx\n",
285: *keycode);
286: }
287: translate_keycode(keycode);
288: DEBUG_PRINTF(" translated key: %0llx\n",
289: *keycode);
290: if (*keycode == 0) {
291: //not found
292: SET_FLAG(F_ZF);
293: } else {
294: CLEAR_FLAG(F_ZF);
295: M.x86.R_AX = (uint16_t) * keycode;
296: //X86EMU_trace_on();
297: //M.x86.debug &= ~DEBUG_DECODE_NOPRINT_F;
298: }
299: }
300: }
301: break;
302: default:
303: printf("%s(): unknown function (%x) for int16 handler.\n",
304: __FUNCTION__, M.x86.R_AH);
305: DEBUG_PRINTF_INTR("AX=%04x BX=%04x CX=%04x DX=%04x\n",
306: M.x86.R_AX, M.x86.R_BX, M.x86.R_CX,
307: M.x86.R_DX);
308: HALT_SYS();
309: break;
310: }
311: }
312:
313: // handle int1a (PCI BIOS Interrupt)
314: void
315: handleInt1a()
316: {
317: // function number in AX
318: uint8_t bus, devfn, offs;
319: switch (M.x86.R_AX) {
320: case 0xb101:
321: // Installation check
322: CLEAR_FLAG(F_CF); // clear CF
323: M.x86.R_EDX = 0x20494350; // " ICP" endian swapped "PCI "
324: M.x86.R_AL = 0x1; // Config Space Mechanism 1 supported
325: M.x86.R_BX = 0x0210; // PCI Interface Level Version 2.10
326: M.x86.R_CL = 0xff; // number of last PCI Bus in system TODO: check!
327: break;
328: case 0xb102:
329: // Find PCI Device
330: // NOTE: we currently only allow the device to find itself...
331: // it SHOULD be all we ever need...
332: // device_id in CX, vendor_id in DX
333: // device index in SI (i.e. if multiple devices with same vendor/device id
334: // are connected). We currently only support device index 0
335: DEBUG_PRINTF_INTR("%s(): function: %x: PCI Find Device\n",
336: __FUNCTION__, M.x86.R_AX);
337: if ((M.x86.R_CX == bios_device.pci_device_id)
338: && (M.x86.R_DX == bios_device.pci_vendor_id)
339: // device index must be 0
340: && (M.x86.R_SI == 0)) {
341: CLEAR_FLAG(F_CF);
342: M.x86.R_AH = 0x00; // return code: success
343: M.x86.R_BH = bios_device.bus;
344: M.x86.R_BL = bios_device.devfn;
345: DEBUG_PRINTF_INTR
346: ("%s(): function %x: PCI Find Device --> 0x%04x\n",
347: __FUNCTION__, M.x86.R_AX, M.x86.R_BX);
348: } else {
349: DEBUG_PRINTF_INTR
350: ("%s(): function %x: invalid device/vendor/device index! (%04x/%04x/%02x expected: %04x/%04x/0) \n",
351: __FUNCTION__, M.x86.R_AX, M.x86.R_CX, M.x86.R_DX,
352: M.x86.R_SI, bios_device.pci_device_id,
353: bios_device.pci_vendor_id);
354: SET_FLAG(F_CF);
355: M.x86.R_AH = 0x86; // return code: device not found
356: }
357: break;
358: case 0xb108: //read configuration byte
359: case 0xb109: //read configuration word
360: case 0xb10a: //read configuration dword
361: bus = M.x86.R_BH;
362: devfn = M.x86.R_BL;
363: offs = M.x86.R_DI;
364: if ((bus != bios_device.bus)
365: || (devfn != bios_device.devfn)) {
366: // fail accesses to any device but ours...
367: printf
368: ("%s(): Config read access invalid! bus: %x (%x), devfn: %x (%x), offs: %x\n",
369: __FUNCTION__, bus, bios_device.bus, devfn,
370: bios_device.devfn, offs);
371: SET_FLAG(F_CF);
372: M.x86.R_AH = 0x87; //return code: bad pci register
373: HALT_SYS();
374: return;
375: } else {
376: switch (M.x86.R_AX) {
377: case 0xb108:
378: M.x86.R_CL =
379: (uint8_t) rtas_pci_config_read(bios_device.
380: puid, 1,
381: bus, devfn,
382: offs);
383: DEBUG_PRINTF_INTR
384: ("%s(): function %x: PCI Config Read @%02x --> 0x%02x\n",
385: __FUNCTION__, M.x86.R_AX, offs,
386: M.x86.R_CL);
387: break;
388: case 0xb109:
389: M.x86.R_CX =
390: (uint16_t) rtas_pci_config_read(bios_device.
391: puid, 2,
392: bus, devfn,
393: offs);
394: DEBUG_PRINTF_INTR
395: ("%s(): function %x: PCI Config Read @%02x --> 0x%04x\n",
396: __FUNCTION__, M.x86.R_AX, offs,
397: M.x86.R_CX);
398: break;
399: case 0xb10a:
400: M.x86.R_ECX =
401: (uint32_t) rtas_pci_config_read(bios_device.
402: puid, 4,
403: bus, devfn,
404: offs);
405: DEBUG_PRINTF_INTR
406: ("%s(): function %x: PCI Config Read @%02x --> 0x%08x\n",
407: __FUNCTION__, M.x86.R_AX, offs,
408: M.x86.R_ECX);
409: break;
410: }
411: CLEAR_FLAG(F_CF);
412: M.x86.R_AH = 0x0; // return code: success
413: }
414: break;
415: case 0xb10b: //write configuration byte
416: case 0xb10c: //write configuration word
417: case 0xb10d: //write configuration dword
418: bus = M.x86.R_BH;
419: devfn = M.x86.R_BL;
420: offs = M.x86.R_DI;
421: if ((bus != bios_device.bus)
422: || (devfn != bios_device.devfn)) {
423: // fail accesses to any device but ours...
424: printf
425: ("%s(): Config read access invalid! bus: %x (%x), devfn: %x (%x), offs: %x\n",
426: __FUNCTION__, bus, bios_device.bus, devfn,
427: bios_device.devfn, offs);
428: SET_FLAG(F_CF);
429: M.x86.R_AH = 0x87; //return code: bad pci register
430: HALT_SYS();
431: return;
432: } else {
433: switch (M.x86.R_AX) {
434: case 0xb10b:
435: rtas_pci_config_write(bios_device.puid, 1, bus,
436: devfn, offs, M.x86.R_CL);
437: DEBUG_PRINTF_INTR
438: ("%s(): function %x: PCI Config Write @%02x <-- 0x%02x\n",
439: __FUNCTION__, M.x86.R_AX, offs,
440: M.x86.R_CL);
441: break;
442: case 0xb10c:
443: rtas_pci_config_write(bios_device.puid, 2, bus,
444: devfn, offs, M.x86.R_CX);
445: DEBUG_PRINTF_INTR
446: ("%s(): function %x: PCI Config Write @%02x <-- 0x%04x\n",
447: __FUNCTION__, M.x86.R_AX, offs,
448: M.x86.R_CX);
449: break;
450: case 0xb10d:
451: rtas_pci_config_write(bios_device.puid, 4, bus,
452: devfn, offs, M.x86.R_ECX);
453: DEBUG_PRINTF_INTR
454: ("%s(): function %x: PCI Config Write @%02x <-- 0x%08x\n",
455: __FUNCTION__, M.x86.R_AX, offs,
456: M.x86.R_ECX);
457: break;
458: }
459: CLEAR_FLAG(F_CF);
460: M.x86.R_AH = 0x0; // return code: success
461: }
462: break;
463: default:
464: printf("%s(): unknown function (%x) for int1a handler.\n",
465: __FUNCTION__, M.x86.R_AX);
466: DEBUG_PRINTF_INTR("AX=%04x BX=%04x CX=%04x DX=%04x\n",
467: M.x86.R_AX, M.x86.R_BX, M.x86.R_CX,
468: M.x86.R_DX);
469: HALT_SYS();
470: break;
471: }
472: }
473:
474: // main Interrupt Handler routine, should be registered as x86emu interrupt handler
475: void
476: handleInterrupt(int intNum)
477: {
478: uint8_t int_handled = 0;
479: #ifndef DEBUG_PRINT_INT10
480: // this printf makes output by int 10 unreadable...
481: // so we only enable it, if int10 print is disabled
482: DEBUG_PRINTF_INTR("%s(%x)\n", __FUNCTION__, intNum);
483: #endif
484: switch (intNum) {
485: case 0x10: //BIOS video interrupt
486: case 0x42: // INT 10h relocated by EGA/VGA BIOS
487: case 0x6d: // INT 10h relocated by VGA BIOS
488: // get interrupt vector from IDT (4 bytes per Interrupt starting at address 0
489: if ((my_rdl(intNum * 4) == 0xF000F065) || //F000:F065 is default BIOS interrupt handler address
490: (my_rdl(intNum * 4) == 0xF4F4F4F4)) //invalid
491: {
492: #if 0
493: // ignore interrupt...
494: DEBUG_PRINTF_INTR
495: ("%s(%x): invalid interrupt Vector (%08x) found, interrupt ignored...\n",
496: __FUNCTION__, intNum, my_rdl(intNum * 4));
497: DEBUG_PRINTF_INTR("AX=%04x BX=%04x CX=%04x DX=%04x\n",
498: M.x86.R_AX, M.x86.R_BX, M.x86.R_CX,
499: M.x86.R_DX);
500: //HALT_SYS();
501: #endif
502: handleInt10();
503: int_handled = 1;
504: }
505: break;
506: case 0x16:
507: // Keyboard BIOS Interrupt
508: handleInt16();
509: int_handled = 1;
510: break;
511: case 0x1a:
512: // PCI BIOS Interrupt
513: handleInt1a();
514: int_handled = 1;
515: break;
516: default:
517: printf("Interrupt %#x (Vector: %x) not implemented\n", intNum,
518: my_rdl(intNum * 4));
519: DEBUG_PRINTF_INTR("AX=%04x BX=%04x CX=%04x DX=%04x\n",
520: M.x86.R_AX, M.x86.R_BX, M.x86.R_CX,
521: M.x86.R_DX);
522: int_handled = 1;
523: HALT_SYS();
524: break;
525: }
526: // if we did not handle the interrupt, jump to the interrupt vector...
527: if (!int_handled) {
528: setupInt(intNum);
529: }
530: }
531:
532: // prepare and execute Interrupt 10 (VGA Interrupt)
533: void
534: runInt10()
535: {
536: // Initialize stack and data segment
537: M.x86.R_SS = STACK_SEGMENT;
538: M.x86.R_DS = DATA_SEGMENT;
539: M.x86.R_SP = STACK_START_OFFSET;
540:
541: // push a HLT instruction and a pointer to it onto the stack
542: // any return will pop the pointer and jump to the HLT, thus
543: // exiting (more or less) cleanly
544: push_word(0xf4f4); //F4=HLT
545: //push_word(M.x86.R_SS);
546: //push_word(M.x86.R_SP + 2);
547:
548: // setupInt will push the current CS and IP to the stack to return to it,
549: // but we want to halt, so set CS:IP to the HLT instruction we just pushed
550: // to the stack
551: M.x86.R_CS = M.x86.R_SS;
552: M.x86.R_IP = M.x86.R_SP; // + 4;
553:
554: CHECK_DBG(DEBUG_TRACE_X86EMU) {
555: X86EMU_trace_on();
556: }
557: CHECK_DBG(DEBUG_JMP) {
558: M.x86.debug |= DEBUG_TRACEJMP_REGS_F;
559: M.x86.debug |= DEBUG_TRACEJMP_REGS_F;
560: M.x86.debug |= DEBUG_TRACECALL_F;
561: M.x86.debug |= DEBUG_TRACECALL_REGS_F;
562: }
563: setupInt(0x10);
564: DEBUG_PRINTF_INTR("%s(): starting execution of INT10...\n",
565: __FUNCTION__);
566: X86EMU_exec();
567: DEBUG_PRINTF_INTR("%s(): execution finished\n", __FUNCTION__);
568: }
569:
570: // prepare and execute Interrupt 13 (Disk Interrupt)
571: void
572: runInt13()
573: {
574: // Initialize stack and data segment
575: M.x86.R_SS = STACK_SEGMENT;
576: M.x86.R_DS = DATA_SEGMENT;
577: M.x86.R_SP = STACK_START_OFFSET;
578:
579: // push a HLT instruction and a pointer to it onto the stack
580: // any return will pop the pointer and jump to the HLT, thus
581: // exiting (more or less) cleanly
582: push_word(0xf4f4); //F4=HLT
583: //push_word(M.x86.R_SS);
584: //push_word(M.x86.R_SP + 2);
585:
586: // setupInt will push the current CS and IP to the stack to return to it,
587: // but we want to halt, so set CS:IP to the HLT instruction we just pushed
588: // to the stack
589: M.x86.R_CS = M.x86.R_SS;
590: M.x86.R_IP = M.x86.R_SP;
591:
592: CHECK_DBG(DEBUG_TRACE_X86EMU) {
593: X86EMU_trace_on();
594: }
595: CHECK_DBG(DEBUG_JMP) {
596: M.x86.debug |= DEBUG_TRACEJMP_REGS_F;
597: M.x86.debug |= DEBUG_TRACEJMP_REGS_F;
598: M.x86.debug |= DEBUG_TRACECALL_F;
599: M.x86.debug |= DEBUG_TRACECALL_REGS_F;
600: }
601:
602: setupInt(0x13);
603: DEBUG_PRINTF_INTR("%s(): starting execution of INT13...\n",
604: __FUNCTION__);
605: X86EMU_exec();
606: DEBUG_PRINTF_INTR("%s(): execution finished\n", __FUNCTION__);
607: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.