Add type and getters for memory node.

Author: qwandor

src/error.rs

@@ -21,6 +21,20 @@ pub enum FdtError {
     /// The `status` property of a node had an invalid value.
     #[error("Invalid status value")]
     InvalidStatus,
+    /// The required `/memory` node wasn't found.
+    #[error("/memory node missing")]
+    MemoryMissing,
+    /// The size of a prop-encoded-array property wasn't a multiple of the
+    /// expected element size.
+    #[error(
+        "prop-encoded-array property was {size} bytes, but should have been a multiple of {chunk} cells"
+    )]
+    PropEncodedArraySizeMismatch {
+        /// The size in bytes of the prop-encoded-array property.
+        size: usize,
+        /// The number of 4 byte cells expected in each element of the array.
+        chunk: usize,
+    },
 }
 
 /// An error that can occur when parsing a device tree.

src/fdt/property.rs

@@ -14,7 +14,7 @@ use core::fmt;
 use zerocopy::{FromBytes, big_endian};
 
 use super::{FDT_TAGSIZE, Fdt, FdtToken};
-use crate::error::{FdtErrorKind, FdtParseError};
+use crate::error::{FdtError, FdtErrorKind, FdtParseError};
 
 /// A property of a device tree node.
 #[derive(Debug, PartialEq)]
@@ -127,6 +127,26 @@ impl<'a> FdtProperty<'a> {
         FdtStringListIterator { value: self.value }
     }
 
+    pub(crate) fn as_prop_encoded_array(
+        &self,
+        chunk_cells: usize,
+    ) -> Result<impl Iterator<Item = &'a [big_endian::U32]> + use<'a>, FdtError> {
+        let chunk_bytes = chunk_cells * size_of::<u32>();
+        if !self.value.len().is_multiple_of(chunk_bytes) {
+            return Err(FdtError::PropEncodedArraySizeMismatch {
+                size: self.value.len(),
+                chunk: chunk_cells,
+            });
+        }
+        // `ref_from_bytes` shouldn't panic because each chunk will always be a multiple
+        // of 4 bytes because of `chunks_exact`.
+        #[allow(clippy::unwrap_used)]
+        Ok(self
+            .value
+            .chunks_exact(chunk_bytes)
+            .map(|chunk| <[big_endian::U32]>::ref_from_bytes(chunk).unwrap()))
+    }
+
     pub(crate) fn fmt(&self, f: &mut fmt::Formatter<'_>, indent: usize) -> fmt::Result {
         write!(f, "{:indent$}{}", "", self.name, indent = indent)?;
 

src/model/property.rs

@@ -10,7 +10,7 @@ use alloc::string::{String, ToString};
 use alloc::vec::Vec;
 use core::{fmt, str};
 
-use crate::error::FdtParseError;
+use crate::error::{FdtError, FdtParseError};
 use crate::fdt::FdtProperty;
 
 /// An error that can occur when parsing a property.

src/standard.rs

@@ -8,10 +8,11 @@
 
 //! Standard nodes and properties.
 
+mod memory;
 mod status;
 
-pub use status::Status;
-
+pub use self::memory::{InitialMappedArea, Memory};
+pub use self::status::Status;
 use crate::error::{FdtError, FdtParseError};
 use crate::fdt::FdtNode;
 

src/standard/memory.rs

@@ -0,0 +1,103 @@
+// 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::ops::Deref;
+
+use zerocopy::big_endian;
+
+use crate::error::FdtError;
+use crate::fdt::{Fdt, FdtNode};
+
+impl Fdt<'_> {
+    /// Returns the /memory node.
+    ///
+    /// This should always be included in a valid device tree.
+    ///
+    /// # Errors
+    ///
+    /// Returns a parse error if there was a problem reading the FDT structure
+    /// to find the node, or `FdtError::MemoryMissing` if the memory node is
+    /// missing.
+    pub fn memory(&self) -> Result<Memory<'_>, FdtError> {
+        let node = self.find_node("/memory")?.ok_or(FdtError::MemoryMissing)?;
+        Ok(Memory { node })
+    }
+}
+
+/// Typed wrapper for a "/memory" node.
+#[derive(Clone, Copy, Debug)]
+pub struct Memory<'a> {
+    node: FdtNode<'a>,
+}
+
+impl<'a> Deref for Memory<'a> {
+    type Target = FdtNode<'a>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.node
+    }
+}
+
+impl<'a> Memory<'a> {
+    /// Returns the value of the standard `initial-mapped-area` property of the
+    /// memory node.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if a property's name or value cannot be read.
+    #[allow(clippy::missing_panics_doc)]
+    pub fn initial_mapped_area(
+        &self,
+    ) -> Result<Option<impl Iterator<Item = InitialMappedArea> + use<'a>>, FdtError> {
+        Ok(
+            if let Some(property) = self.node.property("initial-mapped-area")? {
+                // try_into can't return an error, because we passed a chunk size matching what
+                // `InitialMappedArea::from_cells` expects.
+                #[allow(clippy::unwrap_used)]
+                Some(
+                    property
+                        .as_prop_encoded_array(5)?
+                        .map(|chunk| InitialMappedArea::from_cells(chunk.try_into().unwrap())),
+                )
+            } else {
+                None
+            },
+        )
+    }
+
+    /// Returns the value of the standard `hotpluggable` property of the memory
+    /// node.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if a property's name or value cannot be read.
+    pub fn hotpluggable(&self) -> Result<bool, FdtError> {
+        Ok(self.node.property("hotpluggable")?.is_some())
+    }
+}
+
+/// The value of an `initial-mapped-area` property.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct InitialMappedArea {
+    /// The effective address.
+    pub effective_address: u64,
+    /// The physical address.
+    pub physical_address: u64,
+    /// The size of the area.
+    pub size: u32,
+}
+
+impl InitialMappedArea {
+    fn from_cells([ea_high, ea_low, pa_high, pa_low, size]: [big_endian::U32; 5]) -> Self {
+        Self {
+            effective_address: u64::from(ea_high.get()) << 32 | u64::from(ea_low.get()),
+            physical_address: u64::from(pa_high.get()) << 32 | u64::from(pa_low.get()),
+            size: size.get(),
+        }
+    }
+}

