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