upstream u-boot with additional patches for our devices/boards: https://lists.denx.de/pipermail/u-boot/2017-March/282789.html (AXP crashes) ; Gbit ethernet patch for some LIME2 revisions ; with SPI flash support
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 
u-boot/libfdt/fdt_ro.c

402 lines
8.3 KiB

/*
* libfdt - Flat Device Tree manipulation
* Copyright (C) 2006 David Gibson, IBM Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libfdt_env.h"
#include <fdt.h>
#include <libfdt.h>
#include "libfdt_internal.h"
#define CHECK_HEADER(fdt) { \
int err; \
if ((err = fdt_check_header(fdt)) != 0) \
return err; \
}
static int offset_streq(const void *fdt, int offset,
const char *s, int len)
{
const char *p = fdt_offset_ptr(fdt, offset, len+1);
if (! p)
/* short match */
return 0;
if (memcmp(p, s, len) != 0)
return 0;
if (p[len] != '\0')
return 0;
return 1;
}
/*
* Return a pointer to the string at the given string offset.
*/
char *fdt_string(const void *fdt, int stroffset)
{
return (char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
}
/*
* Return the node offset of the node specified by:
* parentoffset - starting place (0 to start at the root)
* name - name being searched for
* namelen - length of the name: typically strlen(name)
*
* Notes:
* If the start node has subnodes, the subnodes are _not_ searched for the
* requested name.
*/
int fdt_subnode_offset_namelen(const void *fdt, int parentoffset,
const char *name, int namelen)
{
int level = 0;
uint32_t tag;
int offset, nextoffset;
CHECK_HEADER(fdt);
tag = fdt_next_tag(fdt, parentoffset, &nextoffset, NULL);
if (tag != FDT_BEGIN_NODE)
return -FDT_ERR_BADOFFSET;
do {
offset = nextoffset;
tag = fdt_next_tag(fdt, offset, &nextoffset, NULL);
switch (tag) {
case FDT_END:
return -FDT_ERR_TRUNCATED;
case FDT_BEGIN_NODE:
level++;
/*
* If we are nested down levels, ignore the strings
* until we get back to the proper level.
*/
if (level != 1)
continue;
/* Return the offset if this is "our" string. */
if (offset_streq(fdt, offset+FDT_TAGSIZE, name, namelen))
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;
}
/*
* See fdt_subnode_offset_namelen()
*/
int fdt_subnode_offset(const void *fdt, int parentoffset,
const char *name)
{
return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name));
}
/*
* Searches for the node corresponding to the given path and returns the
* offset of that node.
*/
int fdt_path_offset(const void *fdt, const char *path)
{
const char *end = path + strlen(path);
const char *p = path;
int offset = 0;
CHECK_HEADER(fdt);
/* Paths must be absolute */
if (*path != '/')
return -FDT_ERR_BADPATH;
while (*p) {
const char *q;
/* Skip path separator(s) */
while (*p == '/')
p++;
if (! *p)
return -FDT_ERR_BADPATH;
/*
* Find the next path separator. The characters between
* p and q are the next segment of the the path to find.
*/
q = strchr(p, '/');
if (! q)
q = end;
/*
* Find the offset corresponding to the this path segment.
*/
offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
/* Oops, error, abort abort abort */
if (offset < 0)
return offset;
p = q;
}
return offset;
}
/*
* Given the offset of a node and a name of a property in that node, return
* a pointer to the property struct.
*/
struct fdt_property *fdt_get_property(const void *fdt,
int nodeoffset,
const char *name, int *lenp)
{
int level = 0;
uint32_t tag;
struct fdt_property *prop;
int namestroff;
int offset, nextoffset;
int err;
if ((err = fdt_check_header(fdt)) != 0)
goto fail;
err = -FDT_ERR_BADOFFSET;
if (nodeoffset % FDT_TAGSIZE)
goto fail;
tag = fdt_next_tag(fdt, nodeoffset, &nextoffset, NULL);
if (tag != FDT_BEGIN_NODE)
goto fail;
do {
offset = nextoffset;
tag = fdt_next_tag(fdt, offset, &nextoffset, NULL);
switch (tag) {
case FDT_END:
err = -FDT_ERR_TRUNCATED;
goto fail;
case FDT_BEGIN_NODE:
level++;
break;
case FDT_END_NODE:
level--;
break;
case FDT_PROP:
/*
* If we are nested down levels, ignore the strings
* until we get back to the proper level.
*/
if (level != 0)
continue;
err = -FDT_ERR_BADSTRUCTURE;
prop = fdt_offset_ptr_typed(fdt, offset, prop);
if (! prop)
goto fail;
namestroff = fdt32_to_cpu(prop->nameoff);
if (streq(fdt_string(fdt, namestroff), name)) {
/* Found it! */
int len = fdt32_to_cpu(prop->len);
prop = fdt_offset_ptr(fdt, offset,
sizeof(*prop)+len);
if (! prop)
goto fail;
if (lenp)
*lenp = len;
return prop;
}
break;
case FDT_NOP:
break;
default:
err = -FDT_ERR_BADSTRUCTURE;
goto fail;
}
} while (level >= 0);
err = -FDT_ERR_NOTFOUND;
fail:
if (lenp)
*lenp = err;
return NULL;
}
/*
* Given the offset of a node and a name of a property in that node, return
* a pointer to the property data (ONLY).
*/
void *fdt_getprop(const void *fdt, int nodeoffset,
const char *name, int *lenp)
{
const struct fdt_property *prop;
prop = fdt_get_property(fdt, nodeoffset, name, lenp);
if (! prop)
return NULL;
return (void *)prop->data;
}
uint32_t fdt_next_tag(const void *fdt, int offset, int *nextoffset, char **namep)
{
const uint32_t *tagp, *lenp;
uint32_t tag;
const char *p;
if (offset % FDT_TAGSIZE)
return -1;
tagp = fdt_offset_ptr(fdt, offset, FDT_TAGSIZE);
if (! tagp)
return FDT_END; /* premature end */
tag = fdt32_to_cpu(*tagp);
offset += FDT_TAGSIZE;
switch (tag) {
case FDT_BEGIN_NODE:
if(namep)
*namep = fdt_offset_ptr(fdt, offset, 1);
/* skip name */
do {
p = fdt_offset_ptr(fdt, offset++, 1);
} while (p && (*p != '\0'));
if (! p)
return FDT_END;
break;
case FDT_PROP:
lenp = fdt_offset_ptr(fdt, offset, sizeof(*lenp));
if (! lenp)
return FDT_END;
/*
* Get the property and set the namep to the name.
*/
if(namep) {
struct fdt_property *prop;
prop = fdt_offset_ptr_typed(fdt, offset - FDT_TAGSIZE, prop);
if (! prop)
return -FDT_ERR_BADSTRUCTURE;
*namep = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
}
/* skip name offset, length and value */
offset += 2*FDT_TAGSIZE + fdt32_to_cpu(*lenp);
break;
}
if (nextoffset)
*nextoffset = ALIGN(offset, FDT_TAGSIZE);
return tag;
}
/*
* Return the number of used reserve map entries and total slots available.
*/
int fdt_num_reservemap(void *fdt, int *used, int *total)
{
struct fdt_reserve_entry *re;
int start;
int end;
int err = fdt_check_header(fdt);
if (err != 0)
return err;
start = fdt_off_mem_rsvmap(fdt);
/*
* Convention is that the reserve map is before the dt_struct,
* but it does not have to be.
*/
end = fdt_totalsize(fdt);
if (end > fdt_off_dt_struct(fdt))
end = fdt_off_dt_struct(fdt);
if (end > fdt_off_dt_strings(fdt))
end = fdt_off_dt_strings(fdt);
/*
* Since the reserved area list is zero terminated, you get one fewer.
*/
if (total)
*total = ((end - start) / sizeof(struct fdt_reserve_entry)) - 1;
if (used) {
*used = 0;
while (start < end) {
re = (struct fdt_reserve_entry *)(fdt + start);
if (re->size == 0)
return 0; /* zero size terminates the list */
*used += 1;
start += sizeof(struct fdt_reserve_entry);
}
/*
* If we get here, there was no zero size termination.
*/
return -FDT_ERR_BADLAYOUT;
}
return 0;
}
/*
* Return the nth reserve map entry.
*/
int fdt_get_reservemap(void *fdt, int n, struct fdt_reserve_entry *re)
{
int used;
int total;
int err;
err = fdt_num_reservemap(fdt, &used, &total);
if (err != 0)
return err;
if (n >= total)
return -FDT_ERR_NOSPACE;
if (re) {
*re = *(struct fdt_reserve_entry *)
_fdt_offset_ptr(fdt, n * sizeof(struct fdt_reserve_entry));
}
return 0;
}