NotePublic/Software/Development/OperatingSystem/Linux/Kernel/Modules/DeviceTree/DeviceTree.md

# Device Tree

## 设备树的起源

linux 2.6 及之前，大量板级信息被硬编码到内核里，十分庞大，大量代码冗余。

linux 2.6 之后，引入了设备树。设备树源于 OpenFirmware，描述硬件的数据结构。由一些列节点（node）和属性（property）组成，通常包括下列信息：

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

本质上是画一棵 CPU、总线、设备组成的树，Linux 内核会把设备树展开成 platform_device、i2c_client、spi_device 等设备，而这些设备用到的内存、中断等资源，也会传递个内核，内核会将这些资源绑定给展开的相应设备。

## DTSI/DTS/DTC/DTB

dtsi：可被 #include 的设备树源文件；

dts：设备树源文件；

dtc：编译 dts 和 dtsi 后得到的设备树文件，dts 及 dtsi 中的内容被组合或覆盖，该文件为源码形式，Linux 内核无法识别；

dtb：编译 dtc 后得到的二进制设备树文件，Linux 内核可加载和识别其中的内容。

如果谋 dts 文件引用了谋 dtsi 文件，可以在 dts 中覆盖 dtsi 中的部分内容。

## DTS 语法

设备树包含一个根节点和多个子节点，如果在 dts/dtsi 文件中写了多个根节点，则在编译后被组合成一个根节点。子节点可嵌套。 节点会被展开为 device，其 compatible 属性用于与 driver 的 compatible 属性项匹配，如果匹配成功则调用该 driver 的 probe 函数。

DTS 中使用“//”进行行注释或“/**/”进行块注释。

### 节点

节点使用：

```dts
[label]:<name>[@<unit-address>] {}
```

的格式来定义。挂到内存空间的设备，其 unit-address 一般是内存地址。别的地方可以通过“&label”来引用该节点。

### 属性

属性必须包含在节点中，使用：

```dts
<property-name>=<value>
```

来定义。属性值可以为整数或字符串。如果为整数则用“<>”括起来，“<>”中可以有多个单元，称为 cell，cell 间使用空格隔开，不同的 cell 可以有不同的含义。字符串使用英文双引号括起来。同一属性的多个值可以使用英文“,”进行分割，例如：

```dts
reg = <0 0x00000000 0x04000000>,
      <1 0x00000000 0x04000000>;
```

### 标准属性

#### compatible

“compatible”属性通常用来 device 和 driver 的适配，推荐的格式为”manufacturer,model”。

Value type: stringlist

Example:

```dts
compatible = "fsl,mpc8641", "ns16550";
```

#### model

“model”属性只是简单的表示型号，root 节点用其来传递值给 machine_desc_str。

Value type: stringlist

Example:

```dts
model = "fsl,MPC8349EMITX";
```

#### phandle

“phandle”属性通用一个唯一的 id 来标识一个 Node，在 property 可以使用这个 id 来引用 Node。

Value type: u32

Example:

```dts
pic@10000000 {
    phandle = <1>;
    interrupt-controller;
};

another-device-node {
    interrupt-parent = <1>;
};
```

在 DeviceTree 中通过另一种方式进行 phandle 的定义和引用更加常见：

* 定义一个“label：”来引用Node，在编译是系统会自动为node生成一个phandle属性。
* 使用”&”来引用“label”，即是引用phandle。

#### ranges

“ranges”属性用来做当前 node 和父 node 之间的地址映射，格式为(child-bus-address, parentbus-address, length)。其中 child-bus-address 的解析长度受当前 node 的  #address-cells 属性控制，parentbus-address 的解析长度受父 node 的 #address-cells 属性控制 length 的解析长度受当前 node 的 #size-cells 属性控制。

Value type: empty or prop-encoded-array encoded as an arbitrary number of (child-bus-address, parentbus-address, length) triplets.

Example:

