ARM Device Tree起源于OpenFirmware (OF)，在过去的Linux中，arch/arm/plat-xxx和arch/arm/mach-xxx中充斥着大量的垃圾代码，相当多数的代码只是在描述板级细节，而这些板级细节对于内核来讲，不过是垃圾，如板上的platform设备、resource、i2c_board_info、spi_board_info以及各种硬件的platform_data。为了改变这种局面，Linux社区的大牛们参考了PowerPC等体系架构中使用的Flattened Device Tree（FDT），也采用了Device Tree结构，许多硬件的细节可以直接透过它传递给Linux，而不再需要在kernel中进行大量的冗余编码。  

       Device Tree是一种描述硬件的数据结构，它起源于 OpenFirmware (OF)。在Linux 2.6中，ARM架构的板极硬件细节过多地被硬编码在arch/arm/plat-xxx和arch/arm/mach-xxx，采用Device Tree后，许多硬件的细节可以直接透过它传递给Linux，而不再需要在kernel中进行大量的冗余编码。  

      Device Tree由一系列被命名的结点（node）和属性（property）组成，而结点本身可包含子结点。所谓属性，其实就是成对出现的name和value。在Device Tree中，可描述的信息包括（原先这些信息大多被hard code到kernel中）：

• CPU的数量和类别
• 内存基地址和大小
• 总线和桥
• 外设连接
• 中断控制器和中断使用情况
• GPIO控制器和GPIO使用情况
• Clock控制器和Clock使用情况

     它基本上就是画一棵电路板上CPU、总线、设备组成的树，Bootloader会将这棵树传递给内核，然后内核可以识别这棵树，并根据它展开出Linux内核中的platform_device、i2c_client、spi_device等设备，而这些设备用到的内存、IRQ等资源，也被传递给了内核，内核会将这些资源绑定给展开的相应的设备。

     通常由.dts文件以文本方式对系统设备树进行描述，经过Device Tree Compiler(dtc)将dts文件转换成二进制文件binary device tree blob(dtb)，.dtb文件可由Linux内核解析，有了device tree就可以在不改动Linux内核的情况下，对不同的平台实现无差异的支持，只需更换相应的dts文件，即可满足。

二、相关结构体

1、U-Boot需要将设备树在内存中的存储地址传给内核。该树主要由三大部分组成：头（Header）、结构块（Structure block）、字符串块（Strings block）。

设备树在内存中的存储布局图：

1.1 头（header）
      头主要描述设备树的一些基本信息，例如设备树大小，结构块偏移地址，字符串块偏移地址等。偏移地址是相对于设备树头的起始地址计算的。

[cpp] view plaincopy

1. struct boot_param_header {  
2.     __be32 magic;                //设备树魔数，固定为0xd00dfeed  
3.     __be32 totalsize;            //整个设备树的大小  
4.     __be32 off_dt_struct;        //保存结构块在整个设备树中的偏移  
5.     __be32 off_dt_strings;        //保存的字符串块在设备树中的偏移  
6.     __be32 off_mem_rsvmap;        //保留内存区，该区保留了不能被内核动态分配的内存空间  
7.     __be32 version;            //设备树版本  
8.     __be32 last_comp_version;    //向下兼容版本号  
9.     __be32 boot_cpuid_phys;    //为在多核处理器中用于启动的主cpu的物理id  
10.     __be32 dt_strings_size;    //字符串块大小  
11.     __be32 dt_struct_size;     //结构块大小  
12. };  

       设备树结构块是一个线性化的结构体，是设备树的主体，以节点node的形式保存了目标单板上的设备信息。

       在结构块中以宏OF_DT_BEGIN_NODE标志一个节点的开始，以宏OF_DT_END_NODE标识一个节点的结束，整个结构块以宏OF_DT_END结束。一个节点主要由以下几部分组成。

(1)节点开始标志：一般为OF_DT_BEGIN_NODE。
(2)节点路径或者节点的单元名(ersion<3以节点路径表示，version>=0x10以节点单元名表示)
(3)填充字段（对齐到四字节）
(4)节点属性。每个属性以宏OF_DT_PROP开始，后面依次为属性值的字节长度(4字节)、属性名称在字符串块中的偏移量(4字节)、属性值和填充（对齐到四字节）。
(5)如果存在子节点，则定义子节点。
(6)节点结束标志OF_DT_END_NODE。

1.3 字符串块

       通过节点的定义知道节点都有若干属性，而不同的节点的属性又有大量相同的属性名称，因此将这些属性名称提取出一张表，当节点需要应用某个属性名称时直接在属性名字段保存该属性名称在字符串块中的偏移量。

1.4 设备树源码 DTS 表示

      设备树源码文件(.dts)以可读可编辑的文本形式描述系统硬件配置设备树,支持 C/C++方式的注释,该结构有一个唯一的根节点“/”,每个节点都有自己的名字并可以包含多个子节点。设备树的数据格式遵循了 Open Firmware IEEE standard 1275。这个设备树中有很多节点,每个节点都指定了节点单元名称。每一个属性后面都给出相应的值。以双引号引出的内容为 ASCII 字符串,以尖括号给出的是 32 位的16进制值。这个树结构是启动 Linux 内核所需节点和属性简化后的集合,包括了根节点的基本模式信息、CPU 和物理内存布局,它还包括通过/chosen 节点传递给内核的命令行参数信息。

1.5 machine_desc结构

      内核提供了一个重要的结构体struct machine_desc ，这个结构体在内核移植中起到相当重要的作用，内核通过machine_desc结构体来控制系统体系架构相关部分的初始化。machine_desc结构体通过MACHINE_START宏来初始化，在代码中， 通过在start_kernel->setup_arch中调用setup_machine_fdt来获取。

[cpp] view plaincopy

