EFI_STATUS
EFIAPI
StslRecordAssertion (
IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *This,
IN EFI_TEST_ASSERTION Type,
IN EFI_GUID EventId,
IN CHAR16 *Description,
IN CHAR16 *Detail,
...
)
/*++
Routine Description:
Records the test result.
Arguments:
This - Standard test library protocol instance.
Type - Test result.
EventId - GUID for the checkpoint.
Description - Simple description for the checkpoint.
Detail - Format string for the detail test information.
Returns:
EFI_SUCCESS - record the assertion successfully.
EFI_BAD_BUFFER_SIZE - the Description string is too long.
EFI_INVALID_PARAMETER - invalid Type.
--*/
{
EFI_STATUS Status;
VA_LIST Marker;
CHAR16 Buffer[EFI_MAX_PRINT_BUFFER];
CHAR16 AssertionType[10];
STANDARD_TEST_PRIVATE_DATA *Private;
Private = STANDARD_TEST_PRIVATE_DATA_FROM_STSL (This);
//
// Check the parameter
//
if (EfiStrLen (Description) + 14 > EFI_MAX_PRINT_BUFFER) {
return EFI_BAD_BUFFER_SIZE;
}
//
// Write log file detail data
//
switch (Type) {
case EFI_TEST_ASSERTION_PASSED:
EfiStrCpy (AssertionType, L"PASS");
Private->PassCount ++;
break;
case EFI_TEST_ASSERTION_WARNING:
EfiStrCpy (AssertionType, L"WARNING");
Private->WarningCount ++;
break;
case EFI_TEST_ASSERTION_FAILED:
EfiStrCpy (AssertionType, L"FAILURE");
Private->FailCount ++;
break;
default:
return EFI_INVALID_PARAMETER;
break;
}
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%s -- %s\n", Description, AssertionType);
Status = StslWriteLogFile (Private, Buffer);
if (EFI_ERROR (Status)) {
return Status;
}
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%g\n", &EventId);
Status = StslWriteLogFile (Private, Buffer);
if (EFI_ERROR (Status)) {
return Status;
}
VA_START(Marker, Detail);
VSPrint (Buffer, EFI_MAX_PRINT_BUFFER, Detail, Marker);
VA_END (Marker);
if ( EfiStrLen (Buffer) + 5 < EFI_MAX_PRINT_BUFFER ) {
EfiStrCat (Buffer, L"\r\n\r\n");
}
Status = StslWriteLogFile (Private, Buffer);
if (EFI_ERROR (Status)) {
return Status;
}
//
// write key file detail line
//
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%g:%s|%s:",
&EventId, AssertionType, Description);
Status = StslWriteKeyFile (Private, Buffer);
if (EFI_ERROR (Status)) {
return Status;
}
VA_START(Marker, Detail);
VSPrint (Buffer, EFI_MAX_PRINT_BUFFER, Detail, Marker);
VA_END (Marker);
if ( EfiStrLen (Buffer) + 3 < EFI_MAX_PRINT_BUFFER ) {
EfiStrCat (Buffer, L"\r\n");
}
Status = StslWriteKeyFile (Private, Buffer);
if (EFI_ERROR (Status)) {
return Status;
}
return Status;
}
EFI_STATUS
EFIAPI
StslBeginLogging (
IN EFI_STANDARD_TSL_PRIVATE_INTERFACE *This
)
/*++
Routine Description:
One private interface function of the StandardTestLibrary to begin logging.
Arguments:
This - the private interface instance structure.
Returns:
EFI_SUCCESS - begin logging successfully.
--*/
{
EFI_STATUS Status;
STANDARD_TEST_PRIVATE_DATA *Private;
CHAR16 Buffer[EFI_MAX_PRINT_BUFFER];
EFI_TEST_OUTPUT_LIBRARY_PROTOCOL *Output;
EFI_LIB_CONFIG_FILE_HANDLE *FileConf;
EFI_GUID *Guid;
EFI_TIME *CurrentTime;
Private = STANDARD_TEST_PRIVATE_DATA_FROM_PI (This);
Output = Private->OutputProtocol;
StslCloseAllFiles (Private);
//
// Open log and key files
//
//
// Open system log file
//
FileConf = &Private->SystemLogFile;
Status = Output->Open (
Output,
FileConf->DevicePath,
FileConf->FileName,
FileConf->OverwriteFile,
&FileConf->FileHandle
);
if (EFI_ERROR (Status)) {
StslCloseAllFiles (Private);
return Status;
}
//
// Open system key file
//
FileConf = &Private->SystemKeyFile;
Status = Output->Open (
Output,
FileConf->DevicePath,
FileConf->FileName,
FileConf->OverwriteFile,
&FileConf->FileHandle
);
if (EFI_ERROR (Status)) {
StslCloseAllFiles (Private);
return Status;
}
//
// Open case log file
//
FileConf = &Private->CaseLogFile;
Status = Output->Open (
Output,
FileConf->DevicePath,
FileConf->FileName,
FileConf->OverwriteFile,
&FileConf->FileHandle
);
if (EFI_ERROR (Status)) {
StslCloseAllFiles (Private);
return Status;
}
//
// Open case key file
//
FileConf = &Private->CaseKeyFile;
Status = Output->Open (
Output,
FileConf->DevicePath,
FileConf->FileName,
FileConf->OverwriteFile,
&FileConf->FileHandle
);
if (EFI_ERROR (Status)) {
StslCloseAllFiles (Private);
return Status;
}
//
// Write log file header data
//
if (Private->IsRecovery) {
//
// ----------------------------------
//
StslWriteLogFile (Private, DashLine);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L" *********RECOVERY*********\n");
StslWriteLogFile (Private, Buffer);
//
// ----------------------------------
//
StslWriteLogFile (Private, DashLine);
CurrentTime = &Private->StartTime;
gRT->GetTime (CurrentTime, NULL);
} else {
//
// ----------------------------------
//
StslWriteLogFile (Private, DashLine);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%s\n", Private->EntryName);
StslWriteLogFile (Private, Buffer);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Revision 0x%08x\n", Private->TestRevision);
StslWriteLogFile (Private, Buffer);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Test Entry Point GUID: %g\n", &Private->EntryId);
StslWriteLogFile (Private, Buffer);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Test Support Library GUIDs: \n");
StslWriteLogFile (Private, Buffer);
Guid = Private->SupportProtocols;
while (EfiCompareMem (Guid, &gEfiNullGuid, sizeof(EFI_GUID) ) != 0) {
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L" %g\n", Guid);
StslWriteLogFile (Private, Buffer);
Guid ++;
}
//
// ----------------------------------
//
StslWriteLogFile (Private, DashLine);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%s\n", Private->BiosId);
StslWriteLogFile (Private, Buffer);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Test Configuration #%d\n", Private->ConfigurationNumber);
StslWriteLogFile (Private, Buffer);
//
// ----------------------------------
//
StslWriteLogFile (Private, DashLine);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%s\n", Private->EntryDescription);
StslWriteLogFile (Private, Buffer);
//
// ----------------------------------
//
StslWriteLogFile (Private, DashLine);
StslWriteLogFileName (Private);
CurrentTime = &Private->StartTime;
gRT->GetTime (CurrentTime, NULL);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Test Started: %t\n", CurrentTime);
StslWriteLogFile (Private, Buffer);
//
// ----------------------------------
//
StslWriteLogFile (Private, DashLine);
//
// Write key file header line
//
SPrint (
Buffer, EFI_MAX_PRINT_BUFFER, L"|HEAD|||%d|%s|%02d-%02d-%04d|%02d:%02d:%02d|%g|0x%08lx|%s|%s|%s|%s\n",
Private->ConfigurationNumber,
Private->ScenarioString,
CurrentTime->Day,
CurrentTime->Month,
CurrentTime->Year,
CurrentTime->Hour,
CurrentTime->Minute,
CurrentTime->Second,
&Private->EntryId,
Private->TestRevision,
Private->EntryName,
Private->TestName,
Private->TestCategory,
Private->DevicePath
);
StslWriteKeyFile (Private, Buffer);
}
//
// Initial private data
//
Private->BeginLogging = TRUE;
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
StslEndLogging (
IN EFI_STANDARD_TSL_PRIVATE_INTERFACE *This,
IN EFI_STATUS TestStatus
)
/*++
Routine Description:
One private interface function of the StandardTestLibrary to end logging.
Arguments:
This - the private interface instance structure.
Returns:
EFI_SUCCESS - end logging successfully.
--*/
{
STANDARD_TEST_PRIVATE_DATA *Private;
CHAR16 Buffer[EFI_MAX_PRINT_BUFFER];
EFI_TIME CurrentTime;
UINT32 SecondsElapsed;
UINT32 DaysElapsed;
UINT32 HoursElapsed;
UINT32 MunitesElapsed;
Private = STANDARD_TEST_PRIVATE_DATA_FROM_PI (This);
//
// Write log file terminator data
//
SPrint (Buffer, EFI_MAX_PRINT_BUFFER,
L"\nReturned Status Code: %r\n", TestStatus);
StslWriteLogFile (Private, Buffer);
if ((Private->PassCount > 0 ) &&
(Private->WarningCount == 0) &&
(Private->FailCount == 0)) {
SPrint (Buffer, EFI_MAX_PRINT_BUFFER,
L"\n%s: [PASSED]\n", Private->EntryName);
} else if ((Private->PassCount > 0 ) &&
(Private->WarningCount > 0 ) &&
(Private->FailCount == 0)) {
SPrint (Buffer, EFI_MAX_PRINT_BUFFER,
L"\n%s: [PASSED WITH WARNINGS]\n", Private->EntryName);
} else if ((Private->PassCount >= 0) &&
(Private->WarningCount >= 0) &&
(Private->FailCount > 0 )) {
SPrint (Buffer, EFI_MAX_PRINT_BUFFER,
L"\n%s: [FAILED]\n", Private->EntryName);
} else {
SPrint (Buffer, EFI_MAX_PRINT_BUFFER,
L"\n%s: [NOT SUPPORTED]\n", Private->EntryName);
}
StslWriteLogFile (Private, Buffer);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L" Passes........... %d\n", Private->PassCount);
StslWriteLogFile (Private, Buffer);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L" Warnings......... %d\n", Private->WarningCount);
StslWriteLogFile (Private, Buffer);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L" Errors........... %d\n", Private->FailCount);
StslWriteLogFile (Private, Buffer);
//
// ----------------------------------
//
StslWriteLogFile (Private, DashLine);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%s\n", Private->BiosId);
StslWriteLogFile (Private, Buffer);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Revision 0x%08x\n", Private->TestRevision);
StslWriteLogFile (Private, Buffer);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Test Entry Point GUID: %g\n", &Private->EntryId);
StslWriteLogFile (Private, Buffer);
//
// ----------------------------------
//
StslWriteLogFile (Private, DashLine);
StslWriteLogFileName (Private);
gRT->GetTime (&CurrentTime, NULL);
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"Test Finished: %t\n", &CurrentTime);
StslWriteLogFile (Private, Buffer);
SecondsElapsed = SecondsElapsedFromBaseYear (
Private->StartTime.Year,
CurrentTime.Year,
CurrentTime.Month,
CurrentTime.Day,
CurrentTime.Hour,
CurrentTime.Minute,
CurrentTime.Second
) -
SecondsElapsedFromBaseYear (
Private->StartTime.Year,
Private->StartTime.Year,
Private->StartTime.Month,
Private->StartTime.Day,
Private->StartTime.Hour,
Private->StartTime.Minute,
Private->StartTime.Second
);
DaysElapsed = SecondsElapsed / SECS_PER_DAY;
SecondsElapsed -= DaysElapsed * SECS_PER_DAY;
HoursElapsed = SecondsElapsed / SECS_PER_HOUR;
SecondsElapsed -= HoursElapsed * SECS_PER_HOUR;
MunitesElapsed = SecondsElapsed / SECS_PER_MIN;
SecondsElapsed -= MunitesElapsed * SECS_PER_MIN;
SPrint (Buffer, EFI_MAX_PRINT_BUFFER,
L"Elapsed Time: %d Days %02d:%02d:%02d\n",
DaysElapsed, HoursElapsed, MunitesElapsed, SecondsElapsed);
StslWriteLogFile (Private, Buffer);
//
// ----------------------------------
//
StslWriteLogFile (Private, DashLine);
//
// Write key file terminator line
//
SPrint (
Buffer, EFI_MAX_PRINT_BUFFER, L"|TERM|%04x|%02d-%02d-%04d|%02d:%02d:%02d|%d %02d:%02d:%02d\n",
(UINT16)(TestStatus & 0xFFFF),
CurrentTime.Day,
CurrentTime.Month,
CurrentTime.Year,
CurrentTime.Hour,
CurrentTime.Minute,
CurrentTime.Second,
DaysElapsed,
HoursElapsed,
MunitesElapsed,
SecondsElapsed
);
StslWriteKeyFile (Private, Buffer);
//
// Close log and key files
//
StslCloseAllFiles (Private);
Private->BeginLogging = FALSE;
return EFI_SUCCESS;
}
EFI_STATUS
IfrToString (
IN FORM_BROWSER_FORMSET *FormSet,
IN UINT8 Format,
OUT EFI_HII_VALUE *Result
)
/*++
Routine Description:
Evaluate opcode EFI_IFR_TO_STRING.
Arguments:
FormSet - Formset which contains this opcode.
Format - String format in EFI_IFR_TO_STRING.
Result - Evaluation result for this opcode.
Returns:
EFI_SUCCESS - Opcode evaluation success.
Other - Opcode evaluation failed.
--*/
{
EFI_STATUS Status;
EFI_HII_VALUE Value;
CHAR16 *String;
CHAR16 *PrintFormat;
CHAR16 Buffer[CHARACTER_NUMBER_FOR_VALUE];
UINTN BufferSize;
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
return Status;
}
switch (Value.Type) {
case EFI_IFR_TYPE_NUM_SIZE_8:
case EFI_IFR_TYPE_NUM_SIZE_16:
case EFI_IFR_TYPE_NUM_SIZE_32:
case EFI_IFR_TYPE_NUM_SIZE_64:
BufferSize = CHARACTER_NUMBER_FOR_VALUE * sizeof (CHAR16);
switch (Format) {
case EFI_IFR_STRING_UNSIGNED_DEC:
case EFI_IFR_STRING_SIGNED_DEC:
PrintFormat = L"%ld";
break;
case EFI_IFR_STRING_LOWERCASE_HEX:
PrintFormat = L"%lx";
break;
case EFI_IFR_STRING_UPPERCASE_HEX:
PrintFormat = L"%lX";
break;
default:
return EFI_UNSUPPORTED;
}
SPrint (Buffer, BufferSize, PrintFormat, Value.Value.u64);
String = Buffer;
break;
case EFI_IFR_TYPE_STRING:
EfiCopyMem (Result, &Value, sizeof (EFI_HII_VALUE));
return EFI_SUCCESS;
case EFI_IFR_TYPE_BOOLEAN:
String = (Value.Value.b) ? L"True" : L"False";
break;
default:
return EFI_UNSUPPORTED;
}
Result->Type = EFI_IFR_TYPE_STRING;
Result->Value.string = NewString (String, FormSet->HiiHandle);
return EFI_SUCCESS;
}
void
parse_db(UINT8 *data, UINTN len, EFI_HANDLE image, CHAR16 *name, int save_file)
{
EFI_SIGNATURE_LIST *CertList = (EFI_SIGNATURE_LIST *)data;
EFI_SIGNATURE_DATA *Cert;
UINTN count = 0, DataSize = len;
EFI_FILE *file;
CHAR16 *buf = AllocatePool(StrSize(name) + 4 + 2 + 4 + 8 +100);
CHAR16 *ext;
EFI_STATUS status;
int size;
certlist_for_each_certentry(CertList, data, size, DataSize) {
int Index = 0;
count++;
if (CompareGuid(&CertList->SignatureType, &X509_GUID) == 0) {
ext = L"X509";
} else if (CompareGuid(&CertList->SignatureType, &RSA2048_GUID) == 0) {
ext = L"RSA2048";
} else if (CompareGuid(&CertList->SignatureType, &PKCS7_GUID) == 0) {
ext = L"PKCS7";
} else if (CompareGuid(&CertList->SignatureType, &EFI_CERT_SHA256_GUID) == 0) {
ext = L"SHA256";
} else {
ext = L"Unknown";
}
Print(L"%s: List %d, type %s\n", name, count, ext);
certentry_for_each_cert(Cert, CertList) {
Print(L" Signature %d, size %d, owner %g\n",
Index++, CertList->SignatureSize,
&Cert->SignatureOwner);
if (StrCmp(ext, L"X509") == 0) {
CHAR16 buf1[4096];
x509_to_str(Cert->SignatureData,
CertList->SignatureSize,
X509_OBJ_SUBJECT, buf1,
sizeof(buf1));
Print(L" Subject: %s\n", buf1);
x509_to_str(Cert->SignatureData,
CertList->SignatureSize,
X509_OBJ_ISSUER, buf1,
sizeof(buf1));
Print(L" Issuer: %s\n", buf1);
} else if (StrCmp(ext, L"SHA256") == 0) {
CHAR16 buf1[256];
StrCpy(buf1, L"Hash: ");
sha256_StrCat_hash(buf1, Cert->SignatureData);
Print(L" %s\n", buf1);
}
if (save_file) {
SPrint(buf, 0, L"%s-%d-%d-%s-%g", name, count, Index, ext, &Cert->SignatureOwner);
Print(L"Writing to file %s\n", buf);
status = simple_file_open(image, buf, &file, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE);
if (status != EFI_SUCCESS) {
Print(L"Failed to open file %s: %d\n", buf, status);
continue;
}
status = simple_file_write_all(file, CertList->SignatureSize-sizeof(EFI_GUID), Cert->SignatureData);
simple_file_close(file);
if (status != EFI_SUCCESS) {
Print(L"Failed to write signature to file %s: %d\n", buf, status);
continue;
}
}
}
VOID
UpdateSetLegacyDeviceOrderPage (
IN UINT16 UpdatePageId,
IN BMM_CALLBACK_DATA *CallbackData
)
{
BM_LEGACY_DEV_ORDER_CONTEXT *DevOrder;
BM_MENU_OPTION *OptionMenu;
BM_MENU_ENTRY *NewMenuEntry;
IFR_OPTION *IfrOptionList;
EFI_STRING_ID StrRef;
EFI_STRING_ID StrRefHelp;
BBS_TYPE BbsType;
UINTN VarSize;
UINTN Pos;
UINTN Bit;
UINT16 Index;
UINT16 Key;
CHAR16 String[100];
CHAR16 *TypeStr;
CHAR16 *TypeStrHelp;
UINT16 VarDevOrder;
UINT8 *VarData;
UINT8 *OriginalPtr;
UINT8 *LegacyOrder;
UINT8 *OldData;
UINT8 *DisMap;
OptionMenu = NULL;
Key = 0;
StrRef = 0;
StrRefHelp = 0;
TypeStr = NULL;
TypeStrHelp = NULL;
BbsType = BBS_FLOPPY;
LegacyOrder = NULL;
OldData = NULL;
DisMap = NULL;
CallbackData->BmmAskSaveOrNot = TRUE;
UpdatePageStart (CallbackData);
DisMap = CallbackData->BmmOldFakeNVData.DisableMap;
EfiSetMem (DisMap, 32, 0);
//
// Create oneof option list
//
switch (UpdatePageId) {
case FORM_SET_FD_ORDER_ID:
OptionMenu = (BM_MENU_OPTION *) &LegacyFDMenu;
Key = LEGACY_FD_QUESTION_ID;
TypeStr = StrFloppy;
TypeStrHelp = StrFloppyHelp;
BbsType = BBS_FLOPPY;
LegacyOrder = CallbackData->BmmFakeNvData.LegacyFD;
OldData = CallbackData->BmmOldFakeNVData.LegacyFD;
break;
case FORM_SET_HD_ORDER_ID:
OptionMenu = (BM_MENU_OPTION *) &LegacyHDMenu;
Key = LEGACY_HD_QUESTION_ID;
TypeStr = StrHardDisk;
TypeStrHelp = StrHardDiskHelp;
BbsType = BBS_HARDDISK;
LegacyOrder = CallbackData->BmmFakeNvData.LegacyHD;
OldData = CallbackData->BmmOldFakeNVData.LegacyHD;
break;
case FORM_SET_CD_ORDER_ID:
OptionMenu = (BM_MENU_OPTION *) &LegacyCDMenu;
Key = LEGACY_CD_QUESTION_ID;
TypeStr = StrCDROM;
TypeStrHelp = StrCDROMHelp;
BbsType = BBS_CDROM;
LegacyOrder = CallbackData->BmmFakeNvData.LegacyCD;
OldData = CallbackData->BmmOldFakeNVData.LegacyCD;
break;
case FORM_SET_NET_ORDER_ID:
OptionMenu = (BM_MENU_OPTION *) &LegacyNETMenu;
Key = LEGACY_NET_QUESTION_ID;
TypeStr = StrNET;
TypeStrHelp = StrNETHelp;
BbsType = BBS_EMBED_NETWORK;
LegacyOrder = CallbackData->BmmFakeNvData.LegacyNET;
OldData = CallbackData->BmmOldFakeNVData.LegacyNET;
break;
case FORM_SET_BEV_ORDER_ID:
OptionMenu = (BM_MENU_OPTION *) &LegacyBEVMenu;
Key = LEGACY_BEV_QUESTION_ID;
TypeStr = StrBEV;
TypeStrHelp = StrBEVHelp;
BbsType = BBS_BEV_DEVICE;
LegacyOrder = CallbackData->BmmFakeNvData.LegacyBEV;
OldData = CallbackData->BmmOldFakeNVData.LegacyBEV;
break;
}
CreateMenuStringToken (CallbackData, CallbackData->BmmHiiHandle, OptionMenu);
IfrOptionList = EfiAllocateZeroPool (sizeof (IFR_OPTION) * (OptionMenu->MenuNumber + 1));
if (NULL == IfrOptionList) {
return ;
}
for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
NewMenuEntry = BOpt_GetMenuEntry (OptionMenu, Index);
IfrOptionList[Index].Flags = 0;
if (0 == Index) {
IfrOptionList[Index].Flags |= EFI_IFR_OPTION_DEFAULT;
}
IfrOptionList[Index].StringToken = NewMenuEntry->DisplayStringToken;
IfrOptionList[Index].Value.u8 = (UINT8) ((BM_LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext)->Index;
}
//
// for item "Disabled"
//
IfrOptionList[Index].Flags = 0;
IfrOptionList[Index].StringToken = STRING_TOKEN (STR_DISABLE_LEGACY_DEVICE);
IfrOptionList[Index].Value.u8 = 0xFF;
//
// Get Device Order from variable
//
VarData = BdsLibGetVariableAndSize (
VarLegacyDevOrder,
&EfiLegacyDevOrderGuid,
&VarSize
);
if (NULL != VarData) {
OriginalPtr = VarData;
DevOrder = (BM_LEGACY_DEV_ORDER_CONTEXT *) VarData;
while (VarData < VarData + VarSize) {
if (DevOrder->BbsType == BbsType) {
break;
}
VarData += sizeof (BBS_TYPE);
VarData += *(UINT16 *) VarData;
DevOrder = (BM_LEGACY_DEV_ORDER_CONTEXT *) VarData;
}
//
// Create oneof tag here for FD/HD/CD #1 #2
//
for (Index = 0; Index < OptionMenu->MenuNumber; Index++) {
//
// Create the string for oneof tag
//
SPrint (String, sizeof (String), TypeStr, Index);
StrRef = 0;
IfrLibNewString (CallbackData->BmmHiiHandle, &StrRef, String);
SPrint (String, sizeof (String), TypeStrHelp, Index);
StrRefHelp = 0;
IfrLibNewString (CallbackData->BmmHiiHandle, &StrRefHelp, String);
CreateOneOfOpCode (
Key + Index,
VARSTORE_ID_BOOT_MAINT,
Key + Index - CONFIG_OPTION_OFFSET,
StrRef,
StrRefHelp,
EFI_IFR_FLAG_CALLBACK,
EFI_IFR_NUMERIC_SIZE_1,
IfrOptionList,
OptionMenu->MenuNumber + 1,
&gUpdateData
);
VarDevOrder = *(UINT16 *) ((UINT8 *) DevOrder + sizeof (BBS_TYPE) + sizeof (UINT16) + Index * sizeof (UINT16));
if (0xFF00 == (VarDevOrder & 0xFF00)) {
LegacyOrder[Index] = 0xFF;
Pos = (VarDevOrder & 0xFF) / 8;
Bit = 7 - ((VarDevOrder & 0xFF) % 8);
DisMap[Pos] |= (UINT8) (1 << Bit);
} else {
LegacyOrder[Index] = (UINT8) (VarDevOrder & 0xFF);
}
}
}
EfiCopyMem (OldData, LegacyOrder, 100);
if (IfrOptionList != NULL) {
SafeFreePool (IfrOptionList);
IfrOptionList = NULL;
}
UpdatePageEnd (CallbackData);
}
VOID *
GetLegacyBootOptionVar (
IN UINTN DeviceType,
OUT UINTN *OptionIndex,
OUT UINTN *OptionSize
)
{
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
VOID *OptionBuffer;
UINTN OrderSize;
UINTN Index;
UINT32 Attribute;
UINT16 *OrderBuffer;
CHAR16 StrTemp[100];
UINT16 FilePathSize;
CHAR16 *Description;
UINT8 *Ptr;
UINT8 *OptionalData;
//
// Get Boot Option number from the size of BootOrder
//
OrderBuffer = BdsLibGetVariableAndSize (
L"BootOrder",
&gEfiGlobalVariableGuid,
&OrderSize
);
for (Index = 0; Index < OrderSize / sizeof (UINT16); Index++) {
SPrint (StrTemp, 100, L"Boot%04x", OrderBuffer[Index]);
OptionBuffer = BdsLibGetVariableAndSize (
StrTemp,
&gEfiGlobalVariableGuid,
OptionSize
);
if (NULL == OptionBuffer) {
continue;
}
Ptr = (UINT8 *) OptionBuffer;
Attribute = *(UINT32 *) Ptr;
Ptr += sizeof (UINT32);
FilePathSize = *(UINT16 *) Ptr;
Ptr += sizeof (UINT16);
Description = (CHAR16 *) Ptr;
Ptr += EfiStrSize ((CHAR16 *) Ptr);
//
// Now Ptr point to Device Path
//
DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) Ptr;
Ptr += FilePathSize;
//
// Now Ptr point to Optional Data
//
OptionalData = Ptr;
if ((DeviceType == ((BBS_TABLE *) OptionalData)->DeviceType) &&
(BBS_DEVICE_PATH == DevicePath->Type) &&
(BBS_BBS_DP == DevicePath->SubType)
) {
*OptionIndex = OrderBuffer[Index];
SafeFreePool (OrderBuffer);
return OptionBuffer;
} else {
SafeFreePool (OptionBuffer);
}
}
SafeFreePool (OrderBuffer);
return NULL;
}
