Patrick Georgi | afd4c87 | 2020-05-05 23:43:18 +0200 | [diff] [blame] | 1 | /* Taken from depthcharge: src/base/device_tree.h */ |
Patrick Georgi | ac95903 | 2020-05-05 22:49:26 +0200 | [diff] [blame] | 2 | /* SPDX-License-Identifier: GPL-2.0-or-later */ |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 3 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 4 | #ifndef __DEVICE_TREE_H__ |
| 5 | #define __DEVICE_TREE_H__ |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 6 | |
Maximilian Brune | 33079b8 | 2024-03-04 15:34:41 +0100 | [diff] [blame] | 7 | #include <stdbool.h> |
Elyes HAOUAS | 5817c56 | 2020-07-12 09:03:22 +0200 | [diff] [blame] | 8 | #include <stddef.h> |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 9 | #include <stdint.h> |
Maximilian Brune | a99b580 | 2023-09-16 19:56:45 +0200 | [diff] [blame] | 10 | #include <commonlib/list.h> |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 11 | |
| 12 | /* |
| 13 | * Flattened device tree structures/constants. |
| 14 | */ |
| 15 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 16 | struct fdt_header { |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 17 | uint32_t magic; |
| 18 | uint32_t totalsize; |
| 19 | uint32_t structure_offset; |
| 20 | uint32_t strings_offset; |
| 21 | uint32_t reserve_map_offset; |
| 22 | |
| 23 | uint32_t version; |
Julius Werner | 73eaec8 | 2019-05-03 17:58:07 -0700 | [diff] [blame] | 24 | uint32_t last_comp_version; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 25 | |
| 26 | uint32_t boot_cpuid_phys; |
| 27 | |
| 28 | uint32_t strings_size; |
| 29 | uint32_t structure_size; |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 30 | }; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 31 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 32 | #define FDT_HEADER_MAGIC 0xd00dfeed |
Julius Werner | 73eaec8 | 2019-05-03 17:58:07 -0700 | [diff] [blame] | 33 | #define FDT_SUPPORTED_VERSION 17 |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 34 | #define FDT_TOKEN_BEGIN_NODE 1 |
| 35 | #define FDT_TOKEN_END_NODE 2 |
| 36 | #define FDT_TOKEN_PROPERTY 3 |
Maximilian Brune | 33079b8 | 2024-03-04 15:34:41 +0100 | [diff] [blame] | 37 | #define FDT_TOKEN_NOP 4 |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 38 | #define FDT_TOKEN_END 9 |
Julius Werner | 6702b68 | 2019-05-03 18:13:53 -0700 | [diff] [blame] | 39 | #define FDT_PHANDLE_ILLEGAL 0xdeadbeef |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 40 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 41 | struct fdt_property |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 42 | { |
| 43 | const char *name; |
Julius Werner | 0e9116f | 2019-05-13 17:30:31 -0700 | [diff] [blame] | 44 | void *data; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 45 | uint32_t size; |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 46 | }; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 47 | |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 48 | /* |
| 49 | * Unflattened device tree structures. |
| 50 | */ |
| 51 | |
Maximilian Brune | 33079b8 | 2024-03-04 15:34:41 +0100 | [diff] [blame] | 52 | struct device_tree_region { |
| 53 | u64 addr; |
| 54 | u64 size; |
| 55 | }; |
| 56 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 57 | struct device_tree_property |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 58 | { |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 59 | struct fdt_property prop; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 60 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 61 | struct list_node list_node; |
| 62 | }; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 63 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 64 | struct device_tree_node |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 65 | { |
| 66 | const char *name; |
Julius Werner | 6702b68 | 2019-05-03 18:13:53 -0700 | [diff] [blame] | 67 | uint32_t phandle; |
| 68 | |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 69 | /* List of struct device_tree_property-s. */ |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 70 | struct list_node properties; |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 71 | /* List of struct device_tree_nodes. */ |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 72 | struct list_node children; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 73 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 74 | struct list_node list_node; |
| 75 | }; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 76 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 77 | struct device_tree_reserve_map_entry |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 78 | { |
| 79 | uint64_t start; |
| 80 | uint64_t size; |
| 81 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 82 | struct list_node list_node; |
| 83 | }; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 84 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 85 | struct device_tree |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 86 | { |
Patrick Rudolph | 0a7d690 | 2018-08-22 09:55:15 +0200 | [diff] [blame] | 87 | const void *header; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 88 | uint32_t header_size; |
Julius Werner | 6702b68 | 2019-05-03 18:13:53 -0700 | [diff] [blame] | 89 | uint32_t max_phandle; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 90 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 91 | struct list_node reserve_map; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 92 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 93 | struct device_tree_node *root; |
| 94 | }; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 95 | |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 96 | /* |
| 97 | * Flattened device tree functions. These generally return the number of bytes |
| 98 | * which were consumed reading the requested value. |
| 99 | */ |
| 100 | |
Maximilian Brune | 33079b8 | 2024-03-04 15:34:41 +0100 | [diff] [blame] | 101 | /* Checks if blob points to a valid FDT */ |
| 102 | bool fdt_is_valid(const void *blob); |
Alexander Goncharov | 893c3ae8 | 2023-02-04 15:20:37 +0400 | [diff] [blame] | 103 | /* Read the property at offset, if any exists. */ |
Patrick Rudolph | 0a7d690 | 2018-08-22 09:55:15 +0200 | [diff] [blame] | 104 | int fdt_next_property(const void *blob, uint32_t offset, |
| 105 | struct fdt_property *prop); |
Alexander Goncharov | 893c3ae8 | 2023-02-04 15:20:37 +0400 | [diff] [blame] | 106 | /* Read the name of the node at offset, if any exists. */ |
Patrick Rudolph | 0a7d690 | 2018-08-22 09:55:15 +0200 | [diff] [blame] | 107 | int fdt_node_name(const void *blob, uint32_t offset, const char **name); |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 108 | |
Patrick Rudolph | 0a7d690 | 2018-08-22 09:55:15 +0200 | [diff] [blame] | 109 | void fdt_print_node(const void *blob, uint32_t offset); |
| 110 | int fdt_skip_node(const void *blob, uint32_t offset); |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 111 | |
Maximilian Brune | 33079b8 | 2024-03-04 15:34:41 +0100 | [diff] [blame] | 112 | /* Read property and put into fdt_prop. Returns offset to property */ |
| 113 | u32 fdt_read_prop(const void *blob, u32 node_offset, const char *prop_name, |
| 114 | struct fdt_property *fdt_prop); |
| 115 | /* Read reg property and save regions inside 'regions'. Returns number of regions read */ |
| 116 | u32 fdt_read_reg_prop(const void *blob, u32 node_offset, u32 addr_cells, u32 size_cells, |
| 117 | struct device_tree_region regions[], size_t regions_count); |
| 118 | /* Find a node by a given path and return the offset */ |
| 119 | u32 fdt_find_node_by_path(const void *blob, const char *path, u32 *addrcp, u32 *sizecp); |
| 120 | /* Find multiple nodes matching a given pattern. Returns number of nodes found */ |
| 121 | size_t fdt_find_subnodes_by_prefix(const void *blob, u32 node_offset, const char *prefix, |
| 122 | u32 *addrcp, u32 *sizecp, u32 results[], size_t results_len); |
| 123 | /* Find a node by a given alias and return its offset */ |
| 124 | u32 fdt_find_node_by_alias(const void *blob, const char *alias_name, |
| 125 | u32 *addr_cells, u32 *size_cells); |
| 126 | /* |
| 127 | * Read the node name into 'name' of the node behind 'node_offset' |
| 128 | * and return total bytes used for name |
| 129 | */ |
| 130 | int fdt_next_node_name(const void *blob, uint32_t node_offset, const char **name); |
| 131 | |
Alper Nebi Yasak | 377157c | 2024-02-05 17:31:20 +0300 | [diff] [blame] | 132 | /* Read memory regions from a flat device-tree. */ |
| 133 | size_t fdt_read_memory_regions(const void *blob, struct device_tree_region regions[], |
| 134 | size_t regions_count); |
| 135 | /* Find top of memory from a flat device-tree. */ |
| 136 | uint64_t fdt_get_memory_top(const void *blob); |
| 137 | |
Elyes HAOUAS | 5f73e22 | 2020-01-15 21:13:45 +0100 | [diff] [blame] | 138 | /* Read a flattened device tree into a hierarchical structure which refers to |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 139 | the contents of the flattened tree in place. Modifying the flat tree |
| 140 | invalidates the unflattened one. */ |
Patrick Rudolph | 0a7d690 | 2018-08-22 09:55:15 +0200 | [diff] [blame] | 141 | struct device_tree *fdt_unflatten(const void *blob); |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 142 | |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 143 | /* |
| 144 | * Unflattened device tree functions. |
| 145 | */ |
| 146 | |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 147 | /* Figure out how big a device tree would be if it were flattened. */ |
Patrick Rudolph | 0a7d690 | 2018-08-22 09:55:15 +0200 | [diff] [blame] | 148 | uint32_t dt_flat_size(const struct device_tree *tree); |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 149 | /* Flatten a device tree into the buffer pointed to by dest. */ |
Patrick Rudolph | 0a7d690 | 2018-08-22 09:55:15 +0200 | [diff] [blame] | 150 | void dt_flatten(const struct device_tree *tree, void *dest); |
| 151 | void dt_print_node(const struct device_tree_node *node); |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 152 | /* Read #address-cells and #size-cells properties from a node. */ |
Patrick Rudolph | 0a7d690 | 2018-08-22 09:55:15 +0200 | [diff] [blame] | 153 | void dt_read_cell_props(const struct device_tree_node *node, u32 *addrcp, |
| 154 | u32 *sizecp); |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 155 | /* Look up or create a node relative to a parent node, through its path |
| 156 | represented as an array of strings. */ |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 157 | struct device_tree_node *dt_find_node(struct device_tree_node *parent, const char **path, |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 158 | u32 *addrcp, u32 *sizecp, int create); |
Julius Werner | 6702b68 | 2019-05-03 18:13:53 -0700 | [diff] [blame] | 159 | struct device_tree_node *dt_find_node_by_phandle(struct device_tree_node *root, |
| 160 | uint32_t phandle); |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 161 | /* Look up or create a node in the tree, through its path |
| 162 | represented as a string of '/' separated node names. */ |
Julius Werner | f36d53c | 2019-05-03 18:23:34 -0700 | [diff] [blame] | 163 | struct device_tree_node *dt_find_node_by_path(struct device_tree *tree, |
| 164 | const char *path, u32 *addrcp, u32 *sizecp, int create); |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 165 | /* Look up a node through an alias. */ |
Julius Werner | 6d5695f | 2019-05-06 19:23:28 -0700 | [diff] [blame] | 166 | struct device_tree_node *dt_find_node_by_alias(struct device_tree *tree, |
| 167 | const char *alias); |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 168 | /* Look up a node relative to a parent node, through its compatible string. */ |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 169 | struct device_tree_node *dt_find_compat(struct device_tree_node *parent, const char *compatible); |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 170 | /* Look up the next child of a parent node, through its compatible string. It |
| 171 | uses child pointer as the marker to find next. */ |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 172 | struct device_tree_node *dt_find_next_compat_child(struct device_tree_node *parent, |
| 173 | struct device_tree_node *child, |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 174 | const char *compat); |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 175 | /* Look up a node relative to a parent node, through its property value. */ |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 176 | struct device_tree_node *dt_find_prop_value(struct device_tree_node *parent, const char *name, |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 177 | void *data, size_t size); |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 178 | /* Write src into *dest as a 'length'-byte big-endian integer. */ |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 179 | void dt_write_int(u8 *dest, u64 src, size_t length); |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 180 | /* Delete a property */ |
Patrick Rudolph | 5ccc731 | 2018-05-30 15:05:28 +0200 | [diff] [blame] | 181 | void dt_delete_prop(struct device_tree_node *node, const char *name); |
Julius Werner | 23df477 | 2019-05-17 22:50:18 -0700 | [diff] [blame] | 182 | /* Add different kinds of properties to a node, or update existing ones. */ |
Patrick Rudolph | 0a7d690 | 2018-08-22 09:55:15 +0200 | [diff] [blame] | 183 | void dt_add_bin_prop(struct device_tree_node *node, const char *name, |
Julius Werner | 0e9116f | 2019-05-13 17:30:31 -0700 | [diff] [blame] | 184 | void *data, size_t size); |
Patrick Rudolph | 0a7d690 | 2018-08-22 09:55:15 +0200 | [diff] [blame] | 185 | void dt_add_string_prop(struct device_tree_node *node, const char *name, |
| 186 | const char *str); |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 187 | void dt_add_u32_prop(struct device_tree_node *node, const char *name, u32 val); |
Patrick Rudolph | 3fca4ed | 2018-08-10 10:12:35 +0200 | [diff] [blame] | 188 | void dt_add_u64_prop(struct device_tree_node *node, const char *name, u64 val); |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 189 | void dt_add_reg_prop(struct device_tree_node *node, u64 *addrs, u64 *sizes, |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 190 | int count, u32 addr_cells, u32 size_cells); |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 191 | int dt_set_bin_prop_by_path(struct device_tree *tree, const char *path, |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 192 | void *data, size_t size, int create); |
| 193 | |
Patrick Rudolph | 0a7d690 | 2018-08-22 09:55:15 +0200 | [diff] [blame] | 194 | void dt_find_bin_prop(const struct device_tree_node *node, const char *name, |
| 195 | const void **data, size_t *size); |
| 196 | const char *dt_find_string_prop(const struct device_tree_node *node, |
| 197 | const char *name); |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 198 | |
Julius Werner | 735ddc9 | 2019-05-07 17:05:28 -0700 | [diff] [blame] | 199 | /* Apply an overlay to a base device tree. Ownership of the overlay data passes |
| 200 | to the newly combined base tree -- do not free() or access it afterwards! */ |
| 201 | int dt_apply_overlay(struct device_tree *tree, struct device_tree *overlay); |
| 202 | |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 203 | /* |
| 204 | * Fixups to apply to a kernel's device tree before booting it. |
| 205 | */ |
| 206 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 207 | struct device_tree_fixup |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 208 | { |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 209 | /** |
| 210 | * The function which does the fixing. |
| 211 | * 0 on success, non-zero on error. |
| 212 | */ |
| 213 | int (*fixup)(struct device_tree_fixup *fixup, |
| 214 | struct device_tree *tree); |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 215 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 216 | struct list_node list_node; |
| 217 | }; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 218 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 219 | extern struct list_node device_tree_fixups; |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 220 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 221 | /** |
| 222 | * Function to apply fixups. |
| 223 | * 0 on success, non-zero on error. |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 224 | */ |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 225 | int dt_apply_fixups(struct device_tree *tree); |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 226 | |
| 227 | /* |
| 228 | * Init/retrieve the /reserved-memory/ node. |
| 229 | */ |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 230 | struct device_tree_node *dt_init_reserved_memory_node(struct device_tree *tree); |
Patrick Rudolph | 67aca3e | 2018-04-12 11:44:43 +0200 | [diff] [blame] | 231 | |
Patrick Rudolph | 666c172 | 2018-04-03 09:57:33 +0200 | [diff] [blame] | 232 | #endif /* __DEVICE_TREE_H__ */ |