2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Copyright (C) Paul Mackerras 1997.
|
|
|
|
*
|
|
|
|
* Updates for PPC64 by Todd Inglett, Dave Engebretsen & Peter Bergner.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-08-08 11:24:38 +08:00
|
|
|
#include <stdarg.h>
|
|
|
|
#include <stddef.h>
|
|
|
|
#include "elf.h"
|
|
|
|
#include "page.h"
|
|
|
|
#include "string.h"
|
|
|
|
#include "stdio.h"
|
2006-09-19 12:05:08 +08:00
|
|
|
#include "ops.h"
|
2007-03-05 11:24:52 +08:00
|
|
|
#include "gunzip_util.h"
|
2006-09-19 12:05:08 +08:00
|
|
|
#include "flatdevtree.h"
|
2007-03-22 14:02:21 +08:00
|
|
|
#include "reg.h"
|
2005-08-08 11:24:38 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
extern char _start[];
|
2005-10-29 08:46:45 +08:00
|
|
|
extern char __bss_start[];
|
2005-09-07 06:50:02 +08:00
|
|
|
extern char _end[];
|
2005-04-17 06:20:36 +08:00
|
|
|
extern char _vmlinux_start[];
|
|
|
|
extern char _vmlinux_end[];
|
|
|
|
extern char _initrd_start[];
|
|
|
|
extern char _initrd_end[];
|
2006-10-17 04:49:27 +08:00
|
|
|
extern char _dtb_start[];
|
|
|
|
extern char _dtb_end[];
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-03-05 11:24:52 +08:00
|
|
|
static struct gunzip_state gzstate;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
struct addr_range {
|
2007-03-05 11:24:52 +08:00
|
|
|
void *addr;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long size;
|
|
|
|
};
|
2005-11-16 10:38:21 +08:00
|
|
|
|
2006-09-19 12:05:08 +08:00
|
|
|
typedef void (*kernel_entry_t)(unsigned long, unsigned long, void *);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#undef DEBUG
|
|
|
|
|
2007-03-05 11:24:52 +08:00
|
|
|
static struct addr_range prep_kernel(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2007-03-05 11:24:52 +08:00
|
|
|
char elfheader[256];
|
|
|
|
void *vmlinuz_addr = _vmlinux_start;
|
|
|
|
unsigned long vmlinuz_size = _vmlinux_end - _vmlinux_start;
|
|
|
|
void *addr = 0;
|
|
|
|
struct elf_info ei;
|
2005-10-29 08:46:40 +08:00
|
|
|
int len;
|
2006-01-14 12:04:06 +08:00
|
|
|
|
2005-11-16 10:38:21 +08:00
|
|
|
/* gunzip the ELF header of the kernel */
|
2007-03-05 11:24:52 +08:00
|
|
|
gunzip_start(&gzstate, vmlinuz_addr, vmlinuz_size);
|
2007-03-05 11:24:52 +08:00
|
|
|
gunzip_exactly(&gzstate, elfheader, sizeof(elfheader));
|
2005-11-16 10:38:21 +08:00
|
|
|
|
2007-03-21 23:02:44 +08:00
|
|
|
if (!parse_elf64(elfheader, &ei) && !parse_elf32(elfheader, &ei))
|
|
|
|
fatal("Error: not a valid PPC32 or PPC64 ELF file!\n\r");
|
|
|
|
|
2006-09-19 12:05:08 +08:00
|
|
|
if (platform_ops.image_hdr)
|
|
|
|
platform_ops.image_hdr(elfheader);
|
2005-11-16 10:38:21 +08:00
|
|
|
|
2007-03-05 11:24:52 +08:00
|
|
|
/* We need to alloc the memsize: gzip will expand the kernel
|
|
|
|
* text/data, then possible rubbish we don't care about. But
|
|
|
|
* the kernel bss must be claimed (it will be zero'd by the
|
|
|
|
* kernel itself)
|
2005-11-07 16:57:58 +08:00
|
|
|
*/
|
2007-03-05 11:24:52 +08:00
|
|
|
printf("Allocating 0x%lx bytes for kernel ...\n\r", ei.memsize);
|
|
|
|
|
|
|
|
if (platform_ops.vmlinux_alloc) {
|
|
|
|
addr = platform_ops.vmlinux_alloc(ei.memsize);
|
|
|
|
} else {
|
2007-03-21 23:02:44 +08:00
|
|
|
if ((unsigned long)_start < ei.memsize)
|
|
|
|
fatal("Insufficient memory for kernel at address 0!"
|
2007-03-22 13:59:13 +08:00
|
|
|
" (_start=%p)\n\r", _start);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2007-03-05 11:24:52 +08:00
|
|
|
/* Finally, gunzip the kernel */
|
|
|
|
printf("gunzipping (0x%p <- 0x%p:0x%p)...", addr,
|
|
|
|
vmlinuz_addr, vmlinuz_addr+vmlinuz_size);
|
|
|
|
/* discard up to the actual load data */
|
|
|
|
gunzip_discard(&gzstate, ei.elfoffset - sizeof(elfheader));
|
2007-03-29 21:31:41 +08:00
|
|
|
len = gunzip_finish(&gzstate, addr, ei.loadsize);
|
|
|
|
if (len != ei.loadsize)
|
|
|
|
fatal("ran out of data! only got 0x%x of 0x%lx bytes.\n\r",
|
|
|
|
len, ei.loadsize);
|
2007-03-22 13:59:13 +08:00
|
|
|
printf("done 0x%x bytes\n\r", len);
|
2007-03-05 11:24:52 +08:00
|
|
|
|
|
|
|
flush_cache(addr, ei.loadsize);
|
|
|
|
|
|
|
|
return (struct addr_range){addr, ei.memsize};
|
|
|
|
}
|
|
|
|
|
2007-03-22 14:02:21 +08:00
|
|
|
static struct addr_range prep_initrd(struct addr_range vmlinux, void *chosen,
|
2007-03-05 11:24:52 +08:00
|
|
|
unsigned long initrd_addr,
|
|
|
|
unsigned long initrd_size)
|
|
|
|
{
|
|
|
|
/* If we have an image attached to us, it overrides anything
|
|
|
|
* supplied by the loader. */
|
|
|
|
if (_initrd_end > _initrd_start) {
|
|
|
|
printf("Attached initrd image at 0x%p-0x%p\n\r",
|
|
|
|
_initrd_start, _initrd_end);
|
|
|
|
initrd_addr = (unsigned long)_initrd_start;
|
|
|
|
initrd_size = _initrd_end - _initrd_start;
|
|
|
|
} else if (initrd_size > 0) {
|
|
|
|
printf("Using loader supplied ramdisk at 0x%lx-0x%lx\n\r",
|
|
|
|
initrd_addr, initrd_addr + initrd_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If there's no initrd at all, we're done */
|
|
|
|
if (! initrd_size)
|
|
|
|
return (struct addr_range){0, 0};
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2007-03-05 11:24:52 +08:00
|
|
|
* If the initrd is too low it will be clobbered when the
|
|
|
|
* kernel relocates to its final location. In this case,
|
|
|
|
* allocate a safer place and move it.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2007-03-05 11:24:52 +08:00
|
|
|
if (initrd_addr < vmlinux.size) {
|
|
|
|
void *old_addr = (void *)initrd_addr;
|
|
|
|
|
2006-09-19 12:05:08 +08:00
|
|
|
printf("Allocating 0x%lx bytes for initrd ...\n\r",
|
2007-03-05 11:24:52 +08:00
|
|
|
initrd_size);
|
|
|
|
initrd_addr = (unsigned long)malloc(initrd_size);
|
2007-03-21 23:02:44 +08:00
|
|
|
if (! initrd_addr)
|
|
|
|
fatal("Can't allocate memory for initial "
|
2007-03-05 11:24:52 +08:00
|
|
|
"ramdisk !\n\r");
|
2007-03-22 13:59:13 +08:00
|
|
|
printf("Relocating initrd 0x%lx <- 0x%p (0x%lx bytes)\n\r",
|
2007-03-05 11:24:52 +08:00
|
|
|
initrd_addr, old_addr, initrd_size);
|
|
|
|
memmove((void *)initrd_addr, old_addr, initrd_size);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2007-03-05 11:24:52 +08:00
|
|
|
printf("initrd head: 0x%lx\n\r", *((unsigned long *)initrd_addr));
|
|
|
|
|
|
|
|
/* Tell the kernel initrd address via device tree */
|
2007-03-22 14:02:21 +08:00
|
|
|
setprop_val(chosen, "linux,initrd-start", (u32)(initrd_addr));
|
|
|
|
setprop_val(chosen, "linux,initrd-end", (u32)(initrd_addr+initrd_size));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-03-05 11:24:52 +08:00
|
|
|
return (struct addr_range){(void *)initrd_addr, initrd_size};
|
2006-09-19 12:05:08 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-09-19 12:05:08 +08:00
|
|
|
/* A buffer that may be edited by tools operating on a zImage binary so as to
|
|
|
|
* edit the command line passed to vmlinux (by setting /chosen/bootargs).
|
|
|
|
* The buffer is put in it's own section so that tools may locate it easier.
|
|
|
|
*/
|
2007-03-22 14:02:21 +08:00
|
|
|
static char cmdline[COMMAND_LINE_SIZE]
|
2006-09-19 12:05:08 +08:00
|
|
|
__attribute__((__section__("__builtin_cmdline")));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-03-22 14:02:21 +08:00
|
|
|
static void prep_cmdline(void *chosen)
|
2006-09-19 12:05:08 +08:00
|
|
|
{
|
2007-03-22 14:02:21 +08:00
|
|
|
if (cmdline[0] == '\0')
|
|
|
|
getprop(chosen, "bootargs", cmdline, COMMAND_LINE_SIZE-1);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-03-22 14:02:21 +08:00
|
|
|
printf("\n\rLinux/PowerPC load: %s", cmdline);
|
|
|
|
/* If possible, edit the command line */
|
|
|
|
if (console_ops.edit_cmdline)
|
|
|
|
console_ops.edit_cmdline(cmdline, COMMAND_LINE_SIZE);
|
|
|
|
printf("\n\r");
|
2006-09-19 12:05:08 +08:00
|
|
|
|
2007-03-22 14:02:21 +08:00
|
|
|
/* Put the command line back into the devtree for the kernel */
|
|
|
|
setprop_str(chosen, "bootargs", cmdline);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-09-19 12:05:08 +08:00
|
|
|
struct platform_ops platform_ops;
|
|
|
|
struct dt_ops dt_ops;
|
|
|
|
struct console_ops console_ops;
|
[POWERPC] zImage: Cleanup and improve zImage entry point
This patch re-organises the way the zImage wrapper code is entered, to
allow more flexibility on platforms with unusual entry conditions.
After this patch, a platform .o file has two options:
1) It can define a _zimage_start, in which case the platform code gets
control from the very beginning of execution. In this case the
platform code is responsible for relocating the zImage if necessary,
clearing the BSS, performing any platform specific initialization, and
finally calling start() to load and enter the kernel.
2) It can define platform_init(). In this case the generic crt0.S
handles initial entry, and calls platform_init() before calling
start(). The signature of platform_init() is changed, however, to
take up to 5 parameters (in r3..r7) as they come from the platform's
initial loader, instead of a fixed set of parameters based on OF's
usage.
When using the generic crt0.S, the platform .o can optionally
supply a custom stack to use, using the BSS_STACK() macro. If this
is not supplied, the crt0.S will assume that the loader has
supplied a usable stack.
In either case, the platform code communicates information to the
generic code (specifically, a PROM pointer for OF systems, and/or an
initrd image address supplied by the bootloader) via a global
structure "loader_info".
In addition the wrapper script is rearranged to ensure that the
platform .o is always linked first. This means that platforms where
the zImage entry point is at a fixed address or offset, rather than
being encoded in the binary header can be supported using option (1).
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-03-05 11:24:52 +08:00
|
|
|
struct loader_info loader_info;
|
2006-09-19 12:05:08 +08:00
|
|
|
|
2007-03-22 14:02:21 +08:00
|
|
|
void start(void)
|
2006-09-19 12:05:08 +08:00
|
|
|
{
|
2007-03-05 11:24:52 +08:00
|
|
|
struct addr_range vmlinux, initrd;
|
2006-09-19 12:05:08 +08:00
|
|
|
kernel_entry_t kentry;
|
[POWERPC] Cleanup zImage handling of kernel entry with flat device tree
This makes 2 changes to clean up the flat device tree handling
logic in the zImage wrapper.
First, there were two callbacks from the dt_ops structure used for
producing a final flat tree to pass to the kerne: dt_ops.ft_pack()
which packed the flat tree (possibly a no-op) and dt_ops.ft_addr()
which retreived the address of the final blob. Since they were only
ever called together, this patch combines the two into a single new
callback, dt_ops.finalize(). This new callback does whatever
platform-dependent things are necessary to produce a final flat device
tree blob, and returns the blob's addres.
Second, the current logic calls the kernel with a flat device tree if
one is build into the zImage wrapper, otherwise it boots the kernel
with a PROM pointer, expecting the kernel to copy the OF device tree
itself. This approach precludes the possibility of the platform
wrapper code building a flat device tree from whatever
platform-specific information firmware provides. Thus, this patch
takes the more sensible approach of invoking the kernel with a flat
tree if the dt_ops.finalize callback provides one (by whatever means).
So, the dt_ops.finalize callback can be NULL, or can be a function
which returns NULL. In either case, the zImage wrapper logic assumes
that this is a platform with OF and invokes the kernel accordingly.
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-21 08:37:37 +08:00
|
|
|
unsigned long ft_addr = 0;
|
2007-03-22 14:02:21 +08:00
|
|
|
void *chosen;
|
2006-09-19 12:05:08 +08:00
|
|
|
|
2007-03-22 14:02:21 +08:00
|
|
|
/* Do this first, because malloc() could clobber the loader's
|
|
|
|
* command line. Only use the loader command line if a
|
|
|
|
* built-in command line wasn't set by an external tool */
|
|
|
|
if ((loader_info.cmdline_len > 0) && (cmdline[0] == '\0'))
|
|
|
|
memmove(cmdline, loader_info.cmdline,
|
|
|
|
min(loader_info.cmdline_len, COMMAND_LINE_SIZE-1));
|
|
|
|
|
2006-09-19 12:05:08 +08:00
|
|
|
if (console_ops.open && (console_ops.open() < 0))
|
|
|
|
exit();
|
|
|
|
if (platform_ops.fixups)
|
|
|
|
platform_ops.fixups();
|
|
|
|
|
|
|
|
printf("\n\rzImage starting: loaded at 0x%p (sp: 0x%p)\n\r",
|
2007-03-22 14:02:21 +08:00
|
|
|
_start, get_sp());
|
2006-09-19 12:05:08 +08:00
|
|
|
|
2007-03-22 14:02:21 +08:00
|
|
|
/* Ensure that the device tree has a /chosen node */
|
|
|
|
chosen = finddevice("/chosen");
|
|
|
|
if (!chosen)
|
|
|
|
chosen = create_node(NULL, "chosen");
|
|
|
|
|
2007-03-05 11:24:52 +08:00
|
|
|
vmlinux = prep_kernel();
|
2007-03-22 14:02:21 +08:00
|
|
|
initrd = prep_initrd(vmlinux, chosen,
|
|
|
|
loader_info.initrd_addr, loader_info.initrd_size);
|
2007-03-22 14:02:21 +08:00
|
|
|
prep_cmdline(chosen);
|
2006-09-19 12:05:08 +08:00
|
|
|
|
[POWERPC] Cleanup zImage handling of kernel entry with flat device tree
This makes 2 changes to clean up the flat device tree handling
logic in the zImage wrapper.
First, there were two callbacks from the dt_ops structure used for
producing a final flat tree to pass to the kerne: dt_ops.ft_pack()
which packed the flat tree (possibly a no-op) and dt_ops.ft_addr()
which retreived the address of the final blob. Since they were only
ever called together, this patch combines the two into a single new
callback, dt_ops.finalize(). This new callback does whatever
platform-dependent things are necessary to produce a final flat device
tree blob, and returns the blob's addres.
Second, the current logic calls the kernel with a flat device tree if
one is build into the zImage wrapper, otherwise it boots the kernel
with a PROM pointer, expecting the kernel to copy the OF device tree
itself. This approach precludes the possibility of the platform
wrapper code building a flat device tree from whatever
platform-specific information firmware provides. Thus, this patch
takes the more sensible approach of invoking the kernel with a flat
tree if the dt_ops.finalize callback provides one (by whatever means).
So, the dt_ops.finalize callback can be NULL, or can be a function
which returns NULL. In either case, the zImage wrapper logic assumes
that this is a platform with OF and invokes the kernel accordingly.
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-21 08:37:37 +08:00
|
|
|
printf("Finalizing device tree...");
|
|
|
|
if (dt_ops.finalize)
|
|
|
|
ft_addr = dt_ops.finalize();
|
|
|
|
if (ft_addr)
|
|
|
|
printf(" flat tree at 0x%lx\n\r", ft_addr);
|
|
|
|
else
|
[POWERPC] zImage: Cleanup and improve zImage entry point
This patch re-organises the way the zImage wrapper code is entered, to
allow more flexibility on platforms with unusual entry conditions.
After this patch, a platform .o file has two options:
1) It can define a _zimage_start, in which case the platform code gets
control from the very beginning of execution. In this case the
platform code is responsible for relocating the zImage if necessary,
clearing the BSS, performing any platform specific initialization, and
finally calling start() to load and enter the kernel.
2) It can define platform_init(). In this case the generic crt0.S
handles initial entry, and calls platform_init() before calling
start(). The signature of platform_init() is changed, however, to
take up to 5 parameters (in r3..r7) as they come from the platform's
initial loader, instead of a fixed set of parameters based on OF's
usage.
When using the generic crt0.S, the platform .o can optionally
supply a custom stack to use, using the BSS_STACK() macro. If this
is not supplied, the crt0.S will assume that the loader has
supplied a usable stack.
In either case, the platform code communicates information to the
generic code (specifically, a PROM pointer for OF systems, and/or an
initrd image address supplied by the bootloader) via a global
structure "loader_info".
In addition the wrapper script is rearranged to ensure that the
platform .o is always linked first. This means that platforms where
the zImage entry point is at a fixed address or offset, rather than
being encoded in the binary header can be supported using option (1).
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-03-05 11:24:52 +08:00
|
|
|
printf(" using OF tree (promptr=%p)\n\r", loader_info.promptr);
|
[POWERPC] Cleanup zImage handling of kernel entry with flat device tree
This makes 2 changes to clean up the flat device tree handling
logic in the zImage wrapper.
First, there were two callbacks from the dt_ops structure used for
producing a final flat tree to pass to the kerne: dt_ops.ft_pack()
which packed the flat tree (possibly a no-op) and dt_ops.ft_addr()
which retreived the address of the final blob. Since they were only
ever called together, this patch combines the two into a single new
callback, dt_ops.finalize(). This new callback does whatever
platform-dependent things are necessary to produce a final flat device
tree blob, and returns the blob's addres.
Second, the current logic calls the kernel with a flat device tree if
one is build into the zImage wrapper, otherwise it boots the kernel
with a PROM pointer, expecting the kernel to copy the OF device tree
itself. This approach precludes the possibility of the platform
wrapper code building a flat device tree from whatever
platform-specific information firmware provides. Thus, this patch
takes the more sensible approach of invoking the kernel with a flat
tree if the dt_ops.finalize callback provides one (by whatever means).
So, the dt_ops.finalize callback can be NULL, or can be a function
which returns NULL. In either case, the zImage wrapper logic assumes
that this is a platform with OF and invokes the kernel accordingly.
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-21 08:37:37 +08:00
|
|
|
|
2006-09-19 12:05:08 +08:00
|
|
|
if (console_ops.close)
|
|
|
|
console_ops.close();
|
|
|
|
|
|
|
|
kentry = (kernel_entry_t) vmlinux.addr;
|
[POWERPC] Cleanup zImage handling of kernel entry with flat device tree
This makes 2 changes to clean up the flat device tree handling
logic in the zImage wrapper.
First, there were two callbacks from the dt_ops structure used for
producing a final flat tree to pass to the kerne: dt_ops.ft_pack()
which packed the flat tree (possibly a no-op) and dt_ops.ft_addr()
which retreived the address of the final blob. Since they were only
ever called together, this patch combines the two into a single new
callback, dt_ops.finalize(). This new callback does whatever
platform-dependent things are necessary to produce a final flat device
tree blob, and returns the blob's addres.
Second, the current logic calls the kernel with a flat device tree if
one is build into the zImage wrapper, otherwise it boots the kernel
with a PROM pointer, expecting the kernel to copy the OF device tree
itself. This approach precludes the possibility of the platform
wrapper code building a flat device tree from whatever
platform-specific information firmware provides. Thus, this patch
takes the more sensible approach of invoking the kernel with a flat
tree if the dt_ops.finalize callback provides one (by whatever means).
So, the dt_ops.finalize callback can be NULL, or can be a function
which returns NULL. In either case, the zImage wrapper logic assumes
that this is a platform with OF and invokes the kernel accordingly.
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-21 08:37:37 +08:00
|
|
|
if (ft_addr)
|
|
|
|
kentry(ft_addr, 0, NULL);
|
2006-09-19 12:05:08 +08:00
|
|
|
else
|
[POWERPC] zImage: Cleanup and improve zImage entry point
This patch re-organises the way the zImage wrapper code is entered, to
allow more flexibility on platforms with unusual entry conditions.
After this patch, a platform .o file has two options:
1) It can define a _zimage_start, in which case the platform code gets
control from the very beginning of execution. In this case the
platform code is responsible for relocating the zImage if necessary,
clearing the BSS, performing any platform specific initialization, and
finally calling start() to load and enter the kernel.
2) It can define platform_init(). In this case the generic crt0.S
handles initial entry, and calls platform_init() before calling
start(). The signature of platform_init() is changed, however, to
take up to 5 parameters (in r3..r7) as they come from the platform's
initial loader, instead of a fixed set of parameters based on OF's
usage.
When using the generic crt0.S, the platform .o can optionally
supply a custom stack to use, using the BSS_STACK() macro. If this
is not supplied, the crt0.S will assume that the loader has
supplied a usable stack.
In either case, the platform code communicates information to the
generic code (specifically, a PROM pointer for OF systems, and/or an
initrd image address supplied by the bootloader) via a global
structure "loader_info".
In addition the wrapper script is rearranged to ensure that the
platform .o is always linked first. This means that platforms where
the zImage entry point is at a fixed address or offset, rather than
being encoded in the binary header can be supported using option (1).
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-03-05 11:24:52 +08:00
|
|
|
kentry((unsigned long)initrd.addr, initrd.size,
|
|
|
|
loader_info.promptr);
|
2006-09-19 12:05:08 +08:00
|
|
|
|
2007-03-21 23:02:44 +08:00
|
|
|
/* console closed so printf in fatal below may not work */
|
|
|
|
fatal("Error: Linux kernel returned to zImage boot wrapper!\n\r");
|
2006-09-19 12:05:08 +08:00
|
|
|
}
|