英語

簡體中文

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 上事務的目標裝置。如果只需要另一個，則 target 或 id_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，或返回負錯誤數字

Linux 核心

目錄

本頁

DeviceTree 核心 API¶

核心函式¶

驅動程式模型函式¶

覆蓋和動態 DT 函式¶