TextOutputBuiltin.c

Go to the documentation of this file.

 
#include "OcConsoleLibInternal.h"
 
#include <Uefi.h>
#include <Guid/AppleVariable.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/OcConsoleLib.h>
#include <Library/OcMiscLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiRuntimeServicesTableLib.h>
#include <Protocol/ConsoleControl.h>
#include <Protocol/GraphicsOutput.h>
 
STATIC BOOLEAN          mIsDefaultFont;
STATIC OC_CONSOLE_FONT  *mConsoleFont;
 
STATIC UINT32  mGraphicsEfiColors[16] = {
  0x00000000,  // BLACK
  0x00000098,  // LIGHTBLUE
  0x00009800,  // LIGHTGREEN
  0x00009898,  // LIGHTCYAN
  0x00980000,  // LIGHTRED
  0x00980098,  // MAGENTA
  0x00989800,  // BROWN
  0x00bfbfbf,  // LIGHTGRAY
  0x00303030,  // DARKGRAY - BRIGHT BLACK
  0x000000ff,  // BLUE
  0x0000ff00,  // LIME
  0x0000ffff,  // CYAN
  0x00ff0000,  // RED
  0x00ff00ff,  // FUCHSIA
  0x00ffff00,  // YELLOW
  0x00ffffff   // WHITE
};
 
STATIC EFI_GRAPHICS_OUTPUT_PROTOCOL         *mGraphicsOutput;
STATIC UINTN                                mConsolePaddingX;
STATIC UINTN                                mConsolePaddingY;
STATIC UINTN                                mUserWidth;
STATIC UINTN                                mUserHeight;
STATIC UINTN                                mConsoleWidth;
STATIC UINTN                                mConsoleHeight;
STATIC UINTN                                mConsoleMaxPosX;
STATIC UINTN                                mConsoleMaxPosY;
STATIC BOOLEAN                              mConsoleUncontrolled;
STATIC UINTN                                mPrivateColumn; 
STATIC UINTN                                mPrivateRow;    
STATIC UINT32                               mConsoleGopMode;
STATIC UINT8                                mUIScale;
STATIC UINT8                                mFontScale;
STATIC EFI_GRAPHICS_OUTPUT_BLT_PIXEL_UNION  mBackgroundColor;
STATIC EFI_GRAPHICS_OUTPUT_BLT_PIXEL_UNION  mForegroundColor;
STATIC EFI_GRAPHICS_OUTPUT_BLT_PIXEL_UNION  *mCharacterBuffer;
STATIC EFI_CONSOLE_CONTROL_SCREEN_MODE      mConsoleMode = EfiConsoleControlScreenText;
 
#define TGT_CHAR_WIDTH     ((UINTN)(ISO_CHAR_WIDTH) * mFontScale)
#define TGT_CHAR_HEIGHT    ((UINTN)(ISO_CHAR_HEIGHT) * mFontScale)
#define TGT_CHAR_AREA      ((TGT_CHAR_WIDTH) * (TGT_CHAR_HEIGHT))
#define TGT_PADD_WIDTH     (mConsolePaddingX)
#define TGT_PADD_HEIGHT    (mConsolePaddingY)
#define TGT_CURSOR_X       mFontScale
#define TGT_CURSOR_Y       ((TGT_CHAR_HEIGHT) - mFontScale)
#define TGT_CURSOR_WIDTH   ((TGT_CHAR_WIDTH) - mFontScale * 2)
#define TGT_CURSOR_HEIGHT  (mFontScale)
 
#define MIN_SUPPORTED_CONSOLE_WIDTH   (80)
#define MIN_SUPPORTED_CONSOLE_HEIGHT  (25)
 