1. struct machine_desc {  
2.     unsigned int nr; /* architecture number */  
3.     const char *name; /* architecture name */  
4.     unsigned long atag_offset; /* tagged list (relative) */  
5.     const char *const *dt_compat; /* array of device tree* 'compatible' strings */  
6.     unsigned int nr_irqs; /* number of IRQs */  
7.       
8. #ifdef CONFIG_ZONE_DMA  
9.     phys_addr_t dma_zone_size; /* size of DMA-able area */  
10. #endif  
11.       
12.     unsigned int video_start; /* start of video RAM */  
13.     unsigned int video_end; /* end of video RAM */  
14.       
15.     unsigned char reserve_lp0 :1; /* never has lp0 */  
16.     unsigned char reserve_lp1 :1; /* never has lp1 */  
17.     unsigned char reserve_lp2 :1; /* never has lp2 */  
18.     enum reboot_mode reboot_mode; /* default restart mode */  
19.     struct smp_operations *smp; /* SMP operations */  
20.     bool (*smp_init)(void);  
21.     void (*fixup)(struct tag *, char **,struct meminfo *);  
22.     void (*init_meminfo)(void);  
23.     void (*reserve)(void);/* reserve mem blocks */  
24.     void (*map_io)(void);/* IO mapping function */  
25.     void (*init_early)(void);  
26.     void (*init_irq)(void);  
27.     void (*init_time)(void);  
28.     void (*init_machine)(void);  
29.     void (*init_late)(void);  
30. #ifdef CONFIG_MULTI_IRQ_HANDLER  
31.     void (*handle_irq)(struct pt_regs *);  
32. #endif  
33.     void (*restart)(enum reboot_mode, const char *);  
34. };  

[cpp] view plaincopy

1. struct device_node {  
2.     const char *name;    //设备name  
3.     const char *type; //设备类型  
4.     phandle phandle;  
5.     const char *full_name; //设备全称，包括父设备名  
6.   
7.     struct property *properties; //设备属性链表  
8.     struct property *deadprops; //removed properties  
9.     struct device_node *parent; //指向父节点  
10.     struct device_node *child; //指向子节点  
11.     struct device_node *sibling; //指向兄弟节点  
12.     struct device_node *next; //相同设备类型的下一个节点  
13.     struct device_node *allnext; //next in list of all nodes  
14.     struct proc_dir_entry *pde; //该节点对应的proc  
15.     struct kref kref;  
16.     unsigned long _flags;  
17.     void *data;  
18. #if defined(CONFIG_SPARC)  
19.     const char *path_component_name;  
20.     unsigned int unique_id;  
21.     struct of_irq_controller *irq_trans;  
22. #endif  
23. };  

1.7 属性结构体

[cpp] view plaincopy

1. struct property {  
2.     char *name;        //属性名  
3.     int length;        //属性值长度  
4.     void *value;        //属性值  
5.     struct property *next; //指向下一个属性  
6.     unsigned long _flags; //标志  
7.     unsigned int unique_id;  
8. };  

三、设备树初始化及解析

        分析Linux内核的源码，可以看到其对扁平设备树的解析流程如下：

（1）首先在内核入口处将从u-boot传递过来的镜像基地址。

（2）通过调用early_init_dt_scan()函数来获取内核前期初始化所需的bootargs，cmd_line等系统引导参数。

（3）根据bootargs，cmd_line等系统引导参数进入start_kernel()函数，进行内核的第二阶段初始化。

（4）调用unflatten_device_tree()函数来解析dtb文件，构建一个由device_node结构连接而成的单项链表，并使用全局变量of_allnodes指针来保存这个链表的头指针。

（5）内核调用OF提供的API函数获取of_allnodes链表信息来初始化内核其他子系统、设备等。

[cpp] view plaincopy

1. //kernel 初始化的代码（init/main.c）  
2. asmlinkage void __init start_kernel(void)  
3. {  
4.     ...  
5.     //这个setup_arch就是各个架构自己的设置函数，哪个参与了编译就调用哪个，arm架构应当是arch/arm/kernel/setup.c中的 setup_arch。  
6.     setup_arch(&command_line);  
7.     ...  
8. }  
9.   
10. void __init setup_arch(char **cmdline_p)  
11. {  
12.     const struct machine_desc *mdesc;  
13.        
14.     setup_processor();  
15.     //setup_machine_fdt函数获取内核前期初始化所需的bootargs，cmd_line等系统引导参数  
16.     mdesc = setup_machine_fdt(__atags_pointer);//__atags_pointer是bootloader传递参数的物理地址  
17.     if (!mdesc)  
18.         mdesc = setup_machine_tags(__atags_pointer, __machine_arch_type);  
19.     machine_desc = mdesc;  
20.     machine_name = mdesc->name;  
21.           
22.     if (mdesc->reboot_mode != REBOOT_HARD)  
23.         reboot_mode = mdesc->reboot_mode;  
24.           
25.     init_mm.start_code = (unsigned long) _text;  
26.     init_mm.end_code = (unsigned long) _etext;  
27.     init_mm.end_data = (unsigned long) _edata;  
28.     init_mm.brk = (unsigned long) _end;  
29.   
30.     strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE);  
31.     *cmdline_p = cmd_line;  
32.    
33.     parse_early_param();  
34.    
35.     sort(&meminfo.bank, meminfo.nr_banks, sizeof(meminfo.bank[0]), meminfo_cmp, NULL);  
36.    
37.     early_paging_init(mdesc, lookup_processor_type(read_cpuid_id()));  
38.     setup_dma_zone(mdesc);  
39.     sanity_check_meminfo();  
40.     arm_memblock_init(&meminfo, mdesc);  
41.    
42.     paging_init(mdesc);  
43.     request_standard_resources(mdesc);  
44.    
45.     if (mdesc->restart)  
46.         arm_pm_restart = mdesc->restart;  
47.    
48.      //解析设备树  
49.     unflatten_device_tree();  
50.    
51.     ......  
52. }</span>  

1. setup_machine_fdt()函数获取内核前期初始化所需的bootargs，cmd_line等系统引导参数。

[cpp] view plaincopy

