]> git.proxmox.com Git - mirror_edk2.git/blob - ShellPkg/Library/UefiHandleParsingLib/UefiHandleParsingLib.c
projects / mirror_edk2.git / blob
? search:


aa0115bdd4986bb79b751a67b1e834a78cc3c313
[mirror_edk2.git] / ShellPkg / Library / UefiHandleParsingLib / UefiHandleParsingLib.c
1 /** @file
2 Provides interface to advanced shell functionality for parsing both handle and protocol database.
3
4 Copyright (c) 2010 - 2017, Intel Corporation. All rights reserved.<BR>
5 (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>
6 (C) Copyright 2015-2021 Hewlett Packard Enterprise Development LP<BR>
7 SPDX-License-Identifier: BSD-2-Clause-Patent
8
9 **/
10
11 #include "UefiHandleParsingLib.h"
12 #include "IndustryStandard/Acpi10.h"
13 #include "IndustryStandard/Pci.h"
14 #include <PiDxe.h>
15 #include <Protocol/FirmwareVolume2.h>
16
17 EFI_HII_HANDLE mHandleParsingHiiHandle = NULL;
18 HANDLE_INDEX_LIST mHandleList = {
19 {
20 { NULL, NULL }, 0, 0
21 }, 0
22 };
23 GUID_INFO_BLOCK *mGuidList;
24 UINTN mGuidListCount;
25
26 /**
27 Function to find the file name associated with a LoadedImageProtocol.
28
29 @param[in] LoadedImage An instance of LoadedImageProtocol.
30
31 @retval A string representation of the file name associated
32 with LoadedImage, or NULL if no name can be found.
33 **/
34 CHAR16 *
35 FindLoadedImageFileName (
36 IN EFI_LOADED_IMAGE_PROTOCOL *LoadedImage
37 )
38 {
39 EFI_GUID *NameGuid;
40 EFI_STATUS Status;
41 EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;
42 VOID *Buffer;
43 UINTN BufferSize;
44 UINT32 AuthenticationStatus;
45
46 if ((LoadedImage == NULL) || (LoadedImage->FilePath == NULL)) {
47 return NULL;
48 }
49
50 NameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)LoadedImage->FilePath);
51
52 if (NameGuid == NULL) {
53 return NULL;
54 }
55
56 //
57 // Get the FirmwareVolume2Protocol of the device handle that this image was loaded from.
58 //
59 Status = gBS->HandleProtocol (LoadedImage->DeviceHandle, &gEfiFirmwareVolume2ProtocolGuid, (VOID **)&Fv);
60
61 //
62 // FirmwareVolume2Protocol is PI, and is not required to be available.
63 //
64 if (EFI_ERROR (Status)) {
65 return NULL;
66 }
67
68 //
69 // Read the user interface section of the image.
70 //
71 Buffer = NULL;
72 Status = Fv->ReadSection (Fv, NameGuid, EFI_SECTION_USER_INTERFACE, 0, &Buffer, &BufferSize, &AuthenticationStatus);
73
74 if (EFI_ERROR (Status)) {
75 return NULL;
76 }
77
78 //
79 // ReadSection returns just the section data, without any section header. For
80 // a user interface section, the only data is the file name.
81 //
82 return Buffer;
83 }
84
85 /**
86 Function to translate the EFI_MEMORY_TYPE into a string.
87
88 @param[in] Memory The memory type.
89
90 @retval A string representation of the type allocated from BS Pool.
91 **/
92 CHAR16 *
93 ConvertMemoryType (
94 IN CONST EFI_MEMORY_TYPE Memory
95 )
96 {
97 CHAR16 *RetVal;
98
99 RetVal = NULL;
100
101 switch (Memory) {
102 case EfiReservedMemoryType: StrnCatGrow (&RetVal, NULL, L"EfiReservedMemoryType", 0);
103 break;
104 case EfiLoaderCode: StrnCatGrow (&RetVal, NULL, L"EfiLoaderCode", 0);
105 break;
106 case EfiLoaderData: StrnCatGrow (&RetVal, NULL, L"EfiLoaderData", 0);
107 break;
108 case EfiBootServicesCode: StrnCatGrow (&RetVal, NULL, L"EfiBootServicesCode", 0);
109 break;
110 case EfiBootServicesData: StrnCatGrow (&RetVal, NULL, L"EfiBootServicesData", 0);
111 break;
112 case EfiRuntimeServicesCode: StrnCatGrow (&RetVal, NULL, L"EfiRuntimeServicesCode", 0);
113 break;
114 case EfiRuntimeServicesData: StrnCatGrow (&RetVal, NULL, L"EfiRuntimeServicesData", 0);
115 break;
116 case EfiConventionalMemory: StrnCatGrow (&RetVal, NULL, L"EfiConventionalMemory", 0);
117 break;
118 case EfiUnusableMemory: StrnCatGrow (&RetVal, NULL, L"EfiUnusableMemory", 0);
119 break;
120 case EfiACPIReclaimMemory: StrnCatGrow (&RetVal, NULL, L"EfiACPIReclaimMemory", 0);
121 break;
122 case EfiACPIMemoryNVS: StrnCatGrow (&RetVal, NULL, L"EfiACPIMemoryNVS", 0);
123 break;
124 case EfiMemoryMappedIO: StrnCatGrow (&RetVal, NULL, L"EfiMemoryMappedIO", 0);
125 break;
126 case EfiMemoryMappedIOPortSpace: StrnCatGrow (&RetVal, NULL, L"EfiMemoryMappedIOPortSpace", 0);
127 break;
128 case EfiPalCode: StrnCatGrow (&RetVal, NULL, L"EfiPalCode", 0);
129 break;
130 case EfiMaxMemoryType: StrnCatGrow (&RetVal, NULL, L"EfiMaxMemoryType", 0);
131 break;
132 default: ASSERT (FALSE);
133 }
134
135 return (RetVal);
136 }
137
138 /**
139 Function to translate the EFI_GRAPHICS_PIXEL_FORMAT into a string.
140
141 @param[in] Fmt The format type.
142
143 @retval A string representation of the type allocated from BS Pool.
144 **/
145 CHAR16 *
146 ConvertPixelFormat (
147 IN CONST EFI_GRAPHICS_PIXEL_FORMAT Fmt
148 )
149 {
150 CHAR16 *RetVal;
151
152 RetVal = NULL;
153
154 switch (Fmt) {
155 case PixelRedGreenBlueReserved8BitPerColor: StrnCatGrow (&RetVal, NULL, L"PixelRedGreenBlueReserved8BitPerColor", 0);
156 break;
157 case PixelBlueGreenRedReserved8BitPerColor: StrnCatGrow (&RetVal, NULL, L"PixelBlueGreenRedReserved8BitPerColor", 0);
158 break;
159 case PixelBitMask: StrnCatGrow (&RetVal, NULL, L"PixelBitMask", 0);
160 break;
161 case PixelBltOnly: StrnCatGrow (&RetVal, NULL, L"PixelBltOnly", 0);
162 break;
163 case PixelFormatMax: StrnCatGrow (&RetVal, NULL, L"PixelFormatMax", 0);
164 break;
165 default: ASSERT (FALSE);
166 }
167
168 return (RetVal);
169 }
170
171 /**
172 Constructor for the library.
173
174 @param[in] ImageHandle Ignored.
175 @param[in] SystemTable Ignored.
176
177 @retval EFI_SUCCESS The operation was successful.
178 **/
179 EFI_STATUS
180 EFIAPI
181 HandleParsingLibConstructor (
182 IN EFI_HANDLE ImageHandle,
183 IN EFI_SYSTEM_TABLE *SystemTable
184 )
185 {
186 mGuidListCount = 0;
187 mGuidList = NULL;
188
189 //
190 // Do nothing with mHandleParsingHiiHandle. Initialize HII as needed.
191 //
192 return (EFI_SUCCESS);
193 }
194
195 /**
196 Initialization function for HII packages.
197
198 **/
199 VOID
200 HandleParsingHiiInit (
201 VOID
202 )
203 {
204 if (mHandleParsingHiiHandle == NULL) {
205 mHandleParsingHiiHandle = HiiAddPackages (&gHandleParsingHiiGuid, gImageHandle, UefiHandleParsingLibStrings, NULL);
206 ASSERT (mHandleParsingHiiHandle != NULL);
207 }
208 }
209
210 /**
211 Destructor for the library. free any resources.
212
213 @param[in] ImageHandle Ignored.
214 @param[in] SystemTable Ignored.
215
216 @retval EFI_SUCCESS The operation was successful.
217 **/
218 EFI_STATUS
219 EFIAPI
220 HandleParsingLibDestructor (
221 IN EFI_HANDLE ImageHandle,
222 IN EFI_SYSTEM_TABLE *SystemTable
223 )
224 {
225 UINTN LoopCount;
226
227 for (LoopCount = 0; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++) {
228 SHELL_FREE_NON_NULL (mGuidList[LoopCount].GuidId);
229 }
230
231 SHELL_FREE_NON_NULL (mGuidList);
232 if (mHandleParsingHiiHandle != NULL) {
233 HiiRemovePackages (mHandleParsingHiiHandle);
234 }
235
236 return (EFI_SUCCESS);
237 }
238
239 /**
240 Function to dump information about LoadedImage.
241
242 This will allocate the return buffer from boot services pool.
243
244 @param[in] TheHandle The handle that has LoadedImage installed.
245 @param[in] Verbose TRUE for additional information, FALSE otherwise.
246
247 @retval A poitner to a string containing the information.
248 **/
249 CHAR16 *
250 EFIAPI
251 LoadedImageProtocolDumpInformation (
252 IN CONST EFI_HANDLE TheHandle,
253 IN CONST BOOLEAN Verbose
254 )
255 {
256 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
257 EFI_STATUS Status;
258 CHAR16 *RetVal;
259 CHAR16 *Temp;
260 CHAR16 *FileName;
261 CHAR8 *PdbFileName;
262 CHAR16 *FilePath;
263 CHAR16 *CodeType;
264 CHAR16 *DataType;
265
266 Status = gBS->OpenProtocol (
267 TheHandle,
268 &gEfiLoadedImageProtocolGuid,
269 (VOID **)&LoadedImage,
270 gImageHandle,
271 NULL,
272 EFI_OPEN_PROTOCOL_GET_PROTOCOL
273 );
274
275 if (EFI_ERROR (Status)) {
276 return NULL;
277 }
278
279 FileName = FindLoadedImageFileName (LoadedImage);
280 FilePath = ConvertDevicePathToText (LoadedImage->FilePath, TRUE, TRUE);
281 if (!Verbose) {
282 if (FileName == NULL) {
283 FileName = FilePath;
284 } else {
285 SHELL_FREE_NON_NULL (FilePath);
286 }
287
288 return FileName;
289 }
290
291 HandleParsingHiiInit ();
292 RetVal = NULL;
293 if (FileName != NULL) {
294 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_LI_DUMP_NAME), NULL);
295
296 if (Temp != NULL) {
297 RetVal = CatSPrint (NULL, Temp, FileName);
298 }
299
300 SHELL_FREE_NON_NULL (Temp);
301 SHELL_FREE_NON_NULL (FileName);
302 }
303
304 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_LI_DUMP_MAIN), NULL);
305 if (Temp == NULL) {
306 return NULL;
307 }
308
309 PdbFileName = PeCoffLoaderGetPdbPointer (LoadedImage->ImageBase);
310 DataType = ConvertMemoryType (LoadedImage->ImageDataType);
311 CodeType = ConvertMemoryType (LoadedImage->ImageCodeType);
312
313 RetVal = CatSPrint (
314 RetVal,
315 Temp,
316 LoadedImage->Revision,
317 LoadedImage->ParentHandle,
318 LoadedImage->SystemTable,
319 LoadedImage->DeviceHandle,
320 FilePath,
321 PdbFileName,
322 LoadedImage->LoadOptionsSize,
323 LoadedImage->LoadOptions,
324 LoadedImage->ImageBase,
325 LoadedImage->ImageSize,
326 CodeType,
327 DataType,
328 LoadedImage->Unload
329 );
330
331 SHELL_FREE_NON_NULL (Temp);
332 SHELL_FREE_NON_NULL (FilePath);
333 SHELL_FREE_NON_NULL (CodeType);
334 SHELL_FREE_NON_NULL (DataType);
335
336 return RetVal;
337 }
338
339 /**
340 Function to dump information about GOP.
341
342 This will allocate the return buffer from boot services pool.
343
344 @param[in] TheHandle The handle that has LoadedImage installed.
345 @param[in] Verbose TRUE for additional information, FALSE otherwise.
346
347 @retval A poitner to a string containing the information.
348 **/
349 CHAR16 *
350 EFIAPI
351 GraphicsOutputProtocolDumpInformation (
352 IN CONST EFI_HANDLE TheHandle,
353 IN CONST BOOLEAN Verbose
354 )
355 {
356 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
357 EFI_STATUS Status;
358 CHAR16 *RetVal;
359 CHAR16 *Temp;
360 CHAR16 *Fmt;
361 CHAR16 *TempRetVal;
362 UINTN GopInfoSize;
363 UINT32 Mode;
364 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *GopInfo;
365
366 if (!Verbose) {
367 return (CatSPrint (NULL, L"GraphicsOutput"));
368 }
369
370 HandleParsingHiiInit ();
371
372 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GOP_DUMP_MAIN), NULL);
373 if (Temp == NULL) {
374 return NULL;
375 }
376
377 Status = gBS->OpenProtocol (
378 TheHandle,
379 &gEfiGraphicsOutputProtocolGuid,
380 (VOID **)&GraphicsOutput,
381 gImageHandle,
382 NULL,
383 EFI_OPEN_PROTOCOL_GET_PROTOCOL
384 );
385
386 if (EFI_ERROR (Status)) {
387 SHELL_FREE_NON_NULL (Temp);
388 return NULL;
389 }
390
391 Fmt = ConvertPixelFormat (GraphicsOutput->Mode->Info->PixelFormat);
392
393 RetVal = CatSPrint (
394 NULL,
395 Temp,
396 GraphicsOutput->Mode->MaxMode,
397 GraphicsOutput->Mode->Mode,
398 GraphicsOutput->Mode->FrameBufferBase,
399 (UINT64)GraphicsOutput->Mode->FrameBufferSize,
400 (UINT64)GraphicsOutput->Mode->SizeOfInfo,
401 GraphicsOutput->Mode->Info->Version,
402 GraphicsOutput->Mode->Info->HorizontalResolution,
403 GraphicsOutput->Mode->Info->VerticalResolution,
404 Fmt,
405 GraphicsOutput->Mode->Info->PixelsPerScanLine,
406 GraphicsOutput->Mode->Info->PixelFormat != PixelBitMask ? 0 : GraphicsOutput->Mode->Info->PixelInformation.RedMask,
407 GraphicsOutput->Mode->Info->PixelFormat != PixelBitMask ? 0 : GraphicsOutput->Mode->Info->PixelInformation.GreenMask,
408 GraphicsOutput->Mode->Info->PixelFormat != PixelBitMask ? 0 : GraphicsOutput->Mode->Info->PixelInformation.BlueMask
409 );
410
411 SHELL_FREE_NON_NULL (Temp);
412
413 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GOP_RES_LIST_MAIN), NULL);
414 if (Temp == NULL) {
415 SHELL_FREE_NON_NULL (RetVal);
416 goto EXIT;
417 }
418
419 TempRetVal = CatSPrint (RetVal, Temp);
420 SHELL_FREE_NON_NULL (RetVal);
421 if (TempRetVal == NULL) {
422 goto EXIT;
423 }
424
425 RetVal = TempRetVal;
426 SHELL_FREE_NON_NULL (Temp);
427
428 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GOP_RES_LIST_ENTRY), NULL);
429 if (Temp == NULL) {
430 SHELL_FREE_NON_NULL (RetVal);
431 goto EXIT;
432 }
433
434 for (Mode = 0; Mode < GraphicsOutput->Mode->MaxMode; Mode++) {
435 Status = GraphicsOutput->QueryMode (
436 GraphicsOutput,
437 Mode,
438 &GopInfoSize,
439 &GopInfo
440 );
441 if (EFI_ERROR (Status)) {
442 continue;
443 }
444
445 TempRetVal = CatSPrint (
446 RetVal,
447 Temp,
448 Mode,
449 GopInfo->HorizontalResolution,
450 GopInfo->VerticalResolution
451 );
452
453 SHELL_FREE_NON_NULL (GopInfo);
454 SHELL_FREE_NON_NULL (RetVal);
455 RetVal = TempRetVal;
456 }
457
458 EXIT:
459 SHELL_FREE_NON_NULL (Temp);
460 SHELL_FREE_NON_NULL (Fmt);
461
462 return RetVal;
463 }
464
465 /**
466 Function to dump information about EDID Discovered Protocol.
467
468 This will allocate the return buffer from boot services pool.
469
470 @param[in] TheHandle The handle that has LoadedImage installed.
471 @param[in] Verbose TRUE for additional information, FALSE otherwise.
472
473 @retval A pointer to a string containing the information.
474 **/
475 CHAR16 *
476 EFIAPI
477 EdidDiscoveredProtocolDumpInformation (
478 IN CONST EFI_HANDLE TheHandle,
479 IN CONST BOOLEAN Verbose
480 )
481 {
482 EFI_EDID_DISCOVERED_PROTOCOL *EdidDiscovered;
483 EFI_STATUS Status;
484 CHAR16 *RetVal;
485 CHAR16 *Temp;
486 CHAR16 *TempRetVal;
487
488 if (!Verbose) {
489 return (CatSPrint (NULL, L"EDIDDiscovered"));
490 }
491
492 Status = gBS->OpenProtocol (
493 TheHandle,
494 &gEfiEdidDiscoveredProtocolGuid,
495 (VOID **)&EdidDiscovered,
496 NULL,
497 NULL,
498 EFI_OPEN_PROTOCOL_GET_PROTOCOL
499 );
500
501 if (EFI_ERROR (Status)) {
502 return NULL;
503 }
504
505 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_DISCOVERED_MAIN), NULL);
506 if (Temp == NULL) {
507 return NULL;
508 }
509
510 RetVal = CatSPrint (NULL, Temp, EdidDiscovered->SizeOfEdid);
511 SHELL_FREE_NON_NULL (Temp);
512
513 if (EdidDiscovered->SizeOfEdid != 0) {
514 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_DISCOVERED_DATA), NULL);
515 if (Temp == NULL) {
516 SHELL_FREE_NON_NULL (RetVal);
517 return NULL;
518 }
519
520 TempRetVal = CatSPrint (RetVal, Temp);
521 SHELL_FREE_NON_NULL (RetVal);
522 RetVal = TempRetVal;
523
524 TempRetVal = CatSDumpHex (RetVal, 4, 0, EdidDiscovered->SizeOfEdid, EdidDiscovered->Edid);
525 RetVal = TempRetVal;
526 }
527
528 return RetVal;
529 }
530
531 /**
532 Function to dump information about EDID Active Protocol.
533
534 This will allocate the return buffer from boot services pool.
535
536 @param[in] TheHandle The handle that has LoadedImage installed.
537 @param[in] Verbose TRUE for additional information, FALSE otherwise.
538
539 @retval A pointer to a string containing the information.
540 **/
541 CHAR16 *
542 EFIAPI
543 EdidActiveProtocolDumpInformation (
544 IN CONST EFI_HANDLE TheHandle,
545 IN CONST BOOLEAN Verbose
546 )
547 {
548 EFI_EDID_ACTIVE_PROTOCOL *EdidActive;
549 EFI_STATUS Status;
550 CHAR16 *RetVal;
551 CHAR16 *Temp;
552 CHAR16 *TempRetVal;
553
554 if (!Verbose) {
555 return (CatSPrint (NULL, L"EDIDActive"));
556 }
557
558 Status = gBS->OpenProtocol (
559 TheHandle,
560 &gEfiEdidActiveProtocolGuid,
561 (VOID **)&EdidActive,
562 NULL,
563 NULL,
564 EFI_OPEN_PROTOCOL_GET_PROTOCOL
565 );
566
567 if (EFI_ERROR (Status)) {
568 return NULL;
569 }
570
571 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_ACTIVE_MAIN), NULL);
572 if (Temp == NULL) {
573 return NULL;
574 }
575
576 RetVal = CatSPrint (NULL, Temp, EdidActive->SizeOfEdid);
577 SHELL_FREE_NON_NULL (Temp);
578
579 if (EdidActive->SizeOfEdid != 0) {
580 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_EDID_ACTIVE_DATA), NULL);
581 if (Temp == NULL) {
582 SHELL_FREE_NON_NULL (RetVal);
583 return NULL;
584 }
585
586 TempRetVal = CatSPrint (RetVal, Temp);
587 SHELL_FREE_NON_NULL (RetVal);
588 RetVal = TempRetVal;
589
590 TempRetVal = CatSDumpHex (RetVal, 4, 0, EdidActive->SizeOfEdid, EdidActive->Edid);
591 RetVal = TempRetVal;
592 }
593
594 return RetVal;
595 }
596
597 /**
598 Function to dump information about PciRootBridgeIo.
599
600 This will allocate the return buffer from boot services pool.
601
602 @param[in] TheHandle The handle that has PciRootBridgeIo installed.
603 @param[in] Verbose TRUE for additional information, FALSE otherwise.
604
605 @retval A poitner to a string containing the information.
606 **/
607 CHAR16 *
608 EFIAPI
609 PciRootBridgeIoDumpInformation (
610 IN CONST EFI_HANDLE TheHandle,
611 IN CONST BOOLEAN Verbose
612 )
613 {
614 EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *PciRootBridgeIo;
615 EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *Configuration;
616 UINT64 Supports;
617 UINT64 Attributes;
618 CHAR16 *Temp;
619 CHAR16 *Temp2;
620 CHAR16 *RetVal;
621 EFI_STATUS Status;
622
623 RetVal = NULL;
624
625 if (!Verbose) {
626 return (CatSPrint (NULL, L"PciRootBridgeIo"));
627 }
628
629 HandleParsingHiiInit ();
630
631 Status = gBS->HandleProtocol (
632 TheHandle,
633 &gEfiPciRootBridgeIoProtocolGuid,
634 (VOID **)&PciRootBridgeIo
635 );
636
637 if (EFI_ERROR (Status)) {
638 return NULL;
639 }
640
641 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PCIRB_DUMP_PH), NULL);
642 if (Temp == NULL) {
643 return NULL;
644 }
645
646 Temp2 = CatSPrint (NULL, Temp, PciRootBridgeIo->ParentHandle);
647 FreePool (Temp);
648 RetVal = Temp2;
649 Temp2 = NULL;
650
651 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PCIRB_DUMP_SEG), NULL);
652 if (Temp == NULL) {
653 SHELL_FREE_NON_NULL (RetVal);
654 return NULL;
655 }
656
657 Temp2 = CatSPrint (RetVal, Temp, PciRootBridgeIo->SegmentNumber);
658 FreePool (Temp);
659 FreePool (RetVal);
660 RetVal = Temp2;
661 Temp2 = NULL;
662
663 Supports = 0;
664 Attributes = 0;
665 Status = PciRootBridgeIo->GetAttributes (PciRootBridgeIo, &Supports, &Attributes);
666 if (!EFI_ERROR (Status)) {
667 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PCIRB_DUMP_ATT), NULL);
668 if (Temp == NULL) {
669 SHELL_FREE_NON_NULL (RetVal);
670 return NULL;
671 }
672
673 Temp2 = CatSPrint (RetVal, Temp, Attributes);
674 FreePool (Temp);
675 FreePool (RetVal);
676 RetVal = Temp2;
677 Temp2 = NULL;
678
679 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PCIRB_DUMP_SUPPORTS), NULL);
680 if (Temp == NULL) {
681 SHELL_FREE_NON_NULL (RetVal);
682 return NULL;
683 }
684
685 Temp2 = CatSPrint (RetVal, Temp, Supports);
686 FreePool (Temp);
687 FreePool (RetVal);
688 RetVal = Temp2;
689 Temp2 = NULL;
690 }
691
692 Configuration = NULL;
693 Status = PciRootBridgeIo->Configuration (PciRootBridgeIo, (VOID **)&Configuration);
694 if (!EFI_ERROR (Status) && (Configuration != NULL)) {
695 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PCIRB_DUMP_TITLE), NULL);
696 if (Temp == NULL) {
697 SHELL_FREE_NON_NULL (RetVal);
698 return NULL;
699 }
700
701 Temp2 = CatSPrint (RetVal, Temp, Supports);
702 FreePool (Temp);
703 FreePool (RetVal);
704 RetVal = Temp2;
705 Temp2 = NULL;
706 while (Configuration->Desc == ACPI_ADDRESS_SPACE_DESCRIPTOR) {
707 Temp = NULL;
708 switch (Configuration->ResType) {
709 case ACPI_ADDRESS_SPACE_TYPE_MEM:
710 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PCIRB_DUMP_MEM), NULL);
711 break;
712 case ACPI_ADDRESS_SPACE_TYPE_IO:
713 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PCIRB_DUMP_IO), NULL);
714 break;
715 case ACPI_ADDRESS_SPACE_TYPE_BUS:
716 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PCIRB_DUMP_BUS), NULL);
717 break;
718 }
719
720 if (Temp != NULL) {
721 Temp2 = CatSPrint (RetVal, L"\r\n%s", Temp);
722 FreePool (Temp);
723 FreePool (RetVal);
724 RetVal = Temp2;
725 Temp2 = NULL;
726 }
727
728 Temp2 = CatSPrint (
729 RetVal,
730 L"%%H%02x %016lx %016lx %02x%%N",
731 Configuration->SpecificFlag,
732 Configuration->AddrRangeMin,
733 Configuration->AddrRangeMax,
734 Configuration->AddrSpaceGranularity
735 );
736 FreePool (RetVal);
737 RetVal = Temp2;
738 Temp2 = NULL;
739 Configuration++;
740 }
741 }
742
743 return (RetVal);
744 }
745
746 /**
747 Function to dump information about SimpleTextOut.
748
749 This will allocate the return buffer from boot services pool.
750
751 @param[in] TheHandle The handle that has SimpleTextOut installed.
752 @param[in] Verbose TRUE for additional information, FALSE otherwise.
753
754 @retval A poitner to a string containing the information.
755 **/
756 CHAR16 *
757 EFIAPI
758 TxtOutProtocolDumpInformation (
759 IN CONST EFI_HANDLE TheHandle,
760 IN CONST BOOLEAN Verbose
761 )
762 {
763 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Dev;
764 INTN Index;
765 UINTN Col;
766 UINTN Row;
767 EFI_STATUS Status;
768 CHAR16 *RetVal;
769 UINTN Size;
770 CHAR16 *Temp;
771 UINTN NewSize;
772
773 if (!Verbose) {
774 return (NULL);
775 }
776
777 HandleParsingHiiInit ();
778
779 RetVal = NULL;
780 Size = 0;
781
782 Status = gBS->HandleProtocol (
783 TheHandle,
784 &gEfiSimpleTextOutProtocolGuid,
785 (VOID **)&Dev
786 );
787
788 ASSERT_EFI_ERROR (Status);
789 ASSERT (Dev != NULL && Dev->Mode != NULL);
790
791 Size = (Dev->Mode->MaxMode + 1) * 80;
792 RetVal = AllocateZeroPool (Size);
793
794 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_TXT_OUT_DUMP_HEADER), NULL);
795 if (Temp != NULL) {
796 UnicodeSPrint (RetVal, Size, Temp, Dev, Dev->Mode->Attribute);
797 FreePool (Temp);
798 }
799
800 //
801 // Dump TextOut Info
802 //
803 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_TXT_OUT_DUMP_LINE), NULL);
804 for (Index = 0; Index < Dev->Mode->MaxMode; Index++) {
805 Status = Dev->QueryMode (Dev, Index, &Col, &Row);
806 NewSize = Size - StrSize (RetVal);
807 UnicodeSPrint (
808 RetVal + StrLen (RetVal),
809 NewSize,
810 Temp == NULL ? L"" : Temp,
811 Index == Dev->Mode->Mode ? L'*' : L' ',
812 Index,
813 !EFI_ERROR (Status) ? (INTN)Col : -1,
814 !EFI_ERROR (Status) ? (INTN)Row : -1
815 );
816 }
817
818 FreePool (Temp);
819 return (RetVal);
820 }
821
822 STATIC CONST UINTN VersionStringSize = 60;
823
824 /**
825 Function to dump information about EfiDriverSupportedEfiVersion protocol.
826
827 This will allocate the return buffer from boot services pool.
828
829 @param[in] TheHandle The handle that has the protocol installed.
830 @param[in] Verbose TRUE for additional information, FALSE otherwise.
831
832 @retval A poitner to a string containing the information.
833 **/
834 CHAR16 *
835 EFIAPI
836 DriverEfiVersionProtocolDumpInformation (
837 IN CONST EFI_HANDLE TheHandle,
838 IN CONST BOOLEAN Verbose
839 )
840 {
841 EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *DriverEfiVersion;
842 EFI_STATUS Status;
843 CHAR16 *RetVal;
844
845 Status = gBS->HandleProtocol (
846 TheHandle,
847 &gEfiDriverSupportedEfiVersionProtocolGuid,
848 (VOID **)&DriverEfiVersion
849 );
850
851 ASSERT_EFI_ERROR (Status);
852
853 RetVal = AllocateZeroPool (VersionStringSize);
854 if (RetVal != NULL) {
855 UnicodeSPrint (RetVal, VersionStringSize, L"0x%08x", DriverEfiVersion->FirmwareVersion);
856 }
857
858 return (RetVal);
859 }
860
861 /**
862 Function to convert device path to string.
863
864 This will allocate the return buffer from boot services pool.
865
866 @param[in] DevPath Pointer to device path instance.
867 @param[in] Verbose TRUE for additional information, FALSE otherwise.
868 @param[in] Length Maximum allowed text length of the device path.
869
870 @retval A pointer to a string containing the information.
871 **/
872 CHAR16 *
873 ConvertDevicePathToShortText (
874 IN CONST EFI_DEVICE_PATH_PROTOCOL *DevPath,
875 IN CONST BOOLEAN Verbose,
876 IN CONST UINTN Length
877 )
878 {
879 CHAR16 *Temp;
880 CHAR16 *Temp2;
881 UINTN Size;
882
883 //
884 // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)
885 //
886 Temp = ConvertDevicePathToText (DevPath, TRUE, TRUE);
887 if (!Verbose && (Temp != NULL) && (StrLen (Temp) > Length)) {
888 Temp2 = NULL;
889 Size = 0;
890 Temp2 = StrnCatGrow (&Temp2, &Size, L"..", 0);
891 Temp2 = StrnCatGrow (&Temp2, &Size, Temp+(StrLen (Temp) - (Length - 2)), 0);
892 FreePool (Temp);
893 Temp = Temp2;
894 }
895
896 return (Temp);
897 }
898
899 /**
900 Function to dump protocol information.
901
902 This will allocate the return buffer from boot services pool.
903
904 @param[in] TheHandle The handle that has the protocol installed.
905 @param[in] Verbose TRUE for additional information, FALSE otherwise.
906 @param[in] Protocol The protocol is needed to dump.
907
908 @retval A pointer to a string containing the information.
909 **/
910 STATIC CHAR16 *
911 EFIAPI
912 DevicePathProtocolDumpInformationEx (
913 IN CONST EFI_HANDLE TheHandle,
914 IN CONST BOOLEAN Verbose,
915 IN EFI_GUID *Protocol
916 )
917 {
918 EFI_DEVICE_PATH_PROTOCOL *DevPath;
919 CHAR16 *DevPathStr;
920 CHAR16 *DevPathStrTemp;
921 UINTN Size;
922 EFI_STATUS Status;
923
924 DevPathStr = NULL;
925 DevPathStrTemp = NULL;
926 Status = gBS->OpenProtocol (TheHandle, Protocol, (VOID **)&DevPath, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
927 if (!EFI_ERROR (Status)) {
928 DevPathStr = ConvertDevicePathToShortText (DevPath, Verbose, 30);
929 if (Verbose) {
930 Size = StrSize (DevPathStr) + sizeof (CHAR16) * 2;
931 DevPathStrTemp = AllocateZeroPool (Size);
932 if (DevPathStrTemp != NULL) {
933 StrnCatS (DevPathStrTemp, Size/sizeof (CHAR16), L" ", 2);
934 StrnCatS (DevPathStrTemp, Size/sizeof (CHAR16), DevPathStr, StrLen (DevPathStr));
935 }
936
937 FreePool (DevPathStr);
938 DevPathStr = DevPathStrTemp;
939 }
940
941 gBS->CloseProtocol (TheHandle, Protocol, gImageHandle, NULL);
942 }
943
944 return DevPathStr;
945 }
946
947 /**
948 Function to dump information about DevicePath protocol.
949
950 This will allocate the return buffer from boot services pool.
951
952 @param[in] TheHandle The handle that has the protocol installed.
953 @param[in] Verbose TRUE for additional information, FALSE otherwise.
954
955 @retval A pointer to a string containing the information.
956 **/
957 CHAR16 *
958 EFIAPI
959 DevicePathProtocolDumpInformation (
960 IN CONST EFI_HANDLE TheHandle,
961 IN CONST BOOLEAN Verbose
962 )
963 {
964 return DevicePathProtocolDumpInformationEx (TheHandle, Verbose, &gEfiDevicePathProtocolGuid);
965 }
966
967 /**
968 Function to dump information about LoadedImageDevicePath protocol.
969
970 This will allocate the return buffer from boot services pool.
971
972 @param[in] TheHandle The handle that has the protocol installed.
973 @param[in] Verbose TRUE for additional information, FALSE otherwise.
974
975 @retval A pointer to a string containing the information.
976 **/
977 CHAR16 *
978 EFIAPI
979 LoadedImageDevicePathProtocolDumpInformation (
980 IN CONST EFI_HANDLE TheHandle,
981 IN CONST BOOLEAN Verbose
982 )
983 {
984 return DevicePathProtocolDumpInformationEx (TheHandle, Verbose, &gEfiLoadedImageDevicePathProtocolGuid);
985 }
986
987 /**
988 Function to dump information about BusSpecificDriverOverride protocol.
989
990 This will allocate the return buffer from boot services pool.
991
992 @param[in] TheHandle The handle that has the protocol installed.
993 @param[in] Verbose TRUE for additional information, FALSE otherwise.
994
995 @retval A pointer to a string containing the information.
996 **/
997 CHAR16 *
998 EFIAPI
999 BusSpecificDriverOverrideProtocolDumpInformation (
1000 IN CONST EFI_HANDLE TheHandle,
1001 IN CONST BOOLEAN Verbose
1002 )
1003 {
1004 EFI_STATUS Status;
1005 CHAR16 *GetString;
1006 CHAR16 *RetVal;
1007 CHAR16 *TempRetVal;
1008 EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL *BusSpecificDriverOverride;
1009 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
1010 EFI_HANDLE ImageHandle;
1011 UINTN Size;
1012
1013 if (!Verbose) {
1014 return NULL;
1015 }
1016
1017 Size = 0;
1018 GetString = NULL;
1019 RetVal = NULL;
1020 TempRetVal = NULL;
1021 ImageHandle = 0;
1022
1023 Status = gBS->OpenProtocol (
1024 TheHandle,
1025 &gEfiBusSpecificDriverOverrideProtocolGuid,
1026 (VOID **)&BusSpecificDriverOverride,
1027 gImageHandle,
1028 NULL,
1029 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1030 );
1031 if (EFI_ERROR (Status)) {
1032 return NULL;
1033 }
1034
1035 HandleParsingHiiInit ();
1036 GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_BSDO_DUMP_MAIN), NULL);
1037 if (GetString == NULL) {
1038 return NULL;
1039 }
1040
1041 do {
1042 Status = BusSpecificDriverOverride->GetDriver (
1043 BusSpecificDriverOverride,
1044 &ImageHandle
1045 );
1046 if (!EFI_ERROR (Status)) {
1047 Status = gBS->HandleProtocol (
1048 ImageHandle,
1049 &gEfiLoadedImageProtocolGuid,
1050 (VOID **)&LoadedImage
1051 );
1052 if (!EFI_ERROR (Status)) {
1053 TempRetVal = CatSPrint (
1054 TempRetVal,
1055 GetString,
1056 ConvertHandleToHandleIndex (ImageHandle),
1057 ConvertDevicePathToText (LoadedImage->FilePath, TRUE, TRUE)
1058 );
1059 StrnCatGrow (&RetVal, &Size, TempRetVal, 0);
1060 SHELL_FREE_NON_NULL (TempRetVal);
1061 }
1062 }
1063 } while (!EFI_ERROR (Status));
1064
1065 SHELL_FREE_NON_NULL (GetString);
1066 return RetVal;
1067 }
1068
1069 /**
1070 Function to dump information about BlockIo protocol.
1071
1072 This will allocate the return buffer from boot services pool.
1073
1074 @param[in] TheHandle The handle that has the protocol installed.
1075 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1076
1077 @retval A pointer to a string containing the information.
1078 **/
1079 CHAR16 *
1080 EFIAPI
1081 BlockIoProtocolDumpInformation (
1082 IN CONST EFI_HANDLE TheHandle,
1083 IN CONST BOOLEAN Verbose
1084 )
1085 {
1086 EFI_STATUS Status;
1087 EFI_BLOCK_IO_PROTOCOL *BlockIo;
1088 EFI_BLOCK_IO_MEDIA *BlockMedia;
1089 CHAR16 *GetString;
1090 CHAR16 *RetVal;
1091
1092 if (!Verbose) {
1093 return NULL;
1094 }
1095
1096 GetString = NULL;
1097 RetVal = NULL;
1098
1099 Status = gBS->OpenProtocol (
1100 TheHandle,
1101 &gEfiBlockIoProtocolGuid,
1102 (VOID **)&BlockIo,
1103 gImageHandle,
1104 NULL,
1105 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1106 );
1107 if (EFI_ERROR (Status)) {
1108 return NULL;
1109 }
1110
1111 BlockMedia = BlockIo->Media;
1112 //
1113 // Per spec:
1114 // The function (ReadBlocks) must return EFI_NO_MEDIA or
1115 // EFI_MEDIA_CHANGED even if LBA, BufferSize, or Buffer are invalid so the caller can probe
1116 // for changes in media state.
1117 //
1118 BlockIo->ReadBlocks (
1119 BlockIo,
1120 BlockIo->Media->MediaId,
1121 0,
1122 0,
1123 NULL
1124 );
1125
1126 HandleParsingHiiInit ();
1127 GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_BLOCKIO_INFO), NULL);
1128 if (GetString == NULL) {
1129 return NULL;
1130 }
1131
1132 RetVal = CatSPrint (
1133 RetVal,
1134 GetString,
1135 BlockMedia->RemovableMedia ? L"Removable " : L"Fixed ",
1136 BlockMedia->MediaPresent ? L"" : L"not-present ",
1137 BlockMedia->MediaId,
1138 BlockMedia->BlockSize,
1139 BlockMedia->LastBlock,
1140 MultU64x32 (BlockMedia->LastBlock + 1, BlockMedia->BlockSize),
1141 BlockMedia->LogicalPartition ? L"partition" : L"raw",
1142 BlockMedia->ReadOnly ? L"ro" : L"rw",
1143 BlockMedia->WriteCaching ? L"cached" : L"!cached"
1144 );
1145
1146 SHELL_FREE_NON_NULL (GetString);
1147 return RetVal;
1148 }
1149
1150 /**
1151 Function to dump information about DebugSupport Protocol.
1152
1153 @param[in] TheHandle The handle that has the protocol installed.
1154 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1155
1156 @retval A pointer to a string containing the information.
1157 **/
1158 CHAR16 *
1159 EFIAPI
1160 DebugSupportProtocolDumpInformation (
1161 IN CONST EFI_HANDLE TheHandle,
1162 IN CONST BOOLEAN Verbose
1163 )
1164 {
1165 EFI_STATUS Status;
1166 EFI_DEBUG_SUPPORT_PROTOCOL *DebugSupport;
1167 CHAR16 *GetString;
1168 CHAR16 *RetVal;
1169
1170 if (!Verbose) {
1171 return NULL;
1172 }
1173
1174 GetString = NULL;
1175 RetVal = NULL;
1176 Status = gBS->OpenProtocol (
1177 TheHandle,
1178 &gEfiDebugSupportProtocolGuid,
1179 (VOID **)&DebugSupport,
1180 gImageHandle,
1181 NULL,
1182 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1183 );
1184 if (EFI_ERROR (Status)) {
1185 return NULL;
1186 }
1187
1188 HandleParsingHiiInit ();
1189 GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_DEBUGSUPPORT_INFO), NULL);
1190 if (GetString == NULL) {
1191 return NULL;
1192 }
1193
1194 //
1195 // Dump Debug support info
1196 //
1197 switch (DebugSupport->Isa) {
1198 case (IsaIa32):
1199 RetVal = CatSPrint (RetVal, GetString, L"IA-32");
1200 break;
1201 case (IsaIpf):
1202 RetVal = CatSPrint (RetVal, GetString, L"IPF");
1203 break;
1204 case (IsaEbc):
1205 RetVal = CatSPrint (RetVal, GetString, L"EBC");
1206 break;
1207 default:
1208 SHELL_FREE_NON_NULL (GetString);
1209 GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_DEBUGSUPPORT_UNKNOWN), NULL);
1210 RetVal = GetString != NULL ? CatSPrint (RetVal, GetString, DebugSupport->Isa) : NULL;
1211 break;
1212 }
1213
1214 SHELL_FREE_NON_NULL (GetString);
1215 return RetVal;
1216 }
1217
1218 /**
1219 Function to dump information about PciIoProtocol.
1220
1221 This will allocate the return buffer from boot services pool.
1222
1223 @param[in] TheHandle The handle that has PciRootBridgeIo installed.
1224 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1225
1226 @retval A poitner to a string containing the information.
1227 **/
1228 CHAR16 *
1229 EFIAPI
1230 PciIoProtocolDumpInformation (
1231 IN CONST EFI_HANDLE TheHandle,
1232 IN CONST BOOLEAN Verbose
1233 )
1234 {
1235 EFI_STATUS Status;
1236 EFI_PCI_IO_PROTOCOL *PciIo;
1237 PCI_TYPE00 Pci;
1238 UINTN Segment;
1239 UINTN Bus;
1240 UINTN Device;
1241 UINTN Function;
1242 UINTN Index;
1243 CHAR16 *GetString;
1244 CHAR16 *TempRetVal;
1245 CHAR16 *RetVal;
1246
1247 if (!Verbose) {
1248 return (NULL);
1249 }
1250
1251 RetVal = NULL;
1252 GetString = NULL;
1253 TempRetVal = NULL;
1254 Status = gBS->OpenProtocol (
1255 TheHandle,
1256 &gEfiPciIoProtocolGuid,
1257 (VOID **)&PciIo,
1258 gImageHandle,
1259 NULL,
1260 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1261 );
1262
1263 if (EFI_ERROR (Status)) {
1264 return NULL;
1265 }
1266
1267 PciIo->Pci.Read (PciIo, EfiPciIoWidthUint8, 0, sizeof (Pci), &Pci);
1268 PciIo->GetLocation (PciIo, &Segment, &Bus, &Device, &Function);
1269 HandleParsingHiiInit ();
1270 GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PCIIO_DUMP_MAIN), NULL);
1271 if (GetString == NULL) {
1272 return NULL;
1273 }
1274
1275 RetVal = CatSPrint (
1276 NULL,
1277 GetString,
1278 Segment,
1279 Bus,
1280 Device,
1281 Function,
1282 PciIo->RomSize,
1283 PciIo->RomImage,
1284 Pci.Hdr.VendorId,
1285 Pci.Hdr.DeviceId,
1286 Pci.Hdr.ClassCode[0],
1287 Pci.Hdr.ClassCode[1],
1288 Pci.Hdr.ClassCode[2]
1289 );
1290 for (Index = 0; Index < sizeof (Pci); Index++) {
1291 if ((Index % 0x10) == 0) {
1292 TempRetVal = CatSPrint (RetVal, L"\r\n %02x", *((UINT8 *)(&Pci) + Index));
1293 } else {
1294 TempRetVal = CatSPrint (RetVal, L"%02x", *((UINT8 *)(&Pci) + Index));
1295 }
1296
1297 FreePool (RetVal);
1298 RetVal = TempRetVal;
1299 TempRetVal = NULL;
1300 }
1301
1302 FreePool (GetString);
1303 return RetVal;
1304 }
1305
1306 /**
1307 Function to dump information about UsbIoProtocol.
1308
1309 This will allocate the return buffer from boot services pool.
1310
1311 @param[in] TheHandle The handle that has PciRootBridgeIo installed.
1312 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1313
1314 @retval A poitner to a string containing the information.
1315 **/
1316 CHAR16 *
1317 EFIAPI
1318 UsbIoProtocolDumpInformation (
1319 IN CONST EFI_HANDLE TheHandle,
1320 IN CONST BOOLEAN Verbose
1321 )
1322 {
1323 EFI_STATUS Status;
1324 EFI_USB_IO_PROTOCOL *UsbIo;
1325 EFI_USB_INTERFACE_DESCRIPTOR InterfaceDesc;
1326 CHAR16 *GetString;
1327 CHAR16 *RetVal;
1328
1329 if (!Verbose) {
1330 return (NULL);
1331 }
1332
1333 RetVal = NULL;
1334 GetString = NULL;
1335 Status = gBS->OpenProtocol (
1336 TheHandle,
1337 &gEfiUsbIoProtocolGuid,
1338 (VOID **)&UsbIo,
1339 gImageHandle,
1340 NULL,
1341 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1342 );
1343
1344 if (EFI_ERROR (Status)) {
1345 return NULL;
1346 }
1347
1348 UsbIo->UsbGetInterfaceDescriptor (UsbIo, &InterfaceDesc);
1349 HandleParsingHiiInit ();
1350 GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_USBIO_DUMP_MAIN), NULL);
1351 if (GetString == NULL) {
1352 return NULL;
1353 }
1354
1355 RetVal = CatSPrint (
1356 NULL,
1357 GetString,
1358 InterfaceDesc.InterfaceNumber,
1359 InterfaceDesc.InterfaceClass,
1360 InterfaceDesc.InterfaceSubClass,
1361 InterfaceDesc.InterfaceProtocol
1362 );
1363
1364 FreePool (GetString);
1365 return RetVal;
1366 }
1367
1368 /**
1369 Function to dump information about EfiAdapterInformation Protocol.
1370
1371 @param[in] TheHandle The handle that has the protocol installed.
1372 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1373
1374 @retval A pointer to a string containing the information.
1375 **/
1376 CHAR16 *
1377 EFIAPI
1378 AdapterInformationDumpInformation (
1379 IN CONST EFI_HANDLE TheHandle,
1380 IN CONST BOOLEAN Verbose
1381 )
1382 {
1383 EFI_STATUS Status;
1384 EFI_ADAPTER_INFORMATION_PROTOCOL *EfiAdptrInfoProtocol;
1385 UINTN InfoTypesBufferCount;
1386 UINTN GuidIndex;
1387 EFI_GUID *InfoTypesBuffer;
1388 CHAR16 *GuidStr;
1389 CHAR16 *TempStr;
1390 CHAR16 *RetVal;
1391 CHAR16 *TempRetVal;
1392 VOID *InformationBlock;
1393 UINTN InformationBlockSize;
1394
1395 if (!Verbose) {
1396 return (CatSPrint (NULL, L"AdapterInfo"));
1397 }
1398
1399 InfoTypesBuffer = NULL;
1400 InformationBlock = NULL;
1401
1402 Status = gBS->OpenProtocol (
1403 (EFI_HANDLE)(TheHandle),
1404 &gEfiAdapterInformationProtocolGuid,
1405 (VOID **)&EfiAdptrInfoProtocol,
1406 NULL,
1407 NULL,
1408 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1409 );
1410
1411 if (EFI_ERROR (Status)) {
1412 return NULL;
1413 }
1414
1415 //
1416 // Get a list of supported information types for this instance of the protocol.
1417 //
1418 Status = EfiAdptrInfoProtocol->GetSupportedTypes (
1419 EfiAdptrInfoProtocol,
1420 &InfoTypesBuffer,
1421 &InfoTypesBufferCount
1422 );
1423 RetVal = NULL;
1424 if (EFI_ERROR (Status)) {
1425 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GET_SUPP_TYPES_FAILED), NULL);
1426 if (TempStr != NULL) {
1427 RetVal = CatSPrint (NULL, TempStr, Status);
1428 } else {
1429 goto ERROR_EXIT;
1430 }
1431 } else {
1432 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_SUPP_TYPE_HEADER), NULL);
1433 if (TempStr == NULL) {
1434 goto ERROR_EXIT;
1435 }
1436
1437 RetVal = CatSPrint (NULL, TempStr);
1438 SHELL_FREE_NON_NULL (TempStr);
1439
1440 for (GuidIndex = 0; GuidIndex < InfoTypesBufferCount; GuidIndex++) {
1441 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GUID_NUMBER), NULL);
1442 if (TempStr == NULL) {
1443 goto ERROR_EXIT;
1444 }
1445
1446 TempRetVal = CatSPrint (RetVal, TempStr, (GuidIndex + 1), &InfoTypesBuffer[GuidIndex]);
1447 SHELL_FREE_NON_NULL (RetVal);
1448 RetVal = TempRetVal;
1449 SHELL_FREE_NON_NULL (TempStr);
1450
1451 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GUID_STRING), NULL);
1452 if (TempStr == NULL) {
1453 goto ERROR_EXIT;
1454 }
1455
1456 if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {
1457 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoMediaStateGuid");
1458 SHELL_FREE_NON_NULL (RetVal);
1459 RetVal = TempRetVal;
1460 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {
1461 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoNetworkBootGuid");
1462 SHELL_FREE_NON_NULL (RetVal);
1463 RetVal = TempRetVal;
1464 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid)) {
1465 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoSanMacAddressGuid");
1466 SHELL_FREE_NON_NULL (RetVal);
1467 RetVal = TempRetVal;
1468 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoUndiIpv6SupportGuid)) {
1469 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoUndiIpv6SupportGuid");
1470 SHELL_FREE_NON_NULL (RetVal);
1471 RetVal = TempRetVal;
1472 } else {
1473 GuidStr = GetStringNameFromGuid (&InfoTypesBuffer[GuidIndex], NULL);
1474 if (GuidStr == NULL) {
1475 TempRetVal = CatSPrint (RetVal, TempStr, L"UnknownInfoType");
1476 SHELL_FREE_NON_NULL (RetVal);
1477 RetVal = TempRetVal;
1478
1479 SHELL_FREE_NON_NULL (TempStr);
1480 SHELL_FREE_NON_NULL (GuidStr);
1481 //
1482 // So that we never have to pass this UnknownInfoType to the parsing function "GetInformation" service of AIP
1483 //
1484 continue;
1485 } else {
1486 TempRetVal = CatSPrint (RetVal, TempStr, GuidStr);
1487 SHELL_FREE_NON_NULL (RetVal);
1488 RetVal = TempRetVal;
1489 SHELL_FREE_NON_NULL (GuidStr);
1490 }
1491 }
1492
1493 SHELL_FREE_NON_NULL (TempStr);
1494
1495 Status = EfiAdptrInfoProtocol->GetInformation (
1496 EfiAdptrInfoProtocol,
1497 &InfoTypesBuffer[GuidIndex],
1498 &InformationBlock,
1499 &InformationBlockSize
1500 );
1501
1502 if (EFI_ERROR (Status)) {
1503 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GETINFO_FAILED), NULL);
1504 if (TempStr == NULL) {
1505 goto ERROR_EXIT;
1506 }
1507
1508 TempRetVal = CatSPrint (RetVal, TempStr, Status);
1509 SHELL_FREE_NON_NULL (RetVal);
1510 RetVal = TempRetVal;
1511 } else {
1512 if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {
1513 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_MEDIA_STATE), NULL);
1514 if (TempStr == NULL) {
1515 goto ERROR_EXIT;
1516 }
1517
1518 TempRetVal = CatSPrint (
1519 RetVal,
1520 TempStr,
1521 ((EFI_ADAPTER_INFO_MEDIA_STATE *)InformationBlock)->MediaState,
1522 ((EFI_ADAPTER_INFO_MEDIA_STATE *)InformationBlock)->MediaState
1523 );
1524 SHELL_FREE_NON_NULL (RetVal);
1525 RetVal = TempRetVal;
1526 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {
1527 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_NETWORK_BOOT_INFO), NULL);
1528 if (TempStr == NULL) {
1529 goto ERROR_EXIT;
1530 }
1531
1532 TempRetVal = CatSPrint (
1533 RetVal,
1534 TempStr,
1535 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv4BootCapablity,
1536 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv6BootCapablity,
1537 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->FCoeBootCapablity,
1538 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->OffloadCapability,
1539 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiMpioCapability,
1540 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv4Boot,
1541 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv6Boot,
1542 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->FCoeBoot
1543 );
1544 SHELL_FREE_NON_NULL (RetVal);
1545 RetVal = TempRetVal;
1546 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid) == TRUE) {
1547 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_SAN_MAC_ADDRESS_INFO), NULL);
1548 if (TempStr == NULL) {
1549 goto ERROR_EXIT;
1550 }
1551
1552 TempRetVal = CatSPrint (
1553 RetVal,
1554 TempStr,
1555 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[0],
1556 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[1],
1557 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[2],
1558 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[3],
1559 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[4],
1560 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[5]
1561 );
1562 SHELL_FREE_NON_NULL (RetVal);
1563 RetVal = TempRetVal;
1564 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoUndiIpv6SupportGuid) == TRUE) {
1565 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_UNDI_IPV6_INFO), NULL);
1566 if (TempStr == NULL) {
1567 goto ERROR_EXIT;
1568 }
1569
1570 TempRetVal = CatSPrint (
1571 RetVal,
1572 TempStr,
1573 ((EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT *)InformationBlock)->Ipv6Support
1574 );
1575 SHELL_FREE_NON_NULL (RetVal);
1576 RetVal = TempRetVal;
1577 } else {
1578 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_UNKNOWN_INFO_TYPE), NULL);
1579 if (TempStr == NULL) {
1580 goto ERROR_EXIT;
1581 }
1582
1583 TempRetVal = CatSPrint (RetVal, TempStr, &InfoTypesBuffer[GuidIndex]);
1584 SHELL_FREE_NON_NULL (RetVal);
1585 RetVal = TempRetVal;
1586 }
1587 }
1588
1589 SHELL_FREE_NON_NULL (TempStr);
1590 SHELL_FREE_NON_NULL (InformationBlock);
1591 }
1592 }
1593
1594 SHELL_FREE_NON_NULL (InfoTypesBuffer);
1595 return RetVal;
1596
1597 ERROR_EXIT:
1598 SHELL_FREE_NON_NULL (RetVal);
1599 SHELL_FREE_NON_NULL (InfoTypesBuffer);
1600 SHELL_FREE_NON_NULL (InformationBlock);
1601 return NULL;
1602 }
1603
1604 /**
1605 Function to dump information about EFI_FIRMWARE_MANAGEMENT_PROTOCOL Protocol.
1606
1607 @param[in] TheHandle The handle that has the protocol installed.
1608 @param[in] Verbose TRUE for additional information, FALSE otherwise.
1609
1610 @retval A pointer to a string containing the information.
1611 **/
1612 CHAR16 *
1613 EFIAPI
1614 FirmwareManagementDumpInformation (
1615 IN CONST EFI_HANDLE TheHandle,
1616 IN CONST BOOLEAN Verbose
1617 )
1618 {
1619 EFI_STATUS Status;
1620 EFI_FIRMWARE_MANAGEMENT_PROTOCOL *EfiFwMgmtProtocol;
1621 EFI_FIRMWARE_IMAGE_DESCRIPTOR *ImageInfo;
1622 EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1 *ImageInfoV1;
1623 EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2 *ImageInfoV2;
1624 UINT64 AttributeSetting;
1625 UINTN ImageInfoSize;
1626 UINTN DescriptorSize;
1627 UINT32 DescriptorVersion;
1628 UINT32 PackageVersion;
1629 UINT8 DescriptorCount;
1630 UINT8 Index;
1631 UINT8 Index1;
1632 UINT8 ImageCount;
1633 CHAR16 *PackageVersionName;
1634 CHAR16 *TempStr;
1635 CHAR16 *RetVal;
1636 CHAR16 *TempRetVal;
1637 CHAR16 *AttributeSettingStr;
1638 BOOLEAN Found;
1639 BOOLEAN AttributeSupported;
1640
1641 //
1642 // Initialize local variables
1643 //
1644 ImageCount = 0;
1645 ImageInfoSize = 1;
1646 AttributeSetting = 0;
1647 Found = FALSE;
1648 AttributeSupported = FALSE;
1649 ImageInfo = NULL;
1650 ImageInfoV1 = NULL;
1651 ImageInfoV2 = NULL;
1652 PackageVersionName = NULL;
1653 RetVal = NULL;
1654 TempRetVal = NULL;
1655 TempStr = NULL;
1656 AttributeSettingStr = NULL;
1657
1658 if (!Verbose) {
1659 return (CatSPrint (NULL, L"FirmwareManagement"));
1660 }
1661
1662 Status = gBS->OpenProtocol (
1663 (EFI_HANDLE)(TheHandle),
1664 &gEfiFirmwareManagementProtocolGuid,
1665 (VOID **)&EfiFwMgmtProtocol,
1666 NULL,
1667 NULL,
1668 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1669 );
1670
1671 if (EFI_ERROR (Status)) {
1672 return NULL;
1673 }
1674
1675 Status = EfiFwMgmtProtocol->GetImageInfo (
1676 EfiFwMgmtProtocol,
1677 &ImageInfoSize,
1678 ImageInfo,
1679 &DescriptorVersion,
1680 &DescriptorCount,
1681 &DescriptorSize,
1682 &PackageVersion,
1683 &PackageVersionName
1684 );
1685
1686 if (Status == EFI_BUFFER_TOO_SMALL) {
1687 ImageInfo = AllocateZeroPool (ImageInfoSize);
1688
1689 if (ImageInfo == NULL) {
1690 Status = EFI_OUT_OF_RESOURCES;
1691 } else {
1692 Status = EfiFwMgmtProtocol->GetImageInfo (
1693 EfiFwMgmtProtocol,
1694 &ImageInfoSize,
1695 ImageInfo,
1696 &DescriptorVersion,
1697 &DescriptorCount,
1698 &DescriptorSize,
1699 &PackageVersion,
1700 &PackageVersionName
1701 );
1702 }
1703 }
1704
1705 if (EFI_ERROR (Status)) {
1706 goto ERROR_EXIT;
1707 }
1708
1709 //
1710 // Decode Image Descriptor data only if its version is supported
1711 //
1712 if (DescriptorVersion <= EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION) {
1713 if (ImageInfo == NULL) {
1714 goto ERROR_EXIT;
1715 }
1716
1717 ImageInfoV1 = (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1 *)ImageInfo;
1718 ImageInfoV2 = (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2 *)ImageInfo;
1719
1720 //
1721 // Set ImageInfoSize in return buffer
1722 //
1723 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_IMAGE_INFO_SIZE), NULL);
1724 if (TempStr == NULL) {
1725 goto ERROR_EXIT;
1726 }
1727
1728 RetVal = CatSPrint (NULL, TempStr, ImageInfoSize);
1729 SHELL_FREE_NON_NULL (TempStr);
1730
1731 //
1732 // Set DescriptorVersion in return buffer
1733 //
1734 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_DESCRIPTOR_VERSION), NULL);
1735 if (TempStr == NULL) {
1736 goto ERROR_EXIT;
1737 }
1738
1739 TempRetVal = CatSPrint (RetVal, TempStr, DescriptorVersion);
1740 SHELL_FREE_NON_NULL (RetVal);
1741 RetVal = TempRetVal;
1742 SHELL_FREE_NON_NULL (TempStr);
1743
1744 //
1745 // Set DescriptorCount in return buffer
1746 //
1747 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_DESCRIPTOR_COUNT), NULL);
1748 if (TempStr == NULL) {
1749 goto ERROR_EXIT;
1750 }
1751
1752 TempRetVal = CatSPrint (RetVal, TempStr, DescriptorCount);
1753 SHELL_FREE_NON_NULL (RetVal);
1754 RetVal = TempRetVal;
1755 SHELL_FREE_NON_NULL (TempStr);
1756
1757 //
1758 // Set DescriptorSize in return buffer
1759 //
1760 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_DESCRIPTOR_SIZE), NULL);
1761 if (TempStr == NULL) {
1762 goto ERROR_EXIT;
1763 }
1764
1765 TempRetVal = CatSPrint (RetVal, TempStr, DescriptorSize);
1766 SHELL_FREE_NON_NULL (RetVal);
1767 RetVal = TempRetVal;
1768 SHELL_FREE_NON_NULL (TempStr);
1769
1770 //
1771 // Set PackageVersion in return buffer
1772 //
1773 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_PACKAGE_VERSION), NULL);
1774 if (TempStr == NULL) {
1775 goto ERROR_EXIT;
1776 }
1777
1778 TempRetVal = CatSPrint (RetVal, TempStr, PackageVersion);
1779 SHELL_FREE_NON_NULL (RetVal);
1780 RetVal = TempRetVal;
1781 SHELL_FREE_NON_NULL (TempStr);
1782
1783 //
1784 // Set PackageVersionName in return buffer
1785 //
1786 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_PACKAGE_VERSION_NAME), NULL);
1787 if (TempStr == NULL) {
1788 goto ERROR_EXIT;
1789 }
1790
1791 TempRetVal = CatSPrint (RetVal, TempStr, PackageVersionName);
1792 SHELL_FREE_NON_NULL (RetVal);
1793 RetVal = TempRetVal;
1794 SHELL_FREE_NON_NULL (TempStr);
1795
1796 for (Index = 0; Index < DescriptorCount; Index++) {
1797 //
1798 // First check if Attribute is supported
1799 // and generate a string for AttributeSetting field
1800 //
1801 SHELL_FREE_NON_NULL (AttributeSettingStr);
1802 AttributeSupported = FALSE;
1803 AttributeSetting = 0;
1804 if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {
1805 if (ImageInfoV1[Index].AttributesSupported != 0x0) {
1806 AttributeSupported = TRUE;
1807 AttributeSetting = ImageInfoV1[Index].AttributesSetting;
1808 }
1809 } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {
1810 if (ImageInfoV2[Index].AttributesSupported != 0x0) {
1811 AttributeSupported = TRUE;
1812 AttributeSetting = ImageInfoV2[Index].AttributesSetting;
1813 }
1814 } else {
1815 if (ImageInfo[Index].AttributesSupported != 0x0) {
1816 AttributeSupported = TRUE;
1817 AttributeSetting = ImageInfo[Index].AttributesSetting;
1818 }
1819 }
1820
1821 if (!AttributeSupported) {
1822 AttributeSettingStr = CatSPrint (NULL, L"None");
1823 } else {
1824 AttributeSettingStr = CatSPrint (NULL, L"(");
1825
1826 if ((AttributeSetting & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE) != 0x0) {
1827 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IMAGE_UPDATABLE");
1828 SHELL_FREE_NON_NULL (AttributeSettingStr);
1829 AttributeSettingStr = TempRetVal;
1830 }
1831
1832 if ((AttributeSetting & IMAGE_ATTRIBUTE_RESET_REQUIRED) != 0x0) {
1833 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_RESET_REQUIRED");
1834 SHELL_FREE_NON_NULL (AttributeSettingStr);
1835 AttributeSettingStr = TempRetVal;
1836 }
1837
1838 if ((AttributeSetting & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED) != 0x0) {
1839 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED");
1840 SHELL_FREE_NON_NULL (AttributeSettingStr);
1841 AttributeSettingStr = TempRetVal;
1842 }
1843
1844 if ((AttributeSetting & IMAGE_ATTRIBUTE_IN_USE) != 0x0) {
1845 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IN_USE");
1846 SHELL_FREE_NON_NULL (AttributeSettingStr);
1847 AttributeSettingStr = TempRetVal;
1848 }
1849
1850 if ((AttributeSetting & IMAGE_ATTRIBUTE_UEFI_IMAGE) != 0x0) {
1851 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_UEFI_IMAGE");
1852 SHELL_FREE_NON_NULL (AttributeSettingStr);
1853 AttributeSettingStr = TempRetVal;
1854 }
1855
1856 TempRetVal = CatSPrint (AttributeSettingStr, L" )");
1857 SHELL_FREE_NON_NULL (AttributeSettingStr);
1858 AttributeSettingStr = TempRetVal;
1859 }
1860
1861 if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {
1862 if (ImageInfoV1[Index].ImageIndex != 0x0) {
1863 ImageCount++;
1864 }
1865
1866 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_IMAGE_DESCRIPTOR_INFO_V1), NULL);
1867 if (TempStr == NULL) {
1868 goto ERROR_EXIT;
1869 }
1870
1871 TempRetVal = CatSPrint (
1872 RetVal,
1873 TempStr,
1874 Index,
1875 ImageInfoV1[Index].ImageIndex,
1876 &ImageInfoV1[Index].ImageTypeId,
1877 ImageInfoV1[Index].ImageId,
1878 ImageInfoV1[Index].ImageIdName,
1879 ImageInfoV1[Index].Version,
1880 ImageInfoV1[Index].VersionName,
1881 ImageInfoV1[Index].Size,
1882 ImageInfoV1[Index].AttributesSupported,
1883 AttributeSettingStr,
1884 ImageInfoV1[Index].Compatibilities
1885 );
1886 SHELL_FREE_NON_NULL (RetVal);
1887 RetVal = TempRetVal;
1888 SHELL_FREE_NON_NULL (TempStr);
1889 } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {
1890 if (ImageInfoV2[Index].ImageIndex != 0x0) {
1891 ImageCount++;
1892 }
1893
1894 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_IMAGE_DESCRIPTOR_INFO_V2), NULL);
1895 if (TempStr == NULL) {
1896 goto ERROR_EXIT;
1897 }
1898
1899 TempRetVal = CatSPrint (
1900 RetVal,
1901 TempStr,
1902 Index,
1903 ImageInfoV2[Index].ImageIndex,
1904 &ImageInfoV2[Index].ImageTypeId,
1905 ImageInfoV2[Index].ImageId,
1906 ImageInfoV2[Index].ImageIdName,
1907 ImageInfoV2[Index].Version,
1908 ImageInfoV2[Index].VersionName,
1909 ImageInfoV2[Index].Size,
1910 ImageInfoV2[Index].AttributesSupported,
1911 AttributeSettingStr,
1912 ImageInfoV2[Index].Compatibilities,
1913 ImageInfoV2[Index].LowestSupportedImageVersion
1914 );
1915 SHELL_FREE_NON_NULL (RetVal);
1916 RetVal = TempRetVal;
1917 SHELL_FREE_NON_NULL (TempStr);
1918 } else {
1919 if (ImageInfo[Index].ImageIndex != 0x0) {
1920 ImageCount++;
1921 }
1922
1923 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_IMAGE_DESCRIPTOR_INFO), NULL);
1924 if (TempStr == NULL) {
1925 goto ERROR_EXIT;
1926 }
1927
1928 TempRetVal = CatSPrint (
1929 RetVal,
1930 TempStr,
1931 Index,
1932 ImageInfo[Index].ImageIndex,
1933 &ImageInfo[Index].ImageTypeId,
1934 ImageInfo[Index].ImageId,
1935 ImageInfo[Index].ImageIdName,
1936 ImageInfo[Index].Version,
1937 ImageInfo[Index].VersionName,
1938 ImageInfo[Index].Size,
1939 ImageInfo[Index].AttributesSupported,
1940 AttributeSettingStr,
1941 ImageInfo[Index].Compatibilities,
1942 ImageInfo[Index].LowestSupportedImageVersion,
1943 ImageInfo[Index].LastAttemptVersion,
1944 ImageInfo[Index].LastAttemptStatus,
1945 ImageInfo[Index].HardwareInstance
1946 );
1947 SHELL_FREE_NON_NULL (RetVal);
1948 RetVal = TempRetVal;
1949 SHELL_FREE_NON_NULL (TempStr);
1950 }
1951 }
1952 }
1953
1954 if (ImageCount > 0) {
1955 for (Index = 0; Index < DescriptorCount; Index++) {
1956 for (Index1 = Index+1; Index1 < DescriptorCount; Index1++) {
1957 if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {
1958 if (ImageInfoV1[Index].ImageId == ImageInfoV1[Index1].ImageId) {
1959 Found = TRUE;
1960 //
1961 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1962 //
1963 goto ENDLOOP;
1964 }
1965 } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {
1966 if (ImageInfoV2[Index].ImageId == ImageInfoV2[Index1].ImageId) {
1967 Found = TRUE;
1968 //
1969 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1970 //
1971 goto ENDLOOP;
1972 }
1973 } else {
1974 if (ImageInfo[Index].ImageId == ImageInfo[Index1].ImageId) {
1975 Found = TRUE;
1976 //
1977 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed
1978 //
1979 goto ENDLOOP;
1980 }
1981 }
1982 }
1983 }
1984 }
1985
1986 ENDLOOP:
1987 //
1988 // Check if ImageId with duplicate value was found
1989 //
1990 if (Found) {
1991 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_IMAGEID_NON_UNIQUE), NULL);
1992 if (TempStr == NULL) {
1993 goto ERROR_EXIT;
1994 }
1995
1996 TempRetVal = CatSPrint (RetVal, TempStr);
1997 SHELL_FREE_NON_NULL (RetVal);
1998 RetVal = TempRetVal;
1999 SHELL_FREE_NON_NULL (TempStr);
2000 }
2001
2002 SHELL_FREE_NON_NULL (ImageInfo);
2003 SHELL_FREE_NON_NULL (PackageVersionName);
2004 SHELL_FREE_NON_NULL (AttributeSettingStr);
2005
2006 return RetVal;
2007
2008 ERROR_EXIT:
2009 SHELL_FREE_NON_NULL (RetVal);
2010 SHELL_FREE_NON_NULL (ImageInfo);
2011 SHELL_FREE_NON_NULL (PackageVersionName);
2012 SHELL_FREE_NON_NULL (AttributeSettingStr);
2013
2014 return NULL;
2015 }
2016
2017 /**
2018 Function to dump information about Partition Information protocol.
2019
2020 This will allocate the return buffer from boot services pool.
2021
2022 @param[in] TheHandle The handle that has the protocol installed.
2023 @param[in] Verbose TRUE for additional information, FALSE otherwise.
2024
2025 @retval A pointer to a string containing the information.
2026 **/
2027 CHAR16 *
2028 EFIAPI
2029 PartitionInfoProtocolDumpInformation (
2030 IN CONST EFI_HANDLE TheHandle,
2031 IN CONST BOOLEAN Verbose
2032 )
2033 {
2034 EFI_STATUS Status;
2035 EFI_PARTITION_INFO_PROTOCOL *PartitionInfo;
2036 CHAR16 *PartitionType;
2037 CHAR16 *EfiSystemPartition;
2038 CHAR16 *RetVal;
2039
2040 if (!Verbose) {
2041 return NULL;
2042 }
2043
2044 Status = gBS->OpenProtocol (
2045 TheHandle,
2046 &gEfiPartitionInfoProtocolGuid,
2047 (VOID **)&PartitionInfo,
2048 gImageHandle,
2049 NULL,
2050 EFI_OPEN_PROTOCOL_GET_PROTOCOL
2051 );
2052 if (EFI_ERROR (Status)) {
2053 return NULL;
2054 }
2055
2056 HandleParsingHiiInit ();
2057
2058 switch (PartitionInfo->Type) {
2059 case PARTITION_TYPE_OTHER:
2060 PartitionType = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PARTINFO_DUMP_TYPE_OTHER), NULL);
2061 break;
2062 case PARTITION_TYPE_MBR:
2063 PartitionType = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PARTINFO_DUMP_TYPE_MBR), NULL);
2064 break;
2065 case PARTITION_TYPE_GPT:
2066 PartitionType = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PARTINFO_DUMP_TYPE_GPT), NULL);
2067 break;
2068 default:
2069 PartitionType = NULL;
2070 break;
2071 }
2072
2073 if (PartitionType == NULL) {
2074 return NULL;
2075 }
2076
2077 if (PartitionInfo->System == 1) {
2078 EfiSystemPartition = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PARTINFO_DUMP_EFI_SYS_PART), NULL);
2079 } else {
2080 EfiSystemPartition = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PARTINFO_DUMP_NOT_EFI_SYS_PART), NULL);
2081 }
2082
2083 if (EfiSystemPartition == NULL) {
2084 SHELL_FREE_NON_NULL (PartitionType);
2085 return NULL;
2086 }
2087
2088 RetVal = CatSPrint (
2089 NULL,
2090 L"%s\r\n%s",
2091 PartitionType,
2092 EfiSystemPartition
2093 );
2094
2095 SHELL_FREE_NON_NULL (EfiSystemPartition);
2096 SHELL_FREE_NON_NULL (PartitionType);
2097 return RetVal;
2098 }
2099
2100 //
2101 // Put the information on the NT32 protocol GUIDs here so we are not dependant on the Nt32Pkg
2102 //
2103 #define LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID \
2104 { \
2105 0x58c518b1, 0x76f3, 0x11d4, { 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
2106 }
2107
2108 #define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \
2109 { \
2110 0x96eb4ad6, 0xa32a, 0x11d4, { 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
2111 }
2112
2113 #define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \
2114 { \
2115 0xc95a93d, 0xa006, 0x11d4, { 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
2116 }
2117 STATIC CONST EFI_GUID WinNtThunkProtocolGuid = LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID;
2118 STATIC CONST EFI_GUID WinNtIoProtocolGuid = LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID;
2119 STATIC CONST EFI_GUID WinNtSerialPortGuid = LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID;
2120
2121 //
2122 // Deprecated protocols we dont want to link from IntelFrameworkModulePkg
2123 //
2124 #define LOCAL_EFI_ISA_IO_PROTOCOL_GUID \
2125 { \
2126 0x7ee2bd44, 0x3da0, 0x11d4, { 0x9a, 0x38, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \
2127 }
2128 #define LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID \
2129 { \
2130 0x64a892dc, 0x5561, 0x4536, { 0x92, 0xc7, 0x79, 0x9b, 0xfc, 0x18, 0x33, 0x55 } \
2131 }
2132 STATIC CONST EFI_GUID EfiIsaIoProtocolGuid = LOCAL_EFI_ISA_IO_PROTOCOL_GUID;
2133 STATIC CONST EFI_GUID EfiIsaAcpiProtocolGuid = LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID;
2134
2135 STATIC CONST GUID_INFO_BLOCK mGuidStringListNT[] = {
2136 { STRING_TOKEN (STR_WINNT_THUNK), (EFI_GUID *)&WinNtThunkProtocolGuid, NULL },
2137 { STRING_TOKEN (STR_WINNT_DRIVER_IO), (EFI_GUID *)&WinNtIoProtocolGuid, NULL },
2138 { STRING_TOKEN (STR_WINNT_SERIAL_PORT), (EFI_GUID *)&WinNtSerialPortGuid, NULL },
2139 { 0, NULL, NULL },
2140 };
2141
2142 STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {
2143 { STRING_TOKEN (STR_LOADED_IMAGE), &gEfiLoadedImageProtocolGuid, LoadedImageProtocolDumpInformation },
2144 { STRING_TOKEN (STR_DEVICE_PATH), &gEfiDevicePathProtocolGuid, DevicePathProtocolDumpInformation },
2145 { STRING_TOKEN (STR_IMAGE_PATH), &gEfiLoadedImageDevicePathProtocolGuid, LoadedImageDevicePathProtocolDumpInformation },
2146 { STRING_TOKEN (STR_DEVICE_PATH_UTIL), &gEfiDevicePathUtilitiesProtocolGuid, NULL },
2147 { STRING_TOKEN (STR_DEVICE_PATH_TXT), &gEfiDevicePathToTextProtocolGuid, NULL },
2148 { STRING_TOKEN (STR_DEVICE_PATH_FTXT), &gEfiDevicePathFromTextProtocolGuid, NULL },
2149 { STRING_TOKEN (STR_DEVICE_PATH_PC), &gEfiPcAnsiGuid, NULL },
2150 { STRING_TOKEN (STR_DEVICE_PATH_VT100), &gEfiVT100Guid, NULL },
2151 { STRING_TOKEN (STR_DEVICE_PATH_VT100P), &gEfiVT100PlusGuid, NULL },
2152 { STRING_TOKEN (STR_DEVICE_PATH_VTUTF8), &gEfiVTUTF8Guid, NULL },
2153 { STRING_TOKEN (STR_DRIVER_BINDING), &gEfiDriverBindingProtocolGuid, NULL },
2154 { STRING_TOKEN (STR_PLATFORM_OVERRIDE), &gEfiPlatformDriverOverrideProtocolGuid, NULL },
2155 { STRING_TOKEN (STR_BUS_OVERRIDE), &gEfiBusSpecificDriverOverrideProtocolGuid, BusSpecificDriverOverrideProtocolDumpInformation },
2156 { STRING_TOKEN (STR_DRIVER_DIAG), &gEfiDriverDiagnosticsProtocolGuid, NULL },
2157 { STRING_TOKEN (STR_DRIVER_DIAG2), &gEfiDriverDiagnostics2ProtocolGuid, NULL },
2158 { STRING_TOKEN (STR_DRIVER_CN), &gEfiComponentNameProtocolGuid, NULL },
2159 { STRING_TOKEN (STR_DRIVER_CN2), &gEfiComponentName2ProtocolGuid, NULL },
2160 { STRING_TOKEN (STR_PLAT_DRV_CFG), &gEfiPlatformToDriverConfigurationProtocolGuid, NULL },
2161 { STRING_TOKEN (STR_DRIVER_VERSION), &gEfiDriverSupportedEfiVersionProtocolGuid, DriverEfiVersionProtocolDumpInformation },
2162 { STRING_TOKEN (STR_TXT_IN), &gEfiSimpleTextInProtocolGuid, NULL },
2163 { STRING_TOKEN (STR_TXT_IN_EX), &gEfiSimpleTextInputExProtocolGuid, NULL },
2164 { STRING_TOKEN (STR_TXT_OUT), &gEfiSimpleTextOutProtocolGuid, TxtOutProtocolDumpInformation },
2165 { STRING_TOKEN (STR_SIM_POINTER), &gEfiSimplePointerProtocolGuid, NULL },
2166 { STRING_TOKEN (STR_ABS_POINTER), &gEfiAbsolutePointerProtocolGuid, NULL },
2167 { STRING_TOKEN (STR_SERIAL_IO), &gEfiSerialIoProtocolGuid, NULL },
2168 { STRING_TOKEN (STR_GRAPHICS_OUTPUT), &gEfiGraphicsOutputProtocolGuid, GraphicsOutputProtocolDumpInformation },
2169 { STRING_TOKEN (STR_EDID_DISCOVERED), &gEfiEdidDiscoveredProtocolGuid, EdidDiscoveredProtocolDumpInformation },
2170 { STRING_TOKEN (STR_EDID_ACTIVE), &gEfiEdidActiveProtocolGuid, EdidActiveProtocolDumpInformation },
2171 { STRING_TOKEN (STR_EDID_OVERRIDE), &gEfiEdidOverrideProtocolGuid, NULL },
2172 { STRING_TOKEN (STR_CON_IN), &gEfiConsoleInDeviceGuid, NULL },
2173 { STRING_TOKEN (STR_CON_OUT), &gEfiConsoleOutDeviceGuid, NULL },
2174 { STRING_TOKEN (STR_STD_ERR), &gEfiStandardErrorDeviceGuid, NULL },
2175 { STRING_TOKEN (STR_LOAD_FILE), &gEfiLoadFileProtocolGuid, NULL },
2176 { STRING_TOKEN (STR_LOAD_FILE2), &gEfiLoadFile2ProtocolGuid, NULL },
2177 { STRING_TOKEN (STR_SIMPLE_FILE_SYS), &gEfiSimpleFileSystemProtocolGuid, NULL },
2178 { STRING_TOKEN (STR_TAPE_IO), &gEfiTapeIoProtocolGuid, NULL },
2179 { STRING_TOKEN (STR_DISK_IO), &gEfiDiskIoProtocolGuid, NULL },
2180 { STRING_TOKEN (STR_BLK_IO), &gEfiBlockIoProtocolGuid, BlockIoProtocolDumpInformation },
2181 { STRING_TOKEN (STR_UC), &gEfiUnicodeCollationProtocolGuid, NULL },
2182 { STRING_TOKEN (STR_UC2), &gEfiUnicodeCollation2ProtocolGuid, NULL },
2183 { STRING_TOKEN (STR_PCIRB_IO), &gEfiPciRootBridgeIoProtocolGuid, PciRootBridgeIoDumpInformation },
2184 { STRING_TOKEN (STR_PCI_IO), &gEfiPciIoProtocolGuid, PciIoProtocolDumpInformation },
2185 { STRING_TOKEN (STR_SCSI_PT), &gEfiScsiPassThruProtocolGuid, NULL },
2186 { STRING_TOKEN (STR_SCSI_IO), &gEfiScsiIoProtocolGuid, NULL },
2187 { STRING_TOKEN (STR_SCSI_PT_EXT), &gEfiExtScsiPassThruProtocolGuid, NULL },
2188 { STRING_TOKEN (STR_ISCSI), &gEfiIScsiInitiatorNameProtocolGuid, NULL },
2189 { STRING_TOKEN (STR_USB_IO), &gEfiUsbIoProtocolGuid, UsbIoProtocolDumpInformation },
2190 { STRING_TOKEN (STR_USB_HC), &gEfiUsbHcProtocolGuid, NULL },
2191 { STRING_TOKEN (STR_USB_HC2), &gEfiUsb2HcProtocolGuid, NULL },
2192 { STRING_TOKEN (STR_DEBUG_SUPPORT), &gEfiDebugSupportProtocolGuid, DebugSupportProtocolDumpInformation },
2193 { STRING_TOKEN (STR_DEBUG_PORT), &gEfiDebugPortProtocolGuid, NULL },
2194 { STRING_TOKEN (STR_DECOMPRESS), &gEfiDecompressProtocolGuid, NULL },
2195 { STRING_TOKEN (STR_ACPI_TABLE), &gEfiAcpiTableProtocolGuid, NULL },
2196 { STRING_TOKEN (STR_EBC_INTERPRETER), &gEfiEbcProtocolGuid, NULL },
2197 { STRING_TOKEN (STR_SNP), &gEfiSimpleNetworkProtocolGuid, NULL },
2198 { STRING_TOKEN (STR_NII), &gEfiNetworkInterfaceIdentifierProtocolGuid, NULL },
2199 { STRING_TOKEN (STR_NII_31), &gEfiNetworkInterfaceIdentifierProtocolGuid_31, NULL },
2200 { STRING_TOKEN (STR_PXE_BC), &gEfiPxeBaseCodeProtocolGuid, NULL },
2201 { STRING_TOKEN (STR_PXE_CB), &gEfiPxeBaseCodeCallbackProtocolGuid, NULL },
2202 { STRING_TOKEN (STR_BIS), &gEfiBisProtocolGuid, NULL },
2203 { STRING_TOKEN (STR_MNP_SB), &gEfiManagedNetworkServiceBindingProtocolGuid, NULL },
2204 { STRING_TOKEN (STR_MNP), &gEfiManagedNetworkProtocolGuid, NULL },
2205 { STRING_TOKEN (STR_ARP_SB), &gEfiArpServiceBindingProtocolGuid, NULL },
2206 { STRING_TOKEN (STR_ARP), &gEfiArpProtocolGuid, NULL },
2207 { STRING_TOKEN (STR_DHCPV4_SB), &gEfiDhcp4ServiceBindingProtocolGuid, NULL },
2208 { STRING_TOKEN (STR_DHCPV4), &gEfiDhcp4ProtocolGuid, NULL },
2209 { STRING_TOKEN (STR_TCPV4_SB), &gEfiTcp4ServiceBindingProtocolGuid, NULL },
2210 { STRING_TOKEN (STR_TCPV4), &gEfiTcp4ProtocolGuid, NULL },
2211 { STRING_TOKEN (STR_IPV4_SB), &gEfiIp4ServiceBindingProtocolGuid, NULL },
2212 { STRING_TOKEN (STR_IPV4), &gEfiIp4ProtocolGuid, NULL },
2213 { STRING_TOKEN (STR_IPV4_CFG), &gEfiIp4ConfigProtocolGuid, NULL },
2214 { STRING_TOKEN (STR_IPV4_CFG2), &gEfiIp4Config2ProtocolGuid, NULL },
2215 { STRING_TOKEN (STR_UDPV4_SB), &gEfiUdp4ServiceBindingProtocolGuid, NULL },
2216 { STRING_TOKEN (STR_UDPV4), &gEfiUdp4ProtocolGuid, NULL },
2217 { STRING_TOKEN (STR_MTFTPV4_SB), &gEfiMtftp4ServiceBindingProtocolGuid, NULL },
2218 { STRING_TOKEN (STR_MTFTPV4), &gEfiMtftp4ProtocolGuid, NULL },
2219 { STRING_TOKEN (STR_AUTH_INFO), &gEfiAuthenticationInfoProtocolGuid, NULL },
2220 { STRING_TOKEN (STR_HASH_SB), &gEfiHashServiceBindingProtocolGuid, NULL },
2221 { STRING_TOKEN (STR_HASH), &gEfiHashProtocolGuid, NULL },
2222 { STRING_TOKEN (STR_HII_FONT), &gEfiHiiFontProtocolGuid, NULL },
2223 { STRING_TOKEN (STR_HII_STRING), &gEfiHiiStringProtocolGuid, NULL },
2224 { STRING_TOKEN (STR_HII_IMAGE), &gEfiHiiImageProtocolGuid, NULL },
2225 { STRING_TOKEN (STR_HII_DATABASE), &gEfiHiiDatabaseProtocolGuid, NULL },
2226 { STRING_TOKEN (STR_HII_CONFIG_ROUT), &gEfiHiiConfigRoutingProtocolGuid, NULL },
2227 { STRING_TOKEN (STR_HII_CONFIG_ACC), &gEfiHiiConfigAccessProtocolGuid, NULL },
2228 { STRING_TOKEN (STR_HII_FORM_BROWSER2), &gEfiFormBrowser2ProtocolGuid, NULL },
2229 { STRING_TOKEN (STR_DRIVER_FAM_OVERRIDE), &gEfiDriverFamilyOverrideProtocolGuid, NULL },
2230 { STRING_TOKEN (STR_PCD), &gPcdProtocolGuid, NULL },
2231 { STRING_TOKEN (STR_TCG), &gEfiTcgProtocolGuid, NULL },
2232 { STRING_TOKEN (STR_HII_PACKAGE_LIST), &gEfiHiiPackageListProtocolGuid, NULL },
2233
2234 //
2235 // the ones under this are deprecated by the current UEFI Spec, but may be found anyways...
2236 //
2237 { STRING_TOKEN (STR_SHELL_INTERFACE), &gEfiShellInterfaceGuid, NULL },
2238 { STRING_TOKEN (STR_SHELL_ENV2), &gEfiShellEnvironment2Guid, NULL },
2239 { STRING_TOKEN (STR_SHELL_ENV), &gEfiShellEnvironment2Guid, NULL },
2240 { STRING_TOKEN (STR_DEVICE_IO), &gEfiDeviceIoProtocolGuid, NULL },
2241 { STRING_TOKEN (STR_UGA_DRAW), &gEfiUgaDrawProtocolGuid, NULL },
2242 { STRING_TOKEN (STR_UGA_IO), &gEfiUgaIoProtocolGuid, NULL },
2243 { STRING_TOKEN (STR_ESP), &gEfiPartTypeSystemPartGuid, NULL },
2244 { STRING_TOKEN (STR_GPT_NBR), &gEfiPartTypeLegacyMbrGuid, NULL },
2245 { STRING_TOKEN (STR_DRIVER_CONFIG), &gEfiDriverConfigurationProtocolGuid, NULL },
2246 { STRING_TOKEN (STR_DRIVER_CONFIG2), &gEfiDriverConfiguration2ProtocolGuid, NULL },
2247
2248 //
2249 // these are using local (non-global) definitions to reduce package dependancy.
2250 //
2251 { STRING_TOKEN (STR_ISA_IO), (EFI_GUID *)&EfiIsaIoProtocolGuid, NULL },
2252 { STRING_TOKEN (STR_ISA_ACPI), (EFI_GUID *)&EfiIsaAcpiProtocolGuid, NULL },
2253
2254 //
2255 // the ones under this are GUID identified structs, not protocols
2256 //
2257 { STRING_TOKEN (STR_FILE_INFO), &gEfiFileInfoGuid, NULL },
2258 { STRING_TOKEN (STR_FILE_SYS_INFO), &gEfiFileSystemInfoGuid, NULL },
2259
2260 //
2261 // the ones under this are misc GUIDS.
2262 //
2263 { STRING_TOKEN (STR_EFI_GLOBAL_VARIABLE), &gEfiGlobalVariableGuid, NULL },
2264
2265 //
2266 // UEFI 2.2
2267 //
2268 { STRING_TOKEN (STR_IP6_SB), &gEfiIp6ServiceBindingProtocolGuid, NULL },
2269 { STRING_TOKEN (STR_IP6), &gEfiIp6ProtocolGuid, NULL },
2270 { STRING_TOKEN (STR_IP6_CONFIG), &gEfiIp6ConfigProtocolGuid, NULL },
2271 { STRING_TOKEN (STR_MTFTP6_SB), &gEfiMtftp6ServiceBindingProtocolGuid, NULL },
2272 { STRING_TOKEN (STR_MTFTP6), &gEfiMtftp6ProtocolGuid, NULL },
2273 { STRING_TOKEN (STR_DHCP6_SB), &gEfiDhcp6ServiceBindingProtocolGuid, NULL },
2274 { STRING_TOKEN (STR_DHCP6), &gEfiDhcp6ProtocolGuid, NULL },
2275 { STRING_TOKEN (STR_UDP6_SB), &gEfiUdp6ServiceBindingProtocolGuid, NULL },
2276 { STRING_TOKEN (STR_UDP6), &gEfiUdp6ProtocolGuid, NULL },
2277 { STRING_TOKEN (STR_TCP6_SB), &gEfiTcp6ServiceBindingProtocolGuid, NULL },
2278 { STRING_TOKEN (STR_TCP6), &gEfiTcp6ProtocolGuid, NULL },
2279 { STRING_TOKEN (STR_VLAN_CONFIG), &gEfiVlanConfigProtocolGuid, NULL },
2280 { STRING_TOKEN (STR_EAP), &gEfiEapProtocolGuid, NULL },
2281 { STRING_TOKEN (STR_EAP_MGMT), &gEfiEapManagementProtocolGuid, NULL },
2282 { STRING_TOKEN (STR_FTP4_SB), &gEfiFtp4ServiceBindingProtocolGuid, NULL },
2283 { STRING_TOKEN (STR_FTP4), &gEfiFtp4ProtocolGuid, NULL },
2284 { STRING_TOKEN (STR_IP_SEC_CONFIG), &gEfiIpSecConfigProtocolGuid, NULL },
2285 { STRING_TOKEN (STR_DH), &gEfiDriverHealthProtocolGuid, NULL },
2286 { STRING_TOKEN (STR_DEF_IMG_LOAD), &gEfiDeferredImageLoadProtocolGuid, NULL },
2287 { STRING_TOKEN (STR_USER_CRED), &gEfiUserCredentialProtocolGuid, NULL },
2288 { STRING_TOKEN (STR_USER_MNGR), &gEfiUserManagerProtocolGuid, NULL },
2289 { STRING_TOKEN (STR_ATA_PASS_THRU), &gEfiAtaPassThruProtocolGuid, NULL },
2290
2291 //
2292 // UEFI 2.3
2293 //
2294 { STRING_TOKEN (STR_FW_MGMT), &gEfiFirmwareManagementProtocolGuid, FirmwareManagementDumpInformation },
2295 { STRING_TOKEN (STR_IP_SEC), &gEfiIpSecProtocolGuid, NULL },
2296 { STRING_TOKEN (STR_IP_SEC2), &gEfiIpSec2ProtocolGuid, NULL },
2297
2298 //
2299 // UEFI 2.3.1
2300 //
2301 { STRING_TOKEN (STR_KMS), &gEfiKmsProtocolGuid, NULL },
2302 { STRING_TOKEN (STR_BLK_IO2), &gEfiBlockIo2ProtocolGuid, NULL },
2303 { STRING_TOKEN (STR_SSC), &gEfiStorageSecurityCommandProtocolGuid, NULL },
2304 { STRING_TOKEN (STR_UCRED2), &gEfiUserCredential2ProtocolGuid, NULL },
2305
2306 //
2307 // UEFI 2.4
2308 //
2309 { STRING_TOKEN (STR_DISK_IO2), &gEfiDiskIo2ProtocolGuid, NULL },
2310 { STRING_TOKEN (STR_ADAPTER_INFO), &gEfiAdapterInformationProtocolGuid, AdapterInformationDumpInformation },
2311
2312 //
2313 // UEFI2.5
2314 //
2315 { STRING_TOKEN (STR_TLS_SB), &gEfiTlsServiceBindingProtocolGuid, NULL },
2316 { STRING_TOKEN (STR_TLS), &gEfiTlsProtocolGuid, NULL },
2317 { STRING_TOKEN (STR_TLS_CONFIG), &gEfiTlsConfigurationProtocolGuid, NULL },
2318 { STRING_TOKEN (STR_SUPPLICANT_SB), &gEfiSupplicantServiceBindingProtocolGuid, NULL },
2319 { STRING_TOKEN (STR_SUPPLICANT), &gEfiSupplicantProtocolGuid, NULL },
2320
2321 //
2322 // UEFI2.6
2323 //
2324 { STRING_TOKEN (STR_WIFI2), &gEfiWiFi2ProtocolGuid, NULL },
2325 { STRING_TOKEN (STR_RAMDISK), &gEfiRamDiskProtocolGuid, NULL },
2326 { STRING_TOKEN (STR_HII_ID), &gEfiHiiImageDecoderProtocolGuid, NULL },
2327 { STRING_TOKEN (STR_HII_IE), &gEfiHiiImageExProtocolGuid, NULL },
2328 { STRING_TOKEN (STR_SD_MPT), &gEfiSdMmcPassThruProtocolGuid, NULL },
2329 { STRING_TOKEN (STR_ERASE_BLOCK), &gEfiEraseBlockProtocolGuid, NULL },
2330
2331 //
2332 // UEFI2.7
2333 //
2334 { STRING_TOKEN (STR_BLUETOOTH_ATTR), &gEfiBluetoothAttributeProtocolGuid, NULL },
2335 { STRING_TOKEN (STR_BLUETOOTH_ATTR_SB), &gEfiBluetoothAttributeServiceBindingProtocolGuid, NULL },
2336 { STRING_TOKEN (STR_BLUETOOTH_LE_CONFIG), &gEfiBluetoothLeConfigProtocolGuid, NULL },
2337 { STRING_TOKEN (STR_UFS_DEV_CONFIG), &gEfiUfsDeviceConfigProtocolGuid, NULL },
2338 { STRING_TOKEN (STR_HTTP_BOOT_CALL), &gEfiHttpBootCallbackProtocolGuid, NULL },
2339 { STRING_TOKEN (STR_RESET_NOTI), &gEfiResetNotificationProtocolGuid, NULL },
2340 { STRING_TOKEN (STR_PARTITION_INFO), &gEfiPartitionInfoProtocolGuid, PartitionInfoProtocolDumpInformation },
2341 { STRING_TOKEN (STR_HII_POPUP), &gEfiHiiPopupProtocolGuid, NULL },
2342
2343 //
2344 // UEFI 2.8
2345 //
2346 { STRING_TOKEN (STR_REST_EX), &gEfiRestExProtocolGuid, NULL },
2347 { STRING_TOKEN (STR_REDFISH_DISCOVER), &gEfiRedfishDiscoverProtocolGuid, NULL },
2348
2349 //
2350 // PI Spec ones
2351 //
2352 { STRING_TOKEN (STR_IDE_CONT_INIT), &gEfiIdeControllerInitProtocolGuid, NULL },
2353 { STRING_TOKEN (STR_DISK_INFO), &gEfiDiskInfoProtocolGuid, NULL },
2354
2355 //
2356 // PI Spec 1.0
2357 //
2358 { STRING_TOKEN (STR_BDS_ARCH), &gEfiBdsArchProtocolGuid, NULL },
2359 { STRING_TOKEN (STR_CPU_ARCH), &gEfiCpuArchProtocolGuid, NULL },
2360 { STRING_TOKEN (STR_MET_ARCH), &gEfiMetronomeArchProtocolGuid, NULL },
2361 { STRING_TOKEN (STR_MON_ARCH), &gEfiMonotonicCounterArchProtocolGuid, NULL },
2362 { STRING_TOKEN (STR_RTC_ARCH), &gEfiRealTimeClockArchProtocolGuid, NULL },
2363 { STRING_TOKEN (STR_RESET_ARCH), &gEfiResetArchProtocolGuid, NULL },
2364 { STRING_TOKEN (STR_RT_ARCH), &gEfiRuntimeArchProtocolGuid, NULL },
2365 { STRING_TOKEN (STR_SEC_ARCH), &gEfiSecurityArchProtocolGuid, NULL },
2366 { STRING_TOKEN (STR_TIMER_ARCH), &gEfiTimerArchProtocolGuid, NULL },
2367 { STRING_TOKEN (STR_VAR_ARCH), &gEfiVariableWriteArchProtocolGuid, NULL },
2368 { STRING_TOKEN (STR_V_ARCH), &gEfiVariableArchProtocolGuid, NULL },
2369 { STRING_TOKEN (STR_SECP), &gEfiSecurityPolicyProtocolGuid, NULL },
2370 { STRING_TOKEN (STR_WDT_ARCH), &gEfiWatchdogTimerArchProtocolGuid, NULL },
2371 { STRING_TOKEN (STR_SCR), &gEfiStatusCodeRuntimeProtocolGuid, NULL },
2372 { STRING_TOKEN (STR_SMB_HC), &gEfiSmbusHcProtocolGuid, NULL },
2373 { STRING_TOKEN (STR_FV_2), &gEfiFirmwareVolume2ProtocolGuid, NULL },
2374 { STRING_TOKEN (STR_FV_BLOCK), &gEfiFirmwareVolumeBlockProtocolGuid, NULL },
2375 { STRING_TOKEN (STR_CAP_ARCH), &gEfiCapsuleArchProtocolGuid, NULL },
2376 { STRING_TOKEN (STR_MP_SERVICE), &gEfiMpServiceProtocolGuid, NULL },
2377 { STRING_TOKEN (STR_HBRAP), &gEfiPciHostBridgeResourceAllocationProtocolGuid, NULL },
2378 { STRING_TOKEN (STR_PCIP), &gEfiPciPlatformProtocolGuid, NULL },
2379 { STRING_TOKEN (STR_PCIO), &gEfiPciOverrideProtocolGuid, NULL },
2380 { STRING_TOKEN (STR_PCIE), &gEfiPciEnumerationCompleteProtocolGuid, NULL },
2381 { STRING_TOKEN (STR_IPCID), &gEfiIncompatiblePciDeviceSupportProtocolGuid, NULL },
2382 { STRING_TOKEN (STR_PCIHPI), &gEfiPciHotPlugInitProtocolGuid, NULL },
2383 { STRING_TOKEN (STR_PCIHPR), &gEfiPciHotPlugRequestProtocolGuid, NULL },
2384 { STRING_TOKEN (STR_SMBIOS), &gEfiSmbiosProtocolGuid, NULL },
2385 { STRING_TOKEN (STR_S3_SAVE), &gEfiS3SaveStateProtocolGuid, NULL },
2386 { STRING_TOKEN (STR_S3_S_SMM), &gEfiS3SmmSaveStateProtocolGuid, NULL },
2387 { STRING_TOKEN (STR_RSC), &gEfiRscHandlerProtocolGuid, NULL },
2388 { STRING_TOKEN (STR_S_RSC), &gEfiSmmRscHandlerProtocolGuid, NULL },
2389 { STRING_TOKEN (STR_ACPI_SDT), &gEfiAcpiSdtProtocolGuid, NULL },
2390 { STRING_TOKEN (STR_SIO), &gEfiSioProtocolGuid, NULL },
2391 { STRING_TOKEN (STR_S_CPU2), &gEfiSmmCpuIo2ProtocolGuid, NULL },
2392 { STRING_TOKEN (STR_S_BASE2), &gEfiSmmBase2ProtocolGuid, NULL },
2393 { STRING_TOKEN (STR_S_ACC_2), &gEfiSmmAccess2ProtocolGuid, NULL },
2394 { STRING_TOKEN (STR_S_CON_2), &gEfiSmmControl2ProtocolGuid, NULL },
2395 { STRING_TOKEN (STR_S_CONFIG), &gEfiSmmConfigurationProtocolGuid, NULL },
2396 { STRING_TOKEN (STR_S_RTL), &gEfiSmmReadyToLockProtocolGuid, NULL },
2397 { STRING_TOKEN (STR_DS_RTL), &gEfiDxeSmmReadyToLockProtocolGuid, NULL },
2398 { STRING_TOKEN (STR_S_COMM), &gEfiSmmCommunicationProtocolGuid, NULL },
2399 { STRING_TOKEN (STR_S_STAT), &gEfiSmmStatusCodeProtocolGuid, NULL },
2400 { STRING_TOKEN (STR_S_CPU), &gEfiSmmCpuProtocolGuid, NULL },
2401 { STRING_TOKEN (STR_S_PCIRBIO), &gEfiSmmPciRootBridgeIoProtocolGuid, NULL },
2402 { STRING_TOKEN (STR_S_SWD), &gEfiSmmSwDispatch2ProtocolGuid, NULL },
2403 { STRING_TOKEN (STR_S_SXD), &gEfiSmmSxDispatch2ProtocolGuid, NULL },
2404 { STRING_TOKEN (STR_S_PTD2), &gEfiSmmPeriodicTimerDispatch2ProtocolGuid, NULL },
2405 { STRING_TOKEN (STR_S_UD2), &gEfiSmmUsbDispatch2ProtocolGuid, NULL },
2406 { STRING_TOKEN (STR_S_GD2), &gEfiSmmGpiDispatch2ProtocolGuid, NULL },
2407 { STRING_TOKEN (STR_S_SBD2), &gEfiSmmStandbyButtonDispatch2ProtocolGuid, NULL },
2408 { STRING_TOKEN (STR_S_PBD2), &gEfiSmmPowerButtonDispatch2ProtocolGuid, NULL },
2409 { STRING_TOKEN (STR_S_ITD2), &gEfiSmmIoTrapDispatch2ProtocolGuid, NULL },
2410 { STRING_TOKEN (STR_PCD), &gEfiPcdProtocolGuid, NULL },
2411 { STRING_TOKEN (STR_FVB2), &gEfiFirmwareVolumeBlock2ProtocolGuid, NULL },
2412 { STRING_TOKEN (STR_CPUIO2), &gEfiCpuIo2ProtocolGuid, NULL },
2413 { STRING_TOKEN (STR_LEGACY_R2), &gEfiLegacyRegion2ProtocolGuid, NULL },
2414 { STRING_TOKEN (STR_S2ARCH), &gEfiSecurity2ArchProtocolGuid, NULL },
2415 { STRING_TOKEN (STR_EODXE), &gEfiSmmEndOfDxeProtocolGuid, NULL },
2416 { STRING_TOKEN (STR_ISAHC), &gEfiIsaHcProtocolGuid, NULL },
2417 { STRING_TOKEN (STR_ISAHC_B), &gEfiIsaHcServiceBindingProtocolGuid, NULL },
2418 { STRING_TOKEN (STR_SIO_C), &gEfiSioControlProtocolGuid, NULL },
2419 { STRING_TOKEN (STR_GET_PCD), &gEfiGetPcdInfoProtocolGuid, NULL },
2420 { STRING_TOKEN (STR_I2C_M), &gEfiI2cMasterProtocolGuid, NULL },
2421 { STRING_TOKEN (STR_I2CIO), &gEfiI2cIoProtocolGuid, NULL },
2422 { STRING_TOKEN (STR_I2CEN), &gEfiI2cEnumerateProtocolGuid, NULL },
2423 { STRING_TOKEN (STR_I2C_H), &gEfiI2cHostProtocolGuid, NULL },
2424 { STRING_TOKEN (STR_I2C_BCM), &gEfiI2cBusConfigurationManagementProtocolGuid, NULL },
2425 { STRING_TOKEN (STR_TCG2), &gEfiTcg2ProtocolGuid, NULL },
2426 { STRING_TOKEN (STR_TIMESTAMP), &gEfiTimestampProtocolGuid, NULL },
2427 { STRING_TOKEN (STR_RNG), &gEfiRngProtocolGuid, NULL },
2428 { STRING_TOKEN (STR_NVMEPT), &gEfiNvmExpressPassThruProtocolGuid, NULL },
2429 { STRING_TOKEN (STR_H2_SB), &gEfiHash2ServiceBindingProtocolGuid, NULL },
2430 { STRING_TOKEN (STR_HASH2), &gEfiHash2ProtocolGuid, NULL },
2431 { STRING_TOKEN (STR_BIO_C), &gEfiBlockIoCryptoProtocolGuid, NULL },
2432 { STRING_TOKEN (STR_SCR), &gEfiSmartCardReaderProtocolGuid, NULL },
2433 { STRING_TOKEN (STR_SCE), &gEfiSmartCardEdgeProtocolGuid, NULL },
2434 { STRING_TOKEN (STR_USB_FIO), &gEfiUsbFunctionIoProtocolGuid, NULL },
2435 { STRING_TOKEN (STR_BC_HC), &gEfiBluetoothHcProtocolGuid, NULL },
2436 { STRING_TOKEN (STR_BC_IO_SB), &gEfiBluetoothIoServiceBindingProtocolGuid, NULL },
2437 { STRING_TOKEN (STR_BC_IO), &gEfiBluetoothIoProtocolGuid, NULL },
2438 { STRING_TOKEN (STR_BC_C), &gEfiBluetoothConfigProtocolGuid, NULL },
2439 { STRING_TOKEN (STR_REG_EXP), &gEfiRegularExpressionProtocolGuid, NULL },
2440 { STRING_TOKEN (STR_B_MGR_P), &gEfiBootManagerPolicyProtocolGuid, NULL },
2441 { STRING_TOKEN (STR_CKH), &gEfiConfigKeywordHandlerProtocolGuid, NULL },
2442 { STRING_TOKEN (STR_WIFI), &gEfiWiFiProtocolGuid, NULL },
2443 { STRING_TOKEN (STR_EAP_M), &gEfiEapManagement2ProtocolGuid, NULL },
2444 { STRING_TOKEN (STR_EAP_C), &gEfiEapConfigurationProtocolGuid, NULL },
2445 { STRING_TOKEN (STR_PKCS7), &gEfiPkcs7VerifyProtocolGuid, NULL },
2446 { STRING_TOKEN (STR_NET_DNS4_SB), &gEfiDns4ServiceBindingProtocolGuid, NULL },
2447 { STRING_TOKEN (STR_NET_DNS4), &gEfiDns4ProtocolGuid, NULL },
2448 { STRING_TOKEN (STR_NET_DNS6_SB), &gEfiDns6ServiceBindingProtocolGuid, NULL },
2449 { STRING_TOKEN (STR_NET_DNS6), &gEfiDns6ProtocolGuid, NULL },
2450 { STRING_TOKEN (STR_NET_HTTP_SB), &gEfiHttpServiceBindingProtocolGuid, NULL },
2451 { STRING_TOKEN (STR_NET_HTTP), &gEfiHttpProtocolGuid, NULL },
2452 { STRING_TOKEN (STR_NET_HTTP_U), &gEfiHttpUtilitiesProtocolGuid, NULL },
2453 { STRING_TOKEN (STR_REST), &gEfiRestProtocolGuid, NULL },
2454
2455 //
2456 // PI 1.5
2457 //
2458 { STRING_TOKEN (STR_MM_EOD), &gEfiMmEndOfDxeProtocolGuid, NULL },
2459 { STRING_TOKEN (STR_MM_ITD), &gEfiMmIoTrapDispatchProtocolGuid, NULL },
2460 { STRING_TOKEN (STR_MM_PBD), &gEfiMmPowerButtonDispatchProtocolGuid, NULL },
2461 { STRING_TOKEN (STR_MM_SBD), &gEfiMmStandbyButtonDispatchProtocolGuid, NULL },
2462 { STRING_TOKEN (STR_MM_GD), &gEfiMmGpiDispatchProtocolGuid, NULL },
2463 { STRING_TOKEN (STR_MM_UD), &gEfiMmUsbDispatchProtocolGuid, NULL },
2464 { STRING_TOKEN (STR_MM_PTD), &gEfiMmPeriodicTimerDispatchProtocolGuid, NULL },
2465 { STRING_TOKEN (STR_MM_SXD), &gEfiMmSxDispatchProtocolGuid, NULL },
2466 { STRING_TOKEN (STR_MM_SWD), &gEfiMmSwDispatchProtocolGuid, NULL },
2467 { STRING_TOKEN (STR_MM_PRBI), &gEfiMmPciRootBridgeIoProtocolGuid, NULL },
2468 { STRING_TOKEN (STR_MM_CPU), &gEfiMmCpuProtocolGuid, NULL },
2469 { STRING_TOKEN (STR_MM_STACODE), &gEfiMmStatusCodeProtocolGuid, NULL },
2470 { STRING_TOKEN (STR_DXEMM_RTL), &gEfiDxeMmReadyToLockProtocolGuid, NULL },
2471 { STRING_TOKEN (STR_MM_CONFIG), &gEfiMmConfigurationProtocolGuid, NULL },
2472 { STRING_TOKEN (STR_MM_RTL), &gEfiMmReadyToLockProtocolGuid, NULL },
2473 { STRING_TOKEN (STR_MM_CONTROL), &gEfiMmControlProtocolGuid, NULL },
2474 { STRING_TOKEN (STR_MM_ACCESS), &gEfiMmAccessProtocolGuid, NULL },
2475 { STRING_TOKEN (STR_MM_BASE), &gEfiMmBaseProtocolGuid, NULL },
2476 { STRING_TOKEN (STR_MM_CPUIO), &gEfiMmCpuIoProtocolGuid, NULL },
2477 { STRING_TOKEN (STR_MM_RH), &gEfiMmRscHandlerProtocolGuid, NULL },
2478 { STRING_TOKEN (STR_MM_COM), &gEfiMmCommunicationProtocolGuid, NULL },
2479
2480 //
2481 // UEFI Shell Spec 2.0
2482 //
2483 { STRING_TOKEN (STR_SHELL_PARAMETERS), &gEfiShellParametersProtocolGuid, NULL },
2484 { STRING_TOKEN (STR_SHELL), &gEfiShellProtocolGuid, NULL },
2485
2486 //
2487 // UEFI Shell Spec 2.1
2488 //
2489 { STRING_TOKEN (STR_SHELL_DYNAMIC), &gEfiShellDynamicCommandProtocolGuid, NULL },
2490
2491 //
2492 // Misc
2493 //
2494 { STRING_TOKEN (STR_PCDINFOPROT), &gGetPcdInfoProtocolGuid, NULL },
2495
2496 //
2497 // terminator
2498 //
2499 { 0, NULL, NULL },
2500 };
2501
2502 /**
2503 Function to get the node for a protocol or struct from it's GUID.
2504
2505 if Guid is NULL, then ASSERT.
2506
2507 @param[in] Guid The GUID to look for the name of.
2508
2509 @return The node.
2510 **/
2511 CONST GUID_INFO_BLOCK *
2512 InternalShellGetNodeFromGuid (
2513 IN CONST EFI_GUID *Guid
2514 )
2515 {
2516 CONST GUID_INFO_BLOCK *ListWalker;
2517 UINTN LoopCount;
2518
2519 ASSERT (Guid != NULL);
2520
2521 for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {
2522 if (CompareGuid (ListWalker->GuidId, Guid)) {
2523 return (ListWalker);
2524 }
2525 }
2526
2527 if (PcdGetBool (PcdShellIncludeNtGuids)) {
2528 for (ListWalker = mGuidStringListNT; ListWalker != NULL && ListWalker->GuidId != NULL; ListWalker++) {
2529 if (CompareGuid (ListWalker->GuidId, Guid)) {
2530 return (ListWalker);
2531 }
2532 }
2533 }
2534
2535 for (ListWalker = mGuidStringList; ListWalker != NULL && ListWalker->GuidId != NULL; ListWalker++) {
2536 if (CompareGuid (ListWalker->GuidId, Guid)) {
2537 return (ListWalker);
2538 }
2539 }
2540
2541 return (NULL);
2542 }
2543
2544 /**
2545 Function to add a new GUID/Name mapping.
2546
2547 @param[in] Guid The Guid
2548 @param[in] NameID The STRING id of the HII string to use
2549 @param[in] DumpFunc The pointer to the dump function
2550
2551
2552 @retval EFI_SUCCESS The operation was sucessful
2553 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
2554 @retval EFI_INVALID_PARAMETER Guid NameId was invalid
2555 **/
2556 EFI_STATUS
2557 InsertNewGuidNameMapping (
2558 IN CONST EFI_GUID *Guid,
2559 IN CONST EFI_STRING_ID NameID,
2560 IN CONST DUMP_PROTOCOL_INFO DumpFunc OPTIONAL
2561 )
2562 {
2563 ASSERT (Guid != NULL);
2564 ASSERT (NameID != 0);
2565
2566 mGuidList = ReallocatePool (
2567 mGuidListCount * sizeof (GUID_INFO_BLOCK),
2568 (mGuidListCount + 1) * sizeof (GUID_INFO_BLOCK),
2569 mGuidList
2570 );
2571 if (mGuidList == NULL) {
2572 mGuidListCount = 0;
2573 return (EFI_OUT_OF_RESOURCES);
2574 }
2575
2576 mGuidListCount++;
2577
2578 mGuidList[mGuidListCount - 1].GuidId = AllocateCopyPool (sizeof (EFI_GUID), Guid);
2579 mGuidList[mGuidListCount - 1].StringId = NameID;
2580 mGuidList[mGuidListCount - 1].DumpInfo = DumpFunc;
2581
2582 if (mGuidList[mGuidListCount - 1].GuidId == NULL) {
2583 return (EFI_OUT_OF_RESOURCES);
2584 }
2585
2586 return (EFI_SUCCESS);
2587 }
2588
2589 /**
2590 Function to add a new GUID/Name mapping.
2591
2592 This cannot overwrite an existing mapping.
2593
2594 @param[in] Guid The Guid
2595 @param[in] TheName The Guid's name
2596 @param[in] Lang RFC4646 language code list or NULL
2597
2598 @retval EFI_SUCCESS The operation was sucessful
2599 @retval EFI_ACCESS_DENIED There was a duplicate
2600 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
2601 @retval EFI_INVALID_PARAMETER Guid or TheName was NULL
2602 **/
2603 EFI_STATUS
2604 EFIAPI
2605 AddNewGuidNameMapping (
2606 IN CONST EFI_GUID *Guid,
2607 IN CONST CHAR16 *TheName,
2608 IN CONST CHAR8 *Lang OPTIONAL
2609 )
2610 {
2611 EFI_STRING_ID NameID;
2612
2613 HandleParsingHiiInit ();
2614
2615 if ((Guid == NULL) || (TheName == NULL)) {
2616 return (EFI_INVALID_PARAMETER);
2617 }
2618
2619 if ((InternalShellGetNodeFromGuid (Guid)) != NULL) {
2620 return (EFI_ACCESS_DENIED);
2621 }
2622
2623 NameID = HiiSetString (mHandleParsingHiiHandle, 0, (CHAR16 *)TheName, Lang);
2624 if (NameID == 0) {
2625 return (EFI_OUT_OF_RESOURCES);
2626 }
2627
2628 return (InsertNewGuidNameMapping (Guid, NameID, NULL));
2629 }
2630
2631 /**
2632 Function to get the name of a protocol or struct from it's GUID.
2633
2634 if Guid is NULL, then ASSERT.
2635
2636 @param[in] Guid The GUID to look for the name of.
2637 @param[in] Lang The language to use.
2638
2639 @return pointer to string of the name. The caller
2640 is responsible to free this memory.
2641 **/
2642 CHAR16 *
2643 EFIAPI
2644 GetStringNameFromGuid (
2645 IN CONST EFI_GUID *Guid,
2646 IN CONST CHAR8 *Lang OPTIONAL
2647 )
2648 {
2649 CONST GUID_INFO_BLOCK *Id;
2650
2651 HandleParsingHiiInit ();
2652
2653 Id = InternalShellGetNodeFromGuid (Guid);
2654 if (Id == NULL) {
2655 return NULL;
2656 }
2657
2658 return HiiGetString (mHandleParsingHiiHandle, Id->StringId, Lang);
2659 }
2660
2661 /**
2662 Function to dump protocol information from a handle.
2663
2664 This function will return a allocated string buffer containing the
2665 information. The caller is responsible for freeing the memory.
2666
2667 If Guid is NULL, ASSERT().
2668 If TheHandle is NULL, ASSERT().
2669
2670 @param[in] TheHandle The handle to dump information from.
2671 @param[in] Guid The GUID of the protocol to dump.
2672 @param[in] Verbose TRUE for extra info. FALSE otherwise.
2673
2674 @return The pointer to string.
2675 @retval NULL An error was encountered.
2676 **/
2677 CHAR16 *
2678 EFIAPI
2679 GetProtocolInformationDump (
2680 IN CONST EFI_HANDLE TheHandle,
2681 IN CONST EFI_GUID *Guid,
2682 IN CONST BOOLEAN Verbose
2683 )
2684 {
2685 CONST GUID_INFO_BLOCK *Id;
2686
2687 ASSERT (TheHandle != NULL);
2688 ASSERT (Guid != NULL);
2689
2690 if ((TheHandle == NULL) || (Guid == NULL)) {
2691 return (NULL);
2692 }
2693
2694 Id = InternalShellGetNodeFromGuid (Guid);
2695 if ((Id != NULL) && (Id->DumpInfo != NULL)) {
2696 return (Id->DumpInfo (TheHandle, Verbose));
2697 }
2698
2699 return (NULL);
2700 }
2701
2702 /**
2703 Function to get the Guid for a protocol or struct based on it's string name.
2704
2705 do not modify the returned Guid.
2706
2707 @param[in] Name The pointer to the string name.
2708 @param[in] Lang The pointer to the language code.
2709 @param[out] Guid The pointer to the Guid.
2710
2711 @retval EFI_SUCCESS The operation was sucessful.
2712 **/
2713 EFI_STATUS
2714 EFIAPI
2715 GetGuidFromStringName (
2716 IN CONST CHAR16 *Name,
2717 IN CONST CHAR8 *Lang OPTIONAL,
2718 OUT EFI_GUID **Guid
2719 )
2720 {
2721 CONST GUID_INFO_BLOCK *ListWalker;
2722 CHAR16 *String;
2723 UINTN LoopCount;
2724
2725 HandleParsingHiiInit ();
2726
2727 ASSERT (Guid != NULL);
2728 if (Guid == NULL) {
2729 return (EFI_INVALID_PARAMETER);
2730 }
2731
2732 *Guid = NULL;
2733
2734 if (PcdGetBool (PcdShellIncludeNtGuids)) {
2735 for (ListWalker = mGuidStringListNT; ListWalker != NULL && ListWalker->GuidId != NULL; ListWalker++) {
2736 String = HiiGetString (mHandleParsingHiiHandle, ListWalker->StringId, Lang);
2737 if ((Name != NULL) && (String != NULL) && (StringNoCaseCompare (&Name, &String) == 0)) {
2738 *Guid = ListWalker->GuidId;
2739 }
2740
2741 SHELL_FREE_NON_NULL (String);
2742 if (*Guid != NULL) {
2743 return (EFI_SUCCESS);
2744 }
2745 }
2746 }
2747
2748 for (ListWalker = mGuidStringList; ListWalker != NULL && ListWalker->GuidId != NULL; ListWalker++) {
2749 String = HiiGetString (mHandleParsingHiiHandle, ListWalker->StringId, Lang);
2750 if ((Name != NULL) && (String != NULL) && (StringNoCaseCompare (&Name, &String) == 0)) {
2751 *Guid = ListWalker->GuidId;
2752 }
2753
2754 SHELL_FREE_NON_NULL (String);
2755 if (*Guid != NULL) {
2756 return (EFI_SUCCESS);
2757 }
2758 }
2759
2760 for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {
2761 String = HiiGetString (mHandleParsingHiiHandle, ListWalker->StringId, Lang);
2762 if ((Name != NULL) && (String != NULL) && (StringNoCaseCompare (&Name, &String) == 0)) {
2763 *Guid = ListWalker->GuidId;
2764 }
2765
2766 SHELL_FREE_NON_NULL (String);
2767 if (*Guid != NULL) {
2768 return (EFI_SUCCESS);
2769 }
2770 }
2771
2772 return (EFI_NOT_FOUND);
2773 }
2774
2775 /**
2776 Get best support language for this driver.
2777
2778 First base on the user input language to search, second base on the current
2779 platform used language to search, third get the first language from the
2780 support language list. The caller need to free the buffer of the best language.
2781
2782 @param[in] SupportedLanguages The support languages for this driver.
2783 @param[in] InputLanguage The user input language.
2784 @param[in] Iso639Language Whether get language for ISO639.
2785
2786 @return The best support language for this driver.
2787 **/
2788 CHAR8 *
2789 EFIAPI
2790 GetBestLanguageForDriver (
2791 IN CONST CHAR8 *SupportedLanguages,
2792 IN CONST CHAR8 *InputLanguage,
2793 IN BOOLEAN Iso639Language
2794 )
2795 {
2796 CHAR8 *LanguageVariable;
2797 CHAR8 *BestLanguage;
2798
2799 GetVariable2 (Iso639Language ? L"Lang" : L"PlatformLang", &gEfiGlobalVariableGuid, (VOID **)&LanguageVariable, NULL);
2800
2801 BestLanguage = GetBestLanguage (
2802 SupportedLanguages,
2803 Iso639Language,
2804 (InputLanguage != NULL) ? InputLanguage : "",
2805 (LanguageVariable != NULL) ? LanguageVariable : "",
2806 SupportedLanguages,
2807 NULL
2808 );
2809
2810 if (LanguageVariable != NULL) {
2811 FreePool (LanguageVariable);
2812 }
2813
2814 return BestLanguage;
2815 }
2816
2817 /**
2818 Function to retrieve the driver name (if possible) from the ComponentName or
2819 ComponentName2 protocol
2820
2821 @param[in] TheHandle The driver handle to get the name of.
2822 @param[in] Language The language to use.
2823
2824 @retval NULL The name could not be found.
2825 @return A pointer to the string name. Do not de-allocate the memory.
2826 **/
2827 CONST CHAR16 *
2828 EFIAPI
2829 GetStringNameFromHandle (
2830 IN CONST EFI_HANDLE TheHandle,
2831 IN CONST CHAR8 *Language
2832 )
2833 {
2834 EFI_COMPONENT_NAME2_PROTOCOL *CompNameStruct;
2835 EFI_STATUS Status;
2836 CHAR16 *RetVal;
2837 CHAR8 *BestLang;
2838
2839 BestLang = NULL;
2840
2841 Status = gBS->OpenProtocol (
2842 TheHandle,
2843 &gEfiComponentName2ProtocolGuid,
2844 (VOID **)&CompNameStruct,
2845 gImageHandle,
2846 NULL,
2847 EFI_OPEN_PROTOCOL_GET_PROTOCOL
2848 );
2849 if (!EFI_ERROR (Status)) {
2850 BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);
2851 Status = CompNameStruct->GetDriverName (CompNameStruct, BestLang, &RetVal);
2852 if (BestLang != NULL) {
2853 FreePool (BestLang);
2854 BestLang = NULL;
2855 }
2856
2857 if (!EFI_ERROR (Status)) {
2858 return (RetVal);
2859 }
2860 }
2861
2862 Status = gBS->OpenProtocol (
2863 TheHandle,
2864 &gEfiComponentNameProtocolGuid,
2865 (VOID **)&CompNameStruct,
2866 gImageHandle,
2867 NULL,
2868 EFI_OPEN_PROTOCOL_GET_PROTOCOL
2869 );
2870 if (!EFI_ERROR (Status)) {
2871 BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);
2872 Status = CompNameStruct->GetDriverName (CompNameStruct, BestLang, &RetVal);
2873 if (BestLang != NULL) {
2874 FreePool (BestLang);
2875 }
2876
2877 if (!EFI_ERROR (Status)) {
2878 return (RetVal);
2879 }
2880 }
2881
2882 return (NULL);
2883 }
2884
2885 /**
2886 Function to initialize the file global mHandleList object for use in
2887 vonverting handles to index and index to handle.
2888
2889 @retval EFI_SUCCESS The operation was successful.
2890 **/
2891 EFI_STATUS
2892 InternalShellInitHandleList (
2893 VOID
2894 )
2895 {
2896 EFI_STATUS Status;
2897 EFI_HANDLE *HandleBuffer;
2898 UINTN HandleCount;
2899 HANDLE_LIST *ListWalker;
2900
2901 if (mHandleList.NextIndex != 0) {
2902 return EFI_SUCCESS;
2903 }
2904
2905 InitializeListHead (&mHandleList.List.Link);
2906 mHandleList.NextIndex = 1;
2907 Status = gBS->LocateHandleBuffer (
2908 AllHandles,
2909 NULL,
2910 NULL,
2911 &HandleCount,
2912 &HandleBuffer
2913 );
2914 ASSERT_EFI_ERROR (Status);
2915 if (EFI_ERROR (Status)) {
2916 return (Status);
2917 }
2918
2919 for (mHandleList.NextIndex = 1; mHandleList.NextIndex <= HandleCount; mHandleList.NextIndex++) {
2920 ListWalker = AllocateZeroPool (sizeof (HANDLE_LIST));
2921 if (ListWalker != NULL) {
2922 ListWalker->TheHandle = HandleBuffer[mHandleList.NextIndex - 1];
2923 ListWalker->TheIndex = mHandleList.NextIndex;
2924 InsertTailList (&mHandleList.List.Link, &ListWalker->Link);
2925 }
2926 }
2927
2928 FreePool (HandleBuffer);
2929 return (EFI_SUCCESS);
2930 }
2931
2932 /**
2933 Function to retrieve the human-friendly index of a given handle. If the handle
2934 does not have a index one will be automatically assigned. The index value is valid
2935 until the termination of the shell application.
2936
2937 @param[in] TheHandle The handle to retrieve an index for.
2938
2939 @retval 0 A memory allocation failed.
2940 @return The index of the handle.
2941
2942 **/
2943 UINTN
2944 EFIAPI
2945 ConvertHandleToHandleIndex (
2946 IN CONST EFI_HANDLE TheHandle
2947 )
2948 {
2949 EFI_STATUS Status;
2950 EFI_GUID **ProtocolBuffer;
2951 UINTN ProtocolCount;
2952 HANDLE_LIST *ListWalker;
2953
2954 if (TheHandle == NULL) {
2955 return 0;
2956 }
2957
2958 InternalShellInitHandleList ();
2959
2960 for (ListWalker = (HANDLE_LIST *)GetFirstNode (&mHandleList.List.Link)
2961 ; !IsNull (&mHandleList.List.Link, &ListWalker->Link)
2962 ; ListWalker = (HANDLE_LIST *)GetNextNode (&mHandleList.List.Link, &ListWalker->Link)
2963 )
2964 {
2965 if (ListWalker->TheHandle == TheHandle) {
2966 //
2967 // Verify that TheHandle is still present in the Handle Database
2968 //
2969 Status = gBS->ProtocolsPerHandle (TheHandle, &ProtocolBuffer, &ProtocolCount);
2970 if (EFI_ERROR (Status)) {
2971 //
2972 // TheHandle is not present in the Handle Database, so delete from the handle list
2973 //
2974 RemoveEntryList (&ListWalker->Link);
2975 return 0;
2976 }
2977
2978 FreePool (ProtocolBuffer);
2979 return (ListWalker->TheIndex);
2980 }
2981 }
2982
2983 //
2984 // Verify that TheHandle is valid handle
2985 //
2986 Status = gBS->ProtocolsPerHandle (TheHandle, &ProtocolBuffer, &ProtocolCount);
2987 if (EFI_ERROR (Status)) {
2988 //
2989 // TheHandle is not valid, so do not add to handle list
2990 //
2991 return 0;
2992 }
2993
2994 FreePool (ProtocolBuffer);
2995
2996 ListWalker = AllocateZeroPool (sizeof (HANDLE_LIST));
2997 if (ListWalker == NULL) {
2998 return 0;
2999 }
3000
3001 ListWalker->TheHandle = TheHandle;
3002 ListWalker->TheIndex = mHandleList.NextIndex++;
3003 InsertTailList (&mHandleList.List.Link, &ListWalker->Link);
3004 return (ListWalker->TheIndex);
3005 }
3006
3007 /**
3008 Function to retrieve the EFI_HANDLE from the human-friendly index.
3009
3010 @param[in] TheIndex The index to retrieve the EFI_HANDLE for.
3011
3012 @retval NULL The index was invalid.
3013 @return The EFI_HANDLE that index represents.
3014
3015 **/
3016 EFI_HANDLE
3017 EFIAPI
3018 ConvertHandleIndexToHandle (
3019 IN CONST UINTN TheIndex
3020 )
3021 {
3022 EFI_STATUS Status;
3023 EFI_GUID **ProtocolBuffer;
3024 UINTN ProtocolCount;
3025 HANDLE_LIST *ListWalker;
3026
3027 InternalShellInitHandleList ();
3028
3029 if (TheIndex >= mHandleList.NextIndex) {
3030 return NULL;
3031 }
3032
3033 for (ListWalker = (HANDLE_LIST *)GetFirstNode (&mHandleList.List.Link)
3034 ; !IsNull (&mHandleList.List.Link, &ListWalker->Link)
3035 ; ListWalker = (HANDLE_LIST *)GetNextNode (&mHandleList.List.Link, &ListWalker->Link)
3036 )
3037 {
3038 if ((ListWalker->TheIndex == TheIndex) && (ListWalker->TheHandle != NULL)) {
3039 //
3040 // Verify that LinkWalker->TheHandle is valid handle
3041 //
3042 Status = gBS->ProtocolsPerHandle (ListWalker->TheHandle, &ProtocolBuffer, &ProtocolCount);
3043 if (!EFI_ERROR (Status)) {
3044 FreePool (ProtocolBuffer);
3045 } else {
3046 //
3047 // TheHandle is not valid, so do not add to handle list
3048 //
3049 ListWalker->TheHandle = NULL;
3050 }
3051
3052 return (ListWalker->TheHandle);
3053 }
3054 }
3055
3056 return NULL;
3057 }
3058
3059 /**
3060 Gets all the related EFI_HANDLEs based on the mask supplied.
3061
3062 This function scans all EFI_HANDLES in the UEFI environment's handle database
3063 and returns the ones with the specified relationship (Mask) to the specified
3064 controller handle.
3065
3066 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
3067 If MatchingHandleCount is NULL, then ASSERT.
3068
3069 If MatchingHandleBuffer is not NULL upon a successful return the memory must be
3070 caller freed.
3071
3072 @param[in] DriverBindingHandle The handle with Driver Binding protocol on it.
3073 @param[in] ControllerHandle The handle with Device Path protocol on it.
3074 @param[in] MatchingHandleCount The pointer to UINTN that specifies the number of HANDLES in
3075 MatchingHandleBuffer.
3076 @param[out] MatchingHandleBuffer On a successful return, a buffer of MatchingHandleCount
3077 EFI_HANDLEs with a terminating NULL EFI_HANDLE.
3078 @param[out] HandleType An array of type information.
3079
3080 @retval EFI_SUCCESS The operation was successful, and any related handles
3081 are in MatchingHandleBuffer.
3082 @retval EFI_NOT_FOUND No matching handles were found.
3083 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.
3084 **/
3085 EFI_STATUS
3086 EFIAPI
3087 ParseHandleDatabaseByRelationshipWithType (
3088 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL,
3089 IN CONST EFI_HANDLE ControllerHandle OPTIONAL,
3090 IN UINTN *HandleCount,
3091 OUT EFI_HANDLE **HandleBuffer,
3092 OUT UINTN **HandleType
3093 )
3094 {
3095 EFI_STATUS Status;
3096 UINTN HandleIndex;
3097 EFI_GUID **ProtocolGuidArray;
3098 UINTN ArrayCount;
3099 UINTN ProtocolIndex;
3100 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo;
3101 UINTN OpenInfoCount;
3102 UINTN OpenInfoIndex;
3103 UINTN ChildIndex;
3104 INTN DriverBindingHandleIndex;
3105
3106 ASSERT (HandleCount != NULL);
3107 ASSERT (HandleBuffer != NULL);
3108 ASSERT (HandleType != NULL);
3109 ASSERT (DriverBindingHandle != NULL || ControllerHandle != NULL);
3110
3111 *HandleCount = 0;
3112 *HandleBuffer = NULL;
3113 *HandleType = NULL;
3114
3115 //
3116 // Retrieve the list of all handles from the handle database
3117 //
3118 Status = gBS->LocateHandleBuffer (
3119 AllHandles,
3120 NULL,
3121 NULL,
3122 HandleCount,
3123 HandleBuffer
3124 );
3125 if (EFI_ERROR (Status)) {
3126 return (Status);
3127 }
3128
3129 *HandleType = AllocateZeroPool (*HandleCount * sizeof (UINTN));
3130 if (*HandleType == NULL) {
3131 SHELL_FREE_NON_NULL (*HandleBuffer);
3132 *HandleCount = 0;
3133 return EFI_OUT_OF_RESOURCES;
3134 }
3135
3136 DriverBindingHandleIndex = -1;
3137 for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {
3138 if ((DriverBindingHandle != NULL) && ((*HandleBuffer)[HandleIndex] == DriverBindingHandle)) {
3139 DriverBindingHandleIndex = (INTN)HandleIndex;
3140 }
3141 }
3142
3143 for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {
3144 //
3145 // Retrieve the list of all the protocols on each handle
3146 //
3147 Status = gBS->ProtocolsPerHandle (
3148 (*HandleBuffer)[HandleIndex],
3149 &ProtocolGuidArray,
3150 &ArrayCount
3151 );
3152 if (EFI_ERROR (Status)) {
3153 continue;
3154 }
3155
3156 for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
3157 //
3158 // Set the bit describing what this handle has
3159 //
3160 if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiLoadedImageProtocolGuid)) {
3161 (*HandleType)[HandleIndex] |= (UINTN)HR_IMAGE_HANDLE;
3162 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverBindingProtocolGuid)) {
3163 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_BINDING_HANDLE;
3164 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfiguration2ProtocolGuid)) {
3165 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;
3166 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfigurationProtocolGuid)) {
3167 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;
3168 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnostics2ProtocolGuid)) {
3169 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;
3170 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnosticsProtocolGuid)) {
3171 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;
3172 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentName2ProtocolGuid)) {
3173 (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;
3174 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentNameProtocolGuid)) {
3175 (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;
3176 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid)) {
3177 (*HandleType)[HandleIndex] |= (UINTN)HR_DEVICE_HANDLE;
3178 }
3179
3180 //
3181 // Retrieve the list of agents that have opened each protocol
3182 //
3183 Status = gBS->OpenProtocolInformation (
3184 (*HandleBuffer)[HandleIndex],
3185 ProtocolGuidArray[ProtocolIndex],
3186 &OpenInfo,
3187 &OpenInfoCount
3188 );
3189 if (EFI_ERROR (Status)) {
3190 continue;
3191 }
3192
3193 if (ControllerHandle == NULL) {
3194 //
3195 // ControllerHandle == NULL and DriverBindingHandle != NULL.
3196 // Return information on all the controller handles that the driver specified by DriverBindingHandle is managing
3197 //
3198 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
3199 if ((OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) && ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0)) {
3200 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
3201 if (DriverBindingHandleIndex != -1) {
3202 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;
3203 }
3204 }
3205
3206 if ((OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) && ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0)) {
3207 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
3208 if (DriverBindingHandleIndex != -1) {
3209 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
3210 }
3211
3212 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
3213 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
3214 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
3215 }
3216 }
3217 }
3218 }
3219 }
3220
3221 if ((DriverBindingHandle == NULL) && (ControllerHandle != NULL)) {
3222 if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {
3223 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
3224 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
3225 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
3226 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
3227 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
3228 (*HandleType)[ChildIndex] |= (UINTN)HR_DEVICE_DRIVER;
3229 }
3230 }
3231 }
3232
3233 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
3234 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
3235 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
3236 (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
3237 }
3238
3239 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
3240 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
3241 }
3242 }
3243 }
3244 }
3245 } else {
3246 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
3247 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
3248 if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {
3249 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);
3250 }
3251 }
3252 }
3253 }
3254 }
3255
3256 if ((DriverBindingHandle != NULL) && (ControllerHandle != NULL)) {
3257 if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {
3258 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
3259 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
3260 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
3261 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {
3262 if (DriverBindingHandleIndex != -1) {
3263 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;
3264 }
3265 }
3266 }
3267
3268 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
3269 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {
3270 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
3271 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
3272 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
3273 }
3274 }
3275 }
3276
3277 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
3278 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
3279 (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
3280 }
3281 }
3282 }
3283 }
3284 } else {
3285 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
3286 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
3287 if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {
3288 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);
3289 }
3290 }
3291 }
3292 }
3293 }
3294
3295 FreePool (OpenInfo);
3296 }
3297
3298 FreePool (ProtocolGuidArray);
3299 }
3300
3301 return EFI_SUCCESS;
3302 }
3303
3304 /**
3305 Gets all the related EFI_HANDLEs based on the single EFI_HANDLE and the mask
3306 supplied.
3307
3308 This function will scan all EFI_HANDLES in the UEFI environment's handle database
3309 and return all the ones with the specified relationship (Mask) to the specified
3310 controller handle.
3311
3312 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.
3313 If MatchingHandleCount is NULL, then ASSERT.
3314
3315 If MatchingHandleBuffer is not NULL upon a sucessful return the memory must be
3316 caller freed.
3317
3318 @param[in] DriverBindingHandle Handle to a object with Driver Binding protocol
3319 on it.
3320 @param[in] ControllerHandle Handle to a device with Device Path protocol on it.
3321 @param[in] Mask Mask of what relationship(s) is desired.
3322 @param[in] MatchingHandleCount Poitner to UINTN specifying number of HANDLES in
3323 MatchingHandleBuffer.
3324 @param[out] MatchingHandleBuffer On a sucessful return a buffer of MatchingHandleCount
3325 EFI_HANDLEs and a terminating NULL EFI_HANDLE.
3326
3327 @retval EFI_SUCCESS The operation was sucessful and any related handles
3328 are in MatchingHandleBuffer;
3329 @retval EFI_NOT_FOUND No matching handles were found.
3330 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.
3331 **/
3332 EFI_STATUS
3333 EFIAPI
3334 ParseHandleDatabaseByRelationship (
3335 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL,
3336 IN CONST EFI_HANDLE ControllerHandle OPTIONAL,
3337 IN CONST UINTN Mask,
3338 IN UINTN *MatchingHandleCount,
3339 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL
3340 )
3341 {
3342 EFI_STATUS Status;
3343 UINTN HandleCount;
3344 EFI_HANDLE *HandleBuffer;
3345 UINTN *HandleType;
3346 UINTN HandleIndex;
3347
3348 ASSERT (MatchingHandleCount != NULL);
3349 ASSERT (DriverBindingHandle != NULL || ControllerHandle != NULL);
3350
3351 if ((Mask & HR_VALID_MASK) != Mask) {
3352 return (EFI_INVALID_PARAMETER);
3353 }
3354
3355 if (((Mask & HR_CHILD_HANDLE) != 0) && (DriverBindingHandle == NULL)) {
3356 return (EFI_INVALID_PARAMETER);
3357 }
3358
3359 *MatchingHandleCount = 0;
3360 if (MatchingHandleBuffer != NULL) {
3361 *MatchingHandleBuffer = NULL;
3362 }
3363
3364 HandleBuffer = NULL;
3365 HandleType = NULL;
3366
3367 Status = ParseHandleDatabaseByRelationshipWithType (
3368 DriverBindingHandle,
3369 ControllerHandle,
3370 &HandleCount,
3371 &HandleBuffer,
3372 &HandleType
3373 );
3374 if (!EFI_ERROR (Status)) {
3375 //
3376 // Count the number of handles that match the attributes in Mask
3377 //
3378 for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {
3379 if ((HandleType[HandleIndex] & Mask) == Mask) {
3380 (*MatchingHandleCount)++;
3381 }
3382 }
3383
3384 //
3385 // If no handles match the attributes in Mask then return EFI_NOT_FOUND
3386 //
3387 if (*MatchingHandleCount == 0) {
3388 Status = EFI_NOT_FOUND;
3389 } else {
3390 if (MatchingHandleBuffer == NULL) {
3391 //
3392 // Someone just wanted the count...
3393 //
3394 Status = EFI_SUCCESS;
3395 } else {
3396 //
3397 // Allocate a handle buffer for the number of handles that matched the attributes in Mask
3398 //
3399 *MatchingHandleBuffer = AllocateZeroPool ((*MatchingHandleCount +1)* sizeof (EFI_HANDLE));
3400 if (*MatchingHandleBuffer == NULL) {
3401 Status = EFI_OUT_OF_RESOURCES;
3402 } else {
3403 for (HandleIndex = 0, *MatchingHandleCount = 0
3404 ; HandleIndex < HandleCount
3405 ; HandleIndex++
3406 )
3407 {
3408 //
3409 // Fill the allocated buffer with the handles that matched the attributes in Mask
3410 //
3411 if ((HandleType[HandleIndex] & Mask) == Mask) {
3412 (*MatchingHandleBuffer)[(*MatchingHandleCount)++] = HandleBuffer[HandleIndex];
3413 }
3414 }
3415
3416 //
3417 // Make the last one NULL
3418 //
3419 (*MatchingHandleBuffer)[*MatchingHandleCount] = NULL;
3420
3421 Status = EFI_SUCCESS;
3422 } // *MatchingHandleBuffer == NULL (ELSE)
3423 } // MacthingHandleBuffer == NULL (ELSE)
3424 } // *MatchingHandleCount == 0 (ELSE)
3425 } // no error on ParseHandleDatabaseByRelationshipWithType
3426
3427 if (HandleBuffer != NULL) {
3428 FreePool (HandleBuffer);
3429 }
3430
3431 if (HandleType != NULL) {
3432 FreePool (HandleType);
3433 }
3434
3435 ASSERT (
3436 (MatchingHandleBuffer == NULL) ||
3437 (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||
3438 (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL)
3439 );
3440 return Status;
3441 }
3442
3443 /**
3444 Gets handles for any child controllers of the passed in controller.
3445
3446 @param[in] ControllerHandle The handle of the "parent controller"
3447 @param[out] MatchingHandleCount Pointer to the number of handles in
3448 MatchingHandleBuffer on return.
3449 @param[out] MatchingHandleBuffer Buffer containing handles on a successful
3450 return.
3451
3452
3453 @retval EFI_SUCCESS The operation was sucessful.
3454 **/
3455 EFI_STATUS
3456 EFIAPI
3457 ParseHandleDatabaseForChildControllers (
3458 IN CONST EFI_HANDLE ControllerHandle,
3459 OUT UINTN *MatchingHandleCount,
3460 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL
3461 )
3462 {
3463 EFI_STATUS Status;
3464 UINTN HandleIndex;
3465 UINTN DriverBindingHandleCount;
3466 EFI_HANDLE *DriverBindingHandleBuffer;
3467 UINTN DriverBindingHandleIndex;
3468 UINTN ChildControllerHandleCount;
3469 EFI_HANDLE *ChildControllerHandleBuffer;
3470 UINTN ChildControllerHandleIndex;
3471 EFI_HANDLE *HandleBufferForReturn;
3472
3473 if (MatchingHandleCount == NULL) {
3474 return (EFI_INVALID_PARAMETER);
3475 }
3476
3477 *MatchingHandleCount = 0;
3478
3479 Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
3480 ControllerHandle,
3481 &DriverBindingHandleCount,
3482 &DriverBindingHandleBuffer
3483 );
3484 if (EFI_ERROR (Status)) {
3485 return Status;
3486 }
3487
3488 //
3489 // Get a buffer big enough for all the controllers.
3490 //
3491 HandleBufferForReturn = GetHandleListByProtocol (NULL);
3492 if (HandleBufferForReturn == NULL) {
3493 FreePool (DriverBindingHandleBuffer);
3494 return (EFI_NOT_FOUND);
3495 }
3496
3497 for (DriverBindingHandleIndex = 0; DriverBindingHandleIndex < DriverBindingHandleCount; DriverBindingHandleIndex++) {
3498 Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
3499 DriverBindingHandleBuffer[DriverBindingHandleIndex],
3500 ControllerHandle,
3501 &ChildControllerHandleCount,
3502 &ChildControllerHandleBuffer
3503 );
3504 if (EFI_ERROR (Status)) {
3505 continue;
3506 }
3507
3508 for (ChildControllerHandleIndex = 0;
3509 ChildControllerHandleIndex < ChildControllerHandleCount;
3510 ChildControllerHandleIndex++
3511 )
3512 {
3513 for (HandleIndex = 0; HandleIndex < *MatchingHandleCount; HandleIndex++) {
3514 if (HandleBufferForReturn[HandleIndex] == ChildControllerHandleBuffer[ChildControllerHandleIndex]) {
3515 break;
3516 }
3517 }
3518
3519 if (HandleIndex >= *MatchingHandleCount) {
3520 HandleBufferForReturn[(*MatchingHandleCount)++] = ChildControllerHandleBuffer[ChildControllerHandleIndex];
3521 }
3522 }
3523
3524 FreePool (ChildControllerHandleBuffer);
3525 }
3526
3527 FreePool (DriverBindingHandleBuffer);
3528
3529 if ((MatchingHandleBuffer == NULL) || (*MatchingHandleCount == 0)) {
3530 //
3531 // The caller is not interested in the actual handles, or we've found none.
3532 //
3533 FreePool (HandleBufferForReturn);
3534 HandleBufferForReturn = NULL;
3535 }
3536
3537 if (MatchingHandleBuffer != NULL) {
3538 *MatchingHandleBuffer = HandleBufferForReturn;
3539 }
3540
3541 ASSERT (
3542 (MatchingHandleBuffer == NULL) ||
3543 (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||
3544 (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL)
3545 );
3546
3547 return (EFI_SUCCESS);
3548 }
3549
3550 /**
3551 Appends 1 buffer to another buffer. This will re-allocate the destination buffer
3552 if necessary to fit all of the data.
3553
3554 If DestinationBuffer is NULL, then ASSERT().
3555
3556 @param[in, out] DestinationBuffer The pointer to the pointer to the buffer to append onto.
3557 @param[in, out] DestinationSize The pointer to the size of DestinationBuffer.
3558 @param[in] SourceBuffer The pointer to the buffer to append onto DestinationBuffer.
3559 @param[in] SourceSize The number of bytes of SourceBuffer to append.
3560
3561 @retval NULL A memory allocation failed.
3562 @retval NULL A parameter was invalid.
3563 @return A pointer to (*DestinationBuffer).
3564 **/
3565 VOID *
3566 BuffernCatGrow (
3567 IN OUT VOID **DestinationBuffer,
3568 IN OUT UINTN *DestinationSize,
3569 IN VOID *SourceBuffer,
3570 IN UINTN SourceSize
3571 )
3572 {
3573 UINTN LocalDestinationSize;
3574 UINTN LocalDestinationFinalSize;
3575
3576 ASSERT (DestinationBuffer != NULL);
3577
3578 if ((SourceSize == 0) || (SourceBuffer == NULL)) {
3579 return (*DestinationBuffer);
3580 }
3581
3582 if (DestinationSize == NULL) {
3583 LocalDestinationSize = 0;
3584 } else {
3585 LocalDestinationSize = *DestinationSize;
3586 }
3587
3588 LocalDestinationFinalSize = LocalDestinationSize + SourceSize;
3589
3590 if (DestinationSize != NULL) {
3591 *DestinationSize = LocalDestinationSize;
3592 }
3593
3594 if (LocalDestinationSize == 0) {
3595 // allcoate
3596 *DestinationBuffer = AllocateZeroPool (LocalDestinationFinalSize);
3597 } else {
3598 // reallocate
3599 *DestinationBuffer = ReallocatePool (LocalDestinationSize, LocalDestinationFinalSize, *DestinationBuffer);
3600 }
3601
3602 ASSERT (*DestinationBuffer != NULL);
3603
3604 // copy
3605 return (CopyMem (((UINT8 *)(*DestinationBuffer)) + LocalDestinationSize, SourceBuffer, SourceSize));
3606 }
3607
3608 /**
3609 Gets handles for any child devices produced by the passed in driver.
3610
3611 @param[in] DriverHandle The handle of the driver.
3612 @param[in] MatchingHandleCount Pointer to the number of handles in
3613 MatchingHandleBuffer on return.
3614 @param[out] MatchingHandleBuffer Buffer containing handles on a successful
3615 return.
3616 @retval EFI_SUCCESS The operation was sucessful.
3617 @sa ParseHandleDatabaseByRelationship
3618 **/
3619 EFI_STATUS
3620 EFIAPI
3621 ParseHandleDatabaseForChildDevices (
3622 IN CONST EFI_HANDLE DriverHandle,
3623 IN UINTN *MatchingHandleCount,
3624 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL
3625 )
3626 {
3627 EFI_HANDLE *Buffer;
3628 EFI_HANDLE *Buffer2;
3629 UINTN Count1;
3630 UINTN Count2;
3631 UINTN HandleIndex;
3632 EFI_STATUS Status;
3633 UINTN HandleBufferSize;
3634
3635 ASSERT (MatchingHandleCount != NULL);
3636
3637 HandleBufferSize = 0;
3638 Buffer = NULL;
3639 Buffer2 = NULL;
3640 *MatchingHandleCount = 0;
3641
3642 Status = PARSE_HANDLE_DATABASE_DEVICES (
3643 DriverHandle,
3644 &Count1,
3645 &Buffer
3646 );
3647 if (!EFI_ERROR (Status)) {
3648 for (HandleIndex = 0; HandleIndex < Count1; HandleIndex++) {
3649 //
3650 // now find the children
3651 //
3652 Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
3653 DriverHandle,
3654 Buffer[HandleIndex],
3655 &Count2,
3656 &Buffer2
3657 );
3658 if (EFI_ERROR (Status)) {
3659 break;
3660 }
3661
3662 //
3663 // save out required and optional data elements
3664 //
3665 *MatchingHandleCount += Count2;
3666 if (MatchingHandleBuffer != NULL) {
3667 *MatchingHandleBuffer = BuffernCatGrow ((VOID **)MatchingHandleBuffer, &HandleBufferSize, Buffer2, Count2 * sizeof (Buffer2[0]));
3668 }
3669
3670 //
3671 // free the memory
3672 //
3673 if (Buffer2 != NULL) {
3674 FreePool (Buffer2);
3675 }
3676 }
3677 }
3678
3679 if (Buffer != NULL) {
3680 FreePool (Buffer);
3681 }
3682
3683 return (Status);
3684 }
3685
3686 /**
3687 Function to get all handles that support a given protocol or all handles.
3688
3689 @param[in] ProtocolGuid The guid of the protocol to get handles for. If NULL
3690 then the function will return all handles.
3691
3692 @retval NULL A memory allocation failed.
3693 @return A NULL terminated list of handles.
3694 **/
3695 EFI_HANDLE *
3696 EFIAPI
3697 GetHandleListByProtocol (
3698 IN CONST EFI_GUID *ProtocolGuid OPTIONAL
3699 )
3700 {
3701 EFI_HANDLE *HandleList;
3702 UINTN Size;
3703 EFI_STATUS Status;
3704
3705 Size = 0;
3706 HandleList = NULL;
3707
3708 //
3709 // We cannot use LocateHandleBuffer since we need that NULL item on the ends of the list!
3710 //
3711 if (ProtocolGuid == NULL) {
3712 Status = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, HandleList);
3713 if (Status == EFI_BUFFER_TOO_SMALL) {
3714 HandleList = AllocateZeroPool (Size + sizeof (EFI_HANDLE));
3715 if (HandleList == NULL) {
3716 return (NULL);
3717 }
3718
3719 Status = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, HandleList);
3720 HandleList[Size/sizeof (EFI_HANDLE)] = NULL;
3721 }
3722 } else {
3723 Status = gBS->LocateHandle (ByProtocol, (EFI_GUID *)ProtocolGuid, NULL, &Size, HandleList);
3724 if (Status == EFI_BUFFER_TOO_SMALL) {
3725 HandleList = AllocateZeroPool (Size + sizeof (EFI_HANDLE));
3726 if (HandleList == NULL) {
3727 return (NULL);
3728 }
3729
3730 Status = gBS->LocateHandle (ByProtocol, (EFI_GUID *)ProtocolGuid, NULL, &Size, HandleList);
3731 HandleList[Size/sizeof (EFI_HANDLE)] = NULL;
3732 }
3733 }
3734
3735 if (EFI_ERROR (Status)) {
3736 if (HandleList != NULL) {
3737 FreePool (HandleList);
3738 }
3739
3740 return (NULL);
3741 }
3742
3743 return (HandleList);
3744 }
3745
3746 /**
3747 Function to get all handles that support some protocols.
3748
3749 @param[in] ProtocolGuids A NULL terminated list of protocol GUIDs.
3750
3751 @retval NULL A memory allocation failed.
3752 @retval NULL ProtocolGuids was NULL.
3753 @return A NULL terminated list of EFI_HANDLEs.
3754 **/
3755 EFI_HANDLE *
3756 EFIAPI
3757 GetHandleListByProtocolList (
3758 IN CONST EFI_GUID **ProtocolGuids
3759 )
3760 {
3761 EFI_HANDLE *HandleList;
3762 UINTN Size;
3763 UINTN TotalSize;
3764 UINTN TempSize;
3765 EFI_STATUS Status;
3766 CONST EFI_GUID **GuidWalker;
3767 EFI_HANDLE *HandleWalker1;
3768 EFI_HANDLE *HandleWalker2;
3769
3770 Size = 0;
3771 HandleList = NULL;
3772 TotalSize = sizeof (EFI_HANDLE);
3773
3774 for (GuidWalker = ProtocolGuids; GuidWalker != NULL && *GuidWalker != NULL; GuidWalker++, Size = 0) {
3775 Status = gBS->LocateHandle (ByProtocol, (EFI_GUID *)(*GuidWalker), NULL, &Size, NULL);
3776 if (Status == EFI_BUFFER_TOO_SMALL) {
3777 TotalSize += Size;
3778 }
3779 }
3780
3781 //
3782 // No handles were found...
3783 //
3784 if (TotalSize == sizeof (EFI_HANDLE)) {
3785 return (NULL);
3786 }
3787
3788 HandleList = AllocateZeroPool (TotalSize);
3789 if (HandleList == NULL) {
3790 return (NULL);
3791 }
3792
3793 Size = 0;
3794 for (GuidWalker = ProtocolGuids; GuidWalker != NULL && *GuidWalker != NULL; GuidWalker++) {
3795 TempSize = TotalSize - Size;
3796 Status = gBS->LocateHandle (ByProtocol, (EFI_GUID *)(*GuidWalker), NULL, &TempSize, HandleList+(Size/sizeof (EFI_HANDLE)));
3797
3798 //
3799 // Allow for missing protocols... Only update the 'used' size upon success.
3800 //
3801 if (!EFI_ERROR (Status)) {
3802 Size += TempSize;
3803 }
3804 }
3805
3806 ASSERT (HandleList[(TotalSize/sizeof (EFI_HANDLE))-1] == NULL);
3807
3808 for (HandleWalker1 = HandleList; HandleWalker1 != NULL && *HandleWalker1 != NULL; HandleWalker1++) {
3809 for (HandleWalker2 = HandleWalker1 + 1; HandleWalker2 != NULL && *HandleWalker2 != NULL; HandleWalker2++) {
3810 if (*HandleWalker1 == *HandleWalker2) {
3811 //
3812 // copy memory back 1 handle width.
3813 //
3814 CopyMem (HandleWalker2, HandleWalker2 + 1, TotalSize - ((HandleWalker2-HandleList+1)*sizeof (EFI_HANDLE)));
3815 }
3816 }
3817 }
3818
3819 return (HandleList);
3820 }
3821
3822 /**
3823 Return all supported GUIDs.
3824
3825 @param[out] Guids The buffer to return all supported GUIDs.
3826 @param[in, out] Count On input, the count of GUIDs the buffer can hold,
3827 On output, the count of GUIDs to return.
3828
3829 @retval EFI_INVALID_PARAMETER Count is NULL.
3830 @retval EFI_BUFFER_TOO_SMALL Buffer is not enough to hold all GUIDs.
3831 @retval EFI_SUCCESS GUIDs are returned successfully.
3832 **/
3833 EFI_STATUS
3834 EFIAPI
3835 GetAllMappingGuids (
3836 OUT EFI_GUID *Guids,
3837 IN OUT UINTN *Count
3838 )
3839 {
3840 UINTN GuidCount;
3841 UINTN NtGuidCount;
3842 UINTN Index;
3843
3844 if (Count == NULL) {
3845 return EFI_INVALID_PARAMETER;
3846 }
3847
3848 NtGuidCount = 0;
3849 if (PcdGetBool (PcdShellIncludeNtGuids)) {
3850 NtGuidCount = ARRAY_SIZE (mGuidStringListNT) - 1;
3851 }
3852
3853 GuidCount = ARRAY_SIZE (mGuidStringList) - 1;
3854
3855 if (*Count < NtGuidCount + GuidCount + mGuidListCount) {
3856 *Count = NtGuidCount + GuidCount + mGuidListCount;
3857 return EFI_BUFFER_TOO_SMALL;
3858 }
3859
3860 for (Index = 0; Index < NtGuidCount; Index++) {
3861 CopyGuid (&Guids[Index], mGuidStringListNT[Index].GuidId);
3862 }
3863
3864 for (Index = 0; Index < GuidCount; Index++) {
3865 CopyGuid (&Guids[NtGuidCount + Index], mGuidStringList[Index].GuidId);
3866 }
3867
3868 for (Index = 0; Index < mGuidListCount; Index++) {
3869 CopyGuid (&Guids[NtGuidCount + GuidCount + Index], mGuidList[Index].GuidId);
3870 }
3871
3872 return EFI_SUCCESS;
3873 }
EFI Development Kit II mirror for PVE