STATIC
EFI_STATUS
GetConsoleFontCharInfo (
  IN  OC_CONSOLE_FONT       *ConsoleFont,
  IN  CHAR16                Char,
  OUT OC_CONSOLE_FONT_PAGE  **Page,
  OUT UINT8                 *GlyphIndex,
  IN  BOOLEAN               UseFallback
  )
{
  EFI_STATUS  Status;
  UINT16      PageNumber;
  UINT8       PageChar;
  UINT16      PageIndex;
 
  ASSERT (Page != NULL);
  ASSERT (GlyphIndex != NULL);
 
  PageNumber = (Char >> 7) & 0x1FF;
  PageChar   = Char & 0x7F;
 
  *GlyphIndex = 0;
 
  Status = EFI_SUCCESS;
  do {
    if ((PageNumber >= ConsoleFont->PageMin) && (PageNumber < ConsoleFont->PageMax)) {
      PageIndex = PageNumber - ConsoleFont->PageMin + 1;
      if (ConsoleFont->PageOffsets != NULL) {
        PageIndex = ConsoleFont->PageOffsets[PageIndex - 1];
      }
 
      if (PageIndex != 0) {
        *Page = &ConsoleFont->Pages[PageIndex - 1];
        if ((PageChar >= (*Page)->CharMin) && (PageChar < (*Page)->CharMax)) {
          ASSERT ((*Page)->Glyphs != NULL);
          if ((*Page)->GlyphOffsets == NULL) {
            *GlyphIndex = PageChar - (*Page)->CharMin + 1;
          } else {
            *GlyphIndex = (*Page)->GlyphOffsets[PageChar - (*Page)->CharMin];
          }
        }
      }
    }
 
    if (*GlyphIndex == 0) {
      //
      // Give up and render nothing if fallback char is not present.
      //
      ASSERT (Status == EFI_SUCCESS); 
      if (!UseFallback || (Status != EFI_SUCCESS)) {
        return EFI_LOAD_ERROR;
      }
 
      Status = EFI_WARN_UNKNOWN_GLYPH;
 
      //
      // For default font, render all unknown chars in provided page(s) as space (following the explicit
      // spaces in free console font used in XNU); in other pages and in user fonts use underscore.
      //
      STATIC_ASSERT (ISO_FONT_MAX_PAGE == 1 || ISO_FONT_MAX_PAGE == 2, "Invalid ISO_FONT_MAX_PAGE value");
      if (mIsDefaultFont && (PageNumber < ISO_FONT_MAX_PAGE)) {
        PageChar = L' ';
      } else {
        PageChar = OC_CONSOLE_FONT_FALLBACK_CHAR;
      }
 
      PageNumber = 0;
    }
  } while (*GlyphIndex == 0);
 
  return Status;
}
 
BOOLEAN
OcConsoleFontContainsChar (
  IN OC_CONSOLE_FONT  *ConsoleFont,
  IN CHAR16           Char
  )
{
  EFI_STATUS            Status;
  OC_CONSOLE_FONT_PAGE  *Page;
  UINT8                 GlyphIndex;
 
  Status = GetConsoleFontCharInfo (ConsoleFont, Char, &Page, &GlyphIndex, FALSE);
 
  return !EFI_ERROR (Status);
}
 
STATIC
VOID
RenderChar (
  IN CHAR16  Char,
  IN UINTN   PosX,
  IN UINTN   PosY
  )
{
  UINT32                *DstBuffer;
  UINT8                 *SrcBuffer;
  OC_CONSOLE_FONT_PAGE  *Page;
  UINT8                 Line;
  UINT32                Index;
  UINT32                Index2;
  UINT8                 Mask;
  UINT8                 FontHead;
  UINT8                 FontTail;
  UINT8                 GlyphIndex;
  BOOLEAN               LeftToRight;
  EFI_STATUS            Status;
 
  DstBuffer = &mCharacterBuffer[0].Raw;
 
  Status = GetConsoleFontCharInfo (mConsoleFont, Char, &Page, &GlyphIndex, TRUE);
 
  if (EFI_ERROR (Status)) {
    return;
  }
 
  FontHead    = Page->FontHead;
  FontTail    = Page->FontTail;
  LeftToRight = Page->LeftToRight;
 
  SrcBuffer = Page->Glyphs + ((GlyphIndex - 1) * (ISO_CHAR_HEIGHT - FontHead - FontTail));
 
  for (Line = 0; Line < FontHead; ++Line) {
    //
    // Apply scale twice, for width and height.
    //
    SetMem32 (DstBuffer, TGT_CHAR_WIDTH * mFontScale * sizeof (DstBuffer[0]), mBackgroundColor.Raw);
    DstBuffer += TGT_CHAR_WIDTH * mFontScale;
  }
 
  for ( ; Line < ISO_CHAR_HEIGHT - FontTail; ++Line) {
    //
    // Iterate, while single bit scans font.
    //
    for (Index = 0; Index < mFontScale; ++Index) {
      Mask = LeftToRight ? 0x80 : 1;
      do {
        for (Index2 = 0; Index2 < mFontScale; ++Index2) {
          *DstBuffer = (*SrcBuffer & Mask) ? mForegroundColor.Raw : mBackgroundColor.Raw;
          ++DstBuffer;
        }
 
        if (LeftToRight) {
          Mask >>= 1U;
        } else {
          Mask <<= 1U;
        }
      } while (Mask != 0);
    }
 
    ++SrcBuffer;
  }
 
  for ( ; Line < ISO_CHAR_HEIGHT; ++Line) {
    SetMem32 (DstBuffer, TGT_CHAR_WIDTH * mFontScale * sizeof (DstBuffer[0]), mBackgroundColor.Raw);
    DstBuffer += TGT_CHAR_WIDTH * mFontScale;
  }
 
  ASSERT (DstBuffer - &mCharacterBuffer[0].Raw == (INTN)TGT_CHAR_AREA);
 
  mGraphicsOutput->Blt (
                     mGraphicsOutput,
                     &mCharacterBuffer[0].Pixel,
                     EfiBltBufferToVideo,
                     0,
                     0,
                     TGT_PADD_WIDTH  + PosX * TGT_CHAR_WIDTH,
                     TGT_PADD_HEIGHT + PosY * TGT_CHAR_HEIGHT,
                     TGT_CHAR_WIDTH,
                     TGT_CHAR_HEIGHT,
                     0
                     );
}
 