1. const struct machine_desc * __init setup_machine_fdt(unsigned int dt_phys)  
2. {  
3.     const struct machine_desc *mdesc, *mdesc_best = NULL;  
4.    
5. #ifdef CONFIG_ARCH_MULTIPLATFORM  
6.     DT_MACHINE_START(GENERIC_DT, "Generic DT based system")  
7.     MACHINE_END  
8.        
9.     mdesc_best = &__mach_desc_GENERIC_DT;  
10. #endif  
11.   
12.     //bootloader传递参数的物理地址不为空，并将物理地址转化为虚拟地址,  
13.     //通过函数early_init_dt_scan从设备树中读出bootargs，cmd_line等系统引导参数。  
14.     if (!dt_phys || !early_init_dt_scan(phys_to_virt(dt_phys)))  
15.         return NULL;  
16.       
17.     //根据设备树中根节点属性"compatible"的属性描述，找到系统中定义的最匹配的machine_desc结构，该结构控制系统体系架构相关部分的初始化  
18.     mdesc = of_flat_dt_match_machine(mdesc_best, arch_get_next_mach);  
19.     if (!mdesc) {  
20.         const char *prop;  
21.         long size;  
22.         unsigned long dt_root;  
23.    
24.         early_print("\nError: unrecognized/unsupported ""device tree compatible list:\n[ ");  
25.    
26.         //找到设备树的根节点，dt_root指向根节点的属性地址处  
27.         dt_root = of_get_flat_dt_root();  
28.         //读出根节点的"compatible"属性的属性值  
29.         prop = of_get_flat_dt_prop(dt_root, "compatible", &size);  
30.         //将根节点的"compatible"属性的属性值打印出来  
31.         while (size > 0) {  
32.             early_print("'%s' ", prop);  
33.             size -= strlen(prop) + 1;  
34.             prop += strlen(prop) + 1;  
35.         }  
36.         early_print("]\n\n");  
37.           
38.         dump_machine_table(); /* does not return */  
39.     }  
40.            
41.     //Change machine number to match the mdesc we're using  
42.     __machine_arch_type = mdesc->nr;  
43.   
44.     return mdesc;  
45. }  
46.   
47. struct boot_param_header *initial_boot_params;  
48. bool __init early_init_dt_scan(void *params)  
49. {  
50.     if (!params)  
51.         return false;  
52.           
53.     //参数params是bootloader传递参数的物理地址转化为的虚拟地址，保存设备树起始地址  
54.     initial_boot_params = params;  
55.           
56.     //验证设备树的magic   
57.     if (be32_to_cpu(initial_boot_params->magic) != OF_DT_HEADER) {  
58.         initial_boot_params = NULL;  
59.         return false;  
60.     }  
61.           
62.     //从设备树中读取chosen节点的信息,包括命令行boot_command_line,initrd location及size  
63.     of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line);  
64.           
65.     //得到根节点的{size,address}-cells信息  
66.     of_scan_flat_dt(early_init_dt_scan_root, NULL);  
67.           
68.     //读出设备树的系统内存设置  
69.     of_scan_flat_dt(early_init_dt_scan_memory, NULL);  
70.           
71.     return true;  
72. }  
73.   
74. int __init of_scan_flat_dt(int (*it)(unsigned long node,const char *uname, int depth,void *data),void *data)  
75. {  
76.     //找到设备树中结构块的地址  
77.     unsigned long p = ((unsigned long)initial_boot_params) + be32_to_cpu(initial_boot_params->off_dt_struct);  
78.     int rc = 0;  
79.     int depth = -1;  
80.    
81.     do {  
82.         //获得节点起始标志，即OF_DT_BEGIN_NODE，OF_DT_PROP等  
83.         u32 tag = be32_to_cpup((__be32 *)p);  
84.         const char *pathp;  
85.           
86.         p += 4;//跳过节点起始标志  
87.           
88.         //如果是OF_DT_END_NODE标志，表示该节点结束，继续下一结点  
89.         if (tag == OF_DT_END_NODE) {  
90.             depth--;  
91.             continue;  
92.         }  
93.           
94.         //OF_DT_NOP标志代表空节点  
95.         if (tag == OF_DT_NOP)  
96.             continue;  
97.               
98.         //OF_DT_END标志整个结构块结束  
99.         if (tag == OF_DT_END)  
100.             break;  
101.               
102.         //OF_DT_PROP标示属性,Property:属性值的字节长度、属性名称在字符串块中的偏移量、属性值和填充。  
103.         if (tag == OF_DT_PROP) {  
104.             //属性值的字节大小  
105.             u32 sz = be32_to_cpup((__be32 *)p);  
106.             p += 8;//跳过属性值的字节长度、属性名称在字符串块中的偏移量  
107.             if (be32_to_cpu(initial_boot_params->version) < 0x10)  
108.                 p = ALIGN(p, sz >= 8 ? 8 : 4);  
109.             //跳过该属性值的大小  
110.             p += sz;  
111.             //地址对齐  
112.             p = ALIGN(p, 4);  
113.             //表示一个属性节点遍历完成，因为这里并不是寻找属性节点，而是找OF_DT_BEGIN_NODE开始的节点  
114.             continue;  
115.         }  
116.           
117.         //若都不是以上节点类型，也不是节点开始标示(OF_DT_BEGIN_NODE)，则出错返回  
118.         if (tag != OF_DT_BEGIN_NODE) {  
119.             pr_err("Invalid tag %x in flat device tree!\n", tag);  
120.             return -EINVAL;  
121.         }  
122.           
123.         //执行到这里，标示tag=OF_DT_BEGIN_NODE，表示一个节点的开始，探索深度加1  
124.         depth++;  
125.         //节点路径或者节点名  
126.         pathp = (char *)p;  
127.         //节点地址四字节对齐，然后p指向节点属性地址  
128.         p = ALIGN(p + strlen(pathp) + 1, 4);  
129.         //如果是节点路径，则返回路径名的最后一段，假如为/root/my_root,则返回my_root，即获得节点名  
130.         if (*pathp == '/')  
131.             pathp = kbasename(pathp);  
132.         //调用相应的节点处理函数，p指向节点属性地址  
133.         rc = it(p, pathp, depth, data);  
134.         if (rc != 0)  
135.             break;  
136.     } while (1);  
137.    
138.     return rc;  
139. }  

1.1 chosen节点

[cpp] view plaincopy

