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)
static VOID	InitializePalette (VOID)
VOID	DisplayCharacter (_In_ CHAR Character, _In_ ULONG Left, _In_ ULONG Top, _In_ ULONG TextColor, _In_ ULONG BackColor)
VOID	PreserveRow (_In_ ULONG CurrentTop, _In_ ULONG Height, _In_ BOOLEAN Restore)
VOID	DoScroll (_In_ ULONG Scroll)
BOOLEAN NTAPI	VidInitialize (_In_ BOOLEAN SetMode)
VOID NTAPI	VidCleanUp (VOID)
VOID	ResetDisplay (_In_ BOOLEAN SetMode)
static VOID	SaveRowToBuffer (_Out_ UCHAR *__restrict Buffer, _In_ const ULONG *__restrict Pixels, _In_ ULONG Width, _In_ ULONG Shift)
VOID NTAPI	VidScreenToBufferBlt (_Out_writes_bytes_all_(Height *Stride) PUCHAR Buffer, _In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Width, _In_ ULONG Height, _In_ ULONG Stride)
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 282 of file bootvid.c.

{
    const UCHAR* FontChar = GetFontPtr(Character);
    ULONG_PTR StartOffset = FrameBuffer + FB_OFFSET(Left, Top);
    ULONG X, Y;
 
    for (Y = 0; Y < BOOTCHAR_HEIGHT; ++Y)
    {
        PUCHAR Pixel = (PUCHAR)StartOffset;
        UCHAR PixelMask = 1 << (BOOTCHAR_WIDTH - 1);
 
        for (X = 0; X < BOOTCHAR_WIDTH; ++X)
        {
            if (*FontChar & PixelMask)
                *Pixel = (UCHAR)TextColor;
            else if (BackColor < BV_COLOR_NONE)
                *Pixel = (UCHAR)BackColor;
 
            Pixel++;
            PixelMask >>= 1;
        }
 
        FontChar += FONT_PTR_DELTA;
        StartOffset += SCREEN_WIDTH;
    }
}

DoScroll()

VOID DoScroll

(

_In_ ULONG

Scroll

)

Definition at line 339 of file bootvid.c.

{
    const ULONG PixelCount = (VidpScrollRegion.Right - VidpScrollRegion.Left) + 1;
    ULONG Line;
    ULONG_PTR SourceOffset = FrameBuffer + FB_OFFSET(VidpScrollRegion.Left, VidpScrollRegion.Top + Scroll);
    ULONG_PTR DestinationOffset = FrameBuffer + FB_OFFSET(VidpScrollRegion.Left, VidpScrollRegion.Top);
 
    if (PixelCount == 0)
        return;
 
    for (Line = VidpScrollRegion.Top; Line <= VidpScrollRegion.Bottom; Line++)
    {
        ULONG_PTR Src = SourceOffset;
        ULONG_PTR Dst = DestinationOffset;
        ULONG Width = PixelCount;
 
        while (Width > 0)
        {
            /* Note that Src and Dst have the same alignment */
            if (((Src & 3) == 0) && (Width >= sizeof(ULONG)))
            {
                /* Copy 4 pixels at once. We assume that the row width
                 * is small enough to not use the __movsd approach. */
                while (Width >= sizeof(ULONG))
                {
                    /* Volatile to prevent the optimizer from replacing the loop by memcpy */
                    *(volatile ULONG*)Dst = *(volatile ULONG*)Src;
 
                    Dst += sizeof(ULONG);
                    Src += sizeof(ULONG);
                    Width -= sizeof(ULONG);
                }
            }
            else
            {
                *(PUCHAR)Dst = *(PUCHAR)Src;
 
                Dst++;
                Src++;
                Width--;
            }
        }
 
        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().

InitializePalette()

static VOID InitializePalette ( VOID  )

static

Definition at line 270 of file bootvid.c.

{
    ULONG i;
 
    InitPaletteWithTable(VidpDefaultPalette, BV_MAX_COLORS);
 
    /* Reset the unused palette entries */
    for (i = BV_MAX_COLORS; i < PEGC_MAX_COLORS; i++)
        SetPaletteEntryRGB(i, VidpDefaultPalette[BV_COLOR_BLACK]);
}

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++);
}

PreserveRow()

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

Definition at line 315 of file bootvid.c.

{
    PULONG OldPosition, NewPosition;
 
    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));
    }
 
    __movsd(NewPosition, OldPosition, Height * (SCREEN_WIDTH / sizeof(ULONG)));
}

