lib/fdtdec.c

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