]>
git.proxmox.com Git - mirror_qemu.git/blob - device_tree.c
3553819257b1ca39ec18c2a00f2c46802190aefd
2 * Functions to help device tree manipulation using libfdt.
3 * It also provides functions to read entries from device tree proc
6 * Copyright 2008 IBM Corporation.
7 * Authors: Jerone Young <jyoung5@us.ibm.com>
8 * Hollis Blanchard <hollisb@us.ibm.com>
10 * This work is licensed under the GNU GPL license version 2 or later.
14 #include "qemu/osdep.h"
20 #include "qapi/error.h"
21 #include "qemu/error-report.h"
22 #include "qemu/option.h"
23 #include "qemu/bswap.h"
24 #include "sysemu/device_tree.h"
25 #include "sysemu/sysemu.h"
26 #include "hw/loader.h"
27 #include "hw/boards.h"
28 #include "qemu/config-file.h"
32 #define FDT_MAX_SIZE 0x100000
34 void *create_device_tree(int *sizep
)
39 *sizep
= FDT_MAX_SIZE
;
40 fdt
= g_malloc0(FDT_MAX_SIZE
);
41 ret
= fdt_create(fdt
, FDT_MAX_SIZE
);
45 ret
= fdt_finish_reservemap(fdt
);
49 ret
= fdt_begin_node(fdt
, "");
53 ret
= fdt_end_node(fdt
);
57 ret
= fdt_finish(fdt
);
61 ret
= fdt_open_into(fdt
, fdt
, *sizep
);
63 error_report("Unable to copy device tree in memory");
69 error_report("%s Couldn't create dt: %s", __func__
, fdt_strerror(ret
));
73 void *load_device_tree(const char *filename_path
, int *sizep
)
76 int dt_file_load_size
;
81 dt_size
= get_image_size(filename_path
);
83 error_report("Unable to get size of device tree file '%s'",
88 /* Expand to 2x size to give enough room for manipulation. */
91 /* First allocate space in qemu for device tree */
92 fdt
= g_malloc0(dt_size
);
94 dt_file_load_size
= load_image(filename_path
, fdt
);
95 if (dt_file_load_size
< 0) {
96 error_report("Unable to open device tree file '%s'",
101 ret
= fdt_open_into(fdt
, fdt
, dt_size
);
103 error_report("Unable to copy device tree in memory");
107 /* Check sanity of device tree */
108 if (fdt_check_header(fdt
)) {
109 error_report("Device tree file loaded into memory is invalid: %s",
123 #define SYSFS_DT_BASEDIR "/proc/device-tree"
126 * read_fstree: this function is inspired from dtc read_fstree
127 * @fdt: preallocated fdt blob buffer, to be populated
128 * @dirname: directory to scan under SYSFS_DT_BASEDIR
129 * the search is recursive and the tree is searched down to the
130 * leaves (property files).
132 * the function asserts in case of error
134 static void read_fstree(void *fdt
, const char *dirname
)
139 const char *root_dir
= SYSFS_DT_BASEDIR
;
140 const char *parent_node
;
142 if (strstr(dirname
, root_dir
) != dirname
) {
143 error_report("%s: %s must be searched within %s",
144 __func__
, dirname
, root_dir
);
147 parent_node
= &dirname
[strlen(SYSFS_DT_BASEDIR
)];
149 d
= opendir(dirname
);
151 error_report("%s cannot open %s", __func__
, dirname
);
155 while ((de
= readdir(d
)) != NULL
) {
158 if (!g_strcmp0(de
->d_name
, ".")
159 || !g_strcmp0(de
->d_name
, "..")) {
163 tmpnam
= g_strdup_printf("%s/%s", dirname
, de
->d_name
);
165 if (lstat(tmpnam
, &st
) < 0) {
166 error_report("%s cannot lstat %s", __func__
, tmpnam
);
170 if (S_ISREG(st
.st_mode
)) {
174 if (!g_file_get_contents(tmpnam
, &val
, &len
, NULL
)) {
175 error_report("%s not able to extract info from %s",
180 if (strlen(parent_node
) > 0) {
181 qemu_fdt_setprop(fdt
, parent_node
,
182 de
->d_name
, val
, len
);
184 qemu_fdt_setprop(fdt
, "/", de
->d_name
, val
, len
);
187 } else if (S_ISDIR(st
.st_mode
)) {
190 node_name
= g_strdup_printf("%s/%s",
191 parent_node
, de
->d_name
);
192 qemu_fdt_add_subnode(fdt
, node_name
);
194 read_fstree(fdt
, tmpnam
);
203 /* load_device_tree_from_sysfs: extract the dt blob from host sysfs */
204 void *load_device_tree_from_sysfs(void)
209 host_fdt
= create_device_tree(&host_fdt_size
);
210 read_fstree(host_fdt
, SYSFS_DT_BASEDIR
);
211 if (fdt_check_header(host_fdt
)) {
212 error_report("%s host device tree extracted into memory is invalid",
219 #endif /* CONFIG_LINUX */
221 static int findnode_nofail(void *fdt
, const char *node_path
)
225 offset
= fdt_path_offset(fdt
, node_path
);
227 error_report("%s Couldn't find node %s: %s", __func__
, node_path
,
228 fdt_strerror(offset
));
235 char **qemu_fdt_node_path(void *fdt
, const char *name
, char *compat
,
238 int offset
, len
, ret
;
239 const char *iter_name
;
240 unsigned int path_len
= 16, n
= 0;
241 GSList
*path_list
= NULL
, *iter
;
244 offset
= fdt_node_offset_by_compatible(fdt
, -1, compat
);
246 while (offset
>= 0) {
247 iter_name
= fdt_get_name(fdt
, offset
, &len
);
252 if (!strcmp(iter_name
, name
)) {
255 path
= g_malloc(path_len
);
256 while ((ret
= fdt_get_path(fdt
, offset
, path
, path_len
))
257 == -FDT_ERR_NOSPACE
) {
259 path
= g_realloc(path
, path_len
);
261 path_list
= g_slist_prepend(path_list
, path
);
264 offset
= fdt_node_offset_by_compatible(fdt
, offset
, compat
);
267 if (offset
< 0 && offset
!= -FDT_ERR_NOTFOUND
) {
268 error_setg(errp
, "%s: abort parsing dt for %s/%s: %s",
269 __func__
, name
, compat
, fdt_strerror(offset
));
270 for (iter
= path_list
; iter
; iter
= iter
->next
) {
273 g_slist_free(path_list
);
277 path_array
= g_new(char *, n
+ 1);
278 path_array
[n
--] = NULL
;
280 for (iter
= path_list
; iter
; iter
= iter
->next
) {
281 path_array
[n
--] = iter
->data
;
284 g_slist_free(path_list
);
289 int qemu_fdt_setprop(void *fdt
, const char *node_path
,
290 const char *property
, const void *val
, int size
)
294 r
= fdt_setprop(fdt
, findnode_nofail(fdt
, node_path
), property
, val
, size
);
296 error_report("%s: Couldn't set %s/%s: %s", __func__
, node_path
,
297 property
, fdt_strerror(r
));
304 int qemu_fdt_setprop_cell(void *fdt
, const char *node_path
,
305 const char *property
, uint32_t val
)
309 r
= fdt_setprop_cell(fdt
, findnode_nofail(fdt
, node_path
), property
, val
);
311 error_report("%s: Couldn't set %s/%s = %#08x: %s", __func__
,
312 node_path
, property
, val
, fdt_strerror(r
));
319 int qemu_fdt_setprop_u64(void *fdt
, const char *node_path
,
320 const char *property
, uint64_t val
)
322 val
= cpu_to_be64(val
);
323 return qemu_fdt_setprop(fdt
, node_path
, property
, &val
, sizeof(val
));
326 int qemu_fdt_setprop_string(void *fdt
, const char *node_path
,
327 const char *property
, const char *string
)
331 r
= fdt_setprop_string(fdt
, findnode_nofail(fdt
, node_path
), property
, string
);
333 error_report("%s: Couldn't set %s/%s = %s: %s", __func__
,
334 node_path
, property
, string
, fdt_strerror(r
));
341 const void *qemu_fdt_getprop(void *fdt
, const char *node_path
,
342 const char *property
, int *lenp
, Error
**errp
)
350 r
= fdt_getprop(fdt
, findnode_nofail(fdt
, node_path
), property
, lenp
);
352 error_setg(errp
, "%s: Couldn't get %s/%s: %s", __func__
,
353 node_path
, property
, fdt_strerror(*lenp
));
358 uint32_t qemu_fdt_getprop_cell(void *fdt
, const char *node_path
,
359 const char *property
, int *lenp
, Error
**errp
)
367 p
= qemu_fdt_getprop(fdt
, node_path
, property
, lenp
, errp
);
370 } else if (*lenp
!= 4) {
371 error_setg(errp
, "%s: %s/%s not 4 bytes long (not a cell?)",
372 __func__
, node_path
, property
);
376 return be32_to_cpu(*p
);
379 uint32_t qemu_fdt_get_phandle(void *fdt
, const char *path
)
383 r
= fdt_get_phandle(fdt
, findnode_nofail(fdt
, path
));
385 error_report("%s: Couldn't get phandle for %s: %s", __func__
,
386 path
, fdt_strerror(r
));
393 int qemu_fdt_setprop_phandle(void *fdt
, const char *node_path
,
394 const char *property
,
395 const char *target_node_path
)
397 uint32_t phandle
= qemu_fdt_get_phandle(fdt
, target_node_path
);
398 return qemu_fdt_setprop_cell(fdt
, node_path
, property
, phandle
);
401 uint32_t qemu_fdt_alloc_phandle(void *fdt
)
403 static int phandle
= 0x0;
406 * We need to find out if the user gave us special instruction at
407 * which phandle id to start allocating phandles.
410 phandle
= machine_phandle_start(current_machine
);
415 * None or invalid phandle given on the command line, so fall back to
416 * default starting point.
424 int qemu_fdt_nop_node(void *fdt
, const char *node_path
)
428 r
= fdt_nop_node(fdt
, findnode_nofail(fdt
, node_path
));
430 error_report("%s: Couldn't nop node %s: %s", __func__
, node_path
,
438 int qemu_fdt_add_subnode(void *fdt
, const char *name
)
440 char *dupname
= g_strdup(name
);
441 char *basename
= strrchr(dupname
, '/');
454 parent
= findnode_nofail(fdt
, dupname
);
457 retval
= fdt_add_subnode(fdt
, parent
, basename
);
459 error_report("FDT: Failed to create subnode %s: %s", name
,
460 fdt_strerror(retval
));
468 void qemu_fdt_dumpdtb(void *fdt
, int size
)
470 const char *dumpdtb
= qemu_opt_get(qemu_get_machine_opts(), "dumpdtb");
473 /* Dump the dtb to a file and quit */
474 exit(g_file_set_contents(dumpdtb
, fdt
, size
, NULL
) ? 0 : 1);
478 int qemu_fdt_setprop_sized_cells_from_array(void *fdt
,
479 const char *node_path
,
480 const char *property
,
486 int cellnum
, vnum
, ncells
;
490 propcells
= g_new0(uint32_t, numvalues
* 2);
493 for (vnum
= 0; vnum
< numvalues
; vnum
++) {
494 ncells
= values
[vnum
* 2];
495 if (ncells
!= 1 && ncells
!= 2) {
499 value
= values
[vnum
* 2 + 1];
500 hival
= cpu_to_be32(value
>> 32);
502 propcells
[cellnum
++] = hival
;
503 } else if (hival
!= 0) {
507 propcells
[cellnum
++] = cpu_to_be32(value
);
510 ret
= qemu_fdt_setprop(fdt
, node_path
, property
, propcells
,
511 cellnum
* sizeof(uint32_t));