英语

DeviceTree 内核 API

核心函数

struct device_node *of_find_all_nodes(struct device_node *prev)

获取全局列表中的下一个节点

参数

struct device_node *prev

前一个节点,或者为 NULL 以开始迭代 of_node_put() 将在其上调用

返回

一个节点指针,引用计数递增,完成后在其上使用 of_node_put()

bool of_machine_compatible_match(const char *const *compats)

根据兼容性数组测试设备树的根

参数

const char *const *compats

要查找的根节点兼容性属性中,以 NULL 结尾的兼容字符串数组。

描述

如果根节点的兼容性属性中包含任何给定的兼容值,则返回 true。

bool of_device_is_available(const struct device_node *device)

检查设备是否可用

参数

const struct device_node *device

要检查可用性的节点

返回

如果 status 属性不存在或设置为“okay”或“ok”,则为 True,

否则为 False

bool of_device_is_big_endian(const struct device_node *device)

检查设备是否具有 BE 寄存器

参数

const struct device_node *device

要检查字节序的节点

返回

如果设备具有“big-endian”属性,或者内核针对 BE 编译并且设备具有“native-endian”属性,则为 True。否则返回 false。

如果编译时使用了 BE 设备具有“native-endian”属性,则返回 true。否则返回 false。

如果 of_device_is_big_endian() == true,调用者通常会使用 ioread32be/iowrite32be,否则使用 readl/writel。

struct device_node *of_get_parent(const struct device_node *node)

获取节点的父节点(如果有)

参数

const struct device_node *node

要获取父节点的节点

返回

一个节点指针,引用计数递增,完成后在其上使用 of_node_put()

struct device_node *of_get_next_parent(struct device_node *node)

迭代到节点的父节点

参数

struct device_node *node

要获取其父节点的节点

描述

这就像 of_get_parent(),不同之处在于它会删除传递的节点上的引用计数,使其适合迭代节点的父节点。

返回

一个节点指针,引用计数递增,完成后在其上使用 of_node_put()

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

迭代节点子节点

参数

const struct device_node *node

父节点

struct device_node *prev

父节点的前一个子节点,或者为 NULL 以获取第一个子节点

返回

一个节点指针,引用计数递增,完成后在其上使用 of_node_put()。当 prev 是最后一个子节点时返回 NULL。递减 prev 的引用计数。

struct device_node *of_get_next_child_with_prefix(const struct device_node *node, struct device_node *prev, const char *prefix)

查找带有前缀的下一个子节点

参数

const struct device_node *node

父节点

struct device_node *prev

父节点的前一个子节点,或者为 NULL 以获取第一个子节点

const char *prefix

节点名称应具有的前缀

描述

此函数类似于 of_get_next_child(),不同之处在于它会自动跳过任何名称不具有给定前缀的节点。

返回

一个节点指针,引用计数递增,完成后在其上使用 of_node_put()

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

查找下一个可用的子节点

参数

const struct device_node *node

父节点

struct device_node *prev

父节点的前一个子节点,或者为 NULL 以获取第一个子节点

描述

此函数类似于 of_get_next_child(),不同之处在于它会自动跳过任何禁用的节点(即 status = "disabled")。

struct device_node *of_get_next_reserved_child(const struct device_node *node, struct device_node *prev)

查找下一个保留的子节点

参数

const struct device_node *node

父节点

struct device_node *prev

父节点的前一个子节点,或者为 NULL 以获取第一个子节点

描述

此函数类似于 of_get_next_child(),不同之处在于它会自动跳过任何禁用的节点(即 status = "disabled")。

struct device_node *of_get_next_cpu_node(struct device_node *prev)

迭代 cpu 节点

参数

struct device_node *prev

/cpus 节点的前一个子节点,或者为 NULL 以获取第一个子节点

描述

将跳过不可用的 CPU(那些 status 属性设置为“fail”或“fail-...”的 CPU)。

返回

一个 cpu 节点指针,引用计数递增,完成后在其上使用 of_node_put()。当 prev 是最后一个子节点时返回 NULL。递减 prev 的引用计数。

struct device_node *of_get_compatible_child(const struct device_node *parent, const char *compatible)

查找兼容的子节点

参数

const struct device_node *parent

父节点

const char *compatible

兼容字符串

描述

查找其 compatible 属性包含给定 compatible 字符串的子节点。

返回

一个节点指针,引用计数递增,完成后在其上使用 of_node_put();如果未找到,则为 NULL。

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

查找给定父节点的按名称查找子节点

参数

const struct device_node *node

父节点

const char *name

要查找的子节点名称。

描述

此函数查找给定匹配名称的子节点

返回

如果找到节点指针,引用计数递增,完成后在其上使用 of_node_put()。如果未找到节点,则返回 NULL。

struct device_node *of_get_available_child_by_name(const struct device_node *node, const char *name)

查找给定父节点的按名称查找可用的子节点

参数

const struct device_node *node

父节点

const char *name

要查找的子节点名称。

描述

此函数查找给定匹配名称的子节点,并检查该设备是否可用。

返回

如果找到节点指针,引用计数递增,完成后在其上使用 of_node_put()。如果未找到节点,则返回 NULL。

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

查找与完整 OF 路径匹配的节点

参数

const char *path

要匹配的完整路径,或者如果该路径不以“/”开头,则为 /aliases 节点(别名)的属性名称。如果是别名,则将返回与别名的值匹配的节点。

const char **opts

指向指针的地址,该指针用于存储附加到路径末尾并带有“:”分隔符的选项字符串的开头。

描述

有效路径
  • /foo/bar 完整路径

  • foo 有效别名

  • foo/bar 有效别名 + 相对路径

返回

一个节点指针,引用计数递增,完成后在其上使用 of_node_put()

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

按其“name”属性查找节点

参数

struct device_node *from

开始搜索的节点,或 NULL;不会搜索您传递的节点,只会搜索下一个节点。通常,您传递的是前一个调用返回的内容。of_node_put() 将在 from 上调用。

const char *name

要匹配的名称字符串

返回

一个节点指针,引用计数递增,完成后在其上使用 of_node_put()

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

按其“device_type”属性查找节点

参数

struct device_node *from

开始搜索的节点,或 NULL 以开始搜索整个设备树。不会搜索您传递的节点,只会搜索下一个节点;通常,您传递的是前一个调用返回的内容。of_node_put() 将为您在 from 上调用。

const char *type

要匹配的类型字符串

返回

一个节点指针,引用计数递增,完成后在其上使用 of_node_put()

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

基于类型及其“compatible”属性中的一个标记查找节点

参数

struct device_node *from

开始搜索的节点,或 NULL。传递的节点不会被搜索,只会搜索下一个节点;通常,传递前一次调用返回的结果。of_node_put() 将被调用于它

const char *type

要匹配的“device_type”字符串,或 NULL 以忽略

const char *compatible

要与设备“compatible”列表中的一个标记匹配的字符串。

返回

一个节点指针,引用计数递增,完成后在其上使用 of_node_put()

struct device_node *of_find_node_with_property(struct device_node *from, const char *prop_name)

查找具有给定名称的属性的节点。

参数

struct device_node *from

开始搜索的节点,或 NULL。传递的节点不会被搜索,只会搜索下一个节点;通常,传递前一次调用返回的结果。of_node_put() 将被调用于它

const char *prop_name

要查找的属性的名称。

返回

一个节点指针,引用计数递增,完成后在其上使用 of_node_put()

const struct of_device_id *of_match_node(const struct of_device_id *matches, const struct device_node *node)

判断 device_node 是否具有匹配的 of_match 结构

参数

const struct of_device_id *matches

