vbe.h File Reference

#include "hardware/video/svga.h"

Include dependency graph for vbe.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_VBE_INFORMATION
struct	_VBE_MODE_INFO
struct	_VBE_MODE

Macros
#define	OEM_NAME   "Cirrus Logic GD-5434 VGA"
#define	OEM_NAME_PTR   0xF01D5091
#define	VBE_MODE_COUNT   40
#define	VBE_MODE_SUPPORTED   (1 << 0)
#define	VBE_MODE_OPTIONAL_INFO   (1 << 1)
#define	VBE_MODE_BIOS_SUPPORT   (1 << 2)
#define	VBE_MODE_COLOR   (1 << 3)
#define	VBE_MODE_GRAPHICS   (1 << 4)
#define	VBE_WINDOW_EXISTS   (1 << 0)
#define	VBE_WINDOW_READABLE   (1 << 1)
#define	VBE_WINDOW_WRITABLE   (1 << 2)
#define	VBE_MODEL_TEXT   0
#define	VBE_MODEL_CGA   1
#define	VBE_MODEL_HGC   2
#define	VBE_MODEL_EGA   3
#define	VBE_MODEL_PACKED   4
#define	VBE_MODEL_UNCHAINED   5
#define	VBE_MODEL_DIRECT   6
#define	VBE_MODEL_YUV   7

Typedefs
typedef struct _VBE_INFORMATION	VBE_INFORMATION
typedef struct _VBE_INFORMATION *	PVBE_INFORMATION
typedef struct _VBE_MODE_INFO	VBE_MODE_INFO
typedef struct _VBE_MODE_INFO *	PVBE_MODE_INFO
typedef const struct _VBE_MODE_INFO *	PCVBE_MODE_INFO
typedef struct _VBE_MODE	VBE_MODE
typedef struct _VBE_MODE *	PVBE_MODE
typedef const struct _VBE_MODE *	PCVBE_MODE

Functions
	C_ASSERT (sizeof(VBE_INFORMATION)==256)
	C_ASSERT (sizeof(VBE_MODE_INFO) % sizeof(WORD)==0)
VOID WINAPI	VbeService (LPWORD Stack)
VOID WINAPI	VbeResetExtendedRegisters (VOID)
BOOLEAN WINAPI	VbeSetExtendedVideoMode (BYTE ModeNumber)
BOOLEAN	VbeInitialize (VOID)

Macro Definition Documentation

OEM_NAME

#define OEM_NAME   "Cirrus Logic GD-5434 VGA"

Definition at line 16 of file vbe.h.

OEM_NAME_PTR

#define OEM_NAME_PTR   0xF01D5091

Definition at line 17 of file vbe.h.

VBE_MODE_BIOS_SUPPORT

#define VBE_MODE_BIOS_SUPPORT   (1 << 2)

Definition at line 24 of file vbe.h.

VBE_MODE_COLOR

#define VBE_MODE_COLOR   (1 << 3)

Definition at line 25 of file vbe.h.

VBE_MODE_COUNT

#define VBE_MODE_COUNT   40

Definition at line 19 of file vbe.h.

VBE_MODE_GRAPHICS

#define VBE_MODE_GRAPHICS   (1 << 4)

Definition at line 26 of file vbe.h.

VBE_MODE_OPTIONAL_INFO

#define VBE_MODE_OPTIONAL_INFO   (1 << 1)

Definition at line 23 of file vbe.h.

VBE_MODE_SUPPORTED

#define VBE_MODE_SUPPORTED   (1 << 0)

Definition at line 22 of file vbe.h.

VBE_MODEL_CGA

#define VBE_MODEL_CGA   1

Definition at line 35 of file vbe.h.

VBE_MODEL_DIRECT

#define VBE_MODEL_DIRECT   6

Definition at line 40 of file vbe.h.

VBE_MODEL_EGA

#define VBE_MODEL_EGA   3

Definition at line 37 of file vbe.h.

VBE_MODEL_HGC

#define VBE_MODEL_HGC   2

Definition at line 36 of file vbe.h.

VBE_MODEL_PACKED

#define VBE_MODEL_PACKED   4

Definition at line 38 of file vbe.h.

VBE_MODEL_TEXT

#define VBE_MODEL_TEXT   0

Definition at line 34 of file vbe.h.

VBE_MODEL_UNCHAINED

#define VBE_MODEL_UNCHAINED   5

Definition at line 39 of file vbe.h.

VBE_MODEL_YUV

#define VBE_MODEL_YUV   7

Definition at line 41 of file vbe.h.

VBE_WINDOW_EXISTS

#define VBE_WINDOW_EXISTS   (1 << 0)

Definition at line 29 of file vbe.h.

VBE_WINDOW_READABLE

#define VBE_WINDOW_READABLE   (1 << 1)

Definition at line 30 of file vbe.h.

VBE_WINDOW_WRITABLE

#define VBE_WINDOW_WRITABLE   (1 << 2)

Definition at line 31 of file vbe.h.

Typedef Documentation

PCVBE_MODE

typedef const struct _VBE_MODE* PCVBE_MODE

Definition at line 105 of file vbe.h.

PCVBE_MODE_INFO

typedef const struct _VBE_MODE_INFO* PCVBE_MODE_INFO

Definition at line 93 of file vbe.h.

PVBE_INFORMATION

typedef struct _VBE_INFORMATION * PVBE_INFORMATION

PVBE_MODE

typedef struct _VBE_MODE * PVBE_MODE

PVBE_MODE_INFO

typedef struct _VBE_MODE_INFO * PVBE_MODE_INFO

VBE_INFORMATION

typedef struct _VBE_INFORMATION VBE_INFORMATION

VBE_MODE

typedef struct _VBE_MODE VBE_MODE

VBE_MODE_INFO

typedef struct _VBE_MODE_INFO VBE_MODE_INFO

Function Documentation

C_ASSERT() [1/2]

C_ASSERT

(

sizeof(VBE_INFORMATION)

= =256

)

C_ASSERT() [2/2]

C_ASSERT

(

sizeof(VBE_MODE_INFO) % sizeof(WORD)

= =0

)

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:
                {
                    DPRINT1("VESA INT 0x10, AL = 0x05, Unknown subfunction: 0x%02X\n", 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().

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().