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