Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 1 | /* |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 2 | * |
| 3 | * Copyright (C) 2012 secunet Security Networks AG |
| 4 | * |
| 5 | * This program is free software; you can redistribute it and/or modify |
| 6 | * it under the terms of the GNU General Public License as published by |
| 7 | * the Free Software Foundation; version 2 of the License. |
| 8 | * |
| 9 | * This program is distributed in the hope that it will be useful, |
| 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 12 | * GNU General Public License for more details. |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 13 | */ |
| 14 | |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 15 | #include <coreboot_tables.h> |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 16 | #include <libpayload.h> |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 17 | |
| 18 | #include <curses.h> |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 19 | #include <form.h> |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 20 | #include <menu.h> |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 21 | |
| 22 | #ifndef HOSTED |
| 23 | #define HOSTED 0 |
| 24 | #endif |
| 25 | |
| 26 | static int min(int x, int y) |
| 27 | { |
| 28 | if (x < y) |
| 29 | return x; |
| 30 | return y; |
| 31 | } |
| 32 | |
| 33 | static int max(int x, int y) |
| 34 | { |
| 35 | if (x > y) |
| 36 | return x; |
| 37 | return y; |
| 38 | } |
| 39 | |
Nico Huber | 92675d6 | 2020-11-15 19:29:22 +0100 | [diff] [blame] | 40 | static void render_form(FORM *form) |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 41 | { |
| 42 | int y, x, line; |
| 43 | WINDOW *w = form_win(form); |
| 44 | WINDOW *inner_w = form_sub(form); |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 45 | int numlines = getmaxy(w) - 2; |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 46 | getyx(inner_w, y, x); |
| 47 | line = y - (y % numlines); |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 48 | WINDOW *der = derwin(w, getmaxy(w) - 2, getmaxx(w) - 2, 1, 1); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 49 | wclear(der); |
| 50 | wrefresh(der); |
| 51 | delwin(der); |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 52 | copywin(inner_w, w, line, 0, 1, 1, |
| 53 | min(numlines, getmaxy(inner_w) - line), 68, 0); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 54 | wmove(w, y + 1 - line, x + 1); |
| 55 | wrefresh(w); |
| 56 | } |
| 57 | |
Antonello Dettori | 904dd30 | 2016-08-18 10:32:27 +0200 | [diff] [blame] | 58 | /* determine number of options, and maximum option name length */ |
| 59 | static int count_cmos_options(struct cb_cmos_entries *option, int *numopts, |
| 60 | int *maxlength) |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 61 | { |
Antonello Dettori | 904dd30 | 2016-08-18 10:32:27 +0200 | [diff] [blame] | 62 | int n_opts = 0; |
| 63 | int max_l = 0; |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 64 | |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 65 | while (option) { |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 66 | if ((option->config != 'r') && |
Martin Roth | 0cf7acc | 2016-04-26 12:33:44 -0600 | [diff] [blame] | 67 | (strcmp("check_sum", (char *)option->name) != 0)) { |
Antonello Dettori | 904dd30 | 2016-08-18 10:32:27 +0200 | [diff] [blame] | 68 | max_l = max(max_l, strlen((char *)option->name)); |
| 69 | n_opts++; |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 70 | } |
Antonello Dettori | 904dd30 | 2016-08-18 10:32:27 +0200 | [diff] [blame] | 71 | |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 72 | option = next_cmos_entry(option); |
| 73 | } |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 74 | |
Antonello Dettori | 904dd30 | 2016-08-18 10:32:27 +0200 | [diff] [blame] | 75 | if (n_opts == 0) { |
| 76 | printf("NO CMOS OPTIONS FOUND. EXITING!!!"); |
| 77 | return -1; |
| 78 | } |
| 79 | |
| 80 | *numopts = n_opts; |
| 81 | *maxlength = max_l; |
| 82 | |
| 83 | return 0; |
| 84 | |
| 85 | } |
| 86 | |
| 87 | /* walk over options, fetch details */ |
| 88 | static void cmos_walk_options(struct cb_cmos_option_table *opttbl, |
| 89 | FIELD **fields, int numopts, int maxlength) |
| 90 | { |
| 91 | struct cb_cmos_entries *option = first_cmos_entry(opttbl); |
Paul Menzel | e7385d1 | 2017-01-20 23:29:21 +0100 | [diff] [blame] | 92 | int i; |
Antonello Dettori | 904dd30 | 2016-08-18 10:32:27 +0200 | [diff] [blame] | 93 | |
Paul Menzel | e7385d1 | 2017-01-20 23:29:21 +0100 | [diff] [blame] | 94 | for (i = 0; i < numopts; i++) { |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 95 | while ((option->config == 'r') || |
Martin Roth | 0cf7acc | 2016-04-26 12:33:44 -0600 | [diff] [blame] | 96 | (strcmp("check_sum", (char *)option->name) == 0)) { |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 97 | option = next_cmos_entry(option); |
| 98 | } |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 99 | fields[2 * i] = |
Martin Roth | 0cf7acc | 2016-04-26 12:33:44 -0600 | [diff] [blame] | 100 | new_field(1, strlen((char *)option->name), i * 2, 1, 0, 0); |
| 101 | set_field_buffer(fields[2 * i], 0, (char *)option->name); |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 102 | field_opts_off(fields[2 * i], O_ACTIVE); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 103 | |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 104 | fields[2 * i + 1] = |
| 105 | new_field(1, 40, i * 2, maxlength + 2, 0, 0); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 106 | char *buf = NULL; |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 107 | int fail = |
Martin Roth | 0cf7acc | 2016-04-26 12:33:44 -0600 | [diff] [blame] | 108 | get_option_as_string(use_nvram, opttbl, &buf, (char *)option->name); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 109 | switch (option->config) { |
| 110 | case 'h': { |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 111 | set_field_type(fields[2 * i + 1], TYPE_INTEGER, 0, 0, |
| 112 | (1 << option->length) - 1); |
| 113 | field_opts_on(fields[2 * i + 1], O_BLANK); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 114 | break; |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 115 | } |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 116 | case 's': { |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 117 | set_max_field(fields[2 * i + 1], option->length / 8); |
| 118 | field_opts_off(fields[2 * i + 1], O_STATIC); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 119 | break; |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 120 | } |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 121 | case 'e': { |
| 122 | int numvals = 0; |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 123 | struct cb_cmos_enums *cmos_enum = |
| 124 | first_cmos_enum_of_id(opttbl, option->config_id); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 125 | |
| 126 | /* if invalid data in CMOS, set buf to first enum */ |
| 127 | if (fail && cmos_enum) { |
Martin Roth | 0cf7acc | 2016-04-26 12:33:44 -0600 | [diff] [blame] | 128 | buf = (char *)cmos_enum->text; |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 129 | } |
| 130 | |
| 131 | while (cmos_enum) { |
| 132 | numvals++; |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 133 | cmos_enum = next_cmos_enum_of_id( |
| 134 | cmos_enum, option->config_id); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 135 | } |
| 136 | |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 137 | char **values = malloc(sizeof(char *) * (numvals + 1)); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 138 | int cnt = 0; |
| 139 | |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 140 | cmos_enum = |
| 141 | first_cmos_enum_of_id(opttbl, option->config_id); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 142 | while (cmos_enum) { |
Martin Roth | 0cf7acc | 2016-04-26 12:33:44 -0600 | [diff] [blame] | 143 | values[cnt] = (char *)cmos_enum->text; |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 144 | cnt++; |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 145 | cmos_enum = next_cmos_enum_of_id( |
| 146 | cmos_enum, option->config_id); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 147 | } |
| 148 | values[cnt] = NULL; |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 149 | field_opts_off(fields[2 * i + 1], O_EDIT); |
| 150 | set_field_type(fields[2 * i + 1], TYPE_ENUM, values, 1, |
| 151 | 1); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 152 | free(values); // copied by set_field_type |
| 153 | break; |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 154 | } |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 155 | default: |
| 156 | break; |
| 157 | } |
| 158 | if (buf) |
| 159 | set_field_buffer(fields[2 * i + 1], 0, buf); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 160 | #if HOSTED |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 161 | // underline is non-trivial on VGA text |
| 162 | set_field_back(fields[2 * i + 1], A_UNDERLINE); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 163 | #endif |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 164 | field_opts_off(fields[2 * i + 1], |
| 165 | O_BLANK | O_AUTOSKIP | O_NULLOK); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 166 | |
| 167 | option = next_cmos_entry(option); |
| 168 | } |
Antonello Dettori | 904dd30 | 2016-08-18 10:32:27 +0200 | [diff] [blame] | 169 | |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 170 | fields[2 * numopts] = NULL; |
Antonello Dettori | 904dd30 | 2016-08-18 10:32:27 +0200 | [diff] [blame] | 171 | } |
| 172 | |
| 173 | int main(void) |
| 174 | { |
| 175 | int ch, done; |
Paul Menzel | e7385d1 | 2017-01-20 23:29:21 +0100 | [diff] [blame] | 176 | int i; |
Antonello Dettori | 904dd30 | 2016-08-18 10:32:27 +0200 | [diff] [blame] | 177 | |
Julius Werner | eab2a29 | 2019-03-05 16:55:15 -0800 | [diff] [blame] | 178 | if (CONFIG(LP_USB)) |
Paul Menzel | afbc2c9 | 2017-03-13 17:56:17 +0100 | [diff] [blame] | 179 | usb_initialize(); |
Nicola Corna | fece39b | 2017-03-10 17:34:03 +0100 | [diff] [blame] | 180 | |
Antonello Dettori | 904dd30 | 2016-08-18 10:32:27 +0200 | [diff] [blame] | 181 | /* coreboot data structures */ |
| 182 | lib_get_sysinfo(); |
| 183 | |
| 184 | struct cb_cmos_option_table *opttbl = get_system_option_table(); |
| 185 | |
Antonello Dettori | 079feec | 2016-08-18 10:32:27 +0200 | [diff] [blame] | 186 | if (opttbl == NULL) { |
| 187 | printf("Could not find coreboot option table.\n"); |
Antonello Dettori | 904dd30 | 2016-08-18 10:32:27 +0200 | [diff] [blame] | 188 | halt(); |
| 189 | } |
| 190 | |
| 191 | /* prep CMOS layout into libcurses data structures */ |
| 192 | |
| 193 | struct cb_cmos_entries *option = first_cmos_entry(opttbl); |
| 194 | int numopts = 0; |
| 195 | int maxlength = 0; |
| 196 | |
| 197 | count_cmos_options(option, &numopts, &maxlength); |
| 198 | |
| 199 | FIELD **fields = malloc(sizeof(FIELD *) * (2 * numopts + 1)); |
| 200 | |
| 201 | cmos_walk_options(opttbl, fields, numopts, maxlength); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 202 | |
Lubomir Rintel | 1ecc8af | 2015-02-24 20:33:35 +0100 | [diff] [blame] | 203 | /* display initialization */ |
| 204 | initscr(); |
| 205 | keypad(stdscr, TRUE); |
| 206 | cbreak(); |
| 207 | noecho(); |
| 208 | |
| 209 | if (start_color()) { |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 210 | assume_default_colors(COLOR_BLUE, COLOR_CYAN); |
Lubomir Rintel | 1ecc8af | 2015-02-24 20:33:35 +0100 | [diff] [blame] | 211 | } |
| 212 | leaveok(stdscr, TRUE); |
| 213 | curs_set(1); |
| 214 | |
| 215 | erase(); |
| 216 | box(stdscr, 0, 0); |
| 217 | mvaddstr(0, 2, "coreboot configuration utility"); |
| 218 | refresh(); |
| 219 | |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 220 | FORM *form = new_form(fields); |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 221 | int numlines = min(numopts * 2, 16); |
| 222 | WINDOW *w = newwin(numlines + 2, 70, 2, 1); |
| 223 | WINDOW *inner_w = newpad(numopts * 2, 68); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 224 | box(w, 0, 0); |
| 225 | mvwaddstr(w, 0, 2, "Press F1 when done"); |
| 226 | set_form_win(form, w); |
| 227 | set_form_sub(form, inner_w); |
| 228 | post_form(form); |
| 229 | |
| 230 | done = 0; |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 231 | while (!done) { |
Lubomir Rintel | 68009e9 | 2015-02-01 15:24:43 +0100 | [diff] [blame] | 232 | render_form(form); |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 233 | ch = getch(); |
| 234 | if (ch == ERR) |
| 235 | continue; |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 236 | switch (ch) { |
| 237 | case KEY_DOWN: |
| 238 | form_driver(form, REQ_NEXT_FIELD); |
| 239 | break; |
| 240 | case KEY_UP: |
| 241 | form_driver(form, REQ_PREV_FIELD); |
| 242 | break; |
| 243 | case KEY_LEFT: |
| 244 | if (field_type(current_field(form)) == TYPE_ENUM) { |
| 245 | form_driver(form, REQ_PREV_CHOICE); |
| 246 | } else { |
| 247 | form_driver(form, REQ_LEFT_CHAR); |
| 248 | } |
| 249 | break; |
| 250 | case KEY_RIGHT: |
| 251 | if (field_type(current_field(form)) == TYPE_ENUM) { |
| 252 | form_driver(form, REQ_NEXT_CHOICE); |
| 253 | } else { |
| 254 | form_driver(form, REQ_RIGHT_CHAR); |
| 255 | } |
| 256 | break; |
| 257 | case KEY_BACKSPACE: |
| 258 | case '\b': |
| 259 | form_driver(form, REQ_DEL_PREV); |
| 260 | break; |
| 261 | case KEY_DC: |
| 262 | form_driver(form, REQ_DEL_CHAR); |
| 263 | break; |
| 264 | case KEY_F(1): |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 265 | done = 1; |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 266 | break; |
| 267 | default: |
| 268 | form_driver(form, ch); |
| 269 | break; |
| 270 | } |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 271 | } |
| 272 | |
Lubomir Rintel | 1ecc8af | 2015-02-24 20:33:35 +0100 | [diff] [blame] | 273 | endwin(); |
| 274 | |
Paul Menzel | e7385d1 | 2017-01-20 23:29:21 +0100 | [diff] [blame] | 275 | for (i = 0; i < numopts; i++) { |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 276 | char *name = field_buffer(fields[2 * i], 0); |
| 277 | char *value = field_buffer(fields[2 * i + 1], 0); |
Vladimir Serbinenko | c9babb2 | 2014-01-15 22:07:52 +0100 | [diff] [blame] | 278 | char *ptr; |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 279 | for (ptr = value + strlen(value) - 1; |
| 280 | ptr >= value && *ptr == ' '; ptr--) |
| 281 | ; |
Vladimir Serbinenko | c9babb2 | 2014-01-15 22:07:52 +0100 | [diff] [blame] | 282 | ptr[1] = '\0'; |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 283 | set_option_from_string(use_nvram, opttbl, value, name); |
| 284 | } |
| 285 | |
| 286 | unpost_form(form); |
| 287 | free_form(form); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 288 | |
Vladimir Serbinenko | c728288 | 2014-01-15 22:09:25 +0100 | [diff] [blame] | 289 | /* reboot */ |
Martin Roth | f62065f | 2016-04-23 17:24:57 -0600 | [diff] [blame] | 290 | outb(0x6, 0xcf9); |
Patrick Georgi | 4b62ebe | 2012-11-16 15:05:11 +0100 | [diff] [blame] | 291 | halt(); |
| 292 | } |