MdeModulePkg/Universal/Console/TerminalDxe/TerminalConOut.c

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