]> 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
MdePkg/Include: EFI Redfish Discover protocol
[mirror_edk2.git] / ShellPkg / Library / UefiHandleParsingLib / UefiHandleParsingLib.c
CommitLineData
a405b86d 1/** @file\r
2 Provides interface to advanced shell functionality for parsing both handle and protocol database.\r
3\r
d4ec9a57 4 Copyright (c) 2010 - 2017, Intel Corporation. All rights reserved.<BR>\r
256aa6d0 5 (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>\r
8985d612 6 (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>\r
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
6b640b4a
JC		 2253//\r
2254// PI Spec ones\r
2255//\r
2256 {STRING_TOKEN(STR_IDE_CONT_INIT), &gEfiIdeControllerInitProtocolGuid, NULL},\r
4024c116 2257 {STRING_TOKEN(STR_DISK_INFO), &gEfiDiskInfoProtocolGuid, NULL},\r
6b640b4a 2258\r
c2788f1c
JC		 2259//\r
2260// PI Spec 1.0\r
2261//\r
2262 {STRING_TOKEN(STR_BDS_ARCH), &gEfiBdsArchProtocolGuid, NULL},\r
2263 {STRING_TOKEN(STR_CPU_ARCH), &gEfiCpuArchProtocolGuid, NULL},\r
2264 {STRING_TOKEN(STR_MET_ARCH), &gEfiMetronomeArchProtocolGuid, NULL},\r
2265 {STRING_TOKEN(STR_MON_ARCH), &gEfiMonotonicCounterArchProtocolGuid, NULL},\r
2266 {STRING_TOKEN(STR_RTC_ARCH), &gEfiRealTimeClockArchProtocolGuid, NULL},\r
2267 {STRING_TOKEN(STR_RESET_ARCH), &gEfiResetArchProtocolGuid, NULL},\r
2268 {STRING_TOKEN(STR_RT_ARCH), &gEfiRuntimeArchProtocolGuid, NULL},\r
2269 {STRING_TOKEN(STR_SEC_ARCH), &gEfiSecurityArchProtocolGuid, NULL},\r
2270 {STRING_TOKEN(STR_TIMER_ARCH), &gEfiTimerArchProtocolGuid, NULL},\r
2271 {STRING_TOKEN(STR_VAR_ARCH), &gEfiVariableWriteArchProtocolGuid, NULL},\r
2272 {STRING_TOKEN(STR_V_ARCH), &gEfiVariableArchProtocolGuid, NULL},\r
2273 {STRING_TOKEN(STR_SECP), &gEfiSecurityPolicyProtocolGuid, NULL},\r
2274 {STRING_TOKEN(STR_WDT_ARCH), &gEfiWatchdogTimerArchProtocolGuid, NULL},\r
2275 {STRING_TOKEN(STR_SCR), &gEfiStatusCodeRuntimeProtocolGuid, NULL},\r
2276 {STRING_TOKEN(STR_SMB_HC), &gEfiSmbusHcProtocolGuid, NULL},\r
2277 {STRING_TOKEN(STR_FV_2), &gEfiFirmwareVolume2ProtocolGuid, NULL},\r
2278 {STRING_TOKEN(STR_FV_BLOCK), &gEfiFirmwareVolumeBlockProtocolGuid, NULL},\r
2279 {STRING_TOKEN(STR_CAP_ARCH), &gEfiCapsuleArchProtocolGuid, NULL},\r
2280 {STRING_TOKEN(STR_MP_SERVICE), &gEfiMpServiceProtocolGuid, NULL},\r
2281 {STRING_TOKEN(STR_HBRAP), &gEfiPciHostBridgeResourceAllocationProtocolGuid, NULL},\r
2282 {STRING_TOKEN(STR_PCIP), &gEfiPciPlatformProtocolGuid, NULL},\r
2283 {STRING_TOKEN(STR_PCIO), &gEfiPciOverrideProtocolGuid, NULL},\r
2284 {STRING_TOKEN(STR_PCIE), &gEfiPciEnumerationCompleteProtocolGuid, NULL},\r
2285 {STRING_TOKEN(STR_IPCID), &gEfiIncompatiblePciDeviceSupportProtocolGuid, NULL},\r
2286 {STRING_TOKEN(STR_PCIHPI), &gEfiPciHotPlugInitProtocolGuid, NULL},\r
2287 {STRING_TOKEN(STR_PCIHPR), &gEfiPciHotPlugRequestProtocolGuid, NULL},\r
2288 {STRING_TOKEN(STR_SMBIOS), &gEfiSmbiosProtocolGuid, NULL},\r
2289 {STRING_TOKEN(STR_S3_SAVE), &gEfiS3SaveStateProtocolGuid, NULL},\r
2290 {STRING_TOKEN(STR_S3_S_SMM), &gEfiS3SmmSaveStateProtocolGuid, NULL},\r
2291 {STRING_TOKEN(STR_RSC), &gEfiRscHandlerProtocolGuid, NULL},\r
2292 {STRING_TOKEN(STR_S_RSC), &gEfiSmmRscHandlerProtocolGuid, NULL},\r
2293 {STRING_TOKEN(STR_ACPI_SDT), &gEfiAcpiSdtProtocolGuid, NULL},\r
2294 {STRING_TOKEN(STR_SIO), &gEfiSioProtocolGuid, NULL},\r
2295 {STRING_TOKEN(STR_S_CPU2), &gEfiSmmCpuIo2ProtocolGuid, NULL},\r
2296 {STRING_TOKEN(STR_S_BASE2), &gEfiSmmBase2ProtocolGuid, NULL},\r
2297 {STRING_TOKEN(STR_S_ACC_2), &gEfiSmmAccess2ProtocolGuid, NULL},\r
2298 {STRING_TOKEN(STR_S_CON_2), &gEfiSmmControl2ProtocolGuid, NULL},\r
2299 {STRING_TOKEN(STR_S_CONFIG), &gEfiSmmConfigurationProtocolGuid, NULL},\r
2300 {STRING_TOKEN(STR_S_RTL), &gEfiSmmReadyToLockProtocolGuid, NULL},\r
2301 {STRING_TOKEN(STR_DS_RTL), &gEfiDxeSmmReadyToLockProtocolGuid, NULL},\r
2302 {STRING_TOKEN(STR_S_COMM), &gEfiSmmCommunicationProtocolGuid, NULL},\r
2303 {STRING_TOKEN(STR_S_STAT), &gEfiSmmStatusCodeProtocolGuid, NULL},\r
2304 {STRING_TOKEN(STR_S_CPU), &gEfiSmmCpuProtocolGuid, NULL},\r
62634215 2305 {STRING_TOKEN(STR_S_PCIRBIO), &gEfiSmmPciRootBridgeIoProtocolGuid, NULL},\r
c2788f1c
JC		 2306 {STRING_TOKEN(STR_S_SWD), &gEfiSmmSwDispatch2ProtocolGuid, NULL},\r
2307 {STRING_TOKEN(STR_S_SXD), &gEfiSmmSxDispatch2ProtocolGuid, NULL},\r
2308 {STRING_TOKEN(STR_S_PTD2), &gEfiSmmPeriodicTimerDispatch2ProtocolGuid, NULL},\r
2309 {STRING_TOKEN(STR_S_UD2), &gEfiSmmUsbDispatch2ProtocolGuid, NULL},\r
2310 {STRING_TOKEN(STR_S_GD2), &gEfiSmmGpiDispatch2ProtocolGuid, NULL},\r
2311 {STRING_TOKEN(STR_S_SBD2), &gEfiSmmStandbyButtonDispatch2ProtocolGuid, NULL},\r
2312 {STRING_TOKEN(STR_S_PBD2), &gEfiSmmPowerButtonDispatch2ProtocolGuid, NULL},\r
2313 {STRING_TOKEN(STR_S_ITD2), &gEfiSmmIoTrapDispatch2ProtocolGuid, NULL},\r
2314 {STRING_TOKEN(STR_PCD), &gEfiPcdProtocolGuid, NULL},\r
2315 {STRING_TOKEN(STR_FVB2), &gEfiFirmwareVolumeBlock2ProtocolGuid, NULL},\r
2316 {STRING_TOKEN(STR_CPUIO2), &gEfiCpuIo2ProtocolGuid, NULL},\r
2317 {STRING_TOKEN(STR_LEGACY_R2), &gEfiLegacyRegion2ProtocolGuid, NULL},\r
c2788f1c
JC		 2318 {STRING_TOKEN(STR_S2ARCH), &gEfiSecurity2ArchProtocolGuid, NULL},\r
2319 {STRING_TOKEN(STR_EODXE), &gEfiSmmEndOfDxeProtocolGuid, NULL},\r
2320 {STRING_TOKEN(STR_ISAHC), &gEfiIsaHcProtocolGuid, NULL},\r
2321 {STRING_TOKEN(STR_ISAHC_B), &gEfiIsaHcServiceBindingProtocolGuid, NULL},\r
2322 {STRING_TOKEN(STR_SIO_C), &gEfiSioControlProtocolGuid, NULL},\r
2323 {STRING_TOKEN(STR_GET_PCD), &gEfiGetPcdInfoProtocolGuid, NULL},\r
2324 {STRING_TOKEN(STR_I2C_M), &gEfiI2cMasterProtocolGuid, NULL},\r
2325 {STRING_TOKEN(STR_I2CIO), &gEfiI2cIoProtocolGuid, NULL},\r
2326 {STRING_TOKEN(STR_I2CEN), &gEfiI2cEnumerateProtocolGuid, NULL},\r
2327 {STRING_TOKEN(STR_I2C_H), &gEfiI2cHostProtocolGuid, NULL},\r
2328 {STRING_TOKEN(STR_I2C_BCM), &gEfiI2cBusConfigurationManagementProtocolGuid, NULL},\r
c2788f1c
JC		 2329 {STRING_TOKEN(STR_TCG2), &gEfiTcg2ProtocolGuid, NULL},\r
2330 {STRING_TOKEN(STR_TIMESTAMP), &gEfiTimestampProtocolGuid, NULL},\r
2331 {STRING_TOKEN(STR_RNG), &gEfiRngProtocolGuid, NULL},\r
2332 {STRING_TOKEN(STR_NVMEPT), &gEfiNvmExpressPassThruProtocolGuid, NULL},\r
2333 {STRING_TOKEN(STR_H2_SB), &gEfiHash2ServiceBindingProtocolGuid, NULL},\r
2334 {STRING_TOKEN(STR_HASH2), &gEfiHash2ProtocolGuid, NULL},\r
2335 {STRING_TOKEN(STR_BIO_C), &gEfiBlockIoCryptoProtocolGuid, NULL},\r
2336 {STRING_TOKEN(STR_SCR), &gEfiSmartCardReaderProtocolGuid, NULL},\r
2337 {STRING_TOKEN(STR_SCE), &gEfiSmartCardEdgeProtocolGuid, NULL},\r
2338 {STRING_TOKEN(STR_USB_FIO), &gEfiUsbFunctionIoProtocolGuid, NULL},\r
2339 {STRING_TOKEN(STR_BC_HC), &gEfiBluetoothHcProtocolGuid, NULL},\r
2340 {STRING_TOKEN(STR_BC_IO_SB), &gEfiBluetoothIoServiceBindingProtocolGuid, NULL},\r
2341 {STRING_TOKEN(STR_BC_IO), &gEfiBluetoothIoProtocolGuid, NULL},\r
2342 {STRING_TOKEN(STR_BC_C), &gEfiBluetoothConfigProtocolGuid, NULL},\r
2343 {STRING_TOKEN(STR_REG_EXP), &gEfiRegularExpressionProtocolGuid, NULL},\r
2344 {STRING_TOKEN(STR_B_MGR_P), &gEfiBootManagerPolicyProtocolGuid, NULL},\r
2345 {STRING_TOKEN(STR_CKH), &gEfiConfigKeywordHandlerProtocolGuid, NULL},\r
2346 {STRING_TOKEN(STR_WIFI), &gEfiWiFiProtocolGuid, NULL},\r
2347 {STRING_TOKEN(STR_EAP_M), &gEfiEapManagement2ProtocolGuid, NULL},\r
2348 {STRING_TOKEN(STR_EAP_C), &gEfiEapConfigurationProtocolGuid, NULL},\r
2349 {STRING_TOKEN(STR_PKCS7), &gEfiPkcs7VerifyProtocolGuid, NULL},\r
2350 {STRING_TOKEN(STR_NET_DNS4_SB), &gEfiDns4ServiceBindingProtocolGuid, NULL},\r
2351 {STRING_TOKEN(STR_NET_DNS4), &gEfiDns4ProtocolGuid, NULL},\r
2352 {STRING_TOKEN(STR_NET_DNS6_SB), &gEfiDns6ServiceBindingProtocolGuid, NULL},\r
2353 {STRING_TOKEN(STR_NET_DNS6), &gEfiDns6ProtocolGuid, NULL},\r
2354 {STRING_TOKEN(STR_NET_HTTP_SB), &gEfiHttpServiceBindingProtocolGuid, NULL},\r
2355 {STRING_TOKEN(STR_NET_HTTP), &gEfiHttpProtocolGuid, NULL},\r
2356 {STRING_TOKEN(STR_NET_HTTP_U), &gEfiHttpUtilitiesProtocolGuid, NULL},\r
2357 {STRING_TOKEN(STR_REST), &gEfiRestProtocolGuid, NULL},\r
2358\r
59edea51
HL		 2359//\r
2360// PI 1.5\r
2361//\r
2362 {STRING_TOKEN(STR_MM_EOD), &gEfiMmEndOfDxeProtocolGuid, NULL},\r
2363 {STRING_TOKEN(STR_MM_ITD), &gEfiMmIoTrapDispatchProtocolGuid, NULL},\r
2364 {STRING_TOKEN(STR_MM_PBD), &gEfiMmPowerButtonDispatchProtocolGuid, NULL},\r
2365 {STRING_TOKEN(STR_MM_SBD), &gEfiMmStandbyButtonDispatchProtocolGuid, NULL},\r
2366 {STRING_TOKEN(STR_MM_GD), &gEfiMmGpiDispatchProtocolGuid, NULL},\r
2367 {STRING_TOKEN(STR_MM_UD), &gEfiMmUsbDispatchProtocolGuid, NULL},\r
2368 {STRING_TOKEN(STR_MM_PTD), &gEfiMmPeriodicTimerDispatchProtocolGuid, NULL},\r
2369 {STRING_TOKEN(STR_MM_SXD), &gEfiMmSxDispatchProtocolGuid, NULL},\r
2370 {STRING_TOKEN(STR_MM_SWD), &gEfiMmSwDispatchProtocolGuid, NULL},\r
2371 {STRING_TOKEN(STR_MM_PRBI), &gEfiMmPciRootBridgeIoProtocolGuid, NULL},\r
2372 {STRING_TOKEN(STR_MM_CPU), &gEfiMmCpuProtocolGuid, NULL},\r
2373 {STRING_TOKEN(STR_MM_STACODE), &gEfiMmStatusCodeProtocolGuid, NULL},\r
2374 {STRING_TOKEN(STR_DXEMM_RTL), &gEfiDxeMmReadyToLockProtocolGuid, NULL},\r
2375 {STRING_TOKEN(STR_MM_CONFIG), &gEfiMmConfigurationProtocolGuid, NULL},\r
2376 {STRING_TOKEN(STR_MM_RTL), &gEfiMmReadyToLockProtocolGuid, NULL},\r
2377 {STRING_TOKEN(STR_MM_CONTROL), &gEfiMmControlProtocolGuid, NULL},\r
2378 {STRING_TOKEN(STR_MM_ACCESS), &gEfiMmAccessProtocolGuid, NULL},\r
2379 {STRING_TOKEN(STR_MM_BASE), &gEfiMmBaseProtocolGuid, NULL},\r
2380 {STRING_TOKEN(STR_MM_CPUIO), &gEfiMmCpuIoProtocolGuid, NULL},\r
2381 {STRING_TOKEN(STR_MM_RH), &gEfiMmRscHandlerProtocolGuid, NULL},\r
2382 {STRING_TOKEN(STR_MM_COM), &gEfiMmCommunicationProtocolGuid, NULL},\r
2383\r
0a1eb97d
JC		 2384//\r
2385// UEFI Shell Spec 2.0\r
2386//\r
2387 {STRING_TOKEN(STR_SHELL_PARAMETERS), &gEfiShellParametersProtocolGuid, NULL},\r
2388 {STRING_TOKEN(STR_SHELL), &gEfiShellProtocolGuid, NULL},\r
2389\r
2390//\r
2391// UEFI Shell Spec 2.1\r
2392//\r
2393 {STRING_TOKEN(STR_SHELL_DYNAMIC), &gEfiShellDynamicCommandProtocolGuid, NULL},\r
2394\r
c2788f1c
JC		 2395//\r
2396// Misc\r
2397//\r
2398 {STRING_TOKEN(STR_PCDINFOPROT), &gGetPcdInfoProtocolGuid, NULL},\r
2399\r
dee34318 2400//\r
2401// terminator\r
2402//\r
0e88348e 2403 {0, NULL, NULL},\r
a405b86d 2404};\r
2405\r
2406/**\r
2407 Function to get the node for a protocol or struct from it's GUID.\r
2408\r
2409 if Guid is NULL, then ASSERT.\r
2410\r
2411 @param[in] Guid The GUID to look for the name of.\r
2412\r
2413 @return The node.\r
2414**/\r
dee34318 2415CONST GUID_INFO_BLOCK *\r
a405b86d 2416InternalShellGetNodeFromGuid(\r
2417 IN CONST EFI_GUID* Guid\r
2418 )\r
2419{\r
dee34318 2420 CONST GUID_INFO_BLOCK *ListWalker;\r
6306fd90 2421 UINTN LoopCount;\r
a405b86d 2422\r
2423 ASSERT(Guid != NULL);\r
2424\r
d4ec9a57 2425 for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {\r
6306fd90
JC		 2426 if (CompareGuid(ListWalker->GuidId, Guid)) {\r
2427 return (ListWalker);\r
2428 }\r
2429 }\r
2430\r
a405b86d 2431 if (PcdGetBool(PcdShellIncludeNtGuids)) {\r
2432 for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
2433 if (CompareGuid(ListWalker->GuidId, Guid)) {\r
2434 return (ListWalker);\r
2435 }\r
2436 }\r
2437 }\r
2438 for (ListWalker = mGuidStringList ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
2439 if (CompareGuid(ListWalker->GuidId, Guid)) {\r
2440 return (ListWalker);\r
2441 }\r
2442 }\r
6306fd90
JC		 2443 return (NULL);\r
2444}\r
2445\r
2446/**\r
2447Function to add a new GUID/Name mapping.\r
2448\r
2449@param[in] Guid The Guid\r
f5ba4007
QS		 2450@param[in] NameID The STRING id of the HII string to use\r
2451@param[in] DumpFunc The pointer to the dump function\r
6306fd90
JC		 2452\r
2453\r
2454@retval EFI_SUCCESS The operation was sucessful\r
2455@retval EFI_OUT_OF_RESOURCES A memory allocation failed\r
2456@retval EFI_INVALID_PARAMETER Guid NameId was invalid\r
2457**/\r
6306fd90 2458EFI_STATUS\r
6306fd90
JC		 2459InsertNewGuidNameMapping(\r
2460 IN CONST EFI_GUID *Guid,\r
2461 IN CONST EFI_STRING_ID NameID,\r
2462 IN CONST DUMP_PROTOCOL_INFO DumpFunc OPTIONAL\r
2463 )\r
2464{\r
94d4efb5
ZG		 2465 ASSERT (Guid != NULL);\r
2466 ASSERT (NameID != 0);\r
6306fd90 2467\r
94d4efb5
ZG		 2468 mGuidList = ReallocatePool (\r
2469 mGuidListCount * sizeof (GUID_INFO_BLOCK),\r
2470 (mGuidListCount + 1) * sizeof (GUID_INFO_BLOCK),\r
2471 mGuidList\r
2472 );\r
d4ec9a57
RN		 2473 if (mGuidList == NULL) {\r
2474 mGuidListCount = 0;\r
6306fd90
JC		 2475 return (EFI_OUT_OF_RESOURCES);\r
2476 }\r
d4ec9a57 2477 mGuidListCount++;\r
6306fd90 2478\r
94d4efb5 2479 mGuidList[mGuidListCount - 1].GuidId = AllocateCopyPool (sizeof (EFI_GUID), Guid);\r
d4ec9a57
RN		 2480 mGuidList[mGuidListCount - 1].StringId = NameID;\r
2481 mGuidList[mGuidListCount - 1].DumpInfo = DumpFunc;\r
6306fd90 2482\r
d4ec9a57 2483 if (mGuidList[mGuidListCount - 1].GuidId == NULL) {\r
6306fd90
JC		 2484 return (EFI_OUT_OF_RESOURCES);\r
2485 }\r
2486\r
2487 return (EFI_SUCCESS);\r
2488}\r
2489\r
2490/**\r
2491 Function to add a new GUID/Name mapping.\r
2492\r
2493 This cannot overwrite an existing mapping.\r
2494\r
2495 @param[in] Guid The Guid\r
2496 @param[in] TheName The Guid's name\r
2497 @param[in] Lang RFC4646 language code list or NULL\r
2498\r
2499 @retval EFI_SUCCESS The operation was sucessful\r
2500 @retval EFI_ACCESS_DENIED There was a duplicate\r
2501 @retval EFI_OUT_OF_RESOURCES A memory allocation failed\r
2502 @retval EFI_INVALID_PARAMETER Guid or TheName was NULL\r
2503**/\r
2504EFI_STATUS\r
2505EFIAPI\r
2506AddNewGuidNameMapping(\r
2507 IN CONST EFI_GUID *Guid,\r
2508 IN CONST CHAR16 *TheName,\r
2509 IN CONST CHAR8 *Lang OPTIONAL\r
2510 )\r
2511{\r
6306fd90
JC		 2512 EFI_STRING_ID NameID;\r
2513\r
e7e0e42b
CP		 2514 HandleParsingHiiInit();\r
2515\r
6306fd90
JC		 2516 if (Guid == NULL || TheName == NULL){\r
2517 return (EFI_INVALID_PARAMETER);\r
2518 }\r
2519\r
931b2cff 2520 if ((InternalShellGetNodeFromGuid(Guid)) != NULL) {\r
6306fd90
JC		 2521 return (EFI_ACCESS_DENIED);\r
2522 }\r
2523\r
2524 NameID = HiiSetString(mHandleParsingHiiHandle, 0, (CHAR16*)TheName, Lang);\r
2525 if (NameID == 0) {\r
2526 return (EFI_OUT_OF_RESOURCES);\r
2527 }\r
2528\r
2529 return (InsertNewGuidNameMapping(Guid, NameID, NULL));\r
a405b86d 2530}\r
2531\r
2532/**\r
2533 Function to get the name of a protocol or struct from it's GUID.\r
2534\r
2535 if Guid is NULL, then ASSERT.\r
2536\r
2537 @param[in] Guid The GUID to look for the name of.\r
2538 @param[in] Lang The language to use.\r
2539\r
2540 @return pointer to string of the name. The caller\r
2541 is responsible to free this memory.\r
2542**/\r
2543CHAR16*\r
2544EFIAPI\r
2545GetStringNameFromGuid(\r
2546 IN CONST EFI_GUID *Guid,\r
2547 IN CONST CHAR8 *Lang OPTIONAL\r
2548 )\r
2549{\r
dee34318 2550 CONST GUID_INFO_BLOCK *Id;\r
a405b86d 2551\r
e7e0e42b
CP		 2552 HandleParsingHiiInit();\r
2553\r
a405b86d 2554 Id = InternalShellGetNodeFromGuid(Guid);\r
0e88348e
RN		 2555 if (Id == NULL) {\r
2556 return NULL;\r
2557 }\r
2558 return HiiGetString (mHandleParsingHiiHandle, Id->StringId, Lang);\r
a405b86d 2559}\r
2560\r
2561/**\r
2562 Function to dump protocol information from a handle.\r
2563\r
2564 This function will return a allocated string buffer containing the\r
2565 information. The caller is responsible for freeing the memory.\r
2566\r
2567 If Guid is NULL, ASSERT().\r
2568 If TheHandle is NULL, ASSERT().\r
2569\r
2570 @param[in] TheHandle The handle to dump information from.\r
2571 @param[in] Guid The GUID of the protocol to dump.\r
2572 @param[in] Verbose TRUE for extra info. FALSE otherwise.\r
2573\r
2574 @return The pointer to string.\r
2575 @retval NULL An error was encountered.\r
2576**/\r
2577CHAR16*\r
2578EFIAPI\r
2579GetProtocolInformationDump(\r
2580 IN CONST EFI_HANDLE TheHandle,\r
2581 IN CONST EFI_GUID *Guid,\r
2582 IN CONST BOOLEAN Verbose\r
2583 )\r
2584{\r
dee34318 2585 CONST GUID_INFO_BLOCK *Id;\r
a405b86d 2586\r
2587 ASSERT(TheHandle != NULL);\r
2588 ASSERT(Guid != NULL);\r
2589\r
2590 if (TheHandle == NULL || Guid == NULL) {\r
2591 return (NULL);\r
2592 }\r
2593\r
2594 Id = InternalShellGetNodeFromGuid(Guid);\r
2595 if (Id != NULL && Id->DumpInfo != NULL) {\r
2596 return (Id->DumpInfo(TheHandle, Verbose));\r
2597 }\r
2598 return (NULL);\r
2599}\r
2600\r
2601/**\r
2602 Function to get the Guid for a protocol or struct based on it's string name.\r
2603\r
0a1eb97d
JC		 2604 do not modify the returned Guid.\r
2605\r
a405b86d 2606 @param[in] Name The pointer to the string name.\r
2607 @param[in] Lang The pointer to the language code.\r
0a1eb97d 2608 @param[out] Guid The pointer to the Guid.\r
a405b86d 2609\r
2610 @retval EFI_SUCCESS The operation was sucessful.\r
2611**/\r
2612EFI_STATUS\r
2613EFIAPI\r
2614GetGuidFromStringName(\r
2615 IN CONST CHAR16 *Name,\r
2616 IN CONST CHAR8 *Lang OPTIONAL,\r
0a1eb97d 2617 OUT EFI_GUID **Guid\r
a405b86d 2618 )\r
2619{\r
dee34318 2620 CONST GUID_INFO_BLOCK *ListWalker;\r
a405b86d 2621 CHAR16 *String;\r
6306fd90 2622 UINTN LoopCount;\r
a405b86d 2623\r
e7e0e42b
CP		 2624 HandleParsingHiiInit();\r
2625\r
a405b86d 2626 ASSERT(Guid != NULL);\r
2627 if (Guid == NULL) {\r
2628 return (EFI_INVALID_PARAMETER);\r
2629 }\r
2630 *Guid = NULL;\r
2631\r
2632 if (PcdGetBool(PcdShellIncludeNtGuids)) {\r
2633 for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
2634 String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
28cdb62b 2635 if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
a405b86d 2636 *Guid = ListWalker->GuidId;\r
2637 }\r
2638 SHELL_FREE_NON_NULL(String);\r
2639 if (*Guid != NULL) {\r
2640 return (EFI_SUCCESS);\r
2641 }\r
2642 }\r
2643 }\r
2644 for (ListWalker = mGuidStringList ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {\r
2645 String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
28cdb62b 2646 if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
a405b86d 2647 *Guid = ListWalker->GuidId;\r
2648 }\r
2649 SHELL_FREE_NON_NULL(String);\r
2650 if (*Guid != NULL) {\r
2651 return (EFI_SUCCESS);\r
2652 }\r
2653 }\r
6306fd90 2654\r
d4ec9a57 2655 for (LoopCount = 0, ListWalker = mGuidList; mGuidList != NULL && LoopCount < mGuidListCount; LoopCount++, ListWalker++) {\r
6306fd90
JC		 2656 String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);\r
2657 if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {\r
2658 *Guid = ListWalker->GuidId;\r
2659 }\r
2660 SHELL_FREE_NON_NULL(String);\r
2661 if (*Guid != NULL) {\r
2662 return (EFI_SUCCESS);\r
2663 }\r
2664 }\r
2665\r
a405b86d 2666 return (EFI_NOT_FOUND);\r
2667}\r
2668\r
36384ceb
ED		 2669/**\r
2670 Get best support language for this driver.\r
1a6f74d9
CS		 2671\r
2672 First base on the user input language to search, second base on the current\r
2673 platform used language to search, third get the first language from the\r
a71003f2 2674 support language list. The caller need to free the buffer of the best language.\r
36384ceb
ED		 2675\r
2676 @param[in] SupportedLanguages The support languages for this driver.\r
a71003f2 2677 @param[in] InputLanguage The user input language.\r
36384ceb
ED		 2678 @param[in] Iso639Language Whether get language for ISO639.\r
2679\r
2680 @return The best support language for this driver.\r
2681**/\r
2682CHAR8 *\r
a71003f2 2683EFIAPI\r
36384ceb 2684GetBestLanguageForDriver (\r
a71003f2
ED		 2685 IN CONST CHAR8 *SupportedLanguages,\r
2686 IN CONST CHAR8 *InputLanguage,\r
36384ceb
ED		 2687 IN BOOLEAN Iso639Language\r
2688 )\r
2689{\r
2690 CHAR8 *LanguageVariable;\r
2691 CHAR8 *BestLanguage;\r
2692\r
3cdd434e 2693 GetVariable2 (Iso639Language ? L"Lang" : L"PlatformLang", &gEfiGlobalVariableGuid, (VOID**)&LanguageVariable, NULL);\r
36384ceb
ED		 2694\r
2695 BestLanguage = GetBestLanguage(\r
2696 SupportedLanguages,\r
2697 Iso639Language,\r
a71003f2 2698 (InputLanguage != NULL) ? InputLanguage : "",\r
36384ceb 2699 (LanguageVariable != NULL) ? LanguageVariable : "",\r
a71003f2 2700 SupportedLanguages,\r
36384ceb
ED		 2701 NULL\r
2702 );\r
2703\r
2704 if (LanguageVariable != NULL) {\r
2705 FreePool (LanguageVariable);\r
2706 }\r
2707\r
2708 return BestLanguage;\r
2709}\r
2710\r
a405b86d 2711/**\r
2712 Function to retrieve the driver name (if possible) from the ComponentName or\r
2713 ComponentName2 protocol\r
2714\r
2715 @param[in] TheHandle The driver handle to get the name of.\r
2716 @param[in] Language The language to use.\r
2717\r
2718 @retval NULL The name could not be found.\r
2719 @return A pointer to the string name. Do not de-allocate the memory.\r
2720**/\r
2721CONST CHAR16*\r
2722EFIAPI\r
2723GetStringNameFromHandle(\r
2724 IN CONST EFI_HANDLE TheHandle,\r
2725 IN CONST CHAR8 *Language\r
2726 )\r
2727{\r
2728 EFI_COMPONENT_NAME2_PROTOCOL *CompNameStruct;\r
2729 EFI_STATUS Status;\r
2730 CHAR16 *RetVal;\r
36384ceb
ED		 2731 CHAR8 *BestLang;\r
2732\r
2733 BestLang = NULL;\r
a405b86d 2734\r
2735 Status = gBS->OpenProtocol(\r
2736 TheHandle,\r
2737 &gEfiComponentName2ProtocolGuid,\r
2738 (VOID**)&CompNameStruct,\r
2739 gImageHandle,\r
2740 NULL,\r
2741 EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
2742 if (!EFI_ERROR(Status)) {\r
a71003f2
ED		 2743 BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);\r
2744 Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);\r
36384ceb
ED		 2745 if (BestLang != NULL) {\r
2746 FreePool (BestLang);\r
2747 BestLang = NULL;\r
2748 }\r
a405b86d 2749 if (!EFI_ERROR(Status)) {\r
2750 return (RetVal);\r
2751 }\r
2752 }\r
2753 Status = gBS->OpenProtocol(\r
2754 TheHandle,\r
2755 &gEfiComponentNameProtocolGuid,\r
2756 (VOID**)&CompNameStruct,\r
2757 gImageHandle,\r
2758 NULL,\r
2759 EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
2760 if (!EFI_ERROR(Status)) {\r
a71003f2
ED		 2761 BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);\r
2762 Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);\r
36384ceb
ED		 2763 if (BestLang != NULL) {\r
2764 FreePool (BestLang);\r
2765 }\r
a405b86d 2766 if (!EFI_ERROR(Status)) {\r
2767 return (RetVal);\r
2768 }\r
2769 }\r
2770 return (NULL);\r
2771}\r
2772\r
2773/**\r
2774 Function to initialize the file global mHandleList object for use in\r
2775 vonverting handles to index and index to handle.\r
2776\r
2777 @retval EFI_SUCCESS The operation was successful.\r
2778**/\r
2779EFI_STATUS\r
a405b86d 2780InternalShellInitHandleList(\r
2781 VOID\r
2782 )\r
2783{\r
2784 EFI_STATUS Status;\r
2785 EFI_HANDLE *HandleBuffer;\r
2786 UINTN HandleCount;\r
2787 HANDLE_LIST *ListWalker;\r
2788\r
2789 if (mHandleList.NextIndex != 0) {\r
2790 return EFI_SUCCESS;\r
2791 }\r
2792 InitializeListHead(&mHandleList.List.Link);\r
2793 mHandleList.NextIndex = 1;\r
2794 Status = gBS->LocateHandleBuffer (\r
2795 AllHandles,\r
2796 NULL,\r
2797 NULL,\r
2798 &HandleCount,\r
2799 &HandleBuffer\r
2800 );\r
2801 ASSERT_EFI_ERROR(Status);\r
2802 if (EFI_ERROR(Status)) {\r
2803 return (Status);\r
2804 }\r
2805 for (mHandleList.NextIndex = 1 ; mHandleList.NextIndex <= HandleCount ; mHandleList.NextIndex++){\r
78ed876b 2806 ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r
aa3276c1
RN		 2807 if (ListWalker != NULL) {\r
2808 ListWalker->TheHandle = HandleBuffer[mHandleList.NextIndex - 1];\r
2809 ListWalker->TheIndex = mHandleList.NextIndex;\r
2810 InsertTailList (&mHandleList.List.Link, &ListWalker->Link);\r
2811 }\r
a405b86d 2812 }\r
2813 FreePool(HandleBuffer);\r
2814 return (EFI_SUCCESS);\r
2815}\r
2816\r
2817/**\r
2818 Function to retrieve the human-friendly index of a given handle. If the handle\r
2819 does not have a index one will be automatically assigned. The index value is valid\r
2820 until the termination of the shell application.\r
2821\r
2822 @param[in] TheHandle The handle to retrieve an index for.\r
2823\r
2824 @retval 0 A memory allocation failed.\r
2825 @return The index of the handle.\r
2826\r
2827**/\r
2828UINTN\r
2829EFIAPI\r
2830ConvertHandleToHandleIndex(\r
2831 IN CONST EFI_HANDLE TheHandle\r
2832 )\r
2833{\r
f330ff35 2834 EFI_STATUS Status;\r
2835 EFI_GUID **ProtocolBuffer;\r
2836 UINTN ProtocolCount;\r
2837 HANDLE_LIST *ListWalker;\r
2838\r
78ed876b 2839 if (TheHandle == NULL) {\r
2840 return 0;\r
2841 }\r
a405b86d 2842\r
2843 InternalShellInitHandleList();\r
2844\r
2845 for (ListWalker = (HANDLE_LIST*)GetFirstNode(&mHandleList.List.Link)\r
2846 ; !IsNull(&mHandleList.List.Link,&ListWalker->Link)\r
2847 ; ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)\r
2848 ){\r
2849 if (ListWalker->TheHandle == TheHandle) {\r
f330ff35 2850 //\r
2851 // Verify that TheHandle is still present in the Handle Database\r
2852 //\r
2853 Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);\r
2854 if (EFI_ERROR (Status)) {\r
2855 //\r
2856 // TheHandle is not present in the Handle Database, so delete from the handle list\r
2857 //\r
2858 RemoveEntryList (&ListWalker->Link);\r
2859 return 0;\r
2860 }\r
2861 FreePool (ProtocolBuffer);\r
a405b86d 2862 return (ListWalker->TheIndex);\r
2863 }\r
2864 }\r
f330ff35 2865\r
2866 //\r
2867 // Verify that TheHandle is valid handle\r
2868 //\r
2869 Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);\r
2870 if (EFI_ERROR (Status)) {\r
2871 //\r
2872 // TheHandle is not valid, so do not add to handle list\r
2873 //\r
2874 return 0;\r
2875 }\r
2876 FreePool (ProtocolBuffer);\r
2877\r
78ed876b 2878 ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));\r
aa3276c1
RN		 2879 if (ListWalker == NULL) {\r
2880 return 0;\r
2881 }\r
a405b86d 2882 ListWalker->TheHandle = TheHandle;\r
2883 ListWalker->TheIndex = mHandleList.NextIndex++;\r
2884 InsertTailList(&mHandleList.List.Link,&ListWalker->Link);\r
2885 return (ListWalker->TheIndex);\r
2886}\r
2887\r
2888\r
2889\r
2890/**\r
2891 Function to retrieve the EFI_HANDLE from the human-friendly index.\r
2892\r
2893 @param[in] TheIndex The index to retrieve the EFI_HANDLE for.\r
2894\r
2895 @retval NULL The index was invalid.\r
2896 @return The EFI_HANDLE that index represents.\r
2897\r
2898**/\r
2899EFI_HANDLE\r
2900EFIAPI\r
2901ConvertHandleIndexToHandle(\r
2902 IN CONST UINTN TheIndex\r
2903 )\r
2904{\r
f330ff35 2905 EFI_STATUS Status;\r
2906 EFI_GUID **ProtocolBuffer;\r
2907 UINTN ProtocolCount;\r
a405b86d 2908 HANDLE_LIST *ListWalker;\r
2909\r
2910 InternalShellInitHandleList();\r
2911\r
2912 if (TheIndex >= mHandleList.NextIndex) {\r
f330ff35 2913 return NULL;\r
a405b86d 2914 }\r
2915\r
2916 for (ListWalker = (HANDLE_LIST*)GetFirstNode(&mHandleList.List.Link)\r
2917 ; !IsNull(&mHandleList.List.Link,&ListWalker->Link)\r
2918 ; ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)\r
2919 ){\r
f330ff35 2920 if (ListWalker->TheIndex == TheIndex && ListWalker->TheHandle != NULL) {\r
2921 //\r
2922 // Verify that LinkWalker->TheHandle is valid handle\r
2923 //\r
2924 Status = gBS->ProtocolsPerHandle(ListWalker->TheHandle, &ProtocolBuffer, &ProtocolCount);\r
00324f3f
RN		 2925 if (!EFI_ERROR (Status)) {\r
2926 FreePool (ProtocolBuffer);\r
2927 } else {\r
f330ff35 2928 //\r
2929 // TheHandle is not valid, so do not add to handle list\r
2930 //\r
2931 ListWalker->TheHandle = NULL;\r
2932 }\r
a405b86d 2933 return (ListWalker->TheHandle);\r
2934 }\r
2935 }\r
f330ff35 2936 return NULL;\r
a405b86d 2937}\r
2938\r
2939/**\r
2940 Gets all the related EFI_HANDLEs based on the mask supplied.\r
2941\r
2942 This function scans all EFI_HANDLES in the UEFI environment's handle database\r
2943 and returns the ones with the specified relationship (Mask) to the specified\r
2944 controller handle.\r
2945\r
2946 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.\r
2947 If MatchingHandleCount is NULL, then ASSERT.\r
2948\r
2949 If MatchingHandleBuffer is not NULL upon a successful return the memory must be\r
2950 caller freed.\r
2951\r
2952 @param[in] DriverBindingHandle The handle with Driver Binding protocol on it.\r
2953 @param[in] ControllerHandle The handle with Device Path protocol on it.\r
2954 @param[in] MatchingHandleCount The pointer to UINTN that specifies the number of HANDLES in\r
2955 MatchingHandleBuffer.\r
2956 @param[out] MatchingHandleBuffer On a successful return, a buffer of MatchingHandleCount\r
2957 EFI_HANDLEs with a terminating NULL EFI_HANDLE.\r
2958 @param[out] HandleType An array of type information.\r
2959\r
2960 @retval EFI_SUCCESS The operation was successful, and any related handles\r
2961 are in MatchingHandleBuffer.\r
2962 @retval EFI_NOT_FOUND No matching handles were found.\r
2963 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.\r
2964**/\r
2965EFI_STATUS\r
2966EFIAPI\r
2967ParseHandleDatabaseByRelationshipWithType (\r
2968 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL,\r
2969 IN CONST EFI_HANDLE ControllerHandle OPTIONAL,\r
2970 IN UINTN *HandleCount,\r
2971 OUT EFI_HANDLE **HandleBuffer,\r
2972 OUT UINTN **HandleType\r
2973 )\r
2974{\r
2975 EFI_STATUS Status;\r
2976 UINTN HandleIndex;\r
2977 EFI_GUID **ProtocolGuidArray;\r
2978 UINTN ArrayCount;\r
2979 UINTN ProtocolIndex;\r
2980 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfo;\r
2981 UINTN OpenInfoCount;\r
2982 UINTN OpenInfoIndex;\r
2983 UINTN ChildIndex;\r
f330ff35 2984 INTN DriverBindingHandleIndex;\r
a405b86d 2985\r
2986 ASSERT(HandleCount != NULL);\r
2987 ASSERT(HandleBuffer != NULL);\r
2988 ASSERT(HandleType != NULL);\r
2989 ASSERT(DriverBindingHandle != NULL || ControllerHandle != NULL);\r
2990\r
2991 *HandleCount = 0;\r
2992 *HandleBuffer = NULL;\r
2993 *HandleType = NULL;\r
2994\r
2995 //\r
2996 // Retrieve the list of all handles from the handle database\r
2997 //\r
2998 Status = gBS->LocateHandleBuffer (\r
2999 AllHandles,\r
3000 NULL,\r
3001 NULL,\r
3002 HandleCount,\r
3003 HandleBuffer\r
3004 );\r
3005 if (EFI_ERROR (Status)) {\r
3006 return (Status);\r
3007 }\r
3008\r
3009 *HandleType = AllocateZeroPool (*HandleCount * sizeof (UINTN));\r
aa3276c1
RN		 3010 if (*HandleType == NULL) {\r
3011 SHELL_FREE_NON_NULL (*HandleBuffer);\r
94fcb76b 3012 *HandleCount = 0;\r
aa3276c1
RN		 3013 return EFI_OUT_OF_RESOURCES;\r
3014 }\r
a405b86d 3015\r
f330ff35 3016 DriverBindingHandleIndex = -1;\r
3017 for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {\r
3018 if (DriverBindingHandle != NULL && (*HandleBuffer)[HandleIndex] == DriverBindingHandle) {\r
3019 DriverBindingHandleIndex = (INTN)HandleIndex;\r
3020 }\r
3021 }\r
3022\r
a405b86d 3023 for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {\r
3024 //\r
3025 // Retrieve the list of all the protocols on each handle\r
3026 //\r
3027 Status = gBS->ProtocolsPerHandle (\r
3028 (*HandleBuffer)[HandleIndex],\r
3029 &ProtocolGuidArray,\r
3030 &ArrayCount\r
3031 );\r
f330ff35 3032 if (EFI_ERROR (Status)) {\r
3033 continue;\r
3034 }\r
a405b86d 3035\r
f330ff35 3036 for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {\r
a405b86d 3037\r
f330ff35 3038 //\r
3039 // Set the bit describing what this handle has\r
3040 //\r
3041 if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiLoadedImageProtocolGuid) ) {\r
7aae3c35 3042 (*HandleType)[HandleIndex] |= (UINTN)HR_IMAGE_HANDLE;\r
f330ff35 3043 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverBindingProtocolGuid) ) {\r
7aae3c35 3044 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_BINDING_HANDLE;\r
f330ff35 3045 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfiguration2ProtocolGuid)) {\r
7aae3c35 3046 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;\r
f330ff35 3047 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfigurationProtocolGuid) ) {\r
7aae3c35 3048 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;\r
f330ff35 3049 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnostics2ProtocolGuid) ) {\r
7aae3c35 3050 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;\r
f330ff35 3051 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnosticsProtocolGuid) ) {\r
7aae3c35 3052 (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;\r
f330ff35 3053 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentName2ProtocolGuid) ) {\r
7aae3c35 3054 (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;\r
f330ff35 3055 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentNameProtocolGuid) ) {\r
7aae3c35 3056 (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;\r
f330ff35 3057 } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid) ) {\r
7aae3c35 3058 (*HandleType)[HandleIndex] |= (UINTN)HR_DEVICE_HANDLE;\r
f330ff35 3059 }\r
3060 //\r
3061 // Retrieve the list of agents that have opened each protocol\r
3062 //\r
3063 Status = gBS->OpenProtocolInformation (\r
a405b86d 3064 (*HandleBuffer)[HandleIndex],\r
3065 ProtocolGuidArray[ProtocolIndex],\r
3066 &OpenInfo,\r
3067 &OpenInfoCount\r
3068 );\r
f330ff35 3069 if (EFI_ERROR (Status)) {\r
3070 continue;\r
3071 }\r
3072\r
3073 if (ControllerHandle == NULL) {\r
3074 //\r
1a6f74d9 3075 // ControllerHandle == NULL and DriverBindingHandle != NULL.\r
f330ff35 3076 // Return information on all the controller handles that the driver specified by DriverBindingHandle is managing\r
3077 //\r
3078 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
3079 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
7aae3c35 3080 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
f330ff35 3081 if (DriverBindingHandleIndex != -1) {\r
7aae3c35 3082 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
f330ff35 3083 }\r
3084 }\r
3085 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 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_BUS_DRIVER | HR_DEVICE_DRIVER);\r
f330ff35 3089 }\r
3090 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
3091 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 3092 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
f330ff35 3093 }\r
3094 }\r
3095 }\r
3096 }\r
3097 }\r
3098 if (DriverBindingHandle == NULL && ControllerHandle != NULL) {\r
3099 if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {\r
7aae3c35 3100 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
a405b86d 3101 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
f330ff35 3102 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
3103 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
3104 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 3105 (*HandleType)[ChildIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
f330ff35 3106 }\r
a405b86d 3107 }\r
f330ff35 3108 }\r
3109 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
3110 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
3111 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 3112 (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
f330ff35 3113 }\r
3114 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 3115 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
a405b86d 3116 }\r
3117 }\r
3118 }\r
f330ff35 3119 }\r
3120 } else {\r
3121 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
3122 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
3123 if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {\r
7aae3c35 3124 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
f330ff35 3125 }\r
3126 }\r
3127 }\r
3128 }\r
3129 }\r
3130 if (DriverBindingHandle != NULL && ControllerHandle != NULL) {\r
3131 if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {\r
7aae3c35 3132 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);\r
f330ff35 3133 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
3134 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {\r
3135 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {\r
3136 if (DriverBindingHandleIndex != -1) {\r
7aae3c35 3137 (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;\r
a405b86d 3138 }\r
3139 }\r
f330ff35 3140 }\r
3141 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
3142 if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {\r
a405b86d 3143 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
f330ff35 3144 if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 3145 (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);\r
a405b86d 3146 }\r
3147 }\r
3148 }\r
f330ff35 3149\r
3150 for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {\r
3151 if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {\r
7aae3c35 3152 (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);\r
f330ff35 3153 }\r
3154 }\r
3155 }\r
3156 }\r
3157 } else {\r
3158 for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {\r
3159 if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
3160 if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {\r
7aae3c35 3161 (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);\r
f330ff35 3162 }\r
a405b86d 3163 }\r
3164 }\r
a405b86d 3165 }\r
3166 }\r
f330ff35 3167 FreePool (OpenInfo);\r
a405b86d 3168 }\r
f330ff35 3169 FreePool (ProtocolGuidArray);\r
a405b86d 3170 }\r
f330ff35 3171 return EFI_SUCCESS;\r
a405b86d 3172}\r
3173\r
3174/**\r
3175 Gets all the related EFI_HANDLEs based on the single EFI_HANDLE and the mask\r
3176 supplied.\r
3177\r
3178 This function will scan all EFI_HANDLES in the UEFI environment's handle database\r
3179 and return all the ones with the specified relationship (Mask) to the specified\r
3180 controller handle.\r
3181\r
3182 If both DriverBindingHandle and ControllerHandle are NULL, then ASSERT.\r
3183 If MatchingHandleCount is NULL, then ASSERT.\r
3184\r
3185 If MatchingHandleBuffer is not NULL upon a sucessful return the memory must be\r
3186 caller freed.\r
3187\r
3188 @param[in] DriverBindingHandle Handle to a object with Driver Binding protocol\r
3189 on it.\r
3190 @param[in] ControllerHandle Handle to a device with Device Path protocol on it.\r
3191 @param[in] Mask Mask of what relationship(s) is desired.\r
3192 @param[in] MatchingHandleCount Poitner to UINTN specifying number of HANDLES in\r
3193 MatchingHandleBuffer.\r
3194 @param[out] MatchingHandleBuffer On a sucessful return a buffer of MatchingHandleCount\r
3195 EFI_HANDLEs and a terminating NULL EFI_HANDLE.\r
3196\r
3197 @retval EFI_SUCCESS The operation was sucessful and any related handles\r
3198 are in MatchingHandleBuffer;\r
3199 @retval EFI_NOT_FOUND No matching handles were found.\r
3200 @retval EFI_INVALID_PARAMETER A parameter was invalid or out of range.\r
3201**/\r
3202EFI_STATUS\r
3203EFIAPI\r
3204ParseHandleDatabaseByRelationship (\r
3205 IN CONST EFI_HANDLE DriverBindingHandle OPTIONAL,\r
3206 IN CONST EFI_HANDLE ControllerHandle OPTIONAL,\r
3207 IN CONST UINTN Mask,\r
3208 IN UINTN *MatchingHandleCount,\r
3209 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
3210 )\r
3211{\r
3212 EFI_STATUS Status;\r
3213 UINTN HandleCount;\r
3214 EFI_HANDLE *HandleBuffer;\r
3215 UINTN *HandleType;\r
3216 UINTN HandleIndex;\r
3217\r
3218 ASSERT(MatchingHandleCount != NULL);\r
3219 ASSERT(DriverBindingHandle != NULL || ControllerHandle != NULL);\r
3220\r
3221 if ((Mask & HR_VALID_MASK) != Mask) {\r
3222 return (EFI_INVALID_PARAMETER);\r
3223 }\r
3224\r
3225 if ((Mask & HR_CHILD_HANDLE) != 0 && DriverBindingHandle == NULL) {\r
3226 return (EFI_INVALID_PARAMETER);\r
3227 }\r
3228\r
3229 *MatchingHandleCount = 0;\r
3230 if (MatchingHandleBuffer != NULL) {\r
3231 *MatchingHandleBuffer = NULL;\r
3232 }\r
3233\r
3234 HandleBuffer = NULL;\r
3235 HandleType = NULL;\r
3236\r
3237 Status = ParseHandleDatabaseByRelationshipWithType (\r
3238 DriverBindingHandle,\r
3239 ControllerHandle,\r
3240 &HandleCount,\r
3241 &HandleBuffer,\r
3242 &HandleType\r
3243 );\r
3244 if (!EFI_ERROR (Status)) {\r
3245 //\r
3246 // Count the number of handles that match the attributes in Mask\r
3247 //\r
3248 for (HandleIndex = 0; HandleIndex < HandleCount; HandleIndex++) {\r
3249 if ((HandleType[HandleIndex] & Mask) == Mask) {\r
3250 (*MatchingHandleCount)++;\r
3251 }\r
3252 }\r
3253 //\r
3254 // If no handles match the attributes in Mask then return EFI_NOT_FOUND\r
3255 //\r
3256 if (*MatchingHandleCount == 0) {\r
3257 Status = EFI_NOT_FOUND;\r
3258 } else {\r
3259\r
3260 if (MatchingHandleBuffer == NULL) {\r
3261 //\r
3262 // Someone just wanted the count...\r
3263 //\r
3264 Status = EFI_SUCCESS;\r
3265 } else {\r
3266 //\r
3267 // Allocate a handle buffer for the number of handles that matched the attributes in Mask\r
3268 //\r
78ed876b 3269 *MatchingHandleBuffer = AllocateZeroPool ((*MatchingHandleCount +1)* sizeof (EFI_HANDLE));\r
94fcb76b
RN		 3270 if (*MatchingHandleBuffer == NULL) {\r
3271 Status = EFI_OUT_OF_RESOURCES;\r
3272 } else {\r
aa3276c1
RN		 3273 for (HandleIndex = 0, *MatchingHandleCount = 0\r
3274 ; HandleIndex < HandleCount\r
3275 ; HandleIndex++\r
3276 ) {\r
3277 //\r
3278 // Fill the allocated buffer with the handles that matched the attributes in Mask\r
3279 //\r
3280 if ((HandleType[HandleIndex] & Mask) == Mask) {\r
3281 (*MatchingHandleBuffer)[(*MatchingHandleCount)++] = HandleBuffer[HandleIndex];\r
3282 }\r
3283 }\r
a405b86d 3284\r
a405b86d 3285 //\r
aa3276c1 3286 // Make the last one NULL\r
a405b86d 3287 //\r
aa3276c1 3288 (*MatchingHandleBuffer)[*MatchingHandleCount] = NULL;\r
a405b86d 3289\r
aa3276c1 3290 Status = EFI_SUCCESS;\r
94fcb76b 3291 } // *MatchingHandleBuffer == NULL (ELSE)\r
a405b86d 3292 } // MacthingHandleBuffer == NULL (ELSE)\r
3293 } // *MatchingHandleCount == 0 (ELSE)\r
3294 } // no error on ParseHandleDatabaseByRelationshipWithType\r
3295\r
3296 if (HandleBuffer != NULL) {\r
3297 FreePool (HandleBuffer);\r
3298 }\r
3299\r
3300 if (HandleType != NULL) {\r
3301 FreePool (HandleType);\r
3302 }\r
3303\r
94fcb76b
RN		 3304 ASSERT ((MatchingHandleBuffer == NULL) ||\r
3305 (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||\r
3306 (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL));\r
a405b86d 3307 return Status;\r
3308}\r
3309\r
3310/**\r
3311 Gets handles for any child controllers of the passed in controller.\r
3312\r
3313 @param[in] ControllerHandle The handle of the "parent controller"\r
b6c54204 3314 @param[out] MatchingHandleCount Pointer to the number of handles in\r
a405b86d 3315 MatchingHandleBuffer on return.\r
3316 @param[out] MatchingHandleBuffer Buffer containing handles on a successful\r
3317 return.\r
3318\r
3319\r
3320 @retval EFI_SUCCESS The operation was sucessful.\r
3321**/\r
3322EFI_STATUS\r
3323EFIAPI\r
3324ParseHandleDatabaseForChildControllers(\r
3325 IN CONST EFI_HANDLE ControllerHandle,\r
b6c54204 3326 OUT UINTN *MatchingHandleCount,\r
a405b86d 3327 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
3328 )\r
3329{\r
3330 EFI_STATUS Status;\r
f330ff35 3331 UINTN HandleIndex;\r
a405b86d 3332 UINTN DriverBindingHandleCount;\r
3333 EFI_HANDLE *DriverBindingHandleBuffer;\r
3334 UINTN DriverBindingHandleIndex;\r
3335 UINTN ChildControllerHandleCount;\r
3336 EFI_HANDLE *ChildControllerHandleBuffer;\r
3337 UINTN ChildControllerHandleIndex;\r
a405b86d 3338 EFI_HANDLE *HandleBufferForReturn;\r
3339\r
ff51746b 3340 if (MatchingHandleCount == NULL) {\r
3341 return (EFI_INVALID_PARAMETER);\r
3342 }\r
64d753f1 3343 *MatchingHandleCount = 0;\r
a405b86d 3344\r
3345 Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (\r
3346 ControllerHandle,\r
3347 &DriverBindingHandleCount,\r
3348 &DriverBindingHandleBuffer\r
3349 );\r
3350 if (EFI_ERROR (Status)) {\r
3351 return Status;\r
3352 }\r
3353\r
ff51746b 3354 //\r
3355 // Get a buffer big enough for all the controllers.\r
3356 //\r
f330ff35 3357 HandleBufferForReturn = GetHandleListByProtocol(NULL);\r
a405b86d 3358 if (HandleBufferForReturn == NULL) {\r
3359 FreePool (DriverBindingHandleBuffer);\r
ff51746b 3360 return (EFI_NOT_FOUND);\r
a405b86d 3361 }\r
3362\r
a405b86d 3363 for (DriverBindingHandleIndex = 0; DriverBindingHandleIndex < DriverBindingHandleCount; DriverBindingHandleIndex++) {\r
3364 Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (\r
3365 DriverBindingHandleBuffer[DriverBindingHandleIndex],\r
3366 ControllerHandle,\r
3367 &ChildControllerHandleCount,\r
3368 &ChildControllerHandleBuffer\r
3369 );\r
3370 if (EFI_ERROR (Status)) {\r
3371 continue;\r
3372 }\r
3373\r
3374 for (ChildControllerHandleIndex = 0;\r
3375 ChildControllerHandleIndex < ChildControllerHandleCount;\r
3376 ChildControllerHandleIndex++\r
3377 ) {\r
f330ff35 3378 for (HandleIndex = 0; HandleIndex < *MatchingHandleCount; HandleIndex++) {\r
3379 if (HandleBufferForReturn[HandleIndex] == ChildControllerHandleBuffer[ChildControllerHandleIndex]) {\r
3380 break;\r
3381 }\r
3382 }\r
3383 if (HandleIndex >= *MatchingHandleCount) {\r
3384 HandleBufferForReturn[(*MatchingHandleCount)++] = ChildControllerHandleBuffer[ChildControllerHandleIndex];\r
3385 }\r
a405b86d 3386 }\r
3387\r
3388 FreePool (ChildControllerHandleBuffer);\r
3389 }\r
3390\r
3391 FreePool (DriverBindingHandleBuffer);\r
3392\r
7eb3bb6c
LE		 3393 if (MatchingHandleBuffer == NULL || *MatchingHandleCount == 0) {\r
3394 //\r
3395 // The caller is not interested in the actual handles, or we've found none.\r
3396 //\r
3397 FreePool (HandleBufferForReturn);\r
3398 HandleBufferForReturn = NULL;\r
3399 }\r
3400\r
a405b86d 3401 if (MatchingHandleBuffer != NULL) {\r
3402 *MatchingHandleBuffer = HandleBufferForReturn;\r
a405b86d 3403 }\r
7eb3bb6c 3404\r
94fcb76b
RN		 3405 ASSERT ((MatchingHandleBuffer == NULL) ||\r
3406 (*MatchingHandleCount == 0 && *MatchingHandleBuffer == NULL) ||\r
3407 (*MatchingHandleCount != 0 && *MatchingHandleBuffer != NULL));\r
a405b86d 3408\r
3409 return (EFI_SUCCESS);\r
3410}\r
3411\r
3412/**\r
3413 Appends 1 buffer to another buffer. This will re-allocate the destination buffer\r
3414 if necessary to fit all of the data.\r
3415\r
3416 If DestinationBuffer is NULL, then ASSERT().\r
3417\r
4ff7e37b
ED		 3418 @param[in, out] DestinationBuffer The pointer to the pointer to the buffer to append onto.\r
3419 @param[in, out] DestinationSize The pointer to the size of DestinationBuffer.\r
3420 @param[in] SourceBuffer The pointer to the buffer to append onto DestinationBuffer.\r
3421 @param[in] SourceSize The number of bytes of SourceBuffer to append.\r
a405b86d 3422\r
3423 @retval NULL A memory allocation failed.\r
3424 @retval NULL A parameter was invalid.\r
3425 @return A pointer to (*DestinationBuffer).\r
3426**/\r
3427VOID*\r
a405b86d 3428BuffernCatGrow (\r
3429 IN OUT VOID **DestinationBuffer,\r
3430 IN OUT UINTN *DestinationSize,\r
3431 IN VOID *SourceBuffer,\r
3432 IN UINTN SourceSize\r
3433 )\r
3434{\r
3435 UINTN LocalDestinationSize;\r
3436 UINTN LocalDestinationFinalSize;\r
3437\r
3438 ASSERT(DestinationBuffer != NULL);\r
3439\r
3440 if (SourceSize == 0 || SourceBuffer == NULL) {\r
3441 return (*DestinationBuffer);\r
3442 }\r
3443\r
3444 if (DestinationSize == NULL) {\r
3445 LocalDestinationSize = 0;\r
3446 } else {\r
3447 LocalDestinationSize = *DestinationSize;\r
3448 }\r
3449\r
3450 LocalDestinationFinalSize = LocalDestinationSize + SourceSize;\r
3451\r
3452 if (DestinationSize != NULL) {\r
3453 *DestinationSize = LocalDestinationSize;\r
3454 }\r
3455\r
3456 if (LocalDestinationSize == 0) {\r
3457 // allcoate\r
78ed876b 3458 *DestinationBuffer = AllocateZeroPool(LocalDestinationFinalSize);\r
a405b86d 3459 } else {\r
3460 // reallocate\r
3461 *DestinationBuffer = ReallocatePool(LocalDestinationSize, LocalDestinationFinalSize, *DestinationBuffer);\r
3462 }\r
3463\r
3464 ASSERT(*DestinationBuffer != NULL);\r
3465\r
3466 // copy\r
3467 return (CopyMem(((UINT8*)(*DestinationBuffer)) + LocalDestinationSize, SourceBuffer, SourceSize));\r
3468}\r
3469\r
3470/**\r
3471 Gets handles for any child devices produced by the passed in driver.\r
3472\r
3473 @param[in] DriverHandle The handle of the driver.\r
3474 @param[in] MatchingHandleCount Pointer to the number of handles in\r
3475 MatchingHandleBuffer on return.\r
3476 @param[out] MatchingHandleBuffer Buffer containing handles on a successful\r
3477 return.\r
3478 @retval EFI_SUCCESS The operation was sucessful.\r
3479 @sa ParseHandleDatabaseByRelationship\r
3480**/\r
3481EFI_STATUS\r
3482EFIAPI\r
3483ParseHandleDatabaseForChildDevices(\r
3484 IN CONST EFI_HANDLE DriverHandle,\r
3485 IN UINTN *MatchingHandleCount,\r
3486 OUT EFI_HANDLE **MatchingHandleBuffer OPTIONAL\r
3487 )\r
3488{\r
3489 EFI_HANDLE *Buffer;\r
3490 EFI_HANDLE *Buffer2;\r
3491 UINTN Count1;\r
3492 UINTN Count2;\r
3493 UINTN HandleIndex;\r
3494 EFI_STATUS Status;\r
3495 UINTN HandleBufferSize;\r
3496\r
3497 ASSERT(MatchingHandleCount != NULL);\r
3498\r
3499 HandleBufferSize = 0;\r
3500 Buffer = NULL;\r
3501 Buffer2 = NULL;\r
3502 *MatchingHandleCount = 0;\r
3503\r
3504 Status = PARSE_HANDLE_DATABASE_DEVICES (\r
3505 DriverHandle,\r
3506 &Count1,\r
3507 &Buffer\r
3508 );\r
3509 if (!EFI_ERROR (Status)) {\r
3510 for (HandleIndex = 0; HandleIndex < Count1; HandleIndex++) {\r
3511 //\r
3512 // now find the children\r
3513 //\r
3514 Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (\r
3515 DriverHandle,\r
3516 Buffer[HandleIndex],\r
3517 &Count2,\r
3518 &Buffer2\r
3519 );\r
3520 if (EFI_ERROR(Status)) {\r
3521 break;\r
3522 }\r
3523 //\r
3524 // save out required and optional data elements\r
3525 //\r
3526 *MatchingHandleCount += Count2;\r
3527 if (MatchingHandleBuffer != NULL) {\r
3528 *MatchingHandleBuffer = BuffernCatGrow((VOID**)MatchingHandleBuffer, &HandleBufferSize, Buffer2, Count2 * sizeof(Buffer2[0]));\r
3529 }\r
3530\r
3531 //\r
3532 // free the memory\r
3533 //\r
3534 if (Buffer2 != NULL) {\r
3535 FreePool(Buffer2);\r
3536 }\r
3537 }\r
3538 }\r
3539\r
3540 if (Buffer != NULL) {\r
3541 FreePool(Buffer);\r
3542 }\r
3543 return (Status);\r
3544}\r
3545\r
3546/**\r
3547 Function to get all handles that support a given protocol or all handles.\r
3548\r
3549 @param[in] ProtocolGuid The guid of the protocol to get handles for. If NULL\r
3550 then the function will return all handles.\r
3551\r
3552 @retval NULL A memory allocation failed.\r
3553 @return A NULL terminated list of handles.\r
3554**/\r
3555EFI_HANDLE*\r
3556EFIAPI\r
40d7a9cf 3557GetHandleListByProtocol (\r
a405b86d 3558 IN CONST EFI_GUID *ProtocolGuid OPTIONAL\r
3559 )\r
3560{\r
3561 EFI_HANDLE *HandleList;\r
3562 UINTN Size;\r
3563 EFI_STATUS Status;\r
3564\r
3565 Size = 0;\r
3566 HandleList = NULL;\r
3567\r
3568 //\r
3569 // We cannot use LocateHandleBuffer since we need that NULL item on the ends of the list!\r
3570 //\r
3571 if (ProtocolGuid == NULL) {\r
3572 Status = gBS->LocateHandle(AllHandles, NULL, NULL, &Size, HandleList);\r
3573 if (Status == EFI_BUFFER_TOO_SMALL) {\r
78ed876b 3574 HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));\r
40d7a9cf 3575 if (HandleList == NULL) {\r
3576 return (NULL);\r
3577 }\r
a405b86d 3578 Status = gBS->LocateHandle(AllHandles, NULL, NULL, &Size, HandleList);\r
3579 HandleList[Size/sizeof(EFI_HANDLE)] = NULL;\r
3580 }\r
3581 } else {\r
3582 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)ProtocolGuid, NULL, &Size, HandleList);\r
3583 if (Status == EFI_BUFFER_TOO_SMALL) {\r
78ed876b 3584 HandleList = AllocateZeroPool(Size + sizeof(EFI_HANDLE));\r
40d7a9cf 3585 if (HandleList == NULL) {\r
3586 return (NULL);\r
3587 }\r
a405b86d 3588 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)ProtocolGuid, NULL, &Size, HandleList);\r
3589 HandleList[Size/sizeof(EFI_HANDLE)] = NULL;\r
3590 }\r
3591 }\r
3592 if (EFI_ERROR(Status)) {\r
3593 if (HandleList != NULL) {\r
3594 FreePool(HandleList);\r
3595 }\r
3596 return (NULL);\r
3597 }\r
3598 return (HandleList);\r
3599}\r
3600\r
3601/**\r
3602 Function to get all handles that support some protocols.\r
3603\r
3604 @param[in] ProtocolGuids A NULL terminated list of protocol GUIDs.\r
3605\r
3606 @retval NULL A memory allocation failed.\r
ff51746b 3607 @retval NULL ProtocolGuids was NULL.\r
3608 @return A NULL terminated list of EFI_HANDLEs.\r
a405b86d 3609**/\r
3610EFI_HANDLE*\r
3611EFIAPI\r
40d7a9cf 3612GetHandleListByProtocolList (\r
a405b86d 3613 IN CONST EFI_GUID **ProtocolGuids\r
3614 )\r
3615{\r
3616 EFI_HANDLE *HandleList;\r
3617 UINTN Size;\r
3618 UINTN TotalSize;\r
40d7a9cf 3619 UINTN TempSize;\r
a405b86d 3620 EFI_STATUS Status;\r
3621 CONST EFI_GUID **GuidWalker;\r
3622 EFI_HANDLE *HandleWalker1;\r
3623 EFI_HANDLE *HandleWalker2;\r
3624\r
3625 Size = 0;\r
3626 HandleList = NULL;\r
3627 TotalSize = sizeof(EFI_HANDLE);\r
3628\r
3629 for (GuidWalker = ProtocolGuids ; GuidWalker != NULL && *GuidWalker != NULL ; GuidWalker++,Size = 0){\r
3630 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &Size, NULL);\r
3631 if (Status == EFI_BUFFER_TOO_SMALL) {\r
3632 TotalSize += Size;\r
3633 }\r
3634 }\r
40d7a9cf 3635\r
3636 //\r
e918029f 3637 // No handles were found...\r
40d7a9cf 3638 //\r
3639 if (TotalSize == sizeof(EFI_HANDLE)) {\r
3640 return (NULL);\r
3641 }\r
3642\r
3643 HandleList = AllocateZeroPool(TotalSize);\r
a405b86d 3644 if (HandleList == NULL) {\r
3645 return (NULL);\r
3646 }\r
3647\r
3648 Size = 0;\r
3649 for (GuidWalker = ProtocolGuids ; GuidWalker != NULL && *GuidWalker != NULL ; GuidWalker++){\r
40d7a9cf 3650 TempSize = TotalSize - Size;\r
ff51746b 3651 Status = gBS->LocateHandle(ByProtocol, (EFI_GUID*)(*GuidWalker), NULL, &TempSize, HandleList+(Size/sizeof(EFI_HANDLE)));\r
40d7a9cf 3652\r
3653 //\r
3654 // Allow for missing protocols... Only update the 'used' size upon success.\r
3655 //\r
3656 if (!EFI_ERROR(Status)) {\r
ff51746b 3657 Size += TempSize;\r
40d7a9cf 3658 }\r
a405b86d 3659 }\r
ff51746b 3660 ASSERT(HandleList[(TotalSize/sizeof(EFI_HANDLE))-1] == NULL);\r
a405b86d 3661\r
3662 for (HandleWalker1 = HandleList ; HandleWalker1 != NULL && *HandleWalker1 != NULL ; HandleWalker1++) {\r
3663 for (HandleWalker2 = HandleWalker1 + 1; HandleWalker2 != NULL && *HandleWalker2 != NULL ; HandleWalker2++) {\r
3664 if (*HandleWalker1 == *HandleWalker2) {\r
3665 //\r
3666 // copy memory back 1 handle width.\r
3667 //\r
3668 CopyMem(HandleWalker2, HandleWalker2 + 1, TotalSize - ((HandleWalker2-HandleList+1)*sizeof(EFI_HANDLE)));\r
3669 }\r
3670 }\r
3671 }\r
3672\r
3673 return (HandleList);\r
3674}\r
0976f908
CC		 3675\r
3676/**\r
3677 Return all supported GUIDs.\r
3678\r
3679 @param[out] Guids The buffer to return all supported GUIDs.\r
3680 @param[in, out] Count On input, the count of GUIDs the buffer can hold,\r
3681 On output, the count of GUIDs to return.\r
3682\r
3683 @retval EFI_INVALID_PARAMETER Count is NULL.\r
3684 @retval EFI_BUFFER_TOO_SMALL Buffer is not enough to hold all GUIDs.\r
3685 @retval EFI_SUCCESS GUIDs are returned successfully.\r
3686**/\r
3687EFI_STATUS\r
3688EFIAPI\r
3689GetAllMappingGuids (\r
3690 OUT EFI_GUID *Guids,\r
3691 IN OUT UINTN *Count\r
3692 )\r
3693{\r
3694 UINTN GuidCount;\r
7c14bc87 3695 UINTN NtGuidCount;\r
0976f908
CC		 3696 UINTN Index;\r
3697\r
3698 if (Count == NULL) {\r
3699 return EFI_INVALID_PARAMETER;\r
3700 }\r
3701\r
3702 NtGuidCount = 0;\r
3703 if (PcdGetBool (PcdShellIncludeNtGuids)) {\r
3704 NtGuidCount = ARRAY_SIZE (mGuidStringListNT) - 1;\r
3705 }\r
3706 GuidCount = ARRAY_SIZE (mGuidStringList) - 1;\r
3707\r
3708 if (*Count < NtGuidCount + GuidCount + mGuidListCount) {\r
3709 *Count = NtGuidCount + GuidCount + mGuidListCount;\r
3710 return EFI_BUFFER_TOO_SMALL;\r
3711 }\r
3712\r
3713 for (Index = 0; Index < NtGuidCount; Index++) {\r
3714 CopyGuid (&Guids[Index], mGuidStringListNT[Index].GuidId);\r
3715 }\r
3716\r
3717 for (Index = 0; Index < GuidCount; Index++) {\r
3718 CopyGuid (&Guids[NtGuidCount + Index], mGuidStringList[Index].GuidId);\r
3719 }\r
3720\r
3721 for (Index = 0; Index < mGuidListCount; Index++) {\r
3722 CopyGuid (&Guids[NtGuidCount + GuidCount + Index], mGuidList[Index].GuidId);\r
3723 }\r
3724\r
3725 return EFI_SUCCESS;\r
3726}\r
EFI Development Kit II mirror for PVE