static int do_fdtget(struct display_info *disp, const char *filename,
char **arg, int arg_count, int args_per_step)
{
char *blob;
const char *prop;
int i, node;
blob = utilfdt_read(filename);
if (!blob)
return -1;
for (i = 0; i + args_per_step <= arg_count; i += args_per_step) {
node = fdt_path_offset(blob, arg[i]);
if (node < 0) {
if (disp->default_val) {
puts(disp->default_val);
continue;
} else {
report_error(arg[i], node);
return -1;
}
}
prop = args_per_step == 1 ? NULL : arg[i + 1];
if (show_data_for_item(blob, disp, node, prop))
return -1;
}
return 0;
}
int main(int argc, char *argv[])
{
char *buf;
if (argc < 2) {
fprintf(stderr, "supply input filename\n");
return 5;
}
buf = utilfdt_read(argv[1]);
if (buf)
dump_blob(buf);
else
return 10;
return 0;
}
/**
* Run the main fdtgrep operation, given a filename and valid arguments
*
* @param disp Display information / options
* @param filename Filename of blob file
* @param return 0 if ok, -ve on error
*/
static int do_fdtgrep(struct display_info *disp, const char *filename)
{
struct fdt_region *region;
int max_regions;
int count = 100;
char path[1024];
char *blob;
int i, ret;
blob = utilfdt_read(filename);
if (!blob)
return -1;
ret = fdt_check_header(blob);
if (ret) {
fprintf(stderr, "Error: %s\n", fdt_strerror(ret));
return ret;
}
/* Allow old files, but they are untested */
if (fdt_version(blob) < 17 && disp->value_head) {
fprintf(stderr,
"Warning: fdtgrep does not fully support version %d files\n",
fdt_version(blob));
}
/*
* We do two passes, since we don't know how many regions we need.
* The first pass will count the regions, but if it is too many,
* we do another pass to actually record them.
*/
for (i = 0; i < 3; i++) {
region = malloc(count * sizeof(struct fdt_region));
if (!region) {
fprintf(stderr, "Out of memory for %d regions\n",
count);
return -1;
}
max_regions = count;
count = fdtgrep_find_regions(blob,
h_include, disp,
region, max_regions, path, sizeof(path),
disp->flags);
if (count < 0) {
report_error("fdt_find_regions", count);
if (count == -FDT_ERR_BADLAYOUT)
fprintf(stderr,
"/aliases node must come before all other nodes\n");
return -1;
}
if (count <= max_regions)
break;
free(region);
}
/* Optionally print a list of regions */
if (disp->region_list)
show_region_list(region, count);
/* Output either source .dts or binary .dtb */
if (disp->output == OUT_DTS) {
ret = display_fdt_by_regions(disp, blob, region, count);
} else {
void *fdt;
/* Allow reserved memory section to expand slightly */
int size = fdt_totalsize(blob) + 16;
fdt = malloc(size);
if (!fdt) {
fprintf(stderr, "Out_of_memory\n");
ret = -1;
goto err;
}
size = dump_fdt_regions(disp, blob, region, count, fdt);
if (disp->remove_strings) {
void *out;
out = malloc(size);
if (!out) {
fprintf(stderr, "Out_of_memory\n");
ret = -1;
goto err;
}
ret = fdt_remove_unused_strings(fdt, out);
if (ret < 0) {
fprintf(stderr,
"Failed to remove unused strings: err=%d\n",
ret);
goto err;
}
free(fdt);
fdt = out;
ret = fdt_pack(fdt);
if (ret < 0) {
fprintf(stderr, "Failed to pack: err=%d\n",
ret);
goto err;
}
size = fdt_totalsize(fdt);
}
if (size != fwrite(fdt, 1, size, disp->fout)) {
fprintf(stderr, "Write failure, %d bytes\n", size);
free(fdt);
ret = 1;
goto err;
}
free(fdt);
}
err:
free(blob);
free(region);
return ret;
}
static int do_fdtoverlay(const char *input_filename,
const char *output_filename,
int argc, char *argv[])
{
char *blob = NULL;
char **ovblob = NULL;
size_t blob_len, ov_len, total_len;
int i, ret = -1;
blob = utilfdt_read(input_filename, &blob_len);
if (!blob) {
fprintf(stderr, "\nFailed to read base blob %s\n",
input_filename);
goto out_err;
}
if (fdt_totalsize(blob) > blob_len) {
fprintf(stderr,
"\nBase blob is incomplete (%lu / %" PRIu32 " bytes read)\n",
(unsigned long)blob_len, fdt_totalsize(blob));
goto out_err;
}
ret = 0;
/* allocate blob pointer array */
ovblob = malloc(sizeof(*ovblob) * argc);
memset(ovblob, 0, sizeof(*ovblob) * argc);
/* read and keep track of the overlay blobs */
total_len = 0;
for (i = 0; i < argc; i++) {
ovblob[i] = utilfdt_read(argv[i], &ov_len);
if (!ovblob[i]) {
fprintf(stderr, "\nFailed to read overlay %s\n",
argv[i]);
goto out_err;
}
total_len += ov_len;
}
/* grow the blob to worst case */
blob_len = fdt_totalsize(blob) + total_len;
blob = xrealloc(blob, blob_len);
fdt_open_into(blob, blob, blob_len);
/* apply the overlays in sequence */
for (i = 0; i < argc; i++) {
ret = fdt_overlay_apply(blob, ovblob[i]);
if (ret) {
fprintf(stderr, "\nFailed to apply %s (%d)\n",
argv[i], ret);
goto out_err;
}
}
fdt_pack(blob);
ret = utilfdt_write(output_filename, blob);
if (ret)
fprintf(stderr, "\nFailed to write output blob %s\n",
output_filename);
out_err:
if (ovblob) {
for (i = 0; i < argc; i++) {
if (ovblob[i])
free(ovblob[i]);
}
free(ovblob);
}
free(blob);
return ret;
}
