drivers/core/ofnode.c

   1 /*
   2  * Copyright (c) 2017 Google, Inc
   3  * Written by Simon Glass <sjg@chromium.org>
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 #include <common.h>
   9 #include <dm.h>
  10 #include <fdtdec.h>
  11 #include <fdt_support.h>
  12 #include <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
  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 bool ofnode_read_bool(ofnode node, const char *propname)
  59 {
  60         const void *prop;
  61
  62         assert(ofnode_valid(node));
  63         debug("%s: %s: ", __func__, propname);
  64
  65         prop = ofnode_get_property(node, propname, NULL);
  66
  67         debug("%s\n", prop ? "true" : "false");
  68
  69         return prop ? true : false;
  70 }
  71
  72 const char *ofnode_read_string(ofnode node, const char *propname)
  73 {
  74         const char *str = NULL;
  75         int len = -1;
  76
  77         assert(ofnode_valid(node));
  78         debug("%s: %s: ", __func__, propname);
  79
  80         if (ofnode_is_np(node)) {
  81                 struct property *prop = of_find_property(
  82                                 ofnode_to_np(node), propname, NULL);
  83
  84                 if (prop) {
  85                         str = prop->value;
  86                         len = prop->length;
  87                 }
  88         } else {
  89                 str = fdt_getprop(gd->fdt_blob, ofnode_to_offset(node),
  90                                   propname, &len);
  91         }
  92         if (!str) {
  93                 debug("<not found>\n");
  94                 return NULL;
  95         }
  96         if (strnlen(str, len) >= len) {
  97                 debug("<invalid>\n");
  98                 return NULL;
  99         }
 100         debug("%s\n", str);
 101
 102         return str;
 103 }
 104
 105 ofnode ofnode_find_subnode(ofnode node, const char *subnode_name)
 106 {
 107         ofnode subnode;
 108
 109         assert(ofnode_valid(node));
 110         debug("%s: %s: ", __func__, subnode_name);
 111
 112         if (ofnode_is_np(node)) {
 113                 const struct device_node *np = ofnode_to_np(node);
 114
 115                 for (np = np->child; np; np = np->sibling) {
 116                         if (!strcmp(subnode_name, np->name))
 117                                 break;
 118                 }
 119                 subnode = np_to_ofnode(np);
 120         } else {
 121                 int ooffset = fdt_subnode_offset(gd->fdt_blob,
 122                                 ofnode_to_offset(node), subnode_name);
 123                 subnode = offset_to_ofnode(ooffset);
 124         }
 125         debug("%s\n", ofnode_valid(subnode) ?
 126               ofnode_get_name(subnode) : "<none>");
 127
 128         return subnode;
 129 }
 130
 131 int ofnode_read_u32_array(ofnode node, const char *propname,
 132                           u32 *out_values, size_t sz)
 133 {
 134         assert(ofnode_valid(node));
 135         debug("%s: %s: ", __func__, propname);
 136
 137         if (ofnode_is_np(node)) {
 138                 return of_read_u32_array(ofnode_to_np(node), propname,
 139                                          out_values, sz);
 140         } else {
 141                 return fdtdec_get_int_array(gd->fdt_blob,
 142                                             ofnode_to_offset(node), propname,
 143                                             out_values, sz);
 144         }
 145 }
 146
 147 ofnode ofnode_first_subnode(ofnode node)
 148 {
 149         assert(ofnode_valid(node));
 150         if (ofnode_is_np(node))
 151                 return np_to_ofnode(node.np->child);
 152
 153         return offset_to_ofnode(
 154                 fdt_first_subnode(gd->fdt_blob, ofnode_to_offset(node)));
 155 }
 156
 157 ofnode ofnode_next_subnode(ofnode node)
 158 {
 159         assert(ofnode_valid(node));
 160         if (ofnode_is_np(node))
 161                 return np_to_ofnode(node.np->sibling);
 162
 163         return offset_to_ofnode(
 164                 fdt_next_subnode(gd->fdt_blob, ofnode_to_offset(node)));
 165 }
 166
 167 const char *ofnode_get_name(ofnode node)
 168 {
 169         assert(ofnode_valid(node));
 170         if (ofnode_is_np(node))
 171                 return strrchr(node.np->full_name, '/') + 1;
 172
 173         return fdt_get_name(gd->fdt_blob, ofnode_to_offset(node), NULL);
 174 }
 175
 176 int ofnode_read_size(ofnode node, const char *propname)
 177 {
 178         int len;
 179
 180         if (ofnode_is_np(node)) {
 181                 struct property *prop = of_find_property(
 182                                 ofnode_to_np(node), propname, NULL);
 183
 184                 if (prop)
 185                         return prop->length;
 186         } else {
 187                 if (fdt_getprop(gd->fdt_blob, ofnode_to_offset(node), propname,
 188                                 &len))
 189                         return len;
 190         }
 191
 192         return -EINVAL;
 193 }
 194
 195 fdt_addr_t ofnode_get_addr_index(ofnode node, int index)
 196 {
 197         if (ofnode_is_np(node)) {
 198                 const __be32 *prop_val;
 199                 uint flags;
 200                 u64 size;
 201
 202                 prop_val = of_get_address(
 203                         (struct device_node *)ofnode_to_np(node), index,
 204                         &size, &flags);
 205                 if (!prop_val)
 206                         return FDT_ADDR_T_NONE;
 207                 return  be32_to_cpup(prop_val);
 208         } else {
 209                 return fdt_get_base_address(gd->fdt_blob,
 210                                             ofnode_to_offset(node));
 211         }
 212
 213         return FDT_ADDR_T_NONE;
 214 }
 215
 216 fdt_addr_t ofnode_get_addr(ofnode node)
 217 {
 218         return ofnode_get_addr_index(node, 0);
 219 }
 220
 221 int ofnode_stringlist_search(ofnode node, const char *property,
 222                              const char *string)
 223 {
 224         if (ofnode_is_np(node)) {
 225                 return of_property_match_string(ofnode_to_np(node),
 226                                                 property, string);
 227         } else {
 228                 int ret;
 229
 230                 ret = fdt_stringlist_search(gd->fdt_blob,
 231                                             ofnode_to_offset(node), property,
 232                                             string);
 233                 if (ret == -FDT_ERR_NOTFOUND)
 234                         return -ENODATA;
 235                 else if (ret < 0)
 236                         return -EINVAL;
 237
 238                 return ret;
 239         }
 240 }
 241
 242 int ofnode_read_string_index(ofnode node, const char *property, int index,
 243                              const char **outp)
 244 {
 245         if (ofnode_is_np(node)) {
 246                 return of_property_read_string_index(ofnode_to_np(node),
 247                                                      property, index, outp);
 248         } else {
 249                 int len;
 250
 251                 *outp = fdt_stringlist_get(gd->fdt_blob, ofnode_to_offset(node),
 252                                            property, index, &len);
 253                 if (len < 0)
 254                         return -EINVAL;
 255                 return 0;
 256         }
 257 }
 258
 259 int ofnode_read_string_count(ofnode node, const char *property)
 260 {
 261         if (ofnode_is_np(node)) {
 262                 return of_property_count_strings(ofnode_to_np(node), property);
 263         } else {
 264                 return fdt_stringlist_count(gd->fdt_blob,
 265                                             ofnode_to_offset(node), property);
 266         }
 267 }
 268
 269 static void ofnode_from_fdtdec_phandle_args(struct fdtdec_phandle_args *in,
 270                                             struct ofnode_phandle_args *out)
 271 {
 272         assert(OF_MAX_PHANDLE_ARGS == MAX_PHANDLE_ARGS);
 273         out->node = offset_to_ofnode(in->node);
 274         out->args_count = in->args_count;
 275         memcpy(out->args, in->args, sizeof(out->args));
 276 }
 277
 278 static void ofnode_from_of_phandle_args(struct of_phandle_args *in,
 279                                         struct ofnode_phandle_args *out)
 280 {
 281         assert(OF_MAX_PHANDLE_ARGS == MAX_PHANDLE_ARGS);
 282         out->node = np_to_ofnode(in->np);
 283         out->args_count = in->args_count;
 284         memcpy(out->args, in->args, sizeof(out->args));
 285 }
 286
 287 int ofnode_parse_phandle_with_args(ofnode node, const char *list_name,
 288                                    const char *cells_name, int cell_count,
 289                                    int index,
 290                                    struct ofnode_phandle_args *out_args)
 291 {
 292         if (ofnode_is_np(node)) {
 293                 struct of_phandle_args args;
 294                 int ret;
 295
 296                 ret = of_parse_phandle_with_args(ofnode_to_np(node),
 297                                 list_name, cells_name, index, &args);
 298                 if (ret)
 299                         return ret;
 300                 ofnode_from_of_phandle_args(&args, out_args);
 301         } else {
 302                 struct fdtdec_phandle_args args;
 303                 int ret;
 304
 305                 ret = fdtdec_parse_phandle_with_args(gd->fdt_blob,
 306                                 ofnode_to_offset(node), list_name, cells_name,
 307                                 cell_count, index, &args);
 308                 if (ret)
 309                         return ret;
 310                 ofnode_from_fdtdec_phandle_args(&args, out_args);
 311         }
 312
 313         return 0;
 314 }
 315
 316 int ofnode_count_phandle_with_args(ofnode node, const char *list_name,
 317                                    const char *cells_name)
 318 {
 319         if (ofnode_is_np(node))
 320                 return of_count_phandle_with_args(ofnode_to_np(node),
 321                                 list_name, cells_name);
 322         else
 323                 return fdtdec_parse_phandle_with_args(gd->fdt_blob,
 324                                 ofnode_to_offset(node), list_name, cells_name,
 325                                 0, -1, NULL);
 326 }
 327
 328 ofnode ofnode_path(const char *path)
 329 {
 330         if (of_live_active())
 331                 return np_to_ofnode(of_find_node_by_path(path));
 332         else
 333                 return offset_to_ofnode(fdt_path_offset(gd->fdt_blob, path));
 334 }
 335
 336 const char *ofnode_get_chosen_prop(const char *name)
 337 {
 338         ofnode chosen_node;
 339
 340         chosen_node = ofnode_path("/chosen");
 341
 342         return ofnode_read_string(chosen_node, name);
 343 }
 344
 345 ofnode ofnode_get_chosen_node(const char *name)
 346 {
 347         const char *prop;
 348
 349         prop = ofnode_get_chosen_prop(name);
 350         if (!prop)
 351                 return ofnode_null();
 352
 353         return ofnode_path(prop);
 354 }
 355
 356 static int decode_timing_property(ofnode node, const char *name,
 357                                   struct timing_entry *result)
 358 {
 359         int length, ret = 0;
 360
 361         length = ofnode_read_size(node, name);
 362         if (length < 0) {
 363                 debug("%s: could not find property %s\n",
 364                       ofnode_get_name(node), name);
 365                 return length;
 366         }
 367
 368         if (length == sizeof(u32)) {
 369                 result->typ = ofnode_read_u32_default(node, name, 0);
 370                 result->min = result->typ;
 371                 result->max = result->typ;
 372         } else {
 373                 ret = ofnode_read_u32_array(node, name, &result->min, 3);
 374         }
 375
 376         return ret;
 377 }
 378
 379 int ofnode_decode_display_timing(ofnode parent, int index,
 380                                  struct display_timing *dt)
 381 {
 382         int i;
 383         ofnode timings, node;
 384         u32 val = 0;
 385         int ret = 0;
 386
 387         timings = ofnode_find_subnode(parent, "display-timings");
 388         if (!ofnode_valid(timings))
 389                 return -EINVAL;
 390
 391         for (i = 0, node = ofnode_first_subnode(timings);
 392              ofnode_valid(node) && i != index;
 393              node = ofnode_first_subnode(node))
 394                 i++;
 395
 396         if (!ofnode_valid(node))
 397                 return -EINVAL;
 398
 399         memset(dt, 0, sizeof(*dt));
 400
 401         ret |= decode_timing_property(node, "hback-porch", &dt->hback_porch);
 402         ret |= decode_timing_property(node, "hfront-porch", &dt->hfront_porch);
 403         ret |= decode_timing_property(node, "hactive", &dt->hactive);
 404         ret |= decode_timing_property(node, "hsync-len", &dt->hsync_len);
 405         ret |= decode_timing_property(node, "vback-porch", &dt->vback_porch);
 406         ret |= decode_timing_property(node, "vfront-porch", &dt->vfront_porch);
 407         ret |= decode_timing_property(node, "vactive", &dt->vactive);
 408         ret |= decode_timing_property(node, "vsync-len", &dt->vsync_len);
 409         ret |= decode_timing_property(node, "clock-frequency", &dt->pixelclock);
 410
 411         dt->flags = 0;
 412         val = ofnode_read_u32_default(node, "vsync-active", -1);
 413         if (val != -1) {
 414                 dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
 415                                 DISPLAY_FLAGS_VSYNC_LOW;
 416         }
 417         val = ofnode_read_u32_default(node, "hsync-active", -1);
 418         if (val != -1) {
 419                 dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
 420                                 DISPLAY_FLAGS_HSYNC_LOW;
 421         }
 422         val = ofnode_read_u32_default(node, "de-active", -1);
 423         if (val != -1) {
 424                 dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
 425                                 DISPLAY_FLAGS_DE_LOW;
 426         }
 427         val = ofnode_read_u32_default(node, "pixelclk-active", -1);
 428         if (val != -1) {
 429                 dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
 430                                 DISPLAY_FLAGS_PIXDATA_NEGEDGE;
 431         }
 432
 433         if (ofnode_read_bool(node, "interlaced"))
 434                 dt->flags |= DISPLAY_FLAGS_INTERLACED;
 435         if (ofnode_read_bool(node, "doublescan"))
 436                 dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
 437         if (ofnode_read_bool(node, "doubleclk"))
 438                 dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
 439
 440         return ret;
 441 }
 442
 443 const void *ofnode_get_property(ofnode node, const char *propname, int *lenp)
 444 {
 445         if (ofnode_is_np(node))
 446                 return of_get_property(ofnode_to_np(node), propname, lenp);
 447         else
 448                 return fdt_getprop(gd->fdt_blob, ofnode_to_offset(node),
 449                                    propname, lenp);
 450 }
 451
 452 bool ofnode_is_available(ofnode node)
 453 {
 454         if (ofnode_is_np(node))
 455                 return of_device_is_available(ofnode_to_np(node));
 456         else
 457                 return fdtdec_get_is_enabled(gd->fdt_blob,
 458                                              ofnode_to_offset(node));
 459 }
 460
 461 fdt_addr_t ofnode_get_addr_size(ofnode node, const char *property,
 462                                 fdt_size_t *sizep)
 463 {
 464         if (ofnode_is_np(node)) {
 465                 int na, ns;
 466                 int psize;
 467                 const struct device_node *np = ofnode_to_np(node);
 468                 const __be32 *prop = of_get_property(np, "reg", &psize);
 469
 470                 na = of_n_addr_cells(np);
 471                 ns = of_n_addr_cells(np);
 472                 *sizep = of_read_number(prop + na, ns);
 473                 return of_read_number(prop, na);
 474         } else {
 475                 return fdtdec_get_addr_size(gd->fdt_blob,
 476                                             ofnode_to_offset(node), property,
 477                                             sizep);
 478         }
 479 }
 480
 481 const uint8_t *ofnode_read_u8_array_ptr(ofnode node, const char *propname,
 482                                         size_t sz)
 483 {
 484         if (ofnode_is_np(node)) {
 485                 const struct device_node *np = ofnode_to_np(node);
 486                 int psize;
 487                 const __be32 *prop = of_get_property(np, propname, &psize);
 488
 489                 if (!prop || sz != psize)
 490                         return NULL;
 491                 return (uint8_t *)prop;
 492
 493         } else {
 494                 return fdtdec_locate_byte_array(gd->fdt_blob,
 495                                 ofnode_to_offset(node), propname, sz);
 496         }
 497 }
 498
 499 int ofnode_read_pci_addr(ofnode node, enum fdt_pci_space type,
 500                          const char *propname, struct fdt_pci_addr *addr)
 501 {
 502         const fdt32_t *cell;
 503         int len;
 504         int ret = -ENOENT;
 505
 506         debug("%s: %s: ", __func__, propname);
 507
 508         /*
 509          * If we follow the pci bus bindings strictly, we should check
 510          * the value of the node's parent node's #address-cells and
 511          * #size-cells. They need to be 3 and 2 accordingly. However,
 512          * for simplicity we skip the check here.
 513          */
 514         cell = ofnode_get_property(node, propname, &len);
 515         if (!cell)
 516                 goto fail;
 517
 518         if ((len % FDT_PCI_REG_SIZE) == 0) {
 519                 int num = len / FDT_PCI_REG_SIZE;
 520                 int i;
 521
 522                 for (i = 0; i < num; i++) {
 523                         debug("pci address #%d: %08lx %08lx %08lx\n", i,
 524                               (ulong)fdt32_to_cpu(cell[0]),
 525                               (ulong)fdt32_to_cpu(cell[1]),
 526                               (ulong)fdt32_to_cpu(cell[2]));
 527                         if ((fdt32_to_cpu(*cell) & type) == type) {
 528                                 addr->phys_hi = fdt32_to_cpu(cell[0]);
 529                                 addr->phys_mid = fdt32_to_cpu(cell[1]);
 530                                 addr->phys_lo = fdt32_to_cpu(cell[1]);
 531                                 break;
 532                         } else {
 533                                 cell += (FDT_PCI_ADDR_CELLS +
 534                                          FDT_PCI_SIZE_CELLS);
 535                         }
 536                 }
 537
 538                 if (i == num) {
 539                         ret = -ENXIO;
 540                         goto fail;
 541                 }
 542
 543                 return 0;
 544         } else {
 545                 ret = -EINVAL;
 546         }
 547
 548 fail:
 549         debug("(not found)\n");
 550         return ret;
 551 }
 552
 553 int ofnode_read_addr_cells(ofnode node)
 554 {
 555         if (ofnode_is_np(node))
 556                 return of_n_addr_cells(ofnode_to_np(node));
 557         else  /* NOTE: this call should walk up the parent stack */
 558                 return fdt_address_cells(gd->fdt_blob, ofnode_to_offset(node));
 559 }
 560
 561 int ofnode_read_size_cells(ofnode node)
 562 {
 563         if (ofnode_is_np(node))
 564                 return of_n_size_cells(ofnode_to_np(node));
 565         else  /* NOTE: this call should walk up the parent stack */
 566                 return fdt_size_cells(gd->fdt_blob, ofnode_to_offset(node));
 567 }
 568
 569 int ofnode_read_simple_addr_cells(ofnode node)
 570 {
 571         if (ofnode_is_np(node))
 572                 return of_simple_addr_cells(ofnode_to_np(node));
 573         else
 574                 return fdt_address_cells(gd->fdt_blob, ofnode_to_offset(node));
 575 }
 576
 577 int ofnode_read_simple_size_cells(ofnode node)
 578 {
 579         if (ofnode_is_np(node))
 580                 return of_simple_size_cells(ofnode_to_np(node));
 581         else
 582                 return fdt_size_cells(gd->fdt_blob, ofnode_to_offset(node));
 583 }
 584
 585 bool ofnode_pre_reloc(ofnode node)
 586 {
 587         if (ofnode_read_bool(node, "u-boot,dm-pre-reloc"))
 588                 return true;
 589
 590 #ifdef CONFIG_TPL_BUILD
 591         if (ofnode_read_bool(node, "u-boot,dm-tpl"))
 592                 return true;
 593 #elif defined(CONFIG_SPL_BUILD)
 594         if (ofnode_read_bool(node, "u-boot,dm-spl"))
 595                 return true;
 596 #else
 597         /*
 598          * In regular builds individual spl and tpl handling both
 599          * count as handled pre-relocation for later second init.
 600          */
 601         if (ofnode_read_bool(node, "u-boot,dm-spl") ||
 602             ofnode_read_bool(node, "u-boot,dm-tpl"))
 603                 return true;
 604 #endif
 605
 606         return false;
 607 }