tests/dtb/test_pretty_print.dtb

@@ -23,5 +23,7 @@
     memory@80000000 {
         device_type = "memory";
         reg = <0x80000000 0x20000000>;
+        initial-mapped-area = <0x00 0x1234 0x00 0x4321 0x1000>;
+        hotpluggable;
     };
 };

tests/dts/test_pretty_print.dts

@@ -7,7 +7,7 @@
 // except according to those terms.
 
 use dtoolkit::fdt::Fdt;
-use dtoolkit::standard::Status;
+use dtoolkit::standard::{InitialMappedArea, Status};
 
 #[test]
 fn read_child_nodes() {
@@ -183,6 +183,27 @@ fn find_node_by_path() {
     assert!(fdt.find_node("").unwrap().is_none());
 }
 
+#[test]
+fn memory() {
+    let dtb = include_bytes!("dtb/test_pretty_print.dtb");
+    let fdt = Fdt::new(dtb).unwrap();
+
+    let memory = fdt.memory().unwrap();
+    assert!(memory.hotpluggable().unwrap());
+    assert_eq!(
+        memory
+            .initial_mapped_area()
+            .unwrap()
+            .unwrap()
+            .collect::<Vec<_>>(),
+        vec![InitialMappedArea {
+            effective_address: 0x1234,
+            physical_address: 0x4321,
+            size: 0x1000,
+        }]
+    );
+}
+
 #[macro_export]
 macro_rules! load_dtb_dts_pair {
     ($name:expr) => {