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 TempRetVal
= CatSPrint (RetVal
, Temp
);
307 SHELL_FREE_NON_NULL (RetVal
);
309 SHELL_FREE_NON_NULL (Temp
);
311 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_GOP_RES_LIST_ENTRY
), NULL
);
313 for (Mode
= 0; Mode
< GraphicsOutput
->Mode
->MaxMode
; Mode
++) {
314 Status
= GraphicsOutput
->QueryMode (
320 if (EFI_ERROR (Status
)) {
324 TempRetVal
= CatSPrint (
328 GopInfo
->HorizontalResolution
,
329 GopInfo
->VerticalResolution
332 SHELL_FREE_NON_NULL (GopInfo
);
333 SHELL_FREE_NON_NULL (RetVal
);
337 SHELL_FREE_NON_NULL(Temp
);
338 SHELL_FREE_NON_NULL(Fmt
);
344 Function to dump information about EDID Discovered Protocol.
346 This will allocate the return buffer from boot services pool.
348 @param[in] TheHandle The handle that has LoadedImage installed.
349 @param[in] Verbose TRUE for additional information, FALSE otherwise.
351 @retval A pointer to a string containing the information.
355 EdidDiscoveredProtocolDumpInformation (
356 IN CONST EFI_HANDLE TheHandle
,
357 IN CONST BOOLEAN Verbose
360 EFI_EDID_DISCOVERED_PROTOCOL
*EdidDiscovered
;
367 return (CatSPrint (NULL
, L
"EDIDDiscovered"));
370 Status
= gBS
->OpenProtocol (
372 &gEfiEdidDiscoveredProtocolGuid
,
373 (VOID
**)&EdidDiscovered
,
376 EFI_OPEN_PROTOCOL_GET_PROTOCOL
379 if (EFI_ERROR (Status
)) {
383 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_DISCOVERED_MAIN
), NULL
);
388 RetVal
= CatSPrint (NULL
, Temp
, EdidDiscovered
->SizeOfEdid
);
389 SHELL_FREE_NON_NULL (Temp
);
391 if (EdidDiscovered
->SizeOfEdid
!= 0) {
392 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_DISCOVERED_DATA
), NULL
);
394 SHELL_FREE_NON_NULL (RetVal
);
397 TempRetVal
= CatSPrint (RetVal
, Temp
);
398 SHELL_FREE_NON_NULL (RetVal
);
401 TempRetVal
= CatSDumpHex (RetVal
, 7, 0, EdidDiscovered
->SizeOfEdid
, EdidDiscovered
->Edid
);
408 Function to dump information about EDID Active Protocol.
410 This will allocate the return buffer from boot services pool.
412 @param[in] TheHandle The handle that has LoadedImage installed.
413 @param[in] Verbose TRUE for additional information, FALSE otherwise.
415 @retval A pointer to a string containing the information.
419 EdidActiveProtocolDumpInformation (
420 IN CONST EFI_HANDLE TheHandle
,
421 IN CONST BOOLEAN Verbose
424 EFI_EDID_ACTIVE_PROTOCOL
*EdidActive
;
431 return (CatSPrint (NULL
, L
"EDIDActive"));
434 Status
= gBS
->OpenProtocol (
436 &gEfiEdidActiveProtocolGuid
,
440 EFI_OPEN_PROTOCOL_GET_PROTOCOL
443 if (EFI_ERROR (Status
)) {
447 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_ACTIVE_MAIN
), NULL
);
452 RetVal
= CatSPrint (NULL
, Temp
, EdidActive
->SizeOfEdid
);
453 SHELL_FREE_NON_NULL (Temp
);
455 if (EdidActive
->SizeOfEdid
!= 0) {
456 Temp
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN (STR_EDID_ACTIVE_DATA
), NULL
);
458 SHELL_FREE_NON_NULL (RetVal
);
461 TempRetVal
= CatSPrint (RetVal
, Temp
);
462 SHELL_FREE_NON_NULL (RetVal
);
465 TempRetVal
= CatSDumpHex (RetVal
, 7, 0, EdidActive
->SizeOfEdid
, EdidActive
->Edid
);
472 Function to dump information about PciRootBridgeIo.
474 This will allocate the return buffer from boot services pool.
476 @param[in] TheHandle The handle that has PciRootBridgeIo installed.
477 @param[in] Verbose TRUE for additional information, FALSE otherwise.
479 @retval A poitner to a string containing the information.
483 PciRootBridgeIoDumpInformation(
484 IN CONST EFI_HANDLE TheHandle
,
485 IN CONST BOOLEAN Verbose
488 EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL
*PciRootBridgeIo
;
489 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR
*Configuration
;
500 return (CatSPrint(NULL
, L
"PciRootBridgeIo"));
503 HandleParsingHiiInit();
505 Status
= gBS
->HandleProtocol(
507 &gEfiPciRootBridgeIoProtocolGuid
,
508 (VOID
**)&PciRootBridgeIo
);
510 if (EFI_ERROR(Status
)) {
514 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_PH
), NULL
);
518 Temp2
= CatSPrint(L
"\r\n", Temp
, PciRootBridgeIo
->ParentHandle
);
523 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_SEG
), NULL
);
525 SHELL_FREE_NON_NULL(RetVal
);
528 Temp2
= CatSPrint(RetVal
, Temp
, PciRootBridgeIo
->SegmentNumber
);
536 Status
= PciRootBridgeIo
->GetAttributes (PciRootBridgeIo
, &Supports
, &Attributes
);
537 if (!EFI_ERROR(Status
)) {
538 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_ATT
), NULL
);
540 SHELL_FREE_NON_NULL(RetVal
);
543 Temp2
= CatSPrint(RetVal
, Temp
, Attributes
);
549 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_SUPPORTS
), NULL
);
551 SHELL_FREE_NON_NULL(RetVal
);
554 Temp2
= CatSPrint(RetVal
, Temp
, Supports
);
561 Configuration
= NULL
;
562 Status
= PciRootBridgeIo
->Configuration (PciRootBridgeIo
, (VOID
**) &Configuration
);
563 if (!EFI_ERROR(Status
) && Configuration
!= NULL
) {
564 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_TITLE
), NULL
);
566 SHELL_FREE_NON_NULL(RetVal
);
569 Temp2
= CatSPrint(RetVal
, Temp
, Supports
);
574 while (Configuration
->Desc
== ACPI_ADDRESS_SPACE_DESCRIPTOR
) {
576 switch (Configuration
->ResType
) {
577 case ACPI_ADDRESS_SPACE_TYPE_MEM
:
578 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_MEM
), NULL
);
580 case ACPI_ADDRESS_SPACE_TYPE_IO
:
581 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_IO
), NULL
);
583 case ACPI_ADDRESS_SPACE_TYPE_BUS
:
584 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_PCIRB_DUMP_BUS
), NULL
);
588 Temp2
= CatSPrint(RetVal
, L
"%s", Temp
);
595 Temp2
= CatSPrint(RetVal
,
596 L
"%H%02x %016lx %016lx %02x%N\r\n",
597 Configuration
->SpecificFlag
,
598 Configuration
->AddrRangeMin
,
599 Configuration
->AddrRangeMax
,
600 Configuration
->AddrSpaceGranularity
612 Function to dump information about SimpleTextOut.
614 This will allocate the return buffer from boot services pool.
616 @param[in] TheHandle The handle that has SimpleTextOut installed.
617 @param[in] Verbose TRUE for additional information, FALSE otherwise.
619 @retval A poitner to a string containing the information.
623 TxtOutProtocolDumpInformation(
624 IN CONST EFI_HANDLE TheHandle
,
625 IN CONST BOOLEAN Verbose
628 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL
*Dev
;
642 HandleParsingHiiInit();
647 Status
= gBS
->HandleProtocol(
649 &gEfiSimpleTextOutProtocolGuid
,
652 ASSERT_EFI_ERROR(Status
);
653 ASSERT (Dev
!= NULL
&& Dev
->Mode
!= NULL
);
655 Size
= (Dev
->Mode
->MaxMode
+ 1) * 80;
656 RetVal
= AllocateZeroPool(Size
);
658 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_TXT_OUT_DUMP_HEADER
), NULL
);
660 UnicodeSPrint(RetVal
, Size
, Temp
, Dev
, Dev
->Mode
->Attribute
);
667 Temp
= HiiGetString(mHandleParsingHiiHandle
, STRING_TOKEN(STR_TXT_OUT_DUMP_LINE
), NULL
);
668 for (Index
= 0; Index
< Dev
->Mode
->MaxMode
; Index
++) {
669 Status
= Dev
->QueryMode (Dev
, Index
, &Col
, &Row
);
670 NewSize
= Size
- StrSize(RetVal
);
672 RetVal
+ StrLen(RetVal
),
674 Temp
== NULL
?L
"":Temp
,
675 Index
== Dev
->Mode
->Mode
? L
'*' : L
' ',
677 !EFI_ERROR(Status
)?(INTN
)Col
:-1,
678 !EFI_ERROR(Status
)?(INTN
)Row
:-1
685 STATIC CONST UINTN VersionStringSize
= 60;
688 Function to dump information about EfiDriverSupportedEfiVersion protocol.
690 This will allocate the return buffer from boot services pool.
692 @param[in] TheHandle The handle that has the protocol installed.
693 @param[in] Verbose TRUE for additional information, FALSE otherwise.
695 @retval A poitner to a string containing the information.
699 DriverEfiVersionProtocolDumpInformation(
700 IN CONST EFI_HANDLE TheHandle
,
701 IN CONST BOOLEAN Verbose
704 EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL
*DriverEfiVersion
;
708 Status
= gBS
->HandleProtocol(
710 &gEfiDriverSupportedEfiVersionProtocolGuid
,
711 (VOID
**)&DriverEfiVersion
);
713 ASSERT_EFI_ERROR(Status
);
715 RetVal
= AllocateZeroPool(VersionStringSize
);
716 ASSERT(RetVal
!= NULL
);
717 UnicodeSPrint(RetVal
, VersionStringSize
, L
"0x%08x", DriverEfiVersion
->FirmwareVersion
);
722 Function to dump information about DevicePath protocol.
724 This will allocate the return buffer from boot services pool.
726 @param[in] TheHandle The handle that has the protocol installed.
727 @param[in] Verbose TRUE for additional information, FALSE otherwise.
729 @retval A poitner to a string containing the information.
733 DevicePathProtocolDumpInformation(
734 IN CONST EFI_HANDLE TheHandle
,
735 IN CONST BOOLEAN Verbose
738 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
744 Status
= gBS
->OpenProtocol(TheHandle
, &gEfiDevicePathProtocolGuid
, (VOID
**)&DevPath
, gImageHandle
, NULL
, EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
745 if (!EFI_ERROR(Status
)) {
747 // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)
749 Temp
= ConvertDevicePathToText(DevPath
, TRUE
, TRUE
);
750 gBS
->CloseProtocol(TheHandle
, &gEfiDevicePathProtocolGuid
, gImageHandle
, NULL
);
752 if (!Verbose
&& Temp
!= NULL
&& StrLen(Temp
) > 30) {
754 Temp2
= StrnCatGrow(&Temp2
, NULL
, Temp
+(StrLen(Temp
) - 30), 30);
762 Function to dump information about EfiAdapterInformation Protocol.
764 @param[in] TheHandle The handle that has the protocol installed.
765 @param[in] Verbose TRUE for additional information, FALSE otherwise.
767 @retval A pointer to a string containing the information.
771 AdapterInformationDumpInformation (
772 IN CONST EFI_HANDLE TheHandle
,
773 IN CONST BOOLEAN Verbose
777 EFI_ADAPTER_INFORMATION_PROTOCOL
*EfiAdptrInfoProtocol
;
778 UINTN InfoTypesBufferCount
;
780 EFI_GUID
*InfoTypesBuffer
;
785 VOID
*InformationBlock
;
786 UINTN InformationBlockSize
;
789 return (CatSPrint(NULL
, L
"AdapterInfo"));
792 InfoTypesBuffer
= NULL
;
793 InformationBlock
= NULL
;
796 Status
= gBS
->OpenProtocol (
797 (EFI_HANDLE
) (TheHandle
),
798 &gEfiAdapterInformationProtocolGuid
,
799 (VOID
**) &EfiAdptrInfoProtocol
,
802 EFI_OPEN_PROTOCOL_GET_PROTOCOL
805 if (EFI_ERROR (Status
)) {
810 // Get a list of supported information types for this instance of the protocol.
812 Status
= EfiAdptrInfoProtocol
->GetSupportedTypes (
813 EfiAdptrInfoProtocol
,
815 &InfoTypesBufferCount
818 if (EFI_ERROR (Status
)) {
819 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GET_SUPP_TYPES_FAILED
), NULL
);
820 if (TempStr
!= NULL
) {
821 RetVal
= CatSPrint (NULL
, TempStr
, Status
);
826 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_SUPP_TYPE_HEADER
), NULL
);
827 if (TempStr
== NULL
) {
830 RetVal
= CatSPrint (NULL
, TempStr
);
831 SHELL_FREE_NON_NULL (TempStr
);
833 for (GuidIndex
= 0; GuidIndex
< InfoTypesBufferCount
; GuidIndex
++) {
834 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GUID_NUMBER
), NULL
);
835 if (TempStr
== NULL
) {
838 TempRetVal
= CatSPrint (RetVal
, TempStr
, (GuidIndex
+ 1), &InfoTypesBuffer
[GuidIndex
]);
839 SHELL_FREE_NON_NULL (RetVal
);
841 SHELL_FREE_NON_NULL (TempStr
);
843 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GUID_STRING
), NULL
);
844 if (TempStr
== NULL
) {
848 if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoMediaStateGuid
)) {
849 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoMediaStateGuid");
850 SHELL_FREE_NON_NULL (RetVal
);
852 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoNetworkBootGuid
)) {
853 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoNetworkBootGuid");
854 SHELL_FREE_NON_NULL (RetVal
);
856 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoSanMacAddressGuid
)) {
857 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoSanMacAddressGuid");
858 SHELL_FREE_NON_NULL (RetVal
);
860 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoUndiIpv6SupportGuid
)) {
861 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"gEfiAdapterInfoUndiIpv6SupportGuid");
862 SHELL_FREE_NON_NULL (RetVal
);
866 GuidStr
= GetStringNameFromGuid (&InfoTypesBuffer
[GuidIndex
], NULL
);
868 if (GuidStr
!= NULL
) {
869 if (StrCmp(GuidStr
, L
"UnknownDevice") == 0) {
870 TempRetVal
= CatSPrint (RetVal
, TempStr
, L
"UnknownInfoType");
871 SHELL_FREE_NON_NULL (RetVal
);
874 SHELL_FREE_NON_NULL (TempStr
);
875 SHELL_FREE_NON_NULL(GuidStr
);
877 // So that we never have to pass this UnknownInfoType to the parsing function "GetInformation" service of AIP
881 TempRetVal
= CatSPrint (RetVal
, TempStr
, GuidStr
);
882 SHELL_FREE_NON_NULL (RetVal
);
884 SHELL_FREE_NON_NULL(GuidStr
);
889 SHELL_FREE_NON_NULL (TempStr
);
891 Status
= EfiAdptrInfoProtocol
->GetInformation (
892 EfiAdptrInfoProtocol
,
893 &InfoTypesBuffer
[GuidIndex
],
895 &InformationBlockSize
898 if (EFI_ERROR (Status
)) {
899 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_GETINFO_FAILED
), NULL
);
900 if (TempStr
== NULL
) {
903 TempRetVal
= CatSPrint (RetVal
, TempStr
, Status
);
904 SHELL_FREE_NON_NULL (RetVal
);
907 if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoMediaStateGuid
)) {
908 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_MEDIA_STATE
), NULL
);
909 if (TempStr
== NULL
) {
912 TempRetVal
= CatSPrint (
915 ((EFI_ADAPTER_INFO_MEDIA_STATE
*)InformationBlock
)->MediaState
,
916 ((EFI_ADAPTER_INFO_MEDIA_STATE
*)InformationBlock
)->MediaState
918 SHELL_FREE_NON_NULL (RetVal
);
920 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoNetworkBootGuid
)) {
921 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_NETWORK_BOOT_INFO
), NULL
);
922 if (TempStr
== NULL
) {
925 TempRetVal
= CatSPrint (
928 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv4BootCapablity
,
929 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv6BootCapablity
,
930 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->FCoeBootCapablity
,
931 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->OffloadCapability
,
932 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiMpioCapability
,
933 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv4Boot
,
934 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->iScsiIpv6Boot
,
935 ((EFI_ADAPTER_INFO_NETWORK_BOOT
*)InformationBlock
)->FCoeBoot
937 SHELL_FREE_NON_NULL (RetVal
);
939 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoSanMacAddressGuid
) == TRUE
) {
940 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_SAN_MAC_ADDRESS_INFO
), NULL
);
941 if (TempStr
== NULL
) {
944 TempRetVal
= CatSPrint (
947 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[0],
948 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[1],
949 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[2],
950 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[3],
951 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[4],
952 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS
*)InformationBlock
)->SanMacAddress
.Addr
[5]
954 SHELL_FREE_NON_NULL (RetVal
);
956 } else if (CompareGuid (&InfoTypesBuffer
[GuidIndex
], &gEfiAdapterInfoUndiIpv6SupportGuid
) == TRUE
) {
957 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_UNDI_IPV6_INFO
), NULL
);
958 if (TempStr
== NULL
) {
962 TempRetVal
= CatSPrint (
965 ((EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT
*)InformationBlock
)->Ipv6Support
967 SHELL_FREE_NON_NULL (RetVal
);
970 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_UNKNOWN_INFO_TYPE
), NULL
);
971 if (TempStr
== NULL
) {
974 TempRetVal
= CatSPrint (RetVal
, TempStr
, &InfoTypesBuffer
[GuidIndex
]);
975 SHELL_FREE_NON_NULL (RetVal
);
979 SHELL_FREE_NON_NULL (TempStr
);
980 SHELL_FREE_NON_NULL (InformationBlock
);
984 SHELL_FREE_NON_NULL (InfoTypesBuffer
);
988 SHELL_FREE_NON_NULL (RetVal
);
989 SHELL_FREE_NON_NULL (InfoTypesBuffer
);
990 SHELL_FREE_NON_NULL (InformationBlock
);
995 Function to dump information about EFI_FIRMWARE_MANAGEMENT_PROTOCOL Protocol.
997 @param[in] TheHandle The handle that has the protocol installed.
998 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1000 @retval A pointer to a string containing the information.
1004 FirmwareManagementDumpInformation (
1005 IN CONST EFI_HANDLE TheHandle
,
1006 IN CONST BOOLEAN Verbose
1010 EFI_FIRMWARE_MANAGEMENT_PROTOCOL
*EfiFwMgmtProtocol
;
1011 EFI_FIRMWARE_IMAGE_DESCRIPTOR
*ImageInfo
;
1012 EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1
*ImageInfoV1
;
1013 EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2
*ImageInfoV2
;
1014 UINT64 AttributeSetting
;
1015 UINTN ImageInfoSize
;
1016 UINTN DescriptorSize
;
1017 UINT32 DescriptorVersion
;
1018 UINT32 PackageVersion
;
1019 UINT8 DescriptorCount
;
1023 CHAR16
*PackageVersionName
;
1027 CHAR16
*AttributeSettingStr
;
1029 BOOLEAN AttributeSupported
;
1032 // Initialize local variables
1036 AttributeSetting
= 0;
1038 AttributeSupported
= FALSE
;
1042 PackageVersionName
= NULL
;
1046 AttributeSettingStr
= NULL
;
1049 return (CatSPrint(NULL
, L
"FirmwareManagement"));
1052 Status
= gBS
->OpenProtocol (
1053 (EFI_HANDLE
) (TheHandle
),
1054 &gEfiFirmwareManagementProtocolGuid
,
1055 (VOID
**) &EfiFwMgmtProtocol
,
1058 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1061 if (EFI_ERROR (Status
)) {
1065 Status
= EfiFwMgmtProtocol
->GetImageInfo (
1076 if (Status
== EFI_BUFFER_TOO_SMALL
) {
1077 ImageInfo
= AllocateZeroPool (ImageInfoSize
);
1079 if (ImageInfo
== NULL
) {
1080 Status
= EFI_OUT_OF_RESOURCES
;
1082 Status
= EfiFwMgmtProtocol
->GetImageInfo (
1095 if (EFI_ERROR (Status
)) {
1100 // Decode Image Descriptor data only if its version is supported
1102 if (DescriptorVersion
<= EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION
) {
1104 if (ImageInfo
== NULL
) {
1108 ImageInfoV1
= (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1
*)ImageInfo
;
1109 ImageInfoV2
= (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2
*)ImageInfo
;
1112 // Set ImageInfoSize in return buffer
1114 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_INFO_SIZE
), NULL
);
1115 if (TempStr
== NULL
) {
1118 RetVal
= CatSPrint (NULL
, TempStr
, ImageInfoSize
);
1119 SHELL_FREE_NON_NULL (TempStr
);
1122 // Set DescriptorVersion in return buffer
1124 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_DESCRIPTOR_VERSION
), NULL
);
1125 if (TempStr
== NULL
) {
1128 TempRetVal
= CatSPrint (RetVal
, TempStr
, DescriptorVersion
);
1129 SHELL_FREE_NON_NULL (RetVal
);
1130 RetVal
= TempRetVal
;
1131 SHELL_FREE_NON_NULL (TempStr
);
1134 // Set DescriptorCount in return buffer
1136 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_DESCRIPTOR_COUNT
), NULL
);
1137 if (TempStr
== NULL
) {
1140 TempRetVal
= CatSPrint (RetVal
, TempStr
, DescriptorCount
);
1141 SHELL_FREE_NON_NULL (RetVal
);
1142 RetVal
= TempRetVal
;
1143 SHELL_FREE_NON_NULL (TempStr
);
1147 // Set DescriptorSize in return buffer
1149 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_DESCRIPTOR_SIZE
), NULL
);
1150 if (TempStr
== NULL
) {
1153 TempRetVal
= CatSPrint (RetVal
, TempStr
, DescriptorSize
);
1154 SHELL_FREE_NON_NULL (RetVal
);
1155 RetVal
= TempRetVal
;
1156 SHELL_FREE_NON_NULL (TempStr
);
1159 // Set PackageVersion in return buffer
1161 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_PACKAGE_VERSION
), NULL
);
1162 if (TempStr
== NULL
) {
1165 TempRetVal
= CatSPrint (RetVal
, TempStr
, PackageVersion
);
1166 SHELL_FREE_NON_NULL (RetVal
);
1167 RetVal
= TempRetVal
;
1168 SHELL_FREE_NON_NULL (TempStr
);
1171 // Set PackageVersionName in return buffer
1173 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_PACKAGE_VERSION_NAME
), NULL
);
1174 if (TempStr
== NULL
) {
1177 TempRetVal
= CatSPrint (RetVal
, TempStr
, PackageVersionName
);
1178 SHELL_FREE_NON_NULL (RetVal
);
1179 RetVal
= TempRetVal
;
1180 SHELL_FREE_NON_NULL (TempStr
);
1182 for (Index
= 0; Index
< DescriptorCount
; Index
++) {
1184 // First check if Attribute is supported
1185 // and generate a string for AttributeSetting field
1187 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1188 AttributeSupported
= FALSE
;
1189 AttributeSetting
= 0;
1190 if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1
) {
1191 if (ImageInfoV1
[Index
].AttributesSupported
!= 0x0) {
1192 AttributeSupported
= TRUE
;
1193 AttributeSetting
= ImageInfoV1
[Index
].AttributesSetting
;
1195 } else if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2
) {
1196 if (ImageInfoV2
[Index
].AttributesSupported
!= 0x0) {
1197 AttributeSupported
= TRUE
;
1198 AttributeSetting
= ImageInfoV2
[Index
].AttributesSetting
;
1201 if (ImageInfo
[Index
].AttributesSupported
!= 0x0) {
1202 AttributeSupported
= TRUE
;
1203 AttributeSetting
= ImageInfo
[Index
].AttributesSetting
;
1207 if (!AttributeSupported
) {
1208 AttributeSettingStr
= CatSPrint (NULL
, L
"None");
1210 AttributeSettingStr
= CatSPrint (NULL
, L
"(");
1212 if ((AttributeSetting
& IMAGE_ATTRIBUTE_IMAGE_UPDATABLE
) != 0x0) {
1213 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_IMAGE_UPDATABLE");
1214 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1215 AttributeSettingStr
= TempRetVal
;
1217 if ((AttributeSetting
& IMAGE_ATTRIBUTE_RESET_REQUIRED
) != 0x0) {
1218 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_RESET_REQUIRED");
1219 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1220 AttributeSettingStr
= TempRetVal
;
1222 if ((AttributeSetting
& IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED
) != 0x0) {
1223 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED");
1224 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1225 AttributeSettingStr
= TempRetVal
;
1227 if ((AttributeSetting
& IMAGE_ATTRIBUTE_IN_USE
) != 0x0) {
1228 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_IN_USE");
1229 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1230 AttributeSettingStr
= TempRetVal
;
1232 if ((AttributeSetting
& IMAGE_ATTRIBUTE_UEFI_IMAGE
) != 0x0) {
1233 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" IMAGE_ATTRIBUTE_UEFI_IMAGE");
1234 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1235 AttributeSettingStr
= TempRetVal
;
1237 TempRetVal
= CatSPrint (AttributeSettingStr
, L
" )");
1238 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1239 AttributeSettingStr
= TempRetVal
;
1242 if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1
) {
1243 if (ImageInfoV1
[Index
].ImageIndex
!= 0x0) {
1247 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V1
), NULL
);
1248 if (TempStr
== NULL
) {
1251 TempRetVal
= CatSPrint (
1255 ImageInfoV1
[Index
].ImageIndex
,
1256 ImageInfoV1
[Index
].ImageTypeId
,
1257 ImageInfoV1
[Index
].ImageId
,
1258 ImageInfoV1
[Index
].ImageIdName
,
1259 ImageInfoV1
[Index
].Version
,
1260 ImageInfoV1
[Index
].VersionName
,
1261 ImageInfoV1
[Index
].Size
,
1262 ImageInfoV1
[Index
].AttributesSupported
,
1263 AttributeSettingStr
,
1264 ImageInfoV1
[Index
].Compatibilities
1266 SHELL_FREE_NON_NULL (RetVal
);
1267 RetVal
= TempRetVal
;
1268 SHELL_FREE_NON_NULL (TempStr
);
1269 } else if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2
) {
1270 if (ImageInfoV2
[Index
].ImageIndex
!= 0x0) {
1274 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V2
), NULL
);
1275 if (TempStr
== NULL
) {
1278 TempRetVal
= CatSPrint (
1282 ImageInfoV2
[Index
].ImageIndex
,
1283 ImageInfoV2
[Index
].ImageTypeId
,
1284 ImageInfoV2
[Index
].ImageId
,
1285 ImageInfoV2
[Index
].ImageIdName
,
1286 ImageInfoV2
[Index
].Version
,
1287 ImageInfoV2
[Index
].VersionName
,
1288 ImageInfoV2
[Index
].Size
,
1289 ImageInfoV2
[Index
].AttributesSupported
,
1290 AttributeSettingStr
,
1291 ImageInfoV2
[Index
].Compatibilities
,
1292 ImageInfoV2
[Index
].LowestSupportedImageVersion
1294 SHELL_FREE_NON_NULL (RetVal
);
1295 RetVal
= TempRetVal
;
1296 SHELL_FREE_NON_NULL (TempStr
);
1298 if (ImageInfo
[Index
].ImageIndex
!= 0x0) {
1302 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO
), NULL
);
1303 if (TempStr
== NULL
) {
1306 TempRetVal
= CatSPrint (
1310 ImageInfo
[Index
].ImageIndex
,
1311 ImageInfo
[Index
].ImageTypeId
,
1312 ImageInfo
[Index
].ImageId
,
1313 ImageInfo
[Index
].ImageIdName
,
1314 ImageInfo
[Index
].Version
,
1315 ImageInfo
[Index
].VersionName
,
1316 ImageInfo
[Index
].Size
,
1317 ImageInfo
[Index
].AttributesSupported
,
1318 AttributeSettingStr
,
1319 ImageInfo
[Index
].Compatibilities
,
1320 ImageInfo
[Index
].LowestSupportedImageVersion
,
1321 ImageInfo
[Index
].LastAttemptVersion
,
1322 ImageInfo
[Index
].LastAttemptStatus
,
1323 ImageInfo
[Index
].HardwareInstance
1325 SHELL_FREE_NON_NULL (RetVal
);
1326 RetVal
= TempRetVal
;
1327 SHELL_FREE_NON_NULL (TempStr
);
1332 if (ImageCount
> 0) {
1333 for (Index
=0; Index
<DescriptorCount
; Index
++) {
1334 for (Index1
=Index
+1; Index1
<DescriptorCount
; Index1
++) {
1335 if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1
) {
1336 if (ImageInfoV1
[Index
].ImageId
== ImageInfoV1
[Index1
].ImageId
) {
1339 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1343 } else if (DescriptorVersion
== EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2
) {
1344 if (ImageInfoV2
[Index
].ImageId
== ImageInfoV2
[Index1
].ImageId
) {
1347 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1352 if (ImageInfo
[Index
].ImageId
== ImageInfo
[Index1
].ImageId
) {
1355 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1366 // Check if ImageId with duplicate value was found
1369 TempStr
= HiiGetString (mHandleParsingHiiHandle
, STRING_TOKEN(STR_FMP_IMAGEID_NON_UNIQUE
), NULL
);
1370 if (TempStr
== NULL
) {
1373 TempRetVal
= CatSPrint (RetVal
, TempStr
);
1374 SHELL_FREE_NON_NULL (RetVal
);
1375 RetVal
= TempRetVal
;
1376 SHELL_FREE_NON_NULL (TempStr
);
1379 SHELL_FREE_NON_NULL (ImageInfo
);
1380 SHELL_FREE_NON_NULL (PackageVersionName
);
1381 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1386 SHELL_FREE_NON_NULL (RetVal
);
1387 SHELL_FREE_NON_NULL (ImageInfo
);
1388 SHELL_FREE_NON_NULL (PackageVersionName
);
1389 SHELL_FREE_NON_NULL (AttributeSettingStr
);
1395 // Put the information on the NT32 protocol GUIDs here so we are not dependant on the Nt32Pkg
1397 #define LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID \
1399 0x58c518b1, 0x76f3, 0x11d4, { 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
1402 #define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \
1404 0x96eb4ad6, 0xa32a, 0x11d4, { 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
1407 #define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \
1409 0xc95a93d, 0xa006, 0x11d4, { 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
1411 STATIC CONST EFI_GUID WinNtThunkProtocolGuid
= LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID
;
1412 STATIC CONST EFI_GUID WinNtIoProtocolGuid
= LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID
;
1413 STATIC CONST EFI_GUID WinNtSerialPortGuid
= LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID
;
1416 // Deprecated protocols we dont want to link from IntelFrameworkModulePkg
1418 #define LOCAL_EFI_ISA_IO_PROTOCOL_GUID \
1420 0x7ee2bd44, 0x3da0, 0x11d4, { 0x9a, 0x38, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
1422 #define LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID \
1424 0x64a892dc, 0x5561, 0x4536, { 0x92, 0xc7, 0x79, 0x9b, 0xfc, 0x18, 0x33, 0x55 } \
1426 STATIC CONST EFI_GUID EfiIsaIoProtocolGuid
= LOCAL_EFI_ISA_IO_PROTOCOL_GUID
;
1427 STATIC CONST EFI_GUID EfiIsaAcpiProtocolGuid
= LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID
;
1430 STATIC CONST GUID_INFO_BLOCK mGuidStringListNT
[] = {
1431 {STRING_TOKEN(STR_WINNT_THUNK
), (EFI_GUID
*)&WinNtThunkProtocolGuid
, NULL
},
1432 {STRING_TOKEN(STR_WINNT_DRIVER_IO
), (EFI_GUID
*)&WinNtIoProtocolGuid
, NULL
},
1433 {STRING_TOKEN(STR_WINNT_SERIAL_PORT
), (EFI_GUID
*)&WinNtSerialPortGuid
, NULL
},
1434 {STRING_TOKEN(STR_UNKNOWN_DEVICE
), NULL
, NULL
},
1437 STATIC CONST GUID_INFO_BLOCK mGuidStringList
[] = {
1438 {STRING_TOKEN(STR_LOADED_IMAGE
), &gEfiLoadedImageProtocolGuid
, LoadedImageProtocolDumpInformation
},
1439 {STRING_TOKEN(STR_DEVICE_PATH
), &gEfiDevicePathProtocolGuid
, DevicePathProtocolDumpInformation
},
1440 {STRING_TOKEN(STR_IMAGE_PATH
), &gEfiLoadedImageDevicePathProtocolGuid
, DevicePathProtocolDumpInformation
},
1441 {STRING_TOKEN(STR_DEVICE_PATH_UTIL
), &gEfiDevicePathUtilitiesProtocolGuid
, NULL
},
1442 {STRING_TOKEN(STR_DEVICE_PATH_TXT
), &gEfiDevicePathToTextProtocolGuid
, NULL
},
1443 {STRING_TOKEN(STR_DEVICE_PATH_FTXT
), &gEfiDevicePathFromTextProtocolGuid
, NULL
},
1444 {STRING_TOKEN(STR_DEVICE_PATH_PC
), &gEfiPcAnsiGuid
, NULL
},
1445 {STRING_TOKEN(STR_DEVICE_PATH_VT100
), &gEfiVT100Guid
, NULL
},
1446 {STRING_TOKEN(STR_DEVICE_PATH_VT100P
), &gEfiVT100PlusGuid
, NULL
},
1447 {STRING_TOKEN(STR_DEVICE_PATH_VTUTF8
), &gEfiVTUTF8Guid
, NULL
},
1448 {STRING_TOKEN(STR_DRIVER_BINDING
), &gEfiDriverBindingProtocolGuid
, NULL
},
1449 {STRING_TOKEN(STR_PLATFORM_OVERRIDE
), &gEfiPlatformDriverOverrideProtocolGuid
, NULL
},
1450 {STRING_TOKEN(STR_BUS_OVERRIDE
), &gEfiBusSpecificDriverOverrideProtocolGuid
, NULL
},
1451 {STRING_TOKEN(STR_DRIVER_DIAG
), &gEfiDriverDiagnosticsProtocolGuid
, NULL
},
1452 {STRING_TOKEN(STR_DRIVER_DIAG2
), &gEfiDriverDiagnostics2ProtocolGuid
, NULL
},
1453 {STRING_TOKEN(STR_DRIVER_CN
), &gEfiComponentNameProtocolGuid
, NULL
},
1454 {STRING_TOKEN(STR_DRIVER_CN2
), &gEfiComponentName2ProtocolGuid
, NULL
},
1455 {STRING_TOKEN(STR_PLAT_DRV_CFG
), &gEfiPlatformToDriverConfigurationProtocolGuid
, NULL
},
1456 {STRING_TOKEN(STR_DRIVER_VERSION
), &gEfiDriverSupportedEfiVersionProtocolGuid
, DriverEfiVersionProtocolDumpInformation
},
1457 {STRING_TOKEN(STR_TXT_IN
), &gEfiSimpleTextInProtocolGuid
, NULL
},
1458 {STRING_TOKEN(STR_TXT_IN_EX
), &gEfiSimpleTextInputExProtocolGuid
, NULL
},
1459 {STRING_TOKEN(STR_TXT_OUT
), &gEfiSimpleTextOutProtocolGuid
, TxtOutProtocolDumpInformation
},
1460 {STRING_TOKEN(STR_SIM_POINTER
), &gEfiSimplePointerProtocolGuid
, NULL
},
1461 {STRING_TOKEN(STR_ABS_POINTER
), &gEfiAbsolutePointerProtocolGuid
, NULL
},
1462 {STRING_TOKEN(STR_SERIAL_IO
), &gEfiSerialIoProtocolGuid
, NULL
},
1463 {STRING_TOKEN(STR_GRAPHICS_OUTPUT
), &gEfiGraphicsOutputProtocolGuid
, GraphicsOutputProtocolDumpInformation
},
1464 {STRING_TOKEN(STR_EDID_DISCOVERED
), &gEfiEdidDiscoveredProtocolGuid
, EdidDiscoveredProtocolDumpInformation
},
1465 {STRING_TOKEN(STR_EDID_ACTIVE
), &gEfiEdidActiveProtocolGuid
, EdidActiveProtocolDumpInformation
},
1466 {STRING_TOKEN(STR_EDID_OVERRIDE
), &gEfiEdidOverrideProtocolGuid
, NULL
},
1467 {STRING_TOKEN(STR_CON_IN
), &gEfiConsoleInDeviceGuid
, NULL
},
1468 {STRING_TOKEN(STR_CON_OUT
), &gEfiConsoleOutDeviceGuid
, NULL
},
1469 {STRING_TOKEN(STR_STD_ERR
), &gEfiStandardErrorDeviceGuid
, NULL
},
1470 {STRING_TOKEN(STR_LOAD_FILE
), &gEfiLoadFileProtocolGuid
, NULL
},
1471 {STRING_TOKEN(STR_LOAD_FILE2
), &gEfiLoadFile2ProtocolGuid
, NULL
},
1472 {STRING_TOKEN(STR_SIMPLE_FILE_SYS
), &gEfiSimpleFileSystemProtocolGuid
, NULL
},
1473 {STRING_TOKEN(STR_TAPE_IO
), &gEfiTapeIoProtocolGuid
, NULL
},
1474 {STRING_TOKEN(STR_DISK_IO
), &gEfiDiskIoProtocolGuid
, NULL
},
1475 {STRING_TOKEN(STR_BLK_IO
), &gEfiBlockIoProtocolGuid
, NULL
},
1476 {STRING_TOKEN(STR_UC
), &gEfiUnicodeCollationProtocolGuid
, NULL
},
1477 {STRING_TOKEN(STR_UC2
), &gEfiUnicodeCollation2ProtocolGuid
, NULL
},
1478 {STRING_TOKEN(STR_PCIRB_IO
), &gEfiPciRootBridgeIoProtocolGuid
, PciRootBridgeIoDumpInformation
},
1479 {STRING_TOKEN(STR_PCI_IO
), &gEfiPciIoProtocolGuid
, NULL
},
1480 {STRING_TOKEN(STR_SCSI_PT
), &gEfiScsiPassThruProtocolGuid
, NULL
},
1481 {STRING_TOKEN(STR_SCSI_IO
), &gEfiScsiIoProtocolGuid
, NULL
},
1482 {STRING_TOKEN(STR_SCSI_PT_EXT
), &gEfiExtScsiPassThruProtocolGuid
, NULL
},
1483 {STRING_TOKEN(STR_ISCSI
), &gEfiIScsiInitiatorNameProtocolGuid
, NULL
},
1484 {STRING_TOKEN(STR_USB_IO
), &gEfiUsbIoProtocolGuid
, NULL
},
1485 {STRING_TOKEN(STR_USB_HC
), &gEfiUsbHcProtocolGuid
, NULL
},
1486 {STRING_TOKEN(STR_USB_HC2
), &gEfiUsb2HcProtocolGuid
, NULL
},
1487 {STRING_TOKEN(STR_DEBUG_SUPPORT
), &gEfiDebugSupportProtocolGuid
, NULL
},
1488 {STRING_TOKEN(STR_DEBUG_PORT
), &gEfiDebugPortProtocolGuid
, NULL
},
1489 {STRING_TOKEN(STR_DECOMPRESS
), &gEfiDecompressProtocolGuid
, NULL
},
1490 {STRING_TOKEN(STR_ACPI_TABLE
), &gEfiAcpiTableProtocolGuid
, NULL
},
1491 {STRING_TOKEN(STR_EBC_INTERPRETER
), &gEfiEbcProtocolGuid
, NULL
},
1492 {STRING_TOKEN(STR_SNP
), &gEfiSimpleNetworkProtocolGuid
, NULL
},
1493 {STRING_TOKEN(STR_NII
), &gEfiNetworkInterfaceIdentifierProtocolGuid
, NULL
},
1494 {STRING_TOKEN(STR_NII_31
), &gEfiNetworkInterfaceIdentifierProtocolGuid_31
, NULL
},
1495 {STRING_TOKEN(STR_PXE_BC
), &gEfiPxeBaseCodeProtocolGuid
, NULL
},
1496 {STRING_TOKEN(STR_PXE_CB
), &gEfiPxeBaseCodeCallbackProtocolGuid
, NULL
},
1497 {STRING_TOKEN(STR_BIS
), &gEfiBisProtocolGuid
, NULL
},
1498 {STRING_TOKEN(STR_MNP_SB
), &gEfiManagedNetworkServiceBindingProtocolGuid
, NULL
},
1499 {STRING_TOKEN(STR_MNP
), &gEfiManagedNetworkProtocolGuid
, NULL
},
1500 {STRING_TOKEN(STR_ARP_SB
), &gEfiArpServiceBindingProtocolGuid
, NULL
},
1501 {STRING_TOKEN(STR_ARP
), &gEfiArpProtocolGuid
, NULL
},
1502 {STRING_TOKEN(STR_DHCPV4_SB
), &gEfiDhcp4ServiceBindingProtocolGuid
, NULL
},
1503 {STRING_TOKEN(STR_DHCPV4
), &gEfiDhcp4ProtocolGuid
, NULL
},
1504 {STRING_TOKEN(STR_TCPV4_SB
), &gEfiTcp4ServiceBindingProtocolGuid
, NULL
},
1505 {STRING_TOKEN(STR_TCPV4
), &gEfiTcp4ProtocolGuid
, NULL
},
1506 {STRING_TOKEN(STR_IPV4_SB
), &gEfiIp4ServiceBindingProtocolGuid
, NULL
},
1507 {STRING_TOKEN(STR_IPV4
), &gEfiIp4ProtocolGuid
, NULL
},
1508 {STRING_TOKEN(STR_IPV4_CFG
), &gEfiIp4ConfigProtocolGuid
, NULL
},
1509 {STRING_TOKEN(STR_IPV4_CFG2
), &gEfiIp4Config2ProtocolGuid
, NULL
},
1510 {STRING_TOKEN(STR_UDPV4_SB
), &gEfiUdp4ServiceBindingProtocolGuid
, NULL
},
1511 {STRING_TOKEN(STR_UDPV4
), &gEfiUdp4ProtocolGuid
, NULL
},
1512 {STRING_TOKEN(STR_MTFTPV4_SB
), &gEfiMtftp4ServiceBindingProtocolGuid
, NULL
},
1513 {STRING_TOKEN(STR_MTFTPV4
), &gEfiMtftp4ProtocolGuid
, NULL
},
1514 {STRING_TOKEN(STR_AUTH_INFO
), &gEfiAuthenticationInfoProtocolGuid
, NULL
},
1515 {STRING_TOKEN(STR_HASH_SB
), &gEfiHashServiceBindingProtocolGuid
, NULL
},
1516 {STRING_TOKEN(STR_HASH
), &gEfiHashProtocolGuid
, NULL
},
1517 {STRING_TOKEN(STR_HII_FONT
), &gEfiHiiFontProtocolGuid
, NULL
},
1518 {STRING_TOKEN(STR_HII_STRING
), &gEfiHiiStringProtocolGuid
, NULL
},
1519 {STRING_TOKEN(STR_HII_IMAGE
), &gEfiHiiImageProtocolGuid
, NULL
},
1520 {STRING_TOKEN(STR_HII_DATABASE
), &gEfiHiiDatabaseProtocolGuid
, NULL
},
1521 {STRING_TOKEN(STR_HII_CONFIG_ROUT
), &gEfiHiiConfigRoutingProtocolGuid
, NULL
},
1522 {STRING_TOKEN(STR_HII_CONFIG_ACC
), &gEfiHiiConfigAccessProtocolGuid
, NULL
},
1523 {STRING_TOKEN(STR_HII_FORM_BROWSER2
), &gEfiFormBrowser2ProtocolGuid
, NULL
},
1524 {STRING_TOKEN(STR_DRIVER_FAM_OVERRIDE
), &gEfiDriverFamilyOverrideProtocolGuid
, NULL
},
1525 {STRING_TOKEN(STR_PCD
), &gPcdProtocolGuid
, NULL
},
1526 {STRING_TOKEN(STR_TCG
), &gEfiTcgProtocolGuid
, NULL
},
1527 {STRING_TOKEN(STR_HII_PACKAGE_LIST
), &gEfiHiiPackageListProtocolGuid
, NULL
},
1530 // the ones under this are deprecated by the current UEFI Spec, but may be found anyways...
1532 {STRING_TOKEN(STR_SHELL_INTERFACE
), &gEfiShellInterfaceGuid
, NULL
},
1533 {STRING_TOKEN(STR_SHELL_ENV2
), &gEfiShellEnvironment2Guid
, NULL
},
1534 {STRING_TOKEN(STR_SHELL_ENV
), &gEfiShellEnvironment2Guid
, NULL
},
1535 {STRING_TOKEN(STR_DEVICE_IO
), &gEfiDeviceIoProtocolGuid
, NULL
},
1536 {STRING_TOKEN(STR_UGA_DRAW
), &gEfiUgaDrawProtocolGuid
, NULL
},
1537 {STRING_TOKEN(STR_UGA_IO
), &gEfiUgaIoProtocolGuid
, NULL
},
1538 {STRING_TOKEN(STR_ESP
), &gEfiPartTypeSystemPartGuid
, NULL
},
1539 {STRING_TOKEN(STR_GPT_NBR
), &gEfiPartTypeLegacyMbrGuid
, NULL
},
1540 {STRING_TOKEN(STR_DRIVER_CONFIG
), &gEfiDriverConfigurationProtocolGuid
, NULL
},
1541 {STRING_TOKEN(STR_DRIVER_CONFIG2
), &gEfiDriverConfiguration2ProtocolGuid
, NULL
},
1544 // these are using local (non-global) definitions to reduce package dependancy.
1546 {STRING_TOKEN(STR_ISA_IO
), (EFI_GUID
*)&EfiIsaIoProtocolGuid
, NULL
},
1547 {STRING_TOKEN(STR_ISA_ACPI
), (EFI_GUID
*)&EfiIsaAcpiProtocolGuid
, NULL
},
1550 // the ones under this are GUID identified structs, not protocols
1552 {STRING_TOKEN(STR_FILE_INFO
), &gEfiFileInfoGuid
, NULL
},
1553 {STRING_TOKEN(STR_FILE_SYS_INFO
), &gEfiFileSystemInfoGuid
, NULL
},
1556 // the ones under this are misc GUIDS.
1558 {STRING_TOKEN(STR_EFI_GLOBAL_VARIABLE
), &gEfiGlobalVariableGuid
, NULL
},
1563 {STRING_TOKEN(STR_IP6_SB
), &gEfiIp6ServiceBindingProtocolGuid
, NULL
},
1564 {STRING_TOKEN(STR_IP6
), &gEfiIp6ProtocolGuid
, NULL
},
1565 {STRING_TOKEN(STR_IP6_CONFIG
), &gEfiIp6ConfigProtocolGuid
, NULL
},
1566 {STRING_TOKEN(STR_MTFTP6_SB
), &gEfiMtftp6ServiceBindingProtocolGuid
, NULL
},
1567 {STRING_TOKEN(STR_MTFTP6
), &gEfiMtftp6ProtocolGuid
, NULL
},
1568 {STRING_TOKEN(STR_DHCP6_SB
), &gEfiDhcp6ServiceBindingProtocolGuid
, NULL
},
1569 {STRING_TOKEN(STR_DHCP6
), &gEfiDhcp6ProtocolGuid
, NULL
},
1570 {STRING_TOKEN(STR_UDP6_SB
), &gEfiUdp6ServiceBindingProtocolGuid
, NULL
},
1571 {STRING_TOKEN(STR_UDP6
), &gEfiUdp6ProtocolGuid
, NULL
},
1572 {STRING_TOKEN(STR_TCP6_SB
), &gEfiTcp6ServiceBindingProtocolGuid
, NULL
},
1573 {STRING_TOKEN(STR_TCP6
), &gEfiTcp6ProtocolGuid
, NULL
},
1574 {STRING_TOKEN(STR_VLAN_CONFIG
), &gEfiVlanConfigProtocolGuid
, NULL
},
1575 {STRING_TOKEN(STR_EAP
), &gEfiEapProtocolGuid
, NULL
},
1576 {STRING_TOKEN(STR_EAP_MGMT
), &gEfiEapManagementProtocolGuid
, NULL
},
1577 {STRING_TOKEN(STR_FTP4_SB
), &gEfiFtp4ServiceBindingProtocolGuid
, NULL
},
1578 {STRING_TOKEN(STR_FTP4
), &gEfiFtp4ProtocolGuid
, NULL
},
1579 {STRING_TOKEN(STR_IP_SEC_CONFIG
), &gEfiIpSecConfigProtocolGuid
, NULL
},
1580 {STRING_TOKEN(STR_DH
), &gEfiDriverHealthProtocolGuid
, NULL
},
1581 {STRING_TOKEN(STR_DEF_IMG_LOAD
), &gEfiDeferredImageLoadProtocolGuid
, NULL
},
1582 {STRING_TOKEN(STR_USER_CRED
), &gEfiUserCredentialProtocolGuid
, NULL
},
1583 {STRING_TOKEN(STR_USER_MNGR
), &gEfiUserManagerProtocolGuid
, NULL
},
1584 {STRING_TOKEN(STR_ATA_PASS_THRU
), &gEfiAtaPassThruProtocolGuid
, NULL
},
1589 {STRING_TOKEN(STR_FW_MGMT
), &gEfiFirmwareManagementProtocolGuid
, FirmwareManagementDumpInformation
},
1590 {STRING_TOKEN(STR_IP_SEC
), &gEfiIpSecProtocolGuid
, NULL
},
1591 {STRING_TOKEN(STR_IP_SEC2
), &gEfiIpSec2ProtocolGuid
, NULL
},
1596 {STRING_TOKEN(STR_KMS
), &gEfiKmsProtocolGuid
, NULL
},
1597 {STRING_TOKEN(STR_BLK_IO2
), &gEfiBlockIo2ProtocolGuid
, NULL
},
1598 {STRING_TOKEN(STR_SSC
), &gEfiStorageSecurityCommandProtocolGuid
, NULL
},
1599 {STRING_TOKEN(STR_UCRED2
), &gEfiUserCredential2ProtocolGuid
, NULL
},
1604 {STRING_TOKEN(STR_DISK_IO2
), &gEfiDiskIo2ProtocolGuid
, NULL
},
1605 {STRING_TOKEN(STR_ADAPTER_INFO
), &gEfiAdapterInformationProtocolGuid
, AdapterInformationDumpInformation
},
1610 {STRING_TOKEN(STR_IDE_CONT_INIT
), &gEfiIdeControllerInitProtocolGuid
, NULL
},
1611 {STRING_TOKEN(STR_DISK_INFO
), &gEfiDiskInfoProtocolGuid
, NULL
},
1616 {STRING_TOKEN(STR_BDS_ARCH
), &gEfiBdsArchProtocolGuid
, NULL
},
1617 {STRING_TOKEN(STR_CPU_ARCH
), &gEfiCpuArchProtocolGuid
, NULL
},
1618 {STRING_TOKEN(STR_MET_ARCH
), &gEfiMetronomeArchProtocolGuid
, NULL
},
1619 {STRING_TOKEN(STR_MON_ARCH
), &gEfiMonotonicCounterArchProtocolGuid
, NULL
},
1620 {STRING_TOKEN(STR_RTC_ARCH
), &gEfiRealTimeClockArchProtocolGuid
, NULL
},
1621 {STRING_TOKEN(STR_RESET_ARCH
), &gEfiResetArchProtocolGuid
, NULL
},
1622 {STRING_TOKEN(STR_RT_ARCH
), &gEfiRuntimeArchProtocolGuid
, NULL
},
1623 {STRING_TOKEN(STR_SEC_ARCH
), &gEfiSecurityArchProtocolGuid
, NULL
},
1624 {STRING_TOKEN(STR_TIMER_ARCH
), &gEfiTimerArchProtocolGuid
, NULL
},
1625 {STRING_TOKEN(STR_VAR_ARCH
), &gEfiVariableWriteArchProtocolGuid
, NULL
},
1626 {STRING_TOKEN(STR_V_ARCH
), &gEfiVariableArchProtocolGuid
, NULL
},
1627 {STRING_TOKEN(STR_SECP
), &gEfiSecurityPolicyProtocolGuid
, NULL
},
1628 {STRING_TOKEN(STR_WDT_ARCH
), &gEfiWatchdogTimerArchProtocolGuid
, NULL
},
1629 {STRING_TOKEN(STR_SCR
), &gEfiStatusCodeRuntimeProtocolGuid
, NULL
},
1630 {STRING_TOKEN(STR_SMB_HC
), &gEfiSmbusHcProtocolGuid
, NULL
},
1631 {STRING_TOKEN(STR_FV_2
), &gEfiFirmwareVolume2ProtocolGuid
, NULL
},
1632 {STRING_TOKEN(STR_FV_BLOCK
), &gEfiFirmwareVolumeBlockProtocolGuid
, NULL
},
1633 {STRING_TOKEN(STR_CAP_ARCH
), &gEfiCapsuleArchProtocolGuid
, NULL
},
1634 {STRING_TOKEN(STR_MP_SERVICE
), &gEfiMpServiceProtocolGuid
, NULL
},
1635 {STRING_TOKEN(STR_HBRAP
), &gEfiPciHostBridgeResourceAllocationProtocolGuid
, NULL
},
1636 {STRING_TOKEN(STR_PCIP
), &gEfiPciPlatformProtocolGuid
, NULL
},
1637 {STRING_TOKEN(STR_PCIO
), &gEfiPciOverrideProtocolGuid
, NULL
},
1638 {STRING_TOKEN(STR_PCIE
), &gEfiPciEnumerationCompleteProtocolGuid
, NULL
},
1639 {STRING_TOKEN(STR_IPCID
), &gEfiIncompatiblePciDeviceSupportProtocolGuid
, NULL
},
1640 {STRING_TOKEN(STR_PCIHPI
), &gEfiPciHotPlugInitProtocolGuid
, NULL
},
1641 {STRING_TOKEN(STR_PCIHPR
), &gEfiPciHotPlugRequestProtocolGuid
, NULL
},
1642 {STRING_TOKEN(STR_SMBIOS
), &gEfiSmbiosProtocolGuid
, NULL
},
1643 {STRING_TOKEN(STR_S3_SAVE
), &gEfiS3SaveStateProtocolGuid
, NULL
},
1644 {STRING_TOKEN(STR_S3_S_SMM
), &gEfiS3SmmSaveStateProtocolGuid
, NULL
},
1645 {STRING_TOKEN(STR_RSC
), &gEfiRscHandlerProtocolGuid
, NULL
},
1646 {STRING_TOKEN(STR_S_RSC
), &gEfiSmmRscHandlerProtocolGuid
, NULL
},
1647 {STRING_TOKEN(STR_ACPI_SDT
), &gEfiAcpiSdtProtocolGuid
, NULL
},
1648 {STRING_TOKEN(STR_SIO
), &gEfiSioProtocolGuid
, NULL
},
1649 {STRING_TOKEN(STR_S_CPU2
), &gEfiSmmCpuIo2ProtocolGuid
, NULL
},
1650 {STRING_TOKEN(STR_S_BASE2
), &gEfiSmmBase2ProtocolGuid
, NULL
},
1651 {STRING_TOKEN(STR_S_ACC_2
), &gEfiSmmAccess2ProtocolGuid
, NULL
},
1652 {STRING_TOKEN(STR_S_CON_2
), &gEfiSmmControl2ProtocolGuid
, NULL
},
1653 {STRING_TOKEN(STR_S_CONFIG
), &gEfiSmmConfigurationProtocolGuid
, NULL
},
1654 {STRING_TOKEN(STR_S_RTL
), &gEfiSmmReadyToLockProtocolGuid
, NULL
},
1655 {STRING_TOKEN(STR_DS_RTL
), &gEfiDxeSmmReadyToLockProtocolGuid
, NULL
},
1656 {STRING_TOKEN(STR_S_COMM
), &gEfiSmmCommunicationProtocolGuid
, NULL
},
1657 {STRING_TOKEN(STR_S_STAT
), &gEfiSmmStatusCodeProtocolGuid
, NULL
},
1658 {STRING_TOKEN(STR_S_CPU
), &gEfiSmmCpuProtocolGuid
, NULL
},
1659 {STRING_TOKEN(STR_S_PCIRBIO
), &gEfiPciRootBridgeIoProtocolGuid
, NULL
},
1660 {STRING_TOKEN(STR_S_SWD
), &gEfiSmmSwDispatch2ProtocolGuid
, NULL
},
1661 {STRING_TOKEN(STR_S_SXD
), &gEfiSmmSxDispatch2ProtocolGuid
, NULL
},
1662 {STRING_TOKEN(STR_S_PTD2
), &gEfiSmmPeriodicTimerDispatch2ProtocolGuid
, NULL
},
1663 {STRING_TOKEN(STR_S_UD2
), &gEfiSmmUsbDispatch2ProtocolGuid
, NULL
},
1664 {STRING_TOKEN(STR_S_GD2
), &gEfiSmmGpiDispatch2ProtocolGuid
, NULL
},
1665 {STRING_TOKEN(STR_S_SBD2
), &gEfiSmmStandbyButtonDispatch2ProtocolGuid
, NULL
},
1666 {STRING_TOKEN(STR_S_PBD2
), &gEfiSmmPowerButtonDispatch2ProtocolGuid
, NULL
},
1667 {STRING_TOKEN(STR_S_ITD2
), &gEfiSmmIoTrapDispatch2ProtocolGuid
, NULL
},
1668 {STRING_TOKEN(STR_PCD
), &gEfiPcdProtocolGuid
, NULL
},
1669 {STRING_TOKEN(STR_FVB2
), &gEfiFirmwareVolumeBlock2ProtocolGuid
, NULL
},
1670 {STRING_TOKEN(STR_CPUIO2
), &gEfiCpuIo2ProtocolGuid
, NULL
},
1671 {STRING_TOKEN(STR_LEGACY_R2
), &gEfiLegacyRegion2ProtocolGuid
, NULL
},
1672 {STRING_TOKEN(STR_SAL_MIP
), &gEfiSalMcaInitPmiProtocolGuid
, NULL
},
1673 {STRING_TOKEN(STR_ES_BS
), &gEfiExtendedSalBootServiceProtocolGuid
, NULL
},
1674 {STRING_TOKEN(STR_ES_BIO
), &gEfiExtendedSalBaseIoServicesProtocolGuid
, NULL
},
1675 {STRING_TOKEN(STR_ES_STALL
), &gEfiExtendedSalStallServicesProtocolGuid
, NULL
},
1676 {STRING_TOKEN(STR_ES_RTC
), &gEfiExtendedSalRtcServicesProtocolGuid
, NULL
},
1677 {STRING_TOKEN(STR_ES_VS
), &gEfiExtendedSalVariableServicesProtocolGuid
, NULL
},
1678 {STRING_TOKEN(STR_ES_MTC
), &gEfiExtendedSalMtcServicesProtocolGuid
, NULL
},
1679 {STRING_TOKEN(STR_ES_RESET
), &gEfiExtendedSalResetServicesProtocolGuid
, NULL
},
1680 {STRING_TOKEN(STR_ES_SC
), &gEfiExtendedSalStatusCodeServicesProtocolGuid
, NULL
},
1681 {STRING_TOKEN(STR_ES_FBS
), &gEfiExtendedSalFvBlockServicesProtocolGuid
, NULL
},
1682 {STRING_TOKEN(STR_ES_MP
), &gEfiExtendedSalMpServicesProtocolGuid
, NULL
},
1683 {STRING_TOKEN(STR_ES_PAL
), &gEfiExtendedSalPalServicesProtocolGuid
, NULL
},
1684 {STRING_TOKEN(STR_ES_BASE
), &gEfiExtendedSalBaseServicesProtocolGuid
, NULL
},
1685 {STRING_TOKEN(STR_ES_MCA
), &gEfiExtendedSalMcaServicesProtocolGuid
, NULL
},
1686 {STRING_TOKEN(STR_ES_PCI
), &gEfiExtendedSalPciServicesProtocolGuid
, NULL
},
1687 {STRING_TOKEN(STR_ES_CACHE
), &gEfiExtendedSalCacheServicesProtocolGuid
, NULL
},
1688 {STRING_TOKEN(STR_ES_MCA_LOG
), &gEfiExtendedSalMcaLogServicesProtocolGuid
, NULL
},
1689 {STRING_TOKEN(STR_S2ARCH
), &gEfiSecurity2ArchProtocolGuid
, NULL
},
1690 {STRING_TOKEN(STR_EODXE
), &gEfiSmmEndOfDxeProtocolGuid
, NULL
},
1691 {STRING_TOKEN(STR_ISAHC
), &gEfiIsaHcProtocolGuid
, NULL
},
1692 {STRING_TOKEN(STR_ISAHC_B
), &gEfiIsaHcServiceBindingProtocolGuid
, NULL
},
1693 {STRING_TOKEN(STR_SIO_C
), &gEfiSioControlProtocolGuid
, NULL
},
1694 {STRING_TOKEN(STR_GET_PCD
), &gEfiGetPcdInfoProtocolGuid
, NULL
},
1695 {STRING_TOKEN(STR_I2C_M
), &gEfiI2cMasterProtocolGuid
, NULL
},
1696 {STRING_TOKEN(STR_I2CIO
), &gEfiI2cIoProtocolGuid
, NULL
},
1697 {STRING_TOKEN(STR_I2CEN
), &gEfiI2cEnumerateProtocolGuid
, NULL
},
1698 {STRING_TOKEN(STR_I2C_H
), &gEfiI2cHostProtocolGuid
, NULL
},
1699 {STRING_TOKEN(STR_I2C_BCM
), &gEfiI2cBusConfigurationManagementProtocolGuid
, NULL
},
1700 {STRING_TOKEN(STR_TREE
), &gEfiTrEEProtocolGuid
, NULL
},
1701 {STRING_TOKEN(STR_TCG2
), &gEfiTcg2ProtocolGuid
, NULL
},
1702 {STRING_TOKEN(STR_TIMESTAMP
), &gEfiTimestampProtocolGuid
, NULL
},
1703 {STRING_TOKEN(STR_RNG
), &gEfiRngProtocolGuid
, NULL
},
1704 {STRING_TOKEN(STR_NVMEPT
), &gEfiNvmExpressPassThruProtocolGuid
, NULL
},
1705 {STRING_TOKEN(STR_H2_SB
), &gEfiHash2ServiceBindingProtocolGuid
, NULL
},
1706 {STRING_TOKEN(STR_HASH2
), &gEfiHash2ProtocolGuid
, NULL
},
1707 {STRING_TOKEN(STR_BIO_C
), &gEfiBlockIoCryptoProtocolGuid
, NULL
},
1708 {STRING_TOKEN(STR_SCR
), &gEfiSmartCardReaderProtocolGuid
, NULL
},
1709 {STRING_TOKEN(STR_SCE
), &gEfiSmartCardEdgeProtocolGuid
, NULL
},
1710 {STRING_TOKEN(STR_USB_FIO
), &gEfiUsbFunctionIoProtocolGuid
, NULL
},
1711 {STRING_TOKEN(STR_BC_HC
), &gEfiBluetoothHcProtocolGuid
, NULL
},
1712 {STRING_TOKEN(STR_BC_IO_SB
), &gEfiBluetoothIoServiceBindingProtocolGuid
, NULL
},
1713 {STRING_TOKEN(STR_BC_IO
), &gEfiBluetoothIoProtocolGuid
, NULL
},
1714 {STRING_TOKEN(STR_BC_C
), &gEfiBluetoothConfigProtocolGuid
, NULL
},
1715 {STRING_TOKEN(STR_REG_EXP
), &gEfiRegularExpressionProtocolGuid
, NULL
},
1716 {STRING_TOKEN(STR_B_MGR_P
), &gEfiBootManagerPolicyProtocolGuid
, NULL
},
1717 {STRING_TOKEN(STR_CKH
), &gEfiConfigKeywordHandlerProtocolGuid
, NULL
},
1718 {STRING_TOKEN(STR_WIFI
), &gEfiWiFiProtocolGuid
, NULL
},
1719 {STRING_TOKEN(STR_EAP_M
), &gEfiEapManagement2ProtocolGuid
, NULL
},
1720 {STRING_TOKEN(STR_EAP_C
), &gEfiEapConfigurationProtocolGuid
, NULL
},
1721 {STRING_TOKEN(STR_PKCS7
), &gEfiPkcs7VerifyProtocolGuid
, NULL
},
1722 {STRING_TOKEN(STR_NET_DNS4_SB
), &gEfiDns4ServiceBindingProtocolGuid
, NULL
},
1723 {STRING_TOKEN(STR_NET_DNS4
), &gEfiDns4ProtocolGuid
, NULL
},
1724 {STRING_TOKEN(STR_NET_DNS6_SB
), &gEfiDns6ServiceBindingProtocolGuid
, NULL
},
1725 {STRING_TOKEN(STR_NET_DNS6
), &gEfiDns6ProtocolGuid
, NULL
},
1726 {STRING_TOKEN(STR_NET_HTTP_SB
), &gEfiHttpServiceBindingProtocolGuid
, NULL
},
1727 {STRING_TOKEN(STR_NET_HTTP
), &gEfiHttpProtocolGuid
, NULL
},
1728 {STRING_TOKEN(STR_NET_HTTP_U
), &gEfiHttpUtilitiesProtocolGuid
, NULL
},
1729 {STRING_TOKEN(STR_REST
), &gEfiRestProtocolGuid
, NULL
},
1732 // UEFI Shell Spec 2.0
1734 {STRING_TOKEN(STR_SHELL_PARAMETERS
), &gEfiShellParametersProtocolGuid
, NULL
},
1735 {STRING_TOKEN(STR_SHELL
), &gEfiShellProtocolGuid
, NULL
},
1738 // UEFI Shell Spec 2.1
1740 {STRING_TOKEN(STR_SHELL_DYNAMIC
), &gEfiShellDynamicCommandProtocolGuid
, NULL
},
1745 {STRING_TOKEN(STR_PCDINFOPROT
), &gGetPcdInfoProtocolGuid
, NULL
},
1750 {STRING_TOKEN(STR_UNKNOWN_DEVICE
), NULL
, NULL
},
1754 Function to get the node for a protocol or struct from it's GUID.
1756 if Guid is NULL, then ASSERT.
1758 @param[in] Guid The GUID to look for the name of.
1762 CONST GUID_INFO_BLOCK
*
1764 InternalShellGetNodeFromGuid(
1765 IN CONST EFI_GUID
* Guid
1768 CONST GUID_INFO_BLOCK
*ListWalker
;
1771 ASSERT(Guid
!= NULL
);
1773 for (LoopCount
= 0, ListWalker
= GuidList
; GuidList
!= NULL
&& LoopCount
< GuidListCount
; LoopCount
++, ListWalker
++) {
1774 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
1775 return (ListWalker
);
1779 if (PcdGetBool(PcdShellIncludeNtGuids
)) {
1780 for (ListWalker
= mGuidStringListNT
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
1781 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
1782 return (ListWalker
);
1786 for (ListWalker
= mGuidStringList
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
1787 if (CompareGuid(ListWalker
->GuidId
, Guid
)) {
1788 return (ListWalker
);
1795 Function to add a new GUID/Name mapping.
1797 @param[in] Guid The Guid
1798 @param[in] NameID The STRING id of the HII string to use
1799 @param[in] DumpFunc The pointer to the dump function
1802 @retval EFI_SUCCESS The operation was sucessful
1803 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
1804 @retval EFI_INVALID_PARAMETER Guid NameId was invalid
1808 InsertNewGuidNameMapping(
1809 IN CONST EFI_GUID
*Guid
,
1810 IN CONST EFI_STRING_ID NameID
,
1811 IN CONST DUMP_PROTOCOL_INFO DumpFunc OPTIONAL
1814 ASSERT(Guid
!= NULL
);
1815 ASSERT(NameID
!= 0);
1817 GuidList
= ReallocatePool(GuidListCount
* sizeof(GUID_INFO_BLOCK
), GuidListCount
+1 * sizeof(GUID_INFO_BLOCK
), GuidList
);
1818 if (GuidList
== NULL
) {
1820 return (EFI_OUT_OF_RESOURCES
);
1824 GuidList
[GuidListCount
- 1].GuidId
= AllocateCopyPool(sizeof(EFI_GUID
), Guid
);
1825 GuidList
[GuidListCount
- 1].StringId
= NameID
;
1826 GuidList
[GuidListCount
- 1].DumpInfo
= DumpFunc
;
1828 if (GuidList
[GuidListCount
- 1].GuidId
== NULL
) {
1829 return (EFI_OUT_OF_RESOURCES
);
1832 return (EFI_SUCCESS
);
1836 Function to add a new GUID/Name mapping.
1838 This cannot overwrite an existing mapping.
1840 @param[in] Guid The Guid
1841 @param[in] TheName The Guid's name
1842 @param[in] Lang RFC4646 language code list or NULL
1844 @retval EFI_SUCCESS The operation was sucessful
1845 @retval EFI_ACCESS_DENIED There was a duplicate
1846 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
1847 @retval EFI_INVALID_PARAMETER Guid or TheName was NULL
1851 AddNewGuidNameMapping(
1852 IN CONST EFI_GUID
*Guid
,
1853 IN CONST CHAR16
*TheName
,
1854 IN CONST CHAR8
*Lang OPTIONAL
1857 EFI_STRING_ID NameID
;
1859 HandleParsingHiiInit();
1861 if (Guid
== NULL
|| TheName
== NULL
){
1862 return (EFI_INVALID_PARAMETER
);
1865 if ((InternalShellGetNodeFromGuid(Guid
)) != NULL
) {
1866 return (EFI_ACCESS_DENIED
);
1869 NameID
= HiiSetString(mHandleParsingHiiHandle
, 0, (CHAR16
*)TheName
, Lang
);
1871 return (EFI_OUT_OF_RESOURCES
);
1874 return (InsertNewGuidNameMapping(Guid
, NameID
, NULL
));
1878 Function to get the name of a protocol or struct from it's GUID.
1880 if Guid is NULL, then ASSERT.
1882 @param[in] Guid The GUID to look for the name of.
1883 @param[in] Lang The language to use.
1885 @return pointer to string of the name. The caller
1886 is responsible to free this memory.
1890 GetStringNameFromGuid(
1891 IN CONST EFI_GUID
*Guid
,
1892 IN CONST CHAR8
*Lang OPTIONAL
1895 CONST GUID_INFO_BLOCK
*Id
;
1897 HandleParsingHiiInit();
1899 Id
= InternalShellGetNodeFromGuid(Guid
);
1900 return (HiiGetString(mHandleParsingHiiHandle
, Id
==NULL
?STRING_TOKEN(STR_UNKNOWN_DEVICE
):Id
->StringId
, Lang
));
1904 Function to dump protocol information from a handle.
1906 This function will return a allocated string buffer containing the
1907 information. The caller is responsible for freeing the memory.
1909 If Guid is NULL, ASSERT().
1910 If TheHandle is NULL, ASSERT().
1912 @param[in] TheHandle The handle to dump information from.
1913 @param[in] Guid The GUID of the protocol to dump.
1914 @param[in] Verbose TRUE for extra info. FALSE otherwise.
1916 @return The pointer to string.
1917 @retval NULL An error was encountered.
1921 GetProtocolInformationDump(
1922 IN CONST EFI_HANDLE TheHandle
,
1923 IN CONST EFI_GUID
*Guid
,
1924 IN CONST BOOLEAN Verbose
1927 CONST GUID_INFO_BLOCK
*Id
;
1929 ASSERT(TheHandle
!= NULL
);
1930 ASSERT(Guid
!= NULL
);
1932 if (TheHandle
== NULL
|| Guid
== NULL
) {
1936 Id
= InternalShellGetNodeFromGuid(Guid
);
1937 if (Id
!= NULL
&& Id
->DumpInfo
!= NULL
) {
1938 return (Id
->DumpInfo(TheHandle
, Verbose
));
1944 Function to get the Guid for a protocol or struct based on it's string name.
1946 do not modify the returned Guid.
1948 @param[in] Name The pointer to the string name.
1949 @param[in] Lang The pointer to the language code.
1950 @param[out] Guid The pointer to the Guid.
1952 @retval EFI_SUCCESS The operation was sucessful.
1956 GetGuidFromStringName(
1957 IN CONST CHAR16
*Name
,
1958 IN CONST CHAR8
*Lang OPTIONAL
,
1962 CONST GUID_INFO_BLOCK
*ListWalker
;
1966 HandleParsingHiiInit();
1968 ASSERT(Guid
!= NULL
);
1970 return (EFI_INVALID_PARAMETER
);
1974 if (PcdGetBool(PcdShellIncludeNtGuids
)) {
1975 for (ListWalker
= mGuidStringListNT
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
1976 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
1977 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
1978 *Guid
= ListWalker
->GuidId
;
1980 SHELL_FREE_NON_NULL(String
);
1981 if (*Guid
!= NULL
) {
1982 return (EFI_SUCCESS
);
1986 for (ListWalker
= mGuidStringList
; ListWalker
!= NULL
&& ListWalker
->GuidId
!= NULL
; ListWalker
++) {
1987 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
1988 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
1989 *Guid
= ListWalker
->GuidId
;
1991 SHELL_FREE_NON_NULL(String
);
1992 if (*Guid
!= NULL
) {
1993 return (EFI_SUCCESS
);
1997 for (LoopCount
= 0, ListWalker
= GuidList
; GuidList
!= NULL
&& LoopCount
< GuidListCount
; LoopCount
++, ListWalker
++) {
1998 String
= HiiGetString(mHandleParsingHiiHandle
, ListWalker
->StringId
, Lang
);
1999 if (Name
!= NULL
&& String
!= NULL
&& StringNoCaseCompare (&Name
, &String
) == 0) {
2000 *Guid
= ListWalker
->GuidId
;
2002 SHELL_FREE_NON_NULL(String
);
2003 if (*Guid
!= NULL
) {
2004 return (EFI_SUCCESS
);
2008 return (EFI_NOT_FOUND
);
2012 Get best support language for this driver.
2014 First base on the user input language to search, second base on the current
2015 platform used language to search, third get the first language from the
2016 support language list. The caller need to free the buffer of the best language.
2018 @param[in] SupportedLanguages The support languages for this driver.
2019 @param[in] InputLanguage The user input language.
2020 @param[in] Iso639Language Whether get language for ISO639.
2022 @return The best support language for this driver.
2026 GetBestLanguageForDriver (
2027 IN CONST CHAR8
*SupportedLanguages
,
2028 IN CONST CHAR8
*InputLanguage
,
2029 IN BOOLEAN Iso639Language
2032 CHAR8
*LanguageVariable
;
2033 CHAR8
*BestLanguage
;
2035 GetVariable2 (Iso639Language
? L
"Lang" : L
"PlatformLang", &gEfiGlobalVariableGuid
, (VOID
**)&LanguageVariable
, NULL
);
2037 BestLanguage
= GetBestLanguage(
2040 (InputLanguage
!= NULL
) ? InputLanguage
: "",
2041 (LanguageVariable
!= NULL
) ? LanguageVariable
: "",
2046 if (LanguageVariable
!= NULL
) {
2047 FreePool (LanguageVariable
);
2050 return BestLanguage
;
2054 Function to retrieve the driver name (if possible) from the ComponentName or
2055 ComponentName2 protocol
2057 @param[in] TheHandle The driver handle to get the name of.
2058 @param[in] Language The language to use.
2060 @retval NULL The name could not be found.
2061 @return A pointer to the string name. Do not de-allocate the memory.
2065 GetStringNameFromHandle(
2066 IN CONST EFI_HANDLE TheHandle
,
2067 IN CONST CHAR8
*Language
2070 EFI_COMPONENT_NAME2_PROTOCOL
*CompNameStruct
;
2077 Status
= gBS
->OpenProtocol(
2079 &gEfiComponentName2ProtocolGuid
,
2080 (VOID
**)&CompNameStruct
,
2083 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
2084 if (!EFI_ERROR(Status
)) {
2085 BestLang
= GetBestLanguageForDriver (CompNameStruct
->SupportedLanguages
, Language
, FALSE
);
2086 Status
= CompNameStruct
->GetDriverName(CompNameStruct
, BestLang
, &RetVal
);
2087 if (BestLang
!= NULL
) {
2088 FreePool (BestLang
);
2091 if (!EFI_ERROR(Status
)) {
2095 Status
= gBS
->OpenProtocol(
2097 &gEfiComponentNameProtocolGuid
,
2098 (VOID
**)&CompNameStruct
,
2101 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
2102 if (!EFI_ERROR(Status
)) {
2103 BestLang
= GetBestLanguageForDriver (CompNameStruct
->SupportedLanguages
, Language
, FALSE
);
2104 Status
= CompNameStruct
->GetDriverName(CompNameStruct
, BestLang
, &RetVal
);
2105 if (BestLang
!= NULL
) {
2106 FreePool (BestLang
);
2108 if (!EFI_ERROR(Status
)) {
2116 Function to initialize the file global mHandleList object for use in
2117 vonverting handles to index and index to handle.
2119 @retval EFI_SUCCESS The operation was successful.
2123 InternalShellInitHandleList(
2128 EFI_HANDLE
*HandleBuffer
;
2130 HANDLE_LIST
*ListWalker
;
2132 if (mHandleList
.NextIndex
!= 0) {
2135 InitializeListHead(&mHandleList
.List
.Link
);
2136 mHandleList
.NextIndex
= 1;
2137 Status
= gBS
->LocateHandleBuffer (
2144 ASSERT_EFI_ERROR(Status
);
2145 if (EFI_ERROR(Status
)) {
2148 for (mHandleList
.NextIndex
= 1 ; mHandleList
.NextIndex
<= HandleCount
; mHandleList
.NextIndex
++){
2149 ListWalker
= AllocateZeroPool(sizeof(HANDLE_LIST
));
2150 ASSERT(ListWalker
!= NULL
);
2151 ListWalker
->TheHandle
= HandleBuffer
[mHandleList
.NextIndex
-1];
2152 ListWalker
->TheIndex
= mHandleList
.NextIndex
;
2153 InsertTailList(&mHandleList
.List
.Link
,&ListWalker
->Link
);
2155 FreePool(HandleBuffer
);
2156 return (EFI_SUCCESS
);
2160 Function to retrieve the human-friendly index of a given handle. If the handle
2161 does not have a index one will be automatically assigned. The index value is valid
2162 until the termination of the shell application.
2164 @param[in] TheHandle The handle to retrieve an index for.
2166 @retval 0 A memory allocation failed.
2167 @return The index of the handle.
2172 ConvertHandleToHandleIndex(
2173 IN CONST EFI_HANDLE TheHandle
2177 EFI_GUID
**ProtocolBuffer
;
2178 UINTN ProtocolCount
;
2179 HANDLE_LIST
*ListWalker
;
2181 if (TheHandle
== NULL
) {
2185 InternalShellInitHandleList();
2187 for (ListWalker
= (HANDLE_LIST
*)GetFirstNode(&mHandleList
.List
.Link
)
2188 ; !IsNull(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2189 ; ListWalker
= (HANDLE_LIST
*)GetNextNode(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2191 if (ListWalker
->TheHandle
== TheHandle
) {
2193 // Verify that TheHandle is still present in the Handle Database
2195 Status
= gBS
->ProtocolsPerHandle(TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
2196 if (EFI_ERROR (Status
)) {
2198 // TheHandle is not present in the Handle Database, so delete from the handle list
2200 RemoveEntryList (&ListWalker
->Link
);
2203 FreePool (ProtocolBuffer
);
2204 return (ListWalker
->TheIndex
);
2209 // Verify that TheHandle is valid handle
2211 Status
= gBS
->ProtocolsPerHandle(TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
2212 if (EFI_ERROR (Status
)) {
2214 // TheHandle is not valid, so do not add to handle list
2218 FreePool (ProtocolBuffer
);
2220 ListWalker
= AllocateZeroPool(sizeof(HANDLE_LIST
));
2221 ASSERT(ListWalker
!= NULL
);
2222 ListWalker
->TheHandle
= TheHandle
;
2223 ListWalker
->TheIndex
= mHandleList
.NextIndex
++;
2224 InsertTailList(&mHandleList
.List
.Link
,&ListWalker
->Link
);
2225 return (ListWalker
->TheIndex
);
2231 Function to retrieve the EFI_HANDLE from the human-friendly index.
2233 @param[in] TheIndex The index to retrieve the EFI_HANDLE for.
2235 @retval NULL The index was invalid.
2236 @return The EFI_HANDLE that index represents.
2241 ConvertHandleIndexToHandle(
2242 IN CONST UINTN TheIndex
2246 EFI_GUID
**ProtocolBuffer
;
2247 UINTN ProtocolCount
;
2248 HANDLE_LIST
*ListWalker
;
2250 InternalShellInitHandleList();
2252 if (TheIndex
>= mHandleList
.NextIndex
) {
2256 for (ListWalker
= (HANDLE_LIST
*)GetFirstNode(&mHandleList
.List
.Link
)
2257 ; !IsNull(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2258 ; ListWalker
= (HANDLE_LIST
*)GetNextNode(&mHandleList
.List
.Link
,&ListWalker
->Link
)
2260 if (ListWalker
->TheIndex
== TheIndex
&& ListWalker
->TheHandle
!= NULL
) {
2262 // Verify that LinkWalker->TheHandle is valid handle
2264 Status
= gBS
->ProtocolsPerHandle(ListWalker
->TheHandle
, &ProtocolBuffer
, &ProtocolCount
);
2265 if (EFI_ERROR (Status
)) {
2267 // TheHandle is not valid, so do not add to handle list
2269 ListWalker
->TheHandle
= NULL
;
2271 return (ListWalker
->TheHandle
);
2278 Gets all the related EFI_HANDLEs based on the mask supplied.
2280 This function scans all EFI_HANDLES in the UEFI environment's handle database
2281 and returns the ones with the specified relationship (Mask) to the specified
2284 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
2285 If MatchingHandleCount is NULL, then ASSERT.
2287 If MatchingHandleBuffer is not NULL upon a successful return the memory must be
2290 @param[in] DriverBindingHandle The handle with Driver Binding protocol on it.
2291 @param[in] ControllerHandle The handle with Device Path protocol on it.
2292 @param[in] MatchingHandleCount The pointer to UINTN that specifies the number of HANDLES in
2293 MatchingHandleBuffer.
2294 @param[out] MatchingHandleBuffer On a successful return, a buffer of MatchingHandleCount
2295 EFI_HANDLEs with a terminating NULL EFI_HANDLE.
2296 @param[out] HandleType An array of type information.
2298 @retval EFI_SUCCESS The operation was successful, and any related handles
2299 are in MatchingHandleBuffer.
2300 @retval EFI_NOT_FOUND No matching handles were found.
2301 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.
2305 ParseHandleDatabaseByRelationshipWithType (
2306 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL
,
2307 IN CONST EFI_HANDLE ControllerHandle OPTIONAL
,
2308 IN UINTN
*HandleCount
,
2309 OUT EFI_HANDLE
**HandleBuffer
,
2310 OUT UINTN
**HandleType
2315 EFI_GUID
**ProtocolGuidArray
;
2317 UINTN ProtocolIndex
;
2318 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY
*OpenInfo
;
2319 UINTN OpenInfoCount
;
2320 UINTN OpenInfoIndex
;
2322 INTN DriverBindingHandleIndex
;
2324 ASSERT(HandleCount
!= NULL
);
2325 ASSERT(HandleBuffer
!= NULL
);
2326 ASSERT(HandleType
!= NULL
);
2327 ASSERT(DriverBindingHandle
!= NULL
|| ControllerHandle
!= NULL
);
2330 *HandleBuffer
= NULL
;
2334 // Retrieve the list of all handles from the handle database
2336 Status
= gBS
->LocateHandleBuffer (
2343 if (EFI_ERROR (Status
)) {
2347 *HandleType
= AllocateZeroPool (*HandleCount
* sizeof (UINTN
));
2348 ASSERT(*HandleType
!= NULL
);
2350 DriverBindingHandleIndex
= -1;
2351 for (HandleIndex
= 0; HandleIndex
< *HandleCount
; HandleIndex
++) {
2352 if (DriverBindingHandle
!= NULL
&& (*HandleBuffer
)[HandleIndex
] == DriverBindingHandle
) {
2353 DriverBindingHandleIndex
= (INTN
)HandleIndex
;
2357 for (HandleIndex
= 0; HandleIndex
< *HandleCount
; HandleIndex
++) {
2359 // Retrieve the list of all the protocols on each handle
2361 Status
= gBS
->ProtocolsPerHandle (
2362 (*HandleBuffer
)[HandleIndex
],
2366 if (EFI_ERROR (Status
)) {
2370 for (ProtocolIndex
= 0; ProtocolIndex
< ArrayCount
; ProtocolIndex
++) {
2373 // Set the bit describing what this handle has
2375 if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiLoadedImageProtocolGuid
) ) {
2376 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_IMAGE_HANDLE
;
2377 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverBindingProtocolGuid
) ) {
2378 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_BINDING_HANDLE
;
2379 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverConfiguration2ProtocolGuid
)) {
2380 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_CONFIGURATION_HANDLE
;
2381 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverConfigurationProtocolGuid
) ) {
2382 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_CONFIGURATION_HANDLE
;
2383 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverDiagnostics2ProtocolGuid
) ) {
2384 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_DIAGNOSTICS_HANDLE
;
2385 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDriverDiagnosticsProtocolGuid
) ) {
2386 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DRIVER_DIAGNOSTICS_HANDLE
;
2387 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiComponentName2ProtocolGuid
) ) {
2388 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_COMPONENT_NAME_HANDLE
;
2389 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiComponentNameProtocolGuid
) ) {
2390 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_COMPONENT_NAME_HANDLE
;
2391 } else if (CompareGuid (ProtocolGuidArray
[ProtocolIndex
], &gEfiDevicePathProtocolGuid
) ) {
2392 (*HandleType
)[HandleIndex
] |= (UINTN
)HR_DEVICE_HANDLE
;
2395 ASSERT((*HandleType
)[HandleIndex
] == (*HandleType
)[HandleIndex
]);
2399 // Retrieve the list of agents that have opened each protocol
2401 Status
= gBS
->OpenProtocolInformation (
2402 (*HandleBuffer
)[HandleIndex
],
2403 ProtocolGuidArray
[ProtocolIndex
],
2407 if (EFI_ERROR (Status
)) {
2411 if (ControllerHandle
== NULL
) {
2413 // ControllerHandle == NULL and DriverBindingHandle != NULL.
2414 // Return information on all the controller handles that the driver specified by DriverBindingHandle is managing
2416 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2417 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
&& (OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
2418 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
2419 if (DriverBindingHandleIndex
!= -1) {
2420 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
2423 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
&& (OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2424 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
2425 if (DriverBindingHandleIndex
!= -1) {
2426 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
2428 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2429 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
2430 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
2436 if (DriverBindingHandle
== NULL
&& ControllerHandle
!= NULL
) {
2437 if (ControllerHandle
== (*HandleBuffer
)[HandleIndex
]) {
2438 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
2439 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2440 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
2441 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2442 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
2443 (*HandleType
)[ChildIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
2447 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2448 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2449 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
2450 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
2452 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
2453 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
2459 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2460 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2461 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== ControllerHandle
) {
2462 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_PARENT_HANDLE
);
2468 if (DriverBindingHandle
!= NULL
&& ControllerHandle
!= NULL
) {
2469 if (ControllerHandle
== (*HandleBuffer
)[HandleIndex
]) {
2470 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CONTROLLER_HANDLE
);
2471 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2472 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) != 0) {
2473 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
) {
2474 if (DriverBindingHandleIndex
!= -1) {
2475 (*HandleType
)[DriverBindingHandleIndex
] |= (UINTN
)HR_DEVICE_DRIVER
;
2479 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2480 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== DriverBindingHandle
) {
2481 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2482 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== (*HandleBuffer
)[ChildIndex
]) {
2483 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_CHILD_HANDLE
);
2488 for (ChildIndex
= 0; ChildIndex
< *HandleCount
; ChildIndex
++) {
2489 if (OpenInfo
[OpenInfoIndex
].AgentHandle
== (*HandleBuffer
)[ChildIndex
]) {
2490 (*HandleType
)[ChildIndex
] |= (UINTN
)(HR_BUS_DRIVER
| HR_DEVICE_DRIVER
);
2496 for (OpenInfoIndex
= 0; OpenInfoIndex
< OpenInfoCount
; OpenInfoIndex
++) {
2497 if ((OpenInfo
[OpenInfoIndex
].Attributes
& EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) != 0) {
2498 if (OpenInfo
[OpenInfoIndex
].ControllerHandle
== ControllerHandle
) {
2499 (*HandleType
)[HandleIndex
] |= (UINTN
)(HR_DEVICE_HANDLE
| HR_PARENT_HANDLE
);
2505 FreePool (OpenInfo
);
2507 FreePool (ProtocolGuidArray
);
2513 Gets all the related EFI_HANDLEs based on the single EFI_HANDLE and the mask
2516 This function will scan all EFI_HANDLES in the UEFI environment's handle database
2517 and return all the ones with the specified relationship (Mask) to the specified
2520 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
2521 If MatchingHandleCount is NULL, then ASSERT.
2523 If MatchingHandleBuffer is not NULL upon a sucessful return the memory must be
2526 @param[in] DriverBindingHandle Handle to a object with Driver Binding protocol
2528 @param[in] ControllerHandle Handle to a device with Device Path protocol on it.
2529 @param[in] Mask Mask of what relationship(s) is desired.
2530 @param[in] MatchingHandleCount Poitner to UINTN specifying number of HANDLES in
2531 MatchingHandleBuffer.
2532 @param[out] MatchingHandleBuffer On a sucessful return a buffer of MatchingHandleCount
2533 EFI_HANDLEs and a terminating NULL EFI_HANDLE.
2535 @retval EFI_SUCCESS The operation was sucessful and any related handles
2536 are in MatchingHandleBuffer;
2537 @retval EFI_NOT_FOUND No matching handles were found.
2538 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.
2542 ParseHandleDatabaseByRelationship (
2543 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL
,
2544 IN CONST EFI_HANDLE ControllerHandle OPTIONAL
,
2545 IN CONST UINTN Mask
,
2546 IN UINTN
*MatchingHandleCount
,
2547 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
2552 EFI_HANDLE
*HandleBuffer
;
2556 ASSERT(MatchingHandleCount
!= NULL
);
2557 ASSERT(DriverBindingHandle
!= NULL
|| ControllerHandle
!= NULL
);
2559 if ((Mask
& HR_VALID_MASK
) != Mask
) {
2560 return (EFI_INVALID_PARAMETER
);
2563 if ((Mask
& HR_CHILD_HANDLE
) != 0 && DriverBindingHandle
== NULL
) {
2564 return (EFI_INVALID_PARAMETER
);
2567 *MatchingHandleCount
= 0;
2568 if (MatchingHandleBuffer
!= NULL
) {
2569 *MatchingHandleBuffer
= NULL
;
2572 HandleBuffer
= NULL
;
2575 Status
= ParseHandleDatabaseByRelationshipWithType (
2576 DriverBindingHandle
,
2582 if (!EFI_ERROR (Status
)) {
2584 // Count the number of handles that match the attributes in Mask
2586 for (HandleIndex
= 0; HandleIndex
< HandleCount
; HandleIndex
++) {
2587 if ((HandleType
[HandleIndex
] & Mask
) == Mask
) {
2588 (*MatchingHandleCount
)++;
2592 // If no handles match the attributes in Mask then return EFI_NOT_FOUND
2594 if (*MatchingHandleCount
== 0) {
2595 Status
= EFI_NOT_FOUND
;
2598 if (MatchingHandleBuffer
== NULL
) {
2600 // Someone just wanted the count...
2602 Status
= EFI_SUCCESS
;
2605 // Allocate a handle buffer for the number of handles that matched the attributes in Mask
2607 *MatchingHandleBuffer
= AllocateZeroPool ((*MatchingHandleCount
+1)* sizeof (EFI_HANDLE
));
2608 ASSERT(*MatchingHandleBuffer
!= NULL
);
2610 for (HandleIndex
= 0,*MatchingHandleCount
= 0
2611 ; HandleIndex
< HandleCount
2615 // Fill the allocated buffer with the handles that matched the attributes in Mask
2617 if ((HandleType
[HandleIndex
] & Mask
) == Mask
) {
2618 (*MatchingHandleBuffer
)[(*MatchingHandleCount
)++] = HandleBuffer
[HandleIndex
];
2623 // Make the last one NULL
2625 (*MatchingHandleBuffer
)[*MatchingHandleCount
] = NULL
;
2627 Status
= EFI_SUCCESS
;
2628 } // MacthingHandleBuffer == NULL (ELSE)
2629 } // *MatchingHandleCount == 0 (ELSE)
2630 } // no error on ParseHandleDatabaseByRelationshipWithType
2632 if (HandleBuffer
!= NULL
) {
2633 FreePool (HandleBuffer
);
2636 if (HandleType
!= NULL
) {
2637 FreePool (HandleType
);
2644 Gets handles for any child controllers of the passed in controller.
2646 @param[in] ControllerHandle The handle of the "parent controller"
2647 @param[in] MatchingHandleCount Pointer to the number of handles in
2648 MatchingHandleBuffer on return.
2649 @param[out] MatchingHandleBuffer Buffer containing handles on a successful
2653 @retval EFI_SUCCESS The operation was sucessful.
2657 ParseHandleDatabaseForChildControllers(
2658 IN CONST EFI_HANDLE ControllerHandle
,
2659 IN UINTN
*MatchingHandleCount
,
2660 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
2665 UINTN DriverBindingHandleCount
;
2666 EFI_HANDLE
*DriverBindingHandleBuffer
;
2667 UINTN DriverBindingHandleIndex
;
2668 UINTN ChildControllerHandleCount
;
2669 EFI_HANDLE
*ChildControllerHandleBuffer
;
2670 UINTN ChildControllerHandleIndex
;
2671 EFI_HANDLE
*HandleBufferForReturn
;
2673 if (MatchingHandleCount
== NULL
) {
2674 return (EFI_INVALID_PARAMETER
);
2676 *MatchingHandleCount
= 0;
2678 Status
= PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
2680 &DriverBindingHandleCount
,
2681 &DriverBindingHandleBuffer
2683 if (EFI_ERROR (Status
)) {
2688 // Get a buffer big enough for all the controllers.
2690 HandleBufferForReturn
= GetHandleListByProtocol(NULL
);
2691 if (HandleBufferForReturn
== NULL
) {
2692 FreePool (DriverBindingHandleBuffer
);
2693 return (EFI_NOT_FOUND
);
2696 for (DriverBindingHandleIndex
= 0; DriverBindingHandleIndex
< DriverBindingHandleCount
; DriverBindingHandleIndex
++) {
2697 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
2698 DriverBindingHandleBuffer
[DriverBindingHandleIndex
],
2700 &ChildControllerHandleCount
,
2701 &ChildControllerHandleBuffer
2703 if (EFI_ERROR (Status
)) {
2707 for (ChildControllerHandleIndex
= 0;
2708 ChildControllerHandleIndex
< ChildControllerHandleCount
;
2709 ChildControllerHandleIndex
++
2711 for (HandleIndex
= 0; HandleIndex
< *MatchingHandleCount
; HandleIndex
++) {
2712 if (HandleBufferForReturn
[HandleIndex
] == ChildControllerHandleBuffer
[ChildControllerHandleIndex
]) {
2716 if (HandleIndex
>= *MatchingHandleCount
) {
2717 HandleBufferForReturn
[(*MatchingHandleCount
)++] = ChildControllerHandleBuffer
[ChildControllerHandleIndex
];
2721 FreePool (ChildControllerHandleBuffer
);
2724 FreePool (DriverBindingHandleBuffer
);
2726 if (MatchingHandleBuffer
!= NULL
) {
2727 *MatchingHandleBuffer
= HandleBufferForReturn
;
2729 FreePool(HandleBufferForReturn
);
2732 return (EFI_SUCCESS
);
2736 Appends 1 buffer to another buffer. This will re-allocate the destination buffer
2737 if necessary to fit all of the data.
2739 If DestinationBuffer is NULL, then ASSERT().
2741 @param[in, out] DestinationBuffer The pointer to the pointer to the buffer to append onto.
2742 @param[in, out] DestinationSize The pointer to the size of DestinationBuffer.
2743 @param[in] SourceBuffer The pointer to the buffer to append onto DestinationBuffer.
2744 @param[in] SourceSize The number of bytes of SourceBuffer to append.
2746 @retval NULL A memory allocation failed.
2747 @retval NULL A parameter was invalid.
2748 @return A pointer to (*DestinationBuffer).
2753 IN OUT VOID
**DestinationBuffer
,
2754 IN OUT UINTN
*DestinationSize
,
2755 IN VOID
*SourceBuffer
,
2759 UINTN LocalDestinationSize
;
2760 UINTN LocalDestinationFinalSize
;
2762 ASSERT(DestinationBuffer
!= NULL
);
2764 if (SourceSize
== 0 || SourceBuffer
== NULL
) {
2765 return (*DestinationBuffer
);
2768 if (DestinationSize
== NULL
) {
2769 LocalDestinationSize
= 0;
2771 LocalDestinationSize
= *DestinationSize
;
2774 LocalDestinationFinalSize
= LocalDestinationSize
+ SourceSize
;
2776 if (DestinationSize
!= NULL
) {
2777 *DestinationSize
= LocalDestinationSize
;
2780 if (LocalDestinationSize
== 0) {
2782 *DestinationBuffer
= AllocateZeroPool(LocalDestinationFinalSize
);
2785 *DestinationBuffer
= ReallocatePool(LocalDestinationSize
, LocalDestinationFinalSize
, *DestinationBuffer
);
2788 ASSERT(*DestinationBuffer
!= NULL
);
2791 return (CopyMem(((UINT8
*)(*DestinationBuffer
)) + LocalDestinationSize
, SourceBuffer
, SourceSize
));
2795 Gets handles for any child devices produced by the passed in driver.
2797 @param[in] DriverHandle The handle of the driver.
2798 @param[in] MatchingHandleCount Pointer to the number of handles in
2799 MatchingHandleBuffer on return.
2800 @param[out] MatchingHandleBuffer Buffer containing handles on a successful
2802 @retval EFI_SUCCESS The operation was sucessful.
2803 @sa ParseHandleDatabaseByRelationship
2807 ParseHandleDatabaseForChildDevices(
2808 IN CONST EFI_HANDLE DriverHandle
,
2809 IN UINTN
*MatchingHandleCount
,
2810 OUT EFI_HANDLE
**MatchingHandleBuffer OPTIONAL
2814 EFI_HANDLE
*Buffer2
;
2819 UINTN HandleBufferSize
;
2821 ASSERT(MatchingHandleCount
!= NULL
);
2823 HandleBufferSize
= 0;
2826 *MatchingHandleCount
= 0;
2828 Status
= PARSE_HANDLE_DATABASE_DEVICES (
2833 if (!EFI_ERROR (Status
)) {
2834 for (HandleIndex
= 0; HandleIndex
< Count1
; HandleIndex
++) {
2836 // now find the children
2838 Status
= PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
2840 Buffer
[HandleIndex
],
2844 if (EFI_ERROR(Status
)) {
2848 // save out required and optional data elements
2850 *MatchingHandleCount
+= Count2
;
2851 if (MatchingHandleBuffer
!= NULL
) {
2852 *MatchingHandleBuffer
= BuffernCatGrow((VOID
**)MatchingHandleBuffer
, &HandleBufferSize
, Buffer2
, Count2
* sizeof(Buffer2
[0]));
2858 if (Buffer2
!= NULL
) {
2864 if (Buffer
!= NULL
) {
2871 Function to get all handles that support a given protocol or all handles.
2873 @param[in] ProtocolGuid The guid of the protocol to get handles for. If NULL
2874 then the function will return all handles.
2876 @retval NULL A memory allocation failed.
2877 @return A NULL terminated list of handles.
2881 GetHandleListByProtocol (
2882 IN CONST EFI_GUID
*ProtocolGuid OPTIONAL
2885 EFI_HANDLE
*HandleList
;
2893 // We cannot use LocateHandleBuffer since we need that NULL item on the ends of the list!
2895 if (ProtocolGuid
== NULL
) {
2896 Status
= gBS
->LocateHandle(AllHandles
, NULL
, NULL
, &Size
, HandleList
);
2897 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2898 HandleList
= AllocateZeroPool(Size
+ sizeof(EFI_HANDLE
));
2899 if (HandleList
== NULL
) {
2902 Status
= gBS
->LocateHandle(AllHandles
, NULL
, NULL
, &Size
, HandleList
);
2903 HandleList
[Size
/sizeof(EFI_HANDLE
)] = NULL
;
2906 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)ProtocolGuid
, NULL
, &Size
, HandleList
);
2907 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2908 HandleList
= AllocateZeroPool(Size
+ sizeof(EFI_HANDLE
));
2909 if (HandleList
== NULL
) {
2912 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)ProtocolGuid
, NULL
, &Size
, HandleList
);
2913 HandleList
[Size
/sizeof(EFI_HANDLE
)] = NULL
;
2916 if (EFI_ERROR(Status
)) {
2917 if (HandleList
!= NULL
) {
2918 FreePool(HandleList
);
2922 return (HandleList
);
2926 Function to get all handles that support some protocols.
2928 @param[in] ProtocolGuids A NULL terminated list of protocol GUIDs.
2930 @retval NULL A memory allocation failed.
2931 @retval NULL ProtocolGuids was NULL.
2932 @return A NULL terminated list of EFI_HANDLEs.
2936 GetHandleListByProtocolList (
2937 IN CONST EFI_GUID
**ProtocolGuids
2940 EFI_HANDLE
*HandleList
;
2945 CONST EFI_GUID
**GuidWalker
;
2946 EFI_HANDLE
*HandleWalker1
;
2947 EFI_HANDLE
*HandleWalker2
;
2951 TotalSize
= sizeof(EFI_HANDLE
);
2953 for (GuidWalker
= ProtocolGuids
; GuidWalker
!= NULL
&& *GuidWalker
!= NULL
; GuidWalker
++,Size
= 0){
2954 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)(*GuidWalker
), NULL
, &Size
, NULL
);
2955 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2961 // No handles were found...
2963 if (TotalSize
== sizeof(EFI_HANDLE
)) {
2967 HandleList
= AllocateZeroPool(TotalSize
);
2968 if (HandleList
== NULL
) {
2973 for (GuidWalker
= ProtocolGuids
; GuidWalker
!= NULL
&& *GuidWalker
!= NULL
; GuidWalker
++){
2974 TempSize
= TotalSize
- Size
;
2975 Status
= gBS
->LocateHandle(ByProtocol
, (EFI_GUID
*)(*GuidWalker
), NULL
, &TempSize
, HandleList
+(Size
/sizeof(EFI_HANDLE
)));
2978 // Allow for missing protocols... Only update the 'used' size upon success.
2980 if (!EFI_ERROR(Status
)) {
2984 ASSERT(HandleList
[(TotalSize
/sizeof(EFI_HANDLE
))-1] == NULL
);
2986 for (HandleWalker1
= HandleList
; HandleWalker1
!= NULL
&& *HandleWalker1
!= NULL
; HandleWalker1
++) {
2987 for (HandleWalker2
= HandleWalker1
+ 1; HandleWalker2
!= NULL
&& *HandleWalker2
!= NULL
; HandleWalker2
++) {
2988 if (*HandleWalker1
== *HandleWalker2
) {
2990 // copy memory back 1 handle width.
2992 CopyMem(HandleWalker2
, HandleWalker2
+ 1, TotalSize
- ((HandleWalker2
-HandleList
+1)*sizeof(EFI_HANDLE
)));
2997 return (HandleList
);