bios32.c File Reference

#include "ntvdm.h"
#include <reactos/buildno.h>
#include <reactos/version.h>
#include <debug.h>
#include "emulator.h"
#include "cpu/cpu.h"
#include "cpu/bop.h"
#include "int32.h"
#include <isvbop.h>
#include <bios/bios.h>
#include <bios/rom.h>
#include "bios32.h"
#include "bios32p.h"
#include "dskbios32.h"
#include "kbdbios32.h"
#include "vidbios32.h"
#include "moubios32.h"
#include "memory.h"
#include "io.h"
#include "hardware/cmos.h"
#include "hardware/pic.h"
#include "hardware/pit.h"
#include "hardware/ps2.h"

Include dependency graph for bios32.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	BIOS_MODEL   0xFC
#define	BIOS_SUBMODEL   0x01
#define	BIOS_REVISION   0x00

Functions
	C_ASSERT (sizeof(BiosCopyright) -1<=0x5B)
	C_ASSERT (sizeof(BiosDate) -1==0x08)
static VOID	BiosCharPrint (CHAR Character)
static VOID WINAPI	BiosException (LPWORD Stack)
VOID WINAPI	BiosEquipmentService (LPWORD Stack)
VOID WINAPI	BiosGetMemorySize (LPWORD Stack)
static VOID WINAPI	BiosMiscService (LPWORD Stack)
static VOID WINAPI	BiosRomBasic (LPWORD Stack)
VOID	DosBootsectorInitialize (VOID)
VOID WINAPI	BiosDiskService (LPWORD Stack)
static VOID WINAPI	BiosBootstrapLoader (LPWORD Stack)
static VOID WINAPI	BiosTimeService (LPWORD Stack)
static VOID WINAPI	BiosSystemTimerInterrupt (LPWORD Stack)
static VOID	PicSetIRQMask (USHORT off, USHORT on)
VOID	EnableHwIRQ (UCHAR hwirq, EMULATOR_INT32_PROC func)
VOID	PicIRQComplete (BYTE IntNum)
static VOID WINAPI	BiosHandleMasterPicIRQ (LPWORD Stack)
static VOID WINAPI	BiosHandleSlavePicIRQ (LPWORD Stack)
static VOID WINAPI	BiosTimerIrq (LPWORD Stack)
static VOID	BiosHwSetup (VOID)
static VOID	InitializeBiosInt32 (VOID)
static VOID	InitializeBiosData (VOID)
VOID WINAPI	Bios32Post (LPWORD Stack)
BOOLEAN	Bios32Initialize (VOID)
VOID	Bios32Cleanup (VOID)

Variables
CALLBACK16	BiosContext
static const BIOS_CONFIG_TABLE	BiosConfigTable
static const CHAR	BiosCopyright [] = "0000000 NTVDM IBM COMPATIBLE 486 BIOS COPYRIGHT (C) ReactOS Team 1996-"COPYRIGHT_YEAR
static const CHAR	BiosVersion []
static const CHAR	BiosDate [] = "06/17/13"
static const BYTE	Bootstrap []
static const BYTE	PostCode []

Macro Definition Documentation

BIOS_MODEL

#define BIOS_MODEL   0xFC

Definition at line 110 of file bios32.c.

BIOS_REVISION

#define BIOS_REVISION   0x00

Definition at line 112 of file bios32.c.

BIOS_SUBMODEL

#define BIOS_SUBMODEL   0x01

Definition at line 111 of file bios32.c.

NDEBUG

#define NDEBUG

Definition at line 18 of file bios32.c.

Function Documentation

Bios32Cleanup()

VOID Bios32Cleanup

(

VOID

)

Definition at line 1289 of file bios32.c.

{
    DiskBios32Cleanup();
    MouseBios32Cleanup();
    VidBios32Cleanup();
    KbdBiosCleanup();
}

Referenced by BiosCleanup().

Bios32Initialize()

BOOLEAN Bios32Initialize

(

VOID

)

Definition at line 1246 of file bios32.c.

{
    /*
     * Initialize BIOS/Keyboard/Video ROM static data
     */

    /* System BIOS Copyright */
    RtlCopyMemory(SEG_OFF_TO_PTR(BIOS_SEGMENT, 0xE000), BiosCopyright, sizeof(BiosCopyright)-1);

    /* System BIOS Version */
    RtlCopyMemory(SEG_OFF_TO_PTR(BIOS_SEGMENT, 0xE070), BiosVersion, sizeof(BiosVersion)-1);

    /* System BIOS Date */
    RtlCopyMemory(SEG_OFF_TO_PTR(BIOS_SEGMENT, 0xFFF5), BiosDate, sizeof(BiosDate)-1);

    /* Bootstrap code */
    RtlCopyMemory(SEG_OFF_TO_PTR(BIOS_SEGMENT, 0xE05B), PostCode , sizeof(PostCode ));
    RtlCopyMemory(SEG_OFF_TO_PTR(BIOS_SEGMENT, 0xFFF0), Bootstrap, sizeof(Bootstrap));

    /* BIOS ROM Information */
    RtlCopyMemory(SEG_OFF_TO_PTR(BIOS_SEGMENT, 0xE6F5), &BiosConfigTable, sizeof(BiosConfigTable));

    /* System BIOS Model (same as Bct->Model) */
    *(PBYTE)(SEG_OFF_TO_PTR(BIOS_SEGMENT, 0xFFFE)) = BIOS_MODEL;

    /* Initialize the Keyboard and Video BIOS */
    if (!KbdBiosInitialize() || !VidBiosInitialize() || !MouseBiosInitialize() || !DiskBios32Initialize())
    {
        /* Stop the VDM */
        EmulatorTerminate();
        return FALSE;
    }

    /* Redefine our POST function */
    RegisterBop(BOP_RESET, Bios32Post);

    WriteProtectRom((PVOID)TO_LINEAR(BIOS_SEGMENT, 0x0000),
                    ROM_AREA_END - TO_LINEAR(BIOS_SEGMENT, 0x0000) + 1);

    /* We are done */
    return TRUE;
}

Referenced by BiosInitialize().

Bios32Post()

VOID WINAPI Bios32Post

(

LPWORD

Stack

)

Definition at line 1068 of file bios32.c.

