• 欢迎光临~

Linux驱动开发四.使用of函数获取设备树节点信息

开发技术 开发技术 2022-06-08 次浏览

这一章之前我们应该先大致了解一下设备树的基本信息和基础语法。这两点我就先不总结了,网上多的是。为了后续做设备树的使用,我们这一章讲一下如何在驱动中(内核态)获取设备树中对于设备的描述。

of函数

内核为我们提供了一组of函数,用来获取设备树节点中的详细信息。这个OF函数路径为在内核路径下单include/linux/of.c中。我们主要使用下面几种

  1. 查找节点
  2. 查找子/父节点
  3. 提取属性值
  4. 其他,例如查询属性是否包含指定字符的、直接获取内存映射信息的等等

注意一点:在内核中如果想要使用of函数,要在导入的of.h内进行配置,加上下面的代码

#ifdef CONFIG_OF

如下图所示

Linux驱动开发四.使用of函数获取设备树节点信息

 

 

结合下面一段设备树的信息,我们来试下如何使用这些of函数

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

/ {
    model = "Freescale i.MX6 ULL 14x14 EVK Board";
    compatible = "fsl,imx6ull-14x14-evk", "fsl,imx6ull";

    chosen {
        stdout-path = &uart1;
    };

    memory {
        reg = <0x80000000 0x20000000>;
    };

    reserved-memory {
        #address-cells = <1>;
        #size-cells = <1>;
        ranges;

        linux,cma {
            compatible = "shared-dma-pool";
            reusable;
            size = <0x14000000>;
            linux,cma-default;
        };
    };

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

我们主要想要获取根节点下面back-light的信息。

通过OF函数获取节点

节点(device_node)在of.h里是按照一个结构体被定义好的

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

驱动操作硬件,主要是获取节点内的属性。而想要获取属性,首先要索引到该节点。这个device_node结构体就是被索引出来的节点对象。

比如我们需要操作设备树中backlight这个设备,因为我们有这个设备的名称(backlight),并且这个设备树是我们自己写的,所以路径也是明确的,我们只需要直接指定路径就可以了,就要用到下面的函数

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

参数path就是要操作的节点路径,由于backlight是在根节点下面,就可以直接指定,所以这个函数是我们最长用到。但是如果我们不太清楚其具体路径,还有个通过指定名称来查找的

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

指针参数from是我们需要查找的起始路径,name就是我们要找到设备树名称。

此外还有几种不太常用的,在/include/linux/of.h文件中都能找到

#define for_each_of_allnodes_from(from, dn) 
    for (dn = __of_find_all_nodes(from); dn; dn = __of_find_all_nodes(dn))
#define for_each_of_allnodes(dn) for_each_of_allnodes_from(NULL, dn)
extern struct device_node *of_find_node_by_name(struct device_node *from,
    const char *name);
extern struct device_node *of_find_node_by_type(struct device_node *from,
    const char *type);
extern struct device_node *of_find_compatible_node(struct device_node *from,
    const char *type, const char *compat);
extern 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);

extern struct device_node *of_find_node_opts_by_path(const char *path,
    const char **opts);

不太常用,这里就不再一一列举了。

获取父子节点

这个功能暂时还用不到,把头文件中的声明列出来,以后如果需要了再做完善

extern struct device_node *of_get_parent(const struct device_node *node);
extern struct device_node *of_get_next_parent(struct device_node *node);
extern struct device_node *of_get_next_child(const struct device_node *node,
                                     struct device_node *prev);
extern struct device_node *of_get_next_available_child(const struct device_node *node, 
                                 struct device_node *prev); extern struct device_node *of_get_child_by_name(const struct device_node *node,                  const char *name);

不再说明具体用法。

获取节点属性

敲黑板!这段是重点!!!

我们要通过设备树来对应硬件写驱动,必须要拿到设备树里这些节点中指定键的值。根据值不同数据类型我们一步步来实现

字符串类属性获取

backlight属性中compatible(兼容性)属性的值时字符串类型

compatible = "pwm-backlight";
 如果我们要在内核中判定写的驱动是否兼容该设备树节点对应设备,就要读取该属性的值进行判定,这时需要用到下面的函数
extern int of_property_read_string(struct device_node *np,
                   const char *propname,
                   const char **out_string);

参数np就是我们在前面拿到的节点结构体,propame就是属性,out_string就是要读取的数据,通过指针放到内存中。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/types.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>


static int __init dtsof_init(void)
{
    int ret = 0;
    struct device_node *dev_nd=NULL;
    const char *str;

    //获取节点
    dev_nd = of_find_node_by_path("/backlight");
    //找到backlight的节点,其路径为/backlight
    if(dev_nd==NULL){
        ret = -EINVAL;
        return ret;
        goto fail_findnd;
    }

    //获取字符串类型属性
    ret = of_property_read_string(dev_nd,"compatible",&str);
    if(ret<0)
    {
        goto fail_readstr;
    }
    else{
        printk("read string status=%srn",str);
    }

    return ret;
fail_readstr:
fail_findnd:
    return ret;
}

static void __exit dtsof_exit(void)
{

}

