vidbios32.c File Reference

#include "ntvdm.h"
#include <debug.h>
#include "emulator.h"
#include "cpu/bop.h"
#include "int32.h"
#include "vidbios32.h"
#include <bios/vidbios.h>
#include "bios32p.h"

Include dependency graph for vidbios32.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	BOP_VIDEO_INT   0x10

Functions
VOID WINAPI	VidBiosVideoService (LPWORD Stack)
static VOID WINAPI	VidBiosINT (LPWORD Stack)
BOOLEAN	VidBios32Initialize (VOID)
VOID	VidBios32Cleanup (VOID)

Macro Definition Documentation

BOP_VIDEO_INT

#define BOP_VIDEO_INT   0x10

Definition at line 29 of file vidbios32.c.

NDEBUG

#define NDEBUG

Definition at line 15 of file vidbios32.c.

Function Documentation

VidBios32Cleanup()

VOID VidBios32Cleanup

(

VOID

)

Definition at line 67 of file vidbios32.c.

{
    /* Unregister the BIOS support BOPs */
    RegisterBop(BOP_VIDEO_INT, NULL);
}

Referenced by Bios32Cleanup().

VidBios32Initialize()

BOOLEAN VidBios32Initialize

(

VOID

)

Definition at line 60 of file vidbios32.c.

{
    /* Register the BIOS support BOPs */
    RegisterBop(BOP_VIDEO_INT, VidBiosINT);
    return TRUE;
}

Referenced by VidBiosInitialize().

VidBiosINT()

static VOID WINAPI VidBiosINT ( LPWORD  Stack )

static

Definition at line 34 of file vidbios32.c.

{
    /*
     * Set up a false stack to hardwire the BOP function (that can directly
     * manipulate CPU registers) to the 32-bit interrupt function (which uses
     * the stack to be able to modify the original CS:IP and FLAGS).
     *
     * See int32.h stack codes.
     */
    WORD EmuStack[4];
    DWORD Flags = getEFLAGS();
 
    DPRINT1("Calling BOP VidBiosINT\n");
 
    EmuStack[STACK_FLAGS]   = LOWORD(Flags);
    EmuStack[STACK_CS]      = getCS();
    EmuStack[STACK_IP]      = getIP();
    EmuStack[STACK_INT_NUM] = BOP_VIDEO_INT;
 
    VidBiosVideoService(EmuStack);
 
    setIP(EmuStack[STACK_IP]);
    setCS(EmuStack[STACK_CS]);
    setEFLAGS(MAKELONG(EmuStack[STACK_FLAGS], HIWORD(Flags)));
}

Referenced by VidBios32Initialize().

VidBiosVideoService()

VOID WINAPI VidBiosVideoService

(

LPWORD

Stack

)

Definition at line 2947 of file vidbios.c.

