stand/efi/libefi/efi_console.c

   1 /*-
   2  * Copyright (c) 2000 Doug Rabson
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <efi.h>
  31 #include <efilib.h>
  32
  33 #include "bootstrap.h"
  34
  35 static SIMPLE_TEXT_OUTPUT_INTERFACE     *conout;
  36 static SIMPLE_INPUT_INTERFACE           *conin;
  37
  38 #ifdef TERM_EMU
  39 #define DEFAULT_FGCOLOR EFI_LIGHTGRAY
  40 #define DEFAULT_BGCOLOR EFI_BLACK
  41
  42 #define MAXARGS 8
  43 static int args[MAXARGS], argc;
  44 static int fg_c, bg_c, curx, cury;
  45 static int esc;
  46
  47 void get_pos(int *x, int *y);
  48 void curs_move(int *_x, int *_y, int x, int y);
  49 static void CL(int);
  50 void HO(void);
  51 void end_term(void);
  52 #endif
  53
  54 #define KEYBUFSZ 10
  55 static unsigned keybuf[KEYBUFSZ];       /* keybuf for extended codes */
  56 static int key_pending;
  57
  58 static void efi_cons_probe(struct console *);
  59 static int efi_cons_init(int);
  60 void efi_cons_putchar(int);
  61 int efi_cons_getchar(void);
  62 void efi_cons_efiputchar(int);
  63 int efi_cons_poll(void);
  64
  65 struct console efi_console = {
  66         "efi",
  67         "EFI console",
  68         C_WIDEOUT,
  69         efi_cons_probe,
  70         efi_cons_init,
  71         efi_cons_putchar,
  72         efi_cons_getchar,
  73         efi_cons_poll
  74 };
  75
  76 #ifdef TERM_EMU
  77
  78 /* Get cursor position. */
  79 void
  80 get_pos(int *x, int *y)
  81 {
  82         *x = conout->Mode->CursorColumn;
  83         *y = conout->Mode->CursorRow;
  84 }
  85
  86 /* Move cursor to x rows and y cols (0-based). */
  87 void
  88 curs_move(int *_x, int *_y, int x, int y)
  89 {
  90         conout->SetCursorPosition(conout, x, y);
  91         if (_x != NULL)
  92                 *_x = conout->Mode->CursorColumn;
  93         if (_y != NULL)
  94                 *_y = conout->Mode->CursorRow;
  95 }
  96
  97 /* Clear internal state of the terminal emulation code. */
  98 void
  99 end_term(void)
 100 {
 101         esc = 0;
 102         argc = -1;
 103 }
 104
 105 #endif
 106
 107 static void
 108 efi_cons_probe(struct console *cp)
 109 {
 110         conout = ST->ConOut;
 111         conin = ST->ConIn;
 112         cp->c_flags |= C_PRESENTIN | C_PRESENTOUT;
 113 }
 114
 115 static int
 116 efi_cons_init(int arg)
 117 {
 118 #ifdef TERM_EMU
 119         conout->SetAttribute(conout, EFI_TEXT_ATTR(DEFAULT_FGCOLOR,
 120             DEFAULT_BGCOLOR));
 121         end_term();
 122         get_pos(&curx, &cury);
 123         curs_move(&curx, &cury, curx, cury);
 124         fg_c = DEFAULT_FGCOLOR;
 125         bg_c = DEFAULT_BGCOLOR;
 126 #endif
 127         conout->EnableCursor(conout, TRUE);
 128         return 0;
 129 }
 130
 131 static void
 132 efi_cons_rawputchar(int c)
 133 {
 134         int i;
 135         UINTN x, y;
 136         conout->QueryMode(conout, conout->Mode->Mode, &x, &y);
 137
 138         if (c == '\t')
 139                 /* XXX lame tab expansion */
 140                 for (i = 0; i < 8; i++)
 141                         efi_cons_rawputchar(' ');
 142         else {
 143 #ifndef TERM_EMU
 144                 if (c == '\n')
 145                         efi_cons_efiputchar('\r');
 146                 efi_cons_efiputchar(c);
 147 #else
 148                 switch (c) {
 149                 case '\r':
 150                         curx = 0;
 151                         efi_cons_efiputchar('\r');
 152                         return;
 153                 case '\n':
 154                         efi_cons_efiputchar('\n');
 155                         efi_cons_efiputchar('\r');
 156                         cury++;
 157                         if (cury >= y)
 158                                 cury--;
 159                         curx = 0;
 160                         return;
 161                 case '\b':
 162                         if (curx > 0) {
 163                                 efi_cons_efiputchar('\b');
 164                                 curx--;
 165                         }
 166                         return;
 167                 default:
 168                         efi_cons_efiputchar(c);
 169                         curx++;
 170                         if (curx > x-1) {
 171                                 curx = 0;
 172                                 cury++;
 173                         }
 174                         if (cury > y-1) {
 175                                 curx = 0;
 176                                 cury--;
 177                         }
 178                 }
 179 #endif
 180         }
 181 }
 182
 183 #ifdef TERM_EMU
 184 /* Gracefully exit ESC-sequence processing in case of misunderstanding. */
 185 static void
 186 bail_out(int c)
 187 {
 188         char buf[16], *ch;
 189         int i;
 190
 191         if (esc) {
 192                 efi_cons_rawputchar('\033');
 193                 if (esc != '\033')
 194                         efi_cons_rawputchar(esc);
 195                 for (i = 0; i <= argc; ++i) {
 196                         sprintf(buf, "%d", args[i]);
 197                         ch = buf;
 198                         while (*ch)
 199                                 efi_cons_rawputchar(*ch++);
 200                 }
 201         }
 202         efi_cons_rawputchar(c);
 203         end_term();
 204 }
 205
 206 /* Clear display from current position to end of screen. */
 207 static void
 208 CD(void) {
 209         int i;
 210         UINTN x, y;
 211
 212         get_pos(&curx, &cury);
 213         if (curx == 0 && cury == 0) {
 214                 conout->ClearScreen(conout);
 215                 end_term();
 216                 return;
 217         }
 218
 219         conout->QueryMode(conout, conout->Mode->Mode, &x, &y);
 220         CL(0);  /* clear current line from cursor to end */
 221         for (i = cury + 1; i < y-1; i++) {
 222                 curs_move(NULL, NULL, 0, i);
 223                 CL(0);
 224         }
 225         curs_move(NULL, NULL, curx, cury);
 226         end_term();
 227 }
 228
 229 /*
 230  * Absolute cursor move to args[0] rows and args[1] columns
 231  * (the coordinates are 1-based).
 232  */
 233 static void
 234 CM(void)
 235 {
 236         if (args[0] > 0)
 237                 args[0]--;
 238         if (args[1] > 0)
 239                 args[1]--;
 240         curs_move(&curx, &cury, args[1], args[0]);
 241         end_term();
 242 }
 243
 244 /* Home cursor (left top corner), also called from mode command. */
 245 void
 246 HO(void)
 247 {
 248         argc = 1;
 249         args[0] = args[1] = 1;
 250         CM();
 251 }
 252
 253 /* Clear line from current position to end of line */
 254 static void
 255 CL(int direction)
 256 {
 257         int i, len;
 258         UINTN x, y;
 259         CHAR16 *line;
 260
 261         conout->QueryMode(conout, conout->Mode->Mode, &x, &y);
 262         switch (direction) {
 263         case 0:         /* from cursor to end */
 264                 len = x - curx + 1;
 265                 break;
 266         case 1:         /* from beginning to cursor */
 267                 len = curx;
 268                 break;
 269         case 2:         /* entire line */
 270                 len = x;
 271                 break;
 272         default:        /* NOTREACHED */
 273                 __unreachable();
 274         }
 275
 276         if (cury == y - 1)
 277                 len--;
 278
 279         line = malloc(len * sizeof (CHAR16));
 280         if (line == NULL) {
 281                 printf("out of memory\n");
 282                 return;
 283         }
 284         for (i = 0; i < len; i++)
 285                 line[i] = ' ';
 286         line[len-1] = 0;
 287
 288         if (direction != 0)
 289                 curs_move(NULL, NULL, 0, cury);
 290
 291         conout->OutputString(conout, line);
 292         /* restore cursor position */
 293         curs_move(NULL, NULL, curx, cury);
 294         free(line);
 295         end_term();
 296 }
 297
 298 static void
 299 get_arg(int c)
 300 {
 301         if (argc < 0)
 302                 argc = 0;
 303         args[argc] *= 10;
 304         args[argc] += c - '0';
 305 }
 306
 307 /* Emulate basic capabilities of cons25 terminal */
 308 static void
 309 efi_term_emu(int c)
 310 {
 311         static int ansi_col[] = {
 312                 0, 4, 2, 6, 1, 5, 3, 7
 313         };
 314         int t, i;
 315
 316         switch (esc) {
 317         case 0:
 318                 switch (c) {
 319                 case '\033':
 320                         esc = c;
 321                         break;
 322                 default:
 323                         efi_cons_rawputchar(c);
 324                         break;
 325                 }
 326                 break;
 327         case '\033':
 328                 switch (c) {
 329                 case '[':
 330                         esc = c;
 331                         args[0] = 0;
 332                         argc = -1;
 333                         break;
 334                 default:
 335                         bail_out(c);
 336                         break;
 337                 }
 338                 break;
 339         case '[':
 340                 switch (c) {
 341                 case ';':
 342                         if (argc < 0)
 343                                 argc = 0;
 344                         else if (argc + 1 >= MAXARGS)
 345                                 bail_out(c);
 346                         else
 347                                 args[++argc] = 0;
 348                         break;
 349                 case 'H':               /* ho = \E[H */
 350                         if (argc < 0)
 351                                 HO();
 352                         else if (argc == 1)
 353                                 CM();
 354                         else
 355                                 bail_out(c);
 356                         break;
 357                 case 'J':               /* cd = \E[J */
 358                         if (argc < 0)
 359                                 CD();
 360                         else
 361                                 bail_out(c);
 362                         break;
 363                 case 'm':
 364                         if (argc < 0) {
 365                                 fg_c = DEFAULT_FGCOLOR;
 366                                 bg_c = DEFAULT_BGCOLOR;
 367                         }
 368                         for (i = 0; i <= argc; ++i) {
 369                                 switch (args[i]) {
 370                                 case 0:         /* back to normal */
 371                                         fg_c = DEFAULT_FGCOLOR;
 372                                         bg_c = DEFAULT_BGCOLOR;
 373                                         break;
 374                                 case 1:         /* bold */
 375                                         fg_c |= 0x8;
 376                                         break;
 377                                 case 4:         /* underline */
 378                                 case 5:         /* blink */
 379                                         bg_c |= 0x8;
 380                                         break;
 381                                 case 7:         /* reverse */
 382                                         t = fg_c;
 383                                         fg_c = bg_c;
 384                                         bg_c = t;
 385                                         break;
 386                                 case 22:        /* normal intensity */
 387                                         fg_c &= ~0x8;
 388                                         break;
 389                                 case 24:        /* not underline */
 390                                 case 25:        /* not blinking */
 391                                         bg_c &= ~0x8;
 392                                         break;
 393                                 case 30: case 31: case 32: case 33:
 394                                 case 34: case 35: case 36: case 37:
 395                                         fg_c = ansi_col[args[i] - 30];
 396                                         break;
 397                                 case 39:        /* normal */
 398                                         fg_c = DEFAULT_FGCOLOR;
 399                                         break;
 400                                 case 40: case 41: case 42: case 43:
 401                                 case 44: case 45: case 46: case 47:
 402                                         bg_c = ansi_col[args[i] - 40];
 403                                         break;
 404                                 case 49:        /* normal */
 405                                         bg_c = DEFAULT_BGCOLOR;
 406                                         break;
 407                                 }
 408                         }
 409                         conout->SetAttribute(conout, EFI_TEXT_ATTR(fg_c, bg_c));
 410                         end_term();
 411                         break;
 412                 default:
 413                         if (isdigit(c))
 414                                 get_arg(c);
 415                         else
 416                                 bail_out(c);
 417                         break;
 418                 }
 419                 break;
 420         default:
 421                 bail_out(c);
 422                 break;
 423         }
 424 }
 425 #else
 426 void
 427 HO(void)
 428 {
 429 }
 430 #endif
 431
 432 void
 433 efi_cons_putchar(int c)
 434 {
 435 #ifdef TERM_EMU
 436         efi_term_emu(c);
 437 #else
 438         efi_cons_rawputchar(c);
 439 #endif
 440 }
 441
 442 static int
 443 keybuf_getchar(void)
 444 {
 445         int i, c = 0;
 446
 447         for (i = 0; i < KEYBUFSZ; i++) {
 448                 if (keybuf[i] != 0) {
 449                         c = keybuf[i];
 450                         keybuf[i] = 0;
 451                         break;
 452                 }
 453         }
 454
 455         return (c);
 456 }
 457
 458 static bool
 459 keybuf_ischar(void)
 460 {
 461         int i;
 462
 463         for (i = 0; i < KEYBUFSZ; i++) {
 464                 if (keybuf[i] != 0)
 465                         return (true);
 466         }
 467         return (false);
 468 }
 469
 470 /*
 471  * We are not reading input before keybuf is empty, so we are safe
 472  * just to fill keybuf from the beginning.
 473  */
 474 static void
 475 keybuf_inschar(EFI_INPUT_KEY *key)
 476 {
 477
 478         switch (key->ScanCode) {
 479         case 0x1: /* UP */
 480                 keybuf[0] = 0x1b;       /* esc */
 481                 keybuf[1] = '[';
 482                 keybuf[2] = 'A';
 483                 break;
 484         case 0x2: /* DOWN */
 485                 keybuf[0] = 0x1b;       /* esc */
 486                 keybuf[1] = '[';
 487                 keybuf[2] = 'B';
 488                 break;
 489         case 0x3: /* RIGHT */
 490                 keybuf[0] = 0x1b;       /* esc */
 491                 keybuf[1] = '[';
 492                 keybuf[2] = 'C';
 493                 break;
 494         case 0x4: /* LEFT */
 495                 keybuf[0] = 0x1b;       /* esc */
 496                 keybuf[1] = '[';
 497                 keybuf[2] = 'D';
 498                 break;
 499         case 0x17:
 500                 keybuf[0] = 0x1b;       /* esc */
 501                 break;
 502         default:
 503                 keybuf[0] = key->UnicodeChar;
 504                 break;
 505         }
 506 }
 507
 508 static bool
 509 efi_readkey(void)
 510 {
 511         EFI_STATUS status;
 512         EFI_INPUT_KEY key;
 513
 514         status = conin->ReadKeyStroke(conin, &key);
 515         if (status == EFI_SUCCESS) {
 516                 keybuf_inschar(&key);
 517                 return (true);
 518         }
 519         return (false);
 520 }
 521
 522 int
 523 efi_cons_getchar(void)
 524 {
 525         int c;
 526
 527         if ((c = keybuf_getchar()) != 0)
 528                 return (c);
 529
 530         key_pending = 0;
 531
 532         if (efi_readkey())
 533                 return (keybuf_getchar());
 534
 535         return (-1);
 536 }
 537
 538 int
 539 efi_cons_poll(void)
 540 {
 541
 542         if (keybuf_ischar() || key_pending)
 543                 return (1);
 544
 545         /*
 546          * Some EFI implementation (u-boot for example) do not support
 547          * WaitForKey().
 548          * CheckEvent() can clear the signaled state.
 549          */
 550         if (conin->WaitForKey == NULL)
 551                 key_pending = efi_readkey();
 552         else
 553                 key_pending = BS->CheckEvent(conin->WaitForKey) == EFI_SUCCESS;
 554
 555         return (key_pending);
 556 }
 557
 558 /* Plain direct access to EFI OutputString(). */
 559 void
 560 efi_cons_efiputchar(int c)
 561 {
 562         CHAR16 buf[2];
 563
 564         /*
 565          * translate box chars to unicode
 566          */
 567         switch (c) {
 568         /* single frame */
 569         case 0xb3: buf[0] = BOXDRAW_VERTICAL; break;
 570         case 0xbf: buf[0] = BOXDRAW_DOWN_LEFT; break;
 571         case 0xc0: buf[0] = BOXDRAW_UP_RIGHT; break;
 572         case 0xc4: buf[0] = BOXDRAW_HORIZONTAL; break;
 573         case 0xda: buf[0] = BOXDRAW_DOWN_RIGHT; break;
 574         case 0xd9: buf[0] = BOXDRAW_UP_LEFT; break;
 575
 576         /* double frame */
 577         case 0xba: buf[0] = BOXDRAW_DOUBLE_VERTICAL; break;
 578         case 0xbb: buf[0] = BOXDRAW_DOUBLE_DOWN_LEFT; break;
 579         case 0xbc: buf[0] = BOXDRAW_DOUBLE_UP_LEFT; break;
 580         case 0xc8: buf[0] = BOXDRAW_DOUBLE_UP_RIGHT; break;
 581         case 0xc9: buf[0] = BOXDRAW_DOUBLE_DOWN_RIGHT; break;
 582         case 0xcd: buf[0] = BOXDRAW_DOUBLE_HORIZONTAL; break;
 583
 584         default:
 585                 buf[0] = c;
 586         }
 587         buf[1] = 0;     /* terminate string */
 588
 589         conout->OutputString(conout, buf);
 590 }