[people/ms/u-boot.git] / arch / x86 / lib / zimage.c

/*
 * Copyright (c) 2011 The Chromium OS Authors.
 * (C) Copyright 2002
 * Daniel Engström, Omicron Ceti AB, <daniel@omicron.se>
 *
 * 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
 */

/*
 * Linux x86 zImage and bzImage loading
 *
 * based on the procdure described in
 * linux/Documentation/i386/boot.txt
 */

#include <common.h>
#include <asm/io.h>
#include <asm/ptrace.h>
#include <asm/zimage.h>
#include <asm/realmode.h>
#include <asm/byteorder.h>
#include <asm/bootparam.h>
#ifdef CONFIG_SYS_COREBOOT
#include <asm/arch/timestamp.h>
#endif

/*
 * Memory lay-out:
 *
 * relative to setup_base (which is 0x90000 currently)
 *
 *	0x0000-0x7FFF	Real mode kernel
 *	0x8000-0x8FFF	Stack and heap
 *	0x9000-0x90FF	Kernel command line
 */
#define DEFAULT_SETUP_BASE	0x90000
#define COMMAND_LINE_OFFSET	0x9000
#define HEAP_END_OFFSET		0x8e00

#define COMMAND_LINE_SIZE	2048

unsigned generic_install_e820_map(unsigned max_entries,
				  struct e820entry *entries)
{
	return 0;
}

unsigned install_e820_map(unsigned max_entries,
			  struct e820entry *entries)
	__attribute__((weak, alias("generic_install_e820_map")));

static void build_command_line(char *command_line, int auto_boot)
{
	char *env_command_line;

	command_line[0] = '\0';

	env_command_line =  getenv("bootargs");

	/* set console= argument if we use a serial console */
	if (!strstr(env_command_line, "console=")) {
		if (!strcmp(getenv("stdout"), "serial")) {

			/* We seem to use serial console */
			sprintf(command_line, "console=ttyS0,%s ",
				getenv("baudrate"));
		}
	}

	if (auto_boot)
		strcat(command_line, "auto ");

	if (env_command_line)
		strcat(command_line, env_command_line);

	printf("Kernel command line: \"%s\"\n", command_line);
}

static int kernel_magic_ok(struct setup_header *hdr)
{
	if (KERNEL_MAGIC != hdr->boot_flag) {
		printf("Error: Invalid Boot Flag "
			"(found 0x%04x, expected 0x%04x)\n",
			hdr->boot_flag, KERNEL_MAGIC);
		return 0;
	} else {
		printf("Valid Boot Flag\n");
		return 1;
	}
}

static int get_boot_protocol(struct setup_header *hdr)
{
	if (hdr->header == KERNEL_V2_MAGIC) {
		printf("Magic signature found\n");
		return hdr->version;
	} else {
		/* Very old kernel */
		printf("Magic signature not found\n");
		return 0x0100;
	}
}

