/**
Show progress bar with title above it. It only works in Graphics mode.
@param TitleForeground Foreground color for Title.
@param TitleBackground Background color for Title.
@param Title Title above progress bar.
@param ProgressColor Progress bar color.
@param Progress Progress (0-100)
@param PreviousValue The previous value of the progress.
@retval EFI_STATUS Success update the progress bar
**/
EFI_STATUS
PlatformBdsShowProgress (
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL TitleForeground,
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL TitleBackground,
IN CHAR16 *Title,
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL ProgressColor,
IN UINTN Progress,
IN UINTN PreviousValue
)
{
EFI_STATUS Status;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
EFI_UGA_DRAW_PROTOCOL *UgaDraw;
UINT32 SizeOfX;
UINT32 SizeOfY;
UINT32 ColorDepth;
UINT32 RefreshRate;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL Color;
UINTN BlockHeight;
UINTN BlockWidth;
UINTN BlockNum;
UINTN PosX;
UINTN PosY;
UINTN Index;
if (Progress > 100) {
return EFI_INVALID_PARAMETER;
}
UgaDraw = NULL;
Status = gBS->HandleProtocol (
gST->ConsoleOutHandle,
&gEfiGraphicsOutputProtocolGuid,
(VOID **) &GraphicsOutput
);
if (EFI_ERROR (Status) && FeaturePcdGet (PcdUgaConsumeSupport)) {
GraphicsOutput = NULL;
Status = gBS->HandleProtocol (
gST->ConsoleOutHandle,
&gEfiUgaDrawProtocolGuid,
(VOID **) &UgaDraw
);
}
if (EFI_ERROR (Status)) {
return EFI_UNSUPPORTED;
}
SizeOfX = 0;
SizeOfY = 0;
if (GraphicsOutput != NULL) {
SizeOfX = GraphicsOutput->Mode->Info->HorizontalResolution;
SizeOfY = GraphicsOutput->Mode->Info->VerticalResolution;
} else if (UgaDraw != NULL) {
Status = UgaDraw->GetMode (
UgaDraw,
&SizeOfX,
&SizeOfY,
&ColorDepth,
&RefreshRate
);
if (EFI_ERROR (Status)) {
return EFI_UNSUPPORTED;
}
} else {
return EFI_UNSUPPORTED;
}
BlockWidth = SizeOfX / 100;
BlockHeight = SizeOfY / 50;
BlockNum = Progress;
PosX = 0;
PosY = SizeOfY * 48 / 50;
if (BlockNum == 0) {
//
// Clear progress area
//
SetMem (&Color, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0);
if (GraphicsOutput != NULL) {
Status = GraphicsOutput->Blt (
GraphicsOutput,
&Color,
EfiBltVideoFill,
0,
0,
0,
PosY - EFI_GLYPH_HEIGHT - 1,
SizeOfX,
SizeOfY - (PosY - EFI_GLYPH_HEIGHT - 1),
SizeOfX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
);
} else if (FeaturePcdGet (PcdUgaConsumeSupport)) {
Status = UgaDraw->Blt (
UgaDraw,
(EFI_UGA_PIXEL *) &Color,
EfiUgaVideoFill,
0,
0,
0,
PosY - EFI_GLYPH_HEIGHT - 1,
SizeOfX,
SizeOfY - (PosY - EFI_GLYPH_HEIGHT - 1),
SizeOfX * sizeof (EFI_UGA_PIXEL)
);
} else {
return EFI_UNSUPPORTED;
}
}
//
// Show progress by drawing blocks
//
for (Index = PreviousValue; Index < BlockNum; Index++) {
PosX = Index * BlockWidth;
if (GraphicsOutput != NULL) {
Status = GraphicsOutput->Blt (
GraphicsOutput,
&ProgressColor,
EfiBltVideoFill,
0,
0,
PosX,
PosY,
BlockWidth - 1,
BlockHeight,
(BlockWidth) * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
);
} else if (FeaturePcdGet (PcdUgaConsumeSupport)) {
Status = UgaDraw->Blt (
UgaDraw,
(EFI_UGA_PIXEL *) &ProgressColor,
EfiUgaVideoFill,
0,
0,
PosX,
PosY,
BlockWidth - 1,
BlockHeight,
(BlockWidth) * sizeof (EFI_UGA_PIXEL)
);
} else {
return EFI_UNSUPPORTED;
}
}
PrintXY (
(SizeOfX - StrLen (Title) * EFI_GLYPH_WIDTH) / 2,
PosY - EFI_GLYPH_HEIGHT - 1,
&TitleForeground,
&TitleBackground,
Title
);
return EFI_SUCCESS;
}
/**
Set the video device into the specified mode and clears the visible portions of
the output display to black.
@param This The EFI_GRAPHICS_OUTPUT_PROTOCOL instance.
@param ModeNumber Abstraction that defines the current video mode.
@retval EFI_SUCCESS The graphics mode specified by ModeNumber was selected.
@retval EFI_DEVICE_ERROR The device had an error and could not complete the request.
@retval EFI_UNSUPPORTED ModeNumber is not supported by this device.
@retval EFI_OUT_OF_RESOURCES No resource available.
**/
EFI_STATUS
EFIAPI
ConSplitterGraphicsOutputSetMode (
IN EFI_GRAPHICS_OUTPUT_PROTOCOL * This,
IN UINT32 ModeNumber
)
{
EFI_STATUS Status;
TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;
UINTN Index;
EFI_STATUS ReturnStatus;
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Mode;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
UINTN NumberIndex;
UINTN SizeOfInfo;
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;
EFI_UGA_DRAW_PROTOCOL *UgaDraw;
if (ModeNumber >= This->Mode->MaxMode) {
return EFI_UNSUPPORTED;
}
Private = GRAPHICS_OUTPUT_SPLITTER_PRIVATE_DATA_FROM_THIS (This);
Mode = &Private->GraphicsOutputModeBuffer[ModeNumber];
ReturnStatus = EFI_SUCCESS;
//
// return the worst status met
//
for (Index = 0; Index < Private->CurrentNumberOfConsoles; Index++) {
GraphicsOutput = Private->TextOutList[Index].GraphicsOutput;
if (GraphicsOutput != NULL) {
//
// Find corresponding ModeNumber of this GraphicsOutput instance
//
for (NumberIndex = 0; NumberIndex < GraphicsOutput->Mode->MaxMode; NumberIndex ++) {
Status = GraphicsOutput->QueryMode (GraphicsOutput, (UINT32) NumberIndex, &SizeOfInfo, &Info);
if (EFI_ERROR (Status)) {
return Status;
}
if ((Info->HorizontalResolution == Mode->HorizontalResolution) && (Info->VerticalResolution == Mode->VerticalResolution)) {
FreePool (Info);
break;
}
FreePool (Info);
}
Status = GraphicsOutput->SetMode (GraphicsOutput, (UINT32) NumberIndex);
if (EFI_ERROR (Status)) {
ReturnStatus = Status;
}
} else if (FeaturePcdGet (PcdUgaConsumeSupport)) {
UgaDraw = Private->TextOutList[Index].UgaDraw;
if (UgaDraw != NULL) {
Status = UgaDraw->SetMode (
UgaDraw,
Mode->HorizontalResolution,
Mode->VerticalResolution,
32,
60
);
if (EFI_ERROR (Status)) {
ReturnStatus = Status;
}
}
}
}
This->Mode->Mode = ModeNumber;
CopyMem (This->Mode->Info, &Private->GraphicsOutputModeBuffer[ModeNumber], This->Mode->SizeOfInfo);
//
// Information is not enough here, so the following items remain unchanged:
// GraphicsOutputMode->Info->Version, GraphicsOutputMode->Info->PixelFormat
// GraphicsOutputMode->SizeOfInfo, GraphicsOutputMode->FrameBufferBase, GraphicsOutputMode->FrameBufferSize
// These items will be initialized/updated when a new GOP device is added into ConsoleSplitter.
//
return ReturnStatus;
}
/**
This function will change video resolution and text mode
according to defined setup mode or defined boot mode
@param IsSetupMode Indicate mode is changed to setup mode or boot mode.
@retval EFI_SUCCESS Mode is changed successfully.
@retval Others Mode failed to be changed.
**/
EFI_STATUS
EFIAPI
BmBdsSetConsoleMode (
BOOLEAN IsSetupMode
)
{
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *SimpleTextOut;
UINTN SizeOfInfo;
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;
UINT32 MaxGopMode;
UINT32 MaxTextMode;
UINT32 ModeNumber;
UINT32 NewHorizontalResolution;
UINT32 NewVerticalResolution;
UINT32 NewColumns;
UINT32 NewRows;
UINTN HandleCount;
EFI_HANDLE *HandleBuffer;
EFI_STATUS Status;
UINTN Index;
UINTN CurrentColumn;
UINTN CurrentRow;
MaxGopMode = 0;
MaxTextMode = 0;
//
// Get current video resolution and text mode
//
Status = gBS->HandleProtocol (
gST->ConsoleOutHandle,
&gEfiGraphicsOutputProtocolGuid,
(VOID**)&GraphicsOutput
);
if (EFI_ERROR (Status)) {
GraphicsOutput = NULL;
}
Status = gBS->HandleProtocol (
gST->ConsoleOutHandle,
&gEfiSimpleTextOutProtocolGuid,
(VOID**)&SimpleTextOut
);
if (EFI_ERROR (Status)) {
SimpleTextOut = NULL;
}
if ((GraphicsOutput == NULL) || (SimpleTextOut == NULL)) {
return EFI_UNSUPPORTED;
}
if (IsSetupMode) {
//
// The requried resolution and text mode is setup mode.
//
NewHorizontalResolution = mBmSetupHorizontalResolution;
NewVerticalResolution = mBmSetupVerticalResolution;
NewColumns = mBmSetupTextModeColumn;
NewRows = mBmSetupTextModeRow;
} else {
//
// The required resolution and text mode is boot mode.
//
NewHorizontalResolution = mBmBootHorizontalResolution;
NewVerticalResolution = mBmBootVerticalResolution;
NewColumns = mBmBootTextModeColumn;
NewRows = mBmBootTextModeRow;
}
if (GraphicsOutput != NULL) {
MaxGopMode = GraphicsOutput->Mode->MaxMode;
}
if (SimpleTextOut != NULL) {
MaxTextMode = SimpleTextOut->Mode->MaxMode;
}
//
// 1. If current video resolution is same with required video resolution,
// video resolution need not be changed.
// 1.1. If current text mode is same with required text mode, text mode need not be changed.
// 1.2. If current text mode is different from required text mode, text mode need be changed.
// 2. If current video resolution is different from required video resolution, we need restart whole console drivers.
//
for (ModeNumber = 0; ModeNumber < MaxGopMode; ModeNumber++) {
Status = GraphicsOutput->QueryMode (
GraphicsOutput,
ModeNumber,
&SizeOfInfo,
&Info
);
if (!EFI_ERROR (Status)) {
if ((Info->HorizontalResolution == NewHorizontalResolution) &&
(Info->VerticalResolution == NewVerticalResolution)) {
if ((GraphicsOutput->Mode->Info->HorizontalResolution == NewHorizontalResolution) &&
(GraphicsOutput->Mode->Info->VerticalResolution == NewVerticalResolution)) {
//
// Current resolution is same with required resolution, check if text mode need be set
//
Status = SimpleTextOut->QueryMode (SimpleTextOut, SimpleTextOut->Mode->Mode, &CurrentColumn, &CurrentRow);
ASSERT_EFI_ERROR (Status);
if (CurrentColumn == NewColumns && CurrentRow == NewRows) {
//
// If current text mode is same with required text mode. Do nothing
//
FreePool (Info);
return EFI_SUCCESS;
} else {
//
// If current text mode is different from requried text mode. Set new video mode
//
for (Index = 0; Index < MaxTextMode; Index++) {
Status = SimpleTextOut->QueryMode (SimpleTextOut, Index, &CurrentColumn, &CurrentRow);
if (!EFI_ERROR(Status)) {
if ((CurrentColumn == NewColumns) && (CurrentRow == NewRows)) {
//
// Required text mode is supported, set it.
//
Status = SimpleTextOut->SetMode (SimpleTextOut, Index);
ASSERT_EFI_ERROR (Status);
//
// Update text mode PCD.
//
Status = PcdSet32S (PcdConOutColumn, mBmSetupTextModeColumn);
ASSERT_EFI_ERROR (Status);
Status = PcdSet32S (PcdConOutRow, mBmSetupTextModeRow);
ASSERT_EFI_ERROR (Status);
FreePool (Info);
return EFI_SUCCESS;
}
}
}
if (Index == MaxTextMode) {
//
// If requried text mode is not supported, return error.
//
FreePool (Info);
return EFI_UNSUPPORTED;
}
}
} else {
//
// If current video resolution is not same with the new one, set new video resolution.
// In this case, the driver which produces simple text out need be restarted.
//
Status = GraphicsOutput->SetMode (GraphicsOutput, ModeNumber);
if (!EFI_ERROR (Status)) {
FreePool (Info);
break;
}
}
}
FreePool (Info);
}
}
if (ModeNumber == MaxGopMode) {
//
// If the resolution is not supported, return error.
//
return EFI_UNSUPPORTED;
}
//
// Set PCD to Inform GraphicsConsole to change video resolution.
// Set PCD to Inform Consplitter to change text mode.
//
Status = PcdSet32S (PcdVideoHorizontalResolution, NewHorizontalResolution);
ASSERT_EFI_ERROR (Status);
Status = PcdSet32S (PcdVideoVerticalResolution, NewVerticalResolution);
ASSERT_EFI_ERROR (Status);
Status = PcdSet32S (PcdConOutColumn, NewColumns);
ASSERT_EFI_ERROR (Status);
Status = PcdSet32S (PcdConOutRow, NewRows);
ASSERT_EFI_ERROR (Status);
//
// Video mode is changed, so restart graphics console driver and higher level driver.
// Reconnect graphics console driver and higher level driver.
// Locate all the handles with GOP protocol and reconnect it.
//
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiSimpleTextOutProtocolGuid,
NULL,
&HandleCount,
&HandleBuffer
);
if (!EFI_ERROR (Status)) {
for (Index = 0; Index < HandleCount; Index++) {
gBS->DisconnectController (HandleBuffer[Index], NULL, NULL);
}
for (Index = 0; Index < HandleCount; Index++) {
gBS->ConnectController (HandleBuffer[Index], NULL, NULL, TRUE);
}
if (HandleBuffer != NULL) {
FreePool (HandleBuffer);
}
}
return EFI_SUCCESS;
}
/**
Set the current video mode information.
@param This The EFI_UGA_DRAW_PROTOCOL instance.
@param HorizontalResolution The size of video screen in pixels in the X dimension.
@param VerticalResolution The size of video screen in pixels in the Y dimension.
@param ColorDepth Number of bits per pixel, currently defined to be 32.
@param RefreshRate The refresh rate of the monitor in Hertz.
@retval EFI_SUCCESS Mode information returned.
@retval EFI_NOT_STARTED Video display is not initialized. Call SetMode ()
@retval EFI_OUT_OF_RESOURCES Out of resources.
**/
EFI_STATUS
EFIAPI
ConSplitterUgaDrawSetMode (
IN EFI_UGA_DRAW_PROTOCOL *This,
IN UINT32 HorizontalResolution,
IN UINT32 VerticalResolution,
IN UINT32 ColorDepth,
IN UINT32 RefreshRate
)
{
EFI_STATUS Status;
TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;
UINTN Index;
EFI_STATUS ReturnStatus;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
UINTN NumberIndex;
UINTN SizeOfInfo;
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;
EFI_UGA_DRAW_PROTOCOL *UgaDraw;
Private = UGA_DRAW_SPLITTER_PRIVATE_DATA_FROM_THIS (This);
ReturnStatus = EFI_SUCCESS;
//
// Update the Mode data
//
Private->UgaHorizontalResolution = HorizontalResolution;
Private->UgaVerticalResolution = VerticalResolution;
Private->UgaColorDepth = ColorDepth;
Private->UgaRefreshRate = RefreshRate;
//
// return the worst status met
//
for (Index = 0; Index < Private->CurrentNumberOfConsoles; Index++) {
GraphicsOutput = Private->TextOutList[Index].GraphicsOutput;
if (GraphicsOutput != NULL) {
//
// Find corresponding ModeNumber of this GraphicsOutput instance
//
for (NumberIndex = 0; NumberIndex < GraphicsOutput->Mode->MaxMode; NumberIndex ++) {
Status = GraphicsOutput->QueryMode (GraphicsOutput, (UINT32) NumberIndex, &SizeOfInfo, &Info);
if (EFI_ERROR (Status)) {
return Status;
}
if ((Info->HorizontalResolution == HorizontalResolution) && (Info->VerticalResolution == VerticalResolution)) {
FreePool (Info);
break;
}
FreePool (Info);
}
Status = GraphicsOutput->SetMode (GraphicsOutput, (UINT32) NumberIndex);
if (EFI_ERROR (Status)) {
ReturnStatus = Status;
}
} else if (FeaturePcdGet (PcdUgaConsumeSupport)){
UgaDraw = Private->TextOutList[Index].UgaDraw;
if (UgaDraw != NULL) {
Status = UgaDraw->SetMode (
UgaDraw,
HorizontalResolution,
VerticalResolution,
ColorDepth,
RefreshRate
);
if (EFI_ERROR (Status)) {
ReturnStatus = Status;
}
}
}
}
return ReturnStatus;
}
/**
Blt a rectangle of pixels on the graphics screen.
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.
@param This Protocol instance pointer.
@param BltBuffer Buffer containing data to blit into video buffer. This
buffer has a size of Width*Height*sizeof(EFI_UGA_PIXEL)
@param BltOperation Operation to perform on BlitBuffer and video memory
@param SourceX X coordinate of source for the BltBuffer.
@param SourceY Y coordinate of source for the BltBuffer.
@param DestinationX X coordinate of destination for the BltBuffer.
@param DestinationY Y coordinate of destination for the BltBuffer.
@param Width Width of rectangle in BltBuffer in pixels.
@param Height Hight of rectangle in BltBuffer in pixels.
@param Delta OPTIONAL
@retval EFI_SUCCESS The Blt operation completed.
@retval EFI_INVALID_PARAMETER BltOperation is not valid.
@retval EFI_DEVICE_ERROR A hardware error occured writting to the video buffer.
**/
EFI_STATUS
EFIAPI
ConSplitterUgaDrawBlt (
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
)
{
EFI_STATUS Status;
TEXT_OUT_SPLITTER_PRIVATE_DATA *Private;
UINTN Index;
EFI_STATUS ReturnStatus;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
Private = UGA_DRAW_SPLITTER_PRIVATE_DATA_FROM_THIS (This);
ReturnStatus = EFI_SUCCESS;
//
// return the worst status met
//
for (Index = 0; Index < Private->CurrentNumberOfConsoles; Index++) {
GraphicsOutput = Private->TextOutList[Index].GraphicsOutput;
if (GraphicsOutput != NULL) {
Status = GraphicsOutput->Blt (
GraphicsOutput,
(EFI_GRAPHICS_OUTPUT_BLT_PIXEL *) BltBuffer,
(EFI_GRAPHICS_OUTPUT_BLT_OPERATION) 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;
}
}
if (Private->TextOutList[Index].UgaDraw != NULL && FeaturePcdGet (PcdUgaConsumeSupport)) {
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
QemuVideoGraphicsOutputConstructor (
QEMU_VIDEO_PRIVATE_DATA *Private
)
{
EFI_STATUS Status;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
GraphicsOutput = &Private->GraphicsOutput;
GraphicsOutput->QueryMode = QemuVideoGraphicsOutputQueryMode;
GraphicsOutput->SetMode = QemuVideoGraphicsOutputSetMode;
GraphicsOutput->Blt = QemuVideoGraphicsOutputBlt;
//
// Initialize the private data
//
Status = gBS->AllocatePool (
EfiBootServicesData,
sizeof (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE),
(VOID **) &Private->GraphicsOutput.Mode
);
if (EFI_ERROR (Status)) {
return Status;
}
Status = gBS->AllocatePool (
EfiBootServicesData,
sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION),
(VOID **) &Private->GraphicsOutput.Mode->Info
);
if (EFI_ERROR (Status)) {
goto FreeMode;
}
Private->GraphicsOutput.Mode->MaxMode = (UINT32) Private->MaxMode;
Private->GraphicsOutput.Mode->Mode = GRAPHICS_OUTPUT_INVALIDE_MODE_NUMBER;
Private->FrameBufferBltConfigure = NULL;
Private->FrameBufferBltConfigureSize = 0;
//
// Initialize the hardware
//
Status = GraphicsOutput->SetMode (GraphicsOutput, 0);
if (EFI_ERROR (Status)) {
goto FreeInfo;
}
DrawLogo (
Private,
Private->ModeData[Private->GraphicsOutput.Mode->Mode].HorizontalResolution,
Private->ModeData[Private->GraphicsOutput.Mode->Mode].VerticalResolution
);
return EFI_SUCCESS;
FreeInfo:
FreePool (Private->GraphicsOutput.Mode->Info);
FreeMode:
FreePool (Private->GraphicsOutput.Mode);
Private->GraphicsOutput.Mode = NULL;
return Status;
}
EFI_STATUS
EnableQuietBootEx (
IN EFI_GUID *LogoFile,
IN EFI_HANDLE ImageHandle
)
/*++
Routine Description:
Use Console Control to turn off GOP/UGA based Simple Text Out consoles from going
to the GOP/UGA device. Put up LogoFile on every GOP/UGA device that is a console
Arguments:
LogoFile - File name of logo to display on the center of the screen.
ImageHandle - The driver image handle of the caller. The parameter is used to
optimize the loading of the logo file so that the FV from which
the driver image is loaded will be tried first.
Returns:
EFI_SUCCESS - ConsoleControl has been flipped to graphics and logo
displayed.
EFI_UNSUPPORTED - Logo not found
--*/
{
EFI_STATUS Status;
EFI_CONSOLE_CONTROL_PROTOCOL *ConsoleControl;
EFI_OEM_BADGING_PROTOCOL *Badging;
UINT32 SizeOfX;
UINT32 SizeOfY;
INTN DestX;
INTN DestY;
UINT8 *ImageData;
UINTN ImageSize;
UINTN BltSize;
UINT32 Instance;
EFI_BADGING_FORMAT Format;
EFI_BADGING_DISPLAY_ATTRIBUTE Attribute;
UINTN CoordinateX;
UINTN CoordinateY;
UINTN Height;
UINTN Width;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
EFI_UGA_DRAW_PROTOCOL *UgaDraw;
UINT32 ColorDepth;
UINT32 RefreshRate;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
Status = gBS->LocateProtocol (&gEfiConsoleControlProtocolGuid, NULL, (VOID**)&ConsoleControl);
if (EFI_ERROR (Status)) {
return EFI_UNSUPPORTED;
}
UgaDraw = NULL;
//
// Try to open GOP first
//
Status = gBS->HandleProtocol (gST->ConsoleOutHandle, &gEfiGraphicsOutputProtocolGuid, (VOID**)&GraphicsOutput);
if (EFI_ERROR (Status)) {
GraphicsOutput = NULL;
//
// Open GOP failed, try to open UGA
//
Status = gBS->HandleProtocol (gST->ConsoleOutHandle, &gEfiUgaDrawProtocolGuid, (VOID**)&UgaDraw);
if (EFI_ERROR (Status)) {
return EFI_UNSUPPORTED;
}
}
Badging = NULL;
Status = gBS->LocateProtocol (&gEfiOEMBadgingProtocolGuid, NULL, (VOID**)&Badging);
ConsoleControl->SetMode (ConsoleControl, EfiConsoleControlScreenGraphics);
if (GraphicsOutput != NULL) {
SizeOfX = GraphicsOutput->Mode->Info->HorizontalResolution;
SizeOfY = GraphicsOutput->Mode->Info->VerticalResolution;
} else {
Status = UgaDraw->GetMode (UgaDraw, &SizeOfX, &SizeOfY, &ColorDepth, &RefreshRate);
if (EFI_ERROR (Status)) {
return EFI_UNSUPPORTED;
}
}
Instance = 0;
while (1) {
ImageData = NULL;
ImageSize = 0;
if (Badging != NULL) {
Status = Badging->GetImage (
Badging,
&Instance,
&Format,
&ImageData,
&ImageSize,
&Attribute,
&CoordinateX,
&CoordinateY
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Currently only support BMP format
//
if (Format != EfiBadgingFormatBMP) {
gBS->FreePool (ImageData);
continue;
}
} else {
Status = GetGraphicsBitMapFromFVEx (ImageHandle, LogoFile, (VOID **) &ImageData, &ImageSize);
if (EFI_ERROR (Status)) {
return EFI_UNSUPPORTED;
}
CoordinateX = 0;
CoordinateY = 0;
Attribute = EfiBadgingDisplayAttributeCenter;
}
Blt = NULL;
Status = ConvertBmpToGopBlt (
ImageData,
ImageSize,
(VOID**)&Blt,
&BltSize,
&Height,
&Width
);
if (EFI_ERROR (Status)) {
gBS->FreePool (ImageData);
if (Badging == NULL) {
return Status;
} else {
continue;
}
}
switch (Attribute) {
case EfiBadgingDisplayAttributeLeftTop:
DestX = CoordinateX;
DestY = CoordinateY;
break;
case EfiBadgingDisplayAttributeCenterTop:
DestX = (SizeOfX - Width) / 2;
DestY = CoordinateY;
break;
case EfiBadgingDisplayAttributeRightTop:
DestX = (SizeOfX - Width - CoordinateX);
DestY = CoordinateY;;
break;
case EfiBadgingDisplayAttributeCenterRight:
DestX = (SizeOfX - Width - CoordinateX);
DestY = (SizeOfY - Height) / 2;
break;
case EfiBadgingDisplayAttributeRightBottom:
DestX = (SizeOfX - Width - CoordinateX);
DestY = (SizeOfY - Height - CoordinateY);
break;
case EfiBadgingDisplayAttributeCenterBottom:
DestX = (SizeOfX - Width) / 2;
DestY = (SizeOfY - Height - CoordinateY);
break;
case EfiBadgingDisplayAttributeLeftBottom:
DestX = CoordinateX;
DestY = (SizeOfY - Height - CoordinateY);
break;
case EfiBadgingDisplayAttributeCenterLeft:
DestX = CoordinateX;
DestY = (SizeOfY - Height) / 2;
break;
case EfiBadgingDisplayAttributeCenter:
DestX = (SizeOfX - Width) / 2;
DestY = (SizeOfY - Height) / 2;
break;
default:
DestX = CoordinateX;
DestY = CoordinateY;
break;
}
if ((DestX >= 0) && (DestY >= 0)) {
if (GraphicsOutput != NULL) {
Status = GraphicsOutput->Blt (
GraphicsOutput,
Blt,
EfiBltBufferToVideo,
0,
0,
(UINTN) DestX,
(UINTN) DestY,
Width,
Height,
Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
);
} else {
Status = UgaDraw->Blt (
UgaDraw,
(EFI_UGA_PIXEL *) Blt,
EfiUgaBltBufferToVideo,
0,
0,
(UINTN) DestX,
(UINTN) DestY,
Width,
Height,
Width * sizeof (EFI_UGA_PIXEL)
);
}
}
gBS->FreePool (ImageData);
gBS->FreePool (Blt);
if (Badging == NULL) {
break;
}
}
return Status;
}
EFI_STATUS
VBoxVgaGraphicsOutputConstructor (
VBOX_VGA_PRIVATE_DATA *Private
)
{
EFI_STATUS Status;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
UINT32 Index;
UINT32 HorizontalResolution = 1024;
UINT32 VerticalResolution = 768;
UINT32 ColorDepth = 32;
DEBUG((DEBUG_INFO, "%a:%d construct\n", __FILE__, __LINE__));
GraphicsOutput = &Private->GraphicsOutput;
GraphicsOutput->QueryMode = VBoxVgaGraphicsOutputQueryMode;
GraphicsOutput->SetMode = VBoxVgaGraphicsOutputSetMode;
GraphicsOutput->Blt = VBoxVgaGraphicsOutputBlt;
//
// Initialize the private data
//
Status = gBS->AllocatePool (
EfiBootServicesData,
sizeof (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE),
(VOID **) &Private->GraphicsOutput.Mode
);
if (EFI_ERROR (Status)) {
return Status;
}
Status = gBS->AllocatePool (
EfiBootServicesData,
sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION),
(VOID **) &Private->GraphicsOutput.Mode->Info
);
if (EFI_ERROR (Status)) {
return Status;
}
Private->GraphicsOutput.Mode->MaxMode = (UINT32) Private->MaxMode;
Private->GraphicsOutput.Mode->Mode = GRAPHICS_OUTPUT_INVALIDE_MODE_NUMBER;
Private->HardwareNeedsStarting = TRUE;
//
// Initialize the hardware
//
VBoxVgaGetVmVariable(EFI_INFO_INDEX_HORIZONTAL_RESOLUTION, (CHAR8 *)&HorizontalResolution,
sizeof(HorizontalResolution));
VBoxVgaGetVmVariable(EFI_INFO_INDEX_VERTICAL_RESOLUTION, (CHAR8 *)&VerticalResolution,
sizeof(VerticalResolution));
for (Index = 0; Index < Private->MaxMode; Index++)
{
if ( HorizontalResolution == Private->ModeData[Index].HorizontalResolution
&& VerticalResolution == Private->ModeData[Index].VerticalResolution
&& ColorDepth == Private->ModeData[Index].ColorDepth)
break;
}
// not found? try mode number
if (Index >= Private->MaxMode)
{
VBoxVgaGetVmVariable(EFI_INFO_INDEX_GRAPHICS_MODE, (CHAR8 *)&Index, sizeof(Index));
// try with mode 2 (usually 1024x768) as a fallback
if (Index >= Private->MaxMode)
Index = 2;
// try with mode 0 (usually 640x480) as a fallback
if (Index >= Private->MaxMode)
Index = 0;
}
// skip mode setting completely if there is no valid mode
if (Index >= Private->MaxMode)
return EFI_UNSUPPORTED;
GraphicsOutput->SetMode (GraphicsOutput, Index);
DrawLogo (
Private,
Private->ModeData[Private->GraphicsOutput.Mode->Mode].HorizontalResolution,
Private->ModeData[Private->GraphicsOutput.Mode->Mode].VerticalResolution
);
PcdSet32S(PcdVideoHorizontalResolution, Private->ModeData[Private->GraphicsOutput.Mode->Mode].HorizontalResolution);
PcdSet32S(PcdVideoVerticalResolution, Private->ModeData[Private->GraphicsOutput.Mode->Mode].VerticalResolution);
return EFI_SUCCESS;
}
/**
Use SystemTable Conout to stop video based Simple Text Out consoles from going
to the video device. Put up LogoFile on every video device that is a console.
@param[in] LogoFile File name of logo to display on the center of the screen.
@retval EFI_SUCCESS ConsoleControl has been flipped to graphics and logo displayed.
@retval EFI_UNSUPPORTED Logo not found
**/
EFI_STATUS
EFIAPI
EnableQuietBoot (
IN EFI_GUID *LogoFile
)
{
EFI_STATUS Status;
EFI_OEM_BADGING_PROTOCOL *Badging;
UINT32 SizeOfX;
UINT32 SizeOfY;
INTN DestX;
INTN DestY;
UINT8 *ImageData;
UINTN ImageSize;
UINTN BltSize;
UINT32 Instance;
EFI_BADGING_FORMAT Format;
EFI_BADGING_DISPLAY_ATTRIBUTE Attribute;
UINTN CoordinateX;
UINTN CoordinateY;
UINTN Height;
UINTN Width;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
EFI_UGA_DRAW_PROTOCOL *UgaDraw;
UINT32 ColorDepth;
UINT32 RefreshRate;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
EFI_BOOT_LOGO_PROTOCOL *BootLogo;
UINTN NumberOfLogos;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *LogoBlt;
UINTN LogoDestX;
UINTN LogoDestY;
UINTN LogoHeight;
UINTN LogoWidth;
UINTN NewDestX;
UINTN NewDestY;
UINTN NewHeight;
UINTN NewWidth;
UINT64 BufferSize;
UgaDraw = NULL;
//
// Try to open GOP first
//
Status = gBS->HandleProtocol (gST->ConsoleOutHandle, &gEfiGraphicsOutputProtocolGuid, (VOID **) &GraphicsOutput);
if (EFI_ERROR (Status) && FeaturePcdGet (PcdUgaConsumeSupport)) {
GraphicsOutput = NULL;
//
// Open GOP failed, try to open UGA
//
Status = gBS->HandleProtocol (gST->ConsoleOutHandle, &gEfiUgaDrawProtocolGuid, (VOID **) &UgaDraw);
}
if (EFI_ERROR (Status)) {
return EFI_UNSUPPORTED;
}
//
// Try to open Boot Logo Protocol.
//
BootLogo = NULL;
gBS->LocateProtocol (&gEfiBootLogoProtocolGuid, NULL, (VOID **) &BootLogo);
//
// Erase Cursor from screen
//
gST->ConOut->EnableCursor (gST->ConOut, FALSE);
Badging = NULL;
Status = gBS->LocateProtocol (&gEfiOEMBadgingProtocolGuid, NULL, (VOID **) &Badging);
if (GraphicsOutput != NULL) {
SizeOfX = GraphicsOutput->Mode->Info->HorizontalResolution;
SizeOfY = GraphicsOutput->Mode->Info->VerticalResolution;
} else if (UgaDraw != NULL && FeaturePcdGet (PcdUgaConsumeSupport)) {
Status = UgaDraw->GetMode (UgaDraw, &SizeOfX, &SizeOfY, &ColorDepth, &RefreshRate);
if (EFI_ERROR (Status)) {
return EFI_UNSUPPORTED;
}
} else {
return EFI_UNSUPPORTED;
}
Blt = NULL;
NumberOfLogos = 0;
LogoDestX = 0;
LogoDestY = 0;
LogoHeight = 0;
LogoWidth = 0;
NewDestX = 0;
NewDestY = 0;
NewHeight = 0;
NewWidth = 0;
Instance = 0;
while (1) {
ImageData = NULL;
ImageSize = 0;
if (Badging != NULL) {
//
// Get image from OEMBadging protocol.
//
Status = Badging->GetImage (
Badging,
&Instance,
&Format,
&ImageData,
&ImageSize,
&Attribute,
&CoordinateX,
&CoordinateY
);
if (EFI_ERROR (Status)) {
goto Done;
}
//
// Currently only support BMP format.
//
if (Format != EfiBadgingFormatBMP) {
if (ImageData != NULL) {
FreePool (ImageData);
}
continue;
}
} else {
//
// Get the specified image from FV.
//
Status = GetSectionFromAnyFv (LogoFile, EFI_SECTION_RAW, 0, (VOID **) &ImageData, &ImageSize);
if (EFI_ERROR (Status)) {
return EFI_UNSUPPORTED;
}
CoordinateX = 0;
CoordinateY = 0;
if (!FeaturePcdGet(PcdBootlogoOnlyEnable)) {
Attribute = EfiBadgingDisplayAttributeCenter;
} else {
Attribute = EfiBadgingDisplayAttributeCustomized;
}
}
if (Blt != NULL) {
FreePool (Blt);
}
Blt = NULL;
Status = TranslateBmpToGopBlt (
ImageData,
ImageSize,
&Blt,
&BltSize,
&Height,
&Width
);
if (EFI_ERROR (Status)) {
FreePool (ImageData);
if (Badging == NULL) {
return Status;
} else {
continue;
}
}
//
// Calculate the display position according to Attribute.
//
switch (Attribute) {
case EfiBadgingDisplayAttributeLeftTop:
DestX = CoordinateX;
DestY = CoordinateY;
break;
case EfiBadgingDisplayAttributeCenterTop:
DestX = (SizeOfX - Width) / 2;
DestY = CoordinateY;
break;
case EfiBadgingDisplayAttributeRightTop:
DestX = (SizeOfX - Width - CoordinateX);
DestY = CoordinateY;;
break;
case EfiBadgingDisplayAttributeCenterRight:
DestX = (SizeOfX - Width - CoordinateX);
DestY = (SizeOfY - Height) / 2;
break;
case EfiBadgingDisplayAttributeRightBottom:
DestX = (SizeOfX - Width - CoordinateX);
DestY = (SizeOfY - Height - CoordinateY);
break;
case EfiBadgingDisplayAttributeCenterBottom:
DestX = (SizeOfX - Width) / 2;
DestY = (SizeOfY - Height - CoordinateY);
break;
case EfiBadgingDisplayAttributeLeftBottom:
DestX = CoordinateX;
DestY = (SizeOfY - Height - CoordinateY);
break;
case EfiBadgingDisplayAttributeCenterLeft:
DestX = CoordinateX;
DestY = (SizeOfY - Height) / 2;
break;
case EfiBadgingDisplayAttributeCenter:
DestX = (SizeOfX - Width) / 2;
DestY = (SizeOfY - Height) / 2;
break;
case EfiBadgingDisplayAttributeCustomized:
DestX = (SizeOfX - Width) / 2;
DestY = ((SizeOfY * 382) / 1000) - Height / 2;
break;
default:
DestX = CoordinateX;
DestY = CoordinateY;
break;
}
if ((DestX >= 0) && (DestY >= 0)) {
if (GraphicsOutput != NULL) {
Status = GraphicsOutput->Blt (
GraphicsOutput,
Blt,
EfiBltBufferToVideo,
0,
0,
(UINTN) DestX,
(UINTN) DestY,
Width,
Height,
Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
);
} else if (UgaDraw != NULL && FeaturePcdGet (PcdUgaConsumeSupport)) {
Status = UgaDraw->Blt (
UgaDraw,
(EFI_UGA_PIXEL *) Blt,
EfiUgaBltBufferToVideo,
0,
0,
(UINTN) DestX,
(UINTN) DestY,
Width,
Height,
Width * sizeof (EFI_UGA_PIXEL)
);
} else {
Status = EFI_UNSUPPORTED;
}
//
// Report displayed Logo information.
//
if (!EFI_ERROR (Status)) {
NumberOfLogos++;
if (LogoWidth == 0) {
//
// The first Logo.
//
LogoDestX = (UINTN) DestX;
LogoDestY = (UINTN) DestY;
LogoWidth = Width;
LogoHeight = Height;
} else {
//
// Merge new logo with old one.
//
NewDestX = MIN ((UINTN) DestX, LogoDestX);
NewDestY = MIN ((UINTN) DestY, LogoDestY);
NewWidth = MAX ((UINTN) DestX + Width, LogoDestX + LogoWidth) - NewDestX;
NewHeight = MAX ((UINTN) DestY + Height, LogoDestY + LogoHeight) - NewDestY;
LogoDestX = NewDestX;
LogoDestY = NewDestY;
LogoWidth = NewWidth;
LogoHeight = NewHeight;
}
}
}
FreePool (ImageData);
if (Badging == NULL) {
break;
}
}
Done:
if (BootLogo == NULL || NumberOfLogos == 0) {
//
// No logo displayed.
//
if (Blt != NULL) {
FreePool (Blt);
}
return Status;
}
//
// Advertise displayed Logo information.
//
if (NumberOfLogos == 1) {
//
// Only one logo displayed, use its Blt buffer directly for BootLogo protocol.
//
LogoBlt = Blt;
Status = EFI_SUCCESS;
} else {
//
// More than one Logo displayed, get merged BltBuffer using VideoToBuffer operation.
//
if (Blt != NULL) {
FreePool (Blt);
}
//
// Ensure the LogoHeight * LogoWidth doesn't overflow
//
if (LogoHeight > DivU64x64Remainder ((UINTN) ~0, LogoWidth, NULL)) {
return EFI_UNSUPPORTED;
}
BufferSize = MultU64x64 (LogoWidth, LogoHeight);
//
// Ensure the BufferSize * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) doesn't overflow
//
if (BufferSize > DivU64x32 ((UINTN) ~0, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL))) {
return EFI_UNSUPPORTED;
}
LogoBlt = AllocateZeroPool ((UINTN)BufferSize * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
if (LogoBlt == NULL) {
return EFI_OUT_OF_RESOURCES;
}
if (GraphicsOutput != NULL) {
Status = GraphicsOutput->Blt (
GraphicsOutput,
LogoBlt,
EfiBltVideoToBltBuffer,
LogoDestX,
LogoDestY,
0,
0,
LogoWidth,
LogoHeight,
LogoWidth * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
);
} else if (UgaDraw != NULL && FeaturePcdGet (PcdUgaConsumeSupport)) {
Status = UgaDraw->Blt (
UgaDraw,
(EFI_UGA_PIXEL *) LogoBlt,
EfiUgaVideoToBltBuffer,
LogoDestX,
LogoDestY,
0,
0,
LogoWidth,
LogoHeight,
LogoWidth * sizeof (EFI_UGA_PIXEL)
);
} else {
Status = EFI_UNSUPPORTED;
}
}
if (!EFI_ERROR (Status)) {
BootLogo->SetBootLogo (BootLogo, LogoBlt, LogoDestX, LogoDestY, LogoWidth, LogoHeight);
}
FreePool (LogoBlt);
return Status;
}
/**
* efi_main - The entry point for the EFI application
* @image: firmware-allocated handle that identifies the image
* @SystemTable: EFI system table
*/
EFI_STATUS
efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *systemTable)
{
EFI_BOOT_SERVICES *bs = systemTable->BootServices;
EFI_GRAPHICS_OUTPUT_PROTOCOL *graphicsProtocol;
SIMPLE_TEXT_OUTPUT_INTERFACE *conOut = systemTable->ConOut;
EFI_EVENT event = systemTable->ConIn->WaitForKey;
UINTN index;
int i, modeCount;
EFI_STATUS status = bs->LocateProtocol(&GraphicsOutputProtocolGUID, NULL,
(void**)&graphicsProtocol);
if (EFI_ERROR(status) || graphicsProtocol == NULL) {
conOut->OutputString(conOut, L"Failed to init gfx!\r\n");
return status;
}
//Switch to current mode so gfx is started.
status = graphicsProtocol->SetMode(graphicsProtocol, graphicsProtocol->Mode->Mode);
if (EFI_ERROR(status)) {
conOut->OutputString(conOut, L"Failed to set default mode!\r\n");
return status;
}
conOut->OutputString(conOut, L"Current mode: ");
printInt(conOut, graphicsProtocol->Mode->Mode);
conOut->OutputString(conOut, L"\r\n");
modeCount = graphicsProtocol->Mode->MaxMode;
for (i = 0; i < modeCount; i++) {
conOut->OutputString(conOut, L"\r\n");
printInt(conOut, i);
conOut->OutputString(conOut, L": ");
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *info;
UINTN SizeOfInfo;
status = graphicsProtocol->QueryMode(graphicsProtocol, i, &SizeOfInfo, &info);
if (EFI_ERROR(status)) {
conOut->OutputString(conOut, L" Failure to query mode: ");
printInt(conOut, status);
continue;
}
printInt(conOut, info->HorizontalResolution);
conOut->OutputString(conOut, L" x ");
printInt(conOut, info->VerticalResolution);
switch(info->PixelFormat) {
case PixelRedGreenBlueReserved8BitPerColor:
conOut->OutputString(conOut, L" RGB(R)");
break;
case PixelBlueGreenRedReserved8BitPerColor:
conOut->OutputString(conOut, L" BGR(R)");
break;
case PixelBitMask:
conOut->OutputString(conOut, L" BitMask ");
printInt(conOut, info->PixelInformation.RedMask);
conOut->OutputString(conOut, L"R ");
printInt(conOut, info->PixelInformation.GreenMask);
conOut->OutputString(conOut, L"G ");
printInt(conOut, info->PixelInformation.BlueMask);
conOut->OutputString(conOut, L"B ");
printInt(conOut, info->PixelInformation.ReservedMask);
conOut->OutputString(conOut, L"Reserved ");
break;
case PixelBltOnly:
conOut->OutputString(conOut, L" (blt only)");
break;
default:
conOut->OutputString(conOut, L" (Invalid pixel format)");
break;
}
conOut->OutputString(conOut, L" Pixel per scanline: ");
printInt(conOut, info->PixelsPerScanLine);
}
bs->WaitForEvent(1, &event, &index);
return EFI_SUCCESS;
}
//
// TDS 4.2.1
//
EFI_STATUS
BBTestQueryModeConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
/*++
Routine Description:
Entrypoint for EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode() Conformance Test
Arguments:
This - A pointer of EFI_BB_TEST_PROTOCOL
ClientInterface - A pointer to the interface to be tested
TestLevel - Test "thoroughness" control
SupportHandle - A handle containing protocols required
Returns:
EFI_SUCCESS - Finish the test successfully
--*/
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
EFI_TEST_ASSERTION AssertionType;
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *info;
UINTN sizeofInfo;
UINT32 mode;
GraphicsOutput = (EFI_GRAPHICS_OUTPUT_PROTOCOL *) ClientInterface;
if ((Status = InitTestEnv (SupportHandle, &StandardLib, GraphicsOutput)) != EFI_SUCCESS) {
return Status;
}
info = NULL;
sizeofInfo = 0;
//
// Assertion Point
// QueryMode should not succeed with invalid parameter
//
//
// mode number is invalid
//
mode = GraphicsOutput->Mode->MaxMode;
sizeofInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
Status = GraphicsOutput->QueryMode (
GraphicsOutput,
mode,
&sizeofInfo,
&info
);
if (Status != EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gGraphicsOutputQueryModeConformanceTestAssertionGuid001,
L"EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode - QueryMode() with MaxMode",
L"%a:%d:maxmode: %d,Status:%r, Expected:%r",
__FILE__,
(UINTN)__LINE__,
mode,
Status,
EFI_INVALID_PARAMETER
);
mode = GraphicsOutput->Mode->Mode;
//
// &sizeofInfo is invalid
//
Status = GraphicsOutput->QueryMode (
GraphicsOutput,
mode,
NULL,
&info
);
if (Status != EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gGraphicsOutputQueryModeConformanceTestAssertionGuid002,
L"EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode - QueryMode() with NULL &SizeofInfo",
L"%a:%d: Input invalide &SizeofInfo,Status:%r, Expected:%r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_INVALID_PARAMETER
);
//
// &info is invalid
//
Status = GraphicsOutput->QueryMode (
GraphicsOutput,
mode,
&sizeofInfo,
NULL
);
if (Status != EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gGraphicsOutputQueryModeConformanceTestAssertionGuid003,
L"EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode - QueryMode() with NULL &info",
L"%a:%d:, Input invalid &Info, Status:%r, Expected:%r",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_INVALID_PARAMETER
);
//
//
//
for (mode = 0; mode < GraphicsOutput->Mode->MaxMode; mode++) {
sizeofInfo = 0;
info = NULL;
Status = GraphicsOutput->QueryMode (
GraphicsOutput,
mode,
&sizeofInfo,
&info
);
if (Status == EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
if (info == NULL) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
if (sizeofInfo != sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION)) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gGraphicsOutputQueryModeConformanceTestAssertionGuid004,
L"EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode - QueryMode() with valid ModeNumber",
L"%a:%d:,size_out:%d,ModeNumber:%d,Status:%r, Expected:any value except %r",
(UINTN) __FILE__,
(UINTN) (UINTN)__LINE__,
(UINTN) sizeofInfo,
(UINTN) mode,
(UINTN) Status,
EFI_INVALID_PARAMETER
);
if (info != NULL) {
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gGraphicsOutputQueryModeConformanceTestAssertionGuid005,
L"EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode - QueryMode() with ModeNumber, dump info structure",
L"%a:%d:,ModeNumber:%d,dump of info: version:%d, horizonResolution:%d, VerticalResolution:%d, PixelFormat:%d, RedMask:%x,GreenMask:%x,BlueMask:%x,ReserveMask:%x,PixelPerScanline:%d",
(UINTN) __FILE__,
(UINTN) (UINTN)__LINE__,
(UINTN) mode,
(UINTN) info->Version,
(UINTN) info->HorizontalResolution,
(UINTN) info->VerticalResolution,
(UINTN) info->PixelFormat,
(UINTN) info->PixelInformation.RedMask,
(UINTN) info->PixelInformation.GreenMask,
(UINTN) info->PixelInformation.BlueMask,
(UINTN) info->PixelInformation.ReservedMask,
(UINTN) info->PixelsPerScanLine
);
gtBS->FreePool((VOID *)info);
}
}
//
// Check the mode structure
//
AssertionType = EFI_TEST_ASSERTION_PASSED;
if (GraphicsOutput->Mode == NULL) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gGraphicsOutputQueryModeConformanceTestAssertionGuid006,
L"EFI_GRAPHICS_OUTPUT_PROTOCOL.QueryMode - Dump the Mode structure",
L"%a:%d:, dump of Mode: MaxMode:%d, current mode:%d, Info addre:%x, sizeofInfo:%d, frameBufferBase:%x, FrameBufferSize:%x",
(UINTN) __FILE__,
(UINTN) (UINTN)__LINE__,
(UINTN) GraphicsOutput->Mode->MaxMode,
(UINTN) GraphicsOutput->Mode->Mode,
(UINTN) GraphicsOutput->Mode->Info,
(UINTN) GraphicsOutput->Mode->SizeOfInfo,
(UINTN) GraphicsOutput->Mode->FrameBufferBase,
(UINTN) GraphicsOutput->Mode->FrameBufferSize
);
return EFI_SUCCESS;
}
//
// TDS 4.2.2
//
EFI_STATUS
BBTestSetModeConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
/*++
Routine Description:
Entrypoint for EFI_GRAPHICS_OUTPUT_PROTOCOL.SetMode() Conformance Test
Arguments:
This - A pointer of EFI_BB_TEST_PROTOCOL
ClientInterface - A pointer to the interface to be tested
TestLevel - Test "thoroughness" control
SupportHandle - A handle containing protocols required
Returns:
EFI_SUCCESS - Finish the test successfully
--*/
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
EFI_TEST_ASSERTION AssertionType;
UINT32 Index;
UINT32 CurrentMode;
UINT32 MaxMode;
UINTN sizeofInfo;
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *info;
GraphicsOutput = (EFI_GRAPHICS_OUTPUT_PROTOCOL *) ClientInterface;
CurrentMode = GraphicsOutput->Mode->Mode;
if ((Status = InitTestEnv (SupportHandle, &StandardLib, GraphicsOutput)) != EFI_SUCCESS) {
return Status;
}
//
// Assertion Point
//
//
MaxMode = GraphicsOutput->Mode->MaxMode;
for (Index = 0; Index < MaxMode; Index++) {
Status = GraphicsOutput->SetMode (
GraphicsOutput,
Index
);
if (Status == EFI_UNSUPPORTED) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gGraphicsOutputSetModeConformanceTestAssertionGuid001,
L"EFI_GRAPHICS_OUTPUT_PROTOCOL.SetMode - SetMode() with valid mode",
L"%a:%d: mode:%d,Status = %r,Expected = not EFI_UNSUPPORTED ",
__FILE__,
(UINTN)__LINE__,
Index,
Status
);
//
// Check the content of info
//
if (Status == EFI_SUCCESS) {
sizeofInfo = 0;
info = NULL;
Status = GraphicsOutput->QueryMode (
GraphicsOutput,
Index,
&sizeofInfo,
&info
);
if (Status != EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
if (EfiCompareMem (
(void *) info,
(void *) GraphicsOutput->Mode->Info,
sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION)
) != 0) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
if (info != NULL) {
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gGraphicsOutputSetModeConformanceTestAssertionGuid002,
L"EFI_GRAPHICS_OUTPUT_PROTOCOL.SetMode - SetMode() then QueryMode(), compare Info structure",
L"%a:%d: dump of query result:ver:%d, hRes:%d, VRes:%d, PixelFmt:%d, RMsk:%x,GMsk:%x,BMsk:%x,ReserveMask:%x,PixelPerScanline:%d\n dump of GOP->Info:ver:%d, hRes:%d, VRes:%d, PixelFmt:%d, RMsk:%x,GMsk:%x,BMsk:%x,ReserveMask:%x,PixelPerScanline:%d",
(UINTN) __FILE__,
(UINTN) (UINTN)__LINE__,
(UINTN) info->Version,
(UINTN) info->HorizontalResolution,
(UINTN) info->VerticalResolution,
(UINTN) info->PixelFormat,
(UINTN) info->PixelInformation.RedMask,
(UINTN) info->PixelInformation.GreenMask,
(UINTN) info->PixelInformation.BlueMask,
(UINTN) info->PixelInformation.ReservedMask,
(UINTN) info->PixelsPerScanLine,
(UINTN) GraphicsOutput->Mode->Info->Version,
(UINTN) GraphicsOutput->Mode->Info->HorizontalResolution,
(UINTN) GraphicsOutput->Mode->Info->VerticalResolution,
(UINTN) GraphicsOutput->Mode->Info->PixelFormat,
(UINTN) GraphicsOutput->Mode->Info->PixelInformation.RedMask,
(UINTN) GraphicsOutput->Mode->Info->PixelInformation.GreenMask,
(UINTN) GraphicsOutput->Mode->Info->PixelInformation.BlueMask,
(UINTN) GraphicsOutput->Mode->Info->PixelInformation.ReservedMask,
(UINTN) GraphicsOutput->Mode->Info->PixelsPerScanLine
);
gtBS->FreePool(info);
}
}
}
Status = GraphicsOutput->SetMode (
GraphicsOutput,
MaxMode
);
if (Status != EFI_UNSUPPORTED) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gGraphicsOutputSetModeConformanceTestAssertionGuid003,
L"EFI_GRAPHICS_OUTPUT_PROTOCOL.SetMode - SetMode() with invalid (max)mode",
L"%a:%d: mode:%d,Status = %r,Expected = EFI_UNSUPPORTED ",
__FILE__,
(UINTN)__LINE__,
MaxMode,
Status
);
//
// restore
// restore the orignal Mode
//
Status = GraphicsOutput->SetMode (GraphicsOutput, CurrentMode);
if (Status == EFI_SUCCESS) {
AssertionType = EFI_TEST_ASSERTION_PASSED;
} else {
AssertionType = EFI_TEST_ASSERTION_FAILED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gTestGenericFailureGuid,
L"EFI_GRAPHICS_OUTPUT_PROTOCOL.SetMode - SetMode() Function Test,restore the orignal Mode",
L"%a:%d:Status:%r, Expected:EFI_SUCCESS",
__FILE__,
(UINTN)__LINE__,
Status
);
return EFI_SUCCESS;
}
//
// TDS 4.2.3
//
EFI_STATUS
BBTestBltConformanceAutoTest (
IN EFI_BB_TEST_PROTOCOL *This,
IN VOID *ClientInterface,
IN EFI_TEST_LEVEL TestLevel,
IN EFI_HANDLE SupportHandle
)
/*++
Routine Description:
Entrypoint for EFI_GRAPHICS_OUTPUT_PROTOCOL.Blt() Conformance Test
Arguments:
This - A pointer of EFI_BB_TEST_PROTOCOL
ClientInterface - A pointer to the interface to be tested
TestLevel - Test "thoroughness" control
SupportHandle - A handle containing protocols required
Returns:
EFI_SUCCESS - Finish the test successfully
--*/
{
EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
EFI_STATUS Status;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
EFI_TEST_ASSERTION AssertionType;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL BltBuffer[10];
UINTN SourceX;
UINTN SourceY;
UINTN DestinationX;
UINTN DestinationY;
UINTN Width;
UINTN Height;
UINTN Delta;
UINTN Index;
EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation;
SourceX = 0;
SourceY = 0;
DestinationX = 0;
DestinationY = 0;
Width = 1;
Height = 1;
Delta = 0;
GraphicsOutput = (EFI_GRAPHICS_OUTPUT_PROTOCOL *) ClientInterface;
if ((Status = InitTestEnv (SupportHandle, &StandardLib, GraphicsOutput)) != EFI_SUCCESS) {
return Status;
}
//
// Assertion Point
// Blt should not succeed with invalid parameter
//
for (Index = 0; Index < 6; Index++) {
switch (Index) {
case 0:
BltOperation = EfiGraphicsOutputBltOperationMax;
break;
case 1:
BltOperation = EfiGraphicsOutputBltOperationMax + 1;
break;
case 2:
BltOperation = EfiGraphicsOutputBltOperationMax + 10;
break;
case 3:
BltOperation = EfiGraphicsOutputBltOperationMax + 100;
break;
case 4:
BltOperation = EfiGraphicsOutputBltOperationMax + 1000;
break;
case 5:
BltOperation = -1;
break;
default:
BltOperation = EfiGraphicsOutputBltOperationMax - 1;
break;
}
//
// test data verification
//
Status = GraphicsOutput->Blt (
GraphicsOutput,
BltBuffer,
BltOperation,
SourceX,
SourceY,
DestinationX,
DestinationY,
Width,
Height,
Delta
);
if (Status != EFI_INVALID_PARAMETER) {
AssertionType = EFI_TEST_ASSERTION_FAILED;
} else {
AssertionType = EFI_TEST_ASSERTION_PASSED;
}
StandardLib->RecordAssertion (
StandardLib,
AssertionType,
gGraphicsOutputBltConformanceTestAssertionGuid001,
L"EFI_GRAPHICS_OUTPUT_PROTOCOL.Blt - Blt() with invalid BltOperation",
L"%a:%d: Status = %r,Expected = %r, Source=(%dx%d), Destination=(%dx%d), Width=%d, Height=%d, Delta=%d,BltOperation=%d",
__FILE__,
(UINTN)__LINE__,
Status,
EFI_INVALID_PARAMETER,
DestinationX,
DestinationY,
0,
0,
Width,
Height,
Delta,
BltOperation
);
}
return EFI_SUCCESS;
}
EFI_STATUS
QemuVideoGraphicsOutputConstructor (
QEMU_VIDEO_PRIVATE_DATA *Private
)
{
EFI_STATUS Status;
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
UINT32 ModeNumber;
UINT32 InitialModeNumber;
GraphicsOutput = &Private->GraphicsOutput;
GraphicsOutput->QueryMode = QemuVideoGraphicsOutputQueryMode;
GraphicsOutput->SetMode = QemuVideoGraphicsOutputSetMode;
GraphicsOutput->Blt = QemuVideoGraphicsOutputBlt;
//
// Initialize the private data
//
Status = gBS->AllocatePool (
EfiBootServicesData,
sizeof (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE),
(VOID **) &Private->GraphicsOutput.Mode
);
if (EFI_ERROR (Status)) {
return Status;
}
Status = gBS->AllocatePool (
EfiBootServicesData,
sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION),
(VOID **) &Private->GraphicsOutput.Mode->Info
);
if (EFI_ERROR (Status)) {
goto FreeMode;
}
Private->GraphicsOutput.Mode->MaxMode = (UINT32) Private->MaxMode;
Private->GraphicsOutput.Mode->Mode = GRAPHICS_OUTPUT_INVALIDE_MODE_NUMBER;
Private->LineBuffer = NULL;
//
// Initialize the hardware
//
// Search for 800x600 resolution for initial mode
InitialModeNumber = 0;
for (ModeNumber = 0; ModeNumber < Private->MaxMode; ModeNumber++) {
if (Private->ModeData[ModeNumber].HorizontalResolution == 800 && Private->ModeData[ModeNumber].VerticalResolution == 600) {
InitialModeNumber = ModeNumber;
break;
}
}
Status = GraphicsOutput->SetMode (GraphicsOutput, InitialModeNumber);
if (EFI_ERROR (Status)) {
goto FreeInfo;
}
DrawLogo (
Private,
Private->ModeData[Private->GraphicsOutput.Mode->Mode].HorizontalResolution,
Private->ModeData[Private->GraphicsOutput.Mode->Mode].VerticalResolution
);
return EFI_SUCCESS;
FreeInfo:
FreePool (Private->GraphicsOutput.Mode->Info);
FreeMode:
FreePool (Private->GraphicsOutput.Mode);
Private->GraphicsOutput.Mode = NULL;
return Status;
}