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