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