2 Provides interface to advanced shell functionality for parsing both handle and protocol database.
4 Copyright (c) 2010 - 2016, Intel Corporation. All rights reserved.<BR>
5 (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>
6 (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>
7 This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
17 #include "UefiHandleParsingLib.h"
18 #include "IndustryStandard/Acpi10.h"
20 EFI_HANDLE mHandleParsingHiiHandle
= NULL
;
21 HANDLE_INDEX_LIST mHandleList
= {{{NULL
,NULL
},0,0},0};
22 GUID_INFO_BLOCK
*GuidList
;
25 Function to translate the EFI_MEMORY_TYPE into a string.
27 @param[in] Memory The memory type.
29 @retval A string representation of the type allocated from BS Pool.
34 IN CONST EFI_MEMORY_TYPE Memory
41 case EfiReservedMemoryType
: StrnCatGrow(&RetVal
, NULL
, L
"EfiReservedMemoryType", 0); break;
42 case EfiLoaderCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiLoaderCode", 0); break;
43 case EfiLoaderData
: StrnCatGrow(&RetVal
, NULL
, L
"EfiLoaderData", 0); break;
44 case EfiBootServicesCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiBootServicesCode", 0); break;
45 case EfiBootServicesData
: StrnCatGrow(&RetVal
, NULL
, L
"EfiBootServicesData", 0); break;
46 case EfiRuntimeServicesCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiRuntimeServicesCode", 0); break;
47 case EfiRuntimeServicesData
: StrnCatGrow(&RetVal
, NULL
, L
"EfiRuntimeServicesData", 0); break;
48 case EfiConventionalMemory
: StrnCatGrow(&RetVal
, NULL
, L
"EfiConventionalMemory", 0); break;
49 case EfiUnusableMemory
: StrnCatGrow(&RetVal
, NULL
, L
"EfiUnusableMemory", 0); break;
50 case EfiACPIReclaimMemory
: StrnCatGrow(&RetVal
, NULL
, L
"EfiACPIReclaimMemory", 0); break;
51 case EfiACPIMemoryNVS
: StrnCatGrow(&RetVal
, NULL
, L
"EfiACPIMemoryNVS", 0); break;
52 case EfiMemoryMappedIO
: StrnCatGrow(&RetVal
, NULL
, L
"EfiMemoryMappedIO", 0); break;
53 case EfiMemoryMappedIOPortSpace
: StrnCatGrow(&RetVal
, NULL
, L
"EfiMemoryMappedIOPortSpace", 0); break;
54 case EfiPalCode
: StrnCatGrow(&RetVal
, NULL
, L
"EfiPalCode", 0); break;
55 case EfiMaxMemoryType
: StrnCatGrow(&RetVal
, NULL
, L
"EfiMaxMemoryType", 0); break;
56 default: ASSERT(FALSE
);
62 Function to translate the EFI_GRAPHICS_PIXEL_FORMAT into a string.
64 @param[in] Fmt The format type.
66 @retval A string representation of the type allocated from BS Pool.
71 IN CONST EFI_GRAPHICS_PIXEL_FORMAT Fmt
78 case PixelRedGreenBlueReserved8BitPerColor
: StrnCatGrow(&RetVal
, NULL
, L
"PixelRedGreenBlueReserved8BitPerColor", 0); break;
79 case PixelBlueGreenRedReserved8BitPerColor
: StrnCatGrow(&RetVal
, NULL
, L
"PixelBlueGreenRedReserved8BitPerColor", 0); break;
80 case PixelBitMask
: StrnCatGrow(&RetVal
, NULL
, L
"PixelBitMask", 0); break;
81 case PixelBltOnly
: StrnCatGrow(&RetVal
, NULL
, L
"PixelBltOnly", 0); break;
82 case PixelFormatMax
: StrnCatGrow(&RetVal
, NULL
, L
"PixelFormatMax", 0); break;
83 default: ASSERT(FALSE
);
89 Constructor for the library.
91 @param[in] ImageHandle Ignored.
92 @param[in] SystemTable Ignored.
94 @retval EFI_SUCCESS The operation was successful.
98 HandleParsingLibConstructor (
99 IN EFI_HANDLE ImageHandle
,
100 IN EFI_SYSTEM_TABLE
*SystemTable
107 // Do nothing with mHandleParsingHiiHandle. Initialize HII as needed.
109 return (EFI_SUCCESS
);
113 Initialization function for HII packages.
117 HandleParsingHiiInit (VOID
)
119 if (mHandleParsingHiiHandle
== NULL
) {
120 mHandleParsingHiiHandle
= HiiAddPackages (&gHandleParsingHiiGuid
, gImageHandle
, UefiHandleParsingLibStrings
, NULL
);
121 ASSERT (mHandleParsingHiiHandle
!= NULL
);
126 Destructor for the library. free any resources.
128 @param[in] ImageHandle Ignored.
129 @param[in] SystemTable Ignored.
131 @retval EFI_SUCCESS The operation was successful.
135 HandleParsingLibDestructor (
136 IN EFI_HANDLE ImageHandle
,
137 IN EFI_SYSTEM_TABLE
*SystemTable
142 for (LoopCount
= 0; GuidList
!= NULL
&& LoopCount
< GuidListCount
; LoopCount
++) {
143 SHELL_FREE_NON_NULL(GuidList
[LoopCount
].GuidId
);
146 SHELL_FREE_NON_NULL(GuidList
);
147 if (mHandleParsingHiiHandle
!= NULL
) {
148 HiiRemovePackages(mHandleParsingHiiHandle
);
150 return (EFI_SUCCESS
);
154 Function to dump information about LoadedImage.
156 This will allocate the return buffer from boot services pool.
158 @param[in] TheHandle The handle that has LoadedImage installed.
159 @param[in] Verbose TRUE for additional information, FALSE otherwise.
161 @retval A poitner to a string containing the information.
165 LoadedImageProtocolDumpInformation(
166 IN CONST EFI_HANDLE TheHandle
,
167 IN CONST BOOLEAN Verbose
170 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
178 return (CatSPrint(NULL
, L
"LoadedImage"));
181 HandleParsingHiiInit();
183 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_LI_DUMP_MAIN
), NULL
);
188 Status
= gBS
->OpenProtocol (
190 &gEfiLoadedImageProtocolGuid
,
191 (VOID
**)&LoadedImage
,
194 EFI_OPEN_PROTOCOL_GET_PROTOCOL
197 if (EFI_ERROR (Status
)) {
198 SHELL_FREE_NON_NULL (Temp
);
202 DataType
= ConvertMemoryType(LoadedImage
->ImageDataType
);
203 CodeType
= ConvertMemoryType(LoadedImage
->ImageCodeType
);
208 LoadedImage
->Revision
,
209 LoadedImage
->ParentHandle
,
210 LoadedImage
->SystemTable
,
211 LoadedImage
->DeviceHandle
,
212 LoadedImage
->FilePath
,
213 LoadedImage
->LoadOptionsSize
,
214 LoadedImage
->LoadOptions
,
215 LoadedImage
->ImageBase
,
216 LoadedImage
->ImageSize
,
223 SHELL_FREE_NON_NULL(Temp
);
224 SHELL_FREE_NON_NULL(CodeType
);
225 SHELL_FREE_NON_NULL(DataType
);
231 Function to dump information about GOP.
233 This will allocate the return buffer from boot services pool.
235 @param[in] TheHandle The handle that has LoadedImage installed.
236 @param[in] Verbose TRUE for additional information, FALSE otherwise.
238 @retval A poitner to a string containing the information.
242 GraphicsOutputProtocolDumpInformation(
243 IN CONST EFI_HANDLE TheHandle
,
244 IN CONST BOOLEAN Verbose
247 EFI_GRAPHICS_OUTPUT_PROTOCOL
*GraphicsOutput
;
255 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION
*GopInfo
;
258 return (CatSPrint(NULL
, L
"GraphicsOutput"));
261 HandleParsingHiiInit();
263 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_GOP_DUMP_MAIN
), NULL
);
268 Status
= gBS
->OpenProtocol (
270 &gEfiGraphicsOutputProtocolGuid
,
271 (VOID
**)&GraphicsOutput
,
274 EFI_OPEN_PROTOCOL_GET_PROTOCOL
277 if (EFI_ERROR (Status
)) {
278 SHELL_FREE_NON_NULL (Temp
);
282 Fmt
= ConvertPixelFormat(GraphicsOutput
->Mode
->Info
->PixelFormat
);
287 GraphicsOutput
->Mode
->MaxMode
,
288 GraphicsOutput
->Mode
->Mode
,
289 GraphicsOutput
->Mode
->FrameBufferBase
,
290 (UINT64
)GraphicsOutput
->Mode
->FrameBufferSize
,
291 (UINT64
)GraphicsOutput
->Mode
->SizeOfInfo
,
292 GraphicsOutput
->Mode
->Info
->Version
,
293 GraphicsOutput
->Mode
->Info
->HorizontalResolution
,
294 GraphicsOutput
->Mode
->Info
->VerticalResolution
,
296 GraphicsOutput
->Mode
->Info
->PixelsPerScanLine
,
297 GraphicsOutput
->Mode
->Info
->PixelFormat
!=PixelBitMask
?0:GraphicsOutput
->Mode
->Info
->PixelInformation
.RedMask
,
298 GraphicsOutput
->Mode
->Info
->PixelFormat
!=PixelBitMask
?0:GraphicsOutput
->Mode
->Info
->PixelInformation
.GreenMask
,
299 GraphicsOutput
->Mode
->Info
->PixelFormat
!=PixelBitMask
?0:GraphicsOutput
->Mode
->Info
->PixelInformation
.BlueMask
302 SHELL_FREE_NON_NULL (Temp
);
304 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_GOP_RES_LIST_MAIN
), NULL
);
306 SHELL_FREE_NON_NULL (RetVal
);
310 TempRetVal
= CatSPrint (RetVal
, Temp
);
311 SHELL_FREE_NON_NULL (RetVal
);
312 if (TempRetVal
== NULL
) {
316 SHELL_FREE_NON_NULL (Temp
);
318 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_GOP_RES_LIST_ENTRY
), NULL
);
320 SHELL_FREE_NON_NULL (RetVal
);
325 for (Mode
= 0; Mode
< GraphicsOutput
->Mode
->MaxMode
; Mode
++) {
326 Status
= GraphicsOutput
->QueryMode (
332 if (EFI_ERROR (Status
)) {
336 TempRetVal
= CatSPrint (
340 GopInfo
->HorizontalResolution
,
341 GopInfo
->VerticalResolution
344 SHELL_FREE_NON_NULL (GopInfo
);
345 SHELL_FREE_NON_NULL (RetVal
);
351 SHELL_FREE_NON_NULL(Temp
);
352 SHELL_FREE_NON_NULL(Fmt
);
358 Function to dump information about EDID Discovered Protocol.
360 This will allocate the return buffer from boot services pool.
362 @param[in] TheHandle The handle that has LoadedImage installed.
363 @param[in] Verbose TRUE for additional information, FALSE otherwise.
365 @retval A pointer to a string containing the information.
369 EdidDiscoveredProtocolDumpInformation (
370 IN CONST EFI_HANDLE TheHandle
,
371 IN CONST BOOLEAN Verbose
374 EFI_EDID_DISCOVERED_PROTOCOL
*EdidDiscovered
;
381 return (CatSPrint (NULL
, L
"EDIDDiscovered"));
384 Status
= gBS
->OpenProtocol (
386 &gEfiEdidDiscoveredProtocolGuid
,
387 (VOID
**)&EdidDiscovered
,
390 EFI_OPEN_PROTOCOL_GET_PROTOCOL
393 if (EFI_ERROR (Status
)) {
397 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_DISCOVERED_MAIN
), NULL
);
402 RetVal
= CatSPrint (NULL
, Temp
, EdidDiscovered
->SizeOfEdid
);
403 SHELL_FREE_NON_NULL (Temp
);
405 if (EdidDiscovered
->SizeOfEdid
!= 0) {
406 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_DISCOVERED_DATA
), NULL
);
408 SHELL_FREE_NON_NULL (RetVal
);
411 TempRetVal
= CatSPrint (RetVal
, Temp
);
412 SHELL_FREE_NON_NULL (RetVal
);
415 TempRetVal
= CatSDumpHex (RetVal
, 7, 0, EdidDiscovered
->SizeOfEdid
, EdidDiscovered
->Edid
);
422 Function to dump information about EDID Active Protocol.
424 This will allocate the return buffer from boot services pool.
426 @param[in] TheHandle The handle that has LoadedImage installed.
427 @param[in] Verbose TRUE for additional information, FALSE otherwise.
429 @retval A pointer to a string containing the information.
433 EdidActiveProtocolDumpInformation (
434 IN CONST EFI_HANDLE TheHandle
,
435 IN CONST BOOLEAN Verbose
438 EFI_EDID_ACTIVE_PROTOCOL
*EdidActive
;
445 return (CatSPrint (NULL
, L
"EDIDActive"));
448 Status
= gBS
->OpenProtocol (
450 &gEfiEdidActiveProtocolGuid
,
454 EFI_OPEN_PROTOCOL_GET_PROTOCOL
457 if (EFI_ERROR (Status
)) {
461 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_ACTIVE_MAIN
), NULL
);
466 RetVal
= CatSPrint (NULL
, Temp
, EdidActive
->SizeOfEdid
);
467 SHELL_FREE_NON_NULL (Temp
);
469 if (EdidActive
->SizeOfEdid
!= 0) {
470 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_ACTIVE_DATA
), NULL
);
472 SHELL_FREE_NON_NULL (RetVal
);
475 TempRetVal
= CatSPrint (RetVal
, Temp
);
476 SHELL_FREE_NON_NULL (RetVal
);
479 TempRetVal
= CatSDumpHex (RetVal
, 7, 0, EdidActive
->SizeOfEdid
, EdidActive
->Edid
);
486 Function to dump information about PciRootBridgeIo.
488 This will allocate the return buffer from boot services pool.
490 @param[in] TheHandle The handle that has PciRootBridgeIo installed.
491 @param[in] Verbose TRUE for additional information, FALSE otherwise.
493 @retval A poitner to a string containing the information.
497 PciRootBridgeIoDumpInformation(
498 IN CONST EFI_HANDLE TheHandle
,
499 IN CONST BOOLEAN Verbose
502 EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL
*PciRootBridgeIo
;
503 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR
*Configuration
;
514 return (CatSPrint(NULL
, L
"PciRootBridgeIo"));
517 HandleParsingHiiInit();
519 Status
= gBS
->HandleProtocol(
521 &gEfiPciRootBridgeIoProtocolGuid
,
522 (VOID
**)&PciRootBridgeIo
);
524 if (EFI_ERROR(Status
)) {
528 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_PH
), NULL
);
532 Temp2
= CatSPrint(L
"\r\n", Temp
, PciRootBridgeIo
->ParentHandle
);
537 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_SEG
), NULL
);
539 SHELL_FREE_NON_NULL(RetVal
);
542 Temp2
= CatSPrint(RetVal
, Temp
, PciRootBridgeIo
->SegmentNumber
);
550 Status
= PciRootBridgeIo
->GetAttributes (PciRootBridgeIo
, &Supports
, &Attributes
);
551 if (!EFI_ERROR(Status
)) {
552 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_ATT
), NULL
);
554 SHELL_FREE_NON_NULL(RetVal
);
557 Temp2
= CatSPrint(RetVal
, Temp
, Attributes
);
563 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_SUPPORTS
), NULL
);
565 SHELL_FREE_NON_NULL(RetVal
);
568 Temp2
= CatSPrint(RetVal
, Temp
, Supports
);
575 Configuration
= NULL
;
576 Status
= PciRootBridgeIo
->Configuration (PciRootBridgeIo
, (VOID
**) &Configuration
);
577 if (!EFI_ERROR(Status
) && Configuration
!= NULL
) {
578 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_TITLE
), NULL
);
580 SHELL_FREE_NON_NULL(RetVal
);
583 Temp2
= CatSPrint(RetVal
, Temp
, Supports
);
588 while (Configuration
->Desc
== ACPI_ADDRESS_SPACE_DESCRIPTOR
) {
590 switch (Configuration
->ResType
) {
591 case ACPI_ADDRESS_SPACE_TYPE_MEM
:
592 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_MEM
), NULL
);
594 case ACPI_ADDRESS_SPACE_TYPE_IO
:
595 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_IO
), NULL
);
597 case ACPI_ADDRESS_SPACE_TYPE_BUS
:
598 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_BUS
), NULL
);
602 Temp2
= CatSPrint(RetVal
, L
"%s", Temp
);
609 Temp2
= CatSPrint(RetVal
,
610 L
"%H%02x %016lx %016lx %02x%N\r\n",
611 Configuration
->SpecificFlag
,
612 Configuration
->AddrRangeMin
,
613 Configuration
->AddrRangeMax
,
614 Configuration
->AddrSpaceGranularity
626 Function to dump information about SimpleTextOut.
628 This will allocate the return buffer from boot services pool.
630 @param[in] TheHandle The handle that has SimpleTextOut installed.
631 @param[in] Verbose TRUE for additional information, FALSE otherwise.
633 @retval A poitner to a string containing the information.
637 TxtOutProtocolDumpInformation(
638 IN CONST EFI_HANDLE TheHandle
,
639 IN CONST BOOLEAN Verbose
642 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL
*Dev
;
656 HandleParsingHiiInit();
661 Status
= gBS
->HandleProtocol(
663 &gEfiSimpleTextOutProtocolGuid
,
666 ASSERT_EFI_ERROR(Status
);
667 ASSERT (Dev
!= NULL
&& Dev
->Mode
!= NULL
);
669 Size
= (Dev
->Mode
->MaxMode
+ 1) * 80;
670 RetVal
= AllocateZeroPool(Size
);
672 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_TXT_OUT_DUMP_HEADER
), NULL
);
674 UnicodeSPrint(RetVal
, Size
, Temp
, Dev
, Dev
->Mode
->Attribute
);
681 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_TXT_OUT_DUMP_LINE
), NULL
);
682 for (Index
= 0; Index
< Dev
->Mode
->MaxMode
; Index
++) {
683 Status
= Dev
->QueryMode (Dev
, Index
, &Col
, &Row
);
684 NewSize
= Size
- StrSize(RetVal
);
686 RetVal
+ StrLen(RetVal
),
688 Temp
== NULL
?L
"":Temp
,
689 Index
== Dev
->Mode
->Mode
? L
'*' : L
' ',
691 !EFI_ERROR(Status
)?(INTN
)Col
:-1,
692 !EFI_ERROR(Status
)?(INTN
)Row
:-1
699 STATIC CONST UINTN VersionStringSize
= 60;
702 Function to dump information about EfiDriverSupportedEfiVersion protocol.
704 This will allocate the return buffer from boot services pool.
706 @param[in] TheHandle The handle that has the protocol installed.
707 @param[in] Verbose TRUE for additional information, FALSE otherwise.
709 @retval A poitner to a string containing the information.
713 DriverEfiVersionProtocolDumpInformation(
714 IN CONST EFI_HANDLE TheHandle
,
715 IN CONST BOOLEAN Verbose
718 EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL
*DriverEfiVersion
;
722 Status
= gBS
->HandleProtocol(
724 &gEfiDriverSupportedEfiVersionProtocolGuid
,
725 (VOID
**)&DriverEfiVersion
);
727 ASSERT_EFI_ERROR(Status
);
729 RetVal
= AllocateZeroPool(VersionStringSize
);
730 ASSERT(RetVal
!= NULL
);
731 UnicodeSPrint(RetVal
, VersionStringSize
, L
"0x%08x", DriverEfiVersion
->FirmwareVersion
);
735 Function to convert device path to string.
737 This will allocate the return buffer from boot services pool.
739 @param[in] DevPath Pointer to device path instance.
740 @param[in] Verbose TRUE for additional information, FALSE otherwise.
741 @param[in] Length Maximum allowed text length of the device path.
743 @retval A pointer to a string containing the information.
746 ConvertDevicePathToShortText(
747 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevPath
,
748 IN CONST BOOLEAN Verbose
,
749 IN CONST UINTN Length
757 // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)
759 Temp
= ConvertDevicePathToText(DevPath
, TRUE
, TRUE
);
760 if (!Verbose
&& Temp
!= NULL
&& StrLen(Temp
) > Length
) {
763 Temp2
= StrnCatGrow(&Temp2
, &Size
, L
"..", 0);
764 Temp2
= StrnCatGrow(&Temp2
, &Size
, Temp
+(StrLen(Temp
) - (Length
- 2)), 0);
772 Function to dump information about DevicePath protocol.
774 This will allocate the return buffer from boot services pool.
776 @param[in] TheHandle The handle that has the protocol installed.
777 @param[in] Verbose TRUE for additional information, FALSE otherwise.
779 @retval A pointer to a string containing the information.
783 DevicePathProtocolDumpInformation(
784 IN CONST EFI_HANDLE TheHandle
,
785 IN CONST BOOLEAN Verbose
788 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
793 Status
= gBS
->OpenProtocol(TheHandle
, &gEfiDevicePathProtocolGuid
, (VOID
**)&DevPath
, gImageHandle
, NULL
, EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
794 if (!EFI_ERROR(Status
)) {
795 Temp
= ConvertDevicePathToShortText (DevPath
, Verbose
, 30);
796 gBS
->CloseProtocol(TheHandle
, &gEfiDevicePathProtocolGuid
, gImageHandle
, NULL
);
802 Function to dump information about LoadedImageDevicePath protocol.
804 This will allocate the return buffer from boot services pool.
806 @param[in] TheHandle The handle that has the protocol installed.
807 @param[in] Verbose TRUE for additional information, FALSE otherwise.
809 @retval A pointer to a string containing the information.
813 LoadedImageDevicePathProtocolDumpInformation(
814 IN CONST EFI_HANDLE TheHandle
,
815 IN CONST BOOLEAN Verbose
818 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
823 Status
= gBS
->OpenProtocol(TheHandle
, &gEfiLoadedImageDevicePathProtocolGuid
, (VOID
**)&DevPath
, gImageHandle
, NULL
, EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
824 if (!EFI_ERROR(Status
)) {
825 Temp
= ConvertDevicePathToShortText (DevPath
, Verbose
, 30);
826 gBS
->CloseProtocol(TheHandle
, &gEfiDevicePathProtocolGuid
, gImageHandle
, NULL
);
832 Function to dump information about EfiAdapterInformation Protocol.
834 @param[in] TheHandle The handle that has the protocol installed.
835 @param[in] Verbose TRUE for additional information, FALSE otherwise.
837 @retval A pointer to a string containing the information.
841 AdapterInformationDumpInformation (
842 IN CONST EFI_HANDLE TheHandle
,
843 IN CONST BOOLEAN Verbose
847 EFI_ADAPTER_INFORMATION_PROTOCOL
*EfiAdptrInfoProtocol
;
848 UINTN InfoTypesBufferCount
;
850 EFI_GUID
*InfoTypesBuffer
;
855 VOID
*InformationBlock
;
856 UINTN InformationBlockSize
;
859 return (CatSPrint(NULL
, L
"AdapterInfo"));
862 InfoTypesBuffer
= NULL
;
863 InformationBlock
= NULL
;
866 Status
= gBS
->OpenProtocol (
867 (EFI_HANDLE
) (TheHandle
),
868 &gEfiAdapterInformationProtocolGuid
,
869 (VOID
**) &EfiAdptrInfoProtocol
,
872 EFI_OPEN_PROTOCOL_GET_PROTOCOL
875 if (EFI_ERROR (Status
)) {
880 // Get a list of supported information types for this instance of the protocol.
882 Status
= EfiAdptrInfoProtocol
->GetSupportedTypes (
883 EfiAdptrInfoProtocol
,
885 &InfoTypesBufferCount
888 if (EFI_ERROR (Status
)) {
889 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GET_SUPP_TYPES_FAILED
), NULL
);
890 if (TempStr
!= NULL
) {
891 RetVal
= CatSPrint (NULL
, TempStr
, Status
);
896 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_SUPP_TYPE_HEADER
), NULL
);
897 if (TempStr
== NULL
) {
900 RetVal
= CatSPrint (NULL
, TempStr
);
901 SHELL_FREE_NON_NULL (TempStr
);
903 for (GuidIndex
= 0; GuidIndex
< InfoTypesBufferCount
; GuidIndex
++) {
904 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GUID_NUMBER
), NULL
);
905 if (TempStr
== NULL
) {
908 TempRetVal
= CatSPrint (RetVal
, TempStr
, (GuidIndex
+ 1), &InfoTypesBuffer
[GuidIndex
]);
909 SHELL_FREE_NON_NULL (RetVal
);
911 SHELL_FREE_NON_NULL (TempStr
);
913 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GUID_STRING
), NULL
);
914 if (TempStr
== NULL
) {
918 if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoMediaStateGuid
)) {
919 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoMediaStateGuid");
920 SHELL_FREE_NON_NULL (RetVal
);
922 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoNetworkBootGuid
)) {
923 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoNetworkBootGuid");
924 SHELL_FREE_NON_NULL (RetVal
);
926 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoSanMacAddressGuid
)) {
927 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoSanMacAddressGuid");
928 SHELL_FREE_NON_NULL (RetVal
);
930 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoUndiIpv6SupportGuid
)) {
931 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoUndiIpv6SupportGuid");
932 SHELL_FREE_NON_NULL (RetVal
);
936 GuidStr
= GetStringNameFromGuid (&InfoTypesBuffer
[GuidIndex
], NULL
);
938 if (GuidStr
!= NULL
) {
939 if (StrCmp(GuidStr
, L
"UnknownDevice") == 0) {
940 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"UnknownInfoType");
941 SHELL_FREE_NON_NULL (RetVal
);
944 SHELL_FREE_NON_NULL (TempStr
);
945 SHELL_FREE_NON_NULL(GuidStr
);
947 // So that we never have to pass this UnknownInfoType to the parsing function "GetInformation" service of AIP
951 TempRetVal
= CatSPrint (RetVal
, TempStr
, GuidStr
);
952 SHELL_FREE_NON_NULL (RetVal
);
954 SHELL_FREE_NON_NULL(GuidStr
);
959 SHELL_FREE_NON_NULL (TempStr
);
961 Status
= EfiAdptrInfoProtocol
->GetInformation (
962 EfiAdptrInfoProtocol
,
963 &InfoTypesBuffer
[GuidIndex
],
965 &InformationBlockSize
968 if (EFI_ERROR (Status
)) {
969 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GETINFO_FAILED
), NULL
);
970 if (TempStr
== NULL
) {
973 TempRetVal
= CatSPrint (RetVal
, TempStr
, Status
);
974 SHELL_FREE_NON_NULL (RetVal
);
977 if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoMediaStateGuid
)) {
978 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_MEDIA_STATE
), NULL
);
979 if (TempStr
== NULL
) {
982 TempRetVal
= CatSPrint (
985 ((EFI_ADAPTER_INFO_MEDIA_STATE
*)InformationBlock
)->MediaState
,
986 ((EFI_ADAPTER_INFO_MEDIA_STATE
*)InformationBlock
)->MediaState
988 SHELL_FREE_NON_NULL (RetVal
);
990 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoNetworkBootGuid
)) {
991 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_NETWORK_BOOT_INFO
), NULL
);
992 if (TempStr
== NULL
) {
995 TempRetVal
= CatSPrint (
998 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv4BootCapablity
,
999 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv6BootCapablity
,
1000 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->FCoeBootCapablity
,
1001 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->OffloadCapability
,
1002 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiMpioCapability
,
1003 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv4Boot
,
1004 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv6Boot
,
1005 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->FCoeBoot
1007 SHELL_FREE_NON_NULL (RetVal
);
1008 RetVal
= TempRetVal
;
1009 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoSanMacAddressGuid
) == TRUE
) {
1010 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_SAN_MAC_ADDRESS_INFO
), NULL
);
1011 if (TempStr
== NULL
) {
1014 TempRetVal
= CatSPrint (
1017 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[0],
1018 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[1],
1019 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[2],
1020 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[3],
1021 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[4],
1022 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[5]
1024 SHELL_FREE_NON_NULL (RetVal
);
1025 RetVal
= TempRetVal
;
1026 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoUndiIpv6SupportGuid
) == TRUE
) {
1027 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_UNDI_IPV6_INFO
), NULL
);
1028 if (TempStr
== NULL
) {
1032 TempRetVal
= CatSPrint (
1035 ((EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT
*)InformationBlock
)->Ipv6Support
1037 SHELL_FREE_NON_NULL (RetVal
);
1038 RetVal
= TempRetVal
;
1040 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_UNKNOWN_INFO_TYPE
), NULL
);
1041 if (TempStr
== NULL
) {
1044 TempRetVal
= CatSPrint (RetVal
, TempStr
, &InfoTypesBuffer
[GuidIndex
]);
1045 SHELL_FREE_NON_NULL (RetVal
);
1046 RetVal
= TempRetVal
;
1049 SHELL_FREE_NON_NULL (TempStr
);
1050 SHELL_FREE_NON_NULL (InformationBlock
);
1054 SHELL_FREE_NON_NULL (InfoTypesBuffer
);
1058 SHELL_FREE_NON_NULL (RetVal
);
1059 SHELL_FREE_NON_NULL (InfoTypesBuffer
);
1060 SHELL_FREE_NON_NULL (InformationBlock
);
1065 Function to dump information about EFI_FIRMWARE_MANAGEMENT_PROTOCOL Protocol.
1067 @param[in] TheHandle The handle that has the protocol installed.
1068 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1070 @retval A pointer to a string containing the information.
1074 FirmwareManagementDumpInformation (
1075 IN CONST EFI_HANDLE TheHandle
,
1076 IN CONST BOOLEAN Verbose
1080 EFI_FIRMWARE_MANAGEMENT_PROTOCOL
*EfiFwMgmtProtocol
;
1081 EFI_FIRMWARE_IMAGE_DESCRIPTOR
*ImageInfo
;
1082 EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1
*ImageInfoV1
;
1083 EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2
*ImageInfoV2
;
1084 UINT64 AttributeSetting
;
1085 UINTN ImageInfoSize
;
1086 UINTN DescriptorSize
;
1087 UINT32 DescriptorVersion
;
1088 UINT32 PackageVersion
;
1089 UINT8 DescriptorCount
;
1093 CHAR16
*PackageVersionName
;
1097 CHAR16
*AttributeSettingStr
;
1099 BOOLEAN AttributeSupported
;
1102 // Initialize local variables
1106 AttributeSetting
= 0;
1108 AttributeSupported
= FALSE
;
1112 PackageVersionName
= NULL
;
1116 AttributeSettingStr
= NULL
;
1119 return (CatSPrint(NULL
, L
"FirmwareManagement"));
1122 Status
= gBS
->OpenProtocol (
1123 (EFI_HANDLE
) (TheHandle
),
1124 &gEfiFirmwareManagementProtocolGuid
,
1125 (VOID
**) &EfiFwMgmtProtocol
,
1128 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1131 if (EFI_ERROR (Status
)) {
1135 Status
= EfiFwMgmtProtocol
->GetImageInfo (
1146 if (Status
== EFI_BUFFER_TOO_SMALL
) {
1147 ImageInfo
= AllocateZeroPool (ImageInfoSize
);
1149 if (ImageInfo
== NULL
) {
1150 Status
= EFI_OUT_OF_RESOURCES
;
1152 Status
= EfiFwMgmtProtocol
->GetImageInfo (
1165 if (EFI_ERROR (Status
)) {
1170 // Decode Image Descriptor data only if its version is supported
1172 if (DescriptorVersion
<= EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION
) {
1174 if (ImageInfo
== NULL
) {
1178 ImageInfoV1
= (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1
*)ImageInfo
;
1179 ImageInfoV2
= (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2
*)ImageInfo
;
1182 // Set ImageInfoSize in return buffer
1184 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_INFO_SIZE
), NULL
);
1185 if (TempStr
== NULL
) {
1188 RetVal
= CatSPrint (NULL
, TempStr
, ImageInfoSize
);
1189 SHELL_FREE_NON_NULL (TempStr
);
1192 // Set DescriptorVersion in return buffer
1194 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_DESCRIPTOR_VERSION
), NULL
);
1195 if (TempStr
== NULL
) {
1198 TempRetVal
= CatSPrint (RetVal
, TempStr
, DescriptorVersion
);
1199 SHELL_FREE_NON_NULL (RetVal
);
1200 RetVal
= TempRetVal
;
1201 SHELL_FREE_NON_NULL (TempStr
);
1204 // Set DescriptorCount in return buffer
1206 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_DESCRIPTOR_COUNT
), NULL
);
1207 if (TempStr
== NULL
) {
1210 TempRetVal
= CatSPrint (RetVal
, TempStr
, DescriptorCount
);
1211 SHELL_FREE_NON_NULL (RetVal
);
1212 RetVal
= TempRetVal
;
1213 SHELL_FREE_NON_NULL (TempStr
);
1217 // Set DescriptorSize in return buffer
1219 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_DESCRIPTOR_SIZE
), NULL
);
1220 if (TempStr
== NULL
) {
1223 TempRetVal
= CatSPrint (RetVal
, TempStr
, DescriptorSize
);
1224 SHELL_FREE_NON_NULL (RetVal
);
1225 RetVal
= TempRetVal
;
1226 SHELL_FREE_NON_NULL (TempStr
);
1229 // Set PackageVersion in return buffer
1231 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_PACKAGE_VERSION
), NULL
);
1232 if (TempStr
== NULL
) {
1235 TempRetVal
= CatSPrint (RetVal
, TempStr
, PackageVersion
);
1236 SHELL_FREE_NON_NULL (RetVal
);
1237 RetVal
= TempRetVal
;
1238 SHELL_FREE_NON_NULL (TempStr
);
1241 // Set PackageVersionName in return buffer
1243 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_PACKAGE_VERSION_NAME
), NULL
);
1244 if (TempStr
== NULL
) {
1247 TempRetVal
= CatSPrint (RetVal
, TempStr
, PackageVersionName
);
1248 SHELL_FREE_NON_NULL (RetVal
);
1249 RetVal
= TempRetVal
;
1250 SHELL_FREE_NON_NULL (TempStr
);
1252 for (Index
= 0; Index
< DescriptorCount
; Index
++) {
1254 // First check if Attribute is supported
1255 // and generate a string for AttributeSetting field
1257 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1258 AttributeSupported
= FALSE
;
1259 AttributeSetting
= 0;
1260 if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1
) {
1261 if (ImageInfoV1
[Index
].AttributesSupported
!= 0x0) {
1262 AttributeSupported
= TRUE
;
1263 AttributeSetting
= ImageInfoV1
[Index
].AttributesSetting
;
1265 } else if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2
) {
1266 if (ImageInfoV2
[Index
].AttributesSupported
!= 0x0) {
1267 AttributeSupported
= TRUE
;
1268 AttributeSetting
= ImageInfoV2
[Index
].AttributesSetting
;
1271 if (ImageInfo
[Index
].AttributesSupported
!= 0x0) {
1272 AttributeSupported
= TRUE
;
1273 AttributeSetting
= ImageInfo
[Index
].AttributesSetting
;
1277 if (!AttributeSupported
) {
1278 AttributeSettingStr
= CatSPrint (NULL
, L
"None");
1280 AttributeSettingStr
= CatSPrint (NULL
, L
"(");
1282 if ((AttributeSetting
& IMAGE_ATTRIBUTE_IMAGE_UPDATABLE
) != 0x0) {
1283 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_IMAGE_UPDATABLE");
1284 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1285 AttributeSettingStr
= TempRetVal
;
1287 if ((AttributeSetting
& IMAGE_ATTRIBUTE_RESET_REQUIRED
) != 0x0) {
1288 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_RESET_REQUIRED");
1289 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1290 AttributeSettingStr
= TempRetVal
;
1292 if ((AttributeSetting
& IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED
) != 0x0) {
1293 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED");
1294 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1295 AttributeSettingStr
= TempRetVal
;
1297 if ((AttributeSetting
& IMAGE_ATTRIBUTE_IN_USE
) != 0x0) {
1298 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_IN_USE");
1299 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1300 AttributeSettingStr
= TempRetVal
;
1302 if ((AttributeSetting
& IMAGE_ATTRIBUTE_UEFI_IMAGE
) != 0x0) {
1303 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_UEFI_IMAGE");
1304 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1305 AttributeSettingStr
= TempRetVal
;
1307 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" )");
1308 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1309 AttributeSettingStr
= TempRetVal
;
1312 if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1
) {
1313 if (ImageInfoV1
[Index
].ImageIndex
!= 0x0) {
1317 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V1
), NULL
);
1318 if (TempStr
== NULL
) {
1321 TempRetVal
= CatSPrint (
1325 ImageInfoV1
[Index
].ImageIndex
,
1326 ImageInfoV1
[Index
].ImageTypeId
,
1327 ImageInfoV1
[Index
].ImageId
,
1328 ImageInfoV1
[Index
].ImageIdName
,
1329 ImageInfoV1
[Index
].Version
,
1330 ImageInfoV1
[Index
].VersionName
,
1331 ImageInfoV1
[Index
].Size
,
1332 ImageInfoV1
[Index
].AttributesSupported
,
1333 AttributeSettingStr
,
1334 ImageInfoV1
[Index
].Compatibilities
1336 SHELL_FREE_NON_NULL (RetVal
);
1337 RetVal
= TempRetVal
;
1338 SHELL_FREE_NON_NULL (TempStr
);
1339 } else if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2
) {
1340 if (ImageInfoV2
[Index
].ImageIndex
!= 0x0) {
1344 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V2
), NULL
);
1345 if (TempStr
== NULL
) {
1348 TempRetVal
= CatSPrint (
1352 ImageInfoV2
[Index
].ImageIndex
,
1353 ImageInfoV2
[Index
].ImageTypeId
,
1354 ImageInfoV2
[Index
].ImageId
,
1355 ImageInfoV2
[Index
].ImageIdName
,
1356 ImageInfoV2
[Index
].Version
,
1357 ImageInfoV2
[Index
].VersionName
,
1358 ImageInfoV2
[Index
].Size
,
1359 ImageInfoV2
[Index
].AttributesSupported
,
1360 AttributeSettingStr
,
1361 ImageInfoV2
[Index
].Compatibilities
,
1362 ImageInfoV2
[Index
].LowestSupportedImageVersion
1364 SHELL_FREE_NON_NULL (RetVal
);
1365 RetVal
= TempRetVal
;
1366 SHELL_FREE_NON_NULL (TempStr
);
1368 if (ImageInfo
[Index
].ImageIndex
!= 0x0) {
1372 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO
), NULL
);
1373 if (TempStr
== NULL
) {
1376 TempRetVal
= CatSPrint (
1380 ImageInfo
[Index
].ImageIndex
,
1381 ImageInfo
[Index
].ImageTypeId
,
1382 ImageInfo
[Index
].ImageId
,
1383 ImageInfo
[Index
].ImageIdName
,
1384 ImageInfo
[Index
].Version
,
1385 ImageInfo
[Index
].VersionName
,
1386 ImageInfo
[Index
].Size
,
1387 ImageInfo
[Index
].AttributesSupported
,
1388 AttributeSettingStr
,
1389 ImageInfo
[Index
].Compatibilities
,
1390 ImageInfo
[Index
].LowestSupportedImageVersion
,
1391 ImageInfo
[Index
].LastAttemptVersion
,
1392 ImageInfo
[Index
].LastAttemptStatus
,
1393 ImageInfo
[Index
].HardwareInstance
1395 SHELL_FREE_NON_NULL (RetVal
);
1396 RetVal
= TempRetVal
;
1397 SHELL_FREE_NON_NULL (TempStr
);
1402 if (ImageCount
> 0) {
1403 for (Index
=0; Index
<DescriptorCount
; Index
++) {
1404 for (Index1
=Index
+1; Index1
<DescriptorCount
; Index1
++) {
1405 if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1
) {
1406 if (ImageInfoV1
[Index
].ImageId
== ImageInfoV1
[Index1
].ImageId
) {
1409 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1413 } else if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2
) {
1414 if (ImageInfoV2
[Index
].ImageId
== ImageInfoV2
[Index1
].ImageId
) {
1417 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1422 if (ImageInfo
[Index
].ImageId
== ImageInfo
[Index1
].ImageId
) {
1425 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1436 // Check if ImageId with duplicate value was found
1439 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGEID_NON_UNIQUE
), NULL
);
1440 if (TempStr
== NULL
) {
1443 TempRetVal
= CatSPrint (RetVal
, TempStr
);
1444 SHELL_FREE_NON_NULL (RetVal
);
1445 RetVal
= TempRetVal
;
1446 SHELL_FREE_NON_NULL (TempStr
);
1449 SHELL_FREE_NON_NULL (ImageInfo
);
1450 SHELL_FREE_NON_NULL (PackageVersionName
);
1451 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1456 SHELL_FREE_NON_NULL (RetVal
);
1457 SHELL_FREE_NON_NULL (ImageInfo
);
1458 SHELL_FREE_NON_NULL (PackageVersionName
);
1459 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1465 // Put the information on the NT32 protocol GUIDs here so we are not dependant on the Nt32Pkg
1467 #define LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID \
1469 0x58c518b1, 0x76f3, 0x11d4, { 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
1472 #define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \
1474 0x96eb4ad6, 0xa32a, 0x11d4, { 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
1477 #define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \
1479 0xc95a93d, 0xa006, 0x11d4, { 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
1481 STATIC CONST EFI_GUID WinNtThunkProtocolGuid
= LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID
;
1482 STATIC CONST EFI_GUID WinNtIoProtocolGuid
= LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID
;
1483 STATIC CONST EFI_GUID WinNtSerialPortGuid
= LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID
;
1486 // Deprecated protocols we dont want to link from IntelFrameworkModulePkg
1488 #define LOCAL_EFI_ISA_IO_PROTOCOL_GUID \
1490 0x7ee2bd44, 0x3da0, 0x11d4, { 0x9a, 0x38, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
1492 #define LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID \
1494 0x64a892dc, 0x5561, 0x4536, { 0x92, 0xc7, 0x79, 0x9b, 0xfc, 0x18, 0x33, 0x55 } \
1496 STATIC CONST EFI_GUID EfiIsaIoProtocolGuid
= LOCAL_EFI_ISA_IO_PROTOCOL_GUID
;
1497 STATIC CONST EFI_GUID EfiIsaAcpiProtocolGuid
= LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID
;
1500 STATIC CONST GUID_INFO_BLOCK mGuidStringListNT
[] = {
1501 {STRING_TOKEN(STR_WINNT_THUNK
), (EFI_GUID
*)&WinNtThunkProtocolGuid
, NULL
},
1502 {STRING_TOKEN(STR_WINNT_DRIVER_IO
), (EFI_GUID
*)&WinNtIoProtocolGuid
, NULL
},
1503 {STRING_TOKEN(STR_WINNT_SERIAL_PORT
), (EFI_GUID
*)&WinNtSerialPortGuid
, NULL
},
1504 {STRING_TOKEN(STR_UNKNOWN_DEVICE
), NULL
, NULL
},
1507 STATIC CONST GUID_INFO_BLOCK mGuidStringList
[] = {
1508 {STRING_TOKEN(STR_LOADED_IMAGE
), &gEfiLoadedImageProtocolGuid
, LoadedImageProtocolDumpInformation
},
1509 {STRING_TOKEN(STR_DEVICE_PATH
), &gEfiDevicePathProtocolGuid
, DevicePathProtocolDumpInformation
},
1510 {STRING_TOKEN(STR_IMAGE_PATH
), &gEfiLoadedImageDevicePathProtocolGuid
, LoadedImageDevicePathProtocolDumpInformation
},
1511 {STRING_TOKEN(STR_DEVICE_PATH_UTIL
), &gEfiDevicePathUtilitiesProtocolGuid
, NULL
},
1512 {STRING_TOKEN(STR_DEVICE_PATH_TXT
), &gEfiDevicePathToTextProtocolGuid
, NULL
},
1513 {STRING_TOKEN(STR_DEVICE_PATH_FTXT
), &gEfiDevicePathFromTextProtocolGuid
, NULL
},
1514 {STRING_TOKEN(STR_DEVICE_PATH_PC
), &gEfiPcAnsiGuid
, NULL
},
1515 {STRING_TOKEN(STR_DEVICE_PATH_VT100
), &gEfiVT100Guid
, NULL
},
1516 {STRING_TOKEN(STR_DEVICE_PATH_VT100P
), &gEfiVT100PlusGuid
, NULL
},
1517 {STRING_TOKEN(STR_DEVICE_PATH_VTUTF8
), &gEfiVTUTF8Guid
, NULL
},
1518 {STRING_TOKEN(STR_DRIVER_BINDING
), &gEfiDriverBindingProtocolGuid
, NULL
},
1519 {STRING_TOKEN(STR_PLATFORM_OVERRIDE
), &gEfiPlatformDriverOverrideProtocolGuid
, NULL
},
1520 {STRING_TOKEN(STR_BUS_OVERRIDE
), &gEfiBusSpecificDriverOverrideProtocolGuid
, NULL
},
1521 {STRING_TOKEN(STR_DRIVER_DIAG
), &gEfiDriverDiagnosticsProtocolGuid
, NULL
},
1522 {STRING_TOKEN(STR_DRIVER_DIAG2
), &gEfiDriverDiagnostics2ProtocolGuid
, NULL
},
1523 {STRING_TOKEN(STR_DRIVER_CN
), &gEfiComponentNameProtocolGuid
, NULL
},
1524 {STRING_TOKEN(STR_DRIVER_CN2
), &gEfiComponentName2ProtocolGuid
, NULL
},
1525 {STRING_TOKEN(STR_PLAT_DRV_CFG
), &gEfiPlatformToDriverConfigurationProtocolGuid
, NULL
},
1526 {STRING_TOKEN(STR_DRIVER_VERSION
), &gEfiDriverSupportedEfiVersionProtocolGuid
, DriverEfiVersionProtocolDumpInformation
},
1527 {STRING_TOKEN(STR_TXT_IN
), &gEfiSimpleTextInProtocolGuid
, NULL
},
1528 {STRING_TOKEN(STR_TXT_IN_EX
), &gEfiSimpleTextInputExProtocolGuid
, NULL
},
1529 {STRING_TOKEN(STR_TXT_OUT
), &gEfiSimpleTextOutProtocolGuid
, TxtOutProtocolDumpInformation
},
1530 {STRING_TOKEN(STR_SIM_POINTER
), &gEfiSimplePointerProtocolGuid
, NULL
},
1531 {STRING_TOKEN(STR_ABS_POINTER
), &gEfiAbsolutePointerProtocolGuid
, NULL
},
1532 {STRING_TOKEN(STR_SERIAL_IO
), &gEfiSerialIoProtocolGuid
, NULL
},
1533 {STRING_TOKEN(STR_GRAPHICS_OUTPUT
), &gEfiGraphicsOutputProtocolGuid
, GraphicsOutputProtocolDumpInformation
},
1534 {STRING_TOKEN(STR_EDID_DISCOVERED
), &gEfiEdidDiscoveredProtocolGuid
, EdidDiscoveredProtocolDumpInformation
},
1535 {STRING_TOKEN(STR_EDID_ACTIVE
), &gEfiEdidActiveProtocolGuid
, EdidActiveProtocolDumpInformation
},
1536 {STRING_TOKEN(STR_EDID_OVERRIDE
), &gEfiEdidOverrideProtocolGuid
, NULL
},
1537 {STRING_TOKEN(STR_CON_IN
), &gEfiConsoleInDeviceGuid
, NULL
},
1538 {STRING_TOKEN(STR_CON_OUT
), &gEfiConsoleOutDeviceGuid
, NULL
},
1539 {STRING_TOKEN(STR_STD_ERR
), &gEfiStandardErrorDeviceGuid
, NULL
},
1540 {STRING_TOKEN(STR_LOAD_FILE
), &gEfiLoadFileProtocolGuid
, NULL
},
1541 {STRING_TOKEN(STR_LOAD_FILE2
), &gEfiLoadFile2ProtocolGuid
, NULL
},
1542 {STRING_TOKEN(STR_SIMPLE_FILE_SYS
), &gEfiSimpleFileSystemProtocolGuid
, NULL
},
1543 {STRING_TOKEN(STR_TAPE_IO
), &gEfiTapeIoProtocolGuid
, NULL
},
1544 {STRING_TOKEN(STR_DISK_IO
), &gEfiDiskIoProtocolGuid
, NULL
},
1545 {STRING_TOKEN(STR_BLK_IO
), &gEfiBlockIoProtocolGuid
, NULL
},
1546 {STRING_TOKEN(STR_UC
), &gEfiUnicodeCollationProtocolGuid
, NULL
},
1547 {STRING_TOKEN(STR_UC2
), &gEfiUnicodeCollation2ProtocolGuid
, NULL
},
1548 {STRING_TOKEN(STR_PCIRB_IO
), &gEfiPciRootBridgeIoProtocolGuid
, PciRootBridgeIoDumpInformation
},
1549 {STRING_TOKEN(STR_PCI_IO
), &gEfiPciIoProtocolGuid
, NULL
},
1550 {STRING_TOKEN(STR_SCSI_PT
), &gEfiScsiPassThruProtocolGuid
, NULL
},
1551 {STRING_TOKEN(STR_SCSI_IO
), &gEfiScsiIoProtocolGuid
, NULL
},
1552 {STRING_TOKEN(STR_SCSI_PT_EXT
), &gEfiExtScsiPassThruProtocolGuid
, NULL
},
1553 {STRING_TOKEN(STR_ISCSI
), &gEfiIScsiInitiatorNameProtocolGuid
, NULL
},
1554 {STRING_TOKEN(STR_USB_IO
), &gEfiUsbIoProtocolGuid
, NULL
},
1555 {STRING_TOKEN(STR_USB_HC
), &gEfiUsbHcProtocolGuid
, NULL
},
1556 {STRING_TOKEN(STR_USB_HC2
), &gEfiUsb2HcProtocolGuid
, NULL
},
1557 {STRING_TOKEN(STR_DEBUG_SUPPORT
), &gEfiDebugSupportProtocolGuid
, NULL
},
1558 {STRING_TOKEN(STR_DEBUG_PORT
), &gEfiDebugPortProtocolGuid
, NULL
},
1559 {STRING_TOKEN(STR_DECOMPRESS
), &gEfiDecompressProtocolGuid
, NULL
},
1560 {STRING_TOKEN(STR_ACPI_TABLE
), &gEfiAcpiTableProtocolGuid
, NULL
},
1561 {STRING_TOKEN(STR_EBC_INTERPRETER
), &gEfiEbcProtocolGuid
, NULL
},
1562 {STRING_TOKEN(STR_SNP
), &gEfiSimpleNetworkProtocolGuid
, NULL
},
1563 {STRING_TOKEN(STR_NII
), &gEfiNetworkInterfaceIdentifierProtocolGuid
, NULL
},
1564 {STRING_TOKEN(STR_NII_31
), &gEfiNetworkInterfaceIdentifierProtocolGuid_31
, NULL
},
1565 {STRING_TOKEN(STR_PXE_BC
), &gEfiPxeBaseCodeProtocolGuid
, NULL
},
1566 {STRING_TOKEN(STR_PXE_CB
), &gEfiPxeBaseCodeCallbackProtocolGuid
, NULL
},
1567 {STRING_TOKEN(STR_BIS
), &gEfiBisProtocolGuid
, NULL
},
1568 {STRING_TOKEN(STR_MNP_SB
), &gEfiManagedNetworkServiceBindingProtocolGuid
, NULL
},
1569 {STRING_TOKEN(STR_MNP
), &gEfiManagedNetworkProtocolGuid
, NULL
},
1570 {STRING_TOKEN(STR_ARP_SB
), &gEfiArpServiceBindingProtocolGuid
, NULL
},
1571 {STRING_TOKEN(STR_ARP
), &gEfiArpProtocolGuid
, NULL
},
1572 {STRING_TOKEN(STR_DHCPV4_SB
), &gEfiDhcp4ServiceBindingProtocolGuid
, NULL
},
1573 {STRING_TOKEN(STR_DHCPV4
), &gEfiDhcp4ProtocolGuid
, NULL
},
1574 {STRING_TOKEN(STR_TCPV4_SB
), &gEfiTcp4ServiceBindingProtocolGuid
, NULL
},
1575 {STRING_TOKEN(STR_TCPV4
), &gEfiTcp4ProtocolGuid
, NULL
},
1576 {STRING_TOKEN(STR_IPV4_SB
), &gEfiIp4ServiceBindingProtocolGuid
, NULL
},
1577 {STRING_TOKEN(STR_IPV4
), &gEfiIp4ProtocolGuid
, NULL
},
1578 {STRING_TOKEN(STR_IPV4_CFG
), &gEfiIp4ConfigProtocolGuid
, NULL
},
1579 {STRING_TOKEN(STR_IPV4_CFG2
), &gEfiIp4Config2ProtocolGuid
, NULL
},
1580 {STRING_TOKEN(STR_UDPV4_SB
), &gEfiUdp4ServiceBindingProtocolGuid
, NULL
},
1581 {STRING_TOKEN(STR_UDPV4
), &gEfiUdp4ProtocolGuid
, NULL
},
1582 {STRING_TOKEN(STR_MTFTPV4_SB
), &gEfiMtftp4ServiceBindingProtocolGuid
, NULL
},
1583 {STRING_TOKEN(STR_MTFTPV4
), &gEfiMtftp4ProtocolGuid
, NULL
},
1584 {STRING_TOKEN(STR_AUTH_INFO
), &gEfiAuthenticationInfoProtocolGuid
, NULL
},
1585 {STRING_TOKEN(STR_HASH_SB
), &gEfiHashServiceBindingProtocolGuid
, NULL
},
1586 {STRING_TOKEN(STR_HASH
), &gEfiHashProtocolGuid
, NULL
},
1587 {STRING_TOKEN(STR_HII_FONT
), &gEfiHiiFontProtocolGuid
, NULL
},
1588 {STRING_TOKEN(STR_HII_STRING
), &gEfiHiiStringProtocolGuid
, NULL
},
1589 {STRING_TOKEN(STR_HII_IMAGE
), &gEfiHiiImageProtocolGuid
, NULL
},
1590 {STRING_TOKEN(STR_HII_DATABASE
), &gEfiHiiDatabaseProtocolGuid
, NULL
},
1591 {STRING_TOKEN(STR_HII_CONFIG_ROUT
), &gEfiHiiConfigRoutingProtocolGuid
, NULL
},
1592 {STRING_TOKEN(STR_HII_CONFIG_ACC
), &gEfiHiiConfigAccessProtocolGuid
, NULL
},
1593 {STRING_TOKEN(STR_HII_FORM_BROWSER2
), &gEfiFormBrowser2ProtocolGuid
, NULL
},
1594 {STRING_TOKEN(STR_DRIVER_FAM_OVERRIDE
), &gEfiDriverFamilyOverrideProtocolGuid
, NULL
},
1595 {STRING_TOKEN(STR_PCD
), &gPcdProtocolGuid
, NULL
},
1596 {STRING_TOKEN(STR_TCG
), &gEfiTcgProtocolGuid
, NULL
},
1597 {STRING_TOKEN(STR_HII_PACKAGE_LIST
), &gEfiHiiPackageListProtocolGuid
, NULL
},
1600 // the ones under this are deprecated by the current UEFI Spec, but may be found anyways...
1602 {STRING_TOKEN(STR_SHELL_INTERFACE
), &gEfiShellInterfaceGuid
, NULL
},
1603 {STRING_TOKEN(STR_SHELL_ENV2
), &gEfiShellEnvironment2Guid
, NULL
},
1604 {STRING_TOKEN(STR_SHELL_ENV
), &gEfiShellEnvironment2Guid
, NULL
},
1605 {STRING_TOKEN(STR_DEVICE_IO
), &gEfiDeviceIoProtocolGuid
, NULL
},
1606 {STRING_TOKEN(STR_UGA_DRAW
), &gEfiUgaDrawProtocolGuid
, NULL
},
1607 {STRING_TOKEN(STR_UGA_IO
), &gEfiUgaIoProtocolGuid
, NULL
},
1608 {STRING_TOKEN(STR_ESP
), &gEfiPartTypeSystemPartGuid
, NULL
},
1609 {STRING_TOKEN(STR_GPT_NBR
), &gEfiPartTypeLegacyMbrGuid
, NULL
},
1610 {STRING_TOKEN(STR_DRIVER_CONFIG
), &gEfiDriverConfigurationProtocolGuid
, NULL
},
1611 {STRING_TOKEN(STR_DRIVER_CONFIG2
), &gEfiDriverConfiguration2ProtocolGuid
, NULL
},
1614 // these are using local (non-global) definitions to reduce package dependancy.
1616 {STRING_TOKEN(STR_ISA_IO
), (EFI_GUID
*)&EfiIsaIoProtocolGuid
, NULL
},
1617 {STRING_TOKEN(STR_ISA_ACPI
), (EFI_GUID
*)&EfiIsaAcpiProtocolGuid
, NULL
},
1620 // the ones under this are GUID identified structs, not protocols
1622 {STRING_TOKEN(STR_FILE_INFO
), &gEfiFileInfoGuid
, NULL
},
1623 {STRING_TOKEN(STR_FILE_SYS_INFO
), &gEfiFileSystemInfoGuid
, NULL
},
1626 // the ones under this are misc GUIDS.
1628 {STRING_TOKEN(STR_EFI_GLOBAL_VARIABLE
), &gEfiGlobalVariableGuid
, NULL
},
1633 {STRING_TOKEN(STR_IP6_SB
), &gEfiIp6ServiceBindingProtocolGuid
, NULL
},
1634 {STRING_TOKEN(STR_IP6
), &gEfiIp6ProtocolGuid
, NULL
},
1635 {STRING_TOKEN(STR_IP6_CONFIG
), &gEfiIp6ConfigProtocolGuid
, NULL
},
1636 {STRING_TOKEN(STR_MTFTP6_SB
), &gEfiMtftp6ServiceBindingProtocolGuid
, NULL
},
1637 {STRING_TOKEN(STR_MTFTP6
), &gEfiMtftp6ProtocolGuid
, NULL
},
1638 {STRING_TOKEN(STR_DHCP6_SB
), &gEfiDhcp6ServiceBindingProtocolGuid
, NULL
},
1639 {STRING_TOKEN(STR_DHCP6
), &gEfiDhcp6ProtocolGuid
, NULL
},
1640 {STRING_TOKEN(STR_UDP6_SB
), &gEfiUdp6ServiceBindingProtocolGuid
, NULL
},
1641 {STRING_TOKEN(STR_UDP6
), &gEfiUdp6ProtocolGuid
, NULL
},
1642 {STRING_TOKEN(STR_TCP6_SB
), &gEfiTcp6ServiceBindingProtocolGuid
, NULL
},
1643 {STRING_TOKEN(STR_TCP6
), &gEfiTcp6ProtocolGuid
, NULL
},
1644 {STRING_TOKEN(STR_VLAN_CONFIG
), &gEfiVlanConfigProtocolGuid
, NULL
},
1645 {STRING_TOKEN(STR_EAP
), &gEfiEapProtocolGuid
, NULL
},
1646 {STRING_TOKEN(STR_EAP_MGMT
), &gEfiEapManagementProtocolGuid
, NULL
},
1647 {STRING_TOKEN(STR_FTP4_SB
), &gEfiFtp4ServiceBindingProtocolGuid
, NULL
},
1648 {STRING_TOKEN(STR_FTP4
), &gEfiFtp4ProtocolGuid
, NULL
},
1649 {STRING_TOKEN(STR_IP_SEC_CONFIG
), &gEfiIpSecConfigProtocolGuid
, NULL
},
1650 {STRING_TOKEN(STR_DH
), &gEfiDriverHealthProtocolGuid
, NULL
},
1651 {STRING_TOKEN(STR_DEF_IMG_LOAD
), &gEfiDeferredImageLoadProtocolGuid
, NULL
},
1652 {STRING_TOKEN(STR_USER_CRED
), &gEfiUserCredentialProtocolGuid
, NULL
},
1653 {STRING_TOKEN(STR_USER_MNGR
), &gEfiUserManagerProtocolGuid
, NULL
},
1654 {STRING_TOKEN(STR_ATA_PASS_THRU
), &gEfiAtaPassThruProtocolGuid
, NULL
},
1659 {STRING_TOKEN(STR_FW_MGMT
), &gEfiFirmwareManagementProtocolGuid
, FirmwareManagementDumpInformation
},
1660 {STRING_TOKEN(STR_IP_SEC
), &gEfiIpSecProtocolGuid
, NULL
},
1661 {STRING_TOKEN(STR_IP_SEC2
), &gEfiIpSec2ProtocolGuid
, NULL
},
1666 {STRING_TOKEN(STR_KMS
), &gEfiKmsProtocolGuid
, NULL
},
1667 {STRING_TOKEN(STR_BLK_IO2
), &gEfiBlockIo2ProtocolGuid
, NULL
},
1668 {STRING_TOKEN(STR_SSC
), &gEfiStorageSecurityCommandProtocolGuid
, NULL
},
1669 {STRING_TOKEN(STR_UCRED2
), &gEfiUserCredential2ProtocolGuid
, NULL
},
1674 {STRING_TOKEN(STR_DISK_IO2
), &gEfiDiskIo2ProtocolGuid
, NULL
},
1675 {STRING_TOKEN(STR_ADAPTER_INFO
), &gEfiAdapterInformationProtocolGuid
, AdapterInformationDumpInformation
},
1680 {STRING_TOKEN(STR_IDE_CONT_INIT
), &gEfiIdeControllerInitProtocolGuid
, NULL
},
1681 {STRING_TOKEN(STR_DISK_INFO
), &gEfiDiskInfoProtocolGuid
, NULL
},
1686 {STRING_TOKEN(STR_BDS_ARCH
), &gEfiBdsArchProtocolGuid
, NULL
},
1687 {STRING_TOKEN(STR_CPU_ARCH
), &gEfiCpuArchProtocolGuid
, NULL
},
1688 {STRING_TOKEN(STR_MET_ARCH
), &gEfiMetronomeArchProtocolGuid
, NULL
},
1689 {STRING_TOKEN(STR_MON_ARCH
), &gEfiMonotonicCounterArchProtocolGuid
, NULL
},
1690 {STRING_TOKEN(STR_RTC_ARCH
), &gEfiRealTimeClockArchProtocolGuid
, NULL
},
1691 {STRING_TOKEN(STR_RESET_ARCH
), &gEfiResetArchProtocolGuid
, NULL
},
1692 {STRING_TOKEN(STR_RT_ARCH
), &gEfiRuntimeArchProtocolGuid
, NULL
},
1693 {STRING_TOKEN(STR_SEC_ARCH
), &gEfiSecurityArchProtocolGuid
, NULL
},
1694 {STRING_TOKEN(STR_TIMER_ARCH
), &gEfiTimerArchProtocolGuid
, NULL
},
1695 {STRING_TOKEN(STR_VAR_ARCH
), &gEfiVariableWriteArchProtocolGuid
, NULL
},
1696 {STRING_TOKEN(STR_V_ARCH
), &gEfiVariableArchProtocolGuid
, NULL
},
1697 {STRING_TOKEN(STR_SECP
), &gEfiSecurityPolicyProtocolGuid
, NULL
},
1698 {STRING_TOKEN(STR_WDT_ARCH
), &gEfiWatchdogTimerArchProtocolGuid
, NULL
},
1699 {STRING_TOKEN(STR_SCR
), &gEfiStatusCodeRuntimeProtocolGuid
, NULL
},
1700 {STRING_TOKEN(STR_SMB_HC
), &gEfiSmbusHcProtocolGuid
, NULL
},
1701 {STRING_TOKEN(STR_FV_2
), &gEfiFirmwareVolume2ProtocolGuid
, NULL
},
1702 {STRING_TOKEN(STR_FV_BLOCK
), &gEfiFirmwareVolumeBlockProtocolGuid
, NULL
},
1703 {STRING_TOKEN(STR_CAP_ARCH
), &gEfiCapsuleArchProtocolGuid
, NULL
},
1704 {STRING_TOKEN(STR_MP_SERVICE
), &gEfiMpServiceProtocolGuid
, NULL
},
1705 {STRING_TOKEN(STR_HBRAP
), &gEfiPciHostBridgeResourceAllocationProtocolGuid
, NULL
},
1706 {STRING_TOKEN(STR_PCIP
), &gEfiPciPlatformProtocolGuid
, NULL
},
1707 {STRING_TOKEN(STR_PCIO
), &gEfiPciOverrideProtocolGuid
, NULL
},
1708 {STRING_TOKEN(STR_PCIE
), &gEfiPciEnumerationCompleteProtocolGuid
, NULL
},
1709 {STRING_TOKEN(STR_IPCID
), &gEfiIncompatiblePciDeviceSupportProtocolGuid
, NULL
},
1710 {STRING_TOKEN(STR_PCIHPI
), &gEfiPciHotPlugInitProtocolGuid
, NULL
},
1711 {STRING_TOKEN(STR_PCIHPR
), &gEfiPciHotPlugRequestProtocolGuid
, NULL
},
1712 {STRING_TOKEN(STR_SMBIOS
), &gEfiSmbiosProtocolGuid
, NULL
},
1713 {STRING_TOKEN(STR_S3_SAVE
), &gEfiS3SaveStateProtocolGuid
, NULL
},
1714 {STRING_TOKEN(STR_S3_S_SMM
), &gEfiS3SmmSaveStateProtocolGuid
, NULL
},
1715 {STRING_TOKEN(STR_RSC
), &gEfiRscHandlerProtocolGuid
, NULL
},
1716 {STRING_TOKEN(STR_S_RSC
), &gEfiSmmRscHandlerProtocolGuid
, NULL
},
1717 {STRING_TOKEN(STR_ACPI_SDT
), &gEfiAcpiSdtProtocolGuid
, NULL
},
1718 {STRING_TOKEN(STR_SIO
), &gEfiSioProtocolGuid
, NULL
},
1719 {STRING_TOKEN(STR_S_CPU2
), &gEfiSmmCpuIo2ProtocolGuid
, NULL
},
1720 {STRING_TOKEN(STR_S_BASE2
), &gEfiSmmBase2ProtocolGuid
, NULL
},
1721 {STRING_TOKEN(STR_S_ACC_2
), &gEfiSmmAccess2ProtocolGuid
, NULL
},
1722 {STRING_TOKEN(STR_S_CON_2
), &gEfiSmmControl2ProtocolGuid
, NULL
},
1723 {STRING_TOKEN(STR_S_CONFIG
), &gEfiSmmConfigurationProtocolGuid
, NULL
},
1724 {STRING_TOKEN(STR_S_RTL
), &gEfiSmmReadyToLockProtocolGuid
, NULL
},
1725 {STRING_TOKEN(STR_DS_RTL
), &gEfiDxeSmmReadyToLockProtocolGuid
, NULL
},
1726 {STRING_TOKEN(STR_S_COMM
), &gEfiSmmCommunicationProtocolGuid
, NULL
},
1727 {STRING_TOKEN(STR_S_STAT
), &gEfiSmmStatusCodeProtocolGuid
, NULL
},
1728 {STRING_TOKEN(STR_S_CPU
), &gEfiSmmCpuProtocolGuid
, NULL
},
1729 {STRING_TOKEN(STR_S_PCIRBIO
), &gEfiPciRootBridgeIoProtocolGuid
, NULL
},
1730 {STRING_TOKEN(STR_S_SWD
), &gEfiSmmSwDispatch2ProtocolGuid
, NULL
},
1731 {STRING_TOKEN(STR_S_SXD
), &gEfiSmmSxDispatch2ProtocolGuid
, NULL
},
1732 {STRING_TOKEN(STR_S_PTD2
), &gEfiSmmPeriodicTimerDispatch2ProtocolGuid
, NULL
},
1733 {STRING_TOKEN(STR_S_UD2
), &gEfiSmmUsbDispatch2ProtocolGuid
, NULL
},
1734 {STRING_TOKEN(STR_S_GD2
), &gEfiSmmGpiDispatch2ProtocolGuid
, NULL
},
1735 {STRING_TOKEN(STR_S_SBD2
), &gEfiSmmStandbyButtonDispatch2ProtocolGuid
, NULL
},
1736 {STRING_TOKEN(STR_S_PBD2
), &gEfiSmmPowerButtonDispatch2ProtocolGuid
, NULL
},
1737 {STRING_TOKEN(STR_S_ITD2
), &gEfiSmmIoTrapDispatch2ProtocolGuid
, NULL
},
1738 {STRING_TOKEN(STR_PCD
), &gEfiPcdProtocolGuid
, NULL
},
1739 {STRING_TOKEN(STR_FVB2
), &gEfiFirmwareVolumeBlock2ProtocolGuid
, NULL
},
1740 {STRING_TOKEN(STR_CPUIO2
), &gEfiCpuIo2ProtocolGuid
, NULL
},
1741 {STRING_TOKEN(STR_LEGACY_R2
), &gEfiLegacyRegion2ProtocolGuid
, NULL
},
1742 {STRING_TOKEN(STR_SAL_MIP
), &gEfiSalMcaInitPmiProtocolGuid
, NULL
},
1743 {STRING_TOKEN(STR_ES_BS
), &gEfiExtendedSalBootServiceProtocolGuid
, NULL
},
1744 {STRING_TOKEN(STR_ES_BIO
), &gEfiExtendedSalBaseIoServicesProtocolGuid
, NULL
},
1745 {STRING_TOKEN(STR_ES_STALL
), &gEfiExtendedSalStallServicesProtocolGuid
, NULL
},
1746 {STRING_TOKEN(STR_ES_RTC
), &gEfiExtendedSalRtcServicesProtocolGuid
, NULL
},
1747 {STRING_TOKEN(STR_ES_VS
), &gEfiExtendedSalVariableServicesProtocolGuid
, NULL
},
1748 {STRING_TOKEN(STR_ES_MTC
), &gEfiExtendedSalMtcServicesProtocolGuid
, NULL
},
1749 {STRING_TOKEN(STR_ES_RESET
), &gEfiExtendedSalResetServicesProtocolGuid
, NULL
},
1750 {STRING_TOKEN(STR_ES_SC
), &gEfiExtendedSalStatusCodeServicesProtocolGuid
, NULL
},
1751 {STRING_TOKEN(STR_ES_FBS
), &gEfiExtendedSalFvBlockServicesProtocolGuid
, NULL
},
1752 {STRING_TOKEN(STR_ES_MP
), &gEfiExtendedSalMpServicesProtocolGuid
, NULL
},
1753 {STRING_TOKEN(STR_ES_PAL
), &gEfiExtendedSalPalServicesProtocolGuid
, NULL
},
1754 {STRING_TOKEN(STR_ES_BASE
), &gEfiExtendedSalBaseServicesProtocolGuid
, NULL
},
1755 {STRING_TOKEN(STR_ES_MCA
), &gEfiExtendedSalMcaServicesProtocolGuid
, NULL
},
1756 {STRING_TOKEN(STR_ES_PCI
), &gEfiExtendedSalPciServicesProtocolGuid
, NULL
},
1757 {STRING_TOKEN(STR_ES_CACHE
), &gEfiExtendedSalCacheServicesProtocolGuid
, NULL
},
1758 {STRING_TOKEN(STR_ES_MCA_LOG
), &gEfiExtendedSalMcaLogServicesProtocolGuid
, NULL
},
1759 {STRING_TOKEN(STR_S2ARCH
), &gEfiSecurity2ArchProtocolGuid
, NULL
},
1760 {STRING_TOKEN(STR_EODXE
), &gEfiSmmEndOfDxeProtocolGuid
, NULL
},
1761 {STRING_TOKEN(STR_ISAHC
), &gEfiIsaHcProtocolGuid
, NULL
},
1762 {STRING_TOKEN(STR_ISAHC_B
), &gEfiIsaHcServiceBindingProtocolGuid
, NULL
},
1763 {STRING_TOKEN(STR_SIO_C
), &gEfiSioControlProtocolGuid
, NULL
},
1764 {STRING_TOKEN(STR_GET_PCD
), &gEfiGetPcdInfoProtocolGuid
, NULL
},
1765 {STRING_TOKEN(STR_I2C_M
), &gEfiI2cMasterProtocolGuid
, NULL
},
1766 {STRING_TOKEN(STR_I2CIO
), &gEfiI2cIoProtocolGuid
, NULL
},
1767 {STRING_TOKEN(STR_I2CEN
), &gEfiI2cEnumerateProtocolGuid
, NULL
},
1768 {STRING_TOKEN(STR_I2C_H
), &gEfiI2cHostProtocolGuid
, NULL
},
1769 {STRING_TOKEN(STR_I2C_BCM
), &gEfiI2cBusConfigurationManagementProtocolGuid
, NULL
},
1770 {STRING_TOKEN(STR_TREE
), &gEfiTrEEProtocolGuid
, NULL
},
1771 {STRING_TOKEN(STR_TCG2
), &gEfiTcg2ProtocolGuid
, NULL
},
1772 {STRING_TOKEN(STR_TIMESTAMP
), &gEfiTimestampProtocolGuid
, NULL
},
1773 {STRING_TOKEN(STR_RNG
), &gEfiRngProtocolGuid
, NULL
},
1774 {STRING_TOKEN(STR_NVMEPT
), &gEfiNvmExpressPassThruProtocolGuid
, NULL
},
1775 {STRING_TOKEN(STR_H2_SB
), &gEfiHash2ServiceBindingProtocolGuid
, NULL
},
1776 {STRING_TOKEN(STR_HASH2
), &gEfiHash2ProtocolGuid
, NULL
},
1777 {STRING_TOKEN(STR_BIO_C
), &gEfiBlockIoCryptoProtocolGuid
, NULL
},
1778 {STRING_TOKEN(STR_SCR
), &gEfiSmartCardReaderProtocolGuid
, NULL
},
1779 {STRING_TOKEN(STR_SCE
), &gEfiSmartCardEdgeProtocolGuid
, NULL
},
1780 {STRING_TOKEN(STR_USB_FIO
), &gEfiUsbFunctionIoProtocolGuid
, NULL
},
1781 {STRING_TOKEN(STR_BC_HC
), &gEfiBluetoothHcProtocolGuid
, NULL
},
1782 {STRING_TOKEN(STR_BC_IO_SB
), &gEfiBluetoothIoServiceBindingProtocolGuid
, NULL
},
1783 {STRING_TOKEN(STR_BC_IO
), &gEfiBluetoothIoProtocolGuid
, NULL
},
1784 {STRING_TOKEN(STR_BC_C
), &gEfiBluetoothConfigProtocolGuid
, NULL
},
1785 {STRING_TOKEN(STR_REG_EXP
), &gEfiRegularExpressionProtocolGuid
, NULL
},
1786 {STRING_TOKEN(STR_B_MGR_P
), &gEfiBootManagerPolicyProtocolGuid
, NULL
},
1787 {STRING_TOKEN(STR_CKH
), &gEfiConfigKeywordHandlerProtocolGuid
, NULL
},
1788 {STRING_TOKEN(STR_WIFI
), &gEfiWiFiProtocolGuid
, NULL
},
1789 {STRING_TOKEN(STR_EAP_M
), &gEfiEapManagement2ProtocolGuid
, NULL
},
1790 {STRING_TOKEN(STR_EAP_C
), &gEfiEapConfigurationProtocolGuid
, NULL
},
1791 {STRING_TOKEN(STR_PKCS7
), &gEfiPkcs7VerifyProtocolGuid
, NULL
},
1792 {STRING_TOKEN(STR_NET_DNS4_SB
), &gEfiDns4ServiceBindingProtocolGuid
, NULL
},
1793 {STRING_TOKEN(STR_NET_DNS4
), &gEfiDns4ProtocolGuid
, NULL
},
1794 {STRING_TOKEN(STR_NET_DNS6_SB
), &gEfiDns6ServiceBindingProtocolGuid
, NULL
},
1795 {STRING_TOKEN(STR_NET_DNS6
), &gEfiDns6ProtocolGuid
, NULL
},
1796 {STRING_TOKEN(STR_NET_HTTP_SB
), &gEfiHttpServiceBindingProtocolGuid
, NULL
},
1797 {STRING_TOKEN(STR_NET_HTTP
), &gEfiHttpProtocolGuid
, NULL
},
1798 {STRING_TOKEN(STR_NET_HTTP_U
), &gEfiHttpUtilitiesProtocolGuid
, NULL
},
1799 {STRING_TOKEN(STR_REST
), &gEfiRestProtocolGuid
, NULL
},
1802 // UEFI Shell Spec 2.0
1804 {STRING_TOKEN(STR_SHELL_PARAMETERS
), &gEfiShellParametersProtocolGuid
, NULL
},
1805 {STRING_TOKEN(STR_SHELL
), &gEfiShellProtocolGuid
, NULL
},
1808 // UEFI Shell Spec 2.1
1810 {STRING_TOKEN(STR_SHELL_DYNAMIC
), &gEfiShellDynamicCommandProtocolGuid
, NULL
},
1815 {STRING_TOKEN(STR_PCDINFOPROT
), &gGetPcdInfoProtocolGuid
, NULL
},
1820 {STRING_TOKEN(STR_UNKNOWN_DEVICE
), NULL
, NULL
},
1824 Function to get the node for a protocol or struct from it's GUID.
1826 if Guid is NULL, then ASSERT.
1828 @param[in] Guid The GUID to look for the name of.
1832 CONST GUID_INFO_BLOCK
*
1834 InternalShellGetNodeFromGuid(
1835 IN CONST EFI_GUID
* Guid
1838 CONST GUID_INFO_BLOCK
*ListWalker
;
1841 ASSERT(Guid
!= NULL
);
1843 for (LoopCount
= 0, ListWalker
= GuidList
; GuidList
!= NULL
&& LoopCount
< GuidListCount
; LoopCount
++, ListWalker
++) {
1844 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
1845 return (ListWalker
);
1849 if (PcdGetBool(PcdShellIncludeNtGuids
)) {
1850 for (ListWalker
= mGuidStringListNT
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
1851 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
1852 return (ListWalker
);
1856 for (ListWalker
= mGuidStringList
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
1857 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
1858 return (ListWalker
);
1865 Function to add a new GUID/Name mapping.
1867 @param[in] Guid The Guid
1868 @param[in] NameID The STRING id of the HII string to use
1869 @param[in] DumpFunc The pointer to the dump function
1872 @retval EFI_SUCCESS The operation was sucessful
1873 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
1874 @retval EFI_INVALID_PARAMETER Guid NameId was invalid
1878 InsertNewGuidNameMapping(
1879 IN CONST EFI_GUID
*Guid
,
1880 IN CONST EFI_STRING_ID NameID
,
1881 IN CONST DUMP_PROTOCOL_INFO DumpFunc OPTIONAL
1884 ASSERT(Guid
!= NULL
);
1885 ASSERT(NameID
!= 0);
1887 GuidList
= ReallocatePool(GuidListCount
* sizeof(GUID_INFO_BLOCK
), GuidListCount
+1 * sizeof(GUID_INFO_BLOCK
), GuidList
);
1888 if (GuidList
== NULL
) {
1890 return (EFI_OUT_OF_RESOURCES
);
1894 GuidList
[GuidListCount
- 1].GuidId
= AllocateCopyPool(sizeof(EFI_GUID
), Guid
);
1895 GuidList
[GuidListCount
- 1].StringId
= NameID
;
1896 GuidList
[GuidListCount
- 1].DumpInfo
= DumpFunc
;
1898 if (GuidList
[GuidListCount
- 1].GuidId
== NULL
) {
1899 return (EFI_OUT_OF_RESOURCES
);
1902 return (EFI_SUCCESS
);
1906 Function to add a new GUID/Name mapping.
1908 This cannot overwrite an existing mapping.
1910 @param[in] Guid The Guid
1911 @param[in] TheName The Guid's name
1912 @param[in] Lang RFC4646 language code list or NULL
1914 @retval EFI_SUCCESS The operation was sucessful
1915 @retval EFI_ACCESS_DENIED There was a duplicate
1916 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
1917 @retval EFI_INVALID_PARAMETER Guid or TheName was NULL
1921 AddNewGuidNameMapping(
1922 IN CONST EFI_GUID
*Guid
,
1923 IN CONST CHAR16
*TheName
,
1924 IN CONST CHAR8
*Lang OPTIONAL
1927 EFI_STRING_ID NameID
;
1929 HandleParsingHiiInit();
1931 if (Guid
== NULL
|| TheName
== NULL
){
1932 return (EFI_INVALID_PARAMETER
);
1935 if ((InternalShellGetNodeFromGuid(Guid
)) != NULL
) {
1936 return (EFI_ACCESS_DENIED
);
1939 NameID
= HiiSetString(mHandleParsingHiiHandle
, 0, (CHAR16
*)TheName
, Lang
);
1941 return (EFI_OUT_OF_RESOURCES
);
1944 return (InsertNewGuidNameMapping(Guid
, NameID
, NULL
));
1948 Function to get the name of a protocol or struct from it's GUID.
1950 if Guid is NULL, then ASSERT.
1952 @param[in] Guid The GUID to look for the name of.
1953 @param[in] Lang The language to use.
1955 @return pointer to string of the name. The caller
1956 is responsible to free this memory.
1960 GetStringNameFromGuid(
1961 IN CONST EFI_GUID
*Guid
,
1962 IN CONST CHAR8
*Lang OPTIONAL
1965 CONST GUID_INFO_BLOCK
*Id
;
1967 HandleParsingHiiInit();
1969 Id
= InternalShellGetNodeFromGuid(Guid
);
1970 return (HiiGetString(mHandleParsingHiiHandle
, Id
==NULL
?STRING_TOKEN(STR_UNKNOWN_DEVICE
):Id
->StringId
, Lang
));
1974 Function to dump protocol information from a handle.
1976 This function will return a allocated string buffer containing the
1977 information. The caller is responsible for freeing the memory.
1979 If Guid is NULL, ASSERT().
1980 If TheHandle is NULL, ASSERT().
1982 @param[in] TheHandle The handle to dump information from.
1983 @param[in] Guid The GUID of the protocol to dump.
1984 @param[in] Verbose TRUE for extra info. FALSE otherwise.
1986 @return The pointer to string.
1987 @retval NULL An error was encountered.
1991 GetProtocolInformationDump(
1992 IN CONST EFI_HANDLE TheHandle
,
1993 IN CONST EFI_GUID
*Guid
,
1994 IN CONST BOOLEAN Verbose
1997 CONST GUID_INFO_BLOCK
*Id
;
1999 ASSERT(TheHandle
!= NULL
);
2000 ASSERT(Guid
!= NULL
);
2002 if (TheHandle
== NULL
|| Guid
== NULL
) {
2006 Id
= InternalShellGetNodeFromGuid(Guid
);
2007 if (Id
!= NULL
&& Id
->DumpInfo
!= NULL
) {
2008 return (Id
->DumpInfo(TheHandle
, Verbose
));
2014 Function to get the Guid for a protocol or struct based on it's string name.
2016 do not modify the returned Guid.
2018 @param[in] Name The pointer to the string name.
2019 @param[in] Lang The pointer to the language code.
2020 @param[out] Guid The pointer to the Guid.
2022 @retval EFI_SUCCESS The operation was sucessful.
2026 GetGuidFromStringName(
2027 IN CONST CHAR16
*Name
,
2028 IN CONST CHAR8
*Lang OPTIONAL
,
2032 CONST GUID_INFO_BLOCK
*ListWalker
;
2036 HandleParsingHiiInit();
2038 ASSERT(Guid
!= NULL
);
2040 return (EFI_INVALID_PARAMETER
);
2044 if (PcdGetBool(PcdShellIncludeNtGuids
)) {
2045 for (ListWalker
= mGuidStringListNT
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
2046 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
2047 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
2048 *Guid
= ListWalker
->GuidId
;
2050 SHELL_FREE_NON_NULL(String
);
2051 if (*Guid
!= NULL
) {
2052 return (EFI_SUCCESS
);
2056 for (ListWalker
= mGuidStringList
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
2057 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
2058 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
2059 *Guid
= ListWalker
->GuidId
;
2061 SHELL_FREE_NON_NULL(String
);
2062 if (*Guid
!= NULL
) {
2063 return (EFI_SUCCESS
);
2067 for (LoopCount
= 0, ListWalker
= GuidList
; GuidList
!= NULL
&& LoopCount
< GuidListCount
; LoopCount
++, ListWalker
++) {
2068 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
2069 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
2070 *Guid
= ListWalker
->GuidId
;
2072 SHELL_FREE_NON_NULL(String
);
2073 if (*Guid
!= NULL
) {
2074 return (EFI_SUCCESS
);
2078 return (EFI_NOT_FOUND
);
2082 Get best support language for this driver.
2084 First base on the user input language to search, second base on the current
2085 platform used language to search, third get the first language from the
2086 support language list. The caller need to free the buffer of the best language.
2088 @param[in] SupportedLanguages The support languages for this driver.
2089 @param[in] InputLanguage The user input language.
2090 @param[in] Iso639Language Whether get language for ISO639.
2092 @return The best support language for this driver.
2096 GetBestLanguageForDriver (
2097 IN CONST CHAR8
*SupportedLanguages
,
2098 IN CONST CHAR8
*InputLanguage
,
2099 IN BOOLEAN Iso639Language
2102 CHAR8
*LanguageVariable
;
2103 CHAR8
*BestLanguage
;
2105 GetVariable2 (Iso639Language
? L
"Lang" : L
"PlatformLang", &gEfiGlobalVariableGuid
, (VOID
**)&LanguageVariable
, NULL
);
2107 BestLanguage
= GetBestLanguage(
2110 (InputLanguage
!= NULL
) ? InputLanguage
: "",
2111 (LanguageVariable
!= NULL
) ? LanguageVariable
: "",
2116 if (LanguageVariable
!= NULL
) {
2117 FreePool (LanguageVariable
);
2120 return BestLanguage
;
2124 Function to retrieve the driver name (if possible) from the ComponentName or
2125 ComponentName2 protocol
2127 @param[in] TheHandle The driver handle to get the name of.
2128 @param[in] Language The language to use.
2130 @retval NULL The name could not be found.
2131 @return A pointer to the string name. Do not de-allocate the memory.
2135 GetStringNameFromHandle(
2136 IN CONST EFI_HANDLE TheHandle
,
2137 IN CONST CHAR8
*Language
2140 EFI_COMPONENT_NAME2_PROTOCOL
*CompNameStruct
;
2147 Status
= gBS
->OpenProtocol(
2149 &gEfiComponentName2ProtocolGuid
,
2150 (VOID
**)&CompNameStruct
,
2153 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
2154 if (!EFI_ERROR(Status
)) {
2155 BestLang
= GetBestLanguageForDriver (CompNameStruct
->SupportedLanguages
, Language
, FALSE
);
2156 Status
= CompNameStruct
->GetDriverName(CompNameStruct
, BestLang
, &RetVal
);
2157 if (BestLang
!= NULL
) {
2158 FreePool (BestLang
);
2161 if (!EFI_ERROR(Status
)) {
2165 Status
= gBS
->OpenProtocol(
2167 &gEfiComponentNameProtocolGuid
,
2168 (VOID
**)&CompNameStruct
,
2171 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
2172 if (!EFI_ERROR(Status
)) {
2173 BestLang
= GetBestLanguageForDriver (CompNameStruct
->SupportedLanguages
, Language
, FALSE
);
2174 Status
= CompNameStruct
->GetDriverName(CompNameStruct
, BestLang
, &RetVal
);
2175 if (BestLang
!= NULL
) {
2176 FreePool (BestLang
);
2178 if (!EFI_ERROR(Status
)) {
2186 Function to initialize the file global mHandleList object for use in
2187 vonverting handles to index and index to handle.
2189 @retval EFI_SUCCESS The operation was successful.
2193 InternalShellInitHandleList(
2198 EFI_HANDLE
*HandleBuffer
;
2200 HANDLE_LIST
*ListWalker
;
2202 if (mHandleList
.NextIndex
!= 0) {
2205 InitializeListHead(&mHandleList
.List
.Link
);
2206 mHandleList
.NextIndex
= 1;
2207 Status
= gBS
->LocateHandleBuffer (
2214 ASSERT_EFI_ERROR(Status
);
2215 if (EFI_ERROR(Status
)) {
2218 for (mHandleList
.NextIndex
= 1 ; mHandleList
.NextIndex
<= HandleCount
; mHandleList
.NextIndex
++){
2219 ListWalker
= AllocateZeroPool(sizeof(HANDLE_LIST
));
2220 ASSERT(ListWalker
!= NULL
);
2221 ListWalker
->TheHandle
= HandleBuffer
[mHandleList
.NextIndex
-1];
2222 ListWalker
->TheIndex
= mHandleList
.NextIndex
;
2223 InsertTailList(&mHandleList
.List
.Link
,&ListWalker
->Link
);
2225 FreePool(HandleBuffer
);
2226 return (EFI_SUCCESS
);
2230 Function to retrieve the human-friendly index of a given handle. If the handle
2231 does not have a index one will be automatically assigned. The index value is valid
2232 until the termination of the shell application.
2234 @param[in] TheHandle The handle to retrieve an index for.
2236 @retval 0 A memory allocation failed.
2237 @return The index of the handle.
2242 ConvertHandleToHandleIndex(
2243 IN CONST EFI_HANDLE TheHandle
2247 EFI_GUID
**ProtocolBuffer
;
2248 UINTN ProtocolCount
;
2249 HANDLE_LIST
*ListWalker
;
2251 if (TheHandle
== NULL
) {
2255 InternalShellInitHandleList();
2257 for (ListWalker
= (HANDLE_LIST
*)GetFirstNode(&mHandleList
.List
.Link
)
2258 ; !IsNull(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2259 ; ListWalker
= (HANDLE_LIST
*)GetNextNode(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2261 if (ListWalker
->TheHandle
== TheHandle
) {
2263 // Verify that TheHandle is still present in the Handle Database
2265 Status
= gBS
->ProtocolsPerHandle(TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
2266 if (EFI_ERROR (Status
)) {
2268 // TheHandle is not present in the Handle Database, so delete from the handle list
2270 RemoveEntryList (&ListWalker
->Link
);
2273 FreePool (ProtocolBuffer
);
2274 return (ListWalker
->TheIndex
);
2279 // Verify that TheHandle is valid handle
2281 Status
= gBS
->ProtocolsPerHandle(TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
2282 if (EFI_ERROR (Status
)) {
2284 // TheHandle is not valid, so do not add to handle list
2288 FreePool (ProtocolBuffer
);
2290 ListWalker
= AllocateZeroPool(sizeof(HANDLE_LIST
));
2291 ASSERT(ListWalker
!= NULL
);
2292 ListWalker
->TheHandle
= TheHandle
;
2293 ListWalker
->TheIndex
= mHandleList
.NextIndex
++;
2294 InsertTailList(&mHandleList
.List
.Link
,&ListWalker
->Link
);
2295 return (ListWalker
->TheIndex
);
2301 Function to retrieve the EFI_HANDLE from the human-friendly index.
2303 @param[in] TheIndex The index to retrieve the EFI_HANDLE for.
2305 @retval NULL The index was invalid.
2306 @return The EFI_HANDLE that index represents.
2311 ConvertHandleIndexToHandle(
2312 IN CONST UINTN TheIndex
2316 EFI_GUID
**ProtocolBuffer
;
2317 UINTN ProtocolCount
;
2318 HANDLE_LIST
*ListWalker
;
2320 InternalShellInitHandleList();
2322 if (TheIndex
>= mHandleList
.NextIndex
) {
2326 for (ListWalker
= (HANDLE_LIST
*)GetFirstNode(&mHandleList
.List
.Link
)
2327 ; !IsNull(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2328 ; ListWalker
= (HANDLE_LIST
*)GetNextNode(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2330 if (ListWalker
->TheIndex
== TheIndex
&& ListWalker
->TheHandle
!= NULL
) {
2332 // Verify that LinkWalker->TheHandle is valid handle
2334 Status
= gBS
->ProtocolsPerHandle(ListWalker
->TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
2335 if (EFI_ERROR (Status
)) {
2337 // TheHandle is not valid, so do not add to handle list
2339 ListWalker
->TheHandle
= NULL
;
2341 return (ListWalker
->TheHandle
);
2348 Gets all the related EFI_HANDLEs based on the mask supplied.
2350 This function scans all EFI_HANDLES in the UEFI environment's handle database
2351 and returns the ones with the specified relationship (Mask) to the specified
2354 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
2355 If MatchingHandleCount is NULL, then ASSERT.
2357 If MatchingHandleBuffer is not NULL upon a successful return the memory must be
2360 @param[in] DriverBindingHandle The handle with Driver Binding protocol on it.
2361 @param[in] ControllerHandle The handle with Device Path protocol on it.
2362 @param[in] MatchingHandleCount The pointer to UINTN that specifies the number of HANDLES in
2363 MatchingHandleBuffer.
2364 @param[out] MatchingHandleBuffer On a successful return, a buffer of MatchingHandleCount
2365 EFI_HANDLEs with a terminating NULL EFI_HANDLE.
2366 @param[out] HandleType An array of type information.
2368 @retval EFI_SUCCESS The operation was successful, and any related handles
2369 are in MatchingHandleBuffer.
2370 @retval EFI_NOT_FOUND No matching handles were found.
2371 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.
2375 ParseHandleDatabaseByRelationshipWithType (
2376 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL
,
2377 IN CONST EFI_HANDLE ControllerHandle OPTIONAL
,
2378 IN UINTN
*HandleCount
,
2379 OUT EFI_HANDLE
**HandleBuffer
,
2380 OUT UINTN
**HandleType
2385 EFI_GUID
**ProtocolGuidArray
;
2387 UINTN ProtocolIndex
;
2388 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY
*OpenInfo
;
2389 UINTN OpenInfoCount
;
2390 UINTN OpenInfoIndex
;
2392 INTN DriverBindingHandleIndex
;
2394 ASSERT(HandleCount
!= NULL
);
2395 ASSERT(HandleBuffer
!= NULL
);
2396 ASSERT(HandleType
!= NULL
);
2397 ASSERT(DriverBindingHandle
!= NULL
|| ControllerHandle
!= NULL
);
2400 *HandleBuffer
= NULL
;
2404 // Retrieve the list of all handles from the handle database
2406 Status
= gBS
->LocateHandleBuffer (
2413 if (EFI_ERROR (Status
)) {
2417 *HandleType
= AllocateZeroPool (*HandleCount
* sizeof (UINTN
));
2418 ASSERT(*HandleType
!= NULL
);
2420 DriverBindingHandleIndex
= -1;
2421 for (HandleIndex
= 0; HandleIndex
< *HandleCount
; HandleIndex
++) {
2422 if (DriverBindingHandle
!= NULL
&& (*HandleBuffer
)[HandleIndex
] == DriverBindingHandle
) {
2423 DriverBindingHandleIndex
= (INTN
)HandleIndex
;
2427 for (HandleIndex
= 0; HandleIndex
< *HandleCount
; HandleIndex
++) {
2429 // Retrieve the list of all the protocols on each handle
2431 Status
= gBS
->ProtocolsPerHandle (
2432 (*HandleBuffer
)[HandleIndex
],
2436 if (EFI_ERROR (Status
)) {
2440 for (ProtocolIndex
= 0; ProtocolIndex
< ArrayCount
; ProtocolIndex
++) {
2443 // Set the bit describing what this handle has
2445 if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiLoadedImageProtocolGuid
) ) {
2446 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_IMAGE_HANDLE
;
2447 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverBindingProtocolGuid
) ) {
2448 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_BINDING_HANDLE
;
2449 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverConfiguration2ProtocolGuid
)) {
2450 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_CONFIGURATION_HANDLE
;
2451 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverConfigurationProtocolGuid
) ) {
2452 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_CONFIGURATION_HANDLE
;
2453 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverDiagnostics2ProtocolGuid
) ) {
2454 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_DIAGNOSTICS_HANDLE
;
2455 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverDiagnosticsProtocolGuid
) ) {
2456 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_DIAGNOSTICS_HANDLE
;
2457 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiComponentName2ProtocolGuid
) ) {
2458 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_COMPONENT_NAME_HANDLE
;
2459 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiComponentNameProtocolGuid
) ) {
2460 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_COMPONENT_NAME_HANDLE
;
2461 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDevicePathProtocolGuid
) ) {
2462 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DEVICE_HANDLE
;
2465 // Retrieve the list of agents that have opened each protocol
2467 Status
= gBS
->OpenProtocolInformation (
2468 (*HandleBuffer
)[HandleIndex
],
2469 ProtocolGuidArray
[ProtocolIndex
],
2473 if (EFI_ERROR (Status
)) {
2477 if (ControllerHandle
== NULL
) {
2479 // ControllerHandle == NULL and DriverBindingHandle != NULL.
2480 // Return information on all the controller handles that the driver specified by DriverBindingHandle is managing
2482 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2483 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
&& (OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
2484 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
2485 if (DriverBindingHandleIndex
!= -1) {
2486 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
2489 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
&& (OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2490 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
2491 if (DriverBindingHandleIndex
!= -1) {
2492 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
2494 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2495 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
2496 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
2502 if (DriverBindingHandle
== NULL
&& ControllerHandle
!= NULL
) {
2503 if (ControllerHandle
== (*HandleBuffer
)[HandleIndex
]) {
2504 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
2505 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2506 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
2507 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2508 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
2509 (*HandleType
)[ChildIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
2513 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2514 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2515 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
2516 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
2518 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
2519 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
2525 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2526 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2527 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== ControllerHandle
) {
2528 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_PARENT_HANDLE
);
2534 if (DriverBindingHandle
!= NULL
&& ControllerHandle
!= NULL
) {
2535 if (ControllerHandle
== (*HandleBuffer
)[HandleIndex
]) {
2536 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
2537 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2538 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
2539 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
) {
2540 if (DriverBindingHandleIndex
!= -1) {
2541 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
2545 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2546 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
) {
2547 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2548 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
2549 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
2554 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2555 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
2556 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
2562 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2563 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2564 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== ControllerHandle
) {
2565 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_PARENT_HANDLE
);
2571 FreePool (OpenInfo
);
2573 FreePool (ProtocolGuidArray
);
2579 Gets all the related EFI_HANDLEs based on the single EFI_HANDLE and the mask
2582 This function will scan all EFI_HANDLES in the UEFI environment's handle database
2583 and return all the ones with the specified relationship (Mask) to the specified
2586 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
2587 If MatchingHandleCount is NULL, then ASSERT.
2589 If MatchingHandleBuffer is not NULL upon a sucessful return the memory must be
2592 @param[in] DriverBindingHandle Handle to a object with Driver Binding protocol
2594 @param[in] ControllerHandle Handle to a device with Device Path protocol on it.
2595 @param[in] Mask Mask of what relationship(s) is desired.
2596 @param[in] MatchingHandleCount Poitner to UINTN specifying number of HANDLES in
2597 MatchingHandleBuffer.
2598 @param[out] MatchingHandleBuffer On a sucessful return a buffer of MatchingHandleCount
2599 EFI_HANDLEs and a terminating NULL EFI_HANDLE.
2601 @retval EFI_SUCCESS The operation was sucessful and any related handles
2602 are in MatchingHandleBuffer;
2603 @retval EFI_NOT_FOUND No matching handles were found.
2604 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.
2608 ParseHandleDatabaseByRelationship (
2609 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL
,
2610 IN CONST EFI_HANDLE ControllerHandle OPTIONAL
,
2611 IN CONST UINTN Mask
,
2612 IN UINTN
*MatchingHandleCount
,
2613 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
2618 EFI_HANDLE
*HandleBuffer
;
2622 ASSERT(MatchingHandleCount
!= NULL
);
2623 ASSERT(DriverBindingHandle
!= NULL
|| ControllerHandle
!= NULL
);
2625 if ((Mask
& HR_VALID_MASK
) != Mask
) {
2626 return (EFI_INVALID_PARAMETER
);
2629 if ((Mask
& HR_CHILD_HANDLE
) != 0 && DriverBindingHandle
== NULL
) {
2630 return (EFI_INVALID_PARAMETER
);
2633 *MatchingHandleCount
= 0;
2634 if (MatchingHandleBuffer
!= NULL
) {
2635 *MatchingHandleBuffer
= NULL
;
2638 HandleBuffer
= NULL
;
2641 Status
= ParseHandleDatabaseByRelationshipWithType (
2642 DriverBindingHandle
,
2648 if (!EFI_ERROR (Status
)) {
2650 // Count the number of handles that match the attributes in Mask
2652 for (HandleIndex
= 0; HandleIndex
< HandleCount
; HandleIndex
++) {
2653 if ((HandleType
[HandleIndex
] & Mask
) == Mask
) {
2654 (*MatchingHandleCount
)++;
2658 // If no handles match the attributes in Mask then return EFI_NOT_FOUND
2660 if (*MatchingHandleCount
== 0) {
2661 Status
= EFI_NOT_FOUND
;
2664 if (MatchingHandleBuffer
== NULL
) {
2666 // Someone just wanted the count...
2668 Status
= EFI_SUCCESS
;
2671 // Allocate a handle buffer for the number of handles that matched the attributes in Mask
2673 *MatchingHandleBuffer
= AllocateZeroPool ((*MatchingHandleCount
+1)* sizeof (EFI_HANDLE
));
2674 ASSERT(*MatchingHandleBuffer
!= NULL
);
2676 for (HandleIndex
= 0,*MatchingHandleCount
= 0
2677 ; HandleIndex
< HandleCount
2681 // Fill the allocated buffer with the handles that matched the attributes in Mask
2683 if ((HandleType
[HandleIndex
] & Mask
) == Mask
) {
2684 (*MatchingHandleBuffer
)[(*MatchingHandleCount
)++] = HandleBuffer
[HandleIndex
];
2689 // Make the last one NULL
2691 (*MatchingHandleBuffer
)[*MatchingHandleCount
] = NULL
;
2693 Status
= EFI_SUCCESS
;
2694 } // MacthingHandleBuffer == NULL (ELSE)
2695 } // *MatchingHandleCount == 0 (ELSE)
2696 } // no error on ParseHandleDatabaseByRelationshipWithType
2698 if (HandleBuffer
!= NULL
) {
2699 FreePool (HandleBuffer
);
2702 if (HandleType
!= NULL
) {
2703 FreePool (HandleType
);
2710 Gets handles for any child controllers of the passed in controller.
2712 @param[in] ControllerHandle The handle of the "parent controller"
2713 @param[in] MatchingHandleCount Pointer to the number of handles in
2714 MatchingHandleBuffer on return.
2715 @param[out] MatchingHandleBuffer Buffer containing handles on a successful
2719 @retval EFI_SUCCESS The operation was sucessful.
2723 ParseHandleDatabaseForChildControllers(
2724 IN CONST EFI_HANDLE ControllerHandle
,
2725 IN UINTN
*MatchingHandleCount
,
2726 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
2731 UINTN DriverBindingHandleCount
;
2732 EFI_HANDLE
*DriverBindingHandleBuffer
;
2733 UINTN DriverBindingHandleIndex
;
2734 UINTN ChildControllerHandleCount
;
2735 EFI_HANDLE
*ChildControllerHandleBuffer
;
2736 UINTN ChildControllerHandleIndex
;
2737 EFI_HANDLE
*HandleBufferForReturn
;
2739 if (MatchingHandleCount
== NULL
) {
2740 return (EFI_INVALID_PARAMETER
);
2742 *MatchingHandleCount
= 0;
2744 Status
= PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
2746 &DriverBindingHandleCount
,
2747 &DriverBindingHandleBuffer
2749 if (EFI_ERROR (Status
)) {
2754 // Get a buffer big enough for all the controllers.
2756 HandleBufferForReturn
= GetHandleListByProtocol(NULL
);
2757 if (HandleBufferForReturn
== NULL
) {
2758 FreePool (DriverBindingHandleBuffer
);
2759 return (EFI_NOT_FOUND
);
2762 for (DriverBindingHandleIndex
= 0; DriverBindingHandleIndex
< DriverBindingHandleCount
; DriverBindingHandleIndex
++) {
2763 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
2764 DriverBindingHandleBuffer
[DriverBindingHandleIndex
],
2766 &ChildControllerHandleCount
,
2767 &ChildControllerHandleBuffer
2769 if (EFI_ERROR (Status
)) {
2773 for (ChildControllerHandleIndex
= 0;
2774 ChildControllerHandleIndex
< ChildControllerHandleCount
;
2775 ChildControllerHandleIndex
++
2777 for (HandleIndex
= 0; HandleIndex
< *MatchingHandleCount
; HandleIndex
++) {
2778 if (HandleBufferForReturn
[HandleIndex
] == ChildControllerHandleBuffer
[ChildControllerHandleIndex
]) {
2782 if (HandleIndex
>= *MatchingHandleCount
) {
2783 HandleBufferForReturn
[(*MatchingHandleCount
)++] = ChildControllerHandleBuffer
[ChildControllerHandleIndex
];
2787 FreePool (ChildControllerHandleBuffer
);
2790 FreePool (DriverBindingHandleBuffer
);
2792 if (MatchingHandleBuffer
!= NULL
) {
2793 *MatchingHandleBuffer
= HandleBufferForReturn
;
2795 FreePool(HandleBufferForReturn
);
2798 return (EFI_SUCCESS
);
2802 Appends 1 buffer to another buffer. This will re-allocate the destination buffer
2803 if necessary to fit all of the data.
2805 If DestinationBuffer is NULL, then ASSERT().
2807 @param[in, out] DestinationBuffer The pointer to the pointer to the buffer to append onto.
2808 @param[in, out] DestinationSize The pointer to the size of DestinationBuffer.
2809 @param[in] SourceBuffer The pointer to the buffer to append onto DestinationBuffer.
2810 @param[in] SourceSize The number of bytes of SourceBuffer to append.
2812 @retval NULL A memory allocation failed.
2813 @retval NULL A parameter was invalid.
2814 @return A pointer to (*DestinationBuffer).
2819 IN OUT VOID
**DestinationBuffer
,
2820 IN OUT UINTN
*DestinationSize
,
2821 IN VOID
*SourceBuffer
,
2825 UINTN LocalDestinationSize
;
2826 UINTN LocalDestinationFinalSize
;
2828 ASSERT(DestinationBuffer
!= NULL
);
2830 if (SourceSize
== 0 || SourceBuffer
== NULL
) {
2831 return (*DestinationBuffer
);
2834 if (DestinationSize
== NULL
) {
2835 LocalDestinationSize
= 0;
2837 LocalDestinationSize
= *DestinationSize
;
2840 LocalDestinationFinalSize
= LocalDestinationSize
+ SourceSize
;
2842 if (DestinationSize
!= NULL
) {
2843 *DestinationSize
= LocalDestinationSize
;
2846 if (LocalDestinationSize
== 0) {
2848 *DestinationBuffer
= AllocateZeroPool(LocalDestinationFinalSize
);
2851 *DestinationBuffer
= ReallocatePool(LocalDestinationSize
, LocalDestinationFinalSize
, *DestinationBuffer
);
2854 ASSERT(*DestinationBuffer
!= NULL
);
2857 return (CopyMem(((UINT8
*)(*DestinationBuffer
)) + LocalDestinationSize
, SourceBuffer
, SourceSize
));
2861 Gets handles for any child devices produced by the passed in driver.
2863 @param[in] DriverHandle The handle of the driver.
2864 @param[in] MatchingHandleCount Pointer to the number of handles in
2865 MatchingHandleBuffer on return.
2866 @param[out] MatchingHandleBuffer Buffer containing handles on a successful
2868 @retval EFI_SUCCESS The operation was sucessful.
2869 @sa ParseHandleDatabaseByRelationship
2873 ParseHandleDatabaseForChildDevices(
2874 IN CONST EFI_HANDLE DriverHandle
,
2875 IN UINTN
*MatchingHandleCount
,
2876 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
2880 EFI_HANDLE
*Buffer2
;
2885 UINTN HandleBufferSize
;
2887 ASSERT(MatchingHandleCount
!= NULL
);
2889 HandleBufferSize
= 0;
2892 *MatchingHandleCount
= 0;
2894 Status
= PARSE_HANDLE_DATABASE_DEVICES (
2899 if (!EFI_ERROR (Status
)) {
2900 for (HandleIndex
= 0; HandleIndex
< Count1
; HandleIndex
++) {
2902 // now find the children
2904 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
2906 Buffer
[HandleIndex
],
2910 if (EFI_ERROR(Status
)) {
2914 // save out required and optional data elements
2916 *MatchingHandleCount
+= Count2
;
2917 if (MatchingHandleBuffer
!= NULL
) {
2918 *MatchingHandleBuffer
= BuffernCatGrow((VOID
**)MatchingHandleBuffer
, &HandleBufferSize
, Buffer2
, Count2
* sizeof(Buffer2
[0]));
2924 if (Buffer2
!= NULL
) {
2930 if (Buffer
!= NULL
) {
2937 Function to get all handles that support a given protocol or all handles.
2939 @param[in] ProtocolGuid The guid of the protocol to get handles for. If NULL
2940 then the function will return all handles.
2942 @retval NULL A memory allocation failed.
2943 @return A NULL terminated list of handles.
2947 GetHandleListByProtocol (
2948 IN CONST EFI_GUID
*ProtocolGuid OPTIONAL
2951 EFI_HANDLE
*HandleList
;
2959 // We cannot use LocateHandleBuffer since we need that NULL item on the ends of the list!
2961 if (ProtocolGuid
== NULL
) {
2962 Status
= gBS
->LocateHandle(AllHandles
, NULL
, NULL
, &Size
, HandleList
);
2963 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2964 HandleList
= AllocateZeroPool(Size
+ sizeof(EFI_HANDLE
));
2965 if (HandleList
== NULL
) {
2968 Status
= gBS
->LocateHandle(AllHandles
, NULL
, NULL
, &Size
, HandleList
);
2969 HandleList
[Size
/sizeof(EFI_HANDLE
)] = NULL
;
2972 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)ProtocolGuid
, NULL
, &Size
, HandleList
);
2973 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2974 HandleList
= AllocateZeroPool(Size
+ sizeof(EFI_HANDLE
));
2975 if (HandleList
== NULL
) {
2978 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)ProtocolGuid
, NULL
, &Size
, HandleList
);
2979 HandleList
[Size
/sizeof(EFI_HANDLE
)] = NULL
;
2982 if (EFI_ERROR(Status
)) {
2983 if (HandleList
!= NULL
) {
2984 FreePool(HandleList
);
2988 return (HandleList
);
2992 Function to get all handles that support some protocols.
2994 @param[in] ProtocolGuids A NULL terminated list of protocol GUIDs.
2996 @retval NULL A memory allocation failed.
2997 @retval NULL ProtocolGuids was NULL.
2998 @return A NULL terminated list of EFI_HANDLEs.
3002 GetHandleListByProtocolList (
3003 IN CONST EFI_GUID
**ProtocolGuids
3006 EFI_HANDLE
*HandleList
;
3011 CONST EFI_GUID
**GuidWalker
;
3012 EFI_HANDLE
*HandleWalker1
;
3013 EFI_HANDLE
*HandleWalker2
;
3017 TotalSize
= sizeof(EFI_HANDLE
);
3019 for (GuidWalker
= ProtocolGuids
; GuidWalker
!= NULL
&& *GuidWalker
!= NULL
; GuidWalker
++,Size
= 0){
3020 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)(*GuidWalker
), NULL
, &Size
, NULL
);
3021 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3027 // No handles were found...
3029 if (TotalSize
== sizeof(EFI_HANDLE
)) {
3033 HandleList
= AllocateZeroPool(TotalSize
);
3034 if (HandleList
== NULL
) {
3039 for (GuidWalker
= ProtocolGuids
; GuidWalker
!= NULL
&& *GuidWalker
!= NULL
; GuidWalker
++){
3040 TempSize
= TotalSize
- Size
;
3041 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)(*GuidWalker
), NULL
, &TempSize
, HandleList
+(Size
/sizeof(EFI_HANDLE
)));
3044 // Allow for missing protocols... Only update the 'used' size upon success.
3046 if (!EFI_ERROR(Status
)) {
3050 ASSERT(HandleList
[(TotalSize
/sizeof(EFI_HANDLE
))-1] == NULL
);
3052 for (HandleWalker1
= HandleList
; HandleWalker1
!= NULL
&& *HandleWalker1
!= NULL
; HandleWalker1
++) {
3053 for (HandleWalker2
= HandleWalker1
+ 1; HandleWalker2
!= NULL
&& *HandleWalker2
!= NULL
; HandleWalker2
++) {
3054 if (*HandleWalker1
== *HandleWalker2
) {
3056 // copy memory back 1 handle width.
3058 CopyMem(HandleWalker2
, HandleWalker2
+ 1, TotalSize
- ((HandleWalker2
-HandleList
+1)*sizeof(EFI_HANDLE
)));
3063 return (HandleList
);