vbe.c File Reference

#include "ntvdm.h"
#include <debug.h>
#include "emulator.h"
#include "cpu/cpu.h"
#include "bios32p.h"
#include "hardware/video/svga.h"
#include "vbe.h"
#include "io.h"

Include dependency graph for vbe.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
PCVBE_MODE	VbeGetModeByNumber (WORD Number)
static VOID	VbeSetExtendedRegisters (PSVGA_REGISTERS Registers)
BOOLEAN WINAPI	VbeSetExtendedVideoMode (BYTE ModeNumber)
VOID WINAPI	VbeResetExtendedRegisters (VOID)
VOID WINAPI	VbeService (LPWORD Stack)
BOOLEAN	VbeInitialize (VOID)

Variables
static const VBE_MODE_INFO	VbeMode_640x480x256_Info
static SVGA_REGISTERS	VbeMode_640x480x256_Registers
static const VBE_MODE_INFO	VbeMode_800x600x256_Info
static SVGA_REGISTERS	VbeMode_800x600x256_Registers
static const VBE_MODE	Modes [VBE_MODE_COUNT]

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file vbe.c.

Function Documentation

VbeGetModeByNumber()

PCVBE_MODE VbeGetModeByNumber

(

WORD

Number

)

Definition at line 220 of file vbe.c.

{
    INT i;
 
    Number &= 0x1FF;
 
    /* Find the mode */
    for (i = 0; i < VBE_MODE_COUNT; i++)
    {
        if ((!(Number & 0x100) && (Number == Modes[i].Number))
            || ((Number & 0x100) && (Number== Modes[i].VesaNumber)))
        {
            return &Modes[i];
        }
    }
 
    return NULL;
}

Referenced by VbeService(), and VbeSetExtendedVideoMode().

VbeInitialize()

BOOLEAN VbeInitialize

(

VOID

)

Definition at line 763 of file vbe.c.

{
    BOOLEAN Success;
    BYTE SeqIndex = IOReadB(VGA_SEQ_INDEX);
 
    /* Store the OEM name */
    strcpy(FAR_POINTER(OEM_NAME_PTR), OEM_NAME);
 
    /* Unlock SVGA extensions on the card */
    IOWriteB(VGA_SEQ_INDEX, SVGA_SEQ_UNLOCK_REG);
    IOWriteB(VGA_SEQ_DATA, SVGA_SEQ_UNLOCKED);
 
    /* Check if it worked */
    Success = IOReadB(VGA_SEQ_DATA) == SVGA_SEQ_UNLOCKED;
 
    IOWriteB(VGA_SEQ_INDEX, SeqIndex);
    return Success;
}

Referenced by VidBiosPost().

VbeResetExtendedRegisters()

VOID WINAPI VbeResetExtendedRegisters

(

VOID

)

Definition at line 380 of file vbe.c.

