add macro to read config fields

src/device/gpu.rs

@@ -2,6 +2,7 @@
 
 use crate::hal::{BufferDirection, Dma, Hal};
 use crate::queue::VirtQueue;
+use crate::transport::read_config_field;
 use crate::transport::Transport;
 use crate::volatile::{ReadOnly, Volatile, WriteOnly};
 use crate::{pages, Error, Result, PAGE_SIZE};
@@ -44,11 +45,11 @@
         let negotiated_features = transport.begin_init(SUPPORTED_FEATURES);
 
         // read configuration space
-        let events_read = transport.read_config_space::<u32>(offset_of!(Config, events_read))?;
+        let events_read = read_config_field!(transport, Config, events_read)?;
         let num_scanouts = transport.read_config_space::<u32>(offset_of!(Config, num_scanouts))?;
         info!(
             "events_read: {:#x}, num_scanouts: {:#x}",
-            events_read, num_scanouts
+            events_read.0, num_scanouts
         );
 
         let control_queue = VirtQueue::new(
@@ -253,7 +254,7 @@
         rsp.check_type(Command::OK_NODATA)
     }
 
     fn update_cursor(
         &mut self,
         resource_id: u32,
         scanout_id: u32,
@@ -292,6 +293,7 @@
     }
 }
 
+#[derive(Default, zerocopy::FromBytes)]
 #[repr(C)]
 struct Config {
     /// Signals pending events to the driver。

src/transport/mod.rs

@@ -112,6 +112,31 @@
     ) -> Result<()>;
 }
 
+/// Reads a value from the device config space. The parameters are (1) an instance of `Transport`,
+/// (2) a type describing the config's memory layout, and (3) a field of that type.
+macro_rules! read_config_field {
+    ($transport:expr, $config_type:ty, $field:ident) => {{
+        // We need to know the config field's type, but there is nothing like C++'s "decltype" in
+        // Rust. Workaround it by creating an instance of the config and a variable `f` initialized
+        // to the field of that instance. That constrains `f`'s type to match the field's type.
+        // Then, assign the result of `Transport::read_config_space` to `f` to constrain its type
+        // parameter to be of the same type. When optimizations are enabled, the extra variables
+        // and initialization will be elided.
+        let c: $config_type = FromZeros::new_zeroed();
+        #[allow(unused_assignments)]
+        let mut f = c.$field;
+        match $transport.read_config_space(offset_of!($config_type, $field)) {
+            Ok(x) => {
+                f = x;
+                Ok(f)
+            }
+            Err(e) => Err(e),
+        }
+    }};
+}
+
+pub(crate) use read_config_field;
+
 bitflags! {
     /// The device status field. Writing 0 into this field resets the device.
     #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]

src/volatile.rs

@@ -1,5 +1,5 @@
 /// An MMIO register which can only be read from.
-#[derive(Default)]
+#[derive(Default, zerocopy::FromBytes)]
 #[repr(transparent)]
 pub struct ReadOnly<T: Copy>(pub(crate) T);
 
@@ -11,12 +11,12 @@ impl<T: Copy> ReadOnly<T> {
 }
 
 /// An MMIO register which can only be written to.
-#[derive(Default)]
+#[derive(Default, zerocopy::FromBytes)]
 #[repr(transparent)]
 pub struct WriteOnly<T: Copy>(pub(crate) T);
 
 /// An MMIO register which may be both read and written.
-#[derive(Default)]
+#[derive(Default, zerocopy::FromBytes)]
 #[repr(transparent)]
 pub struct Volatile<T: Copy>(T);