scripts/dtc/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 #include <fdt.h>
  54 #include <libfdt.h>
  55
  56 #include "libfdt_internal.h"
  57
  58 static int _fdt_nodename_eq(const void *fdt, int offset,
  59                             const char *s, int len)
  60 {
  61         const char *p = fdt_offset_ptr(fdt, offset + FDT_TAGSIZE, len+1);
  62
  63         if (! p)
  64                 /* short match */
  65                 return 0;
  66
  67         if (memcmp(p, s, len) != 0)
  68                 return 0;
  69
  70         if (p[len] == '\0')
  71                 return 1;
  72         else if (!memchr(s, '@', len) && (p[len] == '@'))
  73                 return 1;
  74         else
  75                 return 0;
  76 }
  77
  78 const char *fdt_string(const void *fdt, int stroffset)
  79 {
  80         return (const char *)fdt + fdt_off_dt_strings(fdt) + stroffset;
  81 }
  82
  83 static int _fdt_string_eq(const void *fdt, int stroffset,
  84                           const char *s, int len)
  85 {
  86         const char *p = fdt_string(fdt, stroffset);
  87
  88         return (strlen(p) == len) && (memcmp(p, s, len) == 0);
  89 }
  90
  91 uint32_t fdt_get_max_phandle(const void *fdt)
  92 {
  93         uint32_t max_phandle = 0;
  94         int offset;
  95
  96         for (offset = fdt_next_node(fdt, -1, NULL);;
  97              offset = fdt_next_node(fdt, offset, NULL)) {
  98                 uint32_t phandle;
  99
 100                 if (offset == -FDT_ERR_NOTFOUND)
 101                         return max_phandle;
 102
 103                 if (offset < 0)
 104                         return (uint32_t)-1;
 105
 106                 phandle = fdt_get_phandle(fdt, offset);
 107                 if (phandle == (uint32_t)-1)
 108                         continue;
 109
 110                 if (phandle > max_phandle)
 111                         max_phandle = phandle;
 112         }
 113
 114         return 0;
 115 }
 116
 117 int fdt_get_mem_rsv(const void *fdt, int n, uint64_t *address, uint64_t *size)
 118 {
 119         FDT_CHECK_HEADER(fdt);
 120         *address = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->address);
 121         *size = fdt64_to_cpu(_fdt_mem_rsv(fdt, n)->size);
 122         return 0;
 123 }
 124
 125 int fdt_num_mem_rsv(const void *fdt)
 126 {
 127         int i = 0;
 128
 129         while (fdt64_to_cpu(_fdt_mem_rsv(fdt, i)->size) != 0)
 130                 i++;
 131         return i;
 132 }
 133
 134 static int _nextprop(const void *fdt, int offset)
 135 {
 136         uint32_t tag;
 137         int nextoffset;
 138
 139         do {
 140                 tag = fdt_next_tag(fdt, offset, &nextoffset);
 141
 142                 switch (tag) {
 143                 case FDT_END:
 144                         if (nextoffset >= 0)
 145                                 return -FDT_ERR_BADSTRUCTURE;
 146                         else
 147                                 return nextoffset;
 148
 149                 case FDT_PROP:
 150                         return offset;
 151                 }
 152                 offset = nextoffset;
 153         } while (tag == FDT_NOP);
 154
 155         return -FDT_ERR_NOTFOUND;
 156 }
 157
 158 int fdt_subnode_offset_namelen(const void *fdt, int offset,
 159                                const char *name, int namelen)
 160 {
 161         int depth;
 162
 163         FDT_CHECK_HEADER(fdt);
 164
 165         for (depth = 0;
 166              (offset >= 0) && (depth >= 0);
 167              offset = fdt_next_node(fdt, offset, &depth))
 168                 if ((depth == 1)
 169                     && _fdt_nodename_eq(fdt, offset, name, namelen))
 170                         return offset;
 171
 172         if (depth < 0)
 173                 return -FDT_ERR_NOTFOUND;
 174         return offset; /* error */
 175 }
 176
 177 int fdt_subnode_offset(const void *fdt, int parentoffset,
 178                        const char *name)
 179 {
 180         return fdt_subnode_offset_namelen(fdt, parentoffset, name, strlen(name));
 181 }
 182
 183 int fdt_path_offset_namelen(const void *fdt, const char *path, int namelen)
 184 {
 185         const char *end = path + namelen;
 186         const char *p = path;
 187         int offset = 0;
 188
 189         FDT_CHECK_HEADER(fdt);
 190
 191         /* see if we have an alias */
 192         if (*path != '/') {
 193                 const char *q = memchr(path, '/', end - p);
 194
 195                 if (!q)
 196                         q = end;
 197
 198                 p = fdt_get_alias_namelen(fdt, p, q - p);
 199                 if (!p)
 200                         return -FDT_ERR_BADPATH;
 201                 offset = fdt_path_offset(fdt, p);
 202
 203                 p = q;
 204         }
 205
 206         while (p < end) {
 207                 const char *q;
 208
 209                 while (*p == '/') {
 210                         p++;
 211                         if (p == end)
 212                                 return offset;
 213                 }
 214                 q = memchr(p, '/', end - p);
 215                 if (! q)
 216                         q = end;
 217
 218                 offset = fdt_subnode_offset_namelen(fdt, offset, p, q-p);
 219                 if (offset < 0)
 220                         return offset;
 221
 222                 p = q;
 223         }
 224
 225         return offset;
 226 }
 227
 228 int fdt_path_offset(const void *fdt, const char *path)
 229 {
 230         return fdt_path_offset_namelen(fdt, path, strlen(path));
 231 }
 232
 233 const char *fdt_get_name(const void *fdt, int nodeoffset, int *len)
 234 {
 235         const struct fdt_node_header *nh = _fdt_offset_ptr(fdt, nodeoffset);
 236         int err;
 237
 238         if (((err = fdt_check_header(fdt)) != 0)
 239             || ((err = _fdt_check_node_offset(fdt, nodeoffset)) < 0))
 240                         goto fail;
 241
 242         if (len)
 243                 *len = strlen(nh->name);
 244
 245         return nh->name;
 246
 247  fail:
 248         if (len)
 249                 *len = err;
 250         return NULL;
 251 }
 252
 253 int fdt_first_property_offset(const void *fdt, int nodeoffset)
 254 {
 255         int offset;
 256
 257         if ((offset = _fdt_check_node_offset(fdt, nodeoffset)) < 0)
 258                 return offset;
 259
 260         return _nextprop(fdt, offset);
 261 }
 262
 263 int fdt_next_property_offset(const void *fdt, int offset)
 264 {
 265         if ((offset = _fdt_check_prop_offset(fdt, offset)) < 0)
 266                 return offset;
 267
 268         return _nextprop(fdt, offset);
 269 }
 270
 271 const struct fdt_property *fdt_get_property_by_offset(const void *fdt,
 272                                                       int offset,
 273                                                       int *lenp)
 274 {
 275         int err;
 276         const struct fdt_property *prop;
 277
 278         if ((err = _fdt_check_prop_offset(fdt, offset)) < 0) {
 279                 if (lenp)
 280                         *lenp = err;
 281                 return NULL;
 282         }
 283
 284         prop = _fdt_offset_ptr(fdt, offset);
 285
 286         if (lenp)
 287                 *lenp = fdt32_to_cpu(prop->len);
 288
 289         return prop;
 290 }
 291
 292 const struct fdt_property *fdt_get_property_namelen(const void *fdt,
 293                                                     int offset,
 294                                                     const char *name,
 295                                                     int namelen, int *lenp)
 296 {
 297         for (offset = fdt_first_property_offset(fdt, offset);
 298              (offset >= 0);
 299              (offset = fdt_next_property_offset(fdt, offset))) {
 300                 const struct fdt_property *prop;
 301
 302                 if (!(prop = fdt_get_property_by_offset(fdt, offset, lenp))) {
 303                         offset = -FDT_ERR_INTERNAL;
 304                         break;
 305                 }
 306                 if (_fdt_string_eq(fdt, fdt32_to_cpu(prop->nameoff),
 307                                    name, namelen))
 308                         return prop;
 309         }
 310
 311         if (lenp)
 312                 *lenp = offset;
 313         return NULL;
 314 }
 315
 316 const struct fdt_property *fdt_get_property(const void *fdt,
 317                                             int nodeoffset,
 318                                             const char *name, int *lenp)
 319 {
 320         return fdt_get_property_namelen(fdt, nodeoffset, name,
 321                                         strlen(name), lenp);
 322 }
 323
 324 const void *fdt_getprop_namelen(const void *fdt, int nodeoffset,
 325                                 const char *name, int namelen, int *lenp)
 326 {
 327         const struct fdt_property *prop;
 328
 329         prop = fdt_get_property_namelen(fdt, nodeoffset, name, namelen, lenp);
 330         if (! prop)
 331                 return NULL;
 332
 333         return prop->data;
 334 }
 335
 336 const void *fdt_getprop_by_offset(const void *fdt, int offset,
 337                                   const char **namep, int *lenp)
 338 {
 339         const struct fdt_property *prop;
 340
 341         prop = fdt_get_property_by_offset(fdt, offset, lenp);
 342         if (!prop)
 343                 return NULL;
 344         if (namep)
 345                 *namep = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
 346         return prop->data;
 347 }
 348
 349 const void *fdt_getprop(const void *fdt, int nodeoffset,
 350                         const char *name, int *lenp)
 351 {
 352         return fdt_getprop_namelen(fdt, nodeoffset, name, strlen(name), lenp);
 353 }
 354
 355 uint32_t fdt_get_phandle(const void *fdt, int nodeoffset)
 356 {
 357         const fdt32_t *php;
 358         int len;
 359
 360         /* FIXME: This is a bit sub-optimal, since we potentially scan
 361          * over all the properties twice. */
 362         php = fdt_getprop(fdt, nodeoffset, "phandle", &len);
 363         if (!php || (len != sizeof(*php))) {
 364                 php = fdt_getprop(fdt, nodeoffset, "linux,phandle", &len);
 365                 if (!php || (len != sizeof(*php)))
 366                         return 0;
 367         }
 368
 369         return fdt32_to_cpu(*php);
 370 }
 371
 372 const char *fdt_get_alias_namelen(const void *fdt,
 373                                   const char *name, int namelen)
 374 {
 375         int aliasoffset;
 376
 377         aliasoffset = fdt_path_offset(fdt, "/aliases");
 378         if (aliasoffset < 0)
 379                 return NULL;
 380
 381         return fdt_getprop_namelen(fdt, aliasoffset, name, namelen, NULL);
 382 }
 383
 384 const char *fdt_get_alias(const void *fdt, const char *name)
 385 {
 386         return fdt_get_alias_namelen(fdt, name, strlen(name));
 387 }
 388
 389 int fdt_get_path(const void *fdt, int nodeoffset, char *buf, int buflen)
 390 {
 391         int pdepth = 0, p = 0;
 392         int offset, depth, namelen;
 393         const char *name;
 394
 395         FDT_CHECK_HEADER(fdt);
 396
 397         if (buflen < 2)
 398                 return -FDT_ERR_NOSPACE;
 399
 400         for (offset = 0, depth = 0;
 401              (offset >= 0) && (offset <= nodeoffset);
 402              offset = fdt_next_node(fdt, offset, &depth)) {
 403                 while (pdepth > depth) {
 404                         do {
 405                                 p--;
 406                         } while (buf[p-1] != '/');
 407                         pdepth--;
 408                 }
 409
 410                 if (pdepth >= depth) {
 411                         name = fdt_get_name(fdt, offset, &namelen);
 412                         if (!name)
 413                                 return namelen;
 414                         if ((p + namelen + 1) <= buflen) {
 415                                 memcpy(buf + p, name, namelen);
 416                                 p += namelen;
 417                                 buf[p++] = '/';
 418                                 pdepth++;
 419                         }
 420                 }
 421
 422                 if (offset == nodeoffset) {
 423                         if (pdepth < (depth + 1))
 424                                 return -FDT_ERR_NOSPACE;
 425
 426                         if (p > 1) /* special case so that root path is "/", not "" */
 427                                 p--;
 428                         buf[p] = '\0';
 429                         return 0;
 430                 }
 431         }
 432
 433         if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
 434                 return -FDT_ERR_BADOFFSET;
 435         else if (offset == -FDT_ERR_BADOFFSET)
 436                 return -FDT_ERR_BADSTRUCTURE;
 437
 438         return offset; /* error from fdt_next_node() */
 439 }
 440
 441 int fdt_supernode_atdepth_offset(const void *fdt, int nodeoffset,
 442                                  int supernodedepth, int *nodedepth)
 443 {
 444         int offset, depth;
 445         int supernodeoffset = -FDT_ERR_INTERNAL;
 446
 447         FDT_CHECK_HEADER(fdt);
 448
 449         if (supernodedepth < 0)
 450                 return -FDT_ERR_NOTFOUND;
 451
 452         for (offset = 0, depth = 0;
 453              (offset >= 0) && (offset <= nodeoffset);
 454              offset = fdt_next_node(fdt, offset, &depth)) {
 455                 if (depth == supernodedepth)
 456                         supernodeoffset = offset;
 457
 458                 if (offset == nodeoffset) {
 459                         if (nodedepth)
 460                                 *nodedepth = depth;
 461
 462                         if (supernodedepth > depth)
 463                                 return -FDT_ERR_NOTFOUND;
 464                         else
 465                                 return supernodeoffset;
 466                 }
 467         }
 468
 469         if ((offset == -FDT_ERR_NOTFOUND) || (offset >= 0))
 470                 return -FDT_ERR_BADOFFSET;
 471         else if (offset == -FDT_ERR_BADOFFSET)
 472                 return -FDT_ERR_BADSTRUCTURE;
 473
 474         return offset; /* error from fdt_next_node() */
 475 }
 476
 477 int fdt_node_depth(const void *fdt, int nodeoffset)
 478 {
 479         int nodedepth;
 480         int err;
 481
 482         err = fdt_supernode_atdepth_offset(fdt, nodeoffset, 0, &nodedepth);
 483         if (err)
 484                 return (err < 0) ? err : -FDT_ERR_INTERNAL;
 485         return nodedepth;
 486 }
 487
 488 int fdt_parent_offset(const void *fdt, int nodeoffset)
 489 {
 490         int nodedepth = fdt_node_depth(fdt, nodeoffset);
 491
 492         if (nodedepth < 0)
 493                 return nodedepth;
 494         return fdt_supernode_atdepth_offset(fdt, nodeoffset,
 495                                             nodedepth - 1, NULL);
 496 }
 497
 498 int fdt_node_offset_by_prop_value(const void *fdt, int startoffset,
 499                                   const char *propname,
 500                                   const void *propval, int proplen)
 501 {
 502         int offset;
 503         const void *val;
 504         int len;
 505
 506         FDT_CHECK_HEADER(fdt);
 507
 508         /* FIXME: The algorithm here is pretty horrible: we scan each
 509          * property of a node in fdt_getprop(), then if that didn't
 510          * find what we want, we scan over them again making our way
 511          * to the next node.  Still it's the easiest to implement
 512          * approach; performance can come later. */
 513         for (offset = fdt_next_node(fdt, startoffset, NULL);
 514              offset >= 0;
 515              offset = fdt_next_node(fdt, offset, NULL)) {
 516                 val = fdt_getprop(fdt, offset, propname, &len);
 517                 if (val && (len == proplen)
 518                     && (memcmp(val, propval, len) == 0))
 519                         return offset;
 520         }
 521
 522         return offset; /* error from fdt_next_node() */
 523 }
 524
 525 int fdt_node_offset_by_phandle(const void *fdt, uint32_t phandle)
 526 {
 527         int offset;
 528
 529         if ((phandle == 0) || (phandle == -1))
 530                 return -FDT_ERR_BADPHANDLE;
 531
 532         FDT_CHECK_HEADER(fdt);
 533
 534         /* FIXME: The algorithm here is pretty horrible: we
 535          * potentially scan each property of a node in
 536          * fdt_get_phandle(), then if that didn't find what
 537          * we want, we scan over them again making our way to the next
 538          * node.  Still it's the easiest to implement approach;
 539          * performance can come later. */
 540         for (offset = fdt_next_node(fdt, -1, NULL);
 541              offset >= 0;
 542              offset = fdt_next_node(fdt, offset, NULL)) {
 543                 if (fdt_get_phandle(fdt, offset) == phandle)
 544                         return offset;
 545         }
 546
 547         return offset; /* error from fdt_next_node() */
 548 }
 549
 550 int fdt_stringlist_contains(const char *strlist, int listlen, const char *str)
 551 {
 552         int len = strlen(str);
 553         const char *p;
 554
 555         while (listlen >= len) {
 556                 if (memcmp(str, strlist, len+1) == 0)
 557                         return 1;
 558                 p = memchr(strlist, '\0', listlen);
 559                 if (!p)
 560                         return 0; /* malformed strlist.. */
 561                 listlen -= (p-strlist) + 1;
 562                 strlist = p + 1;
 563         }
 564         return 0;
 565 }
 566
 567 int fdt_stringlist_count(const void *fdt, int nodeoffset, const char *property)
 568 {
 569         const char *list, *end;
 570         int length, count = 0;
 571
 572         list = fdt_getprop(fdt, nodeoffset, property, &length);
 573         if (!list)
 574                 return length;
 575
 576         end = list + length;
 577
 578         while (list < end) {
 579                 length = strnlen(list, end - list) + 1;
 580
 581                 /* Abort if the last string isn't properly NUL-terminated. */
 582                 if (list + length > end)
 583                         return -FDT_ERR_BADVALUE;
 584
 585                 list += length;
 586                 count++;
 587         }
 588
 589         return count;
 590 }
 591
 592 int fdt_stringlist_search(const void *fdt, int nodeoffset, const char *property,
 593                           const char *string)
 594 {
 595         int length, len, idx = 0;
 596         const char *list, *end;
 597
 598         list = fdt_getprop(fdt, nodeoffset, property, &length);
 599         if (!list)
 600                 return length;
 601
 602         len = strlen(string) + 1;
 603         end = list + length;
 604
 605         while (list < end) {
 606                 length = strnlen(list, end - list) + 1;
 607
 608                 /* Abort if the last string isn't properly NUL-terminated. */
 609                 if (list + length > end)
 610                         return -FDT_ERR_BADVALUE;
 611
 612                 if (length == len && memcmp(list, string, length) == 0)
 613                         return idx;
 614
 615                 list += length;
 616                 idx++;
 617         }
 618
 619         return -FDT_ERR_NOTFOUND;
 620 }
 621
 622 const char *fdt_stringlist_get(const void *fdt, int nodeoffset,
 623                                const char *property, int idx,
 624                                int *lenp)
 625 {
 626         const char *list, *end;
 627         int length;
 628
 629         list = fdt_getprop(fdt, nodeoffset, property, &length);
 630         if (!list) {
 631                 if (lenp)
 632                         *lenp = length;
 633
 634                 return NULL;
 635         }
 636
 637         end = list + length;
 638
 639         while (list < end) {
 640                 length = strnlen(list, end - list) + 1;
 641
 642                 /* Abort if the last string isn't properly NUL-terminated. */
 643                 if (list + length > end) {
 644                         if (lenp)
 645                                 *lenp = -FDT_ERR_BADVALUE;
 646
 647                         return NULL;
 648                 }
 649
 650                 if (idx == 0) {
 651                         if (lenp)
 652                                 *lenp = length - 1;
 653
 654                         return list;
 655                 }
 656
 657                 list += length;
 658                 idx--;
 659         }
 660
 661         if (lenp)
 662                 *lenp = -FDT_ERR_NOTFOUND;
 663
 664         return NULL;
 665 }
 666
 667 int fdt_node_check_compatible(const void *fdt, int nodeoffset,
 668                               const char *compatible)
 669 {
 670         const void *prop;
 671         int len;
 672
 673         prop = fdt_getprop(fdt, nodeoffset, "compatible", &len);
 674         if (!prop)
 675                 return len;
 676
 677         return !fdt_stringlist_contains(prop, len, compatible);
 678 }
 679
 680 int fdt_node_offset_by_compatible(const void *fdt, int startoffset,
 681                                   const char *compatible)
 682 {
 683         int offset, err;
 684
 685         FDT_CHECK_HEADER(fdt);
 686
 687         /* FIXME: The algorithm here is pretty horrible: we scan each
 688          * property of a node in fdt_node_check_compatible(), then if
 689          * that didn't find what we want, we scan over them again
 690          * making our way to the next node.  Still it's the easiest to
 691          * implement approach; performance can come later. */
 692         for (offset = fdt_next_node(fdt, startoffset, NULL);
 693              offset >= 0;
 694              offset = fdt_next_node(fdt, offset, NULL)) {
 695                 err = fdt_node_check_compatible(fdt, offset, compatible);
 696                 if ((err < 0) && (err != -FDT_ERR_NOTFOUND))
 697                         return err;
 698                 else if (err == 0)
 699                         return offset;
 700         }
 701
 702         return offset; /* error from fdt_next_node() */
 703 }