static int do_bootz_linux_fdt(int fd, struct image_data *data)
{
struct fdt_header __header, *header;
void *oftree;
int ret;
u32 end;
if (data->oftree)
return -ENXIO;
header = &__header;
ret = read(fd, header, sizeof(*header));
if (ret < sizeof(*header))
return ret;
if (file_detect_type(header, sizeof(*header)) != filetype_oftree)
return -ENXIO;
end = be32_to_cpu(header->totalsize);
oftree = malloc(end + 0x8000);
if (!oftree) {
perror("zImage: oftree malloc");
return -ENOMEM;
}
memcpy(oftree, header, sizeof(*header));
end -= sizeof(*header);
ret = read_full(fd, oftree + sizeof(*header), end);
if (ret < 0)
goto err_free;
if (ret < end) {
printf("premature end of image\n");
ret = -EIO;
goto err_free;
}
if (IS_BUILTIN(CONFIG_OFTREE)) {
data->of_root_node = of_unflatten_dtb(NULL, oftree);
if (!data->of_root_node) {
pr_err("unable to unflatten devicetree\n");
ret = -EINVAL;
goto err_free;
}
} else {
data->oftree = oftree;
}
pr_info("zImage: concatenated oftree detected\n");
return 0;
err_free:
free(oftree);
return ret;
}
static int of_openrisc_init(void)
{
struct device_node *root;
root = of_get_root_node();
if (root)
return 0;
root = of_unflatten_dtb(__dtb_start);
if (root) {
pr_debug("using internal DTB\n");
of_set_root_node(root);
if (IS_ENABLED(CONFIG_OFDEVICE))
of_probe();
}
return 0;
}
static int of_arm_init(void)
{
struct device_node *root;
void *fdt;
/* See if we already have a dtb */
root = of_get_root_node();
if (root)
return 0;
/* See if we are provided a dtb in boarddata */
fdt = barebox_arm_boot_dtb();
if (fdt)
pr_debug("using boarddata provided DTB\n");
/* Next see if we have a builtin dtb */
if (!fdt && IS_ENABLED(CONFIG_BUILTIN_DTB)) {
fdt = __dtb_start;
pr_debug("using internal DTB\n");
}
if (!fdt) {
pr_debug("No DTB found\n");
return 0;
}
root = of_unflatten_dtb(fdt);
if (root) {
of_set_root_node(root);
of_fix_tree(root);
if (IS_ENABLED(CONFIG_OFDEVICE))
of_probe();
}
return 0;
}
static int do_oftree(int argc, char *argv[])
{
struct fdt_header *fdt = NULL;
void *fdt_free = NULL;
int size;
int opt;
char *file = NULL;
const char *node = "/";
int dump = 0;
int probe = 0;
int load = 0;
int save = 0;
int free_of = 0;
int ret;
while ((opt = getopt(argc, argv, "dpfn:ls")) > 0) {
switch (opt) {
case 'l':
load = 1;
break;
case 'd':
dump = 1;
break;
case 'p':
if (IS_ENABLED(CONFIG_CMD_OFTREE_PROBE)) {
probe = 1;
} else {
printf("oftree device probe support disabled\n");
return COMMAND_ERROR_USAGE;
}
break;
case 'f':
free_of = 1;
break;
case 'n':
node = optarg;
break;
case 's':
save = 1;
break;
}
}
if (free_of) {
struct device_node *root = of_get_root_node();
if (root)
of_free(root);
return 0;
}
if (optind < argc)
file = argv[optind];
if (!dump && !probe && !load && !save)
return COMMAND_ERROR_USAGE;
if (save) {
if (!file) {
printf("no file given\n");
ret = -ENOENT;
goto out;
}
fdt = of_get_fixed_tree(NULL);
if (!fdt) {
printf("no devicetree available\n");
ret = -EINVAL;
goto out;
}
ret = write_file(file, fdt, fdt_totalsize(fdt));
goto out;
}
if (file) {
fdt = read_file(file, &size);
if (!fdt) {
printf("unable to read %s\n", file);
return 1;
}
fdt_free = fdt;
}
if (load) {
if (!fdt) {
printf("no fdt given\n");
ret = -ENOENT;
goto out;
}
ret = of_unflatten_dtb(fdt);
if (ret) {
printf("parse oftree: %s\n", strerror(-ret));
goto out;
}
}
if (dump) {
if (fdt) {
ret = fdt_print(fdt, node);
} else {
struct device_node *n = of_find_node_by_path(node);
if (!n) {
ret = -ENOENT;
goto out;
}
of_print_nodes(n, 0);
ret = 0;
}
goto out;
}
if (probe) {
ret = of_probe();
if (ret)
goto out;
}
ret = 0;
out:
free(fdt_free);
return ret;
}
static int do_of_dump(int argc, char *argv[])
{
int opt;
int ret = 0;
int fix = 0;
struct device_node *root = NULL, *node, *of_free = NULL;
char *dtbfile = NULL;
size_t size;
const char *nodename;
int names_only = 0;
while ((opt = getopt(argc, argv, "Ff:n")) > 0) {
switch (opt) {
case 'f':
dtbfile = optarg;
break;
case 'F':
fix = 1;
break;
case 'n':
names_only = 1;
break;
default:
return COMMAND_ERROR_USAGE;
}
}
if (optind == argc)
nodename = "/";
else
nodename = argv[optind];
if (dtbfile) {
void *fdt;
fdt = read_file(dtbfile, &size);
if (!fdt) {
printf("unable to read %s: %s\n", dtbfile, strerror(errno));
return -errno;
}
root = of_unflatten_dtb(fdt);
free(fdt);
if (IS_ERR(root)) {
ret = PTR_ERR(root);
goto out;
}
of_free = root;
} else {
root = of_get_root_node();
if (fix) {
/* create a copy of internal devicetree */
void *fdt;
fdt = of_flatten_dtb(root);
root = of_unflatten_dtb(fdt);
free(fdt);
if (IS_ERR(root)) {
ret = PTR_ERR(root);
goto out;
}
of_free = root;
}
}
if (fix) {
ret = of_fix_tree(root);
if (ret)
goto out;
}
node = of_find_node_by_path_or_alias(root, nodename);
if (!node) {
printf("Cannot find nodepath %s\n", nodename);
ret = -ENOENT;
goto out;
}
if (names_only)
of_print_nodenames(node);
else
of_print_nodes(node, 0);
out:
if (of_free)
of_delete_node(of_free);
return ret;
}
