diff --git a/MdePkg/Library/CpuLib/CpuLib.inf b/MdePkg/Library/BaseCpuLib/BaseCpuLib.inf similarity index 93% rename from MdePkg/Library/CpuLib/CpuLib.inf rename to MdePkg/Library/BaseCpuLib/BaseCpuLib.inf index 952983e7dc..a58b198723 100644 --- a/MdePkg/Library/CpuLib/CpuLib.inf +++ b/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 diff --git a/MdePkg/Library/CpuLib/Ebc/CpuSleepFlushTlb.c b/MdePkg/Library/BaseCpuLib/Ebc/CpuSleepFlushTlb.c similarity index 100% rename from MdePkg/Library/CpuLib/Ebc/CpuSleepFlushTlb.c rename to MdePkg/Library/BaseCpuLib/Ebc/CpuSleepFlushTlb.c diff --git a/MdePkg/Library/CpuLib/Ia32/CpuFlushTlb.S b/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.S similarity index 100% rename from MdePkg/Library/CpuLib/Ia32/CpuFlushTlb.S rename to MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.S diff --git a/MdePkg/Library/CpuLib/Ia32/CpuFlushTlb.asm b/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.asm similarity index 100% rename from MdePkg/Library/CpuLib/Ia32/CpuFlushTlb.asm rename to MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.asm diff --git a/MdePkg/Library/CpuLib/Ia32/CpuFlushTlb.c b/MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.c similarity index 100% rename from MdePkg/Library/CpuLib/Ia32/CpuFlushTlb.c rename to MdePkg/Library/BaseCpuLib/Ia32/CpuFlushTlb.c diff --git a/MdePkg/Library/CpuLib/Ia32/CpuSleep.S b/MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.S similarity index 100% rename from MdePkg/Library/CpuLib/Ia32/CpuSleep.S rename to MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.S diff --git a/MdePkg/Library/CpuLib/Ia32/CpuSleep.asm b/MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.asm similarity index 100% rename from MdePkg/Library/CpuLib/Ia32/CpuSleep.asm rename to MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.asm diff --git a/MdePkg/Library/CpuLib/Ia32/CpuSleep.c b/MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.c similarity index 100% rename from MdePkg/Library/CpuLib/Ia32/CpuSleep.c rename to MdePkg/Library/BaseCpuLib/Ia32/CpuSleep.c diff --git a/MdePkg/Library/CpuLib/Ipf/CpuFlushTlb.s b/MdePkg/Library/BaseCpuLib/Ipf/CpuFlushTlb.s similarity index 100% rename from MdePkg/Library/CpuLib/Ipf/CpuFlushTlb.s rename to MdePkg/Library/BaseCpuLib/Ipf/CpuFlushTlb.s diff --git a/MdePkg/Library/CpuLib/Ipf/CpuSleep.c b/MdePkg/Library/BaseCpuLib/Ipf/CpuSleep.c similarity index 100% rename from MdePkg/Library/CpuLib/Ipf/CpuSleep.c rename to MdePkg/Library/BaseCpuLib/Ipf/CpuSleep.c diff --git a/MdePkg/Library/CpuLib/X64/CpuFlushTlb.S b/MdePkg/Library/BaseCpuLib/X64/CpuFlushTlb.S similarity index 100% rename from MdePkg/Library/CpuLib/X64/CpuFlushTlb.S rename to MdePkg/Library/BaseCpuLib/X64/CpuFlushTlb.S diff --git a/MdePkg/Library/CpuLib/X64/CpuFlushTlb.asm b/MdePkg/Library/BaseCpuLib/X64/CpuFlushTlb.asm similarity index 100% rename from MdePkg/Library/CpuLib/X64/CpuFlushTlb.asm rename to MdePkg/Library/BaseCpuLib/X64/CpuFlushTlb.asm diff --git a/MdePkg/Library/CpuLib/X64/CpuSleep.S b/MdePkg/Library/BaseCpuLib/X64/CpuSleep.S similarity index 100% rename from MdePkg/Library/CpuLib/X64/CpuSleep.S rename to MdePkg/Library/BaseCpuLib/X64/CpuSleep.S diff --git a/MdePkg/Library/CpuLib/X64/CpuSleep.asm b/MdePkg/Library/BaseCpuLib/X64/CpuSleep.asm similarity index 100% rename from MdePkg/Library/CpuLib/X64/CpuSleep.asm rename to MdePkg/Library/BaseCpuLib/X64/CpuSleep.asm diff --git a/MdePkg/Library/SerialPortLibNull/SerialPortLibNull.c b/MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.c similarity index 100% rename from MdePkg/Library/SerialPortLibNull/SerialPortLibNull.c rename to MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.c diff --git a/MdePkg/Library/SerialPortLibNull/SerialPortLibNull.inf b/MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.inf similarity index 89% rename from MdePkg/Library/SerialPortLibNull/SerialPortLibNull.inf rename to MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.inf index a6d436c8df..b1e33c56d3 100644 --- a/MdePkg/Library/SerialPortLibNull/SerialPortLibNull.inf +++ b/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] diff --git a/MdePkg/Library/DxePalLib/DxePalCallLib.c b/MdePkg/Library/DxePalLib/DxePalCallLib.c new file mode 100644 index 0000000000..61a2146ee1 --- /dev/null +++ b/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 +#include +#include + +#include +#include + +#include +#include +#include +#include +#include + + +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); +} diff --git a/MdePkg/Library/DxePalLib/DxePalLib.inf b/MdePkg/Library/DxePalLib/DxePalLib.inf new file mode 100644 index 0000000000..cd9431245b --- /dev/null +++ b/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 diff --git a/MdePkg/Library/FvbServiceLib/Fvb.c b/MdePkg/Library/FvbServiceLib/Fvb.c new file mode 100644 index 0000000000..d1aa6041dd --- /dev/null +++ b/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 + ); +} diff --git a/MdePkg/Library/FvbServiceLib/Fvb.h b/MdePkg/Library/FvbServiceLib/Fvb.h new file mode 100644 index 0000000000..5d54fd18c9 --- /dev/null +++ b/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.
+ +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 + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#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 diff --git a/MdePkg/Library/FvbServiceLib/FvbServiceLib.inf b/MdePkg/Library/FvbServiceLib/FvbServiceLib.inf new file mode 100644 index 0000000000..54bddcb0e6 --- /dev/null +++ b/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 + diff --git a/MdePkg/Library/GraphicsLib/Graphics.c b/MdePkg/Library/GraphicsLib/Graphics.c new file mode 100644 index 0000000000..75aa91dc6c --- /dev/null +++ b/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 + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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); +} + diff --git a/MdePkg/Library/GraphicsLib/GraphicsLib.inf b/MdePkg/Library/GraphicsLib/GraphicsLib.inf new file mode 100644 index 0000000000..34d568daca --- /dev/null +++ b/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 diff --git a/MdePkg/Library/PeiPalCallLib/PalCallLib.c b/MdePkg/Library/PeiPalLib/PeiPalLib.c similarity index 100% rename from MdePkg/Library/PeiPalCallLib/PalCallLib.c rename to MdePkg/Library/PeiPalLib/PeiPalLib.c diff --git a/MdePkg/Library/PeiPalCallLib/PeiPalCallLib.inf b/MdePkg/Library/PeiPalLib/PeiPalLib.inf similarity index 88% rename from MdePkg/Library/PeiPalCallLib/PeiPalCallLib.inf rename to MdePkg/Library/PeiPalLib/PeiPalLib.inf index b3632564dd..08f164cbd4 100644 --- a/MdePkg/Library/PeiPalCallLib/PeiPalCallLib.inf +++ b/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] diff --git a/MdePkg/Library/HiiLib/HiiLanguage.c b/MdePkg/Library/UefiHiiLib/HiiLanguage.c similarity index 100% rename from MdePkg/Library/HiiLib/HiiLanguage.c rename to MdePkg/Library/UefiHiiLib/HiiLanguage.c diff --git a/MdePkg/Library/HiiLib/HiiLib.c b/MdePkg/Library/UefiHiiLib/HiiLib.c similarity index 100% rename from MdePkg/Library/HiiLib/HiiLib.c rename to MdePkg/Library/UefiHiiLib/HiiLib.c diff --git a/MdePkg/Library/HiiLib/HiiString.c b/MdePkg/Library/UefiHiiLib/HiiString.c similarity index 100% rename from MdePkg/Library/HiiLib/HiiString.c rename to MdePkg/Library/UefiHiiLib/HiiString.c diff --git a/MdePkg/Library/HiiLib/InternalHiiLib.h b/MdePkg/Library/UefiHiiLib/InternalHiiLib.h similarity index 100% rename from MdePkg/Library/HiiLib/InternalHiiLib.h rename to MdePkg/Library/UefiHiiLib/InternalHiiLib.h diff --git a/MdePkg/Library/HiiLib/HiiLib.inf b/MdePkg/Library/UefiHiiLib/UefiHiiLib.inf similarity index 93% rename from MdePkg/Library/HiiLib/HiiLib.inf rename to MdePkg/Library/UefiHiiLib/UefiHiiLib.inf index 422d67d1b3..b8f998bd50 100644 --- a/MdePkg/Library/HiiLib/HiiLib.inf +++ b/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 diff --git a/MdePkg/Library/IfrSupportLib/UefiIfrForm.c b/MdePkg/Library/UefiIfrSupportLib/UefiIfrForm.c similarity index 100% rename from MdePkg/Library/IfrSupportLib/UefiIfrForm.c rename to MdePkg/Library/UefiIfrSupportLib/UefiIfrForm.c diff --git a/MdePkg/Library/IfrSupportLib/UefiIfrLibraryInternal.h b/MdePkg/Library/UefiIfrSupportLib/UefiIfrLibraryInternal.h similarity index 100% rename from MdePkg/Library/IfrSupportLib/UefiIfrLibraryInternal.h rename to MdePkg/Library/UefiIfrSupportLib/UefiIfrLibraryInternal.h diff --git a/MdePkg/Library/IfrSupportLib/UefiIfrOpCodeCreation.c b/MdePkg/Library/UefiIfrSupportLib/UefiIfrOpCodeCreation.c similarity index 100% rename from MdePkg/Library/IfrSupportLib/UefiIfrOpCodeCreation.c rename to MdePkg/Library/UefiIfrSupportLib/UefiIfrOpCodeCreation.c diff --git a/MdePkg/Library/IfrSupportLib/IfrSupportLib.inf b/MdePkg/Library/UefiIfrSupportLib/UefiIfrSupportLib.inf similarity index 93% rename from MdePkg/Library/IfrSupportLib/IfrSupportLib.inf rename to MdePkg/Library/UefiIfrSupportLib/UefiIfrSupportLib.inf index 8bf96caff9..50b1ffedbf 100644 --- a/MdePkg/Library/IfrSupportLib/IfrSupportLib.inf +++ b/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 diff --git a/MdePkg/Library/DxeMemoryAllocationLib/MemoryAllocationLib.c b/MdePkg/Library/UefiMemoryAllocationLib/MemoryAllocationLib.c similarity index 100% rename from MdePkg/Library/DxeMemoryAllocationLib/MemoryAllocationLib.c rename to MdePkg/Library/UefiMemoryAllocationLib/MemoryAllocationLib.c diff --git a/MdePkg/Library/DxeMemoryAllocationLib/DxeMemoryAllocationLib.inf b/MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf similarity index 92% rename from MdePkg/Library/DxeMemoryAllocationLib/DxeMemoryAllocationLib.inf rename to MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf index 8ab92503c6..4b51c808d4 100644 --- a/MdePkg/Library/DxeMemoryAllocationLib/DxeMemoryAllocationLib.inf +++ b/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 diff --git a/MdePkg/Library/DxeMemoryLib/CompareMemWrapper.c b/MdePkg/Library/UefiMemoryLib/CompareMemWrapper.c similarity index 100% rename from MdePkg/Library/DxeMemoryLib/CompareMemWrapper.c rename to MdePkg/Library/UefiMemoryLib/CompareMemWrapper.c diff --git a/MdePkg/Library/DxeMemoryLib/CopyMemWrapper.c b/MdePkg/Library/UefiMemoryLib/CopyMemWrapper.c similarity index 100% rename from MdePkg/Library/DxeMemoryLib/CopyMemWrapper.c rename to MdePkg/Library/UefiMemoryLib/CopyMemWrapper.c diff --git a/MdePkg/Library/DxeMemoryLib/MemLib.c b/MdePkg/Library/UefiMemoryLib/MemLib.c similarity index 100% rename from MdePkg/Library/DxeMemoryLib/MemLib.c rename to MdePkg/Library/UefiMemoryLib/MemLib.c diff --git a/MdePkg/Library/DxeMemoryLib/MemLibGeneric.c b/MdePkg/Library/UefiMemoryLib/MemLibGeneric.c similarity index 100% rename from MdePkg/Library/DxeMemoryLib/MemLibGeneric.c rename to MdePkg/Library/UefiMemoryLib/MemLibGeneric.c diff --git a/MdePkg/Library/DxeMemoryLib/MemLibGuid.c b/MdePkg/Library/UefiMemoryLib/MemLibGuid.c similarity index 100% rename from MdePkg/Library/DxeMemoryLib/MemLibGuid.c rename to MdePkg/Library/UefiMemoryLib/MemLibGuid.c diff --git a/MdePkg/Library/DxeMemoryLib/MemLibInternals.h b/MdePkg/Library/UefiMemoryLib/MemLibInternals.h similarity index 100% rename from MdePkg/Library/DxeMemoryLib/MemLibInternals.h rename to MdePkg/Library/UefiMemoryLib/MemLibInternals.h diff --git a/MdePkg/Library/DxeMemoryLib/ScanMem16Wrapper.c b/MdePkg/Library/UefiMemoryLib/ScanMem16Wrapper.c similarity index 100% rename from MdePkg/Library/DxeMemoryLib/ScanMem16Wrapper.c rename to MdePkg/Library/UefiMemoryLib/ScanMem16Wrapper.c diff --git a/MdePkg/Library/DxeMemoryLib/ScanMem32Wrapper.c b/MdePkg/Library/UefiMemoryLib/ScanMem32Wrapper.c similarity index 100% rename from MdePkg/Library/DxeMemoryLib/ScanMem32Wrapper.c rename to MdePkg/Library/UefiMemoryLib/ScanMem32Wrapper.c diff --git a/MdePkg/Library/DxeMemoryLib/ScanMem64Wrapper.c b/MdePkg/Library/UefiMemoryLib/ScanMem64Wrapper.c similarity index 100% rename from MdePkg/Library/DxeMemoryLib/ScanMem64Wrapper.c rename to MdePkg/Library/UefiMemoryLib/ScanMem64Wrapper.c diff --git a/MdePkg/Library/DxeMemoryLib/ScanMem8Wrapper.c b/MdePkg/Library/UefiMemoryLib/ScanMem8Wrapper.c similarity index 100% rename from MdePkg/Library/DxeMemoryLib/ScanMem8Wrapper.c rename to MdePkg/Library/UefiMemoryLib/ScanMem8Wrapper.c diff --git a/MdePkg/Library/DxeMemoryLib/SetMem16Wrapper.c b/MdePkg/Library/UefiMemoryLib/SetMem16Wrapper.c similarity index 100% rename from MdePkg/Library/DxeMemoryLib/SetMem16Wrapper.c rename to MdePkg/Library/UefiMemoryLib/SetMem16Wrapper.c diff --git a/MdePkg/Library/DxeMemoryLib/SetMem32Wrapper.c b/MdePkg/Library/UefiMemoryLib/SetMem32Wrapper.c similarity index 100% rename from MdePkg/Library/DxeMemoryLib/SetMem32Wrapper.c rename to MdePkg/Library/UefiMemoryLib/SetMem32Wrapper.c diff --git a/MdePkg/Library/DxeMemoryLib/SetMem64Wrapper.c b/MdePkg/Library/UefiMemoryLib/SetMem64Wrapper.c similarity index 100% rename from MdePkg/Library/DxeMemoryLib/SetMem64Wrapper.c rename to MdePkg/Library/UefiMemoryLib/SetMem64Wrapper.c diff --git a/MdePkg/Library/DxeMemoryLib/SetMemWrapper.c b/MdePkg/Library/UefiMemoryLib/SetMemWrapper.c similarity index 100% rename from MdePkg/Library/DxeMemoryLib/SetMemWrapper.c rename to MdePkg/Library/UefiMemoryLib/SetMemWrapper.c diff --git a/MdePkg/Library/DxeMemoryLib/DxeMemoryLib.inf b/MdePkg/Library/UefiMemoryLib/UefiMemoryLib.inf similarity index 93% rename from MdePkg/Library/DxeMemoryLib/DxeMemoryLib.inf rename to MdePkg/Library/UefiMemoryLib/UefiMemoryLib.inf index 91132be6bc..648a69dd17 100644 --- a/MdePkg/Library/DxeMemoryLib/DxeMemoryLib.inf +++ b/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 diff --git a/MdePkg/Library/DxeMemoryLib/ZeroMemWrapper.c b/MdePkg/Library/UefiMemoryLib/ZeroMemWrapper.c similarity index 100% rename from MdePkg/Library/DxeMemoryLib/ZeroMemWrapper.c rename to MdePkg/Library/UefiMemoryLib/ZeroMemWrapper.c