要搜索的 of 设备匹配结构数组

const struct device_node *node

要匹配的 of 设备结构

描述

设备匹配使用的底层实用程序函数。

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)

基于 of_device_id 匹配表查找节点。

参数

struct device_node *from

开始搜索的节点,或 NULL。传递的节点不会被搜索,只会搜索下一个节点;通常,传递前一次调用返回的结果。of_node_put() 将被调用于它

const struct of_device_id *matches

要搜索的 of 设备匹配结构数组

const struct of_device_id **match

更新为指向匹配的 matches 条目

返回

一个节点指针,引用计数递增,完成后在其上使用 of_node_put()

int of_alias_from_compatible(const struct device_node *node, char *alias, int len)

根据 compatible 查找设备节点的适当别名

参数

const struct device_node *node

指向设备树节点的指针

char *alias

指向别名值将被复制到的缓冲区的指针

int len

别名值的长度

描述

根据 compatible 属性的值,此例程将尝试为特定的设备树节点选择适当的别名值。它通过从 compatible 列表属性中的第一个条目中删除制造商前缀(由“,”分隔)来实现此目的。

注意

仅匹配 compatible 的“product”部分是 I2C 和 SPI 的遗留问题。请不要添加任何新用户。

返回

此例程在成功时返回 0,失败时返回 <0。

struct device_node *of_find_node_by_phandle(phandle handle)

给定 phandle 查找节点

参数

phandle handle

要查找的节点的 phandle

返回

一个节点指针,引用计数递增,完成后在其上使用 of_node_put()

int of_parse_phandle_with_args_map(const struct device_node *np, const char *list_name, const char *stem_name, int index, struct of_phandle_args *out_args)

查找列表中 phandle 指向的节点并重新映射它

参数

const struct device_node *np

指向包含列表的设备树节点的指针

const char *list_name

包含列表的属性名称

const char *stem_name

指定 phandle 参数计数的属性名称的词干

int index

要解析出的 phandle 的索引

struct of_phandle_args *out_args

指向输出参数结构的可选指针(将被填充)

描述

此函数对于解析 phandle 及其参数的列表很有用。成功时返回 0 并填充 out_args,出错时返回适当的 errno 值。此函数与 of_parse_phandle_with_args() 之间的区别在于,如果 phandle 指向的节点具有 <stem_name>-map 属性,则此 API 会重新映射 phandle。

调用者负责在返回的 out_args->np 指针上调用 of_node_put()

示例

phandle1: node1 {
    #list-cells = <2>;
};

phandle2: node2 {
    #list-cells = <1>;
};

phandle3: node3 {
    #list-cells = <1>;
    list-map = <0 &phandle2 3>,
               <1 &phandle2 2>,
               <2 &phandle1 5 1>;
    list-map-mask = <0x3>;
};

node4 {
    list = <&phandle1 1 2 &phandle3 0>;
};

要获取 node2 节点的 device_node,您可以调用此函数:of_parse_phandle_with_args(node4, “list”, “list”, 1, args);

int of_count_phandle_with_args(const struct device_node *np, const char *list_name, const char *cells_name)

查找属性中 phandle 引用的数量

参数

const struct device_node *np

指向包含列表的设备树节点的指针

const char *list_name

包含列表的属性名称

const char *cells_name

指定 phandle 参数计数的属性名称

返回

属性中 phandle + 参数元组的数量。通常的模式是将 phandle 和可变参数列表编码到单个属性中。参数的数量由 phandle 目标节点中的属性编码。例如,gpios 属性将包含一个 GPIO 规范列表,该列表由一个 phandle 和 1 个或多个参数组成。参数的数量由 phandle 指向的节点中的 #gpio-cells 属性确定。

int of_add_property(struct device_node *np, struct property *prop)

将属性添加到节点

参数

struct device_node *np

调用者的设备节点

struct property *prop

要添加的属性

int of_remove_property(struct device_node *np, struct property *prop)

从节点中删除属性。

参数

struct device_node *np

调用者的设备节点

struct property *prop

要删除的属性

描述

请注意,我们实际上并没有删除它,因为我们已经使用 get-property 发出了许多指向数据的指针。相反,我们只是将属性移动到“dead properties”列表中,这样就不会再找到它。

int of_alias_get_id(const struct device_node *np, const char *stem)

获取给定 device_node 的别名 ID

参数

const struct device_node *np

指向给定 device_node 的指针

const char *stem

给定 device_node 的别名词干

描述

该函数遍历查找表,以获取给定 device_node 和别名词干的别名 ID。

返回

如果找到别名 ID。

int of_alias_get_highest_id(const char *stem)

获取给定词干的最高别名 ID

参数

const char *stem

要检查的别名词干

描述

该函数遍历查找表,以获取给定别名词干的最高别名 ID。如果找到,则返回别名 ID。

bool of_console_check(const struct device_node *dn, char *name, int index)

测试并设置 DT 设置的控制台

参数

const struct device_node *dn

指向设备节点的指针

char *name

用于首选控制台的名称,不带索引。例如,“ttyS”

int index

用于首选控制台的索引。

描述

检查给定的设备节点是否与 /chosen 节点中的 stdout-path 属性匹配。如果匹配,则将其注册为首选控制台。

返回

如果控制台设置成功,则为 TRUE。否则返回 FALSE。

int of_map_id(const struct device_node *np, u32 id, const char *map_name, const char *map_mask_name, struct device_node **target, u32 *id_out)

通过下游映射转换 ID。

参数

const struct device_node *np

根复合体设备节点。

u32 id

要映射的设备 ID。

const char *map_name

要使用的映射的属性名称。

const char *map_mask_name

要使用的掩码的可选属性名称。

struct device_node **target

指向目标设备节点的可选指针。

u32 *id_out

指向接收转换后的 ID 的可选指针。

描述

给定设备 ID,根据“iommu-map”和“msi-map”绑定,查找适当的实现定义的平台 ID 和/或接收该 ID 上事务的目标设备。如果只需要另一个,则 targetid_out 中的任何一个都可以为 NULL。如果 target 指向非 NULL 设备节点指针,则只会匹配以该节点为目标的条目;如果它指向 NULL 值,它将接收第一个匹配目标 phandle 的设备节点,并保留引用。

返回

成功时为 0,失败时为标准错误代码。

void of_node_init(struct device_node *node)

初始化 devicetree 节点

参数

struct device_node *node

指向由 kzalloc() 创建的设备节点的指针

描述

返回时,device_node 引用计数设置为 1。完成后,在 node 上使用 of_node_put() 释放为其分配的内存。如果节点不是动态节点,则不会释放内存。是否释放内存的决定将由 node->release() 完成,即 of_node_release()。

bool of_machine_is_compatible(const char *compat)

测试设备树的根是否具有给定的 compatible 值

参数

const char *compat

要在根节点的 compatible 属性中查找的 compatible 字符串。

返回

如果根节点的 compatible 属性中具有给定的值,则为 true。

struct device_node *of_parse_phandle(const struct device_node *np, const char *phandle_name, int index)

将 phandle 属性解析为 device_node 指针

参数

const struct device_node *np

指向保存 phandle 属性的设备节点的指针

const char *phandle_name

保存 phandle 值的属性的名称

int index

对于保存 phandle 表的属性,这是表中的索引

返回

device_node 指针,引用计数已递增。完成后,对其使用 of_node_put()

int of_parse_phandle_with_args(const struct device_node *np, const char *list_name, const char *cells_name, int index, struct of_phandle_args *out_args)

查找列表中 phandle 指向的节点

参数

const struct device_node *np

指向包含列表的设备树节点的指针

const char *list_name