{
    static BOOLEAN FirstBoot = TRUE;
    BYTE ShutdownStatus;

    /*
     * Initialize BIOS/Keyboard/Video RAM dynamic data
     */

    DPRINT("Bios32Post\n");

    /* Disable interrupts */
    setIF(0);

    /* Set the data segment */
    setDS(BDA_SEGMENT);

    /* Initialize the stack */
    // Temporary stack for POST (to be used only before initializing the INT vectors)
    // setSS(0x0000);
    // setSP(0x0400);
    //
    // Stack to be used after the initialization of the INT vectors
    setSS(0x0000);  // Stack at 00:8000, going downwards
    setSP(0x8000);

    /*
     * Perform early CMOS shutdown status checks
     */

    /* Read the CMOS shutdown status byte and reset it */
    IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_SHUTDOWN_STATUS | CMOS_DISABLE_NMI);
    ShutdownStatus = IOReadB(CMOS_DATA_PORT);
    IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_SHUTDOWN_STATUS | CMOS_DISABLE_NMI);
    IOWriteB(CMOS_DATA_PORT, 0x00);

    DPRINT1("Bda->SoftReset = 0x%04X ; ShutdownStatus = 0x%02X\n",
            Bda->SoftReset, ShutdownStatus);

    switch (ShutdownStatus)
    {
        /* Shutdown after Memory Tests (unsupported) */
        case 0x01: case 0x02: case 0x03:
        /* Shutdown after Protected Mode Tests (unsupported) */
        case 0x06: case 0x07: case 0x08:
        /* Shutdown after Block Move Test (unsupported) */
        case 0x09:
        {
            DisplayMessage(L"Unsupported CMOS Shutdown Status value 0x%02X. The VDM will shut down.", ShutdownStatus);
            EmulatorTerminate();
            return;
        }

        /* Shutdown to Boot Loader */
        case 0x04:
        {
            DPRINT1("Fast restart to Bootstrap Loader...\n");
            goto Quit; // Reenable interrupts and exit.
        }

        /* Flush keyboard, issue an EOI... */
        case 0x05:
        {
            IOReadB(PS2_DATA_PORT);

            /* Send EOI */
            IOWriteB(PIC_SLAVE_CMD , PIC_OCW2_EOI);
            IOWriteB(PIC_MASTER_CMD, PIC_OCW2_EOI);

            // Fall back
        }

        /*
         * ... and far JMP to user-specified location at 0040:0067
         * (Bda->ResumeEntryPoint) with interrupts and NMI disabled.
         */
        case 0x0A:
        {
            DPRINT1("Bda->ResumeEntryPoint = %04X:%04X\n",
                    HIWORD(Bda->ResumeEntryPoint),
                    LOWORD(Bda->ResumeEntryPoint));

            /* Position execution pointers and return with interrupts disabled */
            setCS(HIWORD(Bda->ResumeEntryPoint));
            setIP(LOWORD(Bda->ResumeEntryPoint));
            return;
        }

        /* Soft reset or unexpected shutdown... */
        case 0x00:
        /* ... or other possible shutdown codes: just continue the POST */
        default:
            break;
    }

    /*
     * FIXME: UNIMPLEMENTED!
     * Check the word at 0040h:0072h (Bda->SoftReset) and do one of the
     * following actions:
     * - if the word is 0000h, perform a cold reboot (aka. Reset). Everything gets initialized.
     * - if the word is 1234h, perform a warm reboot (aka. Ctrl-Alt-Del). Some stuff is skipped.
     */
    switch (Bda->SoftReset)
    {
        case 0x0000:
        {
            if (!FirstBoot)
            {
                DisplayMessage(L"NTVDM is performing a COLD reboot! The program you are currently testing does not seem to behave correctly! The VDM will shut down...");
                EmulatorTerminate();
                return;
            }
            break;
        }

        case 0x1234:
        {
            DisplayMessage(L"NTVDM is performing a WARM reboot! This is not supported at the moment. The VDM will shut down...");
            EmulatorTerminate();
            return;
        }

        default:
            break;
    }

    FirstBoot = FALSE;

    /* Initialize the BDA */
    InitializeBiosData();

    /* Initialize the User Data Area at 0050:XXXX */
    RtlZeroMemory(SEG_OFF_TO_PTR(0x50, 0x0000), sizeof(USER_DATA_AREA));




    /*
     * Initialize IVT and hardware
     */

    // WriteUnProtectRom(...);

    /* Register the BIOS 32-bit Interrupts */
    InitializeBiosInt32();

    /* Initialize platform hardware (PIC/PIT chips, ...) */
    BiosHwSetup();

    /* Initialize the Keyboard, Video and Mouse BIOS */
    KbdBios32Post();
    VidBiosPost();
    MouseBios32Post();
    DiskBios32Post();

    // WriteProtectRom(...);




    SearchAndInitRoms(&BiosContext);

    /*
     * End of the 32-bit POST portion. We then fall back into 16-bit where
     * the rest of the POST code is executed, typically calling INT 19h
     * to boot up the OS.
     */

Quit:
    /* Enable interrupts */
    setIF(1);
}

Referenced by Bios32Initialize().

BiosBootstrapLoader()

static VOID WINAPI BiosBootstrapLoader ( LPWORD  Stack )

static

Definition at line 567 of file bios32.c.

{
    USHORT BootOrder;

    USHORT AX, BX, CX, DX, ES;
    AX = getAX();
    BX = getBX();
    CX = getCX();
    DX = getDX();
    ES = getES();

    /*
     * Read the boot sequence order from the CMOS, old behaviour AMI-style.
     *
     * For more information, see:
     * http://www.virtualbox.org/svn/vbox/trunk/src/VBox/Devices/PC/BIOS/orgs.asm
     * http://www.virtualbox.org/svn/vbox/trunk/src/VBox/Devices/PC/BIOS/boot.c
     * http://bochs.sourceforge.net/cgi-bin/lxr/source/iodev/cmos.cc
     * https://web.archive.org/web/20111209041013/http://www-ivs.cs.uni-magdeburg.de/~zbrog/asm/cmos.html
     * http://www.bioscentral.com/misc/cmosmap.htm
     */
    IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_SYSOP);
    BootOrder = (IOReadB(CMOS_DATA_PORT) & 0x20) >> 5;

    /*
     * BootOrder =
     * 0: Hard Disk, then Floppy Disk
     * 1: Floppy Disk, then Hard Disk
     * In all cases, if booting from those devices failed,
     * ROM DOS-32 is started. If it fails, INT 18h is called.
     */

    DPRINT("BiosBootstrapLoader (BootOrder = 0x%02X) -->\n", BootOrder);

    /*
     * Format of the BootOrder command:
     * 2 bytes. Each half-byte contains the ID of the drive to boot.
     * Currently defined:
     * 0x0: 1st Floppy disk
     * 0x1: 1st Hard disk
     * Other, or 0xF: Stop boot sequence.
     */
    BootOrder = 0xFF00 | ((1 << (4 * BootOrder)) & 0xFF);

Retry:
    switch (BootOrder & 0x0F)
    {
        /* Boot from 1st floppy drive */
        case 0:
        {
            setAH(0x02); // Read sectors
            setAL(0x01); // Number of sectors
            setDH(0x00); // Head 0
            setCH(0x00); // Cylinder 0
            setCL(0x01); // Sector 1
            setDL(0x00); // First diskette drive (used by loader code, so should not be cleared)
            setES(0x0000);  // Write data in 0000:7C00
            setBX(0x7C00);
            BiosDiskService(Stack);
            if (!(Stack[STACK_FLAGS] & EMULATOR_FLAG_CF)) goto Quit;
#ifdef ADVANCED_DEBUGGING
            DPRINT1("An error happened while loading the bootsector from floppy 0, error = %d\n", getAH());
#endif

            break;
        }

        /* Boot from 1st HDD drive */
        case 1:
        {
            setAH(0x02); // Read sectors
            setAL(0x01); // Number of sectors
            setDH(0x00); // Head 0
            setCH(0x00); // Cylinder 0
            setCL(0x01); // Sector 1
            setDL(0x80); // First HDD drive (used by loader code, so should not be cleared)
            setES(0x0000);  // Write data in 0000:7C00
            setBX(0x7C00);
            BiosDiskService(Stack);
            if (!(Stack[STACK_FLAGS] & EMULATOR_FLAG_CF)) goto Quit;
#ifdef ADVANCED_DEBUGGING
            DPRINT1("An error happened while loading the bootsector from HDD 0, error = %d\n", getAH());
#endif

            break;
        }

        default:
            goto StartDos;
    }

    /* Go to next drive and invalidate the last half-byte. */
    BootOrder = (BootOrder >> 4) | 0xF000;
    goto Retry;

StartDos:
    /* Clear everything, we are going to load DOS32 */
    setAX(AX);
    setBX(BX);
    setCX(CX);
    setDX(DX);
    setES(ES);
    Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;

    /* Load our DOS */
    DosBootsectorInitialize();

