machuefi.h File Reference

#include <machine.h>
#include <drivers/acpi/acpi.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)
PDESCRIPTION_HEADER	UefiFindAcpiTable (_In_ ULONG Signature)
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.

{
    EFI_INPUT_KEY Key;
    EFI_STATUS Status;
    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;
    }
 
    Status = GlobalSystemTable->ConIn->ReadKeyStroke(GlobalSystemTable->ConIn, &Key);
    if (EFI_ERROR(Status))
        return 0;
 
    if (Key.UnicodeChar != 0)
    {
        KeyOutput = Key.UnicodeChar;
    }
    else
    {
        ExtendedKey = TRUE;
        ExtendedScanCode = ConvertToBiosExtValue(Key.ScanCode);
        KeyOutput = KEY_EXTENDED;
    }
    return KeyOutput;
}

Referenced by MachInit().

UefiConsKbHit()

BOOLEAN UefiConsKbHit

(

VOID

)

Definition at line 121 of file ueficon.c.

{
    return (GlobalSystemTable->BootServices->CheckEvent(
                GlobalSystemTable->ConIn->WaitForKey) == EFI_SUCCESS);
}

Referenced by MachInit().

UefiConsPutChar()

VOID UefiConsPutChar

(

int

Ch

)

Definition at line 26 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 1301 of file uefidisk.c.

{
    ULONG ArcDriveIndex;
    EFI_BLOCK_IO* BlockIo;
    EFI_STATUS Status;
 
    if (DriveNumber < FIRST_BIOS_DISK)
        return 0;
 
    ArcDriveIndex = DriveNumber - FIRST_BIOS_DISK;
 
    if (InternalUefiDisk == NULL)
    {
        ERR("InternalUefiDisk not initialized\n");
        return 0;
    }
 
    if (ArcDriveIndex >= 32 || InternalUefiDisk[ArcDriveIndex].Handle == NULL)
    {
        ERR("Invalid drive number: %d\n", DriveNumber);
        return 0;
    }
 
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        InternalUefiDisk[ArcDriveIndex].Handle,
        &BlockIoGuid,
        (VOID**)&BlockIo);
 
    if (EFI_ERROR(Status) || BlockIo == NULL)
    {
        ERR("Failed to get Block I/O protocol for drive %d\n", DriveNumber);
        return 0;
    }
 
    if (!BlockIo->Media->MediaPresent)
    {
        ERR("Media not present for drive %d\n", DriveNumber);
        return 0;
    }
 
    return (ULONG)(BlockIo->Media->LastBlock + 1);
}

Referenced by MachInit().

UefiDiskGetDriveGeometry()

BOOLEAN UefiDiskGetDriveGeometry	(	UCHAR	DriveNumber,
		PGEOMETRY	Geometry
	)

Definition at line 1251 of file uefidisk.c.

{
    ULONG ArcDriveIndex;
    EFI_BLOCK_IO* BlockIo;
    EFI_STATUS Status;
 
    if (DriveNumber < FIRST_BIOS_DISK)
        return FALSE;
 
    ArcDriveIndex = DriveNumber - FIRST_BIOS_DISK;
 
    if (InternalUefiDisk == NULL)
    {
        ERR("InternalUefiDisk not initialized\n");
        return FALSE;
    }
 
    if (ArcDriveIndex >= 32 || InternalUefiDisk[ArcDriveIndex].Handle == NULL)
    {
        ERR("Invalid drive number: %d\n", DriveNumber);
        return FALSE;
    }
 
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        InternalUefiDisk[ArcDriveIndex].Handle,
        &BlockIoGuid,
        (VOID**)&BlockIo);
 
    if (EFI_ERROR(Status) || BlockIo == NULL)
    {
        ERR("Failed to get Block I/O protocol for drive %d\n", DriveNumber);
        return FALSE;
    }
 
    if (!BlockIo->Media->MediaPresent)
    {
        ERR("Media not present for drive %d\n", DriveNumber);
        return FALSE;
    }
 
    Geometry->Cylinders = 1; /* Not relevant for UEFI Block I/O protocol */
    Geometry->Heads = 1;     /* Not relevant for UEFI Block I/O protocol */
    Geometry->SectorsPerTrack = (ULONG)(BlockIo->Media->LastBlock + 1);
    Geometry->BytesPerSector = BlockIo->Media->BlockSize;
    Geometry->Sectors = BlockIo->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 1116 of file uefidisk.c.

