machuefi.h File Reference

#include <machine.h>

Include dependency graph for machuefi.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
VOID	UefiConsPutChar (int Ch)
BOOLEAN	UefiConsKbHit (VOID)
int	UefiConsGetCh (void)
EFI_STATUS	UefiInitializeVideo (VOID)
VOID	UefiVideoClearScreen (UCHAR Attr)
VIDEODISPLAYMODE	UefiVideoSetDisplayMode (PCSTR DisplayMode, BOOLEAN Init)
VOID	UefiVideoGetDisplaySize (PULONG Width, PULONG Height, PULONG Depth)
ULONG	UefiVideoGetBufferSize (VOID)
VOID	UefiVideoGetFontsFromFirmware (PULONG RomFontPointers)
VOID	UefiVideoSetTextCursorPosition (UCHAR X, UCHAR Y)
VOID	UefiVideoHideShowTextCursor (BOOLEAN Show)
VOID	UefiVideoPutChar (int Ch, UCHAR Attr, unsigned X, unsigned Y)
VOID	UefiVideoCopyOffScreenBufferToVRAM (PVOID Buffer)
BOOLEAN	UefiVideoIsPaletteFixed (VOID)
VOID	UefiVideoSetPaletteColor (UCHAR Color, UCHAR Red, UCHAR Green, UCHAR Blue)
VOID	UefiVideoGetPaletteColor (UCHAR Color, UCHAR *Red, UCHAR *Green, UCHAR *Blue)
VOID	UefiVideoSync (VOID)
VOID	UefiPcBeep (VOID)
PFREELDR_MEMORY_DESCRIPTOR	UefiMemGetMemoryMap (ULONG *MemoryMapSize)
VOID	UefiGetExtendedBIOSData (PULONG ExtendedBIOSDataArea, PULONG ExtendedBIOSDataSize)
UCHAR	UefiGetFloppyCount (VOID)
BOOLEAN	UefiDiskReadLogicalSectors (IN UCHAR DriveNumber, IN ULONGLONG SectorNumber, IN ULONG SectorCount, OUT PVOID Buffer)
BOOLEAN	UefiDiskGetDriveGeometry (UCHAR DriveNumber, PGEOMETRY Geometry)
ULONG	UefiDiskGetCacheableBlockCount (UCHAR DriveNumber)
TIMEINFO *	UefiGetTime (VOID)
BOOLEAN	UefiInitializeBootDevices (VOID)
PCONFIGURATION_COMPONENT_DATA	UefiHwDetect (_In_opt_ PCSTR Options)
VOID	UefiPrepareForReactOS (VOID)
VOID	UefiHwIdle (VOID)
VOID	UefiInitializeFileSystemSupport (_In_ EFI_HANDLE ImageHandle, _In_ EFI_SYSTEM_TABLE *SystemTable)

Function Documentation

UefiConsGetCh()

int UefiConsGetCh

(

void

)

Definition at line 128 of file ueficon.c.

{
    UCHAR KeyOutput = 0;
 
    /* If an extended key press was detected the last time we were called
     * then return the scan code of that key. */
    if (ExtendedKey)
    {
        ExtendedKey = FALSE;
        return ExtendedScanCode;
    }
 
    if (Key.UnicodeChar != 0)
    {
        KeyOutput = Key.UnicodeChar;
    }
    else
    {
        ExtendedKey = TRUE;
        ExtendedScanCode = ConvertToBiosExtValue(Key.ScanCode);
        KeyOutput = KEY_EXTENDED;
    }
 
    /* UEFI will stack input requests, we have to clear it */
    Key.UnicodeChar = 0;
    Key.ScanCode = 0;
    return KeyOutput;
}

Referenced by MachInit().

UefiConsKbHit()

BOOLEAN UefiConsKbHit

(

VOID

)

Definition at line 122 of file ueficon.c.

{
    return (GlobalSystemTable->ConIn->ReadKeyStroke(GlobalSystemTable->ConIn, &Key) != EFI_NOT_READY);
}