{
    BYTE i;
 
    /* Disable interrupts */
    BOOLEAN Interrupts = getIF();
    setIF(0);
 
    /* Turn the video off */
    IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_CLOCK_REG);
    IOWriteB(VGA_SEQ_DATA , IOReadB(VGA_SEQ_DATA) | VGA_SEQ_CLOCK_SD);
 
    /* Synchronous reset on */
    IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_RESET_REG);
    IOWriteB(VGA_SEQ_DATA , VGA_SEQ_RESET_AR );
 
    /* Clear the extended sequencer registers, except for the VCLKs and MCLK */
    for (i = SVGA_SEQ_EXT_MODE_REG; i < SVGA_SEQ_VCLK0_DENOMINATOR_REG; i++)
    {
        if (i != VGA_SEQ_MAX_REG && i != SVGA_SEQ_UNLOCK_REG
            && (i < SVGA_SEQ_VCLK0_NUMERATOR_REG || i > SVGA_SEQ_VCLK3_NUMERATOR_REG))
        {
            IOWriteB(VGA_SEQ_INDEX, i);
            IOWriteB(VGA_SEQ_DATA, 0x00);
        }
    }
 
    /* Reset the VCLKs */
    IOWriteB(VGA_SEQ_INDEX, SVGA_SEQ_VCLK0_NUMERATOR_REG);
    IOWriteB(VGA_SEQ_DATA, 0x66);
    IOWriteB(VGA_SEQ_INDEX, SVGA_SEQ_VCLK0_DENOMINATOR_REG);
    IOWriteB(VGA_SEQ_DATA, 0x3B);
 
    IOWriteB(VGA_SEQ_INDEX, SVGA_SEQ_VCLK1_NUMERATOR_REG);
    IOWriteB(VGA_SEQ_DATA, 0x5B);
    IOWriteB(VGA_SEQ_INDEX, SVGA_SEQ_VCLK1_DENOMINATOR_REG);
    IOWriteB(VGA_SEQ_DATA, 0x2F);
 
    IOWriteB(VGA_SEQ_INDEX, SVGA_SEQ_VCLK2_NUMERATOR_REG);
    IOWriteB(VGA_SEQ_DATA, 0x45);
    IOWriteB(VGA_SEQ_INDEX, SVGA_SEQ_VCLK2_DENOMINATOR_REG);
    IOWriteB(VGA_SEQ_DATA, 0x30);
 
    IOWriteB(VGA_SEQ_INDEX, SVGA_SEQ_VCLK3_NUMERATOR_REG);
    IOWriteB(VGA_SEQ_DATA, 0x7E);
    IOWriteB(VGA_SEQ_INDEX, SVGA_SEQ_VCLK3_DENOMINATOR_REG);
    IOWriteB(VGA_SEQ_DATA, 0x33);
 
    /* Reset the MCLK */
    IOWriteB(VGA_SEQ_INDEX, SVGA_SEQ_MCLK_REG);
    IOWriteB(VGA_SEQ_DATA, 0x1C);
 
    /* Synchronous reset off */
    IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_RESET_REG);
    IOWriteB(VGA_SEQ_DATA , VGA_SEQ_RESET_SR | VGA_SEQ_RESET_AR);
 
    /* Reset the extended CRTC registers */
    for (i = SVGA_CRTC_INTERLACE_END_REG; i < SVGA_CRTC_MAX_REG; i++)
    {
        if ((i < SVGA_CRTC_UNUSED0_REG || i > SVGA_CRTC_UNUSED6_REG) && i != SVGA_CRTC_UNUSED7_REG)
        {
            IOWriteB(VGA_CRTC_INDEX, i);
            IOWriteB(VGA_CRTC_DATA, 0x00);
        }
    }
 
    /* Reset the extended GC registers */
    for (i = SVGA_GC_OFFSET_0_REG; i < SVGA_GC_MAX_REG; i++)
    {
        if (i != SVGA_GC_UNUSED0_REG && i != SVGA_GC_UNUSED11_REG
            && (i < SVGA_GC_UNUSED1_REG || i > SVGA_GC_UNUSED10_REG))
        {
            IOWriteB(VGA_GC_INDEX, i);
            IOWriteB(VGA_GC_DATA, 0x00);
        }
    }
 
    /*
     * And finally, reset the hidden register. This requires 4 dummy reads from
     * the DAC mask register.
     */
    for (i = 0; i < 4; i++) IOReadB(VGA_DAC_MASK);
    IOWriteB(VGA_DAC_MASK, 0x00);
 
    /* Turn the video on */
    IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_CLOCK_REG);
    IOWriteB(VGA_SEQ_DATA , IOReadB(VGA_SEQ_DATA) & ~VGA_SEQ_CLOCK_SD);
 
    /* Restore interrupts */
    setIF(Interrupts);
}

Referenced by VidBiosSetVideoMode().

VbeService()

VOID WINAPI VbeService

