kernel
/
dtc
mirror of https://git.kernel.org/pub/scm/utils/dtc/dtc.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

libfdt: Add and use a node iteration helper function. 

This patch adds an fdt_next_node() function which can be used to
iterate through nodes of the tree while keeping track of depth.  This
function is used to simplify the iteration code in a lot of other
functions, and is also exported for use by library users.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
main
David Gibson 17 years ago committed by Jon Loeliger
parent
202863e4dd
commit
fc9769ac2b
3 changed files with 131 additions and 174 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 41
      libfdt/fdt.c
  2. 258
      libfdt/fdt_ro.c
  3. 6
      libfdt/libfdt.h

41
libfdt/fdt.c
Unescape View File

@ -129,6 +129,47 @@ uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset)
return tag; return tag;
} }


int fdt_next_node(const void *fdt, int offset, int *depth)
{
int nextoffset = 0;
uint32_t tag;

if (offset >= 0) {
tag = fdt_next_tag(fdt, offset, &nextoffset);
if (tag != FDT_BEGIN_NODE)
return -FDT_ERR_BADOFFSET;
}

do {
offset = nextoffset;
tag = fdt_next_tag(fdt, offset, &nextoffset);

switch (tag) {
case FDT_PROP:
case FDT_NOP:
break;

case FDT_BEGIN_NODE:
if (depth)
(*depth)++;
break;

case FDT_END_NODE:
if (depth)
(*depth)--;
break;

case FDT_END:
return -FDT_ERR_NOTFOUND;

default:
return -FDT_ERR_BADSTRUCTURE;
}
} while (tag != FDT_BEGIN_NODE);

return offset;
}

