/** @file\r
BDS Lib functions which relate with create or process the boot option.\r
\r
-Copyright (c) 2004 - 2008, Intel Corporation. <BR>\r
-All rights reserved. This program and the accompanying materials\r
+Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>\r
+This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
**/\r
\r
#include "InternalBdsLib.h"\r
+#include "String.h"\r
\r
BOOLEAN mEnumBootDevice = FALSE;\r
+EFI_HII_HANDLE gBdsLibStringPackHandle = NULL;\r
\r
///\r
/// This GUID is used for an EFI Variable that stores the front device pathes\r
///\r
EFI_GUID mHdBootVariablePrivateGuid = { 0xfab7e9e1, 0x39dd, 0x4f2b, { 0x84, 0x8, 0xe2, 0xe, 0x90, 0x6c, 0xb6, 0xde } };\r
\r
+///\r
+/// This GUID is used for register UNI string.\r
+///\r
+EFI_GUID mBdsLibStringPackGuid = { 0x3b4d9b23, 0x95ac, 0x44f6, { 0x9f, 0xcd, 0xe, 0x95, 0x94, 0x58, 0x6c, 0x72 } };\r
+\r
+///\r
+/// This GUID is used for Set/Get platform language into/from variable at last time enumeration to ensure the enumeration will\r
+/// only execute once.\r
+///\r
+EFI_GUID mBdsLibLastLangGuid = { 0xe8c545b, 0xa2ee, 0x470d, { 0x8e, 0x26, 0xbd, 0xa1, 0xa1, 0x3c, 0xa, 0xa3 } };\r
+\r
+/**\r
+ The constructor function register UNI strings into imageHandle.\r
+ \r
+ It will ASSERT() if that operation fails and it will always return EFI_SUCCESS. \r
+\r
+ @param ImageHandle The firmware allocated handle for the EFI image.\r
+ @param SystemTable A pointer to the EFI System Table.\r
+ \r
+ @retval EFI_SUCCESS The constructor successfully added string package.\r
+ @retval Other value The constructor can't add string package.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+GenericBdsLibConstructor (\r
+ IN EFI_HANDLE ImageHandle,\r
+ IN EFI_SYSTEM_TABLE *SystemTable\r
+ )\r
+{\r
+\r
+ gBdsLibStringPackHandle = HiiAddPackages (\r
+ &mBdsLibStringPackGuid,\r
+ &ImageHandle,\r
+ GenericBdsLibStrings,\r
+ NULL\r
+ );\r
+\r
+ ASSERT (gBdsLibStringPackHandle != NULL);\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
\r
\r
/**\r
BdsRefreshBbsTableForBoot (Option);\r
\r
//\r
- // Write boot to OS performance data to a file\r
+ // Write boot to OS performance data for legacy boot.\r
//\r
PERF_CODE (\r
WriteBootToOsPerformanceData ();\r
\r
@retval TRUE This boot option matches a valid EFI NV Boot####.\r
@retval FALSE If not.\r
- \r
+\r
**/\r
BOOLEAN\r
IsBootOptionValidNVVarialbe (\r
}\r
\r
//\r
- // If the Boot Option Number and Device Path matches, OptionToCheck matches a \r
+ // If the Boot Option Number and Device Path matches, OptionToCheck matches a\r
// valid EFI NV Boot####.\r
//\r
if ((OptionToCheck->BootCurrent == BootOption->BootCurrent) &&\r
}\r
\r
FreePool (BootOption);\r
- \r
+\r
return Valid;\r
}\r
+\r
+/**\r
+ Check whether a USB device match the specified USB Class device path. This\r
+ function follows "Load Option Processing" behavior in UEFI specification.\r
+\r
+ @param UsbIo USB I/O protocol associated with the USB device.\r
+ @param UsbClass The USB Class device path to match.\r
+\r
+ @retval TRUE The USB device match the USB Class device path.\r
+ @retval FALSE The USB device does not match the USB Class device path.\r
+\r
+**/\r
+BOOLEAN\r
+BdsMatchUsbClass (\r
+ IN EFI_USB_IO_PROTOCOL *UsbIo,\r
+ IN USB_CLASS_DEVICE_PATH *UsbClass\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_USB_DEVICE_DESCRIPTOR DevDesc;\r
+ EFI_USB_INTERFACE_DESCRIPTOR IfDesc;\r
+ UINT8 DeviceClass;\r
+ UINT8 DeviceSubClass;\r
+ UINT8 DeviceProtocol;\r
+\r
+ if ((DevicePathType (UsbClass) != MESSAGING_DEVICE_PATH) ||\r
+ (DevicePathSubType (UsbClass) != MSG_USB_CLASS_DP)){\r
+ return FALSE;\r
+ }\r
+\r
+ //\r
+ // Check Vendor Id and Product Id.\r
+ //\r
+ Status = UsbIo->UsbGetDeviceDescriptor (UsbIo, &DevDesc);\r
+ if (EFI_ERROR (Status)) {\r
+ return FALSE;\r
+ }\r
+\r
+ if ((UsbClass->VendorId != 0xffff) &&\r
+ (UsbClass->VendorId != DevDesc.IdVendor)) {\r
+ return FALSE;\r
+ }\r
+\r
+ if ((UsbClass->ProductId != 0xffff) &&\r
+ (UsbClass->ProductId != DevDesc.IdProduct)) {\r
+ return FALSE;\r
+ }\r
+\r
+ DeviceClass = DevDesc.DeviceClass;\r
+ DeviceSubClass = DevDesc.DeviceSubClass;\r
+ DeviceProtocol = DevDesc.DeviceProtocol;\r
+ if (DeviceClass == 0) {\r
+ //\r
+ // If Class in Device Descriptor is set to 0, use the Class, SubClass and\r
+ // Protocol in Interface Descriptor instead.\r
+ //\r
+ Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &IfDesc);\r
+ if (EFI_ERROR (Status)) {\r
+ return FALSE;\r
+ }\r
+\r
+ DeviceClass = IfDesc.InterfaceClass;\r
+ DeviceSubClass = IfDesc.InterfaceSubClass;\r
+ DeviceProtocol = IfDesc.InterfaceProtocol;\r
+ }\r
+\r
+ //\r
+ // Check Class, SubClass and Protocol.\r
+ //\r
+ if ((UsbClass->DeviceClass != 0xff) &&\r
+ (UsbClass->DeviceClass != DeviceClass)) {\r
+ return FALSE;\r
+ }\r
+\r
+ if ((UsbClass->DeviceSubClass != 0xff) &&\r
+ (UsbClass->DeviceSubClass != DeviceSubClass)) {\r
+ return FALSE;\r
+ }\r
+\r
+ if ((UsbClass->DeviceProtocol != 0xff) &&\r
+ (UsbClass->DeviceProtocol != DeviceProtocol)) {\r
+ return FALSE;\r
+ }\r
+\r
+ return TRUE;\r
+}\r
+\r
+/**\r
+ Check whether a USB device match the specified USB WWID device path. This\r
+ function follows "Load Option Processing" behavior in UEFI specification.\r
+\r
+ @param UsbIo USB I/O protocol associated with the USB device.\r
+ @param UsbWwid The USB WWID device path to match.\r
+\r
+ @retval TRUE The USB device match the USB WWID device path.\r
+ @retval FALSE The USB device does not match the USB WWID device path.\r
+\r
+**/\r
+BOOLEAN\r
+BdsMatchUsbWwid (\r
+ IN EFI_USB_IO_PROTOCOL *UsbIo,\r
+ IN USB_WWID_DEVICE_PATH *UsbWwid\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_USB_DEVICE_DESCRIPTOR DevDesc;\r
+ EFI_USB_INTERFACE_DESCRIPTOR IfDesc;\r
+ UINT16 *LangIdTable;\r
+ UINT16 TableSize;\r
+ UINT16 Index;\r
+ CHAR16 *CompareStr;\r
+ UINTN CompareLen;\r
+ CHAR16 *SerialNumberStr;\r
+ UINTN Length;\r
+\r
+ if ((DevicePathType (UsbWwid) != MESSAGING_DEVICE_PATH) ||\r
+ (DevicePathSubType (UsbWwid) != MSG_USB_WWID_DP )){\r
+ return FALSE;\r
+ }\r
+\r
+ //\r
+ // Check Vendor Id and Product Id.\r
+ //\r
+ Status = UsbIo->UsbGetDeviceDescriptor (UsbIo, &DevDesc);\r
+ if (EFI_ERROR (Status)) {\r
+ return FALSE;\r
+ }\r
+ if ((DevDesc.IdVendor != UsbWwid->VendorId) ||\r
+ (DevDesc.IdProduct != UsbWwid->ProductId)) {\r
+ return FALSE;\r
+ }\r
+\r
+ //\r
+ // Check Interface Number.\r
+ //\r
+ Status = UsbIo->UsbGetInterfaceDescriptor (UsbIo, &IfDesc);\r
+ if (EFI_ERROR (Status)) {\r
+ return FALSE;\r
+ }\r
+ if (IfDesc.InterfaceNumber != UsbWwid->InterfaceNumber) {\r
+ return FALSE;\r
+ }\r
+\r
+ //\r
+ // Check Serial Number.\r
+ //\r
+ if (DevDesc.StrSerialNumber == 0) {\r
+ return FALSE;\r
+ }\r
+\r
+ //\r
+ // Get all supported languages.\r
+ //\r
+ TableSize = 0;\r
+ LangIdTable = NULL;\r
+ Status = UsbIo->UsbGetSupportedLanguages (UsbIo, &LangIdTable, &TableSize);\r
+ if (EFI_ERROR (Status) || (TableSize == 0) || (LangIdTable == NULL)) {\r
+ return FALSE;\r
+ }\r
+\r
+ //\r
+ // Serial number in USB WWID device path is the last 64-or-less UTF-16 characters.\r
+ //\r
+ CompareStr = (CHAR16 *) (UINTN) (UsbWwid + 1);\r
+ CompareLen = (DevicePathNodeLength (UsbWwid) - sizeof (USB_WWID_DEVICE_PATH)) / sizeof (CHAR16);\r
+ if (CompareStr[CompareLen - 1] == L'\0') {\r
+ CompareLen--;\r
+ }\r
+\r
+ //\r
+ // Compare serial number in each supported language.\r
+ //\r
+ for (Index = 0; Index < TableSize / sizeof (UINT16); Index++) {\r
+ SerialNumberStr = NULL;\r
+ Status = UsbIo->UsbGetStringDescriptor (\r
+ UsbIo,\r
+ LangIdTable[Index],\r
+ DevDesc.StrSerialNumber,\r
+ &SerialNumberStr\r
+ );\r
+ if (EFI_ERROR (Status) || (SerialNumberStr == NULL)) {\r
+ continue;\r
+ }\r
+\r
+ Length = StrLen (SerialNumberStr);\r
+ if ((Length >= CompareLen) &&\r
+ (CompareMem (SerialNumberStr + Length - CompareLen, CompareStr, CompareLen * sizeof (CHAR16)) == 0)) {\r
+ FreePool (SerialNumberStr);\r
+ return TRUE;\r
+ }\r
+\r
+ FreePool (SerialNumberStr);\r
+ }\r
+\r
+ return FALSE;\r
+}\r
+\r
+/**\r
+ Find a USB device which match the specified short-form device path start with \r
+ USB Class or USB WWID device path. If ParentDevicePath is NULL, this function\r
+ will search in all USB devices of the platform. If ParentDevicePath is not NULL,\r
+ this function will only search in its child devices.\r
+\r
+ @param ParentDevicePath The device path of the parent.\r
+ @param ShortFormDevicePath The USB Class or USB WWID device path to match.\r
+\r
+ @return The handle of matched USB device, or NULL if not found.\r
+\r
+**/\r
+EFI_HANDLE *\r
+BdsFindUsbDevice (\r
+ IN EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath,\r
+ IN EFI_DEVICE_PATH_PROTOCOL *ShortFormDevicePath\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ UINTN UsbIoHandleCount;\r
+ EFI_HANDLE *UsbIoHandleBuffer;\r
+ EFI_DEVICE_PATH_PROTOCOL *UsbIoDevicePath;\r
+ EFI_USB_IO_PROTOCOL *UsbIo;\r
+ UINTN Index;\r
+ UINTN ParentSize;\r
+ UINTN Size;\r
+ EFI_HANDLE ReturnHandle;\r
+\r
+ //\r
+ // Get all UsbIo Handles.\r
+ //\r
+ UsbIoHandleCount = 0;\r
+ UsbIoHandleBuffer = NULL;\r
+ Status = gBS->LocateHandleBuffer (\r
+ ByProtocol,\r
+ &gEfiUsbIoProtocolGuid,\r
+ NULL,\r
+ &UsbIoHandleCount,\r
+ &UsbIoHandleBuffer\r
+ );\r
+ if (EFI_ERROR (Status) || (UsbIoHandleCount == 0) || (UsbIoHandleBuffer == NULL)) {\r
+ return NULL;\r
+ }\r
+\r
+ ReturnHandle = NULL;\r
+ ParentSize = (ParentDevicePath == NULL) ? 0 : GetDevicePathSize (ParentDevicePath);\r
+ for (Index = 0; Index < UsbIoHandleCount; Index++) {\r
+ //\r
+ // Get the Usb IO interface.\r
+ //\r
+ Status = gBS->HandleProtocol(\r
+ UsbIoHandleBuffer[Index],\r
+ &gEfiUsbIoProtocolGuid,\r
+ (VOID **) &UsbIo\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ continue;\r
+ }\r
+\r
+ if (ParentDevicePath != NULL) {\r
+ //\r
+ // Compare starting part of UsbIoHandle's device path with ParentDevicePath.\r
+ //\r
+ UsbIoDevicePath = DevicePathFromHandle (UsbIoHandleBuffer[Index]);\r
+ ASSERT (UsbIoDevicePath != NULL);\r
+\r
+ Size = GetDevicePathSize (UsbIoDevicePath);\r
+ if ((Size < ParentSize) ||\r
+ (CompareMem (UsbIoDevicePath, ParentDevicePath, ParentSize - END_DEVICE_PATH_LENGTH) != 0)) {\r
+ continue;\r
+ }\r
+ }\r
+\r
+ if (BdsMatchUsbClass (UsbIo, (USB_CLASS_DEVICE_PATH *) ShortFormDevicePath) ||\r
+ BdsMatchUsbWwid (UsbIo, (USB_WWID_DEVICE_PATH *) ShortFormDevicePath)) {\r
+ ReturnHandle = UsbIoHandleBuffer[Index];\r
+ break;\r
+ }\r
+ }\r
+\r
+ FreePool (UsbIoHandleBuffer);\r
+ return ReturnHandle;\r
+}\r
+\r
+/**\r
+ Expand USB Class or USB WWID device path node to be full device path of a USB\r
+ device in platform.\r
+\r
+ This function support following 4 cases:\r
+ 1) Boot Option device path starts with a USB Class or USB WWID device path,\r
+ and there is no Media FilePath device path in the end.\r
+ In this case, it will follow Removable Media Boot Behavior.\r
+ 2) Boot Option device path starts with a USB Class or USB WWID device path,\r
+ and ended with Media FilePath device path.\r
+ 3) Boot Option device path starts with a full device path to a USB Host Controller,\r
+ contains a USB Class or USB WWID device path node, while not ended with Media\r
+ FilePath device path. In this case, it will follow Removable Media Boot Behavior.\r
+ 4) Boot Option device path starts with a full device path to a USB Host Controller,\r
+ contains a USB Class or USB WWID device path node, and ended with Media\r
+ FilePath device path.\r
+\r
+ @param DevicePath The Boot Option device path.\r
+\r
+ @return The full device path after expanding, or NULL if there is no USB Class\r
+ or USB WWID device path found, or USB Class or USB WWID device path\r
+ was found but failed to expand it.\r
+\r
+**/\r
+EFI_DEVICE_PATH_PROTOCOL *\r
+BdsExpandUsbShortFormDevicePath (\r
+ IN EFI_DEVICE_PATH_PROTOCOL *DevicePath\r
+ )\r
+{\r
+ EFI_DEVICE_PATH_PROTOCOL *FullDevicePath;\r
+ EFI_HANDLE *UsbIoHandle;\r
+ EFI_DEVICE_PATH_PROTOCOL *UsbIoDevicePath;\r
+ EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;\r
+ EFI_DEVICE_PATH_PROTOCOL *NextDevicePath;\r
+ EFI_DEVICE_PATH_PROTOCOL *ShortFormDevicePath;\r
+\r
+ //\r
+ // Search for USB Class or USB WWID device path node.\r
+ //\r
+ ShortFormDevicePath = NULL;\r
+ TempDevicePath = DevicePath;\r
+ while (!IsDevicePathEnd (TempDevicePath)) {\r
+ if ((DevicePathType (TempDevicePath) == MESSAGING_DEVICE_PATH) &&\r
+ ((DevicePathSubType (TempDevicePath) == MSG_USB_CLASS_DP) ||\r
+ (DevicePathSubType (TempDevicePath) == MSG_USB_WWID_DP))) {\r
+ ShortFormDevicePath = TempDevicePath;\r
+ break;\r
+ }\r
+\r
+ TempDevicePath = NextDevicePathNode (TempDevicePath);\r
+ }\r
+\r
+ if (ShortFormDevicePath == NULL) {\r
+ //\r
+ // No USB Class or USB WWID device path node found, do nothing.\r
+ //\r
+ return NULL;\r
+ }\r
+\r
+ if (ShortFormDevicePath == DevicePath) {\r
+ //\r
+ // Boot Option device path starts with USB Class or USB WWID device path.\r
+ //\r
+ UsbIoHandle = BdsFindUsbDevice (NULL, ShortFormDevicePath);\r
+ if (UsbIoHandle == NULL) {\r
+ //\r
+ // Failed to find a match in existing devices, connect the short form USB\r
+ // device path and try again.\r
+ //\r
+ BdsLibConnectUsbDevByShortFormDP (0xff, ShortFormDevicePath);\r
+ UsbIoHandle = BdsFindUsbDevice (NULL, ShortFormDevicePath);\r
+ }\r
+ } else {\r
+ //\r
+ // Boot Option device path contains USB Class or USB WWID device path node.\r
+ //\r
+\r
+ //\r
+ // Prepare the parent device path for search.\r
+ //\r
+ TempDevicePath = DuplicateDevicePath (DevicePath);\r
+ ASSERT (TempDevicePath != NULL);\r
+ SetDevicePathEndNode (((UINT8 *) TempDevicePath) + ((UINTN) ShortFormDevicePath - (UINTN) DevicePath));\r
+\r
+ //\r
+ // The USB Host Controller device path is in already in Boot Option device path\r
+ // and USB Bus driver already support RemainingDevicePath starts with USB\r
+ // Class or USB WWID device path, so just search in existing USB devices and\r
+ // doesn't perform ConnectController here.\r
+ //\r
+ UsbIoHandle = BdsFindUsbDevice (TempDevicePath, ShortFormDevicePath);\r
+ FreePool (TempDevicePath);\r
+ }\r
+\r
+ if (UsbIoHandle == NULL) {\r
+ //\r
+ // Failed to expand USB Class or USB WWID device path.\r
+ //\r
+ return NULL;\r
+ }\r
+\r
+ //\r
+ // Get device path of the matched USB device.\r
+ //\r
+ UsbIoDevicePath = DevicePathFromHandle (UsbIoHandle);\r
+ ASSERT (UsbIoDevicePath != NULL);\r
+\r
+ FullDevicePath = NULL;\r
+ //\r
+ // Advance to next device path node to skip the USB Class or USB WWID device path.\r
+ //\r
+ NextDevicePath = NextDevicePathNode (ShortFormDevicePath);\r
+ if (!IsDevicePathEnd (NextDevicePath)) {\r
+ //\r
+ // There is remaining device path after USB Class or USB WWID device path\r
+ // node, append it to the USB device path.\r
+ //\r
+ FullDevicePath = AppendDevicePath (UsbIoDevicePath, NextDevicePath);\r
+\r
+ //\r
+ // Connect the full device path, so that Simple File System protocol\r
+ // could be installed for this USB device.\r
+ //\r
+ BdsLibConnectDevicePath (FullDevicePath);\r
+ } else {\r
+ //\r
+ // USB Class or WWID device path is in the end.\r
+ //\r
+ FullDevicePath = UsbIoDevicePath;\r
+ }\r
+\r
+ return FullDevicePath;\r
+}\r
+\r
/**\r
Process the boot option follow the UEFI specification and\r
special treat the legacy boot option with BBS_DEVICE_PATH.\r
EFI_DEVICE_PATH_PROTOCOL *WorkingDevicePath;\r
EFI_ACPI_S3_SAVE_PROTOCOL *AcpiS3Save;\r
LIST_ENTRY TempBootLists;\r
- EFI_SECURITY_ARCH_PROTOCOL *SecurityProtocol;\r
\r
//\r
// Record the performance data for End of BDS\r
//\r
- PERF_END (0, "BDS", NULL, 0);\r
+ PERF_END(NULL, "BDS", NULL, 0);\r
\r
*ExitDataSize = 0;\r
*ExitData = NULL;\r
\r
- //\r
- // Notes: put EFI64 ROM Shadow Solution\r
- //\r
- EFI64_SHADOW_ALL_LEGACY_ROM ();\r
-\r
//\r
// Notes: this code can be remove after the s3 script table\r
// hook on the event EVT_SIGNAL_READY_TO_BOOT or\r
DevicePath = WorkingDevicePath;\r
}\r
}\r
+\r
+ //\r
+ // Expand USB Class or USB WWID drive path node to full device path.\r
+ //\r
+ WorkingDevicePath = BdsExpandUsbShortFormDevicePath (DevicePath);\r
+ if (WorkingDevicePath != NULL) {\r
+ DevicePath = WorkingDevicePath;\r
+ }\r
+\r
//\r
// Signal the EVT_SIGNAL_READY_TO_BOOT event\r
//\r
EfiSignalEventReadyToBoot();\r
- \r
- \r
+\r
+ //\r
+ // Adjust the different type memory page number just before booting\r
+ // and save the updated info into the variable for next boot to use\r
+ //\r
+ BdsSetMemoryTypeInformationVariable ();\r
+\r
+\r
//\r
// Set Boot Current\r
//\r
//\r
InitializeListHead (&TempBootLists);\r
BdsLibRegisterNewOption (&TempBootLists, DevicePath, L"EFI Internal Shell", L"BootOrder");\r
- \r
+\r
//\r
// free the temporary device path created by BdsLibUpdateFvFileDevicePath()\r
//\r
- FreePool (DevicePath); \r
+ FreePool (DevicePath);\r
DevicePath = Option->DevicePath;\r
}\r
\r
- //\r
- // Measure GPT Table by SAP protocol.\r
- //\r
- Status = gBS->LocateProtocol (\r
- &gEfiSecurityArchProtocolGuid,\r
- NULL,\r
- (VOID**) &SecurityProtocol\r
- );\r
- if (!EFI_ERROR (Status)) {\r
- Status = SecurityProtocol->FileAuthenticationState (SecurityProtocol, 0, DevicePath);\r
- }\r
-\r
- DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Booting %S\n", Option->Description));\r
+ DEBUG_CODE_BEGIN();\r
\r
+ if (Option->Description == NULL) {\r
+ DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Booting from unknown device path\n"));\r
+ } else {\r
+ DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Booting %S\n", Option->Description));\r
+ }\r
+ \r
+ DEBUG_CODE_END();\r
+ \r
Status = gBS->LoadImage (\r
TRUE,\r
- mBdsImageHandle,\r
+ gImageHandle,\r
DevicePath,\r
NULL,\r
0,\r
);\r
\r
//\r
- // If we didn't find an image directly, we need to try as if it is a removable device boot opotion\r
+ // If we didn't find an image directly, we need to try as if it is a removable device boot option\r
// and load the image according to the default boot behavior for removable device.\r
//\r
if (EFI_ERROR (Status)) {\r
if (FilePath != NULL) {\r
Status = gBS->LoadImage (\r
TRUE,\r
- mBdsImageHandle,\r
+ gImageHandle,\r
FilePath,\r
NULL,\r
0,\r
//\r
gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL);\r
\r
+ //\r
+ // Write boot to OS performance data for UEFI boot\r
+ //\r
+ PERF_CODE (\r
+ WriteBootToOsPerformanceData ();\r
+ );\r
+\r
Status = gBS->StartImage (ImageHandle, ExitDataSize, ExitData);\r
DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Image Return Status = %r\n", Status));\r
\r
&mHdBootVariablePrivateGuid,\r
&CachedDevicePathSize\r
);\r
- \r
+\r
if (CachedDevicePath != NULL) {\r
TempNewDevicePath = CachedDevicePath;\r
DeviceExist = FALSE;\r
TempNewDevicePath = CachedDevicePath;\r
CachedDevicePath = BdsLibDelPartMatchInstance (CachedDevicePath, Instance );\r
FreePool (TempNewDevicePath);\r
- \r
+\r
//\r
// Second, append the remaining path after the matched instance\r
//\r
CachedDevicePath\r
);\r
}\r
- \r
+\r
FreePool (Instance);\r
FreePool (CachedDevicePath);\r
return FullDevicePath;\r
\r
TempNewDevicePath = CachedDevicePath;\r
CachedDevicePath = AppendDevicePathInstance (BlockIoDevicePath, CachedDevicePath);\r
- FreePool(TempNewDevicePath);\r
+ if (TempNewDevicePath != NULL) {\r
+ FreePool(TempNewDevicePath);\r
+ }\r
} else {\r
TempNewDevicePath = CachedDevicePath;\r
CachedDevicePath = AppendDevicePathInstance (BlockIoDevicePath, CachedDevicePath);\r
break;\r
}\r
}\r
- \r
- FreePool (CachedDevicePath);\r
+\r
+ if (CachedDevicePath != NULL) {\r
+ FreePool (CachedDevicePath);\r
+ }\r
if (BlockIoBuffer != NULL) {\r
FreePool (BlockIoBuffer);\r
}\r
if ((BlockIoDevicePath == NULL) || (HardDriveDevicePath == NULL)) {\r
return FALSE;\r
}\r
- \r
+\r
//\r
// Make PreviousDevicePath == the device path node before the end node\r
//\r
//\r
TmpHdPath = (HARDDRIVE_DEVICE_PATH *) BlockIoHdDevicePathNode;\r
Match = FALSE;\r
- \r
+\r
//\r
// Check for the match\r
//\r
&gEfiGlobalVariableGuid,\r
&BootOptionSize\r
);\r
- \r
+\r
if (BootOptionVar == NULL) {\r
FreePool (BootOrder);\r
return EFI_OUT_OF_RESOURCES;\r
\r
/**\r
For EFI boot option, BDS separate them as six types:\r
- 1. Network - The boot option points to the SimpleNetworkProtocol device. \r
+ 1. Network - The boot option points to the SimpleNetworkProtocol device.\r
Bds will try to automatically create this type boot option when enumerate.\r
- 2. Shell - The boot option points to internal flash shell. \r
+ 2. Shell - The boot option points to internal flash shell.\r
Bds will try to automatically create this type boot option when enumerate.\r
3. Removable BlockIo - The boot option only points to the removable media\r
device, like USB flash disk, DVD, Floppy etc.\r
These device should contain a *removable* blockIo\r
protocol in their device handle.\r
- Bds will try to automatically create this type boot option \r
+ Bds will try to automatically create this type boot option\r
when enumerate.\r
- 4. Fixed BlockIo - The boot option only points to a Fixed blockIo device, \r
+ 4. Fixed BlockIo - The boot option only points to a Fixed blockIo device,\r
like HardDisk.\r
These device should contain a *fixed* blockIo\r
protocol in their device handle.\r
BDS will skip fixed blockIo devices, and NOT\r
- automatically create boot option for them. But BDS \r
- will help to delete those fixed blockIo boot option, \r
+ automatically create boot option for them. But BDS\r
+ will help to delete those fixed blockIo boot option,\r
whose description rule conflict with other auto-created\r
boot options.\r
- 5. Non-BlockIo Simplefile - The boot option points to a device whose handle \r
+ 5. Non-BlockIo Simplefile - The boot option points to a device whose handle\r
has SimpleFileSystem Protocol, but has no blockio\r
protocol. These devices do not offer blockIo\r
- protocol, but BDS still can get the \r
+ protocol, but BDS still can get the\r
\EFI\BOOT\boot{machinename}.EFI by SimpleFileSystem\r
Protocol.\r
- 6. File - The boot option points to a file. These boot options are usually \r
+ 6. File - The boot option points to a file. These boot options are usually\r
created by user manually or OS loader. BDS will not delete or modify\r
- these boot options. \r
- \r
+ these boot options.\r
+\r
This function will enumerate all possible boot device in the system, and\r
- automatically create boot options for Network, Shell, Removable BlockIo, \r
+ automatically create boot options for Network, Shell, Removable BlockIo,\r
and Non-BlockIo Simplefile devices.\r
It will only execute once of every boot.\r
- \r
+\r
@param BdsBootOptionList The header of the link list which indexed all\r
current boot options\r
\r
UINTN NumberBlockIoHandles;\r
EFI_HANDLE *BlockIoHandles;\r
EFI_BLOCK_IO_PROTOCOL *BlkIo;\r
+ BOOLEAN Removable[2];\r
+ UINTN RemovableIndex;\r
UINTN Index;\r
- UINTN NumberSimpleNetworkHandles;\r
- EFI_HANDLE *SimpleNetworkHandles;\r
+ UINTN NumOfLoadFileHandles;\r
+ EFI_HANDLE *LoadFileHandles;\r
UINTN FvHandleCount;\r
EFI_HANDLE *FvHandleBuffer;\r
EFI_FV_FILETYPE Type;\r
UINTN NumberFileSystemHandles;\r
BOOLEAN NeedDelete;\r
EFI_IMAGE_DOS_HEADER DosHeader;\r
+ CHAR8 *PlatLang;\r
+ CHAR8 *LastLang;\r
EFI_IMAGE_OPTIONAL_HEADER_UNION HdrData;\r
EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr;\r
\r
+ Removable[0] = FALSE;\r
+ Removable[1] = TRUE;\r
FloppyNumber = 0;\r
CdromNumber = 0;\r
UsbNumber = 0;\r
MiscNumber = 0;\r
ScsiNumber = 0;\r
+ PlatLang = NULL;\r
+ LastLang = NULL;\r
ZeroMem (Buffer, sizeof (Buffer));\r
- \r
+\r
//\r
// If the boot device enumerate happened, just get the boot\r
// device from the boot order variable\r
//\r
if (mEnumBootDevice) {\r
- Status = BdsLibBuildOptionFromVar (BdsBootOptionList, L"BootOrder");\r
- return Status;\r
+ LastLang = GetVariable (L"LastEnumLang", &mBdsLibLastLangGuid);\r
+ PlatLang = GetEfiGlobalVariable (L"PlatformLang");\r
+ ASSERT (PlatLang != NULL);\r
+ if ((LastLang != NULL) && (AsciiStrCmp (LastLang, PlatLang) == 0)) {\r
+ Status = BdsLibBuildOptionFromVar (BdsBootOptionList, L"BootOrder");\r
+ FreePool (LastLang);\r
+ FreePool (PlatLang);\r
+ return Status;\r
+ } else {\r
+ Status = gRT->SetVariable (\r
+ L"LastEnumLang",\r
+ &mBdsLibLastLangGuid,\r
+ EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,\r
+ AsciiStrSize (PlatLang),\r
+ PlatLang\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
+ if (LastLang != NULL) {\r
+ FreePool (LastLang);\r
+ }\r
+ FreePool (PlatLang);\r
+ }\r
}\r
- \r
+\r
//\r
// Notes: this dirty code is to get the legacy boot option from the\r
// BBS table and create to variable as the EFI boot option, it should\r
// Delete invalid boot option\r
//\r
BdsDeleteAllInvalidEfiBootOption ();\r
- \r
+\r
//\r
- // Parse removable media\r
+ // Parse removable media followed by fixed media\r
//\r
gBS->LocateHandleBuffer (\r
ByProtocol,\r
&NumberBlockIoHandles,\r
&BlockIoHandles\r
);\r
- \r
- for (Index = 0; Index < NumberBlockIoHandles; Index++) {\r
- Status = gBS->HandleProtocol (\r
- BlockIoHandles[Index],\r
- &gEfiBlockIoProtocolGuid,\r
- (VOID **) &BlkIo\r
- );\r
- if (!EFI_ERROR (Status)) {\r
- if (!BlkIo->Media->RemovableMedia) {\r
- //\r
- // skip the non-removable block devices\r
- //\r
+\r
+ for (RemovableIndex = 0; RemovableIndex < 2; RemovableIndex++) {\r
+ for (Index = 0; Index < NumberBlockIoHandles; Index++) {\r
+ Status = gBS->HandleProtocol (\r
+ BlockIoHandles[Index],\r
+ &gEfiBlockIoProtocolGuid,\r
+ (VOID **) &BlkIo\r
+ );\r
+ //\r
+ // skip the fixed block io then the removable block io\r
+ //\r
+ if (EFI_ERROR (Status) || (BlkIo->Media->RemovableMedia == Removable[RemovableIndex])) {\r
continue;\r
}\r
- }\r
- DevicePath = DevicePathFromHandle (BlockIoHandles[Index]);\r
- DevicePathType = BdsGetBootTypeFromDevicePath (DevicePath);\r
-\r
- switch (DevicePathType) {\r
- case BDS_EFI_ACPI_FLOPPY_BOOT:\r
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%d", FloppyNumber); \r
- BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);\r
- FloppyNumber++;\r
- break;\r
- \r
- //\r
- // Assume a removable SATA device should be the DVD/CD device\r
- //\r
- case BDS_EFI_MESSAGE_ATAPI_BOOT:\r
- case BDS_EFI_MESSAGE_SATA_BOOT:\r
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%d", CdromNumber);\r
- BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);\r
- CdromNumber++;\r
- break;\r
+ DevicePath = DevicePathFromHandle (BlockIoHandles[Index]);\r
+ DevicePathType = BdsGetBootTypeFromDevicePath (DevicePath);\r
\r
- case BDS_EFI_MESSAGE_USB_DEVICE_BOOT:\r
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%d", UsbNumber);\r
- BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);\r
- UsbNumber++;\r
- break;\r
+ switch (DevicePathType) {\r
+ case BDS_EFI_ACPI_FLOPPY_BOOT:\r
+ if (FloppyNumber != 0) {\r
+ UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_FLOPPY)), FloppyNumber);\r
+ } else {\r
+ UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_FLOPPY)));\r
+ }\r
+ BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);\r
+ FloppyNumber++;\r
+ break;\r
\r
- case BDS_EFI_MESSAGE_SCSI_BOOT:\r
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%d", ScsiNumber);\r
- BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer); \r
- ScsiNumber++;\r
- break;\r
+ //\r
+ // Assume a removable SATA device should be the DVD/CD device\r
+ //\r
+ case BDS_EFI_MESSAGE_ATAPI_BOOT:\r
+ case BDS_EFI_MESSAGE_SATA_BOOT:\r
+ if (CdromNumber != 0) {\r
+ UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_CD_DVD)), CdromNumber);\r
+ } else {\r
+ UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_CD_DVD)));\r
+ }\r
+ DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Buffer: %S\n", Buffer));\r
+ BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);\r
+ CdromNumber++;\r
+ break;\r
\r
- case BDS_EFI_MESSAGE_MISC_BOOT:\r
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%d", MiscNumber);\r
- BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer); \r
- MiscNumber++;\r
- break;\r
+ case BDS_EFI_MESSAGE_USB_DEVICE_BOOT:\r
+ if (UsbNumber != 0) {\r
+ UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_USB)), UsbNumber);\r
+ } else {\r
+ UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_USB)));\r
+ }\r
+ BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);\r
+ UsbNumber++;\r
+ break;\r
\r
- default:\r
- break;\r
+ case BDS_EFI_MESSAGE_SCSI_BOOT:\r
+ if (ScsiNumber != 0) {\r
+ UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_SCSI)), ScsiNumber);\r
+ } else {\r
+ UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_SCSI)));\r
+ }\r
+ BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);\r
+ ScsiNumber++;\r
+ break;\r
+\r
+ case BDS_EFI_MESSAGE_MISC_BOOT:\r
+ if (MiscNumber != 0) {\r
+ UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_MISC)), MiscNumber);\r
+ } else {\r
+ UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_MISC)));\r
+ }\r
+ BdsLibBuildOptionFromHandle (BlockIoHandles[Index], BdsBootOptionList, Buffer);\r
+ MiscNumber++;\r
+ break;\r
+\r
+ default:\r
+ break;\r
+ }\r
}\r
}\r
\r
// Do the removable Media thing. \EFI\BOOT\boot{machinename}.EFI\r
// machinename is ia32, ia64, x64, ...\r
//\r
- Hdr.Union = &HdrData;\r
+ Hdr.Union = &HdrData;\r
NeedDelete = TRUE;\r
Status = BdsLibGetImageHeader (\r
FileSystemHandles[Index],\r
//\r
BdsLibDeleteOptionFromHandle (FileSystemHandles[Index]);\r
} else {\r
- UnicodeSPrint (Buffer, sizeof (Buffer), L"EFI Non-Block Boot Device %d", NonBlockNumber);\r
+ if (NonBlockNumber != 0) {\r
+ UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_NON_BLOCK)), NonBlockNumber);\r
+ } else {\r
+ UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_NON_BLOCK)));\r
+ }\r
BdsLibBuildOptionFromHandle (FileSystemHandles[Index], BdsBootOptionList, Buffer);\r
NonBlockNumber++;\r
}\r
//\r
// Parse Network Boot Device\r
//\r
+ NumOfLoadFileHandles = 0;\r
+ //\r
+ // Search Load File protocol for PXE boot option.\r
+ //\r
gBS->LocateHandleBuffer (\r
ByProtocol,\r
- &gEfiSimpleNetworkProtocolGuid,\r
+ &gEfiLoadFileProtocolGuid,\r
NULL,\r
- &NumberSimpleNetworkHandles,\r
- &SimpleNetworkHandles\r
+ &NumOfLoadFileHandles,\r
+ &LoadFileHandles\r
);\r
\r
- for (Index = 0; Index < NumberSimpleNetworkHandles; Index++) {\r
- UnicodeSPrint (Buffer, sizeof (Buffer), L"%d", Index);\r
- BdsLibBuildOptionFromHandle (SimpleNetworkHandles[Index], BdsBootOptionList, Buffer);\r
+ for (Index = 0; Index < NumOfLoadFileHandles; Index++) {\r
+ if (Index != 0) {\r
+ UnicodeSPrint (Buffer, sizeof (Buffer), L"%s %d", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_NETWORK)), Index);\r
+ } else {\r
+ UnicodeSPrint (Buffer, sizeof (Buffer), L"%s", BdsLibGetStringById (STRING_TOKEN (STR_DESCRIPTION_NETWORK)));\r
+ }\r
+ BdsLibBuildOptionFromHandle (LoadFileHandles[Index], BdsBootOptionList, Buffer);\r
}\r
\r
- if (NumberSimpleNetworkHandles != 0) {\r
- FreePool (SimpleNetworkHandles);\r
+ if (NumOfLoadFileHandles != 0) {\r
+ FreePool (LoadFileHandles);\r
}\r
\r
//\r
)\r
{\r
EFI_DEVICE_PATH_PROTOCOL *DevicePath;\r
- \r
+\r
DevicePath = DevicePathFromHandle (Handle);\r
\r
//\r
EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr;\r
\r
UpdatedDevicePath = DevicePath;\r
- \r
+\r
//\r
// Check whether the device is connected\r
//\r
gBS->ConnectController (Handle, NULL, NULL, TRUE);\r
}\r
} else {\r
+ //\r
+ // For removable device boot option, its contained device path only point to the removable device handle, \r
+ // should make sure all its children handles (its child partion or media handles) are created and connected. \r
+ //\r
+ gBS->ConnectController (Handle, NULL, NULL, TRUE); \r
//\r
// Get BlockIo protocol and check removable attribute\r
//\r
//\r
DupDevicePath = DuplicateDevicePath (DevicePath);\r
ASSERT (DupDevicePath != NULL);\r
- \r
+\r
UpdatedDevicePath = DupDevicePath;\r
Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &UpdatedDevicePath, &Handle);\r
//\r
EFI_HANDLE Handle;\r
EFI_SIMPLE_NETWORK_PROTOCOL *Snp;\r
BOOLEAN MediaPresent;\r
+ UINT32 InterruptStatus;\r
\r
MediaPresent = FALSE;\r
\r
UpdatedDevicePath = DevicePath;\r
- Status = gBS->LocateDevicePath (&gEfiSimpleNetworkProtocolGuid, &UpdatedDevicePath, &Handle);\r
+ //\r
+ // Locate Load File Protocol for PXE boot option first\r
+ //\r
+ Status = gBS->LocateDevicePath (&gEfiLoadFileProtocolGuid, &UpdatedDevicePath, &Handle);\r
if (EFI_ERROR (Status)) {\r
//\r
// Device not present so see if we need to connect it\r
//\r
// This one should work after we did the connect\r
//\r
- Status = gBS->LocateDevicePath (&gEfiSimpleNetworkProtocolGuid, &UpdatedDevicePath, &Handle);\r
+ Status = gBS->LocateDevicePath (&gEfiLoadFileProtocolGuid, &UpdatedDevicePath, &Handle);\r
}\r
}\r
\r
if (!EFI_ERROR (Status)) {\r
Status = gBS->HandleProtocol (Handle, &gEfiSimpleNetworkProtocolGuid, (VOID **)&Snp);\r
+ if (EFI_ERROR (Status)) {\r
+ //\r
+ // Failed to open SNP from this handle, try to get SNP from parent handle\r
+ //\r
+ UpdatedDevicePath = DevicePathFromHandle (Handle);\r
+ if (UpdatedDevicePath != NULL) {\r
+ Status = gBS->LocateDevicePath (&gEfiSimpleNetworkProtocolGuid, &UpdatedDevicePath, &Handle);\r
+ if (!EFI_ERROR (Status)) {\r
+ //\r
+ // SNP handle found, get SNP from it\r
+ //\r
+ Status = gBS->HandleProtocol (Handle, &gEfiSimpleNetworkProtocolGuid, (VOID **) &Snp);\r
+ }\r
+ }\r
+ }\r
+\r
if (!EFI_ERROR (Status)) {\r
if (Snp->Mode->MediaPresentSupported) {\r
if (Snp->Mode->State == EfiSimpleNetworkInitialized) {\r
+ //\r
+ // Invoke Snp->GetStatus() to refresh the media status\r
+ //\r
+ Snp->GetStatus (Snp, &InterruptStatus, NULL);\r
+\r
//\r
// In case some one else is using the SNP check to see if it's connected\r
//\r
\r
@param DevicePath The bootable device Path to check\r
\r
- @retval BDS_EFI_MEDIA_HD_BOOT If given device path contains MEDIA_DEVICE_PATH type device path node \r
+ @retval BDS_EFI_MEDIA_HD_BOOT If given device path contains MEDIA_DEVICE_PATH type device path node\r
which subtype is MEDIA_HARDDRIVE_DP\r
@retval BDS_EFI_MEDIA_CDROM_BOOT If given device path contains MEDIA_DEVICE_PATH type device path node\r
which subtype is MEDIA_CDROM_DP\r
@retval BDS_EFI_MESSAGE_MISC_BOOT If the device path not contains any media device path node, and\r
its last device path node point to a message device path node.\r
@retval BDS_LEGACY_BBS_BOOT If given device path contains BBS_DEVICE_PATH type device path node.\r
- @retval BDS_EFI_UNSUPPORT An EFI Removable BlockIO device path not point to a media and message device, \r
+ @retval BDS_EFI_UNSUPPORT An EFI Removable BlockIO device path not point to a media and message device,\r
\r
**/\r
UINT32\r
ACPI_HID_DEVICE_PATH *Acpi;\r
EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;\r
EFI_DEVICE_PATH_PROTOCOL *LastDeviceNode;\r
-\r
+ UINT32 BootType;\r
\r
if (NULL == DevicePath) {\r
return BDS_EFI_UNSUPPORT;\r
return BDS_EFI_MEDIA_HD_BOOT;\r
} else if (DevicePathSubType (TempDevicePath) == MEDIA_CDROM_DP) {\r
return BDS_EFI_MEDIA_CDROM_BOOT;\r
- } \r
+ }\r
break;\r
case ACPI_DEVICE_PATH:\r
Acpi = (ACPI_HID_DEVICE_PATH *) TempDevicePath;\r
if (DevicePathSubType(LastDeviceNode) == MSG_DEVICE_LOGICAL_UNIT_DP) {\r
//\r
// if the next node type is Device Logical Unit, which specify the Logical Unit Number (LUN),\r
- // skit it\r
+ // skip it\r
//\r
LastDeviceNode = NextDevicePathNode (LastDeviceNode);\r
}\r
// if the device path not only point to driver device, it is not a messaging device path,\r
//\r
if (!IsDevicePathEndType (LastDeviceNode)) {\r
- break; \r
+ break;\r
}\r
\r
- if (DevicePathSubType(TempDevicePath) == MSG_ATAPI_DP) {\r
- return BDS_EFI_MESSAGE_ATAPI_BOOT;\r
- } else if (DevicePathSubType(TempDevicePath) == MSG_USB_DP) {\r
- return BDS_EFI_MESSAGE_USB_DEVICE_BOOT;\r
- } else if (DevicePathSubType(TempDevicePath) == MSG_SCSI_DP) {\r
- return BDS_EFI_MESSAGE_SCSI_BOOT;\r
- } else if (DevicePathSubType(TempDevicePath) == MSG_SATA_DP) {\r
- return BDS_EFI_MESSAGE_SATA_BOOT;\r
- } else if (DevicePathSubType(TempDevicePath) == MSG_MAC_ADDR_DP) {\r
- return BDS_EFI_MESSAGE_MAC_BOOT;\r
+ switch (DevicePathSubType (TempDevicePath)) {\r
+ case MSG_ATAPI_DP:\r
+ BootType = BDS_EFI_MESSAGE_ATAPI_BOOT;\r
+ break;\r
+\r
+ case MSG_USB_DP:\r
+ BootType = BDS_EFI_MESSAGE_USB_DEVICE_BOOT;\r
+ break;\r
+\r
+ case MSG_SCSI_DP:\r
+ BootType = BDS_EFI_MESSAGE_SCSI_BOOT;\r
+ break;\r
+\r
+ case MSG_SATA_DP:\r
+ BootType = BDS_EFI_MESSAGE_SATA_BOOT;\r
+ break;\r
+\r
+ case MSG_MAC_ADDR_DP:\r
+ case MSG_VLAN_DP:\r
+ case MSG_IPv4_DP:\r
+ case MSG_IPv6_DP:\r
+ BootType = BDS_EFI_MESSAGE_MAC_BOOT;\r
+ break;\r
+\r
+ default:\r
+ BootType = BDS_EFI_MESSAGE_MISC_BOOT;\r
+ break;\r
}\r
- return BDS_EFI_MESSAGE_MISC_BOOT;\r
+ return BootType;\r
+\r
default:\r
break;\r
}\r
\r
TempDevicePath = DevPath;\r
LastDeviceNode = DevPath;\r
- \r
+\r
//\r
- // Check if it's a valid boot option for network boot device\r
- // Only check if there is SimpleNetworkProtocol installed. If yes, that means\r
- // there is the network card there.\r
+ // Check if it's a valid boot option for network boot device.\r
+ // Check if there is EfiLoadFileProtocol installed. \r
+ // If yes, that means there is a boot option for network.\r
//\r
Status = gBS->LocateDevicePath (\r
- &gEfiSimpleNetworkProtocolGuid,\r
+ &gEfiLoadFileProtocolGuid,\r
&TempDevicePath,\r
&Handle\r
);\r
TempDevicePath = DevPath;\r
BdsLibConnectDevicePath (TempDevicePath);\r
Status = gBS->LocateDevicePath (\r
- &gEfiSimpleNetworkProtocolGuid,\r
+ &gEfiLoadFileProtocolGuid,\r
&TempDevicePath,\r
&Handle\r
);\r
}\r
- \r
+\r
if (!EFI_ERROR (Status)) {\r
+ if (!IsDevicePathEnd (TempDevicePath)) {\r
+ //\r
+ // LoadFile protocol is not installed on handle with exactly the same DevPath\r
+ //\r
+ return FALSE;\r
+ }\r
+\r
if (CheckMedia) {\r
//\r
// Test if it is ready to boot now\r
}\r
} else {\r
return TRUE;\r
- }\r
+ } \r
}\r
\r
//\r
// and assume it is ready to boot now\r
//\r
while (!IsDevicePathEnd (TempDevicePath)) {\r
- LastDeviceNode = TempDevicePath;\r
- TempDevicePath = NextDevicePathNode (TempDevicePath);\r
+ //\r
+ // If there is USB Class or USB WWID device path node, treat it as valid EFI\r
+ // Boot Option. BdsExpandUsbShortFormDevicePath () will be used to expand it\r
+ // to full device path.\r
+ //\r
+ if ((DevicePathType (TempDevicePath) == MESSAGING_DEVICE_PATH) &&\r
+ ((DevicePathSubType (TempDevicePath) == MSG_USB_CLASS_DP) ||\r
+ (DevicePathSubType (TempDevicePath) == MSG_USB_WWID_DP))) {\r
+ return TRUE;\r
+ }\r
+\r
+ LastDeviceNode = TempDevicePath;\r
+ TempDevicePath = NextDevicePathNode (TempDevicePath);\r
}\r
if ((DevicePathType (LastDeviceNode) == MEDIA_DEVICE_PATH) &&\r
(DevicePathSubType (LastDeviceNode) == MEDIA_FILEPATH_DP)) {\r
}\r
\r
//\r
- // Check if it's a valid boot option for internal Shell\r
+ // Check if it's a valid boot option for internal FV application\r
//\r
if (EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) LastDeviceNode) != NULL) {\r
//\r
- // If the boot option point to Internal FV shell, make sure it is valid\r
+ // If the boot option point to internal FV application, make sure it is valid\r
//\r
- TempDevicePath = DevPath; \r
- Status = BdsLibUpdateFvFileDevicePath (&TempDevicePath, PcdGetPtr(PcdShellFile));\r
+ TempDevicePath = DevPath;\r
+ Status = BdsLibUpdateFvFileDevicePath (\r
+ &TempDevicePath,\r
+ EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) LastDeviceNode)\r
+ );\r
if (Status == EFI_ALREADY_STARTED) {\r
return TRUE;\r
} else {\r
if (Status == EFI_SUCCESS) {\r
- FreePool (TempDevicePath); \r
+ FreePool (TempDevicePath);\r
}\r
return FALSE;\r
}\r
}\r
- \r
+\r
//\r
// If the boot option point to a blockIO device:\r
// if it is a removable blockIo device, it is valid.\r
- // if it is a fixed blockIo device, check its description confliction. \r
+ // if it is a fixed blockIo device, check its description confliction.\r
//\r
TempDevicePath = DevPath;\r
Status = gBS->LocateDevicePath (&gEfiBlockIoProtocolGuid, &TempDevicePath, &Handle);\r
Status = gBS->LocateDevicePath (&gEfiBlockIoProtocolGuid, &TempDevicePath, &Handle);\r
}\r
}\r
- \r
+\r
if (!EFI_ERROR (Status)) {\r
Status = gBS->HandleProtocol (Handle, &gEfiBlockIoProtocolGuid, (VOID **)&BlockIo);\r
if (!EFI_ERROR (Status)) {\r
if (FileGuid == NULL) {\r
return EFI_INVALID_PARAMETER;\r
}\r
- \r
+\r
//\r
// Check whether the device path point to the default the input Fv file\r
//\r
FindFvFile = FALSE;\r
FoundFvHandle = NULL;\r
Status = gBS->HandleProtocol (\r
- mBdsImageHandle,\r
+ gImageHandle,\r
&gEfiLoadedImageProtocolGuid,\r
(VOID **) &LoadedImage\r
);\r
}\r
\r
if (FvHandleBuffer != NULL) {\r
- FreePool (FvHandleBuffer); \r
+ FreePool (FvHandleBuffer);\r
}\r
}\r
\r
projects / mirror_edk2.git / blobdiff