1. int __init early_init_dt_scan_chosen(unsigned long node, const char *uname,int depth, void *data)  
2. {  
3.     unsigned long l;  
4.     char *p;  
5.       
6.     pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth, uname);  
7.   
8.     //depth深度要为1，表示在根节点下(一般根节点/的depth为0)  
9.     //data表示系统启动命令行boot_command_line要分配空间  
10.     //检查节点名是否为chosen节点      
11.     if (depth != 1 || !data || (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))  
12.         return 0;  
13.       
14.     //从设备树的chosen节点中读出initrd的起始、结束地址  
15.     early_init_dt_check_for_initrd(node);  
16.    
17.     //设备树的chosen节点中读取bootargs属性的属性值，并拷贝给boot_command_line  
18.     p = of_get_flat_dt_prop(node, "bootargs", &l);  
19.     if (p != NULL && l > 0)  
20.         strlcpy(data, p, min((int)l, COMMAND_LINE_SIZE));  
21.   
22.     pr_debug("Command line is: %s\n", (char*)data);  
23.        
24.     return 1;  
25. }  
26.   
27. static void __init early_init_dt_check_for_initrd(unsigned long node)  
28. {  
29.     u64 start, end;  
30.     unsigned long len;  
31.     __be32 *prop;  
32.           
33.     pr_debug("Looking for initrd properties... ");  
34.            
35.     //返回该chosen节点中属性名为"linux,initrd-start"的地址  
36.     prop = of_get_flat_dt_prop(node, "linux,initrd-start", &len);  
37.     if (!prop)  
38.         return;  
39.     //从该地址读出initrd-start的地址  
40.     start = of_read_number(prop, len/4);  
41.           
42.     //返回该chosen节点中属性名为"linux,initrd-end"的地址  
43.     prop = of_get_flat_dt_prop(node, "linux,initrd-end", &len);  
44.     if (!prop)  
45.         return;  
46.     //从该地址读出initrd-end的地址  
47.     end = of_read_number(prop, len/4);  
48.           
49.     //将读出的地址赋值给全局变量initrd_start和initrd_end，用于跟文件系统的挂载  
50.     initrd_start = (unsigned long)__va(start);  
51.     initrd_end = (unsigned long)__va(end);  
52.     initrd_below_start_ok = 1;  
53.           
54.     pr_debug("initrd_start=0x%llx initrd_end=0x%llx\n",(unsigned long long)start, (unsigned long long)end);  
55. }  
56.   
57. void *__init of_get_flat_dt_prop(unsigned long node, const char *name,unsigned long *size)  
58. {  
59.     return of_fdt_get_property(initial_boot_params, node, name, size);  
60. }  
61.   
62. void *of_fdt_get_property(struct boot_param_header *blob,unsigned long node, const char *name,unsigned long *size)  
63. {  
64.     //p指向该chosen节点的节点属性地址  
65.     unsigned long p = node;  
66.        
67.     //因为一个节点中可能包含多个属性，所以这里遍历chosen节点中的所有属性，找到属性名为name的属性  
68.     do {  
69.         //取得该节点属性的起始标志OF_DT_PROP  
70.         u32 tag = be32_to_cpup((__be32 *)p);  
71.         u32 sz, noff;  
72.         const char *nstr;  
73.            
74.         p += 4;//跳过节点属性的起始标志  
75.   
76.         //空节点则继续  
77.         if (tag == OF_DT_NOP)  
78.             continue;  
79.         //非属性标志则返回NULL  
80.         if (tag != OF_DT_PROP)  
81.             return NULL;  
82.            
83.         //运行到这里表示为属性OF_DT_PROP  
84.         //取得该节点属性的的属性值size  
85.         sz = be32_to_cpup((__be32 *)p);  
86.         //取得该属性名的在字符串块中的偏移值  
87.         noff = be32_to_cpup((__be32 *)(p + 4));  
88.         p += 8;  
89.         //跳过对齐填充字段  
90.         if (be32_to_cpu(blob->version) < 0x10)  
91.             p = ALIGN(p, sz >= 8 ? 8 : 4);  
92.            
93.         //在字符串块取出该属性的名称  
94.         nstr = of_fdt_get_string(blob, noff);  
95.         if (nstr == NULL) {  
96.             pr_warning("Can't find property index name !\n");  
97.             return NULL;  
98.         }  
99.   
100.         //若名称一致，表示找到我们要找的属性  
101.         if (strcmp(name, nstr) == 0) {  
102.             if (size)  
103.                 *size = sz;//返回该属性的属性值size  
104.             //返回该属性值所在的地址  
105.             return (void *)p;  
106.         }  
107.         //否则继续下一个属性  
108.         p += sz;  
109.         p = ALIGN(p, 4);  
110.     } while (1);  
111. }  
112.   
113. char *of_fdt_get_string(struct boot_param_header *blob, u32 offset)  
114. {  
115.     //从设备树的字符串块的offset处读出name  
116.     return ((char *)blob) + be32_to_cpu(blob->off_dt_strings) + offset;  
117. }  
118.   
119. static inline u64 of_read_number(const __be32 *cell, int size)  
120. {  
121.     u64 r = 0;  
122.     //读出属性值，属性值大小为size  
123.     while (size--)  
124.         r = (r << 32) | be32_to_cpu(*(cell++));  
125.     return r;  
126. }  

1.2 根节点"/"

[cpp] view plaincopy

1. int __init early_init_dt_scan_root(unsigned long node, const char *uname,int depth, void *data)  
2. {  
3.     __be32 *prop;  
4.       
5.     //根节点的探索深度depth一定为0，否则不是根节点"/",node为根节点的属性地址      
6.     if (depth != 0)  
7.         return 0;  
8.           
9.     dt_root_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;  
10.     dt_root_addr_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;  
11.           
12.     //返回根节点节点属性名为"#size-cells"的地址  
13.     prop = of_get_flat_dt_prop(node, "#size-cells", NULL);  
14.     if (prop)  
15.         dt_root_size_cells = be32_to_cpup(prop);//从该属性获得root size  
16.           
17.     pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells);  
18.           
19.     //返回根节点节点属性名为"#address-cells"的地址  
20.     prop = of_get_flat_dt_prop(node, "#address-cells", NULL);  
21.     if (prop)  
22.         dt_root_addr_cells = be32_to_cpup(prop);//从该属性获得root address  
23.     pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells);  
24.           
25.     return 1;  
26. }  

[cpp] view plaincopy

