0
0

Linux中的设备树详解

文章目录

前言

设备树是Linux驱动开发中必不可少的环节之一，它可以帮助我们快速了解设备硬件结构及快速配置，提高工作效率

一、设备树是什么

dts：设备树，是一种描述硬件的数据结构，一个dts对应一个开发板。dts文件中会包含有dtsi，就类似于C语言当中的头文件，把板级相同的节点定义都包含在同一个文件中。很多时候我们不必从头开始写一个设备树，大多数情况下都是在原厂Soc提供的设备树基础上进行修改。

dtc：编译dts的工具，一般路径在内核目录的scripts/dtc下，要编译dts文件，只需在源码目录make all或make dtbs或 make xxx.dtb(指定)即可。

二、节点说明

1.简单结构示意图

下面展示一个最基础，简单的设备树结构图。

  1. /{
  2.     node1{
  3.         p1 = a;
  4.         p2 = b;};
  5.     
  6.     node2{
  7.         p3 = c;
  8.         node3{
  9.             p4 = d;};};};

2.设备节点的命名格式

  1. [label:]node-name[@unit-address]{[properties definitions][child nodes]}；
  3. 即：
  4. cpus{
  5.     cpu1:cpu@0{
  6.         compatible ="cpu";};};

[ ] 代表可忽略
label 方便给其他节点引用
node-name 节点名字
unit-address 设备地址
properties 属性值，不一定要有

常用属性值的形式：

  1. 字符串：            compatible ="arm,cortex-a53";32位无符号整形    clock-latency =<1000>;
  2. 二进制            local-mac-address =[000a 35001e 53];
  3. 字符串数组        compatible ="n25q512a","micron,m25p80";
  4. 混合            mixed-property ="a string",[0x010x230x450x67],<0x12345678>;
  5. 节点引用            clocks =<&clkc 3>;    引用clkc这个节点，clkc即是“label”

3.linux下的标准属性

常用的节点属性如下：

  1. compatible 属性，非常重要，用于将驱动和设备绑定起来，与驱动程序文件的OF匹配表中值相等，就表示设备可以使用这个驱动
  2. compatible ="xlnx,xuartps","cdns,uart-r1p8";
  4. model 属性，指定制造商型号，内核解析设备树时会打印出来
  5. model ="Alientek Zynq MpSoc Development Board";
  7. status 属性，禁止或启用设备
  8. status = okay（默认）/disabled
  10. #address-cells 和#size-cells 属性    描述子节点的地址信息#address-cells    reg中的首地址数量    address占用字长    1个字长32bit#size-cells        reg中的地址长度        length占用字长
  11. reg =<address1 length1 address2 length2 address3 length3……>
  13. reg 属性    描述设备地址空间资源信息
  14. reg =<0x00xff0000000x00x1000>;64位时：address=0xff000000（ 0x0 为高 32 位）， length=0x1000
  15. reg =<0xff0000000x04>;32位时：address=0xff000000，映射到虚拟空间长度为4字节
  17. ranges 属性    地址转换表，可以为空或者按照(child-bus-address,parent-bus-address,length)格式编写
  18. soc{
  19.     ranges =<0x00xe00000000x00100000>;
  20.     serial{
  21.         reg =<0x46000x100>;};};
  22. soc中，指定1024KB(0x00100000)的地址范围，子地址空间的物理起始地址为 0x0，父地址空间的物理起始地址为 0xe0000000
  23. serial是串口设备节点，起始地址为 0x4600，寄存器长度为 0x100
  24. 经过地址转换， serial 设备可以从 0xe0004600 开始进行读写操作，0xe0004600=0x4600+0xe0000000
  26. device_type 属性    表示节点类型，用得比较少
  27. device_type ="cpu";

4.特殊节点