struct boot_params *load_zimage(char *image, unsigned long kernel_size,
				void **load_address)
{
	struct boot_params *setup_base;
	int setup_size;
	int bootproto;
	int big_image;

	struct boot_params *params = (struct boot_params *)image;
	struct setup_header *hdr = &params->hdr;

	/* base address for real-mode segment */
	setup_base = (struct boot_params *)DEFAULT_SETUP_BASE;

	if (!kernel_magic_ok(hdr))
		return 0;

	/* determine size of setup */
	if (0 == hdr->setup_sects) {
		printf("Setup Sectors = 0 (defaulting to 4)\n");
		setup_size = 5 * 512;
	} else {
		setup_size = (hdr->setup_sects + 1) * 512;
	}

	printf("Setup Size = 0x%8.8lx\n", (ulong)setup_size);

	if (setup_size > SETUP_MAX_SIZE)
		printf("Error: Setup is too large (%d bytes)\n", setup_size);

	/* determine boot protocol version */
	bootproto = get_boot_protocol(hdr);

	printf("Using boot protocol version %x.%02x\n",
	       (bootproto & 0xff00) >> 8, bootproto & 0xff);

	if (bootproto >= 0x0200) {
		if (hdr->setup_sects >= 15) {
			printf("Linux kernel version %s\n",
				(char *)params +
				hdr->kernel_version + 0x200);
		} else {
			printf("Setup Sectors < 15 - "
				"Cannot print kernel version.\n");
		}
	}

	/* Determine image type */
	big_image = (bootproto >= 0x0200) &&
		    (hdr->loadflags & BIG_KERNEL_FLAG);

	/* Determine load address */
	if (big_image)
		*load_address = (void *)BZIMAGE_LOAD_ADDR;
	else
		*load_address = (void *)ZIMAGE_LOAD_ADDR;

#if (defined CONFIG_ZBOOT_32 || defined CONFIG_X86_NO_REAL_MODE)
	printf("Building boot_params at 0x%8.8lx\n", (ulong)setup_base);
	memset(setup_base, 0, sizeof(*setup_base));
	setup_base->hdr = params->hdr;
#else
	/* load setup */
	printf("Moving Real-Mode Code to 0x%8.8lx (%d bytes)\n",
	       (ulong)setup_base, setup_size);
	memmove(setup_base, image, setup_size);
#endif

	if (bootproto >= 0x0204)
		kernel_size = hdr->syssize * 16;
	else
		kernel_size -= setup_size;

	if (bootproto == 0x0100) {
		/*
		 * A very old kernel MUST have its real-mode code
		 * loaded at 0x90000
		 */
		if ((u32)setup_base != 0x90000) {
			/* Copy the real-mode kernel */
			memmove((void *)0x90000, setup_base, setup_size);

			/* Copy the command line */
			memmove((void *)0x99000,
				(u8 *)setup_base + COMMAND_LINE_OFFSET,
				COMMAND_LINE_SIZE);

			 /* Relocated */
			setup_base = (struct boot_params *)0x90000;
		}

		/* It is recommended to clear memory up to the 32K mark */
		memset((u8 *)0x90000 + setup_size, 0,
		       SETUP_MAX_SIZE - setup_size);
	}

	if (big_image) {
		if (kernel_size > BZIMAGE_MAX_SIZE) {
			printf("Error: bzImage kernel too big! "
				"(size: %ld, max: %d)\n",
				kernel_size, BZIMAGE_MAX_SIZE);
			return 0;
		}
	} else if ((kernel_size) > ZIMAGE_MAX_SIZE) {
		printf("Error: zImage kernel too big! (size: %ld, max: %d)\n",
		       kernel_size, ZIMAGE_MAX_SIZE);
		return 0;
	}

	printf("Loading %s at address %p (%ld bytes)\n",
		big_image ? "bzImage" : "zImage", *load_address, kernel_size);

	memmove(*load_address, image + setup_size, kernel_size);

	return setup_base;
}

