#include "bl.h"
#include <bcd.h>

Include dependency graph for display.c:

Functions
BOOLEAN	DsppGraphicsDisabledByBcd (VOID)

NTSTATUS	DsppLoadFontFile (_In_ PWCHAR FontFileName)

NTSTATUS	BlpDisplayRegisterLocale (_In_ PWCHAR Locale)

NTSTATUS	DsppInitialize (_In_ ULONG Flags)

NTSTATUS	DsppReinitialize (_In_ ULONG Flags)

NTSTATUS	BlpDisplayReinitialize (VOID)

NTSTATUS	BlpDisplayInitialize (_In_ ULONG Flags)

VOID	BlDisplayGetTextCellResolution (_Out_ PULONG TextWidth, _Out_ PULONG TextHeight)

NTSTATUS	BlDisplaySetScreenResolution (VOID)

NTSTATUS	BlDisplayGetScreenResolution (_Out_ PULONG HRes, _Out_ PULONG VRes)

VOID	BlDisplayInvalidateOemBitmap (VOID)

PBITMAP	BlDisplayGetOemBitmap (_In_opt_ PCOORD Offsets, _Out_opt_ PULONG Flags)

BOOLEAN	BlDisplayValidOemBitmap (VOID)

NTSTATUS	BlDisplayClearScreen (VOID)

NTSTATUS	BlDisplaySetCursorType (_In_ ULONG Type)

Function Documentation

◆ BlDisplayClearScreen()

NTSTATUS BlDisplayClearScreen ( VOID )

Definition at line 943 of file display.c.

{
    NTSTATUS Status;
    PBL_TEXT_CONSOLE TextConsole;
 
    /* Nothing to do if there's no text console */
    Status = STATUS_SUCCESS;
    TextConsole = DspTextConsole;
    if (TextConsole)
    {
        /* Otherwise, clear the whole screen */
        Status = TextConsole->Callbacks->ClearText(TextConsole, FALSE);
        if (NT_SUCCESS(Status))
        {
            /* Invalidate the OEM bitmap at this point */
            BlDisplayInvalidateOemBitmap();
        }
    }
 
    /* All done */
    return Status;
};

Referenced by BmMain(), and OslDrawLogo().

◆ BlDisplayGetOemBitmap()

PBITMAP BlDisplayGetOemBitmap	(	_In_opt_ PCOORD	Offsets,
		_Out_opt_ PULONG	Flags
	)

Definition at line 743 of file display.c.

{
    NTSTATUS Status;
    ULONG Size;
    PHYSICAL_ADDRESS PhysicalAddress;
    PBGRT_TABLE BgrtTable;
    PBITMAP Bitmap;
    PBMP_HEADER Header;
 
    Bitmap = NULL;
    BgrtTable = NULL;
 
    /* Search for the BGRT */
    Status = BlUtlGetAcpiTable((PVOID*)&BgrtTable, BGRT_SIGNATURE);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Make sure this is really a BGRT */
    if (BgrtTable->Header.Signature != BGRT_SIGNATURE)
    {
        Status = STATUS_ACPI_INVALID_TABLE;
        goto Quickie;
    }
 
    /* Make sure the BGRT table length is valid */
    if (BgrtTable->Header.Length != sizeof(*BgrtTable))
    {
        Status = STATUS_ACPI_INVALID_TABLE;
        goto Quickie;
    }
 
    /* Make sure its a bitmap */
    if (BgrtTable->ImageType != BgrtImageTypeBitmap)
    {
        Status = STATUS_ACPI_INVALID_TABLE;
        goto Quickie;
    }
 
    /* Make sure it's somewhere in RAM */
    if (!BgrtTable->LogoAddress)
    {
        Status = STATUS_ACPI_INVALID_TABLE;
        goto Quickie;
    }
 
    /* Map the bitmap header only for now */
    PhysicalAddress.QuadPart = BgrtTable->LogoAddress;
    Status = BlMmMapPhysicalAddressEx((PVOID*)&Header,
                                      0,
                                      sizeof(BMP_HEADER),
                                      PhysicalAddress);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Capture the real size of the header */
    Size = Header->Size;
 
    /* Unmap the bitmap header */
    BlMmUnmapVirtualAddressEx(BgrtTable, sizeof(BMP_HEADER));
 
    /* If the real size is smaller than at least a V3 bitmap, bail out */
    if (Size < sizeof(BITMAP))
    {
        Status = STATUS_ACPI_INVALID_TABLE;
        goto Quickie;
    }
 
    /* Map the real size of the header */
    Status = BlMmMapPhysicalAddressEx((PVOID*)&Bitmap,
                                      0,
                                      Size,
                                      PhysicalAddress);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Make sure this is a non-compressed 24-bit or 32-bit V3 bitmap */
    if ((Bitmap->BmpHeader.Signature != 'MB') ||
        (Bitmap->DibHeader.Compression) ||
        ((Bitmap->DibHeader.BitCount != 24) &&
         (Bitmap->DibHeader.BitCount != 32)) ||
        (Bitmap->DibHeader.Size != sizeof(DIB_HEADER)))
    {
        Status = STATUS_ACPI_INVALID_TABLE;
        goto Quickie;
    }
 
    /* Check if caller wants the offsets back */
    if (Offsets)
    {
        /* Give them away */
        Offsets->X = BgrtTable->OffsetX;
        Offsets->Y = BgrtTable->OffsetY;
    }
 
    /* Check if the caller wants flags */
    if (Flags)
    {
        /* Return if the image is valid */
        *Flags = BgrtTable->Status & BGRT_STATUS_IMAGE_VALID;
    }
 
Quickie:
    /* Check if we had mapped the BGRT */
    if (BgrtTable)
    {
        /* Unmap it */
        BlMmUnmapVirtualAddressEx(BgrtTable, BgrtTable->Header.Length);
    }
 
    /* Check if this is the failure path */
    if (!NT_SUCCESS(Status))
    {
        /* Did we have the OEM bitmap mapped? */
        if (Bitmap)
        {
            /* Unmap it */
            BlMmUnmapVirtualAddressEx(Bitmap, Bitmap->BmpHeader.Size);
        }
 
        /* No bitmap to return */
        Bitmap = NULL;
    }
 
    /* Return the bitmap back, if any */
    return Bitmap;
}

