path: root/vendor/r-efi/src/system.rs

//! UEFI System Integration
//!
//! This header defines the structures and types of the surrounding system of an UEFI application.
//! It contains the definitions of the system table, the runtime and boot services, as well as
//! common types.
//!
//! We do not document the behavior of each of these types and functions. They follow the UEFI
//! specification, which does a well-enough job of documenting each. This file just provides you
//! the rust definitions of each symbol and some limited hints on some pecularities.

//
// Time Management
//
// UEFI time management is modeled around the EFI_TIME structure, which represents any arbitrary
// timestamp. The runtime and boot services provide helper functions to query and set the system
// time.
//

pub const TIME_ADJUST_DAYLIGHT: u8 = 0x01u8;
pub const TIME_IN_DAYLIGHT: u8 = 0x02u8;

pub const UNSPECIFIED_TIMEZONE: i16 = 0x07ffi16;

// Cannot derive `Eq` etc. due to uninitialized `pad2` field.
#[repr(C)]
#[derive(Clone, Copy, Debug, Default)]
pub struct Time {
    pub year: u16,
    pub month: u8,
    pub day: u8,
    pub hour: u8,
    pub minute: u8,
    pub second: u8,
    pub pad1: u8,
    pub nanosecond: u32,
    pub timezone: i16,
    pub daylight: u8,
    pub pad2: u8,
}

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct TimeCapabilities {
    pub resolution: u32,
    pub accuracy: u32,
    pub sets_to_zero: crate::base::Boolean,
}

//
// UEFI Variables
//
// UEFI systems provide a way to store global variables. These can be persistent or volatile. The
// variable store must be provided by the platform, but persistent storage might not be available.
//

pub const VARIABLE_NON_VOLATILE: u32 = 0x00000001u32;
pub const VARIABLE_BOOTSERVICE_ACCESS: u32 = 0x00000002u32;
pub const VARIABLE_RUNTIME_ACCESS: u32 = 0x00000004u32;
pub const VARIABLE_HARDWARE_ERROR_RECORD: u32 = 0x00000008u32;
pub const VARIABLE_AUTHENTICATED_WRITE_ACCESS: u32 = 0x00000010u32;
pub const VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS: u32 = 0x00000020u32;
pub const VARIABLE_APPEND_WRITE: u32 = 0x00000040u32;
pub const VARIABLE_ENHANCED_AUTHENTICATED_ACCESS: u32 = 0x00000080u32;

pub const VARIABLE_AUTHENTICATION_3_CERT_ID_SHA256: u32 = 0x1u32;

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct VariableAuthentication3CertId<const N: usize = 0> {
    pub r#type: u8,
    pub id_size: u32,
    pub id: [u8; N],
}

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct VariableAuthentication<const N: usize = 0> {
    pub monotonic_count: u64,
    pub auth_info: [u8; N], // WIN_CERTIFICATE_UEFI_ID from PE/COFF
}

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct VariableAuthentication2<const N: usize = 0> {
    pub timestamp: Time,
    pub auth_info: [u8; N], // WIN_CERTIFICATE_UEFI_ID from PE/COFF
}

pub const VARIABLE_AUTHENTICATION_3_TIMESTAMP_TYPE: u32 = 0x1u32;
pub const VARIABLE_AUTHENTICATION_3_NONCE_TYPE: u32 = 0x2u32;

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct VariableAuthentication3 {
    pub version: u8,
    pub r#type: u8,
    pub metadata_size: u32,
    pub flags: u32,
}

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct VariableAuthentication3Nonce<const N: usize = 0> {
    pub nonce_size: u32,
    pub nonce: [u8; N],
}

pub const HARDWARE_ERROR_VARIABLE_GUID: crate::base::Guid = crate::base::Guid::from_fields(
    0x414E6BDD,
    0xE47B,
    0x47cc,
    0xB2,
    0x44,
    &[0xBB, 0x61, 0x02, 0x0C, 0xF5, 0x16],
);

//
// Virtual Mappings
//
// UEFI runs in an 1-to-1 mapping from virtual to physical addresses. But once you exit boot
// services, you can apply any address mapping you want, as long as you inform UEFI about it (or,
// alternatively, stop using the UEFI runtime services).
//

