189 lines
4.2 KiB
C
189 lines
4.2 KiB
C
/*
|
|
* This file is part of the coreboot project.
|
|
*
|
|
* Copyright 2015 Google Inc.
|
|
*
|
|
* 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; version 2 of the License.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
|
|
#include <stdlib.h>
|
|
#include <cbfs.h>
|
|
#include <cbmem.h>
|
|
#include <console/console.h>
|
|
#include <fallback.h>
|
|
#include <halt.h>
|
|
#include <lib.h>
|
|
#include <program_loading.h>
|
|
#include <romstage_handoff.h>
|
|
#include <rmodule.h>
|
|
#include <rules.h>
|
|
#include <stage_cache.h>
|
|
#include <symbols.h>
|
|
#include <timestamp.h>
|
|
|
|
/* Only can represent up to 1 byte less than size_t. */
|
|
const struct mem_region_device addrspace_32bit = MEM_REGION_DEV_INIT(0, ~0UL);
|
|
|
|
int prog_locate(struct prog *prog)
|
|
{
|
|
struct cbfsf file;
|
|
|
|
cbfs_prepare_program_locate();
|
|
|
|
if (cbfs_boot_locate(&file, prog_name(prog), NULL))
|
|
return -1;
|
|
|
|
cbfs_file_data(prog_rdev(prog), &file);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void run_romstage(void)
|
|
{
|
|
struct prog romstage =
|
|
PROG_INIT(PROG_ROMSTAGE, CONFIG_CBFS_PREFIX "/romstage");
|
|
|
|
if (prog_locate(&romstage))
|
|
goto fail;
|
|
|
|
timestamp_add_now(TS_START_COPYROM);
|
|
|
|
if (cbfs_prog_stage_load(&romstage))
|
|
goto fail;
|
|
|
|
timestamp_add_now(TS_END_COPYROM);
|
|
|
|
prog_run(&romstage);
|
|
|
|
fail:
|
|
if (IS_ENABLED(CONFIG_BOOTBLOCK_CONSOLE))
|
|
die("Couldn't load romstage.\n");
|
|
halt();
|
|
}
|
|
|
|
void __attribute__((weak)) stage_cache_add(int stage_id,
|
|
const struct prog *stage) {}
|
|
void __attribute__((weak)) stage_cache_load_stage(int stage_id,
|
|
struct prog *stage) {}
|
|
void __attribute__((weak)) ramstage_cache_invalid(void) {}
|
|
|
|
static void run_ramstage_from_resume(struct romstage_handoff *handoff,
|
|
struct prog *ramstage)
|
|
{
|
|
if (handoff != NULL && handoff->s3_resume) {
|
|
/* Load the cached ramstage to runtime location. */
|
|
stage_cache_load_stage(STAGE_RAMSTAGE, ramstage);
|
|
|
|
if (prog_entry(ramstage) != NULL) {
|
|
printk(BIOS_DEBUG, "Jumping to image.\n");
|
|
prog_run(ramstage);
|
|
}
|
|
ramstage_cache_invalid();
|
|
}
|
|
}
|
|
|
|
static int load_relocatable_ramstage(struct prog *ramstage)
|
|
{
|
|
struct rmod_stage_load rmod_ram = {
|
|
.cbmem_id = CBMEM_ID_RAMSTAGE,
|
|
.prog = ramstage,
|
|
};
|
|
|
|
return rmodule_stage_load(&rmod_ram);
|
|
}
|
|
|
|
void run_ramstage(void)
|
|
{
|
|
struct prog ramstage =
|
|
PROG_INIT(PROG_RAMSTAGE, CONFIG_CBFS_PREFIX "/ramstage");
|
|
|
|
timestamp_add_now(TS_END_ROMSTAGE);
|
|
|
|
/* Only x86 systems currently take the same firmware path on resume. */
|
|
if (IS_ENABLED(CONFIG_ARCH_X86) && IS_ENABLED(CONFIG_EARLY_CBMEM_INIT))
|
|
run_ramstage_from_resume(romstage_handoff_find_or_add(),
|
|
&ramstage);
|
|
|
|
if (prog_locate(&ramstage))
|
|
goto fail;
|
|
|
|
timestamp_add_now(TS_START_COPYRAM);
|
|
|
|
if (IS_ENABLED(CONFIG_RELOCATABLE_RAMSTAGE)) {
|
|
if (load_relocatable_ramstage(&ramstage))
|
|
goto fail;
|
|
} else if (cbfs_prog_stage_load(&ramstage))
|
|
goto fail;
|
|
|
|
stage_cache_add(STAGE_RAMSTAGE, &ramstage);
|
|
|
|
timestamp_add_now(TS_END_COPYRAM);
|
|
|
|
prog_run(&ramstage);
|
|
|
|
fail:
|
|
die("Ramstage was not loaded!\n");
|
|
}
|
|
|
|
#ifdef __RAMSTAGE__ // gc-sections should take care of this
|
|
|
|
static struct prog global_payload =
|
|
PROG_INIT(PROG_PAYLOAD, CONFIG_CBFS_PREFIX "/payload");
|
|
|
|
void __attribute__((weak)) mirror_payload(struct prog *payload)
|
|
{
|
|
return;
|
|
}
|
|
|
|
void payload_load(void)
|
|
{
|
|
struct prog *payload = &global_payload;
|
|
|
|
timestamp_add_now(TS_LOAD_PAYLOAD);
|
|
|
|
if (prog_locate(payload))
|
|
goto out;
|
|
|
|
mirror_payload(payload);
|
|
|
|
/* Pass cbtables to payload if architecture desires it. */
|
|
prog_set_entry(payload, selfload(payload),
|
|
cbmem_find(CBMEM_ID_CBTABLE));
|
|
|
|
out:
|
|
if (prog_entry(payload) == NULL)
|
|
die("Payload not loaded.\n");
|
|
}
|
|
|
|
void payload_run(void)
|
|
{
|
|
struct prog *payload = &global_payload;
|
|
|
|
/* Reset to booting from this image as late as possible */
|
|
boot_successful();
|
|
|
|
printk(BIOS_DEBUG, "Jumping to boot code at %p(%p)\n",
|
|
prog_entry(payload), prog_entry_arg(payload));
|
|
|
|
post_code(POST_ENTER_ELF_BOOT);
|
|
|
|
timestamp_add_now(TS_SELFBOOT_JUMP);
|
|
|
|
/* Before we go off to run the payload, see if
|
|
* we stayed within our bounds.
|
|
*/
|
|
checkstack(_estack, 0);
|
|
|
|
prog_run(payload);
|
|
}
|
|
|
|
#endif
|