{
    ULONG ArcDriveIndex;
    EFI_BLOCK_IO* BlockIo;
    EFI_STATUS Status;
    ULONG BlockSize;
    ULONG IoAlign;
 
    if (DriveNumber < FIRST_BIOS_DISK)
        return FALSE;
 
    ArcDriveIndex = DriveNumber - FIRST_BIOS_DISK;
 
    if (InternalUefiDisk == NULL)
    {
        ERR("InternalUefiDisk not initialized\n");
        return FALSE;
    }
 
    if (ArcDriveIndex >= 32)
    {
        ERR("Drive index out of bounds: %d (ArcDriveIndex=%lu)\n", DriveNumber, ArcDriveIndex);
        return FALSE;
    }
 
    /* Allow access during initialization: check if handle is set up.
     * During initialization, Handle is set before GetHarddiskInformation is called. */
    if (InternalUefiDisk[ArcDriveIndex].Handle == NULL)
    {
        ERR("Invalid drive number: %d (ArcDriveIndex=%lu, PcBiosDiskCount=%lu, Handle=NULL)\n", 
            DriveNumber, ArcDriveIndex, PcBiosDiskCount);
        return FALSE;
    }
 
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        InternalUefiDisk[ArcDriveIndex].Handle,
        &BlockIoGuid,
        (VOID**)&BlockIo);
 
    if (EFI_ERROR(Status) || BlockIo == NULL)
    {
        ERR("Failed to get Block I/O protocol for drive %d\n", DriveNumber);
        return FALSE;
    }
 
    if (!BlockIo->Media->MediaPresent)
    {
        ERR("Media not present for drive %d\n", DriveNumber);
        return FALSE;
    }
 
    BlockSize = BlockIo->Media->BlockSize;
    IoAlign = BlockIo->Media->IoAlign;
 
    if (!UefiEnsureDiskReadBufferAligned(IoAlign))
    {
        ERR("Failed to align disk read buffer for drive %d\n", DriveNumber);
        return FALSE;
    }
 
    if (!UefiIsAlignedPointer(Buffer, (IoAlign == 0) ? 1 : IoAlign))
    {
        ULONG TotalSectors = SectorCount;
        ULONG MaxSectors = DiskReadBufferSize / BlockSize;
        ULONGLONG CurrentSector = SectorNumber;
        PUCHAR OutPtr = (PUCHAR)Buffer;
 
        if (MaxSectors == 0)
        {
            ERR("DiskReadBufferSize too small for block size %lu\n", BlockSize);
            return FALSE;
        }
 
        while (TotalSectors)
        {
            ULONG ReadSectors = min(TotalSectors, MaxSectors);
            UINTN ReadSize = ReadSectors * BlockSize;
 
            Status = BlockIo->ReadBlocks(
                BlockIo,
                BlockIo->Media->MediaId,
                CurrentSector,
                ReadSize,
                DiskReadBuffer);
 
            if (EFI_ERROR(Status))
            {
                ERR("ReadBlocks failed: DriveNumber=%d, SectorNumber=%llu, SectorCount=%lu, Status=0x%lx\n",
                    DriveNumber, CurrentSector, ReadSectors, (ULONG)Status);
                ERR("ReadBlocks details: BlockSize=%lu, IoAlign=%lu, Buffer=%p, DiskReadBuffer=%p, MediaId=0x%lx\n",
                    BlockSize, IoAlign, Buffer, DiskReadBuffer, (ULONG)BlockIo->Media->MediaId);
                ERR("ReadBlocks media: LastBlock=%llu, LogicalPartition=%s, RemovableMedia=%s\n",
                    BlockIo->Media->LastBlock,
                    BlockIo->Media->LogicalPartition ? "TRUE" : "FALSE",
                    BlockIo->Media->RemovableMedia ? "TRUE" : "FALSE");
                return FALSE;
            }
 
            RtlCopyMemory(OutPtr, DiskReadBuffer, ReadSize);
            OutPtr += ReadSize;
            CurrentSector += ReadSectors;
            TotalSectors -= ReadSectors;
        }
 
        return TRUE;
    }
 
    Status = BlockIo->ReadBlocks(
        BlockIo,
        BlockIo->Media->MediaId,
        SectorNumber,
        SectorCount * BlockSize,
        Buffer);
 
    if (EFI_ERROR(Status))
    {
        ERR("ReadBlocks failed: DriveNumber=%d, SectorNumber=%llu, SectorCount=%lu, Status=0x%lx\n",
            DriveNumber, SectorNumber, SectorCount, (ULONG)Status);
        ERR("ReadBlocks details: BlockSize=%lu, IoAlign=%lu, Buffer=%p, DiskReadBuffer=%p, MediaId=0x%lx\n",
            BlockSize, IoAlign, Buffer, DiskReadBuffer, (ULONG)BlockIo->Media->MediaId);
        ERR("ReadBlocks media: LastBlock=%llu, LogicalPartition=%s, RemovableMedia=%s\n",
            BlockIo->Media->LastBlock,
            BlockIo->Media->LogicalPartition ? "TRUE" : "FALSE",
            BlockIo->Media->RemovableMedia ? "TRUE" : "FALSE");
        return FALSE;
    }
 
    return TRUE;
}