pub const OPTIONAL_POINTER: u32 = 0x00000001u32;

//
// System Reset
//
// UEFI provides access to firmware functions to reset the system. This includes a wide variety of
// different possible resets.
//

pub type ResetType = u32;

pub const RESET_COLD: ResetType = 0x00000000;
pub const RESET_WARM: ResetType = 0x00000001;
pub const RESET_SHUTDOWN: ResetType = 0x00000002;
pub const RESET_PLATFORM_SPECIFIC: ResetType = 0x00000003;

//
// Update Capsules
//
// The process of firmware updates is generalized in UEFI. There are small blobs called capsules
// that you can push into the firmware to be run either immediately or on next reboot.
//

#[repr(C)]
#[derive(Clone, Copy)]
pub union CapsuleBlockDescriptorUnion {
    pub data_block: crate::base::PhysicalAddress,
    pub continuation_pointer: crate::base::PhysicalAddress,
}

#[repr(C)]
#[derive(Clone, Copy)]
pub struct CapsuleBlockDescriptor {
    pub length: u64,
    pub data: CapsuleBlockDescriptorUnion,
}

pub const CAPSULE_FLAGS_PERSIST_ACROSS_RESET: u32 = 0x00010000u32;
pub const CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE: u32 = 0x00020000u32;
pub const CAPSULE_FLAGS_INITIATE_RESET: u32 = 0x00040000u32;

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct CapsuleHeader {
    pub capsule_guid: crate::base::Guid,
    pub header_size: u32,
    pub flags: u32,
    pub capsule_image_size: u32,
}

pub const OS_INDICATIONS_BOOT_TO_FW_UI: u64 = 0x0000000000000001u64;
pub const OS_INDICATIONS_TIMESTAMP_REVOCATION: u64 = 0x0000000000000002u64;
pub const OS_INDICATIONS_FILE_CAPSULE_DELIVERY_SUPPORTED: u64 = 0x0000000000000004u64;
pub const OS_INDICATIONS_FMP_CAPSULE_SUPPORTED: u64 = 0x0000000000000008u64;
pub const OS_INDICATIONS_CAPSULE_RESULT_VAR_SUPPORTED: u64 = 0x0000000000000010u64;
pub const OS_INDICATIONS_START_OS_RECOVERY: u64 = 0x0000000000000020u64;
pub const OS_INDICATIONS_START_PLATFORM_RECOVERY: u64 = 0x0000000000000040u64;

pub const CAPSULE_REPORT_GUID: crate::base::Guid = crate::base::Guid::from_fields(
    0x39b68c46,
    0xf7fb,
    0x441b,
    0xb6,
    0xec,
    &[0x16, 0xb0, 0xf6, 0x98, 0x21, 0xf3],
);

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct CapsuleResultVariableHeader {
    pub variable_total_size: u32,
    pub reserved: u32,
    pub capsule_guid: crate::base::Guid,
    pub capsule_processed: Time,
    pub capsule_status: crate::base::Status,
}

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct CapsuleResultVariableFMP<const N: usize = 0> {
    pub version: u16,
    pub payload_index: u8,
    pub update_image_index: u8,
    pub update_image_type_id: crate::base::Guid,
    pub capsule_file_name_and_target: [crate::base::Char16; N],
}

//
// Tasks
//
// UEFI uses a simplified task model, and only ever runs on a single CPU. Usually, there is only
// one single task running on the system, which is the current execution. No interrupts are
// supported, other than timer interrupts. That is, all device management must be reliant on
// polling.
//
// You can, however, register callbacks to be run by the UEFI core. That is, either when execution
// is returned to the UEFI core, or when a timer interrupt fires, the scheduler will run the
// highest priority task next, interrupting the current task. You can use simple
// task-priority-levels (TPL) to adjust the priority of your callbacks and current task.
//

pub const EVT_TIMER: u32 = 0x80000000u32;
pub const EVT_RUNTIME: u32 = 0x40000000u32;
pub const EVT_NOTIFY_WAIT: u32 = 0x00000100u32;
pub const EVT_NOTIFY_SIGNAL: u32 = 0x00000200u32;
pub const EVT_SIGNAL_EXIT_BOOT_SERVICES: u32 = 0x00000201u32;
pub const EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE: u32 = 0x60000202u32;

