Linux 内核：利用of_函数读取设备树结点/属性信息

Linux 内核：利用of_函数读取设备树结点/属性信息

背景

设备树描述了设备的详细信息，这些信息包括数字类型的、字符串类型的、数组类型的，我们在编写驱动的时候需要获取到这些信息。

Linux 内核给我们提供了一系列的函数来获取设备树中的节点或者属性信息，这一系列的函数都有一个统一的前缀“of_”，所以在很多资料里面也被叫做 OF 。

这些 OF原型都定义在include/linux/of.h 文件中。

我们看看在实际中如何使用设备树。

参考：

• https://blog.csdn.net/qq_43121830/article/details/104866557
• https://blog.csdn.net/qq_35031421/article/details/105107629

判断根节点兼容性OF函数

在Linux内核中，常常使用如下OF函数来判断根节点的兼容性：

int of_machine_is_compatible(const char *compat);

DT设备的.dt_compat可能包含多个电路板，通过该函数可以判断根节点compatible的属性，当该函数的compat参数与根据点的compatible匹配时，返回一个正整数。

用法，例如：

of_machine_is_compatible("samsung,exynos4");

查找节点的 OF

设备都是以节点的形式“挂”到设备树上的，因此要想获取这个设备的其他属性信息，必

须先获取到这个设备的节点。 Linux 内核使用 device_node 结构体来描述一个节点，此结构体定义在文件 include/linux/of.h 中，代码如下：

struct device_node {
	const char *name;  /*节点的名字*/
	const char *type;  /*设备类型，来自节点中的device_type属性, 如果没有该属性, 则设为"NULL"*/
	phandle phandle;
	const char *full_name;  /*节点的全名，node-name[@unit-address]*/
	struct fwnode_handle fwnode;

	struct	property *properties;  /*节点的属性*/
	struct	property *deadprops;	/* removed properties */
	struct	device_node *parent;   /*父节点*/
	struct	device_node *child;    /*子节点*/
	struct	device_node *sibling;  /*节点的兄弟，即同级节点*/
#if defined(CONFIG_OF_KOBJ)
	struct	kobject kobj;
#endif
	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
};

与查找节点相关的，有如下函数。

of_find_node_by_name

of_find_node_by_name通过节点名字查找指定的节点，函数原型如下：

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

函数参数和返回值含义如下：

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

name： 要查找的节点名字。

of_find_node_by_type

of_find_node_by_type通过 device_type 属性查找指定的节点，函数原型如下：

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

函数参数和返回值含义如下：

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

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

返回值： 找到的节点，如果为 NULL 表示查找失败。

of_find_compatible_node

of_find_compatible_node根据 device_type 和 compatible 这两个属性查找指定的节点，函数原型如下：

struct device_node *of_find_compatible_node(struct device_node *from,
											const char *type,
											const char *compatible);

函数参数和返回值含义如下：

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

type： 要查找的节点对应的 type 字符串，也就是 device_type 属性值，可以为 NULL，表示忽略掉 device_type 属性。

compatible： 要查找的节点所对应的 compatible 属性列表。

返回值： 找到的节点，如果为 NULL 表示查找失败

of_find_matching_node_and_match

of_find_matching_node_and_match通过 of_device_id 匹配表来查找指定的节点，函数原型如下：

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

函数参数和返回值含义如下：

• from： 开始查找的节点，如果为 NULL 表示从根节点开始查找整个设备树。
• matches： of_device_id 匹配表，也就是在此匹配表里面查找节点。
• match： 找到的匹配的 of_device_id。
• 返回值： 找到的节点，如果为 NULL 表示查找失败

of_find_node_by_path

of_find_node_by_path通过路径来查找指定的节点，函数原型如下：

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

函数参数和返回值含义如下：

• path： 带有全路径的节点名，可以使用节点的别名，比如“/backlight”就是 backlight 这个节点的全路径。
• 返回值： 找到的节点，如果为 NULL 表示查找失败

查找父/子节点的 OF

of_get_parent

of_get_parent用于获取指定节点的父节点，原型如下：

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

函数参数和返回值含义如下：

• node： 需要查找父节点的子节点；
• 返回值： 返回父节点；

of_get_next_child

of_get_next_child用迭代的查找子节点，函数原型如下：

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

函数参数和返回值含义如下：

• node： 父节点；
• prev： 前一个子节点，也就是从哪一个子节点开始迭代的查找下一个子节点。可以设置为NULL，表示从第一个子节点开始。
• 返回值： 找到的下一个子节点。

of_get_next_child

节点的属性信息里面保存了驱动所需要的内容，因此对于属性值的提取非常重要， Linux 内核中使用结构体 property 表示属性，此结构体同样定义在文件 include/linux/of.h 中，内容如下：

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

提取属性值

Linux 内核也提供了提取属性值的 OF。

of_find_property

of_find_property用于查找指定的属性，函数原型如下：

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

函数参数和返回值含义如下：

• np： 设备节点；
• name： 属性名字；
• lenp： 属性值的字节数；

返回值： 找到的属性。

of_property_count_elems_of_size

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

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

函数参数和返回值含义如下：

