1 /* 2 * Copyright (c) 2011 The Chromium OS Authors. 3 * SPDX-License-Identifier: GPL-2.0+ 4 */ 5 6 #ifndef USE_HOSTCC 7 #include <common.h> 8 #include <dm.h> 9 #include <errno.h> 10 #include <serial.h> 11 #include <libfdt.h> 12 #include <fdtdec.h> 13 #include <asm/sections.h> 14 #include <linux/ctype.h> 15 16 DECLARE_GLOBAL_DATA_PTR; 17 18 /* 19 * Here are the type we know about. One day we might allow drivers to 20 * register. For now we just put them here. The COMPAT macro allows us to 21 * turn this into a sparse list later, and keeps the ID with the name. 22 */ 23 #define COMPAT(id, name) name 24 static const char * const compat_names[COMPAT_COUNT] = { 25 COMPAT(UNKNOWN, "<none>"), 26 COMPAT(NVIDIA_TEGRA20_EMC, "nvidia,tegra20-emc"), 27 COMPAT(NVIDIA_TEGRA20_EMC_TABLE, "nvidia,tegra20-emc-table"), 28 COMPAT(NVIDIA_TEGRA20_NAND, "nvidia,tegra20-nand"), 29 COMPAT(NVIDIA_TEGRA20_PWM, "nvidia,tegra20-pwm"), 30 COMPAT(NVIDIA_TEGRA124_DC, "nvidia,tegra124-dc"), 31 COMPAT(NVIDIA_TEGRA124_SOR, "nvidia,tegra124-sor"), 32 COMPAT(NVIDIA_TEGRA124_PMC, "nvidia,tegra124-pmc"), 33 COMPAT(NVIDIA_TEGRA20_DC, "nvidia,tegra20-dc"), 34 COMPAT(NVIDIA_TEGRA210_SDMMC, "nvidia,tegra210-sdhci"), 35 COMPAT(NVIDIA_TEGRA124_SDMMC, "nvidia,tegra124-sdhci"), 36 COMPAT(NVIDIA_TEGRA30_SDMMC, "nvidia,tegra30-sdhci"), 37 COMPAT(NVIDIA_TEGRA20_SDMMC, "nvidia,tegra20-sdhci"), 38 COMPAT(NVIDIA_TEGRA124_XUSB_PADCTL, "nvidia,tegra124-xusb-padctl"), 39 COMPAT(NVIDIA_TEGRA210_XUSB_PADCTL, "nvidia,tegra210-xusb-padctl"), 40 COMPAT(SMSC_LAN9215, "smsc,lan9215"), 41 COMPAT(SAMSUNG_EXYNOS5_SROMC, "samsung,exynos-sromc"), 42 COMPAT(SAMSUNG_S3C2440_I2C, "samsung,s3c2440-i2c"), 43 COMPAT(SAMSUNG_EXYNOS5_SOUND, "samsung,exynos-sound"), 44 COMPAT(WOLFSON_WM8994_CODEC, "wolfson,wm8994-codec"), 45 COMPAT(GOOGLE_CROS_EC_KEYB, "google,cros-ec-keyb"), 46 COMPAT(SAMSUNG_EXYNOS_USB_PHY, "samsung,exynos-usb-phy"), 47 COMPAT(SAMSUNG_EXYNOS5_USB3_PHY, "samsung,exynos5250-usb3-phy"), 48 COMPAT(SAMSUNG_EXYNOS_TMU, "samsung,exynos-tmu"), 49 COMPAT(SAMSUNG_EXYNOS_FIMD, "samsung,exynos-fimd"), 50 COMPAT(SAMSUNG_EXYNOS_MIPI_DSI, "samsung,exynos-mipi-dsi"), 51 COMPAT(SAMSUNG_EXYNOS5_DP, "samsung,exynos5-dp"), 52 COMPAT(SAMSUNG_EXYNOS_DWMMC, "samsung,exynos-dwmmc"), 53 COMPAT(SAMSUNG_EXYNOS_MMC, "samsung,exynos-mmc"), 54 COMPAT(SAMSUNG_EXYNOS_SERIAL, "samsung,exynos4210-uart"), 55 COMPAT(MAXIM_MAX77686_PMIC, "maxim,max77686"), 56 COMPAT(GENERIC_SPI_FLASH, "spi-flash"), 57 COMPAT(MAXIM_98095_CODEC, "maxim,max98095-codec"), 58 COMPAT(SAMSUNG_EXYNOS5_I2C, "samsung,exynos5-hsi2c"), 59 COMPAT(SANDBOX_LCD_SDL, "sandbox,lcd-sdl"), 60 COMPAT(SAMSUNG_EXYNOS_SYSMMU, "samsung,sysmmu-v3.3"), 61 COMPAT(INTEL_MICROCODE, "intel,microcode"), 62 COMPAT(MEMORY_SPD, "memory-spd"), 63 COMPAT(INTEL_PANTHERPOINT_AHCI, "intel,pantherpoint-ahci"), 64 COMPAT(INTEL_MODEL_206AX, "intel,model-206ax"), 65 COMPAT(INTEL_GMA, "intel,gma"), 66 COMPAT(AMS_AS3722, "ams,as3722"), 67 COMPAT(INTEL_ICH_SPI, "intel,ich-spi"), 68 COMPAT(INTEL_QRK_MRC, "intel,quark-mrc"), 69 COMPAT(INTEL_X86_PINCTRL, "intel,x86-pinctrl"), 70 COMPAT(SOCIONEXT_XHCI, "socionext,uniphier-xhci"), 71 COMPAT(COMPAT_INTEL_PCH, "intel,bd82x6x"), 72 COMPAT(COMPAT_INTEL_IRQ_ROUTER, "intel,irq-router"), 73 COMPAT(ALTERA_SOCFPGA_DWMAC, "altr,socfpga-stmmac"), 74 COMPAT(ALTERA_SOCFPGA_DWMMC, "altr,socfpga-dw-mshc"), 75 COMPAT(ALTERA_SOCFPGA_DWC2USB, "snps,dwc2"), 76 COMPAT(COMPAT_INTEL_BAYTRAIL_FSP, "intel,baytrail-fsp"), 77 COMPAT(COMPAT_INTEL_BAYTRAIL_FSP_MDP, "intel,baytrail-fsp-mdp"), 78 COMPAT(COMPAT_INTEL_IVYBRIDGE_FSP, "intel,ivybridge-fsp"), 79 }; 80 81 const char *fdtdec_get_compatible(enum fdt_compat_id id) 82 { 83 /* We allow reading of the 'unknown' ID for testing purposes */ 84 assert(id >= 0 && id < COMPAT_COUNT); 85 return compat_names[id]; 86 } 87 88 fdt_addr_t fdtdec_get_addr_size_fixed(const void *blob, int node, 89 const char *prop_name, int index, int na, int ns, 90 fdt_size_t *sizep) 91 { 92 const fdt32_t *prop, *prop_end; 93 const fdt32_t *prop_addr, *prop_size, *prop_after_size; 94 int len; 95 fdt_addr_t addr; 96 97 debug("%s: %s: ", __func__, prop_name); 98 99 if (na > (sizeof(fdt_addr_t) / sizeof(fdt32_t))) { 100 debug("(na too large for fdt_addr_t type)\n"); 101 return FDT_ADDR_T_NONE; 102 } 103 104 if (ns > (sizeof(fdt_size_t) / sizeof(fdt32_t))) { 105 debug("(ns too large for fdt_size_t type)\n"); 106 return FDT_ADDR_T_NONE; 107 } 108 109 prop = fdt_getprop(blob, node, prop_name, &len); 110 if (!prop) { 111 debug("(not found)\n"); 112 return FDT_ADDR_T_NONE; 113 } 114 prop_end = prop + (len / sizeof(*prop)); 115 116 prop_addr = prop + (index * (na + ns)); 117 prop_size = prop_addr + na; 118 prop_after_size = prop_size + ns; 119 if (prop_after_size > prop_end) { 120 debug("(not enough data: expected >= %d cells, got %d cells)\n", 121 (u32)(prop_after_size - prop), ((u32)(prop_end - prop))); 122 return FDT_ADDR_T_NONE; 123 } 124 125 addr = fdtdec_get_number(prop_addr, na); 126 127 if (sizep) { 128 *sizep = fdtdec_get_number(prop_size, ns); 129 debug("addr=%08llx, size=%llx\n", (u64)addr, (u64)*sizep); 130 } else { 131 debug("addr=%08llx\n", (u64)addr); 132 } 133 134 return addr; 135 } 136 137 fdt_addr_t fdtdec_get_addr_size_auto_parent(const void *blob, int parent, 138 int node, const char *prop_name, int index, fdt_size_t *sizep) 139 { 140 int na, ns; 141 142 debug("%s: ", __func__); 143 144 na = fdt_address_cells(blob, parent); 145 if (na < 1) { 146 debug("(bad #address-cells)\n"); 147 return FDT_ADDR_T_NONE; 148 } 149 150 ns = fdt_size_cells(blob, parent); 151 if (ns < 0) { 152 debug("(bad #size-cells)\n"); 153 return FDT_ADDR_T_NONE; 154 } 155 156 debug("na=%d, ns=%d, ", na, ns); 157 158 return fdtdec_get_addr_size_fixed(blob, node, prop_name, index, na, 159 ns, sizep); 160 } 161 162 fdt_addr_t fdtdec_get_addr_size_auto_noparent(const void *blob, int node, 163 const char *prop_name, int index, fdt_size_t *sizep) 164 { 165 int parent; 166 167 debug("%s: ", __func__); 168 169 parent = fdt_parent_offset(blob, node); 170 if (parent < 0) { 171 debug("(no parent found)\n"); 172 return FDT_ADDR_T_NONE; 173 } 174 175 return fdtdec_get_addr_size_auto_parent(blob, parent, node, prop_name, 176 index, sizep); 177 } 178 179 fdt_addr_t fdtdec_get_addr_size(const void *blob, int node, 180 const char *prop_name, fdt_size_t *sizep) 181 { 182 int ns = sizep ? (sizeof(fdt_size_t) / sizeof(fdt32_t)) : 0; 183 184 return fdtdec_get_addr_size_fixed(blob, node, prop_name, 0, 185 sizeof(fdt_addr_t) / sizeof(fdt32_t), 186 ns, sizep); 187 } 188 189 fdt_addr_t fdtdec_get_addr(const void *blob, int node, 190 const char *prop_name) 191 { 192 return fdtdec_get_addr_size(blob, node, prop_name, NULL); 193 } 194 195 #if defined(CONFIG_PCI) && defined(CONFIG_DM_PCI) 196 int fdtdec_get_pci_addr(const void *blob, int node, enum fdt_pci_space type, 197 const char *prop_name, struct fdt_pci_addr *addr) 198 { 199 const u32 *cell; 200 int len; 201 int ret = -ENOENT; 202 203 debug("%s: %s: ", __func__, prop_name); 204 205 /* 206 * If we follow the pci bus bindings strictly, we should check 207 * the value of the node's parent node's #address-cells and 208 * #size-cells. They need to be 3 and 2 accordingly. However, 209 * for simplicity we skip the check here. 210 */ 211 cell = fdt_getprop(blob, node, prop_name, &len); 212 if (!cell) 213 goto fail; 214 215 if ((len % FDT_PCI_REG_SIZE) == 0) { 216 int num = len / FDT_PCI_REG_SIZE; 217 int i; 218 219 for (i = 0; i < num; i++) { 220 debug("pci address #%d: %08lx %08lx %08lx\n", i, 221 (ulong)fdt32_to_cpu(cell[0]), 222 (ulong)fdt32_to_cpu(cell[1]), 223 (ulong)fdt32_to_cpu(cell[2])); 224 if ((fdt32_to_cpu(*cell) & type) == type) { 225 addr->phys_hi = fdt32_to_cpu(cell[0]); 226 addr->phys_mid = fdt32_to_cpu(cell[1]); 227 addr->phys_lo = fdt32_to_cpu(cell[1]); 228 break; 229 } else { 230 cell += (FDT_PCI_ADDR_CELLS + 231 FDT_PCI_SIZE_CELLS); 232 } 233 } 234 235 if (i == num) { 236 ret = -ENXIO; 237 goto fail; 238 } 239 240 return 0; 241 } else { 242 ret = -EINVAL; 243 } 244 245 fail: 246 debug("(not found)\n"); 247 return ret; 248 } 249 250 int fdtdec_get_pci_vendev(const void *blob, int node, u16 *vendor, u16 *device) 251 { 252 const char *list, *end; 253 int len; 254 255 list = fdt_getprop(blob, node, "compatible", &len); 256 if (!list) 257 return -ENOENT; 258 259 end = list + len; 260 while (list < end) { 261 char *s; 262 263 len = strlen(list); 264 if (len >= strlen("pciVVVV,DDDD")) { 265 s = strstr(list, "pci"); 266 267 /* 268 * check if the string is something like pciVVVV,DDDD.RR 269 * or just pciVVVV,DDDD 270 */ 271 if (s && s[7] == ',' && 272 (s[12] == '.' || s[12] == 0)) { 273 s += 3; 274 *vendor = simple_strtol(s, NULL, 16); 275 276 s += 5; 277 *device = simple_strtol(s, NULL, 16); 278 279 return 0; 280 } 281 } 282 list += (len + 1); 283 } 284 285 return -ENOENT; 286 } 287 288 int fdtdec_get_pci_bar32(struct udevice *dev, struct fdt_pci_addr *addr, 289 u32 *bar) 290 { 291 int barnum; 292 293 /* extract the bar number from fdt_pci_addr */ 294 barnum = addr->phys_hi & 0xff; 295 if ((barnum < PCI_BASE_ADDRESS_0) || (barnum > PCI_CARDBUS_CIS)) 296 return -EINVAL; 297 298 barnum = (barnum - PCI_BASE_ADDRESS_0) / 4; 299 *bar = dm_pci_read_bar32(dev, barnum); 300 301 return 0; 302 } 303 #endif 304 305 uint64_t fdtdec_get_uint64(const void *blob, int node, const char *prop_name, 306 uint64_t default_val) 307 { 308 const uint64_t *cell64; 309 int length; 310 311 cell64 = fdt_getprop(blob, node, prop_name, &length); 312 if (!cell64 || length < sizeof(*cell64)) 313 return default_val; 314 315 return fdt64_to_cpu(*cell64); 316 } 317 318 int fdtdec_get_is_enabled(const void *blob, int node) 319 { 320 const char *cell; 321 322 /* 323 * It should say "okay", so only allow that. Some fdts use "ok" but 324 * this is a bug. Please fix your device tree source file. See here 325 * for discussion: 326 * 327 * http://www.mail-archive.com/u-boot@lists.denx.de/msg71598.html 328 */ 329 cell = fdt_getprop(blob, node, "status", NULL); 330 if (cell) 331 return 0 == strcmp(cell, "okay"); 332 return 1; 333 } 334 335 enum fdt_compat_id fdtdec_lookup(const void *blob, int node) 336 { 337 enum fdt_compat_id id; 338 339 /* Search our drivers */ 340 for (id = COMPAT_UNKNOWN; id < COMPAT_COUNT; id++) 341 if (0 == fdt_node_check_compatible(blob, node, 342 compat_names[id])) 343 return id; 344 return COMPAT_UNKNOWN; 345 } 346 347 int fdtdec_next_compatible(const void *blob, int node, 348 enum fdt_compat_id id) 349 { 350 return fdt_node_offset_by_compatible(blob, node, compat_names[id]); 351 } 352 353 int fdtdec_next_compatible_subnode(const void *blob, int node, 354 enum fdt_compat_id id, int *depthp) 355 { 356 do { 357 node = fdt_next_node(blob, node, depthp); 358 } while (*depthp > 1); 359 360 /* If this is a direct subnode, and compatible, return it */ 361 if (*depthp == 1 && 0 == fdt_node_check_compatible( 362 blob, node, compat_names[id])) 363 return node; 364 365 return -FDT_ERR_NOTFOUND; 366 } 367 368 int fdtdec_next_alias(const void *blob, const char *name, 369 enum fdt_compat_id id, int *upto) 370 { 371 #define MAX_STR_LEN 20 372 char str[MAX_STR_LEN + 20]; 373 int node, err; 374 375 /* snprintf() is not available */ 376 assert(strlen(name) < MAX_STR_LEN); 377 sprintf(str, "%.*s%d", MAX_STR_LEN, name, *upto); 378 node = fdt_path_offset(blob, str); 379 if (node < 0) 380 return node; 381 err = fdt_node_check_compatible(blob, node, compat_names[id]); 382 if (err < 0) 383 return err; 384 if (err) 385 return -FDT_ERR_NOTFOUND; 386 (*upto)++; 387 return node; 388 } 389 390 int fdtdec_find_aliases_for_id(const void *blob, const char *name, 391 enum fdt_compat_id id, int *node_list, int maxcount) 392 { 393 memset(node_list, '\0', sizeof(*node_list) * maxcount); 394 395 return fdtdec_add_aliases_for_id(blob, name, id, node_list, maxcount); 396 } 397 398 /* TODO: Can we tighten this code up a little? */ 399 int fdtdec_add_aliases_for_id(const void *blob, const char *name, 400 enum fdt_compat_id id, int *node_list, int maxcount) 401 { 402 int name_len = strlen(name); 403 int nodes[maxcount]; 404 int num_found = 0; 405 int offset, node; 406 int alias_node; 407 int count; 408 int i, j; 409 410 /* find the alias node if present */ 411 alias_node = fdt_path_offset(blob, "/aliases"); 412 413 /* 414 * start with nothing, and we can assume that the root node can't 415 * match 416 */ 417 memset(nodes, '\0', sizeof(nodes)); 418 419 /* First find all the compatible nodes */ 420 for (node = count = 0; node >= 0 && count < maxcount;) { 421 node = fdtdec_next_compatible(blob, node, id); 422 if (node >= 0) 423 nodes[count++] = node; 424 } 425 if (node >= 0) 426 debug("%s: warning: maxcount exceeded with alias '%s'\n", 427 __func__, name); 428 429 /* Now find all the aliases */ 430 for (offset = fdt_first_property_offset(blob, alias_node); 431 offset > 0; 432 offset = fdt_next_property_offset(blob, offset)) { 433 const struct fdt_property *prop; 434 const char *path; 435 int number; 436 int found; 437 438 node = 0; 439 prop = fdt_get_property_by_offset(blob, offset, NULL); 440 path = fdt_string(blob, fdt32_to_cpu(prop->nameoff)); 441 if (prop->len && 0 == strncmp(path, name, name_len)) 442 node = fdt_path_offset(blob, prop->data); 443 if (node <= 0) 444 continue; 445 446 /* Get the alias number */ 447 number = simple_strtoul(path + name_len, NULL, 10); 448 if (number < 0 || number >= maxcount) { 449 debug("%s: warning: alias '%s' is out of range\n", 450 __func__, path); 451 continue; 452 } 453 454 /* Make sure the node we found is actually in our list! */ 455 found = -1; 456 for (j = 0; j < count; j++) 457 if (nodes[j] == node) { 458 found = j; 459 break; 460 } 461 462 if (found == -1) { 463 debug("%s: warning: alias '%s' points to a node " 464 "'%s' that is missing or is not compatible " 465 " with '%s'\n", __func__, path, 466 fdt_get_name(blob, node, NULL), 467 compat_names[id]); 468 continue; 469 } 470 471 /* 472 * Add this node to our list in the right place, and mark 473 * it as done. 474 */ 475 if (fdtdec_get_is_enabled(blob, node)) { 476 if (node_list[number]) { 477 debug("%s: warning: alias '%s' requires that " 478 "a node be placed in the list in a " 479 "position which is already filled by " 480 "node '%s'\n", __func__, path, 481 fdt_get_name(blob, node, NULL)); 482 continue; 483 } 484 node_list[number] = node; 485 if (number >= num_found) 486 num_found = number + 1; 487 } 488 nodes[found] = 0; 489 } 490 491 /* Add any nodes not mentioned by an alias */ 492 for (i = j = 0; i < maxcount; i++) { 493 if (!node_list[i]) { 494 for (; j < maxcount; j++) 495 if (nodes[j] && 496 fdtdec_get_is_enabled(blob, nodes[j])) 497 break; 498 499 /* Have we run out of nodes to add? */ 500 if (j == maxcount) 501 break; 502 503 assert(!node_list[i]); 504 node_list[i] = nodes[j++]; 505 if (i >= num_found) 506 num_found = i + 1; 507 } 508 } 509 510 return num_found; 511 } 512 513 int fdtdec_get_alias_seq(const void *blob, const char *base, int offset, 514 int *seqp) 515 { 516 int base_len = strlen(base); 517 const char *find_name; 518 int find_namelen; 519 int prop_offset; 520 int aliases; 521 522 find_name = fdt_get_name(blob, offset, &find_namelen); 523 debug("Looking for '%s' at %d, name %s\n", base, offset, find_name); 524 525 aliases = fdt_path_offset(blob, "/aliases"); 526 for (prop_offset = fdt_first_property_offset(blob, aliases); 527 prop_offset > 0; 528 prop_offset = fdt_next_property_offset(blob, prop_offset)) { 529 const char *prop; 530 const char *name; 531 const char *slash; 532 int len, val; 533 534 prop = fdt_getprop_by_offset(blob, prop_offset, &name, &len); 535 debug(" - %s, %s\n", name, prop); 536 if (len < find_namelen || *prop != '/' || prop[len - 1] || 537 strncmp(name, base, base_len)) 538 continue; 539 540 slash = strrchr(prop, '/'); 541 if (strcmp(slash + 1, find_name)) 542 continue; 543 val = trailing_strtol(name); 544 if (val != -1) { 545 *seqp = val; 546 debug("Found seq %d\n", *seqp); 547 return 0; 548 } 549 } 550 551 debug("Not found\n"); 552 return -ENOENT; 553 } 554 555 const char *fdtdec_get_chosen_prop(const void *blob, const char *name) 556 { 557 int chosen_node; 558 559 if (!blob) 560 return NULL; 561 chosen_node = fdt_path_offset(blob, "/chosen"); 562 return fdt_getprop(blob, chosen_node, name, NULL); 563 } 564 565 int fdtdec_get_chosen_node(const void *blob, const char *name) 566 { 567 const char *prop; 568 569 prop = fdtdec_get_chosen_prop(blob, name); 570 if (!prop) 571 return -FDT_ERR_NOTFOUND; 572 return fdt_path_offset(blob, prop); 573 } 574 575 int fdtdec_check_fdt(void) 576 { 577 /* 578 * We must have an FDT, but we cannot panic() yet since the console 579 * is not ready. So for now, just assert(). Boards which need an early 580 * FDT (prior to console ready) will need to make their own 581 * arrangements and do their own checks. 582 */ 583 assert(!fdtdec_prepare_fdt()); 584 return 0; 585 } 586 587 /* 588 * This function is a little odd in that it accesses global data. At some 589 * point if the architecture board.c files merge this will make more sense. 590 * Even now, it is common code. 591 */ 592 int fdtdec_prepare_fdt(void) 593 { 594 if (!gd->fdt_blob || ((uintptr_t)gd->fdt_blob & 3) || 595 fdt_check_header(gd->fdt_blob)) { 596 #ifdef CONFIG_SPL_BUILD 597 puts("Missing DTB\n"); 598 #else 599 puts("No valid device tree binary found - please append one to U-Boot binary, use u-boot-dtb.bin or define CONFIG_OF_EMBED. For sandbox, use -d <file.dtb>\n"); 600 # ifdef DEBUG 601 if (gd->fdt_blob) { 602 printf("fdt_blob=%p\n", gd->fdt_blob); 603 print_buffer((ulong)gd->fdt_blob, gd->fdt_blob, 4, 604 32, 0); 605 } 606 # endif 607 #endif 608 return -1; 609 } 610 return 0; 611 } 612 613 int fdtdec_lookup_phandle(const void *blob, int node, const char *prop_name) 614 { 615 const u32 *phandle; 616 int lookup; 617 618 debug("%s: %s\n", __func__, prop_name); 619 phandle = fdt_getprop(blob, node, prop_name, NULL); 620 if (!phandle) 621 return -FDT_ERR_NOTFOUND; 622 623 lookup = fdt_node_offset_by_phandle(blob, fdt32_to_cpu(*phandle)); 624 return lookup; 625 } 626 627 /** 628 * Look up a property in a node and check that it has a minimum length. 629 * 630 * @param blob FDT blob 631 * @param node node to examine 632 * @param prop_name name of property to find 633 * @param min_len minimum property length in bytes 634 * @param err 0 if ok, or -FDT_ERR_NOTFOUND if the property is not 635 found, or -FDT_ERR_BADLAYOUT if not enough data 636 * @return pointer to cell, which is only valid if err == 0 637 */ 638 static const void *get_prop_check_min_len(const void *blob, int node, 639 const char *prop_name, int min_len, int *err) 640 { 641 const void *cell; 642 int len; 643 644 debug("%s: %s\n", __func__, prop_name); 645 cell = fdt_getprop(blob, node, prop_name, &len); 646 if (!cell) 647 *err = -FDT_ERR_NOTFOUND; 648 else if (len < min_len) 649 *err = -FDT_ERR_BADLAYOUT; 650 else 651 *err = 0; 652 return cell; 653 } 654 655 int fdtdec_get_int_array(const void *blob, int node, const char *prop_name, 656 u32 *array, int count) 657 { 658 const u32 *cell; 659 int i, err = 0; 660 661 debug("%s: %s\n", __func__, prop_name); 662 cell = get_prop_check_min_len(blob, node, prop_name, 663 sizeof(u32) * count, &err); 664 if (!err) { 665 for (i = 0; i < count; i++) 666 array[i] = fdt32_to_cpu(cell[i]); 667 } 668 return err; 669 } 670 671 int fdtdec_get_int_array_count(const void *blob, int node, 672 const char *prop_name, u32 *array, int count) 673 { 674 const u32 *cell; 675 int len, elems; 676 int i; 677 678 debug("%s: %s\n", __func__, prop_name); 679 cell = fdt_getprop(blob, node, prop_name, &len); 680 if (!cell) 681 return -FDT_ERR_NOTFOUND; 682 elems = len / sizeof(u32); 683 if (count > elems) 684 count = elems; 685 for (i = 0; i < count; i++) 686 array[i] = fdt32_to_cpu(cell[i]); 687 688 return count; 689 } 690 691 const u32 *fdtdec_locate_array(const void *blob, int node, 692 const char *prop_name, int count) 693 { 694 const u32 *cell; 695 int err; 696 697 cell = get_prop_check_min_len(blob, node, prop_name, 698 sizeof(u32) * count, &err); 699 return err ? NULL : cell; 700 } 701 702 int fdtdec_get_bool(const void *blob, int node, const char *prop_name) 703 { 704 const s32 *cell; 705 int len; 706 707 debug("%s: %s\n", __func__, prop_name); 708 cell = fdt_getprop(blob, node, prop_name, &len); 709 return cell != NULL; 710 } 711 712 int fdtdec_parse_phandle_with_args(const void *blob, int src_node, 713 const char *list_name, 714 const char *cells_name, 715 int cell_count, int index, 716 struct fdtdec_phandle_args *out_args) 717 { 718 const __be32 *list, *list_end; 719 int rc = 0, size, cur_index = 0; 720 uint32_t count = 0; 721 int node = -1; 722 int phandle; 723 724 /* Retrieve the phandle list property */ 725 list = fdt_getprop(blob, src_node, list_name, &size); 726 if (!list) 727 return -ENOENT; 728 list_end = list + size / sizeof(*list); 729 730 /* Loop over the phandles until all the requested entry is found */ 731 while (list < list_end) { 732 rc = -EINVAL; 733 count = 0; 734 735 /* 736 * If phandle is 0, then it is an empty entry with no 737 * arguments. Skip forward to the next entry. 738 */ 739 phandle = be32_to_cpup(list++); 740 if (phandle) { 741 /* 742 * Find the provider node and parse the #*-cells 743 * property to determine the argument length. 744 * 745 * This is not needed if the cell count is hard-coded 746 * (i.e. cells_name not set, but cell_count is set), 747 * except when we're going to return the found node 748 * below. 749 */ 750 if (cells_name || cur_index == index) { 751 node = fdt_node_offset_by_phandle(blob, 752 phandle); 753 if (!node) { 754 debug("%s: could not find phandle\n", 755 fdt_get_name(blob, src_node, 756 NULL)); 757 goto err; 758 } 759 } 760 761 if (cells_name) { 762 count = fdtdec_get_int(blob, node, cells_name, 763 -1); 764 if (count == -1) { 765 debug("%s: could not get %s for %s\n", 766 fdt_get_name(blob, src_node, 767 NULL), 768 cells_name, 769 fdt_get_name(blob, node, 770 NULL)); 771 goto err; 772 } 773 } else { 774 count = cell_count; 775 } 776 777 /* 778 * Make sure that the arguments actually fit in the 779 * remaining property data length 780 */ 781 if (list + count > list_end) { 782 debug("%s: arguments longer than property\n", 783 fdt_get_name(blob, src_node, NULL)); 784 goto err; 785 } 786 } 787 788 /* 789 * All of the error cases above bail out of the loop, so at 790 * this point, the parsing is successful. If the requested 791 * index matches, then fill the out_args structure and return, 792 * or return -ENOENT for an empty entry. 793 */ 794 rc = -ENOENT; 795 if (cur_index == index) { 796 if (!phandle) 797 goto err; 798 799 if (out_args) { 800 int i; 801 802 if (count > MAX_PHANDLE_ARGS) { 803 debug("%s: too many arguments %d\n", 804 fdt_get_name(blob, src_node, 805 NULL), count); 806 count = MAX_PHANDLE_ARGS; 807 } 808 out_args->node = node; 809 out_args->args_count = count; 810 for (i = 0; i < count; i++) { 811 out_args->args[i] = 812 be32_to_cpup(list++); 813 } 814 } 815 816 /* Found it! return success */ 817 return 0; 818 } 819 820 node = -1; 821 list += count; 822 cur_index++; 823 } 824 825 /* 826 * Result will be one of: 827 * -ENOENT : index is for empty phandle 828 * -EINVAL : parsing error on data 829 * [1..n] : Number of phandle (count mode; when index = -1) 830 */ 831 rc = index < 0 ? cur_index : -ENOENT; 832 err: 833 return rc; 834 } 835 836 int fdtdec_get_byte_array(const void *blob, int node, const char *prop_name, 837 u8 *array, int count) 838 { 839 const u8 *cell; 840 int err; 841 842 cell = get_prop_check_min_len(blob, node, prop_name, count, &err); 843 if (!err) 844 memcpy(array, cell, count); 845 return err; 846 } 847 848 const u8 *fdtdec_locate_byte_array(const void *blob, int node, 849 const char *prop_name, int count) 850 { 851 const u8 *cell; 852 int err; 853 854 cell = get_prop_check_min_len(blob, node, prop_name, count, &err); 855 if (err) 856 return NULL; 857 return cell; 858 } 859 860 int fdtdec_get_config_int(const void *blob, const char *prop_name, 861 int default_val) 862 { 863 int config_node; 864 865 debug("%s: %s\n", __func__, prop_name); 866 config_node = fdt_path_offset(blob, "/config"); 867 if (config_node < 0) 868 return default_val; 869 return fdtdec_get_int(blob, config_node, prop_name, default_val); 870 } 871 872 int fdtdec_get_config_bool(const void *blob, const char *prop_name) 873 { 874 int config_node; 875 const void *prop; 876 877 debug("%s: %s\n", __func__, prop_name); 878 config_node = fdt_path_offset(blob, "/config"); 879 if (config_node < 0) 880 return 0; 881 prop = fdt_get_property(blob, config_node, prop_name, NULL); 882 883 return prop != NULL; 884 } 885 886 char *fdtdec_get_config_string(const void *blob, const char *prop_name) 887 { 888 const char *nodep; 889 int nodeoffset; 890 int len; 891 892 debug("%s: %s\n", __func__, prop_name); 893 nodeoffset = fdt_path_offset(blob, "/config"); 894 if (nodeoffset < 0) 895 return NULL; 896 897 nodep = fdt_getprop(blob, nodeoffset, prop_name, &len); 898 if (!nodep) 899 return NULL; 900 901 return (char *)nodep; 902 } 903 904 int fdtdec_decode_region(const void *blob, int node, const char *prop_name, 905 fdt_addr_t *basep, fdt_size_t *sizep) 906 { 907 const fdt_addr_t *cell; 908 int len; 909 910 debug("%s: %s: %s\n", __func__, fdt_get_name(blob, node, NULL), 911 prop_name); 912 cell = fdt_getprop(blob, node, prop_name, &len); 913 if (!cell || (len < sizeof(fdt_addr_t) * 2)) { 914 debug("cell=%p, len=%d\n", cell, len); 915 return -1; 916 } 917 918 *basep = fdt_addr_to_cpu(*cell); 919 *sizep = fdt_size_to_cpu(cell[1]); 920 debug("%s: base=%08lx, size=%lx\n", __func__, (ulong)*basep, 921 (ulong)*sizep); 922 923 return 0; 924 } 925 926 /** 927 * Read a flash entry from the fdt 928 * 929 * @param blob FDT blob 930 * @param node Offset of node to read 931 * @param name Name of node being read 932 * @param entry Place to put offset and size of this node 933 * @return 0 if ok, -ve on error 934 */ 935 int fdtdec_read_fmap_entry(const void *blob, int node, const char *name, 936 struct fmap_entry *entry) 937 { 938 const char *prop; 939 u32 reg[2]; 940 941 if (fdtdec_get_int_array(blob, node, "reg", reg, 2)) { 942 debug("Node '%s' has bad/missing 'reg' property\n", name); 943 return -FDT_ERR_NOTFOUND; 944 } 945 entry->offset = reg[0]; 946 entry->length = reg[1]; 947 entry->used = fdtdec_get_int(blob, node, "used", entry->length); 948 prop = fdt_getprop(blob, node, "compress", NULL); 949 entry->compress_algo = prop && !strcmp(prop, "lzo") ? 950 FMAP_COMPRESS_LZO : FMAP_COMPRESS_NONE; 951 prop = fdt_getprop(blob, node, "hash", &entry->hash_size); 952 entry->hash_algo = prop ? FMAP_HASH_SHA256 : FMAP_HASH_NONE; 953 entry->hash = (uint8_t *)prop; 954 955 return 0; 956 } 957 958 u64 fdtdec_get_number(const fdt32_t *ptr, unsigned int cells) 959 { 960 u64 number = 0; 961 962 while (cells--) 963 number = (number << 32) | fdt32_to_cpu(*ptr++); 964 965 return number; 966 } 967 968 int fdt_get_resource(const void *fdt, int node, const char *property, 969 unsigned int index, struct fdt_resource *res) 970 { 971 const fdt32_t *ptr, *end; 972 int na, ns, len, parent; 973 unsigned int i = 0; 974 975 parent = fdt_parent_offset(fdt, node); 976 if (parent < 0) 977 return parent; 978 979 na = fdt_address_cells(fdt, parent); 980 ns = fdt_size_cells(fdt, parent); 981 982 ptr = fdt_getprop(fdt, node, property, &len); 983 if (!ptr) 984 return len; 985 986 end = ptr + len / sizeof(*ptr); 987 988 while (ptr + na + ns <= end) { 989 if (i == index) { 990 res->start = res->end = fdtdec_get_number(ptr, na); 991 res->end += fdtdec_get_number(&ptr[na], ns) - 1; 992 return 0; 993 } 994 995 ptr += na + ns; 996 i++; 997 } 998 999 return -FDT_ERR_NOTFOUND; 1000 } 1001 1002 int fdt_get_named_resource(const void *fdt, int node, const char *property, 1003 const char *prop_names, const char *name, 1004 struct fdt_resource *res) 1005 { 1006 int index; 1007 1008 index = fdt_find_string(fdt, node, prop_names, name); 1009 if (index < 0) 1010 return index; 1011 1012 return fdt_get_resource(fdt, node, property, index, res); 1013 } 1014 1015 int fdtdec_decode_memory_region(const void *blob, int config_node, 1016 const char *mem_type, const char *suffix, 1017 fdt_addr_t *basep, fdt_size_t *sizep) 1018 { 1019 char prop_name[50]; 1020 const char *mem; 1021 fdt_size_t size, offset_size; 1022 fdt_addr_t base, offset; 1023 int node; 1024 1025 if (config_node == -1) { 1026 config_node = fdt_path_offset(blob, "/config"); 1027 if (config_node < 0) { 1028 debug("%s: Cannot find /config node\n", __func__); 1029 return -ENOENT; 1030 } 1031 } 1032 if (!suffix) 1033 suffix = ""; 1034 1035 snprintf(prop_name, sizeof(prop_name), "%s-memory%s", mem_type, 1036 suffix); 1037 mem = fdt_getprop(blob, config_node, prop_name, NULL); 1038 if (!mem) { 1039 debug("%s: No memory type for '%s', using /memory\n", __func__, 1040 prop_name); 1041 mem = "/memory"; 1042 } 1043 1044 node = fdt_path_offset(blob, mem); 1045 if (node < 0) { 1046 debug("%s: Failed to find node '%s': %s\n", __func__, mem, 1047 fdt_strerror(node)); 1048 return -ENOENT; 1049 } 1050 1051 /* 1052 * Not strictly correct - the memory may have multiple banks. We just 1053 * use the first 1054 */ 1055 if (fdtdec_decode_region(blob, node, "reg", &base, &size)) { 1056 debug("%s: Failed to decode memory region %s\n", __func__, 1057 mem); 1058 return -EINVAL; 1059 } 1060 1061 snprintf(prop_name, sizeof(prop_name), "%s-offset%s", mem_type, 1062 suffix); 1063 if (fdtdec_decode_region(blob, config_node, prop_name, &offset, 1064 &offset_size)) { 1065 debug("%s: Failed to decode memory region '%s'\n", __func__, 1066 prop_name); 1067 return -EINVAL; 1068 } 1069 1070 *basep = base + offset; 1071 *sizep = offset_size; 1072 1073 return 0; 1074 } 1075 1076 static int decode_timing_property(const void *blob, int node, const char *name, 1077 struct timing_entry *result) 1078 { 1079 int length, ret = 0; 1080 const u32 *prop; 1081 1082 prop = fdt_getprop(blob, node, name, &length); 1083 if (!prop) { 1084 debug("%s: could not find property %s\n", 1085 fdt_get_name(blob, node, NULL), name); 1086 return length; 1087 } 1088 1089 if (length == sizeof(u32)) { 1090 result->typ = fdtdec_get_int(blob, node, name, 0); 1091 result->min = result->typ; 1092 result->max = result->typ; 1093 } else { 1094 ret = fdtdec_get_int_array(blob, node, name, &result->min, 3); 1095 } 1096 1097 return ret; 1098 } 1099 1100 int fdtdec_decode_display_timing(const void *blob, int parent, int index, 1101 struct display_timing *dt) 1102 { 1103 int i, node, timings_node; 1104 u32 val = 0; 1105 int ret = 0; 1106 1107 timings_node = fdt_subnode_offset(blob, parent, "display-timings"); 1108 if (timings_node < 0) 1109 return timings_node; 1110 1111 for (i = 0, node = fdt_first_subnode(blob, timings_node); 1112 node > 0 && i != index; 1113 node = fdt_next_subnode(blob, node)) 1114 i++; 1115 1116 if (node < 0) 1117 return node; 1118 1119 memset(dt, 0, sizeof(*dt)); 1120 1121 ret |= decode_timing_property(blob, node, "hback-porch", 1122 &dt->hback_porch); 1123 ret |= decode_timing_property(blob, node, "hfront-porch", 1124 &dt->hfront_porch); 1125 ret |= decode_timing_property(blob, node, "hactive", &dt->hactive); 1126 ret |= decode_timing_property(blob, node, "hsync-len", &dt->hsync_len); 1127 ret |= decode_timing_property(blob, node, "vback-porch", 1128 &dt->vback_porch); 1129 ret |= decode_timing_property(blob, node, "vfront-porch", 1130 &dt->vfront_porch); 1131 ret |= decode_timing_property(blob, node, "vactive", &dt->vactive); 1132 ret |= decode_timing_property(blob, node, "vsync-len", &dt->vsync_len); 1133 ret |= decode_timing_property(blob, node, "clock-frequency", 1134 &dt->pixelclock); 1135 1136 dt->flags = 0; 1137 val = fdtdec_get_int(blob, node, "vsync-active", -1); 1138 if (val != -1) { 1139 dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH : 1140 DISPLAY_FLAGS_VSYNC_LOW; 1141 } 1142 val = fdtdec_get_int(blob, node, "hsync-active", -1); 1143 if (val != -1) { 1144 dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH : 1145 DISPLAY_FLAGS_HSYNC_LOW; 1146 } 1147 val = fdtdec_get_int(blob, node, "de-active", -1); 1148 if (val != -1) { 1149 dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH : 1150 DISPLAY_FLAGS_DE_LOW; 1151 } 1152 val = fdtdec_get_int(blob, node, "pixelclk-active", -1); 1153 if (val != -1) { 1154 dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE : 1155 DISPLAY_FLAGS_PIXDATA_NEGEDGE; 1156 } 1157 1158 if (fdtdec_get_bool(blob, node, "interlaced")) 1159 dt->flags |= DISPLAY_FLAGS_INTERLACED; 1160 if (fdtdec_get_bool(blob, node, "doublescan")) 1161 dt->flags |= DISPLAY_FLAGS_DOUBLESCAN; 1162 if (fdtdec_get_bool(blob, node, "doubleclk")) 1163 dt->flags |= DISPLAY_FLAGS_DOUBLECLK; 1164 1165 return 0; 1166 } 1167 1168 int fdtdec_setup(void) 1169 { 1170 #if CONFIG_IS_ENABLED(OF_CONTROL) 1171 # ifdef CONFIG_OF_EMBED 1172 /* Get a pointer to the FDT */ 1173 gd->fdt_blob = __dtb_dt_begin; 1174 # elif defined CONFIG_OF_SEPARATE 1175 # ifdef CONFIG_SPL_BUILD 1176 /* FDT is at end of BSS unless it is in a different memory region */ 1177 if (IS_ENABLED(CONFIG_SPL_SEPARATE_BSS)) 1178 gd->fdt_blob = (ulong *)&_image_binary_end; 1179 else 1180 gd->fdt_blob = (ulong *)&__bss_end; 1181 # else 1182 /* FDT is at end of image */ 1183 gd->fdt_blob = (ulong *)&_end; 1184 # endif 1185 # elif defined(CONFIG_OF_HOSTFILE) 1186 if (sandbox_read_fdt_from_file()) { 1187 puts("Failed to read control FDT\n"); 1188 return -1; 1189 } 1190 # endif 1191 # ifndef CONFIG_SPL_BUILD 1192 /* Allow the early environment to override the fdt address */ 1193 gd->fdt_blob = (void *)getenv_ulong("fdtcontroladdr", 16, 1194 (uintptr_t)gd->fdt_blob); 1195 # endif 1196 #endif 1197 return fdtdec_prepare_fdt(); 1198 } 1199 1200 #endif /* !USE_HOSTCC */ 1201