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