Quit:
    /*
     * Jump to 0000:7C00 to boot the OS.
     *
     * Since we are called via the INT32 mechanism, we need to correctly set
     * CS:IP, not by changing the current one (otherwise the interrupt could
     * not be clean up and return properly), but by changing the CS:IP in the
     * stack, so that when the interrupt returns, the modified CS:IP is popped
     * off the stack and the CPU is correctly repositioned.
     */
    Stack[STACK_CS] = 0x0000;
    Stack[STACK_IP] = 0x7C00;

    DPRINT("<-- BiosBootstrapLoader\n");
}

Referenced by InitializeBiosInt32().

BiosCharPrint()

static VOID BiosCharPrint ( CHAR  Character )

static

Definition at line 168 of file bios32.c.

{
    /* Save AX and BX */
    USHORT AX = getAX();
    USHORT BX = getBX();

    /*
     * Set the parameters:
     * AL contains the character to print,
     * BL contains the character attribute,
     * BH contains the video page to use.
     */
    setAL(Character);
    setBL(DEFAULT_ATTRIBUTE);
    setBH(Bda->VideoPage);

    /* Call the BIOS INT 10h, AH=0Eh "Teletype Output" */
    setAH(0x0E);
    Int32Call(&BiosContext, BIOS_VIDEO_INTERRUPT);

    /* Restore AX and BX */
    setBX(BX);
    setAX(AX);
}

Referenced by BiosRomBasic().

BiosDiskService()

VOID WINAPI BiosDiskService

(

LPWORD

Stack

)

Definition at line 164 of file dskbios32.c.

