Rust设备树解析库fdt的使用，高效处理Flattened Device Tree数据结构

安装

在项目目录中运行以下Cargo命令：

cargo add fdt

或者在Cargo.toml中添加以下行：

fdt = "0.1.5"

基本使用示例

下面是一个使用fdt库解析设备树的基本示例：

use fdt::Fdt;

fn main() {
    // 假设我们有一个设备树二进制数据
    let dtb_data = include_bytes!("path/to/device_tree.dtb");
    
    // 解析设备树
    let fdt = Fdt::new(dtb_data).expect("Failed to parse device tree");
    
    // 获取根节点
    let root = fdt.root();
    
    // 遍历所有子节点
    for node in root.children() {
        println!("Found node: {}", node.name);
        
        // 遍历节点属性
        for prop in node.properties() {
            println!("  Property: {} ({} bytes)", prop.name, prop.value.len());
        }
    }
    
    // 查找特定节点
    if let Some(uart_node) = fdt.find_node("/soc/uart@10000000") {
        println!("Found UART node");
        
        // 获取特定属性值
        if let Some(reg) = uart_node.property("reg") {
            println!("UART registers at {:?}", reg.value);
        }
    }
}

完整示例代码

下面是一个更完整的示例，展示了如何使用fdt库处理设备树数据：

use fdt::Fdt;

fn main() {
    // 加载设备树二进制数据
    let dtb_data = include_bytes!("path/to/device_tree.dtb");
    
    // 解析设备树
    match Fdt::new(dtb_data) {
        Ok(fdt) => {
            // 打印设备树基本信息
            println!("Device tree version: {}", fdt.version());
            println!("Total size: {} bytes", fdt.total_size());
            
            // 处理内存节点
            if let Some(memory_node) = fdt.find_node("/memory") {
                println!("\nMemory information:");
                
                // 获取内存区域
                if let Some(reg) = memory_node.property("reg") {
                    let regions = reg.as_reg().unwrap();
                    for (i, region) in regions.enumerate() {
                        println!("  Region {}: start={:#x}, size={:#x}",
                            i, region.starting_address, region.size.unwrap_or(0));
                    }
                }
            }
            
            // 处理CPU节点
            println!("\nCPU information:");
            for cpu_node in fdt.find_all_nodes("/cpus/cpu@*") {
                println!("Found CPU: {}", cpu_node.name);
                
                // 获取CPU兼容性信息
                if let Some(compatible) = cpu_node.property("compatible") {
                    println!("  Compatible: {}", compatible.as_str().unwrap());
                }
                
                // 获取CPU时钟频率
                if let Some(clock_freq) = cpu_node.property("clock-frequency") {
                    let freq = clock_freq.as_u32().unwrap();
                    println!("  Clock frequency: {} MHz", freq / 1_000_000);
                }
            }
            
            // 处理中断控制器
            if let Some(intc_node) = fdt.find_node("/intc") {
                println!("\nInterrupt controller:");
                println!("  Compatible: {}", 
                    intc_node.property("compatible").unwrap().as_str().unwrap());
                
                // 获取中断号
                if let Some(interrupts) = intc_node.property("interrupts") {
                    println!("  Interrupts: {:?}", interrupts.value);
                }
            }
        },
        Err(e) => eprintln!("Failed to parse device tree: {}", e),
    }
}

高级用法

use fdt::{Fdt, standard_nodes::Compatible};

fn enumerate_devices(fdt: &Fdt) {
    // 查找所有兼容特定驱动的设备
    for node in fdt.find_all_nodes("/soc/*") {
        if let Some(compatible) = node.property("compatible") {
            if compatible.as_str().unwrap().contains("usb") {
                println!("Found USB device at {}", node.name);
                
                // 获取设备地址
                if let Some(reg) = node.property("reg") {
                    let regions = reg.as_reg().unwrap();
                    for region in regions {
                        println!("  Base address: {:#x}", region.starting_address);
                    }
                }
                
                // 获取中断信息
                if let Some(interrupts) = node.property("interrupts") {
                    println!("  Interrupts: {:?}", interrupts.value);
                }
            }
        }
    }
}

fn check_compatibility(fdt: &Fdt) -> bool {
    // 检查设备树是否与我们的系统兼容
    let root = fdt.root();
    
    // 检查兼容性字符串
    if let Some(compatible) = root.property("compatible") {
        let comp = Compatible::new(compatible);
        if comp.matches("my-company,my-board") {
            return true;
        }
    }
    
    false
}

完整示例demo

下面是一个综合性的设备树解析示例，展示了fdt库的核心功能：

use fdt::{Fdt, standard_nodes::Compatible};

fn main() {
    // 加载设备树数据
    let dtb_data = include_bytes!("path/to/device_tree.dtb");
    
    // 解析设备树
    let fdt = match Fdt::new(dtb_data) {
        Ok(fdt) => fdt,
        Err(e) => {
            eprintln!("设备树解析失败: {}", e);
            return;
        }
    };
    
    // 1. 打印设备树基本信息
    println!("=== 设备树基本信息 ===");
    println!("版本: {}", fdt.version());
    println!("总大小: {} 字节", fdt.total_size());
    
    // 2. 检查兼容性
    println!("\n=== 兼容性检查 ===");
    if check_compatibility(&fdt) {
        println!("设备树与系统兼容");
    } else {
        println!("设备树与系统不兼容");
    }
    
    // 3. 枚举所有设备
    println!("\n=== 设备枚举 ===");
    enumerate_devices(&fdt);
    
    // 4. 详细内存信息
    println!("\n=== 内存信息 ===");
    if let Some(memory_node) = fdt.find_node("/memory") {
        if let Some(reg) = memory_node.property("reg") {
            let regions = reg.as_reg().unwrap();
            for (i, region) in regions.enumerate() {
                println!("内存区域 {}: 起始地址={:#x}, 大小={:#x}",
                    i, region.starting_address, region.size.unwrap_or(0));
            }
        }
    }
}

// 检查设备树兼容性
fn check_compatibility(fdt: &Fdt) -> bool {
    let root = fdt.root();
    if let Some(compatible) = root.property("compatible") {
        let comp = Compatible::new(compatible);
        comp.matches("my-company,my-board")
    } else {
        false
    }
}

// 枚举所有设备
fn enumerate_devices(fdt: &Fdt) {
    // 遍历所有节点
    for node in fdt.all_nodes() {
        println!("设备节点: {}", node.name);
        
        // 打印所有属性
        for prop in node.properties() {
            println!("  属性: {} ({}字节)", prop.name, prop.value.len());
        }
        
        // 特殊处理有reg属性的设备
        if let Some(reg) = node.property("reg") {
            if let Ok(regions) = reg.as_reg() {
                for (i, region) in regions.enumerate() {
                    println!("  寄存器区域 {}: 地址={:#x}, 大小={:#x}",
                        i, region.starting_address, region.size.unwrap_or(0));
                }
            }
        }
        
        // 特殊处理中断属性
        if let Some(interrupts) = node.property("interrupts") {
            println!("  中断信息: {:?}", interrupts.value);
        }
    }
}

注意事项

1. fdt库支持no_std环境，适合嵌入式开发
2. 设备树二进制数据必须正确对齐
3. 解析时要注意处理可能的错误情况
4. 属性值的解释需要根据设备树绑定规范进行

这个库提供了高效的方式来解析和处理Flattened Device Tree数据结构，特别适合嵌入式系统开发和裸机编程场景。