arch/x86/lib/zimage.c

   1 /*
   2  * (C) Copyright 2002
   3  * Daniel Engström, Omicron Ceti AB, <daniel@omicron.se>
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21  * MA 02111-1307 USA
  22  */
  23
  24 /*
  25  * Linux x86 zImage and bzImage loading
  26  *
  27  * based on the procdure described in
  28  * linux/Documentation/i386/boot.txt
  29  */
  30
  31 #include <common.h>
  32 #include <asm/io.h>
  33 #include <asm/ptrace.h>
  34 #include <asm/zimage.h>
  35 #include <asm/realmode.h>
  36 #include <asm/byteorder.h>
  37 #include <asm/bootparam.h>
  38 #include <asm/ic/sc520.h>
  39
  40 /*
  41  * Memory lay-out:
  42  *
  43  * relative to setup_base (which is 0x90000 currently)
  44  *
  45  *      0x0000-0x7FFF   Real mode kernel
  46  *      0x8000-0x8FFF   Stack and heap
  47  *      0x9000-0x90FF   Kernel command line
  48  */
  49 #define DEFAULT_SETUP_BASE  0x90000
  50 #define COMMAND_LINE_OFFSET 0x9000
  51 #define HEAP_END_OFFSET     0x8e00
  52
  53 #define COMMAND_LINE_SIZE   2048
  54
  55 static void build_command_line(char *command_line, int auto_boot)
  56 {
  57         char *env_command_line;
  58
  59         command_line[0] = '\0';
  60
  61         env_command_line =  getenv("bootargs");
  62
  63         /* set console= argument if we use a serial console */
  64         if (NULL == strstr(env_command_line, "console=")) {
  65                 if (0==strcmp(getenv("stdout"), "serial")) {
  66
  67                         /* We seem to use serial console */
  68                         sprintf(command_line, "console=ttyS0,%s ",
  69                                  getenv("baudrate"));
  70                 }
  71         }
  72
  73         if (auto_boot) {
  74                 strcat(command_line, "auto ");
  75         }
  76
  77         if (NULL != env_command_line) {
  78                 strcat(command_line, env_command_line);
  79         }
  80
  81
  82         printf("Kernel command line: \"%s\"\n", command_line);
  83 }
  84
  85 void *load_zimage(char *image, unsigned long kernel_size,
  86                   unsigned long initrd_addr, unsigned long initrd_size,
  87                   int auto_boot)
  88 {
  89         void *setup_base;
  90         int setup_size;
  91         int bootproto;
  92         int big_image;
  93         void *load_address;
  94
  95         struct setup_header *hdr = (struct setup_header *)(image + SETUP_SECTS_OFF);
  96
  97         setup_base = (void*)DEFAULT_SETUP_BASE; /* base address for real-mode segment */
  98
  99         if (KERNEL_MAGIC != hdr->boot_flag) {
 100                 printf("Error: Invalid Boot Flag (found 0x%04x, expected 0x%04x)\n",
 101                                 hdr->boot_flag, KERNEL_MAGIC);
 102                 return 0;
 103         } else {
 104                 printf("Valid Boot Flag\n");
 105         }
 106
 107         /* determine boot protocol version */
 108         if (KERNEL_V2_MAGIC == hdr->header) {
 109                 printf("Magic signature found\n");
 110
 111                 bootproto = hdr->version;
 112         } else {
 113                 /* Very old kernel */
 114                 printf("Magic signature not found\n");
 115                 bootproto = 0x0100;
 116         }
 117
 118         /* determine size of setup */
 119         if (0 == hdr->setup_sects) {
 120                 printf("Setup Sectors = 0 (defaulting to 4)\n");
 121                 setup_size = 5 * 512;
 122         } else {
 123                 setup_size = (hdr->setup_sects + 1) * 512;
 124         }
 125
 126         printf("Setup Size = 0x%8.8lx\n", (ulong)setup_size);
 127
 128         if (setup_size > SETUP_MAX_SIZE) {
 129                 printf("Error: Setup is too large (%d bytes)\n", setup_size);
 130         }
 131
 132         /* Determine image type */
 133         big_image = (bootproto >= 0x0200) && (hdr->loadflags & BIG_KERNEL_FLAG);
 134
 135         /* Determine load address */
 136         load_address = (void*)(big_image ? BZIMAGE_LOAD_ADDR : ZIMAGE_LOAD_ADDR);
 137
 138         /* load setup */
 139         printf("Moving Real-Mode Code to 0x%8.8lx (%d bytes)\n", (ulong)setup_base, setup_size);
 140         memmove(setup_base, image, setup_size);
 141
 142         printf("Using boot protocol version %x.%02x\n",
 143                (bootproto & 0xff00) >> 8, bootproto & 0xff);
 144
 145         if (bootproto == 0x0100) {
 146
 147                 *(u16*)(setup_base + CMD_LINE_MAGIC_OFF) = COMMAND_LINE_MAGIC;
 148                 *(u16*)(setup_base + CMD_LINE_OFFSET_OFF) = COMMAND_LINE_OFFSET;
 149
 150                 /* A very old kernel MUST have its real-mode code
 151                  * loaded at 0x90000 */
 152
 153                 if ((u32)setup_base != 0x90000) {
 154                         /* Copy the real-mode kernel */
 155                         memmove((void*)0x90000, setup_base, setup_size);
 156                         /* Copy the command line */
 157                         memmove((void*)0x99000, setup_base+COMMAND_LINE_OFFSET,
 158                                COMMAND_LINE_SIZE);
 159
 160                         setup_base = (void*)0x90000;             /* Relocated */
 161                 }
 162
 163                 /* It is recommended to clear memory up to the 32K mark */
 164                 memset((void*)0x90000 + setup_size, 0, SETUP_MAX_SIZE-setup_size);
 165         }
 166
 167         /* We are now setting up the real-mode version of the header */
 168         hdr = (struct setup_header *)(setup_base + SETUP_SECTS_OFF);
 169
 170         if (bootproto >= 0x0200) {
 171                 hdr->type_of_loader = 8;
 172
 173                 if (hdr->setup_sects >= 15)
 174                         printf("Linux kernel version %s\n", (char *)
 175                                         (setup_base + (hdr->kernel_version + 0x200)));
 176                 else
 177                         printf("Setup Sectors < 15 - Cannot print kernel version.\n");
 178
 179                 if (initrd_addr) {
 180                         printf("Initial RAM disk at linear address 0x%08lx, size %ld bytes\n",
 181                                initrd_addr, initrd_size);
 182
 183                         hdr->ramdisk_image = initrd_addr;
 184                         hdr->ramdisk_size = initrd_size;
 185                 }
 186         }
 187
 188         if (bootproto >= 0x0201) {
 189                 hdr->heap_end_ptr = HEAP_END_OFFSET;
 190                 hdr->loadflags |= HEAP_FLAG;
 191         }
 192
 193         if (bootproto >= 0x0202) {
 194                 hdr->cmd_line_ptr = (u32)setup_base + COMMAND_LINE_OFFSET;
 195         } else if (bootproto >= 0x0200) {
 196
 197                 *(u16*)(setup_base + CMD_LINE_MAGIC_OFF) = COMMAND_LINE_MAGIC;
 198                 *(u16*)(setup_base + CMD_LINE_OFFSET_OFF) = COMMAND_LINE_OFFSET;
 199
 200                 hdr->setup_move_size = 0x9100;
 201         }
 202
 203         if (bootproto >= 0x0204)
 204                 kernel_size = hdr->syssize * 16;
 205         else
 206                 kernel_size -= setup_size;
 207
 208
 209         if (big_image) {
 210                 if ((kernel_size) > BZIMAGE_MAX_SIZE) {
 211                         printf("Error: bzImage kernel too big! (size: %ld, max: %d)\n",
 212                                kernel_size, BZIMAGE_MAX_SIZE);
 213                         return 0;
 214                 }
 215
 216         } else if ((kernel_size) > ZIMAGE_MAX_SIZE) {
 217                 printf("Error: zImage kernel too big! (size: %ld, max: %d)\n",
 218                        kernel_size, ZIMAGE_MAX_SIZE);
 219                 return 0;
 220         }
 221
 222         /* build command line at COMMAND_LINE_OFFSET */
 223         build_command_line(setup_base + COMMAND_LINE_OFFSET, auto_boot);
 224
 225         printf("Loading %czImage at address 0x%08x (%ld bytes)\n", big_image ? 'b' : ' ',
 226                (u32)load_address, kernel_size);
 227
 228
 229         memmove(load_address, image + setup_size, kernel_size);
 230
 231         /* ready for booting */
 232         return setup_base;
 233 }
 234
 235 void boot_zimage(void *setup_base)
 236 {
 237         struct pt_regs regs;
 238
 239         memset(&regs, 0, sizeof(struct pt_regs));
 240         regs.xds = (u32)setup_base >> 4;
 241         regs.xes = regs.xds;
 242         regs.xss = regs.xds;
 243         regs.esp = 0x9000;
 244         regs.eflags = 0;
 245         enter_realmode(((u32)setup_base+SETUP_START_OFFSET)>>4, 0, &regs, &regs);
 246 }
 247
 248 int do_zboot (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 249 {
 250         void *base_ptr;
 251         void *bzImage_addr = NULL;
 252         char *s;
 253         ulong bzImage_size = 0;
 254
 255         disable_interrupts();
 256
 257         /* Setup board for maximum PC/AT Compatibility */
 258         setup_pcat_compatibility();
 259
 260         if (argc >= 2)
 261                 /* argv[1] holds the address of the bzImage */
 262                 s = argv[1];
 263         else
 264                 s = getenv("fileaddr");
 265
 266         if (s)
 267                 bzImage_addr = (void *)simple_strtoul(s, NULL, 16);
 268
 269         if (argc >= 3)
 270                 /* argv[2] holds the size of the bzImage */
 271                 bzImage_size = simple_strtoul(argv[2], NULL, 16);
 272
 273         /* Lets look for*/
 274         base_ptr = load_zimage (bzImage_addr, bzImage_size, 0, 0, 0);
 275
 276         if (NULL == base_ptr) {
 277                 printf ("## Kernel loading failed ...\n");
 278         } else {
 279                 printf ("## Transferring control to Linux (at address %08x) ...\n",
 280                         (u32)base_ptr);
 281
 282                 /* we assume that the kernel is in place */
 283                 printf("\nStarting kernel ...\n\n");
 284
 285                 boot_zimage(base_ptr);
 286                 /* does not return */
 287         }
 288
 289         return -1;
 290 }
 291
 292 U_BOOT_CMD(
 293         zboot, 2, 0,    do_zboot,
 294         "Boot bzImage",
 295         ""
 296 );