bootvid.c File Reference

#include "precomp.h"
#include <drivers/pc98/video.h>

Include dependency graph for bootvid.c:

Go to the source code of this file.

Macros
#define	BYTES_PER_SCANLINE   (SCREEN_WIDTH / 8)
#define	PEGC_MAX_COLORS   256

Functions
static BOOLEAN	GraphGetStatus (_In_ UCHAR Status)
static BOOLEAN	TestMmio (VOID)
static BOOLEAN	HasPegcController (VOID)
static VOID	TextSync (VOID)
static VOID	InitializeDisplay (VOID)
static VOID	SetPaletteEntryRGB (_In_ ULONG Id, _In_ RGBQUAD Rgb)
VOID	InitPaletteWithTable (_In_reads_(Count) const ULONG *Table, _In_ ULONG Count)
VOID	DisplayCharacter (_In_ CHAR Character, _In_ ULONG Left, _In_ ULONG Top, _In_ ULONG TextColor, _In_ ULONG BackColor)
VOID	PreserveRow (_In_ ULONG CurrentTop, _In_ ULONG TopDelta, _In_ BOOLEAN Restore)
VOID	DoScroll (_In_ ULONG Scroll)
BOOLEAN NTAPI	VidInitialize (_In_ BOOLEAN SetMode)
VOID NTAPI	VidCleanUp (VOID)
VOID	ResetDisplay (_In_ BOOLEAN SetMode)
VOID NTAPI	VidScreenToBufferBlt (_Out_writes_bytes_all_(Delta *Height) PUCHAR Buffer, _In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Width, _In_ ULONG Height, _In_ ULONG Delta)
VOID NTAPI	VidSolidColorFill (_In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Right, _In_ ULONG Bottom, _In_ UCHAR Color)

Variables
static ULONG_PTR	PegcControl = 0
ULONG_PTR	FrameBuffer = 0

Macro Definition Documentation

BYTES_PER_SCANLINE

#define BYTES_PER_SCANLINE   (SCREEN_WIDTH / 8)

Definition at line 15 of file bootvid.c.

PEGC_MAX_COLORS

#define PEGC_MAX_COLORS   256

Definition at line 17 of file bootvid.c.

Function Documentation

DisplayCharacter()

VOID DisplayCharacter	(	_In_ CHAR	Character,
		_In_ ULONG	Left,
		_In_ ULONG	Top,
		_In_ ULONG	TextColor,
		_In_ ULONG	BackColor
	)

Definition at line 272 of file bootvid.c.

{
    const UCHAR* FontChar = GetFontPtr(Character);
    ULONG X, Y, PixelMask;
 
    for (Y = Top;
         Y < Top + BOOTCHAR_HEIGHT;
         ++Y, FontChar += FONT_PTR_DELTA)
    {
        for (X = Left, PixelMask = 1 << (BOOTCHAR_WIDTH - 1);
             X < Left + BOOTCHAR_WIDTH;
             ++X, PixelMask >>= 1)
        {
            if (*FontChar & PixelMask)
                SetPixel(X, Y, (UCHAR)TextColor);
            else if (BackColor < BV_COLOR_NONE)
                SetPixel(X, Y, (UCHAR)BackColor);
        }
    }
}

DoScroll()

VOID DoScroll

(

_In_ ULONG

Scroll

)

Definition at line 325 of file bootvid.c.

{
    USHORT i, Line;
    PUCHAR Src, Dst;
    PULONG SrcWide, DstWide;
    USHORT PixelCount = (VidpScrollRegion.Right - VidpScrollRegion.Left) + 1;
    ULONG_PTR SourceOffset = FrameBuffer + FB_OFFSET(VidpScrollRegion.Left, VidpScrollRegion.Top + Scroll);
    ULONG_PTR DestinationOffset = FrameBuffer + FB_OFFSET(VidpScrollRegion.Left, VidpScrollRegion.Top);
 
    for (Line = VidpScrollRegion.Top; Line <= VidpScrollRegion.Bottom; Line++)
    {
        SrcWide = (PULONG)SourceOffset;
        DstWide = (PULONG)DestinationOffset;
        for (i = 0; i < PixelCount / sizeof(ULONG); i++)
            WRITE_REGISTER_ULONG(DstWide++, READ_REGISTER_ULONG(SrcWide++));
 
        Src = (PUCHAR)SrcWide;
        Dst = (PUCHAR)DstWide;
        for (i = 0; i < PixelCount % sizeof(ULONG); i++)
            WRITE_REGISTER_UCHAR(Dst++, READ_REGISTER_UCHAR(Src++));
 
        SourceOffset += SCREEN_WIDTH;
        DestinationOffset += SCREEN_WIDTH;
    }
}

