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