/* SPDX-License-Identifier: GPL-2.0-only */ /* * C Bootstrap code for the coreboot */ #include <acpi/acpi.h> #include <acpi/acpi_gnvs.h> #include <adainit.h> #include <arch/exception.h> #include <boot/tables.h> #include <bootstate.h> #include <cbmem.h> #include <commonlib/console/post_codes.h> #include <commonlib/helpers.h> #include <console/console.h> #include <delay.h> #include <device/device.h> #include <device/pci.h> #include <program_loading.h> #include <thread.h> #include <timer.h> #include <timestamp.h> #include <types.h> static boot_state_t bs_pre_device(void *arg); static boot_state_t bs_dev_init_chips(void *arg); static boot_state_t bs_dev_enumerate(void *arg); static boot_state_t bs_dev_resources(void *arg); static boot_state_t bs_dev_enable(void *arg); static boot_state_t bs_dev_init(void *arg); static boot_state_t bs_post_device(void *arg); static boot_state_t bs_os_resume_check(void *arg); static boot_state_t bs_os_resume(void *arg); static boot_state_t bs_write_tables(void *arg); static boot_state_t bs_payload_load(void *arg); static boot_state_t bs_payload_boot(void *arg); /* The prologue (BS_ON_ENTRY) and epilogue (BS_ON_EXIT) of a state can be * blocked from transitioning to the next (state,seq) pair. When the blockers * field is 0 a transition may occur. */ struct boot_phase { struct boot_state_callback *callbacks; int blockers; }; struct boot_state { const char *name; boot_state_t id; u8 post_code; struct boot_phase phases[2]; boot_state_t (*run_state)(void *arg); void *arg; int num_samples; bool complete; }; #define BS_INIT(state_, run_func_) \ { \ .name = #state_, \ .id = state_, \ .post_code = POSTCODE_ ## state_, \ .phases = { { NULL, 0 }, { NULL, 0 } }, \ .run_state = run_func_, \ .arg = NULL, \ .complete = false, \ } #define BS_INIT_ENTRY(state_, run_func_) \ [state_] = BS_INIT(state_, run_func_) static struct boot_state boot_states[] = { BS_INIT_ENTRY(BS_PRE_DEVICE, bs_pre_device), BS_INIT_ENTRY(BS_DEV_INIT_CHIPS, bs_dev_init_chips), BS_INIT_ENTRY(BS_DEV_ENUMERATE, bs_dev_enumerate), BS_INIT_ENTRY(BS_DEV_RESOURCES, bs_dev_resources), BS_INIT_ENTRY(BS_DEV_ENABLE, bs_dev_enable), BS_INIT_ENTRY(BS_DEV_INIT, bs_dev_init), BS_INIT_ENTRY(BS_POST_DEVICE, bs_post_device), BS_INIT_ENTRY(BS_OS_RESUME_CHECK, bs_os_resume_check), BS_INIT_ENTRY(BS_OS_RESUME, bs_os_resume), BS_INIT_ENTRY(BS_WRITE_TABLES, bs_write_tables), BS_INIT_ENTRY(BS_PAYLOAD_LOAD, bs_payload_load), BS_INIT_ENTRY(BS_PAYLOAD_BOOT, bs_payload_boot), }; void __weak arch_bootstate_coreboot_exit(void) { } static boot_state_t bs_pre_device(void *arg) { return BS_DEV_INIT_CHIPS; } static boot_state_t bs_dev_init_chips(void *arg) { timestamp_add_now(TS_DEVICE_ENUMERATE); /* Initialize chips early, they might disable unused devices. */ dev_initialize_chips(); return BS_DEV_ENUMERATE; } static boot_state_t bs_dev_enumerate(void *arg) { /* Find the devices we don't have hard coded knowledge about. */ dev_enumerate(); return BS_DEV_RESOURCES; } static boot_state_t bs_dev_resources(void *arg) { timestamp_add_now(TS_DEVICE_CONFIGURE); /* Now compute and assign the bus resources. */ dev_configure(); return BS_DEV_ENABLE; } static boot_state_t bs_dev_enable(void *arg) { timestamp_add_now(TS_DEVICE_ENABLE); /* Now actually enable devices on the bus */ dev_enable(); return BS_DEV_INIT; } static boot_state_t bs_dev_init(void *arg) { timestamp_add_now(TS_DEVICE_INITIALIZE); /* And of course initialize devices on the bus */ dev_initialize(); return BS_POST_DEVICE; } static boot_state_t bs_post_device(void *arg) { dev_finalize(); timestamp_add_now(TS_DEVICE_DONE); return BS_OS_RESUME_CHECK; } static boot_state_t bs_os_resume_check(void *arg) { void *wake_vector = NULL; if (CONFIG(HAVE_ACPI_RESUME)) wake_vector = acpi_find_wakeup_vector(); if (wake_vector != NULL) { boot_states[BS_OS_RESUME].arg = wake_vector; return BS_OS_RESUME; } timestamp_add_now(TS_CBMEM_POST); return BS_WRITE_TABLES; } static boot_state_t bs_os_resume(void *wake_vector) { if (CONFIG(HAVE_ACPI_RESUME)) { arch_bootstate_coreboot_exit(); acpi_resume(wake_vector); /* We will not come back. */ } die("Failed OS resume\n"); } static boot_state_t bs_write_tables(void *arg) { timestamp_add_now(TS_WRITE_TABLES); /* Now that we have collected all of our information * write our configuration tables. */ write_tables(); timestamp_add_now(TS_FINALIZE_CHIPS); dev_finalize_chips(); return BS_PAYLOAD_LOAD; } static boot_state_t bs_payload_load(void *arg) { payload_load(); return BS_PAYLOAD_BOOT; } static boot_state_t bs_payload_boot(void *arg) { arch_bootstate_coreboot_exit(); payload_run(); printk(BIOS_EMERG, "Boot failed\n"); /* Returning from this state will fail because the following signals * return to a completed state. */ return BS_PAYLOAD_BOOT; } /* * Typically a state will take 4 time samples: * 1. Before state entry callbacks * 2. After state entry callbacks / Before state function. * 3. After state function / Before state exit callbacks. * 4. After state exit callbacks. */ static void bs_sample_time(struct boot_state *state) { static const char *const sample_id[] = { "entry", "run", "exit" }; static struct mono_time previous_sample; struct mono_time this_sample; long console; if (!CONFIG(HAVE_MONOTONIC_TIMER)) return; console = console_time_get_and_reset(); timer_monotonic_get(&this_sample); state->num_samples++; int i = state->num_samples - 2; if ((i >= 0) && (i < ARRAY_SIZE(sample_id))) { long execution = mono_time_diff_microseconds(&previous_sample, &this_sample); /* Report with millisecond precision to reduce log diffs. */ execution = DIV_ROUND_CLOSEST(execution, USECS_PER_MSEC); console = DIV_ROUND_CLOSEST(console, USECS_PER_MSEC); if (execution) { printk(BIOS_DEBUG, "BS: %s %s times (exec / console): %ld / %ld ms\n", state->name, sample_id[i], execution - console, console); /* Reset again to ignore printk() time above. */ console_time_get_and_reset(); } } timer_monotonic_get(&previous_sample); } #if CONFIG(TIMER_QUEUE) static void bs_run_timers(int drain) { /* Drain all timer callbacks until none are left, if directed. * Otherwise run the timers only once. */ do { if (!timers_run()) break; } while (drain); } #else static void bs_run_timers(int drain) {} #endif static void bs_call_callbacks(struct boot_state *state, boot_state_sequence_t seq) { struct boot_phase *phase = &state->phases[seq]; struct mono_time mt_start, mt_stop; while (1) { if (phase->callbacks != NULL) { struct boot_state_callback *bscb; /* Remove the first callback. */ bscb = phase->callbacks; phase->callbacks = bscb->next; bscb->next = NULL; if (CONFIG(DEBUG_BOOT_STATE)) { printk(BIOS_DEBUG, "BS: callback (%p) @ %s.\n", bscb, bscb_location(bscb)); timer_monotonic_get(&mt_start); } bscb->callback(bscb->arg); if (CONFIG(DEBUG_BOOT_STATE)) { timer_monotonic_get(&mt_stop); printk(BIOS_DEBUG, "BS: callback (%p) @ %s (%lld ms).\n", bscb, bscb_location(bscb), mono_time_diff_microseconds(&mt_start, &mt_stop) / USECS_PER_MSEC); } bs_run_timers(0); continue; } /* All callbacks are complete and there are no blockers for * this state. Therefore, this part of the state is complete. */ if (!phase->blockers) break; /* Something is blocking this state from transitioning. As * there are no more callbacks a pending timer needs to be * ran to unblock the state. */ bs_run_timers(0); } } /* Keep track of the current state. */ static struct state_tracker { boot_state_t state_id; boot_state_sequence_t seq; } current_phase = { .state_id = BS_PRE_DEVICE, .seq = BS_ON_ENTRY, }; static void bs_walk_state_machine(void) { while (1) { struct boot_state *state; boot_state_t next_id; state = &boot_states[current_phase.state_id]; if (state->complete) { printk(BIOS_EMERG, "BS: %s state already executed.\n", state->name); break; } if (CONFIG(DEBUG_BOOT_STATE)) printk(BIOS_DEBUG, "BS: Entering %s state.\n", state->name); bs_run_timers(0); bs_sample_time(state); bs_call_callbacks(state, current_phase.seq); /* Update the current sequence so that any calls to block the * current state from the run_state() function will place a * block on the correct phase. */ current_phase.seq = BS_ON_EXIT; bs_sample_time(state); post_code(state->post_code); next_id = state->run_state(state->arg); if (CONFIG(DEBUG_BOOT_STATE)) printk(BIOS_DEBUG, "BS: Exiting %s state.\n", state->name); bs_sample_time(state); bs_run_timers(0); bs_call_callbacks(state, current_phase.seq); if (CONFIG(DEBUG_BOOT_STATE)) printk(BIOS_DEBUG, "----------------------------------------\n"); /* Update the current phase with new state id and sequence. */ current_phase.state_id = next_id; current_phase.seq = BS_ON_ENTRY; bs_sample_time(state); state->complete = true; } } static int boot_state_sched_callback(struct boot_state *state, struct boot_state_callback *bscb, boot_state_sequence_t seq) { if (state->complete) { printk(BIOS_WARNING, "Tried to schedule callback on completed state %s.\n", state->name); return -1; } bscb->next = state->phases[seq].callbacks; state->phases[seq].callbacks = bscb; return 0; } int boot_state_sched_on_entry(struct boot_state_callback *bscb, boot_state_t state_id) { struct boot_state *state = &boot_states[state_id]; return boot_state_sched_callback(state, bscb, BS_ON_ENTRY); } int boot_state_sched_on_exit(struct boot_state_callback *bscb, boot_state_t state_id) { struct boot_state *state = &boot_states[state_id]; return boot_state_sched_callback(state, bscb, BS_ON_EXIT); } static void boot_state_schedule_static_entries(void) { extern struct boot_state_init_entry *_bs_init_begin[]; struct boot_state_init_entry **slot; for (slot = &_bs_init_begin[0]; *slot != NULL; slot++) { struct boot_state_init_entry *cur = *slot; if (cur->when == BS_ON_ENTRY) boot_state_sched_on_entry(&cur->bscb, cur->state); else boot_state_sched_on_exit(&cur->bscb, cur->state); } } void main(void) { /* * We can generally jump between C and Ada code back and forth * without trouble. But since we don't have an Ada main() we * have to do some Ada package initializations that GNAT would * do there. This has to be done before calling any Ada code. * * The package initializations should not have any dependen- * cies on C code. So we can call them here early, and don't * have to worry at which point we can start to use Ada. */ ramstage_adainit(); /* TODO: Understand why this is here and move to arch/platform code. */ /* For MMIO UART this needs to be called before any other printk. */ if (ENV_X86) init_timer(); /* console_init() MUST PRECEDE ALL printk()! Additionally, ensure * it is the very first thing done in ramstage.*/ console_init(); post_code(POSTCODE_CONSOLE_READY); exception_init(); /* * CBMEM needs to be recovered because timestamps, ACPI, etc rely on * the cbmem infrastructure being around. Explicitly recover it. */ cbmem_initialize(); timestamp_add_now(TS_RAMSTAGE_START); post_code(POSTCODE_ENTRY_HARDWAREMAIN); /* Handoff sleep type from romstage. */ acpi_is_wakeup_s3(); /* Schedule the static boot state entries. */ boot_state_schedule_static_entries(); bs_walk_state_machine(); die("Boot state machine failure.\n"); } int boot_state_block(boot_state_t state, boot_state_sequence_t seq) { struct boot_phase *bp; /* Blocking a previously ran state is not appropriate. */ if (current_phase.state_id > state || (current_phase.state_id == state && current_phase.seq > seq)) { printk(BIOS_WARNING, "BS: Completed state (%d, %d) block attempted.\n", state, seq); return -1; } bp = &boot_states[state].phases[seq]; bp->blockers++; return 0; } int boot_state_unblock(boot_state_t state, boot_state_sequence_t seq) { struct boot_phase *bp; /* Blocking a previously ran state is not appropriate. */ if (current_phase.state_id > state || (current_phase.state_id == state && current_phase.seq > seq)) { printk(BIOS_WARNING, "BS: Completed state (%d, %d) unblock attempted.\n", state, seq); return -1; } bp = &boot_states[state].phases[seq]; if (bp->blockers == 0) { printk(BIOS_WARNING, "BS: Unblock attempted on non-blocked state (%d, %d).\n", state, seq); return -1; } bp->blockers--; return 0; }