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 1563 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 1513 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 1378 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().

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 1371 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 245 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 51 of file stubs.c.

{
 
}

Referenced by MachInit().

UefiInitializeBootDevices()

BOOLEAN UefiInitializeBootDevices

(

VOID

)

Definition at line 1282 of file uefidisk.c.

{
    EFI_BLOCK_IO* BlockIo;
    EFI_STATUS Status;
    ULONG ArcDriveIndex;
    PMASTER_BOOT_RECORD Mbr;
    PULONG Buffer;
    ULONG Checksum = 0;
    ULONG Signature;
    ULONG i;
 
    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)
    {
        /* Read the MBR from CD-ROM (sector 16) */
        if (!MachDiskReadLogicalSectors(FrldrBootDrive, 16ULL, 1, DiskReadBuffer))
        {
            ERR("Reading MBR from CD-ROM failed\n");
            return FALSE;
        }
 
        Buffer = (ULONG*)DiskReadBuffer;
        Mbr = (PMASTER_BOOT_RECORD)DiskReadBuffer;
 
        Signature = Mbr->Signature;
        TRACE("CD-ROM Signature: %x\n", Signature);
 
        /* Calculate the MBR checksum */
        for (i = 0; i < 2048 / sizeof(ULONG); i++)
        {
            Checksum += Buffer[i];
        }
        Checksum = ~Checksum + 1;
        TRACE("CD-ROM Checksum: %x\n", Checksum);
 
        /* Fill out the ARC disk block */
        AddReactOSArcDiskInfo(FrLdrBootPath, Signature, Checksum, TRUE);
 
        FsRegisterDevice(FrLdrBootPath, &UefiDiskVtbl);
        TRACE("Registered CD-ROM boot device: 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 56 of file uefivid.c.

{
    EFI_STATUS Status;
    EFI_GRAPHICS_OUTPUT_PROTOCOL* gop = NULL;
 
    EFI_GRAPHICS_PIXEL_FORMAT PixelFormat;
    EFI_PIXEL_BITMASK* pPixelBitmask;
    ULONG BitsPerPixel;
 
    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 UEFI GOP format %lu\n", PixelFormat);
            pPixelBitmask = NULL;
            BitsPerPixel = 0;
            break;
        }
    }
 
    VramAddress = (ULONG_PTR)gop->Mode->FrameBufferBase;
    VramSize = gop->Mode->FrameBufferSize;
    if (!VidFbInitializeVideo(&FrameBufferData,
                              VramAddress,
                              VramSize,
                              gop->Mode->Info->HorizontalResolution,
                              gop->Mode->Info->VerticalResolution,
                              gop->Mode->Info->PixelsPerScanLine,
                              BitsPerPixel,
                              (PPIXEL_BITMASK)pPixelBitmask))
    {
        ERR("Couldn't initialize video framebuffer\n");
        Status = EFI_UNSUPPORTED;
    }
    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 132 of file uefivid.c.

{
    FbConsClearScreen(Attr);
}

Referenced by MachInit().

UefiVideoCopyOffScreenBufferToVRAM()

VOID UefiVideoCopyOffScreenBufferToVRAM

(

PVOID

Buffer

)

Definition at line 163 of file uefivid.c.

{
    FbConsCopyOffScreenBufferToVRAM(Buffer);
}

Referenced by MachInit().

UefiVideoGetBufferSize()

ULONG UefiVideoGetBufferSize

(

VOID

)

Definition at line 157 of file uefivid.c.

{
    return FbConsGetBufferSize();
}

Referenced by MachInit().

UefiVideoGetDisplaySize()

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

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

{
    /* Not supported */
}

Referenced by MachInit().

UefiVideoHideShowTextCursor()

VOID UefiVideoHideShowTextCursor

(

BOOLEAN

Show

)

Definition at line 175 of file uefivid.c.

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

Referenced by MachInit().

UefiVideoIsPaletteFixed()

BOOLEAN UefiVideoIsPaletteFixed

(

VOID

)

Definition at line 181 of file uefivid.c.

{
    return 0;
}

Referenced by MachInit().

UefiVideoPutChar()

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

Definition at line 138 of file uefivid.c.

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

Referenced by MachInit(), and UefiConsPutChar().

UefiVideoSetDisplayMode()

VIDEODISPLAYMODE UefiVideoSetDisplayMode	(	PCSTR	DisplayMode,
		BOOLEAN	Init
	)

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

{
    /* Not supported */
}

Referenced by MachInit().

UefiVideoSetTextCursorPosition()

VOID UefiVideoSetTextCursorPosition	(	UCHAR	X,
		UCHAR	Y
	)

Definition at line 169 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().