GraphGetStatus()

static BOOLEAN GraphGetStatus ( _In_ UCHAR  Status )

static

Definition at line 25 of file bootvid.c.

{
    UCHAR Result;
 
    WRITE_PORT_UCHAR((PUCHAR)GRAPH_IO_o_STATUS_SELECT, Status);
    Result = READ_PORT_UCHAR((PUCHAR)GRAPH_IO_i_STATUS);
 
    return (Result & GRAPH_STATUS_SET) && (Result != 0xFF);
}

Referenced by HasPegcController().

HasPegcController()

static BOOLEAN HasPegcController ( VOID  )

static

Definition at line 53 of file bootvid.c.

{
    BOOLEAN Success;
 
    if (GraphGetStatus(GRAPH_STATUS_PEGC))
        return TestMmio();
 
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_MODE_FLIPFLOP2, GDC2_EGC_FF_UNPROTECT);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_MODE_FLIPFLOP2, GDC2_MODE_PEGC_ENABLE);
    Success = GraphGetStatus(GRAPH_STATUS_PEGC) ? TestMmio() : FALSE;
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_MODE_FLIPFLOP2, GDC2_MODE_PEGC_DISABLE);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_MODE_FLIPFLOP2, GDC2_EGC_FF_PROTECT);
 
    return Success;
}

Referenced by Pc98VidFindAdapter(), and VidInitialize().

InitializeDisplay()

static VOID InitializeDisplay ( VOID  )

static

Definition at line 80 of file bootvid.c.