{
    BYTE Drive;
    PDISK_IMAGE DiskImage;

    switch (getAH())
    {
        /* Disk -- Reset Disk System */
        case 0x00:
        {
            Drive = getDL();

            if (Drive & 0x80)
            {
                AllDisksReset();

                /* Return success */
                setAH(0x00);
                Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
                break;
            }

            Drive &= ~0x80;

            if (Drive >= ARRAYSIZE(FloppyDrive))
            {
                DPRINT1("BiosDiskService(0x00): Drive number 0x%02X invalid\n", Drive);

                /* Return error */
                setAH(0x01);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
                break;
            }

            // TODO: Reset drive

            /* Return success */
            setAH(0x00);
            Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            break;
        }

        /* Disk -- Get Status of Last Operation */
        case 0x01:
        {
            BYTE LastOperationStatus = 0x00;

            Drive = getDL();
            DiskImage = GetDisk(Drive);
            if (!DiskImage || !IsDiskPresent(DiskImage))
            {
                DPRINT1("BiosDiskService(0x01): Disk number 0x%02X invalid\n", Drive);

                /* Return error */
                setAH(0x01);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
                break;
            }

            LastOperationStatus = DiskImage->LastOperationStatus;

            if (Drive & 0x80)
                Bda->LastDiskOperation = LastOperationStatus;
            else
                Bda->LastDisketteOperation = LastOperationStatus;

            /* Return last error */
            setAH(LastOperationStatus);
            if (LastOperationStatus == 0x00)
                Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            else
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;

            break;
        }

        /* Disk -- Read Sectors into Memory */
        case 0x02:
        {
            BYTE Status;
            BYTE Head = getDH();
            BYTE NumSectors = getAL();

            // CH: Low eight bits of cylinder number
            // CL: High two bits of cylinder (bits 6-7, hard disk only)
            WORD Cylinder = MAKEWORD(getCH(), (getCL() >> 6) & 0x02);

            // CL: Sector number 1-63 (bits 0-5)
            BYTE Sector = (getCL() & 0x3F); // 1-based

            Drive = getDL();
            DiskImage = GetDisk(Drive);
            if (!DiskImage || !IsDiskPresent(DiskImage))
            {
                DPRINT1("BiosDiskService(0x02): Disk number 0x%02X invalid\n", Drive);

                /* Return error */
                setAH(0x01);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
                break;
            }

            /* Read the sectors */
            Status = ReadDisk(DiskImage, Cylinder, Head, Sector, NumSectors);
            if (Status == 0x00)
            {
                /* Return success */
                setAH(0x00);
                Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            }
            else
            {
                DPRINT1("BiosDiskService(0x02): Error when reading from disk number 0x%02X (0x%02X)\n", Drive, Status);

                /* Return error */
                setAH(Status);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
            }

            break;
        }

        /* Disk -- Write Disk Sectors */
        case 0x03:
        {
            BYTE Status;
            BYTE Head = getDH();
            BYTE NumSectors = getAL();

            // CH: Low eight bits of cylinder number
            // CL: High two bits of cylinder (bits 6-7, hard disk only)
            WORD Cylinder = MAKEWORD(getCH(), (getCL() >> 6) & 0x02);

            // CL: Sector number 1-63 (bits 0-5)
            BYTE Sector = (getCL() & 0x3F); // 1-based

            Drive = getDL();
            DiskImage = GetDisk(Drive);
            if (!DiskImage || !IsDiskPresent(DiskImage))
            {
                DPRINT1("BiosDiskService(0x03): Disk number 0x%02X invalid\n", Drive);

                /* Return error */
                setAH(0x01);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
                break;
            }

            /* Write the sectors */
            Status = WriteDisk(DiskImage, Cylinder, Head, Sector, NumSectors);
            if (Status == 0x00)
            {
                /* Return success */
                setAH(0x00);
                Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            }
            else
            {
                DPRINT1("BiosDiskService(0x03): Error when writing to disk number 0x%02X (0x%02X)\n", Drive, Status);

                /* Return error */
                setAH(Status);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
            }

            break;
        }

        /* Disk -- Verify Disk Sectors */
        case 0x04:

        /* Floppy/Fixed Disk -- Format Track */
        case 0x05:

        /* Fixed Disk -- Format Track and Set Bad Sector Flags */
        case 0x06:

        /* Fixed Disk -- Format Drive starting at Given Track */
        case 0x07:
            goto Default;

        /* Disk -- Get Drive Parameters */
        case 0x08:
        {
            WORD MaxCylinders;
            BYTE MaxHeads;
            BYTE PresentDrives = 0;
            BYTE i;

            Drive = getDL();
            DiskImage = GetDisk(Drive);
            if (!DiskImage || !IsDiskPresent(DiskImage))
            {
                DPRINT1("BiosDiskService(0x08): Disk number 0x%02X invalid\n", Drive);

                /* Return error */
                setAH(0x01);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
                break;
            }

            // Minus 2 because it's the maximum cylinder number (not count),
            // and the last cylinder is reserved (for compatibility with BIOSes
            // which reserve it for testing purposes).
            MaxCylinders = DiskImage->DiskInfo.Cylinders - 2;
            // Minus 1 because it's the maximum head number (not count).
            MaxHeads     = DiskImage->DiskInfo.Heads - 1;

            // CL: Sector number 1-63 (bits 0-5)
            //     High two bits of cylinder (bits 6-7, hard disk only)
            setCL((DiskImage->DiskInfo.Sectors & 0x3F) |
                  ((HIBYTE(MaxCylinders) & 0x02) << 6));
            // CH: Low eight bits of cylinder number
            setCH(LOBYTE(MaxCylinders));

            setDH(MaxHeads);

            if (Drive & 0x80)
            {
                /* Count the number of active HDDs */
                for (i = 0; i < ARRAYSIZE(HardDrive); ++i)
                {
                    if (IsDiskPresent(HardDrive[i]))
                        ++PresentDrives;
                }

                /* Reset ES:DI to NULL */
                // FIXME: NONONO!! Apps expect (for example, MS-DOS kernel)
                // that this function does not modify ES:DI if it was called
                // for a HDD.
                // setES(0x0000);
                // setDI(0x0000);
            }
            else
            {
                /* Count the number of active floppies */
                for (i = 0; i < ARRAYSIZE(FloppyDrive); ++i)
                {
                    if (IsDiskPresent(FloppyDrive[i]))
                        ++PresentDrives;
                }

                /* ES:DI points to the floppy parameter table */
                setES(HIWORD(((PULONG)BaseAddress)[0x1E]));
                setDI(LOWORD(((PULONG)BaseAddress)[0x1E]));
            }
            setDL(PresentDrives);

            setBL(DiskImage->DiskType); // DiskGeometryList[DiskImage->DiskType].biosval
            setAL(0x00);

            /* Return success */
            setAH(0x00);
            Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            break;
        }

        /* Hard Disk -- Initialize Controller with Drive Parameters */
        case 0x09:

        /* Hard Disk -- Read Long Sectors */
        case 0x0A:

        /* Hard Disk -- Write Long Sectors */
        case 0x0B:
            goto Default;

        /* Hard Disk -- Seek to Cylinder */
        case 0x0C:
        {
            BYTE Status;
            BYTE Head = getDH();

            // CH: Low eight bits of cylinder number
            // CL: High two bits of cylinder (bits 6-7, hard disk only)
            WORD Cylinder = MAKEWORD(getCH(), (getCL() >> 6) & 0x02);

            // CL: Sector number 1-63 (bits 0-5)
            BYTE Sector = (getCL() & 0x3F); // 1-based

            Drive = getDL();
            if (!(Drive & 0x80))
            {
                DPRINT1("BiosDiskService(0x0C): Disk number 0x%02X is not a HDD\n", Drive);

                /* Return error */
                setAH(0x01);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
                break;
            }

            DiskImage = GetDisk(Drive);
            if (!DiskImage || !IsDiskPresent(DiskImage))
            {
                DPRINT1("BiosDiskService(0x0C): Disk number 0x%02X invalid\n", Drive);

                /* Return error */
                setAH(0x01);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
                break;
            }

            /* Set position */
            Status = SeekDisk(DiskImage, Cylinder, Head, Sector);
            if (Status == 0x00)
            {
                /* Return success */
                setAH(0x00);
                Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            }
            else
            {
                DPRINT1("BiosDiskService(0x0C): Error when seeking in disk number 0x%02X (0x%02X)\n", Drive, Status);

                /* Return error */
                setAH(Status);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
            }

            break;
        }

        /* Hard Disk -- Reset Hard Disks */
        case 0x0D:
        {
            // FIXME: Should do what 0x11 does.
            UNIMPLEMENTED;
        }

        /* Hard Disk -- Read Sector Buffer (XT only) */
        case 0x0E:

        /* Hard Disk -- Write Sector Buffer (XT only) */
        case 0x0F:
            goto Default;

        /* Hard Disk -- Check if Drive is ready */
        case 0x10:
        {
            Drive = getDL();
            if (!(Drive & 0x80))
            {
                DPRINT1("BiosDiskService(0x10): Disk number 0x%02X is not a HDD\n", Drive);

                /* Return error */
                setAH(0x01);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
                break;
            }

            DiskImage = GetDisk(Drive);
            if (!DiskImage || !IsDiskPresent(DiskImage))
            {
                DPRINT1("BiosDiskService(0x10): Disk number 0x%02X invalid\n", Drive);

                /* Return error */
                setAH(0x01);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
                break;
            }

            /* Return success */
            setAH(0x00);
            Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            break;
        }

        /* Hard Disk -- Recalibrate Drive */
        case 0x11:
        {
            BYTE Status;

            Drive = getDL();
            if (!(Drive & 0x80))
            {
                DPRINT1("BiosDiskService(0x11): Disk number 0x%02X is not a HDD\n", Drive);

                /* Return error */
                setAH(0x01);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
                break;
            }

            DiskImage = GetDisk(Drive);
            if (!DiskImage || !IsDiskPresent(DiskImage))
            {
                DPRINT1("BiosDiskService(0x11): Disk number 0x%02X invalid\n", Drive);

                /* Return error */
                setAH(0x01);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
                break;
            }

            /* Set position to zero */
            Status = SeekDisk(DiskImage, /*Cylinder*/ 0, /*Head*/ 0, /*Sector*/ 1);
            if (Status == 0x00)
            {
                /* Return success */
                setAH(0x00);
                Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            }
            else
            {
                DPRINT1("BiosDiskService(0x11): Error when recalibrating disk number 0x%02X (0x%02X)\n", Drive, Status);

                /* Return error */
                setAH(Status);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
            }

            break;
        }

        /* Hard Disk -- Controller RAM Diagnostic */
        case 0x12:

        /* Hard Disk -- Drive Diagnostic */
        case 0x13:

        /* Hard Disk -- Controller Internal Diagnostic */
        case 0x14:
            goto Default;

        /* Disk -- Get Disk Type */
        case 0x15:
        {
            Drive = getDL();
            DiskImage = GetDisk(Drive);
            if (!DiskImage || !IsDiskPresent(DiskImage))
            {
                DPRINT1("BiosDiskService(0x15): Disk number 0x%02X invalid\n", Drive);

                /* Return error */
                setAH(0x01);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
                break;
            }

            if (Drive & 0x80)
            {
                ULONG NumSectors;

                /* Hard disk */
                setAH(0x03);

                /* Number of 512-byte sectors in CX:DX */
                NumSectors = (ULONG)((ULONG)DiskImage->DiskInfo.Cylinders * DiskImage->DiskInfo.Heads)
                                                                          * DiskImage->DiskInfo.Sectors;
                setCX(HIWORD(NumSectors));
                setDX(LOWORD(NumSectors));
            }
            else
            {
                /* Floppy */
                setAH(0x01);
            }

            /* Return success */
            Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            break;
        }

        /* Floppy Disk -- Detect Disk Change */
        case 0x16:

        /* Floppy Disk -- Set Disk Type for Format */
        case 0x17:

        /* Disk -- Set Media Type for Format */
        case 0x18:
            goto Default;

        default: Default:
        {
            DPRINT1("BIOS Function INT 13h, AH = 0x%02X, AL = 0x%02X, BH = 0x%02X NOT IMPLEMENTED\n",
                    getAH(), getAL(), getBH());
        }
    }
}

Referenced by BiosBootstrapLoader(), and DiskBios32Post().

BiosEquipmentService()

VOID WINAPI BiosEquipmentService

(

LPWORD

Stack

)

Definition at line 200 of file bios32.c.

{
    /* Return the equipment list */
    setAX(Bda->EquipmentList);
}

Referenced by BiosInitialize(), and InitializeBiosInt32().

BiosException()

static VOID WINAPI BiosException ( LPWORD  Stack )

static

Definition at line 193 of file bios32.c.

{
    /* Get the exception number and call the emulator API */
    BYTE ExceptionNumber = LOBYTE(Stack[STACK_INT_NUM]);
    EmulatorException(ExceptionNumber, Stack);
}

Referenced by InitializeBiosInt32().

BiosGetMemorySize()

VOID WINAPI BiosGetMemorySize

(

LPWORD

Stack

)

Definition at line 206 of file bios32.c.

{
    /* Return the conventional memory size in kB, typically 640 kB */
    setAX(Bda->MemorySize);
}

Referenced by BiosInitialize(), and InitializeBiosInt32().

BiosHandleMasterPicIRQ()

static VOID WINAPI BiosHandleMasterPicIRQ ( LPWORD  Stack )

static

Definition at line 834 of file bios32.c.

