背景：基于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@address {
}
（1）label：标签。如果有其他属性需要引用该节点，可以通过 &label 的形式直接引用该节点。
（2）name：节点名称。长度范围是1~31，可以使用如下字符组合：数字（0 ~ 9） 小写字母（a ~ z） 大写字母（A ~ Z） 逗号（,） 句号（.）下划线（_） 加号（+） 以及 减号（-）。并且，规范要求以字母开头。
（3）address：节点地址。其实是用来区分同名设备的，同一空间中的不同节点可能是同一个名称，可以通过不同地址来区分。address并不仅仅指设备地址，也可能是设备编号。比如，对于cpu来说，就没有地址，但是可以通过 cpu@0，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_END
mdesc_best = &__mach_desc_GENERIC_DT;
#endif
if (!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了。
扫一扫
2540
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