pub type EventNotify = eficall! {fn(crate::base::Event, *mut core::ffi::c_void)};

pub const EVENT_GROUP_EXIT_BOOT_SERVICES: crate::base::Guid = crate::base::Guid::from_fields(
    0x27abf055,
    0xb1b8,
    0x4c26,
    0x80,
    0x48,
    &[0x74, 0x8f, 0x37, 0xba, 0xa2, 0xdf],
);
pub const EVENT_GROUP_VIRTUAL_ADDRESS_CHANGE: crate::base::Guid = crate::base::Guid::from_fields(
    0x13fa7698,
    0xc831,
    0x49c7,
    0x87,
    0xea,
    &[0x8f, 0x43, 0xfc, 0xc2, 0x51, 0x96],
);
pub const EVENT_GROUP_MEMORY_MAP_CHANGE: crate::base::Guid = crate::base::Guid::from_fields(
    0x78bee926,
    0x692f,
    0x48fd,
    0x9e,
    0xdb,
    &[0x1, 0x42, 0x2e, 0xf0, 0xd7, 0xab],
);
pub const EVENT_GROUP_READY_TO_BOOT: crate::base::Guid = crate::base::Guid::from_fields(
    0x7ce88fb3,
    0x4bd7,
    0x4679,
    0x87,
    0xa8,
    &[0xa8, 0xd8, 0xde, 0xe5, 0x0d, 0x2b],
);
pub const EVENT_GROUP_RESET_SYSTEM: crate::base::Guid = crate::base::Guid::from_fields(
    0x62da6a56,
    0x13fb,
    0x485a,
    0xa8,
    0xda,
    &[0xa3, 0xdd, 0x79, 0x12, 0xcb, 0x6b],
);

pub type TimerDelay = u32;

pub const TIMER_CANCEL: TimerDelay = 0x00000000;
pub const TIMER_PERIODIC: TimerDelay = 0x00000001;
pub const TIMER_RELATIVE: TimerDelay = 0x00000002;

pub const TPL_APPLICATION: crate::base::Tpl = 4;
pub const TPL_CALLBACK: crate::base::Tpl = 8;
pub const TPL_NOTIFY: crate::base::Tpl = 16;
pub const TPL_HIGH_LEVEL: crate::base::Tpl = 31;

//
// Memory management
//
// The UEFI boot services provide you pool-allocation helpers to reserve memory. The region for
// each allocation can be selected by the caller, allowing to reserve memory that even survives
// beyond boot services. However, dynamic allocations can only performed via boot services, so no
// dynamic modifications can be done once you exit boot services.
//

pub type AllocateType = u32;

pub const ALLOCATE_ANY_PAGES: AllocateType = 0x00000000;
pub const ALLOCATE_MAX_ADDRESS: AllocateType = 0x00000001;
pub const ALLOCATE_ADDRESS: AllocateType = 0x00000002;

pub type MemoryType = u32;

pub const RESERVED_MEMORY_TYPE: MemoryType = 0x00000000;
pub const LOADER_CODE: MemoryType = 0x00000001;
pub const LOADER_DATA: MemoryType = 0x00000002;
pub const BOOT_SERVICES_CODE: MemoryType = 0x00000003;
pub const BOOT_SERVICES_DATA: MemoryType = 0x00000004;
pub const RUNTIME_SERVICES_CODE: MemoryType = 0x00000005;
pub const RUNTIME_SERVICES_DATA: MemoryType = 0x00000006;
pub const CONVENTIONAL_MEMORY: MemoryType = 0x00000007;
pub const UNUSABLE_MEMORY: MemoryType = 0x00000008;
pub const ACPI_RECLAIM_MEMORY: MemoryType = 0x00000009;
pub const ACPI_MEMORY_NVS: MemoryType = 0x0000000a;
pub const MEMORY_MAPPED_IO: MemoryType = 0x0000000b;
pub const MEMORY_MAPPED_IO_PORT_SPACE: MemoryType = 0x0000000c;
pub const PAL_CODE: MemoryType = 0x0000000d;
pub const PERSISTENT_MEMORY: MemoryType = 0x0000000e;

