MdeModulePkg/Universal/Console/TerminalDxe/TerminalConOut.c

   1 /*++
   2
   3 Copyright (c) 2006, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14     TerminalConOut.c
  15
  16 Abstract:
  17
  18
  19 Revision History
  20 --*/
  21
  22 #include "Terminal.h"
  23
  24 //
  25 // This list is used to define the valid extend chars.
  26 // It also provides a mapping from Unicode to PCANSI or
  27 // ASCII. The ASCII mapping we just made up.
  28 //
  29 //
  30 STATIC UNICODE_TO_CHAR  UnicodeToPcAnsiOrAscii[] = {
  31   { BOXDRAW_HORIZONTAL,                 0xc4, L'-' },
  32   { BOXDRAW_VERTICAL,                   0xb3, L'|' },
  33   { BOXDRAW_DOWN_RIGHT,                 0xda, L'/' },
  34   { BOXDRAW_DOWN_LEFT,                  0xbf, L'\\' },
  35   { BOXDRAW_UP_RIGHT,                   0xc0, L'\\' },
  36   { BOXDRAW_UP_LEFT,                    0xd9, L'/' },
  37   { BOXDRAW_VERTICAL_RIGHT,             0xc3, L'|' },
  38   { BOXDRAW_VERTICAL_LEFT,              0xb4, L'|' },
  39   { BOXDRAW_DOWN_HORIZONTAL,            0xc2, L'+' },
  40   { BOXDRAW_UP_HORIZONTAL,              0xc1, L'+' },
  41   { BOXDRAW_VERTICAL_HORIZONTAL,        0xc5, L'+' },
  42   { BOXDRAW_DOUBLE_HORIZONTAL,          0xcd, L'-' },
  43   { BOXDRAW_DOUBLE_VERTICAL,            0xba, L'|' },
  44   { BOXDRAW_DOWN_RIGHT_DOUBLE,          0xd5, L'/' },
  45   { BOXDRAW_DOWN_DOUBLE_RIGHT,          0xd6, L'/' },
  46   { BOXDRAW_DOUBLE_DOWN_RIGHT,          0xc9, L'/' },
  47   { BOXDRAW_DOWN_LEFT_DOUBLE,           0xb8, L'\\' },
  48   { BOXDRAW_DOWN_DOUBLE_LEFT,           0xb7, L'\\' },
  49   { BOXDRAW_DOUBLE_DOWN_LEFT,           0xbb, L'\\' },
  50   { BOXDRAW_UP_RIGHT_DOUBLE,            0xd4, L'\\' },
  51   { BOXDRAW_UP_DOUBLE_RIGHT,            0xd3, L'\\' },
  52   { BOXDRAW_DOUBLE_UP_RIGHT,            0xc8, L'\\' },
  53   { BOXDRAW_UP_LEFT_DOUBLE,             0xbe, L'/' },
  54   { BOXDRAW_UP_DOUBLE_LEFT,             0xbd, L'/' },
  55   { BOXDRAW_DOUBLE_UP_LEFT,             0xbc, L'/' },
  56   { BOXDRAW_VERTICAL_RIGHT_DOUBLE,      0xc6, L'|' },
  57   { BOXDRAW_VERTICAL_DOUBLE_RIGHT,      0xc7, L'|' },
  58   { BOXDRAW_DOUBLE_VERTICAL_RIGHT,      0xcc, L'|' },
  59   { BOXDRAW_VERTICAL_LEFT_DOUBLE,       0xb5, L'|' },
  60   { BOXDRAW_VERTICAL_DOUBLE_LEFT,       0xb6, L'|' },
  61   { BOXDRAW_DOUBLE_VERTICAL_LEFT,       0xb9, L'|' },
  62   { BOXDRAW_DOWN_HORIZONTAL_DOUBLE,     0xd1, L'+' },
  63   { BOXDRAW_DOWN_DOUBLE_HORIZONTAL,     0xd2, L'+' },
  64   { BOXDRAW_DOUBLE_DOWN_HORIZONTAL,     0xcb, L'+' },
  65   { BOXDRAW_UP_HORIZONTAL_DOUBLE,       0xcf, L'+' },
  66   { BOXDRAW_UP_DOUBLE_HORIZONTAL,       0xd0, L'+' },
  67   { BOXDRAW_DOUBLE_UP_HORIZONTAL,       0xca, L'+' },
  68   { BOXDRAW_VERTICAL_HORIZONTAL_DOUBLE, 0xd8, L'+' },
  69   { BOXDRAW_VERTICAL_DOUBLE_HORIZONTAL, 0xd7, L'+' },
  70   { BOXDRAW_DOUBLE_VERTICAL_HORIZONTAL, 0xce, L'+' },
  71
  72   { BLOCKELEMENT_FULL_BLOCK,            0xdb, L'*' },
  73   { BLOCKELEMENT_LIGHT_SHADE,           0xb0, L'+' },
  74
  75   { GEOMETRICSHAPE_UP_TRIANGLE,         0x1e, L'^' },
  76   { GEOMETRICSHAPE_RIGHT_TRIANGLE,      0x10, L'>' },
  77   { GEOMETRICSHAPE_DOWN_TRIANGLE,       0x1f, L'v' },
  78   { GEOMETRICSHAPE_LEFT_TRIANGLE,       0x11, L'<' },
  79
  80   {  ARROW_LEFT,                         0x3c, L'<' },
  81   {  ARROW_UP,                           0x18, L'^' },
  82   {  ARROW_RIGHT,                        0x3e, L'>' },
  83   {  ARROW_DOWN,                         0x19, L'v' },
  84
  85   { 0x0000,                             0x00, L'\0' }
  86 };
  87
  88 CHAR16 mSetModeString[]            = { ESC, '[', '=', '3', 'h', 0 };
  89 CHAR16 mSetAttributeString[]       = { ESC, '[', '0', 'm', ESC, '[', '4', '0', 'm', ESC, '[', '4', '0', 'm', 0 };
  90 CHAR16 mClearScreenString[]        = { ESC, '[', '2', 'J', 0 };
  91 CHAR16 mSetCursorPositionString[]  = { ESC, '[', '0', '0', ';', '0', '0', 'H', 0 };
  92
  93 //
  94 // Body of the ConOut functions
  95 //
  96 EFI_STATUS
  97 EFIAPI
  98 TerminalConOutReset (
  99   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
 100   IN  BOOLEAN                          ExtendedVerification
 101   )
 102 /*++
 103   Routine Description:
 104
 105     Implements EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.Reset().
 106     If ExtendeVerification is TRUE, then perform dependent serial device reset,
 107     and set display mode to mode 0.
 108     If ExtendedVerification is FALSE, only set display mode to mode 0.
 109
 110   Arguments:
 111
 112     This - Indicates the calling context.
 113
 114     ExtendedVerification - Indicates that the driver may perform a more exhaustive
 115                            verification operation of the device during reset.
 116
 117   Returns:
 118
 119     EFI_SUCCESS
 120        The reset operation succeeds.
 121
 122     EFI_DEVICE_ERROR
 123       The terminal is not functioning correctly or the serial port reset fails.
 124
 125 --*/
 126 {
 127   EFI_STATUS    Status;
 128   TERMINAL_DEV  *TerminalDevice;
 129
 130   TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (This);
 131
 132   //
 133   // Perform a more exhaustive reset by resetting the serial port.
 134   //
 135   if (ExtendedVerification) {
 136     //
 137     // Report progress code here
 138     //
 139     REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 140       EFI_PROGRESS_CODE,
 141       PcdGet32 (PcdStatusCodeValueRemoteConsoleReset),
 142       TerminalDevice->DevicePath
 143       );
 144
 145     Status = TerminalDevice->SerialIo->Reset (TerminalDevice->SerialIo);
 146     if (EFI_ERROR (Status)) {
 147       //
 148       // Report error code here
 149       //
 150       REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 151         EFI_ERROR_CODE | EFI_ERROR_MINOR,
 152         PcdGet32 (PcdStatusCodeValueRemoteConsoleError),
 153         TerminalDevice->DevicePath
 154         );
 155
 156       return Status;
 157     }
 158   }
 159
 160   This->SetAttribute (This, EFI_TEXT_ATTR (This->Mode->Attribute & 0x0F, EFI_BACKGROUND_BLACK));
 161
 162   Status = This->SetMode (This, 0);
 163
 164   return Status;
 165 }
 166
 167 EFI_STATUS
 168 EFIAPI
 169 TerminalConOutOutputString (
 170   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
 171   IN  CHAR16                           *WString
 172   )
 173 /*++
 174   Routine Description:
 175
 176     Implements EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.OutputString().
 177     The Unicode string will be converted to terminal expressible data stream
 178     and send to terminal via serial port.
 179
 180
 181   Arguments:
 182
 183     This - Indicates the calling context.
 184
 185     WString - The Null-terminated Unicode string to be displayed on
 186               the terminal screen.
 187
 188   Returns:
 189
 190     EFI_SUCCESS
 191        The string is output successfully.
 192
 193     EFI_DEVICE_ERROR
 194       The serial port fails to send the string out.
 195
 196     EFI_WARN_UNKNOWN_GLYPH
 197       Indicates that some of the characters in the Unicode string could not
 198       be rendered and are skipped.
 199
 200     EFI_UNSUPPORTED
 201
 202 --*/
 203 {
 204   TERMINAL_DEV                *TerminalDevice;
 205   EFI_SIMPLE_TEXT_OUTPUT_MODE *Mode;
 206   UINTN                       MaxColumn;
 207   UINTN                       MaxRow;
 208   UINTN                       Length;
 209   UTF8_CHAR                   Utf8Char;
 210   CHAR8                       GraphicChar;
 211   CHAR8                       AsciiChar;
 212   EFI_STATUS                  Status;
 213   UINT8                       ValidBytes;
 214   //
 215   //  flag used to indicate whether condition happens which will cause
 216   //  return EFI_WARN_UNKNOWN_GLYPH
 217   //
 218   BOOLEAN                     Warning;
 219
 220   ValidBytes  = 0;
 221   Warning     = FALSE;
 222
 223   //
 224   //  get Terminal device data structure pointer.
 225   //
 226   TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (This);
 227
 228   //
 229   //  Get current display mode
 230   //
 231   Mode = This->Mode;
 232
 233   if (Mode->Mode > 1) {
 234     return EFI_UNSUPPORTED;
 235   }
 236
 237   This->QueryMode (
 238           This,
 239           Mode->Mode,
 240           &MaxColumn,
 241           &MaxRow
 242           );
 243
 244   for (; *WString != CHAR_NULL; WString++) {
 245
 246     switch (TerminalDevice->TerminalType) {
 247
 248     case PcAnsiType:
 249     case VT100Type:
 250     case VT100PlusType:
 251
 252       if (!TerminalIsValidTextGraphics (*WString, &GraphicChar, &AsciiChar)) {
 253         //
 254         // If it's not a graphic character convert Unicode to ASCII.
 255         //
 256         GraphicChar = (CHAR8) *WString;
 257
 258         if (!(TerminalIsValidAscii (GraphicChar) || TerminalIsValidEfiCntlChar (GraphicChar))) {
 259           //
 260           // when this driver use the OutputString to output control string,
 261           // TerminalDevice->OutputEscChar is set to let the Esc char
 262           // to be output to the terminal emulation software.
 263           //
 264           if ((GraphicChar == 27) && TerminalDevice->OutputEscChar) {
 265             GraphicChar = 27;
 266           } else {
 267             GraphicChar = '?';
 268             Warning     = TRUE;
 269           }
 270         }
 271
 272         AsciiChar = GraphicChar;
 273
 274       }
 275
 276       if (TerminalDevice->TerminalType != PcAnsiType) {
 277         GraphicChar = AsciiChar;
 278       }
 279
 280       Length = 1;
 281
 282       Status = TerminalDevice->SerialIo->Write (
 283                                           TerminalDevice->SerialIo,
 284                                           &Length,
 285                                           &GraphicChar
 286                                           );
 287
 288       if (EFI_ERROR (Status)) {
 289         goto OutputError;
 290       }
 291
 292       break;
 293
 294     case VTUTF8Type:
 295       UnicodeToUtf8 (*WString, &Utf8Char, &ValidBytes);
 296       Length = ValidBytes;
 297       Status = TerminalDevice->SerialIo->Write (
 298                                           TerminalDevice->SerialIo,
 299                                           &Length,
 300                                           (UINT8 *) &Utf8Char
 301                                           );
 302       if (EFI_ERROR (Status)) {
 303         goto OutputError;
 304       }
 305       break;
 306     }
 307     //
 308     //  Update cursor position.
 309     //
 310     switch (*WString) {
 311
 312     case CHAR_BACKSPACE:
 313       if (Mode->CursorColumn > 0) {
 314         Mode->CursorColumn--;
 315       }
 316       break;
 317
 318     case CHAR_LINEFEED:
 319       if (Mode->CursorRow < (INT32) (MaxRow - 1)) {
 320         Mode->CursorRow++;
 321       }
 322       break;
 323
 324     case CHAR_CARRIAGE_RETURN:
 325       Mode->CursorColumn = 0;
 326       break;
 327
 328     default:
 329       if (Mode->CursorColumn < (INT32) (MaxColumn - 1)) {
 330
 331         Mode->CursorColumn++;
 332
 333       } else {
 334
 335         Mode->CursorColumn = 0;
 336         if (Mode->CursorRow < (INT32) (MaxRow - 1)) {
 337           Mode->CursorRow++;
 338         }
 339
 340       }
 341       break;
 342
 343     };
 344
 345   }
 346
 347   if (Warning) {
 348     return EFI_WARN_UNKNOWN_GLYPH;
 349   }
 350
 351   return EFI_SUCCESS;
 352
 353 OutputError:
 354   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 355     EFI_ERROR_CODE | EFI_ERROR_MINOR,
 356     PcdGet32 (PcdStatusCodeValueRemoteConsoleOutputError),
 357     TerminalDevice->DevicePath
 358     );
 359
 360   return EFI_DEVICE_ERROR;
 361 }
 362
 363 EFI_STATUS
 364 EFIAPI
 365 TerminalConOutTestString (
 366   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
 367   IN  CHAR16                           *WString
 368   )
 369 /*++
 370   Routine Description:
 371
 372     Implements EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.TestString().
 373     If one of the characters in the *Wstring is
 374     neither valid Unicode drawing characters,
 375     not ASCII code, then this function will return
 376     EFI_UNSUPPORTED.
 377
 378
 379   Arguments:
 380
 381     This - Indicates the calling context.
 382
 383     WString - The Null-terminated Unicode string to be tested.
 384
 385   Returns:
 386
 387     EFI_SUCCESS
 388        The terminal is capable of rendering the output string.
 389
 390     EFI_UNSUPPORTED
 391       Some of the characters in the Unicode string cannot be rendered.
 392
 393 --*/
 394 {
 395   TERMINAL_DEV  *TerminalDevice;
 396   EFI_STATUS    Status;
 397
 398   //
 399   //  get Terminal device data structure pointer.
 400   //
 401   TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (This);
 402
 403   switch (TerminalDevice->TerminalType) {
 404
 405   case PcAnsiType:
 406   case VT100Type:
 407   case VT100PlusType:
 408     Status = AnsiTestString (TerminalDevice, WString);
 409     break;
 410
 411   case VTUTF8Type:
 412     Status = VTUTF8TestString (TerminalDevice, WString);
 413     break;
 414
 415   default:
 416     Status = EFI_UNSUPPORTED;
 417     break;
 418   }
 419
 420   return Status;
 421 }
 422
 423 EFI_STATUS
 424 EFIAPI
 425 TerminalConOutQueryMode (
 426   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
 427   IN  UINTN                            ModeNumber,
 428   OUT UINTN                            *Columns,
 429   OUT UINTN                            *Rows
 430   )
 431 /*++
 432   Routine Description:
 433
 434     Implements EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.QueryMode().
 435     It returns information for an available text mode
 436     that the terminal supports.
 437     In this driver, we only support text mode 80x25, which is
 438     defined as mode 0.
 439
 440
 441   Arguments:
 442
 443     *This
 444         Indicates the calling context.
 445
 446     ModeNumber
 447         The mode number to return information on.
 448
 449     Columns
 450         The returned columns of the requested mode.
 451
 452     Rows
 453         The returned rows of the requested mode.
 454
 455   Returns:
 456
 457     EFI_SUCCESS
 458       The requested mode information is returned.
 459
 460     EFI_UNSUPPORTED
 461       The mode number is not valid.
 462
 463     EFI_DEVICE_ERROR
 464
 465 --*/
 466 {
 467   if (This->Mode->MaxMode > 2) {
 468     return EFI_DEVICE_ERROR;
 469   }
 470
 471   if (ModeNumber == 0) {
 472     *Columns  = MODE0_COLUMN_COUNT;
 473     *Rows     = MODE0_ROW_COUNT;
 474     return EFI_SUCCESS;
 475   } else if (ModeNumber == 1) {
 476     *Columns  = MODE1_COLUMN_COUNT;
 477     *Rows     = MODE1_ROW_COUNT;
 478     return EFI_SUCCESS;
 479   }
 480
 481   return EFI_UNSUPPORTED;
 482 }
 483
 484 EFI_STATUS
 485 EFIAPI
 486 TerminalConOutSetMode (
 487   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
 488   IN  UINTN                            ModeNumber
 489   )
 490 /*++
 491   Routine Description:
 492
 493     Implements EFI_SIMPLE_TEXT_OUT.SetMode().
 494     Set the terminal to a specified display mode.
 495     In this driver, we only support mode 0.
 496
 497   Arguments:
 498
 499     This
 500         Indicates the calling context.
 501
 502     ModeNumber
 503         The text mode to set.
 504
 505   Returns:
 506
 507     EFI_SUCCESS
 508        The requested text mode is set.
 509
 510     EFI_DEVICE_ERROR
 511       The requested text mode cannot be set because of serial device error.
 512
 513     EFI_UNSUPPORTED
 514       The text mode number is not valid.
 515
 516 --*/
 517 {
 518   EFI_STATUS    Status;
 519   TERMINAL_DEV  *TerminalDevice;
 520
 521   //
 522   //  get Terminal device data structure pointer.
 523   //
 524   TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (This);
 525
 526   if (ModeNumber > 1) {
 527     return EFI_UNSUPPORTED;
 528   }
 529
 530   //
 531   // Set the current mode
 532   //
 533   This->Mode->Mode = (INT32) ModeNumber;
 534
 535   This->ClearScreen (This);
 536
 537   TerminalDevice->OutputEscChar = TRUE;
 538   Status                        = This->OutputString (This, mSetModeString);
 539   TerminalDevice->OutputEscChar = FALSE;
 540
 541   if (EFI_ERROR (Status)) {
 542     return EFI_DEVICE_ERROR;
 543   }
 544
 545   This->Mode->Mode  = (INT32) ModeNumber;
 546
 547   Status            = This->ClearScreen (This);
 548   if (EFI_ERROR (Status)) {
 549     return EFI_DEVICE_ERROR;
 550   }
 551
 552   return EFI_SUCCESS;
 553
 554 }
 555
 556 EFI_STATUS
 557 EFIAPI
 558 TerminalConOutSetAttribute (
 559   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
 560   IN  UINTN                            Attribute
 561   )
 562 /*++
 563   Routine Description:
 564
 565     Implements EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.SetAttribute().
 566
 567   Arguments:
 568
 569     This
 570         Indicates the calling context.
 571
 572     Attribute
 573         The attribute to set. Only bit0..6 are valid, all other bits
 574         are undefined and must be zero.
 575
 576   Returns:
 577
 578     EFI_SUCCESS
 579       The requested attribute is set.
 580
 581     EFI_DEVICE_ERROR
 582       The requested attribute cannot be set due to serial port error.
 583
 584     EFI_UNSUPPORTED
 585       The attribute requested is not defined by EFI spec.
 586
 587 --*/
 588 {
 589   UINT8         ForegroundControl;
 590   UINT8         BackgroundControl;
 591   UINT8         BrightControl;
 592   INT32         SavedColumn;
 593   INT32         SavedRow;
 594   EFI_STATUS    Status;
 595   TERMINAL_DEV  *TerminalDevice;
 596
 597   SavedColumn = 0;
 598   SavedRow    = 0;
 599
 600   //
 601   //  get Terminal device data structure pointer.
 602   //
 603   TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (This);
 604
 605   //
 606   //  only the bit0..6 of the Attribute is valid
 607   //
 608   if ((Attribute | 0x7f) != 0x7f) {
 609     return EFI_UNSUPPORTED;
 610   }
 611   //
 612   //  convert Attribute value to terminal emulator
 613   //  understandable foreground color
 614   //
 615   switch (Attribute & 0x07) {
 616
 617   case EFI_BLACK:
 618     ForegroundControl = 30;
 619     break;
 620
 621   case EFI_BLUE:
 622     ForegroundControl = 34;
 623     break;
 624
 625   case EFI_GREEN:
 626     ForegroundControl = 32;
 627     break;
 628
 629   case EFI_CYAN:
 630     ForegroundControl = 36;
 631     break;
 632
 633   case EFI_RED:
 634     ForegroundControl = 31;
 635     break;
 636
 637   case EFI_MAGENTA:
 638     ForegroundControl = 35;
 639     break;
 640
 641   case EFI_BROWN:
 642     ForegroundControl = 33;
 643     break;
 644
 645   default:
 646
 647   case EFI_LIGHTGRAY:
 648     ForegroundControl = 37;
 649     break;
 650
 651   }
 652   //
 653   //  bit4 of the Attribute indicates bright control
 654   //  of terminal emulator.
 655   //
 656   BrightControl = (UINT8) ((Attribute >> 3) & 1);
 657
 658   //
 659   //  convert Attribute value to terminal emulator
 660   //  understandable background color.
 661   //
 662   switch ((Attribute >> 4) & 0x07) {
 663
 664   case EFI_BLACK:
 665     BackgroundControl = 40;
 666     break;
 667
 668   case EFI_BLUE:
 669     BackgroundControl = 44;
 670     break;
 671
 672   case EFI_GREEN:
 673     BackgroundControl = 42;
 674     break;
 675
 676   case EFI_CYAN:
 677     BackgroundControl = 46;
 678     break;
 679
 680   case EFI_RED:
 681     BackgroundControl = 41;
 682     break;
 683
 684   case EFI_MAGENTA:
 685     BackgroundControl = 45;
 686     break;
 687
 688   case EFI_BROWN:
 689     BackgroundControl = 43;
 690     break;
 691
 692   default:
 693
 694   case EFI_LIGHTGRAY:
 695     BackgroundControl = 47;
 696     break;
 697   }
 698   //
 699   // terminal emulator's control sequence to set attributes
 700   //
 701   mSetAttributeString[BRIGHT_CONTROL_OFFSET]          = (CHAR16) ('0' + BrightControl);
 702   mSetAttributeString[FOREGROUND_CONTROL_OFFSET + 0]  = (CHAR16) ('0' + (ForegroundControl / 10));
 703   mSetAttributeString[FOREGROUND_CONTROL_OFFSET + 1]  = (CHAR16) ('0' + (ForegroundControl % 10));
 704   mSetAttributeString[BACKGROUND_CONTROL_OFFSET + 0]  = (CHAR16) ('0' + (BackgroundControl / 10));
 705   mSetAttributeString[BACKGROUND_CONTROL_OFFSET + 1]  = (CHAR16) ('0' + (BackgroundControl % 10));
 706
 707   //
 708   // save current column and row
 709   // for future scrolling back use.
 710   //
 711   SavedColumn                   = This->Mode->CursorColumn;
 712   SavedRow                      = This->Mode->CursorRow;
 713
 714   TerminalDevice->OutputEscChar = TRUE;
 715   Status                        = This->OutputString (This, mSetAttributeString);
 716   TerminalDevice->OutputEscChar = FALSE;
 717
 718   if (EFI_ERROR (Status)) {
 719     return EFI_DEVICE_ERROR;
 720   }
 721   //
 722   //  scroll back to saved cursor position.
 723   //
 724   This->Mode->CursorColumn  = SavedColumn;
 725   This->Mode->CursorRow     = SavedRow;
 726
 727   This->Mode->Attribute     = (INT32) Attribute;
 728
 729   return EFI_SUCCESS;
 730
 731 }
 732
 733 EFI_STATUS
 734 EFIAPI
 735 TerminalConOutClearScreen (
 736   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This
 737   )
 738 /*++
 739   Routine Description:
 740
 741     Implements EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.ClearScreen().
 742     It clears the ANSI terminal's display to the
 743     currently selected background color.
 744
 745
 746   Arguments:
 747
 748     This
 749         Indicates the calling context.
 750
 751   Returns:
 752
 753     EFI_SUCCESS
 754       The operation completed successfully.
 755
 756     EFI_DEVICE_ERROR
 757       The terminal screen cannot be cleared due to serial port error.
 758
 759     EFI_UNSUPPORTED
 760       The terminal is not in a valid display mode.
 761
 762 --*/
 763 {
 764   EFI_STATUS    Status;
 765   TERMINAL_DEV  *TerminalDevice;
 766
 767   TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (This);
 768
 769   //
 770   //  control sequence for clear screen request
 771   //
 772   TerminalDevice->OutputEscChar = TRUE;
 773   Status                        = This->OutputString (This, mClearScreenString);
 774   TerminalDevice->OutputEscChar = FALSE;
 775
 776   if (EFI_ERROR (Status)) {
 777     return EFI_DEVICE_ERROR;
 778   }
 779
 780   Status = This->SetCursorPosition (This, 0, 0);
 781
 782   return Status;
 783 }
 784
 785 EFI_STATUS
 786 EFIAPI
 787 TerminalConOutSetCursorPosition (
 788   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
 789   IN  UINTN                            Column,
 790   IN  UINTN                            Row
 791   )
 792 /*++
 793   Routine Description:
 794
 795     Implements EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.SetCursorPosition().
 796
 797   Arguments:
 798
 799     This
 800         Indicates the calling context.
 801
 802     Column
 803         The row to set cursor to.
 804
 805     Row
 806         The column to set cursor to.
 807
 808   Returns:
 809
 810     EFI_SUCCESS
 811       The operation completed successfully.
 812
 813     EFI_DEVICE_ERROR
 814       The request fails due to serial port error.
 815
 816     EFI_UNSUPPORTED
 817       The terminal is not in a valid text mode, or the cursor position
 818       is invalid for current mode.
 819
 820 --*/
 821 {
 822   EFI_SIMPLE_TEXT_OUTPUT_MODE *Mode;
 823   UINTN                       MaxColumn;
 824   UINTN                       MaxRow;
 825   EFI_STATUS                  Status;
 826   TERMINAL_DEV                *TerminalDevice;
 827
 828   TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (This);
 829
 830   //
 831   //  get current mode
 832   //
 833   Mode = This->Mode;
 834
 835   //
 836   //  get geometry of current mode
 837   //
 838   Status = This->QueryMode (
 839                   This,
 840                   Mode->Mode,
 841                   &MaxColumn,
 842                   &MaxRow
 843                   );
 844   if (EFI_ERROR (Status)) {
 845     return EFI_UNSUPPORTED;
 846   }
 847
 848   if (Column >= MaxColumn || Row >= MaxRow) {
 849     return EFI_UNSUPPORTED;
 850   }
 851   //
 852   // control sequence to move the cursor
 853   //
 854   mSetCursorPositionString[ROW_OFFSET + 0]    = (CHAR16) ('0' + ((Row + 1) / 10));
 855   mSetCursorPositionString[ROW_OFFSET + 1]    = (CHAR16) ('0' + ((Row + 1) % 10));
 856   mSetCursorPositionString[COLUMN_OFFSET + 0] = (CHAR16) ('0' + ((Column + 1) / 10));
 857   mSetCursorPositionString[COLUMN_OFFSET + 1] = (CHAR16) ('0' + ((Column + 1) % 10));
 858
 859   TerminalDevice->OutputEscChar               = TRUE;
 860   Status = This->OutputString (This, mSetCursorPositionString);
 861   TerminalDevice->OutputEscChar = FALSE;
 862
 863   if (EFI_ERROR (Status)) {
 864     return EFI_DEVICE_ERROR;
 865   }
 866   //
 867   //  update current cursor position
 868   //  in the Mode data structure.
 869   //
 870   Mode->CursorColumn  = (INT32) Column;
 871   Mode->CursorRow     = (INT32) Row;
 872
 873   return EFI_SUCCESS;
 874 }
 875
 876 EFI_STATUS
 877 EFIAPI
 878 TerminalConOutEnableCursor (
 879   IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
 880   IN  BOOLEAN                          Visible
 881   )
 882 /*++
 883   Routine Description:
 884
 885     Implements SIMPLE_TEXT_OUTPUT.EnableCursor().
 886     In this driver, the cursor cannot be hidden.
 887
 888   Arguments:
 889
 890     This
 891         Indicates the calling context.
 892
 893     Visible
 894         If TRUE, the cursor is set to be visible,
 895         If FALSE, the cursor is set to be invisible.
 896
 897   Returns:
 898
 899     EFI_SUCCESS
 900       The request is valid.
 901
 902     EFI_UNSUPPORTED
 903       The terminal does not support cursor hidden.
 904
 905 --*/
 906 {
 907   if (!Visible) {
 908     return EFI_UNSUPPORTED;
 909   }
 910
 911   return EFI_SUCCESS;
 912 }
 913
 914 BOOLEAN
 915 TerminalIsValidTextGraphics (
 916   IN  CHAR16  Graphic,
 917   OUT CHAR8   *PcAnsi, OPTIONAL
 918   OUT CHAR8   *Ascii OPTIONAL
 919   )
 920 /*++
 921
 922 Routine Description:
 923
 924     Detects if a Unicode char is for Box Drawing text graphics.
 925
 926 Arguments:
 927
 928     Graphic  - Unicode char to test.
 929
 930     PcAnsi  - Optional pointer to return PCANSI equivalent of Graphic.
 931
 932     Ascii   - Optional pointer to return ASCII equivalent of Graphic.
 933
 934 Returns:
 935
 936     TRUE if Graphic is a supported Unicode Box Drawing character.
 937
 938 --*/
 939 {
 940   UNICODE_TO_CHAR *Table;
 941
 942   if ((((Graphic & 0xff00) != 0x2500) && ((Graphic & 0xff00) != 0x2100))) {
 943     //
 944     // Unicode drawing code charts are all in the 0x25xx range,
 945     //  arrows are 0x21xx
 946     //
 947     return FALSE;
 948   }
 949
 950   for (Table = UnicodeToPcAnsiOrAscii; Table->Unicode != 0x0000; Table++) {
 951     if (Graphic == Table->Unicode) {
 952       if (PcAnsi != NULL) {
 953         *PcAnsi = Table->PcAnsi;
 954       }
 955
 956       if (Ascii != NULL) {
 957         *Ascii = Table->Ascii;
 958       }
 959
 960       return TRUE;
 961     }
 962   }
 963
 964   return FALSE;
 965 }
 966
 967 BOOLEAN
 968 TerminalIsValidAscii (
 969   IN  CHAR16  Ascii
 970   )
 971 {
 972   //
 973   // valid ascii code lies in the extent of 0x20 ~ 0x7f
 974   //
 975   if ((Ascii >= 0x20) && (Ascii <= 0x7f)) {
 976     return TRUE;
 977   }
 978
 979   return FALSE;
 980 }
 981
 982 BOOLEAN
 983 TerminalIsValidEfiCntlChar (
 984   IN  CHAR16  CharC
 985   )
 986 {
 987   //
 988   // only support four control characters.
 989   //
 990   if (CharC == CHAR_NULL ||
 991       CharC == CHAR_BACKSPACE ||
 992       CharC == CHAR_LINEFEED ||
 993       CharC == CHAR_CARRIAGE_RETURN ||
 994       CharC == CHAR_TAB
 995       ) {
 996     return TRUE;
 997   }
 998
 999   return FALSE;
1000 }