STATIC
VOID
FlushCursor (
  IN BOOLEAN  Enabled,
  IN UINTN    PosX,
  IN UINTN    PosY
  )
{
  EFI_STATUS                           Status;
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL_UNION  Colour;
 
  if (!Enabled || (mConsoleMode != EfiConsoleControlScreenText)) {
    return;
  }
 
  //
  // UEFI only has one cursor at a time. UEFI Shell edit command has a cursor and a mouse
  // pointer, which are not connected. To be able to draw both at a time UEFI Shell constantly
  // redraws both the cursor and the mouse pointer. To do that it constantly flips bg and fg
  // colours as well as cursor visibility.
  // It seems that the Shell implementation relies on an undocumented feature (is that a bug?)
  // of hiding an already drawn cursor with a space with inverted attributes.
  // This is weird but EDK II implementation seems to match the logic, and as a result we
  // track cursor visibility or easily optimise this logic.
  //
  Status = mGraphicsOutput->Blt (
                              mGraphicsOutput,
                              &Colour.Pixel,
                              EfiBltVideoToBltBuffer,
                              TGT_PADD_WIDTH  + PosX * TGT_CHAR_WIDTH  + TGT_CURSOR_X,
                              TGT_PADD_HEIGHT + PosY * TGT_CHAR_HEIGHT + TGT_CURSOR_Y,
                              0,
                              0,
                              1,
                              1,
                              0
                              );
 
  if (EFI_ERROR (Status)) {
    return;
  }
 
  mGraphicsOutput->Blt (
                     mGraphicsOutput,
                     Colour.Raw == mForegroundColor.Raw ? &mBackgroundColor.Pixel : &mForegroundColor.Pixel,
                     EfiBltVideoFill,
                     0,
                     0,
                     TGT_PADD_WIDTH  + PosX * TGT_CHAR_WIDTH  + TGT_CURSOR_X,
                     TGT_PADD_HEIGHT + PosY * TGT_CHAR_HEIGHT + TGT_CURSOR_Y,
                     TGT_CURSOR_WIDTH,
                     TGT_CURSOR_HEIGHT,
                     0
                     );
}
 
STATIC
VOID
RenderScroll (
  VOID
  )
{
  UINTN  Width;
 
  //
  // Move used screen region.
  //
  Width = (mConsoleMaxPosX + 1) * TGT_CHAR_WIDTH;
  mGraphicsOutput->Blt (
                     mGraphicsOutput,
                     NULL,
                     EfiBltVideoToVideo,
                     TGT_PADD_WIDTH,
                     TGT_PADD_HEIGHT + TGT_CHAR_HEIGHT,
                     TGT_PADD_WIDTH,
                     TGT_PADD_HEIGHT,
                     Width,
                     TGT_CHAR_HEIGHT * (mConsoleHeight - 1),
                     0
                     );
 
  //
  // Erase last line.
  //
  mGraphicsOutput->Blt (
                     mGraphicsOutput,
                     &mBackgroundColor.Pixel,
                     EfiBltVideoFill,
                     0,
                     0,
                     TGT_PADD_WIDTH,
                     TGT_PADD_HEIGHT + TGT_CHAR_HEIGHT * (mConsoleHeight - 1),
                     Width,
                     TGT_CHAR_HEIGHT,
                     0
                     );
}
 
