feat: 移除不必要的上下文信息，简化属性迭代器和 reg 属性结构

Author: ZR233

fdt-raw/src/data.rs

@@ -26,15 +26,6 @@ impl<'a> Bytes<'a> {
             range: 0..all.len(),
         }
     }
-
-    pub(crate) fn new_at(all: &'a [u8], start: usize, len: usize) -> Self {
-        assert!(start + len <= all.len());
-        Self {
-            all,
-            range: start..start + len,
-        }
-    }
-
     pub fn slice(&self, range: Range<usize>) -> Self {
         assert!(range.end <= self.len());
         Self {

fdt-raw/src/node/mod.rs

@@ -68,11 +68,7 @@ impl<'a> NodeBase<'a> {
 
     /// 获取节点属性迭代器
     pub fn properties(&self) -> PropIter<'a> {
-        PropIter::new(
-            self.data.reader(),
-            self.strings.clone(),
-            self.context.clone(),
-        )
+        PropIter::new(self.data.reader(), self.strings.clone())
     }
 
     /// 查找指定名称的属性

fdt-raw/src/node/prop/mod.rs

@@ -7,9 +7,8 @@ use core::fmt;
 
 use log::error;
 
-pub use reg::{Reg, RegInfo, RegIter};
+pub use reg::{RegInfo, RegIter};
 
-use super::NodeContext;
 use crate::{
     FdtError, Phandle, Status, Token,
     data::{Bytes, Reader, StrIter, U32Iter},
@@ -172,15 +171,6 @@ impl<'a> Property<'a> {
         }
     }
 
-    /// 获取为 reg 属性（需要 context 信息）
-    pub fn as_reg(&self, address_cells: u32, size_cells: u32) -> Option<Reg<'a>> {
-        if self.name == "reg" {
-            Some(Reg::new(self.data.as_slice(), address_cells as u8, size_cells as u8))
-        } else {
-            None
-        }
-    }
-
     /// 是否为 dma-coherent 属性
     pub fn is_dma_coherent(&self) -> bool {
         self.name == "dma-coherent" && self.data.is_empty()
@@ -294,16 +284,15 @@ fn format_bytes(f: &mut fmt::Formatter<'_>, data: &[u8]) -> fmt::Result {
 pub struct PropIter<'a> {
     reader: Reader<'a>,
     strings: Bytes<'a>,
-    context: NodeContext,
     finished: bool,
 }
 
 impl<'a> PropIter<'a> {
-    pub(crate) fn new(reader: Reader<'a>, strings: Bytes<'a>, context: NodeContext) -> Self {
+    pub(crate) fn new(reader: Reader<'a>, strings: Bytes<'a>) -> Self {
         Self {
             reader,
             strings,
-            context,
+
             finished: false,
         }
     }

fdt-raw/src/node/prop/reg.rs

@@ -1,40 +1,6 @@
 //! Reg 属性相关类型
 
-use crate::data::{Bytes, Reader, U32Iter};
-
-/// Reg 属性包装器
-#[derive(Clone)]
-pub struct Reg<'a> {
-    data: &'a [u8],
-    address_cells: u8,
-    size_cells: u8,
-}
-
-impl<'a> Reg<'a> {
-    pub(crate) fn new(data: &'a [u8], address_cells: u8, size_cells: u8) -> Self {
-        Self {
-            data,
-            address_cells,
-            size_cells,
-        }
-    }
-
-    /// 获取 reg 数据的原始字节
-    pub fn as_slice(&self) -> &[u8] {
-        self.data
-    }
-
-    /// 获取 u32 迭代器
-    pub fn as_u32_iter(&self) -> U32Iter<'a> {
-        Bytes::new(self.data).as_u32_iter()
-    }
-
-    /// 获取 reg 信息迭代器
-    pub fn iter(&self) -> RegIter<'a> {
-        let bytes = Bytes::new(self.data);
-        RegIter::new(bytes.reader(), self.address_cells, self.size_cells)
-    }
-}
+use crate::data::Reader;
 
 /// Reg 条目信息
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

fdt-raw/tests/node.rs

@@ -731,6 +731,10 @@ fn test_memory_in_fdt(raw: &[u8], name: &str) {
     for node in fdt.all_nodes() {
         if node.name().starts_with("memory@") || node.name() == "memory" {
             memory_nodes_found += 1;
+
+            let reg = node.reg().expect("Memory node should have reg property");
+            let reg_infos: Vec<_> = reg.collect();
+
             info!(
                 "[{}] Found memory node: {} (level={})",
                 name,
@@ -763,28 +767,14 @@ fn test_memory_in_fdt(raw: &[u8], name: &str) {
                         s
                     );
                     info!("[{}]   device_type = \"{}\"", name, s);
-                } else if let Some(reg) = prop.as_reg(
-                    node.context.parent_address_cells.into(),
-                    node.context.parent_size_cells.into(),
-                ) {
+
                     found_reg = true;
-                    let reg_infos: Vec<_> = reg.iter().collect();
-                    let u32_values: Vec<_> = reg.as_u32_iter().collect();
 
                     info!("[{}]   reg property found:", name);
                     info!(
                         "[{}]     address_cells={}, size_cells={}",
-                        name,
-                        node.context.parent_address_cells,
-                        node.context.parent_size_cells
-                    );
-                    info!(
-                        "[{}]     raw data ({} bytes): {:02x?}",
-                        name,
-                        reg.as_slice().len(),
-                        reg.as_slice()
+                        name, node.context.parent_address_cells, node.context.parent_size_cells
                     );
-                    info!("[{}]     u32 values: {:x?}", name, u32_values);
 
                     // 平台特定验证
                     if name == "QEMU" {
@@ -809,23 +799,6 @@ fn test_memory_in_fdt(raw: &[u8], name: &str) {
                             reg_info.size
                         );
 
-                        // 验证 u32 值格式
-                        assert_eq!(
-                            u32_values.len(),
-                            4,
-                            "QEMU memory reg should have 4 u32 values"
-                        );
-                        assert_eq!(u32_values[0], 0x0, "QEMU memory high address should be 0");
-                        assert_eq!(
-                            u32_values[1], 0x40000000,
-                            "QEMU memory low address should be 0x40000000"
-                        );
-                        assert_eq!(u32_values[2], 0x0, "QEMU memory high size should be 0");
-                        assert_eq!(
-                            u32_values[3], 0x8000000,
-                            "QEMU memory low size should be 0x8000000"
-                        );
-
                         info!(
                             "[{}]   QEMU memory validated: address={:#x}, size={} bytes",
                             name,
@@ -841,36 +814,9 @@ fn test_memory_in_fdt(raw: &[u8], name: &str) {
                                 "[{}]     reg[{}]: address={:#x}, size={:?}",
                                 name, i, reg_info.address, reg_info.size
                             );
-
-                            // RPi 4B 的特殊情况 - 当前测试数据显示地址和大小为0
-                            // 这可能是测试数据的特殊情况，我们只验证基本结构
-                            if node.context.parent_size_cells == 1 {
-                                assert_eq!(
-                                    reg.as_slice().len() % 12,
-                                    0,
-                                    "RPi 4B reg data should be multiple of 12 bytes (2+1 cells)"
-                                );
-                            } else {
-                                assert_eq!(
-                                    reg.as_slice().len() % 16,
-                                    0,
-                                    "RPi 4B reg data should be multiple of 16 bytes (2+2 cells)"
-                                );
-                            }
                         }
                     }
 
-                    // 验证 reg 数据长度的一致性
-                    let expected_entry_size =
-                        (node.context.parent_address_cells + node.context.parent_size_cells) * 4;
-                    assert_eq!(
-                        reg.as_slice().len() % expected_entry_size as usize,
-                        0,
-                        "Reg data length should be multiple of entry size {} for node {}",
-                        expected_entry_size,
-                        node.name()
-                    );
-
                     for (i, reg_info) in reg_infos.iter().enumerate() {
                         info!(
                             "[{}]     reg[{}]: address={:#x}, size={:?}",