1. int __init early_init_dt_scan_memory(unsigned long node, const char *uname,int depth, void *data)  
2. {  
3.     //获取该节点中属性"device_type"的属性值  
4.     char *type = of_get_flat_dt_prop(node, "device_type", NULL);  
5.     __be32 *reg, *endp;  
6.     unsigned long l;  
7.       
8.     //检查"device_type"的属性值，确定该节点是否为memory节点  
9.     if (type == NULL) {  
10.         if (depth != 1 || strcmp(uname, "memory@0") != 0)  
11.             return 0;  
12.     } else if (strcmp(type, "memory") != 0)  
13.         return 0;  
14.       
15.     //从该memory节点中获取属性"linux,usable-memory"的属性值，及属性值大小l  
16.     reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);  
17.     if (reg == NULL)  
18.         reg = of_get_flat_dt_prop(node, "reg", &l);  
19.     if (reg == NULL)  
20.         return 0;  
21.       
22.     //reg为属性值的起始地址，endp为结束地址  
23.     endp = reg + (l / sizeof(__be32));  
24.       
25.     pr_debug("memory scan node %s, reg size %ld, data: %x %x %x %x,\n",  
26.                         uname, l, reg[0], reg[1], reg[2], reg[3]);  
27.       
28.     while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {  
29.         u64 base, size;  
30.       
31.         //读出物理内存的起始地址以及size  
32.         base = dt_mem_next_cell(dt_root_addr_cells, &reg);  
33.         size = dt_mem_next_cell(dt_root_size_cells, &reg);  
34.       
35.         if (size == 0)  
36.             continue;  
37.         pr_debug(" - %llx , %llx\n", (unsigned long long)base,(unsigned long long)size);  
38.       
39.         //添加物理内存到memblock中进行管理，这里不再展开  
40.         early_init_dt_add_memory_arch(base, size);  
41.     }  
42.       
43.     return 0;  
44. }  

2. 通过比较根节点属性compatible值指明和目标板为同一系列的兼容的开发板名称

[cpp] view plaincopy

1. const void * __init of_flat_dt_match_machine(const void *default_match,  
2.                                             const void * (*get_next_compat)(const char * const**))  
3. {  
4.     const void *data = NULL;  
5.     const void *best_data = default_match;  
6.     const char *const *compat;  
7.     unsigned long dt_root;  
8.     unsigned int best_score = ~1, score = 0;  
9.       
10.     //读出设备树的根节点，dt_root指向根节点的属性地址处  
11.     dt_root = of_get_flat_dt_root();  
12.   
13.     //调用arch_get_next_mach，遍历该系统中的所有machine_desc结构，返回给data，并且返回该结构的compatible  
14.     while ((data = get_next_compat(&compat))) {  
15.         //将系统中的所有machine_desc结构的compatible字符串与设备树根节点的compatible属性进行match  
16.         score = of_flat_dt_match(dt_root, compat);  
17.         //返回与根节点属性compatible属性值最匹配的machine_desc结构  
18.         if (score > 0 && score < best_score) {  
19.             best_data = data;  
20.             best_score = score;  
21.         }  
22.     }  
23.       
24.     if (!best_data) {  
25.         const char *prop;  
26.         long size;  
27.       
28.         pr_err("\n unrecognized device tree list:\n[ ");  
29.        
30.         prop = of_get_flat_dt_prop(dt_root, "compatible", &size);  
31.         if (prop) {  
32.             while (size > 0) {  
33.                 printk("'%s' ", prop);  
34.                 size -= strlen(prop) + 1;  
35.                 prop += strlen(prop) + 1;  
36.             }  
37.         }  
38.         printk("]\n\n");  
39.         return NULL;  
40.     }  
41.        
42.     pr_info("Machine model: %s\n", of_flat_dt_get_machine_name());  
43.       
44.     return best_data;  
45. }  
46.   
47.   
48. //查找设备树的根节点  
49. unsigned long __init of_get_flat_dt_root(void)  
50. {  
51.     //找到设备树的设备块起始地址  
52.     unsigned long p = ((unsigned long)initial_boot_params) +  
53.                                     be32_to_cpu(initial_boot_params->off_dt_struct);  
54.       
55.     //跳过空节点   
56.     while (be32_to_cpup((__be32 *)p) == OF_DT_NOP)  
57.         p += 4;  
58.     BUG_ON(be32_to_cpup((__be32 *)p) != OF_DT_BEGIN_NODE);  
59.     p += 4;  
60.     //第一个节点就是根节点，p指向根节点的属性地址处  
61.     return ALIGN(p + strlen((char *)p) + 1, 4);  
62. }  
63.   
64. //arch/arm/kernel/devtree.c  
65. __arch_info_begin 和 __arch_info_end是在 arch/arm/kernel/vmlinux.lds.S中:  
66. 00034: __arch_info_begin = .;  
67. 00035: *(.arch.info.init)  
68. 00036: __arch_info_end = .;  
69. 这里是声明了两个变量:__arch_info_begin 和 __arch_info_end,其中等号后面的"."是location counter。在__arch_info_begin 的位置上,放置所有文件中的 ".arch.info.init" 段的内容,然后紧接着是 __arch_info_end 的位置.".arch.info.init" 段中定义了设备的machine_desc结构。  
70. //这里就是取出一个machine_desc结构  
71. static const void * __init arch_get_next_mach(const char *const **match)  
72. {  
73.     static const struct machine_desc *mdesc = __arch_info_begin;  
74.     const struct machine_desc *m = mdesc;  
75.           
76.     if (m >= __arch_info_end)  
77.         return NULL;  
78.           
79.     mdesc++;//指针后移，确保下次取出下一个machine_desc结构  
80.     *match = m->dt_compat;  
81.     return m;//返回当前的machine_desc结构  
82. }  
83.   
84. //与设备树根节点进行match  
85. int __init of_flat_dt_match(unsigned long node, const char *const *compat)  
86. {  
87.     //initial_boot_params指向设备树起始地址  
88.     //node指向根节点的属性地址  
89.     //compat为系统中machine_desc结构的compatible字符串  
90.     return of_fdt_match(initial_boot_params, node, compat);  
91. }  
92.   
93. int of_fdt_match(struct boot_param_header *blob, unsigned long node,const char *const *compat)  
94. {  
95.     unsigned int tmp, score = 0;  
96.           
97.     if (!compat)  
98.         return 0;  
99.       
100.     //遍历compatible字符串数组      
101.     while (*compat) {  
102.         //返回compatible的匹配值  
103.         tmp = of_fdt_is_compatible(blob, node, *compat);  
104.         if (tmp && (score == 0 || (tmp < score)))  
105.             score = tmp;//返回最大的匹配值  
106.         compat++;//下一个字符串  
107.     }  
108.           
109.     return score;  
110. }  
111.   
112. int of_fdt_is_compatible(struct boot_param_header *blob,unsigned long node, const char *compat)  
113. {  
114.     const char *cp;  
115.     unsigned long cplen, l, score = 0;  
116.       
117.     //从根节点中读出属性"compatible"的属性值  
118.     cp = of_fdt_get_property(blob, node, "compatible", &cplen);  
119.     if (cp == NULL)  
120.         return 0;  
121.       
122.     //比较compatible的指定的属性字符串的一致性  
123.     while (cplen > 0) {  
124.         score++;  
125.         if (of_compat_cmp(cp, compat, strlen(compat)) == 0)  
126.             return score;  
127.         l = strlen(cp) + 1;  
128.         cp += l;  
129.         cplen -= l;  
130.     }  
131.           
132.     return 0;  
133. }  

