EFI_STATUS
BootMenuRemoveBootOption (
IN LIST_ENTRY *BootOptionsList
)
{
EFI_STATUS Status;
BDS_LOAD_OPTION_ENTRY* BootOptionEntry;
DisplayBootOptions (BootOptionsList);
Status = SelectBootOption (BootOptionsList, DELETE_BOOT_ENTRY, &BootOptionEntry);
if (EFI_ERROR (Status)) {
return Status;
}
// If the Boot Option was attached to a list remove it
if (!IsListEmpty (&BootOptionEntry->Link)) {
// Remove the entry from the list
RemoveEntryList (&BootOptionEntry->Link);
}
// Delete the BDS Load option structures
BootOptionDelete (BootOptionEntry->BdsLoadOption);
return EFI_SUCCESS;
}
/**
Reorder boot options
Ask for the boot option to move and then move it when up or down arrows
are pressed. This function is called when the user selects the "Reorder Boot
Device Entries" entry in the boot manager menu.
The order of the boot options in BootOptionList and in the UEFI BootOrder
global variable are kept coherent until the user confirm his reordering (ie:
he does not exit by pressing escape).
@param[in] BootOptionsList List of the boot devices constructed in
BootMenuMain()
@retval EFI_SUCCESS No error encountered.
@retval !EFI_SUCCESS An error has occured either in the selection of the
boot option to move or while interacting with the user.
**/
STATIC
EFI_STATUS
BootMenuReorderBootOptions (
IN LIST_ENTRY *BootOptionsList
)
{
EFI_STATUS Status;
BDS_LOAD_OPTION_ENTRY *BootOptionEntry;
LIST_ENTRY *SelectedEntry;
LIST_ENTRY *PrevEntry;
BOOLEAN Move;
BOOLEAN Save;
BOOLEAN Cancel;
UINTN WaitIndex;
EFI_INPUT_KEY Key;
LIST_ENTRY *SecondEntry;
UINTN BootOrderSize;
UINT16 *BootOrder;
LIST_ENTRY *Entry;
UINTN Index;
DisplayBootOptions (BootOptionsList);
// Ask to select the boot option to move
while (TRUE) {
Status = SelectBootOption (BootOptionsList, MOVE_BOOT_ENTRY, &BootOptionEntry);
if (EFI_ERROR (Status)) {
goto ErrorExit;
}
SelectedEntry = &BootOptionEntry->Link;
SecondEntry = NULL;
// Note down the previous entry in the list to be able to cancel changes
PrevEntry = GetPreviousNode (BootOptionsList, SelectedEntry);
// Start of interaction
while (TRUE) {
Print (
L"* Use up/down arrows to move the entry '%s'",
BootOptionEntry->BdsLoadOption->Description
);
// Wait for a move, save or cancel request
Move = FALSE;
Save = FALSE;
Cancel = FALSE;
do {
Status = gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &WaitIndex);
if (!EFI_ERROR (Status)) {
Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
}
if (EFI_ERROR (Status)) {
Print (L"\n");
goto ErrorExit;
}
switch (Key.ScanCode) {
case SCAN_NULL:
Save = (Key.UnicodeChar == CHAR_LINEFEED) ||
(Key.UnicodeChar == CHAR_CARRIAGE_RETURN) ||
(Key.UnicodeChar == 0x7f);
break;
case SCAN_UP:
SecondEntry = GetPreviousNode (BootOptionsList, SelectedEntry);
Move = SecondEntry != BootOptionsList;
break;
case SCAN_DOWN:
SecondEntry = GetNextNode (BootOptionsList, SelectedEntry);
Move = SecondEntry != BootOptionsList;
break;
case SCAN_ESC:
Cancel = TRUE;
break;
}
} while ((!Move) && (!Save) && (!Cancel));
if (Move) {
if ((SelectedEntry != NULL) && (SecondEntry != NULL)) {
SwapListEntries (SelectedEntry, SecondEntry);
}
} else {
if (Save) {
Status = GetGlobalEnvironmentVariable (
L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder
);
BootOrderSize /= sizeof (UINT16);
if (!EFI_ERROR (Status)) {
// The order of the boot options in the 'BootOptionsList' is the
// new order that has been just defined by the user. Save this new
// order in "BootOrder" UEFI global variable.
Entry = GetFirstNode (BootOptionsList);
for (Index = 0; Index < BootOrderSize; Index++) {
BootOrder[Index] = (LOAD_OPTION_FROM_LINK (Entry))->LoadOptionIndex;
Entry = GetNextNode (BootOptionsList, Entry);
}
Status = gRT->SetVariable (
(CHAR16*)L"BootOrder",
&gEfiGlobalVariableGuid,
EFI_VARIABLE_NON_VOLATILE |
EFI_VARIABLE_BOOTSERVICE_ACCESS |
EFI_VARIABLE_RUNTIME_ACCESS,
BootOrderSize * sizeof (UINT16),
BootOrder
);
FreePool (BootOrder);
}
if (EFI_ERROR (Status)) {
Print (L"\nAn error occurred, move not completed!\n");
Cancel = TRUE;
}
}
if (Cancel) {
//
// Restore initial position of the selected boot option
//
RemoveEntryList (SelectedEntry);
InsertHeadList (PrevEntry, SelectedEntry);
}
}
Print (L"\n");
DisplayBootOptions (BootOptionsList);
// Saved or cancelled, back to the choice of boot option to move
if (!Move) {
break;
}
}
}
ErrorExit:
return Status ;
}
EFI_STATUS
BootMenuUpdateBootOption (
IN LIST_ENTRY *BootOptionsList
)
{
EFI_STATUS Status;
BDS_LOAD_OPTION_ENTRY *BootOptionEntry;
BDS_LOAD_OPTION *BootOption;
BDS_LOAD_OPTION_SUPPORT* DeviceSupport;
ARM_BDS_LOADER_ARGUMENTS* BootArguments;
CHAR16 BootDescription[BOOT_DEVICE_DESCRIPTION_MAX];
CHAR8 CmdLine[BOOT_DEVICE_OPTION_MAX];
CHAR16 UnicodeCmdLine[BOOT_DEVICE_OPTION_MAX];
EFI_DEVICE_PATH *DevicePath;
EFI_DEVICE_PATH *TempInitrdPath;
ARM_BDS_LOADER_TYPE BootType;
ARM_BDS_LOADER_OPTIONAL_DATA* LoaderOptionalData;
ARM_BDS_LINUX_ARGUMENTS* LinuxArguments;
EFI_DEVICE_PATH *InitrdPathNodes;
EFI_DEVICE_PATH *InitrdPath;
UINTN InitrdSize;
UINTN CmdLineSize;
BOOLEAN InitrdSupport;
UINT8* OptionalData;
UINTN OptionalDataSize;
BOOLEAN IsPrintable;
BOOLEAN IsUnicode;
DisplayBootOptions (BootOptionsList);
Status = SelectBootOption (BootOptionsList, UPDATE_BOOT_ENTRY, &BootOptionEntry);
if (EFI_ERROR (Status)) {
return Status;
}
BootOption = BootOptionEntry->BdsLoadOption;
// Get the device support for this Boot Option
Status = BootDeviceGetDeviceSupport (BootOption->FilePathList, &DeviceSupport);
if (EFI_ERROR(Status)) {
Print(L"Not possible to retrieve the supported device for the update\n");
return EFI_UNSUPPORTED;
}
Status = DeviceSupport->UpdateDevicePathNode (BootOption->FilePathList, L"EFI Application or the kernel", &DevicePath);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto EXIT;
}
if (DeviceSupport->RequestBootType) {
Status = BootDeviceGetType (DevicePath, &BootType, &BootOption->Attributes);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto EXIT;
}
}
LoaderOptionalData = BootOption->OptionalData;
if (LoaderOptionalData != NULL) {
BootType = (ARM_BDS_LOADER_TYPE)ReadUnaligned32 ((UINT32 *)(&LoaderOptionalData->Header.LoaderType));
} else {
BootType = BDS_LOADER_EFI_APPLICATION;
}
if ((BootType == BDS_LOADER_KERNEL_LINUX_ATAG) || (BootType == BDS_LOADER_KERNEL_LINUX_FDT)) {
LinuxArguments = &LoaderOptionalData->Arguments.LinuxArguments;
CmdLineSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->CmdLineSize);
InitrdSize = ReadUnaligned16 ((CONST UINT16*)&LinuxArguments->InitrdSize);
if (InitrdSize > 0) {
Print(L"Keep the initrd: ");
} else {
Print(L"Add an initrd: ");
}
Status = GetHIInputBoolean (&InitrdSupport);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto EXIT;
}
if (InitrdSupport) {
if (InitrdSize > 0) {
// Case we update the initrd device path
Status = DeviceSupport->UpdateDevicePathNode ((EFI_DEVICE_PATH*)((UINTN)(LinuxArguments + 1) + CmdLineSize), L"initrd", &InitrdPath);
if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) {// EFI_NOT_FOUND is returned on empty input string, but we can boot without an initrd
Status = EFI_ABORTED;
goto EXIT;
}
InitrdSize = GetDevicePathSize (InitrdPath);
} else {
// Case we create the initrd device path
Status = DeviceSupport->CreateDevicePathNode (L"initrd", &InitrdPathNodes);
if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) { // EFI_NOT_FOUND is returned on empty input string, but we can boot without an initrd
Status = EFI_ABORTED;
goto EXIT;
}
if (InitrdPathNodes != NULL) {
// Duplicate Linux kernel Device Path
TempInitrdPath = DuplicateDevicePath (BootOption->FilePathList);
// Replace Linux kernel Node by EndNode
SetDevicePathEndNode (GetLastDevicePathNode (TempInitrdPath));
// Append the Device Path to the selected device path
InitrdPath = AppendDevicePath (TempInitrdPath, (CONST EFI_DEVICE_PATH_PROTOCOL *)InitrdPathNodes);
FreePool (TempInitrdPath);
// Free the InitrdPathNodes created by Support->CreateDevicePathNode()
FreePool (InitrdPathNodes);
if (InitrdPath == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto EXIT;
}
InitrdSize = GetDevicePathSize (InitrdPath);
} else {
InitrdPath = NULL;
}
}
} else {
InitrdSize = 0;
}
Print(L"Arguments to pass to the binary: ");
if (CmdLineSize > 0) {
AsciiStrnCpy (CmdLine, (CONST CHAR8*)(LinuxArguments + 1), sizeof (CmdLine));
CmdLine[sizeof (CmdLine) - 1] = '\0';
} else {
CmdLine[0] = '\0';
}
Status = EditHIInputAscii (CmdLine, BOOT_DEVICE_OPTION_MAX);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto FREE_DEVICE_PATH;
}
CmdLineSize = AsciiStrSize (CmdLine);
OptionalDataSize = sizeof(ARM_BDS_LOADER_ARGUMENTS) + CmdLineSize + InitrdSize;
BootArguments = (ARM_BDS_LOADER_ARGUMENTS*)AllocatePool (OptionalDataSize);
BootArguments->LinuxArguments.CmdLineSize = CmdLineSize;
BootArguments->LinuxArguments.InitrdSize = InitrdSize;
CopyMem (&BootArguments->LinuxArguments + 1, CmdLine, CmdLineSize);
CopyMem ((VOID*)((UINTN)(&BootArguments->LinuxArguments + 1) + CmdLineSize), InitrdPath, InitrdSize);
OptionalData = (UINT8*)BootArguments;
} else {
Print (L"Arguments to pass to the EFI Application: ");
if (BootOption->OptionalDataSize > 0) {
IsPrintable = IsPrintableString (BootOption->OptionalData, &IsUnicode);
if (IsPrintable) {
//
// The size in bytes of the string, final zero included, should
// be equal to or at least lower than "BootOption->OptionalDataSize"
// and the "IsPrintableString()" has already tested that the length
// in number of characters is smaller than BOOT_DEVICE_OPTION_MAX,
// final '\0' included. We can thus copy the string for editing
// using "CopyMem()". Furthermore, note that in the case of an Unicode
// string "StrnCpy()" and "StrCpy()" can not be used to copy the
// string because the data pointed to by "BootOption->OptionalData"
// is not necessarily 2-byte aligned.
//
if (IsUnicode) {
CopyMem (
UnicodeCmdLine, BootOption->OptionalData,
MIN (sizeof (UnicodeCmdLine),
BootOption->OptionalDataSize)
);
} else {
CopyMem (
CmdLine, BootOption->OptionalData,
MIN (sizeof (CmdLine),
BootOption->OptionalDataSize)
);
}
}
} else {
UnicodeCmdLine[0] = L'\0';
IsPrintable = TRUE;
IsUnicode = TRUE;
}
// We do not request arguments for OptionalData that cannot be printed
if (IsPrintable) {
if (IsUnicode) {
Status = EditHIInputStr (UnicodeCmdLine, BOOT_DEVICE_OPTION_MAX);
if (EFI_ERROR (Status)) {
Status = EFI_ABORTED;
goto FREE_DEVICE_PATH;
}
OptionalData = (UINT8*)UnicodeCmdLine;
OptionalDataSize = StrSize (UnicodeCmdLine);
} else {
Status = EditHIInputAscii (CmdLine, BOOT_DEVICE_OPTION_MAX);
if (EFI_ERROR (Status)) {
Status = EFI_ABORTED;
goto FREE_DEVICE_PATH;
}
OptionalData = (UINT8*)CmdLine;
OptionalDataSize = AsciiStrSize (CmdLine);
}
} else {
// We keep the former OptionalData
OptionalData = BootOption->OptionalData;
OptionalDataSize = BootOption->OptionalDataSize;
}
}
Print(L"Description for this new Entry: ");
StrnCpy (BootDescription, BootOption->Description, BOOT_DEVICE_DESCRIPTION_MAX);
Status = EditHIInputStr (BootDescription, BOOT_DEVICE_DESCRIPTION_MAX);
if (EFI_ERROR(Status)) {
Status = EFI_ABORTED;
goto FREE_DEVICE_PATH;
}
// Update the entry
Status = BootOptionUpdate (BootOption, BootOption->Attributes, BootDescription, DevicePath, BootType, OptionalData, OptionalDataSize);
FREE_DEVICE_PATH:
FreePool (DevicePath);
EXIT:
if (Status == EFI_ABORTED) {
Print(L"\n");
}
return Status;
}
EFI_STATUS
StartDefaultBootOnTimeout (
VOID
)
{
UINTN Size;
UINT16 Timeout;
UINT16 *TimeoutPtr;
EFI_EVENT WaitList[2];
UINTN WaitIndex;
UINT16 *BootOrder = NULL;
UINTN BootOrderSize = 0;
UINTN Index;
CHAR16 BootVariableName[9];
EFI_STATUS Status;
EFI_INPUT_KEY Key;
LIST_ENTRY BootOptionsList;
BOOLEAN IsFlashBootFirst = FALSE;
BOOLEAN FlashBootSupport = FALSE;
// Get the Boot Option Order from the environment variable (a default value should have been created)
Status = GetGlobalEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);
if (EFI_ERROR(Status))
{
DEBUG((EFI_D_ERROR, "%a(%d):Return a error Status\n", __FUNCTION__,__LINE__));
}
Status = GetBootDeviceTypeInfo();
if (EFI_ERROR(Status))
{
DEBUG((EFI_D_ERROR, "%a(%d):Return a error Status\n", __FUNCTION__,__LINE__));
}
Status = OemBootOrderSeting(BootOrder,BootOrderSize,&IsFlashBootFirst,&FlashBootSupport);
if (EFI_ERROR(Status))
{
DEBUG((EFI_D_ERROR, "%a(%d):Return a error Status\n", __FUNCTION__,__LINE__));
}
// Update (or Create) the BootOrder environment variable
Status = gRT->SetVariable (
L"BootOrder",
&gEfiGlobalVariableGuid,
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
BootOrderSize,
BootOrder
);
if (EFI_ERROR(Status))
{
DEBUG((EFI_D_ERROR, "%a(%d):SetVariable failed!\n", __FUNCTION__,__LINE__));
}
Size = sizeof(UINT16);
Timeout = (UINT16)PcdGet16 (PcdPlatformBootTimeOut);
Status = GetGlobalEnvironmentVariable (L"Timeout", &Timeout, &Size, (VOID**)&TimeoutPtr);
if (!EFI_ERROR (Status)) {
Timeout = *TimeoutPtr;
FreePool (TimeoutPtr);
}
if (Timeout != 0xFFFF) {
if (Timeout > 0) {
// Create the waiting events (keystroke and 1sec timer)
gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &WaitList[0]);
gBS->SetTimer (WaitList[0], TimerPeriodic, EFI_SET_TIMER_TO_SECOND);
WaitList[1] = gST->ConIn->WaitForKey;
// Start the timer
WaitIndex = 0;
Print(L"The default boot selection will start in ");
while ((Timeout > 0) && (WaitIndex == 0)) {
Print(L"%3d seconds",Timeout);
gBS->WaitForEvent (2, WaitList, &WaitIndex);
if (WaitIndex == 0) {
Print(L"\b\b\b\b\b\b\b\b\b\b\b");
Timeout--;
}
}
// Discard key in the buffer
do {
Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
} while(!EFI_ERROR(Status));
gBS->CloseEvent (WaitList[0]);
Print(L"\n\r");
}
// In case of Timeout we start the default boot selection
if (Timeout == 0) {
// Get the Boot Option Order from the environment variable (a default value should have been created)
Status = GetGlobalEnvironmentVariable (L"BootOrder", NULL, &BootOrderSize, (VOID**)&BootOrder);
if (EFI_ERROR(Status))
{
DEBUG((EFI_D_ERROR, "%a(%d):Return a error Status\n", __FUNCTION__,__LINE__));
}
//display the final BootOrder EnviromentVariable, we'll start OS with it!
BootOptionList (&BootOptionsList);
DisplayBootOptions(&BootOptionsList);
if(FlashBootSupport)
{
if(IsFlashBootFirst)
{
Print(L"Bds TimeOut First Start Boot Option [FLASH] ....Begin!...\n\r");
Flash_Start_OS ();
Print(L"Bds TimeOut First Start Boot Option [FLASH] ....Fail!...\n\r");
}
}
for (Index = 0; Index < BootOrderSize / sizeof (UINT16); Index++) {
UnicodeSPrint (BootVariableName, 9 * sizeof(CHAR16), L"Boot%04X", BootOrder[Index]);
OemPreStartBootOptionAction(BootOrder[Index]);
Print(L"Bds TimeOut Start Boot Option [%s] ....Begin!...\n\r",BootVariableName);
Status = BdsStartBootOption (BootVariableName);
if(!EFI_ERROR(Status)){
// Boot option returned successfully, hence don't need to start next boot option
break;
}
Print(L"Bds TimeOut Start Boot Option [%s] ....Fail!...\n\r",BootVariableName);
}
if(FlashBootSupport)
{
if(!IsFlashBootFirst)
{
Print(L"Bds TimeOut Start Boot Option [FLASH] ....Begin!...\n\r");
Flash_Start_OS ();
Print(L"Bds TimeOut Start Boot Option [FLASH] ....Fail!...\n\r");
}
}else{}
// We only free it if the UEFI Variable 'BootOrder' was already existing
if (BootOrderSize > sizeof(UINT16)) {
FreePool (BootOrder);
}
OpenAlarmLed();
Print(L"[WARNING]Bds TimeOut: All Boot Option Start Fail! Lighting The Alarm Led!!! \n\r");
}
}
return EFI_SUCCESS;
}