包含列表的属性名称

const char *cells_name

指定 phandle 参数计数的属性名称

int index

要解析出的 phandle 的索引

struct of_phandle_args *out_args

指向输出参数结构的可选指针(将被填充)

描述

此函数可用于解析 phandle 及其参数的列表。成功时返回 0 并填充 out_args,出错时返回相应的 errno 值。

调用者负责在返回的 out_args->np 指针上调用 of_node_put()

示例

phandle1: node1 {
    #list-cells = <2>;
};

phandle2: node2 {
    #list-cells = <1>;
};

node3 {
    list = <&phandle1 1 2 &phandle2 3>;
};

要获取 node2 节点的 device_node,您可以调用此函数:of_parse_phandle_with_args(node3, “list”, “#list-cells”, 1, args);

int of_parse_phandle_with_fixed_args(const struct device_node *np, const char *list_name, int cell_count, int index, struct of_phandle_args *out_args)

查找列表中 phandle 指向的节点

参数

const struct device_node *np

指向包含列表的设备树节点的指针

const char *list_name

包含列表的属性名称

int cell_count

phandle 后面的参数单元的数量

int index

要解析出的 phandle 的索引

struct of_phandle_args *out_args

指向输出参数结构的可选指针(将被填充)

描述

此函数可用于解析 phandle 及其参数的列表。成功时返回 0 并填充 out_args,出错时返回相应的 errno 值。

调用者负责在返回的 out_args->np 指针上调用 of_node_put()

示例

phandle1: node1 {
};

phandle2: node2 {
};

node3 {
    list = <&phandle1 0 2 &phandle2 2 3>;
};

要获取 node2 节点的 device_node,您可以调用此函数:of_parse_phandle_with_fixed_args(node3, “list”, 2, 1, args);

int of_parse_phandle_with_optional_args(const struct device_node *np, const char *list_name, const char *cells_name, int index, struct of_phandle_args *out_args)

查找列表中 phandle 指向的节点

参数

const struct device_node *np

指向包含列表的设备树节点的指针

const char *list_name

包含列表的属性名称

const char *cells_name

指定 phandle 参数计数的属性名称

int index

要解析出的 phandle 的索引

struct of_phandle_args *out_args

指向输出参数结构的可选指针(将被填充)

描述

of_parse_phandle_with_args() 相同,除非未找到 cells_name 属性,否则假定 cell_count 为 0。

如果您有一个之前没有参数的 phandle,因此没有 '#*-cells' 属性,但现在已迁移到具有参数,同时保留向后兼容性,则此方法非常有用。

bool of_phandle_args_equal(const struct of_phandle_args *a1, const struct of_phandle_args *a2)

比较两个 of_phandle_args

参数

const struct of_phandle_args *a1

要比较的第一个 of_phandle_args

const struct of_phandle_args *a2

要比较的第二个 of_phandle_args

返回

如果 a1 和 a2 相同(相同的节点指针,相同的 phandle 参数),则为 True,否则为 False。

int of_property_count_u8_elems(const struct device_node *np, const char *propname)

计算属性中 u8 元素的数量

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

描述

在设备节点中搜索属性并计算其中的 u8 元素的数量。

返回

成功时返回元素的数量,如果属性不存在或其长度与 u8 的倍数不匹配,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA。

int of_property_count_u16_elems(const struct device_node *np, const char *propname)

计算属性中 u16 元素的数量

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

描述

在设备节点中搜索属性并计算其中的 u16 元素的数量。

返回

成功时返回元素的数量,如果属性不存在或其长度与 u16 的倍数不匹配,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA。

int of_property_count_u32_elems(const struct device_node *np, const char *propname)

计算属性中 u32 元素的数量

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

描述

在设备节点中搜索属性并计算其中的 u32 元素的数量。

返回

成功时返回元素的数量,如果属性不存在或其长度与 u32 的倍数不匹配,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA。

int of_property_count_u64_elems(const struct device_node *np, const char *propname)

计算属性中 u64 元素的数量

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

描述

在设备节点中搜索属性并计算其中的 u64 元素的数量。

返回

成功时返回元素的数量,如果属性不存在或其长度与 u64 的倍数不匹配,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA。

int of_property_read_string_array(const struct device_node *np, const char *propname, const char **out_strs, size_t sz)

从多个字符串属性中读取字符串数组。

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

const char **out_strs

字符串指针的输出数组。

size_t sz

要读取的数组元素的数量。

描述

在设备树节点中搜索属性并检索该属性中以 null 结尾的字符串值的列表(指向数据,而不是副本)。

返回

如果 out_strs 为 NULL,则返回属性中字符串的数量。

int of_property_count_strings(const struct device_node *np, const char *propname)

查找并返回多个字符串属性中字符串的数量。

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

描述

在设备树节点中搜索属性并检索其中包含的以 null 结尾的字符串的数量。

返回

成功时返回字符串的数量,如果属性不存在,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA;如果字符串在属性数据的长度内未以 null 结尾,则返回 -EILSEQ。

int of_property_read_string_index(const struct device_node *np, const char *propname, int index, const char **output)

从多个字符串属性中查找和读取字符串。

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

int index

字符串列表中字符串的索引

const char **output

指向以 null 结尾的返回字符串的指针,仅当返回值是 0 时才修改。

描述

在设备树节点中搜索属性并检索该属性中包含的字符串列表中以 null 结尾的字符串值(指向数据,而不是副本)。

仅当可以解码有效字符串时,才会修改 out_string 指针。

返回

成功时返回 0,如果属性不存在,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA;如果字符串在属性数据的长度内未以 null 结尾,则返回 -EILSEQ。

bool of_property_present(const struct device_node *np, const char *propname)

测试节点中是否存在属性

参数

const struct device_node *np

要在其中搜索属性的设备节点。

const char *propname

要搜索的属性的名称。

描述

测试设备节点中是否存在属性。

返回

如果属性存在则为 true,否则为 false。

int of_property_read_u8_array(const struct device_node *np, const char *propname, u8 *out_values, size_t sz)

查找并从属性中读取 u8 数组。

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

u8 *out_values

指向返回值的指针,仅当返回值是 0 时才修改。

size_t sz

要读取的数组元素的数量

描述

在设备节点中搜索属性并从中读取 8 位值。

数组的 dts 条目应如下所示

property = /bits/ 8 <0x50 0x60 0x70>;

仅当可以解码有效的 u8 值时,才会修改 out_values。

返回

成功时返回 0,如果属性不存在,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA;如果属性数据不够大,则返回 -EOVERFLOW。

int of_property_read_u16_array(const struct device_node *np, const char *propname, u16 *out_values, size_t sz)

查找并从属性中读取 u16 数组。

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

u16 *out_values

指向返回值的指针,仅当返回值是 0 时才修改。

size_t sz

要读取的数组元素的数量

描述

在设备节点中搜索属性并从中读取 16 位值。

数组的 dts 条目应如下所示

property = /bits/ 16 <0x5000 0x6000 0x7000>;

仅当可以解码有效的 u16 值时,才会修改 out_values。

返回

成功时返回 0,如果属性不存在,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA;如果属性数据不够大,则返回 -EOVERFLOW。

int of_property_read_u32_array(const struct device_node *np, const char *propname, u32 *out_values, size_t sz)

查找并从属性中读取 32 位整数数组。

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

u32 *out_values

指向返回值的指针,仅当返回值是 0 时才修改。

size_t sz

要读取的数组元素的数量

描述

在设备节点中搜索属性并从中读取 32 位值。

只有在可以解码有效的 u32 值时,out_values 才会修改。

返回

成功时返回 0,如果属性不存在,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA;如果属性数据不够大,则返回 -EOVERFLOW。

int of_property_read_u64_array(const struct device_node *np, const char *propname, u64 *out_values, size_t sz)

查找并从属性中读取 64 位整数数组。

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

u64 *out_values

指向返回值的指针,仅当返回值是 0 时才修改。

size_t sz

要读取的数组元素的数量

描述

在设备节点中搜索属性,并从中读取 64 位值。

只有在可以解码有效的 u64 值时,out_values 才会修改。

返回

成功时返回 0,如果属性不存在,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA;如果属性数据不够大,则返回 -EOVERFLOW。

struct of_changeset_entry

保存一个变更集条目

定义:

struct of_changeset_entry {
    struct list_head node;
    unsigned long action;
    struct device_node *np;
    struct property *prop;
    struct property *old_prop;
};

成员

node

日志列表的 list_head

action

通知器操作

np

指向受影响的设备节点的指针

prop

指向受影响的属性的指针

old_prop

保存指向原始属性的指针

描述

变更集期间对设备树的每次修改都保存在 of_changeset_entry 结构的列表中。这样,我们可以从部分应用中恢复,或者可以还原变更集

struct of_changeset

变更集跟踪器结构

定义:

struct of_changeset {
    struct list_head entries;
};

成员

entries

变更集条目的 list_head

描述

变更集是将批量更改应用于实时树的便捷方式。如果出现错误,更改将被回滚。变更集在初始应用后仍然存在,如果在使用后未销毁,则可以通过一次调用来还原它们。

bool of_device_is_system_power_controller(const struct device_node *np)

判断是否为 device_node 找到了 system-power-controller

参数

const struct device_node *np

指向给定 device_node 的指针

返回

如果存在则为 true,否则为 false

bool of_have_populated_dt(void)

引导加载程序是否已填充 DT

参数

void

无参数

返回

如果 DTB 已由引导加载程序填充,并且不是空的内置 DTB,则为 True。否则为 False。

bool of_property_read_bool(const struct device_node *np, const char *propname)

查找属性

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

描述

在设备节点中搜索布尔属性。 不建议在非布尔属性类型上使用。

返回

如果属性存在则为 true,否则为 false。

bool of_graph_is_present(const struct device_node *node)

检查 graph 是否存在

参数

const struct device_node *node

指向包含 graph 端口的 device_node 的指针

返回

如果 node 具有端口或端口(带有端口)子节点,则为 True,否则为 False。

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

计算属性中元素的数量

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

int elem_size

单个元素的大小

描述

在设备节点中搜索属性,并计算其中大小为 elem_size 的元素的数量。

返回

成功时返回元素的数量,如果属性不存在或其长度与 elem_size 的倍数不匹配,则返回 -EINVAL,如果属性没有值,则返回 -ENODATA。

int of_property_read_u16_index(const struct device_node *np, const char *propname, u32 index, u16 *out_value)

查找并从多值属性中读取 u16。

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

u32 index

u16 在值列表中的索引

u16 *out_value

指向返回值的指针,只有在没有错误时才修改。

描述

在设备节点中搜索属性,并从中读取第 n 个 16 位值。

只有在可以解码有效的 u16 值时,out_value 才会修改。

返回

成功时返回 0,如果属性不存在,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA;如果属性数据不够大,则返回 -EOVERFLOW。

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

查找并从多值属性中读取 u32。

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

u32 index

u32 在值列表中的索引

u32 *out_value

指向返回值的指针,只有在没有错误时才修改。

描述

在设备节点中搜索属性,并从中读取第 n 个 32 位值。

只有在可以解码有效的 u32 值时,out_value 才会修改。

返回

成功时返回 0,如果属性不存在,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA;如果属性数据不够大,则返回 -EOVERFLOW。

int of_property_read_u64_index(const struct device_node *np, const char *propname, u32 index, u64 *out_value)

查找并从多值属性中读取 u64。

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

u32 index

u64 在值列表中的索引

u64 *out_value

指向返回值的指针,只有在没有错误时才修改。

描述

在设备节点中搜索属性,并从中读取第 n 个 64 位值。

只有在可以解码有效的 u64 值时,out_value 才会修改。

返回

成功时返回 0,如果属性不存在,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA;如果属性数据不够大,则返回 -EOVERFLOW。

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)

