linux驱动之设备树的介绍

未燃机智鱼

已于 2022-10-14 17:28:44 修改

阅读量2.6k

点赞数 2

分类专栏：嵌入式 linux驱动文章标签： linux arm 驱动开发

于 2022-09-18 23:55:07 首次发布

本文链接：https://blog.csdn.net/qq_40684669/article/details/126916994

版权

嵌入式同时被 2 个专栏收录

25 篇文章 19 订阅

订阅专栏

linux驱动

23 篇文章 6 订阅

订阅专栏

一,设备树的概念

设备树引入及其作用

在linux中实现设备与驱动分离的架构
Dev / Bus / Drv 的架构
由于各个厂商的生产的板卡不同, 都会在Dev总线添加自家的外设资源生成设备节点, 导致linux源码越来越臃肿, 于是引入设备树, 由设备树来抽象出设备节点的模式.

在这里插入图片描述

板子上查看设备树

在板子上查看设备树
 ls /sys/firmware/
devicetree   fdt

/sys / firmware / devicetree目录下是以目录结构dtb文件(dtb是设备树编译的二进制格式), 根节点对应base目录, 每一个节点对应一个目录, 每一个属性对应一个文件.

对于属性值是字符串的可以使用cat命令查看;
对属性值是数值的可以使用hexdump查看;

设备树启动流程

一个单板启动时，u-boot先运行，它的作用是启动内核。U-boot会把内核和设备树文件都读入内存，然后启动内核。在启动内核时会把设备树在内存中的地址告诉内核。

二,编写设备树

设备树文件介绍

编写的设备树文件后缀为(dts: device tree source), 它将编译为dtb(device tree blob)文件, 内核使用的是dtb文件.
下面是一个设备树文件的示例
在这里插入图片描述

其dts文件对应如下:

/dts-v1/  //表示版本
/{
	model="fsl,mpc87572ds"
	compatible="fsl,mpc8572ds"
	#address-cell=<1>
	#size-cells=<1>

	cpus{
		#address-cells=<1>
		#size-cells=<0>
		cpu@0{
			device_type="cpu"
			reg=<0>
			timebase-frequency=<825000000>
			clock-frequency=<825000000>
		};
		cpus@1{
			device_type="cpu"
			reg=<1>
			teimebase-frequency=<825000000>
			clock-frequency=<825000000>
		};
	};
	memory@0{
		device_type="memory"
		reg=<0 0x20000000>
	};
	uart@fe001000P{
		compatible="ns16550"
		reg=<0xfe001000 0x100>
	};
	chosen{
		bootargs="root=/dev/sd2";
	};
	aliases{
		serial0="/uart@fe001000"
	};
};

设备树的基本单元成为node(节点), cpus作为一个node , 其子节点有cpu@0, cpus@1

设备树语法

/dts-v1/   //表示版本
/{  //设备树的根
    [label:]cpu[@unit-address]{//cpu节点描述
        name = val;  // ===>  key  =  value的形式
                     //key可以随便取 value有规则:"string"双引号是字符串
                     //<u32 u32 u32>  尖括号是u32整数
                     //[0x12 0x34] 中括号是单字节16进制数
    };
};

一个node的格式

[label:] node-name[@unit-address] {
    [properties definitions] //属性定义 子节点会继承父节点属性
    		propertise定义就是 name=value的格式, 
    		value有多种取值方式 也可以没有值
    		没有值时,仅代表该节点带有这个属性

    		有值的情况有三种定义值方式:
    			1,arrays of cells 数组的形式(1个或多个32位数据, 64位数据使用2个32位数据表示)
    			如:interrupts = <17 0xc>;cell就是一个32位的数据，用尖括号包围起来
    			clock-frequency = <0x00000001 0x00000000>;64bit数据使用2个cell来表示，用尖括号包围起来
    			2,string(字符串, 用双引号包含)
    			如:compatible = "simple-bus";
    		 	3,bytestring(字节形式)用中括号包围
    		 	如:
    		 	local-mac-address = [00 00 12 34 56 78];   每个byte使用2个16进制数来表示
    		 	local-mac-address = [000012345678];        每个byte使用2个16进制数来表示
    		 	4,各种不同类型的组合(用逗号隔开)
    		 	如:
    		 	compatible = "ns16550", "ns8250";
    		 	example = <0xf00f0000 19>, "a strange property format";
    [child nodes]		//子节点
};

label是标号, 可以省略. label是为了方便引用节点如现有节点:

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