{
    switch (getAH())
    {
        /* Set Video Mode */
        case 0x00:
        {
            VidBiosSetVideoMode(getAL());
            break;
        }
 
        /* Set Text-Mode Cursor Shape */
        case 0x01:
        {
            VidBiosSetCursorShape(getCX());
            break;
        }
 
        /* Set Cursor Position */
        case 0x02:
        {
            BYTE Page = getBH();
 
            /* Validate the selected video page */
            if (Page >= BIOS_MAX_PAGES) break;
 
            VidBiosSetCursorPosition(getDH(), getDL(), Page);
            break;
        }
 
        /* Get Cursor Position and Shape */
        case 0x03:
        {
            BYTE Page = getBH();
 
            /* Validate the selected video page */
            if (Page == 0xFF) // Special case: use the current video page
                Page = Bda->VideoPage;
            else if (Page >= BIOS_MAX_PAGES)
                break;
 
            /* Return the result */
            setCX(MAKEWORD(Bda->CursorEndLine, Bda->CursorStartLine));
            setDX(Bda->CursorPosition[Page]);
            break;
        }
 
        /* Query Light Pen */
        case 0x04:
        {
            /*
             * On modern BIOSes, this function returns 0
             * so that we can ignore the other registers.
             */
            setAX(0);
            break;
        }
 
        /* Select Active Display Page */
        case 0x05:
        {
            VidBiosSetVideoPage(getAL());
            break;
        }
 
        /* Scroll Window Up/Down */
        case 0x06:
        case 0x07:
        {
            SMALL_RECT Rectangle = { getCL(), getCH(), getDL(), getDH() };
 
            VidBiosScrollWindow((getAH() == 0x06) ? SCROLL_UP : SCROLL_DOWN,
                                getAL(), Rectangle, Bda->VideoPage, getBH());
 
            break;
        }
 
        /* Read Character and Attribute at Cursor Position */
        case 0x08:
        {
            WORD  CharData;
            BYTE  Page = getBH();
            DWORD Offset;
 
            /* Validate the selected video page */
            if (Page == 0xFF) // Special case: use the current video page
                Page = Bda->VideoPage;
            else if (Page >= BIOS_MAX_PAGES)
                break;
 
            /* Find the offset of the character */
            Offset = Page * Bda->VideoPageSize +
                     (HIBYTE(Bda->CursorPosition[Page])  * Bda->ScreenColumns +
                      LOBYTE(Bda->CursorPosition[Page])) * 2;
 
            /* Read from the video memory */
            EmulatorReadMemory(&EmulatorContext,
                               TO_LINEAR(TEXT_VIDEO_SEG, Offset),
                               (LPVOID)&CharData,
                               sizeof(WORD));
 
            /* Return the character data in AX */
            setAX(CharData);
 
            break;
        }
 
        /* Write Character and Attribute at Cursor Position */
        case 0x09:
        /* Write Character only (PCjr: + Attribute) at Cursor Position */
        case 0x0A:
        {
            WORD Counter = getCX();
            WORD CharData = MAKEWORD(getAL(), getBL());
            BOOLEAN UseAttr = (getAH() == 0x09);
            BYTE Page = getBH();
            BYTE Row, Column;
 
            /* Validate the selected video page */
            if (Page == 0xFF) // Special case: use the current video page
                Page = Bda->VideoPage;
            else if (Page >= BIOS_MAX_PAGES)
                break;
 
            /* Get the cursor position */
            VidBiosGetCursorPosition(&Row, &Column, Page);
 
            /* Write to video memory a certain number of times */
            while (Counter-- > 0)
            {
                /* Write the character and advance the position */
                VidBiosDrawGlyph(CharData, UseAttr, Page, Row, Column);
                Column++;
 
                /* Check if it passed the end of the row */
                if (Column >= Bda->ScreenColumns)
                {
                    /* Return to the first column and go to the next line */
                    Column = 0;
                    Row++;
                }
 
                /* Contrary to the "Teletype Output" function, the screen is not scrolled */
                if (Row > Bda->ScreenRows)
                {
                    Row = Bda->ScreenRows;
                }
            }
 
            break;
        }
 
        /* Set Video Colors */
        case 0x0B:
        {
            if (Bda->VideoMode < 0x04 || Bda->VideoMode > 0x06)
            {
                DPRINT1("BIOS Function INT 10h, AH = 0Bh, BH = 0x%02X is unsupported for non-CGA modes\n",
                        getBH());
                break;
            }
 
            switch (getBH())
            {
                case 0x00: /* Set Background/Border Color */
                {
#ifdef DOSBOX
                    BYTE Index = getBL();
 
                    /* See: https://web.archive.org/web/20240119203029/http://www.bioscentral.com/misc/bda.htm */
                    Bda->CrtColorPaletteMask = (Bda->CrtColorPaletteMask & 0xE0) | (Index & 0x1F);
 
                    Index = ((Index << 1) & 0x10) | (Index & 0x7);
 
                    /* Always set the overscan color */
                    VgaSetSinglePaletteRegister(VGA_AC_OVERSCAN_REG, Index);
 
                    /* Don't set any extra colors when in text mode */
                    if (Bda->VideoMode <= 0x03) break;
 
                    VgaSetSinglePaletteRegister(0x00, Index);
 
                    Index = (Bda->CrtColorPaletteMask & 0x10) | 0x02 | ((Bda->CrtColorPaletteMask & 0x20) >> 5);
 
                    VgaSetSinglePaletteRegister(0x01, Index);
                    Index += 2;
                    VgaSetSinglePaletteRegister(0x02, Index);
                    Index += 2;
                    VgaSetSinglePaletteRegister(0x03, Index);
#else
                    /* Background/Border Color is modifiable via the first index */
                    VgaSetSinglePaletteRegister(0x00, getBL());
#endif
 
                    /* Enable screen and disable palette access */
                    IOReadB(VGA_INSTAT1_READ); // Put the AC register into index state
                    IOWriteB(VGA_AC_INDEX, 0x20);
                    break;
                }
 
                case 0x01: /* Set Palette */
                {
                    BYTE Index = getBL();
 
                    /* See: https://web.archive.org/web/20240119203029/http://www.bioscentral.com/misc/bda.htm */
                    /* Reset bit 5: foreground colors index (0: green/red/yellow; 1: cyan/magenta/white) */
                    Bda->CrtColorPaletteMask = (Bda->CrtColorPaletteMask & 0xDF) | ((Index & 1) ? 0x20 : 0x00);
 
                    /* Don't set any extra colors when in text mode */
                    if (Bda->VideoMode <= 0x03) break;
 
                    Index = (Bda->CrtColorPaletteMask & 0x10) | 0x02 | Index;
 
                    VgaSetSinglePaletteRegister(0x01, Index);
                    Index += 2;
                    VgaSetSinglePaletteRegister(0x02, Index);
                    Index += 2;
                    VgaSetSinglePaletteRegister(0x03, Index);
 
                    /* Enable screen and disable palette access */
                    IOReadB(VGA_INSTAT1_READ); // Put the AC register into index state
                    IOWriteB(VGA_AC_INDEX, 0x20);
                    break;
                }
 
                default:
                    DPRINT1("BIOS Function INT 10h, AH = 0Bh, BH = 0x%02X NOT IMPLEMENTED\n",
                            getAH(), getBH());
                    break;
            }
 
            break;
        }
 
        /* Teletype Output */
        case 0x0E:
        {
            BYTE Page = getBH();
 
            /* Validate the selected video page */
            if (Page == 0xFF) // Special case: use the current video page
                Page = Bda->VideoPage;
            else if (Page >= BIOS_MAX_PAGES)
                break;
 
            VidBiosPrintCharacter(getAL(), getBL(), !IS_TEXT_MODE(Bda->VideoMode), Page);
            break;
        }
 
        /* Get Current Video Mode */
        case 0x0F:
        {
            setAX(MAKEWORD(VidBiosGetVideoMode(), Bda->ScreenColumns));
            setBH(Bda->VideoPage);
            break;
        }
 
        /* Palette Control */
        case 0x10:
        {
            switch (getAL())
            {
                /* Set Single Palette Register */
                case 0x00:
                {
                    VgaSetSinglePaletteRegister(getBL(), getBH());
 
                    /* Enable screen and disable palette access */
                    IOReadB(VGA_INSTAT1_READ); // Put the AC register into index state
                    IOWriteB(VGA_AC_INDEX, 0x20);
                    break;
                }
 
                /* Set Overscan Color */
                case 0x01:
                {
                    VgaSetSinglePaletteRegister(VGA_AC_OVERSCAN_REG, getBH());
 
                    /* Enable screen and disable palette access */
                    IOReadB(VGA_INSTAT1_READ); // Put the AC register into index state
                    IOWriteB(VGA_AC_INDEX, 0x20);
                    break;
                }
 
                /* Set All Palette Registers */
                case 0x02:
                {
                    UINT i;
                    LPBYTE Buffer = SEG_OFF_TO_PTR(getES(), getDX());
 
                    /* Set the palette registers */
                    for (i = 0; i <= VGA_AC_PAL_F_REG; i++)
                    {
                        VgaSetSinglePaletteRegister(i, Buffer[i]);
                    }
 
                    /* Set the overscan register */
                    // VgaSetSinglePaletteRegister(VGA_AC_OVERSCAN_REG, Buffer[VGA_AC_PAL_F_REG + 1]);
                    IOReadB(VGA_INSTAT1_READ);
                    IOWriteB(VGA_AC_INDEX, VGA_AC_OVERSCAN_REG);
                    IOWriteB(VGA_AC_WRITE, Buffer[VGA_AC_PAL_F_REG + 1]);
 
                    /* Enable screen and disable palette access */
                    IOReadB(VGA_INSTAT1_READ); // Put the AC register into index state
                    IOWriteB(VGA_AC_INDEX, 0x20);
                    break;
                }
 
                /* Toggle Intensity/Blinking Bit */
                case 0x03:
                {
                    /* Read the old AC mode control register value */
                    BYTE VgaAcControlReg;
 
                    IOReadB(VGA_INSTAT1_READ);
                    IOWriteB(VGA_AC_INDEX, VGA_AC_CONTROL_REG);
                    VgaAcControlReg = IOReadB(VGA_AC_READ);
 
                    /* Toggle the blinking bit and write the new value */
                    if (getBL())
                    {
                        VgaAcControlReg |= VGA_AC_CONTROL_BLINK;
                        Bda->CrtModeControl |= (1 << 5);
                    }
                    else
                    {
                        VgaAcControlReg &= ~VGA_AC_CONTROL_BLINK;
                        Bda->CrtModeControl &= ~(1 << 5);
                    }
 
                    IOReadB(VGA_INSTAT1_READ);
                    IOWriteB(VGA_AC_INDEX, VGA_AC_CONTROL_REG);
                    IOWriteB(VGA_AC_WRITE, VgaAcControlReg);
 
                    /* Enable screen and disable palette access */
                    IOReadB(VGA_INSTAT1_READ); // Put the AC register into index state
                    IOWriteB(VGA_AC_INDEX, 0x20);
                    break;
                }
 
                /* Get Single Palette Register */
                case 0x07:
                {
                    /* Write the index */
                    IOReadB(VGA_INSTAT1_READ); // Put the AC register into index state
                    IOWriteB(VGA_AC_INDEX, getBL());
 
                    /* Read the data */
                    setBH(IOReadB(VGA_AC_READ));
 
                    /* Enable screen and disable palette access */
                    IOReadB(VGA_INSTAT1_READ); // Put the AC register into index state
                    IOWriteB(VGA_AC_INDEX, 0x20);
                    break;
                }
 
                /* Get Overscan Color */
                case 0x08:
                {
                    /* Write the index */
                    IOReadB(VGA_INSTAT1_READ); // Put the AC register into index state
                    IOWriteB(VGA_AC_INDEX, VGA_AC_OVERSCAN_REG);
 
                    /* Read the data */
                    setBH(IOReadB(VGA_AC_READ));
 
                    /* Enable screen and disable palette access */
                    IOReadB(VGA_INSTAT1_READ); // Put the AC register into index state
                    IOWriteB(VGA_AC_INDEX, 0x20);
                    break;
                }
 
                /* Get All Palette Registers */
                case 0x09:
                {
                    UINT i;
                    LPBYTE Buffer = SEG_OFF_TO_PTR(getES(), getDX());
 
                    /* Get the palette registers */
                    for (i = 0; i <= VGA_AC_PAL_F_REG; i++)
                    {
                        /* Write the index */
                        IOReadB(VGA_INSTAT1_READ); // Put the AC register into index state
                        IOWriteB(VGA_AC_INDEX, i);
 
                        /* Read the data */
                        Buffer[i] = IOReadB(VGA_AC_READ);
                    }
 
                    /* Get the overscan register */
                    IOReadB(VGA_INSTAT1_READ);
                    IOWriteB(VGA_AC_INDEX, VGA_AC_OVERSCAN_REG);
                    Buffer[VGA_AC_PAL_F_REG + 1] = IOReadB(VGA_AC_READ);
 
                    /* Enable screen and disable palette access */
                    IOReadB(VGA_INSTAT1_READ); // Put the AC register into index state
                    IOWriteB(VGA_AC_INDEX, 0x20);
                    break;
                }
 
                /* Set Individual DAC Register */
                case 0x10:
                {
                    /* Write the index */
                    // Certainly in BL and not in BX as said by Ralf Brown...
                    IOWriteB(VGA_DAC_WRITE_INDEX, getBL());
 
                    /* Write the data in this order: Red, Green, Blue */
                    IOWriteB(VGA_DAC_DATA, getDH());
                    IOWriteB(VGA_DAC_DATA, getCH());
                    IOWriteB(VGA_DAC_DATA, getCL());
 
                    break;
                }
 
                /* Set Block of DAC Registers */
                case 0x12:
                {
                    UINT i;
                    LPBYTE Buffer = SEG_OFF_TO_PTR(getES(), getDX());
 
                    /* Write the index */
                    // Certainly in BL and not in BX as said by Ralf Brown...
                    IOWriteB(VGA_DAC_WRITE_INDEX, getBL());
 
                    for (i = 0; i < getCX(); i++)
                    {
                        /* Write the data in this order: Red, Green, Blue */
                        IOWriteB(VGA_DAC_DATA, *Buffer++);
                        IOWriteB(VGA_DAC_DATA, *Buffer++);
                        IOWriteB(VGA_DAC_DATA, *Buffer++);
                    }
 
                    break;
                }
 
                /* Set Video DAC Color Page */
                case 0x13:
                {
                    if (getBL() == 0)
                    {
                        /* Set the highest bit of the AC Mode Control register to BH */
                        IOReadB(VGA_INSTAT1_READ);
                        IOWriteB(VGA_AC_INDEX, VGA_AC_CONTROL_REG);
                        IOWriteB(VGA_AC_WRITE, (IOReadB(VGA_AC_READ) & 0x7F) | (getBH() << 7));
                    }
                    else if (getBL() == 1)
                    {
                        /* Set the AC Color Select register to BH */
                        IOReadB(VGA_INSTAT1_READ);
                        IOWriteB(VGA_AC_INDEX, VGA_AC_COLOR_SEL_REG);
                        IOWriteB(VGA_AC_WRITE, getBH());
                    }
                    else
                    {
                        DPRINT1("BIOS Palette Control Sub-sub-command BL = 0x%02X INVALID\n", getBL());
                    }
 
                    break;
                }
 
                /* Get Individual DAC Register */
                case 0x15:
                {
                    /* Write the index */
                    IOWriteB(VGA_DAC_READ_INDEX, getBL());
 
                    /* Read the data in this order: Red, Green, Blue */
                    setDH(IOReadB(VGA_DAC_DATA));
                    setCH(IOReadB(VGA_DAC_DATA));
                    setCL(IOReadB(VGA_DAC_DATA));
 
                    break;
                }
 
                /* Get Block of DAC Registers */
                case 0x17:
                {
                    UINT i;
                    LPBYTE Buffer = SEG_OFF_TO_PTR(getES(), getDX());
 
                    /* Write the index */
                    // Certainly in BL and not in BX as said by Ralf Brown...
                    IOWriteB(VGA_DAC_READ_INDEX, getBL());
 
                    for (i = 0; i < getCX(); i++)
                    {
                        /* Write the data in this order: Red, Green, Blue */
                        *Buffer++ = IOReadB(VGA_DAC_DATA);
                        *Buffer++ = IOReadB(VGA_DAC_DATA);
                        *Buffer++ = IOReadB(VGA_DAC_DATA);
                    }
 
                    break;
                }
 
                /* Set PEL Mask */
                case 0x18:
                {
                    IOWriteB(VGA_DAC_MASK, getBL());
                    break;
                }
 
                /* Get PEL Mask */
                case 0x19:
                {
                    setBL(IOReadB(VGA_DAC_MASK));
                    break;
                }
 
                default:
                {
                    DPRINT1("BIOS Palette Control Sub-command AL = 0x%02X NOT IMPLEMENTED\n",
                            getAL());
                    break;
                }
            }
 
            break;
        }
 
        /* Font Control */
        case 0x11:
        {
            switch (getAL())
            {
                // FIXME: At the moment we support only graphics-mode functions!
 
                /* Load User-specified Patterns (Character Set) for Text Mode */
                case 0x00:
                case 0x10: // FIXME: 0x1x performs a full mode reset
                {
                    // FIXME: BL == ??
 
                    /* Write the default font to the VGA font plane */
                    // VgaWriteTextModeFont(0, Font8x8, ARRAYSIZE(Font8x8) / VGA_FONT_CHARACTERS);
 
                    UNIMPLEMENTED;
                    break;
                }
 
                /* Load ROM Monochrome 8x14 Patterns (Character Set) for Text Mode */
                case 0x01:
                case 0x11: // FIXME: 0x1x performs a full mode reset
                {
                    // FIXME: BL == ??
 
                    /* Write the default font to the VGA font plane */
                    VgaWriteTextModeFont(0, Font8x14, ARRAYSIZE(Font8x14) / VGA_FONT_CHARACTERS);
 
                    UNIMPLEMENTED;
                    break;
                }
 
                /* Load ROM 8x8 Double-dot Patterns (Character Set) for Text Mode */
                case 0x02:
                case 0x12: // FIXME: 0x1x performs a full mode reset
                {
                    // FIXME: BL == ??
 
                    /* Write the default font to the VGA font plane */
                    VgaWriteTextModeFont(0, Font8x8, ARRAYSIZE(Font8x8) / VGA_FONT_CHARACTERS);
 
                    UNIMPLEMENTED;
                    break;
                }
 
                /* Load ROM 8x16 Character Set for Text Mode */
                case 0x04:
                case 0x14: // FIXME: 0x1x performs a full mode reset
                {
                    // FIXME: BL == ??
 
                    /* Write the default font to the VGA font plane */
                    VgaWriteTextModeFont(0, Font8x16, ARRAYSIZE(Font8x16) / VGA_FONT_CHARACTERS);
 
                    UNIMPLEMENTED;
                    break;
                }
 
                /* Set User 8x8 Graphics Chars (Setup INT 1Fh Vector) */
                case 0x20:
                {
                    /* Update the BIOS INT 1Fh vector to user-defined ES:BP pointer */
                    // Far pointer to the 8x8 characters 80h-FFh
                    ((PULONG)BaseAddress)[0x1F] = MAKELONG(getBP(), getES());
                    break;
                }
 
                /* Set User Graphics Characters */
                case 0x21:
                {
                    /*
                     * Update the BIOS INT 43h vector (far pointer
                     * to the character range 00h-...)
                     */
                    ((PULONG)BaseAddress)[0x43] = MAKELONG(getBP(), getES());
 
                    /* Update BDA */
                    Bda->CharacterHeight = getCX();
                    switch (getBL())
                    {
                        case 0x00: Bda->ScreenRows = getDL()-1; break;
                        case 0x01: Bda->ScreenRows = 13;        break;
                        case 0x03: Bda->ScreenRows = 42;        break;
                        case 0x02:
                        default  : Bda->ScreenRows = 24;        break;
                    }
 
                    break;
                }
 
                /* Setup ROM 8x14 Font for Graphics Mode */
                case 0x22:
                {
                    /*
                     * Update the BIOS INT 43h vector (far pointer
                     * to the character range 00h-...)
                     */
                    ((PULONG)BaseAddress)[0x43] = MAKELONG(FONT_8x14_OFFSET, VIDEO_BIOS_DATA_SEG);
 
                    /* Update BDA */
                    Bda->CharacterHeight = 14;
                    switch (getBL())
                    {
                        case 0x00: Bda->ScreenRows = getDL()-1; break;
                        case 0x01: Bda->ScreenRows = 13;        break;
                        case 0x03: Bda->ScreenRows = 42;        break;
                        case 0x02:
                        default  : Bda->ScreenRows = 24;        break;
                    }
 
                    break;
                }
 
                /* Setup ROM 8x8 Font for Graphics Mode */
                case 0x23:
                {
                    /*
                     * Update the BIOS INT 43h vector (far pointer
                     * to the character range 00h-...)
                     */
                    ((PULONG)BaseAddress)[0x43] = MAKELONG(FONT_8x8_OFFSET, VIDEO_BIOS_DATA_SEG);
 
                    /* Update BDA */
                    Bda->CharacterHeight = 8;
                    switch (getBL())
                    {
                        case 0x00: Bda->ScreenRows = getDL()-1; break;
                        case 0x01: Bda->ScreenRows = 13;        break;
                        case 0x03: Bda->ScreenRows = 42;        break;
                        case 0x02:
                        default  : Bda->ScreenRows = 24;        break;
                    }
 
                    break;
                }
 
                /* Setup ROM 8x16 Font for Graphics Mode */
                case 0x24:
                {
                    /*
                     * Update the BIOS INT 43h vector (far pointer
                     * to the character range 00h-...).
                     */
                    ((PULONG)BaseAddress)[0x43] = MAKELONG(FONT_8x16_OFFSET, VIDEO_BIOS_DATA_SEG);
 
                    /* Update BDA */
                    Bda->CharacterHeight = 16;
                    switch (getBL())
                    {
                        case 0x00: Bda->ScreenRows = getDL()-1; break;
                        case 0x01: Bda->ScreenRows = 13;        break;
                        case 0x03: Bda->ScreenRows = 42;        break;
                        case 0x02:
                        default  : Bda->ScreenRows = 24;        break;
                    }
 
                    break;
                }
 
                /* Get Current Character Font Information */
                case 0x30:
                {
                    ULONG Address = NULL32;
 
                    switch (getBH())
                    {
                        /* 00h - INT 0x1F pointer */
                        case 0x00:
                            Address = ((PULONG)BaseAddress)[0x1F];
                            break;
 
                        /* 01h - INT 0x43 pointer */
                        case 0x01:
                            Address = ((PULONG)BaseAddress)[0x43];
                            break;
 
                        /* 02h - 8x14 font */
                        case 0x02:
                            Address = MAKELONG(FONT_8x14_OFFSET, VIDEO_BIOS_DATA_SEG);
                            break;
 
                        /* 03h - 8x8 font */
                        case 0x03:
                            Address = MAKELONG(FONT_8x8_OFFSET, VIDEO_BIOS_DATA_SEG);
                            break;
 
                        /* 04h - 8x8 font, upper half */
                        case 0x04:
                            Address = MAKELONG(FONT_8x8_HIGH_OFFSET, VIDEO_BIOS_DATA_SEG);
                            break;
 
                        /* 05h - NOT IMPLEMENTED - 9x14 font */
                        case 0x05:
                            break;
 
                        /* 06h - 8x16 font */
                        case 0x06:
                            Address = MAKELONG(FONT_8x16_OFFSET, VIDEO_BIOS_DATA_SEG);
                            break;
 
                        /* 07h - NOT IMPLEMENTED - 9x16 font */
                        case 0x07:
                            break;
 
                        default:
                            DPRINT1("INT 10h, AL=30h Function BH = 0x%02X NOT IMPLEMENTED\n",
                                    getBH());
                    }
 
                    /* Return the data */
                    setES(HIWORD(Address));
                    setBP(LOWORD(Address));
                    setCX(Bda->CharacterHeight);
                    setDL(Bda->ScreenRows);
 
                    break;
                }
 
                default:
                {
                    DPRINT1("BIOS Font Control Sub-command AL = 0x%02X NOT IMPLEMENTED\n",
                            getAL());
                }
            }
 
            break;
        }
 
        /* Alternate Function Select */
        case 0x12:
        {
            switch (getBL())
            {
                /* Get EGA/VGA Information */
                case 0x10:
                {
                    setBH((Bda->VGAOptions  & 0x02) >> 1);  /* Color (0) or monochrome (1) display */
                    setBL((Bda->VGAOptions  & 0x60) >> 5);  /* Video RAM size */
                    setCH((Bda->VGASwitches & 0xF0) >> 4);  /* Features settings */
                    setCL( Bda->VGASwitches & 0x0F);        /* Switches settings */
                    break;
                }
 
                /* Enable/Disable Cursor Emulation */
                case 0x34:
                {
                    BYTE State = getAL();
 
                    /* Check for validity */
                    if (State > 1) break;
 
                    /*
                     * Enable (State == 0) or disable (State == 1) cursor emulation.
                     * Please read the WARNING in the 'VidBiosSetCursorShape'
                     * function for more details.
                     */
                    Bda->VGAOptions = (Bda->VGAOptions & 0xFE) | (State & 0x01);
 
                    /* Return success */
                    setAL(0x12);
                    break;
                }
 
                /* Enable/Disable screen refresh */
                case 0x36:
                {
                    BYTE State = getAL();
                    BYTE Clocking;
 
                    /* Check for validity */
                    if (State > 1) break;
 
                    /* Turn the video on (State == 0) or off (State == 1) */
                    IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_CLOCK_REG);
                    Clocking = IOReadB(VGA_SEQ_DATA);
 
                    if (State == 0)
                        Clocking &= ~VGA_SEQ_CLOCK_SD;
                    else
                        Clocking |= VGA_SEQ_CLOCK_SD;
 
                    IOWriteB(VGA_SEQ_DATA, Clocking);
 
                    /* Return success */
                    setAL(0x12);
                    break;
                }
 
                default:
                {
                    DPRINT1("BIOS Function INT 10h, AH = 12h (Alternate Function Select), BX = 0x%04X NOT IMPLEMENTED\n",
                            getBX());
                    break;
                }
            }
 
            break;
        }
 
        /* Write String */
        case 0x13:
        {
            PCHAR String = (PCHAR)SEG_OFF_TO_PTR(getES(), getBP());
            WORD Counter = getCX();
            BYTE Row, Column;
            BYTE OldRow, OldColumn;
            CHAR Character;
            BYTE Attribute = getBL(); // Default attribute in case the string contains only characters.
            BYTE Page = getBH();
            BYTE Flags = getAL();
 
            /* Validate the selected video page */
            if (Page == 0xFF) // Special case: use the current video page
                Page = Bda->VideoPage;
            else if (Page >= BIOS_MAX_PAGES)
                break;
 
            /* Get the original cursor position */
            VidBiosGetCursorPosition(&OldRow, &OldColumn, Page);
 
            /* Set the new cursor position */
            Row    = getDH();
            Column = getDL();
            if (Row == 0xFF) // Special case: use the current cursor position
            {
                Row    = OldRow;
                Column = OldColumn;
            }
            VidBiosSetCursorPosition(Row, Column, Page);
 
            while (Counter-- > 0)
            {
                Character = *String++;
                if (Flags & 0x02) Attribute = *String++;
                VidBiosPrintCharacter(Character, Attribute, TRUE, Page);
            }
 
            /* Reset the cursor position to its original value if we don't want to update it */
            if (!(Flags & 0x01)) VidBiosSetCursorPosition(OldRow, OldColumn, Page);
 
            break;
        }
 
        /* Get/Set Display combination code */
        case 0x1A:
        {
            switch (getAL())
            {
                case 0x00: /* Get Display combination code */
                {
                    setBL(Bda->VGADccIDActive);
                    setBH(0x00); // No alternate display
 
                    /* Return success */
                    setAL(0x1A);
                    break;
                }
                case 0x01: /* Set Display combination code */
                {
                    DPRINT1("Set Display combination code - Unsupported\n");
                    break;
                }
                default:
                    break;
            }
            break;
        }
 
        /* Functionality/State Information (VGA) */
        case 0x1B:
        {
            PVGA_DYNAMIC_FUNC_TABLE Table = SEG_OFF_TO_PTR(getES(), getDI());
 
            /* Check for only supported subfunction */
            if (getBX() != 0x0000)
            {
                DPRINT1("INT 10h, AH=1Bh, unsupported subfunction 0x%04x\n", getBX());
                break;
            }
 
            /* Fill the VGA dynamic functionality table with our information */
 
            Table->StaticFuncTablePtr = MAKELONG(VIDEO_STATE_INFO_OFFSET, VIDEO_BIOS_DATA_SEG);
 
            Table->VideoMode       = Bda->VideoMode;
            Table->ScreenColumns   = Bda->ScreenColumns;
            Table->VideoPageSize   = Bda->VideoPageSize;
            Table->VideoPageOffset = Bda->VideoPageOffset;
            RtlCopyMemory(Table->CursorPosition, Bda->CursorPosition, sizeof(Bda->CursorPosition));
            Table->CursorEndLine   = Bda->CursorEndLine;
            Table->CursorStartLine = Bda->CursorStartLine;
            Table->VideoPage       = Bda->VideoPage;
            Table->CrtBasePort     = Bda->CrtBasePort;
            Table->CrtModeControl  = Bda->CrtModeControl;
            Table->CrtColorPaletteMask = Bda->CrtColorPaletteMask;
            Table->ScreenRows      = Bda->ScreenRows;
            Table->CharacterHeight = Bda->CharacterHeight;
 
            Table->VGADccIDActive    = Bda->VGADccIDActive;
            Table->VGADccIDAlternate = 0x00; // No alternate display
            // Table->CurrModeSupportedColorsNum;
            // Table->CurrModeSupportedPagesNum;
            // Table->Scanlines;
            // Table->PrimaryCharTable;
            // Table->SecondaryCharTable;
            // Table->VGAFlags;
            Table->VGAAvailMemory = (Bda->VGAOptions & 0x60) >> 5;
            // Table->VGASavePtrStateFlags;
            // Table->VGADispInfo;
            UNIMPLEMENTED;
 
            /* Return success */
            setAL(0x1B);
            break;
        }
 
        /* VESA BIOS Extensions */
        case 0x4F:
        {
            if (VbeInitialized) VbeService(Stack);
            break;
        }
 
        default:
        {
            DPRINT1("BIOS Function INT 10h, AH = 0x%02X, AL = 0x%02X, BH = 0x%02X NOT IMPLEMENTED\n",
                    getAH(), getAL(), getBH());
        }
    }
}

Referenced by VidBiosINT().