AMI-Aptio-BIOS-Reversed/AmiModulePkg/CSM/CsmVideo/CsmVideo.h at c580532ff80c2ad7e798f901916a374cca49b1a6

Fork: 0
ajax / AMI-Aptio-BIOS-Reversed
Find file
Newer
Older
AMI-Aptio-BIOS-Reversed / AmiModulePkg / CSM / CsmVideo / CsmVideo.h
Ajax Dong 2 days ago 25 KB Full restructure
Raw Blame History
/** @file
  CsmVideo.h -- Header for CsmVideo

Copyright (c) HR650X BIOS Decompilation Project
**/

#ifndef __CSMVIDEO_H__
#define __CSMVIDEO_H__

#include "../uefi_headers/Uefi.h"

//
// Function Prototypes
//

EFI_STATUS
EFIAPI
_ModuleEntryPoint(
  VOID
);

EFI_STATUS
EFIAPI
CsmVideoDriverEntry(
  VOID
);

EFI_STATUS
EFIAPI
CsmVideoChildInit(
  VOID
);

EFI_STATUS
EFIAPI
CsmVideoModeSet(
  VOID
);

EFI_STATUS
EFIAPI
CsmVideoInstanceCreate(
  VOID
);

EFI_STATUS
EFIAPI
CsmVideoDetectDevice(
  VOID
);

EFI_STATUS
EFIAPI
CsmVideoChildAddProtocol(
  VOID
);

EFI_STATUS
EFIAPI
CsmVideoFreeBuffers(
  VOID
);

EFI_STATUS
EFIAPI
EdidParseAndMerge(
  VOID
);

EFI_STATUS
EFIAPI
VesaGetControllerCapabilities(
  VOID
);

EFI_STATUS
EFIAPI
VesaEnumerateModes(
  VOID
);

EFI_STATUS
EFIAPI
GraphicsOutputQueryMode(
  VOID
);

EFI_STATUS
EFIAPI
AllocateVideoBuffers(
  VOID
);

EFI_STATUS
EFIAPI
GraphicsOutputSetMode(
  VOID
);

EFI_STATUS
EFIAPI
GraphicsOutputSetModeWrapper(
  VOID
);

EFI_STATUS
EFIAPI
VgaTextSetCursorPosition(
  VOID
);

EFI_STATUS
EFIAPI
EdidOverrideUninstall(
  VOID
);

EFI_STATUS
EFIAPI
VgaClassConstructor(
  VOID
);

EFI_STATUS
EFIAPI
VgaClassDestructor(
  VOID
);

EFI_STATUS
EFIAPI
VgaTextInit(
  VOID
);

EFI_STATUS
EFIAPI
VgaTextStringOutput(
  VOID
);

EFI_STATUS
EFIAPI
VgaTextTestStringValid(
  VOID
);

EFI_STATUS
EFIAPI
VgaTextClearScreen(
  VOID
);

EFI_STATUS
EFIAPI
VgaTextEnableCursor(
  VOID
);

EFI_STATUS
EFIAPI
VgaTextQueryModeInfo(
  VOID
);

EFI_STATUS
EFIAPI
VgaTextSetMode(
  VOID
);

EFI_STATUS
EFIAPI
VgaCursorSetPosition(
  VOID
);

EFI_STATUS
EFIAPI
VgaWriteCrtRegister(
  VOID
);

EFI_STATUS
EFIAPI
VgaOemCharTranslate(
  VOID
);

EFI_STATUS
EFIAPI
IsVgaEnableCheck(
  VOID
);

EFI_STATUS
EFIAPI
LegacyBiosPlatformSetVideoController(
  VOID
);

EFI_STATUS
EFIAPI
IsPciRootBridgeVgaCompatible(
  VOID
);

EFI_STATUS
EFIAPI
CmosReadVideoType(
  VOID
);

EFI_STATUS
EFIAPI
declarations from CsmVideo.h / library code(
  VOID
);

EFI_STATUS
EFIAPI
*gBS;(
  VOID
);

EFI_STATUS
EFIAPI
@ 0x390(
  VOID
);

EFI_STATUS
EFIAPI
@ 0x44C(
  VOID
);