查找并从属性中读取 u8 数组,数组大小有最小和最大限制。

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

u8 *out_values

指向找到的值的指针。

size_t sz_min

要读取的最小数组元素数

size_t sz_max

要读取的最大数组元素数,如果为零,则 dts 条目中元素的数量没有上限,但只会读取 sz_min。

描述

在设备节点中搜索属性并从中读取 8 位值。

数组的 dts 条目应如下所示

property = /bits/ 8 <0x50 0x60 0x70>;

仅当可以解码有效的 u8 值时,才会修改 out_values。

返回

成功时返回读取的元素数,如果属性不存在,则返回 -EINVAL,如果属性没有值,则返回 -ENODATA,如果属性数据小于 sz_min 或长于 sz_max,则返回 -EOVERFLOW。

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)

查找并从属性中读取 u16 数组,数组大小有最小和最大限制。

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

u16 *out_values

指向找到的值的指针。

size_t sz_min

要读取的最小数组元素数

size_t sz_max

要读取的最大数组元素数,如果为零,则 dts 条目中元素的数量没有上限,但只会读取 sz_min。

描述

在设备节点中搜索属性并从中读取 16 位值。

数组的 dts 条目应如下所示

property = /bits/ 16 <0x5000 0x6000 0x7000>;

仅当可以解码有效的 u16 值时,才会修改 out_values。

返回

成功时返回读取的元素数,如果属性不存在,则返回 -EINVAL,如果属性没有值,则返回 -ENODATA,如果属性数据小于 sz_min 或长于 sz_max,则返回 -EOVERFLOW。

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)

查找并从属性中读取 32 位整数数组,数组大小有最小和最大限制。

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

u32 *out_values

指向返回的找到的值的指针。

size_t sz_min

要读取的最小数组元素数

size_t sz_max

要读取的最大数组元素数,如果为零,则 dts 条目中元素的数量没有上限,但只会读取 sz_min。

描述

在设备节点中搜索属性并从中读取 32 位值。

只有在可以解码有效的 u32 值时,out_values 才会修改。

返回

成功时返回读取的元素数,如果属性不存在,则返回 -EINVAL,如果属性没有值,则返回 -ENODATA,如果属性数据小于 sz_min 或长于 sz_max,则返回 -EOVERFLOW。

int of_property_read_u64(const struct device_node *np, const char *propname, u64 *out_value)

查找并从属性中读取 64 位整数

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

u64 *out_value

指向返回值的指针,仅当返回值是 0 时才修改。

描述

在设备节点中搜索属性,并从中读取 64 位值。

只有在可以解码有效的 u64 值时,out_value 才会修改。

返回

成功时返回 0,如果属性不存在,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA;如果属性数据不够大,则返回 -EOVERFLOW。

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)

查找并从属性中读取 64 位整数数组,数组大小有最小和最大限制。

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

u64 *out_values

指向找到的值的指针。

size_t sz_min

要读取的最小数组元素数

size_t sz_max

要读取的最大数组元素数,如果为零,则 dts 条目中元素的数量没有上限,但只会读取 sz_min。

描述

在设备节点中搜索属性,并从中读取 64 位值。

只有在可以解码有效的 u64 值时,out_values 才会修改。

返回

成功时返回读取的元素数,如果属性不存在,则返回 -EINVAL,如果属性没有值,则返回 -ENODATA,如果属性数据小于 sz_min 或长于 sz_max,则返回 -EOVERFLOW。

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

