#endif
#ifdef CONFIG_CMD_BDI
-extern int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
+extern int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
#endif
DECLARE_GLOBAL_DATA_PTR;
-static image_header_t* image_get_ramdisk (ulong rd_addr, uint8_t arch,
+static const image_header_t* image_get_ramdisk (ulong rd_addr, uint8_t arch,
int verify);
#else
#include "mkimage.h"
#include <image.h>
#endif /* !USE_HOSTCC*/
-typedef struct table_entry {
- int id; /* as defined in image.h */
- char *sname; /* short (input) name */
- char *lname; /* long (output) name */
-} table_entry_t;
-
static table_entry_t uimage_arch[] = {
{ IH_ARCH_INVALID, NULL, "Invalid ARCH", },
{ IH_ARCH_ALPHA, "alpha", "Alpha", },
{ IH_ARCH_MICROBLAZE, "microblaze", "MicroBlaze", },
{ IH_ARCH_MIPS, "mips", "MIPS", },
{ IH_ARCH_MIPS64, "mips64", "MIPS 64 Bit", },
- { IH_ARCH_NIOS, "nios", "NIOS", },
{ IH_ARCH_NIOS2, "nios2", "NIOS II", },
{ IH_ARCH_PPC, "powerpc", "PowerPC", },
{ IH_ARCH_PPC, "ppc", "PowerPC", },
{ IH_OS_LYNXOS, "lynxos", "LynxOS", },
#endif
{ IH_OS_NETBSD, "netbsd", "NetBSD", },
+ { IH_OS_OSE, "ose", "Enea OSE", },
{ IH_OS_RTEMS, "rtems", "RTEMS", },
{ IH_OS_U_BOOT, "u-boot", "U-Boot", },
#if defined(CONFIG_CMD_ELF) || defined(USE_HOSTCC)
{ IH_TYPE_SCRIPT, "script", "Script", },
{ IH_TYPE_STANDALONE, "standalone", "Standalone Program", },
{ IH_TYPE_FLATDT, "flat_dt", "Flat Device Tree", },
+ { IH_TYPE_KWBIMAGE, "kwbimage", "Kirkwood Boot Image",},
+ { IH_TYPE_IMXIMAGE, "imximage", "Freescale i.MX Boot Image",},
{ -1, "", "", },
};
{ IH_COMP_NONE, "none", "uncompressed", },
{ IH_COMP_BZIP2, "bzip2", "bzip2 compressed", },
{ IH_COMP_GZIP, "gzip", "gzip compressed", },
+ { IH_COMP_LZMA, "lzma", "lzma compressed", },
+ { IH_COMP_LZO, "lzo", "lzo compressed", },
{ -1, "", "", },
};
uint32_t crc32 (uint32_t, const unsigned char *, uint);
uint32_t crc32_wd (uint32_t, const unsigned char *, uint, uint);
-static void genimg_print_size (uint32_t size);
#if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
static void genimg_print_time (time_t timestamp);
#endif
/*****************************************************************************/
/* Legacy format routines */
/*****************************************************************************/
-int image_check_hcrc (image_header_t *hdr)
+int image_check_hcrc (const image_header_t *hdr)
{
ulong hcrc;
ulong len = image_get_header_size ();
return (hcrc == image_get_hcrc (hdr));
}
-int image_check_dcrc (image_header_t *hdr)
+int image_check_dcrc (const image_header_t *hdr)
{
ulong data = image_get_data (hdr);
ulong len = image_get_data_size (hdr);
* returns:
* number of components
*/
-ulong image_multi_count (image_header_t *hdr)
+ulong image_multi_count (const image_header_t *hdr)
{
ulong i, count = 0;
uint32_t *size;
* data address and size of the component, if idx is valid
* 0 in data and len, if idx is out of range
*/
-void image_multi_getimg (image_header_t *hdr, ulong idx,
+void image_multi_getimg (const image_header_t *hdr, ulong idx,
ulong *data, ulong *len)
{
int i;
}
}
-static void image_print_type (image_header_t *hdr)
+static void image_print_type (const image_header_t *hdr)
{
const char *os, *arch, *type, *comp;
/**
* image_print_contents - prints out the contents of the legacy format image
- * @hdr: pointer to the legacy format image header
+ * @ptr: pointer to the legacy format image header
* @p: pointer to prefix string
*
* image_print_contents() formats a multi line legacy image contents description.
* returns:
* no returned results
*/
-void image_print_contents (image_header_t *hdr)
+void image_print_contents (const void *ptr)
{
+ const image_header_t *hdr = (const image_header_t *)ptr;
const char *p;
#ifdef USE_HOSTCC
* pointer to a ramdisk image header, if image was found and valid
* otherwise, return NULL
*/
-static image_header_t* image_get_ramdisk (ulong rd_addr, uint8_t arch,
+static const image_header_t *image_get_ramdisk (ulong rd_addr, uint8_t arch,
int verify)
{
- image_header_t *rd_hdr = (image_header_t *)rd_addr;
+ const image_header_t *rd_hdr = (const image_header_t *)rd_addr;
if (!image_check_magic (rd_hdr)) {
puts ("Bad Magic Number\n");
return tmp;
}
-#if defined(CFG_SDRAM_BASE)
- return CFG_SDRAM_BASE;
+#if defined(CONFIG_SYS_SDRAM_BASE)
+ return CONFIG_SYS_SDRAM_BASE;
#elif defined(CONFIG_ARM)
return gd->bd->bi_dram[0].start;
#else
phys_size_t getenv_bootm_size(void)
{
+ phys_size_t tmp;
char *s = getenv ("bootm_size");
if (s) {
- phys_size_t tmp;
-#ifdef CFG_64BIT_STRTOUL
tmp = (phys_size_t)simple_strtoull (s, NULL, 16);
-#else
- tmp = (phys_size_t)simple_strtoul (s, NULL, 16);
-#endif
return tmp;
}
+ s = getenv("bootm_low");
+ if (s)
+ tmp = (phys_size_t)simple_strtoull (s, NULL, 16);
+ else
+ tmp = 0;
+
#if defined(CONFIG_ARM)
- return gd->bd->bi_dram[0].size;
+ return gd->bd->bi_dram[0].size - tmp;
#else
- return gd->bd->bi_memsize;
+ return gd->bd->bi_memsize - tmp;
#endif
}
void memmove_wd (void *to, void *from, size_t len, ulong chunksz)
{
+ if (to == from)
+ return;
+
#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
while (len > 0) {
size_t tail = (len > chunksz) ? chunksz : len;
}
#endif /* !USE_HOSTCC */
-static void genimg_print_size (uint32_t size)
+void genimg_print_size (uint32_t size)
{
#ifndef USE_HOSTCC
printf ("%d Bytes = ", size);
* long entry name if translation succeeds
* msg otherwise
*/
-static char *get_table_entry_name (table_entry_t *table, char *msg, int id)
+char *get_table_entry_name (table_entry_t *table, char *msg, int id)
{
for (; table->id >= 0; ++table) {
if (table->id == id)
- return (table->lname);
+#if defined(USE_HOSTCC) || defined(CONFIG_RELOC_FIXUP_WORKS)
+ return table->lname;
+#else
+ return table->lname + gd->reloc_off;
+#endif
}
return (msg);
}
* entry id if translation succeeds
* -1 otherwise
*/
-static int get_table_entry_id (table_entry_t *table,
+int get_table_entry_id (table_entry_t *table,
const char *table_name, const char *name)
{
table_entry_t *t;
fprintf (stderr, "\n");
#else
for (t = table; t->id >= 0; ++t) {
+#ifdef CONFIG_RELOC_FIXUP_WORKS
if (t->sname && strcmp(t->sname, name) == 0)
+#else
+ if (t->sname && strcmp(t->sname + gd->reloc_off, name) == 0)
+#endif
return (t->id);
}
debug ("Invalid %s Type: %s\n", table_name, name);
*/
int genimg_get_format (void *img_addr)
{
- ulong format = IMAGE_FORMAT_INVALID;
- image_header_t *hdr;
+ ulong format = IMAGE_FORMAT_INVALID;
+ const image_header_t *hdr;
#if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT)
- char *fit_hdr;
+ char *fit_hdr;
#endif
- hdr = (image_header_t *)img_addr;
+ hdr = (const image_header_t *)img_addr;
if (image_check_magic(hdr))
format = IMAGE_FORMAT_LEGACY;
#if defined(CONFIG_FIT) || defined(CONFIG_OF_LIBFDT)
if (addr_dataflash (img_addr)){
/* ger RAM address */
- ram_addr = CFG_LOAD_ADDR;
+ ram_addr = CONFIG_SYS_LOAD_ADDR;
/* get header size */
h_size = image_get_header_size ();
/* get data size */
switch (genimg_get_format ((void *)ram_addr)) {
case IMAGE_FORMAT_LEGACY:
- d_size = image_get_data_size ((image_header_t *)ram_addr);
+ d_size = image_get_data_size ((const image_header_t *)ram_addr);
debug (" Legacy format image found at 0x%08lx, size 0x%08lx\n",
ram_addr, d_size);
break;
* 1, if ramdisk image is found but corrupted, or invalid
* rd_start and rd_end are set to 0 if no ramdisk exists
*/
-int boot_get_ramdisk (int argc, char *argv[], bootm_headers_t *images,
+int boot_get_ramdisk (int argc, char * const argv[], bootm_headers_t *images,
uint8_t arch, ulong *rd_start, ulong *rd_end)
{
ulong rd_addr, rd_load;
ulong rd_data, rd_len;
- image_header_t *rd_hdr;
+ const image_header_t *rd_hdr;
#if defined(CONFIG_FIT)
void *fit_hdr;
const char *fit_uname_config = NULL;
error:
return -1;
}
+#endif /* defined(CONFIG_PPC) || defined(CONFIG_M68K) || defined(CONFIG_SPARC) */
#ifdef CONFIG_OF_LIBFDT
static void fdt_error (const char *msg)
puts (" - must RESET the board to recover.\n");
}
-static image_header_t *image_get_fdt (ulong fdt_addr)
+static const image_header_t *image_get_fdt (ulong fdt_addr)
{
- image_header_t *fdt_hdr = (image_header_t *)fdt_addr;
+ const image_header_t *fdt_hdr = (const image_header_t *)fdt_addr;
image_print_contents (fdt_hdr);
}
#endif /* CONFIG_FIT */
-#ifndef CFG_FDT_PAD
-#define CFG_FDT_PAD 0x3000
+#ifndef CONFIG_SYS_FDT_PAD
+#define CONFIG_SYS_FDT_PAD 0x3000
#endif
/**
* 0 - success
* 1 - failure
*/
+#if defined(CONFIG_SYS_BOOTMAPSZ)
int boot_relocate_fdt (struct lmb *lmb, ulong bootmap_base,
char **of_flat_tree, ulong *of_size)
{
goto error;
}
-#ifndef CFG_NO_FLASH
+#ifndef CONFIG_SYS_NO_FLASH
/* move the blob if it is in flash (set relocate) */
if (addr2info ((ulong)fdt_blob) != NULL)
relocate = 1;
if (fdt_blob < (char *)bootmap_base)
relocate = 1;
- if ((fdt_blob + *of_size + CFG_FDT_PAD) >=
- ((char *)CFG_BOOTMAPSZ + bootmap_base))
+ if ((fdt_blob + *of_size + CONFIG_SYS_FDT_PAD) >=
+ ((char *)CONFIG_SYS_BOOTMAPSZ + bootmap_base))
relocate = 1;
/* move flattend device tree if needed */
/* position on a 4K boundary before the alloc_current */
/* Pad the FDT by a specified amount */
- of_len = *of_size + CFG_FDT_PAD;
+ of_len = *of_size + CONFIG_SYS_FDT_PAD;
of_start = (unsigned long)lmb_alloc_base(lmb, of_len, 0x1000,
- (CFG_BOOTMAPSZ + bootmap_base));
+ (CONFIG_SYS_BOOTMAPSZ + bootmap_base));
if (of_start == 0) {
puts("device tree - allocation error\n");
*of_size = of_len;
} else {
*of_flat_tree = fdt_blob;
- of_len = (CFG_BOOTMAPSZ + bootmap_base) - (ulong)fdt_blob;
+ of_len = (CONFIG_SYS_BOOTMAPSZ + bootmap_base) - (ulong)fdt_blob;
lmb_reserve(lmb, (ulong)fdt_blob, of_len);
fdt_set_totalsize(*of_flat_tree, of_len);
error:
return 1;
}
+#endif /* CONFIG_SYS_BOOTMAPSZ */
/**
* boot_get_fdt - main fdt handling routine
* 1, if fdt image is found but corrupted
* of_flat_tree and of_size are set to 0 if no fdt exists
*/
-int boot_get_fdt (int flag, int argc, char *argv[], bootm_headers_t *images,
+int boot_get_fdt (int flag, int argc, char * const argv[], bootm_headers_t *images,
char **of_flat_tree, ulong *of_size)
{
+ const image_header_t *fdt_hdr;
ulong fdt_addr;
- image_header_t *fdt_hdr;
char *fdt_blob = NULL;
ulong image_start, image_end;
ulong load_start, load_end;
*of_flat_tree = fdt_blob;
*of_size = be32_to_cpu (fdt_totalsize (fdt_blob));
debug (" of_flat_tree at 0x%08lx size 0x%08lx\n",
- *of_flat_tree, *of_size);
+ (ulong)*of_flat_tree, *of_size);
return 0;
}
#endif /* CONFIG_OF_LIBFDT */
+#if defined(CONFIG_PPC) || defined(CONFIG_M68K)
/**
* boot_get_cmdline - allocate and initialize kernel cmdline
* @lmb: pointer to lmb handle, will be used for memory mgmt
char *cmdline;
char *s;
- cmdline = (char *)(ulong)lmb_alloc_base(lmb, CFG_BARGSIZE, 0xf,
- CFG_BOOTMAPSZ + bootmap_base);
+ cmdline = (char *)(ulong)lmb_alloc_base(lmb, CONFIG_SYS_BARGSIZE, 0xf,
+ CONFIG_SYS_BOOTMAPSZ + bootmap_base);
if (cmdline == NULL)
return -1;
int boot_get_kbd (struct lmb *lmb, bd_t **kbd, ulong bootmap_base)
{
*kbd = (bd_t *)(ulong)lmb_alloc_base(lmb, sizeof(bd_t), 0xf,
- CFG_BOOTMAPSZ + bootmap_base);
+ CONFIG_SYS_BOOTMAPSZ + bootmap_base);
if (*kbd == NULL)
return -1;
* @p: pointer to prefix string
*
* fit_image_print() lists all mandatory properies for the processed component
- * image. If present, hash nodes are printed out as well.
+ * image. If present, hash nodes are printed out as well. Load
+ * address for images of type firmware is also printed out. Since the load
+ * address is not mandatory for firmware images, it will be output as
+ * "unavailable" when not present.
*
* returns:
* no returned results
printf ("%s OS: %s\n", p, genimg_get_os_name (os));
}
- if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE)) {
+ if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE) ||
+ (type == IH_TYPE_FIRMWARE)) {
ret = fit_image_get_load (fit, image_noffset, &load);
printf ("%s Load Address: ", p);
if (ret)
printf ("unavailable\n");
else
printf ("0x%08lx\n", load);
+ }
+ if ((type == IH_TYPE_KERNEL) || (type == IH_TYPE_STANDALONE)) {
fit_image_get_entry (fit, image_noffset, &entry);
printf ("%s Entry Point: ", p);
if (ret)
continue;
if (fit_image_hash_get_algo (fit, noffset, &algo)) {
- err_msg = "Can't get hash algo property";
+ err_msg = " error!\nCan't get hash algo "
+ "property";
goto error;
}
printf ("%s", algo);
if (fit_image_hash_get_value (fit, noffset, &fit_value,
&fit_value_len)) {
- err_msg = "Can't get hash value property";
+ err_msg = " error!\nCan't get hash value "
+ "property";
goto error;
}
if (calculate_hash (data, size, algo, value, &value_len)) {
- err_msg = "Unsupported hash algorithm";
+ err_msg = " error!\nUnsupported hash algorithm";
goto error;
}
if (value_len != fit_value_len) {
- err_msg = "Bad hash value len";
+ err_msg = " error !\nBad hash value len";
goto error;
} else if (memcmp (value, fit_value, value_len) != 0) {
- err_msg = "Bad hash value";
+ err_msg = " error!\nBad hash value";
goto error;
}
printf ("+ ");
return 0;
}
+/**
+ * fit_all_image_check_hashes - verify data intergity for all images
+ * @fit: pointer to the FIT format image header
+ *
+ * fit_all_image_check_hashes() goes over all images in the FIT and
+ * for every images checks if all it's hashes are valid.
+ *
+ * returns:
+ * 1, if all hashes of all images are valid
+ * 0, otherwise (or on error)
+ */
+int fit_all_image_check_hashes (const void *fit)
+{
+ int images_noffset;
+ int noffset;
+ int ndepth;
+ int count;
+
+ /* Find images parent node offset */
+ images_noffset = fdt_path_offset (fit, FIT_IMAGES_PATH);
+ if (images_noffset < 0) {
+ printf ("Can't find images parent node '%s' (%s)\n",
+ FIT_IMAGES_PATH, fdt_strerror (images_noffset));
+ return 0;
+ }
+
+ /* Process all image subnodes, check hashes for each */
+ printf ("## Checking hash(es) for FIT Image at %08lx ...\n",
+ (ulong)fit);
+ for (ndepth = 0, count = 0,
+ noffset = fdt_next_node (fit, images_noffset, &ndepth);
+ (noffset >= 0) && (ndepth > 0);
+ noffset = fdt_next_node (fit, noffset, &ndepth)) {
+ if (ndepth == 1) {
+ /*
+ * Direct child node of the images parent node,
+ * i.e. component image node.
+ */
+ printf (" Hash(es) for Image %u (%s): ", count++,
+ fit_get_name (fit, noffset, NULL));
+
+ if (!fit_image_check_hashes (fit, noffset))
+ return 0;
+ printf ("\n");
+ }
+ }
+ return 1;
+}
+
/**
* fit_image_check_os - check whether image node is of a given os type
* @fit: pointer to the FIT format image header
#if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE) || defined(USE_HOSTCC)
/* mandatory / node 'timestamp' property */
if (fdt_getprop (fit, 0, FIT_TIMESTAMP_PROP, NULL) == NULL) {
- debug ("Wrong FIT format: no description\n");
+ debug ("Wrong FIT format: no timestamp\n");
return 0;
}
#endif
projects / karo-tx-uboot.git / blobdiff