背景：基于arm平台的soc种类繁多，硬件资源和配置各不相同。这些平台硬件相关的信息在设备树出现之前，是在kernel/arch/arm/plat-xxx目录和kernel/arch/arm/mach-xxx目录下硬编码的。在kernel看来，这些硬件细节代码只不过是些垃圾，需要一套框架抽象出来，屏蔽这些硬件细节。设备树框架被提出用来统一arm平台硬件配置，屏蔽硬件细节。
术语介绍：
1，DTS（Device Tree Source）：设备树源码。为方便阅读和修改，设备树源文件遵循一定的格式，采用文本方式存放。
2，DTB（Device Tree Blob）：设备树对象。DTS的二进制对象表示形式，通过DTC将DTS编译成DTB。
3，DTC（Device Tree Compiler）：设备树编译器。kernel提供的一个小工具，可以将 DTS 编译成 DTB。
DTS为什么需要转换成DTB？kernel在初始化阶段需要从设备树读取平台的各种硬件信息（如，bootargs/cpu/memory/devices等），bootloader在加载kernel image的同时，也需要加载设备树信息。bootloader将加载后的设备树物理地址传递给kernel，kernel再去配置各种硬件信息。因此，需要定义出DTB的二进制格式，通过DTC将DTS编译成DTB，经bootloader加载，kernel解析DTB，最终在kernel中形成一套完整的device tree。
DTS的格式：
DTS以节点和属性的形式组织设备树：节点是树枝，属性是树叶，节点中可以包含子节点。
1，节点格式：
label : name {
}
（1）label：标签。如果有其他属性需要引用该节点，可以通过 &label 的形式直接引用该节点。
（2）name：节点名称。长度范围是1~31，可以使用如下字符组合：数字（0 ~ 9） 小写字母（a ~ z） 大写字母（A ~ Z） 逗号（,） 句号（.）下划线（_） 加号（+） 以及 减号（-）。并且，规范要求以字母开头。
（3）address：节点地址。其实是用来区分同名设备的，同一空间中的不同节点可能是同一个名称，可以通过不同地址来区分。address并不仅仅指设备地址，也可能是设备编号。比如，对于cpu来说，就没有地址，但是可以通过 cpu，cpu@1来区分不同的cpu。
2，属性格式：
property_name = value
（1）property_name：属性名称。长度范围是1~31，可以使用如下字符组合：数字（0 ~ 9） 小写字母（a ~ z） 逗号（,） 句号（.）下划线（_） 加号（+） 减号（-） 问号（?）以及 sharp（#） 。并且，规范要求以字母开头。
（2）value：属性值。标准定义的属性值基本类型如下：<empty> <u32> <u64> <string> <prop-encoded-array> <phandle> <stringlist>。
<prop-encoded-array>：混合编码，自定义property的值。
<phandle>：作为一个句柄指向一个Node，用来引用Node。很少使用，一般使用 &label 方式引用node。
3，标准属性：
（1）compatible：字符串数组类型。通常用来匹配driver和device，一个设备可以定义多个匹配字符串，范围由小到大，由具体到一般。这样在匹配驱动程序时，优先匹配更具体的设备驱动。
（2）model：字符串类型。用来表示设备型号。
（3）#address-cells，#size-cells：一个cell表示32位。这两个属性用来定义一个node的子node中，reg属性值的格式。比如，
父节点中，#address-cells = <2>; #size-cells = <1>
子节点中，reg = <0x00010000 0x7c004000 0x00001000 >
这表明，子节点reg的属性值中前两个cell组成设备的64位起始地址（0x000100007c004000），后一个cell是这个设备占用的32位地址范围（大小0x00001000）。
（4）reg：<prop-encoded-array>类型，格式是<start-addr size>。表示设备节点资源，一般指寄存器起始地址和范围。见（3）中示例。
（5）ranges：<prop-encoded-array>类型，格式是<subnode-addr parent-node-addr size>。subnode-addr占用几个cell由ranges所在的当前节点 #address-cells 决定，parent-node-addr占用几个cell由父节点 #address-cells 决定，size占用几个cell由当前节点 #size-cells 决定。
（6）status：字符串类型。表明设备的状态。“okay”表示设备可用，“disabled”表示设备不可用。
4，中断相关属性：
中断节点分为三种：中断控制器，中断产生设备和中断连接器（nexus）。
（1）中断产生设备属性：
interrupt-parent：<phandle>类型。指示该中断产生设备的中断父节点，即中断控制器或者中断连接器。
#interrupt：<prop-encoded-array>类型。每个中断编号占用几个cell由中断父节点中的 #interrupt-cells 决定。
（2）中断控制器属性：
#interrupt-cells：指示连接到该中断控制器下的设备的 #interrupt 的解析格式，即每个中断编号占用几个cell。
interrupt-controller：<empty>类型。声明该节点是一个中断控制器。
（3）中断连接器属性：
#interrupt-cells：指示连接到该中断连接器下的设备的 #interrupt 的解析格式，即每个中断编号占用几个cell。
interrupt-map：<prop-encoded-array>类型，格式为<child_unit_address, child_interrupt_specifier, interrupt_parent, parent_unit_address, parent_interrupt_specifier>。描述中断连接器对中断的路由。
其中，
child_unit_address：cells长度由子节点的“#address-cells”指定；
child_interrupt_specifier：cells长度由子节点的“#interrupt-cells”指定； interrupt_parent：phandle指向interrupt controller的引用； parent_unit_address：cells长度由父节点的“#address-cells”指定； parent_interrupt_specifier：cells长度由父节点的“#interrupt-cells”指定；5，标准节点：
（1）/ 节点，即根节点：每个设备树有且只有一个根节点。根节点必须包含如下属性：compatible，model，#address-cells 和 #size-cells。
（2）/alias 节点：定义节点别名。
（3）/memory 节点：内存节点。一般有如下属性：device_type，reg等。
（4）/chosen 节点：该节点并不表示某个硬件设备，而是用来传递内核启动参数和定义标准输入输出设备。一般有如下属性：bootargs，stdin-path 和 stdout-path。
（5）/cpu 节点：定义cpu节点。
DTB的格式：
DTS经过DTC编译之后，生成如下格式的DTB
（1）整体结构：分为4个block（图片来源于网络）。
说明：（1）boot_param_header：主要定义了后面三个block的偏移。
（2）device-tree structure：定义了节点和属性值的格式。
（3）device-tree strings：定义了属性名。
（2）boot_param_header结构定义：
struct boot_param_header {
__be32 magic; /* magic word OF_DT_HEADER */ __be32 totalsize; /* total size of DT block */ __be32 off_dt_struct; /* offset to structure */ __be32 off_dt_strings; /* offset to strings */ __be32 off_mem_rsvmap; /* offset to memory reserve map */ __be32 version; /* format version */ __be32 last_comp_version; /* last compatible version */ /* version 2 fields below */ __be32 boot_cpuid_phys; /* Physical CPU id we're booting on */ /* version 3 fields below */ __be32 dt_strings_size; /* size of the DT strings block */ /* version 17 fields below */ __be32 dt_struct_size; /* size of the DT structure block */ };（3）device-tree structure：（图片来源于网络）
说明：
（1）FDT_BEGIN_NODE：节点开始指示符。
（2）FDT_PROP：属性开始指示符。
（3）FDT_END_NODE：节点结束指示符。
（4）每个属性的格式是：4字节指示属性值的长度；接下来4字节指示属性名在 device tree strings 块中的偏移；再接下来就是实际的属性值。
源码分析：
kernel解析DTB分为两个部分，一部分是先进行DTB的解析，生成内核device_node节点树。第二部分是根据device_node节点树创建各个具体的设备。
1，解析DTB
（1）直接解析DTB，获取机器类型，kernel启动参数，内存配置信息等
setup_arch() ->setup_machine_fdt(__atags_pointer)： // __atags_pointer是bootloader提供给kernel的DTB起始物理地址
const struct machine_desc * __init setup_machine_fdt(unsigned int dt_phys)
{ const struct machine_desc *mdesc, *mdesc_best = NULL;#ifdef CONFIG_ARCH_MULTIPLATFORM
DT_MACHINE_START(GENERIC_DT, "Generic DT based system") MACHINE_ENDmdesc_best = &__mach_desc_GENERIC_DT;
#endifif (!dt_phys || !early_init_dt_verify(phys_to_virt(dt_phys))) // 物理地址转换成内核态地址，并检查DTB文件头的合法性
return NULL;mdesc = of_flat_dt_match_machine(mdesc_best, arch_get_next_mach); //根据DTB配置的compatible参数，选取kernel支持的最优machine类型。
if (!mdesc) {
const char *prop; int size; unsigned long dt_root;early_print("\nError: unrecognized/unsupported "
"device tree compatible list:\n[ ");dt_root = of_get_flat_dt_root();
prop = of_get_flat_dt_prop(dt_root, "compatible", &size); while (size > 0) { early_print("'%s' ", prop); size -= strlen(prop) + 1; prop += strlen(prop) + 1; } early_print("]\n\n");dump_machine_table(); /* does not return */
}/* We really don't want to do this, but sometimes firmware provides buggy data */
if (mdesc->dt_fixup) mdesc->dt_fixup();early_init_dt_scan_nodes(); // 解析DTB中配置的bootargs，memory等信息
/* Change machine number to match the mdesc we're using */
__machine_arch_type = mdesc->nr;return mdesc;
}void __init early_init_dt_scan_nodes(void)
{ /* Retrieve various information from the /chosen node */ of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line); // 解析 /chosen 节点，获取kernel启动参数/* Initialize {size,address}-cells info */
of_scan_flat_dt(early_init_dt_scan_root, NULL); // 解析 根节点，获取 #address-cells 和 #size-cells等属性/* Setup memory, calling early_init_dt_add_memory_arch */
of_scan_flat_dt(early_init_dt_scan_memory, NULL); // 解析 /memory 节点，获取内存配置信息，并加入kernel管理 }（2）根据device tree递归创建设备树节点 device_node
setup_arch() ->unflatten_device_tree()：
void __init unflatten_device_tree(void)
{ __unflatten_device_tree(initial_boot_params, &of_root, early_init_dt_alloc_memory_arch); // 解析设备树DTB，加入到of_root根节点中/* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
of_alias_scan(early_init_dt_alloc_memory_arch); // 解析 /alias 节点 }static void __unflatten_device_tree(const void *blob,
struct device_node **mynodes, void * (*dt_alloc)(u64 size, u64 align)) { unsigned long size; int start; void *mem;pr_debug(" -> unflatten_device_tree()\n");
if (!blob) {
pr_debug("No device tree pointer\n"); return; }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; }// 首次轮询，设置mem为NULL，dry_run为true，start为0，用来计算整棵设备树解析后的内存大小
/* First pass, scan for size */
start = 0; size = (unsigned long)unflatten_dt_node(blob, NULL, &start, NULL, NULL, 0, true); // 计算解析后设备树大小 size = ALIGN(size, 4);pr_debug(" size is %lx, allocating...\n", size);
/* Allocate memory for the expanded device tree */
mem = dt_alloc(size + 4, __alignof__(struct device_node)); // 分配解析后的设备树内存 memset(mem, 0, size);*(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);
pr_debug(" unflattening %p...\n", mem);
// 再次轮询，传入mem，设置dry_run为false，进行实际内存分配和设备树加载
/* Second pass, do actual unflattening */
start = 0; unflatten_dt_node(blob, mem, &start, NULL, mynodes, 0, false); // 设备树解析，加载 if (be32_to_cpup(mem + size) != 0xdeadbeef) pr_warning("End of tree marker overwritten: %08x\n", be32_to_cpup(mem + size));pr_debug(" <- unflatten_device_tree()\n");
}static void * unflatten_dt_node(const void *blob,
void *mem, int *poffset, struct device_node *dad, struct device_node **nodepp, unsigned long fpsize, bool dryrun) { const __be32 *p; struct device_node *np; struct property *pp, **prev_pp = NULL; const char *pathp; unsigned int l, allocl; static int depth; int old_depth; int offset; int has_name = 0; int new_format = 0;pathp = fdt_get_name(blob, *poffset, &l); //poffset开始为0，获取根节点路径，递归之后，获取各节点路径
if (!pathp) return mem;allocl = ++l;
/* version 0x10 has a more compact unit name here instead of the full
* path. we accumulate the full path size using "fpsize", we'll rebuild * it later. We detect this because the first character of the name is * not '/'. */// 根据版本的不同，DTB中节点名有可能是绝对路径名，也有可能是相对路径名，如果是相对路径名，需要组合成绝对路径名
if ((*pathp) != '/') { new_format = 1; if (fpsize == 0) { /* root node: special case. fpsize accounts for path * plus terminating zero. root node only has '/', so * fpsize should be 2, but we want to avoid the first * level nodes to have two '/' so we use fpsize 1 here */ fpsize = 1; allocl = 2; l = 1; pathp = ""; } else { /* account for '/' and path size minus terminal 0 * already in 'l' */ fpsize += l; allocl = fpsize; } }np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl, __alignof__(struct device_node)); // 分配存放 device_node + 节点名称 的内存
if (!dryrun) { char *fn; of_node_init(np); np->full_name = fn = ((char *)np) + sizeof(*np); if (new_format) { // new_format == 1 表明节点名称是相对路径名，下面的代码用于处理合成绝对路径名 /* rebuild full path for new format */ if (dad && dad->parent) { strcpy(fn, dad->full_name); #ifdef DEBUG if ((strlen(fn) + l + 1) != allocl) { pr_debug("%s: p: %d, l: %d, a: %d\n", pathp, (int)strlen(fn), l, allocl); } #endif fn += strlen(fn); } *(fn++) = '/'; } memcpy(fn, pathp, l);prev_pp = &np->properties;
// 当前节点加入设备树
if (dad != NULL) { np->parent = dad; np->sibling = dad->child; dad->child = np; } }// 解析该节点下的各个属性
/* process properties */ for (offset = fdt_first_property_offset(blob, *poffset); (offset >= 0); (offset = fdt_next_property_offset(blob, offset))) { const char *pname; u32 sz;if (!(p = fdt_getprop_by_offset(blob, offset, &pname, &sz))) {
offset = -FDT_ERR_INTERNAL; break; }if (pname == NULL) {
pr_info("Can't find property name in list !\n"); break; } if (strcmp(pname, "name") == 0) has_name = 1; pp = unflatten_dt_alloc(&mem, sizeof(struct property), __alignof__(struct property)); // 分配属性内存 if (!dryrun) { /* We accept flattened tree phandles either in * ePAPR-style "phandle" properties, or the * legacy "linux,phandle" properties. If both * appear and have different values, things * will get weird. Don't do that. */ if ((strcmp(pname, "phandle") == 0) || (strcmp(pname, "linux,phandle") == 0)) { if (np->phandle == 0) np->phandle = be32_to_cpup(p); } /* And we process the "ibm,phandle" property * used in pSeries dynamic device tree * stuff */ if (strcmp(pname, "ibm,phandle") == 0) np->phandle = be32_to_cpup(p); pp->name = (char *)pname; // 保存属性名 pp->length = sz; // 保存属性值大小 pp->value = (__be32 *)p; // 保存属性值// 将属性加入当前节点
*prev_pp = pp; prev_pp = &pp->next; } } /* with version 0x10 we may not have the name property, recreate * it here from the unit name if absent */ if (!has_name) { const char *p1 = pathp, *ps = pathp, *pa = NULL; int sz;while (*p1) {
if ((*p1) == '@') pa = p1; if ((*p1) == '/') ps = p1 + 1; p1++; } if (pa < ps) pa = p1; sz = (pa - ps) + 1; pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz, __alignof__(struct property)); if (!dryrun) { pp->name = "name"; pp->length = sz; pp->value = pp + 1; *prev_pp = pp; prev_pp = &pp->next; memcpy(pp->value, ps, sz - 1); ((char *)pp->value)[sz - 1] = 0; pr_debug("fixed up name for %s -> %s\n", pathp, (char *)pp->value); } } if (!dryrun) { *prev_pp = NULL; np->name = of_get_property(np, "name", NULL); np->type = of_get_property(np, "device_type", NULL);if (!np->name)
np->name = "<NULL>"; if (!np->type) np->type = "<NULL>"; }// 递归处理子节点
old_depth = depth;
*poffset = fdt_next_node(blob, *poffset, &depth); if (depth < 0) depth = 0; while (*poffset > 0 && depth > old_depth) mem = unflatten_dt_node(blob, mem, poffset, np, NULL, fpsize, dryrun);if (*poffset < 0 && *poffset != -FDT_ERR_NOTFOUND)
pr_err("unflatten: error %d processing FDT\n", *poffset);/*
* Reverse the child list. Some drivers assumes node order matches .dts * node order */ if (!dryrun && np->child) { struct device_node *child = np->child; np->child = NULL; while (child) { struct device_node *next = child->sibling; child->sibling = np->child; np->child = child; child = next; } }if (nodepp)
*nodepp = np;return mem;
} 至此，整棵设备树的节点和属性都都被加载进kernel中，以device_node形式保存在根节点 of_root 中。2，创建DT设备 platform_device
start_kernel() -> reset_init() -> kernel_init() -> kernel_init_freeable() -> do_basic_setup() -> do_initcalls() -> customize_machine() -> of_platform_populate()
kernel启动阶段会去创建各个配置好的platform_device，包括总线设备和总线下挂的子设备
static int __init customize_machine(void)
{ /* * customizes platform devices, or adds new ones * On DT based machines, we fall back to populating the * machine from the device tree, if no callback is provided, * otherwise we would always need an init_machine callback. */ of_iommu_init(); if (machine_desc->init_machine) machine_desc->init_machine(); #ifdef CONFIG_OF else of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); // 匹配 of_default_bus_match_table的节点被认为是总线设备，叶子设备则不应该匹配 #endif return 0; }arch_initcall(customize_machine); // customize_machine被arch_initcall声明，在do_initcalls()阶段会被调用执行const struct of_device_id of_default_bus_match_table[] = { // 默认总线匹配表
{ .compatible = "simple-bus", }, { .compatible = "simple-mfd", }, #ifdef CONFIG_ARM_AMBA { .compatible = "arm,amba-bus", }, #endif /* CONFIG_ARM_AMBA */ {} /* Empty terminated list */ };int of_platform_populate(struct device_node *root,
const struct of_device_id *matches, const struct of_dev_auxdata *lookup, struct device *parent) { struct device_node *child; int rc = 0;root = root ? of_node_get(root) : of_find_node_by_path("/"); // 获取 of_root 设备树根节点
if (!root) return -EINVAL;// 轮询设备树根节点下的子节点
for_each_child_of_node(root, child) {
rc = of_platform_bus_create(child, matches, lookup, parent, true); // 检查并创建总线设备和叶子设备 if (rc) { of_node_put(child); break; } } of_node_set_flag(root, OF_POPULATED_BUS);of_node_put(root);
return rc; }
static int of_platform_bus_create(struct device_node *bus,
const struct of_device_id *matches, const struct of_dev_auxdata *lookup, struct device *parent, bool strict) { const struct of_dev_auxdata *auxdata; struct device_node *child; struct platform_device *dev; const char *bus_id = NULL; void *platform_data = NULL; int rc = 0;/* Make sure it has a compatible property */
if (strict && (!of_get_property(bus, "compatible", NULL))) { // 无论是总线设备还是叶子设备，都必须包含 compatible 属性 pr_debug("%s() - skipping %s, no compatible prop\n", __func__, bus->full_name); return 0; }auxdata = of_dev_lookup(lookup, bus);
if (auxdata) { bus_id = auxdata->name; platform_data = auxdata->platform_data; }if (of_device_is_compatible(bus, "arm,primecell")) {
/* * Don't return an error here to keep compatibility with older * device tree files. */ of_amba_device_create(bus, bus_id, platform_data, parent); return 0; }dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent); // 创建总线设备或者叶子设备的platform_device
if (!dev || !of_match_node(matches, bus)) // 如果不匹配，说明该设备是个叶子设备，递归结束；如果匹配，说明该设备是个总线设备，需要继续递归轮询其下挂的子设备 return 0;// 循环创建该总线下的所有子总线设备
for_each_child_of_node(bus, child) {
pr_debug(" create child: %s\n", child->full_name); rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict); // 创建总线下的子总线设备 if (rc) { of_node_put(child); break; } } of_node_set_flag(bus, OF_POPULATED_BUS); return rc; }static struct platform_device *of_platform_device_create_pdata(
struct device_node *np, const char *bus_id, void *platform_data, struct device *parent) { struct platform_device *dev;if (!of_device_is_available(np) ||
of_node_test_and_set_flag(np, OF_POPULATED)) return NULL;dev = of_device_alloc(np, bus_id, parent); // 分配 platform_device，并从 node_device 中获取reg和irq信息
if (!dev) goto err_clear_flag;dev->dev.bus = &platform_bus_type; // bus type 为 platform_bus_type
dev->dev.platform_data = platform_data; of_dma_configure(&dev->dev, dev->dev.of_node); of_msi_configure(&dev->dev, dev->dev.of_node);if (of_device_add(dev) != 0) {
of_dma_deconfigure(&dev->dev); platform_device_put(dev); goto err_clear_flag; }return dev;
err_clear_flag:
of_node_clear_flag(np, OF_POPULATED); return NULL; } 至此，从DTS到DTB，从kernel加载DTB，到整个DTB被转换成由of_root引用的device_node tree，最后到整个platform_bus总线的创建过程已经非常清晰明了了。整个arm架构的设备注册部分已经完成，剩下的就是后续各个platform_driver的register，match和probe了。