x86: Move kernel boot function to arch/x86/lib/bootm.c

The boot_zimage() function is badly named it can also boot a raw kernel.
Rename it, and try to avoid pointers for memory addresses as it involves
lots of casting.

Signed-off-by: Simon Glass <sjg@chromium.org>

diff --git a/arch/x86/include/asm/bootm.h b/arch/x86/include/asm/bootm.h
index 033ab79..f6a64ce 100644 (file)
--- a/arch/x86/include/asm/bootm.h
+++ b/arch/x86/include/asm/bootm.h
@@ -9,4 +9,20 @@
 
 void bootm_announce_and_cleanup(void);
 
+/**
+ * boot_linux_kernel() - boot a linux kernel
+ *
+ * This boots a kernel image, either 32-bit or 64-bit. It will also work with
+ * a self-extracting kernel, if you set @image_64bit to false.
+ *
+ * @setup_base:                Pointer to the setup.bin information for the kernel
+ * @load_address:      Pointer to the start of the kernel image
+ * @image_64bit:       true if the image is a raw 64-bit kernel, false if it
+ *                     is raw 32-bit or any type of self-extracting kernel
+ *                     such as a bzImage.
+ * @return -ve error code. This function does not return if the kernel was
+ * booted successfully.
+ */
+int boot_linux_kernel(ulong setup_base, ulong load_address, bool image_64bit);
+
 #endif

diff --git a/arch/x86/include/asm/zimage.h b/arch/x86/include/asm/zimage.h
index 0f36662..8e7dd42 100644 (file)
--- a/arch/x86/include/asm/zimage.h
+++ b/arch/x86/include/asm/zimage.h
@@ -35,10 +35,8 @@
 unsigned install_e820_map(unsigned max_entries, struct e820entry *);
 
 struct boot_params *load_zimage(char *image, unsigned long kernel_size,
-                               void **load_address);
+                               ulong *load_addressp);
 int setup_zimage(struct boot_params *setup_base, char *cmd_line, int auto_boot,
                 unsigned long initrd_addr, unsigned long initrd_size);
 
-void boot_zimage(void *setup_base, void *load_address);
-
 #endif

diff --git a/arch/x86/lib/bootm.c b/arch/x86/lib/bootm.c
index 4c5c7f5..b90ca65 100644 (file)
--- a/arch/x86/lib/bootm.c
+++ b/arch/x86/lib/bootm.c
@@ -10,6 +10,7 @@
 
 #include <common.h>
 #include <command.h>
+#include <errno.h>
 #include <fdt_support.h>
 #include <image.h>
 #include <u-boot/zlib.h>
@@ -109,11 +110,11 @@ static int boot_prep_linux(bootm_headers_t *images)
        }
 
        if (is_zimage) {
-               void *load_address;
+               ulong load_address;
                char *base_ptr;
 
                base_ptr = (char *)load_zimage(data, len, &load_address);
-               images->os.load = (ulong)load_address;
+               images->os.load = load_address;
                cmd_line_dest = base_ptr + COMMAND_LINE_OFFSET;
                images->ep = (ulong)base_ptr;
        } else if (images->ep) {
@@ -139,16 +140,45 @@ error:
        return 1;
 }
 
+int boot_linux_kernel(ulong setup_base, ulong load_address, bool image_64bit)
+{
+       bootm_announce_and_cleanup();
+
+#ifdef CONFIG_SYS_COREBOOT
+       timestamp_add_now(TS_U_BOOT_START_KERNEL);
+#endif
+       if (image_64bit) {
+               /* TODO(boot 64-bit kernel) */
+       } else {
+               /*
+               * 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)
+               );
+       }
+
+       /* We can't get to here */
+       return -EFAULT;
+}
+
 /* Subcommand: GO */
 static int boot_jump_linux(bootm_headers_t *images)
 {
        debug("## Transferring control to Linux (at address %08lx, kernel %08lx) ...\n",
              images->ep, images->os.load);
 
-       boot_zimage((struct boot_params *)images->ep, (void *)images->os.load);
-       /* does not return */
-
-       return 1;
+       return boot_linux_kernel(images->ep, images->os.load, false);
 }
 
 int do_bootm_linux(int flag, int argc, char * const argv[],
@@ -161,10 +191,8 @@ int do_bootm_linux(int flag, int argc, char * const argv[],
        if (flag & BOOTM_STATE_OS_PREP)
                return boot_prep_linux(images);
 
-       if (flag & BOOTM_STATE_OS_GO) {
-               boot_jump_linux(images);
-               return 0;
-       }
+       if (flag & BOOTM_STATE_OS_GO)
+               return boot_jump_linux(images);
 
        return boot_jump_linux(images);
 }

diff --git a/arch/x86/lib/zimage.c b/arch/x86/lib/zimage.c
index b190283..aa5597c 100644 (file)
--- a/arch/x86/lib/zimage.c
+++ b/arch/x86/lib/zimage.c
@@ -103,7 +103,7 @@ static int get_boot_protocol(struct setup_header *hdr)
 }
 
 struct boot_params *load_zimage(char *image, unsigned long kernel_size,
-                               void **load_address)
+                               ulong *load_addressp)
 {
        struct boot_params *setup_base;
        int setup_size;
@@ -155,9 +155,9 @@ struct boot_params *load_zimage(char *image, unsigned long kernel_size,
 
        /* Determine load address */
        if (big_image)
-               *load_address = (void *)BZIMAGE_LOAD_ADDR;
+               *load_addressp = BZIMAGE_LOAD_ADDR;
        else
-               *load_address = (void *)ZIMAGE_LOAD_ADDR;
+               *load_addressp = ZIMAGE_LOAD_ADDR;
 
        printf("Building boot_params at 0x%8.8lx\n", (ulong)setup_base);
        memset(setup_base, 0, sizeof(*setup_base));
@@ -204,10 +204,10 @@ struct boot_params *load_zimage(char *image, unsigned long kernel_size,
                return 0;
        }
 
-       printf("Loading %s at address %p (%ld bytes)\n",
-               big_image ? "bzImage" : "zImage", *load_address, kernel_size);
+       printf("Loading %s at address %lx (%ld bytes)\n",
+              big_image ? "bzImage" : "zImage", *load_addressp, kernel_size);
 
-       memmove(*load_address, image + setup_size, kernel_size);
+       memmove((void *)*load_addressp, image + setup_size, kernel_size);
 
        return setup_base;
 }
@@ -261,30 +261,6 @@ int setup_zimage(struct boot_params *setup_base, char *cmd_line, int auto_boot,
        return 0;
 }
 
-void boot_zimage(void *setup_base, void *load_address)
-{
-       bootm_announce_and_cleanup();
-
-#ifdef CONFIG_SYS_COREBOOT
-       timestamp_add_now(TS_U_BOOT_START_KERNEL);
-#endif
-       /*
-        * 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)
-       );
-}
-
 void setup_pcat_compatibility(void)
        __attribute__((weak, alias("__setup_pcat_compatibility")));
 
@@ -296,7 +272,7 @@ 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;
+       ulong load_address;
        char *s;
        ulong bzImage_size = 0;
        ulong initrd_addr = 0;
@@ -341,10 +317,7 @@ int do_zboot(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
        }
 
        /* we assume that the kernel is in place */
-       boot_zimage(base_ptr, load_address);
-       /* does not return */
-
-       return -1;
+       return boot_linux_kernel((ulong)base_ptr, load_address, false);
 }
 
 U_BOOT_CMD(