查找并从属性中读取字符串

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

const char **out_string

指向以 null 结尾的返回字符串的指针,仅当返回值是 0 时才修改。

描述

在设备树节点中搜索属性,并检索以 null 结尾的字符串值(指向数据的指针,而不是副本)。

请注意,空字符串 "" 的长度为 1,因此 -ENODATA 不能解释为空字符串。

仅当可以解码有效字符串时,才会修改 out_string 指针。

返回

成功时返回 0,如果属性不存在,则返回 -EINVAL;如果属性没有值,则返回 -ENODATA;如果字符串在属性数据的长度内未以 null 结尾,则返回 -EILSEQ。

int of_property_match_string(const struct device_node *np, const char *propname, const char *string)

在列表中查找字符串并返回索引

参数

const struct device_node *np

指向包含字符串列表属性的节点的指针

const char *propname

字符串列表属性名称

const char *string

指向要在字符串列表中搜索的字符串的指针

描述

在设备节点属性(字符串列表)中搜索字符串的完全匹配项。

返回

成功时返回字符串首次出现的索引,如果属性不存在,则返回 -EINVAL,如果属性没有值,则返回 -ENODATA,如果字符串在属性数据的长度内未以 null 结尾,则返回 -EILSEQ。

int of_property_read_string_helper(const struct device_node *np, const char *propname, const char **out_strs, size_t sz, int skip)

用于解析字符串属性的实用程序帮助程序

参数

const struct device_node *np

从中读取属性值的设备节点。

const char *propname

要搜索的属性的名称。

const char **out_strs

字符串指针的输出数组。

size_t sz

要读取的数组元素的数量。

int skip

要跳过列表中开头的字符串数。

描述

不要直接调用此函数。 它是 of_property_read_string*() 系列函数的实用程序帮助程序。

int of_graph_parse_endpoint(const struct device_node *node, struct of_endpoint *endpoint)

解析通用端点节点属性

参数

const struct device_node *node

指向端点 device_node 的指针

struct of_endpoint *endpoint

指向 OF 端点数据结构的指针

描述

调用者应该持有对 node 的引用。

struct device_node *of_graph_get_port_by_id(struct device_node *parent, u32 id)

获取匹配给定 ID 的端口

参数

struct device_node *parent

指向父设备节点的指针

u32 id

端口的 ID

返回

带有引用计数递增的 ‘port’ 节点指针。 完成后,调用者必须对其使用 of_node_put()

struct device_node *of_graph_get_next_port(const struct device_node *parent, struct device_node *prev)

获取下一个端口节点。

参数

const struct device_node *parent

指向父设备节点或父端口节点的指针

struct device_node *prev

前一个端口节点,或者为 NULL 以获取第一个端口节点

描述

无论设备节点是否具有端口节点,父设备节点都可以用作 parent。 它的工作方式与 ports**0** 节点相同。

返回

带有引用计数递增的 ‘port’ 节点指针。 传递的 prev 节点的引用计数会递减。

struct device_node *of_graph_get_next_port_endpoint(const struct device_node *port, struct device_node *prev)

获取端口中的下一个端点节点。 如果到达端口末尾,它将返回 NULL。

参数

const struct device_node *port

指向目标端口节点的指针

struct device_node *prev

前一个端点节点,或者为 NULL 以获取第一个端点节点

返回

带有引用计数递增的 ‘endpoint’ 节点指针。 传递的 prev 节点的引用计数会递减。

struct device_node *of_graph_get_next_endpoint(const struct device_node *parent, struct device_node *prev)

获取下一个端点节点

参数

const struct device_node *parent

指向父设备节点的指针

struct device_node *prev

前一个端点节点,或者为 NULL 以获取第一个端点节点

返回

带有引用计数递增的 ‘endpoint’ 节点指针。 传递的 prev 节点的引用计数会递减。

struct device_node *of_graph_get_endpoint_by_regs(const struct device_node *parent, int port_reg, int reg)

获取特定标识符的端点节点

参数

const struct device_node *parent

指向父设备节点的指针

int port_reg

父端口节点的标识符(reg 属性的值)

int reg

端点节点的标识符(reg 属性的值)

返回

由 reg 标识且同时是由 port_reg 标识的端口节点的子节点的 ‘endpoint’ 节点指针。 当 reg 和 port_reg 为 -1 时,它们将被忽略。 完成后,对指针使用 of_node_put()

struct device_node *of_graph_get_remote_endpoint(const struct device_node *node)

获取远程端点节点

参数

const struct device_node *node

指向本地端点 device_node 的指针

返回

与链接的远程端点节点关联的远程端点节点

node。 完成后,对它使用 of_node_put()

struct device_node *of_graph_get_port_parent(struct device_node *node)

获取端口的父节点

参数

struct device_node *node

指向本地端点 device_node 的指针

返回

与链接的端点节点关联的设备节点

node。 完成后,对它使用 of_node_put()

struct device_node *of_graph_get_remote_port_parent(const struct device_node *node)

获取远程端口的父节点

参数

const struct device_node *node

指向本地端点 device_node 的指针

返回

与链接的远程端点节点关联的远程设备节点

node。 完成后,对它使用 of_node_put()

struct device_node *of_graph_get_remote_port(const struct device_node *node)

获取远程端口节点

参数

const struct device_node *node

指向本地端点 device_node 的指针

返回

与链接到 node 的远程端点节点关联的远程端口节点。 完成后,对它使用 of_node_put()

unsigned int of_graph_get_endpoint_count(const struct device_node *np)

获取设备节点中的端点数量

参数

const struct device_node *np

包含端口和端点的父设备节点

返回

此设备节点的端点计数

unsigned int of_graph_get_port_count(struct device_node *np)

获取设备或端口节点中的端口数量

参数

struct device_node *np

指向设备或端口节点的指针

返回

此设备或端口节点的端口计数

struct device_node *of_graph_get_remote_node(const struct device_node *node, u32 port, u32 endpoint)

获取给定端口/端点的远程父设备节点

参数

const struct device_node *node

指向包含图端口/端点的父设备节点的指针

u32 port

父端口节点的标识符(reg 属性的值)

u32 endpoint

端点节点的标识符(reg 属性的值)

返回

与链接到 node 的远程端点节点关联的远程设备节点。 完成后,对它使用 of_node_put()

struct of_endpoint

OF 图端点数据结构

定义:

struct of_endpoint {
    unsigned int port;
    unsigned int id;
    const struct device_node *local_node;
};

成员

端口

此端点所属端口的标识符(reg 属性的值)

ID

此端点的标识符(reg 属性的值)

local_node

指向此端点的 device_node 的指针

for_each_endpoint_of_node

for_each_endpoint_of_node (parent, child)

迭代设备节点中的每个端点

参数

父节点

包含端口和端点的父设备节点

子节点

指向当前端点节点的循环变量

描述

当跳出循环时,必须手动调用 of_node_put(child)。

for_each_of_graph_port

for_each_of_graph_port (parent, child)

迭代设备或端口节点中的每个端口

参数

父节点

包含端口的父设备或端口节点

子节点

指向当前端口节点的循环变量

描述

当跳出循环并继续使用 child 时,您需要使用 return_ptr(child) 或 no_free_ptr(child),而不是调用 __free()。

for_each_of_graph_port_endpoint

for_each_of_graph_port_endpoint (parent, child)

迭代端口节点中的每个端点

参数

父节点

父端口节点

子节点

指向当前端点节点的循环变量

描述

当跳出循环并继续使用 child 时,您需要使用 return_ptr(child) 或 no_free_ptr(child),而不是调用 __free()。