(

LPWORD

Stack

)

Definition at line 472 of file vbe.c.

{
    INT i;
 
    switch (getAL())
    {
        /* Get VBE Information */
        case 0x00:
        {
            VBE_INFORMATION Info;
            PWORD Data = (PWORD)&Info;
 
            /* Function recognized */
            setAL(0x4F);
 
            ZeroMemory(&Info, sizeof(VBE_INFORMATION));
            Info.Signature = 'ASEV';
            Info.Version = 0x0102;
            Info.OemName = OEM_NAME_PTR;
            Info.Capabilities = 0;
            Info.ModeList = MAKELONG(LOWORD(getDI()
                                     + FIELD_OFFSET(VBE_INFORMATION, ModeListBuffer)),
                                     getES());
            Info.VideoMemory = HIWORD(SVGA_BANK_SIZE * VGA_NUM_BANKS);
 
            /* Fill the mode list */
            for (i = 0; i < VBE_MODE_COUNT; i++)
            {
                /* Some modes don't have VESA numbers */
                if (Modes[i].VesaNumber != 0xFFFF)
                {
                    Info.ModeListBuffer[i] = Modes[i].VesaNumber;
                }
            }
 
            Info.ModeListBuffer[VBE_MODE_COUNT] = 0xFFFF;
 
            /* Copy the data to the caller */
            for (i = 0; i < sizeof(VBE_INFORMATION) / sizeof(WORD); i++)
            {
                *(PWORD)SEG_OFF_TO_PTR(getES(), LOWORD(getDI() + i * 2)) = Data[i];
            }
 
            setAH(0);
            break;
        }
 
        /* Get VBE Mode Information */
        case 0x01:
        {
            PCVBE_MODE Mode = VbeGetModeByNumber(getCX());
            PWORD Data = NULL;
 
            /* Function recognized */
            setAL(0x4F);
 
            if (Mode == NULL)
            {
                /* Mode not found */
                setAH(1);
                break;
            }
 
            Data = (PWORD)Mode->Info;
            if (Data == NULL)
            {
                DPRINT1("WARNING: The mode information for mode %02X (%03X) is missing!\n",
                        Mode->Number,
                        Mode->VesaNumber);
 
                setAH(1);
                break;
            }
 
            /* Clear the buffer */
            for (i = 0; i < 128; i++)
            {
                *(PWORD)SEG_OFF_TO_PTR(getES(), LOWORD(getDI() + i * 2)) = 0;
            }
 
            /* Copy the data to the caller */
            for (i = 0; i < sizeof(VBE_MODE_INFO) / sizeof(WORD); i++)
            {
                *(PWORD)SEG_OFF_TO_PTR(getES(), LOWORD(getDI() + i * 2)) = Data[i];
            }
 
            setAH(0);
            break;
        }
 
        /* Set VBE Mode */
        case 0x02:
        {
            WORD VesaNumber = getBX();
            setAL(0x4F);
 
            if (VesaNumber <= BIOS_MAX_VIDEO_MODE)
            {
                /* Call the VGA BIOS */
                setAH(0x00);
                setAL(VesaNumber);
                Int32Call(&BiosContext, BIOS_VIDEO_INTERRUPT);
 
                setAH(Bda->VideoMode != VesaNumber);
            }
            else
            {
                /* This is an extended video mode */
                PCVBE_MODE Mode = VbeGetModeByNumber(VesaNumber);
 
                if (Mode) setAH(!VbeSetExtendedVideoMode(Mode->Number));
                else setAH(1);
            }
 
            break;
        }
 
        /* Get Current VBE Mode */
        case 0x03:
        {
            PCVBE_MODE Mode = VbeGetModeByNumber(Bda->VideoMode);
 
            setAL(0x4F);
 
            if (Mode)
            {
                setBX(Mode->VesaNumber != 0xFFFF
                      ? Mode->VesaNumber : Mode->Number);
                setAH(0);
            }
            else
            {
                setAH(1);
            }
 
            break;
        }
 
        /* CPU Video Memory Control */
        case 0x05:
        {
            BYTE Window = getBL();
            BYTE OldGcIndex = IOReadB(VGA_GC_INDEX);
 
            switch (getBH())
            {
                /* Select Memory Window */
                case 0:
                {
                    setAL(0x4F);
 
                    if (getDH() != 0)
                    {
                        /* Offset too high */
                        setAH(1);
                        break;
                    }
 
                    IOWriteB(VGA_GC_INDEX, (Window == 0) ? SVGA_GC_OFFSET_0_REG : SVGA_GC_OFFSET_1_REG);
                    IOWriteB(VGA_GC_DATA, getDL());
 
                    setAH(0);
                    break;
                }
 
                /* Return Memory Window */
                case 1:
                {
                    IOWriteB(VGA_GC_INDEX, (Window == 0) ? SVGA_GC_OFFSET_0_REG : SVGA_GC_OFFSET_1_REG);
                    setDX(IOReadB(VGA_GC_DATA));
 
                    setAX(0x004F);
                    break;
                }
 
                default:
                {
                    DPRINT("VESA INT 0x10, AL = 0x05, Unknown subfunction: %02X", getBH());
                }
            }
 
            IOWriteB(VGA_GC_INDEX, OldGcIndex);
            break;
        }
 
        /* Get/Set Display Start */
        case 0x07:
        {
            DWORD StartAddress;
            BYTE Value;
            PCVBE_MODE Mode = VbeGetModeByNumber(Bda->VideoMode);
            BYTE OldCrtcIndex = IOReadB(VGA_CRTC_INDEX_COLOR);
 
            if (getBL() & 0x80)
            {
                /* Wait for a vertical retrace */
                if (!(IOReadB(VGA_INSTAT1_READ_COLOR) & VGA_STAT_VRETRACE))
                {
                    setCF(1);
                    break;
                }
 
                setCF(0);
            }
 
            switch (getBL() & 0x7F)
            {
                /* Set Display Start */
                case 0x00:
                {
                    setAL(0x4F);
 
                    if (Mode == NULL || Mode->Info == NULL)
                    {
                        /* This is not a VBE mode */
                        // TODO: Support anyway, perhaps? It can be done.
                        setAH(0x01);
                        break;
                    }
 
                    StartAddress = getCX() + getDX() * Mode->Info->BytesPerScanline;
 
                    IOWriteB(VGA_CRTC_INDEX_COLOR, SVGA_CRTC_OVERLAY_REG);
                    Value = IOReadB(VGA_CRTC_DATA_COLOR);
                    Value &= ~SVGA_CRTC_EXT_ADDR_BIT19;
                    Value |= (StartAddress >> 12) & SVGA_CRTC_EXT_ADDR_BIT19;
                    IOWriteB(VGA_CRTC_DATA_COLOR, Value);
 
                    IOWriteB(VGA_CRTC_INDEX_COLOR, SVGA_CRTC_EXT_DISPLAY_REG);
                    Value = IOReadB(VGA_CRTC_DATA_COLOR);
                    Value &= ~(SVGA_CRTC_EXT_ADDR_BIT16 | SVGA_CRTC_EXT_ADDR_BITS1718);
                    Value |= (StartAddress >> 16) & SVGA_CRTC_EXT_ADDR_BIT16;
                    Value |= (StartAddress >> 15) & SVGA_CRTC_EXT_ADDR_BITS1718;
                    IOWriteB(VGA_CRTC_DATA_COLOR, Value);
 
                    IOWriteB(VGA_CRTC_INDEX_COLOR, VGA_CRTC_START_ADDR_HIGH_REG);
                    IOWriteB(VGA_CRTC_DATA_COLOR, (StartAddress >> 8) & 0xFF);
                    IOWriteB(VGA_CRTC_INDEX_COLOR, VGA_CRTC_START_ADDR_LOW_REG);
                    IOWriteB(VGA_CRTC_DATA_COLOR, StartAddress & 0xFF);
 
                    setAH(0);
                    break;
                }
 
                /* Get Display Start */
                case 0x01:
                {
                    setAL(0x4F);
                    StartAddress = 0;
 
                    if (Mode == NULL || Mode->Info == NULL)
                    {
                        /* This is not a VBE mode */
                        // TODO: Support anyway, perhaps? It can be done.
                        setAH(0x01);
                        break;
                    }
 
                    IOWriteB(VGA_CRTC_INDEX_COLOR, SVGA_CRTC_OVERLAY_REG);
                    StartAddress = (IOReadB(VGA_CRTC_DATA_COLOR) & SVGA_CRTC_EXT_ADDR_BIT19) << 12;
 
                    IOWriteB(VGA_CRTC_INDEX_COLOR, SVGA_CRTC_EXT_DISPLAY_REG);
                    Value = IOReadB(VGA_CRTC_DATA_COLOR);
                    StartAddress |= (Value & SVGA_CRTC_EXT_ADDR_BIT16) << 16;
                    StartAddress |= (Value & SVGA_CRTC_EXT_ADDR_BITS1718) << 15;
 
                    IOWriteB(VGA_CRTC_INDEX_COLOR, VGA_CRTC_START_ADDR_HIGH_REG);
                    StartAddress |= IOReadB(VGA_CRTC_DATA_COLOR) << 8;
                    IOWriteB(VGA_CRTC_INDEX_COLOR, VGA_CRTC_START_ADDR_LOW_REG);
                    StartAddress |= IOReadB(VGA_CRTC_DATA_COLOR);
 
                    setCX(StartAddress % Mode->Info->BytesPerScanline);
                    setDX(StartAddress / Mode->Info->BytesPerScanline);
 
                    setAH(0);
                    break;
                }
            }
 
            IOWriteB(VGA_CRTC_INDEX_COLOR, OldCrtcIndex);
            break;
        }
 
        default:
        {
            DPRINT1("VESA BIOS Extensions function %02Xh NOT IMPLEMENTED!\n", getAL());
            break;
        }
    }
}

