mirror of https://github.com/acidanthera/audk.git
2842 lines
64 KiB
C
2842 lines
64 KiB
C
/*++
|
|
|
|
Copyright (c) 2006 - 2007, Intel Corporation
|
|
All rights reserved. This program and the accompanying materials
|
|
are licensed and made available under the terms and conditions of the BSD License
|
|
which accompanies this distribution. The full text of the license may be found at
|
|
http://opensource.org/licenses/bsd-license.php
|
|
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
|
|
Module Name:
|
|
|
|
DxeMain.h
|
|
|
|
Abstract:
|
|
|
|
Revision History
|
|
|
|
--*/
|
|
|
|
#ifndef _DXE_MAIN_H_
|
|
#define _DXE_MAIN_H_
|
|
|
|
|
|
|
|
#include <PiDxe.h>
|
|
#include <FrameworkPei.h>
|
|
|
|
#include <Protocol/LoadedImage.h>
|
|
#include <Protocol/GuidedSectionExtraction.h>
|
|
#include <Protocol/SectionExtraction.h>
|
|
#include <Guid/DebugImageInfoTable.h>
|
|
#include <Protocol/DevicePath.h>
|
|
#include <Protocol/Runtime.h>
|
|
#include <Protocol/LoadFile.h>
|
|
#include <Protocol/DriverBinding.h>
|
|
#include <Protocol/VariableWrite.h>
|
|
#include <Protocol/PlatformDriverOverride.h>
|
|
#include <Protocol/Variable.h>
|
|
#include <Guid/MemoryTypeInformation.h>
|
|
#include <Guid/FirmwareFileSystem2.h>
|
|
#include <Guid/HobList.h>
|
|
#include <Protocol/Timer.h>
|
|
#include <Protocol/SimpleFileSystem.h>
|
|
#include <Protocol/Bds.h>
|
|
#include <Guid/FileInfo.h>
|
|
#include <Protocol/RealTimeClock.h>
|
|
#include <Guid/Apriori.h>
|
|
#include <Protocol/WatchdogTimer.h>
|
|
#include <Protocol/FirmwareVolume.h>
|
|
#include <Protocol/MonotonicCounter.h>
|
|
#include <Guid/DxeServices.h>
|
|
#include <Guid/MemoryAllocationHob.h>
|
|
#include <Protocol/StatusCode.h>
|
|
#include <Protocol/CustomizedDecompress.h>
|
|
#include <Protocol/Decompress.h>
|
|
#include <Protocol/LoadPe32Image.h>
|
|
#include <Protocol/FirmwareVolumeDispatch.h>
|
|
#include <Protocol/Security.h>
|
|
#include <Protocol/Ebc.h>
|
|
#include <Guid/EventLegacyBios.h>
|
|
#include <Protocol/Reset.h>
|
|
#include <Protocol/EdkDecompress.h>
|
|
#include <Protocol/Cpu.h>
|
|
#include <Guid/EventGroup.h>
|
|
#include <Protocol/Metronome.h>
|
|
#include <Protocol/FirmwareVolumeBlock.h>
|
|
#include <Protocol/Capsule.h>
|
|
#include <Protocol/BusSpecificDriverOverride.h>
|
|
#include <Protocol/Performance.h>
|
|
#include <Guid/StatusCodeDataTypeId.h>
|
|
|
|
#include <Library/DxeCoreEntryPoint.h>
|
|
#include <Library/DebugLib.h>
|
|
#include <Library/UefiLib.h>
|
|
#include <Library/BaseLib.h>
|
|
#include <Library/HobLib.h>
|
|
#include <Library/PerformanceLib.h>
|
|
#include <Library/UefiDecompressLib.h>
|
|
#include <Library/CustomDecompressLib.h>
|
|
#include <Library/PeCoffLoaderLib.h>
|
|
#include <Library/CacheMaintenanceLib.h>
|
|
#include <Library/BaseMemoryLib.h>
|
|
|
|
#include "DebugImageInfo.h"
|
|
#include "Library.h"
|
|
#include "FwVolBlock.h"
|
|
#include "FwVolDriver.h"
|
|
#include "gcd.h"
|
|
#include "imem.h"
|
|
#include "Image.h"
|
|
#include "Exec.h"
|
|
#include "hand.h"
|
|
|
|
|
|
//
|
|
// Modifier for EFI DXE Services
|
|
//
|
|
#define EFI_DXESERVICE
|
|
|
|
//
|
|
// attributes for reserved memory before it is promoted to system memory
|
|
//
|
|
#define EFI_MEMORY_PRESENT 0x0100000000000000ULL
|
|
#define EFI_MEMORY_INITIALIZED 0x0200000000000000ULL
|
|
#define EFI_MEMORY_TESTED 0x0400000000000000ULL
|
|
|
|
//
|
|
// range for memory mapped port I/O on IPF
|
|
//
|
|
#define EFI_MEMORY_PORT_IO 0x4000000000000000ULL
|
|
|
|
|
|
///
|
|
/// EFI_DEP_REPLACE_TRUE - Used to dynamically patch the dependecy expression
|
|
/// to save time. A EFI_DEP_PUSH is evauated one an
|
|
/// replaced with EFI_DEP_REPLACE_TRUE
|
|
///
|
|
#define EFI_DEP_REPLACE_TRUE 0xff
|
|
|
|
///
|
|
/// Define the initial size of the dependency expression evaluation stack
|
|
///
|
|
#define DEPEX_STACK_SIZE_INCREMENT 0x1000
|
|
|
|
typedef struct {
|
|
EFI_GUID *ProtocolGuid;
|
|
VOID **Protocol;
|
|
EFI_EVENT Event;
|
|
VOID *Registration;
|
|
BOOLEAN Present;
|
|
} ARCHITECTURAL_PROTOCOL_ENTRY;
|
|
|
|
|
|
//
|
|
// DXE Dispatcher Data structures
|
|
//
|
|
|
|
#define KNOWN_HANDLE_SIGNATURE EFI_SIGNATURE_32('k','n','o','w')
|
|
typedef struct {
|
|
UINTN Signature;
|
|
LIST_ENTRY Link; // mFvHandleList
|
|
EFI_HANDLE Handle;
|
|
} KNOWN_HANDLE;
|
|
|
|
|
|
#define EFI_CORE_DRIVER_ENTRY_SIGNATURE EFI_SIGNATURE_32('d','r','v','r')
|
|
typedef struct {
|
|
UINTN Signature;
|
|
LIST_ENTRY Link; // mDriverList
|
|
|
|
LIST_ENTRY ScheduledLink; // mScheduledQueue
|
|
|
|
EFI_HANDLE FvHandle;
|
|
EFI_GUID FileName;
|
|
EFI_DEVICE_PATH_PROTOCOL *FvFileDevicePath;
|
|
EFI_FIRMWARE_VOLUME_PROTOCOL *Fv;
|
|
|
|
VOID *Depex;
|
|
UINTN DepexSize;
|
|
|
|
BOOLEAN Before;
|
|
BOOLEAN After;
|
|
EFI_GUID BeforeAfterGuid;
|
|
|
|
BOOLEAN Dependent;
|
|
BOOLEAN Unrequested;
|
|
BOOLEAN Scheduled;
|
|
BOOLEAN Untrusted;
|
|
BOOLEAN Initialized;
|
|
BOOLEAN DepexProtocolError;
|
|
|
|
EFI_HANDLE ImageHandle;
|
|
|
|
} EFI_CORE_DRIVER_ENTRY;
|
|
|
|
//
|
|
//The data structure of GCD memory map entry
|
|
//
|
|
#define EFI_GCD_MAP_SIGNATURE EFI_SIGNATURE_32('g','c','d','m')
|
|
typedef struct {
|
|
UINTN Signature;
|
|
LIST_ENTRY Link;
|
|
EFI_PHYSICAL_ADDRESS BaseAddress;
|
|
UINT64 EndAddress;
|
|
UINT64 Capabilities;
|
|
UINT64 Attributes;
|
|
EFI_GCD_MEMORY_TYPE GcdMemoryType;
|
|
EFI_GCD_IO_TYPE GcdIoType;
|
|
EFI_HANDLE ImageHandle;
|
|
EFI_HANDLE DeviceHandle;
|
|
} EFI_GCD_MAP_ENTRY;
|
|
|
|
//
|
|
// DXE Core Global Variables
|
|
//
|
|
extern EFI_SYSTEM_TABLE *gDxeCoreST;
|
|
extern EFI_BOOT_SERVICES *gDxeCoreBS;
|
|
extern EFI_RUNTIME_SERVICES *gDxeCoreRT;
|
|
extern EFI_DXE_SERVICES *gDxeCoreDS;
|
|
extern EFI_HANDLE gDxeCoreImageHandle;
|
|
|
|
extern EFI_DECOMPRESS_PROTOCOL gEfiDecompress;
|
|
extern EFI_PEI_PE_COFF_LOADER_PROTOCOL *gEfiPeiPeCoffLoader;
|
|
|
|
extern EFI_RUNTIME_ARCH_PROTOCOL *gRuntime;
|
|
extern EFI_CPU_ARCH_PROTOCOL *gCpu;
|
|
extern EFI_WATCHDOG_TIMER_ARCH_PROTOCOL *gWatchdogTimer;
|
|
extern EFI_METRONOME_ARCH_PROTOCOL *gMetronome;
|
|
extern EFI_TIMER_ARCH_PROTOCOL *gTimer;
|
|
extern EFI_SECURITY_ARCH_PROTOCOL *gSecurity;
|
|
extern EFI_BDS_ARCH_PROTOCOL *gBds;
|
|
extern EFI_STATUS_CODE_PROTOCOL *gStatusCode;
|
|
|
|
extern EFI_TPL gEfiCurrentTpl;
|
|
|
|
extern EFI_GUID *gDxeCoreFileName;
|
|
extern EFI_LOADED_IMAGE_PROTOCOL *gDxeCoreLoadedImage;
|
|
|
|
extern EFI_MEMORY_TYPE_INFORMATION gMemoryTypeInformation[EfiMaxMemoryType + 1];
|
|
|
|
extern BOOLEAN gDispatcherRunning;
|
|
extern EFI_RUNTIME_ARCH_PROTOCOL gRuntimeTemplate;
|
|
|
|
//
|
|
// Service Initialization Functions
|
|
//
|
|
|
|
|
|
VOID
|
|
CoreInitializePool (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called to initialize the pool.
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Returns:
|
|
|
|
None
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
CoreAddMemoryDescriptor (
|
|
IN EFI_MEMORY_TYPE Type,
|
|
IN EFI_PHYSICAL_ADDRESS Start,
|
|
IN UINT64 NumberOfPages,
|
|
IN UINT64 Attribute
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called to initialize the memory map and add descriptors to
|
|
the current descriptor list.
|
|
|
|
The first descriptor that is added must be general usable
|
|
memory as the addition allocates heap.
|
|
|
|
Arguments:
|
|
|
|
Type - The type of memory to add
|
|
|
|
Start - The starting address in the memory range
|
|
Must be page aligned
|
|
|
|
NumberOfPages - The number of pages in the range
|
|
|
|
Attribute - Attributes of the memory to add
|
|
|
|
Returns:
|
|
|
|
None. The range is added to the memory map
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
CoreReleaseGcdMemoryLock (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Release memory lock on mGcdMemorySpaceLock
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Returns:
|
|
None
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
CoreAcquireGcdMemoryLock (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Acquire memory lock on mGcdMemorySpaceLock
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Returns:
|
|
None
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreInitializeMemoryServices (
|
|
IN VOID **HobStart,
|
|
IN EFI_PHYSICAL_ADDRESS *MemoryBaseAddress,
|
|
IN UINT64 *MemoryLength
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
External function. Initializes the GCD and memory services based on the memory
|
|
descriptor HOBs. This function is responsible for priming the GCD map and the
|
|
memory map, so memory allocations and resource allocations can be made. The first
|
|
part of this function can not depend on any memory services until at least one
|
|
memory descriptor is provided to the memory services. Then the memory services
|
|
can be used to intialize the GCD map.
|
|
|
|
Arguments:
|
|
|
|
HobStart - The start address of the HOB.
|
|
|
|
MemoryBaseAddress - Start address of memory region found to init DXE core.
|
|
|
|
MemoryLength - Length of memory region found to init DXE core.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - Memory services successfully initialized.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
CoreInitializeGcdServices (
|
|
IN VOID **HobStart,
|
|
IN EFI_PHYSICAL_ADDRESS MemoryBaseAddress,
|
|
IN UINT64 MemoryLength
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
External function. Initializes the GCD and memory services based on the memory
|
|
descriptor HOBs. This function is responsible for priming the GCD map and the
|
|
memory map, so memory allocations and resource allocations can be made. The first
|
|
part of this function can not depend on any memory services until at least one
|
|
memory descriptor is provided to the memory services. Then the memory services
|
|
can be used to intialize the GCD map.
|
|
|
|
Arguments:
|
|
|
|
HobStart - The start address of the HOB
|
|
|
|
MemoryBaseAddress - Start address of memory region found to init DXE core.
|
|
|
|
MemoryLength - Length of memory region found to init DXE core.
|
|
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - GCD services successfully initialized.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreInitializeEventServices (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initializes "event" support and populates parts of the System and Runtime Table.
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - Always return success
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreInitializeImageServices (
|
|
IN VOID *HobStart
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Add the Image Services to EFI Boot Services Table and install the protocol
|
|
interfaces for this image.
|
|
|
|
Arguments:
|
|
|
|
HobStart - The HOB to initialize
|
|
|
|
Returns:
|
|
|
|
Status code.
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
CoreNotifyOnArchProtocolInstallation (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Creates an event that is fired everytime a Protocol of a specific type is installed
|
|
|
|
Arguments:
|
|
NONE
|
|
|
|
Returns:
|
|
NONE
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreAllEfiServicesAvailable (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Return TRUE if all AP services are availible.
|
|
|
|
Arguments:
|
|
NONE
|
|
|
|
Returns:
|
|
EFI_SUCCESS - All AP services are available
|
|
EFI_NOT_FOUND - At least one AP service is not available
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
CalculateEfiHdrCrc (
|
|
IN OUT EFI_TABLE_HEADER *Hdr
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Calcualte the 32-bit CRC in a EFI table using the service provided by the
|
|
gRuntime service.
|
|
|
|
Arguments:
|
|
|
|
Hdr - Pointer to an EFI standard header
|
|
|
|
Returns:
|
|
|
|
None
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
EFIAPI
|
|
CoreTimerTick (
|
|
IN UINT64 Duration
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called by the platform code to process a tick.
|
|
|
|
Arguments:
|
|
|
|
Duration - The number of 100ns elasped since the last call to TimerTick
|
|
|
|
Returns:
|
|
|
|
None
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
CoreInitializeDispatcher (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initialize the dispatcher. Initialize the notification function that runs when
|
|
a FV protocol is added to the system.
|
|
|
|
Arguments:
|
|
|
|
NONE
|
|
|
|
Returns:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
;
|
|
|
|
BOOLEAN
|
|
CoreIsSchedulable (
|
|
IN EFI_CORE_DRIVER_ENTRY *DriverEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the POSTFIX version of the dependency evaluator. This code does
|
|
not need to handle Before or After, as it is not valid to call this
|
|
routine in this case. The SOR is just ignored and is a nop in the grammer.
|
|
|
|
POSTFIX means all the math is done on top of the stack.
|
|
|
|
Arguments:
|
|
|
|
DriverEntry - DriverEntry element to update
|
|
|
|
Returns:
|
|
|
|
TRUE - If driver is ready to run.
|
|
|
|
FALSE - If driver is not ready to run or some fatal error was found.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CorePreProcessDepex (
|
|
IN EFI_CORE_DRIVER_ENTRY *DriverEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Preprocess dependency expression and update DriverEntry to reflect the
|
|
state of Before, After, and SOR dependencies. If DriverEntry->Before
|
|
or DriverEntry->After is set it will never be cleared. If SOR is set
|
|
it will be cleared by CoreSchedule(), and then the driver can be
|
|
dispatched.
|
|
|
|
Arguments:
|
|
|
|
DriverEntry - DriverEntry element to update
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - It always works.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreExitBootServices (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN UINTN MapKey
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
EFI 1.0 API to terminate Boot Services
|
|
|
|
Arguments:
|
|
|
|
ImageHandle - Handle that represents the identity of the calling image
|
|
|
|
MapKey -Key to the latest memory map.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - Boot Services terminated
|
|
EFI_INVALID_PARAMETER - MapKey is incorrect.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreTerminateMemoryMap (
|
|
IN UINTN MapKey
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Make sure the memory map is following all the construction rules,
|
|
it is the last time to check memory map error before exit boot services.
|
|
|
|
Arguments:
|
|
|
|
MapKey - Memory map key
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Memory map not consistent with construction rules.
|
|
|
|
EFI_SUCCESS - Valid memory map.
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
CoreNotifySignalList (
|
|
IN EFI_GUID *EventGroup
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Signals all events on the requested list
|
|
|
|
Arguments:
|
|
|
|
SignalType - The list to signal
|
|
|
|
Returns:
|
|
|
|
None
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreInstallConfigurationTable (
|
|
IN EFI_GUID *Guid,
|
|
IN VOID *Table
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Boot Service called to add, modify, or remove a system configuration table from
|
|
the EFI System Table.
|
|
|
|
Arguments:
|
|
|
|
Guid: Pointer to the GUID for the entry to add, update, or remove
|
|
Table: Pointer to the configuration table for the entry to add, update, or
|
|
remove, may be NULL.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS Guid, Table pair added, updated, or removed.
|
|
EFI_INVALID_PARAMETER Input GUID not valid.
|
|
EFI_NOT_FOUND Attempted to delete non-existant entry
|
|
EFI_OUT_OF_RESOURCES Not enough memory available
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_TPL
|
|
EFIAPI
|
|
CoreRaiseTpl (
|
|
IN EFI_TPL NewTpl
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Raise the task priority level to the new level.
|
|
High level is implemented by disabling processor interrupts.
|
|
|
|
Arguments:
|
|
|
|
NewTpl - New task priority level
|
|
|
|
Returns:
|
|
|
|
The previous task priority level
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
VOID
|
|
EFIAPI
|
|
CoreRestoreTpl (
|
|
IN EFI_TPL NewTpl
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Lowers the task priority to the previous value. If the new
|
|
priority unmasks events at a higher priority, they are dispatched.
|
|
|
|
Arguments:
|
|
|
|
NewTpl - New, lower, task priority
|
|
|
|
Returns:
|
|
|
|
None
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreStall (
|
|
IN UINTN Microseconds
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Introduces a fine-grained stall.
|
|
|
|
Arguments:
|
|
|
|
Microseconds The number of microseconds to stall execution
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - Execution was stalled for at least the requested amount
|
|
of microseconds.
|
|
|
|
EFI_NOT_AVAILABLE_YET - gMetronome is not available yet
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreSetWatchdogTimer (
|
|
IN UINTN Timeout,
|
|
IN UINT64 WatchdogCode,
|
|
IN UINTN DataSize,
|
|
IN CHAR16 *WatchdogData OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sets the system's watchdog timer.
|
|
|
|
Arguments:
|
|
|
|
Timeout The number of seconds. Zero disables the timer.
|
|
|
|
///////following three parameters are left for platform specific using
|
|
|
|
WatchdogCode The numberic code to log. 0x0 to 0xffff are firmware
|
|
DataSize Size of the optional data
|
|
WatchdogData Optional Null terminated unicode string followed by binary
|
|
data.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS Timeout has been set
|
|
EFI_NOT_AVAILABLE_YET WatchdogTimer is not available yet
|
|
EFI_UNSUPPORTED System does not have a timer (currently not used)
|
|
EFI_DEVICE_ERROR Could not complete due to hardware error
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreInstallProtocolInterface (
|
|
IN OUT EFI_HANDLE *UserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
IN EFI_INTERFACE_TYPE InterfaceType,
|
|
IN VOID *Interface
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Wrapper function to CoreInstallProtocolInterfaceNotify. This is the public API which
|
|
Calls the private one which contains a BOOLEAN parameter for notifications
|
|
|
|
Arguments:
|
|
|
|
UserHandle - The handle to install the protocol handler on,
|
|
or NULL if a new handle is to be allocated
|
|
|
|
Protocol - The protocol to add to the handle
|
|
|
|
InterfaceType - Indicates whether Interface is supplied in native form.
|
|
|
|
Interface - The interface for the protocol being added
|
|
|
|
Returns:
|
|
|
|
Status code
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreInstallProtocolInterfaceNotify (
|
|
IN OUT EFI_HANDLE *UserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
IN EFI_INTERFACE_TYPE InterfaceType,
|
|
IN VOID *Interface,
|
|
IN BOOLEAN Notify
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Installs a protocol interface into the boot services environment.
|
|
|
|
Arguments:
|
|
|
|
UserHandle - The handle to install the protocol handler on,
|
|
or NULL if a new handle is to be allocated
|
|
|
|
Protocol - The protocol to add to the handle
|
|
|
|
InterfaceType - Indicates whether Interface is supplied in native form.
|
|
|
|
Interface - The interface for the protocol being added
|
|
|
|
Notify - Whether to notify the notification list for this protocol
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Invalid parameter
|
|
|
|
EFI_OUT_OF_RESOURCES - No enough buffer to allocate
|
|
|
|
EFI_SUCCESS - Protocol interface successfully installed
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreInstallMultipleProtocolInterfaces (
|
|
IN OUT EFI_HANDLE *Handle,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Installs a list of protocol interface into the boot services environment.
|
|
This function calls InstallProtocolInterface() in a loop. If any error
|
|
occures all the protocols added by this function are removed. This is
|
|
basically a lib function to save space.
|
|
|
|
Arguments:
|
|
|
|
Handle - The handle to install the protocol handlers on,
|
|
or NULL if a new handle is to be allocated
|
|
... - EFI_GUID followed by protocol instance. A NULL terminates the
|
|
list. The pairs are the arguments to InstallProtocolInterface().
|
|
All the protocols are added to Handle.
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Handle is NULL.
|
|
|
|
EFI_SUCCESS - Protocol interfaces successfully installed.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreUninstallMultipleProtocolInterfaces (
|
|
IN EFI_HANDLE Handle,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Uninstalls a list of protocol interface in the boot services environment.
|
|
This function calls UnisatllProtocolInterface() in a loop. This is
|
|
basically a lib function to save space.
|
|
|
|
Arguments:
|
|
|
|
Handle - The handle to uninstall the protocol
|
|
|
|
... - EFI_GUID followed by protocol instance. A NULL terminates the
|
|
list. The pairs are the arguments to UninstallProtocolInterface().
|
|
All the protocols are added to Handle.
|
|
|
|
Returns:
|
|
|
|
Status code
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreReinstallProtocolInterface (
|
|
IN EFI_HANDLE UserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
IN VOID *OldInterface,
|
|
IN VOID *NewInterface
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Reinstall a protocol interface on a device handle. The OldInterface for Protocol is replaced by the NewInterface.
|
|
|
|
Arguments:
|
|
|
|
UserHandle - Handle on which the interface is to be reinstalled
|
|
Protocol - The numeric ID of the interface
|
|
OldInterface - A pointer to the old interface
|
|
NewInterface - A pointer to the new interface
|
|
|
|
|
|
Returns:
|
|
|
|
Status code.
|
|
|
|
On EFI_SUCCESS The protocol interface was installed
|
|
On EFI_NOT_FOUND The OldInterface on the handle was not found
|
|
On EFI_INVALID_PARAMETER One of the parameters has an invalid value
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreUninstallProtocolInterface (
|
|
IN EFI_HANDLE UserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
IN VOID *Interface
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Uninstalls all instances of a protocol:interfacer from a handle.
|
|
If the last protocol interface is remove from the handle, the
|
|
handle is freed.
|
|
|
|
Arguments:
|
|
|
|
UserHandle - The handle to remove the protocol handler from
|
|
|
|
Protocol - The protocol, of protocol:interface, to remove
|
|
|
|
Interface - The interface, of protocol:interface, to remove
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Protocol is NULL.
|
|
|
|
EFI_SUCCESS - Protocol interface successfully uninstalled.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreHandleProtocol (
|
|
IN EFI_HANDLE UserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
OUT VOID **Interface
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Queries a handle to determine if it supports a specified protocol.
|
|
|
|
Arguments:
|
|
|
|
UserHandle - The handle being queried.
|
|
|
|
Protocol - The published unique identifier of the protocol.
|
|
|
|
Interface - Supplies the address where a pointer to the corresponding Protocol
|
|
Interface is returned.
|
|
|
|
Returns:
|
|
|
|
The requested protocol interface for the handle
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreOpenProtocol (
|
|
IN EFI_HANDLE UserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
OUT VOID **Interface OPTIONAL,
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_HANDLE ControllerHandle,
|
|
IN UINT32 Attributes
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Locates the installed protocol handler for the handle, and
|
|
invokes it to obtain the protocol interface. Usage information
|
|
is registered in the protocol data base.
|
|
|
|
Arguments:
|
|
|
|
UserHandle - The handle to obtain the protocol interface on
|
|
|
|
Protocol - The ID of the protocol
|
|
|
|
Interface - The location to return the protocol interface
|
|
|
|
ImageHandle - The handle of the Image that is opening the protocol interface
|
|
specified by Protocol and Interface.
|
|
|
|
ControllerHandle - The controller handle that is requiring this interface.
|
|
|
|
Attributes - The open mode of the protocol interface specified by Handle
|
|
and Protocol.
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Protocol is NULL.
|
|
|
|
EFI_SUCCESS - Get the protocol interface.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreOpenProtocolInformation (
|
|
IN EFI_HANDLE UserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
OUT EFI_OPEN_PROTOCOL_INFORMATION_ENTRY **EntryBuffer,
|
|
OUT UINTN *EntryCount
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Return information about Opened protocols in the system
|
|
|
|
Arguments:
|
|
|
|
UserHandle - The handle to close the protocol interface on
|
|
|
|
Protocol - The ID of the protocol
|
|
|
|
EntryBuffer - A pointer to a buffer of open protocol information in the form of
|
|
EFI_OPEN_PROTOCOL_INFORMATION_ENTRY structures.
|
|
|
|
EntryCount - Number of EntryBuffer entries
|
|
|
|
Returns:
|
|
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreCloseProtocol (
|
|
IN EFI_HANDLE UserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_HANDLE ControllerHandle
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Close Protocol
|
|
|
|
Arguments:
|
|
|
|
UserHandle - The handle to close the protocol interface on
|
|
|
|
Protocol - The ID of the protocol
|
|
|
|
ImageHandle - The user of the protocol to close
|
|
|
|
ControllerHandle - The user of the protocol to close
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Protocol is NULL.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreProtocolsPerHandle (
|
|
IN EFI_HANDLE UserHandle,
|
|
OUT EFI_GUID ***ProtocolBuffer,
|
|
OUT UINTN *ProtocolBufferCount
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the list of protocol interface GUIDs that are installed on a handle in a buffer allocated
|
|
from pool.
|
|
|
|
Arguments:
|
|
|
|
UserHandle - The handle from which to retrieve the list of protocol interface
|
|
GUIDs.
|
|
|
|
ProtocolBuffer - A pointer to the list of protocol interface GUID pointers that are
|
|
installed on Handle.
|
|
|
|
ProtocolBufferCount - A pointer to the number of GUID pointers present in
|
|
ProtocolBuffer.
|
|
|
|
Returns:
|
|
EFI_SUCCESS - The list of protocol interface GUIDs installed on Handle was returned in
|
|
ProtocolBuffer. The number of protocol interface GUIDs was
|
|
returned in ProtocolBufferCount.
|
|
EFI_INVALID_PARAMETER - Handle is NULL.
|
|
EFI_INVALID_PARAMETER - Handle is not a valid EFI_HANDLE.
|
|
EFI_INVALID_PARAMETER - ProtocolBuffer is NULL.
|
|
EFI_INVALID_PARAMETER - ProtocolBufferCount is NULL.
|
|
EFI_OUT_OF_RESOURCES - There is not enough pool memory to store the results.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreRegisterProtocolNotify (
|
|
IN EFI_GUID *Protocol,
|
|
IN EFI_EVENT Event,
|
|
OUT VOID **Registration
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Add a new protocol notification record for the request protocol.
|
|
|
|
Arguments:
|
|
|
|
Protocol - The requested protocol to add the notify registration
|
|
|
|
Event - The event to signal
|
|
|
|
Registration - Returns the registration record
|
|
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Invalid parameter
|
|
|
|
EFI_SUCCESS - Successfully returned the registration record that has been added
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreLocateHandle (
|
|
IN EFI_LOCATE_SEARCH_TYPE SearchType,
|
|
IN EFI_GUID *Protocol OPTIONAL,
|
|
IN VOID *SearchKey OPTIONAL,
|
|
IN OUT UINTN *BufferSize,
|
|
OUT EFI_HANDLE *Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Locates the requested handle(s) and returns them in Buffer.
|
|
|
|
Arguments:
|
|
|
|
SearchType - The type of search to perform to locate the handles
|
|
|
|
Protocol - The protocol to search for
|
|
|
|
SearchKey - Dependant on SearchType
|
|
|
|
BufferSize - On input the size of Buffer. On output the
|
|
size of data returned.
|
|
|
|
Buffer - The buffer to return the results in
|
|
|
|
|
|
Returns:
|
|
|
|
EFI_BUFFER_TOO_SMALL - Buffer too small, required buffer size is returned in BufferSize.
|
|
|
|
EFI_INVALID_PARAMETER - Invalid parameter
|
|
|
|
EFI_SUCCESS - Successfully found the requested handle(s) and returns them in Buffer.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreLocateDevicePath (
|
|
IN EFI_GUID *Protocol,
|
|
IN OUT EFI_DEVICE_PATH_PROTOCOL **FilePath,
|
|
OUT EFI_HANDLE *Device
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Locates the handle to a device on the device path that supports the specified protocol.
|
|
|
|
Arguments:
|
|
|
|
Protocol - The protocol to search for.
|
|
FilePath - On input, a pointer to a pointer to the device path. On output, the device
|
|
path pointer is modified to point to the remaining part of the devicepath.
|
|
Device - A pointer to the returned device handle.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - The resulting handle was returned.
|
|
EFI_NOT_FOUND - No handles matched the search.
|
|
EFI_INVALID_PARAMETER - One of the parameters has an invalid value.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreLocateHandleBuffer (
|
|
IN EFI_LOCATE_SEARCH_TYPE SearchType,
|
|
IN EFI_GUID *Protocol OPTIONAL,
|
|
IN VOID *SearchKey OPTIONAL,
|
|
IN OUT UINTN *NumberHandles,
|
|
OUT EFI_HANDLE **Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Function returns an array of handles that support the requested protocol
|
|
in a buffer allocated from pool. This is a version of CoreLocateHandle()
|
|
that allocates a buffer for the caller.
|
|
|
|
Arguments:
|
|
|
|
SearchType - Specifies which handle(s) are to be returned.
|
|
Protocol - Provides the protocol to search by.
|
|
This parameter is only valid for SearchType ByProtocol.
|
|
SearchKey - Supplies the search key depending on the SearchType.
|
|
NumberHandles - The number of handles returned in Buffer.
|
|
Buffer - A pointer to the buffer to return the requested array of
|
|
handles that support Protocol.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - The result array of handles was returned.
|
|
EFI_NOT_FOUND - No handles match the search.
|
|
EFI_OUT_OF_RESOURCES - There is not enough pool memory to store the matching results.
|
|
EFI_INVALID_PARAMETER - Invalid parameter
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreLocateProtocol (
|
|
IN EFI_GUID *Protocol,
|
|
IN VOID *Registration OPTIONAL,
|
|
OUT VOID **Interface
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Return the first Protocol Interface that matches the Protocol GUID. If
|
|
Registration is pasased in return a Protocol Instance that was just add
|
|
to the system. If Retistration is NULL return the first Protocol Interface
|
|
you find.
|
|
|
|
Arguments:
|
|
|
|
Protocol - The protocol to search for
|
|
|
|
Registration - Optional Registration Key returned from RegisterProtocolNotify()
|
|
|
|
Interface - Return the Protocol interface (instance).
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - If a valid Interface is returned
|
|
|
|
EFI_INVALID_PARAMETER - Invalid parameter
|
|
|
|
EFI_NOT_FOUND - Protocol interface not found
|
|
|
|
--*/
|
|
;
|
|
|
|
UINT64
|
|
CoreGetHandleDatabaseKey (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
return handle database key.
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Returns:
|
|
|
|
Handle database key.
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
CoreConnectHandlesByKey (
|
|
UINT64 Key
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Go connect any handles that were created or modified while a image executed.
|
|
|
|
Arguments:
|
|
|
|
Key - The Key to show that the handle has been created/modified
|
|
|
|
Returns:
|
|
|
|
None
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreConnectController (
|
|
IN EFI_HANDLE ControllerHandle,
|
|
IN EFI_HANDLE *DriverImageHandle OPTIONAL,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL,
|
|
IN BOOLEAN Recursive
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Connects one or more drivers to a controller.
|
|
|
|
Arguments:
|
|
|
|
ControllerHandle - Handle of the controller to be connected.
|
|
|
|
DriverImageHandle - DriverImageHandle A pointer to an ordered list of driver image handles.
|
|
|
|
RemainingDevicePath - RemainingDevicePath A pointer to the device path that specifies a child of the
|
|
controller specified by ControllerHandle.
|
|
|
|
Recursive - - Whether the function would be called recursively or not.
|
|
|
|
Returns:
|
|
|
|
Status code.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreDisconnectController (
|
|
IN EFI_HANDLE ControllerHandle,
|
|
IN EFI_HANDLE DriverImageHandle OPTIONAL,
|
|
IN EFI_HANDLE ChildHandle OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Disonnects a controller from a driver
|
|
|
|
Arguments:
|
|
|
|
ControllerHandle - ControllerHandle The handle of the controller from which driver(s)
|
|
are to be disconnected.
|
|
DriverImageHandle - DriverImageHandle The driver to disconnect from ControllerHandle.
|
|
ChildHandle - ChildHandle The handle of the child to destroy.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - One or more drivers were disconnected from the controller.
|
|
EFI_SUCCESS - On entry, no drivers are managing ControllerHandle.
|
|
EFI_SUCCESS - DriverImageHandle is not NULL, and on entry DriverImageHandle is not managing ControllerHandle.
|
|
EFI_INVALID_PARAMETER - ControllerHandle is not a valid EFI_HANDLE.
|
|
EFI_INVALID_PARAMETER - DriverImageHandle is not NULL, and it is not a valid EFI_HANDLE.
|
|
EFI_INVALID_PARAMETER - ChildHandle is not NULL, and it is not a valid EFI_HANDLE.
|
|
EFI_OUT_OF_RESOURCES - There are not enough resources available to disconnect any drivers from ControllerHandle.
|
|
EFI_DEVICE_ERROR - The controller could not be disconnected because of a device error.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreAllocatePages (
|
|
IN EFI_ALLOCATE_TYPE Type,
|
|
IN EFI_MEMORY_TYPE MemoryType,
|
|
IN UINTN NumberOfPages,
|
|
IN OUT EFI_PHYSICAL_ADDRESS *Memory
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Allocates pages from the memory map.
|
|
|
|
Arguments:
|
|
|
|
Type - The type of allocation to perform
|
|
|
|
MemoryType - The type of memory to turn the allocated pages into
|
|
|
|
NumberOfPages - The number of pages to allocate
|
|
|
|
Memory - A pointer to receive the base allocated memory address
|
|
|
|
Returns:
|
|
|
|
Status. On success, Memory is filled in with the base address allocated
|
|
|
|
EFI_INVALID_PARAMETER - Parameters violate checking rules defined in spec.
|
|
|
|
EFI_NOT_FOUND - Could not allocate pages match the requirement.
|
|
|
|
EFI_OUT_OF_RESOURCES - No enough pages to allocate.
|
|
|
|
EFI_SUCCESS - Pages successfully allocated.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreFreePages (
|
|
IN EFI_PHYSICAL_ADDRESS Memory,
|
|
IN UINTN NumberOfPages
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Frees previous allocated pages.
|
|
|
|
Arguments:
|
|
|
|
Memory - Base address of memory being freed
|
|
|
|
NumberOfPages - The number of pages to free
|
|
|
|
Returns:
|
|
|
|
EFI_NOT_FOUND - Could not find the entry that covers the range
|
|
|
|
EFI_INVALID_PARAMETER - Address not aligned
|
|
|
|
EFI_SUCCESS -Pages successfully freed.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreGetMemoryMap (
|
|
IN OUT UINTN *MemoryMapSize,
|
|
IN OUT EFI_MEMORY_DESCRIPTOR *Desc,
|
|
OUT UINTN *MapKey,
|
|
OUT UINTN *DescriptorSize,
|
|
OUT UINT32 *DescriptorVersion
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Returns the current memory map.
|
|
|
|
Arguments:
|
|
|
|
MemoryMapSize - On input the buffer size of MemoryMap allocated by caller
|
|
On output the required buffer size to contain the memory map
|
|
|
|
Desc - The buffer to return the current memory map
|
|
|
|
MapKey - The address to return the current map key
|
|
|
|
DescriptorSize - The size in bytes for an individual EFI_MEMORY_DESCRIPTOR
|
|
|
|
DescriptorVersion - The version number associated with the EFI_MEMORY_DESCRIPTOR
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS The current memory map was returned successfully
|
|
|
|
EFI_BUFFER_TOO_SMALL The MemoryMap buffer was too small
|
|
|
|
EFI_INVALID_PARAMETER One of the parameters has an invalid value
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreAllocatePool (
|
|
IN EFI_MEMORY_TYPE PoolType,
|
|
IN UINTN Size,
|
|
OUT VOID **Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Allocate pool of a particular type.
|
|
|
|
Arguments:
|
|
|
|
PoolType - Type of pool to allocate
|
|
|
|
Size - The amount of pool to allocate
|
|
|
|
Buffer - The address to return a pointer to the allocated pool
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - PoolType not valid
|
|
|
|
EFI_OUT_OF_RESOURCES - Size exceeds max pool size or allocation failed.
|
|
|
|
EFI_SUCCESS - Pool successfully allocated.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreFreePool (
|
|
IN VOID *Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Frees pool.
|
|
|
|
Arguments:
|
|
|
|
Buffer - The allocated pool entry to free
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Buffer is not a valid value.
|
|
|
|
EFI_SUCCESS - Pool successfully freed.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreLoadImage (
|
|
IN BOOLEAN BootPolicy,
|
|
IN EFI_HANDLE ParentImageHandle,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
|
|
IN VOID *SourceBuffer OPTIONAL,
|
|
IN UINTN SourceSize,
|
|
OUT EFI_HANDLE *ImageHandle
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads an EFI image into memory and returns a handle to the image.
|
|
|
|
Arguments:
|
|
|
|
BootPolicy - If TRUE, indicates that the request originates from the boot manager,
|
|
and that the boot manager is attempting to load FilePath as a boot selection.
|
|
ParentImageHandle - The caller's image handle.
|
|
FilePath - The specific file path from which the image is loaded.
|
|
SourceBuffer - If not NULL, a pointer to the memory location containing a copy of
|
|
the image to be loaded.
|
|
SourceSize - The size in bytes of SourceBuffer.
|
|
ImageHandle - Pointer to the returned image handle that is created when the image
|
|
is successfully loaded.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - The image was loaded into memory.
|
|
EFI_NOT_FOUND - The FilePath was not found.
|
|
EFI_INVALID_PARAMETER - One of the parameters has an invalid value.
|
|
EFI_UNSUPPORTED - The image type is not supported, or the device path cannot be
|
|
parsed to locate the proper protocol for loading the file.
|
|
EFI_OUT_OF_RESOURCES - Image was not loaded due to insufficient resources.
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreUnloadImage (
|
|
IN EFI_HANDLE ImageHandle
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Unload the specified image.
|
|
|
|
Arguments:
|
|
|
|
ImageHandle - The specified image handle.
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Image handle is NULL.
|
|
|
|
EFI_UNSUPPORTED - Attempt to unload an unsupported image.
|
|
|
|
EFI_SUCCESS - Image successfully unloaded.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreStartImage (
|
|
IN EFI_HANDLE ImageHandle,
|
|
OUT UINTN *ExitDataSize,
|
|
OUT CHAR16 **ExitData OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Transfer control to a loaded image's entry point.
|
|
|
|
Arguments:
|
|
|
|
ImageHandle - Handle of image to be started.
|
|
|
|
ExitDataSize - Pointer of the size to ExitData
|
|
|
|
ExitData - Pointer to a pointer to a data buffer that includes a Null-terminated
|
|
Unicode string, optionally followed by additional binary data. The string
|
|
is a description that the caller may use to further indicate the reason for
|
|
the image's exit.
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Invalid parameter
|
|
|
|
EFI_OUT_OF_RESOURCES - No enough buffer to allocate
|
|
|
|
EFI_SUCCESS - Successfully transfer control to the image's entry point.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreExit (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_STATUS Status,
|
|
IN UINTN ExitDataSize,
|
|
IN CHAR16 *ExitData OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Terminates the currently loaded EFI image and returns control to boot services.
|
|
|
|
Arguments:
|
|
|
|
ImageHandle - Handle that identifies the image. This parameter is passed to the image
|
|
on entry.
|
|
Status - The image's exit code.
|
|
ExitDataSize - The size, in bytes, of ExitData. Ignored if ExitStatus is
|
|
EFI_SUCCESS.
|
|
ExitData - Pointer to a data buffer that includes a Null-terminated Unicode string,
|
|
optionally followed by additional binary data. The string is a
|
|
description that the caller may use to further indicate the reason for
|
|
the image's exit.
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Image handle is NULL or it is not current image.
|
|
|
|
EFI_SUCCESS - Successfully terminates the currently loaded EFI image.
|
|
|
|
EFI_ACCESS_DENIED - Should never reach there.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreCreateEvent (
|
|
IN UINT32 Type,
|
|
IN EFI_TPL NotifyTpl,
|
|
IN EFI_EVENT_NOTIFY NotifyFunction,
|
|
IN VOID *NotifyContext,
|
|
OUT EFI_EVENT *pEvent
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Creates a general-purpose event structure
|
|
|
|
Arguments:
|
|
|
|
Type - The type of event to create and its mode and attributes
|
|
NotifyTpl - The task priority level of event notifications
|
|
NotifyFunction - Pointer to the event's notification function
|
|
NotifyContext - Pointer to the notification function's context; corresponds to
|
|
parameter "Context" in the notification function
|
|
pEvent - Pointer to the newly created event if the call succeeds; undefined otherwise
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - The event structure was created
|
|
EFI_INVALID_PARAMETER - One of the parameters has an invalid value
|
|
EFI_OUT_OF_RESOURCES - The event could not be allocated
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreCreateEventEx (
|
|
IN UINT32 Type,
|
|
IN EFI_TPL NotifyTpl,
|
|
IN EFI_EVENT_NOTIFY NotifyFunction, OPTIONAL
|
|
IN CONST VOID *NotifyContext, OPTIONAL
|
|
IN CONST EFI_GUID *EventGroup, OPTIONAL
|
|
OUT EFI_EVENT *Event
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Creates a general-purpose event structure
|
|
|
|
Arguments:
|
|
Type - The type of event to create and its mode and attributes
|
|
NotifyTpl - The task priority level of event notifications
|
|
NotifyFunction - Pointer to the events notification function
|
|
NotifyContext - Pointer to the notification functions context; corresponds to
|
|
parameter "Context" in the notification function
|
|
EventGrout - GUID for EventGroup if NULL act the same as gBS->CreateEvent().
|
|
Event - Pointer to the newly created event if the call succeeds; undefined otherwise
|
|
|
|
Returns:
|
|
EFI_SUCCESS - The event structure was created
|
|
EFI_INVALID_PARAMETER - One of the parameters has an invalid value
|
|
EFI_OUT_OF_RESOURCES - The event could not be allocated
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreSetTimer (
|
|
IN EFI_EVENT Event,
|
|
IN EFI_TIMER_DELAY Type,
|
|
IN UINT64 TriggerTime
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sets the type of timer and the trigger time for a timer event.
|
|
|
|
Arguments:
|
|
|
|
UserEvent - The timer event that is to be signaled at the specified time
|
|
Type - The type of time that is specified in TriggerTime
|
|
TriggerTime - The number of 100ns units until the timer expires
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - The event has been set to be signaled at the requested time
|
|
EFI_INVALID_PARAMETER - Event or Type is not valid
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreSignalEvent (
|
|
IN EFI_EVENT Event
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Signals the event. Queues the event to be notified if needed
|
|
|
|
Arguments:
|
|
|
|
Event - The event to signal
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Parameters are not valid.
|
|
|
|
EFI_SUCCESS - The event was signaled.
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreWaitForEvent (
|
|
IN UINTN NumberOfEvents,
|
|
IN EFI_EVENT *UserEvents,
|
|
OUT UINTN *UserIndex
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Stops execution until an event is signaled.
|
|
|
|
Arguments:
|
|
|
|
NumberOfEvents - The number of events in the UserEvents array
|
|
UserEvents - An array of EFI_EVENT
|
|
UserIndex - Pointer to the index of the event which satisfied the wait condition
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - The event indicated by Index was signaled.
|
|
EFI_INVALID_PARAMETER - The event indicated by Index has a notification function or
|
|
Event was not a valid type
|
|
EFI_UNSUPPORTED - The current TPL is not TPL_APPLICATION
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreCloseEvent (
|
|
IN EFI_EVENT Event
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Closes an event and frees the event structure.
|
|
|
|
Arguments:
|
|
|
|
UserEvent - Event to close
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Parameters are not valid.
|
|
|
|
EFI_SUCCESS - The event has been closed
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreCheckEvent (
|
|
IN EFI_EVENT Event
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Check the status of an event
|
|
|
|
Arguments:
|
|
|
|
UserEvent - The event to check
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - The event is in the signaled state
|
|
EFI_NOT_READY - The event is not in the signaled state
|
|
EFI_INVALID_PARAMETER - Event is of type EVT_NOTIFY_SIGNAL
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreAddMemorySpace (
|
|
IN EFI_GCD_MEMORY_TYPE GcdMemoryType,
|
|
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
|
IN UINT64 Length,
|
|
IN UINT64 Capabilities
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Add a segment of memory space to GCD map and add all available pages in this segment
|
|
as memory descriptors.
|
|
|
|
Arguments:
|
|
|
|
GcdMemoryType - Memory type of the segment.
|
|
|
|
BaseAddress - Base address of the segment.
|
|
|
|
Length - Length of the segment.
|
|
|
|
Capabilities - alterable attributes of the segment.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - Merged this segment into GCD map.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreAllocateMemorySpace (
|
|
IN EFI_GCD_ALLOCATE_TYPE GcdAllocateType,
|
|
IN EFI_GCD_MEMORY_TYPE GcdMemoryType,
|
|
IN UINTN Alignment,
|
|
IN UINT64 Length,
|
|
IN OUT EFI_PHYSICAL_ADDRESS *BaseAddress,
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_HANDLE DeviceHandle OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Allocate memory space on GCD map.
|
|
|
|
Arguments:
|
|
|
|
GcdAllocateType - The type of allocate operation
|
|
|
|
GcdMemoryType - The desired memory type
|
|
|
|
Alignment - Align with 2^Alignment
|
|
|
|
Length - Length to allocate
|
|
|
|
BaseAddress - Base address to allocate
|
|
|
|
ImageHandle - The image handle consume the allocated space.
|
|
|
|
DeviceHandle - The device handle consume the allocated space.
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Invalid parameter.
|
|
|
|
EFI_NOT_FOUND - No descriptor contains the desired space.
|
|
|
|
EFI_SUCCESS - Memory space successfully allocated.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreFreeMemorySpace (
|
|
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
|
IN UINT64 Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:Routine Description:
|
|
|
|
Free a segment of memory space in GCD map.
|
|
|
|
Arguments:
|
|
|
|
BaseAddress - Base address of the segment.
|
|
|
|
Length - Length of the segment.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - Space successfully freed.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreRemoveMemorySpace (
|
|
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
|
IN UINT64 Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:Routine Description:
|
|
|
|
Remove a segment of memory space in GCD map.
|
|
|
|
Arguments:
|
|
|
|
BaseAddress - Base address of the segment.
|
|
|
|
Length - Length of the segment.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - Successfully a segment of memory space.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreGetMemorySpaceDescriptor (
|
|
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
|
OUT EFI_GCD_MEMORY_SPACE_DESCRIPTOR *Descriptor
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Search all entries in GCD map which contains specified segment and build it to a descriptor.
|
|
|
|
Arguments:
|
|
|
|
BaseAddress - Specified start address
|
|
|
|
Descriptor - Specified length
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Invalid parameter
|
|
|
|
EFI_SUCCESS - Successfully get memory space descriptor.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreSetMemorySpaceAttributes (
|
|
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
|
IN UINT64 Length,
|
|
IN UINT64 Attributes
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Set memory space with specified attributes.
|
|
|
|
Arguments:
|
|
|
|
BaseAddress - Specified start address
|
|
|
|
Length - Specified length
|
|
|
|
Attributes - Specified attributes
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - Successfully set attribute of a segment of memory space.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreGetMemorySpaceMap (
|
|
OUT UINTN *NumberOfDescriptors,
|
|
OUT EFI_GCD_MEMORY_SPACE_DESCRIPTOR **MemorySpaceMap
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Transer all entries of GCD memory map into memory descriptors and pass to caller.
|
|
|
|
Arguments:
|
|
|
|
NumberOfDescriptors - Number of descriptors.
|
|
|
|
MemorySpaceMap - Descriptor array
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Invalid parameter
|
|
|
|
EFI_OUT_OF_RESOURCES - No enough buffer to allocate
|
|
|
|
EFI_SUCCESS - Successfully get memory space map.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreAddIoSpace (
|
|
IN EFI_GCD_IO_TYPE GcdIoType,
|
|
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
|
IN UINT64 Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Add a segment of IO space to GCD map.
|
|
|
|
Arguments:
|
|
|
|
GcdIoType - IO type of the segment.
|
|
|
|
BaseAddress - Base address of the segment.
|
|
|
|
Length - Length of the segment.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - Merged this segment into GCD map.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreAllocateIoSpace (
|
|
IN EFI_GCD_ALLOCATE_TYPE GcdAllocateType,
|
|
IN EFI_GCD_IO_TYPE GcdIoType,
|
|
IN UINTN Alignment,
|
|
IN UINT64 Length,
|
|
IN OUT EFI_PHYSICAL_ADDRESS *BaseAddress,
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_HANDLE DeviceHandle OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Allocate IO space on GCD map.
|
|
|
|
Arguments:
|
|
|
|
GcdAllocateType - The type of allocate operation
|
|
|
|
GcdIoType - The desired IO type
|
|
|
|
Alignment - Align with 2^Alignment
|
|
|
|
Length - Length to allocate
|
|
|
|
BaseAddress - Base address to allocate
|
|
|
|
ImageHandle - The image handle consume the allocated space.
|
|
|
|
DeviceHandle - The device handle consume the allocated space.
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Invalid parameter.
|
|
|
|
EFI_NOT_FOUND - No descriptor contains the desired space.
|
|
|
|
EFI_SUCCESS - IO space successfully allocated.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreFreeIoSpace (
|
|
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
|
IN UINT64 Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:Routine Description:
|
|
|
|
Free a segment of IO space in GCD map.
|
|
|
|
Arguments:
|
|
|
|
BaseAddress - Base address of the segment.
|
|
|
|
Length - Length of the segment.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - Space successfully freed.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreRemoveIoSpace (
|
|
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
|
IN UINT64 Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:Routine Description:
|
|
|
|
Remove a segment of IO space in GCD map.
|
|
|
|
Arguments:
|
|
|
|
BaseAddress - Base address of the segment.
|
|
|
|
Length - Length of the segment.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - Successfully removed a segment of IO space.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreGetIoSpaceDescriptor (
|
|
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
|
OUT EFI_GCD_IO_SPACE_DESCRIPTOR *Descriptor
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Search all entries in GCD map which contains specified segment and build it to a descriptor.
|
|
|
|
Arguments:
|
|
|
|
BaseAddress - Specified start address
|
|
|
|
Descriptor - Specified length
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Descriptor is NULL.
|
|
|
|
EFI_SUCCESS - Successfully get the IO space descriptor.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreGetIoSpaceMap (
|
|
OUT UINTN *NumberOfDescriptors,
|
|
OUT EFI_GCD_IO_SPACE_DESCRIPTOR **IoSpaceMap
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Transer all entries of GCD IO map into IO descriptors and pass to caller.
|
|
|
|
Arguments:
|
|
|
|
NumberOfDescriptors - Number of descriptors.
|
|
|
|
IoSpaceMap - Descriptor array
|
|
|
|
Returns:
|
|
|
|
EFI_INVALID_PARAMETER - Invalid parameter
|
|
|
|
EFI_OUT_OF_RESOURCES - No enough buffer to allocate
|
|
|
|
EFI_SUCCESS - Successfully get IO space map.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_DXESERVICE
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreDispatcher (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the main Dispatcher for DXE and it exits when there are no more
|
|
drivers to run. Drain the mScheduledQueue and load and start a PE
|
|
image for each driver. Search the mDiscoveredList to see if any driver can
|
|
be placed on the mScheduledQueue. If no drivers are placed on the
|
|
mScheduledQueue exit the function. On exit it is assumed the Bds()
|
|
will be called, and when the Bds() exits the Dispatcher will be called
|
|
again.
|
|
|
|
Arguments:
|
|
|
|
NONE
|
|
|
|
Returns:
|
|
|
|
EFI_ALREADY_STARTED - The DXE Dispatcher is already running
|
|
|
|
EFI_NOT_FOUND - No DXE Drivers were dispatched
|
|
|
|
EFI_SUCCESS - One or more DXE Drivers were dispatched
|
|
|
|
--*/
|
|
;
|
|
EFI_DXESERVICE
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreSchedule (
|
|
IN EFI_HANDLE FirmwareVolumeHandle,
|
|
IN EFI_GUID *DriverName
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Check every driver and locate a matching one. If the driver is found, the Unrequested
|
|
state flag is cleared.
|
|
|
|
Arguments:
|
|
|
|
FirmwareVolumeHandle - The handle of the Firmware Volume that contains the firmware
|
|
file specified by DriverName.
|
|
|
|
DriverName - The Driver name to put in the Dependent state.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - The DriverName was found and it's SOR bit was cleared
|
|
|
|
EFI_NOT_FOUND - The DriverName does not exist or it's SOR bit was not set.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_DXESERVICE
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreTrust (
|
|
IN EFI_HANDLE FirmwareVolumeHandle,
|
|
IN EFI_GUID *DriverName
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Convert a driver from the Untrused back to the Scheduled state
|
|
|
|
Arguments:
|
|
|
|
FirmwareVolumeHandle - The handle of the Firmware Volume that contains the firmware
|
|
file specified by DriverName.
|
|
|
|
DriverName - The Driver name to put in the Scheduled state
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - The file was found in the untrusted state, and it was promoted
|
|
to the trusted state.
|
|
|
|
EFI_NOT_FOUND - The file was not found in the untrusted state.
|
|
|
|
--*/
|
|
;
|
|
|
|
BOOLEAN
|
|
CoreGrowBuffer (
|
|
IN OUT EFI_STATUS *Status,
|
|
IN OUT VOID **Buffer,
|
|
IN UINTN BufferSize
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Helper function called as part of the code needed
|
|
to allocate the proper sized buffer for various
|
|
EFI interfaces.
|
|
|
|
Arguments:
|
|
|
|
Status - Current status
|
|
|
|
Buffer - Current allocated buffer, or NULL
|
|
|
|
BufferSize - Current buffer size needed
|
|
|
|
Returns:
|
|
|
|
TRUE - if the buffer was reallocated and the caller
|
|
should try the API again.
|
|
|
|
FALSE - buffer could not be allocated and the caller
|
|
should not try the API again.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FwVolDriverInit (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
This routine is the driver initialization entry point. It initializes the
|
|
libraries, and registers two notification functions. These notification
|
|
functions are responsible for building the FV stack dynamically.
|
|
|
|
Arguments:
|
|
ImageHandle - The image handle.
|
|
SystemTable - The system table.
|
|
|
|
Returns:
|
|
EFI_SUCCESS - Function successfully returned.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
InitializeSectionExtraction (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Entry point of the section extraction code. Initializes an instance of the
|
|
section extraction interface and installs it on a new handle.
|
|
|
|
Arguments:
|
|
ImageHandle EFI_HANDLE: A handle for the image that is initializing this driver
|
|
SystemTable EFI_SYSTEM_TABLE: A pointer to the EFI system table
|
|
|
|
Returns:
|
|
EFI_SUCCESS: Driver initialized successfully
|
|
EFI_OUT_OF_RESOURCES: Could not allocate needed resources
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreProcessFirmwareVolume (
|
|
IN VOID *FvHeader,
|
|
IN UINTN Size,
|
|
OUT EFI_HANDLE *FVProtocolHandle
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
This DXE service routine is used to process a firmware volume. In
|
|
particular, it can be called by BDS to process a single firmware
|
|
volume found in a capsule.
|
|
|
|
Arguments:
|
|
FvHeader - pointer to a firmware volume header
|
|
Size - the size of the buffer pointed to by FvHeader
|
|
FVProtocolHandle - the handle on which a firmware volume protocol
|
|
was produced for the firmware volume passed in.
|
|
|
|
Returns:
|
|
EFI_OUT_OF_RESOURCES - if an FVB could not be produced due to lack of
|
|
system resources
|
|
EFI_VOLUME_CORRUPTED - if the volume was corrupted
|
|
EFI_SUCCESS - a firmware volume protocol was produced for the
|
|
firmware volume
|
|
|
|
--*/
|
|
;
|
|
|
|
//
|
|
//Functions used during debug buils
|
|
//
|
|
VOID
|
|
CoreDisplayMissingArchProtocols (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Displays Architectural protocols that were not loaded and are required for DXE core to function
|
|
Only used in Debug Builds
|
|
|
|
Arguments:
|
|
NONE
|
|
|
|
Returns:
|
|
NONE
|
|
|
|
--*/;
|
|
|
|
VOID
|
|
CoreDisplayDiscoveredNotDispatched (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Traverse the discovered list for any drivers that were discovered but not loaded
|
|
because the dependency experessions evaluated to false
|
|
|
|
Arguments:
|
|
|
|
NONE
|
|
|
|
Returns:
|
|
|
|
NONE
|
|
|
|
--*/;
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreEfiNotAvailableYetArg0 (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Place holder function until all the Boot Services and Runtime Services are available
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Returns:
|
|
|
|
EFI_NOT_AVAILABLE_YET
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreEfiNotAvailableYetArg1 (
|
|
UINTN Arg1
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Place holder function until all the Boot Services and Runtime Services are available
|
|
|
|
Arguments:
|
|
|
|
Arg1 - Undefined
|
|
|
|
Returns:
|
|
|
|
EFI_NOT_AVAILABLE_YET
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreEfiNotAvailableYetArg2 (
|
|
UINTN Arg1,
|
|
UINTN Arg2
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Place holder function until all the Boot Services and Runtime Services are available
|
|
|
|
Arguments:
|
|
|
|
Arg1 - Undefined
|
|
|
|
Arg2 - Undefined
|
|
|
|
Returns:
|
|
|
|
EFI_NOT_AVAILABLE_YET
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreEfiNotAvailableYetArg3 (
|
|
UINTN Arg1,
|
|
UINTN Arg2,
|
|
UINTN Arg3
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Place holder function until all the Boot Services and Runtime Services are available
|
|
|
|
Arguments:
|
|
|
|
Arg1 - Undefined
|
|
|
|
Arg2 - Undefined
|
|
|
|
Arg3 - Undefined
|
|
|
|
Returns:
|
|
|
|
EFI_NOT_AVAILABLE_YET
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreEfiNotAvailableYetArg4 (
|
|
UINTN Arg1,
|
|
UINTN Arg2,
|
|
UINTN Arg3,
|
|
UINTN Arg4
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Place holder function until all the Boot Services and Runtime Services are available
|
|
|
|
Arguments:
|
|
|
|
Arg1 - Undefined
|
|
|
|
Arg2 - Undefined
|
|
|
|
Arg3 - Undefined
|
|
|
|
Arg4 - Undefined
|
|
|
|
Returns:
|
|
|
|
EFI_NOT_AVAILABLE_YET
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreEfiNotAvailableYetArg5 (
|
|
UINTN Arg1,
|
|
UINTN Arg2,
|
|
UINTN Arg3,
|
|
UINTN Arg4,
|
|
UINTN Arg5
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Place holder function until all the Boot Services and Runtime Services are available
|
|
|
|
Arguments:
|
|
|
|
Arg1 - Undefined
|
|
|
|
Arg2 - Undefined
|
|
|
|
Arg3 - Undefined
|
|
|
|
Arg4 - Undefined
|
|
|
|
Arg5 - Undefined
|
|
|
|
Returns:
|
|
|
|
EFI_NOT_AVAILABLE_YET
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
CoreGetPeiProtocol (
|
|
IN EFI_GUID *ProtocolGuid,
|
|
IN VOID **Interface
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Searches for a Protocol Interface passed from PEI through a HOB
|
|
|
|
Arguments:
|
|
|
|
ProtocolGuid - The Protocol GUID to search for in the HOB List
|
|
|
|
Interface - A pointer to the interface for the Protocol GUID
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - The Protocol GUID was found and its interface is returned in Interface
|
|
|
|
EFI_NOT_FOUND - The Protocol GUID was not found in the HOB List
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
DxeMainUefiDecompressGetInfo (
|
|
IN EFI_DECOMPRESS_PROTOCOL *This,
|
|
IN VOID *Source,
|
|
IN UINT32 SourceSize,
|
|
OUT UINT32 *DestinationSize,
|
|
OUT UINT32 *ScratchSize
|
|
);
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
DxeMainUefiDecompress (
|
|
IN EFI_DECOMPRESS_PROTOCOL *This,
|
|
IN VOID *Source,
|
|
IN UINT32 SourceSize,
|
|
IN OUT VOID *Destination,
|
|
IN UINT32 DestinationSize,
|
|
IN OUT VOID *Scratch,
|
|
IN UINT32 ScratchSize
|
|
);
|
|
|
|
EFI_STATUS
|
|
DxeMainTianoDecompressGetInfo (
|
|
IN EFI_TIANO_DECOMPRESS_PROTOCOL *This,
|
|
IN VOID *Source,
|
|
IN UINT32 SourceSize,
|
|
OUT UINT32 *DestinationSize,
|
|
OUT UINT32 *ScratchSize
|
|
);
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
DxeMainTianoDecompress (
|
|
IN EFI_TIANO_DECOMPRESS_PROTOCOL *This,
|
|
IN VOID *Source,
|
|
IN UINT32 SourceSize,
|
|
IN OUT VOID *Destination,
|
|
IN UINT32 DestinationSize,
|
|
IN OUT VOID *Scratch,
|
|
IN UINT32 ScratchSize
|
|
);
|
|
|
|
EFI_STATUS
|
|
DxeMainCustomDecompressGetInfo (
|
|
IN EFI_CUSTOMIZED_DECOMPRESS_PROTOCOL *This,
|
|
IN VOID *Source,
|
|
IN UINT32 SourceSize,
|
|
OUT UINT32 *DestinationSize,
|
|
OUT UINT32 *ScratchSize
|
|
);
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
DxeMainCustomDecompress (
|
|
IN EFI_CUSTOMIZED_DECOMPRESS_PROTOCOL *This,
|
|
IN VOID *Source,
|
|
IN UINT32 SourceSize,
|
|
IN OUT VOID *Destination,
|
|
IN UINT32 DestinationSize,
|
|
IN OUT VOID *Scratch,
|
|
IN UINT32 ScratchSize
|
|
);
|
|
|
|
#endif
|