Referenced by BlDisplayValidOemBitmap().

◆ BlDisplayGetScreenResolution()

NTSTATUS BlDisplayGetScreenResolution	(	_Out_ PULONG	HRes,
		_Out_ PULONG	VRes
	)

Definition at line 680 of file display.c.

{
    NTSTATUS Status;
    BL_DISPLAY_MODE Resolution;
    PBL_GRAPHICS_CONSOLE GraphicsConsole;
 
    /* Assume failure if no consoles are active */
    Status = STATUS_UNSUCCESSFUL;
 
    /* Do we have a text console? */
    if (DspTextConsole)
    {
        /* Do we have an active graphics console? */
        GraphicsConsole = DspGraphicalConsole;
        if ((GraphicsConsole) &&
            (((PBL_GRAPHICS_CONSOLE_VTABLE)GraphicsConsole->TextConsole.Callbacks)->IsEnabled(GraphicsConsole)))
        {
            /* Get the resolution */
            Status = ((PBL_GRAPHICS_CONSOLE_VTABLE)GraphicsConsole->TextConsole.Callbacks)->GetGraphicalResolution(GraphicsConsole, &Resolution);
            if (NT_SUCCESS(Status))
            {
                /* Return it back to the caller */
                *HRes = Resolution.HRes;
                *VRes = Resolution.VRes;
            }
        }
        else
        {
            /* Return defaults */
            *HRes = 640;
            *VRes = 200;
            Status = STATUS_SUCCESS;
        }
    }
 
    /* Return if we got a valid resolution back */
    return Status;
}

Referenced by BlDisplayValidOemBitmap(), and BlpResourceInitialize().

◆ BlDisplayGetTextCellResolution()

VOID BlDisplayGetTextCellResolution	(	_Out_ PULONG	TextWidth,
		_Out_ PULONG	TextHeight
	)

Definition at line 603 of file display.c.

{
    NTSTATUS Status;
    PBL_GRAPHICS_CONSOLE GraphicsConsole;
 
    /* If the caller doesn't want anything, bail out */
    if (!(TextWidth) || !(TextHeight))
    {
        return;
    }
 
    /* Do we have a text console? */
    Status = STATUS_UNSUCCESSFUL;
    if (DspTextConsole)
    {
        /* Do we have a graphics console? */
        GraphicsConsole = DspGraphicalConsole;
        if (GraphicsConsole)
        {
            /* Is it currently active? */
            if (((PBL_GRAPHICS_CONSOLE_VTABLE)GraphicsConsole->TextConsole.Callbacks)->IsEnabled(GraphicsConsole))
            {
                /* Yep -- query it */
                EfiPrintf(L"GFX active, not supported query\r\n");
                Status = STATUS_NOT_IMPLEMENTED;
                //Status = ((PBL_GRAPHICS_CONSOLE_VTABLE)GraphicsConsole->TextConsole.Callbacks)->GetTextCellResolution(GraphicsConsole);
            }
        }
    }
 
    /* Check if we failed to get it from the graphics console */
    if (!NT_SUCCESS(Status))
    {
        /* Set default text size */
        *TextWidth = 8;
        *TextHeight = 8;
    }
}

Referenced by ConsoleEfiTextGetStateFromMode(), ConsoleFirmwareTextClear(), and ConsoleFirmwareTextSetState().