```dts
soc {
    compatible = "simple-bus";
    #address-cells = <1>;
    #size-cells = <1>;
    ranges = <0x0 0xe0000000 0x00100000>;
    serial {
        device_type = "serial";
        compatible = "ns16550";
        reg = <0x4600 0x100>;
        clock-frequency = <0>;
        interrupts = <0xA 0x8>;
        interrupt-parent = <&ipic>;
    };
};
```

The soc node specifies a ranges property of <0x0 0xe0000000 0x00100000>;

This property value specifies that for an 1024KB range of address space, a child node addressed at physical 0x0 maps to a parent address of physical 0xe0000000. With this mapping, the serial device node can be addressed by a load or store at address 0xe0004600, an offset of 0x4600 (specified in reg) plus the 0xe0000000 mapping specified in ranges.

#### reg 属性和 address-cells、size-cells

子节点的“reg”属性用于标记 iomem，由“address”字段和“size”字段构成，如：

```dts
reg = <address1 size1 [address2 size2] [address3 size3]...>;
```

属性“#address-cells”描述了子节点的“reg”属性的“address”字段为几个 32bit 的整型数据。

属性“#size-cells”描述了子节点的“reg”属性的“size”字段为几个 32bit 整型数据，如果为 0，则没有 lenth 字段。

#### interrupt

* interrutt-controller：属性为空，表明“我是中断控制器”；
* #interrupt-cells：表明连接此中断控制器的设备的中断属性的 cell 大小，也就是 interrupt = <> 属性的 cell 大小；
* interrupt-parent：设备节点通过这个关键字指定其依附的中断控制器 phandle，如果没有指定，则继承父节点的 interrupt-parent 配置；
* interrupt：设备节点里使用，一般包含中断号、触发方法等。具体有多少个 cell，由 #interrupt-cells 决定，每个 cell 的具体含义，一般由驱动决定。

多个中断可以用 interrupts 描述。interrupts 属性后面，会有不同的参数，有时是两个，有时是三个。

两个的时候一般是这样出现：

```dts
interrupt-parent = <&gpio2>;
interrupts = <29 0>;
```

一般这样表明：中断控制器是 GPIO2，然后使用它的 29 号中断。(这里的 29 号，就是指 29 号引脚)，0 是指触发的方式(上升沿、下降沿等)。

三个的时候一般是这样出现：

```dts
interrupts = <0 37 1>;
interrupts = <GIC_SPI 37 1>;
interrupts = <GIC_PPI 37 1>;
```

第一个参数表示是 IPI、PPI、SPI、SGI 其中的一个。第二个参数表示：是第一个参数里面的第几个。第三个参数表示：中断触发的类型(上升沿、下降沿等)。

IPI、PPI、SPI、SGI 是 ARM 规范的中断，含义如下:

* IPI：inter-processer interrupt   中断号0～15
* PPI：per processor interrupts    中断号16～31
* SPI：shared processor interrupts  中断号 32 ～32+224
* SGI：software generated interrupts (SGI).

中断类型的值如下：

```cpp
#define IRQ_TYPE_NONE           0
#define IRQ_TYPE_EDGE_RISING    1
#define IRQ_TYPE_EDGE_FALLING   2
#define IRQ_TYPE_EDGE_BOTH      (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING)
#define IRQ_TYPE_LEVEL_HIGH     4
#define IRQ_TYPE_LEVEL_LOW      8
```

### 标准节点

#### Root

#### aliases

#### memory

#### chosen

#### cpus

#### 

// TODO: <http://kernel.meizu.com/device-tree.html>、<https://blog.csdn.net/21cnbao/article/details/8457546>、<https://www.jianshu.com/p/923b380366bb>

### DTS 示例

一个简单的 dts 文件示例如下：

