static int do_nanostage_image(uint8_t *buf, unsigned long size)
{
if(size < sizeof(struct rknano_stage_section_t))
return 1;
struct rknano_stage_header_t *hdr = (void *)buf;
cprintf(BLUE, "Header\n");
cprintf(GREEN, " Base Address: ");
cprintf(YELLOW, "%#08x\n", hdr->addr);
cprintf(GREEN, " Load count: ");
cprintf(YELLOW, "%d\n", hdr->count);
struct rknano_stage_section_t *sec = (void *)(hdr + 1);
for(unsigned i = 0; i < hdr->count; i++, sec++)
{
cprintf(BLUE, "Section %d\n", i);
cprintf(GREEN, " Code: ");
cprintf(YELLOW, "0x%08x", sec->code_pa);
cprintf(RED, "-(txt)-");
cprintf(YELLOW, "0x%08x", sec->code_pa + sec->code_sz);
cprintf(BLUE, " |--> ");
cprintf(YELLOW, "0x%08x", sec->code_va);
cprintf(RED, "-(txt)-");
cprintf(YELLOW, "0x%08x\n", sec->code_va + sec->code_sz);
cprintf(GREEN, " Data: ");
cprintf(YELLOW, "0x%08x", sec->data_pa);
cprintf(RED, "-(dat)-");
cprintf(YELLOW, "0x%08x", sec->data_pa + sec->data_sz);
cprintf(BLUE, " |--> ");
cprintf(YELLOW, "0x%08x", sec->data_va);
cprintf(RED, "-(dat)-");
cprintf(YELLOW, "0x%08x\n", sec->data_va + sec->data_sz);
cprintf(GREEN, " Data: ");
cprintf(RED, " ");
cprintf(BLUE, " |--> ");
cprintf(YELLOW, "0x%08x", sec->bss_va);
cprintf(RED, "-(bss)-");
cprintf(YELLOW, "0x%08x\n", sec->bss_va + sec->bss_sz);
#if 0
struct rknano_blob_t blob;
blob.offset = sec->code_pa - hdr->addr;
blob.size = sec->code_sz;
save_blob(&blob, buf, size, "entry.", i, NO_ENC);
#else
struct elf_params_t elf;
elf_init(&elf);
elf_add_load_section(&elf, sec->code_va, sec->code_sz, buf + sec->code_pa - hdr->addr);
elf_add_load_section(&elf, sec->data_va, sec->data_sz, buf + sec->data_pa - hdr->addr);
elf_add_fill_section(&elf, sec->bss_va, sec->bss_sz, 0);
extract_elf_section(&elf, i);
elf_release(&elf);
#endif
}
return 0;
}
int main(int argc, char *argv[])
{
void *fdt;
int err;
int offset, s1, s2;
test_init(argc, argv);
fdt = xmalloc(SPACE);
/* First create empty tree with SW */
CHECK(fdt_create(fdt, SPACE));
CHECK(fdt_finish_reservemap(fdt));
CHECK(fdt_begin_node(fdt, ""));
CHECK(fdt_end_node(fdt));
CHECK(fdt_finish(fdt));
verbose_printf("Built empty tree, totalsize = %d\n",
fdt_totalsize(fdt));
CHECK(fdt_open_into(fdt, fdt, SPACE));
CHECK(fdt_add_mem_rsv(fdt, TEST_ADDR_1, TEST_SIZE_1));
CHECK(fdt_add_mem_rsv(fdt, TEST_ADDR_2, TEST_SIZE_2));
CHECK(fdt_setprop_string(fdt, 0, "compatible", "test_tree1"));
CHECK(fdt_setprop_cell(fdt, 0, "prop-int", TEST_VALUE_1));
CHECK(fdt_setprop_string(fdt, 0, "prop-str", TEST_STRING_1));
OFF_CHECK(offset, fdt_add_subnode(fdt, 0, "subnode@1"));
s1 = offset;
CHECK(fdt_setprop_string(fdt, s1, "compatible", "subnode1"));
CHECK(fdt_setprop_cell(fdt, s1, "prop-int", TEST_VALUE_1));
OFF_CHECK(offset, fdt_add_subnode(fdt, s1, "subsubnode"));
CHECK(fdt_setprop(fdt, offset, "compatible",
"subsubnode1\0subsubnode", 23));
CHECK(fdt_setprop_cell(fdt, offset, "prop-int", TEST_VALUE_1));
OFF_CHECK(offset, fdt_add_subnode(fdt, s1, "ss1"));
OFF_CHECK(offset, fdt_add_subnode(fdt, 0, "subnode@2"));
s2 = offset;
CHECK(fdt_setprop_cell(fdt, s2, "linux,phandle", PHANDLE_1));
CHECK(fdt_setprop_cell(fdt, s2, "prop-int", TEST_VALUE_2));
OFF_CHECK(offset, fdt_add_subnode(fdt, s2, "subsubnode@0"));
CHECK(fdt_setprop_cell(fdt, offset, "linux,phandle", PHANDLE_2));
CHECK(fdt_setprop(fdt, offset, "compatible",
"subsubnode2\0subsubnode", 23));
CHECK(fdt_setprop_cell(fdt, offset, "prop-int", TEST_VALUE_2));
OFF_CHECK(offset, fdt_add_subnode(fdt, s2, "ss2"));
CHECK(fdt_pack(fdt));
save_blob("rw_tree1.test.dtb", fdt);
PASS();
}
int main(int argc, char *argv[])
{
void *fdt, *fdt1;
void *buf;
int oldsize, bufsize, packsize;
int err;
const char *inname;
char outname[PATH_MAX];
test_init(argc, argv);
fdt = load_blob_arg(argc, argv);
inname = argv[1];
oldsize = fdt_totalsize(fdt);
bufsize = oldsize * 2;
buf = xmalloc(bufsize);
/* don't leak uninitialized memory into our output */
memset(buf, 0, bufsize);
fdt1 = buf;
err = fdt_open_into(fdt, fdt1, bufsize);
if (err)
FAIL("fdt_open_into(): %s", fdt_strerror(err));
sprintf(outname, "opened.%s", inname);
save_blob(outname, fdt1);
err = fdt_pack(fdt1);
if (err)
FAIL("fdt_pack(): %s", fdt_strerror(err));
sprintf(outname, "repacked.%s", inname);
save_blob(outname, fdt1);
packsize = fdt_totalsize(fdt1);
verbose_printf("oldsize = %d, bufsize = %d, packsize = %d\n",
oldsize, bufsize, packsize);
PASS();
}
int main(int argc, char *argv[])
{
const char *fname = NULL;
int flags = 0;
int space = 0;
void *fdt;
test_init(argc, argv);
if (argc < 2) {
verbose_printf("Usage: %s <flag value> [<space>]"
" [<output_fname.dtb>]", argv[0]);
FAIL();
}
flags = atoi(argv[1]);
if (argc >= 3)
space = atoi(argv[2]);
if (argc >= 4)
fname = argv[3];
/*
* Allocate space for the tree and build it, creating a list of
* expected regions.
*/
fdt = xmalloc(SPACE);
build_tree(fdt, flags, space);
/* Write the tree out if required */
if (fname)
save_blob(fname, fdt);
/* Check the regions are what we expect */
if (check_regions(fdt, flags))
FAIL();
else
PASS();
return 0;
}
int main(int argc, char *argv[])
{
void *fdt, *buf;
int err;
uint8_t bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04};
test_init(argc, argv);
fdt = load_blob_arg(argc, argv);
buf = xmalloc(SPACE);
CHECK(fdt_open_into(fdt, buf, SPACE));
fdt = buf;
CHECK(fdt_appendprop(fdt, 0, "prop-bytes", bytes, sizeof(bytes)));
CHECK(fdt_appendprop_cell(fdt, 0, "prop-int", TEST_VALUE_2));
CHECK(fdt_appendprop_u64(fdt, 0, "prop-int64", TEST_VALUE64_1));
CHECK(fdt_appendprop_string(fdt, 0, "prop-str", TEST_STRING_2));
CHECK(fdt_pack(fdt));
save_blob("appendprop2.test.dtb", fdt);
PASS();
}
static int do_nanofw_image(uint8_t *buf, unsigned long size)
{
if(size < sizeof(struct rknano_header_t))
return 1;
struct rknano_header_t *hdr = (void *)buf;
if(size < hdr->size)
return 1;
if(strncmp(hdr->magic, MAGIC_RKNANOFW, MAGIC_RKNANOFW_SIZE))
return 1;
cprintf(BLUE, "Header\n");
cprintf(GREEN, " Date: ");
cprintf(YELLOW, "%x/%x/%x\n", hdr->date.mday, hdr->date.month, hdr->date.year);
cprintf(GREEN, " Version: ");
cprintf(YELLOW, "%x.%x.%x\n", hdr->version.major, hdr->version.minor, hdr->version.rev);
cprintf(GREEN, " Vendor: ");
cprintf(YELLOW, "%s\n", hdr->vendor);
cprintf(GREEN, " Model: ");
cprintf(YELLOW, "%s\n", hdr->model);
cprintf(GREEN, " Pad: ");
for(int i = 0; i < 6; i++)
cprintf(YELLOW, " %02x", hdr->unk6[i]);
cprintf(YELLOW, "\n");
cprintf(BLUE, "Stages\n");
for(unsigned i = 0; i < hdr->nr_stages; i++)
{
cprintf(GREEN, " %i: ", i);
print_blob_interval(&hdr->stage[i]);
cprintf(OFF, "\n");
save_blob(&hdr->stage[i], buf, size, "stage", i, NO_ENC);
}
cprintf(BLUE, "Fonts\n");
for(unsigned i = 0; i < hdr->nr_fonts; i++)
{
cprintf(GREEN, " %i: ", i);
print_blob_interval(&hdr->font[i]);
cprintf(OFF, "\n");
save_blob(&hdr->font[i], buf, size, "font", i, NO_ENC);
}
cprintf(BLUE, "GBK\n");
for(unsigned i = 0; i < hdr->nr_gbk; i++)
{
cprintf(GREEN, " %i: ", i);
print_blob_interval(&hdr->gbk[i]);
cprintf(OFF, "\n");
save_blob(&hdr->gbk[i], buf, size, "gbk", i, NO_ENC);
}
cprintf(BLUE, "String Tables\n");
for(unsigned i = 0; i < hdr->nr_strtbl; i++)
{
cprintf(GREEN, " %i: ", i);
print_blob_interval(&hdr->strtbl[i]);
cprintf(OFF, "\n");
save_blob(&hdr->strtbl[i], buf, size, "strtbl", i, NO_ENC);
}
cprintf(BLUE, "Image Resources\n");
for(unsigned i = 0; i < hdr->nr_imageres; i++)
{
cprintf(GREEN, " %i: ", i);
print_blob_interval(&hdr->imageres[i]);
cprintf(OFF, "\n");
save_blob(&hdr->imageres[i], buf, size, "imgres", i, NO_ENC);
}
cprintf(BLUE, "Unknown\n");
for(unsigned i = 0; i < hdr->nr_unk; i++)
{
cprintf(GREEN, " %i: ", i);
print_blob_interval(&hdr->unk[i]);
cprintf(OFF, "\n");
save_blob(&hdr->unk[i], buf, size, "unk", i, NO_ENC);
}
cprintf(BLUE, "Other\n");
cprintf(GREEN, " Size: ");
cprintf(YELLOW, "%#x\n", hdr->size);
cprintf(GREEN, " Magic: ");
cprintf(YELLOW, "%." STR(MAGIC_RKNANOFW_SIZE) "s ", hdr->magic);
if(strncmp(hdr->magic, MAGIC_RKNANOFW, MAGIC_RKNANOFW_SIZE) == 0)
cprintf(RED, "OK\n");
else
cprintf(RED, "Mismatch\n");
return 0;
}
