accel: move qtest CpusAccel functions to a common location
[qemu.git] / include / sysemu / device_tree.h
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 int qemu_fdt_setprop_phandle(void *fdt, const char *node_path,
74 const char *property,
75 const char *target_node_path);
76 /**
77 * qemu_fdt_getprop: retrieve the value of a given property
78 * @fdt: pointer to the device tree blob
79 * @node_path: node path
80 * @property: name of the property to find
81 * @lenp: fdt error if any or length of the property on success
82 * @errp: handle to an error object
83 *
84 * returns a pointer to the property on success and NULL on failure
85 */
86 const void *qemu_fdt_getprop(void *fdt, const char *node_path,
87 const char *property, int *lenp,
88 Error **errp);
89 /**
90 * qemu_fdt_getprop_cell: retrieve the value of a given 4 byte property
91 * @fdt: pointer to the device tree blob
92 * @node_path: node path
93 * @property: name of the property to find
94 * @lenp: fdt error if any or -EINVAL if the property size is different from
95 * 4 bytes, or 4 (expected length of the property) upon success.
96 * @errp: handle to an error object
97 *
98 * returns the property value on success
99 */
100 uint32_t qemu_fdt_getprop_cell(void *fdt, const char *node_path,
101 const char *property, int *lenp,
102 Error **errp);
103 uint32_t qemu_fdt_get_phandle(void *fdt, const char *path);
104 uint32_t qemu_fdt_alloc_phandle(void *fdt);
105 int qemu_fdt_nop_node(void *fdt, const char *node_path);
106 int qemu_fdt_add_subnode(void *fdt, const char *name);
107
108 #define qemu_fdt_setprop_cells(fdt, node_path, property, ...) \
109 do { \
110 uint32_t qdt_tmp[] = { __VA_ARGS__ }; \
111 int i; \
112 \
113 for (i = 0; i < ARRAY_SIZE(qdt_tmp); i++) { \
114 qdt_tmp[i] = cpu_to_be32(qdt_tmp[i]); \
115 } \
116 qemu_fdt_setprop(fdt, node_path, property, qdt_tmp, \
117 sizeof(qdt_tmp)); \
118 } while (0)
119
120 void qemu_fdt_dumpdtb(void *fdt, int size);
121
122 /**
123 * qemu_fdt_setprop_sized_cells_from_array:
124 * @fdt: device tree blob
125 * @node_path: node to set property on
126 * @property: property to set
127 * @numvalues: number of values
128 * @values: array of number-of-cells, value pairs
129 *
130 * Set the specified property on the specified node in the device tree
131 * to be an array of cells. The values of the cells are specified via
132 * the values list, which alternates between "number of cells used by
133 * this value" and "value".
134 * number-of-cells must be either 1 or 2 (other values will result in
135 * an error being returned). If a value is too large to fit in the
136 * number of cells specified for it, an error is returned.
137 *
138 * This function is useful because device tree nodes often have cell arrays
139 * which are either lists of addresses or lists of address,size tuples, but
140 * the number of cells used for each element vary depending on the
141 * #address-cells and #size-cells properties of their parent node.
142 * If you know all your cell elements are one cell wide you can use the
143 * simpler qemu_fdt_setprop_cells(). If you're not setting up the
144 * array programmatically, qemu_fdt_setprop_sized_cells may be more
145 * convenient.
146 *
147 * Return value: 0 on success, <0 on error.
148 */
149 int qemu_fdt_setprop_sized_cells_from_array(void *fdt,
150 const char *node_path,
151 const char *property,
152 int numvalues,
153 uint64_t *values);
154
155 /**
156 * qemu_fdt_setprop_sized_cells:
157 * @fdt: device tree blob
158 * @node_path: node to set property on
159 * @property: property to set
160 * @...: list of number-of-cells, value pairs
161 *
162 * Set the specified property on the specified node in the device tree
163 * to be an array of cells. The values of the cells are specified via
164 * the variable arguments, which alternates between "number of cells
165 * used by this value" and "value".
166 *
167 * This is a convenience wrapper for the function
168 * qemu_fdt_setprop_sized_cells_from_array().
169 *
170 * Return value: 0 on success, <0 on error.
171 */
172 #define qemu_fdt_setprop_sized_cells(fdt, node_path, property, ...) \
173 ({ \
174 uint64_t qdt_tmp[] = { __VA_ARGS__ }; \
175 qemu_fdt_setprop_sized_cells_from_array(fdt, node_path, \
176 property, \
177 ARRAY_SIZE(qdt_tmp) / 2, \
178 qdt_tmp); \
179 })
180
181 #define FDT_PCI_RANGE_RELOCATABLE 0x80000000
182 #define FDT_PCI_RANGE_PREFETCHABLE 0x40000000
183 #define FDT_PCI_RANGE_ALIASED 0x20000000
184 #define FDT_PCI_RANGE_TYPE_MASK 0x03000000
185 #define FDT_PCI_RANGE_MMIO_64BIT 0x03000000
186 #define FDT_PCI_RANGE_MMIO 0x02000000
187 #define FDT_PCI_RANGE_IOPORT 0x01000000
188 #define FDT_PCI_RANGE_CONFIG 0x00000000
189
190 #endif /* DEVICE_TREE_H */