sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1) Cleanup HiiLib, IfrSupportLib.

Browse Source 
2) Add ExtendedHiiLib and ExtendedIfrSupportLib which implement APIs that require the OPcode and Device Path which is specific to Intel's implementation.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@4662 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
qwang12
2008-02-02 13:15:44 +00:00
parent e52c5a9fdc
commit 9226efe5eb
42 changed files with 1171 additions and 2910 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
MdeModulePkg/Core/Dxe/DxeMain.inf
View File

@ -142,3 +142,6 @@
gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueDxeDriverBegin | 0x3040002 # EFI_SOFTWARE_DXE_CORE | EFI_SW_PC_INIT_BEGIN gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueDxeDriverBegin | 0x3040002 # EFI_SOFTWARE_DXE_CORE | EFI_SW_PC_INIT_BEGIN
gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueDxeDriverEnd | 0x3040003 # EFI_SOFTWARE_DXE_CORE | EFI_SW_PC_INIT_END gEfiMdePkgTokenSpaceGuid.PcdStatusCodeValueDxeDriverEnd | 0x3040003 # EFI_SOFTWARE_DXE_CORE | EFI_SW_PC_INIT_END
[BuildOptions]
MSFT:*_*_*_CC_FLAGS = /FAcs

57
MdeModulePkg/Include/Library/ExtendedHiiLib.h Normal file
View File

@ -0,0 +1,57 @@
/** @file
This library includes the APIs that is specific to EDK II's implementation.
It extended the UEFI Specification to define GUIDed device path.
Copyright (c) 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 __EXTENDED_HII_LIB_H__
#define __EXTENDED_HII_LIB_H__
/**
The HII driver handle passed in for HiiDatabase.NewPackageList() requires
that there should be DevicePath Protocol installed on it.
This routine create a virtual Driver Handle by installing a vendor device
path on it, so as to use it to invoke HiiDatabase.NewPackageList().
The Device Path created is a Vendor Device Path specific to Intel's implemenation.
@param DriverHandle Handle to be returned
@retval EFI_SUCCESS Handle destroy success.
@retval EFI_OUT_OF_RESOURCES Not enough memory.
**/
EFI_STATUS
EFIAPI
HiiLibCreateHiiDriverHandle (
OUT EFI_HANDLE *DriverHandle
)
;
/**
Destroy the Driver Handle created by CreateHiiDriverHandle().
If no Device Path protocol is installed on the DriverHandle, then ASSERT.
If this Device Path protocol is failed to be uninstalled, then ASSERT.
@param DriverHandle Handle returned by CreateHiiDriverHandle()
**/
VOID
EFIAPI
HiiLibDestroyHiiDriverHandle (
IN EFI_HANDLE DriverHandle
)
;
#endif

127
MdeModulePkg/Include/Library/ExtendedIfrSupportLib.h Normal file
View File

@ -0,0 +1,127 @@
/** @file
Library header file defines APIs that is related to IFR operations but
specific to EDK II implementation.
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.
**/
#ifndef __EXTENDED_IFR_SUPPORT_LIB_H__
#define __EXTENDED_IFR_SUPPORT_LIB_H__
/**
Create GUIDed opcode for banner. Banner opcode
EFI_IFR_EXTEND_OP_BANNER is extended opcode specific
to Intel's implementation.
@param Title String ID for title
@param LineNumber Line number for this banner
@param Alignment Alignment for this banner, left, center or right
@param Data Destination for the created opcode binary
@retval EFI_SUCCESS Opcode create success
@retval EFI_BUFFER_TOO_SMALL The space reserved in Data field is too small.
**/
EFI_STATUS
CreateBannerOpCode (
IN EFI_STRING_ID Title,
IN UINT16 LineNumber,
IN UINT8 Alignment,
IN OUT EFI_HII_UPDATE_DATA *Data
)
;
/**
This function allows the caller to update a form that has
previously been registered with the EFI HII database.
The update make use of a extended opcode EFI_IFR_EXTEND_OP_LABEL
specific to Intel's implementation to complete the operation.
@param Handle Hii Handle
@param FormSetGuid The formset should be updated.
@param FormId The form should be updated.
@param Label Update information starting immediately after this
label in the IFR
@param Insert If TRUE and Data is not NULL, insert data after
Label. If FALSE, replace opcodes between two
labels with Data.
@param Data The adding data; If NULL, remove opcodes between
two Label.
@retval EFI_SUCCESS Update success.
@retval Other Update fail.
**/
EFI_STATUS
IfrLibUpdateForm (
IN EFI_HII_HANDLE Handle,
IN EFI_GUID *FormSetGuid, OPTIONAL
IN EFI_FORM_ID FormId,
IN UINT16 Label,
IN BOOLEAN Insert,
IN EFI_HII_UPDATE_DATA *Data
)
;
/**
Extract formset class for given HII handle.
If Handle is not a valid EFI_HII_HANDLE in the default HII database, then
ASSERT.
If Class is NULL, then ASSERT.
IfFormSetTitle is NULL, then ASSERT.
If FormSetHelp is NULL, then ASSERT.
@param HiiHandle Hii handle
@param Class On output, Class of the formset
@param FormSetTitle On output, Formset title string
@param FormSetHelp On output, Formset help string
@retval EFI_SUCCESS Successfully extract Class for specified Hii
handle.
**/
EFI_STATUS
IfrLibExtractClassFromHiiHandle (
IN EFI_HII_HANDLE Handle,
OUT UINT16 *Class,
OUT EFI_STRING_ID *FormSetTitle,
OUT EFI_STRING_ID *FormSetHelp
)
;
/**
Configure the buffer accrording to ConfigBody strings in the format of
<Length:4 bytes>, <Offset: 2 bytes>, <Width:2 bytes>, <Data:n bytes>.
@param Buffer the start address of buffer.
@param BufferSize the size of buffer.
@param Number the number of the strings.
@retval EFI_BUFFER_TOO_SMALL the BufferSize is too small to operate.
@retval EFI_INVALID_PARAMETER Buffer is NULL or BufferSize is 0.
@retval EFI_SUCCESS Operation successful.
**/
EFI_STATUS
EFIAPI
IfrLibExtractDefault(
IN VOID *Buffer,
IN UINTN *BufferSize,
UINTN Number,
...
)
;
#endif

6
MdeModulePkg/Include/MdeModuleHii.h
View File

@ -44,12 +44,6 @@ typedef struct {
} HII_VENDOR_DEVICE_PATH; } HII_VENDOR_DEVICE_PATH;
//
// References to string tokens must use this macro to enable scanning for
// token usages.
//
#define STRING_TOKEN(t) t
// //
// GUIDed opcodes defined for Tiano // GUIDed opcodes defined for Tiano
// //

116
MdeModulePkg/Library/ExtendedHiiLib/ExtendedHiiLib.c Normal file
View File

@ -0,0 +1,116 @@
/** @file
HII Library implementation that uses DXE protocols and services.
Copyright (c) 2006, 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.
**/
#include <PiDxe.h>
#include <Protocol/DevicePath.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <MdeModuleHii.h>
//
// Hii vendor device path template
//
HII_VENDOR_DEVICE_PATH mHiiVendorDevicePathTemplate = {
{
{
{
HARDWARE_DEVICE_PATH,
HW_VENDOR_DP,
{
(UINT8) (sizeof (HII_VENDOR_DEVICE_PATH_NODE)),
(UINT8) ((sizeof (HII_VENDOR_DEVICE_PATH_NODE)) >> 8)
}
},
EFI_IFR_TIANO_GUID
},
0
},
{
END_DEVICE_PATH_TYPE,
END_ENTIRE_DEVICE_PATH_SUBTYPE,
{
END_DEVICE_PATH_LENGTH
}
}
};
EFI_STATUS
EFIAPI
HiiLibCreateHiiDriverHandle (
OUT EFI_HANDLE *DriverHandle
)
{
EFI_STATUS Status;
HII_VENDOR_DEVICE_PATH_NODE *VendorDevicePath;
UINT64 MonotonicCount;
VendorDevicePath = AllocateCopyPool (sizeof (HII_VENDOR_DEVICE_PATH), &mHiiVendorDevicePathTemplate);
if (VendorDevicePath == NULL) {
return EFI_OUT_OF_RESOURCES;
}
gBS->GetNextMonotonicCount (&MonotonicCount);
VendorDevicePath->MonotonicCount = (UINT32) MonotonicCount;
*DriverHandle = NULL;
Status = gBS->InstallProtocolInterface (
DriverHandle,
&gEfiDevicePathProtocolGuid,
EFI_NATIVE_INTERFACE,
VendorDevicePath
);
if (EFI_ERROR (Status)) {
return Status;
}
return EFI_SUCCESS;
}
VOID
EFIAPI
HiiLibDestroyHiiDriverHandle (
IN EFI_HANDLE DriverHandle
)
{
EFI_STATUS Status;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
Status = gBS->HandleProtocol (
DriverHandle,
&gEfiDevicePathProtocolGuid,
(VOID **) &DevicePath
);
ASSERT_EFI_ERROR (Status);
Status = gBS->UninstallProtocolInterface (
DriverHandle,
&gEfiDevicePathProtocolGuid,
DevicePath
);
ASSERT_EFI_ERROR (Status);
FreePool (DevicePath);
}

47
MdeModulePkg/Library/ExtendedHiiLib/ExtendedHiiLib.inf Normal file
View File

@ -0,0 +1,47 @@
#/** @file
# Library instance for HII common routines.
#
# This library instance implements the common HII routines.
# Copyright (c) 2006, Intel Corporation
#
# All rights reserved. This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License
# which accompanies this distribution. The full text of the license may be found at
# http://opensource.org/licenses/bsd-license.php
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
#
#
#**/
[Defines]
INF_VERSION = 0x00010005
BASE_NAME = ExtendedHiiLib
FILE_GUID = 35961516-ABA1-4636-A4C0-608E62BE8BB0
MODULE_TYPE = DXE_DRIVER
VERSION_STRING = 1.0
LIBRARY_CLASS = ExtendedHiiLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER
EDK_RELEASE_VERSION = 0x00020000
EFI_SPECIFICATION_VERSION = 0x0002000A
#
# VALID_ARCHITECTURES = IA32 X64 IPF EBC
#
[Sources.common]
ExtendedHiiLib.c
[Packages]
MdePkg/MdePkg.dec
MdeModulePkg/MdeModulePkg.dec
[LibraryClasses]
MemoryAllocationLib
DebugLib
PcdLib
UefiRuntimeServicesTableLib
[Protocols]
gEfiDevicePathProtocolGuid

45
MdeModulePkg/Library/ExtendedHiiLib/ExtendedHiiLib.msa Normal file
View File

@ -0,0 +1,45 @@
<?xml version="1.0" encoding="UTF-8"?>
<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<MsaHeader>
<ModuleName>HiiLib</ModuleName>
<ModuleType>DXE_DRIVER</ModuleType>
<GuidValue>3143687A-7C80-404e-B5FE-2D88980E1B1C</GuidValue>
<Version>1.0</Version>
<Abstract>Library instance for HII common routines.</Abstract>
<Description>This library instance implements the common HII routines.</Description>
<Copyright>Copyright (c) 2006, Intel Corporation</Copyright>
<License>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.</License>
<Specification>FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052</Specification>
</MsaHeader>
<ModuleDefinitions>
<SupportedArchitectures>IA32 X64 IPF EBC</SupportedArchitectures>
<BinaryModule>false</BinaryModule>
<OutputFileBasename>HiiLib</OutputFileBasename>
</ModuleDefinitions>
<LibraryClassDefinitions>
<LibraryClass Usage="ALWAYS_PRODUCED" SupModuleList="DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER">
<Keyword>HiiLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>DebugLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>MemoryAllocationLib</Keyword>
</LibraryClass>
</LibraryClassDefinitions>
<SourceFiles>
<Filename>HiiLib.c</Filename>
</SourceFiles>
<PackageDependencies>
<Package PackageGuid="5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec"/>
</PackageDependencies>
<Externs>
<Specification>EFI_SPECIFICATION_VERSION 0x00020000</Specification>
<Specification>EDK_RELEASE_VERSION 0x00020000</Specification>
</Externs>
</ModuleSurfaceArea>

177
MdeModulePkg/Library/ExtendedIfrSupportLib/Common.c Normal file
View File

