* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*/
+
+#define DEBUG
+
#ifndef USE_HOSTCC
#include <common.h>
#include <watchdog.h>
#include <dataflash.h>
#endif
+#ifdef CONFIG_LOGBUFFER
+#include <logbuff.h>
+#endif
+
+#if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE)
+#include <rtc.h>
+#endif
+
+#if defined(CONFIG_FIT)
+#include <fdt.h>
+#include <libfdt.h>
+#include <fdt_support.h>
+#endif
+
extern int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
+
+#ifdef CONFIG_CMD_BDI
+extern int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
+#endif
+
+DECLARE_GLOBAL_DATA_PTR;
#else
#include "mkimage.h"
-#endif
+#endif /* USE_HOSTCC*/
#include <image.h>
return name;
}
+static void image_print_type (image_header_t *hdr)
+{
+ const char *os, *arch, *type, *comp;
+
+ os = image_get_os_name (image_get_os (hdr));
+ arch = image_get_arch_name (image_get_arch (hdr));
+ type = image_get_type_name (image_get_type (hdr));
+ comp = image_get_comp_name (image_get_comp (hdr));
+
+ printf ("%s %s %s (%s)", arch, os, type, comp);
+}
+
+void image_print_contents (image_header_t *hdr)
+{
+#if defined(CONFIG_TIMESTAMP) || defined(CONFIG_CMD_DATE)
+ time_t timestamp = (time_t)image_get_time (hdr);
+ struct rtc_time tm;
+#endif
+
+ 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_year, tm.tm_mon, tm.tm_mday,
+ tm.tm_hour, tm.tm_min, tm.tm_sec);
+#endif
+ puts (" Image Type: ");
+ image_print_type (hdr);
+
+ 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",
+ image_get_load (hdr), image_get_ep (hdr));
+
+ if (image_check_type (hdr, IH_TYPE_MULTI)) {
+ int i;
+ ulong data, len;
+ ulong count = image_multi_count (hdr);
+
+ puts (" Contents:\n");
+ for (i = 0; i < count; i++) {
+ image_multi_getimg (hdr, i, &data, &len);
+ printf (" Image %d: %8ld Bytes = ", i, len);
+ print_size (len, "\n");
+ }
+ }
+}
+
+/**
+ * gen_image_get_format - get image format type
+ * @img_addr: image start address
+ *
+ * gen_image_get_format() checks whether provided address points to a valid
+ * legacy or FIT image.
+ *
+ * returns:
+ * image format type or IMAGE_FORMAT_INVALID if no image is present
+ */
+int gen_image_get_format (void *img_addr)
+{
+ ulong format = IMAGE_FORMAT_INVALID;
+ image_header_t *hdr;
+#if defined(CONFIG_FIT)
+ char *fit_hdr;
+#endif
+
+ hdr = (image_header_t *)img_addr;
+ if (image_check_magic(hdr))
+ format = IMAGE_FORMAT_LEGACY;
+#if defined(CONFIG_FIT)
+ else {
+ fit_hdr = (char *)img_addr;
+ if (fdt_check_header (fit_hdr) == 0)
+ format = IMAGE_FORMAT_FIT;
+ }
+#endif
+
+ return format;
+}
+
+/**
+ * gen_get_image - get image from special storage (if necessary)
+ * @img_addr: image start address
+ *
+ * gen_get_image() checks if provided image start adddress is located
+ * in a dataflash storage. If so, image is moved to a system RAM memory.
+ *
+ * returns:
+ * image start address after possible relocation from special storage
+ */
+ulong gen_get_image (ulong img_addr)
+{
+ ulong ram_addr, h_size, d_size;
+
+ h_size = image_get_header_size ();
+#if defined(CONFIG_FIT)
+ if (sizeof(struct fdt_header) > h_size)
+ h_size = sizeof(struct fdt_header);
+#endif
+
+#ifdef CONFIG_HAS_DATAFLASH
+ if (addr_dataflash (img_addr)){
+ ram_addr = CFG_LOAD_ADDR;
+ debug (" Reading image header from dataflash address "
+ "%08lx to RAM address %08lx\n", img_addr, ram_addr);
+ read_dataflash (img_addr, h_size, (char *)ram_addr);
+ } else
+#endif
+ return img_addr;
+
+ ram_addr = img_addr;
+
+ switch (gen_image_get_format ((void *)ram_addr)) {
+ case IMAGE_FORMAT_LEGACY:
+ d_size = image_get_data_size ((image_header_t *)ram_addr);
+ debug (" Legacy format image found at 0x%08lx, size 0x%08lx\n",
+ ram_addr, d_size);
+ break;
+#if defined(CONFIG_FIT)
+ case IMAGE_FORMAT_FIT:
+ d_size = fdt_totalsize((void *)ram_addr) - h_size;
+ debug (" FIT/FDT format image found at 0x%08lx, size 0x%08lx\n",
+ ram_addr, d_size);
+
+ break;
+#endif
+ default:
+ printf (" No valid image found at 0x%08lx\n", img_addr);
+ return ram_addr;
+ }
+
+#ifdef CONFIG_HAS_DATAFLASH
+ if (addr_dataflash (img_addr)) {
+ debug (" Reading image remaining data from dataflash address "
+ "%08lx to RAM address %08lx\n", img_addr + h_size,
+ ram_addr + h_size);
+
+ read_dataflash (img_addr + h_size, d_size,
+ (char *)(ram_addr + h_size));
+ }
+#endif
+
+ return ram_addr;
+}
+
/**
* image_get_ramdisk - get and verify ramdisk image
* @cmdtp: command table pointer
image_header_t *rd_hdr;
show_boot_progress (9);
-
-#ifdef CONFIG_HAS_DATAFLASH
- if (addr_dataflash (rd_addr)) {
- rd_hdr = (image_header_t *)CFG_LOAD_ADDR;
- debug (" Reading Ramdisk image header from dataflash address "
- "%08lx to %08lx\n", rd_addr, (ulong)rd_hdr);
- read_dataflash (rd_addr, image_get_header_size (),
- (char *)rd_hdr);
- } else
-#endif
rd_hdr = (image_header_t *)rd_addr;
if (!image_check_magic (rd_hdr)) {
}
show_boot_progress (10);
- print_image_hdr (rd_hdr);
-
-#ifdef CONFIG_HAS_DATAFLASH
- if (addr_dataflash (rd_addr)) {
- debug (" Reading Ramdisk image data from dataflash address "
- "%08lx to %08lx\n", rd_addr + image_get_header_size,
- (ulong)image_get_data (rd_hdr));
-
- read_dataflash (rd_addr + image_get_header_size (),
- image_get_data_size (rd_hdr),
- (char *)image_get_data (rd_hdr));
- }
-#endif
+ image_print_contents (rd_hdr);
if (verify) {
puts(" Verifying Checksum ... ");
* @flag: command flag
* @argc: command argument count
* @argv: command argument list
- * @hdr: pointer to the posiibly multi componet kernel image
+ * @images: pointer to the bootm images strcture
* @verify: checksum verification flag
* @arch: expected ramdisk architecture
* @rd_start: pointer to a ulong variable, will hold ramdisk start address
* board is reset if ramdisk image is found but corrupted
*/
void get_ramdisk (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
- image_header_t *hdr, int verify, uint8_t arch,
+ bootm_headers_t *images, int verify, uint8_t arch,
ulong *rd_start, ulong *rd_end)
{
- ulong rd_addr;
+ ulong rd_addr, rd_load;
ulong rd_data, rd_len;
image_header_t *rd_hdr;
+#if defined(CONFIG_FIT)
+ void *fit_hdr;
+ const char *fit_uname_config = NULL;
+ const char *fit_uname_ramdisk = NULL;
+ ulong default_addr;
+#endif
- if (argc >= 3) {
+ /*
+ * Look for a '-' which indicates to ignore the
+ * ramdisk argument
+ */
+ if ((argc >= 3) && (strcmp(argv[2], "-") == 0)) {
+ debug ("## Skipping init Ramdisk\n");
+ rd_len = rd_data = 0;
+ } else if (argc >= 3) {
+#if defined(CONFIG_FIT)
/*
- * Look for a '-' which indicates to ignore the
- * ramdisk argument
+ * If the init ramdisk comes from the FIT image and the FIT image
+ * address is omitted in the command line argument, try to use
+ * os FIT image address or default load address.
*/
- if (strcmp(argv[2], "-") == 0) {
- debug ("## Skipping init Ramdisk\n");
- rd_len = rd_data = 0;
- } else {
- /*
- * Check if there is an initrd image at the
- * address provided in the second bootm argument
- */
- rd_addr = simple_strtoul (argv[2], NULL, 16);
- printf ("## Loading init Ramdisk Image at %08lx ...\n",
+ if (images->fit_uname_os)
+ default_addr = (ulong)images->fit_hdr_os;
+ else
+ default_addr = load_addr;
+
+ if (fit_parse_conf (argv[2], default_addr,
+ &rd_addr, &fit_uname_config)) {
+ debug ("* ramdisk: config '%s' from image at 0x%08lx\n",
+ fit_uname_config, rd_addr);
+ } else if (fit_parse_subimage (argv[2], default_addr,
+ &rd_addr, &fit_uname_ramdisk)) {
+ debug ("* ramdisk: subimage '%s' from image at 0x%08lx\n",
+ fit_uname_ramdisk, rd_addr);
+ } else
+#endif
+ {
+ rd_addr = simple_strtoul(argv[2], NULL, 16);
+ debug ("* ramdisk: cmdline image address = 0x%08lx\n",
rd_addr);
+ }
+
+ /* copy from dataflash if needed */
+ printf ("## Loading init Ramdisk Image at %08lx ...\n",
+ rd_addr);
+ rd_addr = gen_get_image (rd_addr);
+
+ /*
+ * Check if there is an initrd image at the
+ * address provided in the second bootm argument
+ * check image type, for FIT images get FIT node.
+ */
+ switch (gen_image_get_format ((void *)rd_addr)) {
+ case IMAGE_FORMAT_LEGACY:
+
+ debug ("* ramdisk: legacy format image\n");
rd_hdr = image_get_ramdisk (cmdtp, flag, argc, argv,
rd_addr, arch, verify);
rd_data = image_get_data (rd_hdr);
rd_len = image_get_data_size (rd_hdr);
+ rd_load = image_get_load (rd_hdr);
+ break;
+#if defined(CONFIG_FIT)
+ case IMAGE_FORMAT_FIT:
+ fit_hdr = (void *)rd_addr;
+ debug ("* ramdisk: FIT format image\n");
+ fit_unsupported_reset ("ramdisk");
+ do_reset (cmdtp, flag, argc, argv);
+#endif
+ default:
+ printf ("Wrong Image Format for %s command\n",
+ cmdtp->name);
+ rd_data = rd_len = 0;
+ }
#if defined(CONFIG_B2) || defined(CONFIG_EVB4510) || defined(CONFIG_ARMADILLO)
- /*
- *we need to copy the ramdisk to SRAM to let Linux boot
- */
- memmove ((void *)image_get_load (rd_hdr),
- (uchar *)rd_data, rd_len);
-
- rd_data = image_get_load (rd_hdr);
-#endif /* CONFIG_B2 || CONFIG_EVB4510 || CONFIG_ARMADILLO */
+ /*
+ * We need to copy the ramdisk to SRAM to let Linux boot
+ */
+ if (rd_data) {
+ memmove ((void *)rd_load, (uchar *)rd_data, rd_len);
+ rd_data = rd_load;
}
+#endif /* CONFIG_B2 || CONFIG_EVB4510 || CONFIG_ARMADILLO */
- } else if (image_check_type (hdr, IH_TYPE_MULTI)) {
+ } else if (images->legacy_hdr_valid &&
+ image_check_type (images->legacy_hdr_os, IH_TYPE_MULTI)) {
/*
- * Now check if we have a multifile image
- * Get second entry data start address and len
+ * Now check if we have a legacy mult-component image,
+ * get second entry data start address and len.
*/
show_boot_progress (13);
printf ("## Loading init Ramdisk from multi component "
- "Image at %08lx ...\n", (ulong)hdr);
- image_multi_getimg (hdr, 1, &rd_data, &rd_len);
+ "Image at %08lx ...\n",
+ (ulong)images->legacy_hdr_os);
+
+ image_multi_getimg (images->legacy_hdr_os, 1, &rd_data, &rd_len);
} else {
/*
* no initrd image
debug (" ramdisk start = 0x%08lx, ramdisk end = 0x%08lx\n",
*rd_start, *rd_end);
}
-#endif /* USE_HOSTCC */
+#if defined(CONFIG_PPC) || defined(CONFIG_M68K)
+/**
+ * ramdisk_high - relocate init ramdisk
+ * @rd_data: ramdisk data start address
+ * @rd_len: ramdisk data length
+ * @kbd: kernel board info copy (within BOOTMAPSZ boundary)
+ * @sp_limit: stack pointer limit (including BOOTMAPSZ)
+ * @sp: current stack pointer
+ * @initrd_start: pointer to a ulong variable, will hold final init ramdisk
+ * start address (after possible relocation)
+ * @initrd_end: pointer to a ulong variable, will hold final init ramdisk
+ * end address (after possible relocation)
+ *
+ * ramdisk_high() takes a relocation hint from "initrd_high" environement
+ * variable and if requested ramdisk data is moved to a specified location.
+ *
+ * returns:
+ * - initrd_start and initrd_end are set to final (after relocation) ramdisk
+ * start/end addresses if ramdisk image start and len were provided
+ * otherwise set initrd_start and initrd_end set to zeros
+ * - returns new allc_current, next free address below BOOTMAPSZ
+ */
+ulong ramdisk_high (ulong alloc_current, ulong rd_data, ulong rd_len,
+ bd_t *kbd, ulong sp_limit, ulong sp,
+ ulong *initrd_start, ulong *initrd_end)
+{
+ char *s;
+ ulong initrd_high;
+ int initrd_copy_to_ram = 1;
+ ulong new_alloc_current = alloc_current;
+
+ if ((s = getenv ("initrd_high")) != NULL) {
+ /* a value of "no" or a similar string will act like 0,
+ * turning the "load high" feature off. This is intentional.
+ */
+ initrd_high = simple_strtoul (s, NULL, 16);
+ if (initrd_high == ~0)
+ initrd_copy_to_ram = 0;
+ } else {
+ /* not set, no restrictions to load high */
+ initrd_high = ~0;
+ }
+
+#ifdef CONFIG_LOGBUFFER
+ /* Prevent initrd from overwriting logbuffer */
+ if (initrd_high < (kbd->bi_memsize - LOGBUFF_LEN - LOGBUFF_OVERHEAD))
+ initrd_high = kbd->bi_memsize - LOGBUFF_LEN - LOGBUFF_OVERHEAD;
+ debug ("## Logbuffer at 0x%08lx ", kbd->bi_memsize - LOGBUFF_LEN);
+#endif
+ debug ("## initrd_high = 0x%08lx, copy_to_ram = %d\n",
+ initrd_high, initrd_copy_to_ram);
+
+ if (rd_data) {
+ if (!initrd_copy_to_ram) { /* zero-copy ramdisk support */
+ debug (" in-place initrd\n");
+ *initrd_start = rd_data;
+ *initrd_end = rd_data + rd_len;
+ } else {
+ new_alloc_current = alloc_current - rd_len;
+ *initrd_start = new_alloc_current;
+ *initrd_start &= ~(4096 - 1); /* align on page */
+
+ if (initrd_high) {
+ ulong nsp;
+
+ /*
+ * the inital ramdisk does not need to be within
+ * CFG_BOOTMAPSZ as it is not accessed until after
+ * the mm system is initialised.
+ *
+ * do the stack bottom calculation again and see if
+ * the initrd will fit just below the monitor stack
+ * bottom without overwriting the area allocated
+ * for command line args and board info.
+ */
+ nsp = sp;
+ nsp -= 2048; /* just to be sure */
+ nsp &= ~0xF;
+
+ if (nsp > initrd_high) /* limit as specified */
+ nsp = initrd_high;
+
+ nsp -= rd_len;
+ nsp &= ~(4096 - 1); /* align on page */
+
+ if (nsp >= sp_limit) {
+ *initrd_start = nsp;
+ new_alloc_current = alloc_current;
+ }
+ }
+
+ show_boot_progress (12);
+
+ *initrd_end = *initrd_start + rd_len;
+ printf (" Loading Ramdisk to %08lx, end %08lx ... ",
+ *initrd_start, *initrd_end);
+
+ memmove_wd((void *)*initrd_start,
+ (void *)rd_data, rd_len, CHUNKSZ);
+
+ puts ("OK\n");
+ }
+ } else {
+ *initrd_start = 0;
+ *initrd_end = 0;
+ }
+ debug (" ramdisk load start = 0x%08lx, ramdisk load end = 0x%08lx\n",
+ *initrd_start, *initrd_end);
+
+ return new_alloc_current;
+}
+
+/**
+ * get_boot_sp_limit - calculate stack pointer limit
+ * @sp: current stack pointer
+ *
+ * get_boot_sp_limit() takes current stack pointer adrress and calculates
+ * stack pointer limit, below which kernel boot data (cmdline, board info,
+ * etc.) will be allocated.
+ *
+ * returns:
+ * stack pointer limit
+ */
+ulong get_boot_sp_limit(ulong sp)
+{
+ ulong sp_limit = sp;
+
+ sp_limit -= 2048; /* just to be sure */
+
+ /* make sure sp_limit is within kernel mapped space */
+ if (sp_limit > CFG_BOOTMAPSZ)
+ sp_limit = CFG_BOOTMAPSZ;
+ sp_limit &= ~0xF;
+
+ return sp_limit;
+}
+
+/**
+ * get_boot_cmdline - allocate and initialize kernel cmdline
+ * @alloc_current: current boot allocation address (counting down
+ * from sp_limit)
+ * @cmd_start: pointer to a ulong variable, will hold cmdline start
+ * @cmd_end: pointer to a ulong variable, will hold cmdline end
+ *
+ * get_boot_cmdline() allocates space for kernel command line below
+ * provided alloc_current address. If "bootargs" U-boot environemnt
+ * variable is present its contents is copied to allocated kernel
+ * command line.
+ *
+ * returns:
+ * alloc_current after cmdline allocation
+ */
+ulong get_boot_cmdline (ulong alloc_current, ulong *cmd_start, ulong *cmd_end)
+{
+ char *cmdline;
+ char *s;
+
+ cmdline = (char *)((alloc_current - CFG_BARGSIZE) & ~0xF);
+
+ if ((s = getenv("bootargs")) == NULL)
+ s = "";
+
+ strcpy(cmdline, s);
+
+ *cmd_start = (ulong) & cmdline[0];
+ *cmd_end = *cmd_start + strlen(cmdline);
+
+ debug ("## cmdline at 0x%08lx ... 0x%08lx\n", *cmd_start, *cmd_end);
+
+ return (ulong)cmdline;
+}
+
+/**
+ * get_boot_kbd - allocate and initialize kernel copy of board info
+ * @alloc_current: current boot allocation address (counting down
+ * from sp_limit)
+ * @kbd: double pointer to board info data
+ *
+ * get_boot_kbd() - allocates space for kernel copy of board info data.
+ * Space is allocated below provided alloc_current address and kernel
+ * board info is initialized with the current u-boot board info data.
+ *
+ * returns:
+ * alloc_current after kbd allocation
+ */
+ulong get_boot_kbd (ulong alloc_current, bd_t **kbd)
+{
+ *kbd = (bd_t *) (((ulong)alloc_current - sizeof(bd_t)) & ~0xF);
+ **kbd = *(gd->bd);
+
+ debug ("## kernel board info at 0x%08lx\n", (ulong)*kbd);
+
+#if defined(DEBUG) && defined(CONFIG_CMD_BDI)
+ do_bdinfo(NULL, 0, 0, NULL);
+#endif
+
+ return (ulong)*kbd;
+}
+#endif /* CONFIG_PPC || CONFIG_M68K */
+
+#if defined(CONFIG_FIT)
+/*****************************************************************************/
+/* New uImage format routines */
+/*****************************************************************************/
+static int fit_parse_spec (const char *spec, char sepc, ulong addr_curr,
+ ulong *addr, const char **name)
+{
+ const char *sep;
+
+ *addr = addr_curr;
+ *name = NULL;
+
+ sep = strchr (spec, sepc);
+ if (sep) {
+ if (sep - spec > 0)
+ *addr = simple_strtoul (spec, NULL, 16);
+
+ *name = sep + 1;
+ return 1;
+ }
+
+ return 0;
+}
+
+/**
+ * fit_parse_conf - parse FIT configuration spec
+ * @spec: input string, containing configuration spec
+ * @add_curr: current image address (to be used as a possible default)
+ * @addr: pointer to a ulong variable, will hold FIT image address of a given
+ * configuration
+ * @conf_name double pointer to a char, will hold pointer to a configuration
+ * unit name
+ *
+ * fit_parse_conf() expects configuration spec in the for of [<addr>]#<conf>,
+ * where <addr> is a FIT image address that contains configuration
+ * with a <conf> unit name.
+ *
+ * Address part is optional, and if omitted default add_curr will
+ * be used instead.
+ *
+ * returns:
+ * 1 if spec is a valid configuration string,
+ * addr and conf_name are set accordingly
+ * 0 otherwise
+ */
+inline int fit_parse_conf (const char *spec, ulong addr_curr,
+ ulong *addr, const char **conf_name)
+{
+ return fit_parse_spec (spec, '#', addr_curr, addr, conf_name);
+}
+
+/**
+ * fit_parse_subimage - parse FIT subimage spec
+ * @spec: input string, containing subimage spec
+ * @add_curr: current image address (to be used as a possible default)
+ * @addr: pointer to a ulong variable, will hold FIT image address of a given
+ * subimage
+ * @image_name: double pointer to a char, will hold pointer to a subimage name
+ *
+ * fit_parse_subimage() expects subimage spec in the for of
+ * [<addr>]:<subimage>, where <addr> is a FIT image address that contains
+ * subimage with a <subimg> unit name.
+ *
+ * Address part is optional, and if omitted default add_curr will
+ * be used instead.
+ *
+ * returns:
+ * 1 if spec is a valid subimage string,
+ * addr and image_name are set accordingly
+ * 0 otherwise
+ */
+inline int fit_parse_subimage (const char *spec, ulong addr_curr,
+ ulong *addr, const char **image_name)
+{
+ return fit_parse_spec (spec, ':', addr_curr, addr, image_name);
+}
+
+#endif /* CONFIG_FIT */
+
+#endif /* USE_HOSTCC */