{
    SYNCPARAM SyncParameters;
    CSRFORMPARAM CursorParameters;
    CSRWPARAM CursorPosition;
    PITCHPARAM PitchParameters;
    PRAMPARAM RamParameters;
    ZOOMPARAM ZoomParameters;
    UCHAR RelayState;
 
    /* RESET, without FIFO check */
    WRITE_PORT_UCHAR((PUCHAR)GDC1_IO_o_COMMAND, GDC_COMMAND_RESET1);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_COMMAND, GDC_COMMAND_RESET1);
 
    /* Configure chipset */
    WRITE_PORT_UCHAR((PUCHAR)GDC1_IO_o_MODE_FLIPFLOP1, GRAPH_MODE_COLORED);
    WRITE_PORT_UCHAR((PUCHAR)GDC1_IO_o_MODE_FLIPFLOP1, GDC2_MODE_ODD_RLINE_SHOW);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_MODE_FLIPFLOP2, GDC2_MODE_COLORS_16);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_MODE_FLIPFLOP2, GDC2_MODE_GRCG);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_MODE_FLIPFLOP2, GDC2_MODE_LCD);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_MODE_FLIPFLOP2, GDC2_MODE_LINES_400);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_MODE_FLIPFLOP2, GDC2_CLOCK1_5MHZ);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_MODE_FLIPFLOP2, GDC2_CLOCK2_5MHZ);
    WRITE_PORT_UCHAR((PUCHAR)GRAPH_IO_o_HORIZONTAL_SCAN_RATE, GRAPH_HF_31KHZ);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_VIDEO_PAGE, 0);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_VIDEO_PAGE_ACCESS, 0);
 
    /* =========================== MASTER ============================ */
 
    /* MASTER */
    WRITE_GDC1_COMMAND(GDC_COMMAND_MASTER);
 
    /* SYNC */
    SyncParameters.Flags = SYNC_DISPLAY_MODE_GRAPHICS_AND_CHARACTERS | SYNC_VIDEO_FRAMING_NONINTERLACED |
                           SYNC_DRAW_ONLY_DURING_RETRACE_BLANKING | SYNC_STATIC_RAM_NO_REFRESH;
    SyncParameters.ScreenWidthChars = 80;
    SyncParameters.HorizontalSyncWidth = 12;
    SyncParameters.VerticalSyncWidth = 2;
    SyncParameters.HorizontalFrontPorchWidth = 4;
    SyncParameters.HorizontalBackPorchWidth = 4;
    SyncParameters.VerticalFrontPorchWidth = 6;
    SyncParameters.ScreenWidthLines = 480;
    SyncParameters.VerticalBackPorchWidth = 37;
    WRITE_GDC1_COMMAND(GDC_COMMAND_SYNC_ON);
    WRITE_GDC_SYNC((PUCHAR)GDC1_IO_o_PARAM, &SyncParameters);
 
    /* CSRFORM */
    CursorParameters.Show = FALSE;
    CursorParameters.Blink = FALSE;
    CursorParameters.BlinkRate = 12;
    CursorParameters.LinesPerRow = 16;
    CursorParameters.StartScanLine = 0;
    CursorParameters.EndScanLine = 15;
    WRITE_GDC1_COMMAND(GDC_COMMAND_CSRFORM);
    WRITE_GDC_CSRFORM((PUCHAR)GDC1_IO_o_PARAM, &CursorParameters);
 
    /* PITCH */
    PitchParameters.WordsPerScanline = BYTES_PER_SCANLINE;
    WRITE_GDC1_COMMAND(GDC_COMMAND_PITCH);
    WRITE_GDC_PITCH((PUCHAR)GDC1_IO_o_PARAM, &PitchParameters);
 
    /* PRAM */
    RamParameters.StartingAddress = 0;
    RamParameters.Length = 1023;
    RamParameters.ImageBit = FALSE;
    RamParameters.WideDisplay = FALSE;
    WRITE_GDC1_COMMAND(GDC_COMMAND_PRAM);
    WRITE_GDC_PRAM((PUCHAR)GDC1_IO_o_PARAM, &RamParameters);
 
    /* ZOOM */
    ZoomParameters.DisplayZoomFactor = 0;
    ZoomParameters.WritingZoomFactor = 0;
    WRITE_GDC1_COMMAND(GDC_COMMAND_ZOOM);
    WRITE_GDC_ZOOM((PUCHAR)GDC1_IO_o_PARAM, &ZoomParameters);
 
    /* CSRW */
    CursorPosition.CursorAddress = 0;
    CursorPosition.DotAddress = 0;
    WRITE_GDC1_COMMAND(GDC_COMMAND_CSRW);
    WRITE_GDC_CSRW((PUCHAR)GDC1_IO_o_PARAM, &CursorPosition);
 
    /* START */
    WRITE_GDC1_COMMAND(GDC_COMMAND_BCTRL_START);
 
    /* ============================ SLAVE ============================ */
 
    /* SLAVE */
    WRITE_GDC2_COMMAND(GDC_COMMAND_SLAVE);
 
    /* SYNC */
    SyncParameters.Flags = SYNC_DISPLAY_MODE_GRAPHICS | SYNC_VIDEO_FRAMING_NONINTERLACED |
                           SYNC_DRAW_DURING_ACTIVE_DISPLAY_TIME_AND_RETRACE_BLANKING |
                           SYNC_STATIC_RAM_NO_REFRESH;
    SyncParameters.ScreenWidthChars = 80;
    SyncParameters.HorizontalSyncWidth = 12;
    SyncParameters.VerticalSyncWidth = 2;
    SyncParameters.HorizontalFrontPorchWidth = 4;
    SyncParameters.HorizontalBackPorchWidth = 132;
    SyncParameters.VerticalFrontPorchWidth = 6;
    SyncParameters.ScreenWidthLines = 480;
    SyncParameters.VerticalBackPorchWidth = 37;
    WRITE_GDC2_COMMAND(GDC_COMMAND_SYNC_ON);
    WRITE_GDC_SYNC((PUCHAR)GDC2_IO_o_PARAM, &SyncParameters);
 
    /* CSRFORM */
    CursorParameters.Show = FALSE;
    CursorParameters.Blink = FALSE;
    CursorParameters.BlinkRate = 0;
    CursorParameters.LinesPerRow = 1;
    CursorParameters.StartScanLine = 0;
    CursorParameters.EndScanLine = 0;
    WRITE_GDC2_COMMAND(GDC_COMMAND_CSRFORM);
    WRITE_GDC_CSRFORM((PUCHAR)GDC2_IO_o_PARAM, &CursorParameters);
 
    /* PITCH */
    PitchParameters.WordsPerScanline = BYTES_PER_SCANLINE;
    WRITE_GDC2_COMMAND(GDC_COMMAND_PITCH);
    WRITE_GDC_PITCH((PUCHAR)GDC2_IO_o_PARAM, &PitchParameters);
 
    /* PRAM */
    RamParameters.StartingAddress = 0;
    RamParameters.Length = 1023;
    RamParameters.ImageBit = TRUE;
    RamParameters.WideDisplay = FALSE;
    WRITE_GDC2_COMMAND(GDC_COMMAND_PRAM);
    WRITE_GDC_PRAM((PUCHAR)GDC2_IO_o_PARAM, &RamParameters);
 
    /* ZOOM */
    ZoomParameters.DisplayZoomFactor = 0;
    ZoomParameters.WritingZoomFactor = 0;
    WRITE_GDC2_COMMAND(GDC_COMMAND_ZOOM);
    WRITE_GDC_ZOOM((PUCHAR)GDC2_IO_o_PARAM, &ZoomParameters);
 
    /* CSRW */
    CursorPosition.CursorAddress = 0;
    CursorPosition.DotAddress = 0;
    WRITE_GDC2_COMMAND(GDC_COMMAND_CSRW);
    WRITE_GDC_CSRW((PUCHAR)GDC2_IO_o_PARAM, &CursorPosition);
 
    /* Synchronize the master sync source */
    TextSync();
    TextSync();
    TextSync();
    TextSync();
 
    /* Turn off the text layer */
    WRITE_GDC1_COMMAND(GDC_COMMAND_STOP2);
 
    /* START */
    WRITE_GDC2_COMMAND(GDC_COMMAND_BCTRL_START);
 
    /* 256 colors */
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_MODE_FLIPFLOP2, GDC2_EGC_FF_UNPROTECT);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_MODE_FLIPFLOP2, GDC2_MODE_PEGC_ENABLE);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_MODE_FLIPFLOP2, GDC2_MODE_LINES_800);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_MODE_FLIPFLOP2, GDC2_EGC_FF_PROTECT);
    WRITE_REGISTER_USHORT((PUSHORT)(PegcControl + PEGC_MMIO_MODE), PEGC_MODE_PACKED);
    WRITE_REGISTER_USHORT((PUSHORT)(PegcControl + PEGC_MMIO_FRAMEBUFFER), PEGC_FB_MAP);
 
    /* Select the video source */
    RelayState = READ_PORT_UCHAR((PUCHAR)GRAPH_IO_i_RELAY) & ~(GRAPH_RELAY_0 | GRAPH_RELAY_1);
    RelayState |= GRAPH_VID_SRC_INTERNAL | GRAPH_SRC_GDC;
    WRITE_PORT_UCHAR((PUCHAR)GRAPH_IO_o_RELAY, RelayState);
}

