/****************************************************************************** * Copyright (c) 2004, 2008 IBM Corporation * Copyright (c) 2008, 2009 Pattrick Hueper * * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer * in the documentation and/or other materials provided with the * distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Contributors: * IBM Corporation - initial implementation *****************************************************************************/ #include #include "compat/rtas.h" #include "biosemu.h" #include "mem.h" #include "device.h" #include "debug.h" #include "pmm.h" #include "interrupt.h" #include #include "../x86emu/prim_ops.h" #include #include //setup to run the code at the address, that the Interrupt Vector points to... static void setupInt(int intNum) { DEBUG_PRINTF_INTR("%s(%x): executing interrupt handler @%08x\n", __func__, intNum, my_rdl(intNum * 4)); // push current R_FLG... will be popped by IRET push_word((u16) M.x86.R_FLG); CLEAR_FLAG(F_IF); CLEAR_FLAG(F_TF); // push current CS:IP to the stack, will be popped by IRET push_word(M.x86.R_CS); push_word(M.x86.R_IP); // set CS:IP to the interrupt handler address... so the next executed instruction will // be the interrupt handler M.x86.R_CS = my_rdw(intNum * 4 + 2); M.x86.R_IP = my_rdw(intNum * 4); } // handle int10 (VGA BIOS Interrupt) static void handleInt10(void) { // the data for INT10 is stored in BDA (0000:0400h) offset 49h-66h // function number in AH //DEBUG_PRINTF_CS_IP("%s:\n", __func__); //x86emu_dump_xregs(); //if ((M.x86.R_IP == 0x32c2) && (M.x86.R_SI == 0x1ce2)){ //X86EMU_trace_on(); //M.x86.debug &= ~DEBUG_DECODE_NOPRINT_F; //} switch (M.x86.R_AH) { case 0x00: // set video mode // BDA offset 49h is current video mode my_wrb(0x449, M.x86.R_AL); if (M.x86.R_AL > 7) M.x86.R_AL = 0x20; else if (M.x86.R_AL == 6) M.x86.R_AL = 0x3f; else M.x86.R_AL = 0x30; break; case 0x01: // set cursor shape // ignore break; case 0x02: // set cursor position // BH: pagenumber, DX: cursor_pos (DH:row, DL:col) // BDA offset 50h-60h are 8 cursor position words for // eight possible video pages my_wrw(0x450 + (M.x86.R_BH * 2), M.x86.R_DX); break; case 0x03: //get cursor position // BH: pagenumber // BDA offset 50h-60h are 8 cursor position words for // eight possible video pages M.x86.R_AX = 0; M.x86.R_CH = 0; // start scan line ??? M.x86.R_CL = 0; // end scan line ??? M.x86.R_DX = my_rdw(0x450 + (M.x86.R_BH * 2)); break; case 0x05: // set active page // BDA offset 62h is current page number my_wrb(0x462, M.x86.R_AL); break; case 0x06: //scroll up windows break; case 0x07: //scroll down windows break; case 0x08: //read character and attribute at position M.x86.R_AH = 0x07; // white-on-black M.x86.R_AL = 0x20; // a space... break; case 0x09: // write character and attribute //AL: char, BH: page number, BL: attribute, CX: number of times to write //BDA offset 62h is current page number CHECK_DBG(DEBUG_PRINT_INT10) { u32 i = 0; if (M.x86.R_BH == my_rdb(0x462)) { for (i = 0; i < M.x86.R_CX; i++) printf("%c", M.x86.R_AL); } } break; case 0x0a: // write character //AL: char, BH: page number, BL: attribute, CX: number of times to write //BDA offset 62h is current page number CHECK_DBG(DEBUG_PRINT_INT10) { u32 i = 0; if (M.x86.R_BH == my_rdb(0x462)) { for (i = 0; i < M.x86.R_CX; i++) printf("%c", M.x86.R_AL); } } break; case 0x0e: // teletype output: write character and advance cursor... //AL: char, BH: page number, BL: attribute //BDA offset 62h is current page number CHECK_DBG(DEBUG_PRINT_INT10) { // we ignore the pagenumber on this call... //if (M.x86.R_BH == my_rdb(0x462)) { printf("%c", M.x86.R_AL); // for debugging, to read all lines //if (M.x86.R_AL == 0xd) // carriage return // printf("\n"); } } break; case 0x0f: // get video mode // BDA offset 49h is current video mode // BDA offset 62h is current page number // BDA offset 4ah is columns on screen M.x86.R_AH = 80; //number of character columns... we hardcode it to 80 M.x86.R_AL = my_rdb(0x449); M.x86.R_BH = my_rdb(0x462); break; default: printf("%s(): unknown function (%x) for int10 handler.\n", __func__, M.x86.R_AH); DEBUG_PRINTF_INTR("AX=%04x BX=%04x CX=%04x DX=%04x\n", M.x86.R_AX, M.x86.R_BX, M.x86.R_CX, M.x86.R_DX); HALT_SYS(); break; } } // this table translates ASCII chars into their XT scan codes: static u8 keycode_table[256] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0 - 7 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 8 - 15 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 16 - 23 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 24 - 31 0x39, 0x02, 0x28, 0x04, 0x05, 0x06, 0x08, 0x28, // 32 - 39 0x0a, 0x0b, 0x09, 0x2b, 0x33, 0x0d, 0x34, 0x35, // 40 - 47 0x0b, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // 48 - 55 0x09, 0x0a, 0x27, 0x27, 0x33, 0x2b, 0x34, 0x35, // 56 - 63 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 64 - 71 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 72 - 79 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 80 - 87 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 88 - 95 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 96 - 103 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 104 - 111 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 112 - 119 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 120 - 127 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // ... 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, } ; static void translate_keycode(u64 * keycode) { u8 scan_code = 0; u8 char_code = 0; if (*keycode < 256) { scan_code = keycode_table[*keycode]; char_code = (u8) * keycode & 0xff; } else { switch (*keycode) { case 0x1b50: // F1 scan_code = 0x3b; char_code = 0x0; break; default: printf("%s(): unknown multibyte keycode: %llx\n", __func__, *keycode); break; } } //assemble scan/char code in keycode *keycode = (u64) ((((u16) scan_code) << 8) | char_code); } // handle int16 (Keyboard BIOS Interrupt) static void handleInt16(void) { // keyboard buffer is in BIOS Memory Area: // offset 0x1a (WORD) pointer to next char in keybuffer // offset 0x1c (WORD) pointer to next insert slot in keybuffer // offset 0x1e-0x3e: 16 WORD Ring Buffer // since we currently always read the char from the FW buffer, // we misuse the ring buffer, we use it as pointer to a u64 that stores // multi-byte keys (e.g. special keys in VT100 terminal) // and as long as a key is available (not 0) we don't read further keys u64 *keycode = (u64 *) (M.mem_base + 0x41e); s8 c; // function number in AH DEBUG_PRINTF_INTR("%s(): Keyboard Interrupt: function: %x.\n", __func__, M.x86.R_AH); DEBUG_PRINTF_INTR("AX=%04x BX=%04x CX=%04x DX=%04x\n", M.x86.R_AX, M.x86.R_BX, M.x86.R_CX, M.x86.R_DX); switch (M.x86.R_AH) { case 0x00: // get keystroke if (*keycode) { M.x86.R_AX = (u16) * keycode; // clear keycode *keycode = 0; } else { M.x86.R_AH = 0x61; // scancode for space key M.x86.R_AL = 0x20; // a space } break; case 0x01: // check keystroke // ZF set = no keystroke // read first byte of key code if (*keycode) { // already read, but not yet taken CLEAR_FLAG(F_ZF); M.x86.R_AX = (u16) * keycode; } else { /* TODO: we need getchar... */ c = -1; //getchar(); if (c == -1) { // no key available SET_FLAG(F_ZF); } else { *keycode = c; // since after an ESC it may take a while to receive the next char, // we send something that is not shown on the screen, and then try to get // the next char // TODO: only after ESC?? what about other multibyte keys printf("tt%c%c", 0x08, 0x08); // 0x08 == Backspace /* TODO: we need getchar... */ while ((c = -1 /*getchar()*/) != -1) { *keycode = (*keycode << 8) | c; DEBUG_PRINTF(" key read: %0llx\n", *keycode); } translate_keycode(keycode); DEBUG_PRINTF(" translated key: %0llx\n", *keycode); if (*keycode == 0) { //not found SET_FLAG(F_ZF); } else { CLEAR_FLAG(F_ZF); M.x86.R_AX = (u16) * keycode; //X86EMU_trace_on(); //M.x86.debug &= ~DEBUG_DECODE_NOPRINT_F; } } } break; default: printf("%s(): unknown function (%x) for int16 handler.\n", __func__, M.x86.R_AH); DEBUG_PRINTF_INTR("AX=%04x BX=%04x CX=%04x DX=%04x\n", M.x86.R_AX, M.x86.R_BX, M.x86.R_CX, M.x86.R_DX); HALT_SYS(); break; } } // handle int1a (PCI BIOS Interrupt) static void handleInt1a(void) { // function number in AX u8 bus, devfn, offs; struct device *dev = NULL; switch (M.x86.R_AX) { case 0xb101: // Installation check CLEAR_FLAG(F_CF); // clear CF M.x86.R_EDX = 0x20494350; // " ICP" endian swapped "PCI " M.x86.R_AL = 0x1; // Config Space Mechanism 1 supported M.x86.R_BX = 0x0210; // PCI Interface Level Version 2.10 M.x86.R_CL = 0xff; // number of last PCI Bus in system TODO: check! break; case 0xb102: // Find PCI Device // device_id in CX, vendor_id in DX // device index in SI (i.e. if multiple devices with same vendor/device id // are connected). We currently only support device index 0 // DEBUG_PRINTF_INTR("%s(): function: %x: PCI Find Device\n", __func__, M.x86.R_AX); /* FixME: support SI != 0 */ // only allow the device to find itself... if ((M.x86.R_CX == bios_device.pci_device_id) && (M.x86.R_DX == bios_device.pci_vendor_id) // device index must be 0 && (M.x86.R_SI == 0)) { dev = bios_device.dev; M.x86.R_BH = bios_device.bus; M.x86.R_BL = bios_device.devfn; } else if (CONFIG(YABEL_PCI_ACCESS_OTHER_DEVICES)) { dev = dev_find_device(M.x86.R_DX, M.x86.R_CX, 0); if (dev != NULL) { M.x86.R_BH = dev->upstream->secondary; M.x86.R_BL = dev->path.pci.devfn; DEBUG_PRINTF_INTR ("%s(): function %x: PCI Find Device --> 0x%04x\n", __func__, M.x86.R_AX, M.x86.R_BX); } } if (dev == NULL) { DEBUG_PRINTF_INTR ("%s(): function %x: invalid device/vendor/device index! (%04x/%04x/%02x expected: %04x/%04x/00)\n", __func__, M.x86.R_AX, M.x86.R_CX, M.x86.R_DX, M.x86.R_SI, bios_device.pci_device_id, bios_device.pci_vendor_id); SET_FLAG(F_CF); M.x86.R_AH = 0x86; // return code: device not found return; } CLEAR_FLAG(F_CF); M.x86.R_AH = 0x00; // return code: success break; case 0xb108: //read configuration byte case 0xb109: //read configuration word case 0xb10a: //read configuration dword bus = M.x86.R_BH; devfn = M.x86.R_BL; offs = M.x86.R_DI; DEBUG_PRINTF_INTR("%s(): function: %x: PCI Config Read from device: bus: %02x, devfn: %02x, offset: %02x\n", __func__, M.x86.R_AX, bus, devfn, offs); if ((bus == bios_device.bus) && (devfn == bios_device.devfn)) { dev = bios_device.dev; } else if (CONFIG(YABEL_PCI_ACCESS_OTHER_DEVICES)) { dev = pcidev_path_on_bus(bus, devfn); DEBUG_PRINTF_INTR("%s(): function: %x: pcidev_path_on_bus() returned: %s\n", __func__, M.x86.R_AX, dev_path(dev)); } if (dev == NULL) { printf ("%s(): Config read access invalid device! bus: %02x (%02x), devfn: %02x (%02x), offs: %02x\n", __func__, bus, bios_device.bus, devfn, bios_device.devfn, offs); SET_FLAG(F_CF); M.x86.R_AH = 0x87; //return code: bad pci register HALT_SYS(); return; } switch (M.x86.R_AX) { case 0xb108: M.x86.R_CL = #if CONFIG(PCI_OPTION_ROM_RUN_YABEL) pci_read_config8(dev, offs); #else (u8) rtas_pci_config_read(bios_device.puid, 1, bus, devfn, offs); #endif DEBUG_PRINTF_INTR ("%s(): function %x: PCI Config Read @%02x --> 0x%02x\n", __func__, M.x86.R_AX, offs, M.x86.R_CL); break; case 0xb109: M.x86.R_CX = #if CONFIG(PCI_OPTION_ROM_RUN_YABEL) pci_read_config16(dev, offs); #else (u16) rtas_pci_config_read(bios_device.puid, 2, bus, devfn, offs); #endif DEBUG_PRINTF_INTR ("%s(): function %x: PCI Config Read @%02x --> 0x%04x\n", __func__, M.x86.R_AX, offs, M.x86.R_CX); break; case 0xb10a: M.x86.R_ECX = #if CONFIG(PCI_OPTION_ROM_RUN_YABEL) pci_read_config32(dev, offs); #else (u32) rtas_pci_config_read(bios_device.puid, 4, bus, devfn, offs); #endif DEBUG_PRINTF_INTR ("%s(): function %x: PCI Config Read @%02x --> 0x%08x\n", __func__, M.x86.R_AX, offs, M.x86.R_ECX); break; } CLEAR_FLAG(F_CF); M.x86.R_AH = 0x0; // return code: success break; case 0xb10b: //write configuration byte case 0xb10c: //write configuration word case 0xb10d: //write configuration dword bus = M.x86.R_BH; devfn = M.x86.R_BL; offs = M.x86.R_DI; if ((bus == bios_device.bus) && (devfn == bios_device.devfn)) { dev = bios_device.dev; } if (dev == NULL) { printf ("%s(): Config read access invalid! bus: %x (%x), devfn: %x (%x), offs: %x\n", __func__, bus, bios_device.bus, devfn, bios_device.devfn, offs); SET_FLAG(F_CF); M.x86.R_AH = 0x87; //return code: bad pci register HALT_SYS(); return; } switch (M.x86.R_AX) { case 0xb10b: #if CONFIG(PCI_OPTION_ROM_RUN_YABEL) pci_write_config8(dev, offs, M.x86.R_CL); #else rtas_pci_config_write(bios_device.puid, 1, bus, devfn, offs, M.x86.R_CL); #endif DEBUG_PRINTF_INTR ("%s(): function %x: PCI Config Write @%02x <-- 0x%02x\n", __func__, M.x86.R_AX, offs, M.x86.R_CL); break; case 0xb10c: #if CONFIG(PCI_OPTION_ROM_RUN_YABEL) pci_write_config16(dev, offs, M.x86.R_CX); #else rtas_pci_config_write(bios_device.puid, 2, bus, devfn, offs, M.x86.R_CX); #endif DEBUG_PRINTF_INTR ("%s(): function %x: PCI Config Write @%02x <-- 0x%04x\n", __func__, M.x86.R_AX, offs, M.x86.R_CX); break; case 0xb10d: #if CONFIG(PCI_OPTION_ROM_RUN_YABEL) pci_write_config32(dev, offs, M.x86.R_ECX); #else rtas_pci_config_write(bios_device.puid, 4, bus, devfn, offs, M.x86.R_ECX); #endif DEBUG_PRINTF_INTR ("%s(): function %x: PCI Config Write @%02x <-- 0x%08x\n", __func__, M.x86.R_AX, offs, M.x86.R_ECX); break; } CLEAR_FLAG(F_CF); M.x86.R_AH = 0x0; // return code: success break; default: printf("%s(): unknown function (%x) for int1a handler.\n", __func__, M.x86.R_AX); DEBUG_PRINTF_INTR("AX=%04x BX=%04x CX=%04x DX=%04x\n", M.x86.R_AX, M.x86.R_BX, M.x86.R_CX, M.x86.R_DX); HALT_SYS(); break; } } // main Interrupt Handler routine, should be registered as x86emu interrupt handler void handleInterrupt(int intNum) { u8 int_handled = 0; #ifndef DEBUG_PRINT_INT10 // this printf makes output by int 10 unreadable... // so we only enable it, if int10 print is disabled DEBUG_PRINTF_INTR("%s(%x)\n", __func__, intNum); #endif /* check whether this interrupt has a function pointer set in yabel_intFuncArray and run that */ if (yabel_intFuncArray[intNum]) { DEBUG_PRINTF_INTR("%s(%x) intHandler overridden, calling it...\n", __func__, intNum); int_handled = (*yabel_intFuncArray[intNum])(); } else { switch (intNum) { case 0x10: //BIOS video interrupt case 0x42: // INT 10h relocated by EGA/VGA BIOS case 0x6d: // INT 10h relocated by VGA BIOS // get interrupt vector from IDT (4 bytes per Interrupt starting at address 0 if ((my_rdl(intNum * 4) == 0xF000F065) || //F000:F065 is default BIOS interrupt handler address (my_rdl(intNum * 4) == 0xF4F4F4F4)) //invalid { #if 0 // ignore interrupt... DEBUG_PRINTF_INTR ("%s(%x): invalid interrupt Vector (%08x) found, interrupt ignored...\n", __func__, intNum, my_rdl(intNum * 4)); DEBUG_PRINTF_INTR("AX=%04x BX=%04x CX=%04x DX=%04x\n", M.x86.R_AX, M.x86.R_BX, M.x86.R_CX, M.x86.R_DX); //HALT_SYS(); #endif handleInt10(); int_handled = 1; } break; case 0x16: // Keyboard BIOS Interrupt handleInt16(); int_handled = 1; break; case 0x1a: // PCI BIOS Interrupt handleInt1a(); int_handled = 1; break; case PMM_INT_NUM: /* The self-defined PMM INT number, this is called by * the code in PMM struct, and it is handled by * pmm_handleInt() */ pmm_handleInt(); int_handled = 1; break; default: printf("Interrupt %#x (Vector: %x) not implemented\n", intNum, my_rdl(intNum * 4)); DEBUG_PRINTF_INTR("AX=%04x BX=%04x CX=%04x DX=%04x\n", M.x86.R_AX, M.x86.R_BX, M.x86.R_CX, M.x86.R_DX); int_handled = 1; HALT_SYS(); break; } } // if we did not handle the interrupt, jump to the interrupt vector... if (!int_handled) { setupInt(intNum); } } // prepare and execute Interrupt 10 (VGA Interrupt) void runInt10(void) { // Initialize stack and data segment M.x86.R_SS = STACK_SEGMENT; M.x86.R_DS = DATA_SEGMENT; M.x86.R_SP = STACK_START_OFFSET; // push a HLT instruction and a pointer to it onto the stack // any return will pop the pointer and jump to the HLT, thus // exiting (more or less) cleanly push_word(0xf4f4); //F4=HLT //push_word(M.x86.R_SS); //push_word(M.x86.R_SP + 2); // setupInt will push the current CS and IP to the stack to return to it, // but we want to halt, so set CS:IP to the HLT instruction we just pushed // to the stack M.x86.R_CS = M.x86.R_SS; M.x86.R_IP = M.x86.R_SP; // + 4; CHECK_DBG(DEBUG_TRACE_X86EMU) { X86EMU_trace_on(); } CHECK_DBG(DEBUG_JMP) { M.x86.debug |= DEBUG_TRACEJMP_REGS_F; M.x86.debug |= DEBUG_TRACEJMP_REGS_F; M.x86.debug |= DEBUG_TRACECALL_F; M.x86.debug |= DEBUG_TRACECALL_REGS_F; } setupInt(0x10); DEBUG_PRINTF_INTR("%s(): starting execution of INT10...\n", __func__); X86EMU_exec(); DEBUG_PRINTF_INTR("%s(): execution finished\n", __func__); } // prepare and execute Interrupt 13 (Disk Interrupt) void runInt13(void) { // Initialize stack and data segment M.x86.R_SS = STACK_SEGMENT; M.x86.R_DS = DATA_SEGMENT; M.x86.R_SP = STACK_START_OFFSET; // push a HLT instruction and a pointer to it onto the stack // any return will pop the pointer and jump to the HLT, thus // exiting (more or less) cleanly push_word(0xf4f4); //F4=HLT //push_word(M.x86.R_SS); //push_word(M.x86.R_SP + 2); // setupInt will push the current CS and IP to the stack to return to it, // but we want to halt, so set CS:IP to the HLT instruction we just pushed // to the stack M.x86.R_CS = M.x86.R_SS; M.x86.R_IP = M.x86.R_SP; CHECK_DBG(DEBUG_TRACE_X86EMU) { X86EMU_trace_on(); } CHECK_DBG(DEBUG_JMP) { M.x86.debug |= DEBUG_TRACEJMP_REGS_F; M.x86.debug |= DEBUG_TRACEJMP_REGS_F; M.x86.debug |= DEBUG_TRACECALL_F; M.x86.debug |= DEBUG_TRACECALL_REGS_F; } setupInt(0x13); DEBUG_PRINTF_INTR("%s(): starting execution of INT13...\n", __func__); X86EMU_exec(); DEBUG_PRINTF_INTR("%s(): execution finished\n", __func__); }