void start_main(void)
{
extern int main(int argc, char **argv);
/* Gather system information. */
lib_get_sysinfo();
/* Optionally set up the consoles. */
#ifndef CONFIG_LP_SKIP_CONSOLE_INIT
console_init();
#endif
/*
* Any other system init that has to happen before the
* user gets control goes here.
*/
/*
* Go to the entry point.
* In the future we may care about the return value.
*/
(void) main(main_argc, (main_argc != 0) ? main_argv : NULL);
/*
* Returning here will go to the _leave function to return
* us to the original context.
*/
}
static int bootlog_module_init(void)
{
/* Make sure that lib_sysinfo is initialized */
int ret = lib_get_sysinfo();
if (ret) {
return -1;
}
struct cbmem_console *console = lib_sysinfo.cbmem_cons;
if (console == NULL) {
return -1;
}
/* Extract console information */
char *buffer = (char *)(&(console->body));
u32 buffer_size = console->size;
u32 cursor = console->cursor;
/* The cursor may be bigger than buffer size when the buffer is full */
if (cursor >= buffer_size) {
cursor = buffer_size - 1;
}
/* Calculate how much characters will be displayed on screen */
u32 chars_count = calculate_chars_count(buffer, cursor + 1, SCREEN_X, LINES_SHOWN);
/* Sanity check, chars_count must be padded to full line */
if (chars_count % SCREEN_X != 0) {
return -2;
}
g_lines_count = chars_count / SCREEN_X;
g_max_cursor_line = MAX(g_lines_count - 1 - LINES_SHOWN, 0);
g_buf = malloc(chars_count);
if (!g_buf) {
return -3;
}
if (sanitize_buffer_for_display(buffer, cursor + 1,
g_buf, chars_count,
SCREEN_X) < 0) {
free(g_buf);
g_buf = NULL;
return -4;
}
/* TODO: Maybe a _cleanup hook where we call free()? */
return 0;
}
int start_main(void)
{
extern int main(int argc, char **argv);
/* Gather system information. */
lib_get_sysinfo();
/* Optionally set up the consoles. */
#if !CONFIG(LP_SKIP_CONSOLE_INIT)
console_init();
#endif
exception_init();
if (CONFIG(LP_ENABLE_APIC)) {
apic_init();
enable_interrupts();
}
/*
* Any other system init that has to happen before the
* user gets control goes here.
*/
/*
* Go to the entry point.
* In the future we may care about the return value.
*/
/*
* Returning from main() will go to the _leave function to return
* us to the original context.
*/
return main(main_argc, (main_argc != 0) ? main_argv : NULL);
}
void start_main(void)
{
extern int main(int argc, char **argv);
pre_sysinfo_scan_mmu_setup();
/* Gather system information. */
lib_get_sysinfo();
post_sysinfo_scan_mmu_setup();
#if !IS_ENABLED(CONFIG_LP_SKIP_CONSOLE_INIT)
console_init();
#endif
printf("ARM64: Libpayload %s\n",__func__);
exception_init();
test_exception();
/*
* Any other system init that has to happen before the
* user gets control goes here.
*/
/*
* Go to the entry point.
* In the future we may care about the return value.
*/
(void) main(main_argc, (main_argc != 0) ? main_argv : NULL);
/*
* Returning here will go to the _leave function to return
* us to the original context.
*/
}
static int timestamps_module_init(void)
{
/* Make sure that lib_sysinfo is initialized */
int ret = lib_get_sysinfo();
if (ret)
return -1;
struct timestamp_table *timestamps = lib_sysinfo.tstamp_table;
if (timestamps == NULL)
return -1;
/* Extract timestamps information */
u64 base_time = timestamps->base_time;
u16 max_entries = timestamps->max_entries;
u32 n_entries = timestamps->num_entries;
timestamp_set_tick_freq(timestamps->tick_freq_mhz);
char *buffer;
u32 buff_cur = 0;
uint64_t prev_stamp;
uint64_t total_time;
/* Allocate a buffer big enough to contain all of the possible
* entries plus the other information (number entries, total time). */
buffer = malloc((max_entries + 4) * SCREEN_X * sizeof(char));
if (buffer == NULL)
return -3;
/* Write the content */
buff_cur += snprintf(buffer, SCREEN_X, "%d entries total:\n\n",
n_entries);
prev_stamp = 0;
timestamp_print_entry(buffer, SCREEN_X, &buff_cur, 0, base_time,
prev_stamp);
prev_stamp = base_time;
total_time = 0;
for (int i = 0; i < n_entries; i++) {
uint64_t stamp;
const struct timestamp_entry *tse = ×tamps->entries[i];
stamp = tse->entry_stamp + base_time;
total_time += timestamp_print_entry(buffer, SCREEN_X,
&buff_cur, tse->entry_id, stamp, prev_stamp);
prev_stamp = stamp;
}
buff_cur += snprintf(buffer + buff_cur, SCREEN_X, "\nTotal Time: ");
buff_cur += snprintf(buffer + buff_cur, SCREEN_X, "%llu", total_time);
buff_cur += snprintf(buffer + buff_cur, SCREEN_X, "\n");
/* Calculate how many characters will be displayed on screen */
u32 chars_count = calculate_chars_count(buffer, buff_cur + 1,
SCREEN_X, LINES_SHOWN);
/* Sanity check, chars_count must be padded to full line */
if (chars_count % SCREEN_X != 0) {
free(buffer);
return -2;
}
g_lines_count = chars_count / SCREEN_X;
g_max_cursor_line = MAX(g_lines_count - 1 - LINES_SHOWN, 0);
g_buf = malloc(chars_count);
if (!g_buf) {
free(buffer);
return -3;
}
if (sanitize_buffer_for_display(buffer, buff_cur + 1, g_buf,
chars_count, SCREEN_X) < 0) {
free(buffer);
free(g_buf);
g_buf = NULL;
return -4;
}
free(buffer);
return 0;
}
int main()
{
int ch, done;
ITEM *cur;
/* coreboot data structures */
lib_get_sysinfo();
struct cb_cmos_option_table *opttbl = get_system_option_table();
if (opttbl == NULL) {
printf("Could not find coreboot option table\n");
halt();
}
/* display initialization */
initscr();
keypad(stdscr, TRUE);
cbreak();
noecho();
start_color();
leaveok(stdscr, TRUE);
curs_set(1);
erase();
box(stdscr, 0, 0);
mvaddstr(0, 2, "coreboot configuration utility");
/* prep CMOS layout into libcurses data structures */
/* determine number of options, and maximum option name length */
int numopts=0;
int maxlength=0;
struct cb_cmos_entries *option = first_cmos_entry(opttbl);
while (option) {
if ((option->config != 'r') && (strcmp("check_sum", option->name) != 0)) {
maxlength = max(maxlength, strlen(option->name));
numopts++;
}
option = next_cmos_entry(option);
}
if (numopts == 0) {
printf("NO CMOS OPTIONS FOUND. EXITING!!!");
return 1;
}
FIELD **fields = malloc(sizeof(FIELD*)*(2*numopts+1));
int i;
/* walk over options, fetch details */
option = first_cmos_entry(opttbl);
for (i=0;i<numopts;i++) {
while ((option->config == 'r') || (strcmp("check_sum", option->name) == 0)) {
option = next_cmos_entry(option);
}
fields[2*i] = new_field(1, strlen(option->name), i*2, 1, 0, 0);
set_field_buffer(fields[2*i], 0, option->name);
field_opts_off(fields[2*i], O_ACTIVE);
fields[2*i+1] = new_field(1, 40, i*2, maxlength+2, 0, 0);
char *buf = NULL;
int fail = get_option_as_string(use_nvram, opttbl, &buf, option->name);
switch (option->config) {
case 'h': {
set_field_type(fields[2*i+1], TYPE_INTEGER, 0, 0, (1<<option->length)-1);
field_opts_on(fields[2*i+1], O_BLANK);
break;
}
case 's': {
set_max_field(fields[2*i+1], option->length/8);
field_opts_off(fields[2*i+1], O_STATIC);
break;
}
case 'e': {
int numvals = 0;
struct cb_cmos_enums *cmos_enum = first_cmos_enum_of_id(opttbl, option->config_id);
/* if invalid data in CMOS, set buf to first enum */
if (fail && cmos_enum) {
buf = cmos_enum->text;
}
while (cmos_enum) {
numvals++;
cmos_enum = next_cmos_enum_of_id(cmos_enum, option->config_id);
}
char **values = malloc(sizeof(char*)*numvals + 1);
int cnt = 0;
cmos_enum = first_cmos_enum_of_id(opttbl, option->config_id);
while (cmos_enum) {
values[cnt] = cmos_enum->text;
cnt++;
cmos_enum = next_cmos_enum_of_id(cmos_enum, option->config_id);
}
values[cnt] = NULL;
field_opts_off(fields[2*i+1], O_EDIT);
set_field_type(fields[2*i+1], TYPE_ENUM, values, 1, 1);
free(values); // copied by set_field_type
break;
}
default:
break;
}
if (buf) set_field_buffer(fields[2*i+1], 0, buf);
#if HOSTED
// underline is non-trivial on VGA text
set_field_back(fields[2*i+1], A_UNDERLINE);
#endif
field_opts_off(fields[2*i+1], O_BLANK | O_AUTOSKIP | O_NULLOK);
option = next_cmos_entry(option);
}
fields[2*numopts]=NULL;
FORM *form = new_form(fields);
int numlines = min(numopts*2, 16);
WINDOW *w = newwin(numlines+2, 70, 2, 1);
WINDOW *inner_w = newpad(numopts*2, 68);
box(w, 0, 0);
mvwaddstr(w, 0, 2, "Press F1 when done");
set_form_win(form, w);
set_form_sub(form, inner_w);
post_form(form);
done = 0;
while(!done) {
ch=getch();
if (ch == ERR) continue;
switch (ch) {
case KEY_DOWN:
form_driver(form, REQ_NEXT_FIELD);
break;
case KEY_UP:
form_driver(form, REQ_PREV_FIELD);
break;
case KEY_LEFT:
if (field_type(current_field(form)) == TYPE_ENUM) {
form_driver(form, REQ_PREV_CHOICE);
} else {
form_driver(form, REQ_LEFT_CHAR);
}
break;
case KEY_RIGHT:
if (field_type(current_field(form)) == TYPE_ENUM) {
form_driver(form, REQ_NEXT_CHOICE);
} else {
form_driver(form, REQ_RIGHT_CHAR);
}
break;
case KEY_BACKSPACE:
case '\b':
form_driver(form, REQ_DEL_PREV);
break;
case KEY_DC:
form_driver(form, REQ_DEL_CHAR);
break;
case KEY_F(1):
done=1;
break;
default:
form_driver(form, ch);
break;
}
render_form(form);
}
for (i = 0; i < numopts; i++) {
char *name = field_buffer(fields[2*i], 0);
char *value = field_buffer(fields[2*i+1], 0);
char *ptr;
for (ptr = value + strlen (value) - 1;
ptr >= value && *ptr == ' '; ptr--);
ptr[1] = '\0';
set_option_from_string(use_nvram, opttbl, value, name);
}
unpost_form(form);
free_form(form);
touchwin(stdscr);
refresh();
endwin();
/* TODO: reboot */
halt();
}
