# 设备树 ## 设备树编译与反编译 `/sys/firmware/devicetree`目录下是以目录结构程现的 dtb 文件 , 根节点对应 base 目录 , 每一个节 点对应一个目录 , 每 一个属性对应一个文件 。这些属性的值如果是字符串，可以使用 cat 命令把它打印出来；对于数值，可以用 hexdump 把它打印出来。 ```bash # ls /sys/firmware devicetree fdt ``` 编译设备树 ``` 在内核根目录下 make dtbs V=1 ``` 内核目录下`scripts/dtc/dtc` 是设备树的编译工具，直接使用它的话，包含其他文件时不能使用`#include` ，而必须使用 `incldue/`。 编译、反编译的示例命令如下: -I :指 定输入格式，-O :指定输出格式，-o :指定输出文件 ```bash ./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 ``` ## 更换开发板设备树文件 对于 野火 imx6ull pro ```bash arch/arm/boot/dts/imx6ull_14x14_ebf.dtb # 编译出来的设备树文件位于内核源码路径下 更换这个文件 /boot/imx6ull_14x14_ebf.dtb # 开发板启动后设备树文件位于这个目录 ``` 对于 firefly rk3288 ```bash arch/arm/boot/dts/rk3288_firefly.dtb # 编译出来的设备树文件位于内核源码路径下 更换这个文件 /boot/rk3288_firefly.dtb # 开发板启动后设备树文件位于这个目录 ``` 还可以看到/sys/firmware/fdt 文件，它就是 dtb 格式的设备树文件，可以把它复制出来放到 ubuntu上，执行下面的命令反编译出来 -I dtb ：输入格式是 dtb -O dts ：输出 格式是 dts) ```bash ./scripts/dtc/dtc -I dtb O dts ~/fdt o tmp.dts # ~/fdt是从开发板上拷贝到ubuntu下的~目录下 ``` ## 内核对设备树的处理 ![](media/image-20200602104826186.png) - dts在PC 机上被编译为 dtb 文件； - uboot 把 dtb 文件传给内核； - 内核解析 dtb 文件，把每一个节点都转换为 device_node 结构体； - 对于某些 device_node 结构体，会被转换 为 platform_device 结构体。 dtb 中每一个节点都被转换为 device_node 结构体。根节点被保存在全局变量`of_root` 中，从 `of_root` 开始可以访问到任意节点。 ![](media/image-20200602105006365.png) ## 设备树节点被转换为 platform_device规则 1. 根节点下含有 compatile 属性的 子节点； 2. 如果一个节点的compatile 属性 ，它的值是这 4 者之一 `simple bus`、`simple`、`mfd`、`isa`、`arm,amb a bus`，那么它的子结点如果包含 compatile 属性 也可以转换为 platform_device 。 3. 总线 I2C 、 SPI 节点下的子节点 不转换 为 platform_device，某个总线下到子节点，应该交给对应的总线驱动程序来处理 , 它们不应该被转换为 platform_device 。 ```bash /{ /* * mytest会被转换为 platform_device, 满足条件1 * 子节点 mytest@0 也会被转换，满足条件2 */ mytest { compatile = "mytest", "simple bus"; mytest@0 { compatile = "mytest_0"; }; }; /* * i2c会被转换为 platform_device, 满足条件1 * 子节点 at24c02 不会被转换，它被如何处理完全由父节点的platform_driver决定 , 一般是被创建为一 * 个 i2c_client */ i2c { compatile = "samsung,i2c"; at24c02 { compatile = "at24c02"; }; }; /* * spi 会被转换为 platform_device, 满足条件1 * 子节点 flash@0 不会被转换，它被如何处理完全由父节点的platform_driver决定 , 一般是被创建为一 * 个 spi_device */ spi { compatile = "samsung,spi"; flash@0 { compatible = "winbond,w25q32dw"; spi-max-frequency = <25000000>; reg = <0>; }; }; }; ``` ## 使用设备树后的platform_device如何与 platform_driver的匹配过程 ![](media/image-20200602112340746.png) ![](media/image-20200602112427354.png) 1. 比较`platform_device. driver_override`和`platform_driver.driver.name` 2. 比较：`platform_device.dev.of_node`和`platform_driver.driver.of_match_table` 由设备树节点转换得来的`platform_device.dev`中，含有一个结构体：of_node。 ![](media/image8.png) 如果一个platform_driver支持设备树，它的`platform_driver.driver.of_match_table`是一个数组，类型如下 ![](media/image9.png) 使用设备树信息来判断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`，id_table中可能有多项 platform_driver.id_table是`platform_device_id`指针，表示该drv支持若干个device，它里面列出了各个device的{.name, .driver_data}，其中的“name”表示该drv支持的设备的名字，driver_data是些提供给该device的私有数据 4. platform_driver.id_table可能为空，这时可以根据platform_driver.driver.name来寻找同名的platform_device。 ## 设备树常用函数 ### 常用头文件 ``` 1：处理DTB of_fdt.h // dtb文件的相关操作函数, 我们一般用不到, // 因为dtb文件在内核中已经被转换为device_node树(它更易于使用) 2:处理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 ``` ### 常用函数 #### of_find_device_by_node 函数原型为： ```c 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”。这时，你可以使用这个函数取出这些资源。 函数原型为： ```c /** * 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); ``` 对于设备树节点中的`reg`属性，它属性`IORESOURCE_MEM`类型的资源； 对于设备树节点中的`interrupts`属性，它属性`IORESOURCE_IRQ`类型的资源。 #### 有些节点不会生成platform_device，怎么访问它们 内核会把dtb文件解析出一系列的device_node结构体，我们可以直接访问这些device_node。内核源码`incldue/linux/of.h`中声明了device_node和属性property的操作函数，device_node和property的结构体定义如下： #### 找到节点 1. `of_find_node_by` 根据路径找到节点，比如“/”就对应根节点，“/memory”对应memory节点。 函数原型： ```c static inline struct device_node *of_find_node_by_path(const char *path); ``` 2. `of_find_node_by_name` 根据名字找到节点，节点如果定义了name属性，那我们可以根据名字找到它。 函数原型： ```c extern struct device_node *of_find_node_by_name(struct device_node *from, const char *name); ``` 参数from表示从哪一个节点开始寻找，传入NULL表示从根节点开始寻找。 但是在设备树的官方规范中不建议使用“name”属性，所以这函数也不建议使用。 3. `of_find_node_by_type` 根据类型找到节点，节点如果定义了device_type属性，那我们可以根据类型找到它。 函数原型： ```c extern struct device_node *of_find_node_by_type(struct device_node *from, const char *type); ``` 参数from表示从哪一个节点开始寻找，传入NULL表示从根节点开始寻找。 但是在设备树的官方规范中不建议使用“device_type”属性，所以这函数也不建议使用。 4. `of_find_compatible_node` 根据compatible找到节点，节点如果定义了compatible属性，那我们可以根据compatible属性找到它。 函数原型： ```c 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。 5. `of_find_node_by_phandle` 根据phandle找到节点。dts文件被编译为dtb文件时，每一个节点都有一个数字ID，这些数字ID彼此不同。可以使用数字ID来找到device_node。这些数字ID就是phandle。函数原型： ```c extern struct device_node *of_find_node_by_phandle(phandle handle); ``` 参数from表示从哪一个节点开始寻找，传入NULL表示从根节点开始寻找。 6. `of_get_parent` 找到device_node的父节点。函数原型 ```c extern struct device_node *of_get_parent(const struct device_node *node); ``` 参数from表示从哪一个节点开始寻找，传入NULL表示从根节点开始寻找。 7. `of_get_next_parent` 这个函数名比较奇怪，怎么可能有`next parent`？ 它实际上也是找到device_node的父节点，跟of_get_parent的返回结果是一样的。 差别在于它多调用下列函数，把node节点的引用计数减少了1。这意味着调用of_get_next_parent之后，你不再需要调用of_node_put释放node节点。 ```c of_node_put(node); ``` 函数原型： ```c extern struct device_node *of_get_next_parent(struct device_node *node); ``` 参数from表示从哪一个节点开始寻找，传入NULL表示从根节点开始寻找。 8. `of_get_next_child` 取出下一个子节点。 函数原型： ```c 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参数，就可以得到所有的子节点。 9. `of_get_next_available_child` 取出下一个“可用”的子节点，有些节点的status是“disabled”，那就会跳过这些节点。函数原型： ```c struct device_node *of_get_next_available_child(const struct device_node *node, struct device_node *prev); ``` 参数node表示父节点； prev表示上一个子节点，设为NULL时表示想找到第1个子节点。 10. `of_get_child_by_name` 根据名字取出子节点。 函数原型： ```c extern struct device_node *of_get_child_by_name(const struct device_node *node, const char *name); ``` 参数node表示父节点； name表示子节点的名字。 #### 找到属性 内核源码`incldue/linux/of.h`中声明了device_node的操作函数，当然也包括属性的操作函数。 `of_find_property` 找到节点中的属性。 函数原型： ```c extern struct property *of_find_property(const struct device_node *np, const char *name, int *lenp); ``` 参数np表示节点，我们要在这个节点中找到名为name的属性。 lenp用来保存这个属性的长度，即它的值的长度。 在设备树中，节点大概是这样： ```bash xxx_node { xxx_pp_name = “hello”; }; ``` 上述节点中，“xxx_pp_name”就是属性的名字，值的长度是6。 #### 获取属性的值 1. `of_get_property` 根据名字找到节点的属性，并且返回它的值。 函数原型： ```c /* * 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用来保存这个属性的长度，即它的值的长度。 2. `of_property_count_elems_of_size` 根据名字找到节点的属性，确定它的值有多少个元素(elem)。 函数原型： ```c /* of_property_count_elems_of_size - Count the number of elements in a property * * @np: device node from which the property value is to be read. * @propname: name of the property to be searched. * @elem_size: size of the individual element * * Search for a property in a device node and count the number of elements of * size elem_size in it. Returns number of elements on sucess, -EINVAL if the * property does not exist or its length does not match a multiple of elem_size * and -ENODATA if the property does not have a value. */ int of_property_count_elems_of_size(const struct device_node *np, const char *propname, int elem_size) ``` 参数np表示节点，我们要在这个节点中找到名为propname的属性，然后返回下列结果： ```c return prop->length / elem_size; ``` 在设备树中，节点大概是这样： ```bash 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。 3. 读整数u32/u64 函数原型为： ```c 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); ``` 在设备树中，节点大概是这样： ```bash 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。 4. 读某个整数u32/u64 函数原型为： ```c extern int of_property_read_u32_index(const struct device_node *np, const char *propname, u32 index, u32 *out_value); ``` 在设备树中，节点大概是这样： ```c xxx_node { name2 = <0x50000000 0x60000000>; }; ``` 调用of_property_read_u32 (np, “name2”, 1, &val)时，val将得到值0x0x60000000。 5. 读数组 函数原型为： ```c 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); ``` 在设备树中，节点大概是这样： ```c 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。 ``` 总之，这些函数要么能取到全部的数值，要么一个数值都取不到； 如果值的长度在sz_min和sz_max之间，就返回全部的数值；否则一个数值都不返回。 6. 读字符串 函数原型为： ```c int of_property_read_string(const struct device_node *np, const char *propname, const char **out_string); ``` 返回节点np的属性(名为propname)的值，(*out_string)指向这个值，把它当作字符串。 ## 编写设备树驱动程序 实际工作中工作中，驱动要求设备树节点提供什么，我们就得按这要求去编写设备树。但是，匹配过程所要求的东西是固定的： 1. 设备树要有compatible属性，它的值是一个字符串 2. platform_driver中要有of_match_table，其中一项的.compatible成员设置为一个字符串 3. 上述2个字符串要一致。 如下图所示： ![](media/image2.png) ## 设备树驱动编写步骤 参见【04.led_driver_device_tree】工程 1. 构建自己的of_device_id结构体，里面是设备树要匹配的属性compatible； ```c static const struct of_device_id led_match_table[] = { /* 设备树匹配表 */ { .compatible = "xym-led" }, { }, }; ``` 2. 构建自己的platform驱动结构体，并填充struct of_device_id到里面 ```c static struct platform_driver led_driver = { .driver = { .name = "xym-led", /* 驱动名字，用于和设备匹配 */ .of_match_table = led_match_table, }, .probe = led_probe, .remove = led_remove, }; ``` 3. 入口函数 注册自己的 platform_driver 到平台的总线驱动链表里面注册的过程中会根据匹配规则 到【总线平台设备链表】里面找，如果匹配成功会调用驱动里面的platform_driver下的probe函数 ```c static int __init led_init(void) { printk("%s %s line %d:insmod !\n", __FILE__, __FUNCTION__, __LINE__); return platform_driver_register(&led_driver); } ``` 4. probe函数匹配成功后调用,首先获取设备树节点内容 5. probe函数完成，新字符设备驱动的注册工作 ```c static int led_probe(struct platform_device *dev) { /* * 4：匹配成功后，获取设备树中的属性数据 */ g_led_dev.nd = of_find_node_by_path("/xym_led"); if(g_led_dev.nd == NULL) { printk("xym-led node not find!\r\n"); return -EINVAL; } else { printk("xym-led node find!\r\n"); } /* * 5：剩下的又回到新字符设备那一套了 */ /* * 5.2：在probe函数中，申请设备号，把fp占着该设备号对应的槽 */ if(g_led_dev.major){ g_led_dev.devid = MKDEV(g_led_dev.major, 0); register_chrdev_region(g_led_dev.devid, 1, "xym_led"); }else{ alloc_chrdev_region(&g_led_dev.devid, 0, 1, "xym_led"); /* 申请设备号 */ g_led_dev.major = MAJOR(g_led_dev.devid); /* 获取主设备号 */ g_led_dev.minor = MINOR(g_led_dev.devid); /* 获取次设备号 */ } /* * 5.3：初始化cdev 并添加到内核 */ g_led_dev.cdev.owner = THIS_MODULE; cdev_init(&g_led_dev.cdev, &led_fops); cdev_add(&g_led_dev.cdev, g_led_dev.devid, 1); /* * 5.4：创建类 */ g_led_dev.class = class_create(THIS_MODULE, "xym_led_class"); if (IS_ERR(g_led_dev.class)) { return PTR_ERR(g_led_dev.class); } /* * 5.5：在类下创建设备节点 */ g_led_dev.device = device_create(g_led_dev.class, NULL, g_led_dev.devid, NULL, "xym_led"); /* /dev/xym_led */ if (IS_ERR(g_led_dev.device)) { return PTR_ERR(g_led_dev.device); } printk("%s %s line %d:led_probe !\n", __FILE__, __FUNCTION__, __LINE__); return 0; } ``` 6. 出口函数，当用户卸载该驱动的时候会调用 ```c static void __exit led_exit(void) { /* * 6：如果用户卸载该驱动的时候，会到这里，把平台驱动从总线中去掉 */ printk("%s %s line %d: rmmod ! \n", __FILE__, __FUNCTION__, __LINE__); platform_driver_unregister(&led_driver); } ``` 设备树代码 ``` xym_led{ #address-cells = <1>; #size-cells = <1>; compatible = "xym-led"; status = "okay"; reg = < 0x20C406C 0X04 /* CCM_CCGR1_BASE */ 0x2290014 0X04 /* IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3 */ 0x020AC000 0X04 /* GPIO5_DR_BASE */ 0x020AC004 0X04 >; /* GPIO5_GDIR_BASE */ }; ``` 在open函数中完成硬件的初始化， ```c void hw_led_init(struct device_node *nd) { u32 val = 0; int ret; u32 regdata[14]; const char *str; struct property *proper; /* 2、获取compatible属性内容 */ proper = of_find_property(nd, "compatible", NULL); if(proper == NULL) { printk("compatible property find failed\r\n"); } else { printk("compatible = %s\r\n", (char*)proper->value); } /* 3、获取status属性内容 */ ret = of_property_read_string(nd, "status", &str); if(ret < 0){ printk("status read failed!\r\n"); } else { printk("status = %s\r\n",str); } /* 4、获取reg属性内容 */ ret = of_property_read_u32_array(nd, "reg", regdata, 8); if(ret < 0) { printk("reg property read failed!\r\n"); } else { u8 i = 0; printk("reg data:\r\n"); for(i = 0; i < 8; i++) printk("%#X ", regdata[i]); printk("\r\n"); } CCM_CCGR1 = of_iomap(nd, 0); IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3 = of_iomap(nd, 1); GPIO5_DR = of_iomap(nd, 2); GPIO5_GDIR = of_iomap(nd, 3); /* GPIO5_IO03 */ /* a. 使能GPIO5 * set CCM to enable GPIO5 * CCM_CCGR1[CG15] 0x20C406C * bit[31:30] = 0b11 */ val = readl(CCM_CCGR1); val &= ~(3 << 30); /* 清除以前的设置 */ val |= (3 << 30); /* 设置新值 */ writel(val, CCM_CCGR1); /* b. 设置GPIO5_IO03用于GPIO * set IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3 * to configure GPIO5_IO03 as GPIO * IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3 0x2290014 * bit[3:0] = 0b0101 alt5 */ val = readl(IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3); val &= ~(0xf); val |= (5); writel(val,IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3); /* b. 设置GPIO5_IO03作为output引脚 * set GPIO5_GDIR to configure GPIO5_IO03 as output * GPIO5_GDIR 0x020AC000 + 0x4 * bit[3] = 0b1 */ val = readl(GPIO5_GDIR); val &= ~(1 << 3); /* 清除以前的设置 */ val |= (1 << 3); /* 设置为输出 */ writel(val, GPIO5_GDIR); /* 默认关闭LED1 */ val = readl(GPIO5_DR); val |= (1 << 3) ; writel(val, GPIO5_DR); } ```