pub const MEMORY_UC: u64 = 0x0000000000000001u64;
pub const MEMORY_WC: u64 = 0x0000000000000002u64;
pub const MEMORY_WT: u64 = 0x0000000000000004u64;
pub const MEMORY_WB: u64 = 0x0000000000000008u64;
pub const MEMORY_UCE: u64 = 0x0000000000000010u64;
pub const MEMORY_WP: u64 = 0x0000000000001000u64;
pub const MEMORY_RP: u64 = 0x0000000000002000u64;
pub const MEMORY_XP: u64 = 0x0000000000004000u64;
pub const MEMORY_NV: u64 = 0x0000000000008000u64;
pub const MEMORY_MORE_RELIABLE: u64 = 0x0000000000010000u64;
pub const MEMORY_RO: u64 = 0x0000000000020000u64;
pub const MEMORY_RUNTIME: u64 = 0x8000000000000000u64;

pub const MEMORY_DESCRIPTOR_VERSION: u32 = 0x00000001u32;

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct MemoryDescriptor {
    pub r#type: u32,
    pub physical_start: crate::base::PhysicalAddress,
    pub virtual_start: crate::base::VirtualAddress,
    pub number_of_pages: u64,
    pub attribute: u64,
}

//
// Protocol Management
//
// The UEFI driver model provides ways to have bus-drivers, device-drivers, and applications as
// separate, independent entities. They use protocols to communicate, and handles to refer to
// common state. Drivers and devices can be registered dynamically at runtime, and can support
// hotplugging.
//

pub type InterfaceType = u32;

pub const NATIVE_INTERFACE: InterfaceType = 0x00000000;

pub type LocateSearchType = u32;

pub const ALL_HANDLES: LocateSearchType = 0x00000000;
pub const BY_REGISTER_NOTIFY: LocateSearchType = 0x00000001;
pub const BY_PROTOCOL: LocateSearchType = 0x00000002;

pub const OPEN_PROTOCOL_BY_HANDLE_PROTOCOL: u32 = 0x00000001u32;
pub const OPEN_PROTOCOL_GET_PROTOCOL: u32 = 0x00000002u32;
pub const OPEN_PROTOCOL_TEST_PROTOCOL: u32 = 0x00000004u32;
pub const OPEN_PROTOCOL_BY_CHILD_CONTROLLER: u32 = 0x00000008u32;
pub const OPEN_PROTOCOL_BY_DRIVER: u32 = 0x00000010u32;
pub const OPEN_PROTOCOL_EXCLUSIVE: u32 = 0x00000020u32;

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct OpenProtocolInformationEntry {
    pub agent_handle: crate::base::Handle,
    pub controller_handle: crate::base::Handle,
    pub attributes: u32,
    pub open_count: u32,
}

//
// Configuration Tables
//
// The system table contains an array of auxiliary tables, indexed by their GUID, called
// configuration tables. Each table uses the generic ConfigurationTable structure as header.
//

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct ConfigurationTable {
    pub vendor_guid: crate::base::Guid,
    pub vendor_table: *mut core::ffi::c_void,
}

pub const PROPERTIES_TABLE_GUID: crate::base::Guid = crate::base::Guid::from_fields(
    0x880aaca3,
    0x4adc,
    0x4a04,
    0x90,
    0x79,
    &[0xb7, 0x47, 0x34, 0x8, 0x25, 0xe5],
);

pub const PROPERTIES_TABLE_VERSION: u32 = 0x00010000u32;

pub const PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA: u64 = 0x1u64;

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct PropertiesTable {
    pub version: u32,
    pub length: u32,
    pub memory_protection_attribute: u64,
}

pub const MEMORY_ATTRIBUTES_TABLE_GUID: crate::base::Guid = crate::base::Guid::from_fields(
    0xdcfa911d,
    0x26eb,
    0x469f,
    0xa2,
    0x20,
    &[0x38, 0xb7, 0xdc, 0x46, 0x12, 0x20],
);

pub const MEMORY_ATTRIBUTES_TABLE_VERSION: u32 = 0x00000001u32;

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct MemoryAttributesTable<const N: usize = 0> {
    pub version: u32,
    pub number_of_entries: u32,
    pub descriptor_size: u32,
    pub reserved: u32,
    pub entry: [MemoryDescriptor; N],
}

