Linux 驱动之设备树

参考视频地址

【北京迅为】嵌入式学习之Linux驱动（第七期_设备树_全新升级）_基于RK3568_哔哩哔哩_bilibili

本章总领

1.设备树基本知识

什么是设备树？

Linux之父Linus Torvalds在2011年3月17日的ARM Linux邮件列表中说道：This whole ARM thing is a f*cking pain in the ass。之后ARMLinux社区引入了设备树。为什么Linus Torvalds会爆粗口呢？

在讲平台总线模型的时候，平台总线模型是把驱动分成了两个部分，一部分是device，一部分是driver，设备信息和驱动分离这个设计非常的好。device部分是描述硬件的。一般device部分的代码会放在内核源码中arch/arm/plat-xxx和arch/arm/mach-xxx下面。但是随着Linux支持的硬件越来越多，在内核源码下关于硬件描述的代码也越来越多。并且每修改一下就要编译一次内核。

长此以往Linux内核里面就存在了大量"垃圾代码"，而且非常多，这里说的"垃圾代码"是关于对硬件描述的代码。从长远看，这些代码对Linux内核本身并没有帮助，所以相当于Linux内核是"垃圾代码"。但是并不是说平台总线这种方法不好。

为了解决这个问题 ，设备树就被引入到了Linux上。使用设备树来剔除相对内核来说的"垃圾代码"，既用设备树来描述硬件信息，用来替代原来的device部分的代码。虽然用设备树替换了原来的device部分，但是平台总线模型的匹配和使用基本不变。并且对硬件修改以后不必重新编译内核。直接需要将设备树文件编译成二进制文件，在通过bootloader传递给内核即可。所以设备树就是用来描述硬件资源的文件。

设备树是描述硬件的文本文件，因为语法结构像树一样。所以叫设备树。

设备树的基本概念

基本名词解释

shell 复制代码

<1>DT:Device Tree //设备树
<2>FDT: Flattened Device Tree //开放设备树，起源于OpenFirmware (OF)
<3>dts: device tree source的缩写 //设备树源码
<4>dtsi: device tree source include的缩写 //通用的设备树源码
<5>dtb: device tree blob的缩写//编译设备树源码得到的文件
<6>dtc: device tree compiler的缩写 //设备树编译器

DTS, DTSI, DTB, DTC 之间的关系：

DTS和DTSI相当于源码文件，通过DTC这个编译器，编译生成DTB文件。

以RK3588为例，设备树文件路径为：kernel/arch/arm64/boot/dts/rockchip

DTC编译器的使用

以RK3588为例, DTC编译器源码路径：kernel/scripts/dtc；如果正常编译完内核后，会在这个路径生成编译器dtc。

如果你编译完内核代码后，进入到kernel/scripts/dtc路径，发现没有生成dtc编译器，那么检查kernel路径下.config配置文件，是否包含:CONFIG_DTC=y

如果没有，请将其加入到.config里面。（需要高版本的内核代码，支持设备树）

编译设备树

shell 复制代码

dtc -I dts -O dtb -o xxx.dtb xxx.dts

反编译设备树

shell 复制代码

dtc -I dtb -O dts -o xxx.dts xxx.dtb

编译内核设备树

进入到内核的顶层路径，执行make dtbs, 这种方法需要使能环境变量，暂时无法在我的rk3588内核上编译通过，会报错。

实验测试

编写一个简单的设备树文件，代码路径：/home/topeet/Linux/my-test/40_dtc/my_device_tree.dts, 代码如下所示：

shell 复制代码

/dts-v1/;
/ {

};

这个设备树很简单，只包含了根节点/，而根节点中没有任何子节点或属性。这个示例并没有描述任何具体的硬件设备或连接关系，它只是一个最基本的设备树框架，在本小节只是为了测试设备树的编译和反编译。

dts-v1 明确声明该文件使用设备树语法版本1 ，这是设备树源文件的强制要求，必须放在文件第一行，不能省略，否则编译报错。

编译my_device_tree.dts：

shell 复制代码

/home/topeet/Linux/rk3588-linux/kernel/scripts/dtc/dtc -I dts -O dtb -o my_device_tree.dtb my_device_tree.dts

编译完成后，生成my_device_tree.dtb：

shell 复制代码

root@ubuntu:/home/topeet/Linux/my-test/40_dtc# ls
my_device_tree.dtb

反编译my_device_tree.dtb：

shell 复制代码

/home/topeet/Linux/rk3588-linux/kernel/scripts/dtc/dtc -I dtb -O dts -o re_my_device_tree.dts my_device_tree.dtb

反编译完成后，生成re_my_device_tree.dts：

shell 复制代码

root@ubuntu:/home/topeet/Linux/my-test/40_dtc# ls
re_my_device_tree.dts

VSCode 安装设备树插件

搜索插件DeviceTree 并安装。

2.设备树语法

根结点

根结点是设备树必须包含的结点，根结点的名字 "/"，如下所示：

shell 复制代码

/dts-v1/;     // 第一行表示dts文件的版本
/{            // 根结点
  
};

子结点

格式：

shell 复制代码

[label:] node-name[@unit-address] {
	[properties definitions]
	[child nodes]
};

; ``` 其中 `