ResetDisplay()

VOID ResetDisplay

(

_In_ BOOLEAN

SetMode

)

Definition at line 430 of file bootvid.c.

{
    /* 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();
    __stosd((PULONG)(FrameBuffer + FB_OFFSET(0, 0)), 0,
            (SCREEN_WIDTH * SCREEN_HEIGHT) / sizeof(ULONG));
 
    WRITE_PORT_UCHAR((PUCHAR)GDC1_IO_o_MODE_FLIPFLOP1, GRAPH_MODE_DISPLAY_ENABLE);
}

SaveRowToBuffer()

static VOID SaveRowToBuffer ( _Out_ UCHAR *__restrict  Buffer, _In_ const ULONG *__restrict  Pixels, _In_ ULONG  Width, _In_ ULONG  Shift  )

static

Definition at line 451 of file bootvid.c.

{
    ULONG Px, Value = 0;
 
    if (Shift != 0)
    {
        Px = *Pixels++;
        Value = Px;
    }
 
    /* Read 4 pixels at once */
    while (Width >= sizeof(USHORT))
    {
        Value >>= Shift;
 
        if (Shift == 0 || Shift == 24)
        {
            Px = *Pixels++;
 
            if (Shift == 24)
                Value |= Px << 8;
            else
                Value = Px;
        }
        *Buffer++ = ((Value & 0x000F) << 4) | ((Value & 0x0F00) >> 8);
        Value = Px;
 
        Shift = (Shift + 16) & (32 - 1);
 
        Width -= sizeof(USHORT);
    }
 
    if (Width != 0)
    {
        if (Shift == 0)
            Value = *Pixels;
        Value >>= Shift;
        *Buffer = Value << 4;
    }
}

Referenced by VidScreenToBufferBlt().

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 InitializePalette(), and 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 424 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 392 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_(Height *Stride) PUCHAR	Buffer,
		_In_ ULONG	Left,
		_In_ ULONG	Top,
		_In_ ULONG	Width,
		_In_ ULONG	Height,
		_In_ ULONG	Stride
	)

Definition at line 498 of file bootvid.c.

{
    ULONG_PTR StartOffset;
    ULONG Offset, StartShift;
    ULONG Y;
 
    if ((Width == 0) || (Height == 0))
        return;
 
    /* Clear the destination buffer */
    RtlZeroMemory(Buffer, Height * Stride);
 
    Offset = FB_OFFSET(Left, Top);
    StartOffset = FrameBuffer + (Offset & ~3);
    StartShift = (Offset & 3) * 8;
 
    for (Y = 0; Y < Height; Y++)
    {
        SaveRowToBuffer(Buffer, (PULONG)StartOffset, Width, StartShift);
 
        Buffer += Stride;
        StartOffset += SCREEN_WIDTH;
    }
}

VidSolidColorFill()

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

Definition at line 531 of file bootvid.c.

{
    /* Equivalent to: (Color << 24) | (Color << 16) | (Color << 8) | Color */
    const ULONG WideColor = Color * 0x01010101ul;
    const ULONG PixelCount = (Right - Left) + 1;
    ULONG Line;
    ULONG_PTR StartOffset = FrameBuffer + FB_OFFSET(Left, Top);
 
    if ((Left > Right) || (PixelCount == 0))
        return;
 
    for (Line = Top; Line <= Bottom; Line++)
    {
        ULONG_PTR Px = StartOffset;
        ULONG Width = PixelCount;
 
        while (Width > 0)
        {
            if (((Px & 3) == 0) && (Width >= sizeof(ULONG)))
            {
                /* Modify 4 pixels at once. We assume that the row width
                 * is small enough to not use the __stosd approach. */
                while (Width >= sizeof(ULONG))
                {
                    /* Volatile to prevent the optimizer from replacing the loop by memset */
                    *(volatile ULONG*)Px = WideColor;
 
                    Px += sizeof(ULONG);
                    Width -= sizeof(ULONG);
                }
            }
            else
            {
                *(PUCHAR)Px = (UCHAR)WideColor;
 
                Px++;
                Width--;
            }
        }
 
        StartOffset += SCREEN_WIDTH;
    }
}

Variable Documentation

FrameBuffer

ULONG_PTR FrameBuffer = 0

Definition at line 20 of file bootvid.c.

Referenced by DetectDisplayController(), DisplayCharacter(), DoScroll(), 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().