libfdt/fdt_ro.c

   1 /*
   2  * libfdt - Flat Device Tree manipulation
   3  * Copyright (C) 2006 David Gibson, IBM Corporation.
   4  *
   5  * libfdt is dual licensed: you can use it either under the terms of
   6  * the GPL, or the BSD license, at your option.
   7  *
   8  *  a) This library is free software; you can redistribute it and/or
   9  *     modify it under the terms of the GNU General Public License as
  10  *     published by the Free Software Foundation; either version 2 of the
  11  *     License, or (at your option) any later version.
  12  *
  13  *     This library is distributed in the hope that it will be useful,
  14  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *     GNU General Public License for more details.
  17  *
  18  *     You should have received a copy of the GNU General Public
  19  *     License along with this library; if not, write to the Free
  20  *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
  21  *     MA 02110-1301 USA
  22  *
  23  * Alternatively,
  24  *
  25  *  b) Redistribution and use in source and binary forms, with or
  26  *     without modification, are permitted provided that the following
  27  *     conditions are met:
  28  *
  29  *     1. Redistributions of source code must retain the above
  30  *        copyright notice, this list of conditions and the following
  31  *        disclaimer.
  32  *     2. Redistributions in binary form must reproduce the above
  33  *        copyright notice, this list of conditions and the following
  34  *        disclaimer in the documentation and/or other materials
  35  *        provided with the distribution.
  36  *
  37  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  38  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  39  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  40  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  41  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  42  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  43  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  44  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  45  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  46  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  47  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  48  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  49  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  50  */
  51 #include "libfdt_env.h"
  52
  53 #ifndef USE_HOSTCC
  54 #include <fdt.h>
  55 #include <libfdt.h>
  56 #else
  57 #include "fdt_host.h"
  58 #endif
  59
  60 #include "libfdt_internal.h"
  61
  62 static int nodename_eq(const void *fdt, int offset,
  63                        const char *s, int len)
  64 {
  65         const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1);
  66
  67         if (! p)
  68                 /* short match */
  69                 return 0;
  70
  71         if (memcmp(p, s, len) != 0)
  72                 return 0;
  73
  74         if (p[len] == '\0')
  75                 return 1;
  76         else if (!memchr(s, '@', len) && (p[len] == '@'))
  77                 return 1;
  78         else
  79                 return 0;
  80 }
  81
  82 const char *fdt_string(const void *fdt, int stroffset)
  83 {
  84         return (char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
  85 }
  86
  87 int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
  88 {
  89         CHECK_HEADER(fdt);
  90         *address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address);
  91         *size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size);
  92         return 0;
  93 }
  94
  95 int fdt_num_mem_rsv(const void *fdt)
  96 {
  97         int i = 0;
  98
  99         while (fdt64_to_cpu(_fdt_mem_rsv(fdt, i)->size) != 0)
 100                 i++;
 101         return i;
 102 }
 103
 104 int fdt_subnode_offset_namelen(const void *fdt, int offset,
 105                                const char *name, int namelen)
 106 {
 107         int depth;
 108
 109         CHECK_HEADER(fdt);
 110
 111         for (depth = 0;
 112              offset >= 0;
 113              offset = fdt_next_node(fdt, offset, &depth)) {
 114                 if (depth < 0)
 115                         return -FDT_ERR_NOTFOUND;
 116                 else if ((depth == 1)
 117                          && nodename_eq(fdt, offset, name, namelen))
 118                         return offset;
 119         }
 120
 121         return offset; /* error */
 122 }
 123
 124 int fdt_subnode_offset(const void *fdt, int parentoffset,
 125                        const char *name)
 126 {
 127         return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name));
 128 }
 129
 130 int fdt_path_offset(const void *fdt, const char *path)
 131 {
 132         const char *end = path + strlen(path);
 133         const char *p = path;
 134         int offset = 0;
 135
 136         CHECK_HEADER(fdt);
 137
 138         if (*path != '/')
 139                 return -FDT_ERR_BADPATH;
 140
 141         while (*p) {
 142                 const char *q;
 143
 144                 while (*p == '/')
 145                         p++;
 146                 if (! *p)
 147                         return offset;
 148                 q = strchr(p, '/');
 149                 if (! q)
 150                         q = end;
 151
 152                 offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
 153                 if (offset < 0)
 154                         return offset;
 155
 156                 p = q;
 157         }
 158
 159         return offset;
 160 }
 161
 162 const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
 163 {
 164         const struct fdt_node_header *nh;
 165         int err;
 166
 167         if ((err = fdt_check_header(fdt)) != 0)
 168                 goto fail;
 169
 170         err = -FDT_ERR_BADOFFSET;
 171         nh = fdt_offset_ptr(fdt, nodeoffset, sizeof(*nh));
 172         if (!nh || (fdt32_to_cpu(nh->tag) != FDT_BEGIN_NODE))
 173                 goto fail;
 174
 175         if (len)
 176                 *len = strlen(nh->name);
 177
 178         return nh->name;
 179
 180  fail:
 181         if (len)
 182                 *len = err;
 183         return NULL;
 184 }
 185
 186 const struct fdt_property *fdt_get_property(const void *fdt,
 187                                             int nodeoffset,
 188                                             const char *name, int *lenp)
 189 {
 190         uint32_t tag;
 191         const struct fdt_property *prop;
 192         int namestroff;
 193         int offset, nextoffset;
 194         int err;
 195
 196         if ((err = fdt_check_header(fdt)) != 0)
 197                 goto fail;
 198
 199         err = -FDT_ERR_BADOFFSET;
 200         if (nodeoffset % FDT_TAGSIZE)
 201                 goto fail;
 202
 203         tag = fdt_next_tag(fdt, nodeoffset, &nextoffset);
 204         if (tag != FDT_BEGIN_NODE)
 205                 goto fail;
 206
 207         do {
 208                 offset = nextoffset;
 209
 210                 tag = fdt_next_tag(fdt, offset, &nextoffset);
 211                 switch (tag) {
 212                 case FDT_END:
 213                         err = -FDT_ERR_TRUNCATED;
 214                         goto fail;
 215
 216                 case FDT_BEGIN_NODE:
 217                 case FDT_END_NODE:
 218                 case FDT_NOP:
 219                         break;
 220
 221                 case FDT_PROP:
 222                         err = -FDT_ERR_BADSTRUCTURE;
 223                         prop = fdt_offset_ptr(fdt, offset, sizeof(*prop));
 224                         if (! prop)
 225                                 goto fail;
 226                         namestroff = fdt32_to_cpu(prop->nameoff);
 227                         if (streq(fdt_string(fdt, namestroff), name)) {
 228                                 /* Found it! */
 229                                 int len = fdt32_to_cpu(prop->len);
 230                                 prop = fdt_offset_ptr(fdt, offset,
 231                                                       sizeof(*prop)+len);
 232                                 if (! prop)
 233                                         goto fail;
 234
 235                                 if (lenp)
 236                                         *lenp = len;
 237
 238                                 return prop;
 239                         }
 240                         break;
 241
 242                 default:
 243                         err = -FDT_ERR_BADSTRUCTURE;
 244                         goto fail;
 245                 }
 246         } while ((tag != FDT_BEGIN_NODE) && (tag != FDT_END_NODE));
 247
 248         err = -FDT_ERR_NOTFOUND;
 249  fail:
 250         if (lenp)
 251                 *lenp = err;
 252         return NULL;
 253 }
 254
 255 const void *fdt_getprop(const void *fdt, int nodeoffset,
 256                   const char *name, int *lenp)
 257 {
 258         const struct fdt_property *prop;
 259
 260         prop = fdt_get_property(fdt, nodeoffset, name, lenp);
 261         if (! prop)
 262                 return NULL;
 263
 264         return prop->data;
 265 }
 266
 267 uint32_t fdt_get_phandle(const void *fdt, int nodeoffset)
 268 {
 269         const uint32_t *php;
 270         int len;
 271
 272         php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len);
 273         if (!php || (len != sizeof(*php)))
 274                 return 0;
 275
 276         return fdt32_to_cpu(*php);
 277 }
 278
 279 int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
 280 {
 281         int pdepth = 0, p = 0;
 282         int offset, depth, namelen;
 283         const char *name;
 284
 285         CHECK_HEADER(fdt);
 286
 287         if (buflen < 2)
 288                 return -FDT_ERR_NOSPACE;
 289
 290         for (offset = 0, depth = 0;
 291              (offset >= 0) && (offset <= nodeoffset);
 292              offset = fdt_next_node(fdt, offset, &depth)) {
 293                 if (pdepth < depth)
 294                         continue; /* overflowed buffer */
 295
 296                 while (pdepth > depth) {
 297                         do {
 298                                 p--;
 299                         } while (buf[p-1] != '/');
 300                         pdepth--;
 301                 }
 302
 303                 name = fdt_get_name(fdt, offset, &namelen);
 304                 if (!name)
 305                         return namelen;
 306                 if ((p + namelen + 1) <= buflen) {
 307                         memcpy(buf + p, name, namelen);
 308                         p += namelen;
 309                         buf[p++] = '/';
 310                         pdepth++;
 311                 }
 312
 313                 if (offset == nodeoffset) {
 314                         if (pdepth < (depth + 1))
 315                                 return -FDT_ERR_NOSPACE;
 316
 317                         if (p > 1) /* special case so that root path is "/", not "" */
 318                                 p--;
 319                         buf[p] = '\0';
 320                         return p;
 321                 }
 322         }
 323
 324         if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
 325                 return -FDT_ERR_BADOFFSET;
 326         else if (offset == -FDT_ERR_BADOFFSET)
 327                 return -FDT_ERR_BADSTRUCTURE;
 328
 329         return offset; /* error from fdt_next_node() */
 330 }
 331
 332 int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
 333                                  int supernodedepth, int *nodedepth)
 334 {
 335         int offset, depth;
 336         int supernodeoffset = -FDT_ERR_INTERNAL;
 337
 338         CHECK_HEADER(fdt);
 339
 340         if (supernodedepth < 0)
 341                 return -FDT_ERR_NOTFOUND;
 342
 343         for (offset = 0, depth = 0;
 344              (offset >= 0) && (offset <= nodeoffset);
 345              offset = fdt_next_node(fdt, offset, &depth)) {
 346                 if (depth == supernodedepth)
 347                         supernodeoffset = offset;
 348
 349                 if (offset == nodeoffset) {
 350                         if (nodedepth)
 351                                 *nodedepth = depth;
 352
 353                         if (supernodedepth > depth)
 354                                 return -FDT_ERR_NOTFOUND;
 355                         else
 356                                 return supernodeoffset;
 357                 }
 358         }
 359
 360         if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
 361                 return -FDT_ERR_BADOFFSET;
 362         else if (offset == -FDT_ERR_BADOFFSET)
 363                 return -FDT_ERR_BADSTRUCTURE;
 364
 365         return offset; /* error from fdt_next_node() */
 366 }
 367
 368 int fdt_node_depth(const void *fdt, int nodeoffset)
 369 {
 370         int nodedepth;
 371         int err;
 372
 373         err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth);
 374         if (err)
 375                 return (err < 0) ? err : -FDT_ERR_INTERNAL;
 376         return nodedepth;
 377 }
 378
 379 int fdt_parent_offset(const void *fdt, int nodeoffset)
 380 {
 381         int nodedepth = fdt_node_depth(fdt, nodeoffset);
 382
 383         if (nodedepth < 0)
 384                 return nodedepth;
 385         return fdt_supernode_atdepth_offset(fdt, nodeoffset,
 386                                             nodedepth - 1, NULL);
 387 }
 388
 389 int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
 390                                   const char *propname,
 391                                   const void *propval, int proplen)
 392 {
 393         int offset;
 394         const void *val;
 395         int len;
 396
 397         CHECK_HEADER(fdt);
 398
 399         /* FIXME: The algorithm here is pretty horrible: we scan each
 400          * property of a node in fdt_getprop(), then if that didn't
 401          * find what we want, we scan over them again making our way
 402          * to the next node.  Still it's the easiest to implement
 403          * approach; performance can come later. */
 404         for (offset = fdt_next_node(fdt, startoffset, NULL);
 405              offset >= 0;
 406              offset = fdt_next_node(fdt, offset, NULL)) {
 407                 val = fdt_getprop(fdt, offset, propname, &len);
 408                 if (val && (len == proplen)
 409                     && (memcmp(val, propval, len) == 0))
 410                         return offset;
 411         }
 412
 413         return offset; /* error from fdt_next_node() */
 414 }
 415
 416 int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)
 417 {
 418         if ((phandle == 0) || (phandle == -1))
 419                 return -FDT_ERR_BADPHANDLE;
 420         phandle = cpu_to_fdt32(phandle);
 421         return fdt_node_offset_by_prop_value(fdt, -1, "linux,phandle",
 422                                              &phandle, sizeof(phandle));
 423 }
 424
 425 int _stringlist_contains(const void *strlist, int listlen, const char *str)
 426 {
 427         int len = strlen(str);
 428         const void *p;
 429
 430         while (listlen >= len) {
 431                 if (memcmp(str, strlist, len+1) == 0)
 432                         return 1;
 433                 p = memchr(strlist, '\0', listlen);
 434                 if (!p)
 435                         return 0; /* malformed strlist.. */
 436                 listlen -= (p-strlist) + 1;
 437                 strlist = p + 1;
 438         }
 439         return 0;
 440 }
 441
 442 int fdt_node_check_compatible(const void *fdt, int nodeoffset,
 443                               const char *compatible)
 444 {
 445         const void *prop;
 446         int len;
 447
 448         prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
 449         if (!prop)
 450                 return len;
 451         if (_stringlist_contains(prop, len, compatible))
 452                 return 0;
 453         else
 454                 return 1;
 455 }
 456
 457 int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
 458                                   const char *compatible)
 459 {
 460         int offset, err;
 461
 462         CHECK_HEADER(fdt);
 463
 464         /* FIXME: The algorithm here is pretty horrible: we scan each
 465          * property of a node in fdt_node_check_compatible(), then if
 466          * that didn't find what we want, we scan over them again
 467          * making our way to the next node.  Still it's the easiest to
 468          * implement approach; performance can come later. */
 469         for (offset = fdt_next_node(fdt, startoffset, NULL);
 470              offset >= 0;
 471              offset = fdt_next_node(fdt, offset, NULL)) {
 472                 err = fdt_node_check_compatible(fdt, offset, compatible);
 473                 if ((err < 0) && (err != -FDT_ERR_NOTFOUND))
 474                         return err;
 475                 else if (err == 0)
 476                         return offset;
 477         }
 478
 479         return offset; /* error from fdt_next_node() */
 480 }