Referenced by MachInit().

UefiConsPutChar()

VOID UefiConsPutChar

(

int

Ch

)

Definition at line 27 of file ueficon.c.

{
    ULONG Width, Height, Unused;
    BOOLEAN NeedScroll;
 
    UefiVideoGetDisplaySize(&Width, &Height, &Unused);
 
    NeedScroll = (CurrentCursorY >= Height);
    if (NeedScroll)
    {
        FbConsScrollUp(CurrentAttr);
        --CurrentCursorY;
    }
    if (c == '\r')
    {
        CurrentCursorX = 0;
    }
    else if (c == '\n')
    {
        CurrentCursorX = 0;
        if (!NeedScroll)
            ++CurrentCursorY;
    }
    else if (c == '\t')
    {
        CurrentCursorX = (CurrentCursorX + 8) & ~7;
    }
    else
    {
        UefiVideoPutChar(c, CurrentAttr, CurrentCursorX, CurrentCursorY);
        CurrentCursorX++;
    }
    if (CurrentCursorX >= Width)
    {
        CurrentCursorX = 0;
        CurrentCursorY++;
    }
}

Referenced by MachInit().

UefiDiskGetCacheableBlockCount()

ULONG UefiDiskGetCacheableBlockCount

(

UCHAR

DriveNumber

)

Definition at line 584 of file uefidisk.c.

{
    ULONG UefiDriveNumber = InternalUefiDisk[DriveNumber - FIRST_BIOS_DISK].UefiRootNumber;
    TRACE("UefiDiskGetCacheableBlockCount: DriveNumber: %d\n", UefiDriveNumber);
 
    GlobalSystemTable->BootServices->HandleProtocol(handles[UefiDriveNumber], &bioGuid, (void**)&bio);
    return (bio->Media->LastBlock + 1);
}

Referenced by MachInit().

UefiDiskGetDriveGeometry()

BOOLEAN UefiDiskGetDriveGeometry	(	UCHAR	DriveNumber,
		PGEOMETRY	Geometry
	)

Definition at line 568 of file uefidisk.c.

{
    ULONG UefiDriveNumber;
 
    UefiDriveNumber = InternalUefiDisk[DriveNumber - FIRST_BIOS_DISK].UefiRootNumber;
    GlobalSystemTable->BootServices->HandleProtocol(handles[UefiDriveNumber], &bioGuid, (void**)&bio);
    Geometry->Cylinders = 1; // Not relevant for the UEFI BIO protocol
    Geometry->Heads = 1;     // Not relevant for the UEFI BIO protocol
    Geometry->SectorsPerTrack = (bio->Media->LastBlock + 1);
    Geometry->BytesPerSector = bio->Media->BlockSize;
    Geometry->Sectors = (bio->Media->LastBlock + 1);
 
    return TRUE;
}

Referenced by MachInit().

UefiDiskReadLogicalSectors()

BOOLEAN UefiDiskReadLogicalSectors	(	IN UCHAR	DriveNumber,
		IN ULONGLONG	SectorNumber,
		IN ULONG	SectorCount,
		OUT PVOID	Buffer
	)

Definition at line 550 of file uefidisk.c.

{
    ULONG UefiDriveNumber;
 
    UefiDriveNumber = InternalUefiDisk[DriveNumber - FIRST_BIOS_DISK].UefiRootNumber;
    TRACE("UefiDiskReadLogicalSectors: DriveNumber: %d\n", UefiDriveNumber);
    GlobalSystemTable->BootServices->HandleProtocol(handles[UefiDriveNumber], &bioGuid, (void**)&bio);
 
    /* Devices setup */
    bio->ReadBlocks(bio, bio->Media->MediaId, SectorNumber, SectorCount * bio->Media->BlockSize, Buffer);
    return TRUE;
}

Referenced by MachInit().

UefiGetExtendedBIOSData()

VOID UefiGetExtendedBIOSData	(	PULONG	ExtendedBIOSDataArea,
		PULONG	ExtendedBIOSDataSize
	)

