diff options
Diffstat (limited to 'EDK/MiniSetup/BootOnly/EDKhelper.c')
| -rw-r--r-- | EDK/MiniSetup/BootOnly/EDKhelper.c | 1737 |
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 ** +//** ** +//********************************************************************** +//********************************************************************** |