Referenced by ResetDisplay().

InitPaletteWithTable()

VOID InitPaletteWithTable	(	_In_reads_(Count) const ULONG *	Table,
		_In_ ULONG	Count
	)

Definition at line 257 of file bootvid.c.

{
    const ULONG* Entry = Table;
    ULONG i;
 
    for (i = 0; i < Count; i++)
        SetPaletteEntryRGB(i, *Entry++);
 
    for (i = Count; i < PEGC_MAX_COLORS; i++)
        SetPaletteEntryRGB(i, VidpDefaultPalette[BV_COLOR_BLACK]);
}

PreserveRow()

VOID PreserveRow	(	_In_ ULONG	CurrentTop,
		_In_ ULONG	TopDelta,
		_In_ BOOLEAN	Restore
	)

Definition at line 299 of file bootvid.c.

{
    PULONG OldPosition, NewPosition;
    ULONG PixelCount = TopDelta * (SCREEN_WIDTH / sizeof(ULONG));
 
    if (Restore)
    {
        /* Restore the row by copying back the contents saved off-screen */
        OldPosition = (PULONG)(FrameBuffer + FB_OFFSET(0, SCREEN_HEIGHT));
        NewPosition = (PULONG)(FrameBuffer + FB_OFFSET(0, CurrentTop));
    }
    else
    {
        /* Preserve the row by saving its contents off-screen */
        OldPosition = (PULONG)(FrameBuffer + FB_OFFSET(0, CurrentTop));
        NewPosition = (PULONG)(FrameBuffer + FB_OFFSET(0, SCREEN_HEIGHT));
    }
 
    while (PixelCount--)
        WRITE_REGISTER_ULONG(NewPosition++, READ_REGISTER_ULONG(OldPosition++));
}

