英语

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 结尾的兼容字符串数组，用于在根节点的 compatible 属性中查找。

描述

如果根节点的 compatible 属性中包含任何给定的兼容值，则返回 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。

如果 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 属性包含给定兼容字符串的子节点。

返回

节点指针，引用计数已递增，完成后请对其使用 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_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；您传递的节点不会被搜索，只有下一个节点会被搜索。通常，您传递上一次调用返回的内容。将对 from 调用 of_node_put()。

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 以开始搜索整个设备树。您传递的节点不会被搜索，只有下一个节点会被搜索；通常，您传递上一次调用返回的内容。将为您对 from 调用 of_node_put()。

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

更新以指向匹配的匹配项

返回

一个引用计数增加的节点指针，完成时对其使用 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 的“产品”部分进行匹配是 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 和一个或多个参数组成。参数的数量由 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 向数据发出了谁也不知道的指针。相反，我们只是将该属性移动到“死属性”列表，这样它就不会再被找到。

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 上事务的目标设备。如果只需要另一个，则 target 或 id_out 可以为 NULL。如果 target 指向非 NULL 设备节点指针，则只会匹配以该节点为目标的条目；如果它指向 NULL 值，则它将接收第一个匹配的目标 phandle 的设备节点，并保持引用。

返回

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

void of_node_init(struct device_node *node)

初始化设备树节点

参数

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)

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

参数

const char *compat

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

返回

如果根节点的兼容属性中具有给定值，则为 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_read_bool(const struct device_node *np, const char *propname)

查找一个属性

参数

const struct device_node *np

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

const char *propname

要搜索的属性的名称。

描述

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

返回

如果属性存在，则返回 true；否则返回 false。

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_graph_is_present(const struct device_node *node)

检查图的存在

参数

const struct device_node *node

指向包含图形端口的 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_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 属性的值)。

返回

一个 ‘endpoint’ 节点指针，它由 reg 标识，并且同时是 port_reg 标识的端口节点的子节点。 当 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() 函数。

使用完后请调用 of_node_put() 函数。

struct device_node *of_graph_get_port_parent(struct device_node *node)

获取端口的父节点。

参数

struct device_node *node

指向本地端点 device_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 的指针。

返回

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

使用完后请调用 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;
};

成员

port

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

id

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

local_node

指向此端点的 device_node 的指针。

for_each_endpoint_of_node

for_each_endpoint_of_node (parent, child)

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

参数

parent

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

child

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

描述

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

for_each_of_graph_port

for_each_of_graph_port (parent, child)

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

参数

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)

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

参数

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” 属性，或者如果 DMA 对于当前平台上的 OF 设备默认是一致的，并且没有为此设备找到 “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，错误返回负数。

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 号的中断说明符，来解析节点的中断。

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，并且该 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

要与节点匹配的节点兼容值

phys_addr

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

name

要为匹配的节点分配的名称

platform_data

要为匹配的节点分配的 platform_data

描述

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

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

注意

将平台转换为使用 DT 时，应将辅助数据查找表视为最后的手段。 通常，自动生成的设备名称并不重要，驱动程序应从设备节点而不是从匿名 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 设备模型父设备。

返回

指向创建的平台设备的指针，如果设备未注册，则为 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_device

参数

struct device_node *root

要探测的第一级节点的父节点，如果为 NULL 则为树的根节点

const struct of_device_id *matches

匹配表，如果使用默认值则为 NULL

const struct of_dev_auxdata *lookup

用于将 id 和 platform_data 与设备节点匹配的辅助数据表

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_device

参数

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 到实时扩展的设备树必须受到机制保护，以确保多个 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，或返回一个负错误号