```dts
/ {
 　　　　compatible = "acme,coyotes-rev"
 　　　　#address-cells = <1>;　　// 描述下一级子节点的数据属性
 　　　　#size-cells = <1>;
 　　　　interrupt-parent = <&intc>;

 　　　　cpus {
 　　　　　　#address-cells = <1>;
 　　　　　　#size-cells = <0>;
 　　　　　 cpu@0 {
 　　　　　　　　compatible = "arm,cortex-a9"; 　　// device兼容性，用于与driver匹配
 　　　　　　　　reg = <0>;
 　　　　　 };
 　　　　　 cpu@1 {
 　　　　　　　　compatible = "arm,cortex-a9";
 　　　　　　　　reg = <1>;
 　　　　　 };
 　　　};

 　　　serial@101f0000 {　　　　　　　　// 地址
 　　　　　compatible = "arm,pl011";
 　　　　  reg = <0x101f0000 0x1000 >;
 　　　　　interrupts = < 1 0 >;
 　　  };

 　　　serial@101f2000 {
 　　　　　compatible = "arm,pl011";
 　　　　  reg = <0x101f2000 0x1000 >;
 　　　　　interrupts = < 2 0 >;
 　　　};

 　　　gpio@101f3000 {
 　　　　　compatible = "arm,pl061";
 　　　　　reg = <0x101f3000 0x1000
 　　　　　0x101f4000 0x0010>;
 　　　　　interrupts = < 3 0 >;
 　　　};

 　　  intc: interrupt-controller@10140000 {
 　　　　　compatible = "arm,pl190";
 　　　　  reg = <0x10140000 0x1000 >;
 　　　　　interrupt-controller;
 　　　　　#interrupt-cells = <2>;
 　　　};

 　　　spi@10115000 {
 　　　　　compatible = "arm,pl022";
 　　　　　reg = <0x10115000 0x1000 >;
 　　　　　interrupts = < 4 0 >;50
 　　　};

 　　　external-bus {
 　　　　　#address-cells = <2>
 　　　　　#size-cells = <1>;
 　　　　　ranges = <0 0 0x10100000 0x10000 // Chipselect 1, Ethernet
 　　　　　　　　　　 1 0 0x10160000 0x10000 // Chipselect 2, i2c controller
 　　　　　　　　　　 2 0 0x30000000 0x1000000>; // Chipselect 3, NOR Flash

 　　　　　ethernet@0,0 {
 　　　　　　　compatible = "smc,smc91c111";
 　　　　　　　reg = <0 0 0x1000>;
 　　　　　　　interrupts = < 5 2 >;
 　　　　　};

 　　　　　i2c@1,0 {
 　　　　　　　compatible = "acme,a1234-i2c-bus";
 　　　　　　　#address-cells = <1>;
 　　　　　　　#size-cells = <0>;
 　　　　　　　reg = <1 0 0x1000>;
 　　　　　　　interrupts = < 6 2 >;
 　　　　　　　rtc@58 {
 　　　　　　　　　compatible = "maxim,ds1338";
 　　　　　　　　　reg = <58>;
 　　　　　　　　　interrupts = < 7 3 >;
 　　　　　　　};
 　　　　};

 　　　　flash@2,0 {
 　　　　　　compatible = "samsung,k8f1315ebm", "cfi-flash";
 　　　　　　reg = <2 0 0x4000000>;
 　　　　};
 　　};// end of external-bus
};
```

## Device Tree 的解析

device 包含 “of_node” 属性，其类型为“struct device_node*”，通过 dev_of_node(device) 可获得该 of_node。of_node 代表了该设备在设备树中所对应的节点。各 driver 可以使用内核 API 结合 of_node 属性自行解析设备树中对应的资源。

### device_node 结构体

Linux 内核中使用 device_node 结构体来描述一个节点，此结构体定义在文件 include/linux/of.h 中，定义如下：

```cpp
struct device_node {
    const char *name;           /* 节点名字 */
    const char *type;           /* 设备类型 */
    phandle phandle;
    const char *full_name;      /* 节点全名 */
    struct fwnode_handle fnode;

    struct property *properties; /* 属性 */
    struct property *deadprops;  /* removes 属性 */
    struct device_node *parend;  /* 父节点 */
    struct device_node *child;   /* 子节点 */
    struct device_node *sibling;
    struct kobject kobj;
    ...
};
```