• np： 设备节点。
• proname： 需要统计元素数量的属性名字。
• elem_size： 元素长度。

返回值： 得到的属性元素数量。

of_property_read_u32_index

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

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

函数参数和返回值含义如下：

• np： 设备节点；
• proname： 要读取的属性名字；
• index： 要读取的值标号；
• out_value： 读取到的值；

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

of_property_read_u8_array

of_property_read_u16_array

of_property_read_u32_array

of_property_read_u64_array

这 4 个函数分别是读取属性中 u8、 u16、 u32 和 u64 类型的数组数据，比如大多数的 reg 属性都是数组数据，可以使用这 4 个函数一次读取出 reg 属性中的所有数据。这四个函数的原型如下：

int of_property_read_u8_array(const struct device_node *np,
							const char *propname,
							u8 *out_values,
							size_t sz);
int of_property_read_u16_array(const struct device_node *np,
							const char *propname,
							u16 *out_values,
							size_t sz);
int of_property_read_u32_array(const struct device_node *np,
							const char *propname,
							u32 *out_values,
							size_t sz);
int of_property_read_u64_array(const struct device_node *np,
							const char *propname,
							u64 *out_values
							size_t sz);

函数参数和返回值含义如下：

• np： 设备节点；
• proname： 要读取的属性名字；
• out_value： 读取到的数组值，分别为 u8、 u16、 u32 和 u64。
• sz： 要读取的数组元素数量。

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

of_property_read_u8

of_property_read_u16

of_property_read_u32

of_property_read_u64

有些属性只有一个整形值，这四个函数就是用于读取这种只有一个整形值的属性，分别用

于读取 u8、 u16、 u32 和 u64 类型属性值，函数原型如下：

int of_property_read_u8(const struct device_node *np,
						const char *propname,
						u8 *out_value);
int of_property_read_u16(const struct device_node *np,
						const char *propname,
						u16 *out_value);
int of_property_read_u32(const struct device_node *np,
						const char *propname,
						u32 *out_value);
int of_property_read_u64(const struct device_node *np,
						const char *propname,
						u64 *out_value);

函数参数和返回值含义如下：

• np： 设备节点。
• proname： 要读取的属性名字。
• out_value： 读取到的数组值。

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

of_property_read_string

of_property_read_string用于读取属性中字符串值，函数原型如下：

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

函数参数和返回值含义如下：

• np： 设备节点。
• proname： 要读取的属性名字。
• out_string： 读取到的字符串值。

返回值： 0，读取成功，负值，读取失败。

of_n_addr_cells

of_n_addr_cells用于获取 #address-cells 属性值，函数原型如下：

int of_n_addr_cells(struct device_node *np);

函数参数和返回值含义如下：

• np： 设备节点。
• 返回值： 获取到的#address-cells 属性值。

of_n_size_cells

of_size_cells用于获取 #size-cells 属性值，函数原型如下：

int of_n_size_cells(struct device_node *np);

函数参数和返回值含义如下：

• np： 设备节点。

返回值： 获取到的#size-cells 属性值。

其他常用的 OF

of_get_address

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

值，函数属性如下：

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

函数参数和返回值含义如下：

• dev： 设备节点。
• index： 要读取的地址标号。
• size： 地址长度。
• flags： 参数，比如 IORESOURCE_IO、 IORESOURCE_MEM 等

返回值： 读取到的地址数据首地址，为 NULL 的话表示读取失败。

of_translate_address

of_translate_address负责将从设备树读取到的地址转换为物理地址，函数原型如下：

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

函数参数和返回值含义如下：

• dev： 设备节点。
• in_addr： 要转换的地址。

返回值： 得到的物理地址，如果为 OF_BAD_ADDR 的话表示转换失败。

of_address_to_resource

resource结构体描述的都是设备资源信息， resource 结构体定义在文件include/linux/ioport.h 中，定义如下：

struct resource {
	resource_size_t start; /*起始地址，对于32位soc，resource_size_t 的数据类型是u32*/
	resource_size_t end; /*结束地址*/
	const char *name;  /*资源的名字*/
	unsigned long flags; /*资源标志位，一般表示资源类型,可选的资源标志定义在文件 include/linux/ioport.h,如IORESOURCE_BITS、IORESOURCE_MEM、IORESOURCE_IRQ等 */
	struct resource *parent, *sibling, *child;
};

of_address_to_resource是从设备树里面提取资源值，但是本质上就是将 reg 属性值，然后将其转换为 resource 结构体类型，函数原型如下所示：

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

函数参数和返回值含义如下：

• dev： 设备节点。
• index： 地址资源标号。
• r： 得到的 resource 类型的资源值。

返回值： 0，成功；负值，失败。

of_iomap

of_iomap用于直接内存映射，以前我们会通过 ioremap来完成物理地址到虚拟地址的映射，采用设备树以后就可以直接通过 of_iomap来获取内存地址所对应的虚拟地址，不需要使用 ioremap了。该函数的原型如下：

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

函数参数和返回值含义如下：

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

返回值： 经过内存映射后的虚拟内存首地址，如果为 NULL 的话表示内存映射失败。