const __be32 *of_translate_dma_region(struct device_node *dev, const __be32 *prop, phys_addr_t *start, size_t *length)

转换设备树地址和大小元组

参数

struct device_node *dev

要为其转换的设备树节点

const __be32 *prop

指向单元格数组的指针

phys_addr_t *start

DMA 范围起点的返回值

size_t *length

DMA 范围长度的返回值

描述

返回指向紧随转换后的 DMA 区域之后的单元格的指针。

int of_property_read_reg(struct device_node *np, int idx, u64 *addr, u64 *size)

检索指定的 “reg” 条目索引,无需转换

参数

struct device_node *np

要从中检索 “reg” 的设备树节点

int idx

要读取的 “reg” 条目索引

u64 *addr

未转换地址的返回值

u64 *size

条目大小的返回值

描述

如果找不到 “reg”,则返回 -EINVAL。 成功时返回 0,并填充 addr 和 size 值。

bool of_dma_is_coherent(struct device_node *np)

检查设备是否一致

参数

struct device_node *np

设备节点

描述

如果在 DT 中为此设备找到 “dma-coherent” 属性,或者在当前平台上 OF 设备的 DMA 默认一致,并且未为此设备找到 “dma-noncoherent” 属性,则返回 true。

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

转换设备树地址并作为资源返回

参数

struct device_node *dev

调用者的设备节点

int index

数组中的索引

struct resource *r

指向资源数组的指针

描述

如果无法将范围转换为资源,则返回 -EINVAL。

请注意,如果您的地址是 PIO 地址,则如果无法在内部使用 pci_address_to_pio() 将物理地址转换为 IO 令牌,则转换将失败,这是因为它要么调用得太早,要么无法与任何主机桥 IO 空间匹配

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

映射给定 device_node 的内存映射 IO

参数

struct device_node *np

将映射其 io 范围的设备

int index

io 范围的索引

描述

返回指向映射内存的指针

unsigned int irq_of_parse_and_map(struct device_node *dev, int index)

解析中断并将其映射到 Linux virq 空间

参数

struct device_node *dev

要映射中断的设备的设备节点

int index

要映射的中断的索引

描述

此函数是一个封装器,它将 of_irq_parse_one() 和 irq_create_of_mapping() 链接在一起,以便于调用者使用

struct device_node *of_irq_find_parent(struct device_node *child)

给定一个设备节点,查找其中断父节点

参数

struct device_node *child

指向设备节点的指针

返回

指向中断父节点的指针,引用计数增加,如果无法确定中断父节点,则为 NULL。

int of_irq_parse_raw(const __be32 *addr, struct of_phandle_args *out_irq)

底层中断树解析

参数

const __be32 *addr

地址说明符(设备“reg”属性的开头),格式为 be32

struct of_phandle_args *out_irq

由此函数更新的 of_phandle_args 结构

描述

此函数是一个低级中断树遍历函数。它可用于使用合成的 reg 和 interrupts 属性执行部分遍历,例如,当在没有父节点的设备节点的情况下解析 PCI 中断时。它将中断说明符结构作为输入,遍历树以查找任何 interrupt-map 属性,转换每个映射的说明符,然后返回转换后的映射。

返回

成功时返回 0,错误时返回负数

注意

成功时,节点 out_irq->np 的引用计数增加 1。

int of_irq_parse_one(struct device_node *device, int index, struct of_phandle_args *out_irq)

解析设备的中断

参数

struct device_node *device

要解析中断的设备

int index

要解析的中断的索引

struct of_phandle_args *out_irq

由此函数填充的 of_phandle_args 结构

描述

此函数通过遍历中断树,找到它所连接的中断控制器节点,并返回可用于检索 Linux IRQ 号码的中断说明符来解析节点的中断。

注意

成功时,节点 out_irq->np 的引用计数增加 1。

int of_irq_to_resource(struct device_node *dev, int index, struct resource *r)

解码节点的 IRQ 并将其作为资源返回

参数

struct device_node *dev

指向设备树节点的指针

int index

IRQ 的从零开始的索引

struct resource *r

指向资源结构的指针,用于返回结果。

int of_irq_get(struct device_node *dev, int index)

解码节点的 IRQ 并将其作为 Linux IRQ 号码返回

参数

struct device_node *dev

指向设备树节点的指针

int index

IRQ 的从零开始的索引

返回

成功时返回 Linux IRQ 号码,IRQ 映射失败时返回 0,如果尚未创建 IRQ 域,则返回 -EPROBE_DEFER,或者在发生任何其他故障时返回错误代码。

int of_irq_get_byname(struct device_node *dev, const char *name)

解码节点的 IRQ 并将其作为 Linux IRQ 号码返回

参数

struct device_node *dev

指向设备树节点的指针

const char *name

IRQ 名称

返回

成功时返回 Linux IRQ 号码,IRQ 映射失败时返回 0,如果尚未创建 IRQ 域,则返回 -EPROBE_DEFER,或者在发生任何其他故障时返回错误代码。

int of_irq_to_resource_table(struct device_node *dev, struct resource *res, int nr_irqs)

使用节点的 IRQ 信息填充资源表

参数

struct device_node *dev

指向设备树节点的指针

struct resource *res

要填充的资源数组

int nr_irqs

IRQ 的数量(和 res 元素数量的上限)

返回

填充表的大小(最多 nr_irqs)。

struct irq_domain *of_msi_get_domain(struct device *dev, const struct device_node *np, enum irq_domain_bus_token token)

使用 msi-parent 查找相关的 MSI 域

参数

struct device *dev

请求域的设备

const struct device_node *np

dev 的设备节点

enum irq_domain_bus_token token

此域的总线类型

描述

解析 msi-parent 属性并返回相应的 MSI 域。

返回

此设备的 MSI 域(或失败时返回 NULL)。

void of_msi_configure(struct device *dev, const struct device_node *np)

设置设备的 msi_domain 字段

参数

struct device *dev

要与 MSI irq 域关联的设备结构

const struct device_node *np

该设备的设备节点

void *of_fdt_unflatten_tree(const unsigned long *blob, struct device_node *dad, struct device_node **mynodes)

从平面 blob 创建 device_nodes 树

参数

const unsigned long *blob

平面设备树 blob

struct device_node *dad

父设备节点

struct device_node **mynodes

调用创建的设备树

描述

展开固件传递的设备树,创建 struct device_node 树。它还会填充节点的“name”和“type”指针,以便可以使用普通的设备树遍历函数。

返回

失败时返回 NULL,成功时返回包含未展开的设备树的内存块。

驱动程序模型函数

int of_driver_match_device(struct device *dev, const struct device_driver *drv)

判断驱动程序的 of_match_table 是否与设备匹配。

参数

struct device *dev

要匹配的设备结构

const struct device_driver *drv

要测试的 device_driver 结构

const struct of_device_id *of_match_device(const struct of_device_id *matches, const struct device *dev)

判断 struct device 是否与 of_device_id 列表匹配

参数

const struct of_device_id *matches

要搜索的 of 设备匹配结构数组

const struct device *dev

要匹配的 of 设备结构

描述

由驱动程序使用,以检查系统中存在的 platform_device 是否在其支持的设备列表中。

int of_dma_configure_id(struct device *dev, struct device_node *np, bool force_dma, const u32 *id)

设置 DMA 配置

参数

struct device *dev

要应用 DMA 配置的设备

struct device_node *np

指向具有 DMA 配置的 OF 节点的指针

bool force_dma

即使固件没有明确描述 DMA 功能,是否也要通过 of_dma_configure() 设置设备。

const u32 *id

可选的 const 指针值输入 id

描述

