1. Rename following library instances according to MDE Library Spec:

1) SerialPortLibNull => BaseSerialPortLibNull
2) DxeMemoryLib => UefiMemoryLib
3) DxeMemoryAllocationLib => UefiMemoryAllocationLib
4) CpuLib => BaseCpuLib
5) HiiLib => UefiHiiLib
6) IfrSupportLib => UefiIfrSupportLib
7) PeiPalCallLib => PeiPalLib

2. Add library instances to MDE package
1) DxePalLib
2) FvbServiceLib
3) GraphicsLib


git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@6221 6f19259b-4bc3-4df7-8a09-765794883524

MdePkg/Library/BaseCpuLib/BaseCpuLib.inf

@@ -16,7 +16,7 @@
 
 [Defines]
   INF_VERSION                    = 0x00010005
-  BASE_NAME                      = CpuLib
+  BASE_NAME                      = BaseCpuLib
   FILE_GUID                      = 4FBD2538-249C-4b50-8F4A-A9E66609CBF6
   MODULE_TYPE                    = BASE
   VERSION_STRING                 = 1.0

MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.inf

@@ -15,7 +15,7 @@
 
 [Defines]
   INF_VERSION                    = 0x00010005
-  BASE_NAME                      = SerialPortLibNull
+  BASE_NAME                      = BaseSerialPortLibNull
   FILE_GUID                      = E4541241-8897-411a-91F8-7D7E45837146
   MODULE_TYPE                    = BASE
   VERSION_STRING                 = 1.0
@@ -29,7 +29,7 @@
 #
 
 [Sources.common]
-  SerialPortLibNull.c
+  BaseSerialPortLibNull.c
 
 
 [Packages]

MdePkg/Library/DxePalLib/DxePalCallLib.c

@@ -0,0 +1,116 @@
+/** @file
+  PAL Library Class implementation whose PAL entry is collected
+  from HOB or SAL System Table.
+
+  Copyright (c) 2007 - 2008 Intel Corporation. All rights reserved
+  This software and associated documentation (if any) is furnished
+  under a license and may only be used or copied in accordance
+  with the terms of the license. Except as permitted by such
+  license, no part of this software or documentation may be
+  reproduced, stored in a retrieval system, or transmitted in any
+  form or by any means without the express written consent of
+  Intel Corporation.
+
+  Module Name:  DxePalCallLib.c
+
+**/
+
+#include <PiDxe.h>
+#include <ItaniumFamilyCpuDxe.h>
+#include <IndustryStandard/Sal.h>
+
+#include <Guid/PalEntryHob.h>
+#include <Guid/SalSystemTable.h>
+
+#include <Library/PalCallLib.h>
+#include <Library/BaseLib.h>
+#include <Library/HobLib.h>
+#include <Library/DebugLib.h>
+#include <Library/UefiLib.h>
+
+
+BOOLEAN mPalCallAddressHob = FALSE;
+BOOLEAN mPalCallAddressSal = FALSE;
+UINT64  mPalCallAddress;
+
+/**
+  Makes a PAL procedure call.
+
+  This is a wrapper function to make a PAL procedure call.  Based on the Index value,
+  this API will make static or stacked PAL call. Architected procedures may be designated
+  as required or optional.  If a PAL procedure is specified as optional, a unique return
+  code of 0xFFFFFFFFFFFFFFFF is returned in the Status field of the PAL_CALL_RETURN structure.
+  This indicates that the procedure is not present in this PAL implementation.  It is the
+  caller's responsibility to check for this return code after calling any optional PAL
+  procedure. No parameter checking is performed on the 4 input parameters, but there are
+  some common rules that the caller should follow when making a PAL call.  Any address
+  passed to PAL as buffers for return parameters must be 8-byte aligned.  Unaligned addresses
+  may cause undefined results.  For those parameters defined as reserved or some fields
+  defined as reserved must be zero filled or the invalid argument return value may be
+  returned or undefined result may occur during the execution of the procedure.
+  This function is only available on IPF.
+
+  @param  Index  The PAL procedure Index number.
+  @param  Arg2   The 2nd parameter for PAL procedure calls.
+  @param  Arg3   The 3rd parameter for PAL procedure calls.
+  @param  Arg4   The 4th parameter for PAL procedure calls.
+
+  @return Structure returned from the PAL Call procedure, including the status and return value.
+
+**/
+PAL_CALL_RETURN
+EFIAPI
+PalCall (
+  IN UINT64                  Index,
+  IN UINT64                  Arg2,
+  IN UINT64                  Arg3,
+  IN UINT64                  Arg4
+  )
+{
+  EFI_HOB_GUID_TYPE              *GuidHob;
+  EFI_STATUS                     Status;
+  SAL_ST_ENTRY_POINT_DESCRIPTOR  *SalStEntryDes;
+  SAL_SYSTEM_TABLE_HEADER        *SalSystemTable;
+
+
+  if (!mPalCallAddressHob) {
+    //
+    // Collect PAL entry from HOBs
+    //
+    GuidHob = GetFirstGuidHob (&gPalEntryHobGuid);
+    ASSERT (GuidHob != NULL);
+
+    mPalCallAddress = *((EFI_PHYSICAL_ADDRESS *) GET_GUID_HOB_DATA (GuidHob));
+    ASSERT (mPalCallAddress != 0);
+
+    mPalCallAddressHob = TRUE;
+  }
+
+  if (!mPalCallAddressSal) {
+    Status = EfiGetSystemConfigurationTable (
+               &gEfiSalSystemTableGuid,
+               (VOID **) &SalSystemTable
+               );
+
+    if (!EFI_ERROR (Status)) {
+      //
+      // Move the SAL System Table point to the first Entry
+      // Due to the SAL Entry is in ascending order with the Entry type,
+      // the type 0 Entry should be the first if exist.
+      //
+      SalStEntryDes = (SAL_ST_ENTRY_POINT_DESCRIPTOR *)(SalSystemTable + 1);
+
+      //
+      // Assure the SAL ENTRY Type is 0
+      //
+      ASSERT (SalStEntryDes->Type == EFI_SAL_ST_ENTRY_POINT);
+
+      if (SalStEntryDes->PalProcEntry != 0) {
+        mPalCallAddress = SalStEntryDes->PalProcEntry;
+        mPalCallAddressSal = TRUE;
+      }
+    }
+  }
+
+  return AsmPalCall (mPalCallAddress, Index, Arg2, Arg3, Arg4);
+}

MdePkg/Library/DxePalLib/DxePalLib.inf

@@ -0,0 +1,54 @@
+# @file
+# Instance of PAL Library Class
+#
+# This library implements the PAL Library Class for the early dxe drivers that need PAL calls before the 
+# Extended SAL PAL services are available
+# Copyright (c) 2007, Intel Corporation. All rights reserved.
+#
+#  This software and associated documentation (if any) is furnished
+#  under a license and may only be used or copied in accordance
+#  with the terms of the license. Except as permitted by such
+#  license, no part of this software or documentation may be
+#  reproduced, stored in a retrieval system, or transmitted in any
+#  form or by any means without the express written consent of
+#  Intel Corporation.
+#
+#
+#
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = DxePalLib
+  FILE_GUID                      = B05D4251-5BA5-46f2-A011-46CC46D9A590
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = PalCallLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER UEFI_DRIVER 
+  EDK_RELEASE_VERSION            = 0x00020000
+  EFI_SPECIFICATION_VERSION      = 0x00020000
+
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IPF
+#
+
+[Sources.IPF]
+  DxePalCallLib.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+  IntelFrameworkPkg/IntelFrameworkPkg.dec
+  ItaniumFamilyCpuPkg/ItaniumFamilyCpuPkg.dec
+  ItaniumPlatformPkg/ItaniumPlatformPkg.dec 
+
+[LibraryClasses]
+  BaseLib
+  HobLib
+  UefiLib
+  DebugLib
+
+[Guids]
+  gEfiHobListGuid                               # ALWAYS_CONSUMED
+  gPalEntryHobGuid                              # ALWAYS_CONSUMED
+  gEfiSalSystemTableGuid                        # ALWAYS_CONSUMED