@ -0,0 +1,177 @@
/** @file
Copyright (c) 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.
Module Name:
UefiIfrCommon.c
Abstract:
Common Library Routines to assist handle HII elements.
**/
#include "LibraryInternal.h"
//
// Hii relative protocols
//
EFI_HII_DATABASE_PROTOCOL *gIfrLibHiiDatabase;
EFI_HII_STRING_PROTOCOL *gIfrLibHiiString;
EFI_STATUS
EFIAPI
ExtendedIfrSupportLibConstructor (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
Status = gBS->LocateProtocol (&gEfiHiiDatabaseProtocolGuid, NULL, (VOID **) &gIfrLibHiiDatabase);
ASSERT_EFI_ERROR (Status);
Status = gBS->LocateProtocol (&gEfiHiiStringProtocolGuid, NULL, (VOID **) &gIfrLibHiiString);
ASSERT_EFI_ERROR (Status);
return EFI_SUCCESS;
}
STATIC EFI_GUID mIfrVendorGuid = EFI_IFR_TIANO_GUID;
EFI_STATUS
EFIAPI
IfrLibExtractClassFromHiiHandle (
IN EFI_HII_HANDLE Handle,
OUT UINT16 *Class,
OUT EFI_STRING_ID *FormSetTitle,
OUT EFI_STRING_ID *FormSetHelp
)
/*++
Routine Description:
Extract formset class for given HII handle.
Arguments:
HiiHandle - Hii handle
Class - Class of the formset
FormSetTitle - Formset title string
FormSetHelp - Formset help string
Returns:
EFI_SUCCESS - Successfully extract Class for specified Hii handle.
--*/
{
EFI_STATUS Status;
UINTN BufferSize;
EFI_HII_PACKAGE_LIST_HEADER *HiiPackageList;
UINT8 *Package;
UINT8 *OpCodeData;
UINT32 Offset;
UINT32 Offset2;
UINT32 PackageListLength;
EFI_HII_PACKAGE_HEADER PackageHeader;
ASSERT (Handle != NULL);
ASSERT (Class != NULL);
ASSERT (FormSetTitle != NULL);
ASSERT (FormSetHelp != NULL);
*Class = EFI_NON_DEVICE_CLASS;
*FormSetTitle = 0;
*FormSetHelp = 0;
//
// Get HII PackageList
//
BufferSize = 0;
HiiPackageList = NULL;
Status = gIfrLibHiiDatabase->ExportPackageLists (gIfrLibHiiDatabase, Handle, &BufferSize, HiiPackageList);
ASSERT (Status != EFI_NOT_FOUND);
if (Status == EFI_BUFFER_TOO_SMALL) {
HiiPackageList = AllocatePool (BufferSize);
ASSERT (HiiPackageList != NULL);
Status = gIfrLibHiiDatabase->ExportPackageLists (gIfrLibHiiDatabase, Handle, &BufferSize, HiiPackageList);
}
if (EFI_ERROR (Status)) {
return Status;
}
//
// Get Form package from this HII package List
//
Offset = sizeof (EFI_HII_PACKAGE_LIST_HEADER);
Offset2 = 0;
CopyMem (&PackageListLength, &HiiPackageList->PackageLength, sizeof (UINT32));
while (Offset < PackageListLength) {
Package = ((UINT8 *) HiiPackageList) + Offset;
CopyMem (&PackageHeader, Package, sizeof (EFI_HII_PACKAGE_HEADER));
if (PackageHeader.Type == EFI_HII_PACKAGE_FORM) {
//
// Search Class Opcode in this Form Package
//
Offset2 = sizeof (EFI_HII_PACKAGE_HEADER);
while (Offset2 < PackageHeader.Length) {
OpCodeData = Package + Offset2;
if (((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode == EFI_IFR_FORM_SET_OP) {
//
// Find FormSet OpCode
//
CopyMem (FormSetTitle, &((EFI_IFR_FORM_SET *) OpCodeData)->FormSetTitle, sizeof (EFI_STRING_ID));
CopyMem (FormSetHelp, &((EFI_IFR_FORM_SET *) OpCodeData)->Help, sizeof (EFI_STRING_ID));
}
if ((((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode == EFI_IFR_GUID_OP) &&
CompareGuid (&mIfrVendorGuid, (EFI_GUID *)(OpCodeData + sizeof (EFI_IFR_OP_HEADER))) &&
(((EFI_IFR_GUID_CLASS *) OpCodeData)->ExtendOpCode == EFI_IFR_EXTEND_OP_CLASS)
) {
//
// Find GUIDed Class OpCode
//
CopyMem (Class, &((EFI_IFR_GUID_CLASS *) OpCodeData)->Class, sizeof (UINT16));
//
// Till now, we ought to have found the formset Opcode
//
break;
}
Offset2 += ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
}
if (Offset2 < PackageHeader.Length) {
//
// Target formset found
//
break;
}
}
Offset += PackageHeader.Length;
}
gBS->FreePool (HiiPackageList);
return EFI_SUCCESS;
}

17
MdeModulePkg/Library/IfrSupportLib/IfrSupportLib.inf → MdeModulePkg/Library/ExtendedIfrSupportLib/ExtendedIfrSupportLib.inf
View File

@ -17,14 +17,16 @@
[Defines] [Defines]
INF_VERSION = 0x00010005 INF_VERSION = 0x00010005
BASE_NAME = IfrSupportLib BASE_NAME = MdeModuleIfrSupportLib
FILE_GUID = bf38668e-e231-4baa-99e4-8c0e4c35dca6 FILE_GUID = A47B68BA-5177-4b2d-891E-4722FA5323F8
MODULE_TYPE = DXE_DRIVER MODULE_TYPE = DXE_DRIVER
VERSION_STRING = 1.0 VERSION_STRING = 1.0
LIBRARY_CLASS = IfrSupportLib LIBRARY_CLASS = ExtendedIfrSupportLib|DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER
EDK_RELEASE_VERSION = 0x00020000 EDK_RELEASE_VERSION = 0x00020000
EFI_SPECIFICATION_VERSION = 0x00020000 EFI_SPECIFICATION_VERSION = 0x00020000
CONSTRUCTOR = ExtendedIfrSupportLibConstructor
# #
# The following information is for reference only and not required by the build tools. # The following information is for reference only and not required by the build tools.
@ -33,11 +35,10 @@
# #
[Sources.common] [Sources.common]
UefiIfrCommon.c Common.c
UefiIfrForm.c Form.c
UefiIfrLibraryInternal.h LibraryInternal.h
UefiIfrOpCodeCreation.c IfrOpCodeCreation.c
UefiIfrString.c
R8Lib.h R8Lib.h
R8Lib.c R8Lib.c

0
MdeModulePkg/Library/IfrSupportLib/IfrSupportLib.msa → MdeModulePkg/Library/ExtendedIfrSupportLib/ExtendedIfrSupportLib.msa
View File

441
MdeModulePkg/Library/ExtendedIfrSupportLib/Form.c Normal file
View File

@ -0,0 +1,441 @@
/** @file
Copyright (c) 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.
Module Name:
UefiIfrForm.c
Abstract:
Common Library Routines to assist handle HII elements.
**/
#include "LibraryInternal.h"
STATIC
EFI_STATUS
GetPackageDataFromPackageList (
IN EFI_HII_PACKAGE_LIST_HEADER *HiiPackageList,
IN UINT32 PackageIndex,
OUT UINT32 *BufferLen,
OUT EFI_HII_PACKAGE_HEADER **Buffer
)
{
UINT32 Index;
EFI_HII_PACKAGE_HEADER *Package;
UINT32 Offset;
UINT32 PackageListLength;
EFI_HII_PACKAGE_HEADER PackageHeader = {0, 0};
ASSERT(HiiPackageList != NULL);
if ((BufferLen == NULL) || (Buffer == NULL)) {
return EFI_INVALID_PARAMETER;
}
Package = NULL;
Index = 0;
Offset = sizeof (EFI_HII_PACKAGE_LIST_HEADER);
CopyMem (&PackageListLength, &HiiPackageList->PackageLength, sizeof (UINT32));
while (Offset < PackageListLength) {
Package = (EFI_HII_PACKAGE_HEADER *) (((UINT8 *) HiiPackageList) + Offset);
CopyMem (&PackageHeader, Package, sizeof (EFI_HII_PACKAGE_HEADER));
if (Index == PackageIndex) {
break;
}
Offset += PackageHeader.Length;
Index++;
}
if (Offset >= PackageListLength) {
//
// no package found in this Package List
//
return EFI_NOT_FOUND;
}
*BufferLen = PackageHeader.Length;
*Buffer = Package;
return EFI_SUCCESS;
}
STATIC
EFI_STATUS
EFIAPI
UpdateFormPackageData (
IN EFI_GUID *FormSetGuid,
IN EFI_FORM_ID FormId,
IN EFI_HII_PACKAGE_HEADER *Package,
IN UINT32 PackageLength,
IN UINT16 Label,
IN BOOLEAN Insert,
IN EFI_HII_UPDATE_DATA *Data,
OUT UINT8 **TempBuffer,
OUT UINT32 *TempBufferSize
)
{
UINTN AddSize;
UINT8 *BufferPos;
EFI_HII_PACKAGE_HEADER PackageHeader;
UINTN Offset;
EFI_IFR_OP_HEADER *IfrOpHdr;
BOOLEAN GetFormSet;
BOOLEAN GetForm;
UINT8 ExtendOpCode;
UINT16 LabelNumber;
BOOLEAN Updated;
EFI_IFR_OP_HEADER *AddOpCode;
if ((TempBuffer == NULL) || (TempBufferSize == NULL)) {
return EFI_INVALID_PARAMETER;
}
*TempBufferSize = PackageLength;
if (Data != NULL) {
*TempBufferSize += Data->Offset;
}
*TempBuffer = AllocateZeroPool (*TempBufferSize);
if (*TempBuffer == NULL) {
return EFI_OUT_OF_RESOURCES;
}
CopyMem (*TempBuffer, Package, sizeof (EFI_HII_PACKAGE_HEADER));
*TempBufferSize = sizeof (EFI_HII_PACKAGE_HEADER);
BufferPos = *TempBuffer + sizeof (EFI_HII_PACKAGE_HEADER);
CopyMem (&PackageHeader, Package, sizeof (EFI_HII_PACKAGE_HEADER));
IfrOpHdr = (EFI_IFR_OP_HEADER *)((UINT8 *) Package + sizeof (EFI_HII_PACKAGE_HEADER));
Offset = sizeof (EFI_HII_PACKAGE_HEADER);
GetFormSet = (BOOLEAN) ((FormSetGuid == NULL) ? TRUE : FALSE);
GetForm = FALSE;
Updated = FALSE;
while (Offset < PackageHeader.Length) {
CopyMem (BufferPos, IfrOpHdr, IfrOpHdr->Length);
BufferPos += IfrOpHdr->Length;
*TempBufferSize += IfrOpHdr->Length;
switch (IfrOpHdr->OpCode) {
case EFI_IFR_FORM_SET_OP :
if (FormSetGuid != NULL) {
if (CompareMem (&((EFI_IFR_FORM_SET *) IfrOpHdr)->Guid, FormSetGuid, sizeof (EFI_GUID)) == 0) {
GetFormSet = TRUE;
}
}
break;
case EFI_IFR_FORM_OP:
if (CompareMem (&((EFI_IFR_FORM *) IfrOpHdr)->FormId, &FormId, sizeof (EFI_FORM_ID)) == 0) {
GetForm = TRUE;
}
break;
case EFI_IFR_GUID_OP :
if (!GetFormSet || !GetForm || Updated) {
//
// Go to the next Op-Code
//
Offset += IfrOpHdr->Length;
IfrOpHdr = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (IfrOpHdr) + IfrOpHdr->Length);
continue;
}
ExtendOpCode = ((EFI_IFR_GUID_LABEL *) IfrOpHdr)->ExtendOpCode;
CopyMem (&LabelNumber, &((EFI_IFR_GUID_LABEL *)IfrOpHdr)->Number, sizeof (UINT16));
if ((ExtendOpCode != EFI_IFR_EXTEND_OP_LABEL) || (LabelNumber != Label)) {
//
// Go to the next Op-Code
//
Offset += IfrOpHdr->Length;
IfrOpHdr = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (IfrOpHdr) + IfrOpHdr->Length);
continue;
}
if (Insert && (Data != NULL)) {
//
// insert the DataCount amount of opcodes to TempBuffer if Data is NULL remove
// DataCount amount of opcodes unless runing into a label.
//
AddOpCode = (EFI_IFR_OP_HEADER *)Data->Data;
AddSize = 0;
while (AddSize < Data->Offset) {
CopyMem (BufferPos, AddOpCode, AddOpCode->Length);
BufferPos += AddOpCode->Length;
*TempBufferSize += AddOpCode->Length;
AddSize += AddOpCode->Length;
AddOpCode = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (AddOpCode) + AddOpCode->Length);
}
} else {
//
// Search the next Label.
//
while (TRUE) {
Offset += IfrOpHdr->Length;
//
// Search the next label and Fail if not label found.
//
if (Offset >= PackageHeader.Length) {
goto Fail;
}
IfrOpHdr = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (IfrOpHdr) + IfrOpHdr->Length);
if (IfrOpHdr->OpCode == EFI_IFR_GUID_OP) {
ExtendOpCode = ((EFI_IFR_GUID_LABEL *) IfrOpHdr)->ExtendOpCode;
if (ExtendOpCode == EFI_IFR_EXTEND_OP_LABEL) {
break;
}
}
}
if (Data != NULL) {
AddOpCode = (EFI_IFR_OP_HEADER *)Data->Data;
AddSize = 0;
while (AddSize < Data->Offset) {
CopyMem (BufferPos, AddOpCode, AddOpCode->Length);
BufferPos += AddOpCode->Length;
*TempBufferSize += AddOpCode->Length;
AddSize += AddOpCode->Length;
AddOpCode = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (AddOpCode) + AddOpCode->Length);
}
}
//
// copy the next label
//
CopyMem (BufferPos, IfrOpHdr, IfrOpHdr->Length);
BufferPos += IfrOpHdr->Length;
*TempBufferSize += IfrOpHdr->Length;
}
Updated = TRUE;
break;
default :
break;
}
//
// Go to the next Op-Code
//
Offset += IfrOpHdr->Length;
IfrOpHdr = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (IfrOpHdr) + IfrOpHdr->Length);
}
//
// Update the package length.
//
PackageHeader.Length = *TempBufferSize;
CopyMem (*TempBuffer, &PackageHeader, sizeof (EFI_HII_PACKAGE_HEADER));
Fail:
if (!Updated) {
gBS->FreePool (*TempBuffer);
*TempBufferSize = 0;
return EFI_NOT_FOUND;
}
return EFI_SUCCESS;
}
/**
This function allows the caller to update a form that has
previously been registered with the EFI HII database.
@param Handle Hii Handle
@param FormSetGuid The formset should be updated.
@param FormId The form should be updated.
@param Label Update information starting immediately after this
label in the IFR
@param Insert If TRUE and Data is not NULL, insert data after
Label. If FALSE, replace opcodes between two
labels with Data
@param Data The adding data; If NULL, remove opcodes between
two Label.
@retval EFI_SUCCESS Update success.
@retval Other Update fail.
**/
EFI_STATUS
EFIAPI
IfrLibUpdateForm (
IN EFI_HII_HANDLE Handle,
IN EFI_GUID *FormSetGuid, OPTIONAL
IN EFI_FORM_ID FormId,
IN UINT16 Label,
IN BOOLEAN Insert,
IN EFI_HII_UPDATE_DATA *Data
)
{
EFI_STATUS Status;
EFI_HII_DATABASE_PROTOCOL *HiiDatabase;
EFI_HII_PACKAGE_LIST_HEADER *HiiPackageList;
UINT32 Index;
EFI_HII_PACKAGE_LIST_HEADER *UpdateBuffer;
UINTN BufferSize;
UINT8 *UpdateBufferPos;
EFI_HII_PACKAGE_HEADER PackageHeader;
EFI_HII_PACKAGE_HEADER *Package;
UINT32 PackageLength;
EFI_HII_PACKAGE_HEADER *TempBuffer;
UINT32 TempBufferSize;
BOOLEAN Updated;
if (Data == NULL) {
return EFI_INVALID_PARAMETER;
}
HiiDatabase = gIfrLibHiiDatabase;
//
// Get the orginal package list
//
BufferSize = 0;
HiiPackageList = NULL;
Status = HiiDatabase->ExportPackageLists (HiiDatabase, Handle, &BufferSize, HiiPackageList);
if (Status == EFI_BUFFER_TOO_SMALL) {
HiiPackageList = AllocatePool (BufferSize);
ASSERT (HiiPackageList != NULL);
Status = HiiDatabase->ExportPackageLists (HiiDatabase, Handle, &BufferSize, HiiPackageList);
if (EFI_ERROR (Status)) {
gBS->FreePool (HiiPackageList);
return Status;
}
}
//
// Calculate and allocate space for retrieval of IFR data
//
BufferSize += Data->Offset;
UpdateBuffer = AllocateZeroPool (BufferSize);
if (UpdateBuffer == NULL) {
return EFI_OUT_OF_RESOURCES;
}
UpdateBufferPos = (UINT8 *) UpdateBuffer;
//
// copy the package list header
//
CopyMem (UpdateBufferPos, HiiPackageList, sizeof (EFI_HII_PACKAGE_LIST_HEADER));
UpdateBufferPos += sizeof (EFI_HII_PACKAGE_LIST_HEADER);
Updated = FALSE;
for (Index = 0; ; Index++) {
Status = GetPackageDataFromPackageList (HiiPackageList, Index, &PackageLength, &Package);
if (Status == EFI_SUCCESS) {
CopyMem (&PackageHeader, Package, sizeof (EFI_HII_PACKAGE_HEADER));
if ((PackageHeader.Type == EFI_HII_PACKAGE_FORM) && !Updated) {
Status = UpdateFormPackageData (FormSetGuid, FormId, Package, PackageLength, Label, Insert, Data, (UINT8 **)&TempBuffer, &TempBufferSize);
if (!EFI_ERROR(Status)) {
if (FormSetGuid == NULL) {
Updated = TRUE;
}
CopyMem (UpdateBufferPos, TempBuffer, TempBufferSize);
UpdateBufferPos += TempBufferSize;
gBS->FreePool (TempBuffer);
continue;
}
}
CopyMem (UpdateBufferPos, Package, PackageLength);
UpdateBufferPos += PackageLength;
} else if (Status == EFI_NOT_FOUND) {
break;
} else {
gBS->FreePool (HiiPackageList);
return Status;
}
}
//
// Update package list length
//
BufferSize = UpdateBufferPos - (UINT8 *) UpdateBuffer;
CopyMem (&UpdateBuffer->PackageLength, &BufferSize, sizeof (UINT32));
gBS->FreePool (HiiPackageList);
return HiiDatabase->UpdatePackageList (HiiDatabase, Handle, UpdateBuffer);
}
/**
Configure the buffer accrording to ConfigBody strings.
@param DefaultId the ID of default.
@param Buffer the start address of buffer.
@param BufferSize the size of buffer.
@param Number the number of the strings.
@retval EFI_BUFFER_TOO_SMALL the BufferSize is too small to operate.
@retval EFI_INVALID_PARAMETER Buffer is NULL or BufferSize is 0.
@retval EFI_SUCCESS Operation successful.
**/
EFI_STATUS
EFIAPI
IfrLibExtractDefault(
IN VOID *Buffer,
IN UINTN *BufferSize,
UINTN Number,
...
)
{
VA_LIST Args;
UINTN Index;
UINT32 TotalLen;
UINT8 *BufCfgArray;
UINT8 *BufferPos;
UINT16 Offset;
UINT16 Width;
UINT8 *Value;
if ((Buffer == NULL) || (BufferSize == NULL)) {
return EFI_INVALID_PARAMETER;
}
Offset = 0;
Width = 0;
Value = NULL;
VA_START (Args, Number);
for (Index = 0; Index < Number; Index++) {
BufCfgArray = (UINT8 *) VA_ARG (Args, VOID *);
CopyMem (&TotalLen, BufCfgArray, sizeof (UINT32));
BufferPos = BufCfgArray + sizeof (UINT32);
while ((UINT32)(BufferPos - BufCfgArray) < TotalLen) {
CopyMem (&Offset, BufferPos, sizeof (UINT16));
BufferPos += sizeof (UINT16);
CopyMem (&Width, BufferPos, sizeof (UINT16));
BufferPos += sizeof (UINT16);
Value = BufferPos;
BufferPos += Width;
if ((UINTN)(Offset + Width) > *BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
CopyMem ((UINT8 *)Buffer + Offset, Value, Width);
}
}
VA_END (Args);
*BufferSize = (UINTN)Offset;
return EFI_SUCCESS;
}

63
MdeModulePkg/Library/ExtendedIfrSupportLib/IfrOpCodeCreation.c Normal file
View File

@ -0,0 +1,63 @@
/** @file
Copyright (c) 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.
Module Name:
UefiIfrOpCodeCreation.c
Abstract:
Library Routines to create IFR independent of string data - assume tokens already exist
Primarily to be used for exporting op-codes at a label in pre-defined forms.
Revision History:
**/
#include "LibraryInternal.h"
STATIC EFI_GUID mIfrVendorGuid = EFI_IFR_TIANO_GUID;
EFI_STATUS
EFIAPI
CreateBannerOpCode (
IN EFI_STRING_ID Title,
IN UINT16 LineNumber,
IN UINT8 Alignment,
IN OUT EFI_HII_UPDATE_DATA *Data
)
{
EFI_IFR_GUID_BANNER Banner;
UINT8 *LocalBuffer;
ASSERT (Data != NULL && Data->Data != NULL);
if (Data->Offset + sizeof (EFI_IFR_GUID_BANNER) > Data->BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
Banner.Header.OpCode = EFI_IFR_GUID_OP;
Banner.Header.Length = sizeof (EFI_IFR_GUID_BANNER);
Banner.Header.Scope = 0;
CopyMem (&Banner.Guid, &mIfrVendorGuid, sizeof (EFI_IFR_GUID));
Banner.ExtendOpCode = EFI_IFR_EXTEND_OP_BANNER;
Banner.Title = Title;
Banner.LineNumber = LineNumber;
Banner.Alignment = Alignment;
LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
CopyMem (LocalBuffer, &Banner, sizeof (EFI_IFR_GUID_BANNER));
Data->Offset += sizeof (EFI_IFR_GUID_BANNER);
return EFI_SUCCESS;
}

18
MdeModulePkg/Library/IfrSupportLib/UefiIfrLibraryInternal.h → MdeModulePkg/Library/ExtendedIfrSupportLib/LibraryInternal.h
View File

@ -43,22 +43,4 @@ Abstract:
#include "R8Lib.h" #include "R8Lib.h"
VOID
LocateHiiProtocols (
VOID
)
/*++
Routine Description:
This function locate Hii relative protocols for later usage.
Arguments:
None.
Returns:
None.
--*/
;
#endif #endif

2
MdeModulePkg/Library/IfrSupportLib/R8Lib.c → MdeModulePkg/Library/ExtendedIfrSupportLib/R8Lib.c
View File

@ -12,7 +12,7 @@
**/ **/
#include "UefiIfrLibraryInternal.h" #include "LibraryInternal.h"
CHAR16 CHAR16

0
MdeModulePkg/Library/IfrSupportLib/R8Lib.h → MdeModulePkg/Library/ExtendedIfrSupportLib/R8Lib.h
View File

369
MdeModulePkg/Library/IfrSupportLib/UefiIfrCommon.c
View File

@ -1,369 +0,0 @@
/** @file
Copyright (c) 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.
Module Name:
UefiIfrCommon.c
Abstract:
Common Library Routines to assist handle HII elements.
**/
#include "UefiIfrLibraryInternal.h"
//
// Hii relative protocols
//
BOOLEAN mHiiProtocolsInitialized = FALSE;
EFI_HII_DATABASE_PROTOCOL *gIfrLibHiiDatabase;
EFI_HII_STRING_PROTOCOL *gIfrLibHiiString;
/**
This function locate Hii relative protocols for later usage.
None.
@return None.
**/
VOID
LocateHiiProtocols (
VOID
)
{
EFI_STATUS Status;
if (mHiiProtocolsInitialized) {
return;
}
Status = gBS->LocateProtocol (&gEfiHiiDatabaseProtocolGuid, NULL, (VOID **) &gIfrLibHiiDatabase);
ASSERT_EFI_ERROR (Status);
Status = gBS->LocateProtocol (&gEfiHiiStringProtocolGuid, NULL, (VOID **) &gIfrLibHiiString);
ASSERT_EFI_ERROR (Status);
mHiiProtocolsInitialized = TRUE;
}
/**
Assemble EFI_HII_PACKAGE_LIST according to the passed in packages.
@param NumberOfPackages Number of packages.
@param GuidId Package GUID.
@return Pointer of EFI_HII_PACKAGE_LIST_HEADER.
**/
EFI_HII_PACKAGE_LIST_HEADER *
PreparePackageList (
IN UINTN NumberOfPackages,
IN EFI_GUID *GuidId,
...
)
{
VA_LIST Marker;
EFI_HII_PACKAGE_LIST_HEADER *PackageListHeader;
UINT8 *PackageListData;
UINT32 PackageListLength;
UINT32 PackageLength;
EFI_HII_PACKAGE_HEADER PackageHeader;
UINT8 *PackageArray;
UINTN Index;
PackageListLength = sizeof (EFI_HII_PACKAGE_LIST_HEADER);
VA_START (Marker, GuidId);
for (Index = 0; Index < NumberOfPackages; Index++) {
CopyMem (&PackageLength, VA_ARG (Marker, VOID *), sizeof (UINT32));
PackageListLength += (PackageLength - sizeof (UINT32));
}
VA_END (Marker);
//
// Include the lenght of EFI_HII_PACKAGE_END
//
PackageListLength += sizeof (EFI_HII_PACKAGE_HEADER);
PackageListHeader = AllocateZeroPool (PackageListLength);
ASSERT (PackageListHeader != NULL);
CopyMem (&PackageListHeader->PackageListGuid, GuidId, sizeof (EFI_GUID));
PackageListHeader->PackageLength = PackageListLength;
PackageListData = ((UINT8 *) PackageListHeader) + sizeof (EFI_HII_PACKAGE_LIST_HEADER);
VA_START (Marker, GuidId);
for (Index = 0; Index < NumberOfPackages; Index++) {
PackageArray = (UINT8 *) VA_ARG (Marker, VOID *);
CopyMem (&PackageLength, PackageArray, sizeof (UINT32));
PackageLength -= sizeof (UINT32);
PackageArray += sizeof (UINT32);
CopyMem (PackageListData, PackageArray, PackageLength);
PackageListData += PackageLength;
}
VA_END (Marker);
//
// Append EFI_HII_PACKAGE_END
//
PackageHeader.Type = EFI_HII_PACKAGE_END;
PackageHeader.Length = sizeof (EFI_HII_PACKAGE_HEADER);
CopyMem (PackageListData, &PackageHeader, PackageHeader.Length);
return PackageListHeader;
}
/**
Find HII Handle associated with given Device Path.
@param HiiDatabase Point to EFI_HII_DATABASE_PROTOCOL instance.
@param DevicePath Device Path associated with the HII package list
handle.
@retval Handle HII package list Handle associated with the Device
Path.
@retval NULL Hii Package list handle is not found.
**/
EFI_HII_HANDLE
DevicePathToHiiHandle (
IN EFI_HII_DATABASE_PROTOCOL *HiiDatabase,
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
)
{
EFI_STATUS Status;
EFI_DEVICE_PATH_PROTOCOL *TmpDevicePath;
UINTN BufferSize;
UINTN HandleCount;
UINTN Index;
EFI_HANDLE *Handles;
EFI_HANDLE Handle;
UINTN Size;
EFI_HANDLE DriverHandle;
EFI_HII_HANDLE *HiiHandles;
EFI_HII_HANDLE HiiHandle;
//
// Locate Device Path Protocol handle buffer
//
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiDevicePathProtocolGuid,
NULL,
&HandleCount,
&Handles
);
if (EFI_ERROR (Status)) {
return NULL;
}
//
// Search Driver Handle by Device Path
//
DriverHandle = NULL;
BufferSize = GetDevicePathSize (DevicePath);
for(Index = 0; Index < HandleCount; Index++) {
Handle = Handles[Index];
gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID **) &TmpDevicePath);
//
// Check whether DevicePath match
//
Size = GetDevicePathSize (TmpDevicePath);
if ((Size == BufferSize) && CompareMem (DevicePath, TmpDevicePath, Size) == 0) {
DriverHandle = Handle;
break;
}
}
gBS->FreePool (Handles);
if (DriverHandle == NULL) {
return NULL;
}
//
// Retrieve all Hii Handles from HII database
//
BufferSize = 0x1000;
HiiHandles = AllocatePool (BufferSize);
ASSERT (HiiHandles != NULL);
Status = HiiDatabase->ListPackageLists (
HiiDatabase,
EFI_HII_PACKAGE_TYPE_ALL,
NULL,
&BufferSize,
HiiHandles
);
if (Status == EFI_BUFFER_TOO_SMALL) {
gBS->FreePool (HiiHandles);
HiiHandles = AllocatePool (BufferSize);
ASSERT (HiiHandles != NULL);
Status = HiiDatabase->ListPackageLists (
HiiDatabase,
EFI_HII_PACKAGE_TYPE_ALL,
NULL,
&BufferSize,
HiiHandles
);
}
if (EFI_ERROR (Status)) {
gBS->FreePool (HiiHandles);
return NULL;
}
//
// Search Hii Handle by Driver Handle
//
HiiHandle = NULL;
HandleCount = BufferSize / sizeof (EFI_HII_HANDLE);
for (Index = 0; Index < HandleCount; Index++) {
Status = HiiDatabase->GetPackageListHandle (
HiiDatabase,
HiiHandles[Index],
&Handle
);
if (!EFI_ERROR (Status) && (Handle == DriverHandle)) {
HiiHandle = HiiHandles[Index];
break;
}
}
gBS->FreePool (HiiHandles);
return HiiHandle;
}
/**
Determines the handles that are currently active in the database.
It's the caller's responsibility to free handle buffer.
@param HiiDatabase A pointer to the EFI_HII_DATABASE_PROTOCOL
instance.
@param HandleBufferLength On input, a pointer to the length of the handle
buffer. On output, the length of the handle buffer
that is required for the handles found.
@param HiiHandleBuffer Pointer to an array of Hii Handles returned.
@retval EFI_SUCCESS Get an array of Hii Handles successfully.
@retval EFI_INVALID_PARAMETER Hii is NULL.
@retval EFI_NOT_FOUND Database not found.
**/
EFI_STATUS
GetHiiHandles (
IN OUT UINTN *HandleBufferLength,
OUT EFI_HII_HANDLE **HiiHandleBuffer
)
{
UINTN BufferLength;
EFI_STATUS Status;
BufferLength = 0;
LocateHiiProtocols ();
//
// Try to find the actual buffer size for HiiHandle Buffer.
//
Status = gIfrLibHiiDatabase->ListPackageLists (
gIfrLibHiiDatabase,
EFI_HII_PACKAGE_TYPE_ALL,
NULL,
&BufferLength,
*HiiHandleBuffer
);
if (Status == EFI_BUFFER_TOO_SMALL) {
*HiiHandleBuffer = AllocateZeroPool (BufferLength);
Status = gIfrLibHiiDatabase->ListPackageLists (
gIfrLibHiiDatabase,
EFI_HII_PACKAGE_TYPE_ALL,
NULL,
&BufferLength,
*HiiHandleBuffer
);
//
// we should not fail here.
//
ASSERT_EFI_ERROR (Status);
}
*HandleBufferLength = BufferLength;
return Status;
}
/**
Extract Hii package list GUID for given HII handle.
@param HiiHandle Hii handle
@param Guid Package list GUID
@retval EFI_SUCCESS Successfully extract GUID from Hii database.
**/
EFI_STATUS
ExtractGuidFromHiiHandle (
IN EFI_HII_HANDLE Handle,
OUT EFI_GUID *Guid
)
{
EFI_STATUS Status;
UINTN BufferSize;
EFI_HII_DATABASE_PROTOCOL *HiiDatabase;
EFI_HII_PACKAGE_LIST_HEADER *HiiPackageList;
//
// Locate HII Database protocol
//
Status = gBS->LocateProtocol (
&gEfiHiiDatabaseProtocolGuid,
NULL,
(VOID **) &HiiDatabase
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Get HII PackageList
//
BufferSize = 0;
HiiPackageList = NULL;
Status = HiiDatabase->ExportPackageLists (HiiDatabase, Handle, &BufferSize, HiiPackageList);
if (Status == EFI_BUFFER_TOO_SMALL) {
HiiPackageList = AllocatePool (BufferSize);
ASSERT (HiiPackageList != NULL);
Status = HiiDatabase->ExportPackageLists (HiiDatabase, Handle, &BufferSize, HiiPackageList);
}
if (EFI_ERROR (Status)) {
return Status;
}
//
// Extract GUID
//
CopyMem (Guid, &HiiPackageList->PackageListGuid, sizeof (EFI_GUID));
gBS->FreePool (HiiPackageList);
return EFI_SUCCESS;
}

1121
MdeModulePkg/Library/IfrSupportLib/UefiIfrForm.c
View File

File diff suppressed because it is too large Load Diff

639
MdeModulePkg/Library/IfrSupportLib/UefiIfrOpCodeCreation.c
View File

@ -1,639 +0,0 @@
/** @file
Copyright (c) 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.
Module Name:
UefiIfrOpCodeCreation.c
Abstract:
Library Routines to create IFR independent of string data - assume tokens already exist
Primarily to be used for exporting op-codes at a label in pre-defined forms.
Revision History:
**/
#include "UefiIfrLibraryInternal.h"
STATIC EFI_GUID mIfrVendorGuid = EFI_IFR_TIANO_GUID;
STATIC
BOOLEAN
IsValidQuestionFlags (
IN UINT8 Flags
)
{
return (BOOLEAN) ((Flags & (~QUESTION_FLAGS)) ? FALSE : TRUE);
}
STATIC
BOOLEAN
IsValidValueType (
IN UINT8 Type
)
{
return (BOOLEAN) ((Type <= EFI_IFR_TYPE_OTHER) ? TRUE : FALSE);
}
STATIC
BOOLEAN
IsValidNumricFlags (
IN UINT8 Flags
)
{
if (Flags & ~(EFI_IFR_NUMERIC_SIZE | EFI_IFR_DISPLAY)) {
return FALSE;
}
if ((Flags & EFI_IFR_DISPLAY) > EFI_IFR_DISPLAY_UINT_HEX) {
return FALSE;
}
return TRUE;
}
STATIC
BOOLEAN
IsValidCheckboxFlags (
IN UINT8 Flags
)
{
return (BOOLEAN) ((Flags <= EFI_IFR_CHECKBOX_DEFAULT_MFG) ? TRUE : FALSE);
}
EFI_STATUS
CreateEndOpCode (
IN OUT EFI_HII_UPDATE_DATA *Data
)
{
EFI_IFR_END End;
UINT8 *LocalBuffer;
ASSERT (Data != NULL && Data->Data != NULL);
if (Data->Offset + sizeof (EFI_IFR_END) > Data->BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
End.Header.Length = sizeof (EFI_IFR_END);
End.Header.OpCode = EFI_IFR_END_OP;
End.Header.Scope = 0;
LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
CopyMem (LocalBuffer, &End, sizeof (EFI_IFR_END));
Data->Offset += sizeof (EFI_IFR_END);
return EFI_SUCCESS;
}
EFI_STATUS
CreateDefaultOpCode (
IN EFI_IFR_TYPE_VALUE *Value,
IN UINT8 Type,
IN OUT EFI_HII_UPDATE_DATA *Data
)
{
EFI_IFR_DEFAULT Default;
UINT8 *LocalBuffer;
ASSERT (Data != NULL && Data->Data != NULL);
if ((Value == NULL) || !IsValidValueType (Type)) {
return EFI_INVALID_PARAMETER;
}
if (Data->Offset + sizeof (EFI_IFR_DEFAULT) > Data->BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
Default.Header.OpCode = EFI_IFR_DEFAULT_OP;
Default.Header.Length = sizeof (EFI_IFR_DEFAULT);
Default.Header.Scope = 0;
Default.Type = Type;
Default.DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;
CopyMem (&Default.Value, Value, sizeof(EFI_IFR_TYPE_VALUE));
LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
CopyMem (LocalBuffer, &Default, sizeof (EFI_IFR_DEFAULT));
Data->Offset += sizeof (EFI_IFR_DEFAULT);
return EFI_SUCCESS;
}
EFI_STATUS
CreateActionOpCode (
IN EFI_QUESTION_ID QuestionId,
IN EFI_STRING_ID Prompt,
IN EFI_STRING_ID Help,
IN UINT8 QuestionFlags,
IN EFI_STRING_ID QuestionConfig,
IN OUT EFI_HII_UPDATE_DATA *Data
)
{
EFI_IFR_ACTION Action;
UINT8 *LocalBuffer;
ASSERT (Data != NULL && Data->Data != NULL);
if (!IsValidQuestionFlags (QuestionFlags)) {
return EFI_INVALID_PARAMETER;
}
if (Data->Offset + sizeof (EFI_IFR_ACTION) > Data->BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
Action.Header.OpCode = EFI_IFR_ACTION_OP;
Action.Header.Length = sizeof (EFI_IFR_ACTION);
Action.Header.Scope = 0;
Action.Question.QuestionId = QuestionId;
Action.Question.Header.Prompt = Prompt;
Action.Question.Header.Help = Help;
Action.Question.VarStoreId = INVALID_VARSTORE_ID;
Action.Question.Flags = QuestionFlags;
Action.QuestionConfig = QuestionConfig;
LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
CopyMem (LocalBuffer, &Action, sizeof (EFI_IFR_ACTION));
Data->Offset += sizeof (EFI_IFR_ACTION);
return EFI_SUCCESS;
}
EFI_STATUS
CreateSubTitleOpCode (
IN EFI_STRING_ID Prompt,
IN EFI_STRING_ID Help,
IN UINT8 Flags,
IN UINT8 Scope,
IN OUT EFI_HII_UPDATE_DATA *Data
)
{
EFI_IFR_SUBTITLE Subtitle;
UINT8 *LocalBuffer;
ASSERT (Data != NULL && Data->Data != NULL);
if (Data->Offset + sizeof (EFI_IFR_SUBTITLE) > Data->BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
Subtitle.Header.OpCode = EFI_IFR_SUBTITLE_OP;
Subtitle.Header.Length = sizeof (EFI_IFR_SUBTITLE);
Subtitle.Header.Scope = Scope;
Subtitle.Statement.Prompt = Prompt;
Subtitle.Statement.Help = Help;
Subtitle.Flags = Flags;
LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
CopyMem (LocalBuffer, &Subtitle, sizeof (EFI_IFR_SUBTITLE));
Data->Offset += sizeof (EFI_IFR_SUBTITLE);
return EFI_SUCCESS;
}
EFI_STATUS
CreateTextOpCode (
IN EFI_STRING_ID Prompt,
IN EFI_STRING_ID Help,
IN EFI_STRING_ID TextTwo,
IN OUT EFI_HII_UPDATE_DATA *Data
)
{
EFI_IFR_TEXT Text;
UINT8 *LocalBuffer;
ASSERT (Data != NULL && Data->Data != NULL);
if (Data->Offset + sizeof (EFI_IFR_TEXT) > Data->BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
Text.Header.OpCode = EFI_IFR_TEXT_OP;
Text.Header.Length = sizeof (EFI_IFR_TEXT);
Text.Header.Scope = 0;
Text.Statement.Prompt = Prompt;
Text.Statement.Help = Help;
Text.TextTwo = TextTwo;
LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
CopyMem (LocalBuffer, &Text, sizeof (EFI_IFR_TEXT));
Data->Offset += sizeof (EFI_IFR_TEXT);
return EFI_SUCCESS;
}
EFI_STATUS
CreateGotoOpCode (
IN EFI_FORM_ID FormId,
IN EFI_STRING_ID Prompt,
IN EFI_STRING_ID Help,
IN UINT8 QuestionFlags,
IN EFI_QUESTION_ID QuestionId,
IN OUT EFI_HII_UPDATE_DATA *Data
)
{
EFI_IFR_REF Goto;
UINT8 *LocalBuffer;
ASSERT (Data != NULL && Data->Data != NULL);
if (!IsValidQuestionFlags (QuestionFlags)) {
return EFI_INVALID_PARAMETER;
}
if (Data->Offset + sizeof (EFI_IFR_REF) > Data->BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
Goto.Header.OpCode = EFI_IFR_REF_OP;
Goto.Header.Length = sizeof (EFI_IFR_REF);
Goto.Header.Scope = 0;
Goto.Question.Header.Prompt = Prompt;
Goto.Question.Header.Help = Help;
Goto.Question.VarStoreId = INVALID_VARSTORE_ID;
Goto.Question.QuestionId = QuestionId;
Goto.Question.Flags = QuestionFlags;
Goto.FormId = FormId;
LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
CopyMem (LocalBuffer, &Goto, sizeof (EFI_IFR_REF));
Data->Offset += sizeof (EFI_IFR_REF);
return EFI_SUCCESS;
}
EFI_STATUS
CreateOneOfOptionOpCode (
IN UINTN OptionCount,
IN IFR_OPTION *OptionsList,
IN UINT8 Type,
IN OUT EFI_HII_UPDATE_DATA *Data
)
{
UINTN Index;
UINT8 *LocalBuffer;
EFI_IFR_ONE_OF_OPTION OneOfOption;
ASSERT (Data != NULL && Data->Data != NULL);
if ((OptionCount != 0) && (OptionsList == NULL)) {
return EFI_INVALID_PARAMETER;
}
if (Data->Offset + OptionCount * sizeof (EFI_IFR_ONE_OF_OPTION) > Data->BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
for (Index = 0; Index < OptionCount; Index++) {
OneOfOption.Header.OpCode = EFI_IFR_ONE_OF_OPTION_OP;
OneOfOption.Header.Length = sizeof (EFI_IFR_ONE_OF_OPTION);
OneOfOption.Header.Scope = 0;
OneOfOption.Option = OptionsList[Index].StringToken;
OneOfOption.Value = OptionsList[Index].Value;
OneOfOption.Flags = (UINT8) (OptionsList[Index].Flags & (EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG));
OneOfOption.Type = Type;
LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
CopyMem (LocalBuffer, &OneOfOption, sizeof (EFI_IFR_ONE_OF_OPTION));
Data->Offset += sizeof (EFI_IFR_ONE_OF_OPTION);
}
return EFI_SUCCESS;
}
EFI_STATUS
CreateOneOfOpCode (
IN EFI_QUESTION_ID QuestionId,
IN EFI_VARSTORE_ID VarStoreId,
IN UINT16 VarOffset,
IN EFI_STRING_ID Prompt,
IN EFI_STRING_ID Help,
IN UINT8 QuestionFlags,
IN UINT8 OneOfFlags,
IN IFR_OPTION *OptionsList,
IN UINTN OptionCount,
IN OUT EFI_HII_UPDATE_DATA *Data
)
{
UINTN Length;
EFI_IFR_ONE_OF OneOf;
UINT8 *LocalBuffer;
ASSERT (Data != NULL && Data->Data != NULL);
if (!IsValidNumricFlags (OneOfFlags) ||
!IsValidQuestionFlags (QuestionFlags) ||
((OptionCount != 0) && (OptionsList == NULL))) {
return EFI_INVALID_PARAMETER;
}
Length = sizeof (EFI_IFR_ONE_OF) + OptionCount * sizeof (EFI_IFR_ONE_OF_OPTION) + sizeof (EFI_IFR_END);
if (Data->Offset + Length > Data->BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
OneOf.Header.OpCode = EFI_IFR_ONE_OF_OP;
OneOf.Header.Length = sizeof (EFI_IFR_ONE_OF);
OneOf.Header.Scope = 1;
OneOf.Question.Header.Prompt = Prompt;
OneOf.Question.Header.Help = Help;
OneOf.Question.QuestionId = QuestionId;
OneOf.Question.VarStoreId = VarStoreId;
OneOf.Question.VarStoreInfo.VarOffset = VarOffset;
OneOf.Question.Flags = QuestionFlags;
OneOf.Flags = OneOfFlags;
ZeroMem ((VOID *) &OneOf.data, sizeof (MINMAXSTEP_DATA));
LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
CopyMem (LocalBuffer, &OneOf, sizeof (EFI_IFR_ONE_OF));
Data->Offset += sizeof (EFI_IFR_ONE_OF);
CreateOneOfOptionOpCode (OptionCount, OptionsList, (UINT8) (OneOfFlags & EFI_IFR_NUMERIC_SIZE), Data);
CreateEndOpCode (Data);
return EFI_SUCCESS;
}
EFI_STATUS
CreateOrderedListOpCode (
IN EFI_QUESTION_ID QuestionId,
IN EFI_VARSTORE_ID VarStoreId,
IN UINT16 VarOffset,
IN EFI_STRING_ID Prompt,
IN EFI_STRING_ID Help,
IN UINT8 QuestionFlags,
IN UINT8 OrderedListFlags,
IN UINT8 DataType,
IN UINT8 MaxContainers,
IN IFR_OPTION *OptionsList,
IN UINTN OptionCount,
IN OUT EFI_HII_UPDATE_DATA *Data
)
{
UINTN Length;
EFI_IFR_ORDERED_LIST OrderedList;
UINT8 *LocalBuffer;
ASSERT (Data != NULL && Data->Data != NULL);
if (!IsValidQuestionFlags (QuestionFlags) ||
((OptionCount != 0) && (OptionsList == NULL))) {
return EFI_INVALID_PARAMETER;
}
if ((OrderedListFlags != 0) &&
(OrderedListFlags != EFI_IFR_UNIQUE_SET) &&
(OrderedListFlags != EFI_IFR_NO_EMPTY_SET)) {
return EFI_INVALID_PARAMETER;
}
Length = sizeof (EFI_IFR_ORDERED_LIST) + OptionCount * sizeof (EFI_IFR_ONE_OF_OPTION) + sizeof (EFI_IFR_END);
if (Data->Offset + Length > Data->BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
OrderedList.Header.OpCode = EFI_IFR_ORDERED_LIST_OP;
OrderedList.Header.Length = sizeof (EFI_IFR_ORDERED_LIST);
OrderedList.Header.Scope = 1;
OrderedList.Question.Header.Prompt = Prompt;
OrderedList.Question.Header.Help = Help;
OrderedList.Question.QuestionId = QuestionId;
OrderedList.Question.VarStoreId = VarStoreId;
OrderedList.Question.VarStoreInfo.VarOffset = VarOffset;
OrderedList.Question.Flags = QuestionFlags;
OrderedList.MaxContainers = MaxContainers;
OrderedList.Flags = OrderedListFlags;
LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
CopyMem (LocalBuffer, &OrderedList, sizeof (EFI_IFR_ORDERED_LIST));
Data->Offset += sizeof (EFI_IFR_ORDERED_LIST);
CreateOneOfOptionOpCode (OptionCount, OptionsList, DataType, Data);
CreateEndOpCode (Data);
return EFI_SUCCESS;
}
EFI_STATUS
CreateCheckBoxOpCode (
IN EFI_QUESTION_ID QuestionId,
IN EFI_VARSTORE_ID VarStoreId,
IN UINT16 VarOffset,
IN EFI_STRING_ID Prompt,
IN EFI_STRING_ID Help,
IN UINT8 QuestionFlags,
IN UINT8 CheckBoxFlags,
IN OUT EFI_HII_UPDATE_DATA *Data
)
{
EFI_IFR_CHECKBOX CheckBox;
UINT8 *LocalBuffer;
ASSERT (Data != NULL && Data->Data != NULL);
if (!IsValidQuestionFlags (QuestionFlags) || !IsValidCheckboxFlags (CheckBoxFlags)) {
return EFI_INVALID_PARAMETER;
}
if (Data->Offset + sizeof (EFI_IFR_CHECKBOX) > Data->BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
CheckBox.Header.OpCode = EFI_IFR_CHECKBOX_OP;
CheckBox.Header.Length = sizeof (EFI_IFR_CHECKBOX);
CheckBox.Header.Scope = 0;
CheckBox.Question.QuestionId = QuestionId;
CheckBox.Question.VarStoreId = VarStoreId;
CheckBox.Question.VarStoreInfo.VarOffset = VarOffset;
CheckBox.Question.Header.Prompt = Prompt;
CheckBox.Question.Header.Help = Help;
CheckBox.Question.Flags = QuestionFlags;
CheckBox.Flags = CheckBoxFlags;
LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
CopyMem (LocalBuffer, &CheckBox, sizeof (EFI_IFR_CHECKBOX));
Data->Offset += sizeof (EFI_IFR_CHECKBOX);
return EFI_SUCCESS;
}
EFI_STATUS
CreateNumericOpCode (
IN EFI_QUESTION_ID QuestionId,
IN EFI_VARSTORE_ID VarStoreId,
IN UINT16 VarOffset,
IN EFI_STRING_ID Prompt,
IN EFI_STRING_ID Help,
IN UINT8 QuestionFlags,
IN UINT8 NumericFlags,
IN UINT64 Minimum,
IN UINT64 Maximum,
IN UINT64 Step,
IN UINT64 Default,
IN OUT EFI_HII_UPDATE_DATA *Data
)
{
EFI_STATUS Status;
EFI_IFR_NUMERIC Numeric;
MINMAXSTEP_DATA MinMaxStep;
EFI_IFR_TYPE_VALUE DefaultValue;
UINT8 *LocalBuffer;
ASSERT (Data != NULL && Data->Data != NULL);
if (!IsValidQuestionFlags (QuestionFlags) || !IsValidNumricFlags (NumericFlags)) {
return EFI_INVALID_PARAMETER;
}
if (Data->Offset + sizeof (EFI_IFR_CHECKBOX) > Data->BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
Numeric.Header.OpCode = EFI_IFR_NUMERIC_OP;
Numeric.Header.Length = sizeof (EFI_IFR_NUMERIC);
Numeric.Header.Scope = 1;
Numeric.Question.QuestionId = QuestionId;
Numeric.Question.VarStoreId = VarStoreId;
Numeric.Question.VarStoreInfo.VarOffset = VarOffset;
Numeric.Question.Header.Prompt = Prompt;
Numeric.Question.Header.Help = Help;
Numeric.Question.Flags = QuestionFlags;
Numeric.Flags = NumericFlags;
switch (NumericFlags & EFI_IFR_NUMERIC_SIZE) {
case EFI_IFR_NUMERIC_SIZE_1:
MinMaxStep.u8.MinValue = (UINT8) Minimum;
MinMaxStep.u8.MaxValue = (UINT8) Maximum;
MinMaxStep.u8.Step = (UINT8) Step;
break;
case EFI_IFR_NUMERIC_SIZE_2:
MinMaxStep.u16.MinValue = (UINT16) Minimum;
MinMaxStep.u16.MaxValue = (UINT16) Maximum;
MinMaxStep.u16.Step = (UINT16) Step;
break;
case EFI_IFR_NUMERIC_SIZE_4:
MinMaxStep.u32.MinValue = (UINT32) Minimum;
MinMaxStep.u32.MaxValue = (UINT32) Maximum;
MinMaxStep.u32.Step = (UINT32) Step;
break;
case EFI_IFR_NUMERIC_SIZE_8:
MinMaxStep.u64.MinValue = Minimum;
MinMaxStep.u64.MaxValue = Maximum;
MinMaxStep.u64.Step = Step;
break;
}
CopyMem (&Numeric.data, &MinMaxStep, sizeof (MINMAXSTEP_DATA));
LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
CopyMem (LocalBuffer, &Numeric, sizeof (EFI_IFR_NUMERIC));
Data->Offset += sizeof (EFI_IFR_NUMERIC);
DefaultValue.u64 = Default;
Status = CreateDefaultOpCode (&DefaultValue, (UINT8) (NumericFlags & EFI_IFR_NUMERIC_SIZE), Data);
if (EFI_ERROR(Status)) {
return Status;
}
CreateEndOpCode (Data);
return EFI_SUCCESS;
}
EFI_STATUS
CreateStringOpCode (
IN EFI_QUESTION_ID QuestionId,
IN EFI_VARSTORE_ID VarStoreId,
IN UINT16 VarOffset,
IN EFI_STRING_ID Prompt,
IN EFI_STRING_ID Help,
IN UINT8 QuestionFlags,
IN UINT8 StringFlags,
IN UINT8 MinSize,
IN UINT8 MaxSize,
IN OUT EFI_HII_UPDATE_DATA *Data
)
{
EFI_IFR_STRING String;
UINT8 *LocalBuffer;
ASSERT (Data != NULL && Data->Data != NULL);
if (!IsValidQuestionFlags (QuestionFlags) || (StringFlags & (~EFI_IFR_STRING_MULTI_LINE))) {
return EFI_INVALID_PARAMETER;
}
if (Data->Offset + sizeof (EFI_IFR_STRING) > Data->BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
String.Header.OpCode = EFI_IFR_STRING_OP;
String.Header.Length = sizeof (EFI_IFR_STRING);
String.Header.Scope = 0;
String.Question.Header.Prompt = Prompt;
String.Question.Header.Help = Help;
String.Question.QuestionId = QuestionId;
String.Question.VarStoreId = VarStoreId;
String.Question.VarStoreInfo.VarOffset = VarOffset;
String.Question.Flags = QuestionFlags;
String.MinSize = MinSize;
String.MaxSize = MaxSize;
String.Flags = StringFlags;
LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
CopyMem (LocalBuffer, &String, sizeof (EFI_IFR_STRING));
Data->Offset += sizeof (EFI_IFR_STRING);
return EFI_SUCCESS;
}
EFI_STATUS
CreateBannerOpCode (
IN EFI_STRING_ID Title,
IN UINT16 LineNumber,
IN UINT8 Alignment,
IN OUT EFI_HII_UPDATE_DATA *Data
)
{
EFI_IFR_GUID_BANNER Banner;
UINT8 *LocalBuffer;
ASSERT (Data != NULL && Data->Data != NULL);
if (Data->Offset + sizeof (EFI_IFR_GUID_BANNER) > Data->BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
Banner.Header.OpCode = EFI_IFR_GUID_OP;
Banner.Header.Length = sizeof (EFI_IFR_GUID_BANNER);
Banner.Header.Scope = 0;
CopyMem (&Banner.Guid, &mIfrVendorGuid, sizeof (EFI_IFR_GUID));
Banner.ExtendOpCode = EFI_IFR_EXTEND_OP_BANNER;
Banner.Title = Title;
Banner.LineNumber = LineNumber;
Banner.Alignment = Alignment;
LocalBuffer = (UINT8 *) Data->Data + Data->Offset;
CopyMem (LocalBuffer, &Banner, sizeof (EFI_IFR_GUID_BANNER));
Data->Offset += sizeof (EFI_IFR_GUID_BANNER);
return EFI_SUCCESS;
}

681
MdeModulePkg/Library/IfrSupportLib/UefiIfrString.c
View File

@ -1,681 +0,0 @@
/** @file
Copyright (c) 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.
Module Name:
UefiIfrString.c
Abstract:
Common Library Routines to assist to handle String and Language.
**/
#include "UefiIfrLibraryInternal.h"
//
// Lookup table of ISO639-2 3 character language codes to ISO 639-1 2 character language codes
// Each entry is 5 CHAR8 values long. The first 3 CHAR8 values are the ISO 639-2 code.
// The last 2 CHAR8 values are the ISO 639-1 code.
//
CHAR8 Iso639ToRfc3066ConversionTable[] =
"\
aaraa\
abkab\
afraf\
amham\
araar\
asmas\
aymay\
azeaz\
bakba\
belbe\
benbn\
bihbh\
bisbi\
bodbo\
brebr\
bulbg\
catca\
cescs\
corkw\
cosco\
cymcy\
danda\
deude\
dzodz\
ellel\
engen\
epoeo\
estet\
euseu\
faofo\
fasfa\
fijfj\
finfi\
frafr\
fryfy\
gaiga\
gdhgd\
glggl\
grngn\
gujgu\
hauha\
hebhe\
hinhi\
hrvhr\
hunhu\
hyehy\
ikuiu\
ileie\
inaia\
indid\
ipkik\
islis\
itait\
jawjw\
jpnja\
kalkl\
kankn\
kasks\
katka\
kazkk\
khmkm\
kinrw\
kirky\
korko\
kurku\
laolo\
latla\
lavlv\
linln\
litlt\
ltzlb\
malml\
marmr\
mkdmk\
mlgmg\
mltmt\
molmo\
monmn\
mrimi\
msams\
myamy\
nauna\
nepne\
nldnl\
norno\
ocioc\
ormom\
panpa\
polpl\
porpt\
pusps\
quequ\
rohrm\
ronro\
runrn\
rusru\
sagsg\
sansa\
sinsi\
slksk\
slvsl\
smise\
smosm\
snasn\
sndsd\
somso\
sotst\
spaes\
sqisq\
srpsr\
sswss\
sunsu\
swasw\
swesv\
tamta\
tattt\
telte\
tgktg\
tgltl\
thath\
tsnts\
tuktk\
twitw\
uigug\
ukruk\
urdur\
uzbuz\
vievi\
volvo\
wolwo\
xhoxh\
yidyi\
zhaza\
zhozh\
zulzu\
";
/**
Convert language code from RFC3066 to ISO639-2.
@param LanguageRfc3066 RFC3066 language code.
@param LanguageIso639 ISO639-2 language code.
@retval EFI_SUCCESS Language code converted.
@retval EFI_NOT_FOUND Language code not found.
**/
EFI_STATUS
ConvertRfc3066LanguageToIso639Language (
CHAR8 *LanguageRfc3066,
CHAR8 *LanguageIso639
)
{
UINTN Index;
if ((LanguageRfc3066[2] != '-') && (LanguageRfc3066[2] != 0)) {
CopyMem (LanguageIso639, LanguageRfc3066, 3);
return EFI_SUCCESS;
}
for (Index = 0; Iso639ToRfc3066ConversionTable[Index] != 0; Index += 5) {
if (CompareMem (LanguageRfc3066, &Iso639ToRfc3066ConversionTable[Index + 3], 2) == 0) {
CopyMem (LanguageIso639, &Iso639ToRfc3066ConversionTable[Index], 3);
return EFI_SUCCESS;
}
}
return EFI_NOT_FOUND;
}
/**
Convert language code list from RFC3066 to ISO639-2, e.g. "en-US;fr-FR" will
be converted to "engfra".
@param SupportedLanguages The RFC3066 language list.
@return The ISO639-2 language list.
**/
CHAR8 *
Rfc3066ToIso639 (
CHAR8 *SupportedLanguages
)
{
CHAR8 *Languages;
CHAR8 *ReturnValue;
CHAR8 *LangCodes;
CHAR8 LangRfc3066[RFC_3066_ENTRY_SIZE];
CHAR8 LangIso639[ISO_639_2_ENTRY_SIZE];
EFI_STATUS Status;
ReturnValue = AllocateZeroPool (AsciiStrSize (SupportedLanguages));
if (ReturnValue == NULL) {
return ReturnValue;
}
Languages = ReturnValue;
LangCodes = SupportedLanguages;
while (*LangCodes != 0) {
GetNextLanguage (&LangCodes, LangRfc3066);
Status = ConvertRfc3066LanguageToIso639Language (LangRfc3066, LangIso639);
if (!EFI_ERROR (Status)) {
CopyMem (Languages, LangIso639, 3);
Languages = Languages + 3;
}
}
return ReturnValue;
}
/**
Determine what is the current language setting
@param Lang Pointer of system language
@return Status code
**/
EFI_STATUS
GetCurrentLanguage (
OUT CHAR8 *Lang
)
{
EFI_STATUS Status;
UINTN Size;
//
// Get current language setting
//
Size = RFC_3066_ENTRY_SIZE;
Status = gRT->GetVariable (
L"PlatformLang",
&gEfiGlobalVariableGuid,
NULL,
&Size,
Lang
);
if (EFI_ERROR (Status)) {
AsciiStrCpy (Lang, (CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultPlatformLang));
}
return Status;
}
/**
Get next language from language code list (with separator ';').
@param LangCode On input: point to first language in the list. On
output: point to next language in the list, or
NULL if no more language in the list.
@param Lang The first language in the list.
@return None.
**/
VOID
GetNextLanguage (
IN OUT CHAR8 **LangCode,
OUT CHAR8 *Lang
)
{
UINTN Index;
CHAR8 *StringPtr;
if (LangCode == NULL || *LangCode == NULL) {
*Lang = 0;
return;
}
Index = 0;
StringPtr = *LangCode;
while (StringPtr[Index] != 0 && StringPtr[Index] != ';') {
Index++;
}
CopyMem (Lang, StringPtr, Index);
Lang[Index] = 0;
if (StringPtr[Index] == ';') {
Index++;
}
*LangCode = StringPtr + Index;
}
/**
This function returns the list of supported languages, in the format specified
in UEFI specification Appendix<69>M.
@param HiiHandle The HII package list handle.
@return The supported languages.
**/
CHAR8 *
GetSupportedLanguages (
IN EFI_HII_HANDLE HiiHandle
)
{
EFI_STATUS Status;
UINTN BufferSize;
CHAR8 *LanguageString;
LocateHiiProtocols ();
//
// Collect current supported Languages for given HII handle
//
BufferSize = 0x1000;
LanguageString = AllocatePool (BufferSize);
Status = gIfrLibHiiString->GetLanguages (gIfrLibHiiString, HiiHandle, LanguageString, &BufferSize);
if (Status == EFI_BUFFER_TOO_SMALL) {
gBS->FreePool (LanguageString);
LanguageString = AllocatePool (BufferSize);
Status = gIfrLibHiiString->GetLanguages (gIfrLibHiiString, HiiHandle, LanguageString, &BufferSize);
}
if (EFI_ERROR (Status)) {
LanguageString = NULL;
}
return LanguageString;
}
/**
This function returns the number of supported languages
@param HiiHandle The HII package list handle.
@return The number of supported languages.
**/
UINT16
GetSupportedLanguageNumber (
IN EFI_HII_HANDLE HiiHandle
)
{
CHAR8 *Languages;
CHAR8 *LanguageString;
UINT16 LangNumber;
CHAR8 Lang[RFC_3066_ENTRY_SIZE];
Languages = GetSupportedLanguages (HiiHandle);
if (Languages == NULL) {
return 0;
}
LangNumber = 0;
LanguageString = Languages;
while (*LanguageString != 0) {
GetNextLanguage (&LanguageString, Lang);
LangNumber++;
}
gBS->FreePool (Languages);
return LangNumber;
}
/**
Get string specified by StringId form the HiiHandle.
@param HiiHandle The HII handle of package list.
@param StringId The String ID.
@param String The output string.
@retval EFI_NOT_FOUND String is not found.
@retval EFI_SUCCESS Operation is successful.
@retval EFI_OUT_OF_RESOURCES There is not enought memory in the system.
@retval EFI_INVALID_PARAMETER The String is NULL.
**/
EFI_STATUS
GetStringFromHandle (
IN EFI_HII_HANDLE HiiHandle,
IN EFI_STRING_ID StringId,
OUT EFI_STRING *String
)
{
EFI_STATUS Status;
UINTN StringSize;
if (String == NULL) {
return EFI_INVALID_PARAMETER;
}
StringSize = IFR_LIB_DEFAULT_STRING_SIZE;
*String = AllocateZeroPool (StringSize);
if (*String == NULL) {
return EFI_OUT_OF_RESOURCES;
}
Status = IfrLibGetString (HiiHandle, StringId, *String, &StringSize);
if (Status == EFI_BUFFER_TOO_SMALL) {
gBS->FreePool (*String);
*String = AllocateZeroPool (StringSize);
if (*String == NULL) {
return EFI_OUT_OF_RESOURCES;
}
Status = IfrLibGetString (HiiHandle, StringId, *String, &StringSize);
}
return Status;
}
/**
Get the string given the StringId and String package Producer's Guid.
@param ProducerGuid The Guid of String package list.
@param StringId The String ID.
@param String The output string.
@retval EFI_NOT_FOUND String is not found.
@retval EFI_SUCCESS Operation is successful.
@retval EFI_OUT_OF_RESOURCES There is not enought memory in the system.
**/
EFI_STATUS
GetStringFromToken (
IN EFI_GUID *ProducerGuid,
IN EFI_STRING_ID StringId,
OUT EFI_STRING *String
)
{
EFI_STATUS Status;
UINTN Index;
UINTN HandleBufferLen;
EFI_HII_HANDLE *HiiHandleBuffer;
EFI_GUID Guid;
Status = GetHiiHandles (&HandleBufferLen, &HiiHandleBuffer);
if (EFI_ERROR(Status)) {
return Status;
}
for (Index = 0; Index < (HandleBufferLen / sizeof (EFI_HII_HANDLE)); Index++) {
Status = ExtractGuidFromHiiHandle (HiiHandleBuffer[Index], &Guid);
if (EFI_ERROR(Status)) {
return Status;
}
if (CompareGuid (&Guid, ProducerGuid) == TRUE) {
break;
}
}
if (Index >= (HandleBufferLen / sizeof (EFI_HII_HANDLE))) {
Status = EFI_NOT_FOUND;
goto Out;
}
Status = GetStringFromHandle (HiiHandleBuffer[Index], StringId, String);
Out:
if (HiiHandleBuffer != NULL) {
gBS->FreePool (HiiHandleBuffer);
}
return Status;
}
/**
This function adds the string into String Package of each language.
@param PackageList Handle of the package list where this string will
be added.
@param StringId On return, contains the new strings id, which is
unique within PackageList.
@param String Points to the new null-terminated string.
@retval EFI_SUCCESS The new string was added successfully.
@retval EFI_NOT_FOUND The specified PackageList could not be found in
database.
@retval EFI_OUT_OF_RESOURCES Could not add the string due to lack of resources.
@retval EFI_INVALID_PARAMETER String is NULL or StringId is NULL is NULL.
**/
EFI_STATUS
IfrLibNewString (
IN EFI_HII_HANDLE PackageList,
OUT EFI_STRING_ID *StringId,
IN CONST EFI_STRING String
)
{
EFI_STATUS Status;
CHAR8 *Languages;
CHAR8 *LangStrings;
CHAR8 Lang[RFC_3066_ENTRY_SIZE];
Status = EFI_SUCCESS;
LocateHiiProtocols ();
Languages = GetSupportedLanguages (PackageList);
LangStrings = Languages;
while (*LangStrings != 0) {
GetNextLanguage (&LangStrings, Lang);
Status = gIfrLibHiiString->NewString (
gIfrLibHiiString,
PackageList,
StringId,
Lang,
NULL,
String,
NULL
);
if (EFI_ERROR (Status)) {
break;
}
}
gBS->FreePool (Languages);
return Status;
}
/**
This function try to retrieve string from String package of current language.
If fail, it try to retrieve string from String package of first language it support.
@param PackageList The package list in the HII database to search for
the specified string.
@param StringId The string's id, which is unique within
PackageList.
@param String Points to the new null-terminated string.
@param StringSize On entry, points to the size of the buffer pointed
to by String, in bytes. On return, points to the
length of the string, in bytes.
@retval EFI_SUCCESS The string was returned successfully.
@retval EFI_NOT_FOUND The string specified by StringId is not available.
@retval EFI_BUFFER_TOO_SMALL The buffer specified by StringLength is too small
to hold the string.
@retval EFI_INVALID_PARAMETER The String or StringSize was NULL.
**/
EFI_STATUS
IfrLibGetString (
IN EFI_HII_HANDLE PackageList,
IN EFI_STRING_ID StringId,
OUT EFI_STRING String,
IN OUT UINTN *StringSize
)
{
EFI_STATUS Status;
CHAR8 *Languages;
CHAR8 *LangStrings;
CHAR8 Lang[RFC_3066_ENTRY_SIZE];
CHAR8 CurrentLang[RFC_3066_ENTRY_SIZE];
LocateHiiProtocols ();
GetCurrentLanguage (CurrentLang);
Status = gIfrLibHiiString->GetString (
gIfrLibHiiString,
CurrentLang,
PackageList,
StringId,
String,
StringSize,
NULL
);
if (EFI_ERROR (Status) && (Status != EFI_BUFFER_TOO_SMALL)) {
Languages = GetSupportedLanguages (PackageList);
LangStrings = Languages;
GetNextLanguage (&LangStrings, Lang);
gBS->FreePool (Languages);
Status = gIfrLibHiiString->GetString (
gIfrLibHiiString,
Lang,
PackageList,
StringId,
String,
StringSize,
NULL
);
}
return Status;
}
/**
This function updates the string in String package of each language.
@param PackageList The package list containing the strings.
@param StringId The string's id, which is unique within
PackageList.
@param String Points to the new null-terminated string.
@retval EFI_SUCCESS The string was updated successfully.
@retval EFI_NOT_FOUND The string specified by StringId is not in the
database.
@retval EFI_INVALID_PARAMETER The String was NULL.
@retval EFI_OUT_OF_RESOURCES The system is out of resources to accomplish the
task.
**/
EFI_STATUS
IfrLibSetString (
IN EFI_HII_HANDLE PackageList,
IN EFI_STRING_ID StringId,
IN CONST EFI_STRING String
)
{
EFI_STATUS Status;
CHAR8 *Languages;
CHAR8 *LangStrings;
CHAR8 Lang[RFC_3066_ENTRY_SIZE];
Status = EFI_SUCCESS;
LocateHiiProtocols ();
Languages = GetSupportedLanguages (PackageList);
LangStrings = Languages;
while (*LangStrings != 0) {
GetNextLanguage (&LangStrings, Lang);
Status = gIfrLibHiiString->SetString (
gIfrLibHiiString,
PackageList,
StringId,
Lang,
String,
NULL
);
if (EFI_ERROR (Status)) {
break;
}
}
gBS->FreePool (Languages);
return Status;
}

2
MdeModulePkg/MdeModulePkg.dec
View File

@ -35,6 +35,8 @@
RecoveryLib|Include/Library/RecoveryLib.h RecoveryLib|Include/Library/RecoveryLib.h
GenericBdsLib.h|Include/Library/GenericBdsLib.h GenericBdsLib.h|Include/Library/GenericBdsLib.h
PlatDriOverLib|Include/Library/PlatDriOverLib.h PlatDriOverLib|Include/Library/PlatDriOverLib.h
ExtendedHiiLib|Include/Library/ExtendedHiiLib.h
ExtendedIfrSupportLib|Include/Library/ExtendedIfrSupportLib.h
[Guids.common] [Guids.common]

8
MdeModulePkg/MdeModulePkg.dsc
View File

@ -63,6 +63,7 @@
FvbServiceLib|MdeModulePkg/Library/EdkFvbServiceLib/EdkFvbServiceLib.inf FvbServiceLib|MdeModulePkg/Library/EdkFvbServiceLib/EdkFvbServiceLib.inf
ScsiLib|MdePkg/Library/UefiScsiLib/UefiScsiLib.inf ScsiLib|MdePkg/Library/UefiScsiLib/UefiScsiLib.inf
HiiLib|MdePkg/Library/HiiLib/HiiLib.inf HiiLib|MdePkg/Library/HiiLib/HiiLib.inf
ExtendedHiiLib|MdeModulePkg/Library/ExtendedHiiLib/ExtendedHiiLib.inf
UsbLib|MdePkg/Library/UefiUsbLib/UefiUsbLib.inf UsbLib|MdePkg/Library/UefiUsbLib/UefiUsbLib.inf
NetLib|MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf NetLib|MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf
IpIoLib|MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf IpIoLib|MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf
@ -70,13 +71,13 @@
DpcLib|MdeModulePkg/Library/DxeDpcLib/DxeDpcLib.inf DpcLib|MdeModulePkg/Library/DxeDpcLib/DxeDpcLib.inf
PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
GraphicsLib|MdeModulepkg/Library/GraphicsLib/GraphicsLib.inf GraphicsLib|MdeModulepkg/Library/GraphicsLib/GraphicsLib.inf
IfrSupportLib|MdeModulePkg/Library/IfrSupportLib/IfrSupportLib.inf IfrSupportLib|MdePkg/Library/IfrSupportLib/IfrSupportLib.inf
ExtendedIfrSupportLib|MdeModulePkg/Library/ExtendedIfrSupportLib/ExtendedIfrSupportLib.inf
CapsuleLib|MdeModulePkg/Library/DxeCapsuleLibNull/DxeCapsuleLibNull.inf CapsuleLib|MdeModulePkg/Library/DxeCapsuleLibNull/DxeCapsuleLibNull.inf
DxePiLib|MdePkg/Library/DxePiLib/DxePiLib.inf DxePiLib|MdePkg/Library/DxePiLib/DxePiLib.inf
PlatformBdsLib|MdeModulePkg/Library/PlatformBdsLibNull/PlatformBdsLibNull.inf PlatformBdsLib|MdeModulePkg/Library/PlatformBdsLibNull/PlatformBdsLibNull.inf
GenericBdsLib|MdeModulePkg/Library/GenericBdsLib/GenericBdsLib.inf GenericBdsLib|MdeModulePkg/Library/GenericBdsLib/GenericBdsLib.inf
GraphicsLib|MdeModulepkg/Library/GraphicsLib/GraphicsLib.inf GraphicsLib|MdeModulepkg/Library/GraphicsLib/GraphicsLib.inf
IfrSupportLib|MdeModulePkg/Library/IfrSupportLib/IfrSupportLib.inf
DxePiLib|MdePkg/Library/DxePiLib/DxePiLib.inf DxePiLib|MdePkg/Library/DxePiLib/DxePiLib.inf
PlatformBdsLib|MdeModulePkg/Library/PlatformBdsLibNull/PlatformBdsLibNull.inf PlatformBdsLib|MdeModulePkg/Library/PlatformBdsLibNull/PlatformBdsLibNull.inf
GenericBdsLib|MdeModulePkg/Library/GenericBdsLib/GenericBdsLib.inf GenericBdsLib|MdeModulePkg/Library/GenericBdsLib/GenericBdsLib.inf
@ -269,9 +270,10 @@
MdeModulePkg/Library/PeiS3LibNull/PeiS3LibNull.inf MdeModulePkg/Library/PeiS3LibNull/PeiS3LibNull.inf
MdeModulePkg/Library/PeiRecoveryLibNull/PeiRecoveryLibNull.inf MdeModulePkg/Library/PeiRecoveryLibNull/PeiRecoveryLibNull.inf
MdeModulePkg/Library/IfrSupportLib/IfrSupportLib.inf
MdeModulePkg/Library/GenericBdsLib/GenericBdsLib.inf MdeModulePkg/Library/GenericBdsLib/GenericBdsLib.inf
MdeModulepkg/Library/GraphicsLib/GraphicsLib.inf MdeModulepkg/Library/GraphicsLib/GraphicsLib.inf
MdeModulePkg/Library/ExtendedHiiLib/ExtendedHiiLib.inf
MdeModulePkg/Library/ExtendedIfrSupportLib/ExtendedIfrSupportLib.inf
MdeModulePkg/Library/PlatformBdsLibNull/PlatformBdsLibNull.inf MdeModulePkg/Library/PlatformBdsLibNull/PlatformBdsLibNull.inf

3
MdeModulePkg/Universal/BdsDxe/Bds.h
View File

@ -70,6 +70,7 @@ Revision History
#include <Library/PerformanceLib.h> #include <Library/PerformanceLib.h>
#include <Library/ReportStatusCodeLib.h> #include <Library/ReportStatusCodeLib.h>
#include <Library/IfrSupportLib.h> #include <Library/IfrSupportLib.h>
#include <Library/ExtendedIfrSupportLib.h>
#include <Library/UefiRuntimeServicesTableLib.h> #include <Library/UefiRuntimeServicesTableLib.h>
#include <Library/HobLib.h> #include <Library/HobLib.h>
#include <Library/BaseLib.h> #include <Library/BaseLib.h>
@ -77,6 +78,8 @@ Revision History
#include <Library/PcdLib.h> #include <Library/PcdLib.h>
#include <Library/CapsuleLib.h> #include <Library/CapsuleLib.h>
#include <Library/HiiLib.h> #include <Library/HiiLib.h>
#include <Library/ExtendedHiiLib.h>
#include <Library/GenericBdsLib.h> #include <Library/GenericBdsLib.h>
#include <Library/PlatformBdsLib.h> #include <Library/PlatformBdsLib.h>

2
MdeModulePkg/Universal/BdsDxe/BdsDxe.inf
View File

@ -88,6 +88,7 @@
HobLib HobLib
UefiRuntimeServicesTableLib UefiRuntimeServicesTableLib
IfrSupportLib IfrSupportLib
ExtendedIfrSupportLib
GenericBdsLib GenericBdsLib
ReportStatusCodeLib ReportStatusCodeLib
PerformanceLib PerformanceLib
@ -100,6 +101,7 @@
DebugLib DebugLib
PrintLib PrintLib
HiiLib HiiLib
ExtendedHiiLib
UefiDriverEntryPoint UefiDriverEntryPoint
PlatformBdsLib PlatformBdsLib
CapsuleLib CapsuleLib

10
MdeModulePkg/Universal/BdsDxe/BootMaint/BootMaint.c
View File

@ -68,7 +68,7 @@ Returns:
for (Index = 0; Index < MenuOption->MenuNumber; Index++) { for (Index = 0; Index < MenuOption->MenuNumber; Index++) {
NewMenuEntry = BOpt_GetMenuEntry (MenuOption, Index); NewMenuEntry = BOpt_GetMenuEntry (MenuOption, Index);
IfrLibNewString ( HiiLibNewString (
HiiHandle, HiiHandle,
&NewMenuEntry->DisplayStringToken, &NewMenuEntry->DisplayStringToken,
NewMenuEntry->DisplayString NewMenuEntry->DisplayString
@ -77,7 +77,7 @@ Returns:
if (NULL == NewMenuEntry->HelpString) { if (NULL == NewMenuEntry->HelpString) {
NewMenuEntry->HelpStringToken = NewMenuEntry->DisplayStringToken; NewMenuEntry->HelpStringToken = NewMenuEntry->DisplayStringToken;
} else { } else {
IfrLibNewString ( HiiLibNewString (
HiiHandle, HiiHandle,
&NewMenuEntry->HelpStringToken, &NewMenuEntry->HelpStringToken,
NewMenuEntry->HelpString NewMenuEntry->HelpString
@ -885,7 +885,7 @@ Returns:
// //
// Post our Boot Maint VFR binnary to the HII database. // Post our Boot Maint VFR binnary to the HII database.
// //
PackageList = PreparePackageList (2, &mBootMaintGuid, BmBin, BdsStrings); PackageList = HiiLibPreparePackageList (2, &mBootMaintGuid, BmBin, BdsStrings);
ASSERT (PackageList != NULL); ASSERT (PackageList != NULL);
Status = gHiiDatabase->NewPackageList ( Status = gHiiDatabase->NewPackageList (
@ -899,7 +899,7 @@ Returns:
// //
// Post our File Explorer VFR binary to the HII database. // Post our File Explorer VFR binary to the HII database.
// //
PackageList = PreparePackageList (2, &mFileExplorerGuid, FEBin, BdsStrings); PackageList = HiiLibPreparePackageList (2, &mFileExplorerGuid, FEBin, BdsStrings);
ASSERT (PackageList != NULL); ASSERT (PackageList != NULL);
Status = gHiiDatabase->NewPackageList ( Status = gHiiDatabase->NewPackageList (
@ -1124,7 +1124,7 @@ Returns:
// //
NextListNode = EfiAllocateZeroPool (sizeof (STRING_LIST_NODE)); NextListNode = EfiAllocateZeroPool (sizeof (STRING_LIST_NODE));
IfrLibNewString (CallbackData->BmmHiiHandle, &(NextListNode->StringToken), L" "); HiiLibNewString (CallbackData->BmmHiiHandle, &(NextListNode->StringToken), L" ");
ASSERT (NextListNode->StringToken != 0); ASSERT (NextListNode->StringToken != 0);
StringDepository->TotalNodeNumber++; StringDepository->TotalNodeNumber++;

6
MdeModulePkg/Universal/BdsDxe/BootMaint/UpdatePage.c
View File

@ -688,7 +688,7 @@ Returns:
UnicodeValueToString (RowString, 0, Row, 0); UnicodeValueToString (RowString, 0, Row, 0);
StrCat (ModeString, RowString); StrCat (ModeString, RowString);
IfrLibNewString (CallbackData->BmmHiiHandle, &ModeToken[Index], ModeString); HiiLibNewString (CallbackData->BmmHiiHandle, &ModeToken[Index], ModeString);
IfrOptionList[Index].StringToken = ModeToken[Index]; IfrOptionList[Index].StringToken = ModeToken[Index];
IfrOptionList[Index].Value.u16 = (UINT16) Mode; IfrOptionList[Index].Value.u16 = (UINT16) Mode;
@ -1142,11 +1142,11 @@ UpdateSetLegacyDeviceOrderPage (
// //
UnicodeSPrint (String, sizeof (String), TypeStr, Index); UnicodeSPrint (String, sizeof (String), TypeStr, Index);
StrRef = 0; StrRef = 0;
IfrLibNewString (CallbackData->BmmHiiHandle, &StrRef, String); HiiLibNewString (CallbackData->BmmHiiHandle, &StrRef, String);
UnicodeSPrint (String, sizeof (String), TypeStrHelp, Index); UnicodeSPrint (String, sizeof (String), TypeStrHelp, Index);
StrRefHelp = 0; StrRefHelp = 0;
IfrLibNewString (CallbackData->BmmHiiHandle, &StrRefHelp, String); HiiLibNewString (CallbackData->BmmHiiHandle, &StrRefHelp, String);
CreateOneOfOpCode ( CreateOneOfOpCode (
(EFI_QUESTION_ID) (Key + Index), (EFI_QUESTION_ID) (Key + Index),

8
MdeModulePkg/Universal/BdsDxe/BootMaint/Variable.c
View File

@ -601,13 +601,13 @@ Var_UpdateDriverOption (
CallbackData, CallbackData,
DriverOptionStrDepository DriverOptionStrDepository
); );
IfrLibNewString (HiiHandle, &NewMenuEntry->DisplayStringToken, NewMenuEntry->DisplayString); HiiLibNewString (HiiHandle, &NewMenuEntry->DisplayStringToken, NewMenuEntry->DisplayString);
NewMenuEntry->HelpStringToken = GetStringTokenFromDepository ( NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
CallbackData, CallbackData,
DriverOptionHelpStrDepository DriverOptionHelpStrDepository
); );
IfrLibNewString (HiiHandle, &NewMenuEntry->HelpStringToken, NewMenuEntry->HelpString); HiiLibNewString (HiiHandle, &NewMenuEntry->HelpStringToken, NewMenuEntry->HelpString);
if (OptionalDataExist) { if (OptionalDataExist) {
Ptr += (UINT8) GetDevicePathSize (CallbackData->LoadContext->FilePathList); Ptr += (UINT8) GetDevicePathSize (CallbackData->LoadContext->FilePathList);
@ -759,13 +759,13 @@ Var_UpdateBootOption (
CallbackData, CallbackData,
BootOptionStrDepository BootOptionStrDepository
); );
IfrLibNewString (CallbackData->FeHiiHandle, &NewMenuEntry->DisplayStringToken, NewMenuEntry->DisplayString); HiiLibNewString (CallbackData->FeHiiHandle, &NewMenuEntry->DisplayStringToken, NewMenuEntry->DisplayString);
NewMenuEntry->HelpStringToken = GetStringTokenFromDepository ( NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
CallbackData, CallbackData,
BootOptionHelpStrDepository BootOptionHelpStrDepository
); );
IfrLibNewString (CallbackData->FeHiiHandle, &NewMenuEntry->HelpStringToken, NewMenuEntry->HelpString); HiiLibNewString (CallbackData->FeHiiHandle, &NewMenuEntry->HelpStringToken, NewMenuEntry->HelpString);
if (OptionalDataExist) { if (OptionalDataExist) {
Ptr += (UINT8) GetDevicePathSize (CallbackData->LoadContext->FilePathList); Ptr += (UINT8) GetDevicePathSize (CallbackData->LoadContext->FilePathList);

6
MdeModulePkg/Universal/BdsDxe/BootMngr/BootManager.c
View File

@ -151,7 +151,7 @@ Returns:
// //
// Publish our HII data // Publish our HII data
// //
PackageList = PreparePackageList (2, &mBootManagerGuid, BootManagerVfrBin, BdsStrings); PackageList = HiiLibPreparePackageList (2, &mBootManagerGuid, BootManagerVfrBin, BdsStrings);
ASSERT (PackageList != NULL); ASSERT (PackageList != NULL);
Status = gHiiDatabase->NewPackageList ( Status = gHiiDatabase->NewPackageList (
@ -246,7 +246,7 @@ Returns:
continue; continue;
} }
IfrLibNewString (HiiHandle, &Token, Option->Description); HiiLibNewString (HiiHandle, &Token, Option->Description);
TempStr = DevicePathToStr (Option->DevicePath); TempStr = DevicePathToStr (Option->DevicePath);
TempSize = StrSize (TempStr); TempSize = StrSize (TempStr);
@ -254,7 +254,7 @@ Returns:
StrCat (HelpString, L"Device Path : "); StrCat (HelpString, L"Device Path : ");
StrCat (HelpString, TempStr); StrCat (HelpString, TempStr);
IfrLibNewString (HiiHandle, &HelpToken, HelpString); HiiLibNewString (HiiHandle, &HelpToken, HelpString);
CreateActionOpCode ( CreateActionOpCode (
mKeyInput, mKeyInput,

16
MdeModulePkg/Universal/BdsDxe/DeviceMngr/DeviceManager.c
View File

@ -162,7 +162,7 @@ Returns:
// //
// Publish our HII data // Publish our HII data
// //
PackageList = PreparePackageList (2, &mDeviceManagerGuid, DeviceManagerVfrBin, BdsStrings); PackageList = HiiLibPreparePackageList (2, &mDeviceManagerGuid, DeviceManagerVfrBin, BdsStrings);
ASSERT (PackageList != NULL); ASSERT (PackageList != NULL);
Status = gHiiDatabase->NewPackageList ( Status = gHiiDatabase->NewPackageList (
@ -251,7 +251,7 @@ Returns:
// //
// Get all the Hii handles // Get all the Hii handles
// //
Status = GetHiiHandles (&HandleBufferLength, &HiiHandles); Status = HiiLibGetHiiHandles (&HandleBufferLength, &HiiHandles);
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
HiiHandle = gDeviceManagerPrivate.HiiHandle; HiiHandle = gDeviceManagerPrivate.HiiHandle;
@ -265,7 +265,7 @@ Returns:
// //
NumberOfHiiHandles = HandleBufferLength / sizeof (EFI_HII_HANDLE); NumberOfHiiHandles = HandleBufferLength / sizeof (EFI_HII_HANDLE);
for (Index = 0; Index < NumberOfHiiHandles; Index++) { for (Index = 0; Index < NumberOfHiiHandles; Index++) {
HiiLibExtractClassFromHiiHandle (HiiHandles[Index], &FormSetClass, &FormSetTitle, &FormSetHelp); IfrLibExtractClassFromHiiHandle (HiiHandles[Index], &FormSetClass, &FormSetTitle, &FormSetHelp);
if (FormSetClass == EFI_NON_DEVICE_CLASS) { if (FormSetClass == EFI_NON_DEVICE_CLASS) {
continue; continue;
@ -274,14 +274,14 @@ Returns:
Token = 0; Token = 0;
*String = 0; *String = 0;
StringLength = 0x1000; StringLength = 0x1000;
IfrLibGetString (HiiHandles[Index], FormSetTitle, String, &StringLength); HiiLibGetString (HiiHandles[Index], FormSetTitle, String, &StringLength);
IfrLibNewString (HiiHandle, &Token, String); HiiLibNewString (HiiHandle, &Token, String);
TokenHelp = 0; TokenHelp = 0;
*String = 0; *String = 0;
StringLength = 0x1000; StringLength = 0x1000;
IfrLibGetString (HiiHandles[Index], FormSetHelp, String, &StringLength); HiiLibGetString (HiiHandles[Index], FormSetHelp, String, &StringLength);
IfrLibNewString (HiiHandle, &TokenHelp, String); HiiLibNewString (HiiHandle, &TokenHelp, String);
for (Count = 0; Count < MENU_ITEM_NUM; Count++) { for (Count = 0; Count < MENU_ITEM_NUM; Count++) {
if (FormSetClass & mDeviceManagerMenuItemTable[Count].Class) { if (FormSetClass & mDeviceManagerMenuItemTable[Count].Class) {
@ -413,7 +413,7 @@ Returns:
// Cleanup dynamic created strings in HII database by reinstall the packagelist // Cleanup dynamic created strings in HII database by reinstall the packagelist
// //
gHiiDatabase->RemovePackageList (gHiiDatabase, HiiHandle); gHiiDatabase->RemovePackageList (gHiiDatabase, HiiHandle);
PackageList = PreparePackageList (2, &mDeviceManagerGuid, DeviceManagerVfrBin, BdsStrings); PackageList = HiiLibPreparePackageList (2, &mDeviceManagerGuid, DeviceManagerVfrBin, BdsStrings);
ASSERT (PackageList != NULL); ASSERT (PackageList != NULL);
Status = gHiiDatabase->NewPackageList ( Status = gHiiDatabase->NewPackageList (
gHiiDatabase, gHiiDatabase,

26
MdeModulePkg/Universal/BdsDxe/FrontPage.c
View File

@ -174,13 +174,13 @@ FrontPageCallback (
// //
// Collect the languages from what our current Language support is based on our VFR // Collect the languages from what our current Language support is based on our VFR
// //
LanguageString = GetSupportedLanguages (gFrontPagePrivate.HiiHandle); LanguageString = HiiLibGetSupportedLanguages (gFrontPagePrivate.HiiHandle);
ASSERT (LanguageString != NULL); ASSERT (LanguageString != NULL);
Index = 0; Index = 0;
LangCode = LanguageString; LangCode = LanguageString;
while (*LangCode != 0) { while (*LangCode != 0) {
GetNextLanguage (&LangCode, Lang); HiiLibGetNextLanguage (&LangCode, Lang);
if (Index == Value->u8) { if (Index == Value->u8) {
break; break;
@ -335,7 +335,7 @@ Returns:
// //
// Publish our HII data // Publish our HII data
// //
PackageList = PreparePackageList (2, &mFrontPageGuid, FrontPageVfrBin, BdsStrings); PackageList = HiiLibPreparePackageList (2, &mFrontPageGuid, FrontPageVfrBin, BdsStrings);
ASSERT (PackageList != NULL); ASSERT (PackageList != NULL);
Status = gHiiDatabase->NewPackageList ( Status = gHiiDatabase->NewPackageList (
@ -353,7 +353,7 @@ Returns:
// //
// Get current language setting // Get current language setting
// //
GetCurrentLanguage (CurrentLang); HiiLibGetCurrentLanguage (CurrentLang);
// //
// Allocate space for creation of UpdateData Buffer // Allocate space for creation of UpdateData Buffer
@ -369,13 +369,13 @@ Returns:
// Collect the languages from what our current Language support is based on our VFR // Collect the languages from what our current Language support is based on our VFR
// //
HiiHandle = gFrontPagePrivate.HiiHandle; HiiHandle = gFrontPagePrivate.HiiHandle;
LanguageString = GetSupportedLanguages (HiiHandle); LanguageString = HiiLibGetSupportedLanguages (HiiHandle);
ASSERT (LanguageString != NULL); ASSERT (LanguageString != NULL);
OptionCount = 0; OptionCount = 0;
LangCode = LanguageString; LangCode = LanguageString;
while (*LangCode != 0) { while (*LangCode != 0) {
GetNextLanguage (&LangCode, Lang); HiiLibGetNextLanguage (&LangCode, Lang);
if (gFrontPagePrivate.LanguageToken == NULL) { if (gFrontPagePrivate.LanguageToken == NULL) {
// //
@ -409,7 +409,7 @@ Returns:
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
Token = 0; Token = 0;
Status = IfrLibNewString (HiiHandle, &Token, StringBuffer); Status = HiiLibNewString (HiiHandle, &Token, StringBuffer);
FreePool (StringBuffer); FreePool (StringBuffer);
} else { } else {
Token = gFrontPagePrivate.LanguageToken[OptionCount]; Token = gFrontPagePrivate.LanguageToken[OptionCount];
@ -542,7 +542,7 @@ Returns:
{ {
EFI_STATUS Status; EFI_STATUS Status;
Status = GetStringFromToken (ProducerGuid, Token, String); Status = HiiLibGetStringFromToken (ProducerGuid, Token, String);
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
*String = GetStringById (STRING_TOKEN (STR_MISSING_STRING)); *String = GetStringById (STRING_TOKEN (STR_MISSING_STRING));
} }
@ -677,7 +677,7 @@ Returns:
BiosVendor = (EFI_MISC_BIOS_VENDOR_DATA *) (DataHeader + 1); BiosVendor = (EFI_MISC_BIOS_VENDOR_DATA *) (DataHeader + 1);
GetProducerString (&Record->ProducerName, BiosVendor->BiosVersion, &NewString); GetProducerString (&Record->ProducerName, BiosVendor->BiosVersion, &NewString);
TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_BIOS_VERSION); TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_BIOS_VERSION);
IfrLibSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString); HiiLibSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString);
FreePool (NewString); FreePool (NewString);
Find[0] = TRUE; Find[0] = TRUE;
} }
@ -688,7 +688,7 @@ Returns:
SystemManufacturer = (EFI_MISC_SYSTEM_MANUFACTURER_DATA *) (DataHeader + 1); SystemManufacturer = (EFI_MISC_SYSTEM_MANUFACTURER_DATA *) (DataHeader + 1);
GetProducerString (&Record->ProducerName, SystemManufacturer->SystemProductName, &NewString); GetProducerString (&Record->ProducerName, SystemManufacturer->SystemProductName, &NewString);
TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_COMPUTER_MODEL); TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_COMPUTER_MODEL);
IfrLibSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString); HiiLibSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString);
FreePool (NewString); FreePool (NewString);
Find[1] = TRUE; Find[1] = TRUE;
} }
@ -699,7 +699,7 @@ Returns:
ProcessorVersion = (EFI_PROCESSOR_VERSION_DATA *) (DataHeader + 1); ProcessorVersion = (EFI_PROCESSOR_VERSION_DATA *) (DataHeader + 1);
GetProducerString (&Record->ProducerName, *ProcessorVersion, &NewString); GetProducerString (&Record->ProducerName, *ProcessorVersion, &NewString);
TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_CPU_MODEL); TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_CPU_MODEL);
IfrLibSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString); HiiLibSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString);
FreePool (NewString); FreePool (NewString);
Find[2] = TRUE; Find[2] = TRUE;
} }
@ -710,7 +710,7 @@ Returns:
ProcessorFrequency = (EFI_PROCESSOR_CORE_FREQUENCY_DATA *) (DataHeader + 1); ProcessorFrequency = (EFI_PROCESSOR_CORE_FREQUENCY_DATA *) (DataHeader + 1);
ConvertProcessorToString (ProcessorFrequency, &NewString); ConvertProcessorToString (ProcessorFrequency, &NewString);
TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_CPU_SPEED); TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_CPU_SPEED);
IfrLibSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString); HiiLibSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString);
FreePool (NewString); FreePool (NewString);
Find[3] = TRUE; Find[3] = TRUE;
} }
@ -724,7 +724,7 @@ Returns:
&NewString &NewString
); );
TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_MEMORY_SIZE); TokenToUpdate = STRING_TOKEN (STR_FRONT_PAGE_MEMORY_SIZE);
IfrLibSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString); HiiLibSetString (gFrontPagePrivate.HiiHandle, TokenToUpdate, NewString);
FreePool (NewString); FreePool (NewString);
Find[4] = TRUE; Find[4] = TRUE;
} }

4
MdeModulePkg/Universal/BdsDxe/Language.c
View File

@ -33,7 +33,7 @@ EFI_GUID mFontPackageGuid = {
typedef struct { typedef struct {
// //
// This 4-bytes total array length is required by PreparePackageList() // This 4-bytes total array length is required by HiiLibPreparePackageList()
// //
UINT32 Length; UINT32 Length;
@ -288,7 +288,7 @@ Returns:
return ; return ;
} }
PackageList = PreparePackageList (1, &mFontPackageGuid, &mFontBin); PackageList = HiiLibPreparePackageList (1, &mFontPackageGuid, &mFontBin);
ASSERT (PackageList != NULL); ASSERT (PackageList != NULL);
gHiiDatabase->NewPackageList (gHiiDatabase, PackageList, DriverHandle, &HiiHandle); gHiiDatabase->NewPackageList (gHiiDatabase, PackageList, DriverHandle, &HiiHandle);

4
MdeModulePkg/Universal/BdsDxe/String.c
View File

@ -63,7 +63,7 @@ Returns:
return Status; return Status;
} }
PackageList = PreparePackageList (1, &mBdsStringPackGuid, &BdsStrings); PackageList = HiiLibPreparePackageList (1, &mBdsStringPackGuid, &BdsStrings);
ASSERT (PackageList != NULL); ASSERT (PackageList != NULL);
Status = gHiiDatabase->NewPackageList ( Status = gHiiDatabase->NewPackageList (
@ -98,7 +98,7 @@ Returns:
CHAR16 *String; CHAR16 *String;
String = NULL; String = NULL;
GetStringFromHandle (gStringPackHandle, Id, &String); HiiLibGetStringFromHandle (gStringPackHandle, Id, &String);
return String; return String;
} }

4
MdeModulePkg/Universal/Console/GraphicsConsoleDxe/GraphicsConsole.c
View File

@ -619,10 +619,8 @@ GraphicsConsoleControllerDriverStop (
// Remove the font pack // Remove the font pack
// //
#if 1 #if 1
Status = HiiLibRemovePackagesFromHiiDatabase (Private->HiiHandle); HiiLibRemovePackages (Private->HiiHandle);
if (!EFI_ERROR (Status)) {
mFirstAccessFlag = TRUE; mFirstAccessFlag = TRUE;
}
#else #else
mHii->RemovePack (mHii, Private->HiiHandle); mHii->RemovePack (mHii, Private->HiiHandle);
#endif #endif

12
MdeModulePkg/Universal/DriverSampleDxe/DriverSample.c
View File

@ -111,7 +111,7 @@ ValidatePassword (
Password = AllocateZeroPool (BufferSize); Password = AllocateZeroPool (BufferSize);
ASSERT (Password != NULL); ASSERT (Password != NULL);
Status = IfrLibGetString (PrivateData->HiiHandle[0], StringId, Password, &BufferSize); Status = HiiLibGetString (PrivateData->HiiHandle[0], StringId, Password, &BufferSize);
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
gBS->FreePool (Password); gBS->FreePool (Password);
return Status; return Status;
@ -169,7 +169,7 @@ SetPassword (
// //
Password = &PrivateData->Configuration.WhatIsThePassword2[0]; Password = &PrivateData->Configuration.WhatIsThePassword2[0];
ZeroMem (Password, 20 * sizeof (CHAR16)); ZeroMem (Password, 20 * sizeof (CHAR16));
Status = IfrLibGetString (PrivateData->HiiHandle[0], StringId, Password, &BufferSize); Status = HiiLibGetString (PrivateData->HiiHandle[0], StringId, Password, &BufferSize);
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
return Status; return Status;
} }
@ -646,7 +646,7 @@ DriverSampleInit (
// //
// Publish our HII data // Publish our HII data
// //
PackageList = PreparePackageList ( PackageList = HiiLibPreparePackageList (
2, 2,
&mFormSetGuid, &mFormSetGuid,
DriverSampleStrings, DriverSampleStrings,
@ -677,7 +677,7 @@ DriverSampleInit (
} }
PrivateData->DriverHandle[1] = DriverHandle[1]; PrivateData->DriverHandle[1] = DriverHandle[1];
PackageList = PreparePackageList ( PackageList = HiiLibPreparePackageList (
2, 2,
&mInventoryGuid, &mInventoryGuid,
DriverSampleStrings, DriverSampleStrings,
@ -705,7 +705,7 @@ DriverSampleInit (
// //
NewString = L"700 Mhz"; NewString = L"700 Mhz";
Status = IfrLibSetString (HiiHandle[0], STRING_TOKEN (STR_CPU_STRING2), NewString); Status = HiiLibSetString (HiiHandle[0], STRING_TOKEN (STR_CPU_STRING2), NewString);
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
return Status; return Status;
} }
@ -732,7 +732,7 @@ DriverSampleInit (
// based on default values stored in IFR // based on default values stored in IFR
// //
BufferSize = sizeof (DRIVER_SAMPLE_CONFIGURATION); BufferSize = sizeof (DRIVER_SAMPLE_CONFIGURATION);
Status = ExtractDefault (Configuration, &BufferSize, 1, VfrMyIfrNVDataDefault0000); Status = IfrLibExtractDefault (Configuration, &BufferSize, 1, VfrMyIfrNVDataDefault0000);
if (!EFI_ERROR (Status)) { if (!EFI_ERROR (Status)) {
gRT->SetVariable( gRT->SetVariable(

6
MdeModulePkg/Universal/DriverSampleDxe/DriverSample.h
View File

@ -39,7 +39,9 @@ Revision History
#include <Library/UefiBootServicesTableLib.h> #include <Library/UefiBootServicesTableLib.h>
#include <Library/MemoryAllocationLib.h> #include <Library/MemoryAllocationLib.h>
#include <Library/IfrSupportLib.h> #include <Library/IfrSupportLib.h>
#include <Library/ExtendedIfrSupportLib.h>
#include <Library/HiiLib.h> #include <Library/HiiLib.h>
#include <Library/ExtendedHiiLib.h>
#include <MdeModuleHii.h> #include <MdeModuleHii.h>
@ -53,7 +55,7 @@ extern UINT8 VfrMyIfrNVDataDefault0000[];
// //
// This is the generated IFR binary data for each formset defined in VFR. // This is the generated IFR binary data for each formset defined in VFR.
// This data array is ready to be used as input of PreparePackageList() to // This data array is ready to be used as input of HiiLibPreparePackageList() to
// create a packagelist (which contains Form packages, String packages, etc). // create a packagelist (which contains Form packages, String packages, etc).
// //
extern UINT8 VfrBin[]; extern UINT8 VfrBin[];
@ -61,7 +63,7 @@ extern UINT8 InventoryBin[];
// //
// This is the generated String package data for all .UNI files. // This is the generated String package data for all .UNI files.
// This data array is ready to be used as input of PreparePackageList() to // This data array is ready to be used as input of HiiLibPreparePackageList() to
// create a packagelist (which contains Form packages, String packages, etc). // create a packagelist (which contains Form packages, String packages, etc).
// //
extern UINT8 DriverSampleStrings[]; extern UINT8 DriverSampleStrings[];

2
MdeModulePkg/Universal/DriverSampleDxe/DriverSampleDxe.inf
View File

@ -56,6 +56,8 @@
DebugLib DebugLib
HiiLib HiiLib
IfrSupportLib IfrSupportLib
ExtendedHiiLib
ExtendedIfrSupportLib
BaseLib BaseLib

8
MdeModulePkg/Universal/Network/IScsiDxe/IScsiConfig.c
View File

@ -700,7 +700,7 @@ IScsiFormCallback (
UnicodeSPrint (PortString, (UINTN) 128, L"Port %s", ConfigFormEntry->MacString); UnicodeSPrint (PortString, (UINTN) 128, L"Port %s", ConfigFormEntry->MacString);
DeviceFormTitleToken = (STRING_REF) STR_ISCSI_DEVICE_FORM_TITLE; DeviceFormTitleToken = (STRING_REF) STR_ISCSI_DEVICE_FORM_TITLE;
IfrLibSetString (Private->RegisteredHandle, DeviceFormTitleToken, PortString); HiiLibSetString (Private->RegisteredHandle, DeviceFormTitleToken, PortString);
IScsiConvertDeviceConfigDataToIfrNvData (ConfigFormEntry, IfrNvData); IScsiConvertDeviceConfigDataToIfrNvData (ConfigFormEntry, IfrNvData);
@ -832,13 +832,13 @@ Returns:
// Compose the Port string and create a new STRING_REF. // Compose the Port string and create a new STRING_REF.
// //
UnicodeSPrint (PortString, 128, L"Port %s", ConfigFormEntry->MacString); UnicodeSPrint (PortString, 128, L"Port %s", ConfigFormEntry->MacString);
IfrLibNewString (mCallbackInfo->RegisteredHandle, &ConfigFormEntry->PortTitleToken, PortString); HiiLibNewString (mCallbackInfo->RegisteredHandle, &ConfigFormEntry->PortTitleToken, PortString);
// //
// Compose the help string of this port and create a new STRING_REF. // Compose the help string of this port and create a new STRING_REF.
// //
UnicodeSPrint (PortString, 128, L"Set the iSCSI parameters on port %s", ConfigFormEntry->MacString); UnicodeSPrint (PortString, 128, L"Set the iSCSI parameters on port %s", ConfigFormEntry->MacString);
IfrLibNewString (mCallbackInfo->RegisteredHandle, &ConfigFormEntry->PortTitleHelpToken, PortString); HiiLibNewString (mCallbackInfo->RegisteredHandle, &ConfigFormEntry->PortTitleHelpToken, PortString);
NetListInsertTail (&mIScsiConfigFormList, &ConfigFormEntry->Link); NetListInsertTail (&mIScsiConfigFormList, &ConfigFormEntry->Link);
mNumberOfIScsiDevices++; mNumberOfIScsiDevices++;
@ -958,7 +958,7 @@ Returns:
// //
// Publish our HII data // Publish our HII data
// //
PackageList = PreparePackageList (2, &mVendorGuid, IScsiDxeStrings, IScsiConfigDxeBin); PackageList = HiiLibPreparePackageList (2, &mVendorGuid, IScsiDxeStrings, IScsiConfigDxeBin);
ASSERT (PackageList != NULL); ASSERT (PackageList != NULL);
Status = HiiDatabase->NewPackageList ( Status = HiiDatabase->NewPackageList (

2
MdeModulePkg/Universal/Network/IScsiDxe/IScsiConfig.h
View File

@ -22,7 +22,9 @@ Abstract:
#define _ISCSI_CONFIG_H_ #define _ISCSI_CONFIG_H_
#include <Library/HiiLib.h> #include <Library/HiiLib.h>
#include <Library/ExtendedHiiLib.h>
#include <Library/IfrSupportLib.h> #include <Library/IfrSupportLib.h>
#include <Library/ExtendedIfrSupportLib.h>
#include <Library/DebugLib.h> #include <Library/DebugLib.h>
#include <Library/BaseLib.h> #include <Library/BaseLib.h>
#include <Library/NetLib.h> #include <Library/NetLib.h>

2
MdeModulePkg/Universal/Network/IScsiDxe/IScsiDxe.inf
View File

@ -79,6 +79,8 @@
PrintLib PrintLib
HiiLib HiiLib
IfrSupportLib IfrSupportLib
ExtendedHiiLib
ExtendedIfrSupportLib
NetLib NetLib
[Protocols] [Protocols]

10
MdeModulePkg/Universal/SetupBrowserDxe/Setup.c
View File

@ -568,7 +568,7 @@ InitializeSetup (
Status = HiiLibCreateHiiDriverHandle (&HiiDriverHandle); Status = HiiLibCreateHiiDriverHandle (&HiiDriverHandle);
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
PackageList = PreparePackageList (1, &gSetupBrowserGuid, SetupBrowserStrings); PackageList = HiiLibPreparePackageList (1, &gSetupBrowserGuid, SetupBrowserStrings);
ASSERT (PackageList != NULL); ASSERT (PackageList != NULL);
Status = mHiiDatabase->NewPackageList ( Status = mHiiDatabase->NewPackageList (
mHiiDatabase, mHiiDatabase,
@ -631,7 +631,7 @@ NewString (
EFI_STATUS Status; EFI_STATUS Status;
StringId = 0; StringId = 0;
Status = IfrLibNewString (HiiHandle, &StringId, String); Status = HiiLibNewString (HiiHandle, &StringId, String);
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
return StringId; return StringId;
@ -656,7 +656,7 @@ DeleteString (
CHAR16 NullChar; CHAR16 NullChar;
NullChar = CHAR_NULL; NullChar = CHAR_NULL;
return IfrLibSetString (HiiHandle, StringId, &NullChar); return HiiLibSetString (HiiHandle, StringId, &NullChar);
} }
@ -687,14 +687,14 @@ GetToken (
String = AllocateZeroPool (BufferLength); String = AllocateZeroPool (BufferLength);
ASSERT (String != NULL); ASSERT (String != NULL);
Status = IfrLibGetString (HiiHandle, Token, String, &BufferLength); Status = HiiLibGetString (HiiHandle, Token, String, &BufferLength);
if (Status == EFI_BUFFER_TOO_SMALL) { if (Status == EFI_BUFFER_TOO_SMALL) {
gBS->FreePool (String); gBS->FreePool (String);
String = AllocateZeroPool (BufferLength); String = AllocateZeroPool (BufferLength);
ASSERT (String != NULL); ASSERT (String != NULL);
Status = IfrLibGetString (HiiHandle, Token, String, &BufferLength); Status = HiiLibGetString (HiiHandle, Token, String, &BufferLength);
} }
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);

2
MdeModulePkg/Universal/SetupBrowserDxe/Setup.h
View File

@ -50,7 +50,9 @@ Revision History
#include <Library/BaseLib.h> #include <Library/BaseLib.h>
#include <Library/MemoryAllocationLib.h> #include <Library/MemoryAllocationLib.h>
#include <Library/IfrSupportLib.h> #include <Library/IfrSupportLib.h>
#include <Library/ExtendedIfrSupportLib.h>
#include <Library/HiiLib.h> #include <Library/HiiLib.h>
#include <Library/ExtendedHiiLib.h>
#include "R8Lib.h" #include "R8Lib.h"

1
MdeModulePkg/Universal/SetupBrowserDxe/SetupBrowserDxe.inf
View File

@ -67,6 +67,7 @@
GraphicsLib GraphicsLib
IfrSupportLib IfrSupportLib
HiiLib HiiLib
ExtendedHiiLib
[Protocols] [Protocols]
gEfiPrintProtocolGuid # PROTOCOL ALWAYS_CONSUMED gEfiPrintProtocolGuid # PROTOCOL ALWAYS_CONSUMED

2
MdeModulePkg/Universal/SetupBrowserDxe/Ui.c
View File

@ -2259,7 +2259,7 @@ UiDisplayMenu (
DevicePath = AllocatePool (BufferSize); DevicePath = AllocatePool (BufferSize);
HexStringToBuffer ((UINT8 *) DevicePath, &BufferSize, StringPtr); HexStringToBuffer ((UINT8 *) DevicePath, &BufferSize, StringPtr);
Selection->Handle = DevicePathToHiiHandle (mHiiDatabase, DevicePath); Selection->Handle = HiiLibDevicePathToHiiHandle (DevicePath);
if (Selection->Handle == NULL) { if (Selection->Handle == NULL) {
// //
// If target Hii Handle not found, exit // If target Hii Handle not found, exit