接下来讲一下常用的几个特殊的设备树节点

  1. aliases{//取别名，方便内核访问，不是设备树
  2.     ethernet0 =&gem0;};
  4. chosen{
  5.     bootargs = "console=ttyPS0,115200 earlyprintk root=/dev/mmcblk0p2
  6.                 rw rootwait";/dev/ttyPS0
  7.     stdout-path ="serial0:115200n8";//标准输出串口0,115200 无校验 8位};//两个优先级暂且不管
  8. uboot启动内核时会传bootargs并打印
  9. 结论：如果uboot定义了bootargs，会在设备树chosen中追加bootargs属性，没定义，则用设备树的
  11. memory{
  12.     device_type ="memory";
  13.     reg =<0x00x20000000>;};
  14. 描述了系统内存的基地址和大小，device_type固定为"memory"

内核解析设备树节点的简单流程如下：

  1. start_kernel()
  2.     setup_arch()
  3.         unflatten_device_tree()
  4.             __unflatten_device_tree()
  5.                 unflatten_dt_node()
  6.                 解析DTB文件中的各个节点

节点在Linux系统中的体现：

  1. cd /proc/device-tree

此目录下都是设备树中定义的节点为名的目录，进入目录中可以查看各属性值。
在这里插入图片描述

三、节点匹配

讲完了常用节点属性，那么内核是怎么知道要匹配我们的哪个设备树呢？
每个设备树的根节点下都有一个compatible属性，Linux内核加载的时候系统会用此属性值与内核中保存的属性成员相比较，如果字符串匹配，则表示内核支持此设备树，加载运行；否则，会报错。
Linux内核调用start_kernel启动内核
->setup_arch来匹配machine_desc 即：setup_machine_fdt
machine_desc中有个.dt_compat成员，保存着兼容属性，例如"xlnx,zynq-7000"
(eg:zynqmp平台的成员定义在arch/arm/mach-zynq/common.c)
只要板子根节点和任一值相等，表示内核支持此平台
arch/arm/kernel/setup.c

  1. void __init setup_arch(char**cmdline_p){conststructmachine_desc*mdesc;...
  2.             mdesc =setup_machine_fdt(__atags_pointer);//参数就是uboot传给内核的dtb文件首地址if(!mdesc)
  3.             mdesc =setup_machine_tags(__atags_pointer, __machine_arch_type);
  4.             machine_desc = mdesc;
  5.             machine_name = mdesc->name;...}->setup_machine_fdt(__atags_pointer)->mdesc =of_flat_dt_match_machine(mdesc_best, arch_get_next_mach)

简单点的结构图流程如下：

  1. start_kernel()setup_arch()setup_machine_fdt()of_flat_dt_match_machine()

四、设备树常用of操作函数

1.查找节点

  1. 通过节点名字查找
  2. structdevice_node*of_find_node_by_name(structdevice_node*from,constchar*name);
  3. from：开始查找的节点，如果为 NULL 表示从根节点开始查找整个设备树。
  4. name：要查找的节点名字。
  5. 返回值： 找到的节点，如果为 NULL 表示查找失败。
  7. 通过device_type:structdevice_node*of_find_node_by_type(structdevice_node*from,constchar*type)
  8. 函数参数和返回值含义如下：
  9. from：开始查找的节点，如果为 NULL 表示从根节点开始查找整个设备树。
  10. type：要查找的节点对应的 type 字符串，也就是 device_type 属性值。
  11. 返回值： 找到的节点，如果为 NULL 表示查找失败。
  13. 根据 device_type 和 compatible 
  14. structdevice_node*of_find_compatible_node(structdevice_node*from,constchar*type,constchar*compatible)
  15. from：开始查找的节点，如果为 NULL 表示从根节点开始查找整个设备树
  16. type：要查找的节点对应的 type 字符串，也就是 device_type 属性值，可以为 NULL，表
  17. 示忽略掉 device_type 属性。
  18. compatible： 要查找的节点所对应的 compatible 属性列表。
  19. 返回值： 找到的节点，如果为 NULL 表示查找失败。
  21. 通过 of_device_id 匹配表来查找指定的节点
  22. structdevice_node*of_find_matching_node_and_match(structdevice_node*from,conststructof_device_id*matches,conststructof_device_id**match)
  23. 函数参数和返回值含义如下：
  24. from：开始查找的节点，如果为 NULL 表示从根节点开始查找整个设备树。
  25. matches： of_device_id 匹配表，也就是在此匹配表里面查找节点。
  26. match： 找到的匹配的 of_device_id。
  27. 返回值： 找到的节点，如果为 NULL 表示查找失败。
  29. 通过节点路径来查找
  30. inlinestructdevice_node*of_find_node_by_path(constchar*path)
  31. 函数参数和返回值含义如下：
  32. path：带有全路径的节点名，可以使用节点的别名（用 aliens 节点中定义的别名）。
  33. 返回值： 找到的节点，如果为 NULL 表示查找失败。
  35. 查找父/子节点
  37. 获取指定节点的父节点
  38. structdevice_node*of_get_parent(conststructdevice_node*node)
  39. 函数参数和返回值含义如下：
  40. node：要查找的父节点的节点。
  41. 返回值： 找到的父节点。
  43. 迭代的查找子节点
  44. structdevice_node*of_get_next_child(conststructdevice_node*node,structdevice_node*prev)
  45. 函数参数和返回值含义如下：
  46. node：父节点。
  47. prev： 前一个子节点，也就是从哪一个子节点开始迭代的查找下一个子节点。可以设置
  48. 为 NULL，表示从第一个子节点开始。
  49. 返回值： 找到的下一个子节点。

2.提取属性值

  1. structproperty{char*name;/* 属性名字 */int length;/* 属性长度 */void*value;/* 属性值 */structproperty*next;/* 下一个属性 */unsignedlong _flags;unsignedint unique_id;structbin_attribute attr;};
  3. 查找指定的属性
  4. property *of_find_property(conststructdevice_node*np,constchar*name,int*lenp)
  5. 函数参数和返回值含义如下：
  6. np：设备节点。
  7. name： 属性名字。
  8. lenp：属性值的字节数。
  9. 返回值： 找到的属性
  11. 获取属性中元素的数量，比如 reg 属性值是一个数组，那么使用此函数可以获取到这个数组的大小
  12. intof_property_count_elems_of_size(conststructdevice_node*np,constchar*propname,int elem_size)
  13. 函数参数和返回值含义如下：
  14. np：设备节点。
  15. proname： 需要统计元素数量的属性名字。
  16. elem_size：元素长度。
  17. 返回值： 得到的属性元素数量。
  19. 从属性中获取指定下标
  20. intof_property_read_u32_index(conststructdevice_node*np,constchar*propname,u32 index,u32 *out_value)
  21. 函数参数和返回值含义如下：
  22. np：设备节点。
  23. proname： 要读取的属性名字。
  24. index：要读取的值的下标。
  25. out_value：读取到的值
  26. 返回值： 0 读取成功，负值，读取失败， -EINVAL 表示属性不存在， -ENODATA 表示没
  27. 有要读取的数据， -EOVERFLOW 表示属性值列表太小
  29. of_property_read_u8_array 函数
  30. of_property_read_u16_array 函数
  31. of_property_read_u32_array 函数
  32. of_property_read_u64_array 函数
  33. 这 4 个函数分别是读取属性中 u8、 u16、 u32 和 u64 类型的数组数据，比如大多数的 reg
  34. 属性都是数组数据，可以使用这 4 个函数一次读取出 reg 属性中的所有数据
  35. intof_property_read_u8_array(conststructdevice_node*np,constchar*propname,u8 *out_values,size_t sz)intof_property_read_u16_array(conststructdevice_node*np,onst char*propname,u16 *out_values,size_t sz)intof_property_read_u32_array(conststructdevice_node*np,constchar*propname,u32 *out_values,size_t sz)intof_property_read_u64_array(conststructdevice_node*np,constchar*propname,u64 *out_values,size_t sz)
  36. 函数参数和返回值含义如下：
  37. np：设备节点。
  38. proname： 要读取的属性名字。
  39. out_value：读取到的数组值，分别为 u8、 u16、 u32 和 u64。
  40. sz： 要读取的数组元素数量。
  41. 返回值： 0， 读取成功，负值，读取失败， -EINVAL 表示属性不存在， -ENODATA 表示
  42. 没有要读取的数据， -EOVERFLOW 表示属性值列表太小
  44. of_property_read_u8 函数
  45. of_property_read_u16 函数
  46. of_property_read_u32 函数
  47. of_property_read_u64 函数
  48. 有些属性只有一个整形值，这四个函数就是用于读取这种只有一个整形值的属性，分别
  49. 用于读取 u8、 u16、 u32 和 u64 类型属性值，函数原型如下：
  50. intof_property_read_u8(conststructdevice_node*np,constchar*propname,u8 *out_value)intof_property_read_u16(conststructdevice_node*np,constchar*propname,u16 *out_value)intof_property_read_u32(conststructdevice_node*np,constchar*propname,u32 *out_value)intof_property_read_u64(conststructdevice_node*np,constchar*propname,u64 *out_value)
  51. 函数参数和返回值含义如下：
  52. np：设备节点。
  53. proname： 要读取的属性名字。
  54. out_value： 读取到的数组值。
  55. 返回值： 0，读取成功，负值，读取失败， -EINVAL 表示属性不存在， -ENODATA 表示
  56. 没有要读取的数据， -EOVERFLOW 表示属性值列表太小
  58. of_property_read_string 函数
  59. of_property_read_string 函数用于读取属性中字符串值，函数原型如下：
  60. intof_property_read_string(structdevice_node*np,constchar*propname,constchar**out_string)
  61. 函数参数和返回值含义如下：
  62. np：设备节点。
  63. proname： 要读取的属性名字。
  64. out_string：读取到的字符串值。
  65. 返回值： 0，读取成功，负值，读取失败
  67. of_n_addr_cells 函数
  68. of_n_addr_cells 函数用于获取#address-cells 属性值，函数原型如下：
  69. intof_n_addr_cells(structdevice_node*np)
  70. 函数参数和返回值含义如下：
  71. np：设备节点。
  72. 返回值： 获取到的#address-cells 属性值
  74. of_n_size_cells 函数
  75. of_size_cells 函数用于获取#size-cells 属性值，函数原型如下：
  76. intof_n_size_cells(structdevice_node*np)
  77. 函数参数和返回值含义如下：
  78. np：设备节点。
  79. 返回值： 获取到的#size-cells 属性值。

3.其它常用OF函数

  1. 用于查看节点的 compatible 属性是否有包含 compat 指定的字
  2. 符串，也就是检查设备节点的兼容性
  3. intof_device_is_compatible(conststructdevice_node*device,constchar*compat)
  4. 函数参数和返回值含义如下：
  5. device：设备节点。
  6. compat：要查看的字符串。
  7. 返回值： 0，节点的 compatible 属性中不包含 compat 指定的字符串；正数，节点的
  8. compatible 属性中包含 compat 指定的字符串
  10. 用于获取地址相关属性，主要是“reg”或者“assigned-addresses”
  11. const __be32 *of_get_address(structdevice_node*dev,int index,u64 *size,unsignedint*flags)
  12. 函数参数和返回值含义如下：
  13. dev：设备节点。
  14. index：要读取的地址标号。
  15. size：地址长度。
  16. flags：参数，比如 IORESOURCE_IO、 IORESOURCE_MEM 等。
  17. 返回值： 读取到的地址数据首地址，为 NULL 的话表示读取失败。
  19. 将从设备树读取到的地址转换为物理地址
  20. u64 of_translate_address(structdevice_node*dev,const __be32 *in_addr)
  21. 函数参数和返回值含义如下：
  22. dev：设备节点。
  23. in_addr：要转换的地址。
  24. 返回值： 得到的物理地址，如果为 OF_BAD_ADDR 的话表示转换失败。
  26. 物理地址到虚拟地址的映射，本质上也是将 reg 属性中地址信息转换为虚拟地址
  27. void __iomem *of_iomap(structdevice_node*np,int index)
  28. 函数参数和返回值含义如下：
  29. np：设备节点。
  30. index： reg 属性中要完成内存映射的段，如果 reg 属性只有一段的话 index 就设置为 0。
  31. 返回值： 经过内存映射后的虚拟内存首地址，如果为 NULL 的话表示内存映射失败。

假设有一节点如下：

  1.     led {
  2.         compatible ="test_led";#address-cells =<1>;#size-cells =<1>;
  3.         u32-test =<111>;
  4.         reg =<0x00xFF0A00440x00x10000x00xFF0A02440x00x10000x00xFF0A02480x00x10000x00xFF0A02540x00x10000x00xFF5E00AC0x00x1000>;
  5.         array-reg-test1 =<0x1000x010x2000x020x3000x03>;
  6.         array-reg-test2 =<0x1000x01>,<0x2000x02>,<0x3000x03>;        
  7.         status ="okay";default-status ="off";};

驱动测试程序如下：

  1.     led.nd =of_find_node_by_name(NULL,"led");if(led.nd ==NULL){printk("led of_find_node_by_name = NULL !\n");return-1;}
  2.     
  3.     ret =of_property_read_string(led.nd,"status",&str);if(ret <0)printk("led read status failed !\n");elseprintk("led read status success , str = %s\n",str);if(!strcmp(str,"okay"))printk("led status on !\n");else{printk("led status off !\n");return-1;}
  4.     
  5.     ret =of_property_read_string(led.nd,"default-status",&str);if(ret <0)printk("led read default-status failed !\n");elseprintk("led read default-status success , str = %s\n",str);
  7.     ret =of_n_size_cells(led.nd);printk("led size-cells = %d\n",ret);
  9.     ret =of_n_addr_cells(led.nd);printk("led addr-cells = %d\n",ret);
  11.     ret =of_property_read_u32(led.nd,"u32-test",&read_val);if(ret ==0)printk("led u32-test = %d\n",read_val);elseprintk("led u32-test failed !\n");memset(array_val,0,sizeof(array_val));of_property_read_u32_array(led.nd,"array-reg-test1",array_val,6);for(i=0;i<6;i++)printk("led read array-reg-test1[%d] = 0x%x\n",i,array_val[i]);memset(array_val,0,sizeof(array_val));of_property_read_u32_array(led.nd,"array-reg-test2",array_val,6);for(i=0;i<6;i++)printk("led read array-reg-test2[%d] = 0x%x\n",i,array_val[i]);

insmos ko文件，可得到如下打印结果：
在这里插入图片描述

总结

以上就是今天要讲的内容，本文简单介绍了Linux中设备树的使用，制作不易，多多包涵。

标签： linux arm开发 c语言
本文转载自: https://blog.csdn.net/qq_40514606/article/details/139072740
版权归原作者 -又又- 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Linux中的设备树详解”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？