Linux设备树
! J" H' F" p7 G$ b9 U9 B' `+ J/ z在前面章节中我们多次提到“设备树”这个概念和创建自己的设备树。但是并没有在TF-A和uboot里说设备树的原理，主要是一开始就讲解设备树不利于嵌入式Linux入门，对于大多数嵌入式开发人员来说设备树是个全新的概念。
/ I2 u+ S7 M4 g本章我们就来详细的谈一谈设备树。掌握设备树是Linux驱动开发人员必备的技能！因为在新版本的Linux中，ARM相关的驱动全部采用了设备树(也有支持老式驱动的，比较少)，最新出CPU在系统启动的时候就支持设备树，比如我们的MP1系列、NXP的I.MX8系列等。我们所使用的Linux版本为5.4.31，其支持设备树，所以正点原子MP1开发板的所有Linux驱动都是基于设备树的。本章我们就来了解一下设备树的起源、重点学习一下设备树语法。
* c4 x$ w/ ~0 U$ W' Y$ d( \
7 V& C5 h( k) }23.1 什么是设备树？
6 h1 ?# c' n% ?4 y2 y: I设备树(Device Tree)，将这个词分开就是“设备”和“树”，描述设备树的文件叫做DTS(Device Tree Source)，这个DTS文件采用树形结构描述板级设备，也就是开发板上的设备信息，比如CPU数量、 内存基地址、IIC接口上接了哪些设备、SPI接口上接了哪些设备等等，如图23.1.1所示：
( L5 Q! D- Y( v" C! j/ n6 t  y
" d7 a+ k7 H7 V0 \
. D% q! e5 R; h3 _' ?. v
图23.1.1 设备树结构示意图
在图23.1.1中，树的主干就是系统总线，IIC控制器、GPIO控制器、SPI控制器等都是接到系统主线上的分支。IIC控制器有分为IIC1和IIC2两种，其中IIC1上接了FT5206和AT24C02这两个IIC设备，IIC2上只接了MPU6050这个设备。DTS文件的主要功能就是按照图23.1.1所示的结构来描述板子上的设备信息，DTS文件描述设备信息是有相应的语法规则要求的，稍后我们会详细的讲解DTS语法规则。
在3.x版本(具体哪个版本笔者也无从考证)以前的Linux内核中ARM架构并没有采用设备树。在没有设备树的时候Linux是如何描述ARM架构中的板级信息呢？在Linux内核源码中大量的arch/arm/mach-xxx和arch/arm/plat-xxx文件夹，这些文件夹里面的文件就是对应平台下的板级信息。比如在arch/arm/mach-s3c24xx/mach-smdk2440.c中有如下内容(有缩减)：
; F8 e) T# J# n: O2 m0 R7 x
, b7 `3 ^( E5 a4 t. m

1. 示例代码23.1.1  mach-smdk2440.c文件代码段
   
2. 90  static struct s3c2410fb_display smdk2440_lcd_cfg __initdata = {
   
3. 91  
   
4. 92      .lcdcon5    = S3C2410_LCDCON5_FRM565 |
   
5. 93                S3C2410_LCDCON5_INVVLINE |
   - H  R  u; Z% s9 H, Y
6. 94                S3C2410_LCDCON5_INVVFRAME |
   
7. 95                S3C2410_LCDCON5_PWREN |
   
8. 96                S3C2410_LCDCON5_HWSWP,
   
9. ......
   
10. 113 };
    
11. 114
    # S7 W0 {1 f1 I1 j5 j* ^
12. 115 static struct s3c2410fb_mach_info smdk2440_fb_info __initdata = {
    
13. 116     .displays   = &smdk2440_lcd_cfg,
    / i0 f: [: M# s/ }. h) G
14. 117     .num_displays   = 1,
    : x/ T4 z+ Y0 X2 y& l, j. h3 {
15. 118     .default_display = 0,
    
16. ......
    
17. 133 };
    6 Y( `' v' v8 K4 Z6 j
18. 134
    # n4 H+ Q. T: z4 J2 k8 o
19. 135 static struct platform_device *smdk2440_devices[] __initdata = {
    
20. 136     &s3c_device_ohci,
    - S2 E3 h# \& l, R3 ]. Z% ^
21. 137     &s3c_device_lcd,
    7 N* a( b) q9 M! G' I/ P: ~3 y
22. 138     &s3c_device_wdt,
    
23. 139     &s3c_device_i2c0,
    2 L- V. K+ h; V6 N6 M
24. 140     &s3c_device_iis,
    
25. 141 };

复制代码

4 q0 D% f0 Q: e" f2 c8 F7 w" g上述代码中的结构体变量smdk2440_fb_info就是描述SMDK2440这个开发板上的LCD信息的，结构体指针数组smdk2440_devices描述的SMDK2440这个开发板上的所有平台相关信息。这个仅仅是使用2440这个芯片的SMDK2440开发板下的LCD信息，SMDK2440开发板还有很多的其他外设硬件和平台硬件信息。使用2440这个芯片的板子有很多，每个板子都有描述相应板级信息的文件，这仅仅只是一个2440。随着智能手机的发展，每年新出的ARM架构芯片少说都在数十、甚至数百款，Linux内核下板级信息文件将会成指数级增长！这些板级信息文件都是.c或.h文件，都会被硬编码进Linux内核中，导致Linux内核“虚胖”。就好比你喜欢吃自助餐，然后花了100多块钱到一家宣传看着很不错的自助餐厅，结果你想吃的牛排、海鲜、烤肉基本没多少，全都是一些凉菜、炒面、西瓜、饮料等小吃，相信你此时肯定会脱口而出一句“Fk!”、“骗子！”。同样的，当Linux之父linus看到ARM社区向Linux内核添加了大量“无用”、冗余的板级信息文件，不禁的发出了一句“This whole ARM thing is a fcking pain in the ass”。从此以后ARM社区就引入了PowerPC等架构已经采用的设备树(Flattened Device Tree)，将这些描述板级硬件信息的内容都从Linux内中分离开来，用一个专属的文件格式来描述，这个专属的文件就叫做设备树，文件扩展名为.dts。一个SOC可以作出很多不同的板子，这些不同的板子肯定是有共同的信息，将这些共同的信息提取出来作为一个通用的文件，其他的.dts文件直接引用这个通用文件即可，这个通用文件就是.dtsi文件，类似于C语言中的头文件。一般.dts描述板级信息(也就是开发板上有哪些IIC设备、SPI设备等)，.dtsi描述SOC级信息(也就是SOC有几个CPU、主频是多少、各个外设控制器信息等)。
这个就是设备树的由来，简而言之就是，Linux内核中ARM架构下有太多的冗余的垃圾板级信息文件，导致linus震怒，然后ARM社区引入了设备树。
2 o" Y+ ]2 Z. q' l+ J; _5 s23.2 DTS、DTB和DTC
( g) n9 r- p: o& y上一小节说了，设备树源文件扩展名为.dts，但是我们在前面移植Linux的时候却一直在使用.dtb文件，那么DTS和DTB这两个文件是什么关系呢？DTS是设备树源码文件，DTB是将DTS编译以后得到的二进制文件。将.c文件编译为.o需要用到gcc编译器，那么将.dts编译为.dtb需要用到DTC工具！DTC工具源码在Linux内核的scripts/dtc目录下，scripts/dtc/Makefile文件内容如下：
! E: M; g2 F2 i* n! A- W; Q$ l
; z' k3 _+ A: n* K2 Y

1. 示例代码23.2.1 scripts/dtc/Makefile文件代码段
   9 _( N' g5 ~; u  v
2. 4  hostprogs-$(CONFIG_DTC) := dtc
   . ^% T3 K4 C1 i0 [$ Y, i- U
3. 5  always       := $(hostprogs-y)
   
4. 6  
   
5. 7  dtc-objs := dtc.o flattree.o fstree.o data.o livetree.o treesource.o
   
6. 8           srcpos.o checks.o util.o
   
7. 9  dtc-objs += dtc-lexer.lex.o dtc-parser.tab.o
   8 Q1 G7 s- U" R* B3 X' Y. ^( l; C
8. ......

复制代码

/ P$ Z2 E- q' ^$ I. \可以看出，DTC工具依赖于dtc.c、flattree.c、fstree.c等文件，最终编译并链接出DTC这个主机文件。如果要编译DTS文件的话只需要进入到Linux源码根目录下，然后执行如下命令：
! G2 ^* L# ]& a/ `- V# R
5 ?! Y* _/ j! }! \4 N) smake all
或者：
/ Y. I. D$ Y5 N8 W) n& Mmake dtbs
“make all”命令是编译Linux源码中的所有东西，包括uImage，.ko驱动模块以及设备树，如果只是编译设备树的话建议使用“make dtbs”命令，“make dtbs”会编译选中的所有设备树文件。如果只要编译指定的某个设备树，比如ST官方编写的“stm32mp157d-ed1.dts”，可以输入如下命令：
# I2 w6 Q- {6 |' H8 T" V- R0 x8 ~  Omake stm32mp157d-ed1.dtb
) B5 R9 U! o5 \6 s结果如图23.2.1所示：

5 s7 Z$ \9 @6 N; b% Z

7 j$ j& x4 {9 ^9 z图23.2.1 编译单独的设备树
基于ARM架构的SOC有很多种，一种SOC又可以制作出很多款板子，每个板子都有一个对应的DTS文件，那么如何确定编译哪一个DTS文件呢？我们就以STM32MP1这款芯片对应的板子为例来看一下，打开arch/arm/boot/dts/Makefile，有如下内容：

1. 示例代码23.2.2 arch/arm/boot/dts/Makefile文件代码段
   
2. 981 dtb-$(CONFIG_ARCH_STM32) += \
   
3. 982     stm32f429-disco.dtb \
   $ @0 z* m. X  z* t% C& _
4. 983     stm32f469-disco.dtb \
   ) K6 f+ c! q: ^6 h3 f! Z; x& i
5. 984     stm32f746-disco.dtb \
   3 r4 ?7 Z; C) V  U1 p+ s8 p
6. 985     stm32f769-disco.dtb \
   0 m/ p/ l# k6 G! k& |
7. 986     stm32429i-eval.dtb \
   3 i. s' W" d8 h6 j! q; J
8. 987     stm32746g-eval.dtb \
   
9. 988     stm32h743i-eval.dtb \
   
10. 989     stm32h743i-disco.dtb \
    
11. 990     stm32mp157a-avenger96.dtb \
    
12. 991     stm32mp157a-dk1.dtb \
    & J9 a& E# r9 \  L/ ^$ U
13. 992     stm32mp157d-dk1.dtb \
    ! Z  i; u7 u# |; D/ @5 n  d
14. 993     stm32mp157c-dk2.dtb \
    $ A" `4 o6 n+ Q, w1 O5 Z% T
15. 994     stm32mp157f-dk2.dtb \
    1 X7 W: K( u" ?8 K6 C
16. 995     stm32mp157c-dk2-a7-examples.dtb \
    
17. 996     stm32mp157c-dk2-m4-examples.dtb \
    + J3 K! p5 ?- ~& l8 M
18. 997     stm32mp157f-dk2-a7-examples.dtb \
    - B3 x0 G( H" u2 }4 s, N2 R
19. 998     stm32mp157f-dk2-m4-examples.dtb \
    
20. 999     stm32mp157a-ed1.dtb \
    
21. 1000    stm32mp157c-ed1.dtb \
      c+ S& c. ~) [% x: o
22. 1001    stm32mp157d-ed1.dtb \
    
23. 1002    stm32mp157f-ed1.dtb \
    
24. 1003    stm32mp157a-ev1.dtb \
    / f' e0 V' J2 F
25. 1004    stm32mp157c-ev1.dtb \
    6 A. Q- u6 d8 i' E
26. 1005    stm32mp157d-ev1.dtb \
    
27. 1006    stm32mp157f-ev1.dtb \
    9 B2 h) x8 Z8 m# r2 ]
28. 1007    stm32mp157d-atk.dtb \
    4 Q3 m5 T) S8 u4 A; m9 |# ^! d$ A
29. 1008    stm32mp157c-ev1-a7-examples.dtb \
    7 ~: T1 |: @. @' d2 V) F# r* o9 I
30. 1009    stm32mp157c-ev1-m4-examples.dtb \
    
31. 1010    stm32mp157f-ev1-a7-examples.dtb \
    
32. 1011    stm32mp157f-ev1-m4-examples.dtb

复制代码

可以看出，当选中STM32MP1这个SOC以后(CONFIG_ARCH_STM32=y)，所有使用到STM32MP1这个SOC的板子对应的.dts文件都会被编译为.dtb。如果我们使用STM32MP1新做了一个板子，只需要新建一个此板子对应的.dts文件，然后将对应的.dtb文件名添加到dtb-$( CONFIG_ARCH_STM32)下，这样在编译设备树的时候就会将对应的.dts编译为二进制的.dtb文件。
示例代码23.2.2中1007行就是我们在给正点原子的开发板移植Linux系统的时候添加的设备树。关于.dtb文件怎么使用这里就不多说了，前面讲解TF-A移植、Uboot移植、Linux内核移植的时候已经无数次的提到如何使用.dtb文件了(uboot中使用bootz或bootm命令向Linux内核传递二进制设备树文件(.dtb))。
23.3 DTS语法
虽然我们基本上不会从头到尾重写一个.dts文件，大多时候是直接在SOC厂商提供的.dts文件上进行修改。但是DTS文件语法我们还是需要详细的学习一遍，因为后续工作中肯定需要修改.dts文件。大家不要看到要学习新的语法就觉得会很复杂，DTS语法非常的人性化，是一种ASCII文本文件，不管是阅读还是修改都很方便。
本节我们就以stm32mp157d-atk.dts这个文件为例来讲解一下DTS语法。关于设备树详细的语法规则请参考《Devicetree SpecificationV0.2.pdf》和《Power_ePAPR_APPROVED_v1.12.pdf》这两份文档，此两份文档已经放到了开发板光盘中，路径为：4、参考资料->Devicetree SpecificationV0.2.pdf，4、参考资料-> Power_ePAPR_APPROVED_v1.12.pdf
23.3.1 .dtsi头文件
和C语言一样，设备树也支持头文件，设备树的头文件扩展名为.dtsi。在stm32mp157d-atk.dts中有如下所示内容：
5 `+ e+ F1 [. T$ b( @+ u  c

1. 示例代码23.3.1.1 stm32mp157d-atk.dts文件代码段
   # U8 K% v. l# j; f$ N' E
2. 8  #include "stm32mp157.dtsi"
   & M4 c4 O* _3 o4 ~: N. l( I4 j
3. 9  #include "stm32mp15xd.dtsi"
   
4. 10 #include "stm32mp15-pinctrl.dtsi"
   9 e. ~% u! W7 \  n9 {! {' }
5. 11 #include "stm32mp15xxaa-pinctrl.dtsi"
   
6. 12 #include "stm32mp157-m4-srm.dtsi"
   
7. 13 #include "stm32mp157-m4-srm-pinctrl.dtsi"
   ! }  O7 A: @2 G- v& j
8. 14 #include "stm32mp157d-atk.dtsi"

复制代码

/ @' D  i1 D" f" L' p5 l$ ^# w第8~17行，使用“#include”来引用“stm32mp15*.dtsi”这些.dtsi头文件。
设备树里面除了可以通过“#include”来引用.dtsi文件，也可以引用.h文件头文件，大家打开stm32mp157f-dk2.dts这个文件，找到如下代码：

示例代码23.3.1.2 stm32mp157f-dk2.dts文件代码段
7 E- u3 d+ W4 T) M* |* {14 #include <dt-bindings/rtc/rtc-stm32.h>
.dts文件不仅可以应用C语言里面的.h头文件，甚至也可以引用.dts文件，打开stm32mp157c-ev1.dts这个文件，此文件中有如下内容：
" c% m& o4 y8 W/ `示例代码23.3.1.3 stm32mp157c-ev1.dts文件代码段
7 V( T4 }" i+ [5 D  M8 #include “stm32mp157c-ed1.dts”
可以看出，示例代码23.3.1.3中直接引用了.dts文件，因此在.dts设备树文件中，可以通过“#include”来引用.h、.dtsi和.dts文件。只是，我们在编写设备树头文件的时候最好选择.dtsi后缀。
一般.dtsi文件用于描述SOC的内部外设信息，比如CPU架构、主频、外设寄存器地址范围，比如UART、IIC等等。如果一个系列里有多个SOC就会把相同内部外设信息提炼到一个.dtsi文件里，这样为了减少代码的冗余。目前STM32MP1系列里有stm32mp151、stm32mp153和stm32mp157这三款SOC，其中151是外设最少的，153和157的外设是在151的基础上逐渐增加的。因此151就相当于“基类”，153和157是在151基础上得到的“派生类”。因此ST就把最基本的外设资源都写在stm32mp151.dtsi文件里。stm32mp151.dtsi就是描述151、153和157共有的外设信息的，内容如下：

