git.sur5r.net Git - u-boot/blob - lib_ppc/bootm.c

   1 /*
   2  * (C) Copyright 2008 Semihalf
   3  *
   4  * (C) Copyright 2000-2006
   5  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   6  *
   7  * See file CREDITS for list of people who contributed to this
   8  * project.
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License as
  12  * published by the Free Software Foundation; either version 2 of
  13  * the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  23  * MA 02111-1307 USA
  24  */
  25
  26
  27 #include <common.h>
  28 #include <watchdog.h>
  29 #include <command.h>
  30 #include <image.h>
  31 #include <malloc.h>
  32 #include <zlib.h>
  33 #include <bzlib.h>
  34 #include <environment.h>
  35 #include <asm/byteorder.h>
  36
  37 #if defined(CONFIG_OF_LIBFDT)
  38 #include <fdt.h>
  39 #include <libfdt.h>
  40 #include <fdt_support.h>
  41
  42 static void fdt_error (const char *msg);
  43 static int boot_get_fdt (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
  44                 bootm_headers_t *images, char **of_flat_tree, ulong *of_size);
  45 static int boot_relocate_fdt (struct lmb *lmb, ulong bootmap_base,
  46                 cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
  47                 char **of_flat_tree, ulong *of_size);
  48 #endif
  49
  50 #ifdef CFG_INIT_RAM_LOCK
  51 #include <asm/cache.h>
  52 #endif
  53
  54 DECLARE_GLOBAL_DATA_PTR;
  55
  56 extern int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
  57 extern ulong get_effective_memsize(void);
  58 static ulong get_sp (void);
  59 static void set_clocks_in_mhz (bd_t *kbd);
  60
  61 #ifndef CFG_LINUX_LOWMEM_MAX_SIZE
  62 #define CFG_LINUX_LOWMEM_MAX_SIZE       (768*1024*1024)
  63 #endif
  64
  65 void  __attribute__((noinline))
  66 do_bootm_linux(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
  67                 bootm_headers_t *images)
  68 {
  69         ulong   sp;
  70
  71         ulong   initrd_start, initrd_end;
  72         ulong   rd_data_start, rd_data_end, rd_len;
  73         ulong   size;
  74
  75         ulong   cmd_start, cmd_end, bootmap_base;
  76         bd_t    *kbd;
  77         ulong   ep = 0;
  78         void    (*kernel)(bd_t *, ulong, ulong, ulong, ulong);
  79         int     ret;
  80         ulong   of_size = 0;
  81         struct lmb *lmb = images->lmb;
  82
  83 #if defined(CONFIG_OF_LIBFDT)
  84         char    *of_flat_tree = NULL;
  85 #endif
  86
  87         bootmap_base = getenv_bootm_low();
  88         size = getenv_bootm_size();
  89
  90 #ifdef DEBUG
  91         if (((u64)bootmap_base + size) > (CFG_SDRAM_BASE + (u64)gd->ram_size))
  92                 puts("WARNING: bootm_low + bootm_size exceed total memory\n");
  93         if ((bootmap_base + size) > get_effective_memsize())
  94                 puts("WARNING: bootm_low + bootm_size exceed eff. memory\n");
  95 #endif
  96
  97         size = min(size, get_effective_memsize());
  98         size = min(size, CFG_LINUX_LOWMEM_MAX_SIZE);
  99
 100         if (size < getenv_bootm_size()) {
 101                 ulong base = bootmap_base + size;
 102                 printf("WARNING: adjusting available memory to %x\n", size);
 103                 lmb_reserve(lmb, base, getenv_bootm_size() - size);
 104         }
 105
 106         /*
 107          * Booting a (Linux) kernel image
 108          *
 109          * Allocate space for command line and board info - the
 110          * address should be as high as possible within the reach of
 111          * the kernel (see CFG_BOOTMAPSZ settings), but in unused
 112          * memory, which means far enough below the current stack
 113          * pointer.
 114          */
 115         sp = get_sp();
 116         debug ("## Current stack ends at 0x%08lx\n", sp);
 117
 118         /* adjust sp by 1K to be safe */
 119         sp -= 1024;
 120         lmb_reserve(lmb, sp, (CFG_SDRAM_BASE + get_effective_memsize() - sp));
 121
 122 #if defined(CONFIG_OF_LIBFDT)
 123         /* find flattened device tree */
 124         ret = boot_get_fdt (cmdtp, flag, argc, argv, images, &of_flat_tree, &of_size);
 125
 126         if (ret)
 127                 goto error;
 128 #endif
 129
 130         if (!of_size) {
 131                 /* allocate space and init command line */
 132                 ret = boot_get_cmdline (lmb, &cmd_start, &cmd_end, bootmap_base);
 133                 if (ret) {
 134                         puts("ERROR with allocation of cmdline\n");
 135                         goto error;
 136                 }
 137
 138                 /* allocate space for kernel copy of board info */
 139                 ret = boot_get_kbd (lmb, &kbd, bootmap_base);
 140                 if (ret) {
 141                         puts("ERROR with allocation of kernel bd\n");
 142                         goto error;
 143                 }
 144                 set_clocks_in_mhz(kbd);
 145         }
 146
 147         /* find kernel entry point */
 148         if (images->legacy_hdr_valid) {
 149                 ep = image_get_ep (images->legacy_hdr_os);
 150 #if defined(CONFIG_FIT)
 151         } else if (images->fit_uname_os) {
 152                 ret = fit_image_get_entry (images->fit_hdr_os,
 153                                 images->fit_noffset_os, &ep);
 154                 if (ret) {
 155                         puts ("Can't get entry point property!\n");
 156                         goto error;
 157                 }
 158 #endif
 159         } else {
 160                 puts ("Could not find kernel entry point!\n");
 161                 goto error;
 162         }
 163         kernel = (void (*)(bd_t *, ulong, ulong, ulong, ulong))ep;
 164
 165         /* find ramdisk */
 166         ret = boot_get_ramdisk (argc, argv, images, IH_ARCH_PPC,
 167                         &rd_data_start, &rd_data_end);
 168         if (ret)
 169                 goto error;
 170
 171         rd_len = rd_data_end - rd_data_start;
 172
 173 #if defined(CONFIG_OF_LIBFDT)
 174         ret = boot_relocate_fdt (lmb, bootmap_base,
 175                 cmdtp, flag, argc, argv, &of_flat_tree, &of_size);
 176
 177         /*
 178          * Add the chosen node if it doesn't exist, add the env and bd_t
 179          * if the user wants it (the logic is in the subroutines).
 180          */
 181         if (of_size) {
 182                 /* pass in dummy initrd info, we'll fix up later */
 183                 if (fdt_chosen(of_flat_tree, rd_data_start, rd_data_end, 0) < 0) {
 184                         fdt_error ("/chosen node create failed");
 185                         goto error;
 186                 }
 187 #ifdef CONFIG_OF_HAS_UBOOT_ENV
 188                 if (fdt_env(of_flat_tree) < 0) {
 189                         fdt_error ("/u-boot-env node create failed");
 190                         goto error;
 191                 }
 192 #endif
 193 #ifdef CONFIG_OF_HAS_BD_T
 194                 if (fdt_bd_t(of_flat_tree) < 0) {
 195                         fdt_error ("/bd_t node create failed");
 196                         goto error;
 197                 }
 198 #endif
 199 #ifdef CONFIG_OF_BOARD_SETUP
 200                 /* Call the board-specific fixup routine */
 201                 ft_board_setup(of_flat_tree, gd->bd);
 202 #endif
 203         }
 204 #endif  /* CONFIG_OF_LIBFDT */
 205
 206         ret = boot_ramdisk_high (lmb, rd_data_start, rd_len, &initrd_start, &initrd_end);
 207         if (ret)
 208                 goto error;
 209
 210 #if defined(CONFIG_OF_LIBFDT)
 211         /* fixup the initrd now that we know where it should be */
 212         if ((of_flat_tree) && (initrd_start && initrd_end)) {
 213                 uint64_t addr, size;
 214                 int  total = fdt_num_mem_rsv(of_flat_tree);
 215                 int  j;
 216
 217                 /* Look for the dummy entry and delete it */
 218                 for (j = 0; j < total; j++) {
 219                         fdt_get_mem_rsv(of_flat_tree, j, &addr, &size);
 220                         if (addr == rd_data_start) {
 221                                 fdt_del_mem_rsv(of_flat_tree, j);
 222                                 break;
 223                         }
 224                 }
 225
 226                 ret = fdt_add_mem_rsv(of_flat_tree, initrd_start,
 227                                         initrd_end - initrd_start + 1);
 228                 if (ret < 0) {
 229                         printf("fdt_chosen: %s\n", fdt_strerror(ret));
 230                         goto error;
 231                 }
 232
 233                 do_fixup_by_path_u32(of_flat_tree, "/chosen",
 234                                         "linux,initrd-start", initrd_start, 0);
 235                 do_fixup_by_path_u32(of_flat_tree, "/chosen",
 236                                         "linux,initrd-end", initrd_end, 0);
 237         }
 238 #endif
 239         debug ("## Transferring control to Linux (at address %08lx) ...\n",
 240                 (ulong)kernel);
 241
 242         show_boot_progress (15);
 243
 244 #if defined(CFG_INIT_RAM_LOCK) && !defined(CONFIG_E500)
 245         unlock_ram_in_cache();
 246 #endif
 247         if (!images->autostart)
 248                 return ;
 249
 250 #if defined(CONFIG_OF_LIBFDT)
 251         if (of_flat_tree) {     /* device tree; boot new style */
 252                 /*
 253                  * Linux Kernel Parameters (passing device tree):
 254                  *   r3: pointer to the fdt, followed by the board info data
 255                  *   r4: physical pointer to the kernel itself
 256                  *   r5: NULL
 257                  *   r6: NULL
 258                  *   r7: NULL
 259                  */
 260                 debug ("   Booting using OF flat tree...\n");
 261                 (*kernel) ((bd_t *)of_flat_tree, (ulong)kernel, 0, 0, 0);
 262                 /* does not return */
 263         } else
 264 #endif
 265         {
 266                 /*
 267                  * Linux Kernel Parameters (passing board info data):
 268                  *   r3: ptr to board info data
 269                  *   r4: initrd_start or 0 if no initrd
 270                  *   r5: initrd_end - unused if r4 is 0
 271                  *   r6: Start of command line string
 272                  *   r7: End   of command line string
 273                  */
 274                 debug ("   Booting using board info...\n");
 275                 (*kernel) (kbd, initrd_start, initrd_end, cmd_start, cmd_end);
 276                 /* does not return */
 277         }
 278         return ;
 279
 280 error:
 281         if (images->autostart)
 282                 do_reset (cmdtp, flag, argc, argv);
 283         return ;
 284 }
 285
 286 static ulong get_sp (void)
 287 {
 288         ulong sp;
 289
 290         asm( "mr %0,1": "=r"(sp) : );
 291         return sp;
 292 }
 293
 294 static void set_clocks_in_mhz (bd_t *kbd)
 295 {
 296         char    *s;
 297
 298         if ((s = getenv ("clocks_in_mhz")) != NULL) {
 299                 /* convert all clock information to MHz */
 300                 kbd->bi_intfreq /= 1000000L;
 301                 kbd->bi_busfreq /= 1000000L;
 302 #if defined(CONFIG_MPC8220)
 303                 kbd->bi_inpfreq /= 1000000L;
 304                 kbd->bi_pcifreq /= 1000000L;
 305                 kbd->bi_pevfreq /= 1000000L;
 306                 kbd->bi_flbfreq /= 1000000L;
 307                 kbd->bi_vcofreq /= 1000000L;
 308 #endif
 309 #if defined(CONFIG_CPM2)
 310                 kbd->bi_cpmfreq /= 1000000L;
 311                 kbd->bi_brgfreq /= 1000000L;
 312                 kbd->bi_sccfreq /= 1000000L;
 313                 kbd->bi_vco     /= 1000000L;
 314 #endif
 315 #if defined(CONFIG_MPC5xxx)
 316                 kbd->bi_ipbfreq /= 1000000L;
 317                 kbd->bi_pcifreq /= 1000000L;
 318 #endif /* CONFIG_MPC5xxx */
 319         }
 320 }
 321
 322 #if defined(CONFIG_OF_LIBFDT)
 323 static void fdt_error (const char *msg)
 324 {
 325         puts ("ERROR: ");
 326         puts (msg);
 327         puts (" - must RESET the board to recover.\n");
 328 }
 329
 330 static image_header_t *image_get_fdt (ulong fdt_addr)
 331 {
 332         image_header_t *fdt_hdr = (image_header_t *)fdt_addr;
 333
 334         image_print_contents (fdt_hdr);
 335
 336         puts ("   Verifying Checksum ... ");
 337         if (!image_check_hcrc (fdt_hdr)) {
 338                 fdt_error ("fdt header checksum invalid");
 339                 return NULL;
 340         }
 341
 342         if (!image_check_dcrc (fdt_hdr)) {
 343                 fdt_error ("fdt checksum invalid");
 344                 return NULL;
 345         }
 346         puts ("OK\n");
 347
 348         if (!image_check_type (fdt_hdr, IH_TYPE_FLATDT)) {
 349                 fdt_error ("uImage is not a fdt");
 350                 return NULL;
 351         }
 352         if (image_get_comp (fdt_hdr) != IH_COMP_NONE) {
 353                 fdt_error ("uImage is compressed");
 354                 return NULL;
 355         }
 356         if (fdt_check_header ((char *)image_get_data (fdt_hdr)) != 0) {
 357                 fdt_error ("uImage data is not a fdt");
 358                 return NULL;
 359         }
 360         return fdt_hdr;
 361 }
 362
 363 /**
 364  * fit_check_fdt - verify FIT format FDT subimage
 365  * @fit_hdr: pointer to the FIT  header
 366  * fdt_noffset: FDT subimage node offset within FIT image
 367  * @verify: data CRC verification flag
 368  *
 369  * fit_check_fdt() verifies integrity of the FDT subimage and from
 370  * specified FIT image.
 371  *
 372  * returns:
 373  *     1, on success
 374  *     0, on failure
 375  */
 376 #if defined(CONFIG_FIT)
 377 static int fit_check_fdt (const void *fit, int fdt_noffset, int verify)
 378 {
 379         fit_image_print (fit, fdt_noffset, "   ");
 380
 381         if (verify) {
 382                 puts ("   Verifying Hash Integrity ... ");
 383                 if (!fit_image_check_hashes (fit, fdt_noffset)) {
 384                         fdt_error ("Bad Data Hash");
 385                         return 0;
 386                 }
 387                 puts ("OK\n");
 388         }
 389
 390         if (!fit_image_check_type (fit, fdt_noffset, IH_TYPE_FLATDT)) {
 391                 fdt_error ("Not a FDT image");
 392                 return 0;
 393         }
 394
 395         if (!fit_image_check_comp (fit, fdt_noffset, IH_COMP_NONE)) {
 396                 fdt_error ("FDT image is compressed");
 397                 return 0;
 398         }
 399
 400         return 1;
 401 }
 402 #endif /* CONFIG_FIT */
 403
 404 static int boot_get_fdt (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
 405                 bootm_headers_t *images, char **of_flat_tree, ulong *of_size)
 406 {
 407         ulong           fdt_addr;
 408         image_header_t  *fdt_hdr;
 409         char            *fdt_blob = NULL;
 410         ulong           image_start, image_end;
 411         ulong           load_start, load_end;
 412 #if defined(CONFIG_FIT)
 413         void            *fit_hdr;
 414         const char      *fit_uname_config = NULL;
 415         const char      *fit_uname_fdt = NULL;
 416         ulong           default_addr;
 417         int             cfg_noffset;
 418         int             fdt_noffset;
 419         const void      *data;
 420         size_t          size;
 421 #endif
 422
 423         *of_flat_tree = NULL;
 424         *of_size = 0;
 425
 426         if (argc > 3 || genimg_has_config (images)) {
 427 #if defined(CONFIG_FIT)
 428                 if (argc > 3) {
 429                         /*
 430                          * If the FDT blob comes from the FIT image and the
 431                          * FIT image address is omitted in the command line
 432                          * argument, try to use ramdisk or os FIT image
 433                          * address or default load address.
 434                          */
 435                         if (images->fit_uname_rd)
 436                                 default_addr = (ulong)images->fit_hdr_rd;
 437                         else if (images->fit_uname_os)
 438                                 default_addr = (ulong)images->fit_hdr_os;
 439                         else
 440                                 default_addr = load_addr;
 441
 442                         if (fit_parse_conf (argv[3], default_addr,
 443                                                 &fdt_addr, &fit_uname_config)) {
 444                                 debug ("*  fdt: config '%s' from image at 0x%08lx\n",
 445                                                 fit_uname_config, fdt_addr);
 446                         } else if (fit_parse_subimage (argv[3], default_addr,
 447                                                 &fdt_addr, &fit_uname_fdt)) {
 448                                 debug ("*  fdt: subimage '%s' from image at 0x%08lx\n",
 449                                                 fit_uname_fdt, fdt_addr);
 450                         } else
 451 #endif
 452                         {
 453                                 fdt_addr = simple_strtoul(argv[3], NULL, 16);
 454                                 debug ("*  fdt: cmdline image address = 0x%08lx\n",
 455                                                 fdt_addr);
 456                         }
 457 #if defined(CONFIG_FIT)
 458                 } else {
 459                         /* use FIT configuration provided in first bootm
 460                          * command argument
 461                          */
 462                         fdt_addr = (ulong)images->fit_hdr_os;
 463                         fit_uname_config = images->fit_uname_cfg;
 464                         debug ("*  fdt: using config '%s' from image at 0x%08lx\n",
 465                                         fit_uname_config, fdt_addr);
 466
 467                         /*
 468                          * Check whether configuration has FDT blob defined,
 469                          * if not quit silently.
 470                          */
 471                         fit_hdr = (void *)fdt_addr;
 472                         cfg_noffset = fit_conf_get_node (fit_hdr,
 473                                         fit_uname_config);
 474                         if (cfg_noffset < 0) {
 475                                 debug ("*  fdt: no such config\n");
 476                                 return 0;
 477                         }
 478
 479                         fdt_noffset = fit_conf_get_fdt_node (fit_hdr,
 480                                         cfg_noffset);
 481                         if (fdt_noffset < 0) {
 482                                 debug ("*  fdt: no fdt in config\n");
 483                                 return 0;
 484                         }
 485                 }
 486 #endif
 487
 488                 debug ("## Checking for 'FDT'/'FDT Image' at %08lx\n",
 489                                 fdt_addr);
 490
 491                 /* copy from dataflash if needed */
 492                 fdt_addr = genimg_get_image (fdt_addr);
 493
 494                 /*
 495                  * Check if there is an FDT image at the
 496                  * address provided in the second bootm argument
 497                  * check image type, for FIT images get a FIT node.
 498                  */
 499                 switch (genimg_get_format ((void *)fdt_addr)) {
 500                 case IMAGE_FORMAT_LEGACY:
 501                         /* verify fdt_addr points to a valid image header */
 502                         printf ("## Flattened Device Tree from Legacy Image at %08lx\n",
 503                                         fdt_addr);
 504                         fdt_hdr = image_get_fdt (fdt_addr);
 505                         if (!fdt_hdr)
 506                                 goto error;
 507
 508                         /*
 509                          * move image data to the load address,
 510                          * make sure we don't overwrite initial image
 511                          */
 512                         image_start = (ulong)fdt_hdr;
 513                         image_end = image_get_image_end (fdt_hdr);
 514
 515                         load_start = image_get_load (fdt_hdr);
 516                         load_end = load_start + image_get_data_size (fdt_hdr);
 517
 518                         if ((load_start < image_end) && (load_end > image_start)) {
 519                                 fdt_error ("fdt overwritten");
 520                                 goto error;
 521                         }
 522
 523                         debug ("   Loading FDT from 0x%08lx to 0x%08lx\n",
 524                                         image_get_data (fdt_hdr), load_start);
 525
 526                         memmove ((void *)load_start,
 527                                         (void *)image_get_data (fdt_hdr),
 528                                         image_get_data_size (fdt_hdr));
 529
 530                         fdt_blob = (char *)load_start;
 531                         break;
 532                 case IMAGE_FORMAT_FIT:
 533                         /*
 534                          * This case will catch both: new uImage format
 535                          * (libfdt based) and raw FDT blob (also libfdt
 536                          * based).
 537                          */
 538 #if defined(CONFIG_FIT)
 539                         /* check FDT blob vs FIT blob */
 540                         if (fit_check_format ((const void *)fdt_addr)) {
 541                                 /*
 542                                  * FIT image
 543                                  */
 544                                 fit_hdr = (void *)fdt_addr;
 545                                 printf ("## Flattened Device Tree from FIT Image at %08lx\n",
 546                                                 fdt_addr);
 547
 548                                 if (!fit_uname_fdt) {
 549                                         /*
 550                                          * no FDT blob image node unit name,
 551                                          * try to get config node first. If
 552                                          * config unit node name is NULL
 553                                          * fit_conf_get_node() will try to
 554                                          * find default config node
 555                                          */
 556                                         cfg_noffset = fit_conf_get_node (fit_hdr,
 557                                                         fit_uname_config);
 558
 559                                         if (cfg_noffset < 0) {
 560                                                 fdt_error ("Could not find configuration node\n");
 561                                                 goto error;
 562                                         }
 563
 564                                         fit_uname_config = fdt_get_name (fit_hdr,
 565                                                         cfg_noffset, NULL);
 566                                         printf ("   Using '%s' configuration\n",
 567                                                         fit_uname_config);
 568
 569                                         fdt_noffset = fit_conf_get_fdt_node (fit_hdr,
 570                                                         cfg_noffset);
 571                                         fit_uname_fdt = fit_get_name (fit_hdr,
 572                                                         fdt_noffset, NULL);
 573                                 } else {
 574                                         /* get FDT component image node offset */
 575                                         fdt_noffset = fit_image_get_node (fit_hdr,
 576                                                         fit_uname_fdt);
 577                                 }
 578                                 if (fdt_noffset < 0) {
 579                                         fdt_error ("Could not find subimage node\n");
 580                                         goto error;
 581                                 }
 582
 583                                 printf ("   Trying '%s' FDT blob subimage\n",
 584                                                 fit_uname_fdt);
 585
 586                                 if (!fit_check_fdt (fit_hdr, fdt_noffset,
 587                                                         images->verify))
 588                                         goto error;
 589
 590                                 /* get ramdisk image data address and length */
 591                                 if (fit_image_get_data (fit_hdr, fdt_noffset,
 592                                                         &data, &size)) {
 593                                         fdt_error ("Could not find FDT subimage data");
 594                                         goto error;
 595                                 }
 596
 597                                 /* verift that image data is a proper FDT blob */
 598                                 if (fdt_check_header ((char *)data) != 0) {
 599                                         fdt_error ("Subimage data is not a FTD");
 600                                         goto error;
 601                                 }
 602
 603                                 /*
 604                                  * move image data to the load address,
 605                                  * make sure we don't overwrite initial image
 606                                  */
 607                                 image_start = (ulong)fit_hdr;
 608                                 image_end = fit_get_end (fit_hdr);
 609
 610                                 if (fit_image_get_load (fit_hdr, fdt_noffset,
 611                                                         &load_start) == 0) {
 612                                         load_end = load_start + size;
 613
 614                                         if ((load_start < image_end) &&
 615                                                         (load_end > image_start)) {
 616                                                 fdt_error ("FDT overwritten");
 617                                                 goto error;
 618                                         }
 619
 620                                         printf ("   Loading FDT from 0x%08lx to 0x%08lx\n",
 621                                                         (ulong)data, load_start);
 622
 623                                         memmove ((void *)load_start,
 624                                                         (void *)data, size);
 625
 626                                         fdt_blob = (char *)load_start;
 627                                 } else {
 628                                         fdt_blob = (char *)data;
 629                                 }
 630
 631                                 images->fit_hdr_fdt = fit_hdr;
 632                                 images->fit_uname_fdt = fit_uname_fdt;
 633                                 images->fit_noffset_fdt = fdt_noffset;
 634                                 break;
 635                         } else
 636 #endif
 637                         {
 638                                 /*
 639                                  * FDT blob
 640                                  */
 641                                 debug ("*  fdt: raw FDT blob\n");
 642                                 printf ("## Flattened Device Tree blob at %08lx\n", fdt_blob);
 643                                 fdt_blob = (char *)fdt_addr;
 644                         }
 645                         break;
 646                 default:
 647                         fdt_error ("Did not find a cmdline Flattened Device Tree");
 648                         goto error;
 649                 }
 650
 651                 printf ("   Booting using the fdt blob at 0x%x\n", fdt_blob);
 652
 653         } else if (images->legacy_hdr_valid &&
 654                         image_check_type (images->legacy_hdr_os, IH_TYPE_MULTI)) {
 655
 656                 ulong fdt_data, fdt_len;
 657
 658                 /*
 659                  * Now check if we have a legacy multi-component image,
 660                  * get second entry data start address and len.
 661                  */
 662                 printf ("## Flattened Device Tree from multi "
 663                         "component Image at %08lX\n",
 664                         (ulong)images->legacy_hdr_os);
 665
 666                 image_multi_getimg (images->legacy_hdr_os, 2, &fdt_data, &fdt_len);
 667                 if (fdt_len) {
 668
 669                         fdt_blob = (char *)fdt_data;
 670                         printf ("   Booting using the fdt at 0x%x\n", fdt_blob);
 671
 672                         if (fdt_check_header (fdt_blob) != 0) {
 673                                 fdt_error ("image is not a fdt");
 674                                 goto error;
 675                         }
 676
 677                         if (be32_to_cpu (fdt_totalsize (fdt_blob)) != fdt_len) {
 678                                 fdt_error ("fdt size != image size");
 679                                 goto error;
 680                         }
 681                 } else {
 682                         fdt_error ("Did not find a Flattened Device Tree "
 683                                 "in a legacy multi-component image");
 684                         goto error;
 685                 }
 686         } else {
 687                 debug ("## No Flattened Device Tree\n");
 688                 return 0;
 689         }
 690
 691         *of_flat_tree = fdt_blob;
 692         *of_size = be32_to_cpu (fdt_totalsize (fdt_blob));
 693         debug ("   of_flat_tree at 0x%08lx size 0x%08lx\n",
 694                         *of_flat_tree, *of_size);
 695
 696         return 0;
 697
 698 error:
 699         do_reset (cmdtp, flag, argc, argv);
 700         return 1;
 701 }
 702
 703 static int boot_relocate_fdt (struct lmb *lmb, ulong bootmap_base,
 704                 cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
 705                 char **of_flat_tree, ulong *of_size)
 706 {
 707         char    *fdt_blob = *of_flat_tree;
 708         ulong   relocate = 0;
 709         ulong   of_len = 0;
 710
 711         /* nothing to do */
 712         if (*of_size == 0)
 713                 return 0;
 714
 715         if (fdt_check_header (fdt_blob) != 0) {
 716                 fdt_error ("image is not a fdt");
 717                 goto error;
 718         }
 719
 720 #ifndef CFG_NO_FLASH
 721         /* move the blob if it is in flash (set relocate) */
 722         if (addr2info ((ulong)fdt_blob) != NULL)
 723                 relocate = 1;
 724 #endif
 725
 726         /*
 727          * The blob must be within CFG_BOOTMAPSZ,
 728          * so we flag it to be copied if it is not.
 729          */
 730         if (fdt_blob >= (char *)CFG_BOOTMAPSZ)
 731                 relocate = 1;
 732
 733         of_len = be32_to_cpu (fdt_totalsize (fdt_blob));
 734
 735         /* move flattend device tree if needed */
 736         if (relocate) {
 737                 int err;
 738                 ulong of_start;
 739
 740                 /* position on a 4K boundary before the alloc_current */
 741                 of_start = lmb_alloc_base(lmb, of_len, 0x1000,
 742                                          (CFG_BOOTMAPSZ + bootmap_base));
 743
 744                 if (of_start == 0) {
 745                         puts("device tree - allocation error\n");
 746                         goto error;
 747                 }
 748
 749                 debug ("## device tree at 0x%08lX ... 0x%08lX (len=%ld=0x%lX)\n",
 750                         (ulong)fdt_blob, (ulong)fdt_blob + of_len - 1,
 751                         of_len, of_len);
 752
 753                 printf ("   Loading Device Tree to %08lx, end %08lx ... ",
 754                         of_start, of_start + of_len - 1);
 755
 756                 err = fdt_open_into (fdt_blob, (void *)of_start, of_len);
 757                 if (err != 0) {
 758                         fdt_error ("fdt move failed");
 759                         goto error;
 760                 }
 761                 puts ("OK\n");
 762
 763                 *of_flat_tree = (char *)of_start;
 764         } else {
 765                 *of_flat_tree = fdt_blob;
 766                 lmb_reserve(lmb, (ulong)fdt, of_len);
 767         }
 768
 769         return 0;
 770
 771 error:
 772         return 1;
 773 }
 774 #endif