例子

目的：期望通过linux/of.h中相关函数，在驱动中读取设备树相关结点信息和属性信息

要求：

• ①读取设备树/backlight结点下的属性，以及属性信息，合理处理返回值和错误信息
• ②设计一个能够读取u32类型属性的通用函数，并在init函数中输出信息

设备树

/ {
    backlight {
        compatible = "pwm-backlight";
        pwms = <&pwm1 0 5000000>;
        brightness-levels = <0 4 8 16 32 64 128 255>;
        default-brightness-level = <6>;
        status = "okay";
        wp-inverted ;
    };
};

驱动程序

/* 此文件为linux 内核 of函数测试文件
 *  实验目的：在init函数中使用of函数读取设备树中的 根节点下xxx设备节点信息
 *  其路径为：
 */

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/of_device.h>
#include <linux/slab.h>

struct device_node* ofdts_node;
struct property*    blprop;
int ret = 0;
const char* out_string;
int result = 0;
int mem_count = 0;
u32* out_values;
static u32 show_members(int mem_count, char* prop_name)
{
    u8 i;

    if(mem_count < 0){
        printk("fail_property_count_elems_of_size!!!\n");
        return -ENODEV;
    }
    else if (mem_count == 0)
    {
        printk("%s中有%d个元素\n",prop_name, mem_count);
    }else if(mem_count == 1){
        printk("%s中有%d个元素\n",prop_name, mem_count);
        out_values = kmalloc(sizeof(u32) * mem_count,GFP_KERNEL);
        if(!out_values){
            printk("fail_mem\n");
            return -ENODEV;
        }
        ret = of_property_read_u32(ofdts_node, prop_name, out_values);
        if(ret < 0){
            printk("fail_read_u32!!!\n");
            kfree(out_values);
            return -ENODEV;
        }
        printk("%s中的元素为：%d\n",prop_name, *out_values);
    }
    else{
        printk("%s中有%d个元素\n",prop_name, mem_count);
        out_values = kmalloc(sizeof(u32) * mem_count,GFP_KERNEL);
        ret = of_property_read_u32_array(ofdts_node, prop_name, out_values,mem_count);
        if(ret < 0){
            printk("fail_read_u32_array!!!\n");
            kfree(out_values);
            return -ENODEV;
        }
        printk("%s中有元素为:",prop_name);
        for(i = 0; i < mem_count; i++){
            printk("%d\t",out_values[i]);
        }
    }
    return 0;
}

static int __init ofdts_init(void)
{
    printk("\nofdts_initing.........\n");
    /* 0. 提取 backlight 节点*/
    ofdts_node = of_find_node_by_name(NULL, "backlight");
    if(!ofdts_node){
        goto fail_node;
    }else{
        printk("0. 获取节点：%s 成功~\n", ofdts_node->name);
    }

    /* 1. 获取compatible = "pwm-backlight"  和 status = "okay"这俩都是字符串类型的，使用两个不同的函数分别测试*/
    // 1 compatible
    ret = of_property_read_string(ofdts_node, "compatible", &out_string);
    if(ret < 0){
        goto fail_property_read_string;
    }else{
        printk("1.0 获取compatible成功：%s\n", out_string);
    }
    // 2 status
    blprop = of_find_property(ofdts_node, "status", NULL);
    if(!blprop){
        goto fail_find_property;
    }else{
        printk("1.1 获取status成功：%s\n", (char*)blprop->value);
    }

    /* 2. 获取default-brightness-level = <6>; */
    mem_count = of_property_count_elems_of_size(ofdts_node, "default-brightness-level", sizeof(u32));
    result = show_members(mem_count, "default-brightness-level");
    if(result < 0){
        return result;
    }
    /* 3. brightness-levels = <0 4 8 16 32 64 128 255>; */
    mem_count = of_property_count_elems_of_size(ofdts_node, "brightness-levels", sizeof(u32));
    result = show_members(mem_count, "brightness-levels");

    printk("ofdts_init.........OK!!!\n");
    return result;

    fail_find_property:
    fail_property_read_string:
    printk("fail_property_read_string!!!\n");
    return -ENODEV;
    fail_node:
    printk("fail_find_node_byname!!!\n");
    return -ENODEV;
}

static void __exit ofdts_exit(void)
{
    kfree(out_values);
    printk("ofdts_exit.........OK!!!\n");
}

/* 注册函数 */
module_init(ofdts_init);
module_exit(ofdts_exit);

/* license和作者*/
MODULE_LICENSE("GPL");
MODULE_AUTHOR("QJY");

注意：程序能够测试通过，可能返回值处理以及错误处理有不合理之处，作者并未排查，本程序仅作为练习测试使用；

测试结果：

lib/modules/4.1.15 #modprobe ofdts
ofdts_initing. . . .. . . . .
0．获取节点: backlight成功~
1.0获取compatible成功:pwm-backlight
1.1 获取status成功:okay
default-brightness-level中有1个元素
default-brightness-level中的元素为:6
brightness-levels中有8个元素
brightness-levels中有元素为:0 4 8 16 32 64 128 255
ofdts_init....OK!!