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