ResetDisplay()

VOID ResetDisplay

(

_In_ BOOLEAN

SetMode

)

Definition at line 394 of file bootvid.c.

{
    PULONG PixelsPosition = (PULONG)(FrameBuffer + FB_OFFSET(0, 0));
    ULONG PixelCount = ((SCREEN_WIDTH * SCREEN_HEIGHT) / sizeof(ULONG)) + 1;
 
    /* Reset the video mode with HAL if requested */
    if (SetMode)
        HalResetDisplay();
 
    WRITE_PORT_UCHAR((PUCHAR)GDC1_IO_o_MODE_FLIPFLOP1, GRAPH_MODE_DISPLAY_DISABLE);
 
    /* 640x480 256-color 31 kHz mode */
    InitializeDisplay();
 
    /* Re-initialize the palette and fill the screen black */
    InitializePalette();
    while (PixelCount--)
        WRITE_REGISTER_ULONG(PixelsPosition++, 0);
 
    WRITE_PORT_UCHAR((PUCHAR)GDC1_IO_o_MODE_FLIPFLOP1, GRAPH_MODE_DISPLAY_ENABLE);
}

SetPaletteEntryRGB()

static VOID SetPaletteEntryRGB ( _In_ ULONG  Id, _In_ RGBQUAD  Rgb  )

static

Definition at line 246 of file bootvid.c.

{
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_PALETTE_INDEX, Id);
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_RED, GetRValue(Rgb));
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_GREEN, GetGValue(Rgb));
    WRITE_PORT_UCHAR((PUCHAR)GDC2_IO_o_BLUE, GetBValue(Rgb));
}

Referenced by InitPaletteWithTable().

TestMmio()

static BOOLEAN TestMmio ( VOID  )

static

Definition at line 37 of file bootvid.c.

{
    USHORT OldValue, NewValue;
 
    OldValue = READ_REGISTER_USHORT((PUSHORT)(PegcControl + PEGC_MMIO_MODE));
 
    /* Bits [15:1] are not writable */
    WRITE_REGISTER_USHORT((PUSHORT)(PegcControl + PEGC_MMIO_MODE), 0x80);
    NewValue = READ_REGISTER_USHORT((PUSHORT)(PegcControl + PEGC_MMIO_MODE));
 
    WRITE_REGISTER_USHORT((PUSHORT)(PegcControl + PEGC_MMIO_MODE), OldValue);
 
    return !(NewValue & 0x80);
}

Referenced by HasPegcController().

TextSync()

static VOID TextSync ( VOID  )

static

Definition at line 70 of file bootvid.c.

{
    while (READ_PORT_UCHAR((PUCHAR)GDC1_IO_i_STATUS) & GDC_STATUS_VSYNC)
        NOTHING;
 
    while (!(READ_PORT_UCHAR((PUCHAR)GDC1_IO_i_STATUS) & GDC_STATUS_VSYNC))
        NOTHING;
}

Referenced by InitializeDisplay().

VidCleanUp()

VOID NTAPI VidCleanUp

(

VOID

)

Definition at line 388 of file bootvid.c.

{
    WRITE_PORT_UCHAR((PUCHAR)GDC1_IO_o_MODE_FLIPFLOP1, GRAPH_MODE_DISPLAY_DISABLE);
}

VidInitialize()

BOOLEAN NTAPI VidInitialize

(

_In_ BOOLEAN

SetMode

)

