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