WIP: Add getter for standard reg property.

Author: qwandor

src/error.rs

@@ -21,6 +21,10 @@ pub enum FdtError {
         "prop-encoded-array property was {size} bytes, but should have been a multiple of {chunk} cells"
     )]
     PropEncodedArraySizeMismatch { size: usize, chunk: usize },
+    #[error("Reg address too big for chosen type ({cells} cells)")]
+    AddressTooBig { cells: usize },
+    #[error("Reg size too big for chosen type ({cells} cells)")]
+    SizeTooBig { cells: usize },
 }
 
 /// An error that can occur when parsing a device tree.

src/fdt/mod.rs

@@ -28,6 +28,7 @@ use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout, Unaligned};
 
 pub use self::node::FdtNode;
 pub use self::property::FdtProperty;
+pub use self::property::reg::Reg;
 pub use self::property::status::Status;
 use crate::error::{FdtError, FdtErrorKind, FdtParseError};
 use crate::memreserve::MemoryReservation;

src/fdt/node.rs

@@ -13,6 +13,7 @@ use core::fmt;
 use super::{FDT_TAGSIZE, Fdt, FdtToken};
 use crate::error::{FdtError, FdtParseError};
 use crate::fdt::Status;
+use crate::fdt::property::reg::Reg;
 use crate::fdt::property::{FdtPropIter, FdtProperty};
 
 const DEFAULT_ADDRESS_CELLS: u32 = 2;
@@ -289,6 +290,25 @@ impl<'a> FdtNode<'a> {
         })
     }
 
+    /// Returns the value of the standard `reg` property.
+    pub fn reg(&self) -> Result<Option<impl Iterator<Item = Reg<'a>> + use<'a>>, FdtError> {
+        let parent = self.parent();
+        let address_cells = parent.address_cells()?;
+        let size_cells = parent.size_cells()?;
+        Ok(if let Some(property) = self.property("reg")? {
+            Some(
+                property
+                    .as_prop_encoded_array((address_cells + size_cells) as usize)?
+                    .map(move |element| {
+                        let (address, size) = element.split_at(address_cells as usize);
+                        Reg { address, size }
+                    }),
+            )
+        } else {
+            None
+        })
+    }
+
     /// Returns the value of the standard `virtual-reg` property.
     pub fn virtual_reg(&self) -> Result<Option<u32>, FdtError> {
         Ok(if let Some(property) = self.property("virtual-reg")? {

src/fdt/property.rs

@@ -8,6 +8,7 @@
 
 //! A read-only API for inspecting a device tree property.
 
+pub mod reg;
 pub mod status;
 
 use core::ffi::CStr;

src/fdt/property/reg.rs

@@ -0,0 +1,102 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use core::fmt::{self, Display, Formatter};
+use core::ops::{BitOr, Shl};
+
+use zerocopy::big_endian;
+
+use crate::error::FdtError;
+
+/// The value of a `reg` property.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct Reg<'a> {
+    /// The address of the device within the address space of the parent bus.
+    pub address: &'a [big_endian::U32],
+    /// The size of the device within the address space of the parent bus.
+    pub size: &'a [big_endian::U32],
+}
+
+impl Reg<'_> {
+    /// Attempts to return the address as the given type, if it will fit.
+    pub fn address<T: Default + From<u32> + Shl<usize, Output = T> + BitOr<Output = T>>(
+        self,
+    ) -> Result<T, FdtError> {
+        if size_of::<T>() < self.address.len() * size_of::<u32>() {
+            Err(FdtError::AddressTooBig {
+                cells: self.address.len(),
+            })
+        } else {
+            let mut value = Default::default();
+            for cell in self.address {
+                value = (value << 32) | cell.get().into();
+            }
+            Ok(value)
+        }
+    }
+
+    /// Attempts to return the size as the given type, if it will fit.
+    pub fn size<T: Default + From<u32> + Shl<usize, Output = T> + BitOr<Output = T>>(
+        self,
+    ) -> Result<T, FdtError> {
+        if size_of::<T>() < self.size.len() * size_of::<u32>() {
+            Err(FdtError::SizeTooBig {
+                cells: self.size.len(),
+            })
+        } else {
+            let mut value = Default::default();
+            for cell in self.size {
+                value = value << size_of::<u32>() | cell.get().into();
+            }
+            Ok(value)
+        }
+    }
+}
+
+impl Display for Reg<'_> {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.write_str("0x")?;
+        for part in self.address {
+            write!(f, "{part:08x}")?;
+        }
+        f.write_str(" 0x")?;
+        for part in self.size {
+            write!(f, "{part:08x}")?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn format_reg() {
+        let reg = Reg {
+            address: &[0x12345678.into(), 0xabcd0000.into()],
+            size: &[0x11223344.into()],
+        };
+        assert_eq!(format!("{}", reg), "0x12345678abcd0000 0x11223344");
+    }
+
+    #[test]
+    fn address_size() {
+        let reg = Reg {
+            address: &[0x12345678.into(), 0xabcd0000.into()],
+            size: &[0x11223344.into()],
+        };
+        assert_eq!(
+            reg.address::<u32>(),
+            Err(FdtError::AddressTooBig { cells: 2 })
+        );
+        assert_eq!(reg.address::<u64>(), Ok(0x12345678_abcd0000));
+        assert_eq!(reg.size::<u32>(), Ok(0x11223344));
+        assert_eq!(reg.size::<u64>(), Ok(0x11223344));
+    }
+}

src/lib.rs

@@ -19,7 +19,7 @@
 //! you don't need the Device Tree manipulation functionality, the library is
 //! also no-`alloc`-compatible.
 
-#![no_std]
+#![cfg_attr(not(test), no_std)]
 #![warn(missing_docs, rustdoc::missing_crate_level_docs)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 

tests/dtb/test_props.dtb

@@ -11,9 +11,10 @@
         str-list-prop = "first", "second", "third";
     };
 
-    standard-props {
+    standard-props@1 {
         #address-cells = <0x08>;
         #size-cells = <0x04>;
+        reg = <0x3000 0x20 0xfe00 0x100>;
         compatible = "abc,def", "some,other";
         status = "fail";
         model = "Some Model";

tests/dts/test_props.dts

@@ -6,7 +6,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use dtoolkit::fdt::{Fdt, InitialMappedArea, Status};
+use dtoolkit::fdt::{Fdt, InitialMappedArea, Reg, Status};
 
 #[test]
 fn read_child_nodes() {
@@ -112,6 +112,23 @@ fn standard_properties() {
             .collect::<Vec<_>>(),
         vec!["abc,def", "some,other"]
     );
+    assert_eq!(
+        standard_props_node
+            .reg()
+            .unwrap()
+            .unwrap()
+            .collect::<Vec<_>>(),
+        vec![
+            Reg {
+                address: &[0x3000.into()],
+                size: &[32.into()],
+            },
+            Reg {
+                address: &[0xfe00.into()],
+                size: &[256.into()],
+            },
+        ]
+    );
 }
 
 #[test]
@@ -188,6 +205,13 @@ fn memory() {
     let fdt = Fdt::new(dtb).unwrap();
 
     let memory = fdt.memory().unwrap();
+    assert_eq!(
+        memory.reg().unwrap().unwrap().collect::<Vec<_>>(),
+        vec![Reg {
+            address: &[0.into(), 0x80000000.into()],
+            size: &[0x20000000.into()]
+        }]
+    );
     assert!(memory.hotpluggable().unwrap());
     assert_eq!(
         memory