tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
audk/EdkModulePkg/Universal/Console/ConSplitter/Dxe/ConSplitterGraphics.c

1077 lines
34 KiB
C
Raw Blame History

/*++
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
ConSplitterGraphics.c
Abstract:
Support for ConsoleControl protocol. Support for UGA Draw spliter.
Support for DevNull Console Out. This console uses memory buffers
to represnt the console. It allows a console to start very early and
when a new console is added it is synced up with the current console
--*/
#include "ConSplitter.h"
static CHAR16 mCrLfString[3] = { CHAR_CARRIAGE_RETURN, CHAR_LINEFEED, CHAR_NULL };
EFI_STATUS
EFIAPI
ConSpliterConsoleControlGetMode (
IN EFI_CONSOLE_CONTROL_PROTOCOL *This,
OUT EFI_CONSOLE_CONTROL_SCREEN_MODE *Mode,
OUT BOOLEAN *UgaExists,
OUT BOOLEAN *StdInLocked
)
/*++
Routine Description:
Return the current video mode information. Also returns info about existence
of UGA Draw devices in system, and if the Std In device is locked. All the
arguments are optional and only returned if a non NULL pointer is passed in.
Arguments:
This - Protocol instance pointer.
Mode - Are we in text of grahics mode.
UgaExists - TRUE if UGA Spliter has found a UGA device
StdInLocked - TRUE if StdIn device is keyboard locked
Returns:
EFI_SUCCESS - Mode information returned.
EFI_INVALID_PARAMETER - Invalid parameters.
--*/
{
TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;
UINTN Index;
Private = CONSOLE_CONTROL_SPLITTER_PRIVATE_DATA_FROM_THIS (This);
if (Mode == NULL) {
return EFI_INVALID_PARAMETER;
}
*Mode = Private->UgaMode;
if (UgaExists != NULL) {
*UgaExists = FALSE;
for (Index = 0; Index < Private->CurrentNumberOfConsoles; Index++) {
if (Private->TextOutList[Index].UgaDraw != NULL) {
*UgaExists = TRUE;
break;
}
}
}
if (StdInLocked != NULL) {
*StdInLocked = ConSpliterConssoleControlStdInLocked ();
}
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
ConSpliterConsoleControlSetMode (
IN EFI_CONSOLE_CONTROL_PROTOCOL *This,
IN EFI_CONSOLE_CONTROL_SCREEN_MODE Mode
)
/*++
Routine Description:
Set the current mode to either text or graphics. Graphics is
for Quiet Boot.
Arguments:
This - Protocol instance pointer.
Mode - Mode to set the
Returns:
EFI_SUCCESS - Mode information returned.
EFI_INVALID_PARAMETER - Invalid parameter.
EFI_UNSUPPORTED - Operation unsupported.
--*/
{
TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;
UINTN Index;
TEXT_OUT_AND_UGA_DATA *TextAndUga;
BOOLEAN Supported;
Private = CONSOLE_CONTROL_SPLITTER_PRIVATE_DATA_FROM_THIS (This);
if (Mode >= EfiConsoleControlScreenMaxValue) {
return EFI_INVALID_PARAMETER;
}
Supported = FALSE;
TextAndUga = &Private->TextOutList[0];
for (Index = 0; Index < Private->CurrentNumberOfConsoles; Index++, TextAndUga++) {
if (TextAndUga->UgaDraw != NULL) {
Supported = TRUE;
break;
}
}
if ((!Supported) && (Mode == EfiConsoleControlScreenGraphics)) {
return EFI_UNSUPPORTED;
}
Private->UgaMode = Mode;
TextAndUga = &Private->TextOutList[0];
for (Index = 0; Index < Private->CurrentNumberOfConsoles; Index++, TextAndUga++) {
TextAndUga->TextOutEnabled = TRUE;
//
// If we are going into Graphics mode disable ConOut to any UGA device
//
if ((Mode == EfiConsoleControlScreenGraphics) && (TextAndUga->UgaDraw != NULL)) {
TextAndUga->TextOutEnabled = FALSE;
DevNullUgaSync (Private, TextAndUga->UgaDraw);
}
}
if (Mode == EfiConsoleControlScreenText) {
DevNullSyncUgaStdOut (Private);
}
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
ConSpliterUgaDrawGetMode (
IN EFI_UGA_DRAW_PROTOCOL *This,
OUT UINT32 *HorizontalResolution,
OUT UINT32 *VerticalResolution,
OUT UINT32 *ColorDepth,
OUT UINT32 *RefreshRate
)
/*++
Routine Description:
Return the current video mode information.
Arguments:
This - Protocol instance pointer.
HorizontalResolution - Current video horizontal resolution in pixels
VerticalResolution - Current video vertical resolution in pixels
ColorDepth - Current video color depth in bits per pixel
RefreshRate - Current video refresh rate in Hz.
Returns:
EFI_SUCCESS - Mode information returned.
EFI_NOT_STARTED - Video display is not initialized. Call SetMode ()
EFI_INVALID_PARAMETER - One of the input args was NULL.
--*/
{
TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;
if (!(HorizontalResolution && VerticalResolution && RefreshRate && ColorDepth)) {
return EFI_INVALID_PARAMETER;
}
//
// retrieve private data
//
Private = UGA_DRAW_SPLITTER_PRIVATE_DATA_FROM_THIS (This);
*HorizontalResolution = Private->UgaHorizontalResolution;
*VerticalResolution = Private->UgaVerticalResolution;
*ColorDepth = Private->UgaColorDepth;
*RefreshRate = Private->UgaRefreshRate;
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
ConSpliterUgaDrawSetMode (
IN EFI_UGA_DRAW_PROTOCOL *This,
IN UINT32 HorizontalResolution,
IN UINT32 VerticalResolution,
IN UINT32 ColorDepth,
IN UINT32 RefreshRate
)
/*++
Routine Description:
Return the current video mode information.
Arguments:
This - Protocol instance pointer.
HorizontalResolution - Current video horizontal resolution in pixels
VerticalResolution - Current video vertical resolution in pixels
ColorDepth - Current video color depth in bits per pixel
RefreshRate - Current video refresh rate in Hz.
Returns:
EFI_SUCCESS - Mode information returned.
EFI_NOT_STARTED - Video display is not initialized. Call SetMode ()
EFI_OUT_OF_RESOURCES - Out of resources.
--*/
{
EFI_STATUS Status;
TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;
UINTN Index;
EFI_STATUS ReturnStatus;
UINTN Size;
Private = UGA_DRAW_SPLITTER_PRIVATE_DATA_FROM_THIS (This);
//
// UgaDevNullSetMode ()
//
ReturnStatus = EFI_SUCCESS;
//
// Free the old version
//
gBS->FreePool (Private->UgaBlt);
//
// Allocate the virtual Blt buffer
//
Size = HorizontalResolution * VerticalResolution * sizeof (EFI_UGA_PIXEL);
Private->UgaBlt = AllocateZeroPool (Size);
if (Private->UgaBlt == NULL) {
return EFI_OUT_OF_RESOURCES;
}
//
// Update the Mode data
//
Private->UgaHorizontalResolution = HorizontalResolution;
Private->UgaVerticalResolution = VerticalResolution;
Private->UgaColorDepth = ColorDepth;
Private->UgaRefreshRate = RefreshRate;
if (Private->UgaMode != EfiConsoleControlScreenGraphics) {
return ReturnStatus;
}
//
// return the worst status met
//
for (Index = 0; Index < Private->CurrentNumberOfConsoles; Index++) {
if (Private->TextOutList[Index].UgaDraw != NULL) {
Status = Private->TextOutList[Index].UgaDraw->SetMode (
Private->TextOutList[Index].UgaDraw,
HorizontalResolution,
VerticalResolution,
ColorDepth,
RefreshRate
);
if (EFI_ERROR (Status)) {
ReturnStatus = Status;
}
}
}
return ReturnStatus;
}
EFI_STATUS
DevNullUgaBlt (
IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private,
IN EFI_UGA_PIXEL *BltBuffer, OPTIONAL
IN EFI_UGA_BLT_OPERATION BltOperation,
IN UINTN SourceX,
IN UINTN SourceY,
IN UINTN DestinationX,
IN UINTN DestinationY,
IN UINTN Width,
IN UINTN Height,
IN UINTN Delta OPTIONAL
)
{
UINTN SrcY;
UINTN Index;
EFI_UGA_PIXEL *BltPtr;
EFI_UGA_PIXEL *ScreenPtr;
UINT32 HorizontalResolution;
UINT32 VerticalResolution;
if ((BltOperation < 0) || (BltOperation >= EfiUgaBltMax)) {
return EFI_INVALID_PARAMETER;
}
if (Width == 0 || Height == 0) {
return EFI_INVALID_PARAMETER;
}
if (Delta == 0) {
Delta = Width * sizeof (EFI_UGA_PIXEL);
}
HorizontalResolution = Private->UgaHorizontalResolution;
VerticalResolution = Private->UgaVerticalResolution;
//
// We need to fill the Virtual Screen buffer with the blt data.
//
if (BltOperation == EfiUgaVideoToBltBuffer) {
//
// Video to BltBuffer: Source is Video, destination is BltBuffer
//
if ((SourceY + Height) > VerticalResolution) {
return EFI_INVALID_PARAMETER;
}
if ((SourceX + Width) > HorizontalResolution) {
return EFI_INVALID_PARAMETER;
}
BltPtr = (EFI_UGA_PIXEL *) ((UINT8 *) BltBuffer + DestinationY * Delta + DestinationX * sizeof (EFI_UGA_PIXEL));
ScreenPtr = &Private->UgaBlt[SourceY * HorizontalResolution + SourceX];
while (Height) {
CopyMem (BltPtr, ScreenPtr, Width * sizeof (EFI_UGA_PIXEL));
BltPtr = (EFI_UGA_PIXEL *) ((UINT8 *) BltPtr + Delta);
ScreenPtr += HorizontalResolution;
Height--;
}
} else {
//
// BltBuffer to Video: Source is BltBuffer, destination is Video
//
if (DestinationY + Height > VerticalResolution) {
return EFI_INVALID_PARAMETER;
}
if (DestinationX + Width > HorizontalResolution) {
return EFI_INVALID_PARAMETER;
}
ScreenPtr = &Private->UgaBlt[DestinationY * HorizontalResolution + DestinationX];
SrcY = SourceY;
while (Height) {
if (BltOperation == EfiUgaVideoFill) {
for (Index = 0; Index < Width; Index++) {
ScreenPtr[Index] = *BltBuffer;
}
} else {
if (BltOperation == EfiUgaBltBufferToVideo) {
BltPtr = (EFI_UGA_PIXEL *) ((UINT8 *) BltBuffer + SrcY * Delta + SourceX * sizeof (EFI_UGA_PIXEL));
} else {
BltPtr = &Private->UgaBlt[SrcY * HorizontalResolution + SourceX];
}
CopyMem (ScreenPtr, BltPtr, Width * sizeof (EFI_UGA_PIXEL));
}
ScreenPtr += HorizontalResolution;
SrcY++;
Height--;
}
}
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
ConSpliterUgaDrawBlt (
IN EFI_UGA_DRAW_PROTOCOL *This,
IN EFI_UGA_PIXEL *BltBuffer, OPTIONAL
IN EFI_UGA_BLT_OPERATION BltOperation,
IN UINTN SourceX,
IN UINTN SourceY,
IN UINTN DestinationX,
IN UINTN DestinationY,
IN UINTN Width,
IN UINTN Height,
IN UINTN Delta OPTIONAL
)
/*++
Routine Description:
The following table defines actions for BltOperations:
EfiUgaVideoFill - Write data from the BltBuffer pixel (SourceX, SourceY)
directly to every pixel of the video display rectangle
(DestinationX, DestinationY)
(DestinationX + Width, DestinationY + Height).
Only one pixel will be used from the BltBuffer. Delta is NOT used.
EfiUgaVideoToBltBuffer - Read data from the video display rectangle
(SourceX, SourceY) (SourceX + Width, SourceY + Height) and place it in
the BltBuffer rectangle (DestinationX, DestinationY )
(DestinationX + Width, DestinationY + Height). If DestinationX or
DestinationY is not zero then Delta must be set to the length in bytes
of a row in the BltBuffer.
EfiUgaBltBufferToVideo - Write data from the BltBuffer rectangle
(SourceX, SourceY) (SourceX + Width, SourceY + Height) directly to the
video display rectangle (DestinationX, DestinationY)
(DestinationX + Width, DestinationY + Height). If SourceX or SourceY is
not zero then Delta must be set to the length in bytes of a row in the
BltBuffer.
EfiUgaVideoToVideo - Copy from the video display rectangle
(SourceX, SourceY) (SourceX + Width, SourceY + Height) .
to the video display rectangle (DestinationX, DestinationY)
(DestinationX + Width, DestinationY + Height).
The BltBuffer and Delta are not used in this mode.
Arguments:
This - Protocol instance pointer.
BltBuffer - Buffer containing data to blit into video buffer. This
buffer has a size of Width*Height*sizeof(EFI_UGA_PIXEL)
BltOperation - Operation to perform on BlitBuffer and video memory
SourceX - X coordinate of source for the BltBuffer.
SourceY - Y coordinate of source for the BltBuffer.
DestinationX - X coordinate of destination for the BltBuffer.
DestinationY - Y coordinate of destination for the BltBuffer.
Width - Width of rectangle in BltBuffer in pixels.
Height - Hight of rectangle in BltBuffer in pixels.
Delta -
Returns:
EFI_SUCCESS - The Blt operation completed.
EFI_INVALID_PARAMETER - BltOperation is not valid.
EFI_DEVICE_ERROR - A hardware error occured writting to the video
buffer.
--*/
{
EFI_STATUS Status;
TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;
UINTN Index;
EFI_STATUS ReturnStatus;
Private = UGA_DRAW_SPLITTER_PRIVATE_DATA_FROM_THIS (This);
//
// Sync up DevNull UGA device
//
ReturnStatus = DevNullUgaBlt (
Private,
BltBuffer,
BltOperation,
SourceX,
SourceY,
DestinationX,
DestinationY,
Width,
Height,
Delta
);
if (Private->UgaMode != EfiConsoleControlScreenGraphics) {
return ReturnStatus;
}
//
// return the worst status met
//
for (Index = 0; Index < Private->CurrentNumberOfConsoles; Index++) {
if (Private->TextOutList[Index].UgaDraw != NULL) {
Status = Private->TextOutList[Index].UgaDraw->Blt (
Private->TextOutList[Index].UgaDraw,
BltBuffer,
BltOperation,
SourceX,
SourceY,
DestinationX,
DestinationY,
Width,
Height,
Delta
);
if (EFI_ERROR (Status)) {
ReturnStatus = Status;
} else if (BltOperation == EfiUgaVideoToBltBuffer) {
//
// Only need to read the data into buffer one time
//
return EFI_SUCCESS;
}
}
}
return ReturnStatus;
}
EFI_STATUS
DevNullUgaSync (
IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private,
IN EFI_UGA_DRAW_PROTOCOL *UgaDraw
)
{
return UgaDraw->Blt (
UgaDraw,
Private->UgaBlt,
EfiUgaBltBufferToVideo,
0,
0,
0,
0,
Private->UgaHorizontalResolution,
Private->UgaVerticalResolution,
Private->UgaHorizontalResolution * sizeof (EFI_UGA_PIXEL)
);
}
EFI_STATUS
DevNullTextOutOutputString (
IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private,
IN CHAR16 *WString
)
/*++
Routine Description:
Write a Unicode string to the output device.
Arguments:
Private - Pointer to the console output splitter's private data. It
indicates the calling context.
WString - The NULL-terminated Unicode string to be displayed on the output
device(s). All output devices must also support the Unicode
drawing defined in this file.
Returns:
EFI_SUCCESS - The string was output to the device.
EFI_DEVICE_ERROR - The device reported an error while attempting to
output the text.
EFI_UNSUPPORTED - The output device's mode is not currently in a
defined text mode.
EFI_WARN_UNKNOWN_GLYPH - This warning code indicates that some of the
characters in the Unicode string could not be
rendered and were skipped.
--*/
{
UINTN SizeScreen;
UINTN SizeAttribute;
UINTN Index;
EFI_SIMPLE_TEXT_OUTPUT_MODE *Mode;
CHAR16 *Screen;
CHAR16 *NullScreen;
CHAR16 InsertChar;
CHAR16 TempChar;
CHAR16 *PStr;
INT32 *Attribute;
INT32 *NullAttributes;
INT32 CurrentWidth;
UINTN LastRow;
UINTN MaxColumn;
Mode = &Private->TextOutMode;
NullScreen = Private->DevNullScreen;
NullAttributes = Private->DevNullAttributes;
LastRow = Private->DevNullRows - 1;
MaxColumn = Private->DevNullColumns;
if (Mode->Attribute & EFI_WIDE_ATTRIBUTE) {
CurrentWidth = 2;
} else {
CurrentWidth = 1;
}
while (*WString) {
if (*WString == CHAR_BACKSPACE) {
//
// If the cursor is at the left edge of the display, then move the cursor
// one row up.
//
if (Mode->CursorColumn == 0 && Mode->CursorRow > 0) {
Mode->CursorRow--;
Mode->CursorColumn = (INT32) MaxColumn;
}
//
// If the cursor is not at the left edge of the display,
// then move the cursor left one column.
//
if (Mode->CursorColumn > 0) {
Mode->CursorColumn--;
if (Mode->CursorColumn > 0 &&
NullAttributes[Mode->CursorRow * MaxColumn + Mode->CursorColumn - 1] & EFI_WIDE_ATTRIBUTE
) {
Mode->CursorColumn--;
//
// Insert an extra backspace
//
InsertChar = CHAR_BACKSPACE;
PStr = WString + 1;
while (*PStr) {
TempChar = *PStr;
*PStr = InsertChar;
InsertChar = TempChar;
PStr++;
}
*PStr = InsertChar;
*(++PStr) = 0;
WString++;
}
}
WString++;
} else if (*WString == CHAR_LINEFEED) {
//
// If the cursor is at the bottom of the display,
// then scroll the display one row, and do not update
// the cursor position. Otherwise, move the cursor down one row.
//
if (Mode->CursorRow == (INT32) (LastRow)) {
//
// Scroll Screen Up One Row
//
SizeAttribute = LastRow * MaxColumn;
CopyMem (
NullAttributes,
NullAttributes + MaxColumn,
SizeAttribute * sizeof (INT32)
);
//
// Each row has an ending CHAR_NULL. So one more character each line
// for DevNullScreen than DevNullAttributes
//
SizeScreen = SizeAttribute + LastRow;
CopyMem (
NullScreen,
NullScreen + (MaxColumn + 1),
SizeScreen * sizeof (CHAR16)
);
//
// Print Blank Line at last line
//
Screen = NullScreen + SizeScreen;
Attribute = NullAttributes + SizeAttribute;
for (Index = 0; Index < MaxColumn; Index++, Screen++, Attribute++) {
*Screen = ' ';
*Attribute = Mode->Attribute;
}
} else {
Mode->CursorRow++;
}
WString++;
} else if (*WString == CHAR_CARRIAGE_RETURN) {
//
// Move the cursor to the beginning of the current row.
//
Mode->CursorColumn = 0;
WString++;
} else {
//
// Print the character at the current cursor position and
// move the cursor right one column. If this moves the cursor
// past the right edge of the display, then the line should wrap to
// the beginning of the next line. This is equivalent to inserting
// a CR and an LF. Note that if the cursor is at the bottom of the
// display, and the line wraps, then the display will be scrolled
// one line.
//
Index = Mode->CursorRow * MaxColumn + Mode->CursorColumn;
while (Mode->CursorColumn < (INT32) MaxColumn) {
if (*WString == CHAR_NULL) {
break;
}
if (*WString == CHAR_BACKSPACE) {
break;
}
if (*WString == CHAR_LINEFEED) {
break;
}
if (*WString == CHAR_CARRIAGE_RETURN) {
break;
}
if (*WString == WIDE_CHAR || *WString == NARROW_CHAR) {
CurrentWidth = (*WString == WIDE_CHAR) ? 2 : 1;
WString++;
continue;
}
if (Mode->CursorColumn + CurrentWidth > (INT32) MaxColumn) {
//
// If a wide char is at the rightmost column, then move the char
// to the beginning of the next row
//
NullScreen[Index + Mode->CursorRow] = L' ';
NullAttributes[Index] = Mode->Attribute | (UINT32) EFI_WIDE_ATTRIBUTE;
Index++;
Mode->CursorColumn++;
} else {
NullScreen[Index + Mode->CursorRow] = *WString;
NullAttributes[Index] = Mode->Attribute;
if (CurrentWidth == 1) {
NullAttributes[Index] &= (~ (UINT32) EFI_WIDE_ATTRIBUTE);
} else {
NullAttributes[Index] |= (UINT32) EFI_WIDE_ATTRIBUTE;
NullAttributes[Index + 1] &= (~ (UINT32) EFI_WIDE_ATTRIBUTE);
}
Index += CurrentWidth;
WString++;
Mode->CursorColumn += CurrentWidth;
}
}
//
// At the end of line, output carriage return and line feed
//
if (Mode->CursorColumn >= (INT32) MaxColumn) {
DevNullTextOutOutputString (Private, mCrLfString);
}
}
}
return EFI_SUCCESS;
}
EFI_STATUS
DevNullTextOutSetMode (
IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private,
IN UINTN ModeNumber
)
/*++
Routine Description:
Sets the output device(s) to a specified mode.
Arguments:
Private - Private data structure pointer.
ModeNumber - The mode number to set.
Returns:
EFI_SUCCESS - The requested text mode was set.
EFI_DEVICE_ERROR - The device had an error and
could not complete the request.
EFI_UNSUPPORTED - The mode number was not valid.
EFI_OUT_OF_RESOURCES - Out of resources.
--*/
{
UINTN Size;
UINTN Row;
UINTN Column;
TEXT_OUT_SPLITTER_QUERY_DATA *Mode;
//
// No extra check for ModeNumber here, as it has been checked in
// ConSplitterTextOutSetMode. And mode 0 should always be supported.
//
Mode = &(Private->TextOutQueryData[ModeNumber]);
Row = Mode->Rows;
Column = Mode->Columns;
if (Row <= 0 && Column <= 0) {
return EFI_UNSUPPORTED;
}
if (Private->DevNullColumns != Column || Private->DevNullRows != Row) {
Private->TextOutMode.Mode = (INT32) ModeNumber;
Private->DevNullColumns = Column;
Private->DevNullRows = Row;
gBS->FreePool (Private->DevNullScreen);
Size = (Row * (Column + 1)) * sizeof (CHAR16);
Private->DevNullScreen = AllocateZeroPool (Size);
if (Private->DevNullScreen == NULL) {
return EFI_OUT_OF_RESOURCES;
}
gBS->FreePool (Private->DevNullAttributes);
Size = Row * Column * sizeof (INT32);
Private->DevNullAttributes = AllocateZeroPool (Size);
if (Private->DevNullAttributes == NULL) {
return EFI_OUT_OF_RESOURCES;
}
}
DevNullTextOutClearScreen (Private);
return EFI_SUCCESS;
}
EFI_STATUS
DevNullTextOutClearScreen (
IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private
)
/*++
Routine Description:
Clears the output device(s) display to the currently selected background
color.
Arguments:
Private - Protocol instance pointer.
Returns:
EFI_SUCCESS - The operation completed successfully.
EFI_DEVICE_ERROR - The device had an error and
could not complete the request.
EFI_UNSUPPORTED - The output device is not in a valid text mode.
--*/
{
UINTN Row;
UINTN Column;
CHAR16 *Screen;
INT32 *Attributes;
INT32 CurrentAttribute;
//
// Clear the DevNull Text Out Buffers.
// The screen is filled with spaces.
// The attributes are all synced with the current Simple Text Out Attribute
//
Screen = Private->DevNullScreen;
Attributes = Private->DevNullAttributes;
CurrentAttribute = Private->TextOutMode.Attribute;
for (Row = 0; Row < Private->DevNullRows; Row++) {
for (Column = 0; Column < Private->DevNullColumns; Column++, Screen++, Attributes++) {
*Screen = ' ';
*Attributes = CurrentAttribute;
}
//
// Each line of the screen has a NULL on the end so we must skip over it
//
Screen++;
}
DevNullTextOutSetCursorPosition (Private, 0, 0);
return DevNullTextOutEnableCursor (Private, TRUE);
}
EFI_STATUS
DevNullTextOutSetCursorPosition (
IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private,
IN UINTN Column,
IN UINTN Row
)
/*++
Routine Description:
Sets the current coordinates of the cursor position
Arguments:
Private - Protocol instance pointer.
Column, Row - the position to set the cursor to. Must be greater than or
equal to zero and less than the number of columns and rows
by QueryMode ().
Returns:
EFI_SUCCESS - The operation completed successfully.
EFI_DEVICE_ERROR - The device had an error and
could not complete the request.
EFI_UNSUPPORTED - The output device is not in a valid text mode, or the
cursor position is invalid for the current mode.
--*/
{
//
// No need to do extra check here as whether (Column, Row) is valid has
// been checked in ConSplitterTextOutSetCursorPosition. And (0, 0) should
// always be supported.
//
Private->TextOutMode.CursorColumn = (INT32) Column;
Private->TextOutMode.CursorRow = (INT32) Row;
return EFI_SUCCESS;
}
EFI_STATUS
DevNullTextOutEnableCursor (
IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private,
IN BOOLEAN Visible
)
/*++
Routine Description:
Implements SIMPLE_TEXT_OUTPUT.EnableCursor().
In this driver, the cursor cannot be hidden.
Arguments:
Private - Indicates the calling context.
Visible - If TRUE, the cursor is set to be visible, If FALSE, the cursor
is set to be invisible.
Returns:
EFI_SUCCESS - The request is valid.
--*/
{
Private->TextOutMode.CursorVisible = Visible;
return EFI_SUCCESS;
}
EFI_STATUS
DevNullSyncUgaStdOut (
IN TEXT_OUT_SPLITTER_PRIVATE_DATA *Private
)
/*++
Routine Description:
Take the DevNull TextOut device and update the Simple Text Out on every
UGA device.
Arguments:
Private - Indicates the calling context.
Returns:
EFI_SUCCESS - The request is valid.
other - Return status of TextOut->OutputString ()
--*/
{
EFI_STATUS Status;
EFI_STATUS ReturnStatus;
UINTN Row;
UINTN Column;
UINTN List;
UINTN MaxColumn;
UINTN CurrentColumn;
UINTN StartRow;
UINTN StartColumn;
INT32 StartAttribute;
BOOLEAN StartCursorState;
CHAR16 *Screen;
CHAR16 *Str;
CHAR16 *Buffer;
CHAR16 *BufferTail;
CHAR16 *ScreenStart;
INT32 CurrentAttribute;
INT32 *Attributes;
EFI_SIMPLE_TEXT_OUT_PROTOCOL *Sto;
//
// Save the devices Attributes, Cursor enable state and location
//
StartColumn = Private->TextOutMode.CursorColumn;
StartRow = Private->TextOutMode.CursorRow;
StartAttribute = Private->TextOutMode.Attribute;
StartCursorState = Private->TextOutMode.CursorVisible;
for (List = 0; List < Private->CurrentNumberOfConsoles; List++) {
Sto = Private->TextOutList[List].TextOut;
//
// Skip non UGA devices
//
if (Private->TextOutList[List].UgaDraw != NULL) {
Sto->EnableCursor (Sto, FALSE);
Sto->ClearScreen (Sto);
}
}
ReturnStatus = EFI_SUCCESS;
Screen = Private->DevNullScreen;
Attributes = Private->DevNullAttributes;
MaxColumn = Private->DevNullColumns;
Buffer = AllocateZeroPool ((MaxColumn + 1) * sizeof (CHAR16));
for (Row = 0; Row < Private->DevNullRows; Row++, Screen += (MaxColumn + 1), Attributes += MaxColumn) {
if (Row == (Private->DevNullRows - 1)) {
//
// Don't ever sync the last character as it will scroll the screen
//
Screen[MaxColumn - 1] = 0x00;
}
Column = 0;
while (Column < MaxColumn) {
if (Screen[Column]) {
CurrentAttribute = Attributes[Column];
CurrentColumn = Column;
ScreenStart = &Screen[Column];
//
// the line end is alway 0x0. So Column should be less than MaxColumn
// It should be still in the same row
//
for (Str = ScreenStart, BufferTail = Buffer; *Str != 0; Str++, Column++) {
if (Attributes[Column] != CurrentAttribute) {
Column--;
break;
}
*BufferTail = *Str;
BufferTail++;
if (Attributes[Column] & EFI_WIDE_ATTRIBUTE) {
Str++;
Column++;
}
}
*BufferTail = 0;
for (List = 0; List < Private->CurrentNumberOfConsoles; List++) {
Sto = Private->TextOutList[List].TextOut;
//
// Skip non UGA devices
//
if (Private->TextOutList[List].UgaDraw != NULL) {
Sto->SetAttribute (Sto, CurrentAttribute);
Sto->SetCursorPosition (Sto, CurrentColumn, Row);
Status = Sto->OutputString (Sto, Buffer);
if (EFI_ERROR (Status)) {
ReturnStatus = Status;
}
}
}
}
Column++;
}
}
//
// Restore the devices Attributes, Cursor enable state and location
//
for (List = 0; List < Private->CurrentNumberOfConsoles; List++) {
Sto = Private->TextOutList[List].TextOut;
//
// Skip non UGA devices
//
if (Private->TextOutList[List].UgaDraw != NULL) {
Sto->SetAttribute (Sto, StartAttribute);
Sto->SetCursorPosition (Sto, StartColumn, StartRow);
Status = Sto->EnableCursor (Sto, StartCursorState);
if (EFI_ERROR (Status)) {
ReturnStatus = Status;
}
}
}
gBS->FreePool (Buffer);
return ReturnStatus;
}
Reference in New Issue View Git Blame Copy Permalink