html-to-markdown 2.27.2 → 2.27.3

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

@@ -0,0 +1,42 @@
+//! Debug Port Protocol
+//!
+//! It provides the communication link between the debug agent and the remote host.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0xeba4e8d2,
+    0x3858,
+    0x41ec,
+    0xa2,
+    0x81,
+    &[0x26, 0x47, 0xba, 0x96, 0x60, 0xd0],
+);
+
+pub type Reset = eficall! {fn(
+    *mut Protocol,
+) -> *mut crate::base::Status};
+
+pub type Write = eficall! {fn(
+    *mut Protocol,
+    u32,
+    *mut usize,
+    *mut core::ffi::c_void
+) -> *mut crate::base::Status};
+
+pub type Read = eficall! {fn(
+    *mut Protocol,
+    u32,
+    *mut usize,
+    *mut core::ffi::c_void
+) -> *mut crate::base::Status};
+
+pub type Poll = eficall! {fn(
+    *mut Protocol,
+) -> *mut crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub reset: Reset,
+    pub write: Write,
+    pub read: Read,
+    pub poll: Poll,
+}

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

@@ -0,0 +1,37 @@
+//! Decompress Protocol
+//!
+//! The decompress protocol provides a decompression service that allows a compressed source
+//! buffer in memory to be decompressed into a destination buffer in memory.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0xd8117cfe,
+    0x94a6,
+    0x11d4,
+    0x9a,
+    0x3a,
+    &[0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d],
+);
+
+pub type ProtocolGetInfo = eficall! {fn(
+    *mut Protocol,
+    *mut core::ffi::c_void,
+    u32,
+    *mut u32,
+    *mut u32,
+) -> crate::base::Status};
+
+pub type ProtocolDecompress = eficall! {fn(
+    *mut Protocol,
+    *mut core::ffi::c_void,
+    u32,
+    *mut core::ffi::c_void,
+    u32,
+    *mut core::ffi::c_void,
+    u32,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub get_info: ProtocolGetInfo,
+    pub decompress: ProtocolDecompress,
+}

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

@@ -0,0 +1,82 @@
+//! Device Path Protocol
+//!
+//! The device path protocol defines how to obtain generic path/location information
+//! concerning the phisycal or logical device.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x09576e91,
+    0x6d3f,
+    0x11d2,
+    0x8e,
+    0x39,
+    &[0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b],
+);
+
+pub const TYPE_HARDWARE: u8 = 0x01;
+pub const TYPE_ACPI: u8 = 0x02;
+pub const TYPE_MESSAGING: u8 = 0x03;
+pub const TYPE_MEDIA: u8 = 0x04;
+pub const TYPE_BIOS: u8 = 0x05;
+pub const TYPE_END: u8 = 0x7f;
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct Protocol {
+    pub r#type: u8,
+    pub sub_type: u8,
+    pub length: [u8; 2],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct End {
+    pub header: Protocol,
+}
+
+impl End {
+    pub const SUBTYPE_INSTANCE: u8 = 0x01;
+    pub const SUBTYPE_ENTIRE: u8 = 0xff;
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct Hardware {
+    pub header: Protocol,
+}
+
+impl Hardware {
+    pub const SUBTYPE_PCI: u8 = 0x01;
+    pub const SUBTYPE_PCCARD: u8 = 0x02;
+    pub const SUBTYPE_MMAP: u8 = 0x03;
+    pub const SUBTYPE_VENDOR: u8 = 0x04;
+    pub const SUBTYPE_CONTROLLER: u8 = 0x05;
+    pub const SUBTYPE_BMC: u8 = 0x06;
+}
+
+#[repr(C, packed)]
+#[derive(Clone, Copy, Debug)]
+pub struct HardDriveMedia {
+    pub header: Protocol,
+    pub partition_number: u32,
+    pub partition_start: u64,
+    pub partition_size: u64,
+    pub partition_signature: [u8; 16],
+    pub partition_format: u8,
+    pub signature_type: u8,
+}
+
+pub struct Media {
+    pub header: Protocol,
+}
+
+impl Media {
+    pub const SUBTYPE_HARDDRIVE: u8 = 0x01;
+    pub const SUBTYPE_CDROM: u8 = 0x02;
+    pub const SUBTYPE_VENDOR: u8 = 0x03;
+    pub const SUBTYPE_FILE_PATH: u8 = 0x04;
+    pub const SUBTYPE_MEDIA_PROTOCOL: u8 = 0x05;
+    pub const SUBTYPE_PIWG_FIRMWARE_FILE: u8 = 0x06;
+    pub const SUBTYPE_PIWG_FIRMWARE_VOLUME: u8 = 0x07;
+    pub const SUBTYPE_RELATIVE_OFFSET_RANGE: u8 = 0x08;
+    pub const SUBTYPE_RAM_DISK: u8 = 0x09;
+}

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

@@ -0,0 +1,26 @@
+//! Device Path From Text Protocol
+//!
+//! Convert text to device paths and device nodes.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x5c99a21,
+    0xc70f,
+    0x4ad2,
+    0x8a,
+    0x5f,
+    &[0x35, 0xdf, 0x33, 0x43, 0xf5, 0x1e],
+);
+
+pub type DevicePathFromTextNode = eficall! {fn(
+    *const crate::base::Char16,
+) -> *mut crate::protocols::device_path::Protocol};
+
+pub type DevicePathFromTextPath = eficall! {fn(
+    *const crate::base::Char16,
+) -> *mut crate::protocols::device_path::Protocol};
+
+#[repr(C)]
+pub struct Protocol {
+    pub convert_text_to_device_node: DevicePathFromTextNode,
+    pub convert_text_to_device_path: DevicePathFromTextPath,
+}

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

@@ -0,0 +1,30 @@
+//! Device Path to Text Protocol
+//!
+//! Convert device nodes and paths to text.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x8b843e20,
+    0x8132,
+    0x4852,
+    0x90,
+    0xcc,
+    &[0x55, 0x1a, 0x4e, 0x4a, 0x7f, 0x1c],
+);
+
+pub type DevicePathToTextNode = eficall! {fn(
+    *mut crate::protocols::device_path::Protocol,
+    crate::base::Boolean,
+    crate::base::Boolean,
+) -> *mut crate::base::Char16};
+
+pub type DevicePathToTextPath = eficall! {fn(
+    *mut crate::protocols::device_path::Protocol,
+    crate::base::Boolean,
+    crate::base::Boolean,
+) -> *mut crate::base::Char16};
+
+#[repr(C)]
+pub struct Protocol {
+    pub convert_device_node_to_text: DevicePathToTextNode,
+    pub convert_device_path_to_text: DevicePathToTextPath,
+}

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