{
    BYTE IrqNumber;

    IOWriteB(PIC_MASTER_CMD, PIC_OCW3_READ_ISR /* == 0x0B */);
    IrqNumber = IOReadB(PIC_MASTER_CMD);

    DPRINT("Master - IrqNumber = 0x%02X\n", IrqNumber);

    PicIRQComplete(LOBYTE(Stack[STACK_INT_NUM]));
}

Referenced by InitializeBiosInt32().

BiosHandleSlavePicIRQ()

static VOID WINAPI BiosHandleSlavePicIRQ ( LPWORD  Stack )

static

Definition at line 846 of file bios32.c.

{
    BYTE IrqNumber;

    IOWriteB(PIC_SLAVE_CMD, PIC_OCW3_READ_ISR /* == 0x0B */);
    IrqNumber = IOReadB(PIC_SLAVE_CMD);

    DPRINT("Slave - IrqNumber = 0x%02X\n", IrqNumber);

    PicIRQComplete(LOBYTE(Stack[STACK_INT_NUM]));
}

Referenced by InitializeBiosInt32().

BiosHwSetup()

static VOID BiosHwSetup ( VOID  )

static

Definition at line 897 of file bios32.c.

{
    /* Initialize the master and the slave PICs (cascade mode) */
    IOWriteB(PIC_MASTER_CMD, PIC_ICW1 | PIC_ICW1_ICW4);
    IOWriteB(PIC_SLAVE_CMD , PIC_ICW1 | PIC_ICW1_ICW4);

    /*
     * Set the interrupt vector offsets for each PIC
     * (base IRQs: 0x08-0x0F for IRQ 0-7, 0x70-0x77 for IRQ 8-15)
     */
    IOWriteB(PIC_MASTER_DATA, BIOS_PIC_MASTER_INT);
    IOWriteB(PIC_SLAVE_DATA , BIOS_PIC_SLAVE_INT );

    /* Tell the master PIC that there is a slave PIC at IRQ 2 */
    IOWriteB(PIC_MASTER_DATA, 1 << 2);
    /* Tell the slave PIC its cascade identity */
    IOWriteB(PIC_SLAVE_DATA , 2);

    /* Make sure both PICs are in 8086 mode */
    IOWriteB(PIC_MASTER_DATA, PIC_ICW4_8086);
    IOWriteB(PIC_SLAVE_DATA , PIC_ICW4_8086);

    /* Clear the masks for both PICs */
    // IOWriteB(PIC_MASTER_DATA, 0x00);
    // IOWriteB(PIC_SLAVE_DATA , 0x00);
    /* Disable all IRQs */
    IOWriteB(PIC_MASTER_DATA, 0xFF);
    IOWriteB(PIC_SLAVE_DATA , 0xFF);


    /* Initialize PIT Counter 0 - Mode 2, 16bit binary count */
    // NOTE: Some BIOSes set it to Mode 3 instead.
    IOWriteB(PIT_COMMAND_PORT, 0x34);
    // 18.2Hz refresh rate
    IOWriteB(PIT_DATA_PORT(0), 0x00);
    IOWriteB(PIT_DATA_PORT(0), 0x00);

    /* Initialize PIT Counter 1 - Mode 2, 8bit binary count */
    IOWriteB(PIT_COMMAND_PORT, 0x54);
    // DRAM refresh every 15ms: http://www.cs.dartmouth.edu/~spl/Academic/Organization/docs/PC%20Timer%208253.html
    IOWriteB(PIT_DATA_PORT(1),   18);

    /* Initialize PIT Counter 2 - Mode 3, 16bit binary count */
    IOWriteB(PIT_COMMAND_PORT, 0xB6);
    // Count for 440Hz
    IOWriteB(PIT_DATA_PORT(2), 0x97);
    IOWriteB(PIT_DATA_PORT(2), 0x0A);


    /* Initialize PS/2 keyboard port */
    // Enable the port
    IOWriteB(PS2_CONTROL_PORT, 0xAE);
    // Port interrupts and clock enabled,
    // enable keyboard scancode translation.
    // POST passed, force keyboard unlocking.
    IOWriteB(PS2_CONTROL_PORT, 0x60);
    IOWriteB(PS2_DATA_PORT   , 0x6D);
    // Enable data reporting
    IOWriteB(PS2_DATA_PORT   , 0xF4);

    EnableHwIRQ(0, BiosTimerIrq);
}

Referenced by Bios32Post().

BiosMiscService()

static VOID WINAPI BiosMiscService ( LPWORD  Stack )

static

Definition at line 212 of file bios32.c.

