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