◆ BlDisplayInvalidateOemBitmap()

VOID BlDisplayInvalidateOemBitmap ( VOID )

Definition at line 723 of file display.c.

{
    PBGRT_TABLE BgrtTable;
    NTSTATUS Status;
 
    /* Search for the BGRT */
    Status = BlUtlGetAcpiTable((PVOID*)&BgrtTable, BGRT_SIGNATURE);
    if (NT_SUCCESS(Status))
    {
        /* Mark the bitmap as invalid */
        BgrtTable->Status &= ~BGRT_STATUS_IMAGE_VALID;
 
        /* Unmap the table */
        BlMmUnmapVirtualAddressEx(BgrtTable, BgrtTable->Header.Length);
    }
}

Referenced by BlDisplayClearScreen(), ConsoleEfiGopClose(), and ConsoleEfiGopEnable().

◆ BlDisplaySetCursorType()

NTSTATUS BlDisplaySetCursorType ( _In_ ULONG Type )

Definition at line 969 of file display.c.

{
    NTSTATUS Status;
    PBL_TEXT_CONSOLE TextConsole;
    BL_DISPLAY_STATE State;
 
    /* Nothing to do if there's no text console */
    Status = STATUS_SUCCESS;
    TextConsole = DspTextConsole;
    if (TextConsole)
    {
        /* Write visibility state and call the function to change it */
        State.CursorVisible = Type;
        Status = TextConsole->Callbacks->SetTextState(TextConsole, 8, &State);
    }
 
    /* All done */
    return Status;
}

Referenced by BlXmiInitialize().

◆ BlDisplaySetScreenResolution()

NTSTATUS BlDisplaySetScreenResolution ( VOID )

Definition at line 646 of file display.c.

{
    PBL_GRAPHICS_CONSOLE Console;
    NTSTATUS Status;
 
    /* Assume success */
    Status = STATUS_SUCCESS;
 
    /* Do we have a graphics console? */
    Console = DspGraphicalConsole;
    if (Console)
    {
        /* Is it currently active? */
        if (((PBL_GRAPHICS_CONSOLE_VTABLE)Console->TextConsole.Callbacks)->IsEnabled(Console))
        {
            /* If so, disable it */
            return ((PBL_GRAPHICS_CONSOLE_VTABLE)Console->TextConsole.Callbacks)->Enable(Console, FALSE);
        }
    }
 
    /* We should've now fallen back to text mode */
    if (!DspTextConsole)
    {
        /* Then fail, as no display appears active */
        Status = STATUS_UNSUCCESSFUL;
    }
 
    /* Return back to the caller */
    return Status;
}

Referenced by BlResourceFindMessage(), and ResSelectLocale().

◆ BlDisplayValidOemBitmap()

BOOLEAN BlDisplayValidOemBitmap ( VOID )

Definition at line 880 of file display.c.

{
    PBITMAP Bitmap;
    ULONG HRes, VRes, Height, Width, Flags;
    COORD Offsets;
    BOOLEAN Result;
    NTSTATUS Status;
 
    /* First check if mobile graphics are enabled */
    Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
                                    BcdLibraryBoolean_MobileGraphics,
                                    &Result);
    if ((NT_SUCCESS(Status)) && (Result))
    {
        /* Yes, so use the firmware image */
        return TRUE;
    }
 
    /* Nope, so we'll check the ACPI OEM bitmap */
    Result = FALSE;
    Bitmap = BlDisplayGetOemBitmap(&Offsets, &Flags);
 
    /* Is there one? */
    if (Bitmap)
    {
        /* Is it valid? */
        if (Flags & BGRT_STATUS_IMAGE_VALID)
        {
            /* Get the current screen resolution */
            Status = BlDisplayGetScreenResolution(&HRes, &VRes);
            if (NT_SUCCESS(Status))
            {
                /* Is there a valid width? */
                Width = Bitmap->DibHeader.Width;
                if (Width)
                {
                    /* Is there a valid height? */
                    Height = Bitmap->DibHeader.Height;
                    if (Height)
                    {
                        /* Will if fit on this screen? */
                        if (((Width + Offsets.X) <= HRes) &&
                            ((Height + Offsets.Y) <= VRes))
                        {
                            /* Then it's all good! */
                            Result = TRUE;
                        }
                    }
                }
            }
        }
 
        /* Unmap the bitmap for now, it will be drawn later */
        BlMmUnmapVirtualAddressEx(Bitmap, Bitmap->BmpHeader.Size);
    }
 
    /* Return that a valid OEM bitmap exists */
    return Result;
}

Referenced by BmMain().

◆ BlpDisplayInitialize()

NTSTATUS BlpDisplayInitialize ( _In_ ULONG Flags )

Definition at line 575 of file display.c.

