lib/efi_loader/efi_console.c

   1 /*
   2  *  EFI application console interface
   3  *
   4  *  Copyright (c) 2016 Alexander Graf
   5  *
   6  *  SPDX-License-Identifier:     GPL-2.0+
   7  */
   8
   9 #include <common.h>
  10 #include <charset.h>
  11 #include <dm/device.h>
  12 #include <efi_loader.h>
  13 #include <stdio_dev.h>
  14 #include <video_console.h>
  15
  16 static bool console_size_queried;
  17
  18 #define EFI_COUT_MODE_2 2
  19 #define EFI_MAX_COUT_MODE 3
  20
  21 struct cout_mode {
  22         unsigned long columns;
  23         unsigned long rows;
  24         int present;
  25 };
  26
  27 static struct cout_mode efi_cout_modes[] = {
  28         /* EFI Mode 0 is 80x25 and always present */
  29         {
  30                 .columns = 80,
  31                 .rows = 25,
  32                 .present = 1,
  33         },
  34         /* EFI Mode 1 is always 80x50 */
  35         {
  36                 .columns = 80,
  37                 .rows = 50,
  38                 .present = 0,
  39         },
  40         /* Value are unknown until we query the console */
  41         {
  42                 .columns = 0,
  43                 .rows = 0,
  44                 .present = 0,
  45         },
  46 };
  47
  48 const efi_guid_t efi_guid_console_control = CONSOLE_CONTROL_GUID;
  49
  50 #define cESC '\x1b'
  51 #define ESC "\x1b"
  52
  53 static efi_status_t EFIAPI efi_cin_get_mode(
  54                         struct efi_console_control_protocol *this,
  55                         int *mode, char *uga_exists, char *std_in_locked)
  56 {
  57         EFI_ENTRY("%p, %p, %p, %p", this, mode, uga_exists, std_in_locked);
  58
  59         if (mode)
  60                 *mode = EFI_CONSOLE_MODE_TEXT;
  61         if (uga_exists)
  62                 *uga_exists = 0;
  63         if (std_in_locked)
  64                 *std_in_locked = 0;
  65
  66         return EFI_EXIT(EFI_SUCCESS);
  67 }
  68
  69 static efi_status_t EFIAPI efi_cin_set_mode(
  70                         struct efi_console_control_protocol *this, int mode)
  71 {
  72         EFI_ENTRY("%p, %d", this, mode);
  73         return EFI_EXIT(EFI_UNSUPPORTED);
  74 }
  75
  76 static efi_status_t EFIAPI efi_cin_lock_std_in(
  77                         struct efi_console_control_protocol *this,
  78                         uint16_t *password)
  79 {
  80         EFI_ENTRY("%p, %p", this, password);
  81         return EFI_EXIT(EFI_UNSUPPORTED);
  82 }
  83
  84 const struct efi_console_control_protocol efi_console_control = {
  85         .get_mode = efi_cin_get_mode,
  86         .set_mode = efi_cin_set_mode,
  87         .lock_std_in = efi_cin_lock_std_in,
  88 };
  89
  90 /* Default to mode 0 */
  91 static struct simple_text_output_mode efi_con_mode = {
  92         .max_mode = 1,
  93         .mode = 0,
  94         .attribute = 0,
  95         .cursor_column = 0,
  96         .cursor_row = 0,
  97         .cursor_visible = 1,
  98 };
  99
 100 static int term_read_reply(int *n, int maxnum, char end_char)
 101 {
 102         char c;
 103         int i = 0;
 104
 105         c = getc();
 106         if (c != cESC)
 107                 return -1;
 108         c = getc();
 109         if (c != '[')
 110                 return -1;
 111
 112         n[0] = 0;
 113         while (1) {
 114                 c = getc();
 115                 if (c == ';') {
 116                         i++;
 117                         if (i >= maxnum)
 118                                 return -1;
 119                         n[i] = 0;
 120                         continue;
 121                 } else if (c == end_char) {
 122                         break;
 123                 } else if (c > '9' || c < '0') {
 124                         return -1;
 125                 }
 126
 127                 /* Read one more decimal position */
 128                 n[i] *= 10;
 129                 n[i] += c - '0';
 130         }
 131
 132         return 0;
 133 }
 134
 135 static efi_status_t EFIAPI efi_cout_reset(
 136                         struct efi_simple_text_output_protocol *this,
 137                         char extended_verification)
 138 {
 139         EFI_ENTRY("%p, %d", this, extended_verification);
 140         return EFI_EXIT(EFI_UNSUPPORTED);
 141 }
 142
 143 static efi_status_t EFIAPI efi_cout_output_string(
 144                         struct efi_simple_text_output_protocol *this,
 145                         const efi_string_t string)
 146 {
 147         struct simple_text_output_mode *con = &efi_con_mode;
 148         struct cout_mode *mode = &efi_cout_modes[con->mode];
 149
 150         EFI_ENTRY("%p, %p", this, string);
 151
 152         unsigned int n16 = utf16_strlen(string);
 153         char buf[MAX_UTF8_PER_UTF16 * n16 + 1];
 154         char *p;
 155
 156         *utf16_to_utf8((u8 *)buf, string, n16) = '\0';
 157
 158         fputs(stdout, buf);
 159
 160         for (p = buf; *p; p++) {
 161                 switch (*p) {
 162                 case '\r':   /* carriage-return */
 163                         con->cursor_column = 0;
 164                         break;
 165                 case '\n':   /* newline */
 166                         con->cursor_column = 0;
 167                         con->cursor_row++;
 168                         break;
 169                 case '\t':   /* tab, assume 8 char align */
 170                         break;
 171                 case '\b':   /* backspace */
 172                         con->cursor_column = max(0, con->cursor_column - 1);
 173                         break;
 174                 default:
 175                         con->cursor_column++;
 176                         break;
 177                 }
 178                 if (con->cursor_column >= mode->columns) {
 179                         con->cursor_column = 0;
 180                         con->cursor_row++;
 181                 }
 182                 con->cursor_row = min(con->cursor_row, (s32)mode->rows - 1);
 183         }
 184
 185         return EFI_EXIT(EFI_SUCCESS);
 186 }
 187
 188 static efi_status_t EFIAPI efi_cout_test_string(
 189                         struct efi_simple_text_output_protocol *this,
 190                         const efi_string_t string)
 191 {
 192         EFI_ENTRY("%p, %p", this, string);
 193         return EFI_EXIT(EFI_SUCCESS);
 194 }
 195
 196 static bool cout_mode_matches(struct cout_mode *mode, int rows, int cols)
 197 {
 198         if (!mode->present)
 199                 return false;
 200
 201         return (mode->rows == rows) && (mode->columns == cols);
 202 }
 203
 204 static int query_console_serial(int *rows, int *cols)
 205 {
 206         /* Ask the terminal about its size */
 207         int n[3];
 208         u64 timeout;
 209
 210         /* Empty input buffer */
 211         while (tstc())
 212                 getc();
 213
 214         printf(ESC"[18t");
 215
 216         /* Check if we have a terminal that understands */
 217         timeout = timer_get_us() + 1000000;
 218         while (!tstc())
 219                 if (timer_get_us() > timeout)
 220                         return -1;
 221
 222         /* Read {depth,rows,cols} */
 223         if (term_read_reply(n, 3, 't'))
 224                 return -1;
 225
 226         *cols = n[2];
 227         *rows = n[1];
 228
 229         return 0;
 230 }
 231
 232 static efi_status_t EFIAPI efi_cout_query_mode(
 233                         struct efi_simple_text_output_protocol *this,
 234                         unsigned long mode_number, unsigned long *columns,
 235                         unsigned long *rows)
 236 {
 237         EFI_ENTRY("%p, %ld, %p, %p", this, mode_number, columns, rows);
 238
 239         if (!console_size_queried) {
 240                 const char *stdout_name = env_get("stdout");
 241                 int rows, cols;
 242
 243                 console_size_queried = true;
 244
 245                 if (stdout_name && !strcmp(stdout_name, "vidconsole") &&
 246                     IS_ENABLED(CONFIG_DM_VIDEO)) {
 247                         struct stdio_dev *stdout_dev =
 248                                 stdio_get_by_name("vidconsole");
 249                         struct udevice *dev = stdout_dev->priv;
 250                         struct vidconsole_priv *priv =
 251                                 dev_get_uclass_priv(dev);
 252                         rows = priv->rows;
 253                         cols = priv->cols;
 254                 } else if (query_console_serial(&rows, &cols)) {
 255                         goto out;
 256                 }
 257
 258                 /* Test if we can have Mode 1 */
 259                 if (cols >= 80 && rows >= 50) {
 260                         efi_cout_modes[1].present = 1;
 261                         efi_con_mode.max_mode = 2;
 262                 }
 263
 264                 /*
 265                  * Install our mode as mode 2 if it is different
 266                  * than mode 0 or 1 and set it  as the currently selected mode
 267                  */
 268                 if (!cout_mode_matches(&efi_cout_modes[0], rows, cols) &&
 269                     !cout_mode_matches(&efi_cout_modes[1], rows, cols)) {
 270                         efi_cout_modes[EFI_COUT_MODE_2].columns = cols;
 271                         efi_cout_modes[EFI_COUT_MODE_2].rows = rows;
 272                         efi_cout_modes[EFI_COUT_MODE_2].present = 1;
 273                         efi_con_mode.max_mode = EFI_MAX_COUT_MODE;
 274                         efi_con_mode.mode = EFI_COUT_MODE_2;
 275                 }
 276         }
 277
 278         if (mode_number >= efi_con_mode.max_mode)
 279                 return EFI_EXIT(EFI_UNSUPPORTED);
 280
 281         if (efi_cout_modes[mode_number].present != 1)
 282                 return EFI_EXIT(EFI_UNSUPPORTED);
 283
 284 out:
 285         if (columns)
 286                 *columns = efi_cout_modes[mode_number].columns;
 287         if (rows)
 288                 *rows = efi_cout_modes[mode_number].rows;
 289
 290         return EFI_EXIT(EFI_SUCCESS);
 291 }
 292
 293 static efi_status_t EFIAPI efi_cout_set_mode(
 294                         struct efi_simple_text_output_protocol *this,
 295                         unsigned long mode_number)
 296 {
 297         EFI_ENTRY("%p, %ld", this, mode_number);
 298
 299
 300         if (mode_number > efi_con_mode.max_mode)
 301                 return EFI_EXIT(EFI_UNSUPPORTED);
 302
 303         efi_con_mode.mode = mode_number;
 304         efi_con_mode.cursor_column = 0;
 305         efi_con_mode.cursor_row = 0;
 306
 307         return EFI_EXIT(EFI_SUCCESS);
 308 }
 309
 310 static efi_status_t EFIAPI efi_cout_set_attribute(
 311                         struct efi_simple_text_output_protocol *this,
 312                         unsigned long attribute)
 313 {
 314         EFI_ENTRY("%p, %lx", this, attribute);
 315
 316         /* Just ignore attributes (colors) for now */
 317         return EFI_EXIT(EFI_UNSUPPORTED);
 318 }
 319
 320 static efi_status_t EFIAPI efi_cout_clear_screen(
 321                         struct efi_simple_text_output_protocol *this)
 322 {
 323         EFI_ENTRY("%p", this);
 324
 325         printf(ESC"[2J");
 326
 327         return EFI_EXIT(EFI_SUCCESS);
 328 }
 329
 330 static efi_status_t EFIAPI efi_cout_set_cursor_position(
 331                         struct efi_simple_text_output_protocol *this,
 332                         unsigned long column, unsigned long row)
 333 {
 334         EFI_ENTRY("%p, %ld, %ld", this, column, row);
 335
 336         printf(ESC"[%d;%df", (int)row, (int)column);
 337         efi_con_mode.cursor_column = column;
 338         efi_con_mode.cursor_row = row;
 339
 340         return EFI_EXIT(EFI_SUCCESS);
 341 }
 342
 343 static efi_status_t EFIAPI efi_cout_enable_cursor(
 344                         struct efi_simple_text_output_protocol *this,
 345                         bool enable)
 346 {
 347         EFI_ENTRY("%p, %d", this, enable);
 348
 349         printf(ESC"[?25%c", enable ? 'h' : 'l');
 350
 351         return EFI_EXIT(EFI_SUCCESS);
 352 }
 353
 354 const struct efi_simple_text_output_protocol efi_con_out = {
 355         .reset = efi_cout_reset,
 356         .output_string = efi_cout_output_string,
 357         .test_string = efi_cout_test_string,
 358         .query_mode = efi_cout_query_mode,
 359         .set_mode = efi_cout_set_mode,
 360         .set_attribute = efi_cout_set_attribute,
 361         .clear_screen = efi_cout_clear_screen,
 362         .set_cursor_position = efi_cout_set_cursor_position,
 363         .enable_cursor = efi_cout_enable_cursor,
 364         .mode = (void*)&efi_con_mode,
 365 };
 366
 367 static efi_status_t EFIAPI efi_cin_reset(
 368                         struct efi_simple_input_interface *this,
 369                         bool extended_verification)
 370 {
 371         EFI_ENTRY("%p, %d", this, extended_verification);
 372         return EFI_EXIT(EFI_UNSUPPORTED);
 373 }
 374
 375 static efi_status_t EFIAPI efi_cin_read_key_stroke(
 376                         struct efi_simple_input_interface *this,
 377                         struct efi_input_key *key)
 378 {
 379         struct efi_input_key pressed_key = {
 380                 .scan_code = 0,
 381                 .unicode_char = 0,
 382         };
 383         char ch;
 384
 385         EFI_ENTRY("%p, %p", this, key);
 386
 387         /* We don't do interrupts, so check for timers cooperatively */
 388         efi_timer_check();
 389
 390         if (!tstc()) {
 391                 /* No key pressed */
 392                 return EFI_EXIT(EFI_NOT_READY);
 393         }
 394
 395         ch = getc();
 396         if (ch == cESC) {
 397                 /* Escape Sequence */
 398                 ch = getc();
 399                 switch (ch) {
 400                 case cESC: /* ESC */
 401                         pressed_key.scan_code = 23;
 402                         break;
 403                 case 'O': /* F1 - F4 */
 404                         pressed_key.scan_code = getc() - 'P' + 11;
 405                         break;
 406                 case 'a'...'z':
 407                         ch = ch - 'a';
 408                         break;
 409                 case '[':
 410                         ch = getc();
 411                         switch (ch) {
 412                         case 'A'...'D': /* up, down right, left */
 413                                 pressed_key.scan_code = ch - 'A' + 1;
 414                                 break;
 415                         case 'F': /* End */
 416                                 pressed_key.scan_code = 6;
 417                                 break;
 418                         case 'H': /* Home */
 419                                 pressed_key.scan_code = 5;
 420                                 break;
 421                         case '1': /* F5 - F8 */
 422                                 pressed_key.scan_code = getc() - '0' + 11;
 423                                 getc();
 424                                 break;
 425                         case '2': /* F9 - F12 */
 426                                 pressed_key.scan_code = getc() - '0' + 19;
 427                                 getc();
 428                                 break;
 429                         case '3': /* DEL */
 430                                 pressed_key.scan_code = 8;
 431                                 getc();
 432                                 break;
 433                         }
 434                         break;
 435                 }
 436         } else if (ch == 0x7f) {
 437                 /* Backspace */
 438                 ch = 0x08;
 439         }
 440         pressed_key.unicode_char = ch;
 441         *key = pressed_key;
 442
 443         return EFI_EXIT(EFI_SUCCESS);
 444 }
 445
 446 struct efi_simple_input_interface efi_con_in = {
 447         .reset = efi_cin_reset,
 448         .read_key_stroke = efi_cin_read_key_stroke,
 449         .wait_for_key = NULL,
 450 };
 451
 452 static struct efi_event *console_timer_event;
 453
 454 static void EFIAPI efi_key_notify(struct efi_event *event, void *context)
 455 {
 456 }
 457
 458 static void EFIAPI efi_console_timer_notify(struct efi_event *event,
 459                                             void *context)
 460 {
 461         EFI_ENTRY("%p, %p", event, context);
 462         if (tstc()) {
 463                 efi_con_in.wait_for_key->is_signaled = true;
 464                 efi_signal_event(efi_con_in.wait_for_key);
 465                 }
 466         EFI_EXIT(EFI_SUCCESS);
 467 }
 468
 469
 470 static struct efi_object efi_console_control_obj =
 471         EFI_PROTOCOL_OBJECT(efi_guid_console_control, &efi_console_control);
 472 static struct efi_object efi_console_output_obj =
 473         EFI_PROTOCOL_OBJECT(EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID, &efi_con_out);
 474 static struct efi_object efi_console_input_obj =
 475         EFI_PROTOCOL_OBJECT(EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID, &efi_con_in);
 476
 477 /* This gets called from do_bootefi_exec(). */
 478 int efi_console_register(void)
 479 {
 480         efi_status_t r;
 481
 482         /* Hook up to the device list */
 483         list_add_tail(&efi_console_control_obj.link, &efi_obj_list);
 484         list_add_tail(&efi_console_output_obj.link, &efi_obj_list);
 485         list_add_tail(&efi_console_input_obj.link, &efi_obj_list);
 486
 487         r = efi_create_event(EVT_NOTIFY_WAIT, TPL_CALLBACK,
 488                              efi_key_notify, NULL, &efi_con_in.wait_for_key);
 489         if (r != EFI_SUCCESS) {
 490                 printf("ERROR: Failed to register WaitForKey event\n");
 491                 return r;
 492         }
 493         r = efi_create_event(EVT_TIMER | EVT_NOTIFY_SIGNAL, TPL_CALLBACK,
 494                              efi_console_timer_notify, NULL,
 495                              &console_timer_event);
 496         if (r != EFI_SUCCESS) {
 497                 printf("ERROR: Failed to register console event\n");
 498                 return r;
 499         }
 500         /* 5000 ns cycle is sufficient for 2 MBaud */
 501         r = efi_set_timer(console_timer_event, EFI_TIMER_PERIODIC, 50);
 502         if (r != EFI_SUCCESS)
 503                 printf("ERROR: Failed to set console timer\n");
 504         return r;
 505 }