Linux内核中的设备树详解

Linux内核中的设备树详解

引言

设备树（Device Tree）是Linux内核中用于描述硬件设备的一种数据结构，它取代了传统的硬编码方式，使得内核能够更灵活地适应不同的硬件平台。本文将深入探讨Linux内核中的设备树机制，包括其原理、语法和应用。

设备树的基本概念

1. 设备树的定义

设备树是一种描述硬件设备的数据结构，它使用树形结构来表示硬件设备的层次关系。

2. 设备树的优势

• 硬件描述与内核分离：硬件描述不再硬编码到内核中
• 灵活性：同一份内核代码可以支持多种硬件平台
• 可维护性：硬件描述更加清晰和集中
• 扩展性：便于添加新的硬件设备

3. 设备树的组成

• DTS：设备树源文件
• DTB：设备树二进制文件
• DTC：设备树编译器

设备树的语法

1. DTS文件结构

// 根节点
/
{
    // 子节点
    node1 {
        // 节点属性
        property = value;
        
        // 子节点
        child1 {
            property1 = value1;
        };
    };
    
    node2 {
        property = value;
    };
};

2. 节点命名

// 节点命名格式
node-name@unit-address

// 示例
serial@10000000 {
    compatible = "ns16550a";
    reg = <0x10000000 0x100>;
};

3. 常用属性

4. 特殊节点

// 根节点
/
{
    model = "Vendor Board";
    compatible = "vendor,board";
    #address-cells = <1>;
    #size-cells = <1>;
    
    // CPU节点
    cpus {
        #address-cells = <1>;
        #size-cells = <0>;
        
        cpu@0 {
            compatible = "arm,cortex-a9";
            reg = <0>;
        };
    };
    
    // 内存节点
    memory {
        device_type = "memory";
        reg = <0x0 0x40000000>;
    };
};

设备树的编译和使用

1. 编译设备树

# 编译DTS到DTB
dtc -I dts -O dtb -o device.dtb device.dts

# 反编译DTB到DTS
dtc -I dtb -O dts -o device.dts device.dtb

# 查看DTB信息
dtc -I dtb -O dts -o - device.dtb

2. 加载设备树

# 通过U-Boot加载
tftpboot ${fdtaddr} device.dtb
bootz ${kerneladdr} - ${fdtaddr}

# 通过GRUB加载
linux /vmlinuz root=/dev/sda1 dtb=/boot/device.dtb

# 通过内核参数加载
bootargs=console=ttyS0,115200 root=/dev/mmcblk0p1 dtb=/boot/device.dtb

3. 查看设备树

# 查看运行时设备树
ls /sys/firmware/devicetree/

# 查看设备节点
find /sys/firmware/devicetree -name "compatible"

# 查看设备属性
cat /sys/firmware/devicetree/base/model

设备树的内核API

1. 设备树遍历

#include <linux/of.h>

// 查找节点
struct device_node *of_find_node_by_name(struct device_node *from, const char *name);
struct device_node *of_find_node_by_type(struct device_node *from, const char *type);
struct device_node *of_find_compatible_node(struct device_node *from, 
                                          const char *type, const char *compatible);

// 获取子节点
struct device_node *of_get_child_by_name(struct device_node *node, const char *name);
struct device_node *of_get_next_child(const struct device_node *node, 
                                     struct device_node *prev);

// 遍历子节点
struct device_node *child;
for_each_child_of_node(parent, child) {
    // 处理子节点
}

2. 属性获取

#include <linux/of.h>

// 获取属性
int of_property_read_u32(struct device_node *np, const char *propname, u32 *out_value);
int of_property_read_string(struct device_node *np, const char *propname, 
                          const char **out_string);
int of_property_read_bool(struct device_node *np, const char *propname);
int of_property_count_u32_elems(struct device_node *np, const char *propname);
int of_property_read_u32_array(struct device_node *np, const char *propname, 
                             u32 *out_values, size_t sz);

// 检查兼容性
int of_device_is_compatible(struct device_node *device, const char *compat);

3. 资源获取

#include <linux/of.h>

// 获取内存资源
struct resource res;
int of_address_to_resource(struct device_node *dev, int index, struct resource *r);

// 获取中断资源
int of_irq_get(struct device_node *dev, unsigned int index);

// 获取时钟
struct clk *of_clk_get(struct device_node *np, const char *id);

// 获取GPIO
int of_get_named_gpio(struct device_node *np, const char *propname, int index);

设备树的应用

1. 平台设备驱动

#include <linux/platform_device.h>

