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