MdePkg/Library/FvbServiceLib/Fvb.c

@@ -0,0 +1,726 @@
+/**@file
+
+  Firmware Volume Block Protocol Runtime Interface Abstraction
+  And FVB Extension protocol Runtime Interface Abstraction
+
+  mFvbEntry is an array of Handle Fvb pairs. The Fvb Lib Instance matches the
+  index in the mFvbEntry array. This should be the same sequence as the FVB's
+  were described in the HOB. We have to remember the handle so we can tell if
+  the protocol has been reinstalled and it needs updateing.
+
+  If you are using any of these lib functions.you must first call FvbInitialize ().
+
+Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+#include "Fvb.h"
+
+//
+// Event for Set Virtual Map Changed Event
+//
+STATIC EFI_EVENT mSetVirtualMapChangedEvent = NULL;
+
+//
+// Lib will ASSERT if more FVB devices than this are added to the system.
+//
+STATIC FVB_ENTRY          *mFvbEntry;
+STATIC EFI_EVENT          mFvbRegistration;
+STATIC UINTN              mFvbCount;
+
+/**
+  Check whether an address is runtime memory or not.
+
+  @param    Address   The Address being checked.
+
+  @retval   TRUE      The address is runtime memory.
+  @retval   FALSE     The address is not runtime memory.
+**/
+BOOLEAN
+IsRuntimeMemory (
+  IN VOID   *Address
+  )
+{
+  EFI_STATUS                           Status;
+  UINT8                                TmpMemoryMap[1];
+  UINTN                                MapKey;
+  UINTN                                DescriptorSize;
+  UINT32                               DescriptorVersion;
+  UINTN                                MemoryMapSize;
+  EFI_MEMORY_DESCRIPTOR                *MemoryMap;
+  EFI_MEMORY_DESCRIPTOR                *MemoryMapPtr;
+  BOOLEAN                              IsRuntime;
+  UINTN                                Index;
+
+  IsRuntime = FALSE;
+
+  //
+  // Get System MemoryMapSize
+  //
+  MemoryMapSize = 1;
+  Status = gBS->GetMemoryMap (
+                  &MemoryMapSize,
+                  (EFI_MEMORY_DESCRIPTOR *)TmpMemoryMap,
+                  &MapKey,
+                  &DescriptorSize,
+                  &DescriptorVersion
+                  );
+  ASSERT (Status == EFI_BUFFER_TOO_SMALL);
+  //
+  // Enlarge space here, because we will allocate pool now.
+  //
+  MemoryMapSize += EFI_PAGE_SIZE;
+  Status = gBS->AllocatePool (
+                  EfiBootServicesData,
+                  MemoryMapSize,
+                  (VOID**)&MemoryMap
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  //
+  // Get System MemoryMap
+  //
+  Status = gBS->GetMemoryMap (
+                  &MemoryMapSize,
+                  MemoryMap,
+                  &MapKey,
+                  &DescriptorSize,
+                  &DescriptorVersion
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  MemoryMapPtr = MemoryMap;
+  //
+  // Search the request Address
+  //
+  for (Index = 0; Index < (MemoryMapSize / DescriptorSize); Index++) {
+    if (((EFI_PHYSICAL_ADDRESS)(UINTN)Address >= MemoryMap->PhysicalStart) &&
+        ((EFI_PHYSICAL_ADDRESS)(UINTN)Address < MemoryMap->PhysicalStart
+                                              + LShiftU64 (MemoryMap->NumberOfPages, EFI_PAGE_SHIFT))) {
+      //
+      // Found it
+      //
+      if (MemoryMap->Attribute & EFI_MEMORY_RUNTIME) {
+        IsRuntime = TRUE;
+      }
+      break;
+    }
+    //
+    // Get next item
+    //
+    MemoryMap = (EFI_MEMORY_DESCRIPTOR *)((UINTN)MemoryMap + DescriptorSize);
+  }
+
+  //
+  // Done
+  //
+  gBS->FreePool (MemoryMapPtr);
+
+  return IsRuntime;
+}
+
+/**
+  Update mFvbEntry. Add new entry, or update existing entry if Fvb protocol is
+  reinstalled.
+
+  @param Event      The Event that is being processed
+  @param Context    Event Context
+
+**/
+STATIC
+VOID
+EFIAPI
+FvbNotificationEvent (
+  IN  EFI_EVENT       Event,
+  IN  VOID            *Context
+  )
+{
+  EFI_STATUS  Status;
+  UINTN       BufferSize;
+  EFI_HANDLE  Handle;
+  UINTN       Index;
+  UINTN       UpdateIndex;
+
+  while (TRUE) {
+    BufferSize = sizeof (Handle);
+    Status = gBS->LocateHandle (
+                    ByRegisterNotify,
+                    &gEfiFirmwareVolumeBlockProtocolGuid,
+                    mFvbRegistration,
+                    &BufferSize,
+                    &Handle
+                    );
+    if (EFI_ERROR (Status)) {
+      //
+      // Exit Path of While Loop....
+      //
+      break;
+    }
+
+    UpdateIndex = MAX_FVB_COUNT;
+    for (Index = 0; Index < mFvbCount; Index++) {
+      if (mFvbEntry[Index].Handle == Handle) {
+        //
+        //  If the handle is already in the table just update the protocol
+        //
+        UpdateIndex = Index;
+        break;
+      }
+    }
+
+    if (UpdateIndex == MAX_FVB_COUNT) {
+      //
+      // Use the next free slot for a new entry
+      //
+      UpdateIndex                   = mFvbCount++;
+      //
+      // Check the UpdateIndex whether exceed the maximum value.
+      //
+      ASSERT (UpdateIndex < MAX_FVB_COUNT);
+      mFvbEntry[UpdateIndex].Handle = Handle;
+    }
+    //
+    // The array does not have enough entries
+    //
+    ASSERT (UpdateIndex < MAX_FVB_COUNT);
+
+    //
+    //  Get the interface pointer and if it's ours, skip it
+    //
+    Status = gBS->HandleProtocol (
+                    Handle,
+                    &gEfiFirmwareVolumeBlockProtocolGuid,
+                    (VOID **) &mFvbEntry[UpdateIndex].Fvb
+                    );
+    ASSERT_EFI_ERROR (Status);
+
+    Status = gBS->HandleProtocol (
+                    Handle,
+                    &gEfiFvbExtensionProtocolGuid,
+                    (VOID **) &mFvbEntry[UpdateIndex].FvbExtension
+                    );
+    if (Status != EFI_SUCCESS) {
+      mFvbEntry[UpdateIndex].FvbExtension = NULL;
+    }
+
+    //
+    // Check the FVB can be accessed in RUNTIME, The FVBs in FVB handle list comes
+    // from two way:
+    // 1) Dxe Core. (FVB information is transferred from FV HOB).
+    // 2) FVB driver.
+    // The FVB produced Dxe core is used for discoverying DXE driver and dispatch. These
+    // FVBs can only be accessed in boot time.
+    // FVB driver will discovery all FV in FLASH and these FVBs can be accessed in runtime.
+    // The FVB itself produced by FVB driver is allocated in runtime memory. So we can
+    // determine the what FVB can be accessed in RUNTIME by judging whether FVB itself is allocated
+    // in RUNTIME memory.
+    //
+    mFvbEntry[UpdateIndex].IsRuntimeAccess = IsRuntimeMemory (mFvbEntry[UpdateIndex].Fvb);
+  }
+}
+
+/**
+  Convert all pointers in mFvbEntry after ExitBootServices.
+
+  @param Event      The Event that is being processed
+  @param Context    Event Context
+
+**/
+VOID
+EFIAPI
+FvbVirtualAddressChangeNotifyEvent (
+  IN EFI_EVENT        Event,
+  IN VOID             *Context
+  )
+{
+  UINTN Index;
+  if (mFvbEntry != NULL) {
+    for (Index = 0; Index < MAX_FVB_COUNT; Index++) {
+      if (!mFvbEntry[Index].IsRuntimeAccess) {
+        continue;
+      }
+
+      if (NULL != mFvbEntry[Index].Fvb) {
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->GetBlockSize);
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->GetPhysicalAddress);
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->GetAttributes);
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->SetAttributes);
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->Read);
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->Write);
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->EraseBlocks);
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb);
+      }
+
+      if (NULL != mFvbEntry[Index].FvbExtension) {
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].FvbExtension->EraseFvbCustomBlock);
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].FvbExtension);
+      }
+    }
+
+    EfiConvertPointer (0x0, (VOID **) &mFvbEntry);
+  }
+}
+
+/**
+  Library constructor function entry.
+
+  @param ImageHandle    The handle of image who call this libary.
+  @param SystemTable    The point of System Table.
+
+  @retval EFI_SUCESS    Sucess construct this library.
+  @retval Others        Fail to contruct this libary.
+**/
+EFI_STATUS
+EFIAPI
+FvbLibInitialize (
+  IN EFI_HANDLE         ImageHandle,
+  IN EFI_SYSTEM_TABLE   *SystemTable
+  )
+{
+  UINTN Status;
+  mFvbCount = 0;
+
+  Status = gBS->AllocatePool (
+                  EfiRuntimeServicesData,
+                  (UINTN) sizeof (FVB_ENTRY) * MAX_FVB_COUNT,
+                  (VOID *) &mFvbEntry
+                  );
+
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  ZeroMem (mFvbEntry, sizeof (FVB_ENTRY) * MAX_FVB_COUNT);
+
+  EfiCreateProtocolNotifyEvent (
+    &gEfiFirmwareVolumeBlockProtocolGuid,
+    TPL_CALLBACK,
+    FvbNotificationEvent,
+    NULL,
+    &mFvbRegistration
+    );
+
+  //
+  // Register SetVirtualAddressMap () notify function
+  //
+  Status = gBS->CreateEvent (
+                  EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE,
+                  TPL_NOTIFY,
+                  FvbVirtualAddressChangeNotifyEvent,
+                  NULL,
+                  &mSetVirtualMapChangedEvent
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  return EFI_SUCCESS;
+}
+
+//
+// =============================================================================
+// The following functions wrap Fvb protocol in the Runtime Lib functions.
+// The Instance translates into Fvb instance. The Fvb order defined by HOBs and
+// thus the sequence of FVB protocol addition define Instance.
+//
+// EfiFvbInitialize () must be called before any of the following functions
+// must be called.
+// =============================================================================
+//
+
+/**
+  Reads specified number of bytes into a buffer from the specified block.
+
+  The EfiFvbReadBlock() function reads the requested number of bytes from
+  the requested block in the specified firmware volume and stores them in
+  the provided buffer. Implementations should be mindful that the firmware
+  volume might be in the ReadDisabled state.  If it is in this state, the 
+  EfiFvbReadBlock() function must return the status code EFI_ACCESS_DENIED
+  without modifying the contents of the buffer.
+  
+  The EfiFvbReadBlock() function must also prevent spanning block boundaries.
+  If a read is requested that would span a block boundary, the read must read
+  up to the boundary but not beyond.  The output parameter NumBytes must be
+  set to correctly indicate the number of bytes actually read.  
+  The caller must be aware that a read may be partially completed.
+
+  If NumBytes is NULL, then ASSERT().
+
+  If Buffer is NULL, then ASSERT().
+
+  @param[in]      Instance         The FV instance to be read from.
+  @param[in]      Lba              The logical block address to be read from
+  @param[in]      Offset           The offset relative to the block, at which to begin reading.
+  @param[in, out] NumBytes         Pointer to a UINTN. On input, *NumBytes contains the total
+                                   size of the buffer. On output, it contains the actual number
+                                   of bytes read.
+  @param[out]     Buffer           Pointer to a caller allocated buffer that will be
+                                   used to hold the data read.
+
+  @retval   EFI_SUCCESS	           The firmware volume was read successfully and contents are in Buffer.
+  @retval   EFI_BAD_BUFFER_SIZE    Read attempted across an LBA boundary.  On output, NumBytes contains the total number of bytes returned in Buffer.
+  @retval   EFI_ACCESS_DENIED      The firmware volume is in the ReadDisabled state.
+  @retval   EFI_DEVICE_ERROR       The block device is not functioning correctly and could not be read.
+  @retval   EFI_INVALID_PARAMETER  Invalid parameter, Instance is larger than the max FVB number. Lba index is larger than the last block of the firmware volume. Offset is larger than the block size.
+
+**/
+EFI_STATUS
+EfiFvbReadBlock (
+  IN UINTN                                        Instance,
+  IN EFI_LBA                                      Lba,
+  IN UINTN                                        Offset,
+  IN OUT UINTN                                    *NumBytes,
+  OUT UINT8                                       *Buffer
+  )
+{
+  ASSERT (NumBytes != NULL);
+  ASSERT (Buffer != NULL);
+  
+  if (Instance >= mFvbCount) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  return mFvbEntry[Instance].Fvb->Read (mFvbEntry[Instance].Fvb, Lba, Offset, NumBytes, Buffer);
+}
+
+/**
+  Writes specified number of bytes from the input buffer to the block
+
+  The EfiFvbWriteBlock() function writes the specified number of bytes
+  from the provided buffer to the specified block and offset in the 
+  requested firmware volume. 
+
+  If the firmware volume is sticky write, the caller must ensure that
+  all the bits of the specified range to write are in the EFI_FVB_ERASE_POLARITY
+  state before calling the EfiFvbWriteBlock() function, or else the 
+  result will be unpredictable.  This unpredictability arises because,
+  for a sticky-write firmware volume, a write may negate a bit in the 
+  EFI_FVB_ERASE_POLARITY state but it cannot flip it back again. In 
+  general, before calling the EfiFvbWriteBlock() function, the caller
+  should call the EfiFvbEraseBlock() function first to erase the specified
+  block to write. A block erase cycle will transition bits from the
+  (NOT)EFI_FVB_ERASE_POLARITY state back to the EFI_FVB_ERASE_POLARITY state.
+  Implementations should be mindful that the firmware volume might be 
+  in the WriteDisabled state.  If it is in this state, the EfiFvbWriteBlock()
+  function must return the status code EFI_ACCESS_DENIED without modifying
+  the contents of the firmware volume.
+  
+  The EfiFvbWriteBlock() function must also prevent spanning block boundaries.
+  If a write is requested that spans a block boundary, the write must store
+  up to the boundary but not beyond. The output parameter NumBytes must be 
+  set to correctly indicate the number of bytes actually written. The caller
+  must be aware that a write may be partially completed.
+  All writes, partial or otherwise, must be fully flushed to the hardware 
+  before the EfiFvbWriteBlock() function returns. 
+  
+  If NumBytes is NULL, then ASSERT().
+
+  @param Instance               The FV instance to be written to
+  @param Lba                    The starting logical block index to write to
+  @param Offset                 The offset relative to the block, at which to begin writting.
+  @param NumBytes               Pointer to a UINTN. On input, *NumBytes contains
+                                the total size of the buffer. On output, it contains
+                                the actual number of bytes written.
+  @param Buffer                 Pointer to a caller allocated buffer that contains
+                                the source for the write
+
+  @retval EFI_SUCCESS           The firmware volume was written successfully.
+  @retval EFI_BAD_BUFFER_SIZE   The write was attempted across an LBA boundary. 
+                                On output, NumBytes contains the total number of bytes actually written.
+  @retval EFI_ACCESS_DENIED	    The firmware volume is in the WriteDisabled state.
+  @retval EFI_DEVICE_ERROR      The block device is malfunctioning and could not be written.
+  @retval EFI_INVALID_PARAMETER Invalid parameter, Instance is larger than the max FVB number. 
+                                Lba index is larger than the last block of the firmware volume.
+                                Offset is larger than the block size.
+**/
+EFI_STATUS
+EfiFvbWriteBlock (
+  IN UINTN                                        Instance,
+  IN EFI_LBA                                      Lba,
+  IN UINTN                                        Offset,
+  IN OUT UINTN                                    *NumBytes,
+  IN UINT8                                        *Buffer
+  )
+{
+  ASSERT (NumBytes != NULL);
+  
+  if (Instance >= mFvbCount) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  return mFvbEntry[Instance].Fvb->Write (mFvbEntry[Instance].Fvb, Lba, Offset, NumBytes, Buffer);
+}
+
+/**
+  Erases and initializes a firmware volume block.
+
+  The EfiFvbEraseBlock() function erases one block specified by Lba.
+  Implementations should be mindful that the firmware volume might 
+  be in the WriteDisabled state. If it is in this state, the EfiFvbEraseBlock()
+  function must return the status code EFI_ACCESS_DENIED without 
+  modifying the contents of the firmware volume. If Instance is 
+  larger than the max FVB number, or Lba index is larger than the
+  last block of the firmware volume, this function return the status
+  code EFI_INVALID_PARAMETER.
+  
+  All calls to EfiFvbEraseBlock() must be fully flushed to the 
+  hardware before this function returns. 
+
+  @param[in]     Instance    The FV instance to be erased.
+  @param[in]     Lba         The logical block index to be erased from.
+  
+  @retval EFI_SUCCESS            The erase request was successfully completed.
+  @retval EFI_ACCESS_DENIED      The firmware volume is in the WriteDisabled state.
+  @retval EFI_DEVICE_ERROR       The block device is not functioning correctly and
+                                 could not be written.  The firmware device may 
+                                 have been partially erased.
+  @retval EFI_INVALID_PARAMETER  Invalid parameter. Instance is larger than the max
+                                 FVB number. Lba index is larger than the last block
+                                 of the firmware volume. 
+
+**/
+EFI_STATUS
+EfiFvbEraseBlock (
+  IN UINTN                                Instance,
+  IN EFI_LBA                              Lba
+  )
+{
+  if (Instance >= mFvbCount) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  return mFvbEntry[Instance].Fvb->EraseBlocks (mFvbEntry[Instance].Fvb, Lba, 1, EFI_LBA_LIST_TERMINATOR);
+}
+
+/**
+  Retrieves the attributes and current settings of the specified block, 
+  returns resulting attributes in output parameter.
+
+  The EfiFvbGetAttributes() function retrieves the attributes and current
+  settings of the block specified by Instance. If Instance is larger than
+  the max FVB number, this function returns the status code EFI_INVALID_PARAMETER.
+
+  If Attributes is NULL, then ASSERT().
+
+  @param[in]     Instance          The FV instance to be operated.
+  @param[out]    Attributes        Pointer to EFI_FVB_ATTRIBUTES_2 in which the
+                                   attributes and current settings are returned.
+
+  @retval   EFI_EFI_SUCCESS        The firmware volume attributes were returned.
+  @retval   EFI_INVALID_PARAMETER  Invalid parameter. Instance is larger than the max FVB number. 
+**/
+EFI_STATUS
+EfiFvbGetVolumeAttributes (
+  IN UINTN                                Instance,
+  OUT EFI_FVB_ATTRIBUTES_2                *Attributes
+  )
+{
+  ASSERT (Attributes != NULL);
+  
+  if (Instance >= mFvbCount) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  return mFvbEntry[Instance].Fvb->GetAttributes (mFvbEntry[Instance].Fvb, Attributes);
+}
+
+/**
+  Modify the attributes and current settings of the specified block
+  according to the input parameter.
+
+  The EfiFvbSetAttributes() function sets configurable firmware volume
+  attributes and returns the new settings of the firmware volume specified
+  by Instance. If Instance is larger than the max FVB number, this function
+  returns the status code EFI_INVALID_PARAMETER.
+
+  If Attributes is NULL, then ASSERT().
+
+  @param[in]     Instance          The FV instance to be operated.
+  @param[in, out]Attributes        On input, Attributes is a pointer to EFI_FVB_ATTRIBUTES_2
+                                   that contains the desired firmware volume settings.  
+                                   On successful return, it contains the new settings of the firmware volume.
+
+  @retval   EFI_EFI_SUCCESS        The firmware volume attributes were modified successfully.
+  @retval   EFI_INVALID_PARAMETER  Invalid parameter. Instance is larger than the max FVB number.
+
+**/
+EFI_STATUS
+EfiFvbSetVolumeAttributes (
+  IN     UINTN                                Instance,
+  IN OUT EFI_FVB_ATTRIBUTES_2                 *Attributes
+  )
+{
+  ASSERT (Attributes != NULL);
+  
+  if (Instance >= mFvbCount) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  return mFvbEntry[Instance].Fvb->SetAttributes (mFvbEntry[Instance].Fvb, Attributes);
+}
+
+/**
+  Retrieves the physical address of the specified memory mapped FV.
+
+  Retrieve the base address of a memory-mapped firmware volume specified by Instance.
+  If Instance is larger than the max FVB number, this function returns the status 
+  code EFI_INVALID_PARAMETER.
+  
+  If BaseAddress is NULL, then ASSERT().
+
+  @param[in]     Instance          The FV instance to be operated.
+  @param[out]    BaseAddress       Pointer to a caller allocated EFI_PHYSICAL_ADDRESS 
+                                   that on successful return, contains the base address
+                                   of the firmware volume. 
+
+  @retval   EFI_EFI_SUCCESS        The firmware volume base address is returned.
+  @retval   EFI_INVALID_PARAMETER  Invalid parameter. Instance is larger than the max FVB number. 
+
+**/
+EFI_STATUS
+EfiFvbGetPhysicalAddress (
+  IN UINTN                                Instance,
+  OUT EFI_PHYSICAL_ADDRESS                *BaseAddress
+  )
+{
+  ASSERT (BaseAddress != NULL);
+  
+  if (Instance >= mFvbCount) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  return mFvbEntry[Instance].Fvb->GetPhysicalAddress (mFvbEntry[Instance].Fvb, BaseAddress);
+}
+
+/**
+  Retrieve the block size of the specified fv.
+  
+  The EfiFvbGetBlockSize() function retrieves the size of the requested block. 
+  It also returns the number of additional blocks with the identical size. 
+  If Instance is larger than the max FVB number, or Lba index is larger than
+  the last block of the firmware volume, this function return the status code
+  EFI_INVALID_PARAMETER.
+
+  If BlockSize	is NULL, then ASSERT().
+  
+  If NumOfBlocks  is NULL, then ASSERT().
+
+  @param[in]     Instance          The FV instance to be operated.
+  @param[in]     Lba               Indicates which block to return the size for.
+  @param[out]    BlockSize         Pointer to a caller-allocated UINTN in which the
+                                   size of the block is returned.
+  @param[out]    NumOfBlocks       Pointer to a caller-allocated UINTN in which the 
+                                   number of consecutive blocks, starting with Lba, 
+                                   is returned. All blocks in this range have a size of BlockSize.
+
+  @retval   EFI_EFI_SUCCESS        The firmware volume base address is returned.
+  @retval   EFI_INVALID_PARAMETER  Invalid parameter. Instance is larger than the max FVB number.
+                                   Lba index is larger than the last block of the firmware volume.
+
+**/
+EFI_STATUS
+EfiFvbGetBlockSize (
+  IN UINTN                                        Instance,
+  IN EFI_LBA                                      Lba,
+  OUT UINTN                                       *BlockSize,
+  OUT UINTN                                       *NumOfBlocks
+  )
+{
+  ASSERT (BlockSize != NULL);
+  ASSERT (NumOfBlocks != NULL);
+  
+  if (Instance >= mFvbCount) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  return mFvbEntry[Instance].Fvb->GetBlockSize (mFvbEntry[Instance].Fvb, Lba, BlockSize, NumOfBlocks);
+}
+
+/**
+  Erases and initializes a specified range of a firmware volume.
+
+  The EfiFvbEraseCustomBlockRange() function erases the specified range in the firmware
+  volume index by Instance. If Instance is larger than the max FVB number, StartLba or 
+  LastLba  index is larger than the last block of the firmware volume, StartLba > LastLba
+  or StartLba equal to LastLba but OffsetStartLba > OffsetLastLba, this function return 
+  the status code EFI_INVALID_PARAMETER.
+
+  @param[in]     Instance          The FV instance to be operated.
+  @param[in]     StartLba          The starting logical block index to be erased.
+  @param[in]     OffsetStartLba    Offset into the starting block at which to 
+                                   begin erasing.    
+  @param[in]     LastLba           The last logical block index to be erased.
+  @param[in]     OffsetLastLba     Offset into the last block at which to end erasing.   
+
+  @retval   EFI_EFI_SUCCESS        Successfully erase custom block range
+  @retval   EFI_INVALID_PARAMETER  Invalid parameter. Instance is larger than the max FVB number. 
+  @retval   EFI_UNSUPPORTED        Firmware volume block device has no this capability.
+
+**/
+EFI_STATUS
+EfiFvbEraseCustomBlockRange (
+  IN UINTN                                Instance,
+  IN EFI_LBA                              StartLba,
+  IN UINTN                                OffsetStartLba,
+  IN EFI_LBA                              LastLba,
+  IN UINTN                                OffsetLastLba
+  )
+{
+  if (Instance >= mFvbCount) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if (!(mFvbEntry[Instance].FvbExtension)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  if (!(mFvbEntry[Instance].FvbExtension->EraseFvbCustomBlock)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  return mFvbEntry[Instance].FvbExtension->EraseFvbCustomBlock (
+                                            mFvbEntry[Instance].FvbExtension,
+                                            StartLba,
+                                            OffsetStartLba,
+                                            LastLba,
+                                            OffsetLastLba
+                                            );
+}

MdePkg/Library/FvbServiceLib/Fvb.h

@@ -0,0 +1,44 @@
+/** @file 
+  The internal header file includes the common header files, defines
+  internal structure FVB_ENTRY.
+
+Copyright (c) 2006 - 2008, Intel Corporation. <BR>
+
+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.
+
+**/
+
+#ifndef __FVB_H__
+#define __FVB_H__
+
+
+#include <PiDxe.h>
+
+#include <Protocol/FirmwareVolumeBlock.h>
+#include <Protocol/FvbExtension.h>
+
+#include <Library/FvbServiceLib.h>
+#include <Library/UefiLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/UefiRuntimeLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+
+#define MAX_FVB_COUNT 16
+
+typedef struct {
+  EFI_HANDLE                          Handle;
+  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *Fvb;
+  EFI_FVB_EXTENSION_PROTOCOL          *FvbExtension;
+  BOOLEAN                             IsRuntimeAccess;
+} FVB_ENTRY;
+
+#endif

MdePkg/Library/FvbServiceLib/FvbServiceLib.inf

@@ -0,0 +1,57 @@
+#/** @file
+# FvbService Library for UEFI drivers
+#
+# This library instance provide sevice functions to access Firmware Volume Block protocol.
+# Copyright (c) 2006 - 2007, 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.
+#
+#
+#**/
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = FvbServiceLib
+  FILE_GUID                      = bd4d540e-04b0-4b10-8fd5-4a7bb533cf67
+  MODULE_TYPE                    = DXE_RUNTIME_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = FvbServiceLib|DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION
+  EDK_RELEASE_VERSION            = 0x00020000
+  EFI_SPECIFICATION_VERSION      = 0x00020000
+
+  CONSTRUCTOR                    = FvbLibInitialize
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64
+#
+#  VIRTUAL_ADDRESS_MAP_CALLBACK  =  FvbVirtualAddressChangeNotifyEvent
+#
+
+[Sources]
+  Fvb.h
+  Fvb.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+  MdeModulePkg/MdeModulePkg.dec
+
+[LibraryClasses]
+  UefiBootServicesTableLib
+  UefiRuntimeLib
+  BaseMemoryLib
+  DebugLib
+  BaseLib
+  UefiLib
+
+[Protocols]
+  gEfiFirmwareVolumeBlockProtocolGuid           # PROTOCOL_NOTIFY SOMETIMES_CONSUMED
+  gEfiFvbExtensionProtocolGuid                  # PROTOCOL ALWAYS_CONSUMED
+  gEfiFirmwareVolumeBlockProtocolGuid           # PROTOCOL ALWAYS_CONSUMED
+

MdePkg/Library/GraphicsLib/Graphics.c

@@ -0,0 +1,917 @@
+/** @file
+  Library supports diplaying graphical splash screen,
+  locking of keyboard input and printing character on
+  screen. These basic graphics operations are based on UEFI HII, 
+  Graphics Output protocol or UGA Draw protocol.
+
+Copyright (c) 2006 - 2008, 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.
+
+**/
+
+
+#include <PiDxe.h>
+
+#include <Protocol/SimpleTextOut.h>
+#include <Protocol/OEMBadging.h>
+#include <Protocol/ConsoleControl.h>
+#include <Protocol/GraphicsOutput.h>
+#include <Protocol/UgaDraw.h>
+#include <Protocol/HiiFont.h>
+#include <Protocol/HiiImage.h>
+
+#include <Guid/Bmp.h>
+
+#include <Library/GraphicsLib.h>
+#include <Library/PrintLib.h>
+#include <Library/BaseLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/DxePiLib.h>
+#include <Library/PcdLib.h>
+
+STATIC EFI_GRAPHICS_OUTPUT_BLT_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 }
+};
+
+
+/**
+  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.
+
+  @param  FileNameGuid          File Name of graphics file in the FV(s).
+  @param  Image                 Pointer to pointer to return graphics image.  If NULL, a 
+                                buffer will be allocated.
+  @param  ImageSize             Size of the graphics Image in bytes. Zero if no image found.
+
+  @retval EFI_SUCCESS           Image and ImageSize are valid. 
+  @retval EFI_BUFFER_TOO_SMALL  Image not big enough. ImageSize has required size
+  @retval EFI_NOT_FOUND         FileNameGuid not found
+
+**/
+EFI_STATUS
+EFIAPI
+GetGraphicsBitMapFromFV (
+  IN  EFI_GUID      *FileNameGuid,
+  OUT VOID          **Image,
+  OUT UINTN         *ImageSize
+  )
+{
+  return GetGraphicsBitMapFromFVEx (NULL, FileNameGuid, Image, ImageSize);
+}
+
+/**
+  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.
+
+  @param  ImageHandle           The driver image handle of the caller. The parameter is used to
+                                optimize the loading of the image file so that the FV from which
+                                the driver image is loaded will be tried first. 
+  @param  FileNameGuid          File Name of graphics file in the FV(s).
+  @param  Image                 Pointer to pointer to return graphics image.  If NULL, a 
+                                buffer will be allocated.
+  @param  ImageSize             Size of the graphics Image in bytes. Zero if no image found.
+
+  @retval EFI_SUCCESS           Image and ImageSize are valid. 
+  @retval EFI_BUFFER_TOO_SMALL  Image not big enough. ImageSize has required size
+  @retval EFI_NOT_FOUND         FileNameGuid not found
+
+**/
+EFI_STATUS
+EFIAPI
+GetGraphicsBitMapFromFVEx (
+  IN  EFI_HANDLE    ImageHandle,
+  IN  EFI_GUID      *FileNameGuid,
+  OUT VOID          **Image,
+  OUT UINTN         *ImageSize
+  )
+{
+  return PiLibGetSectionFromAnyFv (
+           FileNameGuid,
+           EFI_SECTION_RAW,
+           0,
+           Image,
+           ImageSize
+           );
+}
+
+/**
+  Convert a *.BMP graphics image to a GOP blt buffer. If a NULL Blt buffer
+  is passed in a GopBlt buffer will be allocated by this routine. If a GopBlt
+  buffer is passed in it will be used if it is big enough.
+
+  @param  BmpImage      Pointer to BMP file
+  @param  BmpImageSize  Number of bytes in BmpImage
+  @param  GopBlt        Buffer containing GOP version of BmpImage.
+  @param  GopBltSize    Size of GopBlt in bytes.
+  @param  PixelHeight   Height of GopBlt/BmpImage in pixels
+  @param  PixelWidth    Width of GopBlt/BmpImage in pixels
+
+  @retval EFI_SUCCESS           GopBlt and GopBltSize are returned. 
+  @retval EFI_UNSUPPORTED       BmpImage is not a valid *.BMP image
+  @retval EFI_BUFFER_TOO_SMALL  The passed in GopBlt buffer is not big enough.
+                                GopBltSize will contain the required size.
+  @retval EFI_OUT_OF_RESOURCES  No enough buffer to allocate.
+
+**/
+EFI_STATUS
+EFIAPI
+ConvertBmpToGopBlt (
+  IN     VOID      *BmpImage,
+  IN     UINTN     BmpImageSize,
+  IN OUT VOID      **GopBlt,
+  IN OUT UINTN     *GopBltSize,
+     OUT UINTN     *PixelHeight,
+     OUT UINTN     *PixelWidth
+  )
+{
+  UINT8                         *Image;
+  UINT8                         *ImageHeader;
+  BMP_IMAGE_HEADER              *BmpHeader;
+  BMP_COLOR_MAP                 *BmpColorMap;
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer;
+  EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
+  UINTN                         BltBufferSize;
+  UINTN                         Index;
+  UINTN                         Height;
+  UINTN                         Width;
+  UINTN                         ImageIndex;
+  BOOLEAN                       IsAllocated;
+
+  BmpHeader = (BMP_IMAGE_HEADER *) BmpImage;
+
+  if (BmpHeader->CharB != 'B' || BmpHeader->CharM != 'M') {
+    return EFI_UNSUPPORTED;
+  }
+
+  //
+  // Doesn't support compress.
+  //
+  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;
+
+  //
+  // Calculate the BltBuffer needed size.
+  //
+  BltBufferSize = BmpHeader->PixelWidth * BmpHeader->PixelHeight * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
+  IsAllocated   = FALSE;
+  if (*GopBlt == NULL) {
+    //
+    // GopBlt is not allocated by caller.
+    //
+    *GopBltSize = BltBufferSize;
+    *GopBlt     = AllocatePool (*GopBltSize);
+    IsAllocated = TRUE;
+    if (*GopBlt == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+  } else {
+    //
+    // GopBlt has been allocated by caller.
+    //
+    if (*GopBltSize < BltBufferSize) {
+      *GopBltSize = BltBufferSize;
+      return EFI_BUFFER_TOO_SMALL;
+    }
+  }
+
+  *PixelWidth   = BmpHeader->PixelWidth;
+  *PixelHeight  = BmpHeader->PixelHeight;
+
+  //
+  // Convert image from BMP to Blt buffer format
+  //
+  BltBuffer = *GopBlt;
+  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 1-bit (2 colors) 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 4-bit (16 colors) 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 8-bit (256 colors) BMP Palette to 24-bit color
+        //
+        Blt->Red    = BmpColorMap[*Image].Red;
+        Blt->Green  = BmpColorMap[*Image].Green;
+        Blt->Blue   = BmpColorMap[*Image].Blue;
+        break;
+
+      case 24:
+        //
+        // It is 24-bit BMP.
+        //
+        Blt->Blue   = *Image++;
+        Blt->Green  = *Image++;
+        Blt->Red    = *Image;
+        break;
+
+      default:
+        //
+        // Other bit format BMP is not supported.
+        //
+        if (IsAllocated) {
+          FreePool (*GopBlt);
+          *GopBlt = NULL;
+        }
+        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;
+}
+
+
+/**
+  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.
+
+  @param  Password        Password used to lock ConIn device.
+
+  @retval EFI_SUCCESS     lock the Console In Spliter virtual handle successfully.
+  @retval EFI_UNSUPPORTED Password not found.
+
+**/
+EFI_STATUS
+EFIAPI
+LockKeyboards (
+  IN  CHAR16    *Password
+  )
+{
+  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;
+}
+
+
+/**
+  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.
+
+  @param  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
+  )
+{
+  return EnableQuietBootEx (LogoFile, NULL);
+}
+
+/**
+  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
+
+  @param  LogoFile    File name of logo to display on the center of the screen.
+  @param  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.
+
+  @retval EFI_SUCCESS     ConsoleControl has been flipped to graphics and logo displayed.
+  @retval EFI_UNSUPPORTED Logo not found.
+
+**/
+EFI_STATUS
+EFIAPI
+EnableQuietBootEx (
+  IN  EFI_GUID    *LogoFile,
+  IN  EFI_HANDLE  ImageHandle
+  )
+{
+  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) && 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;
+  }
+
+  Badging = NULL;
+  Status  = gBS->LocateProtocol (&gEfiOEMBadgingProtocolGuid, NULL, (VOID **) &Badging);
+
+  //
+  // Set console control to graphics mode.
+  //
+  Status = ConsoleControl->SetMode (ConsoleControl, EfiConsoleControlScreenGraphics);
+  if (EFI_ERROR (Status)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  if (GraphicsOutput != NULL) {
+    SizeOfX = GraphicsOutput->Mode->Info->HorizontalResolution;
+    SizeOfY = GraphicsOutput->Mode->Info->VerticalResolution;
+  } else if (FeaturePcdGet (PcdUgaConsumeSupport)) {
+    Status = UgaDraw->GetMode (UgaDraw, &SizeOfX, &SizeOfY, &ColorDepth, &RefreshRate);
+    if (EFI_ERROR (Status)) {
+      return EFI_UNSUPPORTED;
+    }
+  } else {
+    return EFI_UNSUPPORTED;
+  }
+
+  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)) {
+        return Status;
+      }
+
+      //
+      // Currently only support BMP format.
+      //
+      if (Format != EfiBadgingFormatBMP) {
+        SafeFreePool (ImageData);
+        continue;
+      }
+    } else {
+      //
+      // Get the specified image from FV.
+      //
+      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)) {
+      SafeFreePool (ImageData);
+      if (Badging == NULL) {
+        return Status;
+      } else {
+        continue;
+      }
+    }
+
+    //
+    // Caculate 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;
+
+    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 (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;
+      }
+    }
+
+    SafeFreePool (ImageData);
+    SafeFreePool (Blt);
+
+    if (Badging == NULL) {
+      break;
+    }
+  }
+
+  return Status;
+}
+
+/**
+  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
+
+  @retval EFI_SUCCESS          UGA devices are back in text mode and synced up.
+  @retval EFI_UNSUPPORTED      Logo not found
+
+**/
+EFI_STATUS
+EFIAPI
+DisableQuietBoot (
+  VOID
+  )
+{
+  EFI_STATUS                    Status;
+  EFI_CONSOLE_CONTROL_PROTOCOL  *ConsoleControl;
+
+  Status = gBS->LocateProtocol (&gEfiConsoleControlProtocolGuid, NULL, (VOID **) &ConsoleControl);
+  if (EFI_ERROR (Status)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  //
+  // Set console control to text mode.
+  //
+  return ConsoleControl->SetMode (ConsoleControl, EfiConsoleControlScreenText);
+}
+
+/**
+  Internal display string worker function.
+
+  @param GraphicsOutput   Graphics output protocol interface.
+  @param UgaDraw          UGA draw protocol interface.
+  @param Sto              Simple text out protocol interface.
+  @param X                X coordinate to start printing.
+  @param Y                Y coordinate to start printing.
+  @param Foreground       Foreground color.
+  @param Background       Background color.
+  @param fmt              Format string.
+  @param args             Print arguments.
+
+  @return  Number of Characters printed. Zero means no any character 
+           displayed successfully.
+
+**/
+UINTN
+Print (
+  IN EFI_GRAPHICS_OUTPUT_PROTOCOL     *GraphicsOutput,
+  IN EFI_UGA_DRAW_PROTOCOL            *UgaDraw,
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *Sto,
+  IN UINTN                            X,
+  IN UINTN                            Y,
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL    *Foreground,
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL    *Background,
+  IN CHAR16                           *fmt,
+  IN VA_LIST                          args
+  )
+{
+  VOID                           *Buffer;
+  EFI_STATUS                     Status;
+  UINTN                          Index;
+  CHAR16                         *UnicodeWeight;
+  UINT32                         HorizontalResolution;
+  UINT32                         VerticalResolution;
+  UINT32                         ColorDepth;
+  UINT32                         RefreshRate;
+  UINTN                          BufferLen;
+  UINTN                          LineBufferLen;
+  EFI_HII_FONT_PROTOCOL          *HiiFont;
+  EFI_IMAGE_OUTPUT               *Blt;
+  EFI_FONT_DISPLAY_INFO          *FontInfo;
+  EFI_HII_ROW_INFO               *RowInfoArray;
+  UINTN                          RowInfoArraySize;
+  UINTN                          PrintNum;     
+
+  //
+  // For now, allocate an arbitrarily long buffer
+  //
+  Buffer = AllocateZeroPool (0x10000);
+  if (Buffer == NULL) {
+    return 0;
+  }
+
+  HorizontalResolution  = 0;
+  VerticalResolution    = 0;
+  Blt                   = NULL;
+  FontInfo              = NULL;
+  PrintNum              = 0;
+
+  if (GraphicsOutput != NULL) {
+    HorizontalResolution = GraphicsOutput->Mode->Info->HorizontalResolution;
+    VerticalResolution = GraphicsOutput->Mode->Info->VerticalResolution;
+  } else if (FeaturePcdGet (PcdUgaConsumeSupport)) {
+    UgaDraw->GetMode (UgaDraw, &HorizontalResolution, &VerticalResolution, &ColorDepth, &RefreshRate);
+  } else {
+    Status = EFI_UNSUPPORTED;
+    goto Error;
+  }
+
+  ASSERT ((HorizontalResolution != 0) && (VerticalResolution !=0));
+
+  Status = gBS->LocateProtocol (&gEfiHiiFontProtocolGuid, NULL, (VOID **) &HiiFont);
+  if (EFI_ERROR (Status)) {
+    goto Error;
+  }
+
+  PrintNum = 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;
+    }
+  }
+
+  BufferLen = StrLen (Buffer);
+
+  LineBufferLen = sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) * HorizontalResolution * EFI_GLYPH_HEIGHT;
+  if (EFI_GLYPH_WIDTH * EFI_GLYPH_HEIGHT * sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL) * BufferLen > LineBufferLen) {
+     Status = EFI_INVALID_PARAMETER;
+     goto Error;
+  }
+
+  Blt = (EFI_IMAGE_OUTPUT *) AllocateZeroPool (sizeof (EFI_IMAGE_OUTPUT));
+  if (Blt == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto Error;
+  }
+
+  Blt->Width        = (UINT16) (HorizontalResolution);
+  Blt->Height       = (UINT16) (VerticalResolution);
+
+  FontInfo = (EFI_FONT_DISPLAY_INFO *) AllocateZeroPool (sizeof (EFI_FONT_DISPLAY_INFO));
+  if (FontInfo == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto Error;
+  }
+  if (Foreground != NULL) {
+    CopyMem (&FontInfo->ForegroundColor, Foreground, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
+  } else {
+    CopyMem (
+      &FontInfo->ForegroundColor,
+      &mEfiColors[Sto->Mode->Attribute & 0x0f],
+      sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
+      );
+  }
+  if (Background != NULL) {
+    CopyMem (&FontInfo->BackgroundColor, Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
+  } else {
+    CopyMem (
+      &FontInfo->BackgroundColor,
+      &mEfiColors[Sto->Mode->Attribute >> 4],
+      sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
+      );
+  }
+
+  if (GraphicsOutput != NULL) {
+    Blt->Image.Screen = GraphicsOutput;
+    
+    Status = HiiFont->StringToImage (
+                         HiiFont,
+                         EFI_HII_IGNORE_IF_NO_GLYPH | EFI_HII_DIRECT_TO_SCREEN,
+                         Buffer,
+                         FontInfo,
+                         &Blt,
+                         X,
+                         Y,
+                         NULL,
+                         NULL,
+                         NULL
+                         );
+
+  } else if (FeaturePcdGet (PcdUgaConsumeSupport)) {
+    ASSERT (UgaDraw!= NULL);
+
+    Blt->Image.Bitmap = AllocateZeroPool (Blt->Width * Blt->Height * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
+    if (Blt->Image.Bitmap == NULL) {
+      SafeFreePool (Blt);
+      SafeFreePool (Buffer);
+      return EFI_OUT_OF_RESOURCES;
+    }
+
+    RowInfoArray = NULL;
+    //
+    //  StringToImage only support blt'ing image to device using GOP protocol. If GOP is not supported in this platform,
+    //  we ask StringToImage to print the string to blt buffer, then blt to device using UgaDraw.
+    //
+    Status = HiiFont->StringToImage (
+                         HiiFont,
+                         EFI_HII_IGNORE_IF_NO_GLYPH,
+                         Buffer,
+                         FontInfo,
+                         &Blt,
+                         X,
+                         Y,
+                         &RowInfoArray,
+                         &RowInfoArraySize,
+                         NULL
+                         );
+
+    if (!EFI_ERROR (Status)) {
+      //
+      // Line breaks are handled by caller of DrawUnicodeWeightAtCursorN, so the updated parameter RowInfoArraySize by StringToImage will
+      // always be 1 or 0 (if there is no valid Unicode Char can be printed). ASSERT here to make sure.
+      //
+      ASSERT (RowInfoArraySize <= 1);
+
+      Status = UgaDraw->Blt (
+                          UgaDraw,
+                          (EFI_UGA_PIXEL *) Blt->Image.Bitmap,
+                          EfiUgaBltBufferToVideo,
+                          X,
+                          Y,
+                          X,
+                          Y,
+                          RowInfoArray[0].LineWidth,
+                          RowInfoArray[0].LineHeight,
+                          Blt->Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
+                          );
+    }
+
+    SafeFreePool (RowInfoArray);
+    SafeFreePool (Blt->Image.Bitmap);
+  } else {
+    Status = EFI_UNSUPPORTED;
+  }
+
+Error:
+  SafeFreePool (Blt);
+  SafeFreePool (FontInfo);
+  FreePool (Buffer);
+
+  if (EFI_ERROR (Status)) {
+    return PrintNum;
+  } else {
+    return 0;
+  }
+}
+
+/**
+  Print Unicode string to graphics screen at the given X,Y coordinates of the graphics screen.
+  see definition of Print to find rules for constructing Fmt.
+
+  @param  X            Row to start printing at.
+  @param  Y            Column to start printing at.
+  @param  ForeGround   Foreground color.
+  @param  BackGround   background color.
+  @param  Fmt          Print format sting. See definition of Print.
+  @param  ...          Argumnet stream defined by Fmt string.
+
+  @return  Number of Characters printed. Zero means no any character 
+           displayed successfully.
+
+**/
+UINTN
+EFIAPI
+PrintXY (
+  IN UINTN                            X,
+  IN UINTN                            Y,
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL    *ForeGround, OPTIONAL
+  IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL    *BackGround, OPTIONAL
+  IN CHAR16                           *Fmt,
+  ...
+  )
+{
+  EFI_HANDLE                       Handle;
+  EFI_GRAPHICS_OUTPUT_PROTOCOL     *GraphicsOutput;
+  EFI_UGA_DRAW_PROTOCOL            *UgaDraw;
+  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *Sto;
+  EFI_STATUS                       Status;
+  VA_LIST                          Args;
+
+  VA_START (Args, Fmt);
+
+  Handle = gST->ConsoleOutHandle;
+
+  Status = gBS->HandleProtocol (
+                  Handle,
+                  &gEfiGraphicsOutputProtocolGuid,
+                  (VOID **) &GraphicsOutput
+                  );
+
+  UgaDraw = NULL;
+  if (EFI_ERROR (Status) && FeaturePcdGet (PcdUgaConsumeSupport)) {
+    //
+    // If no GOP available, try to open UGA Draw protocol if supported.
+    //
+    GraphicsOutput = NULL;
+
+    Status = gBS->HandleProtocol (
+                    Handle,
+                    &gEfiUgaDrawProtocolGuid,
+                    (VOID **) &UgaDraw
+                    );
+  }
+  if (EFI_ERROR (Status)) {
+    return 0;
+  }
+
+  Status = gBS->HandleProtocol (
+                  Handle,
+                  &gEfiSimpleTextOutProtocolGuid,
+                  (VOID **) &Sto
+                  );
+
+  if (EFI_ERROR (Status)) {
+    return 0;
+  }
+
+  return Print (GraphicsOutput, UgaDraw, Sto, X, Y, ForeGround, BackGround, Fmt, Args);
+}
+

MdePkg/Library/GraphicsLib/GraphicsLib.inf

@@ -0,0 +1,63 @@
+#/** @file
+#   Library supports diplaying graphical splash screen,
+#   locking of keyboard input and printing character on
+#   screen.
+#
+# This library provides supports for basic graphic functions.
+# Copyright (c) 2006 - 2007, 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.
+#
+#
+#**/
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UefiGraphicsLib
+  FILE_GUID                      = 08c1a0e4-1208-47f8-a2c5-f42eabee653a
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  LIBRARY_CLASS                  = GraphicsLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER
+  EDK_RELEASE_VERSION            = 0x00020000
+  EFI_SPECIFICATION_VERSION      = 0x00020000
+
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources.common]
+  Graphics.c
+
+[Packages]
+  MdePkg/MdePkg.dec
+  MdeModulePkg/MdeModulePkg.dec
+
+[LibraryClasses]
+  UefiBootServicesTableLib
+  MemoryAllocationLib
+  BaseLib
+  PrintLib
+  DebugLib
+  DxePiLib
+  BaseMemoryLib
+  PcdLib
+
+[Protocols]
+  gEfiSimpleTextOutProtocolGuid                 # PROTOCOL ALWAYS_CONSUMED
+  gEfiGraphicsOutputProtocolGuid                # PROTOCOL ALWAYS_CONSUMED
+  gEfiUgaDrawProtocolGuid                       # PROTOCOL ALWAYS_CONSUMED
+  gEfiConsoleControlProtocolGuid                # PROTOCOL ALWAYS_CONSUMED
+  gEfiFirmwareVolume2ProtocolGuid               # PROTOCOL ALWAYS_CONSUMED
+  gEfiOEMBadgingProtocolGuid                    # PROTOCOL ALWAYS_CONSUMED
+  gEfiHiiFontProtocolGuid                       # PROTOCOL ALWAYS_CONSUMED
+
+[FeaturePcd.common]
+  gEfiMdeModulePkgTokenSpaceGuid.PcdUgaConsumeSupport

MdePkg/Library/PeiPalLib/PeiPalLib.inf

@@ -2,7 +2,7 @@
 # Component description file for Pei PAL call Library
 #
 # PAL Call Library implementation to wrap the PAL call in PEI.
-# Copyright (c) 2006, Intel Corporation
+# Copyright (c) 2006 - 2008, Intel Corporation
 #
 #  All rights reserved.
 #  This software and associated documentation (if any) is furnished
@@ -18,7 +18,7 @@
 
 [Defines]
   INF_VERSION                    = 0x00010005
-  BASE_NAME                      = PeiPalCallLib
+  BASE_NAME                      = PeiPalLib
   FILE_GUID                      = B53DC524-6B98-4584-940B-8F1363DEF09E
   MODULE_TYPE                    = PEIM
   VERSION_STRING                 = 1.0
@@ -34,7 +34,7 @@
 #
 
 [Sources.common]
-  PalCallLib.c
+  PeiPalLib.c
 
 
 [Packages]

MdePkg/Library/UefiHiiLib/UefiHiiLib.inf

@@ -16,7 +16,7 @@
 
 [Defines]
   INF_VERSION                    = 0x00010005
-  BASE_NAME                      = HiiLib
+  BASE_NAME                      = UefiHiiLib
   FILE_GUID                      = 3143687A-7C80-404e-B5FE-2D88980E1B1C
   MODULE_TYPE                    = UEFI_DRIVER
   VERSION_STRING                 = 1.0

MdePkg/Library/UefiIfrSupportLib/UefiIfrSupportLib.inf

@@ -17,7 +17,7 @@
 
 [Defines]
   INF_VERSION                    = 0x00010005
-  BASE_NAME                      = IfrSupportLib
+  BASE_NAME                      = UefiIfrSupportLib
   FILE_GUID                      = bf38668e-e231-4baa-99e4-8c0e4c35dca6
   MODULE_TYPE                    = UEFI_DRIVER
   VERSION_STRING                 = 1.0

MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf

@@ -17,7 +17,7 @@
 
 [Defines]
   INF_VERSION                    = 0x00010005
-  BASE_NAME                      = DxeMemoryAllocationLib
+  BASE_NAME                      = UefiMemoryAllocationLib
   FILE_GUID                      = 4674739d-3195-4fb2-8094-ac1d22d00194
   MODULE_TYPE                    = UEFI_DRIVER
   VERSION_STRING                 = 1.0

MdePkg/Library/UefiMemoryLib/UefiMemoryLib.inf

@@ -17,7 +17,7 @@
 
 [Defines]
   INF_VERSION                    = 0x00010005
-  BASE_NAME                      = DxeMemoryLib
+  BASE_NAME                      = UefiMemoryLib
   FILE_GUID                      = f1bbe03d-2f28-4dee-bec7-d98d7a30c36a
   MODULE_TYPE                    = UEFI_DRIVER
   VERSION_STRING                 = 1.0