2002-11-02 17:01:44 -07:00
|
|
|
/*
|
2009-07-13 08:01:18 -06:00
|
|
|
* (C) Copyright 2000-2009
|
2002-11-02 17:01:44 -07:00
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2008-01-08 10:14:09 -07:00
|
|
|
|
2002-11-02 17:01:44 -07:00
|
|
|
/*
|
|
|
|
* Boot support
|
|
|
|
*/
|
|
|
|
#include <common.h>
|
|
|
|
#include <watchdog.h>
|
|
|
|
#include <command.h>
|
|
|
|
#include <image.h>
|
|
|
|
#include <malloc.h>
|
2009-04-04 04:49:11 -06:00
|
|
|
#include <u-boot/zlib.h>
|
2003-08-29 14:57:53 -06:00
|
|
|
#include <bzlib.h>
|
2003-05-20 08:25:27 -06:00
|
|
|
#include <environment.h>
|
2008-02-27 20:51:47 -07:00
|
|
|
#include <lmb.h>
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
#include <linux/ctype.h>
|
2002-11-02 17:01:44 -07:00
|
|
|
#include <asm/byteorder.h>
|
2011-11-19 06:12:18 -07:00
|
|
|
#include <linux/compiler.h>
|
2003-06-27 15:31:46 -06:00
|
|
|
|
2008-07-30 01:59:51 -06:00
|
|
|
#if defined(CONFIG_CMD_USB)
|
2008-07-10 06:47:09 -06:00
|
|
|
#include <usb.h>
|
|
|
|
#endif
|
|
|
|
|
2008-10-16 07:01:15 -06:00
|
|
|
#ifdef CONFIG_SYS_HUSH_PARSER
|
2002-11-02 17:01:44 -07:00
|
|
|
#include <hush.h>
|
|
|
|
#endif
|
|
|
|
|
2008-08-15 07:24:39 -06:00
|
|
|
#if defined(CONFIG_OF_LIBFDT)
|
|
|
|
#include <fdt.h>
|
|
|
|
#include <libfdt.h>
|
|
|
|
#include <fdt_support.h>
|
|
|
|
#endif
|
|
|
|
|
2008-09-07 18:46:13 -06:00
|
|
|
#ifdef CONFIG_LZMA
|
|
|
|
#include <lzma/LzmaTypes.h>
|
2009-07-21 02:45:49 -06:00
|
|
|
#include <lzma/LzmaDec.h>
|
2008-09-07 18:46:13 -06:00
|
|
|
#include <lzma/LzmaTools.h>
|
|
|
|
#endif /* CONFIG_LZMA */
|
|
|
|
|
2009-11-19 03:37:51 -07:00
|
|
|
#ifdef CONFIG_LZO
|
|
|
|
#include <linux/lzo.h>
|
|
|
|
#endif /* CONFIG_LZO */
|
|
|
|
|
2008-01-08 10:17:10 -07:00
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
2002-12-08 02:53:23 -07:00
|
|
|
|
2008-10-16 07:01:15 -06:00
|
|
|
#ifndef CONFIG_SYS_BOOTM_LEN
|
|
|
|
#define CONFIG_SYS_BOOTM_LEN 0x800000 /* use 8MByte as default max gunzip size */
|
2003-06-16 17:50:08 -06:00
|
|
|
#endif
|
|
|
|
|
2008-01-08 10:11:43 -07:00
|
|
|
#ifdef CONFIG_BZIP2
|
|
|
|
extern void bz_internal_error(int);
|
2002-11-02 17:01:44 -07:00
|
|
|
#endif
|
|
|
|
|
2007-07-08 16:51:39 -06:00
|
|
|
#if defined(CONFIG_CMD_IMI)
|
2011-10-18 05:11:49 -06:00
|
|
|
static int image_info(unsigned long addr);
|
2002-11-02 17:01:44 -07:00
|
|
|
#endif
|
2003-07-24 17:38:38 -06:00
|
|
|
|
2007-07-08 16:51:39 -06:00
|
|
|
#if defined(CONFIG_CMD_IMLS)
|
2003-07-24 17:38:38 -06:00
|
|
|
#include <flash.h>
|
2010-08-31 02:00:10 -06:00
|
|
|
#include <mtd/cfi_flash.h>
|
2005-10-11 11:09:42 -06:00
|
|
|
extern flash_info_t flash_info[]; /* info for FLASH chips */
|
2011-10-18 05:11:49 -06:00
|
|
|
static int do_imls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
|
2003-07-24 17:38:38 -06:00
|
|
|
#endif
|
|
|
|
|
2008-01-08 10:17:10 -07:00
|
|
|
#ifdef CONFIG_SILENT_CONSOLE
|
2011-10-18 05:11:49 -06:00
|
|
|
static void fixup_silent_linux(void);
|
2008-01-08 10:17:10 -07:00
|
|
|
#endif
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
static image_header_t *image_get_kernel(ulong img_addr, int verify);
|
2008-03-12 03:01:05 -06:00
|
|
|
#if defined(CONFIG_FIT)
|
2011-10-18 05:11:49 -06:00
|
|
|
static int fit_check_kernel(const void *fit, int os_noffset, int verify);
|
2002-11-17 17:14:45 -07:00
|
|
|
#endif
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
static void *boot_get_kernel(cmd_tbl_t *cmdtp, int flag, int argc,
|
|
|
|
char * const argv[], bootm_headers_t *images,
|
|
|
|
ulong *os_data, ulong *os_len);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Continue booting an OS image; caller already has:
|
|
|
|
* - copied image header to global variable `header'
|
|
|
|
* - checked header magic number, checksums (both header & image),
|
|
|
|
* - verified image architecture (PPC) and type (KERNEL or MULTI),
|
|
|
|
* - loaded (first part of) image to header load address,
|
|
|
|
* - disabled interrupts.
|
|
|
|
*/
|
2011-10-18 05:11:49 -06:00
|
|
|
typedef int boot_os_fn(int flag, int argc, char * const argv[],
|
2008-02-27 03:01:04 -07:00
|
|
|
bootm_headers_t *images); /* pointers to os/initrd/fdt */
|
2008-01-08 10:17:10 -07:00
|
|
|
|
2008-10-21 16:25:47 -06:00
|
|
|
#ifdef CONFIG_BOOTM_LINUX
|
2008-01-08 10:17:10 -07:00
|
|
|
extern boot_os_fn do_bootm_linux;
|
2008-10-21 16:25:47 -06:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_BOOTM_NETBSD
|
2008-01-08 10:17:10 -07:00
|
|
|
static boot_os_fn do_bootm_netbsd;
|
2008-10-21 16:25:47 -06:00
|
|
|
#endif
|
2008-01-08 10:12:17 -07:00
|
|
|
#if defined(CONFIG_LYNXKDI)
|
2008-01-08 10:17:10 -07:00
|
|
|
static boot_os_fn do_bootm_lynxkdi;
|
2011-10-18 05:11:49 -06:00
|
|
|
extern void lynxkdi_boot(image_header_t *);
|
2002-11-02 17:01:44 -07:00
|
|
|
#endif
|
2008-10-21 16:25:47 -06:00
|
|
|
#ifdef CONFIG_BOOTM_RTEMS
|
2008-01-08 10:17:10 -07:00
|
|
|
static boot_os_fn do_bootm_rtems;
|
2008-10-21 16:25:47 -06:00
|
|
|
#endif
|
2010-09-28 03:05:36 -06:00
|
|
|
#if defined(CONFIG_BOOTM_OSE)
|
|
|
|
static boot_os_fn do_bootm_ose;
|
|
|
|
#endif
|
2007-07-08 16:51:39 -06:00
|
|
|
#if defined(CONFIG_CMD_ELF)
|
2008-01-08 10:17:10 -07:00
|
|
|
static boot_os_fn do_bootm_vxworks;
|
|
|
|
static boot_os_fn do_bootm_qnxelf;
|
2011-10-18 05:11:49 -06:00
|
|
|
int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
|
|
|
|
int do_bootelf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
|
2007-07-10 10:02:44 -06:00
|
|
|
#endif
|
2008-09-08 13:56:49 -06:00
|
|
|
#if defined(CONFIG_INTEGRITY)
|
|
|
|
static boot_os_fn do_bootm_integrity;
|
|
|
|
#endif
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2009-11-03 09:36:26 -07:00
|
|
|
static boot_os_fn *boot_os[] = {
|
2008-10-21 16:25:47 -06:00
|
|
|
#ifdef CONFIG_BOOTM_LINUX
|
2008-10-21 16:25:44 -06:00
|
|
|
[IH_OS_LINUX] = do_bootm_linux,
|
2008-10-21 16:25:47 -06:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_BOOTM_NETBSD
|
2008-10-21 16:25:44 -06:00
|
|
|
[IH_OS_NETBSD] = do_bootm_netbsd,
|
2008-10-21 16:25:47 -06:00
|
|
|
#endif
|
2008-10-21 16:25:44 -06:00
|
|
|
#ifdef CONFIG_LYNXKDI
|
|
|
|
[IH_OS_LYNXOS] = do_bootm_lynxkdi,
|
|
|
|
#endif
|
2008-10-21 16:25:47 -06:00
|
|
|
#ifdef CONFIG_BOOTM_RTEMS
|
2008-10-21 16:25:44 -06:00
|
|
|
[IH_OS_RTEMS] = do_bootm_rtems,
|
2008-10-21 16:25:47 -06:00
|
|
|
#endif
|
2010-09-28 03:05:36 -06:00
|
|
|
#if defined(CONFIG_BOOTM_OSE)
|
|
|
|
[IH_OS_OSE] = do_bootm_ose,
|
|
|
|
#endif
|
2008-10-21 16:25:44 -06:00
|
|
|
#if defined(CONFIG_CMD_ELF)
|
|
|
|
[IH_OS_VXWORKS] = do_bootm_vxworks,
|
|
|
|
[IH_OS_QNX] = do_bootm_qnxelf,
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_INTEGRITY
|
|
|
|
[IH_OS_INTEGRITY] = do_bootm_integrity,
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2011-09-01 18:50:31 -06:00
|
|
|
bootm_headers_t images; /* pointers to os/initrd/fdt images */
|
2006-03-13 03:16:36 -07:00
|
|
|
|
2009-08-27 07:23:55 -06:00
|
|
|
/* Allow for arch specific config before we boot */
|
|
|
|
void __arch_preboot_os(void)
|
|
|
|
{
|
|
|
|
/* please define platform specific arch_preboot_os() */
|
|
|
|
}
|
|
|
|
void arch_preboot_os(void) __attribute__((weak, alias("__arch_preboot_os")));
|
|
|
|
|
2011-10-03 08:50:33 -06:00
|
|
|
#define IH_INITRD_ARCH IH_ARCH_DEFAULT
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2009-11-03 09:35:59 -07:00
|
|
|
#ifdef CONFIG_LMB
|
2012-03-14 15:52:45 -06:00
|
|
|
static void boot_start_lmb(bootm_headers_t *images)
|
|
|
|
{
|
2008-06-09 19:37:18 -06:00
|
|
|
ulong mem_start;
|
|
|
|
phys_size_t mem_size;
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2012-03-14 15:52:45 -06:00
|
|
|
lmb_init(&images->lmb);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-02-27 20:51:50 -07:00
|
|
|
mem_start = getenv_bootm_low();
|
|
|
|
mem_size = getenv_bootm_size();
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2012-03-14 15:52:45 -06:00
|
|
|
lmb_add(&images->lmb, (phys_addr_t)mem_start, mem_size);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2012-03-14 15:52:45 -06:00
|
|
|
arch_lmb_reserve(&images->lmb);
|
|
|
|
board_lmb_reserve(&images->lmb);
|
|
|
|
}
|
2009-11-03 09:35:59 -07:00
|
|
|
#else
|
2012-03-31 21:59:46 -06:00
|
|
|
#define lmb_reserve(lmb, base, size)
|
2012-03-14 15:52:45 -06:00
|
|
|
static inline void boot_start_lmb(bootm_headers_t *images) { }
|
2009-11-03 09:35:59 -07:00
|
|
|
#endif
|
|
|
|
|
2010-06-28 14:00:46 -06:00
|
|
|
static int bootm_start(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
2009-11-03 09:35:59 -07:00
|
|
|
{
|
|
|
|
void *os_hdr;
|
|
|
|
int ret;
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
memset((void *)&images, 0, sizeof(images));
|
|
|
|
images.verify = getenv_yesno("verify");
|
2009-11-03 09:35:59 -07:00
|
|
|
|
2012-03-14 15:52:45 -06:00
|
|
|
boot_start_lmb(&images);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2011-12-10 04:08:06 -07:00
|
|
|
bootstage_mark_name(BOOTSTAGE_ID_BOOTM_START, "bootm_start");
|
|
|
|
|
2008-01-31 05:59:09 -07:00
|
|
|
/* get kernel image header, start address and length */
|
2011-10-18 05:11:49 -06:00
|
|
|
os_hdr = boot_get_kernel(cmdtp, flag, argc, argv,
|
2008-08-15 07:24:41 -06:00
|
|
|
&images, &images.os.image_start, &images.os.image_len);
|
|
|
|
if (images.os.image_len == 0) {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("ERROR: can't get kernel image!\n");
|
2002-11-02 17:01:44 -07:00
|
|
|
return 1;
|
2005-10-05 17:50:50 -06:00
|
|
|
}
|
|
|
|
|
2008-02-04 00:28:09 -07:00
|
|
|
/* get image parameters */
|
2011-10-18 05:11:49 -06:00
|
|
|
switch (genimg_get_format(os_hdr)) {
|
2008-02-04 00:28:09 -07:00
|
|
|
case IMAGE_FORMAT_LEGACY:
|
2011-10-18 05:11:49 -06:00
|
|
|
images.os.type = image_get_type(os_hdr);
|
|
|
|
images.os.comp = image_get_comp(os_hdr);
|
|
|
|
images.os.os = image_get_os(os_hdr);
|
2005-10-05 17:50:50 -06:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
images.os.end = image_get_image_end(os_hdr);
|
|
|
|
images.os.load = image_get_load(os_hdr);
|
2008-02-04 00:28:09 -07:00
|
|
|
break;
|
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
case IMAGE_FORMAT_FIT:
|
2011-10-18 05:11:49 -06:00
|
|
|
if (fit_image_get_type(images.fit_hdr_os,
|
2008-08-15 07:24:41 -06:00
|
|
|
images.fit_noffset_os, &images.os.type)) {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("Can't get image type!\n");
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_FIT_TYPE);
|
2008-03-12 03:01:05 -06:00
|
|
|
return 1;
|
|
|
|
}
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
if (fit_image_get_comp(images.fit_hdr_os,
|
2008-08-15 07:24:41 -06:00
|
|
|
images.fit_noffset_os, &images.os.comp)) {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("Can't get image compression!\n");
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_FIT_COMPRESSION);
|
2008-03-12 03:01:05 -06:00
|
|
|
return 1;
|
|
|
|
}
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
if (fit_image_get_os(images.fit_hdr_os,
|
2008-08-15 07:24:41 -06:00
|
|
|
images.fit_noffset_os, &images.os.os)) {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("Can't get image OS!\n");
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_FIT_OS);
|
2002-11-02 17:01:44 -07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
images.os.end = fit_get_end(images.fit_hdr_os);
|
2008-03-12 03:01:05 -06:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
if (fit_image_get_load(images.fit_hdr_os, images.fit_noffset_os,
|
2008-08-15 07:24:41 -06:00
|
|
|
&images.os.load)) {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("Can't get image load address!\n");
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_FIT_LOADADDR);
|
2008-03-12 03:01:05 -06:00
|
|
|
return 1;
|
2003-10-30 14:49:38 -07:00
|
|
|
}
|
|
|
|
break;
|
2008-02-04 00:28:09 -07:00
|
|
|
#endif
|
|
|
|
default:
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("ERROR: unknown image format type!\n");
|
2002-11-02 17:01:44 -07:00
|
|
|
return 1;
|
|
|
|
}
|
2008-02-04 00:28:09 -07:00
|
|
|
|
2008-08-15 07:24:36 -06:00
|
|
|
/* find kernel entry point */
|
|
|
|
if (images.legacy_hdr_valid) {
|
2011-10-18 05:11:49 -06:00
|
|
|
images.ep = image_get_ep(&images.legacy_hdr_os_copy);
|
2008-08-15 07:24:36 -06:00
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
} else if (images.fit_uname_os) {
|
2011-10-18 05:11:49 -06:00
|
|
|
ret = fit_image_get_entry(images.fit_hdr_os,
|
2008-08-15 07:24:36 -06:00
|
|
|
images.fit_noffset_os, &images.ep);
|
|
|
|
if (ret) {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("Can't get entry point property!\n");
|
2008-08-15 07:24:36 -06:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
} else {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("Could not find kernel entry point!\n");
|
2008-08-15 07:24:36 -06:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-11-10 13:17:53 -07:00
|
|
|
if (images.os.type == IH_TYPE_KERNEL_NOLOAD) {
|
|
|
|
images.os.load = images.os.image_start;
|
|
|
|
images.ep += images.os.load;
|
|
|
|
}
|
|
|
|
|
2010-03-29 05:15:48 -06:00
|
|
|
if (((images.os.type == IH_TYPE_KERNEL) ||
|
2011-11-10 13:17:53 -07:00
|
|
|
(images.os.type == IH_TYPE_KERNEL_NOLOAD) ||
|
2010-03-29 05:15:48 -06:00
|
|
|
(images.os.type == IH_TYPE_MULTI)) &&
|
2009-12-22 04:43:01 -07:00
|
|
|
(images.os.os == IH_OS_LINUX)) {
|
2008-08-15 07:24:37 -06:00
|
|
|
/* find ramdisk */
|
2011-10-18 05:11:49 -06:00
|
|
|
ret = boot_get_ramdisk(argc, argv, &images, IH_INITRD_ARCH,
|
2008-08-15 07:24:37 -06:00
|
|
|
&images.rd_start, &images.rd_end);
|
|
|
|
if (ret) {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("Ramdisk image is corrupt or invalid\n");
|
2008-08-15 07:24:37 -06:00
|
|
|
return 1;
|
|
|
|
}
|
2008-08-15 07:24:38 -06:00
|
|
|
|
|
|
|
#if defined(CONFIG_OF_LIBFDT)
|
|
|
|
/* find flattened device tree */
|
2011-10-18 05:11:49 -06:00
|
|
|
ret = boot_get_fdt(flag, argc, argv, &images,
|
|
|
|
&images.ft_addr, &images.ft_len);
|
2008-08-15 07:24:38 -06:00
|
|
|
if (ret) {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("Could not find a valid device tree\n");
|
2008-08-15 07:24:38 -06:00
|
|
|
return 1;
|
|
|
|
}
|
2008-08-15 07:24:39 -06:00
|
|
|
|
|
|
|
set_working_fdt_addr(images.ft_addr);
|
2008-08-15 07:24:38 -06:00
|
|
|
#endif
|
2008-08-15 07:24:37 -06:00
|
|
|
}
|
|
|
|
|
2008-08-15 07:24:41 -06:00
|
|
|
images.os.start = (ulong)os_hdr;
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
images.state = BOOTM_STATE_START;
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-08-15 07:24:41 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2008-07-10 06:47:09 -06:00
|
|
|
|
2008-08-15 07:24:41 -06:00
|
|
|
#define BOOTM_ERR_RESET -1
|
|
|
|
#define BOOTM_ERR_OVERLAP -2
|
|
|
|
#define BOOTM_ERR_UNIMPLEMENTED -3
|
|
|
|
static int bootm_load_os(image_info_t os, ulong *load_end, int boot_progress)
|
|
|
|
{
|
|
|
|
uint8_t comp = os.comp;
|
|
|
|
ulong load = os.load;
|
|
|
|
ulong blob_start = os.start;
|
|
|
|
ulong blob_end = os.end;
|
|
|
|
ulong image_start = os.image_start;
|
|
|
|
ulong image_len = os.image_len;
|
2011-11-19 06:12:18 -07:00
|
|
|
__maybe_unused uint unc_len = CONFIG_SYS_BOOTM_LEN;
|
image: Don't detect XIP images as overlapping.
bootm_load_os() detects when it writes the decompressed image over
the top of the compressed image. If this happens, the original image
is corrupted. When the original image is a multi-component legacy image,
or a (potentially multi-component) FIT image, this implies that other
components may be corrupted. In turn, this means that booting is unlikely
to be successful.
However, in the case of no image compresssion coupled with an image with
load address equal to where the image is already located (e.g. an XIP
kernel, or IH_TYPE_KERNEL_ANYLOAD), there has been no copy and hence no
corruption, no matter whether it's a single-component legacy image, a
multi-component legacy image, or a FIT image. In this case, disable the
overlap detection, and allow boot to continue.
Without this change, when booting a single-component legacy image that
contains an IH_TYPE_KERNEL_ANYLOAD, bootm_load_os() would have returned
BOOTM_ERR_OVERLAP, but the caller ignores this, and boot continues and
succeeds. Now, the false error is no longer even returned.
Without this change, when booting a FIT image that contains an
IH_TYPE_KERNEL_ANYLOAD, bootm_load_os() would have returned
BOOTM_ERR_OVERLAP, which would then cause the caller to reset the board.
Now, the false error is no longer returned, and boot succeeds.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Stefan Roese <sr@denx.de>
2011-11-10 13:17:54 -07:00
|
|
|
int no_overlap = 0;
|
2010-08-05 05:17:30 -06:00
|
|
|
#if defined(CONFIG_LZMA) || defined(CONFIG_LZO)
|
|
|
|
int ret;
|
|
|
|
#endif /* defined(CONFIG_LZMA) || defined(CONFIG_LZO) */
|
2008-07-10 06:47:09 -06:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
const char *type_name = genimg_get_type_name(os.type);
|
2002-11-19 04:04:11 -07:00
|
|
|
|
2008-02-04 00:28:09 -07:00
|
|
|
switch (comp) {
|
2002-11-02 17:01:44 -07:00
|
|
|
case IH_COMP_NONE:
|
2011-01-10 03:21:15 -07:00
|
|
|
if (load == blob_start || load == image_start) {
|
2011-10-18 05:11:49 -06:00
|
|
|
printf(" XIP %s ... ", type_name);
|
image: Don't detect XIP images as overlapping.
bootm_load_os() detects when it writes the decompressed image over
the top of the compressed image. If this happens, the original image
is corrupted. When the original image is a multi-component legacy image,
or a (potentially multi-component) FIT image, this implies that other
components may be corrupted. In turn, this means that booting is unlikely
to be successful.
However, in the case of no image compresssion coupled with an image with
load address equal to where the image is already located (e.g. an XIP
kernel, or IH_TYPE_KERNEL_ANYLOAD), there has been no copy and hence no
corruption, no matter whether it's a single-component legacy image, a
multi-component legacy image, or a FIT image. In this case, disable the
overlap detection, and allow boot to continue.
Without this change, when booting a single-component legacy image that
contains an IH_TYPE_KERNEL_ANYLOAD, bootm_load_os() would have returned
BOOTM_ERR_OVERLAP, but the caller ignores this, and boot continues and
succeeds. Now, the false error is no longer even returned.
Without this change, when booting a FIT image that contains an
IH_TYPE_KERNEL_ANYLOAD, bootm_load_os() would have returned
BOOTM_ERR_OVERLAP, which would then cause the caller to reset the board.
Now, the false error is no longer returned, and boot succeeds.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Stefan Roese <sr@denx.de>
2011-11-10 13:17:54 -07:00
|
|
|
no_overlap = 1;
|
2002-11-02 17:01:44 -07:00
|
|
|
} else {
|
2011-10-18 05:11:49 -06:00
|
|
|
printf(" Loading %s ... ", type_name);
|
|
|
|
memmove_wd((void *)load, (void *)image_start,
|
2010-04-20 06:09:43 -06:00
|
|
|
image_len, CHUNKSZ);
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
2008-08-15 07:24:41 -06:00
|
|
|
*load_end = load + image_len;
|
2008-07-31 04:35:04 -06:00
|
|
|
puts("OK\n");
|
2002-11-02 17:01:44 -07:00
|
|
|
break;
|
2010-01-21 17:30:36 -07:00
|
|
|
#ifdef CONFIG_GZIP
|
2002-11-02 17:01:44 -07:00
|
|
|
case IH_COMP_GZIP:
|
2011-10-18 05:11:49 -06:00
|
|
|
printf(" Uncompressing %s ... ", type_name);
|
|
|
|
if (gunzip((void *)load, unc_len,
|
|
|
|
(uchar *)image_start, &image_len) != 0) {
|
|
|
|
puts("GUNZIP: uncompress, out-of-mem or overwrite "
|
|
|
|
"error - must RESET board to recover\n");
|
2008-08-15 07:24:41 -06:00
|
|
|
if (boot_progress)
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
|
2008-08-15 07:24:41 -06:00
|
|
|
return BOOTM_ERR_RESET;
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
2008-01-31 05:20:06 -07:00
|
|
|
|
2008-08-15 07:24:41 -06:00
|
|
|
*load_end = load + image_len;
|
2002-11-02 17:01:44 -07:00
|
|
|
break;
|
2010-01-21 17:30:36 -07:00
|
|
|
#endif /* CONFIG_GZIP */
|
2003-08-29 14:57:53 -06:00
|
|
|
#ifdef CONFIG_BZIP2
|
|
|
|
case IH_COMP_BZIP2:
|
2011-10-18 05:11:49 -06:00
|
|
|
printf(" Uncompressing %s ... ", type_name);
|
2004-02-08 15:55:38 -07:00
|
|
|
/*
|
|
|
|
* If we've got less than 4 MB of malloc() space,
|
|
|
|
* use slower decompression algorithm which requires
|
|
|
|
* at most 2300 KB of memory.
|
|
|
|
*/
|
2011-10-18 05:11:49 -06:00
|
|
|
int i = BZ2_bzBuffToBuffDecompress((char *)load,
|
2008-08-15 07:24:41 -06:00
|
|
|
&unc_len, (char *)image_start, image_len,
|
2008-10-16 07:01:15 -06:00
|
|
|
CONFIG_SYS_MALLOC_LEN < (4096 * 1024), 0);
|
2003-08-29 14:57:53 -06:00
|
|
|
if (i != BZ_OK) {
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("BUNZIP2: uncompress or overwrite error %d "
|
2008-03-12 03:33:01 -06:00
|
|
|
"- must RESET board to recover\n", i);
|
2008-08-15 07:24:41 -06:00
|
|
|
if (boot_progress)
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
|
2008-08-15 07:24:41 -06:00
|
|
|
return BOOTM_ERR_RESET;
|
2003-08-29 14:57:53 -06:00
|
|
|
}
|
2008-01-31 05:20:06 -07:00
|
|
|
|
2008-08-15 07:24:41 -06:00
|
|
|
*load_end = load + unc_len;
|
2003-08-29 14:57:53 -06:00
|
|
|
break;
|
|
|
|
#endif /* CONFIG_BZIP2 */
|
2008-09-07 18:46:13 -06:00
|
|
|
#ifdef CONFIG_LZMA
|
2010-07-25 13:54:17 -06:00
|
|
|
case IH_COMP_LZMA: {
|
|
|
|
SizeT lzma_len = unc_len;
|
2011-10-18 05:11:49 -06:00
|
|
|
printf(" Uncompressing %s ... ", type_name);
|
2008-09-07 18:46:13 -06:00
|
|
|
|
2010-08-05 05:17:30 -06:00
|
|
|
ret = lzmaBuffToBuffDecompress(
|
2010-07-25 13:54:17 -06:00
|
|
|
(unsigned char *)load, &lzma_len,
|
2008-09-13 02:04:32 -06:00
|
|
|
(unsigned char *)image_start, image_len);
|
2010-07-25 13:54:17 -06:00
|
|
|
unc_len = lzma_len;
|
2009-07-21 02:45:49 -06:00
|
|
|
if (ret != SZ_OK) {
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("LZMA: uncompress or overwrite error %d "
|
2008-09-07 18:46:13 -06:00
|
|
|
"- must RESET board to recover\n", ret);
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
|
2008-09-07 18:46:13 -06:00
|
|
|
return BOOTM_ERR_RESET;
|
|
|
|
}
|
|
|
|
*load_end = load + unc_len;
|
|
|
|
break;
|
2010-07-25 13:54:17 -06:00
|
|
|
}
|
2008-09-07 18:46:13 -06:00
|
|
|
#endif /* CONFIG_LZMA */
|
2009-11-19 03:37:51 -07:00
|
|
|
#ifdef CONFIG_LZO
|
|
|
|
case IH_COMP_LZO:
|
2011-10-18 05:11:49 -06:00
|
|
|
printf(" Uncompressing %s ... ", type_name);
|
2009-11-19 03:37:51 -07:00
|
|
|
|
2010-08-05 05:17:30 -06:00
|
|
|
ret = lzop_decompress((const unsigned char *)image_start,
|
2009-11-19 03:37:51 -07:00
|
|
|
image_len, (unsigned char *)load,
|
|
|
|
&unc_len);
|
|
|
|
if (ret != LZO_E_OK) {
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("LZO: uncompress or overwrite error %d "
|
2009-11-19 03:37:51 -07:00
|
|
|
"- must RESET board to recover\n", ret);
|
|
|
|
if (boot_progress)
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_DECOMP_IMAGE);
|
2009-11-19 03:37:51 -07:00
|
|
|
return BOOTM_ERR_RESET;
|
|
|
|
}
|
|
|
|
|
|
|
|
*load_end = load + unc_len;
|
|
|
|
break;
|
|
|
|
#endif /* CONFIG_LZO */
|
2002-11-02 17:01:44 -07:00
|
|
|
default:
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("Unimplemented compression type %d\n", comp);
|
2008-08-15 07:24:41 -06:00
|
|
|
return BOOTM_ERR_UNIMPLEMENTED;
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
2011-08-30 20:45:23 -06:00
|
|
|
|
|
|
|
flush_cache(load, (*load_end - load) * sizeof(ulong));
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("OK\n");
|
|
|
|
debug(" kernel loaded at 0x%08lx, end = 0x%08lx\n", load, *load_end);
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_KERNEL_LOADED);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
image: Don't detect XIP images as overlapping.
bootm_load_os() detects when it writes the decompressed image over
the top of the compressed image. If this happens, the original image
is corrupted. When the original image is a multi-component legacy image,
or a (potentially multi-component) FIT image, this implies that other
components may be corrupted. In turn, this means that booting is unlikely
to be successful.
However, in the case of no image compresssion coupled with an image with
load address equal to where the image is already located (e.g. an XIP
kernel, or IH_TYPE_KERNEL_ANYLOAD), there has been no copy and hence no
corruption, no matter whether it's a single-component legacy image, a
multi-component legacy image, or a FIT image. In this case, disable the
overlap detection, and allow boot to continue.
Without this change, when booting a single-component legacy image that
contains an IH_TYPE_KERNEL_ANYLOAD, bootm_load_os() would have returned
BOOTM_ERR_OVERLAP, but the caller ignores this, and boot continues and
succeeds. Now, the false error is no longer even returned.
Without this change, when booting a FIT image that contains an
IH_TYPE_KERNEL_ANYLOAD, bootm_load_os() would have returned
BOOTM_ERR_OVERLAP, which would then cause the caller to reset the board.
Now, the false error is no longer returned, and boot succeeds.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Stefan Roese <sr@denx.de>
2011-11-10 13:17:54 -07:00
|
|
|
if (!no_overlap && (load < blob_end) && (*load_end > blob_start)) {
|
2011-10-18 05:11:49 -06:00
|
|
|
debug("images.os.start = 0x%lX, images.os.end = 0x%lx\n",
|
|
|
|
blob_start, blob_end);
|
|
|
|
debug("images.os.load = 0x%lx, load_end = 0x%lx\n", load,
|
|
|
|
*load_end);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-08-15 07:24:41 -06:00
|
|
|
return BOOTM_ERR_OVERLAP;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-06-28 14:00:46 -06:00
|
|
|
static int bootm_start_standalone(ulong iflag, int argc, char * const argv[])
|
2009-07-13 08:01:19 -06:00
|
|
|
{
|
|
|
|
char *s;
|
2010-06-28 14:00:46 -06:00
|
|
|
int (*appl)(int, char * const []);
|
2009-07-13 08:01:19 -06:00
|
|
|
|
|
|
|
/* Don't start if "autostart" is set to "no" */
|
|
|
|
if (((s = getenv("autostart")) != NULL) && (strcmp(s, "no") == 0)) {
|
|
|
|
char buf[32];
|
|
|
|
sprintf(buf, "%lX", images.os.image_len);
|
|
|
|
setenv("filesize", buf);
|
|
|
|
return 0;
|
|
|
|
}
|
2011-10-07 07:53:40 -06:00
|
|
|
appl = (int (*)(int, char * const []))(ulong)ntohl(images.ep);
|
2009-07-13 08:01:19 -06:00
|
|
|
(*appl)(argc-1, &argv[1]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
/* we overload the cmd field with our state machine info instead of a
|
|
|
|
* function pointer */
|
2010-02-25 02:12:13 -07:00
|
|
|
static cmd_tbl_t cmd_bootm_sub[] = {
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
U_BOOT_CMD_MKENT(start, 0, 1, (void *)BOOTM_STATE_START, "", ""),
|
|
|
|
U_BOOT_CMD_MKENT(loados, 0, 1, (void *)BOOTM_STATE_LOADOS, "", ""),
|
2010-10-13 13:57:35 -06:00
|
|
|
#ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
U_BOOT_CMD_MKENT(ramdisk, 0, 1, (void *)BOOTM_STATE_RAMDISK, "", ""),
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_OF_LIBFDT
|
|
|
|
U_BOOT_CMD_MKENT(fdt, 0, 1, (void *)BOOTM_STATE_FDT, "", ""),
|
|
|
|
#endif
|
|
|
|
U_BOOT_CMD_MKENT(cmdline, 0, 1, (void *)BOOTM_STATE_OS_CMDLINE, "", ""),
|
2009-11-18 18:08:59 -07:00
|
|
|
U_BOOT_CMD_MKENT(bdt, 0, 1, (void *)BOOTM_STATE_OS_BD_T, "", ""),
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
U_BOOT_CMD_MKENT(prep, 0, 1, (void *)BOOTM_STATE_OS_PREP, "", ""),
|
|
|
|
U_BOOT_CMD_MKENT(go, 0, 1, (void *)BOOTM_STATE_OS_GO, "", ""),
|
|
|
|
};
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
int do_bootm_subcommand(cmd_tbl_t *cmdtp, int flag, int argc,
|
|
|
|
char * const argv[])
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
{
|
|
|
|
int ret = 0;
|
2011-10-07 07:53:40 -06:00
|
|
|
long state;
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
cmd_tbl_t *c;
|
|
|
|
boot_os_fn *boot_fn;
|
|
|
|
|
|
|
|
c = find_cmd_tbl(argv[1], &cmd_bootm_sub[0], ARRAY_SIZE(cmd_bootm_sub));
|
|
|
|
|
|
|
|
if (c) {
|
2011-10-07 07:53:40 -06:00
|
|
|
state = (long)c->cmd;
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
|
|
|
|
/* treat start special since it resets the state machine */
|
|
|
|
if (state == BOOTM_STATE_START) {
|
|
|
|
argc--;
|
|
|
|
argv++;
|
|
|
|
return bootm_start(cmdtp, flag, argc, argv);
|
|
|
|
}
|
2010-07-16 17:06:04 -06:00
|
|
|
} else {
|
|
|
|
/* Unrecognized command */
|
2011-12-10 01:44:01 -07:00
|
|
|
return CMD_RET_USAGE;
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (images.state >= state) {
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("Trying to execute a command out of order\n");
|
2011-12-10 01:44:01 -07:00
|
|
|
return CMD_RET_USAGE;
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
images.state |= state;
|
|
|
|
boot_fn = boot_os[images.os.os];
|
|
|
|
|
|
|
|
switch (state) {
|
|
|
|
ulong load_end;
|
|
|
|
case BOOTM_STATE_START:
|
|
|
|
/* should never occur */
|
|
|
|
break;
|
|
|
|
case BOOTM_STATE_LOADOS:
|
|
|
|
ret = bootm_load_os(images.os, &load_end, 0);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
lmb_reserve(&images.lmb, images.os.load,
|
|
|
|
(load_end - images.os.load));
|
|
|
|
break;
|
2010-10-13 13:57:35 -06:00
|
|
|
#ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
case BOOTM_STATE_RAMDISK:
|
|
|
|
{
|
|
|
|
ulong rd_len = images.rd_end - images.rd_start;
|
|
|
|
char str[17];
|
|
|
|
|
|
|
|
ret = boot_ramdisk_high(&images.lmb, images.rd_start,
|
|
|
|
rd_len, &images.initrd_start, &images.initrd_end);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
sprintf(str, "%lx", images.initrd_start);
|
|
|
|
setenv("initrd_start", str);
|
|
|
|
sprintf(str, "%lx", images.initrd_end);
|
|
|
|
setenv("initrd_end", str);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
2011-03-28 03:58:49 -06:00
|
|
|
#if defined(CONFIG_OF_LIBFDT)
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
case BOOTM_STATE_FDT:
|
|
|
|
{
|
2011-03-28 03:59:01 -06:00
|
|
|
boot_fdt_add_mem_rsv_regions(&images.lmb,
|
|
|
|
images.ft_addr);
|
2011-03-28 03:58:34 -06:00
|
|
|
ret = boot_relocate_fdt(&images.lmb,
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
&images.ft_addr, &images.ft_len);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
case BOOTM_STATE_OS_CMDLINE:
|
|
|
|
ret = boot_fn(BOOTM_STATE_OS_CMDLINE, argc, argv, &images);
|
|
|
|
if (ret)
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("cmdline subcommand not supported\n");
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
break;
|
|
|
|
case BOOTM_STATE_OS_BD_T:
|
|
|
|
ret = boot_fn(BOOTM_STATE_OS_BD_T, argc, argv, &images);
|
|
|
|
if (ret)
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("bdt subcommand not supported\n");
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
break;
|
|
|
|
case BOOTM_STATE_OS_PREP:
|
|
|
|
ret = boot_fn(BOOTM_STATE_OS_PREP, argc, argv, &images);
|
|
|
|
if (ret)
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("prep subcommand not supported\n");
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
break;
|
|
|
|
case BOOTM_STATE_OS_GO:
|
|
|
|
disable_interrupts();
|
2012-08-03 04:59:08 -06:00
|
|
|
#ifdef CONFIG_NETCONSOLE
|
|
|
|
/*
|
|
|
|
* Stop the ethernet stack if NetConsole could have
|
|
|
|
* left it up
|
|
|
|
*/
|
|
|
|
eth_halt();
|
|
|
|
#endif
|
2009-08-27 07:23:55 -06:00
|
|
|
arch_preboot_os();
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
boot_fn(BOOTM_STATE_OS_GO, argc, argv, &images);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-08-15 07:24:41 -06:00
|
|
|
/*******************************************************************/
|
|
|
|
/* bootm - boot application image from image in memory */
|
|
|
|
/*******************************************************************/
|
2008-10-21 16:25:44 -06:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
2008-08-15 07:24:41 -06:00
|
|
|
{
|
|
|
|
ulong iflag;
|
|
|
|
ulong load_end = 0;
|
|
|
|
int ret;
|
2008-10-21 16:25:44 -06:00
|
|
|
boot_os_fn *boot_fn;
|
2010-10-28 12:00:11 -06:00
|
|
|
#ifdef CONFIG_NEEDS_MANUAL_RELOC
|
2009-09-21 10:20:36 -06:00
|
|
|
static int relocated = 0;
|
2008-10-21 16:25:44 -06:00
|
|
|
|
|
|
|
/* relocate boot function table */
|
|
|
|
if (!relocated) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(boot_os); i++)
|
2009-07-13 08:01:18 -06:00
|
|
|
if (boot_os[i] != NULL)
|
|
|
|
boot_os[i] += gd->reloc_off;
|
2008-10-21 16:25:44 -06:00
|
|
|
relocated = 1;
|
|
|
|
}
|
2009-09-21 10:20:36 -06:00
|
|
|
#endif
|
2008-08-15 07:24:41 -06:00
|
|
|
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
/* determine if we have a sub command */
|
|
|
|
if (argc > 1) {
|
|
|
|
char *endp;
|
|
|
|
|
|
|
|
simple_strtoul(argv[1], &endp, 16);
|
|
|
|
/* endp pointing to NULL means that argv[1] was just a
|
|
|
|
* valid number, pass it along to the normal bootm processing
|
|
|
|
*
|
|
|
|
* If endp is ':' or '#' assume a FIT identifier so pass
|
|
|
|
* along for normal processing.
|
|
|
|
*
|
|
|
|
* Right now we assume the first arg should never be '-'
|
|
|
|
*/
|
|
|
|
if ((*endp != 0) && (*endp != ':') && (*endp != '#'))
|
|
|
|
return do_bootm_subcommand(cmdtp, flag, argc, argv);
|
|
|
|
}
|
|
|
|
|
2008-08-29 13:04:45 -06:00
|
|
|
if (bootm_start(cmdtp, flag, argc, argv))
|
|
|
|
return 1;
|
2008-08-15 07:24:41 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We have reached the point of no return: we are going to
|
|
|
|
* overwrite all exception vector code, so we cannot easily
|
|
|
|
* recover from any failures any more...
|
|
|
|
*/
|
|
|
|
iflag = disable_interrupts();
|
|
|
|
|
2012-08-03 04:59:08 -06:00
|
|
|
#ifdef CONFIG_NETCONSOLE
|
|
|
|
/* Stop the ethernet stack if NetConsole could have left it up */
|
|
|
|
eth_halt();
|
|
|
|
#endif
|
|
|
|
|
2008-08-15 07:24:41 -06:00
|
|
|
#if defined(CONFIG_CMD_USB)
|
|
|
|
/*
|
|
|
|
* turn off USB to prevent the host controller from writing to the
|
|
|
|
* SDRAM while Linux is booting. This could happen (at least for OHCI
|
|
|
|
* controller), because the HCCA (Host Controller Communication Area)
|
|
|
|
* lies within the SDRAM and the host controller writes continously to
|
|
|
|
* this area (as busmaster!). The HccaFrameNumber is for example
|
|
|
|
* updated every 1 ms within the HCCA structure in SDRAM! For more
|
|
|
|
* details see the OpenHCI specification.
|
|
|
|
*/
|
|
|
|
usb_stop();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
ret = bootm_load_os(images.os, &load_end, 1);
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
if (ret == BOOTM_ERR_RESET)
|
2011-10-18 05:11:49 -06:00
|
|
|
do_reset(cmdtp, flag, argc, argv);
|
2008-08-15 07:24:41 -06:00
|
|
|
if (ret == BOOTM_ERR_OVERLAP) {
|
|
|
|
if (images.legacy_hdr_valid) {
|
2011-10-18 05:11:49 -06:00
|
|
|
image_header_t *hdr;
|
|
|
|
hdr = &images.legacy_hdr_os_copy;
|
|
|
|
if (image_get_type(hdr) == IH_TYPE_MULTI)
|
|
|
|
puts("WARNING: legacy format multi "
|
|
|
|
"component image "
|
|
|
|
"overwritten\n");
|
2008-08-15 07:24:41 -06:00
|
|
|
} else {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("ERROR: new format image overwritten - "
|
2008-08-15 07:24:41 -06:00
|
|
|
"must RESET the board to recover\n");
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_OVERWRITTEN);
|
2011-10-18 05:11:49 -06:00
|
|
|
do_reset(cmdtp, flag, argc, argv);
|
2008-08-15 07:24:41 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (ret == BOOTM_ERR_UNIMPLEMENTED) {
|
|
|
|
if (iflag)
|
|
|
|
enable_interrupts();
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_DECOMP_UNIMPL);
|
2008-08-15 07:24:41 -06:00
|
|
|
return 1;
|
2008-04-11 03:07:49 -06:00
|
|
|
}
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
2008-01-31 05:20:06 -07:00
|
|
|
|
2008-08-15 07:24:41 -06:00
|
|
|
lmb_reserve(&images.lmb, images.os.load, (load_end - images.os.load));
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2009-07-13 08:01:19 -06:00
|
|
|
if (images.os.type == IH_TYPE_STANDALONE) {
|
|
|
|
if (iflag)
|
|
|
|
enable_interrupts();
|
|
|
|
/* This may return when 'autostart' is 'no' */
|
|
|
|
bootm_start_standalone(iflag, argc, argv);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_CHECK_BOOT_OS);
|
2008-02-27 20:51:47 -07:00
|
|
|
|
2003-10-10 04:05:42 -06:00
|
|
|
#ifdef CONFIG_SILENT_CONSOLE
|
2008-10-21 16:25:44 -06:00
|
|
|
if (images.os.os == IH_OS_LINUX)
|
|
|
|
fixup_silent_linux();
|
2003-07-26 18:21:01 -06:00
|
|
|
#endif
|
|
|
|
|
2008-10-21 16:25:44 -06:00
|
|
|
boot_fn = boot_os[images.os.os];
|
2009-07-13 08:01:18 -06:00
|
|
|
|
|
|
|
if (boot_fn == NULL) {
|
|
|
|
if (iflag)
|
|
|
|
enable_interrupts();
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("ERROR: booting os '%s' (%d) is not supported\n",
|
2009-07-13 08:01:18 -06:00
|
|
|
genimg_get_os_name(images.os.os), images.os.os);
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_CHECK_BOOT_OS);
|
2009-07-13 08:01:18 -06:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-08-27 07:23:55 -06:00
|
|
|
arch_preboot_os();
|
|
|
|
|
2008-10-21 16:25:44 -06:00
|
|
|
boot_fn(0, argc, argv, &images);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_BOOT_OS_RETURNED);
|
2002-11-02 17:01:44 -07:00
|
|
|
#ifdef DEBUG
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("\n## Control returned to monitor - resetting...\n");
|
2002-11-02 17:01:44 -07:00
|
|
|
#endif
|
2011-10-18 05:11:49 -06:00
|
|
|
do_reset(cmdtp, flag, argc, argv);
|
2008-03-12 03:14:57 -06:00
|
|
|
|
2002-11-02 17:01:44 -07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-06-05 07:43:02 -06:00
|
|
|
int bootm_maybe_autostart(cmd_tbl_t *cmdtp, const char *cmd)
|
|
|
|
{
|
|
|
|
const char *ep = getenv("autostart");
|
|
|
|
|
|
|
|
if (ep && !strcmp(ep, "yes")) {
|
|
|
|
char *local_args[2];
|
|
|
|
local_args[0] = (char *)cmd;
|
|
|
|
local_args[1] = NULL;
|
|
|
|
printf("Automatic boot of image at addr 0x%08lX ...\n", load_addr);
|
|
|
|
return do_bootm(cmdtp, 0, 1, local_args);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-27 03:02:07 -07:00
|
|
|
/**
|
2008-02-29 06:58:34 -07:00
|
|
|
* image_get_kernel - verify legacy format kernel image
|
|
|
|
* @img_addr: in RAM address of the legacy format image to be verified
|
|
|
|
* @verify: data CRC verification flag
|
2008-02-27 03:02:07 -07:00
|
|
|
*
|
2008-02-29 06:58:34 -07:00
|
|
|
* image_get_kernel() verifies legacy image integrity and returns pointer to
|
|
|
|
* legacy image header if image verification was completed successfully.
|
2008-02-27 03:02:07 -07:00
|
|
|
*
|
|
|
|
* returns:
|
2008-02-29 06:58:34 -07:00
|
|
|
* pointer to a legacy image header if valid image was found
|
|
|
|
* otherwise return NULL
|
2008-02-27 03:02:07 -07:00
|
|
|
*/
|
2011-10-18 05:11:49 -06:00
|
|
|
static image_header_t *image_get_kernel(ulong img_addr, int verify)
|
2003-10-10 04:05:42 -06:00
|
|
|
{
|
2008-02-27 03:02:07 -07:00
|
|
|
image_header_t *hdr = (image_header_t *)img_addr;
|
2003-10-10 04:05:42 -06:00
|
|
|
|
2008-02-27 03:02:07 -07:00
|
|
|
if (!image_check_magic(hdr)) {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("Bad Magic Number\n");
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_CHECK_MAGIC);
|
2008-02-27 03:02:07 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_CHECK_HEADER);
|
2003-10-10 04:05:42 -06:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
if (!image_check_hcrc(hdr)) {
|
|
|
|
puts("Bad Header Checksum\n");
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_CHECK_HEADER);
|
2008-02-27 03:02:07 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_CHECK_CHECKSUM);
|
2011-10-18 05:11:49 -06:00
|
|
|
image_print_contents(hdr);
|
2008-02-27 03:02:07 -07:00
|
|
|
|
|
|
|
if (verify) {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts(" Verifying Checksum ... ");
|
|
|
|
if (!image_check_dcrc(hdr)) {
|
|
|
|
printf("Bad Data CRC\n");
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_CHECK_CHECKSUM);
|
2008-02-27 03:02:07 -07:00
|
|
|
return NULL;
|
2003-10-10 04:05:42 -06:00
|
|
|
}
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("OK\n");
|
2003-10-10 04:05:42 -06:00
|
|
|
}
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_CHECK_ARCH);
|
2003-10-10 04:05:42 -06:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
if (!image_check_target_arch(hdr)) {
|
|
|
|
printf("Unsupported Architecture 0x%x\n", image_get_arch(hdr));
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_CHECK_ARCH);
|
2008-02-27 03:02:07 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return hdr;
|
2003-10-10 04:05:42 -06:00
|
|
|
}
|
|
|
|
|
2008-03-12 03:01:05 -06:00
|
|
|
/**
|
|
|
|
* fit_check_kernel - verify FIT format kernel subimage
|
|
|
|
* @fit_hdr: pointer to the FIT image header
|
|
|
|
* os_noffset: kernel subimage node offset within FIT image
|
|
|
|
* @verify: data CRC verification flag
|
|
|
|
*
|
|
|
|
* fit_check_kernel() verifies integrity of the kernel subimage and from
|
|
|
|
* specified FIT image.
|
|
|
|
*
|
|
|
|
* returns:
|
|
|
|
* 1, on success
|
|
|
|
* 0, on failure
|
|
|
|
*/
|
2011-10-18 05:11:49 -06:00
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
static int fit_check_kernel(const void *fit, int os_noffset, int verify)
|
2002-11-02 17:01:44 -07:00
|
|
|
{
|
2011-10-18 05:11:49 -06:00
|
|
|
fit_image_print(fit, os_noffset, " ");
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-03-12 03:01:05 -06:00
|
|
|
if (verify) {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts(" Verifying Hash Integrity ... ");
|
|
|
|
if (!fit_image_check_hashes(fit, os_noffset)) {
|
|
|
|
puts("Bad Data Hash\n");
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_FIT_CHECK_HASH);
|
2008-03-12 03:01:05 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("OK\n");
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_FIT_CHECK_ARCH);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
if (!fit_image_check_target_arch(fit, os_noffset)) {
|
|
|
|
puts("Unsupported Architecture\n");
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_FIT_CHECK_ARCH);
|
2008-03-12 03:01:05 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2002-11-05 09:35:14 -07:00
|
|
|
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_FIT_CHECK_KERNEL);
|
2011-11-10 13:17:53 -07:00
|
|
|
if (!fit_image_check_type(fit, os_noffset, IH_TYPE_KERNEL) &&
|
|
|
|
!fit_image_check_type(fit, os_noffset, IH_TYPE_KERNEL_NOLOAD)) {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("Not a kernel image\n");
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_FIT_CHECK_KERNEL);
|
2008-03-12 03:01:05 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_FIT_CHECKED);
|
2008-03-12 03:01:05 -06:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_FIT */
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-01-31 05:59:09 -07:00
|
|
|
/**
|
2008-02-29 06:58:34 -07:00
|
|
|
* boot_get_kernel - find kernel image
|
2008-01-31 05:59:09 -07:00
|
|
|
* @os_data: pointer to a ulong variable, will hold os data start address
|
|
|
|
* @os_len: pointer to a ulong variable, will hold os data length
|
|
|
|
*
|
2008-02-29 06:58:34 -07:00
|
|
|
* boot_get_kernel() tries to find a kernel image, verifies its integrity
|
2008-01-31 05:59:09 -07:00
|
|
|
* and locates kernel data.
|
|
|
|
*
|
|
|
|
* returns:
|
|
|
|
* pointer to image header if valid image was found, plus kernel start
|
|
|
|
* address and length, otherwise NULL
|
|
|
|
*/
|
2011-10-18 05:11:49 -06:00
|
|
|
static void *boot_get_kernel(cmd_tbl_t *cmdtp, int flag, int argc,
|
|
|
|
char * const argv[], bootm_headers_t *images, ulong *os_data,
|
|
|
|
ulong *os_len)
|
2008-01-31 05:59:09 -07:00
|
|
|
{
|
|
|
|
image_header_t *hdr;
|
|
|
|
ulong img_addr;
|
2008-02-04 00:28:09 -07:00
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
void *fit_hdr;
|
|
|
|
const char *fit_uname_config = NULL;
|
|
|
|
const char *fit_uname_kernel = NULL;
|
2008-03-12 03:01:05 -06:00
|
|
|
const void *data;
|
|
|
|
size_t len;
|
2008-03-12 03:35:46 -06:00
|
|
|
int cfg_noffset;
|
2008-03-12 03:01:05 -06:00
|
|
|
int os_noffset;
|
2008-02-04 00:28:09 -07:00
|
|
|
#endif
|
2002-11-05 09:35:14 -07:00
|
|
|
|
2008-02-04 00:28:09 -07:00
|
|
|
/* find out kernel image address */
|
2008-01-31 05:59:09 -07:00
|
|
|
if (argc < 2) {
|
|
|
|
img_addr = load_addr;
|
2011-10-18 05:11:49 -06:00
|
|
|
debug("* kernel: default image load address = 0x%08lx\n",
|
2008-02-04 00:28:09 -07:00
|
|
|
load_addr);
|
|
|
|
#if defined(CONFIG_FIT)
|
2011-10-18 05:11:49 -06:00
|
|
|
} else if (fit_parse_conf(argv[1], load_addr, &img_addr,
|
2008-02-04 00:28:09 -07:00
|
|
|
&fit_uname_config)) {
|
2011-10-18 05:11:49 -06:00
|
|
|
debug("* kernel: config '%s' from image at 0x%08lx\n",
|
2008-02-04 00:28:09 -07:00
|
|
|
fit_uname_config, img_addr);
|
2011-10-18 05:11:49 -06:00
|
|
|
} else if (fit_parse_subimage(argv[1], load_addr, &img_addr,
|
2008-02-04 00:28:09 -07:00
|
|
|
&fit_uname_kernel)) {
|
2011-10-18 05:11:49 -06:00
|
|
|
debug("* kernel: subimage '%s' from image at 0x%08lx\n",
|
2008-02-04 00:28:09 -07:00
|
|
|
fit_uname_kernel, img_addr);
|
|
|
|
#endif
|
2008-01-31 05:59:09 -07:00
|
|
|
} else {
|
|
|
|
img_addr = simple_strtoul(argv[1], NULL, 16);
|
2011-10-18 05:11:49 -06:00
|
|
|
debug("* kernel: cmdline image address = 0x%08lx\n", img_addr);
|
2008-01-31 05:59:09 -07:00
|
|
|
}
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_CHECK_MAGIC);
|
2002-11-05 09:35:14 -07:00
|
|
|
|
2008-02-21 09:20:19 -07:00
|
|
|
/* copy from dataflash if needed */
|
2011-10-18 05:11:49 -06:00
|
|
|
img_addr = genimg_get_image(img_addr);
|
2008-01-31 05:59:09 -07:00
|
|
|
|
2008-02-04 00:28:09 -07:00
|
|
|
/* check image type, for FIT images get FIT kernel node */
|
2008-03-12 03:01:05 -06:00
|
|
|
*os_data = *os_len = 0;
|
2011-10-18 05:11:49 -06:00
|
|
|
switch (genimg_get_format((void *)img_addr)) {
|
2008-02-04 00:28:09 -07:00
|
|
|
case IMAGE_FORMAT_LEGACY:
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("## Booting kernel from Legacy Image at %08lx ...\n",
|
2008-03-12 03:01:05 -06:00
|
|
|
img_addr);
|
2011-10-18 05:11:49 -06:00
|
|
|
hdr = image_get_kernel(img_addr, images->verify);
|
2008-02-27 03:02:07 -07:00
|
|
|
if (!hdr)
|
2008-02-04 00:28:09 -07:00
|
|
|
return NULL;
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_CHECK_IMAGETYPE);
|
2008-02-04 00:28:09 -07:00
|
|
|
|
2008-03-12 03:01:05 -06:00
|
|
|
/* get os_data and os_len */
|
2011-10-18 05:11:49 -06:00
|
|
|
switch (image_get_type(hdr)) {
|
2008-02-04 00:28:09 -07:00
|
|
|
case IH_TYPE_KERNEL:
|
2011-11-10 13:17:53 -07:00
|
|
|
case IH_TYPE_KERNEL_NOLOAD:
|
2011-10-18 05:11:49 -06:00
|
|
|
*os_data = image_get_data(hdr);
|
|
|
|
*os_len = image_get_data_size(hdr);
|
2008-02-04 00:28:09 -07:00
|
|
|
break;
|
|
|
|
case IH_TYPE_MULTI:
|
2011-10-18 05:11:49 -06:00
|
|
|
image_multi_getimg(hdr, 0, os_data, os_len);
|
2008-02-04 00:28:09 -07:00
|
|
|
break;
|
2009-07-13 08:01:19 -06:00
|
|
|
case IH_TYPE_STANDALONE:
|
2011-10-18 05:11:49 -06:00
|
|
|
*os_data = image_get_data(hdr);
|
|
|
|
*os_len = image_get_data_size(hdr);
|
2009-07-13 08:01:19 -06:00
|
|
|
break;
|
2008-02-04 00:28:09 -07:00
|
|
|
default:
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("Wrong Image Type for %s command\n",
|
|
|
|
cmdtp->name);
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_CHECK_IMAGETYPE);
|
2008-02-04 00:28:09 -07:00
|
|
|
return NULL;
|
|
|
|
}
|
2008-04-11 03:07:49 -06:00
|
|
|
|
|
|
|
/*
|
2011-10-18 05:11:49 -06:00
|
|
|
* copy image header to allow for image overwrites during
|
|
|
|
* kernel decompression.
|
2008-04-11 03:07:49 -06:00
|
|
|
*/
|
2011-10-18 05:11:49 -06:00
|
|
|
memmove(&images->legacy_hdr_os_copy, hdr,
|
|
|
|
sizeof(image_header_t));
|
2008-04-11 03:07:49 -06:00
|
|
|
|
|
|
|
/* save pointer to image header */
|
2008-02-04 00:28:09 -07:00
|
|
|
images->legacy_hdr_os = hdr;
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-04-11 03:07:49 -06:00
|
|
|
images->legacy_hdr_valid = 1;
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_DECOMP_IMAGE);
|
2008-01-31 05:59:09 -07:00
|
|
|
break;
|
2008-02-04 00:28:09 -07:00
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
case IMAGE_FORMAT_FIT:
|
|
|
|
fit_hdr = (void *)img_addr;
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("## Booting kernel from FIT Image at %08lx ...\n",
|
2008-03-12 03:01:05 -06:00
|
|
|
img_addr);
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
if (!fit_check_format(fit_hdr)) {
|
|
|
|
puts("Bad FIT kernel image format!\n");
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_FIT_FORMAT);
|
2008-03-12 03:01:05 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_FIT_FORMAT);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-03-12 03:01:05 -06:00
|
|
|
if (!fit_uname_kernel) {
|
|
|
|
/*
|
|
|
|
* no kernel image node unit name, try to get config
|
|
|
|
* node first. If config unit node name is NULL
|
2011-10-18 05:11:49 -06:00
|
|
|
* fit_conf_get_node() will try to find default config
|
|
|
|
* node
|
2008-03-12 03:01:05 -06:00
|
|
|
*/
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_FIT_NO_UNIT_NAME);
|
2011-10-18 05:11:49 -06:00
|
|
|
cfg_noffset = fit_conf_get_node(fit_hdr,
|
|
|
|
fit_uname_config);
|
2008-03-12 03:35:46 -06:00
|
|
|
if (cfg_noffset < 0) {
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_FIT_NO_UNIT_NAME);
|
2008-03-12 03:01:05 -06:00
|
|
|
return NULL;
|
2008-03-12 03:33:01 -06:00
|
|
|
}
|
2008-03-12 03:35:46 -06:00
|
|
|
/* save configuration uname provided in the first
|
|
|
|
* bootm argument
|
|
|
|
*/
|
2011-10-18 05:11:49 -06:00
|
|
|
images->fit_uname_cfg = fdt_get_name(fit_hdr,
|
|
|
|
cfg_noffset,
|
|
|
|
NULL);
|
|
|
|
printf(" Using '%s' configuration\n",
|
|
|
|
images->fit_uname_cfg);
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_FIT_CONFIG);
|
2011-10-18 05:11:49 -06:00
|
|
|
|
|
|
|
os_noffset = fit_conf_get_kernel_node(fit_hdr,
|
|
|
|
cfg_noffset);
|
|
|
|
fit_uname_kernel = fit_get_name(fit_hdr, os_noffset,
|
|
|
|
NULL);
|
2008-03-12 03:01:05 -06:00
|
|
|
} else {
|
|
|
|
/* get kernel component image node offset */
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_FIT_UNIT_NAME);
|
2011-10-18 05:11:49 -06:00
|
|
|
os_noffset = fit_image_get_node(fit_hdr,
|
|
|
|
fit_uname_kernel);
|
2008-03-12 03:01:05 -06:00
|
|
|
}
|
2008-03-12 03:33:01 -06:00
|
|
|
if (os_noffset < 0) {
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_FIT_CONFIG);
|
2008-03-12 03:01:05 -06:00
|
|
|
return NULL;
|
2008-03-12 03:33:01 -06:00
|
|
|
}
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
printf(" Trying '%s' kernel subimage\n", fit_uname_kernel);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_FIT_CHECK_SUBIMAGE);
|
2011-10-18 05:11:49 -06:00
|
|
|
if (!fit_check_kernel(fit_hdr, os_noffset, images->verify))
|
2008-03-12 03:01:05 -06:00
|
|
|
return NULL;
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-03-12 03:01:05 -06:00
|
|
|
/* get kernel image data address and length */
|
2011-10-18 05:11:49 -06:00
|
|
|
if (fit_image_get_data(fit_hdr, os_noffset, &data, &len)) {
|
|
|
|
puts("Could not find kernel subimage data!\n");
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_FIT_KERNEL_INFO_ERR);
|
2008-03-12 03:01:05 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_FIT_KERNEL_INFO);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-03-12 03:01:05 -06:00
|
|
|
*os_len = len;
|
|
|
|
*os_data = (ulong)data;
|
|
|
|
images->fit_hdr_os = fit_hdr;
|
|
|
|
images->fit_uname_os = fit_uname_kernel;
|
2008-03-12 03:32:59 -06:00
|
|
|
images->fit_noffset_os = os_noffset;
|
2008-03-12 03:01:05 -06:00
|
|
|
break;
|
2005-07-23 09:37:35 -06:00
|
|
|
#endif
|
2008-01-31 05:59:09 -07:00
|
|
|
default:
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("Wrong Image Format for %s command\n", cmdtp->name);
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_error(BOOTSTAGE_ID_FIT_KERNEL_INFO);
|
2008-01-31 05:59:09 -07:00
|
|
|
return NULL;
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
debug(" kernel data at 0x%08lx, len = 0x%08lx (%ld)\n",
|
2008-03-12 03:01:05 -06:00
|
|
|
*os_data, *os_len, *os_len);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-02-04 00:28:09 -07:00
|
|
|
return (void *)img_addr;
|
2008-01-31 05:59:09 -07:00
|
|
|
}
|
2006-06-28 09:41:37 -06:00
|
|
|
|
2003-07-01 15:06:45 -06:00
|
|
|
U_BOOT_CMD(
|
2008-10-16 07:01:15 -06:00
|
|
|
bootm, CONFIG_SYS_MAXARGS, 1, do_bootm,
|
2009-01-27 17:03:12 -07:00
|
|
|
"boot application image from memory",
|
2008-01-08 10:17:10 -07:00
|
|
|
"[addr [arg ...]]\n - boot application image stored in memory\n"
|
|
|
|
"\tpassing arguments 'arg ...'; when booting a Linux kernel,\n"
|
|
|
|
"\t'arg' can be the address of an initrd image\n"
|
2008-01-31 05:20:07 -07:00
|
|
|
#if defined(CONFIG_OF_LIBFDT)
|
2006-06-28 09:41:37 -06:00
|
|
|
"\tWhen booting a Linux kernel which requires a flat device-tree\n"
|
2007-10-19 08:47:26 -06:00
|
|
|
"\ta third argument is required which is the address of the\n"
|
2006-06-28 09:41:37 -06:00
|
|
|
"\tdevice-tree blob. To boot that kernel without an initrd image,\n"
|
|
|
|
"\tuse a '-' for the second argument. If you do not pass a third\n"
|
|
|
|
"\ta bd_info struct will be passed instead\n"
|
|
|
|
#endif
|
2008-03-12 03:01:05 -06:00
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
"\t\nFor the new multi component uImage format (FIT) addresses\n"
|
|
|
|
"\tmust be extened to include component or configuration unit name:\n"
|
|
|
|
"\taddr:<subimg_uname> - direct component image specification\n"
|
|
|
|
"\taddr#<conf_uname> - configuration specification\n"
|
|
|
|
"\tUse iminfo command to get the list of existing component\n"
|
|
|
|
"\timages and configurations.\n"
|
|
|
|
#endif
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
"\nSub-commands to do part of the bootm sequence. The sub-commands "
|
|
|
|
"must be\n"
|
|
|
|
"issued in the order below (it's ok to not issue all sub-commands):\n"
|
|
|
|
"\tstart [addr [arg ...]]\n"
|
|
|
|
"\tloados - load OS image\n"
|
|
|
|
#if defined(CONFIG_PPC) || defined(CONFIG_M68K) || defined(CONFIG_SPARC)
|
|
|
|
"\tramdisk - relocate initrd, set env initrd_start/initrd_end\n"
|
|
|
|
#endif
|
|
|
|
#if defined(CONFIG_OF_LIBFDT)
|
|
|
|
"\tfdt - relocate flat device tree\n"
|
|
|
|
#endif
|
|
|
|
"\tcmdline - OS specific command line processing/setup\n"
|
2009-11-18 18:08:59 -07:00
|
|
|
"\tbdt - OS specific bd_t processing\n"
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
"\tprep - OS specific prep before relocation or go\n"
|
2009-05-24 09:06:54 -06:00
|
|
|
"\tgo - start OS"
|
2003-06-27 15:31:46 -06:00
|
|
|
);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-01-08 10:17:10 -07:00
|
|
|
/*******************************************************************/
|
|
|
|
/* bootd - boot default image */
|
|
|
|
/*******************************************************************/
|
2007-07-08 16:51:39 -06:00
|
|
|
#if defined(CONFIG_CMD_BOOTD)
|
2011-10-18 05:11:49 -06:00
|
|
|
int do_bootd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
2002-11-02 17:01:44 -07:00
|
|
|
{
|
|
|
|
int rcode = 0;
|
|
|
|
|
2012-02-14 12:59:21 -07:00
|
|
|
if (run_command(getenv("bootcmd"), flag) < 0)
|
2008-01-08 10:17:10 -07:00
|
|
|
rcode = 1;
|
2002-11-02 17:01:44 -07:00
|
|
|
return rcode;
|
|
|
|
}
|
|
|
|
|
2003-07-01 15:06:45 -06:00
|
|
|
U_BOOT_CMD(
|
2008-01-08 10:17:10 -07:00
|
|
|
boot, 1, 1, do_bootd,
|
2009-01-27 17:03:12 -07:00
|
|
|
"boot default, i.e., run 'bootcmd'",
|
2009-05-24 09:06:54 -06:00
|
|
|
""
|
2003-06-28 17:11:04 -06:00
|
|
|
);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2003-06-28 17:11:04 -06:00
|
|
|
/* keep old command name "bootd" for backward compatibility */
|
2003-07-01 15:06:45 -06:00
|
|
|
U_BOOT_CMD(
|
2008-01-08 10:17:10 -07:00
|
|
|
bootd, 1, 1, do_bootd,
|
2009-01-27 17:03:12 -07:00
|
|
|
"boot default, i.e., run 'bootcmd'",
|
2009-05-24 09:06:54 -06:00
|
|
|
""
|
2003-06-27 15:31:46 -06:00
|
|
|
);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2008-01-08 10:17:10 -07:00
|
|
|
/*******************************************************************/
|
|
|
|
/* iminfo - print header info for a requested image */
|
|
|
|
/*******************************************************************/
|
2007-07-08 16:51:39 -06:00
|
|
|
#if defined(CONFIG_CMD_IMI)
|
2011-10-18 05:11:49 -06:00
|
|
|
int do_iminfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
2002-11-02 17:01:44 -07:00
|
|
|
{
|
|
|
|
int arg;
|
|
|
|
ulong addr;
|
2008-01-08 10:17:10 -07:00
|
|
|
int rcode = 0;
|
2002-11-02 17:01:44 -07:00
|
|
|
|
|
|
|
if (argc < 2) {
|
2011-10-18 05:11:49 -06:00
|
|
|
return image_info(load_addr);
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
|
|
|
|
2008-01-08 10:17:10 -07:00
|
|
|
for (arg = 1; arg < argc; ++arg) {
|
2011-10-18 05:11:49 -06:00
|
|
|
addr = simple_strtoul(argv[arg], NULL, 16);
|
|
|
|
if (image_info(addr) != 0)
|
2008-01-08 10:17:10 -07:00
|
|
|
rcode = 1;
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
|
|
|
return rcode;
|
|
|
|
}
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
static int image_info(ulong addr)
|
2002-11-02 17:01:44 -07:00
|
|
|
{
|
2008-02-04 00:28:09 -07:00
|
|
|
void *hdr = (void *)addr;
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("\n## Checking Image at %08lx ...\n", addr);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
switch (genimg_get_format(hdr)) {
|
2008-02-04 00:28:09 -07:00
|
|
|
case IMAGE_FORMAT_LEGACY:
|
2011-10-18 05:11:49 -06:00
|
|
|
puts(" Legacy image found\n");
|
|
|
|
if (!image_check_magic(hdr)) {
|
|
|
|
puts(" Bad Magic Number\n");
|
2008-02-04 00:28:09 -07:00
|
|
|
return 1;
|
|
|
|
}
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
if (!image_check_hcrc(hdr)) {
|
|
|
|
puts(" Bad Header Checksum\n");
|
2008-02-04 00:28:09 -07:00
|
|
|
return 1;
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
image_print_contents(hdr);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
puts(" Verifying Checksum ... ");
|
|
|
|
if (!image_check_dcrc(hdr)) {
|
|
|
|
puts(" Bad Data CRC\n");
|
2008-02-04 00:28:09 -07:00
|
|
|
return 1;
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("OK\n");
|
2008-02-04 00:28:09 -07:00
|
|
|
return 0;
|
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
case IMAGE_FORMAT_FIT:
|
2011-10-18 05:11:49 -06:00
|
|
|
puts(" FIT image found\n");
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
if (!fit_check_format(hdr)) {
|
|
|
|
puts("Bad FIT image format!\n");
|
2008-03-11 05:35:20 -06:00
|
|
|
return 1;
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
fit_print_contents(hdr);
|
2008-09-09 04:58:16 -06:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
if (!fit_all_image_check_hashes(hdr)) {
|
|
|
|
puts("Bad hash in FIT image!\n");
|
2008-09-09 04:58:16 -06:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-02-04 00:28:09 -07:00
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
default:
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("Unknown image format!\n");
|
2008-02-04 00:28:09 -07:00
|
|
|
break;
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
|
|
|
|
2008-02-04 00:28:09 -07:00
|
|
|
return 1;
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
2003-07-01 15:06:45 -06:00
|
|
|
|
|
|
|
U_BOOT_CMD(
|
2008-10-16 07:01:15 -06:00
|
|
|
iminfo, CONFIG_SYS_MAXARGS, 1, do_iminfo,
|
2009-01-27 17:03:12 -07:00
|
|
|
"print header information for application image",
|
2003-06-27 15:31:46 -06:00
|
|
|
"addr [addr ...]\n"
|
|
|
|
" - print header information for application image starting at\n"
|
|
|
|
" address 'addr' in memory; this includes verification of the\n"
|
2009-05-24 09:06:54 -06:00
|
|
|
" image contents (magic number, header and payload checksums)"
|
2003-06-27 15:31:46 -06:00
|
|
|
);
|
2006-08-16 09:54:09 -06:00
|
|
|
#endif
|
2006-08-22 08:23:55 -06:00
|
|
|
|
2006-08-16 09:54:09 -06:00
|
|
|
|
2008-01-08 10:17:10 -07:00
|
|
|
/*******************************************************************/
|
|
|
|
/* imls - list all images found in flash */
|
|
|
|
/*******************************************************************/
|
2007-07-08 16:51:39 -06:00
|
|
|
#if defined(CONFIG_CMD_IMLS)
|
2011-10-18 05:11:49 -06:00
|
|
|
int do_imls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
2003-07-24 17:38:38 -06:00
|
|
|
{
|
|
|
|
flash_info_t *info;
|
|
|
|
int i, j;
|
2008-02-04 00:28:09 -07:00
|
|
|
void *hdr;
|
2006-08-16 09:54:09 -06:00
|
|
|
|
2008-01-08 10:17:10 -07:00
|
|
|
for (i = 0, info = &flash_info[0];
|
2008-10-16 07:01:15 -06:00
|
|
|
i < CONFIG_SYS_MAX_FLASH_BANKS; ++i, ++info) {
|
2006-08-16 09:54:09 -06:00
|
|
|
|
2003-07-24 17:38:38 -06:00
|
|
|
if (info->flash_id == FLASH_UNKNOWN)
|
|
|
|
goto next_bank;
|
2008-01-08 10:17:10 -07:00
|
|
|
for (j = 0; j < info->sector_count; ++j) {
|
2006-08-16 09:54:09 -06:00
|
|
|
|
2008-02-04 00:28:09 -07:00
|
|
|
hdr = (void *)info->start[j];
|
|
|
|
if (!hdr)
|
2008-01-08 10:14:09 -07:00
|
|
|
goto next_sector;
|
2003-07-24 17:38:38 -06:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
switch (genimg_get_format(hdr)) {
|
2008-02-04 00:28:09 -07:00
|
|
|
case IMAGE_FORMAT_LEGACY:
|
2011-10-18 05:11:49 -06:00
|
|
|
if (!image_check_hcrc(hdr))
|
2008-02-04 00:28:09 -07:00
|
|
|
goto next_sector;
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("Legacy Image at %08lX:\n", (ulong)hdr);
|
|
|
|
image_print_contents(hdr);
|
2008-02-04 00:28:09 -07:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
puts(" Verifying Checksum ... ");
|
|
|
|
if (!image_check_dcrc(hdr)) {
|
|
|
|
puts("Bad Data CRC\n");
|
2008-02-04 00:28:09 -07:00
|
|
|
} else {
|
2011-10-18 05:11:49 -06:00
|
|
|
puts("OK\n");
|
2008-02-04 00:28:09 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
case IMAGE_FORMAT_FIT:
|
2011-10-18 05:11:49 -06:00
|
|
|
if (!fit_check_format(hdr))
|
2008-03-11 05:35:20 -06:00
|
|
|
goto next_sector;
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("FIT Image at %08lX:\n", (ulong)hdr);
|
|
|
|
fit_print_contents(hdr);
|
2008-02-04 00:28:09 -07:00
|
|
|
break;
|
2007-03-31 10:23:51 -06:00
|
|
|
#endif
|
2008-02-04 00:28:09 -07:00
|
|
|
default:
|
2003-07-24 17:38:38 -06:00
|
|
|
goto next_sector;
|
2006-08-16 09:54:09 -06:00
|
|
|
}
|
2006-08-22 08:23:55 -06:00
|
|
|
|
2003-08-05 11:43:17 -06:00
|
|
|
next_sector: ;
|
2006-10-24 22:47:37 -06:00
|
|
|
}
|
2003-08-05 11:43:17 -06:00
|
|
|
next_bank: ;
|
2003-07-24 17:38:38 -06:00
|
|
|
}
|
2006-10-24 22:47:37 -06:00
|
|
|
|
2003-07-24 17:38:38 -06:00
|
|
|
return (0);
|
|
|
|
}
|
2006-10-24 22:47:37 -06:00
|
|
|
|
2003-07-24 17:38:38 -06:00
|
|
|
U_BOOT_CMD(
|
|
|
|
imls, 1, 1, do_imls,
|
2009-01-27 17:03:12 -07:00
|
|
|
"list all images found in flash",
|
2003-07-24 17:38:38 -06:00
|
|
|
"\n"
|
|
|
|
" - Prints information about all images found at sector\n"
|
2009-05-24 09:06:54 -06:00
|
|
|
" boundaries in flash."
|
2003-07-24 17:38:38 -06:00
|
|
|
);
|
2006-06-28 09:41:37 -06:00
|
|
|
#endif
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-01-08 10:17:10 -07:00
|
|
|
/*******************************************************************/
|
2008-01-31 05:59:09 -07:00
|
|
|
/* helper routines */
|
2008-01-08 10:17:10 -07:00
|
|
|
/*******************************************************************/
|
|
|
|
#ifdef CONFIG_SILENT_CONSOLE
|
2011-10-19 06:30:57 -06:00
|
|
|
static void fixup_silent_linux(void)
|
2008-01-08 10:17:10 -07:00
|
|
|
{
|
|
|
|
char buf[256], *start, *end;
|
2011-10-19 06:30:57 -06:00
|
|
|
char *cmdline = getenv("bootargs");
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-01-08 10:17:10 -07:00
|
|
|
/* Only fix cmdline when requested */
|
|
|
|
if (!(gd->flags & GD_FLG_SILENT))
|
|
|
|
return;
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2011-10-19 06:30:57 -06:00
|
|
|
debug("before silent fix-up: %s\n", cmdline);
|
2008-01-08 10:17:10 -07:00
|
|
|
if (cmdline) {
|
2011-10-19 06:30:57 -06:00
|
|
|
start = strstr(cmdline, "console=");
|
|
|
|
if (start) {
|
|
|
|
end = strchr(start, ' ');
|
|
|
|
strncpy(buf, cmdline, (start - cmdline + 8));
|
2008-01-08 10:17:10 -07:00
|
|
|
if (end)
|
2011-10-19 06:30:57 -06:00
|
|
|
strcpy(buf + (start - cmdline + 8), end);
|
2008-01-08 10:17:10 -07:00
|
|
|
else
|
|
|
|
buf[start - cmdline + 8] = '\0';
|
|
|
|
} else {
|
2011-10-19 06:30:57 -06:00
|
|
|
strcpy(buf, cmdline);
|
|
|
|
strcat(buf, " console=");
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
|
|
|
} else {
|
2011-10-19 06:30:57 -06:00
|
|
|
strcpy(buf, "console=");
|
2007-09-06 09:47:40 -06:00
|
|
|
}
|
2007-08-15 16:30:56 -06:00
|
|
|
|
2011-10-19 06:30:57 -06:00
|
|
|
setenv("bootargs", buf);
|
|
|
|
debug("after silent fix-up: %s\n", buf);
|
2008-01-08 10:17:10 -07:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_SILENT_CONSOLE */
|
2007-05-12 07:45:46 -06:00
|
|
|
|
|
|
|
|
2008-01-08 10:17:10 -07:00
|
|
|
/*******************************************************************/
|
|
|
|
/* OS booting routines */
|
|
|
|
/*******************************************************************/
|
2006-10-24 22:47:37 -06:00
|
|
|
|
2008-10-21 16:25:47 -06:00
|
|
|
#ifdef CONFIG_BOOTM_NETBSD
|
2011-10-18 05:11:49 -06:00
|
|
|
static int do_bootm_netbsd(int flag, int argc, char * const argv[],
|
2008-02-27 03:01:04 -07:00
|
|
|
bootm_headers_t *images)
|
2003-04-20 08:04:18 -06:00
|
|
|
{
|
2008-01-08 10:17:10 -07:00
|
|
|
void (*loader)(bd_t *, image_header_t *, char *, char *);
|
2008-02-04 00:28:09 -07:00
|
|
|
image_header_t *os_hdr, *hdr;
|
2008-01-08 10:12:17 -07:00
|
|
|
ulong kernel_data, kernel_len;
|
2008-01-08 10:17:10 -07:00
|
|
|
char *consdev;
|
|
|
|
char *cmdline;
|
|
|
|
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
|
|
|
|
return 1;
|
|
|
|
|
2008-02-04 00:28:09 -07:00
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
if (!images->legacy_hdr_valid) {
|
2011-10-18 05:11:49 -06:00
|
|
|
fit_unsupported_reset("NetBSD");
|
2008-08-15 07:24:45 -06:00
|
|
|
return 1;
|
2007-05-12 07:45:46 -06:00
|
|
|
}
|
|
|
|
#endif
|
2008-02-04 00:28:09 -07:00
|
|
|
hdr = images->legacy_hdr_os;
|
2002-11-02 17:01:44 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Booting a (NetBSD) kernel image
|
|
|
|
*
|
|
|
|
* This process is pretty similar to a standalone application:
|
|
|
|
* The (first part of an multi-) image must be a stage-2 loader,
|
|
|
|
* which in turn is responsible for loading & invoking the actual
|
|
|
|
* kernel. The only differences are the parameters being passed:
|
|
|
|
* besides the board info strucure, the loader expects a command
|
|
|
|
* line, the name of the console device, and (optionally) the
|
|
|
|
* address of the original image header.
|
|
|
|
*/
|
2008-02-04 00:28:09 -07:00
|
|
|
os_hdr = NULL;
|
2011-10-18 05:11:49 -06:00
|
|
|
if (image_check_type(&images->legacy_hdr_os_copy, IH_TYPE_MULTI)) {
|
|
|
|
image_multi_getimg(hdr, 1, &kernel_data, &kernel_len);
|
2008-01-08 10:12:17 -07:00
|
|
|
if (kernel_len)
|
2008-02-04 00:28:09 -07:00
|
|
|
os_hdr = hdr;
|
2008-01-08 10:12:17 -07:00
|
|
|
}
|
2002-11-02 17:01:44 -07:00
|
|
|
|
|
|
|
consdev = "";
|
2011-10-18 05:11:49 -06:00
|
|
|
#if defined(CONFIG_8xx_CONS_SMC1)
|
2002-11-02 17:01:44 -07:00
|
|
|
consdev = "smc1";
|
2011-10-18 05:11:49 -06:00
|
|
|
#elif defined(CONFIG_8xx_CONS_SMC2)
|
2002-11-02 17:01:44 -07:00
|
|
|
consdev = "smc2";
|
2011-10-18 05:11:49 -06:00
|
|
|
#elif defined(CONFIG_8xx_CONS_SCC2)
|
2002-11-02 17:01:44 -07:00
|
|
|
consdev = "scc2";
|
2011-10-18 05:11:49 -06:00
|
|
|
#elif defined(CONFIG_8xx_CONS_SCC3)
|
2002-11-02 17:01:44 -07:00
|
|
|
consdev = "scc3";
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (argc > 2) {
|
|
|
|
ulong len;
|
|
|
|
int i;
|
|
|
|
|
2008-01-08 10:17:10 -07:00
|
|
|
for (i = 2, len = 0; i < argc; i += 1)
|
2011-10-18 05:11:49 -06:00
|
|
|
len += strlen(argv[i]) + 1;
|
|
|
|
cmdline = malloc(len);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-01-08 10:17:10 -07:00
|
|
|
for (i = 2, len = 0; i < argc; i += 1) {
|
2002-11-02 17:01:44 -07:00
|
|
|
if (i > 2)
|
|
|
|
cmdline[len++] = ' ';
|
2011-10-18 05:11:49 -06:00
|
|
|
strcpy(&cmdline[len], argv[i]);
|
|
|
|
len += strlen(argv[i]);
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
2011-10-18 05:11:49 -06:00
|
|
|
} else if ((cmdline = getenv("bootargs")) == NULL) {
|
2002-11-02 17:01:44 -07:00
|
|
|
cmdline = "";
|
|
|
|
}
|
|
|
|
|
2008-08-15 07:24:36 -06:00
|
|
|
loader = (void (*)(bd_t *, image_header_t *, char *, char *))images->ep;
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("## Transferring control to NetBSD stage-2 loader "
|
|
|
|
"(at address %08lx) ...\n",
|
2002-11-02 17:01:44 -07:00
|
|
|
(ulong)loader);
|
|
|
|
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_RUN_OS);
|
2002-11-02 17:01:44 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* NetBSD Stage-2 Loader Parameters:
|
|
|
|
* r3: ptr to board info data
|
|
|
|
* r4: image address
|
|
|
|
* r5: console device
|
|
|
|
* r6: boot args string
|
|
|
|
*/
|
2011-10-18 05:11:49 -06:00
|
|
|
(*loader)(gd->bd, os_hdr, consdev, cmdline);
|
2008-08-15 07:24:45 -06:00
|
|
|
|
|
|
|
return 1;
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
2008-10-21 16:25:47 -06:00
|
|
|
#endif /* CONFIG_BOOTM_NETBSD*/
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-01-08 10:17:10 -07:00
|
|
|
#ifdef CONFIG_LYNXKDI
|
2011-10-18 05:11:49 -06:00
|
|
|
static int do_bootm_lynxkdi(int flag, int argc, char * const argv[],
|
2008-02-27 03:01:04 -07:00
|
|
|
bootm_headers_t *images)
|
2008-01-08 10:17:10 -07:00
|
|
|
{
|
2008-04-11 03:07:49 -06:00
|
|
|
image_header_t *hdr = &images->legacy_hdr_os_copy;
|
2008-02-04 00:28:09 -07:00
|
|
|
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
|
|
|
|
return 1;
|
|
|
|
|
2008-02-04 00:28:09 -07:00
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
if (!images->legacy_hdr_valid) {
|
2011-10-18 05:11:49 -06:00
|
|
|
fit_unsupported_reset("Lynx");
|
2008-08-15 07:24:45 -06:00
|
|
|
return 1;
|
2008-02-04 00:28:09 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
lynxkdi_boot((image_header_t *)hdr);
|
2008-08-15 07:24:45 -06:00
|
|
|
|
|
|
|
return 1;
|
2008-01-08 10:17:10 -07:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_LYNXKDI */
|
|
|
|
|
2008-10-21 16:25:47 -06:00
|
|
|
#ifdef CONFIG_BOOTM_RTEMS
|
2011-10-18 05:11:49 -06:00
|
|
|
static int do_bootm_rtems(int flag, int argc, char * const argv[],
|
2008-02-27 03:01:04 -07:00
|
|
|
bootm_headers_t *images)
|
2008-01-08 10:17:10 -07:00
|
|
|
{
|
|
|
|
void (*entry_point)(bd_t *);
|
2003-04-20 08:04:18 -06:00
|
|
|
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
|
|
|
|
return 1;
|
|
|
|
|
2008-02-04 00:28:09 -07:00
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
if (!images->legacy_hdr_valid) {
|
2011-10-18 05:11:49 -06:00
|
|
|
fit_unsupported_reset("RTEMS");
|
2008-08-15 07:24:45 -06:00
|
|
|
return 1;
|
2008-02-04 00:28:09 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-08-15 07:24:36 -06:00
|
|
|
entry_point = (void (*)(bd_t *))images->ep;
|
2003-04-20 08:04:18 -06:00
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("## Transferring control to RTEMS (at address %08lx) ...\n",
|
2003-04-20 08:04:18 -06:00
|
|
|
(ulong)entry_point);
|
|
|
|
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_RUN_OS);
|
2003-04-20 08:04:18 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* RTEMS Parameters:
|
|
|
|
* r3: ptr to board info data
|
|
|
|
*/
|
2008-01-08 10:17:10 -07:00
|
|
|
(*entry_point)(gd->bd);
|
2008-08-15 07:24:45 -06:00
|
|
|
|
|
|
|
return 1;
|
2003-04-20 08:04:18 -06:00
|
|
|
}
|
2008-10-21 16:25:47 -06:00
|
|
|
#endif /* CONFIG_BOOTM_RTEMS */
|
2003-05-20 08:25:27 -06:00
|
|
|
|
2010-09-28 03:05:36 -06:00
|
|
|
#if defined(CONFIG_BOOTM_OSE)
|
2011-10-18 05:11:49 -06:00
|
|
|
static int do_bootm_ose(int flag, int argc, char * const argv[],
|
2010-09-28 03:05:36 -06:00
|
|
|
bootm_headers_t *images)
|
|
|
|
{
|
|
|
|
void (*entry_point)(void);
|
|
|
|
|
|
|
|
if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
if (!images->legacy_hdr_valid) {
|
2011-10-18 05:11:49 -06:00
|
|
|
fit_unsupported_reset("OSE");
|
2010-09-28 03:05:36 -06:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
entry_point = (void (*)(void))images->ep;
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("## Transferring control to OSE (at address %08lx) ...\n",
|
2010-09-28 03:05:36 -06:00
|
|
|
(ulong)entry_point);
|
|
|
|
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_RUN_OS);
|
2010-09-28 03:05:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* OSE Parameters:
|
|
|
|
* None
|
|
|
|
*/
|
|
|
|
(*entry_point)();
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_BOOTM_OSE */
|
|
|
|
|
2007-07-08 16:51:39 -06:00
|
|
|
#if defined(CONFIG_CMD_ELF)
|
2011-10-18 05:11:49 -06:00
|
|
|
static int do_bootm_vxworks(int flag, int argc, char * const argv[],
|
2008-02-27 03:01:04 -07:00
|
|
|
bootm_headers_t *images)
|
2002-11-02 17:01:44 -07:00
|
|
|
{
|
|
|
|
char str[80];
|
2003-05-20 08:25:27 -06:00
|
|
|
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
|
|
|
|
return 1;
|
|
|
|
|
2008-02-04 00:28:09 -07:00
|
|
|
#if defined(CONFIG_FIT)
|
2008-04-11 03:07:49 -06:00
|
|
|
if (!images->legacy_hdr_valid) {
|
2011-10-18 05:11:49 -06:00
|
|
|
fit_unsupported_reset("VxWorks");
|
2008-08-15 07:24:45 -06:00
|
|
|
return 1;
|
2008-02-04 00:28:09 -07:00
|
|
|
}
|
|
|
|
#endif
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-08-15 07:24:36 -06:00
|
|
|
sprintf(str, "%lx", images->ep); /* write entry-point into string */
|
2002-11-02 17:01:44 -07:00
|
|
|
setenv("loadaddr", str);
|
2008-08-15 07:24:45 -06:00
|
|
|
do_bootvx(NULL, 0, 0, NULL);
|
|
|
|
|
|
|
|
return 1;
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
|
|
|
|
2010-06-28 14:00:46 -06:00
|
|
|
static int do_bootm_qnxelf(int flag, int argc, char * const argv[],
|
2008-02-27 03:01:04 -07:00
|
|
|
bootm_headers_t *images)
|
2002-11-02 17:01:44 -07:00
|
|
|
{
|
|
|
|
char *local_args[2];
|
|
|
|
char str[16];
|
2008-02-04 00:28:09 -07:00
|
|
|
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
|
|
|
|
return 1;
|
|
|
|
|
2008-02-04 00:28:09 -07:00
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
if (!images->legacy_hdr_valid) {
|
2011-10-18 05:11:49 -06:00
|
|
|
fit_unsupported_reset("QNX");
|
2008-08-15 07:24:45 -06:00
|
|
|
return 1;
|
2008-02-04 00:28:09 -07:00
|
|
|
}
|
|
|
|
#endif
|
2002-11-02 17:01:44 -07:00
|
|
|
|
2008-08-15 07:24:36 -06:00
|
|
|
sprintf(str, "%lx", images->ep); /* write entry-point into string */
|
2002-11-02 17:01:44 -07:00
|
|
|
local_args[0] = argv[0];
|
|
|
|
local_args[1] = str; /* and provide it via the arguments */
|
2008-08-15 07:24:45 -06:00
|
|
|
do_bootelf(NULL, 0, 2, local_args);
|
|
|
|
|
|
|
|
return 1;
|
2002-11-02 17:01:44 -07:00
|
|
|
}
|
2007-07-10 10:02:44 -06:00
|
|
|
#endif
|
2008-09-08 13:56:49 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_INTEGRITY
|
2011-10-18 05:11:49 -06:00
|
|
|
static int do_bootm_integrity(int flag, int argc, char * const argv[],
|
2008-09-08 13:56:49 -06:00
|
|
|
bootm_headers_t *images)
|
|
|
|
{
|
|
|
|
void (*entry_point)(void);
|
|
|
|
|
bootm: Add subcommands
Add the ability to break the steps of the bootm command into several
subcommands: start, loados, ramdisk, fdt, bdt, cmdline, prep, go.
This allows us to do things like manipulate device trees before
they are passed to a booting kernel or setup memory for a secondary
core in multicore situations.
Not all OS types support all subcommands (currently only start, loados,
ramdisk, fdt, and go are supported).
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>
2008-10-21 16:25:45 -06:00
|
|
|
if ((flag != 0) && (flag != BOOTM_STATE_OS_GO))
|
|
|
|
return 1;
|
|
|
|
|
2008-09-08 13:56:49 -06:00
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
if (!images->legacy_hdr_valid) {
|
2011-10-18 05:11:49 -06:00
|
|
|
fit_unsupported_reset("INTEGRITY");
|
2008-09-08 13:56:49 -06:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
entry_point = (void (*)(void))images->ep;
|
|
|
|
|
2011-10-18 05:11:49 -06:00
|
|
|
printf("## Transferring control to INTEGRITY (at address %08lx) ...\n",
|
2008-09-08 13:56:49 -06:00
|
|
|
(ulong)entry_point);
|
|
|
|
|
2012-02-13 06:51:18 -07:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_RUN_OS);
|
2008-09-08 13:56:49 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* INTEGRITY Parameters:
|
|
|
|
* None
|
|
|
|
*/
|
|
|
|
(*entry_point)();
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
2012-03-14 15:52:45 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_CMD_BOOTZ
|
|
|
|
|
|
|
|
static int __bootz_setup(void *image, void **start, void **end)
|
|
|
|
{
|
|
|
|
/* Please define bootz_setup() for your platform */
|
|
|
|
|
|
|
|
puts("Your platform's zImage format isn't supported yet!\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
int bootz_setup(void *image, void **start, void **end)
|
|
|
|
__attribute__((weak, alias("__bootz_setup")));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* zImage booting support
|
|
|
|
*/
|
|
|
|
static int bootz_start(cmd_tbl_t *cmdtp, int flag, int argc,
|
|
|
|
char * const argv[], bootm_headers_t *images)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
void *zi_start, *zi_end;
|
|
|
|
|
|
|
|
memset(images, 0, sizeof(bootm_headers_t));
|
|
|
|
|
|
|
|
boot_start_lmb(images);
|
|
|
|
|
|
|
|
/* Setup Linux kernel zImage entry point */
|
|
|
|
if (argc < 2) {
|
|
|
|
images->ep = load_addr;
|
|
|
|
debug("* kernel: default image load address = 0x%08lx\n",
|
|
|
|
load_addr);
|
|
|
|
} else {
|
|
|
|
images->ep = simple_strtoul(argv[1], NULL, 16);
|
|
|
|
debug("* kernel: cmdline image address = 0x%08lx\n",
|
|
|
|
images->ep);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = bootz_setup((void *)images->ep, &zi_start, &zi_end);
|
|
|
|
if (ret != 0)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
lmb_reserve(&images->lmb, images->ep, zi_end - zi_start);
|
|
|
|
|
|
|
|
/* Find ramdisk */
|
|
|
|
ret = boot_get_ramdisk(argc, argv, images, IH_INITRD_ARCH,
|
|
|
|
&images->rd_start, &images->rd_end);
|
|
|
|
if (ret) {
|
|
|
|
puts("Ramdisk image is corrupt or invalid\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(CONFIG_OF_LIBFDT)
|
|
|
|
/* find flattened device tree */
|
|
|
|
ret = boot_get_fdt(flag, argc, argv, images,
|
|
|
|
&images->ft_addr, &images->ft_len);
|
|
|
|
if (ret) {
|
|
|
|
puts("Could not find a valid device tree\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_working_fdt_addr(images->ft_addr);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int do_bootz(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
|
|
{
|
|
|
|
bootm_headers_t images;
|
|
|
|
|
|
|
|
if (bootz_start(cmdtp, flag, argc, argv, &images))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have reached the point of no return: we are going to
|
|
|
|
* overwrite all exception vector code, so we cannot easily
|
|
|
|
* recover from any failures any more...
|
|
|
|
*/
|
2012-05-18 23:38:19 -06:00
|
|
|
disable_interrupts();
|
2012-03-14 15:52:45 -06:00
|
|
|
|
2012-08-03 04:59:08 -06:00
|
|
|
#ifdef CONFIG_NETCONSOLE
|
|
|
|
/* Stop the ethernet stack if NetConsole could have left it up */
|
|
|
|
eth_halt();
|
|
|
|
#endif
|
|
|
|
|
2012-03-14 15:52:45 -06:00
|
|
|
#if defined(CONFIG_CMD_USB)
|
|
|
|
/*
|
|
|
|
* turn off USB to prevent the host controller from writing to the
|
|
|
|
* SDRAM while Linux is booting. This could happen (at least for OHCI
|
|
|
|
* controller), because the HCCA (Host Controller Communication Area)
|
|
|
|
* lies within the SDRAM and the host controller writes continously to
|
|
|
|
* this area (as busmaster!). The HccaFrameNumber is for example
|
|
|
|
* updated every 1 ms within the HCCA structure in SDRAM! For more
|
|
|
|
* details see the OpenHCI specification.
|
|
|
|
*/
|
|
|
|
usb_stop();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_SILENT_CONSOLE
|
|
|
|
fixup_silent_linux();
|
|
|
|
#endif
|
|
|
|
arch_preboot_os();
|
|
|
|
|
|
|
|
do_bootm_linux(0, argc, argv, &images);
|
|
|
|
#ifdef DEBUG
|
|
|
|
puts("\n## Control returned to monitor - resetting...\n");
|
|
|
|
#endif
|
|
|
|
do_reset(cmdtp, flag, argc, argv);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
U_BOOT_CMD(
|
|
|
|
bootz, CONFIG_SYS_MAXARGS, 1, do_bootz,
|
|
|
|
"boot Linux zImage image from memory",
|
2012-03-18 05:47:58 -06:00
|
|
|
"[addr [initrd[:size]] [fdt]]\n"
|
|
|
|
" - boot Linux zImage stored in memory\n"
|
2012-03-14 15:52:45 -06:00
|
|
|
"\tThe argument 'initrd' is optional and specifies the address\n"
|
2012-03-18 05:47:58 -06:00
|
|
|
"\tof the initrd in memory. The optional argument ':size' allows\n"
|
|
|
|
"\tspecifying the size of RAW initrd.\n"
|
2012-03-14 15:52:45 -06:00
|
|
|
#if defined(CONFIG_OF_LIBFDT)
|
|
|
|
"\tWhen booting a Linux kernel which requires a flat device-tree\n"
|
|
|
|
"\ta third argument is required which is the address of the\n"
|
|
|
|
"\tdevice-tree blob. To boot that kernel without an initrd image,\n"
|
|
|
|
"\tuse a '-' for the second argument. If you do not pass a third\n"
|
|
|
|
"\ta bd_info struct will be passed instead\n"
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
#endif /* CONFIG_CMD_BOOTZ */
|