{
    NTSTATUS Status;
 
    /* Are we resetting or initializing? */
    if (Flags & BL_LIBRARY_FLAG_REINITIALIZE)
    {
        /* This is a reset */
        Status = DsppReinitialize(Flags);
        if (NT_SUCCESS(Status))
        {
            /* Re-initialize the class as well */
            Status = BlpDisplayReinitialize();
        }
    }
    else
    {
        /* Initialize the display */
        Status = DsppInitialize(Flags);
    }
 
    /* Return display initialization state */
    return Status;
}

Referenced by BlInitializeLibrary(), and InitializeLibrary().

◆ BlpDisplayRegisterLocale()

NTSTATUS BlpDisplayRegisterLocale ( _In_ PWCHAR Locale )

Definition at line 177 of file display.c.

{
    BOOLEAN StandardLocale;
    NTSTATUS Status;
    PWCHAR FontFileName;
    PBL_DEFERRED_FONT_FILE DeferredFont;
    PLIST_ENTRY NextEntry;
    WCHAR Prefix[3];
 
    /* Assume custom locale */
    StandardLocale = FALSE;
 
    /* Bail out if the locale string seems invalid */
    if (wcslen(Locale) < 2)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Check the prefix first, then traditional vs. simplified */
    Prefix[0] = Locale[0];
    Prefix[1] = Locale[1];
    Prefix[2] = UNICODE_NULL;
    if (!_wcsicmp(Prefix, L"ja"))
    {
        FontFileName = L"\\jpn_boot.ttf";
    }
    else if (!_wcsicmp(Prefix, L"ko"))
    {
        FontFileName = L"\\kor_boot.ttf";
    }
    else if (!(_wcsicmp(Locale, L"zh-CN")) ||
             !(_wcsicmp(Locale, L"zh-CHS")) ||
             !(_wcsicmp(Locale, L"zh-Hans")))
    {
        FontFileName = L"\\chs_boot.ttf";
    }
    else if (!(_wcsicmp(Locale, L"zh-TW")) &&
             !(_wcsicmp(Locale, L"zh-CHT")) &&
             !(_wcsicmp(Locale, L"zh-HK")) &&
             !(_wcsicmp(Locale, L"zh-Hant")))
    {
        FontFileName = L"\\cht_boot.ttf";
    }
    else
    {
        StandardLocale = TRUE;
        FontFileName = L"\\wgl4_boot.ttf";
    }
 
    /* Parse all the currently deferred fonts*/
    NextEntry = BfiDeferredListHead.Flink;
    while (NextEntry != &BfiDeferredListHead)
    {
        /* Grab the font */
        DeferredFont = CONTAINING_RECORD(NextEntry, BL_DEFERRED_FONT_FILE, ListEntry);
 
        /* Move to the next entry, and remove this one */
        NextEntry = NextEntry->Flink;
        RemoveEntryList(&DeferredFont->ListEntry);
 
        /* Free the deferred font, we'll be loading a new one */
        BfiFreeDeferredFontFile(DeferredFont);
    }
 
    /* Load the primary font */
    Status = DsppLoadFontFile(FontFileName);
    if (NT_SUCCESS(Status) && !(StandardLocale))
    {
        /* Also load the standard US one if we loaded a different one */
        Status = DsppLoadFontFile(L"\\wgl4_boot.ttf");
    }
 
    /* Return back to caller */
    return Status;
}

Referenced by ResSelectLocale().

◆ BlpDisplayReinitialize()

NTSTATUS BlpDisplayReinitialize ( VOID )

Definition at line 542 of file display.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PBL_TEXT_CONSOLE TextConsole;
    PBL_INPUT_CONSOLE InputConsole;
 
    /* Do we have a local console? */
    InputConsole = DspLocalInputConsole;
    if (InputConsole)
    {
        /* Reinitialize it */
        Status = InputConsole->Callbacks->Reinitialize((PBL_TEXT_CONSOLE)InputConsole);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
    }
 
    /* Do we have a text console? */
    TextConsole = DspTextConsole;
    if (TextConsole)
    {
        /* Reinitialize it */
        Status = TextConsole->Callbacks->Reinitialize(TextConsole);
    }
 
    /* Return status */
    return Status;
}

Referenced by BlImgStartBootApplication(), and BlpDisplayInitialize().

◆ DsppGraphicsDisabledByBcd()

BOOLEAN DsppGraphicsDisabledByBcd ( VOID )

Definition at line 43 of file display.c.

{
    BOOLEAN Disabled;
    NTSTATUS Status;
 
    /* Get the boot option, and if present, return the result */
    Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
                                    BcdLibraryBoolean_GraphicsModeDisabled,
                                    &Disabled);
    return (NT_SUCCESS(Status) && (Disabled));
}