有两种方法引用

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

dts文件包含dtsi文件

设备树文件不需要我们从零写出来
在内核的arch/arm/boot/dts目录下就有了能用的设备树模板一般命名为xxxx.dtsi
dts中可以包含.h头文件，也可以包含dtsi文件，在.h头文件中可以定义一些宏。

/dts-v1/;

#include <dt-bindings/input/input.h>
#include "imx6ull.dtsi"

/ {
……
};

设备树中常用的属性介绍

#address-cells、#size-cells

cell指一个32位的数值
address-cells：address要用多少个32位数来表示；
size-cells：size要用多少个32位数来表示。
如:

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

子节点memory中的reg属性需要描述起始地址和长度,
#address-cells、#size-cells都指定为1, 其0x80000000就是起始地址, 0x20000000就是长度
对于64位的cpu 也有属性为:

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

那么0x80000000 0x00002000就是起始地址, 0x20000000就是长度

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”，即“厂家名,模块名”。

注意：machine desc的意思就是“机器描述”，学到内核启动流程时才涉及。

model

model属性与compatible属性有些类似，但是有差别。
compatible属性是一个字符串列表，表示可以你的硬件兼容A、B、C等驱动

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

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

它表示这个单板，可以兼容内核中的“smdk2440”，也兼容“mini2440”。
从compatible属性中可以知道它兼容哪些板，但是它到底是什么板？用model属性来明确。

status

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

&uart1 {
      status = "disabled";
};

status的取值
okay : 设备正常运行
disabled : 设备不可操作但是后面可以恢复工作
fail : 发生严重错误, 需要修复
fail-sss : 发生严重错误, 需要修复; sss表示错误信息

reg

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

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

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

常用节点

根节点

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

