]> 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/dh: Modify the dump of "ImageDevicePath" and "DevicePath"
[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
f6e0c4b4
HL		 850/**\r
851 Function to dump protocol information.\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 @param[in] Protocol The protocol is needed to dump.\r
858\r
859 @retval A pointer to a string containing the information.\r
860**/\r
861STATIC CHAR16*\r
862EFIAPI\r
863DevicePathProtocolDumpInformationEx (\r
864 IN CONST EFI_HANDLE TheHandle,\r
865 IN CONST BOOLEAN Verbose,\r
866 IN EFI_GUID *Protocol\r
867)\r
868{\r
869 EFI_DEVICE_PATH_PROTOCOL *DevPath;\r
870 CHAR16 *DevPathStr;\r
871 CHAR16 *DevPathStrTemp;\r
872 UINTN Size;\r
873 EFI_STATUS Status;\r
874 DevPathStr = NULL;\r
875 DevPathStrTemp = NULL;\r
876 Status = gBS->OpenProtocol(TheHandle, Protocol, (VOID**)&DevPath, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
877 if (!EFI_ERROR(Status)) {\r
878 DevPathStr = ConvertDevicePathToShortText (DevPath, Verbose, 30);\r
879 if (Verbose) {\r
880 Size = StrSize(DevPathStr) + sizeof(CHAR16) * 2;\r
881 DevPathStrTemp = AllocateZeroPool (Size);\r
882 if (DevPathStrTemp != NULL) {\r
883 StrnCatS (DevPathStrTemp, Size/sizeof(CHAR16), L" ", 2);\r
884 StrnCatS (DevPathStrTemp, Size/sizeof(CHAR16), DevPathStr, StrLen (DevPathStr));\r
885 }\r
886 FreePool (DevPathStr);\r
887 DevPathStr = DevPathStrTemp;\r
888 }\r
889 gBS->CloseProtocol(TheHandle, Protocol, gImageHandle, NULL);\r
890 }\r
891 return DevPathStr;\r
892}\r
893\r
a405b86d 894/**\r
895 Function to dump information about DevicePath protocol.\r
896\r
897 This will allocate the return buffer from boot services pool.\r
898\r
899 @param[in] TheHandle The handle that has the protocol installed.\r
900 @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
901\r
5e32460d 902 @retval A pointer to a string containing the information.\r
a405b86d 903**/\r
904CHAR16*\r
905EFIAPI\r
906DevicePathProtocolDumpInformation(\r
907 IN CONST EFI_HANDLE TheHandle,\r
908 IN CONST BOOLEAN Verbose\r
909 )\r
910{\r
f6e0c4b4 911 return DevicePathProtocolDumpInformationEx (TheHandle, Verbose, &gEfiDevicePathProtocolGuid);\r
5e32460d
RN		 912}\r
913\r
914/**\r
915 Function to dump information about LoadedImageDevicePath protocol.\r
916\r
917 This will allocate the return buffer from boot services pool.\r
918\r
919 @param[in] TheHandle The handle that has the protocol installed.\r
920 @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
921\r
922 @retval A pointer to a string containing the information.\r
923**/\r
924CHAR16*\r
925EFIAPI\r
926LoadedImageDevicePathProtocolDumpInformation(\r
927 IN CONST EFI_HANDLE TheHandle,\r
928 IN CONST BOOLEAN Verbose\r
929 )\r
930{\r
f6e0c4b4 931 return DevicePathProtocolDumpInformationEx (TheHandle, Verbose, &gEfiLoadedImageDevicePathProtocolGuid);\r
a405b86d 932}\r
933\r
59febea1
SEHM		 934/**\r
935 Function to dump information about EfiAdapterInformation Protocol.\r
936\r
937 @param[in] TheHandle The handle that has the protocol installed.\r
938 @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
939\r
940 @retval A pointer to a string containing the information.\r
941**/\r
942CHAR16*\r
943EFIAPI\r
944AdapterInformationDumpInformation (\r
945 IN CONST EFI_HANDLE TheHandle,\r
946 IN CONST BOOLEAN Verbose\r
947 )\r
948{\r
949 EFI_STATUS Status;\r
950 EFI_ADAPTER_INFORMATION_PROTOCOL *EfiAdptrInfoProtocol;\r
951 UINTN InfoTypesBufferCount;\r
952 UINTN GuidIndex;\r
953 EFI_GUID *InfoTypesBuffer;\r
954 CHAR16 *GuidStr;\r
955 CHAR16 *TempStr;\r
956 CHAR16 *RetVal;\r
1a6f74d9 957 CHAR16 *TempRetVal;\r
59febea1
SEHM		 958 VOID *InformationBlock;\r
959 UINTN InformationBlockSize;\r
1a6f74d9 960\r
59febea1
SEHM		 961 if (!Verbose) {\r
962 return (CatSPrint(NULL, L"AdapterInfo"));\r
963 }\r
964\r
1d6ccad2
QS		 965 InfoTypesBuffer = NULL;\r
966 InformationBlock = NULL;\r
1a6f74d9 967\r
59febea1
SEHM		 968\r
969 Status = gBS->OpenProtocol (\r
970 (EFI_HANDLE) (TheHandle),\r
971 &gEfiAdapterInformationProtocolGuid,\r
972 (VOID **) &EfiAdptrInfoProtocol,\r
973 NULL,\r
974 NULL,\r
975 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
976 );\r
977\r
978 if (EFI_ERROR (Status)) {\r
59febea1
SEHM		 979 return NULL;\r
980 }\r
981\r
982 //\r
983 // Get a list of supported information types for this instance of the protocol.\r
984 //\r
985 Status = EfiAdptrInfoProtocol->GetSupportedTypes (\r
986 EfiAdptrInfoProtocol,\r
1a6f74d9 987 &InfoTypesBuffer,\r
59febea1
SEHM		 988 &InfoTypesBufferCount\r
989 );\r
1a6f74d9 990 RetVal = NULL;\r
59febea1
SEHM		 991 if (EFI_ERROR (Status)) {\r
992 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GET_SUPP_TYPES_FAILED), NULL);\r
1d6ccad2 993 if (TempStr != NULL) {\r
1a6f74d9 994 RetVal = CatSPrint (NULL, TempStr, Status);\r
1d6ccad2
QS		 995 } else {\r
996 goto ERROR_EXIT;\r
1a6f74d9 997 }\r
59febea1
SEHM		 998 } else {\r
999 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_SUPP_TYPE_HEADER), NULL);\r
1d6ccad2
QS		 1000 if (TempStr == NULL) {\r
1001 goto ERROR_EXIT;\r
1002 }\r
1a6f74d9 1003 RetVal = CatSPrint (NULL, TempStr);\r
59febea1
SEHM		 1004 SHELL_FREE_NON_NULL (TempStr);\r
1005\r
1006 for (GuidIndex = 0; GuidIndex < InfoTypesBufferCount; GuidIndex++) {\r
1007 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GUID_NUMBER), NULL);\r
1d6ccad2
QS		 1008 if (TempStr == NULL) {\r
1009 goto ERROR_EXIT;\r
1010 }\r
5d54bbec 1011 TempRetVal = CatSPrint (RetVal, TempStr, (GuidIndex + 1), &InfoTypesBuffer[GuidIndex]);\r
1a6f74d9
CS		 1012 SHELL_FREE_NON_NULL (RetVal);\r
1013 RetVal = TempRetVal;\r
59febea1
SEHM		 1014 SHELL_FREE_NON_NULL (TempStr);\r
1015\r
1016 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GUID_STRING), NULL);\r
1d6ccad2
QS		 1017 if (TempStr == NULL) {\r
1018 goto ERROR_EXIT;\r
1019 }\r
59febea1
SEHM		 1020\r
1021 if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {\r
1a6f74d9
CS		 1022 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoMediaStateGuid");\r
1023 SHELL_FREE_NON_NULL (RetVal);\r
1024 RetVal = TempRetVal;\r
59febea1 1025 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {\r
1a6f74d9
CS		 1026 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoNetworkBootGuid");\r
1027 SHELL_FREE_NON_NULL (RetVal);\r
1028 RetVal = TempRetVal;\r
59febea1 1029 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid)) {\r
1a6f74d9
CS		 1030 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoSanMacAddressGuid");\r
1031 SHELL_FREE_NON_NULL (RetVal);\r
1032 RetVal = TempRetVal;\r
256aa6d0
SEHM		 1033 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoUndiIpv6SupportGuid)) {\r
1034 TempRetVal = CatSPrint (RetVal, TempStr, L"gEfiAdapterInfoUndiIpv6SupportGuid");\r
1035 SHELL_FREE_NON_NULL (RetVal);\r
1036 RetVal = TempRetVal;\r
59febea1
SEHM		 1037 } else {\r
1038\r
1039 GuidStr = GetStringNameFromGuid (&InfoTypesBuffer[GuidIndex], NULL);\r
0e88348e
RN		 1040 if (GuidStr == NULL) {\r
1041 TempRetVal = CatSPrint (RetVal, TempStr, L"UnknownInfoType");\r
1042 SHELL_FREE_NON_NULL (RetVal);\r
1043 RetVal = TempRetVal;\r
1a6f74d9 1044\r
0e88348e
RN		 1045 SHELL_FREE_NON_NULL (TempStr);\r
1046 SHELL_FREE_NON_NULL(GuidStr);\r
1047 //\r
1048 // So that we never have to pass this UnknownInfoType to the parsing function "GetInformation" service of AIP\r
1049 //\r
1050 continue;\r
1051 } else {\r
1052 TempRetVal = CatSPrint (RetVal, TempStr, GuidStr);\r
1053 SHELL_FREE_NON_NULL (RetVal);\r
1054 RetVal = TempRetVal;\r
1055 SHELL_FREE_NON_NULL(GuidStr);\r
59febea1
SEHM		 1056 }\r
1057 }\r
1a6f74d9 1058\r
59febea1
SEHM		 1059 SHELL_FREE_NON_NULL (TempStr);\r
1060\r
1061 Status = EfiAdptrInfoProtocol->GetInformation (\r
1062 EfiAdptrInfoProtocol,\r
1063 &InfoTypesBuffer[GuidIndex],\r
1064 &InformationBlock,\r
1065 &InformationBlockSize\r
1066 );\r
1067\r
1068 if (EFI_ERROR (Status)) {\r
1069 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_GETINFO_FAILED), NULL);\r
1d6ccad2
QS		 1070 if (TempStr == NULL) {\r
1071 goto ERROR_EXIT;\r
1072 }\r
1a6f74d9
CS		 1073 TempRetVal = CatSPrint (RetVal, TempStr, Status);\r
1074 SHELL_FREE_NON_NULL (RetVal);\r
1075 RetVal = TempRetVal;\r
59febea1
SEHM		 1076 } else {\r
1077 if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoMediaStateGuid)) {\r
1078 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_MEDIA_STATE), NULL);\r
1d6ccad2
QS		 1079 if (TempStr == NULL) {\r
1080 goto ERROR_EXIT;\r
1081 }\r
1a6f74d9
CS		 1082 TempRetVal = CatSPrint (\r
1083 RetVal,\r
1084 TempStr,\r
1085 ((EFI_ADAPTER_INFO_MEDIA_STATE *)InformationBlock)->MediaState,\r
1086 ((EFI_ADAPTER_INFO_MEDIA_STATE *)InformationBlock)->MediaState\r
1087 );\r
1088 SHELL_FREE_NON_NULL (RetVal);\r
1089 RetVal = TempRetVal;\r
59febea1
SEHM		 1090 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoNetworkBootGuid)) {\r
1091 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_NETWORK_BOOT_INFO), NULL);\r
1d6ccad2
QS		 1092 if (TempStr == NULL) {\r
1093 goto ERROR_EXIT;\r
1094 }\r
1a6f74d9
CS		 1095 TempRetVal = CatSPrint (\r
1096 RetVal,\r
1097 TempStr,\r
1098 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv4BootCapablity,\r
1099 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv6BootCapablity,\r
1100 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->FCoeBootCapablity,\r
1101 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->OffloadCapability,\r
1102 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiMpioCapability,\r
1103 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv4Boot,\r
1104 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->iScsiIpv6Boot,\r
1105 ((EFI_ADAPTER_INFO_NETWORK_BOOT *)InformationBlock)->FCoeBoot\r
1106 );\r
1107 SHELL_FREE_NON_NULL (RetVal);\r
1108 RetVal = TempRetVal;\r
1109 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoSanMacAddressGuid) == TRUE) {\r
59febea1 1110 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_SAN_MAC_ADDRESS_INFO), NULL);\r
1d6ccad2
QS		 1111 if (TempStr == NULL) {\r
1112 goto ERROR_EXIT;\r
1113 }\r
1a6f74d9
CS		 1114 TempRetVal = CatSPrint (\r
1115 RetVal,\r
1116 TempStr,\r
1117 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[0],\r
1118 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[1],\r
1119 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[2],\r
1120 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[3],\r
1121 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[4],\r
1122 ((EFI_ADAPTER_INFO_SAN_MAC_ADDRESS *)InformationBlock)->SanMacAddress.Addr[5]\r
1123 );\r
1124 SHELL_FREE_NON_NULL (RetVal);\r
1125 RetVal = TempRetVal;\r
256aa6d0
SEHM		 1126 } else if (CompareGuid (&InfoTypesBuffer[GuidIndex], &gEfiAdapterInfoUndiIpv6SupportGuid) == TRUE) {\r
1127 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_UNDI_IPV6_INFO), NULL);\r
1128 if (TempStr == NULL) {\r
1129 goto ERROR_EXIT;\r
1130 }\r
1131\r
1132 TempRetVal = CatSPrint (\r
1133 RetVal,\r
1134 TempStr,\r
1135 ((EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT *)InformationBlock)->Ipv6Support\r
e918029f 1136 );\r
256aa6d0
SEHM		 1137 SHELL_FREE_NON_NULL (RetVal);\r
1138 RetVal = TempRetVal;\r
59febea1
SEHM		 1139 } else {\r
1140 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_UNKNOWN_INFO_TYPE), NULL);\r
1d6ccad2
QS		 1141 if (TempStr == NULL) {\r
1142 goto ERROR_EXIT;\r
1143 }\r
1a6f74d9
CS		 1144 TempRetVal = CatSPrint (RetVal, TempStr, &InfoTypesBuffer[GuidIndex]);\r
1145 SHELL_FREE_NON_NULL (RetVal);\r
1146 RetVal = TempRetVal;\r
59febea1
SEHM		 1147 }\r
1148 }\r
1149 SHELL_FREE_NON_NULL (TempStr);\r
1150 SHELL_FREE_NON_NULL (InformationBlock);\r
1151 }\r
1152 }\r
1153\r
1d6ccad2 1154 SHELL_FREE_NON_NULL (InfoTypesBuffer);\r
59febea1 1155 return RetVal;\r
1d6ccad2
QS		 1156\r
1157ERROR_EXIT:\r
1158 SHELL_FREE_NON_NULL (RetVal);\r
1159 SHELL_FREE_NON_NULL (InfoTypesBuffer);\r
1160 SHELL_FREE_NON_NULL (InformationBlock);\r
1161 return NULL;\r
59febea1 1162}\r
8985d612
TS		 1163\r
1164/**\r
1165 Function to dump information about EFI_FIRMWARE_MANAGEMENT_PROTOCOL Protocol.\r
1166\r
1167 @param[in] TheHandle The handle that has the protocol installed.\r
1168 @param[in] Verbose TRUE for additional information, FALSE otherwise.\r
1169\r
1170 @retval A pointer to a string containing the information.\r
1171**/\r
1172CHAR16*\r
1173EFIAPI\r
1174FirmwareManagementDumpInformation (\r
1175 IN CONST EFI_HANDLE TheHandle,\r
1176 IN CONST BOOLEAN Verbose\r
1177 )\r
1178{\r
1179 EFI_STATUS Status;\r
1180 EFI_FIRMWARE_MANAGEMENT_PROTOCOL *EfiFwMgmtProtocol;\r
1181 EFI_FIRMWARE_IMAGE_DESCRIPTOR *ImageInfo;\r
1182 EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1 *ImageInfoV1;\r
1183 EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2 *ImageInfoV2;\r
1184 UINT64 AttributeSetting;\r
1185 UINTN ImageInfoSize;\r
1186 UINTN DescriptorSize;\r
1187 UINT32 DescriptorVersion;\r
1188 UINT32 PackageVersion;\r
1189 UINT8 DescriptorCount;\r
1190 UINT8 Index;\r
1191 UINT8 Index1;\r
1192 UINT8 ImageCount;\r
1193 CHAR16 *PackageVersionName;\r
1194 CHAR16 *TempStr;\r
1195 CHAR16 *RetVal;\r
1196 CHAR16 *TempRetVal;\r
1197 CHAR16 *AttributeSettingStr;\r
1198 BOOLEAN Found;\r
1199 BOOLEAN AttributeSupported;\r
1200\r
1201 //\r
1202 // Initialize local variables\r
1203 //\r
1204 ImageCount = 0;\r
1205 ImageInfoSize = 1;\r
1206 AttributeSetting = 0;\r
1207 Found = FALSE;\r
1208 AttributeSupported = FALSE;\r
1209 ImageInfo = NULL;\r
1210 ImageInfoV1 = NULL;\r
1211 ImageInfoV2 = NULL;\r
1212 PackageVersionName = NULL;\r
1213 RetVal = NULL;\r
1214 TempRetVal = NULL;\r
1215 TempStr = NULL;\r
1216 AttributeSettingStr = NULL;\r
1217\r
1218 if (!Verbose) {\r
1219 return (CatSPrint(NULL, L"FirmwareManagement"));\r
1220 }\r
1221\r
1222 Status = gBS->OpenProtocol (\r
1223 (EFI_HANDLE) (TheHandle),\r
1224 &gEfiFirmwareManagementProtocolGuid,\r
1225 (VOID **) &EfiFwMgmtProtocol,\r
1226 NULL,\r
1227 NULL,\r
1228 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
1229 );\r
1230\r
1231 if (EFI_ERROR (Status)) {\r
1232 return NULL;\r
1233 }\r
1234\r
1235 Status = EfiFwMgmtProtocol->GetImageInfo (\r
1236 EfiFwMgmtProtocol,\r
1237 &ImageInfoSize,\r
1238 ImageInfo,\r
1239 &DescriptorVersion,\r
1240 &DescriptorCount,\r
1241 &DescriptorSize,\r
1242 &PackageVersion,\r
1243 &PackageVersionName\r
1244 );\r
1245\r
1246 if (Status == EFI_BUFFER_TOO_SMALL) {\r
1247 ImageInfo = AllocateZeroPool (ImageInfoSize);\r
1248\r
1249 if (ImageInfo == NULL) {\r
1250 Status = EFI_OUT_OF_RESOURCES;\r
1251 } else {\r
1252 Status = EfiFwMgmtProtocol->GetImageInfo (\r
1253 EfiFwMgmtProtocol,\r
1254 &ImageInfoSize,\r
1255 ImageInfo,\r
1256 &DescriptorVersion,\r
1257 &DescriptorCount,\r
1258 &DescriptorSize,\r
1259 &PackageVersion,\r
1260 &PackageVersionName\r
1261 );\r
1262 }\r
1263 }\r
1264\r
1265 if (EFI_ERROR (Status)) {\r
1266 goto ERROR_EXIT;\r
1267 }\r
1268\r
1269 //\r
1270 // Decode Image Descriptor data only if its version is supported\r
1271 //\r
1272 if (DescriptorVersion <= EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION) {\r
1273\r
1274 if (ImageInfo == NULL) {\r
1275 goto ERROR_EXIT;\r
1276 }\r
1277\r
1278 ImageInfoV1 = (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V1 *)ImageInfo;\r
1279 ImageInfoV2 = (EFI_FIRMWARE_IMAGE_DESCRIPTOR_V2 *)ImageInfo;\r
1280\r
1281 //\r
1282 // Set ImageInfoSize in return buffer\r
1283 //\r
1284 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_INFO_SIZE), NULL);\r
1285 if (TempStr == NULL) {\r
1286 goto ERROR_EXIT;\r
1287 }\r
1288 RetVal = CatSPrint (NULL, TempStr, ImageInfoSize);\r
1289 SHELL_FREE_NON_NULL (TempStr);\r
1290\r
1291 //\r
1292 // Set DescriptorVersion in return buffer\r
1293 //\r
1294 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_VERSION), NULL);\r
1295 if (TempStr == NULL) {\r
1296 goto ERROR_EXIT;\r
1297 }\r
1298 TempRetVal = CatSPrint (RetVal, TempStr, DescriptorVersion);\r
1299 SHELL_FREE_NON_NULL (RetVal);\r
1300 RetVal = TempRetVal;\r
1301 SHELL_FREE_NON_NULL (TempStr);\r
1302\r
1303 //\r
1304 // Set DescriptorCount in return buffer\r
1305 //\r
1306 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_COUNT), NULL);\r
1307 if (TempStr == NULL) {\r
1308 goto ERROR_EXIT;\r
1309 }\r
1310 TempRetVal = CatSPrint (RetVal, TempStr, DescriptorCount);\r
1311 SHELL_FREE_NON_NULL (RetVal);\r
1312 RetVal = TempRetVal;\r
1313 SHELL_FREE_NON_NULL (TempStr);\r
1314\r
1315\r
1316 //\r
1317 // Set DescriptorSize in return buffer\r
1318 //\r
1319 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_DESCRIPTOR_SIZE), NULL);\r
1320 if (TempStr == NULL) {\r
1321 goto ERROR_EXIT;\r
1322 }\r
1323 TempRetVal = CatSPrint (RetVal, TempStr, DescriptorSize);\r
1324 SHELL_FREE_NON_NULL (RetVal);\r
1325 RetVal = TempRetVal;\r
1326 SHELL_FREE_NON_NULL (TempStr);\r
1327\r
1328 //\r
1329 // Set PackageVersion in return buffer\r
1330 //\r
1331 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_PACKAGE_VERSION), NULL);\r
1332 if (TempStr == NULL) {\r
1333 goto ERROR_EXIT;\r
1334 }\r
1335 TempRetVal = CatSPrint (RetVal, TempStr, PackageVersion);\r
1336 SHELL_FREE_NON_NULL (RetVal);\r
1337 RetVal = TempRetVal;\r
1338 SHELL_FREE_NON_NULL (TempStr);\r
1339\r
1340 //\r
1341 // Set PackageVersionName in return buffer\r
1342 //\r
1343 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_PACKAGE_VERSION_NAME), NULL);\r
1344 if (TempStr == NULL) {\r
1345 goto ERROR_EXIT;\r
1346 }\r
1347 TempRetVal = CatSPrint (RetVal, TempStr, PackageVersionName);\r
1348 SHELL_FREE_NON_NULL (RetVal);\r
1349 RetVal = TempRetVal;\r
1350 SHELL_FREE_NON_NULL (TempStr);\r
1351\r
1352 for (Index = 0; Index < DescriptorCount; Index++) {\r
1353 //\r
1354 // First check if Attribute is supported\r
1355 // and generate a string for AttributeSetting field\r
1356 //\r
1357 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1358 AttributeSupported = FALSE;\r
1359 AttributeSetting = 0;\r
1360 if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {\r
1361 if (ImageInfoV1[Index].AttributesSupported != 0x0) {\r
1362 AttributeSupported = TRUE;\r
1363 AttributeSetting = ImageInfoV1[Index].AttributesSetting;\r
1364 }\r
1365 } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {\r
1366 if (ImageInfoV2[Index].AttributesSupported != 0x0) {\r
1367 AttributeSupported = TRUE;\r
1368 AttributeSetting = ImageInfoV2[Index].AttributesSetting;\r
1369 }\r
1370 } else {\r
1371 if (ImageInfo[Index].AttributesSupported != 0x0) {\r
1372 AttributeSupported = TRUE;\r
1373 AttributeSetting = ImageInfo[Index].AttributesSetting;\r
1374 }\r
1375 }\r
1376\r
1377 if (!AttributeSupported) {\r
1378 AttributeSettingStr = CatSPrint (NULL, L"None");\r
1379 } else {\r
1380 AttributeSettingStr = CatSPrint (NULL, L"(");\r
1381\r
ac14846a 1382 if ((AttributeSetting & IMAGE_ATTRIBUTE_IMAGE_UPDATABLE) != 0x0) {\r
8985d612
TS		 1383 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IMAGE_UPDATABLE");\r
1384 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1385 AttributeSettingStr = TempRetVal;\r
1386 }\r
ac14846a 1387 if ((AttributeSetting & IMAGE_ATTRIBUTE_RESET_REQUIRED) != 0x0) {\r
8985d612
TS		 1388 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_RESET_REQUIRED");\r
1389 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1390 AttributeSettingStr = TempRetVal;\r
1391 }\r
ac14846a 1392 if ((AttributeSetting & IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED) != 0x0) {\r
8985d612
TS		 1393 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED");\r
1394 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1395 AttributeSettingStr = TempRetVal;\r
1396 }\r
ac14846a 1397 if ((AttributeSetting & IMAGE_ATTRIBUTE_IN_USE) != 0x0) {\r
8985d612
TS		 1398 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_IN_USE");\r
1399 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1400 AttributeSettingStr = TempRetVal;\r
1401 }\r
ac14846a 1402 if ((AttributeSetting & IMAGE_ATTRIBUTE_UEFI_IMAGE) != 0x0) {\r
8985d612
TS		 1403 TempRetVal = CatSPrint (AttributeSettingStr, L" IMAGE_ATTRIBUTE_UEFI_IMAGE");\r
1404 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1405 AttributeSettingStr = TempRetVal;\r
1406 }\r
1407 TempRetVal = CatSPrint (AttributeSettingStr, L" )");\r
1408 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1409 AttributeSettingStr = TempRetVal;\r
1410 }\r
1411\r
1412 if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {\r
1413 if (ImageInfoV1[Index].ImageIndex != 0x0) {\r
1414 ImageCount++;\r
1415 }\r
1416\r
1417 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V1), NULL);\r
1418 if (TempStr == NULL) {\r
1419 goto ERROR_EXIT;\r
1420 }\r
1421 TempRetVal = CatSPrint (\r
1422 RetVal,\r
1423 TempStr,\r
1424 Index,\r
1425 ImageInfoV1[Index].ImageIndex,\r
e06a4c08 1426 &ImageInfoV1[Index].ImageTypeId,\r
8985d612
TS		 1427 ImageInfoV1[Index].ImageId,\r
1428 ImageInfoV1[Index].ImageIdName,\r
1429 ImageInfoV1[Index].Version,\r
1430 ImageInfoV1[Index].VersionName,\r
1431 ImageInfoV1[Index].Size,\r
1432 ImageInfoV1[Index].AttributesSupported,\r
1433 AttributeSettingStr,\r
1434 ImageInfoV1[Index].Compatibilities\r
1435 );\r
1436 SHELL_FREE_NON_NULL (RetVal);\r
1437 RetVal = TempRetVal;\r
1438 SHELL_FREE_NON_NULL (TempStr);\r
1439 } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {\r
1440 if (ImageInfoV2[Index].ImageIndex != 0x0) {\r
1441 ImageCount++;\r
1442 }\r
1443\r
1444 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO_V2), NULL);\r
1445 if (TempStr == NULL) {\r
1446 goto ERROR_EXIT;\r
1447 }\r
1448 TempRetVal = CatSPrint (\r
1449 RetVal,\r
1450 TempStr,\r
1451 Index,\r
1452 ImageInfoV2[Index].ImageIndex,\r
e06a4c08 1453 &ImageInfoV2[Index].ImageTypeId,\r
8985d612
TS		 1454 ImageInfoV2[Index].ImageId,\r
1455 ImageInfoV2[Index].ImageIdName,\r
1456 ImageInfoV2[Index].Version,\r
1457 ImageInfoV2[Index].VersionName,\r
1458 ImageInfoV2[Index].Size,\r
1459 ImageInfoV2[Index].AttributesSupported,\r
1460 AttributeSettingStr,\r
1461 ImageInfoV2[Index].Compatibilities,\r
1462 ImageInfoV2[Index].LowestSupportedImageVersion\r
1463 );\r
1464 SHELL_FREE_NON_NULL (RetVal);\r
1465 RetVal = TempRetVal;\r
1466 SHELL_FREE_NON_NULL (TempStr);\r
1467 } else {\r
1468 if (ImageInfo[Index].ImageIndex != 0x0) {\r
1469 ImageCount++;\r
1470 }\r
1471\r
1472 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGE_DESCRIPTOR_INFO), NULL);\r
1473 if (TempStr == NULL) {\r
1474 goto ERROR_EXIT;\r
1475 }\r
1476 TempRetVal = CatSPrint (\r
1477 RetVal,\r
1478 TempStr,\r
1479 Index,\r
1480 ImageInfo[Index].ImageIndex,\r
e06a4c08 1481 &ImageInfo[Index].ImageTypeId,\r
8985d612
TS		 1482 ImageInfo[Index].ImageId,\r
1483 ImageInfo[Index].ImageIdName,\r
1484 ImageInfo[Index].Version,\r
1485 ImageInfo[Index].VersionName,\r
1486 ImageInfo[Index].Size,\r
1487 ImageInfo[Index].AttributesSupported,\r
1488 AttributeSettingStr,\r
1489 ImageInfo[Index].Compatibilities,\r
1490 ImageInfo[Index].LowestSupportedImageVersion,\r
1491 ImageInfo[Index].LastAttemptVersion,\r
1492 ImageInfo[Index].LastAttemptStatus,\r
1493 ImageInfo[Index].HardwareInstance\r
1494 );\r
1495 SHELL_FREE_NON_NULL (RetVal);\r
1496 RetVal = TempRetVal;\r
1497 SHELL_FREE_NON_NULL (TempStr);\r
1498 }\r
1499 }\r
1500 }\r
1501\r
1502 if (ImageCount > 0) {\r
1503 for (Index=0; Index<DescriptorCount; Index++) {\r
1504 for (Index1=Index+1; Index1<DescriptorCount; Index1++) {\r
1505 if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V1) {\r
1506 if (ImageInfoV1[Index].ImageId == ImageInfoV1[Index1].ImageId) {\r
1507 Found = TRUE;\r
1508 //\r
1509 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed\r
1510 //\r
1511 goto ENDLOOP;\r
1512 }\r
1513 } else if (DescriptorVersion == EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION_V2) {\r
1514 if (ImageInfoV2[Index].ImageId == ImageInfoV2[Index1].ImageId) {\r
1515 Found = TRUE;\r
1516 //\r
1517 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed\r
1518 //\r
1519 goto ENDLOOP;\r
1520 }\r
1521 } else {\r
1522 if (ImageInfo[Index].ImageId == ImageInfo[Index1].ImageId) {\r
1523 Found = TRUE;\r
1524 //\r
1525 // At least one match found indicating presense of non unique ImageId values so no more comparisons needed\r
1526 //\r
1527 goto ENDLOOP;\r
1528 }\r
1529 }\r
1530 }\r
1531 }\r
1532 }\r
1533\r
1534ENDLOOP:\r
1535 //\r
1536 // Check if ImageId with duplicate value was found\r
1537 //\r
ac14846a 1538 if (Found) {\r
8985d612
TS		 1539 TempStr = HiiGetString (mHandleParsingHiiHandle, STRING_TOKEN(STR_FMP_IMAGEID_NON_UNIQUE), NULL);\r
1540 if (TempStr == NULL) {\r
1541 goto ERROR_EXIT;\r
1542 }\r
1543 TempRetVal = CatSPrint (RetVal, TempStr);\r
1544 SHELL_FREE_NON_NULL (RetVal);\r
1545 RetVal = TempRetVal;\r
1546 SHELL_FREE_NON_NULL (TempStr);\r
1547 }\r
1548\r
1549 SHELL_FREE_NON_NULL (ImageInfo);\r
1550 SHELL_FREE_NON_NULL (PackageVersionName);\r
1551 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1552\r
1553 return RetVal;\r
1554\r
1555ERROR_EXIT:\r
1556 SHELL_FREE_NON_NULL (RetVal);\r
1557 SHELL_FREE_NON_NULL (ImageInfo);\r
1558 SHELL_FREE_NON_NULL (PackageVersionName);\r
1559 SHELL_FREE_NON_NULL (AttributeSettingStr);\r
1560\r
1561 return NULL;\r
1562}\r
1563\r
a405b86d 1564//\r
1565// Put the information on the NT32 protocol GUIDs here so we are not dependant on the Nt32Pkg\r
1566//\r
1567#define LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID \\r
1568 { \\r
ce68d3bc 1569 0x58c518b1, 0x76f3, 0x11d4, { 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
a405b86d 1570 }\r
1571\r
1572#define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \\r
1573 { \\r
ce68d3bc 1574 0x96eb4ad6, 0xa32a, 0x11d4, { 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
a405b86d 1575 }\r
1576\r
1577#define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \\r
1578 { \\r
ce68d3bc 1579 0xc95a93d, 0xa006, 0x11d4, { 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \\r
a405b86d 1580 }\r
1581STATIC CONST EFI_GUID WinNtThunkProtocolGuid = LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID;\r
1582STATIC CONST EFI_GUID WinNtIoProtocolGuid = LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID;\r
1583STATIC CONST EFI_GUID WinNtSerialPortGuid = LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID;\r
1584\r
2c23ddaa 1585//\r
1586// Deprecated protocols we dont want to link from IntelFrameworkModulePkg\r
1587//\r
1588#define LOCAL_EFI_ISA_IO_PROTOCOL_GUID \\r
1589 { \\r
1590 0x7ee2bd44, 0x3da0, 0x11d4, { 0x9a, 0x38, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } \\r
1a6f74d9 1591 }\r
2c23ddaa 1592#define LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID \\r
1593 { \\r
1594 0x64a892dc, 0x5561, 0x4536, { 0x92, 0xc7, 0x79, 0x9b, 0xfc, 0x18, 0x33, 0x55 } \\r
1595 }\r
1596STATIC CONST EFI_GUID EfiIsaIoProtocolGuid = LOCAL_EFI_ISA_IO_PROTOCOL_GUID;\r
1597STATIC CONST EFI_GUID EfiIsaAcpiProtocolGuid = LOCAL_EFI_ISA_ACPI_PROTOCOL_GUID;\r
1598\r
1599\r
dee34318 1600STATIC CONST GUID_INFO_BLOCK mGuidStringListNT[] = {\r
a405b86d 1601 {STRING_TOKEN(STR_WINNT_THUNK), (EFI_GUID*)&WinNtThunkProtocolGuid, NULL},\r
1602 {STRING_TOKEN(STR_WINNT_DRIVER_IO), (EFI_GUID*)&WinNtIoProtocolGuid, NULL},\r
1603 {STRING_TOKEN(STR_WINNT_SERIAL_PORT), (EFI_GUID*)&WinNtSerialPortGuid, NULL},\r
0e88348e 1604 {0, NULL, NULL},\r
a405b86d 1605};\r
1606\r
dee34318 1607STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {\r
efb76d1a 1608 {STRING_TOKEN(STR_LOADED_IMAGE), &gEfiLoadedImageProtocolGuid, LoadedImageProtocolDumpInformation},\r
a405b86d 1609 {STRING_TOKEN(STR_DEVICE_PATH), &gEfiDevicePathProtocolGuid, DevicePathProtocolDumpInformation},\r
5e32460d 1610 {STRING_TOKEN(STR_IMAGE_PATH), &gEfiLoadedImageDevicePathProtocolGuid, LoadedImageDevicePathProtocolDumpInformation},\r
a405b86d 1611 {STRING_TOKEN(STR_DEVICE_PATH_UTIL), &gEfiDevicePathUtilitiesProtocolGuid, NULL},\r
1612 {STRING_TOKEN(STR_DEVICE_PATH_TXT), &gEfiDevicePathToTextProtocolGuid, NULL},\r
1613 {STRING_TOKEN(STR_DEVICE_PATH_FTXT), &gEfiDevicePathFromTextProtocolGuid, NULL},\r
1614 {STRING_TOKEN(STR_DEVICE_PATH_PC), &gEfiPcAnsiGuid, NULL},\r
1615 {STRING_TOKEN(STR_DEVICE_PATH_VT100), &gEfiVT100Guid, NULL},\r
1616 {STRING_TOKEN(STR_DEVICE_PATH_VT100P), &gEfiVT100PlusGuid, NULL},\r
1617 {STRING_TOKEN(STR_DEVICE_PATH_VTUTF8), &gEfiVTUTF8Guid, NULL},\r
1618 {STRING_TOKEN(STR_DRIVER_BINDING), &gEfiDriverBindingProtocolGuid, NULL},\r
1619 {STRING_TOKEN(STR_PLATFORM_OVERRIDE), &gEfiPlatformDriverOverrideProtocolGuid, NULL},\r
1620 {STRING_TOKEN(STR_BUS_OVERRIDE), &gEfiBusSpecificDriverOverrideProtocolGuid, NULL},\r
1621 {STRING_TOKEN(STR_DRIVER_DIAG), &gEfiDriverDiagnosticsProtocolGuid, NULL},\r
1622 {STRING_TOKEN(STR_DRIVER_DIAG2), &gEfiDriverDiagnostics2ProtocolGuid, NULL},\r
1623 {STRING_TOKEN(STR_DRIVER_CN), &gEfiComponentNameProtocolGuid, NULL},\r
1624 {STRING_TOKEN(STR_DRIVER_CN2), &gEfiComponentName2ProtocolGuid, NULL},\r
1625 {STRING_TOKEN(STR_PLAT_DRV_CFG), &gEfiPlatformToDriverConfigurationProtocolGuid, NULL},\r
1626 {STRING_TOKEN(STR_DRIVER_VERSION), &gEfiDriverSupportedEfiVersionProtocolGuid, DriverEfiVersionProtocolDumpInformation},\r
1627 {STRING_TOKEN(STR_TXT_IN), &gEfiSimpleTextInProtocolGuid, NULL},\r
1628 {STRING_TOKEN(STR_TXT_IN_EX), &gEfiSimpleTextInputExProtocolGuid, NULL},\r
1629 {STRING_TOKEN(STR_TXT_OUT), &gEfiSimpleTextOutProtocolGuid, TxtOutProtocolDumpInformation},\r
1630 {STRING_TOKEN(STR_SIM_POINTER), &gEfiSimplePointerProtocolGuid, NULL},\r
1631 {STRING_TOKEN(STR_ABS_POINTER), &gEfiAbsolutePointerProtocolGuid, NULL},\r
1632 {STRING_TOKEN(STR_SERIAL_IO), &gEfiSerialIoProtocolGuid, NULL},\r
609e0c58 1633 {STRING_TOKEN(STR_GRAPHICS_OUTPUT), &gEfiGraphicsOutputProtocolGuid, GraphicsOutputProtocolDumpInformation},\r
e918029f
RN		 1634 {STRING_TOKEN(STR_EDID_DISCOVERED), &gEfiEdidDiscoveredProtocolGuid, EdidDiscoveredProtocolDumpInformation},\r
1635 {STRING_TOKEN(STR_EDID_ACTIVE), &gEfiEdidActiveProtocolGuid, EdidActiveProtocolDumpInformation},\r
a405b86d 1636 {STRING_TOKEN(STR_EDID_OVERRIDE), &gEfiEdidOverrideProtocolGuid, NULL},\r
1637 {STRING_TOKEN(STR_CON_IN), &gEfiConsoleInDeviceGuid, NULL},\r
1638 {STRING_TOKEN(STR_CON_OUT), &gEfiConsoleOutDeviceGuid, NULL},\r
1639 {STRING_TOKEN(STR_STD_ERR), &gEfiStandardErrorDeviceGuid, NULL},\r
1640 {STRING_TOKEN(STR_LOAD_FILE), &gEfiLoadFileProtocolGuid, NULL},\r
1641 {STRING_TOKEN(STR_LOAD_FILE2), &gEfiLoadFile2ProtocolGuid, NULL},\r
1642 {STRING_TOKEN(STR_SIMPLE_FILE_SYS), &gEfiSimpleFileSystemProtocolGuid, NULL},\r
a405b86d 1643 {STRING_TOKEN(STR_TAPE_IO), &gEfiTapeIoProtocolGuid, NULL},\r
1644 {STRING_TOKEN(STR_DISK_IO), &gEfiDiskIoProtocolGuid, NULL},\r
1645 {STRING_TOKEN(STR_BLK_IO), &gEfiBlockIoProtocolGuid, NULL},\r
1646 {STRING_TOKEN(STR_UC), &gEfiUnicodeCollationProtocolGuid, NULL},\r
1647 {STRING_TOKEN(STR_UC2), &gEfiUnicodeCollation2ProtocolGuid, NULL},\r
f4f3c6bf 1648 {STRING_TOKEN(STR_PCIRB_IO), &gEfiPciRootBridgeIoProtocolGuid, PciRootBridgeIoDumpInformation},\r
a405b86d 1649 {STRING_TOKEN(STR_PCI_IO), &gEfiPciIoProtocolGuid, NULL},\r
1650 {STRING_TOKEN(STR_SCSI_PT), &gEfiScsiPassThruProtocolGuid, NULL},\r
1651 {STRING_TOKEN(STR_SCSI_IO), &gEfiScsiIoProtocolGuid, NULL},\r
1652 {STRING_TOKEN(STR_SCSI_PT_EXT), &gEfiExtScsiPassThruProtocolGuid, NULL},\r
1653 {STRING_TOKEN(STR_ISCSI), &gEfiIScsiInitiatorNameProtocolGuid, NULL},\r
1654 {STRING_TOKEN(STR_USB_IO), &gEfiUsbIoProtocolGuid, NULL},\r
1655 {STRING_TOKEN(STR_USB_HC), &gEfiUsbHcProtocolGuid, NULL},\r
1656 {STRING_TOKEN(STR_USB_HC2), &gEfiUsb2HcProtocolGuid, NULL},\r
1657 {STRING_TOKEN(STR_DEBUG_SUPPORT), &gEfiDebugSupportProtocolGuid, NULL},\r
1658 {STRING_TOKEN(STR_DEBUG_PORT), &gEfiDebugPortProtocolGuid, NULL},\r
1659 {STRING_TOKEN(STR_DECOMPRESS), &gEfiDecompressProtocolGuid, NULL},\r
1660 {STRING_TOKEN(STR_ACPI_TABLE), &gEfiAcpiTableProtocolGuid, NULL},\r
1661 {STRING_TOKEN(STR_EBC_INTERPRETER), &gEfiEbcProtocolGuid, NULL},\r
1662 {STRING_TOKEN(STR_SNP), &gEfiSimpleNetworkProtocolGuid, NULL},\r
1663 {STRING_TOKEN(STR_NII), &gEfiNetworkInterfaceIdentifierProtocolGuid, NULL},\r
1664 {STRING_TOKEN(STR_NII_31), &gEfiNetworkInterfaceIdentifierProtocolGuid_31, NULL},\r
1665 {STRING_TOKEN(STR_PXE_BC), &gEfiPxeBaseCodeProtocolGuid, NULL},\r
1666 {STRING_TOKEN(STR_PXE_CB), &gEfiPxeBaseCodeCallbackProtocolGuid, NULL},\r
1667 {STRING_TOKEN(STR_BIS), &gEfiBisProtocolGuid, NULL},\r
1668 {STRING_TOKEN(STR_MNP_SB), &gEfiManagedNetworkServiceBindingProtocolGuid, NULL},\r
1669 {STRING_TOKEN(STR_MNP), &gEfiManagedNetworkProtocolGuid, NULL},\r
1670 {STRING_TOKEN(STR_ARP_SB), &gEfiArpServiceBindingProtocolGuid, NULL},\r
1671 {STRING_TOKEN(STR_ARP), &gEfiArpProtocolGuid, NULL},\r
1672 {STRING_TOKEN(STR_DHCPV4_SB), &gEfiDhcp4ServiceBindingProtocolGuid, NULL},\r
1673 {STRING_TOKEN(STR_DHCPV4), &gEfiDhcp4ProtocolGuid, NULL},\r
1674 {STRING_TOKEN(STR_TCPV4_SB), &gEfiTcp4ServiceBindingProtocolGuid, NULL},\r
1675 {STRING_TOKEN(STR_TCPV4), &gEfiTcp4ProtocolGuid, NULL},\r
1676 {STRING_TOKEN(STR_IPV4_SB), &gEfiIp4ServiceBindingProtocolGuid, NULL},\r
1677 {STRING_TOKEN(STR_IPV4), &gEfiIp4ProtocolGuid, NULL},\r
1678 {STRING_TOKEN(STR_IPV4_CFG), &gEfiIp4ConfigProtocolGuid, NULL},\r
00a6ad1b 1679 {STRING_TOKEN(STR_IPV4_CFG2), &gEfiIp4Config2ProtocolGuid, NULL},\r
a405b86d 1680 {STRING_TOKEN(STR_UDPV4_SB), &gEfiUdp4ServiceBindingProtocolGuid, NULL},\r
1681 {STRING_TOKEN(STR_UDPV4), &gEfiUdp4ProtocolGuid, NULL},\r
1682 {STRING_TOKEN(STR_MTFTPV4_SB), &gEfiMtftp4ServiceBindingProtocolGuid, NULL},\r
1683 {STRING_TOKEN(STR_MTFTPV4), &gEfiMtftp4ProtocolGuid, NULL},\r
1684 {STRING_TOKEN(STR_AUTH_INFO), &gEfiAuthenticationInfoProtocolGuid, NULL},\r
1685 {STRING_TOKEN(STR_HASH_SB), &gEfiHashServiceBindingProtocolGuid, NULL},\r
1686 {STRING_TOKEN(STR_HASH), &gEfiHashProtocolGuid, NULL},\r
1687 {STRING_TOKEN(STR_HII_FONT), &gEfiHiiFontProtocolGuid, NULL},\r
1688 {STRING_TOKEN(STR_HII_STRING), &gEfiHiiStringProtocolGuid, NULL},\r
1689 {STRING_TOKEN(STR_HII_IMAGE), &gEfiHiiImageProtocolGuid, NULL},\r
1690 {STRING_TOKEN(STR_HII_DATABASE), &gEfiHiiDatabaseProtocolGuid, NULL},\r
1691 {STRING_TOKEN(STR_HII_CONFIG_ROUT), &gEfiHiiConfigRoutingProtocolGuid, NULL},\r
1692 {STRING_TOKEN(STR_HII_CONFIG_ACC), &gEfiHiiConfigAccessProtocolGuid, NULL},\r
1693 {STRING_TOKEN(STR_HII_FORM_BROWSER2), &gEfiFormBrowser2ProtocolGuid, NULL},\r
dee34318 1694 {STRING_TOKEN(STR_DRIVER_FAM_OVERRIDE), &gEfiDriverFamilyOverrideProtocolGuid, NULL},\r
1695 {STRING_TOKEN(STR_PCD), &gPcdProtocolGuid, NULL},\r
1696 {STRING_TOKEN(STR_TCG), &gEfiTcgProtocolGuid, NULL},\r
1697 {STRING_TOKEN(STR_HII_PACKAGE_LIST), &gEfiHiiPackageListProtocolGuid, NULL},\r
1698\r
1699//\r
1700// the ones under this are deprecated by the current UEFI Spec, but may be found anyways...\r
1701//\r
a405b86d 1702 {STRING_TOKEN(STR_SHELL_INTERFACE), &gEfiShellInterfaceGuid, NULL},\r
1703 {STRING_TOKEN(STR_SHELL_ENV2), &gEfiShellEnvironment2Guid, NULL},\r
1704 {STRING_TOKEN(STR_SHELL_ENV), &gEfiShellEnvironment2Guid, NULL},\r
1705 {STRING_TOKEN(STR_DEVICE_IO), &gEfiDeviceIoProtocolGuid, NULL},\r
1706 {STRING_TOKEN(STR_UGA_DRAW), &gEfiUgaDrawProtocolGuid, NULL},\r
1707 {STRING_TOKEN(STR_UGA_IO), &gEfiUgaIoProtocolGuid, NULL},\r
1708 {STRING_TOKEN(STR_ESP), &gEfiPartTypeSystemPartGuid, NULL},\r
1709 {STRING_TOKEN(STR_GPT_NBR), &gEfiPartTypeLegacyMbrGuid, NULL},\r
1710 {STRING_TOKEN(STR_DRIVER_CONFIG), &gEfiDriverConfigurationProtocolGuid, NULL},\r
1711 {STRING_TOKEN(STR_DRIVER_CONFIG2), &gEfiDriverConfiguration2ProtocolGuid, NULL},\r
2c23ddaa 1712\r
1713//\r
1714// these are using local (non-global) definitions to reduce package dependancy.\r
1715//\r
1716 {STRING_TOKEN(STR_ISA_IO), (EFI_GUID*)&EfiIsaIoProtocolGuid, NULL},\r
1717 {STRING_TOKEN(STR_ISA_ACPI), (EFI_GUID*)&EfiIsaAcpiProtocolGuid, NULL},\r
dee34318 1718\r
1719//\r
1720// the ones under this are GUID identified structs, not protocols\r
1721//\r
1722 {STRING_TOKEN(STR_FILE_INFO), &gEfiFileInfoGuid, NULL},\r
1723 {STRING_TOKEN(STR_FILE_SYS_INFO), &gEfiFileSystemInfoGuid, NULL},\r
1724\r
1725//\r
1726// the ones under this are misc GUIDS.\r
1727//\r
1728 {STRING_TOKEN(STR_EFI_GLOBAL_VARIABLE), &gEfiGlobalVariableGuid, NULL},\r
1729\r
1730//\r
1731// UEFI 2.2\r
1732//\r
1733 {STRING_TOKEN(STR_IP6_SB), &gEfiIp6ServiceBindingProtocolGuid, NULL},\r
1734 {STRING_TOKEN(STR_IP6), &gEfiIp6ProtocolGuid, NULL},\r
1735 {STRING_TOKEN(STR_IP6_CONFIG), &gEfiIp6ConfigProtocolGuid, NULL},\r
1736 {STRING_TOKEN(STR_MTFTP6_SB), &gEfiMtftp6ServiceBindingProtocolGuid, NULL},\r
1737 {STRING_TOKEN(STR_MTFTP6), &gEfiMtftp6ProtocolGuid, NULL},\r
1738 {STRING_TOKEN(STR_DHCP6_SB), &gEfiDhcp6ServiceBindingProtocolGuid, NULL},\r
1739 {STRING_TOKEN(STR_DHCP6), &gEfiDhcp6ProtocolGuid, NULL},\r
1740 {STRING_TOKEN(STR_UDP6_SB), &gEfiUdp6ServiceBindingProtocolGuid, NULL},\r
1741 {STRING_TOKEN(STR_UDP6), &gEfiUdp6ProtocolGuid, NULL},\r
1742 {STRING_TOKEN(STR_TCP6_SB), &gEfiTcp6ServiceBindingProtocolGuid, NULL},\r
1743 {STRING_TOKEN(STR_TCP6), &gEfiTcp6ProtocolGuid, NULL},\r
1744 {STRING_TOKEN(STR_VLAN_CONFIG), &gEfiVlanConfigProtocolGuid, NULL},\r
1745 {STRING_TOKEN(STR_EAP), &gEfiEapProtocolGuid, NULL},\r
1746 {STRING_TOKEN(STR_EAP_MGMT), &gEfiEapManagementProtocolGuid, NULL},\r
1747 {STRING_TOKEN(STR_FTP4_SB), &gEfiFtp4ServiceBindingProtocolGuid, NULL},\r
1748 {STRING_TOKEN(STR_FTP4), &gEfiFtp4ProtocolGuid, NULL},\r
1749 {STRING_TOKEN(STR_IP_SEC_CONFIG), &gEfiIpSecConfigProtocolGuid, NULL},\r
1750 {STRING_TOKEN(STR_DH), &gEfiDriverHealthProtocolGuid, NULL},\r
1751 {STRING_TOKEN(STR_DEF_IMG_LOAD), &gEfiDeferredImageLoadProtocolGuid, NULL},\r
1752 {STRING_TOKEN(STR_USER_CRED), &gEfiUserCredentialProtocolGuid, NULL},\r
1753 {STRING_TOKEN(STR_USER_MNGR), &gEfiUserManagerProtocolGuid, NULL},\r
1754 {STRING_TOKEN(STR_ATA_PASS_THRU), &gEfiAtaPassThruProtocolGuid, NULL},\r
1755\r
1756//\r
1757// UEFI 2.3\r
1758//\r
8985d612 1759 {STRING_TOKEN(STR_FW_MGMT), &gEfiFirmwareManagementProtocolGuid, FirmwareManagementDumpInformation},\r
dee34318 1760 {STRING_TOKEN(STR_IP_SEC), &gEfiIpSecProtocolGuid, NULL},\r
1761 {STRING_TOKEN(STR_IP_SEC2), &gEfiIpSec2ProtocolGuid, NULL},\r
1762\r
1763//\r
1764// UEFI 2.3.1\r
1765//\r
1766 {STRING_TOKEN(STR_KMS), &gEfiKmsProtocolGuid, NULL},\r
1767 {STRING_TOKEN(STR_BLK_IO2), &gEfiBlockIo2ProtocolGuid, NULL},\r
1768 {STRING_TOKEN(STR_SSC), &gEfiStorageSecurityCommandProtocolGuid, NULL},\r
12f1a36c 1769 {STRING_TOKEN(STR_UCRED2), &gEfiUserCredential2ProtocolGuid, NULL},\r
dee34318 1770\r
28cdb62b
CP		 1771//\r
1772// UEFI 2.4\r
1773//\r
1774 {STRING_TOKEN(STR_DISK_IO2), &gEfiDiskIo2ProtocolGuid, NULL},\r
59febea1 1775 {STRING_TOKEN(STR_ADAPTER_INFO), &gEfiAdapterInformationProtocolGuid, AdapterInformationDumpInformation},\r
28cdb62b 1776\r
6b640b4a
JC		 1777//\r
1778// PI Spec ones\r
1779//\r
1780 {STRING_TOKEN(STR_IDE_CONT_INIT), &gEfiIdeControllerInitProtocolGuid, NULL},\r
4024c116 1781 {STRING_TOKEN(STR_DISK_INFO), &gEfiDiskInfoProtocolGuid, NULL},\r
6b640b4a 1782\r
c2788f1c
JC		 1783//\r
1784// PI Spec 1.0\r
1785//\r
1786 {STRING_TOKEN(STR_BDS_ARCH), &gEfiBdsArchProtocolGuid, NULL},\r
1787 {STRING_TOKEN(STR_CPU_ARCH), &gEfiCpuArchProtocolGuid, NULL},\r
1788 {STRING_TOKEN(STR_MET_ARCH), &gEfiMetronomeArchProtocolGuid, NULL},\r
1789 {STRING_TOKEN(STR_MON_ARCH), &gEfiMonotonicCounterArchProtocolGuid, NULL},\r
1790 {STRING_TOKEN(STR_RTC_ARCH), &gEfiRealTimeClockArchProtocolGuid, NULL},\r
1791 {STRING_TOKEN(STR_RESET_ARCH), &gEfiResetArchProtocolGuid, NULL},\r
1792 {STRING_TOKEN(STR_RT_ARCH), &gEfiRuntimeArchProtocolGuid, NULL},\r
1793 {STRING_TOKEN(STR_SEC_ARCH), &gEfiSecurityArchProtocolGuid, NULL},\r
1794 {STRING_TOKEN(STR_TIMER_ARCH), &gEfiTimerArchProtocolGuid, NULL},\r
1795 {STRING_TOKEN(STR_VAR_ARCH), &gEfiVariableWriteArchProtocolGuid, NULL},\r
1796 {STRING_TOKEN(STR_V_ARCH), &gEfiVariableArchProtocolGuid, NULL},\r
1797 {STRING_TOKEN(STR_SECP), &gEfiSecurityPolicyProtocolGuid, NULL},\r
1798 {STRING_TOKEN(STR_WDT_ARCH), &gEfiWatchdogTimerArchProtocolGuid, NULL},\r
1799 {STRING_TOKEN(STR_SCR), &gEfiStatusCodeRuntimeProtocolGuid, NULL},\r
1800 {STRING_TOKEN(STR_SMB_HC), &gEfiSmbusHcProtocolGuid, NULL},\r
1801 {STRING_TOKEN(STR_FV_2), &gEfiFirmwareVolume2ProtocolGuid, NULL},\r
1802 {STRING_TOKEN(STR_FV_BLOCK), &gEfiFirmwareVolumeBlockProtocolGuid, NULL},\r
1803 {STRING_TOKEN(STR_CAP_ARCH), &gEfiCapsuleArchProtocolGuid, NULL},\r
1804 {STRING_TOKEN(STR_MP_SERVICE), &gEfiMpServiceProtocolGuid, NULL},\r
1805 {STRING_TOKEN(STR_HBRAP), &gEfiPciHostBridgeResourceAllocationProtocolGuid, NULL},\r
1806 {STRING_TOKEN(STR_PCIP), &gEfiPciPlatformProtocolGuid, NULL},\r
1807 {STRING_TOKEN(STR_PCIO), &gEfiPciOverrideProtocolGuid, NULL},\r
1808 {STRING_TOKEN(STR_PCIE), &gEfiPciEnumerationCompleteProtocolGuid, NULL},\r
1809 {STRING_TOKEN(STR_IPCID), &gEfiIncompatiblePciDeviceSupportProtocolGuid, NULL},\r
1810 {STRING_TOKEN(STR_PCIHPI), &gEfiPciHotPlugInitProtocolGuid, NULL},\r
1811 {STRING_TOKEN(STR_PCIHPR), &gEfiPciHotPlugRequestProtocolGuid, NULL},\r
1812 {STRING_TOKEN(STR_SMBIOS), &gEfiSmbiosProtocolGuid, NULL},\r
1813 {STRING_TOKEN(STR_S3_SAVE), &gEfiS3SaveStateProtocolGuid, NULL},\r
1814 {STRING_TOKEN(STR_S3_S_SMM), &gEfiS3SmmSaveStateProtocolGuid, NULL},\r
1815 {STRING_TOKEN(STR_RSC), &gEfiRscHandlerProtocolGuid, NULL},\r
1816 {STRING_TOKEN(STR_S_RSC), &gEfiSmmRscHandlerProtocolGuid, NULL},\r
1817 {STRING_TOKEN(STR_ACPI_SDT), &gEfiAcpiSdtProtocolGuid, NULL},\r
1818 {STRING_TOKEN(STR_SIO), &gEfiSioProtocolGuid, NULL},\r
1819 {STRING_TOKEN(STR_S_CPU2), &gEfiSmmCpuIo2ProtocolGuid, NULL},\r
1820 {STRING_TOKEN(STR_S_BASE2), &gEfiSmmBase2ProtocolGuid, NULL},\r
1821 {STRING_TOKEN(STR_S_ACC_2), &gEfiSmmAccess2ProtocolGuid, NULL},\r
1822 {STRING_TOKEN(STR_S_CON_2), &gEfiSmmControl2ProtocolGuid, NULL},\r
1823 {STRING_TOKEN(STR_S_CONFIG), &gEfiSmmConfigurationProtocolGuid, NULL},\r
1824 {STRING_TOKEN(STR_S_RTL), &gEfiSmmReadyToLockProtocolGuid, NULL},\r
1825 {STRING_TOKEN(STR_DS_RTL), &gEfiDxeSmmReadyToLockProtocolGuid, NULL},\r
1826 {STRING_TOKEN(STR_S_COMM), &gEfiSmmCommunicationProtocolGuid, NULL},\r
1827 {STRING_TOKEN(STR_S_STAT), &gEfiSmmStatusCodeProtocolGuid, NULL},\r
1828 {STRING_TOKEN(STR_S_CPU), &gEfiSmmCpuProtocolGuid, NULL},\r
1829 {STRING_TOKEN(STR_S_PCIRBIO), &gEfiPciRootBridgeIoProtocolGuid, NULL},\r
1830 {STRING_TOKEN(STR_S_SWD), &gEfiSmmSwDispatch2ProtocolGuid, NULL},\r
1831 {STRING_TOKEN(STR_S_SXD), &gEfiSmmSxDispatch2ProtocolGuid, NULL},\r
1832 {STRING_TOKEN(STR_S_PTD2), &gEfiSmmPeriodicTimerDispatch2ProtocolGuid, NULL},\r
1833 {STRING_TOKEN(STR_S_UD2), &gEfiSmmUsbDispatch2ProtocolGuid, NULL},\r
1834 {STRING_TOKEN(STR_S_GD2), &gEfiSmmGpiDispatch2ProtocolGuid, NULL},\r
1835 {STRING_TOKEN(STR_S_SBD2), &gEfiSmmStandbyButtonDispatch2ProtocolGuid, NULL},\r
1836 {STRING_TOKEN(STR_S_PBD2), &gEfiSmmPowerButtonDispatch2ProtocolGuid, NULL},\r
1837 {STRING_TOKEN(STR_S_ITD2), &gEfiSmmIoTrapDispatch2ProtocolGuid, NULL},\r
1838 {STRING_TOKEN(STR_PCD), &gEfiPcdProtocolGuid, NULL},\r
1839 {STRING_TOKEN(STR_FVB2), &gEfiFirmwareVolumeBlock2ProtocolGuid, NULL},\r
1840 {STRING_TOKEN(STR_CPUIO2), &gEfiCpuIo2ProtocolGuid, NULL},\r
1841 {STRING_TOKEN(STR_LEGACY_R2), &gEfiLegacyRegion2ProtocolGuid, NULL},\r
1842 {STRING_TOKEN(STR_SAL_MIP), &gEfiSalMcaInitPmiProtocolGuid, NULL},\r
1843 {STRING_TOKEN(STR_ES_BS), &gEfiExtendedSalBootServiceProtocolGuid, NULL},\r
1844 {STRING_TOKEN(STR_ES_BIO), &gEfiExtendedSalBaseIoServicesProtocolGuid, NULL},\r
1845 {STRING_TOKEN(STR_ES_STALL), &gEfiExtendedSalStallServicesProtocolGuid, NULL},\r
1846 {STRING_TOKEN(STR_ES_RTC), &gEfiExtendedSalRtcServicesProtocolGuid, NULL},\r
1847 {STRING_TOKEN(STR_ES_VS), &gEfiExtendedSalVariableServicesProtocolGuid, NULL},\r
1848 {STRING_TOKEN(STR_ES_MTC), &gEfiExtendedSalMtcServicesProtocolGuid, NULL},\r
1849 {STRING_TOKEN(STR_ES_RESET), &gEfiExtendedSalResetServicesProtocolGuid, NULL},\r
1850 {STRING_TOKEN(STR_ES_SC), &gEfiExtendedSalStatusCodeServicesProtocolGuid, NULL},\r
1851 {STRING_TOKEN(STR_ES_FBS), &gEfiExtendedSalFvBlockServicesProtocolGuid, NULL},\r
1852 {STRING_TOKEN(STR_ES_MP), &gEfiExtendedSalMpServicesProtocolGuid, NULL},\r
1853 {STRING_TOKEN(STR_ES_PAL), &gEfiExtendedSalPalServicesProtocolGuid, NULL},\r
1854 {STRING_TOKEN(STR_ES_BASE), &gEfiExtendedSalBaseServicesProtocolGuid, NULL},\r
1855 {STRING_TOKEN(STR_ES_MCA), &gEfiExtendedSalMcaServicesProtocolGuid, NULL},\r
1856 {STRING_TOKEN(STR_ES_PCI), &gEfiExtendedSalPciServicesProtocolGuid, NULL},\r
1857 {STRING_TOKEN(STR_ES_CACHE), &gEfiExtendedSalCacheServicesProtocolGuid, NULL},\r
1858 {STRING_TOKEN(STR_ES_MCA_LOG), &gEfiExtendedSalMcaLogServicesProtocolGuid, NULL},\r
1859 {STRING_TOKEN(STR_S2ARCH), &gEfiSecurity2ArchProtocolGuid, NULL},\r
1860 {STRING_TOKEN(STR_EODXE), &gEfiSmmEndOfDxeProtocolGuid, NULL},\r
1861 {STRING_TOKEN(STR_ISAHC), &gEfiIsaHcProtocolGuid, NULL},\r
1862 {STRING_TOKEN(STR_ISAHC_B), &gEfiIsaHcServiceBindingProtocolGuid, NULL},\r
1863 {STRING_TOKEN(STR_SIO_C), &gEfiSioControlProtocolGuid, NULL},\r
1864 {STRING_TOKEN(STR_GET_PCD), &gEfiGetPcdInfoProtocolGuid, NULL},\r
1865 {STRING_TOKEN(STR_I2C_M), &gEfiI2cMasterProtocolGuid, NULL},\r
1866 {STRING_TOKEN(STR_I2CIO), &gEfiI2cIoProtocolGuid, NULL},\r
1867 {STRING_TOKEN(STR_I2CEN), &gEfiI2cEnumerateProtocolGuid, NULL},\r
1868 {STRING_TOKEN(STR_I2C_H), &gEfiI2cHostProtocolGuid, NULL},\r
1869 {STRING_TOKEN(STR_I2C_BCM), &gEfiI2cBusConfigurationManagementProtocolGuid, NULL},\r
1870 {STRING_TOKEN(STR_TREE), &gEfiTrEEProtocolGuid, NULL},\r
1871 {STRING_TOKEN(STR_TCG2), &gEfiTcg2ProtocolGuid, NULL},\r
1872 {STRING_TOKEN(STR_TIMESTAMP), &gEfiTimestampProtocolGuid, NULL},\r
1873 {STRING_TOKEN(STR_RNG), &gEfiRngProtocolGuid, NULL},\r
1874 {STRING_TOKEN(STR_NVMEPT), &gEfiNvmExpressPassThruProtocolGuid, NULL},\r
1875 {STRING_TOKEN(STR_H2_SB), &gEfiHash2ServiceBindingProtocolGuid, NULL},\r
1876 {STRING_TOKEN(STR_HASH2), &gEfiHash2ProtocolGuid, NULL},\r
1877 {STRING_TOKEN(STR_BIO_C), &gEfiBlockIoCryptoProtocolGuid, NULL},\r
1878 {STRING_TOKEN(STR_SCR), &gEfiSmartCardReaderProtocolGuid, NULL},\r
1879 {STRING_TOKEN(STR_SCE), &gEfiSmartCardEdgeProtocolGuid, NULL},\r
1880 {STRING_TOKEN(STR_USB_FIO), &gEfiUsbFunctionIoProtocolGuid, NULL},\r
1881 {STRING_TOKEN(STR_BC_HC), &gEfiBluetoothHcProtocolGuid, NULL},\r
1882 {STRING_TOKEN(STR_BC_IO_SB), &gEfiBluetoothIoServiceBindingProtocolGuid, NULL},\r
1883 {STRING_TOKEN(STR_BC_IO), &gEfiBluetoothIoProtocolGuid, NULL},\r
1884 {STRING_TOKEN(STR_BC_C), &gEfiBluetoothConfigProtocolGuid, NULL},\r
1885 {STRING_TOKEN(STR_REG_EXP), &gEfiRegularExpressionProtocolGuid, NULL},\r
1886 {STRING_TOKEN(STR_B_MGR_P), &gEfiBootManagerPolicyProtocolGuid, NULL},\r
1887 {STRING_TOKEN(STR_CKH), &gEfiConfigKeywordHandlerProtocolGuid, NULL},\r
1888 {STRING_TOKEN(STR_WIFI), &gEfiWiFiProtocolGuid, NULL},\r
1889 {STRING_TOKEN(STR_EAP_M), &gEfiEapManagement2ProtocolGuid, NULL},\r
1890 {STRING_TOKEN(STR_EAP_C), &gEfiEapConfigurationProtocolGuid, NULL},\r
1891 {STRING_TOKEN(STR_PKCS7), &gEfiPkcs7VerifyProtocolGuid, NULL},\r
1892 {STRING_TOKEN(STR_NET_DNS4_SB), &gEfiDns4ServiceBindingProtocolGuid, NULL},\r
1893 {STRING_TOKEN(STR_NET_DNS4), &gEfiDns4ProtocolGuid, NULL},\r
1894 {STRING_TOKEN(STR_NET_DNS6_SB), &gEfiDns6ServiceBindingProtocolGuid, NULL},\r
1895 {STRING_TOKEN(STR_NET_DNS6), &gEfiDns6ProtocolGuid, NULL},\r
1896 {STRING_TOKEN(STR_NET_HTTP_SB), &gEfiHttpServiceBindingProtocolGuid, NULL},\r
1897 {STRING_TOKEN(STR_NET_HTTP), &gEfiHttpProtocolGuid, NULL},\r
1898 {STRING_TOKEN(STR_NET_HTTP_U), &gEfiHttpUtilitiesProtocolGuid, NULL},\r
1899 {STRING_TOKEN(STR_REST), &gEfiRestProtocolGuid, NULL},\r
1900\r
0a1eb97d
JC		 1901//\r
1902// UEFI Shell Spec 2.0\r
1903//\r
1904 {STRING_TOKEN(STR_SHELL_PARAMETERS), &gEfiShellParametersProtocolGuid, NULL},\r
1905 {STRING_TOKEN(STR_SHELL), &gEfiShellProtocolGuid, NULL},\r
1906\r
1907//\r
1908// UEFI Shell Spec 2.1\r
1909//\r
1910 {STRING_TOKEN(STR_SHELL_DYNAMIC), &gEfiShellDynamicCommandProtocolGuid, NULL},\r
1911\r
c2788f1c
JC		 1912//\r
1913// Misc\r
1914//\r
1915 {STRING_TOKEN(STR_PCDINFOPROT), &gGetPcdInfoProtocolGuid, NULL},\r
1916\r
dee34318 1917//\r
1918// terminator\r
1919//\r
0e88348e 1920 {0, NULL, NULL},\r
a405b86d 1921};\r
1922\r
1923/**\r
1924 Function to get the node for a protocol or struct from it's GUID.\r
1925\r
1926 if Guid is NULL, then ASSERT.\r
1927\r
1928 @param[in] Guid The GUID to look for the name of.\r
1929\r
1930 @return The node.\r
1931**/\r
dee34318 1932CONST GUID_INFO_BLOCK *\r
a405b86d 1933InternalShellGetNodeFromGuid(\r
1934 IN CONST EFI_GUID* Guid\r
1935 )\r
1936{\r
dee34318 1937 CONST GUID_INFO_BLOCK *ListWalker;\r
6306fd90 1938 UINTN LoopCount;\r
a405b86d 1939\r
1940 ASSERT(Guid != NULL);\r
1941\r
d4ec9a57 1942 for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {\r
6306fd90
JC		 1943 if (CompareGuid(ListWalker->GuidId, Guid)) {\r
1944 return (ListWalker);\r
1945 }\r
1946 }\r
1947\r
a405b86d 1948 if (PcdGetBool(PcdShellIncludeNtGuids)) {\r
1949 for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
1950 if (CompareGuid(ListWalker->GuidId, Guid)) {\r
1951 return (ListWalker);\r
1952 }\r
1953 }\r
1954 }\r
1955 for (ListWalker = mGuidStringList ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
1956 if (CompareGuid(ListWalker->GuidId, Guid)) {\r
1957 return (ListWalker);\r
1958 }\r
1959 }\r
6306fd90
JC		 1960 return (NULL);\r
1961}\r
1962\r
1963/**\r
1964Function to add a new GUID/Name mapping.\r
1965\r
1966@param[in] Guid The Guid\r
f5ba4007
QS		 1967@param[in] NameID The STRING id of the HII string to use\r
1968@param[in] DumpFunc The pointer to the dump function\r
6306fd90
JC		 1969\r
1970\r
1971@retval EFI_SUCCESS The operation was sucessful\r
1972@retval EFI_OUT_OF_RESOURCES A memory allocation failed\r
1973@retval EFI_INVALID_PARAMETER Guid NameId was invalid\r
1974**/\r
6306fd90 1975EFI_STATUS\r
6306fd90
JC		 1976InsertNewGuidNameMapping(\r
1977 IN CONST EFI_GUID *Guid,\r
1978 IN CONST EFI_STRING_ID NameID,\r
1979 IN CONST DUMP_PROTOCOL_INFO DumpFunc OPTIONAL\r
1980 )\r
1981{\r
1982 ASSERT(Guid != NULL);\r
1983 ASSERT(NameID != 0);\r
1984\r
d4ec9a57
RN		 1985 mGuidList = ReallocatePool(mGuidListCount * sizeof(GUID_INFO_BLOCK), mGuidListCount+1 * sizeof(GUID_INFO_BLOCK), mGuidList);\r
1986 if (mGuidList == NULL) {\r
1987 mGuidListCount = 0;\r
6306fd90
JC		 1988 return (EFI_OUT_OF_RESOURCES);\r
1989 }\r
d4ec9a57 1990 mGuidListCount++;\r
6306fd90 1991\r
d4ec9a57
RN		 1992 mGuidList[mGuidListCount - 1].GuidId = AllocateCopyPool(sizeof(EFI_GUID), Guid);\r
1993 mGuidList[mGuidListCount - 1].StringId = NameID;\r
1994 mGuidList[mGuidListCount - 1].DumpInfo = DumpFunc;\r
6306fd90 1995\r
d4ec9a57 1996 if (mGuidList[mGuidListCount - 1].GuidId == NULL) {\r
6306fd90
JC		 1997 return (EFI_OUT_OF_RESOURCES);\r
1998 }\r
1999\r
2000 return (EFI_SUCCESS);\r
2001}\r
2002\r
2003/**\r
2004 Function to add a new GUID/Name mapping.\r
2005\r
2006 This cannot overwrite an existing mapping.\r
2007\r
2008 @param[in] Guid The Guid\r
2009 @param[in] TheName The Guid's name\r
2010 @param[in] Lang RFC4646 language code list or NULL\r
2011\r
2012 @retval EFI_SUCCESS The operation was sucessful\r
2013 @retval EFI_ACCESS_DENIED There was a duplicate\r
2014 @retval EFI_OUT_OF_RESOURCES A memory allocation failed\r
2015 @retval EFI_INVALID_PARAMETER Guid or TheName was NULL\r
2016**/\r
2017EFI_STATUS\r
2018EFIAPI\r
2019AddNewGuidNameMapping(\r
2020 IN CONST EFI_GUID *Guid,\r
2021 IN CONST CHAR16 *TheName,\r
2022 IN CONST CHAR8 *Lang OPTIONAL\r
2023 )\r
2024{\r
6306fd90
JC		 2025 EFI_STRING_ID NameID;\r
2026\r
e7e0e42b
CP		 2027 HandleParsingHiiInit();\r
2028\r
6306fd90
JC		 2029 if (Guid == NULL || TheName == NULL){\r
2030 return (EFI_INVALID_PARAMETER);\r
2031 }\r
2032\r
931b2cff 2033 if ((InternalShellGetNodeFromGuid(Guid)) != NULL) {\r
6306fd90
JC		 2034 return (EFI_ACCESS_DENIED);\r
2035 }\r
2036\r
2037 NameID = HiiSetString(mHandleParsingHiiHandle, 0, (CHAR16*)TheName, Lang);\r
2038 if (NameID == 0) {\r
2039 return (EFI_OUT_OF_RESOURCES);\r
2040 }\r
2041\r
2042 return (InsertNewGuidNameMapping(Guid, NameID, NULL));\r
a405b86d 2043}\r
2044\r
2045/**\r
2046 Function to get the name of a protocol or struct from it's GUID.\r
2047\r
2048 if Guid is NULL, then ASSERT.\r
2049\r
2050 @param[in] Guid The GUID to look for the name of.\r
2051 @param[in] Lang The language to use.\r
2052\r
2053 @return pointer to string of the name. The caller\r
2054 is responsible to free this memory.\r
2055**/\r
2056CHAR16*\r
2057EFIAPI\r
2058GetStringNameFromGuid(\r
2059 IN CONST EFI_GUID *Guid,\r
2060 IN CONST CHAR8 *Lang OPTIONAL\r
2061 )\r
2062{\r
dee34318 2063 CONST GUID_INFO_BLOCK *Id;\r
a405b86d 2064\r
e7e0e42b
CP		 2065 HandleParsingHiiInit();\r
2066\r
a405b86d 2067 Id = InternalShellGetNodeFromGuid(Guid);\r
0e88348e
RN		 2068 if (Id == NULL) {\r
2069 return NULL;\r
2070 }\r
2071 return HiiGetString (mHandleParsingHiiHandle, Id->StringId, Lang);\r
a405b86d 2072}\r
2073\r
2074/**\r
2075 Function to dump protocol information from a handle.\r
2076\r
2077 This function will return a allocated string buffer containing the\r
2078 information. The caller is responsible for freeing the memory.\r
2079\r
2080 If Guid is NULL, ASSERT().\r
2081 If TheHandle is NULL, ASSERT().\r
2082\r
2083 @param[in] TheHandle The handle to dump information from.\r
2084 @param[in] Guid The GUID of the protocol to dump.\r
2085 @param[in] Verbose TRUE for extra info. FALSE otherwise.\r
2086\r
2087 @return The pointer to string.\r
2088 @retval NULL An error was encountered.\r
2089**/\r
2090CHAR16*\r
2091EFIAPI\r
2092GetProtocolInformationDump(\r
2093 IN CONST EFI_HANDLE TheHandle,\r
2094 IN CONST EFI_GUID *Guid,\r
2095 IN CONST BOOLEAN Verbose\r
2096 )\r
2097{\r
dee34318 2098 CONST GUID_INFO_BLOCK *Id;\r
a405b86d 2099\r
2100 ASSERT(TheHandle != NULL);\r
2101 ASSERT(Guid != NULL);\r
2102\r
2103 if (TheHandle == NULL || Guid == NULL) {\r
2104 return (NULL);\r
2105 }\r
2106\r
2107 Id = InternalShellGetNodeFromGuid(Guid);\r
2108 if (Id != NULL && Id->DumpInfo != NULL) {\r
2109 return (Id->DumpInfo(TheHandle, Verbose));\r
2110 }\r
2111 return (NULL);\r
2112}\r
2113\r
2114/**\r
2115 Function to get the Guid for a protocol or struct based on it's string name.\r
2116\r
0a1eb97d
JC		 2117 do not modify the returned Guid.\r
2118\r
a405b86d 2119 @param[in] Name The pointer to the string name.\r
2120 @param[in] Lang The pointer to the language code.\r
0a1eb97d 2121 @param[out] Guid The pointer to the Guid.\r
a405b86d 2122\r
2123 @retval EFI_SUCCESS The operation was sucessful.\r
2124**/\r
2125EFI_STATUS\r
2126EFIAPI\r
2127GetGuidFromStringName(\r
2128 IN CONST CHAR16 *Name,\r
2129 IN CONST CHAR8 *Lang OPTIONAL,\r
0a1eb97d 2130 OUT EFI_GUID **Guid\r
a405b86d 2131 )\r
2132{\r
dee34318 2133 CONST GUID_INFO_BLOCK *ListWalker;\r
a405b86d 2134 CHAR16 *String;\r
6306fd90 2135 UINTN LoopCount;\r
a405b86d 2136\r
e7e0e42b
CP		 2137 HandleParsingHiiInit();\r
2138\r
a405b86d 2139 ASSERT(Guid != NULL);\r
2140 if (Guid == NULL) {\r
2141 return (EFI_INVALID_PARAMETER);\r
2142 }\r
2143 *Guid = NULL;\r
2144\r
2145 if (PcdGetBool(PcdShellIncludeNtGuids)) {\r
2146 for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
2147 String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
28cdb62b 2148 if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
a405b86d 2149 *Guid = ListWalker->GuidId;\r
2150 }\r
2151 SHELL_FREE_NON_NULL(String);\r
2152 if (*Guid != NULL) {\r
2153 return (EFI_SUCCESS);\r
2154 }\r
2155 }\r
2156 }\r
2157 for (ListWalker = mGuidStringList ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
2158 String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
28cdb62b 2159 if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
a405b86d 2160 *Guid = ListWalker->GuidId;\r
2161 }\r
2162 SHELL_FREE_NON_NULL(String);\r
2163 if (*Guid != NULL) {\r
2164 return (EFI_SUCCESS);\r
2165 }\r
2166 }\r
6306fd90 2167\r
d4ec9a57 2168 for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {\r
6306fd90
JC		 2169 String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
2170 if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
2171 *Guid = ListWalker->GuidId;\r
2172 }\r
2173 SHELL_FREE_NON_NULL(String);\r
2174 if (*Guid != NULL) {\r
2175 return (EFI_SUCCESS);\r
2176 }\r
2177 }\r
2178\r
a405b86d 2179 return (EFI_NOT_FOUND);\r
2180}\r
2181\r
36384ceb
ED		 2182/**\r
2183 Get best support language for this driver.\r
1a6f74d9
CS		 2184\r
2185 First base on the user input language to search, second base on the current\r
2186 platform used language to search, third get the first language from the\r
a71003f2 2187 support language list. The caller need to free the buffer of the best language.\r
36384ceb
ED		 2188\r
2189 @param[in] SupportedLanguages The support languages for this driver.\r
a71003f2 2190 @param[in] InputLanguage The user input language.\r
36384ceb
ED		 2191 @param[in] Iso639Language Whether get language for ISO639.\r
2192\r
2193 @return The best support language for this driver.\r
2194**/\r
2195CHAR8 *\r
a71003f2 2196EFIAPI\r
36384ceb 2197GetBestLanguageForDriver (\r
a71003f2
ED		 2198 IN CONST CHAR8 *SupportedLanguages,\r
2199 IN CONST CHAR8 *InputLanguage,\r
36384ceb
ED		 2200 IN BOOLEAN Iso639Language\r
2201 )\r
2202{\r
2203 CHAR8 *LanguageVariable;\r
2204 CHAR8 *BestLanguage;\r
2205\r
3cdd434e 2206 GetVariable2 (Iso639Language ? L"Lang" : L"PlatformLang", &gEfiGlobalVariableGuid, (VOID**)&LanguageVariable, NULL);\r
36384ceb
ED		 2207\r
2208 BestLanguage = GetBestLanguage(\r
2209 SupportedLanguages,\r
2210 Iso639Language,\r
a71003f2 2211 (InputLanguage != NULL) ? InputLanguage : "",\r
36384ceb 2212 (LanguageVariable != NULL) ? LanguageVariable : "",\r
a71003f2 2213 SupportedLanguages,\r
36384ceb
ED		 2214 NULL\r
2215 );\r
2216\r
2217 if (LanguageVariable != NULL) {\r
2218 FreePool (LanguageVariable);\r
2219 }\r
2220\r
2221 return BestLanguage;\r
2222}\r
2223\r
a405b86d 2224/**\r
2225 Function to retrieve the driver name (if possible) from the ComponentName or\r
2226 ComponentName2 protocol\r
2227\r
2228 @param[in] TheHandle The driver handle to get the name of.\r
2229 @param[in] Language The language to use.\r
2230\r
2231 @retval NULL The name could not be found.\r
2232 @return A pointer to the string name. Do not de-allocate the memory.\r
2233**/\r
2234CONST CHAR16*\r
2235EFIAPI\r
2236GetStringNameFromHandle(\r
2237 IN CONST EFI_HANDLE TheHandle,\r
2238 IN CONST CHAR8 *Language\r
2239 )\r
2240{\r
2241 EFI_COMPONENT_NAME2_PROTOCOL *CompNameStruct;\r
2242 EFI_STATUS Status;\r
2243 CHAR16 *RetVal;\r
36384ceb
ED		 2244 CHAR8 *BestLang;\r
2245\r
2246 BestLang = NULL;\r
a405b86d 2247\r
2248 Status = gBS->OpenProtocol(\r
2249 TheHandle,\r
2250 &gEfiComponentName2ProtocolGuid,\r
2251 (VOID**)&CompNameStruct,\r
2252 gImageHandle,\r
2253 NULL,\r
2254 EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
2255 if (!EFI_ERROR(Status)) {\r
a71003f2
ED		 2256 BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);\r
2257 Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);\r
36384ceb
ED		 2258 if (BestLang != NULL) {\r
2259 FreePool (BestLang);\r
2260 BestLang = NULL;\r
2261 }\r
a405b86d 2262 if (!EFI_ERROR(Status)) {\r
2263 return (RetVal);\r
2264 }\r
2265 }\r
2266 Status = gBS->OpenProtocol(\r
2267 TheHandle,\r
2268 &gEfiComponentNameProtocolGuid,\r
2269 (VOID**)&CompNameStruct,\r
2270 gImageHandle,\r
2271 NULL,\r
2272 EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
2273 if (!EFI_ERROR(Status)) {\r
a71003f2
ED		 2274 BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);\r
2275 Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);\r
36384ceb
ED		 2276 if (BestLang != NULL) {\r
2277 FreePool (BestLang);\r
2278 }\r
a405b86d 2279 if (!EFI_ERROR(Status)) {\r
2280 return (RetVal);\r
2281 }\r
2282 }\r
2283 return (NULL);\r
2284}\r
2285\r
2286/**\r
2287 Function to initialize the file global mHandleList object for use in\r
2288 vonverting handles to index and index to handle.\r
2289\r
2290 @retval EFI_SUCCESS The operation was successful.\r
2291**/\r
2292EFI_STATUS\r
a405b86d 2293InternalShellInitHandleList(\r
2294 VOID\r
2295 )\r
2296{\r
2297 EFI_STATUS Status;\r
2298 EFI_HANDLE *HandleBuffer;\r
2299 UINTN HandleCount;\r
2300 HANDLE_LIST *ListWalker;\r
2301\r
2302 if (mHandleList.NextIndex != 0) {\r
2303 return EFI_SUCCESS;\r
2304 }\r
2305 InitializeListHead(&mHandleList.List.Link);\r
2306 mHandleList.NextIndex = 1;\r
2307 Status = gBS->LocateHandleBuffer (\r
2308 AllHandles,\r
2309 NULL,\r
2310 NULL,\r
2311 &HandleCount,\r
2312 &HandleBuffer\r
2313 );\r
2314 ASSERT_EFI_ERROR(Status);\r
2315 if (EFI_ERROR(Status)) {\r
2316 return (Status);\r
2317 }\r
2318 for (mHandleList.NextIndex = 1 ; mHandleList.NextIndex <= HandleCount ; mHandleList.NextIndex++){\r
78ed876b 2319 ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r
aa3276c1
RN		 2320 if (ListWalker != NULL) {\r
2321 ListWalker->TheHandle = HandleBuffer[mHandleList.NextIndex - 1];\r
2322 ListWalker->TheIndex = mHandleList.NextIndex;\r
2323 InsertTailList (&mHandleList.List.Link, &ListWalker->Link);\r
2324 }\r
a405b86d 2325 }\r
2326 FreePool(HandleBuffer);\r
2327 return (EFI_SUCCESS);\r
2328}\r
2329\r
2330/**\r
2331 Function to retrieve the human-friendly index of a given handle. If the handle\r
2332 does not have a index one will be automatically assigned. The index value is valid\r
2333 until the termination of the shell application.\r
2334\r
2335 @param[in] TheHandle The handle to retrieve an index for.\r
2336\r
2337 @retval 0 A memory allocation failed.\r
2338 @return The index of the handle.\r
2339\r
2340**/\r
2341UINTN\r
2342EFIAPI\r
2343ConvertHandleToHandleIndex(\r
2344 IN CONST EFI_HANDLE TheHandle\r
2345 )\r
2346{\r
f330ff35 2347 EFI_STATUS Status;\r
2348 EFI_GUID **ProtocolBuffer;\r
2349 UINTN ProtocolCount;\r
2350 HANDLE_LIST *ListWalker;\r
2351\r
78ed876b 2352 if (TheHandle == NULL) {\r
2353 return 0;\r
2354 }\r
a405b86d 2355\r
2356 InternalShellInitHandleList();\r
2357\r
2358 for (ListWalker = (HANDLE_LIST*)GetFirstNode(&mHandleList.List.Link)\r
2359 ; !IsNull(&mHandleList.List.Link,&ListWalker->Link)\r
2360 ; ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)\r
2361 ){\r
2362 if (ListWalker->TheHandle == TheHandle) {\r
f330ff35 2363 //\r
2364 // Verify that TheHandle is still present in the Handle Database\r
2365 //\r
2366 Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);\r
2367 if (EFI_ERROR (Status)) {\r
2368 //\r
2369 // TheHandle is not present in the Handle Database, so delete from the handle list\r
2370 //\r
2371 RemoveEntryList (&ListWalker->Link);\r
2372 return 0;\r
2373 }\r
2374 FreePool (ProtocolBuffer);\r
a405b86d 2375 return (ListWalker->TheIndex);\r
2376 }\r
2377 }\r
f330ff35 2378\r
2379 //\r
2380 // Verify that TheHandle is valid handle\r
2381 //\r
2382 Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);\r
2383 if (EFI_ERROR (Status)) {\r
2384 //\r
2385 // TheHandle is not valid, so do not add to handle list\r
2386 //\r
2387 return 0;\r
2388 }\r
2389 FreePool (ProtocolBuffer);\r
2390\r
78ed876b 2391 ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r
aa3276c1
RN		 2392 if (ListWalker == NULL) {\r
2393 return 0;\r
2394 }\r
a405b86d 2395 ListWalker->TheHandle = TheHandle;\r
2396 ListWalker->TheIndex = mHandleList.NextIndex++;\r
2397 InsertTailList(&mHandleList.List.Link,&ListWalker->Link);\r
2398 return (ListWalker->TheIndex);\r
2399}\r
2400\r
2401\r
2402\r
2403/**\r
2404 Function to retrieve the EFI_HANDLE from the human-friendly index.\r
2405\r
2406 @param[in] TheIndex The index to retrieve the EFI_HANDLE for.\r
2407\r
2408 @retval NULL The index was invalid.\r
2409 @return The EFI_HANDLE that index represents.\r
2410\r
2411**/\r
2412EFI_HANDLE\r
2413EFIAPI\r
2414ConvertHandleIndexToHandle(\r
2415 IN CONST UINTN TheIndex\r
2416 )\r
2417{\r
f330ff35 2418 EFI_STATUS Status;\r
2419 EFI_GUID **ProtocolBuffer;\r
2420 UINTN ProtocolCount;\r
a405b86d 2421 HANDLE_LIST *ListWalker;\r
2422\r
2423 InternalShellInitHandleList();\r
2424\r
2425 if (TheIndex >= mHandleList.NextIndex) {\r
f330ff35 2426 return NULL;\r
a405b86d 2427 }\r
2428\r
2429 for (ListWalker = (HANDLE_LIST*)GetFirstNode(&mHandleList.List.Link)\r
2430 ; !IsNull(&mHandleList.List.Link,&ListWalker->Link)\r
2431 ; ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)\r
2432 ){\r
f330ff35 2433 if (ListWalker->TheIndex == TheIndex && ListWalker->TheHandle != NULL) {\r
2434 //\r
2435 // Verify that LinkWalker->TheHandle is valid handle\r
2436 //\r
2437 Status = gBS->ProtocolsPerHandle(ListWalker->TheHandle, &ProtocolBuffer, &ProtocolCount);\r
00324f3f
RN		 2438 if (!EFI_ERROR (Status)) {\r
2439 FreePool (ProtocolBuffer);\r
2440 } else {\r
f330ff35 2441 //\r
2442 // TheHandle is not valid, so do not add to handle list\r
2443 //\r
2444 ListWalker->TheHandle = NULL;\r
2445 }\r
a405b86d 2446 return (ListWalker->TheHandle);\r
2447 }\r
2448 }\r
f330ff35 2449 return NULL;\r
a405b86d 2450}\r
2451\r
2452/**\r
2453 Gets all the related EFI_HANDLEs based on the mask supplied.\r
2454\r
2455 This function scans all EFI_HANDLES in the UEFI environment's handle database\r
2456 and returns the ones with the specified relationship (Mask) to the specified\r
2457 controller handle.\r
2458\r
2459 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.\r
2460 If MatchingHandleCount is NULL, then ASSERT.\r
2461\r
2462 If MatchingHandleBuffer is not NULL upon a successful return the memory must be\r
2463 caller freed.\r
2464\r
2465 @param[in] DriverBindingHandle The handle with Driver Binding protocol on it.\r
2466 @param[in] ControllerHandle The handle with Device Path protocol on it.\r
2467 @param[in] MatchingHandleCount The pointer to UINTN that specifies the number of HANDLES in\r
2468 MatchingHandleBuffer.\r
2469 @param[out] MatchingHandleBuffer On a successful return, a buffer of MatchingHandleCount\r
2470 EFI_HANDLEs with a terminating NULL EFI_HANDLE.\r
2471 @param[out] HandleType An array of type information.\r
2472\r
2473 @retval EFI_SUCCESS The operation was successful, and any related handles\r
2474 are in MatchingHandleBuffer.\r
2475 @retval EFI_NOT_FOUND No matching handles were found.\r
2476 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.\r
2477**/\r
2478EFI_STATUS\r
2479EFIAPI\r
2480ParseHandleDatabaseByRelationshipWithType (\r
2481 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL,\r
2482 IN CONST EFI_HANDLE ControllerHandle OPTIONAL,\r
2483 IN UINTN *HandleCount,\r
2484 OUT EFI_HANDLE **HandleBuffer,\r
2485 OUT UINTN **HandleType\r
2486 )\r
2487{\r
2488 EFI_STATUS Status;\r
2489 UINTN HandleIndex;\r
2490 EFI_GUID **ProtocolGuidArray;\r
2491 UINTN ArrayCount;\r
2492 UINTN ProtocolIndex;\r
2493 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo;\r
2494 UINTN OpenInfoCount;\r
2495 UINTN OpenInfoIndex;\r
2496 UINTN ChildIndex;\r
f330ff35 2497 INTN DriverBindingHandleIndex;\r
a405b86d 2498\r
2499 ASSERT(HandleCount != NULL);\r
2500 ASSERT(HandleBuffer != NULL);\r
2501 ASSERT(HandleType != NULL);\r
2502 ASSERT(DriverBindingHandle != NULL || ControllerHandle != NULL);\r
2503\r
2504 *HandleCount = 0;\r
2505 *HandleBuffer = NULL;\r
2506 *HandleType = NULL;\r
2507\r
2508 //\r
2509 // Retrieve the list of all handles from the handle database\r
2510 //\r
2511 Status = gBS->LocateHandleBuffer (\r
2512 AllHandles,\r
2513 NULL,\r
2514 NULL,\r
2515 HandleCount,\r
2516 HandleBuffer\r
2517 );\r
2518 if (EFI_ERROR (Status)) {\r
2519 return (Status);\r
2520 }\r
2521\r
2522 *HandleType = AllocateZeroPool (*HandleCount * sizeof (UINTN));\r
aa3276c1
RN		 2523 if (*HandleType == NULL) {\r
2524 SHELL_FREE_NON_NULL (*HandleBuffer);\r
94fcb76b 2525 *HandleCount = 0;\r
aa3276c1
RN		 2526 return EFI_OUT_OF_RESOURCES;\r
2527 }\r
a405b86d 2528\r
f330ff35 2529 DriverBindingHandleIndex = -1;\r
2530 for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {\r
2531 if (DriverBindingHandle != NULL && (*HandleBuffer)[HandleIndex] == DriverBindingHandle) {\r
2532 DriverBindingHandleIndex = (INTN)HandleIndex;\r
2533 }\r
2534 }\r
2535\r
a405b86d 2536 for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {\r
2537 //\r
2538 // Retrieve the list of all the protocols on each handle\r
2539 //\r
2540 Status = gBS->ProtocolsPerHandle (\r
2541 (*HandleBuffer)[HandleIndex],\r
2542 &ProtocolGuidArray,\r
2543 &ArrayCount\r
2544 );\r
f330ff35 2545 if (EFI_ERROR (Status)) {\r
2546 continue;\r
2547 }\r
a405b86d 2548\r
f330ff35 2549 for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {\r
a405b86d 2550\r
f330ff35 2551 //\r
2552 // Set the bit describing what this handle has\r
2553 //\r
2554 if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiLoadedImageProtocolGuid) ) {\r
7aae3c35 2555 (*HandleType)[HandleIndex] |= (UINTN)HR_IMAGE_HANDLE;\r
f330ff35 2556 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverBindingProtocolGuid) ) {\r
7aae3c35 2557 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_BINDING_HANDLE;\r
f330ff35 2558 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfiguration2ProtocolGuid)) {\r
7aae3c35 2559 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;\r
f330ff35 2560 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfigurationProtocolGuid) ) {\r
7aae3c35 2561 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;\r
f330ff35 2562 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnostics2ProtocolGuid) ) {\r
7aae3c35 2563 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;\r
f330ff35 2564 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnosticsProtocolGuid) ) {\r
7aae3c35 2565 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;\r
f330ff35 2566 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentName2ProtocolGuid) ) {\r
7aae3c35 2567 (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;\r
f330ff35 2568 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentNameProtocolGuid) ) {\r
7aae3c35 2569 (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;\r
f330ff35 2570 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid) ) {\r
7aae3c35 2571 (*HandleType)[HandleIndex] |= (UINTN)HR_DEVICE_HANDLE;\r
f330ff35 2572 }\r
2573 //\r
2574 // Retrieve the list of agents that have opened each protocol\r
2575 //\r
2576 Status = gBS->OpenProtocolInformation (\r
a405b86d 2577 (*HandleBuffer)[HandleIndex],\r
2578 ProtocolGuidArray[ProtocolIndex],\r
2579 &OpenInfo,\r
2580 &OpenInfoCount\r
2581 );\r
f330ff35 2582 if (EFI_ERROR (Status)) {\r
2583 continue;\r
2584 }\r
2585\r
2586 if (ControllerHandle == NULL) {\r
2587 //\r
1a6f74d9 2588 // ControllerHandle == NULL and DriverBindingHandle != NULL.\r
f330ff35 2589 // Return information on all the controller handles that the driver specified by DriverBindingHandle is managing\r
2590 //\r
2591 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
2592 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
7aae3c35 2593 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
f330ff35 2594 if (DriverBindingHandleIndex != -1) {\r
7aae3c35 2595 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
f330ff35 2596 }\r
2597 }\r
2598 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
7aae3c35 2599 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
f330ff35 2600 if (DriverBindingHandleIndex != -1) {\r
7aae3c35 2601 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
f330ff35 2602 }\r
2603 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
2604 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 2605 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
f330ff35 2606 }\r
2607 }\r
2608 }\r
2609 }\r
2610 }\r
2611 if (DriverBindingHandle == NULL && ControllerHandle != NULL) {\r
2612 if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {\r
7aae3c35 2613 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
a405b86d 2614 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
f330ff35 2615 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
2616 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
2617 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 2618 (*HandleType)[ChildIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
f330ff35 2619 }\r
a405b86d 2620 }\r
f330ff35 2621 }\r
2622 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
2623 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
2624 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 2625 (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
f330ff35 2626 }\r
2627 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 2628 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
a405b86d 2629 }\r
2630 }\r
2631 }\r
f330ff35 2632 }\r
2633 } else {\r
2634 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
2635 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
2636 if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {\r
7aae3c35 2637 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
f330ff35 2638 }\r
2639 }\r
2640 }\r
2641 }\r
2642 }\r
2643 if (DriverBindingHandle != NULL && ControllerHandle != NULL) {\r
2644 if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {\r
7aae3c35 2645 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
f330ff35 2646 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
2647 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
2648 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {\r
2649 if (DriverBindingHandleIndex != -1) {\r
7aae3c35 2650 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
a405b86d 2651 }\r
2652 }\r
f330ff35 2653 }\r
2654 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
2655 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {\r
a405b86d 2656 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
f330ff35 2657 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 2658 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
a405b86d 2659 }\r
2660 }\r
2661 }\r
f330ff35 2662\r
2663 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
2664 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 2665 (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
f330ff35 2666 }\r
2667 }\r
2668 }\r
2669 }\r
2670 } else {\r
2671 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
2672 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
2673 if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {\r
7aae3c35 2674 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
f330ff35 2675 }\r
a405b86d 2676 }\r
2677 }\r
a405b86d 2678 }\r
2679 }\r
f330ff35 2680 FreePool (OpenInfo);\r
a405b86d 2681 }\r
f330ff35 2682 FreePool (ProtocolGuidArray);\r
a405b86d 2683 }\r
f330ff35 2684 return EFI_SUCCESS;\r
a405b86d 2685}\r
2686\r
2687/**\r
2688 Gets all the related EFI_HANDLEs based on the single EFI_HANDLE and the mask\r
2689 supplied.\r
2690\r
2691 This function will scan all EFI_HANDLES in the UEFI environment's handle database\r
2692 and return all the ones with the specified relationship (Mask) to the specified\r
2693 controller handle.\r
2694\r
2695 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.\r
2696 If MatchingHandleCount is NULL, then ASSERT.\r
2697\r
2698 If MatchingHandleBuffer is not NULL upon a sucessful return the memory must be\r
2699 caller freed.\r
2700\r
2701 @param[in] DriverBindingHandle Handle to a object with Driver Binding protocol\r
2702 on it.\r
2703 @param[in] ControllerHandle Handle to a device with Device Path protocol on it.\r
2704 @param[in] Mask Mask of what relationship(s) is desired.\r
2705 @param[in] MatchingHandleCount Poitner to UINTN specifying number of HANDLES in\r
2706 MatchingHandleBuffer.\r
2707 @param[out] MatchingHandleBuffer On a sucessful return a buffer of MatchingHandleCount\r
2708 EFI_HANDLEs and a terminating NULL EFI_HANDLE.\r
2709\r
2710 @retval EFI_SUCCESS The operation was sucessful and any related handles\r
2711 are in MatchingHandleBuffer;\r
2712 @retval EFI_NOT_FOUND No matching handles were found.\r
2713 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.\r
2714**/\r
2715EFI_STATUS\r
2716EFIAPI\r
2717ParseHandleDatabaseByRelationship (\r
2718 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL,\r
2719 IN CONST EFI_HANDLE ControllerHandle OPTIONAL,\r
2720 IN CONST UINTN Mask,\r
2721 IN UINTN *MatchingHandleCount,\r
2722 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
2723 )\r
2724{\r
2725 EFI_STATUS Status;\r
2726 UINTN HandleCount;\r
2727 EFI_HANDLE *HandleBuffer;\r
2728 UINTN *HandleType;\r
2729 UINTN HandleIndex;\r
2730\r
2731 ASSERT(MatchingHandleCount != NULL);\r
2732 ASSERT(DriverBindingHandle != NULL || ControllerHandle != NULL);\r
2733\r
2734 if ((Mask & HR_VALID_MASK) != Mask) {\r
2735 return (EFI_INVALID_PARAMETER);\r
2736 }\r
2737\r
2738 if ((Mask & HR_CHILD_HANDLE) != 0 && DriverBindingHandle == NULL) {\r
2739 return (EFI_INVALID_PARAMETER);\r
2740 }\r
2741\r
2742 *MatchingHandleCount = 0;\r
2743 if (MatchingHandleBuffer != NULL) {\r
2744 *MatchingHandleBuffer = NULL;\r
2745 }\r
2746\r
2747 HandleBuffer = NULL;\r
2748 HandleType = NULL;\r
2749\r
2750 Status = ParseHandleDatabaseByRelationshipWithType (\r
2751 DriverBindingHandle,\r
2752 ControllerHandle,\r
2753 &HandleCount,\r
2754 &HandleBuffer,\r
2755 &HandleType\r
2756 );\r
2757 if (!EFI_ERROR (Status)) {\r
2758 //\r
2759 // Count the number of handles that match the attributes in Mask\r
2760 //\r
2761 for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {\r
2762 if ((HandleType[HandleIndex] & Mask) == Mask) {\r
2763 (*MatchingHandleCount)++;\r
2764 }\r
2765 }\r
2766 //\r
2767 // If no handles match the attributes in Mask then return EFI_NOT_FOUND\r
2768 //\r
2769 if (*MatchingHandleCount == 0) {\r
2770 Status = EFI_NOT_FOUND;\r
2771 } else {\r
2772\r
2773 if (MatchingHandleBuffer == NULL) {\r
2774 //\r
2775 // Someone just wanted the count...\r
2776 //\r
2777 Status = EFI_SUCCESS;\r
2778 } else {\r
2779 //\r
2780 // Allocate a handle buffer for the number of handles that matched the attributes in Mask\r
2781 //\r
78ed876b 2782 *MatchingHandleBuffer = AllocateZeroPool ((*MatchingHandleCount +1)* sizeof (EFI_HANDLE));\r
94fcb76b
RN		 2783 if (*MatchingHandleBuffer == NULL) {\r
2784 Status = EFI_OUT_OF_RESOURCES;\r
2785 } else {\r
aa3276c1
RN		 2786 for (HandleIndex = 0, *MatchingHandleCount = 0\r
2787 ; HandleIndex < HandleCount\r
2788 ; HandleIndex++\r
2789 ) {\r
2790 //\r
2791 // Fill the allocated buffer with the handles that matched the attributes in Mask\r
2792 //\r
2793 if ((HandleType[HandleIndex] & Mask) == Mask) {\r
2794 (*MatchingHandleBuffer)[(*MatchingHandleCount)++] = HandleBuffer[HandleIndex];\r
2795 }\r
2796 }\r
a405b86d 2797\r
a405b86d 2798 //\r
aa3276c1 2799 // Make the last one NULL\r
a405b86d 2800 //\r
aa3276c1 2801 (*MatchingHandleBuffer)[*MatchingHandleCount] = NULL;\r
a405b86d 2802\r
aa3276c1 2803 Status = EFI_SUCCESS;\r
94fcb76b 2804 } // *MatchingHandleBuffer == NULL (ELSE)\r
a405b86d 2805 } // MacthingHandleBuffer == NULL (ELSE)\r
2806 } // *MatchingHandleCount == 0 (ELSE)\r
2807 } // no error on ParseHandleDatabaseByRelationshipWithType\r
2808\r
2809 if (HandleBuffer != NULL) {\r
2810 FreePool (HandleBuffer);\r
2811 }\r
2812\r
2813 if (HandleType != NULL) {\r
2814 FreePool (HandleType);\r
2815 }\r
2816\r
94fcb76b
RN		 2817 ASSERT ((MatchingHandleBuffer == NULL) ||\r
2818 (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||\r
2819 (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL));\r
a405b86d 2820 return Status;\r
2821}\r
2822\r
2823/**\r
2824 Gets handles for any child controllers of the passed in controller.\r
2825\r
2826 @param[in] ControllerHandle The handle of the "parent controller"\r
b6c54204 2827 @param[out] MatchingHandleCount Pointer to the number of handles in\r
a405b86d 2828 MatchingHandleBuffer on return.\r
2829 @param[out] MatchingHandleBuffer Buffer containing handles on a successful\r
2830 return.\r
2831\r
2832\r
2833 @retval EFI_SUCCESS The operation was sucessful.\r
2834**/\r
2835EFI_STATUS\r
2836EFIAPI\r
2837ParseHandleDatabaseForChildControllers(\r
2838 IN CONST EFI_HANDLE ControllerHandle,\r
b6c54204 2839 OUT UINTN *MatchingHandleCount,\r
a405b86d 2840 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
2841 )\r
2842{\r
2843 EFI_STATUS Status;\r
f330ff35 2844 UINTN HandleIndex;\r
a405b86d 2845 UINTN DriverBindingHandleCount;\r
2846 EFI_HANDLE *DriverBindingHandleBuffer;\r
2847 UINTN DriverBindingHandleIndex;\r
2848 UINTN ChildControllerHandleCount;\r
2849 EFI_HANDLE *ChildControllerHandleBuffer;\r
2850 UINTN ChildControllerHandleIndex;\r
a405b86d 2851 EFI_HANDLE *HandleBufferForReturn;\r
2852\r
ff51746b 2853 if (MatchingHandleCount == NULL) {\r
2854 return (EFI_INVALID_PARAMETER);\r
2855 }\r
64d753f1 2856 *MatchingHandleCount = 0;\r
a405b86d 2857\r
2858 Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (\r
2859 ControllerHandle,\r
2860 &DriverBindingHandleCount,\r
2861 &DriverBindingHandleBuffer\r
2862 );\r
2863 if (EFI_ERROR (Status)) {\r
2864 return Status;\r
2865 }\r
2866\r
ff51746b 2867 //\r
2868 // Get a buffer big enough for all the controllers.\r
2869 //\r
f330ff35 2870 HandleBufferForReturn = GetHandleListByProtocol(NULL);\r
a405b86d 2871 if (HandleBufferForReturn == NULL) {\r
2872 FreePool (DriverBindingHandleBuffer);\r
ff51746b 2873 return (EFI_NOT_FOUND);\r
a405b86d 2874 }\r
2875\r
a405b86d 2876 for (DriverBindingHandleIndex = 0; DriverBindingHandleIndex < DriverBindingHandleCount; DriverBindingHandleIndex++) {\r
2877 Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (\r
2878 DriverBindingHandleBuffer[DriverBindingHandleIndex],\r
2879 ControllerHandle,\r
2880 &ChildControllerHandleCount,\r
2881 &ChildControllerHandleBuffer\r
2882 );\r
2883 if (EFI_ERROR (Status)) {\r
2884 continue;\r
2885 }\r
2886\r
2887 for (ChildControllerHandleIndex = 0;\r
2888 ChildControllerHandleIndex < ChildControllerHandleCount;\r
2889 ChildControllerHandleIndex++\r
2890 ) {\r
f330ff35 2891 for (HandleIndex = 0; HandleIndex < *MatchingHandleCount; HandleIndex++) {\r
2892 if (HandleBufferForReturn[HandleIndex] == ChildControllerHandleBuffer[ChildControllerHandleIndex]) {\r
2893 break;\r
2894 }\r
2895 }\r
2896 if (HandleIndex >= *MatchingHandleCount) {\r
2897 HandleBufferForReturn[(*MatchingHandleCount)++] = ChildControllerHandleBuffer[ChildControllerHandleIndex];\r
2898 }\r
a405b86d 2899 }\r
2900\r
2901 FreePool (ChildControllerHandleBuffer);\r
2902 }\r
2903\r
2904 FreePool (DriverBindingHandleBuffer);\r
2905\r
7eb3bb6c
LE		 2906 if (MatchingHandleBuffer == NULL || *MatchingHandleCount == 0) {\r
2907 //\r
2908 // The caller is not interested in the actual handles, or we've found none.\r
2909 //\r
2910 FreePool (HandleBufferForReturn);\r
2911 HandleBufferForReturn = NULL;\r
2912 }\r
2913\r
a405b86d 2914 if (MatchingHandleBuffer != NULL) {\r
2915 *MatchingHandleBuffer = HandleBufferForReturn;\r
a405b86d 2916 }\r
7eb3bb6c 2917\r
94fcb76b
RN		 2918 ASSERT ((MatchingHandleBuffer == NULL) ||\r
2919 (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||\r
2920 (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL));\r
a405b86d 2921\r
2922 return (EFI_SUCCESS);\r
2923}\r
2924\r
2925/**\r
2926 Appends 1 buffer to another buffer. This will re-allocate the destination buffer\r
2927 if necessary to fit all of the data.\r
2928\r
2929 If DestinationBuffer is NULL, then ASSERT().\r
2930\r
4ff7e37b
ED		 2931 @param[in, out] DestinationBuffer The pointer to the pointer to the buffer to append onto.\r
2932 @param[in, out] DestinationSize The pointer to the size of DestinationBuffer.\r
2933 @param[in] SourceBuffer The pointer to the buffer to append onto DestinationBuffer.\r
2934 @param[in] SourceSize The number of bytes of SourceBuffer to append.\r
a405b86d 2935\r
2936 @retval NULL A memory allocation failed.\r
2937 @retval NULL A parameter was invalid.\r
2938 @return A pointer to (*DestinationBuffer).\r
2939**/\r
2940VOID*\r
a405b86d 2941BuffernCatGrow (\r
2942 IN OUT VOID **DestinationBuffer,\r
2943 IN OUT UINTN *DestinationSize,\r
2944 IN VOID *SourceBuffer,\r
2945 IN UINTN SourceSize\r
2946 )\r
2947{\r
2948 UINTN LocalDestinationSize;\r
2949 UINTN LocalDestinationFinalSize;\r
2950\r
2951 ASSERT(DestinationBuffer != NULL);\r
2952\r
2953 if (SourceSize == 0 || SourceBuffer == NULL) {\r
2954 return (*DestinationBuffer);\r
2955 }\r
2956\r
2957 if (DestinationSize == NULL) {\r
2958 LocalDestinationSize = 0;\r
2959 } else {\r
2960 LocalDestinationSize = *DestinationSize;\r
2961 }\r
2962\r
2963 LocalDestinationFinalSize = LocalDestinationSize + SourceSize;\r
2964\r
2965 if (DestinationSize != NULL) {\r
2966 *DestinationSize = LocalDestinationSize;\r
2967 }\r
2968\r
2969 if (LocalDestinationSize == 0) {\r
2970 // allcoate\r
78ed876b 2971 *DestinationBuffer = AllocateZeroPool(LocalDestinationFinalSize);\r
a405b86d 2972 } else {\r
2973 // reallocate\r
2974 *DestinationBuffer = ReallocatePool(LocalDestinationSize, LocalDestinationFinalSize, *DestinationBuffer);\r
2975 }\r
2976\r
2977 ASSERT(*DestinationBuffer != NULL);\r
2978\r
2979 // copy\r
2980 return (CopyMem(((UINT8*)(*DestinationBuffer)) + LocalDestinationSize, SourceBuffer, SourceSize));\r
2981}\r
2982\r
2983/**\r
2984 Gets handles for any child devices produced by the passed in driver.\r
2985\r
2986 @param[in] DriverHandle The handle of the driver.\r
2987 @param[in] MatchingHandleCount Pointer to the number of handles in\r
2988 MatchingHandleBuffer on return.\r
2989 @param[out] MatchingHandleBuffer Buffer containing handles on a successful\r
2990 return.\r
2991 @retval EFI_SUCCESS The operation was sucessful.\r
2992 @sa ParseHandleDatabaseByRelationship\r
2993**/\r
2994EFI_STATUS\r
2995EFIAPI\r
2996ParseHandleDatabaseForChildDevices(\r
2997 IN CONST EFI_HANDLE DriverHandle,\r
2998 IN UINTN *MatchingHandleCount,\r
2999 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
3000 )\r
3001{\r
3002 EFI_HANDLE *Buffer;\r
3003 EFI_HANDLE *Buffer2;\r
3004 UINTN Count1;\r
3005 UINTN Count2;\r
3006 UINTN HandleIndex;\r
3007 EFI_STATUS Status;\r
3008 UINTN HandleBufferSize;\r
3009\r
3010 ASSERT(MatchingHandleCount != NULL);\r
3011\r
3012 HandleBufferSize = 0;\r
3013 Buffer = NULL;\r
3014 Buffer2 = NULL;\r
3015 *MatchingHandleCount = 0;\r
3016\r
3017 Status = PARSE_HANDLE_DATABASE_DEVICES (\r
3018 DriverHandle,\r
3019 &Count1,\r
3020 &Buffer\r
3021 );\r
3022 if (!EFI_ERROR (Status)) {\r
3023 for (HandleIndex = 0; HandleIndex < Count1; HandleIndex++) {\r
3024 //\r
3025 // now find the children\r
3026 //\r
3027 Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (\r
3028 DriverHandle,\r
3029 Buffer[HandleIndex],\r
3030 &Count2,\r
3031 &Buffer2\r
3032 );\r
3033 if (EFI_ERROR(Status)) {\r
3034 break;\r
3035 }\r
3036 //\r
3037 // save out required and optional data elements\r
3038 //\r
3039 *MatchingHandleCount += Count2;\r
3040 if (MatchingHandleBuffer != NULL) {\r
3041 *MatchingHandleBuffer = BuffernCatGrow((VOID**)MatchingHandleBuffer, &HandleBufferSize, Buffer2, Count2 * sizeof(Buffer2[0]));\r
3042 }\r
3043\r
3044 //\r
3045 // free the memory\r
3046 //\r
3047 if (Buffer2 != NULL) {\r
3048 FreePool(Buffer2);\r
3049 }\r
3050 }\r
3051 }\r
3052\r
3053 if (Buffer != NULL) {\r
3054 FreePool(Buffer);\r
3055 }\r
3056 return (Status);\r
3057}\r
3058\r
3059/**\r
3060 Function to get all handles that support a given protocol or all handles.\r
3061\r
3062 @param[in] ProtocolGuid The guid of the protocol to get handles for. If NULL\r
3063 then the function will return all handles.\r
3064\r
3065 @retval NULL A memory allocation failed.\r
3066 @return A NULL terminated list of handles.\r
3067**/\r
3068EFI_HANDLE*\r
3069EFIAPI\r
40d7a9cf 3070GetHandleListByProtocol (\r
a405b86d 3071 IN CONST EFI_GUID *ProtocolGuid OPTIONAL\r
3072 )\r
3073{\r
3074 EFI_HANDLE *HandleList;\r
3075 UINTN Size;\r
3076 EFI_STATUS Status;\r
3077\r
3078 Size = 0;\r
3079 HandleList = NULL;\r
3080\r
3081 //\r
3082 // We cannot use LocateHandleBuffer since we need that NULL item on the ends of the list!\r
3083 //\r
3084 if (ProtocolGuid == NULL) {\r
3085 Status = gBS->LocateHandle(AllHandles, NULL, NULL, &Size, HandleList);\r
3086 if (Status == EFI_BUFFER_TOO_SMALL) {\r
78ed876b 3087 HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));\r
40d7a9cf 3088 if (HandleList == NULL) {\r
3089 return (NULL);\r
3090 }\r
a405b86d 3091 Status = gBS->LocateHandle(AllHandles, NULL, NULL, &Size, HandleList);\r
3092 HandleList[Size/sizeof(EFI_HANDLE)] = NULL;\r
3093 }\r
3094 } else {\r
3095 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)ProtocolGuid, NULL, &Size, HandleList);\r
3096 if (Status == EFI_BUFFER_TOO_SMALL) {\r
78ed876b 3097 HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));\r
40d7a9cf 3098 if (HandleList == NULL) {\r
3099 return (NULL);\r
3100 }\r
a405b86d 3101 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)ProtocolGuid, NULL, &Size, HandleList);\r
3102 HandleList[Size/sizeof(EFI_HANDLE)] = NULL;\r
3103 }\r
3104 }\r
3105 if (EFI_ERROR(Status)) {\r
3106 if (HandleList != NULL) {\r
3107 FreePool(HandleList);\r
3108 }\r
3109 return (NULL);\r
3110 }\r
3111 return (HandleList);\r
3112}\r
3113\r
3114/**\r
3115 Function to get all handles that support some protocols.\r
3116\r
3117 @param[in] ProtocolGuids A NULL terminated list of protocol GUIDs.\r
3118\r
3119 @retval NULL A memory allocation failed.\r
ff51746b 3120 @retval NULL ProtocolGuids was NULL.\r
3121 @return A NULL terminated list of EFI_HANDLEs.\r
a405b86d 3122**/\r
3123EFI_HANDLE*\r
3124EFIAPI\r
40d7a9cf 3125GetHandleListByProtocolList (\r
a405b86d 3126 IN CONST EFI_GUID **ProtocolGuids\r
3127 )\r
3128{\r
3129 EFI_HANDLE *HandleList;\r
3130 UINTN Size;\r
3131 UINTN TotalSize;\r
40d7a9cf 3132 UINTN TempSize;\r
a405b86d 3133 EFI_STATUS Status;\r
3134 CONST EFI_GUID **GuidWalker;\r
3135 EFI_HANDLE *HandleWalker1;\r
3136 EFI_HANDLE *HandleWalker2;\r
3137\r
3138 Size = 0;\r
3139 HandleList = NULL;\r
3140 TotalSize = sizeof(EFI_HANDLE);\r
3141\r
3142 for (GuidWalker = ProtocolGuids ; GuidWalker != NULL && *GuidWalker != NULL ; GuidWalker++,Size = 0){\r
3143 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &Size, NULL);\r
3144 if (Status == EFI_BUFFER_TOO_SMALL) {\r
3145 TotalSize += Size;\r
3146 }\r
3147 }\r
40d7a9cf 3148\r
3149 //\r
e918029f 3150 // No handles were found...\r
40d7a9cf 3151 //\r
3152 if (TotalSize == sizeof(EFI_HANDLE)) {\r
3153 return (NULL);\r
3154 }\r
3155\r
3156 HandleList = AllocateZeroPool(TotalSize);\r
a405b86d 3157 if (HandleList == NULL) {\r
3158 return (NULL);\r
3159 }\r
3160\r
3161 Size = 0;\r
3162 for (GuidWalker = ProtocolGuids ; GuidWalker != NULL && *GuidWalker != NULL ; GuidWalker++){\r
40d7a9cf 3163 TempSize = TotalSize - Size;\r
ff51746b 3164 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &TempSize, HandleList+(Size/sizeof(EFI_HANDLE)));\r
40d7a9cf 3165\r
3166 //\r
3167 // Allow for missing protocols... Only update the 'used' size upon success.\r
3168 //\r
3169 if (!EFI_ERROR(Status)) {\r
ff51746b 3170 Size += TempSize;\r
40d7a9cf 3171 }\r
a405b86d 3172 }\r
ff51746b 3173 ASSERT(HandleList[(TotalSize/sizeof(EFI_HANDLE))-1] == NULL);\r
a405b86d 3174\r
3175 for (HandleWalker1 = HandleList ; HandleWalker1 != NULL && *HandleWalker1 != NULL ; HandleWalker1++) {\r
3176 for (HandleWalker2 = HandleWalker1 + 1; HandleWalker2 != NULL && *HandleWalker2 != NULL ; HandleWalker2++) {\r
3177 if (*HandleWalker1 == *HandleWalker2) {\r
3178 //\r
3179 // copy memory back 1 handle width.\r
3180 //\r
3181 CopyMem(HandleWalker2, HandleWalker2 + 1, TotalSize - ((HandleWalker2-HandleList+1)*sizeof(EFI_HANDLE)));\r
3182 }\r
3183 }\r
3184 }\r
3185\r
3186 return (HandleList);\r
3187}\r
0976f908
CC		 3188\r
3189/**\r
3190 Return all supported GUIDs.\r
3191\r
3192 @param[out] Guids The buffer to return all supported GUIDs.\r
3193 @param[in, out] Count On input, the count of GUIDs the buffer can hold,\r
3194 On output, the count of GUIDs to return.\r
3195\r
3196 @retval EFI_INVALID_PARAMETER Count is NULL.\r
3197 @retval EFI_BUFFER_TOO_SMALL Buffer is not enough to hold all GUIDs.\r
3198 @retval EFI_SUCCESS GUIDs are returned successfully.\r
3199**/\r
3200EFI_STATUS\r
3201EFIAPI\r
3202GetAllMappingGuids (\r
3203 OUT EFI_GUID *Guids,\r
3204 IN OUT UINTN *Count\r
3205 )\r
3206{\r
3207 UINTN GuidCount;\r
7c14bc87 3208 UINTN NtGuidCount;\r
0976f908
CC		 3209 UINTN Index;\r
3210\r
3211 if (Count == NULL) {\r
3212 return EFI_INVALID_PARAMETER;\r
3213 }\r
3214\r
3215 NtGuidCount = 0;\r
3216 if (PcdGetBool (PcdShellIncludeNtGuids)) {\r
3217 NtGuidCount = ARRAY_SIZE (mGuidStringListNT) - 1;\r
3218 }\r
3219 GuidCount = ARRAY_SIZE (mGuidStringList) - 1;\r
3220\r
3221 if (*Count < NtGuidCount + GuidCount + mGuidListCount) {\r
3222 *Count = NtGuidCount + GuidCount + mGuidListCount;\r
3223 return EFI_BUFFER_TOO_SMALL;\r
3224 }\r
3225\r
3226 for (Index = 0; Index < NtGuidCount; Index++) {\r
3227 CopyGuid (&Guids[Index], mGuidStringListNT[Index].GuidId);\r
3228 }\r
3229\r
3230 for (Index = 0; Index < GuidCount; Index++) {\r
3231 CopyGuid (&Guids[NtGuidCount + Index], mGuidStringList[Index].GuidId);\r
3232 }\r
3233\r
3234 for (Index = 0; Index < mGuidListCount; Index++) {\r
3235 CopyGuid (&Guids[NtGuidCount + GuidCount + Index], mGuidList[Index].GuidId);\r
3236 }\r
3237\r
3238 return EFI_SUCCESS;\r
3239}\r
EFI Development Kit II mirror for PVE