Referenced by DsppInitialize(), and DsppReinitialize().

◆ DsppInitialize()

NTSTATUS DsppInitialize ( _In_ ULONG Flags )

Definition at line 256 of file display.c.

{
    BL_LIBRARY_PARAMETERS LibraryParameters = BlpLibraryParameters;
    BOOLEAN NoGraphics, HighestMode;
    NTSTATUS Status;
    PBL_DISPLAY_MODE DisplayMode;
    ULONGLONG GraphicsResolution;
    PBL_GRAPHICS_CONSOLE GraphicsConsole;
    PBL_TEXT_CONSOLE TextConsole, RemoteConsole;
 
    /* Initialize font data */
    BfiCachedStrikeData = 0;
    InitializeListHead(&BfiDeferredListHead);
    InitializeListHead(&BfiFontFileListHead);
 
    /* Allocate the font rectangle */
    BfiGraphicsRectangle = BlMmAllocateHeap(90);
    if (!BfiGraphicsRectangle)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Check if display re-initialization is requested */
    if (LibraryParameters.LibraryFlags & BL_LIBRARY_FLAG_REINITIALIZE_ALL)
    {
        /* Recreate a local input console */
        ConsoleCreateLocalInputConsole();
    }
 
    /* Check if no graphics console is needed */
    if ((Flags & BL_LIBRARY_FLAG_NO_GRAPHICS_CONSOLE) ||
        (DsppGraphicsDisabledByBcd()))
    {
        /* Remember this */
        NoGraphics = TRUE;
    }
    else
    {
        /* No graphics -- remember this */
        NoGraphics = FALSE;
    }
 
    /* On first load, we always initialize a graphics display */
    GraphicsConsole = NULL;
    if (!(Flags & BL_LIBRARY_FLAG_REINITIALIZE_ALL) || !(NoGraphics))
    {
        /* Default to mode 0 (1024x768) */
        DisplayMode = &ConsoleGraphicalResolutionList[0];
 
        /* Check what resolution to use*/
        Status = BlGetBootOptionInteger(BlpApplicationEntry.BcdData,
                                        BcdLibraryInteger_GraphicsResolution,
                                        &GraphicsResolution);
        if (NT_SUCCESS(Status))
        {
            ConsoleGraphicalResolutionListFlags |= BL_DISPLAY_GRAPHICS_FORCED_VIDEO_MODE_FLAG;
            EfiPrintf(L"Display selection not yet handled\r\n");
            return STATUS_NOT_IMPLEMENTED;
        }
 
        /* Check if the highest mode should be forced */
        Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
                                        BcdLibraryBoolean_GraphicsForceHighestMode,
                                        &HighestMode);
        if (NT_SUCCESS(Status))
        {
            ConsoleGraphicalResolutionListFlags |= BL_DISPLAY_GRAPHICS_FORCED_HIGH_RES_MODE_FLAG;
            EfiPrintf(L"High res mode not yet handled\r\n");
            return STATUS_NOT_IMPLEMENTED;
        }
 
        /* Do we need graphics mode after all? */
        if (!NoGraphics)
        {
            /* Yep -- go allocate it */
            GraphicsConsole = BlMmAllocateHeap(sizeof(*GraphicsConsole));
            if (GraphicsConsole)
            {
                /* Construct it */
                Status = ConsoleGraphicalConstruct(GraphicsConsole);
                if (!NT_SUCCESS(Status))
                {
                    EfiPrintf(L"GFX FAILED: %lx\r\n", Status);
                    BlMmFreeHeap(GraphicsConsole);
                    GraphicsConsole = NULL;
                }
            }
        }
 
        /* Are we using something else than the default mode? */
        if (DisplayMode != &ConsoleGraphicalResolutionList[0])
        {
            EfiPrintf(L"Display path not handled\r\n");
            return STATUS_NOT_SUPPORTED;
        }
 
        /* Mask out all the flags now */
        ConsoleGraphicalResolutionListFlags &= ~(BL_DISPLAY_GRAPHICS_FORCED_VIDEO_MODE_FLAG |
                                                 BL_DISPLAY_GRAPHICS_FORCED_HIGH_RES_MODE_FLAG);
    }
 
    /* Do we have a graphics console? */
    TextConsole = NULL;
    if (!GraphicsConsole)
    {
        /* Nope -- go allocate a text console */
        TextConsole = BlMmAllocateHeap(sizeof(*TextConsole));
        if (TextConsole)
        {
            /* Construct it */
            Status = ConsoleTextLocalConstruct(TextConsole, TRUE);
            if (!NT_SUCCESS(Status))
            {
                BlMmFreeHeap(TextConsole);
                TextConsole = NULL;
            }
        }
    }
 
    /* Initialize all globals to NULL */
    DspRemoteInputConsole = NULL;
    DspTextConsole = NULL;
    DspGraphicalConsole = NULL;
 
    /* If we don't have a text console, go get a remote console */
    RemoteConsole = NULL;
    if (!TextConsole)
    {
        ConsoleCreateRemoteConsole(&RemoteConsole);
    }
 
    /* Do we have a remote console? */
    if (!RemoteConsole)
    {
        /* Nope -- what about a graphical one? */
        if (GraphicsConsole)
        {
            /* Yes, use it for both graphics and text */
            DspGraphicalConsole = GraphicsConsole;
            DspTextConsole = GraphicsConsole;
        }
        else if (TextConsole)
        {
            /* Nope, but we have a text console */
            DspTextConsole = TextConsole;
        }
 
        /* Console has been setup */
        return STATUS_SUCCESS;
    }
 
    /* We have a remote console -- have to figure out how to use it*/
    EfiPrintf(L"Display path not handled\r\n");
    return STATUS_NOT_SUPPORTED;
}

