背景
在Linux内核没有引进设备树之前，每一个具体的硬件平台都会在 linux 源码包 arch/arm/mach-xxx/ 目录下存在一个硬件信息描述的源码包，其中定义了 GPIO、I2C 等外设和系统信息。这些信息也定义为 .h、.c 文件，内容多为描述设备信息的结构体，同驱动源码一起编译。这就会在内核中增加了许多没有技术含量的.c文件。Linux的祖师爷Linus看到这种现象后就大发雷霆："this whole ARM thing is a f*cking pain in the ass"，所以为了解决这种现象，从linux-3.x版本开始引进了设备树。
什么是设备树？
设备树（Device Tree）将这个词分开就是“设备”和“树”，描述设备树的文件叫做 DTS(DeviceTree Source)，这个 DTS 文件采用树形结构描述板级设备，也就是开发板上的设备信息，比如CPU 数量、 内存基地址、IIC 接口上接了哪些设备、SPI 接口上接了哪些设备等等。 在Linux内核源码中，ARM架构的设备树文件一般位于 linux 源码的 arch/arm/boot/dts 目录，对应 .dts(device tree source) 后缀的文件。dts 文件可以通过make dtbs 命令编译成 .dtb(device tree blob) 后缀的二进制文件，以供内核驱动使用。
概念
dts (device tree source)
设备树描述文件，硬件的相应信息都会写在.dts为后缀的文件中，每一款硬件可以单独写一份xxxx.dts，一般在Linux源码中存在大量的dts文件，对于 arm 架构可以在 arch/arm/boot/dts 目录下找到相应dts文件。
dtsi (device tree sourceinclude)
设备树头文件，对于一些相同的dts配置可以抽象到dtsi文件中，然后类似于 C 语言的方式可以include到dts文件中，对于同一个节点的设置情况，dts中的配置会覆盖dtsi中的配置；dtsi是关于芯片级别的描述。
dtc (device tree compiler)
设备树编译器，编写 .dtc 使用设备树语法，则需要一个特定的编译器来编译，称为dtc工具，源码在 Linux 内核的 scripts/dtc 目录下。
dtb (device tree blob)
dts 编译后的二进制文件，内核使用的是dtb文件。
设备树语法
-
设备树版本
/dts-v1/-
设备树节点(node)格式
设备树是由一个个节点组成的，每个节点相当于树上的一片叶子，节点的结构和约定如下。
[label:] node-name[@unit-address] {
[properties definitions]
[child nodes]
};
label是标号，可以省略。label的作用是为了方便地引用节点；node-name是节点名字，用于全路径引用节点；unit-address表示设备地址或者寄存器首地址（具体节点具体分析，不一定是绝对地址），必须与节点 reg 属性中指定的首地址匹配。
eg. imx6ull.dtsi 中描述的 uart1 控制器节点：
该节点 label 为 uart1，节点名称为 serial，设备地址（寄存器首地址）为 02020000，正是 imx6ull uart1 外设寄存器的首地址。
引用节点的两种方式如下：
节点示例：
/dts-v1/;
/ {
uart0: uart@fe001000 {
compatible="fsl,imx6ul-uart";
reg=<0xfe001000 0x100>;
};
};
- 通过label引用
// 在根节点之外使用label引用node： &uart0 { status = “disabled”; }; -
通过指定从根节点到所有子节点到所需节点的完整路径，可以唯一地标识设备树中的节点
在根节点之外使用全路径： &{/uart@fe001000} { status = “disabled”; };
-
节点属性
节点属性的格式：
简单地说，properties就是“name=value”，value有多种取值方式。
格式一：
[label:] property-name = value; //有值
格式二：
[label:] property-name; //无值value的取值方式：
a. Arrays of cells : cell就是一个32位的数据，用尖括号包围起来
interrupts = <17 0xc>;
b. 64bit数据使用2个cell来表示，用尖括号包围起来:
clock-frequency = <0x00000001 0x00000000>;
c. A null-terminated string (有结束符的字符串)，用双引号包围起来:
compatible = "simple-bus";
d. A bytestring(字节序列) ，用中括号包围起来:
local-mac-address = [00 00 12 34 56 78]; // 每个byte使用2个16进制数来表示
local-mac-address = [000012345678]; // 每个byte使用2个16进制数来表示
e. 可以是各种值的组合, 用逗号隔开:
compatible = "ns16550", "ns8250";
example = <0xf00f0000 19>, "a strange property format";
常用属性：
- #address-cells、#size-cells
cell指一个32位的数值，
address-cells：address要用多少个32位数来表示；
size-cells：size要用多少个32位数来表示。
示例：
/ {
#address-cells = <1>;
#size-cells = <1>;
memory {
reg = <0x80000000 0x20000000>;
};
};
上述例子描述了内存的大小，address-cells为1，所以reg中用1个数来表示地址，即用0x80000000来表示地址；size-cells为1，所以reg中用1个数来表示大小，即用0x20000000表示大小：
- compatible
compatible 属性值由 string list 组成，定义了设备的兼容性，compatible的值，建议取这样的形式："manufacturer,model"，即“厂家名,模块名”。
compatible = "fsl,imx6ull-14x14-evk", "fsl,imx6ull";示例
led {
compatible = “A”, “B”, “C”;
};
对于某个LED，内核中可能有A、B、C三个驱动都支持它，内核启动时，就会为这个LED按这样的优先顺序为它找到驱动程序：A、B、C。
一般驱动程序文件都会有一个 OF 匹配表，此 OF 匹配表保存着一些 compatible 值，如果设备节点的 compatible 属性值核 OF 匹配表中的任何一个值相等，那么就表示这个设备可以使用这个驱动。比如在文件imx-wm8960.c文件中：
static const struct of_device_id imx_wm8960_dt_ids[] = {
{ .compatible = "fsl,imx-audio-wm8960", },
{ /* sentinel */ }
};这个数组就是imx-wm8960.c这个驱动文件的匹配表。
- model
model 属性值是一个 string，model属性与compatible属性有些类似，但是有差别。compatible属性是一个字符串列表，表示可以你的硬件兼容A、B、C等驱动；model用来准确地定义这个硬件是什么。
比如根节点中可以这样写：
/ {
compatible = "samsung,smdk2440", "samsung,mini2440";
model = "jz2440_v3";
};
它表示这个单板，可以兼容内核中的“smdk2440”，也兼容“mini2440”。从compatible属性中可以知道它兼容哪些板，但是它到底是什么板？用model属性来明确，model属性指明了设备的厂商和型号。
- status
status 属性值是一个 string，表示设备的运行状态，dtsi文件中定义了很多设备，但是在你的板子上某些设备是没有的。这时你可以给这个设备节点添加一个status属性，设置为 "disabled"
&uart1 {
status = "disabled";
};
status 属性可用值如下表:
- reg
reg 属性值是一个 prop-encoded-array，用来描述设备地址空间资源信息，一般是某个外设的寄存器地址范围信息，包括起始地址和地址长度。
reg = <address1 length1 address2 length2 address3 length3……>reg属性的值，是一系列的“address size”，用多少个32位的数来表示address和size，由其父节点的#address-cells、#size-cells决定。
示例:
/dts-v1/;
/ {
#address-cells = <1>;
#size-cells = <1>;
memory {
reg = <0x80000000 0x20000000>;
};
};
常用节点
- 根节点
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款板子*/
- CPU节点
一般不需要我们设置，在dtsi文件中都定义好了：
cpus {
#address-cells = <1>;
#size-cells = <0>;
cpu0: cpu@0 {
.......
}
};
- memory节点
芯片厂家不可能事先确定你的板子使用多大的内存，所以memory节点需要板厂设置，比如：
memory {
reg = <0x80000000 0x20000000>;
};
- chosen 节点
chosen 节点是为了uboot 向 Linux 内核传递数据，重点是 bootargs 参数，一般.dts 文件中 chosen 节点通常为空或者内容很少。
chosen {
bootargs = "noinitrd root=/dev/mtdblock4 rw init=/linuxrc console=ttySAC0,115200";
};
向节点追加内容
- 向根节点追加内容
/ {
//要补充的内容
};- 向子节点追加内容
&node-label {
//追加内容
};设备树编译
- 简单粗暴，编译内核
make - 编译全部设备树文件
make dtbs - 编译指定的设备树文件
make <xxx.dtb>
内核对设备树的处理
从设备树dts源文件开始，处理过程如下：
- dts在PC机上被编译为dtb文件；
- u-boot把dtb文件传给内核解析，内核将每个设备树节点解析为struct device_node 结构体；
- 对于某些device_node结构体，会被转换为platform_device结构体。
- note
设备树的根节点被保存在全局变量of_root中，从of_root中可以访问到任意节点
- struct device_node 结构体
struct device_node {
const char *name; //来自设备树节点的name属性
const char *type; //来自设备树节点的device_type属性
phandle phandle;
char *full_name; //节点全名
struct property *properties; //含有设备树节点的compatible属性
struct property *deadprops; /* removed properties */
struct device_node *parent;
struct device_node *child;
struct device_node *sibling;
struct device_node *next; /* next device of same type */
struct device_node *allnext; /* next in list of all nodes */
struct proc_dir_entry *pde; /* this node's proc directory */
struct kref kref;
unsigned long _flags;
void *data;
#if defined(CONFIG_SPARC)
char *path_component_name;
unsigned int unique_id;
struct of_irq_controller *irq_trans;
#endif
};- struct property 结构体
struct property {
char *name; //属性名字 compatible 就是属性名字
int length; //属性长度 compatible = "test" 长度为5
void *value; //属性值 t例如 test
struct property *next; //下一个属性
unsigned long _flags;
unsigned int unique_id;
};哪些device_node可以被转换成platform_device结构体？
- 根节点下含有compatile属性的子节点
- 根节点下含有特定compatile属性的节点的子节点
如果一个节点的compatile属性，它的值是这4者之一："simple--bus"、"simple-mfd"、"isa"、"arm,amba-bus"。那么它的子结点(需含compatile属性)也可以转换为platform_device。
- 总线I2C、SPI节点可以转换成platform_device，但它们的子节点：不转换为platform_device。
示例：
/ {
mytest {
compatile = "mytest", "simple-bus";
mytest@0 {
compatile = "mytest_0";
};
};
i2c {
compatile = "samsung,i2c";
at24c02 {
compatile = "at24c02";
};
};
spi {
compatile = "samsung,spi";
flash@0 {
compatible = "winbond,w25q32dw";
spi-max-frequency = <25000000>;
reg = <0>;
};
};
};
/mytest会被转换为platform_device；因为它兼容"simple-bus"，所以它的子节点 /mytest/mytest@0 也会被转换为platform_device。
/i2c节点一般表示 i2c 控制器, 它会被转换为 platform_device, 在内核中有对应的platform_driver；它的子节点 /i2c/at24c02 节点不会被转换为 platform_device，它被如何处理完全由父节点的platform_driver决定，一般是被创建为一个i2c_client。
类似的也有 /spi 节点，它一般也是用来表示SPI控制器，它会被转换为 platform_device，在内核中有对应的 platform_driver；它的子节点 /spi/flash@0 节点不会被转换为 platform_device，它被如何处理完全由父节点的platform_driver决定，一般是被创建为一个spi_device。
note:
- platform_device中含有resource数组, 它来自device_node的reg, interrupts属性;
-
struct platform_device里面有struct device，struct device里面有struct device_node ；platform_device.dev.of_node指向device_node, 可以通过它获得设备树其他属性。
由设备树节点转换得到的platform_device如何与platform_driver配对？
从设备树转换得来的platform_device会被注册进内核里，以后当我们每注册一个platform_driver时，它们就会两两确定能否配对，如果能配对成功就调用platform_driver的probe函数，注册和匹配的具体流程可看一下我之前发的platform总线设备模型文章(51条消息) platform总线设备模型_cola冲冲冲的博客-CSDN博客_platform总线模型
但是那篇文章里没有引进设备树的匹配流程，我在这里完善一下。
每当有新的platform_device 或 platform_driver 注册时，最终都会调用最终会调用drivers\base\platform.c下的platform_match函数
static int platform_match(struct device *dev, struct device_driver *drv)
{
struct platform_device *pdev = to_platform_device(dev);
struct platform_driver *pdrv = to_platform_driver(drv);
匹配第一优先级、/* When driver_override is set, only bind to the matching driver */
if (pdev->driver_override)
return !strcmp(pdev->driver_override, drv->name);
匹配第二优先级、/*用于设备树节点匹配*/
/* Attempt an OF style match first */
if (of_driver_match_device(dev, drv))
return 1;
/* Then try ACPI style match */
if (acpi_driver_match_device(dev, drv))
return 1;
匹配第三优先级、/* Then try to match against the id table */
if (pdrv->id_table)
return platform_match_id(pdrv->id_table, pdev) != NULL;
匹配第四优先级、/* fall-back to driver name match */
return (strcmp(pdev->name, drv->name) == 0);
}
匹配规则
1. 最先比较：platform_device. driver_override和platform_driver.driver.name
可以设置platform_device的driver_override，强制选择某个platform_driver。
2. 然后比较：设备树信息
比较platform_device. dev.of_node和platform_driver.driver.of_match_table
platform_device. dev.of_node对应的数据结构为：
struct device_node {
const char *name; //来自设备树节点的name属性
const char *type; //来自设备树节点的device_type属性
phandle phandle;
char *full_name; //节点全名
struct property *properties; //含有设备树节点的compatible属性
......
};
struct property {
char *name; //属性名字 compatible 就是属性名字
int length; //属性长度 compatible = "test" 长度为5
void *value; //属性值 t例如 test
struct property *next; //下一个属性
unsigned long _flags;
unsigned int unique_id;
};platform_driver.driver.of_match_table 依次对应的数据结构为：
struct platform_driver {
int (*probe)(struct platform_device *);
int (*remove)(struct platform_device *);
void (*shutdown)(struct platform_device *);
int (*suspend)(struct platform_device *, pm_message_t state);
int (*resume)(struct platform_device *);
struct device_driver driver;
const struct platform_device_id *id_table;
};
struct device_driver {
const char *name;
struct bus_type *bus;
......
const struct of_device_id *of_match_table;
......
};
struct of_device_id
{
char name[32];
char type[32];
char compatible[128];
#ifdef __KERNEL__
void *data;
#else
kernel_ulong_t data;
#endif
};使用设备树信息来判断dev和drv是否配对时：
- 首先，如果of_match_table中含有compatible值，就跟dev的compatile属性比较，若一致则成功，否则返回失败 ；
- 其次，如果of_match_table中含有type值，就跟dev的device_type属性比较，若一致则成功，否则返回失败 ；
- 最后，如果of_match_table中含有name值，就跟dev的name属性比较，若一致则成功，否则返回失败。
现在都不再建议使用devcie_type和name属性，所以基本上只使用设备节点的compatible属性来寻找匹配的platform_driver。
3. 接下来比较：platform_device. name和platform_driver.id_table[i].name
Platform_driver.id_table是“platform_device_id”指针，表示该drv支持若干个device，它里面列出了各个device的{.name, .driver_data}，其中的“name”表示该drv支持的设备的名字，driver_data是些提供给该device的私有数据。
4. 最后比较：platform_device.name和platform_driver.driver.name
platform_driver.id_table可能为空，这时可以根据platform_driver.driver.name来寻找同名的platform_device。
内核里操作设备树的常用函数
内核源码中include/linux/目录下有很多of开头的头文件，of表示“open firmware”即开放固件。
- 处理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_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函数
函数原型：
/**
* platform_get_resource - get a resource for a device
* @dev: platform device
* @type: resource type // 取哪类资源？IORESOURCE_MEM、IORESOURCE_REG
* // IORESOURCE_IRQ等
* @num: resource index // 这类资源中的哪一个？
*/
struct resource *platform_get_resource(struct platform_device *dev,
unsigned int type, unsigned int num);
设备树中的节点被转换为platform_device后，设备树节点中的reg属性，对应IORESOURCE_MEM类型的资源；interrupts属性，对应IORESOURCE_IRQ类型的资源。
有些节点不会生成platform_device，怎么访问它们?
内核会把dtb文件解析出一系列的device_node结构体，我们可以直接访问这些device_node。内核源码incldue/linux/of.h中声明了device_node和属性property的操作函数。
找到节点：
- of_find_node_by_path函数
作用：根据路径找到节点，比如“/”就对应根节点，“/memory”对应memory节点。
函数原型：static inline struct device_node *of_find_node_by_path(const char *path);of_find_node_by_name函数
作用：根据名字找到节点，节点如果定义了name属性，那我们可以根据名字找到它
函数原型：extern struct device_node *of_find_node_by_name(struct device_node *from, const char *name); 参数from表示从哪一个节点开始寻找，传入NULL表示从根节点开始寻找。 但是在设备树的官方规范中不建议使用“name”属性，所以这函数也不建议使用。of_find_node_by_type函数
作用：根据类型找到节点，节点如果定义了device_type属性，那我们可以根据类型找到它
函数原型：extern struct device_node *of_find_node_by_type(struct device_node *from, const char *type); 参数from表示从哪一个节点开始寻找，传入NULL表示从根节点开始寻找。 但是在设备树的官方规范中不建议使用“device_type”属性，所以这函数也不建议使用of_find_compatible_node函数
作用：根据compatible找到节点，节点如果定义了compatible属性，那我们可以根据compatible属性找到它。
函数原型：extern struct device_node *of_find_compatible_node(struct device_node *from, const char *type, const char *compat); 参数from表示从哪一个节点开始寻找，传入NULL表示从根节点开始寻找。 参数compat是一个字符串，用来指定compatible属性的值； 参数type是一个字符串，用来指定device_type属性的值，可以传入NULL。of_find_node_by_phandle函数
作用：根据phandle找到节点。dts文件被编译为dtb文件时，每一个节点都有一个数字ID，这些数字ID彼此不同。可以使用数字ID来找到device_node。这些数字ID就是phandle
函数原型：extern struct device_node *of_find_node_by_phandle(phandle handle); 参数from表示从哪一个节点开始寻找，传入NULL表示从根节点开始寻找。
3240
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
