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