Referenced by BlpDisplayInitialize().

◆ DsppLoadFontFile()

NTSTATUS DsppLoadFontFile ( _In_ PWCHAR FontFileName )

Definition at line 58 of file display.c.

{
    PBL_DEVICE_DESCRIPTOR FontDevice;
    NTSTATUS Status;
    SIZE_T NameLength, DirectoryLength, TotalLength;
    PWCHAR FontPath, FontDirectory;
    BL_LIBRARY_PARAMETERS LibraryParameters;
    BOOLEAN CustomDirectory, CustomDevice;
 
    /* Initialize locals */
    CustomDirectory = TRUE;
    CustomDevice = TRUE;
    FontDevice = NULL;
    FontPath = NULL;
    FontDirectory = NULL;
 
    /* Check if a custom font path should be used */
    Status = BlGetBootOptionString(BlpApplicationEntry.BcdData,
                                   BcdLibraryString_FontPath,
                                   &FontDirectory);
    if (!NT_SUCCESS(Status))
    {
        /* Nope, use the one configured by the library */
        CustomDirectory = FALSE;
        RtlCopyMemory(&LibraryParameters,
                      &BlpLibraryParameters,
                      sizeof(LibraryParameters)),
        FontDirectory = LibraryParameters.FontBaseDirectory;
    }
 
    /* Do we still not have a font directory? */
    if (!FontDirectory)
    {
        /* Use the boot device and boot directory */
        CustomDevice = FALSE;
        FontDevice = BlpBootDevice;
        FontDirectory = L"\\EFI\\Microsoft\\Boot\\Fonts";
    }
    else
    {
        /* Otherwise, if we have a font directory, what device is the app on? */
        Status = BlGetBootOptionDevice(BlpApplicationEntry.BcdData,
                                       BcdLibraryDevice_ApplicationDevice,
                                       &FontDevice,
                                       NULL);
        if (!NT_SUCCESS(Status))
        {
            /* If we don't know the device, we can't open the path */
            goto Quickie;
        }
    }
 
    /* Figure out the length of the file name, and of the directory */
    NameLength = wcslen(FontFileName);
    DirectoryLength = wcslen(FontDirectory);
 
    /* Safely add them up*/
    Status = RtlSIZETAdd(NameLength, DirectoryLength, &TotalLength);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Convert to bytes */
    Status = RtlSIZETMult(TotalLength, sizeof(WCHAR), &TotalLength);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Add a terminating NUL */
    Status = RtlSIZETAdd(TotalLength, sizeof(UNICODE_NULL), &TotalLength);
    if (!NT_SUCCESS(Status))
    {
        goto Quickie;
    }
 
    /* Allocate the final buffer for it */
    FontPath = BlMmAllocateHeap(TotalLength);
    if (!FontPath)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Concatenate the directory with the file name */
    wcscpy(FontPath, FontDirectory);
    wcscat(FontPath, FontFileName);
 
    /* Try to load this font */
    Status = BfLoadFontFile(FontDevice, FontPath);
 
Quickie:
    /* Check if we had a custom font device allocated and free it */
    if ((CustomDevice) && (FontDevice))
    {
        BlMmFreeHeap(FontDevice);
    }
 
    /* Check if we had a custom font directory allocated and free it */
    if ((CustomDirectory) && (CustomDevice))
    {
        ASSERT(FontDirectory);
        BlMmFreeHeap(FontDirectory);
    }
 
    /* Check if we had allocated a font path and free it */
    if (FontPath)
    {
        BlMmFreeHeap(FontPath);
    }
 
    /* Return back */
    return Status;
}

Referenced by BlpDisplayRegisterLocale().

◆ DsppReinitialize()

NTSTATUS DsppReinitialize ( _In_ ULONG Flags )

Definition at line 415 of file display.c.

