VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/BootLogoLib/BootLogoLib.c@ 105681

Last change on this file since 105681 was 99404, checked in by vboxsync, 2 years ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 16.5 KB
Line 
1/** @file
2 This library is only intended to be used by PlatformBootManagerLib
3 to show progress bar and LOGO.
4
5Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>
6Copyright (c) 2016, Microsoft Corporation<BR>
7SPDX-License-Identifier: BSD-2-Clause-Patent
8
9**/
10
11#include <Uefi.h>
12#include <Protocol/GraphicsOutput.h>
13#include <Protocol/SimpleTextOut.h>
14#include <Protocol/PlatformLogo.h>
15#include <Protocol/UgaDraw.h>
16#include <Protocol/BootLogo.h>
17#include <Protocol/BootLogo2.h>
18#include <Library/BaseLib.h>
19#include <Library/UefiLib.h>
20#include <Library/BaseMemoryLib.h>
21#include <Library/UefiBootServicesTableLib.h>
22#include <Library/PcdLib.h>
23#include <Library/MemoryAllocationLib.h>
24#include <Library/DebugLib.h>
25
26/**
27 Show LOGO returned from Edkii Platform Logo protocol on all consoles.
28
29 @retval EFI_SUCCESS Logo was displayed.
30 @retval EFI_UNSUPPORTED Logo was not found or cannot be displayed.
31**/
32EFI_STATUS
33EFIAPI
34BootLogoEnableLogo (
35 VOID
36 )
37{
38 EFI_STATUS Status;
39 EDKII_PLATFORM_LOGO_PROTOCOL *PlatformLogo;
40 EDKII_PLATFORM_LOGO_DISPLAY_ATTRIBUTE Attribute;
41 INTN OffsetX;
42 INTN OffsetY;
43 UINT32 SizeOfX;
44 UINT32 SizeOfY;
45 INTN DestX;
46 INTN DestY;
47 UINT32 Instance;
48 EFI_IMAGE_INPUT Image;
49 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
50 EFI_UGA_DRAW_PROTOCOL *UgaDraw;
51 UINT32 ColorDepth;
52 UINT32 RefreshRate;
53 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
54 EFI_BOOT_LOGO_PROTOCOL *BootLogo;
55 EDKII_BOOT_LOGO2_PROTOCOL *BootLogo2;
56 UINTN NumberOfLogos;
57 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *LogoBlt;
58 UINTN LogoDestX;
59 UINTN LogoDestY;
60 UINTN LogoHeight;
61 UINTN LogoWidth;
62 UINTN NewDestX;
63 UINTN NewDestY;
64 UINTN BufferSize;
65
66 Status = gBS->LocateProtocol (&gEdkiiPlatformLogoProtocolGuid, NULL, (VOID **)&PlatformLogo);
67 if (EFI_ERROR (Status)) {
68 return EFI_UNSUPPORTED;
69 }
70
71 UgaDraw = NULL;
72 //
73 // Try to open GOP first
74 //
75 Status = gBS->HandleProtocol (gST->ConsoleOutHandle, &gEfiGraphicsOutputProtocolGuid, (VOID **)&GraphicsOutput);
76 if (EFI_ERROR (Status) && FeaturePcdGet (PcdUgaConsumeSupport)) {
77 GraphicsOutput = NULL;
78 //
79 // Open GOP failed, try to open UGA
80 //
81 Status = gBS->HandleProtocol (gST->ConsoleOutHandle, &gEfiUgaDrawProtocolGuid, (VOID **)&UgaDraw);
82 if (EFI_ERROR (Status)) {
83 UgaDraw = NULL;
84 }
85 }
86
87 if (EFI_ERROR (Status)) {
88 return EFI_UNSUPPORTED;
89 }
90
91 //
92 // Try to open Boot Logo Protocol.
93 //
94 Status = gBS->LocateProtocol (&gEfiBootLogoProtocolGuid, NULL, (VOID **)&BootLogo);
95 if (EFI_ERROR (Status)) {
96 BootLogo = NULL;
97 }
98
99 //
100 // Try to open Boot Logo 2 Protocol.
101 //
102 Status = gBS->LocateProtocol (&gEdkiiBootLogo2ProtocolGuid, NULL, (VOID **)&BootLogo2);
103 if (EFI_ERROR (Status)) {
104 BootLogo2 = NULL;
105 }
106
107 //
108 // Erase Cursor from screen
109 //
110 gST->ConOut->EnableCursor (gST->ConOut, FALSE);
111
112 if (GraphicsOutput != NULL) {
113 SizeOfX = GraphicsOutput->Mode->Info->HorizontalResolution;
114 SizeOfY = GraphicsOutput->Mode->Info->VerticalResolution;
115 } else {
116 ASSERT (UgaDraw != NULL);
117 Status = UgaDraw->GetMode (UgaDraw, &SizeOfX, &SizeOfY, &ColorDepth, &RefreshRate);
118 if (EFI_ERROR (Status)) {
119 return EFI_UNSUPPORTED;
120 }
121 }
122
123 Blt = NULL;
124 NumberOfLogos = 0;
125 LogoDestX = 0;
126 LogoDestY = 0;
127 LogoHeight = 0;
128 LogoWidth = 0;
129 NewDestX = 0;
130 NewDestY = 0;
131 Instance = 0;
132 DestX = 0;
133 DestY = 0;
134 while (TRUE) {
135 //
136 // Get image from PlatformLogo protocol.
137 //
138 Status = PlatformLogo->GetImage (
139 PlatformLogo,
140 &Instance,
141 &Image,
142 &Attribute,
143 &OffsetX,
144 &OffsetY
145 );
146 if (EFI_ERROR (Status)) {
147 break;
148 }
149
150 if (Blt != NULL) {
151 FreePool (Blt);
152 }
153
154 Blt = Image.Bitmap;
155
156 //
157 // Calculate the display position according to Attribute.
158 //
159 switch (Attribute) {
160 case EdkiiPlatformLogoDisplayAttributeLeftTop:
161 DestX = 0;
162 DestY = 0;
163 break;
164 case EdkiiPlatformLogoDisplayAttributeCenterTop:
165 DestX = (SizeOfX - Image.Width) / 2;
166 DestY = 0;
167 break;
168 case EdkiiPlatformLogoDisplayAttributeRightTop:
169 DestX = SizeOfX - Image.Width;
170 DestY = 0;
171 break;
172
173 case EdkiiPlatformLogoDisplayAttributeCenterLeft:
174 DestX = 0;
175 DestY = (SizeOfY - Image.Height) / 2;
176 break;
177 case EdkiiPlatformLogoDisplayAttributeCenter:
178 DestX = (SizeOfX - Image.Width) / 2;
179 DestY = (SizeOfY - Image.Height) / 2;
180 break;
181 case EdkiiPlatformLogoDisplayAttributeCenterRight:
182 DestX = SizeOfX - Image.Width;
183 DestY = (SizeOfY - Image.Height) / 2;
184 break;
185
186 case EdkiiPlatformLogoDisplayAttributeLeftBottom:
187 DestX = 0;
188 DestY = SizeOfY - Image.Height;
189 break;
190 case EdkiiPlatformLogoDisplayAttributeCenterBottom:
191 DestX = (SizeOfX - Image.Width) / 2;
192 DestY = SizeOfY - Image.Height;
193 break;
194 case EdkiiPlatformLogoDisplayAttributeRightBottom:
195 DestX = SizeOfX - Image.Width;
196 DestY = SizeOfY - Image.Height;
197 break;
198
199 default:
200 ASSERT (FALSE);
201 continue;
202 break;
203 }
204
205 DestX += OffsetX;
206 DestY += OffsetY;
207
208 if ((DestX >= 0) && (DestY >= 0)) {
209 if (GraphicsOutput != NULL) {
210 Status = GraphicsOutput->Blt (
211 GraphicsOutput,
212 Blt,
213 EfiBltBufferToVideo,
214 0,
215 0,
216 (UINTN)DestX,
217 (UINTN)DestY,
218 Image.Width,
219 Image.Height,
220 Image.Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
221 );
222 } else {
223 ASSERT (UgaDraw != NULL);
224 Status = UgaDraw->Blt (
225 UgaDraw,
226 (EFI_UGA_PIXEL *)Blt,
227 EfiUgaBltBufferToVideo,
228 0,
229 0,
230 (UINTN)DestX,
231 (UINTN)DestY,
232 Image.Width,
233 Image.Height,
234 Image.Width * sizeof (EFI_UGA_PIXEL)
235 );
236 }
237
238 //
239 // Report displayed Logo information.
240 //
241 if (!EFI_ERROR (Status)) {
242 NumberOfLogos++;
243
244 if (NumberOfLogos == 1) {
245 //
246 // The first Logo.
247 //
248 LogoDestX = (UINTN)DestX;
249 LogoDestY = (UINTN)DestY;
250 LogoWidth = Image.Width;
251 LogoHeight = Image.Height;
252 } else {
253 //
254 // Merge new logo with old one.
255 //
256 NewDestX = MIN ((UINTN)DestX, LogoDestX);
257 NewDestY = MIN ((UINTN)DestY, LogoDestY);
258 LogoWidth = MAX ((UINTN)DestX + Image.Width, LogoDestX + LogoWidth) - NewDestX;
259 LogoHeight = MAX ((UINTN)DestY + Image.Height, LogoDestY + LogoHeight) - NewDestY;
260
261 LogoDestX = NewDestX;
262 LogoDestY = NewDestY;
263 }
264 }
265 }
266 }
267
268 if (((BootLogo == NULL) && (BootLogo2 == NULL)) || (NumberOfLogos == 0)) {
269 //
270 // No logo displayed.
271 //
272 if (Blt != NULL) {
273 FreePool (Blt);
274 }
275
276 return Status;
277 }
278
279 //
280 // Advertise displayed Logo information.
281 //
282 if (NumberOfLogos == 1) {
283 //
284 // Only one logo displayed, use its Blt buffer directly for BootLogo protocol.
285 //
286 LogoBlt = Blt;
287 Status = EFI_SUCCESS;
288 } else {
289 //
290 // More than one Logo displayed, get merged BltBuffer using VideoToBuffer operation.
291 //
292 if (Blt != NULL) {
293 FreePool (Blt);
294 }
295
296 //
297 // Ensure the LogoHeight * LogoWidth * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) doesn't overflow
298 //
299 if (LogoHeight > MAX_UINTN / LogoWidth / sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)) {
300 return EFI_UNSUPPORTED;
301 }
302
303 BufferSize = LogoWidth * LogoHeight * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
304
305 LogoBlt = AllocatePool (BufferSize);
306 if (LogoBlt == NULL) {
307 return EFI_OUT_OF_RESOURCES;
308 }
309
310 if (GraphicsOutput != NULL) {
311 Status = GraphicsOutput->Blt (
312 GraphicsOutput,
313 LogoBlt,
314 EfiBltVideoToBltBuffer,
315 LogoDestX,
316 LogoDestY,
317 0,
318 0,
319 LogoWidth,
320 LogoHeight,
321 LogoWidth * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
322 );
323 } else {
324 Status = UgaDraw->Blt (
325 UgaDraw,
326 (EFI_UGA_PIXEL *)LogoBlt,
327 EfiUgaVideoToBltBuffer,
328 LogoDestX,
329 LogoDestY,
330 0,
331 0,
332 LogoWidth,
333 LogoHeight,
334 LogoWidth * sizeof (EFI_UGA_PIXEL)
335 );
336 }
337 }
338
339 if (!EFI_ERROR (Status)) {
340 //
341 // Attempt to register logo with Boot Logo 2 Protocol first
342 //
343 if (BootLogo2 != NULL) {
344 Status = BootLogo2->SetBootLogo (BootLogo2, LogoBlt, LogoDestX, LogoDestY, LogoWidth, LogoHeight);
345 }
346
347 //
348 // If Boot Logo 2 Protocol is not available or registration with Boot Logo 2
349 // Protocol failed, then attempt to register logo with Boot Logo Protocol
350 //
351 if (EFI_ERROR (Status) && (BootLogo != NULL)) {
352 Status = BootLogo->SetBootLogo (BootLogo, LogoBlt, LogoDestX, LogoDestY, LogoWidth, LogoHeight);
353 }
354
355 //
356 // Status of this function is EFI_SUCCESS even if registration with Boot
357 // Logo 2 Protocol or Boot Logo Protocol fails.
358 //
359 Status = EFI_SUCCESS;
360 }
361
362 FreePool (LogoBlt);
363
364 return Status;
365}
366
367/**
368 Use SystemTable Conout to turn on video based Simple Text Out consoles. The
369 Simple Text Out screens will now be synced up with all non video output devices
370
371 @retval EFI_SUCCESS UGA devices are back in text mode and synced up.
372
373**/
374EFI_STATUS
375EFIAPI
376BootLogoDisableLogo (
377 VOID
378 )
379{
380 //
381 // Enable Cursor on Screen
382 //
383 gST->ConOut->EnableCursor (gST->ConOut, TRUE);
384 return EFI_SUCCESS;
385}
386
387/**
388
389 Update progress bar with title above it. It only works in Graphics mode.
390
391 @param TitleForeground Foreground color for Title.
392 @param TitleBackground Background color for Title.
393 @param Title Title above progress bar.
394 @param ProgressColor Progress bar color.
395 @param Progress Progress (0-100)
396 @param PreviousValue The previous value of the progress.
397
398 @retval EFI_STATUS Success update the progress bar
399
400**/
401EFI_STATUS
402EFIAPI
403BootLogoUpdateProgress (
404 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL TitleForeground,
405 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL TitleBackground,
406 IN CHAR16 *Title,
407 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL ProgressColor,
408 IN UINTN Progress,
409 IN UINTN PreviousValue
410 )
411{
412 EFI_STATUS Status;
413 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
414 EFI_UGA_DRAW_PROTOCOL *UgaDraw;
415 UINT32 SizeOfX;
416 UINT32 SizeOfY;
417 UINT32 ColorDepth;
418 UINT32 RefreshRate;
419 EFI_GRAPHICS_OUTPUT_BLT_PIXEL Color;
420 UINTN BlockHeight;
421 UINTN BlockWidth;
422 UINTN BlockNum;
423 UINTN PosX;
424 UINTN PosY;
425 UINTN Index;
426
427 if (Progress > 100) {
428 return EFI_INVALID_PARAMETER;
429 }
430
431 UgaDraw = NULL;
432 Status = gBS->HandleProtocol (gST->ConsoleOutHandle, &gEfiGraphicsOutputProtocolGuid, (VOID **)&GraphicsOutput);
433 if (EFI_ERROR (Status) && FeaturePcdGet (PcdUgaConsumeSupport)) {
434 GraphicsOutput = NULL;
435
436 Status = gBS->HandleProtocol (gST->ConsoleOutHandle, &gEfiUgaDrawProtocolGuid, (VOID **)&UgaDraw);
437 if (EFI_ERROR (Status)) {
438 UgaDraw = NULL;
439 }
440 }
441
442 if (EFI_ERROR (Status)) {
443 return EFI_UNSUPPORTED;
444 }
445
446 SizeOfX = 0;
447 SizeOfY = 0;
448 if (GraphicsOutput != NULL) {
449 SizeOfX = GraphicsOutput->Mode->Info->HorizontalResolution;
450 SizeOfY = GraphicsOutput->Mode->Info->VerticalResolution;
451 } else if (UgaDraw != NULL) {
452 Status = UgaDraw->GetMode (
453 UgaDraw,
454 &SizeOfX,
455 &SizeOfY,
456 &ColorDepth,
457 &RefreshRate
458 );
459 if (EFI_ERROR (Status)) {
460 return EFI_UNSUPPORTED;
461 }
462 } else {
463 return EFI_UNSUPPORTED;
464 }
465
466 BlockWidth = SizeOfX / 100;
467 BlockHeight = SizeOfY / 50;
468
469 BlockNum = Progress;
470
471 PosX = 0;
472 PosY = SizeOfY * 48 / 50;
473
474 if (BlockNum == 0) {
475 //
476 // Clear progress area
477 //
478 SetMem (&Color, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0);
479
480 if (GraphicsOutput != NULL) {
481 Status = GraphicsOutput->Blt (
482 GraphicsOutput,
483 &Color,
484 EfiBltVideoFill,
485 0,
486 0,
487 0,
488 PosY - EFI_GLYPH_HEIGHT - 1,
489 SizeOfX,
490 SizeOfY - (PosY - EFI_GLYPH_HEIGHT - 1),
491 SizeOfX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
492 );
493 } else if (FeaturePcdGet (PcdUgaConsumeSupport)) {
494 Status = UgaDraw->Blt (
495 UgaDraw,
496 (EFI_UGA_PIXEL *)&Color,
497 EfiUgaVideoFill,
498 0,
499 0,
500 0,
501 PosY - EFI_GLYPH_HEIGHT - 1,
502 SizeOfX,
503 SizeOfY - (PosY - EFI_GLYPH_HEIGHT - 1),
504 SizeOfX * sizeof (EFI_UGA_PIXEL)
505 );
506 } else {
507 return EFI_UNSUPPORTED;
508 }
509 }
510
511 //
512 // Show progress by drawing blocks
513 //
514 for (Index = PreviousValue; Index < BlockNum; Index++) {
515 PosX = Index * BlockWidth;
516 if (GraphicsOutput != NULL) {
517 Status = GraphicsOutput->Blt (
518 GraphicsOutput,
519 &ProgressColor,
520 EfiBltVideoFill,
521 0,
522 0,
523 PosX,
524 PosY,
525 BlockWidth - 1,
526 BlockHeight,
527 (BlockWidth) * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
528 );
529 } else if (FeaturePcdGet (PcdUgaConsumeSupport)) {
530 Status = UgaDraw->Blt (
531 UgaDraw,
532 (EFI_UGA_PIXEL *)&ProgressColor,
533 EfiUgaVideoFill,
534 0,
535 0,
536 PosX,
537 PosY,
538 BlockWidth - 1,
539 BlockHeight,
540 (BlockWidth) * sizeof (EFI_UGA_PIXEL)
541 );
542 } else {
543 return EFI_UNSUPPORTED;
544 }
545 }
546
547 PrintXY (
548 (SizeOfX - StrLen (Title) * EFI_GLYPH_WIDTH) / 2,
549 PosY - EFI_GLYPH_HEIGHT - 1,
550 &TitleForeground,
551 &TitleBackground,
552 Title
553 );
554
555 return EFI_SUCCESS;
556}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette