xref: /openbmc/qemu/include/sysemu/device_tree.h (revision 1935b7ea)
1 /*
2  * Header with function prototypes to help device tree manipulation using
3  * libfdt. It also provides functions to read entries from device tree proc
4  * interface.
5  *
6  * Copyright 2008 IBM Corporation.
7  * Authors: Jerone Young <jyoung5@us.ibm.com>
8  *          Hollis Blanchard <hollisb@us.ibm.com>
9  *
10  * This work is licensed under the GNU GPL license version 2 or later.
11  *
12  */
13 
14 #ifndef DEVICE_TREE_H
15 #define DEVICE_TREE_H
16 
17 void *create_device_tree(int *sizep);
18 void *load_device_tree(const char *filename_path, int *sizep);
19 #ifdef CONFIG_LINUX
20 /**
21  * load_device_tree_from_sysfs: reads the device tree information in the
22  * /proc/device-tree directory and return the corresponding binary blob
23  * buffer pointer. Asserts in case of error.
24  */
25 void *load_device_tree_from_sysfs(void);
26 #endif
27 
28 /**
29  * qemu_fdt_node_path: return the paths of nodes matching a given
30  * name and compat string
31  * @fdt: pointer to the dt blob
32  * @name: node name
33  * @compat: compatibility string
34  * @errp: handle to an error object
35  *
36  * returns a newly allocated NULL-terminated array of node paths.
37  * Use g_strfreev() to free it. If one or more nodes were found, the
38  * array contains the path of each node and the last element equals to
39  * NULL. If there is no error but no matching node was found, the
40  * returned array contains a single element equal to NULL. If an error
41  * was encountered when parsing the blob, the function returns NULL
42  *
43  * @name may be NULL to wildcard names and only match compatibility
44  * strings.
45  */
46 char **qemu_fdt_node_path(void *fdt, const char *name, const char *compat,
47                           Error **errp);
48 
49 /**
50  * qemu_fdt_node_unit_path: return the paths of nodes matching a given
51  * node-name, ie. node-name and node-name@unit-address
52  * @fdt: pointer to the dt blob
53  * @name: node name
54  * @errp: handle to an error object
55  *
56  * returns a newly allocated NULL-terminated array of node paths.
57  * Use g_strfreev() to free it. If one or more nodes were found, the
58  * array contains the path of each node and the last element equals to
59  * NULL. If there is no error but no matching node was found, the
60  * returned array contains a single element equal to NULL. If an error
61  * was encountered when parsing the blob, the function returns NULL
62  */
63 char **qemu_fdt_node_unit_path(void *fdt, const char *name, Error **errp);
64 
65 int qemu_fdt_setprop(void *fdt, const char *node_path,
66                      const char *property, const void *val, int size);
67 int qemu_fdt_setprop_cell(void *fdt, const char *node_path,
68                           const char *property, uint32_t val);
69 int qemu_fdt_setprop_u64(void *fdt, const char *node_path,
70                          const char *property, uint64_t val);
71 int qemu_fdt_setprop_string(void *fdt, const char *node_path,
72                             const char *property, const char *string);
73 
74 /**
75  * qemu_fdt_setprop_string_array: set a string array property
76  *
77  * @fdt: pointer to the dt blob
78  * @name: node name
79  * @prop: property array
80  * @array: pointer to an array of string pointers
81  * @len: length of array
82  *
83  * assigns a string array to a property. This function converts and
84  * array of strings to a sequential string with \0 separators before
85  * setting the property.
86  */
87 int qemu_fdt_setprop_string_array(void *fdt, const char *node_path,
88                                   const char *prop, char **array, int len);
89 
90 int qemu_fdt_setprop_phandle(void *fdt, const char *node_path,
91                              const char *property,
92                              const char *target_node_path);
93 /**
94  * qemu_fdt_getprop: retrieve the value of a given property
95  * @fdt: pointer to the device tree blob
96  * @node_path: node path
97  * @property: name of the property to find
98  * @lenp: fdt error if any or length of the property on success
99  * @errp: handle to an error object
100  *
101  * returns a pointer to the property on success and NULL on failure
102  */
103 const void *qemu_fdt_getprop(void *fdt, const char *node_path,
104                              const char *property, int *lenp,
105                              Error **errp);
106 /**
107  * qemu_fdt_getprop_cell: retrieve the value of a given 4 byte property
108  * @fdt: pointer to the device tree blob
109  * @node_path: node path
110  * @property: name of the property to find
111  * @lenp: fdt error if any or -EINVAL if the property size is different from
112  *        4 bytes, or 4 (expected length of the property) upon success.
113  * @errp: handle to an error object
114  *
115  * returns the property value on success
116  */
117 uint32_t qemu_fdt_getprop_cell(void *fdt, const char *node_path,
118                                const char *property, int *lenp,
119                                Error **errp);
120 uint32_t qemu_fdt_get_phandle(void *fdt, const char *path);
121 uint32_t qemu_fdt_alloc_phandle(void *fdt);
122 int qemu_fdt_nop_node(void *fdt, const char *node_path);
123 int qemu_fdt_add_subnode(void *fdt, const char *name);
124 int qemu_fdt_add_path(void *fdt, const char *path);
125 
126 #define qemu_fdt_setprop_cells(fdt, node_path, property, ...)                 \
127     do {                                                                      \
128         uint32_t qdt_tmp[] = { __VA_ARGS__ };                                 \
129         for (unsigned i_ = 0; i_ < ARRAY_SIZE(qdt_tmp); i_++) {               \
130             qdt_tmp[i_] = cpu_to_be32(qdt_tmp[i_]);                           \
131         }                                                                     \
132         qemu_fdt_setprop(fdt, node_path, property, qdt_tmp,                   \
133                          sizeof(qdt_tmp));                                    \
134     } while (0)
135 
136 void qemu_fdt_dumpdtb(void *fdt, int size);
137 
138 /**
139  * qemu_fdt_setprop_sized_cells_from_array:
140  * @fdt: device tree blob
141  * @node_path: node to set property on
142  * @property: property to set
143  * @numvalues: number of values
144  * @values: array of number-of-cells, value pairs
145  *
146  * Set the specified property on the specified node in the device tree
147  * to be an array of cells. The values of the cells are specified via
148  * the values list, which alternates between "number of cells used by
149  * this value" and "value".
150  * number-of-cells must be either 1 or 2 (other values will result in
151  * an error being returned). If a value is too large to fit in the
152  * number of cells specified for it, an error is returned.
153  *
154  * This function is useful because device tree nodes often have cell arrays
155  * which are either lists of addresses or lists of address,size tuples, but
156  * the number of cells used for each element vary depending on the
157  * #address-cells and #size-cells properties of their parent node.
158  * If you know all your cell elements are one cell wide you can use the
159  * simpler qemu_fdt_setprop_cells(). If you're not setting up the
160  * array programmatically, qemu_fdt_setprop_sized_cells may be more
161  * convenient.
162  *
163  * Return value: 0 on success, <0 on error.
164  */
165 int qemu_fdt_setprop_sized_cells_from_array(void *fdt,
166                                             const char *node_path,
167                                             const char *property,
168                                             int numvalues,
169                                             uint64_t *values);
170 
171 /**
172  * qemu_fdt_setprop_sized_cells:
173  * @fdt: device tree blob
174  * @node_path: node to set property on
175  * @property: property to set
176  * @...: list of number-of-cells, value pairs
177  *
178  * Set the specified property on the specified node in the device tree
179  * to be an array of cells. The values of the cells are specified via
180  * the variable arguments, which alternates between "number of cells
181  * used by this value" and "value".
182  *
183  * This is a convenience wrapper for the function
184  * qemu_fdt_setprop_sized_cells_from_array().
185  *
186  * Return value: 0 on success, <0 on error.
187  */
188 #define qemu_fdt_setprop_sized_cells(fdt, node_path, property, ...)       \
189     ({                                                                    \
190         uint64_t qdt_tmp[] = { __VA_ARGS__ };                             \
191         qemu_fdt_setprop_sized_cells_from_array(fdt, node_path,           \
192                                                 property,                 \
193                                                 ARRAY_SIZE(qdt_tmp) / 2,  \
194                                                 qdt_tmp);                 \
195     })
196 
197 
198 /**
199  * qemu_fdt_randomize_seeds:
200  * @fdt: device tree blob
201  *
202  * Re-randomize all "rng-seed" properties with new seeds.
203  */
204 void qemu_fdt_randomize_seeds(void *fdt);
205 
206 #define FDT_PCI_RANGE_RELOCATABLE          0x80000000
207 #define FDT_PCI_RANGE_PREFETCHABLE         0x40000000
208 #define FDT_PCI_RANGE_ALIASED              0x20000000
209 #define FDT_PCI_RANGE_TYPE_MASK            0x03000000
210 #define FDT_PCI_RANGE_MMIO_64BIT           0x03000000
211 #define FDT_PCI_RANGE_MMIO                 0x02000000
212 #define FDT_PCI_RANGE_IOPORT               0x01000000
213 #define FDT_PCI_RANGE_CONFIG               0x00000000
214 
215 #endif /* DEVICE_TREE_H */
216