1. 示例代码23.3.1.4 stm32mp151.dtsi文件代码段
   
2. 6   #include <dt-bindings/interrupt-controller/arm-gic.h>
   1 k$ m  m1 f7 F# X9 S, q
3. 7   #include <dt-bindings/clock/stm32mp1-clks.h>
   1 c6 r( A- r9 Z& h1 [- O
4. 8   #include <dt-bindings/gpio/gpio.h>
   
5. 9   #include <dt-bindings/reset/stm32mp1-resets.h>
   * ]7 S/ J9 n( W, G' D9 H3 s  s+ Z
6. 10  #include <dt-bindings/thermal/thermal.h>
   / m( w! j# a( D4 ]
7. 11  
   , O: F( R( E( {
8. 12  
   
9. 13  / {
   
10. 14      #address-cells = <1>;
    8 H4 l/ D* F. P
11. 15      #size-cells = <1>;
    ) q, ?' g; T8 b$ |* V
12. 16  
    
13. 17      cpus {
    
14. 18          #address-cells = <1>;
    & E/ M6 e; T) Q5 b2 {; R
15. 19          #size-cells = <0>;
    7 l5 T* P& y4 M5 r( h! M/ n) r
16. 20  
    8 b# Q" U+ c7 M0 ~  r2 u
17. 21          cpu0: cpu@0 {
    
18. 22              compatible = "arm,cortex-a7";
    
19. ......
    8 A& g9 i4 d4 Y. p$ M6 _
20. 29              nvmem-cell-names = "part_number";
    
21. 30              #cooling-cells = <2>;
    
22. 31          };
    
23. 32      };
    
24. 33  
    
25. 34      cpu0_opp_table: cpu0-opp-table {
    
26. 35          compatible = "operating-points-v2";
      i9 c, Y1 B$ n8 b2 C& ~3 W
27. 36          opp-shared;
    
28. 37      };
    
29. 38  };
    
30. ......
      G2 Y7 @8 p4 M/ K% W
31. 469         spi2: spi@4000b000 {
    
32. 470             #address-cells = <1>;
    
33. 471             #size-cells = <0>;
    
34. 472             compatible = "st,stm32h7-spi";
    / O& Y8 a* h  t2 P: r  I" S
35. 473             reg = <0x4000b000 0x400>;
    
36. 474             interrupts = <GIC_SPI 36 IRQ_TYPE_LEVEL_HIGH>;
    
37. 475             clocks = <&rcc SPI2_K>;
    
38. 476             resets = <&rcc SPI2_R>;
    
39. 477             dmas = <&dmamux1 39 0x400 0x01>,
    
40. 478                    <&dmamux1 40 0x400 0x01>;
    
41. 479             dma-names = "rx", "tx";
    ( H7 p! C5 N1 L, `
42. 480             power-domains = <&pd_core>;
    
43. 481             status = "disabled";
    ) n7 h0 S* u9 ]- c" b0 u
44. 482         };

复制代码

" N+ y, N& V% S2 m+ w4 c* I. i示例代码23.3.1.4中第1733行就是CPU0这个设备节点信息，这个节点信息描述了STM32MP151这颗SOC所使用的CPU信息，比如架构是cortex-A7,CPU的时钟等等,stm32mp151.dtsi文件中不仅仅描述了CPU0这个节点信息，STM32MP151这颗SOC所有的外设都描述的清清楚楚，比如SAI14, U(S)ART18，SDIO13等等，关于这些设备节点信息的具体内容我们后面具体章节里面再详细的讲解。
23.3.2 设备节点
设备树是采用树形结构来描述板子上的设备信息的文件，每个设备都是一个节点，叫做设备节点，每个节点都通过一些属性信息来描述节点信息，属性就是键—值对。以下文件是结合ST官方的设备树缩减出来设备树文件内容：

# W% V; n( i% Q

1. 示例代码23.3.2.1 设备树模板
   
2. 1   / {
   
3. 2       #address-cells = <1>;
   
4. 3       #size-cells = <1>;
   % W3 ?( Z3 k+ \
5. 4
   
6. 5       aliases {
   , m- c5 N+ f( E! d- e& N" _+ @4 K
7. 6            serial0 = &uart4;
   
8. 7       };
   
9. 8      
   4 h9 R) d) E8 D9 W2 f) l
10. 9       cpus {
    
11. 10          #address-cells = <1>;
    : {) p+ w- V7 h' _0 ?$ |8 A
12. 11          #size-cells = <0>;
      m/ p& F# K6 j+ z; t+ O# J
13. 12
    ! n1 R3 h$ r3 l. v. u$ m
14. 13          cpu0: cpu@0 {
    
15. 14              compatible = "arm,cortex-a7";
    
16. 15              device_type = "cpu";
    : `( H7 |; Q7 W2 w
17. 16              reg = <0>;
    
18. 17              clocks = <&scmi0_clk CK_SCMI0_MPU>;
    
19. 18              clock-names = "cpu";
    / v' H2 k; g$ m. ]
20. 19              operating-points-v2 = <&cpu0_opp_table>;
    
21. 20              nvmem-cells = <&part_number_otp>;
    / t' L7 ?9 `! C9 D' T2 P) J" k3 t
22. 21              nvmem-cell-names = "part_number";
    8 l0 Z/ s% ?9 Q" v6 v: ?  A
23. 22              #cooling-cells = <2>;
    $ k; q2 p, |8 g. P) `
24. 23          };
    ) t/ Q$ l4 J4 k* @* t' U2 @
25. 24      };
      M( H' X( i( s' A$ s
26. 25      
    
27. 26      soc {
    
28. 27          compatible = "simple-bus";
      s) H5 B4 g" c7 H& t/ b3 c. v( h
29. 28          #address-cells = <1>;
    
30. 29          #size-cells = <1>;
    
31. 30          interrupt-parent = <&intc>;
    
32. 31          ranges;
    % V+ }+ B  @4 _% D1 n: J
33. 32
    $ a/ S% m9 ^, y
34. 33          sram: sram@10000000 {
    
35. 34              compatible = "mmio-sram";
    
36. 35              reg = <0x10000000 0x60000>;
    : j1 D+ X3 m7 l( {5 y3 Z! z- H$ n2 D
37. 36              #address-cells = <1>;
    
38. 37              #size-cells = <1>;
      o8 w$ G8 U- M" g8 E" @
39. 38              ranges = <0 0x10000000 0x60000>;
    
40. 39          };
    6 k1 q7 J& m/ G- v; t) P4 R& {
41. 40      };
    5 Z9 ~7 m0 U# h1 v! o4 I. h
42. 41  };

复制代码

' k  p; @  e6 u8 C9 ]0 p% n1 y第1行，“/”是根节点，每个设备树文件只有一个根节点。细心的同学应该会发现，在内核移植设备树的时候，我们新建的stm32mp157d-atk.dts和stm32mp157d-atk.dtsi这两个文件都有一个“/”根节点，这样不会出错吗？不会的，因为这两个“/”根节点的内容会合并成一个根节点。
6 O9 l/ C, O3 Q! p. J第5、9和26行，aliases、cpus和soc是三个子节点，33行sram是soc的子节点。在设备树中节点命名格式如下：
7 ~! \/ l* P* A' t8 Z0 ?node-name@unit-address
. B( \  N/ {. E: {其中“node-name”是节点名字，为ASCII字符串，节点名字应该能够清晰的描述出节点的功能，比如“uart1”就表示这个节点是UART1外设。“unit-address”一般表示设备的地址或寄存器首地址，如果某个节点没有地址或者寄存器的话“unit-address”可以不要，比如“cpu@0”、“sram@10000000”、“soc”。
5 ?8 a5 L+ y) S$ c- i- D  o但是我们在示例代码23.3.2.1中我们看到的节点命名却如下所示：
cpu0:cpu@0
# N& f- p9 |5 X$ g1 t上述命令并不是“node-name@unit-address”这样的格式，而是用“：”隔开成了两部分，“：”前面是节点标签(label)，“：”后面的才是节点名字，格式如下所示：
label: node-name@unit-address
引入label的目的就是为了方便访问节点，可以直接通过&label来访问这个节点，比如通过&cpu0就可以访问“cpu@0”这个节点，而不需要输入完整的节点名字。再比如节点 “sram: sram@10000000”，节点label是sram，而节点名字就很长了，为“sram@10000000”。很明显通过&sram来访问“sram@10000000”这个节点要方便很多！
第13行，cpu0也是一个节点，只是cpu0是cpus的子节点。
每个节点都有不同属性，不同的属性又有不同的内容，属性都是键值对，值可以为空或任意的字节流。设备树源码中常用的几种数据形式如下所示：
1 |5 k3 g+ B" U( f  j  Z) x1、字符串
compatible = “arm,cortex-a7”;
1 A( a; S) d9 Y8 _( c& g上述代码设置compatible属性的值为字符串“arm,cortex-a7”。
6 p. S% k# L( D8 t2、32位无符号整数
: h2 }0 N* ?4 Q0 K. E' Z8 zreg = <0>;
上述代码设置reg属性的值为0，reg的值也可以设置为一组值，比如：
reg = <0 0x123456 100>;
3、字符串列表
属性值也可以为字符串列表，字符串和字符串之间采用“,”隔开，如下所示：
compatible = “st,stm32mp157d-atk”, “st,stm32mp157”;
$ z0 \) h; x) H$ j8 ^& l5 ]5 @上述代码设置属性compatible的值为“st,stm32mp157d-atk”和“st,stm32mp157”。
4 ^5 W8 K5 i$ y4 z1 ]23.3.3 标准属性
3 j6 r* w+ E5 ^: {9 L4 D9 V( u0 ]节点是由一堆的属性组成，节点都是具体的设备，不同的设备需要的属性不同，用户可以自定义属性。除了用户自定义属性，有很多属性是标准属性，Linux下的很多外设驱动都会使用这些标准属性，本节我们就来学习一下几个常用的标准属性。
% j* K8 s! D+ s, Z, d0 @1、compatible属性
9 k* ]  W+ D/ {$ ^4 Wcompatible属性也叫做“兼容性”属性，这是非常重要的一个属性！compatible属性的值是一个字符串列表，compatible属性用于将设备和驱动绑定起来。字符串列表用于选择设备所要使用的驱动程序，compatible属性的值格式如下所示：
“manufacturer,model”
/ Z6 r- G2 ^  U5 s其中manufacturer表示厂商，model一般是模块对应的驱动名字。比如stm32mp15xx-dkx.dtsi中有一个音频设备节点，这个节点的音频芯片采用的Cirrus Logic公司出品的cs42l51，compatible属性值如下：
, m( `& d* U/ l( X) ^7 ocompatible = “cirrus,cs42l51”;
属性值为“cirrus,cs42l51”，其中‘cirrus’表示厂商是Cirrus Logic，“cs42l51”表示驱动模块名字。compatible也可以多个属性值。比如：
$ I3 u: C1 Z3 c0 J9 s4 X+ D' _  xcompatible = “cirrus,my_cs42l51”,“cirrus,cs42l51”;
0 M5 H1 E3 I/ Y这样我们的设备就有两个属性值，这个设备首先使用第一个兼容值在Linux内核里面查找，看看能不能找到与之匹配的驱动文件，如果没有找到的话就使用第二个兼容值查，以此类推，直到查找完compatible属性中的所有值。
5 y8 P/ H4 y4 z一般驱动程序文件都会有一个OF匹配表，此OF匹配表保存着一些compatible值，如果设备节点的compatible属性值和OF匹配表中的任何一个值相等，那么就表示设备可以使用这个驱动。比如在文件cs42l51.c中有如下内容：
: B" n" X+ L; P5 M
! a2 Y, f- {: G& b

1. 示例代码23.3.3.1 cs42l51.c 文件代码段
   2 R5 o5 W8 M& A+ w7 P$ l7 e
2. 799 const struct of_device_id cs42l51_of_match[] = {
   
3. 800     { .compatible = "cirrus,cs42l51", },
   : s# X% K; h4 F3 Q: g! J
4. 801     { }
   
5. 802 };

复制代码

数组cs42l51_of_match就是cs42l51.c这个驱动文件的匹配表，此匹配表只有一个匹配值“cirrus,cs42l51”。如果在设备树中有哪个节点的compatible属性值与此相等，那么这个节点就会使用此驱动文件。

" [8 Q3 ~7 z: C; ]2、model属性
model属性值也是一个字符串，一般model属性描述开发板的名字或者设备模块信息，比如名字什么的，比如：
# ^( T! x( z0 G2 Smodel = “STMicroelectronics STM32MP157C-DK2 Discovery Board”;
3、status属性
7 ~1 b4 h, V7 B1 {& Z5 E4 r$ E# a+ Sstatus属性看名字就知道是和设备状态有关的，status属性值也是字符串，字符串是设备的状态信息，可选的状态如表23.3.3.1所示：
% A7 |" k+ c$ c5 M1 ]0 q; s值 描述
“okay” 表明设备是可操作的。
“disabled” 表明设备当前是不可操作的，但是在未来可以变为可操作的，比如热插拔设备插入以后。至于disabled的具体含义还要看设备的绑定文档。
9 e- x* v) r/ w# @  [“fail” 表明设备不可操作，设备检测到了一系列的错误，而且设备也不大可能变得可操作。
8 w+ J1 w' o! o8 L7 t# j7 d“fail-sss” 含义和“fail”相同，后面的sss部分是检测到的错误内容。
表23.3.3.1 status属性值表
7 k  F  A; s0 ^- ^4、#address-cells和#size-cells属性
8 g! l4 I! j* v; u/ T7 J这两个属性的值都是无符号32位整形，#address-cells和#size-cells这两个属性可以用在任何拥有子节点的设备中，用于描述子节点的地址信息。#address-cells属性值决定了子节点reg属性中地址信息所占用的字长(32位)，#size-cells属性值决定了子节点reg属性中长度信息所占的字长(32位)。#address-cells和#size-cells表明了子节点应该如何编写reg属性值，一般reg属性都是和地址有关的内容，和地址相关的信息有两种：起始地址和地址长度，reg属性的格式一为：
reg = <address1 length1 address2 length2 address3 length3……>
. G* ~6 X# w* f, n; _7 v每个“address length”组合表示一个地址范围，其中address是起始地址，length是地址长度，#address-cells表明address这个数据所占用的字长，#size-cells表明length这个数据所占用的字长，比如:

1 |4 o. c$ C" f2 _/ R) p% w. e

1. 示例代码23.3.3.2 #address-cells和#size-cells属性
   
2. 1   cpus {
   # p+ ~! W* L. l. U. S$ S, q
3. 2       #address-cells = <1>;
   
4. 3       #size-cells = <0>;
   , f5 K, f2 r* E( _3 Y
5. 4
   
6. 5       cpu0: cpu@0 {
   
7. 6           compatible = "arm,cortex-a7";
   % {9 F0 Y, ]0 {: c
8. 7           device_type = "cpu";
   7 V. `9 j; e1 {2 J6 [+ O
9. 8           reg = <0>;
   
10. 9           clocks = <&scmi0_clk CK_SCMI0_MPU>;
    ( M/ X1 H! Y6 x5 G: w
11. 10          clock-names = "cpu";
    / k* y; C; @0 I/ W7 }5 M2 V0 h7 ^
12. 11          operating-points-v2 = <&cpu0_opp_table>;
    + Z5 j3 }) M4 i
13. 12          nvmem-cells = <&part_number_otp>;
    * I1 |6 W/ @( N
14. 13          nvmem-cell-names = "part_number";
    
15. 14          #cooling-cells = <2>;
    , E' o/ O5 Q: B1 B2 o1 I4 V
16. 15      };
    
17. 16  };
    
18. 17  
    " s0 w/ _0 [, x" r" N( w/ R
19. 18  scmi_sram: sram@2ffff000 {
    
20. 19      compatible = "mmio-sram";
    
21. 20      reg = <0x2ffff000 0x1000>;
    . r$ q2 D1 C2 l/ O; c
22. 21      #address-cells = <1>;
    & A  Z. Y* V+ l$ L; _' Y6 H5 f
23. 22      #size-cells = <1>;
    
24. 23      ranges = <0 0x2ffff000 0x1000>;
    0 }, V$ k. a4 l2 ~2 h" n  X
25. 24
    
26. 25      scmi0_shm: scmi_shm@0 {
    
27. 26          reg = <0 0x80>;
    
28. 27      };
    
29. 28  };

复制代码

( i+ T! j/ Z4 H' h2 |第2，3行，节点cpus的#address-cells = <1>，#size-cells = <0>，说明cpus的子节点reg属性中起始地址所占用的字长为1，地址长度所占用的字长为0。
2 F2 L! ]# w8 G/ P& H* ~; G2 ]第8行，子节点cpu0: cpu@0的reg 属性值为 <0>，因为父节点设置了#address-cells = <1>，#size-cells = <0>，因此addres=0，没有length的值，相当于设置了起始地址，而没有设置地址长度。
, l. @; g: _, }( d% K' ^第21，22行，设置scmi_sram: sram@02ffff000节点#address-cells = <1>，#size-cells = <1>，说明scmi_sram: sram@02ffff000节点起始地址长度所占用的字长为1，地址长度所占用的字长也为1。
第26行，子节点scmi0_shm: scmi_shm@0的reg属性值为<0x0 0x80>，因为父节点设置了#address-cells = <1>，#size-cells = <1>，address= 0x0，length= 0x80，相当于设置了起始地址为0x0，地址长度为0x80。
5、reg属性
4 M; u" V& l+ L' n* h2 Sreg属性前面已经提到过了，reg属性的值一般是(address，length)对。reg属性一般用于描述设备地址空间资源信息或者设备地址信息，比如某个外设的寄存器地址范围信息，或者IIC器件的设备地址等，比如在stm32mp151.dtsi中有如下内容：
0 R, B4 x4 u* ~6 S0 K' D  J

1. 示例代码23.3.3.3 uart5节点信息
   
2. 576             uart5: serial@40011000 {
   ) h* u  I4 Q* ^) |/ X
3. 577                 compatible = "st,stm32h7-uart";
   
4. 578                 reg = <0x40011000 0x400>;
   
5. 579                 interrupts-extended = <&exti 31 IRQ_TYPE_LEVEL_HIGH>;
   : h4 ~9 L. a# ~: F+ v' z
6. 580                 clocks = <&rcc UART5_K>;
   
7. 581                 resets = <&rcc UART5_R>;
   ( \) d7 `9 L8 C& P: K
8. 582                 wakeup-source;
   
9. 583                 power-domains = <&pd_core>;
   " _3 y0 m& T0 N# l. m! H
10. 584                 dmas = <&dmamux1 65 0x400 0x5>,
    
11. 585                        <&dmamux1 66 0x400 0x1>;
    9 `( b) B4 D% H7 F! e% V
12. 586                 dma-names = "rx", "tx";
    : V7 t' F& U$ {9 O% L
13. 587                 status = "disabled";
    4 B4 l. K. K, P* M
14. 588             };

复制代码

$ C1 R5 H9 A( Q% \* [8 juart5节点描述了stm32mp1系列芯片的UART5相关信息，重点是第578行的reg属性。由于uart5的父节点“soc”设置了#address-cells = <1>、#size-cells = <1>，因此reg属性中address=0x40011000，length=0x400。查阅《STM32MP157参考手册》可知，stm32mp157芯片的UART5寄存器首地址为0x40011000，但是UART5的地址长度(范围)并没有0x400这么多，这里我们重点是获取UART5寄存器首地址。
6、ranges属性
ranges属性值可以为空或者按照(child-bus-address,parent-bus-address,length)格式编写的数字矩阵，ranges是一个地址映射/转换表，ranges属性每个项目由子地址、父地址和地址空间长度这三部分组成：
1 s+ w! p4 n# D6 B+ [& wchild-bus-address：子总线地址空间的物理地址，由父节点的#address-cells确定此物理地址所占用的字长。
parent-bus-address：父总线地址空间的物理地址，同样由父节点的#address-cells确定此物理地址所占用的字长。
# b1 y7 S: ?; b/ R3 Q& M- Elength：子地址空间的长度，由父节点的#size-cells确定此地址长度所占用的字长。
如果ranges属性值为空值，说明子地址空间和父地址空间完全相同，不需要进行地址转换，对于我们所使用的stm32mp157来说，子地址空间和父地址空间完全相同，因此会在stm32mp151.dtsi中找到大量的值为空的ranges属性，如下所示：

4 E' E7 t- J6 ], A  C! A7 b7 \( U

1. 示例代码23.3.3.4 stm32mp151.dtsi文件代码段
   
2. 192         soc {
   # d* v. l) t3 {0 @- U* H5 q
3. 193             compatible = "simple-bus";
   
4. 194             #address-cells = <1>;
   
5. 195             #size-cells = <1>;
   - r: j) X6 s( u: S3 Z/ M& D0 t
6. 196             interrupt-parent = <&intc>;
   
7. 197             ranges;
   7 n) M. [3 K2 N7 J
8. ......
   8 y8 \8 ^3 R1 Z8 x/ y% @
9. 1968        };

复制代码

第197行定义了ranges属性，但是ranges属性值为空。
* U0 ?% M; J5 R* eranges属性不为空的示例代码如下所示：
% q! x1 t* n; z
% w8 Y: t, `" |! E' J1 k  }' @( C9 O

1. 示例代码23.3.3.5 ranges属性不为空
   
2. 1   soc {
   ; A+ J; G, n$ s1 M
3. 2       compatible = "simple-bus";
   . Y: U# m$ K8 q
4. 3       #address-cells = <1>;
   * J2 k8 W5 f) Z: F* d+ b
5. 4       #size-cells = <1>;
   
6. 5       interrupt-parent = <&intc>;
   & }; `3 ]5 C) P  g; E( O
7. 6       ranges = <0 0x10000000 0x100000>;
   
8. 7
   
9. 8       sram: sram@10000000 {
   , k" h* X. q4 R. C. O! y7 i
10. 9           compatible = "mmio-sram";
    ; X$ R6 j- z3 B7 `
11. 10          reg = <0x0 0x60000>;
    & m: i: S! k* a5 P4 Q7 A
12. 11          #address-cells = <1>;
    2 W0 k/ [9 ^  v( W
13. 12          #size-cells = <1>;
    
14. 13          ranges = <0 0x10000000 0x60000>;
    4 W+ P" }+ ]; ~. m8 W
15. 14      };
    
16. 15  };

复制代码

$ l, P- D' v4 _第6行，节点soc定义的ranges属性，值为<0 0x10000000 0x100000>，此属性值指定了一个1024KB(0x100000)的地址范围，子地址空间的物理起始地址为0，父地址空间的物理起始地址为0x10000000。
2 P. ~$ J1 }% y) x( b第8行，sram是STM32MP1内部RAM节点，reg属性定义了sram设备寄存器的起始地址为0，寄存器长度为0x60000。经过地址转换，sram设备可以从0x10000000开始进行读写操作，0x10000000=0x0 + 0x10000000。
8 e$ J$ h( v0 P, o7 [" C; ?7、name属性
  y  R1 C6 w/ bname属性值为字符串，name属性用于记录节点名字，name属性已经被弃用，不推荐使用name属性，一些老的设备树文件可能会使用此属性。
8、device_type属性
device_type属性值为字符串，IEEE 1275会用到此属性，用于描述设备的FCode，但是设备树没有FCode，所以此属性也被抛弃了。此属性只能用于cpu节点或者memory节点。Stm32mp151.dtsi的cpu0节点用到了此属性，内容如下所示：

+ Y! `* c* M( i' z! z$ `2 P

1. 示例代码23.3.3.6 stm32mp151.dtsi文件代码段
   
2. 21          cpu0: cpu@0 {
   
3. 22              compatible = "arm,cortex-a7";
   9 ^' v- t- T, L+ i, ?$ j
4. 23              device_type = "cpu";
   
5. ......
   
6. 32              };

复制代码

关于标准属性就讲解这么多，其他的比如中断、IIC、SPI等使用的标准属性等到具体的例程再讲解。
* e* e9 z; x6 z+ p3 \7 z23.3.4 根节点compatible属性
* H& x$ R/ U" b. H( v% f6 _& C每个节点都有compatible属性，根节点“/”也不例外，在我们新建的stm32mp157d-atk.dts文件中根节点的compatible属性内容如下所示：
- t7 t1 B  r5 J2 E, B+ e( S0 o
- K' h, I* p5 J- B

1. 示例代码23.3.4.1 stm32mp157d-atk.dts根节点compatible属性
   
2. 16  / {
   - x( O( c, M) q, M0 M* @$ u
3. 17      model = "STMicroelectronics STM32MP157C-DK2 Discovery Board";
   
4. 18      compatible = "st,stm32mp157d-atk", "st,stm32mp157";
   0 Q7 |( R5 R8 C
5. ......
   
6. 41  };

复制代码

可以看出，compatible有两个值：“st,stm32mp157d-atk”和“st,stm32mp157”。前面我们说了，设备节点的compatible属性值是为了匹配Linux内核中的驱动程序，那么根节点中的compatible属性是为了做什么工作的？ 通过根节点的compatible属性可以知道我们所使用的设备，一般第一个值描述了所使用的硬件设备名字，比如这里使用的是“stm32mp157d-atk”这个设备，第二个值描述了设备所使用的SOC，比如这里使用的是“stm32mp157”这颗SOC。Linux内核会通过根节点的compoatible属性查看是否支持此设备，如果支持的话设备就会启动Linux内核。接下来我们就来学习一下Linux内核在使用设备树前后是如何判断是否支持某款设备的。
' e! p5 ]# t) e8 }) l4 W! e5 ~1、使用设备树之前设备匹配方法
( Q& Y8 P$ |* y. L在没有使用设备树以前，uboot会向Linux内核传递一个叫做machine id的值，machine id也就是设备ID，告诉Linux内核自己是个什么设备，看看Linux内核是否支持。Linux内核是支持很多设备的，针对每一个设备(板子)，Linux内核都用MACHINE_START和MACHINE_END来定义一个machine_desc结构体来描述这个设备，比如在文件arch/arm/mach-imx/mach-mx35_3ds.c中有如下定义：

$ T9 h1 f7 d) A) S. s0 ]9 n5 e; \

1. 示例代码23.3.4.2 MX35_3DS设备
   
2. 506 MACHINE_START(MX35_3DS, "Freescale MX35PDK")
   
3. 507     /* Maintainer: Freescale Semiconductor, Inc */
   
4. 508     .atag_offset = 0x100,
   
5. 509     .map_io = mx35_map_io,
   
6. 510     .init_early = imx35_init_early,
   
7. 511     .init_irq = mx35_init_irq,
   & l+ F! C1 _/ U& _8 g
8. 512     .init_time  = mx35pdk_timer_init,
   
9. 513     .init_machine = mx35_3ds_init,
   
10. 514     .reserve = mx35_3ds_reserve,
    
11. 515     .restart    = mxc_restart,
    4 r/ m- F" S! w! d3 b( c2 L
12. 516 MACHINE_END

复制代码

* l& ]# a- [& P上述代码就是定义了“Freescale MX35PDK”这个设备，其中MACHINE_START和MACHINE_END定义在文件arch/arm/include/asm/mach/arch.h中，内容如下：
" X* A+ z$ V* e3 Y6 X

1. 示例代码23.3.4.3 MACHINE_START和MACHINE_END宏定义
   
2. 81 #define MACHINE_START(_type,_name)           \
   
3. 82 static const struct machine_desc __mach_desc_##_type \
   
4. 83  __used                          \
   
5. 84  __attribute__((__section__(".arch.info.init"))) = { \
   
6. 85  .nr     = MACH_TYPE_##_type,        \
   * b4 g3 a7 Z0 T' }5 a
7. 86  .name       = _name,
   
8. 87
   
9. 88 #define MACHINE_END              \
   " I& |0 \7 y7 {( t, K  C  G$ u
10. 89

复制代码

) k; W/ q$ K, _2 u根据MACHINE_START和MACHINE_END的宏定义，将示例代码23.3.4.2展开后如下所示：

1. 示例代码23.3.4.3 展开以后
   $ A/ N/ I" N: U  Z
2. 1  static const struct machine_desc __mach_desc_MX35_3DS            \
   
3. 2           __used                                                                                          \
   
4. 3           __attribute__((__section__(".arch.info.init"))) = {                 
   
5. 4           .nr     = MACH_TYPE_MX35_3DS,      
   6 b. _! m) x: H$ V7 ~9 ?& E" A7 i
6. 5           .name       = "Freescale MX35PDK",
   % G! O4 Q! a8 E6 S" Y9 R5 B& G* Z$ `
7. 6           /* Maintainer: Freescale Semiconductor, Inc */
   
8. 7           .atag_offset = 0x100,
   & v+ l1 z- k/ e4 w
9. 8           .map_io = mx35_map_io,
   
10. 9           .init_early = imx35_init_early,
    ' D; d% \$ f0 S* p9 u5 ~( z( r7 s
11. 10                  .init_irq = mx35_init_irq,
    9 K4 @( Q$ L8 ^
12. 11          .init_time  = mx35pdk_timer_init,
    " E' Z. D# V; j3 i1 |  d2 U: ^- _
13. 12          .init_machine = mx35_3ds_init,
    : J( Q/ F7 m) q* S: s  U8 r
14. 13          .reserve = mx35_3ds_reserve,
    
15. 14          .restart    = mxc_restart,
      b! ]% b6 I  b# \" X
16. 15 };

复制代码

8 n& \% ^" p( S从示例代码23.3.4.3中可以看出，这里定义了一个machine_desc类型的结构体变量__mach_desc_MX35_3DS，这个变量存储在“.arch.info.init”段中。第4行的MACH_TYPE_MX35_3DS就是“Freescale MX35PDK”这个板子的machine id。MACH_TYPE_MX35_3DS定义在文件include/generated/mach-types.h中，此文件定义了大量的machine id，内容如下所示：
/ @4 {9 `2 p# _2 u# I6 _

1. 示例代码23.3.4.3 mach-types.h文件中的machine id
   . {; n) H9 B1 L& _- u
2. 10           #define MACH_TYPE_EBSA110                   0
   ! o% W' `  f  d7 ^; h! A2 r' t- ^
3. 11           #define MACH_TYPE_RISCPC                       1
   
4. 12    #define MACH_TYPE_NEXUSPCI                    3
   
5. ......
   
6. 1629 #define MACH_TYPE_MX35_3DS                    1645
   
7. ......
   
8. 5053 #define MACH_TYPE_OMAP3_MRC3D                5114

复制代码

第1629行就是MACH_TYPE_MX35_3DS的值，为1645。
前面说了，uboot会给Linux内核传递machine id这个参数，Linux内核会检查这个machine id，其实就是将machine id与示例代码23.3.4.3中的这些MACH_TYPE_XXX宏进行对比，看看有没有相等的，如果相等的话就表示Linux内核支持这个设备，如果不支持的话那么这个设备就没法启动Linux内核。
2、使用设备树以后的设备匹配方法
" d" n2 E  k, d0 G. X# d* ~% p当Linux内核引入设备树以后就不再使用MACHINE_START了，而是换为了DT_MACHINE_START。DT_MACHINE_START也定义在文件arch/arm/include/asm/mach/arch.h 里面，定义如下：
; A; p/ j) ?3 a5 \6 c4 u

1. 示例代码23.3.4.4 DT_MACHINE_START宏
   
2. 91 #define DT_MACHINE_START(_name, _namestr)        \
   
3. 92 static const struct machine_desc __mach_desc_##_name \
   6 N, r) o. i" g, J
4. 93  __used                          \
   / [7 Z: L/ {: J0 ]- c
5. 94  __attribute__((__section__(".arch.info.init"))) = { \
   " c3 ~. @2 I/ i) Y# e, L
6. 95  .nr     = ~0,               \
   1 v, E: P& j- L" d1 @2 f
7. 96  .name       = _namestr,
   
8. 97
   6 n. O7 X  U; D# w3 v
9. 98 #endif

复制代码

可以看出，DT_MACHINE_START和MACHINE_START基本相同，只是.nr的设置不同，在DT_MACHINE_START里面直接将.nr设置为~0。说明引入设备树以后不会再根据machine id来检查Linux内核是否支持某个设备了。
( o. q8 ~+ {- t$ ^% p5 z. k打开文件arch/arm/mach-stm32/board-dt.c，有如下所示内容：

4 `5 _1 h  Q  M% W& r$ A

1. 示例代码23.3.4.5 stm32mp157设备
   ; P: C% s' c) m
2. 14  static const char *const stm32_compat[] __initconst = {
   
3. 15      "st,stm32f429",
   ) N6 X1 D. W" t# [$ ^* _
4. 16      "st,stm32f469",
   # J4 R/ P  v: L+ r' O: t! J; X& L
5. 17      "st,stm32f746",
   & c% c+ U, u2 [( K" \; U4 _% l* Z) n, {
6. 18      "st,stm32f769",
   
7. 19      "st,stm32h743",
   
8. 20      "st,stm32mp151",
   
9. 21      "st,stm32mp153",
   & B4 u  \& U6 Y; U' Q0 N' n- E
10. 22      "st,stm32mp157",
    
11. 23      NULL
    
12. 24  };
    / _) D& x/ d' D9 q+ t" B
13. 25
    4 j+ o* \/ u% O/ A$ _
14. 26  DT_MACHINE_START(STM32DT, "STM32 (Device Tree Support)")
    ! [& I& `8 {  q5 T! g! B, `
15. 27      .dt_compat = stm32_compat,
    " S8 _0 [: p' V- Q# C- b" Y; ]5 }3 G3 x
16. 28  #ifdef CONFIG_ARM_SINGLE_ARMV7M
    
17. 29      .restart = armv7m_restart,
    ( l% o+ w- v- y3 a* ]7 f) {
18. 30  #endif
    
19. 31  MACHINE_END

复制代码

* U: x; m8 @. E* T5 e( V3 |machine_desc结构体中有个.dt_compat成员变量，此成员变量保存着本设备兼容属性，示例代码23.3.4.5中设置.dt_compat为stm32_compat，此表里面含有Linux内核所支持的soc兼容值。只要某个设备(板子)根节点“/”的compatible属性值与stm32_compat表中的任何一个值相等，那么就表示Linux内核支持此设备。stm32mp157d-atk.dts中根节点的compatible属性值如下：
compatible = “st,stm32mp157d-atk”, “st,stm32mp157”;
其中“st,stm32mp157”与stm32_compat中的“st,stm32mp157”匹配，因此正点原子STM32MP157开发板可以正常启动Linux内核。
接下来我们简单看一下Linux内核是如何根据设备树根节点的compatible属性来匹配出对应的machine_desc，Linux内核调用start_kernel函数来启动内核，start_kernel函数会调用setup_arch函数来匹配machine_desc，setup_arch函数定义在文件arch/arm/kernel/setup.c中，函数内容如下(有缩减)：

1. 示例代码23.3.4.6 setup_arch函数内容
   ! }0 o: H  h" J* L2 c( I
2. 1076    void __init setup_arch(char **cmdline_p)
   
3. 1077    {
   
4. 1078        const struct machine_desc *mdesc;
   
5. 1079
   
6. 1080        setup_processor();
   
7. 1081        mdesc = setup_machine_fdt(__atags_pointer);
   
8. 1082        if (!mdesc)
   
9. 1083            mdesc = setup_machine_tags(__atags_pointer,
   * h- J# i. g6 H
10. __machine_arch_type);
    
11. ......
    . V3 E/ k% A5 \5 z1 b" ^( M* F
12. 1094        machine_desc = mdesc;
    7 G# T7 J8 K$ [8 h8 N" z
13. 1095        machine_name = mdesc->name;
    2 W1 o7 N3 A8 P- |: Q3 x
14. ......
    - B! Y6 ^+ E5 w5 E3 e
15. 1174    }

复制代码

第1081行，调用setup_machine_fdt函数来获取匹配的machine_desc，参数就是atags的首地址，也就是uboot传递给Linux内核的dtb文件首地址，setup_machine_fdt函数的返回值就是找到的最匹配的machine_desc。
函数setup_machine_fdt定义在文件arch/arm/kernel/devtree.c中，内容如下(有缩减)：

1. 示例代码23.3.4.7 setup_machine_fdt函数内容
   
2. 211 const struct machine_desc * __init setup_machine_fdt(unsigned int dt_phys)
   / J, C8 j. E9 v( E. R: k/ N: C5 d
3. 212 {
   2 _% i9 \$ p1 M0 }2 `( ^$ j
4. 213     const struct machine_desc *mdesc, *mdesc_best = NULL;
   # e) d6 j$ s, f3 {, E8 Z' u9 @
5. ......
   
6. 224     if (!dt_phys || !early_init_dt_verify(phys_to_virt(dt_phys)))
   
7. 225         return NULL;
   * Q7 I7 `+ O' f1 m5 {8 O$ c: r# l
8. 226
   
9. 227     mdesc = of_flat_dt_match_machine(mdesc_best,
   6 N8 K0 ]! I' O
10.                            arch_get_next_mach);
    & j5 r: p9 O) Y( }0 h: G8 z
11. ......
    
12. 256     __machine_arch_type = mdesc->nr;
    0 r' C( S. C" R+ E
13. 257
    
14. 258     return mdesc;
    
15. 259 }

复制代码

& c5 q4 [8 h1 f% Y3 K第227行，调用函数of_flat_dt_match_machine来获取匹配的machine_desc，参数mdesc_best是默认的machine_desc，参数arch_get_next_mach是个函数，此函数定义在定义在arch/arm/kernel/devtree.c文件中。找到匹配的machine_desc的过程就是用设备树根节点的compatible属性值和Linux内核中保存的所以machine_desc结构的. dt_compat中的值比较，看看那个相等，如果相等的话就表示找到匹配的machine_desc，arch_get_next_mach函数的工作就是获取Linux内核中下一个machine_desc结构体。
最后再来看一下of_flat_dt_match_machine函数，此函数定义在文件drivers/of/fdt.c中，内容如下(有缩减)：
8 f/ U" j& `7 X0 N/ E) H3 h
% W$ \# j, D+ k* j

1. 示例代码23.3.4.8 of_flat_dt_match_machine函数内容
   
2. 815     const void * __init of_flat_dt_match_machine(const void *default_match,
   8 X* K* F2 I; G$ w) h" _
3. 816             const void * (*get_next_compat)(const char * const**))
   , g& C0 d' h' ~4 M  V% U" t" [
4. 817     {
   % }1 [" w6 y  E
5. 818         const void *data = NULL;
   % f9 s. D3 B5 R  L3 [
6. 819         const void *best_data = default_match;
   
7. 820         const char *const *compat;
   
8. 821         unsigned long dt_root;
   0 S$ S0 d: i& G! a, t3 ]7 ^
9. 822         unsigned int best_score = ~1, score = 0;
   - D) X& n# @5 h+ X+ i
10. 823
    
11. 824         dt_root = of_get_flat_dt_root();
    8 A. a# S! C. e6 A
12. 825         while ((data = get_next_compat(&compat))) {
    " E0 h/ s$ q$ b$ S& n, E
13. 826             score = of_flat_dt_match(dt_root, compat);
    ( y3 d; x0 L; x5 ?5 s
14. 827             if (score > 0 && score < best_score) {
    " n& U5 Q, q; o- h
15. 828                 best_data = data;
    
16. 829                 best_score = score;
    ) J. m, v' f" v, p
17. 830             }
    
18. 831         }
    
19. .....
    6 C% q+ A' ]  E) k2 P
20. 850         pr_info("Machine model: %s\n", of_flat_dt_get_machine_name());
    
21. 851
    0 ]+ }$ l1 f# ~0 {
22. 852         return best_data;
    
23. 853     }

复制代码

第824行，通过函数of_get_flat_dt_root获取设备树根节点。
4 y6 q5 u7 R2 n' }7 y第825~831行，此循环就是查找匹配的machine_desc过程，第826行的of_flat_dt_match函数会将根节点compatible属性的值和每个machine_desc结构体中. dt_compat的值进行比较，直至找到匹配的那个machine_desc。
  n8 P: h3 s6 j+ \总结一下，Linux内核通过根节点compatible属性找到对应的设备的函数调用过程，如图23.3.4.2所示：



- e  s, i1 e# L; j图23.3.4.2 查找匹配设备的过程
0 q  {3 v- k2 }0 k: S& {23.3.5 向节点追加或修改内容
/ D/ M7 J, ~2 q+ u& C. R0 f产品开发过程中可能面临着频繁的需求更改，比如第一版硬件上有一个IIC接口的六轴芯片MPU6050，第二版硬件又要把这个MPU6050更换为MPU9250等。一旦硬件修改了，我们就要同步的修改设备树文件，毕竟设备树是描述板子硬件信息的文件。假设现在有个六轴芯片fxls8471，fxls8471要接到STM32MP157D-ATK开发板的I2C1接口上，那么相当于需要在i2c1这个节点上添加一个fxls8471子节点。先看一下I2C1接口对应的节点，打开文件stm32mp151.dtsi文件，找到如下所示内容：
0 y$ l+ B7 j3 e1 j, L

1. 示例代码23.3.5.1 i2c1节点
   8 K+ o; Y& ]2 f. |" C: F, N
2. 590     i2c1: i2c@40012000 {
   " N" O) p' g0 h; ]4 @9 o; S
3. 591         compatible = "st,stm32mp15-i2c";
   4 b1 Z. L1 k1 N; H% P& r) m7 O/ I
4. 592         reg = <0x40012000 0x400>;
   
5. 593         interrupt-names = "event", "error";
   + S9 Y& _6 Q/ f' W
6. 594         interrupts-extended = <&exti 21 IRQ_TYPE_LEVEL_HIGH>,
   : k' |# |  W, [1 Z
7. 595                       <&intc GIC_SPI 32 IRQ_TYPE_LEVEL_HIGH>;
   
8. 596         clocks = <&rcc I2C1_K>;
   
9. 597         resets = <&rcc I2C1_R>;
   ; R& @; W* i7 m6 d) m5 P
10. 598         #address-cells = <1>;
    
11. 599         #size-cells = <0>;
    # ^3 E# `# \, P! s$ {
12. 600         dmas = <&dmamux1 33 0x400 0x80000001>,
    ) [+ P/ }: s: D4 F+ O4 c' c, Y
13. 601                <&dmamux1 34 0x400 0x80000001>;
    
14. 602         dma-names = "rx", "tx";
    8 [* l% {$ }( |" G$ W
15. 603         power-domains = <&pd_core>;
      n$ O9 @- i* ?( ?
16. 604         st,syscfg-fmp = <&syscfg 0x4 0x1>;
    
17. 605         wakeup-source;
    
18. 606         status = "disabled";
    ) Q- }& _( x4 ^8 ]  p6 D! V
19. 607     };

复制代码

' K, p. g- i: X' c& g示例代码23.3.5.1就是STM32MP157的I2C1节点，现在要在i2c1节点下创建一个子节点，这个子节点就是fxls8471，最简单的方法就是在i2c1下直接添加一个名为fxls8471的子节点，如下所示：

1. 示例代码23.3.5.2 添加 fxls8471子节点
   
2. 590     i2c1: i2c@40012000 {
   
3. 591         compatible = "st,stm32mp15-i2c";
   
4. 592         reg = <0x40012000 0x400>;
   
5. 593         interrupt-names = "event", "error";
   
6. 594         interrupts-extended = <&exti 21 IRQ_TYPE_LEVEL_HIGH>,
   
7. 595                       <&intc GIC_SPI 32 IRQ_TYPE_LEVEL_HIGH>;
     N5 W+ N7 s7 R9 U/ @  w! w
8. 596         clocks = <&rcc I2C1_K>;
   
9. 597         resets = <&rcc I2C1_R>;
   : p) a" N! F2 `  l+ Q
10. 598         #address-cells = <1>;
    
11. 599         #size-cells = <0>;
    
12. 600         dmas = <&dmamux1 33 0x400 0x80000001>,
    
13. 601                <&dmamux1 34 0x400 0x80000001>;
    
14. 602         dma-names = "rx", "tx";
    ' n$ Q  H1 m5 f0 j' @- y
15. 603         power-domains = <&pd_core>;
    6 O6 n9 g+ B  v' F
16. 604         st,syscfg-fmp = <&syscfg 0x4 0x1>;
    
17. 605         wakeup-source;
    
18. 606         status = "disabled";
    
19. 607         //fxls8471子节点
    : L+ t: A, E7 k3 H$ c' n3 h1 X7 |
20. 608         fxls8471@1e {
    . K: A3 Y$ \. i7 m5 H
21. 609             compatible = "fsl,fxls8471";
    
22. 610                reg = <0x1e>;
    
23. 611            };
    
24. 612     };

复制代码

第608~611行就是添加的fxls8471这个芯片对应的子节点。但是这样会有个问题！i2c1节点是定义在stm32mp151.dtsi文件中的，而stm32mp151.dtsi是共有的设备树头文件，其他所有使用到stm32mp1这颗SOC的板子都会引用stm32mp151.dtsi这个文件。直接在i2c1节点中添加fxls8471就相当于在其他的所有板子上都添加了fxls8471这个设备，但是其他的板子并没有这个设备啊！因此，按照示例代码23.3.5.2这样写肯定是不行的。
这里就要引入另外一个内容，那就是如何向节点追加数据，我们现在要解决的就是如何向i2c1节点追加一个名为fxls8471的子节点，而且不能影响到其他使用到stm32mp1的板子。STM32MP157D-ATK开发板使用的设备树文件为stm32mp157d-atk.dts和stm32mp157d-atk.dtsi，因此我们需要在stm32mp157d-atk.dts文件中完成数据追加的内容，方式如下：
+ p7 j' x% C6 e: I
' r8 F$ {0 q8 }5 F( V, H

1. 示例代码23.3.5.3 节点追加数据方法
   
2. 1 &i2c1 {
   
3. 2         /* 要追加或修改的内容 */
   
4. 3 };

复制代码

) ^% H- R, ^+ Y第1行，&i2c1表示要访问i2c1这个label所对应的节点，也就是stm32mp151.dtsi中的“i2c1: i2c@40012000”。
第2行，花括号内就是要向i2c1这个节点添加的内容，包括修改某些属性的值。
- h0 B4 D& k' @  o打开stm32mp157d-atk.dts，在根节点后添加以下代码：
9 T" j, ~  v1 a
2 O' S- l1 f* `. D) ]

1. 示例代码23.3.5.4 向i2c1节点追加数据
   ! r) _; \5 O7 f
2. 1   &i2c1 {
   
3. 2       pinctrl-names = "default", "sleep";
   # @; U/ S2 Y; a' l
4. 3       pinctrl-0 = <&i2c1_pins_b>;
   
5. 4       pinctrl-1 = <&i2c1_pins_sleep_b>;
   
6. 5       status = "okay";
   & N! ?8 ?, E3 r2 S1 Y# n) p2 d) M
7. 6       clock-frequency = <100000>;
   
8. 7      
   9 y8 K8 H' k* o  r. A1 O3 Z
9. 8       fxls8471@1e {
   ' a# T0 N& }% A' A9 D& R% o' u( m
10. 9           compatible = "fsl,fxls8471";
    
11. 10          reg = <0x1e>;
    
12. 11          position = <0>;
    
13. 12          interrupt-parent = <&gpioh>;
    
14. 13          interrupts = <6 IRQ_TYPE_EDGE_FALLING>;
    & y& j/ x4 t9 o7 ~. s  U6 i
15. 14      };  
    
16. 15  };

复制代码

& u' Z# M+ v: z示例代码23.3.5.4就是向i2c1节点添加/修改数据，比如第5行将status属性的值由原来的disabled改为okay。第6行的属性“clock-frequency”表示i2c1时钟为100KHz。“clock-frequency”就是新添加的属性。
第8~14行，i2c1子节点fxls8471，表示I2C1上连接的fxls8471，“fxls8471”子节点里面描述了fxls8471这颗芯片的相关信息。
( z% f0 _% \0 N) _因为示例代码23.3.5.4中的内容是stm32mp157d-atk.dts这个文件内的，所以不会对使用STM32MP157这颗SOC的其他板子造成任何影响。这个就是向节点追加或修改内容，重点就是通过&label来访问节点，然后直接在里面编写要追加或者修改的内容。
1 q& S: c. B( T) `) R% B
  U  A& @1 ?4 T# o9 f$ Z9 Q2 F23.4 创建小型模板设备树
上一节已经对DTS的语法做了比较详细的讲解，本节我们就根据前面讲解的语法，从头到尾编写一个小型的设备树文件。当然了，这个小型设备树没有实际的意义，做这个的目的是为了掌握设备树的语法。在实际产品开发中，我们是不需要完完全全的重写一个.dts设备树文件，一般都是使用SOC厂商提供好的.dts文件，我们只需要在上面根据自己的实际情况做相应的修改即可。在编写设备树之前要先定义一个设备，我们就以STM32MP157这个SOC为例，我们需要在设备树里面描述的内容如下：
; L. d. W4 T" B2 J  U: o5 k: e、这个芯片是由两个Cortex-A7架构的32位CPU和Cortex-M4组成。
% c4 [6 w3 [% S& Y" s  d、STM32MP157内部sram，起始地址为0x10000000，大小为384KB(0x60000)。
、STM32MP157内部timers6，起始地址为0x40004000，大小为25.6KB(0x400)。
+ C6 V- i- }/ ~" ?( ]8 s$ d. P6 l、STM32MP157内部spi2，起始地址为0x4000b000，大小为25.6KB(0x400)。
) Z; [& S: s3 ~4 ]! T9 c, t、STM32MP157内部usart2，起始地址为0x4000e000，大小为25.6KB(0x400)。
、STM32MP157内部i2c1，起始地址为0x40012000，大小为25.6KB(0x400)。
为了简单起见，我们在设备树里面就实现这些内容即可，首先，搭建一个仅含有根节点“/”的基础的框架，新建一个名为myfirst.dts文件，在里面输入如下所示内容：
7 i0 A7 f0 o- a9 q4 G/ d8 N+ P
8 d; u6 _, t! @& w1 Q

1. 示例代码23.4.1 设备树基础框架
   
2. 1   / {
   " D- i1 w; L  d. w  x) o
3. 2       compatible = "st,stm32mp157d-atk", "st,stm32mp157";
   
4. 3   }；

复制代码

8 {7 c2 I* z* x/ k设备树框架很简单，就一个根节点“/”，根节点里面只有一个compatible属性。我们就在这个基础框架上面将上面列出的内容一点点添加进来。
; t$ A) C5 @! R% v1、添加cpus节点
首先添加CPU节点，STM32MP157采用Cortex-A7架构，先添加一个cpus节点，在cpus节点下添加cpu0子节点和cpu1子节点，完成以后如下所示：
# l; q$ _- I" ^  x) M" Y
: C* c5 X4 C! r3 Y( [# p3 t; r

1. 示例代码23.4.2 添加cpus节点
   
2. 1   / {
   , _: x0 b, T9 L1 Z
3. 2       compatible = "st,stm32mp157d-atk", "st,stm32mp157";
   + u0 r. [$ R. G6 @6 m" J
4. 3       /* cpus节点 */
   # K" R, l/ k8 I) c1 h# C" O
5. 4       cpus {
   
6. 5           #address-cells = <1>;
   
7. 6           #size-cells = <0>;
   
8. 7  
   ; {1 U5 h, I' H& X" w% ?9 u* A; T
9. 8           /* CPU0节点 */
   $ g5 K/ V8 m+ O6 Z" G
10. 9           cpu0: cpu@0 {
    
11. 10              compatible = "arm,cortex-a7";
    ! j" p6 l9 p% g  p
12. 11              device_type = "cpu";
    - ]* H! g$ I1 `( J! f0 J0 o4 l
13. 12              reg = <0>;
    
14. 13          };
    3 o. ~$ }4 \8 H! d7 h/ _, a; h
15. 14          /* CPU1节点 */
    
16. 15          cpu1: cpu@1 {
    5 E: t, Q8 J: T* |# S% q
17. 16              compatible = "arm,cortex-a7";
    - M, w' i/ ?3 t+ y$ P2 M. j: R+ L
18. 17              device_type = "cpu";
    , c+ [" l5 M6 Z+ G0 M* w# a5 m6 G- N/ C
19. 18              reg = <1>;
    / d  i9 L) k+ k5 Q6 U
20. 19          };
    * A. D& `! i$ Z- N! x
21. 20      };
    
22. 21  }；

复制代码

第4~20行，cpus节点，此节点用于描述SOC内部的所有CPU，因为STM32MP157有两个CPU，所以在cpus下添加两个子节点分别为cpu0和cpu1。
2、添加soc节点
像uart，iic控制器等等这些都属于SOC内部外设，因此一般会创建一个叫做soc的父节点来管理这些SOC内部外设的子节点，添加soc节点以后的myfirst.dts文件内容如下所示：
6 n. y, B/ @# l. U' J
# c6 F  c7 R: T5 ^! F2 [9 C/ w

1. 示例代码23.4.3 添加soc节点
   
2. 1   / {
   
3. 2       compatible = "st,stm32mp157d-atk", "st,stm32mp157";
   
4. 3       /* cpus节点  */
   4 W. N* D6 e" U
5. 4       cpus {
   
6. 5           #address-cells = <1>;
   
7. 6           #size-cells = <0>;
   
8. 7
   . f- ]7 c; A8 z% Y& r% g
9. 8           /* CPU0节点 */
   " [) Y% ?/ o) F, l. s. s) |
10. 9           cpu0: cpu@0 {
    % T. i& D! y2 E0 ?" b0 x4 o
11. 10              compatible = "arm,cortex-a7";
    + p4 C% _! G9 Y9 b) V
12. 11              device_type = "cpu";
    4 H* ^5 T) C$ D+ q: q
13. 12              reg = <0>;
    & b/ c3 n: ]( V- H  Z5 M
14. 13          };
    $ o, j* b- |. K" S$ W' j
15. 14          /* CPU1节点 */
    
16. 15          cpu1: cpu@1 {
    
17. 16              compatible = "arm,cortex-a7";
    
18. 17              device_type = "cpu";
    3 {- H3 m: K5 |. m( u
19. 18              reg = <1>;
    8 @2 Z/ I% d, B, n
20. 19          };
    
21. 20      };
    ) w: n2 W+ [! L; q
22. 21      /* soc节点 */
    
23. 22      soc {
    3 R0 i) Z( R% E1 v  h& c# B
24. 23          compatible = "simple-bus";
      @1 t. s; L9 q' U
25. 24          #address-cells = <1>;
    
26. 25          #size-cells = <1>;
    5 s# f: |/ f2 {
27. 26          ranges;
      p# r( f+ g( L
28. 27      }；
    
29. 28  }；

复制代码

第22~27行，soc节点，soc节点设置#address-cells = <1>，#size-cells = <1>，这样soc子节点的reg属性中起始地占用一个字长，地址空间长度也占用一个字长。
% R; X# m# T+ a3 u- z" e第26行，ranges属性，ranges属性为空，说明子空间和父空间地址范围相同。
3、添加sram节点
9 G0 _2 m/ |4 e8 q& d8 @% R; i我们继续添加sram节点，sram是STM32MP157内部RAM，M4内核会用到SRAM4。sram是soc节点的子节点。sram起始地址为0x10000000，大小为384KB，添加sram节点以后myfirst.dts文件内容如下所示：
/ b( p1 c' H+ _" T) g  T
- w: G; @9 V4 O$ G

1. 示例代码23.4.4 添加sram节点
   
2. 1   / {
   
3. 2       compatible = "st,stm32mp157d-atk", "st,stm32mp157";
   ( `% Y$ O" a* h# }$ b" G" y
4. 3       /* cpus节点 */
   4 A* ]. c1 i: M4 ~' R3 y: X
5. 4       cpus {
   $ o2 h* ^+ [( A
6. 5           #address-cells = <1>;
   4 T& G) j0 g, d/ S% z4 O
7. 6           #size-cells = <0>;
   
8. 7
   
9. 8           /* CPU0节点 */
   $ A% A% U* R7 }  _( P6 J# e
10. 9           cpu0: cpu@0 {
    ; B9 o6 y4 ^3 c* X7 j. f
11. 10              compatible = "arm,cortex-a7";
    
12. 11              device_type = "cpu";
    
13. 12              reg = <0>;
    # ?5 {" J5 Y+ }: Y' y& x
14. 13          };
    + Q! x" i, [, V/ s/ w/ _
15. 14          /* CPU1节点 */
    ! r& G4 h$ g  K+ E; e
16. 15          cpu1: cpu@1 {
    8 }: ]! u% @' p* T
17. 16              compatible = "arm,cortex-a7";
    : u& u: p- Y3 A* c/ b
18. 17              device_type = "cpu";
    
19. 18              reg = <1>;
    
20. 19          };
    ( ]( {% c0 f1 h) w9 g  Q
21. 20      };
    $ B7 ^$ ~' ?, H& d5 A, c. G
22. 21      /* soc节点  */
    
23. 22      soc {
    
24. 23          compatible = "simple-bus";
    
25. 24          #address-cells = <1>;
    & p) z2 @! M: |) m6 P
26. 25          #size-cells = <1>;
    . g  Q0 L- Y* ?) ?! O' c; ~
27. 26          ranges;
    
28. 27          /* sram节点  */
    
29. 28          sram: sram@10000000 {
    
30. 29              compatible = "mmio-sram";
    " U* a. l* p8 s" Q0 g
31. 30              reg = <0x10000000 0x60000>;
    0 o; O5 i: D, _4 \; p
32. 31              ranges = <0 0x10000000 0x60000>;
    
33. 32          };
    & ]4 A/ A% \  Y+ k
34. 33      };
    