Referenced by MachInit().

UefiFindAcpiTable()

PDESCRIPTION_HEADER UefiFindAcpiTable

(

_In_ ULONG

Signature

)

Definition at line 94 of file uefihw.c.

{
    UINTN Index, Count;
    PRSDP_DESCRIPTOR Rsdp;
 
    Rsdp = FindAcpiBios();
    if (Rsdp == NULL)
        return NULL;
 
    if ((Rsdp->revision > 0) && (Rsdp->xsdt_physical_address != 0))
    {
        PXSDT Xsdt = (PXSDT)(ULONG_PTR)Rsdp->xsdt_physical_address;
 
        if ((Xsdt != NULL) && (Xsdt->Header.Length >= sizeof(Xsdt->Header)))
        {
            Count = (Xsdt->Header.Length - sizeof(Xsdt->Header)) / sizeof(Xsdt->Tables[0]);
            for (Index = 0; Index < Count; ++Index)
            {
                PDESCRIPTION_HEADER Header =
                    (PDESCRIPTION_HEADER)(ULONG_PTR)Xsdt->Tables[Index].QuadPart;
 
                if ((Header != NULL) && (Header->Signature == Signature))
                    return Header;
            }
        }
    }
 
    if (Rsdp->rsdt_physical_address != 0)
    {
        PRSDT Rsdt = (PRSDT)(ULONG_PTR)Rsdp->rsdt_physical_address;
 
        if ((Rsdt != NULL) && (Rsdt->Header.Length >= sizeof(Rsdt->Header)))
        {
            Count = (Rsdt->Header.Length - sizeof(Rsdt->Header)) / sizeof(Rsdt->Tables[0]);
            for (Index = 0; Index < Count; ++Index)
            {
                PDESCRIPTION_HEADER Header =
                    (PDESCRIPTION_HEADER)(ULONG_PTR)Rsdt->Tables[Index];
 
                if ((Header != NULL) && (Header->Signature == Signature))
                    return Header;
            }
        }
    }
 
    return NULL;
}

Referenced by UefiInitializeBgrtLogo().

UefiGetExtendedBIOSData()