const char *_fdt_find_string(const char *strtab, int tabsize, const char *s) const char *_fdt_find_string(const char *strtab, int tabsize, const char *s)
{ {
int len = strlen(s) + 1; int len = strlen(s) + 1;

258
libfdt/fdt_ro.c
Unescape View File

@ -65,7 +65,7 @@
static int nodename_eq(const void *fdt, int offset, static int nodename_eq(const void *fdt, int offset,
const char *s, int len) const char *s, int len)
{ {
const char *p = fdt_offset_ptr(fdt, offset, len+1); const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1);


if (! p) if (! p)
/* short match */ /* short match */
@ -104,50 +104,24 @@ int fdt_num_mem_rsv(const void *fdt)
return i; return i;
} }


int fdt_subnode_offset_namelen(const void *fdt, int parentoffset, int fdt_subnode_offset_namelen(const void *fdt, int offset,
const char *name, int namelen) const char *name, int namelen)
{ {
int level = 0; int depth;
uint32_t tag;
int offset, nextoffset;


CHECK_HEADER(fdt); CHECK_HEADER(fdt);


tag = fdt_next_tag(fdt, parentoffset, &nextoffset); for (depth = 0;
if (tag != FDT_BEGIN_NODE) offset >= 0;
return -FDT_ERR_BADOFFSET; offset = fdt_next_node(fdt, offset, &depth)) {

if (depth < 0)
do { return -FDT_ERR_NOTFOUND;
offset = nextoffset; else if ((depth == 1)
tag = fdt_next_tag(fdt, offset, &nextoffset); && nodename_eq(fdt, offset, name, namelen))

return offset;
switch (tag) { }
case FDT_END:
return -FDT_ERR_TRUNCATED;

case FDT_BEGIN_NODE:
level++;
if (level != 1)
continue;
if (nodename_eq(fdt, offset+FDT_TAGSIZE, name, namelen))
/* Found it! */
return offset;
break;

case FDT_END_NODE:
level--;
break;

case FDT_PROP:
case FDT_NOP:
break;

default:
return -FDT_ERR_BADSTRUCTURE;
}
} while (level >= 0);


return -FDT_ERR_NOTFOUND; return offset; /* error */
} }


int fdt_subnode_offset(const void *fdt, int parentoffset, int fdt_subnode_offset(const void *fdt, int parentoffset,
@ -307,76 +281,61 @@ uint32_t fdt_get_phandle(const void *fdt, int nodeoffset)


int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen) int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
{ {
uint32_t tag; int pdepth = 0, p = 0;
int p = 0, overflow = 0; int offset, depth, namelen;
int offset, nextoffset, namelen;
const char *name; const char *name;


CHECK_HEADER(fdt); CHECK_HEADER(fdt);


tag = fdt_next_tag(fdt, 0, &nextoffset);
if (tag != FDT_BEGIN_NODE)
return -FDT_ERR_BADSTRUCTURE;

if (buflen < 2) if (buflen < 2)
return -FDT_ERR_NOSPACE; return -FDT_ERR_NOSPACE;
buf[0] = '/';
p = 1;


while (nextoffset <= nodeoffset) { for (offset = 0, depth = 0;
offset = nextoffset; (offset >= 0) && (offset <= nodeoffset);
tag = fdt_next_tag(fdt, offset, &nextoffset); offset = fdt_next_node(fdt, offset, &depth)) {
switch (tag) { if (pdepth < depth)
case FDT_END: continue; /* overflowed buffer */
return -FDT_ERR_BADOFFSET;


case FDT_BEGIN_NODE: while (pdepth > depth) {
name = fdt_get_name(fdt, offset, &namelen); do {
if (!name) p--;
return namelen; } while (buf[p-1] != '/');
if (overflow || ((p + namelen + 1) > buflen)) { pdepth--;
overflow++; }
break;
} name = fdt_get_name(fdt, offset, &namelen);
if (!name)
return namelen;
if ((p + namelen + 1) <= buflen) {
memcpy(buf + p, name, namelen); memcpy(buf + p, name, namelen);
p += namelen; p += namelen;
buf[p++] = '/'; buf[p++] = '/';
break; pdepth++;

}
case FDT_END_NODE:
if (overflow) {
overflow--;
break;
}
do {
p--;
} while (buf[p-1] != '/');
break;


case FDT_PROP: if (offset == nodeoffset) {
case FDT_NOP: if (pdepth < (depth + 1))
break; return -FDT_ERR_NOSPACE;


default: if (p > 1) /* special case so that root path is "/", not "" */
return -FDT_ERR_BADSTRUCTURE; p--;
buf[p] = '\0';
return p;
} }
} }


if (overflow) if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
return -FDT_ERR_NOSPACE; return -FDT_ERR_BADOFFSET;
else if (offset == -FDT_ERR_BADOFFSET)
return -FDT_ERR_BADSTRUCTURE;


if (p > 1) /* special case so that root path is "/", not "" */ return offset; /* error from fdt_next_node() */
p--;
buf[p] = '\0';
return p;
} }


int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset, int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
int supernodedepth, int *nodedepth) int supernodedepth, int *nodedepth)
{ {
int level = -1; int offset, depth;
uint32_t tag;
int offset, nextoffset = 0;
int supernodeoffset = -FDT_ERR_INTERNAL; int supernodeoffset = -FDT_ERR_INTERNAL;


CHECK_HEADER(fdt); CHECK_HEADER(fdt);
@ -384,38 +343,29 @@ int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
if (supernodedepth < 0) if (supernodedepth < 0)
return -FDT_ERR_NOTFOUND; return -FDT_ERR_NOTFOUND;


do { for (offset = 0, depth = 0;
offset = nextoffset; (offset >= 0) && (offset <= nodeoffset);
tag = fdt_next_tag(fdt, offset, &nextoffset); offset = fdt_next_node(fdt, offset, &depth)) {
switch (tag) { if (depth == supernodedepth)
case FDT_END: supernodeoffset = offset;
return -FDT_ERR_BADOFFSET;

case FDT_BEGIN_NODE:
level++;
if (level == supernodedepth)
supernodeoffset = offset;
break;

case FDT_END_NODE:
level--;
break;


case FDT_PROP: if (offset == nodeoffset) {
case FDT_NOP: if (nodedepth)
break; *nodedepth = depth;


default: if (supernodedepth > depth)
return -FDT_ERR_BADSTRUCTURE; return -FDT_ERR_NOTFOUND;
else
return supernodeoffset;
} }
} while (offset < nodeoffset); }


if (nodedepth) if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
*nodedepth = level; return -FDT_ERR_BADOFFSET;
else if (offset == -FDT_ERR_BADOFFSET)
return -FDT_ERR_BADSTRUCTURE;


if (supernodedepth > level) return offset; /* error from fdt_next_node() */
return -FDT_ERR_NOTFOUND;
return supernodeoffset;
} }


