| /*++ | |
| 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; | |
| } |