/*++ | |
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. | |
Module Name: | |
Forms.c | |
Abstract: | |
This file contains the form processing code to the HII database. | |
--*/ | |
#include "HiiDatabase.h" | |
CHAR16* | |
Ascii2Unicode ( | |
OUT CHAR16 *UnicodeStr, | |
IN CHAR8 *AsciiStr | |
) | |
/*++ | |
Routine Description: | |
This function converts ASCII string to Unicode string. | |
Arguments: | |
UnicodeStr - NULL terminated Unicode output string. | |
AsciieStr - NULL terminated ASCII input string. | |
Returns: | |
Start of the Unicode ouput string. | |
--*/ | |
{ | |
CHAR16 *Str = UnicodeStr; | |
while (TRUE) { | |
*(UnicodeStr++) = (CHAR16) *AsciiStr; | |
if (*(AsciiStr++) == '\0') { | |
return Str; | |
} | |
} | |
} | |
CHAR8* | |
Unicode2Ascii ( | |
OUT CHAR8 *AsciiStr, | |
IN CHAR16 *UnicodeStr | |
) | |
/*++ | |
Routine Description: | |
This function converts Unicode string to ASCII string. | |
Arguments: | |
AsciieStr - NULL terminated ASCII output string. | |
UnicodeStr - NULL terminated Unicode input string. | |
Returns: | |
Start of the ASCII ouput string. | |
--*/ | |
{ | |
CHAR8 *Str = AsciiStr; | |
while (TRUE) { | |
*(AsciiStr++) = (CHAR8) *UnicodeStr; | |
if (*(UnicodeStr++) == '\0') { | |
return Str; | |
} | |
} | |
} | |
VOID | |
ExtractDevicePathData ( | |
IN EFI_HII_DATA_TABLE *DataTable, | |
IN UINT8 *IfrData, | |
IN OUT UINT8 **ExportBufferPtr | |
) | |
/*++ | |
Routine Description: | |
Arguments: | |
Returns: | |
--*/ | |
{ | |
UINT8 *ExportBuffer; | |
ExportBuffer = *ExportBufferPtr; | |
// | |
// BUGBUG - don't have devicepath data yet, setting dummy value | |
// | |
DataTable++; | |
ExportBuffer = (UINT8 *) DataTable; | |
((EFI_HII_DEVICE_PATH_PACK *) ExportBuffer)->Header.Type = EFI_HII_DEVICE_PATH; | |
((EFI_HII_DEVICE_PATH_PACK *) ExportBuffer)->Header.Length = (UINT32) (sizeof (EFI_HII_DEVICE_PATH_PACK) + sizeof (EFI_DEVICE_PATH_PROTOCOL)); | |
// | |
// BUGBUG - part of hack - skip the Device Path Pack.....place some data | |
// | |
ExportBuffer = ExportBuffer + sizeof (EFI_HII_DEVICE_PATH_PACK); | |
((EFI_DEVICE_PATH_PROTOCOL *) ExportBuffer)->Type = EFI_END_ENTIRE_DEVICE_PATH; | |
((EFI_DEVICE_PATH_PROTOCOL *) ExportBuffer)->SubType = EFI_END_ENTIRE_DEVICE_PATH_SUBTYPE; | |
// | |
// BUGBUG - still part of hack.... | |
// | |
ExportBuffer = ExportBuffer + sizeof (EFI_DEVICE_PATH_PROTOCOL); | |
*ExportBufferPtr = ExportBuffer; | |
} | |
VOID | |
ExtractVariableData ( | |
IN OUT EFI_HII_DATA_TABLE *DataTable, | |
IN UINT8 *IfrData, | |
IN OUT UINT8 **ExportBufferPtr | |
) | |
/*++ | |
Routine Description: | |
This function extract the EFI_HII_VARIABLE_PACK portion from the | |
each of the EFI_HII_PACKAGE_INSTANCE in HII handle database. | |
Arguments: | |
DataTable ¨C On input, this parameter point to the EFI_HII_DATA_TABLE structure | |
of the final data buffer for the EFI_HII_EXPORT interface. This function | |
update the NumberOfVariableData attribute. | |
IfrData - It points to a staring address of a EFI_HII_IFR_PACK structure. | |
ExportBufferPtr ¨C On input, it points the starting address of the data buffer to | |
host the variable pack. On output, it is the starting address | |
of data buffer for the next extraction operation. | |
Returns: | |
VOID | |
--*/ | |
{ | |
EFI_HII_VARIABLE_PACK *VariableContents; | |
UINT8 *ExportBuffer; | |
UINTN Index; | |
UINTN Index2; | |
UINTN TempValue; | |
UINTN TempValue2; | |
EFI_FORM_CALLBACK_PROTOCOL *FormCallback; | |
EFI_PHYSICAL_ADDRESS CallbackHandle; | |
EFI_STATUS Status; | |
CHAR16 *String; | |
FormCallback = NULL; | |
CallbackHandle = 0; | |
ExportBuffer = *ExportBufferPtr; | |
for (Index = 0; IfrData[Index] != EFI_IFR_END_FORM_SET_OP;) { | |
VariableContents = (EFI_HII_VARIABLE_PACK *) ExportBuffer; | |
switch (IfrData[Index]) { | |
case EFI_IFR_FORM_SET_OP: | |
TempValue = EFI_HII_VARIABLE; | |
CopyMem (&VariableContents->Header.Type, &TempValue, sizeof (UINT16)); | |
CopyMem (&TempValue, &((EFI_IFR_FORM_SET *) &IfrData[Index])->NvDataSize, sizeof (UINT16)); | |
// | |
// If the variable has 0 size, do not process it | |
// | |
if (TempValue == 0) { | |
break; | |
} | |
// | |
// Add the size of the variable pack overhead. Later, will also add the size of the | |
// name of the variable. | |
// | |
TempValue = TempValue + sizeof (EFI_HII_VARIABLE_PACK); | |
CopyMem (&VariableContents->Header.Length, &TempValue, sizeof (UINT32)); | |
CopyMem ( | |
&CallbackHandle, | |
&((EFI_IFR_FORM_SET *) &IfrData[Index])->CallbackHandle, | |
sizeof (EFI_PHYSICAL_ADDRESS) | |
); | |
if (CallbackHandle != 0) { | |
Status = gBS->HandleProtocol ( | |
(EFI_HANDLE) (UINTN) CallbackHandle, | |
&gEfiFormCallbackProtocolGuid, | |
(VOID *) &FormCallback | |
); | |
} | |
// | |
// Since we have a "Setup" variable that wasn't specified by a variable op-code | |
// it will have a VariableId of 0. All other variable op-codes will have a designation | |
// of VariableId 1+ | |
// | |
TempValue = 0; | |
CopyMem (&VariableContents->VariableId, &TempValue, sizeof (UINT16)); | |
CopyMem (&VariableContents->VariableGuid, &((EFI_IFR_FORM_SET *) &IfrData[Index])->Guid, sizeof (EFI_GUID)); | |
TempValue = sizeof (SETUP_MAP_NAME); | |
CopyMem (&VariableContents->VariableNameLength, &TempValue, sizeof (UINT32)); | |
// | |
// Add the size of the name to the Header Length | |
// | |
TempValue2 = 0; | |
CopyMem (&TempValue2, &VariableContents->Header.Length, sizeof (UINT32)); | |
TempValue2 = TempValue + TempValue2; | |
CopyMem (&VariableContents->Header.Length, &TempValue2, sizeof (UINT32)); | |
ExportBuffer = ExportBuffer + sizeof (EFI_HII_VARIABLE_PACK); | |
CopyMem (ExportBuffer, SETUP_MAP_NAME, sizeof (SETUP_MAP_NAME)); | |
ExportBuffer = ExportBuffer + sizeof (SETUP_MAP_NAME); | |
CopyMem (&TempValue, &((EFI_IFR_FORM_SET *) &IfrData[Index])->NvDataSize, sizeof (UINT16)); | |
if ((FormCallback != NULL) && (FormCallback->NvRead != NULL)) { | |
Status = FormCallback->NvRead ( | |
FormCallback, | |
(CHAR16 *) SETUP_MAP_NAME, | |
(EFI_GUID *)(UINTN)&VariableContents->VariableGuid, | |
NULL, | |
&TempValue, | |
ExportBuffer | |
); | |
} else { | |
Status = gRT->GetVariable ( | |
(CHAR16 *) SETUP_MAP_NAME, | |
(EFI_GUID *)(UINTN)&VariableContents->VariableGuid, | |
NULL, | |
&TempValue, | |
ExportBuffer | |
); | |
} | |
ExportBuffer = (UINT8 *) (UINTN) (((UINTN) ExportBuffer) + TempValue); | |
DataTable->NumberOfVariableData++; | |
break; | |
case EFI_IFR_VARSTORE_OP: | |
TempValue = EFI_HII_VARIABLE; | |
CopyMem (&VariableContents->Header.Type, &TempValue, sizeof (UINT16)); | |
CopyMem (&TempValue, &((EFI_IFR_VARSTORE *) &IfrData[Index])->Size, sizeof (UINT16)); | |
// | |
// If the variable has 0 size, do not process it | |
// | |
if (TempValue == 0) { | |
break; | |
} | |
// | |
// Add the size of the variable pack overhead. Later, will also add the size of the | |
// name of the variable. | |
// | |
TempValue = TempValue + sizeof (EFI_HII_VARIABLE_PACK); | |
CopyMem (&VariableContents->Header.Length, &TempValue, sizeof (UINT32)); | |
CopyMem (&VariableContents->VariableId, &((EFI_IFR_VARSTORE *) &IfrData[Index])->VarId, sizeof (UINT16)); | |
CopyMem (&VariableContents->VariableGuid, &((EFI_IFR_VARSTORE *) &IfrData[Index])->Guid, sizeof (EFI_GUID)); | |
TempValue = (UINTN) ((EFI_IFR_VARSTORE *) &IfrData[Index])->Header.Length - sizeof (EFI_IFR_VARSTORE); | |
TempValue = TempValue * 2; | |
CopyMem (&VariableContents->VariableNameLength, &TempValue, sizeof (UINT32)); | |
// | |
// Add the size of the name to the Header Length | |
// | |
TempValue2 = 0; | |
CopyMem (&TempValue2, &VariableContents->Header.Length, sizeof (UINT32)); | |
TempValue2 = TempValue + TempValue2; | |
CopyMem (&VariableContents->Header.Length, &TempValue2, sizeof (UINT32)); | |
ExportBuffer = ExportBuffer + sizeof (EFI_HII_VARIABLE_PACK); | |
String = (CHAR16 *) ExportBuffer; | |
for (Index2 = 0; Index2 < TempValue / 2; Index2++) { | |
ExportBuffer[Index2 * 2] = IfrData[Index + sizeof (EFI_IFR_VARSTORE) + Index2]; | |
ExportBuffer[Index2 * 2 + 1] = 0; | |
} | |
ExportBuffer = ExportBuffer + TempValue; | |
CopyMem (&TempValue, &((EFI_IFR_VARSTORE *) &IfrData[Index])->Size, sizeof (UINT16)); | |
if ((FormCallback != NULL) && (FormCallback->NvRead != NULL)) { | |
Status = FormCallback->NvRead ( | |
FormCallback, | |
String, | |
(EFI_GUID *)(UINTN)&VariableContents->VariableGuid, | |
NULL, | |
&TempValue, | |
ExportBuffer | |
); | |
} else { | |
Status = gRT->GetVariable ( | |
String, | |
(EFI_GUID *)(UINTN)&VariableContents->VariableGuid, | |
NULL, | |
&TempValue, | |
ExportBuffer | |
); | |
} | |
ExportBuffer = (UINT8 *) (UINTN) (((UINTN) ExportBuffer) + TempValue); | |
DataTable->NumberOfVariableData++; | |
break; | |
} | |
Index = IfrData[Index + 1] + Index; | |
} | |
// | |
// If we have added a variable pack, add a dummy empty one to signify the end | |
// | |
if (ExportBuffer != *ExportBufferPtr) { | |
VariableContents = (EFI_HII_VARIABLE_PACK *) ExportBuffer; | |
TempValue = EFI_HII_VARIABLE; | |
CopyMem (&VariableContents->Header.Type, &TempValue, sizeof (UINT16)); | |
TempValue = sizeof (EFI_HII_VARIABLE_PACK); | |
CopyMem (&VariableContents->Header.Length, &TempValue, sizeof (UINT32)); | |
ExportBuffer = ExportBuffer + sizeof (EFI_HII_VARIABLE_PACK); | |
} | |
*ExportBufferPtr = ExportBuffer; | |
} | |
EFI_STATUS | |
EFIAPI | |
HiiExportDatabase ( | |
IN EFI_HII_PROTOCOL *This, | |
IN EFI_HII_HANDLE Handle, | |
IN OUT UINTN *BufferSize, | |
OUT VOID *Buffer | |
) | |
/*++ | |
Routine Description: | |
This function allows a program to extract a form or form package that has | |
previously been registered with the EFI HII database. | |
Arguments: | |
Returns: | |
--*/ | |
{ | |
EFI_HII_PACKAGE_INSTANCE *PackageInstance; | |
EFI_HII_DATA *HiiData; | |
EFI_HII_HANDLE_DATABASE *HandleDatabase; | |
EFI_HII_IFR_PACK *FormPack; | |
UINT8 *RawData; | |
UINT8 *ExportBuffer; | |
EFI_HII_EXPORT_TABLE *ExportTable; | |
EFI_HII_DATA_TABLE *DataTable; | |
BOOLEAN InsufficientSize; | |
BOOLEAN VariableExist; | |
UINT16 NumberOfHiiDataTables; | |
UINTN SizeNeeded; | |
UINTN Index; | |
UINTN VariableSize; | |
UINTN TempValue; | |
if (This == NULL) { | |
return EFI_INVALID_PARAMETER; | |
} | |
HiiData = EFI_HII_DATA_FROM_THIS (This); | |
HandleDatabase = HiiData->DatabaseHead; | |
FormPack = NULL; | |
RawData = NULL; | |
PackageInstance = NULL; | |
InsufficientSize = FALSE; | |
NumberOfHiiDataTables = 0; | |
VariableSize = 0; | |
TempValue = 0; | |
SizeNeeded = sizeof (EFI_HII_EXPORT_TABLE); | |
// | |
// How many total tables are there? | |
// | |
for (; HandleDatabase != NULL; HandleDatabase = HandleDatabase->NextHandleDatabase) { | |
if ((Handle != 0) && (Handle != HandleDatabase->Handle)) { | |
continue; | |
} | |
VariableExist = FALSE; | |
NumberOfHiiDataTables++; | |
PackageInstance = HandleDatabase->Buffer; | |
if (PackageInstance == NULL) { | |
continue; | |
} | |
// | |
// Extract Size of Export Package | |
// | |
SizeNeeded = SizeNeeded + PackageInstance->IfrSize | |
+ PackageInstance->StringSize | |
+ sizeof (EFI_HII_DATA_TABLE) | |
+ sizeof (EFI_HII_DEVICE_PATH_PACK); | |
// | |
// BUGBUG We aren't inserting Device path data yet | |
// | |
SizeNeeded = SizeNeeded + sizeof (EFI_DEVICE_PATH_PROTOCOL); | |
// | |
// Extract Size of Variable Data | |
// | |
if (PackageInstance->IfrSize > 0) { | |
FormPack = (EFI_HII_IFR_PACK *) ((CHAR8 *) (&PackageInstance->IfrData) + sizeof (EFI_HII_PACK_HEADER)); | |
} else { | |
// | |
// No IFR? No variable information | |
// | |
continue; | |
} | |
RawData = (UINT8 *) FormPack; | |
for (Index = 0; RawData[Index] != EFI_IFR_END_FORM_SET_OP;) { | |
switch (RawData[Index]) { | |
case EFI_IFR_FORM_SET_OP: | |
CopyMem (&VariableSize, &((EFI_IFR_FORM_SET *) &RawData[Index])->NvDataSize, sizeof (UINT16)); | |
SizeNeeded = SizeNeeded + VariableSize + sizeof (SETUP_MAP_NAME) + sizeof (EFI_HII_VARIABLE_PACK); | |
VariableExist = TRUE; | |
break; | |
case EFI_IFR_VARSTORE_OP: | |
CopyMem (&VariableSize, &((EFI_IFR_VARSTORE *) &RawData[Index])->Size, sizeof (UINT16)); | |
SizeNeeded = SizeNeeded + VariableSize + sizeof (EFI_HII_VARIABLE_PACK); | |
// | |
// We will be expanding the stored ASCII name to a Unicode string. This will cause some memory overhead | |
// Since the VARSTORE size already takes in consideration the ASCII size, we need to size it and add another | |
// instance of it. Essentially, 2 ASCII strings == 1 Unicode string in size. | |
// | |
TempValue = (UINTN) ((EFI_IFR_VARSTORE *) &RawData[Index])->Header.Length - sizeof (EFI_IFR_VARSTORE); | |
SizeNeeded = SizeNeeded + TempValue * 2; | |
VariableExist = TRUE; | |
break; | |
} | |
Index = RawData[Index + 1] + Index; | |
} | |
// | |
// If a variable exists for this handle, add an additional variable pack overhead to | |
// indicate that we will have an extra null Variable Pack to signify the end of the Variable Packs | |
// | |
if (VariableExist) { | |
SizeNeeded = SizeNeeded + sizeof (EFI_HII_VARIABLE_PACK); | |
} | |
} | |
if (SizeNeeded > *BufferSize) { | |
*BufferSize = SizeNeeded; | |
return EFI_BUFFER_TOO_SMALL; | |
} | |
// | |
// Zero out the incoming buffer | |
// | |
ZeroMem (Buffer, *BufferSize); | |
// | |
// Cast the Buffer to EFI_HII_EXPORT_TABLE | |
// | |
ExportTable = (EFI_HII_EXPORT_TABLE *) Buffer; | |
// | |
// Set the Revision for the Export Table | |
// | |
CopyMem (&ExportTable->Revision, &gEfiHiiProtocolGuid, sizeof (EFI_GUID)); | |
ExportBuffer = (UINT8 *) (UINTN) (((UINT8 *) ExportTable) + sizeof (EFI_HII_EXPORT_TABLE)); | |
HandleDatabase = HiiData->DatabaseHead; | |
// | |
// Check numeric value against the head of the database | |
// | |
for (; HandleDatabase != NULL; HandleDatabase = HandleDatabase->NextHandleDatabase) { | |
DataTable = (EFI_HII_DATA_TABLE *) ExportBuffer; | |
PackageInstance = HandleDatabase->Buffer; | |
// | |
// If not asking for a specific handle, export the entire database | |
// | |
if (Handle == 0) { | |
ExportTable->NumberOfHiiDataTables = NumberOfHiiDataTables; | |
CopyMem (&DataTable->PackageGuid, &PackageInstance->Guid, sizeof (EFI_GUID)); | |
DataTable->HiiHandle = PackageInstance->Handle; | |
DataTable->DevicePathOffset = (UINT32) (sizeof (EFI_HII_DATA_TABLE)); | |
// | |
// Start Dumping DevicePath | |
// | |
ExtractDevicePathData (DataTable, RawData, &ExportBuffer); | |
if (((UINTN) ExportBuffer) == ((UINTN) DataTable)) { | |
// | |
// If there is no DevicePath information - set offset to 0 to signify the absence of data to parse | |
// | |
DataTable->DevicePathOffset = 0; | |
} | |
DataTable->VariableDataOffset = (UINT32) (((UINTN) ExportBuffer) - ((UINTN) DataTable)); | |
if (PackageInstance->IfrSize > 0) { | |
FormPack = (EFI_HII_IFR_PACK *) ((CHAR8 *) (&PackageInstance->IfrData) + sizeof (EFI_HII_PACK_HEADER)); | |
RawData = (UINT8 *) FormPack; | |
TempValue = 0; | |
// | |
// Start dumping the Variable Data | |
// | |
ExtractVariableData (DataTable, RawData, &ExportBuffer); | |
DataTable->IfrDataOffset = (UINT32) (((UINTN) ExportBuffer) - ((UINTN) DataTable)); | |
if (DataTable->VariableDataOffset == DataTable->IfrDataOffset) { | |
DataTable->VariableDataOffset = 0; | |
} | |
// | |
// Start dumping the IFR data (Note: It is in an IFR PACK) | |
// | |
CopyMem (ExportBuffer, &PackageInstance->IfrData, PackageInstance->IfrSize); | |
ExportBuffer = (UINT8 *) (UINTN) (((UINTN) ExportBuffer) + PackageInstance->IfrSize); | |
DataTable->StringDataOffset = (UINT32) (((UINTN) ExportBuffer) - ((UINTN) DataTable)); | |
// | |
// Start dumping the String data (Note: It is in a String PACK) | |
// | |
if (PackageInstance->StringSize > 0) { | |
RawData = (UINT8 *) (((UINTN) &PackageInstance->IfrData) + PackageInstance->IfrSize); | |
CopyMem (ExportBuffer, RawData, PackageInstance->StringSize); | |
DataTable->DataTableSize = (UINT32) (DataTable->StringDataOffset + PackageInstance->StringSize); | |
CopyMem (&TempValue, &((EFI_HII_STRING_PACK *) ExportBuffer)->Header.Length, sizeof (UINT32)); | |
for (; TempValue != 0;) { | |
DataTable->NumberOfLanguages++; | |
ExportBuffer = ExportBuffer + ((EFI_HII_STRING_PACK *) ExportBuffer)->Header.Length; | |
CopyMem (&TempValue, &((EFI_HII_STRING_PACK *) ExportBuffer)->Header.Length, sizeof (UINT32)); | |
} | |
ExportBuffer = ExportBuffer + sizeof (EFI_HII_STRING_PACK); | |
} else { | |
DataTable->StringDataOffset = 0; | |
} | |
} else { | |
// | |
// No IFR? No variable information. If Offset is 0, means there is none. (Hmm - this might be prunable - no strings to export if no IFR - we always have a stub) | |
// | |
DataTable->VariableDataOffset = 0; | |
DataTable->IfrDataOffset = 0; | |
DataTable->StringDataOffset = (UINT32) (((UINTN) ExportBuffer) - ((UINTN) DataTable)); | |
// | |
// Start dumping the String data - NOTE: It is in String Pack form | |
// | |
if (PackageInstance->StringSize > 0) { | |
RawData = (UINT8 *) (((UINTN) &PackageInstance->IfrData) + PackageInstance->IfrSize); | |
CopyMem (ExportBuffer, RawData, PackageInstance->StringSize); | |
DataTable->DataTableSize = (UINT32) (DataTable->StringDataOffset + PackageInstance->StringSize); | |
CopyMem (&TempValue, &((EFI_HII_STRING_PACK *) ExportBuffer)->Header.Length, sizeof (UINT32)); | |
for (; TempValue != 0;) { | |
DataTable->NumberOfLanguages++; | |
ExportBuffer = ExportBuffer + ((EFI_HII_STRING_PACK *) ExportBuffer)->Header.Length; | |
CopyMem (&TempValue, &((EFI_HII_STRING_PACK *) ExportBuffer)->Header.Length, sizeof (UINT32)); | |
} | |
ExportBuffer = ExportBuffer + sizeof (EFI_HII_STRING_PACK); | |
} else { | |
DataTable->StringDataOffset = 0; | |
} | |
} | |
} else { | |
// | |
// Match the numeric value with the database entry - if matched, extract PackageInstance | |
// | |
if (Handle == HandleDatabase->Handle) { | |
PackageInstance = HandleDatabase->Buffer; | |
ExportTable->NumberOfHiiDataTables = NumberOfHiiDataTables; | |
DataTable->HiiHandle = PackageInstance->Handle; | |
CopyMem (&DataTable->PackageGuid, &PackageInstance->Guid, sizeof (EFI_GUID)); | |
// | |
// Start Dumping DevicePath | |
// | |
ExtractDevicePathData (DataTable, RawData, &ExportBuffer); | |
DataTable->VariableDataOffset = (UINT32) (((UINTN) ExportBuffer) - ((UINTN) DataTable)); | |
if (PackageInstance->IfrSize > 0) { | |
FormPack = (EFI_HII_IFR_PACK *) ((CHAR8 *) (&PackageInstance->IfrData) + sizeof (EFI_HII_PACK_HEADER)); | |
RawData = (UINT8 *) FormPack; | |
TempValue = 0; | |
// | |
// Start dumping the Variable Data | |
// | |
ExtractVariableData (DataTable, RawData, &ExportBuffer); | |
DataTable->IfrDataOffset = (UINT32) (((UINTN) ExportBuffer) - ((UINTN) DataTable)); | |
if (DataTable->VariableDataOffset == DataTable->IfrDataOffset) { | |
DataTable->VariableDataOffset = 0; | |
} | |
// | |
// Start dumping the IFR data | |
// | |
CopyMem (ExportBuffer, &PackageInstance->IfrData, PackageInstance->IfrSize); | |
ExportBuffer = (UINT8 *) (UINTN) (((UINTN) ExportBuffer) + PackageInstance->IfrSize); | |
DataTable->StringDataOffset = (UINT32) (((UINTN) ExportBuffer) - ((UINTN) DataTable)); | |
// | |
// Start dumping the String data - NOTE: It is in String Pack form | |
// | |
if (PackageInstance->StringSize > 0) { | |
RawData = (UINT8 *) (((UINTN) &PackageInstance->IfrData) + PackageInstance->IfrSize); | |
CopyMem (ExportBuffer, RawData, PackageInstance->StringSize); | |
DataTable->DataTableSize = (UINT32) (DataTable->StringDataOffset + PackageInstance->StringSize); | |
CopyMem (&TempValue, &((EFI_HII_STRING_PACK *) ExportBuffer)->Header.Length, sizeof (UINT32)); | |
for (; TempValue != 0;) { | |
DataTable->NumberOfLanguages++; | |
ExportBuffer = ExportBuffer + ((EFI_HII_STRING_PACK *) ExportBuffer)->Header.Length; | |
CopyMem (&TempValue, &((EFI_HII_STRING_PACK *) ExportBuffer)->Header.Length, sizeof (UINT32)); | |
} | |
ExportBuffer = ExportBuffer + sizeof (EFI_HII_STRING_PACK); | |
} else { | |
DataTable->StringDataOffset = 0; | |
} | |
} else { | |
// | |
// No IFR? No variable information. If Offset is 0, means there is none. | |
// | |
DataTable->VariableDataOffset = 0; | |
DataTable->IfrDataOffset = 0; | |
DataTable->StringDataOffset = (UINT32) (((UINTN) ExportBuffer) - ((UINTN) DataTable)); | |
// | |
// Start dumping the String data - Note: It is in String Pack form | |
// | |
if (PackageInstance->StringSize > 0) { | |
RawData = (UINT8 *) (((UINTN) &PackageInstance->IfrData) + PackageInstance->IfrSize); | |
CopyMem (ExportBuffer, RawData, PackageInstance->StringSize); | |
DataTable->DataTableSize = (UINT32) (DataTable->StringDataOffset + PackageInstance->StringSize); | |
CopyMem (&TempValue, &((EFI_HII_STRING_PACK *) ExportBuffer)->Header.Length, sizeof (UINT32)); | |
for (; TempValue != 0;) { | |
DataTable->NumberOfLanguages++; | |
ExportBuffer = ExportBuffer + ((EFI_HII_STRING_PACK *) ExportBuffer)->Header.Length; | |
CopyMem (&TempValue, &((EFI_HII_STRING_PACK *) ExportBuffer)->Header.Length, sizeof (UINT32)); | |
} | |
ExportBuffer = ExportBuffer + sizeof (EFI_HII_STRING_PACK); | |
} else { | |
DataTable->StringDataOffset = 0; | |
} | |
} | |
break; | |
} | |
} | |
} | |
return EFI_SUCCESS; | |
} | |
EFI_STATUS | |
EFIAPI | |
HiiGetForms ( | |
IN EFI_HII_PROTOCOL *This, | |
IN EFI_HII_HANDLE Handle, | |
IN EFI_FORM_ID FormId, | |
IN OUT UINTN *BufferLengthTemp, | |
OUT UINT8 *Buffer | |
) | |
/*++ | |
Routine Description: | |
This function allows a program to extract a form or form package that has | |
previously been registered with the EFI HII database. | |
Arguments: | |
This - A pointer to the EFI_HII_PROTOCOL instance. | |
Handle - Handle on which the form resides. Type EFI_HII_HANDLE is defined in | |
EFI_HII_PROTOCOL.NewPack() in the Packages section. | |
FormId - The ID of the form to return. If the ID is zero, the entire form package is returned. | |
Type EFI_FORM_ID is defined in "Related Definitions" below. | |
BufferLength - On input, the length of the Buffer. On output, the length of the returned buffer, if | |
the length was sufficient and, if it was not, the length that is required to fit the | |
requested form(s). | |
Buffer - The buffer designed to receive the form(s). | |
Returns: | |
EFI_SUCCESS - Buffer filled with the requested forms. BufferLength | |
was updated. | |
EFI_INVALID_PARAMETER - The handle is unknown. | |
EFI_NOT_FOUND - A form on the requested handle cannot be found with the | |
requested FormId. | |
EFI_BUFFER_TOO_SMALL - The buffer provided was not large enough to allow the form to be stored. | |
--*/ | |
{ | |
EFI_HII_PACKAGE_INSTANCE *PackageInstance; | |
EFI_HII_DATA *HiiData; | |
EFI_HII_HANDLE_DATABASE *HandleDatabase; | |
EFI_HII_IFR_PACK *FormPack; | |
EFI_IFR_FORM *Form; | |
EFI_IFR_OP_HEADER *Location; | |
UINT16 *BufferLength = (UINT16 *) BufferLengthTemp; | |
if (This == NULL) { | |
return EFI_INVALID_PARAMETER; | |
} | |
HiiData = EFI_HII_DATA_FROM_THIS (This); | |
HandleDatabase = HiiData->DatabaseHead; | |
PackageInstance = NULL; | |
// | |
// Check numeric value against the head of the database | |
// | |
for (; HandleDatabase != NULL; HandleDatabase = HandleDatabase->NextHandleDatabase) { | |
// | |
// Match the numeric value with the database entry - if matched, extract PackageInstance | |
// | |
if (Handle == HandleDatabase->Handle) { | |
PackageInstance = HandleDatabase->Buffer; | |
break; | |
} | |
} | |
// | |
// No handle was found - error condition | |
// | |
if (PackageInstance == NULL) { | |
return EFI_NOT_FOUND; | |
} | |
// | |
// Based on if there is IFR data in this package instance, determine | |
// what the location is of the beginning of the string data. | |
// | |
if (PackageInstance->IfrSize > 0) { | |
FormPack = (EFI_HII_IFR_PACK *) (&PackageInstance->IfrData); | |
} else { | |
// | |
// If there is no IFR data return an error | |
// | |
return EFI_NOT_FOUND; | |
} | |
// | |
// If requesting the entire Form Package | |
// | |
if (FormId == 0) { | |
// | |
// Return an error if buffer is too small | |
// | |
if (PackageInstance->IfrSize > *BufferLength || Buffer == NULL) { | |
*BufferLength = (UINT16) PackageInstance->IfrSize; | |
return EFI_BUFFER_TOO_SMALL; | |
} | |
CopyMem (Buffer, FormPack, PackageInstance->IfrSize); | |
return EFI_SUCCESS; | |
} else { | |
FormPack = (EFI_HII_IFR_PACK *) ((CHAR8 *) (&PackageInstance->IfrData) + sizeof (EFI_HII_PACK_HEADER)); | |
Location = (EFI_IFR_OP_HEADER *) FormPack; | |
// | |
// Look for the FormId requested | |
// | |
for (; Location->OpCode != EFI_IFR_END_FORM_SET_OP;) { | |
switch (Location->OpCode) { | |
case EFI_IFR_FORM_OP: | |
Form = (EFI_IFR_FORM *) Location; | |
// | |
// If we found a Form Op-code and it is of the correct Id, copy it and return | |
// | |
if (Form->FormId == FormId) { | |
if (Location->Length > *BufferLength || Buffer == NULL) { | |
*BufferLength = Location->Length; | |
return EFI_BUFFER_TOO_SMALL; | |
} else { | |
for (; Location->OpCode != EFI_IFR_END_FORM_OP;) { | |
CopyMem (Buffer, Location, Location->Length); | |
Buffer = Buffer + Location->Length; | |
Location = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (Location) + Location->Length); | |
} | |
CopyMem (Buffer, Location, Location->Length); | |
return EFI_SUCCESS; | |
} | |
} | |
default: | |
break; | |
} | |
// | |
// Go to the next Op-Code | |
// | |
Location = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (Location) + Location->Length); | |
} | |
} | |
return EFI_SUCCESS; | |
} | |
// | |
// Helper functions to HiiGetDefaultImage() | |
// | |
STATIC | |
UINT8* | |
HiiGetDefaultImageInitPack ( | |
IN OUT EFI_HII_VARIABLE_PACK_LIST *VariablePackItem, | |
IN EFI_IFR_VARSTORE *VarStore | |
) | |
/*++ | |
Routine Description: | |
Initialize the EFI_HII_VARIABLE_PACK_LIST structure and | |
prepare it ready to be used by HiiGetDefaultImagePopulateMap (). | |
Arguments: | |
VariablePackItem - Variable Package List. | |
VarStore - IFR variable storage. | |
Returns: | |
Return the pointer to the Map space. | |
--*/ | |
{ | |
CHAR16 *Name16; | |
CHAR8 *Name8; | |
CHAR8 *Map; | |
EFI_HII_VARIABLE_PACK *VariablePack; | |
// | |
// Set pointer the pack right after the node | |
// | |
VariablePackItem->VariablePack = (EFI_HII_VARIABLE_PACK *) (VariablePackItem + 1); | |
VariablePack = VariablePackItem->VariablePack; | |
// | |
// Copy the var name to VariablePackItem from VarStore | |
// Needs ASCII->Unicode conversion. | |
// | |
ASSERT (VarStore->Header.Length > sizeof (*VarStore)); | |
Name8 = (CHAR8 *) (VarStore + 1); | |
Name16 = (CHAR16 *) (VariablePack + 1); | |
Ascii2Unicode (Name16, Name8); | |
// | |
// Compute the other fields of the VariablePackItem | |
// | |
VariablePack->VariableId = VarStore->VarId; | |
CopyMem (&VariablePack->VariableGuid, &VarStore->Guid, sizeof (EFI_GUID)); | |
VariablePack->VariableNameLength = (UINT32) ((StrLen (Name16) + 1) * 2); | |
VariablePack->Header.Length = sizeof (*VariablePack) | |
+ VariablePack->VariableNameLength | |
+ VarStore->Size; | |
// | |
// Return the pointer to the Map space. | |
// | |
Map = (CHAR8 *) Name16 + VariablePack->VariableNameLength; | |
return (UINT8 *)Map; | |
} | |
STATIC | |
VOID | |
HiiGetDefaultImagePopulateMap ( | |
IN OUT UINT8 *Map, | |
IN EFI_IFR_OP_HEADER *FormSet, | |
IN EFI_IFR_VARSTORE *VarStore, | |
IN UINTN DefaultMask | |
) | |
/*++ | |
Routine Description: | |
Fill the Map with all the default values either from NV or Hii database. | |
Arguments: | |
Map - Memory pointer to hold the default values. | |
FormSet - The starting EFI_IFR_OP_HEADER to begin retriving default values. | |
VarStore - IFR variable storage. | |
DefaultMask - The mask used to get the default variable. | |
Returns: | |
VOID | |
--*/ | |
{ | |
EFI_STATUS Status; | |
EFI_IFR_OP_HEADER *IfrItem; | |
UINT16 VarId; | |
EFI_IFR_VARSTORE_SELECT *VarSelect; | |
EFI_IFR_ONE_OF_OPTION *OneOfOpt; | |
EFI_IFR_CHECKBOX *CheckBox; | |
EFI_IFR_NUMERIC *Numeric; | |
UINTN Size; | |
UINTN SizeTmp; | |
EFI_IFR_NV_DATA *IfrNvData; | |
EFI_GUID Guid; | |
CHAR16 *Name16; | |
CHAR8 *Name8; | |
EFI_HANDLE CallbackHandle; | |
EFI_FORM_CALLBACK_PROTOCOL *FormCallbackProt; | |
// | |
// Get the Map's Name/Guid/Szie from the Varstore. | |
// VARSTORE contains the Name in ASCII format (@#$^&!), must convert it to Unicode. | |
// | |
ASSERT (VarStore->Header.Length >= sizeof (*VarStore)); | |
Name8 = (CHAR8 *) (VarStore + 1); | |
Name16 = AllocateZeroPool ((VarStore->Header.Length - sizeof (*VarStore)) * sizeof (CHAR16)); | |
Ascii2Unicode (Name16, Name8); | |
CopyMem (&Guid, &VarStore->Guid, sizeof(EFI_GUID)); | |
Size = VarStore->Size; | |
// | |
// First, check if the map exists in the NV. If so, get it from NV and exit. | |
// | |
if (DefaultMask == EFI_IFR_FLAG_MANUFACTURING) { | |
// | |
// Check if Manufaturing Defaults exist in the NV. | |
// | |
Status = EfiLibHiiVariableOverrideBySuffix ( | |
HII_VARIABLE_SUFFIX_MANUFACTURING_OVERRIDE, | |
Name16, | |
&Guid, | |
Size, | |
Map | |
); | |
} else { | |
// | |
// All other cases default to Defaults. Check if Defaults exist in the NV. | |
// | |
Status = EfiLibHiiVariableOverrideBySuffix ( | |
HII_VARIABLE_SUFFIX_DEFAULT_OVERRIDE, | |
Name16, | |
&Guid, | |
Size, | |
Map | |
); | |
} | |
if (!EFI_ERROR (Status)) { | |
// | |
// Either Defaults/Manufacturing variable exists and appears to be valid. | |
// The map is read, exit w/ success now. | |
// | |
gBS->FreePool (Name16); | |
return; | |
} | |
// | |
// First, prime the map with what already is in the NV. | |
// This is needed to cover a situation where the IFR does not contain all the | |
// defaults; either deliberately not having appropriate IFR, or in case of IFR_STRING, there is no default. | |
// Ignore status. Either it gets read or not. | |
// | |
FormCallbackProt = NULL; | |
CopyMem (&CallbackHandle, &((EFI_IFR_FORM_SET*) FormSet)->CallbackHandle, sizeof (CallbackHandle)); | |
if (CallbackHandle != NULL) { | |
Status = gBS->HandleProtocol ( | |
(EFI_HANDLE) (UINTN) CallbackHandle, | |
&gEfiFormCallbackProtocolGuid, | |
(VOID *) &FormCallbackProt | |
); | |
} | |
if ((NULL != FormCallbackProt) && (NULL != FormCallbackProt->NvRead)) { | |
// | |
// Attempt to read using NvRead() callback. Probe first for existence and correct variable size. | |
// | |
SizeTmp = 0; | |
Status = FormCallbackProt->NvRead ( | |
FormCallbackProt, | |
Name16, | |
&Guid, | |
0, | |
&SizeTmp, | |
NULL | |
); | |
if ((EFI_BUFFER_TOO_SMALL == Status) && (SizeTmp == Size)) { | |
Status = FormCallbackProt->NvRead ( | |
FormCallbackProt, | |
Name16, | |
&Guid, | |
0, | |
&SizeTmp, | |
Map | |
); | |
ASSERT_EFI_ERROR (Status); | |
ASSERT (SizeTmp == Size); | |
} | |
} else { | |
// | |
// No callback available for this formset, read straight from NV. Deliberately ignore the Status. | |
// The buffer will only be written if variable exists nd has correct size. | |
// | |
Status = EfiLibHiiVariableRetrieveFromNv ( | |
Name16, | |
&Guid, | |
Size, | |
(VOID **) &Map | |
); | |
} | |
// | |
// Iterate all IFR statements and for applicable, retrieve the default into the Map. | |
// | |
for (IfrItem = FormSet, VarId = 0; | |
IfrItem->OpCode != EFI_IFR_END_FORM_SET_OP; | |
IfrItem = (EFI_IFR_OP_HEADER *) ((UINT8*) IfrItem + IfrItem->Length) | |
) { | |
// | |
// Observe VarStore switch. | |
// | |
if (EFI_IFR_VARSTORE_SELECT_OP == IfrItem->OpCode) { | |
VarSelect = (EFI_IFR_VARSTORE_SELECT *) IfrItem; | |
VarId = VarSelect->VarId; | |
continue; | |
} | |
// | |
// Skip opcodes that reference other VarStore than that specific to current map. | |
// | |
if (VarId != VarStore->VarId) { | |
continue; | |
} | |
// | |
// Extract the default value from this opcode if applicable, and apply it to the map. | |
// | |
IfrNvData = (EFI_IFR_NV_DATA *) IfrItem; | |
switch (IfrItem->OpCode) { | |
case EFI_IFR_ONE_OF_OP: | |
ASSERT (IfrNvData->QuestionId + IfrNvData->StorageWidth <= VarStore->Size); | |
// | |
// Get to the first EFI_IFR_ONE_OF_OPTION_OP | |
// | |
IfrItem = (EFI_IFR_OP_HEADER *) ((UINT8*) IfrItem + IfrItem->Length); | |
ASSERT (EFI_IFR_ONE_OF_OPTION_OP == IfrItem->OpCode); | |
OneOfOpt = (EFI_IFR_ONE_OF_OPTION *)IfrItem; | |
// | |
// In the worst case, the first will be the default. | |
// | |
CopyMem (Map + IfrNvData->QuestionId, &OneOfOpt->Value, IfrNvData->StorageWidth); | |
while (EFI_IFR_ONE_OF_OPTION_OP == IfrItem->OpCode) { | |
OneOfOpt = (EFI_IFR_ONE_OF_OPTION *)IfrItem; | |
if (DefaultMask == EFI_IFR_FLAG_MANUFACTURING) { | |
if (0 != (OneOfOpt->Flags & EFI_IFR_FLAG_MANUFACTURING)) { | |
// | |
// In the worst case, the first will be the default. | |
// | |
CopyMem (Map + IfrNvData->QuestionId, &OneOfOpt->Value, IfrNvData->StorageWidth); | |
break; | |
} | |
} else { | |
if (OneOfOpt->Flags & EFI_IFR_FLAG_DEFAULT) { | |
// | |
// In the worst case, the first will be the default. | |
// | |
CopyMem (Map + IfrNvData->QuestionId, &OneOfOpt->Value, IfrNvData->StorageWidth); | |
break; | |
} | |
} | |
IfrItem = (EFI_IFR_OP_HEADER *)((UINT8*)IfrItem + IfrItem->Length); | |
} | |
continue; | |
break; | |
case EFI_IFR_CHECKBOX_OP: | |
ASSERT (IfrNvData->QuestionId + IfrNvData->StorageWidth <= VarStore->Size); | |
CheckBox = (EFI_IFR_CHECK_BOX *)IfrItem; | |
if (DefaultMask == EFI_IFR_FLAG_MANUFACTURING) { | |
if (0 != (CheckBox->Flags & EFI_IFR_FLAG_MANUFACTURING)) { | |
*(UINT8 *) (Map + IfrNvData->QuestionId) = TRUE; | |
} | |
} else { | |
if (CheckBox->Flags & EFI_IFR_FLAG_DEFAULT) { | |
*(UINT8 *) (Map + IfrNvData->QuestionId) = TRUE; | |
} | |
} | |
break; | |
case EFI_IFR_NUMERIC_OP: | |
ASSERT (IfrNvData->QuestionId + IfrNvData->StorageWidth <= VarStore->Size); | |
Numeric = (EFI_IFR_NUMERIC *) IfrItem; | |
CopyMem (Map + IfrNvData->QuestionId, &Numeric->Default, IfrNvData->StorageWidth); | |
break; | |
case EFI_IFR_ORDERED_LIST_OP: | |
case EFI_IFR_PASSWORD_OP: | |
case EFI_IFR_STRING_OP: | |
// | |
// No support for default value for these opcodes. | |
// | |
break; | |
} | |
} | |
gBS->FreePool (Name16); | |
} | |
EFI_STATUS | |
EFIAPI | |
HiiGetDefaultImage ( | |
IN EFI_HII_PROTOCOL *This, | |
IN EFI_HII_HANDLE Handle, | |
IN UINTN DefaultMask, | |
OUT EFI_HII_VARIABLE_PACK_LIST **VariablePackList | |
) | |
/*++ | |
Routine Description: | |
This function allows a program to extract the NV Image | |
that represents the default storage image | |
Arguments: | |
This - A pointer to the EFI_HII_PROTOCOL instance. | |
Handle - The HII handle from which will have default data retrieved. | |
UINTN - Mask used to retrieve the default image. | |
VariablePackList - Callee allocated, tightly-packed, link list data | |
structure that contain all default varaible packs | |
from the Hii Database. | |
Returns: | |
EFI_NOT_FOUND - If Hii database does not contain any default images. | |
EFI_INVALID_PARAMETER - Invalid input parameter. | |
EFI_SUCCESS - Operation successful. | |
--*/ | |
{ | |
EFI_HII_HANDLE_DATABASE *HandleDatabase; | |
EFI_HII_PACKAGE_INSTANCE *PackageInstance; | |
EFI_IFR_OP_HEADER *FormSet; | |
EFI_IFR_OP_HEADER *IfrItem; | |
EFI_IFR_VARSTORE *VarStore; | |
EFI_IFR_VARSTORE *VarStoreDefault; | |
UINTN SetupMapNameSize; | |
UINTN SizeOfMaps; | |
EFI_HII_VARIABLE_PACK_LIST *PackList; | |
EFI_HII_VARIABLE_PACK_LIST *PackListNext; | |
EFI_HII_VARIABLE_PACK_LIST *PackListLast; | |
UINT8 *Map; | |
// | |
// Find the IFR pack from the handle. Then get the formset from the pack. | |
// | |
PackageInstance = NULL; | |
HandleDatabase = (EFI_HII_DATA_FROM_THIS (This))->DatabaseHead; | |
for ( ; HandleDatabase != NULL; HandleDatabase = HandleDatabase->NextHandleDatabase) { | |
if (Handle == HandleDatabase->Handle) { | |
PackageInstance = HandleDatabase->Buffer; | |
break; | |
} | |
} | |
if (PackageInstance == NULL) { | |
return EFI_INVALID_PARAMETER; | |
} | |
FormSet = (EFI_IFR_OP_HEADER *) ((UINT8 *) &PackageInstance->IfrData + sizeof (EFI_HII_IFR_PACK)); | |
// | |
// Get the sizes of all the VARSTOREs in this VFR. | |
// Then allocate enough space for all of them plus all maps | |
// | |
SizeOfMaps = 0; | |
IfrItem = FormSet; | |
while (EFI_IFR_END_FORM_SET_OP != IfrItem->OpCode) { | |
if (EFI_IFR_VARSTORE_OP == IfrItem->OpCode) { | |
VarStore = (EFI_IFR_VARSTORE *) IfrItem; | |
// | |
// Size of the map | |
// | |
SizeOfMaps += VarStore->Size; | |
// | |
// add the size of the string, in Unicode | |
// | |
SizeOfMaps += (VarStore->Header.Length - sizeof (*VarStore)) * 2; | |
// | |
// Space for node | |
// | |
SizeOfMaps += sizeof (EFI_HII_VARIABLE_PACK); | |
// | |
// Space for linked list node | |
// | |
SizeOfMaps += sizeof (EFI_HII_VARIABLE_PACK_LIST); | |
} | |
IfrItem = (EFI_IFR_OP_HEADER *) ((UINT8 *) IfrItem + IfrItem->Length); | |
} | |
// | |
// If the FormSet OpCode has a non-zero NvDataSize. There is a default | |
// NvMap with ID=0, GUID that of the formset itself and "Setup" as name. | |
// | |
SetupMapNameSize = StrLen (SETUP_MAP_NAME) + 1; | |
VarStoreDefault = AllocateZeroPool (sizeof (*VarStoreDefault) + SetupMapNameSize); | |
if (0 != ((EFI_IFR_FORM_SET*)FormSet)->NvDataSize) { | |
VarStoreDefault->Header.OpCode = EFI_IFR_VARSTORE_OP; | |
VarStoreDefault->Header.Length = (UINT8) (sizeof (*VarStoreDefault) + SetupMapNameSize); | |
Unicode2Ascii ((CHAR8 *) (VarStoreDefault + 1), SETUP_MAP_NAME); | |
CopyMem (&VarStoreDefault->Guid, &((EFI_IFR_FORM_SET*) FormSet)->Guid, sizeof (EFI_GUID)); | |
VarStoreDefault->VarId = 0; | |
VarStoreDefault->Size = ((EFI_IFR_FORM_SET*) FormSet)->NvDataSize; | |
// | |
// Size of the map | |
// | |
SizeOfMaps += VarStoreDefault->Size; | |
// | |
// add the size of the string | |
// | |
SizeOfMaps += sizeof (SETUP_MAP_NAME); | |
// | |
// Space for node | |
// | |
SizeOfMaps += sizeof (EFI_HII_VARIABLE_PACK); | |
// | |
// Space for linked list node | |
// | |
SizeOfMaps += sizeof (EFI_HII_VARIABLE_PACK_LIST); | |
} | |
if (0 == SizeOfMaps) { | |
// | |
// The IFR does not have any explicit or default map(s). | |
// | |
return EFI_NOT_FOUND; | |
} | |
// | |
// Allocate the return buffer | |
// | |
PackList = AllocateZeroPool (SizeOfMaps); | |
ASSERT (NULL != PackList); | |
PackListNext = PackList; | |
PackListLast = PackList; | |
// | |
// Handle the default map first, if any. | |
// | |
if (0 != VarStoreDefault->Size) { | |
Map = HiiGetDefaultImageInitPack (PackListNext, VarStoreDefault); | |
HiiGetDefaultImagePopulateMap (Map, FormSet, VarStoreDefault, DefaultMask); | |
PackListNext->NextVariablePack = (EFI_HII_VARIABLE_PACK_LIST *) ((UINT8 *) PackListNext->VariablePack + PackListNext->VariablePack->Header.Length); | |
PackListLast = PackListNext; | |
PackListNext = PackListNext->NextVariablePack; | |
} | |
// | |
// Handle the explicit varstore(s) | |
// | |
IfrItem = FormSet; | |
while (EFI_IFR_END_FORM_SET_OP != IfrItem->OpCode) { | |
if (EFI_IFR_VARSTORE_OP == IfrItem->OpCode) { | |
Map = HiiGetDefaultImageInitPack (PackListNext, (EFI_IFR_VARSTORE *) IfrItem); | |
HiiGetDefaultImagePopulateMap (Map, FormSet, (EFI_IFR_VARSTORE *) IfrItem, DefaultMask); | |
PackListNext->NextVariablePack = (EFI_HII_VARIABLE_PACK_LIST *) ((UINT8 *) PackListNext->VariablePack + PackListNext->VariablePack->Header.Length); | |
PackListLast = PackListNext; | |
PackListNext = PackListNext->NextVariablePack; | |
} | |
IfrItem = (EFI_IFR_OP_HEADER *) ((UINT8 *) IfrItem + IfrItem->Length); | |
} | |
PackListLast->NextVariablePack = NULL; | |
*VariablePackList = PackList; | |
return EFI_SUCCESS; | |
} | |
EFI_STATUS | |
EFIAPI | |
HiiUpdateForm ( | |
IN EFI_HII_PROTOCOL *This, | |
IN EFI_HII_HANDLE Handle, | |
IN EFI_FORM_LABEL Label, | |
IN BOOLEAN AddData, | |
IN EFI_HII_UPDATE_DATA *Data | |
) | |
/*++ | |
Routine Description: | |
This function allows the caller to update a form that has | |
previously been registered with the EFI HII database. | |
Arguments: | |
Handle - Hii Handle associated with the Formset to modify | |
Label - Update information starting immediately after this label in the IFR | |
AddData - If TRUE, add data. If FALSE, remove data | |
Data - If adding data, this is the pointer to the data to add | |
Returns: | |
EFI_SUCCESS - Update success. | |
Other - Update fail. | |
--*/ | |
{ | |
EFI_HII_PACKAGE_INSTANCE *PackageInstance; | |
EFI_HII_DATA *HiiData; | |
EFI_HII_HANDLE_DATABASE *HandleDatabase; | |
EFI_HII_IFR_PACK *FormPack; | |
EFI_IFR_OP_HEADER *Location; | |
EFI_IFR_OP_HEADER *DataLocation; | |
UINT8 *OtherBuffer; | |
UINT8 *TempBuffer; | |
UINT8 *OrigTempBuffer; | |
UINTN TempBufferSize; | |
UINTN Index; | |
OtherBuffer = NULL; | |
if (This == NULL) { | |
return EFI_INVALID_PARAMETER; | |
} | |
HiiData = EFI_HII_DATA_FROM_THIS (This); | |
HandleDatabase = HiiData->DatabaseHead; | |
PackageInstance = NULL; | |
// | |
// Check numeric value against the head of the database | |
// | |
for (; HandleDatabase != NULL; HandleDatabase = HandleDatabase->NextHandleDatabase) { | |
// | |
// Match the numeric value with the database entry - if matched, extract PackageInstance | |
// | |
if (Handle == HandleDatabase->Handle) { | |
PackageInstance = HandleDatabase->Buffer; | |
break; | |
} | |
} | |
// | |
// No handle was found - error condition | |
// | |
if (PackageInstance == NULL) { | |
return EFI_INVALID_PARAMETER; | |
} | |
// | |
// Calculate and allocate space for retrieval of IFR data | |
// | |
DataLocation = (EFI_IFR_OP_HEADER *) &Data->Data; | |
TempBufferSize = (CHAR8 *) (&PackageInstance->IfrData) - (CHAR8 *) (PackageInstance); | |
for (Index = 0; Index < Data->DataCount; Index++) { | |
TempBufferSize += DataLocation->Length; | |
DataLocation = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (DataLocation) + DataLocation->Length); | |
} | |
TempBufferSize += PackageInstance->IfrSize + PackageInstance->StringSize; | |
TempBuffer = AllocateZeroPool (TempBufferSize); | |
OrigTempBuffer = TempBuffer; | |
// | |
// We update only packages with IFR information in it | |
// | |
if (PackageInstance->IfrSize == 0) { | |
return EFI_INVALID_PARAMETER; | |
} | |
CopyMem ( | |
TempBuffer, | |
PackageInstance, | |
((CHAR8 *) (&PackageInstance->IfrData) + sizeof (EFI_HII_PACK_HEADER) - (CHAR8 *) (PackageInstance)) | |
); | |
TempBuffer = TempBuffer + ((CHAR8 *) (&PackageInstance->IfrData) + sizeof (EFI_HII_PACK_HEADER) - (CHAR8 *) (PackageInstance)); | |
// | |
// Based on if there is IFR data in this package instance, determine | |
// what the location is of the beginning of the string data. | |
// | |
FormPack = (EFI_HII_IFR_PACK *) ((CHAR8 *) (&PackageInstance->IfrData) + sizeof (EFI_HII_PACK_HEADER)); | |
Location = (EFI_IFR_OP_HEADER *) FormPack; | |
// | |
// Look for the FormId requested | |
// | |
for (; Location->OpCode != EFI_IFR_END_FORM_SET_OP;) { | |
switch (Location->OpCode) { | |
case EFI_IFR_FORM_SET_OP: | |
// | |
// If the FormSet has an update pending, pay attention. | |
// | |
if (Data->FormSetUpdate) { | |
((EFI_IFR_FORM_SET *) Location)->CallbackHandle = Data->FormCallbackHandle; | |
} | |
CopyMem (TempBuffer, Location, Location->Length); | |
TempBuffer = TempBuffer + Location->Length; | |
break; | |
case EFI_IFR_FORM_OP: | |
// | |
// If the Form has an update pending, pay attention. | |
// | |
if (Data->FormUpdate) { | |
((EFI_IFR_FORM *) Location)->FormTitle = Data->FormTitle; | |
} | |
CopyMem (TempBuffer, Location, Location->Length); | |
TempBuffer = TempBuffer + Location->Length; | |
break; | |
case EFI_IFR_LABEL_OP: | |
// | |
// If the label does not match the requested update point, ignore it | |
// | |
if (((EFI_IFR_LABEL *) Location)->LabelId != Label) { | |
// | |
// Copy the label | |
// | |
CopyMem (TempBuffer, Location, Location->Length); | |
TempBuffer = TempBuffer + Location->Length; | |
// | |
// Go to the next Op-Code | |
// | |
Location = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (Location) + Location->Length); | |
continue; | |
} | |
if (AddData) { | |
// | |
// Copy the label | |
// | |
CopyMem (TempBuffer, Location, Location->Length); | |
TempBuffer = TempBuffer + Location->Length; | |
// | |
// Add the DataCount amount of opcodes to TempBuffer | |
// | |
DataLocation = (EFI_IFR_OP_HEADER *) &Data->Data; | |
for (Index = 0; Index < Data->DataCount; Index++) { | |
CopyMem (TempBuffer, DataLocation, DataLocation->Length); | |
((EFI_HII_PACKAGE_INSTANCE *) OrigTempBuffer)->IfrSize += DataLocation->Length; | |
OtherBuffer = ((UINT8 *) &((EFI_HII_PACKAGE_INSTANCE *) OrigTempBuffer)->StringSize + sizeof (UINTN)); | |
CopyMem (OtherBuffer, &((EFI_HII_PACKAGE_INSTANCE *) OrigTempBuffer)->IfrSize, 2); | |
TempBuffer = TempBuffer + DataLocation->Length; | |
DataLocation = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (DataLocation) + DataLocation->Length); | |
} | |
// | |
// Go to the next Op-Code | |
// | |
Location = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (Location) + Location->Length); | |
continue; | |
} else { | |
// | |
// Copy the label | |
// | |
CopyMem (TempBuffer, Location, Location->Length); | |
TempBuffer = TempBuffer + Location->Length; | |
Location = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (Location) + Location->Length); | |
// | |
// Remove the DataCount amount of opcodes unless we run into an end of form or a label | |
// | |
for (Index = 0; Index < Data->DataCount; Index++) { | |
// | |
// If we are about to skip an end form - bail out, since that is illegal | |
// | |
if ((Location->OpCode == EFI_IFR_END_FORM_OP) || (Location->OpCode == EFI_IFR_LABEL_OP)) { | |
break; | |
} | |
// | |
// By skipping Location entries, we are in effect not copying what was previously there | |
// | |
((EFI_HII_PACKAGE_INSTANCE *) OrigTempBuffer)->IfrSize -= Location->Length; | |
OtherBuffer = ((UINT8 *) &((EFI_HII_PACKAGE_INSTANCE *) OrigTempBuffer)->StringSize + sizeof (UINTN)); | |
CopyMem (OtherBuffer, &((EFI_HII_PACKAGE_INSTANCE *) OrigTempBuffer)->IfrSize, 2); | |
Location = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (Location) + Location->Length); | |
} | |
} | |
default: | |
CopyMem (TempBuffer, Location, Location->Length); | |
TempBuffer = TempBuffer + Location->Length; | |
break; | |
} | |
// | |
// Go to the next Op-Code | |
// | |
Location = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (Location) + Location->Length); | |
} | |
// | |
// Copy the last op-code left behind from the for loop | |
// | |
CopyMem (TempBuffer, Location, Location->Length); | |
// | |
// Advance to beginning of strings and copy them | |
// | |
TempBuffer = TempBuffer + Location->Length; | |
Location = (EFI_IFR_OP_HEADER *) ((CHAR8 *) (Location) + Location->Length); | |
CopyMem (TempBuffer, Location, PackageInstance->StringSize); | |
// | |
// Free the old buffer, and assign into our database the latest buffer | |
// | |
gBS->FreePool (HandleDatabase->Buffer); | |
HandleDatabase->Buffer = OrigTempBuffer; | |
return EFI_SUCCESS; | |
} |