//
// Global Tables
//
// UEFI uses no global state, so all access to UEFI internal state is done through vtables you get
// passed to your entry-point. The global entry is the system-table, which encorporates several
// sub-tables, including the runtime and boot service tables, and configuration tables (including
// vendor extensions).
//

pub const SPECIFICATION_REVISION: u32 = SYSTEM_TABLE_REVISION;

#[repr(C)]
#[derive(Clone, Copy, Debug)]
pub struct TableHeader {
    pub signature: u64,
    pub revision: u32,
    pub header_size: u32,
    pub crc32: u32,
    pub reserved: u32,
}

pub const RUNTIME_SERVICES_SIGNATURE: u64 = 0x56524553544e5552u64; // "RUNTSERV"
pub const RUNTIME_SERVICES_REVISION: u32 = SPECIFICATION_REVISION;

pub type RuntimeGetTime = eficall! {fn(
    *mut Time,
    *mut TimeCapabilities,
) -> crate::base::Status};

pub type RuntimeSetTime = eficall! {fn(
    *mut Time,
) -> crate::base::Status};

pub type RuntimeGetWakeupTime = eficall! {fn(
    *mut crate::base::Boolean,
    *mut crate::base::Boolean,
    *mut Time,
) -> crate::base::Status};

pub type RuntimeSetWakeupTime = eficall! {fn(
    crate::base::Boolean,
    *mut Time,
) -> crate::base::Status};

pub type RuntimeSetVirtualAddressMap = eficall! {fn(
    usize,
    usize,
    u32,
    *mut MemoryDescriptor,
) -> crate::base::Status};

pub type RuntimeConvertPointer = eficall! {fn(
    usize,
    *mut *mut core::ffi::c_void,
) -> crate::base::Status};

pub type RuntimeGetVariable = eficall! {fn(
    *mut crate::base::Char16,
    *mut crate::base::Guid,
    *mut u32,
    *mut usize,
    *mut core::ffi::c_void,
) -> crate::base::Status};

pub type RuntimeGetNextVariableName = eficall! {fn(
    *mut usize,
    *mut crate::base::Char16,
    *mut crate::base::Guid,
) -> crate::base::Status};

pub type RuntimeSetVariable = eficall! {fn(
    *mut crate::base::Char16,
    *mut crate::base::Guid,
    u32,
    usize,
    *mut core::ffi::c_void,
) -> crate::base::Status};

pub type RuntimeGetNextHighMonoCount = eficall! {fn(
    *mut u32,
) -> crate::base::Status};

pub type RuntimeResetSystem = eficall! {fn(
    ResetType,
    crate::base::Status,
    usize,
    *mut core::ffi::c_void,
)};

pub type RuntimeUpdateCapsule = eficall! {fn(
    *mut *mut CapsuleHeader,
    usize,
    crate::base::PhysicalAddress,
) -> crate::base::Status};

pub type RuntimeQueryCapsuleCapabilities = eficall! {fn(
    *mut *mut CapsuleHeader,
    usize,
    *mut u64,
    *mut ResetType,
) -> crate::base::Status};

pub type RuntimeQueryVariableInfo = eficall! {fn(
    u32,
    *mut u64,
    *mut u64,
    *mut u64,
) -> crate::base::Status};

#[repr(C)]
pub struct RuntimeServices {
    pub hdr: TableHeader,

    pub get_time: RuntimeGetTime,
    pub set_time: RuntimeSetTime,
    pub get_wakeup_time: RuntimeGetWakeupTime,
    pub set_wakeup_time: RuntimeSetWakeupTime,

    pub set_virtual_address_map: RuntimeSetVirtualAddressMap,
    pub convert_pointer: RuntimeConvertPointer,

    pub get_variable: RuntimeGetVariable,
    pub get_next_variable_name: RuntimeGetNextVariableName,
    pub set_variable: RuntimeSetVariable,

    pub get_next_high_mono_count: RuntimeGetNextHighMonoCount,
    pub reset_system: RuntimeResetSystem,

    pub update_capsule: RuntimeUpdateCapsule,
    pub query_capsule_capabilities: RuntimeQueryCapsuleCapabilities,
    pub query_variable_info: RuntimeQueryVariableInfo,
}