/ {
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节点中设置bootargs属性：

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

还有更多设备树信息可在官方文档devicetree-specification-v0.3中阅读

三, 编译设备树

在内核中直接make

设置ARCH、CROSS_COMPILE、PATH这三个环境变量后，进入ubuntu上板子内核源码的目录，执行如下命令即可编译dtb文件：

make  dtbs  V=1

手工编译

内核目录下scripts/dtc/dtc是设备树的编译工具，直接使用它的话，包含其他文件时不能使用“#include”，而必须使用“/incldue”。
编译、反编译的示例命令如下，“-I”指定输入格式，“-O”指定输出格式，“-o”指定输出文件：

./scripts/dtc/dtc -I dts -O dtb -o tmp.dtb arch/arm/boot/dts/xxx.dts  // 编译dts为dtb

./scripts/dtc/dtc -I dtb -O dts -o tmp.dts arch/arm/boot/dts/xxx.dtb  // 反编译dtb为dts

可以在/sys/firmware/fdt 拿到fdt文件,
复制出来放到ubuntu上，执行下面的命令反编译出来(-I dtb：输入格式是dtb，-O dts：输出格式是dts)：

./scripts/dtc/dtc  -I  dtb  -O  dts   /从板子上/复制出来的/fdt  -o   tmp.dts

四,内核对设备树的处理

设备树到platform_device流程

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

struct device_node {
	const char *name;
	const char *type;
	phandle phandle;
	const char *full_name;
	struct fwnode_handle fwnode;

	struct	property *properties;
	struct	property *deadprops;	/* removed properties */
	struct	device_node *parent;
	struct	device_node *child;
	struct	device_node *sibling;
	struct	kobject kobj;
	unsigned long _flags;
	void	*data;
#if defined(CONFIG_SPARC)
	const char *path_component_name;
	unsigned int unique_id;
	struct of_irq_controller *irq_trans;
#endif
};

struct property {
	char	*name;
	int	length;
	void	*value;
	struct property *next;
	unsigned long _flags;
	unsigned int unique_id;
	struct bin_attribute attr;
};

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

哪些设备树节点会被转换为platform_device

根节点下含有compatile属性的子节点
含有特定compatile属性的节点的子节点 如果一个节点的compatile属性，它的值是这4者之一：“simple-bus”,“simple-mfd”,“isa”,“arm,amba-bus”,
那么它的子结点(需含compatile属性)也可以转换为platform_device。
总线I2C、SPI节点下的子节点：不转换为platform_device

设备节点匹配驱动程序的过程

最优先: platform_device. driver_override和platform_driver.driver.name 属于强制device选择指定驱动
次优先: platform_device. dev.of_node和platform_driver.driver.of_match_table。
由设备树节点转换得来的platform_device中，含有一个结构体：of_node。
**如果一个platform_driver支持设备树，它的platform_driver.driver.of_match_table是一个数组类型是of_device_id **

struct of_device_id{
	char name[32];
	char type[32];
	char compatible[128];
	const void *data;
};

使用设备树信息来判断dev和drv是否配对时，
首先，如果of_match_table中含有compatible值，就跟dev的compatile属性比较，若一致则成功，否则返回失败；
其次，如果of_match_table中含有type值，就跟dev的device_type属性比较，若一致则成功，否则返回失败；
最后，如果of_match_table中含有name值，就跟dev的name属性比较，若一致则成功，否则返回失败。

再接下来:比较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_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_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
这个函数跟设备树没什么关系，但是设备树中的节点被转换为platform_device后，设备树中的reg属性、interrupts属性也会被转换为“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如何访问

dtb文件解析出一系列的device_node结构体，我们可以直接访问这些device_node

找节点

of_find_node_by_path

根据路径找到节点，比如“/”就对应根节点，“/memory”对应memory节点。

static inline struct device_node *of_find_node_by_path(const char *path);

根据路径找到节点，比如“/”就对应根节点，“/memory”对应memory节点。

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表示从根节点开始寻找。

of_get_parent

找到device_node的父节点。
函数原型：

extern struct device_node *of_get_parent(const struct device_node *node);

参数from表示从哪一个节点开始寻找，传入NULL表示从根节点开始寻找。

of_get_next_parent

这个函数名比较奇怪，怎么可能有“next parent”？
它实际上也是找到device_node的父节点，跟of_get_parent的返回结果是一样的。
差别在于它多调用下列函数，把node节点的引用计数减少了1。这意味着调用of_get_next_parent之后，你不再需要调用of_node_put释放node节点。

of_node_put(node);

函数原型：

extern struct device_node *of_get_next_parent(struct device_node *node);

参数from表示从哪一个节点开始寻找，传入NULL表示从根节点开始寻找。

of_get_next_child

取出下一个子节点。
函数原型：

extern struct device_node *of_get_next_child(const struct device_node *node, 
									struct device_node *prev);

参数node表示父节点；
prev表示上一个子节点，设为NULL时表示想找到第1个子节点。

不断调用of_get_next_child时，不断更新pre参数，就可以得到所有的子节点

of_get_next_available_child

取出下一个“可用”的子节点，有些节点的status是“disabled”，那就会跳过这些节点。
函数原型：

struct device_node *of_get_next_available_child(const struct device_node *node,
	struct device_node *prev);

参数node表示父节点；
prev表示上一个子节点，设为NULL时表示想找到第1个子节点。

of_get_child_by_name

根据名字取出子节点。
函数原型：

extern struct device_node *of_get_child_by_name(const struct device_node *node,
					const char *name);

参数node表示父节点；
name表示子节点的名字。

找属性

获取属性

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

参数np表示节点，我们要在这个节点中找到名为name的属性。
lenp用来保存这个属性的长度，即它的值的长度。

在设备树中，节点大概是这样：
xxx_node {
xxx_pp_name = “hello”;
};
上述节点中，“xxx_pp_name”就是属性的名字，值的长度是6。

获取属性的值

of_get_property

根据名字找到节点的属性，并且返回它的值。
函数原型：

/*
 * Find a property with a given name for a given node
 * and return the value.
 */
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:单个元素的大小
在设备树中，节点大概是这样：

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。

读某个整数u32/u64

函数原型为：

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_variable_u8_array(const struct device_node *np,
					const char *propname, u8 *out_values,
					size_t sz_min, size_t sz_max);

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);

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);

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>;
};

上述例子中属性name2的值，长度为8。
调用of_property_read_variable_u8_array (np, “name2”, out_values, 1, 10)时，out_values中将会保存这8个字节： 0x12,0x00,0x00,0x50,0x34,0x00,0x00,0x60。
调用of_property_read_variable_u16_array (np, “name2”, out_values, 1, 10)时，out_values中将会保存这4个16位数值： 0x0012, 0x5000,0x0034,0x6000。

读字符串

函数原型为：

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

返回节点np的属性(名为propname)的值，(*out_string)指向这个值，把它当作字符串。

最后修改设备树, 有内核文档位置在Documentation/devicetree/bindings/

未燃机智鱼

关注

2
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
linux驱动之设备树的介绍

linux驱动开发中, 设备树的介绍
复制链接

扫一扫

专栏目录