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 <errno.h>
   9 #include <serial.h>
  10 #include <libfdt.h>
  11 #include <fdtdec.h>
  12 #include <linux/ctype.h>
  13
  14 DECLARE_GLOBAL_DATA_PTR;
  15
  16 /*
  17  * Here are the type we know about. One day we might allow drivers to
  18  * register. For now we just put them here. The COMPAT macro allows us to
  19  * turn this into a sparse list later, and keeps the ID with the name.
  20  */
  21 #define COMPAT(id, name) name
  22 static const char * const compat_names[COMPAT_COUNT] = {
  23         COMPAT(UNKNOWN, "<none>"),
  24         COMPAT(NVIDIA_TEGRA20_USB, "nvidia,tegra20-ehci"),
  25         COMPAT(NVIDIA_TEGRA30_USB, "nvidia,tegra30-ehci"),
  26         COMPAT(NVIDIA_TEGRA114_USB, "nvidia,tegra114-ehci"),
  27         COMPAT(NVIDIA_TEGRA20_EMC, "nvidia,tegra20-emc"),
  28         COMPAT(NVIDIA_TEGRA20_EMC_TABLE, "nvidia,tegra20-emc-table"),
  29         COMPAT(NVIDIA_TEGRA20_KBC, "nvidia,tegra20-kbc"),
  30         COMPAT(NVIDIA_TEGRA20_NAND, "nvidia,tegra20-nand"),
  31         COMPAT(NVIDIA_TEGRA20_PWM, "nvidia,tegra20-pwm"),
  32         COMPAT(NVIDIA_TEGRA20_DC, "nvidia,tegra20-dc"),
  33         COMPAT(NVIDIA_TEGRA124_SDMMC, "nvidia,tegra124-sdhci"),
  34         COMPAT(NVIDIA_TEGRA30_SDMMC, "nvidia,tegra30-sdhci"),
  35         COMPAT(NVIDIA_TEGRA20_SDMMC, "nvidia,tegra20-sdhci"),
  36         COMPAT(NVIDIA_TEGRA124_PCIE, "nvidia,tegra124-pcie"),
  37         COMPAT(NVIDIA_TEGRA30_PCIE, "nvidia,tegra30-pcie"),
  38         COMPAT(NVIDIA_TEGRA20_PCIE, "nvidia,tegra20-pcie"),
  39         COMPAT(NVIDIA_TEGRA124_XUSB_PADCTL, "nvidia,tegra124-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, "google,cros-ec"),
  46         COMPAT(GOOGLE_CROS_EC_KEYB, "google,cros-ec-keyb"),
  47         COMPAT(SAMSUNG_EXYNOS_EHCI, "samsung,exynos-ehci"),
  48         COMPAT(SAMSUNG_EXYNOS5_XHCI, "samsung,exynos5250-xhci"),
  49         COMPAT(SAMSUNG_EXYNOS_USB_PHY, "samsung,exynos-usb-phy"),
  50         COMPAT(SAMSUNG_EXYNOS5_USB3_PHY, "samsung,exynos5250-usb3-phy"),
  51         COMPAT(SAMSUNG_EXYNOS_TMU, "samsung,exynos-tmu"),
  52         COMPAT(SAMSUNG_EXYNOS_FIMD, "samsung,exynos-fimd"),
  53         COMPAT(SAMSUNG_EXYNOS_MIPI_DSI, "samsung,exynos-mipi-dsi"),
  54         COMPAT(SAMSUNG_EXYNOS5_DP, "samsung,exynos5-dp"),
  55         COMPAT(SAMSUNG_EXYNOS_DWMMC, "samsung,exynos-dwmmc"),
  56         COMPAT(SAMSUNG_EXYNOS_MMC, "samsung,exynos-mmc"),
  57         COMPAT(SAMSUNG_EXYNOS_SERIAL, "samsung,exynos4210-uart"),
  58         COMPAT(MAXIM_MAX77686_PMIC, "maxim,max77686_pmic"),
  59         COMPAT(GENERIC_SPI_FLASH, "spi-flash"),
  60         COMPAT(MAXIM_98095_CODEC, "maxim,max98095-codec"),
  61         COMPAT(INFINEON_SLB9635_TPM, "infineon,slb9635-tpm"),
  62         COMPAT(INFINEON_SLB9645_TPM, "infineon,slb9645-tpm"),
  63         COMPAT(SAMSUNG_EXYNOS5_I2C, "samsung,exynos5-hsi2c"),
  64         COMPAT(SANDBOX_HOST_EMULATION, "sandbox,host-emulation"),
  65         COMPAT(SANDBOX_LCD_SDL, "sandbox,lcd-sdl"),
  66         COMPAT(TI_TPS65090, "ti,tps65090"),
  67         COMPAT(COMPAT_NXP_PTN3460, "nxp,ptn3460"),
  68         COMPAT(SAMSUNG_EXYNOS_SYSMMU, "samsung,sysmmu-v3.3"),
  69         COMPAT(PARADE_PS8625, "parade,ps8625"),
  70         COMPAT(COMPAT_INTEL_LPC, "intel,lpc"),
  71         COMPAT(INTEL_MICROCODE, "intel,microcode"),
  72         COMPAT(MEMORY_SPD, "memory-spd"),
  73         COMPAT(INTEL_PANTHERPOINT_AHCI, "intel,pantherpoint-ahci"),
  74         COMPAT(INTEL_MODEL_206AX, "intel,model-206ax"),
  75         COMPAT(INTEL_GMA, "intel,gma"),
  76         COMPAT(AMS_AS3722, "ams,as3722"),
  77         COMPAT(INTEL_ICH_SPI, "intel,ich-spi"),
  78 };
  79
  80 const char *fdtdec_get_compatible(enum fdt_compat_id id)
  81 {
  82         /* We allow reading of the 'unknown' ID for testing purposes */
  83         assert(id >= 0 && id < COMPAT_COUNT);
  84         return compat_names[id];
  85 }
  86
  87 fdt_addr_t fdtdec_get_addr_size(const void *blob, int node,
  88                 const char *prop_name, fdt_size_t *sizep)
  89 {
  90         const fdt_addr_t *cell;
  91         int len;
  92
  93         debug("%s: %s: ", __func__, prop_name);
  94         cell = fdt_getprop(blob, node, prop_name, &len);
  95         if (cell && ((!sizep && len == sizeof(fdt_addr_t)) ||
  96                      len == sizeof(fdt_addr_t) * 2)) {
  97                 fdt_addr_t addr = fdt_addr_to_cpu(*cell);
  98                 if (sizep) {
  99                         const fdt_size_t *size;
 100
 101                         size = (fdt_size_t *)((char *)cell +
 102                                         sizeof(fdt_addr_t));
 103                         *sizep = fdt_size_to_cpu(*size);
 104                         debug("addr=%08lx, size=%08x\n",
 105                               (ulong)addr, *sizep);
 106                 } else {
 107                         debug("%08lx\n", (ulong)addr);
 108                 }
 109                 return addr;
 110         }
 111         debug("(not found)\n");
 112         return FDT_ADDR_T_NONE;
 113 }
 114
 115 fdt_addr_t fdtdec_get_addr(const void *blob, int node,
 116                 const char *prop_name)
 117 {
 118         return fdtdec_get_addr_size(blob, node, prop_name, NULL);
 119 }
 120
 121 #ifdef CONFIG_PCI
 122 int fdtdec_get_pci_addr(const void *blob, int node, enum fdt_pci_space type,
 123                 const char *prop_name, struct fdt_pci_addr *addr)
 124 {
 125         const u32 *cell;
 126         int len;
 127         int ret = -ENOENT;
 128
 129         debug("%s: %s: ", __func__, prop_name);
 130
 131         /*
 132          * If we follow the pci bus bindings strictly, we should check
 133          * the value of the node's parent node's #address-cells and
 134          * #size-cells. They need to be 3 and 2 accordingly. However,
 135          * for simplicity we skip the check here.
 136          */
 137         cell = fdt_getprop(blob, node, prop_name, &len);
 138         if (!cell)
 139                 goto fail;
 140
 141         if ((len % FDT_PCI_REG_SIZE) == 0) {
 142                 int num = len / FDT_PCI_REG_SIZE;
 143                 int i;
 144
 145                 for (i = 0; i < num; i++) {
 146                         debug("pci address #%d: %08lx %08lx %08lx\n", i,
 147                               (ulong)fdt_addr_to_cpu(cell[0]),
 148                               (ulong)fdt_addr_to_cpu(cell[1]),
 149                               (ulong)fdt_addr_to_cpu(cell[2]));
 150                         if ((fdt_addr_to_cpu(*cell) & type) == type) {
 151                                 addr->phys_hi = fdt_addr_to_cpu(cell[0]);
 152                                 addr->phys_mid = fdt_addr_to_cpu(cell[1]);
 153                                 addr->phys_lo = fdt_addr_to_cpu(cell[2]);
 154                                 break;
 155                         } else {
 156                                 cell += (FDT_PCI_ADDR_CELLS +
 157                                          FDT_PCI_SIZE_CELLS);
 158                         }
 159                 }
 160
 161                 if (i == num)
 162                         goto fail;
 163
 164                 return 0;
 165         } else {
 166                 ret = -EINVAL;
 167         }
 168
 169 fail:
 170         debug("(not found)\n");
 171         return ret;
 172 }
 173
 174 int fdtdec_get_pci_vendev(const void *blob, int node, u16 *vendor, u16 *device)
 175 {
 176         const char *list, *end;
 177         int len;
 178
 179         list = fdt_getprop(blob, node, "compatible", &len);
 180         if (!list)
 181                 return -ENOENT;
 182
 183         end = list + len;
 184         while (list < end) {
 185                 char *s;
 186
 187                 len = strlen(list);
 188                 if (len >= strlen("pciVVVV,DDDD")) {
 189                         s = strstr(list, "pci");
 190
 191                         /*
 192                          * check if the string is something like pciVVVV,DDDD.RR
 193                          * or just pciVVVV,DDDD
 194                          */
 195                         if (s && s[7] == ',' &&
 196                             (s[12] == '.' || s[12] == 0)) {
 197                                 s += 3;
 198                                 *vendor = simple_strtol(s, NULL, 16);
 199
 200                                 s += 5;
 201                                 *device = simple_strtol(s, NULL, 16);
 202
 203                                 return 0;
 204                         }
 205                 } else {
 206                         list += (len + 1);
 207                 }
 208         }
 209
 210         return -ENOENT;
 211 }
 212
 213 int fdtdec_get_pci_bdf(const void *blob, int node,
 214                 struct fdt_pci_addr *addr, pci_dev_t *bdf)
 215 {
 216         u16 dt_vendor, dt_device, vendor, device;
 217         int ret;
 218
 219         /* get vendor id & device id from the compatible string */
 220         ret = fdtdec_get_pci_vendev(blob, node, &dt_vendor, &dt_device);
 221         if (ret)
 222                 return ret;
 223
 224         /* extract the bdf from fdt_pci_addr */
 225         *bdf = addr->phys_hi & 0xffff00;
 226
 227         /* read vendor id & device id based on bdf */
 228         pci_read_config_word(*bdf, PCI_VENDOR_ID, &vendor);
 229         pci_read_config_word(*bdf, PCI_DEVICE_ID, &device);
 230
 231         /*
 232          * Note there are two places in the device tree to fully describe
 233          * a pci device: one is via compatible string with a format of
 234          * "pciVVVV,DDDD" and the other one is the bdf numbers encoded in
 235          * the device node's reg address property. We read the vendor id
 236          * and device id based on bdf and compare the values with the
 237          * "VVVV,DDDD". If they are the same, then we are good to use bdf
 238          * to read device's bar. But if they are different, we have to rely
 239          * on the vendor id and device id extracted from the compatible
 240          * string and locate the real bdf by pci_find_device(). This is
 241          * because normally we may only know device's device number and
 242          * function number when writing device tree. The bus number is
 243          * dynamically assigned during the pci enumeration process.
 244          */
 245         if ((dt_vendor != vendor) || (dt_device != device)) {
 246                 *bdf = pci_find_device(dt_vendor, dt_device, 0);
 247                 if (*bdf == -1)
 248                         return -ENODEV;
 249         }
 250
 251         return 0;
 252 }
 253
 254 int fdtdec_get_pci_bar32(const void *blob, int node,
 255                 struct fdt_pci_addr *addr, u32 *bar)
 256 {
 257         pci_dev_t bdf;
 258         int barnum;
 259         int ret;
 260
 261         /* get pci devices's bdf */
 262         ret = fdtdec_get_pci_bdf(blob, node, addr, &bdf);
 263         if (ret)
 264                 return ret;
 265
 266         /* extract the bar number from fdt_pci_addr */
 267         barnum = addr->phys_hi & 0xff;
 268         if ((barnum < PCI_BASE_ADDRESS_0) || (barnum > PCI_CARDBUS_CIS))
 269                 return -EINVAL;
 270
 271         barnum = (barnum - PCI_BASE_ADDRESS_0) / 4;
 272         *bar = pci_read_bar32(pci_bus_to_hose(PCI_BUS(bdf)), bdf, barnum);
 273
 274         return 0;
 275 }
 276 #endif
 277
 278 uint64_t fdtdec_get_uint64(const void *blob, int node, const char *prop_name,
 279                 uint64_t default_val)
 280 {
 281         const uint64_t *cell64;
 282         int length;
 283
 284         cell64 = fdt_getprop(blob, node, prop_name, &length);
 285         if (!cell64 || length < sizeof(*cell64))
 286                 return default_val;
 287
 288         return fdt64_to_cpu(*cell64);
 289 }
 290
 291 int fdtdec_get_is_enabled(const void *blob, int node)
 292 {
 293         const char *cell;
 294
 295         /*
 296          * It should say "okay", so only allow that. Some fdts use "ok" but
 297          * this is a bug. Please fix your device tree source file. See here
 298          * for discussion:
 299          *
 300          * http://www.mail-archive.com/u-boot@lists.denx.de/msg71598.html
 301          */
 302         cell = fdt_getprop(blob, node, "status", NULL);
 303         if (cell)
 304                 return 0 == strcmp(cell, "okay");
 305         return 1;
 306 }
 307
 308 enum fdt_compat_id fdtdec_lookup(const void *blob, int node)
 309 {
 310         enum fdt_compat_id id;
 311
 312         /* Search our drivers */
 313         for (id = COMPAT_UNKNOWN; id < COMPAT_COUNT; id++)
 314                 if (0 == fdt_node_check_compatible(blob, node,
 315                                 compat_names[id]))
 316                         return id;
 317         return COMPAT_UNKNOWN;
 318 }
 319
 320 int fdtdec_next_compatible(const void *blob, int node,
 321                 enum fdt_compat_id id)
 322 {
 323         return fdt_node_offset_by_compatible(blob, node, compat_names[id]);
 324 }
 325
 326 int fdtdec_next_compatible_subnode(const void *blob, int node,
 327                 enum fdt_compat_id id, int *depthp)
 328 {
 329         do {
 330                 node = fdt_next_node(blob, node, depthp);
 331         } while (*depthp > 1);
 332
 333         /* If this is a direct subnode, and compatible, return it */
 334         if (*depthp == 1 && 0 == fdt_node_check_compatible(
 335                                                 blob, node, compat_names[id]))
 336                 return node;
 337
 338         return -FDT_ERR_NOTFOUND;
 339 }
 340
 341 int fdtdec_next_alias(const void *blob, const char *name,
 342                 enum fdt_compat_id id, int *upto)
 343 {
 344 #define MAX_STR_LEN 20
 345         char str[MAX_STR_LEN + 20];
 346         int node, err;
 347
 348         /* snprintf() is not available */
 349         assert(strlen(name) < MAX_STR_LEN);
 350         sprintf(str, "%.*s%d", MAX_STR_LEN, name, *upto);
 351         node = fdt_path_offset(blob, str);
 352         if (node < 0)
 353                 return node;
 354         err = fdt_node_check_compatible(blob, node, compat_names[id]);
 355         if (err < 0)
 356                 return err;
 357         if (err)
 358                 return -FDT_ERR_NOTFOUND;
 359         (*upto)++;
 360         return node;
 361 }
 362
 363 int fdtdec_find_aliases_for_id(const void *blob, const char *name,
 364                         enum fdt_compat_id id, int *node_list, int maxcount)
 365 {
 366         memset(node_list, '\0', sizeof(*node_list) * maxcount);
 367
 368         return fdtdec_add_aliases_for_id(blob, name, id, node_list, maxcount);
 369 }
 370
 371 /* TODO: Can we tighten this code up a little? */
 372 int fdtdec_add_aliases_for_id(const void *blob, const char *name,
 373                         enum fdt_compat_id id, int *node_list, int maxcount)
 374 {
 375         int name_len = strlen(name);
 376         int nodes[maxcount];
 377         int num_found = 0;
 378         int offset, node;
 379         int alias_node;
 380         int count;
 381         int i, j;
 382
 383         /* find the alias node if present */
 384         alias_node = fdt_path_offset(blob, "/aliases");
 385
 386         /*
 387          * start with nothing, and we can assume that the root node can't
 388          * match
 389          */
 390         memset(nodes, '\0', sizeof(nodes));
 391
 392         /* First find all the compatible nodes */
 393         for (node = count = 0; node >= 0 && count < maxcount;) {
 394                 node = fdtdec_next_compatible(blob, node, id);
 395                 if (node >= 0)
 396                         nodes[count++] = node;
 397         }
 398         if (node >= 0)
 399                 debug("%s: warning: maxcount exceeded with alias '%s'\n",
 400                        __func__, name);
 401
 402         /* Now find all the aliases */
 403         for (offset = fdt_first_property_offset(blob, alias_node);
 404                         offset > 0;
 405                         offset = fdt_next_property_offset(blob, offset)) {
 406                 const struct fdt_property *prop;
 407                 const char *path;
 408                 int number;
 409                 int found;
 410
 411                 node = 0;
 412                 prop = fdt_get_property_by_offset(blob, offset, NULL);
 413                 path = fdt_string(blob, fdt32_to_cpu(prop->nameoff));
 414                 if (prop->len && 0 == strncmp(path, name, name_len))
 415                         node = fdt_path_offset(blob, prop->data);
 416                 if (node <= 0)
 417                         continue;
 418
 419                 /* Get the alias number */
 420                 number = simple_strtoul(path + name_len, NULL, 10);
 421                 if (number < 0 || number >= maxcount) {
 422                         debug("%s: warning: alias '%s' is out of range\n",
 423                                __func__, path);
 424                         continue;
 425                 }
 426
 427                 /* Make sure the node we found is actually in our list! */
 428                 found = -1;
 429                 for (j = 0; j < count; j++)
 430                         if (nodes[j] == node) {
 431                                 found = j;
 432                                 break;
 433                         }
 434
 435                 if (found == -1) {
 436                         debug("%s: warning: alias '%s' points to a node "
 437                                 "'%s' that is missing or is not compatible "
 438                                 " with '%s'\n", __func__, path,
 439                                 fdt_get_name(blob, node, NULL),
 440                                compat_names[id]);
 441                         continue;
 442                 }
 443
 444                 /*
 445                  * Add this node to our list in the right place, and mark
 446                  * it as done.
 447                  */
 448                 if (fdtdec_get_is_enabled(blob, node)) {
 449                         if (node_list[number]) {
 450                                 debug("%s: warning: alias '%s' requires that "
 451                                       "a node be placed in the list in a "
 452                                       "position which is already filled by "
 453                                       "node '%s'\n", __func__, path,
 454                                       fdt_get_name(blob, node, NULL));
 455                                 continue;
 456                         }
 457                         node_list[number] = node;
 458                         if (number >= num_found)
 459                                 num_found = number + 1;
 460                 }
 461                 nodes[found] = 0;
 462         }
 463
 464         /* Add any nodes not mentioned by an alias */
 465         for (i = j = 0; i < maxcount; i++) {
 466                 if (!node_list[i]) {
 467                         for (; j < maxcount; j++)
 468                                 if (nodes[j] &&
 469                                         fdtdec_get_is_enabled(blob, nodes[j]))
 470                                         break;
 471
 472                         /* Have we run out of nodes to add? */
 473                         if (j == maxcount)
 474                                 break;
 475
 476                         assert(!node_list[i]);
 477                         node_list[i] = nodes[j++];
 478                         if (i >= num_found)
 479                                 num_found = i + 1;
 480                 }
 481         }
 482
 483         return num_found;
 484 }
 485
 486 int fdtdec_get_alias_seq(const void *blob, const char *base, int offset,
 487                          int *seqp)
 488 {
 489         int base_len = strlen(base);
 490         const char *find_name;
 491         int find_namelen;
 492         int prop_offset;
 493         int aliases;
 494
 495         find_name = fdt_get_name(blob, offset, &find_namelen);
 496         debug("Looking for '%s' at %d, name %s\n", base, offset, find_name);
 497
 498         aliases = fdt_path_offset(blob, "/aliases");
 499         for (prop_offset = fdt_first_property_offset(blob, aliases);
 500              prop_offset > 0;
 501              prop_offset = fdt_next_property_offset(blob, prop_offset)) {
 502                 const char *prop;
 503                 const char *name;
 504                 const char *slash;
 505                 const char *p;
 506                 int len;
 507
 508                 prop = fdt_getprop_by_offset(blob, prop_offset, &name, &len);
 509                 debug("   - %s, %s\n", name, prop);
 510                 if (len < find_namelen || *prop != '/' || prop[len - 1] ||
 511                     strncmp(name, base, base_len))
 512                         continue;
 513
 514                 slash = strrchr(prop, '/');
 515                 if (strcmp(slash + 1, find_name))
 516                         continue;
 517                 for (p = name + strlen(name) - 1; p > name; p--) {
 518                         if (!isdigit(*p)) {
 519                                 *seqp = simple_strtoul(p + 1, NULL, 10);
 520                                 debug("Found seq %d\n", *seqp);
 521                                 return 0;
 522                         }
 523                 }
 524         }
 525
 526         debug("Not found\n");
 527         return -ENOENT;
 528 }
 529
 530 int fdtdec_get_chosen_node(const void *blob, const char *name)
 531 {
 532         const char *prop;
 533         int chosen_node;
 534         int len;
 535
 536         if (!blob)
 537                 return -FDT_ERR_NOTFOUND;
 538         chosen_node = fdt_path_offset(blob, "/chosen");
 539         prop = fdt_getprop(blob, chosen_node, name, &len);
 540         if (!prop)
 541                 return -FDT_ERR_NOTFOUND;
 542         return fdt_path_offset(blob, prop);
 543 }
 544
 545 int fdtdec_check_fdt(void)
 546 {
 547         /*
 548          * We must have an FDT, but we cannot panic() yet since the console
 549          * is not ready. So for now, just assert(). Boards which need an early
 550          * FDT (prior to console ready) will need to make their own
 551          * arrangements and do their own checks.
 552          */
 553         assert(!fdtdec_prepare_fdt());
 554         return 0;
 555 }
 556
 557 /*
 558  * This function is a little odd in that it accesses global data. At some
 559  * point if the architecture board.c files merge this will make more sense.
 560  * Even now, it is common code.
 561  */
 562 int fdtdec_prepare_fdt(void)
 563 {
 564         if (!gd->fdt_blob || ((uintptr_t)gd->fdt_blob & 3) ||
 565             fdt_check_header(gd->fdt_blob)) {
 566                 printf("No valid FDT found - please append one to U-Boot "
 567                         "binary, use u-boot-dtb.bin or define "
 568                         "CONFIG_OF_EMBED. For sandbox, use -d <file.dtb>\n");
 569                 return -1;
 570         }
 571         return 0;
 572 }
 573
 574 int fdtdec_lookup_phandle(const void *blob, int node, const char *prop_name)
 575 {
 576         const u32 *phandle;
 577         int lookup;
 578
 579         debug("%s: %s\n", __func__, prop_name);
 580         phandle = fdt_getprop(blob, node, prop_name, NULL);
 581         if (!phandle)
 582                 return -FDT_ERR_NOTFOUND;
 583
 584         lookup = fdt_node_offset_by_phandle(blob, fdt32_to_cpu(*phandle));
 585         return lookup;
 586 }
 587
 588 /**
 589  * Look up a property in a node and check that it has a minimum length.
 590  *
 591  * @param blob          FDT blob
 592  * @param node          node to examine
 593  * @param prop_name     name of property to find
 594  * @param min_len       minimum property length in bytes
 595  * @param err           0 if ok, or -FDT_ERR_NOTFOUND if the property is not
 596                         found, or -FDT_ERR_BADLAYOUT if not enough data
 597  * @return pointer to cell, which is only valid if err == 0
 598  */
 599 static const void *get_prop_check_min_len(const void *blob, int node,
 600                 const char *prop_name, int min_len, int *err)
 601 {
 602         const void *cell;
 603         int len;
 604
 605         debug("%s: %s\n", __func__, prop_name);
 606         cell = fdt_getprop(blob, node, prop_name, &len);
 607         if (!cell)
 608                 *err = -FDT_ERR_NOTFOUND;
 609         else if (len < min_len)
 610                 *err = -FDT_ERR_BADLAYOUT;
 611         else
 612                 *err = 0;
 613         return cell;
 614 }
 615
 616 int fdtdec_get_int_array(const void *blob, int node, const char *prop_name,
 617                 u32 *array, int count)
 618 {
 619         const u32 *cell;
 620         int i, err = 0;
 621
 622         debug("%s: %s\n", __func__, prop_name);
 623         cell = get_prop_check_min_len(blob, node, prop_name,
 624                                       sizeof(u32) * count, &err);
 625         if (!err) {
 626                 for (i = 0; i < count; i++)
 627                         array[i] = fdt32_to_cpu(cell[i]);
 628         }
 629         return err;
 630 }
 631
 632 int fdtdec_get_int_array_count(const void *blob, int node,
 633                                const char *prop_name, u32 *array, int count)
 634 {
 635         const u32 *cell;
 636         int len, elems;
 637         int i;
 638
 639         debug("%s: %s\n", __func__, prop_name);
 640         cell = fdt_getprop(blob, node, prop_name, &len);
 641         if (!cell)
 642                 return -FDT_ERR_NOTFOUND;
 643         elems = len / sizeof(u32);
 644         if (count > elems)
 645                 count = elems;
 646         for (i = 0; i < count; i++)
 647                 array[i] = fdt32_to_cpu(cell[i]);
 648
 649         return count;
 650 }
 651
 652 const u32 *fdtdec_locate_array(const void *blob, int node,
 653                                const char *prop_name, int count)
 654 {
 655         const u32 *cell;
 656         int err;
 657
 658         cell = get_prop_check_min_len(blob, node, prop_name,
 659                                       sizeof(u32) * count, &err);
 660         return err ? NULL : cell;
 661 }
 662
 663 int fdtdec_get_bool(const void *blob, int node, const char *prop_name)
 664 {
 665         const s32 *cell;
 666         int len;
 667
 668         debug("%s: %s\n", __func__, prop_name);
 669         cell = fdt_getprop(blob, node, prop_name, &len);
 670         return cell != NULL;
 671 }
 672
 673 int fdtdec_parse_phandle_with_args(const void *blob, int src_node,
 674                                    const char *list_name,
 675                                    const char *cells_name,
 676                                    int cell_count, int index,
 677                                    struct fdtdec_phandle_args *out_args)
 678 {
 679         const __be32 *list, *list_end;
 680         int rc = 0, size, cur_index = 0;
 681         uint32_t count = 0;
 682         int node = -1;
 683         int phandle;
 684
 685         /* Retrieve the phandle list property */
 686         list = fdt_getprop(blob, src_node, list_name, &size);
 687         if (!list)
 688                 return -ENOENT;
 689         list_end = list + size / sizeof(*list);
 690
 691         /* Loop over the phandles until all the requested entry is found */
 692         while (list < list_end) {
 693                 rc = -EINVAL;
 694                 count = 0;
 695
 696                 /*
 697                  * If phandle is 0, then it is an empty entry with no
 698                  * arguments.  Skip forward to the next entry.
 699                  */
 700                 phandle = be32_to_cpup(list++);
 701                 if (phandle) {
 702                         /*
 703                          * Find the provider node and parse the #*-cells
 704                          * property to determine the argument length.
 705                          *
 706                          * This is not needed if the cell count is hard-coded
 707                          * (i.e. cells_name not set, but cell_count is set),
 708                          * except when we're going to return the found node
 709                          * below.
 710                          */
 711                         if (cells_name || cur_index == index) {
 712                                 node = fdt_node_offset_by_phandle(blob,
 713                                                                   phandle);
 714                                 if (!node) {
 715                                         debug("%s: could not find phandle\n",
 716                                               fdt_get_name(blob, src_node,
 717                                                            NULL));
 718                                         goto err;
 719                                 }
 720                         }
 721
 722                         if (cells_name) {
 723                                 count = fdtdec_get_int(blob, node, cells_name,
 724                                                        -1);
 725                                 if (count == -1) {
 726                                         debug("%s: could not get %s for %s\n",
 727                                               fdt_get_name(blob, src_node,
 728                                                            NULL),
 729                                               cells_name,
 730                                               fdt_get_name(blob, node,
 731                                                            NULL));
 732                                         goto err;
 733                                 }
 734                         } else {
 735                                 count = cell_count;
 736                         }
 737
 738                         /*
 739                          * Make sure that the arguments actually fit in the
 740                          * remaining property data length
 741                          */
 742                         if (list + count > list_end) {
 743                                 debug("%s: arguments longer than property\n",
 744                                       fdt_get_name(blob, src_node, NULL));
 745                                 goto err;
 746                         }
 747                 }
 748
 749                 /*
 750                  * All of the error cases above bail out of the loop, so at
 751                  * this point, the parsing is successful. If the requested
 752                  * index matches, then fill the out_args structure and return,
 753                  * or return -ENOENT for an empty entry.
 754                  */
 755                 rc = -ENOENT;
 756                 if (cur_index == index) {
 757                         if (!phandle)
 758                                 goto err;
 759
 760                         if (out_args) {
 761                                 int i;
 762
 763                                 if (count > MAX_PHANDLE_ARGS) {
 764                                         debug("%s: too many arguments %d\n",
 765                                               fdt_get_name(blob, src_node,
 766                                                            NULL), count);
 767                                         count = MAX_PHANDLE_ARGS;
 768                                 }
 769                                 out_args->node = node;
 770                                 out_args->args_count = count;
 771                                 for (i = 0; i < count; i++) {
 772                                         out_args->args[i] =
 773                                                         be32_to_cpup(list++);
 774                                 }
 775                         }
 776
 777                         /* Found it! return success */
 778                         return 0;
 779                 }
 780
 781                 node = -1;
 782                 list += count;
 783                 cur_index++;
 784         }
 785
 786         /*
 787          * Result will be one of:
 788          * -ENOENT : index is for empty phandle
 789          * -EINVAL : parsing error on data
 790          * [1..n]  : Number of phandle (count mode; when index = -1)
 791          */
 792         rc = index < 0 ? cur_index : -ENOENT;
 793  err:
 794         return rc;
 795 }
 796
 797 int fdtdec_get_byte_array(const void *blob, int node, const char *prop_name,
 798                 u8 *array, int count)
 799 {
 800         const u8 *cell;
 801         int err;
 802
 803         cell = get_prop_check_min_len(blob, node, prop_name, count, &err);
 804         if (!err)
 805                 memcpy(array, cell, count);
 806         return err;
 807 }
 808
 809 const u8 *fdtdec_locate_byte_array(const void *blob, int node,
 810                              const char *prop_name, int count)
 811 {
 812         const u8 *cell;
 813         int err;
 814
 815         cell = get_prop_check_min_len(blob, node, prop_name, count, &err);
 816         if (err)
 817                 return NULL;
 818         return cell;
 819 }
 820
 821 int fdtdec_get_config_int(const void *blob, const char *prop_name,
 822                 int default_val)
 823 {
 824         int config_node;
 825
 826         debug("%s: %s\n", __func__, prop_name);
 827         config_node = fdt_path_offset(blob, "/config");
 828         if (config_node < 0)
 829                 return default_val;
 830         return fdtdec_get_int(blob, config_node, prop_name, default_val);
 831 }
 832
 833 int fdtdec_get_config_bool(const void *blob, const char *prop_name)
 834 {
 835         int config_node;
 836         const void *prop;
 837
 838         debug("%s: %s\n", __func__, prop_name);
 839         config_node = fdt_path_offset(blob, "/config");
 840         if (config_node < 0)
 841                 return 0;
 842         prop = fdt_get_property(blob, config_node, prop_name, NULL);
 843
 844         return prop != NULL;
 845 }
 846
 847 char *fdtdec_get_config_string(const void *blob, const char *prop_name)
 848 {
 849         const char *nodep;
 850         int nodeoffset;
 851         int len;
 852
 853         debug("%s: %s\n", __func__, prop_name);
 854         nodeoffset = fdt_path_offset(blob, "/config");
 855         if (nodeoffset < 0)
 856                 return NULL;
 857
 858         nodep = fdt_getprop(blob, nodeoffset, prop_name, &len);
 859         if (!nodep)
 860                 return NULL;
 861
 862         return (char *)nodep;
 863 }
 864
 865 int fdtdec_decode_region(const void *blob, int node, const char *prop_name,
 866                          fdt_addr_t *basep, fdt_size_t *sizep)
 867 {
 868         const fdt_addr_t *cell;
 869         int len;
 870
 871         debug("%s: %s: %s\n", __func__, fdt_get_name(blob, node, NULL),
 872               prop_name);
 873         cell = fdt_getprop(blob, node, prop_name, &len);
 874         if (!cell || (len < sizeof(fdt_addr_t) * 2)) {
 875                 debug("cell=%p, len=%d\n", cell, len);
 876                 return -1;
 877         }
 878
 879         *basep = fdt_addr_to_cpu(*cell);
 880         *sizep = fdt_size_to_cpu(cell[1]);
 881         debug("%s: base=%08lx, size=%lx\n", __func__, (ulong)*basep,
 882               (ulong)*sizep);
 883
 884         return 0;
 885 }
 886
 887 /**
 888  * Read a flash entry from the fdt
 889  *
 890  * @param blob          FDT blob
 891  * @param node          Offset of node to read
 892  * @param name          Name of node being read
 893  * @param entry         Place to put offset and size of this node
 894  * @return 0 if ok, -ve on error
 895  */
 896 int fdtdec_read_fmap_entry(const void *blob, int node, const char *name,
 897                            struct fmap_entry *entry)
 898 {
 899         const char *prop;
 900         u32 reg[2];
 901
 902         if (fdtdec_get_int_array(blob, node, "reg", reg, 2)) {
 903                 debug("Node '%s' has bad/missing 'reg' property\n", name);
 904                 return -FDT_ERR_NOTFOUND;
 905         }
 906         entry->offset = reg[0];
 907         entry->length = reg[1];
 908         entry->used = fdtdec_get_int(blob, node, "used", entry->length);
 909         prop = fdt_getprop(blob, node, "compress", NULL);
 910         entry->compress_algo = prop && !strcmp(prop, "lzo") ?
 911                 FMAP_COMPRESS_LZO : FMAP_COMPRESS_NONE;
 912         prop = fdt_getprop(blob, node, "hash", &entry->hash_size);
 913         entry->hash_algo = prop ? FMAP_HASH_SHA256 : FMAP_HASH_NONE;
 914         entry->hash = (uint8_t *)prop;
 915
 916         return 0;
 917 }
 918
 919 static u64 fdtdec_get_number(const fdt32_t *ptr, unsigned int cells)
 920 {
 921         u64 number = 0;
 922
 923         while (cells--)
 924                 number = (number << 32) | fdt32_to_cpu(*ptr++);
 925
 926         return number;
 927 }
 928
 929 int fdt_get_resource(const void *fdt, int node, const char *property,
 930                      unsigned int index, struct fdt_resource *res)
 931 {
 932         const fdt32_t *ptr, *end;
 933         int na, ns, len, parent;
 934         unsigned int i = 0;
 935
 936         parent = fdt_parent_offset(fdt, node);
 937         if (parent < 0)
 938                 return parent;
 939
 940         na = fdt_address_cells(fdt, parent);
 941         ns = fdt_size_cells(fdt, parent);
 942
 943         ptr = fdt_getprop(fdt, node, property, &len);
 944         if (!ptr)
 945                 return len;
 946
 947         end = ptr + len / sizeof(*ptr);
 948
 949         while (ptr + na + ns <= end) {
 950                 if (i == index) {
 951                         res->start = res->end = fdtdec_get_number(ptr, na);
 952                         res->end += fdtdec_get_number(&ptr[na], ns) - 1;
 953                         return 0;
 954                 }
 955
 956                 ptr += na + ns;
 957                 i++;
 958         }
 959
 960         return -FDT_ERR_NOTFOUND;
 961 }
 962
 963 int fdt_get_named_resource(const void *fdt, int node, const char *property,
 964                            const char *prop_names, const char *name,
 965                            struct fdt_resource *res)
 966 {
 967         int index;
 968
 969         index = fdt_find_string(fdt, node, prop_names, name);
 970         if (index < 0)
 971                 return index;
 972
 973         return fdt_get_resource(fdt, node, property, index, res);
 974 }
 975
 976 int fdtdec_decode_memory_region(const void *blob, int config_node,
 977                                 const char *mem_type, const char *suffix,
 978                                 fdt_addr_t *basep, fdt_size_t *sizep)
 979 {
 980         char prop_name[50];
 981         const char *mem;
 982         fdt_size_t size, offset_size;
 983         fdt_addr_t base, offset;
 984         int node;
 985
 986         if (config_node == -1) {
 987                 config_node = fdt_path_offset(blob, "/config");
 988                 if (config_node < 0) {
 989                         debug("%s: Cannot find /config node\n", __func__);
 990                         return -ENOENT;
 991                 }
 992         }
 993         if (!suffix)
 994                 suffix = "";
 995
 996         snprintf(prop_name, sizeof(prop_name), "%s-memory%s", mem_type,
 997                  suffix);
 998         mem = fdt_getprop(blob, config_node, prop_name, NULL);
 999         if (!mem) {
1000                 debug("%s: No memory type for '%s', using /memory\n", __func__,
1001                       prop_name);
1002                 mem = "/memory";
1003         }
1004
1005         node = fdt_path_offset(blob, mem);
1006         if (node < 0) {
1007                 debug("%s: Failed to find node '%s': %s\n", __func__, mem,
1008                       fdt_strerror(node));
1009                 return -ENOENT;
1010         }
1011
1012         /*
1013          * Not strictly correct - the memory may have multiple banks. We just
1014          * use the first
1015          */
1016         if (fdtdec_decode_region(blob, node, "reg", &base, &size)) {
1017                 debug("%s: Failed to decode memory region %s\n", __func__,
1018                       mem);
1019                 return -EINVAL;
1020         }
1021
1022         snprintf(prop_name, sizeof(prop_name), "%s-offset%s", mem_type,
1023                  suffix);
1024         if (fdtdec_decode_region(blob, config_node, prop_name, &offset,
1025                                  &offset_size)) {
1026                 debug("%s: Failed to decode memory region '%s'\n", __func__,
1027                       prop_name);
1028                 return -EINVAL;
1029         }
1030
1031         *basep = base + offset;
1032         *sizep = offset_size;
1033
1034         return 0;
1035 }
1036 #endif