mirror of https://github.com/acidanthera/audk.git
760 lines
17 KiB
C
760 lines
17 KiB
C
/** @file
|
|
Simple Console that sits on a SerialLib.
|
|
|
|
Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
|
|
|
|
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.
|
|
|
|
**/
|
|
|
|
/*
|
|
Symbols used in table below
|
|
===========================
|
|
ESC = 0x1B
|
|
CSI = 0x9B
|
|
DEL = 0x7f
|
|
^ = CTRL
|
|
|
|
+=========+======+===========+==========+==========+
|
|
| | EFI | UEFI 2.0 | | |
|
|
| | Scan | | VT100+ | |
|
|
| KEY | Code | PC ANSI | VTUTF8 | VT100 |
|
|
+=========+======+===========+==========+==========+
|
|
| NULL | 0x00 | | | |
|
|
| UP | 0x01 | ESC [ A | ESC [ A | ESC [ A |
|
|
| DOWN | 0x02 | ESC [ B | ESC [ B | ESC [ B |
|
|
| RIGHT | 0x03 | ESC [ C | ESC [ C | ESC [ C |
|
|
| LEFT | 0x04 | ESC [ D | ESC [ D | ESC [ D |
|
|
| HOME | 0x05 | ESC [ H | ESC h | ESC [ H |
|
|
| END | 0x06 | ESC [ F | ESC k | ESC [ K |
|
|
| INSERT | 0x07 | ESC [ @ | ESC + | ESC [ @ |
|
|
| | | ESC [ L | | ESC [ L |
|
|
| DELETE | 0x08 | ESC [ X | ESC - | ESC [ P |
|
|
| PG UP | 0x09 | ESC [ I | ESC ? | ESC [ V |
|
|
| | | | | ESC [ ? |
|
|
| PG DOWN | 0x0A | ESC [ G | ESC / | ESC [ U |
|
|
| | | | | ESC [ / |
|
|
| F1 | 0x0B | ESC [ M | ESC 1 | ESC O P |
|
|
| F2 | 0x0C | ESC [ N | ESC 2 | ESC O Q |
|
|
| F3 | 0x0D | ESC [ O | ESC 3 | ESC O w |
|
|
| F4 | 0x0E | ESC [ P | ESC 4 | ESC O x |
|
|
| F5 | 0x0F | ESC [ Q | ESC 5 | ESC O t |
|
|
| F6 | 0x10 | ESC [ R | ESC 6 | ESC O u |
|
|
| F7 | 0x11 | ESC [ S | ESC 7 | ESC O q |
|
|
| F8 | 0x12 | ESC [ T | ESC 8 | ESC O r |
|
|
| F9 | 0x13 | ESC [ U | ESC 9 | ESC O p |
|
|
| F10 | 0x14 | ESC [ V | ESC 0 | ESC O M |
|
|
| Escape | 0x17 | ESC | ESC | ESC |
|
|
| F11 | 0x15 | | ESC ! | |
|
|
| F12 | 0x16 | | ESC @ | |
|
|
+=========+======+===========+==========+==========+
|
|
|
|
*/
|
|
|
|
#include <PiDxe.h>
|
|
#include <Library/UefiLib.h>
|
|
#include <Library/UefiBootServicesTableLib.h>
|
|
#include <Library/BaseLib.h>
|
|
#include <Library/MemoryAllocationLib.h>
|
|
#include <Library/DebugLib.h>
|
|
#include <Library/SerialPortLib.h>
|
|
#include <Library/PcdLib.h>
|
|
|
|
#include <Protocol/SerialIo.h>
|
|
#include <Protocol/SimpleTextIn.h>
|
|
#include <Protocol/SimpleTextOut.h>
|
|
#include <Protocol/DevicePath.h>
|
|
|
|
|
|
#define MODE0_COLUMN_COUNT 80
|
|
#define MODE0_ROW_COUNT 25
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
TextInReset(
|
|
IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This,
|
|
IN BOOLEAN ExtendedVerification
|
|
);
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
ReadKeyStroke(
|
|
IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This,
|
|
OUT EFI_INPUT_KEY *Key
|
|
);
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
TextOutReset(
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN BOOLEAN ExtendedVerification
|
|
);
|
|
|
|
CHAR8 *
|
|
EFIAPI
|
|
SafeUnicodeStrToAsciiStr (
|
|
IN CONST CHAR16 *Source,
|
|
OUT CHAR8 *Destination
|
|
);
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
OutputString (
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN CHAR16 *String
|
|
);
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
TestString (
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN CHAR16 *String
|
|
);
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
QueryMode (
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN UINTN ModeNumber,
|
|
OUT UINTN *Columns,
|
|
OUT UINTN *Rows
|
|
);
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
SetMode(
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN UINTN ModeNumber
|
|
);
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
SetAttribute(
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN UINTN Attribute
|
|
);
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
ClearScreen (
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This
|
|
);
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
SetCursorPosition (
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN UINTN Column,
|
|
IN UINTN Row
|
|
);
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
EnableCursor (
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN BOOLEAN Enable
|
|
);
|
|
|
|
|
|
EFI_SIMPLE_TEXT_INPUT_PROTOCOL mSimpleTextIn = {
|
|
TextInReset,
|
|
ReadKeyStroke,
|
|
NULL
|
|
};
|
|
|
|
EFI_SIMPLE_TEXT_OUTPUT_MODE mSimpleTextOutMode = {
|
|
1,
|
|
0,
|
|
EFI_TEXT_ATTR( EFI_LIGHTGRAY, EFI_BLACK ),
|
|
0,
|
|
0,
|
|
TRUE
|
|
};
|
|
|
|
EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL mSimpleTextOut = {
|
|
TextOutReset,
|
|
OutputString,
|
|
TestString,
|
|
QueryMode,
|
|
SetMode,
|
|
SetAttribute,
|
|
ClearScreen,
|
|
SetCursorPosition,
|
|
EnableCursor,
|
|
&mSimpleTextOutMode
|
|
};
|
|
|
|
EFI_HANDLE mInstallHandle = NULL;
|
|
|
|
typedef struct {
|
|
VENDOR_DEVICE_PATH Guid;
|
|
UART_DEVICE_PATH Uart;
|
|
EFI_DEVICE_PATH_PROTOCOL End;
|
|
} SIMPLE_TEXT_OUT_DEVICE_PATH;
|
|
|
|
SIMPLE_TEXT_OUT_DEVICE_PATH mDevicePath = {
|
|
{
|
|
{ HARDWARE_DEVICE_PATH, HW_VENDOR_DP, { sizeof (VENDOR_DEVICE_PATH), 0} },
|
|
EFI_CALLER_ID_GUID
|
|
},
|
|
{
|
|
{ MESSAGING_DEVICE_PATH, MSG_UART_DP, { sizeof (UART_DEVICE_PATH), 0} },
|
|
0, // Reserved
|
|
FixedPcdGet64 (PcdUartDefaultBaudRate), // BaudRate
|
|
FixedPcdGet8 (PcdUartDefaultDataBits), // DataBits
|
|
FixedPcdGet8 (PcdUartDefaultParity), // Parity (N)
|
|
FixedPcdGet8 (PcdUartDefaultStopBits) // StopBits
|
|
},
|
|
{ END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0} }
|
|
};
|
|
|
|
|
|
|
|
|
|
BOOLEAN
|
|
TextOutIsValidAscii (
|
|
IN CHAR16 Ascii
|
|
)
|
|
{
|
|
//
|
|
// valid ASCII code lies in the extent of 0x20 - 0x7F
|
|
//
|
|
if ((Ascii >= 0x20) && (Ascii <= 0x7F)) {
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
TextOutIsValidEfiCntlChar (
|
|
IN CHAR16 Char
|
|
)
|
|
{
|
|
//
|
|
// only support four control characters.
|
|
//
|
|
if (Char == CHAR_NULL ||
|
|
Char == CHAR_BACKSPACE ||
|
|
Char == CHAR_LINEFEED ||
|
|
Char == CHAR_CARRIAGE_RETURN ||
|
|
Char == CHAR_TAB ) {
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
VOID
|
|
EFIAPI
|
|
WaitForKeyEvent (
|
|
IN EFI_EVENT Event,
|
|
IN VOID *Context
|
|
)
|
|
{
|
|
if (SerialPortPoll ()) {
|
|
gBS->SignalEvent (Event);
|
|
}
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
TextInReset (
|
|
IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This,
|
|
IN BOOLEAN ExtendedVerification
|
|
)
|
|
{
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
ReadKeyStroke (
|
|
IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This,
|
|
OUT EFI_INPUT_KEY *Key
|
|
)
|
|
{
|
|
CHAR8 Char;
|
|
|
|
if (!SerialPortPoll ()) {
|
|
return EFI_NOT_READY;
|
|
}
|
|
|
|
SerialPortRead ((UINT8 *)&Char, 1);
|
|
|
|
//
|
|
// Check for ESC sequence. This code is not techincally correct VT100 code.
|
|
// An illegal ESC sequence represents an ESC and the characters that follow.
|
|
// This code will eat one or two chars after an escape. This is done to
|
|
// prevent some complex FIFOing of the data. It is good enough to get
|
|
// the arrow and delete keys working
|
|
//
|
|
Key->UnicodeChar = 0;
|
|
Key->ScanCode = SCAN_NULL;
|
|
if (Char == 0x1b) {
|
|
SerialPortRead ((UINT8 *)&Char, 1);
|
|
if (Char == '[') {
|
|
SerialPortRead ((UINT8 *)&Char, 1);
|
|
switch (Char) {
|
|
case 'A':
|
|
Key->ScanCode = SCAN_UP;
|
|
break;
|
|
case 'B':
|
|
Key->ScanCode = SCAN_DOWN;
|
|
break;
|
|
case 'C':
|
|
Key->ScanCode = SCAN_RIGHT;
|
|
break;
|
|
case 'D':
|
|
Key->ScanCode = SCAN_LEFT;
|
|
break;
|
|
case 'H':
|
|
Key->ScanCode = SCAN_HOME;
|
|
break;
|
|
case 'K':
|
|
case 'F': // PC ANSI
|
|
Key->ScanCode = SCAN_END;
|
|
break;
|
|
case '@':
|
|
case 'L':
|
|
Key->ScanCode = SCAN_INSERT;
|
|
break;
|
|
case 'P':
|
|
case 'X': // PC ANSI
|
|
Key->ScanCode = SCAN_DELETE;
|
|
break;
|
|
case 'U':
|
|
case '/':
|
|
case 'G': // PC ANSI
|
|
Key->ScanCode = SCAN_PAGE_DOWN;
|
|
break;
|
|
case 'V':
|
|
case '?':
|
|
case 'I': // PC ANSI
|
|
Key->ScanCode = SCAN_PAGE_UP;
|
|
break;
|
|
|
|
// PCANSI that does not conflict with VT100
|
|
case 'M':
|
|
Key->ScanCode = SCAN_F1;
|
|
break;
|
|
case 'N':
|
|
Key->ScanCode = SCAN_F2;
|
|
break;
|
|
case 'O':
|
|
Key->ScanCode = SCAN_F3;
|
|
break;
|
|
case 'Q':
|
|
Key->ScanCode = SCAN_F5;
|
|
break;
|
|
case 'R':
|
|
Key->ScanCode = SCAN_F6;
|
|
break;
|
|
case 'S':
|
|
Key->ScanCode = SCAN_F7;
|
|
break;
|
|
case 'T':
|
|
Key->ScanCode = SCAN_F8;
|
|
break;
|
|
|
|
default:
|
|
Key->UnicodeChar = Char;
|
|
break;
|
|
}
|
|
} else if (Char == '0') {
|
|
SerialPortRead ((UINT8 *)&Char, 1);
|
|
switch (Char) {
|
|
case 'P':
|
|
Key->ScanCode = SCAN_F1;
|
|
break;
|
|
case 'Q':
|
|
Key->ScanCode = SCAN_F2;
|
|
break;
|
|
case 'w':
|
|
Key->ScanCode = SCAN_F3;
|
|
break;
|
|
case 'x':
|
|
Key->ScanCode = SCAN_F4;
|
|
break;
|
|
case 't':
|
|
Key->ScanCode = SCAN_F5;
|
|
break;
|
|
case 'u':
|
|
Key->ScanCode = SCAN_F6;
|
|
break;
|
|
case 'q':
|
|
Key->ScanCode = SCAN_F7;
|
|
break;
|
|
case 'r':
|
|
Key->ScanCode = SCAN_F8;
|
|
break;
|
|
case 'p':
|
|
Key->ScanCode = SCAN_F9;
|
|
break;
|
|
case 'm':
|
|
Key->ScanCode = SCAN_F10;
|
|
break;
|
|
default :
|
|
break;
|
|
}
|
|
}
|
|
} else if (Char < ' ') {
|
|
if ((Char == CHAR_BACKSPACE) ||
|
|
(Char == CHAR_TAB) ||
|
|
(Char == CHAR_LINEFEED) ||
|
|
(Char == CHAR_CARRIAGE_RETURN)) {
|
|
// Only let through EFI required control characters
|
|
Key->UnicodeChar = (CHAR16)Char;
|
|
}
|
|
} else if (Char == 0x7f) {
|
|
Key->ScanCode = SCAN_DELETE;
|
|
} else {
|
|
Key->UnicodeChar = (CHAR16)Char;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
TextOutReset (
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN BOOLEAN ExtendedVerification
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
|
|
This->SetAttribute(
|
|
This,
|
|
EFI_TEXT_ATTR(This->Mode->Attribute & 0x0F, EFI_BACKGROUND_BLACK)
|
|
);
|
|
|
|
Status = This->SetMode (This, 0);
|
|
|
|
return Status;
|
|
}
|
|
|
|
CHAR8 *
|
|
EFIAPI
|
|
SafeUnicodeStrToAsciiStr (
|
|
IN CONST CHAR16 *Source,
|
|
OUT CHAR8 *Destination
|
|
)
|
|
{
|
|
CHAR8 *ReturnValue;
|
|
|
|
ASSERT (Destination != NULL);
|
|
|
|
//
|
|
// ASSERT if Source is long than PcdMaximumUnicodeStringLength.
|
|
// Length tests are performed inside StrLen().
|
|
//
|
|
ASSERT (StrSize (Source) != 0);
|
|
|
|
//
|
|
// Source and Destination should not overlap
|
|
//
|
|
ASSERT ((UINTN) ((CHAR16 *) Destination - Source) > StrLen (Source));
|
|
ASSERT ((UINTN) ((CHAR8 *) Source - Destination) > StrLen (Source));
|
|
|
|
|
|
ReturnValue = Destination;
|
|
while (*Source != '\0') {
|
|
//
|
|
// If any non-ascii characters in Source then replace it with '?'.
|
|
//
|
|
if (*Source < 0x80) {
|
|
*Destination = (CHAR8) *Source;
|
|
} else {
|
|
*Destination = '?';
|
|
|
|
//Surrogate pair check.
|
|
if ((*Source >= 0xD800) && (*Source <= 0xDFFF)) {
|
|
Source++;
|
|
}
|
|
}
|
|
|
|
Destination++;
|
|
Source++;
|
|
}
|
|
|
|
*Destination = '\0';
|
|
|
|
//
|
|
// ASSERT Original Destination is less long than PcdMaximumAsciiStringLength.
|
|
// Length tests are performed inside AsciiStrLen().
|
|
//
|
|
ASSERT (AsciiStrSize (ReturnValue) != 0);
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
OutputString (
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN CHAR16 *String
|
|
)
|
|
{
|
|
UINTN Size;
|
|
CHAR8* OutputString;
|
|
EFI_STATUS Status;
|
|
EFI_SIMPLE_TEXT_OUTPUT_MODE *Mode;
|
|
UINTN MaxColumn;
|
|
UINTN MaxRow;
|
|
|
|
Size = StrLen(String) + 1;
|
|
OutputString = AllocatePool(Size);
|
|
|
|
//If there is any non-ascii characters in String buffer then replace it with '?'
|
|
//Eventually, UnicodeStrToAsciiStr API should be fixed.
|
|
SafeUnicodeStrToAsciiStr(String, OutputString);
|
|
SerialPortWrite ((UINT8 *)OutputString, Size - 1);
|
|
|
|
//
|
|
// Parse each character of the string to output
|
|
// to update the cursor position information
|
|
//
|
|
Mode = This->Mode;
|
|
|
|
Status = This->QueryMode (
|
|
This,
|
|
Mode->Mode,
|
|
&MaxColumn,
|
|
&MaxRow
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
for (; *String != CHAR_NULL; String++) {
|
|
|
|
switch (*String) {
|
|
case CHAR_BACKSPACE:
|
|
if (Mode->CursorColumn > 0) {
|
|
Mode->CursorColumn--;
|
|
}
|
|
break;
|
|
|
|
case CHAR_LINEFEED:
|
|
if (Mode->CursorRow < (INT32) (MaxRow - 1)) {
|
|
Mode->CursorRow++;
|
|
}
|
|
break;
|
|
|
|
case CHAR_CARRIAGE_RETURN:
|
|
Mode->CursorColumn = 0;
|
|
break;
|
|
|
|
default:
|
|
if (Mode->CursorColumn >= (INT32) (MaxColumn - 1)) {
|
|
// Move the cursor as if we print CHAR_CARRIAGE_RETURN & CHAR_LINE_FEED
|
|
// CHAR_LINEFEED
|
|
if (Mode->CursorRow < (INT32) (MaxRow - 1)) {
|
|
Mode->CursorRow++;
|
|
}
|
|
// CHAR_CARIAGE_RETURN
|
|
Mode->CursorColumn = 0;
|
|
} else {
|
|
Mode->CursorColumn++;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
FreePool(OutputString);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
TestString (
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN CHAR16 *String
|
|
)
|
|
{
|
|
CHAR8 Character;
|
|
|
|
for ( ; *String != CHAR_NULL; String++) {
|
|
Character = (CHAR8)*String;
|
|
if (!(TextOutIsValidAscii (Character) || TextOutIsValidEfiCntlChar (Character))) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
QueryMode (
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN UINTN ModeNumber,
|
|
OUT UINTN *Columns,
|
|
OUT UINTN *Rows
|
|
)
|
|
{
|
|
if (This->Mode->MaxMode > 1) {
|
|
return EFI_DEVICE_ERROR;
|
|
}
|
|
|
|
if (ModeNumber == 0) {
|
|
*Columns = MODE0_COLUMN_COUNT;
|
|
*Rows = MODE0_ROW_COUNT;
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
SetMode (
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN UINTN ModeNumber
|
|
)
|
|
{
|
|
if (ModeNumber != 0) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
This->Mode->Mode = 0;
|
|
This->ClearScreen (This);
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
SetAttribute(
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN UINTN Attribute
|
|
)
|
|
{
|
|
This->Mode->Attribute = (INT32)Attribute;
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
ClearScreen (
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
|
|
Status = This->SetCursorPosition (This, 0, 0);
|
|
return Status;
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
SetCursorPosition (
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN UINTN Column,
|
|
IN UINTN Row
|
|
)
|
|
{
|
|
EFI_SIMPLE_TEXT_OUTPUT_MODE *Mode;
|
|
EFI_STATUS Status;
|
|
UINTN MaxColumn;
|
|
UINTN MaxRow;
|
|
|
|
Mode = This->Mode;
|
|
|
|
Status = This->QueryMode(
|
|
This,
|
|
Mode->Mode,
|
|
&MaxColumn,
|
|
&MaxRow
|
|
);
|
|
if (EFI_ERROR(Status)) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
if ((Column >= MaxColumn) || (Row >= MaxRow)) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
Mode->CursorColumn = (INT32)Column;
|
|
Mode->CursorRow = (INT32)Row;
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
EnableCursor (
|
|
IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *This,
|
|
IN BOOLEAN Enable
|
|
)
|
|
{
|
|
if (!Enable) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
SimpleTextInOutEntryPoint (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
|
|
Status = gBS->CreateEvent (
|
|
EVT_NOTIFY_WAIT,
|
|
TPL_NOTIFY,
|
|
WaitForKeyEvent,
|
|
NULL,
|
|
&mSimpleTextIn.WaitForKey
|
|
);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
Status = gBS->InstallMultipleProtocolInterfaces(
|
|
&mInstallHandle,
|
|
&gEfiSimpleTextInProtocolGuid, &mSimpleTextIn,
|
|
&gEfiSimpleTextOutProtocolGuid, &mSimpleTextOut,
|
|
&gEfiDevicePathProtocolGuid, &mDevicePath,
|
|
NULL
|
|
);
|
|
if (!EFI_ERROR (Status)) {
|
|
gST->ConOut = &mSimpleTextOut;
|
|
gST->ConIn = &mSimpleTextIn;
|
|
}
|
|
|
|
return Status;
|
|
}
|