你好！这里是风筝的博客，
欢迎和我一起交流。
说来惭愧，虽说一直用设备树，但是都没有好好去看过他的实现细节，
所以今天抽空看了一下代码和网上的文章，试着通过读代码的方式来好好了解一下设备树dtb->platform_device的过程。
Linux内核从3.x开始引入设备树的概念，用于实现驱动代码与设备信息相分离。在设备树出现以前，所有关于设备的具体信息都要写在驱动里，一旦外围设备变化，驱动代码就要重写。引入了设备树之后，驱动代码只负责处理驱动的逻辑，而关于设备的具体信息存放到设备树文件中，这样，如果只是硬件接口信息的变化而没有驱动逻辑的变化，驱动开发者只需要修改设备树文件信息，不需要改写驱动代码。
Device Tree有自己的独立的语法，它的源文件为.dts，编译后得到.dtb，Bootloader在引导Linux内核的时候会将.dtb地址告知内核。之后内核会展开Device Tree并创建和注册相关的设备。我们就以Linux4.14为例，看一下kernel是怎么解析dtb的。
我们从Linux里启动的第一个C函数看起：
start_kernel // init/main.c
setup_arch(&command_line); // arch/arm/kernel/setup.c
rest_init(); // init/main.c
先看setup_arch函数
void __init setup_arch(char **cmdline_p)
{
const struct machine_desc *mdesc;
setup_processor();
mdesc = setup_machine_fdt(__atags_pointer);//根据Device Tree的信息，找到最适合的machine描述符
if (!mdesc)
mdesc = setup_machine_tags(__atags_pointer, __machine_arch_type);//传统的方法setup_machine_tags来setup machine描述符
machine_desc = mdesc;//得到machine_desc
machine_name = mdesc->name;
dump_stack_set_arch_desc("%s", mdesc->name);
//省略部分.........
arm_memblock_init(mdesc);//把DTB所占区域保留下来
if (mdesc->restart)
arm_pm_restart = mdesc->restart;
unflatten_device_tree();//扫描并解析dtb文件，将节点组织成一个由device_node结构连接而成的单项链表
//省略部分.........
这里我们主要了解两个函数：
【1】setup_machine_fdt(__atags_pointer)
【2】unflatten_device_tree()
其中__atags_pointer是bootloader传递参数的物理地址，我们看下setup_machine_fdt函数内部：
const struct machine_desc * __init setup_machine_fdt(unsigned int dt_phys)
{
const struct machine_desc *mdesc, *mdesc_best = NULL;
//省略部分.........
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);//找到最匹配的machine_desc
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();//找到设备树的根节点，dt_root指向根节点的属性地址处
prop = of_get_flat_dt_prop(dt_root, "compatible", &size);//读出根节点的"compatible"属性的属性值
while (size > 0) {//将根节点的"compatible"属性的属性值打印出来
early_print("'%s' ", prop);
size -= strlen(prop) + 1;
prop += strlen(prop) + 1;
}
early_print("]\n\n");
dump_machine_table(); /* does not return */
}
//省略部分.........
early_init_dt_scan_nodes();//对设备树中运行时配置信息的处理
//省略部分.........
return mdesc;
}
里面的内容也是很简单：
根据传递进来的参数（__atags_pointer）判断是否是有效的dtb，然后通过函数【1.1】of_flat_dt_match_machine寻找设备树中根节点属性"compatible"的属性，找到最匹配的machine_desc。
如果找不到，则打印出根节点的"compatible"属性的属性值，以供开发人员调试。
最后调用【1.2】early_init_dt_scan_nodes函数做一些配置处理
所以我们先看看【1.1】of_flat_dt_match_machine函数：
const void * __init of_flat_dt_match_machine(const void *default_match,
const void * (*get_next_compat)(const char * const**))
{
dt_root = of_get_flat_dt_root();//读出设备树的根节点，dt_root指向根节点的属性地址处
while ((data = get_next_compat(&compat))) {//遍历该系统中的所有machine_desc结构，返回给data，获取该结构的compatible
score = of_flat_dt_match(dt_root, compat);//将系统中的所有machine_desc结构的compatible字符串与设备树根节点的compatible属性进行match
if (score > 0 && score < best_score) {
best_data = data;
best_score = score;//返回与根节点属性compatible属性值最匹配的machine_desc结构
}
}
//省略部分.........
return best_data;
}
这里就是通过of_flat_dt_match函数去匹配设备树中machine的compatible属性和Linux的machine了，找到最合适的那个machine描述符，匹配成功就可以获取描述符machine_desc。那么Linux中的machine描述在哪呢？
很简单，搜索DT_MACHINE_START，machine描述符的列表就是通过DT_MACHINE_START和MACHINE_END来定义的。编译的时候，compiler会把这些machine descriptor放到一个特殊的段中（.arch.info.init），形成machine描述符的列表。
我的板子是allwiner h3：
static const char * const sun6i_board_dt_compat[] = {
"allwinner,sun6i-a31",
"allwinner,sun6i-a31s",
NULL,
};
DT_MACHINE_START(SUN6I_DT, "Allwinner sun6i (A31) Family")
.init_time = sun6i_timer_init,
.dt_compat = sun6i_board_dt_compat,
MACHINE_END
接着我们看【1.2】early_init_dt_scan_nodes函数：
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);
/* Initialize {size,address}-cells info */
of_scan_flat_dt(early_init_dt_scan_root, NULL);
/* Setup memory, calling early_init_dt_add_memory_arch */
of_scan_flat_dt(early_init_dt_scan_memory, NULL);
}
里面就三个函数，分别做的是：
1.解析chosen节点中bootargs属性的值，得到启动参数, 存入全局变量： boot_command_line
2.获取 #address-cells, #size-cells信息，并保存在dt_root_addr_cells和dt_root_size_cells全局变量中
3.解析 /memory 节点，获取内存配置信息，并把相关信息"base, size"保存在meminfo中，全局变量meminfo保存了系统内存相关的信息
所以总体来说，【1】setup_machine_fdt函数还是很简单的。
使用setup_machine_fdt来setup machine描述符，如果返回NULL，才使用传统的方法setup_machine_tags来setup machine描述符。传统的方法需要给出__machine_arch_type（bootloader通过r1寄存器传递给kernel的）和tag list的地址（用来进行tag parse）。__machine_arch_type用来寻找machine描述符；tag list用于运行时参数的传递。
在系统初始化的过程中，我们需要将DTB转换成节点是device_node的树状结构，以便后续方便操作。所以接下来看【2】unflatten_device_tree()函数：
void __init unflatten_device_tree(void)
{
__unflatten_device_tree(initial_boot_params, NULL, &of_root,
early_init_dt_alloc_memory_arch, false);//解析设备树
/* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
of_alias_scan(early_init_dt_alloc_memory_arch);//设置内核输出终端，以及遍历“/aliases”节点下的所有的属性，挂入相应链表
unittest_unflatten_overlay_base();
}
这一轮我们也是主要看两个函数：
【2.1】__unflatten_device_tree
【2.2】of_alias_scan
注释如上。
看下【2.1】__unflatten_device_tree函数是如何组织device_node 的：
void *__unflatten_device_tree(const void *blob,
struct device_node *dad,
struct device_node **mynodes,
void *(*dt_alloc)(u64 size, u64 align),
bool detached)
{
if (!blob) {//blob由initial_boot_params传入，initial_boot_params在setup_arch的arm_memblock_init
pr_debug("No device tree pointer\n");
return NULL;
}
//省略部分.........
/* First pass, scan for size */
size = unflatten_dt_nodes(blob, NULL, dad, NULL);//第一轮主要是确定device-tree structure的长度，保存在size变量中
if (size < 0)
return NULL;
size = ALIGN(size, 4);
pr_debug(" size is %d, allocating...\n", size);
/* Allocate memory for the expanded device tree */
mem = dt_alloc(size + 4, __alignof__(struct device_node));//一次性的分配了一大片内存，并不是扫描到一个node或者property就分配相应的内存
if (!mem)
return NULL;
memset(mem, 0, size);
*(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);//设备树结束处赋值0xdeadbeef
pr_debug(" unflattening %p...\n", mem);
/* Second pass, do actual unflattening */
unflatten_dt_nodes(blob, mem, dad, mynodes);//dtb解析主要函数,解析完构成了 device node 树
if (be32_to_cpup(mem + size) != 0xdeadbeef)//检查是否有数据溢出
pr_warning("End of tree marker overwritten: %08x\n", be32_to_cpup(mem + size));
//省略部分.........
return mem;
}
函数里面会调用两次【2.1.1】unflatten_dt_nodes，第一次获取device-tree structure的大小，用以分配内存（一次性的分配了一大片内存）。第二次则是构建device node tree，当然，是调用函数里面的【2.1.1.1】populate_node实现的。
这里不得不说一下device_node结构体：
struct device_node {
const char *name;//对应node的属性
const char *type;//对应device_type的属性
phandle phandle;//对应该节点的phandle属性
const char *full_name;//从“/”开始的，表示该node的full path
struct fwnode_handle fwnode;
struct property *properties;//该节点的属性列表
struct property *deadprops;/* removed properties *///如果需要删除某些属性，kernel并非真的删除，而是挂入到deadprops的列表
struct device_node *parent;//parent、child以及sibling将所有的device node连接起来
struct device_node *child;
struct device_node *sibling;//// 节点的兄弟(同级节点)
struct kobject kobj;
unsigned long _flags;
void *data;
#if defined(CONFIG_SPARC)
const char *path_component_name;
unsigned int unique_id;
struct of_irq_controller *irq_trans;
#endif
};
每一个节点都转换为一个device_node结构体，这些device_node构成一棵树, 根节点为: of_root，device_node结构体中有properties, 用来表示该节点的属性
每一个属性对应一个property结构体，通过property.next指针进行链接，形成一个单链表:
struct property {
char *name;// 属性名字, 指向dtb文件中的字符串
int length;// 属性值的长度
void *value;// 属性值, 指向dtb文件中value所在位置, 数据仍以big endian存储
struct property *next;
unsigned long _flags;
unsigned int unique_id;
struct bin_attribute attr;
};
【2.1.1.1】populate_node函数：
static unsigned int populate_node(const void *blob,
int offset,
void **mem,
struct device_node *dad,
unsigned int fpsize,
struct device_node **pnp,
bool dryrun)
{
//省略部分.........
np = unflatten_dt_alloc(mem, sizeof(struct device_node) + allocl,
__alignof__(struct device_node));//分配device_node结构
if (!dryrun) {
char *fn;
of_node_init(np);//里面设置node->fwnode.ops各种操作函数
np->full_name = fn = ((char *)np) + sizeof(*np);// 完整节点的名字, node-name[@unit-address]，即包括各级父节点的名称
if (new_format) {//传入的路径为'/'则new_format为0，否则为1,建立新的full path
/* 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);
if (dad != NULL) {//若父亲节点不为空，则设置该节点的parent
np->parent = dad;//指向父亲节点
np->sibling = dad->child;
dad->child = np;
}
}
populate_properties(blob, offset, mem, np, pathp, dryrun);//里面设置节点的属性，也就是device_node 的*properties
if (!dryrun) {
np->name = of_get_property(np, "name", NULL);
np->type = of_get_property(np, "device_type", NULL);
if (!np->name) // 来自节点中的name属性, 如果没有该属性, 则设为"NULL"
np->name = "<NULL>";
if (!np->type)
np->type = "<NULL>";
}
}
注释如上，通俗易懂！
里面就是开始为节点分配device_node了，接着就是调用【2.1.1.1.1】populate_properties函数设置节点的属性properties和填充device_node结构体了
static void populate_properties(const void *blob,
int offset,
void **mem,
struct device_node *np,
const char *nodename,
bool dryrun)
{
struct property *pp, **pprev = NULL;
int cur;
bool has_name = false;
pprev = &np->properties;// 设置每个device_node的属性
for (cur = fdt_first_property_offset(blob, offset);
cur >= 0;
cur = fdt_next_property_offset(blob, cur)) {//处理该node节点下面所有的property
//省略部分.........
pp = unflatten_dt_alloc(mem, sizeof(struct property),
__alignof__(struct property));//分配内存
if (!strcmp(pname, "phandle") ||
!strcmp(pname, "linux,phandle")) {/* 处理phandle，得到phandle值 */
if (!np->phandle)
np->phandle = be32_to_cpup(val);
}
pp->name = (char *)pname; // 属性名字, 指向dtb文件中的字符串
pp->length = sz;// 属性值的长度
pp->value = (__be32 *)val; // 属性值, 指向dtb文件中value所在位置, 数据仍以big endian存储
*pprev = pp;
pprev = &pp->next;
}
if (!has_name) {
const char *p = nodename, *ps = p, *pa = NULL;
int len;
while (*p) {
if ((*p) == '@')
pa = p;
else if ((*p) == '/')
ps = p + 1;
p++;
}
if (pa < ps)
pa = p;
len = (pa - ps) + 1;// 得到长度
pp = unflatten_dt_alloc(mem, sizeof(struct property) + len,
__alignof__(struct property));
if (!dryrun) {
pp->name = "name";//每一个node都会自动添加一个名称为“name”的property
pp->length = len;
pp->value = pp + 1;
*pprev = pp;
pprev = &pp->next;
memcpy(pp->value, ps, len - 1);//属性name的value值为node节点的名称，取“/”和“@”之间的子串
((char *)pp->value)[len - 1] = 0;
pr_debug("fixed up name for %s -> %s\n",
nodename, (char *)pp->value);
}
}
}
到这里就是【2.1】__unflatten_device_tree函数以及它的子函数的调用过程了，到这里就差不多是dtb转换为device_node的过程了。
不过还有一点点，看完【2.1】__unflatten_device_tree函数别忘了还有【2.2】of_alias_scan函数。
在设备树中有一个叫做aliases的节点，例如：
aliases {
spi0 = "/spi@13920000";
spi1 = "/spi@13930000";
spi2 = "/spi@13940000";
i2c0 = "/i2c@13860000";
i2c1 = "/i2c@13870000";
... ...
};
void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
{
struct property *pp;
of_aliases = of_find_node_by_path("/aliases");// 找到/aliases节点对应的device_node
of_chosen = of_find_node_by_path("/chosen");// 找到/chosen节点对应的device_node
if (of_chosen == NULL)// 如果没有/chosen的话，就找/chosen@0节点
of_chosen = of_find_node_by_path("/chosen@0");
if (of_chosen) {
/* linux,stdout-path and /aliases/stdout are for legacy compatibility */
const char *name = NULL;
if (of_property_read_string(of_chosen, "stdout-path", &name))
of_property_read_string(of_chosen, "linux,stdout-path",
&name);
if (IS_ENABLED(CONFIG_PPC) && !name)
of_property_read_string(of_aliases, "stdout", &name);
if (name)
of_stdout = of_find_node_opts_by_path(name, &of_stdout_options);
}
if (!of_aliases)
return;
for_each_property_of_node(of_aliases, pp) {//遍历/aliases节点的属性，以属性i2c2 = "/i2c@13880000";为例
const char *start = pp->name;// 属性的名字，如"i2c2"
const char *end = start + strlen(start);// 名字的结尾，*end是'\0'
struct device_node *np;
struct alias_prop *ap;
int id, len;
/* Skip those we do not want to proceed */
if (!strcmp(pp->name, "name") ||//不处理名字是name、phandle、linux,phandle的属性
!strcmp(pp->name, "phandle") ||
!strcmp(pp->name, "linux,phandle"))
continue;
np = of_find_node_by_path(pp->value);
/*
根据属性的值（如"/i2c@13880000"）获得这个值对应的节点
i2c@13880000 {
#address-cells = <0x1>;
#size-cells = <0x0>;
compatible = "samsung,s3c2440-i2c";
reg = <0x13880000 0x100>;
interrupts = <0x0 0x3c 0x0>;
clocks = <0x7 0x13f>;
clock-names = "i2c";
pinctrl-names = "default";
pinctrl-0 = <0x22>;
status = "disabled";
};
*/
if (!np)
continue;
/* walk the alias backwards to extract the id and work out
* the 'stem' string */
while (isdigit(*(end-1)) && end > start)//对于"i2c2"，end最终会指向字符'2'的地址
end--;
len = end - start; // 获得"i2c"的长度(不包含结尾的数字2)，就是3
if (kstrtoint(end, 10, &id) < 0)// 将end指向的字符'2'转化为数字2，赋值给id
continue;
/* Allocate an alias_prop with enough space for the stem */
ap = dt_alloc(sizeof(*ap) + len + 1, __alignof__(*ap));// 分配内存，多分配的"len+1"用于存放stem的名字
if (!ap)
continue;
memset(ap, 0, sizeof(*ap) + len + 1);
ap->alias = start;// ap->alias指向字符串"i2c2"
of_alias_add(ap, np, id, start, len);//里面会添加到aliases_lookup
}
}
of_alias_add函数：
static void of_alias_add(struct alias_prop *ap, struct device_node *np,
int id, const char *stem, int stem_len)
{
ap->np = np;// np是"/i2c@13880000"对应的节点device_node
ap->id = id;// id的值是2
strncpy(ap->stem, stem, stem_len);// 由于stem_len是3，所以ap->stem被赋值为"i2c"
ap->stem[stem_len] = 0;
list_add_tail(&ap->link, &aliases_lookup);// 将这个ap加入到全局aliases_lookup链表中
pr_debug("adding DT alias:%s: stem=%s id=%i node=%pOF\n",
ap->alias, ap->stem, ap->id, np);
}
在i2c里面，就会调用i2c_add_adapter函数
int i2c_add_adapter(struct i2c_adapter *adapter)
{
struct device *dev = &adapter->dev;
int id;
if (dev->of_node) {
id = of_alias_get_id(dev->of_node, "i2c");//获得与这个device_node（即/i2c@13880000节点）对应的alias_prop的id
//如果以/i2c@13880000节点为例，这里得到的id就是2
if (id >= 0) {
adapter->nr = id;
return __i2c_add_numbered_adapter(adapter);
}
}
}
int of_alias_get_id(struct device_node *np, const char *stem)
{
mutex_lock(&of_mutex);
list_for_each_entry(app, &aliases_lookup, link) { // 遍历全局链表aliases_lookup
if (strcmp(app->stem, stem) != 0) // 找到 stem 是 "i2c" 的alias_prop
continue;
if (np == app->np) { // 判断这个alias_prop指向的device_node是不是跟传入的匹配
id = app->id; // 获得 id，2
break;
}
}
mutex_unlock(&of_mutex);
return id;
}
從上面的分析就可以知道alias節點的作用了：
比如SoC上有如果多個i2c控制器，alias的相當於給每個i2c控制器分配一個唯一的編號，如上面的i2c@13880000對應的alias是i2c2，那麼這個編號就是2，將來就可以在/dev下看到名爲i2c-2的設備節點。
在內核中可以看到很多地方都會調用of_alias_get_id，他的作用就是根據傳入的device
node，在alias中找到對應的唯一編號，如： of_alias_get_id(pdev->dev.of_node, “spi”)
of_alias_get_id(node, “fimc”) of_alias_get_id(pdev->dev.of_node,
“serial”)
上面关于alias节点的分析，来自：基于tiny4412的Linux内核移植 — aliases节点解析
接下来就是device_node 怎么转换为platform_device。
文章开头就有，start_kernel 里有两个函数，一个是setup_arch(&command_line)，另一个就是rest_init()了
rest_init();
pid = kernel_thread(kernel_init, NULL, CLONE_FS);
kernel_init
kernel_init_freeable();
do_basic_setup();
do_initcalls();
for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++)
do_initcall_level(level);
do_initcall_level就会调用一些__define_initcall修饰过的函数
#define arch_initcall(fn) __define_initcall("3",fn,3)
#define arch_initcall_sync(fn) __define_initcall("3s",fn,3s)
如：
arch_initcall(customize_machine);
arch_initcall_sync(of_platform_default_populate_init);
以前版本里customize_machine函数里会调用of_platform_populate函数的，现在没有了：
static int __init customize_machine(void)
{
if (machine_desc->init_machine)
machine_desc->init_machine();
return 0;
}
arch_initcall(customize_machine);
这里会调用machine描述符的init_machine函数，machine_desc在文章开头说有，我们是allwiner h3，没有填充init_machine字段。
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_populate会传入参数of_default_bus_match_table
int of_platform_populate(struct device_node *root,
const struct of_device_id *matches,//match table重点是后续节点递归处理时，需要和该table mach后才可以继续递归处理
const struct of_dev_auxdata *lookup,
struct device *parent)
{
struct device_node *child;
int rc = 0;
//此时传入的root=NULL，从dts的\节点开始逐一的递归处理，
//否则根据所选择的device node作为root，做递归处理
root = root ? of_node_get(root) : of_find_node_by_path("/");// 找到root device node
if (!root)
return -EINVAL;
for_each_child_of_node(root, child) {// 遍历root device node的 device node
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;
}
里面就是遍历device_node，然后调用of_platform_bus_create为每个 “适合” 的node创建注册platform_device。
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)
{
if (strict && (!of_get_property(bus, "compatible", NULL))) {// 这样可以把chosen、aliases、memory等没有compatible属性的节点排除在外
pr_debug("%s() - skipping %pOF, no compatible prop\n",
__func__, bus);
return 0;
}
//省略部分.........
dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);// 根据device node创建 platform_device并注册
if (!dev || !of_match_node(matches, bus))// 判断是不是需要继续遍历这个device node下的child device node
return 0;
for_each_child_of_node(bus, child) {// 遍历这个device node下的child device node，将child device node也注册为platform_device
pr_debug(" create child: %pOF\n", child);
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;
}
of_platform_bus_create函数一开始就是去寻找有"compatible"属性的节点，如果节点属性不存在，则表明其不需要生成为platform_device，这样可以把chosen、aliases、memory等没有compatible属性的节点排除在外。
接着调用of_platform_device_create_pdata函数，它里面把各种Device Tree中定义的platform device设备节点加入到系统（即platform bus的所有的子节点，对于device tree中其他的设备节点，需要在各自bus controller初始化的时候自行处理）。
之后接着调用of_match_node(matches, bus)函数，
我们知道，设备树里存在很多节点以及他的子节点， 不是所有的节点都是需要我们注册成platform_device的。也就是说dts中定义的各种device node，往往只是用来辅助核心的device node而存在的，这些node存在并不需要加载为platform device。
但是系统怎么知道该把那些子节点注册成platform_device呢？
答案就在of_match_node的参数matches里，matches是由of_default_bus_match_table得来：
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 /* CONFIG_ARM_AMBA */
{} /* Empty terminated list */
};
只有节点里compatible 属性与of_default_bus_match_table里的任一.compatible字段匹配(“simple-bus”,“simple-mfd”,“isa”,“arm,amba-bus”)，of_match_node函数才会成立，程序才会往下执行，才会继续调用for_each_child_of_node函数（递归调用）遍历子节点并为子节点(需含compatile属性)注册platform_device。
当然，也不是所有的device node都会挂入bus上的设备链表，比如cpus node，memory node，choose node等
也就是说，arm dts中的设备，除了cpu、memory、chosen、interrupt节点，全部都默认挂入platform总线
DTS只描述platform
device（AMBA除外）。这是基于这样的考虑：其它bus上的device，其bus应该具备动态枚举设备的能力。只有platform_device，才一开机就存在，需要靠device tree来描述
举个例子，参考自韦东山设备树视频：
/ {
mytest {
compatile = "mytest", "simple-bus";
mytest@0 {
compatile = "mytest_0";
};
};
i2c {
compatile = "samsung,i2c";
at24c02 {
compatile = "at24c02";
};
};
};
/mytest会被转换为platform_device, 因为它兼容"simple-bus", 它的子节点/mytest/mytest@0 也会被转换为platform_device
/i2c节点一般表示i2c控制器, 它会被转换为platform_device, 在内核中有对应的platform_driver;
/i2c/at24c02节点不会被转换为platform_device！！！
就像我们之前说的，“其它bus上的device，其bus应该具备动态枚举设备的能力”。i2c, spi等总线节点下的子节点, 应该交给其对应的总线驱动程序来处理, 它们不应该被转换为platform_device。这里i2c节点（i2c adapter）是挂载在platform_bus上，被转换为platform_device, 在内核中有对应的platform_driver，它的子节点（at24c02 节点）被如何处理完全由父节点的platform_driver决定。
i2c adapter驱动的probe函数会调用如下：
i2c_add_numbered_adapter // drivers/i2c/i2c-core-base.c
__i2c_add_numbered_adapter
i2c_register_adapter
of_i2c_register_devices(adap); // drivers/i2c/i2c-core-of.c
for_each_available_child_of_node(bus, node) {//遍历i2c节点下面的每一个子节点
client = of_i2c_register_device(adap, node);//为子节点（status = “disable”的除外）创建i2c_client结构体，并与子节点的device_node挂接
client = i2c_new_device(adap, &info);// 设备树中的i2c子节点被转换为i2c_client
}
spi_master驱动的probe函数会调用如下：
spi_register_controller // drivers/spi/spi.c
of_register_spi_devices // drivers/spi/spi.c
for_each_available_child_of_node(ctlr->dev.of_node, nc) {//遍历spi节点下面的每一个子节点
spi = of_register_spi_device(ctlr, nc); // 设备树中的spi子节点被转换为spi_device
spi = spi_alloc_device(ctlr);
rc = of_spi_parse_dt(ctlr, spi, nc);
rc = spi_add_device(spi);
}
i2c adapter设备
在of_i2c_register_devices()函数内部遍历i2c节点下面的每一个子节点，并为子节点（status = “disable”的除外）创建i2c_client结构体，并与子节点的device_node挂接。其中i2c_client的填充是在i2c_new_device()中进行的，最后device_register()。在构建i2c_client的时候，会对node下面的compatible属性名称的厂商名字去除作为i2c_client的name。例如：compatible = “maxim,ds1338”,则i2c_client->name = “ds1338”
明白了这一层关系，我们继续回到之前的of_platform_bus_create函数里，他在遍历子节点前是要先调用of_platform_device_create_pdata(bus, bus_id, platform_data, parent)函数为当前节点创建platform_device的。
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;//这里就是platform_device结构体
dev = of_device_alloc(np, bus_id, parent);
dev->dev.bus = &platform_bus_type;//挂到platform_bus上
dev->dev.platform_data = platform_data;
of_msi_configure(&dev->dev, dev->dev.of_node);
if (of_device_add(dev) != 0) {//把这个platform device加入统一设备模型系统中
platform_device_put(dev);
goto err_clear_flag;
}
}
这个函数最关键，可以说是本文章的最后一步了，就是转换成plateform_device，里面
of_device_alloc函数分配struct platform_device的内存，还分配了该platform device需要的resource的内存（参考struct platform_device 中的resource成员）。当然，这就需要解析该device node的interrupt资源以及memory address资源
of_device_add(dev)就是把plateform_device添加到设备模型系统中了。
struct platform_device *of_device_alloc(struct device_node *np,
const char *bus_id,
struct device *parent)
{
struct platform_device *dev;//这里就是platform_device结构体
int rc, i, num_reg = 0, num_irq;//reg、中断 个数
struct resource *res, temp_res;
dev = platform_device_alloc("", PLATFORM_DEVID_NONE);//创建一个平台设备对象，该对象可以附加其他对象，并且在释放时将释放附加的对象
if (!dev)
return NULL;
while (of_address_to_resource(np, num_reg, &temp_res) == 0)
num_reg++;//获取reg个数
num_irq = of_irq_count(np);//获取中断个数
/* Populate the resource table */
if (num_irq || num_reg) {//填充资源
res = kzalloc(sizeof(*res) * (num_irq + num_reg), GFP_KERNEL);
if (!res) {
platform_device_put(dev);
return NULL;
}
dev->num_resources = num_reg + num_irq;//资源数
dev->resource = res;
for (i = 0; i < num_reg; i++, res++) {
rc = of_address_to_resource(np, i, res);//将io地址转换成struct resource资源信息
WARN_ON(rc);
}
if (of_irq_to_resource_table(np, res, num_irq) != num_irq)//将中断号转换成中断资源信息并赋值给平台设备
pr_debug("not all legacy IRQ resources mapped for %s\n",
np->name);
}
dev->dev.of_node = of_node_get(np);//设置dev->dev.of_node
dev->dev.fwnode = &np->fwnode;
dev->dev.parent = parent ? : &platform_bus;
if (bus_id)
dev_set_name(&dev->dev, "%s", bus_id);
else
of_device_make_bus_id(&dev->dev);
return dev;
}
of_device_alloc函数里计算出reg和irq个数，就可以从设备树获取property来填充resource了。
of_address_to_resource函数是获取reg
of_irq_to_resource_table函数是获取irq
自此，dtb就完全转换为platform_device并注册进platform_bus了。
这里有蜗窝科技里的一段话：
device tree的本质。 没错，device tree的目的是抽象、描述硬件，但是，抽象、描述硬件并不是最终目标。最终目标是：“通过修改device tree，方便的支持不同的平台、版型，从而不需要重新编译kernel”。 要实现这个最终目标，device tree所描述的内容要具备哪些基本条件？共性！
回想一下device tree的基本内容：属性=值。因此所谓的共性，就是要有相同的属性，通过修改属性值，达到支持不同平台、版型的目的，例如reg、irq、gpio、reset、power gate等等
参考：
蜗窝科技设备树系列文章
Device Tree（三）：代码分析
彭东林博客：基于tiny4412的Linux内核移植 — aliases节点解析
韦东山设备树视频