{
    switch (getAH())
    {
        /* OS Hooks for Multitasking */
        case 0x80:  // Device Open
        case 0x81:  // Device Close
        case 0x82:  // Program Termination
        case 0x90:  // Device Busy
        case 0x91:  // Device POST
        {
            /* Return success by default */
            setAH(0x00);
            Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            break;
        }

        /* Wait on External Event */
        case 0x41:
        {
            BYTE Value;
            BOOLEAN Return;
            static DWORD StartingCount;

            /* Check if this is the first time this BOP occurred */
            if (!getCF())
            {
                /* Set the starting count */
                StartingCount = Bda->TickCounter;
            }

            if (getBL() != 0 && (Bda->TickCounter - StartingCount) >= getBL())
            {
                /* Timeout expired */
                setCF(0);
                break;
            }

            if (getAL() & (1 << 4))
            {
                /* Read from the I/O port */
                Value = IOReadB(getDX());
            }
            else
            {
                /* Read from the memory */
                Value = *(LPBYTE)SEG_OFF_TO_PTR(getES(), getDI());
            }

            switch (getAL() & 7)
            {
                /* Any external event */
                case 0:
                {
                    /* Return if this is not the first time the BOP occurred */
                    Return = getCF();
                    break;
                }

                /* Compare and return if equal */
                case 1:
                {
                    Return = Value == getBH();
                    break;
                }

                /* Compare and return if not equal */
                case 2:
                {
                    Return = Value != getBH();
                    break;
                }

                /* Test and return if not zero */
                case 3:
                {
                    Return = (Value & getBH()) != 0;
                    break;
                }

                /* Test and return if zero */
                case 4:
                {
                    Return = (Value & getBH()) == 0;
                    break;
                }

                default:
                {
                    DPRINT1("INT 15h, AH = 41h - Unknown condition type: %u\n", getAL() & 7);
                    Return = TRUE;
                    break;
                }
            }

            /* Repeat the BOP if we shouldn't return */
            setCF(!Return);
            break;
        }

        /* Keyboard intercept */
        case 0x4F:
        {
            /* CF should be set but let's just set it again just in case */
            /* Do not modify AL (the hardware scan code), but set CF to continue processing */
            // setCF(1);
            Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
            break;
        }

        /* Wait */
        case 0x86:
        {
            /*
             * Interval in microseconds in CX:DX
             * See Ralf Brown: http://www.ctyme.com/intr/rb-1525.htm
             * for more information.
             */

            static ULONG CompletionTime = 0;

            /* Check if we're already looping */
            if (getCF())
            {
                if (GetTickCount() >= CompletionTime)
                {
                    /* Stop looping */
                    setCF(0);

                    /* Clear the CF on the stack too */
                    Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
                }
            }
            else
            {
                /* Set the CF on the stack */
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;

                /* Set the completion time and start looping */
                CompletionTime = GetTickCount() + (MAKELONG(getDX(), getCX()) / 1000);
                setCF(1);
            }

            break;
        }

        /* Copy Extended Memory */
        case 0x87:
        {
            DWORD Count = (DWORD)getCX() * 2;
            PFAST486_GDT_ENTRY Gdt = (PFAST486_GDT_ENTRY)SEG_OFF_TO_PTR(getES(), getSI());
            DWORD SourceBase = Gdt[2].Base + (Gdt[2].BaseMid << 16) + (Gdt[2].BaseHigh << 24);
            DWORD SourceLimit = Gdt[2].Limit + (Gdt[2].LimitHigh << 16);
            DWORD DestBase = Gdt[3].Base + (Gdt[3].BaseMid << 16) + (Gdt[3].BaseHigh << 24);
            DWORD DestLimit = Gdt[3].Limit + (Gdt[3].LimitHigh << 16);

            /* Check for flags */
            if (Gdt[2].Granularity) SourceLimit = (SourceLimit << 12) | 0xFFF;
            if (Gdt[3].Granularity) DestLimit = (DestLimit << 12) | 0xFFF;

            if ((Count > SourceLimit) || (Count > DestLimit))
            {
                setAX(0x80);
                Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
                break;
            }

            /* Copy */
            RtlMoveMemory((PVOID)((ULONG_PTR)BaseAddress + DestBase),
                          (PVOID)((ULONG_PTR)BaseAddress + SourceBase),
                          Count);

            setAX(ERROR_SUCCESS);
            Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            break;
        }

        /* Get Extended Memory Size */
        case 0x88:
        {
            UCHAR Low, High;

            /*
             * Return the (usable) extended memory (after 1 MB)
             * size in kB from CMOS.
             */
            IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_ACTUAL_EXT_MEMORY_LOW  | CMOS_DISABLE_NMI);
            Low  = IOReadB(CMOS_DATA_PORT);
            IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_ACTUAL_EXT_MEMORY_HIGH | CMOS_DISABLE_NMI);
            High = IOReadB(CMOS_DATA_PORT);
            setAX(MAKEWORD(Low, High));

            /* Clear CF */
            Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            break;
        }

        /* Switch to Protected Mode */
        case 0x89:
        {
            DPRINT1("BIOS INT 15h, AH=89h \"Switch to Protected Mode\" is UNIMPLEMENTED");

            Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
            goto Default;
        }

        /* Get Configuration */
        case 0xC0:
        {
            /* Return the BIOS ROM Configuration Table address in ES:BX */
            // The BCT is found at F000:E6F5 for 100% compatible BIOSes.
            setES(BIOS_SEGMENT);
            setBX(0xE6F5);

            /* Call successful; clear CF */
            setAH(0x00);
            Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            break;
        }

        /* Return Extended-Bios Data-Area Segment Address (PS) */
        case 0xC1:
        {
            /* We do not support EBDA yet */
            UNIMPLEMENTED;
            Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
            goto Default;
        }

        /* Pointing Device BIOS Interface (PS) */
        case 0xC2:
        {
            // FIXME: Reenable this call when we understand why
            // our included mouse driver doesn't correctly reeanble
            // mouse reporting!
            // BiosMousePs2Interface(Stack);
            // break;
            goto Default;
        }

        /* Get CPU Type and Mask Revision */
        case 0xC9:
        {
            /*
             * We can see this function as a CPUID replacement.
             * See Ralf Brown: http://www.ctyme.com/intr/rb-1613.htm
             * for more information.
             */

            /*
             * Fast486 is a 486DX with FPU included,
             * but old enough to not support CPUID.
             */
            setCX(0x0400);

            /* Call successful; clear CF */
            setAH(0x00);
            Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            break;
        }

        /* Get System Memory Map */
        case 0xE8:
        {
            if (getAL() == 0x01)
            {
                /* The amount of memory between 1M and 16M, in kilobytes */
                ULONG Above1M = (min(MAX_ADDRESS, 0x01000000) - 0x00100000) >> 10;

                /* The amount of memory above 16M, in 64K blocks */
                ULONG Above16M = (MAX_ADDRESS > 0x01000000) ? ((MAX_ADDRESS - 0x01000000) >> 16) : 0;

                setAX(Above1M);
                setBX(Above16M);
                setCX(Above1M);
                setDX(Above16M);

                Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            }
            else if (getAL() == 0x20 && getEDX() == 'SMAP')
            {
                ULONG Offset = getEBX();
                ULONG Length;
                ULONG BytesWritten = 0;
                BOOLEAN Hooked;
                PBIOS_MEMORY_MAP Map = (PBIOS_MEMORY_MAP)SEG_OFF_TO_PTR(getES(), getDI());

                /* Assume the buffer won't be large enough */
                Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;

                while (BytesWritten < getECX() && (ULONG_PTR)Map < (MAX_ADDRESS - sizeof(BIOS_MEMORY_MAP)))
                {
                    /* Let's ask our memory controller */
                    if (!MemQueryMemoryZone(Offset, &Length, &Hooked))
                    {
                        /* No more memory blocks */
                        Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
                        break;
                    }

                    Map->BaseAddress = (ULONGLONG)Offset;
                    Map->Length = (ULONGLONG)Length;
                    Map->Type = Hooked ? BIOS_MEMORY_RESERVED : BIOS_MEMORY_AVAILABLE;

                    /* Go to the next record */
                    Map++;
                    Offset += Length;
                    BytesWritten += sizeof(BIOS_MEMORY_MAP);
                }

                setEAX('SMAP');
                setEBX(Offset);
                setECX(BytesWritten);
            }
            else
            {
                DPRINT1("BIOS Function INT 15h, AH = 0xE8 - unexpected AL = %02X, EDX = %08X\n",
                        getAL(), getEDX());
            }

            break;
        }

        default: Default:
        {
            DPRINT1("BIOS Function INT 15h, AH = 0x%02X NOT IMPLEMENTED\n",
                    getAH());

            /*
             * The original signification of the error code 0x86 is that
             * no PC Cassette is present. The CF is also set in this case.
             * To keep backward compatibility, newer BIOSes use this value
             * to indicate an unimplemented call in INT 15h.
             */
            setAH(0x86);
            Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
        }
    }
}

Referenced by InitializeBiosInt32().

BiosRomBasic()

static VOID WINAPI BiosRomBasic ( LPWORD  Stack )

static

Definition at line 552 of file bios32.c.

{
    PrintMessageAnsi(BiosCharPrint, "FATAL: INT18: BOOT FAILURE.");

    /* ROM Basic is unsupported, display a message to the user */
    DisplayMessage(L"NTVDM doesn't support ROM Basic. The VDM is closing.");

    /* Stop the VDM */
    EmulatorTerminate();
}

Referenced by InitializeBiosInt32().

BiosSystemTimerInterrupt()

static VOID WINAPI BiosSystemTimerInterrupt ( LPWORD  Stack )

static

Definition at line 786 of file bios32.c.

{
    /* Increase the system tick count */
    Bda->TickCounter++;
}

Referenced by InitializeBiosInt32().

BiosTimerIrq()

static VOID WINAPI BiosTimerIrq ( LPWORD  Stack )

static

Definition at line 859 of file bios32.c.

{
    /*
     * Perform the system timer interrupt.
     *
     * Do not call directly BiosSystemTimerInterrupt(Stack);
     * because some programs may hook only BIOS_SYS_TIMER_INTERRUPT
     * for their purpose...
     */

    WORD AX = getAX();
    WORD CX = getCX();
    WORD DX = getDX();
    WORD BX = getBX();
    WORD BP = getBP();
    WORD SI = getSI();
    WORD DI = getDI();
    WORD DS = getDS();
    WORD ES = getES();

    Int32Call(&BiosContext, BIOS_SYS_TIMER_INTERRUPT);

    setAX(AX);
    setCX(CX);
    setDX(DX);
    setBX(BX);
    setBP(BP);
    setSI(SI);
    setDI(DI);
    setDS(DS);
    setES(ES);
    setCF(0);

    // BiosSystemTimerInterrupt(Stack);
    PicIRQComplete(LOBYTE(Stack[STACK_INT_NUM]));
}