VOID UefiGetExtendedBIOSData	(	PULONG	ExtendedBIOSDataArea,
		PULONG	ExtendedBIOSDataSize
	)

Definition at line 32 of file stubs.c.

{
 
}

Referenced by MachInit().

UefiGetFloppyCount()

UCHAR UefiGetFloppyCount

(

VOID

)

Definition at line 1109 of file uefidisk.c.

{
    /* No floppy support in UEFI */
    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 326 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 buses */
    DetectInternal(SystemKey, &BusNumber);
    // TODO: DetectPciBios
    DetectAcpiBios(SystemKey, &BusNumber);
 
    TRACE("DetectHardware() Done\n");
    return SystemKey;
}

Referenced by MachInit().

UefiHwIdle()

VOID UefiHwIdle

(

VOID

)

Definition at line 38 of file uefihw.c.

{
    UINTN Index;
    EFI_STATUS Status;
    EFI_BOOT_SERVICES *BootServices = GlobalSystemTable->BootServices;
 
    /* Keep one timer event around and arm it each idle tick */
    if (IdleTimerEvent == NULL)
    {
        Status = BootServices->CreateEvent(EVT_TIMER,
                                           TPL_APPLICATION,
                                           NULL,
                                           NULL,
                                           &IdleTimerEvent);
        if (EFI_ERROR(Status))
        {
            StallExecutionProcessor(10000); /* 10 ms fallback */
            return;
        }
    }
 
    /* Set a 10ms (100,000 * 100ns) relative timer */
    Status = BootServices->SetTimer(IdleTimerEvent, TimerRelative, 100000);
    if (!EFI_ERROR(Status))
        Status = BootServices->WaitForEvent(1, &IdleTimerEvent, &Index);
    if (EFI_ERROR(Status))
        StallExecutionProcessor(10000); /* 10 ms fallback */
}

Referenced by MachInit().

UefiInitializeBootDevices()

BOOLEAN UefiInitializeBootDevices

(

VOID

)

Definition at line 1040 of file uefidisk.c.