int setup_zimage(struct boot_params *setup_base, char *cmd_line, int auto_boot,
		 unsigned long initrd_addr, unsigned long initrd_size)
{
	struct setup_header *hdr = &setup_base->hdr;
	int bootproto = get_boot_protocol(hdr);

#if (defined CONFIG_ZBOOT_32 || defined CONFIG_X86_NO_REAL_MODE)
	setup_base->e820_entries = install_e820_map(
		ARRAY_SIZE(setup_base->e820_map), setup_base->e820_map);
#endif

	if (bootproto == 0x0100) {
		setup_base->screen_info.cl_magic = COMMAND_LINE_MAGIC;
		setup_base->screen_info.cl_offset = COMMAND_LINE_OFFSET;
	}
	if (bootproto >= 0x0200) {
		hdr->type_of_loader = 8;

		if (initrd_addr) {
			printf("Initial RAM disk at linear address "
			       "0x%08lx, size %ld bytes\n",
			       initrd_addr, initrd_size);

			hdr->ramdisk_image = initrd_addr;
			hdr->ramdisk_size = initrd_size;
		}
	}

	if (bootproto >= 0x0201) {
		hdr->heap_end_ptr = HEAP_END_OFFSET;
		hdr->loadflags |= HEAP_FLAG;
	}

	if (bootproto >= 0x0202) {
		hdr->cmd_line_ptr = (uintptr_t)cmd_line;
	} else if (bootproto >= 0x0200) {
		setup_base->screen_info.cl_magic = COMMAND_LINE_MAGIC;
		setup_base->screen_info.cl_offset =
			(uintptr_t)cmd_line - (uintptr_t)setup_base;

		hdr->setup_move_size = 0x9100;
	}

	/* build command line at COMMAND_LINE_OFFSET */
	build_command_line(cmd_line, auto_boot);
	return 0;
}

void boot_zimage(void *setup_base, void *load_address)
{
	printf("\nStarting kernel ...\n\n");

#ifdef CONFIG_SYS_COREBOOT
	timestamp_add_now(TS_U_BOOT_START_KERNEL);
#endif
#if defined CONFIG_ZBOOT_32
	/*
	 * Set %ebx, %ebp, and %edi to 0, %esi to point to the boot_params
	 * structure, and then jump to the kernel. We assume that %cs is
	 * 0x10, 4GB flat, and read/execute, and the data segments are 0x18,
	 * 4GB flat, and read/write. U-boot is setting them up that way for
	 * itself in arch/i386/cpu/cpu.c.
	 */
	__asm__ __volatile__ (
	"movl $0, %%ebp		\n"
	"cli			\n"
	"jmp %[kernel_entry]	\n"
	:: [kernel_entry]"a"(load_address),
	   [boot_params] "S"(setup_base),
	   "b"(0), "D"(0)
	:  "%ebp"
	);
#else
	struct pt_regs regs;

	memset(&regs, 0, sizeof(struct pt_regs));
	regs.xds = (u32)setup_base >> 4;
	regs.xes = regs.xds;
	regs.xss = regs.xds;
	regs.esp = 0x9000;
	regs.eflags = 0;
	enter_realmode(((u32)setup_base + SETUP_START_OFFSET) >> 4, 0,
		       &regs, &regs);
#endif
}

void setup_pcat_compatibility(void)
	__attribute__((weak, alias("__setup_pcat_compatibility")));

void __setup_pcat_compatibility(void)
{
}

