简介
DTS文件
用来描述设备树文件，也就是开发板上的设备信息
设备树的引用原因
以LED驱动为例，如果你要更换LED所用的GPIO引脚，需要修改驱动程序源码、重新编译驱动、重新加载驱动。
在内核中，使用同一个芯片的板子，它们所用的外设资源不一样，比如A板用GPIO A，B板用GPIO B。而GPIO的驱动程序既支持GPIO A也支持GPIO B，你需要指定使用哪一个引脚，怎么指定？在.c文件中指定。
随着ARM芯片的流行，内核中针对这些ARM板保存有大量的、没有技术含量的文件（上述的指定资源的.c文件）。
Linus大发雷霆：“this whole ARM thing is a f*cking pain in the ass”。
于是，Linux内核开始引入设备树。设备树并不是重新发明出来的，在Linux内核中其他平台如PowerPC，早就使用设备树来描述硬件了。
Linus发火之后，内核开始全面使用设备树来改造，神人就神人。
/sys/firmware/devicetree目录下是以目录结构程现的dtb文件, 根节点对应base目录, 每一个节点对应一个目录, 每一个属性对应一个文件。
这些属性的值如果是字符串，可以用cat命令把它打印出来；对于数值，可以用hexdump把它打印出来。
一个单板启动时，u-boot先运行，它的作用是启动内核。U-boot会把内核和设备树文件都读入内存，然后启动内核。在启动内核时会把设备树在内存中的地址告诉内核。
设备树名词关系
DTS：设备树源码文件
DTB：DTS编译得到的二进制文件
DTS —> DTB 需要用到DTC编译工具
DTC 工具源码在 Linux 内核的 scripts/dtc 目录下.另外dtsi就相当于C语言的.h文件的概念
dtsi文件：设备树模板，一般 dts 文件可以 include 包含 dtsi 文件，类似于头文件
设备树语法
Device格式
DTS文件格式
/dts-v1/; // 表示版本
[memory reservations] // 格式为: /memreserve/ <address> <length>;
/ {
[property definitions]
[child nodes]
};
node格式
设备树中的基本单元，被称为“node”，其格式为：
[label:] node-name[@unit-address] { // unit-address 寄存器/设备地址
[properties definitions]
[child nodes]
};
label是标号，可以省略，作用是方便引用node，比如：
/dts-v1/;
/ {
uart0: uart@fe001000 {
compatible="ns16550";
reg=<0xfe001000 0x100>;
};
};
可以使用下面 2 种方法来修改 uart@fe001000 这个 node：
- 标签
- 全路径
// 在根节点之外使用 label 引用 node：
&uart0 {
status = “disabled”; // 状态设为 disabled 那么这个节点的定义就会失效
};
或在根节点之外使用全路径：
&{/uart@fe001000} {
status = “disabled”;
};
常用属性（propertics）
value表示
properties就是“property-name = value”，value有多种取值方式
property格式1：
[label:] property-name = value;
property格式2（没有值）：
[label:] property-name
property的取值只有4种
1. arrays of cells(1 个或多个 32 位数据, 64 位数据使用 2 个 32 位数据表示),
2. string(字符串),
3. bytestring(1 个或多个字节)
4. 各种值的组合
-
arrays of cells (cell就是一个32位数据，64位数据用两个cell表示)
用尖括号包围起来
interrupts = <17 0xc> // 两个32位数据 interrupts = <0x00000001 0x00000000> // 一个64位数据 -
A null-terminated string (有结束符的字符串)，用双引号包围起来
compatible = "simple-bus"; -
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";
1.#address-cells、size-cells
cell指一个32位的数值
address-cells：address要用多少个32位数来表示
size-cells：size要用多少个32位数来表示
表示这个节点下一级节点的地址属性要如何表示
/ {
#address-cells = <1>;
#size-cells = <1>;
memory {
reg = <0x80000000 0x20000000>;
};
};
// reg中第一个32位数据表示这块内存的起始地址
// 第二个32位数据表示这块内存的大小
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结构体，执行其中的初始化函数。
compatible的值，建议取这样的形式：“manufacturer,model”，即“厂家名,模块名”。
比如：compatible = “fsl,imx6ull-gpmi-nand”, “fsl, imx6ul-gpmi-nand”;
3.model
compatible属性是一个字符串列表，表示可以你的硬件兼容A、B、C等驱动；
model用来准确地定义这个硬件是什么。
/ {
compatible = "samsung,smdk2440", "samsung,mini2440";
model = "jz2440_v3";
};
它表示这个单板，可以兼容内核中的“smdk2440”，也兼容“mini2440”。
从compatible属性中可以知道它兼容哪些板，但是它到底是什么板？用model属性来明确。
4.status
dtsi 文件中定义了很多设备，但是在你的板子上某些设备是没有的。这时你可以给这个
设备节点添加一个 status 属性，设置为“disabled”
&uart1 {
status = "disabled";
};
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>;
};
};
6.name（一般不用）
它的值是字符串，用来表示节点的名字。在跟platform_driver匹配时，优先级最低。
compatible属性在匹配过程中，优先级最高。
7.device_type(一般不用)
它的值是字符串，用来表示节点的类型。在跟platform_driver匹配时，优先级为中。
compatible属性在匹配过程中，优先级最高。
常用节点
1.根节点
dts文件必须有1个根节点
/dts-v1/;
/ {
model = "SMDK24440";
compatible = "samsung,smdk2440";
#address-cells = <1>;
#size-cells = <1>;
};
根节点中必须有这些属性
#address-cells // 在它的子节点的reg属性中, 使用多少个u32整数来描述地址
#size-cells // 在它的子节点的reg属性中, 使用多少个u32整数来描述大小
compatible // 定义一系列的字符串, 用来指定内核中哪个machine_desc可以支持本设备
// 即这个板子兼容哪些平台
// uImage : smdk2410 smdk2440 mini2440 ==> machine_desc
model // 咱这个板子是什么
// 比如有2款板子配置基本一致, 它们的compatible是一样的
// 那么就通过model来分辨这2款板子
2.CPU节点
一般不需要我们设置，在dtsi文件中都定义好了：
cpus {
#address-cells = <1>;
#size-cells = <0>;
cpu0: cpu@0 {
.......
}
};
3.memory节点
芯片厂家不可能事先确定你的板子使用多大的内存，所以memory节点需要板厂设置，比如：
memory {
reg = <0x80000000 0x20000000>;
};
4.chosen节点
我们可以通过设备树文件给内核传入一些参数，这要在chosen节点中设置bootargs属性：
chosen {
bootargs = "noinitrd root=/dev/mtdblock4 rw init=/linuxrc console=ttySAC0,115200";
};
5.aliases子节点
aliases的意思是 ” 别名 “，因此aliases节点的主要功能就是定义别名，定义别名的目的就是为了方便访问节点
aliases {
can0 = &flexcan1;
can1 = &flexcan2;
ethernet0 = &fec1;
ethernet1 = &fec2;
gpio0 = &gpio1;
gpio1 = &gpio2;
....
spi0 = &ecspi1;
spi1 = &ecspi2;
spi2 = &ecspi3;
spi3 = &ecspi4;
usbphy0 = &usbphy1;
usbphy1 = &usbphy2;
};
编译、更换设备树文件
对于IMX6ULL：
内核中设备树文件的位置
/home/book/100ask_imx6ull-sdk/Linux-4.9.88/arch/arm/boot/dts/100ask_imx6ull-14x14.dts
板子中设备树文件的位置
/boot
- 在dts文件中编写
- 在内核目录中 make dtbs
- 将生成的 dtb 文件复制到板子的对应文件目录
- 重启开发板
内核对设备树的处理
- dts文件在pc机上被编译成dtb文件
- u-boot把dtb文件传给内核
- 内核解析dtb文件，把每一个节点都转换成device_node结构体
- 对于某些device_node结构体，会被转换为platform_device结构体
根节点被保存在全局变量of_root中，从of_root开始可以访问到任意节点
设备树节点 -> platform_device的条件
A. 根节点下含有 compatile 属性的子节点
B. 含有特定 compatile 属性的节点的子节点
如果一个节点的 compatile 属性，它的值是这 4 者之一：" simple-bus " , " simple-mfd " , " isa " , " arm,amba-bus ",
那么它的子结点(需含 compatile 属性)也可以转换为 platform_device
C. 总线 I2C、SPI 节点下的子节点：不转换为 platform_device
某个总线下到子节点，应该交给对应的总线驱动程序来处理, 它们不应该被转换为platform_device
怎么转换为platform_device
内核处理设备树的函数调用过程，这里不去分析；我们只需要得到如下结论：
A. platform_device 中含有 resource 数组, 它来自 device_node 的 reg, interrupts 属性;
B. platform_device.dev.of_node 指向 device_node, 可以通过它获得其他属性
platform_device如何与platform_driver配对
struct device 结构体下的 struct device_node 结构体是对于一个DTS中节点对应的内存中设备的描述，一般此对象代表一个设备（一般定义的像led的引脚数据就保存在这个结构体里面）
每当有platform_device或platform_driver写入内核时，总线都会调用.match去查找对应关系，找到后调用platform_driver中的.probe函数
-
最先比较：是否强制选择某个driver
比较 platform_device. driver_override 和 platform_driver.driver.name
-
比较设备树信息
比较：platform_device. dev.of_node
和 platform_driver.driver.of_match_table（一个数组，支持那些设备）
-
接下来比较：platform_device_id
比较platform_device. name和platform_driver.id_table[i].name
-
最后比较：platform_device.name 和 platform_driver.driver.name
内核中操作设备树的常用函数
/home/book/100ask_imx6ull-sdk/Linux-4.9.88/include/linux
这个目录下有很多of开头的头文件，它们中保存着相关函数
-
处理DTB
of_fdt.h // dtb 文件的相关操作函数, 我们一般用不到,
// 因为 dtb 文件在内核中已经被转换为 device_node 树(它更易于使用) -
处理device_node
of.h // 提供设备树的一般处理函数,
// 比如 of_property_read_u32(读取某个属性的 u32 值),
// of_get_child_count(获取某个 device_node 的子节点数)
of_address.h // 地址相关的函数,
// 比如 of_get_address(获得 reg 属性中的 addr, size 值)
// of_match_device (从 matches 数组中取出与当前设备最匹配的一项)
of_dma.h // 设备树中 DMA 相关属性的函数
of_gpio.h // GPIO 相关的函数
of_graph.h // GPU 相关驱动中用到的函数, 从设备树中获得 GPU 信息
of_iommu.h // 很少用到
of_irq.h // 中断相关的函数
of_mdio.h // MDIO (Ethernet PHY) API
of_net.h // OF helpers for network devices.
of_pci.h // PCI 相关函数
of_pdt.h // 很少用到
of_reserved_mem.h // reserved_mem 的相关函数 -
处理platform_device
of_platform.h // 把 device_node 转换为 platform_device 时用到的函数,
// 比如 of_device_alloc(根据 device_node 分配设置 platform_device),
// of_find_device_by_node (根据 device_node 查找到 platform_device),
// of_platform_bus_probe (处理 device_node 及它的子节点)
of_device.h // 设备相关的函数, 比如 of_match_device
platform_device相关函数
of_platform.h 中声明了很多函数，但是作为驱动开发者，我们只使用其中的 1、2 个
其他的都是给内核自己使用的，内核使用它们来处理设备树，转换得到 platform_device
of_find_device_by_node
extern struct platform_device *of_find_device_by_node(struct device_node *np);
设备树中的每一个节点，在内核里都有一个 device_node；你可以使用 device_node 去找到对应的 platform_device。
platform_get_resource
struct resource *platform_get_resource(struct platform_device *dev,unsigned int type, unsigned int num)
这个函数跟设备树没什么关系，但是设备树中的节点被转换为 platform_device 后，设备树中的 reg 属性、interrupts 属性也会被转换为“resource”，这时，你可以使用这个函数取出这些资源
dev：platform device
type：resouce type // 取哪种类型的资源
num：resource index // 这类资源中的哪一个
对于设备树节点中的 reg 属性，它属性 IORESOURCE_MEM 类型的资源
对于设备树节点中的 interrupts 属性，它属性 IORESOURCE_IRQ 类型的资源
访问不能转换为platform_device的节点
内核会把 dtb 文件解析出一系列的 device_node 结构体，我们可以直接访问这些
device_node
找到节点
of_find_node_by_path
static inline struct device_node *of_find_node_by_path(const char *path);
根据路径找到对应的platform_node，比如 “ / ” 对应根节点，“ /memory ” 对应 memory节点
of_find_node_by_name
extern struct device_node *of_find_node_by_name(struct device_node *from,const char *name);
节点如果定义了name属性，则可以根据名字找到节点
但是name属性不建议使用
of_find_node_by_type
extern struct device_node *of_find_node_by_type(struct device_node *from,const char *type);
节点如果定义了device_type属性，则可以根据类型找到节点
from：从哪一个节点开始查找，NULL代表从根节点开始
但是device_type不建议使用
of_find_compatible_node
extern struct device_node *of_find_compatible_node(struct device_node *from,const char *type, const char *compat);
节点如果定义了compatible属性，则可以根据compatible属性找到节点
参数 from 表示从哪一个节点开始寻找，传入 NULL 表示从根节点开始寻找
参数 compat 是一个字符串，用来指定 compatible 属性的值；
参数 type 是一个字符串，用来指定 device_type 属性的值，可以传入 NULL
of_find_node_by_phandle
根据 phandle （数字ID）找到节点
dts 文件被编译为 dtb 文件时，每一个节点都有一个数字 ID，这些数字 ID 彼此不同
可以使用数字 ID 来找到 device_node。这些数字 ID 就是 phandle
extern struct device_node *of_find_node_by_phandle(phandle handle);
of_get_parent
找到device_node的父节点
extern struct device_node *of_get_parent(const struct device_node *node);
of_get_next_parent
extern struct device_node *of_get_next_parent(struct device_node *node);
和of_get_parent的返回值是一样的
差别在于它多调用一些函数，把 node 节点的引用计数减少了 1。这意味着调用
of_get_next_parent 之后，你不再需要调用 of_node_put 释放 node 节点
of_get_next_child
取出下一个子节点
prev 表示上一个子节点，设为 NULL 时表示想找到第 1 个子节点
不断调用 of_get_next_child 时，不断更新 pre 参数，就可以得到所有的子节点
extern struct device_node *of_get_next_child(const struct device_node *node,struct device_node *prev);
of_get_next_available_child
参数 node 表示父节点
prev 表示上一个子节点，设为 NULL 时表示想找到第 1 个子节点
取出下一个“可用”的子节点，有些节点的 status 是“disabled”，那就会跳过这些节点
struct device_node *of_get_next_available_child(const struct device_node *node,struct device_node *prev);
of_get_child_by_name
根据名字取出子节点
extern struct device_node *of_get_child_by_name(const struct device_node *node,const char *name);
参数 node 表示父节点
name 表示子节点的名字
找到属性
of_find_property
找到节点中的属性
extern struct property *of_find_property(const struct device_node *np,const char *name,int *lenp);
np：节点
name：属性的名字
lenp：用来保存这个属性的长度，值的长度
获取属性的值
of_get_property
根据名字返回节点的属性，并且返回它的值
const void *of_get_property(const struct device_node *np, const char *name,int *lenp)
np：节点
name：属性的名字
lenp：用来保存这个属性的长度，值的长度
of_property_count_elems_of_size
根据名字找到节点的属性，确定它的值有多少个元素（elem）
int of_property_count_elems_of_size(const struct device_node *np,const char *propname, int elem_size)
np：节点
propname：属性的名字
elem_size：元素的大小（字节）
return：属性值的字节数 / 元素的大小
xxx_node {
xxx_pp_name = <0x50000000 1024> <0x60000000 2048>;
}
调用 of_property_count_elems_of_size(np, “xxx_pp_name”, 8)时，返回值是 2
调用 of_property_count_elems_of_size(np, “xxx_pp_name”, 4)时，返回值是 4
读整数 u32/u64
static inline int of_property_read_u32(const struct device_node *np,const char *propname,u32 *out_value);
extern int of_property_read_u64(const struct device_node *np,const char *propname, u64 *out_value);
在设备树中，节点大概是这样：
xxx_node {
name1 = <0x50000000>;
name2 = <0x50000000 0x60000000>;
};
调用 of_property_read_u32 (np, “name1”, &val)时，val 将得到值 0x50000000
调用 of_property_read_u64 (np, “name2”, &val)时，val 将得到值 0x0x6000000050000000
读某个整数
extern int of_property_read_u32_index(const struct device_node *np,const char *propname,u32 index, u32 *out_value);
xxx_node {
name2 = <0x50000000 0x60000000>;
};
调用 of_property_read_u32 (np, “name2”, 1, &val)时，val 将得到值 0x0x60000000
读字符串
int of_property_read_string(const struct device_node *np, const char *propname,const char **out_string);
返回节点 np 的属性(名为 propname)的值，(*out_string)指向这个值，把它当作字符串
// 将数据的每8位作为一组
int of_property_read_variable_u8_array(const struct device_node *np,const char *propname, u8 *out_values,size_t sz_min, size_t sz_max);
// 将数据的每16位作为一组
int of_property_read_variable_u16_array(const struct device_node *np,const char *propname, u16 *out_values,size_t sz_min, size_t sz_max);
// 将数据的每32位作为一组
int of_property_read_variable_u32_array(const struct device_node *np,const char *propname, u32 *out_values,size_t sz_min, size_t sz_max);
// 将数据的每64位作为一组
int of_property_read_variable_u64_array(const struct device_node *np,const char *propname, u64 *out_values,size_t sz_min, size_t sz_max);
xxx_node {
name2 = <0x50000012 0x60000034>;
};
of_property_read_variable_u8_array(xxx_node, name2, out_values, 1, 10);
out_value中会保留0x12,0x00,0x00,0x50,0x34,0x00,0x00,0x60这8组八位数据（数量介于1~10）
of_property_read_variable_u16_array(xxx_node, name2, out_values, 1, 10);
out_value中会保留0x0012,0x5000,0x0034,0x6000这4组十六位数据（数量介于1~10）
of_property_read_variable_u32_array(xxx_node, name2, out_values, 1, 10);
out_value中会保留0x50000012 0x60000034这2组三十二位数据（数量介于1~10）
of_property_read_variable_u60_array(xxx_node, name2, out_values, 1, 10);
out_value中会保留0x5000001260000034这1组六十四位数据
总之，这些函数要么能取到全部的数值，要么一个数值都取不到；
如果值的长度在 sz_min 和 sz_max 之间，就返回全部的数值；否则一个数值都不返回。
扫一扫
746
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
