Add BlockIoMedia to uefi-raw

Author: nicholasbishop

uefi-raw/src/protocol/block.rs

@@ -1,2 +1,24 @@
 /// Logical block address.
 pub type Lba = u64;
+
+/// Media information structure
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct BlockIoMedia {
+    pub media_id: u32,
+    pub removable_media: bool,
+    pub media_present: bool,
+    pub logical_partition: bool,
+    pub read_only: bool,
+    pub write_caching: bool,
+    pub block_size: u32,
+    pub io_align: u32,
+    pub last_block: Lba,
+
+    // Added in revision 2.
+    pub lowest_aligned_lba: Lba,
+    pub logical_blocks_per_physical_block: u32,
+
+    // Added in revision 3.
+    pub optimal_transfer_length_granularity: u32,
+}

uefi/src/proto/media/block.rs

@@ -103,100 +103,82 @@ impl BlockIO {
 }
 
 /// Media information structure
-#[repr(C)]
+#[repr(transparent)]
 #[derive(Debug)]
-pub struct BlockIOMedia {
-    media_id: u32,
-    removable_media: bool,
-    media_present: bool,
-    logical_partition: bool,
-    read_only: bool,
-    write_caching: bool,
-
-    block_size: u32,
-    io_align: u32,
-    last_block: Lba,
-
-    // Revision 2
-    lowest_aligned_lba: Lba,
-    logical_blocks_per_physical_block: u32,
-
-    // Revision 3
-    optimal_transfer_length_granularity: u32,
-}
+pub struct BlockIOMedia(uefi_raw::protocol::block::BlockIoMedia);
 
 impl BlockIOMedia {
     /// The current media ID.
     #[must_use]
     pub const fn media_id(&self) -> u32 {
-        self.media_id
+        self.0.media_id
     }
 
     /// True if the media is removable.
     #[must_use]
     pub const fn is_removable_media(&self) -> bool {
-        self.removable_media
+        self.0.removable_media
     }
 
     /// True if there is a media currently present in the device.
     #[must_use]
     pub const fn is_media_present(&self) -> bool {
-        self.media_present
+        self.0.media_present
     }
 
     /// True if block IO was produced to abstract partition structure.
     #[must_use]
     pub const fn is_logical_partition(&self) -> bool {
-        self.logical_partition
+        self.0.logical_partition
     }
 
     /// True if the media is marked read-only.
     #[must_use]
     pub const fn is_read_only(&self) -> bool {
-        self.read_only
+        self.0.read_only
     }
 
     /// True if `writeBlocks` function writes data.
     #[must_use]
     pub const fn is_write_caching(&self) -> bool {
-        self.write_caching
+        self.0.write_caching
     }
 
     /// The intrinsic block size of the device.
     ///
     /// If the media changes, then this field is updated. Returns the number of bytes per logical block.
     #[must_use]
     pub const fn block_size(&self) -> u32 {
-        self.block_size
+        self.0.block_size
     }
 
     /// Supplies the alignment requirement for any buffer used in a data transfer.
     #[must_use]
     pub const fn io_align(&self) -> u32 {
-        self.io_align
+        self.0.io_align
     }
 
     /// The last LBA on the device. If the media changes, then this field is updated.
     #[must_use]
     pub const fn last_block(&self) -> Lba {
-        self.last_block
+        self.0.last_block
     }
 
     /// Returns the first LBA that is aligned to a physical block boundary.
     #[must_use]
     pub const fn lowest_aligned_lba(&self) -> Lba {
-        self.lowest_aligned_lba
+        self.0.lowest_aligned_lba
     }
 
     /// Returns the number of logical blocks per physical block.
     #[must_use]
     pub const fn logical_blocks_per_physical_block(&self) -> u32 {
-        self.logical_blocks_per_physical_block
+        self.0.logical_blocks_per_physical_block
     }
 
     /// Returns the optimal transfer length granularity as a number of logical blocks.
     #[must_use]
     pub const fn optimal_transfer_length_granularity(&self) -> u32 {
-        self.optimal_transfer_length_granularity
+        self.0.optimal_transfer_length_granularity
     }
 }