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 <boot_fit.h> 9 #include <dm.h> 10 #include <dm/of_extra.h> 11 #include <errno.h> 12 #include <fdtdec.h> 13 #include <fdt_support.h> 14 #include <linux/libfdt.h> 15 #include <serial.h> 16 #include <asm/sections.h> 17 #include <linux/ctype.h> 18 #include <linux/lzo.h> 19 20 DECLARE_GLOBAL_DATA_PTR; 21 22 /* 23 * Here are the type we know about. One day we might allow drivers to 24 * register. For now we just put them here. The COMPAT macro allows us to 25 * turn this into a sparse list later, and keeps the ID with the name. 26 * 27 * NOTE: This list is basically a TODO list for things that need to be 28 * converted to driver model. So don't add new things here unless there is a 29 * good reason why driver-model conversion is infeasible. Examples include 30 * things which are used before driver model is available. 31 */ 32 #define COMPAT(id, name) name 33 static const char * const compat_names[COMPAT_COUNT] = { 34 COMPAT(UNKNOWN, "<none>"), 35 COMPAT(NVIDIA_TEGRA20_EMC, "nvidia,tegra20-emc"), 36 COMPAT(NVIDIA_TEGRA20_EMC_TABLE, "nvidia,tegra20-emc-table"), 37 COMPAT(NVIDIA_TEGRA20_NAND, "nvidia,tegra20-nand"), 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(SAMSUNG_EXYNOS_USB_PHY, "samsung,exynos-usb-phy"), 46 COMPAT(SAMSUNG_EXYNOS5_USB3_PHY, "samsung,exynos5250-usb3-phy"), 47 COMPAT(SAMSUNG_EXYNOS_TMU, "samsung,exynos-tmu"), 48 COMPAT(SAMSUNG_EXYNOS_MIPI_DSI, "samsung,exynos-mipi-dsi"), 49 COMPAT(SAMSUNG_EXYNOS_DWMMC, "samsung,exynos-dwmmc"), 50 COMPAT(SAMSUNG_EXYNOS_MMC, "samsung,exynos-mmc"), 51 COMPAT(MAXIM_MAX77686_PMIC, "maxim,max77686"), 52 COMPAT(GENERIC_SPI_FLASH, "spi-flash"), 53 COMPAT(MAXIM_98095_CODEC, "maxim,max98095-codec"), 54 COMPAT(SAMSUNG_EXYNOS5_I2C, "samsung,exynos5-hsi2c"), 55 COMPAT(SAMSUNG_EXYNOS_SYSMMU, "samsung,sysmmu-v3.3"), 56 COMPAT(INTEL_MICROCODE, "intel,microcode"), 57 COMPAT(AMS_AS3722, "ams,as3722"), 58 COMPAT(INTEL_QRK_MRC, "intel,quark-mrc"), 59 COMPAT(ALTERA_SOCFPGA_DWMAC, "altr,socfpga-stmmac"), 60 COMPAT(ALTERA_SOCFPGA_DWMMC, "altr,socfpga-dw-mshc"), 61 COMPAT(ALTERA_SOCFPGA_DWC2USB, "snps,dwc2"), 62 COMPAT(INTEL_BAYTRAIL_FSP, "intel,baytrail-fsp"), 63 COMPAT(INTEL_BAYTRAIL_FSP_MDP, "intel,baytrail-fsp-mdp"), 64 COMPAT(INTEL_IVYBRIDGE_FSP, "intel,ivybridge-fsp"), 65 COMPAT(COMPAT_SUNXI_NAND, "allwinner,sun4i-a10-nand"), 66 COMPAT(ALTERA_SOCFPGA_CLK, "altr,clk-mgr"), 67 COMPAT(ALTERA_SOCFPGA_PINCTRL_SINGLE, "pinctrl-single"), 68 COMPAT(ALTERA_SOCFPGA_H2F_BRG, "altr,socfpga-hps2fpga-bridge"), 69 COMPAT(ALTERA_SOCFPGA_LWH2F_BRG, "altr,socfpga-lwhps2fpga-bridge"), 70 COMPAT(ALTERA_SOCFPGA_F2H_BRG, "altr,socfpga-fpga2hps-bridge"), 71 COMPAT(ALTERA_SOCFPGA_F2SDR0, "altr,socfpga-fpga2sdram0-bridge"), 72 COMPAT(ALTERA_SOCFPGA_F2SDR1, "altr,socfpga-fpga2sdram1-bridge"), 73 COMPAT(ALTERA_SOCFPGA_F2SDR2, "altr,socfpga-fpga2sdram2-bridge"), 74 COMPAT(ROCKCHIP_NANDC, "rockchip,rk-nandc"), 75 }; 76 77 const char *fdtdec_get_compatible(enum fdt_compat_id id) 78 { 79 /* We allow reading of the 'unknown' ID for testing purposes */ 80 assert(id >= 0 && id < COMPAT_COUNT); 81 return compat_names[id]; 82 } 83 84 fdt_addr_t fdtdec_get_addr_size_fixed(const void *blob, int node, 85 const char *prop_name, int index, int na, int ns, 86 fdt_size_t *sizep, bool translate) 87 { 88 const fdt32_t *prop, *prop_end; 89 const fdt32_t *prop_addr, *prop_size, *prop_after_size; 90 int len; 91 fdt_addr_t addr; 92 93 debug("%s: %s: ", __func__, prop_name); 94 95 prop = fdt_getprop(blob, node, prop_name, &len); 96 if (!prop) { 97 debug("(not found)\n"); 98 return FDT_ADDR_T_NONE; 99 } 100 prop_end = prop + (len / sizeof(*prop)); 101 102 prop_addr = prop + (index * (na + ns)); 103 prop_size = prop_addr + na; 104 prop_after_size = prop_size + ns; 105 if (prop_after_size > prop_end) { 106 debug("(not enough data: expected >= %d cells, got %d cells)\n", 107 (u32)(prop_after_size - prop), ((u32)(prop_end - prop))); 108 return FDT_ADDR_T_NONE; 109 } 110 111 #if CONFIG_IS_ENABLED(OF_TRANSLATE) 112 if (translate) 113 addr = fdt_translate_address(blob, node, prop_addr); 114 else 115 #endif 116 addr = fdtdec_get_number(prop_addr, na); 117 118 if (sizep) { 119 *sizep = fdtdec_get_number(prop_size, ns); 120 debug("addr=%08llx, size=%llx\n", (unsigned long long)addr, 121 (unsigned long long)*sizep); 122 } else { 123 debug("addr=%08llx\n", (unsigned long long)addr); 124 } 125 126 return addr; 127 } 128 129 fdt_addr_t fdtdec_get_addr_size_auto_parent(const void *blob, int parent, 130 int node, const char *prop_name, int index, fdt_size_t *sizep, 131 bool translate) 132 { 133 int na, ns; 134 135 debug("%s: ", __func__); 136 137 na = fdt_address_cells(blob, parent); 138 if (na < 1) { 139 debug("(bad #address-cells)\n"); 140 return FDT_ADDR_T_NONE; 141 } 142 143 ns = fdt_size_cells(blob, parent); 144 if (ns < 0) { 145 debug("(bad #size-cells)\n"); 146 return FDT_ADDR_T_NONE; 147 } 148 149 debug("na=%d, ns=%d, ", na, ns); 150 151 return fdtdec_get_addr_size_fixed(blob, node, prop_name, index, na, 152 ns, sizep, translate); 153 } 154 155 fdt_addr_t fdtdec_get_addr_size_auto_noparent(const void *blob, int node, 156 const char *prop_name, int index, fdt_size_t *sizep, 157 bool translate) 158 { 159 int parent; 160 161 debug("%s: ", __func__); 162 163 parent = fdt_parent_offset(blob, node); 164 if (parent < 0) { 165 debug("(no parent found)\n"); 166 return FDT_ADDR_T_NONE; 167 } 168 169 return fdtdec_get_addr_size_auto_parent(blob, parent, node, prop_name, 170 index, sizep, translate); 171 } 172 173 fdt_addr_t fdtdec_get_addr_size(const void *blob, int node, 174 const char *prop_name, fdt_size_t *sizep) 175 { 176 #ifdef CONFIG_OF_ADDR_SIZE_AUTO_NOPARENT 177 /* In case of 64-bit U-Boot use 32-bit platform dtb */ 178 return fdtdec_get_addr_size_auto_noparent(blob, node, prop_name, 179 0, sizep, false); 180 #else 181 int ns = sizep ? (sizeof(fdt_size_t) / sizeof(fdt32_t)) : 0; 182 183 return fdtdec_get_addr_size_fixed(blob, node, prop_name, 0, 184 sizeof(fdt_addr_t) / sizeof(fdt32_t), 185 ns, sizep, false); 186 #endif 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) && CONFIG_IS_ENABLED(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_child_count(const void *blob, int node) 837 { 838 int subnode; 839 int num = 0; 840 841 fdt_for_each_subnode(subnode, blob, node) 842 num++; 843 844 return num; 845 } 846 847 int fdtdec_get_byte_array(const void *blob, int node, const char *prop_name, 848 u8 *array, int count) 849 { 850 const u8 *cell; 851 int err; 852 853 cell = get_prop_check_min_len(blob, node, prop_name, count, &err); 854 if (!err) 855 memcpy(array, cell, count); 856 return err; 857 } 858 859 const u8 *fdtdec_locate_byte_array(const void *blob, int node, 860 const char *prop_name, int count) 861 { 862 const u8 *cell; 863 int err; 864 865 cell = get_prop_check_min_len(blob, node, prop_name, count, &err); 866 if (err) 867 return NULL; 868 return cell; 869 } 870 871 int fdtdec_get_config_int(const void *blob, const char *prop_name, 872 int default_val) 873 { 874 int config_node; 875 876 debug("%s: %s\n", __func__, prop_name); 877 config_node = fdt_path_offset(blob, "/config"); 878 if (config_node < 0) 879 return default_val; 880 return fdtdec_get_int(blob, config_node, prop_name, default_val); 881 } 882 883 int fdtdec_get_config_bool(const void *blob, const char *prop_name) 884 { 885 int config_node; 886 const void *prop; 887 888 debug("%s: %s\n", __func__, prop_name); 889 config_node = fdt_path_offset(blob, "/config"); 890 if (config_node < 0) 891 return 0; 892 prop = fdt_get_property(blob, config_node, prop_name, NULL); 893 894 return prop != NULL; 895 } 896 897 char *fdtdec_get_config_string(const void *blob, const char *prop_name) 898 { 899 const char *nodep; 900 int nodeoffset; 901 int len; 902 903 debug("%s: %s\n", __func__, prop_name); 904 nodeoffset = fdt_path_offset(blob, "/config"); 905 if (nodeoffset < 0) 906 return NULL; 907 908 nodep = fdt_getprop(blob, nodeoffset, prop_name, &len); 909 if (!nodep) 910 return NULL; 911 912 return (char *)nodep; 913 } 914 915 int fdtdec_decode_region(const void *blob, int node, const char *prop_name, 916 fdt_addr_t *basep, fdt_size_t *sizep) 917 { 918 const fdt_addr_t *cell; 919 int len; 920 921 debug("%s: %s: %s\n", __func__, fdt_get_name(blob, node, NULL), 922 prop_name); 923 cell = fdt_getprop(blob, node, prop_name, &len); 924 if (!cell || (len < sizeof(fdt_addr_t) * 2)) { 925 debug("cell=%p, len=%d\n", cell, len); 926 return -1; 927 } 928 929 *basep = fdt_addr_to_cpu(*cell); 930 *sizep = fdt_size_to_cpu(cell[1]); 931 debug("%s: base=%08lx, size=%lx\n", __func__, (ulong)*basep, 932 (ulong)*sizep); 933 934 return 0; 935 } 936 937 u64 fdtdec_get_number(const fdt32_t *ptr, unsigned int cells) 938 { 939 u64 number = 0; 940 941 while (cells--) 942 number = (number << 32) | fdt32_to_cpu(*ptr++); 943 944 return number; 945 } 946 947 int fdt_get_resource(const void *fdt, int node, const char *property, 948 unsigned int index, struct fdt_resource *res) 949 { 950 const fdt32_t *ptr, *end; 951 int na, ns, len, parent; 952 unsigned int i = 0; 953 954 parent = fdt_parent_offset(fdt, node); 955 if (parent < 0) 956 return parent; 957 958 na = fdt_address_cells(fdt, parent); 959 ns = fdt_size_cells(fdt, parent); 960 961 ptr = fdt_getprop(fdt, node, property, &len); 962 if (!ptr) 963 return len; 964 965 end = ptr + len / sizeof(*ptr); 966 967 while (ptr + na + ns <= end) { 968 if (i == index) { 969 if (CONFIG_IS_ENABLED(OF_TRANSLATE)) 970 res->start = fdt_translate_address(fdt, node, ptr); 971 else 972 res->start = fdtdec_get_number(ptr, na); 973 974 res->end = res->start; 975 res->end += fdtdec_get_number(&ptr[na], ns) - 1; 976 return 0; 977 } 978 979 ptr += na + ns; 980 i++; 981 } 982 983 return -FDT_ERR_NOTFOUND; 984 } 985 986 int fdt_get_named_resource(const void *fdt, int node, const char *property, 987 const char *prop_names, const char *name, 988 struct fdt_resource *res) 989 { 990 int index; 991 992 index = fdt_stringlist_search(fdt, node, prop_names, name); 993 if (index < 0) 994 return index; 995 996 return fdt_get_resource(fdt, node, property, index, res); 997 } 998 999 int fdtdec_decode_memory_region(const void *blob, int config_node, 1000 const char *mem_type, const char *suffix, 1001 fdt_addr_t *basep, fdt_size_t *sizep) 1002 { 1003 char prop_name[50]; 1004 const char *mem; 1005 fdt_size_t size, offset_size; 1006 fdt_addr_t base, offset; 1007 int node; 1008 1009 if (config_node == -1) { 1010 config_node = fdt_path_offset(blob, "/config"); 1011 if (config_node < 0) { 1012 debug("%s: Cannot find /config node\n", __func__); 1013 return -ENOENT; 1014 } 1015 } 1016 if (!suffix) 1017 suffix = ""; 1018 1019 snprintf(prop_name, sizeof(prop_name), "%s-memory%s", mem_type, 1020 suffix); 1021 mem = fdt_getprop(blob, config_node, prop_name, NULL); 1022 if (!mem) { 1023 debug("%s: No memory type for '%s', using /memory\n", __func__, 1024 prop_name); 1025 mem = "/memory"; 1026 } 1027 1028 node = fdt_path_offset(blob, mem); 1029 if (node < 0) { 1030 debug("%s: Failed to find node '%s': %s\n", __func__, mem, 1031 fdt_strerror(node)); 1032 return -ENOENT; 1033 } 1034 1035 /* 1036 * Not strictly correct - the memory may have multiple banks. We just 1037 * use the first 1038 */ 1039 if (fdtdec_decode_region(blob, node, "reg", &base, &size)) { 1040 debug("%s: Failed to decode memory region %s\n", __func__, 1041 mem); 1042 return -EINVAL; 1043 } 1044 1045 snprintf(prop_name, sizeof(prop_name), "%s-offset%s", mem_type, 1046 suffix); 1047 if (fdtdec_decode_region(blob, config_node, prop_name, &offset, 1048 &offset_size)) { 1049 debug("%s: Failed to decode memory region '%s'\n", __func__, 1050 prop_name); 1051 return -EINVAL; 1052 } 1053 1054 *basep = base + offset; 1055 *sizep = offset_size; 1056 1057 return 0; 1058 } 1059 1060 static int decode_timing_property(const void *blob, int node, const char *name, 1061 struct timing_entry *result) 1062 { 1063 int length, ret = 0; 1064 const u32 *prop; 1065 1066 prop = fdt_getprop(blob, node, name, &length); 1067 if (!prop) { 1068 debug("%s: could not find property %s\n", 1069 fdt_get_name(blob, node, NULL), name); 1070 return length; 1071 } 1072 1073 if (length == sizeof(u32)) { 1074 result->typ = fdtdec_get_int(blob, node, name, 0); 1075 result->min = result->typ; 1076 result->max = result->typ; 1077 } else { 1078 ret = fdtdec_get_int_array(blob, node, name, &result->min, 3); 1079 } 1080 1081 return ret; 1082 } 1083 1084 int fdtdec_decode_display_timing(const void *blob, int parent, int index, 1085 struct display_timing *dt) 1086 { 1087 int i, node, timings_node; 1088 u32 val = 0; 1089 int ret = 0; 1090 1091 timings_node = fdt_subnode_offset(blob, parent, "display-timings"); 1092 if (timings_node < 0) 1093 return timings_node; 1094 1095 for (i = 0, node = fdt_first_subnode(blob, timings_node); 1096 node > 0 && i != index; 1097 node = fdt_next_subnode(blob, node)) 1098 i++; 1099 1100 if (node < 0) 1101 return node; 1102 1103 memset(dt, 0, sizeof(*dt)); 1104 1105 ret |= decode_timing_property(blob, node, "hback-porch", 1106 &dt->hback_porch); 1107 ret |= decode_timing_property(blob, node, "hfront-porch", 1108 &dt->hfront_porch); 1109 ret |= decode_timing_property(blob, node, "hactive", &dt->hactive); 1110 ret |= decode_timing_property(blob, node, "hsync-len", &dt->hsync_len); 1111 ret |= decode_timing_property(blob, node, "vback-porch", 1112 &dt->vback_porch); 1113 ret |= decode_timing_property(blob, node, "vfront-porch", 1114 &dt->vfront_porch); 1115 ret |= decode_timing_property(blob, node, "vactive", &dt->vactive); 1116 ret |= decode_timing_property(blob, node, "vsync-len", &dt->vsync_len); 1117 ret |= decode_timing_property(blob, node, "clock-frequency", 1118 &dt->pixelclock); 1119 1120 dt->flags = 0; 1121 val = fdtdec_get_int(blob, node, "vsync-active", -1); 1122 if (val != -1) { 1123 dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH : 1124 DISPLAY_FLAGS_VSYNC_LOW; 1125 } 1126 val = fdtdec_get_int(blob, node, "hsync-active", -1); 1127 if (val != -1) { 1128 dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH : 1129 DISPLAY_FLAGS_HSYNC_LOW; 1130 } 1131 val = fdtdec_get_int(blob, node, "de-active", -1); 1132 if (val != -1) { 1133 dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH : 1134 DISPLAY_FLAGS_DE_LOW; 1135 } 1136 val = fdtdec_get_int(blob, node, "pixelclk-active", -1); 1137 if (val != -1) { 1138 dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE : 1139 DISPLAY_FLAGS_PIXDATA_NEGEDGE; 1140 } 1141 1142 if (fdtdec_get_bool(blob, node, "interlaced")) 1143 dt->flags |= DISPLAY_FLAGS_INTERLACED; 1144 if (fdtdec_get_bool(blob, node, "doublescan")) 1145 dt->flags |= DISPLAY_FLAGS_DOUBLESCAN; 1146 if (fdtdec_get_bool(blob, node, "doubleclk")) 1147 dt->flags |= DISPLAY_FLAGS_DOUBLECLK; 1148 1149 return ret; 1150 } 1151 1152 int fdtdec_setup_memory_size(void) 1153 { 1154 int ret, mem; 1155 struct fdt_resource res; 1156 1157 mem = fdt_path_offset(gd->fdt_blob, "/memory"); 1158 if (mem < 0) { 1159 debug("%s: Missing /memory node\n", __func__); 1160 return -EINVAL; 1161 } 1162 1163 ret = fdt_get_resource(gd->fdt_blob, mem, "reg", 0, &res); 1164 if (ret != 0) { 1165 debug("%s: Unable to decode first memory bank\n", __func__); 1166 return -EINVAL; 1167 } 1168 1169 gd->ram_size = (phys_size_t)(res.end - res.start + 1); 1170 debug("%s: Initial DRAM size %llx\n", __func__, 1171 (unsigned long long)gd->ram_size); 1172 1173 return 0; 1174 } 1175 1176 #if defined(CONFIG_NR_DRAM_BANKS) 1177 int fdtdec_setup_memory_banksize(void) 1178 { 1179 int bank, ret, mem, reg = 0; 1180 struct fdt_resource res; 1181 1182 mem = fdt_node_offset_by_prop_value(gd->fdt_blob, -1, "device_type", 1183 "memory", 7); 1184 if (mem < 0) { 1185 debug("%s: Missing /memory node\n", __func__); 1186 return -EINVAL; 1187 } 1188 1189 for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) { 1190 ret = fdt_get_resource(gd->fdt_blob, mem, "reg", reg++, &res); 1191 if (ret == -FDT_ERR_NOTFOUND) { 1192 reg = 0; 1193 mem = fdt_node_offset_by_prop_value(gd->fdt_blob, mem, 1194 "device_type", 1195 "memory", 7); 1196 if (mem == -FDT_ERR_NOTFOUND) 1197 break; 1198 1199 ret = fdt_get_resource(gd->fdt_blob, mem, "reg", reg++, &res); 1200 if (ret == -FDT_ERR_NOTFOUND) 1201 break; 1202 } 1203 if (ret != 0) { 1204 return -EINVAL; 1205 } 1206 1207 gd->bd->bi_dram[bank].start = (phys_addr_t)res.start; 1208 gd->bd->bi_dram[bank].size = 1209 (phys_size_t)(res.end - res.start + 1); 1210 1211 debug("%s: DRAM Bank #%d: start = 0x%llx, size = 0x%llx\n", 1212 __func__, bank, 1213 (unsigned long long)gd->bd->bi_dram[bank].start, 1214 (unsigned long long)gd->bd->bi_dram[bank].size); 1215 } 1216 1217 return 0; 1218 } 1219 #endif 1220 1221 #if CONFIG_IS_ENABLED(MULTI_DTB_FIT) 1222 # if CONFIG_IS_ENABLED(MULTI_DTB_FIT_GZIP) ||\ 1223 CONFIG_IS_ENABLED(MULTI_DTB_FIT_LZO) 1224 static int uncompress_blob(const void *src, ulong sz_src, void **dstp) 1225 { 1226 size_t sz_out = CONFIG_SPL_MULTI_DTB_FIT_UNCOMPRESS_SZ; 1227 ulong sz_in = sz_src; 1228 void *dst; 1229 int rc; 1230 1231 if (CONFIG_IS_ENABLED(GZIP)) 1232 if (gzip_parse_header(src, sz_in) < 0) 1233 return -1; 1234 if (CONFIG_IS_ENABLED(LZO)) 1235 if (!lzop_is_valid_header(src)) 1236 return -EBADMSG; 1237 1238 if (CONFIG_IS_ENABLED(MULTI_DTB_FIT_DYN_ALLOC)) { 1239 dst = malloc(sz_out); 1240 if (!dst) { 1241 puts("uncompress_blob: Unable to allocate memory\n"); 1242 return -ENOMEM; 1243 } 1244 } else { 1245 # if CONFIG_IS_ENABLED(MULTI_DTB_FIT_USER_DEFINED_AREA) 1246 dst = (void *)CONFIG_VAL(MULTI_DTB_FIT_USER_DEF_ADDR); 1247 # else 1248 return -ENOTSUPP; 1249 # endif 1250 } 1251 1252 if (CONFIG_IS_ENABLED(GZIP)) 1253 rc = gunzip(dst, sz_out, (u8 *)src, &sz_in); 1254 else if (CONFIG_IS_ENABLED(LZO)) 1255 rc = lzop_decompress(src, sz_in, dst, &sz_out); 1256 1257 if (rc < 0) { 1258 /* not a valid compressed blob */ 1259 puts("uncompress_blob: Unable to uncompress\n"); 1260 if (CONFIG_IS_ENABLED(MULTI_DTB_FIT_DYN_ALLOC)) 1261 free(dst); 1262 return -EBADMSG; 1263 } 1264 *dstp = dst; 1265 return 0; 1266 } 1267 # else 1268 static int uncompress_blob(const void *src, ulong sz_src, void **dstp) 1269 { 1270 return -ENOTSUPP; 1271 } 1272 # endif 1273 #endif 1274 1275 int fdtdec_setup(void) 1276 { 1277 #if CONFIG_IS_ENABLED(OF_CONTROL) 1278 # if CONFIG_IS_ENABLED(MULTI_DTB_FIT) 1279 void *fdt_blob; 1280 # endif 1281 # ifdef CONFIG_OF_EMBED 1282 /* Get a pointer to the FDT */ 1283 # ifdef CONFIG_SPL_BUILD 1284 gd->fdt_blob = __dtb_dt_spl_begin; 1285 # else 1286 gd->fdt_blob = __dtb_dt_begin; 1287 # endif 1288 # elif defined CONFIG_OF_SEPARATE 1289 # ifdef CONFIG_SPL_BUILD 1290 /* FDT is at end of BSS unless it is in a different memory region */ 1291 if (IS_ENABLED(CONFIG_SPL_SEPARATE_BSS)) 1292 gd->fdt_blob = (ulong *)&_image_binary_end; 1293 else 1294 gd->fdt_blob = (ulong *)&__bss_end; 1295 # else 1296 /* FDT is at end of image */ 1297 gd->fdt_blob = (ulong *)&_end; 1298 1299 # ifdef CONFIG_USING_KERNEL_DTB 1300 gd->fdt_blob_kern = (ulong *)ALIGN((ulong)gd->fdt_blob + 1301 fdt_totalsize(gd->fdt_blob), 8); 1302 if (fdt_check_header(gd->fdt_blob_kern)) 1303 gd->fdt_blob_kern = NULL; 1304 # endif 1305 # endif 1306 # elif defined(CONFIG_OF_BOARD) 1307 /* Allow the board to override the fdt address. */ 1308 gd->fdt_blob = board_fdt_blob_setup(); 1309 # elif defined(CONFIG_OF_HOSTFILE) 1310 if (sandbox_read_fdt_from_file()) { 1311 puts("Failed to read control FDT\n"); 1312 return -1; 1313 } 1314 # endif 1315 # ifndef CONFIG_SPL_BUILD 1316 /* Allow the early environment to override the fdt address */ 1317 # if CONFIG_IS_ENABLED(OF_PRIOR_STAGE) 1318 gd->fdt_blob = (void *)prior_stage_fdt_address; 1319 # else 1320 gd->fdt_blob = (void *)env_get_ulong("fdtcontroladdr", 16, 1321 (uintptr_t)gd->fdt_blob); 1322 # endif 1323 # endif 1324 1325 # if CONFIG_IS_ENABLED(MULTI_DTB_FIT) 1326 /* 1327 * Try and uncompress the blob. 1328 * Unfortunately there is no way to know how big the input blob really 1329 * is. So let us set the maximum input size arbitrarily high. 16MB 1330 * ought to be more than enough for packed DTBs. 1331 */ 1332 if (uncompress_blob(gd->fdt_blob, 0x1000000, &fdt_blob) == 0) 1333 gd->fdt_blob = fdt_blob; 1334 1335 /* 1336 * Check if blob is a FIT images containings DTBs. 1337 * If so, pick the most relevant 1338 */ 1339 fdt_blob = locate_dtb_in_fit(gd->fdt_blob); 1340 if (fdt_blob) 1341 gd->fdt_blob = fdt_blob; 1342 # endif 1343 #endif 1344 1345 return fdtdec_prepare_fdt(); 1346 } 1347 1348 #endif /* !USE_HOSTCC */ 1349