]> git.proxmox.com Git - mirror_edk2.git/blame - ShellPkg/Library/UefiHandleParsingLib/UefiHandleParsingLib.c
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
UefiCpuPkg: Move AsmRelocateApLoopStart from Mpfuncs.nasm to AmdSev.nasm
[mirror_edk2.git] / ShellPkg / Library / UefiHandleParsingLib / UefiHandleParsingLib.c
CommitLineData
a405b86d 1/** @file\r
2 Provides interface to advanced shell functionality for parsing both handle and protocol database.\r
3\r
d4ec9a57 4 Copyright (c) 2010 - 2017, Intel Corporation. All rights reserved.<BR>\r
256aa6d0 5 (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>\r
b33cf5bf 6 (C) Copyright 2015-2021 Hewlett Packard Enterprise Development LP<BR>\r
56ba3746 7 SPDX-License-Identifier: BSD-2-Clause-Patent\r
a405b86d 8\r
9**/\r
10\r
11#include "UefiHandleParsingLib.h"\r
f4f3c6bf 12#include "IndustryStandard/Acpi10.h"\r
66e427fe 13#include "IndustryStandard/Pci.h"\r
f4ac4354
JW		 14#include <PiDxe.h>\r
15#include <Protocol/FirmwareVolume2.h>\r
a405b86d 16\r
47d20b54
MK		 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
f4ac4354
JW		 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
47d20b54 34CHAR16 *\r
f4ac4354 35FindLoadedImageFileName (\r
47d20b54 36 IN EFI_LOADED_IMAGE_PROTOCOL *LoadedImage\r
f4ac4354
JW		 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
47d20b54 50 NameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)LoadedImage->FilePath);\r
f4ac4354
JW		 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
47d20b54 59 Status = gBS->HandleProtocol (LoadedImage->DeviceHandle, &gEfiFirmwareVolume2ProtocolGuid, (VOID **)&Fv);\r
f4ac4354
JW		 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
47d20b54 72 Status = Fv->ReadSection (Fv, NameGuid, EFI_SECTION_USER_INTERFACE, 0, &Buffer, &BufferSize, &AuthenticationStatus);\r
f4ac4354
JW		 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
efb76d1a
JC		 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
47d20b54 92CHAR16 *\r
efb76d1a 93ConvertMemoryType (\r
47d20b54 94 IN CONST EFI_MEMORY_TYPE Memory\r
efb76d1a
JC		 95 )\r
96{\r
47d20b54
MK		 97 CHAR16 *RetVal;\r
98\r
efb76d1a
JC		 99 RetVal = NULL;\r
100\r
101 switch (Memory) {\r
47d20b54
MK		 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
efb76d1a 133 }\r
47d20b54 134\r
efb76d1a
JC		 135 return (RetVal);\r
136}\r
137\r
609e0c58
JC		 138/**\r
139 Function to translate the EFI_GRAPHICS_PIXEL_FORMAT into a string.\r
140\r
9145d314 141 @param[in] Fmt The format type.\r
609e0c58
JC		 142\r
143 @retval A string representation of the type allocated from BS Pool.\r
144**/\r
47d20b54 145CHAR16 *\r
609e0c58 146ConvertPixelFormat (\r
47d20b54 147 IN CONST EFI_GRAPHICS_PIXEL_FORMAT Fmt\r
609e0c58
JC		 148 )\r
149{\r
47d20b54
MK		 150 CHAR16 *RetVal;\r
151\r
609e0c58
JC		 152 RetVal = NULL;\r
153\r
154 switch (Fmt) {\r
47d20b54
MK		 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
609e0c58 166 }\r
47d20b54 167\r
609e0c58
JC		 168 return (RetVal);\r
169}\r
170\r
a405b86d 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
d4ec9a57
RN		 186 mGuidListCount = 0;\r
187 mGuidList = NULL;\r
6306fd90 188\r
e7e0e42b
CP		 189 //\r
190 // Do nothing with mHandleParsingHiiHandle. Initialize HII as needed.\r
191 //\r
192 return (EFI_SUCCESS);\r
193}\r
194\r
1a6f74d9 195/**\r
e7e0e42b 196 Initialization function for HII packages.\r
1a6f74d9 197\r
e7e0e42b
CP		 198**/\r
199VOID\r
47d20b54
MK		 200HandleParsingHiiInit (\r
201 VOID\r
202 )\r
e7e0e42b 203{\r
a405b86d 204 if (mHandleParsingHiiHandle == NULL) {\r
e7e0e42b
CP		 205 mHandleParsingHiiHandle = HiiAddPackages (&gHandleParsingHiiGuid, gImageHandle, UefiHandleParsingLibStrings, NULL);\r
206 ASSERT (mHandleParsingHiiHandle != NULL);\r
a405b86d 207 }\r
a405b86d 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
47d20b54 225 UINTN LoopCount;\r
6306fd90 226\r
d4ec9a57 227 for (LoopCount = 0; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++) {\r
47d20b54 228 SHELL_FREE_NON_NULL (mGuidList[LoopCount].GuidId);\r
6306fd90
JC		 229 }\r
230\r
47d20b54 231 SHELL_FREE_NON_NULL (mGuidList);\r
a405b86d 232 if (mHandleParsingHiiHandle != NULL) {\r
47d20b54 233 HiiRemovePackages (mHandleParsingHiiHandle);\r
a405b86d 234 }\r
47d20b54 235\r
a405b86d 236 return (EFI_SUCCESS);\r
237}\r
238\r
efb76d1a
JC		 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
47d20b54 249CHAR16 *\r
a405b86d 250EFIAPI\r
47d20b54
MK		 251LoadedImageProtocolDumpInformation (\r
252 IN CONST EFI_HANDLE TheHandle,\r
253 IN CONST BOOLEAN Verbose\r
a405b86d 254 )\r
255{\r
47d20b54
MK		 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
a405b86d 265\r
efb76d1a 266 Status = gBS->OpenProtocol (\r
47d20b54
MK		 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
efb76d1a 274\r
5f119dfc 275 if (EFI_ERROR (Status)) {\r
bbb212af
JW		 276 return NULL;\r
277 }\r
278\r
47d20b54
MK		 279 FileName = FindLoadedImageFileName (LoadedImage);\r
280 FilePath = ConvertDevicePathToText (LoadedImage->FilePath, TRUE, TRUE);\r
4f67a614
HL		 281 if (!Verbose) {\r
282 if (FileName == NULL) {\r
283 FileName = FilePath;\r
284 } else {\r
47d20b54 285 SHELL_FREE_NON_NULL (FilePath);\r
4f67a614 286 }\r
47d20b54 287\r
6161123b 288 return FileName;\r
4f67a614 289 }\r
f4ac4354 290\r
47d20b54 291 HandleParsingHiiInit ();\r
f4ac4354
JW		 292 RetVal = NULL;\r
293 if (FileName != NULL) {\r
47d20b54 294 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_LI_DUMP_NAME), NULL);\r
f4ac4354
JW		 295\r
296 if (Temp != NULL) {\r
47d20b54 297 RetVal = CatSPrint (NULL, Temp, FileName);\r
f4ac4354
JW		 298 }\r
299\r
47d20b54
MK		 300 SHELL_FREE_NON_NULL (Temp);\r
301 SHELL_FREE_NON_NULL (FileName);\r
f4ac4354
JW		 302 }\r
303\r
47d20b54 304 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_LI_DUMP_MAIN), NULL);\r
bbb212af 305 if (Temp == NULL) {\r
5f119dfc
HL		 306 return NULL;\r
307 }\r
47d20b54 308\r
4f67a614 309 PdbFileName = PeCoffLoaderGetPdbPointer (LoadedImage->ImageBase);\r
47d20b54
MK		 310 DataType = ConvertMemoryType (LoadedImage->ImageDataType);\r
311 CodeType = ConvertMemoryType (LoadedImage->ImageCodeType);\r
efb76d1a 312\r
47d20b54 313 RetVal = CatSPrint (\r
f4ac4354 314 RetVal,\r
1a6f74d9
CS		 315 Temp,\r
316 LoadedImage->Revision,\r
317 LoadedImage->ParentHandle,\r
318 LoadedImage->SystemTable,\r
319 LoadedImage->DeviceHandle,\r
c15323ae 320 FilePath,\r
4f67a614 321 PdbFileName,\r
1a6f74d9
CS		 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
47d20b54
MK		 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
efb76d1a
JC		 335\r
336 return RetVal;\r
a405b86d 337}\r
a405b86d 338\r
609e0c58
JC		 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
47d20b54 349CHAR16 *\r
609e0c58 350EFIAPI\r
47d20b54
MK		 351GraphicsOutputProtocolDumpInformation (\r
352 IN CONST EFI_HANDLE TheHandle,\r
353 IN CONST BOOLEAN Verbose\r
609e0c58
JC		 354 )\r
355{\r
e918029f
RN		 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
609e0c58
JC		 365\r
366 if (!Verbose) {\r
47d20b54 367 return (CatSPrint (NULL, L"GraphicsOutput"));\r
609e0c58
JC		 368 }\r
369\r
47d20b54 370 HandleParsingHiiInit ();\r
e7e0e42b 371\r
47d20b54 372 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GOP_DUMP_MAIN), NULL);\r
1a6f74d9 373 if (Temp == NULL) {\r
609e0c58
JC		 374 return NULL;\r
375 }\r
376\r
377 Status = gBS->OpenProtocol (\r
47d20b54
MK		 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
609e0c58
JC		 385\r
386 if (EFI_ERROR (Status)) {\r
387 SHELL_FREE_NON_NULL (Temp);\r
609e0c58
JC		 388 return NULL;\r
389 }\r
390\r
47d20b54 391 Fmt = ConvertPixelFormat (GraphicsOutput->Mode->Info->PixelFormat);\r
609e0c58 392\r
47d20b54 393 RetVal = CatSPrint (\r
1a6f74d9
CS		 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
47d20b54
MK		 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
1a6f74d9
CS		 409 );\r
410\r
e918029f
RN		 411 SHELL_FREE_NON_NULL (Temp);\r
412\r
6d3911d4
QS		 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
e918029f
RN		 418\r
419 TempRetVal = CatSPrint (RetVal, Temp);\r
6d3911d4
QS		 420 SHELL_FREE_NON_NULL (RetVal);\r
421 if (TempRetVal == NULL) {\r
422 goto EXIT;\r
423 }\r
47d20b54 424\r
e918029f
RN		 425 RetVal = TempRetVal;\r
426 SHELL_FREE_NON_NULL (Temp);\r
427\r
6d3911d4
QS		 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
e918029f
RN		 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
6d3911d4 458EXIT:\r
47d20b54
MK		 459 SHELL_FREE_NON_NULL (Temp);\r
460 SHELL_FREE_NON_NULL (Fmt);\r
609e0c58
JC		 461\r
462 return RetVal;\r
463}\r
464\r
f4f3c6bf 465/**\r
e918029f
RN		 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
47d20b54 475CHAR16 *\r
e918029f
RN		 476EFIAPI\r
477EdidDiscoveredProtocolDumpInformation (\r
47d20b54
MK		 478 IN CONST EFI_HANDLE TheHandle,\r
479 IN CONST BOOLEAN Verbose\r
e918029f
RN		 480 )\r
481{\r
47d20b54
MK		 482 EFI_EDID_DISCOVERED_PROTOCOL *EdidDiscovered;\r
483 EFI_STATUS Status;\r
484 CHAR16 *RetVal;\r
485 CHAR16 *Temp;\r
486 CHAR16 *TempRetVal;\r
e918029f
RN		 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
47d20b54 495 (VOID **)&EdidDiscovered,\r
e918029f
RN		 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
47d20b54 519\r
e918029f
RN		 520 TempRetVal = CatSPrint (RetVal, Temp);\r
521 SHELL_FREE_NON_NULL (RetVal);\r
522 RetVal = TempRetVal;\r
523\r
79777358 524 TempRetVal = CatSDumpHex (RetVal, 4, 0, EdidDiscovered->SizeOfEdid, EdidDiscovered->Edid);\r
47d20b54 525 RetVal = TempRetVal;\r
e918029f 526 }\r
47d20b54 527\r
e918029f
RN		 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
47d20b54 541CHAR16 *\r
e918029f
RN		 542EFIAPI\r
543EdidActiveProtocolDumpInformation (\r
47d20b54
MK		 544 IN CONST EFI_HANDLE TheHandle,\r
545 IN CONST BOOLEAN Verbose\r
e918029f
RN		 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
47d20b54 561 (VOID **)&EdidActive,\r
e918029f
RN		 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
47d20b54 585\r
e918029f
RN		 586 TempRetVal = CatSPrint (RetVal, Temp);\r
587 SHELL_FREE_NON_NULL (RetVal);\r
588 RetVal = TempRetVal;\r
589\r
79777358 590 TempRetVal = CatSDumpHex (RetVal, 4, 0, EdidActive->SizeOfEdid, EdidActive->Edid);\r
47d20b54 591 RetVal = TempRetVal;\r
e918029f 592 }\r
47d20b54 593\r
e918029f
RN		 594 return RetVal;\r
595}\r
596\r
597/**\r
f4f3c6bf 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
47d20b54 607CHAR16 *\r
f4f3c6bf 608EFIAPI\r
47d20b54
MK		 609PciRootBridgeIoDumpInformation (\r
610 IN CONST EFI_HANDLE TheHandle,\r
611 IN CONST BOOLEAN Verbose\r
f4f3c6bf 612 )\r
613{\r
47d20b54
MK		 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
f4f3c6bf 622\r
47d20b54 623 RetVal = NULL;\r
f4f3c6bf 624\r
625 if (!Verbose) {\r
47d20b54 626 return (CatSPrint (NULL, L"PciRootBridgeIo"));\r
f4f3c6bf 627 }\r
628\r
47d20b54 629 HandleParsingHiiInit ();\r
e7e0e42b 630\r
47d20b54
MK		 631 Status = gBS->HandleProtocol (\r
632 TheHandle,\r
633 &gEfiPciRootBridgeIoProtocolGuid,\r
634 (VOID **)&PciRootBridgeIo\r
635 );\r
f4f3c6bf 636\r
47d20b54 637 if (EFI_ERROR (Status)) {\r
f4f3c6bf 638 return NULL;\r
639 }\r
640\r
47d20b54 641 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PCIRB_DUMP_PH), NULL);\r
1d6ccad2
QS		 642 if (Temp == NULL) {\r
643 return NULL;\r
644 }\r
47d20b54
MK		 645\r
646 Temp2 = CatSPrint (NULL, Temp, PciRootBridgeIo->ParentHandle);\r
647 FreePool (Temp);\r
f4f3c6bf 648 RetVal = Temp2;\r
47d20b54 649 Temp2 = NULL;\r
1a6f74d9 650\r
47d20b54 651 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PCIRB_DUMP_SEG), NULL);\r
1d6ccad2 652 if (Temp == NULL) {\r
47d20b54 653 SHELL_FREE_NON_NULL (RetVal);\r
1d6ccad2
QS		 654 return NULL;\r
655 }\r
47d20b54
MK		 656\r
657 Temp2 = CatSPrint (RetVal, Temp, PciRootBridgeIo->SegmentNumber);\r
658 FreePool (Temp);\r
659 FreePool (RetVal);\r
f4f3c6bf 660 RetVal = Temp2;\r
47d20b54 661 Temp2 = NULL;\r
f4f3c6bf 662\r
663 Supports = 0;\r
664 Attributes = 0;\r
47d20b54
MK		 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
1d6ccad2 668 if (Temp == NULL) {\r
47d20b54 669 SHELL_FREE_NON_NULL (RetVal);\r
1d6ccad2 670 return NULL;\r
1a6f74d9 671 }\r
47d20b54
MK		 672\r
673 Temp2 = CatSPrint (RetVal, Temp, Attributes);\r
674 FreePool (Temp);\r
675 FreePool (RetVal);\r
f4f3c6bf 676 RetVal = Temp2;\r
47d20b54 677 Temp2 = NULL;\r
1a6f74d9 678\r
47d20b54 679 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PCIRB_DUMP_SUPPORTS), NULL);\r
1d6ccad2 680 if (Temp == NULL) {\r
47d20b54 681 SHELL_FREE_NON_NULL (RetVal);\r
1d6ccad2
QS		 682 return NULL;\r
683 }\r
47d20b54
MK		 684\r
685 Temp2 = CatSPrint (RetVal, Temp, Supports);\r
686 FreePool (Temp);\r
687 FreePool (RetVal);\r
f4f3c6bf 688 RetVal = Temp2;\r
47d20b54 689 Temp2 = NULL;\r
f4f3c6bf 690 }\r
691\r
47d20b54
MK		 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
1d6ccad2 696 if (Temp == NULL) {\r
47d20b54 697 SHELL_FREE_NON_NULL (RetVal);\r
1d6ccad2
QS		 698 return NULL;\r
699 }\r
47d20b54
MK		 700\r
701 Temp2 = CatSPrint (RetVal, Temp, Supports);\r
702 FreePool (Temp);\r
703 FreePool (RetVal);\r
f4f3c6bf 704 RetVal = Temp2;\r
47d20b54 705 Temp2 = NULL;\r
f4f3c6bf 706 while (Configuration->Desc == ACPI_ADDRESS_SPACE_DESCRIPTOR) {\r
707 Temp = NULL;\r
708 switch (Configuration->ResType) {\r
47d20b54
MK		 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
f4f3c6bf 718 }\r
47d20b54 719\r
f4f3c6bf 720 if (Temp != NULL) {\r
47d20b54
MK		 721 Temp2 = CatSPrint (RetVal, L"\r\n%s", Temp);\r
722 FreePool (Temp);\r
723 FreePool (RetVal);\r
f4f3c6bf 724 RetVal = Temp2;\r
47d20b54 725 Temp2 = NULL;\r
f4f3c6bf 726 }\r
727\r
47d20b54
MK		 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
f4f3c6bf 737 RetVal = Temp2;\r
47d20b54 738 Temp2 = NULL;\r
f4f3c6bf 739 Configuration++;\r
740 }\r
741 }\r
47d20b54 742\r
f4f3c6bf 743 return (RetVal);\r
744}\r
745\r
a405b86d 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
47d20b54 756CHAR16 *\r
a405b86d 757EFIAPI\r
47d20b54
MK		 758TxtOutProtocolDumpInformation (\r
759 IN CONST EFI_HANDLE TheHandle,\r
760 IN CONST BOOLEAN Verbose\r
a405b86d 761 )\r
762{\r
47d20b54
MK		 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
a405b86d 772\r
773 if (!Verbose) {\r
774 return (NULL);\r
775 }\r
776\r
47d20b54 777 HandleParsingHiiInit ();\r
e7e0e42b 778\r
47d20b54
MK		 779 RetVal = NULL;\r
780 Size = 0;\r
a405b86d 781\r
47d20b54
MK		 782 Status = gBS->HandleProtocol (\r
783 TheHandle,\r
784 &gEfiSimpleTextOutProtocolGuid,\r
785 (VOID **)&Dev\r
786 );\r
a405b86d 787\r
47d20b54 788 ASSERT_EFI_ERROR (Status);\r
a405b86d 789 ASSERT (Dev != NULL && Dev->Mode != NULL);\r
790\r
47d20b54
MK		 791 Size = (Dev->Mode->MaxMode + 1) * 80;\r
792 RetVal = AllocateZeroPool (Size);\r
a405b86d 793\r
47d20b54 794 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_TXT_OUT_DUMP_HEADER), NULL);\r
ecae5117 795 if (Temp != NULL) {\r
47d20b54
MK		 796 UnicodeSPrint (RetVal, Size, Temp, Dev, Dev->Mode->Attribute);\r
797 FreePool (Temp);\r
ecae5117 798 }\r
a405b86d 799\r
800 //\r
801 // Dump TextOut Info\r
802 //\r
47d20b54 803 Temp = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_TXT_OUT_DUMP_LINE), NULL);\r
a405b86d 804 for (Index = 0; Index < Dev->Mode->MaxMode; Index++) {\r
47d20b54
MK		 805 Status = Dev->QueryMode (Dev, Index, &Col, &Row);\r
806 NewSize = Size - StrSize (RetVal);\r
807 UnicodeSPrint (\r
808 RetVal + StrLen (RetVal),\r
a405b86d 809 NewSize,\r
47d20b54 810 Temp == NULL ? L"" : Temp,\r
a405b86d 811 Index == Dev->Mode->Mode ? L'*' : L' ',\r
812 Index,\r
47d20b54
MK		 813 !EFI_ERROR (Status) ? (INTN)Col : -1,\r
814 !EFI_ERROR (Status) ? (INTN)Row : -1\r
815 );\r
a405b86d 816 }\r
47d20b54
MK		 817\r
818 FreePool (Temp);\r
a405b86d 819 return (RetVal);\r
820}\r
821\r
47d20b54 822STATIC CONST UINTN VersionStringSize = 60;\r
a405b86d 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
47d20b54 834CHAR16 *\r
a405b86d 835EFIAPI\r
47d20b54
MK		 836DriverEfiVersionProtocolDumpInformation (\r
837 IN CONST EFI_HANDLE TheHandle,\r
838 IN CONST BOOLEAN Verbose\r
a405b86d 839 )\r
840{\r
47d20b54
MK		 841 EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *DriverEfiVersion;\r
842 EFI_STATUS Status;\r
843 CHAR16 *RetVal;\r
a405b86d 844\r
47d20b54
MK		 845 Status = gBS->HandleProtocol (\r
846 TheHandle,\r
847 &gEfiDriverSupportedEfiVersionProtocolGuid,\r
848 (VOID **)&DriverEfiVersion\r
849 );\r
a405b86d 850\r
47d20b54 851 ASSERT_EFI_ERROR (Status);\r
a405b86d 852\r
47d20b54 853 RetVal = AllocateZeroPool (VersionStringSize);\r
aa3276c1
RN		 854 if (RetVal != NULL) {\r
855 UnicodeSPrint (RetVal, VersionStringSize, L"0x%08x", DriverEfiVersion->FirmwareVersion);\r
856 }\r
47d20b54 857\r
a405b86d 858 return (RetVal);\r
859}\r
47d20b54 860\r
5e32460d
RN		 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
47d20b54
MK		 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
5e32460d
RN		 877 )\r
878{\r
47d20b54
MK		 879 CHAR16 *Temp;\r
880 CHAR16 *Temp2;\r
881 UINTN Size;\r
5e32460d
RN		 882\r
883 //\r
884 // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)\r
885 //\r
47d20b54
MK		 886 Temp = ConvertDevicePathToText (DevPath, TRUE, TRUE);\r
887 if (!Verbose && (Temp != NULL) && (StrLen (Temp) > Length)) {\r
5e32460d
RN		 888 Temp2 = NULL;\r
889 Size = 0;\r
47d20b54
MK		 890 Temp2 = StrnCatGrow (&Temp2, &Size, L"..", 0);\r
891 Temp2 = StrnCatGrow (&Temp2, &Size, Temp+(StrLen (Temp) - (Length - 2)), 0);\r
892 FreePool (Temp);\r
5e32460d
RN		 893 Temp = Temp2;\r
894 }\r
47d20b54 895\r
5e32460d
RN		 896 return (Temp);\r
897}\r
a405b86d 898\r
f6e0c4b4
HL		 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
47d20b54 910STATIC CHAR16 *\r
f6e0c4b4
HL		 911EFIAPI\r
912DevicePathProtocolDumpInformationEx (\r
47d20b54
MK		 913 IN CONST EFI_HANDLE TheHandle,\r
914 IN CONST BOOLEAN Verbose,\r
915 IN EFI_GUID *Protocol\r
916 )\r
f6e0c4b4 917{\r
47d20b54
MK		 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
f6e0c4b4
HL		 924 DevPathStr = NULL;\r
925 DevPathStrTemp = NULL;\r
47d20b54
MK		 926 Status = gBS->OpenProtocol (TheHandle, Protocol, (VOID **)&DevPath, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
927 if (!EFI_ERROR (Status)) {\r
f6e0c4b4
HL		 928 DevPathStr = ConvertDevicePathToShortText (DevPath, Verbose, 30);\r
929 if (Verbose) {\r
47d20b54 930 Size = StrSize (DevPathStr) + sizeof (CHAR16) * 2;\r
f6e0c4b4
HL		 931 DevPathStrTemp = AllocateZeroPool (Size);\r
932 if (DevPathStrTemp != NULL) {\r
47d20b54
MK		 933 StrnCatS (DevPathStrTemp, Size/sizeof (CHAR16), L" ", 2);\r
934 StrnCatS (DevPathStrTemp, Size/sizeof (CHAR16), DevPathStr, StrLen (DevPathStr));\r
f6e0c4b4 935 }\r
47d20b54 936\r
f6e0c4b4
HL		 937 FreePool (DevPathStr);\r
938 DevPathStr = DevPathStrTemp;\r
939 }\r
47d20b54
MK		 940\r
941 gBS->CloseProtocol (TheHandle, Protocol, gImageHandle, NULL);\r
f6e0c4b4 942 }\r
47d20b54 943\r
f6e0c4b4
HL		 944 return DevPathStr;\r
945}\r
946\r
a405b86d 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
5e32460d 955 @retval A pointer to a string containing the information.\r
a405b86d 956**/\r
47d20b54 957CHAR16 *\r
a405b86d 958EFIAPI\r
47d20b54
MK		 959DevicePathProtocolDumpInformation (\r
960 IN CONST EFI_HANDLE TheHandle,\r
961 IN CONST BOOLEAN Verbose\r
a405b86d 962 )\r
963{\r
f6e0c4b4 964 return DevicePathProtocolDumpInformationEx (TheHandle, Verbose, &gEfiDevicePathProtocolGuid);\r
5e32460d
RN		 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
47d20b54 977CHAR16 *\r
5e32460d 978EFIAPI\r
47d20b54
MK		 979LoadedImageDevicePathProtocolDumpInformation (\r
980 IN CONST EFI_HANDLE TheHandle,\r
981 IN CONST BOOLEAN Verbose\r
5e32460d
RN		 982 )\r
983{\r
f6e0c4b4 984 return DevicePathProtocolDumpInformationEx (TheHandle, Verbose, &gEfiLoadedImageDevicePathProtocolGuid);\r
a405b86d 985}\r
986\r
d772f5f3
HL		 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
47d20b54 997CHAR16 *\r
d772f5f3
HL		 998EFIAPI\r
999BusSpecificDriverOverrideProtocolDumpInformation (\r
47d20b54
MK		 1000 IN CONST EFI_HANDLE TheHandle,\r
1001 IN CONST BOOLEAN Verbose\r
d772f5f3
HL		 1002 )\r
1003{\r
47d20b54
MK		 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
d772f5f3
HL		 1012\r
1013 if (!Verbose) {\r
1014 return NULL;\r
1015 }\r
47d20b54 1016\r
d772f5f3
HL		 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
47d20b54 1026 (VOID **)&BusSpecificDriverOverride,\r
d772f5f3
HL		 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
47d20b54 1034\r
d772f5f3 1035 HandleParsingHiiInit ();\r
47d20b54 1036 GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_BSDO_DUMP_MAIN), NULL);\r
d772f5f3
HL		 1037 if (GetString == NULL) {\r
1038 return NULL;\r
1039 }\r
47d20b54 1040\r
d772f5f3
HL		 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
47d20b54 1050 (VOID **)&LoadedImage\r
d772f5f3 1051 );\r
47d20b54 1052 if (!EFI_ERROR (Status)) {\r
d772f5f3
HL		 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
24ac68ef
HL		 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
47d20b54 1079CHAR16 *\r
24ac68ef
HL		 1080EFIAPI\r
1081BlockIoProtocolDumpInformation (\r
47d20b54
MK		 1082 IN CONST EFI_HANDLE TheHandle,\r
1083 IN CONST BOOLEAN Verbose\r
24ac68ef
HL		 1084 )\r
1085{\r
47d20b54
MK		 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
24ac68ef
HL		 1091\r
1092 if (!Verbose) {\r
1093 return NULL;\r
1094 }\r
47d20b54
MK		 1095\r
1096 GetString = NULL;\r
1097 RetVal = NULL;\r
24ac68ef
HL		 1098\r
1099 Status = gBS->OpenProtocol (\r
47d20b54
MK		 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
24ac68ef
HL		 1107 if (EFI_ERROR (Status)) {\r
1108 return NULL;\r
1109 }\r
47d20b54 1110\r
24ac68ef
HL		 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
47d20b54 1127 GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_BLOCKIO_INFO), NULL);\r
24ac68ef
HL		 1128 if (GetString == NULL) {\r
1129 return NULL;\r
1130 }\r
47d20b54 1131\r
24ac68ef 1132 RetVal = CatSPrint (\r
47d20b54
MK		 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
24ac68ef
HL		 1145\r
1146 SHELL_FREE_NON_NULL (GetString);\r
1147 return RetVal;\r
1148}\r
1149\r
6fcf7288
HL		 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
47d20b54 1158CHAR16 *\r
6fcf7288
HL		 1159EFIAPI\r
1160DebugSupportProtocolDumpInformation (\r
47d20b54
MK		 1161 IN CONST EFI_HANDLE TheHandle,\r
1162 IN CONST BOOLEAN Verbose\r
6fcf7288
HL		 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
47d20b54 1173\r
6fcf7288 1174 GetString = NULL;\r
47d20b54
MK		 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
6fcf7288
HL		 1184 if (EFI_ERROR (Status)) {\r
1185 return NULL;\r
1186 }\r
47d20b54 1187\r
6fcf7288 1188 HandleParsingHiiInit ();\r
47d20b54 1189 GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_DEBUGSUPPORT_INFO), NULL);\r
6fcf7288
HL		 1190 if (GetString == NULL) {\r
1191 return NULL;\r
1192 }\r
47d20b54 1193\r
6fcf7288
HL		 1194 //\r
1195 // Dump Debug support info\r
1196 //\r
1197 switch (DebugSupport->Isa) {\r
47d20b54
MK		 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
6fcf7288
HL		 1212 }\r
1213\r
1214 SHELL_FREE_NON_NULL (GetString);\r
1215 return RetVal;\r
1216}\r
1217\r
66e427fe
HL		 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
47d20b54 1228CHAR16 *\r
66e427fe
HL		 1229EFIAPI\r
1230PciIoProtocolDumpInformation (\r
47d20b54
MK		 1231 IN CONST EFI_HANDLE TheHandle,\r
1232 IN CONST BOOLEAN Verbose\r
66e427fe
HL		 1233 )\r
1234{\r
47d20b54
MK		 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
66e427fe
HL		 1246\r
1247 if (!Verbose) {\r
1248 return (NULL);\r
1249 }\r
66e427fe 1250\r
47d20b54
MK		 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
66e427fe
HL		 1264 return NULL;\r
1265 }\r
47d20b54 1266\r
66e427fe
HL		 1267 PciIo->Pci.Read (PciIo, EfiPciIoWidthUint8, 0, sizeof (Pci), &Pci);\r
1268 PciIo->GetLocation (PciIo, &Segment, &Bus, &Device, &Function);\r
1269 HandleParsingHiiInit ();\r
47d20b54 1270 GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PCIIO_DUMP_MAIN), NULL);\r
66e427fe
HL		 1271 if (GetString == NULL) {\r
1272 return NULL;\r
1273 }\r
47d20b54 1274\r
66e427fe 1275 RetVal = CatSPrint (\r
47d20b54
MK		 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
66e427fe 1291 if ((Index % 0x10) == 0) {\r
47d20b54 1292 TempRetVal = CatSPrint (RetVal, L"\r\n %02x", *((UINT8 *)(&Pci) + Index));\r
66e427fe 1293 } else {\r
47d20b54 1294 TempRetVal = CatSPrint (RetVal, L"%02x", *((UINT8 *)(&Pci) + Index));\r
66e427fe 1295 }\r
47d20b54 1296\r
66e427fe 1297 FreePool (RetVal);\r
47d20b54 1298 RetVal = TempRetVal;\r
66e427fe
HL		 1299 TempRetVal = NULL;\r
1300 }\r
1301\r
47d20b54 1302 FreePool (GetString);\r
66e427fe
HL		 1303 return RetVal;\r
1304}\r
1305\r
719c2348
HL		 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
47d20b54 1316CHAR16 *\r
719c2348
HL		 1317EFIAPI\r
1318UsbIoProtocolDumpInformation (\r
47d20b54
MK		 1319 IN CONST EFI_HANDLE TheHandle,\r
1320 IN CONST BOOLEAN Verbose\r
719c2348
HL		 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
47d20b54
MK		 1332\r
1333 RetVal = NULL;\r
719c2348 1334 GetString = NULL;\r
47d20b54
MK		 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
719c2348 1343\r
47d20b54 1344 if (EFI_ERROR (Status)) {\r
719c2348
HL		 1345 return NULL;\r
1346 }\r
47d20b54 1347\r
719c2348
HL		 1348 UsbIo->UsbGetInterfaceDescriptor (UsbIo, &InterfaceDesc);\r
1349 HandleParsingHiiInit ();\r
47d20b54 1350 GetString = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_USBIO_DUMP_MAIN), NULL);\r
719c2348
HL		 1351 if (GetString == NULL) {\r
1352 return NULL;\r
1353 }\r
47d20b54 1354\r
719c2348 1355 RetVal = CatSPrint (\r
47d20b54
MK		 1356 NULL,\r
1357 GetString,\r
1358 InterfaceDesc.InterfaceNumber,\r
1359 InterfaceDesc.InterfaceClass,\r
1360 InterfaceDesc.InterfaceSubClass,\r
1361 InterfaceDesc.InterfaceProtocol\r
1362 );\r
719c2348
HL		 1363\r
1364 FreePool (GetString);\r
1365 return RetVal;\r
1366}\r
1367\r
59febea1
SEHM		 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
47d20b54 1376CHAR16 *\r
59febea1
SEHM		 1377EFIAPI\r
1378AdapterInformationDumpInformation (\r
47d20b54
MK		 1379 IN CONST EFI_HANDLE TheHandle,\r
1380 IN CONST BOOLEAN Verbose\r
59febea1
SEHM		 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
1a6f74d9 1391 CHAR16 *TempRetVal;\r
59febea1
SEHM		 1392 VOID *InformationBlock;\r
1393 UINTN InformationBlockSize;\r
1a6f74d9 1394\r
59febea1 1395 if (!Verbose) {\r
47d20b54 1396 return (CatSPrint (NULL, L"AdapterInfo"));\r
59febea1
SEHM		 1397 }\r
1398\r
47d20b54
MK		 1399 InfoTypesBuffer = NULL;\r
1400 InformationBlock = NULL;\r
59febea1
SEHM		 1401\r
1402 Status = gBS->OpenProtocol (\r
47d20b54 1403 (EFI_HANDLE)(TheHandle),\r
59febea1 1404 &gEfiAdapterInformationProtocolGuid,\r
47d20b54 1405 (VOID **)&EfiAdptrInfoProtocol,\r
59febea1
SEHM		 1406 NULL,\r
1407 NULL,\r
1408 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
1409 );\r
1410\r
1411 if (EFI_ERROR (Status)) {\r
59febea1
SEHM		 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
1a6f74d9 1420 &InfoTypesBuffer,\r
59febea1
SEHM		 1421 &InfoTypesBufferCount\r
1422 );\r
1a6f74d9 1423 RetVal = NULL;\r
59febea1 1424 if (EFI_ERROR (Status)) {\r
47d20b54 1425 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GET_SUPP_TYPES_FAILED), NULL);\r
1d6ccad2 1426 if (TempStr != NULL) {\r
1a6f74d9 1427 RetVal = CatSPrint (NULL, TempStr, Status);\r
1d6ccad2
QS		 1428 } else {\r
1429 goto ERROR_EXIT;\r
1a6f74d9 1430 }\r
59febea1 1431 } else {\r
47d20b54 1432 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_SUPP_TYPE_HEADER), NULL);\r
1d6ccad2
QS		 1433 if (TempStr == NULL) {\r
1434 goto ERROR_EXIT;\r
1435 }\r
47d20b54 1436\r
1a6f74d9 1437 RetVal = CatSPrint (NULL, TempStr);\r
59febea1
SEHM		 1438 SHELL_FREE_NON_NULL (TempStr);\r
1439\r
1440 for (GuidIndex = 0; GuidIndex < InfoTypesBufferCount; GuidIndex++) {\r
47d20b54 1441 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GUID_NUMBER), NULL);\r
1d6ccad2
QS		 1442 if (TempStr == NULL) {\r
1443 goto ERROR_EXIT;\r
1444 }\r
47d20b54 1445\r
5d54bbec 1446 TempRetVal = CatSPrint (RetVal, TempStr, (GuidIndex + 1), &InfoTypesBuffer[GuidIndex]);\r
1a6f74d9
CS		 1447 SHELL_FREE_NON_NULL (RetVal);\r
1448 RetVal = TempRetVal;\r
59febea1
SEHM		 1449 SHELL_FREE_NON_NULL (TempStr);\r
1450\r
47d20b54 1451 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GUID_STRING), NULL);\r
1d6ccad2
QS		 1452 if (TempStr == NULL) {\r
1453 goto ERROR_EXIT;\r
1454 }\r
59febea1
SEHM		 1455\r
1456 if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {\r
1a6f74d9
CS		 1457 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoMediaStateGuid");\r
1458 SHELL_FREE_NON_NULL (RetVal);\r
1459 RetVal = TempRetVal;\r
59febea1 1460 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {\r
1a6f74d9
CS		 1461 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoNetworkBootGuid");\r
1462 SHELL_FREE_NON_NULL (RetVal);\r
1463 RetVal = TempRetVal;\r
59febea1 1464 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid)) {\r
1a6f74d9
CS		 1465 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoSanMacAddressGuid");\r
1466 SHELL_FREE_NON_NULL (RetVal);\r
1467 RetVal = TempRetVal;\r
256aa6d0
SEHM		 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
59febea1 1472 } else {\r
59febea1 1473 GuidStr = GetStringNameFromGuid (&InfoTypesBuffer[GuidIndex], NULL);\r
0e88348e
RN		 1474 if (GuidStr == NULL) {\r
1475 TempRetVal = CatSPrint (RetVal, TempStr, L"UnknownInfoType");\r
1476 SHELL_FREE_NON_NULL (RetVal);\r
1477 RetVal = TempRetVal;\r
1a6f74d9 1478\r
0e88348e 1479 SHELL_FREE_NON_NULL (TempStr);\r
47d20b54 1480 SHELL_FREE_NON_NULL (GuidStr);\r
0e88348e
RN		 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
47d20b54 1489 SHELL_FREE_NON_NULL (GuidStr);\r
59febea1
SEHM		 1490 }\r
1491 }\r
1a6f74d9 1492\r
59febea1
SEHM		 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
47d20b54 1503 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_GETINFO_FAILED), NULL);\r
1d6ccad2
QS		 1504 if (TempStr == NULL) {\r
1505 goto ERROR_EXIT;\r
1506 }\r
47d20b54 1507\r
1a6f74d9
CS		 1508 TempRetVal = CatSPrint (RetVal, TempStr, Status);\r
1509 SHELL_FREE_NON_NULL (RetVal);\r
1510 RetVal = TempRetVal;\r
59febea1
SEHM		 1511 } else {\r
1512 if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {\r
47d20b54 1513 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_MEDIA_STATE), NULL);\r
1d6ccad2
QS		 1514 if (TempStr == NULL) {\r
1515 goto ERROR_EXIT;\r
1516 }\r
47d20b54 1517\r
1a6f74d9
CS		 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
59febea1 1526 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {\r
47d20b54 1527 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_NETWORK_BOOT_INFO), NULL);\r
1d6ccad2
QS		 1528 if (TempStr == NULL) {\r
1529 goto ERROR_EXIT;\r
1530 }\r
47d20b54 1531\r
1a6f74d9
CS		 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
47d20b54 1547 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_SAN_MAC_ADDRESS_INFO), NULL);\r
1d6ccad2
QS		 1548 if (TempStr == NULL) {\r
1549 goto ERROR_EXIT;\r
1550 }\r
47d20b54 1551\r
1a6f74d9
CS		 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
256aa6d0 1564 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoUndiIpv6SupportGuid) == TRUE) {\r
47d20b54 1565 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_UNDI_IPV6_INFO), NULL);\r
256aa6d0
SEHM		 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
e918029f 1574 );\r
256aa6d0
SEHM		 1575 SHELL_FREE_NON_NULL (RetVal);\r
1576 RetVal = TempRetVal;\r
59febea1 1577 } else {\r
47d20b54 1578 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_UNKNOWN_INFO_TYPE), NULL);\r
1d6ccad2
QS		 1579 if (TempStr == NULL) {\r
1580 goto ERROR_EXIT;\r
1581 }\r
47d20b54 1582\r
1a6f74d9
CS		 1583 TempRetVal = CatSPrint (RetVal, TempStr, &InfoTypesBuffer[GuidIndex]);\r
1584 SHELL_FREE_NON_NULL (RetVal);\r
1585 RetVal = TempRetVal;\r
59febea1
SEHM		 1586 }\r
1587 }\r
47d20b54 1588\r
59febea1
SEHM		 1589 SHELL_FREE_NON_NULL (TempStr);\r
1590 SHELL_FREE_NON_NULL (InformationBlock);\r
1591 }\r
1592 }\r
1593\r
1d6ccad2 1594 SHELL_FREE_NON_NULL (InfoTypesBuffer);\r
59febea1 1595 return RetVal;\r
1d6ccad2
QS		 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
59febea1 1602}\r
8985d612
TS		 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
47d20b54 1612CHAR16 *\r
8985d612
TS		 1613EFIAPI\r
1614FirmwareManagementDumpInformation (\r
47d20b54
MK		 1615 IN CONST EFI_HANDLE TheHandle,\r
1616 IN CONST BOOLEAN Verbose\r
8985d612
TS		 1617 )\r
1618{\r
47d20b54
MK		 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
8985d612
TS		 1640\r
1641 //\r
1642 // Initialize local variables\r
1643 //\r
47d20b54
MK		 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
8985d612
TS		 1657\r
1658 if (!Verbose) {\r
47d20b54 1659 return (CatSPrint (NULL, L"FirmwareManagement"));\r
8985d612
TS		 1660 }\r
1661\r
1662 Status = gBS->OpenProtocol (\r
47d20b54 1663 (EFI_HANDLE)(TheHandle),\r
8985d612 1664 &gEfiFirmwareManagementProtocolGuid,\r
47d20b54 1665 (VOID **)&EfiFwMgmtProtocol,\r
8985d612
TS		 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
8985d612
TS		 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
47d20b54 1723 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_IMAGE_INFO_SIZE), NULL);\r
8985d612
TS		 1724 if (TempStr == NULL) {\r
1725 goto ERROR_EXIT;\r
1726 }\r
47d20b54 1727\r
8985d612
TS		 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
47d20b54 1734 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_DESCRIPTOR_VERSION), NULL);\r
8985d612
TS		 1735 if (TempStr == NULL) {\r
1736 goto ERROR_EXIT;\r
1737 }\r
47d20b54 1738\r
8985d612
TS		 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
47d20b54 1747 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_DESCRIPTOR_COUNT), NULL);\r
8985d612
TS		 1748 if (TempStr == NULL) {\r
1749 goto ERROR_EXIT;\r
1750 }\r
47d20b54 1751\r
8985d612
TS		 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
8985d612
TS		 1757 //\r
1758 // Set DescriptorSize in return buffer\r
1759 //\r
47d20b54 1760 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_DESCRIPTOR_SIZE), NULL);\r
8985d612
TS		 1761 if (TempStr == NULL) {\r
1762 goto ERROR_EXIT;\r
1763 }\r
47d20b54 1764\r
8985d612
TS		 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
47d20b54 1773 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_PACKAGE_VERSION), NULL);\r
8985d612
TS		 1774 if (TempStr == NULL) {\r
1775 goto ERROR_EXIT;\r
1776 }\r
47d20b54 1777\r
8985d612
TS		 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
47d20b54 1786 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_PACKAGE_VERSION_NAME), NULL);\r
8985d612
TS		 1787 if (TempStr == NULL) {\r
1788 goto ERROR_EXIT;\r
1789 }\r
47d20b54 1790\r
8985d612
TS		 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
ac14846a 1826 if ((AttributeSetting & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE) != 0x0) {\r
8985d612
TS		 1827 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IMAGE_UPDATABLE");\r
1828 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1829 AttributeSettingStr = TempRetVal;\r
1830 }\r
47d20b54 1831\r
ac14846a 1832 if ((AttributeSetting & IMAGE_ATTRIBUTE_RESET_REQUIRED) != 0x0) {\r
8985d612
TS		 1833 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_RESET_REQUIRED");\r
1834 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1835 AttributeSettingStr = TempRetVal;\r
1836 }\r
47d20b54 1837\r
ac14846a 1838 if ((AttributeSetting & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED) != 0x0) {\r
8985d612
TS		 1839 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED");\r
1840 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1841 AttributeSettingStr = TempRetVal;\r
1842 }\r
47d20b54 1843\r
ac14846a 1844 if ((AttributeSetting & IMAGE_ATTRIBUTE_IN_USE) != 0x0) {\r
8985d612
TS		 1845 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IN_USE");\r
1846 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1847 AttributeSettingStr = TempRetVal;\r
1848 }\r
47d20b54 1849\r
ac14846a 1850 if ((AttributeSetting & IMAGE_ATTRIBUTE_UEFI_IMAGE) != 0x0) {\r
8985d612
TS		 1851 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_UEFI_IMAGE");\r
1852 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1853 AttributeSettingStr = TempRetVal;\r
1854 }\r
47d20b54 1855\r
8985d612
TS		 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
47d20b54 1866 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_IMAGE_DESCRIPTOR_INFO_V1), NULL);\r
8985d612
TS		 1867 if (TempStr == NULL) {\r
1868 goto ERROR_EXIT;\r
1869 }\r
47d20b54 1870\r
8985d612
TS		 1871 TempRetVal = CatSPrint (\r
1872 RetVal,\r
1873 TempStr,\r
1874 Index,\r
1875 ImageInfoV1[Index].ImageIndex,\r
e06a4c08 1876 &ImageInfoV1[Index].ImageTypeId,\r
8985d612
TS		 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
47d20b54 1894 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_IMAGE_DESCRIPTOR_INFO_V2), NULL);\r
8985d612
TS		 1895 if (TempStr == NULL) {\r
1896 goto ERROR_EXIT;\r
1897 }\r
47d20b54 1898\r
8985d612
TS		 1899 TempRetVal = CatSPrint (\r
1900 RetVal,\r
1901 TempStr,\r
1902 Index,\r
1903 ImageInfoV2[Index].ImageIndex,\r
e06a4c08 1904 &ImageInfoV2[Index].ImageTypeId,\r
8985d612
TS		 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
47d20b54 1923 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_IMAGE_DESCRIPTOR_INFO), NULL);\r
8985d612
TS		 1924 if (TempStr == NULL) {\r
1925 goto ERROR_EXIT;\r
1926 }\r
47d20b54 1927\r
8985d612
TS		 1928 TempRetVal = CatSPrint (\r
1929 RetVal,\r
1930 TempStr,\r
1931 Index,\r
1932 ImageInfo[Index].ImageIndex,\r
e06a4c08 1933 &ImageInfo[Index].ImageTypeId,\r
8985d612
TS		 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
47d20b54
MK		 1955 for (Index = 0; Index < DescriptorCount; Index++) {\r
1956 for (Index1 = Index+1; Index1 < DescriptorCount; Index1++) {\r
8985d612
TS		 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
ac14846a 1990 if (Found) {\r
47d20b54 1991 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_FMP_IMAGEID_NON_UNIQUE), NULL);\r
8985d612
TS		 1992 if (TempStr == NULL) {\r
1993 goto ERROR_EXIT;\r
1994 }\r
47d20b54 1995\r
8985d612
TS		 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
770f3f61
HW		 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
47d20b54 2027CHAR16 *\r
770f3f61
HW		 2028EFIAPI\r
2029PartitionInfoProtocolDumpInformation (\r
47d20b54
MK		 2030 IN CONST EFI_HANDLE TheHandle,\r
2031 IN CONST BOOLEAN Verbose\r
770f3f61
HW		 2032 )\r
2033{\r
47d20b54
MK		 2034 EFI_STATUS Status;\r
2035 EFI_PARTITION_INFO_PROTOCOL *PartitionInfo;\r
2036 CHAR16 *PartitionType;\r
2037 CHAR16 *EfiSystemPartition;\r
2038 CHAR16 *RetVal;\r
770f3f61
HW		 2039\r
2040 if (!Verbose) {\r
2041 return NULL;\r
2042 }\r
2043\r
2044 Status = gBS->OpenProtocol (\r
47d20b54
MK		 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
770f3f61
HW		 2052 if (EFI_ERROR (Status)) {\r
2053 return NULL;\r
2054 }\r
2055\r
2056 HandleParsingHiiInit ();\r
2057\r
2058 switch (PartitionInfo->Type) {\r
47d20b54
MK		 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
770f3f61 2071 }\r
47d20b54 2072\r
770f3f61
HW		 2073 if (PartitionType == NULL) {\r
2074 return NULL;\r
2075 }\r
2076\r
2077 if (PartitionInfo->System == 1) {\r
47d20b54 2078 EfiSystemPartition = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PARTINFO_DUMP_EFI_SYS_PART), NULL);\r
770f3f61 2079 } else {\r
47d20b54 2080 EfiSystemPartition = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN (STR_PARTINFO_DUMP_NOT_EFI_SYS_PART), NULL);\r
770f3f61 2081 }\r
47d20b54 2082\r
770f3f61
HW		 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
a405b86d 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
ce68d3bc 2105 0x58c518b1, 0x76f3, 0x11d4, { 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
a405b86d 2106 }\r
2107\r
2108#define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \\r
2109 { \\r
ce68d3bc 2110 0x96eb4ad6, 0xa32a, 0x11d4, { 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
a405b86d 2111 }\r
2112\r
2113#define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \\r
2114 { \\r
ce68d3bc 2115 0xc95a93d, 0xa006, 0x11d4, { 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
a405b86d 2116 }\r
47d20b54
MK		 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
a405b86d 2120\r
2c23ddaa 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
1a6f74d9 2127 }\r
2c23ddaa 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
47d20b54
MK		 2132STATIC CONST EFI_GUID EfiIsaIoProtocolGuid = LOCAL_EFI_ISA_IO_PROTOCOL_GUID;\r
2133STATIC CONST EFI_GUID EfiIsaAcpiProtocolGuid = LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID;\r
2c23ddaa 2134\r
47d20b54
MK		 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
a405b86d 2140};\r
2141\r
47d20b54
MK		 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
dee34318 2233\r
47d20b54
MK		 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
2c23ddaa 2247\r
47d20b54
MK		 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
dee34318 2253\r
47d20b54
MK		 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
dee34318 2259\r
47d20b54
MK		 2260 //\r
2261 // the ones under this are misc GUIDS.\r
2262 //\r
2263 { STRING_TOKEN (STR_EFI_GLOBAL_VARIABLE), &gEfiGlobalVariableGuid, NULL },\r
dee34318 2264\r
47d20b54
MK		 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
dee34318 2290\r
47d20b54
MK		 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
dee34318 2297\r
47d20b54
MK		 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
dee34318 2305\r
47d20b54
MK		 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
28cdb62b 2311\r
47d20b54
MK		 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
59edea51 2320\r
47d20b54
MK		 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
59edea51 2330\r
47d20b54
MK		 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
59edea51 2342\r
47d20b54
MK		 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
b33cf5bf 2348\r
47d20b54
MK		 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
6b640b4a 2354\r
47d20b54
MK		 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
c2788f1c 2454\r
47d20b54
MK		 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
59edea51 2479\r
47d20b54
MK		 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
0a1eb97d 2485\r
47d20b54
MK		 2486 //\r
2487 // UEFI Shell Spec 2.1\r
2488 //\r
2489 { STRING_TOKEN (STR_SHELL_DYNAMIC), &gEfiShellDynamicCommandProtocolGuid, NULL },\r
0a1eb97d 2490\r
47d20b54
MK		 2491 //\r
2492 // Misc\r
2493 //\r
2494 { STRING_TOKEN (STR_PCDINFOPROT), &gGetPcdInfoProtocolGuid, NULL },\r
c2788f1c 2495\r
47d20b54
MK		 2496 //\r
2497 // terminator\r
2498 //\r
2499 { 0, NULL, NULL },\r
a405b86d 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
dee34318 2511CONST GUID_INFO_BLOCK *\r
47d20b54
MK		 2512InternalShellGetNodeFromGuid (\r
2513 IN CONST EFI_GUID *Guid\r
a405b86d 2514 )\r
2515{\r
47d20b54
MK		 2516 CONST GUID_INFO_BLOCK *ListWalker;\r
2517 UINTN LoopCount;\r
a405b86d 2518\r
47d20b54 2519 ASSERT (Guid != NULL);\r
a405b86d 2520\r
d4ec9a57 2521 for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {\r
47d20b54 2522 if (CompareGuid (ListWalker->GuidId, Guid)) {\r
6306fd90
JC		 2523 return (ListWalker);\r
2524 }\r
2525 }\r
2526\r
47d20b54
MK		 2527 if (PcdGetBool (PcdShellIncludeNtGuids)) {\r
2528 for (ListWalker = mGuidStringListNT; ListWalker != NULL && ListWalker->GuidId != NULL; ListWalker++) {\r
2529 if (CompareGuid (ListWalker->GuidId, Guid)) {\r
a405b86d 2530 return (ListWalker);\r
2531 }\r
2532 }\r
2533 }\r
47d20b54
MK		 2534\r
2535 for (ListWalker = mGuidStringList; ListWalker != NULL && ListWalker->GuidId != NULL; ListWalker++) {\r
2536 if (CompareGuid (ListWalker->GuidId, Guid)) {\r
a405b86d 2537 return (ListWalker);\r
2538 }\r
2539 }\r
47d20b54 2540\r
6306fd90
JC		 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
f5ba4007
QS		 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
6306fd90
JC		 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
6306fd90 2556EFI_STATUS\r
47d20b54
MK		 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
6306fd90
JC		 2561 )\r
2562{\r
94d4efb5
ZG		 2563 ASSERT (Guid != NULL);\r
2564 ASSERT (NameID != 0);\r
6306fd90 2565\r
94d4efb5
ZG		 2566 mGuidList = ReallocatePool (\r
2567 mGuidListCount * sizeof (GUID_INFO_BLOCK),\r
2568 (mGuidListCount + 1) * sizeof (GUID_INFO_BLOCK),\r
2569 mGuidList\r
2570 );\r
d4ec9a57
RN		 2571 if (mGuidList == NULL) {\r
2572 mGuidListCount = 0;\r
6306fd90
JC		 2573 return (EFI_OUT_OF_RESOURCES);\r
2574 }\r
47d20b54 2575\r
d4ec9a57 2576 mGuidListCount++;\r
6306fd90 2577\r
94d4efb5 2578 mGuidList[mGuidListCount - 1].GuidId = AllocateCopyPool (sizeof (EFI_GUID), Guid);\r
d4ec9a57
RN		 2579 mGuidList[mGuidListCount - 1].StringId = NameID;\r
2580 mGuidList[mGuidListCount - 1].DumpInfo = DumpFunc;\r
6306fd90 2581\r
d4ec9a57 2582 if (mGuidList[mGuidListCount - 1].GuidId == NULL) {\r
6306fd90
JC		 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
47d20b54
MK		 2605AddNewGuidNameMapping (\r
2606 IN CONST EFI_GUID *Guid,\r
2607 IN CONST CHAR16 *TheName,\r
2608 IN CONST CHAR8 *Lang OPTIONAL\r
6306fd90
JC		 2609 )\r
2610{\r
47d20b54 2611 EFI_STRING_ID NameID;\r
6306fd90 2612\r
47d20b54 2613 HandleParsingHiiInit ();\r
e7e0e42b 2614\r
47d20b54 2615 if ((Guid == NULL) || (TheName == NULL)) {\r
6306fd90
JC		 2616 return (EFI_INVALID_PARAMETER);\r
2617 }\r
2618\r
47d20b54 2619 if ((InternalShellGetNodeFromGuid (Guid)) != NULL) {\r
6306fd90
JC		 2620 return (EFI_ACCESS_DENIED);\r
2621 }\r
2622\r
47d20b54 2623 NameID = HiiSetString (mHandleParsingHiiHandle, 0, (CHAR16 *)TheName, Lang);\r
6306fd90
JC		 2624 if (NameID == 0) {\r
2625 return (EFI_OUT_OF_RESOURCES);\r
2626 }\r
2627\r
47d20b54 2628 return (InsertNewGuidNameMapping (Guid, NameID, NULL));\r
a405b86d 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
47d20b54 2642CHAR16 *\r
a405b86d 2643EFIAPI\r
47d20b54
MK		 2644GetStringNameFromGuid (\r
2645 IN CONST EFI_GUID *Guid,\r
2646 IN CONST CHAR8 *Lang OPTIONAL\r
a405b86d 2647 )\r
2648{\r
47d20b54 2649 CONST GUID_INFO_BLOCK *Id;\r
a405b86d 2650\r
47d20b54 2651 HandleParsingHiiInit ();\r
e7e0e42b 2652\r
47d20b54 2653 Id = InternalShellGetNodeFromGuid (Guid);\r
0e88348e
RN		 2654 if (Id == NULL) {\r
2655 return NULL;\r
2656 }\r
47d20b54 2657\r
0e88348e 2658 return HiiGetString (mHandleParsingHiiHandle, Id->StringId, Lang);\r
a405b86d 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
47d20b54 2677CHAR16 *\r
a405b86d 2678EFIAPI\r
47d20b54
MK		 2679GetProtocolInformationDump (\r
2680 IN CONST EFI_HANDLE TheHandle,\r
2681 IN CONST EFI_GUID *Guid,\r
2682 IN CONST BOOLEAN Verbose\r
a405b86d 2683 )\r
2684{\r
47d20b54 2685 CONST GUID_INFO_BLOCK *Id;\r
a405b86d 2686\r
47d20b54
MK		 2687 ASSERT (TheHandle != NULL);\r
2688 ASSERT (Guid != NULL);\r
a405b86d 2689\r
47d20b54 2690 if ((TheHandle == NULL) || (Guid == NULL)) {\r
a405b86d 2691 return (NULL);\r
2692 }\r
2693\r
47d20b54
MK		 2694 Id = InternalShellGetNodeFromGuid (Guid);\r
2695 if ((Id != NULL) && (Id->DumpInfo != NULL)) {\r
2696 return (Id->DumpInfo (TheHandle, Verbose));\r
a405b86d 2697 }\r
47d20b54 2698\r
a405b86d 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
0a1eb97d
JC		 2705 do not modify the returned Guid.\r
2706\r
a405b86d 2707 @param[in] Name The pointer to the string name.\r
2708 @param[in] Lang The pointer to the language code.\r
0a1eb97d 2709 @param[out] Guid The pointer to the Guid.\r
a405b86d 2710\r
2711 @retval EFI_SUCCESS The operation was sucessful.\r
2712**/\r
2713EFI_STATUS\r
2714EFIAPI\r
47d20b54
MK		 2715GetGuidFromStringName (\r
2716 IN CONST CHAR16 *Name,\r
2717 IN CONST CHAR8 *Lang OPTIONAL,\r
2718 OUT EFI_GUID **Guid\r
a405b86d 2719 )\r
2720{\r
dee34318 2721 CONST GUID_INFO_BLOCK *ListWalker;\r
47d20b54 2722 CHAR16 *String;\r
6306fd90 2723 UINTN LoopCount;\r
a405b86d 2724\r
47d20b54 2725 HandleParsingHiiInit ();\r
e7e0e42b 2726\r
47d20b54 2727 ASSERT (Guid != NULL);\r
a405b86d 2728 if (Guid == NULL) {\r
2729 return (EFI_INVALID_PARAMETER);\r
2730 }\r
47d20b54 2731\r
a405b86d 2732 *Guid = NULL;\r
2733\r
47d20b54
MK		 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
a405b86d 2738 *Guid = ListWalker->GuidId;\r
2739 }\r
47d20b54
MK		 2740\r
2741 SHELL_FREE_NON_NULL (String);\r
a405b86d 2742 if (*Guid != NULL) {\r
2743 return (EFI_SUCCESS);\r
2744 }\r
2745 }\r
2746 }\r
47d20b54
MK		 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
a405b86d 2751 *Guid = ListWalker->GuidId;\r
2752 }\r
47d20b54
MK		 2753\r
2754 SHELL_FREE_NON_NULL (String);\r
a405b86d 2755 if (*Guid != NULL) {\r
2756 return (EFI_SUCCESS);\r
2757 }\r
2758 }\r
6306fd90 2759\r
d4ec9a57 2760 for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {\r
47d20b54
MK		 2761 String = HiiGetString (mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
2762 if ((Name != NULL) && (String != NULL) && (StringNoCaseCompare (&Name, &String) == 0)) {\r
6306fd90
JC		 2763 *Guid = ListWalker->GuidId;\r
2764 }\r
47d20b54
MK		 2765\r
2766 SHELL_FREE_NON_NULL (String);\r
6306fd90
JC		 2767 if (*Guid != NULL) {\r
2768 return (EFI_SUCCESS);\r
2769 }\r
2770 }\r
2771\r
a405b86d 2772 return (EFI_NOT_FOUND);\r
2773}\r
2774\r
36384ceb
ED		 2775/**\r
2776 Get best support language for this driver.\r
1a6f74d9
CS		 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
a71003f2 2780 support language list. The caller need to free the buffer of the best language.\r
36384ceb
ED		 2781\r
2782 @param[in] SupportedLanguages The support languages for this driver.\r
a71003f2 2783 @param[in] InputLanguage The user input language.\r
36384ceb
ED		 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
a71003f2 2789EFIAPI\r
36384ceb 2790GetBestLanguageForDriver (\r
a71003f2
ED		 2791 IN CONST CHAR8 *SupportedLanguages,\r
2792 IN CONST CHAR8 *InputLanguage,\r
36384ceb
ED		 2793 IN BOOLEAN Iso639Language\r
2794 )\r
2795{\r
47d20b54
MK		 2796 CHAR8 *LanguageVariable;\r
2797 CHAR8 *BestLanguage;\r
36384ceb 2798\r
47d20b54 2799 GetVariable2 (Iso639Language ? L"Lang" : L"PlatformLang", &gEfiGlobalVariableGuid, (VOID **)&LanguageVariable, NULL);\r
36384ceb 2800\r
47d20b54 2801 BestLanguage = GetBestLanguage (\r
36384ceb
ED		 2802 SupportedLanguages,\r
2803 Iso639Language,\r
a71003f2 2804 (InputLanguage != NULL) ? InputLanguage : "",\r
36384ceb 2805 (LanguageVariable != NULL) ? LanguageVariable : "",\r
a71003f2 2806 SupportedLanguages,\r
36384ceb
ED		 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
a405b86d 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
47d20b54 2827CONST CHAR16 *\r
a405b86d 2828EFIAPI\r
47d20b54
MK		 2829GetStringNameFromHandle (\r
2830 IN CONST EFI_HANDLE TheHandle,\r
2831 IN CONST CHAR8 *Language\r
a405b86d 2832 )\r
2833{\r
2834 EFI_COMPONENT_NAME2_PROTOCOL *CompNameStruct;\r
2835 EFI_STATUS Status;\r
2836 CHAR16 *RetVal;\r
36384ceb
ED		 2837 CHAR8 *BestLang;\r
2838\r
2839 BestLang = NULL;\r
a405b86d 2840\r
47d20b54
MK		 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
a71003f2 2850 BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);\r
47d20b54 2851 Status = CompNameStruct->GetDriverName (CompNameStruct, BestLang, &RetVal);\r
36384ceb
ED		 2852 if (BestLang != NULL) {\r
2853 FreePool (BestLang);\r
2854 BestLang = NULL;\r
2855 }\r
47d20b54
MK		 2856\r
2857 if (!EFI_ERROR (Status)) {\r
a405b86d 2858 return (RetVal);\r
2859 }\r
2860 }\r
47d20b54
MK		 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
a71003f2 2871 BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);\r
47d20b54 2872 Status = CompNameStruct->GetDriverName (CompNameStruct, BestLang, &RetVal);\r
36384ceb
ED		 2873 if (BestLang != NULL) {\r
2874 FreePool (BestLang);\r
2875 }\r
47d20b54
MK		 2876\r
2877 if (!EFI_ERROR (Status)) {\r
a405b86d 2878 return (RetVal);\r
2879 }\r
2880 }\r
47d20b54 2881\r
a405b86d 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
47d20b54 2892InternalShellInitHandleList (\r
a405b86d 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
47d20b54
MK		 2904\r
2905 InitializeListHead (&mHandleList.List.Link);\r
a405b86d 2906 mHandleList.NextIndex = 1;\r
47d20b54
MK		 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
a405b86d 2916 return (Status);\r
2917 }\r
47d20b54
MK		 2918\r
2919 for (mHandleList.NextIndex = 1; mHandleList.NextIndex <= HandleCount; mHandleList.NextIndex++) {\r
2920 ListWalker = AllocateZeroPool (sizeof (HANDLE_LIST));\r
aa3276c1
RN		 2921 if (ListWalker != NULL) {\r
2922 ListWalker->TheHandle = HandleBuffer[mHandleList.NextIndex - 1];\r
47d20b54 2923 ListWalker->TheIndex = mHandleList.NextIndex;\r
aa3276c1
RN		 2924 InsertTailList (&mHandleList.List.Link, &ListWalker->Link);\r
2925 }\r
a405b86d 2926 }\r
47d20b54
MK		 2927\r
2928 FreePool (HandleBuffer);\r
a405b86d 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
47d20b54
MK		 2945ConvertHandleToHandleIndex (\r
2946 IN CONST EFI_HANDLE TheHandle\r
a405b86d 2947 )\r
2948{\r
f330ff35 2949 EFI_STATUS Status;\r
2950 EFI_GUID **ProtocolBuffer;\r
2951 UINTN ProtocolCount;\r
2952 HANDLE_LIST *ListWalker;\r
2953\r
78ed876b 2954 if (TheHandle == NULL) {\r
2955 return 0;\r
2956 }\r
a405b86d 2957\r
47d20b54 2958 InternalShellInitHandleList ();\r
a405b86d 2959\r
47d20b54
MK		 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
a405b86d 2965 if (ListWalker->TheHandle == TheHandle) {\r
f330ff35 2966 //\r
2967 // Verify that TheHandle is still present in the Handle Database\r
2968 //\r
47d20b54 2969 Status = gBS->ProtocolsPerHandle (TheHandle, &ProtocolBuffer, &ProtocolCount);\r
f330ff35 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
47d20b54 2977\r
f330ff35 2978 FreePool (ProtocolBuffer);\r
a405b86d 2979 return (ListWalker->TheIndex);\r
2980 }\r
2981 }\r
f330ff35 2982\r
2983 //\r
2984 // Verify that TheHandle is valid handle\r
2985 //\r
47d20b54 2986 Status = gBS->ProtocolsPerHandle (TheHandle, &ProtocolBuffer, &ProtocolCount);\r
f330ff35 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
47d20b54 2993\r
f330ff35 2994 FreePool (ProtocolBuffer);\r
2995\r
47d20b54 2996 ListWalker = AllocateZeroPool (sizeof (HANDLE_LIST));\r
aa3276c1
RN		 2997 if (ListWalker == NULL) {\r
2998 return 0;\r
2999 }\r
47d20b54 3000\r
a405b86d 3001 ListWalker->TheHandle = TheHandle;\r
3002 ListWalker->TheIndex = mHandleList.NextIndex++;\r
47d20b54 3003 InsertTailList (&mHandleList.List.Link, &ListWalker->Link);\r
a405b86d 3004 return (ListWalker->TheIndex);\r
3005}\r
3006\r
a405b86d 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
47d20b54
MK		 3018ConvertHandleIndexToHandle (\r
3019 IN CONST UINTN TheIndex\r
a405b86d 3020 )\r
3021{\r
f330ff35 3022 EFI_STATUS Status;\r
3023 EFI_GUID **ProtocolBuffer;\r
3024 UINTN ProtocolCount;\r
47d20b54 3025 HANDLE_LIST *ListWalker;\r
a405b86d 3026\r
47d20b54 3027 InternalShellInitHandleList ();\r
a405b86d 3028\r
3029 if (TheIndex >= mHandleList.NextIndex) {\r
f330ff35 3030 return NULL;\r
a405b86d 3031 }\r
3032\r
47d20b54
MK		 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
f330ff35 3039 //\r
3040 // Verify that LinkWalker->TheHandle is valid handle\r
3041 //\r
47d20b54 3042 Status = gBS->ProtocolsPerHandle (ListWalker->TheHandle, &ProtocolBuffer, &ProtocolCount);\r
00324f3f
RN		 3043 if (!EFI_ERROR (Status)) {\r
3044 FreePool (ProtocolBuffer);\r
3045 } else {\r
f330ff35 3046 //\r
3047 // TheHandle is not valid, so do not add to handle list\r
3048 //\r
3049 ListWalker->TheHandle = NULL;\r
3050 }\r
47d20b54 3051\r
a405b86d 3052 return (ListWalker->TheHandle);\r
3053 }\r
3054 }\r
47d20b54 3055\r
f330ff35 3056 return NULL;\r
a405b86d 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
47d20b54
MK		 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
a405b86d 3093 )\r
3094{\r
47d20b54
MK		 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
a405b86d 3114\r
3115 //\r
3116 // Retrieve the list of all handles from the handle database\r
3117 //\r
3118 Status = gBS->LocateHandleBuffer (\r
47d20b54
MK		 3119 AllHandles,\r
3120 NULL,\r
3121 NULL,\r
3122 HandleCount,\r
3123 HandleBuffer\r
3124 );\r
a405b86d 3125 if (EFI_ERROR (Status)) {\r
3126 return (Status);\r
3127 }\r
3128\r
3129 *HandleType = AllocateZeroPool (*HandleCount * sizeof (UINTN));\r
aa3276c1
RN		 3130 if (*HandleType == NULL) {\r
3131 SHELL_FREE_NON_NULL (*HandleBuffer);\r
94fcb76b 3132 *HandleCount = 0;\r
aa3276c1
RN		 3133 return EFI_OUT_OF_RESOURCES;\r
3134 }\r
a405b86d 3135\r
f330ff35 3136 DriverBindingHandleIndex = -1;\r
3137 for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {\r
47d20b54 3138 if ((DriverBindingHandle != NULL) && ((*HandleBuffer)[HandleIndex] == DriverBindingHandle)) {\r
f330ff35 3139 DriverBindingHandleIndex = (INTN)HandleIndex;\r
3140 }\r
3141 }\r
3142\r
a405b86d 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
47d20b54
MK		 3148 (*HandleBuffer)[HandleIndex],\r
3149 &ProtocolGuidArray,\r
3150 &ArrayCount\r
3151 );\r
f330ff35 3152 if (EFI_ERROR (Status)) {\r
3153 continue;\r
3154 }\r
a405b86d 3155\r
f330ff35 3156 for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {\r
f330ff35 3157 //\r
3158 // Set the bit describing what this handle has\r
3159 //\r
47d20b54 3160 if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiLoadedImageProtocolGuid)) {\r
7aae3c35 3161 (*HandleType)[HandleIndex] |= (UINTN)HR_IMAGE_HANDLE;\r
47d20b54 3162 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverBindingProtocolGuid)) {\r
7aae3c35 3163 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_BINDING_HANDLE;\r
f330ff35 3164 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfiguration2ProtocolGuid)) {\r
7aae3c35 3165 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;\r
47d20b54 3166 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfigurationProtocolGuid)) {\r
7aae3c35 3167 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;\r
47d20b54 3168 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnostics2ProtocolGuid)) {\r
7aae3c35 3169 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;\r
47d20b54 3170 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnosticsProtocolGuid)) {\r
7aae3c35 3171 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;\r
47d20b54 3172 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentName2ProtocolGuid)) {\r
7aae3c35 3173 (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;\r
47d20b54 3174 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentNameProtocolGuid)) {\r
7aae3c35 3175 (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;\r
47d20b54 3176 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid)) {\r
7aae3c35 3177 (*HandleType)[HandleIndex] |= (UINTN)HR_DEVICE_HANDLE;\r
f330ff35 3178 }\r
47d20b54 3179\r
f330ff35 3180 //\r
3181 // Retrieve the list of agents that have opened each protocol\r
3182 //\r
3183 Status = gBS->OpenProtocolInformation (\r
a405b86d 3184 (*HandleBuffer)[HandleIndex],\r
3185 ProtocolGuidArray[ProtocolIndex],\r
3186 &OpenInfo,\r
3187 &OpenInfoCount\r
47d20b54 3188 );\r
f330ff35 3189 if (EFI_ERROR (Status)) {\r
3190 continue;\r
3191 }\r
3192\r
3193 if (ControllerHandle == NULL) {\r
3194 //\r
1a6f74d9 3195 // ControllerHandle == NULL and DriverBindingHandle != NULL.\r
f330ff35 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
47d20b54 3199 if ((OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) && ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0)) {\r
7aae3c35 3200 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
f330ff35 3201 if (DriverBindingHandleIndex != -1) {\r
7aae3c35 3202 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
f330ff35 3203 }\r
3204 }\r
47d20b54
MK		 3205\r
3206 if ((OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) && ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0)) {\r
7aae3c35 3207 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
f330ff35 3208 if (DriverBindingHandleIndex != -1) {\r
7aae3c35 3209 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
f330ff35 3210 }\r
47d20b54 3211\r
f330ff35 3212 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
3213 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 3214 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
f330ff35 3215 }\r
3216 }\r
3217 }\r
3218 }\r
3219 }\r
47d20b54
MK		 3220\r
3221 if ((DriverBindingHandle == NULL) && (ControllerHandle != NULL)) {\r
f330ff35 3222 if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {\r
7aae3c35 3223 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
a405b86d 3224 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
f330ff35 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
7aae3c35 3228 (*HandleType)[ChildIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
f330ff35 3229 }\r
a405b86d 3230 }\r
f330ff35 3231 }\r
47d20b54 3232\r
f330ff35 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
7aae3c35 3236 (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
f330ff35 3237 }\r
47d20b54 3238\r
f330ff35 3239 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 3240 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
a405b86d 3241 }\r
3242 }\r
3243 }\r
f330ff35 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
7aae3c35 3249 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
f330ff35 3250 }\r
3251 }\r
3252 }\r
3253 }\r
3254 }\r
47d20b54
MK		 3255\r
3256 if ((DriverBindingHandle != NULL) && (ControllerHandle != NULL)) {\r
f330ff35 3257 if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {\r
7aae3c35 3258 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
f330ff35 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
7aae3c35 3263 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
a405b86d 3264 }\r
3265 }\r
f330ff35 3266 }\r
47d20b54 3267\r
f330ff35 3268 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
3269 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {\r
a405b86d 3270 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
f330ff35 3271 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 3272 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
a405b86d 3273 }\r
3274 }\r
3275 }\r
f330ff35 3276\r
3277 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
3278 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 3279 (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
f330ff35 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
7aae3c35 3288 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
f330ff35 3289 }\r
a405b86d 3290 }\r
3291 }\r
a405b86d 3292 }\r
3293 }\r
47d20b54 3294\r
f330ff35 3295 FreePool (OpenInfo);\r
a405b86d 3296 }\r
47d20b54 3297\r
f330ff35 3298 FreePool (ProtocolGuidArray);\r
a405b86d 3299 }\r
47d20b54 3300\r
f330ff35 3301 return EFI_SUCCESS;\r
a405b86d 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
47d20b54
MK		 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
a405b86d 3340 )\r
3341{\r
47d20b54
MK		 3342 EFI_STATUS Status;\r
3343 UINTN HandleCount;\r
3344 EFI_HANDLE *HandleBuffer;\r
3345 UINTN *HandleType;\r
3346 UINTN HandleIndex;\r
a405b86d 3347\r
47d20b54
MK		 3348 ASSERT (MatchingHandleCount != NULL);\r
3349 ASSERT (DriverBindingHandle != NULL || ControllerHandle != NULL);\r
a405b86d 3350\r
3351 if ((Mask & HR_VALID_MASK) != Mask) {\r
3352 return (EFI_INVALID_PARAMETER);\r
3353 }\r
3354\r
47d20b54 3355 if (((Mask & HR_CHILD_HANDLE) != 0) && (DriverBindingHandle == NULL)) {\r
a405b86d 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
47d20b54
MK		 3364 HandleBuffer = NULL;\r
3365 HandleType = NULL;\r
a405b86d 3366\r
3367 Status = ParseHandleDatabaseByRelationshipWithType (\r
47d20b54
MK		 3368 DriverBindingHandle,\r
3369 ControllerHandle,\r
3370 &HandleCount,\r
3371 &HandleBuffer,\r
3372 &HandleType\r
3373 );\r
a405b86d 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
47d20b54 3383\r
a405b86d 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
a405b86d 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
78ed876b 3399 *MatchingHandleBuffer = AllocateZeroPool ((*MatchingHandleCount +1)* sizeof (EFI_HANDLE));\r
94fcb76b
RN		 3400 if (*MatchingHandleBuffer == NULL) {\r
3401 Status = EFI_OUT_OF_RESOURCES;\r
3402 } else {\r
aa3276c1 3403 for (HandleIndex = 0, *MatchingHandleCount = 0\r
47d20b54
MK		 3404 ; HandleIndex < HandleCount\r
3405 ; HandleIndex++\r
3406 )\r
3407 {\r
aa3276c1
RN		 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
a405b86d 3415\r
a405b86d 3416 //\r
aa3276c1 3417 // Make the last one NULL\r
a405b86d 3418 //\r
aa3276c1 3419 (*MatchingHandleBuffer)[*MatchingHandleCount] = NULL;\r
a405b86d 3420\r
aa3276c1 3421 Status = EFI_SUCCESS;\r
94fcb76b 3422 } // *MatchingHandleBuffer == NULL (ELSE)\r
a405b86d 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
47d20b54
MK		 3435 ASSERT (\r
3436 (MatchingHandleBuffer == NULL) ||\r
3437 (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||\r
3438 (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL)\r
3439 );\r
a405b86d 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
b6c54204 3447 @param[out] MatchingHandleCount Pointer to the number of handles in\r
a405b86d 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
47d20b54
MK		 3457ParseHandleDatabaseForChildControllers (\r
3458 IN CONST EFI_HANDLE ControllerHandle,\r
3459 OUT UINTN *MatchingHandleCount,\r
3460 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
a405b86d 3461 )\r
3462{\r
3463 EFI_STATUS Status;\r
f330ff35 3464 UINTN HandleIndex;\r
a405b86d 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
a405b86d 3471 EFI_HANDLE *HandleBufferForReturn;\r
3472\r
ff51746b 3473 if (MatchingHandleCount == NULL) {\r
3474 return (EFI_INVALID_PARAMETER);\r
3475 }\r
47d20b54 3476\r
64d753f1 3477 *MatchingHandleCount = 0;\r
a405b86d 3478\r
3479 Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (\r
47d20b54
MK		 3480 ControllerHandle,\r
3481 &DriverBindingHandleCount,\r
3482 &DriverBindingHandleBuffer\r
3483 );\r
a405b86d 3484 if (EFI_ERROR (Status)) {\r
3485 return Status;\r
3486 }\r
3487\r
ff51746b 3488 //\r
3489 // Get a buffer big enough for all the controllers.\r
3490 //\r
47d20b54 3491 HandleBufferForReturn = GetHandleListByProtocol (NULL);\r
a405b86d 3492 if (HandleBufferForReturn == NULL) {\r
3493 FreePool (DriverBindingHandleBuffer);\r
ff51746b 3494 return (EFI_NOT_FOUND);\r
a405b86d 3495 }\r
3496\r
a405b86d 3497 for (DriverBindingHandleIndex = 0; DriverBindingHandleIndex < DriverBindingHandleCount; DriverBindingHandleIndex++) {\r
3498 Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (\r
47d20b54
MK		 3499 DriverBindingHandleBuffer[DriverBindingHandleIndex],\r
3500 ControllerHandle,\r
3501 &ChildControllerHandleCount,\r
3502 &ChildControllerHandleBuffer\r
3503 );\r
a405b86d 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
47d20b54
MK		 3511 )\r
3512 {\r
f330ff35 3513 for (HandleIndex = 0; HandleIndex < *MatchingHandleCount; HandleIndex++) {\r
3514 if (HandleBufferForReturn[HandleIndex] == ChildControllerHandleBuffer[ChildControllerHandleIndex]) {\r
3515 break;\r
3516 }\r
3517 }\r
47d20b54 3518\r
f330ff35 3519 if (HandleIndex >= *MatchingHandleCount) {\r
3520 HandleBufferForReturn[(*MatchingHandleCount)++] = ChildControllerHandleBuffer[ChildControllerHandleIndex];\r
3521 }\r
a405b86d 3522 }\r
3523\r
3524 FreePool (ChildControllerHandleBuffer);\r
3525 }\r
3526\r
3527 FreePool (DriverBindingHandleBuffer);\r
3528\r
47d20b54 3529 if ((MatchingHandleBuffer == NULL) || (*MatchingHandleCount == 0)) {\r
7eb3bb6c
LE		 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
a405b86d 3537 if (MatchingHandleBuffer != NULL) {\r
3538 *MatchingHandleBuffer = HandleBufferForReturn;\r
a405b86d 3539 }\r
7eb3bb6c 3540\r
47d20b54
MK		 3541 ASSERT (\r
3542 (MatchingHandleBuffer == NULL) ||\r
3543 (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||\r
3544 (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL)\r
3545 );\r
a405b86d 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
4ff7e37b
ED		 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
a405b86d 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
47d20b54 3565VOID *\r
a405b86d 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
47d20b54
MK		 3573 UINTN LocalDestinationSize;\r
3574 UINTN LocalDestinationFinalSize;\r
a405b86d 3575\r
47d20b54 3576 ASSERT (DestinationBuffer != NULL);\r
a405b86d 3577\r
47d20b54 3578 if ((SourceSize == 0) || (SourceBuffer == NULL)) {\r
a405b86d 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
47d20b54 3596 *DestinationBuffer = AllocateZeroPool (LocalDestinationFinalSize);\r
a405b86d 3597 } else {\r
3598 // reallocate\r
47d20b54 3599 *DestinationBuffer = ReallocatePool (LocalDestinationSize, LocalDestinationFinalSize, *DestinationBuffer);\r
a405b86d 3600 }\r
3601\r
47d20b54 3602 ASSERT (*DestinationBuffer != NULL);\r
a405b86d 3603\r
3604 // copy\r
47d20b54 3605 return (CopyMem (((UINT8 *)(*DestinationBuffer)) + LocalDestinationSize, SourceBuffer, SourceSize));\r
a405b86d 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
47d20b54
MK		 3621ParseHandleDatabaseForChildDevices (\r
3622 IN CONST EFI_HANDLE DriverHandle,\r
3623 IN UINTN *MatchingHandleCount,\r
3624 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
a405b86d 3625 )\r
3626{\r
47d20b54
MK		 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
a405b86d 3634\r
47d20b54 3635 ASSERT (MatchingHandleCount != NULL);\r
a405b86d 3636\r
47d20b54
MK		 3637 HandleBufferSize = 0;\r
3638 Buffer = NULL;\r
3639 Buffer2 = NULL;\r
3640 *MatchingHandleCount = 0;\r
a405b86d 3641\r
3642 Status = PARSE_HANDLE_DATABASE_DEVICES (\r
47d20b54
MK		 3643 DriverHandle,\r
3644 &Count1,\r
3645 &Buffer\r
3646 );\r
a405b86d 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
47d20b54
MK		 3653 DriverHandle,\r
3654 Buffer[HandleIndex],\r
3655 &Count2,\r
3656 &Buffer2\r
3657 );\r
3658 if (EFI_ERROR (Status)) {\r
a405b86d 3659 break;\r
3660 }\r
47d20b54 3661\r
a405b86d 3662 //\r
3663 // save out required and optional data elements\r
3664 //\r
3665 *MatchingHandleCount += Count2;\r
3666 if (MatchingHandleBuffer != NULL) {\r
47d20b54 3667 *MatchingHandleBuffer = BuffernCatGrow ((VOID **)MatchingHandleBuffer, &HandleBufferSize, Buffer2, Count2 * sizeof (Buffer2[0]));\r
a405b86d 3668 }\r
3669\r
3670 //\r
3671 // free the memory\r
3672 //\r
3673 if (Buffer2 != NULL) {\r
47d20b54 3674 FreePool (Buffer2);\r
a405b86d 3675 }\r
3676 }\r
3677 }\r
3678\r
3679 if (Buffer != NULL) {\r
47d20b54 3680 FreePool (Buffer);\r
a405b86d 3681 }\r
47d20b54 3682\r
a405b86d 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
47d20b54 3695EFI_HANDLE *\r
a405b86d 3696EFIAPI\r
40d7a9cf 3697GetHandleListByProtocol (\r
47d20b54 3698 IN CONST EFI_GUID *ProtocolGuid OPTIONAL\r
a405b86d 3699 )\r
3700{\r
47d20b54
MK		 3701 EFI_HANDLE *HandleList;\r
3702 UINTN Size;\r
3703 EFI_STATUS Status;\r
a405b86d 3704\r
47d20b54 3705 Size = 0;\r
a405b86d 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
47d20b54 3712 Status = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, HandleList);\r
a405b86d 3713 if (Status == EFI_BUFFER_TOO_SMALL) {\r
47d20b54 3714 HandleList = AllocateZeroPool (Size + sizeof (EFI_HANDLE));\r
40d7a9cf 3715 if (HandleList == NULL) {\r
3716 return (NULL);\r
3717 }\r
47d20b54
MK		 3718\r
3719 Status = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, HandleList);\r
3720 HandleList[Size/sizeof (EFI_HANDLE)] = NULL;\r
a405b86d 3721 }\r
3722 } else {\r
47d20b54 3723 Status = gBS->LocateHandle (ByProtocol, (EFI_GUID *)ProtocolGuid, NULL, &Size, HandleList);\r
a405b86d 3724 if (Status == EFI_BUFFER_TOO_SMALL) {\r
47d20b54 3725 HandleList = AllocateZeroPool (Size + sizeof (EFI_HANDLE));\r
40d7a9cf 3726 if (HandleList == NULL) {\r
3727 return (NULL);\r
3728 }\r
47d20b54
MK		 3729\r
3730 Status = gBS->LocateHandle (ByProtocol, (EFI_GUID *)ProtocolGuid, NULL, &Size, HandleList);\r
3731 HandleList[Size/sizeof (EFI_HANDLE)] = NULL;\r
a405b86d 3732 }\r
3733 }\r
47d20b54
MK		 3734\r
3735 if (EFI_ERROR (Status)) {\r
a405b86d 3736 if (HandleList != NULL) {\r
47d20b54 3737 FreePool (HandleList);\r
a405b86d 3738 }\r
47d20b54 3739\r
a405b86d 3740 return (NULL);\r
3741 }\r
47d20b54 3742\r
a405b86d 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
ff51746b 3752 @retval NULL ProtocolGuids was NULL.\r
3753 @return A NULL terminated list of EFI_HANDLEs.\r
a405b86d 3754**/\r
47d20b54 3755EFI_HANDLE *\r
a405b86d 3756EFIAPI\r
40d7a9cf 3757GetHandleListByProtocolList (\r
47d20b54 3758 IN CONST EFI_GUID **ProtocolGuids\r
a405b86d 3759 )\r
3760{\r
47d20b54
MK		 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
a405b86d 3769\r
47d20b54
MK		 3770 Size = 0;\r
3771 HandleList = NULL;\r
3772 TotalSize = sizeof (EFI_HANDLE);\r
a405b86d 3773\r
47d20b54
MK		 3774 for (GuidWalker = ProtocolGuids; GuidWalker != NULL && *GuidWalker != NULL; GuidWalker++, Size = 0) {\r
3775 Status = gBS->LocateHandle (ByProtocol, (EFI_GUID *)(*GuidWalker), NULL, &Size, NULL);\r
a405b86d 3776 if (Status == EFI_BUFFER_TOO_SMALL) {\r
3777 TotalSize += Size;\r
3778 }\r
3779 }\r
40d7a9cf 3780\r
3781 //\r
e918029f 3782 // No handles were found...\r
40d7a9cf 3783 //\r
47d20b54 3784 if (TotalSize == sizeof (EFI_HANDLE)) {\r
40d7a9cf 3785 return (NULL);\r
3786 }\r
3787\r
47d20b54 3788 HandleList = AllocateZeroPool (TotalSize);\r
a405b86d 3789 if (HandleList == NULL) {\r
3790 return (NULL);\r
3791 }\r
3792\r
3793 Size = 0;\r
47d20b54 3794 for (GuidWalker = ProtocolGuids; GuidWalker != NULL && *GuidWalker != NULL; GuidWalker++) {\r
40d7a9cf 3795 TempSize = TotalSize - Size;\r
47d20b54 3796 Status = gBS->LocateHandle (ByProtocol, (EFI_GUID *)(*GuidWalker), NULL, &TempSize, HandleList+(Size/sizeof (EFI_HANDLE)));\r
40d7a9cf 3797\r
3798 //\r
3799 // Allow for missing protocols... Only update the 'used' size upon success.\r
3800 //\r
47d20b54 3801 if (!EFI_ERROR (Status)) {\r
ff51746b 3802 Size += TempSize;\r
40d7a9cf 3803 }\r
a405b86d 3804 }\r
a405b86d 3805\r
47d20b54
MK		 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
a405b86d 3810 if (*HandleWalker1 == *HandleWalker2) {\r
3811 //\r
3812 // copy memory back 1 handle width.\r
3813 //\r
47d20b54 3814 CopyMem (HandleWalker2, HandleWalker2 + 1, TotalSize - ((HandleWalker2-HandleList+1)*sizeof (EFI_HANDLE)));\r
a405b86d 3815 }\r
3816 }\r
3817 }\r
3818\r
3819 return (HandleList);\r
3820}\r
0976f908
CC		 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
47d20b54
MK		 3836 OUT EFI_GUID *Guids,\r
3837 IN OUT UINTN *Count\r
0976f908
CC		 3838 )\r
3839{\r
47d20b54
MK		 3840 UINTN GuidCount;\r
3841 UINTN NtGuidCount;\r
3842 UINTN Index;\r
0976f908
CC		 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
47d20b54
MK		 3852\r
3853 GuidCount = ARRAY_SIZE (mGuidStringList) - 1;\r
0976f908
CC		 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