// 设备匹配表
static const struct of_device_id my_driver_of_match[] = {
    { .compatible = "vendor,device", },
    { },
};
MODULE_DEVICE_TABLE(of, my_driver_of_match);

// 平台驱动
static struct platform_driver my_driver = {
    .probe = my_driver_probe,
    .remove = my_driver_remove,
    .driver = {
        .name = "my-driver",
        .of_match_table = my_driver_of_match,
    },
};

// 探测函数
static int my_driver_probe(struct platform_device *pdev) {
    struct device_node *np = pdev->dev.of_node;
    u32 value;
    
    // 获取属性
    if (of_property_read_u32(np, "reg", &value)) {
        dev_err(&pdev->dev, "Failed to read reg property\n");
        return -EINVAL;
    }
    
    // 处理设备
    return 0;
}

2. 设备树覆盖

// 基础设备树
test.dts

// 覆盖文件
test_overlay.dts

// 编译覆盖文件
dtc -I dts -O dtb -o test_overlay.dtbo test_overlay.dts

// 应用覆盖
 echo test_overlay.dtbo > /sys/kernel/config/device-tree/overlays/test

3. 设备树调试

# 查看设备树节点
tree /sys/firmware/devicetree/

# 查看设备匹配
ls /sys/bus/platform/devices/

# 查看设备属性
find /sys/bus/platform/devices/ -name "compatible"

# 查看内核日志
dmesg | grep "of:"  # 设备树相关日志

实际案例分析

1. 简单设备树示例

// 简单的设备树
/
{
    model = "Test Board";
    compatible = "test,board";
    #address-cells = <1>;
    #size-cells = <1>;
    
    memory {
        device_type = "memory";
        reg = <0x00000000 0x40000000>;
    };
    
    soc {
        #address-cells = <1>;
        #size-cells = <1>;
        compatible = "simple-bus";
        ranges;
        
        serial@10000000 {
            compatible = "ns16550a";
            reg = <0x10000000 0x100>;
            interrupts = <1 0>;
            clock-frequency = <1843200>;
            reg-shift = <0>;
            reg-io-width = <1>;
        };
        
        gpio@10010000 {
            compatible = "gpio-controller";
            #gpio-cells = <2>;
            reg = <0x10010000 0x100>;
        };
    };
};

2. 平台驱动示例

#include <linux/module.h>
#include <linux/platform_device.h>

static int my_driver_probe(struct platform_device *pdev) {
    struct device_node *np = pdev->dev.of_node;
    u32 reg;
    int irq;
    
    dev_info(&pdev->dev, "Probing device\n");
    
    // 获取寄存器地址
    if (of_property_read_u32(np, "reg", &reg)) {
        dev_err(&pdev->dev, "Failed to read reg property\n");
        return -EINVAL;
    }
    dev_info(&pdev->dev, "Reg: 0x%x\n", reg);
    
    // 获取中断
    irq = of_irq_get(np, 0);
    if (irq < 0) {
        dev_err(&pdev->dev, "Failed to get irq\n");
        return irq;
    }
    dev_info(&pdev->dev, "IRQ: %d\n", irq);
    
    return 0;
}

static int my_driver_remove(struct platform_device *pdev) {
    dev_info(&pdev->dev, "Removing device\n");
    return 0;
}

static const struct of_device_id my_driver_of_match[] = {
    { .compatible = "test,device", },
    { },
};
MODULE_DEVICE_TABLE(of, my_driver_of_match);

static struct platform_driver my_driver = {
    .probe = my_driver_probe,
    .remove = my_driver_remove,
    .driver = {
        .name = "my-driver",
        .of_match_table = my_driver_of_match,
    },
};

module_platform_driver(my_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Demo");
MODULE_DESCRIPTION("Device tree demo driver");

3. 设备树覆盖示例

// 覆盖文件
/dts-v1/;
/plugin/;

/ {
    fragment@0 {
        target-path = "/soc";
        __overlay__ {
            new-device@10020000 {
                compatible = "test,new-device";
                reg = <0x10020000 0x100>;
                status = "okay";
            };
        };
    };
};

结论

设备树是Linux内核中一种重要的硬件描述机制，它使得内核能够更灵活地适应不同的硬件平台。通过设备树，硬件描述与内核代码分离，提高了系统的可维护性和可扩展性。理解设备树的原理和使用方法，对于嵌入式系统开发和内核移植都有重要意义。随着ARM和其他架构的广泛应用，设备树已经成为Linux内核中硬件描述的标准方式。