35. 34  };

复制代码

第28~32行，sram节点，第28行节点名字@后面的0x10000000就是sram的起始地址。第30行的reg属性也指明了sram内存的起始地址为0x10000000，大小为0x60000。
4、添加timers6、spi2、usart2和i2c1这四个子节点
3 B8 e; |* H: {" ?6 y6 T最后我们在myfirst.dts文件中加入timers6、spi2、usart2和i2c1这四个外设控制器的节点。最终的myfirst.dts文件内容如下：
! }; ~" K' O0 O% Z, G0 a9 R& W1 V- L0 j

1. 示例代码23.4.5 最终的myfirst.dts文件
   & B8 Y2 ]' G$ j5 N) q  w
2. 1   / {
   / k1 r, R( s2 Y: D3 g
3. 2       compatible = "st,stm32mp157d-atk", "st,stm32mp157";
   7 }  \0 i9 Q& |1 q$ L
4. 3       /* cpus节点 */
   
5. 4       cpus {
   3 Q( o( f/ q& x" L
6. 5           #address-cells = <1>;
   
7. 6           #size-cells = <0>;
   
8. 7
   ! \1 T# X, `5 @4 ]$ v9 ~
9. 8           /* CPU0节点 */
   # ^/ F. h! Q+ Q* s1 @# W( l) g
10. 9           cpu0: cpu@0 {
    
11. 10              compatible = "arm,cortex-a7";
    " L, }) N! y' _+ U' u8 N! b
12. 11              device_type = "cpu";
    
13. 12              reg = <0>;
    ( [8 S: g* s3 c& T3 I' l
14. 13          };
    
15. 14          /* CPU1节点 */
    , h$ a* V6 p6 G2 o" c
16. 15          cpu1: cpu@1 {
    
17. 16              compatible = "arm,cortex-a7";
    
18. 17              device_type = "cpu";
    
19. 18              reg = <1>;
    5 v3 k; E: h  {5 v/ z# a
20. 19          };
    
21. 20      };
    & U2 r! [. o% B6 t4 C, H3 N. O7 e
22. 21      /* soc节点 */
    
23. 22      soc {
    
24. 23          compatible = "simple-bus";
    / o% M9 c7 ^+ _& S/ i5 T9 G2 ^" c2 V8 v
25. 24          #address-cells = <1>;
    $ J% p, J, x/ w6 U( f, j3 p7 h  G! o. s
26. 25          #size-cells = <1>;
    
27. 26          ranges;
    
28. 27          /* sram节点 */
    
29. 28          sram: sram@10000000 {
    
30. 29              compatible = "mmio-sram";
    3 Q, O; P* J; D$ ]
31. 30              reg = <0x10000000 0x60000>;
    5 F) L1 }! K5 T/ f* |
32. 31              #address-cells = <1>;
    
33. 32              #size-cells = <1>;
    - V- g$ ^7 i, Y& ~) n" U" c( P
34. 33              ranges = <0 0x10000000 0x60000>;
    
35. 34          };
    7 _- C  x) @4 q: d- V; d0 j/ {
36. 35          /* timers6节点 */
    
37. 36          timers6: timer@40004000 {
    / Q! j8 @* g- @, `8 r
38. 37              #address-cells = <1>;
    $ E% {+ O; z  n# J' [/ ~/ V  t6 ]
39. 38              #size-cells = <0>;
    
40. 39              compatible = "st,stm32-timers";
    
41. 40              reg = <0x40004000 0x400>;
    
42. 41          };
    
43. 42          /* spi2节点  */
    
44. 43          spi2: spi@4000b000 {
    ( y) r3 L) s1 S% m# [
45. 44              #address-cells = <1>;
    7 t! S6 U: t* {! j1 d% [
46. 45              #size-cells = <0>;
    ' T9 v+ ^3 D) _9 @' [
47. 46              compatible = "st,stm32h7-spi";
    4 L, M; c8 U, o1 b
48. 47              reg = <0x4000b000 0x400>;
    
49. 48          };
    
50. 49          /* usart2节点 */
    
51. 50          usart2: serial@4000e000 {
    
52. 51              compatible = "st,stm32h7-uart";
    # j: W$ i# W  {& s! f, ~2 v. |+ I( m
53. 52              reg = <0x4000e000 0x400>;
    
54. 53          };
    $ L) X* Y0 h' G1 C, K) X. l
55. 54          /* i2c1节点  */
    - r$ a( s! X- i, X( C
56. 55          i2c1: i2c@40012000 {
    
57. 56              compatible = "st,stm32mp15-i2c";
    
58. 57              reg = <0x40012000 0x400>;
    
59. 58          };
    
60. 59         
    
61. 60      };
    % R- [- X( V4 D* U, s# N7 u
62. 61  };

复制代码

第36~41行，timers6外设控制器节点。
& o5 s; l6 T* `2 a8 E6 Q& w第43~48行，spi2外设控制器节点。
第50~53行，usart2外设控制器节点。
$ U0 m$ S% V, u+ K( b+ j1 U第55~58行，i2c1外设控制器节点。
到这里，我们的myfirst.dts小型的设备树模板就编辑好了，基本和stm32mp151.dtsi很像，可以看做是stm32mp151.dtsi的缩小版。在myfirst.dts里面我们仅仅是编写了STM32MP1的外设控制器节点，像SAI接口，LTDC接口下所连接具体设备我们并没有写，因为具体的设备其设备树属性内容不同，这个等到具体的实验在详细讲解。
" c3 v; n: g% t/ {& [
' D% i: w+ W3 [- J( C/ Z) m3 K23.5 设备树在系统中的体现
Linux内核启动的时候会解析设备树中各个节点的信息，并且在根文件系统的/proc/device-tree目录下根据节点名字创建不同文件夹，如图23.5.1所示：
5 ?9 {3 `( R) j$ N
" y  m7 L, U* s

/ H: n# Z: D, \/ O图23.5.1 根节点“/”的属性以及子节点
+ b2 Q( j' j- V7 |: ~图23.5.1就是目录/proc/device-tree目录下的内容，/proc/device-tree目录下是根节点“/”的所有属性和子节点，我们依次来看一下这些属性和子节点。
1、根节点“/”各个属性
在图23.5.1中，根节点属性属性表现为一个个的文件，比如图23.5.1中的“#address-cells”、“#size-cells”、“compatible”、“model”和“name”这5个文件，它们在设备树中就是根节点的5个属性。既然是文件那么肯定可以查看其内容，输入cat命令来查看model和compatible这两个文件的内容，结果如图23.5.2所示：
! y- v# T+ R2 n, o0 ]8 C0 A
- c* k9 |) c3 [# Q' [" |' }
4 W$ a+ ~/ B* Y! A
图23.5.2 model和compatible文件内容
从图23.5.2可以看出，文件model的内容是“STMicroelectronics STM32MP157D eval daughter”，文件compatible的内容为“st，stm32mp157d-ed1st,stm32mp157”。打开文件stm32mp157d-atk.dts查看一下，这不正是根节点“/”的model和compatible属性值吗！
4 G' T) T4 o) o2、根节点“/”各子节点
3 u8 U) z4 s5 S# d/ K8 f& u, j图23.5.1中各个文件夹就是根节点“/”的各个子节点，比如“aliases”、“reboot”、“chosen”和“cpus”等等。大家可以查看一下stm32mp157d-atk.dts和stm32mp157d-atk.dts所引用的.dtsi文件，看看根节点的子节点都有哪些，是否和图23.5.1中的一致。
/proc/device-tree目录就是设备树在根文件系统中的体现，同样是按照树形结构组织的，进入/proc/device-tree/soc目录中就可以看到soc节点的所有子节点，如图23.5.3所示：
9 _7 u' q4 n- R( R0 O+ Z


, z2 n* B1 b+ A! ^图23.5.3 soc部分节点
: E% T- }' z) B  j6 J和根节点“/”一样，图23.5.3中的所有文件分别为soc节点的属性文件和子节点文件夹。大家可以自行查看一下这些属性文件的内容是否和stm32mp151.dtsi中soc节点的属性值相同。
5 s9 c5 Q7 g* n( G5 C2 Q" P# A% P- ]23.6 特殊节点
在根节点“/”中有两个特殊的子节点：aliases和chosen，我们接下来看一下这两个特殊的子节点。
23.6.1 aliases子节点
打开stm32mp157d-atk.dts文件，aliases节点内容如下所示：

$ |; m* u% {% L9 D. E& @0 ~" ?

1. 示例代码23.6.1.1 aliases子节点
   , O' W" p! [: k# [
2. 24      aliases {
   
3. 25          serial0 = &uart4;
   
4. 26      };
   ! D; f8 D; W) _/ W
5. 单词alias

复制代码

( y- B: C: ~/ oes的意思是“别名”，因此aliases节点的主要功能就是定义别名，定义别名的目的就是为了方便访问节点。不过我们一般会在节点命名的时候会加上label，然后通过&label来访问节点，这样也很方便，而且设备树里面大量的使用&label的形式来访问节点。
/ H8 H9 Y" `- Q+ j& ]' ?5 `23.6.2 chosen子节点
  L8 R2 `$ p2 a5 ~# v3 t" ]% Vchosen并不是一个真实的设备，chosen节点主要是为了uboot向Linux内核传递数据，重点是bootargs参数。一般.dts文件中chosen节点通常为空或者内容很少，stm32mp157d-atk.dts中chosen节点内容如下所示：

& J4 g. D! w+ d5 B3 n

1. 示例代码23.6.2.1 chosen子节点
   
2. 20      chosen {
   " b* q& B$ k9 X5 C5 O
3. 21          stdout-path = "serial0:115200n8";
   
4. 22      };

复制代码

$ @) ?* v1 b: z5 q' b* \/ I从示例代码23.6.2.1中可以看出，chosen节点仅仅设置了属性“stdout-path”，表示标准输出使用serial0，而aliases已经设置了serial0为uart4，所以开发板启动以后使用UART4作为默认终端。但是当我们进入到/proc/device-tree/chosen目录里面，会发现多了bootargs这个属性，如图23.6.2.1所示：
+ B. f, ^( X2 t! s, Z4 k
3 p0 d2 \7 ~1 Q3 x( b

( D4 E& T0 Y, ?( F' |( Q! Q图23.6.2.1 chosen节点目录
输入cat命令查看bootargs这个文件的内容，结果如图23.6.2.2所示：

2 \0 }5 r) p' R
" V/ y2 Y' a3 E( z0 f" ~+ N
图23.6.2.2 bootargs文件内容
从图23.6.2.2可以看出，bootargs这个文件的内容为“console=ttySTM0,115200……”，这个就是我们在uboot中设置的bootargs环境变量，现在有两个疑点：
①、我们并没有在设备树中设置chosen节点的bootargs属性，那么图23.6.2.1中bootargs这个属性是怎么产生的？
+ r4 s, r3 Q  M0 d- b②、为何图23.6.2.1中bootargs文件的内容和uboot中bootargs环境变量的值一样？它们之间有什么关系？
前面讲解uboot的时候说过，uboot在启动Linux内核的时候会将bootargs的值传递给Linux内核，bootargs会作为Linux内核的命令行参数，Linux内核启动的时候会打印出命令行参数(也就是uboot传递进来的bootargs的值)，如图23.6.2.3所示：
. x, A/ Z, I( h: X0 _. \5 M: }
& D2 o/ @( F7 o5 c1 |

% p! f  ?2 o; v/ D" V4 U图23.6.2.3 命令行参数
% H5 [. i- p( C7 ^既然chosen节点的bootargs属性不是我们在设备树里面设置的，那么只有一种可能，那就是uboot自己在chosen节点里面添加了bootargs属性！并且设置bootargs属性的值为bootargs环境变量的值。因为在启动Linux内核之前，只有uboot知道bootargs环境变量的值，并且uboot也知道.dtb设备树文件在DRAM中的位置，因此uboot的“作案”嫌疑最大。在uboot源码中全局搜索“chosen”这个字符串，看看能不能找到一些蛛丝马迹。果然不出所料，在common/fdt_support.c文件中发现了“chosen”的身影，fdt_support.c文件中有个fdt_chosen函数，此函数内容如下所示：

- S& u6 i; Q7 ^$ e8 `

1. 示例代码23.6.2.2 uboot源码中的fdt_chosen函数
   
2. 275 int fdt_chosen(void *fdt)
   ' m, D3 g; i4 p* {4 G7 D/ {& \
3. 276 {
   
4. 277     int   nodeoffset;
   
5. 278     int   err;
   
6. 279     char  *str;     /* used to set string properties */
   8 z9 n; }/ g; L; @+ x0 c  T
7. 280
   ! k8 w$ Y0 Q! L& L
8. 281     err = fdt_check_header(fdt);
   
9. 282     if (err < 0) {
   
10. 283         printf("fdt_chosen: %s\n", fdt_strerror(err));
    ) ?# u0 n6 z: ~5 l) ~1 p
11. 284         return err;
    4 F7 a) s/ [  q6 q4 i! U
12. 285     }
    ) S4 T9 c+ W- r/ \/ y4 t) ^4 G
13. 286
    , W3 A; K4 T# z' f  C: Z) l0 D+ _
14. 287     /* find or create "/chosen" node. */
    
15. 288     nodeoffset = fdt_find_or_add_subnode(fdt, 0, "chosen");
    8 ]$ q# ?; O- J3 I5 z) E
16. 289     if (nodeoffset < 0)
    
17. 290         return nodeoffset;
    
18. 291
    3 ^- _. Q7 ~0 n, s0 e
19. 292     str = getenv("bootargs");
    
20. 293     if (str) {
    
21. 294         err = fdt_setprop(fdt, nodeoffset, "bootargs", str,
    
22. 295                   strlen(str) + 1);
    0 [' h" O. O# F1 B
23. 296         if (err < 0) {
    
24. 297             printf("WARNING: could not set bootargs %s.\n",
    
25. 298                    fdt_strerror(err));
    
26. 299             return err;
    
27. 300         }
    
28. 301     }
    
29. 302
    * C4 V' k  A6 @, e, O
30. 303     return fdt_fixup_stdout(fdt, nodeoffset);
    ( M! ?; ^$ b9 b3 i* q
31. 304 }

复制代码

! s6 V! c9 T* h+ o( |/ ~第288行，调用函数fdt_find_or_add_subnode从设备树(.dtb)中找到chosen节点，如果没有找到的话就会自己创建一个chosen节点。
7 ?0 g9 d+ |) W4 w' e1 s2 Y' Q第292行，读取uboot中bootargs环境变量的内容。
$ D! W& j* l8 I1 P3 H; y8 W/ q第294行，调用函数fdt_setprop向chosen节点添加bootargs属性，并且bootargs属性的值就是环境变量bootargs的内容。
+ }+ ?" z0 Y8 c- Q& q证据“实锤”了，就是uboot中的fdt_chosen函数在设备树的chosen节点中加入了bootargs属性，并且还设置了bootargs属性值。接下来我们顺着fdt_chosen函数一点点的抽丝剥茧，看看都有哪些函数调用了fdt_chosen，一直找到最终的源头。这里我就不卖关子了，直接告诉大家整个流程是怎么样的，见图23.6.2.4：
& [$ O: `- p6 Q; e图23.6.2.4 fdt_chosen函数调用流程
图23.6.2.4中框起来的部分就是函数do_bootm_linux函数的执行流程，也就是说do_bootm_linux函数会通过一系列复杂的调用，最终通过fdt_chosen函数在chosen节点中加入了bootargs属性。而我们通过bootz命令启动Linux内核的时候会运行do_bootm_linux函数，至此，真相大白，一切事情的源头都源于如下命令：
bootm c2000000 – c4000000
& s" n5 t8 u" N, }- T+ _9 X' M当我们输入上述命令并执行以后，do_bootm函数就会执行，然后一切就按照图23.6.2.4中所示的流程开始运行。
23.7 Linux内核解析DTB文件
Linux内核在启动的时候会解析DTB文件，然后在/proc/device-tree目录下生成相应的设备树节点文件。接下来我们简单分析一下Linux内核是如何解析DTB文件的，流程如图23.7.1所示：

/ x. A2 N( n$ R- O& k* j: s图23.7.1 设备树节点解析流程。
) @9 F" R7 i, |( C从图23.7.1中可以看出，在start_kernel函数中完成了设备树节点解析的工作，最终实际工作的函数为unflatten_dt_node。
9 ?* d1 s6 T% ]23.8 绑定信息文档
设备树是用来描述板子上的设备信息的，不同的设备其信息不同，反映到设备树中就是属性不同。那么我们在设备树中添加一个硬件对应的节点的时候从哪里查阅相关的说明呢？在Linux内核源码中有详细的TXT文档描述了如何添加节点，这些TXT文档叫做绑定文档，路径为：Linux源码目录/Documentation/devicetree/bindings，如图23.8.1所示：
4 V1 m6 T- i/ S$ J
图23.8.1 绑定文档
比如我们现在要想在STM32MP157这颗SOC的I2C下添加一个节点，那么就可以查看Documentation/devicetree/bindings/i2c/i2c-stm32.txt，此文档详细的描述了STM32MP1系列的SOC如何在设备树中添加I2C设备节点，文档内容如下所示：
; A) H: Z# M& Y  Y5 M+ H5 [
- N8 |0 w% o. q& ^I2C controller embedded in STMicroelectronics STM32 I2C platform
: B0 @/ ?6 A7 ORequired properties:
9 |  G, a/ h! T! Z- I- {9 o
compatible: Must be one of the following
5 `% m& l* F% n2 _“st,stm32f4-i2c”
“st,stm32f7-i2c”
“st,stm32mp15-i2c”
reg: Offset and length of the register set for the device
interrupts: Must contain the interrupt id for I2C event and then the
" P* Q6 I. S: S: F% z* tinterrupt id for I2C error.
resets: Must contain the phandle to the reset controller.
clocks: Must contain the input clock of the I2C instance.
9 l7 f3 h2 }5 G+ k3 r4 c3 B6 ZA pinctrl state named “default” must be defined to set pins in mode
8 X/ c/ U. U- p4 d5 I7 gof operation for I2C transfer. An optional pinctrl state named “sleep”
has to be defined as well as to put I2C in low power mode in suspend
$ |0 g. L! H( i; {$ y. O% ?0 bmode.
/ n" m3 f, O: q2 B/ d#address-cells = <1>;
#size-cells = <0>;
( R7 V* {8 W4 J- gOptional properties:
  C$ A% z) z. C% v6 l7 J
clock-frequency: Desired I2C bus clock frequency in Hz. If not specified,
the default 100 kHz frequency will be used.
: Y# k5 U. f6 q2 p1 tFor STM32F4 SoC Standard-mode and Fast-mode are supported, possible values are
& n. E* n5 ]  K" U3 @- \100000 and 400000.
* y7 Y% b+ y' B$ ^For STM32F7, STM32H7 and STM32MP1 SoCs, Standard-mode, Fast-mode and Fast-mode
Plus are supported, possible values are 100000, 400000 and 1000000.
dmas: List of phandles to rx and tx DMA channels. Refer to stm32-dma.txt.
dma-names: List of dma names. Valid names are: “rx” and “tx”.
8 n) ~2 m  F2 M2 m9 e4 c* K9 g" N) c7 H& ti2c-scl-rising-time-ns: I2C SCL Rising time for the board (default: 25)
) w8 Q: Y  Y) Y6 uFor STM32F7, STM32H7 and STM32MP1 only.
i2c-scl-falling-time-ns: I2C SCL Falling time for the board (default: 10)
For STM32F7, STM32H7 and STM32MP1 only.
I2C Timings are derived from these 2 values
st,syscfg-fmp: Use to set Fast Mode Plus bit within SYSCFG when Fast Mode
0 o$ ~; J* h2 [  O$ t8 Z9 F  aPlus speed is selected by slave.
1st cell: phandle to syscfg
! i/ o- u' L0 |' ?7 V" w- l/ V$ ~2nd cell: register offset within SYSCFG
( r7 w1 _) c' Q/ }6 f" t% T+ y3rd cell: register bitmask for FMP bit
For STM32F7, STM32H7 and STM32MP1 only.
st,smbus-alert: enable the SMBus Alert feature
0 w+ J3 J8 T( m  M& Z% P6 ]1 zst,smbus-host-notify: enable the SMBus Host-Notify feature
wakeup-source: Enable the possibility to use the I2C as a wakeup-source
' n2 A" O, ]% K/ c3 EFor STM32H7 and STM32MP1 only.
; P6 o; v( e6 Y+ ?  C
Example:
+ U$ u: z, g7 V+ f

1. i2c@40005400 {
   ) Q4 v. ]9 g3 l* m: i) c9 J0 ~. U
2.     compatible = "st,stm32f4-i2c";
   - G' ?- q" e8 f* x/ F
3.     #address-cells = <1>;
   
4.     #size-cells = <0>;
   
5.     reg = <0x40005400 0x400>;
   / X, D/ d4 ~% w' P6 w& ~5 X+ {
6.     interrupts = <31>,
   
7.              <32>;
   
8.     resets = <&rcc 277>;
   % z5 `+ ^$ W& D+ H' \9 m. ]9 O( n
9.     clocks = <&rcc 0 149>;
   
10.     pinctrl-0 = <&i2c1_sda_pin>, <&i2c1_scl_pin>;
    
11.     pinctrl-names = "default";
    
12. };
    
13. i2c@40005400 {
    0 R0 ?2 _+ V5 s. o9 b
14.     compatible = "st,stm32f7-i2c";
    ( Q# Y) ]* P# @1 U9 w1 A. q
15.     #address-cells = <1>;
    * k; v# N. x- G0 ~! e$ i
16.     #size-cells = <0>;
    
17.     reg = <0x40005400 0x400>;
    
18.     interrupts = <31>,
    
19.              <32>;
    ) K2 _# x7 q/ s* G: S  D  Q
20.     resets = <&rcc STM32F7_APB1_RESET(I2C1)>;
    
21.     clocks = <&rcc 1 CLK_I2C1>;
    9 ~" ]7 H, f, q& I4 Y: [
22.     pinctrl-0 = <&i2c1_sda_pin>, <&i2c1_scl_pin>;
    
23.     pinctrl-1 =  <&i2c1_sda_pin_sleep>, <&i2c1_scl_pin_sleep>;
    
24.     pinctrl-names = "default", "sleep";
    1 K4 H- }" ~+ g6 U( x" z
25.     st,syscfg-fmp = <&syscfg 0x4 0x1>;
    
26.     st,syscfg-fmp-clr = <&syscfg 0x44 0x1>;
    " d7 D6 R. e( K) x) Q6 x6 e2 e
27. };

复制代码

  l, C; ]$ C  _2 U. U有时候使用的一些芯片在Documentation/devicetree/bindings目录下找不到对应的文档，这个时候就要咨询芯片的提供商，让他们给你提供参考的设备树文件。

23.9 设备树常用OF操作函数
设备树描述了设备的详细信息，这些信息包括数字类型的、字符串类型的、数组类型的，我们在编写驱动的时候需要获取到这些信息。比如设备树使用reg属性描述了某个外设的寄存器地址为0X02005482，长度为0X400，我们在编写驱动的时候需要获取到reg属性的0X02005482和0X400这两个值，然后初始化外设。Linux内核给我们提供了一系列的函数来获取设备树中的节点或者属性信息，这一系列的函数都有一个统一的前缀“of_”，所以在很多资料里面也被叫做OF函数。这些OF函数原型都定义在include/linux/of.h文件中。
+ f' U7 x4 m; B4 B23.9.1 查找节点的OF函数
% J) q% T8 ^; a6 ?设备都是以节点的形式“挂”到设备树上的，因此要想获取这个设备的其他属性信息，必须先获取到这个设备的节点。Linux内核使用device_node结构体来描述一个节点，此结构体定义在文件include/linux/of.h中，定义如下：

0 k7 I+ S& H+ p$ \  ^; F

1. 示例代码23.3.9.1 device_node节点
   3 \/ {2 p- N( ]- m3 b
2. 51  struct device_node {
   
3. 52      const char *name;                       /*节点名字                      */
   
4. 53      phandle phandle;
   / ~; Z3 k8 v" P# a5 O- G) q
5. 54      const char *full_name;                  /*节点全名                      */
   * V; N, a, l. {4 [9 j. Y
6. 55      struct fwnode_handle fwnode;
   4 L4 L" `9 m3 ^
7. 56
   
8. 57      struct  property *properties;   /*属性                    */
   . O& _% Z% M' Q$ l
9. 58      struct  property *deadprops;    /*removed 属性           */
   
10. 59      struct  device_node *parent;    /*父节点                     */
    
11. 60      struct  device_node *child;     /*子节点                     */
    . Q7 @9 @" l. N+ C1 g
12. 61      struct  device_node *sibling;
    
13. 62  #if defined(CONFIG_OF_KOBJ)
    
14. 63      struct  kobject kobj;
    - @! S" w- ]+ `( G' q$ q* u
15. 64  #endif
    
16. 65      unsigned long _flags;
    
17. 66      void    *data;
    * e( W2 P) H- ^8 v' M
18. 67  #if defined(CONFIG_SPARC)
    
19. 68      unsigned int unique_id;
    / m! f! \# ~. I, _7 I+ k# ^
20. 69      struct of_irq_controller *irq_trans;
    
21. 70  #endif
    
22. 71  };

复制代码

5 R2 Y' Z5 `1 V, b- R与查找节点有关的OF函数有5个，我们依次来看一下。
1、of_find_node_by_name函数
9 g# V' C  {. F% K: R: x+ z; jof_find_node_by_name函数通过节点名字查找指定的节点，函数原型如下：
, s; R* m6 h0 w* u6 q9 pstruct device_node *of_find_node_by_name(struct device_node *from,
) E( d$ D& \3 Z0 hconst char *name);
- _0 [0 H' T, A8 K7 d( Y函数参数和返回值含义如下：
9 C; ?5 N# W; ifrom：开始查找的节点，如果为NULL表示从根节点开始查找整个设备树。
name：要查找的节点名字。
返回值：找到的节点，如果为NULL表示查找失败。
2、of_find_node_by_type函数
% x: j9 G5 N' |of_find_node_by_type函数通过device_type属性查找指定的节点，函数原型如下：
struct device_node *of_find_node_by_type(struct device_node *from, const char *type)
函数参数和返回值含义如下：
from：开始查找的节点，如果为NULL表示从根节点开始查找整个设备树。
/ j# p7 x" E$ {  f8 a! `4 [1 Y# |# Mtype：要查找的节点对应的type字符串，也就是device_type属性值。
返回值：找到的节点，如果为NULL表示查找失败。
3、of_find_compatible_node函数
of_find_compatible_node函数根据device_type和compatible这两个属性查找指定的节点，函数原型如下：
struct device_node *of_find_compatible_node(struct device_node *from,
const char *type,
const char *compatible)
函数参数和返回值含义如下：
& _' r+ u0 C3 {, xfrom：开始查找的节点，如果为NULL表示从根节点开始查找整个设备树。
* K; ~7 x. l4 ?( c# C' i7 vtype：要查找的节点对应的type字符串，也就是device_type属性值，可以为NULL，表示忽略掉device_type属性。
3 Z7 n9 Q; w  T/ f8 Xcompatible：要查找的节点所对应的compatible属性列表。
5 `$ ]5 a* A9 N: i9 t返回值：找到的节点，如果为NULL表示查找失败
2 P: \7 @: F( B- r0 ?4、of_find_matching_node_and_match函数
7 D& t8 c7 g8 y9 U9 Jof_find_matching_node_and_match函数通过of_device_id匹配表来查找指定的节点，函数原型如下：
& ]# h+ \" K; M# @struct device_node *of_find_matching_node_and_match(struct device_node *from,
$ w, D; ~# \$ q5 G7 G1 d3 ]const struct of_device_id *matches,
: h8 e& ~5 A2 F& A) L8 c+ _const struct of_device_id **match)
函数参数和返回值含义如下：
, @% Y0 c# P: w$ q9 q6 q2 Xfrom：开始查找的节点，如果为NULL表示从根节点开始查找整个设备树。
. Q2 b& @$ C/ k2 a% [$ K4 xmatches：of_device_id匹配表，也就是在此匹配表里面查找节点。
$ ~* [/ a0 Z  }7 z  ~$ |4 b6 B  Dmatch：找到的匹配的of_device_id。
返回值：找到的节点，如果为NULL表示查找失败
5、of_find_node_by_path函数
; B; C1 w$ ~; _& r& y& J* ?6 |/ H( Qof_find_node_by_path函数通过路径来查找指定的节点，函数原型如下：
# }+ e# U, Z. y9 _* E7 l3 uinline struct device_node *of_find_node_by_path(const char *path)
函数参数和返回值含义如下：
5 i+ h) `" m9 a2 gpath：带有全路径的节点名，可以使用节点的别名，比如“/backlight”就是backlight这个节点的全路径。
6 r, o- w1 N5 m3 B4 a  O返回值：找到的节点，如果为NULL表示查找失败
23.9.2 查找父/子节点的OF函数
Linux内核提供了几个查找节点对应的父节点或子节点的OF函数，我们依次来看一下。
1、of_get_parent函数
of_get_parent函数用于获取指定节点的父节点(如果有父节点的话)，函数原型如下：
" k( n. W) q" H; X8 i, i( a0 istruct device_node *of_get_parent(const struct device_node *node)
$ f% ^7 A( f. J: O( o5 l, m函数参数和返回值含义如下：
: [! e- n- R4 \7 \node：要查找的父节点的节点。
: C5 r6 R+ J: L( E  O2 L# W返回值：找到的父节点。
2、of_get_next_child函数
6 B, p- g) w1 Y( Sof_get_next_child函数用迭代的查找子节点，函数原型如下：
! t: [7 d. Q2 b" N& c) a4 xstruct device_node *of_get_next_child(const struct device_node *node,
struct device_node *prev)
  m) _( ^+ P6 D& p$ P函数参数和返回值含义如下：
6 X! N. K* }' Knode：父节点。
prev：前一个子节点，也就是从哪一个子节点开始迭代的查找下一个子节点。可以设置为NULL，表示从第一个子节点开始。
  G8 y$ g1 o/ R8 ~+ p2 G: N返回值：找到的下一个子节点。
23.9.3 提取属性值的OF函数
节点的属性信息里面保存了驱动所需要的内容，因此对于属性值的提取非常重要，Linux内核中使用结构体property表示属性，此结构体同样定义在文件include/linux/of.h中，内容如下：
" Q- [5 P" A# i0 d5 i

1. 示例代码23.9.3.1 property结构体
   / |6 Y+ h! m7 I1 Y/ z2 W5 B- d$ I
2. 31  struct property {
   
3. 32      char    *name;                          /* 属性名字                 */
   9 {: H2 ^- t* D- w' J  t2 {
4. 33      int         length;                             /* 属性长度                 */
   
5. 34      void    *value;                         /* 属性值                  */
   
6. 35      struct property *next;                  /* 下一个属性              */
   ( X  H, p/ i/ `  D9 t$ t
7. 36  #if defined(CONFIG_OF_DYNAMIC) || defined(CONFIG_SPARC)
   " j, d% _0 E; D! @; r2 b( @6 T: F8 J
8. 37      unsigned long _flags;
   6 @8 P' a% p2 o2 R, H
9. 38  #endif
   
10. 39  #if defined(CONFIG_OF_PROMTREE)
    
11. 40      unsigned int unique_id;
    
12. 41  #endif
    
13. 42  #if defined(CONFIG_OF_KOBJ)
    " t+ I' j2 D1 i2 k5 e1 o7 i
14. 43      struct bin_attribute attr;
    
15. 44  #endif
    
16. 45  };

复制代码

Linux内核也提供了提取属性值的OF函数，我们依次来看一下。
! c5 [% K3 C+ T5 O- c1、of_find_property函数
5 G3 j7 K( O: U$ P9 v5 Q# Aof_find_property函数用于查找指定的属性，函数原型如下：
/ }$ x- n3 @4 a9 a/ X8 x# p4 I: L

1. property *of_find_property(const struct device_node         *np,
   1 l4 \2 j2 H. `
2.                                             const char                                 *name,
   
3.                                             int                                         *lenp)

复制代码

  q- u0 d$ {8 @, _3 k; y8 r函数参数和返回值含义如下：
" K8 f. l0 q! E" p: |3 _1 vnp：设备节点。
# p1 @# v7 E8 s2 u( n* Lname： 属性名字。
lenp：属性值的字节数
返回值：找到的属性。
# L' W1 U/ p  w+ r, i$ i! W2、of_property_count_elems_of_size函数
8 M( ?: T! @6 pof_property_count_elems_of_size函数用于获取属性中元素的数量，比如reg属性值是一个数组，那么使用此函数可以获取到这个数组的大小，此函数原型如下：

  r- i0 n# D# g0 ~

1. int of_property_count_elems_of_size(const struct device_node         *np,
   
2.                                                           const char                                 *propname,
   
3.                                                             int                                         elem_size)

复制代码

8 M1 @% x) ]8 |) I5 l6 F& t- s( `函数参数和返回值含义如下：
5 p, q! M, ?; U( k/ x  G9 Jnp：设备节点。
proname： 需要统计元素数量的属性名字。
elem_size：元素长度。
返回值：得到的属性元素数量。
! K( U1 ^1 P# l0 [- ^! C3、of_property_read_u32_index函数
  ?% }: c+ B- U. l* ~" oof_property_read_u32_index函数用于从属性中获取指定标号的u32类型数据值(无符号32位)，比如某个属性有多个u32类型的值，那么就可以使用此函数来获取指定标号的数据值，此函数原型如下：

% w  N* U# A( a+ n% L" w, T

1. int of_property_read_u32_index(const struct device_node         *np,
   
2.                                           const char                                 *propname,
   / b" y  c4 W; n, o) z
3.                                           u32                                         index,
   
4.                                                   u32                                         *out_value)

复制代码

函数参数和返回值含义如下：
np：设备节点。
proname： 要读取的属性名字。
index：要读取的值标号。
out_value：读取到的值
返回值：0读取成功，负值，读取失败，-EINVAL表示属性不存在，-ENODATA表示没有要读取的数据，-EOVERFLOW表示属性值列表太小。
6 ~3 I3 i  z+ `" k" u3 s4、        of_property_read_u8_array函数
, m6 ?/ a8 ~. M5 g           of_property_read_u16_array函数
* }% y0 f* V2 [" v! aof_property_read_u32_array函数
, H  Q# ~7 _6 u% zof_property_read_u64_array函数
这4个函数分别是读取属性中u8、u16、u32和u64类型的数组数据，比如大多数的reg属性都是数组数据，可以使用这4个函数一次读取出reg属性中的所有数据。这四个函数的原型如下：

1. int of_property_read_u8_array(const struct device_node         *np,
   
2.                                                  const char                                 *propname,
   " t' f* ?0 Y' D/ G$ a# b# r
3.                                                  u8                                         *out_values,
   & o( x$ k( y$ G" T
4.                                                  size_t                                         sz)
   5 @# D; R* F- j, n; J% H% w7 R* z
5. int of_property_read_u16_array(const struct device_node         *np,
   9 v$ z, z; i9 g: g3 r
6.                                                   const char                                 *propname,
   
7.                                                   u16                                         *out_values,
   7 W$ X2 P% s9 u# b
8.                                                   size_t                                         sz)
   
9. int of_property_read_u32_array(const struct device_node         *np,
   
10.                                              const char                                 *propname,
    
11.                                                   u32                                         *out_values,
    
12.                                              size_t                                         sz)
    
13. int of_property_read_u64_array(const struct device_node         *np,
    
14.                                              const char                                 *propname,
    4 U: H. V, ~2 C' _2 Q' X# N
15.                                                   u64                                         *out_values,
    ! F+ C# {: \2 w' N1 C8 X0 P3 U$ q. b
16.                                       size_t                                         sz)
    

复制代码

函数参数和返回值含义如下：
np：设备节点。
proname： 要读取的属性名字。
out_value：读取到的数组值，分别为u8、u16、u32和u64。
sz：要读取的数组元素数量。
8 k; `- C7 f+ c返回值：0，读取成功，负值，读取失败，-EINVAL表示属性不存在，-ENODATA表示没有要读取的数据，-EOVERFLOW表示属性值列表太小。

* x+ L2 i3 D6 a  Z, }* [8 O: |/ f5、of_property_read_u8函数
% r% \2 ?- W; T' [( u3 j- }of_property_read_u16函数
of_property_read_u32函数
8 b" Z  K- L# }6 t: aof_property_read_u64函数
有些属性只有一个整形值，这四个函数就是用于读取这种只有一个整形值的属性，分别用于读取u8、u16、u32和u64类型属性值，函数原型如下：
5 \: Z0 K+ q: E
" q: H! X* Y: m5 K2 c! W( `4 f/ }

1. int of_property_read_u8(const struct device_node         *np,
   * o# H3 }4 {% G5 T  _* N
2.                                          const char                                 *propname,
   / t2 o2 \  D) u% p. H
3.                                           u8                                         *out_value)
   
4. int of_property_read_u16(const struct device_node         *np,
   
5.                                          const char                                 *propname,
   * ]+ L, \2 Y( n0 i" }9 h4 k
6.                                           u16                                         *out_value)
   
7. int of_property_read_u32(const struct device_node         *np,
   . w$ T2 V( U4 e
8.                                          const char                                 *propname,
   
9.                                           u32                                         *out_value)
   $ F7 p: a3 E9 ~/ _
10. int of_property_read_u64(const struct device_node         *np,
    9 ]! m# a7 F7 D/ T8 c# k& [
11.                                          const char                                 *propname,
    - G, B: k. ]2 i5 {" @& R
12.                                           u64                                         *out_value)

复制代码

  k, j3 n1 o2 z8 Y' T; o9 d- B2 J函数参数和返回值含义如下：
np：设备节点。
proname： 要读取的属性名字。
! q6 _5 g  \0 r6 d7 H0 ?out_value：读取到的数组值。
7 j: Z3 ^; g. i  u' ?$ p返回值：0，读取成功，负值，读取失败，-EINVAL表示属性不存在，-ENODATA表示没有要读取的数据，-EOVERFLOW表示属性值列表太小。
6、of_property_read_string函数
of_property_read_string函数用于读取属性中字符串值，函数原型如下：
: `5 I0 H* a: W) y4 |
int of_property_read_string(struct device_node *np,
const char *propname,
const char **out_string)
函数参数和返回值含义如下：
0 L% n( C% x  Y- d% ?% Q9 y4 E7 onp：设备节点。
4 ~. L* n' g' {# Vproname： 要读取的属性名字。
out_string：读取到的字符串值。
" J2 L9 o" J' [4 u6 i9 u3 i返回值：0，读取成功，负值，读取失败。
0 u1 D5 Y+ p" M. Q7、of_n_addr_cells函数
7 D9 s5 {9 Y% z: f8 Y( Q, ~, v  C* ]of_n_addr_cells函数用于获取#address-cells属性值，函数原型如下：
( [$ A7 y& ~! Z" lint of_n_addr_cells(struct device_node *np)
, x! o4 {3 \  ^! W2 H函数参数和返回值含义如下：
4 D, S3 [- ~7 X# f* Mnp：设备节点。
返回值：获取到的#address-cells属性值。
0 H9 l0 a9 M9 I$ @8 r5 P" h  {8、of_n_size_cells函数
  v  z& o1 \6 d+ \of_n_size_cells函数用于获取#size-cells属性值，函数原型如下：
2 g& Z/ x; R/ Z* J  ^, F. iint of_n_size_cells(struct device_node *np)
函数参数和返回值含义如下：
np：设备节点。
返回值：获取到的#size-cells属性值。
23.9.4 其他常用的OF函数
" h+ [  x8 K- b, ^+ B" i, w7 j# y3 l1、of_device_is_compatible函数
2 C( B' t) k" _5 _# B. C/ gof_device_is_compatible函数用于查看节点的compatible属性是否有包含compat指定的字符串，也就是检查设备节点的兼容性，函数原型如下：
int of_device_is_compatible(const struct device_node *device,
7 X0 y3 @- V/ H7 ?5 @  Xconst char *compat)
函数参数和返回值含义如下：
device：设备节点。
compat：要查看的字符串。
返回值：0，节点的compatible属性中不包含compat指定的字符串；正数，节点的compatible属性中包含compat指定的字符串。
* n9 }8 U1 J, R# m; k% F2、of_get_address函数
3 ^2 ^- B! E1 z% Aof_get_address函数用于获取地址相关属性，主要是“reg”或者“assigned-addresses”属性值，函数属性如下：
9 a$ H, y$ G* z" o5 sconst __be32 *of_get_address(struct device_node *dev,
& E' n, t+ j) r1 M- w& [int index,
u64 *size,
/ T- f" C3 X% W4 Q* R8 uunsigned int *flags)
函数参数和返回值含义如下：
dev：设备节点。
index：要读取的地址标号。
size：地址长度。
flags：参数，比如IORESOURCE_IO、IORESOURCE_MEM等
% x$ {1 s6 Y" @' R* B1 X3 l% C+ u返回值：读取到的地址数据首地址，为NULL的话表示读取失败。
6 ?* k; {2 F3 U' k$ l. x- B0 ~3、of_translate_address函数
of_translate_address函数负责将从设备树读取到的地址转换为物理地址，函数原型如下：
3 [$ E- r& ]. O+ A# su64 of_translate_address(struct device_node *dev,
8 W+ v) Z; t+ f& n& I  Q( Zconst __be32 *addr)
函数参数和返回值含义如下：
% Y2 E2 }& S, e# bdev：设备节点。
in_addr：要转换的地址。
& F: b2 D( F  C返回值：得到的物理地址，如果为OF_BAD_ADDR的话表示转换失败。
7 V5 W# O, V/ i& z4、of_address_to_resource函数
IIC、SPI、GPIO等这些外设都有对应的寄存器，这些寄存器其实就是一组内存空间，Linux内核使用resource结构体来描述一段内存空间，“resource”翻译出来就是“资源”，因此用resource结构体描述的都是设备资源信息，resource结构体定义在文件include/linux/ioport.h中，定义如下：
' @& X: t6 n# u: _( V3 [示例代码23.9.4.1 resource结构体
20 struct resource {
21 resource_size_t start;
, g0 _; J7 R6 O: H* C  V$ U22 resource_size_t end;
23 const char *name;
# v# t" l; j+ E6 H24 unsigned long flags;
25 unsigned long desc;
26 struct resource *parent, *sibling, *child;
9 g6 j5 {! H5 I+ {" f. o3 H/ S; }27 };
对于32位的SOC来说，resource_size_t是u32类型的。其中start表示开始地址，end表示结束地址，name是这个资源的名字，flags是资源标志位，一般表示资源类型，可选的资源标志定义在文件include/linux/ioport.h中，如下所示：

) w) V0 T8 y7 D, L$ E

1. 示例代码23.9.4.2 资源标志
   : V% N+ `9 a4 C2 M" i/ b! Y5 p) _
2. 1  #define IORESOURCE_BITS                      0x000000ff  
   $ P  q9 ^! S' y9 a0 N5 f# q  E# ?
3. 2  #define IORESOURCE_TYPE_BITS                0x00001f00  
   
4. 3  #define IORESOURCE_IO                        0x00000100  
   
5. 4  #define IORESOURCE_MEM                       0x00000200
   % X% j) G3 ?6 b' J3 j( }% p
6. 5  #define IORESOURCE_REG                       0x00000300  
   1 v! `' f! p: {, p
7. 6  #define IORESOURCE_IRQ                       0x00000400
   
8. 7  #define IORESOURCE_DMA                       0x00000800
   
9. 8  #define IORESOURCE_BUS                       0x00001000
   
10. 9  #define IORESOURCE_PREFETCH                 0x00002000  
    6 t4 p7 l; T2 w" u' }* @0 O& o3 z
11. 10 #define IORESOURCE_READONLY                 0x00004000
    
12. 11 #define IORESOURCE_CACHEABLE         0x00008000
    
13. 12 #define IORESOURCE_RANGELENGTH         0x00010000
      n% Y+ L! W+ f/ G' P0 i& a
14. 13 #define IORESOURCE_SHADOWABLE          0x00020000
    + h. p9 @5 @  c
15. 14 #define IORESOURCE_SIZEALIGN         0x00040000  
    
16. 15 #define IORESOURCE_STARTALIGN          0x00080000  
    
17. 16 #define IORESOURCE_MEM_64                    0x00100000
    
18. 17 #define IORESOURCE_WINDOW                    0x00200000  
    
19. 18 #define IORESOURCE_MUXED                         0x00400000  
    3 Q+ ?9 t4 S1 B$ K: E
20. 19 #define IORESOURCE_EXCLUSIVE         0x08000000  
    2 e7 v3 t6 s8 Z5 _$ x: t8 }
21. 20 #define IORESOURCE_DISABLED          0x10000000
    
22. 21 #define IORESOURCE_UNSET                         0x20000000
    ' K- q/ F' I. W( r
23. 22 #define IORESOURCE_AUTO                      0x40000000
    # O! Z' }- A3 R" r& Y% [; R) u0 s
24. 23 #define IORESOURCE_BUSY                      0x80000000  

复制代码

大家一般最常见的资源标志就是IORESOURCE_MEM、IORESOURCE_REG和IORESOURCE_IRQ等。接下来我们回到of_address_to_resource函数，此函数看名字像是从设备树里面提取资源值，但是本质上就是将reg属性值，然后将其转换为resource结构体类型，函数原型如下所示

1. int of_address_to_resource(struct device_node        *dev,
   2 G/ b; Y# }- I6 j: u  s+ C
2.                                           int                                 index,
   4 L; A1 E! @" H3 c" T2 a* c
3.                                              struct resource                 *r)

复制代码

( Q" ]& }) T8 S, _函数参数和返回值含义如下：
; X8 P+ b2 O, H1 P7 mdev：设备节点。
index：地址资源标号。
' T" q9 |5 N! S/ L5 Vr：得到的resource类型的资源值。
5 N/ S% N- j( b1 q8 L) x返回值：0，成功；负值，失败。
5、of_iomap函数
, z  ^$ R4 i- u, y- E) c/ U: sof_iomap函数用于直接内存映射，以前我们会通过ioremap函数来完成物理地址到虚拟地址的映射，采用设备树以后就可以直接通过of_iomap函数来获取内存地址所对应的虚拟地址，不需要使用ioremap函数了。当然了，你也可以使用ioremap函数来完成物理地址到虚拟地址的内存映射，只是在采用设备树以后，大部分的驱动都使用of_iomap函数了。of_iomap函数本质上也是将reg属性中地址信息转换为虚拟地址，如果reg属性有多段的话，可以通过index参数指定要完成内存映射的是哪一段，of_iomap函数原型如下：
" d, l  x1 v0 K
7 r% t5 I% i% W

1. void __iomem *of_iomap(struct device_node         *np,
   
2.                                          int                                 index)

复制代码

6 R% [. D: T# [& E4 ?& R" v7 O函数参数和返回值含义如下：
" w8 M& H4 k2 g  _8 Y( e* @9 onp：设备节点。
: U4 Z- I$ e* B  ~; K4 j, Q% c* X/ ~index：reg属性中要完成内存映射的段，如果reg属性只有一段的话index就设置为0。
返回值：经过内存映射后的虚拟内存首地址，如果为NULL的话表示内存映射失败。
5 ]  _# P' O! \关于设备树常用的OF函数就先讲解到这里，Linux内核中关于设备树的OF函数不仅仅只有前面讲的这几个，还有很多OF函数我们并没有讲解，这些没有讲解的OF函数要结合具体的驱动，比如获取中断号的OF函数、获取GPIO的OF函数等等，这些OF函数我们在后面的驱动实验中再详细的讲解。
关于设备树就讲解到这里，关于设备树我们重点要了解一下几点内容：

①、DTS、DTB和DTC之间的区别，如何将.dts文件编译为.dtb文件。
②、设备树语法，这个是重点，因为在实际工作中我们是需要修改设备树的。
③、设备树的几个特殊子节点。
2 V; U- T3 W, r1 N5 v8 h( k$ G④、关于设备树的OF操作函数，也是重点，因为设备树最终是被驱动文件所使用的，而驱动文件必须要读取设备树中的属性信息，比如内存信息、GPIO信息、中断信息等等。要想在驱动中读取设备树的属性值，那么就必须使用Linux内核提供的众多的OF函数。
从下一章开始所以的Linux驱动实验都将采用设备树，从最基本的点灯，到复杂的音频、网络或块设备等驱动。将会带领大家由简入深，深度剖析设备树，最终掌握基于设备树的驱动开发技能。
2 z1 ?: c  l& W+ n% F( K# s. M————————————————
版权声明：正点原子