{
    PBL_TEXT_CONSOLE TextConsole;
    PBL_GRAPHICS_CONSOLE GraphicsConsole;
    NTSTATUS Status;
    ULONGLONG GraphicsResolution;
    BOOLEAN HighestMode;
    BL_DISPLAY_MODE CurrentResolution;
 
    /* Do we have local input yet? */
    if (!DspLocalInputConsole)
    {
        /* Create it now */
        ConsoleCreateLocalInputConsole();
    }
 
    /* If a graphics console is present without a remote console... */
    TextConsole = NULL;
    if (!(DspRemoteInputConsole) && (DspGraphicalConsole))
    {
        /* Try to create a remote console */
        ConsoleCreateRemoteConsole(&TextConsole);
    }
 
    /* All good for now */
    Status = STATUS_SUCCESS;
 
    /* Now check if we were able to create the remote console */
    if (TextConsole)
    {
        EfiPrintf(L"EMS not supported\r\n");
        return STATUS_NOT_IMPLEMENTED;
    }
 
    /* Set a local for the right cast */
    GraphicsConsole = DspGraphicalConsole;
 
    /* Nothing to do without a graphics console being reinitialized */
    if (!(Flags & BL_LIBRARY_FLAG_REINITIALIZE_ALL) ||
        !(GraphicsConsole) ||
        !(((PBL_GRAPHICS_CONSOLE_VTABLE)GraphicsConsole->TextConsole.Callbacks)->IsEnabled(GraphicsConsole)))
    {
        return Status;
    }
 
    /* Check if graphics are disabled in the BCD */
    if (DsppGraphicsDisabledByBcd())
    {
        /* Turn off the graphics console, switching back to text mode */
        Status = ((PBL_GRAPHICS_CONSOLE_VTABLE)GraphicsConsole->TextConsole.Callbacks)->Enable(GraphicsConsole, FALSE);
    }
 
    /* Check if a custom graphics resolution is set */
    if (MiscGetBootOption(BlpApplicationEntry.BcdData,
                          BcdLibraryInteger_GraphicsResolution))
    {
        /* Check what it's set to */
        Status = BlGetBootOptionInteger(BlpApplicationEntry.BcdData,
                                        BcdLibraryInteger_GraphicsResolution,
                                        &GraphicsResolution);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
 
        /* Now check our current graphical resolution */
        Status = ((PBL_GRAPHICS_CONSOLE_VTABLE)GraphicsConsole->TextConsole.Callbacks)->GetGraphicalResolution(GraphicsConsole,
                                                                                                               &CurrentResolution);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
 
        /* Remember that we're forcing a video mode */
        ConsoleGraphicalResolutionListFlags |= BL_DISPLAY_GRAPHICS_FORCED_VIDEO_MODE_FLAG;
 
        /* Check which resolution to set */
        if (!GraphicsResolution)
        {
            /* 1024x768 */
            EfiPrintf(L"Display selection not yet handled\r\n");
            return STATUS_NOT_IMPLEMENTED;
        }
        else if (GraphicsResolution == 1)
        {
            /* 800x600 */
            EfiPrintf(L"Display selection not yet handled\r\n");
            return STATUS_NOT_IMPLEMENTED;
        }
        else if (GraphicsResolution == 2)
        {
            /* 1024x600 */
            EfiPrintf(L"Display selection not yet handled\r\n");
            return STATUS_NOT_IMPLEMENTED;
        }
    }
 
    /* Check if the force highest mode setting is present */
    if (MiscGetBootOption(BlpApplicationEntry.BcdData,
                          BcdLibraryBoolean_GraphicsForceHighestMode))
    {
        /* Check what it's set to */
        Status = BlGetBootOptionBoolean(BlpApplicationEntry.BcdData,
                                        BcdLibraryBoolean_GraphicsForceHighestMode,
                                        &HighestMode);
        if ((NT_SUCCESS(Status)) && (HighestMode))
        {
            /* Remember that high rest mode is being forced */
            ConsoleGraphicalResolutionListFlags |= BL_DISPLAY_GRAPHICS_FORCED_HIGH_RES_MODE_FLAG;
 
            /* Turn it on */
            //((PBL_GRAPHICS_CONSOLE_VTABLE)GraphicsConsole->TextConsole.Callbacks)->SetGraphicalResolution(GraphicsConsole, 0, 0);
 
            /* All done now */
            ConsoleGraphicalResolutionListFlags |= ~BL_DISPLAY_GRAPHICS_FORCED_HIGH_RES_MODE_FLAG;
            EfiPrintf(L"High res mode not yet handled\r\n");
            Status = STATUS_NOT_IMPLEMENTED;
        }
    }
 
    /* Return back to the caller */
    return Status;
}

Referenced by BlpDisplayInitialize().

Variable Documentation

◆ BfiCachedStrikeData

PVOID BfiCachedStrikeData

