mirror of https://github.com/acidanthera/audk.git
1806 lines
55 KiB
C
1806 lines
55 KiB
C
/** @file
|
|
Produces Simple Text Input Protocol, Simple Text Input Extended Protocol and
|
|
Simple Text Output Protocol upon Serial IO Protocol.
|
|
|
|
Copyright (c) 2006 - 2016, Intel Corporation. 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.
|
|
|
|
**/
|
|
|
|
|
|
#include "Terminal.h"
|
|
|
|
//
|
|
// Globals
|
|
//
|
|
EFI_DRIVER_BINDING_PROTOCOL gTerminalDriverBinding = {
|
|
TerminalDriverBindingSupported,
|
|
TerminalDriverBindingStart,
|
|
TerminalDriverBindingStop,
|
|
0xa,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
|
|
EFI_GUID *gTerminalType[] = {
|
|
&gEfiPcAnsiGuid,
|
|
&gEfiVT100Guid,
|
|
&gEfiVT100PlusGuid,
|
|
&gEfiVTUTF8Guid,
|
|
&gEfiTtyTermGuid
|
|
};
|
|
|
|
|
|
TERMINAL_DEV mTerminalDevTemplate = {
|
|
TERMINAL_DEV_SIGNATURE,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
{ // SimpleTextInput
|
|
TerminalConInReset,
|
|
TerminalConInReadKeyStroke,
|
|
NULL
|
|
},
|
|
{ // SimpleTextOutput
|
|
TerminalConOutReset,
|
|
TerminalConOutOutputString,
|
|
TerminalConOutTestString,
|
|
TerminalConOutQueryMode,
|
|
TerminalConOutSetMode,
|
|
TerminalConOutSetAttribute,
|
|
TerminalConOutClearScreen,
|
|
TerminalConOutSetCursorPosition,
|
|
TerminalConOutEnableCursor,
|
|
NULL
|
|
},
|
|
{ // SimpleTextOutputMode
|
|
1, // MaxMode
|
|
0, // Mode
|
|
EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK), // Attribute
|
|
0, // CursorColumn
|
|
0, // CursorRow
|
|
TRUE // CursorVisible
|
|
},
|
|
NULL, // TerminalConsoleModeData
|
|
0, // SerialInTimeOut
|
|
|
|
NULL, // RawFifo
|
|
NULL, // UnicodeFiFo
|
|
NULL, // EfiKeyFiFo
|
|
NULL, // EfiKeyFiFoForNotify
|
|
|
|
NULL, // ControllerNameTable
|
|
NULL, // TimerEvent
|
|
NULL, // TwoSecondTimeOut
|
|
INPUT_STATE_DEFAULT,
|
|
RESET_STATE_DEFAULT,
|
|
{
|
|
0,
|
|
0,
|
|
0
|
|
},
|
|
0,
|
|
FALSE,
|
|
{ // SimpleTextInputEx
|
|
TerminalConInResetEx,
|
|
TerminalConInReadKeyStrokeEx,
|
|
NULL,
|
|
TerminalConInSetState,
|
|
TerminalConInRegisterKeyNotify,
|
|
TerminalConInUnregisterKeyNotify,
|
|
},
|
|
{ // NotifyList
|
|
NULL,
|
|
NULL,
|
|
},
|
|
NULL // KeyNotifyProcessEvent
|
|
};
|
|
|
|
TERMINAL_CONSOLE_MODE_DATA mTerminalConsoleModeData[] = {
|
|
{100, 31},
|
|
//
|
|
// New modes can be added here.
|
|
//
|
|
};
|
|
|
|
/**
|
|
Test to see if this driver supports Controller.
|
|
|
|
@param This Protocol instance pointer.
|
|
@param Controller Handle of device to test
|
|
@param RemainingDevicePath Optional parameter use to pick a specific child
|
|
device to start.
|
|
|
|
@retval EFI_SUCCESS This driver supports this device.
|
|
@retval EFI_ALREADY_STARTED This driver is already running on this device.
|
|
@retval other This driver does not support this device.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
TerminalDriverBindingSupported (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE Controller,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;
|
|
EFI_SERIAL_IO_PROTOCOL *SerialIo;
|
|
VENDOR_DEVICE_PATH *Node;
|
|
|
|
//
|
|
// If remaining device path is not NULL, then make sure it is a
|
|
// device path that describes a terminal communications protocol.
|
|
//
|
|
if (RemainingDevicePath != NULL) {
|
|
//
|
|
// Check if RemainingDevicePath is the End of Device Path Node,
|
|
// if yes, go on checking other conditions
|
|
//
|
|
if (!IsDevicePathEnd (RemainingDevicePath)) {
|
|
//
|
|
// If RemainingDevicePath isn't the End of Device Path Node,
|
|
// check its validation
|
|
//
|
|
Node = (VENDOR_DEVICE_PATH *) RemainingDevicePath;
|
|
|
|
if (Node->Header.Type != MESSAGING_DEVICE_PATH ||
|
|
Node->Header.SubType != MSG_VENDOR_DP ||
|
|
DevicePathNodeLength(&Node->Header) != sizeof(VENDOR_DEVICE_PATH)) {
|
|
|
|
return EFI_UNSUPPORTED;
|
|
|
|
}
|
|
//
|
|
// only supports PC ANSI, VT100, VT100+, VT-UTF8, and TtyTerm terminal types
|
|
//
|
|
if (!CompareGuid (&Node->Guid, &gEfiPcAnsiGuid) &&
|
|
!CompareGuid (&Node->Guid, &gEfiVT100Guid) &&
|
|
!CompareGuid (&Node->Guid, &gEfiVT100PlusGuid) &&
|
|
!CompareGuid (&Node->Guid, &gEfiVTUTF8Guid) &&
|
|
!CompareGuid (&Node->Guid, &gEfiTtyTermGuid)) {
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// Open the IO Abstraction(s) needed to perform the supported test
|
|
// The Controller must support the Serial I/O Protocol.
|
|
// This driver is a bus driver with at most 1 child device, so it is
|
|
// ok for it to be already started.
|
|
//
|
|
Status = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiSerialIoProtocolGuid,
|
|
(VOID **) &SerialIo,
|
|
This->DriverBindingHandle,
|
|
Controller,
|
|
EFI_OPEN_PROTOCOL_BY_DRIVER
|
|
);
|
|
if (Status == EFI_ALREADY_STARTED) {
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Close the I/O Abstraction(s) used to perform the supported test
|
|
//
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiSerialIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
|
|
//
|
|
// Open the EFI Device Path protocol needed to perform the supported test
|
|
//
|
|
Status = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiDevicePathProtocolGuid,
|
|
(VOID **) &ParentDevicePath,
|
|
This->DriverBindingHandle,
|
|
Controller,
|
|
EFI_OPEN_PROTOCOL_BY_DRIVER
|
|
);
|
|
if (Status == EFI_ALREADY_STARTED) {
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Close protocol, don't use device path protocol in the Support() function
|
|
//
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiDevicePathProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Build the terminal device path for the child device according to the
|
|
terminal type.
|
|
|
|
@param ParentDevicePath Parent device path.
|
|
@param RemainingDevicePath A specific child device.
|
|
|
|
@return The child device path built.
|
|
|
|
**/
|
|
EFI_DEVICE_PATH_PROTOCOL*
|
|
EFIAPI
|
|
BuildTerminalDevpath (
|
|
IN EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
|
|
)
|
|
{
|
|
EFI_DEVICE_PATH_PROTOCOL *TerminalDevicePath;
|
|
UINT8 TerminalType;
|
|
VENDOR_DEVICE_PATH *Node;
|
|
EFI_STATUS Status;
|
|
|
|
TerminalDevicePath = NULL;
|
|
|
|
//
|
|
// Use the RemainingDevicePath to determine the terminal type
|
|
//
|
|
Node = (VENDOR_DEVICE_PATH *) RemainingDevicePath;
|
|
if (Node == NULL) {
|
|
TerminalType = PcdGet8 (PcdDefaultTerminalType);
|
|
|
|
} else if (CompareGuid (&Node->Guid, &gEfiPcAnsiGuid)) {
|
|
|
|
TerminalType = PCANSITYPE;
|
|
|
|
} else if (CompareGuid (&Node->Guid, &gEfiVT100Guid)) {
|
|
|
|
TerminalType = VT100TYPE;
|
|
|
|
} else if (CompareGuid (&Node->Guid, &gEfiVT100PlusGuid)) {
|
|
|
|
TerminalType = VT100PLUSTYPE;
|
|
|
|
} else if (CompareGuid (&Node->Guid, &gEfiVTUTF8Guid)) {
|
|
|
|
TerminalType = VTUTF8TYPE;
|
|
|
|
} else if (CompareGuid (&Node->Guid, &gEfiTtyTermGuid)) {
|
|
|
|
TerminalType = TTYTERMTYPE;
|
|
|
|
} else {
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// Build the device path for the child device
|
|
//
|
|
Status = SetTerminalDevicePath (
|
|
TerminalType,
|
|
ParentDevicePath,
|
|
&TerminalDevicePath
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return NULL;
|
|
}
|
|
return TerminalDevicePath;
|
|
}
|
|
|
|
/**
|
|
Compare a device path data structure to that of all the nodes of a
|
|
second device path instance.
|
|
|
|
@param Multi A pointer to a multi-instance device path data structure.
|
|
@param Single A pointer to a single-instance device path data structure.
|
|
|
|
@retval TRUE If the Single is contained within Multi.
|
|
@retval FALSE The Single is not match within Multi.
|
|
|
|
**/
|
|
BOOLEAN
|
|
MatchDevicePaths (
|
|
IN EFI_DEVICE_PATH_PROTOCOL *Multi,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *Single
|
|
)
|
|
{
|
|
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
|
EFI_DEVICE_PATH_PROTOCOL *DevicePathInst;
|
|
UINTN Size;
|
|
|
|
DevicePath = Multi;
|
|
DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
|
|
//
|
|
// Search for the match of 'Single' in 'Multi'
|
|
//
|
|
while (DevicePathInst != NULL) {
|
|
//
|
|
// If the single device path is found in multiple device paths,
|
|
// return success
|
|
//
|
|
if (CompareMem (Single, DevicePathInst, Size) == 0) {
|
|
FreePool (DevicePathInst);
|
|
return TRUE;
|
|
}
|
|
|
|
FreePool (DevicePathInst);
|
|
DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
Check whether the terminal device path is in the global variable.
|
|
|
|
@param VariableName Pointer to one global variable.
|
|
@param TerminalDevicePath Pointer to the terminal device's device path.
|
|
|
|
@retval TRUE The devcie is in the global variable.
|
|
@retval FALSE The devcie is not in the global variable.
|
|
|
|
**/
|
|
BOOLEAN
|
|
IsTerminalInConsoleVariable (
|
|
IN CHAR16 *VariableName,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *TerminalDevicePath
|
|
)
|
|
{
|
|
EFI_DEVICE_PATH_PROTOCOL *Variable;
|
|
BOOLEAN ReturnFlag;
|
|
|
|
//
|
|
// Get global variable and its size according to the name given.
|
|
//
|
|
GetEfiGlobalVariable2 (VariableName, (VOID**)&Variable, NULL);
|
|
if (Variable == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Check whether the terminal device path is one of the variable instances.
|
|
//
|
|
ReturnFlag = MatchDevicePaths (Variable, TerminalDevicePath);
|
|
|
|
FreePool (Variable);
|
|
|
|
return ReturnFlag;
|
|
}
|
|
|
|
/**
|
|
Free notify functions list.
|
|
|
|
@param ListHead The list head
|
|
|
|
@retval EFI_SUCCESS Free the notify list successfully.
|
|
@retval EFI_INVALID_PARAMETER ListHead is NULL.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
TerminalFreeNotifyList (
|
|
IN OUT LIST_ENTRY *ListHead
|
|
)
|
|
{
|
|
TERMINAL_CONSOLE_IN_EX_NOTIFY *NotifyNode;
|
|
|
|
if (ListHead == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
while (!IsListEmpty (ListHead)) {
|
|
NotifyNode = CR (
|
|
ListHead->ForwardLink,
|
|
TERMINAL_CONSOLE_IN_EX_NOTIFY,
|
|
NotifyEntry,
|
|
TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE
|
|
);
|
|
RemoveEntryList (ListHead->ForwardLink);
|
|
FreePool (NotifyNode);
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Initialize all the text modes which the terminal console supports.
|
|
|
|
It returns information for available text modes that the terminal can support.
|
|
|
|
@param[out] TextModeCount The total number of text modes that terminal console supports.
|
|
@param[out] TextModeData The buffer to the text modes column and row information.
|
|
Caller is responsible to free it when it's non-NULL.
|
|
|
|
@retval EFI_SUCCESS The supporting mode information is returned.
|
|
@retval EFI_INVALID_PARAMETER The parameters are invalid.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
InitializeTerminalConsoleTextMode (
|
|
OUT UINTN *TextModeCount,
|
|
OUT TERMINAL_CONSOLE_MODE_DATA **TextModeData
|
|
)
|
|
{
|
|
UINTN Index;
|
|
UINTN Count;
|
|
TERMINAL_CONSOLE_MODE_DATA *ModeBuffer;
|
|
TERMINAL_CONSOLE_MODE_DATA *NewModeBuffer;
|
|
UINTN ValidCount;
|
|
UINTN ValidIndex;
|
|
|
|
if ((TextModeCount == NULL) || (TextModeData == NULL)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
Count = sizeof (mTerminalConsoleModeData) / sizeof (TERMINAL_CONSOLE_MODE_DATA);
|
|
|
|
//
|
|
// Get defined mode buffer pointer.
|
|
//
|
|
ModeBuffer = mTerminalConsoleModeData;
|
|
|
|
//
|
|
// Here we make sure that the final mode exposed does not include the duplicated modes,
|
|
// and does not include the invalid modes which exceed the max column and row.
|
|
// Reserve 2 modes for 80x25, 80x50 of terminal console.
|
|
//
|
|
NewModeBuffer = AllocateZeroPool (sizeof (TERMINAL_CONSOLE_MODE_DATA) * (Count + 2));
|
|
ASSERT (NewModeBuffer != NULL);
|
|
|
|
//
|
|
// Mode 0 and mode 1 is for 80x25, 80x50 according to UEFI spec.
|
|
//
|
|
ValidCount = 0;
|
|
|
|
NewModeBuffer[ValidCount].Columns = 80;
|
|
NewModeBuffer[ValidCount].Rows = 25;
|
|
ValidCount++;
|
|
|
|
NewModeBuffer[ValidCount].Columns = 80;
|
|
NewModeBuffer[ValidCount].Rows = 50;
|
|
ValidCount++;
|
|
|
|
//
|
|
// Start from mode 2 to put the valid mode other than 80x25 and 80x50 in the output mode buffer.
|
|
//
|
|
for (Index = 0; Index < Count; Index++) {
|
|
if ((ModeBuffer[Index].Columns == 0) || (ModeBuffer[Index].Rows == 0)) {
|
|
//
|
|
// Skip the pre-defined mode which is invalid.
|
|
//
|
|
continue;
|
|
}
|
|
for (ValidIndex = 0; ValidIndex < ValidCount; ValidIndex++) {
|
|
if ((ModeBuffer[Index].Columns == NewModeBuffer[ValidIndex].Columns) &&
|
|
(ModeBuffer[Index].Rows == NewModeBuffer[ValidIndex].Rows)) {
|
|
//
|
|
// Skip the duplicated mode.
|
|
//
|
|
break;
|
|
}
|
|
}
|
|
if (ValidIndex == ValidCount) {
|
|
NewModeBuffer[ValidCount].Columns = ModeBuffer[Index].Columns;
|
|
NewModeBuffer[ValidCount].Rows = ModeBuffer[Index].Rows;
|
|
ValidCount++;
|
|
}
|
|
}
|
|
|
|
DEBUG_CODE (
|
|
for (Index = 0; Index < ValidCount; Index++) {
|
|
DEBUG ((EFI_D_INFO, "Terminal - Mode %d, Column = %d, Row = %d\n",
|
|
Index, NewModeBuffer[Index].Columns, NewModeBuffer[Index].Rows));
|
|
}
|
|
);
|
|
|
|
//
|
|
// Return valid mode count and mode information buffer.
|
|
//
|
|
*TextModeCount = ValidCount;
|
|
*TextModeData = NewModeBuffer;
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Start this driver on Controller by opening a Serial IO protocol,
|
|
reading Device Path, and creating a child handle with a Simple Text In,
|
|
Simple Text In Ex and Simple Text Out protocol, and device path protocol.
|
|
And store Console Device Environment Variables.
|
|
|
|
@param This Protocol instance pointer.
|
|
@param Controller Handle of device to bind driver to
|
|
@param RemainingDevicePath Optional parameter use to pick a specific child
|
|
device to start.
|
|
|
|
@retval EFI_SUCCESS This driver is added to Controller.
|
|
@retval EFI_ALREADY_STARTED This driver is already running on Controller.
|
|
@retval other This driver does not support this device.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
TerminalDriverBindingStart (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE Controller,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_SERIAL_IO_PROTOCOL *SerialIo;
|
|
EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;
|
|
VENDOR_DEVICE_PATH *Node;
|
|
EFI_SERIAL_IO_MODE *Mode;
|
|
UINTN SerialInTimeOut;
|
|
TERMINAL_DEV *TerminalDevice;
|
|
UINT8 TerminalType;
|
|
EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfoBuffer;
|
|
UINTN EntryCount;
|
|
UINTN Index;
|
|
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
|
EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *SimpleTextOutput;
|
|
EFI_SIMPLE_TEXT_INPUT_PROTOCOL *SimpleTextInput;
|
|
BOOLEAN ConInSelected;
|
|
BOOLEAN ConOutSelected;
|
|
BOOLEAN NullRemaining;
|
|
BOOLEAN SimTxtInInstalled;
|
|
BOOLEAN SimTxtOutInstalled;
|
|
BOOLEAN FirstEnter;
|
|
UINTN ModeCount;
|
|
|
|
TerminalDevice = NULL;
|
|
ConInSelected = FALSE;
|
|
ConOutSelected = FALSE;
|
|
NullRemaining = FALSE;
|
|
SimTxtInInstalled = FALSE;
|
|
SimTxtOutInstalled = FALSE;
|
|
FirstEnter = FALSE;
|
|
//
|
|
// Get the Device Path Protocol to build the device path of the child device
|
|
//
|
|
Status = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiDevicePathProtocolGuid,
|
|
(VOID **) &ParentDevicePath,
|
|
This->DriverBindingHandle,
|
|
Controller,
|
|
EFI_OPEN_PROTOCOL_BY_DRIVER
|
|
);
|
|
if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Open the Serial I/O Protocol BY_DRIVER. It might already be started.
|
|
//
|
|
Status = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiSerialIoProtocolGuid,
|
|
(VOID **) &SerialIo,
|
|
This->DriverBindingHandle,
|
|
Controller,
|
|
EFI_OPEN_PROTOCOL_BY_DRIVER
|
|
);
|
|
if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) {
|
|
return Status;
|
|
}
|
|
|
|
if (Status != EFI_ALREADY_STARTED) {
|
|
//
|
|
// the serial I/O protocol never be opened before, it is the first
|
|
// time to start the serial Io controller
|
|
//
|
|
FirstEnter = TRUE;
|
|
}
|
|
|
|
//
|
|
// Serial I/O is not already open by this driver, then tag the handle
|
|
// with the Terminal Driver GUID and update the ConInDev, ConOutDev, and
|
|
// StdErrDev variables with the list of possible terminal types on this
|
|
// serial port.
|
|
//
|
|
Status = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiCallerIdGuid,
|
|
NULL,
|
|
This->DriverBindingHandle,
|
|
Controller,
|
|
EFI_OPEN_PROTOCOL_TEST_PROTOCOL
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
Status = gBS->InstallMultipleProtocolInterfaces (
|
|
&Controller,
|
|
&gEfiCallerIdGuid,
|
|
DuplicateDevicePath (ParentDevicePath),
|
|
NULL
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto Error;
|
|
}
|
|
|
|
if (!IsHotPlugDevice (ParentDevicePath)) {
|
|
//
|
|
// if the serial device is a hot plug device, do not update the
|
|
// ConInDev, ConOutDev, and StdErrDev variables.
|
|
//
|
|
TerminalUpdateConsoleDevVariable (L"ConInDev", ParentDevicePath);
|
|
TerminalUpdateConsoleDevVariable (L"ConOutDev", ParentDevicePath);
|
|
TerminalUpdateConsoleDevVariable (L"ErrOutDev", ParentDevicePath);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check the requirement for the SimpleTxtIn and SimpleTxtOut protocols
|
|
//
|
|
// Simple In/Out Protocol will not be installed onto the handle if the
|
|
// device path to the handle is not present in the ConIn/ConOut
|
|
// environment variable. But If RemainingDevicePath is NULL, then always
|
|
// produce both Simple In and Simple Text Output Protocols. This is required
|
|
// for the connect all sequences to make sure all possible consoles are
|
|
// produced no matter what the current values of ConIn, ConOut, or StdErr are.
|
|
//
|
|
if (RemainingDevicePath == NULL) {
|
|
NullRemaining = TRUE;
|
|
}
|
|
|
|
DevicePath = BuildTerminalDevpath (ParentDevicePath, RemainingDevicePath);
|
|
if (DevicePath != NULL) {
|
|
ConInSelected = IsTerminalInConsoleVariable (L"ConIn", DevicePath);
|
|
ConOutSelected = IsTerminalInConsoleVariable (L"ConOut", DevicePath);
|
|
FreePool (DevicePath);
|
|
} else {
|
|
goto Error;
|
|
}
|
|
//
|
|
// Not create the child terminal handle if both Simple In/In Ex and
|
|
// Simple text Out protocols are not required to be published
|
|
//
|
|
if ((!ConInSelected)&&(!ConOutSelected)&&(!NullRemaining)) {
|
|
goto Error;
|
|
}
|
|
|
|
//
|
|
// create the child terminal handle during first entry
|
|
//
|
|
if (FirstEnter) {
|
|
//
|
|
// First enther the start function
|
|
//
|
|
FirstEnter = FALSE;
|
|
//
|
|
// Make sure a child handle does not already exist. This driver can only
|
|
// produce one child per serial port.
|
|
//
|
|
Status = gBS->OpenProtocolInformation (
|
|
Controller,
|
|
&gEfiSerialIoProtocolGuid,
|
|
&OpenInfoBuffer,
|
|
&EntryCount
|
|
);
|
|
if (!EFI_ERROR (Status)) {
|
|
Status = EFI_SUCCESS;
|
|
for (Index = 0; Index < EntryCount; Index++) {
|
|
if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
|
|
Status = EFI_ALREADY_STARTED;
|
|
}
|
|
}
|
|
|
|
FreePool (OpenInfoBuffer);
|
|
if (EFI_ERROR (Status)) {
|
|
goto Error;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If RemainingDevicePath is NULL, use default terminal type
|
|
//
|
|
if (RemainingDevicePath == NULL) {
|
|
TerminalType = PcdGet8 (PcdDefaultTerminalType);
|
|
//
|
|
// Must be between PCANSITYPE (0) and TTYTERMTYPE (4)
|
|
//
|
|
ASSERT (TerminalType <= TTYTERMTYPE);
|
|
} else if (!IsDevicePathEnd (RemainingDevicePath)) {
|
|
//
|
|
// If RemainingDevicePath isn't the End of Device Path Node,
|
|
// Use the RemainingDevicePath to determine the terminal type
|
|
//
|
|
Node = (VENDOR_DEVICE_PATH *)RemainingDevicePath;
|
|
if (CompareGuid (&Node->Guid, &gEfiPcAnsiGuid)) {
|
|
TerminalType = PCANSITYPE;
|
|
} else if (CompareGuid (&Node->Guid, &gEfiVT100Guid)) {
|
|
TerminalType = VT100TYPE;
|
|
} else if (CompareGuid (&Node->Guid, &gEfiVT100PlusGuid)) {
|
|
TerminalType = VT100PLUSTYPE;
|
|
} else if (CompareGuid (&Node->Guid, &gEfiVTUTF8Guid)) {
|
|
TerminalType = VTUTF8TYPE;
|
|
} else if (CompareGuid (&Node->Guid, &gEfiTtyTermGuid)) {
|
|
TerminalType = TTYTERMTYPE;
|
|
} else {
|
|
goto Error;
|
|
}
|
|
} else {
|
|
//
|
|
// If RemainingDevicePath is the End of Device Path Node,
|
|
// skip enumerate any device and return EFI_SUCESSS
|
|
//
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Initialize the Terminal Dev
|
|
//
|
|
TerminalDevice = AllocateCopyPool (sizeof (TERMINAL_DEV), &mTerminalDevTemplate);
|
|
if (TerminalDevice == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto Error;
|
|
}
|
|
|
|
TerminalDevice->TerminalType = TerminalType;
|
|
TerminalDevice->SerialIo = SerialIo;
|
|
|
|
InitializeListHead (&TerminalDevice->NotifyList);
|
|
Status = gBS->CreateEvent (
|
|
EVT_NOTIFY_WAIT,
|
|
TPL_NOTIFY,
|
|
TerminalConInWaitForKeyEx,
|
|
TerminalDevice,
|
|
&TerminalDevice->SimpleInputEx.WaitForKeyEx
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto Error;
|
|
}
|
|
|
|
Status = gBS->CreateEvent (
|
|
EVT_NOTIFY_WAIT,
|
|
TPL_NOTIFY,
|
|
TerminalConInWaitForKey,
|
|
TerminalDevice,
|
|
&TerminalDevice->SimpleInput.WaitForKey
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto Error;
|
|
}
|
|
//
|
|
// Allocates and initializes the FIFO buffer to be zero, used for accommodating
|
|
// the pre-read pending characters.
|
|
//
|
|
TerminalDevice->RawFiFo = AllocateZeroPool (sizeof (RAW_DATA_FIFO));
|
|
if (TerminalDevice->RawFiFo == NULL) {
|
|
goto Error;
|
|
}
|
|
TerminalDevice->UnicodeFiFo = AllocateZeroPool (sizeof (UNICODE_FIFO));
|
|
if (TerminalDevice->UnicodeFiFo == NULL) {
|
|
goto Error;
|
|
}
|
|
TerminalDevice->EfiKeyFiFo = AllocateZeroPool (sizeof (EFI_KEY_FIFO));
|
|
if (TerminalDevice->EfiKeyFiFo == NULL) {
|
|
goto Error;
|
|
}
|
|
TerminalDevice->EfiKeyFiFoForNotify = AllocateZeroPool (sizeof (EFI_KEY_FIFO));
|
|
if (TerminalDevice->EfiKeyFiFoForNotify == NULL) {
|
|
goto Error;
|
|
}
|
|
|
|
//
|
|
// Set the timeout value of serial buffer for
|
|
// keystroke response performance issue
|
|
//
|
|
Mode = TerminalDevice->SerialIo->Mode;
|
|
|
|
SerialInTimeOut = 0;
|
|
if (Mode->BaudRate != 0) {
|
|
SerialInTimeOut = (1 + Mode->DataBits + Mode->StopBits) * 2 * 1000000 / (UINTN) Mode->BaudRate;
|
|
}
|
|
|
|
Status = TerminalDevice->SerialIo->SetAttributes (
|
|
TerminalDevice->SerialIo,
|
|
Mode->BaudRate,
|
|
Mode->ReceiveFifoDepth,
|
|
(UINT32) SerialInTimeOut,
|
|
(EFI_PARITY_TYPE) (Mode->Parity),
|
|
(UINT8) Mode->DataBits,
|
|
(EFI_STOP_BITS_TYPE) (Mode->StopBits)
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
//
|
|
// if set attributes operation fails, invalidate
|
|
// the value of SerialInTimeOut,thus make it
|
|
// inconsistent with the default timeout value
|
|
// of serial buffer. This will invoke the recalculation
|
|
// in the readkeystroke routine.
|
|
//
|
|
TerminalDevice->SerialInTimeOut = 0;
|
|
} else {
|
|
TerminalDevice->SerialInTimeOut = SerialInTimeOut;
|
|
}
|
|
//
|
|
// Set Simple Text Output Protocol from template.
|
|
//
|
|
SimpleTextOutput = CopyMem (
|
|
&TerminalDevice->SimpleTextOutput,
|
|
&mTerminalDevTemplate.SimpleTextOutput,
|
|
sizeof (mTerminalDevTemplate.SimpleTextOutput)
|
|
);
|
|
SimpleTextOutput->Mode = &TerminalDevice->SimpleTextOutputMode;
|
|
|
|
Status = InitializeTerminalConsoleTextMode (&ModeCount, &TerminalDevice->TerminalConsoleModeData);
|
|
if (EFI_ERROR (Status)) {
|
|
goto ReportError;
|
|
}
|
|
TerminalDevice->SimpleTextOutputMode.MaxMode = (INT32) ModeCount;
|
|
|
|
//
|
|
// For terminal devices, cursor is always visible
|
|
//
|
|
TerminalDevice->SimpleTextOutputMode.CursorVisible = TRUE;
|
|
Status = TerminalConOutSetAttribute (
|
|
SimpleTextOutput,
|
|
EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK)
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto ReportError;
|
|
}
|
|
|
|
//
|
|
// Build the component name for the child device
|
|
//
|
|
TerminalDevice->ControllerNameTable = NULL;
|
|
switch (TerminalDevice->TerminalType) {
|
|
case PCANSITYPE:
|
|
AddUnicodeString2 (
|
|
"eng",
|
|
gTerminalComponentName.SupportedLanguages,
|
|
&TerminalDevice->ControllerNameTable,
|
|
(CHAR16 *)L"PC-ANSI Serial Console",
|
|
TRUE
|
|
);
|
|
AddUnicodeString2 (
|
|
"en",
|
|
gTerminalComponentName2.SupportedLanguages,
|
|
&TerminalDevice->ControllerNameTable,
|
|
(CHAR16 *)L"PC-ANSI Serial Console",
|
|
FALSE
|
|
);
|
|
|
|
break;
|
|
|
|
case VT100TYPE:
|
|
AddUnicodeString2 (
|
|
"eng",
|
|
gTerminalComponentName.SupportedLanguages,
|
|
&TerminalDevice->ControllerNameTable,
|
|
(CHAR16 *)L"VT-100 Serial Console",
|
|
TRUE
|
|
);
|
|
AddUnicodeString2 (
|
|
"en",
|
|
gTerminalComponentName2.SupportedLanguages,
|
|
&TerminalDevice->ControllerNameTable,
|
|
(CHAR16 *)L"VT-100 Serial Console",
|
|
FALSE
|
|
);
|
|
|
|
break;
|
|
|
|
case VT100PLUSTYPE:
|
|
AddUnicodeString2 (
|
|
"eng",
|
|
gTerminalComponentName.SupportedLanguages,
|
|
&TerminalDevice->ControllerNameTable,
|
|
(CHAR16 *)L"VT-100+ Serial Console",
|
|
TRUE
|
|
);
|
|
AddUnicodeString2 (
|
|
"en",
|
|
gTerminalComponentName2.SupportedLanguages,
|
|
&TerminalDevice->ControllerNameTable,
|
|
(CHAR16 *)L"VT-100+ Serial Console",
|
|
FALSE
|
|
);
|
|
|
|
break;
|
|
|
|
case VTUTF8TYPE:
|
|
AddUnicodeString2 (
|
|
"eng",
|
|
gTerminalComponentName.SupportedLanguages,
|
|
&TerminalDevice->ControllerNameTable,
|
|
(CHAR16 *)L"VT-UTF8 Serial Console",
|
|
TRUE
|
|
);
|
|
AddUnicodeString2 (
|
|
"en",
|
|
gTerminalComponentName2.SupportedLanguages,
|
|
&TerminalDevice->ControllerNameTable,
|
|
(CHAR16 *)L"VT-UTF8 Serial Console",
|
|
FALSE
|
|
);
|
|
|
|
break;
|
|
|
|
case TTYTERMTYPE:
|
|
AddUnicodeString2 (
|
|
"eng",
|
|
gTerminalComponentName.SupportedLanguages,
|
|
&TerminalDevice->ControllerNameTable,
|
|
(CHAR16 *)L"Tty Terminal Serial Console",
|
|
TRUE
|
|
);
|
|
AddUnicodeString2 (
|
|
"en",
|
|
gTerminalComponentName2.SupportedLanguages,
|
|
&TerminalDevice->ControllerNameTable,
|
|
(CHAR16 *)L"Tty Terminal Serial Console",
|
|
FALSE
|
|
);
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Build the device path for the child device
|
|
//
|
|
Status = SetTerminalDevicePath (
|
|
TerminalDevice->TerminalType,
|
|
ParentDevicePath,
|
|
&TerminalDevice->DevicePath
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto Error;
|
|
}
|
|
|
|
Status = TerminalConOutReset (SimpleTextOutput, FALSE);
|
|
if (EFI_ERROR (Status)) {
|
|
goto ReportError;
|
|
}
|
|
|
|
Status = TerminalConOutSetMode (SimpleTextOutput, 0);
|
|
if (EFI_ERROR (Status)) {
|
|
goto ReportError;
|
|
}
|
|
|
|
Status = TerminalConOutEnableCursor (SimpleTextOutput, TRUE);
|
|
if (EFI_ERROR (Status)) {
|
|
goto ReportError;
|
|
}
|
|
|
|
Status = gBS->CreateEvent (
|
|
EVT_TIMER | EVT_NOTIFY_SIGNAL,
|
|
TPL_NOTIFY,
|
|
TerminalConInTimerHandler,
|
|
TerminalDevice,
|
|
&TerminalDevice->TimerEvent
|
|
);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
Status = gBS->SetTimer (
|
|
TerminalDevice->TimerEvent,
|
|
TimerPeriodic,
|
|
KEYBOARD_TIMER_INTERVAL
|
|
);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
Status = gBS->CreateEvent (
|
|
EVT_TIMER,
|
|
TPL_CALLBACK,
|
|
NULL,
|
|
NULL,
|
|
&TerminalDevice->TwoSecondTimeOut
|
|
);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
Status = gBS->CreateEvent (
|
|
EVT_NOTIFY_SIGNAL,
|
|
TPL_CALLBACK,
|
|
KeyNotifyProcessHandler,
|
|
TerminalDevice,
|
|
&TerminalDevice->KeyNotifyProcessEvent
|
|
);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
Status = gBS->InstallProtocolInterface (
|
|
&TerminalDevice->Handle,
|
|
&gEfiDevicePathProtocolGuid,
|
|
EFI_NATIVE_INTERFACE,
|
|
TerminalDevice->DevicePath
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto Error;
|
|
}
|
|
|
|
//
|
|
// Register the Parent-Child relationship via
|
|
// EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
|
|
//
|
|
Status = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiSerialIoProtocolGuid,
|
|
(VOID **) &TerminalDevice->SerialIo,
|
|
This->DriverBindingHandle,
|
|
TerminalDevice->Handle,
|
|
EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto Error;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Find the child handle, and get its TerminalDevice private data
|
|
//
|
|
Status = gBS->OpenProtocolInformation (
|
|
Controller,
|
|
&gEfiSerialIoProtocolGuid,
|
|
&OpenInfoBuffer,
|
|
&EntryCount
|
|
);
|
|
if (!EFI_ERROR (Status)) {
|
|
Status = EFI_NOT_FOUND;
|
|
ASSERT (OpenInfoBuffer != NULL);
|
|
for (Index = 0; Index < EntryCount; Index++) {
|
|
if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
|
|
//
|
|
// Find the child terminal handle.
|
|
// Test whether the SimpleTxtIn and SimpleTxtOut have been published
|
|
//
|
|
Status = gBS->OpenProtocol (
|
|
OpenInfoBuffer[Index].ControllerHandle,
|
|
&gEfiSimpleTextInProtocolGuid,
|
|
(VOID **) &SimpleTextInput,
|
|
This->DriverBindingHandle,
|
|
OpenInfoBuffer[Index].ControllerHandle,
|
|
EFI_OPEN_PROTOCOL_GET_PROTOCOL
|
|
);
|
|
if (!EFI_ERROR (Status)) {
|
|
SimTxtInInstalled = TRUE;
|
|
TerminalDevice = TERMINAL_CON_IN_DEV_FROM_THIS (SimpleTextInput);
|
|
}
|
|
|
|
Status = gBS->OpenProtocol (
|
|
OpenInfoBuffer[Index].ControllerHandle,
|
|
&gEfiSimpleTextOutProtocolGuid,
|
|
(VOID **) &SimpleTextOutput,
|
|
This->DriverBindingHandle,
|
|
OpenInfoBuffer[Index].ControllerHandle,
|
|
EFI_OPEN_PROTOCOL_GET_PROTOCOL
|
|
);
|
|
if (!EFI_ERROR (Status)) {
|
|
SimTxtOutInstalled = TRUE;
|
|
TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (SimpleTextOutput);
|
|
}
|
|
Status = EFI_SUCCESS;
|
|
break;
|
|
}
|
|
}
|
|
|
|
FreePool (OpenInfoBuffer);
|
|
if (EFI_ERROR (Status)) {
|
|
goto ReportError;
|
|
}
|
|
} else {
|
|
goto ReportError;
|
|
}
|
|
|
|
ASSERT (TerminalDevice != NULL);
|
|
//
|
|
// Only do the reset if the device path is in the Conout variable
|
|
//
|
|
if (ConInSelected && !SimTxtInInstalled) {
|
|
Status = TerminalDevice->SimpleInput.Reset (
|
|
&TerminalDevice->SimpleInput,
|
|
FALSE
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
//
|
|
// Need to report Error Code first
|
|
//
|
|
goto ReportError;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Only output the configure string to remote terminal if the device path
|
|
// is in the Conout variable
|
|
//
|
|
if (ConOutSelected && !SimTxtOutInstalled) {
|
|
Status = TerminalDevice->SimpleTextOutput.SetAttribute (
|
|
&TerminalDevice->SimpleTextOutput,
|
|
EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK)
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto ReportError;
|
|
}
|
|
|
|
Status = TerminalDevice->SimpleTextOutput.Reset (
|
|
&TerminalDevice->SimpleTextOutput,
|
|
FALSE
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto ReportError;
|
|
}
|
|
|
|
Status = TerminalDevice->SimpleTextOutput.SetMode (
|
|
&TerminalDevice->SimpleTextOutput,
|
|
0
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto ReportError;
|
|
}
|
|
|
|
Status = TerminalDevice->SimpleTextOutput.EnableCursor (
|
|
&TerminalDevice->SimpleTextOutput,
|
|
TRUE
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto ReportError;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Simple In/Out Protocol will not be installed onto the handle if the
|
|
// device path to the handle is not present in the ConIn/ConOut
|
|
// environment variable. But If RemainingDevicePath is NULL, then always
|
|
// produce both Simple In and Simple Text Output Protocols. This is required
|
|
// for the connect all sequences to make sure all possible consoles are
|
|
// produced no matter what the current values of ConIn, ConOut, or StdErr are.
|
|
//
|
|
if (!SimTxtInInstalled && (ConInSelected || NullRemaining)) {
|
|
Status = gBS->InstallMultipleProtocolInterfaces (
|
|
&TerminalDevice->Handle,
|
|
&gEfiSimpleTextInProtocolGuid,
|
|
&TerminalDevice->SimpleInput,
|
|
&gEfiSimpleTextInputExProtocolGuid,
|
|
&TerminalDevice->SimpleInputEx,
|
|
NULL
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto Error;
|
|
}
|
|
}
|
|
|
|
if (!SimTxtOutInstalled && (ConOutSelected || NullRemaining)) {
|
|
Status = gBS->InstallProtocolInterface (
|
|
&TerminalDevice->Handle,
|
|
&gEfiSimpleTextOutProtocolGuid,
|
|
EFI_NATIVE_INTERFACE,
|
|
&TerminalDevice->SimpleTextOutput
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
goto Error;
|
|
}
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
|
|
ReportError:
|
|
//
|
|
// Report error code before exiting
|
|
//
|
|
DevicePath = ParentDevicePath;
|
|
REPORT_STATUS_CODE_WITH_DEVICE_PATH (
|
|
EFI_ERROR_CODE | EFI_ERROR_MINOR,
|
|
(EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_EC_CONTROLLER_ERROR),
|
|
DevicePath
|
|
);
|
|
|
|
Error:
|
|
//
|
|
// Use the Stop() function to free all resources allocated in Start()
|
|
//
|
|
if (TerminalDevice != NULL) {
|
|
|
|
if (TerminalDevice->Handle != NULL) {
|
|
This->Stop (This, Controller, 1, &TerminalDevice->Handle);
|
|
} else {
|
|
|
|
if (TerminalDevice->TwoSecondTimeOut != NULL) {
|
|
gBS->CloseEvent (TerminalDevice->TwoSecondTimeOut);
|
|
}
|
|
|
|
if (TerminalDevice->TimerEvent != NULL) {
|
|
gBS->CloseEvent (TerminalDevice->TimerEvent);
|
|
}
|
|
|
|
if (TerminalDevice->SimpleInput.WaitForKey != NULL) {
|
|
gBS->CloseEvent (TerminalDevice->SimpleInput.WaitForKey);
|
|
}
|
|
|
|
if (TerminalDevice->SimpleInputEx.WaitForKeyEx != NULL) {
|
|
gBS->CloseEvent (TerminalDevice->SimpleInputEx.WaitForKeyEx);
|
|
}
|
|
|
|
TerminalFreeNotifyList (&TerminalDevice->NotifyList);
|
|
|
|
if (TerminalDevice->RawFiFo != NULL) {
|
|
FreePool (TerminalDevice->RawFiFo);
|
|
}
|
|
if (TerminalDevice->UnicodeFiFo != NULL) {
|
|
FreePool (TerminalDevice->UnicodeFiFo);
|
|
}
|
|
if (TerminalDevice->EfiKeyFiFo != NULL) {
|
|
FreePool (TerminalDevice->EfiKeyFiFo);
|
|
}
|
|
if (TerminalDevice->EfiKeyFiFoForNotify != NULL) {
|
|
FreePool (TerminalDevice->EfiKeyFiFoForNotify);
|
|
}
|
|
|
|
if (TerminalDevice->ControllerNameTable != NULL) {
|
|
FreeUnicodeStringTable (TerminalDevice->ControllerNameTable);
|
|
}
|
|
|
|
if (TerminalDevice->DevicePath != NULL) {
|
|
FreePool (TerminalDevice->DevicePath);
|
|
}
|
|
|
|
if (TerminalDevice->TerminalConsoleModeData != NULL) {
|
|
FreePool (TerminalDevice->TerminalConsoleModeData);
|
|
}
|
|
|
|
FreePool (TerminalDevice);
|
|
}
|
|
}
|
|
|
|
This->Stop (This, Controller, 0, NULL);
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Stop this driver on Controller by closing Simple Text In, Simple Text
|
|
In Ex, Simple Text Out protocol, and removing parent device path from
|
|
Console Device Environment Variables.
|
|
|
|
@param This Protocol instance pointer.
|
|
@param Controller Handle of device to stop driver on
|
|
@param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
|
|
children is zero stop the entire bus driver.
|
|
@param ChildHandleBuffer List of Child Handles to Stop.
|
|
|
|
@retval EFI_SUCCESS This driver is removed Controller.
|
|
@retval other This driver could not be removed from this device.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
TerminalDriverBindingStop (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE Controller,
|
|
IN UINTN NumberOfChildren,
|
|
IN EFI_HANDLE *ChildHandleBuffer
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINTN Index;
|
|
BOOLEAN AllChildrenStopped;
|
|
EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *SimpleTextOutput;
|
|
TERMINAL_DEV *TerminalDevice;
|
|
EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;
|
|
EFI_SERIAL_IO_PROTOCOL *SerialIo;
|
|
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
|
|
|
Status = gBS->HandleProtocol (
|
|
Controller,
|
|
&gEfiDevicePathProtocolGuid,
|
|
(VOID **) &DevicePath
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Complete all outstanding transactions to Controller.
|
|
// Don't allow any new transaction to Controller to be started.
|
|
//
|
|
if (NumberOfChildren == 0) {
|
|
//
|
|
// Close the bus driver
|
|
//
|
|
Status = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiCallerIdGuid,
|
|
(VOID **) &ParentDevicePath,
|
|
This->DriverBindingHandle,
|
|
Controller,
|
|
EFI_OPEN_PROTOCOL_GET_PROTOCOL
|
|
);
|
|
if (!EFI_ERROR (Status)) {
|
|
//
|
|
// Remove Parent Device Path from
|
|
// the Console Device Environment Variables
|
|
//
|
|
TerminalRemoveConsoleDevVariable (L"ConInDev", ParentDevicePath);
|
|
TerminalRemoveConsoleDevVariable (L"ConOutDev", ParentDevicePath);
|
|
TerminalRemoveConsoleDevVariable (L"ErrOutDev", ParentDevicePath);
|
|
|
|
//
|
|
// Uninstall the Terminal Driver's GUID Tag from the Serial controller
|
|
//
|
|
Status = gBS->UninstallMultipleProtocolInterfaces (
|
|
Controller,
|
|
&gEfiCallerIdGuid,
|
|
ParentDevicePath,
|
|
NULL
|
|
);
|
|
|
|
//
|
|
// Free the ParentDevicePath that was duplicated in Start()
|
|
//
|
|
if (!EFI_ERROR (Status)) {
|
|
FreePool (ParentDevicePath);
|
|
}
|
|
}
|
|
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiSerialIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiDevicePathProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
AllChildrenStopped = TRUE;
|
|
|
|
for (Index = 0; Index < NumberOfChildren; Index++) {
|
|
|
|
Status = gBS->OpenProtocol (
|
|
ChildHandleBuffer[Index],
|
|
&gEfiSimpleTextOutProtocolGuid,
|
|
(VOID **) &SimpleTextOutput,
|
|
This->DriverBindingHandle,
|
|
ChildHandleBuffer[Index],
|
|
EFI_OPEN_PROTOCOL_GET_PROTOCOL
|
|
);
|
|
if (!EFI_ERROR (Status)) {
|
|
|
|
TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (SimpleTextOutput);
|
|
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiSerialIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
ChildHandleBuffer[Index]
|
|
);
|
|
|
|
Status = gBS->UninstallMultipleProtocolInterfaces (
|
|
ChildHandleBuffer[Index],
|
|
&gEfiSimpleTextInProtocolGuid,
|
|
&TerminalDevice->SimpleInput,
|
|
&gEfiSimpleTextInputExProtocolGuid,
|
|
&TerminalDevice->SimpleInputEx,
|
|
&gEfiSimpleTextOutProtocolGuid,
|
|
&TerminalDevice->SimpleTextOutput,
|
|
&gEfiDevicePathProtocolGuid,
|
|
TerminalDevice->DevicePath,
|
|
NULL
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiSerialIoProtocolGuid,
|
|
(VOID **) &SerialIo,
|
|
This->DriverBindingHandle,
|
|
ChildHandleBuffer[Index],
|
|
EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
|
|
);
|
|
} else {
|
|
|
|
if (TerminalDevice->ControllerNameTable != NULL) {
|
|
FreeUnicodeStringTable (TerminalDevice->ControllerNameTable);
|
|
}
|
|
|
|
gBS->CloseEvent (TerminalDevice->TimerEvent);
|
|
gBS->CloseEvent (TerminalDevice->TwoSecondTimeOut);
|
|
gBS->CloseEvent (TerminalDevice->SimpleInput.WaitForKey);
|
|
gBS->CloseEvent (TerminalDevice->SimpleInputEx.WaitForKeyEx);
|
|
gBS->CloseEvent (TerminalDevice->KeyNotifyProcessEvent);
|
|
TerminalFreeNotifyList (&TerminalDevice->NotifyList);
|
|
FreePool (TerminalDevice->DevicePath);
|
|
if (TerminalDevice->TerminalConsoleModeData != NULL) {
|
|
FreePool (TerminalDevice->TerminalConsoleModeData);
|
|
}
|
|
FreePool (TerminalDevice);
|
|
}
|
|
}
|
|
|
|
if (EFI_ERROR (Status)) {
|
|
AllChildrenStopped = FALSE;
|
|
}
|
|
}
|
|
|
|
if (!AllChildrenStopped) {
|
|
return EFI_DEVICE_ERROR;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Update terminal device path in Console Device Environment Variables.
|
|
|
|
@param VariableName The Console Device Environment Variable.
|
|
@param ParentDevicePath The terminal device path to be updated.
|
|
|
|
**/
|
|
VOID
|
|
TerminalUpdateConsoleDevVariable (
|
|
IN CHAR16 *VariableName,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINTN NameSize;
|
|
UINTN VariableSize;
|
|
UINT8 TerminalType;
|
|
EFI_DEVICE_PATH_PROTOCOL *Variable;
|
|
EFI_DEVICE_PATH_PROTOCOL *NewVariable;
|
|
EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
|
|
EDKII_SET_VARIABLE_STATUS *SetVariableStatus;
|
|
|
|
//
|
|
// Get global variable and its size according to the name given.
|
|
//
|
|
GetEfiGlobalVariable2 (VariableName, (VOID**)&Variable, NULL);
|
|
if (Variable == NULL) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Append terminal device path onto the variable.
|
|
//
|
|
for (TerminalType = PCANSITYPE; TerminalType <= TTYTERMTYPE; TerminalType++) {
|
|
SetTerminalDevicePath (TerminalType, ParentDevicePath, &TempDevicePath);
|
|
NewVariable = AppendDevicePathInstance (Variable, TempDevicePath);
|
|
ASSERT (NewVariable != NULL);
|
|
if (Variable != NULL) {
|
|
FreePool (Variable);
|
|
}
|
|
|
|
if (TempDevicePath != NULL) {
|
|
FreePool (TempDevicePath);
|
|
}
|
|
|
|
Variable = NewVariable;
|
|
}
|
|
|
|
VariableSize = GetDevicePathSize (Variable);
|
|
|
|
Status = gRT->SetVariable (
|
|
VariableName,
|
|
&gEfiGlobalVariableGuid,
|
|
EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
|
|
VariableSize,
|
|
Variable
|
|
);
|
|
|
|
if (EFI_ERROR (Status)) {
|
|
NameSize = StrSize (VariableName);
|
|
SetVariableStatus = AllocatePool (sizeof (EDKII_SET_VARIABLE_STATUS) + NameSize + VariableSize);
|
|
if (SetVariableStatus != NULL) {
|
|
CopyGuid (&SetVariableStatus->Guid, &gEfiGlobalVariableGuid);
|
|
SetVariableStatus->NameSize = NameSize;
|
|
SetVariableStatus->DataSize = VariableSize;
|
|
SetVariableStatus->SetStatus = Status;
|
|
SetVariableStatus->Attributes = EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
|
|
CopyMem (SetVariableStatus + 1, VariableName, NameSize);
|
|
CopyMem (((UINT8 *) (SetVariableStatus + 1)) + NameSize, Variable, VariableSize);
|
|
|
|
REPORT_STATUS_CODE_EX (
|
|
EFI_ERROR_CODE,
|
|
PcdGet32 (PcdErrorCodeSetVariable),
|
|
0,
|
|
NULL,
|
|
&gEdkiiStatusCodeDataTypeVariableGuid,
|
|
SetVariableStatus,
|
|
sizeof (EDKII_SET_VARIABLE_STATUS) + NameSize + VariableSize
|
|
);
|
|
|
|
FreePool (SetVariableStatus);
|
|
}
|
|
}
|
|
|
|
FreePool (Variable);
|
|
|
|
return ;
|
|
}
|
|
|
|
|
|
/**
|
|
Remove terminal device path from Console Device Environment Variables.
|
|
|
|
@param VariableName Console Device Environment Variables.
|
|
@param ParentDevicePath The terminal device path to be updated.
|
|
|
|
**/
|
|
VOID
|
|
TerminalRemoveConsoleDevVariable (
|
|
IN CHAR16 *VariableName,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
BOOLEAN FoundOne;
|
|
BOOLEAN Match;
|
|
UINTN VariableSize;
|
|
UINTN InstanceSize;
|
|
UINT8 TerminalType;
|
|
EFI_DEVICE_PATH_PROTOCOL *Instance;
|
|
EFI_DEVICE_PATH_PROTOCOL *Variable;
|
|
EFI_DEVICE_PATH_PROTOCOL *OriginalVariable;
|
|
EFI_DEVICE_PATH_PROTOCOL *NewVariable;
|
|
EFI_DEVICE_PATH_PROTOCOL *SavedNewVariable;
|
|
EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
|
|
|
|
Instance = NULL;
|
|
|
|
//
|
|
// Get global variable and its size according to the name given.
|
|
//
|
|
GetEfiGlobalVariable2 (VariableName, (VOID**)&Variable, NULL);
|
|
if (Variable == NULL) {
|
|
return ;
|
|
}
|
|
|
|
FoundOne = FALSE;
|
|
OriginalVariable = Variable;
|
|
NewVariable = NULL;
|
|
|
|
//
|
|
// Get first device path instance from Variable
|
|
//
|
|
Instance = GetNextDevicePathInstance (&Variable, &InstanceSize);
|
|
if (Instance == NULL) {
|
|
FreePool (OriginalVariable);
|
|
return ;
|
|
}
|
|
//
|
|
// Loop through all the device path instances of Variable
|
|
//
|
|
do {
|
|
//
|
|
// Loop through all the terminal types that this driver supports
|
|
//
|
|
Match = FALSE;
|
|
for (TerminalType = PCANSITYPE; TerminalType <= TTYTERMTYPE; TerminalType++) {
|
|
|
|
SetTerminalDevicePath (TerminalType, ParentDevicePath, &TempDevicePath);
|
|
|
|
//
|
|
// Compare the generated device path to the current device path instance
|
|
//
|
|
if (TempDevicePath != NULL) {
|
|
if (CompareMem (Instance, TempDevicePath, InstanceSize) == 0) {
|
|
Match = TRUE;
|
|
FoundOne = TRUE;
|
|
}
|
|
|
|
FreePool (TempDevicePath);
|
|
}
|
|
}
|
|
//
|
|
// If a match was not found, then keep the current device path instance
|
|
//
|
|
if (!Match) {
|
|
SavedNewVariable = NewVariable;
|
|
NewVariable = AppendDevicePathInstance (NewVariable, Instance);
|
|
if (SavedNewVariable != NULL) {
|
|
FreePool (SavedNewVariable);
|
|
}
|
|
}
|
|
//
|
|
// Get next device path instance from Variable
|
|
//
|
|
FreePool (Instance);
|
|
Instance = GetNextDevicePathInstance (&Variable, &InstanceSize);
|
|
} while (Instance != NULL);
|
|
|
|
FreePool (OriginalVariable);
|
|
|
|
if (FoundOne) {
|
|
VariableSize = GetDevicePathSize (NewVariable);
|
|
|
|
Status = gRT->SetVariable (
|
|
VariableName,
|
|
&gEfiGlobalVariableGuid,
|
|
EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
|
|
VariableSize,
|
|
NewVariable
|
|
);
|
|
//
|
|
// Shrinking variable with existing variable driver implementation shouldn't fail.
|
|
//
|
|
ASSERT_EFI_ERROR (Status);
|
|
}
|
|
|
|
if (NewVariable != NULL) {
|
|
FreePool (NewVariable);
|
|
}
|
|
|
|
return ;
|
|
}
|
|
|
|
/**
|
|
Build terminal device path according to terminal type.
|
|
|
|
@param TerminalType The terminal type is PC ANSI, VT100, VT100+ or VT-UTF8.
|
|
@param ParentDevicePath Parent device path.
|
|
@param TerminalDevicePath Returned terminal device path, if building successfully.
|
|
|
|
@retval EFI_UNSUPPORTED Terminal does not belong to the supported type.
|
|
@retval EFI_OUT_OF_RESOURCES Generate terminal device path failed.
|
|
@retval EFI_SUCCESS Build terminal device path successfully.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
SetTerminalDevicePath (
|
|
IN UINT8 TerminalType,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath,
|
|
OUT EFI_DEVICE_PATH_PROTOCOL **TerminalDevicePath
|
|
)
|
|
{
|
|
VENDOR_DEVICE_PATH Node;
|
|
|
|
*TerminalDevicePath = NULL;
|
|
Node.Header.Type = MESSAGING_DEVICE_PATH;
|
|
Node.Header.SubType = MSG_VENDOR_DP;
|
|
|
|
//
|
|
// Generate terminal device path node according to terminal type.
|
|
//
|
|
switch (TerminalType) {
|
|
|
|
case PCANSITYPE:
|
|
CopyGuid (&Node.Guid, &gEfiPcAnsiGuid);
|
|
break;
|
|
|
|
case VT100TYPE:
|
|
CopyGuid (&Node.Guid, &gEfiVT100Guid);
|
|
break;
|
|
|
|
case VT100PLUSTYPE:
|
|
CopyGuid (&Node.Guid, &gEfiVT100PlusGuid);
|
|
break;
|
|
|
|
case VTUTF8TYPE:
|
|
CopyGuid (&Node.Guid, &gEfiVTUTF8Guid);
|
|
break;
|
|
|
|
case TTYTERMTYPE:
|
|
CopyGuid (&Node.Guid, &gEfiTtyTermGuid);
|
|
break;
|
|
|
|
default:
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
//
|
|
// Get VENDOR_DEVCIE_PATH size and put into Node.Header
|
|
//
|
|
SetDevicePathNodeLength (
|
|
&Node.Header,
|
|
sizeof (VENDOR_DEVICE_PATH)
|
|
);
|
|
|
|
//
|
|
// Append the terminal node onto parent device path
|
|
// to generate a complete terminal device path.
|
|
//
|
|
*TerminalDevicePath = AppendDevicePathNode (
|
|
ParentDevicePath,
|
|
(EFI_DEVICE_PATH_PROTOCOL *) &Node
|
|
);
|
|
if (*TerminalDevicePath == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
The user Entry Point for module Terminal. The user code starts with this function.
|
|
|
|
@param ImageHandle The firmware allocated handle for the EFI image.
|
|
@param SystemTable A pointer to the EFI System Table.
|
|
|
|
@retval EFI_SUCCESS The entry point is executed successfully.
|
|
@retval other Some error occurs when executing this entry point.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
InitializeTerminal(
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
|
|
//
|
|
// Install driver model protocol(s).
|
|
//
|
|
Status = EfiLibInstallDriverBindingComponentName2 (
|
|
ImageHandle,
|
|
SystemTable,
|
|
&gTerminalDriverBinding,
|
|
ImageHandle,
|
|
&gTerminalComponentName,
|
|
&gTerminalComponentName2
|
|
);
|
|
ASSERT_EFI_ERROR (Status);
|
|
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Check if the device supports hot-plug through its device path.
|
|
|
|
This function could be updated to check more types of Hot Plug devices.
|
|
Currently, it checks USB and PCCard device.
|
|
|
|
@param DevicePath Pointer to device's device path.
|
|
|
|
@retval TRUE The devcie is a hot-plug device
|
|
@retval FALSE The devcie is not a hot-plug device.
|
|
|
|
**/
|
|
BOOLEAN
|
|
IsHotPlugDevice (
|
|
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
|
|
)
|
|
{
|
|
EFI_DEVICE_PATH_PROTOCOL *CheckDevicePath;
|
|
|
|
CheckDevicePath = DevicePath;
|
|
while (!IsDevicePathEnd (CheckDevicePath)) {
|
|
//
|
|
// Check device whether is hot plug device or not throught Device Path
|
|
//
|
|
if ((DevicePathType (CheckDevicePath) == MESSAGING_DEVICE_PATH) &&
|
|
(DevicePathSubType (CheckDevicePath) == MSG_USB_DP ||
|
|
DevicePathSubType (CheckDevicePath) == MSG_USB_CLASS_DP ||
|
|
DevicePathSubType (CheckDevicePath) == MSG_USB_WWID_DP)) {
|
|
//
|
|
// If Device is USB device
|
|
//
|
|
return TRUE;
|
|
}
|
|
if ((DevicePathType (CheckDevicePath) == HARDWARE_DEVICE_PATH) &&
|
|
(DevicePathSubType (CheckDevicePath) == HW_PCCARD_DP)) {
|
|
//
|
|
// If Device is PCCard
|
|
//
|
|
return TRUE;
|
|
}
|
|
|
|
CheckDevicePath = NextDevicePathNode (CheckDevicePath);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|