//
// Resync - called on detected change of GOP mode and on reset.
//
STATIC
EFI_STATUS
RenderResync (
  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This
  )
{
  EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  *Info;
  UINTN                                 MaxWidth;
  UINTN                                 MaxHeight;
 
  Info = mGraphicsOutput->Mode->Info;
 
  //
  // Require space for at least 1x1 chars on the calculation below.
  //
  if (  (Info->HorizontalResolution < ISO_CHAR_WIDTH)
     || (Info->VerticalResolution   < ISO_CHAR_HEIGHT))
  {
    return EFI_LOAD_ERROR;
  }
 
  if (mCharacterBuffer != NULL) {
    FreePool (mCharacterBuffer);
  }
 
  //
  // Reset font scale and allocate for target size - may be over-allocated if we have to override below.
  //
  mFontScale       = mUIScale;
  mCharacterBuffer = AllocatePool (TGT_CHAR_AREA * sizeof (mCharacterBuffer[0]));
  if (mCharacterBuffer == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  mConsoleGopMode = mGraphicsOutput->Mode->Mode;
 
  //
  // Override font scale to reach minimum supported text resolution, if needed and possible.
  //
  while (TRUE) {
    MaxWidth  = Info->HorizontalResolution / TGT_CHAR_WIDTH;
    MaxHeight = Info->VerticalResolution / TGT_CHAR_HEIGHT;
    if (  (MaxWidth  >= MIN_SUPPORTED_CONSOLE_WIDTH)
       && (MaxHeight >= MIN_SUPPORTED_CONSOLE_HEIGHT))
    {
      break;
    }
 
    if (mFontScale == 1) {
      break;
    }
 
    mFontScale = 1;
  }
 
  if ((mUserWidth == 0) || (mUserHeight == 0)) {
    mConsoleWidth  = MaxWidth;
    mConsoleHeight = MaxHeight;
  } else {
    mConsoleWidth  = MIN (MaxWidth, mUserWidth);
    mConsoleHeight = MIN (MaxHeight, mUserHeight);
  }
 
  mConsolePaddingX     = (Info->HorizontalResolution - (mConsoleWidth * TGT_CHAR_WIDTH)) / 2;
  mConsolePaddingY     = (Info->VerticalResolution - (mConsoleHeight * TGT_CHAR_HEIGHT)) / 2;
  mConsoleMaxPosX      = 0;
  mConsoleMaxPosY      = 0;
  mConsoleUncontrolled = FALSE;
 
  mPrivateColumn           = mPrivateRow = 0;
  This->Mode->CursorColumn = This->Mode->CursorRow = 0;
 
  //
  // Avoid rendering any console content when in graphics mode.
  //
  if (mConsoleMode == EfiConsoleControlScreenText) {
    mGraphicsOutput->Blt (
                       mGraphicsOutput,
                       &mBackgroundColor.Pixel,
                       EfiBltVideoFill,
                       0,
                       0,
                       0,
                       0,
                       Info->HorizontalResolution,
                       Info->VerticalResolution,
                       0
                       );
  }
 
  return EFI_SUCCESS;
}
 
STATIC
EFI_STATUS
EFIAPI
AsciiTextResetEx (
  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
  IN BOOLEAN                          ExtendedVerification,
  IN BOOLEAN                          Debug
  )
{
  EFI_STATUS  Status;
  EFI_TPL     OldTpl;
 
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  Status = OcHandleProtocolFallback (
             gST->ConsoleOutHandle,
             &gEfiGraphicsOutputProtocolGuid,
             (VOID **)&mGraphicsOutput
             );
 
  if (EFI_ERROR (Status)) {
    gBS->RestoreTPL (OldTpl);
    if (Debug) {
      DEBUG ((DEBUG_INFO, "OCC: ASCII Text Reset [HandleProtocolFallback] - %r\n", Status));
      return Status;
    }
 
    return EFI_DEVICE_ERROR;
  }
 
  This->Mode->MaxMode   = 1;
  This->Mode->Attribute = ARRAY_SIZE (mGraphicsEfiColors) / 2 - 1;
  mBackgroundColor.Raw  = mGraphicsEfiColors[0];
  mForegroundColor.Raw  = mGraphicsEfiColors[ARRAY_SIZE (mGraphicsEfiColors) / 2 - 1];
 
  Status = RenderResync (This);
  gBS->RestoreTPL (OldTpl);
  if (EFI_ERROR (Status)) {
    if (Debug) {
      DEBUG ((DEBUG_INFO, "OCC: ASCII Text Reset [RenderResync] - %r\n", Status));
      return Status;
    }
 
    return EFI_DEVICE_ERROR;
  }
 
  return EFI_SUCCESS;
}
 
STATIC
EFI_STATUS
EFIAPI
AsciiTextReset (
  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
  IN BOOLEAN                          ExtendedVerification
  )
{
  EFI_STATUS  Status;
 
  Status = AsciiTextResetEx (This, ExtendedVerification, FALSE);
  return Status;
}
 
STATIC
EFI_STATUS
EFIAPI
AsciiTextOutputString (
  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
  IN CHAR16                           *String
  )
{
  UINTN       Index;
  EFI_TPL     OldTpl;
  EFI_STATUS  Status;
 
  //
  // Do not print text in graphics mode.
  //
  if (mConsoleMode != EfiConsoleControlScreenText) {
    return EFI_UNSUPPORTED;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  //
  // Do not print in different modes.
  //
  if (mConsoleGopMode != mGraphicsOutput->Mode->Mode) {
    Status = RenderResync (This);
    if (EFI_ERROR (Status)) {
      gBS->RestoreTPL (OldTpl);
      return EFI_DEVICE_ERROR;
    }
  }
 
  //
  // For whatever reason UEFI Shell trashes these values when executing commands like help -b.
  //
  This->Mode->CursorColumn = (INT32)mPrivateColumn;
  This->Mode->CursorRow    = (INT32)mPrivateRow;
 
  FlushCursor (This->Mode->CursorVisible, This->Mode->CursorColumn, This->Mode->CursorRow);
 
  for (Index = 0; String[Index] != '\0'; ++Index) {
    //
    // Carriage return should just move the cursor back.
    //
    if (String[Index] == CHAR_CARRIAGE_RETURN) {
      This->Mode->CursorColumn = 0;
      continue;
    }
 
    if (String[Index] == CHAR_BACKSPACE) {
      if ((This->Mode->CursorColumn == 0) && (This->Mode->CursorRow > 0)) {
        This->Mode->CursorRow--;
        This->Mode->CursorColumn = (INT32)(mConsoleWidth - 1);
        RenderChar (' ', This->Mode->CursorColumn, This->Mode->CursorRow);
      } else if (This->Mode->CursorColumn > 0) {
        This->Mode->CursorColumn--;
        RenderChar (' ', This->Mode->CursorColumn, This->Mode->CursorRow);
      }
 
      continue;
    }
 
    //
    // Newline should move the cursor lower.
    // In case we are out of room it should scroll instead.
    //
    if (String[Index] == CHAR_LINEFEED) {
      if ((UINTN)This->Mode->CursorRow < mConsoleHeight - 1) {
        ++This->Mode->CursorRow;
        mConsoleMaxPosY = MAX (mConsoleMaxPosY, (UINTN)This->Mode->CursorRow);
      } else {
        RenderScroll ();
      }
 
      continue;
    }
 
    //
    // Render normal symbol and decide on next cursor position.
    //
    RenderChar (String[Index] == CHAR_TAB ? L' ' : String[Index], This->Mode->CursorColumn, This->Mode->CursorRow);
 
    if ((UINTN)This->Mode->CursorColumn < mConsoleWidth - 1) {
      //
      // Continues on the same line.
      //
      ++This->Mode->CursorColumn;
      mConsoleMaxPosX = MAX (mConsoleMaxPosX, (UINTN)This->Mode->CursorColumn);
    } else if ((UINTN)This->Mode->CursorRow < mConsoleHeight - 1) {
      //
      // New line without scroll.
      //
      This->Mode->CursorColumn = 0;
      ++This->Mode->CursorRow;
      mConsoleMaxPosY = MAX (mConsoleMaxPosY, (UINTN)This->Mode->CursorRow);
    } else {
      //
      // New line with scroll.
      //
      RenderScroll ();
      This->Mode->CursorColumn = 0;
    }
  }
 
  FlushCursor (This->Mode->CursorVisible, This->Mode->CursorColumn, This->Mode->CursorRow);
 
  mPrivateColumn = (UINTN)This->Mode->CursorColumn;
  mPrivateRow    = (UINTN)This->Mode->CursorRow;
 
  gBS->RestoreTPL (OldTpl);
 
  return EFI_SUCCESS;
}
 
STATIC
EFI_STATUS
EFIAPI
AsciiTextTestString (
  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
  IN CHAR16                           *String
  )
{
  if (StrCmp (String, OC_CONSOLE_MARK_UNCONTROLLED) == 0) {
    mConsoleUncontrolled = TRUE;
  }
 
  return EFI_SUCCESS;
}
 
STATIC
EFI_STATUS
EFIAPI
AsciiTextQueryMode (
  IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
  IN  UINTN                            ModeNumber,
  OUT UINTN                            *Columns,
  OUT UINTN                            *Rows
  )
{
  EFI_STATUS  Status;
  EFI_TPL     OldTpl;
 
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  if (mConsoleGopMode != mGraphicsOutput->Mode->Mode) {
    Status = RenderResync (This);
    if (EFI_ERROR (Status)) {
      gBS->RestoreTPL (OldTpl);
      return EFI_DEVICE_ERROR;
    }
  }
 
  if (ModeNumber == 0) {
    *Columns = mConsoleWidth;
    *Rows    = mConsoleHeight;
    Status   = EFI_SUCCESS;
  } else {
    Status = EFI_UNSUPPORTED;
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
STATIC
EFI_STATUS
EFIAPI
AsciiTextSetMode (
  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
  IN UINTN                            ModeNumber
  )
{
  EFI_STATUS  Status;
  EFI_TPL     OldTpl;
 
  if (ModeNumber != 0) {
    return EFI_UNSUPPORTED;
  }
 
  if (mConsoleGopMode != mGraphicsOutput->Mode->Mode) {
    OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
    Status = RenderResync (This);
    gBS->RestoreTPL (OldTpl);
    if (EFI_ERROR (Status)) {
      return EFI_DEVICE_ERROR;
    }
  }
 
  return EFI_SUCCESS;
}
 
STATIC
EFI_STATUS
EFIAPI
AsciiTextSetAttribute (
  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
  IN UINTN                            Attribute
  )
{
  EFI_STATUS  Status;
  UINT32      FgColor;
  UINT32      BgColor;
  EFI_TPL     OldTpl;
 
  if ((Attribute & ~0x7FU) != 0) {
    return EFI_UNSUPPORTED;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  if (mConsoleGopMode != mGraphicsOutput->Mode->Mode) {
    Status = RenderResync (This);
    if (EFI_ERROR (Status)) {
      gBS->RestoreTPL (OldTpl);
      return EFI_DEVICE_ERROR;
    }
  }
 
  if (Attribute != (UINTN)This->Mode->Attribute) {
    FlushCursor (This->Mode->CursorVisible, mPrivateColumn, mPrivateRow);
 
    FgColor = BitFieldRead32 ((UINT32)Attribute, 0, 3);
    BgColor = BitFieldRead32 ((UINT32)Attribute, 4, 6);
 
    //
    // Once we change the background colour, any clear screen must cover the whole screen.
    //
    if (mGraphicsEfiColors[BgColor] != mBackgroundColor.Raw) {
      mConsoleUncontrolled = TRUE;
    }
 
    mForegroundColor.Raw  = mGraphicsEfiColors[FgColor];
    mBackgroundColor.Raw  = mGraphicsEfiColors[BgColor];
    This->Mode->Attribute = (UINT32)Attribute;
 
    FlushCursor (This->Mode->CursorVisible, mPrivateColumn, mPrivateRow);
  }
 
  gBS->RestoreTPL (OldTpl);
  return EFI_SUCCESS;
}
 
//
// Note: This intentionally performs a partial screen clear, affecting only the
// area containing text which has been written using our renderer, unless console
// is marked uncontrolled prior to clearing.
//
STATIC
EFI_STATUS
EFIAPI
AsciiTextClearScreen (
  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This
  )
{
  EFI_STATUS  Status;
  UINTN       Width;
  UINTN       Height;
  EFI_TPL     OldTpl;
 
  //
  // Note: We stay marked uncontrolled, if staying in graphics mode.
  //
  if (mConsoleMode != EfiConsoleControlScreenText) {
    return EFI_UNSUPPORTED;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  //
  // No need to re-clear screen straight after resync; but note that the initial screen
  // clear after resync, although of non-zero size, is intentionally very lightweight.
  //
  if (mConsoleGopMode != mGraphicsOutput->Mode->Mode) {
    Status = RenderResync (This);
    if (EFI_ERROR (Status)) {
      gBS->RestoreTPL (OldTpl);
      return EFI_DEVICE_ERROR;
    }
  } else {
    //
    // When controlled, we assume that only text which we rendered needs to be cleared.
    // When marked uncontrolled anyone may have put content (in particular, graphics) anywhere
    // so always clear full screen.
    //
    if (mConsoleUncontrolled) {
      mGraphicsOutput->Blt (
                         mGraphicsOutput,
                         &mBackgroundColor.Pixel,
                         EfiBltVideoFill,
                         0,
                         0,
                         0,
                         0,
                         mGraphicsOutput->Mode->Info->HorizontalResolution,
                         mGraphicsOutput->Mode->Info->VerticalResolution,
                         0
                         );
 
      mConsoleUncontrolled = FALSE;
    } else {
      //
      // mConsoleMaxPosX,Y coordinates are the top left coordinates of the of the greatest
      // occupied character position. Because there is a cursor, there is always at least
      // one character position occupied.
      //
      Width  = (mConsoleMaxPosX + 1) * TGT_CHAR_WIDTH;
      Height = (mConsoleMaxPosY + 1) * TGT_CHAR_HEIGHT;
      ASSERT (TGT_PADD_WIDTH  + Width <= mGraphicsOutput->Mode->Info->HorizontalResolution);
      ASSERT (TGT_PADD_HEIGHT + Height <= mGraphicsOutput->Mode->Info->VerticalResolution);
 
      mGraphicsOutput->Blt (
                         mGraphicsOutput,
                         &mBackgroundColor.Pixel,
                         EfiBltVideoFill,
                         0,
                         0,
                         TGT_PADD_WIDTH,
                         TGT_PADD_HEIGHT,
                         Width,
                         Height,
                         0
                         );
    }
  }
 
  //
  // Handle cursor.
  //
  mPrivateColumn           = mPrivateRow = 0;
  This->Mode->CursorColumn = This->Mode->CursorRow = 0;
  FlushCursor (This->Mode->CursorVisible, mPrivateColumn, mPrivateRow);
 
  //
  // After clear screen, shell may scroll through old text via page up/down buttons,
  // but it is okay to reset max x/y here anyway, as any old text is brought on via
  // full redraw.
  //
  mConsoleMaxPosX = 0;
  mConsoleMaxPosY = 0;
 
  gBS->RestoreTPL (OldTpl);
  return EFI_SUCCESS;
}
 
STATIC
EFI_STATUS
EFIAPI
AsciiTextSetCursorPosition (
  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
  IN UINTN                            Column,
  IN UINTN                            Row
  )
{
  EFI_STATUS  Status;
  EFI_TPL     OldTpl;
 
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  if (mConsoleGopMode != mGraphicsOutput->Mode->Mode) {
    Status = RenderResync (This);
    if (EFI_ERROR (Status)) {
      gBS->RestoreTPL (OldTpl);
      return EFI_DEVICE_ERROR;
    }
  }
 
  //
  // Clamping the row here successfully works round a bug in memtest86 where it
  // does not re-read console text resolution when it changes the graphics mode.
  // If changing between text resolutions >= 80x25, the issue is only visible
  // in the position of the footer line on the text UI screen, and this fixes it.
  //
  if (Column >= mConsoleWidth) {
    Column = mConsoleWidth - 1;
  }
 
  if (Row >= mConsoleHeight) {
    Row = mConsoleHeight - 1;
  }
 
  if ((Column < mConsoleWidth) && (Row < mConsoleHeight)) {
    FlushCursor (This->Mode->CursorVisible, mPrivateColumn, mPrivateRow);
    mPrivateColumn           = Column;
    mPrivateRow              = Row;
    This->Mode->CursorColumn = (INT32)mPrivateColumn;
    This->Mode->CursorRow    = (INT32)mPrivateRow;
    FlushCursor (This->Mode->CursorVisible, mPrivateColumn, mPrivateRow);
    mConsoleMaxPosX = MAX (mConsoleMaxPosX, Column);
    mConsoleMaxPosY = MAX (mConsoleMaxPosY, Row);
    Status          = EFI_SUCCESS;
  } else {
    Status = EFI_UNSUPPORTED;
  }
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
STATIC
EFI_STATUS
EFIAPI
AsciiTextEnableCursor (
  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *This,
  IN BOOLEAN                          Visible
  )
{
  EFI_STATUS  Status;
  EFI_TPL     OldTpl;
 
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 
  if (mConsoleGopMode != mGraphicsOutput->Mode->Mode) {
    Status = RenderResync (This);
    if (EFI_ERROR (Status)) {
      gBS->RestoreTPL (OldTpl);
      return EFI_DEVICE_ERROR;
    }
  }
 
  FlushCursor (This->Mode->CursorVisible, mPrivateColumn, mPrivateRow);
  This->Mode->CursorVisible = Visible;
  FlushCursor (This->Mode->CursorVisible, mPrivateColumn, mPrivateRow);
  gBS->RestoreTPL (OldTpl);
  return EFI_SUCCESS;
}
 
STATIC
EFI_SIMPLE_TEXT_OUTPUT_MODE
  mAsciiTextOutputMode;
 
STATIC
EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL
  mAsciiTextOutputProtocol = {
  AsciiTextReset,
  AsciiTextOutputString,
  AsciiTextTestString,
  AsciiTextQueryMode,
  AsciiTextSetMode,
  AsciiTextSetAttribute,
  AsciiTextClearScreen,
  AsciiTextSetCursorPosition,
  AsciiTextEnableCursor,
  &mAsciiTextOutputMode
};
 
STATIC
EFI_STATUS
EFIAPI
ConsoleControlGetMode (
  IN   EFI_CONSOLE_CONTROL_PROTOCOL     *This,
  OUT  EFI_CONSOLE_CONTROL_SCREEN_MODE  *Mode,
  OUT  BOOLEAN                          *GopUgaExists OPTIONAL,
  OUT  BOOLEAN                          *StdInLocked  OPTIONAL
  )
{
  *Mode = mConsoleMode;
 
  if (GopUgaExists != NULL) {
    *GopUgaExists = TRUE;
  }
 
  if (StdInLocked != NULL) {
    *StdInLocked = FALSE;
  }
 
  return EFI_SUCCESS;
}
 
STATIC
EFI_STATUS
EFIAPI
ConsoleControlSetMode (
  IN EFI_CONSOLE_CONTROL_PROTOCOL     *This,
  IN EFI_CONSOLE_CONTROL_SCREEN_MODE  Mode
  )
{
  if (mConsoleMode != Mode) {
    mConsoleMode = Mode;
 
    //
    // If controlled, switching to graphics then back to text should change nothing.
    //
    if (  (mConsoleMode == EfiConsoleControlScreenText)
       && mConsoleUncontrolled)
    {
      gST->ConOut->ClearScreen (gST->ConOut);
    }
  }
 
  return EFI_SUCCESS;
}
 
STATIC
EFI_STATUS
EFIAPI
ConsoleControlLockStdIn (
  IN EFI_CONSOLE_CONTROL_PROTOCOL  *This,
  IN CHAR16                        *Password
  )
{
  return EFI_DEVICE_ERROR;
}
 
STATIC
EFI_CONSOLE_CONTROL_PROTOCOL
  mConsoleControlProtocol = {
  ConsoleControlGetMode,
  ConsoleControlSetMode,
  ConsoleControlLockStdIn
};
 
EFI_STATUS
OcUseBuiltinTextOutput (
  IN EFI_CONSOLE_CONTROL_SCREEN_MODE  InitialMode,
  IN OC_STORAGE_CONTEXT               *Storage  OPTIONAL,
  IN CONST CHAR8                      *Font     OPTIONAL,
  IN EFI_CONSOLE_CONTROL_SCREEN_MODE  Mode,
  IN UINT32                           Width,
  IN UINT32                           Height
  )
{
  EFI_STATUS                    Status;
  UINTN                         UiScaleSize;
  EFI_CONSOLE_CONTROL_PROTOCOL  OriginalConsoleControlProtocol;
 
  Status = EFI_NOT_FOUND;
  if ((Storage != NULL) && (Font != NULL) && (*Font != '\0')) {
    Status = OcLoadConsoleFont (Storage, Font, &mConsoleFont);
    DEBUG ((
      EFI_ERROR (Status) ? DEBUG_WARN : DEBUG_INFO,
      "OCC: Loading hex font %a - %r\n",
      Font,
      Status
      ));
  }
 
  if (EFI_ERROR (Status)) {
    mIsDefaultFont = TRUE;
    mConsoleFont   = &gDefaultConsoleFont;
  }
 
  UiScaleSize = sizeof (mUIScale);
 
  Status = gRT->GetVariable (
                  APPLE_UI_SCALE_VARIABLE_NAME,
                  &gAppleVendorVariableGuid,
                  NULL,
                  &UiScaleSize,
                  (VOID *)&mUIScale
                  );
 
  if (EFI_ERROR (Status) || (mUIScale != 2)) {
    mUIScale = 1;
  }
 
  mFontScale = mUIScale;
 
  DEBUG ((DEBUG_INFO, "OCC: Using builtin text renderer with %d scale\n", mUIScale));
 
  mUserWidth   = Width;
  mUserHeight  = Height;
  mConsoleMode = InitialMode;
  OcConsoleControlSetMode (Mode);
  Status = OcConsoleControlInstallProtocol (&mConsoleControlProtocol, &OriginalConsoleControlProtocol, NULL); 
  if (!EFI_ERROR (Status)) {
    Status = AsciiTextResetEx (&mAsciiTextOutputProtocol, TRUE, TRUE); 
    if (EFI_ERROR (Status)) {
      OcConsoleControlRestoreProtocol (&OriginalConsoleControlProtocol);
    } else {
      gST->ConOut    = &mAsciiTextOutputProtocol; 
      gST->Hdr.CRC32 = 0;
 
      gBS->CalculateCrc32 (
             gST,
             gST->Hdr.HeaderSize,
             &gST->Hdr.CRC32
             );
    }
  }
 
  DEBUG ((DEBUG_INFO, "OCC: Setup ASCII Output - %r\n", Status));
 
  return Status;
}