Definition at line 16 of file display.c.

Referenced by DsppInitialize().

◆ BfiDeferredListHead

LIST_ENTRY BfiDeferredListHead

Definition at line 17 of file display.c.

Referenced by BlpDisplayRegisterLocale(), and DsppInitialize().

◆ BfiFontFileListHead

LIST_ENTRY BfiFontFileListHead

Definition at line 18 of file display.c.

Referenced by DsppInitialize().

◆ BfiGraphicsRectangle

PVOID BfiGraphicsRectangle

Definition at line 19 of file display.c.

Referenced by DsppInitialize().

◆ ConsoleGraphicalResolutionList

BL_DISPLAY_MODE ConsoleGraphicalResolutionList[3]

Initial value:

=
{
    {1024, 768, 1024},
    {800, 600, 800},
    {1024, 600, 1024}
}

Definition at line 22 of file display.c.

Referenced by ConsoleEfiGopOpen(), and DsppInitialize().

◆ ConsoleGraphicalResolutionListFlags

ULONG ConsoleGraphicalResolutionListFlags

Definition at line 21 of file display.c.

Referenced by ConsoleEfiGopOpen(), DsppInitialize(), and DsppReinitialize().

◆ ConsoleGraphicalResolutionListSize

ULONG ConsoleGraphicalResolutionListSize = RTL_NUMBER_OF(ConsoleGraphicalResolutionList)

Definition at line 28 of file display.c.

Referenced by ConsoleEfiGopOpen().

◆ ConsoleTextResolutionList

BL_DISPLAY_MODE ConsoleTextResolutionList[1]

Initial value:

=
{
    {80, 25, 80}
}

Definition at line 30 of file display.c.

Referenced by ConsoleFirmwareTextOpen().

◆ DspGraphicalConsole

PVOID DspGraphicalConsole

Definition at line 37 of file display.c.

Referenced by BlDisplayGetScreenResolution(), BlDisplayGetTextCellResolution(), BlDisplaySetScreenResolution(), DsppInitialize(), DsppReinitialize(), and OslDrawLogo().

◆ DspLocalInputConsole

PVOID DspLocalInputConsole

Definition at line 38 of file display.c.

Referenced by BlpDisplayReinitialize(), ConsoleCreateLocalInputConsole(), and DsppReinitialize().

◆ DspRemoteInputConsole

PVOID DspRemoteInputConsole

Definition at line 35 of file display.c.

Referenced by ConsoleCreateRemoteConsole(), DsppInitialize(), and DsppReinitialize().

◆ DspTextConsole

PVOID DspTextConsole

Definition at line 36 of file display.c.

Referenced by BlDisplayClearScreen(), BlDisplayGetScreenResolution(), BlDisplayGetTextCellResolution(), BlDisplaySetCursorType(), BlDisplaySetScreenResolution(), BlpDisplayReinitialize(), and DsppInitialize().

Variables
PVOID	BfiCachedStrikeData

LIST_ENTRY	BfiDeferredListHead

LIST_ENTRY	BfiFontFileListHead

PVOID	BfiGraphicsRectangle

ULONG	ConsoleGraphicalResolutionListFlags

BL_DISPLAY_MODE	ConsoleGraphicalResolutionList [3]

ULONG	ConsoleGraphicalResolutionListSize = RTL_NUMBER_OF(ConsoleGraphicalResolutionList)

BL_DISPLAY_MODE	ConsoleTextResolutionList [1]

PVOID	DspRemoteInputConsole

PVOID	DspTextConsole

PVOID	DspGraphicalConsole

PVOID	DspLocalInputConsole

Functions

Variables

Function Documentation

◆ BlDisplayClearScreen()

◆ BlDisplayGetOemBitmap()

◆ BlDisplayGetScreenResolution()

◆ BlDisplayGetTextCellResolution()

◆ BlDisplayInvalidateOemBitmap()

◆ BlDisplaySetCursorType()

◆ BlDisplaySetScreenResolution()

◆ BlDisplayValidOemBitmap()

◆ BlpDisplayInitialize()

◆ BlpDisplayRegisterLocale()

◆ BlpDisplayReinitialize()

◆ DsppGraphicsDisabledByBcd()

◆ DsppInitialize()

◆ DsppLoadFontFile()

◆ DsppReinitialize()

Variable Documentation

◆ BfiCachedStrikeData

◆ BfiDeferredListHead

◆ BfiFontFileListHead

◆ BfiGraphicsRectangle

◆ ConsoleGraphicalResolutionList

◆ ConsoleGraphicalResolutionListFlags

◆ ConsoleGraphicalResolutionListSize

◆ ConsoleTextResolutionList

◆ DspGraphicalConsole

◆ DspLocalInputConsole

◆ DspRemoteInputConsole

◆ DspTextConsole