EFI_STATUS
EFIAPI
protocols on ImageHandle:(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->InstallMultipleProtocolInterfaces ((
  VOID
);

EFI_STATUS
EFIAPI
EDID_ACTIVE protocol on a child handle(
  VOID
);

EFI_STATUS
EFIAPI
= NULL;(
  VOID
);

EFI_STATUS
EFIAPI
the LegacyBiosPlatform protocol(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->ConnectController ((
  VOID
);

EFI_STATUS
EFIAPI
-- CsmVideoChildInit: initialize a VGA/display child(
  VOID
);

EFI_STATUS
EFIAPI
PCI Root Bridge IO protocol on the child(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->HandleProtocol ((
  VOID
);

EFI_STATUS
EFIAPI
Legacy BIOS Platform protocol(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->LocateProtocol ((
  VOID
);

EFI_STATUS
EFIAPI
PCI IO protocol with VGA attribute(
  VOID
);

EFI_STATUS
EFIAPI
= *(UINT64 *)((UINT8 *)Instance + 40);  // Instance->Attributes(
  VOID
);

EFI_STATUS
EFIAPI
current mode / attributes(
  VOID
);

EFI_STATUS
EFIAPI
= PciIo->GetAttributes (PciIo, NULL, &Supported, NULL, NULL);(
  VOID
);

EFI_STATUS
EFIAPI
VGA decode, IO, and memory access(
  VOID
);

EFI_STATUS
EFIAPI
= PciIo->SetAttributes ((
  VOID
);

EFI_STATUS
EFIAPI
if this is a VGA-compatible device via LegacyBIOS platform(
  VOID
);

EFI_STATUS
EFIAPI
= LegacyBiosPlatform->GetVgaCompatible ((
  VOID
);

EFI_STATUS
EFIAPI
resources descriptor for VGA legacy IO range(
  VOID
);

EFI_STATUS
EFIAPI
(CsmVideo != NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
if already VGA enabled - skip if so(
  VOID
);

EFI_STATUS
EFIAPI
(IsVgaEnableCheck (ChildHandle)) {(
  VOID
);

EFI_STATUS
EFIAPI
the CsmVideo instance(
  VOID
);

EFI_STATUS
EFIAPI
= CsmVideoInstanceCreate ((
  VOID
);

EFI_STATUS
EFIAPI
-- CsmVideoModeSet: set display mode(
  VOID
);

EFI_STATUS
EFIAPI
no modes requested, try EDID_OVERRIDE first, then EDID_ACTIVE(
  VOID
);

EFI_STATUS
EFIAPI
(ModeCount == 0) {(
  VOID
);

EFI_STATUS
EFIAPI
to open EDID_OVERRIDE protocol(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->OpenProtocol ((
  VOID
);

EFI_STATUS
EFIAPI
open EDID_ACTIVE and configure display(
  VOID
);

EFI_STATUS
EFIAPI
VGA child info(
  VOID
);

EFI_STATUS
EFIAPI
each requested mode, try to add it(
  VOID
);

EFI_STATUS
EFIAPI
(Index = 0; Index < ModeCount; Index++) {(
  VOID
);

EFI_STATUS
EFIAPI
previous VGA mode if needed(
  VOID
);

EFI_STATUS
EFIAPI
(!IsVgaEnableCheck (ChildHandle) && IsVesaModeEnabled) {(
  VOID
);

EFI_STATUS
EFIAPI
the video device(
  VOID
);

EFI_STATUS
EFIAPI
= CsmVideoDetectDevice (Instance, ModeArray[0], &CsmVideo);(
  VOID
);

EFI_STATUS
EFIAPI
each requested mode(
  VOID
);

EFI_STATUS
EFIAPI
VGA mode if necessary(
  VOID
);

EFI_STATUS
EFIAPI
-- CsmVideoInstanceCreate: create and initialize video instance(
  VOID
);

EFI_STATUS
EFIAPI
264-byte instance(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->AllocatePool (EfiBootServicesData, sizeof (CSM_VIDEO_INSTANCE), (VOID **)&CsmVideo);(
  VOID
);

EFI_STATUS
EFIAPI
the VGA PCI config space for class code(
  VOID
);

EFI_STATUS
EFIAPI
= PciIo->Pci.Read ((
  VOID
);

EFI_STATUS
EFIAPI
device type: VGA compatible (class 3) or not(
  VOID
);

EFI_STATUS
EFIAPI
(!(Class[2] == 3 || (Class[2] == 0 && Class[1] == 3 && !Class[0]))) {(
  VOID
);

EFI_STATUS
EFIAPI
VGA-compatible; check for other video class(
  VOID
);

EFI_STATUS
EFIAPI
VGA, not a display controller(
  VOID
);

EFI_STATUS
EFIAPI
VGA compatible - check for VESA mode(
  VOID
);

EFI_STATUS
EFIAPI
already in VGA mode, but VGA compatible(
  VOID
);

EFI_STATUS
EFIAPI
instance fields(
  VOID
);

EFI_STATUS
EFIAPI
to legacy VGA(
  VOID
);

EFI_STATUS
EFIAPI
VESA-capable(
  VOID
);

EFI_STATUS
EFIAPI
no Legacy BIOS platform, go straight to legacy VGA(
  VOID
);

EFI_STATUS
EFIAPI
(!gLegacyBiosPlatformAvailable) {(
  VOID
);

EFI_STATUS
EFIAPI
end of device path for VGA IO range claim(
  VOID
);

EFI_STATUS
EFIAPI
(LegacyBiosHandle == NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
ACPI device path for VGA IO range(
  VOID
);

EFI_STATUS
EFIAPI
device path for the VGA rom(
  VOID
);

EFI_STATUS
EFIAPI
protocol interfaces for the VESA/child(
  VOID
);

EFI_STATUS
EFIAPI
VESA modes(
  VOID
);

EFI_STATUS
EFIAPI
= VesaEnumerateModes (CsmVideo);(
  VOID
);

EFI_STATUS
EFIAPI
succeeded(
  VOID
);

EFI_STATUS
EFIAPI
back to legacy VGA(
  VOID
);

/// install EDID protocol only
EFI_STATUS
EFIAPI
BIOS platform path(
  VOID
);

EFI_STATUS
EFIAPI
full set of protocols for VESA/child(
  VOID
);

EFI_STATUS
EFIAPI
GOP protocol(
  VOID
);

EFI_STATUS
EFIAPI
VGA mode: populate VGA text mode parameters(
  VOID
);

EFI_STATUS
EFIAPI
VGA CRTC parameters(
  VOID
);

EFI_STATUS
EFIAPI
index(
  VOID
);

EFI_STATUS
EFIAPI
data(
  VOID
);

EFI_STATUS
EFIAPI
CRTC index(
  VOID
);

EFI_STATUS
EFIAPI
CRTC data(
  VOID
);

EFI_STATUS
EFIAPI
Controller(
  VOID
);

EFI_STATUS
EFIAPI
CsmVideo->InputRanges = 0xFF;(
  VOID
);

EFI_STATUS
EFIAPI
-- CsmVideoDetectDevice: detect video controller and return instance(
  VOID
);

EFI_STATUS
EFIAPI
ptr to EdidActive field(
  VOID
);

EFI_STATUS
EFIAPI
from field offset back to instance start(
  VOID
);

EFI_STATUS
EFIAPI
is at offset 32 in CsmVideoInstance(
  VOID
);

EFI_STATUS
EFIAPI
back to EDID_OVERRIDE protocol(
  VOID
);

EFI_STATUS
EFIAPI
is at offset 0x60 (96) in the instance(
  VOID
);

EFI_STATUS
EFIAPI
-- CsmVideoChildAddProtocol: install protocols on video child(
  VOID
);

EFI_STATUS
EFIAPI
= CsmVideoDetectDevice (Instance, ParentHandle, &CsmVideo);(
  VOID
);

EFI_STATUS
EFIAPI
any existing EDID_ACTIVE protocol on the target handle(
  VOID
);

EFI_STATUS
EFIAPI
the full protocol set on this child (VESA mode)(
  VOID
);

EFI_STATUS
EFIAPI
EDID_OVERRIDE (legacy VGA mode)(
  VOID
);

EFI_STATUS
EFIAPI
install failed, re-open EDID_ACTIVE to restore state(
  VOID
);

EFI_STATUS
EFIAPI
cursor to 80x25 text mode(
  VOID
);

EFI_STATUS
EFIAPI
color text mode(
  VOID
);

EFI_STATUS
EFIAPI
INT10 AH=00h: set video mode 3 (80x25 color text)(
  VOID
);

EFI_STATUS
EFIAPI
INT10 AH=01h: set cursor shape (no cursor)(
  VOID
);

EFI_STATUS
EFIAPI
01h, CH=11h, CL=14h(
  VOID
);

EFI_STATUS
EFIAPI
VESA controller(
  VOID
);

EFI_STATUS
EFIAPI
(CsmVideo);(
  VOID
);

EFI_STATUS
EFIAPI
the global child handle(
  VOID
);

EFI_STATUS
EFIAPI
-- CsmVideoFreeBuffers: free all resources(
  VOID
);

EFI_STATUS
EFIAPI
frame buffer 3(
  VOID
);

EFI_STATUS
EFIAPI
frame buffer 2(
  VOID
);

EFI_STATUS
EFIAPI
frame buffer(
  VOID
);

EFI_STATUS
EFIAPI
scan line buffer(
  VOID
);

EFI_STATUS
EFIAPI
text buffer + its memory descriptor(
  VOID
);

EFI_STATUS
EFIAPI
EDID override buffer(
  VOID
);

EFI_STATUS
EFIAPI
the instance itself(
  VOID
);

EFI_STATUS
EFIAPI
-- EdidParseAndMerge: parse EDID block, extract timings(
  VOID
);

EFI_STATUS
EFIAPI
EDID checksum(
  VOID
);

EFI_STATUS
EFIAPI
established timings from EDID byte 0x23(
  VOID
);

EFI_STATUS
EFIAPI
= Edid->EstablishedTimings[0] |(
  VOID
);

EFI_STATUS
EFIAPI
known established timing resolutions(
  VOID
);

EFI_STATUS
EFIAPI
timings from EDID spec(
  VOID
);

EFI_STATUS
EFIAPI
@ 70Hz(
  VOID
);

EFI_STATUS
EFIAPI
each flag bit(
  VOID
);

EFI_STATUS
EFIAPI
(TimingIndex = 0; TimingIndex < 17; TimingIndex++) {(
  VOID
);

EFI_STATUS
EFIAPI
detailed timing descriptors (EDID bytes 0x36-0x6F, 18 bytes each)(
  VOID
);

EFI_STATUS
EFIAPI
(DetailedTimingIndex = 0; DetailedTimingIndex < 4; DetailedTimingIndex++) {(
  VOID
);

EFI_STATUS
EFIAPI
if this is a timing descriptor (byte 0 = tag, byte 1 != 1 = pixel clock)(
  VOID
);

EFI_STATUS
EFIAPI
(TimingDescriptor[0] != 0x01 && TimingDescriptor[1] != 0x01) {(
  VOID
);

EFI_STATUS
EFIAPI
Horizontal pixels from bytes 0x02-0x04 (packed)(
  VOID
);

EFI_STATUS
EFIAPI
= (UINT16)(TimingDescriptor[2] + ((TimingDescriptor[4] & 0xF0) << 4));(
  VOID
);

EFI_STATUS
EFIAPI
ratio / Vertical lines extraction(
  VOID
);

EFI_STATUS
EFIAPI
= TimingDescriptor[3] >> 6;(
  VOID
);

EFI_STATUS
EFIAPI
16:10(
  VOID
);

EFI_STATUS
EFIAPI
4:3(
  VOID
);

EFI_STATUS
EFIAPI
5:4(
  VOID
);

EFI_STATUS
EFIAPI
16:9(
  VOID
);

EFI_STATUS
EFIAPI
-- VesaGetControllerCapabilities: query VESA VBE BIOS(
  VOID
);

EFI_STATUS
EFIAPI
bytes(
  VOID
);

EFI_STATUS
EFIAPI
VBE controller capabilities call(
  VOID
);

EFI_STATUS
EFIAPI
VbeControllerInfo[1] = 0x10;                     // Function = Get Capabilities(
  VOID
);

EFI_STATUS
EFIAPI
of graphics ports(
  VOID
);

EFI_STATUS
EFIAPI
to 1(
  VOID
);

EFI_STATUS
EFIAPI
each graphics port to find a connected display(
  VOID
);

EFI_STATUS
EFIAPI
(PortIndex = 0; PortIndex < GraphicsPortCount; PortIndex++) {(
  VOID
);

EFI_STATUS
EFIAPI
= Get Port(
  VOID
);

EFI_STATUS
EFIAPI
a connected port(
  VOID
);

EFI_STATUS
EFIAPI
-- VesaEnumerateModes: enumerate all VESA VBE modes(
  VOID
);

EFI_STATUS
EFIAPI
byte VBE mode info block(
  VOID
);

EFI_STATUS
EFIAPI
byte VBE controller info(
  VOID
);

EFI_STATUS
EFIAPI
VBE controller info(
  VOID
);

EFI_STATUS
EFIAPI
= VesaGetControllerCapabilities (CsmVideo);(
  VOID
);

EFI_STATUS
EFIAPI
EDID override data if present(
  VOID
);

EFI_STATUS
EFIAPI
= 0;(
  VOID
);

EFI_STATUS
EFIAPI
space for mode list (up to ~256 VBE modes)(
  VOID
);

EFI_STATUS
EFIAPI
= AllocateZeroPool (256 * sizeof (UINT16));(
  VOID
);

EFI_STATUS
EFIAPI
through VESA/VBE modes(
  VOID
);

EFI_STATUS
EFIAPI
(Index = 0; ; Index++) {(
  VOID
);

EFI_STATUS
EFIAPI
VBE mode info for this mode number(
  VOID
);

EFI_STATUS
EFIAPI
function 0x4F01: Get Mode Info(
  VOID
);

EFI_STATUS
EFIAPI
function(
  VOID
);

EFI_STATUS
EFIAPI
number(
  VOID
);

EFI_STATUS
EFIAPI
more modes or error(
  VOID
);

EFI_STATUS
EFIAPI
mode number(
  VOID
);

EFI_STATUS
EFIAPI
(VbeModeNumber < 0x100) {(
  VOID
);

EFI_STATUS
EFIAPI
mode attributes bit 7 (linear FB supported) and bit 0 (mode supported)(
  VOID
);

EFI_STATUS
EFIAPI
(!(VbeModeInfo[0] & 0x80) || !(VbeModeInfo[0] & 0x01)) {(
  VOID
);

EFI_STATUS
EFIAPI
mode type (must be invalid type to be graphical)(
  VOID
);

EFI_STATUS
EFIAPI
((VbeModeInfo & 0x08) == 0) {(
  VOID
);

EFI_STATUS
EFIAPI
for linear frame buffer(
  VOID
);

EFI_STATUS
EFIAPI
(!(VbeModeInfo[0] & VESA_MODE_LINEAR_FB_BIT)) {(
  VOID
);

EFI_STATUS
EFIAPI
bits per pixel: must be 24-32, and modulo 8 == 0(
  VOID
);

EFI_STATUS
EFIAPI
PhysBasePtr is non-zero(
  VOID
);

EFI_STATUS
EFIAPI
resolution against EDID table(
  VOID
);

EFI_STATUS
EFIAPI
= *(UINT32 *)&VbeModeInfo[0x12];  // XResolution(
  VOID
);

EFI_STATUS
EFIAPI
EdidMatchFound  = FALSE;(
  VOID
);

EFI_STATUS
EFIAPI
for duplicate(
  VOID
);

EFI_STATUS
EFIAPI
(Index = 0; Index < UsableModes; Index++) {(
  VOID
);

/// add to our mode table
EFI_STATUS
EFIAPI
is usable(
  VOID
);

EFI_STATUS
EFIAPI
mode count(
  VOID
);

EFI_STATUS
EFIAPI
video buffers for this instance(
  VOID
);

EFI_STATUS
EFIAPI
= AllocateVideoBuffers (CsmVideo);(
  VOID
);

EFI_STATUS
EFIAPI
-- GraphicsOutputQueryMode: GOP QueryMode(
  VOID
);

EFI_STATUS
EFIAPI
instance from CR (This is at offset 32 from instance)(
  VOID
);

EFI_STATUS
EFIAPI
= (CSM_VIDEO_INSTANCE *)((UINT8 *)This - 32);(
  VOID
);

EFI_STATUS
EFIAPI
if initialized(
  VOID
);

EFI_STATUS
EFIAPI
(CsmVideo->bEdidOverrideActive) {(
  VOID
);

EFI_STATUS
EFIAPI
parameters(
  VOID
);

EFI_STATUS
EFIAPI
(ModeNumber >= CsmVideo->MaxMode || SizeOfInfo == NULL || Info == NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
output buffer (36 bytes as observed)(
  VOID
);

EFI_STATUS
EFIAPI
mode info from VESA mode table (72 bytes per entry)(
  VOID
);

EFI_STATUS
EFIAPI
= &CsmVideo->VesaModeInfo[ModeNumber];(
  VOID
);

EFI_STATUS
EFIAPI
pixel information(
  VOID
);

EFI_STATUS
EFIAPI
= 8 * BytesPerScanLine / BitsPerPixel(
  VOID
);

EFI_STATUS
EFIAPI
-- AllocateVideoBuffers: allocate scan line, text, and frame buffers(
  VOID
);

EFI_STATUS
EFIAPI
worst-case dimensions from all modes(
  VOID
);

EFI_STATUS
EFIAPI
all modes to find the largest(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->AllocatePool ((
  VOID
);

/// VGA text mode save area)
EFI_STATUS
EFIAPI
text buffer (153600 bytes = 80*25*2*24(
  VOID
);

EFI_STATUS
EFIAPI
-- GraphicsOutputSetMode: GOP SetMode(
  VOID
);

EFI_STATUS
EFIAPI
bytes buffer for INT10(
  VOID
);

EFI_STATUS
EFIAPI
instance via CR (This at offset 32)(
  VOID
);

EFI_STATUS
EFIAPI
(ModeNumber >= CsmVideo->MaxMode) {(
  VOID
);

EFI_STATUS
EFIAPI
VBE call buffer(
  VOID
);

EFI_STATUS
EFIAPI
mode number < 0x100, use standard VGA mode set(
  VOID
);

EFI_STATUS
EFIAPI
(ModeInfo->VbeModeNumber < 0x100) {(
  VOID
);

EFI_STATUS
EFIAPI
mode set via INT10 AH=00h, AL=mode(
  VOID
);

EFI_STATUS
EFIAPI
Set Mode(
  VOID
);

EFI_STATUS
EFIAPI
current mode info(
  VOID
);

EFI_STATUS
EFIAPI
frame buffer size(
  VOID
);

EFI_STATUS
EFIAPI
the frame buffer (fill with zeros)(
  VOID
);

EFI_STATUS
EFIAPI
current frame buffer from VESA linear FB to our shadow buffer(
  VOID
);

EFI_STATUS
EFIAPI
-- GraphicsOutputSetModeWrapper: 10-param wrapper for GOP SetMode(
  VOID
);

EFI_STATUS
EFIAPI
current EDID override info from instance(
  VOID
);

EFI_STATUS
EFIAPI
= CR_FROM_EDID_ACTIVE (CsmVideo);(
  VOID
);

EFI_STATUS
EFIAPI
currently in EDID override mode, handle state transition(
  VOID
);

EFI_STATUS
EFIAPI
(EdidOverrideActive) {(
  VOID
);

EFI_STATUS
EFIAPI
EDID_ACTIVE protocol (open from child controller)(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->CloseProtocol ((
  VOID
);

EFI_STATUS
EFIAPI
the VGA mode(
  VOID
);

EFI_STATUS
EFIAPI
= GraphicsOutputSetMode (&CsmVideo->GraphicsOutput, ModeNumber);(
  VOID
);

EFI_STATUS
EFIAPI
EDID_ACTIVE with BY_CHILD_CONTROLLER after mode set(
  VOID
);

EFI_STATUS
EFIAPI
-- VgaTextSetCursorPosition: set cursor via INT10 AH=02h(
  VOID
);

EFI_STATUS
EFIAPI
cursor mode(
  VOID
);

EFI_STATUS
EFIAPI
(CursorMode > Instance->ModeTableSize) {(
  VOID
);

EFI_STATUS
EFIAPI
INT10 call(
  VOID
);

EFI_STATUS
EFIAPI
= 0 (row=0, col=0)(
  VOID
);

EFI_STATUS
EFIAPI
cursor to end of screen for mode 1(
  VOID
);

EFI_STATUS
EFIAPI
INT10 to set cursor position(
  VOID
);

EFI_STATUS
EFIAPI
-- EdidOverrideUninstall: remove EDID override protocols(
  VOID
);

EFI_STATUS
EFIAPI
EDID_OVERRIDE protocol on child(
  VOID
);

EFI_STATUS
EFIAPI
and uninstall EDID_ACTIVE protocol(
  VOID
);

EFI_STATUS
EFIAPI
-- VgaClassConstructor: create VGA text class(
  VOID
);

EFI_STATUS
EFIAPI
PCI Root Bridge IO protocol(
  VOID
);

EFI_STATUS
EFIAPI
PCI IO protocol(
  VOID
);

EFI_STATUS
EFIAPI
EDID_OVERRIDE protocol(
  VOID
);

EFI_STATUS
EFIAPI
VGA Class Instance (144 bytes)(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->AllocatePool (EfiBootServicesData, sizeof (VGA_CLASS_INSTANCE), (VOID **)&VgaClass);(
  VOID
);

EFI_STATUS
EFIAPI
signature(
  VOID
);

EFI_STATUS
EFIAPI
vtable(
  VOID
);

EFI_STATUS
EFIAPI
the VGA class instance:(
  VOID
);

EFI_STATUS
EFIAPI
-> set mode (15) -> set cursor -> enable cursor(
  VOID
);

EFI_STATUS
EFIAPI
= VgaClass->SetMode (&VgaClass->ModeTableSize, 15);(
  VOID
);

EFI_STATUS
EFIAPI
Legacy BIOS protocol on the child(
  VOID
);

EFI_STATUS
EFIAPI
-- VgaClassDestructor: destroy VGA class instance(
  VOID
);

EFI_STATUS
EFIAPI
Legacy BIOS protocol(
  VOID
);

EFI_STATUS
EFIAPI
from LegacyBios protocol interface back to instance(
  VOID
);

EFI_STATUS
EFIAPI
= (VGA_CLASS_INSTANCE *)((UINT8 *)VgaClass - 16);(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->ReinstallProtocolInterface ((
  VOID
);

EFI_STATUS
EFIAPI
EDID_ACTIVE protocol(
  VOID
);

EFI_STATUS
EFIAPI
the instance(
  VOID
);

EFI_STATUS
EFIAPI
-- VgaTextInit: initialize VGA text mode(
  VOID
);

EFI_STATUS
EFIAPI
palette registers (INT10 AH=0Bh/BH=01h)(
  VOID
);

EFI_STATUS
EFIAPI
cursor type (start, end)(
  VOID
);

EFI_STATUS
EFIAPI
This->SetCursor (This, 0);(
  VOID
);

EFI_STATUS
EFIAPI
-- VgaTextStringOutput: output string to VGA text screen(
  VOID
);

EFI_STATUS
EFIAPI
This signature(
  VOID
);

EFI_STATUS
EFIAPI
(This->Signature != VGA_CLASS_INSTANCE_SIGNATURE) {(
  VOID
);

EFI_STATUS
EFIAPI
current mode dimensions(
  VOID
);

EFI_STATUS
EFIAPI
= This->QueryMode (This, &ScreenWidth, &ScreenHeight);(
  VOID
);

EFI_STATUS
EFIAPI
text cursor position from attribute fields(
  VOID
);

EFI_STATUS
EFIAPI
= This->CursorX;(
  VOID
);

EFI_STATUS
EFIAPI
current attribute(
  VOID
);

EFI_STATUS
EFIAPI
= This->Attribute;(
  VOID
);

EFI_STATUS
EFIAPI
frame buffer stride (bytes per scan line)(
  VOID
);

EFI_STATUS
EFIAPI
= This->FrameBufferStride;(
  VOID
);

EFI_STATUS
EFIAPI
each character in the string(
  VOID
);

EFI_STATUS
EFIAPI
(; *String != 0; String++) {(
  VOID
);

EFI_STATUS
EFIAPI
if (CursorX > 0) {(
  VOID
);

EFI_STATUS
EFIAPI
feed(
  VOID
);

EFI_STATUS
EFIAPI
the screen up by one line(
  VOID
);

EFI_STATUS
EFIAPI
(CursorY == (ScreenHeight - 1)) {(
  VOID
);

EFI_STATUS
EFIAPI
CursorData[0] = ((Attribute << 8) | 0x20);(
  VOID
);

EFI_STATUS
EFIAPI
return(
  VOID
);

EFI_STATUS
EFIAPI
OEM characters to VGA glyphs(
  VOID
);

EFI_STATUS
EFIAPI
(VgaOemCharTranslate (CurrentChar, &GlyphData)) {(
  VOID
);

EFI_STATUS
EFIAPI
character to frame buffer at current cursor position(
  VOID
);

EFI_STATUS
EFIAPI
= CursorY * Stride + CursorX * 2;(
  VOID
);

EFI_STATUS
EFIAPI
character + attribute to VGA text buffer (B8000 or shadow)(
  VOID
);

EFI_STATUS
EFIAPI
to next line(
  VOID
);

EFI_STATUS
EFIAPI
cursor position(
  VOID
);

EFI_STATUS
EFIAPI
-- VgaTextTestStringValid: validate Unicode string for VGA(
  VOID
);

EFI_STATUS
EFIAPI
printable range (0x20-0x7F)(
  VOID
);

EFI_STATUS
EFIAPI
((CurrentChar - 0x20) > 0x5F) {(
  VOID
);

EFI_STATUS
EFIAPI
for control characters (0x00-0x0D with supported set)(
  VOID
);

EFI_STATUS
EFIAPI
(CurrentChar > 0x0D ||(
  VOID
);

EFI_STATUS
EFIAPI
for OEM character range(
  VOID
);

EFI_STATUS
EFIAPI
(((CurrentChar & 0xFF00) - 0x2100) & 0xFBFF) {(
  VOID
);

EFI_STATUS
EFIAPI
up in OEM-to-VGA translation table(
  VOID
);

EFI_STATUS
EFIAPI
(!VgaOemCharTranslate (CurrentChar, NULL)) {(
  VOID
);

EFI_STATUS
EFIAPI
-- VgaTextClearScreen: fill VGA text screen with spaces(
  VOID
);

EFI_STATUS
EFIAPI
//(
  VOID
);

EFI_STATUS
EFIAPI
dimensions(
  VOID
);

EFI_STATUS
EFIAPI
the entire screen buffer(
  VOID
);

EFI_STATUS
EFIAPI
= ScreenWidth * 2;  // Two bytes per character (char + attr)(
  VOID
);

EFI_STATUS
EFIAPI
with current attribute(
  VOID
);

EFI_STATUS
EFIAPI
the VGA text region(
  VOID
);

EFI_STATUS
EFIAPI
(CursorY = 0; CursorY < ScreenHeight; CursorY++) {(
  VOID
);

EFI_STATUS
EFIAPI
cursor to home (0,0)(
  VOID
);

EFI_STATUS
EFIAPI
-- VgaTextSetCursorPosition: set text cursor with bounds check(
  VOID
);

EFI_STATUS
EFIAPI
= This->QueryMode (This, &MaxCol, &MaxRow);(
  VOID
);

EFI_STATUS
EFIAPI
check(
  VOID
);

EFI_STATUS
EFIAPI
(Column >= MaxCol || Row >= MaxRow) {(
  VOID
);

EFI_STATUS
EFIAPI
cursor position via CRT controller registers(
  VOID
);

EFI_STATUS
EFIAPI
(This, Column, Row, MaxCol);(
  VOID
);

EFI_STATUS
EFIAPI
internal state(
  VOID
);

EFI_STATUS
EFIAPI
-- VgaTextEnableCursor: enable/disable cursor(
  VOID
);

EFI_STATUS
EFIAPI
cursor via INT10: AH=01h, CH=cursor start, CL=cursor end(
  VOID
);

EFI_STATUS
EFIAPI
(Enable) {(
  VOID
);

EFI_STATUS
EFIAPI
cursor by moving it off screen(
  VOID
);

EFI_STATUS
EFIAPI
(This, CRTC_CURSOR_START, 0x20);(
  VOID
);

EFI_STATUS
EFIAPI
-- VgaTextQueryModeInfo: return cols/rows for VGA text mode(
  VOID
);

EFI_STATUS
EFIAPI
mode index(
  VOID
);

EFI_STATUS
EFIAPI
(ModeIndex >= This->ModeTableSize) {(
  VOID
);

EFI_STATUS
EFIAPI
0 = 80x25, Mode 1 = 80x50(
  VOID
);

EFI_STATUS
EFIAPI
(ModeIndex == 0) {(
  VOID
);

EFI_STATUS
EFIAPI
-- VgaTextSetMode: select VGA text mode(
  VOID
);

EFI_STATUS
EFIAPI
the current screen(
  VOID
);

EFI_STATUS
EFIAPI
current mode index(
  VOID
);

EFI_STATUS
EFIAPI
the frame buffer mode(
  VOID
);

EFI_STATUS
EFIAPI
This->FrameBufferModeSet (This->FrameBufferAccess, ModeIndex);(
  VOID
);

EFI_STATUS
EFIAPI
-- VgaCursorSetPosition: program cursor via CRT registers(
  VOID
);

EFI_STATUS
EFIAPI
linear cursor offset(
  VOID
);

EFI_STATUS
EFIAPI
= X + ScreenWidth * Y;(
  VOID
);

EFI_STATUS
EFIAPI
cursor location high byte to CRTC register 0x0E(
  VOID
);

EFI_STATUS
EFIAPI
(This, CRTC_CURSOR_LOC_HIGH, (CursorOffset >> 8));(
  VOID
);

EFI_STATUS
EFIAPI
cursor location low byte to CRTC register 0x0F(
  VOID
);

EFI_STATUS
EFIAPI
(This, CRTC_CURSOR_LOC_LOW, (CursorOffset & 0xFF));(
  VOID
);

EFI_STATUS
EFIAPI
-- VgaWriteCrtRegister: write CRTC register(
  VOID
);

EFI_STATUS
EFIAPI
(CRTC_INDEX_PORT, RegisterIndex);(
  VOID
);

EFI_STATUS
EFIAPI
-- VgaOemCharTranslate: convert OEM/Unicode to VGA glyph(
  VOID
);

EFI_STATUS
EFIAPI
character range: Unicode code page 437 / OEM(
  VOID
);

EFI_STATUS
EFIAPI
(((UnicodeChar & 0xFF00) - 0x2100) & 0xFBFF) {(
  VOID
);

EFI_STATUS
EFIAPI
up the character in the translation table (a global static list)(
  VOID
);

EFI_STATUS
EFIAPI
table maps pairs of (Unicode, VGA_Index)(
  VOID
);

EFI_STATUS
EFIAPI
-- IsVgaEnableCheck: check if any child has VGA enable(
  VOID
);

EFI_STATUS
EFIAPI
protocol info for EDID_ACTIVE on this handle(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->OpenProtocolInformation ((
  VOID
);

EFI_STATUS
EFIAPI
each open protocol entry for BIT3 (VGA enable flag)(
  VOID
);

EFI_STATUS
EFIAPI
(Index = 0; Index < OpenInfoCount; Index++) {(
  VOID
);

EFI_STATUS
EFIAPI
-- LegacyBiosPlatformSetVideoController: set/clear video owner(
  VOID
);

EFI_STATUS
EFIAPI
no platform handle or already in the desired state, skip(
  VOID
);

EFI_STATUS
EFIAPI
(BiosPlatformHandle == NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
if the current state matches the request (byte_5770 optimization)(
  VOID
);

EFI_STATUS
EFIAPI
(gIsLegacyVgaMode == SetAsActive && !Force) {(
  VOID
);

EFI_STATUS
EFIAPI
or clear VGA controller ownership on the legacy BIOS platform(
  VOID
);

EFI_STATUS
EFIAPI
(SetAsActive) {(
  VOID
);

EFI_STATUS
EFIAPI
-- IsPciRootBridgeVgaCompatible: check PCI class code(
  VOID
);

EFI_STATUS
EFIAPI
PCI IO protocol on the child handle(
  VOID
);

EFI_STATUS
EFIAPI
PCI class code(
  VOID
);

EFI_STATUS
EFIAPI
if VGA compatible (class 3, subclass 0, prog IF 0)(
  VOID
);

EFI_STATUS
EFIAPI
VGA-compatible (class 3, any subclass, prog IF 0)(
  VOID
);

EFI_STATUS
EFIAPI
(Class[2] == 3 && Class[1] == 0 && Class[0] == 0) {(
  VOID
);

EFI_STATUS
EFIAPI
VGA compatible(
  VOID
);

EFI_STATUS
EFIAPI
protocol(
  VOID
);

EFI_STATUS
EFIAPI
-- CopyMemInternal: low-level memcpy(
  VOID
);

EFI_STATUS
EFIAPI
overlapping case: if Source < Dest and overlap detected(
  VOID
);

EFI_STATUS
EFIAPI
backwards from end(
  VOID
);

EFI_STATUS
EFIAPI
(Source < Destination &&(
  VOID
);

EFI_STATUS
EFIAPI
backwards(
  VOID
);

EFI_STATUS
EFIAPI
CopyMemBackwards (Destination, Source, Length);(
  VOID
);

EFI_STATUS
EFIAPI
forwards with 8-byte chunks then remaining bytes(
  VOID
);

EFI_STATUS
EFIAPI
CopyMemForward (Destination, Source, Length);(
  VOID
);

EFI_STATUS
EFIAPI
-- CmosReadVideoType: get video type from CMOS(
  VOID
);

EFI_STATUS
EFIAPI
CMOS register 0x4B (video type)(
  VOID
);

EFI_STATUS
EFIAPI
= __inbyte (0x70) & 0x80;(
  VOID
);

EFI_STATUS
EFIAPI
or non-standard video(
  VOID
);

EFI_STATUS
EFIAPI
}(
  VOID
);

EFI_STATUS
EFIAPI
-- SetMem: memset with alignment optimization(
  VOID
);

EFI_STATUS
EFIAPI
64-bit word: 8 copies of Value(
  VOID
);

EFI_STATUS
EFIAPI
= Value;(
  VOID
);

EFI_STATUS
EFIAPI
to 4-byte boundary(
  VOID
);

EFI_STATUS
EFIAPI
(Length >= 4 && ((UINTN)Buf & 3)) {(
  VOID
);

EFI_STATUS
EFIAPI
aligned 32-bit words(
  VOID
);

EFI_STATUS
EFIAPI
(AlignedCount = Length >> 2; AlignedCount > 0; AlignedCount--) {(
  VOID
);

EFI_STATUS
EFIAPI
remaining bytes(
  VOID
);

EFI_STATUS
EFIAPI
(Length > 0) {(
  VOID
);

EFI_STATUS
EFIAPI
-- CopyMemOverlapped: memcpy with direction detection(
  VOID
);

EFI_STATUS
EFIAPI
direction: backward if src < dst && overlap(
  VOID
);

EFI_STATUS
EFIAPI
(Src < Dst && (Src + Length) > Dst) {(
  VOID
);

EFI_STATUS
EFIAPI
aligned copy: 8 bytes at a time when both aligned(
  VOID
);

EFI_STATUS
EFIAPI
(Length >= 8 && ((UINTN)Src & 7) == ((UINTN)Dst & 7)) {(
  VOID
);

EFI_STATUS
EFIAPI
leading misaligned bytes(
  VOID
);

EFI_STATUS
EFIAPI
Align = (UINTN)Src & 7;(
  VOID
);

EFI_STATUS
EFIAPI
alignment bytes(
  VOID
);

EFI_STATUS
EFIAPI
aligned 8-byte chunks(
  VOID
);

EFI_STATUS
EFIAPI
Count = Length >> 3;(
  VOID
);

EFI_STATUS
EFIAPI
with 8-byte alignment(
  VOID
);

EFI_STATUS
EFIAPI
remaining(
  VOID
);

#endif /* __CSMVIDEO_H__ */