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
85 PrepareLpcBridgeDevicePath (
86 IN EFI_HANDLE DeviceHandle
92 Add IsaKeyboard to ConIn,
93 add IsaSerial to ConOut, ConIn, ErrOut.
98 DeviceHandle - Handle of PCIIO protocol.
102 EFI_SUCCESS - LPC bridge is added to ConOut, ConIn, and ErrOut.
103 EFI_STATUS - No LPC bridge is added.
108 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
109 EFI_DEVICE_PATH_PROTOCOL
*TempDevicePath
;
113 Status
= gBS
->HandleProtocol (
115 &gEfiDevicePathProtocolGuid
,
118 if (EFI_ERROR (Status
)) {
121 TempDevicePath
= DevicePath
;
126 DevicePath
= AppendDevicePathNode ((EFI_DEVICE_PATH_PROTOCOL
*)NULL
, (EFI_DEVICE_PATH_PROTOCOL
*)&gUartDeviceVenderNode
);
127 DevicePath
= AppendDevicePathNode (DevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*)&gUartDeviceNode
);
128 DevicePath
= AppendDevicePathNode (DevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*)&gTerminalTypeDeviceNode
);
133 DevPathStr
= DevicePathToStr(DevicePath
);
136 "BdsPlatform.c+%d: COM%d DevPath: %s\n",
138 gPnp16550ComPortDeviceNode
.UID
+ 1,
141 FreePool(DevPathStr
);
143 BdsLibUpdateConsoleVariable (VarConsoleOut
, DevicePath
, NULL
);
144 BdsLibUpdateConsoleVariable (VarConsoleInp
, DevicePath
, NULL
);
145 BdsLibUpdateConsoleVariable (VarErrorOut
, DevicePath
, NULL
);
152 IN EFI_DEVICE_PATH_PROTOCOL
*PciDevicePath
,
153 OUT EFI_DEVICE_PATH_PROTOCOL
**GopDevicePath
158 EFI_HANDLE PciDeviceHandle
;
159 EFI_DEVICE_PATH_PROTOCOL
*TempDevicePath
;
160 EFI_DEVICE_PATH_PROTOCOL
*TempPciDevicePath
;
161 UINTN GopHandleCount
;
162 EFI_HANDLE
*GopHandleBuffer
;
164 if (PciDevicePath
== NULL
|| GopDevicePath
== NULL
) {
165 return EFI_INVALID_PARAMETER
;
169 // Initialize the GopDevicePath to be PciDevicePath
171 *GopDevicePath
= PciDevicePath
;
172 TempPciDevicePath
= PciDevicePath
;
174 Status
= gBS
->LocateDevicePath (
175 &gEfiDevicePathProtocolGuid
,
179 if (EFI_ERROR (Status
)) {
184 // Try to connect this handle, so that GOP dirver could start on this
185 // device and create child handles with GraphicsOutput Protocol installed
186 // on them, then we get device paths of these child handles and select
187 // them as possible console device.
190 gBS
->ConnectController (PciDeviceHandle
, NULL
, NULL
, FALSE
);
193 ACPI_ADR_DEVICE_PATH AcpiAdr
;
194 EFI_DEVICE_PATH_PROTOCOL
*MyDevicePath
= NULL
;
196 AcpiAdr
.Header
.Type
= ACPI_DEVICE_PATH
;
197 AcpiAdr
.Header
.SubType
= ACPI_ADR_DP
;
198 //AcpiAdr.ADR= ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_VGA, 6, 0); //on bayleybay, CRT Device
199 AcpiAdr
.ADR
= ACPI_DISPLAY_ADR (1, 0, 0, 1, 0, ACPI_ADR_DISPLAY_TYPE_INTERNAL_DIGITAL
, 8, 0); ; // on rambi, eDP C
201 SetDevicePathNodeLength (&AcpiAdr
.Header
, sizeof (ACPI_ADR_DEVICE_PATH
));
203 MyDevicePath
= AppendDevicePathNode(MyDevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*)&AcpiAdr
);
205 gBS
->ConnectController (PciDeviceHandle
, NULL
, MyDevicePath
, FALSE
);
207 FreePool(MyDevicePath
);
211 Status
= gBS
->LocateHandleBuffer (
213 &gEfiGraphicsOutputProtocolGuid
,
218 if (!EFI_ERROR (Status
)) {
220 // Add all the child handles as possible Console Device
222 for (Index
= 0; Index
< GopHandleCount
; Index
++) {
223 Status
= gBS
->HandleProtocol (GopHandleBuffer
[Index
], &gEfiDevicePathProtocolGuid
, (VOID
*)&TempDevicePath
);
224 if (EFI_ERROR (Status
)) {
230 GetDevicePathSize (PciDevicePath
) - END_DEVICE_PATH_LENGTH
233 // In current implementation, we only enable one of the child handles
234 // as console device, i.e. sotre one of the child handle's device
235 // path to variable "ConOut"
236 // In futhure, we could select all child handles to be console device
239 *GopDevicePath
= TempDevicePath
;
242 // Delete the PCI device's path that added by GetPlugInPciVgaDevicePath()
243 // Add the integrity GOP device path.
245 BdsLibUpdateConsoleVariable (VarConsoleOutDev
, NULL
, PciDevicePath
);
246 BdsLibUpdateConsoleVariable (VarConsoleOutDev
, TempDevicePath
, NULL
);
249 gBS
->FreePool (GopHandleBuffer
);
256 PreparePciVgaDevicePath (
257 IN EFI_HANDLE DeviceHandle
263 Add PCI VGA to ConOut.
268 DeviceHandle - Handle of PCIIO protocol.
272 EFI_SUCCESS - PCI VGA is added to ConOut.
273 EFI_STATUS - No PCI VGA device is added.
278 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
279 EFI_DEVICE_PATH_PROTOCOL
*GopDevicePath
;
282 Status
= gBS
->HandleProtocol (
284 &gEfiDevicePathProtocolGuid
,
287 if (EFI_ERROR (Status
)) {
291 GetGopDevicePath (DevicePath
, &GopDevicePath
);
292 DevicePath
= GopDevicePath
;
294 BdsLibUpdateConsoleVariable (VarConsoleOut
, DevicePath
, NULL
);
300 PreparePciSerialDevicePath (
301 IN EFI_HANDLE DeviceHandle
307 Add PCI Serial to ConOut, ConIn, ErrOut.
312 DeviceHandle - Handle of PCIIO protocol.
316 EFI_SUCCESS - PCI Serial is added to ConOut, ConIn, and ErrOut.
317 EFI_STATUS - No PCI Serial device is added.
322 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
325 Status
= gBS
->HandleProtocol (
327 &gEfiDevicePathProtocolGuid
,
330 if (EFI_ERROR (Status
)) {
334 DevicePath
= AppendDevicePathNode (DevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*)&gUartDeviceNode
);
335 DevicePath
= AppendDevicePathNode (DevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*)&gTerminalTypeDeviceNode
);
337 BdsLibUpdateConsoleVariable (VarConsoleOut
, DevicePath
, NULL
);
338 BdsLibUpdateConsoleVariable (VarConsoleInp
, DevicePath
, NULL
);
339 BdsLibUpdateConsoleVariable (VarErrorOut
, DevicePath
, NULL
);
345 VisitAllInstancesOfProtocol (
347 IN PROTOCOL_INSTANCE_CALLBACK CallBackFunction
,
353 EFI_HANDLE
*HandleBuffer
;
358 // Start to check all the PciIo to find all possible device
362 Status
= gBS
->LocateHandleBuffer (
369 if (EFI_ERROR (Status
)) {
373 for (Index
= 0; Index
< HandleCount
; Index
++) {
374 Status
= gBS
->HandleProtocol (HandleBuffer
[Index
], Id
, &Instance
);
375 if (EFI_ERROR (Status
)) {
379 Status
= (*CallBackFunction
) (
386 gBS
->FreePool (HandleBuffer
);
394 VisitingAPciInstance (
395 IN EFI_HANDLE Handle
,
401 EFI_PCI_IO_PROTOCOL
*PciIo
;
404 PciIo
= (EFI_PCI_IO_PROTOCOL
*) Instance
;
407 // Check for all PCI device
409 Status
= PciIo
->Pci
.Read (
413 sizeof (Pci
) / sizeof (UINT32
),
416 if (EFI_ERROR (Status
)) {
420 return (*(VISIT_PCI_INSTANCE_CALLBACK
)(UINTN
) Context
) (
431 VisitAllPciInstances (
432 IN VISIT_PCI_INSTANCE_CALLBACK CallBackFunction
435 return VisitAllInstancesOfProtocol (
436 &gEfiPciIoProtocolGuid
,
437 VisitingAPciInstance
,
438 (VOID
*)(UINTN
) CallBackFunction
444 Do platform specific PCI Device check and add them to
445 ConOut, ConIn, ErrOut.
447 @param[in] Handle - Handle of PCI device instance
448 @param[in] PciIo - PCI IO protocol instance
449 @param[in] Pci - PCI Header register block
451 @retval EFI_SUCCESS - PCI Device check and Console variable update successfully.
452 @retval EFI_STATUS - PCI Device check or Console variable update fail.
457 DetectAndPreparePlatformPciDevicePath (
458 IN EFI_HANDLE Handle
,
459 IN EFI_PCI_IO_PROTOCOL
*PciIo
,
465 Status
= PciIo
->Attributes (
467 EfiPciIoAttributeOperationEnable
,
468 EFI_PCI_DEVICE_ENABLE
,
471 ASSERT_EFI_ERROR (Status
);
473 if (!mDetectVgaOnly
) {
475 // Here we decide whether it is LPC Bridge
477 if ((IS_PCI_LPC (Pci
)) ||
478 ((IS_PCI_ISA_PDECODE (Pci
)) &&
479 (Pci
->Hdr
.VendorId
== 0x8086)
483 // Add IsaKeyboard to ConIn,
484 // add IsaSerial to ConOut, ConIn, ErrOut
486 DEBUG ((EFI_D_INFO
, "Found LPC Bridge device\n"));
487 PrepareLpcBridgeDevicePath (Handle
);
491 // Here we decide which Serial device to enable in PCI bus
493 if (IS_PCI_16550SERIAL (Pci
)) {
495 // Add them to ConOut, ConIn, ErrOut.
497 DEBUG ((EFI_D_INFO
, "Found PCI 16550 SERIAL device\n"));
498 PreparePciSerialDevicePath (Handle
);
504 // Here we decide which VGA device to enable in PCI bus
506 if (IS_PCI_VGA (Pci
)) {
508 // Add them to ConOut.
510 DEBUG ((EFI_D_INFO
, "Found PCI VGA device\n"));
511 PreparePciVgaDevicePath (Handle
);
520 Do platform specific PCI Device check and add them to ConOut, ConIn, ErrOut
522 @param[in] DetectVgaOnly - Only detect VGA device if it's TRUE.
524 @retval EFI_SUCCESS - PCI Device check and Console variable update successfully.
525 @retval EFI_STATUS - PCI Device check or Console variable update fail.
529 DetectAndPreparePlatformPciDevicePaths (
530 BOOLEAN DetectVgaOnly
533 mDetectVgaOnly
= DetectVgaOnly
;
534 return VisitAllPciInstances (DetectAndPreparePlatformPciDevicePath
);
538 Connect the predefined platform default console device. Always try to find
539 and enable the vga device if have.
541 @param PlatformConsole Predefined platform default console device array.
543 @retval EFI_SUCCESS Success connect at least one ConIn and ConOut
544 device, there must have one ConOut device is
546 @return Return the status of BdsLibConnectAllDefaultConsoles ()
550 PlatformBdsConnectConsole (
551 IN BDS_CONSOLE_CONNECT_ENTRY
*PlatformConsole
556 EFI_DEVICE_PATH_PROTOCOL
*VarConout
;
557 EFI_DEVICE_PATH_PROTOCOL
*VarConin
;
558 UINTN DevicePathSize
;
561 // Connect RootBridge
563 VarConout
= BdsLibGetVariableAndSize (
565 &gEfiGlobalVariableGuid
,
568 VarConin
= BdsLibGetVariableAndSize (
570 &gEfiGlobalVariableGuid
,
574 if (VarConout
== NULL
|| VarConin
== NULL
) {
576 // Do platform specific PCI Device check and add them to ConOut, ConIn, ErrOut
578 DetectAndPreparePlatformPciDevicePaths (FALSE
);
581 // Have chance to connect the platform default console,
582 // the platform default console is the minimue device group
583 // the platform should support
585 for (Index
= 0; PlatformConsole
[Index
].DevicePath
!= NULL
; ++Index
) {
587 // Update the console variable with the connect type
589 if ((PlatformConsole
[Index
].ConnectType
& CONSOLE_IN
) == CONSOLE_IN
) {
590 BdsLibUpdateConsoleVariable (VarConsoleInp
, PlatformConsole
[Index
].DevicePath
, NULL
);
592 if ((PlatformConsole
[Index
].ConnectType
& CONSOLE_OUT
) == CONSOLE_OUT
) {
593 BdsLibUpdateConsoleVariable (VarConsoleOut
, PlatformConsole
[Index
].DevicePath
, NULL
);
595 if ((PlatformConsole
[Index
].ConnectType
& STD_ERROR
) == STD_ERROR
) {
596 BdsLibUpdateConsoleVariable (VarErrorOut
, PlatformConsole
[Index
].DevicePath
, NULL
);
601 // Only detect VGA device and add them to ConOut
603 DetectAndPreparePlatformPciDevicePaths (TRUE
);
607 // Connect the all the default console with current cosole variable
609 Status
= BdsLibConnectAllDefaultConsoles ();
610 if (EFI_ERROR (Status
)) {
618 Connect with predefined platform connect sequence,
619 the OEM/IBV can customize with their own connect sequence.
622 PlatformBdsConnectSequence (
628 DEBUG ((EFI_D_INFO
, "PlatformBdsConnectSequence\n"));
632 // Here we can get the customized platform connect sequence
633 // Notes: we can connect with new variable which record the
634 // last time boots connect device path sequence
636 while (gPlatformConnectSequence
[Index
] != NULL
) {
638 // Build the platform boot option
640 BdsLibConnectDevicePath (gPlatformConnectSequence
[Index
]);
646 Load the predefined driver option, OEM/IBV can customize this
647 to load their own drivers
649 @param BdsDriverLists - The header of the driver option link list.
653 PlatformBdsGetDriverOption (
654 IN OUT LIST_ENTRY
*BdsDriverLists
661 DEBUG ((EFI_D_INFO
, "PlatformBdsGetDriverOption\n"));
665 // Here we can get the customized platform driver option
667 while (gPlatformDriverOption
[Index
] != NULL
) {
670 // Build the platform boot option
672 BdsLibRegisterNewOption (BdsDriverLists
, gPlatformDriverOption
[Index
], NULL
, L
"DriverOrder");
678 Perform the platform diagnostic, such like test memory. OEM/IBV also
679 can customize this function to support specific platform diagnostic.
681 @param MemoryTestLevel The memory test intensive level
682 @param QuietBoot Indicate if need to enable the quiet boot
683 @param BaseMemoryTest A pointer to BdsMemoryTest()
687 PlatformBdsDiagnostics (
688 IN EXTENDMEM_COVERAGE_LEVEL MemoryTestLevel
,
689 IN BOOLEAN QuietBoot
,
690 IN BASEM_MEMORY_TEST BaseMemoryTest
695 DEBUG ((EFI_D_INFO
, "PlatformBdsDiagnostics\n"));
697 // Here we can decide if we need to show
698 // the diagnostics screen
699 // Notes: this quiet boot code should be remove
700 // from the graphic lib
703 EnableQuietBoot (PcdGetPtr(PcdLogoFile
));
706 // Perform system diagnostic
708 Status
= BaseMemoryTest (MemoryTestLevel
);
709 if (EFI_ERROR (Status
)) {
717 // Perform system diagnostic
719 Status
= BaseMemoryTest (MemoryTestLevel
);
724 The function will connect root bridge
726 @return EFI_SUCCESS Connect RootBridge successfully.
735 EFI_HANDLE RootHandle
;
738 // Make all the PCI_IO protocols on PCI Seg 0 show up
740 BdsLibConnectDevicePath (gPlatformRootBridges
[0]);
742 Status
= gBS
->LocateDevicePath (
743 &gEfiDevicePathProtocolGuid
,
744 &gPlatformRootBridges
[0],
747 if (EFI_ERROR (Status
)) {
751 Status
= gBS
->ConnectController (RootHandle
, NULL
, NULL
, FALSE
);
752 if (EFI_ERROR (Status
)) {
760 The function will execute with as the platform policy, current policy
761 is driven by boot mode. IBV/OEM can customize this code for their specific
764 @param DriverOptionList The header of the driver option link list
765 @param BootOptionList The header of the boot option link list
766 @param ProcessCapsules A pointer to ProcessCapsules()
767 @param BaseMemoryTest A pointer to BaseMemoryTest()
772 PlatformBdsPolicyBehavior (
773 IN LIST_ENTRY
*DriverOptionList
,
774 IN LIST_ENTRY
*BootOptionList
,
775 IN PROCESS_CAPSULES ProcessCapsules
,
776 IN BASEM_MEMORY_TEST BaseMemoryTest
781 EFI_EVENT UserInputDurationTime
;
783 BDS_COMMON_OPTION
*BootOption
;
787 EFI_BOOT_MODE BootMode
;
789 DEBUG ((EFI_D_INFO
, "PlatformBdsPolicyBehavior\n"));
791 ConnectRootBridge ();
794 // Init the time out value
796 Timeout
= PcdGet16 (PcdPlatformBootTimeOut
);
799 // Load the driver option as the driver option list
801 PlatformBdsGetDriverOption (DriverOptionList
);
804 // Get current Boot Mode
806 Status
= BdsLibGetBootMode (&BootMode
);
807 DEBUG ((EFI_D_ERROR
, "Boot Mode:%x\n", BootMode
));
810 // Go the different platform policy with different boot mode
811 // Notes: this part code can be change with the table policy
813 ASSERT (BootMode
== BOOT_WITH_FULL_CONFIGURATION
);
815 // Connect platform console
817 Status
= PlatformBdsConnectConsole (gPlatformConsole
);
818 if (EFI_ERROR (Status
)) {
820 // Here OEM/IBV can customize with defined action
822 PlatformBdsNoConsoleAction ();
825 // Create a 300ms duration event to ensure user has enough input time to enter Setup
827 Status
= gBS
->CreateEvent (
832 &UserInputDurationTime
834 ASSERT (Status
== EFI_SUCCESS
);
835 Status
= gBS
->SetTimer (UserInputDurationTime
, TimerRelative
, 3000000);
836 ASSERT (Status
== EFI_SUCCESS
);
838 // Memory test and Logo show
840 PlatformBdsDiagnostics (IGNORE
, TRUE
, BaseMemoryTest
);
843 // Perform some platform specific connect sequence
845 PlatformBdsConnectSequence ();
848 // In BOOT_WITH_FULL_CONFIGURATION boot mode, should always connect every device
849 // and do enumerate all the default boot options. But in development system board, the boot mode
850 // cannot be BOOT_ASSUMING_NO_CONFIGURATION_CHANGES because the machine box
851 // is always open. So the following code only do the ConnectAll and EnumerateAll at first boot.
853 Status
= BdsLibBuildOptionFromVar (BootOptionList
, L
"BootOrder");
854 if (EFI_ERROR(Status
)) {
856 // If cannot find "BootOrder" variable, it may be first boot.
857 // Try to connect all devices and enumerate all boot options here.
860 BdsLibEnumerateAllBootOption (BootOptionList
);
864 // To give the User a chance to enter Setup here, if user set TimeOut is 0.
865 // BDS should still give user a chance to enter Setup
867 // Connect first boot option, and then check user input before exit
869 for (Link
= BootOptionList
->ForwardLink
; Link
!= BootOptionList
;Link
= Link
->ForwardLink
) {
870 BootOption
= CR (Link
, BDS_COMMON_OPTION
, Link
, BDS_LOAD_OPTION_SIGNATURE
);
871 if (!IS_LOAD_OPTION_TYPE (BootOption
->Attribute
, LOAD_OPTION_ACTIVE
)) {
873 // skip the header of the link list, becuase it has no boot option
878 // Make sure the boot option device path connected, but ignore the BBS device path
880 if (DevicePathType (BootOption
->DevicePath
) != BBS_DEVICE_PATH
) {
881 BdsLibConnectDevicePath (BootOption
->DevicePath
);
888 // Check whether the user input after the duration time has expired
890 OldTpl
= EfiGetCurrentTpl();
891 gBS
->RestoreTPL (TPL_APPLICATION
);
892 gBS
->WaitForEvent (1, &UserInputDurationTime
, &Index
);
893 gBS
->CloseEvent (UserInputDurationTime
);
894 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
895 gBS
->RaiseTPL (OldTpl
);
897 if (!EFI_ERROR (Status
)) {
899 // Enter Setup if user input
902 PlatformBdsEnterFrontPage (Timeout
, FALSE
);
907 Hook point after a boot attempt succeeds. We don't expect a boot option to
908 return, so the UEFI 2.0 specification defines that you will default to an
909 interactive mode and stop processing the BootOrder list in this case. This
910 is also a platform implementation and can be customized by IBV/OEM.
912 @param Option Pointer to Boot Option that succeeded to boot.
917 PlatformBdsBootSuccess (
918 IN BDS_COMMON_OPTION
*Option
922 DEBUG ((EFI_D_INFO
, "PlatformBdsBootSuccess\n"));
925 // If Boot returned with EFI_SUCCESS and there is not in the boot device
926 // select loop then we need to pop up a UI and wait for user input.
928 TmpStr
= Option
->StatusString
;
929 if (TmpStr
!= NULL
) {
930 BdsLibOutputStrings (gST
->ConOut
, TmpStr
, Option
->Description
, L
"\n\r", NULL
);
936 Hook point after a boot attempt fails.
938 @param Option Pointer to Boot Option that failed to boot.
939 @param Status Status returned from failed boot.
940 @param ExitData Exit data returned from failed boot.
941 @param ExitDataSize Exit data size returned from failed boot.
946 PlatformBdsBootFail (
947 IN BDS_COMMON_OPTION
*Option
,
948 IN EFI_STATUS Status
,
950 IN UINTN ExitDataSize
954 DEBUG ((EFI_D_INFO
, "PlatformBdsBootFail\n"));
957 // If Boot returned with failed status then we need to pop up a UI and wait
960 TmpStr
= Option
->StatusString
;
961 if (TmpStr
!= NULL
) {
962 BdsLibOutputStrings (gST
->ConOut
, TmpStr
, Option
->Description
, L
"\n\r", NULL
);
968 This function is remained for IBV/OEM to do some platform action,
969 if there no console device can be connected.
971 @return EFI_SUCCESS Direct return success now.
975 PlatformBdsNoConsoleAction (
979 DEBUG ((EFI_D_INFO
, "PlatformBdsNoConsoleAction\n"));
984 This function locks platform flash that is not allowed to be updated during normal boot path.
985 The flash layout is platform specific.
989 PlatformBdsLockNonUpdatableFlash (
993 DEBUG ((EFI_D_INFO
, "PlatformBdsLockNonUpdatableFlash\n"));
999 Lock the ConsoleIn device in system table. All key
1000 presses will be ignored until the Password is typed in. The only way to
1001 disable the password is to type it in to a ConIn device.
1003 @param Password Password used to lock ConIn device.
1005 @retval EFI_SUCCESS lock the Console In Spliter virtual handle successfully.
1006 @retval EFI_UNSUPPORTED Password not found
1015 return EFI_UNSUPPORTED
;