feat: 实现设备地址到CPU物理地址的转换功能，优化节点结构，更新版本号至0.1.2

Author: ZR233

fdt-edit/src/node/mod.rs

@@ -86,21 +86,22 @@ impl Node {
     }
 
     pub fn get_child(&self, name: &str) -> Option<&Node> {
-        if let Some(&index) = self.name_cache.get(name) {
-            if let Some(child) = self.children.get(index) {
-                return Some(child);
-            }
+        if let Some(&index) = self.name_cache.get(name)
+            && let Some(child) = self.children.get(index)
+        {
+            return Some(child);
         }
 
         // Fallback if the cache is stale
         self.children.iter().find(|c| c.name == name)
     }
 
     pub fn get_child_mut(&mut self, name: &str) -> Option<&mut Node> {
-        if let Some(&index) = self.name_cache.get(name) {
-            if index < self.children.len() && self.children[index].name == name {
-                return self.children.get_mut(index);
-            }
+        if let Some(&index) = self.name_cache.get(name)
+            && index < self.children.len()
+            && self.children[index].name == name
+        {
+            return self.children.get_mut(index);
         }
 
         // Cache miss or mismatch: search and rebuild cache to keep indices in sync
@@ -117,7 +118,7 @@ impl Node {
             .filter(|&idx| self.children.get(idx).map(|c| c.name.as_str()) == Some(name))
             .or_else(|| self.children.iter().position(|c| c.name == name));
 
-        let Some(idx) = index else { return None };
+        let idx = index?;
 
         let removed = self.children.remove(idx);
         self.rebuild_name_cache();

fdt-raw/Cargo.toml

@@ -11,7 +11,7 @@ name = "fdt-raw"
 readme = "README.md"
 homepage = "https://github.com/drivercraft/fdt-parser"
 repository = "https://github.com/drivercraft/fdt-parser"
-version = "0.1.1"
+version = "0.1.2"
 
 [dependencies]
 heapless = "0.9"

fdt-raw/src/fdt.rs

@@ -135,15 +135,94 @@ impl<'a> Fdt<'a> {
         }
     }
 
+    /// Translate device address to CPU physical address.
+    ///
+    /// This function implements address translation similar to Linux's of_translate_address.
+    /// It walks up the device tree hierarchy, applying each parent's ranges property to
+    /// translate the child address space to parent address space, ultimately obtaining
+    /// the CPU physical address.
+    ///
+    /// # Arguments
+    /// * `path` - Node path (absolute path starting with '/' or alias name)
+    /// * `address` - Device address from the node's reg property
+    ///
+    /// # Returns
+    /// The translated CPU physical address. If translation fails, returns the original address.
     pub fn translate_address(&self, path: &'a str, address: u64) -> u64 {
         let path = match self.normalize_path(path) {
             Some(p) => p,
             None => return address,
         };
-        let split = path.trim_matches('/').split('/');
+
+        // 分割路径为各级节点名称
+        let path_parts: heapless::Vec<&str, 16> = path
+            .trim_matches('/')
+            .split('/')
+            .filter(|s| !s.is_empty())
+            .collect();
+
+        if path_parts.is_empty() {
+            return address;
+        }
+
         let mut current_address = address;
-        
-        
+
+        // 从最深层的节点向上遍历，对每一层应用 ranges 转换
+        // 注意：我们需要从倒数第二层开始（因为最后一层是目标节点本身）
+        for depth in (0..path_parts.len()).rev() {
+            // 构建到当前层的路径
+            let parent_parts = &path_parts[..depth];
+            if parent_parts.is_empty() {
+                // 已经到达根节点，不需要继续转换
+                break;
+            }
+
+            // 查找父节点
+            let mut parent_path = heapless::String::<256>::new();
+            parent_path.push('/').ok();
+            for (i, part) in parent_parts.iter().enumerate() {
+                if i > 0 {
+                    parent_path.push('/').ok();
+                }
+                parent_path.push_str(part).ok();
+            }
+
+            let parent_node = match self.find_by_path(parent_path.as_str()) {
+                Some(node) => node,
+                None => continue,
+            };
+
+            // 获取父节点的 ranges 属性
+            let ranges = match parent_node.ranges() {
+                Some(r) => r,
+                None => {
+                    // 没有 ranges 属性，停止转换
+                    break;
+                }
+            };
+
+            // 在 ranges 中查找匹配的转换规则
+            let mut found = false;
+            for range in ranges.iter() {
+                // 检查地址是否在当前 range 的范围内
+                if current_address >= range.child_address
+                    && current_address < range.child_address + range.length
+                {
+                    // 计算在 child address space 中的偏移
+                    let offset = current_address - range.child_address;
+                    // 转换到 parent address space
+                    current_address = range.parent_address + offset;
+                    found = true;
+                    break;
+                }
+            }
+
+            if !found {
+                // 如果在 ranges 中没有找到匹配项，保持当前地址不变
+                // 这通常意味着地址转换失败，但我们继续尝试上层
+            }
+        }
+
         current_address
     }
 

fdt-raw/src/node/mod.rs

@@ -41,7 +41,7 @@ pub struct NodeBase<'a> {
     data: Bytes<'a>,
     strings: Bytes<'a>,
     level: usize,
-    fdt: Fdt<'a>,
+    _fdt: Fdt<'a>,
     /// 当前节点的 #address-cells（用于子节点）
     pub address_cells: u8,
     /// 当前节点的 #size-cells（用于子节点）
@@ -275,7 +275,7 @@ impl<'a> OneNodeIter<'a> {
             address_cells: 2,
             size_cells: 1,
             context: self.context.clone(),
-            fdt: self.fdt.clone(),
+            _fdt: self.fdt.clone(),
         })
     }
 

fdt-raw/tests/ranges.rs

@@ -1,6 +1,6 @@
 use std::sync::Once;
 
-use dtb_file::{fdt_qemu, fdt_rpi_4b};
+use dtb_file::fdt_rpi_4b;
 use fdt_raw::Fdt;
 
 fn init_logging() {
@@ -29,10 +29,29 @@ fn test_ranges() {
 }
 
 #[test]
-fn test_memory() {
-    init_logging();
-    let raw = fdt_qemu();
+fn test_reg() {
+    let raw = fdt_rpi_4b();
     let fdt = Fdt::from_bytes(&raw).unwrap();
-    let memory = fdt.memory().unwrap();
-    println!("Memory node: {:#x?}", memory);
+
+    let path = "/soc/serial@7e215040";
+
+    let node = fdt.find_by_path(path).unwrap();
+
+    let reg = node.reg().unwrap().next().unwrap();
+    println!("reg: {:#x?}", reg);
+    let child_bus_address = reg.address;
+    let address = fdt.translate_address(path, child_bus_address);
+
+    assert_eq!(address, 0xfe215040, "want 0xfe215040, got {:#x}", address);
+    assert_eq!(
+        child_bus_address, 0x7e215040,
+        "want 0x7e215040, got {:#x}",
+        child_bus_address
+    );
+    assert_eq!(
+        reg.size,
+        Some(0x40),
+        "want 0x40, got {:#x}",
+        reg.size.unwrap()
+    );
 }