@rm -f $(OBJS) $(obj)*.bak $(obj)ctags $(obj)etags $(obj)TAGS
@rm -fr $(obj)*.*~
@rm -f $(obj)u-boot $(obj)u-boot.map $(obj)u-boot.hex $(ALL)
- @rm -f $(obj)tools/crc32.c $(obj)tools/environment.c $(obj)tools/env/crc32.c $(obj)tools/sha1.c
+ @rm -f $(obj)tools/crc32.c $(obj)tools/environment.c $(obj)tools/env/crc32.c
+ @rm -f $(obj)tools/sha1.c $(obj)tools/image.c
@rm -f $(obj)tools/inca-swap-bytes $(obj)cpu/mpc824x/bedbug_603e.c
@rm -f $(obj)include/asm/proc $(obj)include/asm/arch $(obj)include/asm
@[ ! -d $(obj)nand_spl ] || find $(obj)nand_spl -lname "*" -print | xargs rm -f
struct rtc_time tm;
char bootcmd[32];
- hdr = (image_header_t *) (CFG_MONITOR_BASE - sizeof (image_header_t));
- timestamp = (time_t) hdr->ih_time;
+ hdr = (image_header_t *) (CFG_MONITOR_BASE - image_get_header_size ());
+ timestamp = (time_t)image_get_time (hdr);
to_tm (timestamp, &tm);
printf ("Welcome to U-Boot on Cray L1. Compiled %4d-%02d-%02d %2d:%02d:%02d (UTC)\n", tm.tm_year, tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
int au_check_cksum_valid(int i, long nbytes)
{
image_header_t *hdr;
- unsigned long checksum;
hdr = (image_header_t *)LOAD_ADDR;
- if ((au_image[i].type == AU_FIRMWARE) && (au_image[i].size != ntohl(hdr->ih_size))) {
+ if ((au_image[i].type == AU_FIRMWARE) &&
+ (au_image[i].size != image_get_data_size (hdr))) {
printf ("Image %s has wrong size\n", au_image[i].name);
return -1;
}
- if (nbytes != (sizeof(*hdr) + ntohl(hdr->ih_size))) {
+ if (nbytes != (image_get_image_size (hdr))) {
printf ("Image %s bad total SIZE\n", au_image[i].name);
return -1;
}
- /* check the data CRC */
- checksum = ntohl(hdr->ih_dcrc);
- if (crc32 (0, (uchar *)(LOAD_ADDR + sizeof(*hdr)), ntohl(hdr->ih_size))
- != checksum) {
+ /* check the data CRC */
+ if (!image_check_dcrc (hdr)) {
printf ("Image %s bad data checksum\n", au_image[i].name);
return -1;
}
/* check the easy ones first */
#undef CHECK_VALID_DEBUG
#ifdef CHECK_VALID_DEBUG
- printf("magic %#x %#x ", ntohl(hdr->ih_magic), IH_MAGIC);
- printf("arch %#x %#x ", hdr->ih_arch, IH_CPU_PPC);
- printf("size %#x %#lx ", ntohl(hdr->ih_size), nbytes);
- printf("type %#x %#x ", hdr->ih_type, IH_TYPE_KERNEL);
+ printf("magic %#x %#x ", image_get_magic (hdr), IH_MAGIC);
+ printf("arch %#x %#x ", image_get_arch (hdr), IH_ARCH_PPC);
+ printf("size %#x %#lx ", image_get_data_size (hdr), nbytes);
+ printf("type %#x %#x ", image_get_type (hdr), IH_TYPE_KERNEL);
#endif
- if (nbytes < sizeof(*hdr))
+ if (nbytes < image_get_header_size ())
{
printf ("Image %s bad header SIZE\n", au_image[i].name);
return -1;
}
- if (ntohl(hdr->ih_magic) != IH_MAGIC || hdr->ih_arch != IH_CPU_PPC)
+ if (!image_check_magic (hdr) || !image_check_arch (hdr, IH_ARCH_PPC))
{
printf ("Image %s bad MAGIC or ARCH\n", au_image[i].name);
return -1;
}
- /* check the hdr CRC */
- checksum = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32 (0, (uchar *)hdr, sizeof(*hdr)) != checksum) {
+ if (!image_check_hcrc (hdr)) {
printf ("Image %s bad header checksum\n", au_image[i].name);
return -1;
}
- hdr->ih_hcrc = htonl(checksum);
/* check the type - could do this all in one gigantic if() */
- if ((au_image[i].type == AU_FIRMWARE) && (hdr->ih_type != IH_TYPE_FIRMWARE)) {
+ if ((au_image[i].type == AU_FIRMWARE) && !image_check_type (hdr, IH_TYPE_FIRMWARE)) {
printf ("Image %s wrong type\n", au_image[i].name);
return -1;
}
- if ((au_image[i].type == AU_SCRIPT) && (hdr->ih_type != IH_TYPE_SCRIPT)) {
+ if ((au_image[i].type == AU_SCRIPT) && !image_check_type (hdr, IH_TYPE_SCRIPT)) {
printf ("Image %s wrong type\n", au_image[i].name);
return -1;
}
/* recycle checksum */
- checksum = ntohl(hdr->ih_size);
+ checksum = image_get_data_size (hdr);
#if 0 /* test-only */
/* for kernel and app the image header must also fit into flash */
if (idx != IDX_DISK)
- checksum += sizeof(*hdr);
+ checksum += image_get_header_size ();
/* check the size does not exceed space in flash. HUSH scripts */
/* all have ausize[] set to 0 */
if ((ausize[idx] != 0) && (ausize[idx] < checksum)) {
printf("Executing script %s\n", au_image[i].name);
/* execute a script */
- if (hdr->ih_type == IH_TYPE_SCRIPT) {
- addr = (char *)((char *)hdr + sizeof(*hdr));
+ if (image_check_type (hdr, IH_TYPE_SCRIPT)) {
+ addr = (char *)((char *)hdr + image_get_header_size ());
/* stick a NULL at the end of the script, otherwise */
/* parse_string_outer() runs off the end. */
- addr[ntohl(hdr->ih_size)] = 0;
+ addr[image_get_data_size (hdr)] = 0;
addr += 8;
/*
*/
if (au_image[i].type == AU_FIRMWARE) {
char *orig = (char*)start;
- char *new = (char *)((char *)hdr + sizeof(*hdr));
- nbytes = ntohl(hdr->ih_size);
+ char *new = (char *)((char *)hdr + image_get_header_size ());
+ nbytes = image_get_data_size (hdr);
while(--nbytes) {
if (*orig++ != *new++) {
/* strip the header - except for the kernel and ramdisk */
if (au_image[i].type != AU_FIRMWARE) {
addr = (char *)hdr;
- off = sizeof(*hdr);
- nbytes = sizeof(*hdr) + ntohl(hdr->ih_size);
+ off = image_get_header_size ();
+ nbytes = image_get_image_size (hdr);
} else {
- addr = (char *)((char *)hdr + sizeof(*hdr));
+ addr = (char *)((char *)hdr + image_get_header_size ());
off = 0;
- nbytes = ntohl(hdr->ih_size);
+ nbytes = image_get_data_size (hdr);
}
/*
* check the dcrc of the copy
*/
if (au_image[i].type != AU_NAND) {
- rc = crc32 (0, (uchar *)(start + off), ntohl(hdr->ih_size));
+ rc = crc32 (0, (uchar *)(start + off), image_get_data_size (hdr));
} else {
#if defined(CONFIG_CMD_NAND) && defined(CFG_NAND_LEGACY)
rc = nand_legacy_rw(nand_dev_desc, NANDRW_READ | NANDRW_JFFS2 | NANDRW_JFFS2_SKIP,
start, nbytes, (size_t *)&total, (uchar *)addr);
- rc = crc32 (0, (uchar *)(addr + off), ntohl(hdr->ih_size));
+ rc = crc32 (0, (uchar *)(addr + off), image_get_data_size (hdr));
#endif
}
- if (rc != ntohl(hdr->ih_dcrc)) {
+ if (rc != image_get_dcrc (hdr)) {
printf ("Image %s Bad Data Checksum After COPY\n", au_image[i].name);
return -1;
}
printf("Reading %s ...", au_image[i].name);
/* just read the header */
- sz = do_fat_read(au_image[i].name, LOAD_ADDR, sizeof(image_header_t), LS_NO);
+ sz = do_fat_read(au_image[i].name, LOAD_ADDR, image_get_header_size (), LS_NO);
debug ("read %s sz %ld hdr %d\n",
- au_image[i].name, sz, sizeof(image_header_t));
- if (sz <= 0 || sz < sizeof(image_header_t)) {
+ au_image[i].name, sz, image_get_header_size ());
+ if (sz <= 0 || sz < image_get_header_size ()) {
puts(" not found\n");
continue;
}
}
sz = do_fat_read(au_image[i].name, LOAD_ADDR, MAX_LOADSZ, LS_NO);
debug ("read %s sz %ld hdr %d\n",
- au_image[i].name, sz, sizeof(image_header_t));
- if (sz <= 0 || sz <= sizeof(image_header_t)) {
+ au_image[i].name, sz, image_get_header_size ());
+ if (sz <= 0 || sz <= image_get_header_size ()) {
puts(" not found\n");
continue;
}
int au_check_cksum_valid(int idx, long nbytes)
{
image_header_t *hdr;
- unsigned long checksum;
hdr = (image_header_t *)LOAD_ADDR;
- if (nbytes != (sizeof(*hdr) + ntohl(hdr->ih_size))) {
+ if (nbytes != image_get_image_size (hdr)) {
printf ("Image %s bad total SIZE\n", aufile[idx]);
return -1;
}
/* check the data CRC */
- checksum = ntohl(hdr->ih_dcrc);
-
- if (crc32 (0, (uchar *)(LOAD_ADDR + sizeof(*hdr)), ntohl(hdr->ih_size)) != checksum) {
+ if (!image_check_dcrc (hdr)) {
printf ("Image %s bad data checksum\n", aufile[idx]);
return -1;
}
/* check the easy ones first */
#undef CHECK_VALID_DEBUG
#ifdef CHECK_VALID_DEBUG
- printf("magic %#x %#x ", ntohl(hdr->ih_magic), IH_MAGIC);
- printf("arch %#x %#x ", hdr->ih_arch, IH_CPU_ARM);
- printf("size %#x %#lx ", ntohl(hdr->ih_size), nbytes);
- printf("type %#x %#x ", hdr->ih_type, IH_TYPE_KERNEL);
+ printf("magic %#x %#x ", image_get_magic (hdr), IH_MAGIC);
+ printf("arch %#x %#x ", image_get_arch (hdr), IH_ARCH_ARM);
+ printf("size %#x %#lx ", image_get_data_size (hdr), nbytes);
+ printf("type %#x %#x ", image_get_type (hdr), IH_TYPE_KERNEL);
#endif
- if (nbytes < sizeof(*hdr)) {
+ if (nbytes < image_get_header_size ()) {
printf ("Image %s bad header SIZE\n", aufile[idx]);
ausize[idx] = 0;
return -1;
}
- if (ntohl(hdr->ih_magic) != IH_MAGIC || hdr->ih_arch != IH_CPU_PPC) {
+ if (!image_check_magic (hdr) || !image_check_arch (hdr, IH_ARCH_PPC)) {
printf ("Image %s bad MAGIC or ARCH\n", aufile[idx]);
ausize[idx] = 0;
return -1;
}
/* check the hdr CRC */
- checksum = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32 (0, (uchar *)hdr, sizeof(*hdr)) != checksum) {
+ if (!image_check_hcrc (hdr)) {
printf ("Image %s bad header checksum\n", aufile[idx]);
ausize[idx] = 0;
return -1;
}
- hdr->ih_hcrc = htonl(checksum);
/* check the type - could do this all in one gigantic if() */
- if ((idx == IDX_FIRMWARE) && (hdr->ih_type != IH_TYPE_FIRMWARE)) {
+ if ((idx == IDX_FIRMWARE) && !image_check_type (hdr, IH_TYPE_FIRMWARE)) {
printf ("Image %s wrong type\n", aufile[idx]);
ausize[idx] = 0;
return -1;
}
- if ((idx == IDX_KERNEL) && (hdr->ih_type != IH_TYPE_KERNEL)) {
+ if ((idx == IDX_KERNEL) && !image_check_type (hdr, IH_TYPE_KERNEL)) {
printf ("Image %s wrong type\n", aufile[idx]);
ausize[idx] = 0;
return -1;
}
if ((idx == IDX_ROOTFS) &&
- ( (hdr->ih_type != IH_TYPE_RAMDISK) && (hdr->ih_type != IH_TYPE_FILESYSTEM) )
- ) {
+ (!image_check_type (hdr, IH_TYPE_RAMDISK) &&
+ !image_check_type (hdr, IH_TYPE_FILESYSTEM))) {
printf ("Image %s wrong type\n", aufile[idx]);
ausize[idx] = 0;
return -1;
}
/* recycle checksum */
- checksum = ntohl(hdr->ih_size);
+ checksum = image_get_data_size (hdr);
- fsize = checksum + sizeof(*hdr);
+ fsize = checksum + image_get_header_size ();
/* for kernel and ramdisk the image header must also fit into flash */
- if (idx == IDX_KERNEL || hdr->ih_type == IH_TYPE_RAMDISK)
- checksum += sizeof(*hdr);
+ if (idx == IDX_KERNEL || image_check_type (hdr, IH_TYPE_RAMDISK))
+ checksum += image_get_header_size ();
/* check the size does not exceed space in flash. HUSH scripts */
if ((ausize[idx] != 0) && (ausize[idx] < checksum)) {
hdr = (image_header_t *)LOAD_ADDR;
/* execute a script */
- if (hdr->ih_type == IH_TYPE_SCRIPT) {
- addr = (char *)((char *)hdr + sizeof(*hdr));
+ if (image_check_type (hdr, IH_TYPE_SCRIPT)) {
+ addr = (char *)((char *)hdr + image_get_header_size ());
/* stick a NULL at the end of the script, otherwise */
/* parse_string_outer() runs off the end. */
- addr[ntohl(hdr->ih_size)] = 0;
+ addr[image_get_data_size (hdr)] = 0;
addr += 8;
parse_string_outer(addr, FLAG_PARSE_SEMICOLON);
return 0;
#endif
/* strip the header - except for the kernel and ramdisk */
- if (hdr->ih_type == IH_TYPE_KERNEL || hdr->ih_type == IH_TYPE_RAMDISK) {
+ if (image_check_type (hdr, IH_TYPE_KERNEL) ||
+ image_check_type (hdr, IH_TYPE_RAMDISK)) {
addr = (char *)hdr;
- off = sizeof(*hdr);
- nbytes = sizeof(*hdr) + ntohl(hdr->ih_size);
+ off = image_get_header_size ();
+ nbytes = image_get_image_size (hdr);
} else {
- addr = (char *)((char *)hdr + sizeof(*hdr));
+ addr = (char *)((char *)hdr + image_get_header_size ());
#ifdef AU_UPDATE_TEST
/* copy it to where Linux goes */
if (idx == IDX_FIRMWARE)
start = aufl_layout[1].start;
#endif
off = 0;
- nbytes = ntohl(hdr->ih_size);
+ nbytes = image_get_data_size (hdr);
}
/* copy the data from RAM to FLASH */
#endif
/* check the data CRC of the copy */
- if (crc32 (0, (uchar *)(start + off), ntohl(hdr->ih_size)) != ntohl(hdr->ih_dcrc)) {
+ if (crc32 (0, (uchar *)(start + off), image_get_data_size (hdr)) !=
+ image_get_dcrc (hdr)) {
printf ("Image %s Bad Data Checksum after COPY\n", aufile[idx]);
return -1;
}
for (i = 0; i < AU_MAXFILES; i++) {
ulong imsize;
/* just read the header */
- sz = file_fat_read(aufile[i], LOAD_ADDR, sizeof(image_header_t));
+ sz = file_fat_read(aufile[i], LOAD_ADDR, image_get_header_size ());
debug ("read %s sz %ld hdr %d\n",
- aufile[i], sz, sizeof(image_header_t));
- if (sz <= 0 || sz < sizeof(image_header_t)) {
+ aufile[i], sz, image_get_header_size ());
+ if (sz <= 0 || sz < image_get_header_size ()) {
debug ("%s not found\n", aufile[i]);
ausize[i] = 0;
continue;
sz = file_fat_read(aufile[i], LOAD_ADDR, ausize[i]);
debug ("read %s sz %ld hdr %d\n",
- aufile[i], sz, sizeof(image_header_t));
+ aufile[i], sz, image_get_header_size ());
if (sz != ausize[i]) {
printf ("%s: size %d read %d?\n", aufile[i], ausize[i], sz);
continue;
}
- if (sz <= 0 || sz <= sizeof(image_header_t)) {
+ if (sz <= 0 || sz <= image_get_header_size ()) {
debug ("%s not found\n", aufile[i]);
continue;
}
extern flash_info_t flash_info[]; /* info for FLASH chips */
-static image_header_t header;
-
-
static int
mpl_prg(uchar *src, ulong size)
{
info = &flash_info[0];
#if defined(CONFIG_PIP405) || defined(CONFIG_MIP405) || defined(CONFIG_PATI)
- if (ntohl(magic[0]) != IH_MAGIC) {
+ if (image_to_cpu (magic[0]) != IH_MAGIC) {
puts("Bad Magic number\n");
return -1;
}
static int
mpl_prg_image(uchar *ld_addr)
{
- unsigned long len, checksum;
+ unsigned long len;
uchar *data;
- image_header_t *hdr = &header;
+ image_header_t *hdr = (image_header_t *)ld_addr;
int rc;
- /* Copy header so we can blank CRC field for re-calculation */
- memcpy (&header, (char *)ld_addr, sizeof(image_header_t));
- if (ntohl(hdr->ih_magic) != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
puts("Bad Magic Number\n");
return 1;
}
print_image_hdr(hdr);
- if (hdr->ih_os != IH_OS_U_BOOT) {
+ if (!image_check_os (hdr, IH_OS_U_BOOT)) {
puts("No U-Boot Image\n");
return 1;
}
- if (hdr->ih_type != IH_TYPE_FIRMWARE) {
+ if (!image_check_type (hdr, IH_TYPE_FIRMWARE)) {
puts("No Firmware Image\n");
return 1;
}
- data = (uchar *)&header;
- len = sizeof(image_header_t);
- checksum = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
- if (crc32 (0, (uchar *)data, len) != checksum) {
+ if (!image_check_hcrc (hdr)) {
puts("Bad Header Checksum\n");
return 1;
}
- data = ld_addr + sizeof(image_header_t);
- len = ntohl(hdr->ih_size);
puts("Verifying Checksum ... ");
- if (crc32 (0, (uchar *)data, len) != ntohl(hdr->ih_dcrc)) {
+ if (!image_check_dcrc (hdr)) {
puts("Bad Data CRC\n");
return 1;
}
puts("OK\n");
- if (hdr->ih_comp != IH_COMP_NONE) {
+ data = (uchar *)image_get_data (hdr);
+ len = image_get_data_size (hdr);
+
+ if (image_get_comp (hdr) != IH_COMP_NONE) {
uchar *buf;
/* reserve space for uncompressed image */
if ((buf = malloc(IMAGE_SIZE)) == NULL) {
return 1;
}
- switch (hdr->ih_comp) {
+ switch (image_get_comp (hdr)) {
case IH_COMP_GZIP:
puts("Uncompressing (GZIP) ... ");
rc = gunzip ((void *)(buf), IMAGE_SIZE, data, &len);
break;
#endif
default:
- printf ("Unimplemented compression type %d\n", hdr->ih_comp);
+ printf ("Unimplemented compression type %d\n",
+ image_get_comp (hdr));
free(buf);
return 1;
}
static int fpga_load (fpga_t* fpga, ulong addr, int checkall)
{
volatile uchar *fpga_addr = (volatile uchar *)fpga->conf_base;
- image_header_t hdr;
- ulong len, checksum;
- uchar *data = (uchar *)&hdr;
- char *s, msg[32];
+ image_header_t *hdr = (image_header_t *)addr;
+ ulong len;
+ uchar *data;
+ char msg[32];
int verify, i;
/*
* Check the image header and data of the net-list
*/
- memcpy (&hdr, (char *)addr, sizeof(image_header_t));
-
- if (hdr.ih_magic != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
strcpy (msg, "Bad Image Magic Number");
goto failure;
}
- len = sizeof(image_header_t);
-
- checksum = hdr.ih_hcrc;
- hdr.ih_hcrc = 0;
-
- if (crc32 (0, data, len) != checksum) {
+ if (!image_check_hcrc (hdr)) {
strcpy (msg, "Bad Image Header CRC");
goto failure;
}
- data = (uchar*)(addr + sizeof(image_header_t));
- len = hdr.ih_size;
+ data = (uchar*)image_get_data (hdr);
+ len = image_get_data_size (hdr);
- s = getenv ("verify");
- verify = (s && (*s == 'n')) ? 0 : 1;
+ verify = getenv_verify ();
if (verify) {
- if (crc32 (0, data, len) != hdr.ih_dcrc) {
+ if (!image_check_dcrc (hdr)) {
strcpy (msg, "Bad Image Data CRC");
goto failure;
}
}
- if (checkall && fpga_get_version(fpga, (char *)(hdr.ih_name)) < 0)
+ if (checkall && fpga_get_version(fpga, image_get_name (hdr)) < 0)
return 1;
/* align length */
goto failure;
}
- printf ("(%s)... ", hdr.ih_name);
+ printf ("(%s)... ", image_get_name (hdr));
/*
* Copy data to FPGA
*/
}
hdr = (image_header_t *)addr;
- if ((new_id = fpga_get_version(fpga, (char *)(hdr->ih_name))) == -1)
+ if ((new_id = fpga_get_version(fpga, image_get_name (hdr))) == -1)
return 1;
do_load = 1;
au_check_cksum_valid(int idx, long nbytes)
{
image_header_t *hdr;
- unsigned long checksum;
hdr = (image_header_t *)LOAD_ADDR;
- if (nbytes != (sizeof(*hdr) + ntohl(hdr->ih_size)))
+ if (nbytes != image_get_image_size (hdr))
{
printf ("Image %s bad total SIZE\n", aufile[idx]);
return -1;
}
/* check the data CRC */
- checksum = ntohl(hdr->ih_dcrc);
-
- if (crc32 (0, (uchar *)(LOAD_ADDR + sizeof(*hdr)), ntohl(hdr->ih_size))
- != checksum)
+ if (!image_check_dcrc (hdr)) {
{
printf ("Image %s bad data checksum\n", aufile[idx]);
return -1;
/* check the easy ones first */
#undef CHECK_VALID_DEBUG
#ifdef CHECK_VALID_DEBUG
- printf("magic %#x %#x ", ntohl(hdr->ih_magic), IH_MAGIC);
- printf("arch %#x %#x ", hdr->ih_arch, IH_CPU_ARM);
- printf("size %#x %#lx ", ntohl(hdr->ih_size), nbytes);
- printf("type %#x %#x ", hdr->ih_type, IH_TYPE_KERNEL);
+ printf("magic %#x %#x ", image_get_magic (hdr), IH_MAGIC);
+ printf("arch %#x %#x ", image_get_arch (hdr), IH_ARCH_ARM);
+ printf("size %#x %#lx ", image_get_data_size (hdr), nbytes);
+ printf("type %#x %#x ", image_get_type (hdr), IH_TYPE_KERNEL);
#endif
- if (nbytes < sizeof(*hdr))
+ if (nbytes < image_get_header_size ())
{
printf ("Image %s bad header SIZE\n", aufile[idx]);
return -1;
}
- if (ntohl(hdr->ih_magic) != IH_MAGIC || hdr->ih_arch != IH_CPU_ARM)
+ if (!image_check_magic (hdr) || !image_check_arch (hdr, IH_ARCH_ARM))
{
printf ("Image %s bad MAGIC or ARCH\n", aufile[idx]);
return -1;
}
/* check the hdr CRC */
- checksum = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32 (0, (uchar *)hdr, sizeof(*hdr)) != checksum) {
+ if (!image_check_hcrc (hdr)) {
printf ("Image %s bad header checksum\n", aufile[idx]);
return -1;
}
- hdr->ih_hcrc = htonl(checksum);
/* check the type - could do this all in one gigantic if() */
- if ((idx == IDX_FIRMWARE) && (hdr->ih_type != IH_TYPE_FIRMWARE)) {
+ if ((idx == IDX_FIRMWARE) && !image_check_type (hdr, IH_TYPE_FIRMWARE)) {
printf ("Image %s wrong type\n", aufile[idx]);
return -1;
}
- if ((idx == IDX_KERNEL) && (hdr->ih_type != IH_TYPE_KERNEL)) {
+ if ((idx == IDX_KERNEL) && !image_check_type (hdr, IH_TYPE_KERNEL)) {
printf ("Image %s wrong type\n", aufile[idx]);
return -1;
}
- if ((idx == IDX_DISK) && (hdr->ih_type != IH_TYPE_FILESYSTEM)) {
+ if ((idx == IDX_DISK) && !image_check_type (hdr, IH_TYPE_FILESYSTEM)) {
printf ("Image %s wrong type\n", aufile[idx]);
return -1;
}
- if ((idx == IDX_APP) && (hdr->ih_type != IH_TYPE_RAMDISK)
- && (hdr->ih_type != IH_TYPE_FILESYSTEM)) {
+ if ((idx == IDX_APP) && !image_check_type (hdr, IH_TYPE_RAMDISK)
+ && !image_check_type (hdr, FILESYSTEM)) {
printf ("Image %s wrong type\n", aufile[idx]);
return -1;
}
if ((idx == IDX_PREPARE || idx == IDX_PREINST || idx == IDX_POSTINST)
- && (hdr->ih_type != IH_TYPE_SCRIPT))
+ && !image_check_type (hdr, IH_TYPE_SCRIPT))
{
printf ("Image %s wrong type\n", aufile[idx]);
return -1;
if (idx == IDX_PREPARE)
return 0;
/* recycle checksum */
- checksum = ntohl(hdr->ih_size);
+ checksum = image_get_data_size (hdr);
/* for kernel and app the image header must also fit into flash */
if ((idx != IDX_DISK) && (idx != IDX_FIRMWARE))
- checksum += sizeof(*hdr);
+ checksum += image_get_header_size ();
/* check the size does not exceed space in flash. HUSH scripts */
/* all have ausize[] set to 0 */
if ((ausize[idx] != 0) && (ausize[idx] < checksum)) {
printf ("buf[0] %#x buf[1] %#x buf[2] %#x buf[3] %#x "
"as int %#x time %#x\n",
buf[0], buf[1], buf[2], buf[3],
- *((unsigned int *)buf), ntohl(hdr->ih_time));
+ *((unsigned int *)buf), image_get_time (hdr));
#endif
/* check it */
- if (*((unsigned int *)buf) >= ntohl(hdr->ih_time)) {
+ if (*((unsigned int *)buf) >= image_get_time (hdr)) {
printf ("Image %s is too old\n", aufile[idx]);
return -1;
}
*CPLD_VFD_BK |= POWER_OFF;
/* execute a script */
- if (hdr->ih_type == IH_TYPE_SCRIPT) {
- addr = (char *)((char *)hdr + sizeof(*hdr));
+ if (image_check_type (hdr, IH_TYPE_SCRIPT)) {
+ addr = (char *)((char *)hdr + image_get_header_size ());
/* stick a NULL at the end of the script, otherwise */
/* parse_string_outer() runs off the end. */
- addr[ntohl(hdr->ih_size)] = 0;
+ addr[image_get_data_size (hdr)] = 0;
addr += 8;
parse_string_outer(addr, FLAG_PARSE_SEMICOLON);
return 0;
flash_sect_erase(start, end);
wait_ms(100);
/* strip the header - except for the kernel and ramdisk */
- if (hdr->ih_type == IH_TYPE_KERNEL || hdr->ih_type == IH_TYPE_RAMDISK) {
+ if (image_check_type (hdr, IH_TYPE_KERNEL) ||
+ image_check_type (hdr, IH_TYPE_RAMDISK)) {
addr = (char *)hdr;
- off = sizeof(*hdr);
- nbytes = sizeof(*hdr) + ntohl(hdr->ih_size);
+ off = image_get_header_size ();
+ nbytes = image_get_image_size (hdr);
} else {
- addr = (char *)((char *)hdr + sizeof(*hdr));
+ addr = (char *)((char *)hdr + image_get_header_size ());
#ifdef AU_UPDATE_TEST
/* copy it to where Linux goes */
if (idx == IDX_FIRMWARE)
start = aufl_layout[1].start;
#endif
off = 0;
- nbytes = ntohl(hdr->ih_size);
+ nbytes = image_get_data_size (hdr);
}
/* copy the data from RAM to FLASH */
}
/* check the dcrc of the copy */
- if (crc32 (0, (uchar *)(start + off), ntohl(hdr->ih_size)) != ntohl(hdr->ih_dcrc)) {
+ if (crc32 (0, (uchar *)(start + off), image_get_data_size (hdr)) !=
+ image_get_dcrc (hdr)) {
printf ("Image %s Bad Data Checksum After COPY\n", aufile[idx]);
return -1;
}
hdr = (image_header_t *)LOAD_ADDR;
/* write the time field into EEPROM */
off = auee_off[idx].time;
- val = ntohl(hdr->ih_time);
+ val = image_get_time (hdr);
i2c_write_multiple(0x54, off, 1, &val, sizeof(val));
/* write the size field into EEPROM */
off = auee_off[idx].size;
- val = ntohl(hdr->ih_size);
+ val = image_get_data_size (hdr);
i2c_write_multiple(0x54, off, 1, &val, sizeof(val));
/* write the dcrc field into EEPROM */
off = auee_off[idx].dcrc;
- val = ntohl(hdr->ih_dcrc);
+ val = image_get_dcrc (hdr);
i2c_write_multiple(0x54, off, 1, &val, sizeof(val));
/* enable the power switch */
*CPLD_VFD_BK &= ~POWER_OFF;
/* just loop thru all the possible files */
for (i = 0; i < AU_MAXFILES; i++) {
/* just read the header */
- sz = file_fat_read(aufile[i], LOAD_ADDR, sizeof(image_header_t));
+ sz = file_fat_read(aufile[i], LOAD_ADDR, image_get_header_size ());
debug ("read %s sz %ld hdr %d\n",
- aufile[i], sz, sizeof(image_header_t));
- if (sz <= 0 || sz < sizeof(image_header_t)) {
+ aufile[i], sz, image_get_header_size ());
+ if (sz <= 0 || sz < image_get_header_size ()) {
debug ("%s not found\n", aufile[i]);
continue;
}
}
sz = file_fat_read(aufile[i], LOAD_ADDR, MAX_LOADSZ);
debug ("read %s sz %ld hdr %d\n",
- aufile[i], sz, sizeof(image_header_t));
- if (sz <= 0 || sz <= sizeof(image_header_t)) {
+ aufile[i], sz, image_get_header_size ());
+ if (sz <= 0 || sz <= image_get_header_size ()) {
debug ("%s not found\n", aufile[i]);
continue;
}
COBJS-$(CONFIG_CMD_BDI) += cmd_bdinfo.o
COBJS-$(CONFIG_CMD_BEDBUG) += cmd_bedbug.o
COBJS-$(CONFIG_CMD_BMP) += cmd_bmp.o
+COBJS-y += image.o
COBJS-y += cmd_boot.o
COBJS-y += cmd_bootm.o
COBJS-$(CONFIG_CMD_CACHE) += cmd_cache.o
#if defined(CONFIG_AUTOSCRIPT) || defined(CONFIG_CMD_AUTOSCRIPT)
-extern image_header_t header; /* from cmd_bootm.c */
int
autoscript (ulong addr)
{
- ulong crc, data, len;
- image_header_t *hdr = &header;
+ ulong len;
+ image_header_t *hdr = (image_header_t *)addr;
ulong *len_ptr;
char *cmd;
int rcode = 0;
int verify;
- cmd = getenv ("verify");
- verify = (cmd && (*cmd == 'n')) ? 0 : 1;
+ verify = getenv_verify ();
-
- memmove (hdr, (char *)addr, sizeof(image_header_t));
-
- if (ntohl(hdr->ih_magic) != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
puts ("Bad magic number\n");
return 1;
}
- crc = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
- len = sizeof (image_header_t);
- data = (ulong)hdr;
- if (crc32(0, (uchar *)data, len) != crc) {
+ if (!image_check_hcrc (hdr)) {
puts ("Bad header crc\n");
return 1;
}
- data = addr + sizeof(image_header_t);
- len = ntohl(hdr->ih_size);
-
if (verify) {
- if (crc32(0, (uchar *)data, len) != ntohl(hdr->ih_dcrc)) {
+ if (!image_check_dcrc (hdr)) {
puts ("Bad data crc\n");
return 1;
}
}
- if (hdr->ih_type != IH_TYPE_SCRIPT) {
+ if (!image_check_type (hdr, IH_TYPE_SCRIPT)) {
puts ("Bad image type\n");
return 1;
}
/* get length of script */
- len_ptr = (ulong *)data;
+ len_ptr = (ulong *)image_get_data (hdr);
- if ((len = ntohl(*len_ptr)) == 0) {
+ if ((len = image_to_cpu (*len_ptr)) == 0) {
puts ("Empty Script\n");
return 1;
}
* MA 02111-1307 USA
*/
+#define DEBUG
+
/*
* Boot support
*/
* we must make sure to split long operations like memmove() or
* crc32() into reasonable chunks.
*/
-#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
-# define CHUNKSZ (64 * 1024)
-#endif
+#define CHUNKSZ (64 * 1024)
int gunzip (void *, int, unsigned char *, unsigned long *);
{
ulong iflag;
ulong addr;
- ulong data, len, checksum;
+ ulong data, len;
ulong *len_ptr;
uint unc_len = CFG_BOOTM_LEN;
int i, verify;
int (*appl)(int, char *[]);
image_header_t *hdr = &header;
- s = getenv ("verify");
- verify = (s && (*s == 'n')) ? 0 : 1;
+ verify = getenv_verify ();
if (argc < 2) {
addr = load_addr;
/* Copy header so we can blank CRC field for re-calculation */
#ifdef CONFIG_HAS_DATAFLASH
if (addr_dataflash(addr)){
- read_dataflash(addr, sizeof(image_header_t), (char *)&header);
+ read_dataflash (addr, image_get_header_size (), (char *)&header);
} else
#endif
- memmove (&header, (char *)addr, sizeof(image_header_t));
+ memmove (&header, (char *)addr, image_get_header_size ());
- if (ntohl(hdr->ih_magic) != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
#ifdef __I386__ /* correct image format not implemented yet - fake it */
if (fake_header(hdr, (void*)addr, -1) != NULL) {
/* to compensate for the addition below */
- addr -= sizeof(image_header_t);
+ addr -= image_get_header_size ();
/* turnof verify,
* fake_header() does not fake the data crc
*/
}
show_boot_progress (2);
- data = (ulong)&header;
- len = sizeof(image_header_t);
-
- checksum = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32 (0, (uchar *)data, len) != checksum) {
+ if (!image_check_hcrc (hdr)) {
puts ("Bad Header Checksum\n");
show_boot_progress (-2);
return 1;
#ifdef CONFIG_HAS_DATAFLASH
if (addr_dataflash(addr)){
- len = ntohl(hdr->ih_size) + sizeof(image_header_t);
+ len = image_get_image_size (hdr);
read_dataflash(addr, len, (char *)CFG_LOAD_ADDR);
addr = CFG_LOAD_ADDR;
}
/* for multi-file images we need the data part, too */
print_image_hdr ((image_header_t *)addr);
- data = addr + sizeof(image_header_t);
- len = ntohl(hdr->ih_size);
+ len = image_get_data_size (hdr);
+ data = addr + image_get_header_size ();
+ len_ptr = (ulong *)data;
if (verify) {
puts (" Verifying Checksum ... ");
- if (crc32 (0, (uchar *)data, len) != ntohl(hdr->ih_dcrc)) {
+ if (!image_check_dcrc ((image_header_t *)addr)) {
printf ("Bad Data CRC\n");
show_boot_progress (-3);
return 1;
}
show_boot_progress (4);
- len_ptr = (ulong *)data;
-
-#if defined(__ARM__)
- if (hdr->ih_arch != IH_CPU_ARM)
-#elif defined(__avr32__)
- if (hdr->ih_arch != IH_CPU_AVR32)
-#elif defined(__bfin__)
- if (hdr->ih_arch != IH_CPU_BLACKFIN)
-#elif defined(__I386__)
- if (hdr->ih_arch != IH_CPU_I386)
-#elif defined(__M68K__)
- if (hdr->ih_arch != IH_CPU_M68K)
-#elif defined(__microblaze__)
- if (hdr->ih_arch != IH_CPU_MICROBLAZE)
-#elif defined(__mips__)
- if (hdr->ih_arch != IH_CPU_MIPS)
-#elif defined(__nios__)
- if (hdr->ih_arch != IH_CPU_NIOS)
-#elif defined(__nios2__)
- if (hdr->ih_arch != IH_CPU_NIOS2)
-#elif defined(__PPC__)
- if (hdr->ih_arch != IH_CPU_PPC)
-#elif defined(__sh__)
- if (hdr->ih_arch != IH_CPU_SH)
-#else
-# error Unknown CPU type
-#endif
- {
- printf ("Unsupported Architecture 0x%x\n", hdr->ih_arch);
+ if (!image_check_target_arch (hdr)) {
+ printf ("Unsupported Architecture 0x%x\n", image_get_arch (hdr));
show_boot_progress (-4);
return 1;
}
show_boot_progress (5);
- switch (hdr->ih_type) {
+ switch (image_get_type (hdr)) {
case IH_TYPE_STANDALONE:
name = "Standalone Application";
/* A second argument overwrites the load address */
if (argc > 2) {
- hdr->ih_load = htonl(simple_strtoul(argv[2], NULL, 16));
+ image_set_load (hdr, simple_strtoul (argv[2], NULL, 16));
}
break;
case IH_TYPE_KERNEL:
break;
case IH_TYPE_MULTI:
name = "Multi-File Image";
- len = ntohl(len_ptr[0]);
+ len = image_to_cpu (len_ptr[0]);
/* OS kernel is always the first image */
data += 8; /* kernel_len + terminator */
for (i=1; len_ptr[i]; ++i)
dcache_disable();
#endif
- switch (hdr->ih_comp) {
+ switch (image_get_comp (hdr)) {
case IH_COMP_NONE:
- if(ntohl(hdr->ih_load) == addr) {
+ if (image_get_load (hdr) == addr) {
printf (" XIP %s ... ", name);
} else {
#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
size_t l = len;
- void *to = (void *)ntohl(hdr->ih_load);
+ void *to = (void *)image_get_load (hdr);
void *from = (void *)data;
printf (" Loading %s ... ", name);
l -= tail;
}
#else /* !(CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG) */
- memmove ((void *) ntohl(hdr->ih_load), (uchar *)data, len);
+ memmove ((void *)image_get_load (hdr), (uchar *)data, len);
#endif /* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */
}
break;
case IH_COMP_GZIP:
printf (" Uncompressing %s ... ", name);
- if (gunzip ((void *)ntohl(hdr->ih_load), unc_len,
+ if (gunzip ((void *)image_get_load (hdr), unc_len,
(uchar *)data, &len) != 0) {
puts ("GUNZIP ERROR - must RESET board to recover\n");
show_boot_progress (-6);
* use slower decompression algorithm which requires
* at most 2300 KB of memory.
*/
- i = BZ2_bzBuffToBuffDecompress ((char*)ntohl(hdr->ih_load),
+ i = BZ2_bzBuffToBuffDecompress ((char*)image_get_load (hdr),
&unc_len, (char *)data, len,
CFG_MALLOC_LEN < (4096 * 1024), 0);
if (i != BZ_OK) {
default:
if (iflag)
enable_interrupts();
- printf ("Unimplemented compression type %d\n", hdr->ih_comp);
+ printf ("Unimplemented compression type %d\n", image_get_comp (hdr));
show_boot_progress (-7);
return 1;
}
puts ("OK\n");
show_boot_progress (7);
- switch (hdr->ih_type) {
+ switch (image_get_type (hdr)) {
case IH_TYPE_STANDALONE:
if (iflag)
enable_interrupts();
setenv("filesize", buf);
return 0;
}
- appl = (int (*)(int, char *[]))ntohl(hdr->ih_ep);
+ appl = (int (*)(int, char *[]))image_get_ep (hdr);
(*appl)(argc-1, &argv[1]);
return 0;
case IH_TYPE_KERNEL:
default:
if (iflag)
enable_interrupts();
- printf ("Can't boot image type %d\n", hdr->ih_type);
+ printf ("Can't boot image type %d\n", image_get_type (hdr));
show_boot_progress (-8);
return 1;
}
show_boot_progress (8);
- switch (hdr->ih_os) {
+ switch (image_get_os (hdr)) {
default: /* handled by (original) Linux case */
case IH_OS_LINUX:
#ifdef CONFIG_SILENT_CONSOLE
int verify)
{
ulong sp;
- ulong len, checksum;
+ ulong len;
ulong initrd_start, initrd_end;
ulong cmd_start, cmd_end;
ulong initrd_high;
#endif /* CONFIG_MPC5xxx */
}
- kernel = (void (*)(bd_t *, ulong, ulong, ulong, ulong)) ntohl(hdr->ih_ep);
+ kernel = (void (*)(bd_t *, ulong, ulong, ulong, ulong))image_get_ep (hdr);
/*
* Check if there is an initrd image
addr = simple_strtoul(argv[2], NULL, 16);
printf ("## Loading RAMDisk Image at %08lx ...\n", addr);
+ hdr = (image_header_t *)addr;
- /* Copy header so we can blank CRC field for re-calculation */
- memmove (&header, (char *)addr, sizeof(image_header_t));
-
- if (ntohl(hdr->ih_magic) != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
puts ("Bad Magic Number\n");
show_boot_progress (-10);
do_reset (cmdtp, flag, argc, argv);
}
- data = (ulong)&header;
- len = sizeof(image_header_t);
-
- checksum = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32 (0, (uchar *)data, len) != checksum) {
+ if (!image_check_hcrc (hdr)) {
puts ("Bad Header Checksum\n");
show_boot_progress (-11);
do_reset (cmdtp, flag, argc, argv);
}
-
show_boot_progress (10);
print_image_hdr (hdr);
- data = addr + sizeof(image_header_t);
- len = ntohl(hdr->ih_size);
-
if (verify) {
- ulong csum = 0;
-#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
- ulong cdata = data, edata = cdata + len;
-#endif /* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */
-
puts (" Verifying Checksum ... ");
-#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
-
- while (cdata < edata) {
- ulong chunk = edata - cdata;
-
- if (chunk > CHUNKSZ)
- chunk = CHUNKSZ;
- csum = crc32 (csum, (uchar *)cdata, chunk);
- cdata += chunk;
-
- WATCHDOG_RESET();
- }
-#else /* !(CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG) */
- csum = crc32 (0, (uchar *)data, len);
-#endif /* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */
-
- if (csum != ntohl(hdr->ih_dcrc)) {
+ if (!image_check_dcrc_wd (hdr, CHUNKSZ)) {
puts ("Bad Data CRC\n");
show_boot_progress (-12);
do_reset (cmdtp, flag, argc, argv);
show_boot_progress (11);
- if ((hdr->ih_os != IH_OS_LINUX) ||
- (hdr->ih_arch != IH_CPU_PPC) ||
- (hdr->ih_type != IH_TYPE_RAMDISK) ) {
+ if (!image_check_os (hdr, IH_OS_LINUX) ||
+ !image_check_arch (hdr, IH_ARCH_PPC) ||
+ !image_check_type (hdr, IH_TYPE_RAMDISK)) {
puts ("No Linux PPC Ramdisk Image\n");
show_boot_progress (-13);
do_reset (cmdtp, flag, argc, argv);
}
+ data = image_get_data (hdr);
+ len = image_get_data_size (hdr);
+
/*
* Now check if we have a multifile image
*/
- } else if ((hdr->ih_type==IH_TYPE_MULTI) && (len_ptr[1])) {
- u_long tail = ntohl(len_ptr[0]) % 4;
+ } else if (image_check_type (hdr, IH_TYPE_MULTI) && (len_ptr[1])) {
+ u_long tail = image_to_cpu (len_ptr[0]) % 4;
int i;
show_boot_progress (13);
for (i=1; len_ptr[i]; ++i)
data += 4;
/* add kernel length, and align */
- data += ntohl(len_ptr[0]);
+ data += image_to_cpu (len_ptr[0]);
if (tail) {
data += 4 - tail;
}
- len = ntohl(len_ptr[1]);
+ len = image_to_cpu (len_ptr[1]);
} else {
/*
of_flat_tree = (char *) simple_strtoul(argv[3], NULL, 16);
hdr = (image_header_t *)of_flat_tree;
#if defined(CONFIG_OF_FLAT_TREE)
- if (*((ulong *)(of_flat_tree + sizeof(image_header_t))) != OF_DT_HEADER) {
+ if (*((ulong *)(of_flat_tree + image_get_header_size ())) != OF_DT_HEADER) {
#else
- if (fdt_check_header(of_flat_tree + sizeof(image_header_t)) != 0) {
+ if (fdt_check_header (of_flat_tree + image_get_header_size ()) != 0) {
#endif
#ifndef CFG_NO_FLASH
if (addr2info((ulong)of_flat_tree) != NULL)
of_data = (ulong)of_flat_tree;
#endif
- } else if (ntohl(hdr->ih_magic) == IH_MAGIC) {
+ } else if (image_check_magic (hdr)) {
printf("## Flat Device Tree at %08lX\n", hdr);
- print_image_hdr(hdr);
+ print_image_hdr (hdr);
- if ((ntohl(hdr->ih_load) < ((unsigned long)hdr + ntohl(hdr->ih_size) + sizeof(hdr))) &&
- ((ntohl(hdr->ih_load) + ntohl(hdr->ih_size)) > (unsigned long)hdr)) {
+ if ((image_get_load (hdr) < ((unsigned long)hdr + image_get_image_size (hdr))) &&
+ ((image_get_load (hdr) + image_get_data_size (hdr)) > (unsigned long)hdr)) {
puts ("ERROR: fdt overwritten - "
"must RESET the board to recover.\n");
do_reset (cmdtp, flag, argc, argv);
}
puts (" Verifying Checksum ... ");
- memmove (&header, (char *)hdr, sizeof(image_header_t));
- checksum = ntohl(header.ih_hcrc);
- header.ih_hcrc = 0;
-
- if(checksum != crc32(0, (uchar *)&header, sizeof(image_header_t))) {
+ if (!image_check_hcrc (hdr)) {
puts ("ERROR: fdt header checksum invalid - "
"must RESET the board to recover.\n");
do_reset (cmdtp, flag, argc, argv);
}
- checksum = ntohl(hdr->ih_dcrc);
- addr = (ulong)((uchar *)(hdr) + sizeof(image_header_t));
-
- if(checksum != crc32(0, (uchar *)addr, ntohl(hdr->ih_size))) {
+ if (!image_check_dcrc (hdr)) {
puts ("ERROR: fdt checksum invalid - "
"must RESET the board to recover.\n");
do_reset (cmdtp, flag, argc, argv);
}
puts ("OK\n");
- if (ntohl(hdr->ih_type) != IH_TYPE_FLATDT) {
+ if (!image_check_type (hdr, IH_TYPE_FLATDT)) {
puts ("ERROR: uImage is not a fdt - "
"must RESET the board to recover.\n");
do_reset (cmdtp, flag, argc, argv);
}
- if (ntohl(hdr->ih_comp) != IH_COMP_NONE) {
+ if (image_get_comp (hdr) != IH_COMP_NONE) {
puts ("ERROR: uImage is compressed - "
"must RESET the board to recover.\n");
do_reset (cmdtp, flag, argc, argv);
}
#if defined(CONFIG_OF_FLAT_TREE)
- if (*((ulong *)(of_flat_tree + sizeof(image_header_t))) != OF_DT_HEADER) {
+ if (*((ulong *)(of_flat_tree + image_get_header_size ())) != OF_DT_HEADER) {
#else
- if (fdt_check_header(of_flat_tree + sizeof(image_header_t)) != 0) {
+ if (fdt_check_header (of_flat_tree + image_get_header_size ()) != 0) {
#endif
puts ("ERROR: uImage data is not a fdt - "
"must RESET the board to recover.\n");
do_reset (cmdtp, flag, argc, argv);
}
- memmove((void *)ntohl(hdr->ih_load),
- (void *)(of_flat_tree + sizeof(image_header_t)),
- ntohl(hdr->ih_size));
- of_flat_tree = (char *)ntohl(hdr->ih_load);
+ memmove ((void *)image_get_load (hdr),
+ (void *)(of_flat_tree + image_get_header_size ()),
+ image_get_data_size (hdr));
+
+ of_flat_tree = (char *)image_get_load (hdr);
} else {
puts ("Did not find a flat Flat Device Tree.\n"
"Must RESET the board to recover.\n");
}
printf (" Booting using the fdt at 0x%x\n",
of_flat_tree);
- } else if ((hdr->ih_type==IH_TYPE_MULTI) && (len_ptr[1]) && (len_ptr[2])) {
- u_long tail = ntohl(len_ptr[0]) % 4;
+ } else if (image_check_type (hdr, IH_TYPE_MULTI) && (len_ptr[1]) && (len_ptr[2])) {
+ u_long tail = image_to_cpu (len_ptr[0]) % 4;
int i;
/* skip kernel length, initrd length, and terminator */
for (i=2; len_ptr[i]; ++i)
of_flat_tree += 4;
/* add kernel length, and align */
- of_flat_tree += ntohl(len_ptr[0]);
+ of_flat_tree += image_to_cpu (len_ptr[0]);
if (tail) {
of_flat_tree += 4 - tail;
}
/* add initrd length, and align */
- tail = ntohl(len_ptr[1]) % 4;
- of_flat_tree += ntohl(len_ptr[1]);
+ tail = image_to_cpu (len_ptr[1]) % 4;
+ of_flat_tree += image_to_cpu (len_ptr[1]);
if (tail) {
of_flat_tree += 4 - tail;
}
#if defined(CONFIG_OF_FLAT_TREE)
if (((struct boot_param_header *)of_flat_tree)->totalsize !=
- ntohl (len_ptr[2])) {
+ image_to_cpu (len_ptr[2])) {
#else
if (be32_to_cpu (fdt_totalsize (of_flat_tree)) !=
- ntohl(len_ptr[2])) {
+ image_to_cpu (len_ptr[2])) {
#endif
puts ("ERROR: fdt size != image size - "
"must RESET the board to recover.\n");
*/
img_addr = 0;
- if ((hdr->ih_type==IH_TYPE_MULTI) && (len_ptr[1]))
+ if ((image_check_type (hdr, IH_TYPE_MULTI)) && (len_ptr[1]))
img_addr = (image_header_t *) addr;
cmdline = "";
}
- loader = (void (*)(bd_t *, image_header_t *, char *, char *)) ntohl(hdr->ih_ep);
+ loader = (void (*)(bd_t *, image_header_t *, char *, char *))image_get_ep (hdr);
printf ("## Transferring control to NetBSD stage-2 loader (at address %08lx) ...\n",
(ulong)loader);
}
*ss++ = NULL; /* terminate */
- entry = (void (*)(bd_t *, char *, char **, ulong))ntohl(hdr->ih_ep);
+ entry = (void (*)(bd_t *, char *, char **, ulong))image_get_ep (hdr);
(*entry)(kbd, cmdline, fwenv, top);
}
#endif
static int image_info (ulong addr)
{
- ulong data, len, checksum;
- image_header_t *hdr = &header;
+ image_header_t *hdr = (image_header_t *)addr;
printf ("\n## Checking Image at %08lx ...\n", addr);
- /* Copy header so we can blank CRC field for re-calculation */
- memmove (&header, (char *)addr, sizeof(image_header_t));
-
- if (ntohl(hdr->ih_magic) != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
puts (" Bad Magic Number\n");
return 1;
}
- data = (ulong)&header;
- len = sizeof(image_header_t);
-
- checksum = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32 (0, (uchar *)data, len) != checksum) {
+ if (!image_check_hcrc (hdr)) {
puts (" Bad Header Checksum\n");
return 1;
}
- /* for multi-file images we need the data part, too */
- print_image_hdr ((image_header_t *)addr);
-
- data = addr + sizeof(image_header_t);
- len = ntohl(hdr->ih_size);
+ print_image_hdr (hdr);
puts (" Verifying Checksum ... ");
- if (crc32 (0, (uchar *)data, len) != ntohl(hdr->ih_dcrc)) {
+ if (!image_check_dcrc (hdr)) {
puts (" Bad Data CRC\n");
return 1;
}
flash_info_t *info;
int i, j;
image_header_t *hdr;
- ulong data, len, checksum;
for (i=0, info=&flash_info[0]; i<CFG_MAX_FLASH_BANKS; ++i, ++info) {
if (info->flash_id == FLASH_UNKNOWN)
goto next_bank;
for (j=0; j<info->sector_count; ++j) {
- if (!(hdr=(image_header_t *)info->start[j]) ||
- (ntohl(hdr->ih_magic) != IH_MAGIC))
- goto next_sector;
+ hdr = (image_header_t *)info->start[j];
- /* Copy header so we can blank CRC field for re-calculation */
- memmove (&header, (char *)hdr, sizeof(image_header_t));
-
- checksum = ntohl(header.ih_hcrc);
- header.ih_hcrc = 0;
+ if (!hdr || !image_check_magic (hdr))
+ goto next_sector;
- if (crc32 (0, (uchar *)&header, sizeof(image_header_t))
- != checksum)
+ if (!image_check_hcrc (hdr))
goto next_sector;
printf ("Image at %08lX:\n", (ulong)hdr);
- print_image_hdr( hdr );
-
- data = (ulong)hdr + sizeof(image_header_t);
- len = ntohl(hdr->ih_size);
+ print_image_hdr (hdr);
puts (" Verifying Checksum ... ");
- if (crc32 (0, (uchar *)data, len) != ntohl(hdr->ih_dcrc)) {
- puts (" Bad Data CRC\n");
+ if (!image_check_dcrc (hdr)) {
+ puts ("Bad Data CRC\n");
+ } else {
+ puts ("OK\n");
}
- puts ("OK\n");
next_sector: ;
}
next_bank: ;
print_image_hdr (image_header_t *hdr)
{
#if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE)
- time_t timestamp = (time_t)ntohl(hdr->ih_time);
+ time_t timestamp = (time_t)image_get_time (hdr);
struct rtc_time tm;
#endif
- printf (" Image Name: %.*s\n", IH_NMLEN, hdr->ih_name);
+ printf (" Image Name: %.*s\n", IH_NMLEN, image_get_name (hdr));
#if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE)
to_tm (timestamp, &tm);
printf (" Created: %4d-%02d-%02d %2d:%02d:%02d UTC\n",
tm.tm_hour, tm.tm_min, tm.tm_sec);
#endif
puts (" Image Type: "); print_type(hdr);
- printf ("\n Data Size: %d Bytes = ", ntohl(hdr->ih_size));
- print_size (ntohl(hdr->ih_size), "\n");
+ printf ("\n Data Size: %d Bytes = ", image_get_data_size (hdr));
+ print_size (image_get_data_size (hdr), "\n");
printf (" Load Address: %08x\n"
" Entry Point: %08x\n",
- ntohl(hdr->ih_load), ntohl(hdr->ih_ep));
+ image_get_load (hdr), image_get_ep (hdr));
- if (hdr->ih_type == IH_TYPE_MULTI) {
+ if (image_check_type (hdr, IH_TYPE_MULTI)) {
int i;
ulong len;
- ulong *len_ptr = (ulong *)((ulong)hdr + sizeof(image_header_t));
+ ulong *len_ptr = (ulong *)((ulong)hdr + image_get_header_size ());
puts (" Contents:\n");
- for (i=0; (len = ntohl(*len_ptr)); ++i, ++len_ptr) {
+ for (i=0; (len = image_to_cpu (*len_ptr)); ++i, ++len_ptr) {
printf (" Image %d: %8ld Bytes = ", i, len);
print_size (len, "\n");
}
{
char *os, *arch, *type, *comp;
- switch (hdr->ih_os) {
+ switch (image_get_os (hdr)) {
case IH_OS_INVALID: os = "Invalid OS"; break;
case IH_OS_NETBSD: os = "NetBSD"; break;
case IH_OS_LINUX: os = "Linux"; break;
default: os = "Unknown OS"; break;
}
- switch (hdr->ih_arch) {
- case IH_CPU_INVALID: arch = "Invalid CPU"; break;
- case IH_CPU_ALPHA: arch = "Alpha"; break;
- case IH_CPU_ARM: arch = "ARM"; break;
- case IH_CPU_AVR32: arch = "AVR32"; break;
- case IH_CPU_BLACKFIN: arch = "Blackfin"; break;
- case IH_CPU_I386: arch = "Intel x86"; break;
- case IH_CPU_IA64: arch = "IA64"; break;
- case IH_CPU_M68K: arch = "M68K"; break;
- case IH_CPU_MICROBLAZE: arch = "Microblaze"; break;
- case IH_CPU_MIPS64: arch = "MIPS 64 Bit"; break;
- case IH_CPU_MIPS: arch = "MIPS"; break;
- case IH_CPU_NIOS2: arch = "Nios-II"; break;
- case IH_CPU_NIOS: arch = "Nios"; break;
- case IH_CPU_PPC: arch = "PowerPC"; break;
- case IH_CPU_S390: arch = "IBM S390"; break;
- case IH_CPU_SH: arch = "SuperH"; break;
- case IH_CPU_SPARC64: arch = "SPARC 64 Bit"; break;
- case IH_CPU_SPARC: arch = "SPARC"; break;
+ switch (image_get_arch (hdr)) {
+ case IH_ARCH_INVALID: arch = "Invalid CPU"; break;
+ case IH_ARCH_ALPHA: arch = "Alpha"; break;
+ case IH_ARCH_ARM: arch = "ARM"; break;
+ case IH_ARCH_AVR32: arch = "AVR32"; break;
+ case IH_ARCH_BLACKFIN: arch = "Blackfin"; break;
+ case IH_ARCH_I386: arch = "Intel x86"; break;
+ case IH_ARCH_IA64: arch = "IA64"; break;
+ case IH_ARCH_M68K: arch = "M68K"; break;
+ case IH_ARCH_MICROBLAZE:arch = "Microblaze"; break;
+ case IH_ARCH_MIPS64: arch = "MIPS 64 Bit"; break;
+ case IH_ARCH_MIPS: arch = "MIPS"; break;
+ case IH_ARCH_NIOS2: arch = "Nios-II"; break;
+ case IH_ARCH_NIOS: arch = "Nios"; break;
+ case IH_ARCH_PPC: arch = "PowerPC"; break;
+ case IH_ARCH_S390: arch = "IBM S390"; break;
+ case IH_ARCH_SH: arch = "SuperH"; break;
+ case IH_ARCH_SPARC64: arch = "SPARC 64 Bit"; break;
+ case IH_ARCH_SPARC: arch = "SPARC"; break;
default: arch = "Unknown Architecture"; break;
}
- switch (hdr->ih_type) {
+ switch (image_get_type (hdr)) {
case IH_TYPE_INVALID: type = "Invalid Image"; break;
case IH_TYPE_STANDALONE:type = "Standalone Program"; break;
case IH_TYPE_KERNEL: type = "Kernel Image"; break;
default: type = "Unknown Image"; break;
}
- switch (hdr->ih_comp) {
+ switch (image_get_comp (hdr)) {
case IH_COMP_NONE: comp = "uncompressed"; break;
case IH_COMP_GZIP: comp = "gzip compressed"; break;
case IH_COMP_BZIP2: comp = "bzip2 compressed"; break;
image_header_t *hdr = &header;
void (*entry_point)(bd_t *);
- entry_point = (void (*)(bd_t *)) ntohl(hdr->ih_ep);
+ entry_point = (void (*)(bd_t *))image_get_ep (hdr);
printf ("## Transferring control to RTEMS (at address %08lx) ...\n",
(ulong)entry_point);
image_header_t *hdr = &header;
char str[80];
- sprintf(str, "%x", ntohl(hdr->ih_ep)); /* write entry-point into string */
+ sprintf(str, "%x", image_get_ep (hdr)); /* write entry-point into string */
setenv("loadaddr", str);
do_bootvx(cmdtp, 0, 0, NULL);
}
char *local_args[2];
char str[16];
- sprintf(str, "%x", ntohl(hdr->ih_ep)); /* write entry-point into string */
+ sprintf(str, "%x", image_get_ep (hdr)); /* write entry-point into string */
local_args[0] = argv[0];
local_args[1] = str; /* and provide it via the arguments */
do_bootelf(cmdtp, 0, 2, local_args);
hdr = (image_header_t *)addr;
- if (hdr->ih_magic == IH_MAGIC) {
+ if (image_check_magic (hdr)) {
print_image_hdr (hdr);
- cnt = (ntohl(hdr->ih_size) + sizeof(image_header_t));
+ cnt = image_get_image_size (hdr);
cnt -= SECTORSIZE;
} else {
puts ("\n** Bad Magic Number **\n");
return 1;
}
hdr = (image_header_t *)addr;
- if (ntohl(hdr->ih_magic) != IH_MAGIC) {
+ if (!image_get_magic (hdr)) {
printf ("Bad Magic Number\n");
return 1;
}
- print_image_hdr(hdr);
+ print_image_hdr (hdr);
- imsize= ntohl(hdr->ih_size)+sizeof(image_header_t);
+ imsize= image_get_image_size (hdr);
nrofblk=imsize/512;
if((imsize%512)>0)
nrofblk++;
/* Loading ok, update default load address */
load_addr = addr;
- if(hdr->ih_type == IH_TYPE_KERNEL) {
+ if(image_check_type (hdr, IH_TYPE_KERNEL)) {
/* Check if we should attempt an auto-start */
if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
char *local_args[2];
image_header_t *hdr = &header;
ulong data;
- memmove (&header, (char *)fpga_data, sizeof(image_header_t));
- if (ntohl(hdr->ih_magic) != IH_MAGIC) {
+ memmove (&header, (char *)fpga_data, image_get_header_size ());
+ if (!image_check_magic (hdr)) {
puts ("Bad Magic Number\n");
return 1;
}
- data = ((ulong)fpga_data + sizeof(image_header_t));
- data_size = ntohl(hdr->ih_size);
+ data = ((ulong)fpga_data + image_get_header_size ());
+ data_size = image_get_data_size (hdr);
rc = fpga_load (dev, (void *)data, data_size);
}
break;
char *boot_device = NULL;
char *ep;
int dev, part = 0;
- ulong addr, cnt, checksum;
+ ulong addr, cnt;
disk_partition_t info;
image_header_t *hdr;
int rcode = 0;
hdr = (image_header_t *)addr;
- if (ntohl(hdr->ih_magic) != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
printf("\n** Bad Magic Number **\n");
show_boot_progress (-49);
return 1;
}
show_boot_progress (49);
- checksum = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32 (0, (uchar *)hdr, sizeof(image_header_t)) != checksum) {
+ if (!image_check_hcrc (hdr)) {
puts ("\n** Bad Header Checksum **\n");
show_boot_progress (-50);
return 1;
}
show_boot_progress (50);
- hdr->ih_hcrc = htonl(checksum); /* restore checksum for later use */
print_image_hdr (hdr);
- cnt = (ntohl(hdr->ih_size) + sizeof(image_header_t));
+ cnt = image_get_image_size (hdr);
cnt += info.blksz - 1;
cnt /= info.blksz;
cnt -= 1;
hdr = (image_header_t *) addr;
- if (ntohl(hdr->ih_magic) != IH_MAGIC) {
- printf("\n** Bad Magic Number 0x%x **\n", hdr->ih_magic);
+ if (!image_check_magic (hdr)) {
+ printf("\n** Bad Magic Number 0x%x **\n", image_get_magic (hdr));
show_boot_progress (-57);
return 1;
}
show_boot_progress (57);
- print_image_hdr(hdr);
+ print_image_hdr (hdr);
- cnt = (ntohl(hdr->ih_size) + sizeof (image_header_t));
+ cnt = image_get_image_size (hdr);
if (jffs2) {
nand_read_options_t opts;
memset(&opts, 0, sizeof(opts));
hdr = (image_header_t *)addr;
- if (ntohl(hdr->ih_magic) == IH_MAGIC) {
+ if (image_check_magic (hdr)) {
print_image_hdr (hdr);
- cnt = (ntohl(hdr->ih_size) + sizeof(image_header_t));
+ cnt = image_get_image_size (hdr);
cnt -= SECTORSIZE;
} else {
- printf ("\n** Bad Magic Number 0x%x **\n", ntohl(hdr->ih_magic));
+ printf ("\n** Bad Magic Number 0x%x **\n", image_get_magic (hdr));
show_boot_progress (-57);
return 1;
}
char *boot_device = NULL;
char *ep;
int dev, part = 0;
- ulong addr, cnt, checksum;
+ ulong addr, cnt;
disk_partition_t info;
image_header_t *hdr;
int rcode = 0;
hdr = (image_header_t *)addr;
- if (ntohl(hdr->ih_magic) == IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
printf("\n** Bad Magic Number **\n");
return 1;
}
- checksum = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32 (0, (uchar *)hdr, sizeof(image_header_t)) != checksum) {
+ if (!image_check_hcrc (hdr)) {
puts ("\n** Bad Header Checksum **\n");
return 1;
}
- hdr->ih_hcrc = htonl(checksum); /* restore checksum for later use */
print_image_hdr (hdr);
- cnt = (ntohl(hdr->ih_size) + sizeof(image_header_t));
+ cnt = image_get_image_size (hdr);
cnt += info.blksz - 1;
cnt /= info.blksz;
cnt -= 1;
char *boot_device = NULL;
char *ep;
int dev, part=1, rcode;
- ulong addr, cnt, checksum;
+ ulong addr, cnt;
disk_partition_t info;
image_header_t *hdr;
block_dev_desc_t *stor_dev;
hdr = (image_header_t *)addr;
- if (ntohl(hdr->ih_magic) != IH_MAGIC) {
+ if (!image_get_magic (hdr)) {
printf("\n** Bad Magic Number **\n");
return 1;
}
- checksum = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32 (0, (uchar *)hdr, sizeof(image_header_t)) != checksum) {
+ if (!image_check_hcrc (hdr)) {
puts ("\n** Bad Header Checksum **\n");
return 1;
}
- hdr->ih_hcrc = htonl(checksum); /* restore checksum for later use */
print_image_hdr (hdr);
- cnt = (ntohl(hdr->ih_size) + sizeof(image_header_t));
+ cnt = image_get_image_size (hdr);
cnt += info.blksz - 1;
cnt /= info.blksz;
cnt -= 1;
do_imgextract(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
{
ulong addr = load_addr, dest = 0;
- ulong data, len, checksum;
+ ulong data, len;
ulong *len_ptr;
int i, verify, part = 0;
char pbuf[10], *s;
- image_header_t header;
+ image_header_t *hdr;
- s = getenv("verify");
- verify = (s && (*s == 'n')) ? 0 : 1;
+ verify = getenv_verify ();
if (argc > 1) {
addr = simple_strtoul(argv[1], NULL, 16);
printf("## Copying from image at %08lx ...\n", addr);
- /* Copy header so we can blank CRC field for re-calculation */
- memmove(&header, (char *) addr, sizeof (image_header_t));
+ hdr = (image_header_t *)addr;
- if (ntohl(header.ih_magic) != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
printf("Bad Magic Number\n");
return 1;
}
- data = (ulong) & header;
- len = sizeof (image_header_t);
-
- checksum = ntohl(header.ih_hcrc);
- header.ih_hcrc = 0;
-
- if (crc32(0, (char *) data, len) != checksum) {
+ if (!image_check_hcrc (hdr)) {
printf("Bad Header Checksum\n");
return 1;
}
#ifdef DEBUG
- print_image_hdr((image_header_t *) addr);
+ print_image_hdr (hdr);
#endif
- data = addr + sizeof (image_header_t);
- len = ntohl(header.ih_size);
-
- if (header.ih_type != IH_TYPE_MULTI) {
+ if (!image_check_type (hdr, IH_TYPE_MULTI)) {
printf("Wrong Image Type for %s command\n", cmdtp->name);
return 1;
}
- if (header.ih_comp != IH_COMP_NONE) {
+ if (image_get_comp (hdr) != IH_COMP_NONE) {
printf("Wrong Compression Type for %s command\n", cmdtp->name);
return 1;
}
if (verify) {
printf(" Verifying Checksum ... ");
- if (crc32(0, (char *) data, len) != ntohl(header.ih_dcrc)) {
+ if (!image_check_dcrc (hdr)) {
printf("Bad Data CRC\n");
return 1;
}
printf("OK\n");
}
+ data = image_get_data (hdr);
len_ptr = (ulong *) data;
data += 4; /* terminator */
data += 4;
if (argc > 2 && part > i) {
u_long tail;
- len = ntohl(len_ptr[i]);
+ len = image_to_cpu (len_ptr[i]);
tail = len % 4;
data += len;
if (tail) {
printf("Bad Image Part\n");
return 1;
}
- len = ntohl(len_ptr[part]);
+ len = image_to_cpu (len_ptr[part]);
if (argc > 3) {
memcpy((char *) dest, (char *) data, len);
--- /dev/null
+/*
+ * (C) Copyright 2008 Semihalf
+ *
+ * (C) Copyright 2000-2006
+ * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+#ifndef USE_HOSTCC
+# include <common.h>
+# include <watchdog.h>
+#else
+# include "mkimage.h"
+#endif
+
+#include <image.h>
+
+unsigned long crc32 (unsigned long, const unsigned char *, unsigned int);
+
+int image_check_hcrc (image_header_t *hdr)
+{
+ ulong hcrc;
+ ulong len = image_get_header_size ();
+ image_header_t header;
+
+ /* Copy header so we can blank CRC field for re-calculation */
+ memmove (&header, (char *)hdr, image_get_header_size ());
+ image_set_hcrc (&header, 0);
+
+ hcrc = crc32 (0, (unsigned char *)&header, len);
+
+ return (hcrc == image_get_hcrc (hdr));
+}
+
+int image_check_dcrc (image_header_t *hdr)
+{
+ ulong data = image_get_data (hdr);
+ ulong len = image_get_data_size (hdr);
+ ulong dcrc = crc32 (0, (unsigned char *)data, len);
+
+ return (dcrc == image_get_dcrc (hdr));
+}
+
+int image_check_dcrc_wd (image_header_t *hdr, ulong chunksz)
+{
+ ulong dcrc = 0;
+ ulong len = image_get_data_size (hdr);
+ ulong data = image_get_data (hdr);
+
+#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
+ ulong cdata = data;
+ ulong edata = cdata + len;
+
+ while (cdata < edata) {
+ ulong chunk = edata - cdata;
+
+ if (chunk > chunksz)
+ chunk = chunksz;
+ dcrc = crc32 (dcrc, (unsigned char *)cdata, chunk);
+ cdata += chunk;
+
+ WATCHDOG_RESET ();
+ }
+#else
+ dcrc = crc32 (0, (unsigned char *)data, len);
+#endif
+
+ return (dcrc == image_get_dcrc (hdr));
+}
+
+int getenv_verify (void)
+{
+ char *s = getenv ("verify");
+ return (s && (*s == 'n')) ? 0 : 1;
+}
#if defined(CONFIG_MPC8260) || defined(CONFIG_440EP) || defined(CONFIG_440GR)
void lynxkdi_boot ( image_header_t *hdr )
{
- void (*lynxkdi)(void) = (void(*)(void)) ntohl(hdr->ih_ep);
+ void (*lynxkdi)(void) = (void(*)(void))image_get_ep (hdr);
lynxos_bootparms_t *parms = (lynxos_bootparms_t *)0x0020;
bd_t *kbd;
- u32 *psz = (u32 *)(ntohl(hdr->ih_load) + 0x0204);
+ u32 *psz = (u32 *)(image_get_load (hdr) + 0x0204);
memset( parms, 0, sizeof(*parms));
kbd = gd->bd;
/* Do a simple check for Bluecat so we can pass the
* kernel command line parameters.
*/
- if( le32_to_cpu(*psz) == ntohl(hdr->ih_size) ){ /* FIXME: NOT SURE HERE ! */
+ if( le32_to_cpu(*psz) == image_get_data_size (hdr) ){ /* FIXME: NOT SURE HERE ! */
char *args;
- char *cmdline = (char *)(ntohl(hdr->ih_load) + 0x020c);
+ char *cmdline = (char *)(image_get_load (hdr) + 0x020c);
int len;
printf("Booting Bluecat KDI ...\n");
* and release the resulting code under the GPL.
*/
-#define _PPC_STRING_H_ /* avoid unnecessary str/mem functions */
-#define _LINUX_STRING_H_ /* avoid unnecessary str/mem functions */
+/* avoid unnecessary memcpy function */
+#define __HAVE_ARCH_MEMCPY
+#define _PPC_STRING_H_
#include <common.h>
#include <exports.h>
/*
+ * (C) Copyright 2008 Semihalf
+ *
* (C) Copyright 2000-2005
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
*
#ifndef __IMAGE_H__
#define __IMAGE_H__
+#include <asm/byteorder.h>
+#ifndef USE_HOSTCC
+#include <linux/string.h>
+#endif
+
/*
* Operating System Codes
*/
/*
* CPU Architecture Codes (supported by Linux)
*/
-#define IH_CPU_INVALID 0 /* Invalid CPU */
-#define IH_CPU_ALPHA 1 /* Alpha */
-#define IH_CPU_ARM 2 /* ARM */
-#define IH_CPU_I386 3 /* Intel x86 */
-#define IH_CPU_IA64 4 /* IA64 */
-#define IH_CPU_MIPS 5 /* MIPS */
-#define IH_CPU_MIPS64 6 /* MIPS 64 Bit */
-#define IH_CPU_PPC 7 /* PowerPC */
-#define IH_CPU_S390 8 /* IBM S390 */
-#define IH_CPU_SH 9 /* SuperH */
-#define IH_CPU_SPARC 10 /* Sparc */
-#define IH_CPU_SPARC64 11 /* Sparc 64 Bit */
-#define IH_CPU_M68K 12 /* M68K */
-#define IH_CPU_NIOS 13 /* Nios-32 */
-#define IH_CPU_MICROBLAZE 14 /* MicroBlaze */
-#define IH_CPU_NIOS2 15 /* Nios-II */
-#define IH_CPU_BLACKFIN 16 /* Blackfin */
-#define IH_CPU_AVR32 17 /* AVR32 */
-#define IH_CPU_ST200 18 /* STMicroelectronics ST200 */
+#define IH_ARCH_INVALID 0 /* Invalid CPU */
+#define IH_ARCH_ALPHA 1 /* Alpha */
+#define IH_ARCH_ARM 2 /* ARM */
+#define IH_ARCH_I386 3 /* Intel x86 */
+#define IH_ARCH_IA64 4 /* IA64 */
+#define IH_ARCH_MIPS 5 /* MIPS */
+#define IH_ARCH_MIPS64 6 /* MIPS 64 Bit */
+#define IH_ARCH_PPC 7 /* PowerPC */
+#define IH_ARCH_S390 8 /* IBM S390 */
+#define IH_ARCH_SH 9 /* SuperH */
+#define IH_ARCH_SPARC 10 /* Sparc */
+#define IH_ARCH_SPARC64 11 /* Sparc 64 Bit */
+#define IH_ARCH_M68K 12 /* M68K */
+#define IH_ARCH_NIOS 13 /* Nios-32 */
+#define IH_ARCH_MICROBLAZE 14 /* MicroBlaze */
+#define IH_ARCH_NIOS2 15 /* Nios-II */
+#define IH_ARCH_BLACKFIN 16 /* Blackfin */
+#define IH_ARCH_AVR32 17 /* AVR32 */
+#define IH_ARCH_ST200 18 /* STMicroelectronics ST200 */
/*
* Image Types
uint8_t ih_name[IH_NMLEN]; /* Image Name */
} image_header_t;
+#define image_to_cpu(x) ntohl(x)
+#define cpu_to_image(x) htonl(x)
+
+static inline uint32_t image_get_header_size (void)
+{
+ return (sizeof (image_header_t));
+}
+
+#define image_get_hdr_l(f) \
+ static inline uint32_t image_get_##f(image_header_t *hdr) \
+ { \
+ return image_to_cpu (hdr->ih_##f); \
+ }
+image_get_hdr_l (magic);
+image_get_hdr_l (hcrc);
+image_get_hdr_l (time);
+image_get_hdr_l (size);
+image_get_hdr_l (load);
+image_get_hdr_l (ep);
+image_get_hdr_l (dcrc);
+
+#define image_get_hdr_b(f) \
+ static inline uint8_t image_get_##f(image_header_t *hdr) \
+ { \
+ return hdr->ih_##f; \
+ }
+image_get_hdr_b (os);
+image_get_hdr_b (arch);
+image_get_hdr_b (type);
+image_get_hdr_b (comp);
+
+static inline char *image_get_name (image_header_t *hdr)
+{
+ return (char *)hdr->ih_name;
+}
+
+static inline uint32_t image_get_data_size (image_header_t *hdr)
+{
+ return image_get_size (hdr);
+}
+static inline uint32_t image_get_image_size (image_header_t *hdr)
+{
+ return (image_get_size (hdr) + image_get_header_size ());
+}
+static inline ulong image_get_data (image_header_t *hdr)
+{
+ return ((ulong)hdr + image_get_header_size ());
+}
+
+#define image_set_hdr_l(f) \
+ static inline void image_set_##f(image_header_t *hdr, uint32_t val) \
+ { \
+ hdr->ih_##f = cpu_to_image (val); \
+ }
+image_set_hdr_l (magic);
+image_set_hdr_l (hcrc);
+image_set_hdr_l (time);
+image_set_hdr_l (size);
+image_set_hdr_l (load);
+image_set_hdr_l (ep);
+image_set_hdr_l (dcrc);
+
+#define image_set_hdr_b(f) \
+ static inline void image_set_##f(image_header_t *hdr, uint8_t val) \
+ { \
+ hdr->ih_##f = val; \
+ }
+image_set_hdr_b (os);
+image_set_hdr_b (arch);
+image_set_hdr_b (type);
+image_set_hdr_b (comp);
+
+static inline void image_set_name (image_header_t *hdr, const char *name)
+{
+ strncpy (image_get_name (hdr), name, IH_NMLEN);
+}
+
+int image_check_hcrc (image_header_t *hdr);
+int image_check_dcrc (image_header_t *hdr);
+int image_check_dcrc_wd (image_header_t *hdr, ulong chunksize);
+int getenv_verify (void);
+
+static inline int image_check_magic (image_header_t *hdr)
+{
+ return (image_get_magic (hdr) == IH_MAGIC);
+}
+static inline int image_check_type (image_header_t *hdr, uint8_t type)
+{
+ return (image_get_type (hdr) == type);
+}
+static inline int image_check_arch (image_header_t *hdr, uint8_t arch)
+{
+ return (image_get_arch (hdr) == arch);
+}
+static inline int image_check_os (image_header_t *hdr, uint8_t os)
+{
+ return (image_get_os (hdr) == os);
+}
+
+#ifndef USE_HOSTCC
+static inline int image_check_target_arch (image_header_t *hdr)
+{
+#if defined(__ARM__)
+ if (!image_check_arch (hdr, IH_ARCH_ARM))
+#elif defined(__avr32__)
+ if (!image_check_arch (hdr, IH_ARCH_AVR32))
+#elif defined(__bfin__)
+ if (!image_check_arch (hdr, IH_ARCH_BLACKFIN))
+#elif defined(__I386__)
+ if (!image_check_arch (hdr, IH_ARCH_I386))
+#elif defined(__M68K__)
+ if (!image_check_arch (hdr, IH_ARCH_M68K))
+#elif defined(__microblaze__)
+ if (!image_check_arch (hdr, IH_ARCH_MICROBLAZE))
+#elif defined(__mips__)
+ if (!image_check_arch (hdr, IH_ARCH_MIPS))
+#elif defined(__nios__)
+ if (!image_check_arch (hdr, IH_ARCH_NIOS))
+#elif defined(__nios2__)
+ if (!image_check_arch (hdr, IH_ARCH_NIOS2))
+#elif defined(__PPC__)
+ if (!image_check_arch (hdr, IH_ARCH_PPC))
+#elif defined(__sh__)
+ if (!image_check_arch (hdr, IH_ARCH_SH))
+#else
+# error Unknown CPU type
+#endif
+ return 0;
+
+ return 1;
+}
+#endif
-#endif /* __IMAGE_H__ */
+#endif /* __IMAGE_H__ */
void do_bootm_linux (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
ulong addr, ulong *len_ptr, int verify)
{
- ulong len = 0, checksum;
+ ulong len = 0;
ulong initrd_start, initrd_end;
ulong data;
void (*theKernel)(int zero, int arch, uint params);
char *commandline = getenv ("bootargs");
#endif
- theKernel = (void (*)(int, int, uint))ntohl(hdr->ih_ep);
+ theKernel = (void (*)(int, int, uint))image_get_ep (hdr);
/*
* Check if there is an initrd image
/* Copy header so we can blank CRC field for re-calculation */
#ifdef CONFIG_HAS_DATAFLASH
if (addr_dataflash (addr)) {
- read_dataflash (addr, sizeof (image_header_t),
+ read_dataflash (addr, image_get_header_size (),
(char *) &header);
} else
#endif
memcpy (&header, (char *) addr,
- sizeof (image_header_t));
+ image_get_header_size ());
- if (ntohl (hdr->ih_magic) != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
printf ("Bad Magic Number\n");
show_boot_progress (-10);
do_reset (cmdtp, flag, argc, argv);
}
- data = (ulong) & header;
- len = sizeof (image_header_t);
-
- checksum = ntohl (hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32 (0, (unsigned char *) data, len) != checksum) {
+ if (!image_check_hcrc (hdr)) {
printf ("Bad Header Checksum\n");
show_boot_progress (-11);
do_reset (cmdtp, flag, argc, argv);
print_image_hdr (hdr);
- data = addr + sizeof (image_header_t);
- len = ntohl (hdr->ih_size);
+ data = image_get_data (hdr);
+ len = image_get_data_size (hdr);
#ifdef CONFIG_HAS_DATAFLASH
if (addr_dataflash (addr)) {
#endif
if (verify) {
- ulong csum = 0;
-
printf (" Verifying Checksum ... ");
- csum = crc32 (0, (unsigned char *) data, len);
- if (csum != ntohl (hdr->ih_dcrc)) {
+ if (!image_get_dcrc (hdr)) {
printf ("Bad Data CRC\n");
show_boot_progress (-12);
do_reset (cmdtp, flag, argc, argv);
show_boot_progress (11);
- if ((hdr->ih_os != IH_OS_LINUX) ||
- (hdr->ih_arch != IH_CPU_ARM) ||
- (hdr->ih_type != IH_TYPE_RAMDISK)) {
+ if (!image_check_os (hdr, IH_OS_LINUX) ||
+ !image_check_arch (hdr, IH_ARCH_ARM) ||
+ !image_check_type (hdr, IH_TYPE_RAMDISK)) {
printf ("No Linux ARM Ramdisk Image\n");
show_boot_progress (-13);
do_reset (cmdtp, flag, argc, argv);
/*
*we need to copy the ramdisk to SRAM to let Linux boot
*/
- memmove ((void *) ntohl(hdr->ih_load), (uchar *)data, len);
- data = ntohl(hdr->ih_load);
+ memmove ((void *)image_get_load (hdr), (uchar *)data, len);
+ data = image_get_load (hdr);
#endif /* CONFIG_B2 || CONFIG_EVB4510 */
/*
* Now check if we have a multifile image
*/
- } else if ((hdr->ih_type == IH_TYPE_MULTI) && (len_ptr[1])) {
- ulong tail = ntohl (len_ptr[0]) % 4;
+ } else if (image_check_type (hdr, IH_TYPE_MULTI) && (len_ptr[1])) {
+ ulong tail = image_to_cpu (len_ptr[0]) % 4;
int i;
show_boot_progress (13);
for (i = 1; len_ptr[i]; ++i)
data += 4;
/* add kernel length, and align */
- data += ntohl (len_ptr[0]);
+ data += image_to_cpu (len_ptr[0]);
if (tail) {
data += 4 - tail;
}
- len = ntohl (len_ptr[1]);
+ len = image_to_cpu (len_ptr[1]);
} else {
/*
/* CPU-specific hook to allow flushing of caches, etc. */
extern void prepare_to_boot(void);
-extern image_header_t header; /* from cmd_bootm.c */
-
static struct tag *setup_start_tag(struct tag *params)
{
params->hdr.tag = ATAG_CORE;
unsigned long data, len = 0;
unsigned long initrd_start, initrd_end;
unsigned long image_start, image_end;
- unsigned long checksum;
void (*theKernel)(int magic, void *tagtable);
image_header_t *hdr;
struct tag *params, *params_start;
hdr = (image_header_t *)addr;
image_start = addr;
- image_end = addr + hdr->ih_size;
+ image_end = addr + image_get_data_size (hdr);
- theKernel = (void *)ntohl(hdr->ih_ep);
+ theKernel = (void *)image_get_ep (hdr);
/*
* Check if there is an initrd image
show_boot_progress (9);
addr = simple_strtoul(argv[2], NULL, 16);
+ hdr = (image_header_t *)addr;
printf("## Loading RAMDISK image at %08lx ...\n", addr);
- memcpy(&header, (char *)addr, sizeof(header));
- hdr = &header;
-
- if (ntohl(hdr->ih_magic) != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
puts("Bad Magic Number\n");
show_boot_progress (-10);
do_reset(cmdtp, flag, argc, argv);
}
- data = (unsigned long)hdr;
- len = sizeof(*hdr);
- checksum = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32(0, (unsigned char *)data, len) != checksum) {
+ if (!image_check_hcrc (hdr)) {
puts("Bad Header Checksum\n");
show_boot_progress (-11);
do_reset(cmdtp, flag, argc, argv);
}
show_boot_progress (10);
-
- print_image_hdr(hdr);
-
- data = addr + sizeof(header);
- len = ntohl(hdr->ih_size);
+ print_image_hdr (hdr);
if (verify) {
- unsigned long csum = 0;
-
puts(" Verifying Checksum ... ");
- csum = crc32(0, (unsigned char *)data, len);
- if (csum != ntohl(hdr->ih_dcrc)) {
+ if (!image_check_dcrc (hdr)) {
puts("Bad Data CRC\n");
show_boot_progress (-12);
do_reset(cmdtp, flag, argc, argv);
show_boot_progress (11);
- if ((hdr->ih_os != IH_OS_LINUX) ||
- (hdr->ih_arch != IH_CPU_AVR32) ||
- (hdr->ih_type != IH_TYPE_RAMDISK)) {
+ if (!image_check_os (hdr, IH_OS_LINUX) ||
+ !image_check_arch (hdr, IH_ARCH_AVR32) ||
+ !image_check_type (hdr, IH_TYPE_RAMDISK)) {
puts("Not a Linux/AVR32 RAMDISK image\n");
show_boot_progress (-13);
do_reset(cmdtp, flag, argc, argv);
}
- } else if ((hdr->ih_type == IH_TYPE_MULTI) && (len_ptr[1])) {
- ulong tail = ntohl (len_ptr[0]) % 4;
+
+ data = image_get_data (hdr);
+ len = image_get_data_size (hdr);
+
+ } else if (image_check_type (hdr, IH_TYPE_MULTI) && (len_ptr[1])) {
+ ulong tail = image_to_cpu (len_ptr[0]) % 4;
int i;
show_boot_progress (13);
for (i = 1; len_ptr[i]; ++i)
data += 4;
/* add kernel length, and align */
- data += ntohl (len_ptr[0]);
+ data += image_to_cpu (len_ptr[0]);
if (tail) {
data += 4 - tail;
}
- len = ntohl (len_ptr[1]);
+ len = image_to_cpu (len_ptr[1]);
} else {
/* no initrd image */
show_boot_progress (14);
{
int (*appl) (char *cmdline);
char *cmdline;
+ image_header_t *hdr = &header;
#ifdef SHARED_RESOURCES
swap_to(FLASH);
#endif
- appl = (int (*)(char *))ntohl(header.ih_ep);
+ appl = (int (*)(char *))image_get_ep (hdr);
printf("Starting Kernel at = %x\n", appl);
cmdline = make_command_line();
if (icache_status()) {
{
void *base_ptr;
- ulong len = 0, checksum;
+ ulong len = 0;
ulong initrd_start, initrd_end;
ulong data;
image_header_t *hdr = &header;
*/
if (argc >= 3) {
addr = simple_strtoul(argv[2], NULL, 16);
+ hdr = (image_header_t *)addr;
printf ("## Loading Ramdisk Image at %08lx ...\n", addr);
- /* Copy header so we can blank CRC field for re-calculation */
- memcpy (&header, (char *)addr, sizeof(image_header_t));
-
- if (ntohl(hdr->ih_magic) != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
printf ("Bad Magic Number\n");
do_reset (cmdtp, flag, argc, argv);
}
- data = (ulong)&header;
- len = sizeof(image_header_t);
-
- checksum = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32 (0, (char *)data, len) != checksum) {
+ if (!image_check_hcrc (hdr)) {
printf ("Bad Header Checksum\n");
do_reset (cmdtp, flag, argc, argv);
}
print_image_hdr (hdr);
- data = addr + sizeof(image_header_t);
- len = ntohl(hdr->ih_size);
+ data = image_get_data (hdr);
+ len = image_get_data_size (hdr);
if (verify) {
- ulong csum = 0;
-
printf (" Verifying Checksum ... ");
- csum = crc32 (0, (char *)data, len);
- if (csum != ntohl(hdr->ih_dcrc)) {
+ if (!image_check_dcrc (hdr)) {
printf ("Bad Data CRC\n");
do_reset (cmdtp, flag, argc, argv);
}
printf ("OK\n");
}
- if ((hdr->ih_os != IH_OS_LINUX) ||
- (hdr->ih_arch != IH_CPU_I386) ||
- (hdr->ih_type != IH_TYPE_RAMDISK) ) {
+ if (!image_check_os (hdr, IH_OS_LINUX) ||
+ !image_check_arch (hdr, IH_ARCH_I386) ||
+ !image_check_type (hdr, IH_TYPE_RAMDISK)) {
printf ("No Linux i386 Ramdisk Image\n");
do_reset (cmdtp, flag, argc, argv);
}
/*
* Now check if we have a multifile image
*/
- } else if ((hdr->ih_type==IH_TYPE_MULTI) && (len_ptr[1])) {
- ulong tail = ntohl(len_ptr[0]) % 4;
+ } else if (image_check_type (hdr, IH_TYPE_MULTI) && (len_ptr[1])) {
+ ulong tail = image_to_cpu (len_ptr[0]) % 4;
int i;
/* skip kernel length and terminator */
for (i=1; len_ptr[i]; ++i)
data += 4;
/* add kernel length, and align */
- data += ntohl(len_ptr[0]);
+ data += image_to_cpu (len_ptr[0]);
if (tail) {
data += 4 - tail;
}
- len = ntohl(len_ptr[1]);
+ len = image_to_cpu (len_ptr[1]);
} else {
/*
}
/* if multi-part image, we need to advance base ptr */
- if ((hdr->ih_type==IH_TYPE_MULTI) && (len_ptr[1])) {
+ if (image_check_type (hdr, IH_TYPE_MULTI) && (len_ptr[1])) {
int i;
for (i=0, addr+=sizeof(int); len_ptr[i++]; addr+=sizeof(int));
}
- base_ptr = load_zimage((void*)addr + sizeof(image_header_t), ntohl(hdr->ih_size),
+ base_ptr = load_zimage((void*)addr + image_get_header_size (),
+ image_get_data_size (hdr),
initrd_start, initrd_end-initrd_start, 0);
if (NULL == base_ptr) {
#else
checksum = 0;
#endif
- memset(hdr, 0, sizeof(image_header_t));
+ memset(hdr, 0, image_get_header_size ());
/* Build new header */
- hdr->ih_magic = htonl(IH_MAGIC);
- hdr->ih_time = 0;
- hdr->ih_size = htonl(size);
- hdr->ih_load = htonl(ZIMAGE_LOAD);
- hdr->ih_ep = 0;
- hdr->ih_dcrc = htonl(checksum);
- hdr->ih_os = IH_OS_LINUX;
- hdr->ih_arch = IH_CPU_I386;
- hdr->ih_type = IH_TYPE_KERNEL;
- hdr->ih_comp = IH_COMP_NONE;
-
- strncpy((char *)hdr->ih_name, "(none)", IH_NMLEN);
-
- checksum = crc32(0,(const char *)hdr,sizeof(image_header_t));
-
- hdr->ih_hcrc = htonl(checksum);
+ image_set_magic (hdr, IH_MAGIC);
+ image_set_time (hdr, 0);
+ image_set_size (hdr, size);
+ image_set_load (hdr, ZIMAGE_LOAD);
+ image_set_ep (hdr, 0);
+ image_set_dcrc (hdr, checksum);
+ image_set_os (hdr, IH_OS_LINUX);
+ image_set_arch (hdr, IH_ARCH_I386);
+ image_set_type (hdr, IH_TYPE_KERNEL);
+ image_set_comp (hdr, IH_COMP_NONE);
+
+ image_set_name (hdr, "(none)");
+
+ checksum = crc32 (0, (const char *)hdr, image_get_header_size ());
+ image_set_hcrc (hdr, checksum);
return hdr;
}
extern image_header_t header;
+int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
+
void do_bootm_linux(cmd_tbl_t * cmdtp, int flag,
int argc, char *argv[],
ulong addr, ulong * len_ptr, int verify)
{
ulong sp;
- ulong len, checksum;
+ ulong len;
ulong initrd_start, initrd_end;
ulong cmd_start, cmd_end;
ulong initrd_high;
}
kernel =
- (void (*)(bd_t *, ulong, ulong, ulong, ulong))ntohl(hdr->ih_ep);
+ (void (*)(bd_t *, ulong, ulong, ulong, ulong))image_get_ep (hdr);
/*
* Check if there is an initrd image
SHOW_BOOT_PROGRESS(9);
addr = simple_strtoul(argv[2], NULL, 16);
+ hdr = (image_header_t *)addr;
printf("## Loading RAMDisk Image at %08lx ...\n", addr);
- /* Copy header so we can blank CRC field for re-calculation */
- memmove(&header, (char *)addr, sizeof(image_header_t));
-
- if (ntohl(hdr->ih_magic) != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
puts("Bad Magic Number\n");
SHOW_BOOT_PROGRESS(-10);
do_reset(cmdtp, flag, argc, argv);
}
- data = (ulong) & header;
- len = sizeof(image_header_t);
-
- checksum = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32(0, (uchar *) data, len) != checksum) {
+ if (!image_check_hcrc (hdr)) {
puts("Bad Header Checksum\n");
SHOW_BOOT_PROGRESS(-11);
do_reset(cmdtp, flag, argc, argv);
SHOW_BOOT_PROGRESS(10);
- print_image_hdr(hdr);
+ print_image_hdr (hdr);
- data = addr + sizeof(image_header_t);
- len = ntohl(hdr->ih_size);
+ data = image_get_data (hdr);
+ len = image_get_data_size (hdr);
if (verify) {
- ulong csum = 0;
-#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
- ulong cdata = data, edata = cdata + len;
-#endif /* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */
-
puts(" Verifying Checksum ... ");
-
-#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
-
- while (cdata < edata) {
- ulong chunk = edata - cdata;
-
- if (chunk > CHUNKSZ)
- chunk = CHUNKSZ;
- csum = crc32(csum, (uchar *) cdata, chunk);
- cdata += chunk;
-
- WATCHDOG_RESET();
- }
-#else /* !(CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG) */
- csum = crc32(0, (uchar *) data, len);
-#endif /* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */
-
- if (csum != ntohl(hdr->ih_dcrc)) {
+ if (!image_check_dcrc_wd (hdr, CHUNKSZ)) {
puts("Bad Data CRC\n");
SHOW_BOOT_PROGRESS(-12);
do_reset(cmdtp, flag, argc, argv);
SHOW_BOOT_PROGRESS(11);
- if ((hdr->ih_os != IH_OS_LINUX) ||
- (hdr->ih_arch != IH_CPU_M68K) ||
- (hdr->ih_type != IH_TYPE_RAMDISK)) {
+ if (!image_check_os (hdr, IH_OS_LINUX) ||
+ !image_check_arch (hdr, IH_ARCH_M68K) ||
+ !image_check_type (hdr, IH_TYPE_RAMDISK)) {
puts("No Linux ColdFire Ramdisk Image\n");
SHOW_BOOT_PROGRESS(-13);
do_reset(cmdtp, flag, argc, argv);
/*
* Now check if we have a multifile image
*/
- } else if ((hdr->ih_type == IH_TYPE_MULTI) && (len_ptr[1])) {
- u_long tail = ntohl(len_ptr[0]) % 4;
+ } else if (image_check_type (hdr, IH_TYPE_MULTI) && (len_ptr[1])) {
+ u_long tail = image_to_cpu (len_ptr[0]) % 4;
int i;
SHOW_BOOT_PROGRESS(13);
for (i = 1; len_ptr[i]; ++i)
data += 4;
/* add kernel length, and align */
- data += ntohl(len_ptr[0]);
+ data += image_to_cpu (len_ptr[0]);
if (tail) {
data += 4 - tail;
}
- len = ntohl(len_ptr[1]);
+ len = image_to_cpu (len_ptr[1]);
} else {
/*
char *commandline = getenv ("bootargs");
int i;
- theKernel = (void (*)(char *))ntohl (hdr->ih_ep);
+ theKernel = (void (*)(char *))image_get_ep (hdr);
/* Check if there is an initrd image */
if (argc >= 3) {
show_boot_progress (9);
addr = simple_strtoul (argv[2], NULL, 16);
+ hdr = (image_header_t *)addr;
printf ("## Loading Ramdisk Image at %08lx ...\n", addr);
- /* Copy header so we can blank CRC field for re-calculation */
- memcpy (&header, (char *)addr, sizeof (image_header_t));
-
- if (ntohl (hdr->ih_magic) != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
printf ("Bad Magic Number\n");
show_boot_progress (-10);
do_reset (cmdtp, flag, argc, argv);
}
- data = (ulong) & header;
- len = sizeof (image_header_t);
-
- checksum = ntohl (hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32 (0, (char *)data, len) != checksum) {
+ if (!image_check_magic (hdr)) {
printf ("Bad Header Checksum\n");
show_boot_progress (-11);
do_reset (cmdtp, flag, argc, argv);
print_image_hdr (hdr);
- data = addr + sizeof (image_header_t);
- len = ntohl (hdr->ih_size);
+ data = image_get_data (hdr);
+ len = image_get_data_size (hdr);
if (verify) {
- ulong csum = 0;
-
printf (" Verifying Checksum ... ");
- csum = crc32 (0, (char *)data, len);
- if (csum != ntohl (hdr->ih_dcrc)) {
+ if (!image_check_dcrc (hdr)) {
printf ("Bad Data CRC\n");
show_boot_progress (-12);
do_reset (cmdtp, flag, argc, argv);
show_boot_progress (11);
- if ((hdr->ih_os != IH_OS_LINUX) ||
- (hdr->ih_arch != IH_CPU_MICROBLAZE) ||
- (hdr->ih_type != IH_TYPE_RAMDISK)) {
+ if (!image_check_os (hdr, IH_OS_LINUX) ||
+ !image_check_arch (hdr, IH_ARCH_MICROBLAZE) ||
+ !image_check_type (hdr, IH_TYPE_RAMDISK)) {
printf ("No Linux Microblaze Ramdisk Image\n");
show_boot_progress (-13);
do_reset (cmdtp, flag, argc, argv);
/*
* Now check if we have a multifile image
*/
- } else if ((hdr->ih_type == IH_TYPE_MULTI) && (len_ptr[1])) {
- ulong tail = ntohl (len_ptr[0]) % 4;
+ } else if (image_check_type (hdr, IH_TYPE_MULTI) && (len_ptr[1])) {
+ ulong tail = image_to_cpu (len_ptr[0]) % 4;
show_boot_progress (13);
for (i = 1; len_ptr[i]; ++i)
data += 4;
/* add kernel length, and align */
- data += ntohl (len_ptr[0]);
+ data += image_to_cpu (len_ptr[0]);
if (tail) {
data += 4 - tail;
}
- len = ntohl (len_ptr[1]);
+ len = image_to_cpu (len_ptr[1]);
} else {
/*
void do_bootm_linux (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[],
ulong addr, ulong * len_ptr, int verify)
{
- ulong len = 0, checksum;
+ ulong len = 0;
ulong initrd_start, initrd_end;
ulong data;
void (*theKernel) (int, char **, char **, int *);
char env_buf[12];
theKernel =
- (void (*)(int, char **, char **, int *)) ntohl (hdr->ih_ep);
+ (void (*)(int, char **, char **, int *))image_get_ep (hdr);
/*
* Check if there is an initrd image
show_boot_progress (9);
addr = simple_strtoul (argv[2], NULL, 16);
+ hdr = (image_header_t *)addr;
printf ("## Loading Ramdisk Image at %08lx ...\n", addr);
- /* Copy header so we can blank CRC field for re-calculation */
- memcpy (&header, (char *) addr, sizeof (image_header_t));
-
- if (ntohl (hdr->ih_magic) != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
printf ("Bad Magic Number\n");
show_boot_progress (-10);
do_reset (cmdtp, flag, argc, argv);
}
- data = (ulong) & header;
- len = sizeof (image_header_t);
-
- checksum = ntohl (hdr->ih_hcrc);
- hdr->ih_hcrc = 0;
-
- if (crc32 (0, (uchar *) data, len) != checksum) {
+ if (!image_check_hcrc (hdr)) {
printf ("Bad Header Checksum\n");
show_boot_progress (-11);
do_reset (cmdtp, flag, argc, argv);
print_image_hdr (hdr);
- data = addr + sizeof (image_header_t);
- len = ntohl (hdr->ih_size);
+ data = image_get_data (hdr);
+ len = image_get_data_size (hdr);
if (verify) {
- ulong csum = 0;
-
printf (" Verifying Checksum ... ");
- csum = crc32 (0, (uchar *) data, len);
- if (csum != ntohl (hdr->ih_dcrc)) {
+ if (!image_check_dcrc (hdr)) {
printf ("Bad Data CRC\n");
show_boot_progress (-12);
do_reset (cmdtp, flag, argc, argv);
show_boot_progress (11);
- if ((hdr->ih_os != IH_OS_LINUX) ||
- (hdr->ih_arch != IH_CPU_MIPS) ||
- (hdr->ih_type != IH_TYPE_RAMDISK)) {
+ if (!image_check_os (hdr, IH_OS_LINUX) ||
+ !image_check_arch (hdr, IH_ARCH_MIPS) ||
+ !image_check_type (hdr, IH_TYPE_RAMDISK)) {
printf ("No Linux MIPS Ramdisk Image\n");
show_boot_progress (-13);
do_reset (cmdtp, flag, argc, argv);
/*
* Now check if we have a multifile image
*/
- } else if ((hdr->ih_type == IH_TYPE_MULTI) && (len_ptr[1])) {
- ulong tail = ntohl (len_ptr[0]) % 4;
+ } else if (image_check_type (hdr, IH_TYPE_MULTI) && (len_ptr[1])) {
+ ulong tail = image_to_cpu (len_ptr[0]) % 4;
int i;
show_boot_progress (13);
for (i = 1; len_ptr[i]; ++i)
data += 4;
/* add kernel length, and align */
- data += ntohl (len_ptr[0]);
+ data += image_to_cpu (len_ptr[0]);
if (tail) {
data += 4 - tail;
}
- len = ntohl (len_ptr[1]);
+ len = image_to_cpu (len_ptr[1]);
} else {
/*
ulong addr, ulong *len_ptr, int verify)
{
image_header_t *hdr = &header;
- void (*kernel)(void) = (void (*)(void))ntohl (hdr->ih_ep);
+ void (*kernel)(void) = (void (*)(void))image_get_ep (hdr);
/* For now we assume the Microtronix linux ... which only
* needs to be called ;-)
BIN_FILES = img2srec$(SFX) mkimage$(SFX) envcrc$(SFX) ubsha1$(SFX) gen_eth_addr$(SFX) bmp_logo$(SFX)
-OBJ_LINKS = environment.o crc32.o sha1.o
+OBJ_LINKS = environment.o crc32.o sha1.o image.o
OBJ_FILES = img2srec.o mkimage.o envcrc.o ubsha1.o gen_eth_addr.o bmp_logo.o
ifeq ($(ARCH),mips)
$(CC) $(CFLAGS) $(HOST_LDFLAGS) -o $@ $^
$(STRIP) $@
-$(obj)mkimage$(SFX): $(obj)mkimage.o $(obj)crc32.o
+$(obj)mkimage$(SFX): $(obj)mkimage.o $(obj)crc32.o $(obj)image.o
$(CC) $(CFLAGS) $(HOST_LDFLAGS) -o $@ $^
$(STRIP) $@
$(obj)sha1.o: $(obj)sha1.c
$(CC) -g $(CFLAGS) -c -o $@ $<
+$(obj)image.o: $(obj)image.c
+ $(CC) -g $(CFLAGS) -c -o $@ $<
+
$(obj)mkimage.o: $(src)mkimage.c
$(CC) -g $(CFLAGS) -c -o $@ $<
@rm -f $(obj)sha1.c
ln -s $(src)../lib_generic/sha1.c $(obj)sha1.c
+$(obj)image.c:
+ @rm -f $(obj)image.c
+ ln -s $(src)../common/image.c $(obj)image.c
+
$(LOGO_H): $(obj)bmp_logo $(LOGO_BMP)
$(obj)./bmp_logo $(LOGO_BMP) >$@
* MA 02111-1307 USA
*/
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#ifndef __WIN32__
-#include <netinet/in.h> /* for host / network byte order conversions */
-#endif
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <time.h>
-#include <unistd.h>
-
-#if defined(__BEOS__) || defined(__NetBSD__) || defined(__APPLE__)
-#include <inttypes.h>
-#endif
-
-#ifdef __WIN32__
-typedef unsigned int __u32;
-
-#define SWAP_LONG(x) \
- ((__u32)( \
- (((__u32)(x) & (__u32)0x000000ffUL) << 24) | \
- (((__u32)(x) & (__u32)0x0000ff00UL) << 8) | \
- (((__u32)(x) & (__u32)0x00ff0000UL) >> 8) | \
- (((__u32)(x) & (__u32)0xff000000UL) >> 24) ))
-typedef unsigned char uint8_t;
-typedef unsigned short uint16_t;
-typedef unsigned int uint32_t;
-
-#define ntohl(a) SWAP_LONG(a)
-#define htonl(a) SWAP_LONG(a)
-#endif /* __WIN32__ */
-
-#ifndef O_BINARY /* should be define'd on __WIN32__ */
-#define O_BINARY 0
-#endif
-
+#include "mkimage.h"
#include <image.h>
extern int errno;
} table_entry_t;
table_entry_t arch_name[] = {
- { IH_CPU_INVALID, NULL, "Invalid CPU", },
- { IH_CPU_ALPHA, "alpha", "Alpha", },
- { IH_CPU_ARM, "arm", "ARM", },
- { IH_CPU_I386, "x86", "Intel x86", },
- { IH_CPU_IA64, "ia64", "IA64", },
- { IH_CPU_M68K, "m68k", "MC68000", },
- { IH_CPU_MICROBLAZE, "microblaze", "MicroBlaze", },
- { IH_CPU_MIPS, "mips", "MIPS", },
- { IH_CPU_MIPS64, "mips64", "MIPS 64 Bit", },
- { IH_CPU_NIOS, "nios", "NIOS", },
- { IH_CPU_NIOS2, "nios2", "NIOS II", },
- { IH_CPU_PPC, "ppc", "PowerPC", },
- { IH_CPU_S390, "s390", "IBM S390", },
- { IH_CPU_SH, "sh", "SuperH", },
- { IH_CPU_SPARC, "sparc", "SPARC", },
- { IH_CPU_SPARC64, "sparc64", "SPARC 64 Bit", },
- { IH_CPU_BLACKFIN, "blackfin", "Blackfin", },
- { IH_CPU_AVR32, "avr32", "AVR32", },
+ { IH_ARCH_INVALID, NULL, "Invalid CPU", },
+ { IH_ARCH_ALPHA, "alpha", "Alpha", },
+ { IH_ARCH_ARM, "arm", "ARM", },
+ { IH_ARCH_I386, "x86", "Intel x86", },
+ { IH_ARCH_IA64, "ia64", "IA64", },
+ { IH_ARCH_M68K, "m68k", "MC68000", },
+ { 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, "ppc", "PowerPC", },
+ { IH_ARCH_S390, "s390", "IBM S390", },
+ { IH_ARCH_SH, "sh", "SuperH", },
+ { IH_ARCH_SPARC, "sparc", "SPARC", },
+ { IH_ARCH_SPARC64, "sparc64", "SPARC 64 Bit", },
+ { IH_ARCH_BLACKFIN, "blackfin", "Blackfin", },
+ { IH_ARCH_AVR32, "avr32", "AVR32", },
{ -1, "", "", },
};
int vflag = 0;
int xflag = 0;
int opt_os = IH_OS_LINUX;
-int opt_arch = IH_CPU_PPC;
+int opt_arch = IH_ARCH_PPC;
int opt_type = IH_TYPE_KERNEL;
int opt_comp = IH_COMP_GZIP;
ep = addr;
/* If XIP, entry point must be after the U-Boot header */
if (xflag)
- ep += sizeof(image_header_t);
+ ep += image_get_header_size ();
}
/*
* the size of the U-Boot header.
*/
if (xflag) {
- if (ep != addr + sizeof(image_header_t)) {
+ if (ep != addr + image_get_header_size ()) {
fprintf (stderr,
"%s: For XIP, the entry point must be the load addr + %lu\n",
cmdname,
- (unsigned long)sizeof(image_header_t));
+ (unsigned long)image_get_header_size ());
exit (EXIT_FAILURE);
}
}
exit (EXIT_FAILURE);
}
- if ((unsigned)sbuf.st_size < sizeof(image_header_t)) {
+ if ((unsigned)sbuf.st_size < image_get_header_size ()) {
fprintf (stderr,
"%s: Bad size: \"%s\" is no valid image\n",
cmdname, imagefile);
}
/*
- * create copy of header so that we can blank out the
- * checksum field for checking - this can't be done
- * on the PROT_READ mapped data.
+ * image_check_hcrc() creates copy of header so that
+ * we can blank out the checksum field for checking -
+ * this can't be done on the PROT_READ mapped data.
*/
- memcpy (hdr, ptr, sizeof(image_header_t));
+ hdr = (image_header_t *)ptr;
- if (ntohl(hdr->ih_magic) != IH_MAGIC) {
+ if (!image_check_magic (hdr)) {
fprintf (stderr,
"%s: Bad Magic Number: \"%s\" is no valid image\n",
cmdname, imagefile);
exit (EXIT_FAILURE);
}
- data = (char *)hdr;
- len = sizeof(image_header_t);
-
- checksum = ntohl(hdr->ih_hcrc);
- hdr->ih_hcrc = htonl(0); /* clear for re-calculation */
-
- if (crc32 (0, data, len) != checksum) {
+ if (!image_check_hcrc (hdr)) {
fprintf (stderr,
"%s: ERROR: \"%s\" has bad header checksum!\n",
cmdname, imagefile);
exit (EXIT_FAILURE);
}
- data = (char *)(ptr + sizeof(image_header_t));
- len = sbuf.st_size - sizeof(image_header_t) ;
+ data = (char *)image_get_data (hdr);
+ len = sbuf.st_size - image_get_header_size ();
- if (crc32 (0, data, len) != ntohl(hdr->ih_dcrc)) {
+ if (crc32(0, data, len) != image_get_dcrc (hdr)) {
fprintf (stderr,
"%s: ERROR: \"%s\" has corrupted data!\n",
cmdname, imagefile);
*
* write dummy header, to be fixed later
*/
- memset (hdr, 0, sizeof(image_header_t));
+ memset (hdr, 0, image_get_header_size ());
- if (write(ifd, hdr, sizeof(image_header_t)) != sizeof(image_header_t)) {
+ if (write(ifd, hdr, image_get_header_size ()) != image_get_header_size ()) {
fprintf (stderr, "%s: Write error on %s: %s\n",
cmdname, imagefile, strerror(errno));
exit (EXIT_FAILURE);
cmdname, file, strerror(errno));
exit (EXIT_FAILURE);
}
- size = htonl(sbuf.st_size);
+ size = cpu_to_image (sbuf.st_size);
} else {
size = 0;
}
hdr = (image_header_t *)ptr;
checksum = crc32 (0,
- (const char *)(ptr + sizeof(image_header_t)),
- sbuf.st_size - sizeof(image_header_t)
+ (const char *)(ptr + image_get_header_size ()),
+ sbuf.st_size - image_get_header_size ()
);
/* Build new header */
- hdr->ih_magic = htonl(IH_MAGIC);
- hdr->ih_time = htonl(sbuf.st_mtime);
- hdr->ih_size = htonl(sbuf.st_size - sizeof(image_header_t));
- hdr->ih_load = htonl(addr);
- hdr->ih_ep = htonl(ep);
- hdr->ih_dcrc = htonl(checksum);
- hdr->ih_os = opt_os;
- hdr->ih_arch = opt_arch;
- hdr->ih_type = opt_type;
- hdr->ih_comp = opt_comp;
+ image_set_magic (hdr, IH_MAGIC);
+ image_set_time (hdr, sbuf.st_mtime);
+ image_set_size (hdr, sbuf.st_size - image_get_header_size ());
+ image_set_load (hdr, addr);
+ image_set_ep (hdr, ep);
+ image_set_dcrc (hdr, checksum);
+ image_set_os (hdr, opt_os);
+ image_set_arch (hdr, opt_arch);
+ image_set_type (hdr, opt_type);
+ image_set_comp (hdr, opt_comp);
- strncpy((char *)hdr->ih_name, name, IH_NMLEN);
+ image_set_name (hdr, name);
- checksum = crc32(0,(const char *)hdr,sizeof(image_header_t));
+ checksum = crc32 (0, (const char *)hdr, image_get_header_size ());
- hdr->ih_hcrc = htonl(checksum);
+ image_set_hcrc (hdr, checksum);
print_header (hdr);
* reserved for it.
*/
- if ((unsigned)sbuf.st_size < sizeof(image_header_t)) {
+ if ((unsigned)sbuf.st_size < image_get_header_size ()) {
fprintf (stderr,
"%s: Bad size: \"%s\" is too small for XIP\n",
cmdname, datafile);
exit (EXIT_FAILURE);
}
- for (p=ptr; p < ptr+sizeof(image_header_t); p++) {
+ for (p = ptr; p < ptr + image_get_header_size (); p++) {
if ( *p != 0xff ) {
fprintf (stderr,
"%s: Bad file: \"%s\" has invalid buffer for XIP\n",
}
}
- offset = sizeof(image_header_t);
+ offset = image_get_header_size ();
}
size = sbuf.st_size - offset;
time_t timestamp;
uint32_t size;
- timestamp = (time_t)ntohl(hdr->ih_time);
- size = ntohl(hdr->ih_size);
+ timestamp = (time_t)image_get_time (hdr);
+ size = image_get_data_size (hdr);
- printf ("Image Name: %.*s\n", IH_NMLEN, hdr->ih_name);
+ printf ("Image Name: %.*s\n", IH_NMLEN, image_get_name (hdr));
printf ("Created: %s", ctime(×tamp));
printf ("Image Type: "); print_type(hdr);
printf ("Data Size: %d Bytes = %.2f kB = %.2f MB\n",
size, (double)size / 1.024e3, (double)size / 1.048576e6 );
- printf ("Load Address: 0x%08X\n", ntohl(hdr->ih_load));
- printf ("Entry Point: 0x%08X\n", ntohl(hdr->ih_ep));
+ printf ("Load Address: 0x%08X\n", image_get_load (hdr));
+ printf ("Entry Point: 0x%08X\n", image_get_ep (hdr));
- if (hdr->ih_type == IH_TYPE_MULTI || hdr->ih_type == IH_TYPE_SCRIPT) {
+ if (image_check_type (hdr, IH_TYPE_MULTI) ||
+ image_check_type (hdr, IH_TYPE_SCRIPT)) {
int i, ptrs;
uint32_t pos;
uint32_t *len_ptr = (uint32_t *) (
- (unsigned long)hdr + sizeof(image_header_t)
+ (unsigned long)hdr + image_get_header_size ()
);
/* determine number of images first (to calculate image offsets) */
;
ptrs = i; /* null pointer terminates list */
- pos = sizeof(image_header_t) + ptrs * sizeof(long);
+ pos = image_get_header_size () + ptrs * sizeof(long);
printf ("Contents:\n");
for (i=0; len_ptr[i]; ++i) {
- size = ntohl(len_ptr[i]);
+ size = image_to_cpu (len_ptr[i]);
printf (" Image %d: %8d Bytes = %4d kB = %d MB\n",
i, size, size>>10, size>>20);
- if (hdr->ih_type == IH_TYPE_SCRIPT && i > 0) {
+ if (image_check_type (hdr, IH_TYPE_SCRIPT) && i > 0) {
/*
* the user may need to know offsets
* if planning to do something with
print_type (image_header_t *hdr)
{
printf ("%s %s %s (%s)\n",
- put_arch (hdr->ih_arch),
- put_os (hdr->ih_os ),
- put_type (hdr->ih_type),
- put_comp (hdr->ih_comp)
+ put_arch (image_get_arch (hdr)),
+ put_os (image_get_os (hdr)),
+ put_type (image_get_type (hdr)),
+ put_comp (image_get_comp (hdr))
);
}
--- /dev/null
+/*
+ * (C) Copyright 2000-2004
+ * DENX Software Engineering
+ * Wolfgang Denk, wd@denx.de
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifndef __WIN32__
+#include <netinet/in.h> /* for host / network byte order conversions */
+#endif
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <unistd.h>
+
+#if defined(__BEOS__) || defined(__NetBSD__) || defined(__APPLE__)
+#include <inttypes.h>
+#endif
+
+#ifdef __WIN32__
+typedef unsigned int __u32;
+
+#define SWAP_LONG(x) \
+ ((__u32)( \
+ (((__u32)(x) & (__u32)0x000000ffUL) << 24) | \
+ (((__u32)(x) & (__u32)0x0000ff00UL) << 8) | \
+ (((__u32)(x) & (__u32)0x00ff0000UL) >> 8) | \
+ (((__u32)(x) & (__u32)0xff000000UL) >> 24) ))
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+
+#define ntohl(a) SWAP_LONG(a)
+#define htonl(a) SWAP_LONG(a)
+#endif /* __WIN32__ */
+
+#ifndef O_BINARY /* should be define'd on __WIN32__ */
+#define O_BINARY 0
+#endif
projects / u-boot.git / commitdiff