arch/x86/lib/zimage.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2011 The Chromium OS Authors.
   4  * (C) Copyright 2002
   5  * Daniel Engström, Omicron Ceti AB, <[email protected]>
   6  */
   7
   8 /*
   9  * Linux x86 zImage and bzImage loading
  10  *
  11  * based on the procdure described in
  12  * linux/Documentation/i386/boot.txt
  13  */
  14
  15 #define LOG_CATEGORY    LOGC_BOOT
  16
  17 #include <common.h>
  18 #include <bootm.h>
  19 #include <command.h>
  20 #include <env.h>
  21 #include <init.h>
  22 #include <irq_func.h>
  23 #include <log.h>
  24 #include <malloc.h>
  25 #include <mapmem.h>
  26 #include <acpi/acpi_table.h>
  27 #include <asm/io.h>
  28 #include <asm/ptrace.h>
  29 #include <asm/zimage.h>
  30 #include <asm/byteorder.h>
  31 #include <asm/bootm.h>
  32 #include <asm/bootparam.h>
  33 #include <asm/efi.h>
  34 #include <asm/global_data.h>
  35 #ifdef CONFIG_SYS_COREBOOT
  36 #include <asm/arch/timestamp.h>
  37 #endif
  38 #include <linux/compiler.h>
  39 #include <linux/ctype.h>
  40 #include <linux/libfdt.h>
  41
  42 DECLARE_GLOBAL_DATA_PTR;
  43
  44 /*
  45  * Memory lay-out:
  46  *
  47  * relative to setup_base (which is 0x90000 currently)
  48  *
  49  *      0x0000-0x7FFF   Real mode kernel
  50  *      0x8000-0x8FFF   Stack and heap
  51  *      0x9000-0x90FF   Kernel command line
  52  */
  53 #define DEFAULT_SETUP_BASE      0x90000
  54 #define COMMAND_LINE_OFFSET     0x9000
  55 #define HEAP_END_OFFSET         0x8e00
  56
  57 #define COMMAND_LINE_SIZE       2048
  58
  59 /* Current state of the boot */
  60 struct zboot_state state;
  61
  62 static void build_command_line(char *command_line, int auto_boot)
  63 {
  64         char *env_command_line;
  65
  66         command_line[0] = '\0';
  67
  68         env_command_line =  env_get("bootargs");
  69
  70         /* set console= argument if we use a serial console */
  71         if (!strstr(env_command_line, "console=")) {
  72                 if (!strcmp(env_get("stdout"), "serial")) {
  73
  74                         /* We seem to use serial console */
  75                         sprintf(command_line, "console=ttyS0,%s ",
  76                                 env_get("baudrate"));
  77                 }
  78         }
  79
  80         if (auto_boot)
  81                 strcat(command_line, "auto ");
  82
  83         if (env_command_line)
  84                 strcat(command_line, env_command_line);
  85 #ifdef DEBUG
  86         printf("Kernel command line:");
  87         puts(command_line);
  88         printf("\n");
  89 #endif
  90 }
  91
  92 static int kernel_magic_ok(struct setup_header *hdr)
  93 {
  94         if (KERNEL_MAGIC != hdr->boot_flag) {
  95                 printf("Error: Invalid Boot Flag "
  96                         "(found 0x%04x, expected 0x%04x)\n",
  97                         hdr->boot_flag, KERNEL_MAGIC);
  98                 return 0;
  99         } else {
 100                 printf("Valid Boot Flag\n");
 101                 return 1;
 102         }
 103 }
 104
 105 static int get_boot_protocol(struct setup_header *hdr, bool verbose)
 106 {
 107         if (hdr->header == KERNEL_V2_MAGIC) {
 108                 if (verbose)
 109                         printf("Magic signature found\n");
 110                 return hdr->version;
 111         } else {
 112                 /* Very old kernel */
 113                 if (verbose)
 114                         printf("Magic signature not found\n");
 115                 return 0x0100;
 116         }
 117 }
 118
 119 static int setup_device_tree(struct setup_header *hdr, const void *fdt_blob)
 120 {
 121         int bootproto = get_boot_protocol(hdr, false);
 122         struct setup_data *sd;
 123         int size;
 124
 125         if (bootproto < 0x0209)
 126                 return -ENOTSUPP;
 127
 128         if (!fdt_blob)
 129                 return 0;
 130
 131         size = fdt_totalsize(fdt_blob);
 132         if (size < 0)
 133                 return -EINVAL;
 134
 135         size += sizeof(struct setup_data);
 136         sd = (struct setup_data *)malloc(size);
 137         if (!sd) {
 138                 printf("Not enough memory for DTB setup data\n");
 139                 return -ENOMEM;
 140         }
 141
 142         sd->next = hdr->setup_data;
 143         sd->type = SETUP_DTB;
 144         sd->len = fdt_totalsize(fdt_blob);
 145         memcpy(sd->data, fdt_blob, sd->len);
 146         hdr->setup_data = (unsigned long)sd;
 147
 148         return 0;
 149 }
 150
 151 const char *zimage_get_kernel_version(struct boot_params *params,
 152                                       void *kernel_base)
 153 {
 154         struct setup_header *hdr = &params->hdr;
 155         int bootproto;
 156         const char *s, *end;
 157
 158         bootproto = get_boot_protocol(hdr, false);
 159         log_debug("bootproto %x, hdr->setup_sects %x\n", bootproto,
 160                   hdr->setup_sects);
 161         if (bootproto < 0x0200 || hdr->setup_sects < 15)
 162                 return NULL;
 163
 164         /* sanity-check the kernel version in case it is missing */
 165         log_debug("hdr->kernel_version %x, str at %p\n", hdr->kernel_version,
 166                   kernel_base + hdr->kernel_version + 0x200);
 167         for (s = kernel_base + hdr->kernel_version + 0x200, end = s + 0x100; *s;
 168              s++) {
 169                 if (!isprint(*s))
 170                         return NULL;
 171         }
 172
 173         return kernel_base + hdr->kernel_version + 0x200;
 174 }
 175
 176 struct boot_params *load_zimage(char *image, unsigned long kernel_size,
 177                                 ulong *load_addressp)
 178 {
 179         struct boot_params *setup_base;
 180         const char *version;
 181         int setup_size;
 182         int bootproto;
 183         int big_image;
 184
 185         struct boot_params *params = (struct boot_params *)image;
 186         struct setup_header *hdr = &params->hdr;
 187
 188         /* base address for real-mode segment */
 189         setup_base = (struct boot_params *)DEFAULT_SETUP_BASE;
 190
 191         if (!kernel_magic_ok(hdr))
 192                 return 0;
 193
 194         /* determine size of setup */
 195         if (0 == hdr->setup_sects) {
 196                 log_warning("Setup Sectors = 0 (defaulting to 4)\n");
 197                 setup_size = 5 * 512;
 198         } else {
 199                 setup_size = (hdr->setup_sects + 1) * 512;
 200         }
 201
 202         log_debug("Setup Size = 0x%8.8lx\n", (ulong)setup_size);
 203
 204         if (setup_size > SETUP_MAX_SIZE)
 205                 printf("Error: Setup is too large (%d bytes)\n", setup_size);
 206
 207         /* determine boot protocol version */
 208         bootproto = get_boot_protocol(hdr, true);
 209
 210         log_debug("Using boot protocol version %x.%02x\n",
 211                   (bootproto & 0xff00) >> 8, bootproto & 0xff);
 212
 213         version = zimage_get_kernel_version(params, image);
 214         if (version)
 215                 printf("Linux kernel version %s\n", version);
 216         else
 217                 printf("Setup Sectors < 15 - Cannot print kernel version\n");
 218
 219         /* Determine image type */
 220         big_image = (bootproto >= 0x0200) &&
 221                     (hdr->loadflags & BIG_KERNEL_FLAG);
 222
 223         /* Determine load address */
 224         if (big_image)
 225                 *load_addressp = BZIMAGE_LOAD_ADDR;
 226         else
 227                 *load_addressp = ZIMAGE_LOAD_ADDR;
 228
 229         printf("Building boot_params at 0x%8.8lx\n", (ulong)setup_base);
 230         memset(setup_base, 0, sizeof(*setup_base));
 231         setup_base->hdr = params->hdr;
 232
 233         if (bootproto >= 0x0204)
 234                 kernel_size = hdr->syssize * 16;
 235         else
 236                 kernel_size -= setup_size;
 237
 238         if (bootproto == 0x0100) {
 239                 /*
 240                  * A very old kernel MUST have its real-mode code
 241                  * loaded at 0x90000
 242                  */
 243                 if ((ulong)setup_base != 0x90000) {
 244                         /* Copy the real-mode kernel */
 245                         memmove((void *)0x90000, setup_base, setup_size);
 246
 247                         /* Copy the command line */
 248                         memmove((void *)0x99000,
 249                                 (u8 *)setup_base + COMMAND_LINE_OFFSET,
 250                                 COMMAND_LINE_SIZE);
 251
 252                          /* Relocated */
 253                         setup_base = (struct boot_params *)0x90000;
 254                 }
 255
 256                 /* It is recommended to clear memory up to the 32K mark */
 257                 memset((u8 *)0x90000 + setup_size, 0,
 258                        SETUP_MAX_SIZE - setup_size);
 259         }
 260
 261         if (big_image) {
 262                 if (kernel_size > BZIMAGE_MAX_SIZE) {
 263                         printf("Error: bzImage kernel too big! "
 264                                 "(size: %ld, max: %d)\n",
 265                                 kernel_size, BZIMAGE_MAX_SIZE);
 266                         return 0;
 267                 }
 268         } else if ((kernel_size) > ZIMAGE_MAX_SIZE) {
 269                 printf("Error: zImage kernel too big! (size: %ld, max: %d)\n",
 270                        kernel_size, ZIMAGE_MAX_SIZE);
 271                 return 0;
 272         }
 273
 274         printf("Loading %s at address %lx (%ld bytes)\n",
 275                big_image ? "bzImage" : "zImage", *load_addressp, kernel_size);
 276
 277         memmove((void *)*load_addressp, image + setup_size, kernel_size);
 278
 279         return setup_base;
 280 }
 281
 282 int setup_zimage(struct boot_params *setup_base, char *cmd_line, int auto_boot,
 283                  ulong initrd_addr, ulong initrd_size, ulong cmdline_force)
 284 {
 285         struct setup_header *hdr = &setup_base->hdr;
 286         int bootproto = get_boot_protocol(hdr, false);
 287
 288         log_debug("Setup E820 entries\n");
 289         if (IS_ENABLED(CONFIG_COREBOOT_SYSINFO)) {
 290                 setup_base->e820_entries = cb_install_e820_map(
 291                         ARRAY_SIZE(setup_base->e820_map), setup_base->e820_map);
 292         } else {
 293                 setup_base->e820_entries = install_e820_map(
 294                         ARRAY_SIZE(setup_base->e820_map), setup_base->e820_map);
 295         }
 296
 297         if (bootproto == 0x0100) {
 298                 setup_base->screen_info.cl_magic = COMMAND_LINE_MAGIC;
 299                 setup_base->screen_info.cl_offset = COMMAND_LINE_OFFSET;
 300         }
 301         if (bootproto >= 0x0200) {
 302                 hdr->type_of_loader = 0x80;     /* U-Boot version 0 */
 303                 if (initrd_addr) {
 304                         printf("Initial RAM disk at linear address "
 305                                "0x%08lx, size %ld bytes\n",
 306                                initrd_addr, initrd_size);
 307
 308                         hdr->ramdisk_image = initrd_addr;
 309                         hdr->ramdisk_size = initrd_size;
 310                 }
 311         }
 312
 313         if (bootproto >= 0x0201) {
 314                 hdr->heap_end_ptr = HEAP_END_OFFSET;
 315                 hdr->loadflags |= HEAP_FLAG;
 316         }
 317
 318         if (cmd_line) {
 319                 int max_size = 0xff;
 320                 int ret;
 321
 322                 log_debug("Setup cmdline\n");
 323                 if (bootproto >= 0x0206)
 324                         max_size = hdr->cmdline_size;
 325                 if (bootproto >= 0x0202) {
 326                         hdr->cmd_line_ptr = (uintptr_t)cmd_line;
 327                 } else if (bootproto >= 0x0200) {
 328                         setup_base->screen_info.cl_magic = COMMAND_LINE_MAGIC;
 329                         setup_base->screen_info.cl_offset =
 330                                 (uintptr_t)cmd_line - (uintptr_t)setup_base;
 331
 332                         hdr->setup_move_size = 0x9100;
 333                 }
 334
 335                 /* build command line at COMMAND_LINE_OFFSET */
 336                 if (cmdline_force)
 337                         strcpy(cmd_line, (char *)cmdline_force);
 338                 else
 339                         build_command_line(cmd_line, auto_boot);
 340                 if (IS_ENABLED(CONFIG_CMD_BOOTM)) {
 341                         ret = bootm_process_cmdline(cmd_line, max_size,
 342                                                     BOOTM_CL_ALL);
 343                         if (ret) {
 344                                 printf("Cmdline setup failed (max_size=%x, bootproto=%x, err=%d)\n",
 345                                        max_size, bootproto, ret);
 346                                 return ret;
 347                         }
 348                 }
 349                 printf("Kernel command line: \"");
 350                 puts(cmd_line);
 351                 printf("\"\n");
 352         }
 353
 354         if (IS_ENABLED(CONFIG_INTEL_MID) && bootproto >= 0x0207)
 355                 hdr->hardware_subarch = X86_SUBARCH_INTEL_MID;
 356
 357         if (IS_ENABLED(CONFIG_GENERATE_ACPI_TABLE))
 358                 setup_base->acpi_rsdp_addr = acpi_get_rsdp_addr();
 359
 360         log_debug("Setup devicetree\n");
 361         setup_device_tree(hdr, (const void *)env_get_hex("fdtaddr", 0));
 362         setup_video(&setup_base->screen_info);
 363
 364         if (IS_ENABLED(CONFIG_EFI_STUB))
 365                 setup_efi_info(&setup_base->efi_info);
 366
 367         return 0;
 368 }
 369
 370 int zboot_load(void)
 371 {
 372         struct boot_params *base_ptr;
 373         int ret;
 374
 375         if (state.base_ptr) {
 376                 struct boot_params *from = (struct boot_params *)state.base_ptr;
 377
 378                 base_ptr = (struct boot_params *)DEFAULT_SETUP_BASE;
 379                 log_debug("Building boot_params at 0x%8.8lx\n",
 380                           (ulong)base_ptr);
 381                 memset(base_ptr, '\0', sizeof(*base_ptr));
 382                 base_ptr->hdr = from->hdr;
 383         } else {
 384                 base_ptr = load_zimage((void *)state.bzimage_addr, state.bzimage_size,
 385                                        &state.load_address);
 386                 if (!base_ptr) {
 387                         puts("## Kernel loading failed ...\n");
 388                         return -EINVAL;
 389                 }
 390         }
 391         state.base_ptr = base_ptr;
 392
 393         ret = env_set_hex("zbootbase", map_to_sysmem(state.base_ptr));
 394         if (!ret)
 395                 ret = env_set_hex("zbootaddr", state.load_address);
 396         if (ret)
 397                 return ret;
 398
 399         return 0;
 400 }
 401
 402 int zboot_setup(void)
 403 {
 404         struct boot_params *base_ptr = state.base_ptr;
 405         int ret;
 406
 407         ret = setup_zimage(base_ptr, (char *)base_ptr + COMMAND_LINE_OFFSET,
 408                            0, state.initrd_addr, state.initrd_size,
 409                            (ulong)state.cmdline);
 410         if (ret)
 411                 return -EINVAL;
 412
 413         return 0;
 414 }
 415
 416 int zboot_go(void)
 417 {
 418         struct boot_params *params = state.base_ptr;
 419         struct setup_header *hdr = &params->hdr;
 420         bool image_64bit;
 421         ulong entry;
 422         int ret;
 423
 424         disable_interrupts();
 425
 426         entry = state.load_address;
 427         image_64bit = false;
 428         if (IS_ENABLED(CONFIG_X86_RUN_64BIT) &&
 429             (hdr->xloadflags & XLF_KERNEL_64)) {
 430                 entry += 0x200;
 431                 image_64bit = true;
 432         }
 433
 434         /* we assume that the kernel is in place */
 435         ret = boot_linux_kernel((ulong)state.base_ptr, entry, image_64bit);
 436
 437         return ret;
 438 }
 439
 440 int zboot_run(ulong addr, ulong size, ulong initrd, ulong initrd_size,
 441               ulong base, char *cmdline)
 442 {
 443         int ret;
 444
 445         zboot_start(addr, size, initrd, initrd_size, base, cmdline);
 446         ret = zboot_load();
 447         if (ret)
 448                 return log_msg_ret("ld", ret);
 449         ret = zboot_setup();
 450         if (ret)
 451                 return log_msg_ret("set", ret);
 452         ret = zboot_go();
 453         if (ret)
 454                 return log_msg_ret("go", ret);
 455
 456         return -EFAULT;
 457 }
 458
 459 static void print_num(const char *name, ulong value)
 460 {
 461         printf("%-20s: %lx\n", name, value);
 462 }
 463
 464 static void print_num64(const char *name, u64 value)
 465 {
 466         printf("%-20s: %llx\n", name, value);
 467 }
 468
 469 static const char *const e820_type_name[E820_COUNT] = {
 470         [E820_RAM] = "RAM",
 471         [E820_RESERVED] = "Reserved",
 472         [E820_ACPI] = "ACPI",
 473         [E820_NVS] = "ACPI NVS",
 474         [E820_UNUSABLE] = "Unusable",
 475 };
 476
 477 static const char *const bootloader_id[] = {
 478         "LILO",
 479         "Loadlin",
 480         "bootsect-loader",
 481         "Syslinux",
 482         "Etherboot/gPXE/iPXE",
 483         "ELILO",
 484         "undefined",
 485         "GRUB",
 486         "U-Boot",
 487         "Xen",
 488         "Gujin",
 489         "Qemu",
 490         "Arcturus Networks uCbootloader",
 491         "kexec-tools",
 492         "Extended",
 493         "Special",
 494         "Reserved",
 495         "Minimal Linux Bootloader",
 496         "OVMF UEFI virtualization stack",
 497 };
 498
 499 struct flag_info {
 500         uint bit;
 501         const char *name;
 502 };
 503
 504 static struct flag_info load_flags[] = {
 505         { LOADED_HIGH, "loaded-high" },
 506         { QUIET_FLAG, "quiet" },
 507         { KEEP_SEGMENTS, "keep-segments" },
 508         { CAN_USE_HEAP, "can-use-heap" },
 509 };
 510
 511 static struct flag_info xload_flags[] = {
 512         { XLF_KERNEL_64, "64-bit-entry" },
 513         { XLF_CAN_BE_LOADED_ABOVE_4G, "can-load-above-4gb" },
 514         { XLF_EFI_HANDOVER_32, "32-efi-handoff" },
 515         { XLF_EFI_HANDOVER_64, "64-efi-handoff" },
 516         { XLF_EFI_KEXEC, "kexec-efi-runtime" },
 517 };
 518
 519 static void print_flags(struct flag_info *flags, int count, uint value)
 520 {
 521         int i;
 522
 523         printf("%-20s:", "");
 524         for (i = 0; i < count; i++) {
 525                 uint mask = flags[i].bit;
 526
 527                 if (value & mask)
 528                         printf(" %s", flags[i].name);
 529         }
 530         printf("\n");
 531 }
 532
 533 static void show_loader(struct setup_header *hdr)
 534 {
 535         bool version_valid = false;
 536         int type, version;
 537         const char *name;
 538
 539         type = hdr->type_of_loader >> 4;
 540         version = hdr->type_of_loader & 0xf;
 541         if (type == 0xe)
 542                 type = 0x10 + hdr->ext_loader_type;
 543         version |= hdr->ext_loader_ver << 4;
 544         if (!hdr->type_of_loader) {
 545                 name = "pre-2.00 bootloader";
 546         } else if (hdr->type_of_loader == 0xff) {
 547                 name = "unknown";
 548         } else if (type < ARRAY_SIZE(bootloader_id)) {
 549                 name = bootloader_id[type];
 550                 version_valid = true;
 551         } else {
 552                 name = "undefined";
 553         }
 554         printf("%20s  %s", "", name);
 555         if (version_valid)
 556                 printf(", version %x", version);
 557         printf("\n");
 558 }
 559
 560 void zimage_dump(struct boot_params *base_ptr, bool show_cmdline)
 561 {
 562         struct setup_header *hdr;
 563         const char *version;
 564         int i;
 565
 566         printf("Setup located at %p:\n\n", base_ptr);
 567         print_num64("ACPI RSDP addr", base_ptr->acpi_rsdp_addr);
 568
 569         printf("E820: %d entries\n", base_ptr->e820_entries);
 570         if (base_ptr->e820_entries) {
 571                 printf("%12s  %10s  %s\n", "Addr", "Size", "Type");
 572                 for (i = 0; i < base_ptr->e820_entries; i++) {
 573                         struct e820_entry *entry = &base_ptr->e820_map[i];
 574
 575                         printf("%12llx  %10llx  %s\n", entry->addr, entry->size,
 576                                entry->type < E820_COUNT ?
 577                                e820_type_name[entry->type] :
 578                                simple_itoa(entry->type));
 579                 }
 580         }
 581
 582         hdr = &base_ptr->hdr;
 583         print_num("Setup sectors", hdr->setup_sects);
 584         print_num("Root flags", hdr->root_flags);
 585         print_num("Sys size", hdr->syssize);
 586         print_num("RAM size", hdr->ram_size);
 587         print_num("Video mode", hdr->vid_mode);
 588         print_num("Root dev", hdr->root_dev);
 589         print_num("Boot flag", hdr->boot_flag);
 590         print_num("Jump", hdr->jump);
 591         print_num("Header", hdr->header);
 592         if (hdr->header == KERNEL_V2_MAGIC)
 593                 printf("%-20s  %s\n", "", "Kernel V2");
 594         else
 595                 printf("%-20s  %s\n", "", "Ancient kernel, using version 100");
 596         print_num("Version", hdr->version);
 597         print_num("Real mode switch", hdr->realmode_swtch);
 598         print_num("Start sys seg", hdr->start_sys_seg);
 599         print_num("Kernel version", hdr->kernel_version);
 600         version = zimage_get_kernel_version(base_ptr,
 601                                             (void *)state.bzimage_addr);
 602         if (version)
 603                 printf("   @%p: %s\n", version, version);
 604         print_num("Type of loader", hdr->type_of_loader);
 605         show_loader(hdr);
 606         print_num("Load flags", hdr->loadflags);
 607         print_flags(load_flags, ARRAY_SIZE(load_flags), hdr->loadflags);
 608         print_num("Setup move size", hdr->setup_move_size);
 609         print_num("Code32 start", hdr->code32_start);
 610         print_num("Ramdisk image", hdr->ramdisk_image);
 611         print_num("Ramdisk size", hdr->ramdisk_size);
 612         print_num("Bootsect kludge", hdr->bootsect_kludge);
 613         print_num("Heap end ptr", hdr->heap_end_ptr);
 614         print_num("Ext loader ver", hdr->ext_loader_ver);
 615         print_num("Ext loader type", hdr->ext_loader_type);
 616         print_num("Command line ptr", hdr->cmd_line_ptr);
 617         if (show_cmdline && hdr->cmd_line_ptr) {
 618                 printf("   ");
 619                 /* Use puts() to avoid limits from CONFIG_SYS_PBSIZE */
 620                 puts((char *)(ulong)hdr->cmd_line_ptr);
 621                 printf("\n");
 622         }
 623         print_num("Initrd addr max", hdr->initrd_addr_max);
 624         print_num("Kernel alignment", hdr->kernel_alignment);
 625         print_num("Relocatable kernel", hdr->relocatable_kernel);
 626         print_num("Min alignment", hdr->min_alignment);
 627         if (hdr->min_alignment)
 628                 printf("%-20s: %x\n", "", 1 << hdr->min_alignment);
 629         print_num("Xload flags", hdr->xloadflags);
 630         print_flags(xload_flags, ARRAY_SIZE(xload_flags), hdr->xloadflags);
 631         print_num("Cmdline size", hdr->cmdline_size);
 632         print_num("Hardware subarch", hdr->hardware_subarch);
 633         print_num64("HW subarch data", hdr->hardware_subarch_data);
 634         print_num("Payload offset", hdr->payload_offset);
 635         print_num("Payload length", hdr->payload_length);
 636         print_num64("Setup data", hdr->setup_data);
 637         print_num64("Pref address", hdr->pref_address);
 638         print_num("Init size", hdr->init_size);
 639         print_num("Handover offset", hdr->handover_offset);
 640         if (get_boot_protocol(hdr, false) >= 0x215)
 641                 print_num("Kernel info offset", hdr->kernel_info_offset);
 642 }
 643
 644 void zboot_start(ulong bzimage_addr, ulong bzimage_size, ulong initrd_addr,
 645                  ulong initrd_size, ulong base_addr, const char *cmdline)
 646 {
 647         memset(&state, '\0', sizeof(state));
 648
 649         state.bzimage_size = bzimage_size;
 650         state.initrd_addr = initrd_addr;
 651         state.initrd_size = initrd_size;
 652         if (base_addr) {
 653                 state.base_ptr = map_sysmem(base_addr, 0);
 654                 state.load_address = bzimage_addr;
 655         } else {
 656                 state.bzimage_addr = bzimage_addr;
 657         }
 658         state.cmdline = cmdline;
 659 }
 660
 661 void zboot_info(void)
 662 {
 663         printf("Kernel loaded at %08lx, setup_base=%p\n",
 664                state.load_address, state.base_ptr);
 665 }