pub const BOOT_SERVICES_SIGNATURE: u64 = 0x56524553544f4f42u64; // "BOOTSERV"
pub const BOOT_SERVICES_REVISION: u32 = SPECIFICATION_REVISION;

pub type BootRaiseTpl = eficall! {fn(
    crate::base::Tpl,
) -> crate::base::Tpl};

pub type BootRestoreTpl = eficall! {fn(
    crate::base::Tpl,
)};

pub type BootAllocatePages = eficall! {fn(
    AllocateType,
    MemoryType,
    usize,
    *mut crate::base::PhysicalAddress,
) -> crate::base::Status};

pub type BootFreePages = eficall! {fn(
    crate::base::PhysicalAddress,
    usize,
) -> crate::base::Status};

pub type BootGetMemoryMap = eficall! {fn(
    *mut usize,
    *mut MemoryDescriptor,
    *mut usize,
    *mut usize,
    *mut u32,
) -> crate::base::Status};

pub type BootAllocatePool = eficall! {fn(
    MemoryType,
    usize,
    *mut *mut core::ffi::c_void,
) -> crate::base::Status};

pub type BootFreePool = eficall! {fn(
    *mut core::ffi::c_void,
) -> crate::base::Status};

pub type BootCreateEvent = eficall! {fn(
    u32,
    crate::base::Tpl,
    Option<EventNotify>,
    *mut core::ffi::c_void,
    *mut crate::base::Event,
) -> crate::base::Status};

pub type BootSetTimer = eficall! {fn(
    crate::base::Event,
    TimerDelay,
    u64,
) -> crate::base::Status};

pub type BootWaitForEvent = eficall! {fn(
    usize,
    *mut crate::base::Event,
    *mut usize,
) -> crate::base::Status};

pub type BootSignalEvent = eficall! {fn(
    crate::base::Event,
) -> crate::base::Status};

pub type BootCloseEvent = eficall! {fn(
    crate::base::Event,
) -> crate::base::Status};

pub type BootCheckEvent = eficall! {fn(
    crate::base::Event,
) -> crate::base::Status};

pub type BootInstallProtocolInterface = eficall! {fn(
    *mut crate::base::Handle,
    *mut crate::base::Guid,
    InterfaceType,
    *mut core::ffi::c_void,
) -> crate::base::Status};

pub type BootReinstallProtocolInterface = eficall! {fn(
    crate::base::Handle,
    *mut crate::base::Guid,
    *mut core::ffi::c_void,
    *mut core::ffi::c_void,
) -> crate::base::Status};

pub type BootUninstallProtocolInterface = eficall! {fn(
    crate::base::Handle,
    *mut crate::base::Guid,
    *mut core::ffi::c_void,
) -> crate::base::Status};

pub type BootHandleProtocol = eficall! {fn(
    crate::base::Handle,
    *mut crate::base::Guid,
    *mut *mut core::ffi::c_void,
) -> crate::base::Status};

pub type BootRegisterProtocolNotify = eficall! {fn(
    *mut crate::base::Guid,
    crate::base::Event,
    *mut *mut core::ffi::c_void,
) -> crate::base::Status};

pub type BootLocateHandle = eficall! {fn(
    LocateSearchType,
    *mut crate::base::Guid,
    *mut core::ffi::c_void,
    *mut usize,
    *mut crate::base::Handle,
) -> crate::base::Status};

pub type BootLocateDevicePath = eficall! {fn(
    *mut crate::base::Guid,
    *mut *mut crate::protocols::device_path::Protocol,
    *mut crate::base::Handle,
) -> crate::base::Status};

pub type BootInstallConfigurationTable = eficall! {fn(
    *mut crate::base::Guid,
    *mut core::ffi::c_void,
) -> crate::base::Status};

pub type BootLoadImage = eficall! {fn(
    crate::base::Boolean,
    crate::base::Handle,
    *mut crate::protocols::device_path::Protocol,
    *mut core::ffi::c_void,
    usize,
    *mut crate::base::Handle,
) -> crate::base::Status};

pub type BootStartImage = eficall! {fn(
    crate::base::Handle,
    *mut usize,
    *mut *mut crate::base::Char16,
) -> crate::base::Status};

