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 int ofnode_get_first_property(ofnode node, struct ofprop *prop)
 575 {
 576         prop->node = node;
 577
 578         if (ofnode_is_np(node)) {
 579                 prop->prop = of_get_first_property(ofnode_to_np(prop->node));
 580                 if (!prop->prop)
 581                         return -FDT_ERR_NOTFOUND;
 582         } else {
 583                 prop->offset =
 584                         fdt_first_property_offset(gd->fdt_blob,
 585                                                   ofnode_to_offset(prop->node));
 586                 if (prop->offset < 0)
 587                         return prop->offset;
 588         }
 589
 590         return 0;
 591 }
 592
 593 int ofnode_get_next_property(struct ofprop *prop)
 594 {
 595         if (ofnode_is_np(prop->node)) {
 596                 prop->prop = of_get_next_property(ofnode_to_np(prop->node),
 597                                                   prop->prop);
 598                 if (!prop->prop)
 599                         return -FDT_ERR_NOTFOUND;
 600         } else {
 601                 prop->offset = fdt_next_property_offset(gd->fdt_blob,
 602                                                         prop->offset);
 603                 if (prop->offset  < 0)
 604                         return prop->offset;
 605         }
 606
 607         return 0;
 608 }
 609
 610 const void *ofnode_get_property_by_prop(const struct ofprop *prop,
 611                                         const char **propname, int *lenp)
 612 {
 613         if (ofnode_is_np(prop->node))
 614                 return of_get_property_by_prop(ofnode_to_np(prop->node),
 615                                                prop->prop, propname, lenp);
 616         else
 617                 return fdt_getprop_by_offset(gd->fdt_blob,
 618                                              prop->offset,
 619                                              propname, lenp);
 620 }
 621
 622 bool ofnode_is_available(ofnode node)
 623 {
 624         if (ofnode_is_np(node))
 625                 return of_device_is_available(ofnode_to_np(node));
 626         else
 627                 return fdtdec_get_is_enabled(gd->fdt_blob,
 628                                              ofnode_to_offset(node));
 629 }
 630
 631 fdt_addr_t ofnode_get_addr_size(ofnode node, const char *property,
 632                                 fdt_size_t *sizep)
 633 {
 634         if (ofnode_is_np(node)) {
 635                 int na, ns;
 636                 int psize;
 637                 const struct device_node *np = ofnode_to_np(node);
 638                 const __be32 *prop = of_get_property(np, property, &psize);
 639
 640                 if (!prop)
 641                         return FDT_ADDR_T_NONE;
 642                 na = of_n_addr_cells(np);
 643                 ns = of_n_size_cells(np);
 644                 *sizep = of_read_number(prop + na, ns);
 645
 646                 if (CONFIG_IS_ENABLED(OF_TRANSLATE) && ns > 0)
 647                         return of_translate_address(np, prop);
 648                 else
 649                         return of_read_number(prop, na);
 650         } else {
 651                 return fdtdec_get_addr_size(gd->fdt_blob,
 652                                             ofnode_to_offset(node), property,
 653                                             sizep);
 654         }
 655 }
 656
 657 const uint8_t *ofnode_read_u8_array_ptr(ofnode node, const char *propname,
 658                                         size_t sz)
 659 {
 660         if (ofnode_is_np(node)) {
 661                 const struct device_node *np = ofnode_to_np(node);
 662                 int psize;
 663                 const __be32 *prop = of_get_property(np, propname, &psize);
 664
 665                 if (!prop || sz != psize)
 666                         return NULL;
 667                 return (uint8_t *)prop;
 668
 669         } else {
 670                 return fdtdec_locate_byte_array(gd->fdt_blob,
 671                                 ofnode_to_offset(node), propname, sz);
 672         }
 673 }
 674
 675 int ofnode_read_pci_addr(ofnode node, enum fdt_pci_space type,
 676                          const char *propname, struct fdt_pci_addr *addr)
 677 {
 678         const fdt32_t *cell;
 679         int len;
 680         int ret = -ENOENT;
 681
 682         debug("%s: %s: ", __func__, propname);
 683
 684         /*
 685          * If we follow the pci bus bindings strictly, we should check
 686          * the value of the node's parent node's #address-cells and
 687          * #size-cells. They need to be 3 and 2 accordingly. However,
 688          * for simplicity we skip the check here.
 689          */
 690         cell = ofnode_get_property(node, propname, &len);
 691         if (!cell)
 692                 goto fail;
 693
 694         if ((len % FDT_PCI_REG_SIZE) == 0) {
 695                 int num = len / FDT_PCI_REG_SIZE;
 696                 int i;
 697
 698                 for (i = 0; i < num; i++) {
 699                         debug("pci address #%d: %08lx %08lx %08lx\n", i,
 700                               (ulong)fdt32_to_cpu(cell[0]),
 701                               (ulong)fdt32_to_cpu(cell[1]),
 702                               (ulong)fdt32_to_cpu(cell[2]));
 703                         if ((fdt32_to_cpu(*cell) & type) == type) {
 704                                 addr->phys_hi = fdt32_to_cpu(cell[0]);
 705                                 addr->phys_mid = fdt32_to_cpu(cell[1]);
 706                                 addr->phys_lo = fdt32_to_cpu(cell[2]);
 707                                 break;
 708                         }
 709
 710                         cell += (FDT_PCI_ADDR_CELLS +
 711                                  FDT_PCI_SIZE_CELLS);
 712                 }
 713
 714                 if (i == num) {
 715                         ret = -ENXIO;
 716                         goto fail;
 717                 }
 718
 719                 return 0;
 720         }
 721
 722         ret = -EINVAL;
 723
 724 fail:
 725         debug("(not found)\n");
 726         return ret;
 727 }
 728
 729 int ofnode_read_pci_vendev(ofnode node, u16 *vendor, u16 *device)
 730 {
 731         const char *list, *end;
 732         int len;
 733
 734         list = ofnode_get_property(node, "compatible", &len);
 735         if (!list)
 736                 return -ENOENT;
 737
 738         end = list + len;
 739         while (list < end) {
 740                 len = strlen(list);
 741                 if (len >= strlen("pciVVVV,DDDD")) {
 742                         char *s = strstr(list, "pci");
 743
 744                         /*
 745                          * check if the string is something like pciVVVV,DDDD.RR
 746                          * or just pciVVVV,DDDD
 747                          */
 748                         if (s && s[7] == ',' &&
 749                             (s[12] == '.' || s[12] == 0)) {
 750                                 s += 3;
 751                                 *vendor = simple_strtol(s, NULL, 16);
 752
 753                                 s += 5;
 754                                 *device = simple_strtol(s, NULL, 16);
 755
 756                                 return 0;
 757                         }
 758                 }
 759                 list += (len + 1);
 760         }
 761
 762         return -ENOENT;
 763 }
 764
 765 int ofnode_read_addr_cells(ofnode node)
 766 {
 767         if (ofnode_is_np(node))
 768                 return of_n_addr_cells(ofnode_to_np(node));
 769         else  /* NOTE: this call should walk up the parent stack */
 770                 return fdt_address_cells(gd->fdt_blob, ofnode_to_offset(node));
 771 }
 772
 773 int ofnode_read_size_cells(ofnode node)
 774 {
 775         if (ofnode_is_np(node))
 776                 return of_n_size_cells(ofnode_to_np(node));
 777         else  /* NOTE: this call should walk up the parent stack */
 778                 return fdt_size_cells(gd->fdt_blob, ofnode_to_offset(node));
 779 }
 780
 781 int ofnode_read_simple_addr_cells(ofnode node)
 782 {
 783         if (ofnode_is_np(node))
 784                 return of_simple_addr_cells(ofnode_to_np(node));
 785         else
 786                 return fdt_address_cells(gd->fdt_blob, ofnode_to_offset(node));
 787 }
 788
 789 int ofnode_read_simple_size_cells(ofnode node)
 790 {
 791         if (ofnode_is_np(node))
 792                 return of_simple_size_cells(ofnode_to_np(node));
 793         else
 794                 return fdt_size_cells(gd->fdt_blob, ofnode_to_offset(node));
 795 }
 796
 797 bool ofnode_pre_reloc(ofnode node)
 798 {
 799 #if defined(CONFIG_SPL_BUILD) || defined(CONFIG_TPL_BUILD)
 800         /* for SPL and TPL the remaining nodes after the fdtgrep 1st pass
 801          * had property dm-pre-reloc or u-boot,dm-spl/tpl.
 802          * They are removed in final dtb (fdtgrep 2nd pass)
 803          */
 804         return true;
 805 #else
 806         if (ofnode_read_bool(node, "u-boot,dm-pre-reloc"))
 807                 return true;
 808         if (ofnode_read_bool(node, "u-boot,dm-pre-proper"))
 809                 return true;
 810
 811         /*
 812          * In regular builds individual spl and tpl handling both
 813          * count as handled pre-relocation for later second init.
 814          */
 815         if (ofnode_read_bool(node, "u-boot,dm-spl") ||
 816             ofnode_read_bool(node, "u-boot,dm-tpl"))
 817                 return true;
 818
 819         return false;
 820 #endif
 821 }
 822
 823 int ofnode_read_resource(ofnode node, uint index, struct resource *res)
 824 {
 825         if (ofnode_is_np(node)) {
 826                 return of_address_to_resource(ofnode_to_np(node), index, res);
 827         } else {
 828                 struct fdt_resource fres;
 829                 int ret;
 830
 831                 ret = fdt_get_resource(gd->fdt_blob, ofnode_to_offset(node),
 832                                        "reg", index, &fres);
 833                 if (ret < 0)
 834                         return -EINVAL;
 835                 memset(res, '\0', sizeof(*res));
 836                 res->start = fres.start;
 837                 res->end = fres.end;
 838
 839                 return 0;
 840         }
 841 }
 842
 843 int ofnode_read_resource_byname(ofnode node, const char *name,
 844                                 struct resource *res)
 845 {
 846         int index;
 847
 848         index = ofnode_stringlist_search(node, "reg-names", name);
 849         if (index < 0)
 850                 return index;
 851
 852         return ofnode_read_resource(node, index, res);
 853 }
 854
 855 u64 ofnode_translate_address(ofnode node, const fdt32_t *in_addr)
 856 {
 857         if (ofnode_is_np(node))
 858                 return of_translate_address(ofnode_to_np(node), in_addr);
 859         else
 860                 return fdt_translate_address(gd->fdt_blob, ofnode_to_offset(node), in_addr);
 861 }
 862
 863 u64 ofnode_translate_dma_address(ofnode node, const fdt32_t *in_addr)
 864 {
 865         if (ofnode_is_np(node))
 866                 return of_translate_dma_address(ofnode_to_np(node), in_addr);
 867         else
 868                 return fdt_translate_dma_address(gd->fdt_blob, ofnode_to_offset(node), in_addr);
 869 }
 870
 871 int ofnode_device_is_compatible(ofnode node, const char *compat)
 872 {
 873         if (ofnode_is_np(node))
 874                 return of_device_is_compatible(ofnode_to_np(node), compat,
 875                                                NULL, NULL);
 876         else
 877                 return !fdt_node_check_compatible(gd->fdt_blob,
 878                                                   ofnode_to_offset(node),
 879                                                   compat);
 880 }
 881
 882 ofnode ofnode_by_compatible(ofnode from, const char *compat)
 883 {
 884         if (of_live_active()) {
 885                 return np_to_ofnode(of_find_compatible_node(
 886                         (struct device_node *)ofnode_to_np(from), NULL,
 887                         compat));
 888         } else {
 889                 return offset_to_ofnode(fdt_node_offset_by_compatible(
 890                                 gd->fdt_blob, ofnode_to_offset(from), compat));
 891         }
 892 }
 893
 894 ofnode ofnode_by_prop_value(ofnode from, const char *propname,
 895                             const void *propval, int proplen)
 896 {
 897         if (of_live_active()) {
 898                 return np_to_ofnode(of_find_node_by_prop_value(
 899                         (struct device_node *)ofnode_to_np(from), propname,
 900                         propval, proplen));
 901         } else {
 902                 return offset_to_ofnode(fdt_node_offset_by_prop_value(
 903                                 gd->fdt_blob, ofnode_to_offset(from),
 904                                 propname, propval, proplen));
 905         }
 906 }
 907
 908 int ofnode_write_prop(ofnode node, const char *propname, int len,
 909                       const void *value)
 910 {
 911         const struct device_node *np = ofnode_to_np(node);
 912         struct property *pp;
 913         struct property *pp_last = NULL;
 914         struct property *new;
 915
 916         if (!of_live_active())
 917                 return -ENOSYS;
 918
 919         if (!np)
 920                 return -EINVAL;
 921
 922         for (pp = np->properties; pp; pp = pp->next) {
 923                 if (strcmp(pp->name, propname) == 0) {
 924                         /* Property exists -> change value */
 925                         pp->value = (void *)value;
 926                         pp->length = len;
 927                         return 0;
 928                 }
 929                 pp_last = pp;
 930         }
 931
 932         if (!pp_last)
 933                 return -ENOENT;
 934
 935         /* Property does not exist -> append new property */
 936         new = malloc(sizeof(struct property));
 937         if (!new)
 938                 return -ENOMEM;
 939
 940         new->name = strdup(propname);
 941         if (!new->name) {
 942                 free(new);
 943                 return -ENOMEM;
 944         }
 945
 946         new->value = (void *)value;
 947         new->length = len;
 948         new->next = NULL;
 949
 950         pp_last->next = new;
 951
 952         return 0;
 953 }
 954
 955 int ofnode_write_string(ofnode node, const char *propname, const char *value)
 956 {
 957         if (!of_live_active())
 958                 return -ENOSYS;
 959
 960         assert(ofnode_valid(node));
 961
 962         debug("%s: %s = %s", __func__, propname, value);
 963
 964         return ofnode_write_prop(node, propname, strlen(value) + 1, value);
 965 }
 966
 967 int ofnode_set_enabled(ofnode node, bool value)
 968 {
 969         if (!of_live_active())
 970                 return -ENOSYS;
 971
 972         assert(ofnode_valid(node));
 973
 974         if (value)
 975                 return ofnode_write_string(node, "status", "okay");
 976         else
 977                 return ofnode_write_string(node, "status", "disabled");
 978 }