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