pub type BootExit = eficall! {fn(
    crate::base::Handle,
    crate::base::Status,
    usize,
    *mut crate::base::Char16,
) -> crate::base::Status};

pub type BootUnloadImage = eficall! {fn(
    crate::base::Handle,
) -> crate::base::Status};

pub type BootExitBootServices = eficall! {fn(
    crate::base::Handle,
    usize,
) -> crate::base::Status};

pub type BootGetNextMonotonicCount = eficall! {fn(
    *mut u64,
) -> crate::base::Status};

pub type BootStall = eficall! {fn(
    usize,
) -> crate::base::Status};

pub type BootSetWatchdogTimer = eficall! {fn(
    usize,
    u64,
    usize,
    *mut crate::base::Char16,
) -> crate::base::Status};

pub type BootConnectController = eficall! {fn(
    crate::base::Handle,
    *mut crate::base::Handle,
    *mut crate::protocols::device_path::Protocol,
    crate::base::Boolean,
) -> crate::base::Status};

pub type BootDisconnectController = eficall! {fn(
    crate::base::Handle,
    crate::base::Handle,
    crate::base::Handle,
) -> crate::base::Status};

pub type BootOpenProtocol = eficall! {fn(
    crate::base::Handle,
    *mut crate::base::Guid,
    *mut *mut core::ffi::c_void,
    crate::base::Handle,
    crate::base::Handle,
    u32,
) -> crate::base::Status};

pub type BootCloseProtocol = eficall! {fn(
    crate::base::Handle,
    *mut crate::base::Guid,
    crate::base::Handle,
    crate::base::Handle,
) -> crate::base::Status};

pub type BootOpenProtocolInformation = eficall! {fn(
    crate::base::Handle,
    *mut crate::base::Guid,
    *mut *mut OpenProtocolInformationEntry,
    *mut usize,
) -> crate::base::Status};

pub type BootProtocolsPerHandle = eficall! {fn(
    crate::base::Handle,
    *mut *mut *mut crate::base::Guid,
    *mut usize,
) -> crate::base::Status};

pub type BootLocateHandleBuffer = eficall! {fn(
    LocateSearchType,
    *mut crate::base::Guid,
    *mut core::ffi::c_void,
    *mut usize,
    *mut *mut crate::base::Handle,
) -> crate::base::Status};

pub type BootLocateProtocol = eficall! {fn(
    *mut crate::base::Guid,
    *mut core::ffi::c_void,
    *mut *mut core::ffi::c_void,
) -> crate::base::Status};

pub type BootInstallMultipleProtocolInterfaces = eficall! {fn(
    *mut crate::base::Handle,
    // XXX: Actual definition is variadic. See eficall!{} for details.
    *mut core::ffi::c_void,
    *mut core::ffi::c_void,
) -> crate::base::Status};

pub type BootUninstallMultipleProtocolInterfaces = eficall! {fn(
    *mut crate::base::Handle,
    // XXX: Actual definition is variadic. See eficall!{} for details.
    *mut core::ffi::c_void,
    *mut core::ffi::c_void,
) -> crate::base::Status};

pub type BootCalculateCrc32 = eficall! {fn(
    *mut core::ffi::c_void,
    usize,
    *mut u32,
) -> crate::base::Status};

pub type BootCopyMem = eficall! {fn(
    *mut core::ffi::c_void,
    *mut core::ffi::c_void,
    usize,
)};

pub type BootSetMem = eficall! {fn(
    *mut core::ffi::c_void,
    usize,
    u8,
)};

pub type BootCreateEventEx = eficall! {fn(
    u32,
    crate::base::Tpl,
    Option<EventNotify>,
    *const core::ffi::c_void,
    *const crate::base::Guid,
    *mut crate::base::Event,
) -> crate::base::Status};

#[repr(C)]
pub struct BootServices {
    pub hdr: TableHeader,

    pub raise_tpl: BootRaiseTpl,
    pub restore_tpl: BootRestoreTpl,

    pub allocate_pages: BootAllocatePages,
    pub free_pages: BootFreePages,
    pub get_memory_map: BootGetMemoryMap,
    pub allocate_pool: BootAllocatePool,
    pub free_pool: BootFreePool,

