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