html-to-markdown 2.27.2 → 2.27.3

data/rust-vendor/r-efi-5.3.0/src/protocols/memory_attribute.rs

@@ -0,0 +1,40 @@
+//! Memory Attribute Protocol
+//!
+//! Provides an interface to abstract setting or getting of memory attributes in the UEFI environment.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0xf4560cf6,
+    0x40ec,
+    0x4b4a,
+    0xa1,
+    0x92,
+    &[0xbf, 0x1d, 0x57, 0xd0, 0xb1, 0x89],
+);
+
+pub type GetMemoryAttributes = eficall! {fn(
+    *mut Protocol,
+    crate::base::PhysicalAddress,
+    u64,
+    *mut u64,
+) -> crate::base::Status};
+
+pub type SetMemoryAttributes = eficall! {fn(
+    *mut Protocol,
+    crate::base::PhysicalAddress,
+    u64,
+    u64,
+) -> crate::base::Status};
+
+pub type ClearMemoryAttributes = eficall! {fn(
+    *mut Protocol,
+    crate::base::PhysicalAddress,
+    u64,
+    u64,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub get_memory_attributes: GetMemoryAttributes,
+    pub set_memory_attributes: SetMemoryAttributes,
+    pub clear_memory_attributes: ClearMemoryAttributes,
+}

data/rust-vendor/r-efi-5.3.0/src/protocols/mp_services.rs

@@ -0,0 +1,121 @@
+//! Multi-Processor Services Protocol
+//!
+//! This Protocol is defined in the UEFI Platform Integration Specification,
+//! Section 13.4.
+//!
+//! This provides a generalized way of performing the following tasks:
+//! - Retrieving information of multi-processor environments.
+//! - Dispatching user-provided function to APs.
+//! - Maintain MP-related processor status.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x3fdda605,
+    0xa76e,
+    0x4f46,
+    0xad,
+    0x29,
+    &[0x12, 0xf4, 0x53, 0x1b, 0x3d, 0x08],
+);
+
+pub const PROCESSOR_AS_BSP_BIT: u32 = 0x00000001;
+pub const PROCESSOR_ENABLED_BIT: u32 = 0x00000002;
+pub const PROCESSOR_HEALTH_STATUS_BIT: u32 = 0x00000004;
+
+pub const END_OF_CPU_LIST: usize = usize::MAX;
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CpuPhysicalLocation {
+    pub package: u32,
+    pub core: u32,
+    pub thread: u32,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct CpuPhysicalLocation2 {
+    pub package: u32,
+    pub module: u32,
+    pub tile: u32,
+    pub die: u32,
+    pub core: u32,
+    pub thread: u32,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union ExtendedProcessorInformation {
+    pub location2: CpuPhysicalLocation2,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct ProcessorInformation {
+    pub processor_id: u64,
+    pub status_flag: u32,
+    pub location: CpuPhysicalLocation,
+    pub extended_information: ExtendedProcessorInformation,
+}
+
+pub type ApProcedure = eficall! {fn(*mut core::ffi::c_void)};
+
+pub type GetNumberOfProcessors = eficall! {fn(
+    *mut Protocol,
+    *mut usize,
+    *mut usize,
+) -> crate::base::Status};
+
+pub type GetProcessorInfo = eficall! {fn(
+    *mut Protocol,
+    usize,
+    *mut ProcessorInformation,
+) -> crate::base::Status};
+
+pub type StartupAllAps = eficall! {fn(
+    *mut Protocol,
+    ApProcedure,
+    crate::base::Boolean,
+    crate::base::Event,
+    usize,
+    *mut core::ffi::c_void,
+    *mut *mut usize,
+) -> crate::base::Status};
+
+pub type StartupThisAp = eficall! {fn(
+    *mut Protocol,
+    ApProcedure,
+    usize,
+    crate::base::Event,
+    usize,
+    *mut core::ffi::c_void,
+    *mut crate::base::Boolean,
+) -> crate::base::Status};
+
+pub type SwitchBsp = eficall! {fn(
+    *mut Protocol,
+    usize,
+    crate::base::Boolean,
+) -> crate::base::Status};
+
+pub type EnableDisableAp = eficall! {fn(
+    *mut Protocol,
+    usize,
+    crate::base::Boolean,
+    *mut u32,
+) -> crate::base::Status};
+
+pub type WhoAmI = eficall! {fn(
+    *mut Protocol,
+    *mut usize,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub get_number_of_processors: GetNumberOfProcessors,
+    pub get_processor_info: GetProcessorInfo,
+    pub startup_all_aps: StartupAllAps,
+    pub startup_this_ap: StartupThisAp,
+    pub switch_bsp: SwitchBsp,
+    pub enable_disable_ap: EnableDisableAp,
+    pub who_am_i: WhoAmI,
+}

data/rust-vendor/r-efi-5.3.0/src/protocols/pci_io.rs

@@ -0,0 +1,203 @@
+//! PCI I/O Protocol
+//!
+//! Used by code, typically drivers, running in the EFI boot services
+//! environment to access memory and I/O on a PCI controller.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x4cf5b200,
+    0x68b8,
+    0x4ca5,
+    0x9e,
+    0xec,
+    &[0xb2, 0x3e, 0x3f, 0x50, 0x02, 0x9a],
+);
+
+pub type Width = u32;
+
+pub const WIDTH_UINT8: Width = 0x00000000;
+pub const WIDTH_UINT16: Width = 0x00000001;
+pub const WIDTH_UINT32: Width = 0x00000002;
+pub const WIDTH_UINT64: Width = 0x00000003;
+pub const WIDTH_FIFO_UINT8: Width = 0x00000004;
+pub const WIDTH_FIFO_UINT16: Width = 0x00000005;
+pub const WIDTH_FIFO_UINT32: Width = 0x00000006;
+pub const WIDTH_FIFO_UINT64: Width = 0x00000007;
+pub const WIDTH_FILL_UINT8: Width = 0x00000008;
+pub const WIDTH_FILL_UINT16: Width = 0x00000009;
+pub const WIDTH_FILL_UINT32: Width = 0x0000000a;
+pub const WIDTH_FILL_UINT64: Width = 0x0000000b;
+pub const WIDTH_MAXIMUM: Width = 0x0000000c;
+
+pub type Operation = u32;
+
+pub const OPERATION_BUS_MASTER_READ: Operation = 0x00000000;
+pub const OPERATION_BUS_MASTER_WRITE: Operation = 0x00000001;
+pub const OPERATION_BUS_MASTER_COMMON_BUFFER: Operation = 0x00000002;
+pub const OPERATION_MAXIMUM: Operation = 0x00000003;
+
+pub type Attribute = u64;
+
+pub const ATTRIBUTE_ISA_MOTHERBOARD_IO: Attribute = 0x00000001;
+pub const ATTRIBUTE_ISA_IO: Attribute = 0x00000002;
+pub const ATTRIBUTE_VGA_PALETTE_IO: Attribute = 0x00000004;
+pub const ATTRIBUTE_VGA_MEMORY: Attribute = 0x00000008;
+pub const ATTRIBUTE_VGA_IO: Attribute = 0x00000010;
+pub const ATTRIBUTE_IDE_PRIMARY_IO: Attribute = 0x00000020;
+pub const ATTRIBUTE_IDE_SECONDARY_IO: Attribute = 0x00000040;
+pub const ATTRIBUTE_MEMORY_WRITE_COMBINE: Attribute = 0x00000080;
+pub const ATTRIBUTE_IO: Attribute = 0x00000100;
+pub const ATTRIBUTE_MEMORY: Attribute = 0x00000200;
+pub const ATTRIBUTE_BUS_MASTER: Attribute = 0x00000400;
+pub const ATTRIBUTE_MEMORY_CACHED: Attribute = 0x00000800;
+pub const ATTRIBUTE_MEMORY_DISABLE: Attribute = 0x00001000;
+pub const ATTRIBUTE_EMBEDDED_DEVICE: Attribute = 0x00002000;
+pub const ATTRIBUTE_EMBEDDED_ROM: Attribute = 0x00004000;
+pub const ATTRIBUTE_DUAL_ADDRESS_CYCLE: Attribute = 0x00008000;
+pub const ATTRIBUTE_ISA_IO_16: Attribute = 0x00010000;
+pub const ATTRIBUTE_VGA_PALETTE_IO_16: Attribute = 0x00020000;
+pub const ATTRIBUTE_VGA_IO_16: Attribute = 0x00040000;
+
+pub type AttributeOperation = u32;
+
+pub const ATTRIBUTE_OPERATION_GET: AttributeOperation = 0x00000000;
+pub const ATTRIBUTE_OPERATION_SET: AttributeOperation = 0x00000001;
+pub const ATTRIBUTE_OPERATION_ENABLE: AttributeOperation = 0x00000002;
+pub const ATTRIBUTE_OPERATION_DISABLE: AttributeOperation = 0x00000003;
+pub const ATTRIBUTE_OPERATION_SUPPORTED: AttributeOperation = 0x00000004;
+pub const ATTRIBUTE_OPERATION_MAXIMUM: AttributeOperation = 0x00000005;
+
+pub const PASS_THROUGH_BAR: u8 = 0xff;
+
+pub type ProtocolPollIoMem = eficall! {fn(
+    *mut Protocol,
+    Width,
+    u8,
+    u64,
+    u64,
+    u64,
+    u64,
+    *mut u64,
+) -> crate::base::Status};
+
+pub type ProtocolIoMem = eficall! {fn(
+    *mut Protocol,
+    Width,
+    u8,
+    u64,
+    usize,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolConfig = eficall! {fn(
+    *mut Protocol,
+    Width,
+    u32,
+    usize,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolCopyMem = eficall! {fn(
+    *mut Protocol,
+    Width,
+    u8,
+    u64,
+    u8,
+    u64,
+    usize,
+) -> crate::base::Status};
+
+pub type ProtocolMap = eficall! {fn(
+    *mut Protocol,
+    Operation,
+    *mut core::ffi::c_void,
+    *mut usize,
+    *mut crate::base::PhysicalAddress,
+    *mut *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolUnmap = eficall! {fn(
+    *mut Protocol,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolAllocateBuffer = eficall! {fn(
+    *mut Protocol,
+    crate::system::AllocateType,
+    crate::system::MemoryType,
+    usize,
+    *mut *mut core::ffi::c_void,
+    Attribute,
+) -> crate::base::Status};
+
+pub type ProtocolFreeBuffer = eficall! {fn(
+    *mut Protocol,
+    usize,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolFlush = eficall! {fn(
+    *mut Protocol,
+) -> crate::base::Status};
+
+pub type ProtocolGetLocation = eficall! {fn(
+    *mut Protocol,
+    *mut usize,
+    *mut usize,
+    *mut usize,
+    *mut usize,
+) -> crate::base::Status};
+
+pub type ProtocolAttributes = eficall! {fn(
+    *mut Protocol,
+    AttributeOperation,
+    Attribute,
+    *mut Attribute,
+) -> crate::base::Status};
+
+pub type ProtocolGetBarAttributes = eficall! {fn(
+    *mut Protocol,
+    u8,
+    *mut Attribute,
+    *mut *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolSetBarAttributes = eficall! {fn(
+    *mut Protocol,
+    Attribute,
+    u8,
+    *mut u64,
+    *mut u64,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Access {
+    pub read: ProtocolIoMem,
+    pub write: ProtocolIoMem,
+}
+
+#[repr(C)]
+pub struct ConfigAccess {
+    pub read: ProtocolConfig,
+    pub write: ProtocolConfig,
+}
+
+#[repr(C)]
+pub struct Protocol {
+    pub poll_mem: ProtocolPollIoMem,
+    pub poll_io: ProtocolPollIoMem,
+    pub mem: Access,
+    pub io: Access,
+    pub pci: ConfigAccess,
+    pub copy_mem: ProtocolCopyMem,
+    pub map: ProtocolMap,
+    pub unmap: ProtocolUnmap,
+    pub allocate_buffer: ProtocolAllocateBuffer,
+    pub free_buffer: ProtocolFreeBuffer,
+    pub flush: ProtocolFlush,
+    pub get_location: ProtocolGetLocation,
+    pub attributes: ProtocolAttributes,
+    pub get_bar_attributes: ProtocolGetBarAttributes,
+    pub set_bar_attributes: ProtocolSetBarAttributes,
+    pub rom_size: u64,
+    pub rom_image: *mut core::ffi::c_void,
+}

data/rust-vendor/r-efi-5.3.0/src/protocols/platform_driver_override.rs

@@ -0,0 +1,46 @@
+//! Platform Driver Override Protocol
+//!
+//! This protocol matches one or more drivers to a controller. A platform driver
+//! produces this protocol, and it is installed on a separate handle. This
+//! protocol is used by the `EFI_BOOT_SERVICES.ConnectController()` boot service
+//! to select the best driver for a controller. All of the drivers returned by
+//! this protocol have a higher precedence than drivers found from an EFI Bus
+//! Specific Driver Override Protocol or drivers found from the general UEFI
+//! driver binding search algorithm. If more than one driver is returned by this
+//! protocol, then the drivers are returned in order from highest precedence to
+//! lowest precedence.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x6b30c738,
+    0xa391,
+    0x11d4,
+    0x9a,
+    0x3b,
+    &[0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d],
+);
+
+pub type ProtocolGetDriver = eficall! {fn(
+    *mut Protocol,
+    crate::base::Handle,
+    *mut crate::base::Handle,
+) -> crate::base::Status};
+
+pub type ProtocolGetDriverPath = eficall! {fn(
+    *mut Protocol,
+    crate::base::Handle,
+    *mut *mut crate::protocols::device_path::Protocol
+) -> crate::base::Status};
+
+pub type ProtocolDriverLoaded = eficall! {fn(
+    *mut Protocol,
+    crate::base::Handle,
+    *mut crate::protocols::device_path::Protocol,
+    crate::base::Handle,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub get_driver: ProtocolGetDriver,
+    pub get_driver_path: ProtocolGetDriverPath,
+    pub driver_loaded: ProtocolDriverLoaded,
+}

data/rust-vendor/r-efi-5.3.0/src/protocols/rng.rs

@@ -0,0 +1,83 @@
+//! Random Number Generator Protocol
+//!
+//! This protocol is used to provide random numbers for use in applications, or
+//! entropy for seeding other random number generators.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x3152bca5,
+    0xeade,
+    0x433d,
+    0x86,
+    0x2e,
+    &[0xc0, 0x1c, 0xdc, 0x29, 0x1f, 0x44],
+);
+
+pub type Algorithm = crate::base::Guid;
+
+pub const ALGORITHM_SP800_90_HASH_256_GUID: Algorithm = crate::base::Guid::from_fields(
+    0xa7af67cb,
+    0x603b,
+    0x4d42,
+    0xba,
+    0x21,
+    &[0x70, 0xbf, 0xb6, 0x29, 0x3f, 0x96],
+);
+pub const ALGORITHM_SP800_90_HMAC_256_GUID: Algorithm = crate::base::Guid::from_fields(
+    0xc5149b43,
+    0xae85,
+    0x4f53,
+    0x99,
+    0x82,
+    &[0xb9, 0x43, 0x35, 0xd3, 0xa9, 0xe7],
+);
+pub const ALGORITHM_SP800_90_CTR_256_GUID: Algorithm = crate::base::Guid::from_fields(
+    0x44f0de6e,
+    0x4d8c,
+    0x4045,
+    0xa8,
+    0xc7,
+    &[0x4d, 0xd1, 0x68, 0x85, 0x6b, 0x9e],
+);
+pub const ALGORITHM_X9_31_3DES_GUID: Algorithm = crate::base::Guid::from_fields(
+    0x63c4785a,
+    0xca34,
+    0x4012,
+    0xa3,
+    0xc8,
+    &[0x0b, 0x6a, 0x32, 0x4f, 0x55, 0x46],
+);
+pub const ALGORITHM_X9_31_AES_GUID: Algorithm = crate::base::Guid::from_fields(
+    0xacd03321,
+    0x777e,
+    0x4d3d,
+    0xb1,
+    0xc8,
+    &[0x20, 0xcf, 0xd8, 0x88, 0x20, 0xc9],
+);
+pub const ALGORITHM_RAW: Algorithm = crate::base::Guid::from_fields(
+    0xe43176d7,
+    0xb6e8,
+    0x4827,
+    0xb7,
+    0x84,
+    &[0x7f, 0xfd, 0xc4, 0xb6, 0x85, 0x61],
+);
+
+pub type ProtocolGetInfo = eficall! {fn(
+    *mut Protocol,
+    *mut usize,
+    *mut Algorithm,
+) -> crate::base::Status};
+
+pub type ProtocolGetRng = eficall! {fn(
+    *mut Protocol,
+    *mut Algorithm,
+    usize,
+    *mut u8,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub get_info: ProtocolGetInfo,
+    pub get_rng: ProtocolGetRng,
+}

data/rust-vendor/r-efi-5.3.0/src/protocols/service_binding.rs

@@ -0,0 +1,20 @@
+//! Service Binding Protocol
+//!
+//! Provides services that are required to create and destroy child handles
+//! that support a given set of protocols.
+
+pub type ProtocolCreateChild = eficall! {fn(
+    *mut Protocol,
+    *mut crate::base::Handle,
+) -> crate::base::Status};
+
+pub type ProtocolDestroyChild = eficall! {fn(
+    *mut Protocol,
+    crate::base::Handle,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub create_child: ProtocolCreateChild,
+    pub destroy_child: ProtocolDestroyChild,
+}