bootvid.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Boot Video Driver for NEC PC-98 series
 * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
 * PURPOSE:     Main file
 * COPYRIGHT:   Copyright 2020-2026 Dmitry Borisov <di.sean@protonmail.com>
 */
 
/* INCLUDES *******************************************************************/
 
#include "precomp.h"
#include <drivers/pc98/video.h>
 
/* GLOBALS ********************************************************************/
 
#define BYTES_PER_SCANLINE (SCREEN_WIDTH / 8)
 
#define PEGC_MAX_COLORS    256
 
static ULONG_PTR PegcControl = 0;
ULONG_PTR FrameBuffer = 0;
 
/* PRIVATE FUNCTIONS **********************************************************/
 
static BOOLEAN
GraphGetStatus(
    _In_ UCHAR Status)
{
    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);
}
 
static BOOLEAN
TestMmio(VOID)
{
    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);
}
 
static BOOLEAN
HasPegcController(VOID)
{
    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;
}
 
static VOID
TextSync(VOID)
{
    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;
}
 
static VOID
InitializeDisplay(VOID)
{
    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);
}
 
static VOID
SetPaletteEntryRGB(
    _In_ ULONG Id,
    _In_ RGBQUAD Rgb)
{
    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));
}
 
VOID
InitPaletteWithTable(
    _In_reads_(Count) const ULONG* Table,
    _In_ ULONG Count)
{
    const ULONG* Entry = Table;
    ULONG i;
 
    for (i = 0; i < Count; i++)
        SetPaletteEntryRGB(i, *Entry++);
}
 
#undef InitializePalette
static VOID
InitializePalette(VOID)
{
    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]);
}
 
VOID
DisplayCharacter(
    _In_ CHAR Character,
    _In_ ULONG Left,
    _In_ ULONG Top,
    _In_ ULONG TextColor,
    _In_ ULONG BackColor)
{
    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;
    }
}
 
VOID
PreserveRow(
    _In_ ULONG CurrentTop,
    _In_ ULONG Height,
    _In_ BOOLEAN Restore)
{
    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)));
}
 
VOID
DoScroll(
    _In_ ULONG Scroll)
{
    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;
    }
}
 
/* PUBLIC FUNCTIONS ***********************************************************/
 
BOOLEAN
NTAPI
VidInitialize(
    _In_ BOOLEAN SetMode)
{
    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;
}
 
VOID
NTAPI
VidCleanUp(VOID)
{
    WRITE_PORT_UCHAR((PUCHAR)GDC1_IO_o_MODE_FLIPFLOP1, GRAPH_MODE_DISPLAY_DISABLE);
}
 
VOID
ResetDisplay(
    _In_ BOOLEAN SetMode)
{
    /* 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);
}
 
static VOID
SaveRowToBuffer(
    _Out_ UCHAR* __restrict Buffer,
    _In_ const ULONG* __restrict Pixels,
    _In_ ULONG Width,
    _In_ ULONG Shift)
{
    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;
    }
}
 
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)
{
    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;
    }
}
 
VOID
NTAPI
VidSolidColorFill(
    _In_ ULONG Left,
    _In_ ULONG Top,
    _In_ ULONG Right,
    _In_ ULONG Bottom,
    _In_ UCHAR Color)
{
    /* 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;
    }
}