IntelFrameworkModulePkg/Library/GenericBdsLib/BdsConsole.c

   1 /** @file
   2   BDS Lib functions which contain all the code to connect console device
   3
   4 Copyright (c) 2004 - 2009, Intel Corporation. <BR>
   5 All rights reserved. This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "InternalBdsLib.h"
  16 #include "Bmp.h"
  17
  18 /**
  19   Check if we need to save the EFI variable with "ConVarName" as name
  20   as NV type
  21   If ConVarName is NULL, then ASSERT().
  22
  23   @param ConVarName The name of the EFI variable.
  24
  25   @retval TRUE    Set the EFI variable as NV type.
  26   @retval FALSE   EFI variable as NV type can be set NonNV.
  27 **/
  28 BOOLEAN
  29 IsNvNeed (
  30   IN CHAR16 *ConVarName
  31   )
  32 {
  33   CHAR16 *Ptr;
  34
  35   ASSERT (ConVarName != NULL);
  36
  37   Ptr = ConVarName;
  38
  39   //
  40   // If the variable includes "Dev" at last, we consider
  41   // it does not support NV attribute.
  42   //
  43   while (*Ptr != L'\0') {
  44     Ptr++;
  45   }
  46
  47   if (((INTN)((UINTN)Ptr - (UINTN)ConVarName) / sizeof (CHAR16)) <= 3) {
  48     return TRUE;
  49   }
  50
  51   if ((*(Ptr - 3) == 'D') && (*(Ptr - 2) == 'e') && (*(Ptr - 1) == 'v')) {
  52     return FALSE;
  53   } else {
  54     return TRUE;
  55   }
  56 }
  57
  58 /**
  59   Fill console handle in System Table if there are no valid console handle in.
  60
  61   Firstly, check the validation of console handle in System Table. If it is invalid,
  62   update it by the first console device handle from EFI console variable.
  63
  64   @param  VarName            The name of the EFI console variable.
  65   @param  ConsoleGuid        Specified Console protocol GUID.
  66   @param  ConsoleHandle      On IN,  console handle in System Table to be checked.
  67                              On OUT, new console hanlde in system table.
  68   @param  ProtocolInterface  On IN,  console protocol on console handle in System Table to be checked.
  69                              On OUT, new console protocol on new console hanlde in system table.
  70
  71   @retval TRUE               System Table has been updated.
  72   @retval FALSE              System Table hasn't been updated.
  73
  74 **/
  75 BOOLEAN
  76 UpdateSystemTableConsole (
  77   IN     CHAR16                          *VarName,
  78   IN     EFI_GUID                        *ConsoleGuid,
  79   IN OUT EFI_HANDLE                      *ConsoleHandle,
  80   IN OUT VOID                            **ProtocolInterface
  81   )
  82 {
  83   EFI_STATUS                Status;
  84   UINTN                     DevicePathSize;
  85   EFI_DEVICE_PATH_PROTOCOL  *FullDevicePath;
  86   EFI_DEVICE_PATH_PROTOCOL  *VarConsole;
  87   EFI_DEVICE_PATH_PROTOCOL  *Instance;
  88   VOID                      *Interface;
  89   EFI_HANDLE                NewHandle;
  90
  91   ASSERT (VarName != NULL);
  92   ASSERT (ConsoleHandle != NULL);
  93   ASSERT (ConsoleGuid != NULL);
  94   ASSERT (ProtocolInterface != NULL);
  95
  96   if (*ConsoleHandle != NULL) {
  97     Status = gBS->HandleProtocol (
  98                    *ConsoleHandle,
  99                    ConsoleGuid,
 100                    &Interface
 101                    );
 102     if (Status == EFI_SUCCESS && Interface == *ProtocolInterface) {
 103       //
 104       // If ConsoleHandle is valid and console protocol on this handle also
 105       // also matched, just return.
 106       //
 107       return FALSE;
 108     }
 109   }
 110
 111   //
 112   // Get all possible consoles device path from EFI variable
 113   //
 114   VarConsole = BdsLibGetVariableAndSize (
 115                 VarName,
 116                 &gEfiGlobalVariableGuid,
 117                 &DevicePathSize
 118                 );
 119   if (VarConsole == NULL) {
 120     //
 121     // If there is no any console device, just return.
 122     //
 123     return FALSE;
 124   }
 125
 126   FullDevicePath = VarConsole;
 127
 128   do {
 129     //
 130     // Check every instance of the console variable
 131     //
 132     Instance  = GetNextDevicePathInstance (&VarConsole, &DevicePathSize);
 133     if (Instance == NULL) {
 134       FreePool (FullDevicePath);
 135       ASSERT (FALSE);
 136     }
 137
 138     //
 139     // Find console device handle by device path instance
 140     //
 141     Status = gBS->LocateDevicePath (
 142                    ConsoleGuid,
 143                    &Instance,
 144                    &NewHandle
 145                    );
 146     if (!EFI_ERROR (Status)) {
 147       //
 148       // Get the console protocol on this console device handle
 149       //
 150       Status = gBS->HandleProtocol (
 151                      NewHandle,
 152                      ConsoleGuid,
 153                      &Interface
 154                      );
 155       if (!EFI_ERROR (Status)) {
 156         //
 157         // Update new console handle in System Table.
 158         //
 159         *ConsoleHandle     = NewHandle;
 160         *ProtocolInterface = Interface;
 161         return TRUE;
 162       }
 163     }
 164
 165   } while (Instance != NULL);
 166
 167   //
 168   // No any available console devcie found.
 169   //
 170   return FALSE;
 171 }
 172
 173 /**
 174   This function update console variable based on ConVarName, it can
 175   add or remove one specific console device path from the variable
 176
 177   @param  ConVarName               Console related variable name, ConIn, ConOut,
 178                                    ErrOut.
 179   @param  CustomizedConDevicePath  The console device path which will be added to
 180                                    the console variable ConVarName, this parameter
 181                                    can not be multi-instance.
 182   @param  ExclusiveDevicePath      The console device path which will be removed
 183                                    from the console variable ConVarName, this
 184                                    parameter can not be multi-instance.
 185
 186   @retval EFI_UNSUPPORTED          The added device path is same to the removed one.
 187   @retval EFI_SUCCESS              Success add or remove the device path from  the
 188                                    console variable.
 189
 190 **/
 191 EFI_STATUS
 192 EFIAPI
 193 BdsLibUpdateConsoleVariable (
 194   IN  CHAR16                    *ConVarName,
 195   IN  EFI_DEVICE_PATH_PROTOCOL  *CustomizedConDevicePath,
 196   IN  EFI_DEVICE_PATH_PROTOCOL  *ExclusiveDevicePath
 197   )
 198 {
 199   EFI_DEVICE_PATH_PROTOCOL  *VarConsole;
 200   UINTN                     DevicePathSize;
 201   EFI_DEVICE_PATH_PROTOCOL  *NewDevicePath;
 202   EFI_DEVICE_PATH_PROTOCOL  *TempNewDevicePath;
 203   UINT32                    Attributes;
 204
 205   VarConsole      = NULL;
 206   DevicePathSize  = 0;
 207
 208   //
 209   // Notes: check the device path point, here should check
 210   // with compare memory
 211   //
 212   if (CustomizedConDevicePath == ExclusiveDevicePath) {
 213     return EFI_UNSUPPORTED;
 214   }
 215   //
 216   // Delete the ExclusiveDevicePath from current default console
 217   //
 218   VarConsole = BdsLibGetVariableAndSize (
 219                 ConVarName,
 220                 &gEfiGlobalVariableGuid,
 221                 &DevicePathSize
 222                 );
 223
 224   //
 225   // Initialize NewDevicePath
 226   //
 227   NewDevicePath  = VarConsole;
 228
 229   //
 230   // If ExclusiveDevicePath is even the part of the instance in VarConsole, delete it.
 231   // In the end, NewDevicePath is the final device path.
 232   //
 233   if (ExclusiveDevicePath != NULL && VarConsole != NULL) {
 234       NewDevicePath = BdsLibDelPartMatchInstance (VarConsole, ExclusiveDevicePath);
 235   }
 236   //
 237   // Try to append customized device path to NewDevicePath.
 238   //
 239   if (CustomizedConDevicePath != NULL) {
 240     if (!BdsLibMatchDevicePaths (NewDevicePath, CustomizedConDevicePath)) {
 241       //
 242       // Check if there is part of CustomizedConDevicePath in NewDevicePath, delete it.
 243       //
 244       NewDevicePath = BdsLibDelPartMatchInstance (NewDevicePath, CustomizedConDevicePath);
 245       //
 246       // In the first check, the default console variable will be _ModuleEntryPoint,
 247       // just append current customized device path
 248       //
 249       TempNewDevicePath = NewDevicePath;
 250       NewDevicePath = AppendDevicePathInstance (NewDevicePath, CustomizedConDevicePath);
 251       if (TempNewDevicePath != NULL) {
 252         FreePool(TempNewDevicePath);
 253       }
 254     }
 255   }
 256
 257   //
 258   // The attribute for ConInDev, ConOutDev and ErrOutDev does not include NV.
 259   //
 260   if (IsNvNeed(ConVarName)) {
 261     //
 262     // ConVarName has NV attribute.
 263     //
 264     Attributes = EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE;
 265   } else {
 266     //
 267     // ConVarName does not have NV attribute.
 268     //
 269     Attributes = EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
 270   }
 271
 272   //
 273   // Finally, Update the variable of the default console by NewDevicePath
 274   //
 275   gRT->SetVariable (
 276         ConVarName,
 277         &gEfiGlobalVariableGuid,
 278         Attributes,
 279         GetDevicePathSize (NewDevicePath),
 280         NewDevicePath
 281         );
 282
 283   if (VarConsole == NewDevicePath) {
 284     if (VarConsole != NULL) {
 285       FreePool(VarConsole);
 286     }
 287   } else {
 288     if (VarConsole != NULL) {
 289       FreePool(VarConsole);
 290     }
 291     if (NewDevicePath != NULL) {
 292       FreePool(NewDevicePath);
 293     }
 294   }
 295
 296   return EFI_SUCCESS;
 297
 298 }
 299
 300
 301 /**
 302   Connect the console device base on the variable ConVarName, if
 303   device path of the ConVarName is multi-instance device path, if
 304   anyone of the instances is connected success, then this function
 305   will return success.
 306
 307   @param  ConVarName               Console related variable name, ConIn, ConOut,
 308                                    ErrOut.
 309
 310   @retval EFI_NOT_FOUND            There is not any console devices connected
 311                                    success
 312   @retval EFI_SUCCESS              Success connect any one instance of the console
 313                                    device path base on the variable ConVarName.
 314
 315 **/
 316 EFI_STATUS
 317 EFIAPI
 318 BdsLibConnectConsoleVariable (
 319   IN  CHAR16                 *ConVarName
 320   )
 321 {
 322   EFI_STATUS                Status;
 323   EFI_DEVICE_PATH_PROTOCOL  *StartDevicePath;
 324   UINTN                     VariableSize;
 325   EFI_DEVICE_PATH_PROTOCOL  *Instance;
 326   EFI_DEVICE_PATH_PROTOCOL  *Next;
 327   EFI_DEVICE_PATH_PROTOCOL  *CopyOfDevicePath;
 328   UINTN                     Size;
 329   BOOLEAN                   DeviceExist;
 330
 331   Status      = EFI_SUCCESS;
 332   DeviceExist = FALSE;
 333
 334   //
 335   // Check if the console variable exist
 336   //
 337   StartDevicePath = BdsLibGetVariableAndSize (
 338                       ConVarName,
 339                       &gEfiGlobalVariableGuid,
 340                       &VariableSize
 341                       );
 342   if (StartDevicePath == NULL) {
 343     return EFI_UNSUPPORTED;
 344   }
 345
 346   CopyOfDevicePath = StartDevicePath;
 347   do {
 348     //
 349     // Check every instance of the console variable
 350     //
 351     Instance  = GetNextDevicePathInstance (&CopyOfDevicePath, &Size);
 352     if (Instance == NULL) {
 353       FreePool (StartDevicePath);
 354       return EFI_UNSUPPORTED;
 355     }
 356
 357     Next      = Instance;
 358     while (!IsDevicePathEndType (Next)) {
 359       Next = NextDevicePathNode (Next);
 360     }
 361
 362     SetDevicePathEndNode (Next);
 363     //
 364     // Check USB1.1 console
 365     //
 366     if ((DevicePathType (Instance) == MESSAGING_DEVICE_PATH) &&
 367        ((DevicePathSubType (Instance) == MSG_USB_CLASS_DP)
 368        || (DevicePathSubType (Instance) == MSG_USB_WWID_DP)
 369        )) {
 370       //
 371       // Check the Usb console in Usb2.0 bus firstly, then Usb1.1 bus
 372       //
 373       Status = BdsLibConnectUsbDevByShortFormDP (PCI_CLASSC_PI_EHCI, Instance);
 374       if (!EFI_ERROR (Status)) {
 375         DeviceExist = TRUE;
 376       }
 377
 378       Status = BdsLibConnectUsbDevByShortFormDP (PCI_CLASSC_PI_UHCI, Instance);
 379       if (!EFI_ERROR (Status)) {
 380         DeviceExist = TRUE;
 381       }
 382     } else {
 383       //
 384       // Connect the instance device path
 385       //
 386       Status = BdsLibConnectDevicePath (Instance);
 387       if (EFI_ERROR (Status)) {
 388         //
 389         // Delete the instance from the console varialbe
 390         //
 391         BdsLibUpdateConsoleVariable (ConVarName, NULL, Instance);
 392       } else {
 393         DeviceExist = TRUE;
 394       }
 395     }
 396     FreePool(Instance);
 397   } while (CopyOfDevicePath != NULL);
 398
 399   FreePool (StartDevicePath);
 400
 401   if (!DeviceExist) {
 402     return EFI_NOT_FOUND;
 403   }
 404
 405   return EFI_SUCCESS;
 406 }
 407
 408
 409 /**
 410   This function will search every simpletext device in current system,
 411   and make every simpletext device as pertantial console device.
 412
 413 **/
 414 VOID
 415 EFIAPI
 416 BdsLibConnectAllConsoles (
 417   VOID
 418   )
 419 {
 420   UINTN                     Index;
 421   EFI_DEVICE_PATH_PROTOCOL  *ConDevicePath;
 422   UINTN                     HandleCount;
 423   EFI_HANDLE                *HandleBuffer;
 424
 425   Index         = 0;
 426   HandleCount   = 0;
 427   HandleBuffer  = NULL;
 428   ConDevicePath = NULL;
 429
 430   //
 431   // Update all the console variables
 432   //
 433   gBS->LocateHandleBuffer (
 434           ByProtocol,
 435           &gEfiSimpleTextInProtocolGuid,
 436           NULL,
 437           &HandleCount,
 438           &HandleBuffer
 439           );
 440
 441   for (Index = 0; Index < HandleCount; Index++) {
 442     gBS->HandleProtocol (
 443             HandleBuffer[Index],
 444             &gEfiDevicePathProtocolGuid,
 445             (VOID **) &ConDevicePath
 446             );
 447     BdsLibUpdateConsoleVariable (L"ConIn", ConDevicePath, NULL);
 448   }
 449
 450   if (HandleBuffer != NULL) {
 451     FreePool(HandleBuffer);
 452     HandleBuffer = NULL;
 453   }
 454
 455   gBS->LocateHandleBuffer (
 456           ByProtocol,
 457           &gEfiSimpleTextOutProtocolGuid,
 458           NULL,
 459           &HandleCount,
 460           &HandleBuffer
 461           );
 462   for (Index = 0; Index < HandleCount; Index++) {
 463     gBS->HandleProtocol (
 464             HandleBuffer[Index],
 465             &gEfiDevicePathProtocolGuid,
 466             (VOID **) &ConDevicePath
 467             );
 468     BdsLibUpdateConsoleVariable (L"ConOut", ConDevicePath, NULL);
 469     BdsLibUpdateConsoleVariable (L"ErrOut", ConDevicePath, NULL);
 470   }
 471
 472   if (HandleBuffer != NULL) {
 473     FreePool(HandleBuffer);
 474   }
 475
 476   //
 477   // Connect all console variables
 478   //
 479   BdsLibConnectAllDefaultConsoles ();
 480
 481 }
 482
 483 /**
 484   This function will connect console device base on the console
 485   device variable ConIn, ConOut and ErrOut.
 486
 487   @retval EFI_SUCCESS              At least one of the ConIn and ConOut device have
 488                                    been connected success.
 489   @retval EFI_STATUS               Return the status of BdsLibConnectConsoleVariable ().
 490
 491 **/
 492 EFI_STATUS
 493 EFIAPI
 494 BdsLibConnectAllDefaultConsoles (
 495   VOID
 496   )
 497 {
 498   EFI_STATUS                Status;
 499   BOOLEAN                   SystemTableUpdated;
 500
 501   //
 502   // Connect all default console variables
 503   //
 504
 505   //
 506   // It seems impossible not to have any ConOut device on platform,
 507   // so we check the status here.
 508   //
 509   Status = BdsLibConnectConsoleVariable (L"ConOut");
 510   if (EFI_ERROR (Status)) {
 511     return Status;
 512   }
 513
 514   //
 515   // Insert the performance probe for Console Out
 516   //
 517   PERF_START (NULL, "ConOut", "BDS", 1);
 518   PERF_END (NULL, "ConOut", "BDS", 0);
 519
 520   //
 521   // Because possibly the platform is legacy free, in such case,
 522   // ConIn devices (Serial Port and PS2 Keyboard ) does not exist,
 523   // so we need not check the status.
 524   //
 525   BdsLibConnectConsoleVariable (L"ConIn");
 526
 527   //
 528   // The _ModuleEntryPoint err out var is legal.
 529   //
 530   BdsLibConnectConsoleVariable (L"ErrOut");
 531
 532   SystemTableUpdated = FALSE;
 533   //
 534   // Fill console handles in System Table if no console device assignd.
 535   //
 536   if (UpdateSystemTableConsole (L"ConIn", &gEfiSimpleTextInProtocolGuid, &gST->ConsoleInHandle, (VOID **) &gST->ConIn)) {
 537     SystemTableUpdated = TRUE;
 538   }
 539   if (UpdateSystemTableConsole (L"ConOut", &gEfiSimpleTextOutProtocolGuid, &gST->ConsoleOutHandle, (VOID **) &gST->ConOut)) {
 540     SystemTableUpdated = TRUE;
 541   }
 542   if (UpdateSystemTableConsole (L"ErrOut", &gEfiSimpleTextOutProtocolGuid, &gST->StandardErrorHandle, (VOID **) &gST->StdErr)) {
 543     SystemTableUpdated = TRUE;
 544   }
 545
 546   if (SystemTableUpdated) {
 547     //
 548     // Update the CRC32 in the EFI System Table header
 549     //
 550     gST->Hdr.CRC32 = 0;
 551     gBS->CalculateCrc32 (
 552           (UINT8 *) &gST->Hdr,
 553           gST->Hdr.HeaderSize,
 554           &gST->Hdr.CRC32
 555           );
 556   }
 557
 558   return EFI_SUCCESS;
 559
 560 }
 561
 562 /**
 563   Convert a *.BMP graphics image to a GOP blt buffer. If a NULL Blt buffer
 564   is passed in a GopBlt buffer will be allocated by this routine. If a GopBlt
 565   buffer is passed in it will be used if it is big enough.
 566
 567   @param  BmpImage      Pointer to BMP file
 568   @param  BmpImageSize  Number of bytes in BmpImage
 569   @param  GopBlt        Buffer containing GOP version of BmpImage.
 570   @param  GopBltSize    Size of GopBlt in bytes.
 571   @param  PixelHeight   Height of GopBlt/BmpImage in pixels
 572   @param  PixelWidth    Width of GopBlt/BmpImage in pixels
 573
 574   @retval EFI_SUCCESS           GopBlt and GopBltSize are returned.
 575   @retval EFI_UNSUPPORTED       BmpImage is not a valid *.BMP image
 576   @retval EFI_BUFFER_TOO_SMALL  The passed in GopBlt buffer is not big enough.
 577                                 GopBltSize will contain the required size.
 578   @retval EFI_OUT_OF_RESOURCES  No enough buffer to allocate.
 579
 580 **/
 581 EFI_STATUS
 582 ConvertBmpToGopBlt (
 583   IN     VOID      *BmpImage,
 584   IN     UINTN     BmpImageSize,
 585   IN OUT VOID      **GopBlt,
 586   IN OUT UINTN     *GopBltSize,
 587      OUT UINTN     *PixelHeight,
 588      OUT UINTN     *PixelWidth
 589   )
 590 {
 591   UINT8                         *Image;
 592   UINT8                         *ImageHeader;
 593   BMP_IMAGE_HEADER              *BmpHeader;
 594   BMP_COLOR_MAP                 *BmpColorMap;
 595   EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer;
 596   EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
 597   UINT64                        BltBufferSize;
 598   UINTN                         Index;
 599   UINTN                         Height;
 600   UINTN                         Width;
 601   UINTN                         ImageIndex;
 602   BOOLEAN                       IsAllocated;
 603
 604   BmpHeader = (BMP_IMAGE_HEADER *) BmpImage;
 605
 606   if (BmpHeader->CharB != 'B' || BmpHeader->CharM != 'M') {
 607     return EFI_UNSUPPORTED;
 608   }
 609
 610   //
 611   // Doesn't support compress.
 612   //
 613   if (BmpHeader->CompressionType != 0) {
 614     return EFI_UNSUPPORTED;
 615   }
 616
 617   //
 618   // Calculate Color Map offset in the image.
 619   //
 620   Image       = BmpImage;
 621   BmpColorMap = (BMP_COLOR_MAP *) (Image + sizeof (BMP_IMAGE_HEADER));
 622
 623   //
 624   // Calculate graphics image data address in the image
 625   //
 626   Image         = ((UINT8 *) BmpImage) + BmpHeader->ImageOffset;
 627   ImageHeader   = Image;
 628
 629   //
 630   // Calculate the BltBuffer needed size.
 631   //
 632   BltBufferSize = BmpHeader->PixelWidth * BmpHeader->PixelHeight * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
 633   if (BltBufferSize >= SIZE_4GB) {
 634     //
 635     // If the BMP resolution is too large
 636     //
 637     return EFI_UNSUPPORTED;
 638   }
 639
 640   IsAllocated   = FALSE;
 641   if (*GopBlt == NULL) {
 642     //
 643     // GopBlt is not allocated by caller.
 644     //
 645     *GopBltSize = (UINTN) BltBufferSize;
 646     *GopBlt     = AllocatePool (*GopBltSize);
 647     IsAllocated = TRUE;
 648     if (*GopBlt == NULL) {
 649       return EFI_OUT_OF_RESOURCES;
 650     }
 651   } else {
 652     //
 653     // GopBlt has been allocated by caller.
 654     //
 655     if (*GopBltSize < (UINTN) BltBufferSize) {
 656       *GopBltSize = (UINTN) BltBufferSize;
 657       return EFI_BUFFER_TOO_SMALL;
 658     }
 659   }
 660
 661   *PixelWidth   = BmpHeader->PixelWidth;
 662   *PixelHeight  = BmpHeader->PixelHeight;
 663
 664   //
 665   // Convert image from BMP to Blt buffer format
 666   //
 667   BltBuffer = *GopBlt;
 668   for (Height = 0; Height < BmpHeader->PixelHeight; Height++) {
 669     Blt = &BltBuffer[(BmpHeader->PixelHeight - Height - 1) * BmpHeader->PixelWidth];
 670     for (Width = 0; Width < BmpHeader->PixelWidth; Width++, Image++, Blt++) {
 671       switch (BmpHeader->BitPerPixel) {
 672       case 1:
 673         //
 674         // Convert 1-bit (2 colors) BMP to 24-bit color
 675         //
 676         for (Index = 0; Index < 8 && Width < BmpHeader->PixelWidth; Index++) {
 677           Blt->Red    = BmpColorMap[((*Image) >> (7 - Index)) & 0x1].Red;
 678           Blt->Green  = BmpColorMap[((*Image) >> (7 - Index)) & 0x1].Green;
 679           Blt->Blue   = BmpColorMap[((*Image) >> (7 - Index)) & 0x1].Blue;
 680           Blt++;
 681           Width++;
 682         }
 683
 684         Blt--;
 685         Width--;
 686         break;
 687
 688       case 4:
 689         //
 690         // Convert 4-bit (16 colors) BMP Palette to 24-bit color
 691         //
 692         Index       = (*Image) >> 4;
 693         Blt->Red    = BmpColorMap[Index].Red;
 694         Blt->Green  = BmpColorMap[Index].Green;
 695         Blt->Blue   = BmpColorMap[Index].Blue;
 696         if (Width < (BmpHeader->PixelWidth - 1)) {
 697           Blt++;
 698           Width++;
 699           Index       = (*Image) & 0x0f;
 700           Blt->Red    = BmpColorMap[Index].Red;
 701           Blt->Green  = BmpColorMap[Index].Green;
 702           Blt->Blue   = BmpColorMap[Index].Blue;
 703         }
 704         break;
 705
 706       case 8:
 707         //
 708         // Convert 8-bit (256 colors) BMP Palette to 24-bit color
 709         //
 710         Blt->Red    = BmpColorMap[*Image].Red;
 711         Blt->Green  = BmpColorMap[*Image].Green;
 712         Blt->Blue   = BmpColorMap[*Image].Blue;
 713         break;
 714
 715       case 24:
 716         //
 717         // It is 24-bit BMP.
 718         //
 719         Blt->Blue   = *Image++;
 720         Blt->Green  = *Image++;
 721         Blt->Red    = *Image;
 722         break;
 723
 724       default:
 725         //
 726         // Other bit format BMP is not supported.
 727         //
 728         if (IsAllocated) {
 729           FreePool (*GopBlt);
 730           *GopBlt = NULL;
 731         }
 732         return EFI_UNSUPPORTED;
 733         break;
 734       };
 735
 736     }
 737
 738     ImageIndex = (UINTN) (Image - ImageHeader);
 739     if ((ImageIndex % 4) != 0) {
 740       //
 741       // Bmp Image starts each row on a 32-bit boundary!
 742       //
 743       Image = Image + (4 - (ImageIndex % 4));
 744     }
 745   }
 746
 747   return EFI_SUCCESS;
 748 }
 749
 750
 751 /**
 752   Use Console Control Protocol to lock the Console In Spliter virtual handle.
 753   This is the ConInHandle and ConIn handle in the EFI system table. All key
 754   presses will be ignored until the Password is typed in. The only way to
 755   disable the password is to type it in to a ConIn device.
 756
 757   @param  Password        Password used to lock ConIn device.
 758
 759   @retval EFI_SUCCESS     lock the Console In Spliter virtual handle successfully.
 760   @retval EFI_UNSUPPORTED Password not found
 761
 762 **/
 763 EFI_STATUS
 764 EFIAPI
 765 LockKeyboards (
 766   IN  CHAR16    *Password
 767   )
 768 {
 769     return EFI_UNSUPPORTED;
 770 }
 771
 772
 773 /**
 774   Use Console Control to turn off UGA based Simple Text Out consoles from going
 775   to the UGA device. Put up LogoFile on every UGA device that is a console
 776
 777   @param[in]  LogoFile   File name of logo to display on the center of the screen.
 778
 779   @retval EFI_SUCCESS     ConsoleControl has been flipped to graphics and logo displayed.
 780   @retval EFI_UNSUPPORTED Logo not found
 781
 782 **/
 783 EFI_STATUS
 784 EFIAPI
 785 EnableQuietBoot (
 786   IN  EFI_GUID  *LogoFile
 787   )
 788 {
 789   EFI_STATUS                    Status;
 790   EFI_OEM_BADGING_PROTOCOL      *Badging;
 791   UINT32                        SizeOfX;
 792   UINT32                        SizeOfY;
 793   INTN                          DestX;
 794   INTN                          DestY;
 795   UINT8                         *ImageData;
 796   UINTN                         ImageSize;
 797   UINTN                         BltSize;
 798   UINT32                        Instance;
 799   EFI_BADGING_FORMAT            Format;
 800   EFI_BADGING_DISPLAY_ATTRIBUTE Attribute;
 801   UINTN                         CoordinateX;
 802   UINTN                         CoordinateY;
 803   UINTN                         Height;
 804   UINTN                         Width;
 805   EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
 806   EFI_UGA_DRAW_PROTOCOL         *UgaDraw;
 807   UINT32                        ColorDepth;
 808   UINT32                        RefreshRate;
 809   EFI_GRAPHICS_OUTPUT_PROTOCOL  *GraphicsOutput;
 810
 811   UgaDraw = NULL;
 812   //
 813   // Try to open GOP first
 814   //
 815   Status = gBS->HandleProtocol (gST->ConsoleOutHandle, &gEfiGraphicsOutputProtocolGuid, (VOID **) &GraphicsOutput);
 816   if (EFI_ERROR (Status) && FeaturePcdGet (PcdUgaConsumeSupport)) {
 817     GraphicsOutput = NULL;
 818     //
 819     // Open GOP failed, try to open UGA
 820     //
 821     Status = gBS->HandleProtocol (gST->ConsoleOutHandle, &gEfiUgaDrawProtocolGuid, (VOID **) &UgaDraw);
 822   }
 823   if (EFI_ERROR (Status)) {
 824     return EFI_UNSUPPORTED;
 825   }
 826
 827   //
 828   // Erase Cursor from screen
 829   //
 830   gST->ConOut->EnableCursor (gST->ConOut, FALSE);
 831
 832   Badging = NULL;
 833   Status  = gBS->LocateProtocol (&gEfiOEMBadgingProtocolGuid, NULL, (VOID **) &Badging);
 834
 835   if (GraphicsOutput != NULL) {
 836     SizeOfX = GraphicsOutput->Mode->Info->HorizontalResolution;
 837     SizeOfY = GraphicsOutput->Mode->Info->VerticalResolution;
 838
 839   } else if (UgaDraw != NULL && FeaturePcdGet (PcdUgaConsumeSupport)) {
 840     Status = UgaDraw->GetMode (UgaDraw, &SizeOfX, &SizeOfY, &ColorDepth, &RefreshRate);
 841     if (EFI_ERROR (Status)) {
 842       return EFI_UNSUPPORTED;
 843     }
 844   } else {
 845     return EFI_UNSUPPORTED;
 846   }
 847
 848   Instance = 0;
 849   while (1) {
 850     ImageData = NULL;
 851     ImageSize = 0;
 852
 853     if (Badging != NULL) {
 854       //
 855       // Get image from OEMBadging protocol.
 856       //
 857       Status = Badging->GetImage (
 858                           Badging,
 859                           &Instance,
 860                           &Format,
 861                           &ImageData,
 862                           &ImageSize,
 863                           &Attribute,
 864                           &CoordinateX,
 865                           &CoordinateY
 866                           );
 867       if (EFI_ERROR (Status)) {
 868         return Status;
 869       }
 870
 871       //
 872       // Currently only support BMP format.
 873       //
 874       if (Format != EfiBadgingFormatBMP) {
 875         if (ImageData != NULL) {
 876           FreePool (ImageData);
 877         }
 878         continue;
 879       }
 880     } else {
 881       //
 882       // Get the specified image from FV.
 883       //
 884       Status = GetSectionFromAnyFv (LogoFile, EFI_SECTION_RAW, 0, (VOID **) &ImageData, &ImageSize);
 885       if (EFI_ERROR (Status)) {
 886         return EFI_UNSUPPORTED;
 887       }
 888
 889       CoordinateX = 0;
 890       CoordinateY = 0;
 891       Attribute   = EfiBadgingDisplayAttributeCenter;
 892     }
 893
 894     Blt = NULL;
 895     Status = ConvertBmpToGopBlt (
 896               ImageData,
 897               ImageSize,
 898               (VOID **) &Blt,
 899               &BltSize,
 900               &Height,
 901               &Width
 902               );
 903     if (EFI_ERROR (Status)) {
 904       FreePool (ImageData);
 905
 906       if (Badging == NULL) {
 907         return Status;
 908       } else {
 909         continue;
 910       }
 911     }
 912
 913     //
 914     // Calculate the display position according to Attribute.
 915     //
 916     switch (Attribute) {
 917     case EfiBadgingDisplayAttributeLeftTop:
 918       DestX = CoordinateX;
 919       DestY = CoordinateY;
 920       break;
 921
 922     case EfiBadgingDisplayAttributeCenterTop:
 923       DestX = (SizeOfX - Width) / 2;
 924       DestY = CoordinateY;
 925       break;
 926
 927     case EfiBadgingDisplayAttributeRightTop:
 928       DestX = (SizeOfX - Width - CoordinateX);
 929       DestY = CoordinateY;;
 930       break;
 931
 932     case EfiBadgingDisplayAttributeCenterRight:
 933       DestX = (SizeOfX - Width - CoordinateX);
 934       DestY = (SizeOfY - Height) / 2;
 935       break;
 936
 937     case EfiBadgingDisplayAttributeRightBottom:
 938       DestX = (SizeOfX - Width - CoordinateX);
 939       DestY = (SizeOfY - Height - CoordinateY);
 940       break;
 941
 942     case EfiBadgingDisplayAttributeCenterBottom:
 943       DestX = (SizeOfX - Width) / 2;
 944       DestY = (SizeOfY - Height - CoordinateY);
 945       break;
 946
 947     case EfiBadgingDisplayAttributeLeftBottom:
 948       DestX = CoordinateX;
 949       DestY = (SizeOfY - Height - CoordinateY);
 950       break;
 951
 952     case EfiBadgingDisplayAttributeCenterLeft:
 953       DestX = CoordinateX;
 954       DestY = (SizeOfY - Height) / 2;
 955       break;
 956
 957     case EfiBadgingDisplayAttributeCenter:
 958       DestX = (SizeOfX - Width) / 2;
 959       DestY = (SizeOfY - Height) / 2;
 960       break;
 961
 962     default:
 963       DestX = CoordinateX;
 964       DestY = CoordinateY;
 965       break;
 966     }
 967
 968     if ((DestX >= 0) && (DestY >= 0)) {
 969       if (GraphicsOutput != NULL) {
 970         Status = GraphicsOutput->Blt (
 971                             GraphicsOutput,
 972                             Blt,
 973                             EfiBltBufferToVideo,
 974                             0,
 975                             0,
 976                             (UINTN) DestX,
 977                             (UINTN) DestY,
 978                             Width,
 979                             Height,
 980                             Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
 981                             );
 982       } else if (UgaDraw != NULL && FeaturePcdGet (PcdUgaConsumeSupport)) {
 983         Status = UgaDraw->Blt (
 984                             UgaDraw,
 985                             (EFI_UGA_PIXEL *) Blt,
 986                             EfiUgaBltBufferToVideo,
 987                             0,
 988                             0,
 989                             (UINTN) DestX,
 990                             (UINTN) DestY,
 991                             Width,
 992                             Height,
 993                             Width * sizeof (EFI_UGA_PIXEL)
 994                             );
 995       } else {
 996       Status = EFI_UNSUPPORTED;
 997       }
 998     }
 999
1000     FreePool (ImageData);
1001
1002     if (Blt != NULL) {
1003       FreePool (Blt);
1004     }
1005
1006     if (Badging == NULL) {
1007       break;
1008     }
1009   }
1010
1011   return Status;
1012 }
1013
1014 /**
1015   Use Console Control to turn on UGA based Simple Text Out consoles. The UGA
1016   Simple Text Out screens will now be synced up with all non UGA output devices
1017
1018   @retval EFI_SUCCESS     UGA devices are back in text mode and synced up.
1019
1020 **/
1021 EFI_STATUS
1022 EFIAPI
1023 DisableQuietBoot (
1024   VOID
1025   )
1026 {
1027
1028   //
1029   // Enable Cursor on Screen
1030   //
1031   gST->ConOut->EnableCursor (gST->ConOut, TRUE);
1032   return EFI_SUCCESS;
1033 }
1034