尝试从 DT 获取设备的 DMA 配置并相应地更新它。

如果平台代码需要使用其自己的特殊 DMA 配置,则可以使用平台总线通知程序并处理 BUS_NOTIFY_ADD_DEVICE 事件以修复 DMA 配置。

ssize_t of_device_modalias(struct device *dev, char *str, ssize_t len)

用以换行符结尾的 modalias 字符串填充缓冲区

参数

struct device *dev

调用设备

char *str

Modalias 字符串

ssize_t len

str 的大小

void of_device_uevent(const struct device *dev, struct kobj_uevent_env *env)

显示 OF 相关的 uevent 信息

参数

const struct device *dev

要显示 uevent 信息的设备

struct kobj_uevent_env *env

要填充的内核对象的用户空间事件引用

void of_device_make_bus_id(struct device *dev)

使用设备节点数据分配唯一名称

参数

struct device *dev

指向链接到设备树节点的设备结构的指针

描述

此例程将首先尝试使用转换后的总线地址来派生唯一名称。如果无法做到,它将从父节点预先添加名称,直到可以派生唯一名称。

struct of_dev_auxdata

设备名称和 platform_data 的查找表条目

定义:

struct of_dev_auxdata {
    char *compatible;
    resource_size_t phys_addr;
    char *name;
    void *platform_data;
};

成员

compatible

要与节点匹配的节点的 compatible 值

phys_addr

要与节点匹配的寄存器的起始地址

name

为匹配节点分配的名称

platform_data

为匹配节点分配的 platform_data

描述

此查找表允许 of_platform_populate() 的调用者在从设备树创建设备时覆盖设备的名称。该表应以空条目结尾。它还允许设置 platform_data 指针。

此功能的原因是一些 Linux 基础结构使用设备名称来查找特定设备,但特定于 Linux 的名称未编码到设备树中,因此内核需要提供特定值。

注意

当转换平台以使用 DT 时,应将使用 auxdata 查找表视为最后的手段。通常,自动生成的设备名称无关紧要,驱动程序应从设备节点而不是从匿名 platform_data 指针获取数据。

struct platform_device *of_find_device_by_node(struct device_node *np)

查找与节点关联的 platform_device

参数

struct device_node *np

指向设备树节点的指针

描述

获取对嵌入式 struct device 的引用,使用后需要释放。

返回

platform_device 指针,如果未找到则为 NULL

struct platform_device *of_device_alloc(struct device_node *np, const char *bus_id, struct device *parent)

分配并初始化一个 of_device

参数

struct device_node *np

要分配给设备的设备节点

const char *bus_id

要分配给设备的名称。可以为 null 以使用默认名称。

struct device *parent

父设备。

struct platform_device *of_platform_device_create(struct device_node *np, const char *bus_id, struct device *parent)

分配、初始化和注册一个 of_device

参数

struct device_node *np

指向要为其创建设备的节点的指针

const char *bus_id

分配给设备的名称

struct device *parent

Linux 设备模型父设备。

返回

指向已创建的 platform device 的指针,如果未注册设备,则为 NULL。 不可用的设备将不会被注册。

int of_platform_bus_probe(struct device_node *root, const struct of_device_id *matches, struct device *parent)

探测设备树以查找平台总线

参数

struct device_node *root

要探测的第一级的父节点,或者为 NULL 表示树的根节点

const struct of_device_id *matches

总线节点的匹配表

struct device *parent

挂钩设备的父节点,顶层为 NULL

描述

请注意,除非指定的根节点本身与总线列表匹配且不为 NULL,否则提供的根节点的子节点不会被实例化为设备。

int of_platform_populate(struct device_node *root, const struct of_device_id *matches, const struct of_dev_auxdata *lookup, struct device *parent)

从设备树数据填充 platform_devices

参数

struct device_node *root

要探测的第一级的父节点,或者为 NULL 表示树的根节点

const struct of_device_id *matches

匹配表,NULL 使用默认值

const struct of_dev_auxdata *lookup

用于匹配 ID 和 platform_data 与设备节点的 auxdata 表

struct device *parent

挂钩设备的父节点,顶层为 NULL

描述

of_platform_bus_probe() 类似,此函数遍历设备树并从节点创建设备。 不同之处在于,它遵循现代约定,要求所有设备节点都具有“compatible”属性,并且适用于创建作为根节点的子节点的设备(of_platform_bus_probe 仅会创建由 matches 参数选择的根的子节点)。

新的板级支持应使用此函数而不是 of_platform_bus_probe()

返回

成功时为 0,失败时 < 0。

void of_platform_depopulate(struct device *parent)

删除从设备树填充的设备

参数

struct device *parent

将删除其子设备的设备

描述

of_platform_populate() 互补,此函数删除给定设备的子设备(以及递归地删除它们的子设备),这些子设备是从它们各自的设备树节点创建的(并且只删除这些子设备,留下其他 - 例如手动创建的 - 不受影响)。

int devm_of_platform_populate(struct device *dev)

从设备树数据填充 platform_devices

参数

struct device *dev

请求从设备树数据填充的设备

描述

of_platform_populate() 类似,但当设备从总线解除绑定时,将自动调用 of_platform_depopulate()

返回

成功时为 0,失败时 < 0。

void devm_of_platform_depopulate(struct device *dev)

删除从设备树填充的设备

参数

struct device *dev

请求从设备树数据中删除的设备

描述

devm_of_platform_populate() 互补,此函数删除给定设备的子设备(以及递归地删除它们的子设备),这些子设备是从它们各自的设备树节点创建的(并且只删除这些子设备,留下其他 - 例如手动创建的 - 不受影响)。

覆盖和动态 DT 函数

int of_resolve_phandles(struct device_node *overlay)

相对于实时树重定位和解析覆盖

参数

struct device_node *overlay

指向要重定位和解析的设备树覆盖的指针

描述

修改(重定位)overlay 中的本地 phandle 的值到一个不与实时展开的设备树冲突的范围。 更新 overlay 中对本地 phandle 的引用。 更新(解析)overlay 中引用实时展开的设备树的 phandle 引用。

实时树中的 Phandle 值在 1 .. live_tree_max_phandle() 的范围内。 覆盖中的 phandle 值范围也从 1 开始。 调整覆盖中的 phandle 值,使其从 live_tree_max_phandle() + 1 开始。 将对 phandle 的引用更新为调整后的 phandle 值。

覆盖中“__fixups__”节点中每个属性的名称与实时树中符号(标签)的名称匹配。“__fixups__”节点中每个属性的值是在覆盖中需要更新的属性值列表,以包含与实时树中该符号对应的 phandle 引用。 使用实时树中的 phandle 值更新覆盖中的引用。

overlay 必须是分离的。

解析并将 overlay 应用于实时展开的设备树必须受到一种机制的保护,以确保以单线程方式处理多个覆盖,以便多个覆盖不会将 phandle 重定位到重叠的范围。 用于强制执行此操作的机制尚未实现。

返回

成功时为 0,错误时为负错误值。

struct device_node *of_node_get(struct device_node *node)

递增节点的引用计数

参数

struct device_node *node

要递增引用计数的节点,支持 NULL 以简化调用者的编写

返回

引用计数递增的节点。

void of_node_put(struct device_node *node)

递减节点的引用计数

参数

struct device_node *node

要递减引用计数的节点,支持 NULL 以简化调用者的编写

int of_detach_node(struct device_node *np)

从设备树中“拔出”一个节点。

参数

struct device_node *np

指向调用者的设备节点的指针

struct device_node *of_changeset_create_node(struct of_changeset *ocs, struct device_node *parent, const char *full_name)