module_init(dtsof_init);
module_exit(dtsof_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("ZZQ");

整个文件是以驱动的流程呈现的,通过module_init()将初始化函数dtsof_init注册,在加载模块以后,先获取backlight对应节点(dev_nd),再通过读取字符属性的函数将compatible属性值读取到str指向的内存中,最后通过printk打印至终端。修改make文件后编译生成ko文件。

将ko文件复制到rootfs路径下lib/modules/4.1.15下,加载模块,会直接打印出来(第一次加载模块一定注意先运行depmod一下!),就会有下面的效果

Linux驱动开发四.使用of函数获取设备树节点信息

 

 of函数在读取成功时返回值应该为0,否则返回值为负数,所以在程序中我加了个判定,如果有异常通过goto语句跳转至相应功能代码处(案例中不需要做相应动作,所以是空的。)

数值类型属性读取
这里我们来读取backlight节点中下面的属性
default-brightness-level = <6>;

要注意点是,这里我们读取的数值类型数据都是32位的,要用到下面的函数

static inline int of_property_read_u32(const struct device_node *np,
                                 const char *propname,
                                  u32 *out_value)

其中参数np还是device_node,propname是我们要读取的属性,后面的指针是指向到读取数据存储的内存地址

由于前面已经有了整个函数的架构,这里只把init函数放出来看下

static int __init dtsof_init(void)
{
    int ret = 0;
    struct device_node *dev_nd=NULL;

    const char *str;

    //获取节点
    dev_nd = of_find_node_by_path("/backlight");
    //找到backlight的节点,其路径为/backlight
    if(dev_nd==NULL){
        ret = -EINVAL;
        return ret;
        goto fail_findnd;
    }

    //获取字符串类型属性
    ret = of_property_read_string(dev_nd,"compatible",&str);
    if(ret<0)
    {
        goto fail_readstr;
    }
    else{
        printk("read string status=%srn",str);
    }

    //获取数字类型属性
    const u32 def_val;
    ret = of_property_read_u32(dev_nd,"default-brightness-level",&def_val);
    if(ret<0){goto fail_read32;}
    else{
        printk("default-brightness-level=%drn",def_val);
    }

    return ret;
fail_read32:
fail_readstr:
fail_findnd:
    return ret;
}

make一下复制到指定目录,启动开发板后加载模块

Linux驱动开发四.使用of函数获取设备树节点信息

这样可以看到我们读取到数据了,整形数据,值为6!

数组类型数据读取

最后就是读取数组类型的数据,首先要用到下面的函数获取数组的长度

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

注意那个elem_size是数组中每个元素的数据长度,我们可以直接用sizeof(u32)来指定

static inline int of_property_read_u32(const struct device_node *np,
                       const char *propname,
                       u32 *out_value)

参数device_node就是设备节点,propname为属性名称,最后的out_value是读取的数组存储的地方。

先演示一个稍微复杂的方法,使用这个函数时可以先使用kmalloc函数申请一块内存(记得导入头文件(/linux/slab.h)),把读到的数据放在这块内存中

static int __init dtsof_init(void)
{
    int ret = 0;
    struct device_node *dev_nd=NULL;
    u8 i=0;
    u8 datasize;
    u32 *brival;

    //获取节点
    dev_nd = of_find_node_by_path("/backlight");
    //找到backlight的节点,其路径为/backlight
    if(dev_nd==NULL){
        ret = -EINVAL;
        return ret;
        goto fail_findnd;
    }

    // 获取数组类型属性
    
    datasize = of_property_count_elems_of_size(dev_nd,"brightness-levels",sizeof(u32));
    if(ret<0){
        ret = -EINVAL;
        goto fail_readele;
    }
    else{
        printk("brightness-levels elem size= %drn",datasize);
    }

    brival = kmalloc(datasize * sizeof(u32),GFP_KERNEL);        //申请内存
    if(!brival){
        printk("buf errrn");
        ret = -EINVAL;
        goto fail_mem;
    }

    //内存获取成功,获取数组
    ret = of_property_read_u32_array(dev_nd,"brightness-levels",brival,datasize);
    if(ret<0){
        printk("read array errrn");
        goto fail_read32array;
    }
    else{
        for(i=0;i<datasize;i++)
        {printk("brightness-levels[%d]=%drn",i,*(brival+i));}

    }
    kfree(brival);
    return ret;

fail_read32array:
    kfree(brival);   //释放内存
fail_mem:

fail_readele:
fail_findnd:
    return ret;
}

注意在使用kmalloc函数后如果成功申请了内存,在使用完成后要将该内存空间释放,有个和kmalloc成对的函数kfree,把申请的内存传递过去就可以了。make以后加载模块可以看出来读取到的值和数组

Linux驱动开发四.使用of函数获取设备树节点信息

 上面的过程是我们直接读取数据到申请的内存中,还可以提前声明一个数组指针,把指针传过去,这种用法在下一章节会用到。

有了上面的几个函数,后面我们就可以从最基础的点灯来演示一下了!

 

程序员灯塔
转载请注明原文链接:Linux驱动开发四.使用of函数获取设备树节点信息
喜欢 (0)