/** This CALLBACK_FUNCTION retrieves the EFI_DEVICE_PATH_PROTOCOL from the handle, and adds it to ConOut and ErrOut. **/ STATIC VOID EFIAPI AddOutput ( IN EFI_HANDLE Handle, IN CONST CHAR16 *ReportText ) { EFI_STATUS Status; EFI_DEVICE_PATH_PROTOCOL *DevicePath; DevicePath = DevicePathFromHandle (Handle); if (DevicePath == NULL) { DEBUG ((EFI_D_ERROR, "%a: %s: handle %p: device path not found\n", __FUNCTION__, ReportText, Handle)); return; } Status = BdsLibUpdateConsoleVariable (L"ConOut", DevicePath, NULL); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "%a: %s: adding to ConOut: %r\n", __FUNCTION__, ReportText, Status)); return; } Status = BdsLibUpdateConsoleVariable (L"ErrOut", DevicePath, NULL); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "%a: %s: adding to ErrOut: %r\n", __FUNCTION__, ReportText, Status)); return; } DEBUG ((EFI_D_VERBOSE, "%a: %s: added to ConOut and ErrOut\n", __FUNCTION__, ReportText)); }
EFI_STATUS PreparePciSerialDevicePath ( IN EFI_HANDLE DeviceHandle ) /*++ Routine Description: Add PCI Serial to ConOut, ConIn, ErrOut. PCI Serial: 07 00 02 Arguments: DeviceHandle - Handle of PCIIO protocol. Returns: EFI_SUCCESS - PCI Serial is added to ConOut, ConIn, and ErrOut. EFI_STATUS - No PCI Serial device is added. --*/ { EFI_STATUS Status; EFI_DEVICE_PATH_PROTOCOL *DevicePath; DevicePath = NULL; Status = gBS->HandleProtocol ( DeviceHandle, &gEfiDevicePathProtocolGuid, (VOID*)&DevicePath ); if (EFI_ERROR (Status)) { return Status; } DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gUartDeviceNode); DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gTerminalTypeDeviceNode); BdsLibUpdateConsoleVariable (VarConsoleOut, DevicePath, NULL); BdsLibUpdateConsoleVariable (VarConsoleInp, DevicePath, NULL); BdsLibUpdateConsoleVariable (VarErrorOut, DevicePath, NULL); return EFI_SUCCESS; }
EFI_STATUS PreparePciVgaDevicePath ( IN EFI_HANDLE DeviceHandle ) /*++ Routine Description: Add PCI VGA to ConOut. PCI VGA: 03 00 00 Arguments: DeviceHandle - Handle of PCIIO protocol. Returns: EFI_SUCCESS - PCI VGA is added to ConOut. EFI_STATUS - No PCI VGA device is added. --*/ { EFI_STATUS Status; EFI_DEVICE_PATH_PROTOCOL *DevicePath; EFI_DEVICE_PATH_PROTOCOL *GopDevicePath; DevicePath = NULL; GopDevicePath = NULL; Status = gBS->HandleProtocol ( DeviceHandle, &gEfiDevicePathProtocolGuid, (VOID*)&DevicePath ); if (EFI_ERROR (Status)) { return Status; } GetGopDevicePath (DevicePath, &GopDevicePath); DevicePath = GopDevicePath; BdsLibUpdateConsoleVariable (VarConsoleOut, DevicePath, NULL); return EFI_SUCCESS; }
EFI_STATUS PlatformBdsConnectConsole ( IN BDS_CONSOLE_CONNECT_ENTRY *PlatformConsole ) /*++ Routine Description: Connect the predefined platform default console device. Always try to find and enable the vga device if have. Arguments: PlatformConsole - Predfined platform default console device array. Returns: EFI_SUCCESS - Success connect at least one ConIn and ConOut device, there must have one ConOut device is active vga device. EFI_STATUS - Return the status of BdsLibConnectAllDefaultConsoles () --*/ { EFI_STATUS Status; UINTN Index; EFI_DEVICE_PATH_PROTOCOL *VarConout; EFI_DEVICE_PATH_PROTOCOL *VarConin; UINTN DevicePathSize; // // Connect RootBridge // VarConout = BdsLibGetVariableAndSize ( VarConsoleOut, &gEfiGlobalVariableGuid, &DevicePathSize ); VarConin = BdsLibGetVariableAndSize ( VarConsoleInp, &gEfiGlobalVariableGuid, &DevicePathSize ); if (VarConout == NULL || VarConin == NULL) { // // Do platform specific PCI Device check and add them to ConOut, ConIn, ErrOut // DetectAndPreparePlatformPciDevicePaths (FALSE); // // Have chance to connect the platform default console, // the platform default console is the minimue device group // the platform should support // for (Index = 0; PlatformConsole[Index].DevicePath != NULL; ++Index) { // // Update the console variable with the connect type // if ((PlatformConsole[Index].ConnectType & CONSOLE_IN) == CONSOLE_IN) { BdsLibUpdateConsoleVariable (VarConsoleInp, PlatformConsole[Index].DevicePath, NULL); } if ((PlatformConsole[Index].ConnectType & CONSOLE_OUT) == CONSOLE_OUT) { BdsLibUpdateConsoleVariable (VarConsoleOut, PlatformConsole[Index].DevicePath, NULL); } if ((PlatformConsole[Index].ConnectType & STD_ERROR) == STD_ERROR) { BdsLibUpdateConsoleVariable (VarErrorOut, PlatformConsole[Index].DevicePath, NULL); } } } else { // // Only detect VGA device and add them to ConOut // DetectAndPreparePlatformPciDevicePaths (TRUE); } // // Connect the all the default console with current cosole variable // Status = BdsLibConnectAllDefaultConsoles (); if (EFI_ERROR (Status)) { return Status; } return EFI_SUCCESS; }
EFI_STATUS GetGopDevicePath ( IN EFI_DEVICE_PATH_PROTOCOL *PciDevicePath, OUT EFI_DEVICE_PATH_PROTOCOL **GopDevicePath ) { UINTN Index; EFI_STATUS Status; EFI_HANDLE PciDeviceHandle; EFI_DEVICE_PATH_PROTOCOL *TempDevicePath; EFI_DEVICE_PATH_PROTOCOL *TempPciDevicePath; UINTN GopHandleCount; EFI_HANDLE *GopHandleBuffer; if (PciDevicePath == NULL || GopDevicePath == NULL) { return EFI_INVALID_PARAMETER; } // // Initialize the GopDevicePath to be PciDevicePath // *GopDevicePath = PciDevicePath; TempPciDevicePath = PciDevicePath; Status = gBS->LocateDevicePath ( &gEfiDevicePathProtocolGuid, &TempPciDevicePath, &PciDeviceHandle ); if (EFI_ERROR (Status)) { return Status; } // // Try to connect this handle, so that GOP dirver could start on this // device and create child handles with GraphicsOutput Protocol installed // on them, then we get device paths of these child handles and select // them as possible console device. // gBS->ConnectController (PciDeviceHandle, NULL, NULL, FALSE); Status = gBS->LocateHandleBuffer ( ByProtocol, &gEfiGraphicsOutputProtocolGuid, NULL, &GopHandleCount, &GopHandleBuffer ); if (!EFI_ERROR (Status)) { // // Add all the child handles as possible Console Device // for (Index = 0; Index < GopHandleCount; Index++) { Status = gBS->HandleProtocol (GopHandleBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID*)&TempDevicePath); if (EFI_ERROR (Status)) { continue; } if (CompareMem ( PciDevicePath, TempDevicePath, GetDevicePathSize (PciDevicePath) - END_DEVICE_PATH_LENGTH ) == 0) { // // In current implementation, we only enable one of the child handles // as console device, i.e. sotre one of the child handle's device // path to variable "ConOut" // In futhure, we could select all child handles to be console device // *GopDevicePath = TempDevicePath; // // Delete the PCI device's path that added by GetPlugInPciVgaDevicePath() // Add the integrity GOP device path. // BdsLibUpdateConsoleVariable (VarConsoleOutDev, NULL, PciDevicePath); BdsLibUpdateConsoleVariable (VarConsoleOutDev, TempDevicePath, NULL); } } gBS->FreePool (GopHandleBuffer); } return EFI_SUCCESS; }
EFI_STATUS PrepareLpcBridgeDevicePath ( IN EFI_HANDLE DeviceHandle ) /*++ Routine Description: Add IsaKeyboard to ConIn, add IsaSerial to ConOut, ConIn, ErrOut. LPC Bridge: 06 01 00 Arguments: DeviceHandle - Handle of PCIIO protocol. Returns: EFI_SUCCESS - LPC bridge is added to ConOut, ConIn, and ErrOut. EFI_STATUS - No LPC bridge is added. --*/ { EFI_STATUS Status; EFI_DEVICE_PATH_PROTOCOL *DevicePath; EFI_DEVICE_PATH_PROTOCOL *TempDevicePath; CHAR16 *DevPathStr; DevicePath = NULL; Status = gBS->HandleProtocol ( DeviceHandle, &gEfiDevicePathProtocolGuid, (VOID*)&DevicePath ); if (EFI_ERROR (Status)) { return Status; } TempDevicePath = DevicePath; // // Register Keyboard // DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gPnpPs2KeyboardDeviceNode); BdsLibUpdateConsoleVariable (VarConsoleInp, DevicePath, NULL); // // Register COM1 // DevicePath = TempDevicePath; gPnp16550ComPortDeviceNode.UID = 0; DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gPnp16550ComPortDeviceNode); DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gUartDeviceNode); DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gTerminalTypeDeviceNode); // // Print Device Path // DevPathStr = DevicePathToStr(DevicePath); if (DevPathStr != NULL) { DEBUG(( EFI_D_INFO, "BdsPlatform.c+%d: COM%d DevPath: %s\n", __LINE__, gPnp16550ComPortDeviceNode.UID + 1, DevPathStr )); FreePool(DevPathStr); } BdsLibUpdateConsoleVariable (VarConsoleOut, DevicePath, NULL); BdsLibUpdateConsoleVariable (VarConsoleInp, DevicePath, NULL); BdsLibUpdateConsoleVariable (VarErrorOut, DevicePath, NULL); // // Register COM2 // DevicePath = TempDevicePath; gPnp16550ComPortDeviceNode.UID = 1; DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gPnp16550ComPortDeviceNode); DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gUartDeviceNode); DevicePath = AppendDevicePathNode (DevicePath, (EFI_DEVICE_PATH_PROTOCOL *)&gTerminalTypeDeviceNode); // // Print Device Path // DevPathStr = DevicePathToStr(DevicePath); if (DevPathStr != NULL) { DEBUG(( EFI_D_INFO, "BdsPlatform.c+%d: COM%d DevPath: %s\n", __LINE__, gPnp16550ComPortDeviceNode.UID + 1, DevPathStr )); FreePool(DevPathStr); } BdsLibUpdateConsoleVariable (VarConsoleOut, DevicePath, NULL); BdsLibUpdateConsoleVariable (VarConsoleInp, DevicePath, NULL); BdsLibUpdateConsoleVariable (VarErrorOut, DevicePath, NULL); return EFI_SUCCESS; }
/** The function will execute with as the platform policy, current policy is driven by boot mode. IBV/OEM can customize this code for their specific policy action. @param DriverOptionList The header of the driver option link list @param BootOptionList The header of the boot option link list @param ProcessCapsules A pointer to ProcessCapsules() @param BaseMemoryTest A pointer to BaseMemoryTest() **/ VOID EFIAPI PlatformBdsPolicyBehavior ( IN LIST_ENTRY *DriverOptionList, IN LIST_ENTRY *BootOptionList, IN PROCESS_CAPSULES ProcessCapsules, IN BASEM_MEMORY_TEST BaseMemoryTest ) { // // Locate the PCI root bridges and make the PCI bus driver connect each, // non-recursively. This will produce a number of child handles with PciIo on // them. // FilterAndProcess (&gEfiPciRootBridgeIoProtocolGuid, NULL, Connect); // // Find all display class PCI devices (using the handles from the previous // step), and connect them non-recursively. This should produce a number of // child handles with GOPs on them. // FilterAndProcess (&gEfiPciIoProtocolGuid, IsPciDisplay, Connect); // // Now add the device path of all handles with GOP on them to ConOut and // ErrOut. // FilterAndProcess (&gEfiGraphicsOutputProtocolGuid, NULL, AddOutput); // // Add the hardcoded short-form USB keyboard device path to ConIn. // BdsLibUpdateConsoleVariable (L"ConIn", (EFI_DEVICE_PATH_PROTOCOL *)&mUsbKeyboard, NULL); // // Add the hardcoded serial console device path to ConIn, ConOut, ErrOut. // BdsLibUpdateConsoleVariable (L"ConIn", (EFI_DEVICE_PATH_PROTOCOL *)&mSerialConsole, NULL); BdsLibUpdateConsoleVariable (L"ConOut", (EFI_DEVICE_PATH_PROTOCOL *)&mSerialConsole, NULL); BdsLibUpdateConsoleVariable (L"ErrOut", (EFI_DEVICE_PATH_PROTOCOL *)&mSerialConsole, NULL); // // Connect the consoles based on the above variables. // BdsLibConnectAllDefaultConsoles (); // // Show the splash screen. // EnableQuietBoot (PcdGetPtr (PcdLogoFile)); // // Connect the rest of the devices. // BdsLibConnectAll (); // // Process QEMU's -kernel command line option. Note that the kernel booted // this way should receive ACPI tables, which is why we connect all devices // first (see above) -- PCI enumeration blocks ACPI table installation, if // there is a PCI host. // TryRunningQemuKernel (); BdsLibEnumerateAllBootOption (BootOptionList); SetBootOrderFromQemu (BootOptionList); // // The BootOrder variable may have changed, reload the in-memory list with // it. // BdsLibBuildOptionFromVar (BootOptionList, L"BootOrder"); PlatformBdsEnterFrontPage (GetFrontPageTimeoutFromQemu(), TRUE); }
/** This function will search every simpletext device in current system, and make every simpletext device as pertantial console device. **/ VOID EFIAPI BdsLibConnectAllConsoles ( VOID ) { UINTN Index; EFI_DEVICE_PATH_PROTOCOL *ConDevicePath; UINTN HandleCount; EFI_HANDLE *HandleBuffer; Index = 0; HandleCount = 0; HandleBuffer = NULL; ConDevicePath = NULL; // // Update all the console variables // gBS->LocateHandleBuffer ( ByProtocol, &gEfiSimpleTextInProtocolGuid, NULL, &HandleCount, &HandleBuffer ); for (Index = 0; Index < HandleCount; Index++) { gBS->HandleProtocol ( HandleBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID **) &ConDevicePath ); BdsLibUpdateConsoleVariable (L"ConIn", ConDevicePath, NULL); } if (HandleBuffer != NULL) { FreePool(HandleBuffer); HandleBuffer = NULL; } gBS->LocateHandleBuffer ( ByProtocol, &gEfiSimpleTextOutProtocolGuid, NULL, &HandleCount, &HandleBuffer ); for (Index = 0; Index < HandleCount; Index++) { gBS->HandleProtocol ( HandleBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID **) &ConDevicePath ); BdsLibUpdateConsoleVariable (L"ConOut", ConDevicePath, NULL); BdsLibUpdateConsoleVariable (L"ErrOut", ConDevicePath, NULL); } if (HandleBuffer != NULL) { FreePool(HandleBuffer); } // // Connect all console variables // BdsLibConnectAllDefaultConsoles (); }
/** Connect the console device base on the variable ConVarName, if device path of the ConVarName is multi-instance device path and anyone of the instances is connected success, then this function will return success. If the handle associate with one device path node can not be created successfully, then still give chance to do the dispatch, which load the missing drivers if possible.. @param ConVarName Console related variable name, ConIn, ConOut, 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 BdsLibConnectConsoleVariable ( IN CHAR16 *ConVarName ) { EFI_STATUS Status; EFI_DEVICE_PATH_PROTOCOL *StartDevicePath; UINTN VariableSize; EFI_DEVICE_PATH_PROTOCOL *Instance; EFI_DEVICE_PATH_PROTOCOL *Next; EFI_DEVICE_PATH_PROTOCOL *CopyOfDevicePath; UINTN Size; BOOLEAN DeviceExist; Status = EFI_SUCCESS; DeviceExist = FALSE; // // Check if the console variable exist // StartDevicePath = BdsLibGetVariableAndSize ( ConVarName, &gEfiGlobalVariableGuid, &VariableSize ); 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 = BdsLibConnectUsbDevByShortFormDP (0xFF, Instance); if (!EFI_ERROR (Status)) { DeviceExist = TRUE; } } else { // // Connect the instance device path // Status = BdsLibConnectDevicePath (Instance); if (EFI_ERROR (Status)) { // // Delete the instance from the console varialbe // BdsLibUpdateConsoleVariable (ConVarName, NULL, Instance); } else { DeviceExist = TRUE; } } FreePool(Instance); } while (CopyOfDevicePath != NULL); FreePool (StartDevicePath); if (!DeviceExist) { return EFI_NOT_FOUND; } return EFI_SUCCESS; }
/** Connect the predefined platform default console device. Always try to find and enable the vga device if have. @param PlatformConsole Predefined platform default console device array. @retval EFI_SUCCESS Success connect at least one ConIn and ConOut device, there must have one ConOut device is active vga device. @return Return the status of BdsLibConnectAllDefaultConsoles () **/ EFI_STATUS PlatformBdsConnectConsole ( IN BDS_CONSOLE_CONNECT_ENTRY *PlatformConsole ) { EFI_STATUS Status; UINTN Index; EFI_DEVICE_PATH_PROTOCOL *VarConout; EFI_DEVICE_PATH_PROTOCOL *VarConin; UINTN DevicePathSize; // // Connect RootBridge // VarConout = BdsLibGetVariableAndSize ( VarConsoleOut, &gEfiGlobalVariableGuid, &DevicePathSize ); VarConin = BdsLibGetVariableAndSize ( VarConsoleInp, &gEfiGlobalVariableGuid, &DevicePathSize ); if (VarConout == NULL || VarConin == NULL) { // // Do platform specific PCI Device check and add them to ConOut, ConIn, ErrOut // DetectAndPreparePlatformPciDevicePaths (FALSE); // // Have chance to connect the platform default console, // the platform default console is the minimue device group // the platform should support // for (Index = 0; PlatformConsole[Index].DevicePath != NULL; ++Index) { // // Update the console variable with the connect type // if ((PlatformConsole[Index].ConnectType & CONSOLE_IN) == CONSOLE_IN) { BdsLibUpdateConsoleVariable (VarConsoleInp, PlatformConsole[Index].DevicePath, NULL); } if ((PlatformConsole[Index].ConnectType & CONSOLE_OUT) == CONSOLE_OUT) { BdsLibUpdateConsoleVariable (VarConsoleOut, PlatformConsole[Index].DevicePath, NULL); } if ((PlatformConsole[Index].ConnectType & STD_ERROR) == STD_ERROR) { BdsLibUpdateConsoleVariable (VarErrorOut, PlatformConsole[Index].DevicePath, NULL); } } } else { // // Only detect VGA device and add them to ConOut // DetectAndPreparePlatformPciDevicePaths (TRUE); } // // Connect the all the default console with current cosole variable // Status = BdsLibConnectAllDefaultConsoles (); if (EFI_ERROR (Status)) { return Status; } return EFI_SUCCESS; }
EFI_STATUS GetGopDevicePath ( IN EFI_DEVICE_PATH_PROTOCOL *PciDevicePath, OUT EFI_DEVICE_PATH_PROTOCOL **GopDevicePath ) { UINTN Index; EFI_STATUS Status; EFI_HANDLE PciDeviceHandle; EFI_DEVICE_PATH_PROTOCOL *TempDevicePath; EFI_DEVICE_PATH_PROTOCOL *TempPciDevicePath; UINTN GopHandleCount; EFI_HANDLE *GopHandleBuffer; if (PciDevicePath == NULL || GopDevicePath == NULL) { return EFI_INVALID_PARAMETER; } // // Initialize the GopDevicePath to be PciDevicePath // *GopDevicePath = PciDevicePath; TempPciDevicePath = PciDevicePath; Status = gBS->LocateDevicePath ( &gEfiDevicePathProtocolGuid, &TempPciDevicePath, &PciDeviceHandle ); if (EFI_ERROR (Status)) { return Status; } // // Try to connect this handle, so that GOP dirver could start on this // device and create child handles with GraphicsOutput Protocol installed // on them, then we get device paths of these child handles and select // them as possible console device. // #if 0 gBS->ConnectController (PciDeviceHandle, NULL, NULL, FALSE); #else { ACPI_ADR_DEVICE_PATH AcpiAdr; EFI_DEVICE_PATH_PROTOCOL *MyDevicePath = NULL; AcpiAdr.Header.Type = ACPI_DEVICE_PATH; AcpiAdr.Header.SubType = ACPI_ADR_DP; //AcpiAdr.ADR= ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA, 6, 0); //on bayleybay, CRT Device AcpiAdr.ADR= ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_INTERNAL_DIGITAL, 8, 0); ; // on rambi, eDP C SetDevicePathNodeLength (&AcpiAdr.Header, sizeof (ACPI_ADR_DEVICE_PATH)); MyDevicePath = AppendDevicePathNode(MyDevicePath, (EFI_DEVICE_PATH_PROTOCOL*)&AcpiAdr); gBS->ConnectController (PciDeviceHandle, NULL, MyDevicePath, FALSE); FreePool(MyDevicePath); } #endif Status = gBS->LocateHandleBuffer ( ByProtocol, &gEfiGraphicsOutputProtocolGuid, NULL, &GopHandleCount, &GopHandleBuffer ); if (!EFI_ERROR (Status)) { // // Add all the child handles as possible Console Device // for (Index = 0; Index < GopHandleCount; Index++) { Status = gBS->HandleProtocol (GopHandleBuffer[Index], &gEfiDevicePathProtocolGuid, (VOID*)&TempDevicePath); if (EFI_ERROR (Status)) { continue; } if (CompareMem ( PciDevicePath, TempDevicePath, GetDevicePathSize (PciDevicePath) - END_DEVICE_PATH_LENGTH ) == 0) { // // In current implementation, we only enable one of the child handles // as console device, i.e. sotre one of the child handle's device // path to variable "ConOut" // In futhure, we could select all child handles to be console device // *GopDevicePath = TempDevicePath; // // Delete the PCI device's path that added by GetPlugInPciVgaDevicePath() // Add the integrity GOP device path. // BdsLibUpdateConsoleVariable (VarConsoleOutDev, NULL, PciDevicePath); BdsLibUpdateConsoleVariable (VarConsoleOutDev, TempDevicePath, NULL); } } gBS->FreePool (GopHandleBuffer); } return EFI_SUCCESS; }