动态创建一个设备节点并附加到给定的更改集。

参数

struct of_changeset *ocs

指向更改集的指针

struct device_node *parent

指向父设备节点的指针

const char *full_name

节点完整名称

返回

指向已创建的设备节点的指针,如果发生错误,则为 NULL。

void of_changeset_init(struct of_changeset *ocs)

初始化一个更改集以供使用

参数

struct of_changeset *ocs

更改集指针

描述

初始化一个更改集结构

void of_changeset_destroy(struct of_changeset *ocs)

销毁一个更改集

参数

struct of_changeset *ocs

更改集指针

描述

销毁一个更改集。 请注意,如果应用了更改集,则无法还原其对树的更改。

int of_changeset_apply(struct of_changeset *ocs)

应用一个更改集

参数

struct of_changeset *ocs

更改集指针

描述

将更改集应用于实时树。 实时树状态更改的任何副作用都会在成功时在此处应用,例如创建/销毁设备以及诸如创建 sysfs 属性和目录之类的副作用。

返回

成功时为 0,错误时为负错误值。 发生错误时,将还原部分应用的效果。

int of_changeset_revert(struct of_changeset *ocs)

还原已应用的更改集

参数

struct of_changeset *ocs

更改集指针

描述

还原更改集,将树的状态返回到应用之前的状态。 应用任何副作用,例如创建/销毁设备以及删除 sysfs 属性和目录。

返回

成功时为 0,错误时为负错误值。

int of_changeset_action(struct of_changeset *ocs, unsigned long action, struct device_node *np, struct property *prop)

将一个操作添加到更改集列表的尾部

参数

struct of_changeset *ocs

更改集指针

unsigned long action

要执行的操作

struct device_node *np

指向设备节点的指针

struct property *prop

指向属性的指针

描述

在操作是以下之一时:+ OF_RECONFIG_ATTACH_NODE + OF_RECONFIG_DETACH_NODE, + OF_RECONFIG_ADD_PROPERTY + OF_RECONFIG_REMOVE_PROPERTY, + OF_RECONFIG_UPDATE_PROPERTY

返回

成功时为 0,错误时为负错误值。

int of_changeset_add_prop_string(struct of_changeset *ocs, struct device_node *np, const char *prop_name, const char *str)

向更改集添加一个字符串属性

参数

struct of_changeset *ocs

更改集指针

struct device_node *np

设备节点指针

const char *prop_name

要添加的属性的名称

const char *str

指向以 null 结尾的字符串的指针

描述

创建一个字符串属性并将其添加到更改集中。

返回

成功时为 0,错误时为负错误值。

int of_changeset_add_prop_string_array(struct of_changeset *ocs, struct device_node *np, const char *prop_name, const char *const *str_array, size_t sz)

向变更集添加字符串列表属性

参数

struct of_changeset *ocs

更改集指针

struct device_node *np

设备节点指针

const char *prop_name

要添加的属性的名称

const char * const *str_array

指向以 null 结尾的字符串数组的指针

size_t sz

字符串数组元素的数量

描述

创建一个字符串列表属性并将其添加到变更集中。

返回

成功时为 0,错误时为负错误值。

int of_changeset_add_prop_u32_array(struct of_changeset *ocs, struct device_node *np, const char *prop_name, const u32 *array, size_t sz)

向变更集添加 32 位整数属性

参数

struct of_changeset *ocs

更改集指针

struct device_node *np

设备节点指针

const char *prop_name

要添加的属性的名称

const u32 *array

指向 32 位整数数组的指针

size_t sz

数组元素的数量

描述

创建一个 32 位整数属性并将其添加到变更集中。

返回

成功时为 0,错误时为负错误值。

int of_changeset_add_prop_bool(struct of_changeset *ocs, struct device_node *np, const char *prop_name)

向变更集添加一个布尔属性(即,没有任何值的属性)。

参数

struct of_changeset *ocs

更改集指针

struct device_node *np

设备节点指针

const char *prop_name

要添加的属性的名称

描述

创建一个布尔属性并将其添加到变更集中。

返回

成功时为 0,错误时为负错误值。

int of_changeset_update_prop_string(struct of_changeset *ocs, struct device_node *np, const char *prop_name, const char *str)

向变更集添加字符串属性更新

参数

struct of_changeset *ocs

更改集指针

struct device_node *np

设备节点指针

const char *prop_name

要更新的属性的名称

const char *str

指向以 null 结尾的字符串的指针

描述

创建一个要更新的字符串属性并将其添加到变更集中。

返回

成功时为 0,错误时为负错误值。

int of_overlay_notifier_register(struct notifier_block *nb)

注册覆盖操作的通知器

参数

struct notifier_block *nb

要注册的通知器块

描述

注册以接收设备树节点上覆盖操作的通知。报告的动作由 of_reconfig_change 定义。此外,通知器回调接收指向受影响的设备树节点的指针。

请注意,通知器回调不应存储指向设备树节点或其内容的指针,超出与接收到的相应节点相对应的 OF_OVERLAY_POST_REMOVE

int of_overlay_notifier_unregister(struct notifier_block *nb)

取消注册覆盖操作的通知器

参数

struct notifier_block *nb

要取消注册的通知器块

int of_overlay_fdt_apply(const void *overlay_fdt, u32 overlay_fdt_size, int *ret_ovcs_id, const struct device_node *base)

创建并应用覆盖变更集

参数

const void *overlay_fdt

指向覆盖 FDT 的指针

u32 overlay_fdt_size

overlay_fdt 中的字节数

int *ret_ovcs_id

用于返回创建的变更集 ID 的指针

const struct device_node *base

用于应用覆盖的目标节点的指针

描述

创建并应用一个覆盖变更集。

有关重要的行为信息,请参见 of_overlay_apply()。

在错误返回时,变更集可能被部分应用。如果 OF_OVERLAY_POST_APPLY 通知器返回错误,则尤其可能发生这种情况。在这种情况下,调用者应使用 *ret_ovcs_id 中的值调用 of_overlay_remove()

返回

成功时返回 0,或返回负错误数字。 *ret_ovcs_id 设置为覆盖变更集 ID 的值,该值可以传递给 of_overlay_remove() 以移除覆盖。

int of_overlay_remove(int *ovcs_id)

还原并释放一个覆盖变更集

参数

int *ovcs_id

指向覆盖变更集 ID 的指针

描述

如果允许,则移除覆盖。 ovcs_id 之前由 of_overlay_fdt_apply() 返回。

如果在尝试还原覆盖变更集时发生错误,则会尝试重新应用任何已还原的变更集条目。如果在重新应用时发生错误,则无法确定设备树的状态,并且任何后续应用或移除覆盖变更集的尝试都将被拒绝。

如果错误来自以下情况,则非零返回值不会还原变更集
  • 参数检查

  • 覆盖变更集预移除通知器

  • 覆盖变更集条目还原

如果覆盖变更集预移除通知器返回错误,则不会调用任何进一步的覆盖变更集预移除通知器。

如果多个通知器返回错误,则返回发生的最后一个通知器错误。

如果错误来自以下情况,则非零返回值将还原变更集
  • 覆盖变更集条目通知器

  • 覆盖变更集后移除通知器

如果覆盖变更集后移除通知器返回错误,则不会调用任何进一步的覆盖变更集后移除通知器。

返回

成功时返回 0,或返回负错误数字。还原变更集后,即使发生后续错误,*ovcs_id 也会设置为零。

int of_overlay_remove_all(void)

还原并释放所有覆盖变更集

参数

void

无参数

描述

以正确的顺序从系统中移除所有覆盖。

返回

成功时返回 0,或返回负错误数字