    pub create_event: BootCreateEvent,
    pub set_timer: BootSetTimer,
    pub wait_for_event: BootWaitForEvent,
    pub signal_event: BootSignalEvent,
    pub close_event: BootCloseEvent,
    pub check_event: BootCheckEvent,

    pub install_protocol_interface: BootInstallProtocolInterface,
    pub reinstall_protocol_interface: BootReinstallProtocolInterface,
    pub uninstall_protocol_interface: BootUninstallProtocolInterface,
    pub handle_protocol: BootHandleProtocol,
    pub reserved: *mut core::ffi::c_void,
    pub register_protocol_notify: BootRegisterProtocolNotify,
    pub locate_handle: BootLocateHandle,
    pub locate_device_path: BootLocateDevicePath,

    pub install_configuration_table: BootInstallConfigurationTable,

    pub load_image: BootLoadImage,
    pub start_image: BootStartImage,
    pub exit: BootExit,
    pub unload_image: BootUnloadImage,
    pub exit_boot_services: BootExitBootServices,

    pub get_next_monotonic_count: BootGetNextMonotonicCount,
    pub stall: BootStall,
    pub set_watchdog_timer: BootSetWatchdogTimer,

    // 1.1+
    pub connect_controller: BootConnectController,
    pub disconnect_controller: BootDisconnectController,

    pub open_protocol: BootOpenProtocol,
    pub close_protocol: BootCloseProtocol,
    pub open_protocol_information: BootOpenProtocolInformation,

    pub protocols_per_handle: BootProtocolsPerHandle,
    pub locate_handle_buffer: BootLocateHandleBuffer,
    pub locate_protocol: BootLocateProtocol,
    pub install_multiple_protocol_interfaces: BootInstallMultipleProtocolInterfaces,
    pub uninstall_multiple_protocol_interfaces: BootUninstallMultipleProtocolInterfaces,

    pub calculate_crc32: BootCalculateCrc32,

    pub copy_mem: BootCopyMem,
    pub set_mem: BootSetMem,

    // 2.0+
    pub create_event_ex: BootCreateEventEx,
}

pub const SYSTEM_TABLE_REVISION_2_70: u32 = (2 << 16) | (70);
pub const SYSTEM_TABLE_REVISION_2_60: u32 = (2 << 16) | (60);
pub const SYSTEM_TABLE_REVISION_2_50: u32 = (2 << 16) | (50);
pub const SYSTEM_TABLE_REVISION_2_40: u32 = (2 << 16) | (40);
pub const SYSTEM_TABLE_REVISION_2_31: u32 = (2 << 16) | (31);
pub const SYSTEM_TABLE_REVISION_2_30: u32 = (2 << 16) | (30);
pub const SYSTEM_TABLE_REVISION_2_20: u32 = (2 << 16) | (20);
pub const SYSTEM_TABLE_REVISION_2_10: u32 = (2 << 16) | (10);
pub const SYSTEM_TABLE_REVISION_2_00: u32 = (2 << 16) | (0);
pub const SYSTEM_TABLE_REVISION_1_10: u32 = (1 << 16) | (10);
pub const SYSTEM_TABLE_REVISION_1_02: u32 = (1 << 16) | (2);

pub const SYSTEM_TABLE_SIGNATURE: u64 = 0x5453595320494249u64; // "IBI SYST"
pub const SYSTEM_TABLE_REVISION: u32 = SYSTEM_TABLE_REVISION_2_70;

#[repr(C)]
pub struct SystemTable {
    pub hdr: TableHeader,
    pub firmware_vendor: *mut crate::base::Char16,
    pub firmware_revision: u32,

    pub console_in_handle: crate::base::Handle,
    pub con_in: *mut crate::protocols::simple_text_input::Protocol,
    pub console_out_handle: crate::base::Handle,
    pub con_out: *mut crate::protocols::simple_text_output::Protocol,
    pub standard_error_handle: crate::base::Handle,
    pub std_err: *mut crate::protocols::simple_text_output::Protocol,

    pub runtime_services: *mut RuntimeServices,
    pub boot_services: *mut BootServices,

    pub number_of_table_entries: usize,
    pub configuration_table: *mut ConfigurationTable,
}