summaryrefslogtreecommitdiff
path: root/EDK/MiniSetup/BootOnly/EDKhelper.c
diff options
context:
space:
mode:
authorraywu <raywu@aaeon.com.tw>2018-09-13 16:11:56 +0800
committerraywu <raywu@aaeon.com.tw>2018-09-13 16:11:56 +0800
commit31bb486c913795c8b67d1c4dbaae2bdec4943fc9 (patch)
treef0e04ad6fe983d8aa11f0f8a808518e39ab408f1 /EDK/MiniSetup/BootOnly/EDKhelper.c
parent465bdc2f8b32bb4cc1ac2c420086ec79ccbd5f78 (diff)
downloadzprj-31bb486c913795c8b67d1c4dbaae2bdec4943fc9.tar.xz
SLP1.0 / SLP2.0 / Default Password / Logo / Fix Boot Order
Diffstat (limited to 'EDK/MiniSetup/BootOnly/EDKhelper.c')
-rw-r--r--EDK/MiniSetup/BootOnly/EDKhelper.c1737
1 files changed, 1737 insertions, 0 deletions
diff --git a/EDK/MiniSetup/BootOnly/EDKhelper.c b/EDK/MiniSetup/BootOnly/EDKhelper.c
new file mode 100644
index 0000000..b0aabd9
--- /dev/null
+++ b/EDK/MiniSetup/BootOnly/EDKhelper.c
@@ -0,0 +1,1737 @@
+//*****************************************************************//
+//*****************************************************************//
+//*****************************************************************//
+//** **//
+//** (C)Copyright 2010, American Megatrends, Inc. **//
+//** **//
+//** All Rights Reserved. **//
+//** **//
+//** 5555 Oakbrook Pkwy, Building 200,Norcross, Georgia 30093 **//
+//** **//
+//** Phone (770)-246-8600 **//
+//** **//
+//*****************************************************************//
+//*****************************************************************//
+//*****************************************************************//
+// $Archive: /Alaska/SOURCE/Modules/AMITSE2_0/AMITSE/BootOnly/EDKhelper.c $
+//
+// $Author: Arunsb $
+//
+// $Revision: 11 $
+//
+// $Date: 2/11/14 8:14p $
+//
+//*****************************************************************//
+//*****************************************************************//
+// Revision History
+// ----------------
+// $Log: /Alaska/SOURCE/Modules/AMITSE2_0/AMITSE/BootOnly/EDKhelper.c $
+//
+// 11 2/11/14 8:14p Arunsb
+// [TAG] EIP125719
+// [Category] Improvement
+// [Description] The EfiCreateEventReadyToBoot is conflicted under
+// UefiLib.h and EDKhelper.h.
+// [Files] boot.c, EDKhelper.c and EDKHelper.h
+//
+// 10 5/22/13 10:26a Arunsb
+// [TAG] EIP122907
+// [Category] Improvement
+// [Description] Functions added for name value support
+//
+// 9 10/18/12 5:59a Arunsb
+// Updated for 2.16.1235 QA submission
+//
+// 11 10/10/12 12:36p Arunsb
+// Synched the source for v2.16.1232, backup with Aptio
+//
+// 8 5/29/12 3:58a Arunsb
+// [TAG] EIP91109
+// [Category] Improvement
+// [Description] Sync the Aptio IV source for AptioV
+//
+// 7 6/17/10 2:59p Madhans
+// Dynamic parsing support in TSE.
+//
+// 6 4/23/10 6:22p Madhans
+// To resolve Build issues with EDK support on.
+//
+// 5 2/19/10 1:01p Madhans
+// Updated for TSE 2.01. Refer Changelog.log for File change history.
+//
+// 7 2/19/10 8:14a Mallikarjunanv
+// updated year in copyright message
+//
+// 6 1/09/10 5:49a Mallikarjunanv
+// Updated TSE2.01 Release sources with coding standards
+//
+// 5 7/31/09 6:27p Presannar
+// Removed Redefinition of gEfiOEMBadgingProtocolGuid, EfiCopyMem
+//
+// 4 6/24/09 6:09p Madhans
+// Made TSE_USE_EDK_LIBRARY=OFF to not to refer EDK module.
+//
+// 3 6/23/09 6:56p Blaines
+// Coding standard update,
+// Remove spaces from file header to allow proper chm function list
+// creation.
+//
+// 2 6/12/09 7:41p Presannar
+// Initial implementation of coding standards
+//
+// 1 6/04/09 8:05p Madhans
+//
+// 2 5/07/09 10:35a Madhans
+// Changes after Bin module
+//
+// 3 5/06/09 8:09p Mallikarjunanv
+// updated for if no edk lib support
+//
+// 2 4/28/09 9:39p Madhans
+// Tse 2.0 Code complete Checkin.
+//
+// 1 3/31/09 3:33p Madhans
+// To build with/without EDK libs.
+//
+//*****************************************************************//
+//*****************************************************************//
+
+//<AMI_FHDR_START>
+//----------------------------------------------------------------------------
+//
+// Name: EdkHelper.c
+//
+// Description: This file contains code from EDK library.
+//
+//----------------------------------------------------------------------------
+//<AMI_FHDR_END>
+
+/*++
+
+Copyright (c) 2004 - 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.
+
+Module Name:
+
+ xxxxxx.c
+
+Abstract:
+
+ xxxxxxxxxxxx
+
+--*/
+
+#include "minisetup.h"
+
+#if !TSE_USE_EDK_LIBRARY
+
+extern EFI_SYSTEM_TABLE *pST;
+extern EFI_BOOT_SERVICES *pBS;
+extern EFI_RUNTIME_SERVICES *pRS;
+
+#if !TSE_APTIO_5_SUPPORT
+EFI_SYSTEM_TABLE *gST=NULL;
+EFI_BOOT_SERVICES *gBS=NULL;
+EFI_RUNTIME_SERVICES *gRT=NULL;
+EFI_GUID gEfiGlobalVariableGuid = EFI_GLOBAL_VARIABLE_GUID;
+EFI_GUID gEfiEventReadyToBootGuid = EFI_EVENT_GROUP_READY_TO_BOOT;
+#endif
+
+#define EFI_SHELL_FILE_GUID \
+ { 0xc57ad6b7, 0x0515, 0x40a8, 0x9d, 0x21, 0x55, 0x16, 0x52, 0x85, 0x4e, 0x37 }
+EFI_GUID gEfiShellFileGuid = EFI_SHELL_FILE_GUID;
+
+/*
+#define EFI_GLOBAL_VARIABLE_GUID \
+ { \
+ 0x8BE4DF61, 0x93CA, 0x11d2, 0xAA, 0x0D, 0x00, 0xE0, 0x98, 0x03, 0x2B, 0x8C \
+ }
+*/
+
+#define EFI_PRINT_PROTOCOL_GUID \
+ { 0xdf2d868e, 0x32fc, 0x4cf0, 0x8e, 0x6b, 0xff, 0xd9, 0x5d, 0x13, 0x43, 0xd0 }
+
+EFI_GUID gEfiPrintProtocolGuid = EFI_PRINT_PROTOCOL_GUID;
+
+#ifndef EFI_OEM_BADGING_PROTOCOL_GUID
+#define EFI_OEM_BADGING_PROTOCOL_GUID \
+ { 0x170e13c0, 0xbf1b, 0x4218, 0x87, 0x1d, 0x2a, 0xbd, 0xc6, 0xf8, 0x87, 0xbc }
+#endif
+//EFI_GUID gEfiOEMBadgingProtocolGuid = EFI_OEM_BADGING_PROTOCOL_GUID;
+extern EFI_GUID gEfiOEMBadgingProtocolGuid;
+
+/*
+#define EFI_EVENT_GROUP_READY_TO_BOOT \
+ { 0x7ce88fb3, 0x4bd7, 0x4679, { 0x87, 0xa8, 0xa8, 0xd8, 0xde, 0xe5, 0x0d, 0x2b } }
+*/
+VOID InitAmiLib(
+ IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable
+);
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: EfiInitializeDriverLib
+//
+// Description: To avoid including EDK libs.
+//
+// Input: ImageHandle and Systemtable
+//
+// Output: Status
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS
+EfiInitializeDriverLib (
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable
+ )
+{
+ InitAmiLib(ImageHandle,SystemTable);
+ gST = pST;
+ gBS = pBS;
+ gRT = pRS;
+ return EFI_SUCCESS;
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: EfiLibAllocateZeroPool
+//
+// Description: To avoid including EDK libs.
+//
+// Input: size
+//
+// Output: pointer
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+void* MallocZ(UINTN Size);
+VOID *
+EfiLibAllocateZeroPool (
+ IN UINTN AllocationSize
+ )
+{
+ return MallocZ(AllocationSize);
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: EfiLibAllocatePool
+//
+// Description: To avoid including EDK libs.
+//
+// Input: size
+//
+// Output: pointer
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+void* Malloc(UINTN Size);
+VOID *
+EfiLibAllocatePool (
+ IN UINTN AllocationSize
+ )
+{
+ return Malloc(AllocationSize);
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: EfiCompareGuid
+//
+// Description: To avoid including EDK libs.
+//
+// Input: IN EFI_GUID *Guid1, IN EFI_GUID *Guid2
+//
+// Output: BOOLEAN
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+BOOLEAN
+EfiCompareGuid (
+ IN EFI_GUID *Guid1,
+ IN EFI_GUID *Guid2
+ )
+{
+ return (BOOLEAN)(0==MemCmp((UINT8*)Guid1,(UINT8*)Guid2,sizeof(EFI_GUID)));
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: EfiCompareMem
+//
+// Description: To avoid including EDK libs.
+//
+// Input: IN VOID *MemOne, IN VOID *MemTwo,
+//
+// Output: INTN
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+INTN
+EfiCompareMem (
+ IN VOID *MemOne,
+ IN VOID *MemTwo,
+ IN UINTN Length
+ )
+{
+ return MemCmp(MemOne,MemTwo,Length);
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: Wcslen
+//
+// Description: To avoid including EDK libs.
+//
+// Input: CHAR16 *string
+//
+// Output: UINTN
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+UINTN Wcslen(CHAR16 *string);
+UINTN
+EfiStrLen (
+ IN CHAR16 *String
+ )
+{
+ return Wcslen(String);
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: Wcscpy
+//
+// Description: To avoid including EDK libs.
+//
+// Input: CHAR16 *string1, CHAR16* string2
+//
+// Output: CHAR16*
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+CHAR16* Wcscpy(CHAR16 *string1, CHAR16* string2);
+VOID
+EfiStrCpy (
+ IN CHAR16 *Destination,
+ IN CHAR16 *Source
+ )
+{
+ Wcscpy(Destination,Source);
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: Wcscmp
+//
+// Description: To avoid including EDK libs.
+//
+// Input: CHAR16 *string1, CHAR16 *string2
+//
+// Output: int
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+int Wcscmp( CHAR16 *string1, CHAR16 *string2 );
+INTN
+EfiStrCmp (
+ IN CHAR16 *String,
+ IN CHAR16 *String2
+ )
+{
+ return Wcscmp( String, String2 );
+}
+
+int Strcmp( char *string1, char *string2 );
+INTN
+EfiAsciiStrCmp (
+ IN CHAR8 *String,
+ IN CHAR8 *String2
+ )
+{
+ return Strcmp( String, String2 );
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: DPAdd
+//
+// Description: To avoid including EDK libs.
+//
+// Input: EFI_DEVICE_PATH_PROTOCOL *pDp1, EFI_DEVICE_PATH_PROTOCOL *pDp2
+//
+// Output: VOID*
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+VOID* DPAdd(EFI_DEVICE_PATH_PROTOCOL *pDp1, EFI_DEVICE_PATH_PROTOCOL *pDp2);
+
+EFI_DEVICE_PATH_PROTOCOL *
+EfiAppendDevicePath (
+ IN EFI_DEVICE_PATH_PROTOCOL *Src1,
+ IN EFI_DEVICE_PATH_PROTOCOL *Src2
+ )
+{
+ return (EFI_DEVICE_PATH_PROTOCOL *)DPAdd(Src1,Src2);
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: DPAddNode
+//
+// Description: To avoid including EDK libs.
+//
+// Input: EFI_DEVICE_PATH_PROTOCOL *pDp1, EFI_DEVICE_PATH_PROTOCOL *pDp2
+//
+// Output: VOID*
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+VOID* DPAddNode(EFI_DEVICE_PATH_PROTOCOL *pDp1, EFI_DEVICE_PATH_PROTOCOL *pDp2);
+
+EFI_DEVICE_PATH_PROTOCOL *
+EfiAppendDevicePathNode (
+ IN EFI_DEVICE_PATH_PROTOCOL *Src1,
+ IN EFI_DEVICE_PATH_PROTOCOL *Src2
+ )
+{
+ return (EFI_DEVICE_PATH_PROTOCOL *)DPAddNode(Src1, Src2);
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: EfiDevicePathFromHandle
+//
+// Description: To avoid including EDK libs.
+//
+// Input: IN EFI_HANDLE Handle
+//
+// Output: EFI_DEVICE_PATH_PROTOCOL *
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_DEVICE_PATH_PROTOCOL *
+EfiDevicePathFromHandle (
+ IN EFI_HANDLE Handle
+ )
+/*++
+
+Routine Description:
+
+ Get the device path protocol interface installed on a specified handle.
+
+Arguments:
+
+ Handle - a specified handle
+
+Returns:
+
+ The device path protocol interface installed on that handle.
+
+--*/
+{
+ EFI_DEVICE_PATH_PROTOCOL *DevicePath;
+
+ DevicePath = NULL;
+ gBS->HandleProtocol (
+ Handle,
+ &gEfiDevicePathProtocolGuid,
+ (VOID *) &DevicePath
+ );
+ return DevicePath;
+}
+
+VOID
+EfiStrCat (
+ IN CHAR16 *Destination,
+ IN CHAR16 *Source
+ )
+/*++
+
+Routine Description:
+ Concatinate Source on the end of Destination
+
+Arguments:
+ Destination - String to added to the end of.
+ Source - String to concatinate.
+
+Returns:
+ NONE
+
+--*/
+{
+ EfiStrCpy (Destination + EfiStrLen (Destination), Source);
+}
+
+INTN
+EfiStrnCmp (
+ IN CHAR16 *String,
+ IN CHAR16 *String2,
+ IN UINTN Length
+ )
+/*++
+
+Routine Description:
+ This function compares the Unicode string String to the Unicode
+ string String2 for len characters. If the first len characters
+ of String is identical to the first len characters of String2,
+ then 0 is returned. If substring of String sorts lexicographically
+ after String2, the function returns a number greater than 0. If
+ substring of String sorts lexicographically before String2, the
+ function returns a number less than 0.
+
+Arguments:
+ String - Compare to String2
+ String2 - Compare to String
+ Length - Number of Unicode characters to compare
+
+Returns:
+ 0 - The substring of String and String2 is identical.
+ > 0 - The substring of String sorts lexicographically after String2
+ < 0 - The substring of String sorts lexicographically before String2
+
+--*/
+{
+ while (*String && Length != 0) {
+ if (*String != *String2) {
+ break;
+ }
+ String += 1;
+ String2 += 1;
+ Length -= 1;
+ }
+ return Length > 0 ? *String - *String2 : 0;
+}
+
+
+UINTN
+EfiStrSize (
+ IN CHAR16 *String
+ )
+/*++
+
+Routine Description:
+ Return the number bytes in the Unicode String. This is not the same as
+ the length of the string in characters. The string size includes the NULL
+
+Arguments:
+ String - String to process
+
+Returns:
+ Number of bytes in String
+
+--*/
+{
+ return ((EfiStrLen (String) + 1) * sizeof (CHAR16));
+}
+
+
+#define AMI_SIZE_OF_FILEPATH_DEVICE_PATH STRUCT_OFFSET(FILEPATH_DEVICE_PATH,PathName)
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: EfiFileDevicePath
+//
+// Description: To avoid including EDK libs.
+//
+// Input: IN EFI_HANDLE Device OPTIONAL, IN CHAR16 *FileName
+//
+// Output: EFI_DEVICE_PATH_PROTOCOL *
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_DEVICE_PATH_PROTOCOL *
+EfiFileDevicePath (
+ IN EFI_HANDLE Device OPTIONAL,
+ IN CHAR16 *FileName
+ )
+/*++
+
+Routine Description:
+
+ This function allocates a device path for a file and appends it to an existiong
+ device path.
+
+Arguments:
+ Device - A pointer to a device handle.
+
+ FileName - A pointer to a Null-terminated Unicodestring.
+
+Returns:
+ A device path contain the file name.
+
+--*/
+{
+ UINTN Size;
+ FILEPATH_DEVICE_PATH *FilePath;
+ EFI_DEVICE_PATH_PROTOCOL *Eop;
+ EFI_DEVICE_PATH_PROTOCOL *DevicePath;
+
+ for (Size = 0; FileName[Size] != 0; Size++)
+ ;
+ Size = (Size + 1) * 2;
+
+ FilePath = EfiLibAllocateZeroPool (Size + AMI_SIZE_OF_FILEPATH_DEVICE_PATH + sizeof (EFI_DEVICE_PATH_PROTOCOL));
+
+ DevicePath = NULL;
+
+ if (FilePath != NULL) {
+
+ //
+ // Build a file path
+ //
+ FilePath->Header.Type = MEDIA_DEVICE_PATH;
+ FilePath->Header.SubType = MEDIA_FILEPATH_DP;
+ SetDevicePathNodeLength (&FilePath->Header, Size + AMI_SIZE_OF_FILEPATH_DEVICE_PATH);
+ EfiCopyMem (FilePath->PathName, FileName, Size);
+ Eop = NextDevicePathNode (&FilePath->Header);
+ SetDevicePathEndNode (Eop);
+
+ //
+ // Append file path to device's device path
+ //
+
+ DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) FilePath;
+ if (Device != NULL) {
+ DevicePath = EfiAppendDevicePath (
+ EfiDevicePathFromHandle (Device),
+ DevicePath
+ );
+
+ gBS->FreePool (FilePath);
+ }
+ }
+
+ return DevicePath;
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: EfiInitializeFwVolDevicepathNode
+//
+// Description: To avoid including EDK libs.
+//
+// Input: IN MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvDevicePathNode,
+// IN EFI_GUID *NameGuid
+//
+// Output: VOID EFIAPI
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+VOID
+EFIAPI
+EfiInitializeFwVolDevicepathNode (
+ IN MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvDevicePathNode,
+ IN EFI_GUID *NameGuid
+ )
+/*++
+
+Routine Description:
+
+ Initialize a Firmware Volume (FV) Media Device Path node.
+
+ Tiano extended the EFI 1.10 device path nodes. Tiano does not own this enum
+ so as we move to UEFI 2.0 support we must use a mechanism that conforms with
+ the UEFI 2.0 specification to define the FV device path. An UEFI GUIDed
+ device path is defined for PIWG extensions of device path. If the code
+ is compiled to conform with the UEFI 2.0 specification use the new device path
+ else use the old form for backwards compatability.
+
+Arguments:
+
+ FvDevicePathNode - Pointer to a FV device path node to initialize
+ NameGuid - FV file name to use in FvDevicePathNode
+
+Returns:
+
+ None
+
+--*/
+{
+//*** AMI PORTING BEGIN ***//
+//NEW PIWG Specific Device Path defined here is not in compliance with PI DXE CIS 1.0
+//Let's disable it
+//See also corresponding change in TianoSpecDevicePath.h
+#if 1
+//*** AMI PORTING END *****//
+ //
+ // Use old Device Path that conflicts with UEFI
+ //
+ FvDevicePathNode->Header.Type = MEDIA_DEVICE_PATH;
+ FvDevicePathNode->Header.SubType = MEDIA_FV_FILEPATH_DP;
+ SetDevicePathNodeLength (&FvDevicePathNode->Header, sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH));
+
+#else
+ //
+ // Use the new Device path that does not conflict with the UEFI
+ //
+ FvDevicePathNode->Piwg.Header.Type = MEDIA_DEVICE_PATH;
+ FvDevicePathNode->Piwg.Header.SubType = MEDIA_VENDOR_DP;
+ SetDevicePathNodeLength (&FvDevicePathNode->Piwg.Header, sizeof (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH));
+
+ //
+ // Add the GUID for generic PIWG device paths
+ //
+ EfiCopyMem (&FvDevicePathNode->Piwg.PiwgSpecificDevicePath, &gEfiFrameworkDevicePathGuid, sizeof(EFI_GUID));
+
+ //
+ // Add in the FW Vol File Path PIWG defined inforation
+ //
+ FvDevicePathNode->Piwg.Type = PIWG_MEDIA_FW_VOL_FILEPATH_DEVICE_PATH_TYPE;
+
+#endif
+ EfiCopyMem (&((AMITSE_MEDIA_FW_VOL_FILEPATH_DEVICE_PATH*)FvDevicePathNode)->FvFileName, NameGuid, sizeof(EFI_GUID));
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: EfiLibNamedEventSignal
+//
+// Description: To avoid including EDK libs.
+//
+// Input: IN EFI_GUID *Name
+//
+// Output: STATUS
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS
+EfiLibNamedEventSignal (
+ IN EFI_GUID *Name
+ )
+/*++
+
+Routine Description:
+ Signals a named event. All registered listeners will run.
+ The listeners should register using EfiLibNamedEventListen() function.
+
+ NOTE: For now, the named listening/signalling is implemented
+ on a protocol interface being installed and uninstalled.
+ In the future, this maybe implemented based on a dedicated mechanism.
+
+Arguments:
+ Name - Name to perform the signaling on. The name is a GUID.
+
+Returns:
+ EFI_SUCCESS if successfull.
+
+--*/
+{
+ EFI_STATUS Status;
+ EFI_HANDLE Handle;
+
+ Handle = NULL;
+ Status = gBS->InstallProtocolInterface (
+ &Handle,
+ Name,
+ EFI_NATIVE_INTERFACE,
+ NULL
+ );
+ ASSERT_EFI_ERROR (Status);
+
+ Status = gBS->UninstallProtocolInterface (
+ Handle,
+ Name,
+ NULL
+ );
+ ASSERT_EFI_ERROR (Status);
+
+ return EFI_SUCCESS;
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: LibReportStatusCode
+//
+// Description: To avoid including EDK libs.
+//
+// Input: IN EFI_STATUS_CODE_TYPE Type, IN EFI_STATUS_CODE_VALUE Value,
+// IN UINT32 Instance, IN EFI_GUID *CallerId OPTIONAL,
+// IN EFI_STATUS_CODE_DATA *Data OPTIONAL
+//
+// Output: STATUS
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS LibReportStatusCode(
+ IN EFI_STATUS_CODE_TYPE Type, IN EFI_STATUS_CODE_VALUE Value,
+ IN UINT32 Instance, IN EFI_GUID *CallerId OPTIONAL,
+ IN EFI_STATUS_CODE_DATA *Data OPTIONAL
+);
+
+EFI_STATUS
+EfiLibReportStatusCode (
+ IN EFI_STATUS_CODE_TYPE Type,
+ IN EFI_STATUS_CODE_VALUE Value,
+ IN UINT32 Instance,
+ IN EFI_GUID *CallerId OPTIONAL,
+ IN EFI_STATUS_CODE_DATA *Data OPTIONAL
+ )
+{
+ return LibReportStatusCode(Type,Value,Instance,CallerId,Data);
+}
+
+
+VOID
+EFIAPI
+EventNotifySignalAllNullEvent (
+ IN EFI_EVENT Event,
+ IN VOID *Context
+ )
+{
+ //
+ // This null event is a size efficent way to enusre that
+ // EFI_EVENT_NOTIFY_SIGNAL_ALL is error checked correctly.
+ // EFI_EVENT_NOTIFY_SIGNAL_ALL is now mapped into
+ // CreateEventEx() and this function is used to make the
+ // old error checking in CreateEvent() for Tiano extensions
+ // function.
+ //
+ return;
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: TseEfiCreateEventReadyToBoot
+//
+// Description: To avoid including EDK libs.
+//
+// Input: IN EFI_TPL NotifyTpl,
+// IN EFI_EVENT_NOTIFY NotifyFunction,
+// IN VOID *NotifyContext,
+// OUT EFI_EVENT *ReadyToBootEvent
+//
+// Output: EFI_STATUS
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS
+EFIAPI
+TseEfiCreateEventReadyToBoot (
+ IN EFI_TPL NotifyTpl,
+ IN EFI_EVENT_NOTIFY NotifyFunction,
+ IN VOID *NotifyContext,
+ OUT EFI_EVENT *ReadyToBootEvent
+ )
+/*++
+
+Routine Description:
+ Create a Read to Boot Event.
+
+ Tiano extended the CreateEvent Type enum to add a ready to boot event type.
+ This was bad as Tiano did not own the enum. In UEFI 2.0 CreateEventEx was
+ added and now it's possible to not voilate the UEFI specification and use
+ the ready to boot event class defined in UEFI 2.0. This library supports
+ the R8.5/EFI 1.10 form and R8.6/UEFI 2.0 form and allows common code to
+ work both ways.
+
+Arguments:
+ @param LegacyBootEvent Returns the EFI event returned from gBS->CreateEvent(Ex)
+
+Return:
+ EFI_SUCCESS - Event was created.
+ Other - Event was not created.
+
+--*/
+{
+ EFI_STATUS Status;
+ UINT32 EventType;
+ EFI_EVENT_NOTIFY WorkerNotifyFunction;
+
+#if (EFI_SPECIFICATION_VERSION < 0x00020000)
+
+ if (NotifyFunction == NULL) {
+ EventType = EFI_EVENT_SIGNAL_READY_TO_BOOT | EFI_EVENT_NOTIFY_SIGNAL_ALL;
+ } else {
+ EventType = EFI_EVENT_SIGNAL_READY_TO_BOOT;
+ }
+ WorkerNotifyFunction = NotifyFunction;
+
+ //
+ // prior to UEFI 2.0 use Tiano extension to EFI
+ //
+ Status = gBS->CreateEvent (
+ EventType,
+ NotifyTpl,
+ WorkerNotifyFunction,
+ NotifyContext,
+ ReadyToBootEvent
+ );
+#else
+
+ EventType = EFI_EVENT_NOTIFY_SIGNAL;
+ if (NotifyFunction == NULL) {
+ //
+ // CreatEventEx will check NotifyFunction is NULL or not
+ //
+ WorkerNotifyFunction = EventNotifySignalAllNullEvent;
+ } else {
+ WorkerNotifyFunction = NotifyFunction;
+ }
+
+ //
+ // For UEFI 2.0 and the future use an Event Group
+ //
+ Status = gBS->CreateEventEx (
+ EventType,
+ NotifyTpl,
+ WorkerNotifyFunction,
+ NotifyContext,
+ &gEfiEventReadyToBootGuid,
+ ReadyToBootEvent
+ );
+#endif
+ return Status;
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: IsHexDigit
+//
+// Description: To avoid including EDK libs.
+//
+// Input:
+//
+// Output:
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+BOOLEAN
+IsHexDigit (
+ OUT UINT8 *Digit,
+ IN CHAR16 Char
+ )
+/*++
+
+ Routine Description:
+ Determines if a Unicode character is a hexadecimal digit.
+ The test is case insensitive.
+
+ Arguments:
+ Digit - Pointer to byte that receives the value of the hex character.
+ Char - Unicode character to test.
+
+ Returns:
+ TRUE - If the character is a hexadecimal digit.
+ FALSE - Otherwise.
+
+--*/
+{
+ if ((Char >= L'0') && (Char <= L'9')) {
+ *Digit = (UINT8) (Char - L'0');
+ return TRUE;
+ }
+
+ if ((Char >= L'A') && (Char <= L'F')) {
+ *Digit = (UINT8) (Char - L'A' + 0x0A);
+ return TRUE;
+ }
+
+ if ((Char >= L'a') && (Char <= L'f')) {
+ *Digit = (UINT8) (Char - L'a' + 0x0A);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: HexStringToBuf
+//
+// Description: To avoid including EDK libs.
+//
+// Input:
+//
+// Output:
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS
+HexStringToBuf (
+ IN OUT UINT8 *Buf,
+ IN OUT UINTN *Len,
+ IN CHAR16 *Str,
+ OUT UINTN *ConvertedStrLen OPTIONAL
+ )
+/*++
+
+ Routine Description:
+ Converts Unicode string to binary buffer.
+ The conversion may be partial.
+ The first character in the string that is not hex digit stops the conversion.
+ At a minimum, any blob of data could be represented as a hex string.
+
+ Arguments:
+ Buf - Pointer to buffer that receives the data.
+ Len - Length in bytes of the buffer to hold converted data.
+ If routine return with EFI_SUCCESS, containing length of converted data.
+ If routine return with EFI_BUFFER_TOO_SMALL, containg length of buffer desired.
+ Str - String to be converted from.
+ ConvertedStrLen - Length of the Hex String consumed.
+
+ Returns:
+ EFI_SUCCESS: Routine Success.
+ EFI_BUFFER_TOO_SMALL: The buffer is too small to hold converted data.
+ EFI_
+
+--*/
+{
+ UINTN HexCnt;
+ UINTN Idx;
+ UINTN BufferLength;
+ UINT8 Digit;
+ UINT8 Byte;
+
+ //
+ // Find out how many hex characters the string has.
+ //
+ for (Idx = 0, HexCnt = 0; IsHexDigit (&Digit, Str[Idx]); Idx++, HexCnt++);
+
+ if (HexCnt == 0) {
+ *Len = 0;
+ return EFI_SUCCESS;
+ }
+ //
+ // Two Unicode characters make up 1 buffer byte. Round up.
+ //
+ BufferLength = (HexCnt + 1) / 2;
+
+ //
+ // Test if buffer is passed enough.
+ //
+ if (BufferLength > (*Len)) {
+ *Len = BufferLength;
+ return EFI_BUFFER_TOO_SMALL;
+ }
+
+ *Len = BufferLength;
+
+ for (Idx = 0; Idx < HexCnt; Idx++) {
+
+ IsHexDigit (&Digit, Str[HexCnt - 1 - Idx]);
+
+ //
+ // For odd charaters, write the lower nibble for each buffer byte,
+ // and for even characters, the upper nibble.
+ //
+ if ((Idx & 1) == 0) {
+ Byte = Digit;
+ } else {
+ Byte = Buf[Idx / 2];
+ Byte &= 0x0F;
+ Byte |= Digit << 4;
+ }
+
+ Buf[Idx / 2] = Byte;
+ }
+
+ if (ConvertedStrLen != NULL) {
+ *ConvertedStrLen = HexCnt;
+ }
+
+ return EFI_SUCCESS;
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------------------------------------------------------------------------------
+// Procedure: NameValueHexStringToBuf
+//
+// Description: Converts name value string to buffer
+//
+// Input: : Buf - Pointer to buffer that receives the data.
+// Len - Length in bytes of the buffer to hold converted data.
+// If routine return with EFI_SUCCESS, containing length of converted data.
+// If routine return with EFI_BUFFER_TOO_SMALL, containg length of buffer desired.
+// Str - String to be converted from.
+// ConvertedStrLen - Length of the Hex String consumed.
+//
+// Output: EFI_SUCCESS: Routine Success.
+// EFI_BUFFER_TOO_SMALL: The buffer is too small to hold converted data.
+//
+//-----------------------------------------------------------------------------------------------------------------------------------------------------
+//<AMI_PHDR_END>
+UINT8 HexToNibbleChar (IN UINT8 Nibble);
+EFI_STATUS NameValueHexStringToBuf (
+ IN OUT UINT8 *Buf,
+ IN OUT UINTN *Len,
+ IN CHAR16 *Str,
+ OUT UINTN *ConvertedStrLen OPTIONAL
+ )
+{
+ UINTN HexCnt;
+ UINTN Idx, ByteIndex = 0;
+ UINTN BufferLength;
+ UINT8 Digit;
+ UINT8 Byte;
+ UINT64 Ext8byte = 0;
+ UINT32 Ext4byte = 0;
+ UINT16 Word;
+
+ //
+ // Find out how many hex characters the string has.
+ //
+ for (Idx = 0, HexCnt = 0; IsHexDigit (&Digit, Str[Idx]); Idx++, HexCnt++);
+
+ if (HexCnt == 0) {
+ *Len = 0;
+ return EFI_SUCCESS;
+ }
+ //
+ // Two Unicode characters make up 1 buffer byte. Round up.
+ //
+ BufferLength = (HexCnt + 1) / 2;
+
+ //
+ // Test if buffer is passed enough.
+ //
+ if (BufferLength > (*Len)) {
+ *Len = BufferLength;
+ return EFI_BUFFER_TOO_SMALL;
+ }
+
+ *Len = BufferLength;
+
+ for (Idx = 0; Idx < HexCnt; Idx += 4)
+ {
+ //00 31 00 36 00 30 00 00
+ Ext4byte = *((UINT32 *)&Str[Idx+2]); //00 31 00 36
+
+ Word = ((UINT16)(Ext4byte & 0x0000FFFF)); //00 36
+ Byte = ((UINT8)(Word & 0x00FF)); //36
+ Buf [ByteIndex] = HexToNibbleChar (Byte); //6
+ Buf [ByteIndex] <<= 0x4; //60
+
+ Word = ((UINT16)(Ext4byte >> 16)); //00 31
+ Byte = ((UINT8)(Word & 0x00FF)); //31
+ Buf [ByteIndex] |= HexToNibbleChar (Byte); //1
+
+ ByteIndex ++;
+
+ Ext4byte = *((UINT32 *)&Str[Idx]); //00 30 00 30
+ Word = ((UINT16)(Ext4byte & 0x0000FFFF)); //00 30
+ Byte = ((UINT8)(Word & 0x00FF)); //30
+ Buf [ByteIndex] = HexToNibbleChar (Byte); //0
+ Buf [ByteIndex] <<= 0x4; //60
+
+ Word = ((UINT16)(Ext4byte >> 16)); //00 30
+ Byte = ((UINT8)(Word & 0x00FF)); //30
+ Buf [ByteIndex] |= HexToNibbleChar (Byte); //0
+
+ ByteIndex ++;
+ }
+
+ if (ConvertedStrLen != NULL) {
+ *ConvertedStrLen = HexCnt;
+ }
+
+ return EFI_SUCCESS;
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: Mul64
+//
+// Description: To avoid including EDK libs.
+//
+// Input:
+//
+// Output:
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+UINT64 Mul64(
+ IN UINT64 Value64,
+ IN UINTN Value32
+ );
+#if !TSE_APTIO_5_SUPPORT
+UINT64
+MultU64x32 (
+ IN UINT64 Multiplicand,
+ IN UINTN Multiplier
+ )
+{
+ return Mul64(Multiplicand,Multiplier);
+}
+#endif
+UINTN DPLength(EFI_DEVICE_PATH_PROTOCOL *pDp);
+
+UINTN
+EfiDevicePathSize (
+ IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
+ )
+{
+ return DPLength(DevicePath);
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: NibbleToHexChar
+//
+// Description: Converts the low nibble of a byte to hex unicode character.
+//
+// Input: Nibble - lower nibble of a byte.
+//
+// Output: Hex unicode character.
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+CHAR16
+NibbleToHexChar (
+ IN UINT8 Nibble
+ )
+{
+ Nibble &= 0x0F;
+ if (Nibble <= 0x9) {
+ return (CHAR16)(Nibble + L'0');
+ }
+
+ return (CHAR16)(Nibble - 0xA + L'A');
+}
+
+
+//<AMI_PHDR_START>
+//------------------------------------------------------------------------------------
+// Procedure: HexToNibbleChar
+//
+// Description: Converts the hex value to character.
+//
+// Input: Nibble - lower nibble of a byte.
+//
+// Output: Hex unicode character.
+//
+//--------------------------------------------------------------------------------------
+//<AMI_PHDR_END>
+UINT8
+HexToNibbleChar (
+ IN UINT8 Nibble
+ )
+{
+ if (Nibble - L'0' <= 0x9) {
+ return (CHAR16)(Nibble - L'0');
+ }
+
+ return (CHAR16)(Nibble + 0xA - L'A');
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: BufToHexString
+//
+// Description: Converts binary buffer to Unicode string.
+// At a minimum, any blob of data could be represented as a hex string.
+//
+// Input: Str - Pointer to the string.
+// HexStringBufferLength - Length in bytes of buffer to hold the hex string. Includes tailing '\0' character.
+// If routine return with EFI_SUCCESS, containing length of hex string buffer.
+// If routine return with EFI_BUFFER_TOO_SMALL, containg length of hex string buffer desired.
+// Buf - Buffer to be converted from.
+// Len - Length in bytes of the buffer to be converted.
+//
+// Output: EFI_SUCCESS: Routine success.
+// EFI_BUFFER_TOO_SMALL: The hex string buffer is too small.
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS
+BufToHexString (
+ IN OUT CHAR16 *Str,
+ IN OUT UINTN *HexStringBufferLength,
+ IN UINT8 *Buf,
+ IN UINTN Len
+ )
+{
+ UINTN Idx;
+ UINT8 Byte;
+ UINTN StrLen;
+
+ //
+ // Make sure string is either passed or allocate enough.
+ // It takes 2 Unicode characters (4 bytes) to represent 1 byte of the binary buffer.
+ // Plus the Unicode termination character.
+ //
+ StrLen = Len * 2;
+ if (StrLen > ((*HexStringBufferLength) - 1)) {
+ *HexStringBufferLength = StrLen + 1;
+ return EFI_BUFFER_TOO_SMALL;
+ }
+
+ *HexStringBufferLength = StrLen + 1;
+ //
+ // Ends the string.
+ //
+ Str[StrLen] = L'\0';
+
+ for (Idx = 0; Idx < Len; Idx++) {
+
+ Byte = Buf[Idx];
+ Str[StrLen - 1 - Idx * 2] = NibbleToHexChar (Byte);
+ Str[StrLen - 2 - Idx * 2] = NibbleToHexChar ((UINT8)(Byte >> 4));
+ }
+
+ return EFI_SUCCESS;
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: NameValueBufToHexString
+//
+// Description: Converts binary buffer to Unicode string.
+// At a minimum, any blob of data could be represented as a hex string.
+// Used only for name value implementaion
+//
+// Input: Str - Pointer to the string.
+// HexStringBufferLength - Length in bytes of buffer to hold the hex string. Includes tailing '\0' character.
+// If routine return with EFI_SUCCESS, containing length of hex string buffer.
+// If routine return with EFI_BUFFER_TOO_SMALL, containg length of hex string buffer desired.
+// Buf - Buffer to be converted from.
+// Len - Length in bytes of the buffer to be converted.
+//
+// Output: EFI_SUCCESS: Routine success.
+// EFI_BUFFER_TOO_SMALL: The hex string buffer is too small.
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS
+NameValueBufToHexString (
+ IN OUT CHAR16 **Str,
+ IN OUT UINTN *HexStringBufferLength,
+ IN UINT8 *Buf,
+ IN UINTN Len
+ )
+{
+ UINT8 Byte;
+
+ //
+ // Make sure string is either passed or allocate enough.
+ // It takes 2 Unicode characters (4 bytes) to represent 1 byte of the binary buffer.
+ // Plus the Unicode termination character.
+ //
+
+ if (Len <= sizeof (UINT64)) //For upto 8 bytes we have to take care of endian allignment
+ {
+ UINTN Idx;
+ UINTN StrLen;
+ CHAR16 *tempStr = (CHAR16 *)NULL;
+
+ //
+ // Make sure string is either passed or allocate enough.
+ // It takes 2 Unicode characters (4 bytes) to represent 1 byte of the binary buffer.
+ // Plus the Unicode termination character.
+ //
+ StrLen = Len * 2;
+ *Str = EfiLibAllocateZeroPool ((StrLen + 1) * sizeof (UINT16) );
+ if (NULL == *Str)
+ {
+ return EFI_OUT_OF_RESOURCES;
+ }
+ *HexStringBufferLength = (StrLen + 1) * sizeof (UINT16); //UefiVarSetNvram needs full size
+ //
+ // Ends the string.
+ //
+ tempStr = *Str;
+ tempStr[StrLen] = L'\0';
+
+ for (Idx = 0; Idx < Len; Idx++)
+ {
+ Byte = Buf[Idx];
+ tempStr[StrLen - 1 - Idx * 2] = NibbleToHexChar (Byte);
+ tempStr[StrLen - 2 - Idx * 2] = NibbleToHexChar ((UINT8)(Byte >> 4));
+ }
+ }
+ else
+ {
+ CHAR16 *tempBuf = (CHAR16 *)NULL, *tempStr = (CHAR16 *)NULL;
+ UINT32 iIndex = 0, StringHexLength = 0;
+ CHAR16 Word;
+
+ tempBuf = EfiLibAllocateZeroPool (Len + sizeof (CHAR16)); //If full string is given then NULL wont be there so crashing so added one NULL
+ if (NULL == tempBuf) //character at end
+ {
+ return EFI_OUT_OF_RESOURCES;
+ }
+ MemCpy (tempBuf, Buf, Len);
+ //Finding length to allocate
+ while (tempBuf [iIndex])
+ {
+ StringHexLength ++;
+ iIndex ++;
+ }
+ iIndex = 0;
+ *Str = EfiLibAllocateZeroPool ((StringHexLength * sizeof (CHAR16) * 4) + sizeof (CHAR16));
+ if (NULL == *Str )
+ {
+ return EFI_OUT_OF_RESOURCES;
+ }
+ tempStr = *Str;
+ while (tempBuf [iIndex])
+ {
+ Word = tempBuf [iIndex];
+ Byte = ((UINT8)(Word >> 8));
+ tempStr [iIndex * 4] = NibbleToHexChar ((UINT8)(Byte >> 4));
+ tempStr [iIndex * 4 + 1] = NibbleToHexChar (Byte);
+ Byte = Word & 0x00FF;
+ tempStr [iIndex * 4 + 2] = NibbleToHexChar ((UINT8)(Byte >> 4));
+ tempStr [iIndex * 4 + 3] = NibbleToHexChar (Byte);
+ iIndex ++;
+ }
+ *HexStringBufferLength = (StringHexLength * sizeof (CHAR16) * 4) + sizeof (CHAR16);
+ tempStr [StringHexLength * 4] = L'\0';
+ MemFreePointer ((VOID **)&tempBuf);
+ }
+ return EFI_SUCCESS;
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: ToLower
+//
+// Description: Converts the unicode character of the string from uppercase to lowercase.
+//
+// Input: Str - String to be converted
+//
+// Output: None
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+VOID
+ToLower (
+ IN OUT CHAR16 *Str
+ )
+{
+ CHAR16 *Ptr;
+
+ for (Ptr = Str; *Ptr != L'\0'; Ptr++) {
+ if (*Ptr >= L'A' && *Ptr <= L'Z') {
+ *Ptr = (CHAR16) (*Ptr - L'A' + L'a');
+ }
+ }
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: SwapBuffer
+//
+// Description: Swap bytes in the buffer.
+//
+// Input: Buffer - Binary buffer.
+// BufferSize - Size of the buffer in bytes.
+//
+// Output: None
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+VOID
+SwapBuffer (
+ IN OUT UINT8 *Buffer,
+ IN UINTN BufferSize
+ )
+{
+ UINTN Index;
+ UINT8 Temp;
+ UINTN SwapCount;
+
+ SwapCount = BufferSize / 2;
+ for (Index = 0; Index < SwapCount; Index++) {
+ Temp = Buffer[Index];
+ Buffer[Index] = Buffer[BufferSize - 1 - Index];
+ Buffer[BufferSize - 1 - Index] = Temp;
+ }
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: UnicodeToConfigString
+//
+// Description: Convert Unicode string to binary representation Config string, e.g.
+// "ABCD" => "0041004200430044". Config string appears in <ConfigHdr> (i.e.
+// "&NAME=<string>"), or Name/Value pair in <ConfigBody> (i.e. "label=<string>").
+//
+// Input: ConfigString - Binary representation of Unicode String, <string> := (<HexCh>4)+
+// StrBufferLen - On input: Length in bytes of buffer to hold the Unicode string.
+// Includes tailing '\0' character.
+// On output:
+// If return EFI_SUCCESS, containing length of Unicode string buffer.
+// If return EFI_BUFFER_TOO_SMALL, containg length of string buffer desired.
+// UnicodeString - Original Unicode string.
+//
+// Output: EFI_SUCCESS - Routine success.
+// EFI_BUFFER_TOO_SMALL - The string buffer is too small.
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS
+UnicodeToConfigString (
+ IN OUT CHAR16 *ConfigString,
+ IN OUT UINTN *StrBufferLen,
+ IN CHAR16 *UnicodeString
+ )
+{
+ UINTN Index;
+ UINTN Len;
+ UINTN BufferSize;
+ CHAR16 *String;
+
+ Len = EfiStrLen (UnicodeString);
+ BufferSize = (Len * 4 + 1) * sizeof (CHAR16);
+
+ if (*StrBufferLen < BufferSize) {
+ *StrBufferLen = BufferSize;
+ return EFI_BUFFER_TOO_SMALL;
+ }
+
+ *StrBufferLen = BufferSize;
+ String = ConfigString;
+
+ for (Index = 0; Index < Len; Index++) {
+ BufToHexString (ConfigString, &BufferSize, (UINT8 *) UnicodeString, 2);
+
+ ConfigString += 4;
+ UnicodeString += 1;
+ }
+
+ //
+ // Add tailing '\0' character
+ //
+ *ConfigString = L'\0';
+
+ //
+ // Convert the uppercase to lowercase since <HexAf> is defined in lowercase format.
+ //
+ ToLower (String);
+ return EFI_SUCCESS;
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: EfiLibAllocateCopyPool
+//
+// Description: Allocate BootServicesData pool and use a buffer provided by
+// caller to fill it.
+//
+// Input: AllocationSize - The size to allocate
+// Buffer - Buffer that will be filled into the buffer allocated
+//
+// Output: Pointer of the buffer allocated.
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+VOID *
+EfiLibAllocateCopyPool (
+ IN UINTN AllocationSize,
+ IN VOID *Buffer
+ )
+{
+ VOID *Memory;
+
+ Memory = NULL;
+ gBS->AllocatePool (EfiBootServicesData, AllocationSize, &Memory);
+ if (Memory != NULL) {
+ gBS->CopyMem (Memory, Buffer, AllocationSize);
+ }
+
+ return Memory;
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: BufferToHexString
+//
+// Description: Converts binary buffer to Unicode string in reversed byte order from BufToHexString().
+//
+// Input: Str - String for output
+// Buffer - Binary buffer.
+// BufferSize - Size of the buffer in bytes.
+//
+// Output: EFI_SUCCESS - The function completed successfully.
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS
+BufferToHexString (
+ IN OUT CHAR16 *Str,
+ IN UINT8 *Buffer,
+ IN UINTN BufferSize
+ )
+{
+ EFI_STATUS Status;
+ UINT8 *NewBuffer;
+ UINTN StrBufferLen;
+
+ NewBuffer = EfiLibAllocateCopyPool (BufferSize, Buffer);
+ SwapBuffer (NewBuffer, BufferSize);
+
+ StrBufferLen = BufferSize * 2 + 1;
+ Status = BufToHexString (Str, &StrBufferLen, NewBuffer, BufferSize);
+
+ gBS->FreePool (NewBuffer);
+ //
+ // Convert the uppercase to lowercase since <HexAf> is defined in lowercase format.
+ //
+ ToLower (Str);
+
+ return Status;
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------------
+// Procedure: EfiStrStr
+//
+// Description: Find a substring.
+//
+// Input: String - Null-terminated string to search.
+// StrCharSet - Null-terminated string to search for.
+//
+// Output: The address of the first occurrence of the matching substring if successful,
+// or NULL otherwise.
+//
+//----------------------------------------------------------------------------
+//<AMI_PHDR_END>
+CHAR16*
+ EfiStrStr (
+ IN CHAR16 *String,
+ IN CHAR16 *StrCharSet
+ )
+ {
+ CHAR16 *Src;
+ CHAR16 *Sub;
+
+ Src = String;
+ Sub = StrCharSet;
+
+ while ((*String != L'\0') && (*StrCharSet != L'\0')) {
+ if (*String++ != *StrCharSet++) {
+ String = ++Src;
+ StrCharSet = Sub;
+ }
+ }
+ if (*StrCharSet == L'\0') {
+ return Src;
+ } else {
+ return NULL;
+ }
+ }
+
+UINT64 Shr64(
+ IN UINT64 Value,
+ IN UINT8 Shift
+ );
+
+UINT64 Shl64(
+ IN UINT64 Value,
+ IN UINT8 Shift
+ );
+#if !TSE_APTIO_5_SUPPORT
+UINT64
+LShiftU64 (
+ IN UINT64 Operand,
+ IN UINTN Count
+ )
+{
+ UINT8 Shift;
+
+ while(Count)
+ {
+ Shift = (UINT8)((Count>256)?256:Count);
+ Operand = Shl64(Operand,Shift);
+ Count -= Shift;
+ }
+
+ return Operand;
+}
+
+UINT64
+RShiftU64 (
+ IN UINT64 Operand,
+ IN UINTN Count
+ )
+{
+ UINT8 Shift;
+
+ while(Count)
+ {
+ Shift = (UINT8)((Count>256)?256:Count);
+ Operand = Shr64(Operand,Shift);
+ Count -= Shift;
+ }
+
+ return Operand;
+}
+#endif
+UINT64 Div64 (
+ IN UINT64 Dividend,
+ IN UINTN Divisor, //Can only be 31 bits.
+ OUT UINTN *Remainder OPTIONAL
+ );
+
+UINT64
+AmiTseDivU64x32 (
+ IN UINT64 Dividend,
+ IN UINTN Divisor,
+ OUT UINTN *Remainder OPTIONAL
+ )
+{
+ return Div64(Dividend,Divisor,Remainder);
+}
+
+VOID
+EfiDebugAssert (
+ IN CHAR8 *FileName,
+ IN INTN LineNumber,
+ IN CHAR8 *Description
+ )
+{
+}
+
+VOID
+EfiDebugPrint (
+IN UINTN ErrorLevel,
+IN CHAR8 *Format,
+...
+)
+{
+}
+
+#define EFI_FORM_BROWSER_PROTOCOL_GUID \
+ { \
+ 0xe5a1333e, 0xe1b4, 0x4d55, 0xce, 0xeb, 0x35, 0xc3, 0xef, 0x13, 0x34, 0x43 \
+ }
+EFI_GUID gEfiFormBrowserProtocolGuid = EFI_FORM_BROWSER_PROTOCOL_GUID;
+
+#else //!TSE_USE_EDK_LIBRARY
+
+// To support building when TSE_USE_EDK_LIBRARY = 1
+#ifdef TSE_FOR_APTIO_4_50
+const UINTN FlashEmpty = (UINTN)(-FLASH_ERASE_POLARITY);
+const UINT32 FlashEmptyNext = (FLASH_ERASE_POLARITY ? 0xffffff : 0);
+
+VOID MemCpy(VOID* pDestination, VOID* pSource, UINTN Count)
+{
+ gBS->CopyMem (pDestination, pSource, Count);
+}
+#endif
+
+#endif //#if !TSE_USE_EDK_LIBRARY
+
+//**********************************************************************
+//**********************************************************************
+//** **
+//** (C)Copyright 1985-2010, American Megatrends, Inc. **
+//** **
+//** All Rights Reserved. **
+//** **
+//** 5555 Oakbrook Pkwy, Building 200,Norcross, Georgia 30093 **
+//** **
+//** Phone: (770)-246-8600 **
+//** **
+//**********************************************************************
+//**********************************************************************