audk/MdeModulePkg/Library/UefiBootManagerLib/BmConsole.c

771 lines
24 KiB
C

/** @file
Library functions which contain all the code to connect console device.
Copyright (c) 2011 - 2015, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2015 Hewlett Packard Enterprise Development LP<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 "InternalBm.h"
CHAR16 *mConVarName[] = {
L"ConIn",
L"ConOut",
L"ErrOut",
L"ConInDev",
L"ConOutDev",
L"ErrOutDev"
};
/**
Search out the video controller.
@return PCI device path of the video controller.
**/
EFI_HANDLE
BmGetVideoController (
VOID
)
{
EFI_STATUS Status;
UINTN RootBridgeHandleCount;
EFI_HANDLE *RootBridgeHandleBuffer;
UINTN HandleCount;
EFI_HANDLE *HandleBuffer;
UINTN RootBridgeIndex;
UINTN Index;
EFI_HANDLE VideoController;
EFI_PCI_IO_PROTOCOL *PciIo;
PCI_TYPE00 Pci;
//
// Make all the PCI_IO protocols show up
//
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiPciRootBridgeIoProtocolGuid,
NULL,
&RootBridgeHandleCount,
&RootBridgeHandleBuffer
);
if (EFI_ERROR (Status) || (RootBridgeHandleCount == 0)) {
return NULL;
}
VideoController = NULL;
for (RootBridgeIndex = 0; RootBridgeIndex < RootBridgeHandleCount; RootBridgeIndex++) {
gBS->ConnectController (RootBridgeHandleBuffer[RootBridgeIndex], NULL, NULL, FALSE);
//
// Start to check all the pci io to find the first video controller
//
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiPciIoProtocolGuid,
NULL,
&HandleCount,
&HandleBuffer
);
if (EFI_ERROR (Status)) {
continue;
}
for (Index = 0; Index < HandleCount; Index++) {
Status = gBS->HandleProtocol (HandleBuffer[Index], &gEfiPciIoProtocolGuid, (VOID **) &PciIo);
if (!EFI_ERROR (Status)) {
//
// Check for all video controller
//
Status = PciIo->Pci.Read (
PciIo,
EfiPciIoWidthUint32,
0,
sizeof (Pci) / sizeof (UINT32),
&Pci
);
if (!EFI_ERROR (Status) && IS_PCI_VGA (&Pci)) {
// TODO: use IS_PCI_DISPLAY??
VideoController = HandleBuffer[Index];
break;
}
}
}
FreePool (HandleBuffer);
if (VideoController != NULL) {
break;
}
}
FreePool (RootBridgeHandleBuffer);
return VideoController;
}
/**
Query all the children of VideoController and return the device paths of all the
children that support GraphicsOutput protocol.
@param VideoController PCI handle of video controller.
@return Device paths of all the children that support GraphicsOutput protocol.
**/
EFI_DEVICE_PATH_PROTOCOL *
EFIAPI
EfiBootManagerGetGopDevicePath (
IN EFI_HANDLE VideoController
)
{
UINTN Index;
EFI_STATUS Status;
EFI_GUID **ProtocolBuffer;
UINTN ProtocolBufferCount;
UINTN ProtocolIndex;
EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfoBuffer;
UINTN EntryCount;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
EFI_DEVICE_PATH_PROTOCOL *Next;
EFI_DEVICE_PATH_PROTOCOL *Previous;
EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
EFI_DEVICE_PATH_PROTOCOL *GopPool;
EFI_DEVICE_PATH_PROTOCOL *ReturnDevicePath;
Status = gBS->ProtocolsPerHandle (
VideoController,
&ProtocolBuffer,
&ProtocolBufferCount
);
if (EFI_ERROR (Status)) {
return NULL;
}
GopPool = NULL;
for (ProtocolIndex = 0; ProtocolIndex < ProtocolBufferCount; ProtocolIndex++) {
Status = gBS->OpenProtocolInformation (
VideoController,
ProtocolBuffer[ProtocolIndex],
&OpenInfoBuffer,
&EntryCount
);
if (EFI_ERROR (Status)) {
continue;
}
for (Index = 0; Index < EntryCount; Index++) {
//
// Query all the children
//
if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
Status = gBS->OpenProtocol (
OpenInfoBuffer[Index].ControllerHandle,
&gEfiDevicePathProtocolGuid,
(VOID **) &DevicePath,
NULL,
NULL,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
continue;
}
Previous = NULL;
for (Next = DevicePath; !IsDevicePathEnd (Next); Next = NextDevicePathNode (Next)) {
Previous = Next;
}
ASSERT (Previous != NULL);
if (DevicePathType (Previous) == ACPI_DEVICE_PATH && DevicePathSubType (Previous) == ACPI_ADR_DP) {
Status = gBS->OpenProtocol (
OpenInfoBuffer[Index].ControllerHandle,
&gEfiGraphicsOutputProtocolGuid,
NULL,
NULL,
NULL,
EFI_OPEN_PROTOCOL_TEST_PROTOCOL
);
if (!EFI_ERROR (Status)) {
//
// Append the device path to GOP pool when there is GOP protocol installed.
//
TempDevicePath = GopPool;
GopPool = AppendDevicePathInstance (GopPool, DevicePath);
gBS->FreePool (TempDevicePath);
}
}
if (DevicePathType (Previous) == HARDWARE_DEVICE_PATH && DevicePathSubType (Previous) == HW_CONTROLLER_DP) {
//
// Recursively look for GOP child in this frame buffer handle
//
DEBUG ((EFI_D_INFO, "[Bds] Looking for GOP child deeper ... \n"));
TempDevicePath = GopPool;
ReturnDevicePath = EfiBootManagerGetGopDevicePath (OpenInfoBuffer[Index].ControllerHandle);
GopPool = AppendDevicePathInstance (GopPool, ReturnDevicePath);
gBS->FreePool (ReturnDevicePath);
gBS->FreePool (TempDevicePath);
}
}
}
FreePool (OpenInfoBuffer);
}
FreePool (ProtocolBuffer);
return GopPool;
}
/**
Connect the platform active active video controller.
@param VideoController PCI handle of video controller.
@retval EFI_NOT_FOUND There is no active video controller.
@retval EFI_SUCCESS The video controller is connected.
**/
EFI_STATUS
EFIAPI
EfiBootManagerConnectVideoController (
EFI_HANDLE VideoController OPTIONAL
)
{
EFI_DEVICE_PATH_PROTOCOL *Gop;
if (VideoController == NULL) {
//
// Get the platform vga device
//
VideoController = BmGetVideoController ();
}
if (VideoController == NULL) {
return EFI_NOT_FOUND;
}
//
// Try to connect the PCI device path, so that GOP dirver could start on this
// device and create child handles with GraphicsOutput Protocol installed
// on them, then we get device paths of these child handles and select
// them as possible console device.
//
gBS->ConnectController (VideoController, NULL, NULL, FALSE);
Gop = EfiBootManagerGetGopDevicePath (VideoController);
if (Gop == NULL) {
return EFI_NOT_FOUND;
}
EfiBootManagerUpdateConsoleVariable (ConOut, Gop, NULL);
FreePool (Gop);
//
// Necessary for ConPlatform and ConSplitter driver to start up again after ConOut is updated.
//
return gBS->ConnectController (VideoController, NULL, NULL, TRUE);
}
/**
Fill console handle in System Table if there are no valid console handle in.
Firstly, check the validation of console handle in System Table. If it is invalid,
update it by the first console device handle from EFI console variable.
@param VarName The name of the EFI console variable.
@param ConsoleGuid Specified Console protocol GUID.
@param ConsoleHandle On IN, console handle in System Table to be checked.
On OUT, new console handle in system table.
@param ProtocolInterface On IN, console protocol on console handle in System Table to be checked.
On OUT, new console protocol on new console handle in system table.
@retval TRUE System Table has been updated.
@retval FALSE System Table hasn't been updated.
**/
BOOLEAN
BmUpdateSystemTableConsole (
IN CHAR16 *VarName,
IN EFI_GUID *ConsoleGuid,
IN OUT EFI_HANDLE *ConsoleHandle,
IN OUT VOID **ProtocolInterface
)
{
EFI_STATUS Status;
UINTN DevicePathSize;
EFI_DEVICE_PATH_PROTOCOL *FullDevicePath;
EFI_DEVICE_PATH_PROTOCOL *VarConsole;
EFI_DEVICE_PATH_PROTOCOL *Instance;
EFI_DEVICE_PATH_PROTOCOL *FullInstance;
VOID *Interface;
EFI_HANDLE NewHandle;
EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *TextOut;
ASSERT (VarName != NULL);
ASSERT (ConsoleHandle != NULL);
ASSERT (ConsoleGuid != NULL);
ASSERT (ProtocolInterface != NULL);
if (*ConsoleHandle != NULL) {
Status = gBS->HandleProtocol (
*ConsoleHandle,
ConsoleGuid,
&Interface
);
if (Status == EFI_SUCCESS && Interface == *ProtocolInterface) {
//
// If ConsoleHandle is valid and console protocol on this handle also
// also matched, just return.
//
return FALSE;
}
}
//
// Get all possible consoles device path from EFI variable
//
GetEfiGlobalVariable2 (VarName, (VOID **) &VarConsole, NULL);
if (VarConsole == NULL) {
//
// If there is no any console device, just return.
//
return FALSE;
}
FullDevicePath = VarConsole;
do {
//
// Check every instance of the console variable
//
Instance = GetNextDevicePathInstance (&VarConsole, &DevicePathSize);
if (Instance == NULL) {
DEBUG ((EFI_D_ERROR, "[Bds] No valid console instance is found for %s!\n", VarName));
// We should not ASSERT when all the console devices are removed.
// ASSERT_EFI_ERROR (EFI_NOT_FOUND);
FreePool (FullDevicePath);
return FALSE;
}
//
// Find console device handle by device path instance
//
FullInstance = Instance;
Status = gBS->LocateDevicePath (
ConsoleGuid,
&Instance,
&NewHandle
);
FreePool (FullInstance);
if (!EFI_ERROR (Status)) {
//
// Get the console protocol on this console device handle
//
Status = gBS->HandleProtocol (
NewHandle,
ConsoleGuid,
&Interface
);
if (!EFI_ERROR (Status)) {
//
// Update new console handle in System Table.
//
*ConsoleHandle = NewHandle;
*ProtocolInterface = Interface;
if (CompareGuid (ConsoleGuid, &gEfiSimpleTextOutProtocolGuid)) {
//
// If it is console out device, set console mode 80x25 if current mode is invalid.
//
TextOut = (EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *) Interface;
if (TextOut->Mode->Mode == -1) {
TextOut->SetMode (TextOut, 0);
}
}
FreePool (FullDevicePath);
return TRUE;
}
}
} while (Instance != NULL);
//
// No any available console devcie found.
//
FreePool (FullDevicePath);
return FALSE;
}
/**
This function updates the console variable based on ConVarName. It can
add or remove one specific console device path from the variable
@param ConsoleType ConIn, ConOut, ErrOut, ConInDev, ConOutDev or ErrOutDev.
@param CustomizedConDevicePath The console device path to be added to
the console variable. Cannot be multi-instance.
@param ExclusiveDevicePath The console device path to be removed
from the console variable. Cannot be multi-instance.
@retval EFI_UNSUPPORTED The added device path is the same as a removed one.
@retval EFI_SUCCESS Successfully added or removed the device path from the
console variable.
@retval others Return status of RT->SetVariable().
**/
EFI_STATUS
EFIAPI
EfiBootManagerUpdateConsoleVariable (
IN CONSOLE_TYPE ConsoleType,
IN EFI_DEVICE_PATH_PROTOCOL *CustomizedConDevicePath,
IN EFI_DEVICE_PATH_PROTOCOL *ExclusiveDevicePath
)
{
EFI_STATUS Status;
EFI_DEVICE_PATH_PROTOCOL *VarConsole;
EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
EFI_DEVICE_PATH_PROTOCOL *TempNewDevicePath;
if (ConsoleType >= sizeof (mConVarName) / sizeof (mConVarName[0])) {
return EFI_INVALID_PARAMETER;
}
//
// Notes: check the device path point, here should check
// with compare memory
//
if (CustomizedConDevicePath == ExclusiveDevicePath) {
return EFI_UNSUPPORTED;
}
//
// Delete the ExclusiveDevicePath from current default console
//
GetEfiGlobalVariable2 (mConVarName[ConsoleType], (VOID **) &VarConsole, NULL);
//
// Initialize NewDevicePath
//
NewDevicePath = VarConsole;
//
// If ExclusiveDevicePath is even the part of the instance in VarConsole, delete it.
// In the end, NewDevicePath is the final device path.
//
if (ExclusiveDevicePath != NULL && VarConsole != NULL) {
NewDevicePath = BmDelPartMatchInstance (VarConsole, ExclusiveDevicePath);
}
//
// Try to append customized device path to NewDevicePath.
//
if (CustomizedConDevicePath != NULL) {
if (!BmMatchDevicePaths (NewDevicePath, CustomizedConDevicePath)) {
//
// Check if there is part of CustomizedConDevicePath in NewDevicePath, delete it.
//
NewDevicePath = BmDelPartMatchInstance (NewDevicePath, CustomizedConDevicePath);
//
// In the first check, the default console variable will be _ModuleEntryPoint,
// just append current customized device path
//
TempNewDevicePath = NewDevicePath;
NewDevicePath = AppendDevicePathInstance (NewDevicePath, CustomizedConDevicePath);
if (TempNewDevicePath != NULL) {
FreePool(TempNewDevicePath);
}
}
}
//
// Finally, Update the variable of the default console by NewDevicePath
//
Status = gRT->SetVariable (
mConVarName[ConsoleType],
&gEfiGlobalVariableGuid,
EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS
| ((ConsoleType < ConInDev) ? EFI_VARIABLE_NON_VOLATILE : 0),
GetDevicePathSize (NewDevicePath),
NewDevicePath
);
if (VarConsole == NewDevicePath) {
if (VarConsole != NULL) {
FreePool(VarConsole);
}
} else {
if (VarConsole != NULL) {
FreePool(VarConsole);
}
if (NewDevicePath != NULL) {
FreePool(NewDevicePath);
}
}
return Status;
}
/**
Connect the console device base on the variable ConsoleType.
@param ConsoleType ConIn, ConOut or ErrOut.
@retval EFI_NOT_FOUND There is not any console devices connected
success
@retval EFI_SUCCESS Success connect any one instance of the console
device path base on the variable ConVarName.
**/
EFI_STATUS
EFIAPI
EfiBootManagerConnectConsoleVariable (
IN CONSOLE_TYPE ConsoleType
)
{
EFI_STATUS Status;
EFI_DEVICE_PATH_PROTOCOL *StartDevicePath;
EFI_DEVICE_PATH_PROTOCOL *Instance;
EFI_DEVICE_PATH_PROTOCOL *Next;
EFI_DEVICE_PATH_PROTOCOL *CopyOfDevicePath;
UINTN Size;
BOOLEAN DeviceExist;
EFI_HANDLE Handle;
if ((ConsoleType != ConIn) && (ConsoleType != ConOut) && (ConsoleType != ErrOut)) {
return EFI_INVALID_PARAMETER;
}
Status = EFI_SUCCESS;
DeviceExist = FALSE;
Handle = NULL;
//
// Check if the console variable exist
//
GetEfiGlobalVariable2 (mConVarName[ConsoleType], (VOID **) &StartDevicePath, NULL);
if (StartDevicePath == NULL) {
return EFI_UNSUPPORTED;
}
CopyOfDevicePath = StartDevicePath;
do {
//
// Check every instance of the console variable
//
Instance = GetNextDevicePathInstance (&CopyOfDevicePath, &Size);
if (Instance == NULL) {
FreePool (StartDevicePath);
return EFI_UNSUPPORTED;
}
Next = Instance;
while (!IsDevicePathEndType (Next)) {
Next = NextDevicePathNode (Next);
}
SetDevicePathEndNode (Next);
//
// Connect the USB console
// USB console device path is a short-form device path that
// starts with the first element being a USB WWID
// or a USB Class device path
//
if ((DevicePathType (Instance) == MESSAGING_DEVICE_PATH) &&
((DevicePathSubType (Instance) == MSG_USB_CLASS_DP) || (DevicePathSubType (Instance) == MSG_USB_WWID_DP))
) {
Status = BmConnectUsbShortFormDevicePath (Instance);
if (!EFI_ERROR (Status)) {
DeviceExist = TRUE;
}
} else {
for (Next = Instance; !IsDevicePathEnd (Next); Next = NextDevicePathNode (Next)) {
if (DevicePathType (Next) == ACPI_DEVICE_PATH && DevicePathSubType (Next) == ACPI_ADR_DP) {
break;
} else if (DevicePathType (Next) == HARDWARE_DEVICE_PATH &&
DevicePathSubType (Next) == HW_CONTROLLER_DP &&
DevicePathType (NextDevicePathNode (Next)) == ACPI_DEVICE_PATH &&
DevicePathSubType (NextDevicePathNode (Next)) == ACPI_ADR_DP
) {
break;
}
}
if (!IsDevicePathEnd (Next)) {
//
// For GOP device path, start the video driver with NULL remaining device path
//
SetDevicePathEndNode (Next);
Status = EfiBootManagerConnectDevicePath (Instance, &Handle);
if (!EFI_ERROR (Status)) {
gBS->ConnectController (Handle, NULL, NULL, TRUE);
}
} else {
Status = EfiBootManagerConnectDevicePath (Instance, NULL);
}
if (EFI_ERROR (Status)) {
//
// Delete the instance from the console varialbe
//
EfiBootManagerUpdateConsoleVariable (ConsoleType, NULL, Instance);
} else {
DeviceExist = TRUE;
}
}
FreePool(Instance);
} while (CopyOfDevicePath != NULL);
FreePool (StartDevicePath);
if (!DeviceExist) {
return EFI_NOT_FOUND;
}
return EFI_SUCCESS;
}
/**
This function will search every input/output device in current system,
and make every input/output device as potential console device.
**/
VOID
EFIAPI
EfiBootManagerConnectAllConsoles (
VOID
)
{
UINTN Index;
EFI_DEVICE_PATH_PROTOCOL *ConDevicePath;
UINTN HandleCount;
EFI_HANDLE *HandleBuffer;
Index = 0;
HandleCount = 0;
HandleBuffer = NULL;
ConDevicePath = NULL;
//
// Update all the console variables
//
gBS->LocateHandleBuffer (
ByProtocol,
&gEfiSimpleTextInProtocolGuid,
NULL,
&HandleCount,
&HandleBuffer
);
for (Index = 0; Index < HandleCount; Index++) {
gBS->HandleProtocol (
HandleBuffer[Index],
&gEfiDevicePathProtocolGuid,
(VOID **) &ConDevicePath
);
EfiBootManagerUpdateConsoleVariable (ConIn, ConDevicePath, NULL);
}
if (HandleBuffer != NULL) {
FreePool(HandleBuffer);
HandleBuffer = NULL;
}
gBS->LocateHandleBuffer (
ByProtocol,
&gEfiSimpleTextOutProtocolGuid,
NULL,
&HandleCount,
&HandleBuffer
);
for (Index = 0; Index < HandleCount; Index++) {
gBS->HandleProtocol (
HandleBuffer[Index],
&gEfiDevicePathProtocolGuid,
(VOID **) &ConDevicePath
);
EfiBootManagerUpdateConsoleVariable (ConOut, ConDevicePath, NULL);
EfiBootManagerUpdateConsoleVariable (ErrOut, ConDevicePath, NULL);
}
if (HandleBuffer != NULL) {
FreePool(HandleBuffer);
}
//
// Connect all console variables
//
EfiBootManagerConnectAllDefaultConsoles ();
}
/**
This function will connect all the console devices base on the console
device variable ConIn, ConOut and ErrOut.
@retval EFI_DEVICE_ERROR All the consoles were not connected due to an error.
@retval EFI_SUCCESS Success connect any one instance of the console
device path base on the variable ConVarName.
**/
EFI_STATUS
EFIAPI
EfiBootManagerConnectAllDefaultConsoles (
VOID
)
{
EFI_STATUS Status;
BOOLEAN OneConnected;
BOOLEAN SystemTableUpdated;
OneConnected = FALSE;
Status = EfiBootManagerConnectConsoleVariable (ConOut);
if (!EFI_ERROR (Status)) {
OneConnected = TRUE;
}
PERF_START (NULL, "ConOutReady", "BDS", 1);
PERF_END (NULL, "ConOutReady", "BDS", 0);
Status = EfiBootManagerConnectConsoleVariable (ConIn);
if (!EFI_ERROR (Status)) {
OneConnected = TRUE;
}
PERF_START (NULL, "ConInReady", "BDS", 1);
PERF_END (NULL, "ConInReady", "BDS", 0);
Status = EfiBootManagerConnectConsoleVariable (ErrOut);
if (!EFI_ERROR (Status)) {
OneConnected = TRUE;
}
PERF_START (NULL, "ErrOutReady", "BDS", 1);
PERF_END (NULL, "ErrOutReady", "BDS", 0);
SystemTableUpdated = FALSE;
//
// Fill console handles in System Table if no console device assignd.
//
if (BmUpdateSystemTableConsole (L"ConIn", &gEfiSimpleTextInProtocolGuid, &gST->ConsoleInHandle, (VOID **) &gST->ConIn)) {
SystemTableUpdated = TRUE;
}
if (BmUpdateSystemTableConsole (L"ConOut", &gEfiSimpleTextOutProtocolGuid, &gST->ConsoleOutHandle, (VOID **) &gST->ConOut)) {
SystemTableUpdated = TRUE;
}
if (BmUpdateSystemTableConsole (L"ErrOut", &gEfiSimpleTextOutProtocolGuid, &gST->StandardErrorHandle, (VOID **) &gST->StdErr)) {
SystemTableUpdated = TRUE;
}
if (SystemTableUpdated) {
//
// Update the CRC32 in the EFI System Table header
//
gST->Hdr.CRC32 = 0;
gBS->CalculateCrc32 (
(UINT8 *) &gST->Hdr,
gST->Hdr.HeaderSize,
&gST->Hdr.CRC32
);
}
return OneConnected ? EFI_SUCCESS : EFI_DEVICE_ERROR;
}