### property 结构体

Linux 内核中使用 struct property 结构体来表示属性，定义如下：

```cpp
struct property {
    char *name; //属性名字
    int length; //属性长度
    void *value; //属性值
    struct property *next;//下一个属性
    unsigned long _flags;
    unsigned int unique_id;
    struct bin_attribute attr;
};
```

### 常用 OF 函数

#### of_find_node_by_name 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
struct device_node *of_find_node_by_name(struct device_node *from, const char *name);
```

**说明：**

通过节点名字查找指定的节点。

**参数：**

from：开始查找的节点，如果为 NULL 表示从根节点开始查找整个设备树；

name：要查找的节点名字。

**返回值：**

成功则返回找到的节点，失败返回 NULL。

#### of_find_node_by_type 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
struct device_node *of_find_node_by_type(struct device_node *from, const char *type);
```

**说明：**

通过 device_type 属性查找指定的节点。

**参数：**

from：开始查找的节点，如果为 NULL 表示从根节点开始查找整个设备树；

type：要查找的节点对应的字符串，也就是 device_type 属性值。

**返回值：**

成功则返回找到的节点，失败返回 NULL。

#### of_find_compatible_node 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
struct device_node *of_find_compatible_node(struct device_node *from, const struct of_device_id *matches, const struct of_device_id **match);
```

**说明：**

根据 device_type 和 compatible 这两个属性查找指定的节点。

**参数：**

from：开始查找的节点，如果为 NULL 表示从根节点开始查找整个设备树；

matches：of_device_id 匹配表，也就是在此匹配表里面查找节点；

match：找到的匹配的 of_device_id。

**返回值：**

成功则返回找到的节点，失败返回 NULL。

### of_find_matching_node 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
struct device_node *of_find_matching_node(struct device_node *from, const struct of_device_id *matches);
```

**说明：**

通过 compatible 属性查找指定节点。

**参数：**

from：指向开始路径的节点，如果为NULL，则从根节点开始；
matches：指向设备ID表，注意ID表必须以NULL结束。

**返回值：**

成功：得到节点的首地址；

失败：NULL。

#### of_find_node_by_path 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
inline struct device_node *of_find_node_by_path(const char *path);
```

**说明：**

通过路径来查找指定的节点。

**参数：**

path：带有全路径的节点名。

**返回值：**

成功则返回找到的节点，失败返回 NULL。

#### of_get_parent 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
struct device_node *of_get_parent(const struct device_node *node);
```

**说明：**

用于获取指定节点的父节点(如果有父节点的话)。

**参数：**

node：子节点。

**返回值：**

成功则返回找到的父节点，失败返回 NULL。

#### of_get_next_child 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
struct device_node *of_get_next_child(const struct device_node *node, struct device_node *prev);
```

**说明：**

查找谋节点的子节点。

**参数：**

node：父节点；

prev：前一个子节点，也就是从哪一个子节点开始的下一个子节点，如果为 NULL 表示从第一个子节点开始。

**返回值：**

成功则返回找到的下一个子节点，失败返回 NULL。

#### of_find_property 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
struct property *of_find_property(const struct device_node *np, const char *name, int *lenp);
```

**说明：**

通过属性名称查找指定的属性

**参数：**

np：设备节点；

name：属性名字；

lenp：返回属性值的字节数。

**返回值：**

成功则返回找到的属性，失败返回 NULL。

#### of_get_property 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
const void *of_get_property(const struct device_node *np, const char *name, int *lenp);
```

**说明：**

是 of_find_property 函数的扩展，直接返回 property 的 value 属性。

**参数：**

np：设备节点；

name：属性名字；

lenp：返回属性值的字节数。

**返回值：**

成功则返回找到的 value，失败返回 NULL。

#### of_property_count_elems_of_size 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
int of_property_count_elems_of_size(const struct device_node *np, const char *propname int elem_size);
```

**说明：**

