/**
Connect a device path following the platforms EFI Boot Manager policy.
The ConnectDevicePath() function allows the caller to connect a DevicePath using the
same policy as the EFI Boot Manger.
@param[in] This A pointer to the EFI_BOOT_MANAGER_POLICY_PROTOCOL instance.
@param[in] DevicePath Points to the start of the EFI device path to connect.
If DevicePath is NULL then all the controllers in the
system will be connected using the platforms EFI Boot
Manager policy.
@param[in] Recursive If TRUE, then ConnectController() is called recursively
until the entire tree of controllers below the
controller specified by DevicePath have been created.
If FALSE, then the tree of controllers is only expanded
one level. If DevicePath is NULL then Recursive is ignored.
@retval EFI_SUCCESS The DevicePath was connected.
@retval EFI_NOT_FOUND The DevicePath was not found.
@retval EFI_NOT_FOUND No driver was connected to DevicePath.
@retval EFI_SECURITY_VIOLATION The user has no permission to start UEFI device
drivers on the DevicePath.
@retval EFI_UNSUPPORTED The current TPL is not TPL_APPLICATION.
**/
EFI_STATUS
EFIAPI
BootManagerPolicyConnectDevicePath (
IN EFI_BOOT_MANAGER_POLICY_PROTOCOL *This,
IN EFI_DEVICE_PATH *DevicePath,
IN BOOLEAN Recursive
)
{
EFI_STATUS Status;
EFI_HANDLE Controller;
if (EfiGetCurrentTpl () != TPL_APPLICATION) {
return EFI_UNSUPPORTED;
}
if (DevicePath == NULL) {
EfiBootManagerConnectAll ();
return EFI_SUCCESS;
}
if (Recursive) {
Status = EfiBootManagerConnectDevicePath (DevicePath, NULL);
} else {
Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &DevicePath, &Controller);
if (!EFI_ERROR (Status)) {
Status = gBS->ConnectController (Controller, NULL, DevicePath, FALSE);
}
}
return Status;
}
VOID
ConnectSequence (
VOID
)
/*++
Routine Description:
Connect with predeined platform connect sequence,
the OEM/IBV can customize with their own connect sequence.
Arguments:
None.
Returns:
None.
--*/
{
UINTN Index;
//
// Here we can get the customized platform connect sequence
// Notes: we can connect with new variable which record the
// last time boots connect device path sequence
//
for (Index = 0; gPlatformConnectSequence[Index] != NULL; Index++) {
//
// Build the platform boot option
//
EfiBootManagerConnectDevicePath (gPlatformConnectSequence[Index], NULL);
}
//
// For the debug tip, just use the simple policy to connect all devices
//
EfiBootManagerConnectAll ();
}
/**
Connect the network devices.
@retval EFI_SUCCESS At least one network device was connected.
@retval EFI_DEVICE_ERROR Network devices were not connected due to an error.
**/
EFI_STATUS
ConnectNetwork (
VOID
)
{
EFI_STATUS Status;
BOOLEAN OneConnected;
EFI_DEVICE_PATH_PROTOCOL *Devices;
EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
EFI_DEVICE_PATH_PROTOCOL *SingleDevice;
UINTN Size;
OneConnected = FALSE;
GetVariable2 (mNetworkDeviceList, &gEfiCallerIdGuid, (VOID **) &Devices, NULL);
TempDevicePath = Devices;
while (TempDevicePath != NULL) {
SingleDevice = GetNextDevicePathInstance (&TempDevicePath, &Size);
Status = EfiBootManagerConnectDevicePath (SingleDevice, NULL);
if (!EFI_ERROR (Status)) {
OneConnected = TRUE;
}
FreePool (SingleDevice);
}
if (Devices != NULL) {
FreePool (Devices);
}
if (OneConnected) {
return EFI_SUCCESS;
} else {
//
// Cached network devices list doesn't exist or is NOT valid.
//
return ConnectAllAndCreateNetworkDeviceList ();
}
}
/**
Connect the console device base on the variable ConsoleType.
@param ConsoleType ConIn, ConOut or ErrOut.
@retval EFI_NOT_FOUND There is not any console devices connected
success
@retval EFI_SUCCESS Success connect any one instance of the console
device path base on the variable ConVarName.
**/
EFI_STATUS
EFIAPI
EfiBootManagerConnectConsoleVariable (
IN CONSOLE_TYPE ConsoleType
)
{
EFI_STATUS Status;
EFI_DEVICE_PATH_PROTOCOL *StartDevicePath;
EFI_DEVICE_PATH_PROTOCOL *Instance;
EFI_DEVICE_PATH_PROTOCOL *Next;
EFI_DEVICE_PATH_PROTOCOL *CopyOfDevicePath;
UINTN Size;
BOOLEAN DeviceExist;
EFI_HANDLE Handle;
if ((ConsoleType != ConIn) && (ConsoleType != ConOut) && (ConsoleType != ErrOut)) {
return EFI_INVALID_PARAMETER;
}
Status = EFI_SUCCESS;
DeviceExist = FALSE;
Handle = NULL;
//
// Check if the console variable exist
//
GetEfiGlobalVariable2 (mConVarName[ConsoleType], (VOID **) &StartDevicePath, NULL);
if (StartDevicePath == NULL) {
return EFI_UNSUPPORTED;
}
CopyOfDevicePath = StartDevicePath;
do {
//
// Check every instance of the console variable
//
Instance = GetNextDevicePathInstance (&CopyOfDevicePath, &Size);
if (Instance == NULL) {
FreePool (StartDevicePath);
return EFI_UNSUPPORTED;
}
Next = Instance;
while (!IsDevicePathEndType (Next)) {
Next = NextDevicePathNode (Next);
}
SetDevicePathEndNode (Next);
//
// Connect the USB console
// USB console device path is a short-form device path that
// starts with the first element being a USB WWID
// or a USB Class device path
//
if ((DevicePathType (Instance) == MESSAGING_DEVICE_PATH) &&
((DevicePathSubType (Instance) == MSG_USB_CLASS_DP) || (DevicePathSubType (Instance) == MSG_USB_WWID_DP))
) {
Status = BmConnectUsbShortFormDevicePath (Instance);
if (!EFI_ERROR (Status)) {
DeviceExist = TRUE;
}
} else {
for (Next = Instance; !IsDevicePathEnd (Next); Next = NextDevicePathNode (Next)) {
if (DevicePathType (Next) == ACPI_DEVICE_PATH && DevicePathSubType (Next) == ACPI_ADR_DP) {
break;
} else if (DevicePathType (Next) == HARDWARE_DEVICE_PATH &&
DevicePathSubType (Next) == HW_CONTROLLER_DP &&
DevicePathType (NextDevicePathNode (Next)) == ACPI_DEVICE_PATH &&
DevicePathSubType (NextDevicePathNode (Next)) == ACPI_ADR_DP
) {
break;
}
}
if (!IsDevicePathEnd (Next)) {
//
// For GOP device path, start the video driver with NULL remaining device path
//
SetDevicePathEndNode (Next);
Status = EfiBootManagerConnectDevicePath (Instance, &Handle);
if (!EFI_ERROR (Status)) {
gBS->ConnectController (Handle, NULL, NULL, TRUE);
}
} else {
Status = EfiBootManagerConnectDevicePath (Instance, NULL);
}
if (EFI_ERROR (Status)) {
//
// Delete the instance from the console varialbe
//
EfiBootManagerUpdateConsoleVariable (ConsoleType, NULL, Instance);
} else {
DeviceExist = TRUE;
}
}
FreePool(Instance);
} while (CopyOfDevicePath != NULL);
FreePool (StartDevicePath);
if (!DeviceExist) {
return EFI_NOT_FOUND;
}
return EFI_SUCCESS;
}