` 和 `` 是 64 位 C 风格整数，例如： ```c /* Reserve memory region 0x10000000..0x10003fff */ /memreserve/ 0x10000000 0x4000; ``` 在内存保留块的存储格式： ```c struct fdt_reserve_entry { uint64_t address; uint64_t size; }; ``` ##### 3.字符串块字符串块用来存放属性的名字，比如 compatible、reg 等。通过分析 DTB 的头部，我们已经知道字符串块的位置，如 model 在 DTB 中的表示： ![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/780a664aa9404e49b1c1ddf38e19a843.png) ##### 4.结构块结构块描述的是设备树的结构，也就是设备树的节点。那如何表示一个节点的开始和结束呢？使用 `0x00000001` 表示节点的开始，然后跟上节点名字（根节点的名字用 `0` 表示），然后使用 `0x00000003` 表示一个属性的开始（每表示一个属性，都要用 `0x00000003` 表示开始），使用 `0x00000002` 表示节点的结束，使用 `0x00000009` 表示根节点的结束（整个结构块的结束）属性的名字和值用结构体表示： ```C struct { uint32_t len; uint32_t nameoff; } ``` * `len` 表示属性值的长度 * `nameoff` 表示属性名字在字符串块中的偏移例子中以下节点在 DTB 中是如何表示的呢？ ```c { model = "This is my devicetree!"; #address-cells = <1>; #size-cells = <1>; chosen { bootargs = "root=/dev/nfs rw nfsroot=192.168.1.1 console=ttyS0,115200"; }; ``` ![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/554633f30c8c454a9a8309e3609cf17e.png) *** ** * ** *** #### dtb展开成device_node ##### 设备树是如何传递给内核的 ![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/8251279ec5f34aa0891e8067a28d5363.png) 1. **编译阶段**：DTC将.dts编译为.dtb二进制格式 2. **加载阶段**：U-Boot将内核和.dtb加载到内存 3. **展开阶段**：内核解析.dtb，构建设备树数据结构 4. **使用阶段**：驱动程序通过设备树API获取硬件信息由于内核并不认识dtb文件，需要将dtb文件展开为device_node结构体后，方可识别。 `struct device_node`此结构体定义在Linux内核头文件：`include/linux/of.h`，它是内核中表示设备树节点的核心数据结构, 结构体如下所示： ```c struct device_node { const char *name; // 节点中的 name 属性 const char *type; // 节点中的 device_type 属性 phandle phandle; const char *full_name; // 节点的名字 struct fwnode_handle fwnode; struct property *properties; // 指向该设备节点下的第一个属性，其他属性与该属性链表相连 struct property *deadprops; struct device_node *parent; // 节点的父节点 struct device_node *child; // 节点的子节点 struct device_node *sibling; // 节点的同级节点，也可以叫兄弟节点 // ... 其他成员 }; ``` `struct property`此结构体定义在Linux内核头文件：`include/linux/of.h`，结构体如下所示： ```c struct property { char *name; // 属性名字 int length; // 属性值的长度 void *value; // 属性值 struct property *next; // 指向该节点的下一个属性 // ... 其他成员 }; ``` 1. 每个字段的作用： * `name`：属性名称字符串（如"compatible", "reg"等） * `length`：属性值的字节长度 * `value`：指向属性值的指针 * `next`：指向同一节点的下一个属性，形成链表 2. 设备树节点的所有属性通过`next`指针连接成单向链表： ![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/dd828f50a9d14e95ba134315eb93097e.png) DTB展开为device_node，链表逻辑结构图： ![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/764fe200c8634e7383cf661cd9a7a26f.png) ##### 实例：dtb展开成device_node 首先来到源码目录下的"/init/main.c"文件，找到其中的start_kernel函数，start_kernel函数是 Linux 内核启动的入口点，它是Linux内核的核心函数之一，负责完成内核的初始化和启动过程，具体内容如下所示： ```c asmlinkage __visible void __init __no_sanitize_address start_kernel(void) { char*command_line; char*after_dashes; set_task_stack_end_magic(&init_task); //设置任务栈的魔数 smp_setup_processor_id(); //设置处理器ID debug_objects_early_init(); //初始化调试对象 cgroup_init_early(); //初始化cgroup（控制组） local_irq_disable(); //禁用本地中断 early_boot_irqs_disabled=true; //标记早期引导期间中断已禁用 /* *中断仍然被禁用。进行必要的设置，然后启用它们。 */ boot_cpu_init(); //初始化引导CPU page_address_init(); //设置页地址 pr_notice("%s",linux_banner); //打印Linux内核版本信息 setup_arch(&command_line); //架构相关的初始化 mm_init_cpumask(&init_mm); //初始化内存管理的cpumask（CPU掩码） setup_command_line(command_line); //设置命令行参数 setup_nr_cpu_ids(); //设置CPU个数 setup_per_cpu_areas(); //设置每个CPU的区域 smp_prepare_boot_cpu(); //准备启动CPU（架构特定的启动CPU钩子） boot_cpu_hotplug_init(); //初始化热插拔的引导CPU build_all_zonelists(NULL); //构建所有内存区域列表 page_alloc_init(); //初始化页面分配器 ........ } ``` 代码第17行`setup_arch(&command_line);`该函数定义在内核源码的 `/arch/arm64/kernel/setup.c`文件中，具体内容如下所示: ```c void __init __no_sanitize_address setup_arch(char **cmdline_p) { ...; setup_machine_fdt(__fdt_pointer); // 设置机器的FDT（平台设备树） ...; if (acpi_disabled) unflatten_device_tree(); // 展开设备树 } ``` 在setup_arch函数中与设备树相关的函数分别为第4行的`setup_machine_fdt(__fdt_pointer)`和第8行的`unflatten_device_tree()`，接下来将对上述两个函数进行详细的介绍。 ###### setup_machine_fdt(__fdt_pointer) setup_machine_fdt(fdt_pointer)中的fdt_pointer是dtb二进制文件加载到内存的地址，该地址由bootloader启动kernel时通过x0寄存器传递过来的，具体的汇编代码在内核源码目录下的`/arch/arm64/kernel/head.S`文件中，具体内容如下所示： ```shell preserve_boot_args: mov x21, x0 //x21=FDT __primary_switched: str_l x21, __fdt_pointer, x5 //Save FDT pointer ``` 第2行:将寄存器x0的值复制到寄存器x21。x0寄存器中保存了一个指针，该指针指向设备树（Device Tree）。第4行:将寄存器x21的值存储到内存地址__fdt_pointer中。然后来看setup_machine_fdt函数，该函数定义在内核源码的"/arch/arm64/kernel/setup.c" 文件中，具体内容如下所示： ```c static void __init setup_machine_fdt(phys_addr_t dt_phys) { int size; //将设备树物理地址映射到内核虚拟地址空间 void *dt_virt = fixmap_remap_fdt(dt_phys, &size, PAGE_KERNEL); const char *name; if (dt_virt) //保留设备树占用的内存区域 memblock_reserve(dt_phys, size); if (!dt_virt || !early_init_dt_scan(dt_virt)) { pr_crit("\n" "Error: invalid device tree blob at physical address %pa (virtual address 0x%p)\n" "The dtb must be 8-byte aligned and must not exceed 2 MB in size\n" "\nPlease check your bootloader.", &dt_phys, dt_virt); while (true) cpu_relax(); } /* Early fixups are done, map the FDT as read-only now */ fixmap_remap_fdt(dt_phys, &size, PAGE_KERNEL_RO); //获取设备树的机器名 name = of_flat_dt_get_machine_name(); if (!name) return; pr_info("Machine model: %s\n", name); dump_stack_set_arch_desc("%s (DT)", name); } ``` 第5行代码：fixmap_remap_fdt()将设备树映射到内核虚拟地址空间中的fixmap区域。第10行代码：如果映射成功，则使用memblock_reserve()保留设备树占用的物理内存区域。第12行代码：调用函数early_init_dt_scan(dt_virt)，该函数功能是检查设备树的有效性和完整性，如果设备树无效或扫描失败，则会输出错误信息并进入死循环。，该函数定义在内核源码的"drivers/of/fdt.c"目录下，具体内容如下所示： ```c bool __init early_init_dt_scan(void *params) { bool status; //验证设备树的兼容性和完整性 status = early_init_dt_verify(params); if (!status) return false; //扫描设备树节点 early_init_dt_scan_nodes(); return true; } ``` 第5行代码：首先，调用early_init_dt_verify()函数对设备树进行兼容性和完整性验证。该函数可能会检查设备树中的一致性标记、版本信息以及必需的节点和属性是否存在。如果验证失败，函数会返回false。该函数的具体内容如下所示： ```c bool __init early_init_dt_verify(void *params) { if (!params) return false; /* 检查设备树头部的有效性 */ if (fdt_check_header(params)) return false; /* 设置指向设备树的指针为传入的参数 */ initial_boot_params = params; /* 计算设备树的CRC32校验值, 将结果保存到of_fdt_crc32中 */ of_fdt_crc32 = crc32_be(~0, initial_boot_params, fdt_totalsize(initial_boot_params)); return true; } ``` 第7行代码，检测设备树DTB的`header`是否合法，检查设备树头部的有效性。fdt_check_header是一个用于检查设备树头部的函数，如果设备树头部无效，则返回false，表示设备树不合法。第11行代码，保存设备树指针。第14行代码，计算设备树CRC32校验值。然后继续回到early_init_dt_scan()函数中，如果设备树验证成功（即status为真），则调用early_init_dt_scan_nodes()函数。这个函数的作用是扫描设备树的节点并进行相应的处理，该函数的具体内容如下所示： ```c void __init early_init_dt_scan_nodes(void) { int rc = 0; /*从/chosen节点中检索各种信息 */ rc = of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line); if (!rc) pr_warn("No chosen node found, continuing without\n"); /* 初始化{size,address}-cells信息 */ of_scan_flat_dt(early_init_dt_scan_root, NULL); /* 设置内存信息，调用early_init_dt_add_memory_arch函数 */ of_scan_flat_dt(early_init_dt_scan_memory, NULL); } ``` 函数early_init_dt_scan_nodes 被声明为__init，这表示它是在内核初始化阶段被调用，并且在初始化完成后不再需要。该函数的目的是在早期阶段扫描设备树节点，并执行一些初始化操作。函数中主要调用了of_scan_flat_dt函数，该函数用于扫描平面设备树（flatdevicetree）。平面设备树是一种将设备树以紧凑形式表示的数据结构，它不使用树状结构，而是使用线性结构，以节省内存空间。具体来看，early_init_dt_scan_nodes 函数的执行步骤如下：（1）of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line)：从设备树的/chosen 节点中检索各种信息。/chosen节点通常包含了一些系统的全局配置参数，比如命令行参数。 early_init_dt_scan_chosen 是一个回调函数，用于处理/chosen 节点的信息。boot_command_line 是一个参数，表示内核启动时的命令行参数。（2）of_scan_flat_dt(early_init_dt_scan_root, NULL)：初始化{size,address}-cells 信息。 {size,address}-cells 描述了设备节点中地址和大小的编码方式。early_init_dt_scan_root 是一个回调函数，用于处理设备树的根节点。（3）of_scan_flat_dt(early_init_dt_scan_memory, NULL) ：设置内存信息，并调用 early_init_dt_add_memory_arch 函数。这个步骤主要用于在设备树中获取内存的相关信息，并将其传递给内核的内存管理模块。early_init_dt_scan_memory是一个回调函数，用于处理内存信息。 ###### unflatten_device_tree() 该函数用于解析设备树，将紧凑的设备树数据结构转换为树状结构的设备树，该函数定义在内核源码目录下的"/drivers/of/fdt.c"文件中，具体内容如下所示： ```c void __init unflatten_device_tree(void) { /* 解析设备树 */ __unflatten_device_tree(initial_boot_params, NULL, &of_root, early_init_dt_alloc_memory_arch, false); /* 获取指向 "/chosen" 和 "/aliases" 节点的指针，以供全局使用 */ of_alias_scan(early_init_dt_alloc_memory_arch); /* 运行设备树的单元测试 */ unittest_unflatten_overlay_base(); } ``` 该函数主要用于解析设备树，并将解析后的设备树存储在全局变量of_root中。函数首先调用__unflatten_device_tree函数来执行设备树的解析操作。解析后的设备树将使用of_root指针进行存储。接下来，函数调用of_alias_scan函数。这个函数用于扫描设备树中的/chosen和/aliases节点，并为它们分配内存。这样，其他部分的代码可以通过全局变量访问这些节点。最后，函数调用unittest_unflatten_overlay_base函数，用于运行设备树的单元测试。然后对__unflatten_device_tree这一设备树的解析函数进行详细的介绍，该函数的具体内容如下所示： ```c void *__unflatten_device_tree(const void *blob, struct device_node *dad, struct device_node **mynodes, void *(*dt_alloc)(u64 size, u64 align), bool detached) { int size; void *mem; pr_debug(" -> unflatten_device_tree()\n"); if (!blob) { pr_debug("No device tree pointer\n"); return NULL; } pr_debug("Unflattening device tree:\n"); pr_debug("magic: %08x\n", fdt_magic(blob)); pr_debug("size: %08x\n", fdt_totalsize(blob)); pr_debug("version: %08x\n", fdt_version(blob)); if (fdt_check_header(blob)) { pr_err("Invalid device tree blob header\n"); return NULL; } /* 第一遍扫描，计算大小 */ size = unflatten_dt_nodes(blob, NULL, dad, NULL); if (size < 0) return NULL; size = ALIGN(size, 4); pr_debug(" size is %d, allocating...\n", size); /* 为展开的设备树分配内存 */ mem = dt_alloc(size + 4, __alignof__(struct device_node)); if (!mem) return NULL; memset(mem, 0, size); *(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef); pr_debug(" unflattening %p...\n", mem); /* 第二遍扫描，实际展开设备树 */ unflatten_dt_nodes(blob, mem, dad, mynodes); if (be32_to_cpup(mem + size) != 0xdeadbeef) pr_warn("End of tree marker overwritten: %08x\n", be32_to_cpup(mem + size)); if (detached && mynodes) { of_node_set_flag(*mynodes, OF_DETACHED); pr_debug("unflattened tree is detached\n"); } pr_debug(" <- unflatten_device_tree()\n"); return mem; } ``` 该函数的重点在两次设备树的扫描上，第一遍扫描的目的是计算展开设备树所需的内存大小。第28行：unflatten_dt_nodes函数的作用是递归地遍历设备树数据块，并计算展开设备树所需的内存大小。它接受四个参数：blob（设备树数据块指针）、start（当前节点的起始地址，初始为NULL）、dad（父节点指针）和mynodes（用于存储节点指针数组的指针，初始为NULL）。第一遍扫描完成后，unflatten_dt_nodes函数会返回展开设备树所需的内存大小，然后在对大小进行对齐操作，并为展开的设备树分配内存。第二遍扫描的目的是实际展开设备树，并填充设备节点的名称、类型和属性等信息。第47行：再次调用了unflatten_dt_nodes函数进行第二遍扫描。通过这样的过程，第二遍扫描会将设备树数据块中的节点展开为真正的设备节点，并填充节点的名称、类型和属性等信息。这样就完成了设备树的展开过程。最后我们来对unflatten_dt_nodes函数内容进行一下深究，unflatten_dt_nodes函数具体定义如下所示: ```c static int unflatten_dt_nodes(const void *blob, void *mem, struct device_node *dad, struct device_node **nodepp) { struct device_node *root; //根节点 int offset = 0, depth = 0, initial_depth = 0; //偏移量、深度和初始深度 #define FDT_MAX_DEPTH 64 //最大深度 struct device_node *nps[FDT_MAX_DEPTH]; //设备节点数组 void *base = mem; //基地址，用于计算偏移量 bool dryrun = !base; //是否只是模拟运行，不实际处理 if (nodepp) *nodepp = NULL; //如果指针不为空，将其置为空指针 /* * 如果@dad有效，则表示正在展开设备子树。 * 在第一层深度可能有多个节点。 * 将@depth设置为1，以使fdt_next_node()正常工作。 * 当发现负的@depth时，该函数会立即退出。 * 否则，除第一个节点外的设备节点将无法成功展开。 */ if (dad) depth = initial_depth = 1; root = dad; //根节点为@dad nps[depth] = dad; //将根节点放入设备节点数组 for (offset = 0; offset >= 0 && depth >= initial_depth; offset = fdt_next_node(blob, offset, &depth)) { if (WARN_ON_ONCE(depth >= FDT_MAX_DEPTH)) continue; // 如果未启用CONFIG_OF_KOBJ并且节点不可用，则跳过该节点 if (!IS_ENABLED(CONFIG_OF_KOBJ) && !of_fdt_device_is_available(blob, offset)) continue; //填充节点信息，并将子节点添加到设备节点数组 if (!populate_node(blob, offset, &mem, nps[depth], &nps[depth+1], dryrun)) return mem - base; if (!dryrun && nodepp && !*nodepp) *nodepp = nps[depth+1]; //将子节点指针赋值给@nodepp if (!dryrun && !root) root = nps[depth+1]; //如果根节点为空，则将子节点设置为根节点 } if (offset < 0 && offset != -FDT_ERR_NOTFOUND) { pr_err("Error %d processing FDT\n", offset); return -EINVAL; } //反转子节点列表。一些驱动程序假设节点顺序与.dts文件中的节点顺序一致 if (!dryrun) reverse_nodes(root); return mem - base; //返回处理的字节数 } ``` `unflatten_dt_nodes`函数的作用我们在上面已经讲解过了，这里重点介绍第31行的`fdt_next_node()`函数和第41行的`populate_node`函数。 `fdt_next_node()`函数用来遍历设备树的节点。从偏移量为0开始，只要偏移量大于等于0 且深度大于等于初始深度，就执行循环。循环中的每次迭代都会处理一个设备树节点。在每次迭代中，首先检查深度是否超过了最大深度`FDT_MAX_DEPTH`，如果超过了，则跳过该节点。如果未启用`CONFIG_OF_KOBJ`并且节点不可用（通过`of_fdt_device_is_available()`函数判断），则跳过该节点。随后调用`populate_node()`函数填充节点信息，并将子节点添加到设备节点数组nps中。`populate_node()`函数定义如下所示： ```c static bool populate_node(const void *blob, int offset, void **mem, struct device_node *dad, struct device_node **pnp, bool dryrun) { struct device_node *np; //设备节点指针 const char *pathp; //节点路径字符串指针 unsigned int l, allocl; //路径字符串长度和分配的内存大小 pathp = fdt_get_name(blob, offset, &l); //获取节点路径和长度 if (!pathp) { *pnp = NULL; return false; } allocl = ++l; //分配内存大小为路径长度加一，用于存储节点路径字符串 np = unflatten_dt_alloc(mem, sizeof(struct device_node) + allocl, __alignof__(struct device_node)); //分配设备节点内存 if (!dryrun) { char *fn; of_node_init(np); //初始化设备节点 np->full_name = fn = ((char *)np) + sizeof(*np); //设置设备节点的完整路径名 memcpy(fn, pathp, l); //将节点路径字符串复制到设备节点的完整路径名中 if (dad != NULL) { np->parent = dad; //设置设备节点的父节点 np->sibling = dad->child; //设置设备节点的兄弟节点 dad->child = np; //将设备节点添加为父节点的子节点 } } populate_properties(blob, offset, mem, np, pathp, dryrun); //填充设备节点的属性信息 if (!dryrun) { np->name = of_get_property(np, "name", NULL); //获取设备节点的名称属性 if (!np->name) np->name = ""; } *pnp = np; return true; } ``` 在populate_node函数中首先会调用第18行的unflatten_dt_alloc函数分配设备节点内存。分配的内存大小为 sizeof(struct device_node) + allocl 字节，并使用 **alignof**(struct device_node) 对齐。然后调用populate_properties函数填充设备节点的属性信息。该函数会解析设备节点的属性，并根据需要分配内存来存储属性值。至此，关于dtb二进制文件的解析过程就讲解完成了，完整的源码分析流程图如下所示： ![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/03a5476be5534d9f82c17860d12ce5c7.png) #### device_node转化为platform_device 设备树替换了平台总线模型当中对硬件资源描述的 device 部分。所以设备树也是对硬件资源进行描述的文件。在平台总线模型中，device 部分是用 platform_device 结构体来描述硬件资源的。所以内核最终会将内核认识的 device_node 树转换为 platform_device。但是并不是所有的节点都会被转换成 platform_device，只有满足要求的才会转换成 platform_device，转换成 platform_device 的节点可以在 `/sys/bus/platform/devices` 下查看。节点要满足什么要求才会被转换成 platform_device 呢？ ##### 转会规则 1. **根节点下包含 compatible 属性的子节点** * 例如： ```c / { mydevice { compatible = "vendor,device"; // ✅ 会被转换 }; }; ``` 2. **节点中 compatible 属性包含特定标识的节点** * 若节点的 compatible 属性包含以下值之一： * `"simple-bus"` * `"simple-mfd"` * `"isa"` * 则该节点下包含 compatible 属性的子节点会被转换 * 例如： ```c bus { compatible = "simple-bus"; // 标识符 #address-cells = <1>; #size-cells = <1>; child@0 { compatible = "vendor,child"; // ✅ 会被转换 }; }; ``` 3. **特殊排除规则** * 如果节点的 compatible 属性包含 `"arm,primecell"` 值 * 则该节点会被转换为 amba 设备（**不是** platform_device） * 例如： ```c uart0: serial@fe001000 { compatible = "arm,primecell", "arm,pl011"; // ❌ 转换为amba设备 reg = <0xfe001000 0x1000>; }; ``` *** ** * ** *** 内核是如何将 device_node 转换为 platform_device 和上节课的转换规则是怎么来的。在内核启动的时候会执行 of_platform_default_populate_init 函数，这个函数是用 arch_initcall_sync 来修饰的。 arch_initcall_sync(of_platform_default_populate_init); 所以系统启动的时候会调用 of_platform_default_populate_init 函数。调用参数参数参数内部调用参数参数参数遍历节点根据设置 of_platform_default_populate_init of_platform_default_populate NULL NULL NULL of_platform_populate root (根节点) of_default_bus_match_table lookup.parent 对每个匹配节点调用 of_platform_bus_create of_platform_device_create_pdata of_device_alloc 设置platform_device资源 device_node属性 platform_device.resource of_default_bus_match_table {.compatible = 'simple-bus'} {.compatible = 'simple-mfd'} {.compatible = 'isa'} {.compatible = 'arm,amba-bus'} {} /\* NULL terminated list \*/ 关键函数说明： 1. **`of_platform_default_populate_init`** * 内核初始化时调用的入口函数 * 使用`arch_initcall_sync`修饰，在内核启动早期执行 2. **`of_platform_default_populate`** * 参数全为NULL表示使用默认值 * 实际调用`of_platform_populate` 3. **`of_platform_populate`** * 核心转换函数 * 参数： * `root`：设备树根节点 * `matches`：总线匹配表（`of_default_bus_match_table`） * `parent`：父设备（此处为NULL） 4. **`of_default_bus_match_table`** ```c static const struct of_device_id of_default_bus_match_table[] = { { .compatible = "simple-bus", }, { .compatible = "simple-mfd", }, { .compatible = "isa", }, #ifdef CONFIG_ARM_AMBA { .compatible = "arm,amba-bus", }, #endif {} /* 空值终止列表 */ }; ``` * 定义了哪些总线类型下的节点需要转换 5. **`of_platform_device_create_pdata`** * 为匹配的节点创建platform_device * 调用`of_device_alloc`分配设备资源 6. **`of_device_alloc`** * 从device_node提取资源信息 * 设置platform_device的resource数组 * 关键转换： * `reg`属性 → I/O内存资源 * `interrupts`属性 → IRQ资源 * `dma`属性 → DMA资源 ##### 资源转换示例： ```c // 设备树节点 serial@4000 { compatible = "ns16550a"; reg = <0x4000 0x100>; interrupts = <10 1>; }; ``` 转化如下： ```c // platform_device资源 static struct resource serial_resources[] = { [0] = { .start = 0x4000, // 寄存器起始地址 .end = 0x40FF, // 结束地址 (0x4000 + 0x100 - 1) .flags = IORESOURCE_MEM, }, [1] = { .start = 10, // 中断号 .end = 10, .flags = IORESOURCE_IRQ | IRQ_TYPE_EDGE_RISING, } }; ``` *** ** * ** *** #### 设备树下platform_device和platform_driver匹配首先来对rk3588的设备树结构进行以下介绍，根据sdk源码目录下的"device/rockchip/r k3588/BoardConfig-rk3588-evb7-lp4-v10.mk"默认配置文件可以了解到编译的设备树为 rk3588 evb7-lp4-v10-linux.dts，整理好的设备树之间包含关系列表如下所示： | 顶层设备树 | rk3588-evb7-lp4-v10-linux.dts | | | |:-----------|:------------------------------|-------------------|---------------------------| | **第二级设备树** | rk3588-evb7-lp4.dtsi | rk3588-linux.dtsi | topeet_rk3588_config.dtsi | | **第三级设备树** | rk3588.dtsi | | | | | rk3588-evb.dtsi | | | | | rk3588-rk806-single.dtsi | | | | | topeet_screen_lcds.dts | | | | | topeet_camera_config.dtsi | | | rk3588-evb7-lp4-v10-linux.dts 是顶层设备树，为了便于理解我们之后在该设备树下进行节点的添加（当然这里也可以修改其他设备树），进入该设备树文件之后如下所示： ```c / { topeet { #address-cells = <1>; #size-cells = <1>; compatible = "simple-bus"; myLed{ compatible = "my_devicetree"; reg = <0xFEC30004 0x00000004>; }; }; }; ``` 保存退出，重新编译内核文件。修改设备驱动文件，代码路径：/home/topeet/Linux/my-test/44_devicetree_probe/platform_drv.c, 代码如下所示： ```c #include #include #include #include #include int my_platform_probe(struct platform_device *pdev) { printk(KERN_INFO "my_platform_probe: Probing platform device.\n"); return 0; } int my_platform_remove(struct platform_device *pdev) { printk("my_platform_driver: Removing platform device.\n"); return 0; } const struct platform_device_id mydriver_id_table = { .name = "my_platform_device", }; const struct of_device_id od_match_table_id[] = { {.compatible="my_devicetree"}, {} }; static struct platform_driver my_platform_driver = { .probe = my_platform_probe, .remove = my_platform_remove, .driver = { .name = "my_platform_device", .owner = THIS_MODULE, .of_match_table = od_match_table_id, }, .id_table = &mydriver_id_table, }; static int __init my_platform_driver_init(void) { int ret; ret = platform_driver_register(&my_platform_driver); if( ret ) { printk(KERN_ERR "Failed to register platform driver.\n"); return ret; } printk(KERN_INFO "my_platform_driver: Platform driver initialized.\n"); return 0; } static void __exit my_platform_driver_exit(void) { platform_driver_unregister(&my_platform_driver); printk(KERN_INFO "my_platform_driver: Platform driver exited.\n"); } module_init(my_platform_driver_init); module_exit(my_platform_driver_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("YAN"); MODULE_VERSION("v1.0"); ``` ###### 查看设备树节点是否成功被加载到系统 ```shell ls /sys/firmware/devicetree/base/topeet/ '#address-cells' '#size-cells' compatible myLed name ``` ### 4.of操作函数 #### device_node结构体 Linux 内核使用device_node结构体描述一个和结点，这个结构体定义在文件include/linux/of.h中: ```c struct device_node { const char *name; phandle phandle; const char *full_name; struct fwnode_handle fwnode; struct property *properties; struct property *deadprops; /* removed properties */ struct device_node *parent; struct device_node *child; struct device_node *sibling; #if defined(CONFIG_OF_KOBJ) struct kobject kobj; #endif unsigned long _flags; void *data; #if defined(CONFIG_SPARC) unsigned int unique_id; struct of_irq_controller *irq_trans; #endif }; ``` #### of_ 函数操作集 ##### 1.节点查找函数 ###### of_find_node_by_name(from, name) ```c struct device_node *of_find_node_by_name(struct device_node *from, const char *name); ``` * 作用：通过节点名称查找设备树节点 * 参数： * `from`：起始节点（NULL 表示从根节点开始） * `name`：目标节点名称 * 返回值：成功返回节点指针，失败返回 NULL ###### of_find_node_by_path(path) ```c struct device_node *of_find_node_by_path(const char *path); ``` * 通过完整路径查找节点（如 `/soc/usb@fe800000`） ###### of_find_compatible_node(from, type, compatible) struct device_node *of_find_compatible_node(struct device_node *from, const char *type, const char *compatible); * 通过 compatible 属性查找节点 *** ** * ** *** ##### 2.属性操作函数 Linux内核使用property结构体来描述一个属性，这个结构体定义在文件：include/linux/of.h ```c struct property { char *name; int length; void *value; struct property *next; }; ``` ###### of_find_property(node, name, lenp) struct property *of_find_property(const struct device_node *np, const char *name, int *lenp); * 获取节点属性值 * `lenp`：返回属性长度 ###### of_property_read_xxx()系列 int of_property_read_u32(const 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); // 按索引的值index读取 int of_property_read_u32_index(const struct device_node *np,const char *propname,u32 index,u32 *out_value); * 读取不同类型的属性值（u8/u16/u32/u64/string/array） **of_property_read_u32和of_property_read_u32_index的区别：** | 特性 | `of_property_read_u32` | `of_property_read_u32_index` | |:----------|:-----------------------|:-----------------------------| | **读取目标** | 属性中的第一个值 | 属性中指定索引位置的值 | | **参数差异** | 不需要索引参数 | 需要明确指定索引位置 | | **适用场景** | 单值属性 | 多值数组属性中的特定元素 | | **返回值处理** | 只读取第一个值 | 可读取任意位置的指定值 | | **错误条件** | 属性不存在或长度不足4字节 | 索引越界或长度不足 | **使用场景区别** * **`of_property_read_u32`** 适用于单值属性： ```c clock-frequency = <50000000>; // 单个值 ``` ```c u32 clk_freq; of_property_read_u32(np, "clock-frequency", &clk_freq); ``` * **`of_property_read_u32_index`** 适用于多值数组中的特定元素： ```c reg = <0x40008000 0x1000>; // 两个值的数组 interrupts = <0 40 0x4>; // 三个值的数组 ``` ```c u32 irq_num; // 读取interrupts属性的第2个值（索引1） of_property_read_u32_index(np, "interrupts", 1, &irq_num); ``` *** ** * ** *** ###### of_property_count_elems_of_size 该函数在设备树中的设备节点下查找指定名称的属性，并获取该属性中元素的数量。调用该函数可以用于获取设备树属性中某个属性的元素数量，比如一个字符串列表的元素数量或一个整数数组的元素数量等。 ```c #include int of_property_count_elems_of_size(const struct device_node *np, const char *propname, int elem_size); ``` **函数参数**: np:设备节点。 propname:需要获取元素数量的属性名。 elem_size:单个元素的尺寸。 **返回值**: 如果成功获取了指定属性中元素的数量，则返回该数量；如果未找到属性或属性中没有元素，则返回0。 ##### 3.节点遍历函数 ###### of_get_parent(node) ```c struct device_node *of_get_parent(const struct device_node *node); ``` * 获取父节点 ###### of_get_next_child(parent, prev) struct device_node *of_get_next_child(const struct device_node *parent, struct device_node *prev); * 遍历子节点（`prev = NULL` 开始） ###### of_get_next_available_child() * 获取下一个可用的子节点 *** ** * ** *** ##### 4.地址转化函数 ###### of_translate_address(node, in_addr) ```c u64 of_translate_address(struct device_node *np, const __be32 *addr); ``` * 将逻辑地址转换为物理地址 ###### of_iomap(node, index) ```c void __iomem *of_iomap(struct device_node *np, int index); ``` * 直接映射设备内存到虚拟地址空间 *** ** * ** *** ##### 5.中断相关函数 ###### of_irq_get(node, index) ```c int of_irq_get(struct device_node *np, int index); ``` * 获取中断号 ###### of_irq_to_resource_table() * 解析中断资源表 ###### gpio_to_irq() ```c int gpio_to_irq(unsigned int gpio) ``` **函数作用**：获取中断号。 **函数参数**： gpio： gpio编号 **返回值**：成功返回对应中断号。 ###### irq_of_parse_and_map() ```c unsigned int irq_of_parse_and_map(struct device_node *dev, int index) ``` **函数作用**：从设备树节点的 `interrupts` 属性中解析并映射到对应的硬件中断号。 **函数参数**： `*dev`: 目标设备节点 `index`:要获取的中断在属性中的索引位置 **返回值**：成功：返回映射后的中断号失败：返回0 ###### irqd_get_trigger_type() ```c u32 irqd_get_trigger_type(struct irq_data *d) ``` **函数作用**：从 `irq_data` 结构中获取中断触发类型标志 **函数参数**： \*d: 指向 irq_data 结构的指针 **返回值**：成功返回中断触发标志。失败返回0 ###### irq_get_irq_data() ```c struct irq_data *irq_get_irq_data(unsigned int irq) ``` **函数作用**：通过中断号获取对应的 `irq_data` 结构体 **函数参数**： irq : 中断号 **返回值**：成功：返回指向irq_data的指针。失败：返回NULL。 **示例代码**： ```c #include // 1. 获取中断号 unsigned int irq = irq_of_parse_and_map(dev_node, 0); // 2. 获取irq_data结构 struct irq_data *irq_data = irq_get_irq_data(irq); if (!irq_data) { pr_err("无法获取irq_data\n"); return -ENODEV; } // 3. 获取中断触发类型 u32 trigger_type = irqd_get_trigger_type(irq_data); pr_info("中断触发类型: 0x%x\n", trigger_type); // 4. 根据类型处理中断 switch (trigger_type) { case IRQF_TRIGGER_RISING: pr_info("上升沿触发\n"); break; case IRQF_TRIGGER_FALLING: pr_info("下降沿触发\n"); break; case IRQF_TRIGGER_HIGH: pr_info("高电平触发\n"); break; case IRQF_TRIGGER_LOW: pr_info("低电平触发\n"); break; default: pr_warn("未知触发类型\n"); } ``` *** ** * ** *** #### ranges属性 ##### 1. **基本格式** ```c ranges = ; ``` 或 ```c ranges; // 空属性 ``` ##### 2. **字段说明** | 字段 | 说明 | 长度决定属性 | |:---------------------|:-----------|:---------------------------| | `child-bus-address` | 子地址空间的起始地址 | 由当前节点的 `#address-cells` 决定 | | `parent-bus-address` | 父地址空间的起始地址 | 由父节点的 `#address-cells` 决定 | | `length` | 映射区域的大小 | 由父节点的 `#size-cells` 决定 | ##### 3. **示例解析** ```c ranges = <0x0 0x20 0x100>; ``` * **含义** ： * 子地址空间：`0x0` 到 `0x0 + 0x100`（`0x0-0x100`） * 父地址空间：`0x20` 到 `0x20 + 0x100`（`0x20-0x120`） * **映射关系** ：子空间的 `0x0-0x100` 映射到父空间的 `0x20-0x120` ##### 4. **特殊值含义** | 属性值 | 含义 | |:----------------|:-----------------| | `ranges;` | 1:1 映射（内存区域直接映射） | | `ranges = < >;` | 无映射（地址空间不转换） | ##### 5. **关键属性依赖** ```c soc { #address-cells = <1>; // 父地址用1个32位数表示 #size-cells = <1>; // 长度用1个32位数表示 serial@4000 { #address-cells = <1>; // 子地址用1个32位数表示 #size-cells = <1>; // 子长度用1个32位数表示 ranges = <0x0 0x4000 0x1000>; // 含义: 子地址0x0-0x1000 → 父地址0x4000-0x5000 }; }; ``` ##### 6. **典型应用场景** ###### 场景1：内存映射外设 ```c // 父节点定义 soc { compatible = "simple-bus"; #address-cells = <2>; #size-cells = <2>; ranges; // 1:1映射 }; // 子节点（直接映射） uart0: uart@ff000000 { reg = <0x0 0xff000000 0x0 0x1000>; }; ``` ###### 场景2：地址转换（PCIe设备） ```c pcie_controller { #address-cells = <3>; #size-cells = <2>; // 子地址 → 父地址转换 ranges = <0x02000000 0 0xe0000000 0xc 0x20000000 0 0x20000000>; // 含义: // 子空间: PCIe内存空间 (0x02000000) // 父空间: 0xc20000000-0xc3fffffff }; ``` ###### 场景3：多级转换 ```c // 一级转换 soc { ranges = <0x0 0xf0000000 0x100000>; // 二级转换 i2c@1000 { ranges = <0x0 0x1000 0x100>; // 实际映射: // 子地址0x0 → soc地址0x1000 → 最终物理地址0xf0001000 }; }; ``` ##### 7. **字节序与数据格式** * 所有值均为 **大端序 (Big-Endian)** * 每个值占用32位（4字节） * 示例解析： ```c <0x00000000 0x20000000 0x00001000> // 等同于 <0x0 0x20 0x1000> // 简写形式 ``` ##### 8. **常见错误处理** ```c /* 错误示例1：长度不匹配 */ soc { #address-cells = <2>; // 需要2个地址值 ranges = <0x0 0x4000>; // 缺少长度值 → 编译错误 }; /* 错误示例2：未定义大小 */ serial@4000 { ranges = <0x0 0x4000 0x1000>; // 必须定义 #address-cells 和 #size-cells }; ``` *** ** * ** *** #### 参考资料 --- 设备树bindings文档参考文档路径：`kernel/Documentation/devicetree/bindings` **bindings文档** 设备节点里面除了一些标准的属性（课程中讲解的属性都是标准属性），但是当我们在接触一个新的节点的时候，有的属性不是标准属性，是芯片原厂自定义的属性，我们很难去看懂他是什么意思。这时候我们就可以去源码中查询bindings文档。一般在bindings中可以找到说明。 bindings文档路径：内核源码下：Documentation/devicetree/bindings 但是有的时候有些芯片在bindings中找不到文档，这时候可以去芯片原厂提供的资料中找下，如果也没有，可以咨询芯片供应商和FAE。