| /* |
| * libfdt - Flat Device Tree manipulation |
| * Copyright (C) 2006 David Gibson, IBM Corporation. |
| * |
| * libfdt is dual licensed: you can use it either under the terms of |
| * the GPL, or the BSD license, at your option. |
| * |
| * a) This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License as |
| * published by the Free Software Foundation; either version 2 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 General Public License for more details. |
| * |
| * You should have received a copy of the GNU 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 |
| * |
| * Alternatively, |
| * |
| * b) Redistribution and use in source and binary forms, with or |
| * without modification, are permitted provided that the following |
| * conditions are met: |
| * |
| * 1. Redistributions of source code must retain the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer. |
| * 2. Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include "libfdt_env.h" |
| |
| #ifndef USE_HOSTCC |
| #include <fdt.h> |
| #include <libfdt.h> |
| #else |
| #include "fdt_host.h" |
| #endif |
| |
| #include "libfdt_internal.h" |
| |
| static int _fdt_nodename_eq(const void *fdt, int offset, |
| const char *s, int len) |
| { |
| const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1); |
| |
| if (! p) |
| /* short match */ |
| return 0; |
| |
| if (memcmp(p, s, len) != 0) |
| return 0; |
| |
| if (p[len] == '\0') |
| return 1; |
| else if (!memchr(s, '@', len) && (p[len] == '@')) |
| return 1; |
| else |
| return 0; |
| } |
| |
| const char *fdt_string(const void *fdt, int stroffset) |
| { |
| return (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset; |
| } |
| |
| int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size) |
| { |
| FDT_CHECK_HEADER(fdt); |
| *address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address); |
| *size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size); |
| return 0; |
| } |
| |
| int fdt_num_mem_rsv(const void *fdt) |
| { |
| int i = 0; |
| |
| while (fdt64_to_cpu(_fdt_mem_rsv(fdt, i)->size) != 0) |
| i++; |
| return i; |
| } |
| |
| int fdt_subnode_offset_namelen(const void *fdt, int offset, |
| const char *name, int namelen) |
| { |
| int depth; |
| |
| FDT_CHECK_HEADER(fdt); |
| |
| for (depth = 0; |
| offset >= 0; |
| offset = fdt_next_node(fdt, offset, &depth)) { |
| if (depth < 0) |
| return -FDT_ERR_NOTFOUND; |
| else if ((depth == 1) |
| && _fdt_nodename_eq(fdt, offset, name, namelen)) |
| return offset; |
| } |
| |
| return offset; /* error */ |
| } |
| |
| int fdt_subnode_offset(const void *fdt, int parentoffset, |
| const char *name) |
| { |
| return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name)); |
| } |
| |
| int fdt_path_offset(const void *fdt, const char *path) |
| { |
| const char *end = path + strlen(path); |
| const char *p = path; |
| int offset = 0; |
| |
| FDT_CHECK_HEADER(fdt); |
| |
| if (*path != '/') |
| return -FDT_ERR_BADPATH; |
| |
| while (*p) { |
| const char *q; |
| |
| while (*p == '/') |
| p++; |
| if (! *p) |
| return offset; |
| q = strchr(p, '/'); |
| if (! q) |
| q = end; |
| |
| offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p); |
| if (offset < 0) |
| return offset; |
| |
| p = q; |
| } |
| |
| return offset; |
| } |
| |
| const char *fdt_get_name(const void *fdt, int nodeoffset, int *len) |
| { |
| const struct fdt_node_header *nh = _fdt_offset_ptr(fdt, nodeoffset); |
| int err; |
| |
| if (((err = fdt_check_header(fdt)) != 0) |
| || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0)) |
| goto fail; |
| |
| if (len) |
| *len = strlen(nh->name); |
| |
| return nh->name; |
| |
| fail: |
| if (len) |
| *len = err; |
| return NULL; |
| } |
| |
| const struct fdt_property *fdt_get_property(const void *fdt, |
| int nodeoffset, |
| const char *name, int *lenp) |
| { |
| uint32_t tag; |
| const struct fdt_property *prop; |
| int namestroff; |
| int offset, nextoffset; |
| int err; |
| |
| if (((err = fdt_check_header(fdt)) != 0) |
| || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0)) |
| goto fail; |
| |
| nextoffset = err; |
| do { |
| offset = nextoffset; |
| |
| tag = fdt_next_tag(fdt, offset, &nextoffset); |
| switch (tag) { |
| case FDT_END: |
| err = -FDT_ERR_TRUNCATED; |
| goto fail; |
| |
| case FDT_BEGIN_NODE: |
| case FDT_END_NODE: |
| case FDT_NOP: |
| break; |
| |
| case FDT_PROP: |
| err = -FDT_ERR_BADSTRUCTURE; |
| prop = fdt_offset_ptr(fdt, offset, sizeof(*prop)); |
| if (! prop) |
| goto fail; |
| namestroff = fdt32_to_cpu(prop->nameoff); |
| if (strcmp(fdt_string(fdt, namestroff), name) == 0) { |
| /* 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; |
| |
| default: |
| err = -FDT_ERR_BADSTRUCTURE; |
| goto fail; |
| } |
| } while ((tag != FDT_BEGIN_NODE) && (tag != FDT_END_NODE)); |
| |
| err = -FDT_ERR_NOTFOUND; |
| fail: |
| if (lenp) |
| *lenp = err; |
| return NULL; |
| } |
| |
| const 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 prop->data; |
| } |
| |
| uint32_t fdt_get_phandle(const void *fdt, int nodeoffset) |
| { |
| const uint32_t *php; |
| int len; |
| |
| php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len); |
| if (!php || (len != sizeof(*php))) |
| return 0; |
| |
| return fdt32_to_cpu(*php); |
| } |
| |
| int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen) |
| { |
| int pdepth = 0, p = 0; |
| int offset, depth, namelen; |
| const char *name; |
| |
| FDT_CHECK_HEADER(fdt); |
| |
| if (buflen < 2) |
| return -FDT_ERR_NOSPACE; |
| |
| for (offset = 0, depth = 0; |
| (offset >= 0) && (offset <= nodeoffset); |
| offset = fdt_next_node(fdt, offset, &depth)) { |
| if (pdepth < depth) |
| continue; /* overflowed buffer */ |
| |
| while (pdepth > depth) { |
| do { |
| p--; |
| } while (buf[p-1] != '/'); |
| pdepth--; |
| } |
| |
| name = fdt_get_name(fdt, offset, &namelen); |
| if (!name) |
| return namelen; |
| if ((p + namelen + 1) <= buflen) { |
| memcpy(buf + p, name, namelen); |
| p += namelen; |
| buf[p++] = '/'; |
| pdepth++; |
| } |
| |
| if (offset == nodeoffset) { |
| if (pdepth < (depth + 1)) |
| return -FDT_ERR_NOSPACE; |
| |
| if (p > 1) /* special case so that root path is "/", not "" */ |
| p--; |
| buf[p] = '\0'; |
| return p; |
| } |
| } |
| |
| if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0)) |
| return -FDT_ERR_BADOFFSET; |
| else if (offset == -FDT_ERR_BADOFFSET) |
| return -FDT_ERR_BADSTRUCTURE; |
| |
| return offset; /* error from fdt_next_node() */ |
| } |
| |
| int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset, |
| int supernodedepth, int *nodedepth) |
| { |
| int offset, depth; |
| int supernodeoffset = -FDT_ERR_INTERNAL; |
| |
| FDT_CHECK_HEADER(fdt); |
| |
| if (supernodedepth < 0) |
| return -FDT_ERR_NOTFOUND; |
| |
| for (offset = 0, depth = 0; |
| (offset >= 0) && (offset <= nodeoffset); |
| offset = fdt_next_node(fdt, offset, &depth)) { |
| if (depth == supernodedepth) |
| supernodeoffset = offset; |
| |
| if (offset == nodeoffset) { |
| if (nodedepth) |
| *nodedepth = depth; |
| |
| if (supernodedepth > depth) |
| return -FDT_ERR_NOTFOUND; |
| else |
| return supernodeoffset; |
| } |
| } |
| |
| if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0)) |
| return -FDT_ERR_BADOFFSET; |
| else if (offset == -FDT_ERR_BADOFFSET) |
| return -FDT_ERR_BADSTRUCTURE; |
| |
| return offset; /* error from fdt_next_node() */ |
| } |
| |
| int fdt_node_depth(const void *fdt, int nodeoffset) |
| { |
| int nodedepth; |
| int err; |
| |
| err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth); |
| if (err) |
| return (err < 0) ? err : -FDT_ERR_INTERNAL; |
| return nodedepth; |
| } |
| |
| int fdt_parent_offset(const void *fdt, int nodeoffset) |
| { |
| int nodedepth = fdt_node_depth(fdt, nodeoffset); |
| |
| if (nodedepth < 0) |
| return nodedepth; |
| return fdt_supernode_atdepth_offset(fdt, nodeoffset, |
| nodedepth - 1, NULL); |
| } |
| |
| int fdt_node_offset_by_prop_value(const void *fdt, int startoffset, |
| const char *propname, |
| const void *propval, int proplen) |
| { |
| int offset; |
| const void *val; |
| int len; |
| |
| FDT_CHECK_HEADER(fdt); |
| |
| /* FIXME: The algorithm here is pretty horrible: we scan each |
| * property of a node in fdt_getprop(), then if 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 implement |
| * approach; performance can come later. */ |
| for (offset = fdt_next_node(fdt, startoffset, NULL); |
| offset >= 0; |
| offset = fdt_next_node(fdt, offset, NULL)) { |
| val = fdt_getprop(fdt, offset, propname, &len); |
| if (val && (len == proplen) |
| && (memcmp(val, propval, len) == 0)) |
| return offset; |
| } |
| |
| return offset; /* error from fdt_next_node() */ |
| } |
| |
| int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle) |
| { |
| if ((phandle == 0) || (phandle == -1)) |
| return -FDT_ERR_BADPHANDLE; |
| phandle = cpu_to_fdt32(phandle); |
| return fdt_node_offset_by_prop_value(fdt, -1, "linux,phandle", |
| &phandle, sizeof(phandle)); |
| } |
| |
| static int _fdt_stringlist_contains(const char *strlist, int listlen, |
| const char *str) |
| { |
| int len = strlen(str); |
| const char *p; |
| |
| while (listlen >= len) { |
| if (memcmp(str, strlist, len+1) == 0) |
| return 1; |
| p = memchr(strlist, '\0', listlen); |
| if (!p) |
| return 0; /* malformed strlist.. */ |
| listlen -= (p-strlist) + 1; |
| strlist = p + 1; |
| } |
| return 0; |
| } |
| |
| int fdt_node_check_compatible(const void *fdt, int nodeoffset, |
| const char *compatible) |
| { |
| const void *prop; |
| int len; |
| |
| prop = fdt_getprop(fdt, nodeoffset, "compatible", &len); |
| if (!prop) |
| return len; |
| if (_fdt_stringlist_contains(prop, len, compatible)) |
| return 0; |
| else |
| return 1; |
| } |
| |
| int fdt_node_offset_by_compatible(const void *fdt, int startoffset, |
| const char *compatible) |
| { |
| int offset, err; |
| |
| FDT_CHECK_HEADER(fdt); |
| |
| /* FIXME: The algorithm here is pretty horrible: we scan each |
| * property of a node in fdt_node_check_compatible(), then if |
| * 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 |
| * implement approach; performance can come later. */ |
| for (offset = fdt_next_node(fdt, startoffset, NULL); |
| offset >= 0; |
| offset = fdt_next_node(fdt, offset, NULL)) { |
| err = fdt_node_check_compatible(fdt, offset, compatible); |
| if ((err < 0) && (err != -FDT_ERR_NOTFOUND)) |
| return err; |
| else if (err == 0) |
| return offset; |
| } |
| |
| return offset; /* error from fdt_next_node() */ |
| } |