Definition at line 38 of file stubs.c.

{
 
}

Referenced by MachInit().

UefiGetFloppyCount()

UCHAR UefiGetFloppyCount

(

VOID

)

Definition at line 543 of file uefidisk.c.

{
    /* No floppy for you for now... */
    return 0;
}

Referenced by MachInit().

UefiGetTime()

TIMEINFO * UefiGetTime

(

VOID

)

Definition at line 20 of file uefiutil.c.

{
    static TIMEINFO TimeInfo;
    EFI_STATUS Status;
    EFI_TIME time = {0};
 
    Status = GlobalSystemTable->RuntimeServices->GetTime(&time, NULL);
    if (Status != EFI_SUCCESS)
        ERR("UefiGetTime: cannot get time status %d\n", Status);
 
    TimeInfo.Year = time.Year;
    TimeInfo.Month = time.Month;
    TimeInfo.Day = time.Day;
    TimeInfo.Hour = time.Hour;
    TimeInfo.Minute = time.Minute;
    TimeInfo.Second = time.Second;
    return &TimeInfo;
}

Referenced by MachInit().

UefiHwDetect()

PCONFIGURATION_COMPONENT_DATA UefiHwDetect

(

_In_opt_ PCSTR

Options

)

Definition at line 131 of file uefihw.c.

{
    PCONFIGURATION_COMPONENT_DATA SystemKey;
    ULONG BusNumber = 0;
 
    TRACE("DetectHardware()\n");
 
    /* Create the 'System' key */
#if defined(_M_IX86) || defined(_M_AMD64)
    FldrCreateSystemKey(&SystemKey, "AT/AT COMPATIBLE");
#elif defined(_M_IA64)
    FldrCreateSystemKey(&SystemKey, "Intel Itanium processor family");
#elif defined(_M_ARM) || defined(_M_ARM64)
    FldrCreateSystemKey(&SystemKey, "ARM processor family");
#else
    #error Please define a system key for your architecture
#endif
 
    /* Detect ACPI */
    DetectAcpiBios(SystemKey, &BusNumber);
 
    TRACE("DetectHardware() Done\n");
    return SystemKey;
}

Referenced by MachInit().

UefiHwIdle()

VOID UefiHwIdle

(

VOID

)

Definition at line 51 of file stubs.c.

{
 
}

Referenced by MachInit().

UefiInitializeBootDevices()

BOOLEAN UefiInitializeBootDevices

(

VOID

)

Definition at line 494 of file uefidisk.c.

{
    DiskReadBufferSize = EFI_PAGE_SIZE;
    DiskReadBuffer = MmAllocateMemoryWithType(DiskReadBufferSize, LoaderFirmwareTemporary);
    UefiSetupBlockDevices();
    UefiSetBootpath();
 
    /* Add it, if it's a cdrom */
    GlobalSystemTable->BootServices->HandleProtocol(handles[UefiBootRootIdentifier], &bioGuid, (void**)&bio);
    if (bio->Media->RemovableMedia == TRUE && bio->Media->BlockSize == 2048)
    {
        PMASTER_BOOT_RECORD Mbr;
        PULONG Buffer;
        ULONG Checksum = 0;
        ULONG Signature;
        ULONG i;
 
        /* Read the MBR */
        if (!MachDiskReadLogicalSectors(FrldrBootDrive, 16ULL, 1, DiskReadBuffer))
        {
            ERR("Reading MBR failed\n");
            return FALSE;
        }
 
        Buffer = (ULONG*)DiskReadBuffer;
        Mbr = (PMASTER_BOOT_RECORD)DiskReadBuffer;
 
        Signature = Mbr->Signature;
        TRACE("Signature: %x\n", Signature);
 
        /* Calculate the MBR checksum */
        for (i = 0; i < 2048 / sizeof(ULONG); i++)
        {
            Checksum += Buffer[i];
        }
        Checksum = ~Checksum + 1;
        TRACE("Checksum: %x\n", Checksum);
 
        /* Fill out the ARC disk block */
        AddReactOSArcDiskInfo(FrLdrBootPath, Signature, Checksum, TRUE);
 
        FsRegisterDevice(FrLdrBootPath, &UefiDiskVtbl);
        PcBiosDiskCount++; // This is not accounted for in the number of pre-enumerated BIOS drives!
        TRACE("Additional boot drive detected: 0x%02X\n", (int)FrldrBootDrive);
    }
    return TRUE;
}

