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