Referenced by VidBiosVideoService().

VbeSetExtendedRegisters()

static VOID VbeSetExtendedRegisters ( PSVGA_REGISTERS  Registers )

static

Definition at line 240 of file vbe.c.

{
    UINT i;
 
    /* Disable interrupts */
    BOOLEAN Interrupts = getIF();
    setIF(0);
 
    /*
     * Set the CRT base address according to the selected mode,
     * monochrome or color. The following macros:
     * VGA_INSTAT1_READ, VGA_CRTC_INDEX and VGA_CRTC_DATA are then
     * used to access the correct VGA I/O ports.
     */
    Bda->CrtBasePort = (Registers->Misc & 0x01) ? VGA_CRTC_INDEX_COLOR
                                                : VGA_CRTC_INDEX_MONO;
    /* Bit 1 indicates whether display is color (0) or monochrome (1) */
    Bda->VGAOptions     = (Bda->VGAOptions     & 0xFD) | (!(Registers->Misc & 0x01) << 1);
    Bda->CrtModeControl = (Bda->CrtModeControl & 0xFB) | (!(Registers->Misc & 0x01) << 1);
 
    /* Update blink bit in BDA */
    if (Registers->Attribute[VGA_AC_CONTROL_REG] & VGA_AC_CONTROL_BLINK)
        Bda->CrtModeControl |= (1 << 5);
    else
        Bda->CrtModeControl &= ~(1 << 5);
 
    /* Turn the video off */
    IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_CLOCK_REG);
    IOWriteB(VGA_SEQ_DATA , IOReadB(VGA_SEQ_DATA) | VGA_SEQ_CLOCK_SD);
 
    /* Write the misc register */
    IOWriteB(VGA_MISC_WRITE, Registers->Misc);
 
    /* Synchronous reset on */
    IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_RESET_REG);
    IOWriteB(VGA_SEQ_DATA , VGA_SEQ_RESET_AR );
 
    /* Write the sequencer registers */
    for (i = 1; i < SVGA_SEQ_MAX_REG; i++)
    {
        if (i != VGA_SEQ_MAX_REG && i != SVGA_SEQ_UNLOCK_REG)
        {
            IOWriteB(VGA_SEQ_INDEX, i);
            IOWriteB(VGA_SEQ_DATA , Registers->Sequencer[i]);
        }
    }
 
    /* Synchronous reset off */
    IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_RESET_REG);
    IOWriteB(VGA_SEQ_DATA , VGA_SEQ_RESET_SR | VGA_SEQ_RESET_AR);
 
    /* Unlock CRTC registers 0-7 */
    IOWriteB(VGA_CRTC_INDEX, VGA_CRTC_END_HORZ_BLANKING_REG);
    IOWriteB(VGA_CRTC_DATA , IOReadB(VGA_CRTC_DATA) | 0x80);
    IOWriteB(VGA_CRTC_INDEX, VGA_CRTC_END_VERT_RETRACE_REG);
    IOWriteB(VGA_CRTC_DATA , IOReadB(VGA_CRTC_DATA) & ~0x80);
    // Make sure they remain unlocked
    Registers->CRT[VGA_CRTC_END_HORZ_BLANKING_REG] |= 0x80;
    Registers->CRT[VGA_CRTC_END_VERT_RETRACE_REG] &= ~0x80;
 
    /* Write the CRTC registers */
    for (i = 0; i < SVGA_CRTC_MAX_REG; i++)
    {
        if ((i < SVGA_CRTC_UNUSED0_REG || i > SVGA_CRTC_UNUSED6_REG) && i != SVGA_CRTC_UNUSED7_REG)
        {
            IOWriteB(VGA_CRTC_INDEX, i);
            IOWriteB(VGA_CRTC_DATA , Registers->CRT[i]);
        }
    }
 
    /* Write the GC registers */
    for (i = 0; i < SVGA_GC_MAX_REG; i++)
    {
        if (i != SVGA_GC_UNUSED0_REG && i != SVGA_GC_UNUSED11_REG
            && (i < SVGA_GC_UNUSED1_REG || i > SVGA_GC_UNUSED10_REG))
        {
            IOWriteB(VGA_GC_INDEX, i);
            IOWriteB(VGA_GC_DATA , Registers->Graphics[i]);
        }
    }
 
    /* Write the AC registers */
    for (i = 0; i < VGA_AC_MAX_REG; i++)
    {
        /* Write the index */
        IOReadB(VGA_INSTAT1_READ); // Put the AC register into index state
        IOWriteB(VGA_AC_INDEX, i);
 
        /* Write the data */
        IOWriteB(VGA_AC_WRITE, Registers->Attribute[i]);
    }
 
    /* Perform 4 dummy reads from the DAC mask to access the hidden register */
    for (i = 0; i < 4; i++) IOReadB(VGA_DAC_MASK);
 
    /* Set the hidden register */
    IOWriteB(VGA_DAC_MASK, Registers->Hidden);
 
    /* Set the PEL mask */
    IOWriteB(VGA_DAC_MASK, 0xFF);
 
    /* Enable screen and disable palette access */
    IOReadB(VGA_INSTAT1_READ); // Put the AC register into index state
    IOWriteB(VGA_AC_INDEX, 0x20);
 
    /* Turn the video on */
    IOWriteB(VGA_SEQ_INDEX, VGA_SEQ_CLOCK_REG);
    IOWriteB(VGA_SEQ_DATA , IOReadB(VGA_SEQ_DATA) & ~VGA_SEQ_CLOCK_SD);
 
    /* Restore interrupts */
    setIF(Interrupts);
}