Referenced by BiosHwSetup().

BiosTimeService()

static VOID WINAPI BiosTimeService ( LPWORD  Stack )

static

Definition at line 690 of file bios32.c.

{
    switch (getAH())
    {
        /* Get System Time */
        case 0x00:
        {
            /* Set AL to 1 if midnight had passed, 0 otherwise */
            setAL(Bda->MidnightPassed ? 0x01 : 0x00);

            /* Return the tick count in CX:DX */
            setCX(HIWORD(Bda->TickCounter));
            setDX(LOWORD(Bda->TickCounter));

            /* Reset the midnight flag */
            Bda->MidnightPassed = FALSE;

            break;
        }

        /* Set System Time */
        case 0x01:
        {
            /* Set the tick count to CX:DX */
            Bda->TickCounter = MAKELONG(getDX(), getCX());

            /* Reset the midnight flag */
            Bda->MidnightPassed = FALSE;

            break;
        }

        /* Get Real-Time Clock Time */
        case 0x02:
        {
            UCHAR StatusB;

            IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_HOURS);
            setCH(IOReadB(CMOS_DATA_PORT));

            IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_MINUTES);
            setCL(IOReadB(CMOS_DATA_PORT));

            IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_SECONDS);
            setDH(IOReadB(CMOS_DATA_PORT));

            /* Daylight Savings Time */
            IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_STATUS_B);
            StatusB = IOReadB(CMOS_DATA_PORT);
            setDL(StatusB & 0x01);

            /* Clear CF */
            Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            break;
        }

        // /* Set Real-Time Clock Time */
        // case 0x03:
        // {
        //     break;
        // }

        /* Get Real-Time Clock Date */
        case 0x04:
        {
            IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_CENTURY);
            setCH(IOReadB(CMOS_DATA_PORT));

            IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_YEAR);
            setCL(IOReadB(CMOS_DATA_PORT));

            IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_MONTH);
            setDH(IOReadB(CMOS_DATA_PORT));

            IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_DAY);
            setDL(IOReadB(CMOS_DATA_PORT));

            /* Clear CF */
            Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
            break;
        }

        // /* Set Real-Time Clock Date */
        // case 0x05:
        // {
        //     break;
        // }

        default:
        {
            DPRINT1("BIOS Function INT 1Ah, AH = 0x%02X NOT IMPLEMENTED\n",
                    getAH());
        }
    }
}

Referenced by InitializeBiosInt32().

C_ASSERT() [1/2]

C_ASSERT

(

sizeof(BiosCopyright) -1<=

0x5B

)

C_ASSERT() [2/2]

C_ASSERT

(

sizeof(BiosDate) -

1 = =0x08

)

DosBootsectorInitialize()

VOID DosBootsectorInitialize

(

VOID

)

Definition at line 1089 of file dem.c.

{
    /* We write the bootsector at 0000:7C00 */
    ULONG_PTR StartAddress = (ULONG_PTR)SEG_OFF_TO_PTR(0x0000, 0x7C00);
    ULONG_PTR Address = StartAddress;
    CHAR DosKernelFileName[] = ""; // No DOS BIOS file name, therefore we will load DOS32

    DPRINT("DosBootsectorInitialize\n");

    /* Write the "bootsector" */
    RtlCopyMemory((PVOID)Address, Bootsector1, sizeof(Bootsector1));
    Address += sizeof(Bootsector1);
    RtlCopyMemory((PVOID)Address, DosKernelFileName, sizeof(DosKernelFileName));
    Address += sizeof(DosKernelFileName);
    RtlCopyMemory((PVOID)Address, Bootsector2, sizeof(Bootsector2));
    Address += sizeof(Bootsector2);

    /* Initialize the callback context */
    InitializeContext(&DosContext, 0x0000,
                      (ULONG_PTR)MEM_ALIGN_UP(0x7C00 + Address - StartAddress, sizeof(WORD)));

    /* Register the DOS Loading BOP */
    RegisterBop(BOP_LOAD_DOS, DosInitialize);
}

Referenced by BiosBootstrapLoader().

EnableHwIRQ()

VOID EnableHwIRQ	(	UCHAR	hwirq,
		EMULATOR_INT32_PROC	func
	)

Definition at line 802 of file bios32.c.

{
    UCHAR vector;

    PicSetIRQMask(1 << hwirq, 0);
    if (hwirq < 8)
        vector = BIOS_PIC_MASTER_INT + hwirq;
    else
        vector = BIOS_PIC_SLAVE_INT  + hwirq - 8;

    RegisterBiosInt32(vector, func);
}

Referenced by BiosHwSetup(), KbdBios32Post(), and MouseBios32Post().

InitializeBiosData()

static VOID InitializeBiosData ( VOID  )

static

Definition at line 1036 of file bios32.c.

{
    UCHAR Low, High;

    /* Initialize the BDA contents */
    RtlZeroMemory(Bda, sizeof(*Bda));

    /*
     * Retrieve the basic equipment list from the CMOS
     */
    IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_EQUIPMENT_LIST | CMOS_DISABLE_NMI);
    Bda->EquipmentList = IOReadB(CMOS_DATA_PORT);
    // TODO: Update it if required.
    Bda->EquipmentList &= 0x00FF; // High byte cleared for now...

    /*
     * Retrieve the conventional memory size
     * in kB from the CMOS, typically 640 kB.
     */
    IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_BASE_MEMORY_LOW  | CMOS_DISABLE_NMI);
    Low  = IOReadB(CMOS_DATA_PORT);
    IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_BASE_MEMORY_HIGH | CMOS_DISABLE_NMI);
    High = IOReadB(CMOS_DATA_PORT);
    Bda->MemorySize = MAKEWORD(Low, High);
}

Referenced by Bios32Post().

InitializeBiosInt32()

static VOID InitializeBiosInt32 ( VOID  )

static

Definition at line 960 of file bios32.c.