用于获取属性中元素的数量，比如 reg 属性值是一个数组，那么使用此函数可以获取到这个数组的大小。

**参数：**

np：设备节点；

proname：需要统计元素数量的属性名字；

elem_size：元素长度。

**返回值：**

得到的属性元素数量。

#### of_property_read_u32_index 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
int of_property_read_u32_index(const struct device_node *np,
                               const char *propname,
                               u32 index,
                               u32 *out_value);
```

**说明：**

用于从属性中获取指定标号的 u32 类型数据值(无符号 32 位)，比如某个属性有多个 u32 类型的值，那么就可以使用此函数来获取指定标号的数据值。

**参数：**

np：设备节点；

proname：要读取的属性名字；

index：要读取的值标号；

out_value：读取到的值。

**返回值：**

0：读取成功；

负值：读取失败。-EINVAL 表示属性不存在，-ENODATA 表示没有要读取的数据，-EOVERFLOW 表示属性值列表太小。

#### of_property_read_u8 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
int of_property_read_u8(const struct device_node *np,
                        const char *propname,
                        u8 *out_value);
```

**说明：**

用于读取属性只有一个 u8 数据的值。

**参数：**

np：设备节点；

proname：要读取的属性名字；

out_value：读取到的数组值。

**返回值：**

0：读取成功；

负值：读取失败。-EINVAL 表示属性不存在，-ENODATA 表示没有要读取的数据，-EOVERFLOW 表示属性值列表太小。

#### of_property_read_u16 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
int of_property_read_u16(const struct device_node *np,
                        const char *propname,
                        u16 *out_value);
```

**说明：**

用于读取属性只有一个 u16 数据的值。

**参数：**

np：设备节点；

proname：要读取的属性名字；

out_value：读取到的数组值。

**返回值：**

0：读取成功；

负值：读取失败。-EINVAL 表示属性不存在，-ENODATA 表示没有要读取的数据，-EOVERFLOW 表示属性值列表太小。

#### of_property_read_u32 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
int of_property_read_u32(const struct device_node *np,
                        const char *propname,
                        u32 *out_value);
```

**说明：**

用于读取属性只有一个 u32 数据的值。

**参数：**

np：设备节点；

proname：要读取的属性名字；

out_value：读取到的数组值。

**返回值：**

0：读取成功；

负值：读取失败。-EINVAL 表示属性不存在，-ENODATA 表示没有要读取的数据，-EOVERFLOW 表示属性值列表太小。

#### of_property_read_u64 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
int of_property_read_u64(const struct device_node *np,
                        const char *propname,
                        u64 *out_value);
```

**说明：**

用于读取属性只有一个 u64 数据的值。

**参数：**

np：设备节点；

proname：要读取的属性名字；

out_value：读取到的数组值。

**返回值：**

0：读取成功；

负值：读取失败。-EINVAL 表示属性不存在，-ENODATA 表示没有要读取的数据，-EOVERFLOW 表示属性值列表太小。

#### of_property_read_u8_array 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
int of_property_read_u8_array(const struct device_node *np,
                                const char *propname,
                                u8 *out_values,
                                size_t sz);
```

**说明：**

以 u8 数组形式读取属性值。

**参数：**

np：设备节点；

proname：要读取的属性名字；

out_value：读取到的数组值；

sz：要读取的数组元素数量。

**返回值：**

0：读取成功；

负值：读取失败。-EINVAL 表示属性不存在，-ENODATA 表示没有要读取的数据，-EOVERFLOW 表示属性值列表太小。

#### of_property_read_u16_array 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
int of_property_read_u16_array(const struct device_node *np,
                                const char *propname,
                                u16 *out_values,
                                size_t sz);
```

**说明：**

以 u16 数组形式读取属性值。

**参数：**

np：设备节点；

proname：要读取的属性名字；

out_value：读取到的数组值；

sz：要读取的数组元素数量。

**返回值：**

0：读取成功；

负值：读取失败。-EINVAL 表示属性不存在，-ENODATA 表示没有要读取的数据，-EOVERFLOW 表示属性值列表太小。

#### of_property_read_u32_array 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
int of_property_read_u32_array(const struct device_node *np,
                                const char *propname,
                                u32 *out_values,
                                size_t sz);
```

