int fdt_resize(void *fdt, void *buf, int bufsize)
{
size_t headsize, tailsize;
char *oldtail, *newtail;
FDT_SW_CHECK_HEADER(fdt);
headsize = fdt_off_dt_struct(fdt);
tailsize = fdt_size_dt_strings(fdt);
if ((headsize + tailsize) > bufsize)
return -FDT_ERR_NOSPACE;
oldtail = (char *)fdt + fdt_totalsize(fdt) - tailsize;
newtail = (char *)buf + bufsize - tailsize;
/* Two cases to avoid clobbering data if the old and new
* buffers partially overlap */
if (buf <= fdt) {
memmove(buf, fdt, headsize);
memmove(newtail, oldtail, tailsize);
} else {
memmove(newtail, oldtail, tailsize);
memmove(buf, fdt, headsize);
}
fdt_set_off_dt_strings(buf, bufsize);
fdt_set_totalsize(buf, bufsize);
return 0;
}
static int state_ensure_space(int extra_size)
{
void *blob = state->state_fdt;
int used, size, free;
void *buf;
int ret;
used = fdt_off_dt_strings(blob) + fdt_size_dt_strings(blob);
size = fdt_totalsize(blob);
free = size - used;
if (free > extra_size)
return 0;
size = used + extra_size;
buf = os_malloc(size);
if (!buf)
return -ENOMEM;
ret = fdt_open_into(blob, buf, size);
if (ret) {
os_free(buf);
return -EIO;
}
os_free(blob);
state->state_fdt = buf;
return 0;
}
int fdt_finish(void *fdt)
{
int err = check_header_sw(fdt);
char *p = (char *)fdt;
uint32_t *end;
int oldstroffset, newstroffset;
uint32_t tag;
int offset, nextoffset;
if (err)
return err;
/* Add terminator */
end = grab_space(fdt, sizeof(*end));
if (! end)
return -FDT_ERR_NOSPACE;
*end = cpu_to_fdt32(FDT_END);
/* Relocate the string table */
oldstroffset = fdt_totalsize(fdt) - fdt_size_dt_strings(fdt);
newstroffset = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
memmove(p + newstroffset, p + oldstroffset, fdt_size_dt_strings(fdt));
fdt_set_off_dt_strings(fdt, newstroffset);
/* Walk the structure, correcting string offsets */
offset = 0;
while ((tag = fdt_next_tag(fdt, offset, &nextoffset)) != FDT_END) {
if (tag == FDT_PROP) {
struct fdt_property *prop =
fdt_offset_ptr_w(fdt, offset, sizeof(*prop));
int nameoff;
if (! prop)
return -FDT_ERR_BADSTRUCTURE;
nameoff = fdt32_to_cpu(prop->nameoff);
nameoff += fdt_size_dt_strings(fdt);
prop->nameoff = cpu_to_fdt32(nameoff);
}
offset = nextoffset;
}
/* Finally, adjust the header */
fdt_set_totalsize(fdt, newstroffset + fdt_size_dt_strings(fdt));
fdt_set_magic(fdt, FDT_MAGIC);
return 0;
}
int fdt_finish(void *fdt)
{
char *p = (char *)fdt;
uint32_t *end;
int oldstroffset, newstroffset;
uint32_t tag;
int offset, nextoffset;
FDT_SW_CHECK_HEADER(fdt);
end = _fdt_grab_space(fdt, sizeof(*end));
if (! end)
return -FDT_ERR_NOSPACE;
*end = cpu_to_fdt32(FDT_END);
oldstroffset = fdt_totalsize(fdt) - fdt_size_dt_strings(fdt);
newstroffset = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
memmove(p + newstroffset, p + oldstroffset, fdt_size_dt_strings(fdt));
fdt_set_off_dt_strings(fdt, newstroffset);
offset = 0;
while ((tag = fdt_next_tag(fdt, offset, &nextoffset)) != FDT_END) {
if (tag == FDT_PROP) {
struct fdt_property *prop =
_fdt_offset_ptr_w(fdt, offset);
int nameoff;
nameoff = fdt32_to_cpu(prop->nameoff);
nameoff += fdt_size_dt_strings(fdt);
prop->nameoff = cpu_to_fdt32(nameoff);
}
offset = nextoffset;
}
if (nextoffset < 0)
return nextoffset;
fdt_set_totalsize(fdt, newstroffset + fdt_size_dt_strings(fdt));
fdt_set_magic(fdt, FDT_MAGIC);
return 0;
}
void dump_fdt(const void *fdt)
{
int err;
dprintf("FDT @ %p:\n", fdt);
if (!fdt)
return;
err = fdt_check_header(fdt);
if (err) {
dprintf("fdt error: %s\n", fdt_strerror(err));
return;
}
dprintf("fdt_totalsize: %d\n", fdt_totalsize(fdt));
dprintf("fdt_off_dt_struct: %d\n", fdt_off_dt_struct(fdt));
dprintf("fdt_off_dt_strings: %d\n", fdt_off_dt_strings(fdt));
dprintf("fdt_off_mem_rsvmap: %d\n", fdt_off_mem_rsvmap(fdt));
dprintf("fdt_version: %d\n", fdt_version(fdt));
dprintf("fdt_last_comp_version: %d\n", fdt_last_comp_version(fdt));
dprintf("fdt_boot_cpuid_phys: %d\n", fdt_boot_cpuid_phys(fdt));
dprintf("fdt_size_dt_strings: %d\n", fdt_size_dt_strings(fdt));
dprintf("fdt_size_dt_struct: %d\n", fdt_size_dt_struct(fdt));
#ifdef FDT_DUMP_NODES
dprintf("fdt tree:\n");
int node = -1;
int depth = 0;
while ((node = fdt_next_node(fdt, node, &depth)) >= 0) {
dprintf(DS"node at %d: '%s'\n", DA, node,
fdt_get_name(fdt, node, NULL));
#ifdef FDT_DUMP_PROPS
int prop, len;
const struct fdt_property *property;
prop = fdt_first_property_offset(fdt, node);
while (prop >= 0) {
property = fdt_get_property_by_offset(fdt, prop, &len);
if (property == NULL) {
dprintf("getting prop at %d: %s\n", prop, fdt_strerror(len));
break;
}
dprintf(DS" prop at %d: '%s', len %d\n", DA, prop,
fdt_string(fdt, fdt32_to_cpu(property->nameoff)),
fdt32_to_cpu(property->len));
#ifdef FDT_DUMP_PROP_VALUES
dump_hex(property->data, fdt32_to_cpu(property->len), depth);
#endif
prop = fdt_next_property_offset(fdt, prop);
}
#endif
}
#endif
}
static void *_fdt_grab_space(void *fdt, int len)
{
int offset = fdt_size_dt_struct(fdt);
int spaceleft;
spaceleft = fdt_totalsize(fdt) - fdt_off_dt_struct(fdt)
- fdt_size_dt_strings(fdt);
if ((offset + len < offset) || (offset + len > spaceleft))
return NULL;
fdt_set_size_dt_struct(fdt, offset + len);
return fdt_offset_ptr_w(fdt, offset, len);
}
/* Resize the fdt to its actual size + a bit of padding */
int fdt_shrink_to_minimum(void *blob, uint extrasize)
{
int i;
uint64_t addr, size;
int total, ret;
uint actualsize;
if (!blob)
return 0;
total = fdt_num_mem_rsv(blob);
for (i = 0; i < total; i++) {
fdt_get_mem_rsv(blob, i, &addr, &size);
if (addr == (uintptr_t)blob) {
fdt_del_mem_rsv(blob, i);
break;
}
}
/*
* Calculate the actual size of the fdt
* plus the size needed for 5 fdt_add_mem_rsv, one
* for the fdt itself and 4 for a possible initrd
* ((initrd-start + initrd-end) * 2 (name & value))
*/
actualsize = fdt_off_dt_strings(blob) +
fdt_size_dt_strings(blob) + 5 * sizeof(struct fdt_reserve_entry);
actualsize += extrasize;
/* Make it so the fdt ends on a page boundary */
actualsize = ALIGN(actualsize + ((uintptr_t)blob & 0xfff), 0x1000);
actualsize = actualsize - ((uintptr_t)blob & 0xfff);
/* Change the fdt header to reflect the correct size */
fdt_set_totalsize(blob, actualsize);
/* Add the new reservation */
ret = fdt_add_mem_rsv(blob, (uintptr_t)blob, actualsize);
if (ret < 0)
return ret;
return actualsize;
}
/**
* fit_image_write_sig() - write the signature to a FIT
*
* This writes the signature and signer data to the FIT.
*
* @fit: pointer to the FIT format image header
* @noffset: hash node offset
* @value: signature value to be set
* @value_len: signature value length
* @comment: Text comment to write (NULL for none)
*
* returns
* 0, on success
* -FDT_ERR_..., on failure
*/
static int fit_image_write_sig(void *fit, int noffset, uint8_t *value,
int value_len, const char *comment, const char *region_prop,
int region_proplen)
{
int string_size;
int ret;
/*
* Get the current string size, before we update the FIT and add
* more
*/
string_size = fdt_size_dt_strings(fit);
ret = fdt_setprop(fit, noffset, FIT_VALUE_PROP, value, value_len);
if (!ret) {
ret = fdt_setprop_string(fit, noffset, "signer-name",
"mkimage");
}
if (!ret) {
ret = fdt_setprop_string(fit, noffset, "signer-version",
PLAIN_VERSION);
}
if (comment && !ret)
ret = fdt_setprop_string(fit, noffset, "comment", comment);
if (!ret)
ret = fit_set_timestamp(fit, noffset, time(NULL));
if (region_prop && !ret) {
uint32_t strdata[2];
ret = fdt_setprop(fit, noffset, "hashed-nodes",
region_prop, region_proplen);
strdata[0] = 0;
strdata[1] = cpu_to_fdt32(string_size);
if (!ret) {
ret = fdt_setprop(fit, noffset, "hashed-strings",
strdata, sizeof(strdata));
}
}
return ret;
}
static int _fdt_find_add_string(void *fdt, const char *s)
{
char *strtab = (char *)fdt + fdt_totalsize(fdt);
const char *p;
int strtabsize = fdt_size_dt_strings(fdt);
int len = strlen(s) + 1;
int struct_top, offset;
p = _fdt_find_string(strtab - strtabsize, strtabsize, s);
if (p)
return p - strtab;
/* Add it */
offset = -strtabsize - len;
struct_top = fdt_off_dt_struct(fdt) + fdt_size_dt_struct(fdt);
if (fdt_totalsize(fdt) + offset < (unsigned int)struct_top)
return 0; /* no more room :( */
memcpy(strtab + offset, s, len);
fdt_set_size_dt_strings(fdt, strtabsize + len);
return offset;
}
/*
* Flattened Device Tree command, see the help for parameter definitions.
*/
static int do_fdt(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
if (argc < 2)
return CMD_RET_USAGE;
/*
* Set the address of the fdt
*/
if (strncmp(argv[1], "ad", 2) == 0) {
unsigned long addr;
int control = 0;
struct fdt_header *blob;
/*
* Set the address [and length] of the fdt.
*/
argc -= 2;
argv += 2;
/* Temporary #ifdef - some archs don't have fdt_blob yet */
#ifdef CONFIG_OF_CONTROL
if (argc && !strcmp(*argv, "-c")) {
control = 1;
argc--;
argv++;
}
#endif
if (argc == 0) {
if (control)
blob = (struct fdt_header *)gd->fdt_blob;
else
blob = working_fdt;
if (!blob || !fdt_valid(&blob))
return 1;
printf("The address of the fdt is %#08lx\n",
control ? (ulong)map_to_sysmem(blob) :
getenv_hex("fdtaddr", 0));
return 0;
}
addr = simple_strtoul(argv[0], NULL, 16);
blob = map_sysmem(addr, 0);
if (!fdt_valid(&blob))
return 1;
if (control)
gd->fdt_blob = blob;
else
set_working_fdt_addr(addr);
if (argc >= 2) {
int len;
int err;
/*
* Optional new length
*/
len = simple_strtoul(argv[1], NULL, 16);
if (len < fdt_totalsize(blob)) {
printf ("New length %d < existing length %d, "
"ignoring.\n",
len, fdt_totalsize(blob));
} else {
/*
* Open in place with a new length.
*/
err = fdt_open_into(blob, blob, len);
if (err != 0) {
printf ("libfdt fdt_open_into(): %s\n",
fdt_strerror(err));
}
}
}
return CMD_RET_SUCCESS;
}
if (!working_fdt) {
puts(
"No FDT memory address configured. Please configure\n"
"the FDT address via \"fdt addr <address>\" command.\n"
"Aborting!\n");
return CMD_RET_FAILURE;
}
/*
* Move the working_fdt
*/
if (strncmp(argv[1], "mo", 2) == 0) {
struct fdt_header *newaddr;
int len;
int err;
if (argc < 4)
return CMD_RET_USAGE;
/*
* Set the address and length of the fdt.
*/
working_fdt = (struct fdt_header *)simple_strtoul(argv[2], NULL, 16);
if (!fdt_valid(&working_fdt))
return 1;
newaddr = (struct fdt_header *)simple_strtoul(argv[3],NULL,16);
/*
* If the user specifies a length, use that. Otherwise use the
* current length.
*/
if (argc <= 4) {
len = fdt_totalsize(working_fdt);
} else {
len = simple_strtoul(argv[4], NULL, 16);
if (len < fdt_totalsize(working_fdt)) {
printf ("New length 0x%X < existing length "
"0x%X, aborting.\n",
len, fdt_totalsize(working_fdt));
return 1;
}
}
/*
* Copy to the new location.
*/
err = fdt_open_into(working_fdt, newaddr, len);
if (err != 0) {
printf ("libfdt fdt_open_into(): %s\n",
fdt_strerror(err));
return 1;
}
working_fdt = newaddr;
/*
* Make a new node
*/
} else if (strncmp(argv[1], "mk", 2) == 0) {
char *pathp; /* path */
char *nodep; /* new node to add */
int nodeoffset; /* node offset from libfdt */
int err;
/*
* Parameters: Node path, new node to be appended to the path.
*/
if (argc < 4)
return CMD_RET_USAGE;
pathp = argv[2];
nodep = argv[3];
nodeoffset = fdt_path_offset (working_fdt, pathp);
if (nodeoffset < 0) {
/*
* Not found or something else bad happened.
*/
printf ("libfdt fdt_path_offset() returned %s\n",
fdt_strerror(nodeoffset));
return 1;
}
err = fdt_add_subnode(working_fdt, nodeoffset, nodep);
if (err < 0) {
printf ("libfdt fdt_add_subnode(): %s\n",
fdt_strerror(err));
return 1;
}
/*
* Set the value of a property in the working_fdt.
*/
} else if (argv[1][0] == 's') {
char *pathp; /* path */
char *prop; /* property */
int nodeoffset; /* node offset from libfdt */
static char data[SCRATCHPAD]; /* storage for the property */
int len; /* new length of the property */
int ret; /* return value */
/*
* Parameters: Node path, property, optional value.
*/
if (argc < 4)
return CMD_RET_USAGE;
pathp = argv[2];
prop = argv[3];
if (argc == 4) {
len = 0;
} else {
ret = fdt_parse_prop(&argv[4], argc - 4, data, &len);
if (ret != 0)
return ret;
}
nodeoffset = fdt_path_offset (working_fdt, pathp);
if (nodeoffset < 0) {
/*
* Not found or something else bad happened.
*/
printf ("libfdt fdt_path_offset() returned %s\n",
fdt_strerror(nodeoffset));
return 1;
}
ret = fdt_setprop(working_fdt, nodeoffset, prop, data, len);
if (ret < 0) {
printf ("libfdt fdt_setprop(): %s\n", fdt_strerror(ret));
return 1;
}
/********************************************************************
* Get the value of a property in the working_fdt.
********************************************************************/
} else if (argv[1][0] == 'g') {
char *subcmd; /* sub-command */
char *pathp; /* path */
char *prop; /* property */
char *var; /* variable to store result */
int nodeoffset; /* node offset from libfdt */
const void *nodep; /* property node pointer */
int len = 0; /* new length of the property */
/*
* Parameters: Node path, property, optional value.
*/
if (argc < 5)
return CMD_RET_USAGE;
subcmd = argv[2];
if (argc < 6 && subcmd[0] != 's')
return CMD_RET_USAGE;
var = argv[3];
pathp = argv[4];
prop = argv[5];
nodeoffset = fdt_path_offset(working_fdt, pathp);
if (nodeoffset < 0) {
/*
* Not found or something else bad happened.
*/
printf("libfdt fdt_path_offset() returned %s\n",
fdt_strerror(nodeoffset));
return 1;
}
if (subcmd[0] == 'n' || (subcmd[0] == 's' && argc == 5)) {
int reqIndex = -1;
int startDepth = fdt_node_depth(
working_fdt, nodeoffset);
int curDepth = startDepth;
int curIndex = -1;
int nextNodeOffset = fdt_next_node(
working_fdt, nodeoffset, &curDepth);
if (subcmd[0] == 'n')
reqIndex = simple_strtoul(argv[5], NULL, 16);
while (curDepth > startDepth) {
if (curDepth == startDepth + 1)
curIndex++;
if (subcmd[0] == 'n' && curIndex == reqIndex) {
const char *nodeName = fdt_get_name(
working_fdt, nextNodeOffset, NULL);
setenv(var, (char *)nodeName);
return 0;
}
nextNodeOffset = fdt_next_node(
working_fdt, nextNodeOffset, &curDepth);
if (nextNodeOffset < 0)
break;
}
if (subcmd[0] == 's') {
/* get the num nodes at this level */
setenv_ulong(var, curIndex + 1);
} else {
/* node index not found */
printf("libfdt node not found\n");
return 1;
}
} else {
nodep = fdt_getprop(
working_fdt, nodeoffset, prop, &len);
if (len == 0) {
/* no property value */
setenv(var, "");
return 0;
} else if (len > 0) {
if (subcmd[0] == 'v') {
int ret;
ret = fdt_value_setenv(nodep, len, var);
if (ret != 0)
return ret;
} else if (subcmd[0] == 'a') {
/* Get address */
char buf[11];
sprintf(buf, "0x%p", nodep);
setenv(var, buf);
} else if (subcmd[0] == 's') {
/* Get size */
char buf[11];
sprintf(buf, "0x%08X", len);
setenv(var, buf);
} else
return CMD_RET_USAGE;
return 0;
} else {
printf("libfdt fdt_getprop(): %s\n",
fdt_strerror(len));
return 1;
}
}
/*
* Print (recursive) / List (single level)
*/
} else if ((argv[1][0] == 'p') || (argv[1][0] == 'l')) {
int depth = MAX_LEVEL; /* how deep to print */
char *pathp; /* path */
char *prop; /* property */
int ret; /* return value */
static char root[2] = "/";
/*
* list is an alias for print, but limited to 1 level
*/
if (argv[1][0] == 'l') {
depth = 1;
}
/*
* Get the starting path. The root node is an oddball,
* the offset is zero and has no name.
*/
if (argc == 2)
pathp = root;
else
pathp = argv[2];
if (argc > 3)
prop = argv[3];
else
prop = NULL;
ret = fdt_print(pathp, prop, depth);
if (ret != 0)
return ret;
/*
* Remove a property/node
*/
} else if (strncmp(argv[1], "rm", 2) == 0) {
int nodeoffset; /* node offset from libfdt */
int err;
/*
* Get the path. The root node is an oddball, the offset
* is zero and has no name.
*/
nodeoffset = fdt_path_offset (working_fdt, argv[2]);
if (nodeoffset < 0) {
/*
* Not found or something else bad happened.
*/
printf ("libfdt fdt_path_offset() returned %s\n",
fdt_strerror(nodeoffset));
return 1;
}
/*
* Do the delete. A fourth parameter means delete a property,
* otherwise delete the node.
*/
if (argc > 3) {
err = fdt_delprop(working_fdt, nodeoffset, argv[3]);
if (err < 0) {
printf("libfdt fdt_delprop(): %s\n",
fdt_strerror(err));
return err;
}
} else {
err = fdt_del_node(working_fdt, nodeoffset);
if (err < 0) {
printf("libfdt fdt_del_node(): %s\n",
fdt_strerror(err));
return err;
}
}
/*
* Display header info
*/
} else if (argv[1][0] == 'h') {
u32 version = fdt_version(working_fdt);
printf("magic:\t\t\t0x%x\n", fdt_magic(working_fdt));
printf("totalsize:\t\t0x%x (%d)\n", fdt_totalsize(working_fdt),
fdt_totalsize(working_fdt));
printf("off_dt_struct:\t\t0x%x\n",
fdt_off_dt_struct(working_fdt));
printf("off_dt_strings:\t\t0x%x\n",
fdt_off_dt_strings(working_fdt));
printf("off_mem_rsvmap:\t\t0x%x\n",
fdt_off_mem_rsvmap(working_fdt));
printf("version:\t\t%d\n", version);
printf("last_comp_version:\t%d\n",
fdt_last_comp_version(working_fdt));
if (version >= 2)
printf("boot_cpuid_phys:\t0x%x\n",
fdt_boot_cpuid_phys(working_fdt));
if (version >= 3)
printf("size_dt_strings:\t0x%x\n",
fdt_size_dt_strings(working_fdt));
if (version >= 17)
printf("size_dt_struct:\t\t0x%x\n",
fdt_size_dt_struct(working_fdt));
printf("number mem_rsv:\t\t0x%x\n",
fdt_num_mem_rsv(working_fdt));
printf("\n");
/*
* Set boot cpu id
*/
} else if (strncmp(argv[1], "boo", 3) == 0) {
unsigned long tmp = simple_strtoul(argv[2], NULL, 16);
fdt_set_boot_cpuid_phys(working_fdt, tmp);
/*
* memory command
*/
} else if (strncmp(argv[1], "me", 2) == 0) {
uint64_t addr, size;
int err;
addr = simple_strtoull(argv[2], NULL, 16);
size = simple_strtoull(argv[3], NULL, 16);
err = fdt_fixup_memory(working_fdt, addr, size);
if (err < 0)
return err;
/*
* mem reserve commands
*/
} else if (strncmp(argv[1], "rs", 2) == 0) {
if (argv[2][0] == 'p') {
uint64_t addr, size;
int total = fdt_num_mem_rsv(working_fdt);
int j, err;
printf("index\t\t start\t\t size\n");
printf("-------------------------------"
"-----------------\n");
for (j = 0; j < total; j++) {
err = fdt_get_mem_rsv(working_fdt, j, &addr, &size);
if (err < 0) {
printf("libfdt fdt_get_mem_rsv(): %s\n",
fdt_strerror(err));
return err;
}
printf(" %x\t%08x%08x\t%08x%08x\n", j,
(u32)(addr >> 32),
(u32)(addr & 0xffffffff),
(u32)(size >> 32),
(u32)(size & 0xffffffff));
}
} else if (argv[2][0] == 'a') {
/*
* Flattened Device Tree command, see the help for parameter definitions.
*/
int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
{
if (argc < 2) {
printf ("Usage:\n%s\n", cmdtp->usage);
return 1;
}
/********************************************************************
* Set the address of the fdt
********************************************************************/
if (argv[1][0] == 'a') {
/*
* Set the address [and length] of the fdt.
*/
if (argc == 2) {
if (!fdt_valid()) {
return 1;
}
printf("The address of the fdt is %p\n", working_fdt);
return 0;
}
working_fdt = (struct fdt_header *)simple_strtoul(argv[2], NULL, 16);
if (!fdt_valid()) {
return 1;
}
if (argc >= 4) {
int len;
int err;
/*
* Optional new length
*/
len = simple_strtoul(argv[3], NULL, 16);
if (len < fdt_totalsize(working_fdt)) {
printf ("New length %d < existing length %d, "
"ignoring.\n",
len, fdt_totalsize(working_fdt));
} else {
/*
* Open in place with a new length.
*/
err = fdt_open_into(working_fdt, working_fdt, len);
if (err != 0) {
printf ("libfdt fdt_open_into(): %s\n",
fdt_strerror(err));
}
}
}
/********************************************************************
* Move the working_fdt
********************************************************************/
} else if (strncmp(argv[1], "mo", 2) == 0) {
struct fdt_header *newaddr;
int len;
int err;
if (argc < 4) {
printf ("Usage:\n%s\n", cmdtp->usage);
return 1;
}
/*
* Set the address and length of the fdt.
*/
working_fdt = (struct fdt_header *)simple_strtoul(argv[2], NULL, 16);
if (!fdt_valid()) {
return 1;
}
newaddr = (struct fdt_header *)simple_strtoul(argv[3],NULL,16);
/*
* If the user specifies a length, use that. Otherwise use the
* current length.
*/
if (argc <= 4) {
len = fdt_totalsize(working_fdt);
} else {
len = simple_strtoul(argv[4], NULL, 16);
if (len < fdt_totalsize(working_fdt)) {
printf ("New length 0x%X < existing length "
"0x%X, aborting.\n",
len, fdt_totalsize(working_fdt));
return 1;
}
}
/*
* Copy to the new location.
*/
err = fdt_open_into(working_fdt, newaddr, len);
if (err != 0) {
printf ("libfdt fdt_open_into(): %s\n",
fdt_strerror(err));
return 1;
}
working_fdt = newaddr;
/********************************************************************
* Make a new node
********************************************************************/
} else if (strncmp(argv[1], "mk", 2) == 0) {
char *pathp; /* path */
char *nodep; /* new node to add */
int nodeoffset; /* node offset from libfdt */
int err;
/*
* Parameters: Node path, new node to be appended to the path.
*/
if (argc < 4) {
printf ("Usage:\n%s\n", cmdtp->usage);
return 1;
}
pathp = argv[2];
nodep = argv[3];
nodeoffset = fdt_path_offset (working_fdt, pathp);
if (nodeoffset < 0) {
/*
* Not found or something else bad happened.
*/
printf ("libfdt fdt_path_offset() returned %s\n",
fdt_strerror(nodeoffset));
return 1;
}
err = fdt_add_subnode(working_fdt, nodeoffset, nodep);
if (err < 0) {
printf ("libfdt fdt_add_subnode(): %s\n",
fdt_strerror(err));
return 1;
}
/********************************************************************
* Set the value of a property in the working_fdt.
********************************************************************/
} else if (argv[1][0] == 's') {
char *pathp; /* path */
char *prop; /* property */
int nodeoffset; /* node offset from libfdt */
static char data[SCRATCHPAD]; /* storage for the property */
int len; /* new length of the property */
int ret; /* return value */
/*
* Parameters: Node path, property, optional value.
*/
if (argc < 4) {
printf ("Usage:\n%s\n", cmdtp->usage);
return 1;
}
pathp = argv[2];
prop = argv[3];
if (argc == 4) {
len = 0;
} else {
ret = fdt_parse_prop(&argv[4], argc - 4, data, &len);
if (ret != 0)
return ret;
}
nodeoffset = fdt_path_offset (working_fdt, pathp);
if (nodeoffset < 0) {
/*
* Not found or something else bad happened.
*/
printf ("libfdt fdt_path_offset() returned %s\n",
fdt_strerror(nodeoffset));
return 1;
}
ret = fdt_setprop(working_fdt, nodeoffset, prop, data, len);
if (ret < 0) {
printf ("libfdt fdt_setprop(): %s\n", fdt_strerror(ret));
return 1;
}
/********************************************************************
* Print (recursive) / List (single level)
********************************************************************/
} else if ((argv[1][0] == 'p') || (argv[1][0] == 'l')) {
int depth = MAX_LEVEL; /* how deep to print */
char *pathp; /* path */
char *prop; /* property */
int ret; /* return value */
static char root[2] = "/";
/*
* list is an alias for print, but limited to 1 level
*/
if (argv[1][0] == 'l') {
depth = 1;
}
/*
* Get the starting path. The root node is an oddball,
* the offset is zero and has no name.
*/
if (argc == 2)
pathp = root;
else
pathp = argv[2];
if (argc > 3)
prop = argv[3];
else
prop = NULL;
ret = fdt_print(pathp, prop, depth);
if (ret != 0)
return ret;
/********************************************************************
* Remove a property/node
********************************************************************/
} else if (strncmp(argv[1], "rm", 2) == 0) {
int nodeoffset; /* node offset from libfdt */
int err;
/*
* Get the path. The root node is an oddball, the offset
* is zero and has no name.
*/
nodeoffset = fdt_path_offset (working_fdt, argv[2]);
if (nodeoffset < 0) {
/*
* Not found or something else bad happened.
*/
printf ("libfdt fdt_path_offset() returned %s\n",
fdt_strerror(nodeoffset));
return 1;
}
/*
* Do the delete. A fourth parameter means delete a property,
* otherwise delete the node.
*/
if (argc > 3) {
err = fdt_delprop(working_fdt, nodeoffset, argv[3]);
if (err < 0) {
printf("libfdt fdt_delprop(): %s\n",
fdt_strerror(err));
return err;
}
} else {
err = fdt_del_node(working_fdt, nodeoffset);
if (err < 0) {
printf("libfdt fdt_del_node(): %s\n",
fdt_strerror(err));
return err;
}
}
/********************************************************************
* Display header info
********************************************************************/
} else if (argv[1][0] == 'h') {
u32 version = fdt_version(working_fdt);
printf("magic:\t\t\t0x%x\n", fdt_magic(working_fdt));
printf("totalsize:\t\t0x%x (%d)\n", fdt_totalsize(working_fdt),
fdt_totalsize(working_fdt));
printf("off_dt_struct:\t\t0x%x\n",
fdt_off_dt_struct(working_fdt));
printf("off_dt_strings:\t\t0x%x\n",
fdt_off_dt_strings(working_fdt));
printf("off_mem_rsvmap:\t\t0x%x\n",
fdt_off_mem_rsvmap(working_fdt));
printf("version:\t\t%d\n", version);
printf("last_comp_version:\t%d\n",
fdt_last_comp_version(working_fdt));
if (version >= 2)
printf("boot_cpuid_phys:\t0x%x\n",
fdt_boot_cpuid_phys(working_fdt));
if (version >= 3)
printf("size_dt_strings:\t0x%x\n",
fdt_size_dt_strings(working_fdt));
if (version >= 17)
printf("size_dt_struct:\t\t0x%x\n",
fdt_size_dt_struct(working_fdt));
printf("number mem_rsv:\t\t0x%x\n",
fdt_num_mem_rsv(working_fdt));
printf("\n");
/********************************************************************
* Set boot cpu id
********************************************************************/
} else if (strncmp(argv[1], "boo", 3) == 0) {
unsigned long tmp = simple_strtoul(argv[2], NULL, 16);
fdt_set_boot_cpuid_phys(working_fdt, tmp);
/********************************************************************
* memory command
********************************************************************/
} else if (strncmp(argv[1], "me", 2) == 0) {
uint64_t addr, size;
int err;
#ifdef CFG_64BIT_STRTOUL
addr = simple_strtoull(argv[2], NULL, 16);
size = simple_strtoull(argv[3], NULL, 16);
#else
addr = simple_strtoul(argv[2], NULL, 16);
size = simple_strtoul(argv[3], NULL, 16);
#endif
err = fdt_fixup_memory(working_fdt, addr, size);
if (err < 0)
return err;
/********************************************************************
* mem reserve commands
********************************************************************/
} else if (strncmp(argv[1], "rs", 2) == 0) {
if (argv[2][0] == 'p') {
uint64_t addr, size;
int total = fdt_num_mem_rsv(working_fdt);
int j, err;
printf("index\t\t start\t\t size\n");
printf("-------------------------------"
"-----------------\n");
for (j = 0; j < total; j++) {
err = fdt_get_mem_rsv(working_fdt, j, &addr, &size);
if (err < 0) {
printf("libfdt fdt_get_mem_rsv(): %s\n",
fdt_strerror(err));
return err;
}
printf(" %x\t%08x%08x\t%08x%08x\n", j,
(u32)(addr >> 32),
(u32)(addr & 0xffffffff),
(u32)(size >> 32),
(u32)(size & 0xffffffff));
}
} else if (argv[2][0] == 'a') {
/**
* display_fdt_by_regions() - Display regions of an FDT source
*
* This dumps an FDT as source, but only certain regions of it. This is the
* final stage of the grep - we have a list of regions we want to display,
* and this function displays them.
*
* @disp: Display structure, holding info about our options
* @blob: FDT blob to display
* @region: List of regions to display
* @count: Number of regions
*/
static int display_fdt_by_regions(struct display_info *disp, const void *blob,
struct fdt_region region[], int count)
{
struct fdt_region *reg = region, *reg_end = region + count;
uint32_t off_mem_rsvmap = fdt_off_mem_rsvmap(blob);
int base = fdt_off_dt_struct(blob);
int version = fdt_version(blob);
int offset, nextoffset;
int tag, depth, shift;
FILE *f = disp->fout;
uint64_t addr, size;
int in_region;
int file_ofs;
int i;
if (disp->show_dts_version)
fprintf(f, "/dts-v1/;\n");
if (disp->header) {
fprintf(f, "// magic:\t\t0x%x\n", fdt_magic(blob));
fprintf(f, "// totalsize:\t\t0x%x (%d)\n", fdt_totalsize(blob),
fdt_totalsize(blob));
fprintf(f, "// off_dt_struct:\t0x%x\n",
fdt_off_dt_struct(blob));
fprintf(f, "// off_dt_strings:\t0x%x\n",
fdt_off_dt_strings(blob));
fprintf(f, "// off_mem_rsvmap:\t0x%x\n", off_mem_rsvmap);
fprintf(f, "// version:\t\t%d\n", version);
fprintf(f, "// last_comp_version:\t%d\n",
fdt_last_comp_version(blob));
if (version >= 2) {
fprintf(f, "// boot_cpuid_phys:\t0x%x\n",
fdt_boot_cpuid_phys(blob));
}
if (version >= 3) {
fprintf(f, "// size_dt_strings:\t0x%x\n",
fdt_size_dt_strings(blob));
}
if (version >= 17) {
fprintf(f, "// size_dt_struct:\t0x%x\n",
fdt_size_dt_struct(blob));
}
fprintf(f, "\n");
}
if (disp->flags & FDT_REG_ADD_MEM_RSVMAP) {
const struct fdt_reserve_entry *p_rsvmap;
p_rsvmap = (const struct fdt_reserve_entry *)
((const char *)blob + off_mem_rsvmap);
for (i = 0; ; i++) {
addr = fdt64_to_cpu(p_rsvmap[i].address);
size = fdt64_to_cpu(p_rsvmap[i].size);
if (addr == 0 && size == 0)
break;
fprintf(f, "/memreserve/ %llx %llx;\n",
(unsigned long long)addr,
(unsigned long long)size);
}
}
depth = 0;
nextoffset = 0;
shift = 4; /* 4 spaces per indent */
do {
const struct fdt_property *prop;
const char *name;
int show;
int len;
offset = nextoffset;
/*
* Work out the file offset of this offset, and decide
* whether it is in the region list or not
*/
file_ofs = base + offset;
if (reg < reg_end && file_ofs >= reg->offset + reg->size)
reg++;
in_region = reg < reg_end && file_ofs >= reg->offset &&
file_ofs < reg->offset + reg->size;
tag = fdt_next_tag(blob, offset, &nextoffset);
if (tag == FDT_END)
break;
show = in_region || disp->all;
if (show && disp->diff)
fprintf(f, "%c", in_region ? '+' : '-');
if (!show) {
/* Do this here to avoid 'if (show)' in every 'case' */
if (tag == FDT_BEGIN_NODE)
depth++;
else if (tag == FDT_END_NODE)
depth--;
continue;
}
if (tag != FDT_END) {
if (disp->show_addr)
fprintf(f, "%4x: ", file_ofs);
if (disp->show_offset)
fprintf(f, "%4x: ", file_ofs - base);
}
/* Green means included, red means excluded */
if (disp->colour)
print_ansi_colour(f, in_region ? COL_GREEN : COL_RED);
switch (tag) {
case FDT_PROP:
prop = fdt_get_property_by_offset(blob, offset, NULL);
name = fdt_string(blob, fdt32_to_cpu(prop->nameoff));
fprintf(f, "%*s%s", depth * shift, "", name);
utilfdt_print_data(prop->data,
fdt32_to_cpu(prop->len));
fprintf(f, ";");
break;
case FDT_NOP:
fprintf(f, "%*s// [NOP]", depth * shift, "");
break;
case FDT_BEGIN_NODE:
name = fdt_get_name(blob, offset, &len);
fprintf(f, "%*s%s {", depth++ * shift, "",
*name ? name : "/");
break;
case FDT_END_NODE:
fprintf(f, "%*s};", --depth * shift, "");
break;
}
/* Reset colour back to normal before end of line */
if (disp->colour)
print_ansi_colour(f, COL_NONE);
fprintf(f, "\n");
} while (1);
/* Print a list of strings if requested */
if (disp->list_strings) {
const char *str;
int str_base = fdt_off_dt_strings(blob);
for (offset = 0; offset < fdt_size_dt_strings(blob);
offset += strlen(str) + 1) {
str = fdt_string(blob, offset);
int len = strlen(str) + 1;
int show;
/* Only print strings that are in the region */
file_ofs = str_base + offset;
in_region = reg < reg_end &&
file_ofs >= reg->offset &&
file_ofs + len < reg->offset +
reg->size;
show = in_region || disp->all;
if (show && disp->diff)
printf("%c", in_region ? '+' : '-');
if (disp->show_addr)
printf("%4x: ", file_ofs);
if (disp->show_offset)
printf("%4x: ", offset);
printf("%s\n", str);
}
}
return 0;
}
/**
* build_tree() - Build a tree
*
* @fdt: Pointer to place to put tree, assumed to be large enough
* @flags: Flags to control the tree creation (FDT_REG_...)
* @space: Amount of space to create for later tree additions
*
* This creates a tree modelled on a U-Boot FIT image, with various nodes
* and properties which are useful for testing the hashing features of
* fdt_find_regions().
*
* See h_include() below for a list of the nodes we later search for.
*/
static void build_tree(void *fdt, int flags, int space)
{
int direct_subnodes = flags & FDT_REG_DIRECT_SUBNODES;
int all_subnodes = flags & FDT_REG_ALL_SUBNODES;
int supernodes = flags & FDT_REG_SUPERNODES;
int either = !all_subnodes && (direct_subnodes || supernodes);
int err;
CHECK(fdt_create(fdt, SPACE));
CHECK(fdt_add_reservemap_entry(fdt, TEST_ADDR_1, TEST_SIZE_1));
CHECK(fdt_add_reservemap_entry(fdt, TEST_ADDR_2, TEST_SIZE_2));
CHECK(fdt_finish_reservemap(fdt));
/*
* This is the start of a new region because in the fdt_xxx_region()
* call, we pass "/" as one of the nodes to find.
*/
start(fdt); /* region 0 */
CHECK(fdt_begin_node(fdt, ""));
CHECK(fdt_property_string(fdt, "description", "kernel image"));
CHECK(fdt_property_u32(fdt, "#address-cells", 1));
/* /images */
if (!either && !all_subnodes)
stop(fdt);
CHECK(fdt_begin_node(fdt, "images"));
if (either)
stop(fdt);
CHECK(fdt_property_u32(fdt, "image-prop", 1));
/* /images/kernel@1 */
if (!all_subnodes)
start(fdt); /* region 1 */
CHECK(fdt_begin_node(fdt, "kernel@1"));
CHECK(fdt_property_string(fdt, "description", "exynos kernel"));
stop(fdt);
CHECK(fdt_property_string(fdt, "data", "this is the kernel image"));
start(fdt); /* region 2 */
/* /images/kernel/hash@1 */
CHECK(fdt_begin_node(fdt, "hash@1"));
CHECK(fdt_property_string(fdt, "algo", "sha1"));
CHECK(fdt_end_node(fdt));
/* /images/kernel/hash@2 */
if (!direct_subnodes)
stop(fdt);
CHECK(fdt_begin_node(fdt, "hash@2"));
if (direct_subnodes)
stop(fdt);
CHECK(fdt_property_string(fdt, "algo", "sha1"));
if (direct_subnodes)
start(fdt); /* region 3 */
CHECK(fdt_end_node(fdt));
if (!direct_subnodes)
start(fdt); /* region 3 */
CHECK(fdt_end_node(fdt));
/* /images/fdt@1 */
CHECK(fdt_begin_node(fdt, "fdt@1"));
CHECK(fdt_property_string(fdt, "description", "snow FDT"));
if (!all_subnodes)
stop(fdt);
CHECK(fdt_property_string(fdt, "data", "FDT data"));
if (!all_subnodes)
start(fdt); /* region 4 */
/* /images/kernel/hash@1 */
CHECK(fdt_begin_node(fdt, "hash@1"));
CHECK(fdt_property_string(fdt, "algo", "sha1"));
CHECK(fdt_end_node(fdt));
CHECK(fdt_end_node(fdt));
if (!either && !all_subnodes)
stop(fdt);
CHECK(fdt_end_node(fdt));
/* /configurations */
CHECK(fdt_begin_node(fdt, "configurations"));
if (either)
stop(fdt);
CHECK(fdt_property_string(fdt, "default", "conf@1"));
/* /configurations/conf@1 */
if (!all_subnodes)
start(fdt); /* region 6 */
CHECK(fdt_begin_node(fdt, "conf@1"));
CHECK(fdt_property_string(fdt, "kernel", "kernel@1"));
CHECK(fdt_property_string(fdt, "fdt", "fdt@1"));
CHECK(fdt_end_node(fdt));
if (!all_subnodes)
stop(fdt);
/* /configurations/conf@2 */
CHECK(fdt_begin_node(fdt, "conf@2"));
CHECK(fdt_property_string(fdt, "kernel", "kernel@1"));
CHECK(fdt_property_string(fdt, "fdt", "fdt@2"));
CHECK(fdt_end_node(fdt));
if (either)
start(fdt); /* region 7 */
CHECK(fdt_end_node(fdt));
if (!either && !all_subnodes)
start(fdt); /* region 7 */
CHECK(fdt_end_node(fdt));
CHECK(fdt_finish(fdt));
stop(fdt);
/* Add in the strings */
if (flags & FDT_REG_ADD_STRING_TAB) {
expect[expect_count].offset = fdt_off_dt_strings(fdt);
expect[expect_count].size = fdt_size_dt_strings(fdt);
expect_count++;
}
/* Make a bit of space */
if (space)
CHECK(fdt_open_into(fdt, fdt, fdt_totalsize(fdt) + space));
verbose_printf("Completed tree, totalsize = %d\n", fdt_totalsize(fdt));
}
int fdt_find_regions(const void *fdt, char * const inc[], int inc_count,
char * const exc_prop[], int exc_prop_count,
struct fdt_region region[], int max_regions,
char *path, int path_len, int add_string_tab)
{
int stack[FDT_MAX_DEPTH];
char *end;
int nextoffset = 0;
uint32_t tag;
int count = 0;
int start = -1;
int depth = -1;
int want = 0;
int base = fdt_off_dt_struct(fdt);
end = path;
*end = '\0';
do {
const struct fdt_property *prop;
const char *name;
const char *str;
int include = 0;
int stop_at = 0;
int offset;
int len;
offset = nextoffset;
tag = fdt_next_tag(fdt, offset, &nextoffset);
stop_at = nextoffset;
switch (tag) {
case FDT_PROP:
include = want >= 2;
stop_at = offset;
prop = fdt_get_property_by_offset(fdt, offset, NULL);
str = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
if (str_in_list(str, exc_prop, exc_prop_count))
include = 0;
break;
case FDT_NOP:
include = want >= 2;
stop_at = offset;
break;
case FDT_BEGIN_NODE:
depth++;
if (depth == FDT_MAX_DEPTH)
return -FDT_ERR_BADSTRUCTURE;
name = fdt_get_name(fdt, offset, &len);
if (end - path + 2 + len >= path_len)
return -FDT_ERR_NOSPACE;
if (end != path + 1)
*end++ = '/';
strcpy(end, name);
end += len;
stack[depth] = want;
if (want == 1)
stop_at = offset;
if (str_in_list(path, inc, inc_count))
want = 2;
else if (want)
want--;
else
stop_at = offset;
include = want;
break;
case FDT_END_NODE:
include = want;
want = stack[depth--];
while (end > path && *--end != '/')
;
*end = '\0';
break;
case FDT_END:
include = 1;
break;
}
if (include && start == -1) {
/* Should we merge with previous? */
if (count && count <= max_regions &&
offset == region[count - 1].offset +
region[count - 1].size - base)
start = region[--count].offset - base;
else
start = offset;
}
if (!include && start != -1) {
if (count < max_regions) {
region[count].offset = base + start;
region[count].size = stop_at - start;
}
count++;
start = -1;
}
} while (tag != FDT_END);
if (nextoffset != fdt_size_dt_struct(fdt))
return -FDT_ERR_BADLAYOUT;
/* Add a region for the END tag and the string table */
if (count < max_regions) {
region[count].offset = base + start;
region[count].size = nextoffset - start;
if (add_string_tab)
region[count].size += fdt_size_dt_strings(fdt);
}
count++;
return count;
}