{
    USHORT i;

    /* Initialize the callback context */
    InitializeContext(&BiosContext, BIOS_SEGMENT, 0x0000);

    /* Register the default BIOS interrupt vectors */

    /*
     * Zero out all of the IVT (0x00 -- 0xFF). Some applications
     * indeed expect to have free vectors at the end of the IVT.
     */
    RtlZeroMemory(BaseAddress, 0x0100 * sizeof(ULONG));

#if defined(ADVANCED_DEBUGGING) && (ADVANCED_DEBUGGING_LEVEL >= 3)
    // Initialize all the interrupt vectors to the default one.
    for (i = 0x00; i <= 0xFF; i++)
        RegisterBiosInt32(i, NULL);
#endif

    /* Initialize the exception interrupt vectors to a default Exception handler */
    for (i = 0x00; i <= 0x07; i++)
        RegisterBiosInt32(i, BiosException);

    /* Initialize HW interrupt vectors to a default HW handler */
    for (i = BIOS_PIC_MASTER_INT; i < BIOS_PIC_MASTER_INT + 8; i++) // 0x08 -- 0x0F
        RegisterBiosInt32(i, BiosHandleMasterPicIRQ);
    for (i = BIOS_PIC_SLAVE_INT ; i < BIOS_PIC_SLAVE_INT  + 8; i++) // 0x70 -- 0x77
        RegisterBiosInt32(i, BiosHandleSlavePicIRQ);

    /* Initialize software vector handlers */
    // BIOS_VIDEO_INTERRUPT  : 0x10 (vidbios32.c)
    RegisterBiosInt32(BIOS_EQUIPMENT_INTERRUPT, BiosEquipmentService    );
    RegisterBiosInt32(BIOS_MEMORY_SIZE        , BiosGetMemorySize       );
    // BIOS_DISK_INTERRUPT   : 0x13 (dskbios32.c)
    // BIOS_SERIAL_INTERRUPT : 0x14 -- UNIMPLEMENTED
    RegisterBiosInt32(BIOS_MISC_INTERRUPT     , BiosMiscService         );
    // BIOS_KBD_INTERRUPT    : 0x16 (kbdbios32.c)
    // BIOS_PRINTER_INTERRUPT: 0x17 -- UNIMPLEMENTED
    RegisterBiosInt32(BIOS_ROM_BASIC          , BiosRomBasic            );
    RegisterBiosInt32(BIOS_BOOTSTRAP_LOADER   , BiosBootstrapLoader     );
    RegisterBiosInt32(BIOS_TIME_INTERRUPT     , BiosTimeService         );
    // BIOS_KBD_CTRL_BREAK_INTERRUPT: 0x1B -- UNIMPLEMENTED
    RegisterBiosInt32(BIOS_SYS_TIMER_INTERRUPT, BiosSystemTimerInterrupt);

    /* Vectors that should be implemented (see above) */
    RegisterBiosInt32(0x14, NULL);
    RegisterBiosInt32(0x17, NULL);
    RegisterBiosInt32(0x1B, NULL);
    RegisterBiosInt32(0x4A, NULL); // User Alarm Handler

    /* Relocated services by the BIOS (when needed) */
    RegisterBiosInt32(0x40, NULL); // ROM BIOS Diskette Handler relocated by Hard Disk BIOS
    RegisterBiosInt32(0x42, NULL); // Relocated Default INT 10h Video Services

    /* Miscellaneous unimplemented vector handlers that should better have a default one */
    RegisterBiosInt32(0x4B, NULL); // Virtual DMA Specification Services
    RegisterBiosInt32(0x5C, NULL); // NetBIOS

    // ROM-BASIC interrupts span from 0x80 up to 0xEF.
    // They don't have any default handler at the moment.

    /* Some vectors are in fact addresses to tables */
    ((PULONG)BaseAddress)[0x1D] = NULL32; // Video Parameter Tables
    ((PULONG)BaseAddress)[0x1E] = NULL32; // Diskette Parameters
    ((PULONG)BaseAddress)[0x1F] = NULL32; // 8x8 Graphics Font
    ((PULONG)BaseAddress)[0x41] = NULL32; // Hard Disk 0 Parameter Table Address
    ((PULONG)BaseAddress)[0x43] = NULL32; // Character Table (EGA, MCGA, VGA)
    ((PULONG)BaseAddress)[0x46] = NULL32; // Hard Disk 1 Drive Parameter Table Address
    /* Tables that are always uninitialized */
    ((PULONG)BaseAddress)[0x44] = NULL32; // ROM BIOS Character Font, Characters 00h-7Fh (PCjr)
    ((PULONG)BaseAddress)[0x48] = NULL32; // Cordless Keyboard Translation (PCjr)
    ((PULONG)BaseAddress)[0x49] = NULL32; // Non-Keyboard Scan-code Translation Table (PCJr)
}

Referenced by Bios32Post().

PicIRQComplete()

VOID PicIRQComplete

(

BYTE

IntNum

)

Definition at line 816 of file bios32.c.

{
    /*
     * If this was a PIC IRQ, send an End-of-Interrupt to the PIC.
     */
    if (IntNum >= BIOS_PIC_MASTER_INT && IntNum < BIOS_PIC_MASTER_INT + 8)
    {
        /* It was an IRQ from the master PIC */
        IOWriteB(PIC_MASTER_CMD, PIC_OCW2_EOI);
    }
    else if (IntNum >= BIOS_PIC_SLAVE_INT && IntNum < BIOS_PIC_SLAVE_INT + 8)
    {
        /* It was an IRQ from the slave PIC */
        IOWriteB(PIC_SLAVE_CMD , PIC_OCW2_EOI);
        IOWriteB(PIC_MASTER_CMD, PIC_OCW2_EOI);
    }
}

Referenced by BiosHandleMasterPicIRQ(), BiosHandleSlavePicIRQ(), BiosKeyboardIrq(), BiosMouseIrq(), BiosTimerIrq(), and DosMouseIrq().

PicSetIRQMask()

static VOID PicSetIRQMask ( USHORT  off, USHORT  on  )

static

Definition at line 794 of file bios32.c.

{
    UCHAR pic1off = off, pic1on = on, pic2off = off>>8, pic2on = on>>8;
    IOWriteB(PIC_MASTER_DATA, (IOReadB(PIC_MASTER_DATA) & ~pic1off) | pic1on);
    IOWriteB(PIC_SLAVE_DATA , (IOReadB(PIC_SLAVE_DATA ) & ~pic2off) | pic2on);
}

Referenced by EnableHwIRQ().

Variable Documentation

BiosConfigTable

const BIOS_CONFIG_TABLE BiosConfigTable

static

Initial value:

=
{
    sizeof(BIOS_CONFIG_TABLE) - sizeof(((BIOS_CONFIG_TABLE*)0)->Length),    

    BIOS_MODEL,     
    BIOS_SUBMODEL,  
    BIOS_REVISION,  

    
    {
        0x78,       
        0x00,       
        0x10,       
        0x00,
        0x00
    }
}

Definition at line 115 of file bios32.c.

Referenced by Bios32Initialize().

BiosContext

CALLBACK16 BiosContext

Definition at line 45 of file bios32.c.

Referenced by Bios32Post(), BiosCharPrint(), BiosKeyboardIrq(), BiosMouseIrq(), BiosTimerIrq(), InitializeBiosInt32(), IntInt10CallBios(), and VbeService().

BiosCopyright

const CHAR BiosCopyright[] = "0000000 NTVDM IBM COMPATIBLE 486 BIOS COPYRIGHT (C) ReactOS Team 1996-"COPYRIGHT_YEAR

static

Definition at line 138 of file bios32.c.

Referenced by Bios32Initialize().

BiosDate

const CHAR BiosDate[] = "06/17/13"

static

Definition at line 141 of file bios32.c.

Referenced by Bios32Initialize(), and CmpGetBiosDate().

BiosVersion

const CHAR BiosVersion[]

static

Initial value:

= "ReactOS NTVDM 32-bit BIOS Version "KERNEL_VERSION_STR"\0"
                                    "BIOS32 Version "KERNEL_VERSION_STR" (Build "KERNEL_VERSION_BUILD_STR")"

Definition at line 139 of file bios32.c.

Referenced by Bios32Initialize(), CmpGetBiosVersion(), and CmpInitializeMachineDependentConfiguration().

Bootstrap

const BYTE Bootstrap[]

static

Initial value:

=
{
    0xEA,                   
    0x5B, 0xE0, 0x00, 0xF0, 
}

Definition at line 147 of file bios32.c.

Referenced by Bios32Initialize().

PostCode

const BYTE PostCode[]

static

Initial value:

=
{
    LOBYTE(EMULATOR_BOP), HIBYTE(EMULATOR_BOP), BOP_RESET,  
    0xCD, BIOS_BOOTSTRAP_LOADER,                            
    0xCD, BIOS_ROM_BASIC,                                   
    LOBYTE(EMULATOR_BOP), HIBYTE(EMULATOR_BOP), BOP_UNSIMULATE
}

Definition at line 157 of file bios32.c.

Referenced by Bios32Initialize().