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 <linux/libfdt.h>
  12 #include <dm/of_access.h>
  13 #include <dm/of_addr.h>
  14 #include <dm/ofnode.h>
  15 #include <linux/err.h>
  16 #include <linux/ioport.h>
  17
  18 int ofnode_read_u32(ofnode node, const char *propname, u32 *outp)
  19 {
  20         assert(ofnode_valid(node));
  21         debug("%s: %s: ", __func__, propname);
  22
  23         if (ofnode_is_np(node)) {
  24                 return of_read_u32(ofnode_to_np(node), propname, outp);
  25         } else {
  26                 const fdt32_t *cell;
  27                 int len;
  28
  29                 cell = fdt_getprop(gd->fdt_blob, ofnode_to_offset(node),
  30                                    propname, &len);
  31                 if (!cell || len < sizeof(int)) {
  32                         debug("(not found)\n");
  33                         return -EINVAL;
  34                 }
  35                 *outp = fdt32_to_cpu(cell[0]);
  36         }
  37         debug("%#x (%d)\n", *outp, *outp);
  38
  39         return 0;
  40 }
  41
  42 int ofnode_read_u32_default(ofnode node, const char *propname, u32 def)
  43 {
  44         assert(ofnode_valid(node));
  45         ofnode_read_u32(node, propname, &def);
  46
  47         return def;
  48 }
  49
  50 int ofnode_read_s32_default(ofnode node, const char *propname, s32 def)
  51 {
  52         assert(ofnode_valid(node));
  53         ofnode_read_u32(node, propname, (u32 *)&def);
  54
  55         return def;
  56 }
  57
  58 int ofnode_read_u64(ofnode node, const char *propname, u64 *outp)
  59 {
  60         const fdt64_t *cell;
  61         int len;
  62
  63         assert(ofnode_valid(node));
  64         debug("%s: %s: ", __func__, propname);
  65
  66         if (ofnode_is_np(node))
  67                 return of_read_u64(ofnode_to_np(node), propname, outp);
  68
  69         cell = fdt_getprop(gd->fdt_blob, ofnode_to_offset(node), propname,
  70                            &len);
  71         if (!cell || len < sizeof(*cell)) {
  72                 debug("(not found)\n");
  73                 return -EINVAL;
  74         }
  75         *outp = fdt64_to_cpu(cell[0]);
  76         debug("%#llx (%lld)\n", (unsigned long long)*outp,
  77               (unsigned long long)*outp);
  78
  79         return 0;
  80 }
  81
  82 int ofnode_read_u64_default(ofnode node, const char *propname, u64 def)
  83 {
  84         assert(ofnode_valid(node));
  85         ofnode_read_u64(node, propname, &def);
  86
  87         return def;
  88 }
  89
  90 bool ofnode_read_bool(ofnode node, const char *propname)
  91 {
  92         const void *prop;
  93
  94         assert(ofnode_valid(node));
  95         debug("%s: %s: ", __func__, propname);
  96
  97         prop = ofnode_get_property(node, propname, NULL);
  98
  99         debug("%s\n", prop ? "true" : "false");
 100
 101         return prop ? true : false;
 102 }
 103
 104 const char *ofnode_read_string(ofnode node, const char *propname)
 105 {
 106         const char *str = NULL;
 107         int len = -1;
 108
 109         assert(ofnode_valid(node));
 110         debug("%s: %s: ", __func__, propname);
 111
 112         if (ofnode_is_np(node)) {
 113                 struct property *prop = of_find_property(
 114                                 ofnode_to_np(node), propname, NULL);
 115
 116                 if (prop) {
 117                         str = prop->value;
 118                         len = prop->length;
 119                 }
 120         } else {
 121                 str = fdt_getprop(gd->fdt_blob, ofnode_to_offset(node),
 122                                   propname, &len);
 123         }
 124         if (!str) {
 125                 debug("<not found>\n");
 126                 return NULL;
 127         }
 128         if (strnlen(str, len) >= len) {
 129                 debug("<invalid>\n");
 130                 return NULL;
 131         }
 132         debug("%s\n", str);
 133
 134         return str;
 135 }
 136
 137 ofnode ofnode_find_subnode(ofnode node, const char *subnode_name)
 138 {
 139         ofnode subnode;
 140
 141         assert(ofnode_valid(node));
 142         debug("%s: %s: ", __func__, subnode_name);
 143
 144         if (ofnode_is_np(node)) {
 145                 const struct device_node *np = ofnode_to_np(node);
 146
 147                 for (np = np->child; np; np = np->sibling) {
 148                         if (!strcmp(subnode_name, np->name))
 149                                 break;
 150                 }
 151                 subnode = np_to_ofnode(np);
 152         } else {
 153                 int ooffset = fdt_subnode_offset(gd->fdt_blob,
 154                                 ofnode_to_offset(node), subnode_name);
 155                 subnode = offset_to_ofnode(ooffset);
 156         }
 157         debug("%s\n", ofnode_valid(subnode) ?
 158               ofnode_get_name(subnode) : "<none>");
 159
 160         return subnode;
 161 }
 162
 163 int ofnode_read_u32_array(ofnode node, const char *propname,
 164                           u32 *out_values, size_t sz)
 165 {
 166         assert(ofnode_valid(node));
 167         debug("%s: %s: ", __func__, propname);
 168
 169         if (ofnode_is_np(node)) {
 170                 return of_read_u32_array(ofnode_to_np(node), propname,
 171                                          out_values, sz);
 172         } else {
 173                 return fdtdec_get_int_array(gd->fdt_blob,
 174                                             ofnode_to_offset(node), propname,
 175                                             out_values, sz);
 176         }
 177 }
 178
 179 ofnode ofnode_first_subnode(ofnode node)
 180 {
 181         assert(ofnode_valid(node));
 182         if (ofnode_is_np(node))
 183                 return np_to_ofnode(node.np->child);
 184
 185         return offset_to_ofnode(
 186                 fdt_first_subnode(gd->fdt_blob, ofnode_to_offset(node)));
 187 }
 188
 189 ofnode ofnode_next_subnode(ofnode node)
 190 {
 191         assert(ofnode_valid(node));
 192         if (ofnode_is_np(node))
 193                 return np_to_ofnode(node.np->sibling);
 194
 195         return offset_to_ofnode(
 196                 fdt_next_subnode(gd->fdt_blob, ofnode_to_offset(node)));
 197 }
 198
 199 ofnode ofnode_get_parent(ofnode node)
 200 {
 201         ofnode parent;
 202
 203         assert(ofnode_valid(node));
 204         if (ofnode_is_np(node))
 205                 parent = np_to_ofnode(of_get_parent(ofnode_to_np(node)));
 206         else
 207                 parent.of_offset = fdt_parent_offset(gd->fdt_blob,
 208                                                      ofnode_to_offset(node));
 209
 210         return parent;
 211 }
 212
 213 const char *ofnode_get_name(ofnode node)
 214 {
 215         assert(ofnode_valid(node));
 216         if (ofnode_is_np(node))
 217                 return strrchr(node.np->full_name, '/') + 1;
 218
 219         return fdt_get_name(gd->fdt_blob, ofnode_to_offset(node), NULL);
 220 }
 221
 222 ofnode ofnode_get_by_phandle(uint phandle)
 223 {
 224         ofnode node;
 225
 226         if (of_live_active())
 227                 node = np_to_ofnode(of_find_node_by_phandle(phandle));
 228         else
 229                 node.of_offset = fdt_node_offset_by_phandle(gd->fdt_blob,
 230                                                             phandle);
 231
 232         return node;
 233 }
 234
 235 int ofnode_read_size(ofnode node, const char *propname)
 236 {
 237         int len;
 238
 239         if (ofnode_is_np(node)) {
 240                 struct property *prop = of_find_property(
 241                                 ofnode_to_np(node), propname, NULL);
 242
 243                 if (prop)
 244                         return prop->length;
 245         } else {
 246                 if (fdt_getprop(gd->fdt_blob, ofnode_to_offset(node), propname,
 247                                 &len))
 248                         return len;
 249         }
 250
 251         return -EINVAL;
 252 }
 253
 254 fdt_addr_t ofnode_get_addr_index(ofnode node, int index)
 255 {
 256         if (ofnode_is_np(node)) {
 257                 const __be32 *prop_val;
 258                 uint flags;
 259                 u64 size;
 260                 int na;
 261                 int ns;
 262
 263                 prop_val = of_get_address(ofnode_to_np(node), index, &size,
 264                                           &flags);
 265                 if (!prop_val)
 266                         return FDT_ADDR_T_NONE;
 267
 268                 ns = of_n_size_cells(ofnode_to_np(node));
 269
 270                 if (IS_ENABLED(CONFIG_OF_TRANSLATE) && ns > 0) {
 271                         return of_translate_address(ofnode_to_np(node), prop_val);
 272                 } else {
 273                         na = of_n_addr_cells(ofnode_to_np(node));
 274                         return of_read_number(prop_val, na);
 275                 }
 276         } else {
 277                 return fdt_get_base_address(gd->fdt_blob,
 278                                             ofnode_to_offset(node));
 279         }
 280
 281         return FDT_ADDR_T_NONE;
 282 }
 283
 284 fdt_addr_t ofnode_get_addr(ofnode node)
 285 {
 286         return ofnode_get_addr_index(node, 0);
 287 }
 288
 289 int ofnode_stringlist_search(ofnode node, const char *property,
 290                              const char *string)
 291 {
 292         if (ofnode_is_np(node)) {
 293                 return of_property_match_string(ofnode_to_np(node),
 294                                                 property, string);
 295         } else {
 296                 int ret;
 297
 298                 ret = fdt_stringlist_search(gd->fdt_blob,
 299                                             ofnode_to_offset(node), property,
 300                                             string);
 301                 if (ret == -FDT_ERR_NOTFOUND)
 302                         return -ENODATA;
 303                 else if (ret < 0)
 304                         return -EINVAL;
 305
 306                 return ret;
 307         }
 308 }
 309
 310 int ofnode_read_string_index(ofnode node, const char *property, int index,
 311                              const char **outp)
 312 {
 313         if (ofnode_is_np(node)) {
 314                 return of_property_read_string_index(ofnode_to_np(node),
 315                                                      property, index, outp);
 316         } else {
 317                 int len;
 318
 319                 *outp = fdt_stringlist_get(gd->fdt_blob, ofnode_to_offset(node),
 320                                            property, index, &len);
 321                 if (len < 0)
 322                         return -EINVAL;
 323                 return 0;
 324         }
 325 }
 326
 327 int ofnode_read_string_count(ofnode node, const char *property)
 328 {
 329         if (ofnode_is_np(node)) {
 330                 return of_property_count_strings(ofnode_to_np(node), property);
 331         } else {
 332                 return fdt_stringlist_count(gd->fdt_blob,
 333                                             ofnode_to_offset(node), property);
 334         }
 335 }
 336
 337 static void ofnode_from_fdtdec_phandle_args(struct fdtdec_phandle_args *in,
 338                                             struct ofnode_phandle_args *out)
 339 {
 340         assert(OF_MAX_PHANDLE_ARGS == MAX_PHANDLE_ARGS);
 341         out->node = offset_to_ofnode(in->node);
 342         out->args_count = in->args_count;
 343         memcpy(out->args, in->args, sizeof(out->args));
 344 }
 345
 346 static void ofnode_from_of_phandle_args(struct of_phandle_args *in,
 347                                         struct ofnode_phandle_args *out)
 348 {
 349         assert(OF_MAX_PHANDLE_ARGS == MAX_PHANDLE_ARGS);
 350         out->node = np_to_ofnode(in->np);
 351         out->args_count = in->args_count;
 352         memcpy(out->args, in->args, sizeof(out->args));
 353 }
 354
 355 int ofnode_parse_phandle_with_args(ofnode node, const char *list_name,
 356                                    const char *cells_name, int cell_count,
 357                                    int index,
 358                                    struct ofnode_phandle_args *out_args)
 359 {
 360         if (ofnode_is_np(node)) {
 361                 struct of_phandle_args args;
 362                 int ret;
 363
 364                 ret = of_parse_phandle_with_args(ofnode_to_np(node),
 365                                                  list_name, cells_name, index,
 366                                                  &args);
 367                 if (ret)
 368                         return ret;
 369                 ofnode_from_of_phandle_args(&args, out_args);
 370         } else {
 371                 struct fdtdec_phandle_args args;
 372                 int ret;
 373
 374                 ret = fdtdec_parse_phandle_with_args(gd->fdt_blob,
 375                                                      ofnode_to_offset(node),
 376                                                      list_name, cells_name,
 377                                                      cell_count, index, &args);
 378                 if (ret)
 379                         return ret;
 380                 ofnode_from_fdtdec_phandle_args(&args, out_args);
 381         }
 382
 383         return 0;
 384 }
 385
 386 int ofnode_count_phandle_with_args(ofnode node, const char *list_name,
 387                                    const char *cells_name)
 388 {
 389         if (ofnode_is_np(node))
 390                 return of_count_phandle_with_args(ofnode_to_np(node),
 391                                 list_name, cells_name);
 392         else
 393                 return fdtdec_parse_phandle_with_args(gd->fdt_blob,
 394                                 ofnode_to_offset(node), list_name, cells_name,
 395                                 0, -1, NULL);
 396 }
 397
 398 ofnode ofnode_path(const char *path)
 399 {
 400         if (of_live_active())
 401                 return np_to_ofnode(of_find_node_by_path(path));
 402         else
 403                 return offset_to_ofnode(fdt_path_offset(gd->fdt_blob, path));
 404 }
 405
 406 const char *ofnode_get_chosen_prop(const char *name)
 407 {
 408         ofnode chosen_node;
 409
 410         chosen_node = ofnode_path("/chosen");
 411
 412         return ofnode_read_string(chosen_node, name);
 413 }
 414
 415 ofnode ofnode_get_chosen_node(const char *name)
 416 {
 417         const char *prop;
 418
 419         prop = ofnode_get_chosen_prop(name);
 420         if (!prop)
 421                 return ofnode_null();
 422
 423         return ofnode_path(prop);
 424 }
 425
 426 static int decode_timing_property(ofnode node, const char *name,
 427                                   struct timing_entry *result)
 428 {
 429         int length, ret = 0;
 430
 431         length = ofnode_read_size(node, name);
 432         if (length < 0) {
 433                 debug("%s: could not find property %s\n",
 434                       ofnode_get_name(node), name);
 435                 return length;
 436         }
 437
 438         if (length == sizeof(u32)) {
 439                 result->typ = ofnode_read_u32_default(node, name, 0);
 440                 result->min = result->typ;
 441                 result->max = result->typ;
 442         } else {
 443                 ret = ofnode_read_u32_array(node, name, &result->min, 3);
 444         }
 445
 446         return ret;
 447 }
 448
 449 int ofnode_decode_display_timing(ofnode parent, int index,
 450                                  struct display_timing *dt)
 451 {
 452         int i;
 453         ofnode timings, node;
 454         u32 val = 0;
 455         int ret = 0;
 456
 457         timings = ofnode_find_subnode(parent, "display-timings");
 458         if (!ofnode_valid(timings))
 459                 return -EINVAL;
 460
 461         i = 0;
 462         ofnode_for_each_subnode(node, timings) {
 463                 if (i++ == index)
 464                         break;
 465         }
 466
 467         if (!ofnode_valid(node))
 468                 return -EINVAL;
 469
 470         memset(dt, 0, sizeof(*dt));
 471
 472         ret |= decode_timing_property(node, "hback-porch", &dt->hback_porch);
 473         ret |= decode_timing_property(node, "hfront-porch", &dt->hfront_porch);
 474         ret |= decode_timing_property(node, "hactive", &dt->hactive);
 475         ret |= decode_timing_property(node, "hsync-len", &dt->hsync_len);
 476         ret |= decode_timing_property(node, "vback-porch", &dt->vback_porch);
 477         ret |= decode_timing_property(node, "vfront-porch", &dt->vfront_porch);
 478         ret |= decode_timing_property(node, "vactive", &dt->vactive);
 479         ret |= decode_timing_property(node, "vsync-len", &dt->vsync_len);
 480         ret |= decode_timing_property(node, "clock-frequency", &dt->pixelclock);
 481
 482         dt->flags = 0;
 483         val = ofnode_read_u32_default(node, "vsync-active", -1);
 484         if (val != -1) {
 485                 dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
 486                                 DISPLAY_FLAGS_VSYNC_LOW;
 487         }
 488         val = ofnode_read_u32_default(node, "hsync-active", -1);
 489         if (val != -1) {
 490                 dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
 491                                 DISPLAY_FLAGS_HSYNC_LOW;
 492         }
 493         val = ofnode_read_u32_default(node, "de-active", -1);
 494         if (val != -1) {
 495                 dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
 496                                 DISPLAY_FLAGS_DE_LOW;
 497         }
 498         val = ofnode_read_u32_default(node, "pixelclk-active", -1);
 499         if (val != -1) {
 500                 dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
 501                                 DISPLAY_FLAGS_PIXDATA_NEGEDGE;
 502         }
 503
 504         if (ofnode_read_bool(node, "interlaced"))
 505                 dt->flags |= DISPLAY_FLAGS_INTERLACED;
 506         if (ofnode_read_bool(node, "doublescan"))
 507                 dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
 508         if (ofnode_read_bool(node, "doubleclk"))
 509                 dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
 510
 511         return ret;
 512 }
 513
 514 const void *ofnode_get_property(ofnode node, const char *propname, int *lenp)
 515 {
 516         if (ofnode_is_np(node))
 517                 return of_get_property(ofnode_to_np(node), propname, lenp);
 518         else
 519                 return fdt_getprop(gd->fdt_blob, ofnode_to_offset(node),
 520                                    propname, lenp);
 521 }
 522
 523 bool ofnode_is_available(ofnode node)
 524 {
 525         if (ofnode_is_np(node))
 526                 return of_device_is_available(ofnode_to_np(node));
 527         else
 528                 return fdtdec_get_is_enabled(gd->fdt_blob,
 529                                              ofnode_to_offset(node));
 530 }
 531
 532 fdt_addr_t ofnode_get_addr_size(ofnode node, const char *property,
 533                                 fdt_size_t *sizep)
 534 {
 535         if (ofnode_is_np(node)) {
 536                 int na, ns;
 537                 int psize;
 538                 const struct device_node *np = ofnode_to_np(node);
 539                 const __be32 *prop = of_get_property(np, property, &psize);
 540
 541                 if (!prop)
 542                         return FDT_ADDR_T_NONE;
 543                 na = of_n_addr_cells(np);
 544                 ns = of_n_addr_cells(np);
 545                 *sizep = of_read_number(prop + na, ns);
 546                 return of_read_number(prop, na);
 547         } else {
 548                 return fdtdec_get_addr_size(gd->fdt_blob,
 549                                             ofnode_to_offset(node), property,
 550                                             sizep);
 551         }
 552 }
 553
 554 const uint8_t *ofnode_read_u8_array_ptr(ofnode node, const char *propname,
 555                                         size_t sz)
 556 {
 557         if (ofnode_is_np(node)) {
 558                 const struct device_node *np = ofnode_to_np(node);
 559                 int psize;
 560                 const __be32 *prop = of_get_property(np, propname, &psize);
 561
 562                 if (!prop || sz != psize)
 563                         return NULL;
 564                 return (uint8_t *)prop;
 565
 566         } else {
 567                 return fdtdec_locate_byte_array(gd->fdt_blob,
 568                                 ofnode_to_offset(node), propname, sz);
 569         }
 570 }
 571
 572 int ofnode_read_pci_addr(ofnode node, enum fdt_pci_space type,
 573                          const char *propname, struct fdt_pci_addr *addr)
 574 {
 575         const fdt32_t *cell;
 576         int len;
 577         int ret = -ENOENT;
 578
 579         debug("%s: %s: ", __func__, propname);
 580
 581         /*
 582          * If we follow the pci bus bindings strictly, we should check
 583          * the value of the node's parent node's #address-cells and
 584          * #size-cells. They need to be 3 and 2 accordingly. However,
 585          * for simplicity we skip the check here.
 586          */
 587         cell = ofnode_get_property(node, propname, &len);
 588         if (!cell)
 589                 goto fail;
 590
 591         if ((len % FDT_PCI_REG_SIZE) == 0) {
 592                 int num = len / FDT_PCI_REG_SIZE;
 593                 int i;
 594
 595                 for (i = 0; i < num; i++) {
 596                         debug("pci address #%d: %08lx %08lx %08lx\n", i,
 597                               (ulong)fdt32_to_cpu(cell[0]),
 598                               (ulong)fdt32_to_cpu(cell[1]),
 599                               (ulong)fdt32_to_cpu(cell[2]));
 600                         if ((fdt32_to_cpu(*cell) & type) == type) {
 601                                 addr->phys_hi = fdt32_to_cpu(cell[0]);
 602                                 addr->phys_mid = fdt32_to_cpu(cell[1]);
 603                                 addr->phys_lo = fdt32_to_cpu(cell[1]);
 604                                 break;
 605                         }
 606
 607                         cell += (FDT_PCI_ADDR_CELLS +
 608                                  FDT_PCI_SIZE_CELLS);
 609                 }
 610
 611                 if (i == num) {
 612                         ret = -ENXIO;
 613                         goto fail;
 614                 }
 615
 616                 return 0;
 617         }
 618
 619         ret = -EINVAL;
 620
 621 fail:
 622         debug("(not found)\n");
 623         return ret;
 624 }
 625
 626 int ofnode_read_addr_cells(ofnode node)
 627 {
 628         if (ofnode_is_np(node))
 629                 return of_n_addr_cells(ofnode_to_np(node));
 630         else  /* NOTE: this call should walk up the parent stack */
 631                 return fdt_address_cells(gd->fdt_blob, ofnode_to_offset(node));
 632 }
 633
 634 int ofnode_read_size_cells(ofnode node)
 635 {
 636         if (ofnode_is_np(node))
 637                 return of_n_size_cells(ofnode_to_np(node));
 638         else  /* NOTE: this call should walk up the parent stack */
 639                 return fdt_size_cells(gd->fdt_blob, ofnode_to_offset(node));
 640 }
 641
 642 int ofnode_read_simple_addr_cells(ofnode node)
 643 {
 644         if (ofnode_is_np(node))
 645                 return of_simple_addr_cells(ofnode_to_np(node));
 646         else
 647                 return fdt_address_cells(gd->fdt_blob, ofnode_to_offset(node));
 648 }
 649
 650 int ofnode_read_simple_size_cells(ofnode node)
 651 {
 652         if (ofnode_is_np(node))
 653                 return of_simple_size_cells(ofnode_to_np(node));
 654         else
 655                 return fdt_size_cells(gd->fdt_blob, ofnode_to_offset(node));
 656 }
 657
 658 bool ofnode_pre_reloc(ofnode node)
 659 {
 660         if (ofnode_read_bool(node, "u-boot,dm-pre-reloc"))
 661                 return true;
 662
 663 #ifdef CONFIG_TPL_BUILD
 664         if (ofnode_read_bool(node, "u-boot,dm-tpl"))
 665                 return true;
 666 #elif defined(CONFIG_SPL_BUILD)
 667         if (ofnode_read_bool(node, "u-boot,dm-spl"))
 668                 return true;
 669 #else
 670         /*
 671          * In regular builds individual spl and tpl handling both
 672          * count as handled pre-relocation for later second init.
 673          */
 674         if (ofnode_read_bool(node, "u-boot,dm-spl") ||
 675             ofnode_read_bool(node, "u-boot,dm-tpl"))
 676                 return true;
 677 #endif
 678
 679         return false;
 680 }
 681
 682 int ofnode_read_resource(ofnode node, uint index, struct resource *res)
 683 {
 684         if (ofnode_is_np(node)) {
 685                 return of_address_to_resource(ofnode_to_np(node), index, res);
 686         } else {
 687                 struct fdt_resource fres;
 688                 int ret;
 689
 690                 ret = fdt_get_resource(gd->fdt_blob, ofnode_to_offset(node),
 691                                        "reg", index, &fres);
 692                 if (ret < 0)
 693                         return -EINVAL;
 694                 memset(res, '\0', sizeof(*res));
 695                 res->start = fres.start;
 696                 res->end = fres.end;
 697
 698                 return 0;
 699         }
 700 }
 701
 702 int ofnode_read_resource_byname(ofnode node, const char *name,
 703                                 struct resource *res)
 704 {
 705         int index;
 706
 707         index = ofnode_stringlist_search(node, "reg-names", name);
 708         if (index < 0)
 709                 return index;
 710
 711         return ofnode_read_resource(node, index, res);
 712 }
 713
 714 u64 ofnode_translate_address(ofnode node, const fdt32_t *in_addr)
 715 {
 716         if (ofnode_is_np(node))
 717                 return of_translate_address(ofnode_to_np(node), in_addr);
 718         else
 719                 return fdt_translate_address(gd->fdt_blob, ofnode_to_offset(node), in_addr);
 720 }
 721
 722 int ofnode_device_is_compatible(ofnode node, const char *compat)
 723 {
 724         if (ofnode_is_np(node))
 725                 return of_device_is_compatible(ofnode_to_np(node), compat,
 726                                                NULL, NULL);
 727         else
 728                 return !fdt_node_check_compatible(gd->fdt_blob,
 729                                                   ofnode_to_offset(node),
 730                                                   compat);
 731 }
 732
 733 ofnode ofnode_by_compatible(ofnode from, const char *compat)
 734 {
 735         if (of_live_active()) {
 736                 return np_to_ofnode(of_find_compatible_node(
 737                         (struct device_node *)ofnode_to_np(from), NULL,
 738                         compat));
 739         } else {
 740                 return offset_to_ofnode(fdt_node_offset_by_compatible(
 741                                 gd->fdt_blob, ofnode_to_offset(from), compat));
 742         }
 743 }