{
    EFI_BLOCK_IO* BlockIo;
    EFI_STATUS Status;
    ULONG ArcDriveIndex;
 
    DiskReadBufferSize = EFI_PAGE_SIZE;
    DiskReadBuffer = NULL;
    DiskReadBufferRaw = NULL;
    DiskReadBufferAlignment = 1;
    DiskReadBufferFromPool = FALSE;
    if (!UefiEnsureDiskReadBufferAligned(1))
    {
        ERR("Failed to allocate disk read buffer\n");
        return FALSE;
    }
 
    UefiSetupBlockDevices();
 
    if (PcBiosDiskCount == 0)
    {
        ERR("No block devices found\n");
        return FALSE;
    }
 
    if (!UefiSetBootpath())
    {
        ERR("Failed to set boot path\n");
        return FALSE;
    }
 
    /* Handle CD-ROM boot device registration */
    ArcDriveIndex = PublicBootArcDisk;
    if (ArcDriveIndex >= PcBiosDiskCount || InternalUefiDisk == NULL)
    {
        ERR("Invalid boot arc disk index\n");
        return FALSE;
    }
 
    Status = GlobalSystemTable->BootServices->HandleProtocol(
        InternalUefiDisk[ArcDriveIndex].Handle,
        &BlockIoGuid,
        (VOID**)&BlockIo);
 
    if (EFI_ERROR(Status) || BlockIo == NULL)
    {
        ERR("Failed to get Block I/O protocol\n");
        return FALSE;
    }
 
    if (BlockIo->Media->RemovableMedia == TRUE && BlockIo->Media->BlockSize == 2048)
    {
        ARC_STATUS Status;
 
        DiskReportError(FALSE);
        Status = DiskInitialize(FrldrBootDrive, FrLdrBootPath, CdromController,
                                &UefiDiskVtbl, NULL, NULL, NULL);
        DiskReportError(TRUE);
 
        if (Status == ESUCCESS)
            TRACE("Registered CD-ROM boot device: 0x%02X\n", FrldrBootDrive);
        else
            ERR("CD-ROM boot device 0x%02X failed\n", 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 620 of file uefivid.c.

{
    EFI_STATUS Status;
 
    /* First, try GOP */
    Status = UefiInitializeGop();
    if (Status == EFI_SUCCESS)
        return Status;
 
    /* Try Apple Graphics Info if that fails */
    TRACE("Failed to detect GOP, trying Apple Graphics Info\n");
    Status = UefiInitializeAppleGraphics();
    if (Status == EFI_SUCCESS)
        return Status;
 
    /* We didn't find GOP or Apple Graphics Info, probably a UGA-only system */
    ERR("Cannot find framebuffer!\n");
    return Status;
}

Referenced by MachInit().

UefiMemGetMemoryMap()

PFREELDR_MEMORY_DESCRIPTOR UefiMemGetMemoryMap

(

ULONG *

MemoryMapSize

)

Definition at line 144 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;
            }
        }
 
        /* 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 39 of file stubs.c.

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

Referenced by MachInit().

UefiPrepareForReactOS()

VOID UefiPrepareForReactOS

(

VOID

)

Definition at line 272 of file uefimem.c.

{
    _exituefi();
}

Referenced by MachInit().

UefiVideoClearScreen()

VOID UefiVideoClearScreen

(

UCHAR

Attr

)

Definition at line 642 of file uefivid.c.

{
    FbConsClearScreen(Attr);
}

Referenced by MachInit().

UefiVideoCopyOffScreenBufferToVRAM()

VOID UefiVideoCopyOffScreenBufferToVRAM

(

PVOID

Buffer

)

Definition at line 673 of file uefivid.c.

{
    FbConsCopyOffScreenBufferToVRAM(Buffer);
    UefiDrawBgrtLogo();
}

Referenced by MachInit().

UefiVideoGetBufferSize()

ULONG UefiVideoGetBufferSize

(

VOID

)

Definition at line 667 of file uefivid.c.

{
    return FbConsGetBufferSize();
}

Referenced by MachInit().

UefiVideoGetDisplaySize()

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

Definition at line 654 of file uefivid.c.

{
    FbConsGetDisplaySize(Width, Height, Depth);
}

Referenced by MachInit(), and UefiConsPutChar().

UefiVideoGetFontsFromFirmware()

VOID UefiVideoGetFontsFromFirmware

(

PULONG

RomFontPointers

)

Definition at line 20 of file stubs.c.

{
 
}

Referenced by MachInit().

UefiVideoGetPaletteColor()

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

Definition at line 705 of file uefivid.c.

{
    /* Not supported */
}

Referenced by MachInit().

UefiVideoHideShowTextCursor()

VOID UefiVideoHideShowTextCursor

(

BOOLEAN

Show

)

Definition at line 686 of file uefivid.c.

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

Referenced by MachInit().

UefiVideoIsPaletteFixed()

BOOLEAN UefiVideoIsPaletteFixed

(

VOID

)

Definition at line 692 of file uefivid.c.

{
    return 0;
}

Referenced by MachInit().

UefiVideoPutChar()

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

Definition at line 648 of file uefivid.c.

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

Referenced by MachInit(), and UefiConsPutChar().

UefiVideoSetDisplayMode()

VIDEODISPLAYMODE UefiVideoSetDisplayMode	(	PCSTR	DisplayMode,
		BOOLEAN	Init
	)

Definition at line 660 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 698 of file uefivid.c.

{
    /* Not supported */
}

Referenced by MachInit().

UefiVideoSetTextCursorPosition()

VOID UefiVideoSetTextCursorPosition	(	UCHAR	X,
		UCHAR	Y
	)

Definition at line 680 of file uefivid.c.

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

Referenced by MachInit().

UefiVideoSync()

VOID UefiVideoSync

(

VOID

)

Definition at line 26 of file stubs.c.

{
 
}

Referenced by MachInit().