Referenced by VbeSetExtendedVideoMode().

VbeSetExtendedVideoMode()

BOOLEAN WINAPI VbeSetExtendedVideoMode

(

BYTE

ModeNumber

)

Definition at line 356 of file vbe.c.

{
    PCVBE_MODE Mode = VbeGetModeByNumber(ModeNumber);
    if (Mode == NULL) return FALSE;
 
    /* At this point, Mode->Registers shouldn't be NULL unless the mode is unimplemented */
    if (Mode->Registers == NULL)
    {
        DPRINT1("Extended video mode %02X still UNIMPLEMENTED.\n", ModeNumber);
        return FALSE;
    }
 
    /* Set the registers */
    VbeSetExtendedRegisters(Mode->Registers);
 
    /* Update the current video mode in the BDA */
    Bda->VideoMode = ModeNumber;
 
    /* Clear the screen */
    VgaClearMemory();
 
    return TRUE;
}

Referenced by VbeService(), and VidBiosSetVideoMode().

Variable Documentation

Modes

const VBE_MODE Modes[VBE_MODE_COUNT]

static

Initial value:

=
{
    { 0x14, 0xFFFF, NULL                     , NULL                 },
    { 0x54, 0x10A , NULL           , NULL                 },
    { 0x55, 0x109 , NULL           , NULL                 },
    { 0x58, 0x102 , NULL           , NULL                 },
    { 0x5C, 0x103 , &VbeMode_800x600x256_Info, &VbeMode_800x600x256_Registers },
    { 0x5D, 0x104 , NULL           , NULL                 },
    { 0x5E, 0x100 , NULL           , NULL                 },
    { 0x5F, 0x101 , &VbeMode_640x480x256_Info, &VbeMode_640x480x256_Registers },
    { 0x60, 0x105 , NULL           , NULL                 },
    { 0x64, 0x111 , NULL           , NULL                 },
    { 0x65, 0x114 , NULL           , NULL                 },
    { 0x66, 0x110 , NULL           , NULL                 },
    { 0x67, 0x113 , NULL           , NULL                 },
    { 0x68, 0x116 , NULL           , NULL                 },
    { 0x69, 0x119 , NULL           , NULL                 },
    { 0x6C, 0x106 , NULL           , NULL                 },
    { 0x6D, 0x107 , NULL           , NULL                 },
    { 0x71, 0x112 , NULL           , NULL                 },
    { 0x72, 0xFFFF, NULL                     , NULL                 },
    { 0x73, 0xFFFF, NULL                     , NULL                 },
    { 0x74, 0x117 , NULL           , NULL                 },
    { 0x75, 0x11A , NULL           , NULL                 },
    { 0x76, 0xFFFF, NULL                     , NULL                 },
    { 0x78, 0x115 , NULL           , NULL                 },
    { 0x79, 0x118 , NULL           , NULL                 },
}

Definition at line 189 of file vbe.c.

Referenced by ddraw7_StartModeTest(), GetAvailableModes(), Pc98VidQueryNumAvailModes(), VbeGetModeByNumber(), VBEQueryNumAvailModes(), VbeService(), and XboxVmpQueryNumAvailModes().

VbeMode_640x480x256_Info

const VBE_MODE_INFO VbeMode_640x480x256_Info

static

Definition at line 27 of file vbe.c.

VbeMode_640x480x256_Registers

SVGA_REGISTERS VbeMode_640x480x256_Registers

static

Definition at line 69 of file vbe.c.

VbeMode_800x600x256_Info

const VBE_MODE_INFO VbeMode_800x600x256_Info

static

Definition at line 108 of file vbe.c.

VbeMode_800x600x256_Registers

SVGA_REGISTERS VbeMode_800x600x256_Registers

static

Definition at line 150 of file vbe.c.