Referenced by MachInit().

UefiInitializeFileSystemSupport()

VOID UefiInitializeFileSystemSupport	(	_In_ EFI_HANDLE	ImageHandle,
		_In_ EFI_SYSTEM_TABLE *	SystemTable
	)

UefiInitializeVideo()

EFI_STATUS UefiInitializeVideo

(

VOID

)

Definition at line 52 of file uefivid.c.

{
    EFI_GRAPHICS_PIXEL_FORMAT PixelFormat;
    EFI_PIXEL_BITMASK* pPixelBitmask;
    ULONG BitsPerPixel;
 
    EFI_STATUS Status;
    EFI_GRAPHICS_OUTPUT_PROTOCOL* gop = NULL;
 
    Status = GlobalSystemTable->BootServices->LocateProtocol(&EfiGraphicsOutputProtocol, 0, (void**)&gop);
    if (Status != EFI_SUCCESS)
    {
        TRACE("Failed to find GOP with status %d\n", Status);
        return Status;
    }
 
    /* We don't need high resolutions for freeldr */
    gop->SetMode(gop, LOWEST_SUPPORTED_RES);
 
    /* Physical format of the pixel */
    PixelFormat = gop->Mode->Info->PixelFormat;
    switch (PixelFormat)
    {
        case PixelRedGreenBlueReserved8BitPerColor:
        case PixelBlueGreenRedReserved8BitPerColor:
        {
            pPixelBitmask = &EfiPixelMasks[PixelFormat];
            BitsPerPixel = RTL_BITS_OF(EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
            break;
        }
 
        case PixelBitMask:
        {
            /*
             * When the GOP pixel format is given by PixelBitMask, the pixel
             * element size _may be_ different from 4 bytes.
             * See UEFI Spec Rev.2.10 Section 12.9 "Graphics Output Protocol":
             * example code "GetPixelElementSize()" function.
             */
            pPixelBitmask = &gop->Mode->Info->PixelInformation;
            BitsPerPixel =
                PixelBitmasksToBpp(pPixelBitmask->RedMask,
                                   pPixelBitmask->GreenMask,
                                   pPixelBitmask->BlueMask,
                                   pPixelBitmask->ReservedMask);
            break;
        }
 
        case PixelBltOnly:
        default:
        {
            ERR("Unsupported UFEI GOP format %lu\n", PixelFormat);
            pPixelBitmask = NULL;
            BitsPerPixel = 0;
            break;
        }
    }
 
    VidFbInitializeVideo((ULONG_PTR)gop->Mode->FrameBufferBase,
                         gop->Mode->FrameBufferSize,
                         gop->Mode->Info->HorizontalResolution,
                         gop->Mode->Info->VerticalResolution,
                         gop->Mode->Info->PixelsPerScanLine,
                         BitsPerPixel,
                         (PPIXEL_BITMASK)pPixelBitmask);
    return Status;
}

Referenced by MachInit().

UefiMemGetMemoryMap()

PFREELDR_MEMORY_DESCRIPTOR UefiMemGetMemoryMap

(

ULONG *

MemoryMapSize

)

Definition at line 145 of file uefimem.c.

{
    EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
    UINT32 DescriptorVersion;
    SIZE_T FreeldrMemMapSize;
    UINTN DescriptorSize;
    EFI_STATUS Status;
    UINTN MapSize;
    UINTN MapKey;
    UINT32 Index;
 
    EFI_GUID EfiLoadedImageProtocol = EFI_LOADED_IMAGE_PROTOCOL_GUID;
    PFREELDR_MEMORY_DESCRIPTOR FreeldrMem = NULL;
    EFI_MEMORY_DESCRIPTOR* MapEntry = NULL;
    UINT32 EntryCount = 0;
    FreeldrDescCount = 0;
 
    Status = GlobalSystemTable->BootServices->HandleProtocol(GlobalImageHandle,
                                                             &EfiLoadedImageProtocol,
                                                             (VOID**)&LoadedImage);
    if (Status != EFI_SUCCESS)
    {
        TRACE("Failed to find LoadedImageHandle with status: %d\n", Status);
        UiMessageBoxCritical("Unable to initialize memory manager.");
        return NULL;
    }
    OsLoaderBase = LoadedImage->ImageBase;
    OsLoaderSize = LoadedImage->ImageSize;
    PublicBootHandle = LoadedImage->DeviceHandle;
    EfiMemoryMap = NULL;
 
    TRACE("UefiMemGetMemoryMap: Gather memory map\n");
    PUEFI_LoadMemoryMap(&MapKey,
                        &MapSize,
                        &DescriptorSize,
                        &DescriptorVersion);
 
    TRACE("Value of MapKey: %d\n", MapKey);
    TRACE("Value of MapSize: %d\n", MapSize);
    TRACE("Value of DescriptorSize: %d\n", DescriptorSize);
    TRACE("Value of DescriptorVersion: %d\n", DescriptorVersion);
 
    EntryCount = (MapSize / DescriptorSize);
 
    FreeldrMemMapSize = (sizeof(FREELDR_MEMORY_DESCRIPTOR) * EntryCount);
    Status = GlobalSystemTable->BootServices->AllocatePool(EfiLoaderData,
                                                           FreeldrMemMapSize,
                                                           (void**)&FreeldrMem);
    if (Status != EFI_SUCCESS)
    {
        TRACE("Failed to allocate pool with status %d\n", Status);
        UiMessageBoxCritical("Unable to initialize memory manager.");
        return NULL;
    }
 
    RtlZeroMemory(FreeldrMem, FreeldrMemMapSize);
    MapEntry = EfiMemoryMap;
    for (Index = 0; Index < EntryCount; ++Index)
    {
        TYPE_OF_MEMORY MemoryType = UefiConvertToFreeldrDesc(MapEntry->Type);
        if (MemoryType == LoaderFree)
        {
            Status = GlobalSystemTable->BootServices->AllocatePages(AllocateAddress,
                                                                    EfiLoaderData,
                                                                    MapEntry->NumberOfPages,
                                                                    &MapEntry->PhysicalStart);
            if (Status != EFI_SUCCESS)
            {
                /* We failed to reserve the page, so change its type */
                MemoryType = LoaderFirmwareTemporary;
            }
        }
 
        /* Sometimes our loader can be loaded into higher memory than we ever allocate */
        if (MemoryType == LoaderLoadedProgram)
        {
            if (((MapEntry->PhysicalStart + (MapEntry->NumberOfPages * PAGE_SIZE)) >> EFI_PAGE_SHIFT) > LoaderPagesSpanned)
            {
                /* This value needs to be adjusted if this occurs */
                LoaderPagesSpanned = ((MapEntry->PhysicalStart + (MapEntry->NumberOfPages * PAGE_SIZE)) >> EFI_PAGE_SHIFT);
            }
        }
 
        /* We really don't want to touch these reserved spots at all */
        if (MemoryType != LoaderReserve)
        {
            UefiSetMemory(FreeldrMem,
                          MapEntry->PhysicalStart,
                          MapEntry->NumberOfPages,
                          MemoryType);
        }
 
        MapEntry = NEXT_MEMORY_DESCRIPTOR(MapEntry, DescriptorSize);
    }
 
    /* Windows expects the first page to be reserved, otherwise it asserts.
     * However it can be just a free page on some UEFI systems. */
    UefiSetMemory(FreeldrMem, 0x000000, 1, LoaderFirmwarePermanent);
    *MemoryMapSize = FreeldrDescCount;
    return FreeldrMem;
}

Referenced by MachInit().

UefiPcBeep()

VOID UefiPcBeep

(

VOID

)

Definition at line 45 of file stubs.c.

{
    /* Not possible on UEFI, for now */
}

Referenced by MachInit().

UefiPrepareForReactOS()

VOID UefiPrepareForReactOS

(

VOID

)

Definition at line 283 of file uefimem.c.

{
    _exituefi();
}

Referenced by MachInit().

UefiVideoClearScreen()

VOID UefiVideoClearScreen

(

UCHAR

Attr

)

Definition at line 121 of file uefivid.c.

{
    FbConsClearScreen(Attr);
}

Referenced by MachInit().

UefiVideoCopyOffScreenBufferToVRAM()

VOID UefiVideoCopyOffScreenBufferToVRAM

(

PVOID

Buffer

)

Definition at line 152 of file uefivid.c.

{
    FbConsCopyOffScreenBufferToVRAM(Buffer);
}

Referenced by MachInit().

UefiVideoGetBufferSize()

ULONG UefiVideoGetBufferSize

(

VOID

)

Definition at line 146 of file uefivid.c.

{
    return FbConsGetBufferSize();
}

Referenced by MachInit().

UefiVideoGetDisplaySize()

VOID UefiVideoGetDisplaySize	(	PULONG	Width,
		PULONG	Height,
		PULONG	Depth
	)

Definition at line 133 of file uefivid.c.

{
    FbConsGetDisplaySize(Width, Height, Depth);
}

Referenced by MachInit(), and UefiConsPutChar().

UefiVideoGetFontsFromFirmware()

VOID UefiVideoGetFontsFromFirmware

(

PULONG

RomFontPointers

)

Definition at line 26 of file stubs.c.

{
 
}

Referenced by MachInit().

UefiVideoGetPaletteColor()

VOID UefiVideoGetPaletteColor	(	UCHAR	Color,
		UCHAR *	Red,
		UCHAR *	Green,
		UCHAR *	Blue
	)

Definition at line 183 of file uefivid.c.

{
    /* Not supported */
}

Referenced by MachInit().

UefiVideoHideShowTextCursor()

VOID UefiVideoHideShowTextCursor

(

BOOLEAN

Show

)

Definition at line 164 of file uefivid.c.

{
    /* We don't have a cursor yet */
}

Referenced by MachInit().

UefiVideoIsPaletteFixed()

BOOLEAN UefiVideoIsPaletteFixed

(

VOID

)

Definition at line 170 of file uefivid.c.

{
    return 0;
}

Referenced by MachInit().

UefiVideoPutChar()

VOID UefiVideoPutChar	(	int	Ch,
		UCHAR	Attr,
		unsigned	X,
		unsigned	Y
	)

Definition at line 127 of file uefivid.c.

{
    FbConsPutChar(Ch, Attr, X, Y);
}

Referenced by MachInit(), and UefiConsPutChar().

UefiVideoSetDisplayMode()

VIDEODISPLAYMODE UefiVideoSetDisplayMode	(	PCSTR	DisplayMode,
		BOOLEAN	Init
	)

Definition at line 139 of file uefivid.c.

{
    /* We only have one mode, semi-text */
    return VideoTextMode;
}

Referenced by MachInit().

UefiVideoSetPaletteColor()

VOID UefiVideoSetPaletteColor	(	UCHAR	Color,
		UCHAR	Red,
		UCHAR	Green,
		UCHAR	Blue
	)

Definition at line 176 of file uefivid.c.

{
    /* Not supported */
}

Referenced by MachInit().

UefiVideoSetTextCursorPosition()

VOID UefiVideoSetTextCursorPosition	(	UCHAR	X,
		UCHAR	Y
	)

Definition at line 158 of file uefivid.c.

{
    /* We don't have a cursor yet */
}

Referenced by MachInit().

UefiVideoSync()

VOID UefiVideoSync

(

VOID

)

Definition at line 32 of file stubs.c.

{
 
}

Referenced by MachInit().