int fdt_node_depth(const void *fdt, int nodeoffset) int fdt_node_depth(const void *fdt, int nodeoffset)
@ -443,51 +393,27 @@ int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
const char *propname, const char *propname,
const void *propval, int proplen) const void *propval, int proplen)
{ {
uint32_t tag; int offset;
int offset, nextoffset;
const void *val; const void *val;
int len; int len;


CHECK_HEADER(fdt); CHECK_HEADER(fdt);


if (startoffset >= 0) {
tag = fdt_next_tag(fdt, startoffset, &nextoffset);
if (tag != FDT_BEGIN_NODE)
return -FDT_ERR_BADOFFSET;
} else {
nextoffset = 0;
}

/* FIXME: The algorithm here is pretty horrible: we scan each /* FIXME: The algorithm here is pretty horrible: we scan each
* property of a node in fdt_getprop(), then if that didn't * property of a node in fdt_getprop(), then if that didn't
* find what we want, we scan over them again making our way * find what we want, we scan over them again making our way
* to the next node. Still it's the easiest to implement * to the next node. Still it's the easiest to implement
* approach; performance can come later. */ * approach; performance can come later. */
do { for (offset = fdt_next_node(fdt, startoffset, NULL);
offset = nextoffset; offset >= 0;
tag = fdt_next_tag(fdt, offset, &nextoffset); offset = fdt_next_node(fdt, offset, NULL)) {

val = fdt_getprop(fdt, offset, propname, &len);
switch (tag) { if (val && (len == proplen)
case FDT_BEGIN_NODE: && (memcmp(val, propval, len) == 0))
val = fdt_getprop(fdt, offset, propname, &len); return offset;
if (val }
&& (len == proplen)
&& (memcmp(val, propval, len) == 0))
return offset;
break;

case FDT_PROP:
case FDT_END:
case FDT_END_NODE:
case FDT_NOP:
break;

default:
return -FDT_ERR_BADSTRUCTURE;
}
} while (tag != FDT_END);


return -FDT_ERR_NOTFOUND; return offset; /* error from fdt_next_node() */
} }


int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle) int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)
@ -553,31 +479,15 @@ int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
* that didn't find what we want, we scan over them again * that didn't find what we want, we scan over them again
* making our way to the next node. Still it's the easiest to * making our way to the next node. Still it's the easiest to
* implement approach; performance can come later. */ * implement approach; performance can come later. */
do { for (offset = fdt_next_node(fdt, startoffset, NULL);
offset = nextoffset; offset >= 0;
tag = fdt_next_tag(fdt, offset, &nextoffset); offset = fdt_next_node(fdt, offset, NULL)) {

err = fdt_node_check_compatible(fdt, offset, compatible);
switch (tag) { if ((err < 0) && (err != -FDT_ERR_NOTFOUND))
case FDT_BEGIN_NODE: return err;
err = fdt_node_check_compatible(fdt, offset, else if (err == 0)
compatible); return offset;
if ((err < 0) }
&& (err != -FDT_ERR_NOTFOUND))
return err;
else if (err == 0)
return offset;
break;

case FDT_PROP:
case FDT_END:
case FDT_END_NODE:
case FDT_NOP:
break;

default:
return -FDT_ERR_BADSTRUCTURE;
}
} while (tag != FDT_END);


return -FDT_ERR_NOTFOUND; return offset; /* error from fdt_next_node() */
} }

6
libfdt/libfdt.h
Unescape View File

@ -130,6 +130,12 @@ static inline void *fdt_offset_ptr_w(void *fdt, int offset, int checklen)


uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset); uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset);


/**********************************************************************/
/* Traversal functions */
/**********************************************************************/

int fdt_next_node(const void *fdt, int offset, int *depth);

/**********************************************************************/ /**********************************************************************/
/* General functions */ /* General functions */
/**********************************************************************/ /**********************************************************************/

Write Preview
Loading…
Cancel
Save