@@ -0,0 +1,63 @@
+//! Device Path Utilities Protocol
+//!
+//! The device-path utilities protocol provides common utilities for creating and manipulating
+//! device paths and device nodes.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x379be4e,
+    0xd706,
+    0x437d,
+    0xb0,
+    0x37,
+    &[0xed, 0xb8, 0x2f, 0xb7, 0x72, 0xa4],
+);
+
+pub type ProtocolGetDevicePathSize = eficall! {fn(
+    *const crate::protocols::device_path::Protocol,
+) -> usize};
+
+pub type ProtocolDuplicateDevicePath = eficall! {fn(
+    *const crate::protocols::device_path::Protocol,
+) -> *mut crate::protocols::device_path::Protocol};
+
+pub type ProtocolAppendDevicePath = eficall! {fn(
+    *const crate::protocols::device_path::Protocol,
+    *const crate::protocols::device_path::Protocol,
+) -> *mut crate::protocols::device_path::Protocol};
+
+pub type ProtocolAppendDeviceNode = eficall! {fn(
+    *const crate::protocols::device_path::Protocol,
+    *const crate::protocols::device_path::Protocol,
+) -> *mut crate::protocols::device_path::Protocol};
+
+pub type ProtocolAppendDevicePathInstance = eficall! {fn(
+    *const crate::protocols::device_path::Protocol,
+    *const crate::protocols::device_path::Protocol,
+) -> *mut crate::protocols::device_path::Protocol};
+
+pub type ProtocolGetNextDevicePathInstance = eficall! {fn(
+    *mut *mut crate::protocols::device_path::Protocol,
+    *mut usize,
+) -> *mut crate::protocols::device_path::Protocol};
+
+pub type ProtocolIsDevicePathMultiInstance = eficall! {fn(
+    *const crate::protocols::device_path::Protocol,
+) -> crate::base::Boolean};
+
+pub type ProtocolCreateDeviceNode = eficall! {fn(
+    u8,
+    u8,
+    u16,
+) -> *mut crate::protocols::device_path::Protocol};
+
+#[repr(C)]
+pub struct Protocol {
+    pub get_device_path_size: ProtocolGetDevicePathSize,
+    pub duplicate_device_path: ProtocolDuplicateDevicePath,
+    pub append_device_path: ProtocolAppendDevicePath,
+    pub append_device_node: ProtocolAppendDeviceNode,
+    pub append_device_path_instance: ProtocolAppendDevicePathInstance,
+    pub get_next_device_path_instance: ProtocolGetNextDevicePathInstance,
+    pub is_device_path_multi_instance: ProtocolIsDevicePathMultiInstance,
+    pub create_device_node: ProtocolCreateDeviceNode,
+}

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

