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 #ifndef USE_HOSTCC 27 #include <common.h> 28 #include <watchdog.h> 29 30 #ifdef CONFIG_SHOW_BOOT_PROGRESS 31 #include <status_led.h> 32 #endif 33 34 #ifdef CONFIG_HAS_DATAFLASH 35 #include <dataflash.h> 36 #endif 37 38 #ifdef CONFIG_LOGBUFFER 39 #include <logbuff.h> 40 #endif 41 42 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) 43 #include <rtc.h> 44 #endif 45 46 #include <image.h> 47 48 #if defined(CONFIG_FIT) || defined (CONFIG_OF_LIBFDT) 49 #include <fdt.h> 50 #include <libfdt.h> 51 #include <fdt_support.h> 52 #endif 53 54 #if defined(CONFIG_FIT) 55 #include <u-boot/md5.h> 56 #include <sha1.h> 57 58 static int fit_check_ramdisk (const void *fit, int os_noffset, 59 uint8_t arch, int verify); 60 #endif 61 62 #ifdef CONFIG_CMD_BDI 63 extern int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]); 64 #endif 65 66 DECLARE_GLOBAL_DATA_PTR; 67 68 static const image_header_t* image_get_ramdisk (ulong rd_addr, uint8_t arch, 69 int verify); 70 #else 71 #include "mkimage.h" 72 #include <u-boot/md5.h> 73 #include <time.h> 74 #include <image.h> 75 #endif /* !USE_HOSTCC*/ 76 77 static const table_entry_t uimage_arch[] = { 78 { IH_ARCH_INVALID, NULL, "Invalid ARCH", }, 79 { IH_ARCH_ALPHA, "alpha", "Alpha", }, 80 { IH_ARCH_ARM, "arm", "ARM", }, 81 { IH_ARCH_I386, "x86", "Intel x86", }, 82 { IH_ARCH_IA64, "ia64", "IA64", }, 83 { IH_ARCH_M68K, "m68k", "M68K", }, 84 { IH_ARCH_MICROBLAZE, "microblaze", "MicroBlaze", }, 85 { IH_ARCH_MIPS, "mips", "MIPS", }, 86 { IH_ARCH_MIPS64, "mips64", "MIPS 64 Bit", }, 87 { IH_ARCH_NIOS2, "nios2", "NIOS II", }, 88 { IH_ARCH_PPC, "powerpc", "PowerPC", }, 89 { IH_ARCH_PPC, "ppc", "PowerPC", }, 90 { IH_ARCH_S390, "s390", "IBM S390", }, 91 { IH_ARCH_SH, "sh", "SuperH", }, 92 { IH_ARCH_SPARC, "sparc", "SPARC", }, 93 { IH_ARCH_SPARC64, "sparc64", "SPARC 64 Bit", }, 94 { IH_ARCH_BLACKFIN, "blackfin", "Blackfin", }, 95 { IH_ARCH_AVR32, "avr32", "AVR32", }, 96 { -1, "", "", }, 97 }; 98 99 static const table_entry_t uimage_os[] = { 100 { IH_OS_INVALID, NULL, "Invalid OS", }, 101 { IH_OS_LINUX, "linux", "Linux", }, 102 #if defined(CONFIG_LYNXKDI) || defined(USE_HOSTCC) 103 { IH_OS_LYNXOS, "lynxos", "LynxOS", }, 104 #endif 105 { IH_OS_NETBSD, "netbsd", "NetBSD", }, 106 { IH_OS_OSE, "ose", "Enea OSE", }, 107 { IH_OS_RTEMS, "rtems", "RTEMS", }, 108 { IH_OS_U_BOOT, "u-boot", "U-Boot", }, 109 #if defined(CONFIG_CMD_ELF) || defined(USE_HOSTCC) 110 { IH_OS_QNX, "qnx", "QNX", }, 111 { IH_OS_VXWORKS, "vxworks", "VxWorks", }, 112 #endif 113 #if defined(CONFIG_INTEGRITY) || defined(USE_HOSTCC) 114 { IH_OS_INTEGRITY,"integrity", "INTEGRITY", }, 115 #endif 116 #ifdef USE_HOSTCC 117 { IH_OS_4_4BSD, "4_4bsd", "4_4BSD", }, 118 { IH_OS_DELL, "dell", "Dell", }, 119 { IH_OS_ESIX, "esix", "Esix", }, 120 { IH_OS_FREEBSD, "freebsd", "FreeBSD", }, 121 { IH_OS_IRIX, "irix", "Irix", }, 122 { IH_OS_NCR, "ncr", "NCR", }, 123 { IH_OS_OPENBSD, "openbsd", "OpenBSD", }, 124 { IH_OS_PSOS, "psos", "pSOS", }, 125 { IH_OS_SCO, "sco", "SCO", }, 126 { IH_OS_SOLARIS, "solaris", "Solaris", }, 127 { IH_OS_SVR4, "svr4", "SVR4", }, 128 #endif 129 { -1, "", "", }, 130 }; 131 132 static const table_entry_t uimage_type[] = { 133 { IH_TYPE_INVALID, NULL, "Invalid Image", }, 134 { IH_TYPE_FILESYSTEM, "filesystem", "Filesystem Image", }, 135 { IH_TYPE_FIRMWARE, "firmware", "Firmware", }, 136 { IH_TYPE_KERNEL, "kernel", "Kernel Image", }, 137 { IH_TYPE_MULTI, "multi", "Multi-File Image", }, 138 { IH_TYPE_RAMDISK, "ramdisk", "RAMDisk Image", }, 139 { IH_TYPE_SCRIPT, "script", "Script", }, 140 { IH_TYPE_STANDALONE, "standalone", "Standalone Program", }, 141 { IH_TYPE_FLATDT, "flat_dt", "Flat Device Tree", }, 142 { IH_TYPE_KWBIMAGE, "kwbimage", "Kirkwood Boot Image",}, 143 { IH_TYPE_IMXIMAGE, "imximage", "Freescale i.MX Boot Image",}, 144 { -1, "", "", }, 145 }; 146 147 static const table_entry_t uimage_comp[] = { 148 { IH_COMP_NONE, "none", "uncompressed", }, 149 { IH_COMP_BZIP2, "bzip2", "bzip2 compressed", }, 150 { IH_COMP_GZIP, "gzip", "gzip compressed", }, 151 { IH_COMP_LZMA, "lzma", "lzma compressed", }, 152 { IH_COMP_LZO, "lzo", "lzo compressed", }, 153 { -1, "", "", }, 154 }; 155 156 uint32_t crc32 (uint32_t, const unsigned char *, uint); 157 uint32_t crc32_wd (uint32_t, const unsigned char *, uint, uint); 158 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC) 159 static void genimg_print_time (time_t timestamp); 160 #endif 161 162 /*****************************************************************************/ 163 /* Legacy format routines */ 164 /*****************************************************************************/ 165 int image_check_hcrc (const image_header_t *hdr) 166 { 167 ulong hcrc; 168 ulong len = image_get_header_size (); 169 image_header_t header; 170 171 /* Copy header so we can blank CRC field for re-calculation */ 172 memmove (&header, (char *)hdr, image_get_header_size ()); 173 image_set_hcrc (&header, 0); 174 175 hcrc = crc32 (0, (unsigned char *)&header, len); 176 177 return (hcrc == image_get_hcrc (hdr)); 178 } 179 180 int image_check_dcrc (const image_header_t *hdr) 181 { 182 ulong data = image_get_data (hdr); 183 ulong len = image_get_data_size (hdr); 184 ulong dcrc = crc32_wd (0, (unsigned char *)data, len, CHUNKSZ_CRC32); 185 186 return (dcrc == image_get_dcrc (hdr)); 187 } 188 189 /** 190 * image_multi_count - get component (sub-image) count 191 * @hdr: pointer to the header of the multi component image 192 * 193 * image_multi_count() returns number of components in a multi 194 * component image. 195 * 196 * Note: no checking of the image type is done, caller must pass 197 * a valid multi component image. 198 * 199 * returns: 200 * number of components 201 */ 202 ulong image_multi_count (const image_header_t *hdr) 203 { 204 ulong i, count = 0; 205 uint32_t *size; 206 207 /* get start of the image payload, which in case of multi 208 * component images that points to a table of component sizes */ 209 size = (uint32_t *)image_get_data (hdr); 210 211 /* count non empty slots */ 212 for (i = 0; size[i]; ++i) 213 count++; 214 215 return count; 216 } 217 218 /** 219 * image_multi_getimg - get component data address and size 220 * @hdr: pointer to the header of the multi component image 221 * @idx: index of the requested component 222 * @data: pointer to a ulong variable, will hold component data address 223 * @len: pointer to a ulong variable, will hold component size 224 * 225 * image_multi_getimg() returns size and data address for the requested 226 * component in a multi component image. 227 * 228 * Note: no checking of the image type is done, caller must pass 229 * a valid multi component image. 230 * 231 * returns: 232 * data address and size of the component, if idx is valid 233 * 0 in data and len, if idx is out of range 234 */ 235 void image_multi_getimg (const image_header_t *hdr, ulong idx, 236 ulong *data, ulong *len) 237 { 238 int i; 239 uint32_t *size; 240 ulong offset, count, img_data; 241 242 /* get number of component */ 243 count = image_multi_count (hdr); 244 245 /* get start of the image payload, which in case of multi 246 * component images that points to a table of component sizes */ 247 size = (uint32_t *)image_get_data (hdr); 248 249 /* get address of the proper component data start, which means 250 * skipping sizes table (add 1 for last, null entry) */ 251 img_data = image_get_data (hdr) + (count + 1) * sizeof (uint32_t); 252 253 if (idx < count) { 254 *len = uimage_to_cpu (size[idx]); 255 offset = 0; 256 257 /* go over all indices preceding requested component idx */ 258 for (i = 0; i < idx; i++) { 259 /* add up i-th component size, rounding up to 4 bytes */ 260 offset += (uimage_to_cpu (size[i]) + 3) & ~3 ; 261 } 262 263 /* calculate idx-th component data address */ 264 *data = img_data + offset; 265 } else { 266 *len = 0; 267 *data = 0; 268 } 269 } 270 271 static void image_print_type (const image_header_t *hdr) 272 { 273 const char *os, *arch, *type, *comp; 274 275 os = genimg_get_os_name (image_get_os (hdr)); 276 arch = genimg_get_arch_name (image_get_arch (hdr)); 277 type = genimg_get_type_name (image_get_type (hdr)); 278 comp = genimg_get_comp_name (image_get_comp (hdr)); 279 280 printf ("%s %s %s (%s)\n", arch, os, type, comp); 281 } 282 283 /** 284 * image_print_contents - prints out the contents of the legacy format image 285 * @ptr: pointer to the legacy format image header 286 * @p: pointer to prefix string 287 * 288 * image_print_contents() formats a multi line legacy image contents description. 289 * The routine prints out all header fields followed by the size/offset data 290 * for MULTI/SCRIPT images. 291 * 292 * returns: 293 * no returned results 294 */ 295 void image_print_contents (const void *ptr) 296 { 297 const image_header_t *hdr = (const image_header_t *)ptr; 298 const char *p; 299 300 #ifdef USE_HOSTCC 301 p = ""; 302 #else 303 p = " "; 304 #endif 305 306 printf ("%sImage Name: %.*s\n", p, IH_NMLEN, image_get_name (hdr)); 307 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC) 308 printf ("%sCreated: ", p); 309 genimg_print_time ((time_t)image_get_time (hdr)); 310 #endif 311 printf ("%sImage Type: ", p); 312 image_print_type (hdr); 313 printf ("%sData Size: ", p); 314 genimg_print_size (image_get_data_size (hdr)); 315 printf ("%sLoad Address: %08x\n", p, image_get_load (hdr)); 316 printf ("%sEntry Point: %08x\n", p, image_get_ep (hdr)); 317 318 if (image_check_type (hdr, IH_TYPE_MULTI) || 319 image_check_type (hdr, IH_TYPE_SCRIPT)) { 320 int i; 321 ulong data, len; 322 ulong count = image_multi_count (hdr); 323 324 printf ("%sContents:\n", p); 325 for (i = 0; i < count; i++) { 326 image_multi_getimg (hdr, i, &data, &len); 327 328 printf ("%s Image %d: ", p, i); 329 genimg_print_size (len); 330 331 if (image_check_type (hdr, IH_TYPE_SCRIPT) && i > 0) { 332 /* 333 * the user may need to know offsets 334 * if planning to do something with 335 * multiple files 336 */ 337 printf ("%s Offset = 0x%08lx\n", p, data); 338 } 339 } 340 } 341 } 342 343 344 #ifndef USE_HOSTCC 345 /** 346 * image_get_ramdisk - get and verify ramdisk image 347 * @rd_addr: ramdisk image start address 348 * @arch: expected ramdisk architecture 349 * @verify: checksum verification flag 350 * 351 * image_get_ramdisk() returns a pointer to the verified ramdisk image 352 * header. Routine receives image start address and expected architecture 353 * flag. Verification done covers data and header integrity and os/type/arch 354 * fields checking. 355 * 356 * If dataflash support is enabled routine checks for dataflash addresses 357 * and handles required dataflash reads. 358 * 359 * returns: 360 * pointer to a ramdisk image header, if image was found and valid 361 * otherwise, return NULL 362 */ 363 static const image_header_t *image_get_ramdisk (ulong rd_addr, uint8_t arch, 364 int verify) 365 { 366 const image_header_t *rd_hdr = (const image_header_t *)rd_addr; 367 368 if (!image_check_magic (rd_hdr)) { 369 puts ("Bad Magic Number\n"); 370 show_boot_progress (-10); 371 return NULL; 372 } 373 374 if (!image_check_hcrc (rd_hdr)) { 375 puts ("Bad Header Checksum\n"); 376 show_boot_progress (-11); 377 return NULL; 378 } 379 380 show_boot_progress (10); 381 image_print_contents (rd_hdr); 382 383 if (verify) { 384 puts(" Verifying Checksum ... "); 385 if (!image_check_dcrc (rd_hdr)) { 386 puts ("Bad Data CRC\n"); 387 show_boot_progress (-12); 388 return NULL; 389 } 390 puts("OK\n"); 391 } 392 393 show_boot_progress (11); 394 395 if (!image_check_os (rd_hdr, IH_OS_LINUX) || 396 !image_check_arch (rd_hdr, arch) || 397 !image_check_type (rd_hdr, IH_TYPE_RAMDISK)) { 398 printf ("No Linux %s Ramdisk Image\n", 399 genimg_get_arch_name(arch)); 400 show_boot_progress (-13); 401 return NULL; 402 } 403 404 return rd_hdr; 405 } 406 #endif /* !USE_HOSTCC */ 407 408 /*****************************************************************************/ 409 /* Shared dual-format routines */ 410 /*****************************************************************************/ 411 #ifndef USE_HOSTCC 412 int getenv_yesno (char *var) 413 { 414 char *s = getenv (var); 415 return (s && (*s == 'n')) ? 0 : 1; 416 } 417 418 ulong getenv_bootm_low(void) 419 { 420 char *s = getenv ("bootm_low"); 421 if (s) { 422 ulong tmp = simple_strtoul (s, NULL, 16); 423 return tmp; 424 } 425 426 #if defined(CONFIG_SYS_SDRAM_BASE) 427 return CONFIG_SYS_SDRAM_BASE; 428 #elif defined(CONFIG_ARM) 429 return gd->bd->bi_dram[0].start; 430 #else 431 return 0; 432 #endif 433 } 434 435 phys_size_t getenv_bootm_size(void) 436 { 437 phys_size_t tmp; 438 char *s = getenv ("bootm_size"); 439 if (s) { 440 tmp = (phys_size_t)simple_strtoull (s, NULL, 16); 441 return tmp; 442 } 443 s = getenv("bootm_low"); 444 if (s) 445 tmp = (phys_size_t)simple_strtoull (s, NULL, 16); 446 else 447 tmp = 0; 448 449 450 #if defined(CONFIG_ARM) 451 return gd->bd->bi_dram[0].size - tmp; 452 #else 453 return gd->bd->bi_memsize - tmp; 454 #endif 455 } 456 457 phys_size_t getenv_bootm_mapsize(void) 458 { 459 phys_size_t tmp; 460 char *s = getenv ("bootm_mapsize"); 461 if (s) { 462 tmp = (phys_size_t)simple_strtoull (s, NULL, 16); 463 return tmp; 464 } 465 466 #if defined(CONFIG_SYS_BOOTMAPSZ) 467 return CONFIG_SYS_BOOTMAPSZ; 468 #else 469 return getenv_bootm_size(); 470 #endif 471 } 472 473 void memmove_wd (void *to, void *from, size_t len, ulong chunksz) 474 { 475 if (to == from) 476 return; 477 478 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG) 479 while (len > 0) { 480 size_t tail = (len > chunksz) ? chunksz : len; 481 WATCHDOG_RESET (); 482 memmove (to, from, tail); 483 to += tail; 484 from += tail; 485 len -= tail; 486 } 487 #else /* !(CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG) */ 488 memmove (to, from, len); 489 #endif /* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */ 490 } 491 #endif /* !USE_HOSTCC */ 492 493 void genimg_print_size (uint32_t size) 494 { 495 #ifndef USE_HOSTCC 496 printf ("%d Bytes = ", size); 497 print_size (size, "\n"); 498 #else 499 printf ("%d Bytes = %.2f kB = %.2f MB\n", 500 size, (double)size / 1.024e3, 501 (double)size / 1.048576e6); 502 #endif 503 } 504 505 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC) 506 static void genimg_print_time (time_t timestamp) 507 { 508 #ifndef USE_HOSTCC 509 struct rtc_time tm; 510 511 to_tm (timestamp, &tm); 512 printf ("%4d-%02d-%02d %2d:%02d:%02d UTC\n", 513 tm.tm_year, tm.tm_mon, tm.tm_mday, 514 tm.tm_hour, tm.tm_min, tm.tm_sec); 515 #else 516 printf ("%s", ctime(×tamp)); 517 #endif 518 } 519 #endif /* CONFIG_TIMESTAMP || CONFIG_CMD_DATE || USE_HOSTCC */ 520 521 /** 522 * get_table_entry_name - translate entry id to long name 523 * @table: pointer to a translation table for entries of a specific type 524 * @msg: message to be returned when translation fails 525 * @id: entry id to be translated 526 * 527 * get_table_entry_name() will go over translation table trying to find 528 * entry that matches given id. If matching entry is found, its long 529 * name is returned to the caller. 530 * 531 * returns: 532 * long entry name if translation succeeds 533 * msg otherwise 534 */ 535 char *get_table_entry_name(const table_entry_t *table, char *msg, int id) 536 { 537 for (; table->id >= 0; ++table) { 538 if (table->id == id) 539 #if defined(USE_HOSTCC) || !defined(CONFIG_NEEDS_MANUAL_RELOC) 540 return table->lname; 541 #else 542 return table->lname + gd->reloc_off; 543 #endif 544 } 545 return (msg); 546 } 547 548 const char *genimg_get_os_name (uint8_t os) 549 { 550 return (get_table_entry_name (uimage_os, "Unknown OS", os)); 551 } 552 553 const char *genimg_get_arch_name (uint8_t arch) 554 { 555 return (get_table_entry_name (uimage_arch, "Unknown Architecture", arch)); 556 } 557 558 const char *genimg_get_type_name (uint8_t type) 559 { 560 return (get_table_entry_name (uimage_type, "Unknown Image", type)); 561 } 562 563 const char *genimg_get_comp_name (uint8_t comp) 564 { 565 return (get_table_entry_name (uimage_comp, "Unknown Compression", comp)); 566 } 567 568 /** 569 * get_table_entry_id - translate short entry name to id 570 * @table: pointer to a translation table for entries of a specific type 571 * @table_name: to be used in case of error 572 * @name: entry short name to be translated 573 * 574 * get_table_entry_id() will go over translation table trying to find 575 * entry that matches given short name. If matching entry is found, 576 * its id returned to the caller. 577 * 578 * returns: 579 * entry id if translation succeeds 580 * -1 otherwise 581 */ 582 int get_table_entry_id(const table_entry_t *table, 583 const char *table_name, const char *name) 584 { 585 const table_entry_t *t; 586 #ifdef USE_HOSTCC 587 int first = 1; 588 589 for (t = table; t->id >= 0; ++t) { 590 if (t->sname && strcasecmp(t->sname, name) == 0) 591 return (t->id); 592 } 593 594 fprintf (stderr, "\nInvalid %s Type - valid names are", table_name); 595 for (t = table; t->id >= 0; ++t) { 596 if (t->sname == NULL) 597 continue; 598 fprintf (stderr, "%c %s", (first) ? ':' : ',', t->sname); 599 first = 0; 600 } 601 fprintf (stderr, "\n"); 602 #else 603 for (t = table; t->id >= 0; ++t) { 604 #ifdef CONFIG_NEEDS_MANUAL_RELOC 605 if (t->sname && strcmp(t->sname + gd->reloc_off, name) == 0) 606 #else 607 if (t->sname && strcmp(t->sname, name) == 0) 608 #endif 609 return (t->id); 610 } 611 debug ("Invalid %s Type: %s\n", table_name, name); 612 #endif /* USE_HOSTCC */ 613 return (-1); 614 } 615 616 int genimg_get_os_id (const char *name) 617 { 618 return (get_table_entry_id (uimage_os, "OS", name)); 619 } 620 621 int genimg_get_arch_id (const char *name) 622 { 623 return (get_table_entry_id (uimage_arch, "CPU", name)); 624 } 625 626 int genimg_get_type_id (const char *name) 627 { 628 return (get_table_entry_id (uimage_type, "Image", name)); 629 } 630 631 int genimg_get_comp_id (const char *name) 632 { 633 return (get_table_entry_id (uimage_comp, "Compression", name)); 634 } 635 636 #ifndef USE_HOSTCC 637 /** 638 * genimg_get_format - get image format type 639 * @img_addr: image start address 640 * 641 * genimg_get_format() checks whether provided address points to a valid 642 * legacy or FIT image. 643 * 644 * New uImage format and FDT blob are based on a libfdt. FDT blob 645 * may be passed directly or embedded in a FIT image. In both situations 646 * genimg_get_format() must be able to dectect libfdt header. 647 * 648 * returns: 649 * image format type or IMAGE_FORMAT_INVALID if no image is present 650 */ 651 int genimg_get_format (void *img_addr) 652 { 653 ulong format = IMAGE_FORMAT_INVALID; 654 const image_header_t *hdr; 655 #if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT) 656 char *fit_hdr; 657 #endif 658 659 hdr = (const image_header_t *)img_addr; 660 if (image_check_magic(hdr)) 661 format = IMAGE_FORMAT_LEGACY; 662 #if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT) 663 else { 664 fit_hdr = (char *)img_addr; 665 if (fdt_check_header (fit_hdr) == 0) 666 format = IMAGE_FORMAT_FIT; 667 } 668 #endif 669 670 return format; 671 } 672 673 /** 674 * genimg_get_image - get image from special storage (if necessary) 675 * @img_addr: image start address 676 * 677 * genimg_get_image() checks if provided image start adddress is located 678 * in a dataflash storage. If so, image is moved to a system RAM memory. 679 * 680 * returns: 681 * image start address after possible relocation from special storage 682 */ 683 ulong genimg_get_image (ulong img_addr) 684 { 685 ulong ram_addr = img_addr; 686 687 #ifdef CONFIG_HAS_DATAFLASH 688 ulong h_size, d_size; 689 690 if (addr_dataflash (img_addr)){ 691 /* ger RAM address */ 692 ram_addr = CONFIG_SYS_LOAD_ADDR; 693 694 /* get header size */ 695 h_size = image_get_header_size (); 696 #if defined(CONFIG_FIT) 697 if (sizeof(struct fdt_header) > h_size) 698 h_size = sizeof(struct fdt_header); 699 #endif 700 701 /* read in header */ 702 debug (" Reading image header from dataflash address " 703 "%08lx to RAM address %08lx\n", img_addr, ram_addr); 704 705 read_dataflash (img_addr, h_size, (char *)ram_addr); 706 707 /* get data size */ 708 switch (genimg_get_format ((void *)ram_addr)) { 709 case IMAGE_FORMAT_LEGACY: 710 d_size = image_get_data_size ((const image_header_t *)ram_addr); 711 debug (" Legacy format image found at 0x%08lx, size 0x%08lx\n", 712 ram_addr, d_size); 713 break; 714 #if defined(CONFIG_FIT) 715 case IMAGE_FORMAT_FIT: 716 d_size = fit_get_size ((const void *)ram_addr) - h_size; 717 debug (" FIT/FDT format image found at 0x%08lx, size 0x%08lx\n", 718 ram_addr, d_size); 719 break; 720 #endif 721 default: 722 printf (" No valid image found at 0x%08lx\n", img_addr); 723 return ram_addr; 724 } 725 726 /* read in image data */ 727 debug (" Reading image remaining data from dataflash address " 728 "%08lx to RAM address %08lx\n", img_addr + h_size, 729 ram_addr + h_size); 730 731 read_dataflash (img_addr + h_size, d_size, 732 (char *)(ram_addr + h_size)); 733 734 } 735 #endif /* CONFIG_HAS_DATAFLASH */ 736 737 return ram_addr; 738 } 739 740 /** 741 * fit_has_config - check if there is a valid FIT configuration 742 * @images: pointer to the bootm command headers structure 743 * 744 * fit_has_config() checks if there is a FIT configuration in use 745 * (if FTI support is present). 746 * 747 * returns: 748 * 0, no FIT support or no configuration found 749 * 1, configuration found 750 */ 751 int genimg_has_config (bootm_headers_t *images) 752 { 753 #if defined(CONFIG_FIT) 754 if (images->fit_uname_cfg) 755 return 1; 756 #endif 757 return 0; 758 } 759 760 /** 761 * boot_get_ramdisk - main ramdisk handling routine 762 * @argc: command argument count 763 * @argv: command argument list 764 * @images: pointer to the bootm images structure 765 * @arch: expected ramdisk architecture 766 * @rd_start: pointer to a ulong variable, will hold ramdisk start address 767 * @rd_end: pointer to a ulong variable, will hold ramdisk end 768 * 769 * boot_get_ramdisk() is responsible for finding a valid ramdisk image. 770 * Curently supported are the following ramdisk sources: 771 * - multicomponent kernel/ramdisk image, 772 * - commandline provided address of decicated ramdisk image. 773 * 774 * returns: 775 * 0, if ramdisk image was found and valid, or skiped 776 * rd_start and rd_end are set to ramdisk start/end addresses if 777 * ramdisk image is found and valid 778 * 779 * 1, if ramdisk image is found but corrupted, or invalid 780 * rd_start and rd_end are set to 0 if no ramdisk exists 781 */ 782 int boot_get_ramdisk (int argc, char * const argv[], bootm_headers_t *images, 783 uint8_t arch, ulong *rd_start, ulong *rd_end) 784 { 785 ulong rd_addr, rd_load; 786 ulong rd_data, rd_len; 787 const image_header_t *rd_hdr; 788 #if defined(CONFIG_FIT) 789 void *fit_hdr; 790 const char *fit_uname_config = NULL; 791 const char *fit_uname_ramdisk = NULL; 792 ulong default_addr; 793 int rd_noffset; 794 int cfg_noffset; 795 const void *data; 796 size_t size; 797 #endif 798 799 *rd_start = 0; 800 *rd_end = 0; 801 802 /* 803 * Look for a '-' which indicates to ignore the 804 * ramdisk argument 805 */ 806 if ((argc >= 3) && (strcmp(argv[2], "-") == 0)) { 807 debug ("## Skipping init Ramdisk\n"); 808 rd_len = rd_data = 0; 809 } else if (argc >= 3 || genimg_has_config (images)) { 810 #if defined(CONFIG_FIT) 811 if (argc >= 3) { 812 /* 813 * If the init ramdisk comes from the FIT image and 814 * the FIT image address is omitted in the command 815 * line argument, try to use os FIT image address or 816 * default load address. 817 */ 818 if (images->fit_uname_os) 819 default_addr = (ulong)images->fit_hdr_os; 820 else 821 default_addr = load_addr; 822 823 if (fit_parse_conf (argv[2], default_addr, 824 &rd_addr, &fit_uname_config)) { 825 debug ("* ramdisk: config '%s' from image at 0x%08lx\n", 826 fit_uname_config, rd_addr); 827 } else if (fit_parse_subimage (argv[2], default_addr, 828 &rd_addr, &fit_uname_ramdisk)) { 829 debug ("* ramdisk: subimage '%s' from image at 0x%08lx\n", 830 fit_uname_ramdisk, rd_addr); 831 } else 832 #endif 833 { 834 rd_addr = simple_strtoul(argv[2], NULL, 16); 835 debug ("* ramdisk: cmdline image address = 0x%08lx\n", 836 rd_addr); 837 } 838 #if defined(CONFIG_FIT) 839 } else { 840 /* use FIT configuration provided in first bootm 841 * command argument 842 */ 843 rd_addr = (ulong)images->fit_hdr_os; 844 fit_uname_config = images->fit_uname_cfg; 845 debug ("* ramdisk: using config '%s' from image at 0x%08lx\n", 846 fit_uname_config, rd_addr); 847 848 /* 849 * Check whether configuration has ramdisk defined, 850 * if not, don't try to use it, quit silently. 851 */ 852 fit_hdr = (void *)rd_addr; 853 cfg_noffset = fit_conf_get_node (fit_hdr, fit_uname_config); 854 if (cfg_noffset < 0) { 855 debug ("* ramdisk: no such config\n"); 856 return 1; 857 } 858 859 rd_noffset = fit_conf_get_ramdisk_node (fit_hdr, cfg_noffset); 860 if (rd_noffset < 0) { 861 debug ("* ramdisk: no ramdisk in config\n"); 862 return 0; 863 } 864 } 865 #endif 866 867 /* copy from dataflash if needed */ 868 rd_addr = genimg_get_image (rd_addr); 869 870 /* 871 * Check if there is an initrd image at the 872 * address provided in the second bootm argument 873 * check image type, for FIT images get FIT node. 874 */ 875 switch (genimg_get_format ((void *)rd_addr)) { 876 case IMAGE_FORMAT_LEGACY: 877 printf ("## Loading init Ramdisk from Legacy " 878 "Image at %08lx ...\n", rd_addr); 879 880 show_boot_progress (9); 881 rd_hdr = image_get_ramdisk (rd_addr, arch, 882 images->verify); 883 884 if (rd_hdr == NULL) 885 return 1; 886 887 rd_data = image_get_data (rd_hdr); 888 rd_len = image_get_data_size (rd_hdr); 889 rd_load = image_get_load (rd_hdr); 890 break; 891 #if defined(CONFIG_FIT) 892 case IMAGE_FORMAT_FIT: 893 fit_hdr = (void *)rd_addr; 894 printf ("## Loading init Ramdisk from FIT " 895 "Image at %08lx ...\n", rd_addr); 896 897 show_boot_progress (120); 898 if (!fit_check_format (fit_hdr)) { 899 puts ("Bad FIT ramdisk image format!\n"); 900 show_boot_progress (-120); 901 return 1; 902 } 903 show_boot_progress (121); 904 905 if (!fit_uname_ramdisk) { 906 /* 907 * no ramdisk image node unit name, try to get config 908 * node first. If config unit node name is NULL 909 * fit_conf_get_node() will try to find default config node 910 */ 911 show_boot_progress (122); 912 cfg_noffset = fit_conf_get_node (fit_hdr, fit_uname_config); 913 if (cfg_noffset < 0) { 914 puts ("Could not find configuration node\n"); 915 show_boot_progress (-122); 916 return 1; 917 } 918 fit_uname_config = fdt_get_name (fit_hdr, cfg_noffset, NULL); 919 printf (" Using '%s' configuration\n", fit_uname_config); 920 921 rd_noffset = fit_conf_get_ramdisk_node (fit_hdr, cfg_noffset); 922 fit_uname_ramdisk = fit_get_name (fit_hdr, rd_noffset, NULL); 923 } else { 924 /* get ramdisk component image node offset */ 925 show_boot_progress (123); 926 rd_noffset = fit_image_get_node (fit_hdr, fit_uname_ramdisk); 927 } 928 if (rd_noffset < 0) { 929 puts ("Could not find subimage node\n"); 930 show_boot_progress (-124); 931 return 1; 932 } 933 934 printf (" Trying '%s' ramdisk subimage\n", fit_uname_ramdisk); 935 936 show_boot_progress (125); 937 if (!fit_check_ramdisk (fit_hdr, rd_noffset, arch, images->verify)) 938 return 1; 939 940 /* get ramdisk image data address and length */ 941 if (fit_image_get_data (fit_hdr, rd_noffset, &data, &size)) { 942 puts ("Could not find ramdisk subimage data!\n"); 943 show_boot_progress (-127); 944 return 1; 945 } 946 show_boot_progress (128); 947 948 rd_data = (ulong)data; 949 rd_len = size; 950 951 if (fit_image_get_load (fit_hdr, rd_noffset, &rd_load)) { 952 puts ("Can't get ramdisk subimage load address!\n"); 953 show_boot_progress (-129); 954 return 1; 955 } 956 show_boot_progress (129); 957 958 images->fit_hdr_rd = fit_hdr; 959 images->fit_uname_rd = fit_uname_ramdisk; 960 images->fit_noffset_rd = rd_noffset; 961 break; 962 #endif 963 default: 964 puts ("Wrong Ramdisk Image Format\n"); 965 rd_data = rd_len = rd_load = 0; 966 return 1; 967 } 968 969 #if defined(CONFIG_B2) || defined(CONFIG_EVB4510) || defined(CONFIG_ARMADILLO) 970 /* 971 * We need to copy the ramdisk to SRAM to let Linux boot 972 */ 973 if (rd_data) { 974 memmove ((void *)rd_load, (uchar *)rd_data, rd_len); 975 rd_data = rd_load; 976 } 977 #endif /* CONFIG_B2 || CONFIG_EVB4510 || CONFIG_ARMADILLO */ 978 979 } else if (images->legacy_hdr_valid && 980 image_check_type (&images->legacy_hdr_os_copy, IH_TYPE_MULTI)) { 981 /* 982 * Now check if we have a legacy mult-component image, 983 * get second entry data start address and len. 984 */ 985 show_boot_progress (13); 986 printf ("## Loading init Ramdisk from multi component " 987 "Legacy Image at %08lx ...\n", 988 (ulong)images->legacy_hdr_os); 989 990 image_multi_getimg (images->legacy_hdr_os, 1, &rd_data, &rd_len); 991 } else { 992 /* 993 * no initrd image 994 */ 995 show_boot_progress (14); 996 rd_len = rd_data = 0; 997 } 998 999 if (!rd_data) { 1000 debug ("## No init Ramdisk\n"); 1001 } else { 1002 *rd_start = rd_data; 1003 *rd_end = rd_data + rd_len; 1004 } 1005 debug (" ramdisk start = 0x%08lx, ramdisk end = 0x%08lx\n", 1006 *rd_start, *rd_end); 1007 1008 return 0; 1009 } 1010 1011 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH 1012 /** 1013 * boot_ramdisk_high - relocate init ramdisk 1014 * @lmb: pointer to lmb handle, will be used for memory mgmt 1015 * @rd_data: ramdisk data start address 1016 * @rd_len: ramdisk data length 1017 * @initrd_start: pointer to a ulong variable, will hold final init ramdisk 1018 * start address (after possible relocation) 1019 * @initrd_end: pointer to a ulong variable, will hold final init ramdisk 1020 * end address (after possible relocation) 1021 * 1022 * boot_ramdisk_high() takes a relocation hint from "initrd_high" environement 1023 * variable and if requested ramdisk data is moved to a specified location. 1024 * 1025 * Initrd_start and initrd_end are set to final (after relocation) ramdisk 1026 * start/end addresses if ramdisk image start and len were provided, 1027 * otherwise set initrd_start and initrd_end set to zeros. 1028 * 1029 * returns: 1030 * 0 - success 1031 * -1 - failure 1032 */ 1033 int boot_ramdisk_high (struct lmb *lmb, ulong rd_data, ulong rd_len, 1034 ulong *initrd_start, ulong *initrd_end) 1035 { 1036 char *s; 1037 ulong initrd_high; 1038 int initrd_copy_to_ram = 1; 1039 1040 if ((s = getenv ("initrd_high")) != NULL) { 1041 /* a value of "no" or a similar string will act like 0, 1042 * turning the "load high" feature off. This is intentional. 1043 */ 1044 initrd_high = simple_strtoul (s, NULL, 16); 1045 if (initrd_high == ~0) 1046 initrd_copy_to_ram = 0; 1047 } else { 1048 /* not set, no restrictions to load high */ 1049 initrd_high = ~0; 1050 } 1051 1052 1053 #ifdef CONFIG_LOGBUFFER 1054 /* Prevent initrd from overwriting logbuffer */ 1055 lmb_reserve(lmb, logbuffer_base() - LOGBUFF_OVERHEAD, LOGBUFF_RESERVE); 1056 #endif 1057 1058 debug ("## initrd_high = 0x%08lx, copy_to_ram = %d\n", 1059 initrd_high, initrd_copy_to_ram); 1060 1061 if (rd_data) { 1062 if (!initrd_copy_to_ram) { /* zero-copy ramdisk support */ 1063 debug (" in-place initrd\n"); 1064 *initrd_start = rd_data; 1065 *initrd_end = rd_data + rd_len; 1066 lmb_reserve(lmb, rd_data, rd_len); 1067 } else { 1068 if (initrd_high) 1069 *initrd_start = (ulong)lmb_alloc_base (lmb, rd_len, 0x1000, initrd_high); 1070 else 1071 *initrd_start = (ulong)lmb_alloc (lmb, rd_len, 0x1000); 1072 1073 if (*initrd_start == 0) { 1074 puts ("ramdisk - allocation error\n"); 1075 goto error; 1076 } 1077 show_boot_progress (12); 1078 1079 *initrd_end = *initrd_start + rd_len; 1080 printf (" Loading Ramdisk to %08lx, end %08lx ... ", 1081 *initrd_start, *initrd_end); 1082 1083 memmove_wd ((void *)*initrd_start, 1084 (void *)rd_data, rd_len, CHUNKSZ); 1085 1086 puts ("OK\n"); 1087 } 1088 } else { 1089 *initrd_start = 0; 1090 *initrd_end = 0; 1091 } 1092 debug (" ramdisk load start = 0x%08lx, ramdisk load end = 0x%08lx\n", 1093 *initrd_start, *initrd_end); 1094 1095 return 0; 1096 1097 error: 1098 return -1; 1099 } 1100 #endif /* CONFIG_SYS_BOOT_RAMDISK_HIGH */ 1101 1102 #ifdef CONFIG_OF_LIBFDT 1103 static void fdt_error (const char *msg) 1104 { 1105 puts ("ERROR: "); 1106 puts (msg); 1107 puts (" - must RESET the board to recover.\n"); 1108 } 1109 1110 static const image_header_t *image_get_fdt (ulong fdt_addr) 1111 { 1112 const image_header_t *fdt_hdr = (const image_header_t *)fdt_addr; 1113 1114 image_print_contents (fdt_hdr); 1115 1116 puts (" Verifying Checksum ... "); 1117 if (!image_check_hcrc (fdt_hdr)) { 1118 fdt_error ("fdt header checksum invalid"); 1119 return NULL; 1120 } 1121 1122 if (!image_check_dcrc (fdt_hdr)) { 1123 fdt_error ("fdt checksum invalid"); 1124 return NULL; 1125 } 1126 puts ("OK\n"); 1127 1128 if (!image_check_type (fdt_hdr, IH_TYPE_FLATDT)) { 1129 fdt_error ("uImage is not a fdt"); 1130 return NULL; 1131 } 1132 if (image_get_comp (fdt_hdr) != IH_COMP_NONE) { 1133 fdt_error ("uImage is compressed"); 1134 return NULL; 1135 } 1136 if (fdt_check_header ((char *)image_get_data (fdt_hdr)) != 0) { 1137 fdt_error ("uImage data is not a fdt"); 1138 return NULL; 1139 } 1140 return fdt_hdr; 1141 } 1142 1143 /** 1144 * fit_check_fdt - verify FIT format FDT subimage 1145 * @fit_hdr: pointer to the FIT header 1146 * fdt_noffset: FDT subimage node offset within FIT image 1147 * @verify: data CRC verification flag 1148 * 1149 * fit_check_fdt() verifies integrity of the FDT subimage and from 1150 * specified FIT image. 1151 * 1152 * returns: 1153 * 1, on success 1154 * 0, on failure 1155 */ 1156 #if defined(CONFIG_FIT) 1157 static int fit_check_fdt (const void *fit, int fdt_noffset, int verify) 1158 { 1159 fit_image_print (fit, fdt_noffset, " "); 1160 1161 if (verify) { 1162 puts (" Verifying Hash Integrity ... "); 1163 if (!fit_image_check_hashes (fit, fdt_noffset)) { 1164 fdt_error ("Bad Data Hash"); 1165 return 0; 1166 } 1167 puts ("OK\n"); 1168 } 1169 1170 if (!fit_image_check_type (fit, fdt_noffset, IH_TYPE_FLATDT)) { 1171 fdt_error ("Not a FDT image"); 1172 return 0; 1173 } 1174 1175 if (!fit_image_check_comp (fit, fdt_noffset, IH_COMP_NONE)) { 1176 fdt_error ("FDT image is compressed"); 1177 return 0; 1178 } 1179 1180 return 1; 1181 } 1182 #endif /* CONFIG_FIT */ 1183 1184 #ifndef CONFIG_SYS_FDT_PAD 1185 #define CONFIG_SYS_FDT_PAD 0x3000 1186 #endif 1187 1188 #if defined(CONFIG_OF_LIBFDT) 1189 /** 1190 * boot_fdt_add_mem_rsv_regions - Mark the memreserve sections as unusable 1191 * @lmb: pointer to lmb handle, will be used for memory mgmt 1192 * @fdt_blob: pointer to fdt blob base address 1193 * 1194 * Adds the memreserve regions in the dtb to the lmb block. Adding the 1195 * memreserve regions prevents u-boot from using them to store the initrd 1196 * or the fdt blob. 1197 */ 1198 void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob) 1199 { 1200 uint64_t addr, size; 1201 int i, total; 1202 1203 if (fdt_check_header (fdt_blob) != 0) 1204 return; 1205 1206 total = fdt_num_mem_rsv(fdt_blob); 1207 for (i = 0; i < total; i++) { 1208 if (fdt_get_mem_rsv(fdt_blob, i, &addr, &size) != 0) 1209 continue; 1210 printf(" reserving fdt memory region: addr=%llx size=%llx\n", 1211 (unsigned long long)addr, (unsigned long long)size); 1212 lmb_reserve(lmb, addr, size); 1213 } 1214 } 1215 1216 /** 1217 * boot_relocate_fdt - relocate flat device tree 1218 * @lmb: pointer to lmb handle, will be used for memory mgmt 1219 * @of_flat_tree: pointer to a char* variable, will hold fdt start address 1220 * @of_size: pointer to a ulong variable, will hold fdt length 1221 * 1222 * boot_relocate_fdt() allocates a region of memory within the bootmap and 1223 * relocates the of_flat_tree into that region, even if the fdt is already in 1224 * the bootmap. It also expands the size of the fdt by CONFIG_SYS_FDT_PAD 1225 * bytes. 1226 * 1227 * of_flat_tree and of_size are set to final (after relocation) values 1228 * 1229 * returns: 1230 * 0 - success 1231 * 1 - failure 1232 */ 1233 int boot_relocate_fdt (struct lmb *lmb, char **of_flat_tree, ulong *of_size) 1234 { 1235 void *fdt_blob = *of_flat_tree; 1236 void *of_start = 0; 1237 ulong of_len = 0; 1238 int err; 1239 1240 /* nothing to do */ 1241 if (*of_size == 0) 1242 return 0; 1243 1244 if (fdt_check_header (fdt_blob) != 0) { 1245 fdt_error ("image is not a fdt"); 1246 goto error; 1247 } 1248 1249 /* position on a 4K boundary before the alloc_current */ 1250 /* Pad the FDT by a specified amount */ 1251 of_len = *of_size + CONFIG_SYS_FDT_PAD; 1252 of_start = (void *)(unsigned long)lmb_alloc_base(lmb, of_len, 0x1000, 1253 getenv_bootm_mapsize() + getenv_bootm_low()); 1254 1255 if (of_start == 0) { 1256 puts("device tree - allocation error\n"); 1257 goto error; 1258 } 1259 1260 debug ("## device tree at %p ... %p (len=%ld [0x%lX])\n", 1261 fdt_blob, fdt_blob + *of_size - 1, of_len, of_len); 1262 1263 printf (" Loading Device Tree to %p, end %p ... ", 1264 of_start, of_start + of_len - 1); 1265 1266 err = fdt_open_into (fdt_blob, of_start, of_len); 1267 if (err != 0) { 1268 fdt_error ("fdt move failed"); 1269 goto error; 1270 } 1271 puts ("OK\n"); 1272 1273 *of_flat_tree = of_start; 1274 *of_size = of_len; 1275 1276 set_working_fdt_addr(*of_flat_tree); 1277 return 0; 1278 1279 error: 1280 return 1; 1281 } 1282 #endif /* CONFIG_OF_LIBFDT */ 1283 1284 /** 1285 * boot_get_fdt - main fdt handling routine 1286 * @argc: command argument count 1287 * @argv: command argument list 1288 * @images: pointer to the bootm images structure 1289 * @of_flat_tree: pointer to a char* variable, will hold fdt start address 1290 * @of_size: pointer to a ulong variable, will hold fdt length 1291 * 1292 * boot_get_fdt() is responsible for finding a valid flat device tree image. 1293 * Curently supported are the following ramdisk sources: 1294 * - multicomponent kernel/ramdisk image, 1295 * - commandline provided address of decicated ramdisk image. 1296 * 1297 * returns: 1298 * 0, if fdt image was found and valid, or skipped 1299 * of_flat_tree and of_size are set to fdt start address and length if 1300 * fdt image is found and valid 1301 * 1302 * 1, if fdt image is found but corrupted 1303 * of_flat_tree and of_size are set to 0 if no fdt exists 1304 */ 1305 int boot_get_fdt (int flag, int argc, char * const argv[], bootm_headers_t *images, 1306 char **of_flat_tree, ulong *of_size) 1307 { 1308 const image_header_t *fdt_hdr; 1309 ulong fdt_addr; 1310 char *fdt_blob = NULL; 1311 ulong image_start, image_end; 1312 ulong load_start, load_end; 1313 #if defined(CONFIG_FIT) 1314 void *fit_hdr; 1315 const char *fit_uname_config = NULL; 1316 const char *fit_uname_fdt = NULL; 1317 ulong default_addr; 1318 int cfg_noffset; 1319 int fdt_noffset; 1320 const void *data; 1321 size_t size; 1322 #endif 1323 1324 *of_flat_tree = NULL; 1325 *of_size = 0; 1326 1327 if (argc > 3 || genimg_has_config (images)) { 1328 #if defined(CONFIG_FIT) 1329 if (argc > 3) { 1330 /* 1331 * If the FDT blob comes from the FIT image and the 1332 * FIT image address is omitted in the command line 1333 * argument, try to use ramdisk or os FIT image 1334 * address or default load address. 1335 */ 1336 if (images->fit_uname_rd) 1337 default_addr = (ulong)images->fit_hdr_rd; 1338 else if (images->fit_uname_os) 1339 default_addr = (ulong)images->fit_hdr_os; 1340 else 1341 default_addr = load_addr; 1342 1343 if (fit_parse_conf (argv[3], default_addr, 1344 &fdt_addr, &fit_uname_config)) { 1345 debug ("* fdt: config '%s' from image at 0x%08lx\n", 1346 fit_uname_config, fdt_addr); 1347 } else if (fit_parse_subimage (argv[3], default_addr, 1348 &fdt_addr, &fit_uname_fdt)) { 1349 debug ("* fdt: subimage '%s' from image at 0x%08lx\n", 1350 fit_uname_fdt, fdt_addr); 1351 } else 1352 #endif 1353 { 1354 fdt_addr = simple_strtoul(argv[3], NULL, 16); 1355 debug ("* fdt: cmdline image address = 0x%08lx\n", 1356 fdt_addr); 1357 } 1358 #if defined(CONFIG_FIT) 1359 } else { 1360 /* use FIT configuration provided in first bootm 1361 * command argument 1362 */ 1363 fdt_addr = (ulong)images->fit_hdr_os; 1364 fit_uname_config = images->fit_uname_cfg; 1365 debug ("* fdt: using config '%s' from image at 0x%08lx\n", 1366 fit_uname_config, fdt_addr); 1367 1368 /* 1369 * Check whether configuration has FDT blob defined, 1370 * if not quit silently. 1371 */ 1372 fit_hdr = (void *)fdt_addr; 1373 cfg_noffset = fit_conf_get_node (fit_hdr, 1374 fit_uname_config); 1375 if (cfg_noffset < 0) { 1376 debug ("* fdt: no such config\n"); 1377 return 0; 1378 } 1379 1380 fdt_noffset = fit_conf_get_fdt_node (fit_hdr, 1381 cfg_noffset); 1382 if (fdt_noffset < 0) { 1383 debug ("* fdt: no fdt in config\n"); 1384 return 0; 1385 } 1386 } 1387 #endif 1388 1389 debug ("## Checking for 'FDT'/'FDT Image' at %08lx\n", 1390 fdt_addr); 1391 1392 /* copy from dataflash if needed */ 1393 fdt_addr = genimg_get_image (fdt_addr); 1394 1395 /* 1396 * Check if there is an FDT image at the 1397 * address provided in the second bootm argument 1398 * check image type, for FIT images get a FIT node. 1399 */ 1400 switch (genimg_get_format ((void *)fdt_addr)) { 1401 case IMAGE_FORMAT_LEGACY: 1402 /* verify fdt_addr points to a valid image header */ 1403 printf ("## Flattened Device Tree from Legacy Image at %08lx\n", 1404 fdt_addr); 1405 fdt_hdr = image_get_fdt (fdt_addr); 1406 if (!fdt_hdr) 1407 goto error; 1408 1409 /* 1410 * move image data to the load address, 1411 * make sure we don't overwrite initial image 1412 */ 1413 image_start = (ulong)fdt_hdr; 1414 image_end = image_get_image_end (fdt_hdr); 1415 1416 load_start = image_get_load (fdt_hdr); 1417 load_end = load_start + image_get_data_size (fdt_hdr); 1418 1419 if ((load_start < image_end) && (load_end > image_start)) { 1420 fdt_error ("fdt overwritten"); 1421 goto error; 1422 } 1423 1424 debug (" Loading FDT from 0x%08lx to 0x%08lx\n", 1425 image_get_data (fdt_hdr), load_start); 1426 1427 memmove ((void *)load_start, 1428 (void *)image_get_data (fdt_hdr), 1429 image_get_data_size (fdt_hdr)); 1430 1431 fdt_blob = (char *)load_start; 1432 break; 1433 case IMAGE_FORMAT_FIT: 1434 /* 1435 * This case will catch both: new uImage format 1436 * (libfdt based) and raw FDT blob (also libfdt 1437 * based). 1438 */ 1439 #if defined(CONFIG_FIT) 1440 /* check FDT blob vs FIT blob */ 1441 if (fit_check_format ((const void *)fdt_addr)) { 1442 /* 1443 * FIT image 1444 */ 1445 fit_hdr = (void *)fdt_addr; 1446 printf ("## Flattened Device Tree from FIT Image at %08lx\n", 1447 fdt_addr); 1448 1449 if (!fit_uname_fdt) { 1450 /* 1451 * no FDT blob image node unit name, 1452 * try to get config node first. If 1453 * config unit node name is NULL 1454 * fit_conf_get_node() will try to 1455 * find default config node 1456 */ 1457 cfg_noffset = fit_conf_get_node (fit_hdr, 1458 fit_uname_config); 1459 1460 if (cfg_noffset < 0) { 1461 fdt_error ("Could not find configuration node\n"); 1462 goto error; 1463 } 1464 1465 fit_uname_config = fdt_get_name (fit_hdr, 1466 cfg_noffset, NULL); 1467 printf (" Using '%s' configuration\n", 1468 fit_uname_config); 1469 1470 fdt_noffset = fit_conf_get_fdt_node (fit_hdr, 1471 cfg_noffset); 1472 fit_uname_fdt = fit_get_name (fit_hdr, 1473 fdt_noffset, NULL); 1474 } else { 1475 /* get FDT component image node offset */ 1476 fdt_noffset = fit_image_get_node (fit_hdr, 1477 fit_uname_fdt); 1478 } 1479 if (fdt_noffset < 0) { 1480 fdt_error ("Could not find subimage node\n"); 1481 goto error; 1482 } 1483 1484 printf (" Trying '%s' FDT blob subimage\n", 1485 fit_uname_fdt); 1486 1487 if (!fit_check_fdt (fit_hdr, fdt_noffset, 1488 images->verify)) 1489 goto error; 1490 1491 /* get ramdisk image data address and length */ 1492 if (fit_image_get_data (fit_hdr, fdt_noffset, 1493 &data, &size)) { 1494 fdt_error ("Could not find FDT subimage data"); 1495 goto error; 1496 } 1497 1498 /* verift that image data is a proper FDT blob */ 1499 if (fdt_check_header ((char *)data) != 0) { 1500 fdt_error ("Subimage data is not a FTD"); 1501 goto error; 1502 } 1503 1504 /* 1505 * move image data to the load address, 1506 * make sure we don't overwrite initial image 1507 */ 1508 image_start = (ulong)fit_hdr; 1509 image_end = fit_get_end (fit_hdr); 1510 1511 if (fit_image_get_load (fit_hdr, fdt_noffset, 1512 &load_start) == 0) { 1513 load_end = load_start + size; 1514 1515 if ((load_start < image_end) && 1516 (load_end > image_start)) { 1517 fdt_error ("FDT overwritten"); 1518 goto error; 1519 } 1520 1521 printf (" Loading FDT from 0x%08lx to 0x%08lx\n", 1522 (ulong)data, load_start); 1523 1524 memmove ((void *)load_start, 1525 (void *)data, size); 1526 1527 fdt_blob = (char *)load_start; 1528 } else { 1529 fdt_blob = (char *)data; 1530 } 1531 1532 images->fit_hdr_fdt = fit_hdr; 1533 images->fit_uname_fdt = fit_uname_fdt; 1534 images->fit_noffset_fdt = fdt_noffset; 1535 break; 1536 } else 1537 #endif 1538 { 1539 /* 1540 * FDT blob 1541 */ 1542 fdt_blob = (char *)fdt_addr; 1543 debug ("* fdt: raw FDT blob\n"); 1544 printf ("## Flattened Device Tree blob at %08lx\n", (long)fdt_blob); 1545 } 1546 break; 1547 default: 1548 puts ("ERROR: Did not find a cmdline Flattened Device Tree\n"); 1549 goto error; 1550 } 1551 1552 printf (" Booting using the fdt blob at 0x%x\n", (int)fdt_blob); 1553 1554 } else if (images->legacy_hdr_valid && 1555 image_check_type (&images->legacy_hdr_os_copy, IH_TYPE_MULTI)) { 1556 1557 ulong fdt_data, fdt_len; 1558 1559 /* 1560 * Now check if we have a legacy multi-component image, 1561 * get second entry data start address and len. 1562 */ 1563 printf ("## Flattened Device Tree from multi " 1564 "component Image at %08lX\n", 1565 (ulong)images->legacy_hdr_os); 1566 1567 image_multi_getimg (images->legacy_hdr_os, 2, &fdt_data, &fdt_len); 1568 if (fdt_len) { 1569 1570 fdt_blob = (char *)fdt_data; 1571 printf (" Booting using the fdt at 0x%x\n", (int)fdt_blob); 1572 1573 if (fdt_check_header (fdt_blob) != 0) { 1574 fdt_error ("image is not a fdt"); 1575 goto error; 1576 } 1577 1578 if (fdt_totalsize(fdt_blob) != fdt_len) { 1579 fdt_error ("fdt size != image size"); 1580 goto error; 1581 } 1582 } else { 1583 debug ("## No Flattened Device Tree\n"); 1584 return 0; 1585 } 1586 } else { 1587 debug ("## No Flattened Device Tree\n"); 1588 return 0; 1589 } 1590 1591 *of_flat_tree = fdt_blob; 1592 *of_size = fdt_totalsize(fdt_blob); 1593 debug (" of_flat_tree at 0x%08lx size 0x%08lx\n", 1594 (ulong)*of_flat_tree, *of_size); 1595 1596 return 0; 1597 1598 error: 1599 *of_flat_tree = 0; 1600 *of_size = 0; 1601 return 1; 1602 } 1603 #endif /* CONFIG_OF_LIBFDT */ 1604 1605 #ifdef CONFIG_SYS_BOOT_GET_CMDLINE 1606 /** 1607 * boot_get_cmdline - allocate and initialize kernel cmdline 1608 * @lmb: pointer to lmb handle, will be used for memory mgmt 1609 * @cmd_start: pointer to a ulong variable, will hold cmdline start 1610 * @cmd_end: pointer to a ulong variable, will hold cmdline end 1611 * 1612 * boot_get_cmdline() allocates space for kernel command line below 1613 * BOOTMAPSZ + getenv_bootm_low() address. If "bootargs" U-boot environemnt 1614 * variable is present its contents is copied to allocated kernel 1615 * command line. 1616 * 1617 * returns: 1618 * 0 - success 1619 * -1 - failure 1620 */ 1621 int boot_get_cmdline (struct lmb *lmb, ulong *cmd_start, ulong *cmd_end) 1622 { 1623 char *cmdline; 1624 char *s; 1625 1626 cmdline = (char *)(ulong)lmb_alloc_base(lmb, CONFIG_SYS_BARGSIZE, 0xf, 1627 getenv_bootm_mapsize() + getenv_bootm_low()); 1628 1629 if (cmdline == NULL) 1630 return -1; 1631 1632 if ((s = getenv("bootargs")) == NULL) 1633 s = ""; 1634 1635 strcpy(cmdline, s); 1636 1637 *cmd_start = (ulong) & cmdline[0]; 1638 *cmd_end = *cmd_start + strlen(cmdline); 1639 1640 debug ("## cmdline at 0x%08lx ... 0x%08lx\n", *cmd_start, *cmd_end); 1641 1642 return 0; 1643 } 1644 #endif /* CONFIG_SYS_BOOT_GET_CMDLINE */ 1645 1646 #ifdef CONFIG_SYS_BOOT_GET_KBD 1647 /** 1648 * boot_get_kbd - allocate and initialize kernel copy of board info 1649 * @lmb: pointer to lmb handle, will be used for memory mgmt 1650 * @kbd: double pointer to board info data 1651 * 1652 * boot_get_kbd() allocates space for kernel copy of board info data below 1653 * BOOTMAPSZ + getenv_bootm_low() address and kernel board info is initialized 1654 * with the current u-boot board info data. 1655 * 1656 * returns: 1657 * 0 - success 1658 * -1 - failure 1659 */ 1660 int boot_get_kbd (struct lmb *lmb, bd_t **kbd) 1661 { 1662 *kbd = (bd_t *)(ulong)lmb_alloc_base(lmb, sizeof(bd_t), 0xf, 1663 getenv_bootm_mapsize() + getenv_bootm_low()); 1664 if (*kbd == NULL) 1665 return -1; 1666 1667 **kbd = *(gd->bd); 1668 1669 debug ("## kernel board info at 0x%08lx\n", (ulong)*kbd); 1670 1671 #if defined(DEBUG) && defined(CONFIG_CMD_BDI) 1672 do_bdinfo(NULL, 0, 0, NULL); 1673 #endif 1674 1675 return 0; 1676 } 1677 #endif /* CONFIG_SYS_BOOT_GET_KBD */ 1678 #endif /* !USE_HOSTCC */ 1679 1680 #if defined(CONFIG_FIT) 1681 /*****************************************************************************/ 1682 /* New uImage format routines */ 1683 /*****************************************************************************/ 1684 #ifndef USE_HOSTCC 1685 static int fit_parse_spec (const char *spec, char sepc, ulong addr_curr, 1686 ulong *addr, const char **name) 1687 { 1688 const char *sep; 1689 1690 *addr = addr_curr; 1691 *name = NULL; 1692 1693 sep = strchr (spec, sepc); 1694 if (sep) { 1695 if (sep - spec > 0) 1696 *addr = simple_strtoul (spec, NULL, 16); 1697 1698 *name = sep + 1; 1699 return 1; 1700 } 1701 1702 return 0; 1703 } 1704 1705 /** 1706 * fit_parse_conf - parse FIT configuration spec 1707 * @spec: input string, containing configuration spec 1708 * @add_curr: current image address (to be used as a possible default) 1709 * @addr: pointer to a ulong variable, will hold FIT image address of a given 1710 * configuration 1711 * @conf_name double pointer to a char, will hold pointer to a configuration 1712 * unit name 1713 * 1714 * fit_parse_conf() expects configuration spec in the for of [<addr>]#<conf>, 1715 * where <addr> is a FIT image address that contains configuration 1716 * with a <conf> unit name. 1717 * 1718 * Address part is optional, and if omitted default add_curr will 1719 * be used instead. 1720 * 1721 * returns: 1722 * 1 if spec is a valid configuration string, 1723 * addr and conf_name are set accordingly 1724 * 0 otherwise 1725 */ 1726 inline int fit_parse_conf (const char *spec, ulong addr_curr, 1727 ulong *addr, const char **conf_name) 1728 { 1729 return fit_parse_spec (spec, '#', addr_curr, addr, conf_name); 1730 } 1731 1732 /** 1733 * fit_parse_subimage - parse FIT subimage spec 1734 * @spec: input string, containing subimage spec 1735 * @add_curr: current image address (to be used as a possible default) 1736 * @addr: pointer to a ulong variable, will hold FIT image address of a given 1737 * subimage 1738 * @image_name: double pointer to a char, will hold pointer to a subimage name 1739 * 1740 * fit_parse_subimage() expects subimage spec in the for of 1741 * [<addr>]:<subimage>, where <addr> is a FIT image address that contains 1742 * subimage with a <subimg> unit name. 1743 * 1744 * Address part is optional, and if omitted default add_curr will 1745 * be used instead. 1746 * 1747 * returns: 1748 * 1 if spec is a valid subimage string, 1749 * addr and image_name are set accordingly 1750 * 0 otherwise 1751 */ 1752 inline int fit_parse_subimage (const char *spec, ulong addr_curr, 1753 ulong *addr, const char **image_name) 1754 { 1755 return fit_parse_spec (spec, ':', addr_curr, addr, image_name); 1756 } 1757 #endif /* !USE_HOSTCC */ 1758 1759 static void fit_get_debug (const void *fit, int noffset, 1760 char *prop_name, int err) 1761 { 1762 debug ("Can't get '%s' property from FIT 0x%08lx, " 1763 "node: offset %d, name %s (%s)\n", 1764 prop_name, (ulong)fit, noffset, 1765 fit_get_name (fit, noffset, NULL), 1766 fdt_strerror (err)); 1767 } 1768 1769 /** 1770 * fit_print_contents - prints out the contents of the FIT format image 1771 * @fit: pointer to the FIT format image header 1772 * @p: pointer to prefix string 1773 * 1774 * fit_print_contents() formats a multi line FIT image contents description. 1775 * The routine prints out FIT image properties (root node level) follwed by 1776 * the details of each component image. 1777 * 1778 * returns: 1779 * no returned results 1780 */ 1781 void fit_print_contents (const void *fit) 1782 { 1783 char *desc; 1784 char *uname; 1785 int images_noffset; 1786 int confs_noffset; 1787 int noffset; 1788 int ndepth; 1789 int count = 0; 1790 int ret; 1791 const char *p; 1792 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC) 1793 time_t timestamp; 1794 #endif 1795 1796 #ifdef USE_HOSTCC 1797 p = ""; 1798 #else 1799 p = " "; 1800 #endif 1801 1802 /* Root node properties */ 1803 ret = fit_get_desc (fit, 0, &desc); 1804 printf ("%sFIT description: ", p); 1805 if (ret) 1806 printf ("unavailable\n"); 1807 else 1808 printf ("%s\n", desc); 1809 1810 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC) 1811 ret = fit_get_timestamp (fit, 0, ×tamp); 1812 printf ("%sCreated: ", p); 1813 if (ret) 1814 printf ("unavailable\n"); 1815 else 1816 genimg_print_time (timestamp); 1817 #endif 1818 1819 /* Find images parent node offset */ 1820 images_noffset = fdt_path_offset (fit, FIT_IMAGES_PATH); 1821 if (images_noffset < 0) { 1822 printf ("Can't find images parent node '%s' (%s)\n", 1823 FIT_IMAGES_PATH, fdt_strerror (images_noffset)); 1824 return; 1825 } 1826 1827 /* Process its subnodes, print out component images details */ 1828 for (ndepth = 0, count = 0, noffset = fdt_next_node (fit, images_noffset, &ndepth); 1829 (noffset >= 0) && (ndepth > 0); 1830 noffset = fdt_next_node (fit, noffset, &ndepth)) { 1831 if (ndepth == 1) { 1832 /* 1833 * Direct child node of the images parent node, 1834 * i.e. component image node. 1835 */ 1836 printf ("%s Image %u (%s)\n", p, count++, 1837 fit_get_name(fit, noffset, NULL)); 1838 1839 fit_image_print (fit, noffset, p); 1840 } 1841 } 1842 1843 /* Find configurations parent node offset */ 1844 confs_noffset = fdt_path_offset (fit, FIT_CONFS_PATH); 1845 if (confs_noffset < 0) { 1846 debug ("Can't get configurations parent node '%s' (%s)\n", 1847 FIT_CONFS_PATH, fdt_strerror (confs_noffset)); 1848 return; 1849 } 1850 1851 /* get default configuration unit name from default property */ 1852 uname = (char *)fdt_getprop (fit, noffset, FIT_DEFAULT_PROP, NULL); 1853 if (uname) 1854 printf ("%s Default Configuration: '%s'\n", p, uname); 1855 1856 /* Process its subnodes, print out configurations details */ 1857 for (ndepth = 0, count = 0, noffset = fdt_next_node (fit, confs_noffset, &ndepth); 1858 (noffset >= 0) && (ndepth > 0); 1859 noffset = fdt_next_node (fit, noffset, &ndepth)) { 1860 if (ndepth == 1) { 1861 /* 1862 * Direct child node of the configurations parent node, 1863 * i.e. configuration node. 1864 */ 1865 printf ("%s Configuration %u (%s)\n", p, count++, 1866 fit_get_name(fit, noffset, NULL)); 1867 1868 fit_conf_print (fit, noffset, p); 1869 } 1870 } 1871 } 1872 1873 /** 1874 * fit_image_print - prints out the FIT component image details 1875 * @fit: pointer to the FIT format image header 1876 * @image_noffset: offset of the component image node 1877 * @p: pointer to prefix string 1878 * 1879 * fit_image_print() lists all mandatory properies for the processed component 1880 * image. If present, hash nodes are printed out as well. Load 1881 * address for images of type firmware is also printed out. Since the load 1882 * address is not mandatory for firmware images, it will be output as 1883 * "unavailable" when not present. 1884 * 1885 * returns: 1886 * no returned results 1887 */ 1888 void fit_image_print (const void *fit, int image_noffset, const char *p) 1889 { 1890 char *desc; 1891 uint8_t type, arch, os, comp; 1892 size_t size; 1893 ulong load, entry; 1894 const void *data; 1895 int noffset; 1896 int ndepth; 1897 int ret; 1898 1899 /* Mandatory properties */ 1900 ret = fit_get_desc (fit, image_noffset, &desc); 1901 printf ("%s Description: ", p); 1902 if (ret) 1903 printf ("unavailable\n"); 1904 else 1905 printf ("%s\n", desc); 1906 1907 fit_image_get_type (fit, image_noffset, &type); 1908 printf ("%s Type: %s\n", p, genimg_get_type_name (type)); 1909 1910 fit_image_get_comp (fit, image_noffset, &comp); 1911 printf ("%s Compression: %s\n", p, genimg_get_comp_name (comp)); 1912 1913 ret = fit_image_get_data (fit, image_noffset, &data, &size); 1914 1915 #ifndef USE_HOSTCC 1916 printf ("%s Data Start: ", p); 1917 if (ret) 1918 printf ("unavailable\n"); 1919 else 1920 printf ("0x%08lx\n", (ulong)data); 1921 #endif 1922 1923 printf ("%s Data Size: ", p); 1924 if (ret) 1925 printf ("unavailable\n"); 1926 else 1927 genimg_print_size (size); 1928 1929 /* Remaining, type dependent properties */ 1930 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) || 1931 (type == IH_TYPE_RAMDISK) || (type == IH_TYPE_FIRMWARE) || 1932 (type == IH_TYPE_FLATDT)) { 1933 fit_image_get_arch (fit, image_noffset, &arch); 1934 printf ("%s Architecture: %s\n", p, genimg_get_arch_name (arch)); 1935 } 1936 1937 if (type == IH_TYPE_KERNEL) { 1938 fit_image_get_os (fit, image_noffset, &os); 1939 printf ("%s OS: %s\n", p, genimg_get_os_name (os)); 1940 } 1941 1942 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) || 1943 (type == IH_TYPE_FIRMWARE)) { 1944 ret = fit_image_get_load (fit, image_noffset, &load); 1945 printf ("%s Load Address: ", p); 1946 if (ret) 1947 printf ("unavailable\n"); 1948 else 1949 printf ("0x%08lx\n", load); 1950 } 1951 1952 if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE)) { 1953 fit_image_get_entry (fit, image_noffset, &entry); 1954 printf ("%s Entry Point: ", p); 1955 if (ret) 1956 printf ("unavailable\n"); 1957 else 1958 printf ("0x%08lx\n", entry); 1959 } 1960 1961 /* Process all hash subnodes of the component image node */ 1962 for (ndepth = 0, noffset = fdt_next_node (fit, image_noffset, &ndepth); 1963 (noffset >= 0) && (ndepth > 0); 1964 noffset = fdt_next_node (fit, noffset, &ndepth)) { 1965 if (ndepth == 1) { 1966 /* Direct child node of the component image node */ 1967 fit_image_print_hash (fit, noffset, p); 1968 } 1969 } 1970 } 1971 1972 /** 1973 * fit_image_print_hash - prints out the hash node details 1974 * @fit: pointer to the FIT format image header 1975 * @noffset: offset of the hash node 1976 * @p: pointer to prefix string 1977 * 1978 * fit_image_print_hash() lists properies for the processed hash node 1979 * 1980 * returns: 1981 * no returned results 1982 */ 1983 void fit_image_print_hash (const void *fit, int noffset, const char *p) 1984 { 1985 char *algo; 1986 uint8_t *value; 1987 int value_len; 1988 int i, ret; 1989 1990 /* 1991 * Check subnode name, must be equal to "hash". 1992 * Multiple hash nodes require unique unit node 1993 * names, e.g. hash@1, hash@2, etc. 1994 */ 1995 if (strncmp (fit_get_name(fit, noffset, NULL), 1996 FIT_HASH_NODENAME, 1997 strlen(FIT_HASH_NODENAME)) != 0) 1998 return; 1999 2000 debug ("%s Hash node: '%s'\n", p, 2001 fit_get_name (fit, noffset, NULL)); 2002 2003 printf ("%s Hash algo: ", p); 2004 if (fit_image_hash_get_algo (fit, noffset, &algo)) { 2005 printf ("invalid/unsupported\n"); 2006 return; 2007 } 2008 printf ("%s\n", algo); 2009 2010 ret = fit_image_hash_get_value (fit, noffset, &value, 2011 &value_len); 2012 printf ("%s Hash value: ", p); 2013 if (ret) { 2014 printf ("unavailable\n"); 2015 } else { 2016 for (i = 0; i < value_len; i++) 2017 printf ("%02x", value[i]); 2018 printf ("\n"); 2019 } 2020 2021 debug ("%s Hash len: %d\n", p, value_len); 2022 } 2023 2024 /** 2025 * fit_get_desc - get node description property 2026 * @fit: pointer to the FIT format image header 2027 * @noffset: node offset 2028 * @desc: double pointer to the char, will hold pointer to the descrption 2029 * 2030 * fit_get_desc() reads description property from a given node, if 2031 * description is found pointer to it is returened in third call argument. 2032 * 2033 * returns: 2034 * 0, on success 2035 * -1, on failure 2036 */ 2037 int fit_get_desc (const void *fit, int noffset, char **desc) 2038 { 2039 int len; 2040 2041 *desc = (char *)fdt_getprop (fit, noffset, FIT_DESC_PROP, &len); 2042 if (*desc == NULL) { 2043 fit_get_debug (fit, noffset, FIT_DESC_PROP, len); 2044 return -1; 2045 } 2046 2047 return 0; 2048 } 2049 2050 /** 2051 * fit_get_timestamp - get node timestamp property 2052 * @fit: pointer to the FIT format image header 2053 * @noffset: node offset 2054 * @timestamp: pointer to the time_t, will hold read timestamp 2055 * 2056 * fit_get_timestamp() reads timestamp poperty from given node, if timestamp 2057 * is found and has a correct size its value is retured in third call 2058 * argument. 2059 * 2060 * returns: 2061 * 0, on success 2062 * -1, on property read failure 2063 * -2, on wrong timestamp size 2064 */ 2065 int fit_get_timestamp (const void *fit, int noffset, time_t *timestamp) 2066 { 2067 int len; 2068 const void *data; 2069 2070 data = fdt_getprop (fit, noffset, FIT_TIMESTAMP_PROP, &len); 2071 if (data == NULL) { 2072 fit_get_debug (fit, noffset, FIT_TIMESTAMP_PROP, len); 2073 return -1; 2074 } 2075 if (len != sizeof (uint32_t)) { 2076 debug ("FIT timestamp with incorrect size of (%u)\n", len); 2077 return -2; 2078 } 2079 2080 *timestamp = uimage_to_cpu (*((uint32_t *)data)); 2081 return 0; 2082 } 2083 2084 /** 2085 * fit_image_get_node - get node offset for component image of a given unit name 2086 * @fit: pointer to the FIT format image header 2087 * @image_uname: component image node unit name 2088 * 2089 * fit_image_get_node() finds a component image (withing the '/images' 2090 * node) of a provided unit name. If image is found its node offset is 2091 * returned to the caller. 2092 * 2093 * returns: 2094 * image node offset when found (>=0) 2095 * negative number on failure (FDT_ERR_* code) 2096 */ 2097 int fit_image_get_node (const void *fit, const char *image_uname) 2098 { 2099 int noffset, images_noffset; 2100 2101 images_noffset = fdt_path_offset (fit, FIT_IMAGES_PATH); 2102 if (images_noffset < 0) { 2103 debug ("Can't find images parent node '%s' (%s)\n", 2104 FIT_IMAGES_PATH, fdt_strerror (images_noffset)); 2105 return images_noffset; 2106 } 2107 2108 noffset = fdt_subnode_offset (fit, images_noffset, image_uname); 2109 if (noffset < 0) { 2110 debug ("Can't get node offset for image unit name: '%s' (%s)\n", 2111 image_uname, fdt_strerror (noffset)); 2112 } 2113 2114 return noffset; 2115 } 2116 2117 /** 2118 * fit_image_get_os - get os id for a given component image node 2119 * @fit: pointer to the FIT format image header 2120 * @noffset: component image node offset 2121 * @os: pointer to the uint8_t, will hold os numeric id 2122 * 2123 * fit_image_get_os() finds os property in a given component image node. 2124 * If the property is found, its (string) value is translated to the numeric 2125 * id which is returned to the caller. 2126 * 2127 * returns: 2128 * 0, on success 2129 * -1, on failure 2130 */ 2131 int fit_image_get_os (const void *fit, int noffset, uint8_t *os) 2132 { 2133 int len; 2134 const void *data; 2135 2136 /* Get OS name from property data */ 2137 data = fdt_getprop (fit, noffset, FIT_OS_PROP, &len); 2138 if (data == NULL) { 2139 fit_get_debug (fit, noffset, FIT_OS_PROP, len); 2140 *os = -1; 2141 return -1; 2142 } 2143 2144 /* Translate OS name to id */ 2145 *os = genimg_get_os_id (data); 2146 return 0; 2147 } 2148 2149 /** 2150 * fit_image_get_arch - get arch id for a given component image node 2151 * @fit: pointer to the FIT format image header 2152 * @noffset: component image node offset 2153 * @arch: pointer to the uint8_t, will hold arch numeric id 2154 * 2155 * fit_image_get_arch() finds arch property in a given component image node. 2156 * If the property is found, its (string) value is translated to the numeric 2157 * id which is returned to the caller. 2158 * 2159 * returns: 2160 * 0, on success 2161 * -1, on failure 2162 */ 2163 int fit_image_get_arch (const void *fit, int noffset, uint8_t *arch) 2164 { 2165 int len; 2166 const void *data; 2167 2168 /* Get architecture name from property data */ 2169 data = fdt_getprop (fit, noffset, FIT_ARCH_PROP, &len); 2170 if (data == NULL) { 2171 fit_get_debug (fit, noffset, FIT_ARCH_PROP, len); 2172 *arch = -1; 2173 return -1; 2174 } 2175 2176 /* Translate architecture name to id */ 2177 *arch = genimg_get_arch_id (data); 2178 return 0; 2179 } 2180 2181 /** 2182 * fit_image_get_type - get type id for a given component image node 2183 * @fit: pointer to the FIT format image header 2184 * @noffset: component image node offset 2185 * @type: pointer to the uint8_t, will hold type numeric id 2186 * 2187 * fit_image_get_type() finds type property in a given component image node. 2188 * If the property is found, its (string) value is translated to the numeric 2189 * id which is returned to the caller. 2190 * 2191 * returns: 2192 * 0, on success 2193 * -1, on failure 2194 */ 2195 int fit_image_get_type (const void *fit, int noffset, uint8_t *type) 2196 { 2197 int len; 2198 const void *data; 2199 2200 /* Get image type name from property data */ 2201 data = fdt_getprop (fit, noffset, FIT_TYPE_PROP, &len); 2202 if (data == NULL) { 2203 fit_get_debug (fit, noffset, FIT_TYPE_PROP, len); 2204 *type = -1; 2205 return -1; 2206 } 2207 2208 /* Translate image type name to id */ 2209 *type = genimg_get_type_id (data); 2210 return 0; 2211 } 2212 2213 /** 2214 * fit_image_get_comp - get comp id for a given component image node 2215 * @fit: pointer to the FIT format image header 2216 * @noffset: component image node offset 2217 * @comp: pointer to the uint8_t, will hold comp numeric id 2218 * 2219 * fit_image_get_comp() finds comp property in a given component image node. 2220 * If the property is found, its (string) value is translated to the numeric 2221 * id which is returned to the caller. 2222 * 2223 * returns: 2224 * 0, on success 2225 * -1, on failure 2226 */ 2227 int fit_image_get_comp (const void *fit, int noffset, uint8_t *comp) 2228 { 2229 int len; 2230 const void *data; 2231 2232 /* Get compression name from property data */ 2233 data = fdt_getprop (fit, noffset, FIT_COMP_PROP, &len); 2234 if (data == NULL) { 2235 fit_get_debug (fit, noffset, FIT_COMP_PROP, len); 2236 *comp = -1; 2237 return -1; 2238 } 2239 2240 /* Translate compression name to id */ 2241 *comp = genimg_get_comp_id (data); 2242 return 0; 2243 } 2244 2245 /** 2246 * fit_image_get_load - get load address property for a given component image node 2247 * @fit: pointer to the FIT format image header 2248 * @noffset: component image node offset 2249 * @load: pointer to the uint32_t, will hold load address 2250 * 2251 * fit_image_get_load() finds load address property in a given component image node. 2252 * If the property is found, its value is returned to the caller. 2253 * 2254 * returns: 2255 * 0, on success 2256 * -1, on failure 2257 */ 2258 int fit_image_get_load (const void *fit, int noffset, ulong *load) 2259 { 2260 int len; 2261 const uint32_t *data; 2262 2263 data = fdt_getprop (fit, noffset, FIT_LOAD_PROP, &len); 2264 if (data == NULL) { 2265 fit_get_debug (fit, noffset, FIT_LOAD_PROP, len); 2266 return -1; 2267 } 2268 2269 *load = uimage_to_cpu (*data); 2270 return 0; 2271 } 2272 2273 /** 2274 * fit_image_get_entry - get entry point address property for a given component image node 2275 * @fit: pointer to the FIT format image header 2276 * @noffset: component image node offset 2277 * @entry: pointer to the uint32_t, will hold entry point address 2278 * 2279 * fit_image_get_entry() finds entry point address property in a given component image node. 2280 * If the property is found, its value is returned to the caller. 2281 * 2282 * returns: 2283 * 0, on success 2284 * -1, on failure 2285 */ 2286 int fit_image_get_entry (const void *fit, int noffset, ulong *entry) 2287 { 2288 int len; 2289 const uint32_t *data; 2290 2291 data = fdt_getprop (fit, noffset, FIT_ENTRY_PROP, &len); 2292 if (data == NULL) { 2293 fit_get_debug (fit, noffset, FIT_ENTRY_PROP, len); 2294 return -1; 2295 } 2296 2297 *entry = uimage_to_cpu (*data); 2298 return 0; 2299 } 2300 2301 /** 2302 * fit_image_get_data - get data property and its size for a given component image node 2303 * @fit: pointer to the FIT format image header 2304 * @noffset: component image node offset 2305 * @data: double pointer to void, will hold data property's data address 2306 * @size: pointer to size_t, will hold data property's data size 2307 * 2308 * fit_image_get_data() finds data property in a given component image node. 2309 * If the property is found its data start address and size are returned to 2310 * the caller. 2311 * 2312 * returns: 2313 * 0, on success 2314 * -1, on failure 2315 */ 2316 int fit_image_get_data (const void *fit, int noffset, 2317 const void **data, size_t *size) 2318 { 2319 int len; 2320 2321 *data = fdt_getprop (fit, noffset, FIT_DATA_PROP, &len); 2322 if (*data == NULL) { 2323 fit_get_debug (fit, noffset, FIT_DATA_PROP, len); 2324 *size = 0; 2325 return -1; 2326 } 2327 2328 *size = len; 2329 return 0; 2330 } 2331 2332 /** 2333 * fit_image_hash_get_algo - get hash algorithm name 2334 * @fit: pointer to the FIT format image header 2335 * @noffset: hash node offset 2336 * @algo: double pointer to char, will hold pointer to the algorithm name 2337 * 2338 * fit_image_hash_get_algo() finds hash algorithm property in a given hash node. 2339 * If the property is found its data start address is returned to the caller. 2340 * 2341 * returns: 2342 * 0, on success 2343 * -1, on failure 2344 */ 2345 int fit_image_hash_get_algo (const void *fit, int noffset, char **algo) 2346 { 2347 int len; 2348 2349 *algo = (char *)fdt_getprop (fit, noffset, FIT_ALGO_PROP, &len); 2350 if (*algo == NULL) { 2351 fit_get_debug (fit, noffset, FIT_ALGO_PROP, len); 2352 return -1; 2353 } 2354 2355 return 0; 2356 } 2357 2358 /** 2359 * fit_image_hash_get_value - get hash value and length 2360 * @fit: pointer to the FIT format image header 2361 * @noffset: hash node offset 2362 * @value: double pointer to uint8_t, will hold address of a hash value data 2363 * @value_len: pointer to an int, will hold hash data length 2364 * 2365 * fit_image_hash_get_value() finds hash value property in a given hash node. 2366 * If the property is found its data start address and size are returned to 2367 * the caller. 2368 * 2369 * returns: 2370 * 0, on success 2371 * -1, on failure 2372 */ 2373 int fit_image_hash_get_value (const void *fit, int noffset, uint8_t **value, 2374 int *value_len) 2375 { 2376 int len; 2377 2378 *value = (uint8_t *)fdt_getprop (fit, noffset, FIT_VALUE_PROP, &len); 2379 if (*value == NULL) { 2380 fit_get_debug (fit, noffset, FIT_VALUE_PROP, len); 2381 *value_len = 0; 2382 return -1; 2383 } 2384 2385 *value_len = len; 2386 return 0; 2387 } 2388 2389 /** 2390 * fit_set_timestamp - set node timestamp property 2391 * @fit: pointer to the FIT format image header 2392 * @noffset: node offset 2393 * @timestamp: timestamp value to be set 2394 * 2395 * fit_set_timestamp() attempts to set timestamp property in the requested 2396 * node and returns operation status to the caller. 2397 * 2398 * returns: 2399 * 0, on success 2400 * -1, on property read failure 2401 */ 2402 int fit_set_timestamp (void *fit, int noffset, time_t timestamp) 2403 { 2404 uint32_t t; 2405 int ret; 2406 2407 t = cpu_to_uimage (timestamp); 2408 ret = fdt_setprop (fit, noffset, FIT_TIMESTAMP_PROP, &t, 2409 sizeof (uint32_t)); 2410 if (ret) { 2411 printf ("Can't set '%s' property for '%s' node (%s)\n", 2412 FIT_TIMESTAMP_PROP, fit_get_name (fit, noffset, NULL), 2413 fdt_strerror (ret)); 2414 return -1; 2415 } 2416 2417 return 0; 2418 } 2419 2420 /** 2421 * calculate_hash - calculate and return hash for provided input data 2422 * @data: pointer to the input data 2423 * @data_len: data length 2424 * @algo: requested hash algorithm 2425 * @value: pointer to the char, will hold hash value data (caller must 2426 * allocate enough free space) 2427 * value_len: length of the calculated hash 2428 * 2429 * calculate_hash() computes input data hash according to the requested algorithm. 2430 * Resulting hash value is placed in caller provided 'value' buffer, length 2431 * of the calculated hash is returned via value_len pointer argument. 2432 * 2433 * returns: 2434 * 0, on success 2435 * -1, when algo is unsupported 2436 */ 2437 static int calculate_hash (const void *data, int data_len, const char *algo, 2438 uint8_t *value, int *value_len) 2439 { 2440 if (strcmp (algo, "crc32") == 0 ) { 2441 *((uint32_t *)value) = crc32_wd (0, data, data_len, 2442 CHUNKSZ_CRC32); 2443 *((uint32_t *)value) = cpu_to_uimage (*((uint32_t *)value)); 2444 *value_len = 4; 2445 } else if (strcmp (algo, "sha1") == 0 ) { 2446 sha1_csum_wd ((unsigned char *) data, data_len, 2447 (unsigned char *) value, CHUNKSZ_SHA1); 2448 *value_len = 20; 2449 } else if (strcmp (algo, "md5") == 0 ) { 2450 md5_wd ((unsigned char *)data, data_len, value, CHUNKSZ_MD5); 2451 *value_len = 16; 2452 } else { 2453 debug ("Unsupported hash alogrithm\n"); 2454 return -1; 2455 } 2456 return 0; 2457 } 2458 2459 #ifdef USE_HOSTCC 2460 /** 2461 * fit_set_hashes - process FIT component image nodes and calculate hashes 2462 * @fit: pointer to the FIT format image header 2463 * 2464 * fit_set_hashes() adds hash values for all component images in the FIT blob. 2465 * Hashes are calculated for all component images which have hash subnodes 2466 * with algorithm property set to one of the supported hash algorithms. 2467 * 2468 * returns 2469 * 0, on success 2470 * libfdt error code, on failure 2471 */ 2472 int fit_set_hashes (void *fit) 2473 { 2474 int images_noffset; 2475 int noffset; 2476 int ndepth; 2477 int ret; 2478 2479 /* Find images parent node offset */ 2480 images_noffset = fdt_path_offset (fit, FIT_IMAGES_PATH); 2481 if (images_noffset < 0) { 2482 printf ("Can't find images parent node '%s' (%s)\n", 2483 FIT_IMAGES_PATH, fdt_strerror (images_noffset)); 2484 return images_noffset; 2485 } 2486 2487 /* Process its subnodes, print out component images details */ 2488 for (ndepth = 0, noffset = fdt_next_node (fit, images_noffset, &ndepth); 2489 (noffset >= 0) && (ndepth > 0); 2490 noffset = fdt_next_node (fit, noffset, &ndepth)) { 2491 if (ndepth == 1) { 2492 /* 2493 * Direct child node of the images parent node, 2494 * i.e. component image node. 2495 */ 2496 ret = fit_image_set_hashes (fit, noffset); 2497 if (ret) 2498 return ret; 2499 } 2500 } 2501 2502 return 0; 2503 } 2504 2505 /** 2506 * fit_image_set_hashes - calculate/set hashes for given component image node 2507 * @fit: pointer to the FIT format image header 2508 * @image_noffset: requested component image node 2509 * 2510 * fit_image_set_hashes() adds hash values for an component image node. All 2511 * existing hash subnodes are checked, if algorithm property is set to one of 2512 * the supported hash algorithms, hash value is computed and corresponding 2513 * hash node property is set, for example: 2514 * 2515 * Input component image node structure: 2516 * 2517 * o image@1 (at image_noffset) 2518 * | - data = [binary data] 2519 * o hash@1 2520 * |- algo = "sha1" 2521 * 2522 * Output component image node structure: 2523 * 2524 * o image@1 (at image_noffset) 2525 * | - data = [binary data] 2526 * o hash@1 2527 * |- algo = "sha1" 2528 * |- value = sha1(data) 2529 * 2530 * returns: 2531 * 0 on sucess 2532 * <0 on failure 2533 */ 2534 int fit_image_set_hashes (void *fit, int image_noffset) 2535 { 2536 const void *data; 2537 size_t size; 2538 char *algo; 2539 uint8_t value[FIT_MAX_HASH_LEN]; 2540 int value_len; 2541 int noffset; 2542 int ndepth; 2543 2544 /* Get image data and data length */ 2545 if (fit_image_get_data (fit, image_noffset, &data, &size)) { 2546 printf ("Can't get image data/size\n"); 2547 return -1; 2548 } 2549 2550 /* Process all hash subnodes of the component image node */ 2551 for (ndepth = 0, noffset = fdt_next_node (fit, image_noffset, &ndepth); 2552 (noffset >= 0) && (ndepth > 0); 2553 noffset = fdt_next_node (fit, noffset, &ndepth)) { 2554 if (ndepth == 1) { 2555 /* Direct child node of the component image node */ 2556 2557 /* 2558 * Check subnode name, must be equal to "hash". 2559 * Multiple hash nodes require unique unit node 2560 * names, e.g. hash@1, hash@2, etc. 2561 */ 2562 if (strncmp (fit_get_name(fit, noffset, NULL), 2563 FIT_HASH_NODENAME, 2564 strlen(FIT_HASH_NODENAME)) != 0) { 2565 /* Not a hash subnode, skip it */ 2566 continue; 2567 } 2568 2569 if (fit_image_hash_get_algo (fit, noffset, &algo)) { 2570 printf ("Can't get hash algo property for " 2571 "'%s' hash node in '%s' image node\n", 2572 fit_get_name (fit, noffset, NULL), 2573 fit_get_name (fit, image_noffset, NULL)); 2574 return -1; 2575 } 2576 2577 if (calculate_hash (data, size, algo, value, &value_len)) { 2578 printf ("Unsupported hash algorithm (%s) for " 2579 "'%s' hash node in '%s' image node\n", 2580 algo, fit_get_name (fit, noffset, NULL), 2581 fit_get_name (fit, image_noffset, NULL)); 2582 return -1; 2583 } 2584 2585 if (fit_image_hash_set_value (fit, noffset, value, 2586 value_len)) { 2587 printf ("Can't set hash value for " 2588 "'%s' hash node in '%s' image node\n", 2589 fit_get_name (fit, noffset, NULL), 2590 fit_get_name (fit, image_noffset, NULL)); 2591 return -1; 2592 } 2593 } 2594 } 2595 2596 return 0; 2597 } 2598 2599 /** 2600 * fit_image_hash_set_value - set hash value in requested has node 2601 * @fit: pointer to the FIT format image header 2602 * @noffset: hash node offset 2603 * @value: hash value to be set 2604 * @value_len: hash value length 2605 * 2606 * fit_image_hash_set_value() attempts to set hash value in a node at offset 2607 * given and returns operation status to the caller. 2608 * 2609 * returns 2610 * 0, on success 2611 * -1, on failure 2612 */ 2613 int fit_image_hash_set_value (void *fit, int noffset, uint8_t *value, 2614 int value_len) 2615 { 2616 int ret; 2617 2618 ret = fdt_setprop (fit, noffset, FIT_VALUE_PROP, value, value_len); 2619 if (ret) { 2620 printf ("Can't set hash '%s' property for '%s' node (%s)\n", 2621 FIT_VALUE_PROP, fit_get_name (fit, noffset, NULL), 2622 fdt_strerror (ret)); 2623 return -1; 2624 } 2625 2626 return 0; 2627 } 2628 #endif /* USE_HOSTCC */ 2629 2630 /** 2631 * fit_image_check_hashes - verify data intergity 2632 * @fit: pointer to the FIT format image header 2633 * @image_noffset: component image node offset 2634 * 2635 * fit_image_check_hashes() goes over component image hash nodes, 2636 * re-calculates each data hash and compares with the value stored in hash 2637 * node. 2638 * 2639 * returns: 2640 * 1, if all hashes are valid 2641 * 0, otherwise (or on error) 2642 */ 2643 int fit_image_check_hashes (const void *fit, int image_noffset) 2644 { 2645 const void *data; 2646 size_t size; 2647 char *algo; 2648 uint8_t *fit_value; 2649 int fit_value_len; 2650 uint8_t value[FIT_MAX_HASH_LEN]; 2651 int value_len; 2652 int noffset; 2653 int ndepth; 2654 char *err_msg = ""; 2655 2656 /* Get image data and data length */ 2657 if (fit_image_get_data (fit, image_noffset, &data, &size)) { 2658 printf ("Can't get image data/size\n"); 2659 return 0; 2660 } 2661 2662 /* Process all hash subnodes of the component image node */ 2663 for (ndepth = 0, noffset = fdt_next_node (fit, image_noffset, &ndepth); 2664 (noffset >= 0) && (ndepth > 0); 2665 noffset = fdt_next_node (fit, noffset, &ndepth)) { 2666 if (ndepth == 1) { 2667 /* Direct child node of the component image node */ 2668 2669 /* 2670 * Check subnode name, must be equal to "hash". 2671 * Multiple hash nodes require unique unit node 2672 * names, e.g. hash@1, hash@2, etc. 2673 */ 2674 if (strncmp (fit_get_name(fit, noffset, NULL), 2675 FIT_HASH_NODENAME, 2676 strlen(FIT_HASH_NODENAME)) != 0) 2677 continue; 2678 2679 if (fit_image_hash_get_algo (fit, noffset, &algo)) { 2680 err_msg = " error!\nCan't get hash algo " 2681 "property"; 2682 goto error; 2683 } 2684 printf ("%s", algo); 2685 2686 if (fit_image_hash_get_value (fit, noffset, &fit_value, 2687 &fit_value_len)) { 2688 err_msg = " error!\nCan't get hash value " 2689 "property"; 2690 goto error; 2691 } 2692 2693 if (calculate_hash (data, size, algo, value, &value_len)) { 2694 err_msg = " error!\nUnsupported hash algorithm"; 2695 goto error; 2696 } 2697 2698 if (value_len != fit_value_len) { 2699 err_msg = " error !\nBad hash value len"; 2700 goto error; 2701 } else if (memcmp (value, fit_value, value_len) != 0) { 2702 err_msg = " error!\nBad hash value"; 2703 goto error; 2704 } 2705 printf ("+ "); 2706 } 2707 } 2708 2709 return 1; 2710 2711 error: 2712 printf ("%s for '%s' hash node in '%s' image node\n", 2713 err_msg, fit_get_name (fit, noffset, NULL), 2714 fit_get_name (fit, image_noffset, NULL)); 2715 return 0; 2716 } 2717 2718 /** 2719 * fit_all_image_check_hashes - verify data intergity for all images 2720 * @fit: pointer to the FIT format image header 2721 * 2722 * fit_all_image_check_hashes() goes over all images in the FIT and 2723 * for every images checks if all it's hashes are valid. 2724 * 2725 * returns: 2726 * 1, if all hashes of all images are valid 2727 * 0, otherwise (or on error) 2728 */ 2729 int fit_all_image_check_hashes (const void *fit) 2730 { 2731 int images_noffset; 2732 int noffset; 2733 int ndepth; 2734 int count; 2735 2736 /* Find images parent node offset */ 2737 images_noffset = fdt_path_offset (fit, FIT_IMAGES_PATH); 2738 if (images_noffset < 0) { 2739 printf ("Can't find images parent node '%s' (%s)\n", 2740 FIT_IMAGES_PATH, fdt_strerror (images_noffset)); 2741 return 0; 2742 } 2743 2744 /* Process all image subnodes, check hashes for each */ 2745 printf ("## Checking hash(es) for FIT Image at %08lx ...\n", 2746 (ulong)fit); 2747 for (ndepth = 0, count = 0, 2748 noffset = fdt_next_node (fit, images_noffset, &ndepth); 2749 (noffset >= 0) && (ndepth > 0); 2750 noffset = fdt_next_node (fit, noffset, &ndepth)) { 2751 if (ndepth == 1) { 2752 /* 2753 * Direct child node of the images parent node, 2754 * i.e. component image node. 2755 */ 2756 printf (" Hash(es) for Image %u (%s): ", count++, 2757 fit_get_name (fit, noffset, NULL)); 2758 2759 if (!fit_image_check_hashes (fit, noffset)) 2760 return 0; 2761 printf ("\n"); 2762 } 2763 } 2764 return 1; 2765 } 2766 2767 /** 2768 * fit_image_check_os - check whether image node is of a given os type 2769 * @fit: pointer to the FIT format image header 2770 * @noffset: component image node offset 2771 * @os: requested image os 2772 * 2773 * fit_image_check_os() reads image os property and compares its numeric 2774 * id with the requested os. Comparison result is returned to the caller. 2775 * 2776 * returns: 2777 * 1 if image is of given os type 2778 * 0 otherwise (or on error) 2779 */ 2780 int fit_image_check_os (const void *fit, int noffset, uint8_t os) 2781 { 2782 uint8_t image_os; 2783 2784 if (fit_image_get_os (fit, noffset, &image_os)) 2785 return 0; 2786 return (os == image_os); 2787 } 2788 2789 /** 2790 * fit_image_check_arch - check whether image node is of a given arch 2791 * @fit: pointer to the FIT format image header 2792 * @noffset: component image node offset 2793 * @arch: requested imagearch 2794 * 2795 * fit_image_check_arch() reads image arch property and compares its numeric 2796 * id with the requested arch. Comparison result is returned to the caller. 2797 * 2798 * returns: 2799 * 1 if image is of given arch 2800 * 0 otherwise (or on error) 2801 */ 2802 int fit_image_check_arch (const void *fit, int noffset, uint8_t arch) 2803 { 2804 uint8_t image_arch; 2805 2806 if (fit_image_get_arch (fit, noffset, &image_arch)) 2807 return 0; 2808 return (arch == image_arch); 2809 } 2810 2811 /** 2812 * fit_image_check_type - check whether image node is of a given type 2813 * @fit: pointer to the FIT format image header 2814 * @noffset: component image node offset 2815 * @type: requested image type 2816 * 2817 * fit_image_check_type() reads image type property and compares its numeric 2818 * id with the requested type. Comparison result is returned to the caller. 2819 * 2820 * returns: 2821 * 1 if image is of given type 2822 * 0 otherwise (or on error) 2823 */ 2824 int fit_image_check_type (const void *fit, int noffset, uint8_t type) 2825 { 2826 uint8_t image_type; 2827 2828 if (fit_image_get_type (fit, noffset, &image_type)) 2829 return 0; 2830 return (type == image_type); 2831 } 2832 2833 /** 2834 * fit_image_check_comp - check whether image node uses given compression 2835 * @fit: pointer to the FIT format image header 2836 * @noffset: component image node offset 2837 * @comp: requested image compression type 2838 * 2839 * fit_image_check_comp() reads image compression property and compares its 2840 * numeric id with the requested compression type. Comparison result is 2841 * returned to the caller. 2842 * 2843 * returns: 2844 * 1 if image uses requested compression 2845 * 0 otherwise (or on error) 2846 */ 2847 int fit_image_check_comp (const void *fit, int noffset, uint8_t comp) 2848 { 2849 uint8_t image_comp; 2850 2851 if (fit_image_get_comp (fit, noffset, &image_comp)) 2852 return 0; 2853 return (comp == image_comp); 2854 } 2855 2856 /** 2857 * fit_check_format - sanity check FIT image format 2858 * @fit: pointer to the FIT format image header 2859 * 2860 * fit_check_format() runs a basic sanity FIT image verification. 2861 * Routine checks for mandatory properties, nodes, etc. 2862 * 2863 * returns: 2864 * 1, on success 2865 * 0, on failure 2866 */ 2867 int fit_check_format (const void *fit) 2868 { 2869 /* mandatory / node 'description' property */ 2870 if (fdt_getprop (fit, 0, FIT_DESC_PROP, NULL) == NULL) { 2871 debug ("Wrong FIT format: no description\n"); 2872 return 0; 2873 } 2874 2875 #if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC) 2876 /* mandatory / node 'timestamp' property */ 2877 if (fdt_getprop (fit, 0, FIT_TIMESTAMP_PROP, NULL) == NULL) { 2878 debug ("Wrong FIT format: no timestamp\n"); 2879 return 0; 2880 } 2881 #endif 2882 2883 /* mandatory subimages parent '/images' node */ 2884 if (fdt_path_offset (fit, FIT_IMAGES_PATH) < 0) { 2885 debug ("Wrong FIT format: no images parent node\n"); 2886 return 0; 2887 } 2888 2889 return 1; 2890 } 2891 2892 /** 2893 * fit_conf_get_node - get node offset for configuration of a given unit name 2894 * @fit: pointer to the FIT format image header 2895 * @conf_uname: configuration node unit name 2896 * 2897 * fit_conf_get_node() finds a configuration (withing the '/configurations' 2898 * parant node) of a provided unit name. If configuration is found its node offset 2899 * is returned to the caller. 2900 * 2901 * When NULL is provided in second argument fit_conf_get_node() will search 2902 * for a default configuration node instead. Default configuration node unit name 2903 * is retrived from FIT_DEFAULT_PROP property of the '/configurations' node. 2904 * 2905 * returns: 2906 * configuration node offset when found (>=0) 2907 * negative number on failure (FDT_ERR_* code) 2908 */ 2909 int fit_conf_get_node (const void *fit, const char *conf_uname) 2910 { 2911 int noffset, confs_noffset; 2912 int len; 2913 2914 confs_noffset = fdt_path_offset (fit, FIT_CONFS_PATH); 2915 if (confs_noffset < 0) { 2916 debug ("Can't find configurations parent node '%s' (%s)\n", 2917 FIT_CONFS_PATH, fdt_strerror (confs_noffset)); 2918 return confs_noffset; 2919 } 2920 2921 if (conf_uname == NULL) { 2922 /* get configuration unit name from the default property */ 2923 debug ("No configuration specified, trying default...\n"); 2924 conf_uname = (char *)fdt_getprop (fit, confs_noffset, FIT_DEFAULT_PROP, &len); 2925 if (conf_uname == NULL) { 2926 fit_get_debug (fit, confs_noffset, FIT_DEFAULT_PROP, len); 2927 return len; 2928 } 2929 debug ("Found default configuration: '%s'\n", conf_uname); 2930 } 2931 2932 noffset = fdt_subnode_offset (fit, confs_noffset, conf_uname); 2933 if (noffset < 0) { 2934 debug ("Can't get node offset for configuration unit name: '%s' (%s)\n", 2935 conf_uname, fdt_strerror (noffset)); 2936 } 2937 2938 return noffset; 2939 } 2940 2941 static int __fit_conf_get_prop_node (const void *fit, int noffset, 2942 const char *prop_name) 2943 { 2944 char *uname; 2945 int len; 2946 2947 /* get kernel image unit name from configuration kernel property */ 2948 uname = (char *)fdt_getprop (fit, noffset, prop_name, &len); 2949 if (uname == NULL) 2950 return len; 2951 2952 return fit_image_get_node (fit, uname); 2953 } 2954 2955 /** 2956 * fit_conf_get_kernel_node - get kernel image node offset that corresponds to 2957 * a given configuration 2958 * @fit: pointer to the FIT format image header 2959 * @noffset: configuration node offset 2960 * 2961 * fit_conf_get_kernel_node() retrives kernel image node unit name from 2962 * configuration FIT_KERNEL_PROP property and translates it to the node 2963 * offset. 2964 * 2965 * returns: 2966 * image node offset when found (>=0) 2967 * negative number on failure (FDT_ERR_* code) 2968 */ 2969 int fit_conf_get_kernel_node (const void *fit, int noffset) 2970 { 2971 return __fit_conf_get_prop_node (fit, noffset, FIT_KERNEL_PROP); 2972 } 2973 2974 /** 2975 * fit_conf_get_ramdisk_node - get ramdisk image node offset that corresponds to 2976 * a given configuration 2977 * @fit: pointer to the FIT format image header 2978 * @noffset: configuration node offset 2979 * 2980 * fit_conf_get_ramdisk_node() retrives ramdisk image node unit name from 2981 * configuration FIT_KERNEL_PROP property and translates it to the node 2982 * offset. 2983 * 2984 * returns: 2985 * image node offset when found (>=0) 2986 * negative number on failure (FDT_ERR_* code) 2987 */ 2988 int fit_conf_get_ramdisk_node (const void *fit, int noffset) 2989 { 2990 return __fit_conf_get_prop_node (fit, noffset, FIT_RAMDISK_PROP); 2991 } 2992 2993 /** 2994 * fit_conf_get_fdt_node - get fdt image node offset that corresponds to 2995 * a given configuration 2996 * @fit: pointer to the FIT format image header 2997 * @noffset: configuration node offset 2998 * 2999 * fit_conf_get_fdt_node() retrives fdt image node unit name from 3000 * configuration FIT_KERNEL_PROP property and translates it to the node 3001 * offset. 3002 * 3003 * returns: 3004 * image node offset when found (>=0) 3005 * negative number on failure (FDT_ERR_* code) 3006 */ 3007 int fit_conf_get_fdt_node (const void *fit, int noffset) 3008 { 3009 return __fit_conf_get_prop_node (fit, noffset, FIT_FDT_PROP); 3010 } 3011 3012 /** 3013 * fit_conf_print - prints out the FIT configuration details 3014 * @fit: pointer to the FIT format image header 3015 * @noffset: offset of the configuration node 3016 * @p: pointer to prefix string 3017 * 3018 * fit_conf_print() lists all mandatory properies for the processed 3019 * configuration node. 3020 * 3021 * returns: 3022 * no returned results 3023 */ 3024 void fit_conf_print (const void *fit, int noffset, const char *p) 3025 { 3026 char *desc; 3027 char *uname; 3028 int ret; 3029 3030 /* Mandatory properties */ 3031 ret = fit_get_desc (fit, noffset, &desc); 3032 printf ("%s Description: ", p); 3033 if (ret) 3034 printf ("unavailable\n"); 3035 else 3036 printf ("%s\n", desc); 3037 3038 uname = (char *)fdt_getprop (fit, noffset, FIT_KERNEL_PROP, NULL); 3039 printf ("%s Kernel: ", p); 3040 if (uname == NULL) 3041 printf ("unavailable\n"); 3042 else 3043 printf ("%s\n", uname); 3044 3045 /* Optional properties */ 3046 uname = (char *)fdt_getprop (fit, noffset, FIT_RAMDISK_PROP, NULL); 3047 if (uname) 3048 printf ("%s Init Ramdisk: %s\n", p, uname); 3049 3050 uname = (char *)fdt_getprop (fit, noffset, FIT_FDT_PROP, NULL); 3051 if (uname) 3052 printf ("%s FDT: %s\n", p, uname); 3053 } 3054 3055 /** 3056 * fit_check_ramdisk - verify FIT format ramdisk subimage 3057 * @fit_hdr: pointer to the FIT ramdisk header 3058 * @rd_noffset: ramdisk subimage node offset within FIT image 3059 * @arch: requested ramdisk image architecture type 3060 * @verify: data CRC verification flag 3061 * 3062 * fit_check_ramdisk() verifies integrity of the ramdisk subimage and from 3063 * specified FIT image. 3064 * 3065 * returns: 3066 * 1, on success 3067 * 0, on failure 3068 */ 3069 #ifndef USE_HOSTCC 3070 static int fit_check_ramdisk (const void *fit, int rd_noffset, uint8_t arch, int verify) 3071 { 3072 fit_image_print (fit, rd_noffset, " "); 3073 3074 if (verify) { 3075 puts (" Verifying Hash Integrity ... "); 3076 if (!fit_image_check_hashes (fit, rd_noffset)) { 3077 puts ("Bad Data Hash\n"); 3078 show_boot_progress (-125); 3079 return 0; 3080 } 3081 puts ("OK\n"); 3082 } 3083 3084 show_boot_progress (126); 3085 if (!fit_image_check_os (fit, rd_noffset, IH_OS_LINUX) || 3086 !fit_image_check_arch (fit, rd_noffset, arch) || 3087 !fit_image_check_type (fit, rd_noffset, IH_TYPE_RAMDISK)) { 3088 printf ("No Linux %s Ramdisk Image\n", 3089 genimg_get_arch_name(arch)); 3090 show_boot_progress (-126); 3091 return 0; 3092 } 3093 3094 show_boot_progress (127); 3095 return 1; 3096 } 3097 #endif /* USE_HOSTCC */ 3098 #endif /* CONFIG_FIT */ 3099