**说明：**

以 u32 数组形式读取属性值。

**参数：**

np：设备节点；

proname：要读取的属性名字；

out_value：读取到的数组值；

sz：要读取的数组元素数量。

**返回值：**

0：读取成功；

负值：读取失败。-EINVAL 表示属性不存在，-ENODATA 表示没有要读取的数据，-EOVERFLOW 表示属性值列表太小。

#### of_property_read_u64_array 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
int of_property_read_u64_array(const struct device_node *np,
                                const char *propname,
                                u64 *out_values,
                                size_t sz);
```

**说明：**

以 u64 数组形式读取属性值。

**参数：**

np：设备节点；

proname：要读取的属性名字；

out_value：读取到的数组值；

sz：要读取的数组元素数量。

**返回值：**

0：读取成功；

负值：读取失败，-EINVAL 表示属性不存在。-ENODATA 表示没有要读取的数据，-EOVERFLOW 表示属性值列表太小。

#### of_property_read_string 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
int of_property_read_string(struct device_node *np,
                            const char *propname,
                            const char **out_string);
```

**说明：**

用于读取属性中字符串值。

**参数：**

np：设备节点；

proname：要读取的属性名字；

out_string：读取到的字符串值。

**返回值：**

0：读取成功；

负值：读取失败。

#### of_property_read_bool 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
static inline bool of_property_read_bool(const struct device_node *np,
                                         const char *propname);
```

**说明：**

用于读取属性中布尔类型数据的值。

**参数：**

np：设备节点；

proname：要读取的属性名字。

**返回值：**

属性存在则返回 true，否则返回 false。

#### of_n_addr_cells 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
int of_n_addr_cells(struct device_node *np);
```

**说明：**

用于获取“#address-cells“属性值。

**参数：**

np：设备节点。

**返回值：**

获取到的“#address-cells”属性值。

#### of_n_size_cells 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
int of_n_size_cells(struct device_node *np);
```

**说明：**

用于获取“#size-cells“属性值。

**参数：**

np：设备节点。

**返回值：**

获取到的“#size-cells”属性值。

#### of_device_is_compatible 函数

**头文件：**

```cpp
#include <linux/of.h>
```

**函数原型：**

```cpp
int of_device_is_compatible(const struct device_node *device,
                            const char *compat);
```

**说明：**

用于查看节点的 compatible 属性是否有包含 compat 指定的字符串，也就是检查设备节点的兼容性。

**参数：**

device：设备节点；

compat：要查看的字符串。

**返回值：**

0：节点的 compatible 属性中不包含 compat 指定的字符串；

正数：节点的 compatible 属性中包含 compat 指定的字符串。

#### of_get_address 函数

**头文件：**

```cpp
#include <linux/of_address.h>
```

**函数原型：**

```cpp
const __be32 *of_get_address(struct device_node *dev,
                            int index,
                            u64 *size,
                            unsigned int *flags);
```

**说明：**

用于获取地址相关属性，主要是“reg”或者“assigned-addresses”属性值。

**参数：**

dev：设备节点；

index：要读取的地址标号；

size：地址长度；

flags：参数，比如 IORESOURCE_IO、IORESOURCE_MEM 等。

**返回值：**

成功则返回读取到的地址数据首地址，失败返回 NULL。

#### of_translate_address 函数

**头文件：**

```cpp
#include <linux/of_address.h>
```

**函数原型：**

```cpp
u64 of_translate_address(struct device_node *dev,const __be32 *in_addr);
```

**说明：**

将从设备树读取到的地址转换为物理地址。

**参数：**

dev：设备节点；

in_addr：要转换的地址。

**返回值：**

成功则返回转换得到的物理地址，失败返回 OF_BAD_ADDR。

#### of_address_to_resource 函数

**头文件：**

```cpp
#include <linux/of_address.h>
```

**函数原型：**

```cpp
int of_address_to_resource(struct device_node *dev,
                            int index,
                            struct resource *r);