int do_zboot(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
{
	struct boot_params *base_ptr;
	void *bzImage_addr = NULL;
	void *load_address;
	char *s;
	ulong bzImage_size = 0;
	ulong initrd_addr = 0;
	ulong initrd_size = 0;

	disable_interrupts();

	/* Setup board for maximum PC/AT Compatibility */
	setup_pcat_compatibility();

	if (argc >= 2) {
		/* argv[1] holds the address of the bzImage */
		s = argv[1];
	} else {
		s = getenv("fileaddr");
	}

	if (s)
		bzImage_addr = (void *)simple_strtoul(s, NULL, 16);

	if (argc >= 3) {
		/* argv[2] holds the size of the bzImage */
		bzImage_size = simple_strtoul(argv[2], NULL, 16);
	}

	if (argc >= 4)
		initrd_addr = simple_strtoul(argv[3], NULL, 16);
	if (argc >= 5)
		initrd_size = simple_strtoul(argv[4], NULL, 16);

	/* Lets look for */
	base_ptr = load_zimage(bzImage_addr, bzImage_size, &load_address);

	if (!base_ptr) {
		printf("## Kernel loading failed ...\n");
		return -1;
	}
	if (setup_zimage(base_ptr, (char *)base_ptr + COMMAND_LINE_OFFSET,
			0, initrd_addr, initrd_size)) {
		printf("Setting up boot parameters failed ...\n");
		return -1;
	}

	printf("## Transferring control to Linux "
	       "(at address %08x) ...\n",
	       (u32)base_ptr);

	/* we assume that the kernel is in place */
	boot_zimage(base_ptr, load_address);
	/* does not return */

	return -1;
}

U_BOOT_CMD(
	zboot, 5, 0,	do_zboot,
	"Boot bzImage",
	"[addr] [size] [initrd addr] [initrd size]\n"
	"      addr -        The optional starting address of the bzimage.\n"
	"                    If not set it defaults to the environment\n"
	"                    variable \"fileaddr\".\n"
	"      size -        The optional size of the bzimage. Defaults to\n"
	"                    zero.\n"
	"      initrd addr - The address of the initrd image to use, if any.\n"
	"      initrd size - The size of the initrd image to use, if any.\n"
);
Commit	Line	Data
2262cfee	1	/*
d3a2bc3f	2	* Copyright (c) 2011 The Chromium OS Authors.
2262cfee	3	* (C) Copyright 2002
fa82f871	4	* Daniel Engström, Omicron Ceti AB, <daniel@omicron.se>
8bde7f77	5	*
2262cfee WD	6	* See file CREDITS for list of people who contributed to this
	7	* project.
	8	*
	9	* This program is free software; you can redistribute it and/or
	10	* modify it under the terms of the GNU General Public License as
	11	* published by the Free Software Foundation; either version 2 of
	12	* the License, or (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	22	* MA 02111-1307 USA
	23	*/
	24
8bde7f77	25	/*
dbf7115a	26	* Linux x86 zImage and bzImage loading
8bde7f77 WD	27	*
8bde7f77 WD	28	* based on the procdure described in
2262cfee WD	29	* linux/Documentation/i386/boot.txt
	30	*/
	31
	32	#include <common.h>
	33	#include <asm/io.h>
	34	#include <asm/ptrace.h>
	35	#include <asm/zimage.h>
	36	#include <asm/realmode.h>
	37	#include <asm/byteorder.h>
95ffaba3	38	#include <asm/bootparam.h>
3cdc18a8 VB	39	#ifdef CONFIG_SYS_COREBOOT
	40	#include <asm/arch/timestamp.h>
	41	#endif
2262cfee WD	42
	43	/*
	44	* Memory lay-out:
8bde7f77	45	*
2262cfee	46	* relative to setup_base (which is 0x90000 currently)
8bde7f77 WD	47	*
8bde7f77 WD	48	* 0x0000-0x7FFF Real mode kernel
2262cfee WD	49	* 0x8000-0x8FFF Stack and heap
	50	* 0x9000-0x90FF Kernel command line
	51	*/
83088afb GR	52	#define DEFAULT_SETUP_BASE 0x90000
	53	#define COMMAND_LINE_OFFSET 0x9000
	54	#define HEAP_END_OFFSET 0x8e00
2262cfee	55
83088afb	56	#define COMMAND_LINE_SIZE 2048
2262cfee	57
233dbc11 GB	58	unsigned generic_install_e820_map(unsigned max_entries,
	59	struct e820entry *entries)
	60	{
	61	return 0;
	62	}
	63
	64	unsigned install_e820_map(unsigned max_entries,
	65	struct e820entry *entries)
	66	__attribute__((weak, alias("generic_install_e820_map")));
	67
2262cfee WD	68	static void build_command_line(char *command_line, int auto_boot)
	69	{
	70	char *env_command_line;
8bde7f77	71
2262cfee	72	command_line[0] = '\0';
8bde7f77	73
2262cfee	74	env_command_line = getenv("bootargs");
8bde7f77	75
2262cfee	76	/* set console= argument if we use a serial console */
83088afb GR	77	if (!strstr(env_command_line, "console=")) {
83088afb GR	78	if (!strcmp(getenv("stdout"), "serial")) {
8bde7f77	79
2262cfee	80	/* We seem to use serial console */
8bde7f77	81	sprintf(command_line, "console=ttyS0,%s ",
83088afb	82	getenv("baudrate"));
2262cfee WD	83	}
2262cfee WD	84	}
8bde7f77	85
83088afb	86	if (auto_boot)
2262cfee	87	strcat(command_line, "auto ");
8bde7f77	88
83088afb	89	if (env_command_line)
2262cfee	90	strcat(command_line, env_command_line);
8bde7f77	91
2262cfee WD	92	printf("Kernel command line: \"%s\"\n", command_line);
	93	}
	94
69370d14	95	static int kernel_magic_ok(struct setup_header *hdr)
2262cfee	96	{
95ffaba3	97	if (KERNEL_MAGIC != hdr->boot_flag) {
d3a2bc3f GB	98	printf("Error: Invalid Boot Flag "
	99	"(found 0x%04x, expected 0x%04x)\n",
	100	hdr->boot_flag, KERNEL_MAGIC);
2262cfee	101	return 0;
95ffaba3 GR	102	} else {
95ffaba3 GR	103	printf("Valid Boot Flag\n");
69370d14	104	return 1;
2262cfee	105	}
69370d14	106	}
8bde7f77	107
69370d14 GB	108	static int get_boot_protocol(struct setup_header *hdr)
	109	{
	110	if (hdr->header == KERNEL_V2_MAGIC) {
95ffaba3	111	printf("Magic signature found\n");
69370d14	112	return hdr->version;
2262cfee WD	113	} else {
2262cfee WD	114	/* Very old kernel */
95ffaba3	115	printf("Magic signature not found\n");
69370d14	116	return 0x0100;
2262cfee	117	}
69370d14 GB	118	}
	119
	120	struct boot_params load_zimage(char image, unsigned long kernel_size,
	121	void **load_address)
	122	{
	123	struct boot_params *setup_base;
	124	int setup_size;
	125	int bootproto;
	126	int big_image;
	127
	128	struct boot_params params = (struct boot_params )image;
	129	struct setup_header *hdr = &params->hdr;
	130
	131	/* base address for real-mode segment */
	132	setup_base = (struct boot_params *)DEFAULT_SETUP_BASE;
	133
	134	if (!kernel_magic_ok(hdr))
	135	return 0;
8bde7f77	136
2262cfee	137	/* determine size of setup */
95ffaba3 GR	138	if (0 == hdr->setup_sects) {
95ffaba3 GR	139	printf("Setup Sectors = 0 (defaulting to 4)\n");
2262cfee WD	140	setup_size = 5 * 512;
2262cfee WD	141	} else {
95ffaba3	142	setup_size = (hdr->setup_sects + 1) * 512;
2262cfee	143	}
8bde7f77	144
95ffaba3 GR	145	printf("Setup Size = 0x%8.8lx\n", (ulong)setup_size);
95ffaba3 GR	146
83088afb	147	if (setup_size > SETUP_MAX_SIZE)
2262cfee	148	printf("Error: Setup is too large (%d bytes)\n", setup_size);
8bde7f77	149
69370d14 GB	150	/* determine boot protocol version */
	151	bootproto = get_boot_protocol(hdr);
	152
	153	printf("Using boot protocol version %x.%02x\n",
	154	(bootproto & 0xff00) >> 8, bootproto & 0xff);
	155
	156	if (bootproto >= 0x0200) {
	157	if (hdr->setup_sects >= 15) {
	158	printf("Linux kernel version %s\n",
	159	(char *)params +
	160	hdr->kernel_version + 0x200);
	161	} else {
	162	printf("Setup Sectors < 15 - "
	163	"Cannot print kernel version.\n");
	164	}
	165	}
	166
2262cfee	167	/* Determine image type */
83088afb GR	168	big_image = (bootproto >= 0x0200) &&
83088afb GR	169	(hdr->loadflags & BIG_KERNEL_FLAG);
8bde7f77	170
95ffaba3	171	/* Determine load address */
d3a2bc3f	172	if (big_image)
233dbc11	173	load_address = (void )BZIMAGE_LOAD_ADDR;
d3a2bc3f	174	else
233dbc11	175	load_address = (void )ZIMAGE_LOAD_ADDR;
8bde7f77	176
5b5ece9e	177	#if (defined CONFIG_ZBOOT_32 \|\| defined CONFIG_X86_NO_REAL_MODE)
233dbc11 GB	178	printf("Building boot_params at 0x%8.8lx\n", (ulong)setup_base);
	179	memset(setup_base, 0, sizeof(*setup_base));
	180	setup_base->hdr = params->hdr;
233dbc11	181	#else
2262cfee	182	/* load setup */
83088afb GR	183	printf("Moving Real-Mode Code to 0x%8.8lx (%d bytes)\n",
83088afb GR	184	(ulong)setup_base, setup_size);
2262cfee	185	memmove(setup_base, image, setup_size);
233dbc11	186	#endif
8bde7f77	187
69370d14 GB	188	if (bootproto >= 0x0204)
	189	kernel_size = hdr->syssize * 16;
	190	else
	191	kernel_size -= setup_size;
8bde7f77	192
8bde7f77	193	if (bootproto == 0x0100) {
83088afb GR	194	/*
	195	* A very old kernel MUST have its real-mode code
	196	* loaded at 0x90000
	197	*/
2262cfee WD	198	if ((u32)setup_base != 0x90000) {
2262cfee WD	199	/* Copy the real-mode kernel */
83088afb GR	200	memmove((void *)0x90000, setup_base, setup_size);
83088afb GR	201
2262cfee	202	/* Copy the command line */
83088afb	203	memmove((void *)0x99000,
d3a2bc3f	204	(u8 *)setup_base + COMMAND_LINE_OFFSET,
83088afb	205	COMMAND_LINE_SIZE);
8bde7f77	206
83088afb	207	/* Relocated */
d3a2bc3f	208	setup_base = (struct boot_params *)0x90000;
2262cfee	209	}
8bde7f77	210
2262cfee	211	/* It is recommended to clear memory up to the 32K mark */
d3a2bc3f GB	212	memset((u8 *)0x90000 + setup_size, 0,
d3a2bc3f GB	213	SETUP_MAX_SIZE - setup_size);
2262cfee	214	}
8bde7f77	215
69370d14 GB	216	if (big_image) {
	217	if (kernel_size > BZIMAGE_MAX_SIZE) {
	218	printf("Error: bzImage kernel too big! "
	219	"(size: %ld, max: %d)\n",
	220	kernel_size, BZIMAGE_MAX_SIZE);
	221	return 0;
	222	}
	223	} else if ((kernel_size) > ZIMAGE_MAX_SIZE) {
	224	printf("Error: zImage kernel too big! (size: %ld, max: %d)\n",
	225	kernel_size, ZIMAGE_MAX_SIZE);
	226	return 0;
	227	}
	228
	229	printf("Loading %s at address %p (%ld bytes)\n",
	230	big_image ? "bzImage" : "zImage", *load_address, kernel_size);
	231
	232	memmove(*load_address, image + setup_size, kernel_size);
	233
	234	return setup_base;
	235	}
	236
	237	int setup_zimage(struct boot_params setup_base, char cmd_line, int auto_boot,
	238	unsigned long initrd_addr, unsigned long initrd_size)
	239	{
	240	struct setup_header *hdr = &setup_base->hdr;
	241	int bootproto = get_boot_protocol(hdr);
	242
5b5ece9e	243	#if (defined CONFIG_ZBOOT_32 \|\| defined CONFIG_X86_NO_REAL_MODE)
69370d14 GB	244	setup_base->e820_entries = install_e820_map(
	245	ARRAY_SIZE(setup_base->e820_map), setup_base->e820_map);
	246	#endif
95ffaba3	247
69370d14 GB	248	if (bootproto == 0x0100) {
	249	setup_base->screen_info.cl_magic = COMMAND_LINE_MAGIC;
	250	setup_base->screen_info.cl_offset = COMMAND_LINE_OFFSET;
	251	}
2262cfee	252	if (bootproto >= 0x0200) {
95ffaba3 GR	253	hdr->type_of_loader = 8;
95ffaba3 GR	254
2262cfee	255	if (initrd_addr) {
d3a2bc3f GB	256	printf("Initial RAM disk at linear address "
d3a2bc3f GB	257	"0x%08lx, size %ld bytes\n",
2262cfee	258	initrd_addr, initrd_size);
8bde7f77	259
95ffaba3 GR	260	hdr->ramdisk_image = initrd_addr;
95ffaba3 GR	261	hdr->ramdisk_size = initrd_size;
2262cfee WD	262	}
2262cfee WD	263	}
8bde7f77	264
2262cfee	265	if (bootproto >= 0x0201) {
95ffaba3 GR	266	hdr->heap_end_ptr = HEAP_END_OFFSET;
95ffaba3 GR	267	hdr->loadflags \|= HEAP_FLAG;
2262cfee	268	}
8bde7f77	269
2262cfee	270	if (bootproto >= 0x0202) {
69370d14	271	hdr->cmd_line_ptr = (uintptr_t)cmd_line;
2262cfee	272	} else if (bootproto >= 0x0200) {
d3a2bc3f	273	setup_base->screen_info.cl_magic = COMMAND_LINE_MAGIC;
69370d14 GB	274	setup_base->screen_info.cl_offset =
69370d14 GB	275	(uintptr_t)cmd_line - (uintptr_t)setup_base;
95ffaba3 GR	276
95ffaba3 GR	277	hdr->setup_move_size = 0x9100;
2262cfee	278	}
2262cfee	279
2262cfee	280	/* build command line at COMMAND_LINE_OFFSET */
69370d14 GB	281	build_command_line(cmd_line, auto_boot);
69370d14 GB	282	return 0;
2262cfee WD	283	}
2262cfee WD	284
233dbc11	285	void boot_zimage(void setup_base, void load_address)
2262cfee	286	{
233dbc11 GB	287	printf("\nStarting kernel ...\n\n");
233dbc11 GB	288
3cdc18a8 VB	289	#ifdef CONFIG_SYS_COREBOOT
	290	timestamp_add_now(TS_U_BOOT_START_KERNEL);
	291	#endif
233dbc11 GB	292	#if defined CONFIG_ZBOOT_32
	293	/*
	294	* Set %ebx, %ebp, and %edi to 0, %esi to point to the boot_params
	295	* structure, and then jump to the kernel. We assume that %cs is
	296	* 0x10, 4GB flat, and read/execute, and the data segments are 0x18,
	297	* 4GB flat, and read/write. U-boot is setting them up that way for
	298	* itself in arch/i386/cpu/cpu.c.
	299	*/
	300	__asm__ __volatile__ (
	301	"movl $0, %%ebp \n"
	302	"cli \n"
	303	"jmp %[kernel_entry] \n"
	304	:: [kernel_entry]"a"(load_address),
	305	[boot_params] "S"(setup_base),
	306	"b"(0), "D"(0)
	307	: "%ebp"
	308	);
	309	#else
2262cfee	310	struct pt_regs regs;
8bde7f77	311
2262cfee WD	312	memset(&regs, 0, sizeof(struct pt_regs));
2262cfee WD	313	regs.xds = (u32)setup_base >> 4;
95ffaba3 GR	314	regs.xes = regs.xds;
95ffaba3 GR	315	regs.xss = regs.xds;
7a8e9bed	316	regs.esp = 0x9000;
2262cfee	317	regs.eflags = 0;
d3a2bc3f GB	318	enter_realmode(((u32)setup_base + SETUP_START_OFFSET) >> 4, 0,
d3a2bc3f GB	319	&regs, &regs);
233dbc11	320	#endif
2262cfee	321	}
95ffaba3	322
8e18e6e1 GR	323	void setup_pcat_compatibility(void)
	324	__attribute__((weak, alias("__setup_pcat_compatibility")));
	325
	326	void __setup_pcat_compatibility(void)
	327	{
	328	}
	329
83088afb	330	int do_zboot(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
95ffaba3	331	{
69370d14	332	struct boot_params *base_ptr;
abe98f49	333	void *bzImage_addr = NULL;
233dbc11	334	void *load_address;
abe98f49	335	char *s;
95ffaba3	336	ulong bzImage_size = 0;
6f9d9986 GB	337	ulong initrd_addr = 0;
6f9d9986 GB	338	ulong initrd_size = 0;
95ffaba3 GR	339
	340	disable_interrupts();
	341
	342	/* Setup board for maximum PC/AT Compatibility */
	343	setup_pcat_compatibility();
	344
d3a2bc3f	345	if (argc >= 2) {
abe98f49 GR	346	/* argv[1] holds the address of the bzImage */
abe98f49 GR	347	s = argv[1];
d3a2bc3f	348	} else {
abe98f49	349	s = getenv("fileaddr");
d3a2bc3f	350	}
abe98f49 GR	351
	352	if (s)
	353	bzImage_addr = (void *)simple_strtoul(s, NULL, 16);
95ffaba3	354
6f9d9986	355	if (argc >= 3) {
abe98f49	356	/* argv[2] holds the size of the bzImage */
95ffaba3	357	bzImage_size = simple_strtoul(argv[2], NULL, 16);
6f9d9986 GB	358	}
	359
	360	if (argc >= 4)
	361	initrd_addr = simple_strtoul(argv[3], NULL, 16);
	362	if (argc >= 5)
	363	initrd_size = simple_strtoul(argv[4], NULL, 16);
95ffaba3	364
d3a2bc3f	365	/* Lets look for */
69370d14	366	base_ptr = load_zimage(bzImage_addr, bzImage_size, &load_address);
95ffaba3	367
83088afb GR	368	if (!base_ptr) {
83088afb GR	369	printf("## Kernel loading failed ...\n");
69370d14	370	return -1;
95ffaba3	371	}
69370d14	372	if (setup_zimage(base_ptr, (char *)base_ptr + COMMAND_LINE_OFFSET,
6f9d9986	373	0, initrd_addr, initrd_size)) {
69370d14 GB	374	printf("Setting up boot parameters failed ...\n");
	375	return -1;
	376	}
	377
	378	printf("## Transferring control to Linux "
	379	"(at address %08x) ...\n",
	380	(u32)base_ptr);
	381
	382	/* we assume that the kernel is in place */
	383	boot_zimage(base_ptr, load_address);
	384	/* does not return */
95ffaba3 GR	385
	386	return -1;
	387	}
	388
	389	U_BOOT_CMD(
6f9d9986	390	zboot, 5, 0, do_zboot,
95ffaba3	391	"Boot bzImage",
6f9d9986 GB	392	"[addr] [size] [initrd addr] [initrd size]\n"
	393	" addr - The optional starting address of the bzimage.\n"
	394	" If not set it defaults to the environment\n"
	395	" variable \"fileaddr\".\n"
	396	" size - The optional size of the bzimage. Defaults to\n"
	397	" zero.\n"
	398	" initrd addr - The address of the initrd image to use, if any.\n"
	399	" initrd size - The size of the initrd image to use, if any.\n"
95ffaba3	400	);