Linux驱动开发基础(设备树)

所学来自百问网

[1. 引入设备树的原因](#1. 引入设备树的原因)

[2. 设备树语法](#2. 设备树语法)

[2.1 Devicetree格式](#2.1 Devicetree格式)

[2.1.1 DTS文件格式](#2.1.1 DTS文件格式)

[2.1.2 node的格式](#2.1.2 node的格式)

[2.1.3 properties的格式](#2.1.3 properties的格式)

[2.1.4 dts 文件包含dtsi文件](#2.1.4 dts 文件包含dtsi文件)

[2.2 常用属性](#2.2 常用属性)

2.2.1 #address-cells、#size-cells

[2.2.2 compatible](#2.2.2 compatible)

[2.2.3 model](#2.2.3 model)

[2.2.4 status](#2.2.4 status)

[2.2.5 reg](#2.2.5 reg)

[2.2.6 name(过时了，建议不用)](#2.2.6 name(过时了，建议不用))

[2.2.7 device_type(过时了，建议不用)](#2.2.7 device_type(过时了，建议不用))

[2.3 常用节点(node)](#2.3 常用节点(node))

[2.3.1 根节点](#2.3.1 根节点)

[2.3.2 CPU节点](#2.3.2 CPU节点)

[2.3.3 memory节点](#2.3.3 memory节点)

[2.3.4 chosen节点](#2.3.4 chosen节点)

[3. 内核对设备树的处理](#3. 内核对设备树的处理)

[3.1 dtb 中每一个节点都被转换为device_node结构体](#3.1 dtb 中每一个节点都被转换为device_node结构体)

[3.2 设备树节点转换为platform_device规则](#3.2 设备树节点转换为platform_device规则)

[3.3 platform_device如何与platform_driver配对](#3.3 platform_device如何与platform_driver配对)

[4. 相关函数](#4. 相关函数)

[4.1 platform_device相关的函数](#4.1 platform_device相关的函数)

[4.2 获取未生成platform_device的节点](#4.2 获取未生成platform_device的节点)

[4.3 获取属性](#4.3 获取属性)

[4.4 获取属性的值](#4.4 获取属性的值)

1. 引入设备树的原因

在总线驱动设备模型中，知道了在platform_bus_type总线下有两个链表，一个platform_driver和platform_device，platform_driver负责编写驱动程序，platform_device负责编写硬件资源，实现了分层分离的思想，但是该模型对于要适应多种开发板的程序有很大的弊端，当我们有若干个开发板，每个开发板的硬件资源都有所不同，为了适配开发板，我们必须重新提供一个platform_device文件，没增加一块就多一个文件，这样就会导致代码臃肿，修改麻烦。为了解决这种情况，引入设备树的概念。

设备树只是用来给内核里的驱动程序，指定硬件的信息。比如LED驱动，在内核的驱动程序里去操作寄存器，但是操作哪一个引脚？这由设备树指定。

2. 设备树语法

我们需要编写设备树文件(dts: device tree source)，它需要编译为dtb(device tree blob)文件，内核使用的是dtb文件。

以下是设备树示例：

它对应的dts文件如下：

2.1 Devicetree格式

2.1.1 DTS文件格式

DTS文件布局(layout):

/dts-v1/;                // 表示版本 
[memory reservations]    // 格式为: /memreserve/ <address> <length>; 
/ { 
    [property definitions]  // 参数定义
    [child nodes]           // 子节点
};

2.1.2 node的格式

设备树中的基本单元，被称为"node"，其格式为：

[label:] node-name[@unit-address] { 
    [properties definitions] 
    [child nodes] 
};

label是标号，可以省略。label的作用是为了方便地引用node，比如：

/dts-v1/; 
/ { 
 uart0: uart@fe001000 { 
        compatible="ns16550"; 
        reg=<0xfe001000 0x100>; 
 }; 
};

可以使用下面2种方法来修改uart@fe001000这个node：

// 在根节点之外使用label引用node： 
&uart0 { 
    status = "disabled"; 
}; 
或在根节点之外使用全路径： 
&{/uart@fe001000}  { 
    status = "disabled"; 
};

2.1.3 properties的格式

简单地说，properties就是"name=value"，value有多种取值方式。

Property格式1:

[label:] property-name = value;
Property格式2(没有值)：

[label:] property-name;
Property取值只有3种：

arrays of cells(1个或多个32位数据, 64位数据使用2个32位数据表示),
string(字符串),
bytestring(1个或多个字节)

示例：

a) Arrays of cells : cell就是一个32位的数据，用尖括号包围起来

interrupts = <17 0xc>;

64bit数据使用2个cell来表示，用尖括号包围起来:

clock-frequency = <0x00000001 0x00000000>;

b) A null-terminated string (有结束符的字符串)，用双引号包围起来:

compatible = "simple-bus";

c) A bytestring(字节序列) ，用中括号包围起来:

local-mac-address = [00 00 12 34 56 78];  // 每个byte使用2个16进制数来表示 
local-mac-address = [000012345678];       
// 每个byte使用2个16进制数来表示

可以是各种值的组合, 用逗号隔开:

compatible = "ns16550", "ns8250"; 
example = <0xf00f0000 19>, "a strange property format";

2.1.4 dts 文件包含dtsi文件

设备树文件不需要我们从零写出来，内核支持了某款芯片比如imx6ull，在内核的 arch/arm/boot/dts 目录下就有了能用的设备树模板，一般命名为 xxxx.dtsi。" i"表示"include"，被别的文件引用的。

我们使用某款芯片制作出了自己的单板，所用资源跟 xxxx.dtsi 是大部分相同，小部分不同，所以需要引脚xxxx.dtsi并修改。

dtsi 文件跟dts文件的语法是完全一样的。

dts 中可以包含.h头文件，也可以包含dtsi文件，在.h头文件中可以定义一些宏。

示例：

/dts-v1/; 
#include <dt-bindings/input/input.h> 
#include "imx6ull.dtsi" 
/ { 
    ...... 
};

2.2 常用属性

2.2.1 #address-cells、#size-cells

cell指一个32位的数值

**address-cells：**address 要用多少个32位数来表示；

**size-cells：**size要用多少个32位数来表示。

比如一段内存，怎么描述它的起始地址和大小？

下例中，address-cells 为 1，所以 reg 中用 1 个数来表示地址，即用 0x80000000 来表示地址；size-cells为1，所以reg中用1个数来表示大小，即用0x20000000表示大小：

/ { 
    #address-cells = <1>; 
    #size-cells = <1>; 
    memory { 
        reg = <0x80000000 0x20000000>; 
       }; 
};

2.2.2 compatible

"compatible"表示"兼容"，对于某个LED，内核中可能有A、B、C三个驱动都支持它，那可以这样写：

led { 
    compatible = "A", "B", "C"; 
};

内核启动时，就会为这个LED按这样的优先顺序为它找到驱动程序：A、B、C。

根节点下也有compatible属性，用来选择哪一个"machine desc"：一个内核可以支持 machine A，也支持 machine B，内核启动后会根据根节点的 compatible 属性找到对应的 machine desc 结构体，执行其中的初始化函数。

2.2.3 model

model 属性与compatible属性有些类似，但是有差别。

compatible 属性是一个字符串列表，表示可以你的硬件兼容A、B、C等驱动；

model 用来准确地定义这个硬件是什么。

比如根节点中可以这样写：

{ 
    compatible = "samsung,smdk2440", "samsung,mini2440"; 
    model = "jz2440_v3"; 
};

它表示这个单板，可以兼容内核中的"smdk2440"，也兼容"mini2440"

从 compatible 属性中可以知道它兼容哪些板，但是它到底是什么板？用 model 属性来明确。

2.2.4 status

dtsi 文件中定义了很多设备，但是在你的板子上某些设备是没有的。这时你可以给这个设备节点添加一个status属性，设置为"disabled"

&uart1 { 
    status = "disabled"; 
};

2.2.5 reg

reg 的本意是register，用来表示寄存器地址。

但是在设备树里，它可以用来描述一段空间。反正对于ARM系统，寄存器和内存是统一编址的，即访问寄存器时用某块地址，访问内存时用某块地址，在访问方法上没有区别。

reg 属性的值，是一系列的"address size"，用多少个32位的数来表示 address 和 size，由其父节点的#address-cells、#size-cells决定。

示例：

/dts-v1/; 
/ { 
    #address-cells = <1>; 
    #size-cells = <1>;  
    memory { 
        reg = <0x80000000 0x20000000>; 
    }; 
};

2.2.6 name(过时了，建议不用)

它的值是字符串，用来表示节点的名字。在跟platform_driver匹配时，优先级最低。compatible 属性在匹配过程中，优先级最高。

2.2.7 device_type(过时了，建议不用)

它的值是字符串，用来表示节点的类型。在跟platform_driver匹配时，优先级为中。compatible 属性在匹配过程中，优先级最高。

2.3 常用节点(node)

2.3.1 根节点

dts 文件中必须有一个根节点：

/dts-v1/; 
/ { 
    model = "SMDK24440"; 
    compatible = "samsung,smdk2440"; 
    #address-cells = <1>; 
    #size-cells = <1>;  
};

根节点中必须有这些属性：

#address-cells // 在它的子节点的reg属性中, 使用多少个u32整数来描述地址(address) 
#size-cells   // 在它的子节点的reg属性中, 使用多少个u32整数来描述大小(size) 
compatible   /* 定义一系列的字符串, 用来指定内核中哪个machine_desc可以支持本设备 
              * 即这个板子兼容哪些平台  
              * uImage : smdk2410 smdk2440 mini2440     ==> machine_desc   
              */          
model       // 咱这个板子是什么 比如有2款板子配置基本一致, 它们的compatible是一样的 那么就通过model来分辨这2款板子

2.3.2 CPU节点

一般不需要我们设置，在dtsi文件中都定义好了：

cpus { 
        #address-cells = <1>; 
        #size-cells = <0>; 
        cpu0: cpu@0 { 
            ....... 
        } 
};

2.3.3 memory节点

芯片厂家不可能事先确定你的板子使用多大的内存，所以memory节点需要板厂设置，比如：

memory { 
    reg = <0x80000000 0x20000000>; 
};

2.3.4 chosen节点

chosen是虚拟的，不对应哪些设备，我们可以通过设备树文件给内核传入一些参数，这要在chosen节点中设置 bootargs 属性：

chosen { 
    bootargs = "noinitrd root=/dev/mtdblock4 rw init=/linuxrc console=ttySAC0,115200"; 
};

3. 内核对设备树的处理

从源代码文件dts文件开始，设备树的处理过程为：

1.dts在PC机上被编译为dtb文件；

2.u-boot把dtb文件传给内核；

3.内核解析dtb文件，把每一个节点都转换为device_node结构体；

4.对于某些device_node结构体，会被转换为platform_device结构体。

3.1 dtb 中每一个节点都被转换为device_node结构体

根节点被保存在全局变量of_root中，从of_root开始可以访问到任意节点。

3.2 设备树节点转换为platform_device规则

根节点下含有compatile属性的子节点
含有特定compatile属性的节点的子节点

如果一个节点的 compatile 属性，它的值是这 4 者之一："simple bus","simple-mfd","isa","arm,amba-bus", 那么它的子结点( 需含 compatile 属性)也可以转换为platform_device。

总线I2C、SPI节点下的子节点：不转换为platform_device

某个总线下到子节点，应该交给对应的总线驱动程序来处理, 它们不应该被转换为platform_device。

示例：

/ { 
    // 每个根节点下的子节点都含有compatile，故mytest、i2c、spi都能转换为platform_device
    mytest { 
        compatile = "mytest", "simple-bus";    // 含有"simple-bus"，故mytest@0能转换为platform_device
        mytest@0 { 
            compatile = "mytest_0";           
        }; 
    }; 
    i2c { 
        compatile = "samsung,i2c";            // 不含"simple bus","simple-mfd","isa","arm,amba-bus"其中之一
        at24c02 {                                故at24c02不能能转换为platform_device
            compatile = "at24c02";                       
        }; 
    }; 
    spi { 
        compatile = "samsung,spi";             // 同i2c
        flash@0 { 
            compatible = "winbond,w25q32dw"; 
            spi-max-frequency = <25000000>; 
            reg = <0>; 
        }; 
    }; 
};

3.3 platform_device如何与platform_driver配对

从设备树转换得来的platform_device会被注册进内核里，以后当我们每注册一个platform_driver时，它们就会两两确定能否配对，如果能配对成功就调用platform_driver的probe函数。

platform_device与platform_driver配对对应的函数源码如下：

最先比较：是否强制选择某个driver

platform_device.driver_override 和 platform_driver.driver.name 可以设置platform_device 的 driver_override，强制选择某个platform_driver。

然后比较：设备树信息

platform_device.dev.of_node 和 platform_driver.driver.of_match_table

由设备树节点转换得来的platform_device中，含有一个结构体：of_node。它的类型如下：

如果一个platform_driver 支持设备树，它的 platform_driver.driver.of_match_table 是一个数组，类型如下：

使用设备树信息来判断dev和drv是否配对时:

1.首先，如果of_match_table中含有compatible值，就跟dev的compatile 属性比较，若一致则成功，否则返回失败；

2.其次，如果of_match_table中含有type值，就跟dev的device_type属性比较，若一致则成功，否则返回失败；

3.最后，如果of_match_table中含有name值，就跟dev的name属性比较，若一致则成功，否则返回失败。

而设备树中建议不再使用devcie_type和name属性，所以基本上只使用设备节点的compatible属性来寻找匹配的platform_driver。

接下来比较：platform_device_id

比较platform_device. name和platform_driver.id_table[i].name， id_table 中可能有多项。

platform_driver.id_table 是" platform_device_id"指针，表示该 drv 支持若干个device，它里面列出了各个device的{.name, .driver_data}，其中的"name"表示该 drv 支持的设备的名字，driver_data 是些提供给该 device 的私有数据。

最后比较

platform_device.name 和 platform_driver.driver.name

platform_driver.id_table 可能为空，这时可以根据 platform_driver.driver.name 来寻找同名的 platform_device。

汇总图示

4. 相关函数

4.1 platform_device相关的函数

of_platform.h中声明了很多函数，但是作为驱动开发者，我们只使用其中的1、2个。其他的都是给内核自己使用的，内核使用它们来处理设备树，转换得到platform_device。

遍历设备树，找到与给定节点 np 匹配的 platform_device 结构
- extern struct platform_device *of_find_device_by_node(struct device_node *np);
- np: 指向设备树中某个节点的指针，该节点代表了要查找的设备。
- 返回值：成功返回一个指向 platform_device 结构的指针，失败返回NULL
由于设备树中的节点被转换为 platform_device后，设备树中的reg属性、interrupts属性也会被转换为 "resource"。通过platform_get_resource可获取这些资源
- struct resource *platform_get_resource(struct platform_device *dev, unsigned int type, unsigned int num);
- dev指向 platform_device 结构的指针，该结构代表了要获取资源的平台设备。
- type要获取的资源类型。资源类型可以是 IORESOURCE_MEM（内存资源）、IORESOURCE_IO（IO端口资源）、IORESOURCE_IRQ（中断资源）等
- num要获取的资源编号

4.2 获取未生成platform_device的节点

在设备树中根据给定的路径查找节点
- static inline struct device_node *of_find_node_by_path(const char *path);
- const char *path：指向表示设备树中节点路径的字符串的指针。
- 返回值：成功时，返回指向找到的节点的指针；失败时，返回NULL
从指定的起始节点开始，在设备树中根据节点名称查找节点(不建议使用)
- extern struct device_node *of_find_node_by_name(struct device_node *from,const char *name);
- struct device_node *from：指向起始节点的指针，传入NULL表示从根节点开始寻找
- const char *name：指向要查找的节点名称的字符串的指针
- 返回值：成功时，返回指向找到的节点的指针；失败时，返回NULL。
从指定的起始节点开始，在设备树中根据节点类型查找节点(不建议使用)
- extern struct device_node *of_find_node_by_type(struct device_node *from, const char *type);
- struct device_node *from：指向起始节点的指针，传入NULL表示从根节点开始寻找
- const char *type：指向要查找的节点类型的字符串的指针。
- 返回值：成功时，返回指向找到的节点的指针；失败时，返回NULL。
从指定的起始节点开始，在设备树中查找与给定类型和字符串匹配的节点
- extern struct device_node *of_find_compatible_node(struct device_node *from, const char *type, const char *compat);
- struct device_node *from：指向起始节点的指针，传入NULL表示从根节点开始寻找
- const char *type：指向节点类型的字符串的指针，用来指定device_type属性的值，可以传入NULL。
- const char *compat：指向字符串的指针，用来指定compatible属性的值。
- 返回值：成功时，返回指向找到的节点的指针；失败时，返回NULL。
根据phandle找到节点。dts 文件被编译为dtb 文件时，每一个节点都有一个数字ID，这些数字ID彼此不同。可以使用数字ID来找到device_node。这些数字ID就是phandle。
- extern struct device_node *of_find_node_by_phandle(phandle handle);
- phandle handle：要查找的节点的phandle值
- 返回值：成功时，返回指向找到的节点的指针；失败时，返回NULL。
用于获取给定节点的父节点
- extern struct device_node *of_get_parent(const struct device_node *node);
- const struct device_node *node：指向要获取其父节点的节点的指针。
- 返回值：返回指向父节点的指针；如果给定节点是根节点，则返回NULL
获取给定节点的下一个更高层级的父节点（即父节点的父节点）
- extern struct device_node *of_get_next_parent(struct device_node *node);
- struct device_node *node：指向要获取其下一个更高层级父节点的节点的指针。
- 返回值：返回指向下一个更高层级父节点的指针；如果给定节点是根节点或其父节点是根节点，则返回NULL

获取给定节点的下一个子节点
- extern struct device_node *of_get_next_child(const struct device_node *node, struct device_node *prev);
- const struct device_node *node：指向要获取其下一个子节点的节点的指针。
- struct device_node *prev：指向当前已处理的子节点的指针，用于确定下一个子节点的位置。
- 返回值：返回指向下一个子节点的指针；如果没有更多的子节点，则返回NULL。
取出下一个"可用"的子节点，有些节点的status是"disabled"，那就会跳过这些节点。
- struct device_node *of_get_next_available_child( const struct device_node *node, struct device_node *prev);
- onst struct device_node *node：指向要获取其下一个子节点的节点的指针。
- struct device_node *prev：表示上一个子节点，设为NULL时表示想找到第1个子节点
根据名字取出子节点
- extern struct device_node *of_get_child_by_name(const struct device_node *node, const char *name);
- const struct device_node *node：指向要获取其子节点的节点的指针。
- const char *name：指向要查找的子节点名称的字符串的指针
- 返回值：成功时，返回指向具有指定名称的子节点的指针；如果找不到具有该名称的子节点，则返回NULL

4.3 获取属性

查找并获取指定设备节点（device node）的属性（property）
- extern struct property *of_find_property(const struct device_node *np, const char *name, int *lenp);
- const struct device_node *np：指向要搜索的设备节点的指针。设备节点是设备树中的一个元素，代表了一个硬件设备或设备的一个部分。
- const char *name：要查找的属性的名称。属性的名称是一个字符串，用于唯一标识设备节点中的一个属性。
- int *lenp：一个指向整数的指针，用于返回找到的属性的长度（以字节为单位）。如果调用者对此信息不感兴趣，可以将其设置为NULL。
- 返回值：返回一个指向struct property的指针，该结构体包含了找到的属性的详细信息（如名称、值、长度等）。如果未找到指定的属性，则返回NULL

在设备树中，节点大概是这样：

xxx_node { 
    xxx_pp_name = "hello"; 
};

上述节点中，"xxx_pp_name"就是属性的名字，值的长度是6。

4.4 获取属性的值

从给定的设备节点（device node）中获取指定名称的属性（property）的值
- const void *of_get_property(const struct device_node *np, const char *name, int *lenp)
- const struct device_node *np：指向要查询的设备节点的指针。
- const char *name：要获取的属性名称。
- int *lenp：一个指向整数的指针，用于返回获取到的属性值的长度（以字节为单位）。如果调用者不需要这个信息，可以将其设置为NULL。
- 返回值：如果找到指定名称的属性，则返回指向该属性值数据的指针，如果没有找到指定的属性，则返回NULL。
用于计算给定设备节点（device node）中指定名称的属性（property）中包含的元素数量
- int of_property_count_elems_of_size(const struct device_node *np, const char *propname, int elem_size);
- const struct device_node *np：指向要查询的设备节点的指针。
- const char *propname：要查询的属性的名称。
- int elem_size：属性中每个元素的大小（以字节为单位）。
- 返回值：如果找到指定名称的属性，并且属性中的元素大小与elem_size匹配，则返回该属性中包含的元素数量，反之则返回错误码（通常是负数）。
从给定的设备节点（device node）中读取指定名称的属性（property），并将该属性的值存储到提供的输出变量中
static inline int of_property_read_u32(const struct device_node *np, const char *propname, u32 *out_value); // 读32位
extern int of_property_read_u64(const struct device_node *np, const char *propname, u64 *out_value); // 读64位
- const struct device_node *np：指向要查询的设备节点的指针。
- const char *propname：要读取的属性的名称。
- *out_value：指向无符号32位或64位整数的指针，用于存储读取到的属性值
- 返回值：如果成功读取到属性并将其值存储到out_value中，则返回0，失败返回错误码（通常是负数）
- 在设备树中，节点大概是这样：
```
  xxx_node { 
      name1 = <0x50000000>; 
      name2 = <0x50000000  0x60000000>; 
  }; 
  调用of_property_read_u32 (np, "name1", &val)时，val将得到值0x50000000； 
  调用of_property_read_u64 (np, "name2", &val)时，val将得到值0x6000000050000000。 
```
从给定的设备节点（device node）中读取指定名称的属性（property），并返回该属性中指定索引（index）的无符号32位整数值（u32）
- extern int of_property_read_u32_index(const struct device_node *np, const char *propname, u32 index, u32 *out_value);
- const struct device_node *np：指向要查询的设备节点的指针。
- const char *propname：要读取的属性的名称。
- u32 index：要读取的值的索引。索引通常从0开始。
- u32 *out_value：指向无符号32位整数的指针，用于存储读取到的属性值。
- 返回值：如果成功读取到属性并将其值存储到out_value中，则返回0，失败返回错误码（通常是负数）
- 在设备树中，节点大概是这样：
```
  xxx_node { 
      name2 = <0x50000000  0x60000000>; 
  }; 
  调用of_property_read_u32 (np, "name2", 1, &val)时，val将得到值0x60000000
```
从给定的设备节点（device node）中读取指定名称的属性（property），并返回该属性的字符串值
- int of_property_read_string(const struct device_node *np, const char *propname, const char **out_string);
- const struct device_node *np：指向要查询的设备节点的指针。
- const char *propname：要读取的属性的名称。
- const char **out_string：指向const char*的指针，用于存储读取到的字符串值的地址。注意，这里存储的是指向设备树内存中字符串的指针，而不是字符串的副本。
- 返回值：如果成功读取到字符串值，并将其地址存储在out_string中，则返回0，失败返回错误码（通常是负数）