```

**说明：**

根据索引号从设备树中获取“reg”这一类的地址资源。

**参数：**

dev：设备节点；

index：地址资源索引号；

r：得到的 resource 类型的资源值。

**返回值：**

0：成功；

负值：失败。

#### of_iomap 函数

**头文件：**

```cpp
#include <linux/of_address.h>
```

**函数原型：**

```cpp
void __iomem *of_iomap(struct device_node *np, int index);
```

**说明：**

通过设备结点的“reg”字段直接进行设备内存区间的 ioremap()。

**参数：**

np：设备节点；

index：reg 属性中要完成内存映射的段，如果 reg 属性只有一段的话 index 就设置为 0。

**返回值：**

成功则返回经过内存映射后的虚拟内存首地址，失败返回 NULL。

#### of_io_request_and_map 函数

**头文件：**

```cpp
#include <linux/of_address.h>
```

**函数原型：**

```cpp
void __iomem *of_io_request_and_map(struct device_node *np, int index, const char *name);
```

**说明：**

提取 I/O 口地址并申请 I/O 资源及映射成虚拟地址。

**参数：**

np：设备节点；

index：reg 属性中要完成内存映射的段，如果 reg 属性只有一段的话 index 就设置为 0；

name：设备名，申请 I/O 地址时使用。

**返回值：**

成功：映射好虚拟地址；

失败：NULL

#### of_get_named_gpio 函数

**头文件：**

```cpp
#include <linux/of_gpio.h>
```

**函数原型：**

```cpp
int of_get_named_gpio(struct device_node *np, const char *propname, int index);
```

**说明：**

从设备树中提取gpio口。

**参数：**

dev：设备节点；

propname：属性名；

index：gpio 口引脚标号。

**返回值：**

成功：得到 GPIO 口编号；

失败：负数，绝对值是错误码。

#### irq_of_parse_and_map 函数

**头文件：**

```cpp
#include <linux/of_irq.h>
```

**函数原型：**

```cpp
unsigned int irq_of_parse_and_map(struct device_node *node, int index);
```

**说明：**

从设备树的 interrupt 字段解析出中断号，如果有多个中断则通过 index 来指定。

**参数：**

node：设备节点；

index：用于指定要解析中断的段，如果只有一段的话，就设置为 0。

**返回值：**

成功则返回解析的中断号，失败返回 0。

#### of_irq_count 函数

**头文件：**

```cpp
#include <linux/of_irq.h>
```

**函数原型：**

```cpp
int of_irq_count(struct device_node *np);
```

**说明：**

从设备树中提取中断的数量。

**参数：**

np：设备节点。

**返回值：**

成功：大于等于0，实际中断数量；

0：表示没有中断。

#### of_irq_get 函数

**头文件：**

```cpp
#include <linux/of_irq.h>
```

**函数原型：**

```cpp
int of_irq_get(struct device_node *np, int index);
```

**说明：**

从设备树中提取中断号。

**参数：**

np：设备节点；

index：要提取的中断号的标号。

**返回值：**

成功：中断号；

失败：负数，其绝对值是错误码。

#### of_get_mac_address 函数

**头文件：**

```cpp
#include <linux/of_net.h>
```

**函数原型：**

```cpp
void *of_get_mac_address(struct device_node *np);
```

**说明：**

从设备树中提取 MAC 地址。

**参数：**

np：设备节点；

**返回值：**

成功：MAC（6字节）的首地址；

失败：NULL。

#### of_find_device_by_node 函数

**头文件：**

```cpp
#include <linux/of_platform.h>
```

**函数原型：**

```cpp
struct platform_device *of_find_device_by_node(struct device_node *np);
```

**说明：**

获取与节点对应的 platform_device。

**参数：**

node：设备节点。

**返回值：**

成功则返回 platform_device 指针，失败返回 NULL。