| /*++ | |
| Copyright (c) 2006, Intel Corporation | |
| All rights reserved. This program and the accompanying materials | |
| are licensed and made available under the terms and conditions of the BSD License | |
| which accompanies this distribution. The full text of the license may be found at | |
| http://opensource.org/licenses/bsd-license.php | |
| THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
| WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
| Module Name: | |
| Graphics.c | |
| Abstract: | |
| Support for Basic Graphics operations. | |
| BugBug: Currently *.BMP files are supported. This will be replaced | |
| when Tiano graphics format is supported. | |
| --*/ | |
| EFI_STATUS | |
| GetGraphicsBitMapFromFV ( | |
| IN EFI_GUID *FileNameGuid, | |
| OUT VOID **Image, | |
| OUT UINTN *ImageSize | |
| ) | |
| /*++ | |
| Routine Description: | |
| Return the graphics image file named FileNameGuid into Image and return it's | |
| size in ImageSize. All Firmware Volumes (FV) in the system are searched for the | |
| file name. | |
| Arguments: | |
| FileNameGuid - File Name of graphics file in the FV(s). | |
| Image - Pointer to pointer to return graphics image. If NULL, a | |
| buffer will be allocated. | |
| ImageSize - Size of the graphics Image in bytes. Zero if no image found. | |
| Returns: | |
| EFI_SUCCESS - Image and ImageSize are valid. | |
| EFI_BUFFER_TOO_SMALL - Image not big enough. ImageSize has required size | |
| EFI_NOT_FOUND - FileNameGuid not found | |
| --*/ | |
| { | |
| EFI_STATUS Status; | |
| UINTN FvProtocolCount; | |
| EFI_HANDLE *FvHandles; | |
| EFI_FIRMWARE_VOLUME_PROTOCOL *Fv; | |
| UINTN Index; | |
| UINT32 AuthenticationStatus; | |
| Status = gBS->LocateHandleBuffer ( | |
| ByProtocol, | |
| &gEfiFirmwareVolumeProtocolGuid, | |
| NULL, | |
| &FvProtocolCount, | |
| &FvHandles | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return EFI_NOT_FOUND; | |
| } | |
| for (Index = 0; Index < FvProtocolCount; Index++) { | |
| Status = gBS->HandleProtocol ( | |
| FvHandles[Index], | |
| &gEfiFirmwareVolumeProtocolGuid, | |
| (VOID **) &Fv | |
| ); | |
| // | |
| // Assuming Image and ImageSize are correct on input. | |
| // | |
| Status = Fv->ReadSection ( | |
| Fv, | |
| &gEfiDefaultBmpLogoGuid, | |
| EFI_SECTION_RAW, | |
| 0, | |
| Image, | |
| ImageSize, | |
| &AuthenticationStatus | |
| ); | |
| if (!EFI_ERROR (Status)) { | |
| return EFI_SUCCESS; | |
| } else if (Status == EFI_BUFFER_TOO_SMALL) { | |
| // | |
| // ImageSize updated to needed size so return | |
| // | |
| return EFI_BUFFER_TOO_SMALL; | |
| } | |
| } | |
| return EFI_NOT_FOUND; | |
| } | |
| EFI_STATUS | |
| ConvertBmpToUgaBlt ( | |
| IN VOID *BmpImage, | |
| IN UINTN BmpImageSize, | |
| IN OUT VOID **UgaBlt, | |
| IN OUT UINTN *UgaBltSize, | |
| OUT UINTN *PixelHeight, | |
| OUT UINTN *PixelWidth | |
| ) | |
| /*++ | |
| Routine Description: | |
| Convert a *.BMP graphics image to a UGA blt buffer. If a NULL UgaBlt buffer | |
| is passed in a UgaBlt buffer will be allocated by this routine. If a UgaBlt | |
| buffer is passed in it will be used if it is big enough. | |
| Arguments: | |
| BmpImage - Pointer to BMP file | |
| BmpImageSize - Number of bytes in BmpImage | |
| UgaBlt - Buffer containing UGA version of BmpImage. | |
| UgaBltSize - Size of UgaBlt in bytes. | |
| PixelHeight - Height of UgaBlt/BmpImage in pixels | |
| PixelWidth - Width of UgaBlt/BmpImage in pixels | |
| Returns: | |
| EFI_SUCCESS - UgaBlt and UgaBltSize are returned. | |
| EFI_UNSUPPORTED - BmpImage is not a valid *.BMP image | |
| EFI_BUFFER_TOO_SMALL - The passed in UgaBlt buffer is not big enough. | |
| UgaBltSize will contain the required size. | |
| EFI_OUT_OF_RESOURCES - No enough buffer to allocate | |
| --*/ | |
| { | |
| UINT8 *Image; | |
| UINT8 *ImageHeader; | |
| BMP_IMAGE_HEADER *BmpHeader; | |
| BMP_COLOR_MAP *BmpColorMap; | |
| EFI_UGA_PIXEL *BltBuffer; | |
| EFI_UGA_PIXEL *Blt; | |
| UINTN BltBufferSize; | |
| UINTN Index; | |
| UINTN Height; | |
| UINTN Width; | |
| UINTN ImageIndex; | |
| BmpHeader = (BMP_IMAGE_HEADER *) BmpImage; | |
| if (BmpHeader->CharB != 'B' || BmpHeader->CharM != 'M') { | |
| return EFI_UNSUPPORTED; | |
| } | |
| if (BmpHeader->CompressionType != 0) { | |
| return EFI_UNSUPPORTED; | |
| } | |
| // | |
| // Calculate Color Map offset in the image. | |
| // | |
| Image = BmpImage; | |
| BmpColorMap = (BMP_COLOR_MAP *) (Image + sizeof (BMP_IMAGE_HEADER)); | |
| // | |
| // Calculate graphics image data address in the image | |
| // | |
| Image = ((UINT8 *) BmpImage) + BmpHeader->ImageOffset; | |
| ImageHeader = Image; | |
| BltBufferSize = BmpHeader->PixelWidth * BmpHeader->PixelHeight * sizeof (EFI_UGA_PIXEL); | |
| if (*UgaBlt == NULL) { | |
| *UgaBltSize = BltBufferSize; | |
| *UgaBlt = AllocatePool (*UgaBltSize); | |
| if (*UgaBlt == NULL) { | |
| return EFI_OUT_OF_RESOURCES; | |
| } | |
| } else { | |
| if (*UgaBltSize < BltBufferSize) { | |
| *UgaBltSize = BltBufferSize; | |
| return EFI_BUFFER_TOO_SMALL; | |
| } | |
| } | |
| *PixelWidth = BmpHeader->PixelWidth; | |
| *PixelHeight = BmpHeader->PixelHeight; | |
| // | |
| // Convert image from BMP to Blt buffer format | |
| // | |
| BltBuffer = *UgaBlt; | |
| for (Height = 0; Height < BmpHeader->PixelHeight; Height++) { | |
| Blt = &BltBuffer[(BmpHeader->PixelHeight - Height - 1) * BmpHeader->PixelWidth]; | |
| for (Width = 0; Width < BmpHeader->PixelWidth; Width++, Image++, Blt++) { | |
| switch (BmpHeader->BitPerPixel) { | |
| case 1: | |
| // | |
| // Convert 1bit BMP to 24-bit color | |
| // | |
| for (Index = 0; Index < 8 && Width < BmpHeader->PixelWidth; Index++) { | |
| Blt->Red = BmpColorMap[((*Image) >> (7 - Index)) & 0x1].Red; | |
| Blt->Green = BmpColorMap[((*Image) >> (7 - Index)) & 0x1].Green; | |
| Blt->Blue = BmpColorMap[((*Image) >> (7 - Index)) & 0x1].Blue; | |
| Blt++; | |
| Width++; | |
| } | |
| Blt --; | |
| Width --; | |
| break; | |
| case 4: | |
| // | |
| // Convert BMP Palette to 24-bit color | |
| // | |
| Index = (*Image) >> 4; | |
| Blt->Red = BmpColorMap[Index].Red; | |
| Blt->Green = BmpColorMap[Index].Green; | |
| Blt->Blue = BmpColorMap[Index].Blue; | |
| if (Width < (BmpHeader->PixelWidth - 1)) { | |
| Blt++; | |
| Width++; | |
| Index = (*Image) & 0x0f; | |
| Blt->Red = BmpColorMap[Index].Red; | |
| Blt->Green = BmpColorMap[Index].Green; | |
| Blt->Blue = BmpColorMap[Index].Blue; | |
| } | |
| break; | |
| case 8: | |
| // | |
| // Convert BMP Palette to 24-bit color | |
| // | |
| Blt->Red = BmpColorMap[*Image].Red; | |
| Blt->Green = BmpColorMap[*Image].Green; | |
| Blt->Blue = BmpColorMap[*Image].Blue; | |
| break; | |
| case 24: | |
| Blt->Blue = *Image++; | |
| Blt->Green = *Image++; | |
| Blt->Red = *Image; | |
| break; | |
| default: | |
| return EFI_UNSUPPORTED; | |
| break; | |
| }; | |
| } | |
| ImageIndex = (UINTN) (Image - ImageHeader); | |
| if ((ImageIndex % 4) != 0) { | |
| // | |
| // Bmp Image starts each row on a 32-bit boundary! | |
| // | |
| Image = Image + (4 - (ImageIndex % 4)); | |
| } | |
| } | |
| return EFI_SUCCESS; | |
| } | |
| EFI_STATUS | |
| LockKeyboards ( | |
| IN CHAR16 *Password | |
| ) | |
| /*++ | |
| Routine Description: | |
| Use Console Control Protocol to lock the Console In Spliter virtual handle. | |
| This is the ConInHandle and ConIn handle in the EFI system table. All key | |
| presses will be ignored until the Password is typed in. The only way to | |
| disable the password is to type it in to a ConIn device. | |
| Arguments: | |
| Password - Password used to lock ConIn device | |
| 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; | |
| Status = gBS->LocateProtocol (&gEfiConsoleControlProtocolGuid, NULL, (VOID **) &ConsoleControl); | |
| if (EFI_ERROR (Status)) { | |
| return EFI_UNSUPPORTED; | |
| } | |
| Status = ConsoleControl->LockStdIn (ConsoleControl, Password); | |
| return Status; | |
| } | |
| EFI_STATUS | |
| EnableQuietBoot ( | |
| IN EFI_GUID *LogoFile | |
| ) | |
| /*++ | |
| Routine Description: | |
| Use Console Control to turn off UGA based Simple Text Out consoles from going | |
| to the UGA device. Put up LogoFile on every UGA device that is a console | |
| Arguments: | |
| LogoFile - File name of logo to display on the center of the screen. | |
| 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_UGA_DRAW_PROTOCOL *UgaDraw; | |
| EFI_OEM_BADGING_PROTOCOL *Badging; | |
| UINT32 SizeOfX; | |
| UINT32 SizeOfY; | |
| UINT32 ColorDepth; | |
| UINT32 RefreshRate; | |
| INTN DestX; | |
| INTN DestY; | |
| UINT8 *ImageData; | |
| UINTN ImageSize; | |
| EFI_UGA_PIXEL *UgaBlt; | |
| UINTN UgaBltSize; | |
| UINT32 Instance; | |
| EFI_BADGING_FORMAT Format; | |
| EFI_BADGING_DISPLAY_ATTRIBUTE Attribute; | |
| UINTN CoordinateX; | |
| UINTN CoordinateY; | |
| UINTN Height; | |
| UINTN Width; | |
| Status = gBS->LocateProtocol (&gEfiConsoleControlProtocolGuid, NULL, (VOID **) &ConsoleControl); | |
| if (EFI_ERROR (Status)) { | |
| return EFI_UNSUPPORTED; | |
| } | |
| 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); | |
| 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 = GetGraphicsBitMapFromFV (LogoFile, (VOID **) &ImageData, &ImageSize); | |
| if (EFI_ERROR (Status)) { | |
| return EFI_UNSUPPORTED; | |
| } | |
| CoordinateX = 0; | |
| CoordinateY = 0; | |
| Attribute = EfiBadgingDisplayAttributeCenter; | |
| } | |
| UgaBlt = NULL; | |
| Status = ConvertBmpToUgaBlt ( | |
| ImageData, | |
| ImageSize, | |
| (VOID **) &UgaBlt, | |
| &UgaBltSize, | |
| &Height, | |
| &Width | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| gBS->FreePool (ImageData); | |
| 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)) { | |
| Status = UgaDraw->Blt ( | |
| UgaDraw, | |
| UgaBlt, | |
| EfiUgaBltBufferToVideo, | |
| 0, | |
| 0, | |
| (UINTN) DestX, | |
| (UINTN) DestY, | |
| Width, | |
| Height, | |
| Width * sizeof (EFI_UGA_PIXEL) | |
| ); | |
| } | |
| gBS->FreePool (ImageData); | |
| gBS->FreePool (UgaBlt); | |
| if (Badging == NULL) { | |
| break; | |
| } | |
| } | |
| return Status; | |
| } | |
| EFI_STATUS | |
| DisableQuietBoot ( | |
| VOID | |
| ) | |
| /*++ | |
| Routine Description: | |
| Use Console Control to turn on UGA based Simple Text Out consoles. The UGA | |
| Simple Text Out screens will now be synced up with all non UGA output devices | |
| Arguments: | |
| NONE | |
| Returns: | |
| EFI_SUCCESS - UGA devices are back in text mode and synced up. | |
| EFI_UNSUPPORTED - Logo not found | |
| --*/ | |
| { | |
| EFI_STATUS Status; | |
| EFI_CONSOLE_CONTROL_PROTOCOL *ConsoleControl; | |
| Status = gBS->LocateProtocol (&gEfiConsoleControlProtocolGuid, NULL, (VOID **) &ConsoleControl); | |
| if (EFI_ERROR (Status)) { | |
| return EFI_UNSUPPORTED; | |
| } | |
| return ConsoleControl->SetMode (ConsoleControl, EfiConsoleControlScreenText); | |
| } | |
| static EFI_UGA_PIXEL mEfiColors[16] = { | |
| { 0x00, 0x00, 0x00, 0x00 }, | |
| { 0x98, 0x00, 0x00, 0x00 }, | |
| { 0x00, 0x98, 0x00, 0x00 }, | |
| { 0x98, 0x98, 0x00, 0x00 }, | |
| { 0x00, 0x00, 0x98, 0x00 }, | |
| { 0x98, 0x00, 0x98, 0x00 }, | |
| { 0x00, 0x98, 0x98, 0x00 }, | |
| { 0x98, 0x98, 0x98, 0x00 }, | |
| { 0x10, 0x10, 0x10, 0x00 }, | |
| { 0xff, 0x10, 0x10, 0x00 }, | |
| { 0x10, 0xff, 0x10, 0x00 }, | |
| { 0xff, 0xff, 0x10, 0x00 }, | |
| { 0x10, 0x10, 0xff, 0x00 }, | |
| { 0xf0, 0x10, 0xff, 0x00 }, | |
| { 0x10, 0xff, 0xff, 0x00 }, | |
| { 0xff, 0xff, 0xff, 0x00 } | |
| }; | |
| STATIC | |
| UINTN | |
| _IPrint ( | |
| IN EFI_UGA_DRAW_PROTOCOL *UgaDraw, | |
| IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *Sto, | |
| IN UINTN X, | |
| IN UINTN Y, | |
| IN EFI_UGA_PIXEL *Foreground, | |
| IN EFI_UGA_PIXEL *Background, | |
| IN CHAR16 *fmt, | |
| IN VA_LIST args | |
| ) | |
| /*++ | |
| Routine Description: | |
| Display string worker for: Print, PrintAt, IPrint, IPrintAt | |
| Arguments: | |
| UgaDraw - UGA draw protocol interface | |
| Sto - Simple text out protocol interface | |
| X - X coordinate to start printing | |
| Y - Y coordinate to start printing | |
| Foreground - Foreground color | |
| Background - Background color | |
| fmt - Format string | |
| args - Print arguments | |
| Returns: | |
| EFI_SUCCESS - success | |
| EFI_OUT_OF_RESOURCES - out of resources | |
| --*/ | |
| { | |
| VOID *Buffer; | |
| EFI_STATUS Status; | |
| UINT16 GlyphWidth; | |
| UINT32 GlyphStatus; | |
| UINT16 StringIndex; | |
| UINTN Index; | |
| CHAR16 *UnicodeWeight; | |
| EFI_NARROW_GLYPH *Glyph; | |
| EFI_HII_PROTOCOL *Hii; | |
| EFI_UGA_PIXEL *LineBuffer; | |
| UINT32 HorizontalResolution; | |
| UINT32 VerticalResolution; | |
| UINT32 ColorDepth; | |
| UINT32 RefreshRate; | |
| GlyphStatus = 0; | |
| // | |
| // For now, allocate an arbitrarily long buffer | |
| // | |
| Buffer = AllocateZeroPool (0x10000); | |
| if (Buffer == NULL) { | |
| return EFI_OUT_OF_RESOURCES; | |
| } | |
| UgaDraw->GetMode (UgaDraw, &HorizontalResolution, &VerticalResolution, &ColorDepth, &RefreshRate); | |
| LineBuffer = AllocatePool (sizeof (EFI_UGA_PIXEL) * HorizontalResolution * GLYPH_WIDTH * GLYPH_HEIGHT); | |
| if (LineBuffer == NULL) { | |
| gBS->FreePool (Buffer); | |
| return EFI_OUT_OF_RESOURCES; | |
| } | |
| Status = gBS->LocateProtocol (&gEfiHiiProtocolGuid, NULL, (VOID **) &Hii); | |
| if (EFI_ERROR (Status)) { | |
| goto Error; | |
| } | |
| UnicodeVSPrint (Buffer, 0x10000, fmt, args); | |
| UnicodeWeight = (CHAR16 *) Buffer; | |
| for (Index = 0; UnicodeWeight[Index] != 0; Index++) { | |
| if (UnicodeWeight[Index] == CHAR_BACKSPACE || | |
| UnicodeWeight[Index] == CHAR_LINEFEED || | |
| UnicodeWeight[Index] == CHAR_CARRIAGE_RETURN) { | |
| UnicodeWeight[Index] = 0; | |
| } | |
| } | |
| for (Index = 0; Index < StrLen (Buffer); Index++) { | |
| StringIndex = (UINT16) Index; | |
| Status = Hii->GetGlyph (Hii, UnicodeWeight, &StringIndex, (UINT8 **) &Glyph, &GlyphWidth, &GlyphStatus); | |
| if (EFI_ERROR (Status)) { | |
| goto Error; | |
| } | |
| if (Foreground == NULL || Background == NULL) { | |
| Status = Hii->GlyphToBlt ( | |
| Hii, | |
| (UINT8 *) Glyph, | |
| mEfiColors[Sto->Mode->Attribute & 0x0f], | |
| mEfiColors[Sto->Mode->Attribute >> 4], | |
| StrLen (Buffer), | |
| GlyphWidth, | |
| GLYPH_HEIGHT, | |
| &LineBuffer[Index * GLYPH_WIDTH] | |
| ); | |
| } else { | |
| Status = Hii->GlyphToBlt ( | |
| Hii, | |
| (UINT8 *) Glyph, | |
| *Foreground, | |
| *Background, | |
| StrLen (Buffer), | |
| GlyphWidth, | |
| GLYPH_HEIGHT, | |
| &LineBuffer[Index * GLYPH_WIDTH] | |
| ); | |
| } | |
| } | |
| // | |
| // Blt a character to the screen | |
| // | |
| Status = UgaDraw->Blt ( | |
| UgaDraw, | |
| LineBuffer, | |
| EfiUgaBltBufferToVideo, | |
| 0, | |
| 0, | |
| X, | |
| Y, | |
| GLYPH_WIDTH * StrLen (Buffer), | |
| GLYPH_HEIGHT, | |
| GLYPH_WIDTH * StrLen (Buffer) * sizeof (EFI_UGA_PIXEL) | |
| ); | |
| Error: | |
| gBS->FreePool (LineBuffer); | |
| gBS->FreePool (Buffer); | |
| return Status; | |
| } | |
| UINTN | |
| PrintXY ( | |
| IN UINTN X, | |
| IN UINTN Y, | |
| IN EFI_UGA_PIXEL *ForeGround, OPTIONAL | |
| IN EFI_UGA_PIXEL *BackGround, OPTIONAL | |
| IN CHAR16 *Fmt, | |
| ... | |
| ) | |
| /*++ | |
| Routine Description: | |
| Prints a formatted unicode string to the default console | |
| Arguments: | |
| X - X coordinate to start printing | |
| Y - Y coordinate to start printing | |
| ForeGround - Foreground color | |
| BackGround - Background color | |
| Fmt - Format string | |
| ... - Print arguments | |
| Returns: | |
| Length of string printed to the console | |
| --*/ | |
| { | |
| EFI_HANDLE Handle; | |
| EFI_UGA_DRAW_PROTOCOL *UgaDraw; | |
| EFI_SIMPLE_TEXT_OUT_PROTOCOL *Sto; | |
| EFI_STATUS Status; | |
| VA_LIST Args; | |
| VA_START (Args, Fmt); | |
| Handle = gST->ConsoleOutHandle; | |
| Status = gBS->HandleProtocol ( | |
| Handle, | |
| &gEfiUgaDrawProtocolGuid, | |
| (VOID **) &UgaDraw | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| Status = gBS->HandleProtocol ( | |
| Handle, | |
| &gEfiSimpleTextOutProtocolGuid, | |
| (VOID **) &Sto | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| return _IPrint (UgaDraw, Sto, X, Y, ForeGround, BackGround, Fmt, Args); | |
| } |