Definition at line 356 of file bootvid.c.

{
    PHYSICAL_ADDRESS BaseAddress;
 
    BaseAddress.QuadPart = VRAM_NORMAL_PLANE_I;
    PegcControl = (ULONG_PTR)MmMapIoSpace(BaseAddress, PEGC_CONTROL_SIZE, MmNonCached);
    if (!PegcControl)
        goto Failure;
 
    if (!HasPegcController())
        goto Failure;
 
    BaseAddress.QuadPart = PEGC_FRAMEBUFFER_PACKED;
    FrameBuffer = (ULONG_PTR)MmMapIoSpace(BaseAddress, PEGC_FRAMEBUFFER_SIZE, MmNonCached);
    if (!FrameBuffer)
        goto Failure;
 
    if (SetMode)
        VidResetDisplay(TRUE);
 
    return TRUE;
 
Failure:
    if (PegcControl)
        MmUnmapIoSpace((PVOID)PegcControl, PEGC_CONTROL_SIZE);
 
    return FALSE;
}

VidScreenToBufferBlt()

VOID NTAPI VidScreenToBufferBlt	(	_Out_writes_bytes_all_(Delta *Height) PUCHAR	Buffer,
		_In_ ULONG	Left,
		_In_ ULONG	Top,
		_In_ ULONG	Width,
		_In_ ULONG	Height,
		_In_ ULONG	Delta
	)

Definition at line 419 of file bootvid.c.

{
    ULONG X, Y;
    PUCHAR OutputBuffer;
    USHORT Px;
    PUSHORT PixelsPosition;
 
    /* Clear the destination buffer */
    RtlZeroMemory(Buffer, Delta * Height);
 
    for (Y = 0; Y < Height; Y++)
    {
        OutputBuffer = Buffer + Y * Delta;
        PixelsPosition = (PUSHORT)(FrameBuffer + FB_OFFSET(Left, Top + Y));
 
        for (X = 0; X < Width; X += sizeof(USHORT))
        {
            Px = READ_REGISTER_USHORT(PixelsPosition++);
            *OutputBuffer++ = (FIRSTBYTE(Px) << 4) | (SECONDBYTE(Px) & 0x0F);
        }
    }
}

VidSolidColorFill()

VOID NTAPI VidSolidColorFill	(	_In_ ULONG	Left,
		_In_ ULONG	Top,
		_In_ ULONG	Right,
		_In_ ULONG	Bottom,
		_In_ UCHAR	Color
	)

Definition at line 450 of file bootvid.c.

{
    USHORT i, Line;
    PUCHAR PixelPtr;
    PULONG PixelsPtr;
    ULONG WideColor = (Color << 24) | (Color << 16) | (Color << 8) | Color;
    USHORT PixelCount = (Right - Left) + 1;
    ULONG_PTR StartOffset = FrameBuffer + FB_OFFSET(Left, Top);
 
    for (Line = Top; Line <= Bottom; Line++)
    {
        PixelsPtr = (PULONG)StartOffset;
        for (i = 0; i < PixelCount / sizeof(ULONG); i++)
            WRITE_REGISTER_ULONG(PixelsPtr++, WideColor);
 
        PixelPtr = (PUCHAR)PixelsPtr;
        for (i = 0; i < PixelCount % sizeof(ULONG); i++)
            WRITE_REGISTER_UCHAR(PixelPtr++, Color);
 
        StartOffset += SCREEN_WIDTH;
    }
}

Variable Documentation

FrameBuffer

ULONG_PTR FrameBuffer = 0

Definition at line 20 of file bootvid.c.

Referenced by ConsoleEfiGopEnable(), ConsolepClearBuffer(), DetectDisplayController(), DoScroll(), EfiGopGetFrameBuffer(), PreserveRow(), ResetDisplay(), SetPixel(), VBEMapVideoMemory(), VidInitialize(), VidScreenToBufferBlt(), VidSolidColorFill(), XboxMemGetMemoryMap(), and XboxVmpMapVideoMemory().

PegcControl

ULONG_PTR PegcControl = 0

static

Definition at line 19 of file bootvid.c.

Referenced by InitializeDisplay(), TestMmio(), and VidInitialize().