diff --git a/example_all_nodes.rs b/example_all_nodes.rs new file mode 100644 index 0000000..c07112d --- /dev/null +++ b/example_all_nodes.rs @@ -0,0 +1,61 @@ +// 示例：使用 all_nodes 函数 +extern crate alloc; +use alloc::{string::String, vec::Vec}; + +use fdt_edit::{Fdt, Node, NodeRef}; + +fn main() { + // 创建一个示例 FDT + let mut fdt = Fdt::new(); + + // 添加一些示例节点 + { + let root = &mut fdt.root; + let mut soc = Node::new_raw("soc"); + let mut uart = Node::new_raw("uart@4000"); + let mut gpio = Node::new_raw("gpio@5000"); + let mut led = Node::new_raw("led"); + + // 设置属性 + uart.add_property(fdt_edit::Property::new_str("compatible", "vendor,uart")); + gpio.add_property(fdt_edit::Property::new_str("compatible", "vendor,gpio")); + led.add_property(fdt_edit::Property::new_str("compatible", "vendor,led")); + + // 构建树结构 + gpio.add_child(led); + soc.add_child(uart); + soc.add_child(gpio); + root.add_child(soc); + } + + // 使用 all_nodes 获取所有节点 + let all_nodes: Vec = fdt.all_nodes().collect(); + + println!("FDT 中所有节点 (深度优先遍历):"); + for (i, node_ref) in all_nodes.iter().enumerate() { + println!( + "{}: 节点 '{}', 路径: '{}', 深度: {}", + i + 1, + node_ref.node.name(), + node_ref.context.current_path, + node_ref.context.depth + ); + + // 显示节点的 compatible 属性 + let compatibles: Vec<&str> = node_ref.compatibles(); + if !compatibles.is_empty() { + println!(" Compatible: {:?}", compatibles); + } + } + + // 使用 find_compatible 查找特定节点 + let uart_nodes = fdt.find_compatible(&["vendor,uart"]); + println!("\n找到 UART 节点:"); + for node_ref in uart_nodes { + println!( + " 节点: {}, 完整路径: '{}'", + node_ref.node.name(), + node_ref.context.current_path + ); + } +} diff --git a/fdt-edit/Cargo.toml b/fdt-edit/Cargo.toml index 18c6ca5..dfd4e19 100644 --- a/fdt-edit/Cargo.toml +++ b/fdt-edit/Cargo.toml @@ -1,11 +1,30 @@ [package] +authors = ["周睿 "] +categories = ["embedded", "no-std", "hardware-support"] +description = "A high-level library for creating, editing, and encoding Flattened Device Tree (FDT) structures" +documentation = "https://docs.rs/fdt-edit" edition = "2024" +exclude = [".git*", "*.md", "tests/"] +keywords = ["device-tree", "dtb", "embedded", "no-std", "editor"] +license = "MIT OR Apache-2.0" name = "fdt-edit" +readme = "README.md" +repository = "https://github.com/drivercraft/fdt-parser" version = "0.1.0" [dependencies] -fdt-raw = {path = "../fdt-raw"} +log = "0.4" +fdt-raw = {version = "0.1.0", path = "../fdt-raw"} enum_dispatch = "0.3.13" [dev-dependencies] dtb-file = {path = "../dtb-file"} +env_logger = "0.11" + +[features] +default = [] +std = [] + +[package.metadata.docs.rs] +all-features = true +targets = ["x86_64-unknown-linux-gnu", "aarch64-unknown-none-softfloat", "riscv64gc-unknown-none-elf"] diff --git a/fdt-edit/README.md b/fdt-edit/README.md new file mode 100644 index 0000000..90a3dcc --- /dev/null +++ b/fdt-edit/README.md @@ -0,0 +1,148 @@ +# fdt-edit + +用于创建、编辑和编码设备树（FDT）的高级 Rust 库。 + +## 概述 + +`fdt-edit` 是一个功能丰富的设备树操作库，基于 `fdt-raw` 构建，提供了完整的设备树创建、编辑和编码功能。该库支持从零创建新的设备树，修改现有的设备树，以及将编辑后的设备树编码为标准 DTB 格式。 + +## 特性 + +- **完整的设备树编辑**：支持节点和属性的增删改查 +- **类型安全的节点操作**：提供专门的节点类型（时钟、内存、PCI、中断控制器等） +- **高效的编码器**：将内存中的设备树结构编码为标准 DTB 格式 +- **phandle 管理**：自动 phandle 分配和引用管理 +- **内存保留块支持**：完整的内存保留区域操作 +- **`no_std` 兼容**：适用于嵌入式环境 + +## 核心组件 + +### Fdt 结构 +可编辑的设备树容器： +- 从原始 DTB 数据解析 +- 创建新的空设备树 +- 管理 phandle 缓存 +- 编码为 DTB 格式 + +### 节点系统 +支持多种专用节点类型： +- **时钟节点**：时钟源和时钟消费者 +- **内存节点**：内存区域定义 +- **PCI 节点**：PCI 总线和设备 +- **中断控制器**：中断映射和管理 +- **通用节点**：可自定义的节点类型 + +### 属性系统 +- **强类型属性**：各种数据类型的属性支持 +- **自动属性管理**：智能的属性增删改查 +- **格式化显示**：友好的节点和属性显示 + +## 快速开始 + +```rust +use fdt_edit::{Fdt, Node, NodeKind}; + +// 创建新的空设备树 +let mut fdt = Fdt::new(); + +// 添加根节点下的子节点 +let memory_node = fdt.root_mut() + .add_child("memory@80000000") + .unwrap(); +memory_node.add_property("device_type", "memory")?; +memory_node.add_property("reg", &[0x8000_0000u64, 0x1000_0000u64])?; + +// 添加时钟节点 +let clock_node = fdt.root_mut() + .add_child("clk_osc") + .unwrap(); +clock_node.add_property("compatible", &["fixed-clock"])?; +clock_node.add_property("#clock-cells", &[0u32])?; +clock_node.add_property("clock-frequency", &[24_000_000u32])?; + +// 编码为 DTB 数据 +let dtb_data = fdt.encode()?; +``` + +### 从现有 DTB 编辑 + +```rust +// 解析现有 DTB +let mut fdt = Fdt::from_bytes(&existing_dtb)?; + +// 查找并修改节点 +if let Some(cpu_node) = fdt.root_mut() + .find_child_mut("cpus")? + .and_then(|n| n.find_child_mut("cpu@0")) { + + // 修改时钟频率 + cpu_node.set_property("clock-frequency", &[1_200_000_000u32])?; +} + +// 添加新的属性 +cpu_node.add_property("new-property", "value")?; + +// 重新编码 +let modified_dtb = fdt.encode()?; +``` + +### 节点遍历和查找 + +```rust +// 遍历所有节点 +for node in fdt.root().traverse() { + match node.kind() { + NodeKind::Memory(mem) => { + println!("Memory node: {:x?}", mem.regions()); + } + NodeKind::Clock(clock) => { + println!("Clock: {}, freq: {}", clock.name(), clock.frequency()?); + } + _ => { + println!("Generic node: {}", node.name()); + } + } +} + +// 查找特定节点 +if let Some(chosen) = fdt.root().find_child("chosen") { + if let Some(bootargs) = chosen.get_property("bootargs") { + println!("Boot args: {}", bootargs.as_str()?); + } +} +``` + +## 依赖 + +- `fdt-raw` - 底层 FDT 解析库 +- `log = "0.4"` - 日志记录 +- `enum_dispatch = "0.3.13"` - 枚举分发优化 + +## 开发依赖 + +- `dtb-file` - 测试数据 +- `env_logger = "0.11"` - 日志实现 + +## 许可证 + +本项目采用开源许可证，具体许可证类型请查看项目根目录的 LICENSE 文件。 + +## 贡献 + +欢迎提交 Issue 和 Pull Request。请确保： + +1. 代码遵循项目的格式规范（`cargo fmt`） +2. 通过所有测试（`cargo test`） +3. 通过 Clippy 检查（`cargo clippy`） +4. 新功能添加相应的测试用例 + +## 相关项目 + +- [fdt-raw](../fdt-raw/) - 底层 FDT 解析库 +- [fdt-parser](../fdt-parser/) - 高级缓存式 FDT 解析器 +- [dtb-tool](../dtb-tool/) - DTB 文件检查工具 +- [dtb-file](../dtb-file/) - 测试数据包 + +## 示例 + +更多使用示例请查看 `examples/` 目录（如果存在）或源码中的测试用例。 \ No newline at end of file diff --git a/fdt-edit/examples/display_dts.rs b/fdt-edit/examples/display_dts.rs deleted file mode 100644 index 5a7f273..0000000 --- a/fdt-edit/examples/display_dts.rs +++ /dev/null @@ -1,92 +0,0 @@ -use core::fmt::Write; -use fdt_edit::{Fdt, Node, Property, RegInfo}; - -fn main() { - let mut fdt = Fdt::new(); - - // 设置根节点属性 - fdt.root.add_property(Property::AddressCells(1)); - fdt.root.add_property(Property::SizeCells(1)); - fdt.root - .add_property(Property::Compatible(vec!["vendor,board".to_string()])); - fdt.root - .add_property(Property::Model("Demo Board".to_string())); - - // 添加内存保留块 - fdt.memory_reservations.push(fdt_edit::MemoryReservation { - address: 0x80000000, - size: 0x200000, - }); - - // 添加 CPU 节点 - let mut cpu0 = Node::new("cpu@0"); - cpu0.add_property(Property::DeviceType("cpu".to_string())); - cpu0.add_property(Property::Compatible(vec!["arm,cortex-a53".to_string()])); - cpu0.add_property(Property::reg(vec![RegInfo::new(0x0, Some(0x1000))])); - cpu0.add_property(Property::Status(fdt_raw::Status::Okay)); - fdt.root.add_child(cpu0); - - let mut cpu1 = Node::new("cpu@1"); - cpu1.add_property(Property::DeviceType("cpu".to_string())); - cpu1.add_property(Property::Compatible(vec!["arm,cortex-a53".to_string()])); - cpu1.add_property(Property::reg(vec![RegInfo::new(0x1, Some(0x1000))])); - cpu1.add_property(Property::Status(fdt_raw::Status::Okay)); - fdt.root.add_child(cpu1); - - // 添加 SOC 节点 - let mut soc = Node::new("soc"); - soc.add_property(Property::Compatible(vec!["simple-bus".to_string()])); - soc.add_property(Property::reg(vec![RegInfo::new( - 0x40000000, - Some(0x100000), - )])); - soc.add_property(Property::Ranges { - entries: vec![], - child_address_cells: 1, - parent_address_cells: 1, - size_cells: 1, - }); - - // 添加 UART 节点 - let mut uart = Node::new("uart@9000000"); - uart.add_property(Property::Compatible(vec![ - "arm,pl011".to_string(), - "arm,primecell".to_string(), - ])); - uart.add_property(Property::reg(vec![RegInfo::new(0x9000000, Some(0x1000))])); - uart.add_property(Property::Raw(fdt_edit::RawProperty::from_u32( - "interrupts", - 0x12345678, - ))); - uart.add_property(Property::Status(fdt_raw::Status::Okay)); - soc.add_child(uart); - - fdt.root.add_child(soc); - - // 生成 DTS - let mut output = String::new(); - write!(&mut output, "{}", fdt).unwrap(); - - // 输出结果（在实际应用中，这可以写入文件） - // 注意：在 no_std 环境中，我们无法使用 println! - - // 创建一个测试来验证输出 - assert!(output.contains("// Device Tree Source")); - assert!(output.contains("/dts-v1/;")); - assert!(output.contains("/memreserve/")); - assert!(output.contains("0x80000000 0x200000")); - assert!(output.contains("#address-cells = <1>")); - assert!(output.contains("#size-cells = <1>")); - assert!(output.contains("compatible = \"vendor,board\"")); - assert!(output.contains("model = \"Demo Board\"")); - assert!(output.contains("cpu@0 {")); - assert!(output.contains("cpu@1 {")); - assert!(output.contains("soc {")); - assert!(output.contains("uart@9000000 {")); - - // 示例：将输出长度记录（在实际应用中可以将此写入文件） - let _output_length = output.len(); - - // 在调试时，可以检查输出 - // 这里我们只是验证功能正常工作 -} diff --git a/fdt-edit/examples/fdt_debug_demo.rs b/fdt-edit/examples/fdt_debug_demo.rs new file mode 100644 index 0000000..7bcb469 --- /dev/null +++ b/fdt-edit/examples/fdt_debug_demo.rs @@ -0,0 +1,25 @@ +//! FDT 深度调试演示 +//! +//! 演示如何使用新的深度调试功能来遍历和打印设备树的所有节点 + +use dtb_file::fdt_rpi_4b; +use fdt_edit::Fdt; + +fn main() -> Result<(), Box> { + env_logger::init(); + + // 从 RPI 4B DTB 数据创建 FDT + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data)?; + + println!("=== FDT 基本调试信息 ==="); + // 基本调试格式（紧凑） + println!("{:?}", fdt); + println!(); + + println!("=== FDT 深度调试信息 ==="); + // 深度调试格式（遍历所有节点） + println!("{:#?}", fdt); + + Ok(()) +} diff --git a/fdt-edit/src/ctx.rs b/fdt-edit/src/ctx.rs new file mode 100644 index 0000000..f5f12e8 --- /dev/null +++ b/fdt-edit/src/ctx.rs @@ -0,0 +1,141 @@ +use alloc::{collections::BTreeMap, string::String, vec::Vec}; + +use fdt_raw::{Phandle, Status}; + +use crate::{Node, RangesEntry}; + +// ============================================================================ +// FDT 上下文 +// ============================================================================ + +/// 遍历上下文，存储从根到当前节点的父节点引用栈 +#[derive(Clone, Default)] +pub struct Context<'a> { + /// 父节点引用栈（从根节点到当前节点的父节点） + /// 栈底是根节点，栈顶是当前节点的直接父节点 + pub parents: Vec<&'a Node>, + + /// phandle 到节点引用的映射 + /// 用于通过 phandle 快速查找节点（如中断父节点） + pub phandle_map: BTreeMap, +} + +impl<'a> Context<'a> { + /// 创建新的上下文 + pub fn new() -> Self { + Self::default() + } + + pub fn current_path(&self) -> String { + self.parents + .iter() + .map(|n| n.name()) + .collect::>() + .join("/") + } + + /// 创建用于根节点的上下文 + pub fn for_root() -> Self { + Self::default() + } + + /// 获取当前深度（父节点数量 + 1） + pub fn depth(&self) -> usize { + self.parents.len() + 1 + } + + /// 获取直接父节点 + pub fn parent(&self) -> Option<&'a Node> { + self.parents.last().copied() + } + + /// 获取父节点的 #address-cells + /// 优先从直接父节点获取，否则返回默认值 2 + pub fn parent_address_cells(&self) -> u32 { + self.parent().and_then(|p| p.address_cells()).unwrap_or(2) + } + + /// 获取父节点的 #size-cells + /// 优先从直接父节点获取，否则返回默认值 1 + pub fn parent_size_cells(&self) -> u32 { + self.parent().and_then(|p| p.size_cells()).unwrap_or(1) + } + + /// 查找中断父节点 phandle + /// 从当前父节点向上查找，返回最近的 interrupt-parent + pub fn interrupt_parent(&self) -> Option { + for parent in self.parents.iter().rev() { + if let Some(phandle) = parent.interrupt_parent() { + return Some(phandle); + } + } + None + } + + /// 检查节点是否被禁用 + /// 检查父节点栈中是否有任何节点被禁用 + pub fn is_disabled(&self) -> bool { + for parent in &self.parents { + if matches!(parent.status(), Some(Status::Disabled)) { + return true; + } + } + false + } + + /// 解析当前路径上所有父节点的 ranges，用于地址转换 + /// 返回从根到父节点的 ranges 栈 + pub fn collect_ranges(&self) -> Vec> { + let mut ranges_stack = Vec::new(); + let mut prev_address_cells = 2; // 根节点默认 + + for parent in &self.parents { + if let Some(ranges) = parent.ranges(prev_address_cells) { + ranges_stack.push(ranges); + } + // 更新 address cells 为当前节点的值，供下一级使用 + prev_address_cells = parent.address_cells().unwrap_or(2); + } + + ranges_stack + } + + /// 获取最近一层的 ranges（用于当前节点的地址转换） + pub fn current_ranges(&self) -> Option> { + // 需要父节点来获取 ranges + if self.parents.is_empty() { + return None; + } + + let parent = self.parents.last()?; + + // 获取父节点的父节点的 address_cells + let grandparent_address_cells = if self.parents.len() >= 2 { + self.parents[self.parents.len() - 2] + .address_cells() + .unwrap_or(2) + } else { + 2 // 根节点默认 + }; + parent.ranges(grandparent_address_cells) + } + + pub fn push(&mut self, node: &'a Node) { + self.parents.push(node); + } + + /// 通过 phandle 查找节点 + pub fn find_by_phandle(&self, phandle: Phandle) -> Option<&'a Node> { + self.phandle_map.get(&phandle).copied() + } + + /// 从 Fdt 构建 phandle 映射 + pub fn build_phandle_map_from_node(node: &'a Node, map: &mut BTreeMap) { + if let Some(phandle) = node.phandle() { + map.insert(phandle, node); + } + for child in &node.children { + Self::build_phandle_map_from_node(child, map); + } + } +} diff --git a/fdt-edit/src/encode.rs b/fdt-edit/src/encode.rs new file mode 100644 index 0000000..ad43b81 --- /dev/null +++ b/fdt-edit/src/encode.rs @@ -0,0 +1,219 @@ +//! FDT 编码模块 +//! +//! 将 Fdt 结构序列化为 DTB 二进制格式 + +use alloc::{string::String, vec::Vec}; +use core::ops::Deref; +use fdt_raw::{FDT_MAGIC, Token}; + +use crate::{Fdt, Node}; + +/// FDT 二进制数据 +#[derive(Clone, Debug)] +pub struct FdtData(Vec); + +impl FdtData { + /// 获取数据长度（字节） + pub fn len(&self) -> usize { + self.0.len() * 4 + } + + /// 数据是否为空 + pub fn is_empty(&self) -> bool { + self.0.is_empty() + } +} + +impl Deref for FdtData { + type Target = [u8]; + + fn deref(&self) -> &Self::Target { + unsafe { + core::slice::from_raw_parts( + self.0.as_ptr() as *const u8, + self.0.len() * core::mem::size_of::(), + ) + } + } +} + +impl AsRef<[u8]> for FdtData { + fn as_ref(&self) -> &[u8] { + self + } +} + +/// FDT 编码器 +pub struct FdtEncoder<'a> { + fdt: &'a Fdt, + struct_data: Vec, + strings_data: Vec, + string_offsets: Vec<(String, u32)>, +} + +impl<'a> FdtEncoder<'a> { + /// 创建新的编码器 + pub fn new(fdt: &'a Fdt) -> Self { + Self { + fdt, + struct_data: Vec::new(), + strings_data: Vec::new(), + string_offsets: Vec::new(), + } + } + + /// 获取或添加字符串，返回偏移量 + fn get_or_add_string(&mut self, s: &str) -> u32 { + for (existing, offset) in &self.string_offsets { + if existing == s { + return *offset; + } + } + + let offset = self.strings_data.len() as u32; + self.strings_data.extend_from_slice(s.as_bytes()); + self.strings_data.push(0); // null terminator + self.string_offsets.push((s.into(), offset)); + offset + } + + /// 写入 BEGIN_NODE token 和节点名 + fn write_begin_node(&mut self, name: &str) { + let begin_token: u32 = Token::BeginNode.into(); + self.struct_data.push(begin_token.to_be()); + + let name_bytes = name.as_bytes(); + let name_len = name_bytes.len() + 1; // +1 for null + let aligned_len = (name_len + 3) & !3; + + let mut name_buf = vec![0u8; aligned_len]; + name_buf[..name_bytes.len()].copy_from_slice(name_bytes); + + for chunk in name_buf.chunks(4) { + let word = u32::from_ne_bytes(chunk.try_into().unwrap()); + self.struct_data.push(word); + } + } + + /// 写入 END_NODE token + fn write_end_node(&mut self) { + let end_token: u32 = Token::EndNode.into(); + self.struct_data.push(end_token.to_be()); + } + + /// 写入属性 + fn write_property(&mut self, name: &str, data: &[u8]) { + let prop_token: u32 = Token::Prop.into(); + self.struct_data.push(prop_token.to_be()); + + self.struct_data.push((data.len() as u32).to_be()); + + let nameoff = self.get_or_add_string(name); + self.struct_data.push(nameoff.to_be()); + + if !data.is_empty() { + let aligned_len = (data.len() + 3) & !3; + let mut data_buf = vec![0u8; aligned_len]; + data_buf[..data.len()].copy_from_slice(data); + + for chunk in data_buf.chunks(4) { + let word = u32::from_ne_bytes(chunk.try_into().unwrap()); + self.struct_data.push(word); + } + } + } + + /// 执行编码 + pub fn encode(mut self) -> FdtData { + // 递归编码节点树 + self.encode_node(&self.fdt.root.clone()); + + // 添加 END token + let token: u32 = Token::End.into(); + self.struct_data.push(token.to_be()); + + self.finalize() + } + + /// 递归编码节点及其子节点 + fn encode_node(&mut self, node: &Node) { + // 写入 BEGIN_NODE 和节点名 + self.write_begin_node(node.name()); + + // 写入所有属性（直接使用原始数据） + for prop in node.properties() { + self.write_property(prop.name(), &prop.data); + } + + // 递归编码子节点 + for child in node.children() { + self.encode_node(child); + } + + // 写入 END_NODE + self.write_end_node(); + } + + /// 生成最终 FDT 数据 + fn finalize(self) -> FdtData { + let memory_reservations = &self.fdt.memory_reservations; + let boot_cpuid_phys = self.fdt.boot_cpuid_phys; + + let header_size = 40u32; // 10 * 4 bytes + let mem_rsv_size = ((memory_reservations.len() + 1) * 16) as u32; + let struct_size = (self.struct_data.len() * 4) as u32; + let strings_size = self.strings_data.len() as u32; + + let off_mem_rsvmap = header_size; + let off_dt_struct = off_mem_rsvmap + mem_rsv_size; + let off_dt_strings = off_dt_struct + struct_size; + let totalsize = off_dt_strings + strings_size; + let totalsize_aligned = (totalsize + 3) & !3; + + let mut data = Vec::with_capacity(totalsize_aligned as usize / 4); + + // Header + data.push(FDT_MAGIC.to_be()); + data.push(totalsize_aligned.to_be()); + data.push(off_dt_struct.to_be()); + data.push(off_dt_strings.to_be()); + data.push(off_mem_rsvmap.to_be()); + data.push(17u32.to_be()); // version + data.push(16u32.to_be()); // last_comp_version + data.push(boot_cpuid_phys.to_be()); + data.push(strings_size.to_be()); + data.push(struct_size.to_be()); + + // Memory reservation block + for rsv in memory_reservations { + let addr_hi = (rsv.address >> 32) as u32; + let addr_lo = rsv.address as u32; + let size_hi = (rsv.size >> 32) as u32; + let size_lo = rsv.size as u32; + data.push(addr_hi.to_be()); + data.push(addr_lo.to_be()); + data.push(size_hi.to_be()); + data.push(size_lo.to_be()); + } + // Terminator + data.push(0); + data.push(0); + data.push(0); + data.push(0); + + // Struct block + data.extend_from_slice(&self.struct_data); + + // Strings block + let strings_aligned_len = (self.strings_data.len() + 3) & !3; + let mut strings_buf = vec![0u8; strings_aligned_len]; + strings_buf[..self.strings_data.len()].copy_from_slice(&self.strings_data); + + for chunk in strings_buf.chunks(4) { + let word = u32::from_ne_bytes(chunk.try_into().unwrap()); + data.push(word); + } + + FdtData(data) + } +} diff --git a/fdt-edit/src/fdt.rs b/fdt-edit/src/fdt.rs index e2d024f..6bc1c37 100644 --- a/fdt-edit/src/fdt.rs +++ b/fdt-edit/src/fdt.rs @@ -1,27 +1,20 @@ -use core::fmt; -use core::ops::Deref; - use alloc::{ collections::BTreeMap, format, string::{String, ToString}, - vec, vec::Vec, }; -use fdt_raw::{FDT_MAGIC, FdtError, Phandle, Token}; -use crate::Node; -use crate::node::NodeOp; +pub use fdt_raw::MemoryReservation; +use fdt_raw::{FdtError, Phandle, Status}; -/// Memory reservation block entry -#[derive(Clone, Debug, Default)] -pub struct MemoryReservation { - pub address: u64, - pub size: u64, -} +use crate::{ + ClockType, Node, NodeIter, NodeIterMut, NodeKind, NodeMut, NodeRef, + encode::{FdtData, FdtEncoder}, +}; /// 可编辑的 FDT -#[derive(Clone, Debug)] +#[derive(Clone)] pub struct Fdt { /// 引导 CPU ID pub boot_cpuid_phys: u32, @@ -45,7 +38,7 @@ impl Fdt { Self { boot_cpuid_phys: 0, memory_reservations: Vec::new(), - root: Node::root(), + root: Node::new(""), phandle_cache: BTreeMap::new(), } } @@ -71,35 +64,18 @@ impl Fdt { let mut fdt = Fdt { boot_cpuid_phys: header.boot_cpuid_phys, - memory_reservations: Vec::new(), - root: Node::root(), + memory_reservations: raw_fdt.memory_reservations().collect(), + root: Node::new(""), phandle_cache: BTreeMap::new(), }; - // 解析内存保留块 - let data = raw_fdt.as_slice(); - let mut offset = header.off_mem_rsvmap as usize; - loop { - if offset + 16 > data.len() { - break; - } - let address = u64::from_be_bytes(data[offset..offset + 8].try_into().unwrap()); - let size = u64::from_be_bytes(data[offset + 8..offset + 16].try_into().unwrap()); - if address == 0 && size == 0 { - break; - } - fdt.memory_reservations - .push(MemoryReservation { address, size }); - offset += 16; - } - // 构建节点树 // 使用栈来跟踪父节点，栈底是一个虚拟父节点 let mut node_stack: Vec = Vec::new(); for raw_node in raw_fdt.all_nodes() { let level = raw_node.level(); - let node = Node::from(raw_node); + let node = Node::from(&raw_node); // 弹出栈直到达到正确的父级别 // level 0 = 根节点，应该直接放入空栈 @@ -148,7 +124,7 @@ impl Fdt { } // 递归处理子节点 - for child in node.children() { + for child in &node.children { let child_name = child.name(); let child_path = if current_path == "/" { format!("/{}", child_name) @@ -159,161 +135,35 @@ impl Fdt { } } - /// 根据路径查找节点（非精确匹配） - /// - /// 路径格式: "/node1/node2/node3" - /// 支持 node-name@unit-address 格式，如 "/soc/i2c@40002000" - /// 支持 alias：如果路径不以 '/' 开头，会从 /aliases 节点解析别名 - /// 支持智能匹配：中间级别只支持精确匹配，最后一级支持前缀匹配（忽略 @unit-address） - /// 返回所有匹配的节点及其完整路径 - pub fn find_by_path(&self, path: &str) -> Vec<(&Node, String)> { - // 如果路径以 '/' 开头，直接按路径查找 - // 否则解析 alias - let resolved_path = if path.starts_with('/') { - path.to_string() - } else { - let Some(path) = self.resolve_alias(path) else { - return Vec::new(); - }; - path - }; - - // 对于根路径，直接返回根节点 - let path_str = resolved_path.trim_start_matches('/'); - if path_str.is_empty() { - return vec![(&self.root, String::from("/"))]; - } - - // 使用 Node 的智能查找功能 - self.root.find_all(&resolved_path) - } - - /// 根据路径精确查找节点 - /// - /// 路径格式: "/node1/node2/node3" - /// 支持 node-name@unit-address 格式，如 "/soc/i2c@40002000" - /// 支持 alias：如果路径不以 '/' 开头，会从 /aliases 节点解析别名 - /// 只支持精确匹配，不支持模糊匹配 - /// 返回 (节点引用, 完整路径) - pub fn get_by_path(&self, path: &str) -> Option<(&Node, String)> { - // 如果路径以 '/' 开头，直接按路径查找 - // 否则解析 alias - let resolved_path = if path.starts_with('/') { - path.to_string() - } else { - self.resolve_alias(path)? - }; - - // 对于根路径，直接返回根节点 - let path_str = resolved_path.trim_start_matches('/'); - if path_str.is_empty() { - return Some((&self.root, String::from("/"))); - } - - // 使用 Node 的精确查找功能 - if let Some(node) = self.root.get_by_path(&resolved_path) { - Some((node, resolved_path)) + /// 规范化路径：如果是别名则解析为完整路径，否则确保以 / 开头 + fn normalize_path(&self, path: &str) -> Option { + if path.starts_with('/') { + Some(path.to_string()) } else { - None + // 尝试解析别名 + self.resolve_alias(path).map(|s| s.to_string()) } } - /// 根据路径精确查找节点（可变） - /// - /// 支持 node-name@unit-address 格式，如 "/soc/i2c@40002000" - /// 支持 alias：如果路径不以 '/' 开头，会从 /aliases 节点解析别名 - /// 只支持精确匹配，不支持模糊匹配 - /// 返回 (节点可变引用, 完整路径) - pub fn get_by_path_mut(&mut self, path: &str) -> Option<(&mut Node, String)> { - // 如果路径以 '/' 开头，直接按路径查找 - // 否则解析 alias - let resolved_path = if path.starts_with('/') { - path.to_string() - } else { - self.resolve_alias(path)? - }; - - // 对于根路径，直接返回根节点 - let path_str = resolved_path.trim_start_matches('/'); - if path_str.is_empty() { - return Some((&mut self.root, String::from("/"))); - } - - // 使用 Node 的精确查找功能 - if let Some(node) = self.root.get_by_path_mut(&resolved_path) { - Some((node, resolved_path)) - } else { - None - } - } - - /// 根据节点名称查找所有匹配的节点 - /// 支持智能匹配（精确匹配和前缀匹配） - pub fn find_by_name(&self, name: &str) -> Vec<(&Node, String)> { - self.root.find_all(name) - } - - /// 根据节点名称前缀查找所有匹配的节点 - pub fn find_by_name_prefix(&self, prefix: &str) -> Vec<(&Node, String)> { - self.root.find_all(prefix) - } - - /// 根据路径查找所有匹配的节点 - pub fn find_all_by_path(&self, path: &str) -> Vec<(&Node, String)> { - // 如果路径以 '/' 开头，直接按路径查找 - // 否则解析 alias - let resolved_path = if path.starts_with('/') { - path.to_string() - } else { - let Some(path) = self.resolve_alias(path) else { - return Vec::new(); - }; - path - }; - - // 对于根路径，直接返回根节点 - let path_str = resolved_path.trim_start_matches('/'); - if path_str.is_empty() { - return vec![(&self.root, String::from("/"))]; - } - - // 使用 Node 的智能查找功能 - self.root.find_all(&resolved_path) - } - /// 解析别名，返回对应的完整路径 /// /// 从 /aliases 节点查找别名对应的路径 - pub fn resolve_alias(&self, alias: &str) -> Option { - let aliases_node = self.root.get_by_path("aliases")?; + pub fn resolve_alias(&self, alias: &str) -> Option<&str> { + let aliases_node = self.get_by_path("/aliases")?; let prop = aliases_node.find_property(alias)?; - - // 从属性中获取字符串值（路径） - match prop { - crate::Property::Raw(raw) => { - // 字符串属性以 null 结尾 - let data = raw.data(); - let len = data.iter().position(|&b| b == 0).unwrap_or(data.len()); - core::str::from_utf8(&data[..len]).ok().map(String::from) - } - _ => None, - } + prop.as_str() } /// 获取所有别名 /// /// 返回 (别名, 路径) 的列表 - pub fn aliases(&self) -> Vec<(&str, String)> { + pub fn aliases(&self) -> Vec<(String, String)> { let mut result = Vec::new(); - if let Some(aliases_node) = self.root.get_by_path("aliases") { + if let Some(aliases_node) = self.get_by_path("/aliases") { for prop in aliases_node.properties() { - if let crate::Property::Raw(raw) = prop { - let data = raw.data(); - let len = data.iter().position(|&b| b == 0).unwrap_or(data.len()); - if let Ok(path) = core::str::from_utf8(&data[..len]) { - result.push((raw.name(), path.to_string())); - } - } + let name = prop.name().to_string(); + let path = prop.as_str().unwrap().to_string(); + result.push((name, path)); } } result @@ -321,18 +171,16 @@ impl Fdt { /// 根据 phandle 查找节点 /// 返回 (节点引用, 完整路径) - pub fn find_by_phandle(&self, phandle: Phandle) -> Option<(&Node, String)> { + pub fn find_by_phandle(&self, phandle: Phandle) -> Option> { let path = self.phandle_cache.get(&phandle)?.clone(); - let node = self.root.get_by_path(&path)?; - Some((node, path)) + self.get_by_path(&path) } /// 根据 phandle 查找节点（可变） /// 返回 (节点可变引用, 完整路径) - pub fn find_by_phandle_mut(&mut self, phandle: Phandle) -> Option<(&mut Node, String)> { + pub fn find_by_phandle_mut(&mut self, phandle: Phandle) -> Option> { let path = self.phandle_cache.get(&phandle)?.clone(); - let node = self.root.get_by_path_mut(&path)?; - Some((node, path)) + self.get_by_path_mut(&path) } /// 获取根节点 @@ -345,29 +193,6 @@ impl Fdt { &mut self.root } - /// 删除别名条目 - /// - /// 从 /aliases 节点中删除指定的别名属性 - fn remove_alias_entry(&mut self, alias_name: &str) -> Result<(), FdtError> { - if let Some(aliases_node) = self.root.get_by_path_mut("aliases") { - // 查找并删除别名属性 - // aliases_node.as_raw_mut().properties.retain(|prop| { - // if let crate::Property::Raw(raw) = prop { - // // 检查属性名是否匹配 - // raw.name() != alias_name - // } else { - // true - // } - // }); - - // 如果 aliases 节点没有其他属性了，可以考虑删除整个节点 - // 但这里我们保留空节点以符合设备树规范 - } - - // 不论如何都返回成功，因为别名条目删除是可选的优化 - Ok(()) - } - /// 应用设备树覆盖 (Device Tree Overlay) /// /// 支持两种 overlay 格式： @@ -386,7 +211,7 @@ impl Fdt { /// ``` pub fn apply_overlay(&mut self, overlay: &Fdt) -> Result<(), FdtError> { // 遍历 overlay 根节点的所有子节点 - for child in overlay.root.children() { + for child in &overlay.root.children { if child.name().starts_with("fragment@") || child.name() == "fragment" { // fragment 格式 self.apply_fragment(child)?; @@ -415,7 +240,7 @@ impl Fdt { // 找到 __overlay__ 子节点 let overlay_node = fragment - .get_by_path("__overlay__") + .get_child("__overlay__") .ok_or(FdtError::NotFound)?; // 找到目标节点并应用覆盖 @@ -431,24 +256,18 @@ impl Fdt { /// 解析 fragment 的目标路径 fn resolve_fragment_target(&self, fragment: &Node) -> Result { // 优先使用 target-path（字符串路径） - if let Some(crate::Property::Raw(raw)) = fragment.find_property("target-path") { - let data = raw.data(); - let len = data.iter().position(|&b| b == 0).unwrap_or(data.len()); - if let Ok(path) = core::str::from_utf8(&data[..len]) { - return Ok(path.to_string()); - } + if let Some(prop) = fragment.get_property("target-path") { + return Ok(prop.as_str().ok_or(FdtError::Utf8Parse)?.to_string()); } // 使用 target（phandle 引用） - if let Some(crate::Property::Raw(raw)) = fragment.find_property("target") { - let data = raw.data(); - if data.len() >= 4 { - let phandle_val = u32::from_be_bytes(data[..4].try_into().unwrap()); - let phandle = Phandle::from(phandle_val); - // 通过 phandle 找到节点，然后构建路径 - if let Some((_node, path)) = self.find_by_phandle(phandle) { - return Ok(path); - } + if let Some(prop) = fragment.get_property("target") { + let ph = prop.get_u32().ok_or(FdtError::InvalidInput)?; + let ph = Phandle::from(ph); + + // 通过 phandle 找到节点，然后构建路径 + if let Some(node) = self.find_by_phandle(ph) { + return Ok(node.path()); } } @@ -462,12 +281,12 @@ impl Fdt { overlay_node: &Node, ) -> Result<(), FdtError> { // 找到目标节点 - let (target, _path) = self + let mut target = self .get_by_path_mut(target_path) .ok_or(FdtError::NotFound)?; // 合并 overlay 的属性和子节点 - Self::merge_nodes(target, overlay_node); + Self::merge_nodes(target.node, overlay_node); Ok(()) } @@ -481,7 +300,7 @@ impl Fdt { for child in overlay.children() { let child_name = child.name(); - if let Some(existing) = self.root.find_child_mut(child_name) { + if let Some(existing) = self.root.get_child_mut(child_name) { // 合并到现有子节点 Self::merge_nodes(existing, child); } else { @@ -503,7 +322,7 @@ impl Fdt { // 合并子节点 for source_child in source.children() { let child_name = &source_child.name(); - if let Some(target_child) = target.find_child_mut(child_name) { + if let Some(target_child) = target.get_child_mut(child_name) { // 递归合并 Self::merge_nodes(target_child, source_child); } else { @@ -537,10 +356,7 @@ impl Fdt { // 移除 disabled 的子节点 let mut to_remove = Vec::new(); for child in node.children() { - if matches!( - child.find_property("status"), - Some(crate::Property::Status(crate::Status::Disabled)) - ) { + if matches!(child.status(), Some(Status::Disabled)) { to_remove.push(child.name().to_string()); } } @@ -568,41 +384,28 @@ impl Fdt { /// /// # 示例 /// ```rust - /// # use fdt_edit::Fdt; + /// # use fdt_edit::{Fdt, Node}; /// let mut fdt = Fdt::new(); /// /// // 先添加节点再删除 - /// let mut soc = fdt_edit::Node::new("soc"); - /// let mut gpio = fdt_edit::Node::new("gpio@1000"); - /// soc.add_child(gpio); + /// let mut soc = Node::new("soc"); + /// soc.add_child(Node::new("gpio@1000")); /// fdt.root.add_child(soc); /// - /// // 精确删除节点 - /// let removed = fdt.remove_node("soc/gpio@1000")?; + /// // 精确删除节点（使用完整路径） + /// let removed = fdt.remove_node("/soc/gpio@1000")?; + /// assert!(removed.is_some()); /// - /// // 删除不存在的节点会返回 NotFound 错误 - /// // let removed = fdt.remove_node("nonexistent")?; // 这会返回 Err(NotFound) + /// // 尝试删除不存在的节点会返回错误 + /// let not_found = fdt.remove_node("/soc/nonexistent"); + /// assert!(not_found.is_err()); /// # Ok::<(), fdt_raw::FdtError>(()) /// ``` pub fn remove_node(&mut self, path: &str) -> Result, FdtError> { - let normalized_path = path.trim_start_matches('/'); - if normalized_path.is_empty() { - return Err(FdtError::InvalidInput); - } - - // 首先检查是否是别名 - if !path.starts_with('/') { - // 可能是别名，尝试解析 - if let Some(resolved_path) = self.resolve_alias(path) { - // 删除别名条目 - let _ = self.remove_alias_entry(path); - // 删除实际节点 - return self.root.remove_by_path(&resolved_path); - } - } + let normalized_path = self.normalize_path(path).ok_or(FdtError::InvalidInput)?; // 直接使用精确路径删除 - let result = self.root.remove_by_path(path)?; + let result = self.root.remove_by_path(&normalized_path)?; // 如果删除成功且结果是 None，说明路径不存在 if result.is_none() { @@ -612,533 +415,213 @@ impl Fdt { Ok(result) } - /// 获取所有节点的递归列表 - /// - /// 返回包含根节点及其所有子节点的向量，按照深度优先遍历顺序 - pub fn all_nodes(&self) -> Vec<&Node> { - let mut nodes = Vec::new(); - self.collect_all_nodes(&self.root, &mut nodes); - nodes - } - - /// 递归收集所有节点到结果向量中 + /// 获取所有节点的深度优先迭代器 /// - /// # 参数 - /// - `node`: 当前要处理的节点 - /// - `nodes`: 用于收集节点的结果向量 - fn collect_all_nodes<'a>(&'a self, node: &'a Node, nodes: &mut Vec<&'a Node>) { - // 添加当前节点 - nodes.push(node); - - // 递归处理所有子节点 - for child in node.children() { - self.collect_all_nodes(child, nodes); - } + /// 返回包含根节点及其所有子节点的迭代器，按照深度优先遍历顺序 + pub fn all_nodes(&self) -> impl Iterator> + '_ { + NodeIter::new(&self.root) } - /// 序列化为 FDT 二进制数据 - pub fn to_bytes(&self) -> FdtData { - let mut builder = FdtBuilder::new(); - - // 收集所有字符串 - builder.collect_strings(&self.root); - - // 构建结构块 - builder.build_struct(&self.root); - - // 生成最终数据 - builder.finalize(self.boot_cpuid_phys, &self.memory_reservations) - } -} - -/// 节点上下文信息 -#[derive(Debug, Clone)] -struct NodeContext { - /// 当前节点的 address cells - address_cells: u8, - /// 当前节点的 size cells - size_cells: u8, -} - -impl Default for NodeContext { - fn default() -> Self { - Self { - address_cells: 1, // 默认值 - size_cells: 1, // 默认值 - } - } -} - -/// FDT 构建器 -struct FdtBuilder { - /// 结构块数据 - struct_data: Vec, - /// 字符串块数据 - strings_data: Vec, - /// 字符串偏移映射 - string_offsets: Vec<(String, u32)>, - /// 节点栈，用于跟踪当前构建的节点层次结构 - /// 栈顶是当前正在处理的节点的上下文 - node_stack: Vec, -} - -impl FdtBuilder { - fn new() -> Self { - Self { - struct_data: Vec::new(), - strings_data: Vec::new(), - string_offsets: Vec::new(), - node_stack: vec![NodeContext::default()], // 初始化栈，包含根节点上下文 - } - } - - /// 获取当前节点的上下文 - fn current_context(&self) -> &NodeContext { - self.node_stack.last().unwrap() + pub fn all_nodes_mut(&mut self) -> impl Iterator> + '_ { + NodeIterMut::new(&mut self.root) } - /// 推入新的节点上下文 - fn push_context(&mut self, address_cells: u8, size_cells: u8) { - let context = NodeContext { - address_cells, - size_cells, - }; - self.node_stack.push(context); - } + pub fn find_by_path<'a>(&'a self, path: &str) -> impl Iterator> { + let path = self + .normalize_path(path) + .unwrap_or_else(|| path.to_string()); - /// 弹出当前节点上下文 - fn pop_context(&mut self) { - if self.node_stack.len() > 1 { - // 保留根节点上下文 - self.node_stack.pop(); - } - } - - /// 获取父节点的 address cells 和 size cells - fn get_parent_cells(&self) -> (u8, u8) { - if self.node_stack.len() >= 2 { - let parent_context = &self.node_stack[self.node_stack.len() - 2]; - (parent_context.address_cells, parent_context.size_cells) - } else { - // 根节点的父节点，使用默认值 - (1, 1) - } - } - - /// 获取或添加字符串，返回偏移量 - fn get_or_add_string(&mut self, s: &str) -> u32 { - // 查找已存在的字符串 - for (existing, offset) in &self.string_offsets { - if existing == s { - return *offset; + NodeIter::new(self.root()).filter_map(move |node_ref| { + if node_ref.path_eq_fuzzy(&path) { + Some(node_ref) + } else { + None } - } - - // 添加新字符串 - let offset = self.strings_data.len() as u32; - self.strings_data.extend_from_slice(s.as_bytes()); - self.strings_data.push(0); // null terminator - self.string_offsets.push((s.into(), offset)); - offset - } - - /// 递归收集所有属性名字符串 - fn collect_strings(&mut self, node: &Node) { - for prop in node.properties() { - self.get_or_add_string(prop.name()); - } - for child in node.children() { - self.collect_strings(child); - } + }) } - /// 构建结构块 - fn build_struct(&mut self, node: &Node) { - self.build_node(node); - // 添加 END token - let token: u32 = Token::End.into(); - self.struct_data.push(token.to_be()); + pub fn get_by_path<'a>(&'a self, path: &str) -> Option> { + let path = self.normalize_path(path)?; + NodeIter::new(self.root()).find_map(move |node_ref| { + if node_ref.path_eq(&path) { + Some(node_ref) + } else { + None + } + }) } - /// 递归构建节点 - fn build_node(&mut self, node: &Node) { - // 首先分析当前节点的 address-cells 和 size-cells 属性 - let mut address_cells = self.current_context().address_cells; - let mut size_cells = self.current_context().size_cells; - - // 查找节点的 address-cells 和 size-cells 属性 - for prop in node.properties() { - match prop { - crate::Property::AddressCells(value) => address_cells = *value, - crate::Property::SizeCells(value) => size_cells = *value, - _ => {} + pub fn get_by_path_mut<'a>(&'a mut self, path: &str) -> Option> { + let path = self.normalize_path(path)?; + NodeIterMut::new(self.root_mut()).find_map(move |node_mut| { + if node_mut.path_eq(&path) { + Some(node_mut) + } else { + None } - } - - // 推入当前节点的上下文 - self.push_context(address_cells, size_cells); - - // BEGIN_NODE - let begin_token: u32 = Token::BeginNode.into(); - self.struct_data.push(begin_token.to_be()); - - // 节点名（包含 null 终止符，对齐到 4 字节） - // 节点名是字节流，不需要进行大端转换 - let name_bytes = node.name().as_bytes(); - let name_len = name_bytes.len() + 1; // +1 for null - let aligned_len = (name_len + 3) & !3; - - let mut name_buf = vec![0u8; aligned_len]; - name_buf[..name_bytes.len()].copy_from_slice(name_bytes); - // null 终止符已经被 vec![0u8; ...] 填充 - - // 转换为 u32 数组（保持字节顺序不变） - for chunk in name_buf.chunks(4) { - let word = u32::from_ne_bytes(chunk.try_into().unwrap()); - self.struct_data.push(word); - } - - // 属性 - for prop in node.properties() { - self.build_property(node, prop); - } - - // 子节点 - for child in node.children() { - self.build_node(child); - } - - // END_NODE - let end_token: u32 = Token::EndNode.into(); - self.struct_data.push(end_token.to_be()); - - // 弹出当前节点的上下文 - self.pop_context(); + }) } - /// 构建属性 - fn build_property(&mut self, node: &Node, prop: &crate::Property) { - // PROP token - let prop_token: u32 = Token::Prop.into(); - self.struct_data.push(prop_token.to_be()); - - // 获取父节点的 address_cells 和 size_cells - let (parent_address_cells, parent_size_cells) = self.get_parent_cells(); - - // 获取序列化数据（传入父节点的 cells 信息） - let data = prop.to_bytes_with_cells(node, parent_address_cells, parent_size_cells); - - // 属性长度 - self.struct_data.push((data.len() as u32).to_be()); - - // 字符串偏移 - let nameoff = self.get_or_add_string(prop.name()); - self.struct_data.push(nameoff.to_be()); - - // 属性数据（对齐到 4 字节） - // 属性数据是原始字节流，不需要大端转换 - if !data.is_empty() { - let aligned_len = (data.len() + 3) & !3; - let mut data_buf = vec![0u8; aligned_len]; - data_buf[..data.len()].copy_from_slice(&data); + pub fn find_compatible(&self, compatible: &[&str]) -> Vec> { + let mut results = Vec::new(); + for node_ref in self.all_nodes() { + let Some(ls) = node_ref.compatible() else { + continue; + }; - // 转换为 u32 数组（保持字节顺序不变） - for chunk in data_buf.chunks(4) { - let word = u32::from_ne_bytes(chunk.try_into().unwrap()); - self.struct_data.push(word); + for comp in ls { + if compatible.contains(&comp) { + results.push(node_ref); + break; + } } } + results } - /// 生成最终 FDT 数据 - fn finalize(self, boot_cpuid_phys: u32, memory_reservations: &[MemoryReservation]) -> FdtData { - // 计算各部分大小和偏移 - let header_size = 40u32; // 10 * 4 bytes - let mem_rsv_size = ((memory_reservations.len() + 1) * 16) as u32; // +1 for terminator - let struct_size = (self.struct_data.len() * 4) as u32; - let strings_size = self.strings_data.len() as u32; - - let off_mem_rsvmap = header_size; - let off_dt_struct = off_mem_rsvmap + mem_rsv_size; - let off_dt_strings = off_dt_struct + struct_size; - let totalsize = off_dt_strings + strings_size; - - // 对齐到 4 字节 - let totalsize_aligned = (totalsize + 3) & !3; - - let mut data = Vec::with_capacity(totalsize_aligned as usize / 4); - - // Header - data.push(FDT_MAGIC.to_be()); - data.push(totalsize_aligned.to_be()); - data.push(off_dt_struct.to_be()); - data.push(off_dt_strings.to_be()); - data.push(off_mem_rsvmap.to_be()); - data.push(17u32.to_be()); // version - data.push(16u32.to_be()); // last_comp_version - data.push(boot_cpuid_phys.to_be()); - data.push(strings_size.to_be()); - data.push(struct_size.to_be()); - - // Memory reservation block - for rsv in memory_reservations { - let addr_hi = (rsv.address >> 32) as u32; - let addr_lo = rsv.address as u32; - let size_hi = (rsv.size >> 32) as u32; - let size_lo = rsv.size as u32; - data.push(addr_hi.to_be()); - data.push(addr_lo.to_be()); - data.push(size_hi.to_be()); - data.push(size_lo.to_be()); - } - // Terminator - data.push(0); - data.push(0); - data.push(0); - data.push(0); - - // Struct block - data.extend_from_slice(&self.struct_data); - - // Strings block（按字节复制，对齐到 4 字节） - // 字符串数据是原始字节流，不需要大端转换 - let strings_aligned_len = (self.strings_data.len() + 3) & !3; - let mut strings_buf = vec![0u8; strings_aligned_len]; - strings_buf[..self.strings_data.len()].copy_from_slice(&self.strings_data); - - // 转换为 u32 数组（保持字节顺序不变） - for chunk in strings_buf.chunks(4) { - let word = u32::from_ne_bytes(chunk.try_into().unwrap()); - data.push(word); - } - - FdtData(data) - } -} - -/// FDT 二进制数据 -#[derive(Clone, Debug)] -pub struct FdtData(Vec); - -impl FdtData { - /// 获取数据长度（字节） - pub fn len(&self) -> usize { - self.0.len() * 4 - } - - /// 数据是否为空 - pub fn is_empty(&self) -> bool { - self.0.is_empty() + /// 序列化为 FDT 二进制数据 + pub fn encode(&self) -> FdtData { + FdtEncoder::new(self).encode() } } -impl Deref for FdtData { - type Target = [u8]; +impl core::fmt::Display for Fdt { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + // 输出 DTS 头部信息 + writeln!(f, "/dts-v1/;")?; - fn deref(&self) -> &Self::Target { - unsafe { - core::slice::from_raw_parts( - self.0.as_ptr() as *const u8, - self.0.len() * core::mem::size_of::(), - ) + // 输出内存保留块 + for reservation in &self.memory_reservations { + writeln!( + f, + "/memreserve/ 0x{:x} 0x{:x};", + reservation.address, reservation.size + )?; } - } -} -impl AsRef<[u8]> for FdtData { - fn as_ref(&self) -> &[u8] { - self + // 输出根节点 + writeln!(f, "{}", self.root) } } -impl fmt::Display for Fdt { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - // 写入 DTS 文件头注释 - writeln!(f, "// Device Tree Source")?; - writeln!(f, "// Generated by fdt-edit")?; - writeln!(f)?; - - // 写入内存保留块 - if !self.memory_reservations.is_empty() { - writeln!(f, "/dts-v1/;")?; - writeln!(f, "/memreserve/ ")?; - for rsv in &self.memory_reservations { - writeln!(f, "\t{:#x} {:#x};", rsv.address, rsv.size)?; - } - writeln!(f)?; +impl core::fmt::Debug for Fdt { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + if f.alternate() { + // Deep debug format with node traversal + self.fmt_debug_deep(f) + } else { + // Simple debug format (current behavior) + f.debug_struct("Fdt") + .field("boot_cpuid_phys", &self.boot_cpuid_phys) + .field("memory_reservations_count", &self.memory_reservations.len()) + .field("root_node_name", &self.root.name) + .field("total_nodes", &self.root.children.len()) + .field("phandle_cache_size", &self.phandle_cache.len()) + .finish() } - - // 写入根节点 - self.fmt_node(f, &self.root, 0)?; - - Ok(()) } } impl Fdt { - /// 格式化节点为 DTS 格式 - fn fmt_node(&self, f: &mut fmt::Formatter<'_>, node: &Node, indent: usize) -> fmt::Result { - let indent_str = " ".repeat(indent); - - // 写入节点名（根节点名为空，显示为 /） - let node_name = if node.name().is_empty() { - "/" - } else { - node.name() - }; - - write!(f, "{}{} {{", indent_str, node_name)?; - - // 如果没有属性和子节点，写成单行 - if node.properties().count() == 0 && node.children().count() == 0 { - return writeln!(f, " }};"); - } - - writeln!(f)?; + fn fmt_debug_deep(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + writeln!(f, "Fdt {{")?; + writeln!(f, " boot_cpuid_phys: 0x{:x},", self.boot_cpuid_phys)?; + writeln!( + f, + " memory_reservations_count: {},", + self.memory_reservations.len() + )?; + writeln!(f, " phandle_cache_size: {},", self.phandle_cache.len())?; + writeln!(f, " nodes:")?; - // 写入属性 - for prop in node.properties() { - self.fmt_property(f, prop, indent + 1)?; + // 遍历所有节点并打印带缩进的调试信息 + for (i, node) in self.all_nodes().enumerate() { + self.fmt_node_debug(f, &node, 2, i)?; } - // 如果有子节点，添加空行分隔 - if node.properties().count() > 0 && node.children().count() > 0 { - writeln!(f)?; - } - - // 写入子节点 - for child in node.children() { - self.fmt_node(f, child, indent + 1)?; - } - - // 写入节点结束 - writeln!(f, "{}}};", indent_str)?; - - Ok(()) + writeln!(f, "}}") } - /// 格式化属性为 DTS 格式 - fn fmt_property( + fn fmt_node_debug( &self, - f: &mut fmt::Formatter<'_>, - prop: &crate::Property, + f: &mut core::fmt::Formatter<'_>, + node: &NodeRef, indent: usize, - ) -> fmt::Result { - let indent_str = " ".repeat(indent); - write!(f, "{}{};", indent_str, self.format_property_value(prop))?; - writeln!(f) - } - - /// 格式化属性值为 DTS 格式 - fn format_property_value(&self, prop: &crate::Property) -> String { - match prop { - crate::Property::AddressCells(value) => format!("#address-cells = <{}>", value), - crate::Property::SizeCells(value) => format!("#size-cells = <{}>", value), - crate::Property::InterruptCells(value) => format!("#interrupt-cells = <{}>", value), - crate::Property::Reg(entries) => { - let values: Vec = entries - .iter() - .map(|entry| { - let mut result = format!("{:#x}", entry.address); - if let Some(size) = entry.size { - result.push_str(&format!(" {:#x}", size)); - } - result - }) - .collect(); - format!("reg = <{}>", values.join(" ")) - } - crate::Property::Ranges { - entries, - child_address_cells: _, - parent_address_cells: _, - size_cells: _, - } => { - if entries.is_empty() { - "ranges;".to_string() + index: usize, + ) -> core::fmt::Result { + // 打印缩进 + for _ in 0..indent { + write!(f, " ")?; + } + + // 打印节点索引和基本信息 + write!(f, "[{:03}] {}: ", index, node.name())?; + + // 根据节点类型打印特定信息 + match node.as_ref() { + NodeKind::Clock(clock) => { + write!(f, "Clock")?; + if let ClockType::Fixed(fixed) = &clock.kind { + write!(f, " (Fixed, {}Hz)", fixed.frequency)?; } else { - let values: Vec = entries - .iter() - .map(|entry| { - format!( - "{:#x} {:#x} {:#x}", - entry.child_bus_address, entry.parent_bus_address, entry.length - ) - }) - .collect(); - format!("ranges = <{}>", values.join(" ")) + write!(f, " (Provider)")?; } - } - crate::Property::Compatible(values) => { - let quoted: Vec = values.iter().map(|v| format!("\"{}\"", v)).collect(); - format!("compatible = {}", quoted.join(", ")) - } - crate::Property::Model(value) => format!("model = \"{}\"", value), - crate::Property::Status(status) => format!( - "status = \"{}\"", - match status { - crate::Status::Okay => "okay", - crate::Status::Disabled => "disabled", + if !clock.clock_output_names.is_empty() { + write!(f, ", outputs: {:?}", clock.clock_output_names)?; } - ), - crate::Property::Phandle(phandle) => format!("phandle = <{:#x}>", phandle.as_usize()), - crate::Property::LinuxPhandle(phandle) => { - format!("linux,phandle = <{:#x}>", phandle.as_usize()) + write!(f, ", cells={}", clock.clock_cells)?; } - crate::Property::DeviceType(value) => format!("device_type = \"{}\"", value), - crate::Property::InterruptParent(phandle) => { - format!("interrupt-parent = <{:#x}>", phandle.as_usize()) + NodeKind::Pci(pci) => { + write!(f, "PCI")?; + if let Some(bus_range) = pci.bus_range() { + write!(f, " (bus: {:?})", bus_range)?; + } + write!(f, ", interrupt-cells={}", pci.interrupt_cells())?; } - crate::Property::ClockNames(values) => { - let quoted: Vec = values.iter().map(|v| format!("\"{}\"", v)).collect(); - format!("clock-names = {}", quoted.join(", ")) + NodeKind::InterruptController(ic) => { + write!(f, "InterruptController")?; + if let Some(cells) = ic.interrupt_cells() { + write!(f, " (cells={})", cells)?; + } + let compatibles = ic.compatibles(); + if !compatibles.is_empty() { + write!(f, ", compatible: {:?}", compatibles)?; + } } - crate::Property::DmaCoherent => "dma-coherent;".to_string(), - crate::Property::Raw(raw) => { - if raw.is_empty() { - format!("{};", raw.name()) - } else { - // 尝试解析为字符串 - if let Ok(s) = core::str::from_utf8(raw.data()) { - if let Some(s) = s.strip_suffix('\0') { - return format!("{} = \"{}\"", raw.name(), s); - } else { - return format!("{} = \"{}\"", raw.name(), s); - } - } - - // 如果数据以 null 结尾且只包含可打印字符，当作字符串 - if let Some(null_pos) = raw.data().iter().position(|&b| b == 0) { - let data_str = &raw.data()[..null_pos]; - if data_str - .iter() - .all(|&b| b.is_ascii_graphic() || b.is_ascii_whitespace()) - { - if let Ok(s) = core::str::from_utf8(data_str) { - return format!("{} = \"{}\"", raw.name(), s); - } - } + NodeKind::Memory(mem) => { + write!(f, "Memory")?; + let regions = mem.regions(); + if !regions.is_empty() { + write!(f, " ({} regions", regions.len())?; + for (i, region) in regions.iter().take(2).enumerate() { + write!(f, ", [{}]: 0x{:x}+0x{:x}", i, region.address, region.size)?; } - - // 如果全是 4 字节对齐的数据，当作数字数组 - if raw.data().len() % 4 == 0 { - let values: Vec = raw - .data() - .chunks(4) - .map(|chunk| { - let array: [u8; 4] = chunk.try_into().unwrap(); - format!("{:#x}", u32::from_be_bytes(array)) - }) - .collect(); - format!("{} = <{}>", raw.name(), values.join(" ")) - } else { - // 当作字节数组 - let values: Vec = - raw.data().iter().map(|&b| format!("{:02x}", b)).collect(); - format!("{} = [{}]", raw.name(), values.join(" ")) + if regions.len() > 2 { + write!(f, ", ...")?; } + write!(f, ")")?; } } + NodeKind::Generic(_) => { + write!(f, "Generic")?; + } + } + + // 打印 phandle 信息 + if let Some(phandle) = node.phandle() { + write!(f, ", phandle={}", phandle)?; + } + + // 打印地址和大小 cells 信息 + if let Some(address_cells) = node.address_cells() { + write!(f, ", #address-cells={}", address_cells)?; + } + if let Some(size_cells) = node.size_cells() { + write!(f, ", #size-cells={}", size_cells)?; } + + writeln!(f)?; + + Ok(()) } } diff --git a/fdt-edit/src/lib.rs b/fdt-edit/src/lib.rs index 90c8849..b92da07 100644 --- a/fdt-edit/src/lib.rs +++ b/fdt-edit/src/lib.rs @@ -1,11 +1,18 @@ #![no_std] +#[macro_use] extern crate alloc; +mod ctx; +// mod display; +mod encode; mod fdt; mod node; mod prop; -pub use fdt::{Fdt, FdtData, MemoryReservation}; -pub use node::{Node, NodeOp}; -pub use prop::{Phandle, Property, RangesEntry, RawProperty, RegInfo, Status}; +pub use ctx::Context; +// pub use display::FmtLevel; +pub use fdt::{Fdt, MemoryReservation}; +pub use node::NodeKind; +pub use node::*; +pub use prop::{Phandle, Property, RangesEntry, RegInfo, Status}; diff --git a/fdt-edit/src/node/clock.rs b/fdt-edit/src/node/clock.rs new file mode 100644 index 0000000..11724b5 --- /dev/null +++ b/fdt-edit/src/node/clock.rs @@ -0,0 +1,221 @@ +use core::ops::Deref; + +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; +use fdt_raw::Phandle; + +use crate::node::gerneric::NodeRefGen; + +/// 时钟提供者类型 +#[derive(Clone, Debug, PartialEq)] +pub enum ClockType { + /// 固定时钟 + Fixed(FixedClock), + /// 普通时钟提供者 + Normal, +} + +/// 固定时钟 +#[derive(Clone, Debug, PartialEq)] +pub struct FixedClock { + pub name: Option, + /// 时钟频率 (Hz) + pub frequency: u32, + /// 时钟精度 + pub accuracy: Option, +} + +/// 时钟引用，用于解析 clocks 属性 +/// +/// 根据设备树规范，clocks 属性格式为： +/// `clocks = <&clock_provider specifier [specifier ...]> [<&clock_provider2 ...>]` +/// +/// 每个时钟引用由一个 phandle 和若干个 specifier cells 组成， +/// specifier 的数量由目标 clock provider 的 `#clock-cells` 属性决定。 +#[derive(Clone, Debug)] +pub struct ClockRef { + /// 时钟的名称，来自 clock-names 属性 + pub name: Option, + /// 时钟提供者的 phandle + pub phandle: Phandle, + /// provider 的 #clock-cells 值 + pub cells: u32, + /// 时钟选择器（specifier），通常第一个值用于选择时钟输出 + /// 长度由 provider 的 #clock-cells 决定 + pub specifier: Vec, +} + +impl ClockRef { + /// 创建一个新的时钟引用 + pub fn new(phandle: Phandle, cells: u32, specifier: Vec) -> Self { + Self { + name: None, + phandle, + cells, + specifier, + } + } + + /// 创建一个带名称的时钟引用 + pub fn with_name( + name: Option, + phandle: Phandle, + cells: u32, + specifier: Vec, + ) -> Self { + Self { + name, + phandle, + cells, + specifier, + } + } + + /// 获取选择器的第一个值（通常用于选择时钟输出） + /// + /// 只有当 `cells > 0` 时才返回选择器值， + /// 因为 `#clock-cells = 0` 的 provider 不需要选择器。 + pub fn select(&self) -> Option { + if self.cells > 0 { + self.specifier.first().copied() + } else { + None + } + } +} + +/// 时钟提供者节点引用 +#[derive(Clone)] +pub struct NodeRefClock<'a> { + pub node: NodeRefGen<'a>, + pub clock_output_names: Vec, + pub clock_cells: u32, + pub kind: ClockType, +} + +impl<'a> NodeRefClock<'a> { + pub fn try_from(node: NodeRefGen<'a>) -> Result> { + // 检查是否有时钟提供者属性 + if node.find_property("#clock-cells").is_none() { + return Err(node); + } + + // 获取 clock-output-names 属性 + let clock_output_names = if let Some(prop) = node.find_property("clock-output-names") { + let iter = prop.as_str_iter(); + iter.map(|s| s.to_string()).collect() + } else { + Vec::new() + }; + + // 获取 #clock-cells + let clock_cells = node + .find_property("#clock-cells") + .and_then(|prop| prop.get_u32()) + .unwrap_or(0); + + // 判断时钟类型 + let kind = if node.compatibles().any(|c| c == "fixed-clock") { + let frequency = node + .find_property("clock-frequency") + .and_then(|prop| prop.get_u32()) + .unwrap_or(0); + let accuracy = node + .find_property("clock-accuracy") + .and_then(|prop| prop.get_u32()); + let name = clock_output_names.first().cloned(); + + ClockType::Fixed(FixedClock { + name, + frequency, + accuracy, + }) + } else { + ClockType::Normal + }; + + Ok(Self { + node, + clock_output_names, + clock_cells, + kind, + }) + } + + /// 获取时钟输出名称（用于 provider） + pub fn output_name(&self, index: usize) -> Option<&str> { + self.clock_output_names.get(index).map(|s| s.as_str()) + } + + /// 解析 clocks 属性，返回时钟引用列表 + /// + /// 通过查找每个 phandle 对应的 clock provider 的 #clock-cells， + /// 正确解析 specifier 的长度。 + pub fn clocks(&self) -> Vec { + let Some(prop) = self.find_property("clocks") else { + return Vec::new(); + }; + + let mut clocks = Vec::new(); + let mut data = prop.as_reader(); + let mut index = 0; + + // 获取 clock-names 用于命名 + let clock_names = if let Some(prop) = self.find_property("clock-names") { + let iter = prop.as_str_iter(); + iter.map(|s| s.to_string()).collect() + } else { + Vec::new() + }; + + while let Some(phandle_raw) = data.read_u32() { + let phandle = Phandle::from(phandle_raw); + + // 通过 phandle 查找 provider 节点，获取其 #clock-cells + let clock_cells = if let Some(provider) = self.ctx.find_by_phandle(phandle) { + provider + .get_property("#clock-cells") + .and_then(|p| p.get_u32()) + .unwrap_or(1) // 默认 1 cell + } else { + 1 // 默认 1 cell + }; + + // 读取 specifier（根据 provider 的 #clock-cells） + let mut specifier = Vec::with_capacity(clock_cells as usize); + let mut complete = true; + for _ in 0..clock_cells { + if let Some(val) = data.read_u32() { + specifier.push(val); + } else { + // 数据不足，停止解析 + complete = false; + break; + } + } + + // 只有完整的 clock reference 才添加 + if !complete { + break; + } + + // 从 clock-names 获取对应的名称 + let name = clock_names.get(index).cloned(); + + clocks.push(ClockRef::with_name(name, phandle, clock_cells, specifier)); + index += 1; + } + + clocks + } +} + +impl<'a> Deref for NodeRefClock<'a> { + type Target = NodeRefGen<'a>; + + fn deref(&self) -> &Self::Target { + &self.node + } +} diff --git a/fdt-edit/src/node/display.rs b/fdt-edit/src/node/display.rs new file mode 100644 index 0000000..4d6050c --- /dev/null +++ b/fdt-edit/src/node/display.rs @@ -0,0 +1,459 @@ +use core::fmt; + +use alloc::vec::Vec; + +use crate::{ + ClockType, Node, NodeKind, NodeMut, NodeRef, NodeRefClock, NodeRefInterruptController, + NodeRefMemory, Property, +}; + +/// Node 的 DTS 显示格式化器 +pub struct NodeDisplay<'a> { + node: &'a Node, + indent: usize, + show_address: bool, + show_size: bool, +} + +impl<'a> NodeDisplay<'a> { + pub fn new(node: &'a Node) -> Self { + Self { + node, + indent: 0, + show_address: true, + show_size: true, + } + } + + pub fn indent(mut self, indent: usize) -> Self { + self.indent = indent; + self + } + + pub fn show_address(mut self, show: bool) -> Self { + self.show_address = show; + self + } + + pub fn show_size(mut self, show: bool) -> Self { + self.show_size = show; + self + } + + fn format_indent(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + for _ in 0..self.indent { + write!(f, " ")?; + } + Ok(()) + } + + fn format_property(&self, prop: &Property, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.format_indent(f)?; + match prop.name() { + "reg" => { + if self.show_address || self.show_size { + write!(f, "reg = ")?; + self.format_reg_values(prop, f)?; + } else { + write!(f, "reg;")?; + } + } + "compatible" => { + write!(f, "compatible = ")?; + self.format_string_list(prop, f)?; + } + "clock-names" | "pinctrl-names" | "reg-names" => { + write!(f, "{} = ", prop.name())?; + self.format_string_list(prop, f)?; + } + "interrupt-controller" + | "#address-cells" + | "#size-cells" + | "#interrupt-cells" + | "#clock-cells" + | "phandle" => { + write!(f, "{};", prop.name())?; + } + _ => { + write!(f, "{} = ", prop.name())?; + self.format_property_value(prop, f)?; + } + } + writeln!(f) + } + + fn format_reg_values(&self, prop: &Property, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut reader = prop.as_reader(); + let mut first = true; + write!(f, "<")?; + + // 获取 parent 的 address-cells 和 size-cells + // 这里需要从上下文获取，暂时使用默认值 + let address_cells = 2; // 默认值 + let size_cells = 1; // 默认值 + + while let (Some(addr), Some(size)) = ( + reader.read_cells(address_cells), + reader.read_cells(size_cells), + ) { + if !first { + write!(f, " ")?; + } + first = false; + + if self.show_address { + write!(f, "0x{:x}", addr)?; + } + if self.show_size && size > 0 { + if self.show_address { + write!(f, " ")?; + } + write!(f, "0x{:x}", size)?; + } + } + + write!(f, ">;") + } + + fn format_string_list(&self, prop: &Property, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let iter = prop.as_str_iter(); + let mut first = true; + write!(f, "\"")?; + for s in iter { + if !first { + write!(f, "\", \"")?; + } + first = false; + write!(f, "{}", s)?; + } + write!(f, "\";") + } + + fn format_property_value(&self, prop: &Property, f: &mut fmt::Formatter<'_>) -> fmt::Result { + if let Some(s) = prop.as_str() { + write!(f, "\"{}\";", s) + } else if let Some(u32_val) = prop.get_u32() { + write!(f, "<0x{:x}>;", u32_val) + } else if let Some(u64_val) = prop.get_u64() { + write!(f, "<0x{:x}>;", u64_val) + } else { + // 尝试格式化为字节数组 + let mut reader = prop.as_reader(); + let mut first = true; + write!(f, "<")?; + while let Some(val) = reader.read_u32() { + if !first { + write!(f, " ")?; + } + first = false; + write!(f, "0x{:02x}", val)?; + } + write!(f, ">;") + } + } +} + +impl<'a> fmt::Display for NodeDisplay<'a> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.format_indent(f)?; + + if self.node.name.is_empty() { + // 根节点 + writeln!(f, "/ {{")?; + } else { + // 普通节点 + write!(f, "{}", self.node.name)?; + + // 检查是否有地址和大小属性需要显示 + let mut props = Vec::new(); + for prop in self.node.properties() { + if prop.name() != "reg" { + props.push(prop); + } + } + + if !props.is_empty() { + writeln!(f, " {{")?; + } else { + writeln!(f, ";")?; + return Ok(()); + } + } + + // 输出属性 + for prop in self.node.properties() { + if prop.name() != "reg" || self.show_address || self.show_size { + self.format_property(prop, f)?; + } + } + + // 输出子节点 + for child in self.node.children() { + let child_display = NodeDisplay::new(child) + .indent(self.indent + 1) + .show_address(self.show_address) + .show_size(self.show_size); + write!(f, "{}", child_display)?; + } + + // 关闭节点 + self.format_indent(f)?; + writeln!(f, "}};")?; + + Ok(()) + } +} + +impl fmt::Display for Node { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let display = NodeDisplay::new(self); + write!(f, "{}", display) + } +} + +impl fmt::Debug for Node { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("Node") + .field("name", &self.name) + .field("children_count", &self.children.len()) + .field("properties_count", &self.properties.len()) + .field("phandle", &self.phandle()) + .field("address_cells", &self.address_cells()) + .field("size_cells", &self.size_cells()) + .finish() + } +} + +/// NodeRef 的显示格式化器 +pub struct NodeRefDisplay<'a> { + node_ref: &'a NodeRef<'a>, + indent: usize, + show_details: bool, +} + +impl<'a> NodeRefDisplay<'a> { + pub fn new(node_ref: &'a NodeRef<'a>) -> Self { + Self { + node_ref, + indent: 0, + show_details: true, + } + } + + pub fn indent(mut self, indent: usize) -> Self { + self.indent = indent; + self + } + + pub fn show_details(mut self, show: bool) -> Self { + self.show_details = show; + self + } + + fn format_type_info(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self.node_ref.as_ref() { + NodeKind::Clock(clock) => { + write!(f, "Clock Node: ")?; + if let ClockType::Fixed(fixed) = &clock.kind { + write!(f, "Fixed Clock (freq={}Hz", fixed.frequency)?; + if let Some(accuracy) = fixed.accuracy { + write!(f, ", accuracy={})", accuracy)?; + } + write!(f, ")")?; + } else { + write!(f, "Clock Provider")?; + } + if !clock.clock_output_names.is_empty() { + write!(f, ", outputs: {:?}", clock.clock_output_names)?; + } + write!(f, ", cells={}", clock.clock_cells)?; + } + NodeKind::Pci(pci) => { + write!(f, "PCI Node")?; + if let Some(bus_range) = pci.bus_range() { + write!(f, " (bus range: {:?})", bus_range)?; + } + write!(f, ", interrupt-cells={}", pci.interrupt_cells())?; + } + NodeKind::InterruptController(ic) => { + write!(f, "Interrupt Controller")?; + if let Some(cells) = ic.interrupt_cells() { + write!(f, " (interrupt-cells={})", cells)?; + } + let compatibles = ic.compatibles(); + if !compatibles.is_empty() { + write!(f, ", compatible: {:?}", compatibles)?; + } + } + NodeKind::Memory(mem) => { + write!(f, "Memory Node")?; + let regions = mem.regions(); + if !regions.is_empty() { + write!(f, " ({} regions)", regions.len())?; + for (i, region) in regions.iter().take(3).enumerate() { + write!( + f, + "\n [{}]: 0x{:x}-0x{:x}", + i, + region.address, + region.address + region.size + )?; + } + } + if let Some(dt) = mem.device_type() { + write!(f, ", device_type={}", dt)?; + } + } + NodeKind::Generic(_) => { + write!(f, "Generic Node")?; + } + } + Ok(()) + } +} + +impl<'a> fmt::Display for NodeRefDisplay<'a> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + for _ in 0..self.indent { + write!(f, " ")?; + } + + if self.show_details { + write!(f, "{}: ", self.node_ref.name())?; + self.format_type_info(f)?; + writeln!(f)?; + + // 添加缩进并显示 DTS + let dts_display = NodeDisplay::new(self.node_ref).indent(self.indent + 1); + write!(f, "{}", dts_display)?; + } else { + write!(f, "{}", self.node_ref.name())?; + } + + Ok(()) + } +} + +impl fmt::Display for NodeRef<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let display = NodeRefDisplay::new(self); + write!(f, "{}", display) + } +} + +impl fmt::Debug for NodeRef<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("NodeRef") + .field("name", &self.name()) + .field("path", &self.path()) + .field( + "node_type", + &match self.as_ref() { + NodeKind::Clock(_) => "Clock", + NodeKind::Pci(_) => "PCI", + NodeKind::InterruptController(_) => "InterruptController", + NodeKind::Memory(_) => "Memory", + NodeKind::Generic(_) => "Generic", + }, + ) + .field("phandle", &self.phandle()) + .finish() + } +} + +impl fmt::Debug for NodeRefClock<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("NodeRefClock") + .field("name", &self.name()) + .field("clock_cells", &self.clock_cells) + .field("clock_type", &self.kind) + .field("output_names", &self.clock_output_names) + .field("phandle", &self.phandle()) + .finish() + } +} + +impl fmt::Debug for NodeRefInterruptController<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("NodeRefInterruptController") + .field("name", &self.name()) + .field("interrupt_cells", &self.interrupt_cells()) + .field("interrupt_address_cells", &self.interrupt_address_cells()) + .field("is_interrupt_controller", &self.is_interrupt_controller()) + .field("compatibles", &self.compatibles()) + .field("phandle", &self.phandle()) + .finish() + } +} + +impl fmt::Debug for NodeRefMemory<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("NodeRefMemory") + .field("name", &self.name()) + .field("regions_count", &self.regions().len()) + .field("device_type", &self.device_type()) + .field("phandle", &self.phandle()) + .finish() + } +} + +impl fmt::Display for NodeRefClock<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let node_ref = crate::NodeRef::Clock(self.clone()); + let display = NodeRefDisplay::new(&node_ref); + write!(f, "{}", display) + } +} + +impl fmt::Display for NodeRefInterruptController<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let node_ref = crate::NodeRef::InterruptController(self.clone()); + let display = NodeRefDisplay::new(&node_ref); + write!(f, "{}", display) + } +} + +impl fmt::Display for NodeRefMemory<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let node_ref = crate::NodeRef::Memory(self.clone()); + let display = NodeRefDisplay::new(&node_ref); + write!(f, "{}", display) + } +} + +impl fmt::Display for NodeMut<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + NodeMut::Gerneric(generic) => { + let display = NodeDisplay::new(generic.node); + write!(f, "{}", display) + } + } + } +} + +impl fmt::Debug for NodeMut<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("NodeMut") + .field( + "name", + &match self { + NodeMut::Gerneric(generic) => generic.node.name(), + }, + ) + .field("node_type", &"Generic") + .field( + "children_count", + &match self { + NodeMut::Gerneric(generic) => generic.node.children.len(), + }, + ) + .field( + "properties_count", + &match self { + NodeMut::Gerneric(generic) => generic.node.properties.len(), + }, + ) + .finish() + } +} diff --git a/fdt-edit/src/node/gerneric.rs b/fdt-edit/src/node/gerneric.rs new file mode 100644 index 0000000..9cba00a --- /dev/null +++ b/fdt-edit/src/node/gerneric.rs @@ -0,0 +1,251 @@ +use alloc::{string::String, vec::Vec}; +use core::{fmt::Debug, ops::Deref}; +use fdt_raw::RegInfo; + +use crate::{Context, Node, Property}; + +#[derive(Clone)] +pub struct NodeRefGen<'a> { + pub node: &'a Node, + pub ctx: Context<'a>, +} + +impl<'a> NodeRefGen<'a> { + pub fn find_property(&self, name: &str) -> Option<&'a Property> { + self.node.get_property(name) + } + + pub fn properties(&self) -> impl Iterator { + self.node.properties.iter() + } + + fn op(&'a self) -> RefOp<'a> { + RefOp { + ctx: &self.ctx, + node: self.node, + } + } + + pub fn path(&self) -> String { + self.op().path() + } + + pub fn path_eq(&self, path: &str) -> bool { + self.op().ref_path_eq(path) + } + + pub fn path_eq_fuzzy(&self, path: &str) -> bool { + self.op().ref_path_eq_fuzzy(path) + } + + pub fn regs(&self) -> Option> { + self.op().regs() + } +} + +impl Deref for NodeRefGen<'_> { + type Target = Node; + + fn deref(&self) -> &Self::Target { + self.node + } +} + +pub struct NodeMutGen<'a> { + pub node: &'a mut Node, + pub ctx: Context<'a>, +} + +impl<'a> NodeMutGen<'a> { + fn op(&'a self) -> RefOp<'a> { + RefOp { + ctx: &self.ctx, + node: self.node, + } + } + + pub fn path(&self) -> String { + self.op().path() + } + + pub fn path_eq(&self, path: &str) -> bool { + self.op().ref_path_eq(path) + } + + pub fn path_eq_fuzzy(&self, path: &str) -> bool { + self.op().ref_path_eq_fuzzy(path) + } + + pub fn regs(&self) -> Option> { + self.op().regs() + } + + /// 设置 reg 属性 + /// + /// # 参数 + /// - `regs`: RegInfo 列表，其中 `address` 是 CPU 地址（物理地址） + /// + /// 该方法会根据父节点的 ranges 将 CPU 地址转换为 bus 地址后存储 + pub fn set_regs(&mut self, regs: &[RegInfo]) { + let address_cells = self.ctx.parent_address_cells() as usize; + let size_cells = self.ctx.parent_size_cells() as usize; + let ranges = self.ctx.current_ranges(); + + let mut data = Vec::new(); + + for reg in regs { + // 将 CPU 地址转换为 bus 地址 + let mut bus_address = reg.address; + if let Some(ref ranges) = ranges { + for r in ranges { + // 检查 CPU 地址是否在 ranges 映射范围内 + if reg.address >= r.parent_bus_address + && reg.address < r.parent_bus_address + r.length + { + // 反向转换：cpu_address -> bus_address + bus_address = reg.address - r.parent_bus_address + r.child_bus_address; + break; + } + } + } + + // 写入 bus address (big-endian) + if address_cells == 1 { + data.extend_from_slice(&(bus_address as u32).to_be_bytes()); + } else if address_cells == 2 { + data.extend_from_slice(&((bus_address >> 32) as u32).to_be_bytes()); + data.extend_from_slice(&((bus_address & 0xFFFF_FFFF) as u32).to_be_bytes()); + } + + // 写入 size (big-endian) + if size_cells == 1 { + let size = reg.size.unwrap_or(0); + data.extend_from_slice(&(size as u32).to_be_bytes()); + } else if size_cells == 2 { + let size = reg.size.unwrap_or(0); + data.extend_from_slice(&((size >> 32) as u32).to_be_bytes()); + data.extend_from_slice(&((size & 0xFFFF_FFFF) as u32).to_be_bytes()); + } + } + + let prop = Property::new("reg", data); + self.node.set_property(prop); + } +} + +impl Debug for NodeRefGen<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "NodeRefGen {{ name: {} }}", self.node.name()) + } +} + +impl Debug for NodeMutGen<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "NodeMutGen {{ name: {} }}", self.node.name()) + } +} + +struct RefOp<'a> { + ctx: &'a Context<'a>, + node: &'a Node, +} + +impl<'a> RefOp<'a> { + fn path(&self) -> String { + self.ctx.current_path() + "/" + self.node.name() + } + + fn ref_path_eq(&self, path: &str) -> bool { + self.path() == path + } + + fn ref_path_eq_fuzzy(&self, path: &str) -> bool { + let mut want = path.trim_matches('/').split("/"); + let got_path = self.path(); + let mut got = got_path.trim_matches('/').split("/"); + let got_count = got.clone().count(); + let mut current = 0; + + loop { + let w = want.next(); + let g = got.next(); + let is_last = current + 1 == got_count; + + match (w, g) { + (Some(w), Some(g)) => { + if w != g && !is_last { + return false; + } + + let name = g.split('@').next().unwrap_or(g); + let addr = g.split('@').nth(1); + + let want_name = w.split('@').next().unwrap_or(w); + let want_addr = w.split('@').nth(1); + + let res = match (addr, want_addr) { + (Some(a), Some(wa)) => name == want_name && a == wa, + (Some(_), None) => name == want_name, + (None, Some(_)) => false, + (None, None) => name == want_name, + }; + if !res { + return false; + } + } + (None, _) => break, + _ => return false, + } + current += 1; + } + true + } + + fn regs(&self) -> Option> { + let prop = self.node.get_property("reg")?; + let mut iter = prop.as_reader(); + let address_cells = self.ctx.parent_address_cells() as usize; + let size_cells = self.ctx.parent_size_cells() as usize; + + // 从上下文获取当前 ranges + let ranges = self.ctx.current_ranges(); + let mut out = vec![]; + let mut size; + + while let Some(mut address) = iter.read_cells(address_cells) { + if size_cells > 0 { + size = iter.read_cells(size_cells); + } else { + size = None; + } + let child_bus_address = address; + + if let Some(ref ranges) = ranges { + for r in ranges { + if child_bus_address >= r.child_bus_address + && child_bus_address < r.child_bus_address + r.length + { + address = child_bus_address - r.child_bus_address + r.parent_bus_address; + break; + } + } + } + + let reg = RegFixed { + address, + child_bus_address, + size, + }; + out.push(reg); + } + + Some(out) + } +} + +#[derive(Clone, Copy, Debug)] +pub struct RegFixed { + pub address: u64, + pub child_bus_address: u64, + pub size: Option, +} diff --git a/fdt-edit/src/node/interrupt_controller.rs b/fdt-edit/src/node/interrupt_controller.rs new file mode 100644 index 0000000..cee6f71 --- /dev/null +++ b/fdt-edit/src/node/interrupt_controller.rs @@ -0,0 +1,64 @@ +use core::ops::Deref; + +use alloc::vec::Vec; + +use crate::node::gerneric::NodeRefGen; + +/// 中断控制器节点引用 +#[derive(Clone)] +pub struct NodeRefInterruptController<'a> { + pub node: NodeRefGen<'a>, +} + +impl<'a> NodeRefInterruptController<'a> { + pub fn try_from(node: NodeRefGen<'a>) -> Result> { + if !is_interrupt_controller_node(&node) { + return Err(node); + } + Ok(Self { node }) + } + + /// 获取 #interrupt-cells 值 + /// + /// 这决定了引用此控制器的中断需要多少个 cell 来描述 + pub fn interrupt_cells(&self) -> Option { + self.find_property("#interrupt-cells") + .and_then(|prop| prop.get_u32()) + } + + /// 获取 #address-cells 值（用于 interrupt-map） + pub fn interrupt_address_cells(&self) -> Option { + self.find_property("#address-cells") + .and_then(|prop| prop.get_u32()) + } + + /// 检查是否是中断控制器 + pub fn is_interrupt_controller(&self) -> bool { + // 检查 interrupt-controller 属性（空属性标记） + self.find_property("interrupt-controller").is_some() + } + + /// 获取 compatible 列表 + pub fn compatibles(&self) -> Vec<&str> { + self.node.compatibles().collect() + } +} + +impl<'a> Deref for NodeRefInterruptController<'a> { + type Target = NodeRefGen<'a>; + + fn deref(&self) -> &Self::Target { + &self.node + } +} + +/// 检查节点是否是中断控制器 +fn is_interrupt_controller_node(node: &NodeRefGen) -> bool { + // 名称以 interrupt-controller 开头 + if node.name().starts_with("interrupt-controller") { + return true; + } + + // 或者有 interrupt-controller 属性 + node.find_property("interrupt-controller").is_some() +} diff --git a/fdt-edit/src/node/iter.rs b/fdt-edit/src/node/iter.rs new file mode 100644 index 0000000..e178977 --- /dev/null +++ b/fdt-edit/src/node/iter.rs @@ -0,0 +1,244 @@ +use core::{ + ops::{Deref, DerefMut}, + ptr::NonNull, + slice::Iter, +}; + +use alloc::vec::Vec; + +use crate::{ + Context, Node, NodeKind, NodeRefClock, NodeRefInterruptController, NodeRefMemory, NodeRefPci, + node::gerneric::{NodeMutGen, NodeRefGen}, +}; + +#[derive(Clone)] +pub enum NodeRef<'a> { + Gerneric(NodeRefGen<'a>), + Pci(NodeRefPci<'a>), + Clock(NodeRefClock<'a>), + InterruptController(NodeRefInterruptController<'a>), + Memory(NodeRefMemory<'a>), +} + +impl<'a> NodeRef<'a> { + pub fn new(node: &'a Node, ctx: Context<'a>) -> Self { + let mut g = NodeRefGen { node, ctx }; + + // 先尝试 PCI + g = match NodeRefPci::try_from(g) { + Ok(pci) => return Self::Pci(pci), + Err(v) => v, + }; + + // 再尝试 Clock + g = match NodeRefClock::try_from(g) { + Ok(clock) => return Self::Clock(clock), + Err(v) => v, + }; + + // 然后尝试 InterruptController + g = match NodeRefInterruptController::try_from(g) { + Ok(ic) => return Self::InterruptController(ic), + Err(v) => v, + }; + + // 最后尝试 Memory + g = match NodeRefMemory::try_from(g) { + Ok(mem) => return Self::Memory(mem), + Err(v) => v, + }; + + Self::Gerneric(g) + } + + /// 获取节点的具体类型用于模式匹配 + pub fn as_ref(&self) -> NodeKind<'a> { + match self { + NodeRef::Clock(clock) => NodeKind::Clock(clock.clone()), + NodeRef::Pci(pci) => NodeKind::Pci(pci.clone()), + NodeRef::InterruptController(ic) => NodeKind::InterruptController(ic.clone()), + NodeRef::Memory(mem) => NodeKind::Memory(mem.clone()), + NodeRef::Gerneric(generic) => NodeKind::Generic(generic.clone()), + } + } +} + +impl<'a> Deref for NodeRef<'a> { + type Target = NodeRefGen<'a>; + + fn deref(&self) -> &Self::Target { + match self { + NodeRef::Gerneric(n) => n, + NodeRef::Pci(n) => &n.node, + NodeRef::Clock(n) => &n.node, + NodeRef::InterruptController(n) => &n.node, + NodeRef::Memory(n) => &n.node, + } + } +} + +pub enum NodeMut<'a> { + Gerneric(NodeMutGen<'a>), +} + +impl<'a> NodeMut<'a> { + pub fn new(node: &'a mut Node, ctx: Context<'a>) -> Self { + Self::Gerneric(NodeMutGen { node, ctx }) + } +} + +impl<'a> Deref for NodeMut<'a> { + type Target = NodeMutGen<'a>; + + fn deref(&self) -> &Self::Target { + match self { + NodeMut::Gerneric(n) => n, + } + } +} + +impl<'a> DerefMut for NodeMut<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + match self { + NodeMut::Gerneric(n) => n, + } + } +} + +pub struct NodeIter<'a> { + ctx: Context<'a>, + node: Option<&'a Node>, + stack: Vec>, +} + +impl<'a> NodeIter<'a> { + pub fn new(root: &'a Node) -> Self { + let mut ctx = Context::new(); + // 预先构建整棵树的 phandle_map + // 这样在遍历任何节点时都能通过 phandle 找到其他节点 + Context::build_phandle_map_from_node(root, &mut ctx.phandle_map); + + Self { + ctx, + node: Some(root), + stack: vec![], + } + } +} + +impl<'a> Iterator for NodeIter<'a> { + type Item = NodeRef<'a>; + + fn next(&mut self) -> Option { + if let Some(n) = self.node.take() { + // 返回当前节点，并将其子节点压入栈中 + let ctx = self.ctx.clone(); + self.ctx.push(n); + self.stack.push(n.children.iter()); + return Some(NodeRef::new(n, ctx)); + } + + let iter = self.stack.last_mut()?; + + if let Some(child) = iter.next() { + // 返回子节点，并将其子节点压入栈中 + let ctx = self.ctx.clone(); + self.ctx.push(child); + self.stack.push(child.children.iter()); + return Some(NodeRef::new(child, ctx)); + } + + // 当前迭代器耗尽，弹出栈顶 + self.stack.pop(); + self.ctx.parents.pop(); + self.next() + } +} + +pub struct NodeIterMut<'a> { + ctx: Context<'a>, + node: Option>, + stack: Vec, + _marker: core::marker::PhantomData<&'a mut Node>, +} + +/// 原始指针子节点迭代器 +struct RawChildIter { + ptr: *mut Node, + end: *mut Node, +} + +impl RawChildIter { + fn new(children: &mut Vec) -> Self { + let ptr = children.as_mut_ptr(); + let end = unsafe { ptr.add(children.len()) }; + Self { ptr, end } + } + + fn next(&mut self) -> Option> { + if self.ptr < self.end { + let current = self.ptr; + self.ptr = unsafe { self.ptr.add(1) }; + NonNull::new(current) + } else { + None + } + } +} + +impl<'a> NodeIterMut<'a> { + pub fn new(root: &'a mut Node) -> Self { + let mut ctx = Context::new(); + // 预先构建整棵树的 phandle_map + // 使用原始指针来避免借用冲突 + let root_ptr = root as *mut Node; + unsafe { + // 用不可变引用构建 phandle_map + Context::build_phandle_map_from_node(&*root_ptr, &mut ctx.phandle_map); + } + + Self { + ctx, + node: NonNull::new(root_ptr), + stack: vec![], + _marker: core::marker::PhantomData, + } + } +} + +impl<'a> Iterator for NodeIterMut<'a> { + type Item = NodeMut<'a>; + + fn next(&mut self) -> Option { + if let Some(node_ptr) = self.node.take() { + // 返回当前节点，并将其子节点压入栈中 + let ctx = self.ctx.clone(); + unsafe { + let node_ref = node_ptr.as_ref(); + self.ctx.push(node_ref); + let node_mut = &mut *node_ptr.as_ptr(); + self.stack.push(RawChildIter::new(&mut node_mut.children)); + return Some(NodeMut::new(node_mut, ctx)); + } + } + + let iter = self.stack.last_mut()?; + + if let Some(child_ptr) = iter.next() { + // 返回子节点，并将其子节点压入栈中 + let ctx = self.ctx.clone(); + unsafe { + let child_ref = child_ptr.as_ref(); + self.ctx.push(child_ref); + let child_mut = &mut *child_ptr.as_ptr(); + self.stack.push(RawChildIter::new(&mut child_mut.children)); + return Some(NodeMut::new(child_mut, ctx)); + } + } + + // 当前迭代器耗尽，弹出栈顶 + self.stack.pop(); + self.ctx.parents.pop(); + self.next() + } +} diff --git a/fdt-edit/src/node/memory.rs b/fdt-edit/src/node/memory.rs new file mode 100644 index 0000000..2d17aaf --- /dev/null +++ b/fdt-edit/src/node/memory.rs @@ -0,0 +1,103 @@ +use core::ops::Deref; + +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; +use fdt_raw::MemoryRegion; + +use crate::node::gerneric::NodeRefGen; + +/// Memory 节点，描述物理内存布局 +#[derive(Clone, Debug)] +pub struct NodeMemory { + pub name: String, +} + +impl NodeMemory { + pub fn new(name: &str) -> Self { + Self { + name: name.to_string(), + } + } + + /// 获取节点名称 + pub fn name(&self) -> &str { + &self.name + } + + /// 获取内存区域列表 + /// 注意：这是一个简单的实现，实际使用时需要从实际的 FDT 节点中解析 + pub fn regions(&self) -> Vec { + // 这个方法在测试中主要用来检查是否为空 + Vec::new() + } + + /// 获取 device_type 属性 + /// 注意：这是一个简单的实现，返回 "memory" + pub fn device_type(&self) -> Option<&str> { + Some("memory") + } +} + +/// Memory 节点引用 +#[derive(Clone)] +pub struct NodeRefMemory<'a> { + pub node: NodeRefGen<'a>, +} + +impl<'a> NodeRefMemory<'a> { + pub fn try_from(node: NodeRefGen<'a>) -> Result> { + if !is_memory_node(&node) { + return Err(node); + } + Ok(Self { node }) + } + + /// 获取内存区域列表 + pub fn regions(&self) -> Vec { + let mut regions = Vec::new(); + if let Some(reg_prop) = self.find_property("reg") { + let mut reader = reg_prop.as_reader(); + + // 获取 parent 的 address-cells 和 size-cells + let address_cells = self.ctx.parent_address_cells() as usize; + let size_cells = self.ctx.parent_size_cells() as usize; + + while let (Some(address), Some(size)) = ( + reader.read_cells(address_cells), + reader.read_cells(size_cells), + ) { + regions.push(MemoryRegion { address, size }); + } + } + regions + } + + /// 获取 device_type 属性 + pub fn device_type(&self) -> Option<&str> { + self.find_property("device_type") + .and_then(|prop| prop.as_str()) + } +} + +impl<'a> Deref for NodeRefMemory<'a> { + type Target = NodeRefGen<'a>; + + fn deref(&self) -> &Self::Target { + &self.node + } +} + +/// 检查节点是否是 memory 节点 +fn is_memory_node(node: &NodeRefGen) -> bool { + // 检查 device_type 属性是否为 "memory" + if let Some(device_type) = node.device_type() + && device_type == "memory" + { + return true; + } + + // 或者节点名以 "memory" 开头 + node.name().starts_with("memory") +} diff --git a/fdt-edit/src/node/mod.rs b/fdt-edit/src/node/mod.rs index 91313f7..50bdec8 100644 --- a/fdt-edit/src/node/mod.rs +++ b/fdt-edit/src/node/mod.rs @@ -1,490 +1,221 @@ -use core::ops::{Deref, DerefMut}; +use core::fmt::Debug; use alloc::{ collections::BTreeMap, - format, string::{String, ToString}, - vec, vec::Vec, }; +use fdt_raw::data::StrIter; -use crate::{Phandle, Property, Status}; +use crate::{Phandle, Property, RangesEntry, Status, node::gerneric::NodeRefGen}; +mod clock; +mod display; +mod gerneric; +mod interrupt_controller; +mod iter; +mod memory; mod pci; +pub use clock::*; +pub use display::*; +pub use interrupt_controller::*; +pub use iter::*; +pub use memory::*; pub use pci::*; -#[enum_dispatch::enum_dispatch] +/// 节点类型枚举，用于模式匹配 #[derive(Clone, Debug)] -pub enum Node { - Raw(RawNode), - Pci(NodePci), +pub enum NodeKind<'a> { + Clock(NodeRefClock<'a>), + Pci(NodeRefPci<'a>), + InterruptController(NodeRefInterruptController<'a>), + Memory(NodeRefMemory<'a>), + Generic(NodeRefGen<'a>), } -impl Deref for Node { - type Target = RawNode; - - fn deref(&self) -> &Self::Target { - self.as_raw() - } -} - -impl DerefMut for Node { - fn deref_mut(&mut self) -> &mut Self::Target { - self.as_raw_mut() - } +#[derive(Clone)] +pub struct Node { + pub name: String, + /// 属性列表（保持原始顺序） + pub(crate) properties: Vec, + /// 属性名到索引的映射（用于快速查找） + pub(crate) prop_cache: BTreeMap, + pub(crate) children: Vec, + pub(crate) name_cache: BTreeMap, } impl Node { - /// 创建根节点 - pub fn root() -> Self { - Self::Raw(RawNode::new("")) - } - - fn new(raw: RawNode) -> Self { - let mut node = Self::Raw(raw); - if let Some(t) = node.find_property("device_type") - && let Property::DeviceType(dt) = t - && dt == "pci" - { - node = Self::Pci(NodePci(node.to_raw())); - } - node - } - - pub fn new_raw(name: &str) -> Self { - Self::new(RawNode::new(name)) - } -} - -#[enum_dispatch::enum_dispatch(Node)] -pub trait NodeTrait { - fn as_raw(&self) -> &RawNode; - fn as_raw_mut(&mut self) -> &mut RawNode; - fn to_raw(self) -> RawNode; -} - -impl NodeTrait for RawNode { - fn as_raw(&self) -> &RawNode { - self - } - fn as_raw_mut(&mut self) -> &mut RawNode { - self - } - fn to_raw(self) -> RawNode { - self - } -} - -impl NodeOp for Node {} -impl NodeOp for RawNode {} - -pub trait NodeOp: NodeTrait { - fn name(&self) -> &str { - &self.as_raw().name - } - - fn children(&self) -> core::slice::Iter<'_, Node> { - self.as_raw().children.iter() - } - - fn children_mut(&mut self) -> core::slice::IterMut<'_, Node> { - self.as_raw_mut().children.iter_mut() - } - - /// 获取所有子节点名称（按原始顺序） - fn child_names(&self) -> Vec<&str> { - self.children().map(|child| child.name()).collect() - } - - /// 获取子节点数量 - fn child_count(&self) -> usize { - self.as_raw().children.len() - } - - /// 按索引获取子节点 - fn child_at(&self, index: usize) -> Option<&Node> { - self.as_raw().children.get(index) - } - - /// 按索引获取子节点（可变） - fn child_at_mut(&mut self, index: usize) -> Option<&mut Node> { - self.as_raw_mut().children.get_mut(index) - } - - /// 重建子节点缓存索引 - /// 当手动修改children向量时调用此方法重新建立索引 - fn rebuild_children_cache(&mut self) { - self.as_raw_mut().children_cache.clear(); - let mut elem = vec![]; - - for (index, child) in self.children().enumerate() { - elem.push((child.name().to_string(), index)); - } - - for (name, index) in elem { - self.as_raw_mut().children_cache.insert(name, index); + pub fn new(name: &str) -> Self { + Self { + name: name.to_string(), + properties: Vec::new(), + prop_cache: BTreeMap::new(), + children: Vec::new(), + name_cache: BTreeMap::new(), } } - /// 添加子节点 - fn add_child(&mut self, child: Node) -> &mut Self { - let child_name = child.name().to_string(); - let index = self.child_count(); - self.as_raw_mut().children.push(child); - self.as_raw_mut().children_cache.insert(child_name, index); - self - } - - /// 添加属性 - fn add_property(&mut self, prop: Property) -> &mut Self { - self.as_raw_mut().properties.push(prop); - self - } - - fn properties(&self) -> core::slice::Iter<'_, Property> { - self.as_raw().properties.iter() + pub fn name(&self) -> &str { + &self.name } - fn properties_mut(&mut self) -> core::slice::IterMut<'_, Property> { - self.as_raw_mut().properties.iter_mut() + pub fn properties(&self) -> impl Iterator { + self.properties.iter() } - /// 按名称查找属性 - fn find_property(&self, name: &str) -> Option<&Property> { - self.properties().find(|p| p.name() == name) + pub fn children(&self) -> impl Iterator { + self.children.iter() } - /// 按名称查找属性（可变） - fn find_property_mut(&mut self, name: &str) -> Option<&mut Property> { - self.properties_mut().find(|p| p.name() == name) + pub fn children_mut(&mut self) -> impl Iterator { + self.children.iter_mut() } - /// 移除属性 - fn remove_property(&mut self, name: &str) -> Option { - self.properties() - .position(|p| p.name() == name) - .map(|pos| self.as_raw_mut().properties.remove(pos)) + pub fn add_child(&mut self, child: Node) { + let index = self.children.len(); + self.name_cache.insert(child.name.clone(), index); + self.children.push(child); } - /// 移除子节点，支持 node-name@unit-address 格式 - /// - /// # 匹配规则 - /// - 精确匹配：如果名称包含 @，优先精确匹配完整名称 - /// - 部分匹配：如果精确匹配失败，尝试匹配节点名部分（忽略 @unit-address） - fn remove_child(&mut self, name: &str) -> Option { - // 首先尝试精确匹配（使用缓存） - if let Some(&index) = self.as_raw().children_cache.get(name) { - let child = self.as_raw_mut().children.remove(index); - self.as_raw_mut().children_cache.remove(name); - // 重建缓存，因为索引已经改变 - self.rebuild_children_cache(); - return Some(child); - } - - // 如果精确匹配失败，尝试部分匹配（忽略 @unit-address） - let name_base = name.split('@').next().unwrap_or(name); - - // 找到匹配的节点名称 - let matching_index = self.children().position(|child| { - let child_base = child.name().split('@').next().unwrap_or(child.name()); - child_base == name_base - }); - - if let Some(index) = matching_index { - let child = self.as_raw_mut().children.remove(index); - // 重建缓存，因为索引已经改变 - self.rebuild_children_cache(); - Some(child) + pub fn get_child(&self, name: &str) -> Option<&Node> { + if let Some(&index) = self.name_cache.get(name) { + self.children.get(index) } else { None } } - /// 精确匹配子节点，不支持部分匹配 - fn find_child_exact(&self, name: &str) -> Option<&Node> { - if let Some(&index) = self.as_raw().children_cache.get(name) { - self.as_raw().children.get(index) + pub fn get_child_mut(&mut self, name: &str) -> Option<&mut Node> { + if let Some(&index) = self.name_cache.get(name) { + self.children.get_mut(index) } else { None } } - /// 查找子节点（支持智能匹配，等同于 remove_child 的查找逻辑） - fn find_child(&self, name: &str) -> Option<&Node> { - // 首先尝试精确匹配（使用缓存） - if let Some(&index) = self.as_raw().children_cache.get(name) { - return self.as_raw().children.get(index); - } - - // 如果精确匹配失败，尝试部分匹配（忽略 @unit-address） - let name_base = name.split('@').next().unwrap_or(name); - - // 找到匹配的节点 - for child in self.children() { - let child_base = child.name().split('@').next().unwrap_or(child.name()); - if child_base == name_base { - return Some(child); - } - } - - None - } - - /// 精确匹配子节点（可变），不支持部分匹配 - fn find_child_exact_mut(&mut self, name: &str) -> Option<&mut Node> { - if let Some(&index) = self.as_raw().children_cache.get(name) { - self.as_raw_mut().children.get_mut(index) + pub fn remove_child(&mut self, name: &str) -> Option { + if let Some(&index) = self.name_cache.get(name) { + self.name_cache.remove(name); + Some(self.children.remove(index)) } else { None } } - /// 查找子节点（支持智能匹配，等同于 remove_child 的查找逻辑） - fn find_child_mut(&mut self, name: &str) -> Option<&mut Node> { - // 首先尝试精确匹配（使用缓存） - if let Some(&index) = self.as_raw().children_cache.get(name) { - return self.as_raw_mut().children.get_mut(index); - } - - // 如果精确匹配失败，尝试部分匹配（忽略 @unit-address） - let name_base = name.split('@').next().unwrap_or(name); - - // 找到匹配的节点 - for child in self.children_mut() { - let child_base = child.name().split('@').next().unwrap_or(child.name()); - if child_base == name_base { - return Some(child); - } + pub fn set_property(&mut self, prop: Property) { + let name = prop.name.clone(); + if let Some(&idx) = self.prop_cache.get(&name) { + // 更新已存在的属性 + self.properties[idx] = prop; + } else { + // 添加新属性 + let idx = self.properties.len(); + self.prop_cache.insert(name, idx); + self.properties.push(prop); } - - None } - /// 精确删除子节点，不支持部分匹配 - fn remove_child_exact(&mut self, name: &str) -> Option { - if let Some(&index) = self.as_raw_mut().children_cache.get(name) { - let child = self.as_raw_mut().children.remove(index); - self.as_raw_mut().children_cache.remove(name); - // 重建缓存，因为索引已经改变 - self.rebuild_children_cache(); - Some(child) - } else { - None - } + pub fn get_property(&self, name: &str) -> Option<&Property> { + self.prop_cache.get(name).map(|&idx| &self.properties[idx]) } - /// 获取所有子节点名称（按字典序排序） - fn child_names_sorted(&self) -> Vec<&str> { - let mut names = self - .children() - .map(|child| child.name()) - .collect::>(); - names.sort(); - names + pub fn get_property_mut(&mut self, name: &str) -> Option<&mut Property> { + self.prop_cache + .get(name) + .map(|&idx| &mut self.properties[idx]) } - /// 设置或更新属性 - fn set_property(&mut self, prop: Property) -> &mut Self { - let name = prop.name(); - if let Some(pos) = self.properties().position(|p| p.name() == name) { - self.as_raw_mut().properties[pos] = prop; + pub fn remove_property(&mut self, name: &str) -> Option { + if let Some(&idx) = self.prop_cache.get(name) { + self.prop_cache.remove(name); + // 重建索引（移除元素后需要更新后续索引） + let prop = self.properties.remove(idx); + for (_, v) in self.prop_cache.iter_mut() { + if *v > idx { + *v -= 1; + } + } + Some(prop) } else { - self.as_raw_mut().properties.push(prop); + None } - self } - /// 获取 #address-cells 值 - fn address_cells(&self) -> Option { - self.find_property("#address-cells").and_then(|p| match p { - Property::AddressCells(v) => Some(*v), - _ => None, - }) + pub fn address_cells(&self) -> Option { + self.get_property("#address-cells") + .and_then(|prop| prop.get_u32()) } - /// 获取 #size-cells 值 - fn size_cells(&self) -> Option { - self.find_property("#size-cells").and_then(|p| match p { - Property::SizeCells(v) => Some(*v), - _ => None, - }) - } - - /// 获取 phandle 值 - fn phandle(&self) -> Option { - self.find_property("phandle") - .and_then(|p| match p { - Property::Phandle(v) => Some(*v), - _ => None, - }) - .or_else(|| { - // 也检查 linux,phandle - self.find_property("linux,phandle").and_then(|p| match p { - Property::LinuxPhandle(v) => Some(*v), - _ => None, - }) - }) - } - - fn status(&self) -> Option { - for prop in self.properties() { - if let Property::Status(s) = prop { - return Some(*s); - } - } - None + pub fn size_cells(&self) -> Option { + self.get_property("#size-cells") + .and_then(|prop| prop.get_u32()) } - /// 根据路径查找节点 - /// 路径格式: "/node1@addr1/node2@addr2" 或 "node1@addr1/node2" - fn get_by_path(&self, path: &str) -> Option<&Node> { - // 标准化路径：去掉开头的斜杠，按斜杠分割 - let normalized_path = path.trim_start_matches('/'); - // if normalized_path.is_empty() { - // return Some(self); // 空路径或根路径返回当前节点 - // } - - let parts: Vec<&str> = normalized_path.split('/').collect(); - self.get_by_parts(&parts, 0) + pub fn phandle(&self) -> Option { + self.get_property("phandle") + .and_then(|prop| prop.get_u32()) + .map(Phandle::from) } - /// 递归查找实现（不可变引用） - fn get_by_parts(&self, parts: &[&str], index: usize) -> Option<&Node> { - // if index >= parts.len() { - // return Some(self); - // } - - let part = parts[index]; - - // 查找子节点（使用缓存） - let child = if let Some(&child_index) = self.as_raw().children_cache.get(part) { - self.as_raw().children.get(child_index)? - } else { - return None; - }; - - // 在子节点中查找匹配的节点 - child.get_by_parts(parts, index + 1) + pub fn interrupt_parent(&self) -> Option { + self.get_property("interrupt-parent") + .and_then(|prop| prop.get_u32()) + .map(Phandle::from) } - /// 根据路径查找节点（可变版本） - /// 路径格式: "/node1@addr1/node2@addr2" 或 "node1@addr1/node2" - fn get_by_path_mut(&mut self, path: &str) -> Option<&mut Node> { - // 标准化路径：去掉开头的斜杠，按斜杠分割 - let normalized_path = path.trim_start_matches('/'); - if normalized_path.is_empty() { - return None; + pub fn status(&self) -> Option { + let prop = self.get_property("status")?; + let s = prop.as_str()?; + match s { + "okay" => Some(Status::Okay), + "disabled" => Some(Status::Disabled), + _ => None, } - - let parts: Vec<&str> = normalized_path.split('/').collect(); - self.get_by_parts_mut(&parts, 0) } - /// 递归查找实现（可变引用） - fn get_by_parts_mut(&mut self, parts: &[&str], index: usize) -> Option<&mut Node> { - if index >= parts.len() { - return None; + pub fn ranges(&self, parent_address_cells: u32) -> Option> { + let prop = self.get_property("ranges")?; + let mut entries = Vec::new(); + let mut reader = prop.as_reader(); + + // 当前节点的 #address-cells 用于子节点地址 + let child_address_cells = self.address_cells().unwrap_or(2) as usize; + // 父节点的 #address-cells 用于父总线地址 + let parent_addr_cells = parent_address_cells as usize; + // 当前节点的 #size-cells + let size_cells = self.size_cells().unwrap_or(1) as usize; + + while let (Some(child_addr), Some(parent_addr), Some(size)) = ( + reader.read_cells(child_address_cells), + reader.read_cells(parent_addr_cells), + reader.read_cells(size_cells), + ) { + entries.push(RangesEntry { + child_bus_address: child_addr, + parent_bus_address: parent_addr, + length: size, + }); } - let part = parts[index]; - // 获取可变引用并继续递归（使用缓存） - let child = if let Some(&child_index) = self.as_raw().children_cache.get(part) { - // 安全地获取两个可变引用：一个指向当前向量元素，一个递归调用 - // 由于我们只访问一个子节点，所以是安全的 - self.as_raw_mut().children.get_mut(child_index)? - } else { - return None; - }; - child.get_by_parts_mut(parts, index + 1) + Some(entries) } - /// 根据路径查找所有匹配的节点 - /// 支持智能匹配，返回所有找到的节点及其完整路径 - /// - /// # 匹配规则 - /// - **中间级别**：只支持精确匹配 - /// - **最后级别**：支持精确匹配和前缀匹配 - /// - **前缀匹配**：在最后一级，节点名以指定前缀开头（忽略 @unit-address） - /// - /// # 参数 - /// - `path`: 查找路径，支持前缀匹配 - /// - /// # 返回值 - /// 返回 Vec<(&Node, String)>，包含所有匹配的节点及其完整路径 - /// - /// # 示例 - /// ```rust - /// # use fdt_edit::Node; - /// let mut node = Node::root(); - /// let nodes = node.find_all("gpio"); // 查找 gpio 或 gpio@xxx 等节点 - /// let nodes = node.find_all("soc/uart"); // 查找 soc/uart 或 soc/uart@1000 等节点 - /// ``` - fn find_all(&self, path: &str) -> Vec<(&Node, String)> { - let normalized_path = path.trim_start_matches('/'); - if normalized_path.is_empty() { - vec![] - } else { - let parts: Vec<&str> = normalized_path.split('/').collect(); - self.find_all_by_parts(&parts, 0, "/") - } + pub fn compatible(&self) -> Option> { + let prop = self.get_property("compatible")?; + Some(prop.as_str_iter()) } - /// 递归查找所有匹配节点的实现 - fn find_all_by_parts( - &self, - parts: &[&str], - index: usize, - current_path: &str, - ) -> Vec<(&Node, String)> { - if index >= parts.len() { - return vec![]; - } - - let part = parts[index]; - let is_last_level = index == parts.len() - 1; - let mut results = Vec::new(); - - // 普通匹配：支持精确匹配和最后一级的前缀匹配 - let matching_children = if is_last_level { - // 最后一级：支持精确匹配和前缀匹配 - self.find_children_with_prefix(part) - } else { - let mut matches = Vec::new(); - // 中间级别：只支持精确匹配（使用缓存） - if let Some(&child_index) = self.as_raw().children_cache.get(part) { - matches.push((part.to_string(), &self.as_raw().children[child_index])); - } - matches - }; - - for (child_name, child) in matching_children { - let child_path = format!("{}{}/", current_path, child_name); - - if is_last_level { - // 最后一级：添加匹配的子节点 - results.push((child, format!("{}{}", current_path, child_name))); - } else { - // 继续递归 - results.extend(child.find_all_by_parts(parts, index + 1, &child_path)); - } - } - - results + pub fn compatibles(&self) -> impl Iterator { + self.get_property("compatible") + .map(|prop| prop.as_str_iter()) + .into_iter() + .flatten() } - /// 支持前缀匹配的子节点查找（最后一级使用） - fn find_children_with_prefix(&self, prefix: &str) -> Vec<(String, &Node)> { - let mut matches = Vec::new(); - - // 找到所有匹配的节点并返回 - for child in self.children() { - if child.name().starts_with(prefix) { - matches.push((child.name().into(), child)); - } - } - - matches + pub fn device_type(&self) -> Option<&str> { + let prop = self.get_property("device_type")?; + prop.as_str() } /// 通过精确路径删除子节点及其子树 @@ -500,15 +231,18 @@ pub trait NodeOp: NodeTrait { /// # 示例 /// ```rust /// # use fdt_edit::Node; - /// let mut node = Node::root(); - /// // 精确删除节点 - /// let removed = node.remove_by_path("soc/gpio@1000")?; + /// let mut root = Node::new(""); + /// // 添加测试节点 + /// let mut soc = Node::new("soc"); + /// soc.add_child(Node::new("gpio@1000")); + /// root.add_child(soc); /// - /// // 精确删除嵌套节点 - /// let removed = node.remove_by_path("soc/i2c@0/eeprom@50")?; + /// // 精确删除节点 + /// let removed = root.remove_by_path("soc/gpio@1000")?; + /// assert!(removed.is_some()); /// # Ok::<(), fdt_raw::FdtError>(()) /// ``` - fn remove_by_path(&mut self, path: &str) -> Result, fdt_raw::FdtError> { + pub fn remove_by_path(&mut self, path: &str) -> Result, fdt_raw::FdtError> { let normalized_path = path.trim_start_matches('/'); if normalized_path.is_empty() { return Err(fdt_raw::FdtError::InvalidInput); @@ -545,48 +279,35 @@ pub trait NodeOp: NodeTrait { let current_part = parts[index]; // 中间级别只支持精确匹配（使用缓存） - if let Some(&child_index) = self.as_raw().children_cache.get(current_part) { - self.as_raw_mut().children[child_index].remove_child_recursive(parts, index + 1) + if let Some(&child_index) = self.name_cache.get(current_part) { + self.children[child_index].remove_child_recursive(parts, index + 1) } else { // 路径不存在 Ok(None) } } } -} -/// 可编辑的节点 -#[derive(Clone, Debug)] -pub struct RawNode { - pub name: String, - pub properties: Vec, - // 子节点列表，保持原始顺序 - pub children: Vec, - // 名称到索引的缓存映射，用于快速查找 - children_cache: BTreeMap, -} - -impl RawNode { - /// 创建新节点 - pub fn new(name: impl Into) -> Self { - Self { - name: name.into(), - properties: Vec::new(), - children: Vec::new(), - children_cache: BTreeMap::new(), + /// 精确删除子节点，不支持部分匹配 + fn remove_child_exact(&mut self, name: &str) -> Option { + if let Some(&index) = self.name_cache.get(name) { + let child = self.children.remove(index); + self.name_cache.remove(name); + Some(child) + } else { + None } } } -impl<'a> From> for Node { - fn from(raw_node: fdt_raw::Node<'a>) -> Self { - let mut node = RawNode::new(raw_node.name()); - - // 转换属性 - for prop in raw_node.properties() { - node.properties.push(Property::from(prop)); +impl From<&fdt_raw::Node<'_>> for Node { + fn from(raw: &fdt_raw::Node<'_>) -> Self { + let mut new_node = Node::new(raw.name()); + // 复制属性 + for raw_prop in raw.properties() { + let prop = Property::from(&raw_prop); + new_node.set_property(prop); } - - Self::new(node) + new_node } } diff --git a/fdt-edit/src/node/pci.rs b/fdt-edit/src/node/pci.rs index 8704ecf..f895896 100644 --- a/fdt-edit/src/node/pci.rs +++ b/fdt-edit/src/node/pci.rs @@ -1,26 +1,350 @@ -use crate::node::{NodeOp, NodeTrait, RawNode}; +use core::ops::{Deref, Range}; + +use alloc::vec::Vec; +use fdt_raw::{FdtError, Phandle, data::U32Iter}; +use log::debug; + +use crate::node::gerneric::NodeRefGen; + +#[derive(Clone, Debug, PartialEq)] +pub enum PciSpace { + IO, + Memory32, + Memory64, +} + +#[derive(Clone, Debug, PartialEq)] +pub struct PciRange { + pub space: PciSpace, + pub bus_address: u64, + pub cpu_address: u64, + pub size: u64, + pub prefetchable: bool, +} #[derive(Clone, Debug)] -pub struct NodePci(pub(crate) RawNode); +pub struct PciInterruptMap { + pub child_address: Vec, + pub child_irq: Vec, + pub interrupt_parent: Phandle, + pub parent_irq: Vec, +} + +#[derive(Clone, Debug, PartialEq)] +pub struct PciInterruptInfo { + pub irqs: Vec, +} + +#[derive(Clone, Debug)] +pub struct NodeRefPci<'a> { + pub node: NodeRefGen<'a>, +} + +impl<'a> NodeRefPci<'a> { + // 在这里添加 PCI 相关的方法 + pub fn try_from(node: NodeRefGen<'a>) -> Result> { + if node.device_type() == Some("pci") { + Ok(Self { node }) + } else { + Err(node) + } + } + + pub fn interrupt_cells(&self) -> u32 { + self.find_property("#interrupt-cells") + .and_then(|prop| prop.get_u32()) + .unwrap_or(1) // Default to 1 interrupt cell for PCI + } + + /// Get the interrupt-map-mask property if present + pub fn interrupt_map_mask(&self) -> Option> { + self.find_property("interrupt-map-mask") + .map(|prop| prop.get_u32_iter()) + } -impl NodeOp for NodePci {} + /// Get the bus range property if present + pub fn bus_range(&self) -> Option> { + self.find_property("bus-range").and_then(|prop| { + let mut data = prop.get_u32_iter(); + let start = data.next()?; + let end = data.next()?; -impl NodeTrait for NodePci { - fn as_raw(&self) -> &RawNode { - &self.0 + Some(start..end) + }) } - fn as_raw_mut(&mut self) -> &mut RawNode { - &mut self.0 + /// Get the ranges property for address translation + pub fn ranges(&self) -> Option> { + let prop = self.find_property("ranges")?; + + let mut data = prop.as_reader(); + + let mut ranges = Vec::new(); + + // PCI ranges format: + // child-bus-address: 3 cells (pci.hi pci.mid pci.lo) - PCI 地址固定 3 cells + // parent-bus-address: 使用父节点的 #address-cells + // size: 使用当前节点的 #size-cells + let parent_addr_cells = self.ctx.parent_address_cells() as usize; + let size_cells = self.size_cells().unwrap_or(2) as usize; + + while let Some(pci_hi) = data.read_u32() { + // Parse child bus address (3 cells for PCI: phys.hi, phys.mid, phys.lo) + let bus_address = data.read_u64()?; + + // Parse parent bus address (使用父节点的 #address-cells) + let parent_addr = data.read_cells(parent_addr_cells)?; + + // Parse size (使用当前节点的 #size-cells) + let size = data.read_cells(size_cells)?; + + // Extract PCI address space and prefetchable from child_addr[0] + let (space, prefetchable) = self.decode_pci_address_space(pci_hi); + + ranges.push(PciRange { + space, + bus_address, + cpu_address: parent_addr, + size, + prefetchable, + }); + } + + Some(ranges) } - fn to_raw(self) -> RawNode { - self.0 + /// Decode PCI address space from the high cell of PCI address + fn decode_pci_address_space(&self, pci_hi: u32) -> (PciSpace, bool) { + // PCI address high cell format: + // Bits 31-28: 1 for IO space, 2 for Memory32, 3 for Memory64 + // Bit 30: Prefetchable for memory spaces + let space_code = (pci_hi >> 24) & 0x03; + let prefetchable = (pci_hi >> 30) & 0x01 == 1; + + let space = match space_code { + 1 => PciSpace::IO, + 2 => PciSpace::Memory32, + 3 => PciSpace::Memory64, + _ => PciSpace::Memory32, // Default fallback + }; + + (space, prefetchable) + } + + /// 获取 PCI 设备的中断信息 + /// 参数: bus, device, function, pin (1=INTA, 2=INTB, 3=INTC, 4=INTD) + pub fn child_interrupts( + &self, + bus: u8, + device: u8, + function: u8, + interrupt_pin: u8, + ) -> Result { + // 获取 interrupt-map 和 mask + let interrupt_map = self.interrupt_map()?; + + // 将 mask 转换为 Vec 以便索引访问 + let mask: Vec = self + .interrupt_map_mask() + .ok_or(FdtError::NotFound)? + .collect(); + + // 构造 PCI 设备的子地址 + // 格式: [bus_num, device_num, func_num] 在适当的位 + let child_addr_high = ((bus as u32 & 0xff) << 16) + | ((device as u32 & 0x1f) << 11) + | ((function as u32 & 0x7) << 8); + let child_addr_mid = 0u32; + let child_addr_low = 0u32; + + let child_addr_cells = self.address_cells().unwrap_or(3) as usize; + let child_irq_cells = self.interrupt_cells() as usize; + + let encoded_address = [child_addr_high, child_addr_mid, child_addr_low]; + let mut masked_child_address = Vec::with_capacity(child_addr_cells); + + // 应用 mask 到子地址 + for (idx, value) in encoded_address.iter().take(child_addr_cells).enumerate() { + let mask_value = mask.get(idx).copied().unwrap_or(0xffff_ffff); + masked_child_address.push(value & mask_value); + } + + // 如果 encoded_address 比 child_addr_cells 短，填充 0 + let remaining = child_addr_cells.saturating_sub(encoded_address.len()); + masked_child_address.extend(core::iter::repeat_n(0, remaining)); + + let encoded_irq = [interrupt_pin as u32]; + let mut masked_child_irq = Vec::with_capacity(child_irq_cells); + + // 应用 mask 到子 IRQ + for (idx, value) in encoded_irq.iter().take(child_irq_cells).enumerate() { + let mask_value = mask + .get(child_addr_cells + idx) + .copied() + .unwrap_or(0xffff_ffff); + masked_child_irq.push(value & mask_value); + } + + // 如果 encoded_irq 比 child_irq_cells 短，填充 0 + let remaining_irq = child_irq_cells.saturating_sub(encoded_irq.len()); + masked_child_irq.extend(core::iter::repeat_n(0, remaining_irq)); + + // 在 interrupt-map 中查找匹配的条目 + for mapping in &interrupt_map { + if mapping.child_address == masked_child_address + && mapping.child_irq == masked_child_irq + { + return Ok(PciInterruptInfo { + irqs: mapping.parent_irq.clone(), + }); + } + } + + // 回退到简单的 IRQ 计算 + let simple_irq = (device as u32 * 4 + interrupt_pin as u32) % 32; + Ok(PciInterruptInfo { + irqs: vec![simple_irq], + }) + } + + /// 解析 interrupt-map 属性 + pub fn interrupt_map(&self) -> Result, FdtError> { + let prop = self + .find_property("interrupt-map") + .ok_or(FdtError::NotFound)?; + + // 将 mask 和 data 转换为 Vec 以便索引访问 + let mask: Vec = self + .interrupt_map_mask() + .ok_or(FdtError::NotFound)? + .collect(); + + let mut data = prop.as_reader(); + let mut mappings = Vec::new(); + + // 计算每个条目的大小 + // 格式: + let child_addr_cells = self.address_cells().unwrap_or(3) as usize; + let child_irq_cells = self.interrupt_cells() as usize; + + loop { + // 解析子地址 + let mut child_address = Vec::with_capacity(child_addr_cells); + for _ in 0..child_addr_cells { + match data.read_u32() { + Some(v) => child_address.push(v), + None => return Ok(mappings), // 数据结束 + } + } + + // 解析子 IRQ + let mut child_irq = Vec::with_capacity(child_irq_cells); + for _ in 0..child_irq_cells { + match data.read_u32() { + Some(v) => child_irq.push(v), + None => return Ok(mappings), + } + } + + // 解析中断父 phandle + let interrupt_parent_raw = match data.read_u32() { + Some(v) => v, + None => return Ok(mappings), + }; + let interrupt_parent = Phandle::from(interrupt_parent_raw); + + debug!( + "Looking for interrupt parent phandle: 0x{:x} (raw: {})", + interrupt_parent.raw(), + interrupt_parent_raw + ); + debug!( + "Context phandle_map keys: {:?}", + self.ctx + .phandle_map + .keys() + .map(|p| format!("0x{:x}", p.raw())) + .collect::>() + ); + + // 通过 phandle 查找中断父节点以获取其 #address-cells 和 #interrupt-cells + // 根据 devicetree 规范，interrupt-map 中的 parent unit address 使用中断父节点的 #address-cells + let (parent_addr_cells, parent_irq_cells) = + if let Some(irq_parent) = self.ctx.find_by_phandle(interrupt_parent) { + debug!("Found interrupt parent: {:?}", irq_parent.name); + + // 直接使用中断父节点的 #address-cells + let addr_cells = irq_parent.address_cells().unwrap_or(0) as usize; + + let irq_cells = irq_parent + .get_property("#interrupt-cells") + .and_then(|p| p.get_u32()) + .unwrap_or(3) as usize; + debug!( + "irq_parent addr_cells: {}, irq_cells: {}", + addr_cells, irq_cells + ); + (addr_cells, irq_cells) + } else { + debug!( + "Interrupt parent phandle 0x{:x} NOT FOUND in context!", + interrupt_parent.raw() + ); + // 默认值：address_cells=0, interrupt_cells=3 (GIC 格式) + (0, 3) + }; + + // 跳过父地址 cells + for _ in 0..parent_addr_cells { + if data.read_u32().is_none() { + return Ok(mappings); + } + } + + // 解析父 IRQ + let mut parent_irq = Vec::with_capacity(parent_irq_cells); + for _ in 0..parent_irq_cells { + match data.read_u32() { + Some(v) => parent_irq.push(v), + None => return Ok(mappings), + } + } + + // 应用 mask 到子地址和 IRQ + let masked_address: Vec = child_address + .iter() + .enumerate() + .map(|(i, value)| { + let mask_value = mask.get(i).copied().unwrap_or(0xffff_ffff); + value & mask_value + }) + .collect(); + let masked_irq: Vec = child_irq + .iter() + .enumerate() + .map(|(i, value)| { + let mask_value = mask + .get(child_addr_cells + i) + .copied() + .unwrap_or(0xffff_ffff); + value & mask_value + }) + .collect(); + + mappings.push(PciInterruptMap { + child_address: masked_address, + child_irq: masked_irq, + interrupt_parent, + parent_irq, + }); + } } } -impl NodePci { - pub fn new(name: &str) -> Self { - NodePci(RawNode::new(name)) +impl<'a> Deref for NodeRefPci<'a> { + type Target = NodeRefGen<'a>; + + fn deref(&self) -> &Self::Target { + &self.node } } diff --git a/fdt-edit/src/prop/mod.rs b/fdt-edit/src/prop/mod.rs index 92879dc..b361c5b 100644 --- a/fdt-edit/src/prop/mod.rs +++ b/fdt-edit/src/prop/mod.rs @@ -1,442 +1,120 @@ -use alloc::{string::String, vec::Vec}; +use core::ffi::CStr; +use alloc::{ + string::{String, ToString}, + vec::Vec, +}; + +use fdt_raw::data::{Bytes, Reader, StrIter, U32Iter}; // Re-export from fdt_raw pub use fdt_raw::{Phandle, RegInfo, Status}; -use crate::{Node, NodeOp}; - -/// Ranges 条目信息 -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub struct RangesEntry { - /// 子总线地址 - pub child_bus_address: u64, - /// 父总线地址 - pub parent_bus_address: u64, - /// 区域长度 - pub length: u64, +#[derive(Clone)] +pub struct Property { + pub name: String, + pub data: Vec, } -impl RangesEntry { - /// 创建新的 RangesEntry - pub fn new(child_bus_address: u64, parent_bus_address: u64, length: u64) -> Self { - Self { - child_bus_address, - parent_bus_address, - length, - } - } -} - -/// 原始属性（未识别的通用属性） -#[derive(Clone, Debug)] -pub struct RawProperty { - name: String, - data: Vec, -} - -impl RawProperty { - /// 创建新的原始属性 - pub fn new(name: impl Into, data: Vec) -> Self { +impl Property { + pub fn new(name: &str, data: Vec) -> Self { Self { - name: name.into(), + name: name.to_string(), data, } } - /// 创建空属性 - pub fn empty(name: impl Into) -> Self { - Self::new(name, Vec::new()) - } - - /// 创建 u32 属性 - pub fn from_u32(name: impl Into, value: u32) -> Self { - Self::new(name, value.to_be_bytes().to_vec()) - } - - /// 创建 u64 属性 - pub fn from_u64(name: impl Into, value: u64) -> Self { - Self::new(name, value.to_be_bytes().to_vec()) - } - - /// 创建字符串属性 - pub fn from_string(name: impl Into, value: &str) -> Self { - let mut data = value.as_bytes().to_vec(); - data.push(0); - Self::new(name, data) - } - - /// 创建字符串列表属性 - pub fn from_string_list(name: impl Into, values: &[&str]) -> Self { - let mut data = Vec::new(); - for s in values { - data.extend_from_slice(s.as_bytes()); - data.push(0); - } - Self::new(name, data) - } - - /// 获取属性名称 pub fn name(&self) -> &str { &self.name } - /// 获取属性数据 - pub fn data(&self) -> &[u8] { - &self.data - } - - /// 获取可变属性数据 - pub fn data_mut(&mut self) -> &mut Vec { - &mut self.data - } - - /// 属性数据是否为空 - pub fn is_empty(&self) -> bool { - self.data.is_empty() - } - - /// 属性数据长度 - pub fn len(&self) -> usize { - self.data.len() - } -} - -/// 可编辑的属性（类型化枚举） -#[derive(Clone, Debug)] -pub enum Property { - /// #address-cells 属性 - AddressCells(u8), - /// #size-cells 属性 - SizeCells(u8), - /// #interrupt-cells 属性 - InterruptCells(u8), - /// reg 属性（已解析） - Reg(Vec), - /// ranges 属性（空表示 1:1 映射） - Ranges { - entries: Vec, - child_address_cells: u8, - parent_address_cells: u8, - size_cells: u8, - }, - /// compatible 属性（字符串列表） - Compatible(Vec), - /// model 属性 - Model(String), - /// status 属性 - Status(Status), - /// phandle 属性 - Phandle(Phandle), - /// linux,phandle 属性 - LinuxPhandle(Phandle), - /// device_type 属性 - DeviceType(String), - /// interrupt-parent 属性 - InterruptParent(Phandle), - /// clock-names 属性 - ClockNames(Vec), - /// dma-coherent 属性（无数据） - DmaCoherent, - /// 原始属性（未识别的通用属性） - Raw(RawProperty), -} - -impl Property { - /// 获取属性名称 - pub fn name(&self) -> &str { - match self { - Property::AddressCells(_) => "#address-cells", - Property::SizeCells(_) => "#size-cells", - Property::InterruptCells(_) => "#interrupt-cells", - Property::Reg { .. } => "reg", - Property::Ranges { .. } => "ranges", - Property::Compatible(_) => "compatible", - Property::Model(_) => "model", - Property::Status(_) => "status", - Property::Phandle(_) => "phandle", - Property::LinuxPhandle(_) => "linux,phandle", - Property::DeviceType(_) => "device_type", - Property::InterruptParent(_) => "interrupt-parent", - Property::ClockNames(_) => "clock-names", - Property::DmaCoherent => "dma-coherent", - Property::Raw(raw) => raw.name(), + pub fn get_u32(&self) -> Option { + if self.data.len() != 4 { + return None; } - } - - /// 将属性序列化为二进制数据 - pub fn to_bytes(&self, node: &Node) -> Vec { - let address_cells = node.address_cells().unwrap_or(2); - let size_cells = node.size_cells().unwrap_or(1); - self.to_bytes_with_cells(node, address_cells, size_cells) - } - - /// 将属性序列化为二进制数据，使用指定的父节点 address_cells 和 size_cells - pub fn to_bytes_with_cells( - &self, - _node: &Node, - parent_address_cells: u8, - parent_size_cells: u8, - ) -> Vec { - match self { - Property::AddressCells(v) => (*v as u32).to_be_bytes().to_vec(), - Property::SizeCells(v) => (*v as u32).to_be_bytes().to_vec(), - Property::InterruptCells(v) => (*v as u32).to_be_bytes().to_vec(), - Property::Reg(entries) => { - let mut data = Vec::new(); - for entry in entries { - write_cells(&mut data, entry.address, parent_address_cells); - if let Some(size) = entry.size { - write_cells(&mut data, size, parent_size_cells); - } - } - data - } - Property::Ranges { - entries, - child_address_cells, - parent_address_cells, - size_cells, - } => { - let mut data = Vec::new(); - for entry in entries { - write_cells(&mut data, entry.child_bus_address, *child_address_cells); - write_cells(&mut data, entry.parent_bus_address, *parent_address_cells); - write_cells(&mut data, entry.length, *size_cells); - } - data - } - Property::Compatible(strs) => { - let mut data = Vec::new(); - for s in strs { - data.extend_from_slice(s.as_bytes()); - data.push(0); - } - data - } - Property::Model(s) => { - let mut data = s.as_bytes().to_vec(); - data.push(0); - data - } - Property::Status(status) => { - let s = match status { - Status::Okay => "okay", - Status::Disabled => "disabled", - }; - let mut data = s.as_bytes().to_vec(); - data.push(0); - data - } - Property::Phandle(v) => (v.as_usize() as u32).to_be_bytes().to_vec(), - Property::LinuxPhandle(v) => (v.as_usize() as u32).to_be_bytes().to_vec(), - Property::DeviceType(s) => { - let mut data = s.as_bytes().to_vec(); - data.push(0); - data - } - Property::InterruptParent(v) => (v.as_usize() as u32).to_be_bytes().to_vec(), - Property::ClockNames(strs) => { - let mut data = Vec::new(); - for s in strs { - data.extend_from_slice(s.as_bytes()); - data.push(0); - } - data - } - Property::DmaCoherent => Vec::new(), - Property::Raw(raw) => raw.data().to_vec(), + Some(u32::from_be_bytes([ + self.data[0], + self.data[1], + self.data[2], + self.data[3], + ])) + } + + pub fn set_u32_ls(&mut self, values: &[u32]) { + self.data.clear(); + for &value in values { + self.data.extend_from_slice(&value.to_be_bytes()); } } - /// 属性数据是否为空 - pub fn is_empty(&self) -> bool { - match self { - Property::DmaCoherent => true, - Property::Ranges { entries, .. } => entries.is_empty(), - Property::Raw(raw) => raw.is_empty(), - _ => false, - } + pub fn get_u32_iter(&self) -> U32Iter<'_> { + Bytes::new(&self.data).as_u32_iter() } - // ========== 构造器方法 ========== - - /// 创建 #address-cells 属性 - pub fn address_cells(value: u8) -> Self { - Property::AddressCells(value) - } - - /// 创建 #size-cells 属性 - pub fn size_cells(value: u8) -> Self { - Property::SizeCells(value) - } - - /// 创建 #interrupt-cells 属性 - pub fn interrupt_cells(value: u8) -> Self { - Property::InterruptCells(value) - } - - /// 创建 reg 属性 - pub fn reg(entries: Vec) -> Self { - Property::Reg(entries) - } - - /// 创建 ranges 属性（空表示 1:1 映射） - pub fn ranges_empty(child_address_cells: u8, parent_address_cells: u8, size_cells: u8) -> Self { - Property::Ranges { - entries: Vec::new(), - child_address_cells, - parent_address_cells, - size_cells, - } - } - - /// 创建 ranges 属性 - pub fn ranges( - entries: Vec, - child_address_cells: u8, - parent_address_cells: u8, - size_cells: u8, - ) -> Self { - Property::Ranges { - entries, - child_address_cells, - parent_address_cells, - size_cells, + pub fn get_u64(&self) -> Option { + if self.data.len() != 8 { + return None; } + Some(u64::from_be_bytes([ + self.data[0], + self.data[1], + self.data[2], + self.data[3], + self.data[4], + self.data[5], + self.data[6], + self.data[7], + ])) } - /// 创建 compatible 属性 - pub fn compatible(values: Vec) -> Self { - Property::Compatible(values) - } - - /// 从字符串切片创建 compatible 属性 - pub fn compatible_from_strs(values: &[&str]) -> Self { - Property::Compatible(values.iter().map(|s| String::from(*s)).collect()) - } - - /// 创建 model 属性 - pub fn model(value: impl Into) -> Self { - Property::Model(value.into()) - } - - /// 创建 status 属性 - pub fn status(status: Status) -> Self { - Property::Status(status) - } - - /// 创建 status = "okay" 属性 - pub fn status_okay() -> Self { - Property::Status(Status::Okay) - } - - /// 创建 status = "disabled" 属性 - pub fn status_disabled() -> Self { - Property::Status(Status::Disabled) - } - - /// 创建 phandle 属性 - pub fn phandle(value: u32) -> Self { - Property::Phandle(Phandle::from(value)) - } - - /// 创建 linux,phandle 属性 - pub fn linux_phandle(value: u32) -> Self { - Property::LinuxPhandle(Phandle::from(value)) - } - - /// 创建 device_type 属性 - pub fn device_type(value: impl Into) -> Self { - Property::DeviceType(value.into()) - } - - /// 创建 interrupt-parent 属性 - pub fn interrupt_parent(phandle: u32) -> Self { - Property::InterruptParent(Phandle::from(phandle)) - } - - /// 创建 clock-names 属性 - pub fn clock_names(values: Vec) -> Self { - Property::ClockNames(values) - } - - /// 创建 dma-coherent 属性 - pub fn dma_coherent() -> Self { - Property::DmaCoherent + pub fn set_u64(&mut self, value: u64) { + self.data = value.to_be_bytes().to_vec(); } - /// 创建原始属性（通用属性） - pub fn raw(name: impl Into, data: Vec) -> Self { - Property::Raw(RawProperty::new(name, data)) + pub fn as_str(&self) -> Option<&str> { + CStr::from_bytes_with_nul(&self.data) + .ok() + .and_then(|cstr| cstr.to_str().ok()) } - /// 创建 u32 原始属性 - pub fn raw_u32(name: impl Into, value: u32) -> Self { - Property::Raw(RawProperty::from_u32(name, value)) + pub fn set_string(&mut self, value: &str) { + let mut bytes = value.as_bytes().to_vec(); + bytes.push(0); // Null-terminate + self.data = bytes; } - /// 创建 u64 原始属性 - pub fn raw_u64(name: impl Into, value: u64) -> Self { - Property::Raw(RawProperty::from_u64(name, value)) + pub fn as_str_iter(&self) -> StrIter<'_> { + Bytes::new(&self.data).as_str_iter() } - /// 创建字符串原始属性 - pub fn raw_string(name: impl Into, value: &str) -> Self { - Property::Raw(RawProperty::from_string(name, value)) - } - - /// 创建字符串列表原始属性 - pub fn raw_string_list(name: impl Into, values: &[&str]) -> Self { - Property::Raw(RawProperty::from_string_list(name, values)) + pub fn set_string_ls(&mut self, values: &[&str]) { + self.data.clear(); + for &value in values { + self.data.extend_from_slice(value.as_bytes()); + self.data.push(0); // Null-terminate each string + } } - /// 创建空原始属性 - pub fn raw_empty(name: impl Into) -> Self { - Property::Raw(RawProperty::empty(name)) + pub fn as_reader(&self) -> Reader<'_> { + Bytes::new(&self.data).reader() } } -/// 根据 cells 数量写入值 -fn write_cells(data: &mut Vec, value: u64, cells: u8) { - match cells { - 0 => {} - 1 => data.extend_from_slice(&(value as u32).to_be_bytes()), - 2 => data.extend_from_slice(&value.to_be_bytes()), - _ => { - // 超过 2 cells，先填充 0，再写入 64 位值 - for _ in 0..(cells as usize - 2) { - data.extend_from_slice(&0u32.to_be_bytes()); - } - data.extend_from_slice(&value.to_be_bytes()); +impl From<&fdt_raw::Property<'_>> for Property { + fn from(value: &fdt_raw::Property<'_>) -> Self { + Self { + name: value.name().to_string(), + data: value.as_slice().to_vec(), } } } -impl<'a> From> for Property { - fn from(prop: fdt_raw::Property<'a>) -> Self { - match prop { - fdt_raw::Property::AddressCells(v) => Property::AddressCells(v), - fdt_raw::Property::SizeCells(v) => Property::SizeCells(v), - fdt_raw::Property::InterruptCells(v) => Property::InterruptCells(v), - fdt_raw::Property::Reg(reg) => Property::Reg(reg.iter().collect()), - fdt_raw::Property::Compatible(iter) => { - let strs: Vec = iter.map(String::from).collect(); - Property::Compatible(strs) - } - fdt_raw::Property::Model(s) => Property::Model(String::from(s)), - fdt_raw::Property::Status(status) => Property::Status(status), - fdt_raw::Property::Phandle(p) => Property::Phandle(p), - fdt_raw::Property::LinuxPhandle(p) => Property::LinuxPhandle(p), - fdt_raw::Property::DeviceType(s) => Property::DeviceType(String::from(s)), - fdt_raw::Property::InterruptParent(p) => Property::InterruptParent(p), - fdt_raw::Property::ClockNames(iter) => { - let strs: Vec = iter.map(String::from).collect(); - Property::ClockNames(strs) - } - fdt_raw::Property::DmaCoherent => Property::DmaCoherent, - fdt_raw::Property::Unknown(raw) => { - Property::Raw(RawProperty::new(raw.name(), raw.data().to_vec())) - } - } - } +/// Ranges 条目信息 +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct RangesEntry { + /// 子总线地址 + pub child_bus_address: u64, + /// 父总线地址 + pub parent_bus_address: u64, + /// 区域长度 + pub length: u64, } diff --git a/fdt-edit/tests/all_nodes.rs b/fdt-edit/tests/all_nodes.rs deleted file mode 100644 index 55a8373..0000000 --- a/fdt-edit/tests/all_nodes.rs +++ /dev/null @@ -1,190 +0,0 @@ -#![no_std] - -extern crate alloc; - -#[cfg(test)] -mod tests { - use alloc::{string::ToString, vec}; - use fdt_edit::{Fdt, Node, Property, RegInfo}; - - #[test] - fn test_all_nodes_empty() { - let fdt = Fdt::new(); - let nodes = fdt.all_nodes(); - - // 空的 FDT 应该只有一个根节点 - assert_eq!(nodes.len(), 1); - assert_eq!(nodes[0].name, ""); // 根节点名为空 - } - - #[test] - fn test_all_nodes_simple() { - let mut fdt = Fdt::new(); - - // 添加一个子节点 - let mut child = Node::new("test-node"); - child.add_property(Property::compatible(vec!["test-compatible".to_string()])); - - fdt.root.add_child(child); - - let nodes = fdt.all_nodes(); - - // 应该有根节点和一个子节点 - assert_eq!(nodes.len(), 2); - assert_eq!(nodes[0].name, ""); // 根节点 - assert_eq!(nodes[1].name, "test-node"); // 子节点 - } - - #[test] - fn test_all_nodes_multiple_children() { - let mut fdt = Fdt::new(); - - // 添加多个子节点 - let mut node1 = Node::new("node1"); - node1.add_property(Property::reg(vec![RegInfo::new(0x1000, Some(0x100))])); - - let mut node2 = Node::new("node2"); - node2.add_property(Property::compatible(vec!["test-device".to_string()])); - - let mut node3 = Node::new("node3"); - - fdt.root.add_child(node1); - fdt.root.add_child(node2); - fdt.root.add_child(node3); - - let nodes = fdt.all_nodes(); - - // 应该有根节点和三个子节点 - assert_eq!(nodes.len(), 4); - assert_eq!(nodes[0].name, ""); // 根节点 - assert_eq!(nodes[1].name, "node1"); - assert_eq!(nodes[2].name, "node2"); - assert_eq!(nodes[3].name, "node3"); - } - - #[test] - fn test_all_nodes_nested() { - let mut fdt = Fdt::new(); - - // 创建嵌套结构：root -> soc -> uart -> clock - let mut uart = Node::new("uart"); - uart.add_property(Property::reg(vec![RegInfo::new(0x9000000, Some(0x1000))])); - - let mut clock = Node::new("clock"); - clock.add_property(Property::compatible(vec!["fixed-clock".to_string()])); - - uart.add_child(clock); - - let mut soc = Node::new("soc"); - soc.add_property(Property::compatible(vec!["simple-bus".to_string()])); - soc.add_child(uart); - - fdt.root.add_child(soc); - - let nodes = fdt.all_nodes(); - - // 应该有根节点 -> soc -> uart -> clock，共4个节点 - assert_eq!(nodes.len(), 4); - assert_eq!(nodes[0].name, ""); // 根节点 - assert_eq!(nodes[1].name, "soc"); // 第一级子节点 - assert_eq!(nodes[2].name, "uart"); // 第二级子节点 - assert_eq!(nodes[3].name, "clock"); // 第三级子节点 - } - - #[test] - fn test_all_nodes_complex_hierarchy() { - let mut fdt = Fdt::new(); - - // 构建复杂层次结构： - // root - // ├── soc - // │ ├── uart0 - // │ └── uart1 - // └── memory - - let mut uart0 = Node::new("uart0"); - uart0.add_property(Property::reg(vec![RegInfo::new(0x9000000, Some(0x1000))])); - - let mut uart1 = Node::new("uart1"); - uart1.add_property(Property::reg(vec![RegInfo::new(0x9001000, Some(0x1000))])); - - let mut soc = Node::new("soc"); - soc.add_property(Property::compatible(vec!["simple-bus".to_string()])); - soc.add_child(uart0); - soc.add_child(uart1); - - let mut memory = Node::new("memory"); - memory.add_property(Property::reg(vec![RegInfo::new( - 0x40000000, - Some(0x10000000), - )])); - - fdt.root.add_child(soc); - fdt.root.add_child(memory); - - let nodes = fdt.all_nodes(); - - // 应该有根节点 + soc + uart0 + uart1 + memory，共5个节点 - // 深度优先遍历：根节点 -> soc -> uart0 -> uart1 -> memory - assert_eq!(nodes.len(), 5); - assert_eq!(nodes[0].name, ""); // 根节点 - assert_eq!(nodes[1].name, "soc"); // 第一级子节点1（按插入顺序，深度优先遍历） - assert_eq!(nodes[2].name, "uart0"); // soc的子节点1 - assert_eq!(nodes[3].name, "uart1"); // soc的子节点2 - assert_eq!(nodes[4].name, "memory"); // 第一级子节点2（按插入顺序，在soc的子树处理完后） - } - - #[test] - fn test_all_nodes_depth_first_order() { - let mut fdt = Fdt::new(); - - // 构建测试结构以验证深度优先遍历顺序 - let mut child1 = Node::new("child1"); - let mut grandchild1 = Node::new("grandchild1"); - child1.add_child(grandchild1); - - let mut child2 = Node::new("child2"); - let mut grandchild2 = Node::new("grandchild2"); - child2.add_child(grandchild2); - - fdt.root.add_child(child1); - fdt.root.add_child(child2); - - let nodes = fdt.all_nodes(); - - // 验证深度优先遍历顺序 - assert_eq!(nodes.len(), 5); - assert_eq!(nodes[0].name, ""); // 根节点 - assert_eq!(nodes[1].name, "child1"); // 第一个子节点 - assert_eq!(nodes[2].name, "grandchild1"); // child1的子节点 - assert_eq!(nodes[3].name, "child2"); // 第二个子节点 - assert_eq!(nodes[4].name, "grandchild2"); // child2的子节点 - } - - #[test] - fn test_all_nodes_with_properties() { - let mut fdt = Fdt::new(); - - // 根节点添加属性 - fdt.root.add_property(Property::AddressCells(1)); - fdt.root.add_property(Property::SizeCells(1)); - - // 子节点添加属性 - let mut test_node = Node::new("test"); - test_node.add_property(Property::compatible(vec!["test-compatible".to_string()])); - test_node.add_property(Property::reg(vec![RegInfo::new(0x2000, Some(0x1000))])); - - fdt.root.add_child(test_node); - - let nodes = fdt.all_nodes(); - - // 验证节点数量 - assert_eq!(nodes.len(), 2); - - // 验证根节点属性 - assert_eq!(nodes[0].properties.len(), 2); // address-cells, size-cells - - // 验证子节点属性 - assert_eq!(nodes[1].properties.len(), 2); // compatible, reg - } -} diff --git a/fdt-edit/tests/builder_cells.rs b/fdt-edit/tests/builder_cells.rs deleted file mode 100644 index 507729b..0000000 --- a/fdt-edit/tests/builder_cells.rs +++ /dev/null @@ -1,104 +0,0 @@ -#![no_std] - -extern crate alloc; - -#[cfg(test)] -mod tests { - use alloc::{string::ToString, vec}; - use fdt_edit::{Fdt, Node, Property, RegInfo}; - - #[test] - fn test_builder_with_different_cells() { - let mut fdt = Fdt::new(); - - // 根节点使用 2 cells for address, 1 for size - fdt.root.add_property(Property::AddressCells(2)); - fdt.root.add_property(Property::SizeCells(1)); - - // 验证 FDT 构建成功，没有 panic - let fdt_data = fdt.to_bytes(); - - // 确保数据不为空 - assert!(!fdt_data.is_empty()); - assert!(fdt_data.len() > 100); // 应该有基本的 FDT 结构 - } - - #[test] - fn test_builder_with_size_cells_zero() { - let mut fdt = Fdt::new(); - - // 根节点使用 1 cell for address, 0 for size - fdt.root.add_property(Property::AddressCells(1)); - fdt.root.add_property(Property::SizeCells(0)); - - // 当 size-cells = 0 时，reg 只有地址，没有大小 - fdt.root - .add_property(Property::reg(vec![RegInfo::new(0x1000, None)])); - - // 验证 FDT 构建成功，没有 panic - let fdt_data = fdt.to_bytes(); - - // 确保数据不为空 - assert!(!fdt_data.is_empty()); - } - - #[test] - fn test_nested_cells_inheritance() { - let mut fdt = Fdt::new(); - - // 根节点: address-cells = 2, size-cells = 1 - fdt.root.add_property(Property::AddressCells(2)); - fdt.root.add_property(Property::SizeCells(1)); - - // 中间节点: address-cells = 1, size-cells = 1 - let mut bus = Node::new("bus"); - bus.add_property(Property::AddressCells(1)); - bus.add_property(Property::SizeCells(1)); - - // 设备节点: 继承父节点的 1 cell address, 1 cell size - let mut device = Node::new("device"); - device.add_property(Property::reg(vec![RegInfo::new(0x2000, Some(0x100))])); - - bus.add_child(device); - fdt.root.add_child(bus); - - // 验证 FDT 构建成功，没有 panic - let fdt_data = fdt.to_bytes(); - - // 确保数据不为空，应该比简单测试更大 - assert!(!fdt_data.is_empty()); - assert!(fdt_data.len() > 200); - } - - #[test] - fn test_complex_hierarchy_with_cells() { - let mut fdt = Fdt::new(); - - // 根节点: address-cells = 2, size-cells = 2 - fdt.root.add_property(Property::AddressCells(2)); - fdt.root.add_property(Property::SizeCells(2)); - - // 中间节点: address-cells = 1, size-cells = 1 - let mut soc = Node::new("soc"); - soc.add_property(Property::AddressCells(1)); - soc.add_property(Property::SizeCells(1)); - soc.add_property(Property::reg(vec![RegInfo::new( - 0x40000000, - Some(0x100000), - )])); - - // 设备节点: 使用父节点的 1 cell address, 1 cell size - let mut uart = Node::new("uart"); - uart.add_property(Property::reg(vec![RegInfo::new(0x9000000, Some(0x1000))])); - - soc.add_child(uart); - fdt.root.add_child(soc); - - // 验证复杂层级结构的 FDT 构建成功 - let fdt_data = fdt.to_bytes(); - - // 确保数据不为空，应该比简单测试更大 - assert!(!fdt_data.is_empty()); - assert!(fdt_data.len() > 150); // 调整期望值 - } -} diff --git a/fdt-edit/tests/cells_scope.rs b/fdt-edit/tests/cells_scope.rs deleted file mode 100644 index 4deacf1..0000000 --- a/fdt-edit/tests/cells_scope.rs +++ /dev/null @@ -1,104 +0,0 @@ -#![no_std] - -extern crate alloc; - -#[cfg(test)] -mod tests { - use alloc::vec; - use fdt_edit::{Fdt, Node, Property, RegInfo}; - - #[test] - fn test_address_cells_scope_only_affects_children() { - let mut fdt = Fdt::new(); - - // 根节点: address-cells = 2, size-cells = 2 - // 这会影响根节点的直接子节点 - fdt.root.add_property(Property::AddressCells(2)); - fdt.root.add_property(Property::SizeCells(2)); - - // SoC 节点: 作为根节点的子节点，应该使用父节点的 2+2 cells - let mut soc = Node::new("soc"); - soc.add_property(Property::reg(vec![ - RegInfo::new(0x40000000, Some(0x100000)), // 地址用2个cell，大小用2个cell - ])); - - // SoC 节点: address-cells = 1, size-cells = 1 - // 这会影响 SoC 的子节点（如 uart） - soc.add_property(Property::AddressCells(1)); - soc.add_property(Property::SizeCells(1)); - - // UART 节点: 作为 SoC 的子节点，应该使用 SoC 的 1+1 cells - let mut uart = Node::new("uart"); - uart.add_property(Property::reg(vec![ - RegInfo::new(0x9000000, Some(0x1000)), // 地址用1个cell，大小用1个cell - ])); - - soc.add_child(uart); - fdt.root.add_child(soc); - - // 验证 FDT 构建成功，没有 panic - let fdt_data = fdt.to_bytes(); - - // 确保数据不为空 - assert!(!fdt_data.is_empty()); - - // 这个测试证明了 address_cells 和 size_cells 只影响直接子节点 - // - 根节点的 2+2 cells影响了 SoC 节点的 reg 属性格式 - // - SoC 节点的 1+1 cells影响了 UART 节点的 reg 属性格式 - - // 测试通过：address_cells 和 size_cells 作用范围正确 - // 根节点设置 2+2 cells 影响了 SoC 节点 - // SoC 节点设置 1+1 cells 影响了 UART 节点 - } - - #[test] - fn test_cells_inheritance_chain() { - let mut fdt = Fdt::new(); - - // 第一层: 根节点 2+2 cells - fdt.root.add_property(Property::AddressCells(2)); - fdt.root.add_property(Property::SizeCells(2)); - - // 第二层: 中间节点 1+1 cells - let mut middle = Node::new("middle"); - middle.add_property(Property::reg(vec![ - RegInfo::new(0x10000000, Some(0x1000)), // 使用根节点的 2+2 cells - ])); - middle.add_property(Property::AddressCells(1)); - middle.add_property(Property::SizeCells(1)); - - // 第三层: 设备节点，继承中间节点的 1+1 cells - let mut device = Node::new("device"); - device.add_property(Property::reg(vec![ - RegInfo::new(0x2000, Some(0x100)), // 使用中间节点的 1+1 cells - ])); - - middle.add_child(device); - fdt.root.add_child(middle); - - let fdt_data = fdt.to_bytes(); - assert!(!fdt_data.is_empty()); - - // 多级 cells 继承链测试通过 - } - - #[test] - fn test_default_cells_when_not_specified() { - let mut fdt = Fdt::new(); - - // 根节点不设置 address-cells 和 size-cells - // 应该使用默认值 1+1 - - let mut device = Node::new("device"); - device.add_property(Property::reg(vec![ - RegInfo::new(0x1000, Some(0x100)), // 使用默认的 1+1 cells - ])); - - fdt.root.add_child(device); - - let fdt_data = fdt.to_bytes(); - assert!(!fdt_data.is_empty()); - - // 默认 cells 值测试通过 - } -} diff --git a/fdt-edit/tests/clock.rs b/fdt-edit/tests/clock.rs new file mode 100644 index 0000000..e0c5bfa --- /dev/null +++ b/fdt-edit/tests/clock.rs @@ -0,0 +1,205 @@ +#![cfg(unix)] + +use dtb_file::*; +use fdt_edit::NodeKind; +use fdt_edit::*; + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_clock_node_detection() { + // 使用 RPI 4B DTB 测试 clock 节点检测 + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + // 遍历查找 clock 节点（有 #clock-cells 属性的节点） + let mut clock_count = 0; + for node in fdt.all_nodes() { + if let NodeKind::Clock(clock) = node.as_ref() { + clock_count += 1; + println!( + "Clock node: {} (#clock-cells={})", + clock.name(), + clock.clock_cells + ); + } + } + println!("Found {} clock nodes", clock_count); + } + + #[test] + fn test_clock_properties() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + if let NodeKind::Clock(clock) = node.as_ref() { + // 获取 #clock-cells + let cells = clock.clock_cells; + println!("Clock: {} cells={}", clock.name(), cells); + + // 获取输出名称 + if !clock.clock_output_names.is_empty() { + println!(" output-names: {:?}", clock.clock_output_names); + } + + match &clock.kind { + ClockType::Fixed(fixed) => { + println!( + " Fixed clock: freq={}Hz accuracy={:?}", + fixed.frequency, fixed.accuracy + ); + } + ClockType::Normal => { + println!(" Clock provider"); + } + } + } + } + } + + #[test] + fn test_fixed_clock() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + // 查找固定时钟 + let mut found_with_freq = false; + for node in fdt.all_nodes() { + if let NodeKind::Clock(clock) = node.as_ref() { + if let ClockType::Fixed(fixed) = &clock.kind { + // 打印固定时钟信息 + println!( + "Fixed clock found: {} freq={}Hz accuracy={:?}", + clock.name(), + fixed.frequency, + fixed.accuracy + ); + // 有些固定时钟（如 cam1_clk, cam0_clk）没有 clock-frequency 属性 + if fixed.frequency > 0 { + found_with_freq = true; + } + } + } + } + // 至少应该有一个固定时钟有频率 + assert!( + found_with_freq, + "Should find at least one fixed clock with frequency" + ); + } + + #[test] + fn test_clock_output_name() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + if let NodeKind::Clock(clock) = node.as_ref() { + let names = &clock.clock_output_names; + if !names.is_empty() { + // 测试 output_name 方法 + let first = clock.output_name(0); + assert_eq!(first, Some(names[0].as_str())); + + // 如果有多个输出，测试索引访问 + if names.len() > 1 && clock.clock_cells > 0 { + let second = clock.output_name(1); + assert_eq!(second, Some(names[1].as_str())); + } + } + } + } + } + + #[test] + fn test_clock_type_conversion() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + if let NodeKind::Clock(clock) = node.as_ref() { + match &clock.kind { + ClockType::Fixed(fixed) => { + // 打印固定时钟信息 + println!( + "Fixed clock: {} freq={} accuracy={:?}", + clock.name(), + fixed.frequency, + fixed.accuracy + ); + } + ClockType::Normal => { + // 测试 Normal 类型 + println!("Clock {} is a provider", clock.name()); + } + } + } + } + } + + #[test] + fn test_clocks_with_context() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + let mut found_clocks = false; + for node in fdt.all_nodes() { + if let NodeKind::Clock(clock_ref) = node.as_ref() { + found_clocks = true; + + let clocks = clock_ref.clocks(); + if !clocks.is_empty() { + found_clocks = true; + println!( + "Node: {} has {} clock references:", + clock_ref.name(), + clocks.len() + ); + for (i, clk) in clocks.iter().enumerate() { + println!( + " [{}] phandle={:?} cells={} specifier={:?} name={:?}", + i, clk.phandle, clk.cells, clk.specifier, clk.name + ); + // 验证 specifier 长度与 cells 一致 + assert_eq!( + clk.specifier.len(), + clk.cells as usize, + "specifier length should match cells" + ); + } + } + } + } + assert!(found_clocks, "Should find nodes with clock references"); + } + + #[test] + fn test_clock_ref_select() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + // 使用 as_clock_ref 获取带上下文的 clock 引用 + if let NodeKind::Clock(clock) = node.as_ref() { + let clocks = clock.clocks(); + for clk in clocks { + // 测试 select() 方法 + if clk.cells > 0 { + assert!( + clk.select().is_some(), + "select() should return Some when cells > 0" + ); + assert_eq!( + clk.select(), + clk.specifier.first().copied(), + "select() should return first specifier" + ); + } + } + } + } + } +} diff --git a/fdt-edit/tests/display.rs b/fdt-edit/tests/display.rs deleted file mode 100644 index b74328b..0000000 --- a/fdt-edit/tests/display.rs +++ /dev/null @@ -1,102 +0,0 @@ -#![no_std] - -extern crate alloc; - -#[cfg(test)] -mod tests { - use alloc::{string::String, string::ToString, vec}; - use core::fmt::Write; - - use fdt_edit::{Fdt, Node, Property, RegInfo}; - - #[test] - fn test_display_simple_fdt() { - let mut fdt = Fdt::new(); - - // 设置基本属性 - fdt.root.add_property(Property::AddressCells(1)); - fdt.root.add_property(Property::SizeCells(1)); - fdt.root - .add_property(Property::Compatible(vec!["test,soc".to_string()])); - - let mut cpu_node = Node::new("cpu@0"); - cpu_node.add_property(Property::DeviceType("cpu".to_string())); - cpu_node.add_property(Property::Compatible(vec!["arm,cortex-a53".to_string()])); - cpu_node.add_property(Property::reg(vec![RegInfo::new(0x0, Some(0x1000))])); - cpu_node.add_property(Property::Status(fdt_raw::Status::Okay)); - - fdt.root.add_child(cpu_node); - - // 测试格式化 - let mut output = String::new(); - write!(&mut output, "{}", fdt).unwrap(); - - // 验证基本结构 - assert!(output.contains("// Device Tree Source")); - assert!(output.contains("/ {")); - assert!(output.contains("#address-cells = <1>")); - assert!(output.contains("#size-cells = <1>")); - assert!(output.contains("compatible = \"test,soc\"")); - assert!(output.contains("cpu@0 {")); - assert!(output.contains("device_type = \"cpu\"")); - assert!(output.contains("compatible = \"arm,cortex-a53\"")); - assert!(output.contains("reg = <0x0 0x1000>")); - assert!(output.contains("status = \"okay\"")); - assert!(output.contains("};")); - } - - #[test] - fn test_display_with_memory_reservation() { - let mut fdt = Fdt::new(); - fdt.memory_reservations.push(fdt_edit::MemoryReservation { - address: 0x80000000, - size: 0x100000, - }); - - fdt.root - .add_property(Property::Model("Test Board".to_string())); - - let mut output = String::new(); - write!(&mut output, "{}", fdt).unwrap(); - - assert!(output.contains("/dts-v1/;")); - assert!(output.contains("/memreserve/")); - assert!(output.contains("0x80000000 0x100000;")); - assert!(output.contains("model = \"Test Board\"")); - } - - #[test] - fn test_display_nested_structure() { - let mut fdt = Fdt::new(); - - fdt.root.add_property(Property::AddressCells(1)); - fdt.root.add_property(Property::SizeCells(1)); - - let mut bus_node = Node::new("bus@1000"); - bus_node.add_property(Property::reg(vec![RegInfo::new(0x1000, Some(0x100))])); - - let mut device1_node = Node::new("device1@2000"); - device1_node.add_property(Property::reg(vec![RegInfo::new(0x2000, Some(0x50))])); - device1_node.add_property(Property::Status(fdt_raw::Status::Okay)); - - let mut device2_node = Node::new("device2@3000"); - device2_node.add_property(Property::reg(vec![RegInfo::new(0x3000, Some(0x50))])); - device2_node.add_property(Property::Status(fdt_raw::Status::Disabled)); - - bus_node.add_child(device1_node); - bus_node.add_child(device2_node); - fdt.root.add_child(bus_node); - - let mut output = String::new(); - write!(&mut output, "{}", fdt).unwrap(); - - assert!(output.contains("bus@1000 {")); - assert!(output.contains("reg = <0x1000 0x100>")); - assert!(output.contains("device1@2000 {")); - assert!(output.contains("reg = <0x2000 0x50>")); - assert!(output.contains("status = \"okay\"")); - assert!(output.contains("device2@3000 {")); - assert!(output.contains("reg = <0x3000 0x50>")); - assert!(output.contains("status = \"disabled\"")); - } -} diff --git a/fdt-edit/tests/display_debug.rs b/fdt-edit/tests/display_debug.rs new file mode 100644 index 0000000..b6ed916 --- /dev/null +++ b/fdt-edit/tests/display_debug.rs @@ -0,0 +1,271 @@ +#![cfg(unix)] + +use dtb_file::*; +use fdt_edit::*; + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_fdt_display() { + // 使用 RPI 4B DTB 测试 Display 功能 + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + // 测试 Display 输出 + let dts_output = format!("{}", fdt); + + // 验证输出包含 DTS 头部 + assert!(dts_output.contains("/dts-v1/;")); + + // 验证输出包含根节点 + assert!(dts_output.contains("/ {")); + + println!("FDT Display output:\n{}", dts_output); + } + + #[test] + fn test_fdt_debug() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + // 测试 Debug 输出 + let debug_output = format!("{:?}", fdt); + + // 验证 Debug 输出包含结构体信息 + assert!(debug_output.contains("Fdt")); + assert!(debug_output.contains("boot_cpuid_phys")); + + println!("FDT Debug output:\n{}", debug_output); + } + + #[test] + fn test_node_display() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + // 找到一个节点进行测试 + for node in fdt.all_nodes() { + if node.name().contains("gpio") { + let dts_output = format!("{}", node); + + // 验证输出包含节点名称 + assert!(dts_output.contains("gpio")); + + println!("Node Display output:\n{}", dts_output); + break; + } + } + } + + #[test] + fn test_node_debug() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + if node.name().contains("gpio") { + let debug_output = format!("{:?}", node); + + // 验证 Debug 输出包含 Node 结构体信息 + assert!(debug_output.contains("NodeRef")); + assert!(debug_output.contains("name")); + + println!("Node Debug output:\n{}", debug_output); + break; + } + } + } + + #[test] + fn test_clock_node_display() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + if let NodeKind::Clock(clock) = node.as_ref() { + let display_output = format!("{}", clock); + let debug_output = format!("{:?}", clock); + + println!("Clock Node Display:\n{}", display_output); + println!("Clock Node Debug:\n{}", debug_output); + + // 验证输出包含时钟相关信息 + assert!(display_output.contains("Clock Node")); + + // 验证 Debug 包含详细信息 + assert!(debug_output.contains("NodeRefClock")); + assert!(debug_output.contains("clock_cells")); + + break; + } + } + } + + #[test] + fn test_interrupt_controller_display() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + if let NodeKind::InterruptController(ic) = node.as_ref() { + let display_output = format!("{}", ic); + let debug_output = format!("{:?}", ic); + + println!("Interrupt Controller Display:\n{}", display_output); + println!("Interrupt Controller Debug:\n{}", debug_output); + + // 验证输出包含中断控制器相关信息 + assert!(display_output.contains("Interrupt Controller")); + + // 验证 Debug 包含详细信息 + assert!(debug_output.contains("NodeRefInterruptController")); + assert!(debug_output.contains("interrupt_cells")); + + break; + } + } + } + + #[test] + fn test_memory_node_display() { + let raw_data = fdt_phytium(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + if let NodeKind::Memory(mem) = node.as_ref() { + let display_output = format!("{}", mem); + let debug_output = format!("{:?}", mem); + + println!("Memory Node Display:\n{}", display_output); + println!("Memory Node Debug:\n{}", debug_output); + + // 验证输出包含内存相关信息 + assert!(display_output.contains("Memory Node")); + + // 验证 Debug 包含详细信息 + assert!(debug_output.contains("NodeRefMemory")); + assert!(debug_output.contains("regions_count")); + + break; + } + } + } + + #[test] + fn test_noderef_display_with_details() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + if node.name().contains("clock") { + let display_output = format!("{}", node); + + println!("NodeRef Display with details:\n{}", display_output); + + // 验证输出包含类型信息 + assert!(display_output.contains("Clock Node")); + + break; + } + } + } + + #[test] + fn test_create_simple_fdt() { + let mut fdt = Fdt::new(); + + // 测试基本 Display 功能 + let dts_output = format!("{}", fdt); + println!("Created FDT Display:\n{}", dts_output); + + // 验证输出包含基本头部 + assert!(dts_output.contains("/dts-v1/;")); + assert!(dts_output.contains("/ {")); + } + + #[test] + fn test_manual_node_display() { + let mut node = Node::new("test-node"); + + // 测试基本 Display 功能 + let display_output = format!("{}", node); + println!("Manual Node Display:\n{}", display_output); + + // 验证输出包含节点名称 + assert!(display_output.contains("test-node")); + + // 测试 Debug + let debug_output = format!("{:?}", node); + println!("Manual Node Debug:\n{}", debug_output); + + assert!(debug_output.contains("Node")); + assert!(debug_output.contains("test-node")); + } + + #[test] + fn test_fdt_deep_debug() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + // 测试基本 Debug 格式 + let simple_debug = format!("{:?}", fdt); + println!("FDT Simple Debug:\n{}", simple_debug); + + // 验证基本格式包含基本信息 + assert!(simple_debug.contains("Fdt")); + assert!(simple_debug.contains("boot_cpuid_phys")); + + // 测试深度 Debug 格式 + let deep_debug = format!("{:#?}", fdt); + println!("FDT Deep Debug:\n{}", deep_debug); + + // 验证深度格式包含节点信息 + assert!(deep_debug.contains("Fdt {")); + assert!(deep_debug.contains("nodes:")); + assert!(deep_debug.contains("[000]")); + + // 验证包含特定节点类型 + assert!( + deep_debug.contains("Clock") + || deep_debug.contains("InterruptController") + || deep_debug.contains("Memory") + || deep_debug.contains("Generic") + ); + } + + #[test] + fn test_fdt_deep_debug_with_simple_tree() { + let mut fdt = Fdt::new(); + + // 创建一个简单的树结构进行测试 + let mut soc = Node::new("soc"); + soc.set_property(Property::new("#address-cells", vec![0x1, 0x0, 0x0, 0x0])); + soc.set_property(Property::new("#size-cells", vec![0x1, 0x0, 0x0, 0x0])); + + let mut uart = Node::new("uart@9000000"); + uart.set_property(Property::new("compatible", b"arm,pl011\0".to_vec())); + uart.set_property(Property::new( + "reg", + vec![ + 0x00, 0x90, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, + ], + )); + uart.set_property(Property::new("status", b"okay\0".to_vec())); + + soc.add_child(uart); + fdt.root.add_child(soc); + + // 测试深度调试输出 + let deep_debug = format!("{:#?}", fdt); + println!("Simple Tree Deep Debug:\n{}", deep_debug); + + // 验证输出包含预期的节点信息 + assert!(deep_debug.contains("[000] : Generic")); + assert!(deep_debug.contains("[001] soc: Generic")); + assert!(deep_debug.contains("[002] uart@9000000: Generic")); + assert!(deep_debug.contains("#address-cells=1")); + assert!(deep_debug.contains("#size-cells=1")); + } +} diff --git a/fdt-edit/tests/edit.rs b/fdt-edit/tests/edit.rs index 45d201a..0a61430 100644 --- a/fdt-edit/tests/edit.rs +++ b/fdt-edit/tests/edit.rs @@ -10,7 +10,7 @@ fn test_parse_and_rebuild() { // 解析原始 DTB let raw_data = fdt_qemu(); let fdt = Fdt::from_bytes(&raw_data).unwrap(); - let fdt_data = fdt.to_bytes(); + let fdt_data = fdt.encode(); // 创建临时文件 let temp_dir = std::env::temp_dir(); @@ -145,3 +145,25 @@ fn test_parse_and_rebuild() { println!("✅ 测试通过：原始DTB和重建DTB的DTS表示完全一致"); } + +// TODO: 需要为 Fdt 实现 Display trait +// #[test] +// fn test_display_dts() { +// // 解析 DTB +// let raw_data = fdt_qemu(); +// let fdt = Fdt::from_bytes(&raw_data).unwrap(); + +// // 使用 Display 输出 DTS +// let dts = format!("{}", fdt); + +// // 验证输出格式 +// assert!(dts.starts_with("/dts-v1/;"), "DTS 应该以 /dts-v1/; 开头"); +// assert!(dts.contains("/ {"), "DTS 应该包含根节点"); +// assert!(dts.contains("};"), "DTS 应该包含节点闭合"); + +// // 验证包含一些常见节点 +// assert!(dts.contains("compatible"), "DTS 应该包含 compatible 属性"); + +// println!("✅ Display 测试通过"); +// println!("DTS 输出前 500 字符:\n{}", &dts[..dts.len().min(500)]); +// } diff --git a/fdt-edit/tests/find2.rs b/fdt-edit/tests/find2.rs new file mode 100644 index 0000000..8545472 --- /dev/null +++ b/fdt-edit/tests/find2.rs @@ -0,0 +1,67 @@ +#[cfg(test)] +mod tests { + use dtb_file::fdt_qemu; + use fdt_edit::*; + + #[test] + fn test_get_method() { + // 解析原始 DTB + let raw_data = fdt_qemu(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + let node = fdt.get_by_path("/virtio_mmio@a002600"); + + println!("Found node: {:#?}", node.unwrap()); + } + + #[test] + fn test_find_method() { + // 解析原始 DTB + let raw_data = fdt_qemu(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + let node = fdt.find_by_path("/virtio_mmio"); + + for n in node { + println!("Found node {n:#?}"); + } + + let count = fdt.find_by_path("/virtio_mmio").count(); + println!("Total found nodes: {}", count); + assert_eq!(count, 32); + } + + #[test] + fn test_all() { + // 解析原始 DTB + let raw_data = fdt_qemu(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + println!("Node: {:#?}", node); + println!(" {}", node.path()); + println!("-------------------------"); + } + + let count = fdt.all_nodes().count(); + println!("Total nodes: {}", count); + assert_eq!(count, 56); + } + + #[test] + fn test_all_mut() { + // 解析原始 DTB + let raw_data = fdt_qemu(); + let mut fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes_mut() { + println!("Node: {:#?}", node); + println!(" {}", node.path()); + println!("-------------------------"); + } + + let count = fdt.all_nodes().count(); + println!("Total nodes: {}", count); + assert_eq!(count, 56); + } +} diff --git a/fdt-edit/tests/find_all.rs b/fdt-edit/tests/find_all.rs deleted file mode 100644 index 8eb2d0f..0000000 --- a/fdt-edit/tests/find_all.rs +++ /dev/null @@ -1,132 +0,0 @@ -#[cfg(test)] -mod tests { - use fdt_edit::Property; - use fdt_edit::*; - - #[test] - fn test_find_all_method() { - let mut root = Node::root(); - - // 添加几个子节点 - let mut gpio0 = Node::new_raw("gpio@1000"); - gpio0.add_property(Property::compatible_from_strs(&["gpio"])); - - let mut gpio1 = Node::new_raw("gpio@2000"); - gpio1.add_property(Property::compatible_from_strs(&["gpio"])); - - let mut uart = Node::new_raw("uart@3000"); - uart.add_property(Property::compatible_from_strs(&["uart"])); - - root.add_child(gpio0); - root.add_child(gpio1); - root.add_child(uart); - - // 测试 find_all 与前缀匹配 - let gpio_nodes = root.find_all("gpio"); - assert_eq!(gpio_nodes.len(), 2); // 应该找到两个 GPIO 节点 - - // 验证返回的路径是正确的 - for (node, path) in &gpio_nodes { - assert!(path.starts_with("/gpio@")); - assert!(node.name.starts_with("gpio")); - } - } - - #[test] - fn test_find_all_nested() { - let mut root = Node::root(); - - // 创建嵌套结构 - let mut soc = Node::new_raw("soc"); - - let mut i2c0 = Node::new_raw("i2c@0"); - let mut eeprom = Node::new_raw("eeprom@50"); - eeprom.add_property(Property::compatible_from_strs(&["eeprom"])); - - let mut i2c1 = Node::new_raw("i2c@1"); - let mut sensor = Node::new_raw("sensor@60"); - sensor.add_property(Property::compatible_from_strs(&["sensor"])); - - i2c0.add_child(eeprom); - i2c1.add_child(sensor); - soc.add_child(i2c0); - soc.add_child(i2c1); - root.add_child(soc); - - // 测试嵌套查找 - let i2c_nodes = root.find_all("soc/i2c"); - assert_eq!(i2c_nodes.len(), 2); // 应该找到 i2c@0 和 i2c@1 节点 - - let eeprom_nodes = root.find_all("soc/i2c@0/eeprom"); - assert_eq!(eeprom_nodes.len(), 1); // 应该找到 eeprom@50 节点 - } - - #[test] - fn test_find_all_prefix_matching() { - let mut root = Node::root(); - - // 添加多个带地址的节点 - let gpio0 = Node::new_raw("gpio@1000"); - let gpio1 = Node::new_raw("gpio@2000"); - let gpio2 = Node::new_raw("gpio-controller@3000"); - let uart0 = Node::new_raw("uart@4000"); - let uart1 = Node::new_raw("serial@5000"); - - root.add_child(gpio0); - root.add_child(gpio1); - root.add_child(gpio2); - root.add_child(uart0); - root.add_child(uart1); - - // 测试前缀匹配：查找所有以 "gpio" 开头的节点 - let gpio_nodes = root.find_all("gpio"); - assert_eq!(gpio_nodes.len(), 3); // 应该找到所有 gpio 开头的节点 - - // 验证找到的节点名称 - for (node, path) in &gpio_nodes { - assert!( - node.name.starts_with("gpio"), - "Node '{}' should start with 'gpio'", - node.name - ); - assert_eq!(path.as_str(), format!("/{}", node.name)); - } - - // 测试前缀匹配：查找所有以 "uart" 开头的节点 - let uart_nodes = root.find_all("uart"); - assert_eq!(uart_nodes.len(), 1); // 应该找到 uart@4000，但不会找到 serial@5000 - - // 测试精确匹配 - let exact_uart = root.find_all("uart@4000"); - assert_eq!(exact_uart.len(), 1); // 精确匹配应该找到 uart@4000 - - // 测试前缀匹配 "serial" - let serial_nodes = root.find_all("serial"); - assert_eq!(serial_nodes.len(), 1); // 应该找到 serial@5000 - } - - #[test] - fn test_find_all_intermediate_exact_matching() { - let mut root = Node::root(); - - // 创建嵌套结构，测试中间级别的精确匹配 - let mut soc = Node::new_raw("soc"); - let mut bus = Node::new_raw("bus"); - - let device1 = Node::new_raw("device@1000"); - let device2 = Node::new_raw("device@2000"); - - bus.add_child(device1); - bus.add_child(device2); - soc.add_child(bus); - root.add_child(soc); - - // 测试中间级别必须精确匹配：soc/bus 是正确的路径 - let devices = root.find_all("soc/bus/device"); - assert_eq!(devices.len(), 2); // 应该找到两个 device 节点 - - // 测试中间级别模糊匹配不应该工作：soc/b 不会匹配 bus - let no_match = root.find_all("soc/b/device"); - assert_eq!(no_match.len(), 0); // 中间级别的模糊匹配不应该工作 - } -} diff --git a/fdt-edit/tests/irq.rs b/fdt-edit/tests/irq.rs new file mode 100644 index 0000000..bc4bd65 --- /dev/null +++ b/fdt-edit/tests/irq.rs @@ -0,0 +1,172 @@ +#![cfg(unix)] + +use dtb_file::*; +use fdt_edit::NodeKind; +use fdt_edit::*; + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_interrupt_controller_detection() { + // 使用 RPI 4B DTB 测试中断控制器节点检测 + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + // 遍历查找中断控制器节点 + let mut irq_count = 0; + for node in fdt.all_nodes() { + if let NodeKind::InterruptController(ic) = node.as_ref() { + irq_count += 1; + println!( + "Interrupt controller: {} (#interrupt-cells={:?})", + ic.name(), + ic.interrupt_cells() + ); + } + } + println!("Found {} interrupt controllers", irq_count); + assert!( + irq_count > 0, + "Should find at least one interrupt controller" + ); + } + + #[test] + fn test_interrupt_controller_properties() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + if let NodeKind::InterruptController(ic) = node.as_ref() { + // 获取 #interrupt-cells + let cells = ic.interrupt_cells(); + println!("IRQ Controller: {} cells={:?}", ic.name(), cells); + + // 获取 #address-cells (如果有) + let addr_cells = ic.interrupt_address_cells(); + if addr_cells.is_some() { + println!(" #address-cells: {:?}", addr_cells); + } + + // 验证 is_interrupt_controller + assert!( + ic.is_interrupt_controller(), + "Should be marked as interrupt controller" + ); + + // 获取 compatible 列表 + let compat = ic.compatibles(); + if !compat.is_empty() { + println!(" compatible: {:?}", compat); + } + } + } + } + + #[test] + fn test_interrupt_controller_by_name() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + // 查找 GIC (ARM Generic Interrupt Controller) + let mut found_gic = false; + for node in fdt.all_nodes() { + if let NodeKind::InterruptController(ic) = node.as_ref() { + let compat = ic.compatibles(); + if compat.iter().any(|c| c.contains("gic")) { + found_gic = true; + println!("Found GIC: {}", ic.name()); + + // GIC 通常有 3 个 interrupt-cells + let cells = ic.interrupt_cells(); + println!(" #interrupt-cells: {:?}", cells); + } + } + } + // 注意：并非所有 DTB 都有 GIC，这里只是示例 + if found_gic { + println!("GIC found in this DTB"); + } + } + + #[test] + fn test_interrupt_controller_with_phytium() { + // Phytium DTB 应该有中断控制器 + let raw_data = fdt_phytium(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + let mut controllers = Vec::new(); + for node in fdt.all_nodes() { + if let NodeKind::InterruptController(ic) = node.as_ref() { + controllers.push(( + ic.name().to_string(), + ic.interrupt_cells(), + ic.compatibles().join(", "), + )); + } + } + + println!("Interrupt controllers in Phytium DTB:"); + for (name, cells, compat) in &controllers { + println!( + " {} (#interrupt-cells={:?}, compatible={})", + name, cells, compat + ); + } + + assert!( + !controllers.is_empty(), + "Phytium should have at least one interrupt controller" + ); + } + + #[test] + fn test_interrupt_controller_detection_logic() { + // 测试节点是否正确被识别为中断控制器 + let raw_data = fdt_qemu(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + let name = node.name(); + let is_ic = matches!(node.as_ref(), NodeKind::InterruptController(_)); + + // 如果节点名以 interrupt-controller 开头，应该被识别 + if name.starts_with("interrupt-controller") && !is_ic { + println!( + "Warning: {} might be an interrupt controller but not detected", + name + ); + } + + // 如果有 interrupt-controller 属性，应该被识别 + if node.find_property("interrupt-controller").is_some() && !is_ic { + println!( + "Warning: {} has interrupt-controller property but not detected", + name + ); + } + } + } + + #[test] + fn test_interrupt_cells_values() { + let raw_data = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + if let NodeKind::InterruptController(ic) = node.as_ref() { + if let Some(cells) = ic.interrupt_cells() { + // 常见的 interrupt-cells 值：1, 2, 3 + assert!( + cells >= 1 && cells <= 4, + "Unusual #interrupt-cells value: {} for {}", + cells, + ic.name() + ); + } + } + } + } +} diff --git a/fdt-edit/tests/memory.rs b/fdt-edit/tests/memory.rs new file mode 100644 index 0000000..77c3239 --- /dev/null +++ b/fdt-edit/tests/memory.rs @@ -0,0 +1,85 @@ +#![cfg(unix)] + +use dtb_file::*; +use fdt_edit::NodeKind; +use fdt_edit::*; + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_memory_node_detection() { + // 使用 phytium DTB 测试 memory 节点检测 + let raw_data = fdt_phytium(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + // 遍历查找 memory 节点 + let mut found_memory = false; + for node in fdt.all_nodes() { + if let NodeKind::Memory(mem) = node.as_ref() { + found_memory = true; + println!("Memory node: {}", mem.name()); + } + } + assert!(found_memory, "Should find at least one memory node"); + } + + #[test] + fn test_memory_regions() { + let raw_data = fdt_phytium(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + // 查找 memory 节点并获取区域信息 + for node in fdt.all_nodes() { + if let NodeKind::Memory(mem) = node.as_ref() { + let regions = mem.regions(); + // memory 节点应该有至少一个区域 + if !regions.is_empty() { + for region in regions { + println!( + "Memory region: address=0x{:x}, size=0x{:x}", + region.address, region.size + ); + } + } + } + } + } + + #[test] + fn test_memory_node_properties() { + let raw_data = fdt_phytium(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + if let NodeKind::Memory(mem) = node.as_ref() { + // memory 节点应该有 device_type 属性 + let dt = mem.device_type(); + if let Some(device_type) = dt { + assert_eq!(device_type, "memory", "device_type should be 'memory'"); + } + + // 获取节点名称 + let name = mem.name(); + assert!( + name.starts_with("memory"), + "Memory node name should start with 'memory'" + ); + } + } + } + + #[test] + fn test_create_memory_node() { + // 手动创建一个 memory 节点 + let mem = NodeMemory::new("memory@80000000"); + assert_eq!(mem.name(), "memory@80000000"); + + // 验证初始状态 + assert!( + mem.regions().is_empty(), + "New memory node should have no regions" + ); + } +} diff --git a/fdt-edit/tests/pci.rs b/fdt-edit/tests/pci.rs new file mode 100644 index 0000000..e423990 --- /dev/null +++ b/fdt-edit/tests/pci.rs @@ -0,0 +1,182 @@ +#[cfg(test)] +mod tests { + use std::sync::Once; + + use dtb_file::{fdt_phytium, fdt_qemu}; + use fdt_edit::*; + + fn init_logging() { + static INIT: Once = Once::new(); + INIT.call_once(|| { + let _ = env_logger::builder() + .is_test(true) + .filter_level(log::LevelFilter::Trace) + .try_init(); + }); + } + + #[test] + fn test_pci_node_detection() { + let raw_data = fdt_qemu(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + // Try to find PCI nodes + let mut pci_nodes_found = 0; + for node in fdt.all_nodes() { + { + if let NodeRef::Pci(pci) = node { + pci_nodes_found += 1; + println!("Found PCI node: {}", pci.name()); + } + } + } + + // We should find at least one PCI node in the qemu PCI test file + assert!(pci_nodes_found > 0, "Should find at least one PCI node"); + } + + #[test] + fn test_bus_range() { + let raw_data = fdt_qemu(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + { + if let NodeRef::Pci(pci) = node + && let Some(range) = pci.bus_range() + { + println!("Found bus-range: {range:?}"); + assert!(range.start <= range.end, "Bus range start should be <= end"); + return; // Test passed + } + } + } + + // println!("No bus-range found in any PCI node"); + } + + #[test] + fn test_pci_properties() { + let raw_data = fdt_qemu(); + let fdt = Fdt::from_bytes(&raw_data).unwrap(); + + for node in fdt.all_nodes() { + { + if let NodeRef::Pci(pci) = node { + // Test address cells + assert_eq!( + pci.address_cells(), + Some(3), + "PCI should use 3 address cells" + ); + + // Test interrupt cells + assert_eq!(pci.interrupt_cells(), 1, "PCI should use 1 interrupt cell"); + + // Test device type + if let Some(device_type) = pci.device_type() { + assert!(!device_type.is_empty()); + } + + // Test compatibles + let compatibles = pci.compatibles().collect::>(); + if !compatibles.is_empty() { + println!("Compatibles: {:?}", compatibles); + } + + return; // Test passed for first PCI node found + } + } + } + + panic!("No PCI nodes found for property testing"); + } + + #[test] + fn test_pci2() { + let raw = fdt_phytium(); + let fdt = Fdt::from_bytes(&raw).unwrap(); + let node = fdt + .find_compatible(&["pci-host-ecam-generic"]) + .into_iter() + .next() + .unwrap(); + + let NodeRef::Pci(pci) = node else { + panic!("Not a PCI node"); + }; + + let want = [ + PciRange { + space: PciSpace::IO, + bus_address: 0x0, + cpu_address: 0x50000000, + size: 0xf00000, + prefetchable: false, + }, + PciRange { + space: PciSpace::Memory32, + bus_address: 0x58000000, + cpu_address: 0x58000000, + size: 0x28000000, + prefetchable: false, + }, + PciRange { + space: PciSpace::Memory64, + bus_address: 0x1000000000, + cpu_address: 0x1000000000, + size: 0x1000000000, + prefetchable: false, + }, + ]; + + for (i, range) in pci.ranges().unwrap().iter().enumerate() { + assert_eq!(*range, want[i]); + println!("{range:#x?}"); + } + } + + #[test] + fn test_pci_irq_map() { + let raw = fdt_phytium(); + let fdt = Fdt::from_bytes(&raw).unwrap(); + let node_ref = fdt + .find_compatible(&["pci-host-ecam-generic"]) + .into_iter() + .next() + .unwrap(); + + let NodeRef::Pci(pci) = node_ref else { + panic!("Not a PCI node"); + }; + + let irq = pci.child_interrupts(0, 0, 0, 4).unwrap(); + + assert!(!irq.irqs.is_empty()); + } + + #[test] + fn test_pci_irq_map2() { + init_logging(); + + let raw = fdt_qemu(); + let fdt = Fdt::from_bytes(&raw).unwrap(); + let node_ref = fdt + .find_compatible(&["pci-host-ecam-generic"]) + .into_iter() + .next() + .unwrap(); + + let NodeRef::Pci(pci) = node_ref else { + panic!("Not a PCI node"); + }; + + let irq = pci.child_interrupts(0, 2, 0, 1).unwrap(); + + let want = [0, 5, 4]; + + for (got, want) in irq.irqs.iter().zip(want.iter()) { + assert_eq!(*got, *want); + } + } +} diff --git a/fdt-edit/tests/range.rs b/fdt-edit/tests/range.rs new file mode 100644 index 0000000..4207cc2 --- /dev/null +++ b/fdt-edit/tests/range.rs @@ -0,0 +1,145 @@ +#[cfg(test)] +mod tests { + use std::sync::Once; + + use dtb_file::fdt_rpi_4b; + use fdt_edit::*; + use log::*; + + fn init_logging() { + static INIT: Once = Once::new(); + INIT.call_once(|| { + let _ = env_logger::builder() + .is_test(true) + .filter_level(log::LevelFilter::Trace) + .try_init(); + }); + } + + #[test] + fn test_reg() { + init_logging(); + let raw = fdt_rpi_4b(); + let fdt = Fdt::from_bytes(&raw).unwrap(); + + let node = fdt.get_by_path("/soc/serial@7e215040").unwrap(); + + let reg = node.regs().unwrap()[0]; + + info!("reg: {:#x?}", reg); + + assert_eq!( + reg.address, 0xfe215040, + "want 0xfe215040, got {:#x}", + reg.address + ); + + assert_eq!( + reg.child_bus_address, 0x7e215040, + "want 0x7e215040, got {:#x}", + reg.child_bus_address + ); + assert_eq!( + reg.size, + Some(0x40), + "want 0x40, got {:#x}", + reg.size.unwrap() + ); + } + + #[test] + fn test_set_regs_with_ranges_conversion() { + init_logging(); + let raw = fdt_rpi_4b(); + let mut fdt = Fdt::from_bytes(&raw).unwrap(); + + // 获取可变节点引用 + let mut node = fdt.get_by_path_mut("/soc/serial@7e215040").unwrap(); + + // 获取原始 reg 信息 + let original_regs = node.regs().unwrap(); + let original_reg = original_regs[0]; + info!("Original reg: {:#x?}", original_reg); + + // 使用 CPU 地址设置 reg (0xfe215040 是 CPU 地址) + // set_regs 应该将其转换为 bus 地址 (0x7e215040) 后存储 + let new_cpu_address = 0xfe215080u64; // 新的 CPU 地址 + let new_size = 0x80u64; + node.set_regs(&[RegInfo { + address: new_cpu_address, + size: Some(new_size), + }]); + + // 重新读取验证 + let updated_regs = node.regs().unwrap(); + let updated_reg = updated_regs[0]; + info!("Updated reg: {:#x?}", updated_reg); + + // 验证：读取回来的 CPU 地址应该是我们设置的值 + assert_eq!( + updated_reg.address, new_cpu_address, + "CPU address should be {:#x}, got {:#x}", + new_cpu_address, updated_reg.address + ); + + // 验证：bus 地址应该是转换后的值 + // 0xfe215080 - 0xfe000000 + 0x7e000000 = 0x7e215080 + let expected_bus_address = 0x7e215080u64; + assert_eq!( + updated_reg.child_bus_address, expected_bus_address, + "Bus address should be {:#x}, got {:#x}", + expected_bus_address, updated_reg.child_bus_address + ); + + assert_eq!( + updated_reg.size, + Some(new_size), + "Size should be {:#x}, got {:?}", + new_size, + updated_reg.size + ); + } + + #[test] + fn test_set_regs_roundtrip() { + init_logging(); + let raw = fdt_rpi_4b(); + let mut fdt = Fdt::from_bytes(&raw).unwrap(); + + // 获取原始 reg 信息 + let original_reg = { + let node = fdt.get_by_path("/soc/serial@7e215040").unwrap(); + node.regs().unwrap()[0] + }; + info!("Original reg: {:#x?}", original_reg); + + // 使用相同的 CPU 地址重新设置 reg + { + let mut node = fdt.get_by_path_mut("/soc/serial@7e215040").unwrap(); + node.set_regs(&[RegInfo { + address: original_reg.address, // 使用 CPU 地址 + size: original_reg.size, + }]); + } + + // 验证 roundtrip：读取回来应该和原来一样 + let roundtrip_reg = { + let node = fdt.get_by_path("/soc/serial@7e215040").unwrap(); + node.regs().unwrap()[0] + }; + info!("Roundtrip reg: {:#x?}", roundtrip_reg); + + assert_eq!( + roundtrip_reg.address, original_reg.address, + "Roundtrip CPU address mismatch" + ); + assert_eq!( + roundtrip_reg.child_bus_address, original_reg.child_bus_address, + "Roundtrip bus address mismatch" + ); + assert_eq!( + roundtrip_reg.size, original_reg.size, + "Roundtrip size mismatch" + ); + } +} diff --git a/fdt-edit/tests/remove_node.rs b/fdt-edit/tests/remove_node.rs index 4c8b1f4..4f1a731 100644 --- a/fdt-edit/tests/remove_node.rs +++ b/fdt-edit/tests/remove_node.rs @@ -1,173 +1,158 @@ #[cfg(test)] mod tests { + use dtb_file::fdt_qemu; use fdt_edit::*; - use fdt_edit::{Property, Status}; #[test] fn test_remove_node_exact_path() { - let mut root = Node::root(); + // 解析原始 DTB + let raw_data = fdt_qemu(); + let mut fdt = Fdt::from_bytes(&raw_data).unwrap(); - // 添加一些子节点 - let mut gpio0 = Node::new("gpio@1000"); - let mut gpio1 = Node::new("gpio@2000"); - let mut uart = Node::new("uart@3000"); + // 找到一个存在的节点路径进行删除 + let node = fdt.get_by_path("/psci"); + assert!(node.is_some(), "psci 节点应该存在"); - root.add_child(gpio0); - root.add_child(gpio1); - root.add_child(uart); - - // 测试精确删除 - let removed = root.remove_by_path("gpio@1000").unwrap(); - assert!(removed.is_some(), "Should remove gpio@1000"); - assert_eq!(removed.unwrap().name, "gpio@1000"); + // 删除节点 + let removed = fdt.remove_node("/psci"); + assert!(removed.is_ok(), "删除应该成功"); + assert!(removed.unwrap().is_some(), "应该返回被删除的节点"); - // 验证节点已删除 - assert!(root.find_child_exact("gpio@1000").is_none()); - assert!(root.find_child_exact("gpio@2000").is_some()); - assert!(root.find_child_exact("uart@3000").is_some()); + // 验证节点已被删除 + let node_after = fdt.get_by_path("/psci"); + assert!(node_after.is_none(), "psci 节点应该已被删除"); } #[test] - fn test_remove_node_nested_path() { - let mut root = Node::root(); + fn test_remove_nested_node() { + // 使用手动创建的树测试嵌套删除 + let mut fdt = Fdt::new(); - // 创建嵌套结构 + // 创建嵌套节点: /soc/i2c@0/eeprom@50 let mut soc = Node::new("soc"); - let mut i2c0 = Node::new("i2c@0"); - let mut eeprom = Node::new("eeprom@50"); + let mut i2c = Node::new("i2c@0"); + let eeprom = Node::new("eeprom@50"); + i2c.add_child(eeprom); + soc.add_child(i2c); + fdt.root.add_child(soc); - i2c0.add_child(eeprom); - soc.add_child(i2c0); - root.add_child(soc); + // 验证节点存在 + assert!(fdt.get_by_path("/soc/i2c@0/eeprom@50").is_some()); - // 测试嵌套删除 - let removed = root.remove_by_path("soc/i2c@0/eeprom@50").unwrap(); - assert!(removed.is_some(), "Should remove eeprom@50"); - assert_eq!(removed.unwrap().name, "eeprom@50"); + // 删除嵌套节点 + let removed = fdt.remove_node("/soc/i2c@0/eeprom@50"); + assert!(removed.is_ok()); + assert!(removed.unwrap().is_some()); - // 验证 eeprom 已删除但 i2c@0 还在 - let i2c_node = root.find_child("soc").unwrap().find_child("i2c@0").unwrap(); - assert!(i2c_node.find_child("eeprom@50").is_none()); - } + // 验证节点已删除 + assert!(fdt.get_by_path("/soc/i2c@0/eeprom@50").is_none()); - #[test] - fn test_remove_node_not_found() { - let mut root = Node::root(); - - // 测试删除不存在的节点 - let removed = root.remove_by_path("nonexistent").unwrap(); - assert!(removed.is_none(), "Should return None for nonexistent node"); - - // 测试删除不存在的嵌套节点 - let removed = root.remove_by_path("soc/nonexistent").unwrap(); - assert!( - removed.is_none(), - "Should return None for nonexistent nested node" - ); + // 父节点应该仍然存在 + assert!(fdt.get_by_path("/soc/i2c@0").is_some()); + assert!(fdt.get_by_path("/soc").is_some()); } #[test] - fn test_remove_node_invalid_path() { - let mut root = Node::root(); - - // 测试空路径 - let result = root.remove_by_path(""); - assert!(result.is_err(), "Should error for empty path"); + fn test_remove_nonexistent_node() { + let mut fdt = Fdt::new(); - // 测试只有斜杠的路径 - let result = root.remove_by_path("/"); - assert!(result.is_err(), "Should error for root path"); + // 删除不存在的节点应该返回 NotFound + let result = fdt.remove_node("/nonexistent"); + assert!(result.is_err()); } #[test] - fn test_fdt_remove_node() { + fn test_remove_direct_child() { let mut fdt = Fdt::new(); - // 添加根节点属性 - fdt.root - .add_property(Property::address_cells(2)) - .add_property(Property::size_cells(2)); - - // 添加子节点 - let mut soc = Node::new("soc"); - let mut gpio = Node::new("gpio@1000"); - gpio.add_property(Property::compatible_from_strs(&["gpio"])); - soc.add_child(gpio); - fdt.root.add_child(soc); + // 添加直接子节点 + fdt.root.add_child(Node::new("memory@0")); - // 验证节点存在 - assert!(fdt.get_by_path("/soc/gpio@1000").is_some()); + // 验证存在 + assert!(fdt.get_by_path("/memory@0").is_some()); - // 删除节点 - let removed = fdt.remove_node("soc/gpio@1000").unwrap(); - assert!(removed.is_some(), "Should remove gpio@1000"); - assert_eq!(removed.unwrap().name, "gpio@1000"); + // 删除直接子节点 + let removed = fdt.remove_node("/memory@0"); + assert!(removed.is_ok()); + assert!(removed.unwrap().is_some()); - // 验证节点已删除 - assert!(fdt.get_by_path("/soc/gpio@1000").is_none()); - assert!(fdt.get_by_path("/soc").is_some()); + // 验证已删除 + assert!(fdt.get_by_path("/memory@0").is_none()); } #[test] - fn test_fdt_remove_node_with_alias() { + fn test_remove_empty_path() { let mut fdt = Fdt::new(); - // 添加根节点属性 - fdt.root - .add_property(Property::address_cells(2)) - .add_property(Property::size_cells(2)); + // 空路径应该返回错误 + let result = fdt.remove_node(""); + assert!(result.is_err()); - // 添加别名节点 - let mut aliases = Node::new("aliases"); - aliases.add_property(Property::raw_string("serial0", "/soc/uart@1000")); - fdt.root.add_child(aliases); - - // 添加 soc 和 uart 节点 - let mut soc = Node::new("soc"); - let mut uart = Node::new("uart@1000"); - uart.add_property(Property::compatible_from_strs(&["uart"])); - soc.add_child(uart); - fdt.root.add_child(soc); + let result = fdt.remove_node("/"); + assert!(result.is_err()); + } - // 验证节点存在 - assert!(fdt.get_by_path("serial0").is_some()); - assert!(fdt.get_by_path("/soc/uart@1000").is_some()); + #[test] + fn test_node_remove_by_path() { + // 直接测试 Node 的 remove_by_path 方法 + let mut root = Node::new(""); + + // 创建结构: /a/b/c + let mut a = Node::new("a"); + let mut b = Node::new("b"); + let c = Node::new("c"); + b.add_child(c); + a.add_child(b); + root.add_child(a); + + // 验证 c 存在 + assert!(root.get_child("a").is_some()); + + // 删除 c + let removed = root.remove_by_path("a/b/c"); + assert!(removed.is_ok()); + assert!(removed.unwrap().is_some()); + + // 删除 b + let removed = root.remove_by_path("a/b"); + assert!(removed.is_ok()); + assert!(removed.unwrap().is_some()); + + // 删除 a + let removed = root.remove_by_path("a"); + assert!(removed.is_ok()); + assert!(removed.unwrap().is_some()); + + // 所有节点都已删除 + assert!(root.get_child("a").is_none()); + } - // 通过别名删除节点 - let removed = fdt.remove_node("serial0").unwrap(); - assert!(removed.is_some(), "Should remove uart via alias"); - assert_eq!(removed.unwrap().name, "uart@1000"); + #[test] + fn test_remove_with_leading_slash() { + let mut fdt = Fdt::new(); + fdt.root.add_child(Node::new("test")); - // 验证节点已删除 - assert!(fdt.get_by_path("serial0").is_none()); - assert!(fdt.get_by_path("/soc/uart@1000").is_none()); + // 带有和不带斜杠的路径都应该工作 + let result = fdt.remove_node("/test"); + assert!(result.is_ok()); } #[test] - fn test_remove_node_only_exact_matching() { - let mut root = Node::root(); - - // 添加相似名称的节点 - let mut gpio = Node::new("gpio@1000"); - let mut gpio_controller = Node::new("gpio-controller@2000"); - - root.add_child(gpio); - root.add_child(gpio_controller); - - // 测试精确删除：删除 gpio@1000 - let removed = root.remove_by_path("gpio").unwrap(); - // 由于只支持精确匹配，这应该找不到 gpio@1000 - assert!( - removed.is_none(), - "Should not find 'gpio' when only 'gpio@1000' exists" - ); - - // 精确删除 gpio@1000 - let removed = root.remove_by_path("gpio@1000").unwrap(); - assert!(removed.is_some(), "Should find and remove 'gpio@1000'"); - - // 验证只有 gpio-controller@2000 还在 - assert!(root.find_child("gpio@1000").is_none()); - assert!(root.find_child("gpio-controller@2000").is_some()); + fn test_remove_node_preserves_siblings() { + let mut fdt = Fdt::new(); + + // 添加多个兄弟节点 + fdt.root.add_child(Node::new("node1")); + fdt.root.add_child(Node::new("node2")); + fdt.root.add_child(Node::new("node3")); + + // 删除中间节点 + let removed = fdt.remove_node("/node2"); + assert!(removed.is_ok()); + + // 验证其他节点仍然存在 + assert!(fdt.get_by_path("/node1").is_some()); + assert!(fdt.get_by_path("/node2").is_none()); + assert!(fdt.get_by_path("/node3").is_some()); } } diff --git a/fdt-parser/src/cache/node/pci.rs b/fdt-parser/src/cache/node/pci.rs index cbd8cb5..a2ac889 100644 --- a/fdt-parser/src/cache/node/pci.rs +++ b/fdt-parser/src/cache/node/pci.rs @@ -213,8 +213,8 @@ impl Pci { while !data.remain().as_ref().is_empty() { // Parse child bus address (3 cells for PCI) let mut child_addr = [0u32; 3]; - for i in 0..3 { - child_addr[i] = data.take_u32().ok()?; + for addr in child_addr.iter_mut() { + *addr = data.take_u32().ok()?; } // Parse parent bus address (2 cells for 64-bit) @@ -296,9 +296,9 @@ impl Pci { let encoded_address = [child_addr_high, child_addr_mid, child_addr_low]; let mut masked_child_address = Vec::with_capacity(child_addr_cells); - for idx in 0..child_addr_cells { + for (idx, mask) in mask.iter().enumerate().take(child_addr_cells) { let value = *encoded_address.get(idx).unwrap_or(&0); - masked_child_address.push(value & mask[idx]); + masked_child_address.push(value & mask); } let encoded_irq = [pin]; diff --git a/fdt-raw/Cargo.toml b/fdt-raw/Cargo.toml index 7abf98b..f70d8d6 100644 --- a/fdt-raw/Cargo.toml +++ b/fdt-raw/Cargo.toml @@ -1,10 +1,15 @@ [package] authors = ["周睿 "] -categories = ["embedded", "no-std"] -description = "A crate for parsing FDT" -documentation = "https://docs.rs/fdt-parser" +categories = ["embedded", "no-std", "hardware-support"] +description = "A low-level, no-std compatible library for parsing Flattened Device Tree (FDT) binary files" +documentation = "https://docs.rs/fdt-raw" edition = "2024" +exclude = [".git*", "*.md", "tests/"] +keywords = ["device-tree", "dtb", "embedded", "no-std", "bare-metal"] +license = "MIT OR Apache-2.0" name = "fdt-raw" +readme = "README.md" +repository = "https://github.com/drivercraft/fdt-parser" version = "0.1.0" [dependencies] @@ -14,4 +19,12 @@ thiserror = {version = "2", default-features = false} [dev-dependencies] dtb-file = { path = "../dtb-file" } -env_logger = "0.11" \ No newline at end of file +env_logger = "0.11" + +[features] +default = [] +std = [] + +[package.metadata.docs.rs] +all-features = true +targets = ["x86_64-unknown-linux-gnu", "aarch64-unknown-none-softfloat", "riscv64gc-unknown-none-elf"] \ No newline at end of file diff --git a/fdt-raw/README.md b/fdt-raw/README.md new file mode 100644 index 0000000..098463e --- /dev/null +++ b/fdt-raw/README.md @@ -0,0 +1,91 @@ +# fdt-raw + +用于解析设备树二进制文件（DTB）的低级 Rust 库。 + +## 概述 + +`fdt-raw` 是一个基于 [Device Tree Specification v0.4](https://www.devicetree.org/specifications/) 实现的纯 Rust、`#![no_std]` 兼容的设备树解析库。该库提供了对扁平设备树（FDT）结构的底层访问接口，适用于嵌入式系统和裸机开发环境。 + +## 特性 + +- **纯 Rust 实现**：无需 C 语言依赖 +- **`no_std` 兼容**：适用于裸机和嵌入式环境 +- **基于规范**：严格遵循 Device Tree Specification v0.4 +- **零拷贝解析**：直接在原始数据上操作，避免不必要的内存分配 +- **类型安全**：提供强类型的 API 接口 +- **内存高效**：使用 `heapless` 进行无分配器集合操作 + +## 核心组件 + +### Fdt 结构 +主要的 FDT 解析器，提供对设备树结构的访问： +- 头部信息解析 +- 内存保留块遍历 +- 节点树遍历 +- 属性访问 + +### 支持的节点类型 +- **内存节点**：解析内存区域信息 +- **chosen 节点**：访问启动参数 +- **通用节点**：处理其他所有节点类型 + +### 属性解析 +- **reg 属性**：地址范围解析，支持 `#address-cells` 和 `#size-cells` +- **属性迭代器**：高效的属性遍历 +- **属性值访问**：提供各种数据类型的访问方法 + +## 快速开始 + +```rust +use fdt_raw::Fdt; + +// 从字节数据解析 FDT +let fdt = Fdt::from_bytes(&dtb_data)?; + +// 遍历根节点的子节点 +for node in fdt.root().children() { + println!("Node name: {}", node.name()?); + + // 遍历节点属性 + for prop in node.properties() { + println!(" Property: {}", prop.name()?); + } +} + +// 访问内存保留块 +for reservation in fdt.memory_reservations() { + println!("Reserved: 0x{:x} - 0x{:x}", + reservation.address, + reservation.address + reservation.size); +} +``` + +## 依赖 + +- `heapless = "0.9"` - 无分配器集合 +- `log = "0.4"` - 日志记录 +- `thiserror = {version = "2", default-features = false}` - 错误处理 + +## 开发依赖 + +- `dtb-file` - 测试数据 +- `env_logger = "0.11"` - 日志实现 + +## 许可证 + +本项目采用开源许可证，具体许可证类型请查看项目根目录的 LICENSE 文件。 + +## 贡献 + +欢迎提交 Issue 和 Pull Request。请确保： + +1. 代码遵循项目的格式规范（`cargo fmt`） +2. 通过所有测试（`cargo test`） +3. 通过 Clippy 检查（`cargo clippy`） + +## 相关项目 + +- [fdt-parser](../fdt-parser/) - 更高级的缓存式 FDT 解析器 +- [fdt-edit](../fdt-edit/) - FDT 编辑和操作库 +- [dtb-tool](../dtb-tool/) - DTB 文件检查工具 +- [dtb-file](../dtb-file/) - 测试数据包 \ No newline at end of file diff --git a/fdt-raw/src/data.rs b/fdt-raw/src/data.rs index f909119..6791455 100644 --- a/fdt-raw/src/data.rs +++ b/fdt-raw/src/data.rs @@ -1,10 +1,13 @@ -use core::ops::{Deref, Range}; +use core::{ + ffi::CStr, + ops::{Deref, Range}, +}; use crate::define::{FdtError, Token}; #[derive(Clone)] -pub(crate) struct Bytes<'a> { - all: &'a [u8], +pub struct Bytes<'a> { + pub(crate) all: &'a [u8], range: Range, } @@ -23,7 +26,6 @@ impl<'a> Bytes<'a> { range: 0..all.len(), } } - pub fn slice(&self, range: Range) -> Self { assert!(range.end <= self.len()); Self { @@ -54,12 +56,28 @@ impl<'a> Bytes<'a> { iter: 0, } } + + pub fn as_u32_iter(&self) -> U32Iter<'a> { + U32Iter { + reader: self.reader(), + } + } + + pub fn as_str_iter(&self) -> StrIter<'a> { + StrIter { + reader: self.reader(), + } + } + + pub fn is_empty(&self) -> bool { + self.len() == 0 + } } #[derive(Clone)] -pub(crate) struct Reader<'a> { - bytes: Bytes<'a>, - iter: usize, +pub struct Reader<'a> { + pub(crate) bytes: Bytes<'a>, + pub(crate) iter: usize, } impl<'a> Reader<'a> { @@ -71,20 +89,40 @@ impl<'a> Reader<'a> { self.bytes.slice(self.iter..self.bytes.len()) } - pub fn read_bytes(&mut self, size: usize) -> Option<&'a [u8]> { + pub fn read_bytes(&mut self, size: usize) -> Option> { if self.iter + size > self.bytes.len() { return None; } let start = self.iter; self.iter += size; - Some(&self.bytes.all[self.bytes.range.start + start..self.bytes.range.start + start + size]) + Some(self.bytes.slice(start..start + size)) + } + + pub fn read_u32(&mut self) -> Option { + let bytes = self.read_bytes(4)?; + Some(u32::from_be_bytes(bytes.as_slice().try_into().unwrap())) + } + + pub fn read_u64(&mut self) -> Option { + let high = self.read_u32()? as u64; + let low = self.read_u32()? as u64; + Some((high << 32) | low) + } + + pub fn read_cells(&mut self, cell_count: usize) -> Option { + let mut value: u64 = 0; + for _ in 0..cell_count { + let cell = self.read_u32()? as u64; + value = (value << 32) | cell; + } + Some(value) } pub fn read_token(&mut self) -> Result { let bytes = self.read_bytes(4).ok_or(FdtError::BufferTooSmall { pos: self.position(), })?; - Ok(u32::from_be_bytes(bytes.try_into().unwrap()).into()) + Ok(u32::from_be_bytes(bytes.as_slice().try_into().unwrap()).into()) } pub fn backtrack(&mut self, size: usize) { @@ -92,3 +130,40 @@ impl<'a> Reader<'a> { self.iter -= size; } } + +#[derive(Clone)] +pub struct U32Iter<'a> { + pub reader: Reader<'a>, +} + +impl Iterator for U32Iter<'_> { + type Item = u32; + + fn next(&mut self) -> Option { + let bytes = self.reader.read_bytes(4)?; + Some(u32::from_be_bytes(bytes.as_slice().try_into().unwrap())) + } +} + +#[derive(Clone)] +pub struct StrIter<'a> { + pub reader: Reader<'a>, +} + +impl<'a> Iterator for StrIter<'a> { + type Item = &'a str; + + fn next(&mut self) -> Option { + let remain = self.reader.remain(); + if remain.is_empty() { + return None; + } + let s = CStr::from_bytes_until_nul(remain.as_slice()) + .ok()? + .to_str() + .ok()?; + let str_len = s.len() + 1; // 包括 null 终止符 + self.reader.read_bytes(str_len)?; // 移动读取位置 + Some(s) + } +} diff --git a/fdt-raw/src/define.rs b/fdt-raw/src/define.rs index 0f0135c..c1f41be 100644 --- a/fdt-raw/src/define.rs +++ b/fdt-raw/src/define.rs @@ -1,10 +1,18 @@ use core::{ ffi::FromBytesUntilNulError, fmt::{Debug, Display}, + ops::Deref, }; pub const FDT_MAGIC: u32 = 0xd00dfeed; +/// Memory reservation block entry +#[derive(Clone, Debug, Default)] +pub struct MemoryReservation { + pub address: u64, + pub size: u64, +} + #[derive(Debug, PartialEq, Eq, Clone, Copy)] pub enum Token { BeginNode, @@ -47,6 +55,23 @@ pub enum Status { Disabled, } +impl Deref for Status { + type Target = str; + + fn deref(&self) -> &Self::Target { + match self { + Status::Okay => "okay", + Status::Disabled => "disabled", + } + } +} + +impl core::fmt::Display for Status { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + write!(f, "{}", self.deref()) + } +} + #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[repr(transparent)] pub struct Phandle(u32); @@ -60,6 +85,10 @@ impl Phandle { pub fn as_usize(&self) -> usize { self.0 as usize } + + pub fn raw(&self) -> u32 { + self.0 + } } impl Display for Phandle { diff --git a/fdt-raw/src/fdt.rs b/fdt-raw/src/fdt.rs index 154ba5d..7ae805b 100644 --- a/fdt-raw/src/fdt.rs +++ b/fdt-raw/src/fdt.rs @@ -1,6 +1,40 @@ use core::fmt; -use crate::{FdtError, data::Bytes, header::Header, iter::FdtIter}; +use crate::{FdtError, MemoryReservation, data::Bytes, header::Header, iter::FdtIter}; + +/// Memory reservation block iterator +pub struct MemoryReservationIter<'a> { + data: &'a [u8], + offset: usize, +} + +impl<'a> Iterator for MemoryReservationIter<'a> { + type Item = MemoryReservation; + + fn next(&mut self) -> Option { + // 确保我们有足够的数据来读取地址和大小（各8字节） + if self.offset + 16 > self.data.len() { + return None; + } + + // 读取地址（8字节，大端序） + let address_bytes = &self.data[self.offset..self.offset + 8]; + let address = u64::from_be_bytes(address_bytes.try_into().unwrap()); + self.offset += 8; + + // 读取大小（8字节，大端序） + let size_bytes = &self.data[self.offset..self.offset + 8]; + let size = u64::from_be_bytes(size_bytes.try_into().unwrap()); + self.offset += 8; + + // 检查是否到达终止符（地址和大小都为0） + if address == 0 && size == 0 { + return None; + } + + Some(MemoryReservation { address, size }) + } +} /// 写入缩进（使用空格） fn write_indent(f: &mut fmt::Formatter<'_>, count: usize, ch: &str) -> fmt::Result { @@ -26,6 +60,7 @@ impl<'a> Fdt<'a> { }); } let buffer = Bytes::new(data); + Ok(Fdt { header, data: buffer, @@ -42,7 +77,8 @@ impl<'a> Fdt<'a> { pub unsafe fn from_ptr(ptr: *mut u8) -> Result, FdtError> { let header = unsafe { Header::from_ptr(ptr)? }; - let data = Bytes::new(unsafe { core::slice::from_raw_parts(ptr, header.totalsize as _) }); + let data_slice = unsafe { core::slice::from_raw_parts(ptr, header.totalsize as _) }; + let data = Bytes::new(data_slice); Ok(Fdt { header, data }) } @@ -58,6 +94,14 @@ impl<'a> Fdt<'a> { pub fn all_nodes(&self) -> FdtIter<'a> { FdtIter::new(self.clone()) } + + /// Get an iterator over memory reservation entries + pub fn memory_reservations(&self) -> MemoryReservationIter<'a> { + MemoryReservationIter { + data: self.data.as_slice(), + offset: self.header.off_mem_rsvmap as usize, + } + } } impl fmt::Display for Fdt<'_> { @@ -134,81 +178,27 @@ impl fmt::Debug for Fdt<'_> { // 打印属性 for prop in node.properties() { write_indent(f, level + 3, "\t")?; - // 使用 Debug 格式展示解析后的属性 - match &prop { - crate::Property::Reg(reg) => { - write!(f, "reg: [")?; - for (i, info) in reg.iter().enumerate() { - if i > 0 { - write!(f, ", ")?; - } - write!(f, "{{addr: {:#x}, size: {:?}}}", info.address, info.size)?; - } - writeln!(f, "]")?; - } - - crate::Property::Compatible(iter) => { - write!(f, "compatible: [")?; - for (i, s) in iter.clone().enumerate() { - if i > 0 { - write!(f, ", ")?; - } - write!(f, "\"{}\"", s)?; - } - writeln!(f, "]")?; - } - crate::Property::AddressCells(v) => { - writeln!(f, "#address-cells: {}", v)?; - } - crate::Property::SizeCells(v) => { - writeln!(f, "#size-cells: {}", v)?; - } - crate::Property::InterruptCells(v) => { - writeln!(f, "#interrupt-cells: {}", v)?; - } - crate::Property::Model(s) => { - writeln!(f, "model: \"{}\"", s)?; - } - crate::Property::DeviceType(s) => { - writeln!(f, "device_type: \"{}\"", s)?; - } - crate::Property::Status(s) => { - writeln!(f, "status: {:?}", s)?; - } - crate::Property::Phandle(p) => { - writeln!(f, "phandle: {}", p)?; - } - crate::Property::LinuxPhandle(p) => { - writeln!(f, "linux,phandle: {}", p)?; - } - crate::Property::InterruptParent(p) => { - writeln!(f, "interrupt-parent: {}", p)?; - } - - crate::Property::ClockNames(iter) => { - write!(f, "clock-names: [")?; - for (i, s) in iter.clone().enumerate() { - if i > 0 { - write!(f, ", ")?; - } - write!(f, "\"{}\"", s)?; - } - writeln!(f, "]")?; - } - crate::Property::DmaCoherent => { - writeln!(f, "dma-coherent")?; - } - crate::Property::Unknown(raw) => { - if raw.is_empty() { - writeln!(f, "{}", raw.name())?; - } else if let Some(s) = raw.as_str() { - writeln!(f, "{}: \"{}\"", raw.name(), s)?; - } else if raw.len() == 4 { - let v = u32::from_be_bytes(raw.data().try_into().unwrap()); - writeln!(f, "{}: {:#x}", raw.name(), v)?; - } else { - writeln!(f, "{}: <{} bytes>", raw.name(), raw.len())?; - } + if let Some(v) = prop.as_address_cells() { + writeln!(f, "#address-cells: {}", v)?; + } else if let Some(v) = prop.as_size_cells() { + writeln!(f, "#size-cells: {}", v)?; + } else if let Some(v) = prop.as_interrupt_cells() { + writeln!(f, "#interrupt-cells: {}", v)?; + } else if let Some(s) = prop.as_status() { + writeln!(f, "status: {:?}", s)?; + } else if let Some(p) = prop.as_phandle() { + writeln!(f, "phandle: {}", p)?; + } else { + // 默认处理未知属性 + if prop.is_empty() { + writeln!(f, "{}", prop.name())?; + } else if let Some(s) = prop.as_str() { + writeln!(f, "{}: \"{}\"", prop.name(), s)?; + } else if prop.len() == 4 { + let v = u32::from_be_bytes(prop.data().as_slice().try_into().unwrap()); + writeln!(f, "{}: {:#x}", prop.name(), v)?; + } else { + writeln!(f, "{}: <{} bytes>", prop.name(), prop.len())?; } } } @@ -217,3 +207,48 @@ impl fmt::Debug for Fdt<'_> { writeln!(f, "}}") } } + +#[cfg(test)] +mod tests { + use super::*; + use heapless::Vec; + + #[test] + fn test_memory_reservation_iterator() { + // 创建一个简单的测试数据：一个内存保留条目 + 终止符 + let mut test_data = [0u8; 32]; + + // 地址: 0x80000000, 大小: 0x10000000 (256MB) + test_data[0..8].copy_from_slice(&0x80000000u64.to_be_bytes()); + test_data[8..16].copy_from_slice(&0x10000000u64.to_be_bytes()); + // 终止符: address=0, size=0 + test_data[16..24].copy_from_slice(&0u64.to_be_bytes()); + test_data[24..32].copy_from_slice(&0u64.to_be_bytes()); + + let iter = MemoryReservationIter { + data: &test_data, + offset: 0, + }; + + let reservations: Vec = iter.collect(); + assert_eq!(reservations.len(), 1); + assert_eq!(reservations[0].address, 0x80000000); + assert_eq!(reservations[0].size, 0x10000000); + } + + #[test] + fn test_empty_memory_reservation_iterator() { + // 只有终止符 + let mut test_data = [0u8; 16]; + test_data[0..8].copy_from_slice(&0u64.to_be_bytes()); + test_data[8..16].copy_from_slice(&0u64.to_be_bytes()); + + let iter = MemoryReservationIter { + data: &test_data, + offset: 0, + }; + + let reservations: Vec = iter.collect(); + assert_eq!(reservations.len(), 0); + } +} diff --git a/fdt-raw/src/iter.rs b/fdt-raw/src/iter.rs index 1792fc0..72f49f7 100644 --- a/fdt-raw/src/iter.rs +++ b/fdt-raw/src/iter.rs @@ -150,7 +150,7 @@ impl<'a> Iterator for FdtIter<'a> { } } - return Some(node); + return Some(node.into()); } Err(e) => { self.handle_error(e); diff --git a/fdt-raw/src/lib.rs b/fdt-raw/src/lib.rs index cbbac26..5376c6e 100644 --- a/fdt-raw/src/lib.rs +++ b/fdt-raw/src/lib.rs @@ -1,6 +1,6 @@ #![no_std] -mod data; +pub mod data; mod define; mod fdt; mod header; diff --git a/fdt-raw/src/node/chosen.rs b/fdt-raw/src/node/chosen.rs new file mode 100644 index 0000000..c1be43c --- /dev/null +++ b/fdt-raw/src/node/chosen.rs @@ -0,0 +1,47 @@ +use core::ops::Deref; + +use super::NodeBase; + +/// Chosen 节点，包含启动参数等信息 +#[derive(Clone)] +pub struct Chosen<'a> { + node: NodeBase<'a>, +} + +impl<'a> Chosen<'a> { + pub(crate) fn new(node: NodeBase<'a>) -> Self { + Self { node } + } + + /// 获取 bootargs 属性 + pub fn bootargs(&self) -> Option<&'a str> { + self.node.find_property_str("bootargs") + } + + /// 获取 stdout-path 属性 + pub fn stdout_path(&self) -> Option<&'a str> { + self.node.find_property_str("stdout-path") + } + + /// 获取 stdin-path 属性 + pub fn stdin_path(&self) -> Option<&'a str> { + self.node.find_property_str("stdin-path") + } +} + +impl<'a> Deref for Chosen<'a> { + type Target = NodeBase<'a>; + + fn deref(&self) -> &Self::Target { + &self.node + } +} + +impl core::fmt::Debug for Chosen<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.debug_struct("Chosen") + .field("bootargs", &self.bootargs()) + .field("stdout_path", &self.stdout_path()) + .finish() + } +} diff --git a/fdt-raw/src/node/memory.rs b/fdt-raw/src/node/memory.rs new file mode 100644 index 0000000..fdcc3b7 --- /dev/null +++ b/fdt-raw/src/node/memory.rs @@ -0,0 +1,71 @@ +use core::ops::Deref; + +use super::NodeBase; + +/// 内存区域信息 +#[derive(Debug, Clone, Copy)] +pub struct MemoryRegion { + /// 起始地址 + pub address: u64, + /// 区域大小 + pub size: u64, +} + +/// Memory 节点，描述物理内存布局 +#[derive(Clone)] +pub struct Memory<'a> { + node: NodeBase<'a>, +} + +impl<'a> Memory<'a> { + pub(crate) fn new(node: NodeBase<'a>) -> Self { + Self { node } + } + + /// 获取内存区域迭代器 + /// + /// Memory 节点的 reg 属性描述了物理内存的布局 + pub fn regions(&self) -> impl Iterator + 'a { + self.node.reg().into_iter().flat_map(|reg| { + reg.map(|info| MemoryRegion { + address: info.address, + size: info.size.unwrap_or(0), + }) + }) + } + + /// 获取所有内存区域（使用固定大小数组） + pub fn regions_array(&self) -> heapless::Vec { + let mut result = heapless::Vec::new(); + for region in self.regions() { + if result.push(region).is_err() { + break; + } + } + result + } + + /// 计算总内存大小 + pub fn total_size(&self) -> u64 { + self.regions().map(|r| r.size).sum() + } +} + +impl<'a> Deref for Memory<'a> { + type Target = NodeBase<'a>; + + fn deref(&self) -> &Self::Target { + &self.node + } +} + +impl core::fmt::Debug for Memory<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut st = f.debug_struct("Memory"); + st.field("name", &self.node.name()); + for region in self.regions() { + st.field("region", ®ion); + } + st.finish() + } +} diff --git a/fdt-raw/src/node/mod.rs b/fdt-raw/src/node/mod.rs index f30a179..36af684 100644 --- a/fdt-raw/src/node/mod.rs +++ b/fdt-raw/src/node/mod.rs @@ -1,14 +1,19 @@ use core::ffi::CStr; use core::fmt; +use core::ops::Deref; use crate::{ FdtError, Token, data::{Bytes, Reader}, }; +mod chosen; +mod memory; mod prop; -pub use prop::{PropIter, Property, Reg, RegInfo, RegIter, StrIter, U32Iter}; +pub use chosen::Chosen; +pub use memory::{Memory, MemoryRegion}; +pub use prop::{PropIter, Property, RegInfo, RegIter}; /// 节点上下文，保存从父节点继承的信息 #[derive(Debug, Clone)] @@ -29,8 +34,9 @@ impl Default for NodeContext { } } +/// 基础节点结构 #[derive(Clone)] -pub struct Node<'a> { +pub struct NodeBase<'a> { name: &'a str, data: Bytes<'a>, strings: Bytes<'a>, @@ -43,7 +49,7 @@ pub struct Node<'a> { pub context: NodeContext, } -impl<'a> Node<'a> { +impl<'a> NodeBase<'a> { pub fn name(&self) -> &'a str { self.name } @@ -52,16 +58,6 @@ impl<'a> Node<'a> { self.level } - /// 获取用于解析当前节点 reg 属性的 address cells - pub fn reg_address_cells(&self) -> u8 { - self.context.parent_address_cells - } - - /// 获取用于解析当前节点 reg 属性的 size cells - pub fn reg_size_cells(&self) -> u8 { - self.context.parent_size_cells - } - /// 为子节点创建上下文 pub(crate) fn create_child_context(&self) -> NodeContext { NodeContext { @@ -72,28 +68,37 @@ impl<'a> Node<'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()) + } + + /// 查找指定名称的属性 + pub fn find_property(&self, name: &str) -> Option> { + self.properties().find(|p| p.name() == name) + } + + /// 查找指定名称的字符串属性 + pub fn find_property_str(&self, name: &str) -> Option<&'a str> { + let prop = self.find_property(name)?; + + // 否则作为普通字符串处理 + prop.as_str() } /// 查找并解析 reg 属性，返回 Reg 迭代器 - pub fn reg(&self) -> Option> { - for prop in self.properties() { - if let Property::Reg(reg) = prop { - return Some(reg); - } - } - None + pub fn reg(&self) -> Option> { + let prop = self.find_property("reg")?; + Some(RegIter::new( + prop.data().reader(), + self.context.parent_address_cells, + self.context.parent_size_cells, + )) } /// 查找并解析 reg 属性，返回所有 RegInfo 条目 pub fn reg_array(&self) -> heapless::Vec { let mut result = heapless::Vec::new(); if let Some(reg) = self.reg() { - for info in reg.iter() { + for info in reg { if result.push(info).is_err() { break; // 数组已满 } @@ -101,6 +106,16 @@ impl<'a> Node<'a> { } result } + + /// 检查是否是 chosen 节点 + fn is_chosen(&self) -> bool { + self.name == "chosen" + } + + /// 检查是否是 memory 节点 + fn is_memory(&self) -> bool { + self.name.starts_with("memory") + } } /// 写入缩进 @@ -111,7 +126,7 @@ fn write_indent(f: &mut fmt::Formatter<'_>, count: usize, ch: &str) -> fmt::Resu Ok(()) } -impl fmt::Display for Node<'_> { +impl fmt::Display for NodeBase<'_> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write_indent(f, self.level, " ")?; let name = if self.name.is_empty() { "/" } else { self.name }; @@ -126,6 +141,86 @@ impl fmt::Display for Node<'_> { } } +// ============================================================================ +// Node 枚举：支持特化节点类型 +// ============================================================================ + +/// 节点枚举，支持 General、Chosen、Memory 等特化类型 +#[derive(Clone)] +pub enum Node<'a> { + /// 通用节点 + General(NodeBase<'a>), + /// Chosen 节点，包含启动参数 + Chosen(Chosen<'a>), + /// Memory 节点，描述物理内存布局 + Memory(Memory<'a>), +} + +impl<'a> Node<'a> { + /// 获取底层的 NodeBase 引用 + pub fn as_base(&self) -> &NodeBase<'a> { + self.deref() + } + + /// 尝试转换为 Chosen 节点 + pub fn as_chosen(&self) -> Option<&Chosen<'a>> { + if let Node::Chosen(c) = self { + Some(c) + } else { + None + } + } + + /// 尝试转换为 Memory 节点 + pub fn as_memory(&self) -> Option<&Memory<'a>> { + if let Node::Memory(m) = self { + Some(m) + } else { + None + } + } +} + +impl<'a> From> for Node<'a> { + fn from(node: NodeBase<'a>) -> Self { + if node.is_chosen() { + Node::Chosen(Chosen::new(node)) + } else if node.is_memory() { + Node::Memory(Memory::new(node)) + } else { + Node::General(node) + } + } +} + +impl<'a> Deref for Node<'a> { + type Target = NodeBase<'a>; + + fn deref(&self) -> &Self::Target { + match self { + Node::General(n) => n, + Node::Chosen(c) => c.deref(), + Node::Memory(m) => m.deref(), + } + } +} + +impl fmt::Display for Node<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.as_base().fmt(f) + } +} + +impl fmt::Debug for Node<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Node::General(n) => f.debug_tuple("General").field(&n.name()).finish(), + Node::Chosen(c) => c.fmt(f), + Node::Memory(m) => m.fmt(f), + } + } +} + /// 解析属性时提取的关键信息 #[derive(Debug, Clone, Default)] pub(crate) struct ParsedProps { @@ -176,7 +271,7 @@ impl<'a> OneNodeIter<'a> { } /// 读取节点名称（在 BeginNode token 之后调用） - pub fn read_node_name(&mut self) -> Result, FdtError> { + pub fn read_node_name(&mut self) -> Result, FdtError> { // 读取以 null 结尾的名称字符串 let name = self.read_cstr()?; @@ -185,7 +280,7 @@ impl<'a> OneNodeIter<'a> { let data = self.reader.remain(); - Ok(Node { + Ok(NodeBase { name, data, strings: self.strings.clone(), @@ -244,16 +339,13 @@ impl<'a> OneNodeIter<'a> { } Token::Prop => { // 读取属性：len 和 nameoff - let len_bytes = self.reader.read_bytes(4).ok_or(FdtError::BufferTooSmall { + let len = self.reader.read_u32().ok_or(FdtError::BufferTooSmall { pos: self.reader.position(), - })?; - let len = u32::from_be_bytes(len_bytes.try_into().unwrap()) as usize; + })? as usize; - let nameoff_bytes = - self.reader.read_bytes(4).ok_or(FdtError::BufferTooSmall { - pos: self.reader.position(), - })?; - let nameoff = u32::from_be_bytes(nameoff_bytes.try_into().unwrap()); + let nameoff = self.reader.read_u32().ok_or(FdtError::BufferTooSmall { + pos: self.reader.position(), + })?; // 读取属性数据 let prop_data = if len > 0 { @@ -263,7 +355,7 @@ impl<'a> OneNodeIter<'a> { pos: self.reader.position(), })? } else { - &[] + Bytes::new(&[]) }; // 解析关键属性 @@ -271,11 +363,11 @@ impl<'a> OneNodeIter<'a> { match prop_name { "#address-cells" if len == 4 => { self.parsed_props.address_cells = - Some(Self::read_u32_be(prop_data, 0) as u8); + Some(Self::read_u32_be(&prop_data, 0) as u8); } "#size-cells" if len == 4 => { self.parsed_props.size_cells = - Some(Self::read_u32_be(prop_data, 0) as u8); + Some(Self::read_u32_be(&prop_data, 0) as u8); } _ => {} } diff --git a/fdt-raw/src/node/prop/mod.rs b/fdt-raw/src/node/prop/mod.rs index 19c62aa..05baa93 100644 --- a/fdt-raw/src/node/prop/mod.rs +++ b/fdt-raw/src/node/prop/mod.rs @@ -7,23 +7,22 @@ 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}, + data::{Bytes, Reader, StrIter, U32Iter}, }; /// 通用属性，包含名称和原始数据 #[derive(Clone)] -pub struct RawProperty<'a> { +pub struct Property<'a> { name: &'a str, - data: &'a [u8], + data: Bytes<'a>, } -impl<'a> RawProperty<'a> { - pub fn new(name: &'a str, data: &'a [u8]) -> Self { +impl<'a> Property<'a> { + pub fn new(name: &'a str, data: Bytes<'a>) -> Self { Self { name, data } } @@ -31,8 +30,8 @@ impl<'a> RawProperty<'a> { self.name } - pub fn data(&self) -> &'a [u8] { - self.data + pub fn data(&self) -> Bytes<'a> { + self.data.clone() } pub fn is_empty(&self) -> bool { @@ -45,247 +44,192 @@ impl<'a> RawProperty<'a> { /// 作为 u32 迭代器 pub fn as_u32_iter(&self) -> U32Iter<'a> { - U32Iter::new(self.data) + self.data.as_u32_iter() } /// 作为字符串迭代器（用于 compatible 等属性） pub fn as_str_iter(&self) -> StrIter<'a> { - StrIter { data: self.data } + self.data.as_str_iter() + } + + /// 获取数据作为字节切片 + pub fn as_slice(&self) -> &[u8] { + self.data.as_slice() } /// 作为单个 u64 值 pub fn as_u64(&self) -> Option { - if self.data.len() != 8 { + let mut iter = self.as_u32_iter(); + let high = iter.next()? as u64; + let low = iter.next()? as u64; + if iter.next().is_some() { return None; } - Some(u64::from_be_bytes(self.data.try_into().unwrap())) + Some((high << 32) | low) } /// 作为单个 u32 值 pub fn as_u32(&self) -> Option { - if self.data.len() != 4 { + let mut iter = self.as_u32_iter(); + let value = iter.next()?; + if iter.next().is_some() { return None; } - Some(u32::from_be_bytes(self.data.try_into().unwrap())) + Some(value) } /// 作为字符串 pub fn as_str(&self) -> Option<&'a str> { - if self.data.is_empty() { - return None; - } - // 去除尾部的 null 终止符 - let data = if self.data.last() == Some(&0) { - &self.data[..self.data.len() - 1] + let bytes = self.data.as_slice(); + let cstr = CStr::from_bytes_until_nul(bytes).ok()?; + cstr.to_str().ok() + } + + /// 获取为 #address-cells 值 + pub fn as_address_cells(&self) -> Option { + if self.name == "#address-cells" { + self.as_u32().map(|v| v as u8) } else { - self.data - }; - core::str::from_utf8(data).ok() + None + } } -} -/// 类型化属性枚举 -#[derive(Clone)] -pub enum Property<'a> { - /// #address-cells 属性 - AddressCells(u8), - /// #size-cells 属性 - SizeCells(u8), - /// reg 属性（已解析） - Reg(Reg<'a>), - /// compatible 属性（字符串列表） - Compatible(StrIter<'a>), - /// model 属性 - Model(&'a str), - /// status 属性 - Status(Status), - /// phandle 属性 - Phandle(Phandle), - /// linux,phandle 属性 - LinuxPhandle(Phandle), - /// device_type 属性 - DeviceType(&'a str), - /// interrupt-parent 属性 - InterruptParent(Phandle), - /// interrupt-cells 属性 - InterruptCells(u8), - /// clock-names 属性 - ClockNames(StrIter<'a>), - /// dma-coherent 属性（无数据） - DmaCoherent, - /// 未识别的通用属性 - Unknown(RawProperty<'a>), -} + /// 获取为 #size-cells 值 + pub fn as_size_cells(&self) -> Option { + if self.name == "#size-cells" { + self.as_u32().map(|v| v as u8) + } else { + None + } + } -impl<'a> Property<'a> { - /// 获取属性名称 - pub fn name(&self) -> &str { - match self { - Property::AddressCells(_) => "#address-cells", - Property::SizeCells(_) => "#size-cells", - Property::Reg(_) => "reg", - Property::Compatible(_) => "compatible", - Property::Model(_) => "model", - Property::Status(_) => "status", - Property::Phandle(_) => "phandle", - Property::LinuxPhandle(_) => "linux,phandle", - Property::DeviceType(_) => "device_type", - Property::InterruptParent(_) => "interrupt-parent", - Property::InterruptCells(_) => "#interrupt-cells", - Property::ClockNames(_) => "clock-names", - Property::DmaCoherent => "dma-coherent", - Property::Unknown(raw) => raw.name(), + /// 获取为 #interrupt-cells 值 + pub fn as_interrupt_cells(&self) -> Option { + if self.name == "#interrupt-cells" { + self.as_u32().map(|v| v as u8) + } else { + None } } - /// 从名称和数据创建类型化属性 - fn from_raw(name: &'a str, data: &'a [u8], context: &NodeContext) -> Self { - match name { - "#address-cells" => { - if data.len() == 4 { - let val = u32::from_be_bytes(data.try_into().unwrap()) as u8; - Property::AddressCells(val) - } else { - Property::Unknown(RawProperty::new(name, data)) - } - } - "#size-cells" => { - if data.len() == 4 { - let val = u32::from_be_bytes(data.try_into().unwrap()) as u8; - Property::SizeCells(val) - } else { - Property::Unknown(RawProperty::new(name, data)) - } - } - "#interrupt-cells" => { - if data.len() == 4 { - let val = u32::from_be_bytes(data.try_into().unwrap()) as u8; - Property::InterruptCells(val) - } else { - Property::Unknown(RawProperty::new(name, data)) - } - } - "reg" => { - // 使用 context 中的 cells 信息解析 reg - let reg = Reg::new( - data, - context.parent_address_cells, - context.parent_size_cells, - ); - Property::Reg(reg) - } - "compatible" => Property::Compatible(StrIter { data }), - "model" => { - if let Some(s) = Self::parse_str(data) { - Property::Model(s) - } else { - Property::Unknown(RawProperty::new(name, data)) - } - } - "status" => { - if let Some(s) = Self::parse_str(data) { - match s { - "okay" | "ok" => Property::Status(Status::Okay), - "disabled" => Property::Status(Status::Disabled), - _ => Property::Unknown(RawProperty::new(name, data)), - } - } else { - Property::Unknown(RawProperty::new(name, data)) - } - } - "phandle" => { - if data.len() == 4 { - let val = u32::from_be_bytes(data.try_into().unwrap()); - Property::Phandle(Phandle::from(val)) - } else { - Property::Unknown(RawProperty::new(name, data)) - } - } - "linux,phandle" => { - if data.len() == 4 { - let val = u32::from_be_bytes(data.try_into().unwrap()); - Property::LinuxPhandle(Phandle::from(val)) - } else { - Property::Unknown(RawProperty::new(name, data)) - } - } - "device_type" => { - if let Some(s) = Self::parse_str(data) { - Property::DeviceType(s) - } else { - Property::Unknown(RawProperty::new(name, data)) - } - } - "interrupt-parent" => { - if data.len() == 4 { - let val = u32::from_be_bytes(data.try_into().unwrap()); - Property::InterruptParent(Phandle::from(val)) - } else { - Property::Unknown(RawProperty::new(name, data)) - } + /// 获取为 status 枚举 + pub fn as_status(&self) -> Option { + let v = self.as_str()?; + if self.name == "status" { + match v { + "okay" | "ok" => Some(Status::Okay), + "disabled" => Some(Status::Disabled), + _ => None, } + } else { + None + } + } - "clock-names" => Property::ClockNames(StrIter { data }), - "dma-coherent" => Property::DmaCoherent, - _ => Property::Unknown(RawProperty::new(name, data)), + /// 获取为 phandle + pub fn as_phandle(&self) -> Option { + if self.name == "phandle" { + self.as_u32().map(Phandle::from) + } else { + None } } - /// 解析字符串（去除 null 终止符） - fn parse_str(data: &[u8]) -> Option<&str> { - if data.is_empty() { - return None; + /// 获取为 device_type 字符串 + pub fn as_device_type(&self) -> Option<&'a str> { + if self.name == "device_type" { + self.as_str() + } else { + None + } + } + + /// 获取为 interrupt-parent + pub fn as_interrupt_parent(&self) -> Option { + if self.name == "interrupt-parent" { + self.as_u32().map(Phandle::from) + } else { + None } - let data = if data.last() == Some(&0) { - &data[..data.len() - 1] + } + + /// 获取为 clock-names 字符串列表 + pub fn as_clock_names(&self) -> Option> { + if self.name == "clock-names" { + Some(self.as_str_iter()) } else { - data - }; - core::str::from_utf8(data).ok() + None + } } - /// 尝试获取为通用属性 - pub fn as_raw(&self) -> Option<&RawProperty<'a>> { - match self { - Property::Unknown(raw) => Some(raw), - _ => None, + /// 获取为 compatible 字符串列表 + pub fn as_compatible(&self) -> Option> { + if self.name == "compatible" { + Some(self.as_str_iter()) + } else { + None } } + + /// 是否为 dma-coherent 属性 + pub fn is_dma_coherent(&self) -> bool { + self.name == "dma-coherent" && self.data.is_empty() + } } impl fmt::Display for Property<'_> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - Property::AddressCells(v) => write!(f, "#address-cells = <{:#x}>", v), - Property::SizeCells(v) => write!(f, "#size-cells = <{:#x}>", v), - Property::InterruptCells(v) => write!(f, "#interrupt-cells = <{:#x}>", v), - Property::Reg(reg) => { - write!(f, "reg = ")?; - format_bytes(f, reg.as_slice()) + if self.is_empty() { + write!(f, "{}", self.name()) + } else if let Some(v) = self.as_address_cells() { + write!(f, "#address-cells = <{:#x}>", v) + } else if let Some(v) = self.as_size_cells() { + write!(f, "#size-cells = <{:#x}>", v) + } else if let Some(v) = self.as_interrupt_cells() { + write!(f, "#interrupt-cells = <{:#x}>", v) + } else if self.name() == "reg" { + // reg 属性需要特殊处理，但我们没有 context 信息 + // 直接显示原始数据 + write!(f, "reg = ")?; + format_bytes(f, &self.data()) + } else if let Some(s) = self.as_status() { + write!(f, "status = \"{:?}\"", s) + } else if let Some(p) = self.as_phandle() { + write!(f, "phandle = {}", p) + } else if let Some(p) = self.as_interrupt_parent() { + write!(f, "interrupt-parent = {}", p) + } else if let Some(s) = self.as_device_type() { + write!(f, "device_type = \"{}\"", s) + } else if let Some(iter) = self.as_compatible() { + write!(f, "compatible = ")?; + let mut first = true; + for s in iter.clone() { + if !first { + write!(f, ", ")?; + } + write!(f, "\"{}\"", s)?; + first = false; } - - Property::Compatible(iter) => { - write!(f, "compatible = ")?; - let mut first = true; - for s in iter.clone() { - if !first { - write!(f, ", ")?; - } - write!(f, "\"{}\"", s)?; - first = false; + Ok(()) + } else if let Some(iter) = self.as_clock_names() { + write!(f, "clock-names = ")?; + let mut first = true; + for s in iter.clone() { + if !first { + write!(f, ", ")?; } - Ok(()) + write!(f, "\"{}\"", s)?; + first = false; } - Property::Model(s) => write!(f, "model = \"{}\"", s), - Property::DeviceType(s) => write!(f, "device_type = \"{}\"", s), - Property::Status(s) => write!(f, "status = \"{:?}\"", s), - Property::Phandle(p) => write!(f, "phandle = {}", p), - Property::LinuxPhandle(p) => write!(f, "linux,phandle = {}", p), - Property::InterruptParent(p) => write!(f, "interrupt-parent = {}", p), - Property::ClockNames(iter) => { - write!(f, "clock-names = ")?; + Ok(()) + } else if self.is_dma_coherent() { + write!(f, "dma-coherent") + } else if let Some(s) = self.as_str() { + // 检查是否有多个字符串 + if self.data().iter().filter(|&&b| b == 0).count() > 1 { + write!(f, "{} = ", self.name())?; let mut first = true; - for s in iter.clone() { + for s in self.as_str_iter() { if !first { write!(f, ", ")?; } @@ -293,37 +237,17 @@ impl fmt::Display for Property<'_> { first = false; } Ok(()) + } else { + write!(f, "{} = \"{}\"", self.name(), s) } - Property::DmaCoherent => write!(f, "dma-coherent"), - Property::Unknown(raw) => { - if raw.is_empty() { - write!(f, "{}", raw.name()) - } else if let Some(s) = raw.as_str() { - // 检查是否有多个字符串 - if raw.data().iter().filter(|&&b| b == 0).count() > 1 { - write!(f, "{} = ", raw.name())?; - let mut first = true; - for s in raw.as_str_iter() { - if !first { - write!(f, ", ")?; - } - write!(f, "\"{}\"", s)?; - first = false; - } - Ok(()) - } else { - write!(f, "{} = \"{}\"", raw.name(), s) - } - } else if raw.len() == 4 { - // 单个 u32 - let v = u32::from_be_bytes(raw.data().try_into().unwrap()); - write!(f, "{} = <{:#x}>", raw.name(), v) - } else { - // 原始字节 - write!(f, "{} = ", raw.name())?; - format_bytes(f, raw.data()) - } - } + } else if self.len() == 4 { + // 单个 u32 + let v = u32::from_be_bytes(self.data().as_slice().try_into().unwrap()); + write!(f, "{} = <{:#x}>", self.name(), v) + } else { + // 原始字节 + write!(f, "{} = ", self.name())?; + format_bytes(f, &self.data()) } } } @@ -360,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, } } @@ -422,7 +345,7 @@ impl<'a> Iterator for PropIter<'a> { match token { Token::Prop => { // 读取属性长度 - let len_bytes = match self.reader.read_bytes(4) { + let len = match self.reader.read_u32() { Some(b) => b, None => { self.handle_error(FdtError::BufferTooSmall { @@ -431,10 +354,9 @@ impl<'a> Iterator for PropIter<'a> { return None; } }; - let len = u32::from_be_bytes(len_bytes.try_into().unwrap()) as usize; // 读取属性名偏移 - let nameoff_bytes = match self.reader.read_bytes(4) { + let nameoff = match self.reader.read_u32() { Some(b) => b, None => { self.handle_error(FdtError::BufferTooSmall { @@ -443,11 +365,10 @@ impl<'a> Iterator for PropIter<'a> { return None; } }; - let nameoff = u32::from_be_bytes(nameoff_bytes.try_into().unwrap()); // 读取属性数据 let prop_data = if len > 0 { - match self.reader.read_bytes(len) { + match self.reader.read_bytes(len as _) { Some(b) => b, None => { self.handle_error(FdtError::BufferTooSmall { @@ -457,7 +378,7 @@ impl<'a> Iterator for PropIter<'a> { } } } else { - &[] + Bytes::new(&[]) }; // 读取属性名 @@ -472,7 +393,7 @@ impl<'a> Iterator for PropIter<'a> { // 对齐到 4 字节边界 self.align4(); - return Some(Property::from_raw(name, prop_data, &self.context)); + return Some(Property::new(name, prop_data)); } Token::BeginNode | Token::EndNode | Token::End => { // 遇到节点边界，回溯并终止属性迭代 @@ -495,68 +416,3 @@ impl<'a> Iterator for PropIter<'a> { } } } - -/// u32 值迭代器 -#[derive(Clone)] -pub struct U32Iter<'a> { - data: &'a [u8], -} - -impl<'a> U32Iter<'a> { - pub fn new(data: &'a [u8]) -> Self { - Self { data } - } -} - -impl Iterator for U32Iter<'_> { - type Item = u32; - - fn next(&mut self) -> Option { - if self.data.len() < 4 { - return None; - } - let value = u32::from_be_bytes(self.data[..4].try_into().unwrap()); - self.data = &self.data[4..]; - Some(value) - } -} - -/// 字符串迭代器（用于 compatible 等多字符串属性） -#[derive(Clone)] -pub struct StrIter<'a> { - data: &'a [u8], -} - -impl<'a> Iterator for StrIter<'a> { - type Item = &'a str; - - fn next(&mut self) -> Option { - if self.data.is_empty() { - return None; - } - - // 查找 null 终止符 - let end = self - .data - .iter() - .position(|&b| b == 0) - .unwrap_or(self.data.len()); - - if end == 0 { - // 空字符串，跳过 null - self.data = &self.data[1..]; - return self.next(); - } - - let s = core::str::from_utf8(&self.data[..end]).ok()?; - - // 跳过字符串和 null 终止符 - if end < self.data.len() { - self.data = &self.data[end + 1..]; - } else { - self.data = &[]; - } - - Some(s) - } -} diff --git a/fdt-raw/src/node/prop/reg.rs b/fdt-raw/src/node/prop/reg.rs index 7d0ba2c..ac7b08e 100644 --- a/fdt-raw/src/node/prop/reg.rs +++ b/fdt-raw/src/node/prop/reg.rs @@ -1,5 +1,7 @@ //! Reg 属性相关类型 +use crate::data::Reader; + /// Reg 条目信息 #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct RegInfo { @@ -16,81 +18,21 @@ impl RegInfo { } } -/// Reg 属性类型 -#[derive(Clone)] -pub struct Reg<'a> { - data: &'a [u8], - address_cells: u8, - size_cells: u8, -} - -impl<'a> Reg<'a> { - /// 创建新的 Reg - pub fn new(data: &'a [u8], address_cells: u8, size_cells: u8) -> Self { - Self { - data, - address_cells, - size_cells, - } - } - - /// 获取原始数据 - pub fn as_slice(&self) -> &'a [u8] { - self.data - } - - /// 获取原始 u32 迭代器 - pub fn as_u32_iter(&self) -> super::U32Iter<'a> { - super::U32Iter::new(self.data) - } - - /// 获取 RegInfo 迭代器 - pub fn iter(&self) -> RegIter<'a> { - RegIter { - data: self.data, - address_cells: self.address_cells, - size_cells: self.size_cells, - } - } - - /// 获取所有 RegInfo 条目到数组 - pub fn to_array(&self) -> heapless::Vec { - let mut result = heapless::Vec::new(); - for info in self.iter() { - if result.push(info).is_err() { - break; - } - } - result - } -} - /// Reg 迭代器 #[derive(Clone)] pub struct RegIter<'a> { - data: &'a [u8], + reader: Reader<'a>, address_cells: u8, size_cells: u8, } -impl RegIter<'_> { - /// 根据 cells 数量读取值 - fn read_value(data: &[u8], cells: u8) -> Option<(u64, usize)> { - let bytes_needed = (cells as usize) * 4; - if data.len() < bytes_needed { - return None; +impl<'a> RegIter<'a> { + pub(crate) fn new(reader: Reader<'a>, address_cells: u8, size_cells: u8) -> RegIter<'a> { + RegIter { + reader, + address_cells, + size_cells, } - let value = match cells { - 0 => 0, - 1 => u32::from_be_bytes(data[0..4].try_into().unwrap()) as u64, - 2 => u64::from_be_bytes(data[0..8].try_into().unwrap()), - _ => { - // 超过 2 cells，取低 64 位 - let offset = bytes_needed - 8; - u64::from_be_bytes(data[offset..offset + 8].try_into().unwrap()) - } - }; - Some((value, bytes_needed)) } } @@ -98,22 +40,25 @@ impl Iterator for RegIter<'_> { type Item = RegInfo; fn next(&mut self) -> Option { - if self.data.is_empty() { + let address; + let size; + if self.address_cells == 1 { + address = self.reader.read_u32().map(|addr| addr as u64)?; + } else if self.address_cells == 2 { + address = self.reader.read_u64()?; + } else { return None; } - - // 读取地址 - let (address, addr_bytes) = Self::read_value(self.data, self.address_cells)?; - self.data = &self.data[addr_bytes..]; - - // 读取大小 - let size = if self.size_cells > 0 { - let (size_val, size_bytes) = Self::read_value(self.data, self.size_cells)?; - self.data = &self.data[size_bytes..]; - Some(size_val) + if self.size_cells == 0 { + size = None; + } else if self.size_cells == 1 { + size = self.reader.read_u32().map(|s| s as u64); + } else if self.size_cells == 2 { + size = self.reader.read_u64(); } else { - None - }; + // 不支持的 size_cells + return None; + } Some(RegInfo::new(address, size)) } diff --git a/fdt-raw/tests/node.rs b/fdt-raw/tests/node.rs index 5e4ebcb..5b61bce 100644 --- a/fdt-raw/tests/node.rs +++ b/fdt-raw/tests/node.rs @@ -32,209 +32,66 @@ fn test_fdt_display() { info!("FDT Display:\n{}", output); // 验证基本 DTS 结构 - assert!( - output.contains("/dts-v1/;"), - "Output should contain DTS version header" - ); - assert!( - output.contains("/ {"), - "Output should contain root node opening" - ); - assert!(output.contains("};"), "Output should contain node closing"); + let basic_checks = [ + ("/dts-v1/;", "DTS version header"), + ("/ {", "root node opening"), + ("};", "node closing"), + ]; + for (pattern, desc) in basic_checks { + assert!(output.contains(pattern), "Output should contain {desc}"); + } // 验证根节点属性 - assert!( - output.contains("interrupt-parent = <0x8002>"), - "Should contain interrupt-parent property" - ); - assert!( - output.contains("model = \"linux,dummy-virt\""), - "Should contain model property" - ); - assert!( - output.contains("#size-cells = <0x2>"), - "Should contain #size-cells property" - ); - assert!( - output.contains("#address-cells = <0x2>"), - "Should contain #address-cells property" - ); - assert!( - output.contains("compatible = \"linux,dummy-virt\""), - "Should contain compatible property" - ); - - // 验证 PSCI 节点 - assert!( - output.contains("psci {"), - "Should contain psci node opening" - ); - assert!( - output.contains("compatible = \"arm,psci-1.0\", \"arm,psci-0.2\", \"arm,psci\""), - "Should contain PSCI compatible strings" - ); - assert!( - output.contains("method = \"hvc\""), - "Should contain PSCI method" - ); - assert!( - output.contains("cpu_on = <0xc4000003>"), - "Should contain PSCI cpu_on function" - ); - assert!( - output.contains("cpu_off = <0x84000002>"), - "Should contain PSCI cpu_off function" - ); - - // 验证内存节点 - assert!( - output.contains("memory@40000000 {"), - "Should contain memory node" - ); - assert!( - output.contains("device_type = \"memory\""), - "Should contain memory device_type" - ); - assert!( - output.contains("reg = <0x0 0x40000000 0x0 0x8000000>"), - "Should contain memory reg property with correct values" - ); - - // 验证 platform-bus 节点 - assert!( - output.contains("platform-bus@c000000 {"), - "Should contain platform-bus node" - ); - assert!( - output.contains("compatible = \"qemu,platform\", \"simple-bus\""), - "Should contain platform-bus compatible strings" - ); - - // 验证重要设备节点存在 - assert!( - output.contains("fw-cfg@9020000 {"), - "Should contain fw-cfg node" - ); - assert!( - output.contains("compatible = \"qemu,fw-cfg-mmio\""), - "Should contain fw-cfg compatible" - ); - assert!( - output.contains("dma-coherent"), - "Should contain dma-coherent property" - ); - - // 验证 virtio 设备 - assert!( - output.contains("virtio_mmio@a000000 {"), - "Should contain virtio_mmio device" - ); - assert!( - output.contains("compatible = \"virtio,mmio\""), - "Should contain virtio compatible" - ); - - // 验证 GPIO 控制器 - assert!( - output.contains("pl061@9030000 {"), - "Should contain GPIO controller node" - ); - assert!( - output.contains("compatible = \"arm,pl061\", \"arm,primecell\""), - "Should contain GPIO compatible strings" - ); - - // 验证 PCI 控制器 - assert!( - output.contains("pcie@10000000 {"), - "Should contain PCIe controller node" - ); - assert!( - output.contains("device_type = \"pci\""), - "Should contain PCI device_type" - ); - assert!( - output.contains("compatible = \"pci-host-ecam-generic\""), - "Should contain PCIe compatible" - ); - - // 验证中断控制器 - assert!( - output.contains("intc@8000000 {"), - "Should contain interrupt controller node" - ); - assert!( - output.contains("compatible = \"arm,cortex-a15-gic\""), - "Should contain GIC compatible strings" - ); - assert!( - output.contains("interrupt-controller"), - "Should contain interrupt-controller property" - ); - - // 验证 CPU 节点 - assert!(output.contains("cpu@0 {"), "Should contain CPU node"); - assert!( - output.contains("device_type = \"cpu\""), - "Should contain CPU device_type" - ); - assert!( - output.contains("compatible = \"arm,cortex-a53\""), - "Should contain CPU compatible" - ); - - // 验证时钟节点 - assert!(output.contains("apb-pclk {"), "Should contain clock node"); - assert!( - output.contains("compatible = \"fixed-clock\""), - "Should contain fixed-clock compatible" - ); - assert!( - output.contains("clock-frequency ="), - "Should contain clock-frequency property" - ); - - // 验证 chosen 节点 - assert!(output.contains("chosen {"), "Should contain chosen node"); - assert!( - output.contains("stdout-path = \"/pl011@9000000\""), - "Should contain stdout-path property" - ); + let root_props = [ + ("interrupt-parent = <0x8002>", "interrupt-parent property"), + ("model = \"linux,dummy-virt\"", "model property"), + ("#size-cells = <0x2>", "#size-cells property"), + ("#address-cells = <0x2>", "#address-cells property"), + ("compatible = \"linux,dummy-virt\"", "compatible property"), + ]; + for (pattern, desc) in root_props { + assert!(output.contains(pattern), "Should contain {desc}"); + } - // 验证十六进制数值格式 - assert!( - output.contains("<0x8002>"), - "Should use proper hex format for phandle values" - ); - assert!( - output.contains("<0xc4000003>"), - "Should use proper hex format for function numbers" - ); - assert!( - output.contains("<0x2>"), - "Should use proper hex format for cell values" - ); + // 验证重要节点存在 + let important_nodes = [ + ("psci {", "psci node opening"), + ("memory@40000000 {", "memory node"), + ("platform-bus@c000000 {", "platform-bus node"), + ("fw-cfg@9020000 {", "fw-cfg node"), + ("virtio_mmio@a000000 {", "virtio_mmio device"), + ("pl061@9030000 {", "GPIO controller node"), + ("pcie@10000000 {", "PCIe controller node"), + ("intc@8000000 {", "interrupt controller node"), + ("cpu@0 {", "CPU node"), + ("apb-pclk {", "clock node"), + ("chosen {", "chosen node"), + ]; + for (pattern, desc) in important_nodes { + assert!(output.contains(pattern), "Should contain {desc}"); + } - // 验证字符串值格式 - assert!( - output.contains("\"linux,dummy-virt\""), - "Should properly quote string values" - ); - assert!( - output.contains("\"arm,psci-1.0\""), - "Should properly quote compatible strings" - ); - assert!( - output.contains("\"hvc\""), - "Should properly quote method strings" - ); + // 验证重要属性 + let important_props = [ + ("device_type = \"memory\"", "memory device_type"), + ("dma-coherent", "dma-coherent property"), + ("interrupt-controller", "interrupt-controller property"), + ("stdout-path = \"/pl011@9000000\"", "stdout-path property"), + ]; + for (pattern, desc) in important_props { + assert!(output.contains(pattern), "Should contain {desc}"); + } - // 验证属性值格式 - assert!(output.contains("= <"), "Should use '< >' for cell values"); - assert!( - output.contains("= \""), - "Should use '\" \"' for string values" - ); + // 验证格式规范 + let format_checks = [ + ("= <", "use '< >' for cell values"), + ("= \"", "use '\" \"' for string values"), + ("<0x", "hex format for values"), + ("\"", "quoted strings"), + ]; + for (pattern, desc) in format_checks { + assert!(output.contains(pattern), "Should {desc}"); + } info!("All FDT display format validations passed!"); } @@ -248,155 +105,71 @@ fn test_fdt_debug() { info!("FDT Debug:\n{}", output); // 验证基本 Debug 结构 - assert!( - output.contains("Fdt {"), - "Debug output should contain Fdt struct opening" - ); - assert!( - output.contains("header: Header"), - "Should contain header field" - ); - assert!(output.contains("nodes:"), "Should contain nodes field"); + let struct_checks = [ + ("Fdt {", "Fdt struct opening"), + ("header: Header", "header field"), + ("nodes:", "nodes field"), + ]; + for (pattern, desc) in struct_checks { + assert!( + output.contains(pattern), + "Debug output should contain {desc}" + ); + } - // 验证 header 信息 - assert!( - output.contains("magic:"), - "Should contain header magic field" - ); - assert!( - output.contains("totalsize:"), - "Should contain header totalsize field" - ); - assert!( - output.contains("off_dt_struct:"), - "Should contain header off_dt_struct field" - ); - assert!( - output.contains("off_dt_strings:"), - "Should contain header off_dt_strings field" - ); - assert!( - output.contains("off_mem_rsvmap:"), - "Should contain header off_mem_rsvmap field" - ); - assert!( - output.contains("version:"), - "Should contain header version field" - ); - assert!( - output.contains("last_comp_version:"), - "Should contain header last_comp_version field" - ); - assert!( - output.contains("boot_cpuid_phys:"), - "Should contain header boot_cpuid_phys field" - ); - assert!( - output.contains("size_dt_strings:"), - "Should contain header size_dt_strings field" - ); - assert!( - output.contains("size_dt_struct:"), - "Should contain header size_dt_struct field" - ); + // 验证 header 字段 + let header_fields = [ + ("magic:", "magic field"), + ("totalsize:", "totalsize field"), + ("off_dt_struct:", "off_dt_struct field"), + ("off_dt_strings:", "off_dt_strings field"), + ("off_mem_rsvmap:", "off_mem_rsvmap field"), + ("version:", "version field"), + ("last_comp_version:", "last_comp_version field"), + ("boot_cpuid_phys:", "boot_cpuid_phys field"), + ("size_dt_strings:", "size_dt_strings field"), + ("size_dt_struct:", "size_dt_struct field"), + ]; + for (pattern, desc) in header_fields { + assert!(output.contains(pattern), "Should contain header {desc}"); + } // 验证根节点信息 - assert!(output.contains("[/]"), "Should contain root node"); - assert!( - output.contains("address_cells="), - "Should contain address_cells field" - ); - assert!( - output.contains("size_cells="), - "Should contain size_cells field" - ); - // RPi 4B 的 debug 输出格式可能不包含 parent_address_cells 和 parent_size_cells - // assert!(output.contains("parent_address_cells="), "Should contain parent_address_cells field"); - // assert!(output.contains("parent_size_cells="), "Should contain parent_size_cells field"); - - // 验证上下文信息（根据实际输出格式调整） - // assert!(output.contains("NodeContext {"), "Should contain NodeContext struct"); - // assert!(output.contains("address_cells:"), "Should contain context address_cells"); - // assert!(output.contains("size_cells:"), "Should contain context size_cells"); - - // 验证属性解析结果（RPi 4B 使用不同格式） - // assert!(output.contains("properties:"), "Should contain properties field"); - - // 验证不同类型的属性（RPi 4B 格式可能不同） - assert!(output.contains("model:"), "Should contain model field"); - assert!( - output.contains("#address-cells:"), - "Should contain #address-cells field" - ); - assert!( - output.contains("#size-cells:"), - "Should contain #size-cells field" - ); - assert!( - output.contains("compatible:"), - "Should contain compatible field" - ); - - // 验证 reg 属性解析（根据实际输出格式） - // assert!(output.contains("reg: ["), "Should contain reg array"); - // assert!(output.contains("RegInfo {"), "Should contain RegInfo struct"); - // assert!(output.contains("address:"), "Should contain address field"); - // assert!(output.contains("size:"), "Should contain size field"); - - // 验证兼容字符串 - // assert!(output.contains("Compatible("), "Should contain Compatible property"); - - // 验证 phandle 属性（根据实际输出） - assert!( - output.contains("interrupt-parent:"), - "Should contain interrupt-parent field" - ); - - // 验证设备类型 - // assert!(output.contains("DeviceType("), "Should contain DeviceType property"); - - // 验证中断相关属性（根据实际输出格式调整） - // assert!(output.contains("InterruptParent("), "Should contain InterruptParent property"); - // assert!(output.contains("InterruptCells("), "Should contain InterruptCells property"); - - // 验证特殊属性 - // assert!(output.contains("DmaCoherent"), "Should contain DmaCoherent property"); - - // 验证未知属性 - // assert!(output.contains("Unknown("), "Should contain Unknown property for unrecognized types"); - - // 验证数值格式 - assert!(output.contains("0x"), "Should contain hexadecimal numbers"); - - // 验证字符串格式 - assert!(output.contains("\""), "Should contain quoted strings"); + let root_node_checks = [ + ("[/]", "root node"), + ("address_cells=", "address_cells field"), + ("size_cells=", "size_cells field"), + ("model:", "model field"), + ("#address-cells:", "#address-cells field"), + ("#size-cells:", "#size-cells field"), + ("compatible:", "compatible field"), + ("interrupt-parent:", "interrupt-parent field"), + ]; + for (pattern, desc) in root_node_checks { + assert!(output.contains(pattern), "Should contain {desc}"); + } - // 验证数组格式 - assert!(output.contains("["), "Should contain array brackets"); - assert!( - output.contains("]"), - "Should contain array closing brackets" - ); + // 验证数据格式 + let format_checks = [ + ("0x", "hexadecimal numbers"), + ("\"", "quoted strings"), + ("[", "array opening brackets"), + ("]", "array closing brackets"), + ]; + for (pattern, desc) in format_checks { + assert!(output.contains(pattern), "Should contain {desc}"); + } // 验证特定节点 - assert!(output.contains("memory@"), "Should contain memory node"); - // RPi 4B 可能没有 psci 节点 - // assert!(output.contains("psci"), "Should contain psci node"); - - // 验证地址和大小数值 - // assert!(output.contains("address: 0x"), "Should contain address with hex value"); - // assert!(output.contains("size: Some("), "Should contain size with Some value"); - - // 验证 RPi 4B 特有的节点和属性 - assert!(output.contains("soc"), "Should contain soc node"); - assert!( - output.contains("Raspberry Pi 4 Model B"), - "Should contain RPi 4 model name" - ); - assert!( - output.contains("raspberrypi,4-model-b"), - "Should contain RPi compatible string" - ); + let specific_checks = [ + ("memory@", "memory node"), + ("soc", "soc node"), + ("Raspberry Pi 4 Model B", "RPi 4 model name"), + ("raspberrypi,4-model-b", "RPi compatible string"), + ]; + for (pattern, desc) in specific_checks { + assert!(output.contains(pattern), "Should contain {desc}"); + } info!("All FDT debug format validations passed!"); } @@ -429,13 +202,11 @@ fn test_node_context() { for node in fdt.all_nodes() { info!( - "node: {} (level={}, addr_cells={}, size_cells={}, parent_addr_cells={}, parent_size_cells={})", + "node: {} (level={}, parent_addr_cells={}, parent_size_cells={})", node.name(), node.level(), node.address_cells, node.size_cells, - node.reg_address_cells(), - node.reg_size_cells() ); } } @@ -449,7 +220,6 @@ fn test_node_properties() { let mut found_address_cells = false; let mut found_size_cells = false; let mut found_interrupt_cells = false; - let mut found_model = false; let mut found_device_type = false; let mut found_compatible = false; let mut found_phandle = false; @@ -461,173 +231,89 @@ fn test_node_properties() { for node in fdt.all_nodes() { info!("node: {}", node.name()); for prop in node.properties() { - match &prop { - Property::AddressCells(v) => { - found_address_cells = true; - info!(" #address-cells = {}", v); - assert!( - *v == 1 || *v == 2 || *v == 3, - "Unexpected #address-cells value: {}, should be 1, 2, or 3", - v - ); - } - Property::SizeCells(v) => { - found_size_cells = true; - info!(" #size-cells = {}", v); - assert!( - *v == 0 || *v == 1 || *v == 2, - "Unexpected #size-cells value: {}, should be 0, 1, or 2", - v - ); - } - Property::InterruptCells(v) => { - found_interrupt_cells = true; - info!(" #interrupt-cells = {}", v); - assert!( - *v >= 1 && *v <= 4, - "Unexpected #interrupt-cells value: {}, should be 1-4", - v - ); - } - Property::Status(s) => { - info!(" status = {:?}", s); - // 验证状态值的有效性 - match s { - Status::Okay | Status::Disabled => {} - } - } - Property::Phandle(p) => { - found_phandle = true; - info!(" phandle = {}", p); - assert!( - p.as_usize() > 0, - "Phandle value should be positive, got {}", - p.as_usize() - ); - } - Property::LinuxPhandle(p) => { - info!(" linux,phandle = {}", p); - assert!( - p.as_usize() > 0, - "Linux phandle value should be positive, got {}", - p.as_usize() - ); - } - Property::InterruptParent(p) => { - found_interrupt_parent = true; - info!(" interrupt-parent = {}", p); - assert!( - p.as_usize() > 0, - "Interrupt-parent value should be positive, got {}", - p.as_usize() - ); - } - Property::Model(s) => { - found_model = true; - info!(" model = \"{}\"", s); - assert_eq!( - *s, "linux,dummy-virt", - "Model should be 'linux,dummy-virt', got '{}'", - s - ); - assert!(!s.is_empty(), "Model string should not be empty"); - } - Property::DeviceType(s) => { - found_device_type = true; - info!(" device_type = \"{}\"", s); - assert!(!s.is_empty(), "Device_type string should not be empty"); - // 验证常见的设备类型 - match *s { - "memory" | "cpu" | "serial" | "gpio" | "pci" | "interrupt-controller" => {} - _ => { - // 其他设备类型也是允许的 - } - } + if let Some(v) = prop.as_address_cells() { + found_address_cells = true; + info!(" #address-cells = {}", v); + assert!( + v == 1 || v == 2 || v == 3, + "Unexpected #address-cells value: {}, should be 1, 2, or 3", + v + ); + } else if let Some(v) = prop.as_size_cells() { + found_size_cells = true; + info!(" #size-cells = {}", v); + assert!( + v == 0 || v == 1 || v == 2, + "Unexpected #size-cells value: {}, should be 0, 1, or 2", + v + ); + } else if let Some(v) = prop.as_interrupt_cells() { + found_interrupt_cells = true; + info!(" #interrupt-cells = {}", v); + assert!( + (1..=4).contains(&v), + "Unexpected #interrupt-cells value: {}, should be 1-4", + v + ); + } else if let Some(s) = prop.as_status() { + info!(" status = {:?}", s); + // 验证状态值的有效性 + match s { + Status::Okay | Status::Disabled => {} } - Property::Compatible(iter) => { + } else if let Some(iter) = prop.as_compatible() { + let strs: Vec<_> = iter.clone().collect(); + if !strs.is_empty() { found_compatible = true; - let strs: Vec<_> = iter.clone().collect(); info!(" compatible = {:?}", strs); - assert!(!strs.is_empty(), "Compatible strings should not be empty"); - - // 验证每个兼容字符串都不为空 - for compat_str in &strs { - assert!( - !compat_str.is_empty(), - "Compatible string should not be empty" - ); - assert!( - compat_str.len() <= 128, - "Compatible string too long: {}", - compat_str.len() - ); - } - - // 特定节点的兼容性验证 - if node.name() == "psci" { - assert!( - strs.contains(&"arm,psci-1.0") || strs.contains(&"arm,psci-0.2"), - "PSCI should contain arm,psci compatibility, got {:?}", - strs - ); - assert!( - strs.len() >= 2, - "PSCI should have multiple compatible strings, got {:?}", - strs - ); - } - } - Property::ClockNames(iter) => { - let strs: Vec<_> = iter.clone().collect(); - info!(" clock-names = {:?}", strs); - // 验证时钟名称格式 - for clock_name in &strs { - assert!(!clock_name.is_empty(), "Clock name should not be empty"); - } } - Property::Reg(reg) => { - found_reg = true; - info!(" reg ({} bytes)", reg.as_slice().len()); - assert!(!reg.as_slice().is_empty(), "Reg data should not be empty"); - // 验证 reg 数据长度应该是 4 的倍数 - assert_eq!( - reg.as_slice().len() % 4, - 0, - "Reg data length should be multiple of 4" + } else if let Some(s) = prop.as_device_type() { + found_device_type = true; + info!(" device_type = \"{}\"", s); + } else if prop.as_phandle().is_some() { + found_phandle = true; + info!(" {} = <{:?}>", prop.name(), prop.as_phandle()); + } else if prop.as_interrupt_parent().is_some() { + found_interrupt_parent = true; + info!(" {} = <{:?}>", prop.name(), prop.as_interrupt_parent()); + } else if prop.name() == "reg" { + found_reg = true; + info!(" reg ({} bytes)", prop.len()); + } else if prop.name() == "dma-coherent" { + found_dma_coherent = true; + info!(" dma-coherent (empty)"); + } else { + // 处理未知属性 + if let Some(s) = prop.as_str() { + info!(" {} = \"{}\"", prop.name(), s); + // 验证字符串长度合理 + assert!( + s.len() <= 256, + "String property too long: {} bytes", + s.len() ); - } - Property::DmaCoherent => { - found_dma_coherent = true; - info!(" dma-coherent"); - } - Property::Unknown(raw) => { - if let Some(s) = raw.as_str() { - info!(" {} = \"{}\"", raw.name(), s); - // 验证字符串长度合理 - assert!( - s.len() <= 256, - "String property too long: {} bytes", - s.len() - ); - } else if let Some(v) = raw.as_u32() { - info!(" {} = {:#x}", raw.name(), v); - } else if raw.is_empty() { - found_empty_property = true; - info!(" {} (empty)", raw.name()); - } else { - info!(" {} ({} bytes)", raw.name(), raw.len()); - // 验证属性长度合理 - assert!(raw.len() <= 1024, "Property too large: {} bytes", raw.len()); - } - - // 验证属性名称 - assert!(!raw.name().is_empty(), "Property name should not be empty"); + } else if let Some(v) = prop.as_u32() { + info!(" {} = {:#x}", prop.name(), v); + } else if prop.is_empty() { + found_empty_property = true; + info!(" {} (empty)", prop.name()); + } else { + info!(" {} ({} bytes)", prop.name(), prop.len()); + // 验证属性长度合理 assert!( - raw.name().len() <= 31, - "Property name too long: {}", - raw.name().len() + prop.len() <= 1024, + "Property too large: {} bytes", + prop.len() ); } + + // 验证属性名称 + assert!(!prop.name().is_empty(), "Property name should not be empty"); + assert!( + prop.name().len() <= 31, + "Property name too long: {}", + prop.name().len() + ); } } } @@ -635,7 +321,6 @@ fn test_node_properties() { // 验证找到了基本属性 assert!(found_address_cells, "Should find #address-cells property"); assert!(found_size_cells, "Should find #size-cells property"); - assert!(found_model, "Should find model property"); assert!(found_compatible, "Should find compatible property"); assert!(found_device_type, "Should find device_type property"); assert!(found_reg, "Should find reg property"); @@ -646,6 +331,10 @@ fn test_node_properties() { found_interrupt_parent, "Should find interrupt-parent property" ); + assert!( + found_interrupt_cells, + "Should find #interrupt-cells property" + ); assert!(found_dma_coherent, "Should find dma-coherent property"); assert!(found_empty_property, "Should find empty property"); @@ -662,45 +351,19 @@ fn test_reg_parsing() { let mut found_memory_reg = false; let mut found_virtio_mmio_reg = false; - let mut found_psci_reg = false; let mut found_fw_cfg_reg = false; let mut found_gpio_reg = false; for node in fdt.all_nodes() { if let Some(reg) = node.reg() { info!("node: {}", node.name()); - info!( - " address_cells={}, size_cells={}", - node.reg_address_cells(), - node.reg_size_cells() - ); - - // 测试 as_u32_iter - let u32_values: Vec<_> = reg.as_u32_iter().collect(); - info!(" raw u32: {:x?}", u32_values); - - // 测试 RegInfo iter - let reg_infos: Vec<_> = reg.iter().collect(); - for (i, reg_info) in reg_infos.iter().enumerate() { - info!( - " RegInfo[{}]: address={:#x}, size={:?}", - i, reg_info.address, reg_info.size - ); - } - // 验证 address_cells 和 size_cells 的一致性 - let expected_entry_size = (node.reg_address_cells() + node.reg_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 {}", - node.name() - ); + let reg_infos: Vec<_> = reg.collect(); // 验证特定节点的 reg 属性 if node.name().starts_with("memory@") { found_memory_reg = true; - assert!(!u32_values.is_empty(), "Memory reg should have u32 values"); + assert!( !reg_infos.is_empty(), "Memory should have at least one reg entry" @@ -717,32 +380,11 @@ fn test_reg_parsing() { Some(134217728), "Memory size should be 128MB (0x8000000)" ); - - // 验证 u32 值格式 - assert_eq!( - u32_values.len(), - 4, - "Memory reg should have 4 u32 values (2 addr + 2 size)" - ); - assert_eq!(u32_values[0], 0x0, "Memory high address should be 0"); - assert_eq!( - u32_values[1], 0x40000000, - "Memory low address should be 0x40000000" - ); - assert_eq!(u32_values[2], 0x0, "Memory high size should be 0"); - assert_eq!( - u32_values[3], 0x8000000, - "Memory low size should be 0x8000000" - ); } if node.name().starts_with("virtio_mmio@") { found_virtio_mmio_reg = true; - assert_eq!( - u32_values.len(), - 4, - "Virtio MMIO reg should have 4 u32 values" - ); + assert_eq!(reg_infos.len(), 1, "Virtio MMIO should have one reg entry"); let reg_info = ®_infos[0]; @@ -774,15 +416,8 @@ fn test_reg_parsing() { ); } - if node.name() == "psci" { - found_psci_reg = true; - // PSCI 通常没有 reg 属性，但如果有的话应该验证 - info!(" PSCI reg found (unexpected)"); - } - if node.name() == "fw-cfg@9020000" { found_fw_cfg_reg = true; - assert_eq!(u32_values.len(), 4, "fw-cfg reg should have 4 u32 values"); assert_eq!(reg_infos.len(), 1, "fw-cfg should have one reg entry"); let reg_info = ®_infos[0]; @@ -797,20 +432,10 @@ fn test_reg_parsing() { "fw-cfg size should be 24 bytes, got {:?}", reg_info.size ); - - // 验证 u32 值 - assert_eq!(u32_values[0], 0x0, "fw-cfg high address should be 0"); - assert_eq!( - u32_values[1], 0x9020000, - "fw-cfg low address should be 0x9020000" - ); - assert_eq!(u32_values[2], 0x0, "fw-cfg high size should be 0"); - assert_eq!(u32_values[3], 0x18, "fw-cfg low size should be 0x18 (24)"); } if node.name() == "pl061@9030000" { found_gpio_reg = true; - assert_eq!(u32_values.len(), 4, "pl061 reg should have 4 u32 values"); assert_eq!(reg_infos.len(), 1, "pl061 should have one reg entry"); let reg_info = ®_infos[0]; @@ -825,18 +450,6 @@ fn test_reg_parsing() { "pl061 size should be 4096 bytes, got {:?}", reg_info.size ); - - // 验证 u32 值 - assert_eq!(u32_values[0], 0x0, "pl061 high address should be 0"); - assert_eq!( - u32_values[1], 0x9030000, - "pl061 low address should be 0x9030000" - ); - assert_eq!(u32_values[2], 0x0, "pl061 high size should be 0"); - assert_eq!( - u32_values[3], 0x1000, - "pl061 low size should be 0x1000 (4096)" - ); } } } @@ -883,6 +496,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, @@ -902,165 +519,25 @@ fn test_memory_in_fdt(raw: &[u8], name: &str) { node.level() ); - // 验证 address_cells 和 size_cells - assert_eq!( - node.reg_address_cells(), - 2, - "Memory should use 2 address cells, got {}", - node.reg_address_cells() - ); - assert!( - node.reg_size_cells() == 1 || node.reg_size_cells() == 2, - "Memory should use 1 or 2 size cells, got {}", - node.reg_size_cells() - ); - // 验证并解析 reg 属性 let mut found_device_type = false; - let mut found_reg = false; for prop in node.properties() { - match &prop { - Property::DeviceType(s) => { - found_device_type = true; - assert_eq!( - *s, "memory", - "Memory node device_type should be 'memory', got '{}'", - s - ); - info!("[{}] device_type = \"{}\"", name, s); - } - Property::Reg(reg) => { - 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.reg_address_cells(), - node.reg_size_cells() - ); - info!( - "[{}] raw data ({} bytes): {:02x?}", - name, - reg.as_slice().len(), - reg.as_slice() - ); - info!("[{}] u32 values: {:x?}", name, u32_values); - - // 平台特定验证 - if name == "QEMU" { - // QEMU 特定验证 - assert!(!reg_infos.is_empty(), "QEMU memory should have reg entries"); - assert_eq!( - reg_infos.len(), - 1, - "QEMU memory should have exactly one reg entry" - ); - - let reg_info = ®_infos[0]; - assert_eq!( - reg_info.address, 0x40000000, - "QEMU memory base address should be 0x40000000, got {:#x}", - reg_info.address - ); - assert_eq!( - reg_info.size, - Some(134217728), - "QEMU memory size should be 128MB (0x8000000), got {:?}", - 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, - reg_info.address, - reg_info.size.unwrap_or(0) - ); - } else if name == "RPi 4B" { - // RPi 4B 特定验证（根据测试输出，RPi 4B 内存地址和大小都为0） - info!("[{}] RPi 4B memory entries: {}", name, reg_infos.len()); - - for (i, reg_info) in reg_infos.iter().enumerate() { - info!( - "[{}] reg[{}]: address={:#x}, size={:?}", - name, i, reg_info.address, reg_info.size - ); - - // RPi 4B 的特殊情况 - 当前测试数据显示地址和大小为0 - // 这可能是测试数据的特殊情况，我们只验证基本结构 - if node.reg_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.reg_address_cells() + node.reg_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={:?}", - name, i, reg_info.address, reg_info.size - ); - - // 基本验证：地址应该是有效的 - if reg_info.size.is_some() && reg_info.size.unwrap() > 0 { - // 对于有大小的内存区域，验证大小是合理的（大于0） - assert!( - reg_info.size.unwrap() > 0, - "Memory size should be positive, got {:?}", - reg_info.size - ); - } - } - } - Property::Compatible(iter) => { - let strs: Vec<_> = iter.clone().collect(); - if !strs.is_empty() { - info!("[{}] compatible = {:?}", name, strs); - } - } - _ => { - info!("[{}] {}", name, prop.name()); + if let Some(s) = prop.as_device_type() { + found_device_type = true; + assert_eq!( + s, "memory", + "Memory node device_type should be 'memory', got '{}'", + s + ); + info!("[{}] device_type = \"{}\"", name, s); + } else if let Some(iter) = prop.as_compatible() { + let strs: Vec<_> = iter.clone().collect(); + if !strs.is_empty() { + info!("[{}] compatible = {:?}", name, strs); } + } else { + info!("[{}] {}", name, prop.name()); } } @@ -1069,7 +546,58 @@ fn test_memory_in_fdt(raw: &[u8], name: &str) { found_device_type, "Memory node should have device_type property" ); - assert!(found_reg, "Memory node should have reg property"); + + // 输出 reg 信息并验证 + info!( + "[{}] address_cells={}, size_cells={}", + name, node.context.parent_address_cells, node.context.parent_size_cells + ); + info!("[{}] reg entries: {}", name, reg_infos.len()); + + for (i, reg_info) in reg_infos.iter().enumerate() { + info!( + "[{}] reg[{}]: address={:#x}, size={:?}", + name, i, reg_info.address, reg_info.size + ); + + // 基本验证：地址应该是有效的 + if reg_info.size.is_some() && reg_info.size.unwrap() > 0 { + assert!( + reg_info.size.unwrap() > 0, + "Memory size should be positive, got {:?}", + reg_info.size + ); + } + } + + // 平台特定验证 + if name == "QEMU" && !reg_infos.is_empty() { + assert_eq!( + reg_infos.len(), + 1, + "QEMU memory should have exactly one reg entry" + ); + + let reg_info = ®_infos[0]; + assert_eq!( + reg_info.address, 0x40000000, + "QEMU memory base address should be 0x40000000, got {:#x}", + reg_info.address + ); + assert_eq!( + reg_info.size, + Some(134217728), + "QEMU memory size should be 128MB (0x8000000), got {:?}", + reg_info.size + ); + + info!( + "[{}] QEMU memory validated: address={:#x}, size={} bytes", + name, + reg_info.address, + reg_info.size.unwrap_or(0) + ); + } } }