drivers/core/ofnode.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2017 Google, Inc
   4  * Written by Simon Glass <sjg@chromium.org>
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <fdtdec.h>
  10 #include <fdt_support.h>
  11 #include <malloc.h>
  12 #include <linux/libfdt.h>
  13 #include <dm/of_access.h>
  14 #include <dm/of_addr.h>
  15 #include <dm/ofnode.h>
  16 #include <linux/err.h>
  17 #include <linux/ioport.h>
  18
  19 int ofnode_read_u32(ofnode node, const char *propname, u32 *outp)
  20 {
  21         return ofnode_read_u32_index(node, propname, 0, outp);
  22 }
  23
  24 u32 ofnode_read_u32_default(ofnode node, const char *propname, u32 def)
  25 {
  26         assert(ofnode_valid(node));
  27         ofnode_read_u32_index(node, propname, 0, &def);
  28
  29         return def;
  30 }
  31
  32 int ofnode_read_u32_index(ofnode node, const char *propname, int index,
  33                           u32 *outp)
  34 {
  35         const fdt32_t *cell;
  36         int len;
  37
  38         assert(ofnode_valid(node));
  39         debug("%s: %s: ", __func__, propname);
  40
  41         if (ofnode_is_np(node))
  42                 return of_read_u32_index(ofnode_to_np(node), propname, index,
  43                                          outp);
  44
  45         cell = fdt_getprop(gd->fdt_blob, ofnode_to_offset(node), propname,
  46                            &len);
  47         if (!cell) {
  48                 debug("(not found)\n");
  49                 return -EINVAL;
  50         }
  51
  52         if (len < (sizeof(int) * (index + 1))) {
  53                 debug("(not large enough)\n");
  54                 return -EOVERFLOW;
  55         }
  56
  57         *outp = fdt32_to_cpu(cell[index]);
  58         debug("%#x (%d)\n", *outp, *outp);
  59
  60         return 0;
  61 }
  62
  63 u32 ofnode_read_u32_index_default(ofnode node, const char *propname, int index,
  64                                   u32 def)
  65 {
  66         assert(ofnode_valid(node));
  67         ofnode_read_u32_index(node, propname, index, &def);
  68
  69         return def;
  70 }
  71
  72 int ofnode_read_s32_default(ofnode node, const char *propname, s32 def)
  73 {
  74         assert(ofnode_valid(node));
  75         ofnode_read_u32(node, propname, (u32 *)&def);
  76
  77         return def;
  78 }
  79
  80 int ofnode_read_u64(ofnode node, const char *propname, u64 *outp)
  81 {
  82         const unaligned_fdt64_t *cell;
  83         int len;
  84
  85         assert(ofnode_valid(node));
  86         debug("%s: %s: ", __func__, propname);
  87
  88         if (ofnode_is_np(node))
  89                 return of_read_u64(ofnode_to_np(node), propname, outp);
  90
  91         cell = fdt_getprop(gd->fdt_blob, ofnode_to_offset(node), propname,
  92                            &len);
  93         if (!cell || len < sizeof(*cell)) {
  94                 debug("(not found)\n");
  95                 return -EINVAL;
  96         }
  97         *outp = fdt64_to_cpu(cell[0]);
  98         debug("%#llx (%lld)\n", (unsigned long long)*outp,
  99               (unsigned long long)*outp);
 100
 101         return 0;
 102 }
 103
 104 u64 ofnode_read_u64_default(ofnode node, const char *propname, u64 def)
 105 {
 106         assert(ofnode_valid(node));
 107         ofnode_read_u64(node, propname, &def);
 108
 109         return def;
 110 }
 111
 112 bool ofnode_read_bool(ofnode node, const char *propname)
 113 {
 114         const void *prop;
 115
 116         assert(ofnode_valid(node));
 117         debug("%s: %s: ", __func__, propname);
 118
 119         prop = ofnode_get_property(node, propname, NULL);
 120
 121         debug("%s\n", prop ? "true" : "false");
 122
 123         return prop ? true : false;
 124 }
 125
 126 const void *ofnode_read_prop(ofnode node, const char *propname, int *sizep)
 127 {
 128         const char *val = NULL;
 129         int len;
 130
 131         assert(ofnode_valid(node));
 132         debug("%s: %s: ", __func__, propname);
 133
 134         if (ofnode_is_np(node)) {
 135                 struct property *prop = of_find_property(
 136                                 ofnode_to_np(node), propname, &len);
 137
 138                 if (prop) {
 139                         val = prop->value;
 140                         len = prop->length;
 141                 }
 142         } else {
 143                 val = fdt_getprop(gd->fdt_blob, ofnode_to_offset(node),
 144                                   propname, &len);
 145         }
 146         if (!val) {
 147                 debug("<not found>\n");
 148                 if (sizep)
 149                         *sizep = -FDT_ERR_NOTFOUND;
 150                 return NULL;
 151         }
 152         if (sizep)
 153                 *sizep = len;
 154
 155         return val;
 156 }
 157
 158 const char *ofnode_read_string(ofnode node, const char *propname)
 159 {
 160         const char *str;
 161         int len;
 162
 163         str = ofnode_read_prop(node, propname, &len);
 164         if (!str)
 165                 return NULL;
 166
 167         if (strnlen(str, len) >= len) {
 168                 debug("<invalid>\n");
 169                 return NULL;
 170         }
 171         debug("%s\n", str);
 172
 173         return str;
 174 }
 175
 176 int ofnode_read_size(ofnode node, const char *propname)
 177 {
 178         int len;
 179
 180         if (!ofnode_read_prop(node, propname, &len))
 181                 return -EINVAL;
 182
 183         return len;
 184 }
 185
 186 ofnode ofnode_find_subnode(ofnode node, const char *subnode_name)
 187 {
 188         ofnode subnode;
 189
 190         assert(ofnode_valid(node));
 191         debug("%s: %s: ", __func__, subnode_name);
 192
 193         if (ofnode_is_np(node)) {
 194                 const struct device_node *np = ofnode_to_np(node);
 195
 196                 for (np = np->child; np; np = np->sibling) {
 197                         if (!strcmp(subnode_name, np->name))
 198                                 break;
 199                 }
 200                 subnode = np_to_ofnode(np);
 201         } else {
 202                 int ooffset = fdt_subnode_offset(gd->fdt_blob,
 203                                 ofnode_to_offset(node), subnode_name);
 204                 subnode = offset_to_ofnode(ooffset);
 205         }
 206         debug("%s\n", ofnode_valid(subnode) ?
 207               ofnode_get_name(subnode) : "<none>");
 208
 209         return subnode;
 210 }
 211
 212 int ofnode_read_u32_array(ofnode node, const char *propname,
 213                           u32 *out_values, size_t sz)
 214 {
 215         assert(ofnode_valid(node));
 216         debug("%s: %s: ", __func__, propname);
 217
 218         if (ofnode_is_np(node)) {
 219                 return of_read_u32_array(ofnode_to_np(node), propname,
 220                                          out_values, sz);
 221         } else {
 222                 return fdtdec_get_int_array(gd->fdt_blob,
 223                                             ofnode_to_offset(node), propname,
 224                                             out_values, sz);
 225         }
 226 }
 227
 228 ofnode ofnode_first_subnode(ofnode node)
 229 {
 230         assert(ofnode_valid(node));
 231         if (ofnode_is_np(node))
 232                 return np_to_ofnode(node.np->child);
 233
 234         return offset_to_ofnode(
 235                 fdt_first_subnode(gd->fdt_blob, ofnode_to_offset(node)));
 236 }
 237
 238 ofnode ofnode_next_subnode(ofnode node)
 239 {
 240         assert(ofnode_valid(node));
 241         if (ofnode_is_np(node))
 242                 return np_to_ofnode(node.np->sibling);
 243
 244         return offset_to_ofnode(
 245                 fdt_next_subnode(gd->fdt_blob, ofnode_to_offset(node)));
 246 }
 247
 248 ofnode ofnode_get_parent(ofnode node)
 249 {
 250         ofnode parent;
 251
 252         assert(ofnode_valid(node));
 253         if (ofnode_is_np(node))
 254                 parent = np_to_ofnode(of_get_parent(ofnode_to_np(node)));
 255         else
 256                 parent.of_offset = fdt_parent_offset(gd->fdt_blob,
 257                                                      ofnode_to_offset(node));
 258
 259         return parent;
 260 }
 261
 262 const char *ofnode_get_name(ofnode node)
 263 {
 264         if (!ofnode_valid(node)) {
 265                 debug("%s node not valid\n", __func__);
 266                 return NULL;
 267         }
 268
 269         if (ofnode_is_np(node))
 270                 return strrchr(node.np->full_name, '/') + 1;
 271
 272         return fdt_get_name(gd->fdt_blob, ofnode_to_offset(node), NULL);
 273 }
 274
 275 ofnode ofnode_get_by_phandle(uint phandle)
 276 {
 277         ofnode node;
 278
 279         if (of_live_active())
 280                 node = np_to_ofnode(of_find_node_by_phandle(phandle));
 281         else
 282                 node.of_offset = fdt_node_offset_by_phandle(gd->fdt_blob,
 283                                                             phandle);
 284
 285         return node;
 286 }
 287
 288 fdt_addr_t ofnode_get_addr_size_index(ofnode node, int index, fdt_size_t *size)
 289 {
 290         int na, ns;
 291
 292         if (ofnode_is_np(node)) {
 293                 const __be32 *prop_val;
 294                 u64 size64;
 295                 uint flags;
 296
 297                 prop_val = of_get_address(ofnode_to_np(node), index, &size64,
 298                                           &flags);
 299                 if (!prop_val)
 300                         return FDT_ADDR_T_NONE;
 301                 if (size)
 302                         *size = size64;
 303
 304                 ns = of_n_size_cells(ofnode_to_np(node));
 305
 306                 if (IS_ENABLED(CONFIG_OF_TRANSLATE) && ns > 0) {
 307                         return of_translate_address(ofnode_to_np(node), prop_val);
 308                 } else {
 309                         na = of_n_addr_cells(ofnode_to_np(node));
 310                         return of_read_number(prop_val, na);
 311                 }
 312         } else {
 313                 na = ofnode_read_simple_addr_cells(ofnode_get_parent(node));
 314                 ns = ofnode_read_simple_size_cells(ofnode_get_parent(node));
 315                 return fdtdec_get_addr_size_fixed(gd->fdt_blob,
 316                                                   ofnode_to_offset(node), "reg",
 317                                                   index, na, ns, size, true);
 318         }
 319
 320         return FDT_ADDR_T_NONE;
 321 }
 322
 323 fdt_addr_t ofnode_get_addr_index(ofnode node, int index)
 324 {
 325         fdt_size_t size;
 326
 327         return ofnode_get_addr_size_index(node, index, &size);
 328 }
 329
 330 fdt_addr_t ofnode_get_addr(ofnode node)
 331 {
 332         return ofnode_get_addr_index(node, 0);
 333 }
 334
 335 int ofnode_stringlist_search(ofnode node, const char *property,
 336                              const char *string)
 337 {
 338         if (ofnode_is_np(node)) {
 339                 return of_property_match_string(ofnode_to_np(node),
 340                                                 property, string);
 341         } else {
 342                 int ret;
 343
 344                 ret = fdt_stringlist_search(gd->fdt_blob,
 345                                             ofnode_to_offset(node), property,
 346                                             string);
 347                 if (ret == -FDT_ERR_NOTFOUND)
 348                         return -ENODATA;
 349                 else if (ret < 0)
 350                         return -EINVAL;
 351
 352                 return ret;
 353         }
 354 }
 355
 356 int ofnode_read_string_index(ofnode node, const char *property, int index,
 357                              const char **outp)
 358 {
 359         if (ofnode_is_np(node)) {
 360                 return of_property_read_string_index(ofnode_to_np(node),
 361                                                      property, index, outp);
 362         } else {
 363                 int len;
 364
 365                 *outp = fdt_stringlist_get(gd->fdt_blob, ofnode_to_offset(node),
 366                                            property, index, &len);
 367                 if (len < 0)
 368                         return -EINVAL;
 369                 return 0;
 370         }
 371 }
 372
 373 int ofnode_read_string_count(ofnode node, const char *property)
 374 {
 375         if (ofnode_is_np(node)) {
 376                 return of_property_count_strings(ofnode_to_np(node), property);
 377         } else {
 378                 return fdt_stringlist_count(gd->fdt_blob,
 379                                             ofnode_to_offset(node), property);
 380         }
 381 }
 382
 383 static void ofnode_from_fdtdec_phandle_args(struct fdtdec_phandle_args *in,
 384                                             struct ofnode_phandle_args *out)
 385 {
 386         assert(OF_MAX_PHANDLE_ARGS == MAX_PHANDLE_ARGS);
 387         out->node = offset_to_ofnode(in->node);
 388         out->args_count = in->args_count;
 389         memcpy(out->args, in->args, sizeof(out->args));
 390 }
 391
 392 static void ofnode_from_of_phandle_args(struct of_phandle_args *in,
 393                                         struct ofnode_phandle_args *out)
 394 {
 395         assert(OF_MAX_PHANDLE_ARGS == MAX_PHANDLE_ARGS);
 396         out->node = np_to_ofnode(in->np);
 397         out->args_count = in->args_count;
 398         memcpy(out->args, in->args, sizeof(out->args));
 399 }
 400
 401 int ofnode_parse_phandle_with_args(ofnode node, const char *list_name,
 402                                    const char *cells_name, int cell_count,
 403                                    int index,
 404                                    struct ofnode_phandle_args *out_args)
 405 {
 406         if (ofnode_is_np(node)) {
 407                 struct of_phandle_args args;
 408                 int ret;
 409
 410                 ret = of_parse_phandle_with_args(ofnode_to_np(node),
 411                                                  list_name, cells_name, index,
 412                                                  &args);
 413                 if (ret)
 414                         return ret;
 415                 ofnode_from_of_phandle_args(&args, out_args);
 416         } else {
 417                 struct fdtdec_phandle_args args;
 418                 int ret;
 419
 420                 ret = fdtdec_parse_phandle_with_args(gd->fdt_blob,
 421                                                      ofnode_to_offset(node),
 422                                                      list_name, cells_name,
 423                                                      cell_count, index, &args);
 424                 if (ret)
 425                         return ret;
 426                 ofnode_from_fdtdec_phandle_args(&args, out_args);
 427         }
 428
 429         return 0;
 430 }
 431
 432 int ofnode_count_phandle_with_args(ofnode node, const char *list_name,
 433                                    const char *cells_name)
 434 {
 435         if (ofnode_is_np(node))
 436                 return of_count_phandle_with_args(ofnode_to_np(node),
 437                                 list_name, cells_name);
 438         else
 439                 return fdtdec_parse_phandle_with_args(gd->fdt_blob,
 440                                 ofnode_to_offset(node), list_name, cells_name,
 441                                 0, -1, NULL);
 442 }
 443
 444 ofnode ofnode_path(const char *path)
 445 {
 446         if (of_live_active())
 447                 return np_to_ofnode(of_find_node_by_path(path));
 448         else
 449                 return offset_to_ofnode(fdt_path_offset(gd->fdt_blob, path));
 450 }
 451
 452 const void *ofnode_read_chosen_prop(const char *propname, int *sizep)
 453 {
 454         ofnode chosen_node;
 455
 456         chosen_node = ofnode_path("/chosen");
 457
 458         return ofnode_read_prop(chosen_node, propname, sizep);
 459 }
 460
 461 const char *ofnode_read_chosen_string(const char *propname)
 462 {
 463         return ofnode_read_chosen_prop(propname, NULL);
 464 }
 465
 466 ofnode ofnode_get_chosen_node(const char *name)
 467 {
 468         const char *prop;
 469
 470         prop = ofnode_read_chosen_prop(name, NULL);
 471         if (!prop)
 472                 return ofnode_null();
 473
 474         return ofnode_path(prop);
 475 }
 476
 477 static int decode_timing_property(ofnode node, const char *name,
 478                                   struct timing_entry *result)
 479 {
 480         int length, ret = 0;
 481
 482         length = ofnode_read_size(node, name);
 483         if (length < 0) {
 484                 debug("%s: could not find property %s\n",
 485                       ofnode_get_name(node), name);
 486                 return length;
 487         }
 488
 489         if (length == sizeof(u32)) {
 490                 result->typ = ofnode_read_u32_default(node, name, 0);
 491                 result->min = result->typ;
 492                 result->max = result->typ;
 493         } else {
 494                 ret = ofnode_read_u32_array(node, name, &result->min, 3);
 495         }
 496
 497         return ret;
 498 }
 499
 500 int ofnode_decode_display_timing(ofnode parent, int index,
 501                                  struct display_timing *dt)
 502 {
 503         int i;
 504         ofnode timings, node;
 505         u32 val = 0;
 506         int ret = 0;
 507
 508         timings = ofnode_find_subnode(parent, "display-timings");
 509         if (!ofnode_valid(timings))
 510                 return -EINVAL;
 511
 512         i = 0;
 513         ofnode_for_each_subnode(node, timings) {
 514                 if (i++ == index)
 515                         break;
 516         }
 517
 518         if (!ofnode_valid(node))
 519                 return -EINVAL;
 520
 521         memset(dt, 0, sizeof(*dt));
 522
 523         ret |= decode_timing_property(node, "hback-porch", &dt->hback_porch);
 524         ret |= decode_timing_property(node, "hfront-porch", &dt->hfront_porch);
 525         ret |= decode_timing_property(node, "hactive", &dt->hactive);
 526         ret |= decode_timing_property(node, "hsync-len", &dt->hsync_len);
 527         ret |= decode_timing_property(node, "vback-porch", &dt->vback_porch);
 528         ret |= decode_timing_property(node, "vfront-porch", &dt->vfront_porch);
 529         ret |= decode_timing_property(node, "vactive", &dt->vactive);
 530         ret |= decode_timing_property(node, "vsync-len", &dt->vsync_len);
 531         ret |= decode_timing_property(node, "clock-frequency", &dt->pixelclock);
 532
 533         dt->flags = 0;
 534         val = ofnode_read_u32_default(node, "vsync-active", -1);
 535         if (val != -1) {
 536                 dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
 537                                 DISPLAY_FLAGS_VSYNC_LOW;
 538         }
 539         val = ofnode_read_u32_default(node, "hsync-active", -1);
 540         if (val != -1) {
 541                 dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
 542                                 DISPLAY_FLAGS_HSYNC_LOW;
 543         }
 544         val = ofnode_read_u32_default(node, "de-active", -1);
 545         if (val != -1) {
 546                 dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
 547                                 DISPLAY_FLAGS_DE_LOW;
 548         }
 549         val = ofnode_read_u32_default(node, "pixelclk-active", -1);
 550         if (val != -1) {
 551                 dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
 552                                 DISPLAY_FLAGS_PIXDATA_NEGEDGE;
 553         }
 554
 555         if (ofnode_read_bool(node, "interlaced"))
 556                 dt->flags |= DISPLAY_FLAGS_INTERLACED;
 557         if (ofnode_read_bool(node, "doublescan"))
 558                 dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
 559         if (ofnode_read_bool(node, "doubleclk"))
 560                 dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
 561
 562         return ret;
 563 }
 564
 565 const void *ofnode_get_property(ofnode node, const char *propname, int *lenp)
 566 {
 567         if (ofnode_is_np(node))
 568                 return of_get_property(ofnode_to_np(node), propname, lenp);
 569         else
 570                 return fdt_getprop(gd->fdt_blob, ofnode_to_offset(node),
 571                                    propname, lenp);
 572 }
 573
 574 bool ofnode_is_available(ofnode node)
 575 {
 576         if (ofnode_is_np(node))
 577                 return of_device_is_available(ofnode_to_np(node));
 578         else
 579                 return fdtdec_get_is_enabled(gd->fdt_blob,
 580                                              ofnode_to_offset(node));
 581 }
 582
 583 fdt_addr_t ofnode_get_addr_size(ofnode node, const char *property,
 584                                 fdt_size_t *sizep)
 585 {
 586         if (ofnode_is_np(node)) {
 587                 int na, ns;
 588                 int psize;
 589                 const struct device_node *np = ofnode_to_np(node);
 590                 const __be32 *prop = of_get_property(np, property, &psize);
 591
 592                 if (!prop)
 593                         return FDT_ADDR_T_NONE;
 594                 na = of_n_addr_cells(np);
 595                 ns = of_n_size_cells(np);
 596                 *sizep = of_read_number(prop + na, ns);
 597
 598                 if (CONFIG_IS_ENABLED(OF_TRANSLATE) && ns > 0)
 599                         return of_translate_address(np, prop);
 600                 else
 601                         return of_read_number(prop, na);
 602         } else {
 603                 return fdtdec_get_addr_size(gd->fdt_blob,
 604                                             ofnode_to_offset(node), property,
 605                                             sizep);
 606         }
 607 }
 608
 609 const uint8_t *ofnode_read_u8_array_ptr(ofnode node, const char *propname,
 610                                         size_t sz)
 611 {
 612         if (ofnode_is_np(node)) {
 613                 const struct device_node *np = ofnode_to_np(node);
 614                 int psize;
 615                 const __be32 *prop = of_get_property(np, propname, &psize);
 616
 617                 if (!prop || sz != psize)
 618                         return NULL;
 619                 return (uint8_t *)prop;
 620
 621         } else {
 622                 return fdtdec_locate_byte_array(gd->fdt_blob,
 623                                 ofnode_to_offset(node), propname, sz);
 624         }
 625 }
 626
 627 int ofnode_read_pci_addr(ofnode node, enum fdt_pci_space type,
 628                          const char *propname, struct fdt_pci_addr *addr)
 629 {
 630         const fdt32_t *cell;
 631         int len;
 632         int ret = -ENOENT;
 633
 634         debug("%s: %s: ", __func__, propname);
 635
 636         /*
 637          * If we follow the pci bus bindings strictly, we should check
 638          * the value of the node's parent node's #address-cells and
 639          * #size-cells. They need to be 3 and 2 accordingly. However,
 640          * for simplicity we skip the check here.
 641          */
 642         cell = ofnode_get_property(node, propname, &len);
 643         if (!cell)
 644                 goto fail;
 645
 646         if ((len % FDT_PCI_REG_SIZE) == 0) {
 647                 int num = len / FDT_PCI_REG_SIZE;
 648                 int i;
 649
 650                 for (i = 0; i < num; i++) {
 651                         debug("pci address #%d: %08lx %08lx %08lx\n", i,
 652                               (ulong)fdt32_to_cpu(cell[0]),
 653                               (ulong)fdt32_to_cpu(cell[1]),
 654                               (ulong)fdt32_to_cpu(cell[2]));
 655                         if ((fdt32_to_cpu(*cell) & type) == type) {
 656                                 addr->phys_hi = fdt32_to_cpu(cell[0]);
 657                                 addr->phys_mid = fdt32_to_cpu(cell[1]);
 658                                 addr->phys_lo = fdt32_to_cpu(cell[2]);
 659                                 break;
 660                         }
 661
 662                         cell += (FDT_PCI_ADDR_CELLS +
 663                                  FDT_PCI_SIZE_CELLS);
 664                 }
 665
 666                 if (i == num) {
 667                         ret = -ENXIO;
 668                         goto fail;
 669                 }
 670
 671                 return 0;
 672         }
 673
 674         ret = -EINVAL;
 675
 676 fail:
 677         debug("(not found)\n");
 678         return ret;
 679 }
 680
 681 int ofnode_read_pci_vendev(ofnode node, u16 *vendor, u16 *device)
 682 {
 683         const char *list, *end;
 684         int len;
 685
 686         list = ofnode_get_property(node, "compatible", &len);
 687         if (!list)
 688                 return -ENOENT;
 689
 690         end = list + len;
 691         while (list < end) {
 692                 len = strlen(list);
 693                 if (len >= strlen("pciVVVV,DDDD")) {
 694                         char *s = strstr(list, "pci");
 695
 696                         /*
 697                          * check if the string is something like pciVVVV,DDDD.RR
 698                          * or just pciVVVV,DDDD
 699                          */
 700                         if (s && s[7] == ',' &&
 701                             (s[12] == '.' || s[12] == 0)) {
 702                                 s += 3;
 703                                 *vendor = simple_strtol(s, NULL, 16);
 704
 705                                 s += 5;
 706                                 *device = simple_strtol(s, NULL, 16);
 707
 708                                 return 0;
 709                         }
 710                 }
 711                 list += (len + 1);
 712         }
 713
 714         return -ENOENT;
 715 }
 716
 717 int ofnode_read_addr_cells(ofnode node)
 718 {
 719         if (ofnode_is_np(node))
 720                 return of_n_addr_cells(ofnode_to_np(node));
 721         else  /* NOTE: this call should walk up the parent stack */
 722                 return fdt_address_cells(gd->fdt_blob, ofnode_to_offset(node));
 723 }
 724
 725 int ofnode_read_size_cells(ofnode node)
 726 {
 727         if (ofnode_is_np(node))
 728                 return of_n_size_cells(ofnode_to_np(node));
 729         else  /* NOTE: this call should walk up the parent stack */
 730                 return fdt_size_cells(gd->fdt_blob, ofnode_to_offset(node));
 731 }
 732
 733 int ofnode_read_simple_addr_cells(ofnode node)
 734 {
 735         if (ofnode_is_np(node))
 736                 return of_simple_addr_cells(ofnode_to_np(node));
 737         else
 738                 return fdt_address_cells(gd->fdt_blob, ofnode_to_offset(node));
 739 }
 740
 741 int ofnode_read_simple_size_cells(ofnode node)
 742 {
 743         if (ofnode_is_np(node))
 744                 return of_simple_size_cells(ofnode_to_np(node));
 745         else
 746                 return fdt_size_cells(gd->fdt_blob, ofnode_to_offset(node));
 747 }
 748
 749 bool ofnode_pre_reloc(ofnode node)
 750 {
 751 #if defined(CONFIG_SPL_BUILD) || defined(CONFIG_TPL_BUILD)
 752         /* for SPL and TPL the remaining nodes after the fdtgrep 1st pass
 753          * had property dm-pre-reloc or u-boot,dm-spl/tpl.
 754          * They are removed in final dtb (fdtgrep 2nd pass)
 755          */
 756         return true;
 757 #else
 758         if (ofnode_read_bool(node, "u-boot,dm-pre-reloc"))
 759                 return true;
 760         if (ofnode_read_bool(node, "u-boot,dm-pre-proper"))
 761                 return true;
 762
 763         /*
 764          * In regular builds individual spl and tpl handling both
 765          * count as handled pre-relocation for later second init.
 766          */
 767         if (ofnode_read_bool(node, "u-boot,dm-spl") ||
 768             ofnode_read_bool(node, "u-boot,dm-tpl"))
 769                 return true;
 770
 771         return false;
 772 #endif
 773 }
 774
 775 int ofnode_read_resource(ofnode node, uint index, struct resource *res)
 776 {
 777         if (ofnode_is_np(node)) {
 778                 return of_address_to_resource(ofnode_to_np(node), index, res);
 779         } else {
 780                 struct fdt_resource fres;
 781                 int ret;
 782
 783                 ret = fdt_get_resource(gd->fdt_blob, ofnode_to_offset(node),
 784                                        "reg", index, &fres);
 785                 if (ret < 0)
 786                         return -EINVAL;
 787                 memset(res, '\0', sizeof(*res));
 788                 res->start = fres.start;
 789                 res->end = fres.end;
 790
 791                 return 0;
 792         }
 793 }
 794
 795 int ofnode_read_resource_byname(ofnode node, const char *name,
 796                                 struct resource *res)
 797 {
 798         int index;
 799
 800         index = ofnode_stringlist_search(node, "reg-names", name);
 801         if (index < 0)
 802                 return index;
 803
 804         return ofnode_read_resource(node, index, res);
 805 }
 806
 807 u64 ofnode_translate_address(ofnode node, const fdt32_t *in_addr)
 808 {
 809         if (ofnode_is_np(node))
 810                 return of_translate_address(ofnode_to_np(node), in_addr);
 811         else
 812                 return fdt_translate_address(gd->fdt_blob, ofnode_to_offset(node), in_addr);
 813 }
 814
 815 u64 ofnode_translate_dma_address(ofnode node, const fdt32_t *in_addr)
 816 {
 817         if (ofnode_is_np(node))
 818                 return of_translate_dma_address(ofnode_to_np(node), in_addr);
 819         else
 820                 return fdt_translate_dma_address(gd->fdt_blob, ofnode_to_offset(node), in_addr);
 821 }
 822
 823 int ofnode_device_is_compatible(ofnode node, const char *compat)
 824 {
 825         if (ofnode_is_np(node))
 826                 return of_device_is_compatible(ofnode_to_np(node), compat,
 827                                                NULL, NULL);
 828         else
 829                 return !fdt_node_check_compatible(gd->fdt_blob,
 830                                                   ofnode_to_offset(node),
 831                                                   compat);
 832 }
 833
 834 ofnode ofnode_by_compatible(ofnode from, const char *compat)
 835 {
 836         if (of_live_active()) {
 837                 return np_to_ofnode(of_find_compatible_node(
 838                         (struct device_node *)ofnode_to_np(from), NULL,
 839                         compat));
 840         } else {
 841                 return offset_to_ofnode(fdt_node_offset_by_compatible(
 842                                 gd->fdt_blob, ofnode_to_offset(from), compat));
 843         }
 844 }
 845
 846 ofnode ofnode_by_prop_value(ofnode from, const char *propname,
 847                             const void *propval, int proplen)
 848 {
 849         if (of_live_active()) {
 850                 return np_to_ofnode(of_find_node_by_prop_value(
 851                         (struct device_node *)ofnode_to_np(from), propname,
 852                         propval, proplen));
 853         } else {
 854                 return offset_to_ofnode(fdt_node_offset_by_prop_value(
 855                                 gd->fdt_blob, ofnode_to_offset(from),
 856                                 propname, propval, proplen));
 857         }
 858 }
 859
 860 int ofnode_write_prop(ofnode node, const char *propname, int len,
 861                       const void *value)
 862 {
 863         const struct device_node *np = ofnode_to_np(node);
 864         struct property *pp;
 865         struct property *pp_last = NULL;
 866         struct property *new;
 867
 868         if (!of_live_active())
 869                 return -ENOSYS;
 870
 871         if (!np)
 872                 return -EINVAL;
 873
 874         for (pp = np->properties; pp; pp = pp->next) {
 875                 if (strcmp(pp->name, propname) == 0) {
 876                         /* Property exists -> change value */
 877                         pp->value = (void *)value;
 878                         pp->length = len;
 879                         return 0;
 880                 }
 881                 pp_last = pp;
 882         }
 883
 884         if (!pp_last)
 885                 return -ENOENT;
 886
 887         /* Property does not exist -> append new property */
 888         new = malloc(sizeof(struct property));
 889         if (!new)
 890                 return -ENOMEM;
 891
 892         new->name = strdup(propname);
 893         if (!new->name) {
 894                 free(new);
 895                 return -ENOMEM;
 896         }
 897
 898         new->value = (void *)value;
 899         new->length = len;
 900         new->next = NULL;
 901
 902         pp_last->next = new;
 903
 904         return 0;
 905 }
 906
 907 int ofnode_write_string(ofnode node, const char *propname, const char *value)
 908 {
 909         if (!of_live_active())
 910                 return -ENOSYS;
 911
 912         assert(ofnode_valid(node));
 913
 914         debug("%s: %s = %s", __func__, propname, value);
 915
 916         return ofnode_write_prop(node, propname, strlen(value) + 1, value);
 917 }
 918
 919 int ofnode_set_enabled(ofnode node, bool value)
 920 {
 921         if (!of_live_active())
 922                 return -ENOSYS;
 923
 924         assert(ofnode_valid(node));
 925
 926         if (value)
 927                 return ofnode_write_string(node, "status", "okay");
 928         else
 929                 return ofnode_write_string(node, "status", "disabled");
 930 }