2 This file include all platform action which can be customized by IBV/OEM.
4 Copyright (c) 2014, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 #include "BdsPlatform.h"
20 BOOLEAN mDetectVgaOnly
;
29 (EFIAPI
*PROTOCOL_INSTANCE_CALLBACK
)(
36 @param[in] Handle - Handle of PCI device instance
37 @param[in] PciIo - PCI IO protocol instance
38 @param[in] Pci - PCI Header register block
42 (EFIAPI
*VISIT_PCI_INSTANCE_CALLBACK
)(
44 IN EFI_PCI_IO_PROTOCOL
*PciIo
,
50 // Function prototypes
54 VisitAllInstancesOfProtocol (
56 IN PROTOCOL_INSTANCE_CALLBACK CallBackFunction
,
61 VisitAllPciInstancesOfProtocol (
62 IN VISIT_PCI_INSTANCE_CALLBACK CallBackFunction
67 // BDS Platform Functions
71 Platform Bds init. Include the platform firmware vendor, revision
81 gUartDeviceNode
.BaudRate
= PcdGet64 (PcdUartDefaultBaudRate
);
82 gUartDeviceNode
.DataBits
= PcdGet8 (PcdUartDefaultDataBits
);
83 gUartDeviceNode
.Parity
= PcdGet8 (PcdUartDefaultParity
);
84 gUartDeviceNode
.StopBits
= PcdGet8 (PcdUartDefaultStopBits
);
89 PrepareLpcBridgeDevicePath (
90 IN EFI_HANDLE DeviceHandle
96 Add IsaKeyboard to ConIn,
97 add IsaSerial to ConOut, ConIn, ErrOut.
102 DeviceHandle - Handle of PCIIO protocol.
106 EFI_SUCCESS - LPC bridge is added to ConOut, ConIn, and ErrOut.
107 EFI_STATUS - No LPC bridge is added.
112 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
116 Status
= gBS
->HandleProtocol (
118 &gEfiDevicePathProtocolGuid
,
121 if (EFI_ERROR (Status
)) {
128 DevicePath
= AppendDevicePathNode ((EFI_DEVICE_PATH_PROTOCOL
*)NULL
, (EFI_DEVICE_PATH_PROTOCOL
*)&gUartDeviceVendorNode
);
129 DevicePath
= AppendDevicePathNode (DevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*)&gUartDeviceNode
);
130 DevicePath
= AppendDevicePathNode (DevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*)&gTerminalTypeDeviceNode
);
135 DevPathStr
= DevicePathToStr(DevicePath
);
138 "BdsPlatform.c+%d: COM%d DevPath: %s\n",
140 gPnp16550ComPortDeviceNode
.UID
+ 1,
143 FreePool(DevPathStr
);
145 BdsLibUpdateConsoleVariable (VarConsoleOut
, DevicePath
, NULL
);
146 BdsLibUpdateConsoleVariable (VarConsoleInp
, DevicePath
, NULL
);
147 BdsLibUpdateConsoleVariable (VarErrorOut
, DevicePath
, NULL
);
154 IN EFI_DEVICE_PATH_PROTOCOL
*PciDevicePath
,
155 OUT EFI_DEVICE_PATH_PROTOCOL
**GopDevicePath
160 EFI_HANDLE PciDeviceHandle
;
161 EFI_DEVICE_PATH_PROTOCOL
*TempDevicePath
;
162 EFI_DEVICE_PATH_PROTOCOL
*TempPciDevicePath
;
163 UINTN GopHandleCount
;
164 EFI_HANDLE
*GopHandleBuffer
;
166 if (PciDevicePath
== NULL
|| GopDevicePath
== NULL
) {
167 return EFI_INVALID_PARAMETER
;
171 // Initialize the GopDevicePath to be PciDevicePath
173 *GopDevicePath
= PciDevicePath
;
174 TempPciDevicePath
= PciDevicePath
;
176 Status
= gBS
->LocateDevicePath (
177 &gEfiDevicePathProtocolGuid
,
181 if (EFI_ERROR (Status
)) {
186 // Try to connect this handle, so that GOP dirver could start on this
187 // device and create child handles with GraphicsOutput Protocol installed
188 // on them, then we get device paths of these child handles and select
189 // them as possible console device.
192 gBS
->ConnectController (PciDeviceHandle
, NULL
, NULL
, FALSE
);
195 ACPI_ADR_DEVICE_PATH AcpiAdr
;
196 EFI_DEVICE_PATH_PROTOCOL
*MyDevicePath
= NULL
;
198 AcpiAdr
.Header
.Type
= ACPI_DEVICE_PATH
;
199 AcpiAdr
.Header
.SubType
= ACPI_ADR_DP
;
200 //AcpiAdr.ADR= ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA, 6, 0); //on bayleybay, CRT Device
201 AcpiAdr
.ADR
= ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_INTERNAL_DIGITAL
, 8, 0); ; // on rambi, eDP C
203 SetDevicePathNodeLength (&AcpiAdr
.Header
, sizeof (ACPI_ADR_DEVICE_PATH
));
205 MyDevicePath
= AppendDevicePathNode(MyDevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*)&AcpiAdr
);
207 gBS
->ConnectController (PciDeviceHandle
, NULL
, MyDevicePath
, FALSE
);
209 FreePool(MyDevicePath
);
213 Status
= gBS
->LocateHandleBuffer (
215 &gEfiGraphicsOutputProtocolGuid
,
220 if (!EFI_ERROR (Status
)) {
222 // Add all the child handles as possible Console Device
224 for (Index
= 0; Index
< GopHandleCount
; Index
++) {
225 Status
= gBS
->HandleProtocol (GopHandleBuffer
[Index
], &gEfiDevicePathProtocolGuid
, (VOID
*)&TempDevicePath
);
226 if (EFI_ERROR (Status
)) {
232 GetDevicePathSize (PciDevicePath
) - END_DEVICE_PATH_LENGTH
235 // In current implementation, we only enable one of the child handles
236 // as console device, i.e. sotre one of the child handle's device
237 // path to variable "ConOut"
238 // In futhure, we could select all child handles to be console device
241 *GopDevicePath
= TempDevicePath
;
244 // Delete the PCI device's path that added by GetPlugInPciVgaDevicePath()
245 // Add the integrity GOP device path.
247 BdsLibUpdateConsoleVariable (VarConsoleOutDev
, NULL
, PciDevicePath
);
248 BdsLibUpdateConsoleVariable (VarConsoleOutDev
, TempDevicePath
, NULL
);
251 gBS
->FreePool (GopHandleBuffer
);
258 PreparePciVgaDevicePath (
259 IN EFI_HANDLE DeviceHandle
265 Add PCI VGA to ConOut.
270 DeviceHandle - Handle of PCIIO protocol.
274 EFI_SUCCESS - PCI VGA is added to ConOut.
275 EFI_STATUS - No PCI VGA device is added.
280 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
281 EFI_DEVICE_PATH_PROTOCOL
*GopDevicePath
;
284 Status
= gBS
->HandleProtocol (
286 &gEfiDevicePathProtocolGuid
,
289 if (EFI_ERROR (Status
)) {
293 GetGopDevicePath (DevicePath
, &GopDevicePath
);
294 DevicePath
= GopDevicePath
;
296 BdsLibUpdateConsoleVariable (VarConsoleOut
, DevicePath
, NULL
);
302 PreparePciSerialDevicePath (
303 IN EFI_HANDLE DeviceHandle
309 Add PCI Serial to ConOut, ConIn, ErrOut.
314 DeviceHandle - Handle of PCIIO protocol.
318 EFI_SUCCESS - PCI Serial is added to ConOut, ConIn, and ErrOut.
319 EFI_STATUS - No PCI Serial device is added.
324 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
327 Status
= gBS
->HandleProtocol (
329 &gEfiDevicePathProtocolGuid
,
332 if (EFI_ERROR (Status
)) {
336 DevicePath
= AppendDevicePathNode (DevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*)&gUartDeviceNode
);
337 DevicePath
= AppendDevicePathNode (DevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*)&gTerminalTypeDeviceNode
);
339 BdsLibUpdateConsoleVariable (VarConsoleOut
, DevicePath
, NULL
);
340 BdsLibUpdateConsoleVariable (VarConsoleInp
, DevicePath
, NULL
);
341 BdsLibUpdateConsoleVariable (VarErrorOut
, DevicePath
, NULL
);
347 VisitAllInstancesOfProtocol (
349 IN PROTOCOL_INSTANCE_CALLBACK CallBackFunction
,
355 EFI_HANDLE
*HandleBuffer
;
360 // Start to check all the PciIo to find all possible device
364 Status
= gBS
->LocateHandleBuffer (
371 if (EFI_ERROR (Status
)) {
375 for (Index
= 0; Index
< HandleCount
; Index
++) {
376 Status
= gBS
->HandleProtocol (HandleBuffer
[Index
], Id
, &Instance
);
377 if (EFI_ERROR (Status
)) {
381 Status
= (*CallBackFunction
) (
388 gBS
->FreePool (HandleBuffer
);
396 VisitingAPciInstance (
397 IN EFI_HANDLE Handle
,
403 EFI_PCI_IO_PROTOCOL
*PciIo
;
406 PciIo
= (EFI_PCI_IO_PROTOCOL
*) Instance
;
409 // Check for all PCI device
411 Status
= PciIo
->Pci
.Read (
415 sizeof (Pci
) / sizeof (UINT32
),
418 if (EFI_ERROR (Status
)) {
422 return (*(VISIT_PCI_INSTANCE_CALLBACK
)(UINTN
) Context
) (
433 VisitAllPciInstances (
434 IN VISIT_PCI_INSTANCE_CALLBACK CallBackFunction
437 return VisitAllInstancesOfProtocol (
438 &gEfiPciIoProtocolGuid
,
439 VisitingAPciInstance
,
440 (VOID
*)(UINTN
) CallBackFunction
446 Do platform specific PCI Device check and add them to
447 ConOut, ConIn, ErrOut.
449 @param[in] Handle - Handle of PCI device instance
450 @param[in] PciIo - PCI IO protocol instance
451 @param[in] Pci - PCI Header register block
453 @retval EFI_SUCCESS - PCI Device check and Console variable update successfully.
454 @retval EFI_STATUS - PCI Device check or Console variable update fail.
459 DetectAndPreparePlatformPciDevicePath (
460 IN EFI_HANDLE Handle
,
461 IN EFI_PCI_IO_PROTOCOL
*PciIo
,
467 Status
= PciIo
->Attributes (
469 EfiPciIoAttributeOperationEnable
,
470 EFI_PCI_DEVICE_ENABLE
,
473 ASSERT_EFI_ERROR (Status
);
475 if (!mDetectVgaOnly
) {
477 // Here we decide whether it is LPC Bridge
479 if ((IS_PCI_LPC (Pci
)) ||
480 ((IS_PCI_ISA_PDECODE (Pci
)) &&
481 (Pci
->Hdr
.VendorId
== 0x8086)
485 // Add IsaKeyboard to ConIn,
486 // add IsaSerial to ConOut, ConIn, ErrOut
488 DEBUG ((EFI_D_INFO
, "Found LPC Bridge device\n"));
489 PrepareLpcBridgeDevicePath (Handle
);
493 // Here we decide which Serial device to enable in PCI bus
495 if (IS_PCI_16550SERIAL (Pci
)) {
497 // Add them to ConOut, ConIn, ErrOut.
499 DEBUG ((EFI_D_INFO
, "Found PCI 16550 SERIAL device\n"));
500 PreparePciSerialDevicePath (Handle
);
506 // Here we decide which VGA device to enable in PCI bus
508 if (IS_PCI_VGA (Pci
)) {
510 // Add them to ConOut.
512 DEBUG ((EFI_D_INFO
, "Found PCI VGA device\n"));
513 PreparePciVgaDevicePath (Handle
);
522 Do platform specific PCI Device check and add them to ConOut, ConIn, ErrOut
524 @param[in] DetectVgaOnly - Only detect VGA device if it's TRUE.
526 @retval EFI_SUCCESS - PCI Device check and Console variable update successfully.
527 @retval EFI_STATUS - PCI Device check or Console variable update fail.
531 DetectAndPreparePlatformPciDevicePaths (
532 BOOLEAN DetectVgaOnly
535 mDetectVgaOnly
= DetectVgaOnly
;
536 return VisitAllPciInstances (DetectAndPreparePlatformPciDevicePath
);
540 Connect the predefined platform default console device. Always try to find
541 and enable the vga device if have.
543 @param PlatformConsole Predefined platform default console device array.
545 @retval EFI_SUCCESS Success connect at least one ConIn and ConOut
546 device, there must have one ConOut device is
548 @return Return the status of BdsLibConnectAllDefaultConsoles ()
552 PlatformBdsConnectConsole (
553 IN BDS_CONSOLE_CONNECT_ENTRY
*PlatformConsole
558 EFI_DEVICE_PATH_PROTOCOL
*VarConout
;
559 EFI_DEVICE_PATH_PROTOCOL
*VarConin
;
560 UINTN DevicePathSize
;
563 // Connect RootBridge
565 VarConout
= BdsLibGetVariableAndSize (
567 &gEfiGlobalVariableGuid
,
570 VarConin
= BdsLibGetVariableAndSize (
572 &gEfiGlobalVariableGuid
,
576 if (VarConout
== NULL
|| VarConin
== NULL
) {
578 // Do platform specific PCI Device check and add them to ConOut, ConIn, ErrOut
580 DetectAndPreparePlatformPciDevicePaths (FALSE
);
583 // Have chance to connect the platform default console,
584 // the platform default console is the minimue device group
585 // the platform should support
587 for (Index
= 0; PlatformConsole
[Index
].DevicePath
!= NULL
; ++Index
) {
589 // Update the console variable with the connect type
591 if ((PlatformConsole
[Index
].ConnectType
& CONSOLE_IN
) == CONSOLE_IN
) {
592 BdsLibUpdateConsoleVariable (VarConsoleInp
, PlatformConsole
[Index
].DevicePath
, NULL
);
594 if ((PlatformConsole
[Index
].ConnectType
& CONSOLE_OUT
) == CONSOLE_OUT
) {
595 BdsLibUpdateConsoleVariable (VarConsoleOut
, PlatformConsole
[Index
].DevicePath
, NULL
);
597 if ((PlatformConsole
[Index
].ConnectType
& STD_ERROR
) == STD_ERROR
) {
598 BdsLibUpdateConsoleVariable (VarErrorOut
, PlatformConsole
[Index
].DevicePath
, NULL
);
603 // Only detect VGA device and add them to ConOut
605 DetectAndPreparePlatformPciDevicePaths (TRUE
);
609 // Connect the all the default console with current cosole variable
611 Status
= BdsLibConnectAllDefaultConsoles ();
612 if (EFI_ERROR (Status
)) {
620 Connect with predefined platform connect sequence,
621 the OEM/IBV can customize with their own connect sequence.
624 PlatformBdsConnectSequence (
630 DEBUG ((EFI_D_INFO
, "PlatformBdsConnectSequence\n"));
634 // Here we can get the customized platform connect sequence
635 // Notes: we can connect with new variable which record the
636 // last time boots connect device path sequence
638 while (gPlatformConnectSequence
[Index
] != NULL
) {
640 // Build the platform boot option
642 BdsLibConnectDevicePath (gPlatformConnectSequence
[Index
]);
648 Load the predefined driver option, OEM/IBV can customize this
649 to load their own drivers
651 @param BdsDriverLists - The header of the driver option link list.
655 PlatformBdsGetDriverOption (
656 IN OUT LIST_ENTRY
*BdsDriverLists
663 DEBUG ((EFI_D_INFO
, "PlatformBdsGetDriverOption\n"));
667 // Here we can get the customized platform driver option
669 while (gPlatformDriverOption
[Index
] != NULL
) {
672 // Build the platform boot option
674 BdsLibRegisterNewOption (BdsDriverLists
, gPlatformDriverOption
[Index
], NULL
, L
"DriverOrder");
680 Perform the platform diagnostic, such like test memory. OEM/IBV also
681 can customize this function to support specific platform diagnostic.
683 @param MemoryTestLevel The memory test intensive level
684 @param QuietBoot Indicate if need to enable the quiet boot
685 @param BaseMemoryTest A pointer to BdsMemoryTest()
689 PlatformBdsDiagnostics (
690 IN EXTENDMEM_COVERAGE_LEVEL MemoryTestLevel
,
691 IN BOOLEAN QuietBoot
,
692 IN BASEM_MEMORY_TEST BaseMemoryTest
697 DEBUG ((EFI_D_INFO
, "PlatformBdsDiagnostics\n"));
699 // Here we can decide if we need to show
700 // the diagnostics screen
701 // Notes: this quiet boot code should be remove
702 // from the graphic lib
705 EnableQuietBoot (PcdGetPtr(PcdLogoFile
));
708 // Perform system diagnostic
710 Status
= BaseMemoryTest (MemoryTestLevel
);
711 if (EFI_ERROR (Status
)) {
719 // Perform system diagnostic
721 Status
= BaseMemoryTest (MemoryTestLevel
);
726 The function will connect root bridge
728 @return EFI_SUCCESS Connect RootBridge successfully.
737 EFI_HANDLE RootHandle
;
740 // Make all the PCI_IO protocols on PCI Seg 0 show up
742 BdsLibConnectDevicePath (gPlatformRootBridges
[0]);
744 Status
= gBS
->LocateDevicePath (
745 &gEfiDevicePathProtocolGuid
,
746 &gPlatformRootBridges
[0],
749 if (EFI_ERROR (Status
)) {
753 Status
= gBS
->ConnectController (RootHandle
, NULL
, NULL
, FALSE
);
754 if (EFI_ERROR (Status
)) {
762 The function will execute with as the platform policy, current policy
763 is driven by boot mode. IBV/OEM can customize this code for their specific
766 @param DriverOptionList The header of the driver option link list
767 @param BootOptionList The header of the boot option link list
768 @param ProcessCapsules A pointer to ProcessCapsules()
769 @param BaseMemoryTest A pointer to BaseMemoryTest()
774 PlatformBdsPolicyBehavior (
775 IN LIST_ENTRY
*DriverOptionList
,
776 IN LIST_ENTRY
*BootOptionList
,
777 IN PROCESS_CAPSULES ProcessCapsules
,
778 IN BASEM_MEMORY_TEST BaseMemoryTest
783 EFI_EVENT UserInputDurationTime
;
785 BDS_COMMON_OPTION
*BootOption
;
789 EFI_BOOT_MODE BootMode
;
791 DEBUG ((EFI_D_INFO
, "PlatformBdsPolicyBehavior\n"));
794 ConnectRootBridge ();
797 // Init the time out value
799 Timeout
= PcdGet16 (PcdPlatformBootTimeOut
);
802 // Load the driver option as the driver option list
804 PlatformBdsGetDriverOption (DriverOptionList
);
807 // Get current Boot Mode
809 Status
= BdsLibGetBootMode (&BootMode
);
810 DEBUG ((EFI_D_ERROR
, "Boot Mode:%x\n", BootMode
));
813 // Go the different platform policy with different boot mode
814 // Notes: this part code can be change with the table policy
816 ASSERT (BootMode
== BOOT_WITH_FULL_CONFIGURATION
);
818 // Connect platform console
820 Status
= PlatformBdsConnectConsole (gPlatformConsole
);
821 if (EFI_ERROR (Status
)) {
823 // Here OEM/IBV can customize with defined action
825 PlatformBdsNoConsoleAction ();
828 // Create a 300ms duration event to ensure user has enough input time to enter Setup
830 Status
= gBS
->CreateEvent (
835 &UserInputDurationTime
837 ASSERT (Status
== EFI_SUCCESS
);
838 Status
= gBS
->SetTimer (UserInputDurationTime
, TimerRelative
, 3000000);
839 ASSERT (Status
== EFI_SUCCESS
);
841 // Memory test and Logo show
843 PlatformBdsDiagnostics (IGNORE
, TRUE
, BaseMemoryTest
);
846 // Perform some platform specific connect sequence
848 PlatformBdsConnectSequence ();
851 // In BOOT_WITH_FULL_CONFIGURATION boot mode, should always connect every device
852 // and do enumerate all the default boot options. But in development system board, the boot mode
853 // cannot be BOOT_ASSUMING_NO_CONFIGURATION_CHANGES because the machine box
854 // is always open. So the following code only do the ConnectAll and EnumerateAll at first boot.
856 Status
= BdsLibBuildOptionFromVar (BootOptionList
, L
"BootOrder");
857 if (EFI_ERROR(Status
)) {
859 // If cannot find "BootOrder" variable, it may be first boot.
860 // Try to connect all devices and enumerate all boot options here.
863 BdsLibEnumerateAllBootOption (BootOptionList
);
867 // To give the User a chance to enter Setup here, if user set TimeOut is 0.
868 // BDS should still give user a chance to enter Setup
870 // Connect first boot option, and then check user input before exit
872 for (Link
= BootOptionList
->ForwardLink
; Link
!= BootOptionList
;Link
= Link
->ForwardLink
) {
873 BootOption
= CR (Link
, BDS_COMMON_OPTION
, Link
, BDS_LOAD_OPTION_SIGNATURE
);
874 if (!IS_LOAD_OPTION_TYPE (BootOption
->Attribute
, LOAD_OPTION_ACTIVE
)) {
876 // skip the header of the link list, becuase it has no boot option
881 // Make sure the boot option device path connected, but ignore the BBS device path
883 if (DevicePathType (BootOption
->DevicePath
) != BBS_DEVICE_PATH
) {
884 BdsLibConnectDevicePath (BootOption
->DevicePath
);
891 // Check whether the user input after the duration time has expired
893 OldTpl
= EfiGetCurrentTpl();
894 gBS
->RestoreTPL (TPL_APPLICATION
);
895 gBS
->WaitForEvent (1, &UserInputDurationTime
, &Index
);
896 gBS
->CloseEvent (UserInputDurationTime
);
897 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
898 gBS
->RaiseTPL (OldTpl
);
900 if (!EFI_ERROR (Status
)) {
902 // Enter Setup if user input
905 PlatformBdsEnterFrontPage (Timeout
, FALSE
);
910 Hook point after a boot attempt succeeds. We don't expect a boot option to
911 return, so the UEFI 2.0 specification defines that you will default to an
912 interactive mode and stop processing the BootOrder list in this case. This
913 is also a platform implementation and can be customized by IBV/OEM.
915 @param Option Pointer to Boot Option that succeeded to boot.
920 PlatformBdsBootSuccess (
921 IN BDS_COMMON_OPTION
*Option
925 DEBUG ((EFI_D_INFO
, "PlatformBdsBootSuccess\n"));
928 // If Boot returned with EFI_SUCCESS and there is not in the boot device
929 // select loop then we need to pop up a UI and wait for user input.
931 TmpStr
= Option
->StatusString
;
932 if (TmpStr
!= NULL
) {
933 BdsLibOutputStrings (gST
->ConOut
, TmpStr
, Option
->Description
, L
"\n\r", NULL
);
939 Hook point after a boot attempt fails.
941 @param Option Pointer to Boot Option that failed to boot.
942 @param Status Status returned from failed boot.
943 @param ExitData Exit data returned from failed boot.
944 @param ExitDataSize Exit data size returned from failed boot.
949 PlatformBdsBootFail (
950 IN BDS_COMMON_OPTION
*Option
,
951 IN EFI_STATUS Status
,
953 IN UINTN ExitDataSize
957 DEBUG ((EFI_D_INFO
, "PlatformBdsBootFail\n"));
960 // If Boot returned with failed status then we need to pop up a UI and wait
963 TmpStr
= Option
->StatusString
;
964 if (TmpStr
!= NULL
) {
965 BdsLibOutputStrings (gST
->ConOut
, TmpStr
, Option
->Description
, L
"\n\r", NULL
);
971 This function is remained for IBV/OEM to do some platform action,
972 if there no console device can be connected.
974 @return EFI_SUCCESS Direct return success now.
978 PlatformBdsNoConsoleAction (
982 DEBUG ((EFI_D_INFO
, "PlatformBdsNoConsoleAction\n"));
987 This function locks platform flash that is not allowed to be updated during normal boot path.
988 The flash layout is platform specific.
992 PlatformBdsLockNonUpdatableFlash (
996 DEBUG ((EFI_D_INFO
, "PlatformBdsLockNonUpdatableFlash\n"));
1002 Lock the ConsoleIn device in system table. All key
1003 presses will be ignored until the Password is typed in. The only way to
1004 disable the password is to type it in to a ConIn device.
1006 @param Password Password used to lock ConIn device.
1008 @retval EFI_SUCCESS lock the Console In Spliter virtual handle successfully.
1009 @retval EFI_UNSUPPORTED Password not found
1018 return EFI_UNSUPPORTED
;