@@ -0,0 +1,40 @@
+//! Disk I/O Protocol
+//!
+//! Abstracts block accesses of the Block I/O protocol to a more general offset-length protocol.
+//! Firmware is responsible for adding this protocol to any Block I/O interface that appears
+//! in the system that does not already have a Disk I/O protocol. File systems and other disk
+//! access code utilize the Disk I/O protocol.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0xce345171,
+    0xba0b,
+    0x11d2,
+    0x8e,
+    0x4f,
+    &[0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b],
+);
+
+pub const REVISION: u64 = 0x0000000000010000u64;
+
+pub type ProtocolReadDisk = eficall! {fn(
+    *mut Protocol,
+    u32,
+    u64,
+    usize,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolWriteDisk = eficall! {fn(
+    *mut Protocol,
+    u32,
+    u64,
+    usize,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub revision: u64,
+    pub read_disk: ProtocolReadDisk,
+    pub write_disk: ProtocolWriteDisk,
+}

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

@@ -0,0 +1,58 @@
+//! Disk I/O 2 Protocol
+//!
+//! Extends the Disk I/O protocol interface to enable non-blocking /
+//! asynchronous byte-oriented disk operation.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x151c8eae,
+    0x7f2c,
+    0x472c,
+    0x9e,
+    0x54,
+    &[0x98, 0x28, 0x19, 0x4f, 0x6a, 0x88],
+);
+
+pub const REVISION: u64 = 0x0000000000020000u64;
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct Token {
+    event: crate::base::Event,
+    transaction_status: crate::base::Status,
+}
+
+pub type ProtocolCancel = eficall! {fn(
+    *mut Protocol,
+) -> crate::base::Status};
+
+pub type ProtocolReadDiskEx = eficall! {fn(
+    *mut Protocol,
+    u32,
+    u64,
+    *mut Token,
+    usize,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolWriteDiskEx = eficall! {fn(
+    *mut Protocol,
+    u32,
+    u64,
+    *mut Token,
+    usize,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolFlushDiskEx = eficall! {fn(
+    *mut Protocol,
+    *mut Token,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub revision: u64,
+    pub cancel: ProtocolCancel,
+    pub read_disk_ex: ProtocolReadDiskEx,
+    pub write_disk_ex: ProtocolWriteDiskEx,
+    pub flush_disk_ex: ProtocolFlushDiskEx,
+}

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

@@ -0,0 +1,42 @@
+//! Driver Binding Protocol
+//!
+//! Provides the services required to determine if a driver supports a given controller. If
+//! a controller is supported, then it also provides routines to start and stop the controller.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x18a031ab,
+    0xb443,
+    0x4d1a,
+    0xa5,
+    0xc0,
+    &[0x0c, 0x09, 0x26, 0x1e, 0x9f, 0x71],
+);
+
+pub type ProtocolSupported = eficall! {fn(
+    *mut Protocol,
+    crate::base::Handle,
+    *mut crate::protocols::device_path::Protocol,
+) -> crate::base::Status};
+
+pub type ProtocolStart = eficall! {fn(
+    *mut Protocol,
+    crate::base::Handle,
+    *mut crate::protocols::device_path::Protocol,
+) -> crate::base::Status};
+
+pub type ProtocolStop = eficall! {fn(
+    *mut Protocol,
+    crate::base::Handle,
+    usize,
+    *mut crate::base::Handle,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub supported: ProtocolSupported,
+    pub start: ProtocolStart,
+    pub stop: ProtocolStop,
+    pub version: u32,
+    pub image_handle: crate::base::Handle,
+    pub driver_binding_handle: crate::base::Handle,
+}

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

@@ -0,0 +1,38 @@
+//! Driver Diagnostics Protocol
+//!
+//! Defined in UEFI Specification, Section 11.4
+//! Used to perform diagnostics on a controller that a UEFI driver is managing.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x4d330321,
+    0x025f,
+    0x4aac,
+    0x90,
+    0xd8,
+    &[0x5e, 0xd9, 0x00, 0x17, 0x3b, 0x63],
+);
+
+pub type Type = u32;
+
+pub const TYPE_STANDARD: Type = 0;
+pub const TYPE_EXTENDED: Type = 1;
+pub const TYPE_MANUFACTURING: Type = 2;
+pub const TYPE_CANCEL: Type = 3;
+pub const TYPE_MAXIMUM: Type = 4;
+
+pub type RunDiagnostics = eficall! {fn(
+    *mut Protocol,
+    crate::base::Handle,
+    crate::base::Handle,
+    Type,
+    *mut crate::base::Char8,
+    *mut *mut crate::base::Guid,
+    *mut usize,
+    *mut *mut crate::base::Char16,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub run_diagnostics: RunDiagnostics,
+    pub supported_languages: *mut crate::base::Char8,
+}

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

@@ -0,0 +1,23 @@
+//! Driver Family Override Protocol
+//!
+//! When installed, the Driver Family Override Protocol informs the UEFI Boot
+//! Service `ConnectController()` that this driver is higher priority than the
+//! list of drivers returned by the Bus Specific Driver Override Protocol.
+
+pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
+    0xb1ee129e,
+    0xda36,
+    0x4181,
+    0x91,
+    0xf8,
+    &[0x04, 0xa4, 0x92, 0x37, 0x66, 0xa7],
+);
+
+pub type ProtocolGetVersion = eficall! {fn(
+    *mut Protocol,
+) -> u32};
+
+#[repr(C)]
+pub struct Protocol {
+    pub get_version: ProtocolGetVersion,
+}

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

@@ -0,0 +1,183 @@
+//! File Protocol
+//!
+//! Provides an interface to interact with both files and directories. This protocol is typically
+//! obtained via an EFI_SIMPLE_FILE_SYSTEM protocol or via another EFI_FILE_PROTOCOL.
+
+pub const REVISION: u64 = 0x0000_0000_0001_0000u64;
+pub const REVISION2: u64 = 0x0000_0000_0002_0000u64;
+pub const LATEST_REVISION: u64 = REVISION2;
+
+pub const MODE_READ: u64 = 0x0000000000000001u64;
+pub const MODE_WRITE: u64 = 0x0000000000000002u64;
+pub const MODE_CREATE: u64 = 0x8000000000000000u64;
+
+pub const READ_ONLY: u64 = 0x0000000000000001u64;
+pub const HIDDEN: u64 = 0x0000000000000002u64;
+pub const SYSTEM: u64 = 0x0000000000000004u64;
+pub const RESERVED: u64 = 0x0000000000000008u64;
+pub const DIRECTORY: u64 = 0x0000000000000010u64;
+pub const ARCHIVE: u64 = 0x0000000000000020u64;
+pub const VALID_ATTR: u64 = 0x0000000000000037u64;
+
+pub const INFO_ID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x09576e92,
+    0x6d3f,
+    0x11d2,
+    0x8e,
+    0x39,
+    &[0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b],
+);
+pub const SYSTEM_INFO_ID: crate::base::Guid = crate::base::Guid::from_fields(
+    0x09576e93,
+    0x6d3f,
+    0x11d2,
+    0x8e,
+    0x39,
+    &[0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b],
+);
+pub const SYSTEM_VOLUME_LABEL_ID: crate::base::Guid = crate::base::Guid::from_fields(
+    0xdb47d7d3,
+    0xfe81,
+    0x11d3,
+    0x9a,
+    0x35,
+    &[0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d],
+);
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct IoToken {
+    pub event: crate::base::Event,
+    pub status: crate::base::Status,
+    pub buffer_size: usize,
+    pub buffer: *mut core::ffi::c_void,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct Info<const N: usize = 0> {
+    pub size: u64,
+    pub file_size: u64,
+    pub physical_size: u64,
+    pub create_time: crate::system::Time,
+    pub last_access_time: crate::system::Time,
+    pub modification_time: crate::system::Time,
+    pub attribute: u64,
+    pub file_name: [crate::base::Char16; N],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct SystemInfo<const N: usize = 0> {
+    pub size: u64,
+    pub read_only: crate::base::Boolean,
+    pub volume_size: u64,
+    pub free_space: u64,
+    pub block_size: u32,
+    pub volume_label: [crate::base::Char16; N],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct SystemVolumeLabel<const N: usize = 0> {
+    pub volume_label: [crate::base::Char16; N],
+}
+
+pub type ProtocolOpen = eficall! {fn(
+    *mut Protocol,
+    *mut *mut Protocol,
+    *mut crate::base::Char16,
+    u64,
+    u64,
+) -> crate::base::Status};
+
+pub type ProtocolClose = eficall! {fn(
+    *mut Protocol,
+) -> crate::base::Status};
+
+pub type ProtocolDelete = eficall! {fn(
+    *mut Protocol,
+) -> crate::base::Status};
+
+pub type ProtocolRead = eficall! {fn(
+    *mut Protocol,
+    *mut usize,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolWrite = eficall! {fn(
+    *mut Protocol,
+    *mut usize,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolGetPosition = eficall! {fn(
+    *mut Protocol,
+    *mut u64,
+) -> crate::base::Status};
+
+pub type ProtocolSetPosition = eficall! {fn(
+    *mut Protocol,
+    u64,
+) -> crate::base::Status};
+
+pub type ProtocolGetInfo = eficall! {fn(
+    *mut Protocol,
+    *mut crate::base::Guid,
+    *mut usize,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolSetInfo = eficall! {fn(
+    *mut Protocol,
+    *mut crate::base::Guid,
+    usize,
+    *mut core::ffi::c_void,
+) -> crate::base::Status};
+
+pub type ProtocolFlush = eficall! {fn(
+    *mut Protocol,
+) -> crate::base::Status};
+
+pub type ProtocolOpenEx = eficall! {fn(
+    *mut Protocol,
+    *mut *mut Protocol,
+    *mut crate::base::Char16,
+    u64,
+    u64,
+    *mut IoToken,
+) -> crate::base::Status};
+
+pub type ProtocolReadEx = eficall! {fn(
+    *mut Protocol,
+    *mut IoToken,
+) -> crate::base::Status};
+
+pub type ProtocolWriteEx = eficall! {fn(
+    *mut Protocol,
+    *mut IoToken,
+) -> crate::base::Status};
+
+pub type ProtocolFlushEx = eficall! {fn(
+    *mut Protocol,
+    *mut IoToken,
+) -> crate::base::Status};
+
+#[repr(C)]
+pub struct Protocol {
+    pub revision: u64,
+    pub open: ProtocolOpen,
+    pub close: ProtocolClose,
+    pub delete: ProtocolDelete,
+    pub read: ProtocolRead,
+    pub write: ProtocolWrite,
+    pub get_position: ProtocolGetPosition,
+    pub set_position: ProtocolSetPosition,
+    pub get_info: ProtocolGetInfo,
+    pub set_info: ProtocolSetInfo,
+    pub flush: ProtocolFlush,
+    pub open_ex: ProtocolOpenEx,
+    pub read_ex: ProtocolReadEx,
+    pub write_ex: ProtocolWriteEx,
+    pub flush_ex: ProtocolFlushEx,
+}