boot/image-fdt.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2013, Google Inc.
   4  *
   5  * (C) Copyright 2008 Semihalf
   6  *
   7  * (C) Copyright 2000-2006
   8  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   9  */
  10
  11 #include <common.h>
  12 #include <fdt_support.h>
  13 #include <fdtdec.h>
  14 #include <env.h>
  15 #include <errno.h>
  16 #include <image.h>
  17 #include <lmb.h>
  18 #include <log.h>
  19 #include <malloc.h>
  20 #include <asm/global_data.h>
  21 #include <linux/libfdt.h>
  22 #include <mapmem.h>
  23 #include <asm/io.h>
  24 #include <dm/ofnode.h>
  25 #include <tee/optee.h>
  26
  27 /* adding a ramdisk needs 0x44 bytes in version 2008.10 */
  28 #define FDT_RAMDISK_OVERHEAD    0x80
  29
  30 DECLARE_GLOBAL_DATA_PTR;
  31
  32 static void fdt_error(const char *msg)
  33 {
  34         puts("ERROR: ");
  35         puts(msg);
  36         puts(" - must RESET the board to recover.\n");
  37 }
  38
  39 #if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
  40 static const struct legacy_img_hdr *image_get_fdt(ulong fdt_addr)
  41 {
  42         const struct legacy_img_hdr *fdt_hdr = map_sysmem(fdt_addr, 0);
  43
  44         image_print_contents(fdt_hdr);
  45
  46         puts("   Verifying Checksum ... ");
  47         if (!image_check_hcrc(fdt_hdr)) {
  48                 fdt_error("fdt header checksum invalid");
  49                 return NULL;
  50         }
  51
  52         if (!image_check_dcrc(fdt_hdr)) {
  53                 fdt_error("fdt checksum invalid");
  54                 return NULL;
  55         }
  56         puts("OK\n");
  57
  58         if (!image_check_type(fdt_hdr, IH_TYPE_FLATDT)) {
  59                 fdt_error("uImage is not a fdt");
  60                 return NULL;
  61         }
  62         if (image_get_comp(fdt_hdr) != IH_COMP_NONE) {
  63                 fdt_error("uImage is compressed");
  64                 return NULL;
  65         }
  66         if (fdt_check_header((void *)image_get_data(fdt_hdr)) != 0) {
  67                 fdt_error("uImage data is not a fdt");
  68                 return NULL;
  69         }
  70         return fdt_hdr;
  71 }
  72 #endif
  73
  74 static void boot_fdt_reserve_region(struct lmb *lmb, uint64_t addr,
  75                                     uint64_t size, enum lmb_flags flags)
  76 {
  77         long ret;
  78
  79         ret = lmb_reserve_flags(lmb, addr, size, flags);
  80         if (ret >= 0) {
  81                 debug("   reserving fdt memory region: addr=%llx size=%llx flags=%x\n",
  82                       (unsigned long long)addr,
  83                       (unsigned long long)size, flags);
  84         } else {
  85                 puts("ERROR: reserving fdt memory region failed ");
  86                 printf("(addr=%llx size=%llx flags=%x)\n",
  87                        (unsigned long long)addr,
  88                        (unsigned long long)size, flags);
  89         }
  90 }
  91
  92 /**
  93  * boot_fdt_add_mem_rsv_regions - Mark the memreserve and reserved-memory
  94  * sections as unusable
  95  * @lmb: pointer to lmb handle, will be used for memory mgmt
  96  * @fdt_blob: pointer to fdt blob base address
  97  *
  98  * Adds the and reserved-memorymemreserve regions in the dtb to the lmb block.
  99  * Adding the memreserve regions prevents u-boot from using them to store the
 100  * initrd or the fdt blob.
 101  */
 102 void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob)
 103 {
 104         uint64_t addr, size;
 105         int i, total, ret;
 106         int nodeoffset, subnode;
 107         struct fdt_resource res;
 108         enum lmb_flags flags;
 109
 110         if (fdt_check_header(fdt_blob) != 0)
 111                 return;
 112
 113         /* process memreserve sections */
 114         total = fdt_num_mem_rsv(fdt_blob);
 115         for (i = 0; i < total; i++) {
 116                 if (fdt_get_mem_rsv(fdt_blob, i, &addr, &size) != 0)
 117                         continue;
 118                 boot_fdt_reserve_region(lmb, addr, size, LMB_NONE);
 119         }
 120
 121         /* process reserved-memory */
 122         nodeoffset = fdt_subnode_offset(fdt_blob, 0, "reserved-memory");
 123         if (nodeoffset >= 0) {
 124                 subnode = fdt_first_subnode(fdt_blob, nodeoffset);
 125                 while (subnode >= 0) {
 126                         /* check if this subnode has a reg property */
 127                         ret = fdt_get_resource(fdt_blob, subnode, "reg", 0,
 128                                                &res);
 129                         if (!ret && fdtdec_get_is_enabled(fdt_blob, subnode)) {
 130                                 flags = LMB_NONE;
 131                                 if (fdtdec_get_bool(fdt_blob, subnode,
 132                                                     "no-map"))
 133                                         flags = LMB_NOMAP;
 134                                 addr = res.start;
 135                                 size = res.end - res.start + 1;
 136                                 boot_fdt_reserve_region(lmb, addr, size, flags);
 137                         }
 138
 139                         subnode = fdt_next_subnode(fdt_blob, subnode);
 140                 }
 141         }
 142 }
 143
 144 /**
 145  * boot_relocate_fdt - relocate flat device tree
 146  * @lmb: pointer to lmb handle, will be used for memory mgmt
 147  * @of_flat_tree: pointer to a char* variable, will hold fdt start address
 148  * @of_size: pointer to a ulong variable, will hold fdt length
 149  *
 150  * boot_relocate_fdt() allocates a region of memory within the bootmap and
 151  * relocates the of_flat_tree into that region, even if the fdt is already in
 152  * the bootmap.  It also expands the size of the fdt by CONFIG_SYS_FDT_PAD
 153  * bytes.
 154  *
 155  * of_flat_tree and of_size are set to final (after relocation) values
 156  *
 157  * returns:
 158  *      0 - success
 159  *      1 - failure
 160  */
 161 int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size)
 162 {
 163         void    *fdt_blob = *of_flat_tree;
 164         void    *of_start = NULL;
 165         u64     start, size, usable;
 166         char    *fdt_high;
 167         ulong   mapsize, low;
 168         ulong   of_len = 0;
 169         int     bank;
 170         int     err;
 171         int     disable_relocation = 0;
 172
 173         /* nothing to do */
 174         if (*of_size == 0)
 175                 return 0;
 176
 177         if (fdt_check_header(fdt_blob) != 0) {
 178                 fdt_error("image is not a fdt");
 179                 goto error;
 180         }
 181
 182         /* position on a 4K boundary before the alloc_current */
 183         /* Pad the FDT by a specified amount */
 184         of_len = *of_size + CONFIG_SYS_FDT_PAD;
 185
 186         /* If fdt_high is set use it to select the relocation address */
 187         fdt_high = env_get("fdt_high");
 188         if (fdt_high) {
 189                 ulong desired_addr = hextoul(fdt_high, NULL);
 190                 ulong addr;
 191
 192                 if (desired_addr == ~0UL) {
 193                         /* All ones means use fdt in place */
 194                         of_start = fdt_blob;
 195                         lmb_reserve(lmb, map_to_sysmem(of_start), of_len);
 196                         disable_relocation = 1;
 197                 } else if (desired_addr) {
 198                         addr = lmb_alloc_base(lmb, of_len, 0x1000,
 199                                               desired_addr);
 200                         of_start = map_sysmem(addr, of_len);
 201                         if (of_start == NULL) {
 202                                 puts("Failed using fdt_high value for Device Tree");
 203                                 goto error;
 204                         }
 205                 } else {
 206                         addr = lmb_alloc(lmb, of_len, 0x1000);
 207                         of_start = map_sysmem(addr, of_len);
 208                 }
 209         } else {
 210                 mapsize = env_get_bootm_mapsize();
 211                 low = env_get_bootm_low();
 212                 of_start = NULL;
 213
 214                 for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) {
 215                         start = gd->bd->bi_dram[bank].start;
 216                         size = gd->bd->bi_dram[bank].size;
 217
 218                         /* DRAM bank addresses are too low, skip it. */
 219                         if (start + size < low)
 220                                 continue;
 221
 222                         usable = min(size, (u64)mapsize);
 223
 224                         /*
 225                          * At least part of this DRAM bank is usable, try
 226                          * using it for LMB allocation.
 227                          */
 228                         of_start = map_sysmem((ulong)lmb_alloc_base(lmb,
 229                                     of_len, 0x1000, start + usable), of_len);
 230                         /* Allocation succeeded, use this block. */
 231                         if (of_start != NULL)
 232                                 break;
 233
 234                         /*
 235                          * Reduce the mapping size in the next bank
 236                          * by the size of attempt in current bank.
 237                          */
 238                         mapsize -= usable - max(start, (u64)low);
 239                         if (!mapsize)
 240                                 break;
 241                 }
 242         }
 243
 244         if (of_start == NULL) {
 245                 puts("device tree - allocation error\n");
 246                 goto error;
 247         }
 248
 249         if (disable_relocation) {
 250                 /*
 251                  * We assume there is space after the existing fdt to use
 252                  * for padding
 253                  */
 254                 fdt_set_totalsize(of_start, of_len);
 255                 printf("   Using Device Tree in place at %p, end %p\n",
 256                        of_start, of_start + of_len - 1);
 257         } else {
 258                 debug("## device tree at %p ... %p (len=%ld [0x%lX])\n",
 259                       fdt_blob, fdt_blob + *of_size - 1, of_len, of_len);
 260
 261                 printf("   Loading Device Tree to %p, end %p ... ",
 262                        of_start, of_start + of_len - 1);
 263
 264                 err = fdt_open_into(fdt_blob, of_start, of_len);
 265                 if (err != 0) {
 266                         fdt_error("fdt move failed");
 267                         goto error;
 268                 }
 269                 puts("OK\n");
 270         }
 271
 272         *of_flat_tree = of_start;
 273         *of_size = of_len;
 274
 275         if (IS_ENABLED(CONFIG_CMD_FDT))
 276                 set_working_fdt_addr(map_to_sysmem(*of_flat_tree));
 277         return 0;
 278
 279 error:
 280         return 1;
 281 }
 282
 283 /**
 284  * select_fdt() - Select and locate the FDT to use
 285  *
 286  * @images: pointer to the bootm images structure
 287  * @select: name of FDT to select, or NULL for any
 288  * @arch: expected FDT architecture
 289  * @fdt_addrp: pointer to a ulong variable, will hold FDT pointer
 290  * Return: 0 if OK, -ENOPKG if no FDT (but an error should not be reported),
 291  *      other -ve value on other error
 292  */
 293
 294 static int select_fdt(struct bootm_headers *images, const char *select, u8 arch,
 295                       ulong *fdt_addrp)
 296 {
 297         const char *buf;
 298         ulong fdt_addr;
 299
 300 #if CONFIG_IS_ENABLED(FIT)
 301         const char *fit_uname_config = images->fit_uname_cfg;
 302         const char *fit_uname_fdt = NULL;
 303         ulong default_addr;
 304         int fdt_noffset;
 305
 306         if (select) {
 307                         /*
 308                          * If the FDT blob comes from the FIT image and the
 309                          * FIT image address is omitted in the command line
 310                          * argument, try to use ramdisk or os FIT image
 311                          * address or default load address.
 312                          */
 313                         if (images->fit_uname_rd)
 314                                 default_addr = (ulong)images->fit_hdr_rd;
 315                         else if (images->fit_uname_os)
 316                                 default_addr = (ulong)images->fit_hdr_os;
 317                         else
 318                                 default_addr = image_load_addr;
 319
 320                         if (fit_parse_conf(select, default_addr, &fdt_addr,
 321                                            &fit_uname_config)) {
 322                                 debug("*  fdt: config '%s' from image at 0x%08lx\n",
 323                                       fit_uname_config, fdt_addr);
 324                         } else if (fit_parse_subimage(select, default_addr, &fdt_addr,
 325                                    &fit_uname_fdt)) {
 326                                 debug("*  fdt: subimage '%s' from image at 0x%08lx\n",
 327                                       fit_uname_fdt, fdt_addr);
 328                         } else
 329 #endif
 330                 {
 331                         fdt_addr = hextoul(select, NULL);
 332                         debug("*  fdt: cmdline image address = 0x%08lx\n",
 333                               fdt_addr);
 334                 }
 335 #if CONFIG_IS_ENABLED(FIT)
 336         } else {
 337                 /* use FIT configuration provided in first bootm
 338                  * command argument
 339                  */
 340                 fdt_addr = map_to_sysmem(images->fit_hdr_os);
 341                 fdt_noffset = fit_get_node_from_config(images, FIT_FDT_PROP,
 342                                                        fdt_addr);
 343                 if (fdt_noffset == -ENOENT)
 344                         return -ENOPKG;
 345                 else if (fdt_noffset < 0)
 346                         return fdt_noffset;
 347         }
 348 #endif
 349         debug("## Checking for 'FDT'/'FDT Image' at %08lx\n",
 350               fdt_addr);
 351
 352         /*
 353          * Check if there is an FDT image at the
 354          * address provided in the second bootm argument
 355          * check image type, for FIT images get a FIT node.
 356          */
 357         buf = map_sysmem(fdt_addr, 0);
 358         switch (genimg_get_format(buf)) {
 359 #if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
 360         case IMAGE_FORMAT_LEGACY: {
 361                         const struct legacy_img_hdr *fdt_hdr;
 362                         ulong load, load_end;
 363                         ulong image_start, image_data, image_end;
 364
 365                         /* verify fdt_addr points to a valid image header */
 366                         printf("## Flattened Device Tree from Legacy Image at %08lx\n",
 367                                fdt_addr);
 368                         fdt_hdr = image_get_fdt(fdt_addr);
 369                         if (!fdt_hdr)
 370                                 return -ENOPKG;
 371
 372                         /*
 373                          * move image data to the load address,
 374                          * make sure we don't overwrite initial image
 375                          */
 376                         image_start = (ulong)fdt_hdr;
 377                         image_data = (ulong)image_get_data(fdt_hdr);
 378                         image_end = image_get_image_end(fdt_hdr);
 379
 380                         load = image_get_load(fdt_hdr);
 381                         load_end = load + image_get_data_size(fdt_hdr);
 382
 383                         if (load == image_start ||
 384                             load == image_data) {
 385                                 fdt_addr = load;
 386                                 break;
 387                         }
 388
 389                         if ((load < image_end) && (load_end > image_start)) {
 390                                 fdt_error("fdt overwritten");
 391                                 return -EFAULT;
 392                         }
 393
 394                         debug("   Loading FDT from 0x%08lx to 0x%08lx\n",
 395                               image_data, load);
 396
 397                         memmove((void *)load,
 398                                 (void *)image_data,
 399                                 image_get_data_size(fdt_hdr));
 400
 401                         fdt_addr = load;
 402                         break;
 403                 }
 404 #endif
 405         case IMAGE_FORMAT_FIT:
 406                 /*
 407                  * This case will catch both: new uImage format
 408                  * (libfdt based) and raw FDT blob (also libfdt
 409                  * based).
 410                  */
 411 #if CONFIG_IS_ENABLED(FIT)
 412                         /* check FDT blob vs FIT blob */
 413                         if (!fit_check_format(buf, IMAGE_SIZE_INVAL)) {
 414                                 ulong load, len;
 415
 416                                 fdt_noffset = boot_get_fdt_fit(images, fdt_addr,
 417                                                                &fit_uname_fdt,
 418                                                                &fit_uname_config,
 419                                                                arch, &load, &len);
 420
 421                                 if (fdt_noffset < 0)
 422                                         return -ENOENT;
 423
 424                                 images->fit_hdr_fdt = map_sysmem(fdt_addr, 0);
 425                                 images->fit_uname_fdt = fit_uname_fdt;
 426                                 images->fit_noffset_fdt = fdt_noffset;
 427                                 fdt_addr = load;
 428
 429                                 break;
 430                 } else
 431 #endif
 432                 {
 433                         /*
 434                          * FDT blob
 435                          */
 436                         debug("*  fdt: raw FDT blob\n");
 437                         printf("## Flattened Device Tree blob at %08lx\n",
 438                                (long)fdt_addr);
 439                 }
 440                 break;
 441         default:
 442                 puts("ERROR: Did not find a cmdline Flattened Device Tree\n");
 443                 return -ENOENT;
 444         }
 445         *fdt_addrp = fdt_addr;
 446
 447         return 0;
 448 }
 449
 450 /**
 451  * boot_get_fdt - main fdt handling routine
 452  * @argc: command argument count
 453  * @argv: command argument list
 454  * @arch: architecture (IH_ARCH_...)
 455  * @images: pointer to the bootm images structure
 456  * @of_flat_tree: pointer to a char* variable, will hold fdt start address
 457  * @of_size: pointer to a ulong variable, will hold fdt length
 458  *
 459  * boot_get_fdt() is responsible for finding a valid flat device tree image.
 460  * Currently supported are the following ramdisk sources:
 461  *      - multicomponent kernel/ramdisk image,
 462  *      - commandline provided address of decicated ramdisk image.
 463  *
 464  * returns:
 465  *     0, if fdt image was found and valid, or skipped
 466  *     of_flat_tree and of_size are set to fdt start address and length if
 467  *     fdt image is found and valid
 468  *
 469  *     1, if fdt image is found but corrupted
 470  *     of_flat_tree and of_size are set to 0 if no fdt exists
 471  */
 472 int boot_get_fdt(int flag, int argc, char *const argv[], uint8_t arch,
 473                  struct bootm_headers *images, char **of_flat_tree, ulong *of_size)
 474 {
 475         ulong           img_addr;
 476         ulong           fdt_addr;
 477         char            *fdt_blob = NULL;
 478         void            *buf;
 479         const char *select = NULL;
 480
 481         *of_flat_tree = NULL;
 482         *of_size = 0;
 483
 484         img_addr = (argc == 0) ? image_load_addr : hextoul(argv[0], NULL);
 485         buf = map_sysmem(img_addr, 0);
 486
 487         if (argc > 2)
 488                 select = argv[2];
 489         if (select || genimg_has_config(images)) {
 490                 int ret;
 491
 492                 ret = select_fdt(images, select, arch, &fdt_addr);
 493                 if (ret == -ENOPKG)
 494                         goto no_fdt;
 495                 else if (ret)
 496                         return 1;
 497                 printf("   Booting using the fdt blob at %#08lx\n", fdt_addr);
 498                 fdt_blob = map_sysmem(fdt_addr, 0);
 499         } else if (images->legacy_hdr_valid &&
 500                         image_check_type(&images->legacy_hdr_os_copy,
 501                                          IH_TYPE_MULTI)) {
 502                 ulong fdt_data, fdt_len;
 503
 504                 /*
 505                  * Now check if we have a legacy multi-component image,
 506                  * get second entry data start address and len.
 507                  */
 508                 printf("## Flattened Device Tree from multi component Image at %08lX\n",
 509                        (ulong)images->legacy_hdr_os);
 510
 511                 image_multi_getimg(images->legacy_hdr_os, 2, &fdt_data,
 512                                    &fdt_len);
 513                 if (fdt_len) {
 514                         fdt_blob = (char *)fdt_data;
 515                         printf("   Booting using the fdt at 0x%p\n", fdt_blob);
 516
 517                         if (fdt_check_header(fdt_blob) != 0) {
 518                                 fdt_error("image is not a fdt");
 519                                 goto error;
 520                         }
 521
 522                         if (fdt_totalsize(fdt_blob) != fdt_len) {
 523                                 fdt_error("fdt size != image size");
 524                                 goto error;
 525                         }
 526                 } else {
 527                         debug("## No Flattened Device Tree\n");
 528                         goto no_fdt;
 529                 }
 530 #ifdef CONFIG_ANDROID_BOOT_IMAGE
 531         } else if (genimg_get_format(buf) == IMAGE_FORMAT_ANDROID) {
 532                 void *hdr = buf;
 533                 ulong           fdt_data, fdt_len;
 534                 u32                     fdt_size, dtb_idx;
 535                 /*
 536                  * Firstly check if this android boot image has dtb field.
 537                  */
 538                 dtb_idx = (u32)env_get_ulong("adtb_idx", 10, 0);
 539                 if (android_image_get_dtb_by_index((ulong)hdr, 0,
 540                                                    dtb_idx, &fdt_addr, &fdt_size)) {
 541                         fdt_blob = (char *)map_sysmem(fdt_addr, 0);
 542                         if (fdt_check_header(fdt_blob))
 543                                 goto no_fdt;
 544
 545                         debug("## Using FDT in Android image dtb area with idx %u\n", dtb_idx);
 546                 } else if (!android_image_get_second(hdr, &fdt_data, &fdt_len) &&
 547                         !fdt_check_header((char *)fdt_data)) {
 548                         fdt_blob = (char *)fdt_data;
 549                         if (fdt_totalsize(fdt_blob) != fdt_len)
 550                                 goto error;
 551
 552                         debug("## Using FDT in Android image second area\n");
 553                 } else {
 554                         fdt_addr = env_get_hex("fdtaddr", 0);
 555                         if (!fdt_addr)
 556                                 goto no_fdt;
 557
 558                         fdt_blob = map_sysmem(fdt_addr, 0);
 559                         if (fdt_check_header(fdt_blob))
 560                                 goto no_fdt;
 561
 562                         debug("## Using FDT at ${fdtaddr}=Ox%lx\n", fdt_addr);
 563                 }
 564 #endif
 565         } else {
 566                 debug("## No Flattened Device Tree\n");
 567                 goto no_fdt;
 568         }
 569
 570         *of_flat_tree = fdt_blob;
 571         *of_size = fdt_totalsize(fdt_blob);
 572         debug("   of_flat_tree at 0x%08lx size 0x%08lx\n",
 573               (ulong)*of_flat_tree, *of_size);
 574
 575         return 0;
 576
 577 no_fdt:
 578         debug("Continuing to boot without FDT\n");
 579         return 0;
 580 error:
 581         return 1;
 582 }
 583
 584 /*
 585  * Verify the device tree.
 586  *
 587  * This function is called after all device tree fix-ups have been enacted,
 588  * so that the final device tree can be verified.  The definition of "verified"
 589  * is up to the specific implementation.  However, it generally means that the
 590  * addresses of some of the devices in the device tree are compared with the
 591  * actual addresses at which U-Boot has placed them.
 592  *
 593  * Returns 1 on success, 0 on failure.  If 0 is returned, U-Boot will halt the
 594  * boot process.
 595  */
 596 __weak int ft_verify_fdt(void *fdt)
 597 {
 598         return 1;
 599 }
 600
 601 __weak int arch_fixup_fdt(void *blob)
 602 {
 603         return 0;
 604 }
 605
 606 int image_setup_libfdt(struct bootm_headers *images, void *blob,
 607                        int of_size, struct lmb *lmb)
 608 {
 609         ulong *initrd_start = &images->initrd_start;
 610         ulong *initrd_end = &images->initrd_end;
 611         int ret = -EPERM;
 612         int fdt_ret;
 613
 614         if (fdt_root(blob) < 0) {
 615                 printf("ERROR: root node setup failed\n");
 616                 goto err;
 617         }
 618         if (fdt_chosen(blob) < 0) {
 619                 printf("ERROR: /chosen node create failed\n");
 620                 goto err;
 621         }
 622         if (arch_fixup_fdt(blob) < 0) {
 623                 printf("ERROR: arch-specific fdt fixup failed\n");
 624                 goto err;
 625         }
 626
 627         fdt_ret = optee_copy_fdt_nodes(blob);
 628         if (fdt_ret) {
 629                 printf("ERROR: transfer of optee nodes to new fdt failed: %s\n",
 630                        fdt_strerror(fdt_ret));
 631                 goto err;
 632         }
 633
 634         /* Store name of configuration node as u-boot,bootconf in /chosen node */
 635         if (images->fit_uname_cfg)
 636                 fdt_find_and_setprop(blob, "/chosen", "u-boot,bootconf",
 637                                         images->fit_uname_cfg,
 638                                         strlen(images->fit_uname_cfg) + 1, 1);
 639
 640         /* Update ethernet nodes */
 641         fdt_fixup_ethernet(blob);
 642 #if IS_ENABLED(CONFIG_CMD_PSTORE)
 643         /* Append PStore configuration */
 644         fdt_fixup_pstore(blob);
 645 #endif
 646         if (IS_ENABLED(CONFIG_OF_BOARD_SETUP)) {
 647                 const char *skip_board_fixup;
 648
 649                 skip_board_fixup = env_get("skip_board_fixup");
 650                 if (skip_board_fixup && ((int)simple_strtol(skip_board_fixup, NULL, 10) == 1)) {
 651                         printf("skip board fdt fixup\n");
 652                 } else {
 653                         fdt_ret = ft_board_setup(blob, gd->bd);
 654                         if (fdt_ret) {
 655                                 printf("ERROR: board-specific fdt fixup failed: %s\n",
 656                                        fdt_strerror(fdt_ret));
 657                                 goto err;
 658                         }
 659                 }
 660         }
 661         if (IS_ENABLED(CONFIG_OF_SYSTEM_SETUP)) {
 662                 fdt_ret = ft_system_setup(blob, gd->bd);
 663                 if (fdt_ret) {
 664                         printf("ERROR: system-specific fdt fixup failed: %s\n",
 665                                fdt_strerror(fdt_ret));
 666                         goto err;
 667                 }
 668         }
 669         if (!of_live_active() && CONFIG_IS_ENABLED(EVENT)) {
 670                 struct event_ft_fixup fixup;
 671
 672                 fixup.tree = oftree_from_fdt(blob);
 673                 fixup.images = images;
 674                 if (oftree_valid(fixup.tree)) {
 675                         ret = event_notify(EVT_FT_FIXUP, &fixup, sizeof(fixup));
 676                         if (ret) {
 677                                 printf("ERROR: fdt fixup event failed: %d\n",
 678                                        ret);
 679                                 goto err;
 680                         }
 681                 }
 682         }
 683
 684         /* Delete the old LMB reservation */
 685         if (lmb)
 686                 lmb_free(lmb, (phys_addr_t)(u32)(uintptr_t)blob,
 687                          (phys_size_t)fdt_totalsize(blob));
 688
 689         ret = fdt_shrink_to_minimum(blob, 0);
 690         if (ret < 0)
 691                 goto err;
 692         of_size = ret;
 693
 694         if (*initrd_start && *initrd_end) {
 695                 of_size += FDT_RAMDISK_OVERHEAD;
 696                 fdt_set_totalsize(blob, of_size);
 697         }
 698         /* Create a new LMB reservation */
 699         if (lmb)
 700                 lmb_reserve(lmb, (ulong)blob, of_size);
 701
 702         fdt_initrd(blob, *initrd_start, *initrd_end);
 703         if (!ft_verify_fdt(blob))
 704                 goto err;
 705
 706 #if defined(CONFIG_ARCH_KEYSTONE)
 707         if (IS_ENABLED(CONFIG_OF_BOARD_SETUP))
 708                 ft_board_setup_ex(blob, gd->bd);
 709 #endif
 710
 711         return 0;
 712 err:
 713         printf(" - must RESET the board to recover.\n\n");
 714
 715         return ret;
 716 }