(二)、解析设备树
       unflatten_device_tree()函数来解析dtb文件，构建一个由device_node结构连接而成的单项链表，并使用全局变量of_allnodes指针来保存这个链表的头指针。内核调用OF提供的API函数获取of_allnodes链表信息来初始化内核其他子系统、设备。

[cpp] view plaincopy

1. void __init unflatten_device_tree(void)  
2. {  
3.     //解析设备树，将所有的设备节点链入全局链表    of_allnodes中  
4.     __unflatten_device_tree(initial_boot_params, &of_allnodes,early_init_dt_alloc_memory_arch);  
5.        
6.     //设置内核输出终端，以及遍历“/aliases”节点下的所有的属性，挂入相应链表  
7.     of_alias_scan(early_init_dt_alloc_memory_arch);  
8. }  
9.   
10. static void __unflatten_device_tree(struct boot_param_header *blob,  
11.                                     struct device_node **mynodes,  
12.                                     void * (*dt_alloc)(u64 size, u64 align))  
13. {  
14.     unsigned long size;  
15.     void *start, *mem;  
16.     struct device_node **allnextp = mynodes;  
17.       
18.     pr_debug(" -> unflatten_device_tree()\n");  
19.        
20.     if (!blob) {  
21.         pr_debug("No device tree pointer\n");  
22.         return;  
23.     }  
24.        
25.     pr_debug("Unflattening device tree:\n");  
26.     pr_debug("magic: %08x\n", be32_to_cpu(blob->magic));  
27.     pr_debug("size: %08x\n", be32_to_cpu(blob->totalsize));  
28.     pr_debug("version: %08x\n", be32_to_cpu(blob->version));  
29.       
30.     //检查设备树magic  
31.     if (be32_to_cpu(blob->magic) != OF_DT_HEADER) {  
32.         pr_err("Invalid device tree blob header\n");  
33.         return;  
34.     }  
35.       
36.     //找到设备树的设备节点起始地址  
37.     start = ((void *)blob) + be32_to_cpu(blob->off_dt_struct);  
38.     //第一次调用mem传0，allnextpp传NULL，实际上是为了计算整个设备树所要的空间  
39.     size = (unsigned long)unflatten_dt_node(blob, 0, &start, NULL, NULL, 0);  
40.     size = ALIGN(size, 4);//4字节对齐  
41.        
42.     pr_debug(" size is %lx, allocating...\n", size);  
43.        
44.     //调用early_init_dt_alloc_memory_arch函数，为设备树分配内存空间  
45.     mem = dt_alloc(size + 4, __alignof__(struct device_node));  
46.     memset(mem, 0, size);  
47.       
48.     //设备树结束处赋值0xdeadbeef，为了后边检查是否有数据溢出  
49.     *(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);   
50.     pr_debug(" unflattening %p...\n", mem);  
51.        
52.     //再次获取设备树的设备节点起始地址  
53.     start = ((void *)blob) + be32_to_cpu(blob->off_dt_struct);  
54.     //mem为设备树分配的内存空间，allnextp指向全局变量of_allnodes，生成整个设备树  
55.     unflatten_dt_node(blob, mem, &start, NULL, &allnextp, 0);  
56.     if (be32_to_cpup(start) != OF_DT_END)  
57.         pr_warning("Weird tag at end of tree: %08x\n", be32_to_cpup(start));  
58.     if (be32_to_cpup(mem + size) != 0xdeadbeef)  
59.         pr_warning("End of tree marker overwritten: %08x\n",be32_to_cpup(mem + size));  
60.     *allnextp = NULL;  
61.        
62.     pr_debug(" <- unflatten_device_tree()\n");  
63. }  
64.   
65. static void * unflatten_dt_node(struct boot_param_header *blob,  
66.                                 void *mem,void **p,  
67.                                 struct device_node *dad,  
68.                                 struct device_node ***allnextpp,  
69.                                 unsigned long fpsize)  
70. {  
71.     struct device_node *np;  
72.     struct property *pp, **prev_pp = NULL;  
73.     char *pathp;  
74.     u32 tag;  
75.     unsigned int l, allocl;  
76.     int has_name = 0;  
77.     int new_format = 0;  
78.       
79.     //*p指向设备树的设备块起始地址  
80.     tag = be32_to_cpup(*p);  
81.     //每个有孩子的设备节点，其tag一定是OF_DT_BEGIN_NODE  
82.     if (tag != OF_DT_BEGIN_NODE) {  
83.         pr_err("Weird tag at start of node: %x\n", tag);  
84.         return mem;  
85.     }  
86.   
87.     *p += 4;//地址+4，跳过tag，这样指向节点的名称或者节点路径名  
88.     pathp = *p;//获得节点名或者节点路径名  
89.     l = allocl = strlen(pathp) + 1;//该节点名称的长度  
90.     *p = PTR_ALIGN(*p + l, 4);//地址对齐后，*p指向该节点属性的地址  
91.       
92.     //如果是节点名则进入，若是节点路径名则(*pathp) == '/'  
93.     if ((*pathp) != '/') {  
94.         new_format = 1;  
95.         if (fpsize == 0) {//fpsize=0  
96.             fpsize = 1;  
97.             allocl = 2;  
98.             l = 1;  
99.             *pathp = '\0';  
100.         } else {  
101.             fpsize += l;//代分配的长度=本节点名称长度+父亲节点绝对路径的长度  
102.             allocl = fpsize;  
103.         }  
104.     }  
105.       
106.     //分配一个设备节点device_node结构，*mem记录分配了多大空间，最终会累加计算出该设备树总共分配的空间大小  
107.     np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,__alignof__(struct device_node));  
108.   
109.     //第一次调用unflatten_dt_node时，allnextpp=NULL  
110.     //第一次调用unflatten_dt_node时，allnextpp指向全局变量of_allnodes的地址  
111.     if (allnextpp) {  
112.         char *fn;  
113.         //full_name保存完整的节点名，即包括各级父节点的名称  
114.         np->full_name = fn = ((char *)np) + sizeof(*np);  
115.         //若new_format=1，表示pathp保存的是节点名，而不是节点路径名，所以需要加上父节点的name  
116.         if (new_format) {  
117.             if (dad && dad->parent) {  
118.                 strcpy(fn, dad->full_name);//把父亲节点绝对路径先拷贝  
119.                 fn += strlen(fn);  
120.             }  
121.             *(fn++) = '/';  
122.         }  
123.         memcpy(fn, pathp, l);//拷贝本节点的名称  
124.       
125.         //prev_pp指向节点的属性链表  
126.         prev_pp = &np->properties;  
127.   
128.         //当前节点插入全局链表of_allnodes  
129.         **allnextpp = np;  
130.         *allnextpp = &np->allnext;  
131.   
132.         //若父亲节点不为空，则设置该节点的parent  
133.         if (dad != NULL) {  
134.             np->parent = dad;//指向父亲节点  
135.             if (dad->next == NULL)//第一个孩子  
136.                 dad->child = np;//child指向第一个孩子  
137.             else  
138.                 dad->next->sibling = np;//把np插入next，这样孩子节点形成链表  
139.             dad->next = np;  
140.         }  
141.         kref_init(&np->kref);  
142.     }  
143.   
144.     //分析该节点的属性  
145.     while (1) {  
146.         u32 sz, noff;  
147.         char *pname;  
148.        
149.         //前边已经将*p移到指向节点属性的地址处，取出属性标识  
150.         tag = be32_to_cpup(*p);  
151.         //空属性，则跳过  
152.         if (tag == OF_DT_NOP) {  
153.             *p += 4;  
154.             continue;  
155.         }  
156.         //tag不是属性则退出，对于有孩子节点退出时为OF_DT_BEGIN_NODE，对于叶子节点退出时为OF_DT_END_NODE  
157.         if (tag != OF_DT_PROP)  
158.             break;  
159.         //地址加4，跳过tag  
160.         *p += 4;  
161.         //获得属性值的大小，是以为占多少整形指针计算的  
162.         sz = be32_to_cpup(*p);  
163.         //获取属性名称在节点的字符串块中的偏移  
164.         noff = be32_to_cpup(*p + 4);  
165.         //地址加8，跳过属性值的大小和属性名称在节点的字符串块中的偏移  
166.         *p += 8;  
167.         //地址对齐后，*P指向属性值所在的地址  
168.         if (be32_to_cpu(blob->version) < 0x10)  
169.             *p = PTR_ALIGN(*p, sz >= 8 ? 8 : 4);  
170.           
171.         //从节点的字符串块中noff偏移处，得到该属性的name  
172.         pname = of_fdt_get_string(blob, noff);  
173.         if (pname == NULL) {  
174.             pr_info("Can't find property name in list !\n");  
175.             break;  
176.         }  
177.   
178.         //如果有名称为name的属性，表示变量has_name为1  
179.         if (strcmp(pname, "name") == 0)  
180.             has_name = 1;  
181.         //计算该属性name的大小  
182.         l = strlen(pname) + 1;  
183.   
184.         //为该属性分配一个属性结构，即struct property，  
185.         //*mem记录分配了多大空间，最终会累加计算出该设备树总共分配的空间大小  
186.         pp = unflatten_dt_alloc(&mem, sizeof(struct property),__alignof__(struct property));  
187.   
188.         //第一次调用unflatten_dt_node时，allnextpp=NULL  
189.         //第一次调用unflatten_dt_node时，allnextpp指向全局变量of_allnodes的地址  
190.         if (allnextpp) {  
191.             if ((strcmp(pname, "phandle") == 0) || (strcmp(pname, "linux,phandle") == 0)) {  
192.                 if (np->phandle == 0)  
193.                     np->phandle = be32_to_cpup((__be32*)*p);  
194.             }  
195.             if (strcmp(pname, "ibm,phandle") == 0)  
196.                 np->phandle = be32_to_cpup((__be32 *)*p);  
197.             pp->name = pname;//属性名  
198.             pp->length = sz;//属性值长度  
199.             pp->value = *p;//属性值  
200.   
201.             //属性插入该节点的属性链表np->properties  
202.             *prev_pp = pp;  
203.             prev_pp = &pp->next;  
204.         }  
205.         *p = PTR_ALIGN((*p) + sz, 4);//指向下一个属性  
206.     }  
207.     //至此遍历完该节点的所有属性  
208.   
209.     //如果该节点没有"name"的属性，则为该节点生成一个name属性，插入该节点的属性链表  
210.     if (!has_name) {  
211.         char *p1 = pathp, *ps = pathp, *pa = NULL;  
212.         int sz;  
213.        
214.         while (*p1) {  
215.             if ((*p1) == '@')  
216.                 pa = p1;  
217.             if ((*p1) == '/')  
218.                 ps = p1 + 1;  
219.                 p1++;  
220.         }  
221.         if (pa < ps)  
222.             pa = p1;  
223.         sz = (pa - ps) + 1;  
224.         pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,__alignof__(struct property));  
225.         if (allnextpp) {  
226.             pp->name = "name";  
227.             pp->length = sz;  
228.             pp->value = pp + 1;  
229.             *prev_pp = pp;  
230.             prev_pp = &pp->next;  
231.             memcpy(pp->value, ps, sz - 1);  
232.             ((char *)pp->value)[sz - 1] = 0;  
233.             pr_debug("fixed up name for %s -> %s\n", pathp,(char *)pp->value);  
234.         }  
235.     }  
236.   
237.     //若设置了allnextpp指针  
238.     if (allnextpp) {  
239.         *prev_pp = NULL;  
240.         //设置节点的名称  
241.         np->name = of_get_property(np, "name", NULL);  
242.         //设置该节点对应的设备类型  
243.         np->type = of_get_property(np, "device_type", NULL);  
244.       
245.         if (!np->name)  
246.             np->name = "<NULL>";  
247.         if (!np->type)  
248.             np->type = "<NULL>";  
249.     }  
250.   
251.     //前边在遍历属性时，tag不是属性则退出  
252.     //对于有孩子节点退出时tag为OF_DT_BEGIN_NODE，对于叶子节点退出时tag为OF_DT_END_NODE  
253.     while (tag == OF_DT_BEGIN_NODE || tag == OF_DT_NOP) {  
254.         //空属性则指向下个属性  
255.         if (tag == OF_DT_NOP)  
256.             *p += 4;  
257.         else  
258.             //OF_DT_BEGIN_NODE则表明其还有子节点，所以递归分析其子节点  
259.             mem = unflatten_dt_node(blob, mem, p, np, allnextpp,fpsize);  
260.         tag = be32_to_cpup(*p);  
261.     }  
262.   
263.     //对于叶子节点或者分析完成  
264.     if (tag != OF_DT_END_NODE) {  
265.         pr_err("Weird tag at end of node: %x\n", tag);  
266.         return mem;  
267.     }  
268.     *p += 4;  
269.     //mem返回整个设备树所分配的内存大小，即设备树占的内存空间  
270.     return mem;  
271. }  
272.   
273.   
274. //从mem分配内存空间，*mem记录分配了多大空间  
275. static void *unflatten_dt_alloc(void **mem, unsigned long size,unsigned long align)  
276. {  
277.     void *res;  
278.        
279.     *mem = PTR_ALIGN(*mem, align);  
280.     res = *mem;  
281.     *mem += size;  
282.           
283.     return res;  
284. }  
285.   
286. //一个特定的节点通常是以完整的路径来引用，比如/external-bus/ethernet@0,0，不过当一个用户真的想知道“哪个设备是eth0”时，这将会很繁琐。aliases节点可以用来为一个完整的设备路径分配一个短的别名。比如：  
287. //aliases {  
288. //    serial0 = &uart0;  
289. //    serial1 = &uart1;  
290. //    serial2 = &uart2;  
291. //    serial3 = &uart3;  
292. //    ethernet0 = ð0;  
293. //    serial0 = &serial0;  
294. //};  
295. //当需要为设备指定一个标示符时，操作系统欢迎大家使用别名。  
296. //设置内核输出终端，以及遍历“/aliases”节点下的所有的属性，挂入相应链表  
297. void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))  
298. {  
299.     struct property *pp;  
300.       
301.     //根据全局的device_node结构的链表of_allnodes,查找节点名为“/chosen”或者“/chosen@0”的节点，赋值给全局变量of_chosen  
302.     of_chosen = of_find_node_by_path("/chosen");  
303.     if (of_chosen == NULL)  
304.         of_chosen = of_find_node_by_path("/chosen@0");  
305.       
306.     //找到的话，则在该节点查找"linux,stdout-path"    属性  
307.     //"linux,stdout-path"的属性值，常常为标准终端设备的节点路径名，内核会以此作为默认终端  
308.     if (of_chosen) {  
309.         const char *name;  
310.         //返回属性"linux,stdout-path"的属性值  
311.         name = of_get_property(of_chosen, "linux,stdout-path", NULL);  
312.         //根据属性值查找设备节点device_node，即内核默认终端的设备节点,赋值给全局变量of_stdout  
313.         if (name)  
314.             of_stdout = of_find_node_by_path(name);  
315.     }  
316.       
317.     //据全局链表of_allnodes,查找节点名为“/aliases”的节点，赋值给全局变量of_aliases  
318.     of_aliases = of_find_node_by_path("/aliases");  
319.     if (!of_aliases)  
320.         return;  
321.        
322.     //遍历“/aliases”节点下的所有的属性  
323.     for_each_property_of_node(of_aliases, pp) {  
324.         const char *start = pp->name;//属性名  
325.         const char *end = start + strlen(start);//属性名结尾  
326.         struct device_node *np;  
327.         struct alias_prop *ap;  
328.         int id, len;  
329.           
330.         //跳过"name"、"phandle"和"linux,phandle"的属性  
331.         if (!strcmp(pp->name, "name") ||  
332.             !strcmp(pp->name, "phandle") ||  
333.             !strcmp(pp->name, "linux,phandle"))  
334.             continue;  
335.               
336.             //根据属性值找到对应的设备节点  
337.             np = of_find_node_by_path(pp->value);  
338.             if (!np)  
339.                 continue;  
340.           
341.             //去除属性名中结尾的数字，即设备id  
342.             while (isdigit(*(end-1)) && end > start)  
343.                 end--;  
344.             //len为属性名去掉结尾数字序号的长度  
345.             len = end - start;  
346.           
347.             //此时end指向属性名中结尾的数字，即开始时start指向“&uart0”，end指向字符串结尾。  
348.             //经过上步操作，start仍指向“&uart0”字符串开始处，而end指向字符‘0’。  
349.             //将end字符串转化为10进制数，赋值给id，作为设备的id号  
350.             if (kstrtoint(end, 10, &id) < 0)  
351.                 continue;  
352.           
353.             //分配alias_prop结构  
354.             ap = dt_alloc(sizeof(*ap) + len + 1, 4);  
355.             if (!ap)  
356.                 continue;  
357.             memset(ap, 0, sizeof(*ap) + len + 1);  
358.             ap->alias = start;  
359.             //将该设备的aliases指向对应的device_node,并且链入aliases_lookup链表中  
360.             of_alias_add(ap, np, id, start, len);  
361.         }  
362. }